408 lines
10 KiB
C++
408 lines
10 KiB
C++
//
|
|
// The developer of the original code and/or files is Tripwire, Inc.
|
|
// Portions created by Tripwire, Inc. are copyright (C) 2000 Tripwire,
|
|
// Inc. Tripwire is a registered trademark of Tripwire, Inc. All rights
|
|
// reserved.
|
|
//
|
|
// This program is free software. The contents of this file are subject
|
|
// to 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. You may redistribute it and/or modify it
|
|
// only in compliance with the GNU General Public License.
|
|
//
|
|
// This program is distributed in the hope that it will be useful.
|
|
// However, this program is distributed AS-IS WITHOUT ANY
|
|
// WARRANTY; INCLUDING THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS
|
|
// FOR A PARTICULAR PURPOSE. Please 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.
|
|
//
|
|
// Nothing in the GNU General Public License or any other license to use
|
|
// the code or files shall permit you to use Tripwire's trademarks,
|
|
// service marks, or other intellectual property without Tripwire's
|
|
// prior written consent.
|
|
//
|
|
// If you have any questions, please contact Tripwire, Inc. at either
|
|
// info@tripwire.org or www.tripwire.org.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// crypto.h -- Tripwire crypto header
|
|
//
|
|
|
|
#ifndef __CRYPTO_H
|
|
#define __CRYPTO_H
|
|
|
|
#ifndef __TYPES_H
|
|
#include "types.h"
|
|
#endif
|
|
|
|
#ifndef __TCHAR_H
|
|
#include "core/tchar.h"
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// class iCipher
|
|
|
|
class iCipher
|
|
{
|
|
public:
|
|
virtual ~iCipher() {}
|
|
|
|
enum EncryptionDir { ENCRYPT, DECRYPT };
|
|
|
|
virtual int GetBlockSizePlain() = 0;
|
|
virtual int GetBlockSizeCipher() = 0;
|
|
// return the size of data blocks this crypter works on.
|
|
virtual void ProcessBlock(const void* indata, void* outdata) = 0; // throw eArchive
|
|
// process a block of data. indata and outdata may be the same memory
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// class cNullCipher -- no encryption cipher
|
|
|
|
class cNullCipher : public iCipher
|
|
{
|
|
public:
|
|
cNullCipher() {}
|
|
virtual ~cNullCipher() {}
|
|
|
|
virtual int GetBlockSizePlain();
|
|
virtual int GetBlockSizeCipher();
|
|
// return the size of data blocks for plaintext and cipertext
|
|
virtual void ProcessBlock(const void* indata, void* outdata);
|
|
// process a block of data. indata and outdata may be the same memory
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// class cIDEACipher
|
|
|
|
#ifdef _IDEA_ENCRYPTION
|
|
class cIDEA_i;
|
|
class cHashedKey128;
|
|
|
|
class cIDEA : public iCipher
|
|
{
|
|
public:
|
|
cIDEA();
|
|
virtual ~cIDEA();
|
|
|
|
void SetKey(iCipher::EncryptionDir dir, const cHashedKey128& key);
|
|
|
|
virtual int GetBlockSizePlain();
|
|
virtual int GetBlockSizeCipher();
|
|
// return the size of data blocks for plaintext and cipertext
|
|
virtual void ProcessBlock(const void* indata, void* outdata);
|
|
// process a block of data. indata and outdata may be the same memory
|
|
|
|
protected:
|
|
cIDEA_i* mpData;
|
|
};
|
|
#endif // _IDEA_ENCRYPTION
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// class cTripleDES
|
|
|
|
class cTripleDES_i;
|
|
class cHashedKey192;
|
|
|
|
class cTripleDES : public iCipher
|
|
{
|
|
public:
|
|
cTripleDES();
|
|
virtual ~cTripleDES();
|
|
|
|
void SetKey(iCipher::EncryptionDir dir, const cHashedKey192& key);
|
|
|
|
virtual int GetBlockSizePlain();
|
|
virtual int GetBlockSizeCipher();
|
|
// return the size of data blocks for plaintext and cipertext
|
|
virtual void ProcessBlock(const void* indata, void* outdata);
|
|
// process a block of data. indata and outdata may be the same memory
|
|
|
|
protected:
|
|
cTripleDES_i* mpData;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// class cRSA
|
|
|
|
#ifdef _RSA_ENCRYPTION
|
|
|
|
class cRSA_i;
|
|
class cRSAPublicKey;
|
|
class cRSAPrivateKey;
|
|
|
|
class cRSA : public iCipher
|
|
{
|
|
public:
|
|
enum KeySize
|
|
{
|
|
KEY256 = 256,
|
|
KEY512 = 512,
|
|
KEY1024 = 1024,
|
|
KEY2048 = 2048
|
|
};
|
|
|
|
explicit cRSA(KeySize keysize);
|
|
explicit cRSA(const cRSAPublicKey& publicKey); // read keysize from key
|
|
explicit cRSA(const cRSAPrivateKey& privateKey); // ditto
|
|
virtual ~cRSA();
|
|
|
|
void SetEncrypting(const cRSAPublicKey* pKey);
|
|
void SetDecrypting(const cRSAPrivateKey* pKey);
|
|
void SetSigning(const cRSAPrivateKey* pKey);
|
|
void SetVerifying(const cRSAPublicKey* pKey);
|
|
|
|
virtual int GetBlockSizePlain();
|
|
virtual int GetBlockSizeCipher();
|
|
// return the size of data blocks for plaintext and cipertext
|
|
virtual void ProcessBlock(const void* indata, void* outdata);
|
|
// process a block of data. indata and outdata may be the same memory
|
|
|
|
void GenerateKeys(cRSAPrivateKey*& retPrivate, cRSAPublicKey*& retPublic);
|
|
// generate public and private keys. Caller is responsible for deleting these keys when done
|
|
|
|
protected:
|
|
cRSA_i* mpData;
|
|
|
|
private:
|
|
void Init(KeySize keysize);
|
|
};
|
|
|
|
class cRSAPrivateKey_i;
|
|
class cRSAPublicKey_i;
|
|
|
|
// cRSAPrivateKey
|
|
|
|
class cRSAPrivateKey
|
|
{
|
|
friend class cRSA;
|
|
friend class cRSAPublicKey;
|
|
public:
|
|
explicit cRSAPrivateKey(void* pDataStream);
|
|
~cRSAPrivateKey();
|
|
|
|
int GetWriteLen() const;
|
|
void Write(void* pDataStream) const;
|
|
|
|
protected:
|
|
cRSAPrivateKey_i* mpData;
|
|
|
|
private:
|
|
cRSAPrivateKey(); // cRSA should be used to generate keys
|
|
};
|
|
|
|
// cRSAPublicKey
|
|
|
|
class cRSAPublicKey
|
|
{
|
|
friend class cRSA;
|
|
public:
|
|
explicit cRSAPublicKey(void* pDataStream);
|
|
explicit cRSAPublicKey(const cRSAPrivateKey& privateKey);
|
|
~cRSAPublicKey();
|
|
|
|
int GetWriteLen() const;
|
|
void Write(void* pDataStream) const;
|
|
|
|
#ifdef _DEBUG
|
|
void TraceContents();
|
|
#endif
|
|
|
|
protected:
|
|
cRSAPublicKey_i* mpData;
|
|
|
|
private:
|
|
cRSAPublicKey(); // cRSA should be used to generate keys
|
|
};
|
|
|
|
#endif // _RSA_ENCRYPTION
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// class cElGamalSig
|
|
//
|
|
// This class does not encrypt the cipher stream. For each block written
|
|
// it signs a hash of the block and appends the signature to the end of the
|
|
// block. When reading an exception will be thrown if the signature does
|
|
// not match the data.
|
|
//
|
|
// We use El Gamal because it is patent free..
|
|
//
|
|
|
|
class cElGamalSig_i;
|
|
class cElGamalSigPublicKey;
|
|
class cElGamalSigPrivateKey;
|
|
|
|
class cElGamalSig : public iCipher
|
|
{
|
|
public:
|
|
enum KeySize
|
|
{
|
|
KEY256 = 256,
|
|
KEY512 = 512,
|
|
KEY1024 = 1024,
|
|
KEY2048 = 2048
|
|
};
|
|
|
|
explicit cElGamalSig(KeySize keysize);
|
|
explicit cElGamalSig(const cElGamalSigPublicKey& publicKey); // read keysize from key
|
|
explicit cElGamalSig(const cElGamalSigPrivateKey& privateKey); // ditto
|
|
virtual ~cElGamalSig();
|
|
|
|
void SetSigning(const cElGamalSigPrivateKey* pKey);
|
|
void SetVerifying(const cElGamalSigPublicKey* pKey);
|
|
|
|
virtual int GetBlockSizePlain();
|
|
virtual int GetBlockSizeCipher();
|
|
// return the size of data blocks for plaintext and cipertext
|
|
virtual void ProcessBlock(const void* indata, void* outdata);
|
|
// process a block of data. indata and outdata may be the same memory
|
|
|
|
void GenerateKeys(cElGamalSigPrivateKey*& retPrivate, cElGamalSigPublicKey*& retPublic);
|
|
// generate public and private keys. Caller is responsible for deleting these keys when done
|
|
|
|
protected:
|
|
cElGamalSig_i* mpData;
|
|
|
|
private:
|
|
void Init(KeySize keysize);
|
|
|
|
enum { PLAIN_BLOCK_SIZE = 4083 };
|
|
};
|
|
|
|
class cElGamalSigPrivateKey_i;
|
|
class cElGamalSigPublicKey_i;
|
|
|
|
// cElGamalSigPrivateKey
|
|
|
|
class cElGamalSigPrivateKey
|
|
{
|
|
friend class cElGamalSig;
|
|
friend class cElGamalSigPublicKey;
|
|
public:
|
|
explicit cElGamalSigPrivateKey(void* pDataStream);
|
|
~cElGamalSigPrivateKey();
|
|
|
|
int GetWriteLen() const;
|
|
void Write(void* pDataStream) const;
|
|
|
|
protected:
|
|
cElGamalSigPrivateKey_i* mpData;
|
|
|
|
private:
|
|
cElGamalSigPrivateKey(); // cElGamal should be used to generate keys
|
|
};
|
|
|
|
// cElGamalSigPublicKey
|
|
|
|
class cElGamalSigPublicKey
|
|
{
|
|
friend class cElGamalSig;
|
|
public:
|
|
explicit cElGamalSigPublicKey(void* pDataStream);
|
|
explicit cElGamalSigPublicKey(const cElGamalSigPrivateKey& privateKey);
|
|
~cElGamalSigPublicKey();
|
|
|
|
int GetWriteLen() const;
|
|
void Write(void* pDataStream) const;
|
|
|
|
bool IsEqual(const cElGamalSigPublicKey& rhs) const;
|
|
// This is used to make sure the key used to sign the config
|
|
// file is the same as the key we are currently using.
|
|
|
|
#ifdef _DEBUG
|
|
void TraceContents();
|
|
#endif
|
|
|
|
protected:
|
|
cElGamalSigPublicKey_i* mpData;
|
|
|
|
private:
|
|
cElGamalSigPublicKey(); // cElGamal should be used to generate keys
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// class cHashedKey128 -- A 128 bit key based on the hash value of some data
|
|
|
|
class cHashedKey128
|
|
{
|
|
public:
|
|
explicit cHashedKey128(const TSTRING& data);
|
|
cHashedKey128(void* pData, int dataLen);
|
|
~cHashedKey128();
|
|
|
|
const int8* GetKey() const;
|
|
|
|
static int GetWriteLen();
|
|
void Write(void* pDataStream);
|
|
|
|
protected:
|
|
enum { KEYLEN = 16, BUFSIZE = 20};
|
|
|
|
int8 mKey[BUFSIZE];
|
|
};
|
|
|
|
inline const int8* cHashedKey128::GetKey() const
|
|
{
|
|
return mKey;
|
|
}
|
|
|
|
inline int cHashedKey128::GetWriteLen()
|
|
{
|
|
return KEYLEN;
|
|
}
|
|
|
|
inline void cHashedKey128::Write(void* pDataStream)
|
|
{
|
|
memcpy(pDataStream, mKey, KEYLEN);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// class cHashedKey192 -- A 192 bit key based on the hash value of some data
|
|
|
|
class cHashedKey192
|
|
{
|
|
public:
|
|
explicit cHashedKey192(const TSTRING& data);
|
|
cHashedKey192(void* pData, int dataLen);
|
|
~cHashedKey192();
|
|
|
|
const int8* GetKey() const;
|
|
|
|
static int GetWriteLen();
|
|
void Write(void* pDataStream);
|
|
|
|
protected:
|
|
enum { KEYLEN = 24 };
|
|
|
|
int8 mKey[KEYLEN];
|
|
};
|
|
|
|
inline const int8* cHashedKey192::GetKey() const
|
|
{
|
|
return mKey;
|
|
}
|
|
|
|
inline int cHashedKey192::GetWriteLen()
|
|
{
|
|
return KEYLEN;
|
|
}
|
|
|
|
inline void cHashedKey192::Write(void* pDataStream)
|
|
{
|
|
memcpy(pDataStream, mKey, KEYLEN);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// void RandomizeBytes(byte* destbuf, int len) -- Fill a buffer with random bytes
|
|
|
|
void RandomizeBytes(int8* destbuf, int len);
|
|
|
|
#endif // __CRYPTO_H
|
|
|