--- a/crypto/weakcrypto/inc/hash.h Tue Jul 21 01:04:32 2009 +0100
+++ b/crypto/weakcrypto/inc/hash.h Thu Sep 10 14:01:51 2009 +0300
@@ -1,721 +1,715 @@
-/*
-* Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
-* All rights reserved.
-* This component and the accompanying materials are made available
-* under the terms of the License "Eclipse Public License v1.0"
-* which accompanies this distribution, and is available
-* at the URL "http://www.eclipse.org/legal/epl-v10.html".
-*
-* Initial Contributors:
-* Nokia Corporation - initial contribution.
-*
-* Contributors:
-*
-* Description:
-* ** IMPORTANT ** PublishedPartner API's in this file are published to 3rd party developers via the
-* Symbian website. Changes to these API's should be treated as PublishedAll API changes and the Security TA should be consulted.
-* This header contains the definition of the message digest classes
-*
-*/
-
-
-
-
-/**
- @file
- @publishedAll
- @released
-*/
-
-#ifndef __HASH_H__
-#define __HASH_H__
-
-#include <e32base.h>
-
-
-//Forward Declarations
-class MSHA2Impl;
-
-/**
- * Base class for message digests.
- */
-class CMessageDigest:public CBase
- {
- public:
- /**
- * Enumeration to identify hash functions (aka message-digest algorithms).
- */
- enum THashId
- {
- /**
- * Message Digest algorithm developed by Rivest for digital signature
- * applications (and optimized for 8-bit machines).
- *
- * Takes a message of arbitrary length and produces a 128-bit message digest.
- *
- * See RFC 1319
- */
- EMD2,
- /**
- * Message Digest algorithm developed by Rivest for digital signature
- * applications (and optimized for 32-bit machines).
- *
- * Takes a message of arbitrary length and produces a 128-bit message digest.
- *
- * See RFC 1321
- */
- EMD5,
- /**
- * Secure Hash Algorithm (version 1) is a message digest algorithm developed by
- * NIST, along with the NSA, for use with the Digital Signature Standard (DSS).
- *
- * It takes a message of less than 2^64 bits in length and produces
- * a 160-bit message digest.
- *
- * See FIPS 180-1 and RFC 3174
- */
- ESHA1,
- /**
- * HMAC - Hash function based Message Authentication Code is a mechanism
- * for message authentication using cryptographic hash functions. (A checksum.)
- *
- * It can be used with any iterative cryptographic hash function,
- * e.g., MD5, SHA-1, in combination with a secret shared key
- * to produce a checksum that is appended to the message.
- * The cryptographic strength of HMAC depends on the properties
- * of the underlying hash function.
- *
- * See RFC 2104
- */
- HMAC,
- /**
- * Message Digest algorithm developed by Rivest for digital signature
- * applications (and optimized for 32-bit machines).
- *
- * Takes a message of arbitrary length and produces a 128-bit message digest.
- *
- * See RFC 1320
- */
- EMD4,
- /**
- * Secure Hash Algorithm - 224 (version 2) is a message digest algorithm developed by
- * NIST, along with the NSA, for use with the Digital Signature Standard (DSS).
- *
- * It takes a message of less than 2^64 bits in length and produces
- * a 224-bit message digest.
- *
- * See FIPS 180-2 (with change notice), RFC3874 and FIPS 180-3
- */
- ESHA224,
- /**
- * Secure Hash Algorithm - 256 (version 2) is a message digest algorithm developed by
- * NIST, along with the NSA, for use with the Digital Signature Standard (DSS).
- *
- * It takes a message of less than 2^64 bits in length and produces
- * a 256-bit message digest.
- *
- * See FIPS 180-2 and RFC 4634
- */
- ESHA256,
- /**
- * Secure Hash Algorithm - 384 (version 2) is a message digest algorithm developed by
- * NIST, along with the NSA, for use with the Digital Signature Standard (DSS).
- *
- * It takes a message of less than 2^128 bits in length and produces
- * a 384-bit message digest.
- *
- * See FIPS 180-2 and RFC 4634
- */
- ESHA384,
- /**
- * Secure Hash Algorithm - 512 (version 2) is a message digest algorithm developed by
- * NIST, along with the NSA, for use with the Digital Signature Standard (DSS).
- *
- * It takes a message of less than 2^128 bits in length and produces
- * a 512-bit message digest.
- *
- * See FIPS 180-2 and RFC 4634
- */
- ESHA512
- };
-
- public:
- /**
- * Creates a brand new reset CMessageDigest object containing no state
- * information from the current object.
- *
- * To make a copy of a message digest with its internal state intact,
- * see CopyL().
- *
- * @return A pointer to the new reset CMessageDigest object
- */
- IMPORT_C virtual CMessageDigest* ReplicateL(void)=0;
-
- /**
- * Adds aMessage to the internal representation of data to be hashed,
- * then returns a TPtrC8 of the finalised hash of all the previously
- * appended messages.
- *
- * @param aMessage Data to be included in the hash.
- * @return A descriptor pointer to the buffer containing the
- * resulting hash.
- */
- IMPORT_C virtual TPtrC8 Hash(const TDesC8& aMessage)=0;
-
- /**
- * Creates a new CMessageDigest object with the exact same state as
- * the current object.
- *
- * This function copies all internal state of the message digest.
- * To create a new CMessageDigest object without the state of
- * the current object, see ReplicateL().
- *
- * @return A pointer to the new CMessageDigest object
- */
- IMPORT_C virtual CMessageDigest* CopyL(void)=0;
-
- /**
- * Gets the internal block size of the message digest.
- *
- * @return Internal block size of message digest in bytes.
- */
- IMPORT_C virtual TInt BlockSize(void)=0;
-
- /**
- * Gets the size of the message digest output.
- *
- * @return Output size of the message digest in bytes.
- */
- IMPORT_C virtual TInt HashSize(void)=0;
-
- /**
- * Resets the internal state of the message digest.
- *
- * A reset hash object loses all internal state representing the hashed
- * data. A reset message digest is suitable to begin a new, distinct hash
- * of different data. Any previously returned TPtrC8 from a call to
- * Final() remains valid until any subsequent call to Update() or
- * Final().
- */
- IMPORT_C virtual void Reset(void)=0;
-
- /**
- * Destructor.
- */
- IMPORT_C ~CMessageDigest(void);
- public:
- /**
- * Adds data to the internal representation of messages to be hashed.
- *
- * @param aMessage Data to be included in the hash.
- * @since v8.0
- */
- IMPORT_C virtual void Update(const TDesC8& aMessage)=0;
-
- /**
- * Adds aMessage to the internal representation of data to be hashed,
- * returns a TPtrC8 of the finalised hash of all the previously
- * appended messages, and calls Reset().
- *
- * @param aMessage Data to be included in the hash
- * @return A descriptor pointer to the buffer containing the
- * resulting hash.
- * @since v8.0
- */
- IMPORT_C virtual TPtrC8 Final(const TDesC8& aMessage)=0;
-
- /**
- * Gets a TPtrC8 of the finalised hash of all the previously
- * appended messages and then calls Reset().
- *
- * @return A descriptor pointer to the buffer containing the
- * resulting hash.
- * @since v8.0
- */
- IMPORT_C virtual TPtrC8 Final(void)=0;
- public:
- /**
- * Restores the internal state of the message digest
- * to a previously stored state.
- *
- * @see StoreState()
- */
- virtual void RestoreState() = 0;
-
- /**
- * Stores the internal state of the message digest.
- */
- virtual void StoreState() = 0;
- protected:
- /**
- * Constructor
- */
- IMPORT_C CMessageDigest(void);
-
- /**
- * Copy constructor
- *
- * @param aMD A CMessageDigest object
- */
- IMPORT_C CMessageDigest(const CMessageDigest& aMD);
- };
-
-/**
- * The MD2 block size (in bytes)
- *
- * @internalTechnology
- */
-const TInt MD2_BLOCK=16;
-
-/** The size (in bytes) of the MD2 message digest */
-const TInt MD2_HASH=16;
-
-/**
- * An MD2 message digest
- */
-class CMD2:public CMessageDigest
-
- {
- public:
- /**
- * Creates a new MD2 object.
- *
- * @return A pointer to the new CMD2 object
- */
- IMPORT_C static CMD2* NewL(void);
- IMPORT_C CMessageDigest* ReplicateL(void);
- IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
- /** Destructor */
- IMPORT_C ~CMD2(void);
- IMPORT_C CMessageDigest* CopyL(void);
- IMPORT_C TInt BlockSize(void);
- IMPORT_C TInt HashSize(void);
- IMPORT_C void Reset(void);
- IMPORT_C void Update(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final();
- public:
- void RestoreState();
- void StoreState();
- private:
- void DoUpdate(const TUint8* aData,TUint aLength);
- void DoFinal(void);
- void Block(const TUint8* aData);
- private:
- CMD2(void);
- CMD2(const CMD2& aMD2);
- private:
- TBuf8<MD2_HASH> iHash;
- TInt iNum;
- TUint8 iData[MD2_BLOCK];
- TUint iChecksum[MD2_BLOCK];
- TUint iState[MD2_BLOCK];
- private:
- TBuf8<MD2_HASH> iHashBuf;
- TUint8 iDataTemp[MD2_BLOCK];
- TUint iChecksumTemp[MD2_BLOCK];
- TUint iStateTemp[MD2_BLOCK];
- };
-
-/**
- * The MD5 block size (in bytes)
- *
- * @internalTechnology
- */
-const TUint MD5_LBLOCK=16;
-
-/** The size (in bytes) of the MD5 message digest */
-const TUint MD5_HASH=16;
-
-/**
- * An MD5 message digest
- *
- * Takes a message of arbitrary length as input and produces a 128-bit message digest.
- *
- * The length of input data should not be longer than 2^32 in bits(2^31 in bytes)
- * which is roughly half a gig.
- *
- */
-class CMD5:public CMessageDigest
- {
- public:
- /**
- * Creates a new MD5 object.
- *
- * @return A pointer to the new CMD5 object
- */
- IMPORT_C static CMD5* NewL(void);
- IMPORT_C CMessageDigest* ReplicateL(void);
- IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
- /** Destructor */
- IMPORT_C ~CMD5(void);
- IMPORT_C CMessageDigest* CopyL(void);
- IMPORT_C TInt BlockSize(void);
- IMPORT_C TInt HashSize(void);
- IMPORT_C void Reset(void);
- IMPORT_C void Update(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final();
- public:
- void RestoreState();
- void StoreState();
- private:
- CMD5(void);
- CMD5(const CMD5& aMD5);
- private:
- void DoUpdate(const TUint8* aData,TUint aLength);
- void DoFinal(void);
- void Block();
- private:
- TBuf8<MD5_HASH> iHash;
- private:
- TUint iA;
- TUint iB;
- TUint iC;
- TUint iD;
- TUint iNl;
- TUint iNh;
- TUint iData[MD5_LBLOCK];
- private:
- TUint iACopy;
- TUint iBCopy;
- TUint iCCopy;
- TUint iDCopy;
- TUint iNlCopy;
- TUint iNhCopy;
- TUint iDataCopy[MD5_LBLOCK];
- };
-
-/**
- * The SHA-1 block size (in bytes)
- *
- * @internalTechnology
- */
-const TUint SHA1_LBLOCK=16;
-
-/** The size (in bytes) of the SHA-1 message digest */
-const TUint SHA1_HASH=20;
-
-/** The size (in bytes) of the SHA message digest */
-const TUint SHA_HASH=SHA1_HASH;
-
-/**
- * A SHA-1 message digest
- */
-class CSHA1:public CMessageDigest
- {
- public:
- /**
- * Creates a new SHA-1 object.
- *
- * @return A pointer to the new SHA-1 object
- */
- IMPORT_C static CSHA1* NewL(void);
- IMPORT_C CMessageDigest* ReplicateL(void);
- IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
- /** Destructor */
- IMPORT_C ~CSHA1(void);
- IMPORT_C CMessageDigest* CopyL(void);
- IMPORT_C TInt BlockSize(void);
- IMPORT_C TInt HashSize(void);
- IMPORT_C void Reset(void);
- IMPORT_C void Update(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final();
- public:
- void RestoreState();
- void StoreState();
- private:
- CSHA1(void);
- CSHA1(const CSHA1& aSHA1);
- void ConstructL(void);
- private:
- void DoUpdate(const TUint8* aData,TUint aLength);
- void DoFinal(void);
- void Block();
- private:
- TBuf8<SHA1_HASH> iHash;
- TUint iA;
- TUint iB;
- TUint iC;
- TUint iD;
- TUint iE;
- TUint iNl;
- TUint iNh;
- TUint iData[SHA1_LBLOCK*5];
- private:
- TUint iACopy;
- TUint iBCopy;
- TUint iCCopy;
- TUint iDCopy;
- TUint iECopy;
- TUint iNlCopy;
- TUint iNhCopy;
- TUint iDataCopy[SHA1_LBLOCK*5];
- };
-
-enum TSH2Algo
- {
- E224Bit,
- E256Bit,
- E384Bit,
- E512Bit
- };
-
-/**
- * A SHA-2 message digest
- *
- * SHA-2 comprises of SHA-224, SHA256, SHA384 and SHA512
- */
-class CSHA2 : public CMessageDigest
- {
-public:
- //NewL & NewLC
- IMPORT_C static CSHA2* NewL(TSH2Algo aAlgorithmId);
- IMPORT_C static CSHA2* NewLC(TSH2Algo aAlgorithmId);
-
- /** Destructor */
- IMPORT_C ~CSHA2(void);
-
- //From CMessageDigest
- IMPORT_C CMessageDigest* ReplicateL(void);
- IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
- IMPORT_C CMessageDigest* CopyL(void);
- IMPORT_C TInt BlockSize(void);
- IMPORT_C TInt HashSize(void);
- IMPORT_C void Reset(void);
- IMPORT_C void Update(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final();
-
-public:
- void RestoreState();
- void StoreState();
-
-private:
- //Constructors
- void ConstructL(TSH2Algo aAlgorithmId);
- void ConstructL(const CSHA2& aSHA512);
-
-private:
- MSHA2Impl* iImplementation;
- const TAny* iInitValues;
- TSH2Algo iAlgorithmType;
- TUint iHashSize;
- };
-
-/**
- * A SHA message digest
- *
- * @deprecated Replaced by CSHA1
- */
-class CSHA:public CMessageDigest
- {
- public:
- /**
- * Creates a new SHA object.
- *
- * @return A pointer to the new SHA object
- */
- IMPORT_C static CSHA* NewL(void);
- IMPORT_C CMessageDigest* ReplicateL(void);
- IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
- /** Destructor */
- IMPORT_C ~CSHA(void);
- IMPORT_C CMessageDigest* CopyL(void);
- IMPORT_C TInt BlockSize(void);
- IMPORT_C TInt HashSize(void);
- IMPORT_C void Reset(void);
- IMPORT_C void Update(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final();
- public:
- void RestoreState();
- void StoreState();
- };
-
-/**
- * This is the maximum block size currently supported by HMAC implementation.
- */
- const TUint KMaxBlockSize=128;
-
-/**
- * An HMAC (Hashed Message Authentication Code)
- */
- class CHMAC:public CMessageDigest
-
- {
- public:
- /**
- * Creates a new HMAC object from a specified type of message digest
- * and authentication key.
- *
- * @param aKey Authentication key.
- * @param aDigest A message digest to construct the HMAC from.
- * @return A pointer to the new CHMAC object.
- * The resulting HMAC object takes ownership of aDigest
- * and is responsible for its deletion.
- */
- IMPORT_C static CHMAC* NewL(const TDesC8& aKey,CMessageDigest* aDigest);
- IMPORT_C CMessageDigest* ReplicateL(void);
- IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
- /** Destructor */
- IMPORT_C ~CHMAC(void);
- IMPORT_C CMessageDigest* CopyL(void);
- IMPORT_C TInt BlockSize(void);
- IMPORT_C TInt HashSize(void);
- IMPORT_C void Reset(void);
- IMPORT_C void Update(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final();
- public:
- void RestoreState();
- void StoreState();
- private:
- CHMAC(void);
- CHMAC(CMessageDigest* aDigest);
- CHMAC(const CHMAC& aHMAC);
- void InitialiseL(const TDesC8& aKey);
- void InitBlockSizeL();
-
- private:
- CMessageDigest* iDigest;
- TBuf8<KMaxBlockSize> iInnerPad;
- TBuf8<KMaxBlockSize> iOuterPad;
- TBuf8<KMaxBlockSize> iInnerPadCopy;
- TBuf8<KMaxBlockSize> iOuterPadCopy;
- TInt iBlockSize;
- };
-
-/**
- * The MD4 block size
- * @internalTechnology
- */
- const TUint MD4_LBLOCK=16;
-
-/** The size (in bytes) of the MD4 message digest */
- const TUint MD4_HASH=16;
-
-
-/**
- * An MD4 message digest Algorithm.
- *
- * Takes a message of arbitrary length as input and produces a 128-bit message digest.
- *
- * The total input length of data should not be longer than 2^32 in bits(2^31 in bytes)
- * which is roughly half a gig.
- *
- */
-class CMD4:public CMessageDigest
- {
- public:
- /**
- * Creates a new MD4 object.
- *
- * @return A pointer to the new CMD4 object
- */
- IMPORT_C static CMD4* NewL(void);
- IMPORT_C CMessageDigest* ReplicateL(void);
- IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
- /** Destructor */
- IMPORT_C ~CMD4(void);
- IMPORT_C CMessageDigest* CopyL(void);
- IMPORT_C TInt BlockSize(void);
- IMPORT_C TInt HashSize(void);
- IMPORT_C void Reset(void);
- IMPORT_C void Update(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
- IMPORT_C TPtrC8 Final();
- public:
- virtual void RestoreState();
- virtual void StoreState();
- private:
- CMD4(void);
- CMD4(const CMD4& aMD4);
- private:
- /**
- * Divides the message into blocks of 512 bits and performs the
- * Block operation on them.
- */
- void DoUpdate(const TUint8* aData,TUint aLength);
- /**
- * Performs the Block operation on the last 512 bit block.
- * This function does the padding on the last 512 bit block
- * and also appends the length of the message to the last 64-bits
- * of the block.
- */
- void DoFinal(void);
- /**
- * Performs the Block operation on the 512 bit blocks
- */
- void Block();
- private:
- /*Holds the generated 128-bit Message Digest*/
- TBuf8<MD4_HASH> iHash;
- private:
- TUint iA;
- TUint iB;
- TUint iC;
- TUint iD;
- TUint iNl;
- TUint iNh;
- TUint iData[MD4_LBLOCK];
- private:
- TUint iACopy;
- TUint iBCopy;
- TUint iCCopy;
- TUint iDCopy;
- TUint iNlCopy;
- TUint iNhCopy;
- TUint iDataCopy[MD4_LBLOCK];
- };
-
-
-/**
- * Factory to create a CMessageDigest derived object according to the identity of the hash algorithm.
- */
-class CMessageDigestFactory : public CBase
-{
-public:
- /**
- * Creates a CMessageDigest derived object according to the specified type of hash algorithm.
- *
- * @param aHashId The identity of the hash algorithm
- * @return A pointer to a CMessageDigest object
- */
- IMPORT_C static CMessageDigest* NewDigestL(CMessageDigest::THashId aHashId);
-
- /**
- * Creates a CMessageDigest derived object according to the specified type of hash algorithm.
- *
- * The returned pointer is put onto the cleanup stack.
- *
- * @param aHashId The identity of the hash algorithm
- * @return A pointer to a CMessageDigest object
- */
- IMPORT_C static CMessageDigest* NewDigestLC(CMessageDigest::THashId aHashId);
-
- /**
- * Creates a CMessageDigest derived object according to the specified type of hash algorithm
- * and authentication key.
- *
- * @param aHashId The identity of the hash algorithm
- * @param aKey The authentication key
- * @return A pointer to a CMessageDigest object
- */
- IMPORT_C static CMessageDigest* NewHMACL(CMessageDigest::THashId aHashId, const TDesC8& aKey);
-
- /**
- * Creates a CMessageDigest derived object according to the specified type of hash algorithm
- * and authentication key.
- *
- * The returned pointer is put onto the cleanup stack.
- *
- * @param aHashId The identity of the hash algorithm
- * @param aKey The authentication key
- * @return A pointer to a CMessageDigest object
- */
- IMPORT_C static CMessageDigest* NewHMACLC(CMessageDigest::THashId aHashId, const TDesC8& aKey);
-};
-
-#endif // __HASH_H__
+/*
+* Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+* ** IMPORTANT ** PublishedPartner API's in this file are published to 3rd party developers via the
+* Symbian website. Changes to these API's should be treated as PublishedAll API changes and the Security TA should be consulted.
+* This header contains the definition of the message digest classes
+*
+*/
+
+
+/**
+ @file
+ @publishedAll
+ @released
+*/
+
+#ifndef __HASH_H__
+#define __HASH_H__
+
+#include <e32base.h>
+
+
+//Forward Declarations
+class MSHA2Impl;
+
+/**
+ * Base class for message digests.
+ */
+class CMessageDigest:public CBase
+ {
+ public:
+ /**
+ * Enumeration to identify hash functions (aka message-digest algorithms).
+ */
+ enum THashId
+ {
+ /**
+ * Message Digest algorithm developed by Rivest for digital signature
+ * applications (and optimized for 8-bit machines).
+ *
+ * Takes a message of arbitrary length and produces a 128-bit message digest.
+ *
+ * See RFC 1319
+ */
+ EMD2,
+ /**
+ * Message Digest algorithm developed by Rivest for digital signature
+ * applications (and optimized for 32-bit machines).
+ *
+ * Takes a message of arbitrary length and produces a 128-bit message digest.
+ *
+ * See RFC 1321
+ */
+ EMD5,
+ /**
+ * Secure Hash Algorithm (version 1) is a message digest algorithm developed by
+ * NIST, along with the NSA, for use with the Digital Signature Standard (DSS).
+ *
+ * It takes a message of less than 2^64 bits in length and produces
+ * a 160-bit message digest.
+ *
+ * See FIPS 180-1 and RFC 3174
+ */
+ ESHA1,
+ /**
+ * HMAC - Hash function based Message Authentication Code is a mechanism
+ * for message authentication using cryptographic hash functions. (A checksum.)
+ *
+ * It can be used with any iterative cryptographic hash function,
+ * e.g., MD5, SHA-1, in combination with a secret shared key
+ * to produce a checksum that is appended to the message.
+ * The cryptographic strength of HMAC depends on the properties
+ * of the underlying hash function.
+ *
+ * See RFC 2104
+ */
+ HMAC,
+ /**
+ * Message Digest algorithm developed by Rivest for digital signature
+ * applications (and optimized for 32-bit machines).
+ *
+ * Takes a message of arbitrary length and produces a 128-bit message digest.
+ *
+ * See RFC 1320
+ */
+ EMD4,
+ /**
+ * Secure Hash Algorithm - 224 (version 2) is a message digest algorithm developed by
+ * NIST, along with the NSA, for use with the Digital Signature Standard (DSS).
+ *
+ * It takes a message of less than 2^64 bits in length and produces
+ * a 224-bit message digest.
+ *
+ * See FIPS 180-2 (with change notice), RFC3874 and FIPS 180-3
+ */
+ ESHA224,
+ /**
+ * Secure Hash Algorithm - 256 (version 2) is a message digest algorithm developed by
+ * NIST, along with the NSA, for use with the Digital Signature Standard (DSS).
+ *
+ * It takes a message of less than 2^64 bits in length and produces
+ * a 256-bit message digest.
+ *
+ * See FIPS 180-2 and RFC 4634
+ */
+ ESHA256,
+ /**
+ * Secure Hash Algorithm - 384 (version 2) is a message digest algorithm developed by
+ * NIST, along with the NSA, for use with the Digital Signature Standard (DSS).
+ *
+ * It takes a message of less than 2^128 bits in length and produces
+ * a 384-bit message digest.
+ *
+ * See FIPS 180-2 and RFC 4634
+ */
+ ESHA384,
+ /**
+ * Secure Hash Algorithm - 512 (version 2) is a message digest algorithm developed by
+ * NIST, along with the NSA, for use with the Digital Signature Standard (DSS).
+ *
+ * It takes a message of less than 2^128 bits in length and produces
+ * a 512-bit message digest.
+ *
+ * See FIPS 180-2 and RFC 4634
+ */
+ ESHA512
+ };
+
+ public:
+ /**
+ * Creates a brand new reset CMessageDigest object containing no state
+ * information from the current object.
+ *
+ * To make a copy of a message digest with its internal state intact,
+ * see CopyL().
+ *
+ * @return A pointer to the new reset CMessageDigest object
+ */
+ IMPORT_C virtual CMessageDigest* ReplicateL(void)=0;
+
+ /**
+ * Adds aMessage to the internal representation of data to be hashed,
+ * then returns a TPtrC8 of the finalised hash of all the previously
+ * appended messages.
+ *
+ * @param aMessage Data to be included in the hash.
+ * @return A descriptor pointer to the buffer containing the
+ * resulting hash.
+ */
+ IMPORT_C virtual TPtrC8 Hash(const TDesC8& aMessage)=0;
+
+ /**
+ * Creates a new CMessageDigest object with the exact same state as
+ * the current object.
+ *
+ * This function copies all internal state of the message digest.
+ * To create a new CMessageDigest object without the state of
+ * the current object, see ReplicateL().
+ *
+ * @return A pointer to the new CMessageDigest object
+ */
+ IMPORT_C virtual CMessageDigest* CopyL(void)=0;
+
+ /**
+ * Gets the internal block size of the message digest.
+ *
+ * @return Internal block size of message digest in bytes.
+ */
+ IMPORT_C virtual TInt BlockSize(void)=0;
+
+ /**
+ * Gets the size of the message digest output.
+ *
+ * @return Output size of the message digest in bytes.
+ */
+ IMPORT_C virtual TInt HashSize(void)=0;
+
+ /**
+ * Resets the internal state of the message digest.
+ *
+ * A reset hash object loses all internal state representing the hashed
+ * data. A reset message digest is suitable to begin a new, distinct hash
+ * of different data. Any previously returned TPtrC8 from a call to
+ * Final() remains valid until any subsequent call to Update() or
+ * Final().
+ */
+ IMPORT_C virtual void Reset(void)=0;
+
+ /**
+ * Destructor.
+ */
+ IMPORT_C ~CMessageDigest(void);
+ public:
+ /**
+ * Adds data to the internal representation of messages to be hashed.
+ *
+ * @param aMessage Data to be included in the hash.
+ * @since v8.0
+ */
+ IMPORT_C virtual void Update(const TDesC8& aMessage)=0;
+
+ /**
+ * Adds aMessage to the internal representation of data to be hashed,
+ * returns a TPtrC8 of the finalised hash of all the previously
+ * appended messages, and calls Reset().
+ *
+ * @param aMessage Data to be included in the hash
+ * @return A descriptor pointer to the buffer containing the
+ * resulting hash.
+ * @since v8.0
+ */
+ IMPORT_C virtual TPtrC8 Final(const TDesC8& aMessage)=0;
+
+ /**
+ * Gets a TPtrC8 of the finalised hash of all the previously
+ * appended messages and then calls Reset().
+ *
+ * @return A descriptor pointer to the buffer containing the
+ * resulting hash.
+ * @since v8.0
+ */
+ IMPORT_C virtual TPtrC8 Final(void)=0;
+ public:
+ /**
+ * Restores the internal state of the message digest
+ * to a previously stored state.
+ *
+ * @see StoreState()
+ */
+ virtual void RestoreState() = 0;
+
+ /**
+ * Stores the internal state of the message digest.
+ */
+ virtual void StoreState() = 0;
+ protected:
+ /**
+ * Constructor
+ */
+ IMPORT_C CMessageDigest(void);
+
+ /**
+ * Copy constructor
+ *
+ * @param aMD A CMessageDigest object
+ */
+ IMPORT_C CMessageDigest(const CMessageDigest& aMD);
+ };
+
+/**
+ * The MD2 block size (in bytes)
+ *
+ */
+const TInt MD2_BLOCK=16;
+
+/** The size (in bytes) of the MD2 message digest */
+const TInt MD2_HASH=16;
+
+/**
+ * An MD2 message digest
+ */
+class CMD2:public CMessageDigest
+
+ {
+ public:
+ /**
+ * Creates a new MD2 object.
+ *
+ * @return A pointer to the new CMD2 object
+ */
+ IMPORT_C static CMD2* NewL(void);
+ IMPORT_C CMessageDigest* ReplicateL(void);
+ IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
+ /** Destructor */
+ IMPORT_C ~CMD2(void);
+ IMPORT_C CMessageDigest* CopyL(void);
+ IMPORT_C TInt BlockSize(void);
+ IMPORT_C TInt HashSize(void);
+ IMPORT_C void Reset(void);
+ IMPORT_C void Update(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final();
+ public:
+ void RestoreState();
+ void StoreState();
+ private:
+ void DoUpdate(const TUint8* aData,TUint aLength);
+ void DoFinal(void);
+ void Block(const TUint8* aData);
+ private:
+ CMD2(void);
+ CMD2(const CMD2& aMD2);
+ private:
+ TBuf8<MD2_HASH> iHash;
+ TInt iNum;
+ TUint8 iData[MD2_BLOCK];
+ TUint iChecksum[MD2_BLOCK];
+ TUint iState[MD2_BLOCK];
+ private:
+ TBuf8<MD2_HASH> iHashBuf;
+ TUint8 iDataTemp[MD2_BLOCK];
+ TUint iChecksumTemp[MD2_BLOCK];
+ TUint iStateTemp[MD2_BLOCK];
+ };
+
+/**
+ * The MD5 block size (in bytes)
+ *
+ */
+const TUint MD5_LBLOCK=16;
+
+/** The size (in bytes) of the MD5 message digest */
+const TUint MD5_HASH=16;
+
+/**
+ * An MD5 message digest
+ *
+ * Takes a message of arbitrary length as input and produces a 128-bit message digest.
+ *
+ * The length of input data should not be longer than 2^32 in bits(2^31 in bytes)
+ * which is roughly half a gig.
+ *
+ */
+class CMD5:public CMessageDigest
+ {
+ public:
+ /**
+ * Creates a new MD5 object.
+ *
+ * @return A pointer to the new CMD5 object
+ */
+ IMPORT_C static CMD5* NewL(void);
+ IMPORT_C CMessageDigest* ReplicateL(void);
+ IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
+ /** Destructor */
+ IMPORT_C ~CMD5(void);
+ IMPORT_C CMessageDigest* CopyL(void);
+ IMPORT_C TInt BlockSize(void);
+ IMPORT_C TInt HashSize(void);
+ IMPORT_C void Reset(void);
+ IMPORT_C void Update(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final();
+ public:
+ void RestoreState();
+ void StoreState();
+ private:
+ CMD5(void);
+ CMD5(const CMD5& aMD5);
+ private:
+ void DoUpdate(const TUint8* aData,TUint aLength);
+ void DoFinal(void);
+ void Block();
+ private:
+ TBuf8<MD5_HASH> iHash;
+ private:
+ TUint iA;
+ TUint iB;
+ TUint iC;
+ TUint iD;
+ TUint iNl;
+ TUint iNh;
+ TUint iData[MD5_LBLOCK];
+ private:
+ TUint iACopy;
+ TUint iBCopy;
+ TUint iCCopy;
+ TUint iDCopy;
+ TUint iNlCopy;
+ TUint iNhCopy;
+ TUint iDataCopy[MD5_LBLOCK];
+ };
+
+/**
+ * The SHA-1 block size (in bytes)
+ *
+ */
+const TUint SHA1_LBLOCK=16;
+
+/** The size (in bytes) of the SHA-1 message digest */
+const TUint SHA1_HASH=20;
+
+/** The size (in bytes) of the SHA message digest */
+const TUint SHA_HASH=SHA1_HASH;
+
+/**
+ * A SHA-1 message digest
+ */
+class CSHA1:public CMessageDigest
+ {
+ public:
+ /**
+ * Creates a new SHA-1 object.
+ *
+ * @return A pointer to the new SHA-1 object
+ */
+ IMPORT_C static CSHA1* NewL(void);
+ IMPORT_C CMessageDigest* ReplicateL(void);
+ IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
+ /** Destructor */
+ IMPORT_C ~CSHA1(void);
+ IMPORT_C CMessageDigest* CopyL(void);
+ IMPORT_C TInt BlockSize(void);
+ IMPORT_C TInt HashSize(void);
+ IMPORT_C void Reset(void);
+ IMPORT_C void Update(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final();
+ public:
+ void RestoreState();
+ void StoreState();
+ private:
+ CSHA1(void);
+ CSHA1(const CSHA1& aSHA1);
+ void ConstructL(void);
+ private:
+ void DoUpdate(const TUint8* aData,TUint aLength);
+ void DoFinal(void);
+ void Block();
+ private:
+ TBuf8<SHA1_HASH> iHash;
+ TUint iA;
+ TUint iB;
+ TUint iC;
+ TUint iD;
+ TUint iE;
+ TUint iNl;
+ TUint iNh;
+ TUint iData[SHA1_LBLOCK*5];
+ private:
+ TUint iACopy;
+ TUint iBCopy;
+ TUint iCCopy;
+ TUint iDCopy;
+ TUint iECopy;
+ TUint iNlCopy;
+ TUint iNhCopy;
+ TUint iDataCopy[SHA1_LBLOCK*5];
+ };
+
+enum TSH2Algo
+ {
+ E224Bit,
+ E256Bit,
+ E384Bit,
+ E512Bit
+ };
+
+/**
+ * A SHA-2 message digest
+ *
+ * SHA-2 comprises of SHA-224, SHA256, SHA384 and SHA512
+ */
+class CSHA2 : public CMessageDigest
+ {
+public:
+ //NewL & NewLC
+ IMPORT_C static CSHA2* NewL(TSH2Algo aAlgorithmId);
+ IMPORT_C static CSHA2* NewLC(TSH2Algo aAlgorithmId);
+
+ /** Destructor */
+ IMPORT_C ~CSHA2(void);
+
+ //From CMessageDigest
+ IMPORT_C CMessageDigest* ReplicateL(void);
+ IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
+ IMPORT_C CMessageDigest* CopyL(void);
+ IMPORT_C TInt BlockSize(void);
+ IMPORT_C TInt HashSize(void);
+ IMPORT_C void Reset(void);
+ IMPORT_C void Update(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final();
+
+public:
+ void RestoreState();
+ void StoreState();
+
+private:
+ //Constructors
+ void ConstructL(TSH2Algo aAlgorithmId);
+ void ConstructL(const CSHA2& aSHA512);
+
+private:
+ MSHA2Impl* iImplementation;
+ const TAny* iInitValues;
+ TSH2Algo iAlgorithmType;
+ TUint iHashSize;
+ };
+
+/**
+ * A SHA message digest
+ *
+ * @deprecated Replaced by CSHA1
+ */
+class CSHA:public CMessageDigest
+ {
+ public:
+ /**
+ * Creates a new SHA object.
+ *
+ * @return A pointer to the new SHA object
+ */
+ IMPORT_C static CSHA* NewL(void);
+ IMPORT_C CMessageDigest* ReplicateL(void);
+ IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
+ /** Destructor */
+ IMPORT_C ~CSHA(void);
+ IMPORT_C CMessageDigest* CopyL(void);
+ IMPORT_C TInt BlockSize(void);
+ IMPORT_C TInt HashSize(void);
+ IMPORT_C void Reset(void);
+ IMPORT_C void Update(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final();
+ public:
+ void RestoreState();
+ void StoreState();
+ };
+
+/**
+ * This is the maximum block size currently supported by HMAC implementation.
+ */
+ const TUint KMaxBlockSize=128;
+
+/**
+ * An HMAC (Hashed Message Authentication Code)
+ */
+ class CHMAC:public CMessageDigest
+
+ {
+ public:
+ /**
+ * Creates a new HMAC object from a specified type of message digest
+ * and authentication key.
+ *
+ * @param aKey Authentication key.
+ * @param aDigest A message digest to construct the HMAC from.
+ * @return A pointer to the new CHMAC object.
+ * The resulting HMAC object takes ownership of aDigest
+ * and is responsible for its deletion.
+ */
+ IMPORT_C static CHMAC* NewL(const TDesC8& aKey,CMessageDigest* aDigest);
+ IMPORT_C CMessageDigest* ReplicateL(void);
+ IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
+ /** Destructor */
+ IMPORT_C ~CHMAC(void);
+ IMPORT_C CMessageDigest* CopyL(void);
+ IMPORT_C TInt BlockSize(void);
+ IMPORT_C TInt HashSize(void);
+ IMPORT_C void Reset(void);
+ IMPORT_C void Update(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final();
+ public:
+ void RestoreState();
+ void StoreState();
+ private:
+ CHMAC(void);
+ CHMAC(CMessageDigest* aDigest);
+ CHMAC(const CHMAC& aHMAC);
+ void InitialiseL(const TDesC8& aKey);
+ void InitBlockSizeL();
+
+ private:
+ CMessageDigest* iDigest;
+ TBuf8<KMaxBlockSize> iInnerPad;
+ TBuf8<KMaxBlockSize> iOuterPad;
+ TBuf8<KMaxBlockSize> iInnerPadCopy;
+ TBuf8<KMaxBlockSize> iOuterPadCopy;
+ TInt iBlockSize;
+ };
+
+/**
+ * The MD4 block size
+ */
+ const TUint MD4_LBLOCK=16;
+
+/** The size (in bytes) of the MD4 message digest */
+ const TUint MD4_HASH=16;
+
+
+/**
+ * An MD4 message digest Algorithm.
+ *
+ * Takes a message of arbitrary length as input and produces a 128-bit message digest.
+ *
+ * The total input length of data should not be longer than 2^32 in bits(2^31 in bytes)
+ * which is roughly half a gig.
+ *
+ */
+class CMD4:public CMessageDigest
+ {
+ public:
+ /**
+ * Creates a new MD4 object.
+ *
+ * @return A pointer to the new CMD4 object
+ */
+ IMPORT_C static CMD4* NewL(void);
+ IMPORT_C CMessageDigest* ReplicateL(void);
+ IMPORT_C TPtrC8 Hash(const TDesC8& aMessage);
+ /** Destructor */
+ IMPORT_C ~CMD4(void);
+ IMPORT_C CMessageDigest* CopyL(void);
+ IMPORT_C TInt BlockSize(void);
+ IMPORT_C TInt HashSize(void);
+ IMPORT_C void Reset(void);
+ IMPORT_C void Update(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final(const TDesC8& aMessage);
+ IMPORT_C TPtrC8 Final();
+ public:
+ virtual void RestoreState();
+ virtual void StoreState();
+ private:
+ CMD4(void);
+ CMD4(const CMD4& aMD4);
+ private:
+ /**
+ * Divides the message into blocks of 512 bits and performs the
+ * Block operation on them.
+ */
+ void DoUpdate(const TUint8* aData,TUint aLength);
+ /**
+ * Performs the Block operation on the last 512 bit block.
+ * This function does the padding on the last 512 bit block
+ * and also appends the length of the message to the last 64-bits
+ * of the block.
+ */
+ void DoFinal(void);
+ /**
+ * Performs the Block operation on the 512 bit blocks
+ */
+ void Block();
+ private:
+ /*Holds the generated 128-bit Message Digest*/
+ TBuf8<MD4_HASH> iHash;
+ private:
+ TUint iA;
+ TUint iB;
+ TUint iC;
+ TUint iD;
+ TUint iNl;
+ TUint iNh;
+ TUint iData[MD4_LBLOCK];
+ private:
+ TUint iACopy;
+ TUint iBCopy;
+ TUint iCCopy;
+ TUint iDCopy;
+ TUint iNlCopy;
+ TUint iNhCopy;
+ TUint iDataCopy[MD4_LBLOCK];
+ };
+
+
+/**
+ * Factory to create a CMessageDigest derived object according to the identity of the hash algorithm.
+ */
+class CMessageDigestFactory : public CBase
+{
+public:
+ /**
+ * Creates a CMessageDigest derived object according to the specified type of hash algorithm.
+ *
+ * @param aHashId The identity of the hash algorithm
+ * @return A pointer to a CMessageDigest object
+ */
+ IMPORT_C static CMessageDigest* NewDigestL(CMessageDigest::THashId aHashId);
+
+ /**
+ * Creates a CMessageDigest derived object according to the specified type of hash algorithm.
+ *
+ * The returned pointer is put onto the cleanup stack.
+ *
+ * @param aHashId The identity of the hash algorithm
+ * @return A pointer to a CMessageDigest object
+ */
+ IMPORT_C static CMessageDigest* NewDigestLC(CMessageDigest::THashId aHashId);
+
+ /**
+ * Creates a CMessageDigest derived object according to the specified type of hash algorithm
+ * and authentication key.
+ *
+ * @param aHashId The identity of the hash algorithm
+ * @param aKey The authentication key
+ * @return A pointer to a CMessageDigest object
+ */
+ IMPORT_C static CMessageDigest* NewHMACL(CMessageDigest::THashId aHashId, const TDesC8& aKey);
+
+ /**
+ * Creates a CMessageDigest derived object according to the specified type of hash algorithm
+ * and authentication key.
+ *
+ * The returned pointer is put onto the cleanup stack.
+ *
+ * @param aHashId The identity of the hash algorithm
+ * @param aKey The authentication key
+ * @return A pointer to a CMessageDigest object
+ */
+ IMPORT_C static CMessageDigest* NewHMACLC(CMessageDigest::THashId aHashId, const TDesC8& aKey);
+};
+
+#endif // __HASH_H__