def decrypt_PBEWithSHAAndTwofishCBC(encrypted_data, password, salt, iteration_count): """ Decrypts PBEWithSHAAndTwofishCBC, assuming PKCS#12-generated PBE parameters. (Not explicitly defined as an algorithm in RFC 7292, but defined here nevertheless because of the assumption of PKCS#12 parameters). """ iv = derive_key(hashlib.sha1, PURPOSE_IV_MATERIAL, password, salt, iteration_count, 16) key = derive_key(hashlib.sha1, PURPOSE_KEY_MATERIAL, password, salt, iteration_count, 256//8) encrypted_data = bytearray(encrypted_data) encrypted_data_len = len(encrypted_data) if encrypted_data_len % 16 != 0: raise BadDataLengthException("encrypted data length is not a multiple of 16 bytes") plaintext = bytearray() # slow and dirty CBC decrypt from twofish import Twofish cipher = Twofish(key) last_cipher_block = bytearray(iv) for block_offset in range(0, encrypted_data_len, 16): cipher_block = encrypted_data[block_offset:block_offset+16] plaintext_block = xor_bytearrays(bytearray(cipher.decrypt(bytes(cipher_block))), last_cipher_block) plaintext.extend(plaintext_block) last_cipher_block = cipher_block plaintext = strip_pkcs7_padding(plaintext, 16) return bytes(plaintext)
def encrypt_PBEWithSHAAndTwofishCBC(plaintext_data, password, salt, iteration_count): """ Encrypts a value with PBEWithSHAAndTwofishCBC, assuming PKCS#12-generated PBE parameters. (Not explicitly defined as an algorithm in RFC 7292, but defined here nevertheless because of the assumption of PKCS#12 parameters). """ iv = derive_key(hashlib.sha1, PURPOSE_IV_MATERIAL, password, salt, iteration_count, 16) key = derive_key(hashlib.sha1, PURPOSE_KEY_MATERIAL, password, salt, iteration_count, 256//8) plaintext_data = add_pkcs7_padding(plaintext_data, 16) plaintext_data = bytearray(plaintext_data) plaintext_len = len(plaintext_data) assert plaintext_len % 16 == 0 ciphertext = bytearray() from twofish import Twofish cipher = Twofish(key) last_cipher_block = bytearray(iv) for block_offset in range(0, plaintext_len, 16): plaintext_block = plaintext_data[block_offset:block_offset+16] cipher_block = bytearray(cipher.encrypt(bytes(xor_bytearrays(plaintext_block, last_cipher_block)))) ciphertext.extend(cipher_block) last_cipher_block = cipher_block return bytes(ciphertext)
def check_proof(o, proof): o = pickle.dumps(o) T = Twofish(o[0:32]) x = T.encrypt(bytes.fromhex(proof)) if x.hex()[0:3] == '000': return True return False
def fencrypt(filen, password, tweak=0, mode='twofish'): f=open(filen,'r') smstr=f.read() f.close() if mode=='twofish': # splitting it to blocks with 16-bytes len if len(smstr)%16: nstr=str(smstr+'%'*(16-len(smstr)%16)).encode('utf-8') else: nstr=smstr.encode('utf-8') psswd=Twofish(password) encredstr=b'' # ENCRyptED STRing # encrypting blocks for x in range(int(len(nstr)/16)): encredstr+=psswd.encrypt(nstr[x*16:(x+1)*16]) elif mode=='threefish': # splitting it to blocks with 128-bytes len if len(smstr)%128: nstr=str(smstr+'%'*(128 - len(smstr)%128)).encode('utf-8') else: nstr=smstr.encode('utf-8') psswd=threefish(password,tweak) encredstr=b'' # ENCRyptED STRing # encrypting blocks for x in range(int(len(nstr)/128)): encredstr+=psswd.encrypt_block(nstr[x*128:(x+1)*128]) # writing it to file f=open(filen,'wb') f.write(encredstr) f.close()
def decrypt(self, msg): d_start_ts = time.time() end_timestamp = round(time.time(), 5) print('End timestamp at decryption:', end_timestamp, 's') random.seed(seed_no2) self.sk2 = ''.join(random.choice(possible_chars) for i in range(16)) algo2 = Rijndael(self.sk2, self.block_size) decrypt_msg2 = algo2.decrypt(msg) random.seed(seed_no1) self.sk1 = ''.join(random.choice(possible_chars) for i in range(16)) algo1 = Twofish(self.sk1.encode('utf-8')) decrypt_msg1 = algo1.decrypt(decrypt_msg2[:16]) print('Size of decrypt1:', len(decrypt_msg1), 'bytes') print('\nSize of decrypt2:', len(decrypt_msg2), 'bytes') start_timestamp = float((decrypt_msg2[16:]).decode('utf-8')) print('Start timestamp extracted at decryption:', start_timestamp) diff_timestamp = end_timestamp - start_timestamp d_end_ts = time.time() print('Time taken for decrypt():', (d_end_ts - d_start_ts) * 10**3, 'ms') return decrypt_msg1.decode('utf-8'), diff_timestamp
def decrypt(self, message, key): cipher = Twofish(key) data = b'' for i in range(0, len(message), 16): st = message[i:i + 16] data += cipher.decrypt(st) return data
def decrypt_PBEWithSHAAndTwofishCBC(encrypted_data, password, salt, iteration_count): """ Decrypts PBEWithSHAAndTwofishCBC, assuming PKCS#12-generated PBE parameters. (Not explicitly defined as an algorithm in RFC 7292, but defined here nevertheless because of the assumption of PKCS#12 parameters). """ iv = derive_key(hashlib.sha1, PURPOSE_IV_MATERIAL, password, salt, iteration_count, 16) key = derive_key(hashlib.sha1, PURPOSE_KEY_MATERIAL, password, salt, iteration_count, 256 // 8) encrypted_data = bytearray(encrypted_data) encrypted_data_len = len(encrypted_data) if encrypted_data_len % 16 != 0: raise BadDataLengthException( "encrypted data length is not a multiple of 16 bytes") plaintext = bytearray() # slow and dirty CBC decrypt from twofish import Twofish cipher = Twofish(key) last_cipher_block = bytearray(iv) for block_offset in range(0, encrypted_data_len, 16): cipher_block = encrypted_data[block_offset:block_offset + 16] plaintext_block = xor_bytearrays( bytearray(cipher.decrypt(bytes(cipher_block))), last_cipher_block) plaintext.extend(plaintext_block) last_cipher_block = cipher_block plaintext = strip_pkcs7_padding(plaintext, 16) return bytes(plaintext)
def encrypt_PBEWithSHAAndTwofishCBC(plaintext_data, password, salt, iteration_count): """ Encrypts a value with PBEWithSHAAndTwofishCBC, assuming PKCS#12-generated PBE parameters. (Not explicitly defined as an algorithm in RFC 7292, but defined here nevertheless because of the assumption of PKCS#12 parameters). """ iv = derive_key(hashlib.sha1, PURPOSE_IV_MATERIAL, password, salt, iteration_count, 16) key = derive_key(hashlib.sha1, PURPOSE_KEY_MATERIAL, password, salt, iteration_count, 256 // 8) plaintext_data = add_pkcs7_padding(plaintext_data, 16) plaintext_data = bytearray(plaintext_data) plaintext_len = len(plaintext_data) assert plaintext_len % 16 == 0 ciphertext = bytearray() from twofish import Twofish cipher = Twofish(key) last_cipher_block = bytearray(iv) for block_offset in range(0, plaintext_len, 16): plaintext_block = plaintext_data[block_offset:block_offset + 16] cipher_block = bytearray( cipher.encrypt( bytes(xor_bytearrays(plaintext_block, last_cipher_block)))) ciphertext.extend(cipher_block) last_cipher_block = cipher_block return bytes(ciphertext)
class TwofishCipher: """ This class handles all the cryptographic operations. """ def __init__(self, key): self.__bs = bs self.__cipher = Twofish(key) def __add_pad(self, chunk): """ Return a chunk with padding added (ISO 10126). """ padding = self.__bs - len(chunk) for idx, i in enumerate(range(padding), start=1): chunk += os.urandom(1) if idx != padding else bytes([padding]) return chunk def __del_pad(self, chunk): """ Return a chunk with padding removed (ISO 10126). """ return chunk[:-chunk[-1]] def encrypt(self, chunk): """ Return an encrypted chunk. """ if len(chunk) != bs: return self.__cipher.encrypt(self.__add_pad(chunk)) else: return self.__cipher.encrypt(chunk) def decrypt(self, chunk, unpad=False): """ Return a decrypted chunk. """ if unpad: return self.__del_pad(self.__cipher.decrypt(chunk)) else: return self.__cipher.decrypt(chunk)
def __init__(self, key, iv): self.log = logging.getLogger("twofish.cbc.%s" % type(self).__name__) self.log.debug('initing') assert len(iv) == 16 from twofish import Twofish self.key = key self.iv = iv self.tw = Twofish(self.key)
def find_nonce(o): T = Twofish(o[0:32]) x = secrets.token_bytes(16) secret = secrets.token_bytes(16) while x.hex()[0:3] != '000': secret = secrets.token_bytes(16) x = T.encrypt(secret) return secret.hex(), x.hex()
def encrypt(self, message, key): cipher = Twofish(key) data = b'' for i in range(0, len(message), 16): st = message[i:i + 16] if len(st) < 16: st = st + b' ' * (16 - len(st)) data += cipher.encrypt(st) return self.encryption.encrypt(data, key)
def produceCCMtag(nonce, payload, header, key=None): if (key == None): raise AttributeError("CCMtag key undefined") iv = Twofish(key).encrypt(produceIV(nonce, len(payload))) processed_header = blockCipherZeroPad(produceHeaderHeader(header)) result = (CBCMode(Twofish(key), iv).encrypt(processed_header + blockCipherZeroPad(payload))) result = result[len(result) - 16:len(result) - 8] # mac ctr = Twofish(key).encrypt(produceCTRblock(nonce, 0)) final = stringXOR(result, ctr) return final
def fdecrypt(filen,password): f=open(filen,'rb') smstr=f.read() f.close() psswd=Twofish(password) decredstr=b'' for x in range(int(len(smstr)/16)): decredstr+=psswd.decrypt(smstr[x*16:(x+1)*16]) return codecs.decode(decredstr,'utf-8').strip('%')
def TWOde(key, in_filename, out_filename=None, chunksize=16): key = key.encode('utf-8') key = Twofish(key) if not out_filename: out_filename = in_filename[:-4] with open(in_filename, 'rb') as infile: with open(out_filename, 'wb') as outfile: while True: chunk = infile.read(chunksize) if len(chunk) == 0: break outfile.write(key.decrypt(chunk))
def whale(key , cipher): #Define key: #key = str(raw_input("Key: ")) #cipher = str(raw_input("Cipher: ")) #Get key: try: tuna = Twofish(key) print(key + ": " + tuna.decrypt(cipher).decode()) except: #print("Key :" + key + " failed") pass; # save your eye some trouble
def whale(key, cipher): #Define key: #key = str(raw_input("Key: ")) #cipher = str(raw_input("Cipher: ")) #Get key: try: tuna = Twofish(key) print(key + ": " + tuna.decrypt(cipher).decode()) except: #print("Key :" + key + " failed") pass
class TwofishExample: """ A class to represent an TwofishExample. METHODS ------- encrypt(msg): Encrypts the msg and returns it. decrypt(encrypted): Decrypts the encrypted msg and returns it. """ def __init__(self): """ Constructs the TwofishExample object. """ self.key = b'FSMF73R873YM1872Y' self.tf = Twofish(self.key) def encrypt(self, msg): """ Encrypts the msg. PARAMETERS ---------- :param msg : Message to be encrypted :type msg : str RETURNS ------- :returns encrypted message :rtype bytearray """ return self.tf.encrypt(msg) def decrypt(self, encrypted): """ Decrypts the encrypted message. PARAMETERS ---------- :param encrypted : Encrypted message to be decrypted :type encrypted : bytearray RETURNS ------- :returns decrypted message :rtype str """ return self.tf.decrypt(encrypted).decode()
def twofish_decrypt(password, path): infile = open(path, "rb") data = infile.read() infile.close() cipher = Twofish(bytes(password, 'utf-8')) decrypted = b'' # decrypted string for x in range(int(len(data) / 16)): decrypted += cipher.decrypt(data[x * 16:(x + 1) * 16]) outfile = open(path + '.decrypted', "wb") outfile.write(decrypted) outfile.close()
def TWOen(key, in_filename, out_filename=None, chunksize=16) : key = key.encode('utf-8') key = Twofish(key) if not out_filename : out_filename = in_filename + '.enc' with open(in_filename, 'rb') as infile : with open(out_filename, 'wb') as outfile : while True : chunk = infile.read(chunksize) if len(chunk) == 0: break elif len(chunk) % 16 != 0 : temp = ' '*(16 - len(chunk)%16) chunk += temp.encode('utf-8') outfile.write(key.encrypt(chunk))
def test_ecb(self): from twofish import Twofish tw = Twofish(self.key) for testData in self.testData: self.assertTrue( len(testData) % 16 == 0, "Test data length needs to be evenly divisible by 16. Got %r" % len(testData) ) # Can take multiple blocks cipherText = tw.encrypt(testData) self.assertNotEqual(cipherText, testData, "Plain and cipher text should not be the same") decrypted = tw.decrypt(cipherText) self.assertEqual( decrypted, testData, "The encrypted and then decrypted text should match the original text" )
class TwofishCBCDecryption(object): def __init__(self, key, iv): self.log = logging.getLogger("twofish.cbc.%s" % type(self).__name__) self.log.debug('initing') assert len(iv) == 16 from twofish import Twofish self.key = key self.iv = iv self.tw = Twofish(self.key) def decrypt(self, blocks): assert len( blocks ) % 16 == 0, "Expected cipher text length to be a multiple of 16. Got %r. " % len( blocks) ret = b'' while len(blocks) > 0: block = blocks[:16] blocks = blocks[16:] ret += self.decryptBlock(block) return ret def decryptBlock(self, block): assert len(block) == 16 intr = self.tw.decrypt(block) oldIV = self.iv self.iv = block return xor(oldIV, intr)
def CTRmodeEncryptData(plain, nonce, key): if (key is None): return None padded = blockCipherZeroPad(plain) stream = '' for i in range(len(padded) >> 4): stream += Twofish(key).encrypt(produceCTRblock(nonce, i + 1)) return stringXOR(padded, stream)[:len(plain)]
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"
class TwofishCBCDecryption(object): def __init__(self, key, iv): self.log = logging.getLogger("twofish.cbc.%s" % type(self).__name__) self.log.debug('initing') assert len(iv) == 16 from twofish import Twofish self.key = key self.iv = iv self.tw = Twofish(self.key) def decrypt(self, blocks): assert len(blocks) % 16 == 0, "Expected cipher text length to be a multiple of 16. Got %r. " % len(blocks) ret = '' while len(blocks) > 0: block = blocks[:16] blocks = blocks[16:] ret += self.decryptBlock(block) return ret def decryptBlock(self, block): assert len(block) == 16 intr = self.tw.decrypt(block) oldIV = self.iv self.iv = block return xor(oldIV, intr)
def send(self): to_send=self.entry.get() print("Sending: "+to_send) index=random.randrange(1,100,1) key=self.alldata.key[index] self.alldata.encrypt_key=key self.setkeylabel() tfh=Twofish(key.encode()) if(self.alldata.encrypt_key==""): #self.send_queue.put("message "+to_send) self.alldata.senddict[self.messenger_socket].put("message "+to_send) self.alldata.sent_raw_message[self.messenger_socket].put("message "+to_send) self.alldata.outputs.append(self.messenger_socket) else: try: encrypted_data=self.alldata.encryptor.encode(to_send,tfh) except LookupError: self.alldata.encryptor=Encryptor(b'7774') encrypted_data=self.alldata.encryptor.encode(to_send, tfh) msg_data = tools.message_obj(index, encrypted_data, None) self.alldata.senddict[self.messenger_socket].put(pickle.dumps(msg_data)) self.alldata.sent_raw_message[self.messenger_socket].put(str(index).encode() + b' ' + encrypted_data) self.alldata.outputs.append(self.messenger_socket) self.messagequeue.put(datetime.date.strftime(datetime.datetime.now(),'%m/%d-%H:%M:%S')+"\nME: "+to_send) self.entry.delete(0,'end')
def fencrypt(filen,password): f=open(filen,'r') smstr=f.read() f.close() if len(smstr)%16: nstr=str(smstr+'%'*(16-len(smstr)%16)).encode('utf-8') else: nstr=smstr.encode('utf-8') psswd=Twofish(password) encredstr=b'' for x in range(int(len(nstr)/16)): encredstr+=psswd.encrypt(nstr[x*16:(x+1)*16]) f=open(filen,'wb') f.write(encredstr) f.close()
def TWOde(key, in_filename, out_filename=None, chunksize=16) : key = key.encode('utf-8') key = Twofish(key) if not out_filename : out_filename = in_filename[:-4] with open(in_filename, 'rb') as infile : with open(out_filename, 'wb') as outfile : while True : chunk = infile.read(chunksize) if len(chunk) == 0 : break outfile.write(key.decrypt(chunk)) # key = 'pass' # TWOen(key, 'Capture.PNG') # TWOde(key, 'Capture.PNG.enc', 'random.png')
def twofishEncrypt(): start_time = time() key = twofish_password.get() T = Twofish(key) n = 16 pos = 0 x = [] res = "" for c in normal_message: if (pos % n == 0): if (pos == 0): res += c else: x.append(res) res = "" res += c else: res += c pos = pos + 1 print(x) carry = res i = 0 msg_len = 16 - len(carry) while i < msg_len: carry += "_" i = i + 1 x.append(carry) twofish_array = [] for split_message in x: print("split normal message : " + split_message) cipher_twofish = T.encrypt(split_message) print("split cipher result : " + cipher_twofish.encode("hex")) cipher_twofish = cipher_twofish.encode("hex") twofish_array.append(cipher_twofish) global twofish_encrypted_message twofish_encrypted_message = "".join(twofish_array) print("merged cipher result : " + twofish_encrypted_message) messagebox.showinfo("Success", "Encrypt Twofish Success") end_time = time() time_taken = end_time - start_time hours, rest = divmod(time_taken, 3600) minutes, seconds = divmod(rest, 60) print("Time taken:", format_timespan(end_time - start_time))
def twofish_encrypt(password, path): infile = open(path, "r") data = infile.read() infile.close() if len(data) % 16: nstr = str(data + "%" * (16 - len(data) % 16)).encode('ascii') else: nstr = data.encode("ascii") cipher = Twofish(bytes(password, 'ascii')) encrypted = b'' for x in range(int(len(nstr) / 16)): encrypted += bytes(cipher.encrypt(nstr[x * 16:(x + 1) * 16])) outfile = open(path + '.encrypted', "wb") outfile.write(encrypted) outfile.close()
class TwoFish: def __init__(self, key=None): if key is None: self.key = secrets.token_bytes(16) else: self.key = key self.tf = Twofish(self.key) def encode(self, strs): strs = _16fillblock(strs) ret = b'' for i in range(len(strs)): ret += self.tf.encrypt(strs[i]) return ret def decode(self, strs): strs = _16fillblock(strs) ret = b'' for i in range(len(strs)): ret += self.tf.decrypt(strs[i]) return ret[:len(ret) - 16]
def encrypt(self, msg): e_start_ts = time.time() start_timestamp = round(time.time(), 5) print('Start timestamp at encryption:', start_timestamp, 's') algo1 = Twofish(self.sk.encode('utf-8')) encrypt_msg1 = algo1.encrypt(msg.encode('utf-8')) algo2 = Rijndael(self.sk, self.block_size) encrypt_msg2 = algo2.encrypt(encrypt_msg1 + str(start_timestamp).encode('utf-8')) print('\nSize of encrypt1:', len(encrypt_msg1), 'bytes') print('Size of encrypt2:', len(encrypt_msg2), 'bytes') e_end_ts = time.time() print('Time taken for encrypt():', (e_end_ts - e_start_ts) * 10**3, 'ms') return encrypt_msg2
def TwofishEncryption(key, msgB): encrypted = "" i = 0 #start encrypt start = time.perf_counter() loops = math.ceil(len(msgB) / 16) T = Twofish(key[:32].encode("UTF-8")) while i < loops: x = T.encrypt(msgB[i:i + 16]) x = binascii.hexlify(x) x = x.decode("UTF-8") encrypted += x i += 1 stop = time.perf_counter() #encrypt stop #stats begining lenght = len(encrypted) timeDiff = stop - start return lenght, timeDiff
def twofishDecrypt(): # twf_var.get() #ini get password start_time = time() global decrypt_twofish_join text = hc_join key = twofish_password.get() T = Twofish(key) n = 32 ii = 0 x = [] res = "" for c in text: if (ii % n == 0): if (ii == 0): res += c else: x.append(res) res = "" res += c else: res += c ii = ii + 1 x.append(res) print(x) twofish_array = [] for twofish_plain_res in x: print(twofish_plain_res) twofish_decrypt = T.decrypt(twofish_plain_res.decode("hex")) print(twofish_decrypt) twofish_array.append(twofish_decrypt) decrypt_twofish_join = "".join(twofish_array) print(decrypt_twofish_join) messagebox.showinfo("Success", "Decrypt Twofish Success") end_time = time() time_taken = end_time - start_time hours, rest = divmod(time_taken, 3600) minutes, seconds = divmod(rest, 60) print("Time taken:", format_timespan(end_time - start_time))
def decrypt(self, msg): d_start_ts = time.time() end_timestamp = round(time.time(), 5) print('End timestamp at decryption:', end_timestamp, 's') algo2 = Rijndael(self.sk, self.block_size) decrypt_msg2 = algo2.decrypt(msg) algo1 = Twofish(self.sk.encode('utf-8')) decrypt_msg1 = algo1.decrypt(decrypt_msg2[:16]) print('\nSize of decrypt2:', len(decrypt_msg2), 'bytes') print('Size of decrypt1:', len(decrypt_msg1), 'bytes') start_timestamp = float((decrypt_msg2[16:]).decode('utf-8')) print('Start timestamp extracted at decryption:', start_timestamp, 's') diff_timestamp = end_timestamp - start_timestamp d_end_ts = time.time() print('Time taken for decrypt():', (d_end_ts - d_start_ts) * 10**3, 'ms') return decrypt_msg1.decode('utf-8'), diff_timestamp
def index(): if request.method == 'POST': gener_key = generator2() T = Twofish(gener_key) plaintext = request.form['plaintext'] plaintext_original = request.form['plaintext'] if (len(plaintext) < 16): while (len(plaintext) < 16): plaintext = plaintext + random.choice(string.ascii_letters) if (len(plaintext) == 16): chipertext = T.encrypt(bytes(plaintext, 'utf-8')) new_chipertext = Ciphertext(chipertext, gener_key) #new_key = Ciphertext(hex_to_binary(gener_key)) #db.session().add(new_chipertext) db.session().add(new_chipertext) db.session().commit() result = chipertext.decode('utf-8', 'ignore') #chipertext_to_plaintext = T.decrypt(chipertext) return render_template("index.html", result_c=result, result_p=plaintext_original) return render_template("index.html")
def fdecrypt(filen, password, tweak=0, mode='twofish'): # reading file in byte mode f=open(filen,'rb') smstr=f.read() f.close() if mode=='twofish': psswd=Twofish(password) decredstr=b'' # decrypting blocks for x in range(int(len(smstr)/16)): decredstr+=psswd.decrypt(smstr[x*16:(x+1)*16]) elif mode=='threefish': psswd=threefish(password,tweak) decredstr=b'' # decrypting blocks for x in range(int(len(smstr)/128)): decredstr+=psswd.decrypt_block(smstr[x*128:(x+1)*128]) return decode(decredstr,'utf-8').strip('%')
class TwofishCBCEncryption(object): def __init__(self, key, iv): self.log = logging.getLogger("twofish.cbc.%s" % type(self).__name__) self.log.debug('initing') assert len(iv) == 16 from twofish import Twofish self.key = key self.iv = iv self.tw = Twofish(self.key) def encrypt(self, blocks): assert len(blocks) % 16 == 0 ret = '' while len(blocks) > 0: block = blocks[:16] blocks = blocks[16:] ret += self.encryptBlock(block) return ret def encryptBlock(self, block): assert len(block) == 16 self.iv = self.tw.encrypt(xor(self.iv, block)) return self.iv
def CBC_encrypt(IV_str: str, key_str: str, data_str: str) -> str: ''' Encrypt data CBC using the IV, key and the actual data IV - Initialization Value (aka the salt/nonce) (what type?) key - the key (what type?) data - the data (what type?) ''' print('[*] Encrypting database...') IV = IV_str.encode('utf-8') key = key_str.encode('utf-8') data = data_str.encode('utf-8') if len(IV) > 16: while len(IV) != 16: IV = IV[1:] if len(IV) < 16: while len(IV) != 16: for i in IV: IV += i if len(IV) == 16: break if len(key) > 32: while len(key) != 32: key = key[1:] cipher = Twofish(key) rounds = int(float(len(data))/16) #print("[+] Initiating encryption process..") buf = b'' block = data[:16] data = data[16:] if len(block) != 16: block = padup(block) #print('block: {}\niv: {}'.format(len(block), len(IV))) # hexxed is type(bytes) hexxed = byte_hexxor(block, IV) #print('hexxed: {}\nlen: {}'.format(hexxed, len(hexxed))) # block is type(bytes) block = cipher.encrypt(hexxed) buf += block for round in range(0, rounds-1): data_chunk_bytes = data[:16] hexxed = byte_hexxor(data_chunk_bytes, block) #print(type(hexxed)) #print(len(hexxed)) block = cipher.encrypt(hexxed) #print('data: {}'.format(base64.b64encode(hexxed))) #print('block : {}'.format(base64.b64encode(block))) buf += block data = data[16:] #print(type(data)) if len(data) < 16: # Padding up the last block. data = padup(data) # data is bytes block = cipher.encrypt(byte_hexxor(data, block)) buf += block break # Obfuscation for the 0END signature. #print("buf " + str(base64.b64encode(buf))) #print(data) data = ASCII_0END_BLOCK[:] # Make a copy of the block block = cipher.encrypt(byte_hexxor(data, block)) buf += block #print('buf: ', end='') #print(base64.b64encode(buf)) #print('=======================') for i in range(rand(1,obfuscation_layers)): if rand(1, 3301) % 2 == 0: data = ASCII_0END_BLOCK[:] else: data = padup("") block = cipher.encrypt(byte_hexxor(data, block)) buf += block if padding != 0: buf = b"PADDING = " + str(padding).encode('utf-8') + b"\n" + buf print('[*] Database encrypted.') return buf
def CBC_decrypt(IV_str, key_str, data): ''' Decrypt a Twofish-CBC encrypted file. IV - Initalization Vector (aka nonce) key - The key used to decrypt the file (type str) data - the file to be decrypted (type str) ''' print('[*] Decrypting database...') IV = IV_str.encode('utf-8') key = key_str.encode('utf-8') assert type(data) == bytes if len(IV) > 16: #while len(IV) != 16: # IV = IV[1:] IV = IV[len(IV)-16:] elif len(IV) < 16: # TODO: How to do this better? copy = IV[:] while len(IV) != 16: for i in copy: IV += i if len(IV) == 16: break assert len(IV) == 16 # keysize is limited to 32 bytes as per libtwofish, the libary # that pytwofish is based off of if len(key) > 32: while len(key) != 32: key = key[1:] #print(len(key)) cipher = Twofish(key) padlen = 0 if b'PADDING' in data: data = data.replace(b'PADDING = ', b'') padlen = int(data[:data.find(b'\n')]) data = data[data.find(b'\n')+1:] # number or rounds is equal the the number of 16-byte blocks rounds = len(data) // 16 #print('padding length: {}'.format(padlen)) #print('data length: {}'.format(len(data))) #print('[+] Initiating decryption process..') buf = b'' old_block = data[:16] #print('old block: {}'.format(len(old_block))) data = data[16:] #print('old_block len: {}'.format(len(old_block))) hexxed = byte_hexxor(cipher.decrypt(old_block), IV) new_block = byte_hexxor(cipher.decrypt(old_block), IV) buf += new_block assert type(new_block) == bytes and type(old_block) == bytes for rnd in range(rounds-1): new_block = data[:16] data = data[16:] #print('old: {}\nnew: {}'.format(base64.b64encode(old_block), base64.b64encode(new_block))) #print('='*5) buf += byte_hexxor(cipher.decrypt(new_block), old_block) old_block = new_block[:] # strip obfuscation end_block_index = buf.find(ASCII_0END_BLOCK) # USE find() here, rfind() breaks sutff if end_block_index != -1: buf = buf[:end_block_index] # strip padding if padlen != 0: buf = buf[:len(buf)-padlen] print('[*] Database decrypted.') return buf
from twofish import Twofish import sys T = Twofish(sys.argv[1]) crypt = raw_input('encrypted data: ') print 'decrypted:' i = 0 while (i < len(crypt)): sys.stdout.write(T.decrypt(crypt[i:i+16])) i+=16