def handle_find(self, message, find_value=False):
# logger('RCV FIND: ', find_value)
key = kadmini_codec.guid_bts_to_int(message["id"])
id = kadmini_codec.guid_bts_to_int(message["peer_id"])
if id == key:
# logger('KEY IS PEER')
guid_owner = cdx.guid_int_to_bts(key)
# logger('\n\n\n + + + ++ ++ GUID' , guid_owner)
if guid_owner in self.server.dht.storage.pubkeys:
# logger(' \n\n\n + + ++ ++ + IN PUBKEYS \n \n \n\ ')
pass
else:
# todo async
self.server.dht.storage.dhf.pull_pubkey(guid=guid_owner,
remote_only=True)
pass
# self.server.dht
# if guid_owner in self.pubkeys:
# logger('HAVE PUBKEY', guid_owner)
msg_rpc_id_int = cdx.guid_bts_to_int(message["rpc_id"])
info = None
client_host, client_port = self.client_address
peer = Peer(client_host, client_port, id, info)
response_socket = self.request[1]
# logger('RCV FIND KEY', key)
if find_value and (key in self.server.dht.data):
bv = self.server.dht.storage.pull(key)
# logger('RCV FIND VALUE')
peer.found_value(id,
bv,
msg_rpc_id_int,
socket=response_socket,
peer_id=self.server.dht.peer.id,
peer_info=self.server.dht.peer.info,
lock=self.server.send_lock)
else:
nearest_nodes = self.server.dht.buckets.nearest_nodes(id)
if not nearest_nodes:
nearest_nodes.append(self.server.dht.peer)
nearest_nodes = [
nearest_peer.astriple() for nearest_peer in nearest_nodes
]
peer.found_nodes(id,
nearest_nodes,
msg_rpc_id_int,
socket=response_socket,
peer_id=self.server.dht.peer.id,
peer_info=self.server.dht.peer.info,
lock=self.server.send_lock)
def handle_dht(self, message, message_type):
# todo make it in dict or something, some general protocol handler
# that way is lame, .... whole thing have to refactored in brand new kademlia
try:
# handle message receive
if message_type == "ping":
self.handle_ping(message)
elif message_type == "pong":
self.handle_pong(message)
elif message_type == "find_node":
self.handle_find(message)
elif message_type == "find_value":
self.handle_find(message, find_value=True)
elif message_type == "found_nodes":
self.handle_found_nodes(message)
elif message_type == "found_value":
self.handle_found_value(message)
elif message_type == "store":
self.handle_store(message)
except KeyError:
pass
except ValueError:
pass
client_host, client_port = self.client_address
peer_id = kadmini_codec.guid_bts_to_int(message["peer_id"])
# peer_info = message["peer_info"] # disabled in protocol
peer_info = None
new_peer = Peer(client_host, client_port, peer_id, peer_info)
self.server.dht.buckets.insert(new_peer)
def handle_ping(self, message):
# logger('RCV PING', )
client_host, client_port = self.client_address
id = kadmini_codec.guid_bts_to_int(message["peer_id"])
# info = message["peer_info"] # diabled in protocol
info = None
peer = Peer(client_host, client_port, id, info)
peer.pong(socket=self.server.socket, peer_id=self.server.dht.peer.id, lock=self.server.send_lock)
d = None
dl = None
try:
ert_profile_ctl = main_profile(
http_webdir=http_webdir,
files_dir_name=config.static_files,
cdn_host=boot_cdn_host,
cdn_port=boot_cdn_port,
shared_profile_instance_id=args.shared_profile_instance_id)
ert = ert_profile_ctl
if args.upnp_attempt:
upnp.punch_port(udp_port, udp_port, args.if_name)
hex_guid, bin_guid = ert_profile_ctl.rsa_guid_hex_bin
int_guid = kadmini_codec.guid_bts_to_int(bin_guid)
bts_2 = kadmini_codec.guid_int_to_bts(int_guid)
hex2_guid = kadmini_codec.guid_int_to_hex(int_guid)
assert hex2_guid == hex_guid
#
storage_handle = store_handler.DHTStoreHandlerOne(
dht_sqlite_file=ert.dht_fb_fn,
pubkeys_sqlite_file=ert.dht_ref_pubkeys_fn,
)
# local_ip = upnp.get_my_ip()
# todo
from toolkit.tools import get_ip_address
local_ip = get_ip_address(args.if_name)
ip = local_ip
def push(self, key, val, signature, guid_owner):
print('STORE HANDLER PUSH')
print('HK', key)
# sig_val = (signature, val)
owner_signature_value = (guid_owner, signature, val)
revision, data = cdx.decode_bson_val(val)
if 'ert:pubkey' in data:
pubkey_der = data['ert:pubkey']
# print('PUBKEY DER', pubkey_der)
is_ok = cdx.verify_message(val, signature, pubkey_der)
print('PUBKEY RCV')
if is_ok:
print('SIGNATURE OK')
if cdx.pub_der_guid_bts(pubkey_der) == guid_owner:
print('FROM HASH OK')
# todo may be check before all checks
if guid_owner not in self.pubkeys:
print('STORE PUB KEY')
# store only reference
self.pubkeys[guid_owner] = key
print('STORE IN DHT')
return self.store.__setitem__(key,
owner_signature_value)
else:
print('PUB KEY EXIST')
return
else:
print('CHECKS FAILED PUBKEY NOT STORED')
return
else:
print('STORE RCV')
print('guid_owner', guid_owner)
if guid_owner in self.pubkeys:
print('HAVE PUBKEY', guid_owner)
hk_from_store = self.pubkeys[guid_owner]
hk = hk_from_store
if isinstance(hk_from_store, bytes):
hk = cdx.guid_bts_to_int(hk_from_store)
elif isinstance(hk_from_store, int):
hk = hk_from_store
else:
raise ValueError('HKEY REF PUBKEY ERROR')
pk_owner, pk_signature, pk_value = self.pull(hk)
# pk_value =
pk_rev, pubkey_data = cdx.decode_bson_val(pk_value)
if 'ert:pubkey' in pubkey_data:
print('ert:pubkey IN local DHT')
pubkey_der = pubkey_data['ert:pubkey']
val_ok = cdx.verify_message(val, signature, pubkey_der)
if val_ok:
print('VAL SIG OK STORE IN DHT')
# pk_rev, data = cdx.decode_bson_val(pk_value)
# if self.ON_PUSH_PEER_KEY in key:
print('\n\n\n +++')
self.on_pushed_ip4_peer(data, hk_int=key)
print('\n\n\n +++')
# event handler here
return self.store.__setitem__(key,
owner_signature_value)
else:
print('VAL SIG FAILED')
else:
'ERR ert:pubkey not found'
else:
print('NO PUB KEY FOUND')
def rsa_guid_int(self) -> int:
return cdx.guid_bts_to_int(self.rsa_guid_bin)
