#include #include "libp2p/record/record.h" #include "libp2p/record/message.h" #include "libp2p/peer/peer.h" #include "multiaddr/multiaddr.h" int setval(char** result, size_t* result_size, char* in) { *result = malloc(strlen(in) + 1); if (*result == NULL) return 0; strcpy(*result, in); if (result_size != NULL) *result_size = strlen(in); return 1; } struct Libp2pRecord* test_record_create() { struct Libp2pRecord* record = libp2p_record_new(); if (record != NULL) { setval(&record->key, &record->key_size, "Key"); setval((char**)&record->value, &record->value_size, "Value"); setval(&record->author, &record->author_size, "Author"); setval((char**)&record->signature, &record->signature_size, "Signature"); setval(&record->time_received, &record->time_received_size, "Time_Received"); } return record; } int test_record_protobuf() { struct Libp2pRecord* record = test_record_create(); struct Libp2pRecord* results = NULL; size_t protobuf_size = 0; char* protobuf = NULL; int retVal = 0; // protobuf, unprotobuf protobuf_size = libp2p_record_protobuf_encode_size(record); protobuf = (unsigned char*)malloc(protobuf_size); if (!libp2p_record_protobuf_encode(record, protobuf, protobuf_size, &protobuf_size)) goto exit; if (!libp2p_record_protobuf_decode(protobuf, protobuf_size, &results)) goto exit; if (record->key_size != results->key_size || record->value_size != results->value_size || record->author_size != results->author_size || record->signature_size != results->signature_size || record->time_received_size != results->time_received_size) goto exit; if (strcmp(record->key, results->key) != 0) goto exit; if (strncmp(record->value, results->value, results->value_size) != 0) goto exit; if (strncmp(record->author, results->author, results->author_size) != 0) goto exit; if (strncmp(record->signature, results->signature, results->signature_size) != 0) goto exit; if (strncmp(record->time_received, results->time_received, results->time_received_size) != 0) goto exit; retVal = 1; exit: if (protobuf != NULL) free (protobuf); libp2p_record_free(record); if (results != NULL) libp2p_record_free(results); return retVal; } int test_record_make_put_record() { int retVal = 0; char* protobuf = NULL; size_t protobuf_size = 0; struct RsaPrivateKey* rsa_private_key = NULL; struct RsaPublicKey rsa_public_key; char* record_key = "Record Key"; unsigned char* record_value = (unsigned char*)"Record Value"; size_t record_value_length = strlen((char*)record_value); struct Libp2pRecord* results = NULL; char* signature_buffer = NULL; size_t signature_buffer_length = 0; // generate keys rsa_public_key.der = NULL; rsa_public_key.der_length = 0; rsa_private_key = libp2p_crypto_rsa_rsa_private_key_new(); if (rsa_private_key == NULL) goto exit; if (!libp2p_crypto_rsa_generate_keypair(rsa_private_key, 2048)) goto exit; rsa_public_key.der = rsa_private_key->public_key_der; rsa_public_key.der_length = rsa_private_key->public_key_length; // sign and protobuf if (libp2p_record_make_put_record(&protobuf, &protobuf_size, rsa_private_key, record_key, record_value, record_value_length, 1) != 0) goto exit; // unprotobuf and test if (!libp2p_record_protobuf_decode(protobuf, protobuf_size, &results)) goto exit; if (strcmp(record_key, results->key) != 0) goto exit; if (strncmp(record_value, results->value, results->value_size) != 0) goto exit; if (results->key_size != strlen(record_key) || results->value_size != record_value_length) goto exit; // verify signature signature_buffer_length = results->key_size + results->value_size + results->author_size; signature_buffer = malloc(signature_buffer_length); strncpy(&signature_buffer[0], results->key, results->key_size); strncpy(&signature_buffer[results->key_size], results->value, results->value_size); strncpy(&signature_buffer[results->key_size + results->value_size], results->author, results->author_size); if (!libp2p_crypto_rsa_verify(&rsa_public_key, signature_buffer, signature_buffer_length, results->signature)) goto exit; // cleanup retVal = 1; exit: if (signature_buffer != NULL) free(signature_buffer); if (protobuf != NULL) free(protobuf); if (results != NULL) libp2p_record_free(results); if (rsa_private_key != NULL) libp2p_crypto_rsa_rsa_private_key_free(rsa_private_key); return retVal; } int test_record_peer_protobuf() { struct Libp2pPeer* peer = NULL; struct MultiAddress* multi_addr1 = NULL; struct MultiAddress* multi_addr2 = NULL; int retVal = 0; unsigned char* protobuf = NULL; size_t protobuf_size = 0; struct Libp2pPeer* result = NULL; // make multiaddress multi_addr1 = multiaddress_new_from_string("/ip4/127.0.0.1/tcp/4001"); // make peer peer = libp2p_peer_new(); peer->connection_type = CONNECTION_TYPE_CAN_CONNECT; peer->id = malloc(7); strcpy(peer->id, "ABC123"); peer->id_size = strlen(peer->id); peer->addr_head = libp2p_utils_linked_list_new(); peer->addr_head->item = multi_addr1; // protobuf protobuf_size = libp2p_peer_protobuf_encode_size(peer); protobuf = (unsigned char*)malloc(protobuf_size); if (protobuf == NULL) goto exit; if (!libp2p_peer_protobuf_encode(peer, protobuf, protobuf_size, &protobuf_size)) goto exit; // unprotobuf if (!libp2p_peer_protobuf_decode(protobuf, protobuf_size, &result)) goto exit; // check results if (!strncmp(peer->id, result->id, peer->id_size) == 0) goto exit; if (peer->id_size != result->id_size || peer->connection_type != result->connection_type) goto exit; // check multiaddress multi_addr2 = (struct MultiAddress*)result->addr_head->item; if (multi_addr1->bsize != multi_addr2->bsize) goto exit; if (strncmp(multi_addr1->bytes, multi_addr2->bytes, multi_addr2->bsize) != 0) goto exit; // cleanup retVal = 1; exit: if (peer != NULL) { libp2p_peer_free(peer); // above gets rid of below... multi_addr1 = NULL; } if (multi_addr1 != NULL) multiaddress_free(multi_addr1); if (protobuf != NULL) free(protobuf); if (result != NULL) libp2p_peer_free(result); return retVal; } int test_record_message_protobuf() { int retVal = 0; struct Libp2pPeer* closer_peer = NULL; struct Libp2pMessage* message = NULL; struct Libp2pMessage* result = NULL; char* buffer = NULL; size_t buffer_len = 0; // construct message closer_peer = libp2p_peer_new(); closer_peer->connection_type = CONNECTION_TYPE_CAN_CONNECT; closer_peer->id = malloc(7); strcpy(closer_peer->id, "ABC123"); closer_peer->id_size = strlen(closer_peer->id); closer_peer->addr_head = libp2p_utils_linked_list_new(); closer_peer->addr_head->item = multiaddress_new_from_string("/ip4/127.0.0.1/tcp/4001"); message = libp2p_message_new(); message->closer_peer_head = libp2p_utils_linked_list_new(); message->closer_peer_head->item = closer_peer; message->cluster_level_raw = 1; message->key = malloc(7); strcpy(message->key, "ABC123"); message->key_size = 6; message->message_type = MESSAGE_TYPE_ADD_PROVIDER; message->record = test_record_create(); // protobuf buffer_len = libp2p_message_protobuf_encode_size(message); buffer = malloc(buffer_len); if (!libp2p_message_protobuf_encode(message, buffer, buffer_len, &buffer_len)) goto exit; // decode if (!libp2p_message_protobuf_decode(buffer, buffer_len, &result)) goto exit; // check results if (result->cluster_level_raw != 1) goto exit; // cleanup retVal = 1; exit: if (message != NULL) libp2p_message_free(message); if (buffer != NULL) free(buffer); if (result != NULL) libp2p_message_free(result); return retVal; }