Crypt.cpp

/*
** libutil++
** $Id: Crypt.cpp 1653 2016-02-28 19:54:59Z sella $
** Copyright (c) 2011-2016 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: Crypt.cpp 1653 2016-02-28 19:54:59Z sella $";

#include "Crypt.h"
#include "CommonMacro.h"
#include "Time.h"
#include "../Exception.h"

#ifndef SKIP_CRYPT

#include <mhash.h>
#include <mutils/mhash.h>
#include <string.h>
#include <stdlib.h>

//#define DUMP

using namespace sella::util;

Crypt::Crypt(const char *algo, const char *mode, int keylen, uint32_t seed) : init(false), password(NULL), salt(NULL), key(NULL), iv(NULL), algo(algo), mode(mode) {
        td = mcrypt_module_open((char*) algo, NULL, (char*) mode, NULL);

        if (mcrypt_enc_is_block_algorithm(td) == 1 && mcrypt_enc_is_block_mode(td) == 1) {
                THROW(Exception, "Crypt does not support block algorithm or block modes");
        }

        setKeyLen(keylen);

        if (seed == 0) {
                setFlipSeed((uint32_t) Time::gettimeofday_usec());
        } else {
                setFlipSeed(seed);
        }

        setPassword(CRYPT_PASSWORD_DEF, CRYPT_SALT_DEF);
}

Crypt::Crypt(const Crypt &other) :
        init(false),
        seed(other.seed),
        password(strdup(other.password)),
        salt(strdup(other.salt)),
        key((unsigned char *)malloc(other.keylen)),
        iv(NULL),
        keylen(other.keylen),
        algo(other.algo),
        mode(other.mode)
{
        memcpy(this->key, other.key, this->keylen);

        this->td = mcrypt_module_open((char*) this->algo.c_str(), NULL, (char*) this->mode.c_str(), NULL);
}

Crypt::~Crypt() {
        clear();

        mcrypt_module_close(td);
}

Crypt& Crypt::operator=(const Crypt &other) throw () {
        if (this != &other) {
                clear();

                this->init = false;
                this->seed = other.seed;
                this->password = strdup(other.password);
                this->salt = strdup(other.salt);
                this->iv = NULL;
                this->keylen = other.keylen;
                this->algo = other.algo;
                this->mode = other.mode;

                key = (unsigned char *)malloc(this->keylen);
                memcpy(this->key, other.key, this->keylen);

                this->td = mcrypt_module_open((char*) this->algo.c_str(), NULL, (char*) this->mode.c_str(), NULL);
        }

        return *this;
}

void Crypt::clear(void) {
        int iv_size = mcrypt_enc_get_iv_size(td);

        deinitialize();

        /* Scrub from memory before release */
        if (this->iv) {
                memset(this->iv, 0, iv_size);
                SAFE_FREE(this->iv);
        }

        if (this->key) {
                memset(this->key, 0, this->keylen);
                SAFE_FREE(this->key);
        }

        if (this->salt) {
                memset(this->salt, 0, strlen(this->salt));
                SAFE_FREE(this->salt);
        }

        if (this->password) {
                memset(this->password, 0, strlen(this->password));
                SAFE_FREE(this->password);
        }
}

void Crypt::setSeed(uint32_t seed) {
        this->seed = seed;

        /* Seed change invalidates iv */
        if (this->iv) { /* Scrub from memory before release */
                int iv_size = mcrypt_enc_get_iv_size(td);

                memset(this->iv, 0, iv_size);
                SAFE_FREE(this->iv);
        }
}

void Crypt::setFlipSeed(uint32_t seed, uint32_t pattern) {
        setSeed((~seed) ^ pattern);
}

uint32_t Crypt::getSeed(void) const {
        return seed;
}

bool Crypt::setPassword(const char *password, const char *salt) {
        KEYGEN data;
        int passlen, saltlen;
        unsigned char* key = NULL;

        assert(password != NULL);
        assert(salt != NULL);

        /* Scrub from memory before release */
        if (this->key) {
                memset(this->key, 0, this->keylen);
                SAFE_FREE(this->key);
        }

        if (this->salt) {
                memset(this->salt, 0, strlen(this->salt));
                SAFE_FREE(this->salt);
        }

        if (this->password) {
                memset(this->password, 0, strlen(this->password));
                SAFE_FREE(this->password);
        }

        if (password == NULL || salt == NULL) {
                goto error;
        }

        if ((key = (unsigned char*) calloc(1, keylen)) == NULL) {
                goto error;
        }

        if ((saltlen = mhash_get_keygen_salt_size(KEYGEN_MCRYPT)) == 0) {
                saltlen = strlen(salt);
        } else if (saltlen > (int) strlen(salt)) {
                saltlen = strlen(salt);
        }

        data.hash_algorithm[0] = MHASH_MD5;
        data.count = 0;
        data.salt = (void*) salt;
        data.salt_size = saltlen;
        passlen = strlen(password);

        if (mhash_keygen_ext(KEYGEN_MCRYPT, data, key, keylen, (unsigned char*) password, passlen) < 0) {
                goto error;
        }

        this->key = key;
        this->password = strndup(password, passlen);
        this->salt = strndup(salt, saltlen);

#ifdef DUMP
        printf("key(%d): 0x", keylen);
        for (int i = 0; i < keylen; i++) {
                printf("%.2x", this->key[i]);
        }
        printf("\n");
#endif

        return true;

error:
        if (key) { /* Scrub local key value before release. */
                memset(key, 0, this->keylen);
                SAFE_FREE(key);
        }

        return false;
}

const char* Crypt::getPassword(void) {
        return password;
}

const unsigned char* Crypt::getKey(void) {
        return key;
}

void Crypt::setKeyLen(int bits) {
        int maxlen = mcrypt_enc_get_key_size(td);
        keylen = bits / 8;

        if (keylen > maxlen) {
                keylen = maxlen;
        } else if (keylen < 1) {
                keylen = CRYPT_KEYLEN_DEF;
        }

        /* KeyLen change invalides key */
        if (password && salt) {
                char *tpassword = strdup(password);
                char *tsalt = strdup(salt);

                setPassword(password, salt);

                /* Scrub memory before release */
                memset(tpassword, 0, strlen(tpassword));
                SAFE_FREE(tpassword);

                memset(tsalt, 0, strlen(tsalt));
                SAFE_FREE(tsalt);
        }
}

int Crypt::getKeyLen(void) const {
        return (keylen * 8);
}

bool Crypt::encrypt(char *plaintext, int len) {
        if (!plaintext || len < 1) {
                return false;
        }

        if (!initialize()) {
                return false;
        }

        return !mcrypt_generic(td, plaintext, len);
}

bool Crypt::decrypt(char *ciphertext, int len) {
        if (!ciphertext || len < 1) {
                return false;
        }

        if (!initialize()) {
                return false;
        }

        return !mdecrypt_generic(td, ciphertext, len);
}

bool Crypt::check(const char *ciphertext, int len) {
        bool retval;
        void *tmp;

        if ((tmp = malloc(len)) == NULL) {
                return false;
        }

        memcpy(tmp, ciphertext, len);

        retval = decrypt((char*) tmp, len);

        memset(tmp, 0, len); /* Scrub memory before release */
        free(tmp);

        return retval;
}

bool Crypt::initialize(void) {
        if (!deinitialize()) {
                return false;
        }

        if (iv == NULL) {
                if (!generateIV()) {
                        return false;
                }
        }

        if (mcrypt_generic_init(td, key, keylen, iv) >= 0) {
                init = true;

                return true;
        }

        return false;
}

bool Crypt::deinitialize(void) {
        if (init) {
                init = false;

                if (mcrypt_generic_deinit(td) < 0) {
                        return false;
                }
        }

        return true;
}

bool Crypt::generateIV(void) {
        struct drand48_data state;
        long int result;
        int iv_size = mcrypt_enc_get_iv_size(td);

        if (this->iv) { /* Scrub from memory before release */
                memset(this->iv, 0, iv_size);
                SAFE_FREE(this->iv);
        }

        if ((this->iv = (unsigned char*) malloc(iv_size)) == NULL) {
                return false;
        }

        srand48_r(seed, &state);
        for (int i = 0; i < iv_size; i++) {
                lrand48_r(&state, &result);
                this->iv[i] = (unsigned char) result;
        }

#ifdef DUMP
        printf("iv(%d)[seed: %lu]: 0x", iv_size, seed);
        for (int i = 0; i < iv_size; i++) {
                printf("%.1x", this->iv[i]);
        }
        printf("\n");
#endif

        return true;
}

#endif

/*
** vim: noet ts=3 sw=3
*/