class CredentialStorage:
def __init__(self):
self.identityStorage = MemoryIdentityStorage()
self.privateKeyStorage = MemoryPrivateKeyStorage()
self.keyChain = KeyChain(IdentityManager(self.identityStorage, self.privateKeyStorage),
SelfVerifyPolicyManager(self.identityStorage))
keyName = Name("/testname/DSK-123")
self.defaultCertName = keyName[:-1].append(
"KEY").append(keyName[-1]).append("ID-CERT").append("0")
ecdsaKeyName = Name("/testEcdsa/DSK-123")
self.ecdsaCertName = ecdsaKeyName[:-1].append(
"KEY").append(ecdsaKeyName[-1]).append("ID-CERT").append("0")
self.identityStorage.addKey(
keyName, KeyType.RSA, Blob(DEFAULT_RSA_PUBLIC_KEY_DER))
self.privateKeyStorage.setKeyPairForKeyName(
keyName, KeyType.RSA, DEFAULT_RSA_PUBLIC_KEY_DER, DEFAULT_RSA_PRIVATE_KEY_DER)
self.identityStorage.addKey(
ecdsaKeyName, KeyType.ECDSA, Blob(DEFAULT_EC_PUBLIC_KEY_DER))
self.privateKeyStorage.setKeyPairForKeyName(
ecdsaKeyName, KeyType.ECDSA, DEFAULT_EC_PUBLIC_KEY_DER, DEFAULT_EC_PRIVATE_KEY_DER)
def signData(self, data, certificateName = None):
if certificateName is None:
certificateName = self.defaultCertName
self.keyChain.sign(data, certificateName)
def signDataWithSha256(self, data):
self.keyChain.signWithSha256(data)
def verifyData(self, data, verifiedCallback, failedCallback):
self.keyChain.verifyData(data, verifiedCallback, failedCallback)
class CredentialStorage:
def __init__(self):
self.identityStorage = MemoryIdentityStorage()
self.privateKeyStorage = MemoryPrivateKeyStorage()
self.keyChain = KeyChain(IdentityManager(self.identityStorage, self.privateKeyStorage),
SelfVerifyPolicyManager(self.identityStorage))
keyName = Name("/testname/DSK-123")
self.defaultCertName = keyName[:-1].append(
"KEY").append(keyName[-1]).append("ID-CERT").append("0")
ecdsaKeyName = Name("/testEcdsa/DSK-123")
self.ecdsaCertName = ecdsaKeyName[:-1].append(
"KEY").append(ecdsaKeyName[-1]).append("ID-CERT").append("0")
self.identityStorage.addKey(
keyName, KeyType.RSA, Blob(DEFAULT_RSA_PUBLIC_KEY_DER))
self.privateKeyStorage.setKeyPairForKeyName(
keyName, KeyType.RSA, DEFAULT_RSA_PUBLIC_KEY_DER, DEFAULT_RSA_PRIVATE_KEY_DER)
self.identityStorage.addKey(
ecdsaKeyName, KeyType.EC, Blob(DEFAULT_EC_PUBLIC_KEY_DER))
self.privateKeyStorage.setKeyPairForKeyName(
ecdsaKeyName, KeyType.EC, DEFAULT_EC_PUBLIC_KEY_DER, DEFAULT_EC_PRIVATE_KEY_DER)
def signData(self, data, certificateName = None):
if certificateName is None:
certificateName = self.defaultCertName
self.keyChain.sign(data, certificateName)
def signDataWithSha256(self, data):
self.keyChain.signWithSha256(data)
def verifyData(self, data, verifiedCallback, failedCallback):
self.keyChain.verifyData(data, verifiedCallback, failedCallback)
def prepare_data(filePath, keychain: KeyChain):
"""
Shard file into data packets.
"""
temp_data={}
logging.info('preparing data for {}'.format(filePath))
print('preparing data for {}'.format(filePath))
with open(filePath, 'rb') as binary_file:
b_array = bytearray(binary_file.read())
if len(b_array) == 0:
logging.warning("File is 0 bytes")
return
n_packets = int((len(b_array) - 1) / MAX_BYTES_IN_DATA_PACKET + 1)
print('There are {} packets'.format(n_packets))
seq = 0
for i in range(0, len(b_array), MAX_BYTES_IN_DATA_PACKET):
data = Data(Name(VIDEO_STREAM_NAME).append(filePath.split('.')[0]).append(str(seq)))
data.setContent(b_array[i: min(i + MAX_BYTES_IN_DATA_PACKET, len(b_array))])
data.metaInfo.setFinalBlockId(Name.Component.fromSegment(n_packets - 1))
keychain.signWithSha256(data)
temp_data[str(data.getName())] = data
seq += 1
print('{} packets prepared: {}'.format(n_packets, str(Name(VIDEO_STREAM_NAME).append(filePath.split('.')[0]))))
return temp_data
def test_verify_digest_sha256(self):
# Create a KeyChain but we don't need to add keys.
identityStorage = MemoryIdentityStorage()
keyChain = KeyChain(
IdentityManager(identityStorage, MemoryPrivateKeyStorage()),
SelfVerifyPolicyManager(identityStorage))
interest = Interest(Name("/test/signed-interest"))
keyChain.signWithSha256(interest)
# We create 'mock' objects to replace callbacks since we're not
# interested in the effect of the callbacks themselves.
failedCallback = Mock()
verifiedCallback = Mock()
keyChain.verifyInterest(interest, verifiedCallback, failedCallback)
self.assertEqual(failedCallback.call_count, 0, 'Signature verification failed')
self.assertEqual(verifiedCallback.call_count, 1, 'Verification callback was not used.')
def test_verify_digest_sha256(self):
# Create a KeyChain but we don't need to add keys.
identityStorage = MemoryIdentityStorage()
keyChain = KeyChain(
IdentityManager(identityStorage, MemoryPrivateKeyStorage()),
SelfVerifyPolicyManager(identityStorage))
interest = Interest(Name("/test/signed-interest"))
keyChain.signWithSha256(interest)
# We create 'mock' objects to replace callbacks since we're not
# interested in the effect of the callbacks themselves.
failedCallback = Mock()
verifiedCallback = Mock()
keyChain.verifyInterest(interest, verifiedCallback, failedCallback)
self.assertEqual(failedCallback.call_count, 0, 'Signature verification failed')
self.assertEqual(verifiedCallback.call_count, 1, 'Verification callback was not used.')
class PutfileClient(object):
"""
This client serves random segmented data
"""
def __init__(self, args):
self.repo_name = Name(args.repo_name)
self.file_path = args.file_path
self.name_at_repo = Name(args.name)
self.face = Face()
self.keychain = KeyChain()
self.face.setCommandSigningInfo(
self.keychain, self.keychain.getDefaultCertificateName())
self.running = True
self.m_name_str_to_data = dict()
self.n_packets = 0
self.prepare_data()
self.face.registerPrefix(self.name_at_repo, None,
self.on_register_failed)
self.face.setInterestFilter(self.name_at_repo, self.on_interest)
async def face_loop(self):
while self.running:
self.face.processEvents()
await asyncio.sleep(0.001)
def prepare_data(self):
"""
Shard file into data packets.
"""
logging.info('preparing data')
with open(self.file_path, 'rb') as binary_file:
b_array = bytearray(binary_file.read())
if len(b_array) == 0:
logging.warning("File is 0 bytes")
return
self.n_packets = int((len(b_array) - 1) / MAX_BYTES_IN_DATA_PACKET + 1)
logging.info('There are {} packets in total'.format(self.n_packets))
seq = 0
for i in range(0, len(b_array), MAX_BYTES_IN_DATA_PACKET):
data = Data(Name(self.name_at_repo).append(str(seq)))
data.metaInfo.freshnessPeriod = 100000
data.setContent(
b_array[i:min(i + MAX_BYTES_IN_DATA_PACKET, len(b_array))])
data.metaInfo.setFinalBlockId(
Name.Component.fromSegment(self.n_packets - 1))
self.keychain.signWithSha256(data)
self.m_name_str_to_data[str(data.getName())] = data
seq += 1
@staticmethod
def on_register_failed(prefix):
logging.error("Prefix registration failed: %s", prefix)
def on_interest(self, _prefix, interest: Interest, face, _filter_id,
_filter):
logging.info('On interest: {}'.format(interest.getName()))
if str(interest.getName()) in self.m_name_str_to_data:
self.face.putData(self.m_name_str_to_data[str(interest.getName())])
logging.info('Serve data: {}'.format(interest.getName()))
else:
logging.info('Data does not exist: {}'.format(interest.getName()))
async def insert_segmented_file(self):
event_loop = asyncio.get_event_loop()
face_task = event_loop.create_task(self.face_loop())
parameter = RepoCommandParameterMessage()
for compo in self.name_at_repo:
parameter.repo_command_parameter.name.component.append(
compo.getValue().toBytes())
parameter.repo_command_parameter.start_block_id = 0
parameter.repo_command_parameter.end_block_id = self.n_packets - 1
param_blob = ProtobufTlv.encode(parameter)
# Prepare cmd interest
name = Name(self.repo_name).append('insert').append(
Name.Component(param_blob))
interest = Interest(name)
self.face.makeCommandInterest(interest)
logging.info('Send insert command interest')
ret = await fetch_data_packet(self.face, interest)
if not isinstance(ret, Data):
logging.warning('Insert failed')
return
response = RepoCommandResponseMessage()
try:
ProtobufTlv.decode(response, ret.content)
except RuntimeError as exc:
logging.warning('Response decoding failed', exc)
process_id = response.repo_command_response.process_id
status_code = response.repo_command_response.status_code
logging.info('Insertion process {} accepted: status code {}'.format(
process_id, status_code))
# Use insert check command to probe if insert process is completed
checker = CommandChecker(self.face, self.keychain)
while True:
response = await checker.check_insert(self.repo_name, process_id)
if response is None or response.repo_command_response.status_code == 300:
await asyncio.sleep(1)
elif response.repo_command_response.status_code == 200:
logging.info(
'Insert process {} status: {}, insert_num: {}'.format(
process_id, response.repo_command_response.status_code,
response.repo_command_response.insert_num))
break
else:
# Shouldn't get here
assert (False)
self.running = False
await face_task
