/*
* 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 <cmssignerinfo.h>
#include <asn1dec.h>
#include <asn1enc.h>
#include <x509cert.h>
#include <cmssigneridentifier.h>
#include <cmsdefs.h>
#include "cmsutils.h"
#include "pkcs7asn1.h"

//
// Implementation of CCmsSignerInfo
//
CCmsSignerInfo* CCmsSignerInfo::NewL(const TDesC8& aDataToBeSigned,
									TBool aIsHash,
									const CDSAPrivateKey& aKey,
									CCmsSignerIdentifier* aSignerIdentifier,
									CX509AlgorithmIdentifier* aDigestAlgorithm,
									CX509AlgorithmIdentifier* aSignatureAlgorithm)
	{
	CCmsSignerInfo* self = NewLC(aDataToBeSigned,
								 aIsHash,
								 aKey,
								 aSignerIdentifier,
								 aDigestAlgorithm,
								 aSignatureAlgorithm);
	CleanupStack::Pop(self);
	return self;
	}
										
CCmsSignerInfo* CCmsSignerInfo::NewLC(const TDesC8& aDataToBeSigned,
									TBool aIsHash,
									const CDSAPrivateKey& aKey,
									CCmsSignerIdentifier* aSignerIdentifier,
									CX509AlgorithmIdentifier* aDigestAlgorithm,
									CX509AlgorithmIdentifier* aSignatureAlgorithm)
	{
	if (!aSignerIdentifier||!aDigestAlgorithm||!aSignatureAlgorithm)
		{
		User::Leave(KErrArgument);	
		}
	CCmsSignerInfo* self = new (ELeave) CCmsSignerInfo();
	CleanupStack::PushL(self);
	self->ConstructL(aDataToBeSigned, aIsHash, aKey, aSignerIdentifier, aDigestAlgorithm, aSignatureAlgorithm);
	return self;
	}

CCmsSignerInfo* CCmsSignerInfo::NewL(const TDesC8& aDataToBeSigned,
									TBool aIsHash,
									const CRSAPrivateKey& aKey,
									CCmsSignerIdentifier* aSignerIdentifier,
									CX509AlgorithmIdentifier* aDigestAlgorithm,
									CX509AlgorithmIdentifier* aSignatureAlgorithm)
	{
	CCmsSignerInfo* self = NewLC(aDataToBeSigned,
								 aIsHash,
								 aKey,
								 aSignerIdentifier,
								 aDigestAlgorithm,
								 aSignatureAlgorithm);
	CleanupStack::Pop(self);
	return self;		
	}

CCmsSignerInfo* CCmsSignerInfo::NewLC(const TDesC8& aDataToBeSigned,
									TBool aIsHash,
									const CRSAPrivateKey& aKey,
									CCmsSignerIdentifier* aSignerIdentifier,
									CX509AlgorithmIdentifier* aDigestAlgorithm,
									CX509AlgorithmIdentifier* aSignatureAlgorithm)
	{
	if (!aSignerIdentifier||!aDigestAlgorithm||!aSignatureAlgorithm)
		{
		User::Leave(KErrArgument);	
		}

	CCmsSignerInfo* self = new (ELeave) CCmsSignerInfo();
	CleanupStack::PushL(self);
	self->ConstructL(aDataToBeSigned, aIsHash, aKey, aSignerIdentifier, aDigestAlgorithm, aSignatureAlgorithm);
	return self;
	}

CCmsSignerInfo* CCmsSignerInfo::NewL(const TDesC8& aRawData)
	{
	CCmsSignerInfo* self = NewLC(aRawData);
	CleanupStack::Pop(self);
	return self;
	}
	
CCmsSignerInfo* CCmsSignerInfo::NewLC(const TDesC8& aRawData)
	{
	CCmsSignerInfo* self = new (ELeave) CCmsSignerInfo();
	CleanupStack::PushL(self);
	self->ConstructL(aRawData);
	return self;
	}

CCmsSignerInfo::CCmsSignerInfo()
	{	
	}
	
CCmsSignerInfo::~CCmsSignerInfo()
	{
	delete iDigestAlgorithm;
	delete iSignatureAlgorithm;
	delete iSignatureValue;	
	delete iSignerIdentifier;
	}

void CCmsSignerInfo::ConstructL(const TDesC8& aDataToBeSigned, 	
								TBool aIsHash, 
								const CDSAPrivateKey& aKey,
								CCmsSignerIdentifier* aSignerIdentifier,
								CX509AlgorithmIdentifier* aDigestAlgorithm,
								CX509AlgorithmIdentifier* aSignatureAlgorithm)
								
	{
	if (aSignatureAlgorithm->Algorithm()!=EDSA)
		{
		User::Leave(KErrArgument);	
		}
	iSignatureValue=CmsUtils::CreateSignatureL(aDataToBeSigned, aIsHash, aDigestAlgorithm->Algorithm(), aKey);
	
	iSignerIdentifier=aSignerIdentifier;
	iDigestAlgorithm=aDigestAlgorithm;
	iSignatureAlgorithm=aSignatureAlgorithm;
	//find out the CMS signer info version
	if (iSignerIdentifier->SignerIdentifierType() == CCmsSignerIdentifier::EIssuerAndSerialNumber)
		{
		iVersion=EVersion_1;
		}
	else if (iSignerIdentifier->SignerIdentifierType() == CCmsSignerIdentifier::ESubjectKeyIdentifier)
		{
		iVersion=EVersion_3;	
		}	
	
	}

void CCmsSignerInfo::ConstructL(const TDesC8& aDataToBeSigned, 	
								TBool aIsHash, 
								const CRSAPrivateKey& aKey,
								CCmsSignerIdentifier* aSignerIdentifier,
								CX509AlgorithmIdentifier* aDigestAlgorithm,
								CX509AlgorithmIdentifier* aSignatureAlgorithm)								
	{
	if (aSignatureAlgorithm->Algorithm()!=ERSA)
		{
		User::Leave(KErrArgument);	
		}
	iSignatureValue=CmsUtils::CreateSignatureL(aDataToBeSigned, aIsHash, aDigestAlgorithm->Algorithm(), aKey);
	iSignerIdentifier=aSignerIdentifier;
	iDigestAlgorithm=aDigestAlgorithm;
	iSignatureAlgorithm=aSignatureAlgorithm;
	//find out the CMS signer info version
	if (iSignerIdentifier->SignerIdentifierType() == CCmsSignerIdentifier::EIssuerAndSerialNumber)
		{
		iVersion=EVersion_1;
		}
	else if (iSignerIdentifier->SignerIdentifierType() == CCmsSignerIdentifier::ESubjectKeyIdentifier)
		{
		iVersion=EVersion_3;	
		}
	}

void CCmsSignerInfo::ConstructL(const TDesC8& aRawData)
	{
	CArrayPtr<TASN1DecGeneric>* signerInfo = PKCS7ASN1::DecodeSequenceLC(aRawData, 5, 7);
	TASN1DecInteger decInt;
	TInt pos = 0;
	// decodes version
	iVersion = decInt.DecodeDERShortL(*signerInfo->At(pos++));
	if (iVersion<0 || iVersion>4)
		{
		User::Leave(KErrArgument);	
		}

	DecodeSignerIdentifierL(signerInfo->At(pos++)->Encoding());
	
	iDigestAlgorithm = CX509AlgorithmIdentifier::NewL(signerInfo->At(pos++)->Encoding());

	if(signerInfo->At(pos)->Tag() == 0 && signerInfo->At(pos)->Class() == EContextSpecific)
		{
		// authenticated attributes not supported at this time
		iSignedAttributesPresent=ETrue;
		pos++;
		}
	iSignatureAlgorithm = CX509AlgorithmIdentifier::NewL(signerInfo->At(pos++)->Encoding());
	DecodeEncryptedDigestL(signerInfo->At(pos++)->Encoding());

	if(pos < signerInfo->Count() && signerInfo->At(pos)->Tag() == 1 && signerInfo->At(pos)->Class() == EContextSpecific)
		{
		// unauthenticated attributes not supported at this time
		iUnsignedAttributesPresent=ETrue;
		pos++;		
		}

	CleanupStack::PopAndDestroy(signerInfo);
	}
	
CASN1EncSequence* CCmsSignerInfo::EncodeASN1DERLC() const
	{
	// the root sequence contains the signed object
	CASN1EncSequence* root = CASN1EncSequence::NewLC();
	
	//Encode the version
	CASN1EncInt* version=CASN1EncInt::NewLC(iVersion);	
	root->AddAndPopChildL(version);
	
	//Encode sid
	CASN1EncBase* sid=EncodeSignerIdentifierLC();
	root->AddAndPopChildL(sid);
	
	//Encode Digest Algoritm
	CASN1EncSequence* digAlg=iDigestAlgorithm->EncodeASN1DERLC();
	root->AddAndPopChildL(digAlg);
	
	//Encode signature Algoritm
	CASN1EncSequence* sigAlg=iSignatureAlgorithm->EncodeASN1DERLC();
	root->AddAndPopChildL(sigAlg);
	
	//Encode signature value
	CASN1EncOctetString* sigEnc=CASN1EncOctetString::NewLC(iSignatureValue->Des());
	root->AddAndPopChildL(sigEnc);
	
	return root;	
	}
	
void CCmsSignerInfo::DecodeEncryptedDigestL(const TDesC8& aRawData)
	{
	CmsUtils::DecodeOctetStringL(aRawData, iSignatureValue);
	}

void CCmsSignerInfo::DecodeSignerIdentifierL(const TDesC8& aRawData)
	{
	iSignerIdentifier=CCmsSignerIdentifier::NewL(aRawData);
	}

CASN1EncBase* CCmsSignerInfo::EncodeSignerIdentifierLC() const
	{
	return iSignerIdentifier->EncodeASN1DERLC();	
	}

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

EXPORT_C TBool CCmsSignerInfo::IsSignedAttributesPresent() const
	{
	return iSignedAttributesPresent;	
	}

EXPORT_C TBool CCmsSignerInfo::IsUnsignedAttributesPresent() const
	{
	return iUnsignedAttributesPresent;	
	}
	
EXPORT_C const CX509AlgorithmIdentifier& CCmsSignerInfo::DigestAlgorithm() const
	{
	return *iDigestAlgorithm;	
	}

EXPORT_C const CX509AlgorithmIdentifier& CCmsSignerInfo::SignatureAlgorithm() const	
	{
	return *iSignatureAlgorithm;	
	}

EXPORT_C const TPtrC8 CCmsSignerInfo::SignatureValue() const
	{
	return *iSignatureValue;	
	}
	
EXPORT_C const CCmsSignerIdentifier& CCmsSignerInfo::SignerIdentifier() const
	{
	return *iSignerIdentifier;
	}