test/test_ecp_arithmetics_ZZZ.c.in

/*
    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_ecp_arithmetics_ZZZ.c
 * @author Alessandro Budroni
 * @brief Test for aritmetics with ECP_ZZZ
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "arch.h"
#include "amcl.h"
#include "utils.h"
#include "ecp_ZZZ.h"

#define LINE_LEN 1000
#define MAX_STRING 400
#define PIN 1234

void read_BIG_XXX(BIG_XXX A, char* string)
{
    int len;
    char support[LINE_LEN];
    BIG_XXX_zero(A);
    len = strlen(string)+1;
    amcl_hex2bin(string,support,len);
    len = (len-1)/2;;
    BIG_XXX_fromBytesLen(A,support,len);
    BIG_XXX_norm(A);
}

int read_ECP_ZZZ(ECP_ZZZ *ecp, char* string)
{
    BIG_XXX x;
#if CURVETYPE_ZZZ!=MONTGOMERY
    BIG_XXX y;
#endif
    char *stringy = strchr(string,':');
    stringy[0] = '\0';
    read_BIG_XXX(x,string);
#if CURVETYPE_ZZZ==MONTGOMERY
    return ECP_ZZZ_set(ecp,x);
#else
    stringy++;
    read_BIG_XXX(y,stringy);
    return ECP_ZZZ_set(ecp,x,y);
#endif
}

int main(int argc, char** argv)
{
    if (argc != 2)
    {
        printf("usage: ./test_ecp_arithmetics_ZZZ [path to test vector file]\n");
        exit(EXIT_FAILURE);
    }

    int i=0, len=0;

    char line[LINE_LEN];
    char * linePtr = NULL;

    ECP_ZZZ inf, ECPaux1;
    BIG_XXX BIGaux1;

    char oct[LINE_LEN];
    octet OCTaux = {0,sizeof(oct),oct};
#if CURVETYPE_ZZZ!=MONTGOMERY
    BIG_XXX BIGaux2;
    FP_YYY FPaux1,FPaux2;
    ECP_ZZZ ECPaux2;
#endif
    ECP_ZZZ ecp1;
    const char* ECP1line = "ECP1 = ";
#if CURVETYPE_ZZZ!=MONTGOMERY
    ECP_ZZZ ecp2;
    const char* ECP2line = "ECP2 = ";
    ECP_ZZZ ecpsum;
    const char* ECPsumline = "ECPsum = ";
    ECP_ZZZ ecpneg;
    const char* ECPnegline = "ECPneg = ";
    ECP_ZZZ ecpsub;
    const char* ECPsubline = "ECPsub = ";
#endif
    ECP_ZZZ ecpdbl;
    const char* ECPdblline = "ECPdbl = ";
    BIG_XXX BIGscalar1;
    const char* BIGscalar1line = "BIGscalar1 = ";
    ECP_ZZZ ecpmul;
    const char* ECPmulline = "ECPmul = ";
    ECP_ZZZ ecpwrong;
    const char* ECPwrongline = "ECPwrong = ";
    ECP_ZZZ ecpinf;
    const char* ECPinfline = "ECPinf = ";
#if CURVETYPE_ZZZ!=MONTGOMERY
    ECP_ZZZ ecppinmul;
    const char* ECPpinmulline = "ECPpinmul = ";
    BIG_XXX BIGscalar2;
    const char* BIGscalar2line = "BIGscalar2 = ";
    ECP_ZZZ ecpmul2;
    const char* ECPmul2line = "ECPmul2 = ";
    ECP_ZZZ ecpeven;
    const char* ECPevenline = "ECPeven = ";
    ECP_ZZZ ecpodd;
    const char* ECPoddline = "ECPodd = ";
#endif
#if CURVETYPE_ZZZ==MONTGOMERY
    ECP_ZZZ ecpmul3;
    const char* ECPmul3line = "ECPmul3 = ";
#endif

    ECP_ZZZ_inf(&inf);

    if(!ECP_ZZZ_isinf(&inf))
    {
        printf("ERROR setting ECP_ZZZ to infinity\n");
        exit(EXIT_FAILURE);
    }

    FILE *fp;
    fp = fopen(argv[1],"r");
    if (fp == NULL)
    {
        printf("ERROR opening test vector file\n");
        exit(EXIT_FAILURE);
    }

    while (fgets(line, LINE_LEN, fp) != NULL)
    {
        i++;
        if (!strncmp(line,  ECP1line, strlen(ECP1line))) // get first test vector
        {
            len = strlen(ECP1line);
            linePtr = line + len;
            if(!read_ECP_ZZZ(&ecp1,linePtr) || ECP_ZZZ_isinf(&ecp1))
            {
                printf("ERROR getting test vector input ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
#if CURVETYPE_ZZZ!=MONTGOMERY
            ECP_ZZZ_get(BIGaux1,BIGaux2,&ecp1);
            FP_YYY_nres(&FPaux1,BIGaux1);
            FP_YYY_nres(&FPaux2,BIGaux2);
            FP_YYY_sqr(&FPaux2,&FPaux2);
            ECP_ZZZ_rhs(&FPaux1,&FPaux1);
            FP_YYY_reduce(&FPaux1); // in case of lazy reduction
            FP_YYY_reduce(&FPaux2); // in case of lazy reduction
            if (!FP_YYY_equals(&FPaux1,&FPaux2)) // test if y^2=f(x)
            {
                printf("ERROR computing right hand side of equation ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
#endif
            ECP_ZZZ_toOctet(&OCTaux,&ecp1,false);
            ECP_ZZZ_fromOctet(&ECPaux1,&OCTaux);
            if(!ECP_ZZZ_equals(&ECPaux1,&ecp1)) // test octet conversion
            {
                printf("ERROR converting ECP_ZZZ to/from OCTET, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
#if CURVETYPE_ZZZ!=MONTGOMERY
        if (!strncmp(line,  ECP2line, strlen(ECP2line))) // get second test vector
        {
            len = strlen(ECP2line);
            linePtr = line + len;
            if(!read_ECP_ZZZ(&ecp2,linePtr) || ECP_ZZZ_isinf(&ecp2))
            {
                printf("ERROR getting test vector input ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        if (!strncmp(line,  ECPsumline, strlen(ECPsumline)))
        {
            len = strlen(ECPsumline);
            linePtr = line + len;
            if(!read_ECP_ZZZ(&ecpsum,linePtr) || ECP_ZZZ_isinf(&ecpsum))
            {
                printf("ERROR getting test vector input ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            ECP_ZZZ_copy(&ECPaux1,&ecp1);
            ECP_ZZZ_add(&ECPaux1,&ecp2);
            ECP_ZZZ_affine(&ECPaux1);
            ECP_ZZZ_copy(&ECPaux2,&ecp2);
            ECP_ZZZ_add(&ECPaux2,&ecp1);
            ECP_ZZZ_affine(&ECPaux2);
            if(!ECP_ZZZ_equals(&ECPaux1,&ecpsum) || !ECP_ZZZ_equals(&ECPaux2,&ecpsum)) // test addition P+Q and Q+P (commutativity)
            {
                printf("ERROR adding two ECPs, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            ECP_ZZZ_copy(&ECPaux1,&ecp1); // test associativity
            ECP_ZZZ_add(&ECPaux1,&ecp2);
            ECP_ZZZ_add(&ECPaux1,&ecpsum);
            ECP_ZZZ_copy(&ECPaux2,&ecpsum);
            ECP_ZZZ_add(&ECPaux2,&ecp2);
            ECP_ZZZ_add(&ECPaux2,&ecp1);
            if(!ECP_ZZZ_equals(&ECPaux1,&ECPaux2)) // test associativity (P+Q)+R = P+(Q+R)
            {
                printf("ERROR testing associativity between three ECPs, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        if (!strncmp(line,  ECPsubline, strlen(ECPsubline)))
        {
            len = strlen(ECPsubline);
            linePtr = line + len;
            if(!read_ECP_ZZZ(&ecpsub,linePtr) || ECP_ZZZ_isinf(&ecpsub))
            {
                printf("ERROR getting test vector input ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            ECP_ZZZ_copy(&ECPaux1,&ecp1);
            ECP_ZZZ_sub(&ECPaux1,&ecp2);
            ECP_ZZZ_affine(&ECPaux1);
            if(!ECP_ZZZ_equals(&ECPaux1,&ecpsub)) // test subtraction P-Q
            {
                printf("ERROR computing subtraction of two ECPs, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        if (!strncmp(line,  ECPnegline, strlen(ECPnegline)))
        {
            len = strlen(ECPnegline);
            linePtr = line + len;
            if(!read_ECP_ZZZ(&ecpneg,linePtr) || ECP_ZZZ_isinf(&ecpneg))
            {
                printf("ERROR getting test vector input ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            ECP_ZZZ_copy(&ECPaux1,&ecp1);
            ECP_ZZZ_neg(&ECPaux1);
            ECP_ZZZ_affine(&ECPaux1);
            if(!ECP_ZZZ_equals(&ECPaux1,&ecpneg))
            {
                printf("ERROR computing negative of ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
#endif
        if (!strncmp(line,  ECPdblline, strlen(ECPdblline)))
        {
            len = strlen(ECPdblline);
            linePtr = line + len;
            if(!read_ECP_ZZZ(&ecpdbl,linePtr) || ECP_ZZZ_isinf(&ecpdbl))
            {
                printf("ERROR getting test vector input ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            ECP_ZZZ_copy(&ECPaux1,&ecp1);
            ECP_ZZZ_dbl(&ECPaux1);
            ECP_ZZZ_affine(&ECPaux1);
            if(!ECP_ZZZ_equals(&ECPaux1,&ecpdbl))
            {
                ECP_ZZZ_outputxyz(&ECPaux1);
                ECP_ZZZ_outputxyz(&ecpdbl);
                printf("ERROR computing double of ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
#if CURVETYPE_ZZZ==MONTGOMERY
        if (!strncmp(line,  ECPmul3line, strlen(ECPmul3line)))
        {
            len = strlen(ECPmul3line);
            linePtr = line + len;
            if(!read_ECP_ZZZ(&ecpmul3,linePtr) || ECP_ZZZ_isinf(&ecpmul3))
            {
                printf("ERROR getting test vector input ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            BIG_XXX_one(BIGaux1);
            BIG_XXX_inc(BIGaux1,2);
            BIG_XXX_norm(BIGaux1);
            ECP_ZZZ_copy(&ECPaux1,&ecp1);
            ECP_ZZZ_mul(&ECPaux1,BIGaux1);
            ECP_ZZZ_affine(&ECPaux1);
            if(!ECP_ZZZ_equals(&ECPaux1,&ecpmul3))
            {
                printf("ERROR computing multiplication of ECP_ZZZ by 3, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            ECP_ZZZ_copy(&ECPaux1,&ecpdbl);
            ECP_ZZZ_add(&ECPaux1,&ecp1,&ecp1);
            if(!ECP_ZZZ_equals(&ECPaux1,&ecpmul3))
            {
                printf("ERROR computing multiplication of ECP_ZZZ by 3, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
#endif
        if (!strncmp(line,  BIGscalar1line, strlen(BIGscalar1line)))
        {
            len = strlen(BIGscalar1line);
            linePtr = line + len;
            read_BIG_XXX(BIGscalar1,linePtr);
        }
        if (!strncmp(line,  ECPmulline, strlen(ECPmulline)))
        {
            len = strlen(ECPmulline);
            linePtr = line + len;
            if(!read_ECP_ZZZ(&ecpmul,linePtr))
            {
                printf("ERROR getting test vector input ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            ECP_ZZZ_copy(&ECPaux1,&ecp1);
            ECP_ZZZ_mul(&ECPaux1,BIGscalar1);
            ECP_ZZZ_affine(&ECPaux1);
            if(!ECP_ZZZ_equals(&ECPaux1,&ecpmul))
            {
                ECP_ZZZ_outputxyz(&ecp1);
                ECP_ZZZ_outputxyz(&ECPaux1);
                ECP_ZZZ_outputxyz(&ecpmul);
                printf("ERROR computing multiplication of ECP_ZZZ by a scalar, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
#if CURVETYPE_ZZZ!=MONTGOMERY
        if (!strncmp(line,  ECPpinmulline, strlen(ECPpinmulline)))
        {
            len = strlen(ECPpinmulline);
            linePtr = line + len;
            if(!read_ECP_ZZZ(&ecppinmul,linePtr))
            {
                printf("ERROR getting test vector input ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            ECP_ZZZ_copy(&ECPaux1,&ecp1);
            ECP_ZZZ_pinmul(&ECPaux1,PIN,14);
            ECP_ZZZ_affine(&ECPaux1);
            if(!ECP_ZZZ_equals(&ECPaux1,&ecppinmul))
            {
                printf("ERROR computing multiplication of ECP_ZZZ by small integer, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        if (!strncmp(line,  BIGscalar2line, strlen(BIGscalar2line)))
        {
            len = strlen(BIGscalar2line);
            linePtr = line + len;
            read_BIG_XXX(BIGscalar2,linePtr);
        }
        if (!strncmp(line,  ECPmul2line, strlen(ECPmul2line)))
        {
            len = strlen(ECPmul2line);
            linePtr = line + len;
            if(!read_ECP_ZZZ(&ecpmul2,linePtr))
            {
                printf("ERROR getting test vector input ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            ECP_ZZZ_copy(&ECPaux1,&ecp1);
            ECP_ZZZ_copy(&ECPaux2,&ecp2);
            ECP_ZZZ_mul2(&ECPaux1,&ECPaux2,BIGscalar1,BIGscalar2);
            ECP_ZZZ_affine(&ECPaux1);
            if(!ECP_ZZZ_equals(&ECPaux1,&ecpmul2))
            {
                printf("ERROR computing linear combination of 2 ECPs, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
#endif
        if (!strncmp(line,  ECPwrongline, strlen(ECPwrongline)))
        {
            len = strlen(ECPwrongline);
            linePtr = line + len;
            if(read_ECP_ZZZ(&ecpwrong,linePtr) || !ECP_ZZZ_isinf(&ecpwrong) || !ECP_ZZZ_equals(&ecpwrong,&inf))
            {
                printf("ERROR identifying wrong ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        if (!strncmp(line,  ECPinfline, strlen(ECPinfline)))
        {
            len = strlen(ECPinfline);
            linePtr = line + len;
            if(read_ECP_ZZZ(&ecpinf,linePtr) || !ECP_ZZZ_isinf(&ecpinf) || !ECP_ZZZ_equals(&ecpinf,&inf))
            {
                printf("ERROR identifying infinite point ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
#if CURVETYPE_ZZZ!=MONTGOMERY
        if (!strncmp(line,  ECPevenline, strlen(ECPevenline)))
        {
            len = strlen(ECPevenline);
            linePtr = line + len;
            if(!read_ECP_ZZZ(&ecpeven,linePtr))
            {
                printf("ERROR getting test vector input ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            ECP_ZZZ_get(BIGaux1,BIGaux2,&ecp1);
            BIG_XXX_norm(BIGaux1);
            ECP_ZZZ_setx(&ECPaux1,BIGaux1,0);
            if(!ECP_ZZZ_equals(&ECPaux1,&ecpeven))
            {
                printf("ERROR computing ECP_ZZZ from coordinate x and with y even, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        if (!strncmp(line,  ECPoddline, strlen(ECPoddline)))
        {
            len = strlen(ECPoddline);
            linePtr = line + len;
            if(!read_ECP_ZZZ(&ecpodd,linePtr))
            {
                printf("ERROR getting test vector input ECP_ZZZ, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            ECP_ZZZ_setx(&ECPaux1,BIGaux1,1);
            if(!ECP_ZZZ_equals(&ECPaux1,&ecpodd))
            {
                printf("ERROR computing ECP_ZZZ from coordinate x and with y odd, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
#endif
    }
    fclose(fp);

    printf("SUCCESS TEST ARITMETIC OF ECP_ZZZ PASSED\n");
    exit(EXIT_SUCCESS);
}