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)