def encript(self, txt): backend = default_backend() cipher = None block_size = 0 # Algoritmo if self.algoritmo == 'AES': alg = algorithms.AES(self.key) block_size = alg.block_size elif self.algoritmo == 'CAST5': alg = algorithms.CAST5(self.key) block_size = alg.block_size # Modo de encriptografar if self.modo == 'ECB': mod = modes.ECB() elif self.modo == 'CBC': mod = modes.CBC(self.iv) cipher = Cipher(alg, mod, backend=default_backend()) # Sintese if self.sintese == 'SHA-256': sints = hashes.SHA256() elif self.sintese == 'MD5': sints = hashes.MD5() encryptor = cipher.encryptor() # Text msg = base64.b64encode(txt) padder = padding.PKCS7(block_size).padder() padded_data = padder.update(msg) + padder.finalize() # Encrypted text ct = encryptor.update(padded_data) + encryptor.finalize() # HMAC h = hmac.HMAC(self.key, sints, backend=default_backend()) h.update(ct) mac = h.finalize() return ct, mac
def decript(self, ct, mac): backend = default_backend() cipher = None block_size = 0 # Algoritmo if self.algoritmo == 'AES': alg = algorithms.AES(self.key) block_size = alg.block_size elif self.algoritmo == 'CAST5': alg = algorithms.CAST5(self.key) block_size = alg.block_size # Modo de encriptografar if self.modo == 'ECB': mod = modes.ECB() elif self.modo == 'CBC': mod = modes.CBC(self.iv) cipher = Cipher(alg, mod, backend=default_backend()) # Sintese if self.sintese == 'SHA-256': sints = hashes.SHA256() elif self.sintese == 'MD5': sints = hashes.MD5() # Decryptor decryptor = cipher.decryptor() # Padder unpadder = padding.PKCS7(block_size).unpadder() # Hmac h = hmac.HMAC(self.key, sints, backend=default_backend()) # VERIFICAR SE O HMAC CONTINUA O MESMO h.update(ct) h.verify(mac) padded_data = decryptor.update(ct) + decryptor.finalize() data = unpadder.update(padded_data) + unpadder.finalize() clean_data = base64.b64decode(data) return clean_data
def CAST5Decrypt(ciphertext, key, iv): backend = default_backend() cipher = Cipher(algorithms.CAST5(key), modes.CBC(iv), backend=backend) decryptor = cipher.decryptor() plaintext = decryptor.update(ciphertext) + decryptor.finalize() plaintext = plaintext[0:123] return plaintext
def encrypt(mode, key, iv, plaintext): cipher = base.Cipher(algorithms.CAST5(binascii.unhexlify(key)), mode(binascii.unhexlify(iv)), default_backend()) encryptor = cipher.encryptor() ct = encryptor.update(binascii.unhexlify(plaintext)) ct += encryptor.finalize() return binascii.hexlify(ct)
def CAST5Encrypt(plaintext, key, iv): plaintext = pad(plaintext) backend = default_backend() cipher = Cipher(algorithms.CAST5(key), modes.CBC(iv), backend=backend) encryptor = cipher.encryptor() ciphertext = encryptor.update(plaintext) + encryptor.finalize() return ciphertext
class TestCAST5ModeECB(object): test_ECB = generate_encrypt_test( load_nist_vectors, os.path.join("ciphers", "CAST5"), ["cast5-ecb.txt"], lambda key, **kwargs: algorithms.CAST5(binascii.unhexlify((key))), lambda **kwargs: modes.ECB(), )
class TestCAST5ModeCBC(object): test_cbc = generate_encrypt_test( load_nist_vectors, os.path.join("ciphers", "CAST5"), ["cast5-cbc.txt"], lambda key, **kwargs: algorithms.CAST5(binascii.unhexlify((key))), lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)), )
def _algorithm(self, secret, name='AES'): if not name: return algorithms.AES(secret) name = name.upper() if name == 'AES': return algorithms.AES(secret) if name == 'CAMELLIA': return algorithms.Camellia(secret) elif name == 'CAST5': return algorithms.CAST5(secret) elif name == 'SEED': return algorithms.SEED(secret) else: return algorithms.AES(secret)
def get_algorithm(self, algorithm, key): if algorithm == SecurityAlgorithm.none: return None elif algorithm == SecurityAlgorithm.aes: return algorithms.AES(key) elif algorithm == SecurityAlgorithm.camellia: return algorithms.Camellia(key) # elif algorithm == SecurityAlgorithm.chacha20: # return algorithms.ChaCha20(key) elif algorithm == SecurityAlgorithm.triple_des: return algorithms.TripleDES(key) elif algorithm == SecurityAlgorithm.cast5: return algorithms.CAST5(key) elif algorithm == SecurityAlgorithm.seed: return algorithms.SEED(key) else: logger.error("Not supportable algorithm")
def start_cifra(key,iv,who): global CSUIT alg,modo,dige = CSUIT[who].split("_") if(modo == 'CFB'): mode = modes.CFB(iv) elif(modo == 'CTR'): mode = modes.CTR(iv) elif(modo == 'OFB'): mode = modes.OFB(iv) if(alg == 'AES'): algorithm = algorithms.AES(key) elif(alg == 'SEED'): algorithm = algorithms.SEED(key) elif(alg == 'CAST5'): algorithm = algorithms.CAST5(key) elif(alg == 'TripleDES'): algorithm = algorithms.TripleDES(key) elif(alg == 'Camellia'): algorithm = algorithms.Camellia(key) cifra = Cipher(algorithm,mode) return cifra
def get_cipher(self): if self.method.startswith('aes'): return Cipher(algorithms.AES(self.key), modes.CFB(self.iv), default_backend()) if self.method.startswith('bf'): return Cipher(algorithms.Blowfish(self.key), modes.CFB(self.iv), default_backend()) if self.method.startswith('camellia'): return Cipher(algorithms.Camellia(self.key), modes.CFB(self.iv), default_backend()) if self.method.startswith('cast5'): return Cipher(algorithms.CAST5(self.key), modes.CFB(self.iv), default_backend()) if self.method.startswith('seed'): return Cipher(algorithms.SEED(self.key), modes.CFB(self.iv), default_backend()) if self.method.startswith('idea'): return Cipher(algorithms.IDEA(self.key), modes.CFB(self.iv), default_backend()) if self.method.startswith('rc4'): return Cipher(algorithms.ARC4(self.key), None, default_backend()) raise ValueError('crypto method %s not supported!' % self.method)
encryptor = cipher.encryptor() enctext = encryptor.update(message) + encryptor.finalize() enc_run = ['encrypt'] enc_trial = Timer("encryptor.update(message) + encryptor.finalize()", setup) enc_run.append(enc_trial.repeat(RUN_COUNT, 1)) algo_run.append(enc_run) dec_run = ['decrypt'] dec_trial = Timer("decryptor.update(enctext) + decryptor.finalize()", setup) dec_run.append(dec_trial.repeat(RUN_COUNT, 1)) algo_run.append(dec_run) set_run.append(algo_run) # Create cipher, create cipher text for decryption, time operations, update # result with each new operation algo_run = ['CAST5'] cipher = Cipher(algorithms.CAST5(key), modes.CBC(iv8), backend=backend) encryptor = cipher.encryptor() enctext = encryptor.update(message) + encryptor.finalize() enc_run = ['encrypt'] enc_trial = Timer("encryptor.update(message) + encryptor.finalize()", setup) enc_run.append(enc_trial.repeat(RUN_COUNT, 1)) algo_run.append(enc_run) dec_run = ['decrypt'] dec_trial = Timer("decryptor.update(enctext) + decryptor.finalize()", setup) dec_run.append(dec_trial.repeat(RUN_COUNT, 1)) algo_run.append(dec_run) set_run.append(algo_run) lib_run.append(set_run)
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_nist_vectors @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported( algorithms.CAST5(b"\x00" * 16), modes.ECB()), skip_message="Does not support CAST5 ECB", ) @pytest.mark.requires_backend_interface(interface=CipherBackend) class TestCAST5ModeECB(object): test_ECB = generate_encrypt_test( load_nist_vectors, os.path.join("ciphers", "CAST5"), ["cast5-ecb.txt"], lambda key, **kwargs: algorithms.CAST5(binascii.unhexlify((key))), lambda **kwargs: modes.ECB(), ) @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported(
def choicesS(algo): if (algo == 1): return algorithms.AES(key) #block size == 128 bits elif (algo == 2): return algorithms.TripleDES(key) #64 bits elif (algo == 3): return algorithms.Camellia(key) #128 bits elif (algo == 4): return algorithms.CAST5(key) #64 bits elif (algo == 5): return algorithms.SEED(key) #128 bits
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_nist_vectors @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported( algorithms.CAST5("\x00" * 16), modes.ECB()), skip_message="Does not support CAST5 ECB", ) @pytest.mark.requires_backend_interface(interface=CipherBackend) class TestCAST5ModeECB(object): test_ECB = generate_encrypt_test( load_nist_vectors, os.path.join("ciphers", "CAST5"), ["cast5-ecb.txt"], lambda key, **kwargs: algorithms.CAST5(binascii.unhexlify((key))), lambda **kwargs: modes.ECB(), ) @pytest.mark.supported( only_if=lambda backend: backend.cipher_supported(
CAST5_plaintext_bytes) #This pads the data CAST5_padded_data += CAST5_padder.finalize( ) #This finalizes the padded data print(CAST5_padded_data, "\n\n") #This prints the padded data #The padding portion of the code is done #The following code does the encryption print("You have selected CAST5\n") CAST5_backend = default_backend() CAST5_key = os.urandom(16) CAST5_iv = os.urandom(8) cipher = Cipher(algorithms.CAST5(CAST5_key), modes.CFB(CAST5_iv), backend=CAST5_backend) CAST5_encryptor = cipher.encryptor() cipher_text = CAST5_encryptor.update( CAST5_plaintext_bytes) + CAST5_encryptor.finalize() CAST5_decryptor = cipher.decryptor() plaintext_from_ciphertext = CAST5_decryptor.update( cipher_text) + CAST5_decryptor.finalize() print("This is the key that was used to encrypt:", CAST5_key, "\n") print("This is the value of the Initization Vector that was used:", CAST5_iv, "\n") print("This is the cipher text: ", cipher_text, "\n") print("\nThis is the plaintext decoded from the plaintext: ",