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

 
#include <cmssignedobject.h>
#include <x509cert.h>
#include <x509certext.h>
#include <asymmetrickeys.h>
#include <hash.h>
#include <asn1enc.h>
#include <asn1dec.h>
#include <pkcs7excert.h>
#include <cmssigneridentifier.h>
#include <cmscontentinfo.h>
#include <cmssignerinfo.h>
#include "cmsutils.h"
#include "pkcs7asn1.h"

const TInt KSignedDataCertificates = 0;
const TInt KSignedDataRevocationLists = 1;

const TInt KCmsMinSignedDataElements = 4;
//
// Implementation of CMS Signed object
//
EXPORT_C CCmsSignedObject* CCmsSignedObject::NewLC(TCmsContentInfoType aType, TBool aIsDetached, const TDesC8& aContentData)
	{
	CCmsSignedObject* self = new (ELeave) CCmsSignedObject();
	CleanupStack::PushL(self);
	self->ConstructL(aType, aIsDetached, aContentData);
	return self;
	}

EXPORT_C CCmsSignedObject* CCmsSignedObject::NewL(TCmsContentInfoType aType, TBool aIsDetached, const TDesC8& aContentData)
	{
	CCmsSignedObject* self = NewLC(aType, aIsDetached, aContentData);
	CleanupStack::Pop(self);
	return self;
	}
	
EXPORT_C CCmsSignedObject* CCmsSignedObject::NewLC(TCmsContentInfoType aType,
												const TDesC8& aHashValue,
												TAlgorithmId aDigestAlgorithm,
												const CDSAPrivateKey& aKey,
												const CX509Certificate& aCert,
												TBool aAddCertificate)
	{
	CCmsSignedObject* self = new (ELeave) CCmsSignedObject();
	CleanupStack::PushL(self);
	self->ConstructL(aType, aHashValue, aDigestAlgorithm, aKey, aCert, aAddCertificate);
	return self;
	}

EXPORT_C CCmsSignedObject* CCmsSignedObject::NewL(TCmsContentInfoType aType,
												const TDesC8& aHashValue,
												TAlgorithmId aDigestAlgorithm,
												const CDSAPrivateKey& aKey,
												const CX509Certificate& aCert,
												TBool aAddCertificate)
	{
	CCmsSignedObject* self = NewLC(aType, aHashValue, aDigestAlgorithm, aKey, aCert, aAddCertificate);
	CleanupStack::Pop(self);
	return self;
	}


EXPORT_C CCmsSignedObject* CCmsSignedObject::NewLC(TCmsContentInfoType aType,
												const TDesC8& aHashValue,
												TAlgorithmId aDigestAlgorithm,
												const CRSAPrivateKey& aKey,
												const CX509Certificate& aCert,
												TBool aAddCertificate)
	{
	CCmsSignedObject* self = new (ELeave) CCmsSignedObject();
	CleanupStack::PushL(self);
	self->ConstructL(aType, aHashValue, aDigestAlgorithm, aKey, aCert, aAddCertificate);
	return self;
	}

EXPORT_C CCmsSignedObject* CCmsSignedObject::NewL(TCmsContentInfoType aType,
												const TDesC8& aHashValue,
												TAlgorithmId aDigestAlgorithm,
												const CRSAPrivateKey& aKey,
												const CX509Certificate& aCert,
												TBool aAddCertificate)
	{
	CCmsSignedObject* self = NewLC(aType, aHashValue, aDigestAlgorithm, aKey, aCert, aAddCertificate);
	CleanupStack::Pop(self);
	return self;
	}

	
EXPORT_C CCmsSignedObject* CCmsSignedObject::NewL(const CCmsContentInfo& aContentInfo)
	{
	CCmsSignedObject* self = NewLC(aContentInfo);
	CleanupStack::Pop(self);
	return self;		
	}
	
EXPORT_C CCmsSignedObject* CCmsSignedObject::NewLC(const CCmsContentInfo& aContentInfo)
	{
	CCmsSignedObject* self = new (ELeave) CCmsSignedObject();
	CleanupStack::PushL(self);
	self->ConstructL(aContentInfo);
	return self;				
	}

CCmsSignedObject::CCmsSignedObject() : iVersion(EVersion_1)
	{
	}

EXPORT_C CCmsSignedObject::~CCmsSignedObject()
	{
	delete iContentInfo;
	iDigestAlgorithms.ResetAndDestroy();
	iCertificates.ResetAndDestroy();
	iSignerInfo.ResetAndDestroy();	
	for(TInt i = 0; i < KCmsMaxSignedDataElements; i++)
		{
		delete iDataElements.At(i);
		}		
	}
	

EXPORT_C TBool CCmsSignedObject::IsCertificateSetPresent() const
	{
	return iIsCertificateSetPresent;
	}
	
EXPORT_C TBool CCmsSignedObject::IsCertificateRevocationListsPresent() const
	{
	return iIsCertificateRevocationListsPresent;
	}

EXPORT_C TInt CCmsSignedObject::Version() const
	{
	return iVersion;	
	}

EXPORT_C const RPointerArray<CCmsCertificateChoice>& CCmsSignedObject::Certificates() const
	{
	return iCertificates;
	}

EXPORT_C const RPointerArray<CX509AlgorithmIdentifier>& CCmsSignedObject::DigestAlgorithms() const
	{
	return iDigestAlgorithms;
	}

EXPORT_C const CEncapsulatedContentInfo& CCmsSignedObject::ContentInfo() const
	{
	return *iContentInfo;
	}
		
EXPORT_C const RPointerArray<CCmsSignerInfo>& CCmsSignedObject::SignerInfo() const
	{
	return iSignerInfo;
	}

EXPORT_C void CCmsSignedObject::AddCertificateL(const CX509Certificate& aCert)
	{	
	CmsUtils::AddCertificateL(iCertificates, aCert);
	}

void CCmsSignedObject::AddDigestAlgorithmL(TAlgorithmId aDigestAlgorithm)
	{
	CmsUtils::AddAlgorithmIdentifierL(iDigestAlgorithms, aDigestAlgorithm);	
	}

EXPORT_C void CCmsSignedObject::AddCertificateL(const TDesC8& aCert, CCmsCertificateChoice::TCertificateType aType)
	{
	if (aType==CCmsCertificateChoice::ECertificateAttribute)
		{
		iVersion=EVersion_3;
		}
	CmsUtils::AddCertificateL(iCertificates, aCert, aType);
	}

void CCmsSignedObject::DecodeSignerInfoL(const TDesC8& aRawData)
	{	
	CArrayPtr<TASN1DecGeneric>* signerInfo = PKCS7ASN1::DecodeSequenceLC(aRawData);
	TInt total = signerInfo->Count();
	CCmsSignerInfo* signer(NULL);

	for(TInt item = 0; item < total; item ++)
		{
		signer = CCmsSignerInfo::NewL(signerInfo->At(item)->Encoding());
		CleanupStack::PushL(signer);
		User::LeaveIfError(iSignerInfo.Append(signer));
		CleanupStack::Pop(signer);
		}
	CleanupStack::PopAndDestroy(signerInfo);
	}

void CCmsSignedObject::DecodeEncapsulatedContentInfoL(const TDesC8& aRawData)
	{
	iContentInfo = CEncapsulatedContentInfo::NewL(aRawData);
	}

void CCmsSignedObject::ConstructL(const CCmsContentInfo& aContentInfo)
	{
	if(aContentInfo.ContentType() != EContentTypeSignedData)
		{
		User::Leave(KErrArgument);
		}
	
	TASN1DecGeneric decGen(aContentInfo.ContentData());
	decGen.InitL();

	if(decGen.Tag() == EASN1Sequence && decGen.Class()==EUniversal)
		{
		InitSignedObjectL(decGen.Encoding());
	    DecodeSignedDataL(*iEncoding);
		}
	else
		{
	    User::Leave(KErrArgument);
		}			
	}

void CCmsSignedObject::ConstructL(TCmsContentInfoType aType, TBool aIsDetached, const TDesC8& aContentData)
	{
	if (aContentData==KNullDesC8() && !aIsDetached)
		{
		User::Leave(KErrArgument);	
		}
	iContentInfo=CEncapsulatedContentInfo::NewL(aType, !aIsDetached, aContentData);	
	//For later use to create hash if detached and hash not provided
	iContentData.Set(aContentData);			
	}

CCmsSignerIdentifier* CCmsSignedObject::BuildSignerIdentifierLC(const CX509Certificate& aCert)
	{
	CCmsSignerIdentifier* sid(NULL);
	const CX509CertExtension* certExt = aCert.Extension(KSubjectKeyId);
	if (certExt)
		{
		CX509SubjectKeyIdExt* ext=CX509SubjectKeyIdExt::NewLC(certExt->Data());
		HBufC8* subKeyId=ext->KeyId().AllocL();
		CleanupStack::PopAndDestroy(ext);
		CleanupStack::PushL(subKeyId);
		sid=CCmsSignerIdentifier::NewL(subKeyId);
		CleanupStack::Pop(subKeyId);
		CleanupStack::PushL(sid);
		iVersion=EVersion_3;
		}
	else
		{
		CX500DistinguishedName* distinguishedName=CX500DistinguishedName::NewLC(aCert.IssuerName());
		CPKCS7IssuerAndSerialNumber* issuerAndSN=CPKCS7IssuerAndSerialNumber::NewL(distinguishedName, aCert.SerialNumber());
		CleanupStack::Pop(distinguishedName);
		CleanupStack::PushL(issuerAndSN);
		sid=CCmsSignerIdentifier::NewL(issuerAndSN);
		CleanupStack::Pop(issuerAndSN);
		CleanupStack::PushL(sid);
		}
	return sid;	
	}


void CCmsSignedObject::BuildSignerInfoCertListAndAlgoritmListL(TAlgorithmId aDigestAlgorithm,
																TBool aIsHash,
																const TDesC8& aValue,
																const CDSAPrivateKey& aKey,
																const CX509Certificate& aCert,
																TBool aAddCertificate)
	{		
	//build Signer Identifier
	CCmsSignerIdentifier* sid=BuildSignerIdentifierLC(aCert);
	
	//build digest algorithm and signing algorithm
	CX509AlgorithmIdentifier* digAlg=CX509AlgorithmIdentifier::NewLC(aDigestAlgorithm, KNullDesC8());
	const CSubjectPublicKeyInfo& publicKeyInfo=aCert.PublicKey();
	CX509AlgorithmIdentifier* signingAlg=CX509AlgorithmIdentifier::NewLC(publicKeyInfo.AlgorithmId(), KNullDesC8());

	//build signer info
	CCmsSignerInfo* signerInfo=CCmsSignerInfo::NewL(aValue,
													aIsHash,
													aKey,
													sid,
													digAlg,
													signingAlg);
	CleanupStack::Pop(3, sid);
	CleanupStack::PushL(signerInfo);
	//add to the signer info list
	iSignerInfo.AppendL(signerInfo);
	CleanupStack::Pop();
	
	//Add the certificate to the list if needed
	if (aAddCertificate)
		{
		AddCertificateL(aCert);
		}
		
	//Add the digest algorithm the list if needed
	AddDigestAlgorithmL(aDigestAlgorithm);	
	}



void CCmsSignedObject::BuildSignerInfoCertListAndAlgoritmListL(TAlgorithmId aDigestAlgorithm,
																TBool aIsHash,
																const TDesC8& aValue,
																const CRSAPrivateKey& aKey,
																const CX509Certificate& aCert,
																TBool aAddCertificate)

	{		
	//build Signer Identifier
	CCmsSignerIdentifier* sid=BuildSignerIdentifierLC(aCert);
	
	//build digest algorithm and signing algorithm
	CX509AlgorithmIdentifier* digAlg=CX509AlgorithmIdentifier::NewLC(aDigestAlgorithm, KNullDesC8());	
	const CSubjectPublicKeyInfo& publicKeyInfo=aCert.PublicKey();
	CX509AlgorithmIdentifier* signingAlg=CX509AlgorithmIdentifier::NewLC(publicKeyInfo.AlgorithmId(), publicKeyInfo.EncodedParams());

	//build signer info
	CCmsSignerInfo* signerInfo=CCmsSignerInfo::NewL(aValue,
													aIsHash,
													aKey,
													sid,
													digAlg,
													signingAlg);
	CleanupStack::Pop(3, sid);
	CleanupStack::PushL(signerInfo);
	//add to the signer info list
	iSignerInfo.AppendL(signerInfo);
	CleanupStack::Pop();
	
	//Add the certificate to the list if needed
	if (aAddCertificate)
		{
		AddCertificateL(aCert);
		}
		
	//Add the digest algorithm the list if needed
	AddDigestAlgorithmL(aDigestAlgorithm);
	}

void CCmsSignedObject::ConstructL(TCmsContentInfoType aType,
								const TDesC8& aHashValue,
								TAlgorithmId aDigestAlgorithm,
								const CDSAPrivateKey& aKey,
								const CX509Certificate& aCert,
								TBool aAddCertificate)
	{
	//Set the CMS object version to version 3 if the encapsulatedconetent data type is not data
	if (aType != EContentTypeData)
		{
		iVersion=EVersion_3;
		}
		
	//build EncapsulatedContentInfo	
	iContentInfo=CEncapsulatedContentInfo::NewL(aType, EFalse, KNullDesC8());
	
	BuildSignerInfoCertListAndAlgoritmListL(aDigestAlgorithm,
											ETrue,
											aHashValue,
											aKey,
											aCert,
											aAddCertificate);		
		
	}
void CCmsSignedObject::ConstructL(TCmsContentInfoType aType,
								const TDesC8& aHashValue,
								TAlgorithmId aDigestAlgorithm,
								const CRSAPrivateKey& aKey,
								const CX509Certificate& aCert,
								TBool aAddCertificate)
	{
	//Set the CMS object version to version 3 if the encapsulatedconetent data type is not data
	if (aType != EContentTypeData)
		{
		iVersion=EVersion_3;
		}

	//build EncapsulatedContentInfo	
	iContentInfo=CEncapsulatedContentInfo::NewL(aType, EFalse, KNullDesC8());

	BuildSignerInfoCertListAndAlgoritmListL(aDigestAlgorithm,
											ETrue,
											aHashValue,
											aKey,
											aCert,
											aAddCertificate);		
	}


EXPORT_C void CCmsSignedObject::SignL(const TDesC8& aHashValue,
										TAlgorithmId aDigestAlgorithm,
										const CDSAPrivateKey& aKey,
										const CX509Certificate& aCert,
										TBool aAddCertificate)
										
	{
	TBool isHash=(aHashValue!=KNullDesC8())? ETrue:EFalse;
	if (isHash)
		{
		BuildSignerInfoCertListAndAlgoritmListL(aDigestAlgorithm,
												isHash,
												aHashValue,
												aKey,
												aCert,
												aAddCertificate);			
		}
	else
		{
		if (iContentData!=KNullDesC8())
			{
			BuildSignerInfoCertListAndAlgoritmListL(aDigestAlgorithm,
													isHash,
													iContentData,
													aKey,
													aCert,
													aAddCertificate);							
			}
		else
			{
			//No way to sign if no data content nor its hash.
			User::Leave(KErrArgument);	
			}
		}
	}
										
EXPORT_C void CCmsSignedObject::SignL(const TDesC8& aHashValue,
										TAlgorithmId aDigestAlgorithm,
										const CRSAPrivateKey& aKey,
										const CX509Certificate& aCert,
										TBool aAddCertificate)
	{
	TBool isHash=(aHashValue!=KNullDesC8())? ETrue:EFalse;
	if (isHash)
		{
		BuildSignerInfoCertListAndAlgoritmListL(aDigestAlgorithm,
												isHash,
												aHashValue,
												aKey,
												aCert,
												aAddCertificate);			
		}
	else
		{
		if (iContentData!=KNullDesC8())
			{
			BuildSignerInfoCertListAndAlgoritmListL(aDigestAlgorithm,
													isHash,
													iContentData,
													aKey,
													aCert,
													aAddCertificate);
			}
		else
			{
			//No way to sign if no data content nor its hash.
			User::Leave(KErrArgument);	
			}
		}
	}


EXPORT_C CASN1EncSequence* CCmsSignedObject::EncodeASN1DERLC() const
	{
	// the root sequence contains the signed object
	CASN1EncSequence* root = CASN1EncSequence::NewLC();
	
	// Encode version
	CASN1EncInt* version=CASN1EncInt::NewLC(iVersion);	
	root->AddAndPopChildL(version);

	// Encode Algorithm
	CASN1EncBase* algorithm=EncodeAlgorithmsLC();
	root->AddAndPopChildL(algorithm);			

			
	// Encode EncapsulatedContentInfo	
	CASN1EncSequence* contentInfo=iContentInfo->EncodeASN1DERLC();
	root->AddAndPopChildL(contentInfo);
	
	// Encode option fields certificates SET
	CASN1EncBase* cert=EncodeCertificatesLC();
	if (cert)
		{
		root->AddAndPopChildL(cert);			
		}
		
	// Encode signerinfo
	CASN1EncBase* signerInfo=EncodeSignerInfoLC();
	root->AddAndPopChildL(signerInfo);			
	
	return root;
	}


CASN1EncBase* CCmsSignedObject::EncodeCertificatesLC() const
	{
	return CmsUtils::EncodeCertificatesLC(iCertificates);
	}

CASN1EncBase* CCmsSignedObject::EncodeAlgorithmsLC() const
	{
	return CmsUtils::EncodeDigestAlgorithmsLC(iDigestAlgorithms);
	}

CASN1EncBase* CCmsSignedObject::EncodeSignerInfoLC() const
	{
	CASN1EncSet* signerInfoSet = CASN1EncSet::NewLC();
	TInt count=iSignerInfo.Count();
	
	for (TInt i=0;i<count;i++)
		{
		CASN1EncSequence* signerInfo=iSignerInfo[i]->EncodeASN1DERLC();
		signerInfoSet->AddAndPopChildL(signerInfo);	
		}
	return signerInfoSet;	
	}
	
EXPORT_C TBool CCmsSignedObject::ValidateSignerLC(const CCmsSignerInfo& aSignerInfo, HBufC8*& aCertChainEncoding)
	{
	TInt certCount = iCertificates.Count();
	TInt endEntityPos = -1;
	TInt endEncodingSize = 0;
	TPtrC8 endEntityEncoding;
	TInt cert;
	TBool valid = EFalse;

	const CCmsSignerIdentifier& signerId = aSignerInfo.SignerIdentifier();
	
	// looks for end entity certificate
	for(cert = 0; cert < certCount; cert++)
		{
		if (iCertificates[cert]->CertificateType()==CCmsCertificateChoice::ECertificateX509)
			{
			const CX509Certificate& certificate = iCertificates[cert]->Certificate();

			endEncodingSize+= certificate.Encoding().Length();
			
			if(endEntityPos == -1)
				{
				if (signerId.SignerIdentifierType()==CCmsSignerIdentifier::EIssuerAndSerialNumber)
					{
					if (certificate.IssuerName().ExactMatchL(signerId.IssuerAndSerialNumber()->IssuerName()))
						{
						RInteger sn1=RInteger::NewL(certificate.SerialNumber());
						CleanupClosePushL(sn1);
						RInteger sn2=RInteger::NewL(signerId.IssuerAndSerialNumber()->SerialNumber());
						CleanupClosePushL(sn2);
						if (sn1==sn2)
							{
							endEntityPos = cert;
							endEntityEncoding.Set(certificate.Encoding());
							valid = ValidateSignatureL(aSignerInfo, certificate);					
							}
						CleanupStack::PopAndDestroy(2, &sn1);//sn2, sn1
						}
					}
				else
					{
					const CX509CertExtension* certExt = certificate.Extension(KSubjectKeyId);
					if (certExt)
						{
						CX509SubjectKeyIdExt* ext=CX509SubjectKeyIdExt::NewLC(certExt->Data());
						if (signerId.SubjectKeyIdentifier().Compare(ext->KeyId())==0)
							{
							endEntityPos = cert;
							endEntityEncoding.Set(certificate.Encoding());
							valid = ValidateSignatureL(aSignerInfo, certificate);						
							}
						CleanupStack::PopAndDestroy(ext);					
						}
					}											
				}
			}
		}

	// checks if end entity was found
	if(endEntityPos != -1)
		{
		// builds the cert chain encoding by putting the end entity first then all remaining
		// certs
  		aCertChainEncoding = HBufC8::NewLC(endEncodingSize);
  		TPtr8 encodingPtr(aCertChainEncoding->Des());
		encodingPtr.Copy(endEntityEncoding);
		for(cert = 0; cert < certCount; cert++)
			{
			if (iCertificates[cert]->CertificateType()==CCmsCertificateChoice::ECertificateX509)
				{
				const CX509Certificate& certificate = iCertificates[cert]->Certificate();
				if(cert != endEntityPos)
					{
					encodingPtr.Append(certificate.Encoding());
					}					
				}
			}
		}
	else
		{
		User::Leave(KErrNotFound);
		}
	return valid;
	}


EXPORT_C TBool CCmsSignedObject::ValidateSignerLC(const CCmsSignerInfo& aSignerInfo, const RPointerArray<CX509Certificate>& aCertificates, HBufC8*& aCertChainEncoding)
	{
	TInt certCount = aCertificates.Count();
	TInt endEntityPos = -1;
	TInt endEncodingSize = 0;
	TPtrC8 endEntityEncoding;
	TInt cert;
	TBool valid = EFalse;
	const CCmsSignerIdentifier& signerId = aSignerInfo.SignerIdentifier();
	
	// looks for end entity certificate
	for(cert = 0; cert < certCount; cert++)
		{
		const CX509Certificate& certificate = *aCertificates[cert];
		endEncodingSize+= certificate.Encoding().Length();
		if(endEntityPos == -1)
			{
			if (signerId.SignerIdentifierType()==CCmsSignerIdentifier::EIssuerAndSerialNumber)
				{
				if (certificate.IssuerName().ExactMatchL(signerId.IssuerAndSerialNumber()->IssuerName()))
					{					
					RInteger sn1=RInteger::NewL(certificate.SerialNumber());
					CleanupClosePushL(sn1);
					RInteger sn2=RInteger::NewL(signerId.IssuerAndSerialNumber()->SerialNumber());
					CleanupClosePushL(sn2);
					if (sn1==sn2)
						{
						endEntityPos = cert;
						endEntityEncoding.Set(certificate.Encoding());
						valid = ValidateSignatureL(aSignerInfo, certificate);					
						}
					CleanupStack::PopAndDestroy(2, &sn1);//sn2, sn1
					}
				}
			else
				{
				const CX509CertExtension* certExt = certificate.Extension(KSubjectKeyId);
				if (certExt)
					{
					CX509SubjectKeyIdExt* ext=CX509SubjectKeyIdExt::NewLC(certExt->Data());
					if (signerId.SubjectKeyIdentifier().Compare(ext->KeyId())==0)
						{
						endEntityPos = cert;
						endEntityEncoding.Set(certificate.Encoding());
						valid = ValidateSignatureL(aSignerInfo, certificate);						
						}
					CleanupStack::PopAndDestroy(ext);
					}
				}				
			}		
		}

	// checks if end entity was found
	if(endEntityPos != -1)
		{
		// builds the cert chain encoding by putting the end entity first then all remaining
		// certs
  		aCertChainEncoding = HBufC8::NewLC(endEncodingSize);
  		TPtr8 encodingPtr(aCertChainEncoding->Des());
		encodingPtr.Copy(endEntityEncoding);
		for(cert = 0; cert < certCount; cert++)
			{
			const CX509Certificate& certificate = *aCertificates[cert];
	
			if(cert != endEntityPos)
				{
				encodingPtr.Append(certificate.Encoding());
				}
			}
		}
	else
		{
		User::Leave(KErrNotFound);
		}
		
	return valid;
	}


EXPORT_C TBool CCmsSignedObject::ValidateSignerLC(const CCmsSignerInfo& aSignerInfo, HBufC8*& aCertChainEncoding, TBool aIsHash, const TDesC8& aContentDataOrHash)
	{
	if (aIsHash)
		{
		SetHash(aContentDataOrHash);	
		}
	else
		{
		SetContentData(aContentDataOrHash);
		}
	return ValidateSignerLC(aSignerInfo, aCertChainEncoding);
	}

EXPORT_C TBool CCmsSignedObject::ValidateSignerLC(const CCmsSignerInfo& aSignerInfo, const RPointerArray<CX509Certificate>& aCertificates, HBufC8*& aCertChainEncoding, TBool aIsHash, const TDesC8& aContentDataOrHash)
	{
	if (aIsHash)
		{
		SetHash(aContentDataOrHash);	
		}
	else
		{
		SetContentData(aContentDataOrHash);
		}
	return ValidateSignerLC(aSignerInfo, aCertificates, aCertChainEncoding);	
	}

TBool CCmsSignedObject::ValidateSignatureL(const CCmsSignerInfo& aSignerInfo, const CX509Certificate& aEndEntityCert)
	{
	delete iSigningAlgorithm;
	iSigningAlgorithm = NULL;			
	iSigningAlgorithm = CX509SigningAlgorithmIdentifier::NewL(aSignerInfo.SignatureAlgorithm(), aSignerInfo.DigestAlgorithm());
	
	delete iSignature;
	iSignature = NULL;
	iSignature = aSignerInfo.SignatureValue().AllocL();
	
	if (aSignerInfo.SignatureAlgorithm().Algorithm()==EDSA)
		{
		delete iParameters;
		iParameters = NULL;
		CDSAParameters* theDSAParams = iKeyFactory->DSAParametersL(aEndEntityCert.PublicKey().EncodedParams());
		CleanupStack::PushL(theDSAParams);
		CSigningKeyParameters* params = CSigningKeyParameters::NewLC();
		params->SetDSAParamsL(*theDSAParams);
		SetParametersL(*params);
		CleanupStack::PopAndDestroy(2, theDSAParams);
		}
	
	if (iContentInfo->IsContentDataPresent() || iContentData != KNullDesC8)
		{
		return VerifySignatureL(aEndEntityCert.PublicKey().KeyData());			
		}
	else if (iHash!=KNullDesC8)
			{
			return VerifySignatureL(aEndEntityCert.PublicKey().KeyData(), iHash);	
			}
		 else
			 {
			 User::Leave(KErrArgument);
			 return EFalse;
			 }			
	
	}

void CCmsSignedObject::InitSignedObjectL(const TDesC8& aRawData)
	{	
	// Populate CSignedObject data members
	iKeyFactory = new (ELeave) TX509KeyFactory;
	iEncoding = aRawData.AllocL();

	CSHA1* hash = CSHA1::NewL();
	CleanupStack::PushL(hash);
	iFingerprint = hash->Hash(Encoding()).AllocL();
	CleanupStack::PopAndDestroy(hash);	
	}

void CCmsSignedObject::DecodeSignedDataL(const TDesC8& aRawData)
	{		
	CArrayPtr<TASN1DecGeneric>* signedData = PKCS7ASN1::DecodeSequenceLC(aRawData, KCmsMinSignedDataElements, KCmsMaxSignedDataElements);
	TInt totalItems = signedData->Count();
	TASN1DecInteger decInt;

	// decodes version
	iDataElements.At(EVersionNumber) = new(ELeave) TPtrC8(signedData->At(0)->GetContentDER());
	iVersion = decInt.DecodeDERShortL(*signedData->At(0));
	if (iVersion>4 || iVersion<0)
		{
		User::Leave(KErrArgument);
		}
	// decodes algorithms
	iDataElements.At(EDigestAlgorithms) = new(ELeave) TPtrC8(signedData->At(1)->GetContentDER());
	DecodeDigestAlgorithmsL(signedData->At(1)->Encoding());
	// decodes contentinfo
	iDataElements.At(EEncapsulatedContentInfo) = new(ELeave) TPtrC8(signedData->At(2)->GetContentDER());
	DecodeEncapsulatedContentInfoL(signedData->At(2)->Encoding());

	// Checks for optional fields
	TInt pos = 3;	// Skip first non-optional fields
	do
		{
		const TASN1DecGeneric& currentItem = *signedData->At(pos);
		switch(currentItem.Tag())
			{
			case KSignedDataCertificates:
				{
				if (currentItem.Class()!=EContextSpecific)
					{
					User::Leave(KErrArgument);	
					}				
				iIsCertificateSetPresent=ETrue;
				iDataElements.At(ECertificates) = new(ELeave) TPtrC8(currentItem.GetContentDER());
				DecodeCertificatesL(currentItem.Encoding());
				break;
				}
			case KSignedDataRevocationLists:
				{
				if (currentItem.Class()!=EContextSpecific)
					{
					User::Leave(KErrArgument);	
					}				
				iIsCertificateRevocationListsPresent=ETrue;
				iDataElements.At(ERevocationLists) = new(ELeave) TPtrC8(currentItem.GetContentDER());
				DecodeRevocationListsL(currentItem.Encoding());
				break;
				}
			default:	
				{
				//Optional field with wrong tag and class
				if (pos<totalItems-1)
					{
					User::Leave(KErrArgument);
					}
				// else Non-optional field	
				}
			}
		pos++;
		}
	while(pos < totalItems);

	iDataElements.At(ESignedInfo) = new(ELeave) TPtrC8(signedData->At(totalItems-1)->GetContentDER());
	DecodeSignerInfoL(signedData->At(totalItems-1)->Encoding());

	CleanupStack::PopAndDestroy(signedData);
	}

void CCmsSignedObject::DecodeDigestAlgorithmsL(const TDesC8& aRawData)
	{	
	CmsUtils::DecodeDigestAlgorithmsL(iDigestAlgorithms, aRawData);
	}

void CCmsSignedObject::DecodeCertificatesL(const TDesC8& aRawData)
	{
	CmsUtils::DecodeCertificatesL(iCertificates, aRawData);	
	}

void CCmsSignedObject::DecodeRevocationListsL(const TDesC8& /*aRawData*/)
	{	
	}
	
EXPORT_C const TPtrC8 CCmsSignedObject::SignedDataL() const
	{
	if (iContentInfo->IsContentDataPresent())
		{
		return iContentInfo->ContentData();	
		}
	else
		{
		if (iContentData!=KNullDesC8)
			{
			return iContentData;	
			}
		else
			{
			User::Leave(KErrArgument);
			}
		}
	return KNullDesC8();
	}

EXPORT_C void CCmsSignedObject::InternalizeL(RReadStream& /*aStream*/) 
	{
	User::Leave(KErrNotSupported);
	}

EXPORT_C const TPtrC8* CCmsSignedObject::DataElementEncoding(const TUint aIndex) const
	{
	return iDataElements.At(aIndex);
	}

void CCmsSignedObject::SetContentData(const TDesC8& aContentData)
	{
	iContentData.Set(aContentData);	
	}

void CCmsSignedObject::SetHash(const TDesC8& aHash)
	{
	iHash.Set(aHash);
	}