Python源码示例：Crypto.Cipher.AES.MODE_ECB
示例1
def decrypt(self, data):
key = self.session.get_session_key()
method = self.settings.get("pia.encryption_method")
if method == EncryptionMethod.AES_ECB:
aes = AES.new(key, AES.MODE_ECB)
return aes.decrypt(data)
else:
nonce = self.session.generate_nonce(self)
aes = AES.new(key, AES.MODE_GCM, nonce=nonce)
try:
data = aes.decrypt_and_verify(data, self.signature)
except ValueError:
logger.warning("Received incorrect AES-GCM tag")
return None
return data
示例2
def decrypt_lsa_key_nt6(lsakey, syskey):
"""
This function decrypts the LSA keys using the syskey
"""
dg = hashlib.sha256()
dg.update(syskey)
for i in xrange(1000):
dg.update(lsakey[28:60])
keys = AES.new(dg.digest(), AES.MODE_ECB).decrypt(lsakey[60:])
size = struct.unpack_from("<L", keys)[0]
keys = keys[16:16 + size]
currentkey = "%0x-%0x-%0x-%0x%0x-%0x%0x%0x%0x%0x%0x" % struct.unpack("<L2H8B", keys[4:20])
nb = struct.unpack("<L", keys[24:28])[0]
off = 28
kd = {}
for i in xrange(nb):
g = "%0x-%0x-%0x-%0x%0x-%0x%0x%0x%0x%0x%0x" % struct.unpack("<L2H8B", keys[off:off + 16])
t, l = struct.unpack_from("<2L", keys[off + 16:])
k = keys[off + 24:off + 24 + l]
kd[g] = {"type": t, "key": k}
off += 24 + l
return (currentkey, kd)
示例3
def decrypt_lsa_secret(secret, lsa_keys):
"""
This function replaces SystemFunction005 for newer Windows
"""
keyid = "%0x-%0x-%0x-%0x%0x-%0x%0x%0x%0x%0x%0x" % struct.unpack("<L2H8B", secret[4:20])
if keyid not in lsa_keys:
return None
algo = struct.unpack("<L", secret[20:24])[0]
dg = hashlib.sha256()
dg.update(lsa_keys[keyid]["key"])
for i in xrange(1000):
dg.update(secret[28:60])
clear = AES.new(dg.digest(), AES.MODE_ECB).decrypt(secret[60:])
size = struct.unpack_from("<L", clear)[0]
return clear[16:16 + size]
示例4
def encryption_oracle_aes(payload):
global constant, prefix_len, suffix_len, secret
if secret:
if constant:
payload = random_bytes(prefix_len) + payload + secret
else:
payload = random_bytes(random.randint(1, 50)) + payload + secret
else:
if constant:
payload = random_bytes(prefix_len) + payload + random_bytes(suffix_len)
else:
payload = random_bytes(random.randint(1, 50)) + payload + random_bytes(random.randint(1, 50))
payload = add_padding(payload, AES.block_size)
cipher = AES.new(key_AES, AES.MODE_ECB)
return cipher.encrypt(payload)
示例5
def encryption_oracle_des(payload):
global constant, prefix_len, suffix_len, secret
if secret:
if constant:
payload = random_bytes(prefix_len) + payload + secret
else:
payload = random_bytes(random.randint(1, 50)) + payload + secret
else:
if constant:
payload = random_bytes(prefix_len) + payload + random_bytes(suffix_len)
else:
payload = random_bytes(random.randint(1, 50)) + payload + random_bytes(random.randint(1, 50))
payload = add_padding(payload, DES3.block_size)
cipher = DES3.new(key_DES3, DES3.MODE_ECB)
return cipher.encrypt(payload)
示例6
def change_key(self, master_key):
if master_key >= (1 << 128):
raise InvalidInputException('Master key should be 128-bit')
self.__master_key = long_to_bytes(master_key, 16)
self.__aes_ecb = AES.new(self.__master_key, AES.MODE_ECB)
self.__auth_key = bytes_to_long(self.__aes_ecb.encrypt(b'\x00' * 16))
# precompute the table for multiplication in finite field
table = [] # for 8-bit
for i in range(16):
row = []
for j in range(256):
row.append(self.gf_2_128_mul(self.__auth_key, j << (8 * i)))
table.append(tuple(row))
self.__pre_table = tuple(table)
self.prev_init_value = None # reset
示例7
def main():
with open(F,'r') as f:
b64 = f.read()
enc = tools.fromB64(b64)
encBlocks = tools.split(enc, 16, False)
iv = IV
result = b''
cipher=AES.new(KEY, AES.MODE_ECB)
for block in encBlocks:
decBlock = cipher.decrypt(block)
dec = crypto.xor(decBlock, iv)
iv = block
result += dec
print(tools.toStr(tools.stripPadding(result)))
示例8
def __init__(self, key):
super().__init__(AES.new(key, AES.MODE_ECB))
示例9
def _aes_decrypt(aes_key, aes_text) -> Text:
"""
使用密钥解密文本信息，将会自动填充空白字符
:param aes_key: 解密密钥
:param aes_text: 需要解密的文本
:return: 经过解密的数据
"""
# 初始化解码器
cipher = AES.new(_fill_16(aes_key), AES.MODE_ECB)
# 优先逆向解密十六进制为bytes
converted = a2b_base64(aes_text.replace('-', '/').replace("%3D", "=").encode())
# 使用aes解密密文
decrypt_text = str(cipher.decrypt(converted), encoding='utf-8').replace('\0', '')
# 返回执行结果
return decrypt_text.strip()
示例10
def _aes_encrypt(aes_key, aes_text) -> Text:
"""
使用密钥加密文本信息，将会自动填充空白字符
:param aes_key: 加密密钥
:param aes_text: 需要加密的文本
:return: 经过加密的数据
"""
# 初始化加密器
cipher = AES.new(_fill_16(aes_key), AES.MODE_ECB)
# 先进行aes加密
aes_encrypted = cipher.encrypt(_fill_16(aes_text))
# 使用十六进制转成字符串形式
encrypt_text = b2a_base64(aes_encrypted).decode().replace('/', '-').strip()
# 返回执行结果
return encrypt_text
示例11
def decrypt(self, hex):
encoded = binascii.unhexlify(hex)
secret = self.get_secret()
BLOCK_SIZE = 16
mode = AES.MODE_ECB
cipher = AES.new(secret, mode)
return cipher.decrypt(encoded).split('\x00')[0]
示例12
def aes(self):
return AES.new(self.key, AES.MODE_ECB) # 初始化加密器
示例13
def GetDeviceKey(self):
_LOGGER.info('Retrieving HVAC encryption key')
GENERIC_GREE_DEVICE_KEY = "a3K8Bx%2r8Y7#xDh"
cipher = AES.new(GENERIC_GREE_DEVICE_KEY.encode("utf8"), AES.MODE_ECB)
pack = base64.b64encode(cipher.encrypt(self.Pad('{"mac":"' + str(self._mac_addr) + '","t":"bind","uid":0}').encode("utf8"))).decode('utf-8')
jsonPayloadToSend = '{"cid": "app","i": 1,"pack": "' + pack + '","t":"pack","tcid":"' + str(self._mac_addr) + '","uid": 0}'
return self.FetchResult(cipher, self._ip_addr, self._port, self._timeout, jsonPayloadToSend)['key']
示例14
def aes_unwrap_key_and_iv(kek, wrapped):
n = len(wrapped)//8 - 1
#NOTE: R[0] is never accessed, left in for consistency with RFC indices
R = [None]+[wrapped[i*8:i*8+8] for i in range(1, n+1)]
A = QUAD.unpack(wrapped[:8])[0]
decrypt = AES.new(kek, AES.MODE_ECB).decrypt
for j in range(5,-1,-1): #counting down
for i in range(n, 0, -1): #(n, n-1, ..., 1)
ciphertext = QUAD.pack(A^(n*j+i)) + R[i]
B = decrypt(ciphertext)
A = QUAD.unpack(B[:8])[0]
R[i] = B[8:]
return b"".join(R[1:]), A
示例15
def aes_unwrap_key_withpad(kek, wrapped):
'''
alternate initial value for aes key wrapping, as defined in RFC 5649 section 3
http://www.ietf.org/rfc/rfc5649.txt
'''
if len(wrapped) == 16:
plaintext = AES.new(kek, AES.MODE_ECB).decrypt(wrapped)
key, key_iv = plaintext[:8], plaintext[8:]
else:
key, key_iv = aes_unwrap_key_and_iv(kek, wrapped)
key_iv = "{0:016X}".format(key_iv)
if key_iv[:8] != "A65959A6":
raise ValueError("Integrity Check Failed: "+key_iv[:8]+" (expected A65959A6)")
key_len = int(key_iv[8:], 16)
return key[:key_len]
示例16
def aes_wrap_key(kek, plaintext, iv=0xa6a6a6a6a6a6a6a6):
n = len(plaintext)//8
R = [None]+[plaintext[i*8:i*8+8] for i in range(0, n)]
A = iv
encrypt = AES.new(kek, AES.MODE_ECB).encrypt
for j in range(6):
for i in range(1, n+1):
B = encrypt(QUAD.pack(A) + R[i])
A = QUAD.unpack(B[:8])[0] ^ (n*j + i)
R[i] = B[8:]
return QUAD.pack(A) + b"".join(R[1:])
示例17
def aes_wrap_key_withpad(kek, plaintext):
iv = 0xA65959A600000000 + len(plaintext)
plaintext = plaintext + b"\0" * ((8 - len(plaintext)) % 8)
if len(plaintext) == 8:
return AES.new(kek, AES.MODE_ECB).encrypt(QUAD.pack[iv] + plaintext)
return aes_wrap_key(kek, plaintext, iv)
示例18
def encrypt():
cipher = AES.new(base64.b16decode(key, casefold=True), AES.MODE_ECB)
return base64.b16encode(cipher.encrypt(flag))
# flush output immediately
示例19
def encrypt_string(self, string_to_encrypt: str) -> str:
# This is needed to remove the escaping added by Python. For example, if we find in smali the instruction
# const-string v0, "\"message\"" Android will treat it as "message" while in Python it's \"message\",
# so we need to encrypt "message" and not \"message\" (we have to remove the unnecessary escaping, otherwise
# the backslashes would by encrypted as part of the string).
string_to_encrypt = string_to_encrypt.encode(errors='replace').decode('unicode_escape')
key = PBKDF2(password=self.encryption_secret, salt=self.encryption_secret.encode(), dkLen=32, count=128)
encrypted_string = hexlify(AES.new(key=key, mode=AES.MODE_ECB)
.encrypt(pad(string_to_encrypt.encode(errors='replace'), AES.block_size))).decode()
return encrypted_string
示例20
def encrypt_string(self, string_to_encrypt: str) -> str:
# This is needed to remove the escaping added by Python. For example, if we find in string resources
# the string "\"message\"" Android will treat it as "message" while in Python it's \"message\", so we
# need to encrypt "message" and not \"message\" (we have to remove the unnecessary escaping, otherwise
# the backslashes would by encrypted as part of the string).
string_to_encrypt = string_to_encrypt.encode(errors='replace').decode('unicode_escape')
key = PBKDF2(password=self.encryption_secret, salt=self.encryption_secret.encode(), dkLen=32, count=128)
encrypted_string = hexlify(AES.new(key=key, mode=AES.MODE_ECB)
.encrypt(pad(string_to_encrypt.encode(errors='replace'), AES.block_size))).decode()
return encrypted_string
示例21
def basic_decrypt(cls, key, ciphertext):
assert len(ciphertext) >= 16
aes = AES.new(key.contents, AES.MODE_ECB)
if len(ciphertext) == 16:
return aes.decrypt(ciphertext)
# Split the ciphertext into blocks. The last block may be partial.
cblocks = [ciphertext[p:p+16] for p in xrange(0, len(ciphertext), 16)]
lastlen = len(cblocks[-1])
# CBC-decrypt all but the last two blocks.
prev_cblock = '\0' * 16
plaintext = ''
for b in cblocks[:-2]:
plaintext += _xorbytes(aes.decrypt(b), prev_cblock)
prev_cblock = b
# Decrypt the second-to-last cipher block. The left side of
# the decrypted block will be the final block of plaintext
# xor'd with the final partial cipher block; the right side
# will be the omitted bytes of ciphertext from the final
# block.
b = aes.decrypt(cblocks[-2])
lastplaintext =_xorbytes(b[:lastlen], cblocks[-1])
omitted = b[lastlen:]
# Decrypt the final cipher block plus the omitted bytes to get
# the second-to-last plaintext block.
plaintext += _xorbytes(aes.decrypt(cblocks[-1] + omitted), prev_cblock)
return plaintext + lastplaintext
示例22
def decryptData(key, encryptedData):
"""Decrypts the apk data using the specified AES key"""
aes = AES.new(key, AES.MODE_ECB)
return b''.join(util.unpad(aes.decrypt(c)) for c in util.chunk(encryptedData, constants.blockSize + constants.paddingSize))
示例23
def encryptData(key, data):
"""Encrypts the apk data using the specified AES key"""
aes = AES.new(key, AES.MODE_ECB)
return b''.join(aes.encrypt(util.pad(c, constants.paddingSize)) for c in util.chunk(data, constants.blockSize))
示例24
def encode_password(password):
passw = password.rjust(32)
cipher = AES.new(secret_key, AES.MODE_ECB)
return base64.b64encode(cipher.encrypt(passw)).decode("utf-8")
示例25
def decode_password(encoded_password):
cipher = AES.new(secret_key, AES.MODE_ECB)
return cipher.decrypt(base64.b64decode(encoded_password)).strip()
示例26
def __init__(self, key, version="3.1"):
self.key = key
try:
self.version = version.encode()
except:
print("This is it {}".format(version))
self.version = version
self.cipher = AES.new(self.key, AES.MODE_ECB)
示例27
def aes_decrypt_block(block, key):
cipher = AES.new(key, AES.MODE_ECB)
return cipher.decrypt(block)
示例28
def aes_encrypt_block(block, key):
cipher = AES.new(key, AES.MODE_ECB)
return cipher.encrypt(block)
示例29
def gunbound_dynamic_decrypt_raw(blocks, username, password, auth_token):
key = get_dynamic_key(username, password, auth_token)
cipher = AES.new(key, AES.MODE_ECB)
plain_unprocessed_bytes = cipher.decrypt(blocks)
return plain_unprocessed_bytes
示例30
def gunbound_dynamic_encrypt_raw(plain_bytes, username, password, auth_token):
key = get_dynamic_key(username, password, auth_token)
cipher = AES.new(key, AES.MODE_ECB)
encrypted_bytes = cipher.encrypt(plain_bytes)
return encrypted_bytes
