void srp_free(srp_t *srp)
{
mpz_clear(srp->a);
mpz_clear(srp->n);
gmp_randclear(srp->rand);
g_free(srp->username);
g_free(srp->username_upper);
g_free(srp->password_upper);
if (srp->A)
g_free(srp->A);
if (srp->S)
g_free(srp->S);
if (srp->K)
g_free(srp->K);
if (srp->M1)
g_free(srp->M1);
if (srp->M2)
g_free(srp->M2);
if (srp->salt)
g_free(srp->salt);
if (srp->B)
g_free(srp->B);
g_free(srp);
}
void
check_random (int argc, char *argv[])
{
gmp_randstate_t rands;
mpz_t w, x, y;
int i, reps = 2000;
gmp_randinit_default(rands);
mpz_init (w);
mpz_init (x);
mpz_init (y);
if (argc == 2)
reps = atoi (argv[1]);
for (i = 0; i < reps; i++)
{
mpz_errandomb (w, rands, 5*BITS_PER_MP_LIMB);
mpz_errandomb (x, rands, 5*BITS_PER_MP_LIMB);
mpz_errandomb (y, rands, 5*BITS_PER_MP_LIMB);
check_all (w, x, y);
check_all_inplace (w, y);
mpz_errandomb (w, rands, 5*BITS_PER_MP_LIMB);
mpz_errandomb (x, rands, 5*BITS_PER_MP_LIMB);
mpz_errandomb (y, rands, BITS_PER_ULONG);
check_all (w, x, y);
check_all_inplace (w, y);
}
mpz_clear (w);
mpz_clear (x);
mpz_clear (y);
gmp_randclear(rands);
}
damgard_jurik_ciphertext_t* damgard_jurik::encrypt(damgard_jurik_plaintext_t* pt, unsigned long s) {
mpz_t r;
gmp_randstate_t rand;
mpz_t x;
mpz_t gc;
damgard_jurik_ciphertext_t *res = new damgard_jurik_ciphertext_t();
/* pick random blinding factor */
mpz_init(r);
mpz_init(gc);
init_rand(rand, pubkey->bits / 8 + 1);
do {
mpz_urandomb(r, rand, pubkey->bits);
mpz_gcd(gc, r, pubkey->n);
}while( mpz_cmp(r, pubkey->n) >= 0 || mpz_cmp_ui(gc, 1) > 0 || mpz_cmp_ui(r, 0) == 0);
mpz_init(x);
// mpz_powm(res->text, pubkey->g, pt->text, pubkey->n_j[s + 1]);
compute_exp(&res->text, &pt->text, s);
mpz_powm(x, r, pubkey->n_j[s], pubkey->n_j[s + 1]);
mpz_mul(res->text, res->text, x);
mpz_mod(res->text, res->text, pubkey->n_j[s + 1]);
mpz_set(res->n_s, pubkey->n_j[s + 1]);
res->s = s;
mpz_clear(x);
mpz_clear(r);
gmp_randclear(rand);
return res;
}
void damgard_jurik::encrypt(damgard_jurik_ciphertext_t **list, damgard_jurik_plaintext_t **text, unsigned long s, int size) {
mpz_t r;
gmp_randstate_t rand;
mpz_t x;
mpz_t gc;
/* pick random blinding factor */
mpz_init(r);
mpz_init(gc);
init_rand(rand, pubkey->bits / 8 + 1);
do {
mpz_urandomb(r, rand, pubkey->bits);
mpz_gcd(gc, r, pubkey->n);
}while (mpz_cmp(r, pubkey->n) >= 0 || mpz_cmp_ui(gc, 1) > 0 || mpz_cmp_ui(r, 0) == 0);
mpz_init(x);
mpz_powm(x, r, pubkey->n_j[s], pubkey->n_j[s + 1]);
for (int i = 0; i < size; i++) {
list[i] = new damgard_jurik_ciphertext_t();
// mpz_powm(list[i]->text, pubkey->g, text[i]->text, pubkey->n_j[s + 1]);
compute_exp(&list[i]->text, &text[i]->text, s);
mpz_mul(list[i]->text, list[i]->text, x);
mpz_mod(list[i]->text, list[i]->text, pubkey->n_j[s + 1]);
mpz_set(list[i]->n_s, pubkey->n_j[s + 1]);
list[i]->s = s;
}
mpz_clear(x);
mpz_clear(r);
gmp_randclear(rand);
}
// This function is Obsolete 17/8/2009
void mpz_nextprime(mpz_ptr x,mpz_srcptr y)
{gmp_randstate_t rnd;
gmp_randinit_default(rnd);
mpz_next_likely_prime(x,y,rnd);
gmp_randclear(rnd);
return;}
int main(int argc, const char* argv[]) {
gmp_randstate_t state;
data_arr source;
mpz_t seed;
uint32_t min, max, n;
mpz_init(seed);
parse_input(argc, argv, seed, &min, &max);
gmp_randinit_default(state);
gmp_randseed(state, seed);
n = rand_range(state, min, max);
fprintf(stderr, "%u\n",n);
source = make_array(n);
generate_random_arr(n, source, state);
fprint_array(stdout, source, n);
gmp_randclear(state);
delete_array(source, n);
mpz_clear(seed);
return 0;
}
/* Test operands from a table of seed data. This variant creates the operands
using a division chain. This is a hack for better coverage of the gcd
code, which depends on that the random number generators give the exact
numbers we expect. */
void
check_kolmo2 (void)
{
static const struct {
unsigned int seed;
int nb, chain_len;
} data[] = {
{ 917, 15, 5 },
{ 1032, 18, 6 },
{ 1167, 18, 6 },
{ 1174, 18, 6 },
{ 1192, 18, 6 },
};
gmp_randstate_t rs;
mpz_t bs, a, b, want;
int i;
gmp_randinit_default (rs);
mpz_inits (bs, a, b, want, NULL);
for (i = 0; i < numberof (data); i++)
{
gmp_randseed_ui (rs, data[i].seed);
make_chain_operands (want, a, b, rs, data[i].nb, data[i].nb, data[i].chain_len);
one_test (a, b, want, -1);
}
mpz_clears (bs, a, b, want, NULL);
gmp_randclear (rs);
}
static pk_t * pkMatrix_rand(long n, long k)
{
long i, j;
mpzMatrix_t * A = mpzMatrix_init(n, n);
pk_t * Z;
mpz_t * data;
gmp_randstate_t state;
gmp_randinit_default(state);
gmp_randseed_ui(state, rand());
data = mpzMatrix_data(A);
for (i = 0; i < A->nrows; ++i) {
mpz_set_ui(data[i*A->nrows + i], 1);
}
for (i = 0; i < k; ++i) {
long c = rand() % n;
for (j = 0; j <= c; ++j) {
mpz_urandomb(data[j*n+c], state, 10);
}
}
gmp_randclear(state);
Z = pkMatrix_fromFull(A);
mpzMatrix_fini(A);
return Z;
}
long long testPerformance(long long tests, int bit_count, int repetitions)
{
gmp_randstate_t RAND;
gmp_randinit_default(RAND);
gmp_randseed_ui(RAND, getTime());
mpz_t base;
mpz_init_set_ui(base, 1);
mpz_mul_2exp(base, base, bit_count-1); // base = 2^(bit_count-1)
mpz_t n;
mpz_init(n);
long long time = 0;
int test;
for (test = 0; test < tests; test++) {
mpz_urandomb(n, RAND, bit_count-1);
mpz_add(n, n, base); // n has bit_count bits
time += measureTime(n, repetitions);
}
mpz_clear(n);
mpz_clear(base);
gmp_randclear(RAND);
return time / tests; // Average
}
void camlidl_custom_gmp_randstate2_finalize(value val)
{
CAMLparam1(val);
__gmp_randstate_struct** gmp_randstate = (__gmp_randstate_struct**)(Data_custom_val(val));
gmp_randclear(*gmp_randstate);
free(*gmp_randstate);
}
double run_mp(double sigma_, double c_, int tau, dgs_disc_gauss_alg_t alg, size_t ntrials, unsigned long long *t) {
mpfr_set_default_prec(80);
mpfr_t sigma;
mpfr_init_set_d(sigma, sigma_, MPFR_RNDN);
gmp_randstate_t state;
gmp_randinit_default(state);
mpfr_t c;
mpfr_init_set_d(c, c_, MPFR_RNDN);
dgs_disc_gauss_mp_t *gen = dgs_disc_gauss_mp_init(sigma, c, tau, alg);
double variance = 0.0;
mpz_t r;
mpz_init(r);
*t = walltime(0);
for(size_t i=0; i<ntrials; i++) {
gen->call(r, gen, state);
variance += mpz_get_d(r)*mpz_get_d(r);
}
*t = walltime(*t);
dgs_disc_gauss_mp_clear(gen);
mpfr_clear(sigma);
mpz_clear(r);
mpfr_clear(c);
gmp_randclear(state);
variance /= ntrials;
return sqrt(variance);
}
/* expect after a gmp_randinit_set that the new and old generators will
produce the same sequence of numbers */
void
check_one (const char *name, gmp_randstate_ptr src)
{
gmp_randstate_t dst;
mpz_t sz, dz;
int i;
gmp_randinit_set (dst, src);
mpz_init (sz);
mpz_init (dz);
for (i = 0; i < 20; i++)
{
mpz_urandomb (sz, src, 123);
mpz_urandomb (dz, dst, 123);
if (mpz_cmp (sz, dz) != 0)
{
printf ("gmp_randinit_set didn't duplicate randstate\n");
printf (" algorithm: %s\n", name);
gmp_printf (" from src: %#Zx\n", sz);
gmp_printf (" from dst: %#Zx\n", dz);
abort ();
}
}
mpz_clear (sz);
mpz_clear (dz);
gmp_randclear (dst);
}
/*Generate signature for a message*/
void signature_sign(signature sig, mpz_t message, mpz_t private_key, domain_parameters curve)
{
//message must not have a bit length longer than that of n
//see: Guide to Elliptic Curve Cryptography, section 4.4.1.
assert(mpz_sizeinbase(message, 2) <= mpz_sizeinbase(curve->n, 2));
//Initializing variables
mpz_t k;mpz_init(k);
mpz_t x;mpz_init(x);
point Q = point_init();
mpz_t r;mpz_init(r);
mpz_t t1;mpz_init(t1);
mpz_t t2;mpz_init(t2);
mpz_t t3;mpz_init(t3);
mpz_t s;mpz_init(s);
gmp_randstate_t r_state;
signature_sign_start:
//Set k
gmp_randinit_default(r_state);
random_seeding(r_state);
mpz_sub_ui(t1, curve->n, 2);
mpz_urandomm(k , r_state , t1);
gmp_randclear(r_state);
//Calculate x
point_multiplication(Q, k, curve->G, curve);
mpz_set(x, Q->x);
point_clear(Q);
//Calculate r
mpz_mod(r, x, curve->n);
if(!mpz_sgn(r)) //Start over if r=0, note haven't been tested memory might die :)
goto signature_sign_start;
mpz_clear(x);
//Calculate s
//s = k¯¹(e+d*r) mod n = (k¯¹ mod n) * ((e+d*r) mod n) mod n
number_theory_inverse(t1, k, curve->n);//t1 = k¯¹ mod n
mpz_mul(t2, private_key, r);//t2 = d*r
mpz_add(t3, message, t2); //t3 = e+t2
mpz_mod(t2, t3, curve->n); //t2 = t3 mod n
mpz_mul(t3, t2, t1); //t3 = t2 * t1
mpz_mod(s, t3, curve->n); //s = t3 mod n
mpz_clear(t1);
mpz_clear(t2);
mpz_clear(t3);
//Set signature
mpz_set(sig->r, r);
mpz_set(sig->s, s);
//Release k,r and s
mpz_clear(k);
mpz_clear(r);
mpz_clear(s);
}
static void
_hec_quit (void)
{
mpz_clear (n);
mpz_clear (g);
mpz_clear (n2);
gmp_randclear (state);
}
void
paillier_keygen( int modulusbits,
paillier_pubkey_t** pub,
paillier_prvkey_t** prv,
paillier_get_rand_t get_rand )
{
mpz_t p;
mpz_t q;
gmp_randstate_t rand;
/* allocate the new key structures */
*pub = (paillier_pubkey_t*) malloc(sizeof(paillier_pubkey_t));
*prv = (paillier_prvkey_t*) malloc(sizeof(paillier_prvkey_t));
/* initialize our integers */
mpz_init((*pub)->n);
mpz_init((*pub)->n_squared);
mpz_init((*pub)->n_plusone);
mpz_init((*prv)->lambda);
mpz_init((*prv)->x);
mpz_init(p);
mpz_init(q);
/* pick random (modulusbits/2)-bit primes p and q */
init_rand(rand, get_rand, modulusbits / 8 + 1);
do
{
do
mpz_urandomb(p, rand, modulusbits / 2);
while( !mpz_probab_prime_p(p, 10) );
do
mpz_urandomb(q, rand, modulusbits / 2);
while( !mpz_probab_prime_p(q, 10) );
/* compute the public modulus n = p q */
mpz_mul((*pub)->n, p, q);
} while( !mpz_tstbit((*pub)->n, modulusbits - 1) );
complete_pubkey(*pub);
(*pub)->bits = modulusbits;
/* compute the private key lambda = lcm(p-1,q-1) */
mpz_sub_ui(p, p, 1);
mpz_sub_ui(q, q, 1);
mpz_lcm((*prv)->lambda, p, q);
complete_prvkey(*prv, *pub);
/* clear temporary integers and randstate */
mpz_clear(p);
mpz_clear(q);
gmp_randclear(rand);
}
void
check_rand (void)
{
unsigned long min_prec = __GMPF_BITS_TO_PREC (1);
gmp_randstate_t rands;
mpf_t got, u;
unsigned long prec, v;
int i;
/* The nails code in mpf_mul_ui currently isn't exact, so suppress these
tests for now. */
if (BITS_PER_UI > GMP_NUMB_BITS)
return;
mpf_init (got);
mpf_init (u);
gmp_randinit_default(rands);
for (i = 0; i < 200; i++)
{
/* got precision */
prec = min_prec + gmp_urandomm_ui (rands, 15L);
refmpf_set_prec_limbs (got, prec);
/* u precision */
prec = min_prec + gmp_urandomm_ui (rands, 15L);
refmpf_set_prec_limbs (u, prec);
/* u, possibly negative */
mpf_rrandomb (u, rands, PREC(u), (mp_exp_t) 20);
if (gmp_urandomb_ui (rands, 1L))
mpf_neg (u, u);
/* v, 0 to BITS_PER_ULONG bits (inclusive) */
prec = gmp_urandomm_ui (rands, BITS_PER_ULONG+1);
v = gmp_urandomb_ui (rands, prec);
if ((i % 2) == 0)
{
/* separate */
mpf_mul_ui (got, u, v);
check_one ("separate", got, u, v);
}
else
{
/* overlap */
prec = refmpf_set_overlap (got, u);
mpf_mul_ui (got, got, v);
check_one ("overlap src==dst", got, u, v);
mpf_set_prec_raw (got, prec);
}
}
mpf_clear (got);
mpf_clear (u);
gmp_randclear(rands);
}
int
main (int argc, char **argv)
{
char str[1000];
gmp_randstate_t rnd;
mpz_t x, y, z;
int i, j, k, s;
tests_start ();
gmp_randinit_default (rnd);
mpz_init(x);
mpz_init(y);
mpz_init(z);
for( i = 0 ; i < sizeof(tests1) / sizeof(tests1[0]) ; ++i )
{
mpz_ui_pow_ui(x, 10, tests1[i].pow10);
mpz_next_prime_candidate(y, x, rnd);
mpz_sub(y, y, x);
j = mpz_get_ui(y);
if(j != tests1[i].np_off)
{
printf("\nnext_likely_prime(10^%d) - 10^%d: expected %d but got %d",
tests1[i].pow10, tests1[i].pow10, tests1[i].np_off, j);
abort();
}
}
for( i = 0 ; i < sizeof(tests2) / sizeof(tests2[0]) ; ++i )
{
mpz_ui_pow_ui(x, 10, tests2[i].pow10);
mpz_set(y, x);
s = j = 0;
for( ; ; )
{
mpz_next_prime_candidate(y, y, rnd);
mpz_sub(z, y, x);
k = mpz_get_si(z);
if(k >= 1000)
break;
j++;
s += k * k;
}
if(j != tests2[i].count || s != tests2[i].sumsq)
{
printf("\nnext_likely_prime failed test2[%d], expected %d and %d but got %d and %d",
i, tests2[i].count, tests2[i].sumsq, j, s);
abort();
}
}
gmp_randclear (rnd);
mpz_clear(z);
mpz_clear(y);
mpz_clear(x);
tests_end ();
exit (0);
}
int main(void)
{
/* Initialization */
long D, sd = 0;
mpz_t p, m, n, h, private_key;
mpz_t curv[2], base_point[2], public_key[2];
mpz_t seed;
gmp_randinit(stat, GMP_RAND_ALG_LC, 120);
mpz_init(p);
mpz_init(m);
mpz_init(n);
mpz_init(h);
mpz_init(private_key);
mpz_init(curv[0]); mpz_init(curv[1]);
mpz_init(base_point[0]); mpz_init(base_point[1]);
mpz_init(public_key[0]); mpz_init(public_key[1]);
mpz_init(seed);
srand( (unsigned) getpid());
sd=rand();
mpz_set_ui(seed, sd);
gmp_randseed(stat, seed);
/* set the value of the discriminant*/
D = 40;
/* create the order p, the elliptic curve and its order m using D */
CMmethod(D, &p, &m, curv);
/* create a base point of order n, where m = nh and returns n and h*/
domain_parameters(curv, base_point, &p, &m, &n, &h);
/* create a private and a public key */
create_priv_and_public(curv, &p, base_point, &private_key, public_key);
/* generate the signature on the message using ECDSA */
file_create_signature("README", curv, base_point, &p, &n, &private_key, "signature");
gmp_randclear(stat);
mpz_clear(p);
mpz_clear(m);
mpz_clear(n);
mpz_clear(h);
mpz_clear(private_key);
mpz_clear(curv[0]); mpz_clear(curv[1]);
mpz_clear(base_point[0]); mpz_clear(base_point[1]);
mpz_clear(public_key[0]); mpz_clear(public_key[1]);
mpz_clear(seed);
return 0;
}
paillier_ciphertext_t*
paillier_enc(paillier_tag* tag, paillier_ciphertext_t* res,
paillier_pubkey_t* pub,
paillier_plaintext_t* pt,
paillier_get_rand_t get_rand, int no_copies, mpz_t* rand_prf)
{
mpz_t r;
gmp_randstate_t rand;
mpz_t x, one;
// char val = '1';
/* pick random blinding factor */
mpz_init(r);
mpz_init_set_str(one, "1", 10);
//printf("\npubbits : %d \n", pub->bits);
init_rand(rand, get_rand, pub->bits / 8 + 1);
/* compute ciphertext */
/*if( !res )
{
res = (paillier_ciphertext_t*) malloc(sizeof(paillier_ciphertext_t));
mpz_init(res->c);
} */
//printf("\n calculating enc");
mpz_t t;
mpz_init(x);
mpz_init(t);
mpz_set(tag->t, pt->m);
mpz_mul(t, pub->n, pt->m);
int j;
for(j=0; j < no_copies; j++)
{
do
mpz_urandomb(r, rand, pub->bits);
while( mpz_cmp(r, pub->n) >= 0 );
mpz_mul(r, r, rand_prf[j]);
mpz_mod(r, r, pub->n);
mpz_powm(x, r, pub->n, pub->n_squared);
mpz_init(res[j].c);
//printf("\n power %d", j );
mpz_add(res[j].c, one, t);
//mpz_powm(res[j].c, pub->n_plusone, pt->m, pub->n_squared);
mpz_mul(res[j].c, res[j].c, x);
//printf("\n multiply");
mpz_mod(res[j].c, res[j].c, pub->n_squared);
}
//printf("\n mod");
mpz_clear(x);
//printf("\n clear");
mpz_clear(r);
gmp_randclear(rand);
return res;
}
int
mpz_millerrabin (mpz_srcptr n, int reps)
{
int r;
mpz_t nm1, nm3, x, y, q;
unsigned long int k;
gmp_randstate_t rstate;
int is_prime;
TMP_DECL;
TMP_MARK;
MPZ_TMP_INIT (nm1, SIZ (n) + 1);
mpz_sub_ui (nm1, n, 1L);
MPZ_TMP_INIT (x, SIZ (n) + 1);
MPZ_TMP_INIT (y, 2 * SIZ (n)); /* mpz_powm_ui needs excessive memory!!! */
/* Perform a Fermat test. */
mpz_set_ui (x, 210L);
mpz_powm (y, x, nm1, n);
if (mpz_cmp_ui (y, 1L) != 0)
{
TMP_FREE;
return 0;
}
MPZ_TMP_INIT (q, SIZ (n));
/* Find q and k, where q is odd and n = 1 + 2**k * q. */
k = mpz_scan1 (nm1, 0L);
mpz_tdiv_q_2exp (q, nm1, k);
/* n-3 */
MPZ_TMP_INIT (nm3, SIZ (n) + 1);
mpz_sub_ui (nm3, n, 3L);
ASSERT (mpz_cmp_ui (nm3, 1L) >= 0);
gmp_randinit_default (rstate);
is_prime = 1;
for (r = 0; r < reps && is_prime; r++)
{
/* 2 to n-2 inclusive, don't want 1, 0 or -1 */
mpz_urandomm (x, rstate, nm3);
mpz_add_ui (x, x, 2L);
is_prime = millerrabin (n, nm1, x, y, q, k);
}
gmp_randclear (rstate);
TMP_FREE;
return is_prime;
}
int
mpz_millerrabin (mpz_srcptr n, int reps)
{
gmp_randstate_t rstate;
int is_prime;
gmp_randinit_default(rstate);
is_prime = mpz_miller_rabin(n, reps, rstate);
gmp_randclear(rstate);
return is_prime;
}
void mpfr_bench(mpfr_prec_t prec_a, mpfr_prec_t prec_b, mpfr_prec_t prec_c,
const char *b_str, const char *c_str, unsigned long seed)
{
mpfr_t a,b,c;
mpf_t x,y,z;
mpz_t zz;
gmp_randstate_t state;
gmp_randinit_lc_2exp_size (state, 128);
gmp_randseed_ui (state, seed);
mpfr_init2(a, prec_a);
mpfr_init2(b, prec_b);
mpfr_init2(c, prec_c);
mpf_init2(x, prec_a);
mpf_init2(y, prec_b);
mpf_init2(z, prec_c);
if (b_str)
mpf_set_str(y, b_str, 10);
else
mpf_urandomb(y, state, prec_b);
if (c_str)
mpf_set_str(z, c_str, 10);
else
mpf_urandomb(z, state, prec_c);
mpfr_set_f(b, y, MPFR_RNDN);
mpfr_set_f(c, z, MPFR_RNDN);
mpz_init (zz);
mpz_urandomb (zz, state, 2*prec_b);
if (verbose)
{
printf("B="); mpfr_out_str(stdout, 10, 0, b, MPFR_RNDD);
printf("\nC="); mpfr_out_str(stdout, 10, 0, c, MPFR_RNDD);
putchar('\n');
}
TIMP_OVERHEAD ();
#undef BENCH
#define BENCH(TEST_STR, TEST) printf(" "TEST_STR": %Lu\n", TIMP_MEASURE(TEST))
TEST_LIST;
mpz_clear (zz);
mpfr_clear (a);
mpfr_clear (b);
mpfr_clear (c);
mpf_clear (x);
mpf_clear (y);
mpf_clear (z);
gmp_randclear (state);
}
void clear(){
gmp_randclear(state);
mpz_clear(big_temp);
mpz_clear(n);
mpz_clear(n_plus_1);
mpz_clear(n_square);
mpz_clear(r);
mpz_clear(r_pow_n);
mpz_clear(d);
mpz_clear(d_inverse);
}
void damgard_jurik::key_gen(int modulusbits) {
mpz_t p, q;
gmp_randstate_t rand;
mpz_init(pubkey->n);
mpz_init(pubkey->g);
mpz_init(prvkey->lambda);
mpz_init(p);
mpz_init(q);
init_rand(rand, modulusbits / 8 + 1);
do
{
do
mpz_urandomb(p, rand, modulusbits / 2);
while( !mpz_probab_prime_p(p, 10) );
do
mpz_urandomb(q, rand, modulusbits / 2);
while( !mpz_probab_prime_p(q, 10) );
/* compute the public modulus n = p q */
mpz_mul(pubkey->n, p, q);
} while( !mpz_tstbit(pubkey->n, modulusbits - 1));
pubkey->bits = modulusbits;
mpz_add_ui(pubkey->g, pubkey->n, 1);
pubkey->n_j = new mpz_t[s_max + 2];
pubkey->k_n = new mpz_t[s_max + 2];
mpz_init(pubkey->n_j[0]);
mpz_set_ui(pubkey->n_j[0], 1);
mpz_init(pubkey->k_n[0]);
mpz_set_ui(pubkey->k_n[0], 1);
for (int i = 1;i <= s_max + 1;i++) {
mpz_init(pubkey->n_j[i]);
mpz_mul(pubkey->n_j[i], pubkey->n_j[i - 1], pubkey->n);
mpz_init(pubkey->k_n[i]);
mpz_mul_ui(pubkey->k_n[i], pubkey->k_n[i - 1], i);
}
/* Compute Private Key */
mpz_sub_ui(p, p, 1);
mpz_sub_ui(q, q, 1);
mpz_lcm(prvkey->lambda, p, q);
mpz_clear(p);
mpz_clear(q);
gmp_randclear(rand);
}
void
test_main (void)
{
gmp_randstate_t rands;
unsigned i;
gmp_randinit_default (rands);
for (i = 0; ecc_curves[i]; i++)
{
if (ecc_curves[i]->p.sqrt)
test_modulo (rands, &ecc_curves[i]->p);
}
gmp_randclear (rands);
}
/* Check divide and conquer hensel division routine. */
void
check_dc_bdiv_q (void)
{
mp_limb_t np[2*MAX_LIMBS];
mp_limb_t np2[2*MAX_LIMBS];
mp_limb_t rp[3*MAX_LIMBS];
mp_limb_t dp[MAX_LIMBS];
mp_limb_t qp[2*MAX_LIMBS];
mp_limb_t dip;
mp_size_t nn, rn, dn, qn;
gmp_randstate_t rands;
int i, j, s;
gmp_randinit_default(rands);
for (i = 0; i < ITERS; i++)
{
dn = (random() % (MAX_LIMBS - 5)) + 6;
nn = (random() % MAX_LIMBS) + dn;
mpn_rrandom (np, rands, nn);
mpn_rrandom (dp, rands, dn);
dp[0] |= 1;
MPN_COPY(np2, np, nn);
modlimb_invert(dip, dp[0]);
mpn_dc_bdiv_q(qp, np, nn, dp, dn, dip);
if (nn >= dn) mpn_mul(rp, qp, nn, dp, dn);
else mpn_mul(rp, dp, dn, qp, nn);
if (mpn_cmp(rp, np2, nn) != 0)
{
printf("failed: quotient wrong!\n");
printf ("nn = %lu, dn = %lu\n\n", nn, dn);
gmp_printf (" np: %Nx\n\n", np2, nn);
gmp_printf (" dp: %Nx\n\n", dp, dn);
gmp_printf (" qp: %Nx\n\n", qp, nn);
gmp_printf (" rp: %Nx\n\n", rp, nn);
abort ();
}
}
gmp_randclear(rands);
}
void
PerlCryptDHGMP_mpz_rand_set(pTHX_ mpz_t *v, unsigned int bits)
{
gmp_randstate_t state;
gmp_randinit_default(state);
/* Perl_seed should come with Perl 5.8.1. You shouldn't be using
Perl older than that, or at least you should be supplying me with
a patch
*/
gmp_randseed_ui(state, Perl_seed(aTHX));
mpz_urandomb(*v, state, bits);
gmp_randclear(state);
}
int
main (void)
{
unsigned long n;
gmp_randstate_t rands;
int j, k, i, i1;
mp_limb_t sp[10000], tp[10000], xp[10000], yp[10000], zp[10000];
tests_start ();
gmp_randinit_default(rands);
for (i1 = 0; i1 < 2; i1++)
{
for (n = 1; n < 100; n++)
{
for (j = 1; j < 5; j++)
{
if (i1 == 0)
{
mpn_randomb (xp, rands, n);
mpn_randomb (yp, rands, n);
mpn_randomb (zp, rands, n);
}
else
{
mpn_rrandom (xp, rands, n);
mpn_rrandom (yp, rands, n);
mpn_rrandom (zp, rands, n);
}
k = mpn_addadd_n (sp, xp, yp, zp, n);
i = mpn_add_n (tp, xp, yp, n);
i += mpn_add_n (tp, tp, zp, n);
if (k != i)
{
printf ("mpn_addadd_n ret wrong\n");
abort ();
}
if (mpn_cmp (sp, tp, n) != 0)
{
printf ("mpn_addadd_n sum wrong\n");
abort ();
}
}
}
}
gmp_randclear(rands);
tests_end ();
exit (0);
}
//mocked key
void paillier_pubkey::init_key(unsigned int key_bit_size)
{
init_s = 1;
gmp_randstate_t rand;
gmp_randinit_default(rand);
mpz_urandomb(nj[1], rand, key_bit_size);
mpz_add_ui(g, nj[1], 1);
for (int i = 2; i <= init_s+1; i++)
{
mpz_pow_ui(nj[i], nj[1], i);
}
gmp_randclear(rand);
}
void
test_main (void)
{
const char *nettle_test_seed;
gmp_randstate_t rands;
unsigned count = COUNT;
unsigned i;
gmp_randinit_default (rands);
test_fixed ();
for (i = 0; ecc_curves[i]; i++)
{
test_patterns ("p", &ecc_curves[i]->p);
test_patterns ("q", &ecc_curves[i]->p);
}
#if !NETTLE_USE_MINI_GMP
nettle_test_seed = getenv ("NETTLE_TEST_SEED");
if (nettle_test_seed && *nettle_test_seed)
{
mpz_t seed;
mpz_init (seed);
if (mpz_set_str (seed, nettle_test_seed, 0) < 0
|| mpz_sgn (seed) < 0)
die ("Invalid NETTLE_TEST_SEED: %s\n",
nettle_test_seed);
if (mpz_sgn (seed) == 0)
get_random_seed (seed);
fprintf (stderr, "Using NETTLE_TEST_SEED=");
mpz_out_str (stderr, 10, seed);
fprintf (stderr, "\n");
gmp_randseed (rands, seed);
mpz_clear (seed);
count *= 20;
}
#endif /* !NETTLE_USE_MINI_GMP */
for (i = 0; ecc_curves[i]; i++)
{
test_modulo (rands, "p", &ecc_curves[i]->p, count);
test_modulo (rands, "q", &ecc_curves[i]->q, count);
}
gmp_randclear (rands);
}