def _on_incoming_suppliers_list(self, inp):
# this packet came from another supplier who belongs to that family also
incoming_packet = inp['packet']
if _Debug:
lg.out(
_DebugLevel,
'family_member._on_incoming_suppliers_list with %s' %
incoming_packet)
if not self.my_info:
if _Debug:
lg.out(_DebugLevel,
' current DHT info is not yet known, skip')
return p2p_service.SendAck(incoming_packet)
try:
another_ecc_map = inp['customer_ecc_map']
another_suppliers_list = inp['suppliers_list']
another_revision = int(inp['transaction_revision'])
except:
lg.exc()
return p2p_service.SendFail(incoming_packet,
response=serialization.DictToBytes(
self.my_info))
if _Debug:
lg.out(
_DebugLevel,
' another_revision=%d another_ecc_map=%s another_suppliers_list=%r'
% (another_revision, another_ecc_map, another_suppliers_list))
if another_revision >= int(self.my_info['revision']):
self.my_info = self._do_create_revision_from_another_supplier(
another_revision, another_suppliers_list, another_ecc_map)
lg.info(
'another supplier have more fresh revision, update my info and raise "family-refresh" event'
)
self.automat('family-refresh')
return p2p_service.SendAck(incoming_packet)
if my_id.getLocalIDURL() not in another_suppliers_list:
lg.warn(
'another supplier is trying to remove my IDURL from the family of customer %s'
% self.customer_idurl)
return p2p_service.SendFail(incoming_packet,
response=serialization.DictToBytes(
self.my_info))
my_position_in_transaction = another_suppliers_list.index(
my_id.getLocalIDURL())
my_known_position = self.my_info['suppliers'].index(
my_id.getLocalIDURL())
if my_position_in_transaction != my_known_position:
lg.warn(
'another supplier is trying to put my IDURL on another position in the family of customer %s'
% self.customer_idurl)
return p2p_service.SendFail(incoming_packet,
response=serialization.DictToBytes(
self.my_info))
return p2p_service.SendAck(incoming_packet)
def encrypt_json(raw_data, secret_bytes_key, cipher_type='AES'):
# TODO: add salt to raw_data
padded_data = Padding.pad(
data_to_pad=raw_data,
block_size=AES.block_size,
)
if cipher_type == 'AES':
cipher = AES.new(
key=secret_bytes_key,
mode=AES.MODE_CBC,
)
elif cipher_type == 'DES3':
cipher = DES3.new(
key=secret_bytes_key,
mode=DES3.MODE_CBC,
)
else:
raise Exception('unsupported cipher type')
ct_bytes = cipher.encrypt(padded_data)
dct = {
'iv': base64.b64encode(cipher.iv).decode('utf-8'),
'ct': base64.b64encode(ct_bytes).decode('utf-8'),
}
encrypted_data = serialization.DictToBytes(dct, encoding='utf-8')
return encrypted_data
def SendRequestService(remote_idurl,
service_name,
json_payload={},
wide=False,
callbacks={},
timeout=60):
service_info = {
'name': service_name,
'payload': json_payload,
}
service_info_raw = serialization.DictToBytes(service_info)
if _Debug:
lg.out(
_DebugLevel,
'p2p_service.SendRequestService "%s" to %s with %d bytes' % (
service_name,
remote_idurl,
len(service_info_raw),
))
result = signed.Packet(
Command=commands.RequestService(),
OwnerID=my_id.getLocalID(),
CreatorID=my_id.getLocalID(),
PacketID=packetid.UniqueID(),
Payload=service_info_raw,
RemoteID=remote_idurl,
)
gateway.outbox(result,
wide=wide,
callbacks=callbacks,
response_timeout=timeout)
return result
def SendEvent(remote_idurl, event_id, payload=None,
producer_id=None, message_id=None, created=None,
packet_id=None, wide=False, callbacks={}, response_timeout=5):
if packet_id is None:
packet_id = packetid.UniqueID()
e_json = {
'event_id': event_id,
'payload': payload,
}
if producer_id and message_id:
e_json['producer_id'] = producer_id
e_json['message_id'] = message_id
if created:
e_json['created'] = created
e_json_src = serialization.DictToBytes(e_json)
if _Debug:
lg.out(_DebugLevel, "p2p_service.SendEvent to %s with %d bytes message json data" % (
remote_idurl, len(e_json_src)))
outpacket = signed.Packet(
Command=commands.Event(),
OwnerID=my_id.getLocalID(),
CreatorID=my_id.getLocalID(),
PacketID=packet_id,
Payload=e_json_src,
RemoteID=remote_idurl,
)
gateway.outbox(outpacket, wide=wide, callbacks=callbacks, response_timeout=response_timeout)
return outpacket
def Serialize(self):
"""
Create a string that stores all data fields of that ``encrypted.Block``
object.
"""
return serialization.DictToBytes({
'c':
self.CreatorID,
'b':
self.BackupID,
'n':
self.BlockNumber,
'e':
self.LastBlock,
'k':
base64.b64encode(self.EncryptedSessionKey).decode('utf-8'),
't':
self.SessionKeyType,
'l':
self.Length,
'p':
self.EncryptedData,
's':
self.Signature,
})
def doSendMyListFiles(self, *args, **kwargs):
"""
Action method.
"""
json_list_files = backup_fs.Serialize(
to_json=True,
filter_cb=lambda path_id, path, info: True if strng.to_text(info.key_id) == strng.to_text(self.key_id) else False,
)
# raw_list_files = json.dumps(json_list_files, indent=2, encoding='utf-8')
raw_list_files = serialization.DictToBytes(json_list_files, keys_to_text=True, values_to_text=True)
if _Debug:
lg.out(_DebugLevel, 'shared_access_donor.doSendMyListFiles prepared list of files for %s :\n%s' % (
self.remote_idurl, raw_list_files))
block = encrypted.Block(
CreatorID=my_id.getLocalID(),
BackupID=self.key_id,
Data=raw_list_files,
SessionKey=key.NewSessionKey(),
EncryptKey=self.key_id,
)
encrypted_list_files = block.Serialize()
packet_id = "%s:%s" % (self.key_id, packetid.UniqueID(), )
p2p_service.SendFiles(
idurl=self.remote_idurl,
raw_list_files_info=encrypted_list_files,
packet_id=packet_id,
callbacks={
commands.Ack(): lambda response, _: self.automat('list-files-ok', response),
commands.Fail(): lambda response, _: self.automat('fail', Exception(str(response))),
None: lambda pkt_out: self.automat('fail', Exception('timeout')),
},
)
def SendContacts(remote_idurl, json_payload={}, wide=False, callbacks={}):
"""
"""
MyID = my_id.getLocalID()
if _Debug:
lg.out(
_DebugLevel,
"p2p_service.SendContacts to %s" % nameurl.GetName(remote_idurl))
PacketID = packetid.UniqueID()
try:
json_payload['type']
json_payload['space']
except:
lg.err()
return None
Payload = serialization.DictToBytes(json_payload)
result = signed.Packet(
Command=commands.Contacts(),
OwnerID=MyID,
CreatorID=MyID,
PacketID=PacketID,
Payload=Payload,
RemoteID=remote_idurl,
)
gateway.outbox(result, wide=wide, callbacks=callbacks)
return result
def SendCancelService(remote_idurl,
service_name,
json_payload={},
wide=False,
callbacks={}):
service_info = {
'name': service_name,
'payload': json_payload,
}
service_info_raw = serialization.DictToBytes(service_info)
if _Debug:
lg.out(
_DebugLevel,
'p2p_service.SendCancelService "%s" to %s with %d bytes payload' %
(service_name, remote_idurl, len(service_info_raw)))
result = signed.Packet(
commands.CancelService(),
my_id.getLocalID(),
my_id.getLocalID(),
packetid.UniqueID(),
service_info_raw,
remote_idurl,
)
gateway.outbox(result, wide=wide, callbacks=callbacks)
return result
def _do_send_request_service(self, *args, **kwargs):
if len(self.request_service_packet_id) >= 10:
if _Debug:
lg.warn('too many service requests to %r' % self.router_idurl)
self.automat('service-refused', *args, **kwargs)
return
orig_identity = config.conf().getData('services/proxy-transport/my-original-identity').strip()
if not orig_identity:
orig_identity = my_id.getLocalIdentity().serialize(as_text=True)
service_info = {
'name': 'service_proxy_server',
'payload': {
'identity': orig_identity,
},
}
newpacket = signed.Packet(
commands.RequestService(),
my_id.getIDURL(),
my_id.getIDURL(),
packetid.UniqueID(),
serialization.DictToBytes(service_info, values_to_text=True),
self.router_idurl,
)
packet_out.create(
newpacket,
wide=False,
callbacks={
commands.Ack(): self._on_request_service_ack,
commands.Fail(): self._on_request_service_fail,
None: lambda pkt_out: self.automat('request-timeout', pkt_out),
},
response_timeout=30,
)
self.request_service_packet_id.append(newpacket.PacketID)
def Serialize(self):
"""
Create a string that stores all data fields of that ``encrypted.Block``
object.
"""
dct = {
'c':
self.CreatorID,
'b':
self.BackupID,
'n':
self.BlockNumber,
'e':
self.LastBlock,
'k':
strng.to_text(
base64.b64encode(strng.to_bin(self.EncryptedSessionKey))),
't':
self.SessionKeyType,
'l':
self.Length,
'p':
self.EncryptedData,
's':
self.Signature,
}
if _Debug:
lg.out(_DebugLevel, 'encrypted.Serialize %r' % dct)
return serialization.DictToBytes(dct, encoding='utf-8')
def audit_private_key(key_id, untrusted_idurl, timeout=10):
"""
Be sure remote user posses given private key.
I need to posses the public key to be able to audit.
I will generate a random string, encrypt it with given key public key and send encrypted string to him.
He will decrypt and send me back original string.
Returns Deferred object.
"""
if _Debug:
lg.out(_DebugLevel, 'key_ring.audit_private_key testing %s from %s' % (key_id, untrusted_idurl))
result = Deferred()
recipient_id_obj = identitycache.FromCache(untrusted_idurl)
if not recipient_id_obj:
lg.warn('not found "%s" in identity cache' % untrusted_idurl)
result.errback(Exception('not found "%s" in identity cache' % untrusted_idurl))
return result
key_alias, creator_idurl = my_keys.split_key_id(key_id)
if not key_alias or not creator_idurl:
lg.warn('wrong key_id')
result.errback(Exception('wrong key_id'))
return result
private_test_sample = key.NewSessionKey()
if untrusted_idurl == creator_idurl and key_alias == 'master':
lg.warn('doing audit of master key (private part) of remote user')
private_test_encrypted_sample = recipient_id_obj.encrypt(private_test_sample)
else:
if not my_keys.is_key_registered(key_id):
lg.warn('unknown key: "%s"' % key_id)
result.errback(Exception('unknown key: "%s"' % key_id))
return result
private_test_encrypted_sample = my_keys.encrypt(key_id, private_test_sample)
json_payload = {
'key_id': key_id,
'audit': {
'public_sample': '',
'private_sample': base64.b64encode(private_test_encrypted_sample),
}
}
raw_payload = serialization.DictToBytes(json_payload, values_to_text=True)
block = encrypted.Block(
BackupID=key_id,
Data=raw_payload,
SessionKey=key.NewSessionKey(),
# encrypt data using public key of recipient
EncryptKey=lambda inp: recipient_id_obj.encrypt(inp),
)
encrypted_payload = block.Serialize()
p2p_service.SendAuditKey(
remote_idurl=recipient_id_obj.getIDURL(),
encrypted_payload=encrypted_payload,
packet_id=key_id,
timeout=timeout,
callbacks={
commands.Ack(): lambda response, info:
_on_audit_private_key_response(response, info, key_id, untrusted_idurl, private_test_sample, result),
commands.Fail(): lambda response, info: result.errback(Exception(response)),
None: lambda pkt_out: result.errback(Exception('timeout')), # timeout
},
)
return result
def serialize(self):
dct = {
'r': self.recipient,
's': self.sender,
'k': self.encrypted_session,
'p': self.encrypted_body,
}
return serialization.DictToBytes(dct, encoding='utf-8')
def serialize(self):
dct = {
'r': self.recipient,
's': self.sender,
'k': strng.to_text(base64.b64encode(strng.to_bin(self.encrypted_session))),
'p': self.encrypted_body,
}
return serialization.DictToBytes(dct, encoding='utf-8')
def transfer_key(key_id, trusted_idurl, include_private=False, include_signature=False, timeout=10, result=None):
"""
Actually sending given key to remote user.
"""
if _Debug:
lg.out(_DebugLevel, 'key_ring.transfer_key %s -> %s' % (key_id, trusted_idurl))
if not result:
result = Deferred()
recipient_id_obj = identitycache.FromCache(trusted_idurl)
if not recipient_id_obj:
lg.warn('not found "%s" in identity cache' % trusted_idurl)
result.errback(Exception('not found "%s" in identity cache' % trusted_idurl))
return result
key_alias, creator_idurl = my_keys.split_key_id(key_id)
if not key_alias or not creator_idurl:
lg.warn('wrong key_id')
result.errback(Exception('wrong key_id'))
return result
if not my_keys.is_key_registered(key_id):
lg.warn('unknown key: "%s"' % key_id)
result.errback(Exception('unknown key: "%s"' % key_id))
return result
key_object = my_keys.key_obj(key_id)
try:
key_json = my_keys.make_key_info(
key_object,
key_id=key_id,
include_private=include_private,
include_signature=include_signature,
)
except Exception as exc:
lg.exc()
result.errback(exc)
return result
key_data = serialization.DictToBytes(key_json, values_to_text=True)
block = encrypted.Block(
BackupID=key_id,
Data=key_data,
SessionKey=key.NewSessionKey(session_key_type=key.SessionKeyType()),
SessionKeyType=key.SessionKeyType(),
# encrypt data using public key of recipient
EncryptKey=lambda inp: recipient_id_obj.encrypt(inp),
)
encrypted_key_data = block.Serialize()
p2p_service.SendKey(
remote_idurl=recipient_id_obj.getIDURL(),
encrypted_key_data=encrypted_key_data,
packet_id=key_id,
callbacks={
commands.Ack(): lambda response, info: _on_transfer_key_response(response, info, key_id, result),
commands.Fail(): lambda response, info: _on_transfer_key_response(response, info, key_id, result),
None: lambda pkt_out: _on_transfer_key_response(None, None, key_id, result),
},
timeout=timeout,
)
return result
def do_send_message(json_data, recipient_global_id, packet_id, message_ack_timeout, result_defer=None, fire_callbacks=True):
global _OutgoingMessageCallbacks
remote_idurl = global_id.GlobalUserToIDURL(recipient_global_id, as_field=False)
if not remote_idurl:
raise Exception('invalid recipient')
remote_identity = identitycache.FromCache(remote_idurl)
if not remote_identity:
raise Exception('remote identity object not exist in cache')
message_body = serialization.DictToBytes(
json_data,
pack_types=True,
encoding='utf-8',
)
if _Debug:
lg.out(_DebugLevel, "message.do_send_message to %s with %d bytes message ack_timeout=%s" % (
recipient_global_id, len(message_body), message_ack_timeout))
try:
private_message_object = PrivateMessage(recipient=recipient_global_id)
private_message_object.encrypt(message_body)
except:
lg.exc()
raise Exception('message encryption failed')
payload = private_message_object.serialize()
if _Debug:
lg.out(_DebugLevel, " payload is %d bytes, remote idurl is %s" % (len(payload), remote_idurl))
callbacks = {}
if message_ack_timeout:
callbacks = {
commands.Ack(): lambda response, info: on_message_delivered(
remote_idurl, json_data, recipient_global_id, packet_id, response, info, result_defer, ),
commands.Fail(): lambda response, info: on_message_failed(
remote_idurl, json_data, recipient_global_id, packet_id, response, info,
result_defer=result_defer, error='fail received'),
None: lambda pkt_out: on_message_failed(
remote_idurl, json_data, recipient_global_id, packet_id, None, None,
result_defer=result_defer, error='timeout', ),
'failed': lambda pkt_out, errmsg: on_message_failed(
remote_idurl, json_data, recipient_global_id, packet_id, None, None,
result_defer=result_defer, error=errmsg, ),
}
result, outpacket = p2p_service.SendMessage(
remote_idurl=remote_idurl,
packet_id=packet_id,
payload=payload,
callbacks=callbacks,
response_timeout=message_ack_timeout,
)
if fire_callbacks:
try:
for cp in _OutgoingMessageCallbacks:
cp(json_data, private_message_object, remote_identity, outpacket, result)
except:
lg.exc()
raise Exception('failed sending message')
return result
def SendCoin(remote_idurl, coins, packet_id=None, wide=False, callbacks={}):
if _Debug:
lg.out(_DebugLevel, "p2p_service.SendCoin to %s with %d records" % (remote_idurl, len(coins)))
if packet_id is None:
packet_id = packetid.UniqueID()
outpacket = signed.Packet(
commands.Coin(), my_id.getLocalID(),
my_id.getLocalID(), packet_id,
serialization.DictToBytes(coins), remote_idurl)
gateway.outbox(outpacket, wide=wide, callbacks=callbacks)
return outpacket
def test_serialization(self):
data1 = os.urandom(1024)
dct1 = {
'd': {
'data': data1,
},
}
raw = serialization.DictToBytes(dct1, encoding='latin1')
dct2 = serialization.BytesToDict(raw, encoding='latin1')
data2 = dct2['d']['data']
self.assertEqual(data1, data2)
def test_serialization(self):
from lib import serialization
data1 = os.urandom(1024)
dct1 = {
'd': {
'data': data1,
},
}
raw = serialization.DictToBytes(dct1)
dct2 = serialization.BytesToDict(raw)
data2 = dct2['d']['data']
self.assertEqual(data1, data2)
def push(json_data):
global _WebSocketTransport
if not _WebSocketTransport:
return False
raw_bytes = serialization.DictToBytes(json_data)
_WebSocketTransport.write(raw_bytes)
if _Debug:
lg.dbg(_DebugLevel, 'sent %d bytes to web socket: %r' % (len(raw_bytes), json_data))
if _Debug:
lg.out(0, '*** API WS PUSH %d bytes : %r' % (len(json_data), json_data, ))
if _APILogFileEnabled:
lg.out(0, '*** WS PUSH %d bytes : %r' % (len(json_data), json_data, ), log_name='api', showtime=True)
return True
def encrypt_json(raw_data, secret_16bytes_key):
# TODO: add salt to raw_data
cipher = AES.new(
key=secret_16bytes_key,
mode=AES.MODE_CBC,
)
ct_bytes = cipher.encrypt(Padding.pad(raw_data, AES.block_size))
dct = {
'iv': base64.b64encode(cipher.iv).decode('utf-8'),
'ct': base64.b64encode(ct_bytes).decode('utf-8'),
}
raw = serialization.DictToBytes(dct)
return raw
def SendRetrieveCoin(remote_idurl, query, wide=False, callbacks={}):
if _Debug:
lg.out(_DebugLevel, "p2p_service.SendRetrieveCoin to %s" % remote_idurl)
outpacket = signed.Packet(
commands.RetrieveCoin(),
my_id.getLocalID(),
my_id.getLocalID(),
packetid.UniqueID(),
serialization.DictToBytes(query),
remote_idurl,
)
gateway.outbox(outpacket, wide=wide, callbacks=callbacks)
return outpacket
def SendRetrieveCoin(remote_idurl, query, wide=False, callbacks={}):
if _Debug:
lg.out(_DebugLevel,
"p2p_service.SendRetrieveCoin to %s" % remote_idurl)
outpacket = signed.Packet(
Command=commands.RetrieveCoin(),
OwnerID=my_id.getIDURL(),
CreatorID=my_id.getIDURL(),
PacketID=packetid.UniqueID(),
Payload=serialization.DictToBytes(query),
RemoteID=remote_idurl,
)
gateway.outbox(outpacket, wide=wide, callbacks=callbacks)
return outpacket
def SendCoin(remote_idurl, coins, packet_id=None, wide=False, callbacks={}):
if _Debug:
lg.out(_DebugLevel, "p2p_service.SendCoin to %s with %d records" % (remote_idurl, len(coins)))
if packet_id is None:
packet_id = packetid.UniqueID()
outpacket = signed.Packet(
Command=commands.Coin(),
OwnerID=my_id.getLocalID(),
CreatorID=my_id.getLocalID(),
PacketID=packet_id,
Payload=serialization.DictToBytes(coins, keys_to_text=True),
RemoteID=remote_idurl,
)
gateway.outbox(outpacket, wide=wide, callbacks=callbacks)
return outpacket
def doSendCancelService(self, *args, **kwargs):
"""
Action method.
"""
newpacket = signed.Packet(
commands.CancelService(),
my_id.getIDURL(),
my_id.getIDURL(),
packetid.UniqueID(),
serialization.DictToBytes({'name': 'service_proxy_server', }),
self.router_idurl,
)
packet_out.create(newpacket, wide=True, callbacks={
commands.Ack(): self._on_request_service_ack,
commands.Fail(): self._on_request_service_fail,
})
def encrypt_json(raw_data, secret_16bytes_key):
# TODO: add salt to raw_data
padded_data = Padding.pad(
data_to_pad=raw_data,
block_size=AES.block_size,
)
cipher = AES.new(
key=secret_16bytes_key,
mode=AES.MODE_CBC,
)
ct_bytes = cipher.encrypt(padded_data)
dct = {
'iv': base64.b64encode(cipher.iv).decode('utf-8'),
'ct': base64.b64encode(ct_bytes).decode('utf-8'),
}
encrypted_data = serialization.DictToBytes(dct, encoding='utf-8')
return encrypted_data
def _write_route(self, user_id):
src = config.conf().getData('services/proxy-server/current-routes')
try:
dct = serialization.BytesToDict(strng.to_bin(src),
keys_to_text=True,
values_to_text=True)
except:
dct = {}
dct[user_id] = self.routes[user_id]
newsrc = strng.to_text(
serialization.DictToBytes(dct,
keys_to_text=True,
values_to_text=True))
config.conf().setData('services/proxy-server/current-routes', newsrc)
if _Debug:
lg.out(_DebugLevel,
'proxy_router._write_route %d bytes wrote' % len(newsrc))
def push_signed_message(producer_id, queue_id, data, creation_time=None):
try:
signed_data = signed.Packet(
Command=commands.Event(),
OwnerID=producer_id,
CreatorID=producer_id,
PacketID=packetid.UniqueID(),
Payload=serialization.DictToBytes(data, keys_to_text=True),
RemoteID=queue_id,
KeyID=producer_id,
)
except:
lg.exc()
raise Exception('sign message failed')
return push_message(producer_id,
queue_id,
data=signed_data.Serialize(),
creation_time=creation_time)
def _do_send_message_to_broker(self, json_payload=None, packet_id=None):
if packet_id is None:
packet_id = packetid.UniqueID()
if _Debug:
lg.args(_DebugLevel,
json_payload=json_payload,
packet_id=packet_id)
raw_payload = serialization.DictToBytes(
json_payload,
pack_types=True,
encoding='utf-8',
)
try:
private_message_object = message.GroupMessage(
recipient=self.group_key_id,
sender=self.producer_id,
)
private_message_object.encrypt(raw_payload)
except:
lg.exc()
raise Exception('message encryption failed')
encrypted_payload = private_message_object.serialize()
d = message.send_message(
json_data={
'msg_type': 'queue_message',
'action': 'produce',
'created': utime.get_sec1970(),
'payload': encrypted_payload,
'queue_id': self.active_queue_id,
'producer_id': self.producer_id,
},
recipient_global_id=self.active_broker_id,
packet_id=packetid.MakeQueueMessagePacketID(
self.active_queue_id, packet_id),
message_ack_timeout=config.conf().getInt(
'services/private-groups/message-ack-timeout'),
skip_handshake=True,
fire_callbacks=False,
)
if _Debug:
d.addErrback(lg.errback,
debug=_Debug,
debug_level=_DebugLevel,
method='message_producer._do_send_message_to_broker')
def SendListFiles(target_supplier, customer_idurl=None, key_id=None, query_items=[], wide=False, callbacks={}, timeout=None):
"""
This is used as a request method from your supplier : if you send him a ListFiles() packet
he will reply you with a list of stored files in a Files() packet.
"""
MyID = my_id.getLocalID()
if not customer_idurl:
customer_idurl = MyID
if not str(target_supplier).isdigit():
RemoteID = target_supplier
else:
RemoteID = contactsdb.supplier(target_supplier, customer_idurl=customer_idurl)
if not RemoteID:
lg.warn("RemoteID is empty target_supplier=%s" % str(target_supplier))
return None
if not key_id:
# key_id = global_id.MakeGlobalID(idurl=customer_idurl, key_alias='customer')
# TODO: due to issue with "customer" key backup/restore decided to always use my "master" key
# to retrieve my list files info from supplier
# expect remote user always poses my master public key from my identity.
# probably require more work to build more reliable solution without using my master key at all
# when my identity rotated supplier first needs to receive my new identity and then sending ListFiles()
key_id = my_id.getGlobalID(key_alias='master')
if not my_keys.is_key_registered(key_id) or not my_keys.is_key_private(key_id):
lg.warn('key %r not exist or public, my "master" key to be used with ListFiles() packet' % key_id)
key_id = my_id.getGlobalID(key_alias='master')
PacketID = "%s:%s" % (key_id, packetid.UniqueID(), )
if not query_items:
query_items = ['*', ]
Payload = serialization.DictToBytes({'items': query_items, })
if _Debug:
lg.out(_DebugLevel, "p2p_service.SendListFiles %r to %s with query : %r" % (
PacketID, nameurl.GetName(RemoteID), query_items, ))
result = signed.Packet(
Command=commands.ListFiles(),
OwnerID=MyID,
CreatorID=MyID,
PacketID=PacketID,
Payload=Payload,
RemoteID=RemoteID,
)
gateway.outbox(result, wide=wide, callbacks=callbacks, response_timeout=timeout)
return result
def Serialize(self):
"""
Create a string from packet object.
This is useful when need to save the packet on disk or send via network.
"""
dct = {
'm': self.Command,
'o': self.OwnerID,
'c': self.CreatorID,
'i': self.PacketID,
'd': self.Date,
'p': self.Payload,
'r': self.RemoteID,
'k': self.KeyID,
's': self.Signature,
}
if _Debug:
lg.out(_DebugLevel, 'signed.Serialize %r' % dct)
src = serialization.DictToBytes(dct)
return src
