cryptography.h

// --*-c++-*--
/*
  $Id: cryptography_8h-source.html,v 1.1 2004/10/05 21:12:01 mentat Exp $
 
  GNU Messenger - The secure instant messenger
  Copyright (C) 2002-2004  Jesse Lovelace - jllovela@eos.ncsu.edu
 
  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

*/
#ifndef GM_CRYPTOGRAPHY_H
#define GM_CRYPTOGRAPHY_H

#include <string>
#include "gm/exception.h"
#include "gm/buffer.h"
#include "gm/crypto_defs.h"
#include "cryptopp/misc.h"
#include "cryptopp/secblock.h"

namespace GNUMessenger {

    using namespace std;
    using namespace CryptoPP;

    //template<class CIPHER, class MODE>
    class CryptoSession {
    public:
        CryptoSession(const string& pk);
        
    private:
       // CIPHER m_ciper;
       // MODE m_mode;
    };

    class CryptoManager {
    public:

        class CryptoError: public Exception
        {
        public:
            CryptoError(const string& msg): Exception(msg) {}
        };
    
        class IOError: public CryptoError
        {
        public:
            IOError(const string& msg): CryptoError(msg) {}
        };

        class InvalidPassword: public CryptoError
        {
        public:
            InvalidPassword(const string& msg): CryptoError(msg) {}
        };

        class AuthFailed: public CryptoError
        {
        public:
            AuthFailed(const string& msg): CryptoError(msg) {}
        };
    
        class RNGError: public CryptoError
        {
        public:
            RNGError(const string& msg): CryptoError(msg) {}
        };
        
        class AlgoError: public CryptoError
        {
        public:
            AlgoError(const string& msg): CryptoError(msg) {}
        };
        
        class BlockSizeError: public CryptoError
        {
        public:
            BlockSizeError(const string& msg): CryptoError(msg) {}
        };
        
        class KeySizeError: public CryptoError
        {
        public:
            KeySizeError(const string& msg, const unsigned int min = 0,
                         const unsigned int max = 0,
                         const unsigned int mult = 0)
                : CryptoError(msg), m_max(max), m_min(min), m_mult(mult) {}
            unsigned int GetMax() { return m_max; }
            unsigned int GetMin() { return m_min; }
            unsigned int GetMult() { return m_mult; }
                
        private:
            unsigned int m_max;
            unsigned int m_min;
            unsigned int m_mult;
        
        };
    
    CryptoManager(const string& pk);

    virtual ~CryptoManager();

        CryptoSession * createSession();

    static byte * hash(const string& str, unsigned int& len, 
                           CryptDefines::Hashes type = CryptDefines::DefaultHash)
            throw (AlgoError);
    
    static string encode(const SecByteBlock& array,
                         CryptDefines::Encoding enc = CryptDefines::DefaultEncoder)
            throw (AlgoError);
            
    static string encode(const string& str, 
                         CryptDefines::Encoding enc = CryptDefines::DefaultEncoder) {
        SecByteBlock sec((const unsigned char *)str.c_str(), str.length());
        return encode(sec, enc);
    }

        static byte * decode(const string& input, unsigned int& outLen,
                             CryptDefines::Encoding enc) throw (AlgoError);
        
    
    static string hashEncode(const string& str,
                                 CryptDefines::Hashes type = CryptDefines::DefaultHash,
                                 CryptDefines::Encoding enc = CryptDefines::DefaultEncoder)
            throw (AlgoError);
    
    static byte * generateRandom(const unsigned int size) throw (RNGError);
    
    static byte * encrypt(const SecByteBlock& data,
                              const SecByteBlock& key, 
                              unsigned int& resultLen,
                              const unsigned int blockSize = 0,
                              CryptDefines::BlockCipher cipher = CryptDefines::DefaultBC,
                              CryptDefines::Mode mode = CryptDefines::DefaultMode) 
            throw (RNGError, AlgoError, KeySizeError, BlockSizeError);
        
    static void encryptToFileWithHMAC(const string& filename,
                                      const SecByteBlock& data, 
                                      const SecByteBlock& key,
                                      const unsigned int blockSize = 0,
                                      CryptDefines::BlockCipher bc = CryptDefines::DefaultBC,
                                      CryptDefines::Mode mode = CryptDefines::DefaultMode,
                                      CryptDefines::Hashes hash = CryptDefines::DefaultHash) 
        throw (RNGError, AlgoError, KeySizeError, BlockSizeError, IOError);
        
    static byte * compress(const SecByteBlock& data,
                               unsigned int& resultLen, 
                               const unsigned int level = CryptDefines::DEFAULT_COMPRESS_LEVEL);
        
    static byte * decompress(const SecByteBlock& data,
                                 unsigned int& resultLen);

    static byte * generateIV(const SecByteBlock& data, 
                                 CryptDefines::Hashes hash = CryptDefines::DefaultHash);
        
    static unsigned int testRNG(const unsigned int insize) throw (RNGError);
    
    static bool encryptFile(const string& filename, const VBuffer& key,
                     const string& data)
        throw (IOError);
                                   
    static string decryptFile(const string& filename, const VBuffer &key)
        throw (InvalidPassword, AuthFailed);
        
    static string hashEncode(const VBuffer& toHash, 
                      CryptDefines::Hashes hash = CryptDefines::DefaultHash, 
                      CryptDefines::Encoding enc = CryptDefines::DefaultEncoder);
                      
    static VBuffer hash(const VBuffer& toHash, CryptDefines::Hashes hash = CryptDefines::DefaultHash);

    
    protected:
    static HashTransformation * getHash(CryptDefines::Hashes type)
            throw (AlgoError);
    

        static SymmetricCipher * getEncryptor(
            CryptDefines::BlockCipher cipher,
            CryptDefines::Mode mode)
            throw (AlgoError);
    };
    

} // !GNUMessenger


#endif 

/*
  -----
  $Log: cryptography.h,v $
  Revision 1.1.1.1  2004/10/03 06:17:37  mentat
  Initial re-import.

  Revision 1.2  2003/04/09 21:18:30  mentat
  Adding new headers and pruning old.

  Revision 1.1  2003/04/05 23:12:28  mentat
  Moving headers to a new dir.


*/

---