From 425613b68d5e8f66dd3462bf6b47c64b3534ee96 Mon Sep 17 00:00:00 2001 From: Martin Schanzenbach Date: Fri, 24 Feb 2012 15:36:28 +0000 Subject: [PATCH] -can finally resolve alice.gnunet as well as www.bob.gnunet (no signatures) --- src/gns/gnunet-service-gns.c | 134 +++++++++++++++++++++++++---------- src/gns/namestore_stub_api.c | 103 +++++++++++++++++++++++---- 2 files changed, 186 insertions(+), 51 deletions(-) diff --git a/src/gns/gnunet-service-gns.c b/src/gns/gnunet-service-gns.c index 21791a6fa..563c9d851 100644 --- a/src/gns/gnunet-service-gns.c +++ b/src/gns/gnunet-service-gns.c @@ -89,6 +89,8 @@ struct GNUNET_GNS_PendingQuery * may be able to resolve */ int authority_found; + + struct GNUNET_DNSPARSER_Packet *p; }; @@ -212,6 +214,7 @@ process_authority_dht_result(void* cls, uint16_t namelen; char* name = NULL; struct GNUNET_CRYPTO_RsaSignature *signature; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key; int i; char* pos; GNUNET_HashCode zone, name_hash; @@ -260,21 +263,25 @@ process_authority_dht_result(void* cls, } - if ((((char*)data)-pos) < sizeof(struct GNUNET_CRYPTO_RsaSignature)) + if ((((char*)data)-pos) < + (sizeof(struct GNUNET_CRYPTO_RsaSignature) + + sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded))) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Cannot parse signature in DHT response. Corrupted or Missing"); + "Cannot parse signature/key in DHT response. Corrupted or Missing"); return; } signature = (struct GNUNET_CRYPTO_RsaSignature*)pos; - + pos += sizeof(struct GNUNET_CRYPTO_RsaSignature); + + public_key = (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded*)pos; GNUNET_CRYPTO_hash(name, strlen(name), &name_hash); GNUNET_CRYPTO_hash_xor(key, &name_hash, &zone); //Save to namestore GNUNET_NAMESTORE_record_put (namestore_handle, - &zone, + public_key, name, exp, num_records, @@ -365,6 +372,7 @@ process_name_dht_result(void* cls, uint16_t namelen; char* name = NULL; struct GNUNET_CRYPTO_RsaSignature *signature; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key; int i; char* pos; GNUNET_HashCode zone, name_hash; @@ -413,21 +421,26 @@ process_name_dht_result(void* cls, } - if ((((char*)data)-pos) < sizeof(struct GNUNET_CRYPTO_RsaSignature)) + if ((((char*)data)-pos) < + (sizeof(struct GNUNET_CRYPTO_RsaSignature) + + sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded))) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Cannot parse signature in DHT response. Corrupted or Missing"); + "Cannot parse signature/key in DHT response. Corrupted or Missing"); return; } signature = (struct GNUNET_CRYPTO_RsaSignature*)pos; + pos += sizeof(struct GNUNET_CRYPTO_RsaSignature); + + public_key = (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded*)pos; GNUNET_CRYPTO_hash(name, strlen(name), &name_hash); GNUNET_CRYPTO_hash_xor(key, &name_hash, &zone); //Save to namestore GNUNET_NAMESTORE_record_put (namestore_handle, - &zone, + public_key, name, exp, num_records, @@ -571,15 +584,19 @@ reply_to_dns(struct GNUNET_GNS_PendingQuery *answer, uint32_t rd_count, size_t len; int ret; char *buf; - struct GNUNET_DNSPARSER_Packet packet; + struct GNUNET_DNSPARSER_Packet *packet = answer->p; struct GNUNET_DNSPARSER_Record answer_records[answer->num_records]; - packet.answers = answer_records; + packet->answers = answer_records; len = sizeof(struct GNUNET_DNSPARSER_Record*); for (i=0; i < rd_count; i++) { GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Adding type %d to DNS response\n", rd[i].record_type); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Name: %s\n", answer->name); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "OName: %s\n", answer->original_name); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Record %d/%d\n", i+1, rd_count); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Record len %d\n", rd[i].data_size); answer_records[i].name = answer->original_name; //FIXME yes? answer_records[i].type = rd[i].record_type; answer_records[i].data.raw.data_len = rd[i].data_size; @@ -588,26 +605,40 @@ reply_to_dns(struct GNUNET_GNS_PendingQuery *answer, uint32_t rd_count, answer_records[i].class = GNUNET_DNSPARSER_CLASS_INTERNET;//hmmn //GNUNET_free(i->record); DO this later! } - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "after memcpy\n"); - /* FIXME how to handle auth, additional etc */ - packet.num_answers = answer->num_records; - packet.num_authority_records = answer->num_authority_records; + + /** + * FIXME how to handle auth, additional etc + * PKEY might be auth, != name,record_type additional + **/ + packet->num_queries = 0; + packet->num_additional_records = 0; + packet->num_answers = rd_count; //answer->num_records; + //packet.num_authority_records = 0;//answer->num_authority_records; dnsflags.authoritative_answer = 1; + dnsflags.message_truncated = 0; + dnsflags.recursion_desired = 0; + dnsflags.authenticated_data = 0; + dnsflags.checking_disabled = 1; + dnsflags.zero = 0; + dnsflags.recursion_available = 0; dnsflags.opcode = GNUNET_DNSPARSER_OPCODE_QUERY; - dnsflags.return_code = GNUNET_DNSPARSER_RETURN_CODE_NO_ERROR; //not sure + if (rd == NULL) + dnsflags.return_code = GNUNET_DNSPARSER_RETURN_CODE_NAME_ERROR; + else + dnsflags.return_code = GNUNET_DNSPARSER_RETURN_CODE_NO_ERROR; dnsflags.query_or_response = 1; - packet.flags = dnsflags; + packet->flags = dnsflags; - packet.id = answer->id; - //FIXME this is silently discarded - ret = GNUNET_DNSPARSER_pack (&packet, + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Building DNS response\n"); + ret = GNUNET_DNSPARSER_pack (packet, 1024, /* FIXME magic from dns redirector */ &buf, &len); GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Built DNS response! (ret=%d)\n", ret); + "Built DNS response! (ret=%d,len=%d)\n", ret, len); if (ret == GNUNET_OK) { GNUNET_log(GNUNET_ERROR_TYPE_INFO, @@ -669,7 +700,7 @@ process_authoritative_result(void* cls, * -> DHT Phase unless data is recent */ GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Namestore lookup terminated. without results\n"); + "Namestore lookup for %s terminated without results\n", name); /** * if this is not our zone we cannot rely on the namestore to be @@ -851,6 +882,7 @@ resolve_name(struct GNUNET_GNS_PendingQuery *query, GNUNET_HashCode *zone) */ void start_resolution(struct GNUNET_DNS_RequestHandle *rh, + struct GNUNET_DNSPARSER_Packet *p, char* name, uint16_t id, uint16_t type) { struct GNUNET_GNS_PendingQuery *query; @@ -860,6 +892,7 @@ start_resolution(struct GNUNET_DNS_RequestHandle *rh, query = GNUNET_malloc(sizeof (struct GNUNET_GNS_PendingQuery)); query->id = id; query->original_name = name; //Full name of original query + query->p = p; //FIXME do not forget to free!! query->name = GNUNET_malloc(strlen(name)-strlen(gnunet_tld) + 1); @@ -924,7 +957,7 @@ handle_dns_request(void *cls, if (0 == strcmp(tldoffset, gnunet_tld)) { - start_resolution(rh, p->queries[i].name, p->id, p->queries[i].type); + start_resolution(rh, p, p->queries[i].name, p->id, p->queries[i].type); } else { @@ -948,38 +981,61 @@ put_some_records(void) /* put a few records into namestore */ char* ipA = "1.2.3.4"; char* ipB = "5.6.7.8"; + struct GNUNET_CRYPTO_RsaPrivateKey *bob_key = GNUNET_CRYPTO_rsa_key_create (); struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *bob; + bob = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + + GNUNET_CRYPTO_rsa_key_get_public (bob_key, bob); + + GNUNET_HashCode *bob_zone = GNUNET_malloc(sizeof(GNUNET_HashCode)); + + GNUNET_CRYPTO_hash(bob, GNUNET_CRYPTO_RSA_KEY_LENGTH, bob_zone); + struct in_addr *alice = GNUNET_malloc(sizeof(struct in_addr)); - struct in_addr *bob = GNUNET_malloc(sizeof(struct in_addr)); - struct GNUNET_NAMESTORE_RecordData *rda; - struct GNUNET_NAMESTORE_RecordData *rdb; + struct in_addr *bob_web = GNUNET_malloc(sizeof(struct in_addr)); + struct GNUNET_NAMESTORE_RecordData rda; + struct GNUNET_NAMESTORE_RecordData rdb; + struct GNUNET_NAMESTORE_RecordData rdb_web; - rda = GNUNET_malloc(sizeof(struct GNUNET_NAMESTORE_RecordData)); - rdb = GNUNET_malloc(sizeof(struct GNUNET_NAMESTORE_RecordData)); - GNUNET_assert(1 == inet_pton (AF_INET, ipA, alice)); - GNUNET_assert(1 == inet_pton (AF_INET, ipB, bob)); - - rda->data_size = sizeof(struct in_addr); - rdb->data_size = sizeof(struct in_addr); - rda->data = alice; - rdb->data = bob; - rda->record_type = GNUNET_GNS_RECORD_TYPE_A; - rdb->record_type = GNUNET_GNS_RECORD_TYPE_A; - rda->expiration = GNUNET_TIME_absolute_get_forever (); - rdb->expiration = GNUNET_TIME_absolute_get_forever (); + GNUNET_assert(1 == inet_pton (AF_INET, ipB, bob_web)); + + rda.data_size = sizeof(struct in_addr); + rdb_web.data_size = sizeof(struct in_addr); + rdb.data_size = sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded); + rda.data = alice; + rdb.data = bob; + rdb_web.data = bob_web; + rda.record_type = GNUNET_GNS_RECORD_TYPE_A; + rdb_web.record_type = GNUNET_GNS_RECORD_TYPE_A; + rdb.record_type = GNUNET_GNS_RECORD_PKEY; + rdb_web.expiration = GNUNET_TIME_absolute_get_forever (); + rda.expiration = GNUNET_TIME_absolute_get_forever (); + rdb.expiration = GNUNET_TIME_absolute_get_forever (); + //alice.gnunet A IN 1.2.3.4 GNUNET_NAMESTORE_record_create (namestore_handle, zone_key, "alice", - rda, + &rda, NULL, NULL); + + //www.bob.gnunet A IN 5.6.7.8 GNUNET_NAMESTORE_record_create (namestore_handle, zone_key, "bob", - rdb, + &rdb, NULL, NULL); + GNUNET_NAMESTORE_record_put(namestore_handle, + bob, + "www", + GNUNET_TIME_absolute_get_forever (), + 1, + &rdb_web, + NULL, //Signature + NULL, //Cont + NULL); //cls } void diff --git a/src/gns/namestore_stub_api.c b/src/gns/namestore_stub_api.c index e511bef31..e2c9de33e 100644 --- a/src/gns/namestore_stub_api.c +++ b/src/gns/namestore_stub_api.c @@ -115,6 +115,8 @@ GNUNET_NAMESTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg) handle = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_Handle)); handle->cfg = cfg; + handle->records_head = NULL; + handle->records_tail = NULL; return handle; } @@ -150,7 +152,7 @@ GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *handle, int drop) */ struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_record_put (struct GNUNET_NAMESTORE_Handle *h, - const GNUNET_HashCode *zone, + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key, const char *name, struct GNUNET_TIME_Absolute expiration, unsigned int rd_count, @@ -161,7 +163,57 @@ GNUNET_NAMESTORE_record_put (struct GNUNET_NAMESTORE_Handle *h, { struct GNUNET_NAMESTORE_QueueEntry *qe; qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry)); - //FIXME + struct GNUNET_NAMESTORE_SimpleRecord* sr; + GNUNET_HashCode *zone; + int i; + + zone = GNUNET_malloc(sizeof(GNUNET_HashCode)); + GNUNET_CRYPTO_hash(public_key, + sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + zone); + + sr = h->records_head; + for (; sr != NULL; sr = sr->next) + { + if (GNUNET_CRYPTO_hash_cmp(zone, sr->zone) == 0) + { + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "records for %s already present ow\n", + name); + sr->rd_count = rd_count; + for (i=0; ird[i] = rd[i]; + } + //Expiration, Signature etc + return qe; + } + } + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "new records for %s\n", name); + // Not present + sr = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_SimpleRecord)); + sr->rd_count = rd_count; + sr->name = GNUNET_malloc(strlen(name)); + sr->zone = zone; + sr->zone_key = public_key; //pkey FIXME; + sr->next = NULL; + sr->prev = NULL; + strcpy((char*)sr->name, name); + + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "copying \n"); + for (i=0; ird[i] = rd[i]; + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "done \n"); + + if (h->records_head == NULL && h->records_tail == NULL) + { + h->records_head = sr; + h->records_tail = sr; + } + else + { + GNUNET_CONTAINER_DLL_insert(h->records_head, h->records_tail, sr); + } + return qe; } @@ -177,7 +229,7 @@ GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_RsaPublicKeyBinary struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h, - const struct GNUNET_CRYPTO_RsaPrivateKey *pkey, + const struct GNUNET_CRYPTO_RsaPrivateKey *key, const char *name, const struct GNUNET_NAMESTORE_RecordData *rd, GNUNET_NAMESTORE_ContinuationWithStatus cont, @@ -186,13 +238,25 @@ GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h, struct GNUNET_NAMESTORE_QueueEntry *qe; qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry)); struct GNUNET_NAMESTORE_SimpleRecord* sr; + + GNUNET_HashCode *zone_hash; + + //memleakage.. but only stub so w/e + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pkey; + pkey = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + GNUNET_CRYPTO_rsa_key_get_public (key, pkey); + + zone_hash = GNUNET_malloc(sizeof(GNUNET_HashCode)); + + GNUNET_CRYPTO_hash(pkey, GNUNET_CRYPTO_RSA_KEY_LENGTH, zone_hash); sr = h->records_head; for (; sr != NULL; sr = sr->next) { - if (strcmp(sr->name, name) && (sr->zone == NULL)) + if (strcmp(sr->name, name) && (sr->zone == zone_hash)) { - memcpy (&(sr->rd[sr->rd_count]), rd, + //Dangerous + memcpy (&(sr->rd[sr->rd_count-1]), rd, sizeof(struct GNUNET_NAMESTORE_RecordData)); sr->rd_count++; @@ -200,18 +264,27 @@ GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h, } } - sr = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_SimpleRecord*)); + sr = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_SimpleRecord)); - sr->rd_count = 0; + sr->rd_count = 1; sr->name = GNUNET_malloc(strlen(name)); - sr->zone = NULL; - sr->zone_key = NULL; + sr->zone = zone_hash; + sr->zone_key = pkey; + sr->next = NULL; + sr->prev = NULL; strcpy((char*)sr->name, name); memcpy (&(sr->rd), rd, sizeof(struct GNUNET_NAMESTORE_RecordData)); - - GNUNET_CONTAINER_DLL_insert(h->records_head, h->records_tail, sr); + if (h->records_head == NULL && h->records_tail == NULL) + { + h->records_head = sr; + h->records_tail = sr; + } + else + { + GNUNET_CONTAINER_DLL_insert(h->records_head, h->records_tail, sr); + } return qe; } @@ -272,17 +345,23 @@ GNUNET_NAMESTORE_lookup_record (struct GNUNET_NAMESTORE_Handle *h, qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry)); struct GNUNET_NAMESTORE_SimpleRecord *sr; + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Looking up %s\n", name); sr = h->records_head; for (; sr != NULL; sr = sr->next) { - if (strcmp(sr->name, name) && + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Got %s\n", sr->name); + if ((strcmp(sr->name, name) == 0) && (GNUNET_CRYPTO_hash_cmp(sr->zone, zone))) { + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Found match for %s with %d entries\n", + sr->name, sr->rd_count); //Simply always return all records proc(proc_cls, sr->zone_key, GNUNET_TIME_UNIT_FOREVER_ABS, //FIXME name, sr->rd_count, sr->rd, NULL); return qe; } + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "No match\n"); } proc(proc_cls, NULL, GNUNET_TIME_UNIT_ZERO_ABS, name, 0, NULL, NULL); //FIXME -- 2.25.1