/**
* Variable size object (in network byte order, encoded using
* Crockford Base32hex encoding).
*
* @param name name of the JSON field
* @param[out] obj pointer where to write the data, will be allocated
* @param[out] size where to store the number of bytes allocated for @a obj
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_varsize (const char *name,
void **obj,
size_t *size)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_variable_data,
.cleaner = &clean_variable_data,
.cls = NULL,
.field = name,
.ptr = obj,
.ptr_size = 0,
.size_ptr = size
};
*obj = NULL;
*size = 0;
return ret;
}
/**
* Parse given JSON object to string.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_string (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
const char *str;
str = json_string_value (root);
if (NULL == str)
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
*(const char **) spec->ptr = str;
return GNUNET_OK;
}
/**
* The expected field stores a string.
*
* @param name name of the JSON field
* @param strptr where to store a pointer to the field
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_string (const char *name,
const char **strptr)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_string,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = strptr,
.ptr_size = 0,
.size_ptr = NULL
};
*strptr = NULL;
return ret;
}
/**
* Parse given JSON object to a JSON object. (Yes, trivial.)
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_object (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
if (! (json_is_object (root) || json_is_array (root)) )
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
json_incref (root);
*(json_t **) spec->ptr = root;
return GNUNET_OK;
}
/**
* Cleanup data left from parsing JSON object.
*
* @param cls closure, NULL
* @param[out] spec where to free the data
*/
static void
clean_object (void *cls,
struct GNUNET_JSON_Specification *spec)
{
json_t **ptr = (json_t **) spec->ptr;
if (NULL != *ptr)
{
json_decref (*ptr);
*ptr = NULL;
}
}
/**
* JSON object.
*
* @param name name of the JSON field
* @param[out] jsonp where to store the JSON found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_json (const char *name,
json_t **jsonp)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_object,
.cleaner = &clean_object,
.cls = NULL,
.field = name,
.ptr = jsonp,
.ptr_size = 0,
.size_ptr = NULL
};
*jsonp = NULL;
return ret;
}
/**
* Parse given JSON object to a uint8_t.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_u8 (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
json_int_t val;
uint8_t *up = spec->ptr;
if (! json_is_integer (root))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
val = json_integer_value (root);
if ( (0 > val) || (val > UINT8_MAX) )
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
*up = (uint8_t) val;
return GNUNET_OK;
}
/**
* 8-bit integer.
*
* @param name name of the JSON field
* @param[out] u8 where to store the integer found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_uint8 (const char *name,
uint8_t *u8)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_u8,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = u8,
.ptr_size = sizeof (uint8_t),
.size_ptr = NULL
};
return ret;
}
/**
* Parse given JSON object to a uint16_t.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_u16 (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
json_int_t val;
uint16_t *up = spec->ptr;
if (! json_is_integer (root))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
val = json_integer_value (root);
if ( (0 > val) || (val > UINT16_MAX) )
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
*up = (uint16_t) val;
return GNUNET_OK;
}
/**
* 16-bit integer.
*
* @param name name of the JSON field
* @param[out] u16 where to store the integer found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_uint16 (const char *name,
uint16_t *u16)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_u16,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = u16,
.ptr_size = sizeof (uint16_t),
.size_ptr = NULL
};
return ret;
}
/**
* Parse given JSON object to a uint32_t.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_u32 (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
json_int_t val;
uint32_t *up = spec->ptr;
if (! json_is_integer (root))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
val = json_integer_value (root);
if ( (0 > val) || (val > UINT32_MAX) )
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
*up = (uint32_t) val;
return GNUNET_OK;
}
/**
* 32-bit integer.
*
* @param name name of the JSON field
* @param[out] u32 where to store the integer found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_uint32 (const char *name,
uint32_t *u32)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_u32,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = u32,
.ptr_size = sizeof (uint32_t),
.size_ptr = NULL
};
return ret;
}
/**
* Parse given JSON object to a uint8_t.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_u64 (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
json_int_t val;
uint64_t *up = spec->ptr;
if (! json_is_integer (root))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
val = json_integer_value (root);
*up = (uint64_t) val;
return GNUNET_OK;
}
/**
* 64-bit integer.
*
* @param name name of the JSON field
* @param[out] u64 where to store the integer found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_uint64 (const char *name,
uint64_t *u64)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_u64,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = u64,
.ptr_size = sizeof (uint64_t),
.size_ptr = NULL
};
return ret;
}
/* ************ GNUnet-specific parser specifications ******************* */
/**
* Parse given JSON object to absolute time.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_abs_time (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_TIME_Absolute *abs = spec->ptr;
const char *val;
unsigned long long int tval;
val = json_string_value (root);
if (NULL == val)
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
if ( (0 == strcasecmp (val,
"/forever/")) ||
(0 == strcasecmp (val,
"/end of time/")) ||
(0 == strcasecmp (val,
"/never/")) )
{
*abs = GNUNET_TIME_UNIT_FOREVER_ABS;
return GNUNET_OK;
}
if (1 != sscanf (val,
"/Date(%llu)/",
&tval))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
/* Time is in seconds in JSON, but in microseconds in GNUNET_TIME_Absolute */
abs->abs_value_us = tval * 1000LL * 1000LL;
if ( (abs->abs_value_us) / 1000LL / 1000LL != tval)
{
/* Integer overflow */
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
return GNUNET_OK;
}
/**
* Absolute time.
*
* @param name name of the JSON field
* @param[out] at where to store the absolute time found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_absolute_time (const char *name,
struct GNUNET_TIME_Absolute *at)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_abs_time,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = at,
.ptr_size = sizeof (uint64_t),
.size_ptr = NULL
};
return ret;
}
/**
* Parse given JSON object to relative time.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_rel_time (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_TIME_Relative *rel = spec->ptr;
const char *val;
unsigned long long int tval;
val = json_string_value (root);
if (NULL == val)
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
if ( (0 == strcasecmp (val,
"/forever/")) )
{
*rel = GNUNET_TIME_UNIT_FOREVER_REL;
return GNUNET_OK;
}
if (1 != sscanf (val,
"/Delay(%llu)/",
&tval))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
/* Time is in seconds in JSON, but in microseconds in GNUNET_TIME_Relative */
rel->rel_value_us = tval * 1000LL * 1000LL;
if ( (rel->rel_value_us) / 1000LL / 1000LL != tval)
{
/* Integer overflow */
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
return GNUNET_OK;
}
/**
* Relative time.
*
* @param name name of the JSON field
* @param[out] rt where to store the relative time found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_relative_time (const char *name,
struct GNUNET_TIME_Relative *rt)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_rel_time,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = rt,
.ptr_size = sizeof (uint64_t),
.size_ptr = NULL
};
return ret;
}
/**
* Parse given JSON object to RSA public key.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_rsa_public_key (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_CRYPTO_RsaPublicKey **pk = spec->ptr;
const char *enc;
char *buf;
size_t len;
size_t buf_len;
if (NULL == (enc = json_string_value (root)))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
len = strlen (enc);
buf_len = (len * 5) / 8;
buf = GNUNET_malloc (buf_len);
if (GNUNET_OK !=
GNUNET_STRINGS_string_to_data (enc,
len,
buf,
buf_len))
{
GNUNET_break_op (0);
GNUNET_free (buf);
return GNUNET_SYSERR;
}
if (NULL == (*pk = GNUNET_CRYPTO_rsa_public_key_decode (buf,
buf_len)))
{
GNUNET_break_op (0);
GNUNET_free (buf);
return GNUNET_SYSERR;
}
GNUNET_free (buf);
return GNUNET_OK;
}
/**
* Cleanup data left from parsing RSA public key.
*
* @param cls closure, NULL
* @param[out] spec where to free the data
*/
static void
clean_rsa_public_key (void *cls,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_CRYPTO_RsaPublicKey **pk = spec->ptr;
if (NULL != *pk)
{
GNUNET_CRYPTO_rsa_public_key_free (*pk);
*pk = NULL;
}
}
/**
* Specification for parsing an RSA public key.
*
* @param name name of the JSON field
* @param pk where to store the RSA key found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_rsa_public_key (const char *name,
struct GNUNET_CRYPTO_RsaPublicKey **pk)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_rsa_public_key,
.cleaner = &clean_rsa_public_key,
.cls = NULL,
.field = name,
.ptr = pk,
.ptr_size = 0,
.size_ptr = NULL
};
*pk = NULL;
return ret;
}
/**
* Parse given JSON object to RSA signature.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_rsa_signature (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_CRYPTO_RsaSignature **sig = spec->ptr;
size_t size;
const char *str;
int res;
void *buf;
str = json_string_value (root);
if (NULL == str)
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
size = (strlen (str) * 5) / 8;
buf = GNUNET_malloc (size);
res = GNUNET_STRINGS_string_to_data (str,
strlen (str),
buf,
size);
if (GNUNET_OK != res)
{
GNUNET_free (buf);
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
if (NULL == (*sig = GNUNET_CRYPTO_rsa_signature_decode (buf,
size)))
{
GNUNET_break_op (0);
GNUNET_free (buf);
return GNUNET_SYSERR;
}
GNUNET_free (buf);
return GNUNET_OK;
}
/**
* Cleanup data left from parsing RSA signature.
*
* @param cls closure, NULL
* @param[out] spec where to free the data
*/
static void
clean_rsa_signature (void *cls,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_CRYPTO_RsaSignature **sig = spec->ptr;
if (NULL != *sig)
{
GNUNET_CRYPTO_rsa_signature_free (*sig);
*sig = NULL;
}
}
/**
* Specification for parsing an RSA signature.
*
* @param name name of the JSON field
* @param sig where to store the RSA signature found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_rsa_signature (const char *name,
struct GNUNET_CRYPTO_RsaSignature **sig)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_rsa_signature,
.cleaner = &clean_rsa_signature,
.cls = NULL,
.field = name,
.ptr = sig,
.ptr_size = 0,
.size_ptr = NULL
};
*sig = NULL;
return ret;
}
/**
* 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);
}
