static int
testCreateFromFile ()
{
struct GNUNET_CRYPTO_RsaPrivateKey *key;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded p1;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded p2;
key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE);
GNUNET_assert (NULL != key);
GNUNET_CRYPTO_rsa_key_get_public (key, &p1);
GNUNET_CRYPTO_rsa_key_free (key);
key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE);
GNUNET_assert (NULL != key);
GNUNET_CRYPTO_rsa_key_get_public (key, &p2);
GNUNET_assert (0 == memcmp (&p1, &p2, sizeof (p1)));
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_assert (0 == UNLINK (KEYFILE));
key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE);
GNUNET_assert (NULL != key);
GNUNET_CRYPTO_rsa_key_get_public (key, &p2);
GNUNET_assert (0 != memcmp (&p1, &p2, sizeof (p1)));
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_assert (0 == UNLINK (KEYFILE));
return GNUNET_OK;
}
static int
setup_alice (const struct GNUNET_CONFIGURATION_Handle * cfg)
{
char* keyfile;
struct GNUNET_CRYPTO_RsaPrivateKey *key;
struct GNUNET_NAMESTORE_RecordData rd;
cfg_handles[2] = GNUNET_CONFIGURATION_dup (cfg);
GNUNET_assert (NULL != cfg);
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
return GNUNET_SYSERR;
}
key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
if (NULL == key)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
nh[2] = GNUNET_NAMESTORE_connect (cfg_handles[2]);
if (NULL == nh[2])
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
rd.expiration_time = UINT64_MAX;
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNS_RECORD_PKEY;
rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
GNUNET_NAMESTORE_record_create (nh[2], key, "bob", &rd, &cont_ns, nh[2]);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up alice gns\n");
gh = GNUNET_GNS_connect (cfg_handles[2]);
if (NULL == gh)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to gns\n");
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_free (keyfile);
alice_is_setup = GNUNET_YES;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up alice done\n");
return GNUNET_OK;
}
/**
* Create a flat file with a large number of key pairs for testing.
*/
static void
create_keys (const char *fn)
{
FILE *f;
struct GNUNET_CRYPTO_RsaPrivateKey *pk;
struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *enc;
if (NULL == (f = fopen (fn, "w+")))
{
fprintf (stderr,
_("Failed to open `%s': %s\n"),
fn,
STRERROR (errno));
return;
}
fprintf (stderr,
_("Generating %u keys, please wait"),
make_keys);
while (0 < make_keys--)
{
fprintf (stderr,
".");
if (NULL == (pk = rsa_key_create ()))
{
GNUNET_break (0);
break;
}
enc = GNUNET_CRYPTO_rsa_encode_key (pk);
if (GNUNET_TESTING_HOSTKEYFILESIZE != htons (enc->len))
{
/* sometimes we get a different key length because 'd' or 'u' start
with leading bits; skip those... */
GNUNET_CRYPTO_rsa_key_free (pk);
GNUNET_free (enc);
make_keys++;
continue;
}
if (htons (enc->len) != fwrite (enc, 1, htons (enc->len), f))
{
fprintf (stderr,
_("\nFailed to write to `%s': %s\n"),
fn,
STRERROR (errno));
GNUNET_CRYPTO_rsa_key_free (pk);
GNUNET_free (enc);
break;
}
GNUNET_CRYPTO_rsa_key_free (pk);
GNUNET_free (enc);
}
if (0 == make_keys)
fprintf (stderr,
_("Finished!\n"));
fclose (f);
}
static void
end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (stopiteration_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (stopiteration_task);
stopiteration_task = GNUNET_SCHEDULER_NO_TASK;
}
if (endbadly_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (endbadly_task);
endbadly_task = GNUNET_SCHEDULER_NO_TASK;
}
if (privkey != NULL)
GNUNET_CRYPTO_rsa_key_free (privkey);
privkey = NULL;
if (privkey2 != NULL)
GNUNET_CRYPTO_rsa_key_free (privkey2);
privkey2 = NULL;
GNUNET_free (sig_1);
GNUNET_free (sig_2);
GNUNET_free (sig_3);
GNUNET_free (s_name_1);
GNUNET_free (s_name_2);
GNUNET_free (s_name_3);
if (s_rd_1 != NULL)
{
GNUNET_free ((void *)s_rd_1->data);
GNUNET_free (s_rd_1);
}
if (s_rd_2 != NULL)
{
GNUNET_free ((void *)s_rd_2->data);
GNUNET_free (s_rd_2);
}
if (s_rd_3 != NULL)
{
GNUNET_free ((void *)s_rd_3->data);
GNUNET_free (s_rd_3);
}
if (nsh != NULL)
GNUNET_NAMESTORE_disconnect (nsh);
nsh = NULL;
if (returned_records == 1)
res = 0;
else
res = 1;
}
static void
end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (endbadly_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (endbadly_task);
endbadly_task = GNUNET_SCHEDULER_NO_TASK;
}
int c;
for (c = 0; c < RECORDS; c++)
GNUNET_free_non_null((void *) s_rd[c].data);
GNUNET_free (s_rd);
if (privkey != NULL)
GNUNET_CRYPTO_rsa_key_free (privkey);
privkey = NULL;
if (nsh != NULL)
GNUNET_NAMESTORE_disconnect (nsh, GNUNET_YES);
nsh = NULL;
if (NULL != arm)
stop_arm();
}
static int
testSignPerformance ()
{
struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
struct GNUNET_CRYPTO_RsaSignaturePurpose purp;
struct GNUNET_CRYPTO_RsaSignature sig;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
int i;
struct GNUNET_TIME_Absolute start;
int ok = GNUNET_OK;
purp.size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose));
purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
FPRINTF (stderr, "%s", "W");
hostkey = GNUNET_CRYPTO_rsa_key_create ();
GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
start = GNUNET_TIME_absolute_get ();
for (i = 0; i < ITER; i++)
{
FPRINTF (stderr, "%s", ".");
if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_sign (hostkey, &purp, &sig))
{
FPRINTF (stderr, "%s", "GNUNET_CRYPTO_rsa_sign returned SYSERR\n");
ok = GNUNET_SYSERR;
continue;
}
}
printf ("%d RSA sign operations %llu ms\n", ITER,
(unsigned long long)
GNUNET_TIME_absolute_get_duration (start).rel_value);
GNUNET_CRYPTO_rsa_key_free (hostkey);
return ok;
}
/**
* Function called when the service shuts down. Unloads our plugins
* and cancels pending validations.
*
* @param cls closure, unused
* @param tc task context (unused)
*/
static void
shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GST_neighbours_stop ();
GST_validation_stop ();
GST_plugins_unload ();
GNUNET_ATS_scheduling_done (GST_ats);
GST_ats = NULL;
GST_clients_stop ();
GST_blacklist_stop ();
GST_hello_stop ();
if (GST_peerinfo != NULL)
{
GNUNET_PEERINFO_disconnect (GST_peerinfo);
GST_peerinfo = NULL;
}
if (GST_stats != NULL)
{
GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO);
GST_stats = NULL;
}
if (GST_my_private_key != NULL)
{
GNUNET_CRYPTO_rsa_key_free (GST_my_private_key);
GST_my_private_key = NULL;
}
}
/**
* Main function that will be run by the scheduler.
*
* @param cls closure
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
struct GNUNET_CRYPTO_RsaPrivateKey *priv;
char *fn;
cfg = c;
if ( (NULL != args[0]) &&
(NULL == put_uri) &&
(args[0] == strcasestr (args[0], "gnunet://hello/")) )
{
put_uri = GNUNET_strdup (args[0]);
args++;
}
if (NULL != args[0])
{
FPRINTF (stderr,
_("Invalid command line argument `%s'\n"),
args[0]);
return;
}
if (NULL == (peerinfo = GNUNET_PEERINFO_connect (cfg)))
{
FPRINTF (stderr, "%s", _("Could not access PEERINFO service. Exiting.\n"));
return;
}
if ( (GNUNET_YES == get_self) || (GNUNET_YES == get_uri) )
{
/* load private key */
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "GNUNETD", "HOSTKEY",
&fn))
{
FPRINTF (stderr, _("Could not find option `%s:%s' in configuration.\n"),
"GNUNETD", "HOSTKEYFILE");
return;
}
if (NULL == (priv = GNUNET_CRYPTO_rsa_key_create_from_file (fn)))
{
FPRINTF (stderr, _("Loading hostkey from `%s' failed.\n"), fn);
GNUNET_free (fn);
return;
}
GNUNET_free (fn);
GNUNET_CRYPTO_rsa_key_get_public (priv, &my_public_key);
GNUNET_CRYPTO_rsa_key_free (priv);
GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key), &my_peer_identity.hashPubKey);
}
tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
}
static int
testEncryptDecryptSK ()
{
struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
struct GNUNET_CRYPTO_RsaEncryptedData target;
struct GNUNET_CRYPTO_AesSessionKey insk;
struct GNUNET_CRYPTO_AesSessionKey outsk;
int i;
struct GNUNET_TIME_Absolute start;
int ok;
FPRINTF (stderr, "%s", "W");
hostkey = GNUNET_CRYPTO_rsa_key_create ();
GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
ok = 0;
start = GNUNET_TIME_absolute_get ();
for (i = 0; i < ITER; i++)
{
FPRINTF (stderr, "%s", ".");
GNUNET_CRYPTO_aes_create_session_key (&insk);
if (GNUNET_SYSERR ==
GNUNET_CRYPTO_rsa_encrypt (&insk,
sizeof (struct GNUNET_CRYPTO_AesSessionKey),
&pkey, &target))
{
FPRINTF (stderr, "%s", "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
ok++;
continue;
}
if (-1 ==
GNUNET_CRYPTO_rsa_decrypt (hostkey, &target, &outsk,
sizeof (struct GNUNET_CRYPTO_AesSessionKey)))
{
FPRINTF (stderr, "%s", "GNUNET_CRYPTO_rsa_decrypt returned SYSERR\n");
ok++;
continue;
}
if (0 !=
memcmp (&insk, &outsk, sizeof (struct GNUNET_CRYPTO_AesSessionKey)))
{
printf ("testEncryptDecryptSK failed!\n");
ok++;
continue;
}
}
printf ("%d RSA encrypt/decrypt SK operations %llums (%d failures)\n", ITER,
(unsigned long long)
GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
GNUNET_CRYPTO_rsa_key_free (hostkey);
if (ok != 0)
return GNUNET_SYSERR;
return GNUNET_OK;
}
static int
testEncryptDecrypt ()
{
struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
struct GNUNET_CRYPTO_RsaEncryptedData target;
char result[MAX_TESTVAL];
int i;
struct GNUNET_TIME_Absolute start;
int ok;
FPRINTF (stderr, "%s", "W");
hostkey = GNUNET_CRYPTO_rsa_key_create ();
GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
ok = 0;
start = GNUNET_TIME_absolute_get ();
for (i = 0; i < ITER; i++)
{
FPRINTF (stderr, "%s", ".");
if (GNUNET_SYSERR ==
GNUNET_CRYPTO_rsa_encrypt (TESTSTRING, strlen (TESTSTRING) + 1, &pkey,
&target))
{
FPRINTF (stderr, "%s", "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
ok++;
continue;
}
if (-1 ==
GNUNET_CRYPTO_rsa_decrypt (hostkey, &target, result,
strlen (TESTSTRING) + 1))
{
FPRINTF (stderr, "%s", "GNUNET_CRYPTO_rsa_decrypt returned SYSERR\n");
ok++;
continue;
}
if (strncmp (TESTSTRING, result, strlen (TESTSTRING)) != 0)
{
printf ("%s != %.*s - testEncryptDecrypt failed!\n", TESTSTRING,
(int) MAX_TESTVAL, result);
ok++;
continue;
}
}
printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n", ITER,
(unsigned long long)
GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
GNUNET_CRYPTO_rsa_key_free (hostkey);
if (ok == 0)
return GNUNET_OK;
else
return GNUNET_SYSERR;
}
/**
* Main function that will be run by the scheduler.
*
* @param cls closure
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param cfg configuration
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_CRYPTO_RsaPrivateKey *pk;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
struct GNUNET_PeerIdentity pid;
if (NULL == args[0])
{
fprintf (stderr, _("No hostkey file specified on command line\n"));
return;
}
if (0 != weak_random)
GNUNET_CRYPTO_random_disable_entropy_gathering ();
if (make_keys > 0)
{
create_keys (args[0]);
return;
}
pk = GNUNET_CRYPTO_rsa_key_create_from_file (args[0]);
if (NULL == pk)
return;
if (print_public_key)
{
char *s;
GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
s = GNUNET_CRYPTO_rsa_public_key_to_string (&pub);
fprintf (stdout, "%s\n", s);
GNUNET_free (s);
}
if (print_peer_identity)
{
struct GNUNET_CRYPTO_HashAsciiEncoded enc;
GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
GNUNET_CRYPTO_hash (&pub, sizeof (pub), &pid.hashPubKey);
GNUNET_CRYPTO_hash_to_enc (&pid.hashPubKey, &enc);
fprintf (stdout, "%s\n", enc.encoding);
}
if (print_short_identity)
{
struct GNUNET_CRYPTO_ShortHashAsciiEncoded enc;
struct GNUNET_CRYPTO_ShortHashCode sh;
GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
GNUNET_CRYPTO_short_hash (&pub, sizeof (pub), &sh);
GNUNET_CRYPTO_short_hash_to_enc (&sh, &enc);
fprintf (stdout, "%s\n", enc.short_encoding);
}
GNUNET_CRYPTO_rsa_key_free (pk);
}
static void
do_check (void *cls,
const struct GNUNET_CONFIGURATION_Handle *ccfg,
struct GNUNET_TESTING_Peer *peer)
{
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
struct GNUNET_NAMESTORE_RecordData rd;
char* alice_keyfile;
char* ip = TEST_IP;
struct in_addr web;
cfg = ccfg;
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
/* put records into namestore */
namestore_handle = GNUNET_NAMESTORE_connect(cfg);
if (NULL == namestore_handle)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to connect to namestore\n");
end_badly_now ();
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&alice_keyfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to get key from cfg\n");
end_badly_now ();
return;
}
alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
GNUNET_free (alice_keyfile);
rd.expiration_time = UINT64_MAX;
GNUNET_assert (1 == inet_pton (AF_INET, ip, &web));
rd.data_size = sizeof(struct in_addr);
rd.data = &web;
rd.record_type = GNUNET_DNSPARSER_TYPE_A;
rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
nsqe = GNUNET_NAMESTORE_record_create (namestore_handle,
alice_key,
TEST_RECORD_NAME,
&rd,
&commence_testing,
NULL);
GNUNET_CRYPTO_rsa_key_free (alice_key);
}
static void
cleanup ()
{
if (NULL != nsh)
{
GNUNET_NAMESTORE_disconnect (nsh);
nsh = NULL;
}
if (NULL != privkey)
{
GNUNET_CRYPTO_rsa_key_free (privkey);
privkey = NULL;
}
GNUNET_SCHEDULER_shutdown ();
}
/**
* Re-establish the connection to the service.
*
* @param cls handle to use to re-connect.
* @param tc scheduler context
*/
static void
endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (nsh != NULL)
GNUNET_NAMESTORE_disconnect (nsh, GNUNET_YES);
nsh = NULL;
if (privkey != NULL)
GNUNET_CRYPTO_rsa_key_free (privkey);
privkey = NULL;
if (NULL != arm)
stop_arm();
res = 1;
}
/**
* Continuation of "GNUNET_FS_publish_ksk" that performs the actual
* publishing operation (iterating over all of the keywords).
*
* @param cls closure of type "struct GNUNET_FS_PublishKskContext*"
* @param tc unused
*/
static void
publish_ksk_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_FS_PublishKskContext *pkc = cls;
const char *keyword;
GNUNET_HashCode key;
GNUNET_HashCode query;
struct GNUNET_CRYPTO_AesSessionKey skey;
struct GNUNET_CRYPTO_AesInitializationVector iv;
struct GNUNET_CRYPTO_RsaPrivateKey *pk;
pkc->ksk_task = GNUNET_SCHEDULER_NO_TASK;
if ((pkc->i == pkc->ksk_uri->data.ksk.keywordCount) || (NULL == pkc->dsh))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "KSK PUT operation complete\n");
pkc->cont (pkc->cont_cls, pkc->ksk_uri, NULL);
GNUNET_FS_publish_ksk_cancel (pkc);
return;
}
keyword = pkc->ksk_uri->data.ksk.keywords[pkc->i++];
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing under keyword `%s'\n",
&keyword[1]);
/* first character of keyword indicates if it is
* mandatory or not -- ignore for hashing */
GNUNET_CRYPTO_hash (&keyword[1], strlen (&keyword[1]), &key);
GNUNET_CRYPTO_hash_to_aes_key (&key, &skey, &iv);
GNUNET_CRYPTO_aes_encrypt (&pkc->kb[1], pkc->slen + pkc->mdsize, &skey, &iv,
&pkc->cpy[1]);
pk = GNUNET_CRYPTO_rsa_key_create_from_hash (&key);
GNUNET_assert (NULL != pk);
GNUNET_CRYPTO_rsa_key_get_public (pk, &pkc->cpy->keyspace);
GNUNET_CRYPTO_hash (&pkc->cpy->keyspace,
sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
&query);
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_rsa_sign (pk, &pkc->cpy->purpose,
&pkc->cpy->signature));
GNUNET_CRYPTO_rsa_key_free (pk);
pkc->qre =
GNUNET_DATASTORE_put (pkc->dsh, 0, &query,
pkc->mdsize + sizeof (struct KBlock) + pkc->slen,
pkc->cpy, GNUNET_BLOCK_TYPE_FS_KBLOCK,
pkc->bo.content_priority, pkc->bo.anonymity_level,
pkc->bo.replication_level, pkc->bo.expiration_time,
-2, 1, GNUNET_CONSTANTS_SERVICE_TIMEOUT,
&kb_put_cont, pkc);
}
/**
* Leave a chat room.
*/
void
GNUNET_CHAT_leave_room (struct GNUNET_CHAT_Room *chat_room)
{
struct MemberList *pos;
#if DEBUG_CHAT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Leaving the room '%s'\n",
chat_room->room_name);
#endif
GNUNET_CLIENT_disconnect (chat_room->client);
GNUNET_free (chat_room->room_name);
GNUNET_CONTAINER_meta_data_destroy (chat_room->member_info);
GNUNET_CRYPTO_rsa_key_free (chat_room->my_private_key);
while (NULL != chat_room->members)
{
pos = chat_room->members;
chat_room->members = pos->next;
GNUNET_CONTAINER_meta_data_destroy (pos->meta);
GNUNET_free (pos);
}
GNUNET_free (chat_room);
}
static void
end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (endbadly_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (endbadly_task);
endbadly_task = GNUNET_SCHEDULER_NO_TASK;
}
if (privkey != NULL)
GNUNET_CRYPTO_rsa_key_free (privkey);
privkey = NULL;
if (nsh != NULL)
GNUNET_NAMESTORE_disconnect (nsh, GNUNET_YES);
nsh = NULL;
if (NULL != arm)
stop_arm();
res = 0;
}
static int
testEncryptPerformance ()
{
struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
struct GNUNET_CRYPTO_RsaEncryptedData target;
int i;
struct GNUNET_TIME_Absolute start;
int ok;
FPRINTF (stderr, "%s", "W");
hostkey = GNUNET_CRYPTO_rsa_key_create ();
GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
ok = 0;
start = GNUNET_TIME_absolute_get ();
for (i = 0; i < ITER; i++)
{
FPRINTF (stderr, "%s", ".");
if (GNUNET_SYSERR ==
GNUNET_CRYPTO_rsa_encrypt (TESTSTRING, strlen (TESTSTRING) + 1, &pkey,
&target))
{
FPRINTF (stderr, "%s", "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
ok++;
continue;
}
}
printf ("%d RSA encrypt operations %llu ms (%d failures)\n", ITER,
(unsigned long long)
GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
GNUNET_CRYPTO_rsa_key_free (hostkey);
if (ok != 0)
return GNUNET_SYSERR;
return GNUNET_OK;
}
static void
do_check (void *cls,
const struct GNUNET_CONFIGURATION_Handle *ccfg,
struct GNUNET_TESTING_Peer *peer)
{
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
struct GNUNET_CRYPTO_ShortHashCode bob_hash;
struct GNUNET_CRYPTO_RsaSignature *sig;
char* alice_keyfile;
struct srv_data *srv_data;
struct GNUNET_TIME_Absolute et;
cfg = ccfg;
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
/* put records into namestore */
namestore_handle = GNUNET_NAMESTORE_connect(cfg);
if (NULL == namestore_handle)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
end_badly_now();
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&alice_keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
end_badly_now();
return;
}
alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
struct GNUNET_NAMESTORE_RecordData rd;
char* ip = TEST_IP;
struct in_addr *sipserver = GNUNET_malloc (sizeof (struct in_addr));
srv_data = GNUNET_malloc (sizeof (struct srv_data) + strlen (TEST_SRV_NAME) + 1);
uint16_t srv_weight = 60;
uint16_t srv_prio = 50;
uint16_t srv_port = 5060;
rd.expiration_time = UINT64_MAX;
GNUNET_assert(1 == inet_pton (AF_INET, ip, sipserver));
GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash);
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNS_RECORD_PKEY;
rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
GNUNET_NAMESTORE_record_create (namestore_handle,
alice_key,
TEST_AUTHORITY_NAME,
&rd,
NULL,
NULL);
rd.data_size = sizeof (struct in_addr);
rd.data = sipserver;
rd.record_type = GNUNET_DNSPARSER_TYPE_A;
sig = GNUNET_NAMESTORE_create_signature(bob_key,
GNUNET_TIME_UNIT_FOREVER_ABS,
TEST_RECORD_NAME,
&rd, 1);
et.abs_value = rd.expiration_time;
GNUNET_NAMESTORE_record_put (namestore_handle,
&bob_pkey,
TEST_RECORD_NAME,
et,
1,
&rd,
sig,
NULL,
NULL);
GNUNET_free (sig);
rd.data_size = sizeof (struct srv_data)+strlen(TEST_SRV_NAME)+1;
srv_data->port = srv_port;
srv_data->prio = srv_prio;
srv_data->weight = srv_weight;
strcpy((char*)&srv_data[1], TEST_SRV_NAME);
rd.data = srv_data;
rd.record_type = GNUNET_GNS_RECORD_SRV;
sig = GNUNET_NAMESTORE_create_signature(bob_key,
GNUNET_TIME_UNIT_FOREVER_ABS,
TEST_RECORD_NAME_SRV,
&rd, 1);
et.abs_value = rd.expiration_time;
GNUNET_NAMESTORE_record_put (namestore_handle,
&bob_pkey,
TEST_RECORD_NAME_SRV,
et,
1,
&rd,
sig,
&commence_testing,
NULL);
GNUNET_free (alice_keyfile);
GNUNET_free (srv_data);
GNUNET_free (sipserver);
GNUNET_free (sig);
GNUNET_CRYPTO_rsa_key_free (bob_key);
GNUNET_CRYPTO_rsa_key_free (alice_key);
}
static void
do_lookup(void *cls, const struct GNUNET_PeerIdentity *id,
const struct GNUNET_CONFIGURATION_Handle *_cfg,
struct GNUNET_TESTING_Daemon *d, const char *emsg)
{
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
struct GNUNET_CRYPTO_RsaSignature *sig;
char* alice_keyfile;
cfg = _cfg;
GNUNET_SCHEDULER_cancel (die_task);
/* put records into namestore */
namestore_handle = GNUNET_NAMESTORE_connect(cfg);
if (NULL == namestore_handle)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
ok = -1;
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&alice_keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
ok = -1;
return;
}
alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
struct GNUNET_NAMESTORE_RecordData rd;
char* ip = TEST_IP;
struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr));
rd.expiration = GNUNET_TIME_UNIT_FOREVER_ABS;
GNUNET_assert(1 == inet_pton (AF_INET, ip, web));
GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash);
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNS_RECORD_PKEY;
GNUNET_NAMESTORE_record_create (namestore_handle,
alice_key,
TEST_AUTHORITY_NAME,
&rd,
NULL,
NULL);
rd.data_size = sizeof(struct in_addr);
rd.data = web;
rd.record_type = GNUNET_DNSPARSER_TYPE_A;
sig = GNUNET_NAMESTORE_create_signature(bob_key,
GNUNET_TIME_UNIT_FOREVER_ABS,
TEST_RECORD_NAME,
&rd, 1);
GNUNET_NAMESTORE_record_put (namestore_handle,
&bob_pkey,
TEST_RECORD_NAME,
rd.expiration,
1,
&rd,
sig,
&commence_testing,
NULL);
GNUNET_free(sig);
GNUNET_CRYPTO_rsa_key_free(bob_key);
GNUNET_CRYPTO_rsa_key_free(alice_key);
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
enum MHD_FLAG flags;
struct GNUNET_CRYPTO_RsaPrivateKey *host_key;
struct GNUNET_NAMESTORE_RecordData rd;
char *zone_keyfile;
namestore = GNUNET_NAMESTORE_connect (cfg);
GNUNET_assert (NULL != namestore);
flags = MHD_USE_DEBUG;
mhd = MHD_start_daemon (flags,
PORT,
NULL, NULL,
&mhd_ahc, NULL,
MHD_OPTION_END);
GNUNET_assert (NULL != mhd);
mhd_main ();
tmp_cfgfile = GNUNET_DISK_mktemp ("test_gns_proxy_tmp.conf");
if (NULL == tmp_cfgfile)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to create tmp cfg!\n");
do_shutdown ();
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_write ((struct GNUNET_CONFIGURATION_Handle *)cfg,
tmp_cfgfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to write tmp cfg\n");
do_shutdown ();
return;
}
proxy_proc = GNUNET_OS_start_process (GNUNET_NO,
GNUNET_OS_INHERIT_STD_ALL,
NULL,
NULL,
"gnunet-gns-proxy",
"gnunet-gns-proxy",
"-c", tmp_cfgfile, NULL);
if (NULL == proxy_proc)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Unable to start proxy\n");
do_shutdown ();
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&zone_keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
return;
}
host_key = GNUNET_CRYPTO_rsa_key_create_from_file (zone_keyfile);
rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value;
GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_string_to_value (GNUNET_GNS_RECORD_A,
"127.0.0.1",
(void**)&rd.data,
&rd.data_size));
rd.record_type = GNUNET_GNS_RECORD_A;
GNUNET_NAMESTORE_record_create (namestore,
host_key,
"www",
&rd,
&commence_testing,
NULL);
GNUNET_free ((void**)rd.data);
GNUNET_free (zone_keyfile);
GNUNET_CRYPTO_rsa_key_free (host_key);
}
void do_check (void *cls,
const struct GNUNET_CONFIGURATION_Handle *ccfg,
struct GNUNET_TESTING_Peer *peer)
{
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded our_pkey;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
struct GNUNET_CRYPTO_RsaPrivateKey *our_key;
struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
struct GNUNET_CRYPTO_ShortHashCode bob_hash;
struct GNUNET_CRYPTO_ShortHashCode alice_hash;
struct GNUNET_CRYPTO_RsaSignature *sig;
char* our_keyfile;
cfg = ccfg;
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running test\n");
/* put records into namestore */
namestore_handle = GNUNET_NAMESTORE_connect(cfg);
if (NULL == namestore_handle)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
end_badly_now();
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&our_keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
end_badly_now();
return;
}
our_key = GNUNET_CRYPTO_rsa_key_create_from_file (our_keyfile);
GNUNET_free(our_keyfile);
bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_ALICE);
GNUNET_CRYPTO_rsa_key_get_public (our_key, &our_pkey);
GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
struct GNUNET_NAMESTORE_RecordData rd;
char* ip = TEST_IP;
struct in_addr *web = GNUNET_malloc (sizeof(struct in_addr));
rd.expiration_time = UINT64_MAX;
GNUNET_assert (1 == inet_pton (AF_INET, ip, web));
GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash);
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNS_RECORD_PKEY;
rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
/* put bob into our zone */
GNUNET_NAMESTORE_record_create (namestore_handle,
our_key,
TEST_AUTHORITY_BOB,
&rd,
NULL,
NULL);
/* put alice into bobs zone */
GNUNET_CRYPTO_short_hash(&alice_pkey, sizeof(alice_pkey), &alice_hash);
rd.data = &alice_hash;
sig = GNUNET_NAMESTORE_create_signature(bob_key, GNUNET_TIME_UNIT_FOREVER_ABS, TEST_AUTHORITY_ALICE,
&rd, 1);
GNUNET_NAMESTORE_record_put (namestore_handle,
&bob_pkey,
TEST_AUTHORITY_ALICE,
GNUNET_TIME_UNIT_FOREVER_ABS,
1,
&rd,
sig,
NULL,
NULL);
GNUNET_free (sig);
/* put www A record and PSEU into alice's zone */
rd.data_size = sizeof(struct in_addr);
rd.data = web;
rd.record_type = GNUNET_DNSPARSER_TYPE_A;
sig = GNUNET_NAMESTORE_create_signature(alice_key,GNUNET_TIME_UNIT_FOREVER_ABS, TEST_RECORD_NAME,
&rd, 1);
GNUNET_NAMESTORE_record_put (namestore_handle,
&alice_pkey,
TEST_RECORD_NAME,
GNUNET_TIME_UNIT_FOREVER_ABS,
1,
&rd,
sig,
NULL,
NULL);
rd.data_size = strlen(TEST_ALICE_PSEU);
rd.data = TEST_ALICE_PSEU;
rd.record_type = GNUNET_GNS_RECORD_PSEU;
GNUNET_free(sig);
sig = GNUNET_NAMESTORE_create_signature(alice_key,GNUNET_TIME_UNIT_FOREVER_ABS, "",
&rd, 1);
GNUNET_NAMESTORE_record_put (namestore_handle,
&alice_pkey,
"",
GNUNET_TIME_UNIT_FOREVER_ABS,
1,
&rd,
sig,
&commence_testing,
NULL);
GNUNET_free (web);
GNUNET_free (sig);
GNUNET_CRYPTO_rsa_key_free (alice_key);
GNUNET_CRYPTO_rsa_key_free (bob_key);
GNUNET_CRYPTO_rsa_key_free (our_key);
}
static int
setup_dave (const struct GNUNET_CONFIGURATION_Handle * cfg)
{
char* keyfile;
struct GNUNET_CRYPTO_RsaPrivateKey *key;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
struct in_addr *web;
struct GNUNET_NAMESTORE_RecordData rd;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up dave\n");
cfg_handles[0] = GNUNET_CONFIGURATION_dup (cfg);
GNUNET_assert (NULL != cfg_handles[0]);
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
return GNUNET_SYSERR;
}
key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
if (NULL == key)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
nh[0] = GNUNET_NAMESTORE_connect (cfg_handles[0]);
if (NULL == nh[0])
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
GNUNET_CRYPTO_short_hash(&pkey, sizeof(pkey), &dave_hash);
rd.expiration_time = UINT64_MAX;
web = GNUNET_malloc(sizeof(struct in_addr));
GNUNET_assert(1 == inet_pton (AF_INET, TEST_IP, web));
rd.data_size = sizeof(struct in_addr);
rd.data = web;
rd.record_type = GNUNET_GNS_RECORD_A;
rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
GNUNET_NAMESTORE_record_create (nh[0], key, "www", &rd, NULL, NULL);
rd.data_size = strlen(TEST_DAVE_PSEU);
rd.data = TEST_DAVE_PSEU;
rd.record_type = GNUNET_GNS_RECORD_PSEU;
GNUNET_NAMESTORE_record_create (nh[0], key, GNUNET_GNS_MASTERZONE_STR, &rd, &cont_ns, nh[0]);
GNUNET_CRYPTO_rsa_key_free(key);
GNUNET_free(keyfile);
GNUNET_free(web);
dave_is_setup = GNUNET_YES;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up dave done\n");
return GNUNET_OK;
}