source: comparacioncriptosistemas/elgamal/main-original.cpp

#include <QCoreApplication>

#include <QTime>
#include <QElapsedTimer>
#include <QFile>
#include <QTextStream>

#include <iostream>

#include "crypto++/rsa.h"
#include "crypto++/elgamal.h"
#include "crypto++/osrng.h"
#include <crypto++/files.h>



/**
 * Programa de Cryptopp para realizar estimaciones de ejecuciones del
 * algoritmo EL GAMAL
 *
 * https://www.cryptopp.com/wiki/ElGamal
 *
 *
 * Es necesario instalar los siguientes paquetes:
 * libcrypto++9 y libcrypto++-dev
 *
 */

using namespace CryptoPP;

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    //return a.exec();


    ///////////////////////////////////////
    // Pseudo Random Number Generator
    AutoSeededRandomPool rng;


    //QTime timer;
    QElapsedTimer timer;

    //int runtime = timer.elapsed(); //gets the runtime in ms

    // prefijo del nombre del archivo con el texto a cifrar
    QString messageFile = "message";


    ////////////////////////////////////////////////
    // Secret to protect
    //static const int SECRET_SIZE = 16;
    //SecByteBlock plaintext( SECRET_SIZE );
    //memset( plaintext, 'A', SECRET_SIZE );

    std::string s;
    //CryptoPP::FileSource file( "message.txt", true, new StringSink( s ) );

    std::cout << s << std::endl;
    std::cout << s.size() << std::endl;

    SecByteBlock plaintext( (const unsigned char *) s.data(), s.size() );


    // iterar por el número de archivos (10)
    for (int i = 1; i <= 2; i++)
    {
        messageFile.append(QString::number(i));

        qDebug("generar archivo...");
        // generar registros en archivo de texto
        QString fileName = "registro-elgamal-";
        fileName.append(messageFile+"-");
        fileName.append(QDateTime::currentDateTime().toString("dd.MM.yy.hh.mm.ss"));
        fileName.append(".txt");

        messageFile.append(".txt");

        std::string s;
        //CryptoPP::FileSource file( qPrintable(messageFile), true, new StringSink( s ) );

        //std::cout << s ;//<< std::endl;
        //std::cout << s.size() << std::endl;

        // archivo de salida de resultados
        QFile registerFile(fileName);
        if (registerFile.open(QFile::WriteOnly))
        {
            // flujo para el archivo de salida de resultados
            QTextStream outFile(&registerFile);


            // linea que mantiene los valores de tiempo
            QString line;

            // iterar 50 veces el proceso de cifrado y descifrado del texto
            for (int j = 0; j < 1; j++)
            {

                qDebug("*************************************************");
                std::cout << "Generating private key. This may take some time..." << std::endl;
                timer.start();
                ElGamal::Decryptor gamalDecryptor;
                gamalDecryptor.AccessKey().GenerateRandomWithKeySize(rng, 2048);
                qDebug("gamalDecryptor.AccessKey().GenerateRandomWithKeySize(rng, 2048);");

                int runtime = timer.elapsed(); //gets the runtime in ms
                qDebug(qPrintable("key generation: "+QString::number(runtime)+" ms"));

                line.append(QString::number(runtime));
                line.append(" ");

                const ElGamalKeys::PrivateKey& gamalPrivateKey = gamalDecryptor.AccessKey();

                ElGamal::Encryptor gamalEncryptor(gamalDecryptor);
                const PublicKey& gamalPublicKey = gamalEncryptor.AccessKey();
                qDebug("const PublicKey& gamalPublicKey = gamalEncryptor.AccessKey();");
                ////////////////////////////////////////////////
                // Secret to protect
                //static const int SECRET_SIZE = 16;
                //SecByteBlock plaintext( SECRET_SIZE );
                //memset( plaintext, 'A', SECRET_SIZE );

                ////////////////////////////////////////////////
                // Encrypt

                // Now that there is a concrete object, we can validate
                assert( 0 != gamalEncryptor.FixedMaxPlaintextLength() );
                qDebug("gamalEncryptor.FixedMaxPlaintextLength(): %zu", gamalEncryptor.FixedMaxPlaintextLength());
                // para ElGamal mas de 253 bytes hace que el asser que sigue falle

                assert( plaintext.size() <= gamalEncryptor.FixedMaxPlaintextLength() );

                // Create cipher text space
                //size_t ecl = gamalEncryptor.CiphertextLength( plaintext.size() );
                size_t ecl2 = gamalEncryptor.CiphertextLength( plaintext.size() );
                assert( 0 != ecl2 );
                SecByteBlock ciphertext2( ecl2 );

                timer.start();
                gamalEncryptor.Encrypt( rng, plaintext, plaintext.size(), ciphertext2 );
                runtime = timer.elapsed(); //gets the runtime in ms
                qDebug(qPrintable("ElGamal encryption time: "+QString::number(runtime)+" ms"));
                line.append(QString::number(runtime));
                line.append(" ");

                ////////////////////////////////////////////////
                // Decrypt

                // Now that there is a concrete object, we can check sizes
                assert( 0 != gamalDecryptor.FixedCiphertextLength() );
                assert( ciphertext2.size() <= gamalDecryptor.FixedCiphertextLength() );

                // Create recovered text space
                //size_t dpl = gamalDecryptor.MaxPlaintextLength( ciphertext2.size() );
                size_t dpl2 = gamalDecryptor.MaxPlaintextLength( ciphertext2.size() );
                assert( 0 != dpl2 );
                SecByteBlock recovered2( dpl2 );

                timer.start();
                //DecodingResult result = gamalDecryptor.Decrypt( rng, ciphertext, ciphertext.size(), recovered );
                DecodingResult result2 = gamalDecryptor.Decrypt( rng, ciphertext2, ciphertext2.size(), recovered2 );
                runtime = timer.elapsed(); //gets the runtime in ms
                qDebug(qPrintable("ElGamal decryption time: "+QString::number(runtime)+" ms"));
                line.append(QString::number(runtime));
                line.append(" ");


                // More sanity checks
                assert( result2.isValidCoding );
                assert( result2.messageLength <= gamalDecryptor.MaxPlaintextLength( ciphertext2.size() ) );

                // At this point, we can set the size of the recovered
                //  data. Until decryption occurs (successfully), we
                //  only know its maximum size
                recovered2.resize( result2.messageLength );

                // SecByteBlock is overloaded for proper results below
                assert( plaintext == recovered2 );

                // If the assert fires, we won't get this far.
                if(plaintext == recovered2)
                std::cout << "Recovered plain text" << std::endl;
                else
               std::cout << "Failed to recover plain text" << std::endl;

           }
        }
    }
                qDebug("exit");
}