QCryptoRSAEnvelope.cc

Go to the documentation of this file.

#include "QCryptoRSAEnvelope.hh"
#include "QDiana.hh"
#include "QError.hh"
#include <stdio.h>
#include <stdlib.h>
#include <sstream>
 
#include <openssl/pem.h>
#include <openssl/rsa.h>
#include <openssl/evp.h>
#include <openssl/err.h>
 
#include <arpa/inet.h> /* For htonl() */
 
ClassImp(QCryptoRSAEnvelope)
 
 
 
QCryptoRSAEnvelope::QCryptoRSAEnvelope(const std::string& pKey, const QCryptoRSAEnvelope::Mode mode)
{
    fCTX = NULL;
    RSA *rsa_pkey = NULL;
    fPKey = NULL;
    FILE* inputKeyFile = fopen(pKey.c_str(),"r");
    fMode = mode;
    if(!inputKeyFile) {
        QError err = QERR_CANNOT_OPEN_FILE;
        std::stringstream msg;
        msg<<"Cannot open file: "<<pKey;
        err.SetDescription(__FILE__,__LINE__,msg.str());
        DianaThrow(err);
    }
 
    if(mode == ENCRYPT) {
        if (!PEM_read_RSA_PUBKEY(inputKeyFile, &rsa_pkey, NULL, NULL)) {
            QError err = QERR_UNKNOWN_ERR;
            err.SetDescription(__FILE__,__LINE__,"Error loading RSA Public Key File");
            DianaThrow(err);
        }
    } else if(mode == DECRYPT) {
        if (!PEM_read_RSAPrivateKey(inputKeyFile, &rsa_pkey, NULL, NULL)) {
            QError err = QERR_UNKNOWN_ERR;
            err.SetDescription(__FILE__,__LINE__,"Error loading RSA Private Key File");
            DianaThrow(err);
        }
    } else {
        QError err = QERR_UNKNOWN_ERR;
        err.SetDescription(__FILE__,__LINE__,"Mode must be encrypt or decrypt");
        DianaThrow(err);
    }
    if(inputKeyFile) fclose(inputKeyFile);
 
    fPKey = EVP_PKEY_new();
    if (!EVP_PKEY_assign_RSA(fPKey, rsa_pkey)) {
        QError err = QERR_UNKNOWN_ERR;
        err.SetDescription("__FILE__,__LINE__,EVP_PKEY_assign_RSA: failed.");
        DianaThrow(err);
    }
 
    fCTX = EVP_CIPHER_CTX_new();
    EVP_CIPHER_CTX_init(fCTX);
}
 
 
 
QCryptoRSAEnvelope::~QCryptoRSAEnvelope()
{
    if(fPKey) EVP_PKEY_free(fPKey);
    if(fCTX != NULL)
      EVP_CIPHER_CTX_free(fCTX);
}
 
 
 
std::vector<unsigned char> QCryptoRSAEnvelope::Process(const std::string& message)
{
    if(fMode != ENCRYPT) {
        QError err = QERR_UNKNOWN_ERR;
        err.SetDescription("__FILE__,__LINE__,string message allowed only when encrypting");
        DianaThrow(err);
    }
    std::vector<unsigned char> output(message.size());
    for(size_t i = 0; i < message.size(); i++) {
        output[i] = message[i];
    }
    return Process(output);
}
 
std::vector<unsigned char> QCryptoRSAEnvelope::Process(const std::vector<unsigned char>& message)
{
    int eklen;
    size_t totLength;
    int len_out;
 
    unsigned char buffer_out[4096 + EVP_MAX_IV_LENGTH*2];
    if(fMode == ENCRYPT) {
        totLength = EVP_CIPHER_iv_length(EVP_aes_128_cbc());
        std::cout<<"IV:length: "<<totLength<<std::endl;
 
        unsigned char* ek = (unsigned char*) malloc(4096);
        // init and write iv to buffer_out
        if (!EVP_SealInit(fCTX, EVP_aes_128_cbc(), &ek, &eklen, buffer_out, &fPKey, 1)) {
            QError err = QERR_UNKNOWN_ERR;
            err.SetDescription(__FILE__,__LINE__,"EVP_SealInit: failed.");
            DianaThrow(err);
        }
 
//        Print("E:IV:",buffer_out,totLength);
        if(eklen < 0 ) eklen = 0;
        std::cout<<"E:length: "<<eklen<<std::endl;
        //Print("E:EK:",ek,eklen);
 
        // write ek and eklen to buffer_out
        uint32_t eklen_n = htonl(eklen);
        memcpy(buffer_out+totLength, &eklen_n,sizeof(eklen_n));
 
        totLength += sizeof(eklen_n);
        memcpy(buffer_out+totLength,ek,eklen);
        totLength += eklen;
        free(ek);
 
        // write encrypted message
        unsigned char* buffer_in = Convert(message);
        size_t n = message.size();
 
        if (!EVP_SealUpdate(fCTX, buffer_out+totLength, &len_out, buffer_in, n )) {
 
            QError err = QERR_UNKNOWN_ERR;
            err.SetDescription(__FILE__,__LINE__,"EVP_SealUpdate: failed.");
            DianaThrow(err);
        }
        free(buffer_in);
        totLength += len_out;
 
        if (!EVP_SealFinal(fCTX, buffer_out+totLength, &len_out))
        {
            QError err = QERR_UNKNOWN_ERR;
            err.SetDescription(__FILE__,__LINE__,"EVP_SealFinal: failed.");
            DianaThrow(err);
        }
        totLength += len_out;
 
    } else {
 
        unsigned char* buffer_in = Convert(message);
        size_t n = message.size();
        totLength = EVP_CIPHER_iv_length(EVP_aes_128_cbc());
        unsigned char* iv = buffer_in;
        //Print("D:IV:",iv,totLength);
 
        // read eklen and ek
        uint32_t eklen_n;
        memcpy(&eklen_n,buffer_in+totLength,sizeof(eklen_n));
        totLength += sizeof(eklen_n);
        eklen = ntohl(eklen_n);
        unsigned char* ek = buffer_in+totLength;
        totLength += eklen;
 
        //std::cout<<"D:length: "<<eklen<<std::endl;
        //Print("D:EK:",ek,eklen);
 
 
        if (!EVP_OpenInit(fCTX, EVP_aes_128_cbc(), ek, eklen, iv, fPKey))
        {
            QError err = QERR_UNKNOWN_ERR;
            err.SetDescription(__FILE__,__LINE__,"EVP_OpenInit: failed.");
            DianaThrow(err);
        }
 
        len_out = 0;
 
        if (!EVP_OpenUpdate(fCTX, buffer_out, &len_out, buffer_in+totLength, n-totLength))
        {
            QError err = QERR_UNKNOWN_ERR;
            err.SetDescription(__FILE__,__LINE__,"EVP_OpenUpdate: failed.");
            DianaThrow(err);
 
        }
        totLength = len_out;
        if (!EVP_OpenFinal(fCTX, buffer_out+len_out, &len_out))
        {
            QError err = QERR_UNKNOWN_ERR;
            err.SetDescription(__FILE__,__LINE__,"EVP_OpenFinal: failed.");
            DianaThrow(err);
        }
        totLength += len_out;
        free(buffer_in);
    }
 
    return Convert(buffer_out,totLength);
 
}
 
unsigned char* QCryptoRSAEnvelope::Convert(const std::vector<unsigned char>& input) 
{
    unsigned char* output = (unsigned char*) malloc(sizeof(char)*input.size());
    for(size_t i = 0; i < input.size(); i++) {
        output[i] = input[i];
    }
    return output;
}
 
std::vector<unsigned char> QCryptoRSAEnvelope::Convert(const unsigned char* input, const size_t n)
{
    std::vector<unsigned char> output(n);
    for(size_t i = 0; i < n; i++) {
        output[i] = input[i];
    }
    return output;
}
 
 
void QCryptoRSAEnvelope::Print(const char* header, const unsigned char* data, const size_t n)
{
    printf("%s: ",header);
    for(size_t c = 0; c < n; c++) printf("%x",data[c]);
    printf("\n");
 
 
}