def __init__(self, block_length, k): self.block_length = block_length self.aes_cipher = Cipher(algorithms.AES(k), modes.ECB(), default_backend()) self.pad = padding.PKCS7(8 * block_length)
def decrypt_file(metadata, encryption_material, in_filename, chunk_size=block_size * 4 * 1024, tmp_dir=None): """Decrypts a file and stores the output in the temporary directory. Args: metadata: The file's metadata input. encryption_material: The file's encryption material. in_filename: The name of the input file. chunk_size: The size of read chunks (Default value = block_size * 4 * 1024). tmp_dir: Temporary directory to use, optional (Default value = None). Returns: The decrypted file's location. """ logger = getLogger(__name__) use_openssl_only = os.getenv('SF_USE_OPENSSL_ONLY', 'False') == 'True' key_base64 = metadata.key iv_base64 = metadata.iv decoded_key = base64.standard_b64decode( encryption_material.query_stage_master_key) key_bytes = base64.standard_b64decode(key_base64) iv_bytes = base64.standard_b64decode(iv_base64) if not use_openssl_only: key_cipher = AES.new(key=decoded_key, mode=AES.MODE_ECB) file_key = PKCS5_UNPAD(key_cipher.decrypt(key_bytes)) data_cipher = AES.new(key=file_key, mode=AES.MODE_CBC, IV=iv_bytes) else: backend = default_backend() cipher = Cipher(algorithms.AES(decoded_key), modes.ECB(), backend=backend) decryptor = cipher.decryptor() file_key = PKCS5_UNPAD( decryptor.update(key_bytes) + decryptor.finalize()) cipher = Cipher(algorithms.AES(file_key), modes.CBC(iv_bytes), backend=backend) decryptor = cipher.decryptor() temp_output_fd, temp_output_file = tempfile.mkstemp( text=False, dir=tmp_dir, prefix=os.path.basename(in_filename) + "#") total_file_size = 0 prev_chunk = None logger.debug('encrypted file: %s, tmp file: %s', in_filename, temp_output_file) with open(in_filename, 'rb') as infile: with os.fdopen(temp_output_fd, 'wb') as outfile: while True: chunk = infile.read(chunk_size) if len(chunk) == 0: break total_file_size += len(chunk) if not use_openssl_only: d = data_cipher.decrypt(chunk) else: d = decryptor.update(chunk) outfile.write(d) prev_chunk = d if prev_chunk is not None: total_file_size -= PKCS5_OFFSET(prev_chunk) if use_openssl_only: outfile.write(decryptor.finalize()) outfile.truncate(total_file_size) return temp_output_file
"CBCVarKey256.rsp", "CBCVarTxt128.rsp", "CBCVarTxt192.rsp", "CBCVarTxt256.rsp", "CBCMMT128.rsp", "CBCMMT192.rsp", "CBCMMT256.rsp", ], lambda key, **kwargs: algorithms.AES(binascii.unhexlify(key)), lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)), ) @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported( algorithms.AES(b"\x00" * 16), modes.ECB() ), skip_message="Does not support AES ECB", ) class TestAESModeECB(object): test_ecb = generate_encrypt_test( load_nist_vectors, os.path.join("ciphers", "AES", "ECB"), [ "ECBGFSbox128.rsp", "ECBGFSbox192.rsp", "ECBGFSbox256.rsp", "ECBKeySbox128.rsp", "ECBKeySbox192.rsp", "ECBKeySbox256.rsp", "ECBVarKey128.rsp",
lambda iv, **kwargs: modes.CFB8(binascii.unhexlify(iv)), ) test_mmt = generate_encrypt_test( load_nist_vectors, os.path.join("ciphers", "3DES", "CFB"), ["TCFB8MMT1.rsp", "TCFB8MMT2.rsp", "TCFB8MMT3.rsp"], lambda key1, key2, key3, **kwargs: algorithms.TripleDES( binascii.unhexlify(key1 + key2 + key3)), lambda iv, **kwargs: modes.CFB8(binascii.unhexlify(iv)), ) @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported( algorithms.TripleDES(b"\x00" * 8), modes.ECB()), skip_message="Does not support TripleDES ECB", ) class TestTripleDESModeECB(object): test_kat = generate_encrypt_test( load_nist_vectors, os.path.join("ciphers", "3DES", "ECB"), [ "TECBinvperm.rsp", "TECBpermop.rsp", "TECBsubtab.rsp", "TECBvarkey.rsp", "TECBvartext.rsp", ], lambda keys, **kwargs: algorithms.TripleDES(binascii.unhexlify(keys)), lambda **kwargs: modes.ECB(),
class TestAESKeyWrap(object): @pytest.mark.parametrize( "params", _load_all_params(os.path.join("keywrap", "kwtestvectors"), ["KW_AE_128.txt", "KW_AE_192.txt", "KW_AE_256.txt"], load_nist_vectors)) @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported( algorithms.AES(b"\x00" * 16), modes.ECB()), skip_message="Does not support AES key wrap (RFC 3394) because AES-ECB" " is unsupported", ) def test_wrap(self, backend, params): wrapping_key = binascii.unhexlify(params["k"]) key_to_wrap = binascii.unhexlify(params["p"]) wrapped_key = keywrap.aes_key_wrap(wrapping_key, key_to_wrap, backend) assert params["c"] == binascii.hexlify(wrapped_key) @pytest.mark.parametrize( "params", _load_all_params(os.path.join("keywrap", "kwtestvectors"), ["KW_AD_128.txt", "KW_AD_192.txt", "KW_AD_256.txt"], load_nist_vectors)) @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported( algorithms.AES(b"\x00" * 16), modes.ECB()), skip_message="Does not support AES key wrap (RFC 3394) because AES-ECB" " is unsupported", ) def test_unwrap(self, backend, params): wrapping_key = binascii.unhexlify(params["k"]) wrapped_key = binascii.unhexlify(params["c"]) if params.get("fail") is True: with pytest.raises(keywrap.InvalidUnwrap): keywrap.aes_key_unwrap(wrapping_key, wrapped_key, backend) else: unwrapped_key = keywrap.aes_key_unwrap(wrapping_key, wrapped_key, backend) assert params["p"] == binascii.hexlify(unwrapped_key) @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported( algorithms.AES(b"\x00" * 16), modes.ECB()), skip_message="Does not support AES key wrap (RFC 3394) because AES-ECB" " is unsupported", ) def test_wrap_invalid_key_length(self, backend): # The wrapping key must be of length [16, 24, 32] with pytest.raises(ValueError): keywrap.aes_key_wrap(b"badkey", b"sixteen_byte_key", backend) @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported( algorithms.AES(b"\x00" * 16), modes.ECB()), skip_message="Does not support AES key wrap (RFC 3394) because AES-ECB" " is unsupported", ) def test_unwrap_invalid_key_length(self, backend): with pytest.raises(ValueError): keywrap.aes_key_unwrap(b"badkey", b"\x00" * 24, backend) @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported( algorithms.AES(b"\x00" * 16), modes.ECB()), skip_message="Does not support AES key wrap (RFC 3394) because AES-ECB" " is unsupported", ) def test_wrap_invalid_key_to_wrap_length(self, backend): # Keys to wrap must be at least 16 bytes long with pytest.raises(ValueError): keywrap.aes_key_wrap(b"sixteen_byte_key", b"\x00" * 15, backend) # Keys to wrap must be a multiple of 8 bytes with pytest.raises(ValueError): keywrap.aes_key_wrap(b"sixteen_byte_key", b"\x00" * 23, backend) def test_unwrap_invalid_wrapped_key_length(self, backend): # Keys to unwrap must be at least 24 bytes with pytest.raises(ValueError): keywrap.aes_key_unwrap(b"sixteen_byte_key", b"\x00" * 16, backend) # Keys to unwrap must be a multiple of 8 bytes with pytest.raises(ValueError): keywrap.aes_key_unwrap(b"sixteen_byte_key", b"\x00" * 27, backend)
def _decrypt_dek(self, key): """ Decrypt AES data encryption key with AES key encryption key: openpgp-do.c decrypt_dek """ assert len(key) == AES_SIZE dec = Cipher(algorithms.AES(key), modes.ECB(), default_backend()).decryptor() return dec.update(self.dek) + dec.finalize()
def test_invalid_key_type(self): with pytest.raises(TypeError, match="key must be bytes"): SEED(u"0" * 16) def test_invalid_backend(): pretend_backend = object() with raises_unsupported_algorithm(_Reasons.BACKEND_MISSING_INTERFACE): ciphers.Cipher(AES(b"AAAAAAAAAAAAAAAA"), modes.ECB, pretend_backend) @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported(AES(b"\x00" * 16), modes.ECB()), skip_message="Does not support AES ECB", ) @pytest.mark.requires_backend_interface(interface=CipherBackend) class TestCipherUpdateInto(object): @pytest.mark.parametrize( "params", load_vectors_from_file( os.path.join("ciphers", "AES", "ECB", "ECBGFSbox128.rsp"), load_nist_vectors, ), ) def test_update_into(self, params, backend): key = binascii.unhexlify(params["key"]) pt = binascii.unhexlify(params["plaintext"]) ct = binascii.unhexlify(params["ciphertext"])
def _mysql_aes_engine(key): """Create MYSQL AES cipher engine.""" return Cipher(algorithms.AES(key), modes.ECB(), default_backend())
def encrypt_aes_ecb(plaintext, key): cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend()) encryptor = cipher.encryptor() return encryptor.update(plaintext) + encryptor.finalize()
passwd = b'password' ivval = b'hello' key = kdf.derive(passwd) iv = idf.derive(ivval) print("key", key.hex()) print("iv", iv.hex()) ##### # 2.2 ##### cipher = Cipher( algorithm=algorithms.AES(key), #mode=modes.CBC(iv), mode=modes.ECB(), backend=backend) encryptor = cipher.encryptor() #mydata = b'this is my long data for this task to ensure that multiple blocks are processed during the cipher' #print("my data", mydata) #print("my data hex", mydata.hex()) padder = padding.PKCS7(128).padder() mydata = b'1234567812345678' mydata_pad = padder.update(mydata) + padder.finalize() print("padded data", mydata_pad.hex()) ciphertext = encryptor.update(mydata_pad) + encryptor.finalize() #ciphertext = encryptor.update(mydata) + encryptor.finalize() print("ciphertext", ciphertext.hex())
from __future__ import absolute_import, division, print_function import binascii import os import pytest from cryptography.hazmat.primitives.ciphers import algorithms, modes from .utils import generate_encrypt_test from ...utils import load_nist_vectors @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported( algorithms.SEED("\x00" * 16), modes.ECB()), skip_message="Does not support SEED ECB", ) @pytest.mark.cipher class TestSEEDModeECB(object): test_ECB = generate_encrypt_test( load_nist_vectors, os.path.join("ciphers", "SEED"), ["rfc-4269.txt"], lambda key, **kwargs: algorithms.SEED(binascii.unhexlify((key))), lambda **kwargs: modes.ECB(), ) @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported(
def _calculate_iv(key, counter): encryptor = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend()).encryptor() return encryptor.update(int_to_bytes(counter, 16)) + encryptor.finalize()
def aes_ecb_decrypt(ciphertext, key): cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=backend) decryptor = cipher.decryptor() unpadder = padding.PKCS7(cipher.algorithm.block_size).unpadder() padded = decryptor.update(b64d(ciphertext)) + decryptor.finalize() return unpadder.update(padded) + unpadder.finalize()
def __init__(self, key): super().__init__(Cipher(algorithms.AES(key), modes.ECB()))
def digest_secure_bootloader(args): """ Calculate the digest of a bootloader image, in the same way the hardware secure boot engine would do so. Can be used with a pre-loaded key to update a secure bootloader. """ _check_output_is_not_input(args.keyfile, args.output) _check_output_is_not_input(args.image, args.output) _check_output_is_not_input(args.iv, args.output) if args.iv is not None: print("WARNING: --iv argument is for TESTING PURPOSES ONLY") iv = args.iv.read(128) else: iv = os.urandom(128) plaintext_image = args.image.read() args.image.seek(0) # secure boot engine reads in 128 byte blocks (ie SHA512 block # size), but also doesn't look for any appended SHA-256 digest fw_image = esptool.ESP32FirmwareImage(args.image) if fw_image.append_digest: if len(plaintext_image) % 128 <= 32: # ROM bootloader will read to the end of the 128 byte block, but not # to the end of the SHA-256 digest at the end new_len = len(plaintext_image) - (len(plaintext_image) % 128) plaintext_image = plaintext_image[:new_len] # if image isn't 128 byte multiple then pad with 0xFF (ie unwritten flash) # as this is what the secure boot engine will see if len(plaintext_image) % 128 != 0: plaintext_image += b"\xFF" * (128 - (len(plaintext_image) % 128)) plaintext = iv + plaintext_image # Secure Boot digest algorithm in hardware uses AES256 ECB to # produce a ciphertext, then feeds output through SHA-512 to # produce the digest. Each block in/out of ECB is reordered # (due to hardware quirks not for security.) key = _load_hardware_key(args.keyfile) backend = default_backend() cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=backend) encryptor = cipher.encryptor() digest = hashlib.sha512() for block in get_chunks(plaintext, 16): block = block[::-1] # reverse each input block cipher_block = encryptor.update(block) # reverse and then byte swap each word in the output block cipher_block = cipher_block[::-1] for block in get_chunks(cipher_block, 4): # Python hashlib can build each SHA block internally digest.update(block[::-1]) if args.output is None: args.output = os.path.splitext( args.image.name)[0] + "-digest-0x0000.bin" with open(args.output, "wb") as f: f.write(iv) digest = digest.digest() for word in get_chunks(digest, 4): f.write(word[::-1]) # swap word order in the result f.write(b'\xFF' * (0x1000 - f.tell())) # pad to 0x1000 f.write(plaintext_image) print("digest+image written to %s" % args.output)
def decrypt_aes_ecb(ciphertext, key): cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend()) decryptor = cipher.decryptor() plaintext = decryptor.update(ciphertext) + decryptor.finalize() return plaintext
def decrypt(data, key): cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend()) decryptor = cipher.decryptor() return decryptor.update(data) + decryptor.finalize()
def __init__(self, key): backend = default_backend() self.cipher = Cipher(algorithms.AES(key), modes.ECB(), backend) self.padder = padding.PKCS7(len(key) * 8)
def aes_ecb_encrypt(message, key): cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=backend) encryptor = cipher.encryptor() padder = padding.PKCS7(cipher.algorithm.block_size).padder() padded = padder.update(message) + padder.finalize() return b64e(encryptor.update(padded) + encryptor.finalize())
KEY = b"YELLOW SUBMARINE" BLOCK_SIZE = 16 def blocks(l, n=BLOCK_SIZE): for i in range(0, len(l) // n): yield l[i * n:(i + 1) * n] if __name__ == "__main__": with open('10.txt') as f: ciphertext = base64.b64decode(f.read()) backend = default_backend() cipher = Cipher(algorithms.AES(KEY), modes.ECB(), backend=backend) iv = b"\x00" * BLOCK_SIZE plaintext = "" for ciphertext_block in blocks(ciphertext): decryptor = cipher.decryptor() plaintext_block = decryptor.update( ciphertext_block) + decryptor.finalize() plaintext_block = bytes( [a ^ b for (a, b) in zip(iv, plaintext_block)]) plaintext += plaintext_block.decode('utf8') iv = ciphertext_block print(plaintext)
def tests(device_details, encryption_function): # initialize row for database entry new_row = { "device": device_details, "algo": None, "start_time": None, "end_time": None, "total_time": None, "sensor_data": "b'a secret message'", "cypher_text": None, "test_number": None } # convert the dictionary into a proper JSON object # device_data = json.dumps(device_details, indent=4, sort_keys=False) # generate keys backend = default_backend() salt = os.urandom(16) # AES key derivation function and key aes_kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt, iterations=100000, backend=backend) aes_key = aes_kdf.derive(b"password") # 3DES key derivation fucntion and key des3_kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=24, salt=salt, iterations=100000, backend=backend) des3_key = des3_kdf.derive(b"password") # SEED key derivation fucntion and key seed_kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=16, salt=salt, iterations=100000, backend=backend) seed_key = seed_kdf.derive(b"password") # cycle through three encryption algorithms (AES, 3DES, and SEED) algos = { "AES_CBC": { 'algo': algorithms.AES(aes_key), 'mode': modes.CBC(os.urandom(16)) }, "AES_ECB": { 'algo': algorithms.AES(aes_key), 'mode': modes.ECB() }, "AES_CFB": { 'algo': algorithms.AES(aes_key), 'mode': modes.CFB(os.urandom(16)) }, "AES_CTR": { 'algo': algorithms.AES(aes_key), 'mode': modes.CTR(os.urandom(16)) }, "AES_OFB": { 'algo': algorithms.AES(aes_key), 'mode': modes.OFB(os.urandom(16)) }, "3DES": { 'algo': algorithms.TripleDES(des3_key), 'mode': modes.CBC(os.urandom(8)) }, "SEED": { 'algo': algorithms.SEED(seed_key), 'mode': modes.CBC(os.urandom(16)) } } print("Device OS, OS Release, Processor, Algorithm, Average") for selected_algo in algos: # go through each algorithm and run the test for each one 10x times_to_repeat = 10000 i = 0 new_row['algo'] = selected_algo total_run_time = 0 while times_to_repeat >= i: # choose an algorithm for the test algorithm_with_key = algos[selected_algo] # record start time new_row['start_time'] = int(round(time.time() * 10000000)) # encrypt the data new_row['cypher_text'] = encryption_function(algorithm_with_key) # connect to database # record end time new_row['end_time'] = int(round(time.time() * 10000000)) # subtract end from start time new_row['total_time'] = (new_row['end_time'] - new_row['start_time']) # record test number new_row['test_number'] = i # decrement counter i += 1 total_run_time += new_row['total_time'] # print result #print("----\n%s algorithm on attempt %d took %d"%(selected_algo, i, new_row['total_time'])) #print("RAW ROW DATA %s ATTEMPT %d: %s"%(selected_algo,i,new_row)) print( "%s, %s, %s, %s, %s" % (device_details()['os']['name'], device_details()['os']['release'], device_details()['processor'], selected_algo, str(total_run_time / (times_to_repeat + 1)))) ############### #process_telemetry(device_profile())
def encrypt_aes_128_ecb(msg, key): padded_msg = pkcs7_padding(msg, block_size=16) cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=backend) encryptor = cipher.encryptor() return encryptor.update(padded_msg) + encryptor.finalize()
keepassheader.check_version_support(keepass) keepassheader.read(keepass) m = hashlib.sha256() m.update(b'Password01') pwd_hash = m.digest() m = hashlib.sha256() m.update(pwd_hash) composite_key = m.digest() backend = default_backend() cipher = Cipher(algorithms.AES(keepassheader.transform_seed), modes.ECB(), backend) encryptor = cipher.encryptor() transformed_key = composite_key for round in range(0, keepassheader.transform_rounds): transformed_key = encryptor.update(transformed_key) m = hashlib.sha256() m.update(transformed_key) transformed_key = m.digest() masterkey = keepassheader.master_seed + transformed_key cipher = Cipher(algorithms.AES(masterkey), modes.CBC(keepassheader.encryption_iv), backend) encryptor = cipher.encryptor()
def block_decrypt_aes_128_ecb(ctxt, i, key): cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=backend) decryptor = cipher.decryptor() decrypted_data = decryptor.update(cipher_text) + decryptor.finalize() message = pkcs7_strip(decrypted_data) return message[i * 16:(i + 1) * 16]
import binascii import os import pytest from cryptography.hazmat.backends.interfaces import CipherBackend from cryptography.hazmat.primitives.ciphers import algorithms, modes from .utils import generate_encrypt_test from ...utils import load_cryptrec_vectors, load_nist_vectors @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported( algorithms.Camellia(b"\x00" * 16), modes.ECB()), skip_message="Does not support Camellia ECB", ) @pytest.mark.requires_backend_interface(interface=CipherBackend) class TestCamelliaModeECB(object): test_ecb = generate_encrypt_test( load_cryptrec_vectors, os.path.join("ciphers", "Camellia"), [ "camellia-128-ecb.txt", "camellia-192-ecb.txt", "camellia-256-ecb.txt", ], lambda key, **kwargs: algorithms.Camellia(binascii.unhexlify(key)), lambda **kwargs: modes.ECB(), )
def aes_ecb(k, m): c = Cipher(algorithms.AES(k), modes.ECB(), backend=default_backend()) e = c.encryptor() return e.update(m) + e.finalize()
def encrypt_file(encryption_material, in_filename, chunk_size=block_size * 4 * 1024, tmp_dir=None): """Encrypts a file in a temporary directory. Args: encryption_material: The encryption material for file. in_filename: The input file's name. chunk_size: The size of read chunks (Default value = block_size * 4 * 1024). tmp_dir: Temporary directory to use, optional (Default value = None). Returns: The encrypted file's location. """ logger = getLogger(__name__) use_openssl_only = os.getenv('SF_USE_OPENSSL_ONLY', 'False') == 'True' decoded_key = base64.standard_b64decode( encryption_material.query_stage_master_key) key_size = len(decoded_key) logger.debug('key_size = %s', key_size) # Generate key for data encryption iv_data = SnowflakeEncryptionUtil.get_secure_random(block_size) file_key = SnowflakeEncryptionUtil.get_secure_random(key_size) if not use_openssl_only: data_cipher = AES.new(key=file_key, mode=AES.MODE_CBC, IV=iv_data) else: backend = default_backend() cipher = Cipher(algorithms.AES(file_key), modes.CBC(iv_data), backend=backend) encryptor = cipher.encryptor() temp_output_fd, temp_output_file = tempfile.mkstemp( text=False, dir=tmp_dir, prefix=os.path.basename(in_filename) + "#") padded = False logger.debug('unencrypted file: %s, temp file: %s, tmp_dir: %s', in_filename, temp_output_file, tmp_dir) with open(in_filename, 'rb') as infile: with os.fdopen(temp_output_fd, 'wb') as outfile: while True: chunk = infile.read(chunk_size) if len(chunk) == 0: break elif len(chunk) % block_size != 0: chunk = PKCS5_PAD(chunk, block_size) padded = True if not use_openssl_only: outfile.write(data_cipher.encrypt(chunk)) else: outfile.write(encryptor.update(chunk)) if not padded: if not use_openssl_only: outfile.write( data_cipher.encrypt(block_size * chr(block_size).encode(UTF8))) else: outfile.write( encryptor.update(block_size * chr(block_size).encode(UTF8))) if use_openssl_only: outfile.write(encryptor.finalize()) # encrypt key with QRMK if not use_openssl_only: key_cipher = AES.new(key=decoded_key, mode=AES.MODE_ECB) enc_kek = key_cipher.encrypt(PKCS5_PAD(file_key, block_size)) else: cipher = Cipher(algorithms.AES(decoded_key), modes.ECB(), backend=backend) encryptor = cipher.encryptor() enc_kek = encryptor.update(PKCS5_PAD( file_key, block_size)) + encryptor.finalize() mat_desc = MaterialDescriptor(smk_id=encryption_material.smk_id, query_id=encryption_material.query_id, key_size=key_size * 8) metadata = EncryptionMetadata( key=base64.b64encode(enc_kek).decode('utf-8'), iv=base64.b64encode(iv_data).decode('utf-8'), matdesc=matdesc_to_unicode(mat_desc), ) return metadata, temp_output_file
def _flash_encryption_operation_esp32(output_file, input_file, flash_address, keyfile, flash_crypt_conf, do_decrypt): key = _load_hardware_key(keyfile) if flash_address % 16 != 0: raise esptool.FatalError( "Starting flash address 0x%x must be a multiple of 16" % flash_address) if flash_crypt_conf == 0: print("WARNING: Setting FLASH_CRYPT_CONF to zero is not recommended") if esptool.PYTHON2: tweak_range = _flash_encryption_tweak_range(flash_crypt_conf) else: tweak_range = _flash_encryption_tweak_range_bits(flash_crypt_conf) key = int.from_bytes(key, byteorder='big', signed=False) backend = default_backend() cipher = None block_offs = flash_address while True: block = input_file.read(16) if len(block) == 0: break elif len(block) < 16: if do_decrypt: raise esptool.FatalError( "Data length is not a multiple of 16 bytes") pad = 16 - len(block) block = block + os.urandom(pad) print( "Note: Padding with %d bytes of random data (encrypted data must be multiple of 16 bytes long)" % pad) if block_offs % 32 == 0 or cipher is None: # each bit of the flash encryption key is XORed with tweak bits derived from the offset of 32 byte block of flash block_key = _flash_encryption_tweak_key(key, block_offs, tweak_range) if cipher is None: # first pass cipher = Cipher(algorithms.AES(block_key), modes.ECB(), backend=backend) # note AES is used inverted for flash encryption, so # "decrypting" flash uses AES encrypt algorithm and vice # versa. (This does not weaken AES.) actor = cipher.encryptor() if do_decrypt else cipher.decryptor( ) else: # performance hack: changing the key using pyca-cryptography API requires recreating # 'actor'. With openssl backend, this re-initializes the openssl cipher context. To save some time, # manually call EVP_CipherInit_ex() in the openssl backend to update the key. # If it fails, fall back to recreating the entire context via public API. try: backend = actor._ctx._backend res = backend._lib.EVP_CipherInit_ex( actor._ctx._ctx, backend._ffi.NULL, backend._ffi.NULL, backend._ffi.from_buffer(block_key), backend._ffi.NULL, actor._ctx._operation, ) backend.openssl_assert(res != 0) except AttributeError: # backend is not an openssl backend, or implementation has changed: fall back to the slow safe version cipher.algorithm.key = block_key actor = cipher.encryptor( ) if do_decrypt else cipher.decryptor() block = block[::-1] # reverse input block byte order block = actor.update(block) output_file.write(block[::-1]) # reverse output block byte order block_offs += 16
import os import string from copy import deepcopy key = os.urandom(16) # vi = os.urandom(16) #FOR TESTING PURPOSES, ENSURE THIS VI VALUE IS MORE "CONTROLLED" vi = bytes('xxxxxxxxxxxxxxxx', 'utf-8') print(vi) aesCipher = Cipher( algorithms.AES(key), modes.ECB(), backend=default_backend() ) aesEncriptor = aesCipher.encryptor() aesDecriptor = aesCipher.decryptor() class HandmadeCBC(object): def __init__(self): aesCipher = Cipher( algorithms.AES(key), modes.ECB(), backend=default_backend() )
from __future__ import absolute_import, division, print_function import binascii import os import pytest from cryptography.hazmat.primitives.ciphers import algorithms, modes from .utils import generate_encrypt_test from ...utils import load_nist_vectors @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported( algorithms.IDEA("\x00" * 16), modes.ECB()), skip_message="Does not support IDEA ECB", ) @pytest.mark.cipher class TestIDEAModeECB(object): test_ECB = generate_encrypt_test( load_nist_vectors, os.path.join("ciphers", "IDEA"), ["idea-ecb.txt"], lambda key, **kwargs: algorithms.IDEA(binascii.unhexlify((key))), lambda **kwargs: modes.ECB(), ) @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported(