QCryptoRSA.cc

Go to the documentation of this file.

#include "QCryptoRSA.hh"
#include "QDiana.hh"
#include "QError.hh"
#include <stdio.h>
#include <stdlib.h>
#include <sstream>
 
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>
 
#include <arpa/inet.h> /* For htonl() */
 
ClassImp(QCryptoRSA)
 
 
 
QCryptoRSA::QCryptoRSA(const std::string& pKey, const QCryptoRSA::Mode mode, bool nopad)
{
    FILE* inputKeyFile = fopen(pKey.c_str(),"r");
    fMode = mode;
    fRSA = NULL;
    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, &fRSA, 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, &fRSA, 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);
    fOutput = (unsigned char*)malloc(sizeof(char)*RSA_size(fRSA));
    fNoPadding = nopad;
    if(fNoPadding) {
        fRandomSize = 1;
        fBeginPad = 1;
        srand(time(0));
        fMsgLength = RSA_size(fRSA)-fRandomSize-fBeginPad; 
    } else {
        fBeginPad = 0;
        fRandomSize = 0;
        fMsgLength = RSA_size(fRSA)-11;
    }
    if(fMsgLength < 0) {
        QError err = QERR_SIZE_NOT_MATCH;
        err.SetDescription(__FILE__,__LINE__,"RSA key length too short");
        DianaThrow(err);
    }
 
}
 
QCryptoRSA::~QCryptoRSA()
{
}
 
std::vector<unsigned char> QCryptoRSA::ConvertString(const std::string& message)
{
    std::vector<unsigned char> output(message.size());
    for(size_t i = 0; i < message.size(); i++) {
        output[i] = message[i];
    }
    return output;
}
 
std::string QCryptoRSA::ConvertString(const std::vector<unsigned char>& message)
{
    std::string output(message.size(), ' ');
    for(size_t i = 0; i < message.size(); i++) {
        output[i] = (char)message[i];
    }
    return output; 
}
std::vector<unsigned char> QCryptoRSA::ConvertHex(const std::string& message)
{
    size_t size = message.size();
    if(size % 2 != 0) {
        QError err = QERR_SIZE_NOT_MATCH;
        err.SetDescription(__FILE__,__LINE__,"String size is odd, must be even");
        DianaThrow(err);
    }
    size_t outsize = size/2;
    std::vector<unsigned char> output(outsize);
    char byte[3];
    for(size_t i = 0; i < message.size(); i+=2) {
        byte[0] = message[i];
        byte[1] = message[i+1];
        byte[2] = '\0';
        unsigned int tmp;
        sscanf(byte, "%02x", &tmp);
        output[i/2] = (unsigned char)tmp;
    }
    return output;
}
 
std::string QCryptoRSA::ConvertHex(const std::vector<unsigned char>& message)
{
    std::string output(message.size()*2,' ');
    char byte[3];
    for(size_t i = 0; i < message.size(); i++) {
        snprintf(byte,3,"%02x",message[i]);
        output[i*2] = byte[0];
        output[i*2+1] = byte[1];
    }
    return output;
}
 
std::vector<unsigned char> QCryptoRSA::ConvertDouble(const double message)
{
    size_t size = sizeof(message);
    std::vector<unsigned char> output(size);
    const unsigned char* input = reinterpret_cast<const unsigned char*>(&message);
    for(size_t i = 0; i < size; i++) {
        output[i] = input[i];
    }
    return output;
}
 
double QCryptoRSA::ConvertDouble(const std::vector<unsigned char>& message)
{
    double output;
    size_t size = sizeof(output);
    if(message.size() != size) {
        QError err = QERR_SIZE_NOT_MATCH;
        std::stringstream msg;
        msg<<"QCryptoRSA::ConvertDouble: Input message size ("<<message.size()<<")"
            <<" differs from "<<size;
        err.SetDescription(__FILE__,__LINE__,msg.str());
        DianaThrow(err);
    }
    unsigned char* coutput = reinterpret_cast<unsigned char*>(&output);
    for(size_t i = 0; i < size; i++) {
        coutput[i] = message[i];
    }
    return output;
}
 
std::vector<unsigned char> QCryptoRSA::Process(const std::vector<unsigned char>& message) const
{
    int len_out,len_in;
    len_in = message.size();
    if(fMode == ENCRYPT) {
        if(fNoPadding && len_in != fMsgLength) {
            QError err = QERR_SIZE_NOT_MATCH;
            std::stringstream msg;
            msg<<"Input message size ("<<message.size()<<")"
                <<" differs from "<<fMsgLength<<" char";
            err.SetDescription(__FILE__,__LINE__,msg.str());
            DianaThrow(err);
        } else if(!fNoPadding && len_in >=( fMsgLength)) {
            QError err = QERR_SIZE_NOT_MATCH;
            std::stringstream msg;
            msg<<"Input message too long ("<<message.size()<<")"
                <<" must be shorter than "<<fMsgLength<<" char";
            err.SetDescription(__FILE__,__LINE__,msg.str());
            DianaThrow(err);
        } 
 
        len_in += fBeginPad;
        unsigned char* input = ConvertArray(message,fRandomSize,fBeginPad);
        for(size_t i = 0; i < fRandomSize; i++) {
            input[len_in+i] = rand()%256;
        }
        len_in += fRandomSize;
        if(fNoPadding) {
            len_out = RSA_public_encrypt(len_in, input,
                    fOutput, fRSA, RSA_NO_PADDING);
        } else {
            len_out = RSA_public_encrypt(len_in, input,
                    fOutput, fRSA, RSA_PKCS1_PADDING);
        }
    } else {
        unsigned char* input = ConvertArray(message);
        if(fNoPadding) {
            len_out = RSA_private_decrypt(len_in, input,
                    fOutput, fRSA, RSA_NO_PADDING);
        } else {
            len_out = RSA_private_decrypt(len_in, input,
                    fOutput, fRSA, RSA_PKCS1_PADDING);
        }
    }
    if(len_out == -1) {
        QError err = QERR_UNKNOWN_ERR;
        std::stringstream msg;
        char buf[128];
        ERR_error_string(ERR_get_error(), buf);
        msg<<"RSA failed with "<<buf;
        err.SetDescription(__FILE__,__LINE__,msg.str());
        DianaThrow(err);
    }
    int start = 0;
    if(fMode == DECRYPT) {
        len_out -= fRandomSize+fBeginPad;
        start = fBeginPad;
    }
 
    return ConvertArray(fOutput+start,len_out);
 
}
 
unsigned char* QCryptoRSA::ConvertArray(const std::vector<unsigned char>& input, const size_t pad, const size_t beginpad) const
{
    unsigned char* output = (unsigned char*) malloc(sizeof(unsigned char)*(input.size()+pad+beginpad));
 
    for(size_t i = 0; i < beginpad; i++) {
        output[i] = 0;
    }
    for(size_t i = beginpad; i < input.size()+beginpad; i++) {
        output[i] = input[i-beginpad];
    } 
    for(size_t i = input.size()+beginpad; i < input.size()+pad+beginpad; i++) {
        output[i] = 0;
    }
 
    return output;
}
 
std::vector<unsigned char> QCryptoRSA::ConvertArray(const unsigned char* input, const size_t n) const
{
    std::vector<unsigned char> output(n);
    for(size_t i = 0; i < n; i++) {
        output[i] = input[i];
    }
    return output;
}
 
 
void QCryptoRSA::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");
 
 
}