/*

* 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)