#include "cryptclassnullcipher.h"

CryptClassNullCipher::CryptClassNullCipher()
    : CryptClassBase()
{
    ERR_load_crypto_strings();
    OpenSSL_add_all_algorithms();
}

CryptClassNullCipher::~CryptClassNullCipher()
{
    EVP_cleanup();
    ERR_free_strings();
}

void CryptClassNullCipher::encrypt()
{
    //    int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
    //             unsigned char *iv, unsigned char *ciphertext)

    m_cryptText = QByteArray(m_clearText.size() + 50, 0);

    EVP_CIPHER_CTX *ctx;

    int len;

    int ciphertext_len;

    /* Create and initialise the context */
    if (!(ctx = EVP_CIPHER_CTX_new()))
    {
        handleErrors();
    }

    /* Initialise the encryption operation. IMPORTANT - ensure you use a key
     * and IV size appropriate for your cipher
     * In this example we are using 256 bit AES (i.e. a 256 bit key). The
     * IV size for *most* modes is the same as the block size. For AES this
     * is 128 bits */
    if (1 != EVP_EncryptInit_ex(ctx, EVP_enc_null(), NULL, NULL, NULL))
    {
        qDebug() << "EVP_EncryptInit_ex";
        handleErrors();
    }

    /* Provide the message to be encrypted, and obtain the encrypted output.
     * EVP_EncryptUpdate can be called multiple times if necessary
     */
    if (1 != EVP_EncryptUpdate(ctx, (unsigned char *) m_cryptText.data(), &len,
                               (unsigned char *) m_clearText.data(), m_clearText.length()))
    {
        handleErrors();
    }

    ciphertext_len = len;

    /* Finalise the encryption. Further ciphertext bytes may be written at
     * this stage.
     */
    if (1 != EVP_EncryptFinal_ex(ctx, (unsigned char *)(m_cryptText.data() + len),
                                 &len))
    {
        handleErrors();
    }

    ciphertext_len += len;

    /* Clean up */
    EVP_CIPHER_CTX_free(ctx);
}

void CryptClassNullCipher::decrypt()
{
    m_clearText = QByteArray(m_cryptText.size() + 50, 0);

    EVP_CIPHER_CTX *ctx;

    int len;

    int plaintext_len;

    /* Create and initialise the context */
    if (!(ctx = EVP_CIPHER_CTX_new()))
    {
        handleErrors();
    }

    /* Initialise the decryption operation. IMPORTANT - ensure you use a key
     * and IV size appropriate for your cipher
     * In this example we are using 256 bit AES (i.e. a 256 bit key). The
     * IV size for *most* modes is the same as the block size. For AES this
     * is 128 bits */
    if (1 != EVP_DecryptInit_ex(ctx, EVP_enc_null(), NULL, NULL, NULL))
    {
        handleErrors();
    }

    /* Provide the message to be decrypted, and obtain the plaintext output.
     * EVP_DecryptUpdate can be called multiple times if necessary
     */
    if (1 != EVP_DecryptUpdate(ctx, (unsigned char*) m_clearText.data(), &len, (unsigned char*) m_cryptText.data(), m_cryptText.length()))
    {
        handleErrors();
    }

    plaintext_len = len;

    /* Finalise the decryption. Further plaintext bytes may be written at
     * this stage.
     */
    if (1 != EVP_DecryptFinal_ex(ctx, (unsigned char*) m_cryptText.data() + len, &len))
    {
        handleErrors();
    }

    plaintext_len += len;

    /* Clean up */
    EVP_CIPHER_CTX_free(ctx);
}

void CryptClassNullCipher::handleErrors()
{
    qDebug() << ERR_reason_error_string(ERR_get_error());
    abort();
}