def rsa_processing(data, p_value, q_value, e_value, encrypt):
open_mix = p_value * q_value
d_value = get_closed_key(p_value, q_value, e_value)
encrypt_block_size = int(math.log2(open_mix))
decrypt_block_size = math.ceil(math.log2(open_mix))
byte_buf = math.ceil(decrypt_block_size / 8)
data_block_size, res_block_size = get_block_sizes(
encrypt, encrypt_block_size, decrypt_block_size
)
key = e_value if encrypt == "encrypt" else d_value
crypto_tools.supl_to_mult(data, data_block_size)
result = bitarray()
for i in range(0, len(data), data_block_size):
block_val = crypto_tools.get_block_as_int(
i, data_block_size, byte_buf, data
)
crypto_tools.cterm(
"output", f"Block {int(i / data_block_size)}: {block_val}", "inf"
)
res_val = (pow(block_val, key) % open_mix).to_bytes(byte_buf, "big")
block = crypto_tools.to_bitarray(res_val)
result += block[-res_block_size:]
if encrypt == "decrypt":
if len(result) % 8:
result = result[:-(len(result) % 8)]
result = bytes(result)
return result if encrypt == "encrypt" else result.decode()
def openssl_aes_128_pre_processing(key, iv):
if len(key) > 16:
raise ValueError(f"Too big key. Max len required: 16")
else:
crypto_tools.supl_to_mult(key, 16)
if len(iv) > 16:
raise ValueError(
f"Too big initialization vector. Max len required: 16")
else:
crypto_tools.supl_to_mult(iv, 16)
def magma_pre_processing(data, key, key_len):
if data.__class__ == str:
data = bytearray(data.encode())
if key.__class__ == str:
key = bytearray(key.encode())
if len(key) > key_len:
raise ValueError(f"Too big key. Max len required: {key_len}")
else:
crypto_tools.supl_to_mult(key, key_len)
return data, key
def ansi_x9_17_pre_processing(key, buffer_v0):
if len(key) > 7 * 2:
raise ValueError(f"Too big key. Max len required: {7 * 2}")
crypto_tools.supl_to_mult(key, 7 * 2)
if len(buffer_v0) > 8:
raise ValueError(f"Too big key. Max len required: {7 * 2}")
crypto_tools.supl_to_mult(buffer_v0, 8)
return key + key[:7]
def block_pre_processing(data, key, block_size, rounds):
if data.__class__ == str:
data = bytearray(data.encode())
if key.__class__ == str:
key = bytearray(key.encode())
if len(key) > (block_size * rounds):
raise ValueError("Too big key. Max len required: block_size * rounds")
crypto_tools.supl_to_mult(key, block_size * rounds)
return data, key
def lfsr_processing(data, register_size, exec_xor_pos, start_state):
tick = lfsr_init(register_size, exec_xor_pos, start_state)
crypto_tools.supl_to_mult(data, register_size)
result = bytearray()
for byte in data:
random_number = next(tick)
random_number = int.from_bytes(random_number,
byteorder='big',
signed=False)
result.append(byte ^ random_number)
return result
def hash_processing(data, res_size):
if data.__class__ == str:
data = bytearray(data, "utf-8")
result = bytearray(res_size)
crypto_tools.supl_to_mult(data, len(result))
dib_iter = 0
while dib_iter < len(data):
for res_iter in range(len(result)):
result[res_iter] ^= data[dib_iter]
dib_iter += 1
integer = int.from_bytes(result, byteorder="big")
integer = smart_shift(integer, len(result) * 8)
result = bytearray(
integer.to_bytes(res_size + 1, byteorder="big")[1:res_size + 1])
return result
def magma_processing(data, key, encrypt, mode):
block_size = 8
rounds = 32
key_len = 32
data, key = magma_pre_processing(data, key, key_len)
res_data = None
if mode == "xor":
synchro_package = lfsr_generator_processing(2, [3, 5, 6, 7, 9, 14],
[2, 4, 5, 7], ceil(len(data) / block_size) * block_size)
crypto_tools.supl_to_mult(data, block_size)
synchro_package_stage_1 = crypto_tools.block_cypher(synchro_package, block_size, "encrypt", rounds,
False, xor_processing, magma_secret_func, key)
synchro_package_stage_2 = bytearray()
for block_id in range(len(synchro_package_stage_1) // 8):
first_start = block_id * 8
second_start = first_start + block_size // 2
first_part = synchro_package_stage_1[first_start:first_start + block_size // 2]
second_part = synchro_package_stage_1[second_start:second_start + block_size // 2]
const_0 = 0x1010101
const_1 = 0x1010104
first_part = (int.from_bytes(first_part, byteorder="big") + const_0) % pow(2, 32)
second_part = (int.from_bytes(second_part, byteorder="big") + const_1 - 1) % pow(2, 32 - 1) + 1
synchro_package_stage_2 += first_part.to_bytes(4, 'big') + second_part.to_bytes(4, 'big')
synchro_package_stage_3 = crypto_tools.block_cypher(synchro_package_stage_2, block_size, "encrypt", rounds,
False, xor_processing, magma_secret_func, key)
res_data = xor_processing(data, synchro_package_stage_3, "encrypt")
else:
res_data = crypto_tools.block_cypher(data, block_size, encrypt, rounds,
False, xor_processing, magma_secret_func, key)
return res_data
def cryptoapi_aes_pre_processing(key, key_length):
if len(key) > key_length // 8:
raise ValueError(f"Too big key. Max len required: {key_length // 8}")
crypto_tools.supl_to_mult(key, key_length // 8)
def triple_des_pre_processing(key):
if len(key) > 7 * 3:
raise ValueError(f"Too big key. Max len required: {7 * 3}")
else:
crypto_tools.supl_to_mult(key, 7 * 3)
def des_pre_processing(key):
if len(key) > 7:
raise ValueError("Too big key. Max len required: 7")
crypto_tools.supl_to_mult(key, 7)
