def CBCtestVector(key,iv,pt,kct):
""" CBC test vectors using AES algorithm """
key,iv,pt,kct = a2b_hex(key),a2b_hex(iv),a2b_p(pt),a2b_p(kct)
alg = AES_CBC(key, padding=noPadding())
self.assertEqual( alg.encrypt(pt,iv=iv), kct )
self.assertEqual( alg.decrypt(iv+kct), pt )
def testAutoIV(self):
k = a2b_hex('2b7e151628aed2a6abf7158809cf4f3c')
alg = AES_CBC(key=k, padding=noPadding())
pt = a2b_hex('6bc1bee22e409f96e93d7e117393172a')
ct = alg.encrypt(pt)
dct = alg.decrypt(ct)
self.assertEqual( dct, pt ) # 'AES_CBC auto IV error'
def testAutoIVandPadding(self):
k = a2b_hex('2b7e151628aed2a6abf7158809cf4f3c')
alg = AES_CBC(key=k) # should default to padWithPadLen
pt = a2b_hex('6bc1bee22e409f96e93d7e117393172a')
ct = alg.encrypt(pt)
dct = alg.decrypt(ct)
self.assertEqual( dct, pt ) # 'AES_CBC auto IV and pad error'
def testAutoIVandPadding(self):
k = a2b_hex('2b7e151628aed2a6abf7158809cf4f3c')
alg = AES_CBC(key=k) # should default to padWithPadLen
pt = a2b_hex('6bc1bee22e409f96e93d7e117393172a')
ct = alg.encrypt(pt)
dct = alg.decrypt(ct)
self.assertEqual( dct, pt ) # 'AES_CBC auto IV and pad error'
def CBCtestVector(key,iv,pt,kct):
""" CBC test vectors using AES algorithm """
key,iv,pt,kct = a2b_hex(key),a2b_hex(iv),a2b_p(pt),a2b_p(kct)
alg = AES_CBC(key, padding=noPadding())
self.assertEqual( alg.encrypt(pt,iv=iv), kct )
self.assertEqual( alg.decrypt(iv+kct), pt )
def testAutoIV(self):
k = a2b_hex('2b7e151628aed2a6abf7158809cf4f3c')
alg = AES_CBC(key=k, padding=noPadding())
pt = a2b_hex('6bc1bee22e409f96e93d7e117393172a')
ct = alg.encrypt(pt)
dct = alg.decrypt(ct)
self.assertEqual( dct, pt ) # 'AES_CBC auto IV error'
def encryptPlayerUrl(data):
# print(("_encryptPlayerUrl data[%s]" % data))
decrypted = ''
try:
data = json.loads(data)
salt = str(a2b_hex(data["v"]).decode('iso-8859-1')).encode('iso-8859-1')
const = str('s05z9Gpd=syG^7{').encode('iso-8859-1')
key, iv = EVP_BytesToKey(md5, const, salt, 32, 16, 1)
bcompare = str(a2b_hex(data['b']).decode('iso-8859-1')).encode('utf-8')
ivcompare = str(iv).encode('utf-8')
if ivcompare != bcompare:
print("_encryptPlayerUrl IV mismatched")
if 0:
from crypto.cipher import AES
aes = AES.new(key, AES.MODE_CBC, iv, segment_size=128)
input = str(a2b_base64(data["a"]).decode('iso-8859-1')).encode('iso-8859-1')
decrypted = aes.decrypt(input)
decrypted = decrypted[0:-ord(decrypted[-1])]
else:
kSize = len(key)
alg = AES_CBC(key, keySize=kSize)
input = str(a2b_base64(data["a"]).decode('iso-8859-1'))
decrypted = alg.decrypt(input, iv=iv)
decrypted = decrypted.split('\x00')[0]
decrypted = "%s" % json.loads(decrypted)
except:
decrypted = ''
return decrypted
def decrypt(secret_token, data):
iv = secret_token[:len(secret_token) // 2]
key = secret_token[len(secret_token) // 2:]
cipher = AES_CBC(key=key, keySize=16)
decrypted_data = cipher.decrypt(base64.b64decode(data), iv).strip()
return decrypted_data
def encrypt(secret_token, data):
data = data.encode('utf-8')
iv = secret_token[:len(secret_token) // 2]
key = secret_token[len(secret_token) // 2:]
cipher = AES_CBC(key=key, keySize=16)
encrypted_data = base64.b64encode(cipher.encrypt(data, iv))
return encrypted_data
def testNonDupIV(self):
""" Test to ensure that two instances of CBC don't get duplicate IV """
k = a2b_hex('2b7e151628aed2a6abf7158809cf4f3c')
alg1 = AES_CBC(k)
alg2 = AES_CBC(k)
pt = a2b_hex('6bc1bee22e409f96e93d7e117393172a')
ct1 = alg1.encrypt(pt)
ct2 = alg2.encrypt(pt)
assert( ct1!= ct2 ), 'AES_CBC dup IV error'
def decode(self, id, iv, data, compressed=True):
key = generateKey(id)
iv = base64.b64decode(iv)
data = base64.b64decode(data)
data = iv + data
cipher = AES_CBC(key, padding=noPadding(), keySize=32)
decryptedData = cipher.decrypt(data)
if compressed:
return zlib.decompress(decryptedData)
else:
return decryptedData
def decodeSubtitles(self, id, iv, data): compressed = True key = self.generateKey(id) iv = Common().ByteArrayToString(Base64Decoder().decode(iv)) data = Common().ByteArrayToString(Base64Decoder().decode(data)) data = iv+data cipher = AES_CBC(key, padding=noPadding(), keySize=32) decryptedData = cipher.decrypt(data) if compressed: return zlib.decompress(decryptedData) else: return decryptedData
def decode(self, id, iv, data, compressed=True):
key = generateKey(id)
iv = base64.b64decode(iv)
data = base64.b64decode(data)
data = iv + data
cipher = AES_CBC(key, padding=noPadding(), keySize=32)
decryptedData = cipher.decrypt(data)
if compressed:
return zlib.decompress(decryptedData)
else:
return decryptedData
def decodeSubtitles(self, id, iv, data):
compressed = True
key = self.generateKey(id)
iv = self.ByteArrayToString(self.decode(iv))
data = self.ByteArrayToString(self.decode(data))
data = iv + data
cipher = AES_CBC(key, padding=noPadding(), keySize=32)
decryptedData = cipher.decrypt(data)
if compressed:
return zlib.decompress(decryptedData)
else:
return decryptedData
def decode_subtitles(self, id, iv, data):
compressed = True
key = self.generate_key(id)
iv = base64.b64decode(iv)
data = base64.b64decode(data)
data = iv+data
#cipher = AES.new(key, AES.MODE_CBC, iv)
cipher = AES_CBC(key, padding=noPadding(), keySize=32)
decryptedData = cipher.decrypt(data)
if compressed:
return zlib.decompress(decryptedData)
else:
return decryptedData
def ooyalaDecrypt(self, data):
print "Ooyala: --> Attempting to decrypt SMIL..."
crypt = {'KEY':'4b3d32bed59fb8c54ab8a190d5d147f0e4f0cbe6804c8e0721175ab68b40cb01','IV':'00020406080a0c0ea0a2a4a6a8aaacae'}
decodedByteArray = Base64Decoder().decode(data)
data = Common().ByteArrayToString(decodedByteArray)
aes_key = unhexlify(crypt['KEY'])
iv_bytes = iv=unhexlify(crypt['IV'])
d = iv_bytes + data
cipher = AES_CBC(aes_key, padding=noPadding(), keySize=32)
v = cipher.decrypt(d)
length = struct.unpack('>I', v[:4])[0]
compressed = v[4:length+4]
decompressed = zlib.decompress(compressed)
print "Ooyala: --> SMIL decrypted successfully."
return decompressed[16:]
def ooyalaDecrypt(self, data):
print "Ooyala: --> Attempting to decrypt SMIL..."
crypt = {'KEY':'4b3d32bed59fb8c54ab8a190d5d147f0e4f0cbe6804c8e0721175ab68b40cb01','IV':'00020406080a0c0ea0a2a4a6a8aaacae'}
decodedByteArray = Base64Decoder().decode(data)
data = Common().ByteArrayToString(decodedByteArray)
aes_key = unhexlify(crypt['KEY'])
iv_bytes = iv=unhexlify(crypt['IV'])
d = iv_bytes + data
cipher = AES_CBC(aes_key, padding=noPadding(), keySize=32)
v = cipher.decrypt(d)
length = struct.unpack('>I', v[:4])[0]
compressed = v[4:length+4]
decompressed = zlib.decompress(compressed)
print "Ooyala: --> SMIL decrypted successfully."
return decompressed[16:]
def testNonDupIV(self):
""" Test to ensure that two instances of CBC don't get duplicate IV """
k = a2b_hex('2b7e151628aed2a6abf7158809cf4f3c')
alg1 = AES_CBC(k)
alg2 = AES_CBC(k)
pt = a2b_hex('6bc1bee22e409f96e93d7e117393172a')
ct1 = alg1.encrypt(pt)
ct2 = alg2.encrypt(pt)
assert( ct1!= ct2 ), 'AES_CBC dup IV error'
def encryptPlayerUrl(data):
# print("_encryptPlayerUrl data[%s]" % data)
decrypted = ''
try:
data = byteify(json.loads(data))
salt = a2b_hex(data["v"])
key, iv = EVP_BytesToKey(md5, "s05z9Gpd=syG^7{", salt, 32, 16, 1)
if iv != a2b_hex(data.get('b', '')):
print("_encryptPlayerUrl IV mismatched")
if 0:
from crypto.cipher import AES
aes = AES.new(key, AES.MODE_CBC, iv, segment_size=128)
decrypted = aes.decrypt(a2b_base64(data["a"]))
decrypted = decrypted[0:-ord(decrypted[-1])]
else:
kSize = len(key)
alg = AES_CBC(key, keySize=kSize)
decrypted = alg.decrypt(a2b_base64(data["a"]), iv=iv)
decrypted = decrypted.split('\x00')[0]
decrypted = "%s" % json.loads(decrypted).encode('utf-8')
except:
decrypted = ''
return decrypted
def decrypt_input(self, f, key, iv):
"""decrypt video URL"""
cipher = AES_CBC(key=key, keySize=32)
return self.ensure_unicode(cipher.decrypt(binascii.a2b_base64(f), iv))
def decrypt_func(data):
cipher = AES_CBC(encryption_key, padding=noPadding(),
keySize=len(encryption_key))
return cipher.decrypt(iv + data)
def decrypt_func(data):
cipher = AES_CBC(encryption_key,
padding=noPadding(),
keySize=len(encryption_key))
return cipher.decrypt(iv + data)
def generate_mic(data):
'''Generate the MIC over the given data'''
alg = AES_CBC(key=OTAP_KEY, keySize=len(OTAP_KEY), padding=padWithZeros())
outdata = alg.encrypt(data, iv=OTAP_NONCE)
# use the first 4 bytes of the CBC-MAC result as the MIC (per CCM spec)
return struct.unpack('!L', outdata[-16:-12])[0]
