| /* |
| 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_ecp2_arithmetics_ZZZ.c |
| * @author Alessandro Budroni |
| * @brief Test for aritmetics with ECP2_ZZZ |
| * |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include "arch.h" |
| #include "amcl.h" |
| #include "utils.h" |
| #include "ecp2_ZZZ.h" |
| |
| #define LINE_LEN 1000 |
| #define MAX_STRING 1000 |
| |
| void read_BIG_XXX(BIG_XXX A, const char* string) |
| { |
| unsigned long len; |
| char bin[LINE_LEN]; |
| BIG_XXX_zero(A); |
| len = strlen(string)+1; |
| amcl_hex2bin(string,bin,len); |
| len = (len-1)/2; |
| BIG_XXX_fromBytesLen(A,bin,(int)len); |
| BIG_XXX_norm(A); |
| } |
| |
| |
| int read_ECP2_ZZZ(ECP2_ZZZ *ecp2, const char* stringx1) |
| { |
| char *stringx2; |
| char *stringy1; |
| char *stringy2; |
| BIG_XXX x1; |
| BIG_XXX x2; |
| BIG_XXX y1; |
| BIG_XXX y2; |
| FP2_YYY x; |
| FP2_YYY y; |
| |
| stringx2 = strchr(stringx1,':'); |
| stringx2[0] = '\0'; |
| stringx2++; |
| stringy1 = strchr(stringx2,'&'); |
| stringy1[0] = '\0'; |
| stringy1++; |
| stringy2 = strchr(stringy1,':'); |
| stringy2[0] = '\0'; |
| stringy2++; |
| |
| read_BIG_XXX(x1,stringx1); |
| read_BIG_XXX(x2,stringx2); |
| read_BIG_XXX(y1,stringy1); |
| read_BIG_XXX(y2,stringy2); |
| |
| FP2_YYY_from_BIGs(&x,x1,x2); |
| FP2_YYY_from_BIGs(&y,y1,y2); |
| |
| return ECP2_ZZZ_set(ecp2,&x,&y); |
| } |
| |
| int main(int argc, char** argv) |
| { |
| if (argc != 2) |
| { |
| printf("usage: ./test_ecp2_arithmetics_ZZZ [path to test vector file]\n"); |
| exit(EXIT_FAILURE); |
| } |
| |
| int i=0; |
| unsigned long len=0; |
| |
| char line[LINE_LEN]; |
| const char * linePtr = NULL; |
| |
| ECP2_ZZZ ECP2aux1; |
| ECP2_ZZZ ECP2aux2; |
| ECP2_ZZZ inf; |
| FP2_YYY FP2aux1; |
| FP2_YYY FP2aux2; |
| |
| char oct[LINE_LEN]; |
| octet OCTaux= {0,sizeof(oct),oct}; |
| |
| ECP2_ZZZ ecp2[4]; |
| const char* ECP21line = "ECP21 = "; |
| const char* ECP22line = "ECP22 = "; |
| const char* ECP23line = "ECP23 = "; |
| const char* ECP24line = "ECP24 = "; |
| ECP2_ZZZ ecp2sum; |
| const char* ECP2sumline = "ECP2sum = "; |
| ECP2_ZZZ ecp2neg; |
| const char* ECP2negline = "ECP2neg = "; |
| ECP2_ZZZ ecp2sub; |
| const char* ECP2subline = "ECP2sub = "; |
| ECP2_ZZZ ecp2dbl; |
| const char* ECP2dblline = "ECP2dbl = "; |
| BIG_XXX BIGscalar[4]; |
| const char* BIGscalar1line = "BIGscalar1 = "; |
| const char* BIGscalar2line = "BIGscalar2 = "; |
| const char* BIGscalar3line = "BIGscalar3 = "; |
| const char* BIGscalar4line = "BIGscalar4 = "; |
| ECP2_ZZZ ecp2mul; |
| const char* ECP2mulline = "ECP2mul = "; |
| ECP2_ZZZ ecp2mul4; |
| const char* ECP2mul4line = "ECP2mul4 = "; |
| ECP2_ZZZ ecp2wrong; |
| const char* ECP2wrongline = "ECP2wrong = "; |
| ECP2_ZZZ ecp2inf; |
| const char* ECP2infline = "ECP2inf = "; |
| ECP2_ZZZ ecp2set1; |
| const char* ECP2set1line = "ECP2set1 = "; |
| ECP2_ZZZ ecp2set2; |
| const char* ECP2set2line = "ECP2set2 = "; |
| |
| ECP2_ZZZ_inf(&inf); |
| |
| if(!ECP2_ZZZ_isinf(&inf)) |
| { |
| printf("ERROR setting ECP2_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, ECP21line, strlen(ECP21line))) |
| { |
| len = strlen(ECP21line); |
| linePtr = line + len; |
| if(!read_ECP2_ZZZ(&ecp2[0],linePtr) || ECP2_ZZZ_isinf(&ecp2[0])) |
| { |
| printf("ERROR getting test vector input ECP2_ZZZ, line %d\n",i); |
| fclose(fp); |
| exit(EXIT_FAILURE); |
| } |
| ECP2_ZZZ_get(&FP2aux1,&FP2aux2,&ecp2[0]); |
| FP2_YYY_sqr(&FP2aux2,&FP2aux2); |
| ECP2_ZZZ_rhs(&FP2aux1,&FP2aux1); |
| if (!FP2_YYY_equals(&FP2aux1,&FP2aux2)) |
| { |
| printf("ERROR computing right hand side of equation ECP, line %d\n",i); |
| fclose(fp); |
| exit(EXIT_FAILURE); |
| } |
| ECP2_ZZZ_toOctet(&OCTaux,&ecp2[0]); |
| ECP2_ZZZ_fromOctet(&ECP2aux1,&OCTaux); |
| if(!ECP2_ZZZ_equals(&ECP2aux1,&ecp2[0])) |
| { |
| printf("ERROR converting ECP2_ZZZ to/from OCTET, line %d\n",i); |
| fclose(fp); |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (!strncmp(line, ECP22line, strlen(ECP22line))) |
| { |
| len = strlen(ECP22line); |
| linePtr = line + len; |
| if(!read_ECP2_ZZZ(&ecp2[1],linePtr) || ECP2_ZZZ_isinf(&ecp2[1])) |
| { |
| printf("ERROR getting test vector input ECP2_ZZZ, line %d\n",i); |
| fclose(fp); |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (!strncmp(line, ECP23line, strlen(ECP23line))) |
| { |
| len = strlen(ECP23line); |
| linePtr = line + len; |
| if(!read_ECP2_ZZZ(&ecp2[2],linePtr) || ECP2_ZZZ_isinf(&ecp2[2])) |
| { |
| printf("ERROR getting test vector input ECP2_ZZZ, line %d\n",i); |
| fclose(fp); |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (!strncmp(line, ECP24line, strlen(ECP24line))) |
| { |
| len = strlen(ECP24line); |
| linePtr = line + len; |
| if(!read_ECP2_ZZZ(&ecp2[3],linePtr) || ECP2_ZZZ_isinf(&ecp2[3])) |
| { |
| printf("ERROR getting test vector input ECP2_ZZZ, line %d\n",i); |
| fclose(fp); |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (!strncmp(line, ECP2sumline, strlen(ECP2sumline))) |
| { |
| len = strlen(ECP2sumline); |
| linePtr = line + len; |
| if(!read_ECP2_ZZZ(&ecp2sum,linePtr)) |
| { |
| printf("ERROR reading test vector input ECP2_ZZZs, line %d\n",i); |
| fclose(fp); |
| exit(EXIT_FAILURE); |
| } |
| ECP2_ZZZ_copy(&ECP2aux1,&ecp2[0]); |
| ECP2_ZZZ_add(&ECP2aux1,&ecp2[1]); |
| ECP2_ZZZ_affine(&ECP2aux1); |
| ECP2_ZZZ_copy(&ECP2aux2,&ecp2[1]); // testing commutativity P+Q = Q+P |
| ECP2_ZZZ_add(&ECP2aux2,&ecp2[0]); |
| ECP2_ZZZ_affine(&ECP2aux2); |
| if(!ECP2_ZZZ_equals(&ECP2aux1,&ecp2sum) || !ECP2_ZZZ_equals(&ECP2aux2,&ecp2sum)) |
| { |
| printf("ERROR adding two ECP2_ZZZs, line %d\n",i); |
| fclose(fp); |
| exit(EXIT_FAILURE); |
| } |
| ECP2_ZZZ_copy(&ECP2aux1,&ecp2[0]); // testing associativity (P+Q)+R = P+(Q+R) |
| ECP2_ZZZ_add(&ECP2aux1,&ecp2[1]); |
| ECP2_ZZZ_add(&ECP2aux1,&ecp2[2]); |
| ECP2_ZZZ_affine(&ECP2aux1); |
| ECP2_ZZZ_copy(&ECP2aux2,&ecp2[2]); |
| ECP2_ZZZ_add(&ECP2aux2,&ecp2[1]); |
| ECP2_ZZZ_add(&ECP2aux2,&ecp2[0]); |
| ECP2_ZZZ_affine(&ECP2aux2); |
| if(!ECP2_ZZZ_equals(&ECP2aux1,&ECP2aux2)) |
| { |
| printf("ERROR testing associativity bewtween three ECP2_ZZZs, line %d\n",i); |
| fclose(fp); |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (!strncmp(line, ECP2negline, strlen(ECP2negline))) |
| { |
| len = strlen(ECP2negline); |
| linePtr = line + len; |
| if(!read_ECP2_ZZZ(&ecp2neg,linePtr)) |
| { |
| printf("ERROR getting test vector input ECP2_ZZZ, line %d\n",i); |
| fclose(fp); |
| exit(EXIT_FAILURE); |
| } |
| ECP2_ZZZ_copy(&ECP2aux1,&ecp2[0]); |
| ECP2_ZZZ_neg(&ECP2aux1); |
| ECP2_ZZZ_affine(&ECP2aux1); |
| if(!ECP2_ZZZ_equals(&ECP2aux1,&ecp2neg)) |
| { |
| printf("ERROR computing negative of ECP2_ZZZ, line %d\n",i); |
| fclose(fp); |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (!strncmp(line, ECP2subline, strlen(ECP2subline))) |
| { |
| len = strlen(ECP2subline); |
| linePtr = line + len; |
| if(!read_ECP2_ZZZ(&ecp2sub,linePtr)) |
| { |
| printf("ERROR getting test vector input ECP2_ZZZ, line %d\n",i); |
| fclose(fp); |
| exit(EXIT_FAILURE); |
| } |
| ECP2_ZZZ_copy(&ECP2aux1,&ecp2[0]); |
| ECP2_ZZZ_sub(&ECP2aux1,&ecp2[1]); |
| ECP2_ZZZ_affine(&ECP2aux1); |
| if(!ECP2_ZZZ_equals(&ECP2aux1,&ecp2sub)) |
| { |
| printf("ERROR performing subtraction bewtween two ECP2_ZZZs, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (!strncmp(line, ECP2dblline, strlen(ECP2dblline))) |
| { |
| len = strlen(ECP2dblline); |
| linePtr = line + len; |
| if(!read_ECP2_ZZZ(&ecp2dbl,linePtr)) |
| { |
| printf("ERROR getting test vector input ECP2_ZZZ, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| ECP2_ZZZ_copy(&ECP2aux1,&ecp2[0]); |
| ECP2_ZZZ_dbl(&ECP2aux1); |
| ECP2_ZZZ_affine(&ECP2aux1); |
| if(!ECP2_ZZZ_equals(&ECP2aux1,&ecp2dbl)) |
| { |
| printf("ERROR computing double of ECP2_ZZZ, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (!strncmp(line, BIGscalar1line, strlen(BIGscalar1line))) |
| { |
| len = strlen(BIGscalar1line); |
| linePtr = line + len; |
| read_BIG_XXX(BIGscalar[0],linePtr); |
| } |
| if (!strncmp(line, BIGscalar2line, strlen(BIGscalar2line))) |
| { |
| len = strlen(BIGscalar2line); |
| linePtr = line + len; |
| read_BIG_XXX(BIGscalar[1],linePtr); |
| } |
| if (!strncmp(line, BIGscalar3line, strlen(BIGscalar3line))) |
| { |
| len = strlen(BIGscalar3line); |
| linePtr = line + len; |
| read_BIG_XXX(BIGscalar[2],linePtr); |
| } |
| if (!strncmp(line, BIGscalar4line, strlen(BIGscalar4line))) |
| { |
| len = strlen(BIGscalar4line); |
| linePtr = line + len; |
| read_BIG_XXX(BIGscalar[3],linePtr); |
| } |
| if (!strncmp(line, ECP2mulline, strlen(ECP2mulline))) |
| { |
| len = strlen(ECP2mulline); |
| linePtr = line + len; |
| if(!read_ECP2_ZZZ(&ecp2mul,linePtr)) |
| { |
| printf("ERROR getting test vector input ECP2_ZZZ, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| ECP2_ZZZ_copy(&ECP2aux1,&ecp2[0]); |
| ECP2_ZZZ_mul(&ECP2aux1,BIGscalar[0]); |
| ECP2_ZZZ_affine(&ECP2aux1); |
| if(!ECP2_ZZZ_equals(&ECP2aux1,&ecp2mul)) |
| { |
| printf("ERROR computing multiplication of ECP2_ZZZ by a scalar, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (!strncmp(line, ECP2mul4line, strlen(ECP2mul4line))) |
| { |
| len = strlen(ECP2mul4line); |
| linePtr = line + len; |
| if(!read_ECP2_ZZZ(&ecp2mul4,linePtr)) |
| { |
| printf("ERROR getting test vector input ECP2_ZZZ, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| ECP2_ZZZ_mul4(&ECP2aux1,ecp2,BIGscalar); |
| ECP2_ZZZ_affine(&ECP2aux1); |
| if(!ECP2_ZZZ_equals(&ECP2aux1,&ecp2mul4)) |
| { |
| printf("ERROR computing linear combination of 4 ECP2_ZZZs, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (!strncmp(line, ECP2wrongline, strlen(ECP2wrongline))) |
| { |
| len = strlen(ECP2wrongline); |
| linePtr = line + len; |
| if(read_ECP2_ZZZ(&ecp2wrong,linePtr) || !ECP2_ZZZ_isinf(&ecp2wrong) || !ECP2_ZZZ_equals(&ecp2wrong,&inf)) |
| { |
| printf("ERROR identifying a wrong ECP2_ZZZ, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (!strncmp(line, ECP2infline, strlen(ECP2infline))) |
| { |
| len = strlen(ECP2infline); |
| linePtr = line + len; |
| if(read_ECP2_ZZZ(&ecp2inf,linePtr) || !ECP2_ZZZ_isinf(&ecp2inf) || !ECP2_ZZZ_equals(&ecp2inf,&inf)) |
| { |
| printf("ERROR identifying infinite point ECP2_ZZZ, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (!strncmp(line, ECP2set1line, strlen(ECP2set1line))) |
| { |
| len = strlen(ECP2set1line); |
| linePtr = line + len; |
| if(!read_ECP2_ZZZ(&ecp2set1,linePtr)) |
| { |
| printf("ERROR getting test vector input ECP2_ZZZ, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| ECP2_ZZZ_get(&FP2aux1,&FP2aux2,&ecp2[0]); |
| ECP2_ZZZ_setx(&ECP2aux1,&FP2aux1); |
| } |
| if (!strncmp(line, ECP2set2line, strlen(ECP2set2line))) |
| { |
| len = strlen(ECP2set2line); |
| linePtr = line + len; |
| if(!read_ECP2_ZZZ(&ecp2set2,linePtr)) |
| { |
| printf("ERROR getting test vector input ECP2_ZZZ, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| if((!ECP2_ZZZ_equals(&ECP2aux1,&ecp2set2)) && (!ECP2_ZZZ_equals(&ECP2aux1,&ecp2set1))) |
| { |
| printf("ERROR computing ECP2_ZZZ from coordinate x and with y set2, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| } |
| fclose(fp); |
| |
| printf("SUCCESS TEST ARITMETIC OF ECP2_ZZZ PASSED\n"); |
| exit(EXIT_SUCCESS); |
| } |