diff --git a/scripts/client.c b/communication/client.c
similarity index 96%
rename from scripts/client.c
rename to communication/client.c
index 02d6ed0e3b1dd3be136ae57a976685545ad0a9fa..84efafe016c9e78126b643e79002d7b5397949ca 100644
--- a/scripts/client.c
+++ b/communication/client.c
@@ -1,157 +1,157 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <wolfssl/ssl.h>
-#include <wolfssl/wolfcrypt/error-crypt.h>
-#include <wolfssl/openssl/err.h>
-#include <unistd.h>
-#include <arpa/inet.h>
-
-#define CERT_FILE "../certificates/ca-cert.pem"
-#define SERVER_IP "192.168.178.51" // Die IP-Adresse des Servers
-#define PORT 5000
-#define BUFFER_SIZE 1024
-
-void initWolfSSL() {
- wolfSSL_Init(); // Initialize WolfSSL library
-}
-
-void cleanupWolfSSL() {
- wolfSSL_Cleanup(); // Cleanup WolfSSL library
-}
-
-int createClientSocket(const char *server_ip, int port) {
- int client_fd;
- struct sockaddr_in server_addr;
-
- if ((client_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
- perror("Socket creation failed");
- exit(EXIT_FAILURE);
- }
-
- memset(&server_addr, 0, sizeof(server_addr));
- server_addr.sin_family = AF_INET;
- server_addr.sin_port = htons(port);
- if (inet_pton(AF_INET, server_ip, &server_addr.sin_addr) <= 0) {
- perror("Invalid server IP address");
- close(client_fd);
- exit(EXIT_FAILURE);
- }
-
- if (connect(client_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
- perror("Connection failed");
- close(client_fd);
- exit(EXIT_FAILURE);
- }
-
- return client_fd;
-}
-
-int main() {
- // Verschlüsselungsalgorithmus auswählen (AES, RSA, etc.)
- int choice;
- printf("Wählen Sie den Verschlüsselungsalgorithmus:\n");
- printf("1. TLSv1.2 mit AES\n");
- printf("2. TLSv1.3\n");
- printf("Geben Sie Ihre Wahl ein (1 oder 2): ");
- scanf("%d", &choice);
-
- // Initialize WolfSSL
- initWolfSSL();
-
- // Konfiguration des Verschlüsselungsalgorithmus
- const WOLFSSL_METHOD *method; // Korrekte Methode für WolfSSL
- if (choice == 1) {
- method = wolfTLSv1_2_client_method(); // TLSv1.2
- } else {
- method = wolfTLSv1_3_client_method(); // TLSv1.3
- }
-
- // Load CA certificate
- WOLFSSL_CTX *ctx = wolfSSL_CTX_new(method);
- if (ctx == NULL) {
- printf("Failed to create SSL context\n");
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- if (wolfSSL_CTX_load_verify_locations(ctx, CERT_FILE, NULL) != SSL_SUCCESS) {
- printf("Failed to load CA certificate\n");
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- // Create client socket
- int client_fd = createClientSocket(SERVER_IP, PORT);
-
- // Create SSL object
- WOLFSSL *ssl = wolfSSL_new(ctx);
- if (ssl == NULL) {
- printf("Failed to create SSL object\n");
- close(client_fd);
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- // Associate socket with SSL object
- if (wolfSSL_set_fd(ssl, client_fd) != SSL_SUCCESS) {
- printf("Failed to associate socket with SSL object\n");
- wolfSSL_free(ssl);
- close(client_fd);
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- // Perform TLS handshake
- if (wolfSSL_connect(ssl) != SSL_SUCCESS) {
- printf("SSL handshake failed\n");
- wolfSSL_free(ssl);
- close(client_fd);
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- printf("Connected to the server!\n");
-
- // Open the file to send
- const char *file_path = "../testData/test.txt";
- FILE *file = fopen(file_path, "rb");
- if (file == NULL) {
- perror("Failed to open file");
- wolfSSL_free(ssl);
- close(client_fd);
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- // Send file in chunks
- char buffer[BUFFER_SIZE];
- size_t bytes_read;
- while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
- if (wolfSSL_write(ssl, buffer, bytes_read) != bytes_read) {
- printf("Error sending file\n");
- fclose(file);
- wolfSSL_free(ssl);
- close(client_fd);
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
- }
-
- printf("File '%s' successfully sent to the server.\n", file_path);
-
- // Clean up
- fclose(file);
- wolfSSL_free(ssl);
- close(client_fd);
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
-
- return 0;
-}
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wolfssl/ssl.h>
+#include <wolfssl/wolfcrypt/error-crypt.h>
+#include <wolfssl/openssl/err.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+
+#define CERT_FILE "../certificates/ca-cert.pem"
+#define SERVER_IP "192.168.178.51" // Die IP-Adresse des Servers
+#define PORT 5000
+#define BUFFER_SIZE 1024
+
+void initWolfSSL() {
+ wolfSSL_Init(); // Initialize WolfSSL library
+}
+
+void cleanupWolfSSL() {
+ wolfSSL_Cleanup(); // Cleanup WolfSSL library
+}
+
+int createClientSocket(const char *server_ip, int port) {
+ int client_fd;
+ struct sockaddr_in server_addr;
+
+ if ((client_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
+ perror("Socket creation failed");
+ exit(EXIT_FAILURE);
+ }
+
+ memset(&server_addr, 0, sizeof(server_addr));
+ server_addr.sin_family = AF_INET;
+ server_addr.sin_port = htons(port);
+ if (inet_pton(AF_INET, server_ip, &server_addr.sin_addr) <= 0) {
+ perror("Invalid server IP address");
+ close(client_fd);
+ exit(EXIT_FAILURE);
+ }
+
+ if (connect(client_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
+ perror("Connection failed");
+ close(client_fd);
+ exit(EXIT_FAILURE);
+ }
+
+ return client_fd;
+}
+
+int main() {
+ // Verschlüsselungsalgorithmus auswählen (AES, RSA, etc.)
+ int choice;
+ printf("Wählen Sie den Verschlüsselungsalgorithmus:\n");
+ printf("1. TLSv1.2 mit AES\n");
+ printf("2. TLSv1.3\n");
+ printf("Geben Sie Ihre Wahl ein (1 oder 2): ");
+ scanf("%d", &choice);
+
+ // Initialize WolfSSL
+ initWolfSSL();
+
+ // Konfiguration des Verschlüsselungsalgorithmus
+ const WOLFSSL_METHOD *method; // Korrekte Methode für WolfSSL
+ if (choice == 1) {
+ method = wolfTLSv1_2_client_method(); // TLSv1.2
+ } else {
+ method = wolfTLSv1_3_client_method(); // TLSv1.3
+ }
+
+ // Load CA certificate
+ WOLFSSL_CTX *ctx = wolfSSL_CTX_new(method);
+ if (ctx == NULL) {
+ printf("Failed to create SSL context\n");
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ if (wolfSSL_CTX_load_verify_locations(ctx, CERT_FILE, NULL) != SSL_SUCCESS) {
+ printf("Failed to load CA certificate\n");
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ // Create client socket
+ int client_fd = createClientSocket(SERVER_IP, PORT);
+
+ // Create SSL object
+ WOLFSSL *ssl = wolfSSL_new(ctx);
+ if (ssl == NULL) {
+ printf("Failed to create SSL object\n");
+ close(client_fd);
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ // Associate socket with SSL object
+ if (wolfSSL_set_fd(ssl, client_fd) != SSL_SUCCESS) {
+ printf("Failed to associate socket with SSL object\n");
+ wolfSSL_free(ssl);
+ close(client_fd);
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ // Perform TLS handshake
+ if (wolfSSL_connect(ssl) != SSL_SUCCESS) {
+ printf("SSL handshake failed\n");
+ wolfSSL_free(ssl);
+ close(client_fd);
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ printf("Connected to the server!\n");
+
+ // Open the file to send
+ const char *file_path = "../testData/test.txt";
+ FILE *file = fopen(file_path, "rb");
+ if (file == NULL) {
+ perror("Failed to open file");
+ wolfSSL_free(ssl);
+ close(client_fd);
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ // Send file in chunks
+ char buffer[BUFFER_SIZE];
+ size_t bytes_read;
+ while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
+ if (wolfSSL_write(ssl, buffer, bytes_read) != bytes_read) {
+ printf("Error sending file\n");
+ fclose(file);
+ wolfSSL_free(ssl);
+ close(client_fd);
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ printf("File '%s' successfully sent to the server.\n", file_path);
+
+ // Clean up
+ fclose(file);
+ wolfSSL_free(ssl);
+ close(client_fd);
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+
+ return 0;
+}
diff --git a/scripts/client.py b/communication/client.py
similarity index 100%
rename from scripts/client.py
rename to communication/client.py
diff --git a/scripts/server.c b/communication/server.c
similarity index 96%
rename from scripts/server.c
rename to communication/server.c
index 6906d30babb47c2e7d6162dd179e6765c4074041..71135641c9b036ff16f61fc3c8fd884d51fac1e9 100644
--- a/scripts/server.c
+++ b/communication/server.c
@@ -1,179 +1,179 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <wolfssl/ssl.h>
-#include <wolfssl/wolfcrypt/error-crypt.h>
-#include <wolfssl/openssl/err.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <unistd.h>
-
-#define CERT_FILE "../certificates/server-cert.pem"
-#define KEY_FILE "../certificates/server-key.pem"
-#define PORT 5000
-#define BUFFER_SIZE 1024
-
-void initWolfSSL() {
- wolfSSL_Init(); // Initialize WolfSSL library
-}
-
-void cleanupWolfSSL() {
- wolfSSL_Cleanup(); // Cleanup WolfSSL library
-}
-
-int createServerSocket(int port) {
- int server_fd;
- struct sockaddr_in server_addr;
-
- if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
- perror("Socket creation failed");
- exit(EXIT_FAILURE);
- }
-
- memset(&server_addr, 0, sizeof(server_addr));
- server_addr.sin_family = AF_INET;
- server_addr.sin_addr.s_addr = INADDR_ANY;
- server_addr.sin_port = htons(port);
-
- if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
- perror("Binding failed");
- close(server_fd);
- exit(EXIT_FAILURE);
- }
-
- if (listen(server_fd, 1) == -1) {
- perror("Listening failed");
- close(server_fd);
- exit(EXIT_FAILURE);
- }
-
- printf("Server is listening on port %d...\n", port);
- return server_fd;
-}
-
-int main() {
- // Verschlüsselungsalgorithmus auswählen (AES, RSA, etc.)
- int choice;
- printf("Wählen Sie den Verschlüsselungsalgorithmus:\n");
- printf("1. TLSv1.2 mit AES\n");
- printf("2. TLSv1.3\n");
- printf("Geben Sie Ihre Wahl ein (1 oder 2): ");
- scanf("%d", &choice);
-
- // Initialize WolfSSL
- initWolfSSL();
-
- // Create server socket
- int server_fd = createServerSocket(PORT);
-
- // Konfiguration des Verschlüsselungsalgorithmus
- const WOLFSSL_METHOD *method; // Korrekte Methode für WolfSSL
- if (choice == 1) {
- method = wolfTLSv1_2_client_method(); // TLSv1.2
- } else {
- method = wolfTLSv1_3_client_method(); // TLSv1.3
- }
-
- // SSL-Kontext erstellen
- WOLFSSL_CTX *ctx = wolfSSL_CTX_new(method);
- if (ctx == NULL) {
- printf("Failed to create SSL context\n");
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- if (wolfSSL_CTX_use_certificate_file(ctx, CERT_FILE, SSL_FILETYPE_PEM) != SSL_SUCCESS) {
- printf("Failed to load certificate\n");
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- if (wolfSSL_CTX_use_PrivateKey_file(ctx, KEY_FILE, SSL_FILETYPE_PEM) != SSL_SUCCESS) {
- printf("Failed to load private key\n");
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- // Accept client connection
- int client_fd = accept(server_fd, NULL, NULL);
- if (client_fd == -1) {
- perror("Accept failed");
- close(server_fd);
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- // Create SSL object
- WOLFSSL *ssl = wolfSSL_new(ctx);
- if (ssl == NULL) {
- printf("Failed to create SSL object\n");
- close(client_fd);
- close(server_fd);
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- // Associate socket with SSL object
- if (wolfSSL_set_fd(ssl, client_fd) != SSL_SUCCESS) {
- printf("Failed to associate socket with SSL object\n");
- wolfSSL_free(ssl);
- close(client_fd);
- close(server_fd);
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- // Perform TLS handshake
- if (wolfSSL_accept(ssl) != SSL_SUCCESS) {
- printf("SSL handshake failed\n");
- wolfSSL_free(ssl);
- close(client_fd);
- close(server_fd);
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- printf("TLS handshake completed successfully\n");
-
- // Receive file data
- FILE *file = fopen("received_file.txt", "wb");
- if (file == NULL) {
- perror("File open failed");
- wolfSSL_free(ssl);
- close(client_fd);
- close(server_fd);
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
- exit(EXIT_FAILURE);
- }
-
- char buffer[BUFFER_SIZE];
- int bytes_received;
- while ((bytes_received = wolfSSL_read(ssl, buffer, sizeof(buffer))) > 0) {
- fwrite(buffer, 1, bytes_received, file);
- }
-
- if (bytes_received < 0) {
- printf("Error receiving file\n");
- } else {
- printf("File successfully received and saved as 'received_file.txt'\n");
- }
-
- fclose(file);
-
- // Clean up
- wolfSSL_free(ssl);
- close(client_fd);
- close(server_fd);
- wolfSSL_CTX_free(ctx);
- cleanupWolfSSL();
-
- return 0;
-}
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wolfssl/ssl.h>
+#include <wolfssl/wolfcrypt/error-crypt.h>
+#include <wolfssl/openssl/err.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <unistd.h>
+
+#define CERT_FILE "../certificates/server-cert.pem"
+#define KEY_FILE "../certificates/server-key.pem"
+#define PORT 5000
+#define BUFFER_SIZE 1024
+
+void initWolfSSL() {
+ wolfSSL_Init(); // Initialize WolfSSL library
+}
+
+void cleanupWolfSSL() {
+ wolfSSL_Cleanup(); // Cleanup WolfSSL library
+}
+
+int createServerSocket(int port) {
+ int server_fd;
+ struct sockaddr_in server_addr;
+
+ if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
+ perror("Socket creation failed");
+ exit(EXIT_FAILURE);
+ }
+
+ memset(&server_addr, 0, sizeof(server_addr));
+ server_addr.sin_family = AF_INET;
+ server_addr.sin_addr.s_addr = INADDR_ANY;
+ server_addr.sin_port = htons(port);
+
+ if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
+ perror("Binding failed");
+ close(server_fd);
+ exit(EXIT_FAILURE);
+ }
+
+ if (listen(server_fd, 1) == -1) {
+ perror("Listening failed");
+ close(server_fd);
+ exit(EXIT_FAILURE);
+ }
+
+ printf("Server is listening on port %d...\n", port);
+ return server_fd;
+}
+
+int main() {
+ // Verschlüsselungsalgorithmus auswählen (AES, RSA, etc.)
+ int choice;
+ printf("Wählen Sie den Verschlüsselungsalgorithmus:\n");
+ printf("1. TLSv1.2 mit AES\n");
+ printf("2. TLSv1.3\n");
+ printf("Geben Sie Ihre Wahl ein (1 oder 2): ");
+ scanf("%d", &choice);
+
+ // Initialize WolfSSL
+ initWolfSSL();
+
+ // Create server socket
+ int server_fd = createServerSocket(PORT);
+
+ // Konfiguration des Verschlüsselungsalgorithmus
+ const WOLFSSL_METHOD *method; // Korrekte Methode für WolfSSL
+ if (choice == 1) {
+ method = wolfTLSv1_2_client_method(); // TLSv1.2
+ } else {
+ method = wolfTLSv1_3_client_method(); // TLSv1.3
+ }
+
+ // SSL-Kontext erstellen
+ WOLFSSL_CTX *ctx = wolfSSL_CTX_new(method);
+ if (ctx == NULL) {
+ printf("Failed to create SSL context\n");
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ if (wolfSSL_CTX_use_certificate_file(ctx, CERT_FILE, SSL_FILETYPE_PEM) != SSL_SUCCESS) {
+ printf("Failed to load certificate\n");
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ if (wolfSSL_CTX_use_PrivateKey_file(ctx, KEY_FILE, SSL_FILETYPE_PEM) != SSL_SUCCESS) {
+ printf("Failed to load private key\n");
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ // Accept client connection
+ int client_fd = accept(server_fd, NULL, NULL);
+ if (client_fd == -1) {
+ perror("Accept failed");
+ close(server_fd);
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ // Create SSL object
+ WOLFSSL *ssl = wolfSSL_new(ctx);
+ if (ssl == NULL) {
+ printf("Failed to create SSL object\n");
+ close(client_fd);
+ close(server_fd);
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ // Associate socket with SSL object
+ if (wolfSSL_set_fd(ssl, client_fd) != SSL_SUCCESS) {
+ printf("Failed to associate socket with SSL object\n");
+ wolfSSL_free(ssl);
+ close(client_fd);
+ close(server_fd);
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ // Perform TLS handshake
+ if (wolfSSL_accept(ssl) != SSL_SUCCESS) {
+ printf("SSL handshake failed\n");
+ wolfSSL_free(ssl);
+ close(client_fd);
+ close(server_fd);
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ printf("TLS handshake completed successfully\n");
+
+ // Receive file data
+ FILE *file = fopen("received_file.txt", "wb");
+ if (file == NULL) {
+ perror("File open failed");
+ wolfSSL_free(ssl);
+ close(client_fd);
+ close(server_fd);
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+ exit(EXIT_FAILURE);
+ }
+
+ char buffer[BUFFER_SIZE];
+ int bytes_received;
+ while ((bytes_received = wolfSSL_read(ssl, buffer, sizeof(buffer))) > 0) {
+ fwrite(buffer, 1, bytes_received, file);
+ }
+
+ if (bytes_received < 0) {
+ printf("Error receiving file\n");
+ } else {
+ printf("File successfully received and saved as 'received_file.txt'\n");
+ }
+
+ fclose(file);
+
+ // Clean up
+ wolfSSL_free(ssl);
+ close(client_fd);
+ close(server_fd);
+ wolfSSL_CTX_free(ctx);
+ cleanupWolfSSL();
+
+ return 0;
+}
diff --git a/scripts/server.py b/communication/server.py
similarity index 100%
rename from scripts/server.py
rename to communication/server.py
diff --git a/decryption/3des.py b/decryption/3des.py
new file mode 100644
index 0000000000000000000000000000000000000000..443b73d350f113a68e76382bbd87256e54dd5803
--- /dev/null
+++ b/decryption/3des.py
@@ -0,0 +1,32 @@
+from Crypto.Cipher import DES3
+from itertools import product
+
+# Verschlüsselten Datenstrom laden
+with open('encrypted_file_3des.bin', 'rb') as f:
+ ciphertext = f.read()
+
+start_time = time.time() # Startzeit
+# Brute-Force-Funktion für 3DES
+def brute_force_3des(ciphertext):
+ key_space = (b''.join(k) for k in product(b'abc123', repeat=8)) # Demo: Schlüsselraum für 3DES
+ target_pattern = b"Das ist eine Text-Datei!" # Gesuchter Inhalt
+ for key in key_space:
+ try:
+ cipher = DES3.new(key, DES3.MODE_ECB)
+ plaintext = cipher.decrypt(ciphertext)
+ if target_pattern in plaintext: # Überprüfung des entschlüsselten Inhalts
+ print(f"Schlüssel gefunden: {key}")
+ print(f"Entschlüsselter Inhalt: {plaintext}")
+ return plaintext
+ except Exception as e:
+ continue
+
+end_time = time.time()
+plaintext = brute_force_3des(ciphertext)
+if plaintext:
+ print("Datei erfolgreich entschlüsselt!")
+else:
+ print("Kein gültiger Schlüssel gefunden.")
+
+duration = end_time - start_time
+print(f"Dauer des Angriffs: {duration:.2f} Sekunden")
\ No newline at end of file
diff --git a/decryption/blowfish.py b/decryption/blowfish.py
new file mode 100644
index 0000000000000000000000000000000000000000..0600f9f9567d7bc7d8b844cbbdb5eca741c794d2
--- /dev/null
+++ b/decryption/blowfish.py
@@ -0,0 +1,32 @@
+from Crypto.Cipher import Blowfish
+from itertools import product
+
+# Verschlüsselten Datenstrom laden
+with open('encrypted_file_blowfish.bin', 'rb') as f:
+ ciphertext = f.read()
+
+start_time = time.time() # Startzeit
+# Brute-Force-Funktion für Blowfish
+def brute_force_blowfish(ciphertext):
+ key_space = (b''.join(k) for k in product(b'abc123', repeat=4)) # Demo: Schlüsselraum für 32-Bit
+ target_pattern = b"Das ist eine Text-Datei!" # Gesuchter Inhalt
+ for key in key_space:
+ try:
+ cipher = Blowfish.new(key, Blowfish.MODE_ECB)
+ plaintext = cipher.decrypt(ciphertext)
+ if target_pattern in plaintext: # Überprüfung des entschlüsselten Inhalts
+ print(f"Schlüssel gefunden: {key}")
+ print(f"Entschlüsselter Inhalt: {plaintext}")
+ return plaintext
+ except Exception as e:
+ continue
+
+end_time = time.time()
+plaintext = brute_force_blowfish(ciphertext)
+if plaintext:
+ print("Datei erfolgreich entschlüsselt!")
+else:
+ print("Kein gültiger Schlüssel gefunden.")
+
+duration = end_time - start_time
+print(f"Dauer des Angriffs: {duration:.2f} Sekunden")
\ No newline at end of file
diff --git a/decryption/camellia.py b/decryption/camellia.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae8ae0ee84eb51cf8941cff88fd32f32efcfbb20
--- /dev/null
+++ b/decryption/camellia.py
@@ -0,0 +1,33 @@
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+import itertools
+
+# Verschlüsselten Datenstrom laden
+with open('encrypted_file_camellia.bin', 'rb') as f:
+ ciphertext = f.read()
+
+start_time = time.time() # Startzeit
+# Brute-Force-Funktion für Camellia
+def brute_force_camellia(ciphertext):
+ key_space = (bytes([k]) for k in range(2**8)) # 8-Bit Schlüsselraum zur Demo
+ target_pattern = b"Das ist eine Text-Datei!" # Gesuchter Inhalt
+ for key in key_space:
+ try:
+ cipher = Cipher(algorithms.Camellia(key.ljust(16, b'\0')), modes.ECB())
+ decryptor = cipher.decryptor()
+ plaintext = decryptor.update(ciphertext)
+ if target_pattern in plaintext: # Überprüfung des entschlüsselten Inhalts
+ print(f"Schlüssel gefunden: {key}")
+ print(f"Entschlüsselter Inhalt: {plaintext}")
+ return plaintext
+ except Exception as e:
+ continue
+
+end_time = time.time()
+plaintext = brute_force_camellia(ciphertext)
+if plaintext:
+ print("Datei erfolgreich entschlüsselt!")
+else:
+ print("Kein gültiger Schlüssel gefunden.")
+
+duration = end_time - start_time
+print(f"Dauer des Angriffs: {duration:.2f} Sekunden")
\ No newline at end of file
diff --git a/decryption/rc4.py b/decryption/rc4.py
new file mode 100644
index 0000000000000000000000000000000000000000..efb6e80144e32395bc9970792e45a5c8fa4b9c58
--- /dev/null
+++ b/decryption/rc4.py
@@ -0,0 +1,33 @@
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms
+import itertools
+
+# Verschlüsselten Datenstrom laden
+with open('encrypted_file_rc4.bin', 'rb') as f:
+ ciphertext = f.read()
+
+start_time = time.time() # Startzeit
+# Brute-Force-Funktion für RC4
+def brute_force_rc4(ciphertext):
+ key_space = (bytes([k]) for k in range(2**8)) # 8-Bit Schlüsselraum zur Demo
+ target_pattern = b"Das ist eine Text-Datei!" # Gesuchter Inhalt
+ for key in key_space:
+ try:
+ cipher = Cipher(algorithms.ARC4(key), mode=None)
+ decryptor = cipher.decryptor()
+ plaintext = decryptor.update(ciphertext)
+ if target_pattern in plaintext: # Überprüfung des entschlüsselten Inhalts
+ print(f"Schlüssel gefunden: {key}")
+ print(f"Entschlüsselter Inhalt: {plaintext}")
+ return plaintext
+ except Exception as e:
+ continue
+
+end_time = time.time()
+plaintext = brute_force_rc4(ciphertext)
+if plaintext:
+ print("Datei erfolgreich entschlüsselt!")
+else:
+ print("Kein gültiger Schlüssel gefunden.")
+
+duration = end_time - start_time
+print(f"Dauer des Angriffs: {duration:.2f} Sekunden")
\ No newline at end of file