def decrypt(self):
if not os.path.exists("key"):
os.makedirs("key")
if not os.path.exists("result"):
os.makedirs("result")
decryption = Decryptor(self.file_path)
decryption.save_file()
parsed_image = self.parse_image(decryption.main_image, 500)
self.label_image.setPixmap(parsed_image)
self.file_path = decryption.decryption_path
self.makeHistogram()
class CryptoService(object):
def __init__(self, rsa_pub_path=None, rsa_pri_path=None, p=None, g=None):
self.dh = DiffieHellman(p, g) if p is not None and g is not None else None
self.encryptor = Encryptor(rsa_pub_path)
self.decryptor = Decryptor(rsa_pri_path)
def get_dh_pri_key(self):
return self.dh.generate_private_key()
def get_dh_pub_key(self, private_key):
return self.dh.generate_public_key(private_key)
def get_dh_secret(self, private_key, other_public_key):
# TODO verify the other_public_key
return self.dh.compute_secret(private_key, other_public_key)
def sym_encrypt(self, secret, p_text):
return self.encryptor.sym_encrypt(secret, p_text)
def sym_decrypt(self, secret, c_text):
return self.decryptor.sym_decrypt(secret, c_text)
def rsa_decrypt(self, c_text):
return self.decryptor.rsa_decrypt(c_text)
def rsa_sign(self, msg):
return self.decryptor.rsa_sign(msg)
def rsa_verify(self, msg, sign):
return self.encryptor.rsa_verify(msg, sign)
def rsa_encrypt(self, p_text):
return self.encryptor.rsa_encrypt(p_text)
def compute_pw_hash(self, pw, salt):
return hashlib.sha256(pw + salt).hexdigest()
def new_sym_key(self, size=32):
return os.urandom(size)
@staticmethod
def generate_hmac_sign(dh_key, msg):
#generate digest for the cipher text with HMAC
h = hmac.HMAC(dh_key, hashes.SHA256(), backend=default_backend())
h.update(msg)
sign = h.finalize()
return sign
@staticmethod
def verify_hmac_sign(dh_key, msg, sign):
expect_sign = CryptoService.generate_hmac_sign(dh_key, msg)
return expect_sign == sign
def KPIClient(config, datasink):
"""\ KPIClient(config, datasink) -> returns a Graphline
KPIClient handles authentication and decryption
Keyword arguments:
- config -- uses KPIUser instance for looking up user
key from client config file
- datasink -- any component with an inbox. the KPIClient sends
decrypted data to datasink's inbox
"""
return Graphline(authenticatee=Authenticatee(KPIUser(configfile=config)),
dec=Decryptor(),
ds=datasink,
linkages={
("", "inbox"): ("authenticatee", "inbox"),
("authenticatee", "outbox"): ("", "outbox"),
("authenticatee", "encout"): ("dec", "inbox"),
("authenticatee", "notifykey"): ("dec", "keyevent"),
("dec", "outbox"): ("ds", "inbox"),
})
def main():
global INPUT_FILE
global OUTPUT_FILE
args = argparse.ArgumentParser(description="Vigenère cipher decryption "
"tool.")
args.add_argument("-e",
"--encrypt",
help="Encrypt the input file",
action="store_true",
dest="mode_encrypt")
args.add_argument('-k',
'--key',
help="Add custom key for encryption or "
"decryption")
args.add_argument("-d",
"--decrypt",
help="Decrypt the input file",
action="store_true",
dest="mode_decrypt")
args.add_argument("-i",
"--input-file",
help="The file from which the text"
" will be read to be "
"encrypted or decrypted")
args.add_argument("-o",
"--output-file",
help="The file where the output "
"will be saved")
args.add_argument("-v",
"--verbose",
help="Enable verbosity",
action="store_true")
parser = args.parse_args()
if not parser.mode_encrypt and not parser.mode_decrypt:
display_error("Mode must be set using --encrypt or --decrypt options.")
if parser.input_file:
INPUT_FILE = parser.input_file
try:
with open(INPUT_FILE, "r") as _:
pass
except FileNotFoundError:
display_error(f"The file '{INPUT_FILE}' does not exist.")
except PermissionError:
display_error(f"You do not have enough permissions to read the "
f"file '{INPUT_FILE}'")
else:
display_error("No input file provided.")
if parser.output_file:
OUTPUT_FILE = parser.output_file
else:
display_error("No output file provided")
if parser.mode_encrypt:
# Creating a new Encryptor object and uploading the plaintext to be
# encrypted with a random key
encryptor = Encryptor(parser.verbose)
encryptor.read_plaintext_from_file(INPUT_FILE)
if parser.key:
encryptor.encrypt(parser.key)
else:
encryptor.encrypt()
encryptor.save_ciphertext_to_file(OUTPUT_FILE)
display_info("Encryption performed successfully.")
display_info(f"Saved encrypted text to '{OUTPUT_FILE}'")
else:
# Now, prepare the decrypting process by creating a new Decryptor
# object which will crack the key by itself
enigma = Decryptor(parser.verbose)
enigma.read_ciphertext_from_file(INPUT_FILE)
if parser.key:
decrypted_key = parser.key
display_verbose(f"Decrypting using custom key "
f"[green]{decrypted_key}[/green] of length "
f"[yellow]{len(decrypted_key)}[/yellow]")
else:
decrypted_key = enigma.crack_key()
enigma.decrypt(decrypted_key)
enigma.save_decrypted_plaintext_to_file(OUTPUT_FILE)
display_info("Decryption performed successfully.")
display_info(f"Saved decrypted text to '{OUTPUT_FILE}'")
def __init__(self, rsa_pub_path=None, rsa_pri_path=None, p=None, g=None):
self.dh = DiffieHellman(p, g) if p is not None and g is not None else None
self.encryptor = Encryptor(rsa_pub_path)
self.decryptor = Decryptor(rsa_pri_path)
