#include "hybridcrypt.h"

HybridCrypt::HybridCrypt()
{
    // Initialisiere Nutzerschlüssel mit NULL
    userKeypair = NULL;

    // Lade die menschenlesbaren Fehlerstrings für LibCrypto
    ERR_load_crypto_strings();

    // Lade alle Hash- und  Verschlüsselungsalgorithmen
    OpenSSL_add_all_algorithms();

    // Lade Konfigurationsdatei und andere wichtige Initialisierungen
    OPENSSL_config(NULL);

    // Zeige ob der Zufallszahlengenerator initialisiert wurde
    qDebug() << "Zufallszahlengenerator erfolgreich initialisiert: " <<
             isCsprngSeeded();
}

HybridCrypt::~HybridCrypt()
{
    // Räume Nutzerschlüssel auf
    freeKeyIfNotNull();

    // Räume OpenSSL auf
    // Entferne alle Hash- und Verschlüsselungsalgorithmen
    EVP_cleanup();

    // Falls das nächste Ausgelassen wird, könnte ein Speicherleck auftreten,
    // wenn die BIO Api verwendet wurde (Base64 transformationen)
    CRYPTO_cleanup_all_ex_data();

    // Lösche den CSPRNG sicher
    RAND_cleanup();

    // Entferne Fehlerstrings
    ERR_free_strings();
}

void HybridCrypt::encrypt(QString infileName, QString outfileName,
                          QVector<QString> recipientKeyfileNames)
{

}

void HybridCrypt::decrypt(QString infileName, QString outfileName)
{

}

void HybridCrypt::createKeypair()
{
    if (isCsprngSeeded())
    {
        // Räume den alten Schlüssel vorher ab
        freeKeyIfNotNull();

        // Lege Schlüsselkontextvariable an
        EVP_PKEY_CTX *ctx = NULL;

        // Erzeuge den Schlüsselkontext
        if (!(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)))
        {
            throwOpenSslException();
        }

        // Initialisiere den Schlüsselgenerator
        if (EVP_PKEY_keygen_init(ctx) <= 0)
        {
            throwOpenSslException();
        }

        // Lege den Schlüssel mit 2048 Bit an
        if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048) <= 0)
        {
            throwOpenSslException();
        }

        // Erzeuge den Schlüssel
        if (EVP_PKEY_keygen(ctx, &userKeypair) <= 0)
        {
            throwOpenSslException();
        }

        // Räume den Schlüsselkontext ab
        EVP_PKEY_CTX_free(ctx);
    }
}

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+");

        // Teste ob die Datei zum Schreiben geöffnet werden konnte
        if (keyfile == NULL)
        {
            throw CryptException("Konnte Datei nicht schreiben: " +
                                 keyfileName.toStdString(), 1);
        }

        // Wird benutzt um die OpenSSL Fehler aufzufangen
        int opensslReturnError = 0;

        // Wenn password ein Leerstring ist, verschlüssele den privaten Schlüssel nicht
        opensslReturnError = PEM_write_PKCS8PrivateKey(keyfile, userKeypair,
                             (password == "") ? NULL : EVP_aes_256_cbc(), NULL, 0, NULL,
                             (void *) password.toStdString().c_str());

        // Räume die Ressourcen auf
        fclose(keyfile);

        // Wirf einen Fehler, falls OpenSSL ein Problem hatte
        if (!opensslReturnError)
        {
            throwOpenSslException();
        }
    }
}

void HybridCrypt::exportPublicUserKey(QString keyfileName)
{

}

bool HybridCrypt::isCsprngSeeded()
{
    return RAND_status() == 1;
}

void HybridCrypt::throwOpenSslException()
{
    QString errorMsg("OpenSSL Fehler. Fehlermeldung: ");
    errorMsg.append(ERR_error_string(ERR_get_error(), NULL));
    throw CryptException(errorMsg.toStdString(), 5);
}


void HybridCrypt::freeKeyIfNotNull()
{
    if (userKeypair != NULL)
    {
        EVP_PKEY_free(userKeypair);
        userKeypair = NULL;
    }
}