test/test_paillier_keygen.c - incubator-milagro-crypto-c - Git at Google

 /*
     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.
 */

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

 #define LINE_LEN 2000

 void read_OCTET(octet* OCT, char* string)
 {
     int len = strlen(string);
     char buff[len];
     memcpy(buff,string,len);
     char *end = strchr(buff,',');
     if (end == NULL)
     {
         printf("ERROR unexpected test vector %s\n",string);
         exit(EXIT_FAILURE);
     }
     end[0] = '\0';
     OCT_fromHex(OCT,buff);
 }

 void read_FF_2048(BIG_1024_58 *x, char* string, int n)
 {
     int len = strlen(string);
     char oct[len/2];
     octet OCT = {0, len/2, oct};

     read_OCTET(&OCT, string);
     FF_2048_fromOctet(x, &OCT, n);
 }

 void read_FF_4096(BIG_512_60 *x, char* string, int n)
 {
     int len = strlen(string);
     char oct[len/2];
     octet OCT = {0, len/2, oct};

     read_OCTET(&OCT, string);
     FF_4096_fromOctet(x, &OCT, n);
 }

 void ff_4096_compare(char *x_name, char* y_name, BIG_512_60 *x, BIG_512_60 *y, int n)
 {
     if(FF_4096_comp(x, y, n))
     {
         fprintf(stderr, "FAILURE %s != %s\n", x_name, y_name);
         exit(EXIT_FAILURE);
     }
 }

 void ff_2048_compare(char *x_name, char* y_name, BIG_1024_58 *x, BIG_1024_58 *y, int n)
 {
     if(FF_2048_comp(x, y, n))
     {
         fprintf(stderr, "FAILURE %s != %s\n", x_name, y_name);
         exit(EXIT_FAILURE);
     }
 }

 void clean_public(PAILLIER_public_key *PUB)
 {
     FF_4096_zero(PUB->n,  HFLEN_4096);
     FF_4096_zero(PUB->n2, FFLEN_4096);
 }

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

     int len=0;
     FILE *fp;

     char line[LINE_LEN]= {0};
     char * linePtr=NULL;

     int testSeed=0;

     PAILLIER_private_key PRIV;
     PAILLIER_public_key PUB;

     int testNo=0;
     const char* TESTline = "TEST = ";

     char seedgolden[32]= {0};
     octet SEEDGOLDEN = {0,sizeof(seedgolden),seedgolden};
     const char* SEEDline = "SEED = ";

     char pgolden[HFS_2048]= {0};
     octet PGOLDEN = {0,sizeof(pgolden),pgolden};
     const char* Pline = "P = ";

     char qgolden[HFS_2048]= {0};
     octet QGOLDEN = {0,sizeof(qgolden),qgolden};
     const char* Qline = "Q = ";

     PAILLIER_private_key PRIVGOLDEN;
     PAILLIER_public_key PUBGOLDEN;
     const char* Nline = "N = ";
     const char* LPline = "LP = ";
     const char* MPline = "MP = ";
     const char* LQline = "LQ = ";
     const char* MQline = "MQ = ";

     // Clean GOLDEN keys, the generated keys should be cleaned
     // during initialisation
     PAILLIER_PRIVATE_KEY_KILL(&PRIVGOLDEN);
     clean_public(&PUBGOLDEN);

     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)
     {
         // Read TEST Number
         if (!strncmp(line,TESTline, strlen(TESTline)))
         {
             len = strlen(TESTline);
             linePtr = line + len;
             sscanf(linePtr,"%d\n",&testNo);
         }

         // Read SEED
         if (!strncmp(line,SEEDline, strlen(SEEDline)))
         {
             len = strlen(SEEDline);
             linePtr = line + len;
             read_OCTET(&SEEDGOLDEN,linePtr);
             testSeed = 1;
         }

         // Read N
         if (!strncmp(line, Nline, strlen(Nline)))
         {
             len = strlen(Nline);
             linePtr = line + len;

             read_FF_4096(PUBGOLDEN.n, linePtr, HFLEN_4096);

             FF_4096_sqr(PUBGOLDEN.n2, PUBGOLDEN.n, HFLEN_4096);
             FF_4096_norm(PUBGOLDEN.n2, FFLEN_4096);
         }

         // Read P
         if (!strncmp(line, Pline, strlen(Pline)))
         {
             len = strlen(Pline);
             linePtr = line + len;
             read_OCTET(&PGOLDEN, linePtr);
             read_FF_2048(PRIVGOLDEN.p, linePtr, HFLEN_2048);

             FF_2048_sqr(PRIVGOLDEN.p2, PRIVGOLDEN.p, HFLEN_2048);
             FF_2048_norm(PRIVGOLDEN.p2, FFLEN_2048);
             FF_2048_invmod2m(PRIVGOLDEN.invp, PRIVGOLDEN.p, HFLEN_2048);
         }

         // Read Q
         if (!strncmp(line, Qline, strlen(Qline)))
         {
             len = strlen(Qline);
             linePtr = line + len;
             read_OCTET(&QGOLDEN, linePtr);
             read_FF_2048(PRIVGOLDEN.q, linePtr, HFLEN_2048);

             FF_2048_sqr(PRIVGOLDEN.q2, PRIVGOLDEN.q, HFLEN_2048);
             FF_2048_norm(PRIVGOLDEN.q2, FFLEN_2048);
             FF_2048_invmod2m(PRIVGOLDEN.invq, PRIVGOLDEN.q, HFLEN_2048);
         }

         // Read LP
         if (!strncmp(line, LPline, strlen(LPline)))
         {
             len = strlen(LPline);
             linePtr = line + len;
             read_FF_2048(PRIVGOLDEN.lp, linePtr, HFLEN_2048);
         }

         // Read LQ
         if (!strncmp(line, LQline, strlen(LQline)))
         {
             len = strlen(LQline);
             linePtr = line + len;
             read_FF_2048(PRIVGOLDEN.lq, linePtr, HFLEN_2048);
         }

         // Read MP
         if (!strncmp(line, MPline, strlen(MPline)))
         {
             len = strlen(MPline);
             linePtr = line + len;
             read_FF_2048(PRIVGOLDEN.mp, linePtr, HFLEN_2048);
         }

         // Read MQ and process test vector
         if (!strncmp(line, MQline, strlen(MQline)))
         {
             len = strlen(MQline);
             linePtr = line + len;
             read_FF_2048(PRIVGOLDEN.mq, linePtr, HFLEN_2048);

             if (testSeed)
             {
                 testSeed=0;

                 // CSPRNG
                 csprng RNG;

                 // initialise strong RNG
                 CREATE_CSPRNG(&RNG,&SEEDGOLDEN);

                 PAILLIER_KEY_PAIR(&RNG, NULL, NULL, &PUB, &PRIV);
             }
             else
             {
                 PAILLIER_KEY_PAIR(NULL, &PGOLDEN, &QGOLDEN, &PUB, &PRIV);
             }

             ff_2048_compare("PRIV.p",    "PRIVGOLDEN.p",    PRIV.p,    PRIVGOLDEN.p,    HFLEN_2048);
             ff_2048_compare("PRIV.q",    "PRIVGOLDEN.q",    PRIV.q,    PRIVGOLDEN.q,    HFLEN_2048);
             ff_2048_compare("PRIV.lp",   "PRIVGOLDEN.lp",   PRIV.lp,   PRIVGOLDEN.lp,   HFLEN_2048);
             ff_2048_compare("PRIV.mp",   "PRIVGOLDEN.mp",   PRIV.mp,   PRIVGOLDEN.mp,   HFLEN_2048);
             ff_2048_compare("PRIV.lq",   "PRIVGOLDEN.lq",   PRIV.lq,   PRIVGOLDEN.lq,   HFLEN_2048);
             ff_2048_compare("PRIV.mq",   "PRIVGOLDEN.mq",   PRIV.mq,   PRIVGOLDEN.mq,   HFLEN_2048);
             ff_2048_compare("PRIV.invp", "PRIVGOLDEN.invp", PRIV.invp, PRIVGOLDEN.invp, FFLEN_2048);
             ff_2048_compare("PRIV.p2",   "PRIVGOLDEN.p2",   PRIV.p2,   PRIVGOLDEN.p2,   FFLEN_2048);
             ff_2048_compare("PRIV.invq", "PRIVGOLDEN.invq", PRIV.invq, PRIVGOLDEN.invq, FFLEN_2048);
             ff_2048_compare("PRIV.q2",   "PRIVGOLDEN.q2",   PRIV.q2,   PRIVGOLDEN.q2,   FFLEN_2048);

             ff_4096_compare("PUB.n",  "PUBGOLDEN.n",  PUB.n,  PUBGOLDEN.n,  HFLEN_4096);
             ff_4096_compare("PUB.n2", "PUBGOLDEN.n2", PUB.n2, PUBGOLDEN.n2, FFLEN_4096);

             // Clean keys for next test vector
             PAILLIER_PRIVATE_KEY_KILL(&PRIV);
             PAILLIER_PRIVATE_KEY_KILL(&PRIVGOLDEN);

             clean_public(&PUB);
             clean_public(&PUBGOLDEN);
         }
     }

     fclose(fp);

     printf("SUCCESS TEST PAILLIER KEYGEN PASSED\n");
     exit(EXIT_SUCCESS);
 }
	/*
	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.
	*/

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

	#define LINE_LEN 2000

	void read_OCTET(octet* OCT, char* string)
	{
	int len = strlen(string);
	char buff[len];
	memcpy(buff,string,len);
	char *end = strchr(buff,',');
	if (end == NULL)
	{
	printf("ERROR unexpected test vector %s\n",string);
	exit(EXIT_FAILURE);
	}
	end[0] = '\0';
	OCT_fromHex(OCT,buff);
	}

	void read_FF_2048(BIG_1024_58 x, char string, int n)
	{
	int len = strlen(string);
	char oct[len/2];
	octet OCT = {0, len/2, oct};

	read_OCTET(&OCT, string);
	FF_2048_fromOctet(x, &OCT, n);
	}

	void read_FF_4096(BIG_512_60 x, char string, int n)
	{
	int len = strlen(string);
	char oct[len/2];
	octet OCT = {0, len/2, oct};

	read_OCTET(&OCT, string);
	FF_4096_fromOctet(x, &OCT, n);
	}

	void ff_4096_compare(char x_name, char y_name, BIG_512_60 x, BIG_512_60 y, int n)
	{
	if(FF_4096_comp(x, y, n))
	{
	fprintf(stderr, "FAILURE %s != %s\n", x_name, y_name);
	exit(EXIT_FAILURE);
	}
	}

	void ff_2048_compare(char x_name, char y_name, BIG_1024_58 x, BIG_1024_58 y, int n)
	{
	if(FF_2048_comp(x, y, n))
	{
	fprintf(stderr, "FAILURE %s != %s\n", x_name, y_name);
	exit(EXIT_FAILURE);
	}
	}

	void clean_public(PAILLIER_public_key *PUB)
	{
	FF_4096_zero(PUB->n, HFLEN_4096);
	FF_4096_zero(PUB->n2, FFLEN_4096);
	}

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

	int len=0;
	FILE *fp;

	char line[LINE_LEN]= {0};
	char * linePtr=NULL;

	int testSeed=0;

	PAILLIER_private_key PRIV;
	PAILLIER_public_key PUB;

	int testNo=0;
	const char* TESTline = "TEST = ";

	char seedgolden[32]= {0};
	octet SEEDGOLDEN = {0,sizeof(seedgolden),seedgolden};
	const char* SEEDline = "SEED = ";

	char pgolden[HFS_2048]= {0};
	octet PGOLDEN = {0,sizeof(pgolden),pgolden};
	const char* Pline = "P = ";

	char qgolden[HFS_2048]= {0};
	octet QGOLDEN = {0,sizeof(qgolden),qgolden};
	const char* Qline = "Q = ";

	PAILLIER_private_key PRIVGOLDEN;
	PAILLIER_public_key PUBGOLDEN;
	const char* Nline = "N = ";
	const char* LPline = "LP = ";
	const char* MPline = "MP = ";
	const char* LQline = "LQ = ";
	const char* MQline = "MQ = ";

	// Clean GOLDEN keys, the generated keys should be cleaned
	// during initialisation
	PAILLIER_PRIVATE_KEY_KILL(&PRIVGOLDEN);
	clean_public(&PUBGOLDEN);

	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)
	{
	// Read TEST Number
	if (!strncmp(line,TESTline, strlen(TESTline)))
	{
	len = strlen(TESTline);
	linePtr = line + len;
	sscanf(linePtr,"%d\n",&testNo);
	}

	// Read SEED
	if (!strncmp(line,SEEDline, strlen(SEEDline)))
	{
	len = strlen(SEEDline);
	linePtr = line + len;
	read_OCTET(&SEEDGOLDEN,linePtr);
	testSeed = 1;
	}

	// Read N
	if (!strncmp(line, Nline, strlen(Nline)))
	{
	len = strlen(Nline);
	linePtr = line + len;

	read_FF_4096(PUBGOLDEN.n, linePtr, HFLEN_4096);

	FF_4096_sqr(PUBGOLDEN.n2, PUBGOLDEN.n, HFLEN_4096);
	FF_4096_norm(PUBGOLDEN.n2, FFLEN_4096);
	}

	// Read P
	if (!strncmp(line, Pline, strlen(Pline)))
	{
	len = strlen(Pline);
	linePtr = line + len;
	read_OCTET(&PGOLDEN, linePtr);
	read_FF_2048(PRIVGOLDEN.p, linePtr, HFLEN_2048);

	FF_2048_sqr(PRIVGOLDEN.p2, PRIVGOLDEN.p, HFLEN_2048);
	FF_2048_norm(PRIVGOLDEN.p2, FFLEN_2048);
	FF_2048_invmod2m(PRIVGOLDEN.invp, PRIVGOLDEN.p, HFLEN_2048);
	}

	// Read Q
	if (!strncmp(line, Qline, strlen(Qline)))
	{
	len = strlen(Qline);
	linePtr = line + len;
	read_OCTET(&QGOLDEN, linePtr);
	read_FF_2048(PRIVGOLDEN.q, linePtr, HFLEN_2048);

	FF_2048_sqr(PRIVGOLDEN.q2, PRIVGOLDEN.q, HFLEN_2048);
	FF_2048_norm(PRIVGOLDEN.q2, FFLEN_2048);
	FF_2048_invmod2m(PRIVGOLDEN.invq, PRIVGOLDEN.q, HFLEN_2048);
	}

	// Read LP
	if (!strncmp(line, LPline, strlen(LPline)))
	{
	len = strlen(LPline);
	linePtr = line + len;
	read_FF_2048(PRIVGOLDEN.lp, linePtr, HFLEN_2048);
	}

	// Read LQ
	if (!strncmp(line, LQline, strlen(LQline)))
	{
	len = strlen(LQline);
	linePtr = line + len;
	read_FF_2048(PRIVGOLDEN.lq, linePtr, HFLEN_2048);
	}

	// Read MP
	if (!strncmp(line, MPline, strlen(MPline)))
	{
	len = strlen(MPline);
	linePtr = line + len;
	read_FF_2048(PRIVGOLDEN.mp, linePtr, HFLEN_2048);
	}

	// Read MQ and process test vector
	if (!strncmp(line, MQline, strlen(MQline)))
	{
	len = strlen(MQline);
	linePtr = line + len;
	read_FF_2048(PRIVGOLDEN.mq, linePtr, HFLEN_2048);

	if (testSeed)
	{
	testSeed=0;

	// CSPRNG
	csprng RNG;

	// initialise strong RNG
	CREATE_CSPRNG(&RNG,&SEEDGOLDEN);

	PAILLIER_KEY_PAIR(&RNG, NULL, NULL, &PUB, &PRIV);
	}
	else
	{
	PAILLIER_KEY_PAIR(NULL, &PGOLDEN, &QGOLDEN, &PUB, &PRIV);
	}

	ff_2048_compare("PRIV.p", "PRIVGOLDEN.p", PRIV.p, PRIVGOLDEN.p, HFLEN_2048);
	ff_2048_compare("PRIV.q", "PRIVGOLDEN.q", PRIV.q, PRIVGOLDEN.q, HFLEN_2048);
	ff_2048_compare("PRIV.lp", "PRIVGOLDEN.lp", PRIV.lp, PRIVGOLDEN.lp, HFLEN_2048);
	ff_2048_compare("PRIV.mp", "PRIVGOLDEN.mp", PRIV.mp, PRIVGOLDEN.mp, HFLEN_2048);
	ff_2048_compare("PRIV.lq", "PRIVGOLDEN.lq", PRIV.lq, PRIVGOLDEN.lq, HFLEN_2048);
	ff_2048_compare("PRIV.mq", "PRIVGOLDEN.mq", PRIV.mq, PRIVGOLDEN.mq, HFLEN_2048);
	ff_2048_compare("PRIV.invp", "PRIVGOLDEN.invp", PRIV.invp, PRIVGOLDEN.invp, FFLEN_2048);
	ff_2048_compare("PRIV.p2", "PRIVGOLDEN.p2", PRIV.p2, PRIVGOLDEN.p2, FFLEN_2048);
	ff_2048_compare("PRIV.invq", "PRIVGOLDEN.invq", PRIV.invq, PRIVGOLDEN.invq, FFLEN_2048);
	ff_2048_compare("PRIV.q2", "PRIVGOLDEN.q2", PRIV.q2, PRIVGOLDEN.q2, FFLEN_2048);

	ff_4096_compare("PUB.n", "PUBGOLDEN.n", PUB.n, PUBGOLDEN.n, HFLEN_4096);
	ff_4096_compare("PUB.n2", "PUBGOLDEN.n2", PUB.n2, PUBGOLDEN.n2, FFLEN_4096);

	// Clean keys for next test vector
	PAILLIER_PRIVATE_KEY_KILL(&PRIV);
	PAILLIER_PRIVATE_KEY_KILL(&PRIVGOLDEN);

	clean_public(&PUB);
	clean_public(&PUBGOLDEN);
	}
	}

	fclose(fp);

	printf("SUCCESS TEST PAILLIER KEYGEN PASSED\n");
	exit(EXIT_SUCCESS);
	}