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 lfsr_tick():
register_size = yield
start_state = yield
exec_xor_pos = yield
register = crypto_tools.to_bitarray(bytes(register_size))
for pos in start_state:
register[pos] = 1
while True:
random_number = bitarray()
for i in range(8):
updated_bit = 0
for pos in exec_xor_pos:
updated_bit ^= register[pos]
random_number.append(register[0])
for j in range(register_size * 8 - 1):
register[j] = register[j + 1]
register[register_size * 8 - 1] = updated_bit
yield random_number
def key_extension(key):
key_in_bits = crypto_tools.to_bitarray(bytes(key))
extended_key = bitarray()
for idx in range(0, len(key_in_bits), 7):
part = key_in_bits[idx:idx + 7]
if part.count("1") % 2 == 0:
part += bitarray('1')
else:
part += bitarray('0')
extended_key += part
key_mutation_table = [
57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4
]
extended_key = crypto_tools.permutation_by_table(
key_mutation_table, extended_key, len(extended_key)
)
return bytes(extended_key)
def rsa(data):
data = crypto_tools.to_bitarray(data)
p_value = int(crypto_tools.cterm('input',
'Enter first(p) number: ', 'ans'))
q_value = int(crypto_tools.cterm('input',
'Enter second(q) number: ', 'ans'))
e_value = int(crypto_tools.cterm('input',
'Enter open(e) number: ', 'ans'))
encrypt = crypto_tools.cterm('input',
'You want encrypt or decrypt: ', 'ans')
if encrypt != "encrypt" and encrypt != "decrypt":
raise ValueError(f"Incorrect action {encrypt}")
return rsa_processing(data, p_value, q_value, e_value, encrypt)
def magma_secret_func(val, now_round, block_size, key):
sub_key_table = [ 0, 1, 2, 3, 4, 5, 6, 7,
0, 1, 2, 3, 4, 5, 6, 7,
0, 1, 2, 3, 4, 5, 6, 7,
7, 6, 5, 4, 3, 2, 1, 0 ]
T_table = [
[ 1, 7, 14, 13, 0, 5, 8, 3, 4, 15, 10, 6, 9, 12, 11, 2 ],
[ 8, 14, 2, 5, 6, 9, 1, 12, 15, 4, 11, 0, 13, 10, 3, 7 ],
[ 5, 13, 15, 6, 9, 2, 12, 10, 11, 7, 8, 1, 4, 3, 14, 0 ],
[ 7, 15, 5, 10, 8, 1, 6, 13, 0, 9, 3, 14, 11, 4, 2, 12 ],
[ 12, 8, 2, 1, 13, 4, 15, 6, 7, 0, 10, 5, 3, 14, 9, 11 ],
[ 11, 3, 5, 8, 2, 15, 10, 13, 14, 1, 7, 4, 12, 9, 6, 0 ],
[ 6, 8, 2, 3, 9, 10, 5, 12, 1, 14, 4, 7, 11, 13, 0, 15 ],
[ 12, 4, 6, 2, 10, 5, 11, 9, 14, 8, 13, 7, 0, 3, 15, 1 ]
]
sub_key = key[sub_key_table[now_round]:sub_key_table[now_round] + 4: 1]
stage_1 = (int.from_bytes(val, byteorder="big") + int.from_bytes(sub_key, byteorder="big")) % 32
stage_2 = bitarray()
for part_id in range(4):
first_part_byte = T_table[part_id * 2][stage_1 & 0xF0 >> 4]
sec_part_byte = T_table[part_id * 2 + 1][stage_1 & 0x0F]
first_part_byte = crypto_tools.to_bitarray(first_part_byte.to_bytes(1, 'big'))[4:8]
sec_part_byte = crypto_tools.to_bitarray(sec_part_byte.to_bytes(1, 'big'))[4:8]
stage_2 += first_part_byte + sec_part_byte
temp = stage_2[0:11]
stage_3 = stage_2[11:32]
stage_3.append(temp)
return bytes(stage_3)
def rsa_hijack_repeat(data, open_mix, e_value):
data = crypto_tools.to_bitarray(data)
crypto_tools.cterm("output", f"Hijacking using repeat cypher method",
"inf")
data_block_size = math.ceil(math.log2(open_mix))
res_block_size = int(math.log2(open_mix))
byte_buf = math.ceil(data_block_size / 8)
block_val = crypto_tools.get_block_as_int(0, data_block_size, byte_buf,
data)
m_value = 1
repeat_block = (block_val**e_value**m_value) % open_mix
while (repeat_block != block_val % open_mix):
m_value += 1
repeat_block = (block_val**e_value**m_value) % open_mix
res_val = ((block_val**e_value**(m_value - 1)) % open_mix)
return res_val
def rsa_hijack_fermat(data, open_mix, e_value):
data = crypto_tools.to_bitarray(data)
crypto_tools.cterm("output", f"Hijacking using Fermat method", "inf")
check_params(open_mix, e_value)
k_value = 1
a = int(math.sqrt(open_mix))
b = a**2 - open_mix
while (not crypto_tools.is_perfect_square(b)):
a += 1
b = a**2 - open_mix
p_value = a + int(math.sqrt(b))
q_value = a - int(math.sqrt(b))
crypto_tools.cterm("output", f"P:Q = {p_value}:{q_value}", "inf")
return algo.rsa.processor(data, p_value, q_value, e_value, "decrypt")
def s_table_permutation(xor_with_key):
s_table = [
[
[ 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 ],
[ 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8 ],
[ 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0 ],
[ 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 ]
],
[
[ 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 ],
[ 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5 ],
[ 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15 ],
[ 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 ]
],
[
[ 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 ],
[ 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1 ],
[ 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7 ],
[ 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 ]
],
[
[ 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 ],
[ 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9 ],
[ 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4 ],
[ 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 ]
],
[
[ 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 ],
[ 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6 ],
[ 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14 ],
[ 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 ]
],
[
[ 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 ],
[ 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8 ],
[ 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6 ],
[ 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 ]
],
[
[ 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 ],
[ 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6 ],
[ 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2 ],
[ 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 ]
],
[
[ 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 ],
[ 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2 ],
[ 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8 ],
[ 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 ]
]
]
after_s = bitarray()
xor_with_key_bit = crypto_tools.to_bitarray(bytes(xor_with_key))
for i in range(0, len(xor_with_key_bit), 6):
xwk_part = xor_with_key_bit[i:i + 6]
val_a = bitarray([xwk_part[0], xwk_part[-1]])
val_b = xwk_part[1:5]
res_part = crypto_tools.to_bitarray(
(
s_table[i // 6][int(val_a.to01(), 2)][int(val_b.to01(), 2)]
).to_bytes(1, byteorder='big')
)[4:]
after_s += res_part
return bytes(after_s)