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
