/**
* Run actual test queries.
*
* @return 0 on success
*/
static int
run_queries (PGconn *conn)
{
struct GNUNET_CRYPTO_rsa_PublicKey *pub;
struct GNUNET_CRYPTO_rsa_PublicKey *pub2 = NULL;
struct GNUNET_CRYPTO_rsa_Signature *sig;
struct GNUNET_CRYPTO_rsa_Signature *sig2 = NULL;
struct GNUNET_TIME_Absolute abs_time = GNUNET_TIME_absolute_get ();
struct GNUNET_TIME_Absolute abs_time2;
struct GNUNET_TIME_Absolute forever = GNUNET_TIME_UNIT_FOREVER_ABS;
struct GNUNET_TIME_Absolute forever2;
struct GNUNET_HashCode hc;
struct GNUNET_HashCode hc2;
PGresult *result;
int ret;
struct GNUNET_CRYPTO_rsa_PrivateKey *priv;
char msg[] = "Hello";
void *msg2;
size_t msg2_len;
uint16_t u16;
uint16_t u162;
uint32_t u32;
uint32_t u322;
uint64_t u64;
uint64_t u642;
priv = GNUNET_CRYPTO_rsa_private_key_create (1024);
pub = GNUNET_CRYPTO_rsa_private_key_get_public (priv);
sig = GNUNET_CRYPTO_rsa_sign (priv,
msg,
sizeof (msg));
u16 = 16;
u32 = 32;
u64 = 64;
/* FIXME: test GNUNET_PQ_result_spec_variable_size */
{
struct GNUNET_PQ_QueryParam params_insert[] = {
GNUNET_PQ_query_param_rsa_public_key (pub),
GNUNET_PQ_query_param_rsa_signature (sig),
GNUNET_PQ_query_param_absolute_time (&abs_time),
GNUNET_PQ_query_param_absolute_time (&forever),
GNUNET_PQ_query_param_auto_from_type (&hc),
GNUNET_PQ_query_param_fixed_size (msg, strlen (msg)),
GNUNET_PQ_query_param_uint16 (&u16),
GNUNET_PQ_query_param_uint32 (&u32),
GNUNET_PQ_query_param_uint64 (&u64),
GNUNET_PQ_query_param_end
};
struct GNUNET_PQ_QueryParam params_select[] = {
GNUNET_PQ_query_param_end
};
struct GNUNET_PQ_ResultSpec results_select[] = {
GNUNET_PQ_result_spec_rsa_public_key ("pub", &pub2),
GNUNET_PQ_result_spec_rsa_signature ("sig", &sig2),
GNUNET_PQ_result_spec_absolute_time ("abs_time", &abs_time2),
GNUNET_PQ_result_spec_absolute_time ("forever", &forever2),
GNUNET_PQ_result_spec_auto_from_type ("hash", &hc2),
GNUNET_PQ_result_spec_variable_size ("vsize", &msg2, &msg2_len),
GNUNET_PQ_result_spec_uint16 ("u16", &u162),
GNUNET_PQ_result_spec_uint32 ("u32", &u322),
GNUNET_PQ_result_spec_uint64 ("u64", &u642),
GNUNET_PQ_result_spec_end
};
result = GNUNET_PQ_exec_prepared (conn,
"test_insert",
params_insert);
if (PGRES_COMMAND_OK != PQresultStatus (result))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Database failure: %s\n",
PQresultErrorMessage (result));
PQclear (result);
GNUNET_CRYPTO_rsa_signature_free (sig);
GNUNET_CRYPTO_rsa_private_key_free (priv);
GNUNET_CRYPTO_rsa_public_key_free (pub);
return 1;
}
PQclear (result);
result = GNUNET_PQ_exec_prepared (conn,
"test_select",
params_select);
if (1 !=
PQntuples (result))
{
GNUNET_break (0);
PQclear (result);
GNUNET_CRYPTO_rsa_signature_free (sig);
GNUNET_CRYPTO_rsa_private_key_free (priv);
GNUNET_CRYPTO_rsa_public_key_free (pub);
return 1;
}
ret = GNUNET_PQ_extract_result (result,
results_select,
0);
GNUNET_break (GNUNET_YES == ret);
GNUNET_break (abs_time.abs_value_us == abs_time2.abs_value_us);
GNUNET_break (forever.abs_value_us == forever2.abs_value_us);
GNUNET_break (0 ==
memcmp (&hc,
&hc2,
sizeof (struct GNUNET_HashCode)));
GNUNET_break (0 ==
GNUNET_CRYPTO_rsa_signature_cmp (sig,
sig2));
GNUNET_break (0 ==
GNUNET_CRYPTO_rsa_public_key_cmp (pub,
pub2));
GNUNET_break (strlen (msg) == msg2_len);
GNUNET_break (0 ==
strncmp (msg,
msg2,
msg2_len));
GNUNET_break (16 == u162);
GNUNET_break (32 == u322);
GNUNET_break (64 == u642);
GNUNET_PQ_cleanup_result (results_select);
PQclear (result);
}
GNUNET_CRYPTO_rsa_signature_free (sig);
GNUNET_CRYPTO_rsa_private_key_free (priv);
GNUNET_CRYPTO_rsa_public_key_free (pub);
if (GNUNET_OK != ret)
return 1;
return 0;
}
/**
* Evaluate RSA performance.
*
* @param len keylength to evaluate with
*/
static void
eval (unsigned int len)
{
struct GNUNET_TIME_Absolute start;
struct GNUNET_CRYPTO_RsaSignature *sig;
struct GNUNET_CRYPTO_RsaSignature *rsig;
struct GNUNET_CRYPTO_RsaPublicKey *public_key;
struct GNUNET_CRYPTO_RsaPrivateKey *private_key;
struct GNUNET_CRYPTO_RsaBlindingKeySecret bsec[10];
unsigned int i;
char sbuf[128];
char *bbuf;
size_t bbuf_len;
struct GNUNET_HashCode hc;
start = GNUNET_TIME_absolute_get ();
for (i=0;i<10;i++)
{
private_key = GNUNET_CRYPTO_rsa_private_key_create (len);
GNUNET_CRYPTO_rsa_private_key_free (private_key);
}
printf ("10x %u-key generation took %s\n",
len,
GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
GNUNET_YES));
GNUNET_snprintf (sbuf,
sizeof (sbuf),
"RSA %u-key generation",
len);
GAUGER ("UTIL", sbuf,
64 * 1024 / (1 +
GNUNET_TIME_absolute_get_duration
(start).rel_value_us / 1000LL), "keys/ms");
private_key = GNUNET_CRYPTO_rsa_private_key_create (len);
public_key = GNUNET_CRYPTO_rsa_private_key_get_public (private_key);
for (i=0;i<10;i++)
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
&bsec[i], sizeof (bsec[0]));
/*
start = GNUNET_TIME_absolute_get ();
for (i=0;i<10;i++)
rsa_blinding_key_derive(public_key, &bsec[i]);
printf ("10x %u-blinding key generation took %s\n",
len,
GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
GNUNET_YES));
GNUNET_snprintf (sbuf,
sizeof (sbuf),
"RSA %u-blinding key generation",
len);
GAUGER ("UTIL", sbuf,
64 * 1024 / (1 +
GNUNET_TIME_absolute_get_duration
(start).rel_value_us / 1000LL), "keys/ms");
*/
start = GNUNET_TIME_absolute_get ();
GNUNET_CRYPTO_hash ("test", 4, &hc);
for (i=0;i<10;i++)
{
GNUNET_CRYPTO_rsa_blind (&hc,
&bsec[i],
public_key,
&bbuf, &bbuf_len);
GNUNET_free (bbuf);
}
printf ("10x %u-blinding took %s\n",
len,
GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
GNUNET_YES));
GNUNET_snprintf (sbuf,
sizeof (sbuf),
"RSA %u-blinding",
len);
GAUGER ("UTIL",
sbuf,
64 * 1024 / (1 +
GNUNET_TIME_absolute_get_duration
(start).rel_value_us / 1000LL), "ops/ms");
GNUNET_CRYPTO_rsa_blind (&hc,
&bsec[0],
public_key,
&bbuf, &bbuf_len);
start = GNUNET_TIME_absolute_get ();
for (i=0;i<10;i++)
{
sig = GNUNET_CRYPTO_rsa_sign_blinded (private_key,
bbuf, bbuf_len);
GNUNET_CRYPTO_rsa_signature_free (sig);
}
printf ("10x %u-signing took %s\n",
len,
GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
GNUNET_YES));
GNUNET_snprintf (sbuf,
sizeof (sbuf),
"RSA %u-signing",
len);
GAUGER ("UTIL",
sbuf,
64 * 1024 / (1 +
GNUNET_TIME_absolute_get_duration
(start).rel_value_us / 1000LL), "ops/ms");
sig = GNUNET_CRYPTO_rsa_sign_blinded (private_key,
bbuf,
bbuf_len);
start = GNUNET_TIME_absolute_get ();
for (i=0;i<10;i++)
{
rsig = GNUNET_CRYPTO_rsa_unblind (sig,
&bsec[0],
public_key);
GNUNET_CRYPTO_rsa_signature_free (rsig);
}
printf ("10x %u-unblinding took %s\n",
len,
GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
GNUNET_YES));
GNUNET_snprintf (sbuf,
sizeof (sbuf),
"RSA %u-unblinding",
len);
GAUGER ("UTIL",
sbuf,
64 * 1024 / (1 +
GNUNET_TIME_absolute_get_duration
(start).rel_value_us / 1000LL), "ops/ms");
rsig = GNUNET_CRYPTO_rsa_unblind (sig,
&bsec[0],
public_key);
start = GNUNET_TIME_absolute_get ();
for (i=0;i<10;i++)
{
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_rsa_verify (&hc,
rsig,
public_key));
}
printf ("10x %u-verifying took %s\n",
len,
GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
GNUNET_YES));
GNUNET_snprintf (sbuf,
sizeof (sbuf),
"RSA %u-verification",
len);
GAUGER ("UTIL",
sbuf,
64 * 1024 / (1 +
GNUNET_TIME_absolute_get_duration
(start).rel_value_us / 1000LL), "ops/ms");
GNUNET_CRYPTO_rsa_signature_free (sig);
GNUNET_CRYPTO_rsa_public_key_free (public_key);
GNUNET_CRYPTO_rsa_private_key_free (private_key);
GNUNET_free (bbuf);
}
