154 lines
5.5 KiB
Python
154 lines
5.5 KiB
Python
import subprocess
|
|
import tempfile
|
|
import base64
|
|
import os
|
|
|
|
|
|
class DiffieHellmanConsoleManager():
|
|
"""Class for managing diffie-hellman crypto operations"""
|
|
host_private_key = None
|
|
host_public_key = None
|
|
remote_public_key = None
|
|
shared_key = None
|
|
dh_params = None
|
|
|
|
def generate_dh_params(self) -> str:
|
|
"""Method for generating Diffie-Hellman (DH) parameters"""
|
|
|
|
# Generating DH parameters
|
|
dhparam_command = ['openssl', 'dhparam', '2048']
|
|
|
|
# Capturing result of generator command to string
|
|
completed_process = subprocess.run(dhparam_command, check=True, capture_output=True, text=True)
|
|
dhparam_output = completed_process.stdout
|
|
|
|
# Returning DH parameters
|
|
return dhparam_output
|
|
|
|
def generate_host_private_key(self, dh_params: str) -> str:
|
|
"""Method for generating console private key for further usage in DH algorithms
|
|
|
|
Args:
|
|
dh_params (str): DH paramters, that are generated earlier
|
|
|
|
Returns:
|
|
str: console private key
|
|
"""
|
|
|
|
# Creating temporary file with DH params
|
|
with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp_file:
|
|
temp_file.write(dh_params)
|
|
temp_filename = temp_file.name
|
|
|
|
# Generating console private key
|
|
generate_private_console_key_command = ['openssl', 'genpkey', '-paramfile', temp_filename]
|
|
|
|
# Capturing result of generator command to string
|
|
generator_command_invoker = subprocess.run(generate_private_console_key_command,
|
|
check=True,
|
|
capture_output=True,
|
|
text=True)
|
|
command_result_output = generator_command_invoker.stdout
|
|
|
|
# Closing and deleting temporary file
|
|
temp_file.close()
|
|
|
|
# Returning console private key
|
|
return command_result_output
|
|
|
|
def generate_host_public_key(self, host_private_key: str) -> str:
|
|
"""Method for generating console public key
|
|
|
|
Args:
|
|
host_private_key (str): console private key, that is used to create public key
|
|
|
|
Returns:
|
|
str: Console public key
|
|
"""
|
|
# Creating temporary file with console private key
|
|
with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp_file:
|
|
temp_file.write(host_private_key)
|
|
temp_filename = temp_file.name
|
|
|
|
# Generating console public key
|
|
generate_private_console_key_command = ['openssl', 'pkey', '-in', temp_filename, '-pubout']
|
|
|
|
# Capturing result of generator command to string
|
|
generator_command_invoker = subprocess.run(generate_private_console_key_command,
|
|
check=True,
|
|
capture_output=True,
|
|
text=True)
|
|
command_result_output = generator_command_invoker.stdout
|
|
|
|
# Closing and deleting temporary file
|
|
temp_file.close()
|
|
|
|
# Returning console private key
|
|
return command_result_output
|
|
|
|
def decode_remote_public_key(self, encoded_public_key: str) -> str:
|
|
"""Method for decoding publice key, received from remote
|
|
|
|
Args:
|
|
encoded_public_key (str): encoded remote public key
|
|
|
|
Returns:
|
|
str: decoded remote public key
|
|
"""
|
|
# TODO: Add exception handler if key could not be decoded
|
|
decoded_public_key = base64.b64decode(encoded_public_key).decode('utf-8')
|
|
return decoded_public_key
|
|
|
|
def generate_shared_key(self, host_private_key: str, remote_public_key: str) -> str:
|
|
"""Method for creation shared key, that will be used to encrypt data between host and remote
|
|
|
|
Args:
|
|
host_private_key (str): console private key
|
|
remote_public_key (str): remote public key
|
|
|
|
Returns:
|
|
str: shared key for encryption
|
|
"""
|
|
|
|
# Creating temporary file with console private key
|
|
with tempfile.NamedTemporaryFile(mode='w', delete=False) as host_private_key_file:
|
|
host_private_key_file.write(host_private_key)
|
|
host_private_key_filename = host_private_key_file.name
|
|
|
|
# Creating temportaty file with remote public key
|
|
with tempfile.NamedTemporaryFile(mode='w', delete=False) as remote_public_key_file:
|
|
remote_public_key_file.write(remote_public_key)
|
|
remote_public_key_filename = remote_public_key_file.name
|
|
|
|
command = [
|
|
"openssl", "pkeyutl", "-derive", "-inkey", host_private_key_filename,
|
|
'-peerkey', remote_public_key_filename, "-out", "secretSharedClass.bin"
|
|
]
|
|
|
|
subprocess.run(
|
|
command,
|
|
check=True,
|
|
)
|
|
# command_result_output = generator_command_invoker.stdout
|
|
|
|
file_name = "secretSharedClass.bin" # Specify the name of the file you want to delete
|
|
|
|
with open(file_name, "rb") as shared_file:
|
|
shared_secret = shared_file.read().hex()
|
|
self.shared_key = shared_secret
|
|
|
|
|
|
if os.path.exists(file_name):
|
|
os.remove(file_name)
|
|
print(f"File '{file_name}' deleted successfully.")
|
|
else:
|
|
print(f"File '{file_name}' does not exist.")
|
|
|
|
# Closing and deleting temporary files
|
|
host_private_key_file.close()
|
|
remote_public_key_file.close()
|
|
print("|"*60)
|
|
print(self.shared_key)
|
|
print("|"*60)
|
|
|
|
return self.shared_key
|