void
test_key_encrypt (rabin_priv &sk, schnorr_clnt_priv *scp,
schnorr_srv_priv *ssp)
{
for (int i = 0; i < 10; i++) {
size_t len = 512;
wmstr wmsg (len);
rnd.getbytes (wmsg, len);
str msg = wmsg;
startt ();
ref<ephem_key_pair> ekp = scp->make_ephem_key_pair ();
eg += stopt ();
startt ();
bigint rab = sk.sign (msg);
rs += stopt ();
startt();
if (!sk.verify (msg, rab)) {
panic << "verify failed.\n";
}
rv += stopt ();
int bitno = rnd.getword () % mpz_sizeinbase2 (&rab);
rab.setbit (bitno, !rab.getbit (bitno));
if (sk.verify (msg, rab)) {
panic << "verify should have failed\n";
}
bigint r_srv, s_srv, r, s;
startt ();
if (!ssp->endorse_signature (&r_srv, &s_srv, msg, ekp->public_half ())) {
panic << "cannot endorse\n";
}
se += stopt ();
startt ();
if (!scp->complete_signature (&r, &s, msg, ekp->public_half (),
ekp->private_half (), r_srv, s_srv)) {
panic << "cannot complete sig\n";
}
sc += stopt ();
startt ();
if (!scp->verify (msg, r, s)) {
panic << "verify failed\n";
}
sv += stopt ();
bitno = rnd.getword () % mpz_sizeinbase2 (&s);
s.setbit (bitno, !s.getbit (bitno));
if (scp->verify (msg, r, s))
panic << "verify should have failed.\n";
/*
warn << "Success: " << i << "\n";
*/
n++;
}
}
void
test_key_sign (dsa_priv *sk)
{
u_int64_t tmp1, tmp2, tmp3;
for (int i = 0; i < 50; i++) {
bigint r, s;
size_t len = 512;
wmstr wmsg (len);
rnd.getbytes (wmsg, len);
str msg = wmsg;
tmp1 = get_time ();
sk->sign (&r, &s, msg);
tmp2 = get_time ();
if (!sk->verify (msg, r, s))
panic << "Verify failed\n"
<< " p = " << sk->p << "\n"
<< " q = " << sk->q << "\n"
<< " g = " << sk->g << "\n"
<< " x = " << sk->x << "\n"
<< " y = " << sk->y << "\n"
<< "msg = " << hexdump (msg.cstr (), msg.len ()) << "\n"
<< "sig.r = " << r << "\n"
<< "sig.s = " << s << "\n";
tmp3 = get_time ();
tst_vtime += (tmp3 - tmp2);
tst_stime += (tmp2 - tmp1);
int bitno = rnd.getword () % mpz_sizeinbase2 (&r);
r.setbit (bitno, !r.getbit (bitno));
if (sk->verify (msg, r, s))
panic << "Verify should have failed\n";
bitno = rnd.getword () % mpz_sizeinbase2 (&s);
s.setbit (bitno, !s.getbit (bitno));
if (sk->verify (msg, s, s))
panic << "Verify should have failed\n";
}
}
void test_key_sign (esign_priv &sk)
{
uint8_t zz = 2;
strbuf y;
y << str((char*) &zz, 1) << "hello";
uint8_t yy = (uint8_t) str(y)[0];
warn << yy << "\n";
esign_pub pk = get_public_key();
bool ret;
for (int i = 0; i < 25000; i++) {
size_t len = rnd.getword () % 256;
wmstr wmsg (len);
rnd.getbytes (wmsg, len);
str msg1 = wmsg;
bigint m = sk.sign (msg1);
// test converting back and forth
std::vector<uint8_t> raw_m;
get_raw_bigint(m, &raw_m);
m = get_bigint_raw(raw_m);
ret = pk.verify (msg1, m);
if (!ret)
panic << "Verify failed\n"
<< " p = " << sk.p << "\n"
<< " q = " << sk.q << "\n"
<< "msg = " << hexdump (msg1.cstr (), msg1.len ()) << "\n"
<< "sig = " << m << "\n";
int bitno = rnd.getword () % mpz_sizeinbase2 (&m);
m.setbit (bitno, !m.getbit (bitno));
if (pk.verify (msg1, m)) {
panic << "Verify should have failed\n"
<< " p = " << sk.p << "\n"
<< " q = " << sk.q << "\n"
<< "msg = " << hexdump (msg1.cstr (), msg1.len ()) << "\n"
<< "sig = " << m << "\n";
}
}
}
static int
rw_precompute (rw_priv *sk)
{
mpz_t k, p1, q1;
sk->key.vptr = &rabin_1;
sk->key.type = PRIVATE;
if (mpz_cmp (sk->p, sk->q) > 0) {
/* Make sk->p < sk->q to make sk->u as small as possible */
*k = *sk->p;
*sk->p = *sk->q;
*sk->q = *k;
}
/* Calculate modulus N = pq */
mpz_mul (sk->n, sk->p, sk->q);
sk->nbits = mpz_sizeinbase2 (sk->n);
if (sk->nbits <= rw_resvbits)
return -1;
sk->nbits -= rw_resvbits;
mpz_init (k);
mpz_init (p1);
mpz_init (q1);
/* Calculate k = ((p-1)(q-1)/4 + 1)/2 = ((p-1)(q-1) + 4)/8 */
mpz_sub_ui (p1, sk->p, 1);
mpz_sub_ui (q1, sk->q, 1);
mpz_mul (k, p1, q1);
mpz_add_ui (k, k, 4);
mpz_fdiv_q_2exp (k, k, 3);
/* Calculate kp = k % (p-1), and kq = k % (q-1) */
mpz_mod (sk->kp, k, p1);
mpz_mod (sk->kq, k, q1);
/* Calculate u such that (uq) % p = 1 */
mpz_invert (sk->u, sk->q, sk->p);
mpz_clear (k);
mpz_clear (p1);
mpz_clear (q1);
return 0;
}
static dckey *
rw_import_pub (const char *asc)
{
rw_pub *pk;
if (skip_str (&asc, rabin_1.name)
|| skip_str (&asc, ":Pub,n="))
return NULL;
pk = malloc (sizeof (*pk));
mpz_init (pk->n);
if (read_mpz (&asc, pk->n)) {
rw_free_pub (&pk->key);
return NULL;
}
pk->key.vptr = &rabin_1;
pk->key.type = PUBLIC;
pk->nbits = mpz_sizeinbase2 (pk->n) - rw_resvbits;
return &pk->key;
}
void
test_key_sign (esign_priv &sk)
{
u_int64_t tmp, tmp2, tmp3;
bool ret;
for (int i = 0; i < 50; i++) {
size_t len = rnd.getword () % 256;
wmstr wmsg (len);
rnd.getbytes (wmsg, len);
str msg1 = wmsg;
tmp = get_time ();
bigint m = sk.sign (msg1);
tmp2 = get_time ();
ret = sk.verify (msg1, m);
tmp3 = get_time ();
vtime += (tmp3 - tmp2);
signtime += (tmp2 - tmp);
if (!ret)
panic << "Verify failed\n"
<< " p = " << sk.p << "\n"
<< " q = " << sk.q << "\n"
<< "msg = " << hexdump (msg1.cstr (), msg1.len ()) << "\n"
<< "sig = " << m << "\n";
int bitno = rnd.getword () % mpz_sizeinbase2 (&m);
m.setbit (bitno, !m.getbit (bitno));
if (sk.verify (msg1, m))
panic << "Verify should have failed\n"
<< " p = " << sk.p << "\n"
<< " q = " << sk.q << "\n"
<< "msg = " << hexdump (msg1.cstr (), msg1.len ()) << "\n"
<< "sig = " << m << "\n";
}
}
