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")