1 files changed, 102 insertions, 67 deletions

diff --git a/crypt/hybridcrypt.cpp b/crypt/hybridcrypt.cpp
index 9c236cb..0d56038 100644
--- a/crypt/hybridcrypt.cpp
+++ b/crypt/hybridcrypt.cpp
@@ -52,41 +52,44 @@ void HybridCrypt::decrypt(QString infileName, QString outfileName)
 
 void HybridCrypt::createKeypair()
 {
-    if (isCsprngSeeded())
-    {
-        // Räume den alten Schlüssel vorher ab
-        freeEvpKey(&userKeypair);
+    throwExceptionIfCsprngIsNotSeeded();
 
-        // Lege Schlüsselkontextvariable an
-        EVP_PKEY_CTX *ctx = NULL;
+    // Räume den alten Schlüssel vorher ab
+    freeEvpKey(&userKeypair);
 
-        // Erzeuge den Schlüsselkontext
-        if (!(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)))
-        {
-            throwOpenSslException();
-        }
+    // Lege Schlüsselkontextvariable an
+    EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
 
-        // Initialisiere den Schlüsselgenerator
-        if (EVP_PKEY_keygen_init(ctx) <= 0)
-        {
-            throwOpenSslException();
-        }
+    // Erzeuge den Schlüsselkontext
+    if (!ctx)
+    {
+        throwOpenSslException();
+    }
 
-        // Lege den Schlüssel mit 2048 Bit an
-        if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048) <= 0)
-        {
-            throwOpenSslException();
-        }
+    // Initialisiere den Schlüsselgenerator
+    if (EVP_PKEY_keygen_init(ctx) <= 0)
+    {
+        freePkeyCtx(&ctx);
+        throwOpenSslException();
+    }
 
-        // Erzeuge den Schlüssel
-        if (EVP_PKEY_keygen(ctx, &userKeypair) <= 0)
-        {
-            throwOpenSslException();
-        }
+    // Lege den Schlüssel mit 2048 Bit an
+    if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048) <= 0)
+    {
+        freePkeyCtx(&ctx);
+        throwOpenSslException();
+    }
 
-        // Räume den Schlüsselkontext ab
-        EVP_PKEY_CTX_free(ctx);
+    // Erzeuge den Schlüssel
+    if (EVP_PKEY_keygen(ctx, &userKeypair) <= 0)
+    {
+        freePkeyCtx(&ctx);
+        throwOpenSslException();
     }
+
+    // Räume den Schlüsselkontext ab
+    freePkeyCtx(&ctx);
+
 }
 
 void HybridCrypt::importUserKeypair(QString keyfileName, QString password)
@@ -99,7 +102,8 @@ void HybridCrypt::importUserKeypair(QString keyfileName, QString password)
     // Datei existiert nicht
     if (keyfile == NULL)
     {
-        throw CryptException("Datei nicht gefunden: " + keyfileName.toStdString(), CryptException::FileNotFound);
+        throw CryptException("Datei nicht gefunden: " + keyfileName.toStdString(),
+                             CryptException::FileNotFound);
     }
 
     // Ließ den Schlüssel des Nutzers ein
@@ -121,56 +125,56 @@ void HybridCrypt::importUserKeypair(QString keyfileName, QString password)
 
 void HybridCrypt::exportUserKeypair(QString keyfileName, QString password)
 {
-    if (userKeypair != NULL && isCsprngSeeded())
-    {
-        FILE *keyfile = fopen(keyfileName.toStdString().c_str(), "w+");
+    throwExceptionIfCsprngIsNotSeeded();
+
+    throwExceptionIfUserKeyIsNull();
 
-        // Teste, ob die Datei zum Schreiben geöffnet werden konnte
-        if (keyfile == NULL)
-        {
-            throw CryptException("Konnte Datei nicht schreiben: " +
-                                 keyfileName.toStdString(), CryptException::FileNotWritable);
-        }
+    FILE *keyfile = fopen(keyfileName.toStdString().c_str(), "w+");
 
-        // Wenn password ein Leerstring ist, verschlüssele den privaten Schlüssel nicht
-        int opensslReturnError = PEM_write_PKCS8PrivateKey(keyfile, userKeypair,
-                                 (password.isEmpty()) ? NULL : EVP_aes_256_cbc(), NULL, 0, NULL,
-                                 (void *) password.toStdString().c_str());
+    // Teste, ob die Datei zum Schreiben geöffnet werden konnte
+    if (keyfile == NULL)
+    {
+        throw CryptException("Konnte Datei nicht schreiben: " +
+                             keyfileName.toStdString(), CryptException::FileNotWritable);
+    }
 
-        // Räume die Ressourcen auf
-        fclose(keyfile);
+    // Wenn password ein Leerstring ist, verschlüssele den privaten Schlüssel nicht
+    int opensslReturnError = PEM_write_PKCS8PrivateKey(keyfile, userKeypair,
+                             (password.isEmpty()) ? NULL : EVP_aes_256_cbc(), NULL, 0, NULL,
+                             (void *) password.toStdString().c_str());
 
-        // Wirf einen Fehler, falls OpenSSL ein Problem hatte
-        if (!opensslReturnError)
-        {
-            throwOpenSslException();
-        }
+    // Räume die Ressourcen auf
+    fclose(keyfile);
+
+    // Wirf einen Fehler, falls OpenSSL ein Problem hatte
+    if (!opensslReturnError)
+    {
+        throwOpenSslException();
     }
 }
 
 void HybridCrypt::exportPublicUserKey(QString keyfileName)
 {
-    if (userKeypair != NULL)
-    {
-        FILE *keyfile = fopen(keyfileName.toStdString().c_str(), "w+");
+    throwExceptionIfUserKeyIsNull();
 
-        // Teste, ob die Datei zum Schreiben geöffnet werden konnte
-        if (keyfile == NULL)
-        {
-            throw CryptException("Konnte Datei nicht schreiben: " +
-                                 keyfileName.toStdString(), CryptException::FileNotWritable);
-        }
+    FILE *keyfile = fopen(keyfileName.toStdString().c_str(), "w+");
 
-        int opensslReturnError = PEM_write_PUBKEY(keyfile, userKeypair);
+    // Teste, ob die Datei zum Schreiben geöffnet werden konnte
+    if (keyfile == NULL)
+    {
+        throw CryptException("Konnte Datei nicht schreiben: " +
+                             keyfileName.toStdString(), CryptException::FileNotWritable);
+    }
 
-        // Räume die Ressourcen auf
-        fclose(keyfile);
+    int opensslReturnError = PEM_write_PUBKEY(keyfile, userKeypair);
+
+    // Räume die Ressourcen auf
+    fclose(keyfile);
 
-        // Wirft einen Fehler, falls OpenSSL ein Problem hatte
-        if (!opensslReturnError)
-        {
-            throwOpenSslException();
-        }
+    // Wirft einen Fehler, falls OpenSSL ein Problem hatte
+    if (!opensslReturnError)
+    {
+        throwOpenSslException();
     }
 }
 
@@ -200,7 +204,26 @@ void HybridCrypt::throwExceptionIfEvpKeyIsNotRsa(EVP_PKEY **key)
     if (!isKeyRsa(*key))
     {
         freeEvpKey(key);
-        throw CryptException("Nur RSA Schlüssel werden unterstüzt.", CryptException::KeyNotRsa);
+        throw CryptException("Nur RSA Schlüssel werden unterstüzt.",
+                             CryptException::KeyNotRsa);
+    }
+}
+
+void HybridCrypt::throwExceptionIfCsprngIsNotSeeded()
+{
+    if (!isCsprngSeeded())
+    {
+        throw new CryptException("Zufallszahlengenerator ist nicht initialisiert",
+                                 CryptException::CsprngNotSeeded);
+    }
+}
+
+void HybridCrypt::throwExceptionIfUserKeyIsNull()
+{
+    if (userKeypair == NULL)
+    {
+        throw CryptException("Kein Schlüssel wurde angelegt",
+                             CryptException::NoUserKeyCreated);
     }
 }
 
@@ -209,3 +232,15 @@ void HybridCrypt::freeEvpKey(EVP_PKEY **key)
     EVP_PKEY_free(*key);
     *key = NULL;
 }
+
+void HybridCrypt::freeCipherCtx(EVP_CIPHER_CTX **ctx)
+{
+    EVP_CIPHER_CTX_free(*ctx);
+    *ctx = NULL;
+}
+
+void HybridCrypt::freePkeyCtx(EVP_PKEY_CTX **ctx)
+{
+    EVP_PKEY_CTX_free(*ctx);
+    *ctx = NULL;
+}