def get(self, uid):
'''
The uid of the file_object in question has to be given in the url
The return format will be {"binary": b64_encoded_binary, "file_name": file_name}
'''
with ConnectTo(FrontEndDbInterface, self.config) as db_service:
existence = db_service.existence_quick_check(uid)
if not existence:
return error_message('No firmware with UID {} found in database'.format(uid), self.URL, request_data={'uid': uid}, return_code=404)
try:
tar_flag = get_boolean_from_request(request.args, 'tar')
except ValueError as value_error:
return error_message(str(value_error), self.URL, request_data=dict(uid=uid, tar=request.args.get('tar')))
with ConnectTo(InterComFrontEndBinding, self.config) as intercom:
if not tar_flag:
binary, file_name = intercom.get_binary_and_filename(uid)
else:
binary, file_name = intercom.get_repacked_binary_and_file_name(uid)
response = {
'binary': standard_b64encode(binary).decode(),
'file_name': file_name,
'SHA256': get_sha256(binary)
}
return success_message(response, self.URL, request_data={'uid': uid, 'tar': tar_flag})
def test_init_dsk(self):
test_file = os.path.join(TEST_DATA_DIR, 'test.dsk1')
test_obj = DskOne(test_file)
self.assertEqual(test_obj.raw[1:4], b'DSK', 'Raw Data not set correct')
self.assertEqual(test_obj.header[1], b'DSK1.0', 'header parsing not correct')
self.assertEqual(test_obj.payload_size, 860293, 'payload length not correct')
self.assertEqual(get_sha256(test_obj.decoded_payload), '057e936e6c1d45d617fe52decd532776c95c06a1b5e4a8f752d4227a645e5edc', 'payload checksum not correct')
def create_uid(input_data):
'''
creates an unique identifier: SHA256_SIZE
'''
hash_value = get_sha256(input_data)
size = len(make_bytes(input_data))
return "{}_{}".format(hash_value, size)
def create_uid(input_data: bytes) -> str:
'''
generate a UID (unique identifier) SHA256_SIZE for a byte string containing data (e.g. a binary)
:param input_data: the data to generate the UID for
:return: a string containing the UID
'''
hash_value = get_sha256(input_data)
size = len(make_bytes(input_data))
return '{}_{}'.format(hash_value, size)
def set_binary(self, binary: bytes) -> None:
'''
Store the binary representation of the file as byte string.
Additionally set binary related meta data (size, hash) and compute uid after that.
:param binary: file in binary representation
'''
self.binary = make_bytes(binary)
self.sha256 = get_sha256(self.binary)
self.size = len(self.binary)
self._uid = create_uid(binary)
def test_compute_sha256_of_file(self):
data = b'-' * 2000
with TemporaryDirectory(prefix='unit_test_') as tmp_dir:
test_file = Path(tmp_dir) / 'test_file'
with open(test_file, 'wb') as f:
f.write(data)
sha256 = compute_sha256_of_file(test_file)
# test that the computed sha is the same with both methods
self.assertEqual(get_sha256(data), sha256,
"not correct from string")
def test_extraction(self):
in_file = os.path.join(TEST_DATA_DIR, 'test.zlib')
files, meta_data = self.unpacker.extract_files_from_file(
in_file, self.tmp_dir.name)
self.assertEqual(len(files), 1,
'number of extracted files not correct')
self.assertEqual(files[0],
os.path.join(self.tmp_dir.name, 'zlib_decompressed'),
'file name not correct')
file_binary = get_binary_from_file(files[0])
file_hash = get_sha256(file_binary)
self.assertEqual(
file_hash,
'e429103649e24ca126077bfb38cce8c57cc913a966d7e36356e4fe0513ab02c4')
self.assertEqual(len(meta_data.keys()), 4,
'more or fewer than standard keys in meta dict')
def test_header_and_binary(self):
files, meta_data = self.unpacker.extract_files_from_file(
self.test_file.file_path, self.tmp_dir.name)
files = set(files)
self.assertEqual(len(files), 1, 'file number incorrect')
data_bin = get_binary_from_file(
os.path.join(self.tmp_dir.name, 'dlm_data.bin'))
self.assertEqual(
get_sha256(data_bin),
'701962b0d11f50d9129d5a1655ee054865e90cd1b547d40d590ea96f7dfb64eb')
self.assertEqual(meta_data['dlm_version'], 'NO_DLM_VERSION_CHECK',
'meta: dlm_version not correct')
self.assertEqual(
meta_data['dlm_signature'],
'90ec11f7b52468378362987a4ed9e56855070915887e6afe567e1c47875b29f9',
'meta: dlm_signature not correct')
self.assertEqual(meta_data['dlm_name'], '080415_08142013',
'meta: dlm_name not correct')
self.assertEqual(meta_data['dlm_extraction_criteria'],
'upgradeExtract.sh /tmp/080415_08142013.dnld',
'meta: dlm_criteria not correct')
def get(self, uid):
'''
The uid of the file_object in question has to be given in the url
The return format will be {"binary": b64_encoded_binary, "file_name": file_name}
'''
with ConnectTo(FrontEndDbInterface, self.config) as db_service:
existence = db_service.existence_quick_check(uid)
if not existence:
return error_message(
'No firmware with UID {} found in database'.format(uid),
self.URL,
request_data={'uid': uid},
return_code=404)
with ConnectTo(InterComFrontEndBinding, self.config) as intercom:
binary, file_name = intercom.get_binary_and_filename(uid)
response = {
'binary': standard_b64encode(binary).decode(),
'file_name': file_name,
'SHA256': get_sha256(binary)
}
return success_message(response, self.URL, request_data={'uid': uid})
def set_binary(self, binary):
self.binary = make_bytes(binary)
self.sha256 = get_sha256(self.binary)
self.size = len(self.binary)
self.uid = create_uid(binary)
def generate_task_id(input_data):
serialized_data = pickle.dumps(input_data)
task_id = '{}_{}'.format(get_sha256(serialized_data), time())
return task_id
def _hash_compare(self, filename, hashsum):
binary_data = get_binary_from_file(
os.path.join(self.tmp_dir.name, filename))
self.assertEqual(get_sha256(binary_data), hashsum,
'Checksum incorrect for file {}'.format(filename))
def test_get_sha256():
assert get_sha256(TEST_STRING) == TEST_SHA256, 'not correct from string'
def test_get_sha256(self):
self.assertEqual(get_sha256(self.test_string), self.test_string_SHA256,
"not correct from string")
