def test_non_bytes(self): padder = padding.ANSIX923(128).padder() with pytest.raises(TypeError): padder.update("abc") # type: ignore[arg-type] unpadder = padding.ANSIX923(128).unpadder() with pytest.raises(TypeError): unpadder.update("abc") # type: ignore[arg-type]
def main(): parser = argparse.ArgumentParser() parser.add_argument('-out', help='Output encrypted file', dest='output', required=True) parser.add_argument('-in', help='File to be encrypted', dest='input', required=True) parser.add_argument('-k', help='The key to be used for encryption, must be in hex', dest='key') parser.add_argument('-iv', help='The initialization vector, must be in hex', dest='iv') parser.add_argument('-e','--encrypt', action='store_true') parser.add_argument('-d','--decrypt', action='store_true') args = parser.parse_args() input_content = readfile_binary(args.input) backend = default_backend() cipher = Cipher(algorithms.AES(binascii.unhexlify(args.key)), modes.CBC(binascii.unhexlify(args.iv)), backend=backend) if(args.decrypt): print('This is decrypt mode') decryptor = cipher.decryptor() plainText = decryptor.update(input_content) + decryptor.finalize() unpadder = padding.ANSIX923(128).unpadder() unpadded_data = unpadder.update(plainText) finalText = unpadded_data + unpadder.finalize() writefile_binary(args.output, finalText) elif(args.encrypt): print('This is encrypt mode') encryptor = cipher.encryptor() padder = padding.ANSIX923(128).padder() padded_data = padder.update(readfile_binary(args.input)) padded_data += padder.finalize() ct = encryptor.update(padded_data) + encryptor.finalize() writefile_binary(args.output, ct) else: print('Select -e or -d option')
def test_non_bytes(self): padder = padding.ANSIX923(128).padder() with pytest.raises(TypeError): padder.update(u"abc") unpadder = padding.ANSIX923(128).unpadder() with pytest.raises(TypeError): unpadder.update(u"abc")
def test_bytearray(self): padder = padding.ANSIX923(128).padder() unpadded = bytearray(b"t" * 38) padded = (padder.update(unpadded) + padder.update(unpadded) + padder.finalize()) unpadder = padding.ANSIX923(128).unpadder() final = unpadder.update(padded) + unpadder.finalize() assert final == unpadded + unpadded
def test_zany_py2_bytes_subclass(self): class mybytes(bytes): # noqa: N801 def __str__(self): return "broken" str(mybytes()) padder = padding.ANSIX923(128).padder() padder.update(mybytes(b"abc")) unpadder = padding.ANSIX923(128).unpadder() unpadder.update(mybytes(padder.finalize())) assert unpadder.finalize() == b"abc"
def test_use_after_finalize(self): padder = padding.ANSIX923(128).padder() b = padder.finalize() with pytest.raises(AlreadyFinalized): padder.update(b"") with pytest.raises(AlreadyFinalized): padder.finalize() unpadder = padding.ANSIX923(128).unpadder() unpadder.update(b) unpadder.finalize() with pytest.raises(AlreadyFinalized): unpadder.update(b"") with pytest.raises(AlreadyFinalized): unpadder.finalize()
def decrypt(self, key, msg, b64decode=True): """Decrypts the provided ciphertext. The ciphertext can be optionally base64 encoded. Uses AES-128-CBC with an IV by default. :param key: The Encryption key. :param msg: the ciphetext, the first block is the IV :returns plain: the plaintext message, after padding is removed. """ key = str.encode(get_valid_encryption_key(key)) if b64decode: msg = base64.b64decode(msg) algo = self.algo(key) block_size_bytes = algo.block_size // 8 iv = msg[:block_size_bytes] backend = backends.default_backend() cipher = Cipher(algo, modes.CBC(iv), backend=backend) decryptor = cipher.decryptor() padded = (decryptor.update(msg[block_size_bytes:]) + decryptor.finalize()) unpadder = padding.ANSIX923(algo.block_size).unpadder() plain = unpadder.update(padded) + unpadder.finalize() # The original padding algorithm was a slight variation on ANSI X.923, # where the size of the padding did not include the byte that tells # you the size of the padding. Therefore, we need to remove one extra # byte (which will be 0x00) when unpadding. return plain[:-1]
def encrypt_text(self, message): # create encryptor object encryptor = self.cipher.encryptor() # create padding object, which adds some chars for text, which length is not multiple of block size (128) padder = padding.ANSIX923(algorithms.AES.block_size).padder() # adding padding to message message = padder.update(message) + padder.finalize() # return encrypted message return encryptor.update(message) + encryptor.finalize()
def enc(bitstring): if algoname not in ['ARC4', 'ChaCha20']: if padd.upper() == 'PKCS7': padder = padding.PKCS7(algoer.block_size).padder() bitstring = padder.update(bitstring) + padder.finalize() elif padd.upper() == 'ANSIX923': padder = padding.ANSIX923(algoer.block_size).padder() bitstring = padder.update(bitstring) + padder.finalize() encryptor = cipher.encryptor() return encryptor.update(bitstring) + encryptor.finalize()
def decrypt_text(self, encrypted_message): # create decryptor object decryptor = self.cipher.decryptor() # create unpadder object, which deletes padding unpadder = padding.ANSIX923(algorithms.AES.block_size).unpadder() # decrypt message encrypted_message = decryptor.update( encrypted_message) + decryptor.finalize() # remove padding return unpadder.update(encrypted_message) + unpadder.finalize()
def paswword_padding(passwd): passlen = len(passwd) passbyte = bytes(passwd, 'UTF-8') if passlen not in KEY_LENGTHS: if passlen < 16: padder = padding.ANSIX923(128).padder() pad_passwd = padder.update(passbyte) pad_passwd += padder.finalize() elif passlen < 24: padder = padding.ANSIX923(192).padder() pad_passwd = padder.update(passbyte) pad_passwd += padder.finalize() elif passlen < 32: padder = padding.ANSIX923(256).padder() pad_passwd = padder.update(passbyte) pad_passwd += padder.finalize() else: print('Password cant be larger than 32bytes') return pad_passwd
def dec(bitstring): decryptor = cipher.decryptor() ddata = decryptor.update(bitstring) + decryptor.finalize() if algoname not in ['ARC4', 'ChaCha20']: if padd.upper() == 'PKCS7': unpadder = padding.PKCS7(algoer.block_size).unpadder() ddata = unpadder.update(ddata) + unpadder.finalize() elif padd.upper() == 'ANSIX923': unpadder = padding.ANSIX923(algoer.block_size).unpadder() ddata = unpadder.update(ddata) + unpadder.finalize() return ddata
def encryption_OFB(file_content, key, iv): cipher = Cipher(algorithms.TripleDES(key), modes.ECB(), default_backend()) encrypted_data = [] for block in file_content: encryptor = cipher.encryptor() # cazul in care ultimul bloc nu are dimensiunea de 16 bytes if len(block) != 16: padder = padding.ANSIX923(128).padder() block = padder.update(block) + padder.finalize() result = encryptor.update(iv) + encryptor.finalize() # criptotextul curent inainte de XOR-ul cu plaintextul # devine vector de initilizare pentru blocul urmator iv = result result = xor_between_arrays(block, result) encrypted_data.append(result) return encrypted_data
def decryption_CBC(cipher_text, key, iv): cipher = Cipher(algorithms.TripleDES(key), modes.ECB(), default_backend()) decrypted_data = [] for encrypted_block in cipher_text: encryptor = cipher.decryptor() copy_iv = iv iv = encrypted_block result = encryptor.update(encrypted_block) + encryptor.finalize() final = xor_between_arrays(copy_iv, result) decrypted_data.append(final) # incercam sa obtinem blocul initial, in cazul in care acesta nu a avut initial 16 bytes try: unpadder = padding.ANSIX923(128).unpadder() decrypted_data[-1] = unpadder.update( decrypted_data[-1]) + unpadder.finalize() except Exception as e: pass return decrypted_data
def test_unpad(self, size, unpadded, padded): unpadder = padding.ANSIX923(size).unpadder() result = unpadder.update(padded) result += unpadder.finalize() assert result == unpadded
def test_pad(self, size, unpadded, padded): padder = padding.ANSIX923(size).padder() result = padder.update(unpadded) result += padder.finalize() assert result == padded
def test_invalid_padding(self, size, padded): unpadder = padding.ANSIX923(size).unpadder() with pytest.raises(ValueError): unpadder.update(padded) unpadder.finalize()
def test_invalid_block_size(self, size): with pytest.raises(ValueError): padding.ANSIX923(size)
# -*- coding: utf-8 -*- import cryptography from codecs import encode, decode from cryptography.hazmat.primitives import padding secret = b'message secret' a = encode(secret, 'hex') #print(a) # print(decode(a,'hex')) padder = padding.ANSIX923(128).padder() padded_data = padder.update(b"11111111111111112222222222") # print(padded_data) # print(padder.finalize()) '''def pkcs7(data,block_size): padding_size=(block_size-len(data))%block_size if padding_size==0: padding_size= block_size padding =(chr(padding_size)*padding_size).encode return data+ bytearray() print (pkcs7('message secret',16)) ''' def read(): f = open("C:\\Users\\Narutowin\\Downloads\\cipher.hex") return f # Enzo's function