/*

* Copyright (c) 1997-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: 

*

*/

/**

 @file 

 @internalAll 

*/

#ifndef __WTLSCERT_H__

#define __WTLSCERT_H__

#include <e32base.h>

#include <e32std.h>

#include <s32std.h>

#include <signed.h>

#include <unifiedcertstore.h>

#include <wtlsnames.h>

class CRSAPublicKey;

class CDSAPublicKey;

class CDSASignature;

class CDSAParameters;

const TInt KWTLSCertMaxDataElements = 6;

/**

 * @publishedAll

 * @released

 */

class CWTLSRSASignatureResult : public CRSASignatureResult

	{

public:

	IMPORT_C static CWTLSRSASignatureResult* NewL(const CAlgorithmIdentifier& aDigestAlgorithm, const TDesC8& aDigest);

	IMPORT_C static CWTLSRSASignatureResult* NewLC(const CAlgorithmIdentifier& aDigestAlgorithm, const TDesC8& aDigest);

	IMPORT_C virtual TBool VerifyL(const TDesC8& aResult);

private:

	void ConstructL(const CAlgorithmIdentifier& aDigestAlgorithm, const TDesC8& aDigest);

	};

/**

 * @publishedAll

 * @released

 */

class TWTLSKeyFactory : public TKeyFactory

	{

public:

	virtual CRSAPublicKey* RSAPublicKeyL(const TDesC8& aEncoding) const;

	virtual CRSASignatureResult* RSASignatureResultL(const CAlgorithmIdentifier& aDigestAlgorithm, TDesC8& aDigest) const;

	virtual CDSAPublicKey* DSAPublicKeyL(const CDSAParameters& aParams, const TDesC8& aEncoding) const;

	virtual CDSASignature* DSASignatureL(const TDesC8& aEncoding) const;

	virtual CDSAParameters* DSAParametersL(const TDesC8& aEncoding) const;

	virtual CDSAPublicKey* DSAPublicKeyL(const TDesC8& aParamsEncoding, const TDesC8& aEncoding) const;

	};

/**

 * @publishedAll

 * @released

 */

class CWTLSValidityPeriod : public CValidityPeriod

	{

public:

	IMPORT_C static CWTLSValidityPeriod* NewL(const TDesC8& aBinaryData);

	IMPORT_C static CWTLSValidityPeriod* NewLC(const TDesC8& aBinaryData);

	IMPORT_C static CWTLSValidityPeriod* NewL(const TDesC8& aBinaryData, TInt& aPos);

	IMPORT_C static CWTLSValidityPeriod* NewLC(const TDesC8& aBinaryData, TInt& aPos);

private:

	CWTLSValidityPeriod();

	void ConstructL(const TDesC8& aBinaryData, TInt& aPos);

	};

/**

 * @publishedAll

 * @released

 */

class CWTLSAlgorithmIdentifier : public CAlgorithmIdentifier

	{

public:

	IMPORT_C static CWTLSAlgorithmIdentifier* NewL(const TDesC8& aBinaryData);

	IMPORT_C static CWTLSAlgorithmIdentifier* NewLC(const TDesC8& aBinaryData);

	IMPORT_C static CWTLSAlgorithmIdentifier* NewL(const TDesC8& aBinaryData, TInt& aPos);

	IMPORT_C static CWTLSAlgorithmIdentifier* NewLC(const TDesC8& aBinaryData, TInt& aPos);

private:

	CWTLSAlgorithmIdentifier();

	void ConstructL(const TDesC8& aBinaryData, TInt& aPos);

	};

/**

 * @publishedAll

 * @released

 */

class CWTLSSigningAlgorithmIdentifier : public CSigningAlgorithmIdentifier

	{

public:

	IMPORT_C static CWTLSSigningAlgorithmIdentifier* NewL(const TDesC8& aBinaryData);

	IMPORT_C static CWTLSSigningAlgorithmIdentifier* NewLC(const TDesC8& aBinaryData);

	IMPORT_C static CWTLSSigningAlgorithmIdentifier* NewL(const TDesC8& aBinaryData, TInt& aPos);

	IMPORT_C static CWTLSSigningAlgorithmIdentifier* NewLC(const TDesC8& aBinaryData, TInt& aPos);

private:

	CWTLSSigningAlgorithmIdentifier();

	void ConstructL(const TDesC8& aBinaryData, TInt& aPos);

	};

/**

 * @publishedAll

 * @released

 */

class CWTLSSubjectPublicKeyInfo : public CSubjectPublicKeyInfo

	{

public:

	IMPORT_C static CWTLSSubjectPublicKeyInfo* NewL(const TDesC8& aBinaryData);

	IMPORT_C static CWTLSSubjectPublicKeyInfo* NewLC(const TDesC8& aBinaryData);

	IMPORT_C static CWTLSSubjectPublicKeyInfo* NewL(const TDesC8& aBinaryData, TInt& aPos);

	IMPORT_C static CWTLSSubjectPublicKeyInfo* NewLC(const TDesC8& aBinaryData, TInt& aPos);

private:

	CWTLSSubjectPublicKeyInfo();

	void ConstructL(const TDesC8& aBinaryData, TInt& aPos);

	};

_LIT(KWTLSTCAType, " T");

_LIT(KWTLSTCAValue, "ca");

/**

 * @publishedAll

 * @released

 */

class CWTLSCertificate : public CCertificate

	{

public:

	enum	//enum values for encoded data element positions in tbsCert data structure

		{	//these values are to be used as params to DataElementEncoding() function

		EVersionNumber = 0,

		EAlgorithmId = 1,

		EIssuerName = 2,

		EValidityPeriod = 3,

		ESubjectName = 4,

		ESubjectPublicKeyInfo = 5,

		};

	/**

	 * Creates a new CWTLSCertificate object from the specified buffer containing the binary coded representation.

	 *

	 * @param aBinaryData	The encoded binary representation.

	 * @return				The new CWTLSCertificate object.

	 */	

	IMPORT_C static CWTLSCertificate* NewL(const TDesC8& aBinaryData);

	/**

	 * Creates a new CWTLSCertificate object from the specified buffer containing the binary coded representation,

	 * and puts a pointer to it onto the cleanup stack.

	 *

	 * @param aBinaryData	The encoded binary representation.

	 * @return				The new CWTLSCertificate object.

	 */	

	IMPORT_C static CWTLSCertificate* NewLC(const TDesC8& aBinaryData);

	/**

	 * Creates a new CWTLSCertificate object from the specified buffer containing the binary coded representation.

	 *

	 * @param aBinaryData	The encoded binary representation.

	 * @param aPos			An offset into the descriptor, and is updated to the position at the end of the object.

	 * @return				The new CWTLSCertificate object.

	 */	

	IMPORT_C static CWTLSCertificate* NewL(const TDesC8& aBinaryData, TInt& aPos);

	/**

	 * Creates a new CWTLSCertificate object from the specified buffer containing the binary coded representation,

	 * and puts a pointer to it onto the cleanup stack.

	 *

	 * @param aBinaryData	The encoded binary representation.

	 * @param aPos			An offset into the descriptor, and is updated to the position at the end of the object.

	 * @return				The new CWTLSCertificate object.

	 */	

	IMPORT_C static CWTLSCertificate* NewLC(const TDesC8& aBinaryData, TInt& aPos);

	/**

	 * Creates a new CWTLSCertificate object from a stream.

	 *

	 * The stream must have been written using the corresponding ExternalizeL() function.

	 *

	 * @param aStream	The stream to be used as input.

	 * @return			The new CWTLSCertificate object.

	 */	

	IMPORT_C static CWTLSCertificate* NewL(RReadStream& aStream);

	/**

	 * Creates a new CWTLSCertificate object from a stream,

	 * and puts a pointer to it onto the cleanup stack.

	 *

	 * The stream must have been written using the corresponding ExternalizeL() function.

	 *

	 * @param aStream	The stream to be used as input.

	 * @return			The new CWTLSCertificate object.

	 */	

	IMPORT_C static CWTLSCertificate* NewLC(RReadStream& aStream);

	/**

	 * Creates a new CWTLSCertificate object from an existing one in the certificate store.

	 *

	 * @param aCert	The certificate to be copied.

	 * @return		The new CWTLSCertificate object.

	 */	

	IMPORT_C static CWTLSCertificate* NewL(const CWTLSCertificate& aCert);

	/**

	 * Creates a new CWTLSCertificate object from an existing one in the certificate store,

	 * and puts a pointer to it onto the cleanup stack.

	 *

	 * @param aCert	The certificate to be copied.

	 * @return		The new CWTLSCertificate object.

	 */	

	IMPORT_C static CWTLSCertificate* NewLC(const CWTLSCertificate& aCert);

	/**

	 * Destructor.

	 *

	 * Frees all resources owned by the object, prior to its destruction.

	 */

	IMPORT_C ~CWTLSCertificate();

	/**

	* Tests whether this WTLS certificate is the same as the specified WTLS certificate.

	*

	* This is not a simple as it sounds. For X.509 certificates equality means that the issuer name 

	* and serial number fields are the same. This guarantees equality since a CA must ensure that every 

	* certificate it issues has a unique serial number. But WTLS certificates do not include serial numbers, 

	* so there seems to be no definition of equality. This function uses a byte-for-byte comparison of the 

	* signatures on the certificates: this should not result in any false positives, but may give false 

	* negatives if CAs do naughty things like recertifying the same key (which they have been known to do).

	*

	* @param aCert	A WTLS certificate

	* @return		ETrue, if the parameter is the same certificate; EFalse, otherwise.

	*/

	IMPORT_C TBool IsEqualL(const CWTLSCertificate& aCert) const;

	//extra accessors

	/**

	 * Gets the version number of the WTLS certificate.

	 *

	 * @return	The version number of the certificate. Always returns 1.

	 */

	IMPORT_C TInt Version() const;

	/**

	 * Gets the name of the WTLS certificate's issuing authority.

	 *

	 * @return	A WTLS name:

	 *			@li	If the name is an X.500 DN, then if the name contains a Common name, that will be returned. 

	 * 				Otherwise, if the name contains an Organization name, that will be returned. Otherwise an empty 

	 * 				string will be returned. 

	 *			@li	If the name is of type text, then if the name is not a 'structured' name the entire string will 

	 *				be returned, otherwise the same procedure will be followed as for X.509 certificates.

	 * 			@li	If the name is null an empty string will be returned. 

	 */

	 // Unsupported -- If the name is a key hash or binary value the entire contents will be returned.

	IMPORT_C const CWTLSName& IssuerName() const;

	/**

	* Gets the name of the owner of the public key the WTLS certificate contains.

	*

	* @return A WTLS name.

	*/

	IMPORT_C const CWTLSName& SubjectName() const;

	IMPORT_C virtual TBool IsSelfSignedL() const;

	IMPORT_C virtual HBufC* SubjectL() const;

	IMPORT_C virtual HBufC* IssuerL() const;

	/**

	* Initialises the certificate from a stream. 

	*

	* This should not be called by client code; instead the static factory function above should be used. 

	* If a client is using the certstore component for storage then it should use CCertStore::AddL() for 

	* externalizing and CWTLSCert::NewL(CCertStore& aStore, const CCertStoreEntry& aEntry); for restoring.

	*

	* @param aStream 

	*/

	IMPORT_C void InternalizeL(RReadStream& aStream);

	/**

	* Gets the certificate's signed data.

	*

	* @return	A non-modifiable pointer descriptor representing the certificate's signed data.

	*/

	IMPORT_C const TPtrC8 SignedDataL() const;

	/**

	* Gets the encoding for a data element at the specified index.

	*

	* @param aIndex	The position of the encoded data element.

	*/

	IMPORT_C virtual const TPtrC8* DataElementEncoding(const TUint aIndex) const;

	/**

	* Tests whether a non-selfsigned certificate can be used to sign others.

	* 

	* Currently this only supports structured text variety of WTLS certificates.  

	* Other certificate types will return EFalse.

	*

	* @return	ETrue, if the certificate is capable of signing other certificates; otherwise, EFalse. 

	*/

	IMPORT_C TBool IsTCAL() const;

private:

	CWTLSCertificate();

	void ConstructL(const TDesC8& aBinaryData, TInt& aPos);

	void ConstructL(const CWTLSCertificate& aCertificate);

	void ConstructCertL(const TDesC8& aBinaryData, TInt& aPos);

	void InitEncodedDataElementsL();

	//private data

	TInt iVersion;

	CWTLSName* iIssuerName;

	CWTLSName* iSubjectName;

	TFixedArray<TPtrC8*, KWTLSCertMaxDataElements>* iDataElements;

	};

#endif