wave-crypto.cpp

Go to the documentation of this file.

/*
 * wave-crypto.cpp
 *
 * Copyright (C) 2007-2011  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Implementation of simple encryption helper functions.
 * See crypto.h
 */

// includes --------------------------------------------------------------------
#include "wave-crypto.h"        // always include our own header file first!

#ifdef WIN32
// for windows we have to provide our own pre-build OpenSSL binaries + headers
#include "third-party/openssl/openssl/des.h"
#include "third-party/openssl/openssl/rsa.h"
#include "third-party/openssl/openssl/sha.h"
#else   // WIN32
// on Linux, use the current installed version of OpenSSL
#include <openssl/des.h>
#include <openssl/rsa.h>
#include <openssl/sha.h>
#endif  // WIN32

#include "common/wave_ex.h"
#include "perf/perf.h"


namespace crypto {


static const int s_keyNumber            = 1536;
static const long s_keyExponent         = 65537;
static const int s_padding              = RSA_PKCS1_OAEP_PADDING;

static const int32_t s_maxEncodeLength  = 0x007FFFFFF;

static const int s_bytesPerDESBlock     = 8;

typedef std::vector<byte_t> byte_vec_t;


// interface virtual destructor implementations
RSAPublicKey::~RSAPublicKey(void) throw() { }
RSAKey::~RSAKey(void) throw() { }
DESKey::~DESKey(void) throw() { }


static char s_base64encode[65] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";

static int s_base64decode[128];


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static void
initializeDecoding
(
void
)
throw()
{
        for (int i = 0; i < 128; ++i) {
                s_base64decode[i] = -1;
        }
        for (int i = 0; i < 26; ++i) {
                s_base64decode['A' + i] = i;
                s_base64decode['a' + i] = i + 26;
        }
        for (int i = 0; i < 10; ++i) {
                s_base64decode['0' + i] = i + 52;
        }
        s_base64decode['-' + 0] = 62;
        s_base64decode['_' + 0] = 63;
}



static void
encodeInt32
(
IO std::string& out,
IN int32_t l
)
{
        ASSERT(l >= 0 && l < s_maxEncodeLength, "bad l: %ld", (long) l);

        // base64 these 3 bytes into 4 characters
        char buff[4];
        for (int i = 0; i < 4; ++i) {
                int val = l % 64;
                l = l / 64;
                buff[i] = s_base64encode[val];
        }

        for (int i = 3; i >= 0; --i) {
                out += buff[i];
        }
}



static int32_t
decodeInt32
(
IN const char * p
)
{
        int32_t l = 0;
        for (int i = 0; i < 4; ++i, ++p) {
                l = 64 * l;
                l += s_base64decode[(int) *p];
        }
        return l;
}



/*
static void
dumpDCB
(
IN const char * title,
IN const_DES_cblock * pdcb
)
{
        ASSERT(title, "null");
        ASSERT(pdcb, "null");

        DPRINTF("DES cblock: %s", title);
        for (int i = 0; i < s_bytesPerDESBlock; ++i) {
                byte_t b = (*pdcb)[i];
                char c = '?';
                if (b > 'A' && b < 'z')
                        c = b;
                DPRINTF("  byte[%d] = %3d ('%c')", i, b, c);
        }
}
*/



static long
symmetricEncrypt
(
IN const byte_t * input,
IN long bytes,
IN DES_key_schedule * ks,
IN int flag,
OUT byte_vec_t& output
)
{
        ASSERT(input, "null");
        ASSERT(bytes > 0, "bad bytes: %ld", bytes);
        ASSERT(ks, "null");
        output.clear();

        // loop through input in N-byte blocks
        int remainder = bytes % s_bytesPerDESBlock;
        int nBlocks = bytes / s_bytesPerDESBlock;

        long output_size = ((nBlocks + 1) * s_bytesPerDESBlock) + 1;
        output.resize(output_size);

        long output_bytes = 0;
        byte_t * b = &output[0];
        DES_cblock in_dcb;
        DES_cblock out_dcb;
        const byte_t * p = input;
        for (int i = 0; i < nBlocks; ++i, p += s_bytesPerDESBlock) {
                // encrypt this block
                DES_ecb_encrypt((const_DES_cblock *) p, &out_dcb, ks, flag);
                //dumpDCB("output", &out_dcb);

                // copy
                memcpy(b, out_dcb, s_bytesPerDESBlock);
                b += s_bytesPerDESBlock;
                output_bytes += s_bytesPerDESBlock;
        }

        // final block
        if (remainder) {
                byte_t * q = (byte_t *) in_dcb;
                memcpy(q, p, remainder);
                memset(q + remainder, 0, s_bytesPerDESBlock - remainder);
//              dumpDCB("input", &in_dcb);
                DES_ecb_encrypt(&in_dcb, &out_dcb, ks, flag);
                memcpy(b, out_dcb, s_bytesPerDESBlock);
//              dumpDCB("output", &out_dcb);
                output_bytes += s_bytesPerDESBlock;
        }

        return output_bytes;
}



////////////////////////////////////////////////////////////////////////////////
//
//      PublicKey -- class that implements the RSAPublicKey interface
//
////////////////////////////////////////////////////////////////////////////////

class PublicKey : public RSAPublicKey {
public:
        PublicKey(void) throw();
        ~PublicKey(void) throw();

        // public class methods ------------------------------------------------
        void initialize(IN const char * serialized);
        void initialize(IN RSA * rsa);

        // crypto::PublicRSAKey class interface methods ------------------------
        std::string serialize(void);
        std::string encrypt(IN const char * plaintext);

private:
        // private member data -------------------------------------------------
        RSA *           m_rsa;
};



PublicKey::PublicKey
(
void
)
throw()
{
        m_rsa = NULL;
}


PublicKey::~PublicKey
(
void
)
throw()
{
        if (m_rsa) {
                RSA_free(m_rsa);
        }
}



void
PublicKey::initialize
(
IN const char * serialized
)
{
        ASSERT(serialized, "null");

//      DPRINTF("SERIALIZED: %s", serialized);

        // create empty key
        m_rsa = RSA_new();
        ASSERT(m_rsa, "failed to create empty RSA key");
        ASSERT(!m_rsa->n, "already have n?");
        ASSERT(!m_rsa->e, "already have e?");

        // attempt to extract N and E
        // (see PublicKey::serialize below for format, basically "n:e")
        const int buffsize = 1024;
        char buffer[buffsize];
        const char * s = strstr(serialized, ":");
        if (!s) {
                WAVE_EX(wex);
                wex << "Malformed serialized key";
        }
        int iN = s - serialized;
        if (iN < 1 || iN >= buffsize) {
                WAVE_EX(wex);
                wex << "Malformed serialized key";
        }
        strncpy(buffer, serialized, iN);
        buffer[iN] = 0;
//      DPRINTF("N = %s", buffer);
        BN_hex2bn(&m_rsa->n, buffer);

        serialized += iN + 1;
        iN = strlen(serialized);
        if (iN < 1 || iN >= buffsize) {
                WAVE_EX(wex);
                wex << "Malformed serialized key";
        }
        strcpy(buffer, serialized);
//      DPRINTF("e = %s", buffer);
        BN_hex2bn(&m_rsa->e, buffer);
}



void
PublicKey::initialize
(
IN RSA * rsa
)
{
        ASSERT(rsa, "null");
        ASSERT(!m_rsa, "already have a key?");
        m_rsa = rsa;
}



std::string
PublicKey::serialize
(
void
)
{
        std::string public_key;

        // WOW the RSA libraries SUCK
        // there is NO mechanism for getting/serializing the public key
        // of an RSA key.  Somehow they expect you to magically extract the
        // public bits of the key (!!??).  At the moment I don't have internet
        // access, so I'm basing this on the man documentation.  But it is
        // amazingly useless.

        // So I have rolled my OWN public key serialization.  Hopefully this
        // can be replaced by the real solution
        ASSERT(m_rsa, "null");
        ASSERT(m_rsa->n, "null");
        ASSERT(m_rsa->e, "null");

        char * n = BN_bn2hex(m_rsa->n);         // must be free()'d!
        char * e = BN_bn2hex(m_rsa->e);         // must be free()'d!

//      DPRINTF("n = '%s'", n);
//      DPRINTF("e = '%s'", e);

        public_key += n;
        public_key += ":";
        public_key += e;

        OPENSSL_free(n);
        OPENSSL_free(e);

        // that's it!
        return public_key;
}



std::string
PublicKey::encrypt
(
IN const char * plaintext
)
{
        perf::Timer timer("crypto::RSAPublicKey::encrypt");
        ASSERT(m_rsa, "null");
        ASSERT(plaintext, "null");

        long bytes = strlen(plaintext);

        // construct array
        int rbytes = RSA_size(m_rsa);
//      DPRINTF("encryption requires %d bytes", rbytes);
        ASSERT(bytes > 0, "bad byte count? %d", rbytes);

        std::vector<byte_t> out;
        out.resize(rbytes + 1);

        int ebytes = RSA_public_encrypt(bytes, (byte_t *) plaintext,
            &out[0], m_rsa, s_padding);

//      DPRINTF("Encrypted %ld bytes, resulted in %d bytes",
//          bytes, ebytes);

        if (ebytes < 1) {
                WAVE_EX(wex);
                wex << "Failed public key encryption";
        }

        return encodeBase64(&out[0], ebytes);
}



////////////////////////////////////////////////////////////////////////////////
//
//      Key -- class that implements the RSAKey interface
//
////////////////////////////////////////////////////////////////////////////////

class Key : public RSAKey {
public:
        Key(void) throw();
        ~Key(void) throw();

        // public class methods ------------------------------------------------
        void initialize(void);

        // crypto::RSAKey class interface methods ------------------------------
        smart_ptr<RSAPublicKey> getPublicKey(void);
        std::string decrypt(IN const char * encrypted);

private:
        // private member data -------------------------------------------------
        RSA *           m_rsa;
};



Key::Key
(
void
)
throw()
{
        m_rsa = NULL;
}



Key::~Key
(
void
)
throw()
{
        if (m_rsa) {
                RSA_free(m_rsa);
        }
}



void
Key::initialize
(
void
)
{
        ASSERT(!m_rsa, "already have a key?");
        m_rsa = RSA_generate_key(s_keyNumber, s_keyExponent, NULL, NULL);
        ASSERT(m_rsa, "failed to generate RSA key");
}



smart_ptr<RSAPublicKey>
Key::getPublicKey
(
void
)
{
        // See previous note.  Basically, RSA libraries suck.
        // There is no supported way to extract the public key (!?)
        // so I have rolled my own.  Sigh.

        RSA * rsa = RSA_new();
        ASSERT(rsa, "failed to create empty RSA key");
        ASSERT(!rsa->n, "already have n?");
        ASSERT(!rsa->e, "already have e?");

        // copy just the public parts (n and e)
        rsa->n = BN_dup(m_rsa->n);
        rsa->e = BN_dup(m_rsa->e);
        ASSERT(rsa->n, "null");
        ASSERT(rsa->e, "null");

        // okay, return public key from that
        smart_ptr<PublicKey> pkey = new PublicKey();
        ASSERT(pkey, "out of memory");
        pkey->initialize(rsa);          // public key takes ownership of rsa
        return pkey;
}



std::string
Key::decrypt
(
IN const char * encrypted
)
{
        perf::Timer timer("crypto::RSAKey::decrypt");
        ASSERT(m_rsa, "null");
        ASSERT(encrypted, "null");

        byte_vec_t data;
        decodeBase64(encrypted, data);

        int ebytes = data.size();
//      DPRINTF("Decoded string results in %d bytes of data", ebytes);

        byte_vec_t out;
        out.resize(RSA_size(m_rsa));

        int bytes = RSA_private_decrypt(ebytes, &data[0],
            &out[0], m_rsa, s_padding);
//      DPRINTF("Decryption results in %d bytes", bytes);
        if (bytes < 1) {
                WAVE_EX(wex);
                wex << "Failed to decrypt data";
        }

        return (const char *) &out[0];
}



////////////////////////////////////////////////////////////////////////////////
//
//      SymKey - class that implements the DESKey interface
//
////////////////////////////////////////////////////////////////////////////////

class SymKey : public DESKey {
public:
        SymKey(void) throw();
        ~SymKey(void) throw();

        // public class methods ------------------------------------------------
        void initialize(void);
        void initialize(IN const char * serialized);

        // crypto::DESKey class interface methods -----------------------------
        std::string serialize(void);
        std::string encrypt(IN const char * plaintext, IN int minSize);
        std::string decrypt(IN const char * encrypted);

private:
        // private member data -------------------------------------------------
        DES_cblock              m_dcb;
        DES_key_schedule        m_sched;
};



SymKey::SymKey
(
void
)
throw()
{
}



SymKey::~SymKey
(
void
)
throw()
{
}



void
SymKey::initialize
(
void
)
{
        // see the des documentation ("man DES_random_key")
        // have to create a key, then a schedule
        DES_random_key(&m_dcb);

        // create schedule
        if (DES_set_key_checked(&m_dcb, &m_sched)) {
                WAVE_EX(wex);
                wex << "Failed to create symmetric key (schedule)";
        }

//      dumpDCB("new", &m_dcb);
}



void
SymKey::initialize
(
IN const char * serialized
)
{
        ASSERT(serialized, "null");

        byte_vec_t data;
        decodeBase64(serialized, data);
        if (s_bytesPerDESBlock != (int) data.size()) {
                WAVE_EX(wex);
                wex << "Improperly encoded DES key";
        }

        memcpy(m_dcb, &data[0], s_bytesPerDESBlock);
        if (DES_set_key_checked(&m_dcb, &m_sched)) {
                WAVE_EX(wex);
                wex << "Failed to create symmetric key (schedule)";
        }

//      dumpDCB("remote", &m_dcb);
}



std::string
SymKey::serialize
(
void
)
{
        const byte_t * b = (const byte_t *) m_dcb;

        return encodeBase64(b, s_bytesPerDESBlock);
}



std::string
SymKey::encrypt
(
IN const char * plaintext,
IN int minSize
)
{
        perf::Timer timer("crypto::DESKey::encrypt");
        ASSERT(plaintext, "null");
        long bytes = strlen(plaintext);
        ASSERT(bytes >= 0, "Bad bytes: %ld", bytes);

        //DPRINTF("Encrypting '%s'", plaintext);

        // pad if necessary
        std::string base;
        int nPad = minSize - bytes;
        if (minSize > 0 && nPad > 0) {
                for (int i = 0; i < nPad; ++i) {
                        base += 'a' + (rand() % 26);
                }
                bytes += nPad;
        }
        base += ':';
        bytes += 1;             // account for colon
        base += plaintext;

        //DPRINTF("  '%s'", base.c_str());
        //DPRINTF("  %ld bytes", bytes);

        // encrypt
        byte_vec_t raw;
        long obytes = symmetricEncrypt((const byte_t *) base.c_str(), bytes,
            &m_sched, DES_ENCRYPT, raw);
        //DPRINTF("  %ld output bytes", obytes);

        // convert
        return encodeBase64(&raw[0], obytes);
}



std::string
SymKey::decrypt
(
IN const char * encrypted
)
{
        perf::Timer timer("crypto::DESKey::decrypt");
        ASSERT(encrypted, "null");

        //DPRINTF("Decrypting '%s'", encrypted);

        // decode first
        byte_vec_t raw;
        decodeBase64(encrypted, raw);

        long bytes = raw.size();
        ASSERT(bytes > 0, "Bad bytes: %ld", bytes);
        //DPRINTF("  Found %ld bytes", bytes);

        // decrypt
        byte_vec_t output;
        symmetricEncrypt(&raw[0], bytes, &m_sched, DES_DECRYPT,
            output);
        output.push_back(0);    // null-terminate

        // skip padding
        const char * p = (const char *) &output[0];
        //DPRINTF("  '%s'", p);
        while (*p && *p != ':') { ++p; }
        if (!*p) {
                WAVE_EX(wex);
                wex << "Improperly encrypted string?";
        }
        ++p;    // skip colon
        //DPRINTF("  '%s'", p);

        // all done
        return p;
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<RSAPublicKey>
RSAPublicKey::create
(
IN const char * serialized
)
{
        perf::Timer timer("crypto::RSAPublicKey::create");

        smart_ptr<PublicKey> local = new PublicKey;
        ASSERT(local, "out of memory");

        local->initialize(serialized);

        return local;
}



smart_ptr<RSAKey>
RSAKey::create
(
void
)
{
        perf::Timer timer("crypto::RSAKey::create");

        smart_ptr<Key> local = new Key;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}



smart_ptr<DESKey>
DESKey::create
(
void
)
{
        perf::Timer timer("crypto::DESKey::create");

        smart_ptr<SymKey> local = new SymKey;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}



smart_ptr<DESKey>
DESKey::create
(
IN const char * serialized
)
{
        smart_ptr<SymKey> local = new SymKey;
        ASSERT(local, "out of memory");
        local->initialize(serialized);
        return local;
}



std::string
getSHA1
(
IN const char * data
)
{
        perf::Timer timer("crypto::getSHA1");
        ASSERT(data, "null");

        const int bufSize = SHA_DIGEST_LENGTH;
        byte_t buffer[bufSize];
        int length = strlen(data);

        SHA1((const unsigned char *) data, length, buffer);
        return encodeBase64(buffer, SHA_DIGEST_LENGTH, false);
}



std::string
encodeBase64
(
IN const byte_t * data,
IN long bytes,
IN bool encodeLength
)
{
        perf::Timer timer("crypto::encodeBase64");
        ASSERT(data, "null");
        ASSERT(bytes > 0, "bad bytes: %ld", bytes);
        if (bytes >= s_maxEncodeLength) {
                WAVE_EX(wex);
                wex << "Cannot encode " << bytes << " bytes.";
                wex << "  Max encode length is " << s_maxEncodeLength;
        }

        // uses a simple base64 encoding
        // uses "modified base64" so it is not necessary to URL encode
        // see http://en.wikipedia.org/wiki/Base64

        std::string out;

        // if you don't encode the length, it can't be decoded!
        if (encodeLength) {
                // DPRINTF("Encoding %ld bytes", bytes);
                encodeInt32(out, bytes);
        }

        char buf[4];
        buf[3] = 0;     // most significant byte is empty
        const byte_t * p = data;
        while (bytes > 0) {
                // walk through data in chunks of 3 bytes
                // pad with last valid byte if necessary
                for (int i = 0; i < 3; ++i, --bytes) {
                        buf[i] = *p;
                        if (bytes > 1) {
                                ++p;
                        }
                }

                int32_t * pl = (int32_t *) &buf;
                int32_t l = *pl;
                ASSERT(l >= 0, "Bad l: %ld", (long) l);
//              DPRINTF("l = 0x%08lx", l);
                encodeInt32(out, l);
        }
//      DPRINTF("out: %s", out.c_str());
        return out;
}



void
decodeBase64
(
IN const char * encoded,
OUT byte_vec_t& data
)
{
        perf::Timer timer("crypto::decodeBase64");
        data.clear();

        int N = strlen(encoded);
        if (N % 4) {
                WAVE_EX(wex);
                wex << "Improperly encoded data (bad length)";
        }

        static bool s_init = false;
        if (!s_init) {
                initializeDecoding();
                s_init = true;
        }

        const char * p = encoded;
        int32_t bytes = decodeInt32(p);
        // DPRINTF("Decoding %ld bytes", bytes);
        p += 4;

        // decrypt 4 characters at a time, populate 3 bytes
        for (; N > 0; N -= 4) {

                int32_t l = decodeInt32(p);
                p += 4;
                byte_t * pb = (byte_t *) &l;
                for (int i = 0; i < 3; ++i ) {
                        if (bytes > 0) {
                                data.push_back(pb[i]);
                                bytes--;
                        }
                }
        }
        // DPRINTF("  Decoded %d bytes", data.size());
}



};      // crypto namespace