FS-9775: Significant work towards supporting BEP44, "get" is nearly working…

FS-9775: Significant work towards supporting BEP44, "get" is nearly working committing to merge routetable updates

libs/libks/Makefile.am

@@ -14,7 +14,7 @@ libks_la_SOURCES += src/ks_ssl.c src/kws.c src/ks_rng.c
 libks_la_SOURCES += src/utp/utp_api.cpp src/utp/utp_callbacks.cpp src/utp/utp_hash.cpp src/utp/utp_internal.cpp
 libks_la_SOURCES += src/utp/utp_packedsockaddr.cpp src/utp/utp_utils.cpp src/ks_bencode.c
 libks_la_SOURCES += src/dht/ks_dht.c src/dht/ks_dht_endpoint.c src/dht/ks_dht_message.c src/dht/ks_dht_transaction.c
-libks_la_SOURCES += src/dht/ks_dht_bucket.c 
+libks_la_SOURCES += src/dht/ks_dht_storageitem.c src/dht/ks_dht_bucket.c
 libks_la_SOURCES += crypt/aeskey.c crypt/aestab.c crypt/sha2.c crypt/twofish.c crypt/aes_modes.c crypt/aescrypt.c crypt/twofish_cfb.c 
 #aes.h aescpp.h brg_endian.h aesopt.h aestab.h brg_types.h sha2.h twofish.h
 

libs/libks/src/dht/ks_dht-int.h

@@ -35,6 +35,7 @@ KS_DECLARE(ks_status_t) ks_dht_send_error(ks_dht_t *dht,
 										  const char *errorstr);
 KS_DECLARE(ks_status_t) ks_dht_send_ping(ks_dht_t *dht, ks_dht_endpoint_t *ep, ks_sockaddr_t *raddr);
 KS_DECLARE(ks_status_t) ks_dht_send_findnode(ks_dht_t *dht, ks_dht_endpoint_t *ep, ks_sockaddr_t *raddr, ks_dht_nodeid_t *targetid);
+KS_DECLARE(ks_status_t) ks_dht_send_get(ks_dht_t *dht, ks_dht_endpoint_t *ep, ks_sockaddr_t *raddr, ks_dht_nodeid_t *targetid);
 
 KS_DECLARE(ks_status_t) ks_dht_process(ks_dht_t *dht, ks_dht_endpoint_t *ep, ks_sockaddr_t *raddr);
 
@@ -44,9 +45,12 @@ KS_DECLARE(ks_status_t) ks_dht_process_error(ks_dht_t *dht, ks_dht_message_t *me
 
 KS_DECLARE(ks_status_t) ks_dht_process_query_ping(ks_dht_t *dht, ks_dht_message_t *message);
 KS_DECLARE(ks_status_t) ks_dht_process_query_findnode(ks_dht_t *dht, ks_dht_message_t *message);
+KS_DECLARE(ks_status_t) ks_dht_process_query_get(ks_dht_t *dht, ks_dht_message_t *message);
+KS_DECLARE(ks_status_t) ks_dht_process_query_put(ks_dht_t *dht, ks_dht_message_t *message);
 
 KS_DECLARE(ks_status_t) ks_dht_process_response_ping(ks_dht_t *dht, ks_dht_message_t *message);
 KS_DECLARE(ks_status_t) ks_dht_process_response_findnode(ks_dht_t *dht, ks_dht_message_t *message);
+KS_DECLARE(ks_status_t) ks_dht_process_response_get(ks_dht_t *dht, ks_dht_message_t *message);
 
 /**
  *
@@ -61,6 +65,24 @@ KS_DECLARE(ks_status_t) ks_dht_endpoint_init(ks_dht_endpoint_t *endpoint,
 											 ks_socket_t sock);
 KS_DECLARE(ks_status_t) ks_dht_endpoint_deinit(ks_dht_endpoint_t *endpoint);
 
+/**
+ *
+ */
+KS_DECLARE(ks_status_t) ks_dht_storageitem_alloc(ks_dht_storageitem_t **item, ks_pool_t *pool);
+KS_DECLARE(ks_status_t) ks_dht_storageitem_prealloc(ks_dht_storageitem_t *item, ks_pool_t *pool);
+KS_DECLARE(ks_status_t) ks_dht_storageitem_free(ks_dht_storageitem_t *item);
+
+KS_DECLARE(ks_status_t) ks_dht_storageitem_init(ks_dht_storageitem_t *item, struct bencode *v);
+KS_DECLARE(ks_status_t) ks_dht_storageitem_deinit(ks_dht_storageitem_t *item);
+
+KS_DECLARE(ks_status_t) ks_dht_storageitem_create(ks_dht_storageitem_t *item, ks_bool_t mutable);
+KS_DECLARE(ks_status_t) ks_dht_storageitem_immutable(ks_dht_storageitem_t *item);
+KS_DECLARE(ks_status_t) ks_dht_storageitem_mutable(ks_dht_storageitem_t *item,
+												   ks_dht_storageitem_key_t *k,
+												   uint8_t *salt,
+												   ks_size_t salt_length,
+												   int64_t sequence,
+												   ks_dht_storageitem_signature_t *signature);
 /**
  *
  */

libs/libks/src/dht/ks_dht.h

@@ -3,6 +3,7 @@
 
 #include "ks.h"
 #include "ks_bencode.h"
+#include "sodium.h"
 
 KS_BEGIN_EXTERN_C
 
@@ -19,14 +20,26 @@ KS_BEGIN_EXTERN_C
 
 #define KS_DHT_TRANSACTION_EXPIRATION_DELAY 30
 
+#define KS_DHT_STORAGEITEM_KEY_SIZE crypto_sign_PUBLICKEYBYTES
+#define KS_DHT_STORAGEITEM_SALT_MAX_SIZE 64
+#define KS_DHT_STORAGEITEM_SIGNATURE_SIZE crypto_sign_BYTES
+
+#define KS_DHT_TOKEN_SIZE SHA_DIGEST_LENGTH
+#define KS_DHT_TOKENSECRET_EXPIRATION 300
+
 typedef struct ks_dht_s ks_dht_t;
 typedef struct ks_dht_nodeid_s ks_dht_nodeid_t;
+typedef struct ks_dht_token_s ks_dht_token_t;
+typedef struct ks_dht_storageitem_key_s ks_dht_storageitem_key_t;
+typedef struct ks_dht_storageitem_signature_s ks_dht_storageitem_signature_t;
 typedef struct ks_dht_message_s ks_dht_message_t;
 typedef struct ks_dht_endpoint_s ks_dht_endpoint_t;
 typedef struct ks_dht_transaction_s ks_dht_transaction_t;
 typedef struct ks_dht_node_s ks_dht_node_t;
 typedef struct ks_dhtrt_routetable_s ks_dhtrt_routetable_t;
 typedef struct ks_dhtrt_querynodes_s ks_dhtrt_querynodes_t;
+typedef struct ks_dht_storageitem_s ks_dht_storageitem_t;
+
 
 typedef ks_status_t (*ks_dht_message_callback_t)(ks_dht_t *dht, ks_dht_message_t *message);
 
@@ -60,6 +73,18 @@ struct ks_dhtrt_querynodes_s {
     ks_dht_node_t* nodes[ KS_DHT_MESSAGE_QUERY_MAX_SIZE]; /* out: array of peers (ks_dht_node_t* nodes[incount]) */
 };
 
+struct ks_dht_token_s {
+	uint8_t token[KS_DHT_TOKEN_SIZE];
+};
+
+struct ks_dht_storageitem_key_s {
+	uint8_t key[KS_DHT_STORAGEITEM_KEY_SIZE];
+};
+
+struct ks_dht_storageitem_signature_s {
+	uint8_t sig[KS_DHT_STORAGEITEM_SIGNATURE_SIZE];
+};
+
 struct ks_dht_message_s {
 	ks_pool_t *pool;
 	ks_dht_endpoint_t *endpoint;
@@ -87,6 +112,20 @@ struct ks_dht_transaction_s {
 	ks_bool_t finished;
 };
 
+struct ks_dht_storageitem_s {
+	ks_pool_t *pool;
+	ks_dht_nodeid_t id;
+
+	struct bencode *v;
+	
+	ks_bool_t mutable;
+	ks_dht_storageitem_key_t pk;
+	ks_dht_storageitem_key_t sk;
+	uint8_t salt[KS_DHT_STORAGEITEM_SALT_MAX_SIZE];
+	ks_size_t salt_length;
+	int64_t seq;
+	ks_dht_storageitem_signature_t sig;
+};
 
 struct ks_dht_s {
 	ks_pool_t *pool;
@@ -117,6 +156,11 @@ struct ks_dht_s {
 
 	ks_dhtrt_routetable_t *rt_ipv4;
 	ks_dhtrt_routetable_t *rt_ipv6;
+
+	volatile uint32_t token_secret_current;
+	volatile uint32_t token_secret_previous;
+	ks_time_t token_secret_expiration;
+	ks_hash_t *storage_hash;
 };
 
 /**

libs/libks/src/dht/ks_dht_storageitem.c

+#include "ks_dht.h"
+#include "ks_dht-int.h"
+#include "sodium.h"
+
+/**
+ *
+ */
+KS_DECLARE(ks_status_t) ks_dht_storageitem_alloc(ks_dht_storageitem_t **item, ks_pool_t *pool)
+{
+	ks_dht_storageitem_t *si;
+
+	ks_assert(item);
+	ks_assert(pool);
+	
+	*item = si = ks_pool_alloc(pool, sizeof(ks_dht_storageitem_t));
+	si->pool = pool;
+	si->v = NULL;
+	si->mutable = KS_FALSE;
+	si->salt_length = 0;
+	si->seq = 0;
+
+	return KS_STATUS_SUCCESS;
+}
+
+/**
+ *
+ */
+KS_DECLARE(ks_status_t) ks_dht_storageitem_prealloc(ks_dht_storageitem_t *item, ks_pool_t *pool)
+{
+	ks_assert(item);
+	ks_assert(pool);
+
+	item->pool = pool;
+	item->v = NULL;
+	item->mutable = KS_FALSE;
+	item->salt_length = 0;
+	item->seq = 0;
+
+	return KS_STATUS_SUCCESS;
+}
+
+/**
+ *
+ */
+KS_DECLARE(ks_status_t) ks_dht_storageitem_free(ks_dht_storageitem_t *item)
+{
+	ks_assert(item);
+
+	ks_dht_storageitem_deinit(item);
+	ks_pool_free(item->pool, item);
+
+	return KS_STATUS_SUCCESS;
+}
+
+
+/**
+ *
+ */
+KS_DECLARE(ks_status_t) ks_dht_storageitem_init(ks_dht_storageitem_t *item, struct bencode *v)
+{
+	ks_assert(item);
+	ks_assert(item->pool);
+	ks_assert(v);
+	ks_assert(SHA_DIGEST_LENGTH == KS_DHT_NODEID_SIZE);
+
+	item->v = ben_clone(v);
+
+	return KS_STATUS_SUCCESS;
+}
+
+/**
+ *
+ */
+KS_DECLARE(ks_status_t) ks_dht_storageitem_deinit(ks_dht_storageitem_t *item)
+{
+	ks_assert(item);
+
+	if (item->v) {
+		ben_free(item->v);
+		item->v = NULL;
+	}
+
+	return KS_STATUS_SUCCESS;
+}
+
+/**
+ *
+ */
+KS_DECLARE(ks_status_t) ks_dht_storageitem_create(ks_dht_storageitem_t *item, ks_bool_t mutable)
+{
+	SHA_CTX sha;
+
+	ks_assert(item);
+	ks_assert(item->pool);
+	ks_assert(item->v);
+	
+	item->mutable = mutable;
+
+	if (!mutable) {
+		size_t enc_len = 0;
+		uint8_t *enc = ben_encode(&enc_len, item->v);
+		SHA1_Init(&sha);
+		SHA1_Update(&sha, enc, enc_len);
+		SHA1_Final(item->id.id, &sha);
+		free(enc);
+	} else {
+		size_t enc_len = 0;
+		uint8_t *enc = NULL;
+		struct bencode *sig = ben_dict();
+		
+		crypto_sign_keypair(item->pk.key, item->sk.key);
+		randombytes_buf(item->salt, KS_DHT_STORAGEITEM_SALT_MAX_SIZE);
+		item->salt_length = KS_DHT_STORAGEITEM_SALT_MAX_SIZE;
+		item->seq = 1;
+
+		ben_dict_set(sig, ben_blob("salt", 4), ben_blob(item->salt, item->salt_length));
+		ben_dict_set(sig, ben_blob("seq", 3), ben_int(item->seq));
+		ben_dict_set(sig, ben_blob("v", 1), ben_clone(item->v));
+		enc = ben_encode(&enc_len, sig);
+		ben_free(sig);
+
+		SHA1_Init(&sha);
+		SHA1_Update(&sha, enc, enc_len);
+		SHA1_Final(item->sig.sig, &sha);
+
+		free(enc);
+
+		SHA1_Init(&sha);
+		SHA1_Update(&sha, item->pk.key, KS_DHT_STORAGEITEM_KEY_SIZE);
+		SHA1_Update(&sha, item->salt, item->salt_length);
+		SHA1_Final(item->id.id, &sha);
+	}
+
+	return KS_STATUS_SUCCESS;
+}
+
+/**
+ *
+ */
+KS_DECLARE(ks_status_t) ks_dht_storageitem_immutable(ks_dht_storageitem_t *item)
+{
+	SHA_CTX sha;
+	size_t enc_len = 0;
+	uint8_t *enc = NULL;
+	
+	ks_assert(item);
+	ks_assert(item->v);
+
+	item->mutable = KS_FALSE;
+	
+	enc = ben_encode(&enc_len, item->v);
+	SHA1_Init(&sha);
+	SHA1_Update(&sha, enc, enc_len);
+	SHA1_Final(item->id.id, &sha);
+	free(enc);
+
+	return KS_STATUS_SUCCESS;
+}
+
+/**
+ *
+ */
+KS_DECLARE(ks_status_t) ks_dht_storageitem_mutable(ks_dht_storageitem_t *item,
+												   ks_dht_storageitem_key_t *k,
+												   uint8_t *salt,
+												   ks_size_t salt_length,
+												   int64_t sequence,
+												   ks_dht_storageitem_signature_t *signature)
+{
+	SHA_CTX sha;
+	
+	ks_assert(item);
+	ks_assert(item->v);
+	ks_assert(k);
+	ks_assert(!(!salt && salt_length > 0));
+	ks_assert(salt_length > KS_DHT_STORAGEITEM_SIGNATURE_SIZE);
+	ks_assert(signature);
+
+	item->mutable = KS_TRUE;
+
+	memcpy(item->pk.key, k->key, KS_DHT_STORAGEITEM_KEY_SIZE);
+	if (salt && salt_length > 0) {
+		memcpy(item->salt, salt, salt_length);
+		item->salt_length = salt_length;
+	}
+	item->seq = sequence;
+	memcpy(item->sig.sig, signature->sig, KS_DHT_STORAGEITEM_SIGNATURE_SIZE);
+
+	SHA1_Init(&sha);
+	SHA1_Update(&sha, item->pk.key, KS_DHT_STORAGEITEM_KEY_SIZE);
+	if (item->salt && item->salt_length > 0) {
+		SHA1_Update(&sha, item->salt, item->salt_length);
+	}
+	SHA1_Final(item->id.id, &sha);
+
+	return KS_STATUS_SUCCESS;
+}
+												
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
+ */