def new(key, mode, IV=None):
if mode == MODE_ECB:
return ECBMode(AES(key))
elif mode == MODE_CBC:
if IV is None:
raise ValueError, "CBC mode needs an IV value!"
return CBCMode(AES(key), IV)
else:
raise NotImplementedError
def aes_ecb_decrypt(ctext, key, unpad=True):
if HAVE_CRYPTO:
cipher = AES.new(key, mode=AES.MODE_ECB)
else:
cipher = AES(key, mode="ECB")
ptext = cipher.decrypt(ctext)
return unpad_pkcs7_aes(ptext) if unpad else ptext
def _get_cipher(self):
try:
from Crypto.Cipher import AES
return AES.new(self.key)
except ImportError:
from aescbc import AES, noPadding
return AES(self.key, padding=noPadding())
def encrypt(input_message, user_id):
master_key = long(user_id)
print master_key
a = AES(master_key)
print a.encrypt(int(input_message.encode("hex")))
aes_key_cipher = rsa_encrypt(user_id, n, e, 15)
print aes_key_cipher
def decrypt(cipher_text, aes_cipher_key):
aes_key = rsa_decrypt(aes_cipher_key, n, d, 15)
aes_key = aes_key[0:5]
master_key = long(aes_key)
a = AES(master_key)
result = a.decrypt(cipher_text)
print str(result).decode("hex")
def create_decryptor(self, key, sequence):
if key.method != "AES-128":
raise StreamError("Unable to decrypt cipher {0}", key.method)
if not key.uri:
raise StreamError("Missing URI to decryption key")
if self.key_uri != key.uri:
zoom_key = self.reader.stream.session.options.get("zoom-key")
saw_key = self.reader.stream.session.options.get("saw-key")
your_key = self.reader.stream.session.options.get("your-key")
if zoom_key:
uri = 'http://www.zoomtv.me/k.php?q=' + base64.urlsafe_b64encode(
zoom_key + base64.urlsafe_b64encode(key.uri))
elif saw_key:
if 'foxsportsgo' in key.uri:
_tmp = key.uri.split('/')
uri = urljoin(saw_key,
'/m/fream?p=' + _tmp[-4] + '&k=' + _tmp[-1])
elif 'nlsk.neulion' in key.uri:
_tmp = key.uri.split('?')
uri = urljoin(saw_key, '/m/stream?' + _tmp[-1])
elif 'nhl.com' in key.uri:
_tmp = key.uri.split('/')
uri = urljoin(saw_key,
'/m/streams?ci=' + _tmp[-3] + '&k=' + _tmp[-1])
elif your_key:
if 'mlb.com' in key.uri:
_tmp = key.uri.split('?')
uri = urljoin(your_key, '/mlb/get_key/' + _tmp[-1])
elif 'espn3/auth' in key.uri:
_tmp = key.uri.split('?')
uri = urljoin(your_key, '/ncaa/get_key/' + _tmp[-1])
elif 'nhl.com' in key.uri:
_tmp = key.uri.split('nhl.com/')
uri = urljoin(your_key, '/nhl/get_key/' + _tmp[-1])
else:
uri = key.uri
else:
uri = key.uri
res = self.session.http.get(uri,
exception=StreamError,
**self.reader.request_params)
self.key_data = res.content
self.key_uri = key.uri
iv = key.iv or num_to_iv(sequence)
if _android_ssl:
return enc(self.key_data, iv)
elif _oscrypto:
return AES(self.key_data, iv)
else:
return AES.new(self.key_data, AES.MODE_CBC, iv)
def pyOCB_encrypt(text):
aes = AES(128)
ocb = OCB(aes)
key = bytearray().fromhex('A45F5FDEA5C088D1D7C8BE37CABC8C5C')
ocb.setKey(key)
nonce = bytearray(range(16))
ocb.setNonce(nonce)
plaintext = bytearray('The Magic Words are Squeamish Ossifrage')
header = bytearray('Recipient: [email protected]')
(tag,ciphertext) = ocb.encrypt(plaintext, header)
(is_authentic, plaintext2) = ocb.decrypt(header, ciphertext, tag)
return True
def aes_cbc_encrypt(ptext, key, iv=b"\x00" * 16):
if HAVE_CRYPTO:
# `AES.MODE_ECB` isn't a typo; we're implementing CBC by hand.
cipher = AES.new(key, AES.MODE_ECB)
ptext, ctext, ct_block = pad_pkcs7(ptext), bytearray(), iv
for i in range(0, len(ptext), 16):
pt_block = repeating_key_xor(ptext[i:i + 16], ct_block)
ct_block = cipher.encrypt(pt_block)
ctext.extend(ct_block)
return bytes(ctext)
else:
cipher = AES(key, mode="CBC", iv=iv)
return cipher.encrypt(pad_pkcs7(ptext))
def AES_ECB_keysize(AES: callable) -> int:
"""
Returns keysize used by an AES ECB encryption function.
"""
text = "A random key long enough to decode the key size used in the encryption"
# Checks repetition of blocks.
# Looks for increase in cipher length because the moment text length goes over blocksize, a new block is created of blocksize, padded.
# Thus we can infer block size from the increase in length observed.
for i in range(1, len(text)):
plaintext = text[:i] + text[:i]
cipher = AES(plaintext.encode())
if cipher[:i] == cipher[i:2 * i]:
print("Key size used for the given ciphertext is {}".format(i))
return i
def aes_ctr(bstream, key, nonce=0):
nonce = aes_ctr_pack(nonce)
if HAVE_CRYPTO:
# `AES.MODE_ECB` isn't a typo; we're implementing CTR by hand.
cipher = AES.new(key, mode=AES.MODE_ECB)
else:
cipher = AES(key, mode="ECB")
result = bytearray()
for count, i in enumerate(range(0, len(bstream), 16)):
key_block = cipher.encrypt(nonce + aes_ctr_pack(count))
result.extend(kb ^ sb for kb, sb in zip(key_block, bstream[i:i + 16]))
return bytes(result)
def decrypt_pass(cpassword):
'''
AES key for cpassword decryption: http://msdn.microsoft.com/en-us/library/2c15cbf0-f086-4c74-8b70-1f2fa45dd4be%28v=PROT.13%29#endNote2
'''
key = (b'\x4e\x99\x06\xe8'
b'\xfc\xb6\x6c\xc9'
b'\xfa\xf4\x93\x10'
b'\x62\x0f\xfe\xe8'
b'\xf4\x96\xe8\x06'
b'\xcc\x05\x79\x90'
b'\x20\x9b\x09\xa4'
b'\x33\xb6\x6c\x1b')
cpass_len = len(cpassword)
padded_pass = (cpassword + "=" * ((4 - cpass_len % 4) % 4))
password = b64decode(padded_pass)
decrypter = AES(key, AES.MODE_CBC, '\x00' * 16)
return decrypter.decrypt(password)
def aes_cbc_decrypt(ctext, key, iv=b"\x00" * 16, unpad=True):
if HAVE_CRYPTO:
# `AES.MODE_ECB` isn't a typo; we're implementing CBC by hand.
cipher = AES.new(key, AES.MODE_ECB)
ptext, ct_block = bytearray(), iv
for i in range(0, len(ctext), 16):
next_ct_block = ctext[i:i + 16]
pt_block = repeating_key_xor(cipher.decrypt(next_ct_block),
ct_block)
ct_block = next_ct_block
ptext.extend(pt_block)
ptext = bytes(ptext)
else:
cipher = AES(key, mode="CBC", iv=iv)
ptext = cipher.decrypt(ctext)
return unpad_pkcs7_aes(ptext) if unpad else ptext
def aes_encipher_block(self, key, block):
#print('KEY',key)
key=key[0].to_bytes(4,'big')+ \
key[1].to_bytes(4,'big')+ \
key[2].to_bytes(4,'big')+ \
key[3].to_bytes(4,'big')
#print('key',binascii.hexlify(key))
if os.__name__ == 'os':
my_aes = AES.new(key, AES.MODE_ECB)
else:
my_aes = AES(key, AES.MODE_ECB)
result = my_aes.encrypt(block[0].to_bytes(4, 'big') +
block[1].to_bytes(4, 'big') +
block[2].to_bytes(4, 'big') +
block[3].to_bytes(4, 'big'))
result = (int.from_bytes(result[0:4],
'big'), int.from_bytes(result[4:8], 'big'),
int.from_bytes(result[8:12],
'big'), int.from_bytes(result[12:16], 'big'))
#print('result type',type(result))
return result
# coding=utf-8
# 这里使用pycrypto库
# easy_install pycrypto
from Crypto.Cipher import AES
from binascii import b2a_hex, a2b_hex
fchr = '\0' # fill character
"""
AES(Advanced Encryption Standard)对称加密:
对称加密就是公钥和撕咬是
1. 秘钥必须长度是16,24,32
2. 加密之前需要把文本改成16的倍数, 所以需要填充特殊字符
"""
class AEScrypt():
def __init__(self, key):
self.key = key
self.mode = AES.MODE_CBC
def _fill_text(self, text):
"""
补位:
如果text不足16位就用空格补足为16位，
如果大于16当时不是16的倍数，那就补足为16的倍数。
"""
length = 16
def create_decryptor(self, key, sequence):
if key.method != "AES-128":
raise StreamError("Unable to decrypt cipher {0}", key.method)
if not key.uri:
raise StreamError("Missing URI to decryption key")
if self.key_uri != key.uri:
zoom_key = self.reader.stream.session.options.get("zoom-key")
zuom_key = self.reader.stream.session.options.get("zuom-key")
livecam_key = self.reader.stream.session.options.get("livecam-key")
saw_key = self.reader.stream.session.options.get("saw-key")
your_key = self.reader.stream.session.options.get("your-key")
mama_key = self.reader.stream.session.options.get("mama-key")
if zoom_key:
uri = 'http://www.zoomtv.me/k.php?q='+base64.urlsafe_b64encode(zoom_key+base64.urlsafe_b64encode(key.uri))
elif zuom_key:
uri = 'http://www.zuom.xyz/k.php?q='+base64.urlsafe_b64encode(zuom_key+base64.urlsafe_b64encode(key.uri))
elif livecam_key:
h = urlparse.urlparse(urllib.unquote(livecam_key)).netloc
q = urlparse.urlparse(urllib.unquote(livecam_key)).query
uri = 'http://%s/kaes?q='%h+base64.urlsafe_b64encode(q+base64.b64encode(key.uri))
elif saw_key:
if 'foxsportsgo' in key.uri:
_tmp = key.uri.split('/')
uri = urljoin(saw_key,'/m/fream?p='+_tmp[-4]+'&k='+_tmp[-1])
elif 'nlsk.neulion' in key.uri:
_tmp = key.uri.split('?')
uri = urljoin(saw_key,'/m/stream?'+_tmp[-1])
elif 'nlsk' in key.uri:
_tmp = key.uri.split('?')
uri = 'http://bile.level303.club/m/stream?'+_tmp[-1]
elif 'nhl.com' in key.uri:
_tmp = key.uri.split('/')
uri = urljoin(saw_key,'/m/streams?ci='+_tmp[-3]+'&k='+_tmp[-1])
else:
uri = key.uri
elif mama_key:
if 'nlsk' in key.uri:
_tmp = key.uri.split('&url=')
uri = 'http://mamahd.in/nba?url=' + _tmp[-1]
elif your_key:
if 'mlb.com' in key.uri:
_tmp = key.uri.split('?')
uri = urljoin(your_key,'/mlb/get_key/'+_tmp[-1])
elif 'espn3/auth' in key.uri:
_tmp = key.uri.split('?')
uri = urljoin(your_key,'/ncaa/get_key/'+_tmp[-1])
elif 'nhl.com' in key.uri:
_tmp = key.uri.split('nhl.com/')
uri = urljoin(your_key,'/nhl/get_key/'+_tmp[-1])
else:
uri = key.uri
else:
uri = key.uri
res = self.session.http.get(uri, exception=StreamError,
**self.reader.request_params)
self.key_data = res.content
self.key_uri = key.uri
iv = key.iv or num_to_iv(sequence)
if _android_ssl:
return enc(self.key_data, iv)
elif _oscrypto:
return AES(self.key_data, iv)
else:
return AES.new(self.key_data, AES.MODE_CBC, iv)
def aes_ecb_encrypt(ptext, key):
if HAVE_CRYPTO:
cipher = AES.new(key, mode=AES.MODE_ECB)
else:
cipher = AES(key, mode="ECB")
return cipher.encrypt(pad_pkcs7(ptext))
block = xor(block, self.get_round_key(0))
return block
def aes128_reverse_keyschedule(key, round):
for i in range(round, 0, -1):
for j in range(15, 3, -1):
key[j] ^= key[j - 4]
for j in range(3, -1, -1):
key[j] ^= aes_sbox[key[12 +
(j + 1) % 4]] ^ (0 if j else aes_Rcon[i])
return key
if __name__ == '__main__':
print 'Running test...'
import Crypto.Cipher.AES
key = ''.join(map(chr, range(16)))
plain = ''.join(map(chr, range(16, 32)))
assert len(key) == len(plain) == 16
cipher = AES(key)
cipher2 = Crypto.Cipher.AES.new(key)
assert (list(cipher.encrypt(plain)) == map(ord, cipher2.encrypt(plain)))
assert (list(cipher.decrypt(plain)) == map(ord, cipher2.decrypt(plain)))
for round in range(11):
assert aes128_reverse_keyschedule(cipher.get_round_key(round),
round) == ary(key)
def new(unused_1, unused_2, unused_3):
return AES()
def new(key, mode=MODE_ECB, IV=None, counter=None, segment_size=None):
"""Create a new cipher object
key = raw string containing the key, AES-128..256 will be selected according to the key length
-> when using XTS mode: the key should be a tuple of the 2 keys needed
mode = AES.MODE_ECB/CBC/CFB/OFB/CTR/XTS/CMAC, default is ECB
IV = IV as a raw string, default is "all zero" IV
-> only needed for CBC mode
counter = counter object (CryptoPlus.Util.util.Counter)
-> only needed for CTR mode
segment_size = amount of bits to use from the keystream in each chain part
-> supported values: multiple of 8 between 8 and the blocksize
of the cipher (only per byte access possible), default is 8
-> only needed for CFB mode
EXAMPLES:
**********
IMPORTING:
-----------
>>> from CryptoPlus.Cipher import AES
ECB EXAMPLE:
-------------
NIST Special Publication 800-38A http://cryptome.org/bcm/sp800-38a.htm#F
>>> cipher = AES.new('2b7e151628aed2a6abf7158809cf4f3c'.decode('hex'))
>>> crypted = cipher.encrypt('6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51'.decode('hex'))
>>> crypted.encode('hex')
'3ad77bb40d7a3660a89ecaf32466ef97f5d3d58503b9699de785895a96fdbaaf'
>>> decipher = AES.new('2b7e151628aed2a6abf7158809cf4f3c'.decode('hex'))
>>> decipher.decrypt(crypted).encode('hex')
'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51'
CBC EXAMPLE (plaintext = 3 blocksizes):
-----------------------------------------
NIST Special Publication 800-38A http://cryptome.org/bcm/sp800-38a.htm#F
>>> key = ('2b7e151628aed2a6abf7158809cf4f3c').decode('hex')
>>> IV = ('000102030405060708090a0b0c0d0e0f').decode('hex')
>>> plaintext1 = ('6bc1bee22e409f96e93d7e117393172a').decode('hex')
>>> plaintext2 = ('ae2d8a571e03ac9c9eb76fac45af8e51').decode('hex')
>>> plaintext3 = ('30c81c46a35ce411e5fbc1191a0a52ef').decode('hex')
>>> cipher = AES.new(key,AES.MODE_CBC,IV)
>>> ciphertext = cipher.encrypt(plaintext1 + plaintext2 + plaintext3)
>>> (ciphertext).encode('hex')
'7649abac8119b246cee98e9b12e9197d5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e22229516'
>>> decipher = AES.new(key,AES.MODE_CBC,IV)
>>> plaintext = decipher.decrypt(ciphertext)
>>> (plaintext).encode('hex')
'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52ef'
OR: supply plaintext as separate pieces:
------------------------------------------
>>> cipher = AES.new(key,AES.MODE_CBC,IV)
>>> ( cipher.encrypt(plaintext1 + plaintext2[:-2]) ).encode('hex')
'7649abac8119b246cee98e9b12e9197d'
>>> ( cipher.encrypt(plaintext2[-2:] + plaintext3) ).encode('hex')
'5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e22229516'
>>> decipher = AES.new(key,AES.MODE_CBC,IV)
>>> (decipher.decrypt(ciphertext[:22])).encode('hex')
'6bc1bee22e409f96e93d7e117393172a'
>>> (decipher.decrypt(ciphertext[22:])).encode('hex')
'ae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52ef'
CTR EXAMPLE:
------------
NIST Special Publication 800-38A http://cryptome.org/bcm/sp800-38a.htm#F
>>> from CryptoPlus.Util.util import Counter
>>> key = '2b7e151628aed2a6abf7158809cf4f3c'.decode('hex')
>>> counter = Counter('f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff'.decode('hex'))
>>> cipher = AES.new(key,AES.MODE_CTR,counter=counter)
>>> plaintext1 = '6bc1bee22e409f96e93d7e117393172a'.decode('hex')
>>> plaintext2 = 'ae2d8a571e03ac9c9eb76fac45af8e51'.decode('hex')
>>> plaintext3 = '30c81c46a35ce411e5fbc1191a0a52ef'.decode('hex')
>>> ciphertext = cipher.encrypt(plaintext1 + plaintext2 + plaintext3)
>>> ciphertext.encode('hex')
'874d6191b620e3261bef6864990db6ce9806f66b7970fdff8617187bb9fffdff5ae4df3edbd5d35e5b4f09020db03eab'
>>> counter2 = Counter('f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff'.decode('hex'))
>>> decipher = AES.new(key,AES.MODE_CTR,counter=counter2)
>>> decipher.decrypt(ciphertext).encode('hex')
'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52ef'
XTS EXAMPLE:
cipher/decipher plaintext of 3 blocks, provided as a 2 pieces (31 bytes + 33 bytes)
------------
>>> key = (('2b7e151628aed2a6abf7158809cf4f3c').decode('hex'),('2b7e151628aed2a6abf7158809cf4f3c').decode('hex'))
>>> plaintext1 = ('6bc1bee22e409f96e93d7e117393172a').decode('hex')
>>> plaintext2 = ('ae2d8a571e03ac9c9eb76fac45af8e51').decode('hex')
>>> plaintext3 = ('30c81c46a35ce411e5fbc1191a0a52ef').decode('hex')
>>> cipher = AES.new(key,AES.MODE_XTS)
>>> ciphertext = cipher.encrypt(plaintext1 + plaintext2[:15])
>>> decipher = AES.new(key,AES.MODE_XTS)
>>> deciphertext = decipher.decrypt(ciphertext)
>>> (deciphertext).encode('hex')
'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e'
>>> ciphertext2 = cipher.encrypt(plaintext2[15:]+plaintext3)
>>> deciphertext2 = decipher.decrypt(ciphertext2)
>>> (deciphertext2).encode('hex')
'5130c81c46a35ce411e5fbc1191a0a52ef'
XTS-AES-128 applied for a data unit of 512 bytes
testvector: http://grouper.ieee.org/groups/1619/email/pdf00086.pdf
>>> key = ('27182818284590452353602874713526'.decode('hex'),'31415926535897932384626433832795'.decode('hex'))
>>> plaintext = '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff'.decode('hex')
>>> cipher = AES.new(key,AES.MODE_XTS)
>>> cipher.encrypt(plaintext).encode('hex')
'27a7479befa1d476489f308cd4cfa6e2a96e4bbe3208ff25287dd3819616e89cc78cf7f5e543445f8333d8fa7f56000005279fa5d8b5e4ad40e736ddb4d35412328063fd2aab53e5ea1e0a9f332500a5df9487d07a5c92cc512c8866c7e860ce93fdf166a24912b422976146ae20ce846bb7dc9ba94a767aaef20c0d61ad02655ea92dc4c4e41a8952c651d33174be51a10c421110e6d81588ede82103a252d8a750e8768defffed9122810aaeb99f9172af82b604dc4b8e51bcb08235a6f4341332e4ca60482a4ba1a03b3e65008fc5da76b70bf1690db4eae29c5f1badd03c5ccf2a55d705ddcd86d449511ceb7ec30bf12b1fa35b913f9f747a8afd1b130e94bff94effd01a91735ca1726acd0b197c4e5b03393697e126826fb6bbde8ecc1e08298516e2c9ed03ff3c1b7860f6de76d4cecd94c8119855ef5297ca67e9f3e7ff72b1e99785ca0a7e7720c5b36dc6d72cac9574c8cbbc2f801e23e56fd344b07f22154beba0f08ce8891e643ed995c94d9a69c9f1b5f499027a78572aeebd74d20cc39881c213ee770b1010e4bea718846977ae119f7a023ab58cca0ad752afe656bb3c17256a9f6e9bf19fdd5a38fc82bbe872c5539edb609ef4f79c203ebb140f2e583cb2ad15b4aa5b655016a8449277dbd477ef2c8d6c017db738b18deb4a427d1923ce3ff262735779a418f20a282df920147beabe421ee5319d0568'
CMAC EXAMPLE:
-------------
NIST publication 800-38B: http://csrc.nist.gov/publications/nistpubs/800-38B/Updated_CMAC_Examples.pdf
>>> key = '2b7e151628aed2a6abf7158809cf4f3c'.decode('hex')
>>> plaintext = '6bc1bee22e409f96e93d7e117393172a'.decode('hex')
>>> cipher = AES.new(key,AES.MODE_CMAC)
>>> cipher.encrypt(plaintext).encode('hex')
'070a16b46b4d4144f79bdd9dd04a287c'
CMAC EXAMPLE2:
--------------
>>> key = '2b7e151628aed2a6abf7158809cf4f3c'.decode('hex')
>>> plaintext = '6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411'.decode('hex')
>>> cipher = AES.new(key,AES.MODE_CMAC)
>>> cipher.encrypt(plaintext).encode('hex')
'dfa66747de9ae63030ca32611497c827'
"""
return AES(key, mode, IV, counter, segment_size)
