ckcrypt2.h

来自「DES加密解密算法,西望大家共享.参考学习」· C头文件 代码 · 共 244 行

// CkCrypt2.h: interface for the CkCrypt2 class.
//
//////////////////////////////////////////////////////////////////////

#ifndef _CKCRYPT2_H
#define _CKCRYPT2_H

#pragma once

class CkCSP;
class CkCert;
class CkCertStore;
#include "CkString.h"
class CkByteData;
#include "CkObject.h"
class CkPrivateKey;

// CLASS: CkCrypt2
class CkCrypt2  : public CkObject
{
    private:
	void *m_impl;
	bool m_utf8;	// If true, all input "const char *" parameters are utf-8, otherwise they are ANSI strings.

	// Don't allow assignment or copying these objects.
	CkCrypt2(const CkCrypt2 &);
	CkCrypt2 &operator=(const CkCrypt2 &);
	CkCrypt2(void *impl);

    public:
	void *getImpl(void) const;

	CkCrypt2();
	virtual ~CkCrypt2();

	void SetSecretKey(const char *keyData, int numBytes);
	void SetIV(const char *ivData, int numBytes);

	// BEGIN PUBLIC INTERFACE
	bool get_Utf8(void) const;
	void put_Utf8(bool b);


	bool SetSigningCert2(const CkCert &cert, CkPrivateKey &key);
	bool SetDecryptCert2(const CkCert &cert, CkPrivateKey &key);

	bool SetCSP(const CkCSP *csp);
	bool SetCSP(const CkCSP &csp) { return this->SetCSP(&csp); }
	CkCert *GetLastCert(void);
	void SetEncryptCert(const CkCert *cert);
	void SetSigningCert(const CkCert *cert);
	void SetVerifyCert(const CkCert *cert);
	void SetEncryptCert(const CkCert &cert) { this->SetEncryptCert(&cert); }
	void SetSigningCert(const CkCert &cert) { this->SetSigningCert(&cert); }
	void SetVerifyCert(const CkCert &cert) { this->SetVerifyCert(&cert); }

	bool CkEncryptFile(const char *inFile, const char *outFile);
	bool CkDecryptFile(const char *inFile, const char *outFile);

	bool CreateDetachedSignature(const char *inFile, const char *sigFile);
	bool VerifyDetachedSignature(const char *inFile, const char *sigFile);

	bool VerifyStringENC(const char *str, const char *encodedSig);
	bool VerifyString(const char *str, const CkByteData &sigData);
	bool VerifyBytesENC(const CkByteData &bData, const char *encodedSig);
	bool VerifyBytes(const CkByteData &bData1, const CkByteData &sigData);

	bool SignStringENC(const char *str, CkString &out);
	bool SignBytesENC(const CkByteData &bData, CkString &out);
	bool SignString(const char *str, CkByteData &out);
	bool SignBytes(const CkByteData &bData, CkByteData &out);

	bool OpaqueVerifyStringENC(const char *p7s, CkString &original);
	bool OpaqueVerifyString(const CkByteData &p7s, CkString &original);
	bool OpaqueVerifyBytesENC(const char *p7s, CkByteData &original);
	bool OpaqueVerifyBytes(const CkByteData &p7s, CkByteData &original);

	bool OpaqueSignStringENC(const char *str, CkString &out);
	bool OpaqueSignBytesENC(const CkByteData &bData, CkString &out);
	bool OpaqueSignString(const char *str, CkByteData &out);
	bool OpaqueSignBytes(const CkByteData &bData, CkByteData &out);

	bool CreateP7S(const char *inFilename, const char *p7sFilename);
	bool VerifyP7S(const char *p7sFilename, const char *outFilename);

	bool InflateStringENC(const char *str, CkString &out);
	bool InflateString(const CkByteData &bData, CkString &out);
	bool InflateBytesENC(const char *str, CkByteData &out);
	bool InflateBytes(const CkByteData &bData, CkByteData &out);

	bool CompressStringENC(const char *str, CkString &out);
	bool CompressBytesENC(const CkByteData &bData, CkString &out);
	bool CompressString(const char *str, CkByteData &out);
	bool CompressBytes(const CkByteData &bData, CkByteData &out);

	bool get_CompressionAlgorithm(CkString &out);
	void put_CompressionAlgorithm(const char *alg);

	bool DecryptStringENC(const char *str, CkString &out);
	bool DecryptString(const CkByteData &bData, CkString &out);
	bool DecryptBytesENC(const char *str, CkByteData &out);
	bool DecryptBytes(const CkByteData &bData, CkByteData &out);

	bool EncryptStringENC(const char *str, CkString &out);
	bool EncryptBytesENC(const CkByteData &bData, CkString &out);
	bool EncryptString(const char *str, CkByteData &out);
	bool EncryptBytes(const CkByteData &bData, CkByteData &out);

	bool HashBytesENC(const CkByteData &bData, CkString &out);
	bool HashStringENC(const char *str, CkString &out);
	bool HashBytes(const CkByteData &bData, CkByteData &out);
	bool HashString(const char *str, CkByteData &out);

	bool HashFileENC(const char *filename, CkString &out);
	bool HashFile(const char *filename, CkByteData &out);
	const char *hashFileENC(const char *filename);

	void ByteSwap4321(CkByteData &inOut);

	void get_EncodingMode(CkString &out);
	void put_EncodingMode(const char *str);
	void get_CryptAlgorithm(CkString &out);
	void put_CryptAlgorithm(const char *str);
	void get_HashAlgorithm(CkString &out);
	void put_HashAlgorithm(const char *str);
	void get_Charset(CkString &out);
	void put_Charset(const char *str);

	void GenerateSecretKey(const char *password, CkByteData &out);
	void SetSecretKeyViaPassword(const char *password);

	const char *genEncodedSecretKey(const char *password, const char *encoding);

	void get_CipherMode(CkString &out);
	void put_CipherMode(const char *newVal);
	// 0 = Each padding byte is the pad count (16 extra added if size is already a multiple of 16)
	// 1 = Random bytes except the last is the pad count (16 extra added if size is already multiple of 16)
	// 2 = Pad with random data. (If already a multiple of 16, no padding is added).
	// 3 = Pad with NULLs. (If already a multiple of 16, no padding is added).
	// 4 = Pad with SPACE chars(0x20). (If already a multiple of 16, no padding is added).
	long get_PaddingScheme(void);
	void put_PaddingScheme(long newVal);
	long get_KeyLength(void);
	void put_KeyLength(long newVal);
	void get_IV(CkByteData &bData);
	void put_IV(const CkByteData &bData);
	void get_SecretKey(CkByteData &bData);
	void put_SecretKey(const CkByteData &bData);
	void get_Version(CkString &out);

	// must be 3, 4, or 5.
	long get_HavalRounds(void);
	void put_HavalRounds(long newVal);

	bool IsUnlocked(void);
	bool UnlockComponent(const char *unlockCode);

	// Encoding can be base64, hex, URL
	void SetEncodedKey(const char *keyStr, const char *encoding);
	void SetEncodedIV(const char *ivStr, const char *encoding);
	void GetEncodedKey(const char *encoding, CkString &strKey);
	void GetEncodedIV(const char *encoding, CkString &strIV);

	void SetSecretKey(const unsigned char *keyData, int numBytes);
	void SetIV(const unsigned char *ivData, int numBytes);

	void Encode(const CkByteData &bData, const char *encoding, CkString &str);
	void Decode(const char *str, const char *encoding, CkByteData &bData);

	void RandomizeIV(void);

	void SetHmacKeyBytes(const CkByteData &keyBytes);
	void SetHmacKeyString(const char *key);

	// HMAC using the currently set hash alg and HMAC key.
	void HmacBytes(const CkByteData &inBytes, CkByteData &hmacOut);
	void HmacString(const char *inText, CkByteData &hmacOut);
	void HmacBytesENC(const CkByteData &inBytes, CkString &encodedHmacOut);
	void HmacStringENC(const char *inText, CkString &encodedHmacOut);
	const char *hmacStringENC(const char *inText);
	const char *hmacBytesENC(const CkByteData &inBytes);

	// Error log retrieval and saving (these methods are common to all Chilkat VC++ classes.)
	bool SaveLastError(const char *filename);
        void LastErrorXml(CkString &str);
        void LastErrorHtml(CkString &str);
        void LastErrorText(CkString &str);

	CkString m_resultString;
	const char *encodeBytes(const unsigned char *byteData, int numBytes, const char *encoding);
	const char *encodeBytes(const char *byteData, int numBytes, const char *encoding);

	const char *opaqueSignStringENC(const char *str);
	const char *opaqueSignBytesENC(const CkByteData &bData);

	const char *opaqueVerifyStringENC(const char *p7s);
	const char *opaqueVerifyString(const CkByteData &p7s);

	const char *signStringENC(const char *str);
	const char *signBytesENC(const CkByteData &bData);

	const char *inflateStringENC(const char *str);
	const char *inflateString(const CkByteData &bData);

	const char *compressStringENC(const char *str);
	const char *compressBytesENC(const CkByteData &bData);

	const char *encryptStringENC(const char *str);
	const char *encryptBytesENC(const CkByteData &bData);

	const char *decryptString(const CkByteData &bData);
	const char *decryptStringENC(const char *str);

	const char *hashStringENC(const char *str);
	const char *hashBytesENC(const CkByteData &bData);

	const char *getEncodedKey(const char *encoding);
	const char *getEncodedIV(const char *encoding);

	const char *encode(const CkByteData &bData, const char *encoding); //

	const char *encodingMode(void);
	const char *compressionAlgorithm(void); //
	const char *cryptAlgorithm(void);
	const char *hashAlgorithm(void);
	const char *charset(void);
	const char *cipherMode(void);
	const char *version(void); //

        const char *lastErrorText(void);
        const char *lastErrorXml(void);
        const char *lastErrorHtml(void);

	// END PUBLIC INTERFACE


};



#endif