def run(self):
"""run when our device driver thread is started"""
enc = SettingsBase.get_setting(self, "encryption")
if enc:
enc_key = '%016x' % 0x1234
kSize = len(enc_key)
aes = AES(enc_key, keySize=kSize, padding=padWithPadLen())
self.sd = socket(AF_INET, SOCK_DGRAM)
self.sd.bind((self.ip, self.port))
self.sd.setblocking(0)
while self.__stopevent.isSet()==False:
while self.__stopevent.isSet()==False:
try:
buf, addr = self.sd.recvfrom(255)
break
except:
time.sleep(0.01)
try:
data=str(buf)
except:
data='data error'
if enc:
data=aes.decrypt(data)
self.property_set(self.ch_name, Sample(0, str(data), self.ch_unit))
self.__stopevent.clear()
def decrypt_file(file, key):
from crypto.cipher.aes import AES
from crypto.cipher.base import noPadding
cipher = AES(key, keySize=len(key), padding=noPadding())
data = ''
with open(file, "rb") as f:
data = f.read()
with open(file, "wb") as f:
offset = 0
while True:
for enc in [True, False]:
if enc:
chunk = data[offset:offset + len(key)]
offset += len(key)
else:
chunk = data[offset:offset + len(key) * 1000]
offset += len(key) * 1000
if len(chunk) == len(key):
chunk = cipher.decrypt(chunk)
f.write(chunk)
if not chunk:
break
f.close()
def decrypt_subs(self, encsubs):
encdata = binascii.unhexlify(encsubs)
for key in subdeckeys[:]:
subs=""
out=[0,0,0,0]
ecb = AES(binascii.unhexlify(key[0]))
unaes = ecb.decrypt(encdata)
xorkey = array('i',key[1])
for i in range(0, len(encdata)/16):
x = unaes[i*16:i*16+16]
res = array('i',x)
for j in range(0,4):
out[j] = res[j] ^ xorkey[j]
x = encdata[i*16:i*16+16]
xorkey = array('i',x)
a=array('i',out)
x=a.tostring()
subs += x
substart = subs.find("<P")
if (substart > -1):
print key
i = subs.rfind("</P>")
subs = subs[substart:i+4]
return subs
def decrypt_SMIL(self, encsmil):
encdata = binascii.unhexlify(encsmil)
for key in smildeckeys[:]:
smil=""
out=[0,0,0,0]
ecb = AES(binascii.unhexlify(key[0]))
unaes = ecb.decrypt(encdata)
xorkey = array('i',key[1])
for i in range(0, len(encdata)/16):
x = unaes[i*16:i*16+16]
res = array('i',x)
for j in range(0,4):
out[j] = res[j] ^ xorkey[j]
x = encdata[i*16:i*16+16]
xorkey = array('i',x)
a=array('i',out)
x=a.tostring()
smil = smil + x
if (smil.find("<smil") == 0):
print key
i = smil.rfind("</smil>")
smil = smil[0:i+7]
return smil
def decrypt_cid(self, p):
cidkey = '48555bbbe9f41981df49895f44c83993a09334d02d17e7a76b237d04c084e342'
v3 = binascii.unhexlify(p)
print v3
ecb = AES(binascii.unhexlify(cidkey))
print ecb
print ecb.decrypt(v3)
return ecb.decrypt(v3).split("~")[0]
def CCMtestVector(testCase, macSize, key, nonce, addAuth, pt, kct):
""" CCM test vectors using AES algorithm """
print '%s %s %s' % ('=' *
((54 - len(testCase)) / 2), testCase, '=' *
((54 - len(testCase)) / 2))
key, nonce, pt, addAuth, kct = a2b_p(key), a2b_p(nonce), a2b_p(
pt), a2b_p(addAuth), a2b_p(kct)
alg = CCM(AES(key, keySize=len(key)),
macSize=macSize,
nonceSize=len(nonce))
print 'alg=%s%skeySize=%3d blockSize=%3d M=%2d L=%2d' % (
alg.baseCipher.name, ' ' * (10 - len(alg.baseCipher.name)),
alg.keySize, alg.blockSize, alg.M, alg.L)
print 'key: %s' % b2a_p(key)[9:]
print 'nonce: %s' % b2a_p(nonce)[9:]
print 'addAuth:%s' % b2a_p(addAuth)[9:]
print 'pt: %s' % b2a_p(pt)[9:]
ct = alg.encrypt(pt, nonce=nonce, addAuthData=addAuth)
print 'ct: %s' % b2a_p(ct)[9:]
print 'kct: %s' % b2a_p(kct)[9:]
print '========================================================'
self.assertEqual(ct, kct)
dct = alg.decrypt(ct, nonce=nonce, addAuthData=addAuth)
self.assertEqual(dct, pt)
def CBCtestVector(key, iv, pt, kct):
""" CBC test vectors using AES algorithm """
key, iv, pt, kct = a2b_p(key), a2b_p(iv), a2b_p(pt), a2b_p(kct)
alg = CBC(AES(key), padding=noPadding())
self.assertEqual(alg.encrypt(pt, iv=iv), kct)
self.assertEqual(alg.decrypt(iv + kct), pt)
def decrypt_pid(self, p):
cp_strings = [
'6fe8131ca9b01ba011e9b0f5bc08c1c9ebaf65f039e1592d53a30def7fced26c',
'd3802c10649503a60619b709d1278ffff84c1856dfd4097541d55c6740442d8b',
'c402fb2f70c89a0df112c5e38583f9202a96c6de3fa1aa3da6849bb317a983b3',
'e1a28374f5562768c061f22394a556a75860f132432415d67768e0c112c31495',
'd3802c10649503a60619b709d1278efef84c1856dfd4097541d55c6740442d8b'
]
v3 = p.split("~")
v3a = binascii.unhexlify(v3[0])
v3b = binascii.unhexlify(v3[1])
ecb = AES(v3b)
tmp = ecb.decrypt(v3a)
for v1 in cp_strings[:]:
ecb = AES(binascii.unhexlify(v1))
v2 = ecb.decrypt(tmp)
if (re.match("[0-9A-Za-z_-]{32}", v2)):
return v2
def generate_mic(data):
'''
\brief Generate a Message Integrity Code (MIC) over some given data.
\param[in] data The data to calculate the MIC over, a binary string.
\returns The 32-bit MIC, an integer.
'''
#alg = AES_CBC(key=OTAP_KEY, keySize=len(OTAP_KEY), padding=padWithZeros())
#outdata = alg.encrypt(data, iv=OTAP_NONCE)
alg = CCM(AES(OTAP_KEY), macSize=OTAP_MIC_LEN)
outdata = alg.encrypt('', OTAP_NONCE, addAuthData=data)
# the 32-bit MIC is the first 4 bytes of the CBC-MAC result (per CCM spec)
#return struct.unpack('!L', outdata[-16:-12])[0]
return struct.unpack('!L', outdata[-OTAP_MIC_LEN:])[0]
def decrypt(encrypted, key):
pes = AES(key.decode('base64'))
decrypted = pes.decrypt(encrypted.decode('base64'))
return decrypted
def __init__(self, key=None, padding=padWithPadLen(), keySize=16):
CBC.__init__(self, AES(key, noPadding(), keySize), padding)
self.name = 'AES_CBC'
def TX(self):
try:
if self.rand:
self.random_data_generator()
else:
self.bin_file_data_extractor()
SAMPLES=int(self.samples_textctrl.GetValue())
self.progress_bar.SetRange(SAMPLES)
#Check Sample Rate mode and calculate Sleep in seconds
sample_rate=self.sample_rate_textctrl.GetValue()
if sample_rate in ['0','']:
sample_rate=1
self.sample_rate_textctrl.SetValue('1')
else:
sample_rate=float(sample_rate)
choice=self.sample_rate_rb.GetStringSelection()
if choice=='[Hz]':
SLEEP=1.0/float(sample_rate)
else:
SLEEP=float(sample_rate)
choice=self.addressing_type_rb.GetStringSelection()
if choice.startswith('XBee'):
#PAN Change
#self.ser.Open()
PAN = self.pan_id_textctrl.GetValue()
frame_data="0801"+hexlify("ID")+PAN
length = self.length_calc(frame_data)
check_sum = self.check_sum_calc(frame_data)
command="7E" + length + frame_data + check_sum
self.ser.write(unhexlify(command))
#response=hexlify(self.ser.readall())
#Encryption Disable (if not set)
if self.encryption_enabled:
AT_cmd=hexlify('KY')
AT_par=self.encryption_key
if len(AT_par) % 2:
AT_par='0'+AT_par
frame_data="0801"+AT_cmd+AT_par #AT command send
length = self.length_calc(frame_data)
check_sum = self.check_sum_calc(frame_data)
command="7E" + length + frame_data + check_sum
self.ser.write(unhexlify(command))
#response=(hexlify(self.ser.readall()))
AT_cmd=hexlify('EE')
AT_par='01'
frame_data="0801"+AT_cmd+AT_par #AT command send
length = self.length_calc(frame_data)
check_sum = self.check_sum_calc(frame_data)
command="7E" + length + frame_data + check_sum
self.ser.write(unhexlify(command))
#response=(hexlify(self.ser.readall()))
else:
AT_cmd=hexlify('EE')
AT_par='00'
frame_data="0801"+AT_cmd+AT_par #AT command send
length = self.length_calc(frame_data)
check_sum = self.check_sum_calc(frame_data)
command="7E" + length + frame_data + check_sum
self.ser.write(unhexlify(command))
#response=(hexlify(self.ser.readall()))
else:
if self.encryption_enabled: #UDP AES Encryption calrulation here!
key = '%016x' % int(self.encryption_key, 16)
kSize = len(key)
alg = AES(key, keySize=kSize, padding=padWithPadLen())
for i in range(0, SAMPLES):
self.data_arr[i]=alg.encrypt(self.data_arr[i])
'''
XBee S2 - we will use Radios Series2 (ZigBee) Module with explicit addressing (64bit & 16bit) data Transmission
XBee short - we will use Radios Series1 (XBee) Module with short addressing (16bit) data Transmission
XBee long - we will use Radios Series1 (XBee) Module with long addressing (64bit) data Transmission
UDP - we will use standard UDP data Transmission (no Digi Modules involved here)
'''
if choice=="XBee S2":
#self.ser.Open()
self.S2_TX(SLEEP, SAMPLES)
#self.ser.Close()
elif choice=="XBee short":
#self.ser.Open()
self.S1_TX_short(SLEEP, SAMPLES)
#self.ser.Close()
elif choice=="XBee long":
#self.ser.Open()
self.S1_TX_long(SLEEP, SAMPLES)
#self.ser.Close()
elif choice=="UDP":
#self.udp.Open()
self.UDP_TX(SLEEP, SAMPLES)
#self.udp.Close()
except KeyboardInterrupt:
return
def test(self):
aes_cbc = CBC(AES())
aes_cbc.setKey('aaaaaaaaaaaaaaaa')
ct1 = aes_cbc.encrypt('test')
ct2 = aes_cbc.encrypt(
'test') # note - auto iv, reslt is different ths time
from crypto.cipher.aes import AES from crypto.cipher.base import padWithPadLen from binascii import a2b_hex, b2a_hex, hexlify, unhexlify key = '%016x' % 0x1234 kSize = len(key) data = 'Data goes here! Is that a surprize?' alg = AES(key, keySize=kSize, padding=padWithPadLen()) enc_data=alg.encrypt(data) dec_data=alg.decrypt(enc_data)
