| /* |
| 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_big_consistency.c |
| * @author Alessandro Budroni |
| * @brief Test for aritmetics with BIG_XXX |
| * |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include "arch.h" |
| #include "amcl.h" |
| #include "utils.h" |
| #include "big_XXX.h" |
| |
| #define LINE_LEN 10000 |
| #define MAX_STRING 300 |
| |
| 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); |
| } |
| |
| void read_DBIG_XXX(DBIG_XXX A, char* string) |
| { |
| int len; |
| char support[LINE_LEN]; |
| BIG_XXX_dzero(A); |
| len = strlen(string)+1; |
| amcl_hex2bin(string,support,len); |
| len = (len-1)/2; |
| BIG_XXX_dfromBytesLen(A,support,len); |
| BIG_XXX_dnorm(A); |
| } |
| |
| int main(int argc, char** argv) |
| { |
| if (argc != 2) |
| { |
| printf("usage: ./test_BIG_XXX_arithmetics [path to test vector file]\n"); |
| exit(EXIT_FAILURE); |
| } |
| |
| int i=0, len=0, bitlen=0; |
| |
| FILE *fp; |
| |
| char line[LINE_LEN]; |
| char * linePtr = NULL; |
| |
| BIG_XXX supp,mod,div; |
| DBIG_XXX dsupp; |
| |
| BIG_XXX BIG1; |
| const char* BIG1line = "BIG1 = "; |
| BIG_XXX BIG2; |
| const char* BIG2line = "BIG2 = "; |
| BIG_XXX BIGsum; |
| const char* BIGsumline = "BIGsum = "; |
| BIG_XXX BIGsub; |
| const char* BIGsubline = "BIGsub = "; |
| BIG_XXX BIG1mod2; |
| const char* BIG1mod2line = "BIG1mod2 = "; |
| BIG_XXX BIG2mod1; |
| const char* BIG2mod1line = "BIG2mod1 = "; |
| DBIG_XXX BIGmul; |
| const char* BIGmulline = "BIGmul = "; |
| DBIG_XXX BIG1sqr; |
| const char* BIG1sqrline = "BIG1sqr = "; |
| DBIG_XXX BIG2sqr; |
| const char* BIG2sqrline = "BIG2sqr = "; |
| BIG_XXX BIG1sqrmod2; |
| const char* BIG1sqrmod2line = "BIG1sqrmod2 = "; |
| BIG_XXX BIG1modneg2; |
| const char* BIG1modneg2line = "BIG1modneg2 = "; |
| int nbitBIG = 0; |
| const char* nbitBIGline = "nbitBIG = "; |
| int nbitDBIG = 0; |
| const char* nbitDBIGline = "nbitDBIG = "; |
| BIG_XXX BIGdiv; |
| const char* BIGdivline = "BIGdiv = "; |
| BIG_XXX BIGdivmod; |
| const char* BIGdivmodline = "BIGdivmod = "; |
| DBIG_XXX BIGpxmul; |
| const char* BIGpxmulline = "BIGpxmul = "; |
| |
| 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, BIG1line, strlen(BIG1line))) |
| { |
| len = strlen(BIG1line); |
| linePtr = line + len; |
| read_BIG_XXX(BIG1,linePtr); |
| } |
| // test comparison |
| if (!strncmp(line,BIG2line, strlen(BIG2line))) |
| { |
| len = strlen(BIG2line); |
| linePtr = line + len; |
| read_BIG_XXX(BIG2,linePtr); |
| if (BIG_XXX_comp(BIG1,BIG2) < 0) |
| { |
| printf("ERROR comparing two BIGs, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test addition |
| if (!strncmp(line,BIGsumline, strlen(BIGsumline))) |
| { |
| BIG_XXX_zero(supp); |
| BIG_XXX_add(supp,BIG1,BIG2); |
| len = strlen(BIGsumline); |
| linePtr = line + len; |
| read_BIG_XXX(BIGsum,linePtr); |
| BIG_XXX_norm(supp); |
| if (BIG_XXX_comp(BIGsum,supp) != 0) |
| { |
| printf("ERROR adding two BIGs, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test subtraction |
| if (!strncmp(line,BIGsubline, strlen(BIGsubline))) |
| { |
| BIG_XXX_zero(supp); |
| BIG_XXX_sub(supp,BIG1,BIG2); |
| len = strlen(BIGsubline); |
| linePtr = line + len; |
| read_BIG_XXX(BIGsub,linePtr); |
| BIG_XXX_norm(supp); |
| if (BIG_XXX_comp(BIGsub,supp) != 0) |
| { |
| printf("ERROR subtracting two BIGs, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test modulo 1 |
| if (!strncmp(line,BIG1mod2line, strlen(BIG1mod2line))) |
| { |
| BIG_XXX_zero(supp); |
| BIG_XXX_copy(supp,BIG1); |
| BIG_XXX_mod(supp,BIG2); |
| len = strlen(BIG1mod2line); |
| linePtr = line + len; |
| read_BIG_XXX(BIG1mod2,linePtr); |
| BIG_XXX_norm(supp); |
| if (BIG_XXX_comp(BIG1mod2,supp) != 0) |
| { |
| printf("ERROR reducing modulo BIG, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test modulo 2 |
| if (!strncmp(line,BIG2mod1line, strlen(BIG2mod1line))) |
| { |
| BIG_XXX_zero(supp); |
| BIG_XXX_copy(supp,BIG2); |
| BIG_XXX_mod(supp,BIG1); |
| len = strlen(BIG2mod1line); |
| linePtr = line + len; |
| read_BIG_XXX(BIG2mod1,linePtr); |
| BIG_XXX_norm(supp); |
| if (BIG_XXX_comp(BIG2mod1,supp) != 0) |
| { |
| printf("ERROR reducing modulo BIG, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test multiplication |
| if (!strncmp(line,BIGmulline, strlen(BIGmulline))) |
| { |
| BIG_XXX_dzero(dsupp); |
| BIG_XXX_mul(dsupp,BIG1,BIG2); |
| len = strlen(BIGmulline); |
| linePtr = line + len; |
| read_DBIG_XXX(BIGmul,linePtr); |
| BIG_XXX_dnorm(dsupp); |
| if (BIG_XXX_dcomp(BIGmul,dsupp) != 0) |
| { |
| printf("ERROR multiplication BIG, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test square 1 |
| if (!strncmp(line,BIG1sqrline, strlen(BIG1sqrline))) |
| { |
| BIG_XXX_dzero(dsupp); |
| BIG_XXX_sqr(dsupp,BIG1); |
| len = strlen(BIG1sqrline); |
| linePtr = line + len; |
| read_DBIG_XXX(BIG1sqr,linePtr); |
| BIG_XXX_dnorm(dsupp); |
| if (BIG_XXX_dcomp(BIG1sqr,dsupp) != 0) |
| { |
| printf("ERROR squaring BIG 1, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test square 2 |
| if (!strncmp(line,BIG2sqrline, strlen(BIG2sqrline))) |
| { |
| BIG_XXX_dzero(dsupp); |
| BIG_XXX_sqr(dsupp,BIG2); |
| len = strlen(BIG2sqrline); |
| linePtr = line + len; |
| read_DBIG_XXX(BIG2sqr,linePtr); |
| BIG_XXX_dnorm(dsupp); |
| if (BIG_XXX_dcomp(BIG2sqr,dsupp) != 0) |
| { |
| printf("ERROR squaring BIG 2, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test square mod |
| if (!strncmp(line,BIG1sqrmod2line, strlen(BIG1sqrmod2line))) |
| { |
| BIG_XXX_zero(supp); |
| BIG_XXX_copy(supp,BIG1); |
| BIG_XXX_modsqr(supp,supp,BIG2); |
| len = strlen(BIG1sqrmod2line); |
| linePtr = line + len; |
| read_BIG_XXX(BIG1sqrmod2,linePtr); |
| BIG_XXX_norm(supp); |
| if (BIG_XXX_comp(BIG1sqrmod2,supp) != 0) |
| { |
| printf("ERROR reducing squaring modulo BIG, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test negative and modulo |
| if (!strncmp(line,BIG1modneg2line, strlen(BIG1modneg2line))) |
| { |
| BIG_XXX_zero(supp); |
| BIG_XXX_copy(supp,BIG1); |
| BIG_XXX_modneg(supp,supp,BIG2); |
| BIG_XXX_mod(supp,BIG2); // Account for case BIG1 = BIG2 |
| len = strlen(BIG1modneg2line); |
| linePtr = line + len; |
| read_BIG_XXX(BIG1modneg2,linePtr); |
| BIG_XXX_norm(supp); |
| if (BIG_XXX_comp(BIG1modneg2,supp) != 0) |
| { |
| printf("ERROR negative reduced modulo BIG, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test counting bit BIG |
| if (!strncmp(line,nbitBIGline, strlen(nbitBIGline))) |
| { |
| len = strlen(nbitBIGline); |
| nbitBIG = BIG_XXX_nbits(BIG1); |
| linePtr = line + len; |
| sscanf(linePtr,"%d\n",&bitlen); |
| if (nbitBIG != bitlen) |
| { |
| printf("ERROR counting bit BIG, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test counting bit DBIG |
| if (!strncmp(line,nbitDBIGline, strlen(nbitDBIGline))) |
| { |
| len = strlen(nbitDBIGline); |
| nbitDBIG = BIG_XXX_dnbits(BIGmul); |
| linePtr = line + len; |
| sscanf(linePtr,"%d\n",&bitlen); |
| if (nbitDBIG != bitlen) |
| { |
| printf("ERROR counting bit DBIG, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test division |
| if (!strncmp(line,BIGdivline, strlen(BIGdivline))) |
| { |
| BIG_XXX_dzero(dsupp); |
| BIG_XXX_zero(supp); |
| BIG_XXX_dcopy(dsupp,BIGmul); |
| BIG_XXX_ddiv(supp,dsupp,BIGsum); |
| len = strlen(BIGdivline); |
| linePtr = line + len; |
| read_BIG_XXX(BIGdiv,linePtr); |
| BIG_XXX_norm(supp); |
| if (BIG_XXX_comp(BIGdiv,supp) != 0) |
| { |
| printf("ERROR division BIG, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test division with modulo |
| if (!strncmp(line,BIGdivmodline, strlen(BIGdivmodline))) |
| { |
| read_BIG_XXX(mod,"E186EB30EF"); |
| read_BIG_XXX(div,"0ED5066C6815047425DF"); |
| BIG_XXX_zero(supp); |
| BIG_XXX_copy(supp,BIG1); |
| BIG_XXX_moddiv(supp,supp,div,mod); |
| len = strlen(BIGdivmodline); |
| linePtr = line + len; |
| read_BIG_XXX(BIGdivmod,linePtr); |
| BIG_XXX_norm(supp); |
| if (BIG_XXX_comp(BIGdivmod,supp) != 0) |
| { |
| printf("ERROR division modulo BIG, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| // test small multiplication |
| if (!strncmp(line,BIGpxmulline, strlen(BIGpxmulline))) |
| { |
| BIG_XXX_dzero(dsupp); |
| BIG_XXX_pxmul(dsupp,BIG1,nbitDBIG); |
| len = strlen(BIGpxmulline); |
| linePtr = line + len; |
| read_DBIG_XXX(BIGpxmul,linePtr); |
| BIG_XXX_dnorm(dsupp); |
| if (BIG_XXX_dcomp(BIGpxmul,dsupp) != 0) |
| { |
| printf("ERROR small multiplication BIG, line %d\n",i); |
| exit(EXIT_FAILURE); |
| } |
| } |
| } |
| |
| fclose(fp); |
| printf("SUCCESS TEST ARITMETIC OF BIG_XXX PASSED\n"); |
| exit(EXIT_SUCCESS); |
| } |