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; }