#include "hybridcrypt.h"

HybridCrypt::HybridCrypt()
{
    // Initialisiere Nutzerschlüssel mit NULL
    privateUserkey = NULL;
    publicUserkey = 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
    if (privateUserkey != NULL)
    {
        EVP_PKEY_free(privateUserkey);
    }

    if (publicUserkey != NULL)
    {
        EVP_PKEY_free(publicUserkey);
    }

    // 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())
    {
        // 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, &privateUserkey) <= 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)
{

}

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 new CryptException(errorMsg.toStdString(), 5);
}