cryptography.cpp

// --*-c++-*--
/*
  $Id: cryptography_8cpp-source.html,v 1.1 2004/10/05 21:12:01 mentat Exp $
 
  GNU Messenger - The secure instant messenger
  Copyright (C) 2001-2004  Jesse Lovelace
 
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <string>
#include <memory>
#include <cmath>

#include "cryptopp/misc.h"
#include "cryptopp/idea.h"
#include "cryptopp/rng.h"
#include "cryptopp/osrng.h"
#include "cryptopp/files.h"
#include "cryptopp/rsa.h"
#include "cryptopp/queue.h"
#include "cryptopp/randpool.h"
#include "cryptopp/hex.h"
#include "cryptopp/osrng.h"
#include "cryptopp/rijndael.h"
#include "cryptopp/mars.h"
#include "cryptopp/des.h"
#include "cryptopp/3way.h"
#include "cryptopp/idea.h"
#include "cryptopp/serpent.h"
#include "cryptopp/rc2.h"
#include "cryptopp/rc5.h"
#include "cryptopp/blowfish.h"
#include "cryptopp/rc6.h"
#include "cryptopp/camellia.h"
#include "cryptopp/twofish.h"
#include "cryptopp/tea.h"
#include "cryptopp/modes.h"
#include "cryptopp/sha.h"
#include "cryptopp/md2.h"
#include "cryptopp/md5.h"
#include "cryptopp/haval.h"
#include "cryptopp/ripemd.h"
#include "cryptopp/tiger.h"
#include "cryptopp/default.h"
#include "cryptopp/base64.h"
#include "cryptopp/base32.h"
#include "cryptopp/panama.h"
#include "cryptopp/gzip.h"
#include "cryptopp/zlib.h"
#include "cryptopp/filters.h"
#include "cryptopp/secblock.h"

#include "gm/cryptography.h"
#include "gm/crypto_defs.h"
#include "gm/misc.h"

namespace GNUMessenger {

    using namespace CryptoPP;
    using namespace std;

   /* template<class T>
    StreamTransformationFilter* getMode(CryptDefines::Mode mode)
        throw (CryptoManager::AlgoError)
    {
        SecByteBlock key;
        switch (mode) {
            case(CryptDefines::CBC_CTS):
                CBC_CTS_Mode<T>::Encryption enc(key, key.size());
                return new StreamTransformationFilter(enc);
            case(CryptDefines::CBC):
                CBC_Mode<T>::Encryption enc(key, key.size());
                return new StreamTransformationFilter(enc);
            case(CryptDefines::CFB):
                CFB_Mode<T>::Encryption enc(key, key.size());
                return new StreamTransformationFilter(enc);
            case(CryptDefines::CTR):
                CTR_Mode<T>::Encryption enc(key, key.size());
                return new StreamTransformationFilter(enc);
            case(CryptDefines::ECB):
                ECB_Mode<T>::Encryption enc(key, key.size());
                return new StreamTransformationFilter(enc);
            case(CryptDefines::OFB):
                OFB_Mode<T>::Encryption enc(key, key.size());
                return new StreamTransformationFilter(enc);
            default: throw CryptoManager::AlgoError("Invalid cipher mode");
        }
    }*/


#if 0 // dunno if i need these
    void Cryptography::compressFile(const string& data, const string& filename)
    {

        try {
                StringSource f(data.c_str(), true,
                               new Gzip(
                                   new FileSink(filename.c_str())
                                   )
                               );
        } catch (CryptoPP::Exception &e) {
                throw DiskError(e.what());
        }

    }

    string Cryptography::decompressFile(const string& infile)
    {

    string decryptedFile;
    try {
            FileSource f(infile.c_str(), true,
                         new Gunzip(
                             new StringSink(decryptedFile)
                             )
                         );
    } catch (CryptoPP::Exception &e) {
            throw DiskError(e.what());
    }
    return decryptedFile;

    }
#endif

    HashTransformation * CryptoManager::getHash(CryptDefines::Hashes type)
        throw (AlgoError)
    {
    switch (type)
    {
            case(CryptDefines::SHA1): return new SHA();
            case(CryptDefines::SHA_256): return new SHA256();
            case(CryptDefines::SHA_384): return new SHA384();
            case(CryptDefines::SHA_512): return new SHA512();
            case(CryptDefines::MD_2): return new MD2();
            case(CryptDefines::MD_5): return new MD5();
            case(CryptDefines::HAVAL_3): return new HAVAL3();
            case(CryptDefines::HAVAL_4): return new HAVAL4();
            case(CryptDefines::HAVAL_5): return new HAVAL5();
            case(CryptDefines::RIPEMD_160): return new RIPEMD160();
            case(CryptDefines::_TIGER): return new Tiger();
#ifdef IS_LITTLE_ENDIAN
            case(CryptDefines::PANAMA_HASH):
                return new PanamaHash<LittleEndian>();
#else
            case(CryptDefines::PANAMA_HASH):
                return new PanamaHash<BigEndian>();
#endif
            default: throw AlgoError("Invalid Hash Algorithm.");
    }
    }

    byte * CryptoManager::hash(const string& data, unsigned int& len,
                               CryptDefines::Hashes hashType) throw (AlgoError)
    {
        auto_ptr<HashTransformation> theHash(getHash(hashType));

        byte * result = new byte[theHash->DigestSize()];
        theHash->CalculateDigest(result, (byte *)data.c_str(), data.length());
    
        return result;
    }
    
    byte * CryptoManager::generateIV(const SecByteBlock& data,
                                     CryptDefines::Hashes hash)
    {
        auto_ptr<HashTransformation> theHash(getHash(hash));
        
        byte * result = new byte[theHash->DigestSize()];
        
        SecByteBlock hashed(theHash->DigestSize());
        theHash->CalculateDigest(hashed, data, data.size());
        
        // digestsize should always be 2a = b
            for (unsigned int i = 0; i < theHash->DigestSize() / 2; i++) 
                result[i] = hashed[i] ^ hashed[i+ (theHash->DigestSize() / 2)];
        
        return result;
    }

    unsigned int CryptoManager::testRNG(const unsigned int insize)
        throw (RNGError)
    {
        unsigned int result = 0;
        
        byte * randomData = generateRandom(insize);
        byte * compressedData = compress(SecByteBlock(randomData, insize),
                                             result);
        delete [] compressedData;
        delete [] randomData;
        
        return result;
    
    }

    byte * CryptoManager::generateRandom(const unsigned int size)
        throw (RNGError)
    {

        byte * result = new byte[size];
        
            AutoSeededRandomPool rng;
        try {
                rng.GenerateBlock(result, size);
        } catch (OS_RNG_Err &e) {
                delete [] result;
                throw RNGError(e.what());
        }
        return result;

    }

    byte * CryptoManager::compress(const SecByteBlock& data,
                                   unsigned int& resultLen, 
                                   const unsigned int level)
    {
        ZlibCompressor z(NULL, level);
        z.Put(data, data.size());
            z.MessageEnd();
        
        resultLen = z.MaxRetrievable();
        byte * out = new byte[resultLen];
        z.Get(out, z.MaxRetrievable());
        
        return out;
    }

    byte * CryptoManager::decompress(const SecByteBlock& data,
                                     unsigned int& resultLen)
    {
        ZlibDecompressor inflate;
        inflate.Put(data, data.size());
        inflate.MessageEnd();
        
        resultLen = inflate.MaxRetrievable();
        byte * out = new byte[resultLen];
        inflate.Get(out, inflate.MaxRetrievable());
        
        return out;
    }

    byte * CryptoManager::encrypt(const SecByteBlock& data,
                                  const SecByteBlock& key, 
                                  unsigned int& resultLen,
                                  const unsigned int blockSize,
                                  CryptDefines::BlockCipher cipher,
                                  CryptDefines::Mode mode)
    throw (RNGError, AlgoError, KeySizeError, BlockSizeError)
    {

        auto_ptr<SymmetricCipher> theCipher(getEncryptor(cipher,mode));
    
        if (!theCipher->IsValidKeyLength(key.size()))
            throw KeySizeError("Invalid key size for this cipher",
                                   theCipher->MinKeyLength(),
                                   theCipher->MaxKeyLength());
    
        if (theCipher->IVRequirement() == theCipher->RANDOM_IV)
                LOG_DEBUG("Requires random IV");
        
        SecByteBlock iv(
            generateIV(
                SecByteBlock(
                    generateRandom(theCipher->MandatoryBlockSize()),
                    theCipher->MandatoryBlockSize()
                    )
                ),
            theCipher->MandatoryBlockSize()
        );

        theCipher->SetKeyWithIV(key, key.size(), iv);
        ArraySink cipherText;
            
        StreamTransformationFilter encryptor(*theCipher, &cipherText);
        encryptor.Put(data, data.size());
        // input more plaintext here if needed
        encryptor.MessageEnd();
        return NULL;
    }

    string CryptoManager::encode(const SecByteBlock& data,
                                 CryptDefines::Encoding type) throw (AlgoError)
    {
        string result;
        auto_ptr<SimpleProxyFilter> encoder;
        
        switch (type) { // @todo This isn't optimal
                case(CryptDefines::Base64):
                    encoder.reset(new Base64Encoder(new StringSink(result)));
                    break;
                case(CryptDefines::Base32):
                    encoder.reset(new Base32Encoder(new StringSink(result)));
                    break;
                case(CryptDefines::Hex):
                    encoder.reset(new HexEncoder(new StringSink(result)));
                    break;
                default: throw AlgoError("No such encoding system.");
        }
    
        encoder->Put(data, data.size());
        encoder->MessageEnd();
        return result;
    }

    SymmetricCipher * CryptoManager::getEncryptor(
        CryptDefines::BlockCipher cipher,
        CryptDefines::Mode mode)
        throw (AlgoError)
    {

       
        return NULL;
    }


    bool CryptoManager::encryptFile(const string& filename, const VBuffer& key,
                                   const string& data) throw (IOError)
    {

        // generating random seed for iv
        SecByteBlock ivSeed(CryptDefines::IV_SEED_LENGTH);
        SecByteBlock realIv(CryptDefines::IV_LENGTH);
        
        AutoSeededRandomPool rng;
        rng.GenerateBlock(ivSeed, CryptDefines::IV_SEED_LENGTH);
        
        //creating actual iv, thanks to denis bider for this method
        SecByteBlock ivHash(SHA256::DIGESTSIZE);
        SHA256().CalculateDigest(ivHash, ivSeed, CryptDefines::IV_SEED_LENGTH);
        
        for (unsigned int i = 0; i != CryptDefines::IV_LENGTH; ++i)
            realIv[i] = ivHash[i] ^ ivHash[i+16];

        //compress 
        ZlibCompressor z(NULL,9);
        z.Put((const unsigned char *)data.c_str(),
              static_cast<unsigned int>(data.length()));
        z.MessageEnd();

        SecByteBlock compressedPlainText(z.MaxRetrievable());
        z.Get(compressedPlainText, compressedPlainText.size());

        //encrypting
        SecByteBlock cipherText(compressedPlainText.size());

        CBC_Mode<MARS>::Encryption enc(key.data(), key.size(), realIv.data()); 
        StreamTransformationFilter encryptor(enc);
        encryptor.Put(compressedPlainText, compressedPlainText.size());
        encryptor.MessageEnd();
        
        cipherText.CleanGrow(encryptor.MaxRetrievable());
        encryptor.Get(cipherText, cipherText.size());

        // create HMAC
        SecByteBlock myMac(HMAC<SHA>::DIGESTSIZE);
        HMAC<SHA> themac(key.data(), key.size());
        themac.Update(cipherText, cipherText.size());
        themac.Final(myMac);

        // setup output file and encode the file as base64
        try {
            Base64Encoder encoder(new FileSink(filename.c_str(), false));
            encoder.Put(realIv, CryptDefines::IV_LENGTH);
            encoder.Put(cipherText, cipherText.size());
            encoder.Put(myMac, HMAC<SHA>::DIGESTSIZE);
            encoder.MessageEnd();

        } catch(CryptoPP::Exception &e) {
            throw IOError(e.what());
        }
    
        return true;

    }

    string CryptoManager::decryptFile(const string& filename,
                                     const VBuffer &key) 
                                     throw (InvalidPassword, AuthFailed)
    {
        // read from file
        FileSource inputFile(filename.c_str(), true);
        SecByteBlock dataFromFile(inputFile.MaxRetrievable());
        inputFile.Get(dataFromFile, dataFromFile.size());

        // decode from base64
        Base64Decoder decoder64;
        decoder64.Put(dataFromFile, dataFromFile.size());
        decoder64.MessageEnd();

        SecByteBlock iv(CryptDefines::IV_LENGTH);
        SecByteBlock payload(decoder64.MaxRetrievable() -
                             CryptDefines::IV_LENGTH - HMAC<SHA>::DIGESTSIZE);
        SecByteBlock hmac(HMAC<SHA>::DIGESTSIZE);

        //SecByteBlock decodedData(decoder64.MaxRetrievable());
        decoder64.Get(iv, CryptDefines::IV_LENGTH);
        decoder64.Get(payload, payload.size());
        decoder64.Get(hmac, HMAC<SHA>::DIGESTSIZE);

        // decrypt, dat becomes new compressed cipher text.
        CBC_Mode<MARS>::Decryption dec(key.data(), key.size(), iv.data());
        StreamTransformationFilter decf(dec);

        try {
            decf.Put(payload, payload.size());
            decf.MessageEnd();
        } catch (CryptoPP::Exception& e) {
            throw InvalidPassword(e.what());
        }

        // verify hmac digest

        if (!HMAC<SHA>(key.data(), key.size()).VerifyDigest(hmac, payload,
                                                            payload.size()))
            throw AuthFailed("File digest not verified.");

        // create object to store compressed plain text
        SecByteBlock compressedPlaintext(decf.MaxRetrievable());

        // put decrypted data in
        decf.Get(compressedPlaintext, compressedPlaintext.size());

        string output;
        ZlibDecompressor zDecompressor(new StringSink(output));
        zDecompressor.Put(compressedPlaintext, compressedPlaintext.size());
        zDecompressor.MessageEnd();

        return output;

    }
    
string CryptoManager::hashEncode(const VBuffer& toHash, 
                      CryptDefines::Hashes hashf, 
                      CryptDefines::Encoding enc)
{
    VBuffer block(hash(toHash, hashf));
    auto_ptr<Filter> encoding;

    string outString;

    switch (enc) {
        case (CryptDefines::Hex):
            encoding.reset(new HexEncoder(new StringSink(outString)));
            break;
        case (CryptDefines::Base64):
            encoding.reset(new Base64Encoder(new StringSink(outString), false));
            break;
        case (CryptDefines::Base32):
            encoding.reset(new Base32Encoder(new StringSink(outString), false));
            break;
        default: break;
    };
        
    encoding->Put(block.data(), block.size());
    encoding->MessageEnd();

    return outString;
}


VBuffer CryptoManager::hash(const VBuffer& toHash, CryptDefines::Hashes hashf)
{
    auto_ptr<HashTransformation> hash;

    switch (hashf)
    {
    case(CryptDefines::SHA1): hash.reset(new SHA); break;
    case(CryptDefines::SHA_256): hash.reset(new SHA256); break;
    case(CryptDefines::SHA_384): hash.reset(new SHA384); break;
    case(CryptDefines::SHA_512): hash.reset(new SHA512); break;
    case(CryptDefines::MD_2): hash.reset(new MD2); break;
    case(CryptDefines::MD_5): hash.reset(new MD5); break;
    case(CryptDefines::HAVAL_3): hash.reset(new HAVAL3); break;
    case(CryptDefines::HAVAL_4): hash.reset(new HAVAL4); break;
    case(CryptDefines::HAVAL_5): hash.reset(new HAVAL5); break;
    case(CryptDefines::RIPEMD_160): hash.reset(new RIPEMD160); break;
    case(CryptDefines::_TIGER): hash.reset(new Tiger); break;
    }

    SecByteBlock retBlock(hash->DigestSize());
    hash->CalculateDigest(retBlock, toHash.data(), toHash.size());

    VBuffer ret(retBlock.begin(), retBlock.size());

    return ret;

}

} 

---