improved scripts

communication/client.py

@@ -7,7 +7,10 @@ from Crypto.PublicKey import RSA
 from Crypto.Util.Padding import pad
 from Crypto.Random import get_random_bytes
 import base64
-from ../setup/logging.py import configure_logging, user_input
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'setup')))
+from custom_logging import configure_logging, user_input
 
 # Load the RSA public key to encrypt the key
 def load_public_key():
@@ -76,7 +79,7 @@ def main():
     configure_logging()
     
     # server information
-    host = '127.0.0.1'
+    host = '192.168.178.51'
     port = 12345
     
     # Load RSA public key (for encrypting the key)

communication/server.py

@@ -6,7 +6,10 @@ from Crypto.Cipher import DES, Blowfish, ARC4, PKCS1_OAEP
 from Crypto.PublicKey import RSA
 from Crypto.Util.Padding import unpad
 import base64
-from ../setup/logging.py import configure_logging, user_input
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'setup')))
+from custom_logging import configure_logging, user_input
 
 # Load the RSA private key to decrypt the key
 def load_private_key():
@@ -100,7 +103,7 @@ def main():
     configure_logging()
     
     # server information
-    host = '127.0.0.1'
+    host = '192.168.178.51'
     port = 12345
     
     # Load RSA private key (for decrypting the key)

decryption/blowfish_128.py

@@ -2,31 +2,77 @@ import logging
 from Crypto.Cipher import Blowfish
 from Crypto.Util.Padding import unpad
 import itertools
-import base64
-from logger import setup_logging  # Import logging configuration
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'setup')))
+from custom_logging import configure_logging
 
-def brute_force_blowfish_128(ciphertext_base64, iv_hex):
-    ciphertext = base64.b64decode(ciphertext_base64)
-    iv = bytes.fromhex(iv_hex)
+# Brute-force attack on Blowfish encryption (128-bit block size)
+def brute_force_blowfish(ciphertext_hex, expected_plaintext, debug_key=None):
+    # Convert the hex string to bytes
+    decoded_ciphertext = bytes.fromhex(ciphertext_hex)
     
-    logging.info("Starting brute-force for Blowfish (128-bit key)...")
-    for key in itertools.product(range(256), repeat=16):  # 128-bit key
+    # Extract the IV (the first 8 bytes)
+    iv = decoded_ciphertext[:8]
+    ciphertext = decoded_ciphertext[8:]  # The rest is the encrypted text
+    
+    logging.info(f"Extracted IV (Hex): {iv.hex()}")
+    logging.info("Starting brute-force for Blowfish with 128-bit keys...")
+    
+    # Optional debug key
+    if debug_key:
+        try:
+            key = bytes.fromhex(debug_key)
+            cipher = Blowfish.new(key, Blowfish.MODE_CBC, iv)
+            plaintext = unpad(cipher.decrypt(ciphertext), Blowfish.block_size)
+            if plaintext.decode() == expected_plaintext:
+                logging.info(f"Decrypted successfully: {plaintext.decode()} with debug key {key.hex()}")
+                return plaintext.decode()
+            else:
+                logging.warning("Debug key provided but failed to match the expected plaintext.")
+        except Exception as e:
+            logging.error(f"Error with debug key: {e}")
+    
+    # Brute-force key generation: all possible 8-byte keys (128 bits)
+    for key in itertools.product(range(256), repeat=16):
         key = bytes(key)
         try:
+            # Decrypt with the generated key
             cipher = Blowfish.new(key, Blowfish.MODE_CBC, iv)
             plaintext = unpad(cipher.decrypt(ciphertext), Blowfish.block_size)
-            logging.info(f"Decrypted successfully: {plaintext.decode()} with key {key.hex()}")
-            return plaintext.decode()
+            
+            # Check if the decrypted text matches the expected plaintext
+            if plaintext.decode() == expected_plaintext:
+                logging.info(f"Decrypted successfully: {plaintext.decode()} with key {key.hex()}")
+                return plaintext.decode()
         except Exception:
             continue
+        
     logging.error("No matching key found.")
     return None
 
 def main():
-    setup_logging()  # Set up logging
-    ciphertext_base64 = input("Enter the Blowfish-encrypted text (Base64): ").strip()
-    iv_hex = input("Enter the initialization vector (IV) in hexadecimal (16 characters): ").strip()
-    brute_force_blowfish_128(ciphertext_base64, iv_hex)
+    # Configure colored logging
+    configure_logging()
+    
+    # Input the encrypted text as a hex string
+    ciphertext_hex = input("Enter the Blowfish-encrypted text (Hex, including IV): ").strip()
+    
+    # Optionally provide a debug key
+    debug_key = input("Enter a debug key in hex (or press Enter to skip): ").strip()
+    if not debug_key:
+        debug_key = None
+    
+    # Define the expected plaintext
+    expected_plaintext = "Test"
+    
+    # Call brute-force decryption
+    result = brute_force_blowfish(ciphertext_hex, expected_plaintext, debug_key)
+    
+    if result:
+        logging.info(f"Decrypted text: {result}")
+    else:
+        logging.error("Failed to decrypt the ciphertext.")
 
 if __name__ == "__main__":
-    main()
+    main()
\ No newline at end of file

decryption/blowfish_64.py

@@ -2,31 +2,77 @@ import logging
 from Crypto.Cipher import Blowfish
 from Crypto.Util.Padding import unpad
 import itertools
-import base64
-from logger import setup_logging  # Import logging configuration
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'setup')))
+from custom_logging import configure_logging
 
-def brute_force_blowfish_64(ciphertext_base64, iv_hex):
-    ciphertext = base64.b64decode(ciphertext_base64)
-    iv = bytes.fromhex(iv_hex)
+# Brute-force attack on Blowfish encryption (64-bit block size)
+def brute_force_blowfish(ciphertext_hex, expected_plaintext, debug_key=None):
+    # Convert the hex string to bytes
+    decoded_ciphertext = bytes.fromhex(ciphertext_hex)
     
-    logging.info("Starting brute-force for Blowfish (64-bit key)...")
+    # Extract the IV (the first 8 bytes)
+    iv = decoded_ciphertext[:8]
+    ciphertext = decoded_ciphertext[8:]  # The rest is the encrypted text
+    
+    logging.info(f"Extracted IV (Hex): {iv.hex()}")
+    logging.info("Starting brute-force for Blowfish with 64-bit keys...")
+    
+    # Optional debug key
+    if debug_key:
+        try:
+            key = bytes.fromhex(debug_key)
+            cipher = Blowfish.new(key, Blowfish.MODE_CBC, iv)
+            plaintext = unpad(cipher.decrypt(ciphertext), Blowfish.block_size)
+            if plaintext.decode() == expected_plaintext:
+                logging.info(f"Decrypted successfully: {plaintext.decode()} with debug key {key.hex()}")
+                return plaintext.decode()
+            else:
+                logging.warning("Debug key provided but failed to match the expected plaintext.")
+        except Exception as e:
+            logging.error(f"Error with debug key: {e}")
+    
+    # Brute-force key generation: all possible 8-byte keys (64 bits)
     for key in itertools.product(range(256), repeat=8):
         key = bytes(key)
         try:
+            # Decrypt with the generated key
             cipher = Blowfish.new(key, Blowfish.MODE_CBC, iv)
             plaintext = unpad(cipher.decrypt(ciphertext), Blowfish.block_size)
-            logging.info(f"Decrypted successfully: {plaintext.decode()} with key {key.hex()}")
-            return plaintext.decode()
+            
+            # Check if the decrypted text matches the expected plaintext
+            if plaintext.decode() == expected_plaintext:
+                logging.info(f"Decrypted successfully: {plaintext.decode()} with key {key.hex()}")
+                return plaintext.decode()
         except Exception:
             continue
+        
     logging.error("No matching key found.")
     return None
 
 def main():
-    setup_logging()  # Set up logging
-    ciphertext_base64 = input("Enter the Blowfish-encrypted text (Base64): ").strip()
-    iv_hex = input("Enter the initialization vector (IV) in hexadecimal (16 characters): ").strip()
-    brute_force_blowfish_64(ciphertext_base64, iv_hex)
+    # Configure colored logging
+    configure_logging()
+    
+    # Input the encrypted text as a hex string
+    ciphertext_hex = input("Enter the Blowfish-encrypted text (Hex, including IV): ").strip()
+    
+    # Optionally provide a debug key
+    debug_key = input("Enter a debug key in hex (or press Enter to skip): ").strip()
+    if not debug_key:
+        debug_key = None
+    
+    # Define the expected plaintext
+    expected_plaintext = "Test"
+    
+    # Call brute-force decryption
+    result = brute_force_blowfish(ciphertext_hex, expected_plaintext, debug_key)
+    
+    if result:
+        logging.info(f"Decrypted text: {result}")
+    else:
+        logging.error("Failed to decrypt the ciphertext.")
 
 if __name__ == "__main__":
-    main()
+    main()
\ No newline at end of file

decryption/des_64.py

@@ -2,30 +2,77 @@ import logging
 from Crypto.Cipher import DES
 from Crypto.Util.Padding import unpad
 import itertools
-import base64
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'setup')))
+from custom_logging import configure_logging
 
-def brute_force_des(ciphertext_base64, iv_hex):
-    ciphertext = base64.b64decode(ciphertext_base64)
-    iv = bytes.fromhex(iv_hex)
+# Brute-force attack on DES encryption
+def brute_force_des(ciphertext_hex, expected_plaintext, debug_key=None):
+    # Convert the hex string to bytes
+    decoded_ciphertext = bytes.fromhex(ciphertext_hex)
     
+    # Extract the IV (the first 8 bytes)
+    iv = decoded_ciphertext[:8]
+    ciphertext = decoded_ciphertext[8:]  # The rest is the encrypted text
+    
+    logging.info(f"Extracted IV (Hex): {iv.hex()}")
     logging.info("Starting brute-force for DES (64-bit key)...")
+    
+    # Optional debug key
+    if debug_key:
+        try:
+            key = bytes.fromhex(debug_key)
+            cipher = DES.new(key, DES.MODE_CBC, iv)
+            plaintext = unpad(cipher.decrypt(ciphertext), DES.block_size)
+            if plaintext.decode() == expected_plaintext:
+                logging.info(f"Decrypted successfully: {plaintext.decode()} with debug key {key.hex()}")
+                return plaintext.decode()
+            else:
+                logging.warning("Debug key provided but failed to match the expected plaintext.")
+        except Exception as e:
+            logging.error(f"Error with debug key: {e}")
+    
+    # Brute-force key generation: all possible 8-byte keys
     for key in itertools.product(range(256), repeat=8):
         key = bytes(key)
         try:
+            # Decrypt with the generated key
             cipher = DES.new(key, DES.MODE_CBC, iv)
             plaintext = unpad(cipher.decrypt(ciphertext), DES.block_size)
-            logging.info(f"Decrypted successfully: {plaintext.decode()} with key {key.hex()}")
-            return plaintext.decode()
+            
+            # Check if the decrypted text matches the expected plaintext
+            if plaintext.decode() == expected_plaintext:
+                logging.info(f"Decrypted successfully: {plaintext.decode()} with key {key.hex()}")
+                return plaintext.decode()
         except Exception:
             continue
+        
     logging.error("No matching key found.")
     return None
 
 def main():
-    setup_logging()
-    ciphertext_base64 = input("Enter the DES-encrypted text (Base64): ").strip()
-    iv_hex = input("Enter the initialization vector (IV) in hexadecimal (16 characters): ").strip()
-    brute_force_des(ciphertext_base64, iv_hex)
+    # Configure colored logging
+    configure_logging()
+    
+    # Input the encrypted text as a hex string
+    ciphertext_hex = input("Enter the DES-encrypted text (Hex, including IV): ").strip()
+    
+    # Optionally provide a debug key
+    debug_key = input("Enter a debug key in hex (or press Enter to skip): ").strip()
+    if not debug_key:
+        debug_key = None
+    
+    # Define the expected plaintext
+    expected_plaintext = "Test"
+    
+    # Call brute-force decryption
+    result = brute_force_des(ciphertext_hex, expected_plaintext, debug_key)
+    
+    if result:
+        logging.info(f"Decrypted text: {result}")
+    else:
+        logging.error("Failed to decrypt the ciphertext.")
 
 if __name__ == "__main__":
     main()
\ No newline at end of file

decryption/rc4_128.py

 import logging
 from Crypto.Cipher import ARC4
 import itertools
-import base64
-from logger import setup_logging  # Import logging configuration
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'setup')))
+from custom_logging import configure_logging
 
-def brute_force_rc4_128(ciphertext_base64):
-    ciphertext = base64.b64decode(ciphertext_base64)
+# Brute-force attack on RC4 encryption (128-bit key)
+def brute_force_rc4(ciphertext_hex, expected_plaintext, debug_key=None):
+    # Convert the hex string to bytes
+    ciphertext = bytes.fromhex(ciphertext_hex)
     
-    logging.info("Starting brute-force for RC4 (128-bit key)...")
-    for key in itertools.product(range(256), repeat=16):  # 128-bit key
+    logging.info("Starting brute-force for RC4 with 128-bit keys...")
+    
+    # Optional debug key
+    if debug_key:
+        try:
+            key = bytes.fromhex(debug_key)
+            cipher = ARC4.new(key)
+            plaintext = cipher.decrypt(ciphertext)
+            if plaintext.decode() == expected_plaintext:
+                logging.info(f"Decrypted successfully: {plaintext.decode()} with debug key {key.hex()}")
+                return plaintext.decode()
+            else:
+                logging.warning("Debug key provided but failed to match the expected plaintext.")
+        except Exception as e:
+            logging.error(f"Error with debug key: {e}")
+    
+    # Brute-force key generation: all possible 16-byte keys (128 bits)
+    for key in itertools.product(range(256), repeat=16):
         key = bytes(key)
         try:
+            # Decrypt with the generated key
             cipher = ARC4.new(key)
             plaintext = cipher.decrypt(ciphertext)
-            logging.info(f"Decrypted successfully: {plaintext.decode()} with key {key.hex()}")
-            return plaintext.decode()
+            
+            # Check if the decrypted text matches the expected plaintext
+            if plaintext.decode() == expected_plaintext:
+                logging.info(f"Decrypted successfully: {plaintext.decode()} with key {key.hex()}")
+                return plaintext.decode()
         except Exception:
             continue
+        
     logging.error("No matching key found.")
     return None
 
 def main():
-    setup_logging()  # Set up logging
-    ciphertext_base64 = input("Enter the RC4-encrypted text (Base64): ").strip()
-    brute_force_rc4_128(ciphertext_base64)
+    # Configure colored logging
+    configure_logging()
+    
+    # Input the encrypted text as a hex string
+    ciphertext_hex = input("Enter the RC4-encrypted text (Hex): ").strip()
+    
+    # Optionally provide a debug key
+    debug_key = input("Enter a debug key in hex (or press Enter to skip): ").strip()
+    if not debug_key:
+        debug_key = None
+    
+    # Define the expected plaintext
+    expected_plaintext = "Test"
+    
+    # Call brute-force decryption
+    result = brute_force_rc4(ciphertext_hex, expected_plaintext, debug_key)
+    
+    if result:
+        logging.info(f"Decrypted text: {result}")
+    else:
+        logging.error("Failed to decrypt the ciphertext.")
 
 if __name__ == "__main__":
-    main()
+    main()
\ No newline at end of file

decryption/rc4_64.py

 import logging
 from Crypto.Cipher import ARC4
 import itertools
-import base64
-from logger import setup_logging  # Import logging configuration
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'setup')))
+from custom_logging import configure_logging
 
-def brute_force_rc4(ciphertext_base64):
-    ciphertext = base64.b64decode(ciphertext_base64)
+# Brute-force attack on RC4 encryption (64-bit key)
+def brute_force_rc4(ciphertext_hex, expected_plaintext, debug_key=None):
+    # Convert the hex string to bytes
+    ciphertext = bytes.fromhex(ciphertext_hex)
     
-    logging.info("Starting brute-force for RC4 (64-bit key)...")
-    for key in itertools.product(range(256), repeat=8):  # 64-bit key
+    logging.info("Starting brute-force for RC4 with 64-bit keys...")
+    
+    # Optional debug key
+    if debug_key:
+        try:
+            key = bytes.fromhex(debug_key)
+            cipher = ARC4.new(key)
+            plaintext = cipher.decrypt(ciphertext)
+            if plaintext.decode() == expected_plaintext:
+                logging.info(f"Decrypted successfully: {plaintext.decode()} with debug key {key.hex()}")
+                return plaintext.decode()
+            else:
+                logging.warning("Debug key provided but failed to match the expected plaintext.")
+        except Exception as e:
+            logging.error(f"Error with debug key: {e}")
+    
+    # Brute-force key generation: all possible 8-byte keys (64 bits)
+    for key in itertools.product(range(256), repeat=8):
         key = bytes(key)
         try:
+            # Decrypt with the generated key
             cipher = ARC4.new(key)
             plaintext = cipher.decrypt(ciphertext)
-            logging.info(f"Decrypted successfully: {plaintext.decode()} with key {key.hex()}")
-            return plaintext.decode()
+            
+            # Check if the decrypted text matches the expected plaintext
+            if plaintext.decode() == expected_plaintext:
+                logging.info(f"Decrypted successfully: {plaintext.decode()} with key {key.hex()}")
+                return plaintext.decode()
         except Exception:
             continue
+        
     logging.error("No matching key found.")
     return None
 
 def main():
-    setup_logging()  # Set up logging
-    ciphertext_base64 = input("Enter the RC4-encrypted text (Base64): ").strip()
-    brute_force_rc4(ciphertext_base64)
+    # Configure colored logging
+    configure_logging()
+    
+    # Input the encrypted text as a hex string
+    ciphertext_hex = input("Enter the RC4-encrypted text (Hex): ").strip()
+    
+    # Optionally provide a debug key
+    debug_key = input("Enter a debug key in hex (or press Enter to skip): ").strip()
+    if not debug_key:
+        debug_key = None
+    
+    # Define the expected plaintext
+    expected_plaintext = "Test"
+    
+    # Call brute-force decryption
+    result = brute_force_rc4(ciphertext_hex, expected_plaintext, debug_key)
+    
+    if result:
+        logging.info(f"Decrypted text: {result}")
+    else:
+        logging.error("Failed to decrypt the ciphertext.")
 
 if __name__ == "__main__":
-    main()
+    main()
\ No newline at end of file

keys/private.pem

 -----BEGIN RSA PRIVATE KEY-----
-MIIEpAIBAAKCAQEA3rQBwcolop8zkonx/+JsyvWtMGBxdXBNRufBnc5nIF+pKjpc
-BTLTdlZx2K85Xj1Rz1waGOdf78oBECfeOb6ckeLm86JliQlKS9vkEROuxfagO5jz
-2qW/BHuYIbxS0O9vdrShoC8tw+qci1pMsVu7IBLHMO+mJ3NLVCv9HL+fAYRntrpE
-yx+j9HdZqmyJRriWrHCjN1/dnJoUt5dABGXTIny0BlUQJE5CrfP7oGb0fCvzO5Ms
-Sy5/W9rl2O8bZLbbNXJxDoWzsM87YLL7SqUwq2SDZpy6DPO+NW9S3tqplwoI+Cqj
-tId5t9FbZ/eQJXSm2bCUAl8MMToUQp9385ew3wIDAQABAoIBABUoIKqaW6zxVuLq
-+/SFPDSj1kosP1sayhycU8Z8H0vyCo4acTeFNpWdbL9bFiYfyS/b3hbTlEehdyxj
-vTbbJuCtH6exm9fC7C38u9PrfMUNwvcmdrQk3tq8Kx25WFzFAl/SlTA0izJ7jVen
-wnVu833+irHZcn149IUQkME0axSnpBPzlz/fqhqNRh29W3ktwjLKNPZk/yWyQ0ce
-RlPJ5H1QZsRlC8VzfUF7r7ZA+ZeiwBVtZGRgz+8d01+OntFyYrbbXyD9r9N85gNu
-p8k/kx3tZRzXALhmB+TmYyPj2Pk2kAf1pkBfegAlWIYtfbROqY0oq4lxSgbZTeBe
-6rq/DpECgYEA5a77j6iKIDHle54fd/d/kn0KNek1Bt3Xq6/8HVri9jMAGvlGhQRT
-K5rGU5eIDHxznpOEccmev0FSm7o8RER1d2JeX6ZgvWB8j0NuEcy7fPGyU1+yZ5w8
-oEZsMWnt7yZXt2WK3hKHb+1BDgFL3rcnaz+rThUhTsrQiMp1PWumKTMCgYEA+DhH
-Flwci/mHZV3Rf+UBc1hrSgBfvDyau4mjoOQ3706Dv8BWqExWGJjv7i8qE3n9lbKa
-8q693zETKmb77rmTX1Ur/8sfazRqS2Q2Dz31sYaGOx6DIltiphPsrb1Vdg8E/yap
-YomrZvrc6yYdbhaKgRkl5GP0p2/6qUCKe0OyUaUCgYByhIBg7EOSMc6diAVgp0Iw
-I7AHmTMbLVju/VvStxIadutCh68lezaMsyrXWuI2d4aeNib/JOvFqCgsBPsvfoKi
-96TeQ/JP+d+g/pnOvils7oVfFIO7LSb9Mp+XM52yc4egpTxL5SkqIT0iYnsVnHRH
-AQPEdryYsH6w9WDnMtkyCQKBgQCSgNzsRJeQwkl4ucQCIY8WnlRMzCW1O2v0Toum
-Vazx8LxwO7yp/sw+Hl5Wjb3e2vyiE1XC8QIeLp/qQfhmcV+bP/EFO8UiiEBImTAT
-FPXjvsuRLzQk3h0+eroR3ZMIaFsBobcN8sWYtW4Y2Fk8dc9v3QDxaVGoVb5zkSVr
-FYy1BQKBgQCT/MuEAW0G7auTJH9FHhI7HzagHIZPphQi5KGG6N0CnGiTV6J2idgO
-KEQQpcyKAEry6nTl3NjMDpnqOt2e8bOO3Yjtqrs6axQe6Kef/kwRFZhTF4dFXJcB
-Dk4xNAtPKoyzMrxMV1Xz64L5xl8G9VClsHDfRTH9glfqnOle+eUveg==
+MIIEogIBAAKCAQEAxjw3DrDWxWtPLWdyGbNTMMUlDXmR+nFItaifmR9BFnbVVGME
+Xwr6BMrtdDOqPkP544c7HzpIsnTfncs0DLvcc0YGXgst1Yeoh5IugoUj4bU65f/1
+JUaXJniTAPUBOAKLNSweUmzRTeXMbpI5M1Es3ZTBVhFZ10xVPJQu20EkYcPrf7bX
++ALvNackyXfnLd1aUKGPggFwKMcmfiXPFlJZJyr9vUoGepu/LOihVliM8s7dHV+7
+6uqBRx5sKarY2TLq+CzRWOcSH6Jp/EeJXE+ce/mpZuBHMpKhE1NB9fIjYB0qq8Es
+0TD//pTi9d9gA2khcw3rNS9TrTV90i52JDGbRQIDAQABAoIBACnpH6vNs+6TsC71
+hLBN0zwHpjyJ1BTaoAh2EN4G91QYRiR79bfhYngibh8H8EmPRhT2aYfB4w5FuuRJ
+yqSZkDNX3e9Clktjjbwx6f7ixrIIxp3LZmkd2kWCLvRAGGSe1w8kF3oOMxcwyy6i
+YBELK7ziHxkC/JdR9mBjJN/qjxZS/eZ27N3W3oGScMCNnAm4sQoqImpTCHFFNIyf
+UmugShriwrQNEG7lkLpNrAJCgHzYNe4lR00eQ8NALl4FkhLc1hD1HCZMNkqISkyA
+wBOgnbEoY6IgDyIfYrwXLDrTAk8hKxe/nyelrsLCEtmyT2J0errslVed6Pd2q1w+
+ysIqukkCgYEA0bX+zAvF3YCQ4D/1XnQSQcuzjl5uGKhkFc4WyL+BDSUTNxdqtbHS
+1k6XuMvbaMSOfntO8YeW8uzJ9DF50hW7MU6fadgGjeOi3VGveq6mhSpHeYlf7YSS
+VXzIbkaRCCpkM6sstEvhBmKgIYeudn4rnSVn/Swc0PRc4D+nenqbP10CgYEA8f3E
+78+pMt0hWO4kd05Rfscd94XeiNdFzDt+1ixFwuFLsl1bpWMUH5xhoffcyGdPqH0/
+ha6VN7fcjoGutB8Km1ed7d9ZCM4T8OJtg8JKRUJsjyCudQx0hY6lPeUYGHfc2bzY
+6HGjbIlBuGeM8dbL1tsyZzdkTX6qxTbiEfDU1QkCgYAISAOT0zMxGA6gjGYIINVH
+u9+PU7NNTfkF02ma69UQy9ICbu5L1oXY6KmdJo+3h2uJGx129D/FwAwJlJqW7TzD
+KbOp3loD6GVaEAu58IOq5oyEBCTBoGaW8aKImEjJ5cKnN69AP27XbbWdHVqKW1kl
+j4CXwtIwfjXctSbL82OGEQKBgEHI0vi+YyjIpIAgfRlR2SW1y5e2dMCOhRL4OYrP
+jkdkJ8fdSUS0oovVX1VApGx2aVlMczBMPZRgDz1OU8fziFaigvRfezzBiPo7E7p1
+3urlG83s/IAlWqfUF2e0F9DPBOLMS8sk2WBwD8WpoM89rTxDanhUvpeyj4n9WYe3
+CKTBAoGAe6k2o0tCz4tGiPNAhGHRY3i3FLOhUWbKOHMDu2RAoFQTdEjKwuYOpjXN
+3sfWy2wJoz+v2+qrKKKL3nOmjMBLS0r+RkBf4QaNqA9wJ6hikrqsEe6tczazO9Ic
+UzOXV2wexb1i65B6SuNWE1V0ZEL1tyxHnPJwI42qkyXViFw0tyU=
 -----END RSA PRIVATE KEY-----
\ No newline at end of file

keys/public.pem

 -----BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3rQBwcolop8zkonx/+Js
-yvWtMGBxdXBNRufBnc5nIF+pKjpcBTLTdlZx2K85Xj1Rz1waGOdf78oBECfeOb6c
-keLm86JliQlKS9vkEROuxfagO5jz2qW/BHuYIbxS0O9vdrShoC8tw+qci1pMsVu7
-IBLHMO+mJ3NLVCv9HL+fAYRntrpEyx+j9HdZqmyJRriWrHCjN1/dnJoUt5dABGXT
-Iny0BlUQJE5CrfP7oGb0fCvzO5MsSy5/W9rl2O8bZLbbNXJxDoWzsM87YLL7SqUw
-q2SDZpy6DPO+NW9S3tqplwoI+CqjtId5t9FbZ/eQJXSm2bCUAl8MMToUQp9385ew
-3wIDAQAB
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxjw3DrDWxWtPLWdyGbNT
+MMUlDXmR+nFItaifmR9BFnbVVGMEXwr6BMrtdDOqPkP544c7HzpIsnTfncs0DLvc
+c0YGXgst1Yeoh5IugoUj4bU65f/1JUaXJniTAPUBOAKLNSweUmzRTeXMbpI5M1Es
+3ZTBVhFZ10xVPJQu20EkYcPrf7bX+ALvNackyXfnLd1aUKGPggFwKMcmfiXPFlJZ
+Jyr9vUoGepu/LOihVliM8s7dHV+76uqBRx5sKarY2TLq+CzRWOcSH6Jp/EeJXE+c
+e/mpZuBHMpKhE1NB9fIjYB0qq8Es0TD//pTi9d9gA2khcw3rNS9TrTV90i52JDGb
+RQIDAQAB
 -----END PUBLIC KEY-----
\ No newline at end of file

keys/generateKeys.py → setup/generate_keys.py

@@ -7,10 +7,10 @@ def main():
     public_key = private_key.publickey()
     
     # Save as files
-    with open('private.pem', 'wb') as private_file:
+    with open('../keys/private.pem', 'wb') as private_file:
         private_file.write(private_key.export_key())
     
-    with open('public.pem', 'wb') as public_file:
+    with open('../keys/public.pem', 'wb') as public_file:
         public_file.write(public_key.export_key())
         
     print("RSA-keys generated and saved.")