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 void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
char *hostkey_file;
struct GNUNET_TIME_Absolute et;
endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,&endbadly, NULL);
GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
"N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
GNUNET_free (hostkey_file);
GNUNET_assert (privkey != NULL);
GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
GNUNET_CRYPTO_hash(&pubkey, sizeof (pubkey), &zone);
GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
"HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
privkey2 = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
GNUNET_free (hostkey_file);
GNUNET_assert (privkey2 != NULL);
GNUNET_CRYPTO_rsa_key_get_public(privkey2, &pubkey2);
GNUNET_CRYPTO_hash(&pubkey2, sizeof (pubkey), &zone2);
nsh = GNUNET_NAMESTORE_connect (cfg);
GNUNET_break (NULL != nsh);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record 1\n");
GNUNET_asprintf(&s_name_1, "dummy1");
s_rd_1 = create_record(1);
et.abs_value = s_rd_1[0].expiration_time;
sig_1 = GNUNET_NAMESTORE_create_signature(privkey, et, s_name_1, s_rd_1, 1);
GNUNET_NAMESTORE_record_create(nsh, privkey, s_name_1, s_rd_1, &put_cont, NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record 2 \n");
GNUNET_asprintf(&s_name_2, "dummy2");
s_rd_2 = create_record(1);
et.abs_value = s_rd_2[0].expiration_time;
sig_2 = GNUNET_NAMESTORE_create_signature(privkey, et, s_name_2, s_rd_2, 1);
GNUNET_NAMESTORE_record_create(nsh, privkey, s_name_2, s_rd_2, &put_cont, NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record 3\n");
/* name in different zone */
GNUNET_asprintf(&s_name_3, "dummy3");
s_rd_3 = create_record(1);
et.abs_value = s_rd_3[0].expiration_time;
sig_3 = GNUNET_NAMESTORE_create_signature(privkey2, et, s_name_3, s_rd_3, 1);
GNUNET_NAMESTORE_record_put (nsh, &pubkey2, s_name_3, GNUNET_TIME_UNIT_FOREVER_ABS, 1, s_rd_3, sig_3, &put_cont, 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 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 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;
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
struct GNUNET_CRYPTO_RsaSignature signature;
struct GNUNET_NAMESTORE_RecordData rd;
char *hostkey_file;
const char * name = "dummy.dummy.gnunet";
endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&endbadly, NULL);
GNUNET_asprintf (&hostkey_file,
"zonefiles%s%s",
DIR_SEPARATOR_STR,
"N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
privkey = GNUNET_CRYPTO_rsa_key_create_from_file (hostkey_file);
GNUNET_free (hostkey_file);
GNUNET_assert (privkey != NULL);
GNUNET_CRYPTO_rsa_key_get_public (privkey, &pubkey);
GNUNET_CRYPTO_short_hash (&pubkey, sizeof (pubkey), &zone);
memset (&signature, '\0', sizeof (signature));
rd.expiration_time = GNUNET_TIME_absolute_get().abs_value;
rd.record_type = TEST_RECORD_TYPE;
rd.data_size = TEST_RECORD_DATALEN;
rd.data = GNUNET_malloc (TEST_RECORD_DATALEN);
memset ((char *) rd.data, 'a', TEST_RECORD_DATALEN);
nsh = GNUNET_NAMESTORE_connect (cfg);
GNUNET_break (NULL != nsh);
nsqe = GNUNET_NAMESTORE_record_put (nsh, &pubkey, name,
GNUNET_TIME_UNIT_FOREVER_ABS,
1, &rd, &signature, &put_cont, (void*) name);
GNUNET_free ((void *)rd.data);
}
/**
* 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;
}
static int
setup_bob (const struct GNUNET_CONFIGURATION_Handle * cfg)
{
char* keyfile;
struct GNUNET_CRYPTO_RsaPrivateKey *key;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
struct GNUNET_NAMESTORE_RecordData rd;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up bob\n");
cfg_handles[1] = GNUNET_CONFIGURATION_dup (cfg);
GNUNET_assert (NULL != cfg_handles[1]);
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[1] = GNUNET_NAMESTORE_connect (cfg_handles[1]);
if (NULL == nh[1])
{
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), &bob_hash);
rd.expiration_time = UINT64_MAX;
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &dave_hash;
rd.record_type = GNUNET_GNS_RECORD_PKEY;
rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
GNUNET_NAMESTORE_record_create (nh[1], key, "buddy", &rd, &cont_ns, nh[1]);
GNUNET_CRYPTO_rsa_key_free(key);
GNUNET_free(keyfile);
bob_is_setup = GNUNET_YES;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up bob done\n");
return GNUNET_OK;
}
/**
* Transmit a join request to the chat service.
*
* @param cls closure, pointer to the 'struct GNUNET_CHAT_Room'
* @param size number of bytes available in buf
* @param buf where the callee should write the message
* @return number of bytes written to buf
*/
static size_t
transmit_join_request (void *cls, size_t size, void *buf)
{
struct GNUNET_CHAT_Room *chat_room = cls;
struct JoinRequestMessage *join_msg;
char *room;
char *meta;
size_t room_len;
ssize_t meta_len;
size_t size_of_join;
if (NULL == buf)
{
#if DEBUG_CHAT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Could not transmit join request, retrying...\n");
#endif
rejoin_room (chat_room);
return 0;
}
#if DEBUG_CHAT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Transmitting join request to the service\n");
#endif
room_len = strlen (chat_room->room_name);
meta_len =
GNUNET_CONTAINER_meta_data_get_serialized_size (chat_room->member_info);
size_of_join = sizeof (struct JoinRequestMessage) + meta_len + room_len;
GNUNET_assert (size >= size_of_join);
join_msg = buf;
join_msg->header.size = htons (size);
join_msg->header.type = htons (GNUNET_MESSAGE_TYPE_CHAT_JOIN_REQUEST);
join_msg->msg_options = htonl (chat_room->msg_options);
join_msg->room_name_len = htons (room_len);
join_msg->reserved = htons (0);
join_msg->reserved2 = htonl (0);
GNUNET_CRYPTO_rsa_key_get_public (chat_room->my_private_key,
&join_msg->public_key);
room = (char *) &join_msg[1];
memcpy (room, chat_room->room_name, room_len);
meta = &room[room_len];
if (GNUNET_SYSERR ==
GNUNET_CONTAINER_meta_data_serialize (chat_room->member_info, &meta,
meta_len,
GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Could not serialize metadata\n"));
return 0;
}
GNUNET_CLIENT_receive (chat_room->client, &receive_results, chat_room,
GNUNET_TIME_UNIT_FOREVER_REL);
return size_of_join;
}
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);
}
/**
* Transmit a confirmation receipt to the chat service.
*
* @param cls closure, pointer to the 'struct GNUNET_CHAT_SendReceiptContext'
* @param size number of bytes available in buf
* @param buf where the callee should write the message
* @return number of bytes written to buf
*/
static size_t
transmit_acknowledge_request (void *cls, size_t size, void *buf)
{
struct GNUNET_CHAT_SendReceiptContext *src = cls;
struct ConfirmationReceiptMessage *receipt;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub_key;
uint16_t msg_len;
size_t msg_size;
if (NULL == buf)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not transmit confirmation receipt\n"));
return 0;
}
#if DEBUG_CHAT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Transmitting confirmation receipt to the service\n");
#endif
msg_size = sizeof (struct ConfirmationReceiptMessage);
GNUNET_assert (size >= msg_size);
receipt = buf;
receipt->header.size = htons (msg_size);
receipt->header.type = htons (GNUNET_MESSAGE_TYPE_CHAT_CONFIRMATION_RECEIPT);
receipt->reserved = htonl (0);
receipt->sequence_number = src->received_msg->sequence_number;
receipt->reserved2 = htonl (0);
receipt->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
GNUNET_CRYPTO_rsa_key_get_public (src->chat_room->my_private_key, &pub_key);
GNUNET_CRYPTO_hash (&pub_key,
sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
&receipt->target);
receipt->author = src->received_msg->sender;
receipt->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_RECEIPT);
receipt->purpose.size =
htonl (msg_size - sizeof (struct GNUNET_MessageHeader) -
sizeof (uint32_t) - sizeof (struct GNUNET_CRYPTO_RsaSignature));
msg_len =
ntohs (src->received_msg->header.size) -
sizeof (struct ReceiveNotificationMessage);
GNUNET_CRYPTO_hash (&src->received_msg[1], msg_len, &receipt->content);
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_rsa_sign (src->chat_room->my_private_key,
&receipt->purpose,
&receipt->signature));
GNUNET_free (src->received_msg);
GNUNET_free (src);
return msg_size;
}
/**
* 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);
}
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
delete_existing_db(cfg);
endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,endbadly, NULL);
size_t rd_ser_len;
/* load privat key from file not included in zonekey dir */
privkey = GNUNET_CRYPTO_rsa_key_create_from_file("test_hostkey");
GNUNET_assert (privkey != NULL);
/* get public key */
GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
/* create record */
s_name = "dummy.dummy.gnunet";
s_rd = create_record (RECORDS);
rd_ser_len = GNUNET_NAMESTORE_records_get_size(RECORDS, s_rd);
char rd_ser[rd_ser_len];
GNUNET_NAMESTORE_records_serialize(RECORDS, s_rd, rd_ser_len, rd_ser);
/* sign */
s_signature = GNUNET_NAMESTORE_create_signature(privkey, s_rd[0].expiration, s_name, s_rd, RECORDS);
/* create random zone hash */
GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &s_zone);
start_arm (cfgfile);
GNUNET_assert (arm != NULL);
nsh = GNUNET_NAMESTORE_connect (cfg);
GNUNET_break (NULL != nsh);
GNUNET_break (s_rd != NULL);
GNUNET_break (s_name != NULL);
GNUNET_NAMESTORE_record_put (nsh, &pubkey, s_name,
GNUNET_TIME_UNIT_FOREVER_ABS,
RECORDS, s_rd, s_signature, put_cont, s_name);
}
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_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 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;
}
/**
* Initiate transport service.
*
* @param cls closure
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
char *keyfile;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded tmp;
/* setup globals */
GST_cfg = c;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (c, "GNUNETD", "HOSTKEY",
&keyfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_
("Transport service is lacking key configuration settings. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
GST_my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
GNUNET_free (keyfile);
if (GST_my_private_key == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Transport service could not access hostkey. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
GST_stats = GNUNET_STATISTICS_create ("transport", c);
GST_peerinfo = GNUNET_PEERINFO_connect (c);
memset (&GST_my_public_key, '\0', sizeof (GST_my_public_key));
memset (&tmp, '\0', sizeof (tmp));
GNUNET_CRYPTO_rsa_key_get_public (GST_my_private_key, &GST_my_public_key);
GNUNET_CRYPTO_hash (&GST_my_public_key, sizeof (GST_my_public_key),
&GST_my_identity.hashPubKey);
GNUNET_assert (NULL != GST_my_private_key);
GNUNET_assert (0 != memcmp (&GST_my_public_key, &tmp, sizeof (GST_my_public_key)));
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
if (GST_peerinfo == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not access PEERINFO service. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
/* start subsystems */
GST_hello_start (&process_hello_update, NULL);
GNUNET_assert (NULL != GST_hello_get());
GST_blacklist_start (server);
GST_ats =
GNUNET_ATS_scheduling_init (GST_cfg, &ats_request_address_change, NULL);
GST_plugins_load (&plugin_env_receive_callback,
&plugin_env_address_change_notification,
&plugin_env_session_end,
&plugin_env_address_to_type);
GST_neighbours_start (NULL,
&neighbours_connect_notification,
&neighbours_disconnect_notification,
&neighbours_address_notification);
GST_clients_start (server);
GST_validation_start ();
}
/**
* Handles messages received from the service. Calls the proper client
* callback.
*/
static void
process_result (struct GNUNET_CHAT_Room *room,
const struct GNUNET_MessageHeader *reply)
{
struct LeaveNotificationMessage *leave_msg;
struct JoinNotificationMessage *join_msg;
struct ReceiveNotificationMessage *received_msg;
struct ConfirmationReceiptMessage *receipt;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
GNUNET_HashCode id;
const GNUNET_HashCode *sender;
struct GNUNET_CONTAINER_MetaData *meta;
struct GNUNET_CHAT_SendReceiptContext *src;
struct MemberList *pos;
struct MemberList *prev;
struct GNUNET_CRYPTO_AesSessionKey key;
char decrypted_msg[MAX_MESSAGE_LENGTH];
uint16_t size;
uint16_t meta_len;
uint16_t msg_len;
char *message_content;
size = ntohs (reply->size);
switch (ntohs (reply->type))
{
case GNUNET_MESSAGE_TYPE_CHAT_JOIN_NOTIFICATION:
#if DEBUG_CHAT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got a join notification\n");
#endif
if (size < sizeof (struct JoinNotificationMessage))
{
GNUNET_break (0);
return;
}
join_msg = (struct JoinNotificationMessage *) reply;
meta_len = size - sizeof (struct JoinNotificationMessage);
meta =
GNUNET_CONTAINER_meta_data_deserialize ((const char *) &join_msg[1],
meta_len);
if (NULL == meta)
{
GNUNET_break (0);
return;
}
pos = GNUNET_malloc (sizeof (struct MemberList));
pos->meta = meta;
GNUNET_CRYPTO_hash (&join_msg->public_key,
sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
&pos->id);
GNUNET_PSEUDONYM_add (room->cfg, &pos->id, meta);
pos->next = room->members;
room->members = pos;
if (GNUNET_NO == room->is_joined)
{
GNUNET_CRYPTO_rsa_key_get_public (room->my_private_key, &pkey);
if (0 ==
memcmp (&join_msg->public_key, &pkey,
sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)))
{
room->join_callback (room->join_callback_cls);
room->is_joined = GNUNET_YES;
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("The current user must be the the first one joined\n"));
GNUNET_break (0);
return;
}
}
else
room->member_list_callback (room->member_list_callback_cls, meta,
&join_msg->public_key,
ntohl (join_msg->msg_options));
break;
case GNUNET_MESSAGE_TYPE_CHAT_LEAVE_NOTIFICATION:
#if DEBUG_CHAT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got a leave notification\n");
#endif
if (size < sizeof (struct LeaveNotificationMessage))
{
GNUNET_break (0);
return;
}
leave_msg = (struct LeaveNotificationMessage *) reply;
room->member_list_callback (room->member_list_callback_cls, NULL,
&leave_msg->user, GNUNET_CHAT_MSG_OPTION_NONE);
GNUNET_CRYPTO_hash (&leave_msg->user,
sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
&id);
prev = NULL;
pos = room->members;
while ((NULL != pos) &&
(0 != memcmp (&pos->id, &id, sizeof (GNUNET_HashCode))))
{
prev = pos;
pos = pos->next;
}
GNUNET_assert (NULL != pos);
if (NULL == prev)
room->members = pos->next;
else
prev->next = pos->next;
GNUNET_CONTAINER_meta_data_destroy (pos->meta);
GNUNET_free (pos);
break;
case GNUNET_MESSAGE_TYPE_CHAT_MESSAGE_NOTIFICATION:
#if DEBUG_CHAT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got a message notification\n");
#endif
if (size <= sizeof (struct ReceiveNotificationMessage))
{
GNUNET_break (0);
return;
}
received_msg = (struct ReceiveNotificationMessage *) reply;
if (0 != (ntohl (received_msg->msg_options) & GNUNET_CHAT_MSG_ACKNOWLEDGED))
{
src = GNUNET_malloc (sizeof (struct GNUNET_CHAT_SendReceiptContext));
src->chat_room = room;
src->received_msg = GNUNET_memdup (received_msg, size);
GNUNET_CLIENT_notify_transmit_ready (room->client,
sizeof (struct
ConfirmationReceiptMessage),
GNUNET_CONSTANTS_SERVICE_TIMEOUT,
GNUNET_YES,
&transmit_acknowledge_request, src);
}
msg_len = size - sizeof (struct ReceiveNotificationMessage);
if (0 != (ntohl (received_msg->msg_options) & GNUNET_CHAT_MSG_PRIVATE))
{
if (-1 ==
GNUNET_CRYPTO_rsa_decrypt (room->my_private_key,
&received_msg->encrypted_key, &key,
sizeof (struct
GNUNET_CRYPTO_AesSessionKey)))
{
GNUNET_break (0);
return;
}
msg_len =
GNUNET_CRYPTO_aes_decrypt (&received_msg[1], msg_len, &key,
(const struct
GNUNET_CRYPTO_AesInitializationVector *)
INITVALUE, decrypted_msg);
message_content = decrypted_msg;
}
else
{
message_content = GNUNET_malloc (msg_len + 1);
memcpy (message_content, &received_msg[1], msg_len);
}
message_content[msg_len] = '\0';
if (0 != (ntohl (received_msg->msg_options) & GNUNET_CHAT_MSG_ANONYMOUS))
{
sender = NULL;
meta = NULL;
}
else
{
pos = room->members;
while ((NULL != pos) &&
(0 !=
memcmp (&pos->id, &received_msg->sender,
sizeof (GNUNET_HashCode))))
pos = pos->next;
GNUNET_assert (NULL != pos);
sender = &received_msg->sender;
meta = pos->meta;
}
room->message_callback (room->message_callback_cls, room, sender, meta,
message_content,
GNUNET_TIME_absolute_ntoh (received_msg->timestamp),
ntohl (received_msg->msg_options));
if (message_content != decrypted_msg)
GNUNET_free (message_content);
break;
case GNUNET_MESSAGE_TYPE_CHAT_CONFIRMATION_NOTIFICATION:
#if DEBUG_CHAT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got a confirmation receipt\n");
#endif
if (size < sizeof (struct ConfirmationReceiptMessage))
{
GNUNET_break (0);
return;
}
receipt = (struct ConfirmationReceiptMessage *) reply;
if (NULL != room->confirmation_callback)
room->confirmation_callback (room->confirmation_cls, room,
ntohl (receipt->sequence_number),
GNUNET_TIME_absolute_ntoh
(receipt->timestamp), &receipt->target);
break;
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Unknown message type: '%u'\n"),
ntohs (reply->type));
GNUNET_break_op (0);
break;
}
}
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 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);
}
/**
* Process GNS requests.
*
* @param cls closure)
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Initializing GNS\n");
char* keyfile;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
unsigned long long max_parallel_bg_queries = 0;
unsigned long long default_lookup_timeout_secs = 0;
int ignore_pending = GNUNET_NO;
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
{&handle_shorten, NULL, GNUNET_MESSAGE_TYPE_GNS_SHORTEN, 0},
{&handle_lookup, NULL, GNUNET_MESSAGE_TYPE_GNS_LOOKUP, 0},
{&handle_get_authority, NULL, GNUNET_MESSAGE_TYPE_GNS_GET_AUTH, 0}
};
GNS_cfg = c;
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (c, "gns",
"ZONEKEY", &keyfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"No private key for root zone specified!\n");
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"Using keyfile %s for root zone.\n", keyfile);
zone_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
GNUNET_CRYPTO_rsa_key_get_public (zone_key, &pkey);
GNUNET_CRYPTO_short_hash(&pkey,
sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
&zone_hash);
GNUNET_free(keyfile);
/**
* handle to our local namestore
*/
namestore_handle = GNUNET_NAMESTORE_connect(c);
if (NULL == namestore_handle)
{
//FIXME do error handling;
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
"Failed to connect to the namestore!\n");
GNUNET_SCHEDULER_shutdown ();
return;
}
auto_import_pkey = GNUNET_NO;
if (GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_yesno (c, "gns",
"AUTO_IMPORT_PKEY"))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Automatic PKEY import is enabled.\n");
auto_import_pkey = GNUNET_YES;
}
dht_max_update_interval = GNUNET_GNS_DHT_MAX_UPDATE_INTERVAL;
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_number (c, "gns",
"ZONE_PUT_INTERVAL",
&dht_max_update_interval))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"DHT zone update interval: %d\n",
dht_max_update_interval);
}
max_record_put_interval = 1;
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_number (c, "gns",
"RECORD_PUT_INTERVAL",
&max_record_put_interval))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Record put interval: %d\n",
max_record_put_interval);
}
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_number (c, "gns",
"MAX_PARALLEL_BACKGROUND_QUERIES",
&max_parallel_bg_queries))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Number of allowed parallel background queries: %d\n",
max_parallel_bg_queries);
}
if (GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_yesno (c, "gns",
"AUTO_IMPORT_CONFIRMATION_REQ"))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Auto import requires user confirmation\n");
ignore_pending = GNUNET_YES;
}
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_number(c, "gns",
"DEFAULT_LOOKUP_TIMEOUT",
&default_lookup_timeout_secs))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Default lookup timeout: %ds\n", default_lookup_timeout_secs);
default_lookup_timeout = GNUNET_TIME_relative_multiply(
GNUNET_TIME_UNIT_SECONDS,
default_lookup_timeout_secs);
}
/**
* handle to the dht
*/
dht_handle = GNUNET_DHT_connect(c,
//max_parallel_bg_queries); //FIXME get ht_len from cfg
1024);
if (NULL == dht_handle)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Could not connect to DHT!\n");
}
if (gns_resolver_init(namestore_handle, dht_handle, zone_hash,
max_parallel_bg_queries,
ignore_pending)
== GNUNET_SYSERR)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
"Unable to initialize resolver!\n");
GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
return;
}
if (GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_yesno (c, "gns", "HIJACK_DNS"))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"DNS hijacking enabled... connecting to service.\n");
if (gns_interceptor_init(zone_hash, zone_key, c) == GNUNET_SYSERR)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
"Failed to enable the dns interceptor!\n");
}
}
/**
* Schedule periodic put
* for our records
* We have roughly an hour for all records;
*/
record_put_interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
1);
zone_update_taskid = GNUNET_SCHEDULER_add_now (&update_zone_dht_start, NULL);
GNUNET_SERVER_add_handlers (server, handlers);
//FIXME
//GNUNET_SERVER_disconnect_notify (server,
// &client_disconnect_notification,
// NULL);
nc = GNUNET_SERVER_notification_context_create (server, 1);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
}
/**
* Join a chat room.
*
* @param cfg configuration
* @param nick_name nickname of the user joining (used to
* determine which public key to use);
* the nickname should probably also
* be used in the member_info (as "EXTRACTOR_TITLE")
* @param member_info information about the joining member
* @param room_name name of the room
* @param msg_options message options of the joining user
* @param joinCallback function to call on successful join
* @param join_cls closure for joinCallback
* @param messageCallback which function to call if a message has
* been received?
* @param message_cls argument to callback
* @param memberCallback which function to call for join/leave notifications
* @param member_cls argument to callback
* @param confirmationCallback which function to call for confirmations (maybe NULL)
* @param confirmation_cls argument to callback
* @param me member ID (pseudonym)
* @return NULL on error
*/
struct GNUNET_CHAT_Room *
GNUNET_CHAT_join_room (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *nick_name,
struct GNUNET_CONTAINER_MetaData *member_info,
const char *room_name,
enum GNUNET_CHAT_MsgOptions msg_options,
GNUNET_CHAT_JoinCallback joinCallback, void *join_cls,
GNUNET_CHAT_MessageCallback messageCallback,
void *message_cls,
GNUNET_CHAT_MemberListCallback memberCallback,
void *member_cls,
GNUNET_CHAT_MessageConfirmation confirmationCallback,
void *confirmation_cls, GNUNET_HashCode * me)
{
struct GNUNET_CHAT_Room *chat_room;
struct GNUNET_CRYPTO_RsaPrivateKey *priv_key;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub_key;
struct GNUNET_CLIENT_Connection *client;
#if DEBUG_CHAT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Joining the room '%s'\n", room_name);
#endif
priv_key = init_private_key (cfg, nick_name);
if (NULL == priv_key)
return NULL;
GNUNET_CRYPTO_rsa_key_get_public (priv_key, &pub_key);
GNUNET_CRYPTO_hash (&pub_key,
sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
me);
GNUNET_PSEUDONYM_add (cfg, me, member_info);
client = GNUNET_CLIENT_connect ("chat", cfg);
if (NULL == client)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to connect to the chat service\n"));
return NULL;
}
if (NULL == joinCallback)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Undefined mandatory parameter: joinCallback\n"));
return NULL;
}
if (NULL == messageCallback)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Undefined mandatory parameter: messageCallback\n"));
return NULL;
}
if (NULL == memberCallback)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Undefined mandatory parameter: memberCallback\n"));
return NULL;
}
chat_room = GNUNET_malloc (sizeof (struct GNUNET_CHAT_Room));
chat_room->msg_options = msg_options;
chat_room->room_name = GNUNET_strdup (room_name);
chat_room->member_info = GNUNET_CONTAINER_meta_data_duplicate (member_info);
chat_room->my_private_key = priv_key;
chat_room->is_joined = GNUNET_NO;
chat_room->join_callback = joinCallback;
chat_room->join_callback_cls = join_cls;
chat_room->message_callback = messageCallback;
chat_room->message_callback_cls = message_cls;
chat_room->member_list_callback = memberCallback;
chat_room->member_list_callback_cls = member_cls;
chat_room->confirmation_callback = confirmationCallback;
chat_room->confirmation_cls = confirmation_cls;
chat_room->cfg = cfg;
chat_room->client = client;
chat_room->members = NULL;
if (GNUNET_SYSERR == rejoin_room (chat_room))
{
GNUNET_CHAT_leave_room (chat_room);
return NULL;
}
return chat_room;
}
