def _mac_finalize(self):
padding = get_omac_pad(self.__previous_block, block_size)
null_vector = bytes([0]) * 16
l = aes_block_encrypt(self.__key, null_vector)
if first_bit(l) == 0: #нужно ли в bytearray?
k_1 = shift_one_left(l)
else:
k_1 = xor_two_arr(shift_one_left(l), const_omac())
if padding is None:
final = aes_block_encrypt(
self.__key,
xor_two_arr(
xor_two_arr(self.__help_encrypt_block,
self.__previous_block), k_1))
self.__num_of_get_blocks = 0
return final
elif padding is not None:
if first_bit(k_1) == 0:
k_2 = shift_one_left(k_1)
else:
k_2 = xor_two_arr(shift_one_left(k_1), const_omac())
self.__previous_block = arr_concat_pad(self.__previous_block,
padding)
final = aes_block_encrypt(
self.__key,
xor_two_arr(
xor_two_arr(self.__help_encrypt_block,
self.__previous_block), k_2))
self.__num_of_get_blocks = 0
return final
def ctr_encrypt(key, data, iv):
num_of_get_blocks = 0
if iv is None:
nonce = os.urandom(4)
iv = init_vec_ctr(nonce, 0, num_of_get_blocks)
encrypt_arr = bytearray()
start = 0
last = 16
is_final_block = False
num_of_blocks = how_many_blocks(data)
encrypt_arr.extend(bytearray(iv))
while num_of_get_blocks != num_of_blocks:
if num_of_get_blocks == num_of_blocks - 1:
is_final_block = True
if is_final_block is False:
encrypt_arr.extend(
bytearray(
xor_two_arr(
data[start:last],
aes_block_encrypt(key, iv, is_final_block, None))))
num_of_get_blocks += 1
start += 16
last += 16
iv = iv[0:12] + (int_to_bytes_4(bytes_to_int(iv[12:16]) + 1))
if is_final_block is True:
encrypt_arr.extend(
bytearray(
xor_two_arr(
data[start:],
aes_block_encrypt(key, iv, is_final_block, None))))
num_of_get_blocks += 1
return encrypt_arr
def ctr_decrypt(key, data, iv):
if iv is None:
iv = data[0:16]
data = data[16:]
num_of_get_blocks = 0
decrypt_arr = bytearray()
start = 0
last = 16
is_final_block = False
num_of_blocks = how_many_blocks(data)
while num_of_get_blocks != num_of_blocks:
if num_of_get_blocks == num_of_blocks - 1:
is_final_block = True
if is_final_block is False:
decrypt_arr.extend(
bytearray(
xor_two_arr(
data[start:last],
aes_block_encrypt(key, iv, is_final_block, None))))
num_of_get_blocks += 1
start += 16
last += 16
iv = iv[0:12] + (int_to_bytes_4(bytes_to_int(iv[12:16]) + 1))
if is_final_block is True:
decrypt_arr.extend(
bytearray(
xor_two_arr(
data[start:],
aes_block_encrypt(key, iv, is_final_block, None))))
num_of_get_blocks += 1
return decrypt_arr
def cbc_encrypt(key, data, iv):
encrypt_arr = bytearray()
if iv is None:
iv = os.urandom(16)
num_of_get_blocks = 0
start = 0
last = 16
is_final_block = False
num_of_blocks = how_many_blocks(data)
encrypt_arr.extend(bytearray(iv))
if num_of_blocks == 1:
is_final_block = True
padding = get_pad_pkcs_7(data, block_size)
data = arr_pad(data, padding)
data = xor_two_arr(data, iv)
padding = get_pad_pkcs_7(data, block_size)
encrypt_arr.extend(
bytearray(aes_block_encrypt(key, data, is_final_block, padding)))
else:
padding = None
help_arr = aes_block_encrypt(key, xor_two_arr(data[start:last], iv),
is_final_block, padding)
encrypt_arr.extend(bytearray(help_arr))
num_of_get_blocks += 1
start += 16
last += 16
while num_of_get_blocks != num_of_blocks:
if num_of_get_blocks == num_of_blocks - 1:
is_final_block = True
if is_final_block is False:
padding = None
help_arr = aes_block_encrypt(
key, xor_two_arr(help_arr, data[start:last]),
is_final_block, padding)
encrypt_arr.extend(bytearray(help_arr))
num_of_get_blocks += 1
start += 16
last += 16
if is_final_block is True:
padding = get_pad_pkcs_7(data[start:], block_size)
help_arr = aes_block_encrypt(
key, xor_two_arr(help_arr, arr_pad(data[start:], padding)),
is_final_block, None)
encrypt_arr.extend(bytearray(help_arr))
num_of_get_blocks += 1
return encrypt_arr
def cfb_decrypt(key, data, iv):
if iv is None:
iv = data[0:16]
data = data[16:]
decrypt_arr = bytearray()
num_of_get_blocks = 0
start = 0
last = 16
is_final_block = False
num_of_blocks = how_many_blocks(data)
if num_of_blocks == 1:
help_arr = xor_two_arr(
data[start:], aes_block_encrypt(key, iv, is_final_block, None))
decrypt_arr.extend(bytearray(help_arr))
else:
help_arr = data[start:last]
decrypt_arr.extend(
bytearray(
xor_two_arr(help_arr,
aes_block_encrypt(key, iv, is_final_block, None))))
num_of_get_blocks += 1
start += 16
last += 16
while num_of_get_blocks != num_of_blocks:
if num_of_get_blocks == num_of_blocks - 1:
is_final_block = True
if is_final_block is False:
decrypt_arr.extend(
bytearray(
xor_two_arr(
data[start:last],
aes_block_encrypt(key, help_arr, is_final_block,
None))))
help_arr = data[start:last]
num_of_get_blocks += 1
start += 16
last += 16
if is_final_block is True:
decrypt_arr.extend(
bytearray(
xor_two_arr(
data[start:],
aes_block_encrypt(key, help_arr, is_final_block,
None))))
num_of_get_blocks += 1
return decrypt_arr
def _mac_add_block(self, data_block):
if self.__num_of_get_blocks == 0:
self.__previous_block = data_block
self.__num_of_get_blocks += 1
elif self.__num_of_get_blocks == 1:
self.__help_encrypt_block = aes_block_encrypt(
self.__key, self.__previous_block)
self.__previous_block = data_block
self.__num_of_get_blocks += 1
else:
self.__help_encrypt_block = aes_block_encrypt(
self.__key,
xor_two_arr(self.__previous_block, self.__help_encrypt_block))
self.__previous_block = data_block
self.__num_of_get_blocks += 1
def _add_block(self, data_block, iv, is_final_block, get_hmac):
if self.__is_encrypt_arr is True:
self.__Hmac_encrypt.update(
xor_two_arr(data_block, aes_block_encrypt(self.__key, iv)))
return xor_two_arr(data_block, aes_block_encrypt(self.__key, iv))
elif self.__is_encrypt_arr is False:
if is_final_block is False:
self.__Hmac_decrypt.update(data_block)
return xor_two_arr(data_block,
aes_block_encrypt(self.__key, iv))
else:
self.__Hmac_decrypt.update(data_block)
if self.__Hmac_decrypt.digest() == get_hmac:
return xor_two_arr(data_block,
aes_block_encrypt(self.__key, iv))
else:
return None
def cfb_encrypt(key, data, iv):
if iv is None:
iv = os.urandom(16)
encrypt_arr = bytearray()
num_of_get_blocks = 0
start = 0
last = 16
is_final_block = False
num_of_blocks = how_many_blocks(data)
encrypt_arr.extend(bytearray(iv))
if num_of_blocks == 1:
help_arr = aes_block_encrypt(key, iv, is_final_block, None)
encrypt_arr.extend(bytearray(xor_two_arr(data[start:], help_arr)))
else:
help_arr = xor_two_arr(
data[start:last], aes_block_encrypt(key, iv, is_final_block, None))
encrypt_arr.extend(bytearray(help_arr))
num_of_get_blocks += 1
start += 16
last += 16
while num_of_get_blocks != num_of_blocks:
if num_of_get_blocks == num_of_blocks - 1:
is_final_block = True
if is_final_block is False:
help_arr = xor_two_arr(
data[start:last],
aes_block_encrypt(key, help_arr, is_final_block, None))
encrypt_arr.extend(bytearray(help_arr))
num_of_get_blocks += 1
start += 16
last += 16
if is_final_block is True:
help_arr = xor_two_arr(
data[start:],
aes_block_encrypt(key, help_arr, is_final_block, None))
encrypt_arr.extend(bytearray(help_arr))
num_of_get_blocks += 1
return encrypt_arr
def ecb_decrypt(key, data, iv=None):
encrypt_arr = bytearray()
num_of_blocks = how_many_blocks(data)
num_of_get_blocks = 0
start = 0
last = 16
is_final_block = False
while num_of_get_blocks != num_of_blocks:
if num_of_get_blocks == num_of_blocks - 1:
is_final_block = True
if is_final_block is False:
padding = None
encrypt_arr.extend(bytearray(aes_block_encrypt(key, data[start:last], is_final_block, padding)))
num_of_get_blocks += 1
start += 16
last += 16
if is_final_block is True:
padding = get_pad_pkcs_7(data[start:], block_size)
encrypt_arr.extend(bytearray(aes_block_encrypt(key, data[start:], is_final_block, padding)))
num_of_get_blocks += 1
return encrypt_arr
def _mac_add_block(self, data_block):
self.__help_encrypt_block = aes_block_encrypt(
self.__key, xor_two_arr(self.__help_encrypt_block, data_block))
