def test08(self): print 'test08-------------------------' # en-- key = 'Call me Ishmael.'[:16] key = map(ord, key) data = 'This is not a block length.' mode = aes.AESModeOfOperation.modeOfOperation["CBC"] if mode == aes.AESModeOfOperation.modeOfOperation["CBC"]: data = aes.append_PKCS7_padding(data) keysize = len(key) assert keysize in aes.AES.keySize.values( ), 'invalid key size: %s' % keysize # create a new iv using random data iv = [12, 34, 96, 15, 12, 34, 96, 15, 12, 34, 96, 15, 12, 34, 96, 15] moo = aes.AESModeOfOperation() (mode, length, ciph) = moo.encrypt(data, mode, key, keysize, iv) # With padding, the original length does not need to be known. It's a bad # idea to store the original message length. # prepend the iv. encrypt_data = ciph print aes.decryptDataIv(key, ciph, iv) keysize = len(key) assert keysize in aes.AES.keySize.values( ), 'invalid key size: %s' % keysize # iv is first 16 bytes #iv = map(ord, encrypt_data[:16]) moo = aes.AESModeOfOperation() decr = moo.decrypt(encrypt_data, None, mode, key, keysize, iv) if mode == aes.AESModeOfOperation.modeOfOperation["CBC"]: decr = aes.strip_PKCS7_padding(decr) print decr
def encryptResponse(self, request, decrypted, response): randomSalt = self.getRandomSalt() sha256 = hashlib.sha256() sha256.update(randomSalt) #*2to3* result = sha256.digest() iv = bytearray(request['message']['salt'].encode('latin-1')) #*2to3* randomStuff = bytearray(16) for i in range(0, 16): randomStuff[i] = (bytearray(decrypted['salt'].encode('latin-1'))[i] ^ iv[i] ^ randomSalt[i]) & 0xff #*2to3* responsedata = self.DecryptedResponse() responsedata['response'] = response responsedata['keys'] = randomStuff #*2to3* responsedata['hash'] = result padded = aes.append_PKCS7_padding( str(responsedata).encode('latin-1')) #*2to3* moo = aes.AESModeOfOperation() moo.aes.v6 = self.v6 mode, orig_len, crypted = moo.encrypt(padded, moo.ModeOfOperation["CBC"], self.key, moo.aes.KeySize["SIZE_128"], iv) #*2to3* return iv.decode('latin-1').encode('latin-1'), crypted #*2to3*
def send(): """ will take a message and encypt it based on the setting chosen in encryption_selected """ global stext global encryption_selected stext = entr.get() entr.delete(0, END) if encryption_selected == "basic": # Takes the message to be sent and encrypts it using the basicencrypt module stext = basicencrypt.encrypt(stext) # Adds identifier onto the end of the message stext += "rbUb7qe14x" server_socket.send(stext) elif encryption_selected == "aes": # Takes the message to be sent and encrypts it using the aes module encrypt = aes.AESModeOfOperation() key = get_aes_key() mode, orig_len, ciphertext = encrypt.encrypt( stext, encrypt.modeOfOperation["OFB"], key, encrypt.aes.keySize["SIZE_128"], [ 103, 35, 148, 239, 76, 213, 47, 118, 255, 222, 123, 176, 106, 134, 98, 92 ]) # converts the integer list that is output to a string ciphertext = str(ciphertext) # the original message length is then appended to the front of the message ciphertext = str(orig_len) + "," + ciphertext server_socket.send(ciphertext) else: # if there is no encryption the message is just sent server_socket.send(stext)
def generateRequest(self, requestBase): esalt = self.getRandomSalt() moo = aes.AESModeOfOperation() moo.aes.v6 = self.v6 dsalt = moo.decrypt(esalt, 16, moo.ModeOfOperation["CBC"], self.key, moo.aes.KeySize["SIZE_128"], esalt) dsalt = bytearray(dsalt) decrypted = self.DecryptedRequest() decrypted['salt'] = dsalt decrypted['request'] = requestBase padded = aes.append_PKCS7_padding(str(decrypted).encode('latin-1')) mode, orig_len, crypted = moo.encrypt(padded, moo.ModeOfOperation["CBC"], self.key, moo.aes.KeySize["SIZE_128"], esalt) message = self.RequestV5.Message(bytes(crypted)) request = self.RequestV5() bodyLength = 2 + 2 + len(message) request['bodyLength1'] = bodyLength request['bodyLength2'] = bodyLength request['versionMinor'] = requestBase['versionMinor'] request['versionMajor'] = requestBase['versionMajor'] request['message'] = message shell_message(nshell = 10) request = byterize(request) logger.info("Request V%d Data: \n%s\n" % (self.ver, justify(request.dump(print_to_stdout = False)))) logger.info("Request V%d: \n%s\n" % (self.ver, justify(binascii.b2a_hex(str(request).encode('latin-1')).decode('utf-8')))) return request
def generateRequest(self, requestBase): esalt = self.getRandomSalt() moo = aes.AESModeOfOperation() moo.aes.v6 = self.v6 dsalt = moo.decrypt(esalt, 16, moo.modeOfOperation["CBC"], self.key, moo.aes.keySize["SIZE_128"], esalt) dsalt = bytearray(dsalt) decrypted = self.DecryptedRequest() decrypted['salt'] = str(dsalt) decrypted['request'] = requestBase padded = aes.append_PKCS7_padding(str(decrypted)) mode, orig_len, crypted = moo.encrypt(padded, moo.modeOfOperation["CBC"], self.key, moo.aes.keySize["SIZE_128"], esalt) message = self.RequestV5.Message(str(bytearray(crypted))) bodyLength = len(message) + 2 + 2 request = self.RequestV5() request['bodyLength1'] = bodyLength request['bodyLength2'] = bodyLength request['versionMinor'] = requestBase['versionMinor'] request['versionMajor'] = requestBase['versionMajor'] request['message'] = message logging.info("Request V%d Data: %s" % (self.ver, request.dump())) logging.info("Request V%d: %s" % (self.ver, binascii.b2a_hex(str(request)))) return request
def test02(self): print '-------------------------' plaintext = 'This is not a block length.' #54686973206973206a75737420616e206578616d706c65 #54686973206973206a75737420616e206578616d706c65 textnum = str2nums(plaintext) print textnum print str2hex(plaintext) moo = aes.AESModeOfOperation() smode = 'CBC' pymode = moo.modeOfOperation[smode] print 'mode %r (%s)' % (smode, pymode) skey = 'Call me Ishmael.'[:16] #print 'skey is %s' % skey nkey = str2nums(skey) print 'nkey:', nkey #[67, 97, 108, 108, 32, 109, 101, 32, 73, 115, 104, 109, 97, 101, 108, 46] #iv = [12, 34, 96, 15] * 4 iv = [12, 34, 96, 15, 12, 34, 96, 15, 12, 34, 96, 15, 12, 34, 96, 15] pymo, pyos, pyen = moo.encrypt(plaintext, pymode, nkey, len(nkey), iv) print ' PY enc (mode=%s, orgsize=%s):' % (pymo, pyos) print type(bytes(pyen[1])), bytes(pyen[1]) print ' pyen:', type(pyen), pyen print ashex(pyen) pyos = 32 pydec = moo.decrypt(pyen, pyos, pymo, nkey, len(nkey), iv) print ' PY dec (mode=%s, orgsize=%s):' % (pymo, pyos) print pydec pass
def encryptResponse(self, request, decrypted, response): randomSalt = self.getRandomSalt() sha256 = hashlib.sha256() sha256.update(str(randomSalt)) result = sha256.digest() SaltC = bytearray(request['message']['salt']) DSaltC = bytearray(decrypted['salt']) randomStuff = bytearray(16) for i in range(0, 16): randomStuff[i] = (SaltC[i] ^ DSaltC[i] ^ randomSalt[i]) & 0xff # XorSalts XorSalts = bytearray(16) for i in range(0, 16): XorSalts[i] = (SaltC[i] ^ DSaltC[i]) & 0xff message = self.DecryptedResponse.Message() message['response'] = response message['keys'] = str(randomStuff) message['hash'] = result message['xorSalts'] = str(XorSalts) message['hwid'] = self.config['hwid'] # SaltS SaltS = self.getRandomSalt() moo = aes.AESModeOfOperation() moo.aes.v6 = True d = moo.decrypt(SaltS, 16, moo.modeOfOperation["CBC"], self.key, moo.aes.keySize["SIZE_128"], SaltS) # DSaltS DSaltS = bytearray(d) # HMacMsg HMacMsg = bytearray(16) for i in range(0, 16): HMacMsg[i] = (SaltS[i] ^ DSaltS[i]) & 0xff HMacMsg.extend(str(message)) # HMacKey requestTime = decrypted['request']['requestTime'] HMacKey = self.getMACKey(requestTime) HMac = hmac.new(HMacKey, str(HMacMsg), hashlib.sha256) digest = HMac.digest() responsedata = self.DecryptedResponse() responsedata['message'] = message responsedata['hmac'] = digest[16:] padded = aes.append_PKCS7_padding(str(responsedata)) mode, orig_len, crypted = moo.encrypt(str(padded), moo.modeOfOperation["CBC"], self.key, moo.aes.keySize["SIZE_128"], SaltS) return str(SaltS), str(bytearray(crypted))
def print_(data, incoming_message): """ will read if there is and incoming message check for its encryption type if its a message it is then decrypted if it needs it and is output to the text box """ global line11 if (len(data) > 0) and (incoming_message == False): # if it is not a message that needs to be output to the text box data = data + '\n' elif incoming_message: # the size alias part of the string is found count = 0 for char in data: if char == ' ': count += 1 break else: count += 1 if data[-10:] == "rbUb7qe14x": # if the identifier above is found on the end of the message then # data has the alias put in front with the main message decrypted using basicencrypt module data = data[:count] + basicencrypt.decrypt(data[count:-10]) + '\n' elif data[-1:] == "]": # if a ']' is at the end of the message then the message has the # alias and original length parts taken off the front and is then converted to an # integer list to be decrypted extracted_data = data[count:] extracted_data = extracted_data.split(',') ori_length = int(extracted_data[0]) data_list = [] for i in range(1, len(extracted_data)): if i != len(extracted_data): temp = extracted_data[1] temp = temp[1:] data_list.append(int(temp)) else: temp = extracted_data[i] temp = temp[1:-1] data_list.append(int(temp)) decrypt = aes.AESModeOfOperation() key = get_aes_key() mode = decrypt.modeOfOperation["OFB"] decrypted = decrypt.decrypt( data_list, ori_length, mode, key, decrypt.aes.keySize["SIZE_128"], [ 103, 35, 148, 239, 76, 213, 47, 118, 255, 222, 123, 176, 106, 134, 98, 92 ]) # the decrypted message is then output to a string with the alias at the front data = data[:count] + decrypted + '\n' else: data = data + '\n' # writes data to the text box line11 += 1.0 text1.config(state=NORMAL) text1.insert(line11, data) text1.mark_set(INSERT, line11) text1.config(state=DISABLED)
def encrypt(self, key, data): key = map(ord, key) data = aes.append_PKCS7_padding(data) keysize = len(key) iv = [ord(i) for i in os.urandom(16)] mode = aes.AESModeOfOperation.modeOfOperation["CBC"] moo = aes.AESModeOfOperation() (mode, length, ciph) = moo.encrypt(data, mode, key, keysize, iv) return ("".join([chr(i) for i in iv]), "".join([chr(i) for i in ciph]))
def decrypt(self, key, param, data): key = map(ord, key) keysize = len(key) iv = map(ord, param[:16]) data = map(ord, data) moo = aes.AESModeOfOperation() mode = aes.AESModeOfOperation.modeOfOperation["CBC"] decr = moo.decrypt(data, None, mode, key, keysize, iv) return aes.strip_PKCS7_padding(decr)
def decryptRequest(self, request): encrypted = bytearray(str(request['message'])) iv = bytearray(request['message']['salt']) moo = aes.AESModeOfOperation() moo.aes.v6 = self.v6 decrypted = moo.decrypt(encrypted, 256, moo.modeOfOperation["CBC"], self.key, moo.aes.keySize["SIZE_128"], iv) decrypted = aes.strip_PKCS7_padding(decrypted) return self.DecryptedRequest(decrypted)
def decryptResponse(self, response): paddingLength = response['bodyLength1'] % 8 iv = bytearray(response['salt']) encrypted = bytearray(response['encrypted'][:-paddingLength]) moo = aes.AESModeOfOperation() moo.aes.v6 = self.v6 decrypted = moo.decrypt(encrypted, 256, moo.modeOfOperation["CBC"], self.key, moo.aes.keySize["SIZE_128"], iv) decrypted = aes.strip_PKCS7_padding(decrypted) return self.DecryptedResponse(decrypted)
def aes_encrypt_with_iv(key, iv, data): mode = aes.AESModeOfOperation.modeOfOperation["CBC"] key = map(ord, key) iv = map(ord, iv) data = aes.append_PKCS7_padding(data) keysize = len(key) assert keysize in aes.AES.keySize.values(), 'invalid key size: %s' % keysize moo = aes.AESModeOfOperation() (mode, length, ciph) = moo.encrypt(data, mode, key, keysize, iv) return ''.join(map(chr, ciph))
def aes_decrypt_with_iv(key, iv, data): mode = aes.AESModeOfOperation.modeOfOperation["CBC"] key = map(ord, key) iv = map(ord, iv) keysize = len(key) assert keysize in aes.AES.keySize.values(), 'invalid key size: %s' % keysize data = map(ord, data) moo = aes.AESModeOfOperation() decr = moo.decrypt(data, None, mode, key, keysize, iv) decr = strip_PKCS7_padding(decr) return decr
def decryptRequest(self, request): encrypted = bytearray(str( request['message']).encode('latin-1')) #*2to3* iv = bytearray(request['message']['salt'].encode('latin-1')) #*2to3* moo = aes.AESModeOfOperation() moo.aes.v6 = self.v6 decrypted = moo.decrypt(encrypted, 256, moo.ModeOfOperation["CBC"], self.key, moo.aes.KeySize["SIZE_128"], iv) #*2to3* decrypted = aes.strip_PKCS7_padding(decrypted) decrypted = bytes(decrypted) #*2to3* return self.DecryptedRequest(decrypted)
def aes128_cbc_decrypt(data, key, iv): moo = aes.AESModeOfOperation() cbc = moo.modeOfOperation["CBC"] aes128 = moo.aes.keySize["SIZE_128"] def str_to_list(s): return map(ord, s) data = str_to_list(data) key = str_to_list(key) iv = str_to_list(iv) return moo.decrypt(data, 16, cbc, key, aes128, iv)
def decryptResponse(self, response): paddingLength = response['bodyLength1'] % 8 iv = bytearray(response['salt'].encode('latin-1')) #*2to3* encrypted = bytearray( response['encrypted'][:-paddingLength].encode('latin-1')) #*2to3* moo = aes.AESModeOfOperation() moo.aes.v6 = self.v6 decrypted = moo.decrypt(encrypted, 256, moo.ModeOfOperation["CBC"], self.key, moo.aes.KeySize["SIZE_128"], iv) #*2to3* decrypted = aes.strip_PKCS7_padding(decrypted) decrypted = bytes(decrypted) #*2to3* return self.DecryptedResponse(decrypted)
def test01(self): print '-------------------------' plaintext = 'This is just an example' moo = aes.AESModeOfOperation() for smode in modes: pymode = moo.modeOfOperation[smode] print 'mode %r (%s)' % (smode, pymode) skey = 'Call me Ishmael.'[:16] #print 'skey is %s' % skey nkey = str2nums(skey) print 'nkey:', nkey #[67, 97, 108, 108, 32, 109, 101, 32, 73, 115, 104, 109, 97, 101, 108, 46] iv = [12, 34, 96, 15] * 4 pymo, pyos, pyen = moo.encrypt(plaintext, pymode, nkey, len(nkey), iv) print ' PY enc (mode=%s, orgsize=%s):' % (pymo, pyos) print ' ', pyen pydec = moo.decrypt(pyen, pyos, pymo, nkey, len(nkey), iv) print ' PY dec (mode=%s, orgsize=%s):' % (pymo, pyos) print pydec pass
def encryptResponse(self, request, decrypted, response): randomSalt = self.getRandomSalt() result = hashlib.sha256(str(randomSalt)).digest() iv = bytearray(request['message']['salt']) randomStuff = bytearray(16) for i in range(0, 16): randomStuff[i] = (bytearray(decrypted['salt'])[i] ^ iv[i] ^ randomSalt[i]) & 0xff responsedata = self.DecryptedResponse() responsedata['response'] = response responsedata['keys'] = str(randomStuff) responsedata['hash'] = result padded = aes.append_PKCS7_padding(str(responsedata)) moo = aes.AESModeOfOperation() moo.aes.v6 = self.v6 mode, orig_len, crypted = moo.encrypt(padded, moo.modeOfOperation["CBC"], self.key, moo.aes.keySize["SIZE_128"], iv) return str(iv), str(bytearray(crypted))
#if no encryption, take strings as is if use_enc == '0': key_str = password[0:32] #take first 32 bytes as is key_ext_str = password[32:] #takelast 32 bytes as is data_str = data ################################################################################ #Start of Encryption procedure ################################################################################ else: if password == "open": print "cannot encrypt since no password was supplied !!!" exit moo = aes.AESModeOfOperation() #first byte is the length of the password (unless password length is 32 bytes) password_input = password if (len(password) < 32): password = chr( len(password_input)) + password_input #add length of password password_ext = [] elif (len(password) == 32): #taske as is password = password_input password_ext = [] elif (len(password) < 64): password = password_input[0:32] #take first 32 bytes as is password_ext = password_input[32:] #take rest of bytes password_ext = chr( len(password_ext)) + password_ext #add length of extension