/** * Sign the given message. * * @param key private key to use for the signing * @param msg the message to sign * @param msg_len number of bytes in @a msg to sign * @return NULL on error, signature on success */ struct GNUNET_CRYPTO_rsa_Signature * GNUNET_CRYPTO_rsa_sign (const struct GNUNET_CRYPTO_rsa_PrivateKey *key, const void *msg, size_t msg_len) { struct GNUNET_CRYPTO_rsa_Signature *sig; struct GNUNET_CRYPTO_rsa_PublicKey *public_key; gcry_sexp_t result; gcry_sexp_t data; data = data_to_sexp (msg, msg_len); if (0 != gcry_pk_sign (&result, data, key->sexp)) { GNUNET_break (0); return NULL; } /* verify signature (guards against Lenstra's attack with fault injection...) */ public_key = GNUNET_CRYPTO_rsa_private_key_get_public (key); if (0 != gcry_pk_verify (result, data, public_key->sexp)) { GNUNET_break (0); GNUNET_CRYPTO_rsa_public_key_free (public_key); gcry_sexp_release (data); gcry_sexp_release (result); return NULL; } GNUNET_CRYPTO_rsa_public_key_free (public_key); /* return signature */ gcry_sexp_release (data); sig = GNUNET_new (struct GNUNET_CRYPTO_rsa_Signature); sig->sexp = result; return sig; }
/** * 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; }
/** * 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; }
/** * 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); }