def encrypt_file(inkey, in_filename, out_filename, chunksize=64 * 1024): key = fixkey(inkey) if not out_filename: out_filename = in_filename + '.enc' iv = ''.join(chr(random.randint(0, 0xFF)) for i in range(8)) encryptor = CAST.new(key, CAST.MODE_CBC, iv) filesize = os.path.getsize(in_filename) with open(in_filename, 'rb') as infile: with open(out_filename, 'wb') as outfile: outfile.write(struct.pack('<Q', filesize)) outfile.write(iv) while True: chunk = infile.read(chunksize) if len(chunk) == 0: break elif len(chunk) % 16 != 0: chunk += ' ' * (16 - len(chunk) % 16) outfile.write(encryptor.encrypt(chunk)) infile.close() outfile.close()
def encrypt(self, msg, password): salt = os.urandom(8) password = blake2b(password.encode("ascii"), digest_size=8).digest() crypter = CAST.new(password, mode=self.MODE, IV=salt) return binascii.b2a_base64(salt).decode( "utf-8")[:-1], binascii.b2a_base64( crypter.encrypt(self.pad(msg, 8))).decode("utf-8")[:-1]
def __init__(self, keylen, time_str, state, algorythm): if keylen != 16 and keylen != 24 and keylen != 32: keylen = 16 # Either keying 1 or 2, resp. self.IV = Random.new().read(state) #Init vector self.key = Random.new().read(keylen) self.__state = Random.new().read(state) self.__time_format = time_str if algorythm == 'DES': self.cipher = DES3.new(self.key, DES3.MODE_CBC, self.IV) if algorythm == 'AES': self.cipher = AES.new(self.key, AES.MODE_CBC, self.IV) if algorythm == 'CAST': self.cipher = CAST.new(self.key, CAST.MODE_CBC, self.IV) if algorythm == 'BLOWFISH': self.cipher = Blowfish.new(self.key, Blowfish.MODE_CBC, self.IV) if algorythm == 'Twofish': self.cipher = Twofish(self.key) if algorythm == "RC2": self.cipher = ARC2.new(self.key, ARC2.MODE_CBC, self.IV) if algorythm == "IDEA": self.cipher = IDEA(self.key) if algorythm == "RC5": self.cipher = RC5(self.key, BLOCKSIZE, ROUNDS) if algorythm == "GOST28147": self.IV = Random.new().read(8) self.cipher = "gost"
def runTest(self): # Encrypt/Decrypt data and test output parameter cipher = CAST.new(b'4'*16, CAST.MODE_ECB) pt = b'5' * 16 ct = cipher.encrypt(pt) output = bytearray(16) res = cipher.encrypt(pt, output=output) self.assertEqual(ct, output) self.assertEqual(res, None) res = cipher.decrypt(ct, output=output) self.assertEqual(pt, output) self.assertEqual(res, None) import sys if sys.version[:3] != '2.6': output = memoryview(bytearray(16)) cipher.encrypt(pt, output=output) self.assertEqual(ct, output) cipher.decrypt(ct, output=output) self.assertEqual(pt, output) self.assertRaises(TypeError, cipher.encrypt, pt, output=b'0'*16) self.assertRaises(TypeError, cipher.decrypt, ct, output=b'0'*16) shorter_output = bytearray(7) self.assertRaises(ValueError, cipher.encrypt, pt, output=shorter_output) self.assertRaises(ValueError, cipher.decrypt, ct, output=shorter_output)
def main(): parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter) parser.add_argument("-e", "--encrypt", help="encrypt carbon file", required=False) parser.add_argument("-d", "--decrypt", help="decrypt carbon file", required=False) try: args = parser.parse_args() except IOError as e: parser.error(e) return 0 if len(sys.argv) != 3: parser.print_help() return 0 key = "\x12\x34\x56\x78\x9A\xBC\xDE\xF0\xFE\xFC\xBA\x98\x76\x54\x32\x10" iv = "\x12\x34\x56\x78\x9A\xBC\xDE\xF0" cipher = CAST.new(key, CAST.MODE_OFB, iv) if args.encrypt: plaintext = open(args.encrypt, "rb").read() while len(plaintext) % 8 != 0: plaintext += "\x00" data = cipher.encrypt(plaintext) open(args.encrypt + "_encrypted", "wb").write(data) else: ciphertext = open(args.decrypt, "rb").read() while len(ciphertext) % 8 != 0: ciphertext += "\x00" data = cipher.decrypt(ciphertext) open(args.decrypt + "_decrypted", "wb").write(data)
def main(): parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter) parser.add_argument("-e", "--encrypt", help="encrypt carbon file", required=False) parser.add_argument("-d", "--decrypt", help="decrypt carbon file", required=False) try: args = parser.parse_args() except IOError as e: parser.error(e) return 0 if len(sys.argv) != 3: parser.print_help() return 0 key = b"\x12\x34\x56\x78\x9A\xBC\xDE\xF0\xFE\xFC\xBA\x98\x76\x54\x32\x10" iv = b"\x12\x34\x56\x78\x9A\xBC\xDE\xF0" cipher = CAST.new(key, CAST.MODE_OFB, iv) if args.encrypt: plaintext = open(args.encrypt, "rb").read() while len(plaintext) % 8 != 0: plaintext += b"\x00" data = cipher.encrypt(plaintext) open(args.encrypt + "_encrypted", "wb").write(data) else: ciphertext = open(args.decrypt, "rb").read() while len(ciphertext) % 8 != 0: ciphertext += b"\x00" data = cipher.decrypt(ciphertext) open(args.decrypt + "_decrypted", "wb").write(data)
def _getcipher_real(self, key, algo): """ do the real job of decrypting using functions form PyCrypto """ if (algo == "AES"): key = self._padkey(key, [16, 24, 32]) cipher = cAES.new(key, cAES.MODE_ECB) elif (algo == 'ARC2'): cipher = cARC2.new(key, cARC2.MODE_ECB) elif (algo == 'ARC4'): raise CryptoUnsupportedException("ARC4 is currently unsupported") elif (algo == 'Blowfish'): cipher = cBlowfish.new(key, cBlowfish.MODE_ECB) elif (algo == 'CAST'): cipher = cCAST.new(key, cCAST.MODE_ECB) elif (algo == 'DES'): self._padkey(key, [8]) cipher = cDES.new(key, cDES.MODE_ECB) elif (algo == 'DES3'): key = self._padkey(key, [16, 24]) cipher = cDES3.new(key, cDES3.MODE_ECB) elif (algo == 'XOR'): raise CryptoUnsupportedException("XOR is currently unsupported") else: raise CryptoException("Invalid algorithm specified") return cipher
def runTest(self): # Encrypt/Decrypt data and test output parameter cipher = CAST.new(b'4'*16, CAST.MODE_ECB) pt = b'5' * 16 ct = cipher.encrypt(pt) output = bytearray(16) res = cipher.encrypt(pt, output=output) self.assertEqual(ct, output) self.assertEqual(res, None) res = cipher.decrypt(ct, output=output) self.assertEqual(pt, output) self.assertEqual(res, None) output = memoryview(bytearray(16)) cipher.encrypt(pt, output=output) self.assertEqual(ct, output) cipher.decrypt(ct, output=output) self.assertEqual(pt, output) self.assertRaises(TypeError, cipher.encrypt, pt, output=b'0'*16) self.assertRaises(TypeError, cipher.decrypt, ct, output=b'0'*16) shorter_output = bytearray(7) self.assertRaises(ValueError, cipher.encrypt, pt, output=shorter_output) self.assertRaises(ValueError, cipher.decrypt, ct, output=shorter_output)
def decrypt_file(input_filename, output_filename, authenticity_key, cipher_key): encrypted = open(input_filename, 'rb').read() print "Encrypted: " + encrypted length = len(encrypted) # mac is 16 bytes at end encrypted_before_MAC = encrypted[:length-16] print "Before MAC: " + encrypted_before_MAC orig_MAC = encrypted[length-16:] print "Old MAC: " + orig_MAC computed_MAC = hmac.new(authenticity_key, encrypted_before_MAC).digest() print "New MAC: " + computed_MAC if hmac.compare_digest(orig_MAC, computed_MAC): hex_length = encrypted[:9] cipher_length = int(hex_length, 16)#some function from hex to int print cipher_length iv = encrypted[9: 17] cipher_text = encrypted[17:length-20] #-cipher.length] obj=CAST.new(cipher_key, CAST.MODE_CBC, IV=iv) f = open(output_filename, 'wb') temp = obj.decrypt(cipher_text) print temp f.write(temp)
def _getcipher_real(self, key, algo): """ do the real job of decrypting using functions form PyCrypto """ if (algo == "AES"): key = hashlib.sha256(key) cipher = cAES.new(key.digest(), cAES.MODE_ECB) elif (algo == 'ARC2'): cipher = cARC2.new(key, cARC2.MODE_ECB) elif (algo == 'ARC4'): raise CryptoUnsupportedException("ARC4 is currently unsupported") elif (algo == 'Blowfish'): cipher = cBlowfish.new(key, cBlowfish.MODE_ECB) elif (algo == 'CAST'): cipher = cCAST.new(key, cCAST.MODE_ECB) elif (algo == 'DES'): if len(key) != 8: raise Exception("DES Encrypted keys must be 8 characters " "long!") cipher = cDES.new(key, cDES.MODE_ECB) elif (algo == 'DES3'): key = hashlib.sha224(key) cipher = cDES3.new(key.digest()[:24], cDES3.MODE_ECB) elif (algo == 'XOR'): raise CryptoUnsupportedException("XOR is currently unsupported") else: raise CryptoException("Invalid algorithm specified") return cipher
def encrypt_file(inkey, in_filename, out_filename, chunksize=64*1024): key = fixkey(inkey) if not out_filename: out_filename = in_filename + '.enc' iv = ''.join(chr(random.randint(0, 0xFF)) for i in range(8)) encryptor = CAST.new(key, CAST.MODE_CBC, iv) filesize = os.path.getsize(in_filename) with open(in_filename, 'rb') as infile: with open(out_filename, 'wb') as outfile: outfile.write(struct.pack('<Q', filesize)) outfile.write(iv) while True: chunk = infile.read(chunksize) if len(chunk) == 0: break elif len(chunk) % 16 != 0: chunk += ' ' * (16 - len(chunk) % 16) outfile.write(encryptor.encrypt(chunk)) infile.close() outfile.close()
def decrypt(self, keys, output_dir): if not self.infile: raise DecryptBeforeLoading # if there's a pubkey wrapper, decrypt that first if bool(ord(self.options) & self.OPTIONS['pubkey']): print strings._('scfile_decrypting_pubkey') common.gpg.pubkey_decrypt(self.ciphertext_filename) # delete the .gpg file os.remove(self.ciphertext_filename) self.ciphertext_filename = self.ciphertext_filename.rstrip('.gpg') # reverse the order of ciphers list reversed_ciphers = common.ciphers[:] reversed_ciphers.reverse() # decrypt all the layers of symmetric encryption ciphertext = open(self.ciphertext_filename, 'r').read() for cipher in reversed_ciphers: try: print strings._('scfile_decrypting_symmetric').format(cipher) if cipher == 'aes256': bs = AES.block_size eiv = ciphertext[:bs] ciphertext = ciphertext[bs:] cipher = AES.new(keys[cipher], AES.MODE_CFB, eiv) if cipher == 'blowfish': bs = Blowfish.block_size eiv = ciphertext[:bs] ciphertext = ciphertext[bs:] cipher = Blowfish.new(keys[cipher], Blowfish.MODE_CBC, eiv) if cipher == 'cast5': bs = CAST.block_size eiv = ciphertext[:bs+2] ciphertext = ciphertext[bs+2:] cipher = CAST.new(keys[cipher], CAST.MODE_OPENPGP, eiv) plaintext = cipher.decrypt(ciphertext) except ValueError: raise InvalidDecryptionPassphrase ciphertext = plaintext # delete the .cast5.blowfish.aes256 file os.unlink(self.ciphertext_filename) # write archive to disk archive_filename = self.ciphertext_filename.rstrip('.cast5.blowfish.aes256') open(archive_filename, 'w').write(plaintext) # extract print strings._('scfile_extracting') if not tarfile.is_tarfile(archive_filename): raise InvalidArchive tar = tarfile.open(archive_filename, 'r:gz') names = tar.getnames() tar.extractall(output_dir)
def pycrypto_tests(): # https://pycrypto.readthedocs.io/en/latest/ from Crypto.Cipher import DES, CAST, DES3, ARC2, Blowfish, AES, PKCS1_OAEP, PKCS1_v1_5 DES.new(key, DES.MODE_ECB) # Noncompliant DES.new(mode=DES.MODE_ECB, key=key) # Noncompliant DES.new(key, DES.MODE_CBC, IV=iv) # Noncompliant DES.new(key, DES.MODE_CFB, IV=iv) # Compliant DES.new(key, DES.MODE_OFB, IV=iv) # Compliant DES.new(key, DES.MODE_CTR, IV=iv, counter=ctr) # Compliant CAST.new(key, CAST.MODE_ECB) # Noncompliant DES3.new(key, DES3.MODE_ECB) # Noncompliant ARC2.new(key, ARC2.MODE_CBC, IV=iv) # Noncompliant Blowfish.new(key, Blowfish.MODE_ECB) # Noncompliant AES.new(key, AES.MODE_CBC, IV=iv) # Noncompliant PKCS1_OAEP.new(key) # Compliant PKCS1_v1_5.new(key) # Noncompliant
def Encrypt(self, digestA, pbk): cryp = ARC4.new(digestA) data = ZipInputStream(self.content, True).compress() data = cryp.encrypt(data) iv = Random.new().read(CAST.block_size) cipher = CAST.new(pbk, CAST.MODE_OPENPGP, iv) self.content = cipher.encrypt(data) return
def decryption(cipher_text): start = datetime.now() decryption_suite = CAST.new(key, CAST.MODE_CFB, iv) plain_text = decryption_suite.decrypt(cipher_text) end = datetime.now() total = end - start total = total.total_seconds() print("Decryption time:", total) return plain_text, total
def CryptionMessage(message): """ 暗号化できる文字数は8の倍数です """ crypto_object = CAST.new(CRYPTO_KEY) crypto_message = crypto_object.encrypt(message) en_cr_message = base64.b16encode(crypto_message) return en_cr_message
def encryption(message): start = datetime.now() encryption_suite = CAST.new(key, CAST.MODE_CFB, iv) cipher_text = encryption_suite.encrypt(message) end = datetime.now() total = end - start total = total.total_seconds() print("Encryption time:", total) return cipher_text, total
def Decrypt(self, digestA, pbk): cryp = ARC4.new(digestA) eiv = self.content[:CAST.block_size+2] ciphertext = self.content[CAST.block_size+2:] cipher = CAST.new(pbk, CAST.MODE_OPENPGP, eiv) data = cipher.decrypt(ciphertext) data = cryp.decrypt(data) data = ZipInputStream(StringIO.StringIO(data)).read() self.content = data return
def dec_cast(string_to_decrypt, key): try: hashed_key = HachageHelper.hash('md5', key) cipher = CAST.new(hashed_key[:16]) encrypted_msg = base64.b64decode(string_to_decrypt.encode()) decrypted_msg = cipher.decrypt(encrypted_msg) return decrypted_msg.decode().rstrip(padding_character) except: return "Une erreur s'est produite, veuillez vérifier vos entrées"
def pyCrypto(): import Crypto from Crypto.Cipher import AES, DES, DES3, ARC2, ARC4, Blowfish, CAST, PKCS1_v1_5, PKCS1_OAEP, XOR from Crypto.PublicKey import ElGamal Crypto.Cipher.AES.new() # Noncompliant Crypto.Other.AES.new() # OK AES.new(key=key) # Noncompliant DES.new(key=key) # Noncompliant DES3.new(key=key) # Noncompliant ARC2.new(key=key) # Noncompliant ARC4.new(key=key) # Noncompliant Blowfish.new(key=key) # Noncompliant CAST.new(key=key) # Noncompliant PKCS1_v1_5.new(key=key) # Noncompliant PKCS1_OAEP.new(key=key) # Noncompliant XOR.new(key=key) # Noncompliant ElGamal.generate(key_size) # Noncompliant
def pyCrypto(): import Cryptodome from Cryptodome.Cipher import AES, ChaCha20, DES, DES3, ARC2, ARC4, Blowfish, CAST, PKCS1_v1_5, PKCS1_OAEP, ChaCha20_Poly1305, Salsa20 from Cryptodome.PublicKey import ElGamal Cryptodome.Cipher.AES.new() # Noncompliant Cryptodome.Other.AES.new() # OK AES.new(key=key) # Noncompliant ChaCha20.new(key=key) # Noncompliant DES.new(key=key) # Noncompliant DES3.new(key=key) # Noncompliant ARC2.new(key=key) # Noncompliant ARC4.new(key=key) # Noncompliant Blowfish.new(key=key) # Noncompliant CAST.new(key=key) # Noncompliant PKCS1_v1_5.new(key=key) # Noncompliant PKCS1_OAEP.new(key=key) # Noncompliant ChaCha20_Poly1305.new(key=key) # Noncompliant Salsa20.new(key=key) # Noncompliant ElGamal.generate(key_size) # Noncompliant
def enc_cast(string_to_encrypt, key): try: hashed_key = HachageHelper.hash('md5', key) # CAST key must be at least 5 bytes and no more than 16 bytes long cipher = CAST.new(hashed_key[:16]) padded_private_msg = string_to_encrypt + (padding_character * ( (8 - len(string_to_encrypt)) % 8)) encrypted_msg = cipher.encrypt(padded_private_msg) encoded_encrypted_msg = base64.b64encode(encrypted_msg) return encoded_encrypted_msg.decode() except: return "Une erreur s'est produite, veuillez vérifier vos entrées"
def set_password(self, password, pubkey, privkey): self.privkey_1 = privkey self.pubkey_1 = pubkey self.salt = secrets.token_hex(8) self.password_hash = bcrypt.generate_password_hash( password + self.salt).decode("ascii") cipher = CAST.new(password.encode("utf8"), CAST.MODE_ECB) pubkey = pubkey + "0000000000000000000000" privkey = privkey + "00000000000000" self.pubkey = cipher.encrypt(pubkey.encode("utf8")) self.privkey = cipher.encrypt(privkey.encode("utf8")) db.session.add(self) db.session.commit()
def decrypt_file(key, in_filename,out_filename, chunksize=24*1024): key= fixkey(inkey) if not out_filename: out_filename= in_filename with open(in_filename, 'rb') as infile: origsize = struct.unpack('<Q', infile.read(struct.calcsize('Q')))[0] iv = infile.read(8) decryptor = CAST.new(key, CAST.MODE_CBC, iv) with open(out_filename, 'wb') as outfile: while True: chunk = infile.read(chunksize) if len(chunk) == 0: break outfile.write(decryptor.decrypt(chunk)) outfile.truncate(origsize)
def decrypt_file(key, in_filename, out_filename, chunksize=24 * 1024): key = fixkey(inkey) if not out_filename: out_filename = in_filename with open(in_filename, 'rb') as infile: origsize = struct.unpack('<Q', infile.read(struct.calcsize('Q')))[0] iv = infile.read(8) decryptor = CAST.new(key, CAST.MODE_CBC, iv) with open(out_filename, 'wb') as outfile: while True: chunk = infile.read(chunksize) if len(chunk) == 0: break outfile.write(decryptor.decrypt(chunk)) outfile.truncate(origsize)
def encrypt(plaintext, iv, cipher): #最初加密时的加密函数 key = ENCKEY key = key.encode('utf-8') if cipher.lower() == "des": if len(key) != 8: print("[-] DES 密钥长度为8位!") return False o = DES.new(key, DES.MODE_CBC, iv) elif cipher.lower() == "aes": if len(key) != 16 and len(key) != 24 and len(key) != 32: print("[-] AES 密钥长度为16/24/32位!") return False o = AES.new(key, AES.MODE_CBC, iv) elif cipher.lower() == "des3": if len(key) != 16: print("[-] DES3 密钥长度为16位!") return False o = DES3.new(key, DES3.MODE_CBC, iv) elif cipher.lower() == "blowfish": o = Blowfish.new(key, Blowfish.MODE_CBC, iv) elif cipher.lower() == "cast": o = CAST.new(key, CAST.MODE_CBC, iv) elif cipher.lower() == "arc2": o = ARC2.new(key, ARC2.MODE_CBC, iv) else: return False plaintext = add_PKCS7_padding(plaintext, len(iv)) return o.encrypt(plaintext)
def encrypt_file(input_filename, output_filename): # hard coded private key from os.urandom for this iteration cipher_key = '\xc7\xdfK\xb2\xb1^S\xb9' #CBC, or cipher block chaining, hides large scale patterns, bc depends on previous blocks, not just block encrypted #since CBC depends on previous chunk, needs IV, or initialization vector, for first chunk iv = os.urandom(8) obj=CAST.new(cipher_key, CAST.MODE_CBC, IV=iv) plain = open(input_filename, 'rb').read() rev_mod = 8 - (len(plain) % 8) padding_len = 0 if (rev_mod == 8) else rev_mod padded_plain = plain + chr(padding_len) * padding_len ciph=obj.encrypt(padded_plain) # checksum for authentication, hard coded from os.urandom authencity_key = '\xbd\xd4q7@W\xa3\xbd' h = hmac.new(authencity_key, ciph) plain_len = struct.pack('!Q', len(plain)) f = open(output_filename, 'wb') # encrypted file: length + cipher text (+ padding) + MAC (message authentication code) h.update(plain_len) f.write(plain_len) h.update(iv) f.write(iv) h.update(ciph) f.write(ciph) f.write(h.digest()) print "Old MAC: " + h.digest() f.close()
def decrypt(ciphertext, iv, cipher): #加密过程中的解密函数 # 我们只需要填充错误本身,而不是key # 在真正的攻击中,可以触发解密程序 key = ENCKEY key = key.encode('utf-8') if cipher.lower() == "des": o = DES.new(key, DES.MODE_CBC, iv) elif cipher.lower() == "aes": o = AES.new(key, AES.MODE_CBC, iv) elif cipher.lower() == "des3": o = DES3.new(key, DES3.MODE_CBC, iv) elif cipher.lower() == "blowfish": o = Blowfish.new(key, Blowfish.MODE_CBC, iv) elif cipher.lower() == "cast": o = CAST.new(key, CAST.MODE_CBC, iv) elif cipher.lower() == "arc2": o = ARC2.new(key, ARC2.MODE_CBC, iv) else: return False if len(iv) % 8 != 0: return False if len(ciphertext) % 8 != 0: return False return o.decrypt(ciphertext)
''' Copyright (c) 2014 blu3b0lt CAST implementation ''' from Crypto.Cipher import CAST from Crypto import Random key = b'Key is 5 to 16' iv = Random.new().read(CAST.block_size) cipher = CAST.new(key, CAST.MODE_OPENPGP, iv) plaintext = raw_input("Enter Text to be Encrypted: ") msg = cipher.encrypt(plaintext) print "Encrypted text is: " print msg eiv = msg[:CAST.block_size+2] ciphertext = msg[CAST.block_size+2:] cipher = CAST.new(key, CAST.MODE_OPENPGP, eiv) print "Decrypted text is: " print cipher.decrypt(ciphertext)
def setup(self): self.cipher = CAST.new(self.key, CAST.MODE_CFB, iv=self.iv, segment_size=64)
def DecryptionMessage(message): crypto_object = CAST.new(CRYPTO_KEY) de_message = base64.b16decode(message) decrypto_message = crypto_object.decrypt(de_message) return decrypto_message
) # Write the iv to the output file (will be required for decryption) file_out.write( ciphered_data ) # Write the varying length cipher text to the file (this is the encrypted data) file_out.close() # source: https://pycryptodome.readthedocs.io/en/latest/src/cipher/classic.html # source: https://pycryptodome.readthedocs.io/en/latest/src/cipher/aes.html # source: https://nitratine.net/blog/post/python-encryption-and-decryption-with-pycryptodome/ # Method 2: Encrypting using CAST Mode: from Crypto.Cipher import CAST output_file = 'R#_CAST.bin' data = content key = b'!SQS5342_LBO@S_B' cipher = CAST.new(key, CAST.MODE_OPENPGP) plaintext = content msg = cipher.encrypt(plaintext) file_out = open(output_file, "wb") # Open file to write bytes #file_out.write(cipher.iv) # Write the iv to the output file (will be required for decryption) file_out.write( ciphered_data ) # Write the varying length cipher text to the file (this is the encrypted data) file_out.close() # source: https://pycryptodome.readthedocs.io/en/latest/src/cipher/cast.html ################################ ### PART 3 - DATA DECRYPTION ### ################################
def __getKeyObject(key, iv): global MODE cipher = CAST.new(key, MODE, iv) return cipher
def decrypt(self, enc): iv = enc[:CAST.block_size] cipher = CAST.new(self.key, CAST.MODE_CBC, iv) return Enclibv1_unpad(cipher.decrypt(enc[CAST.block_size:]), self.bs)
def decrypt_castcbc(enc, pwd, salt, keylen): key = hashlib.pbkdf2_hmac("SHA1", pwd.encode('utf-8'), salt.encode('utf-8'), 1024, keylen) iv = b"\x00\x00\x00\x00\x00\x00\x00\x00" cipher = CAST.new(key, CAST.MODE_CBC, iv) return cipher.decrypt(enc)
def cipher(self, key): return CAST.new(key, IV="\0\0\0\0\0\0\0\0", mode=CAST.MODE_CBC)
def encrypt(self, string, isfile=False, addmeta=False): ''' If key is setted up the method will encrypt the string with a path compliant result ''' # If we got an encryption key if self.__key: # Start ciphering system if self.__algorithm == 'AESCFB': cipher = AES.new(self.__key, AES.MODE_CFB) elif self.__algorithm == 'AESECB': cipher = AES.new(self.__key, AES.MODE_ECB) elif self.__algorithm == 'ARC2CFB': cipher = ARC2.new(self.__key, ARC2.MODE_CFB) elif self.__algorithm == 'ARC2ECB': cipher = ARC2.new(self.__key, ARC2.MODE_ECB) elif self.__algorithm == 'BlowfishCFB': cipher = Blowfish.new(self.__key, Blowfish.MODE_CFB) elif self.__algorithm == 'BlowfishECB': cipher = Blowfish.new(self.__key, Blowfish.MODE_ECB) elif self.__algorithm == 'CASTCFB': cipher = CAST.new(self.__key, CAST.MODE_CFB) elif self.__algorithm == 'CASTECB': cipher = CAST.new(self.__key, CAST.MODE_ECB) elif self.__algorithm == 'DESCFB': cipher = DES.new(self.__key, DES.MODE_CFB) elif self.__algorithm == 'DESECB': cipher = DES.new(self.__key, DES.MODE_ECB) else: raise IOError, "Specified encryption algorithm is unkown: %s" % ( self.__algorithm) # Add padding to the string if required if self.padding: (string, padder) = self.pad(string) else: padder = '' # Encrypt the string encoded = cipher.encrypt(string) # Security check if len(encoded) != len(string): self.error( "Encrypt => Normal and decoded string are different size: %s -> %s\n" % (len(encoded), len(string))) # Check if is a file if isfile: # Metadata if not addmeta: b64corrected = encoded else: b64corrected = encoded + padder else: # Encode the result b64encoded = base64.b64encode(encoded) # Correct the result to be path compliant b64corrected = b64encoded.replace("/", "_") else: # Nothing to do b64corrected = string # Return the result return b64corrected
def decrypt(self, b64corrected, isfile=False, removemeta=False): ''' If key is setted up the method will decrypt the string from a path compliant encrypted string ''' # If we got an encryption key if self.__key: # Start ciphering system if self.__algorithm == 'AESCFB': cipher = AES.new(self.__key, AES.MODE_CFB) elif self.__algorithm == 'AESECB': cipher = AES.new(self.__key, AES.MODE_ECB) elif self.__algorithm == 'ARC2CFB': cipher = ARC2.new(self.__key, ARC2.MODE_CFB) elif self.__algorithm == 'ARC2ECB': cipher = ARC2.new(self.__key, ARC2.MODE_ECB) elif self.__algorithm == 'BlowfishCFB': cipher = Blowfish.new(self.__key, Blowfish.MODE_CFB) elif self.__algorithm == 'BlowfishECB': cipher = Blowfish.new(self.__key, Blowfish.MODE_ECB) elif self.__algorithm == 'CASTCFB': cipher = CAST.new(self.__key, CAST.MODE_CFB) elif self.__algorithm == 'CASTECB': cipher = CAST.new(self.__key, CAST.MODE_ECB) elif self.__algorithm == 'DESCFB': cipher = DES.new(self.__key, DES.MODE_CFB) elif self.__algorithm == 'DESECB': cipher = DES.new(self.__key, DES.MODE_ECB) else: raise IOError, "Specified decrypting algorithm is unkown: %s" % ( self.__algorithm) # If is a file if isfile: # And we have to use padding if self.padding: # Remove metatada if not removemeta: encoded = b64corrected else: encoded = b64corrected[:-1] else: # No padder was used encoded = b64corrected else: # Revert the path compliant correction b64encoded = b64corrected.replace("_", "/") # Decode the result encoded = base64.b64decode(b64encoded) # Decrypt the encoded string string = cipher.decrypt(encoded) # Security check if len(encoded) != len(string): self.error( "Decrypt => Normal and encoded string are different size: %s -> %s\n" % (len(encoded), len(string))) # Unpad the string if self.padding: try: string = self.unpad(string) except Exception, e: self.error("Unpad error: %s - String:%s - Encoded:%s\n" % (e, string, b64corrected)) raise
def encrypt(self, txt, pre, enc, post, pwd, tags=True): # if type(txt) != type('') and type(txt) != type(u''): raise TypeError('Invalid data type for encryption: "%s" !' % str(type(txt))) # # Scramble operation. if not pre or pre == 'N' or pre == 'None': pass elif pre == 'ZLIB' or pre == SCRAMBLE_D['ZLIB']: txt = zlib.compress(txt) elif pre == 'BZ2' or pre == SCRAMBLE_D['BZ2']: txt = bz2.compress(txt) elif pre == 'ROT13' or pre == SCRAMBLE_D['ROT13']: txt = string.translate(txt, ROT) else: raise Exception('Invalid scramble "%s" !' % pre) # # Check RSA key path. if enc in ['RSA', 'RSA'] and not os.path.exists(self.rsa_path): print('RSA encryption must specify a valid path !') self.__error(2, pre, enc, post, field='L') return # pwd = self._fix_password(pwd, enc) # if enc == 'AES' or enc == ENC['AES']: o = AES.new(pwd, mode=3, segment_size=16) elif enc == 'ARC2' or enc == ENC['ARC2']: o = ARC2.new(pwd, mode=3, segment_size=16) elif enc == 'CAST' or enc == ENC['CAST']: o = CAST.new(pwd, mode=3, segment_size=16) elif enc == 'Blowfish' or enc == ENC['Blowfish']: o = Blowfish.new(pwd, mode=3, segment_size=16) elif enc == 'DES3' or enc == ENC['DES3']: o = DES3.new(pwd, mode=3, segment_size=16) elif enc == 'RSA' or enc == ENC['RSA']: # Using Blowfish encryption for RSA. o = Blowfish.new(pwd, Blowfish.MODE_CFB) elif not enc or enc in ['None', ENC['None']]: o = None else: raise Exception('Invalid encryption mode "%s" !' % enc) # # Encryption operation. if o: pad_len = 16 - (len(txt) % 16) padding = (chr(pad_len) * pad_len) txt = o.encrypt(txt + padding) # # Codec operation. if post == 'Base64 Codec' or post == ENCODE_D['Base64 Codec']: if tags: txt = '<#>%s:%s:%s<#>%s' % \ (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post].replace(' Codec',''), ba.b2a_base64(txt).decode()) else: txt = ba.b2a_base64(txt).decode() elif post == 'Base32 Codec' or post == ENCODE_D['Base32 Codec']: if tags: txt = '<#>%s:%s:%s<#>%s' % \ (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post].replace(' Codec',''), base64.b32encode(txt).decode()) else: txt = base64.b32encode(txt).decode() elif post == 'HEX Codec' or post == ENCODE_D['HEX Codec']: if tags: txt = '<#>%s:%s:%s<#>%s' % \ (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post].replace(' Codec',''), ba.b2a_hex(txt).decode()) else: txt = ba.b2a_hex(txt).decode() elif post == 'Quopri Codec' or post == ENCODE_D['Quopri Codec']: if tags: txt = '<#>%s:%s:%s<#>%s' % (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post].replace(' Codec',''), \ ba.b2a_qp(txt, quotetabs=True, header=True).decode()) else: txt = ba.b2a_qp(txt, quotetabs=True, header=True).decode() elif post == 'Json' or post == ENCODE_D['Json']: if tags: # Format : {"pre": "AAA", "enc": "BBB", "post": "CCC", "data": "Blah blah blah"} txt = '{"pre": "%s", "enc": "%s", "post": "%s", "data": "%s"}' % \ (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post], ba.b2a_base64(txt).rstrip().decode()) else: txt = json.dumps( {'data': ba.b2a_base64(txt).rstrip().decode()}) elif post == 'XML': if tags: # Format : <root><pre>AAA</pre> <enc>BBB</enc> <post>CCC</post> <data>Blah blah blah</data></root> txt = '<root>\n<pre>%s</pre><enc>%s</enc><post>%s</post>\n<data>%s</data>\n</root>' % \ (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post], ba.b2a_base64(txt).rstrip().decode()) else: txt = '<root>\n<data>%s</data>\n</root>' % ba.b2a_base64( txt).rstrip().decode() else: raise Exception('Invalid codec "%s" !' % post) # # The final text must be String, to be used in GUI return txt
def setup(self): from Crypto.Cipher import CAST self.cipher = CAST.new(self.key, CAST.MODE_CFB, iv=self.iv, segment_size=64)
def decrypt(self, txt, pre, enc, post, pwd): # if type(txt) != type('') and type(txt) != type(u''): raise TypeError('Invalid data type for decryption: "%s" !' % str(type(txt))) # if not (pre and enc and post): self.guess_pre_enc_post(txt) pre = self.pre enc = self.enc post = self.post if '{' in txt and '}' in txt and '"data":' in txt: temp = json.loads(txt.decode()) txt = temp['data'].encode() del temp elif '<data>' in txt and '</data>' in txt: txt = re.search('<data>(.+)</data>', txt, re.S).group(1) else: txt = re.sub(NO_TAGS, '', txt) else: # If Json. if '{' in txt and '}' in txt and '"data":' in txt: pre = 'Json' temp = json.loads(txt.decode()) txt = temp['data'].encode() del temp # If XML. elif '<data>' in txt and '</data>' in txt: pre = 'XML' txt = re.search('<data>(.+)</data>', txt, re.S).group(1) else: txt = re.sub(NO_TAGS, '', txt) # # Check RSA key path. if enc == 'RSA' and not os.path.exists(self.rsa_path): print('RSA decryption must specify a valid path !') self.__error(2, pre, enc, post) return # # Adapting password for encryption. pwd = self._fix_password(pwd, enc) # # Codec operation. if not pre: self.__error(1, 'None', enc, post) return elif pre == 'Base64 Codec' or pre == ENCODE_D['Base64 Codec']: try: txt = ba.a2b_base64(txt) except: self.__error(1, pre, enc, post) return elif pre == 'Base32 Codec' or pre == ENCODE_D['Base32 Codec']: try: txt = base64.b32decode(txt) except: self.__error(1, pre, enc, post) return elif pre == 'HEX Codec' or pre == ENCODE_D['HEX Codec']: try: txt = ba.a2b_hex(txt) except: self.__error(1, pre, enc, post) return elif pre == 'Quopri Codec' or pre == ENCODE_D['Quopri Codec']: try: txt = ba.a2b_qp(txt, header=True) except: self.__error(1, pre, enc, post) return elif pre == 'Json' or pre == ENCODE_D['Json']: try: txt = ba.a2b_base64(txt) except: self.__error(1, pre, enc, post) return elif pre == 'XML': try: txt = ba.a2b_base64(txt) except: self.__error(1, pre, enc, post) return else: raise Exception('Invalid codec "%s" !' % pre) # if enc == 'AES' or enc == ENC['AES']: o = AES.new(pwd, mode=3, segment_size=16) elif enc == 'ARC2' or enc == ENC['ARC2']: o = ARC2.new(pwd, mode=3, segment_size=16) elif enc == 'CAST' or enc == ENC['CAST']: o = CAST.new(pwd, mode=3, segment_size=16) elif enc == 'Blowfish' or enc == ENC['Blowfish']: o = Blowfish.new(pwd, mode=3, segment_size=16) elif enc == 'DES3' or enc == ENC['DES3']: o = DES3.new(pwd, mode=3, segment_size=16) elif enc == 'RSA' or enc == ENC['RSA']: # Using Blowfish decryption for RSA. o = Blowfish.new(pwd, mode=3, segment_size=16) elif not enc or enc in ['None', ENC['None']]: o = None else: raise Exception('Invalid decrypt "%s" !' % enc) # # Decryption operation. if o: try: temp = o.decrypt(txt) pad_len = ord(temp[-1]) txt = temp[:-pad_len] del temp except: self.__error(2, pre, enc, post) return # # Un-scramble operation. if not post or post == 'N' or post == 'None': pass elif post == 'ZLIB' or post == SCRAMBLE_D['ZLIB']: try: txt = zlib.decompress(txt) except: self.__error(3, pre, enc, post) return elif post == 'BZ2' or post == SCRAMBLE_D['BZ2']: try: txt = bz2.decompress(txt) except: self.__error(3, pre, enc, post) return elif post == 'ROT13' or post == SCRAMBLE_D['ROT13']: txt = string.translate(txt, ROT) else: raise Exception('Invalid scramble "%s" !' % post) # return txt
def decrypt(self, txt, pre, enc, post, pwd): # if type(txt) != type('') and type(txt) != type(u''): raise TypeError('Invalid data type for decryption: "%s" !' % str(type(txt))) # if not (pre and enc and post): self.guess_pre_enc_post(txt) pre = self.pre enc = self.enc post = self.post if '{' in txt and '}' in txt and '"data":' in txt: temp = json.loads(txt.decode()) txt = temp['data'].encode() del temp elif '<data>' in txt and '</data>' in txt: txt = re.search('<data>(.+)</data>', txt, re.S).group(1) else: txt = re.sub(NO_TAGS, '', txt) else: # If Json. if '{' in txt and '}' in txt and '"data":' in txt: pre = 'Json' temp = json.loads(txt.decode()) txt = temp['data'].encode() del temp # If XML. elif '<data>' in txt and '</data>' in txt: pre = 'XML' txt = re.search('<data>(.+)</data>', txt, re.S).group(1) else: txt = re.sub(NO_TAGS, '', txt) # # Check RSA key path. if enc == 'RSA' and not os.path.exists(self.rsa_path): print('RSA decryption must specify a valid path !') self.__error(2, pre, enc, post) return # # Adapting password for encryption. pwd = self._fix_password(pwd, enc) # # Codec operation. if not pre: self.__error(1, 'None', enc, post) ; return elif pre == 'Base64 Codec' or pre == ENCODE_D['Base64 Codec']: try: txt = ba.a2b_base64(txt) except: self.__error(1, pre, enc, post) ; return elif pre == 'Base32 Codec' or pre == ENCODE_D['Base32 Codec']: try: txt = base64.b32decode(txt) except: self.__error(1, pre, enc, post) ; return elif pre == 'HEX Codec' or pre == ENCODE_D['HEX Codec']: try: txt = ba.a2b_hex(txt) except: self.__error(1, pre, enc, post) ; return elif pre == 'Quopri Codec' or pre == ENCODE_D['Quopri Codec']: try: txt = ba.a2b_qp(txt, header=True) except: self.__error(1, pre, enc, post) ; return elif pre == 'Json' or pre == ENCODE_D['Json']: try: txt = ba.a2b_base64(txt) except: self.__error(1, pre, enc, post) ; return elif pre == 'XML': try: txt = ba.a2b_base64(txt) except: self.__error(1, pre, enc, post) ; return else: raise Exception('Invalid codec "%s" !' % pre) # if enc == 'AES' or enc == ENC['AES']: o = AES.new(pwd, mode=3, segment_size=16) elif enc == 'ARC2' or enc == ENC['ARC2']: o = ARC2.new(pwd, mode=3, segment_size=16) elif enc == 'CAST' or enc == ENC['CAST']: o = CAST.new(pwd, mode=3, segment_size=16) elif enc == 'Blowfish' or enc == ENC['Blowfish']: o = Blowfish.new(pwd, mode=3, segment_size=16) elif enc == 'DES3' or enc == ENC['DES3']: o = DES3.new(pwd, mode=3, segment_size=16) elif enc == 'RSA' or enc == ENC['RSA']: # Using Blowfish decryption for RSA. o = Blowfish.new(pwd, mode=3, segment_size=16) elif not enc or enc in ['None', ENC['None']]: o = None else: raise Exception('Invalid decrypt "%s" !' % enc) # # Decryption operation. if o: try: temp = o.decrypt(txt) pad_len = ord(temp[-1]) txt = temp[:-pad_len] del temp except: self.__error(2, pre, enc, post) ; return # # Un-scramble operation. if not post or post == 'N' or post == 'None': pass elif post == 'ZLIB' or post == SCRAMBLE_D['ZLIB']: try: txt = zlib.decompress(txt) except: self.__error(3, pre, enc, post) ; return elif post == 'BZ2' or post == SCRAMBLE_D['BZ2']: try: txt = bz2.decompress(txt) except: self.__error(3, pre, enc, post) ; return elif post == 'ROT13' or post == SCRAMBLE_D['ROT13']: txt = string.translate(txt, ROT) else: raise Exception('Invalid scramble "%s" !' % post) # return txt
cipher = AES.new(key, AES.MODE_CBC, iv16) enctext = cipher.encrypt(message) enc_run = ['encrypt'] enc_trial = Timer("cipher.encrypt(message)", setup) enc_run.append(enc_trial.repeat(RUN_COUNT, 1)) algo_run.append(enc_run) dec_run = ['decrypt'] dec_trial = Timer("cipher.decrypt(enctext)", 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 = ['CAST'] cipher = CAST.new(key, CAST.MODE_CBC, iv8) enctext = cipher.encrypt(message) enc_run = ['encrypt'] enc_trial = Timer("cipher.encrypt(message)", setup) enc_run.append(enc_trial.repeat(RUN_COUNT, 1)) algo_run.append(enc_run) dec_run = ['decrypt'] dec_trial = Timer("cipher.decrypt(enctext)", 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) # BEGIN STREAM CIPHER OPERATIONS
def cast_decrypt_transform(data, key, mode, iv): cast = CAST.new(key, mode, iv) return cast.decrypt(data)
def decrypt_castecb(enc, pwd, salt, keylen): key = hashlib.pbkdf2_hmac("SHA1", pwd.encode('utf-8'), salt.encode('utf-8'), 1024, keylen) cipher = CAST.new(key, CAST.MODE_ECB) return cipher.decrypt(enc)
def encrypt(self, txt, pre, enc, post, pwd, tags=True): # if type(txt) != type('') and type(txt) != type(u''): raise TypeError('Invalid data type for encryption: "%s" !' % str(type(txt))) # # Scramble operation. if not pre or pre == 'N' or pre == 'None': pass elif pre == 'ZLIB' or pre == SCRAMBLE_D['ZLIB']: txt = zlib.compress(txt) elif pre == 'BZ2' or pre == SCRAMBLE_D['BZ2']: txt = bz2.compress(txt) elif pre == 'ROT13' or pre == SCRAMBLE_D['ROT13']: txt = string.translate(txt, ROT) else: raise Exception('Invalid scramble "%s" !' % pre) # # Check RSA key path. if enc in ['RSA', 'RSA'] and not os.path.exists(self.rsa_path): print('RSA encryption must specify a valid path !') self.__error(2, pre, enc, post, field='L') return # pwd = self._fix_password(pwd, enc) # if enc == 'AES' or enc == ENC['AES']: o = AES.new(pwd, mode=3, segment_size=16) elif enc == 'ARC2' or enc == ENC['ARC2']: o = ARC2.new(pwd, mode=3, segment_size=16) elif enc == 'CAST' or enc == ENC['CAST']: o = CAST.new(pwd, mode=3, segment_size=16) elif enc == 'Blowfish' or enc == ENC['Blowfish']: o = Blowfish.new(pwd, mode=3, segment_size=16) elif enc == 'DES3' or enc == ENC['DES3']: o = DES3.new(pwd, mode=3, segment_size=16) elif enc == 'RSA' or enc == ENC['RSA']: # Using Blowfish encryption for RSA. o = Blowfish.new(pwd, Blowfish.MODE_CFB) elif not enc or enc in ['None', ENC['None']]: o = None else: raise Exception('Invalid encryption mode "%s" !' % enc) # # Encryption operation. if o: pad_len = 16 - (len(txt) % 16) padding = (chr(pad_len) * pad_len) txt = o.encrypt(txt + padding) # # Codec operation. if post == 'Base64 Codec' or post == ENCODE_D['Base64 Codec']: if tags: txt = '<#>%s:%s:%s<#>%s' % \ (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post].replace(' Codec',''), ba.b2a_base64(txt).decode()) else: txt = ba.b2a_base64(txt).decode() elif post == 'Base32 Codec' or post == ENCODE_D['Base32 Codec']: if tags: txt = '<#>%s:%s:%s<#>%s' % \ (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post].replace(' Codec',''), base64.b32encode(txt).decode()) else: txt = base64.b32encode(txt).decode() elif post == 'HEX Codec'or post == ENCODE_D['HEX Codec']: if tags: txt = '<#>%s:%s:%s<#>%s' % \ (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post].replace(' Codec',''), ba.b2a_hex(txt).decode()) else: txt = ba.b2a_hex(txt).decode() elif post == 'Quopri Codec' or post == ENCODE_D['Quopri Codec']: if tags: txt = '<#>%s:%s:%s<#>%s' % (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post].replace(' Codec',''), \ ba.b2a_qp(txt, quotetabs=True, header=True).decode()) else: txt = ba.b2a_qp(txt, quotetabs=True, header=True).decode() elif post == 'Json' or post == ENCODE_D['Json']: if tags: # Format : {"pre": "AAA", "enc": "BBB", "post": "CCC", "data": "Blah blah blah"} txt = '{"pre": "%s", "enc": "%s", "post": "%s", "data": "%s"}' % \ (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post], ba.b2a_base64(txt).rstrip().decode()) else: txt = json.dumps({'data':ba.b2a_base64(txt).rstrip().decode()}) elif post == 'XML': if tags: # Format : <root><pre>AAA</pre> <enc>BBB</enc> <post>CCC</post> <data>Blah blah blah</data></root> txt = '<root>\n<pre>%s</pre><enc>%s</enc><post>%s</post>\n<data>%s</data>\n</root>' % \ (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post], ba.b2a_base64(txt).rstrip().decode()) else: txt = '<root>\n<data>%s</data>\n</root>' % ba.b2a_base64(txt).rstrip().decode() else: raise Exception('Invalid codec "%s" !' % post) # # The final text must be String, to be used in GUI return txt
def encrypt(self, raw): raw=Enclibv1_pad(raw, self.bs) iv = Enclibv1_strong_random(CAST.block_size) cipher = CAST.new(self.key, CAST.MODE_CBC, iv) return iv + cipher.encrypt(raw)
def decrypt(self, content, salt, password): salt = binascii.a2b_base64(salt) content = binascii.a2b_base64(content) password = blake2b(password.encode("ascii"), digest_size=8).digest() crypter = CAST.new(password, mode=self.MODE, IV=salt) return crypter.decrypt(content).decode("utf-8")
def setup(self): from Crypto.Cipher import CAST self.cipher = CAST.new(self.key, CAST.MODE_CFB, iv=self.iv, segment_size=64)
def lock(self, output_filename, filenames, passphrase, pubkey=None): timer = helpers.Timer() # random salt salt = Random.new().read(16) # compress files into archive timer.start() archive_filename = os.path.join(self.tmp_dir, 'archive.tar.gz') helpers.compress(filenames, archive_filename) print strings._('time_compression').format(timer.stop()) # derive keys from passphrase timer.start() keys = self.stretch_passphrase(passphrase, salt) print strings._('time_stretching').format(timer.stop()) # encrypt with symmetric ciphers timer.start() sys.stdout.write(strings._('encrypt_encrypting_cipher')) sys.stdout.flush() plaintext = open(archive_filename, 'r').read() os.unlink(archive_filename) for cipher in common.ciphers: sys.stdout.write(' {0}'.format(cipher)) sys.stdout.flush() if cipher == 'aes256': # https://www.dlitz.net/software/pycrypto/api/current/Crypto.Cipher.AES-module.html iv = Random.new().read(AES.block_size) cipher = AES.new(keys[cipher], AES.MODE_CFB, iv) ciphertext = iv + cipher.encrypt(plaintext) elif cipher == 'blowfish': # https://www.dlitz.net/software/pycrypto/api/current/Crypto.Cipher.Blowfish-module.html bs = Blowfish.block_size iv = Random.new().read(bs) cipher = Blowfish.new(keys[cipher], Blowfish.MODE_CBC, iv) plen = bs - divmod(len(plaintext),bs)[1] padding = [plen]*plen padding = pack('b'*plen, *padding) ciphertext = iv + cipher.encrypt(plaintext + padding) elif cipher == 'cast5': # https://www.dlitz.net/software/pycrypto/api/current/Crypto.Cipher.CAST-module.html iv = Random.new().read(CAST.block_size) cipher = CAST.new(keys[cipher], CAST.MODE_OPENPGP, iv) ciphertext = cipher.encrypt(plaintext) # today's plaintext is yesterday's ciphertext plaintext = ciphertext sys.stdout.write('\n') # save the new super-enciphered ciphertext current_filename = '{0}.cast5.blowfish.aes256'.format(archive_filename) open(current_filename, 'w').write(plaintext) # encrypt with pubkey if pubkey: common.gpg.pubkey_encrypt(current_filename, pubkey) os.remove(current_filename) current_filename += '.gpg' # write the output file self.save(salt, current_filename, output_filename, bool(pubkey)) print strings._('time_encryption').format(timer.stop()) print strings._('encrypt_encrypted_to').format(output_filename)
def cast_decrypt_transform(data, key, mode, iv): cast = CAST.new(key, mode, iv) return cast.decrypt(data)
def pycrypto_cast(keysize=32, data_size=1024, mode_str="", mode=CAST.MODE_CBC): plaintext = get_random_bytes(data_size * 1024) key = get_random_bytes(keysize) cipher = CAST.new(key, mode) _ = cipher.encrypt(plaintext)