def rsa_hijack_chinese(data, open_mix, e_value):
data = int(crypto_tools.utf_decoder(data))
crypto_tools.cterm("output", f"Hijacking using chinese reminder method",
"inf")
tx_data = [data]
open_mixes = [open_mix]
for i in range(2, e_value + 1):
tx_data.append(int(crypto_tools.utf_decoder(crypto_tools.get_data())))
open_mixes.append(
int(
crypto_tools.cterm('input', f'Enter {i} open(p * q) number: ',
'ans')))
result = 0
m_value = 1
for i in range(e_value):
temp_m = 1
m_value *= open_mixes[i]
for j in range(1, e_value):
temp_m *= open_mixes[(i + j) % e_value]
inverse_m = crypto_tools.inverse_modulo_numb(temp_m, open_mixes[i])
result += tx_data[i] * temp_m * inverse_m
result = (result % m_value)**(1 / float(e_value))
return f"{result}"
def magma(data):
key = crypto_tools.cterm('input', 'Enter key(str): ', 'ans')
encrypt = crypto_tools.cterm('input',
'You want encrypt or decrypt: ', 'ans')
if encrypt != "decrypt" and encrypt != "encrypt":
raise ValueError("Incorrect type")
mode = crypto_tools.cterm(
'input',
'Enter mode(simple_replacement|xor): ',
'ans'
)
if mode not in ["simple_replacement", "xor"]:
raise ValueError(f"Incorrect mode: {mode}")
res_data = magma_processing(data, key, encrypt, mode)
if encrypt == "encrypt":
result_str = res_data
else:
result_str = res_data.decode()
return result_str
def openssl_rsa(data):
if not os.path.exists("storage/"):
raise ValueError("Can't find storage directory with keys")
pem_key_filename = crypto_tools.cterm('input',
'Enter private key filename(str): ',
'ans')
pem_key_filename = "storage/" + pem_key_filename
pub_key_filename = crypto_tools.cterm('input',
'Enter public key filename(str): ',
'ans')
pub_key_filename = "storage/" + pub_key_filename
encrypt = crypto_tools.cterm('input', 'You want encrypt or decrypt: ',
'ans')
if encrypt not in ["decrypt", "encrypt"]:
raise ValueError("Incorrect type")
res_data = openssl_rsa_processing(data, encrypt, pem_key_filename,
pub_key_filename)
if encrypt == "encrypt":
result_str = res_data
else:
result_str = res_data.decode()
return result_str
def openssl_aes_128(data):
if data.__class__ == str:
data = bytearray(data, "utf-8")
key = crypto_tools.cterm('input', 'Enter key(str): ', 'ans')
if key.__class__ == str:
key = bytearray(key.encode())
iv = crypto_tools.cterm('input', 'Enter initialization vector(str): ',
'ans')
if iv.__class__ == str:
iv = bytearray(iv.encode())
mode = crypto_tools.cterm(
'input',
'Enter mode(CBC(Cipher Block Chaining)|CFB(Cipher Feedback)): ', 'ans')
if mode not in ["CBC", "CFB"]:
raise ValueError(f"Incorrect mode: {mode}")
encrypt = crypto_tools.cterm('input', 'You want encrypt or decrypt: ',
'ans')
if encrypt not in ["decrypt", "encrypt"]:
raise ValueError("Incorrect type")
res_data = openssl_aes_128_processing(data, key, iv, mode, encrypt)
if encrypt == "encrypt":
result_str = res_data
else:
result_str = res_data.decode()
return result_str
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 generate_ca_processing(ca_info):
key = OpenSSL.crypto.PKey()
key.generate_key(OpenSSL.crypto.TYPE_RSA, 2048)
if os.path.exists("crypto_ca"):
shutil.rmtree("crypto_ca")
os.mkdir("crypto_ca")
cert = crypto_tools.generate_cert(ca_info, key, key)
with open("crypto_ca/crypto_cert.pem", "wt") as pem_file:
pem_file.write(
OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_PEM,
cert).decode("utf-8"))
with open("crypto_ca/crypto_key.pem", "wt") as pem_file:
pem_file.write(
OpenSSL.crypto.dump_privatekey(OpenSSL.crypto.FILETYPE_PEM,
key).decode("utf-8"))
pkcs12_cert = OpenSSL.crypto.PKCS12()
pkcs12_cert.set_privatekey(key)
pkcs12_cert.set_certificate(cert)
p12data = pkcs12_cert.export("")
with open('crypto_ca/crypto_pkcs12_cert.pfx', 'wb') as pfxfile:
pfxfile.write(p12data)
crypto_tools.cterm("output", "Created Successfully!", "inf")
def lfsr_generator():
register_size = int(
crypto_tools.cterm('input', 'Enter register_size(uint): ', 'ans'))
if register_size <= 0:
raise ValueError("Register size must be bigger then 0")
start_state = json.loads(
crypto_tools.cterm('input', 'Enter register start state(list): ',
'ans'))
if start_state.__class__ != list:
raise ValueError(
f"Incorrect exec_xor_pos class {start_state.__class__}")
exec_xor_pos = json.loads(
crypto_tools.cterm('input',
'Enter executive polynomial xor bits(list): ',
'ans'))
if exec_xor_pos.__class__ != list:
raise ValueError(
f"Incorrect exec_xor_pos class {exec_xor_pos.__class__}")
output_size = int(crypto_tools.cterm('input', 'Enter output size: ',
'ans'))
if output_size <= 0:
raise ValueError(f"Incorrect output buffer size {output_size}")
return lfsr_generator_processing(register_size, exec_xor_pos, start_state,
output_size)
def lfsr(data):
if data.__class__ == str:
data = bytearray(data, "utf-8")
register_size = int(
crypto_tools.cterm('input', 'Enter register_size(uint): ', 'ans'))
if register_size <= 0:
raise ValueError("Register size must be bigger then 0")
start_state = json.loads(
crypto_tools.cterm('input', 'Enter register start state(list): ',
'ans'))
if start_state.__class__ != list:
raise ValueError(
f"Incorrect exec_xor_pos class {start_state.__class__}")
exec_xor_pos = json.loads(
crypto_tools.cterm('input',
'Enter executive polynomial xor bits(list): ',
'ans'))
if exec_xor_pos.__class__ != list:
raise ValueError(
f"Incorrect exec_xor_pos class {exec_xor_pos.__class__}")
return lfsr_processing(data, register_size, exec_xor_pos, start_state)
def issue_cert():
cert_info = {
"emailAddress":
crypto_tools.cterm('input', 'Enter email(str): ', 'ans'),
"commonName":
crypto_tools.cterm('input', 'Enter common name(str): ', 'ans'),
"countryName":
crypto_tools.cterm('input', 'Enter country name(str): ', 'ans'),
"localityName":
crypto_tools.cterm('input', 'Enter locality name(str): ', 'ans'),
"stateOrProvinceName":
crypto_tools.cterm('input', 'Enter state or province name(str): ',
'ans'),
"organizationName":
crypto_tools.cterm('input', 'Enter organization name(str): ', 'ans'),
"organizationUnitName":
crypto_tools.cterm('input', 'Enter organization unit name(str): ',
'ans'),
"serialNumber":
int(
crypto_tools.cterm('input', 'Enter serial number name(int): ',
'ans')),
"validityEndInSeconds":
int(
crypto_tools.cterm('input', 'Enter validity end in seconds(int): ',
'ans')),
}
username = crypto_tools.cterm('input', 'Enter username(str): ', 'ans')
return issue_cert_processing(cert_info, username)
def openssl_generate_rsa_keys_processing(key_length, exponent,
pem_key_filename, pub_key_filename):
crypto_native.openssl_api_init()
result = crypto_native.openssl_api_generate_rsa_keys(
key_length, exponent, pem_key_filename, pub_key_filename)
crypto_tools.cterm("output", result, "inf")
def dummy_rsa(data):
data = int(crypto_tools.utf_decoder(data))
e_value = int(crypto_tools.cterm('input', 'Enter open(e) value: ', 'ans'))
p_value = int(crypto_tools.cterm('input', 'Enter first(p) number: ',
'ans'))
q_value = int(
crypto_tools.cterm('input', 'Enter second(q) number: ', 'ans'))
return dummy_rsa_processing(data, p_value, q_value, e_value)
def vigenere(data):
lang = crypto_tools.cterm('input', 'Data language: ', 'ans')
key = crypto_tools.cterm('input', 'Enter key(str): ', 'ans')
encrypt = crypto_tools.cterm('input', 'You want encrypt or decrypt: ',
'ans')
if encrypt != "encrypt" and encrypt != "decrypt":
raise ValueError("Incorrect action")
data = crypto_tools.utf_decoder(data)
return vigenere_processing(data, key, lang, encrypt)
def help_process_input(commands_list):
while True:
full_doc = None
quest = 'Write command name for more info or "back": '
command = crypto_tools.cterm('input', quest, 'ans')
if command == "back":
break
if command in ["help", "exit", "force_exit"]:
crypto_tools.cterm('output',
"O'rly, It's too easy, I hope it's a joke",
'inf')
continue
try:
for module, commands in commands_list.items():
if command in commands:
full_doc = getattr(module, f"{command}").full_doc()
except AttributeError:
crypto_tools.cterm('output',
'No detailed description for this command',
'err')
continue
if full_doc:
crypto_tools.cterm("output", full_doc, "inf")
else:
crypto_tools.cterm('output', 'No such command', 'err')
def xor(data):
key = crypto_tools.cterm('input', 'Enter key(str): ', 'ans')
encrypt = crypto_tools.cterm('input',
'You want encrypt or decrypt: ', 'ans')
if encrypt != "encrypt" and encrypt != "decrypt":
raise ValueError("Incorrect action")
if len(key) == 0:
raise ValueError("Empty key")
if key.__class__ == str:
key = bytearray(key, "utf-8")
return xor_processing(data, key, encrypt)
def caesar(data):
lang = crypto_tools.cterm('input', 'Data language: ', 'ans')
key = int(crypto_tools.cterm('input', 'Enter key(int): ', 'ans'))
encrypt = crypto_tools.cterm('input', 'You want encrypt or decrypt: ',
'ans')
if encrypt == "decrypt":
key = key * -1
elif encrypt != "encrypt":
raise ValueError("Incorrect type")
return caesar_processing(data, lang, key)
def rc4(data):
key = crypto_tools.cterm('input', 'Enter key(str): ', 'ans')
encrypt = crypto_tools.cterm('input', 'You want encrypt or decrypt: ',
'ans')
if encrypt != "decrypt" and encrypt != "encrypt":
raise ValueError("Incorrect type")
byte_key = bytearray(key, "utf-8")
if len(byte_key) > 256:
raise ValueError("Key len must be <= 256")
if data.__class__ == str:
data = bytearray(data, "utf-8")
return rc4_processing(data, byte_key, encrypt)
def hill(data):
lang = crypto_tools.cterm('input', 'Data language: ', 'ans')
key = crypto_tools.cterm('input', 'Enter key: ', 'ans')
encrypt = crypto_tools.cterm('input', 'You want encrypt or decrypt: ',
'ans')
if len(key) < 2:
raise ValueError("Key must be bigger then 1 char")
if encrypt != "encrypt" and encrypt != "decrypt":
raise ValueError("Incorrect action")
hill_dict = crypto_tools.get_param_json_data("alphabets.json", lang)
return hill_processing(data, key, encrypt, hill_dict)
def rsa_hijack(data):
method = crypto_tools.cterm(
'input', 'Enter hijack method(fermat|repeat|chinese|nokey): ', 'ans')
open_mix = int(
crypto_tools.cterm('input', 'Enter open(p * q) number: ', 'ans'))
e_value = int(crypto_tools.cterm('input', 'Enter open(e) number: ', 'ans'))
try:
hijack = getattr(sys.modules[__name__], "rsa_hijack_" + method)
return hijack(data, open_mix, e_value)
except AttributeError:
raise ValueError(f"No such method: {method}")
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 cryptoapi_aes_processing(data, key_length, key, mode, provider, encrypt):
cryptoapi_aes_pre_processing(key, key_length)
if provider == "standard":
result = crypto_native.ms_cryptoapi_standard_aes(data, key, encrypt)
else:
result = crypto_native.ms_cryptoapi_nextgen_aes(
data, key, mode, encrypt)
crypto_tools.cterm("output", f"Hashed key: {result['hashed_key']}", "inf")
crypto_tools.cterm("output", f"Session key: {result['session_key']}",
"inf")
return result["result"]
def elgamal(data):
data = crypto_tools.utf_decoder(data)
p_value = int(crypto_tools.cterm('input', 'Enter first(p) number: ',
'ans'))
g_value = int(
crypto_tools.cterm('input', 'Enter generator(g) number: ', 'ans'))
x_value = int(
crypto_tools.cterm('input', 'Enter closed(x) number: ', 'ans'))
encrypt = crypto_tools.cterm('input', 'You want encrypt or decrypt: ',
'ans')
if encrypt not in ("encrypt", "decrypt"):
raise ValueError(f"Incorrect action {encrypt}")
return elgamal_processing(data, p_value, x_value, encrypt, g_value)
def rsa_hijack_nokey(data, open_mix, e_value):
data = int(crypto_tools.utf_decoder(data))
crypto_tools.cterm("output", f"Hijacking using nokey reading method",
"inf")
second_data = int(crypto_tools.utf_decoder(crypto_tools.get_data()))
second_e_value = int(
crypto_tools.cterm('input', 'Enter second open(e) number: ', 'ans'))
gcd, r, s = crypto_tools.EGCD(e_value, second_e_value)
c1_r = pow(data, r) % open_mix
c2_s = pow(crypto_tools.inverse_modulo_numb(second_data, open_mix),
-s) % open_mix
result = (c1_r * c2_s) % open_mix
return f"{result}"
def ansi_x9_17():
output_size = int(
crypto_tools.cterm('input', 'Enter output size(bytes): ', 'ans'))
if output_size <= 0:
raise ValueError(f"Incorrect output buffer size {output_size}")
key = crypto_tools.cterm('input', 'Enter key(str): ', 'ans')
if key.__class__ == str:
key = bytearray(key.encode())
buffer_v0 = crypto_tools.cterm('input', 'Enter v0(str): ', 'ans')
if buffer_v0.__class__ == str:
buffer_v0 = bytearray(buffer_v0.encode())
return ansi_x9_17_processing(output_size, key, buffer_v0)
def block(data):
key = crypto_tools.cterm('input', 'Enter key(str): ', 'ans')
block_size = int(crypto_tools.cterm('input', 'Block size(int): ', 'ans'))
rounds = int(crypto_tools.cterm('input', 'Rounds(int): ', 'ans'))
encrypt = crypto_tools.cterm('input', 'You want encrypt or decrypt: ',
'ans')
if encrypt not in ("decrypt", "encrypt"):
raise ValueError("Incorrect type")
res_data = block_processing(data, key, block_size, rounds, encrypt)
if encrypt == "encrypt":
result_str = res_data
else:
result_str = res_data.decode()
return result_str
def dsa(data):
data = crypto_tools.utf_decoder(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'))
x_value = int(
crypto_tools.cterm('input', 'Enter secret key(x) number: ', 'ans'))
k_value = int(
crypto_tools.cterm('input', 'Enter secret key(k) number: ', 'ans'))
encrypt = crypto_tools.cterm('input', 'You want sign or verify: ', 'ans')
if encrypt not in ("sign", "verify"):
raise ValueError(f"Incorrect action {encrypt}")
return dsa_processing(data, p_value, q_value, x_value, k_value, encrypt)
def elliptic_encrypt(data, open_key, r_number, big_g):
new_data = []
for i in data:
temp = big_g * ord(i)
if not crypto_tools.elliptic_point.belong_to_curve(temp):
crypto_tools.cterm("output",
f"Warning: {big_g} * {ord(i)} out of curve",
"inf")
new_data.append(temp)
crypto_tools.cterm("output", f"Encoded data = {new_data}", "inf")
res_data = []
for point in new_data:
first_point = big_g * r_number
second_point = point + open_key * r_number
res_data.append([[first_point.x, first_point.y],
[second_point.x, second_point.y]])
return json.dumps(res_data)
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 main_loop():
while True:
command = None
command_name = crypto_tools.cterm("input", "", "def")
if command_name == "":
continue
try:
if command_name != "help":
completer.in_menu = False
for module, commands in commands_list.items():
if command_name in commands:
command = getattr(module, command_name)
break
if command:
command()
else:
crypto_tools.cterm('output', 'Error: incorrect command', 'err')
except KeyError as err:
crypto_tools.cterm("output", err, "err")
completer.in_menu = True
def issue_cert_processing(cert_info, username):
key = OpenSSL.crypto.PKey()
key.generate_key(OpenSSL.crypto.TYPE_RSA, 2048)
if not os.path.exists("crypto_ca"):
raise Exception("Generate CA firstly")
if os.path.exists(f"storage/certs/{username}"):
shutil.rmtree(f"storage/certs/{username}")
os.makedirs(f"storage/certs/{username}")
with open("crypto_ca/crypto_cert.pem") as ca_cert_file:
ca_cert = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM,
ca_cert_file.read())
with open("crypto_ca/crypto_key.pem") as ca_key_file:
ca_key = OpenSSL.crypto.load_privatekey(OpenSSL.crypto.FILETYPE_PEM,
ca_key_file.read())
cert = crypto_tools.generate_cert(cert_info, key, ca_key,
ca_cert.get_subject())
with open(f"storage/certs/{username}/{username}_cert.pem", "wt") as f:
f.write(
OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_PEM,
cert).decode("utf-8"))
with open(f"storage/certs/{username}/{username}_key.pem", "wt") as f:
f.write(
OpenSSL.crypto.dump_privatekey(OpenSSL.crypto.FILETYPE_PEM,
key).decode("utf-8"))
pkcs12_cert = OpenSSL.crypto.PKCS12()
pkcs12_cert.set_privatekey(key)
pkcs12_cert.set_certificate(cert)
p12data = pkcs12_cert.export("")
with open(f"storage/certs/{username}/{username}_pkcs12_cert.pfx",
'wb') as pfxfile:
pfxfile.write(p12data)
crypto_tools.cterm("output", "Issued Successfully!", "inf")
