/*
    Licensed to the Apache Software Foundation (ASF) under one
    or more contributor license agreements.  See the NOTICE file
    distributed with this work for additional information
    regarding copyright ownership.  The ASF licenses this file
    to you under the Apache License, Version 2.0 (the
    "License"); you may not use this file except in compliance
    with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing,
    software distributed under the License is distributed on an
    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, either express or implied.  See the License for the
    specific language governing permissions and limitations
    under the License.
*/
/**
 * @file test_ecc_ZZZ.c
 * @author Kealan McCusker
 * @brief Test function for ECC
 *
 */

/* test driver and function exerciser for ECDH/ECIES/ECDSA API Functions */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "ecdh_ZZZ.h"
#include "randapi.h"

//#define DEBUG

int main()
{
    int i,j=0,res;
    unsigned long ran;
    char pp[]="M0ng00se";
    /* These octets are automatically protected against buffer overflow attacks */
    /* Note salt must be big enough to include an appended word */
    /* Note ECIES ciphertext C must be big enough to include at least 1 appended block */
    /* Recall EFS_ZZZ is field size in bytes. So EFS_ZZZ=32 for 256-bit curve */
    char s0[EGS_ZZZ],s1[EGS_ZZZ],w0[2*EFS_ZZZ+1],w1[2*EFS_ZZZ+1],z0[EFS_ZZZ],z1[EFS_ZZZ],raw[100],key[AESKEY_ZZZ],salt[32],pw[20];
#if CURVETYPE_ZZZ != MONTGOMERY
    char ds[EGS_ZZZ],p1[32],p2[32],v[2*EFS_ZZZ+1],m[32],plm[32],c[64],t[32],cs[EGS_ZZZ];
#endif

    octet S0= {0,sizeof(s0),s0};
    octet S1= {0,sizeof(s1),s1};
    octet W0= {0,sizeof(w0),w0};
    octet W1= {0,sizeof(w1),w1};
    octet Z0= {0,sizeof(z0),z0};
    octet Z1= {0,sizeof(z1),z1};
    octet RAW= {0,sizeof(raw),raw};
    octet KEY= {0,sizeof(key),key};
    octet SALT= {0,sizeof(salt),salt};
    octet PW= {0,sizeof(pw),pw};
#if CURVETYPE_ZZZ != MONTGOMERY
    octet DS= {0,sizeof(ds),ds};
    octet CS= {0,sizeof(cs),cs};
    octet P1= {0,sizeof(p1),p1};
    octet P2= {0,sizeof(p2),p2};
    octet V= {0,sizeof(v),v};
    octet M= {0,sizeof(m),m};
    octet PlM= {0,sizeof(plm),plm};
    octet C= {0,sizeof(c),c};
    octet T= {0,sizeof(t),t};
#endif

// Initialize radom number generator with fake random seed source
    csprng RNG;
    time((time_t *)&ran);

    RAW.len=100;
    RAW.val[0]=ran;
    RAW.val[1]=ran>>8;
    RAW.val[2]=ran>>16;
    RAW.val[3]=ran>>24;
    for (i=0; i<100; i++) RAW.val[i]=i;

    CREATE_CSPRNG(&RNG,&RAW);

// Set salt
    for (j=0; j<100; j++)
    {
        SALT.len=8;
        for (i=0; i<8; i++) SALT.val[i]=i+1;

// Copy Passhrase
#ifdef DEBUG
        printf("Alice's Passphrase= %s\n",pp);
#endif
        OCT_empty(&PW);
        OCT_jstring(&PW,pp);   // set Password from string

// Derive private key S0 of size EGS_ZZZ bytes from Password and Salt
        PBKDF2(HASH_TYPE_ZZZ,&PW,&SALT,1000,EGS_ZZZ,&S0);
#ifdef DEBUG
        printf("Alices private key= 0x");
        OCT_output(&S0);
#endif

// Generate Key pair S/W
        ECP_ZZZ_KEY_PAIR_GENERATE(NULL,&S0,&W0);
#ifdef DEBUG
        printf("Alices public key= 0x");
        OCT_output(&W0);
#endif
        res=ECP_ZZZ_PUBLIC_KEY_VALIDATE(&W0);
        if (res!=0)
        {
            printf("ECP Public Key is invalid!\n");
            exit(1);
        }

// Random private key for other party
        ECP_ZZZ_KEY_PAIR_GENERATE(&RNG,&S1,&W1);
        res=ECP_ZZZ_PUBLIC_KEY_VALIDATE(&W1);
        if (res!=0)
        {
            printf("ECP Public Key is invalid!\n");
            exit(1);
        }
#ifdef DEBUG
        printf("Servers private key= 0x");
        OCT_output(&S1);
        printf("Servers public key= 0x");
        OCT_output(&W1);
#endif

// Calculate common key using DH - IEEE 1363 method
        ECP_ZZZ_SVDP_DH(&S0,&W1,&Z0);
        ECP_ZZZ_SVDP_DH(&S1,&W0,&Z1);
        if (!OCT_comp(&Z0,&Z1))
        {
            printf("ECPSVDP-DH Failed\n");
            exit(1);
        }

        KDF2(HASH_TYPE_ZZZ,&Z0,NULL,AESKEY_ZZZ,&KEY);
#ifdef DEBUG
        printf("Alice's DH Key=  0x");
        OCT_output(&KEY);
        printf("Servers DH Key=  0x");
        OCT_output(&KEY);
#endif

#if CURVETYPE_ZZZ != MONTGOMERY
#ifdef DEBUG
        printf("Testing ECIES\n");
#endif
// Generate parameters and message randomly
        OCT_rand(&P1,&RNG,P1.len);
        OCT_rand(&P2,&RNG,P2.len);
        OCT_rand(&M,&RNG,M.len);

// ECIES ecncryption
        ECP_ZZZ_ECIES_ENCRYPT(HASH_TYPE_ZZZ,&P1,&P2,&RNG,&W1,&M,12,&V,&C,&T);
#ifdef DEBUG
        printf("Ciphertext= \n");
        printf("V= 0x");
        OCT_output(&V);
        printf("C= 0x");
        OCT_output(&C);
        printf("T= 0x");
        OCT_output(&T);
#endif
        OCT_copy(&PlM,&M);

// ECIES decryption
        if (!ECP_ZZZ_ECIES_DECRYPT(HASH_TYPE_ZZZ,&P1,&P2,&V,&C,&T,&S1,&M))
        {
            printf("ECIES Decryption Failed\n");
            exit(1);
        }
#ifdef DEBUG
        else
        {
            printf("ECIES Decryption Succeeded\n");
        }
#endif

// Compare intial message with the decripted one
        if(!OCT_comp(&PlM,&M))
        {
            printf("ECIES Decryption Failed\n");
            exit(1);
        }
#ifdef DEBUG
        printf("Message is 0x");
        OCT_output(&M);

        printf("Testing ECDSA\n");
#endif

// Sign with ECDSA
        if (ECP_ZZZ_SP_DSA(HASH_TYPE_ZZZ,&RNG,NULL,&S0,&M,&CS,&DS)!=0)
        {
            printf("ECDSA Signature Failed\n");
            exit(1);
        }
#ifdef DEBUG
        printf("Signature C = 0x");
        OCT_output(&CS);
        printf("Signature D = 0x");
        OCT_output(&DS);
#endif

// Verify ECDSA signature
        if (ECP_ZZZ_VP_DSA(HASH_TYPE_ZZZ,&W0,&M,&CS,&DS)!=0)
        {
            printf("ECDSA Verification Failed\n");
            exit(1);
        }
#ifdef DEBUG
        else
        {
            printf("ECDSA Signature/Verification succeeded %d\n",j);
        }
#endif

#endif
    }

    KILL_CSPRNG(&RNG);

    printf("SUCCESS\n");
    return 0;
}