js331zc/MastersThesis
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
2fb6f67e15
MastersThesis/PQ_TIIGER_TLS/sal/miracl-ubuntu22-11-04-24/includes/benchtest_all.cpp
josi 2fb6f67e15 finale structure update
2024-04-19 14:16:07 +02:00

1463 lines
31 KiB
C++
Raw Blame History

/*
* Copyright (c) 2012-2020 MIRACL UK Ltd.
*
* This file is part of MIRACL Core
* (see https://github.com/miracl/core).
*
* Licensed 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.
*/
/* Test and benchmark elliptic curve and RSA functions
First build core.a from config*.py file
g++ -O3 benchtest_all.c core.a -o benchtest_all
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "rsa_RSA2048.h"
#include "ecp_Ed25519.h"
#include "pair_BN254.h"
#if CHUNK==32 || CHUNK==64
#include "ecp_NIST256.h"
#include "ecp_Ed448.h"
#include "pair_BLS12383.h"
#include "pair4_BLS24479.h"
#include "pair8_BLS48556.h"
#endif
#define MIN_TIME 10.0
#define MIN_ITERS 10
using namespace core;
int ed25519(csprng *RNG)
{
using namespace Ed25519;
using namespace Ed25519_BIG;
using namespace Ed25519_FP;
int i, iterations;
clock_t start;
double elapsed;
ECP EP, EG;
BIG s, r, x, y;
FP rw;
printf("\nTesting/Timing Ed25519 ECC\n");
#if CURVETYPE_Ed25519==WEIERSTRASS
printf("Weierstrass parameterization\n");
#endif
#if CURVETYPE_Ed25519==EDWARDS
printf("Edwards parameterization\n");
#endif
#if CURVETYPE_Ed25519==MONTGOMERY
printf("Montgomery parameterization\n");
#endif
#if MODTYPE_F25519 == PSEUDO_MERSENNE
printf("Pseudo-Mersenne Modulus\n");
#endif
#if MODTYPE_F25519 == GENERALISED_MERSENNE
printf("Generalised-Mersenne Modulus\n");
#endif
#if MODTYPE_F25519 == MONTGOMERY_FRIENDLY
printf("Montgomery Friendly Modulus\n");
#endif
#if MODTYPE_F25519 == NOT_SPECIAL
printf("Not special Modulus\n");
#endif
#if CHUNK==16
printf("16-bit Build\n");
#endif
#if CHUNK==32
printf("32-bit Build\n");
#endif
#if CHUNK==64
printf("64-bit Build\n");
#endif
ECP_generator(&EG);
BIG_rcopy(r, CURVE_Order);
FP_rand(&rw,RNG);
ECP_map2point(&EP,&rw);
ECP_cfp(&EP);
if (ECP_isinf(&EP))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
ECP_mul(&EP,r);
if (!ECP_isinf(&EP))
{
printf("EP= "); ECP_output(&EP); printf("\n");
printf("HASHING FAILURE - P=O\n");
return 0;
}
BIG_randtrunc(s, r, 2 * CURVE_SECURITY_Ed25519, RNG);
ECP_copy(&EP, &EG);
ECP_mul(&EP, r);
if (!ECP_isinf(&EP))
{
printf("FAILURE - rG!=O\n");
return 0;
}
iterations = 0;
start = clock();
do {
ECP_copy(&EP, &EG);
ECP_mul(&EP, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("EC mul - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
return 0;
}
#if CHUNK==32 || CHUNK==64
int nist256(csprng *RNG)
{
using namespace NIST256;
using namespace NIST256_BIG;
using namespace NIST256_FP;
int i, iterations;
clock_t start;
double elapsed;
ECP EP, EG;
BIG s, r, x, y;
FP rw;
printf("\nTesting/Timing NIST256 ECC\n");
#if CURVETYPE_NIST256==WEIERSTRASS
printf("Weierstrass parameterization\n");
#endif
#if CURVETYPE_NIST256==EDWARDS
printf("Edwards parameterization\n");
#endif
#if CURVETYPE_NIST256==MONTGOMERY
printf("Montgomery parameterization\n");
#endif
#if MODTYPE_NIST256 == PSEUDO_MERSENNE
printf("Pseudo-Mersenne Modulus\n");
#endif
#if MODTYPE_NIST256 == GENERALISED_MERSENNE
printf("Generalised-Mersenne Modulus\n");
#endif
#if MODTYPE_NIST256 == MONTGOMERY_FRIENDLY
printf("Montgomery Friendly Modulus\n");
#endif
#if MODTYPE_NIST256 == NOT_SPECIAL
printf("Not special Modulus\n");
#endif
#if CHUNK==16
printf("16-bit Build\n");
#endif
#if CHUNK==32
printf("32-bit Build\n");
#endif
#if CHUNK==64
printf("64-bit Build\n");
#endif
ECP_generator(&EG);
BIG_rcopy(r, CURVE_Order);
FP_rand(&rw,RNG);
ECP_map2point(&EP,&rw);
ECP_cfp(&EP);
if (ECP_isinf(&EP))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
ECP_mul(&EP,r);
if (!ECP_isinf(&EP))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
BIG_randtrunc(s, r, 2 * CURVE_SECURITY_NIST256, RNG);
ECP_copy(&EP, &EG);
ECP_mul(&EP, r);
if (!ECP_isinf(&EP))
{
printf("FAILURE - rG!=O\n");
return 0;
}
iterations = 0;
start = clock();
do {
ECP_copy(&EP, &EG);
ECP_mul(&EP, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("EC mul - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
return 0;
}
int ed448(csprng *RNG)
{
using namespace Ed448;
using namespace Ed448_BIG;
using namespace Ed448_FP;
int i, iterations;
clock_t start;
double elapsed;
ECP EP, EG;
BIG s, r, x, y;
FP rw;
printf("\nTesting/Timing Ed448 ECC\n");
#if CURVETYPE_Ed448==WEIERSTRASS
printf("Weierstrass parameterization\n");
#endif
#if CURVETYPE_Ed448==EDWARDS
printf("Edwards parameterization\n");
#endif
#if CURVETYPE_Ed448==MONTGOMERY
printf("Montgomery parameterization\n");
#endif
#if MODTYPE_F448 == PSEUDO_MERSENNE
printf("Pseudo-Mersenne Modulus\n");
#endif
#if MODTYPE_F448 == GENERALISED_MERSENNE
printf("Generalised-Mersenne Modulus\n");
#endif
#if MODTYPE_F448 == MONTGOMERY_FRIENDLY
printf("Montgomery Friendly Modulus\n");
#endif
#if MODTYPE_F448 == NOT_SPECIAL
printf("Not special Modulus\n");
#endif
#if CHUNK==16
printf("16-bit Build\n");
#endif
#if CHUNK==32
printf("32-bit Build\n");
#endif
#if CHUNK==64
printf("64-bit Build\n");
#endif
ECP_generator(&EG);
BIG_rcopy(r, CURVE_Order);
FP_rand(&rw,RNG);
ECP_map2point(&EP,&rw);
ECP_cfp(&EP);
if (ECP_isinf(&EP))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
ECP_mul(&EP,r);
if (!ECP_isinf(&EP))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
BIG_randtrunc(s, r, 2 * CURVE_SECURITY_Ed448, RNG);
ECP_copy(&EP, &EG);
ECP_mul(&EP, r);
if (!ECP_isinf(&EP))
{
printf("FAILURE - rG!=O\n");
return 0;
}
iterations = 0;
start = clock();
do {
ECP_copy(&EP, &EG);
ECP_mul(&EP, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("EC mul - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
return 0;
}
#endif
int bn254(csprng *RNG)
{
using namespace BN254;
using namespace BN254_FP;
using namespace BN254_BIG;
int i, iterations;
clock_t start;
double elapsed;
ECP P, G;
ECP2 Q, W;
FP12 g, w;
FP4 cm;
FP2 rz2;
FP rz;
BIG s, r, x, y;
printf("\nTesting/Timing BN254 Pairings\n");
ECP_generator(&G);
BIG_rcopy(r, CURVE_Order);
FP_rand(&rz,RNG);
ECP_map2point(&P,&rz);
ECP_cfp(&P);
if (ECP_isinf(&P))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
ECP_mul(&P,r);
if (!ECP_isinf(&P))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
BIG_randtrunc(s, r, 2 * CURVE_SECURITY_BN254, RNG);
ECP_copy(&P, &G);
PAIR_G1mul(&P, r);
if (!ECP_isinf(&P))
{
printf("FAILURE - rG!=O\n");
return 0;
}
iterations = 0;
start = clock();
do {
ECP_copy(&P, &G);
PAIR_G1mul(&P, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("G1 mul - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
ECP2_generator(&W);
FP2_rand(&rz2,RNG);
ECP2_map2point(&Q,&rz2);
ECP2_cfp(&Q);
if (ECP2_isinf(&Q))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
//printf("Q= "); ECP2_output(&Q); printf("\n");
ECP2_mul(&Q,r);
if (!ECP2_isinf(&Q))
{
printf("FAILURE - rQ!=O\n");
return 0;
}
ECP2_copy(&Q, &W);
ECP2_mul(&Q, r);
if (!ECP2_isinf(&Q))
{
printf("FAILURE - rQ!=O\n");
return 0;
}
iterations = 0;
start = clock();
do {
ECP2_copy(&Q, &W);
PAIR_G2mul(&Q, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("G2 mul - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
PAIR_ate(&w, &Q, &P);
PAIR_fexp(&w);
//printf("pairing= ");FP12_output(&w); printf("\n");
FP12_copy(&g, &w);
PAIR_GTpow(&g, r);
if (!FP12_isunity(&g))
{
printf("FAILURE - g^r!=1\n");
return 0;
}
iterations = 0;
start = clock();
do {
FP12_copy(&g, &w);
PAIR_GTpow(&g, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("GT pow - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
FP12_copy(&g, &w);
iterations = 0;
start = clock();
do {
FP12_compow(&cm, &g, s, r);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("GT pow (compressed) - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
iterations = 0;
start = clock();
do {
PAIR_ate(&w, &Q, &P);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("PAIRing ATE - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
iterations = 0;
start = clock();
do {
FP12_copy(&g, &w);
PAIR_fexp(&g);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("PAIRing FEXP - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
ECP_copy(&P, &G);
ECP2_copy(&Q, &W);
PAIR_G1mul(&P, s);
PAIR_ate(&g, &Q, &P);
PAIR_fexp(&g);
ECP_copy(&P, &G);
PAIR_G2mul(&Q, s);
PAIR_ate(&w, &Q, &P);
PAIR_fexp(&w);
if (!PAIR_G1member(&P))
{
printf("FAILURE - P not in G1\n");
return 0;
}
if (!PAIR_G2member(&Q))
{
printf("FAILURE - Q not in G2\n");
return 0;
}
if (!PAIR_GTmember(&w))
{
printf("FAILURE - e(Q,P) not in GT\n");
return 0;
}
if (!FP12_equals(&g, &w))
{
printf("FAILURE - e(sQ,p)!=e(Q,sP) \n");
return 0;
}
ECP2_copy(&Q, &W);
PAIR_ate(&g, &Q, &P);
PAIR_fexp(&g);
PAIR_GTpow(&g, s);
if (!FP12_equals(&g, &w))
{
printf("FAILURE - e(sQ,p)!=e(Q,P)^s \n");
return 0;
}
ECP N1;
ECP2 N2;
ECP_inf(&N1);
ECP2_inf(&N2);
PAIR_ate(&g, &N2, &P);
PAIR_fexp(&g);
if (!FP12_isunity(&g))
{
printf("FAILURE - e(O,P) !=1 \n");
return 0;
}
PAIR_ate(&g, &Q, &N1);
PAIR_fexp(&g);
if (!FP12_isunity(&g))
{
printf("FAILURE - e(Q,O) !=1 \n");
return 0;
}
return 0;
}
#if CHUNK==32 || CHUNK==64
int bls383(csprng *RNG)
{
using namespace BLS12383;
using namespace BLS12383_FP;
using namespace BLS12383_BIG;
int i, iterations;
clock_t start;
double elapsed;
ECP P, G;
ECP2 Q, W;
FP12 g, w;
FP4 cm;
FP2 rz2;
FP rz;
BIG s, r, x, y;
printf("\nTesting/Timing BLS12383 Pairings\n");
ECP_generator(&G);
BIG_rcopy(r, CURVE_Order);
FP_rand(&rz,RNG);
/*
iterations = 0;
start = clock();
do {
BIG_randomnum(s,r,RNG);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("BIG_randomnum - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
printf("nbits(r)= %d\n",BIG_nbits(r));
*/
// iterations = 0;
// start = clock();
// do {
ECP_map2point(&P,&rz);
ECP_cfp(&P);
// iterations++;
// elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
// } while (elapsed < MIN_TIME || iterations < MIN_ITERS);
// elapsed = 1000.0 * elapsed / iterations;
// printf("G1 hash to point - %8d iterations ", iterations);
// printf(" %8.2lf ms per iteration\n", elapsed);
if (ECP_isinf(&P))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
ECP_mul(&P,r);
if (!ECP_isinf(&P))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
BIG_randtrunc(s, r, 2 * CURVE_SECURITY_BLS12383, RNG);
ECP_copy(&P, &G);
PAIR_G1mul(&P, r);
if (!ECP_isinf(&P))
{
printf("FAILURE - rG!=O\n");
return 0;
}
iterations = 0;
start = clock();
do {
ECP_copy(&P, &G);
PAIR_G1mul(&P, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("G1 mul - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
ECP2_generator(&W);
FP2_rand(&rz2,RNG);
ECP2_map2point(&Q,&rz2);
ECP2_cfp(&Q);
if (ECP2_isinf(&Q))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
ECP2_mul(&Q,r);
if (!ECP2_isinf(&Q))
{
printf("FAILURE - rQ!=O\n");
return 0;
}
ECP2_copy(&Q, &W);
ECP2_mul(&Q, r);
if (!ECP2_isinf(&Q))
{
printf("FAILURE - rQ!=O\n");
return 0;
}
iterations = 0;
start = clock();
do {
ECP2_copy(&Q, &W);
PAIR_G2mul(&Q, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("G2 mul - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
PAIR_ate(&w, &Q, &P);
PAIR_fexp(&w);
FP12_copy(&g, &w);
PAIR_GTpow(&g, r);
if (!FP12_isunity(&g))
{
printf("FAILURE - g^r!=1\n");
return 0;
}
iterations = 0;
start = clock();
do {
FP12_copy(&g, &w);
PAIR_GTpow(&g, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("GT pow - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
FP12_copy(&g, &w);
iterations = 0;
start = clock();
do {
FP12_compow(&cm, &g, s, r);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("GT pow (compressed) - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
iterations = 0;
start = clock();
do {
PAIR_ate(&w, &Q, &P);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("PAIRing ATE - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
iterations = 0;
start = clock();
do {
FP12_copy(&g, &w);
PAIR_fexp(&g);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("PAIRing FEXP - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
ECP_copy(&P, &G);
ECP2_copy(&Q, &W);
PAIR_G1mul(&P, s);
PAIR_ate(&g, &Q, &P);
PAIR_fexp(&g);
ECP_copy(&P, &G);
PAIR_G2mul(&Q, s);
PAIR_ate(&w, &Q, &P);
PAIR_fexp(&w);
if (!PAIR_G1member(&P))
{
printf("FAILURE - P not in G1\n");
return 0;
}
if (!PAIR_G2member(&Q))
{
printf("FAILURE - Q not in G2\n");
return 0;
}
if (!PAIR_GTmember(&w))
{
printf("FAILURE - e(Q,P) not in GT\n");
return 0;
}
if (!FP12_equals(&g, &w))
{
printf("FAILURE - e(sQ,p)!=e(Q,sP) \n");
return 0;
}
ECP2_copy(&Q, &W);
PAIR_ate(&g, &Q, &P);
PAIR_fexp(&g);
PAIR_GTpow(&g, s);
if (!FP12_equals(&g, &w))
{
printf("FAILURE - e(sQ,p)!=e(Q,P)^s \n");
return 0;
}
ECP N1;
ECP2 N2;
ECP_inf(&N1);
ECP2_inf(&N2);
PAIR_ate(&g, &N2, &P);
PAIR_fexp(&g);
if (!FP12_isunity(&g))
{
printf("FAILURE - e(O,P) !=1 \n");
return 0;
}
PAIR_ate(&g, &Q, &N1);
PAIR_fexp(&g);
if (!FP12_isunity(&g))
{
printf("FAILURE - e(Q,O) !=1 \n");
return 0;
}
return 0;
}
int bls24(csprng *RNG)
{
using namespace BLS24479;
using namespace BLS24479_FP;
using namespace BLS24479_BIG;
int i, iterations;
clock_t start;
double elapsed;
ECP P, G;
ECP4 Q, W;
FP24 g, w;
FP rz;
FP4 rz4;
FP8 cm;
BIG a, b, s, r;
printf("\nTesting/Timing BLS24479 Pairings\n");
ECP_generator(&G);
BIG_rcopy(r, CURVE_Order);
FP_rand(&rz,RNG);
ECP_map2point(&P,&rz);
ECP_cfp(&P);
if (ECP_isinf(&P))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
ECP_mul(&P,r);
if (!ECP_isinf(&P))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
BIG_randtrunc(s, r, 2 * CURVE_SECURITY_BLS24479, RNG);
ECP_copy(&P, &G);
PAIR_G1mul(&P, r);
if (!ECP_isinf(&P))
{
printf("FAILURE - rG!=O\n");
return 0;
}
iterations = 0;
start = clock();
do {
ECP_copy(&P, &G);
PAIR_G1mul(&P, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("G1 mul - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
ECP4_generator(&W);
FP4_rand(&rz4,RNG);
ECP4_map2point(&Q,&rz4);
ECP4_cfp(&Q);
if (ECP4_isinf(&Q))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
ECP4_mul(&Q,r);
if (!ECP4_isinf(&Q))
{
printf("FAILURE - rQ!=O\n");
return 0;
}
ECP4_copy(&Q, &W);
ECP4_mul(&Q, r);
if (!ECP4_isinf(&Q))
{
printf("FAILURE - rQ!=O\n");
return 0;
}
iterations = 0;
start = clock();
do {
ECP4_copy(&Q, &W);
PAIR_G2mul(&Q, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("G2 mul - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
PAIR_ate(&w, &Q, &P);
PAIR_fexp(&w);
FP24_copy(&g, &w);
PAIR_GTpow(&g, r);
if (!FP24_isunity(&g))
{
printf("FAILURE - g^r!=1\n");
return 0;
}
iterations = 0;
start = clock();
do {
FP24_copy(&g, &w);
PAIR_GTpow(&g, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("GT pow - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
/*
FP24_copy(&g, &w);
iterations = 0;
start = clock();
do {
FP24_compow(&cm, &g, s, r);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("GT pow (compressed) - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
*/
iterations = 0;
start = clock();
do {
PAIR_ate(&w, &Q, &P);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("PAIRing ATE - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
iterations = 0;
start = clock();
do {
FP24_copy(&g, &w);
PAIR_fexp(&g);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("PAIRing FEXP - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
ECP_copy(&P, &G);
ECP4_copy(&Q, &W);
PAIR_G1mul(&P, s);
PAIR_ate(&g, &Q, &P);
PAIR_fexp(&g);
ECP_copy(&P, &G);
PAIR_G2mul(&Q, s);
PAIR_ate(&w, &Q, &P);
PAIR_fexp(&w);
if (!PAIR_G1member(&P))
{
printf("FAILURE - P not in G1\n");
return 0;
}
if (!PAIR_G2member(&Q))
{
printf("FAILURE - Q not in G2\n");
return 0;
}
if (!PAIR_GTmember(&w))
{
printf("FAILURE - e(Q,P) not in GT\n");
return 0;
}
if (!FP24_equals(&g, &w))
{
printf("FAILURE - e(sQ,p)!=e(Q,sP) \n");
return 0;
}
ECP4_copy(&Q, &W);
PAIR_ate(&g, &Q, &P);
PAIR_fexp(&g);
PAIR_GTpow(&g, s);
if (!FP24_equals(&g, &w))
{
printf("FAILURE - e(sQ,p)!=e(Q,P)^s \n");
return 0;
}
ECP N1;
ECP4 N2;
ECP_inf(&N1);
ECP4_inf(&N2);
PAIR_ate(&g, &N2, &P);
PAIR_fexp(&g);
if (!FP24_isunity(&g))
{
printf("FAILURE - e(O,P) !=1 \n");
return 0;
}
PAIR_ate(&g, &Q, &N1);
PAIR_fexp(&g);
if (!FP24_isunity(&g))
{
printf("FAILURE - e(Q,O) !=1 \n");
return 0;
}
/*
PAIR_ate(&g,&N2,&N1);
PAIR_fexp(&g);
if (!FP24_isunity(&g))
{
printf("FAILURE - e(O,O) !=1 \n");
return 0;
}
*/
return 0;
}
int bls48(csprng *RNG)
{
using namespace BLS48556;
using namespace BLS48556_FP;
using namespace BLS48556_BIG;
int i, iterations;
clock_t start;
double elapsed;
ECP P, G;
ECP8 Q, W;
FP48 g, w;
FP rz;
FP8 rz8;
FP16 cm;
BIG a, b, s, r;
printf("\nTesting/Timing BLS48556 Pairings\n");
ECP_generator(&G);
BIG_rcopy(r, CURVE_Order);
FP_rand(&rz,RNG);
ECP_map2point(&P,&rz);
ECP_cfp(&P);
if (ECP_isinf(&P))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
ECP_mul(&P,r);
if (!ECP_isinf(&P))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
BIG_randtrunc(s, r, 2 * CURVE_SECURITY_BLS48556, RNG);
ECP_copy(&P, &G);
PAIR_G1mul(&P, r);
if (!ECP_isinf(&P))
{
printf("FAILURE - rG!=O\n");
return 0;
}
iterations = 0;
start = clock();
do {
ECP_copy(&P, &G);
PAIR_G1mul(&P, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("G1 mul - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
ECP8_generator(&W);
FP8_rand(&rz8,RNG);
ECP8_map2point(&Q,&rz8);
ECP8_cfp(&Q);
if (ECP8_isinf(&Q))
{
printf("HASHING FAILURE - P=O\n");
return 0;
}
ECP8_mul(&Q,r);
if (!ECP8_isinf(&Q))
{
printf("FAILURE - rQ!=O\n");
return 0;
}
ECP8_copy(&Q, &W);
//ECP8_mul(&Q,r);
PAIR_G2mul(&Q, r);
if (!ECP8_isinf(&Q))
{
printf("FAILURE - rQ!=O\n");
return 0;
}
iterations = 0;
start = clock();
do {
ECP8_copy(&Q, &W);
PAIR_G2mul(&Q, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("G2 mul - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
PAIR_ate(&w, &Q, &P);
PAIR_fexp(&w);
FP48_copy(&g, &w);
PAIR_GTpow(&g, r);
if (!FP48_isunity(&g))
{
printf("FAILURE - g^r!=1\n");
return 0;
}
iterations = 0;
start = clock();
do {
FP48_copy(&g, &w);
PAIR_GTpow(&g, s);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("GT pow - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
/*
FP48_copy(&g, &w);
iterations = 0;
start = clock();
do {
FP48_compow(&cm, &g, s, r);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("GT pow (compressed) - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
*/
iterations = 0;
start = clock();
do {
PAIR_ate(&w, &Q, &P);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("PAIRing ATE - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
iterations = 0;
start = clock();
do {
FP48_copy(&g, &w);
PAIR_fexp(&g);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("PAIRing FEXP - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
ECP_copy(&P, &G);
ECP8_copy(&Q, &W);
PAIR_G1mul(&P, s);
PAIR_ate(&g, &Q, &P);
PAIR_fexp(&g);
ECP_copy(&P, &G);
PAIR_G2mul(&Q, s);
//ECP8_mul(&Q,s);
PAIR_ate(&w, &Q, &P);
PAIR_fexp(&w);
if (!PAIR_G1member(&P))
{
printf("FAILURE - P not in G1\n");
return 0;
}
if (!PAIR_G2member(&Q))
{
printf("FAILURE - Q not in G2\n");
return 0;
}
if (!PAIR_GTmember(&w))
{
printf("FAILURE - e(Q,P) not in GT\n");
return 0;
}
if (!FP48_equals(&g, &w))
{
printf("FAILURE - e(sQ,p)!=e(Q,sP) \n");
return 0;
}
ECP8_copy(&Q, &W);
PAIR_ate(&g, &Q, &P);
PAIR_fexp(&g);
PAIR_GTpow(&g, s);
if (!FP48_equals(&g, &w))
{
printf("FAILURE - e(sQ,p)!=e(Q,P)^s \n");
return 0;
}
ECP N1;
ECP8 N2;
ECP_inf(&N1);
ECP8_inf(&N2);
PAIR_ate(&g, &N2, &P);
PAIR_fexp(&g);
if (!FP48_isunity(&g))
{
printf("FAILURE - e(O,P) !=1 \n");
return 0;
}
PAIR_ate(&g, &Q, &N1);
PAIR_fexp(&g);
if (!FP48_isunity(&g))
{
printf("FAILURE - e(Q,O) !=1 \n");
return 0;
}
/*
PAIR_ate(&g,&N2,&N1);
PAIR_fexp(&g);
if (!FP48_isunity(&g))
{
printf("FAILURE - e(O,O) !=1 \n");
return 0;
}
*/
return 0;
}
#endif
int rsa2048(csprng *RNG)
{
using namespace RSA2048;
rsa_public_key pub;
rsa_private_key priv;
int i, iterations;
clock_t start;
double elapsed;
char m[RFS_RSA2048], d[RFS_RSA2048], c[RFS_RSA2048];
octet M = {0, sizeof(m), m};
octet D = {0, sizeof(d), d};
octet C = {0, sizeof(c), c};
printf("\nTesting/Timing 2048-bit RSA\n");
printf("Generating 2048-bit RSA public/private key pair\n");
iterations = 0;
start = clock();
do {
RSA_KEY_PAIR(RNG, 65537, &priv, &pub, NULL, NULL);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < 1);
elapsed = 1000.0 * elapsed / iterations;
printf("RSA gen - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
M.len = RFS_RSA2048;
for (i = 0; i < RFS_RSA2048; i++) M.val[i] = i % 128;
iterations = 0;
start = clock();
do {
RSA_ENCRYPT(&pub, &M, &C);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("RSA enc - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
iterations = 0;
start = clock();
do {
RSA_DECRYPT(&priv, &C, &D);
iterations++;
elapsed = (clock() - start) / (double)CLOCKS_PER_SEC;
} while (elapsed < MIN_TIME || iterations < MIN_ITERS);
elapsed = 1000.0 * elapsed / iterations;
printf("RSA dec - %8d iterations ", iterations);
printf(" %8.2lf ms per iteration\n", elapsed);
for (i = 0; i < RFS_RSA2048; i++)
{
if (M.val[i] != D.val[i])
{
printf("FAILURE - RSA decryption\n");
return 0;
}
}
printf("All tests pass\n");
return 0;
}
int main()
{
csprng RNG;
int i;
char pr[10];
unsigned long ran;
time((time_t *)&ran);
pr[0] = ran;
pr[1] = ran >> 8;
pr[2] = ran >> 16;
pr[3] = ran >> 24;
for (i = 4; i < 10; i++) pr[i] = i; /*****4****/
RAND_seed(&RNG, 10, pr);
ed25519(&RNG);
#if CHUNK==32 || CHUNK==64
nist256(&RNG);
ed448(&RNG);
#endif
bn254(&RNG);
#if CHUNK==32 || CHUNK==64
bls383(&RNG);
bls24(&RNG);
bls48(&RNG);
#endif
rsa2048(&RNG);
}
Reference in New Issue View Git Blame Copy Permalink