/*

* Copyright (c) 2006-2006 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:       Xmlsecurity signing tests

*

*/

//  CLASS HEADER

#include "xmlsecsigntester.h"

//  EXTERNAL INCLUDES

#include <StifParser.h>

#include <f32file.h>

#include <Stiftestinterface.h>

#include <s32file.h>

#include <e32svr.h>

#include <libc/sys/reent.h>

#include <utf.h>

//  INTERNAL INCLUDES

#include "xmlsecwinit.h"

#include "xmlsecwsign.h"

#include "xmlsecwerrors.h"

#include "inetprottextutils.h" 

// MACROS

//#define ?macro ?macro_def

#define LOCAL_ASSERT(expression)	{if(!(expression)){return KErrArgument;}}

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CXmlSecTester::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

// -----------------------------------------------------------------------------

//

void CXmlSecSignTester::Delete() 

    {

    }

// -----------------------------------------------------------------------------

// CXmlSecTester::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt CXmlSecSignTester::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function. 

		// Test cases for encryption

		ENTRY( "Test-NewLL", CXmlSecSignTester::CXmlSecSign_NewLL),

		ENTRY( "Test-NewLC", CXmlSecSignTester::CXmlSecSign_NewLCL),

		ENTRY( "Test-SignXmlDocumentLL", CXmlSecSignTester::CXmlSecSign_SignXmlDocumentLL),

		ENTRY( "Test-SignXmlDocumentL_2L", CXmlSecSignTester::CXmlSecSign_SignXmlDocumentL_2L),

		ENTRY( "Test-SignXmlDocumentL_3L", CXmlSecSignTester::CXmlSecSign_SignXmlDocumentL_3L),

	  ENTRY( "Test-SignXmlDocumentKeyFromFileL_1L", CXmlSecSignTester::CXmlSecSign_SignXmlDocumentKeyFromFileL_1L),

	  ENTRY( "Test-SignXmlDocumentKeyFromFileL_2L", CXmlSecSignTester::CXmlSecSign_SignXmlDocumentKeyFromFileL_2L),

	  ENTRY( "Test-SignXmlDocumentKeyFromBufferL_1L", CXmlSecSignTester::CXmlSecSign_SignXmlDocumentKeyFromBufferL_1L),

	  ENTRY( "Test-SignXmlDocumentKeyFromBufferL_2L", CXmlSecSignTester::CXmlSecSign_SignXmlDocumentKeyFromBufferL_2L),

	  ENTRY( "Test-SignXmlNodesLL", CXmlSecSignTester::CXmlSecSign_SignXmlNodesLL),

	  ENTRY( "Test-VerifyXmlNodeLL", CXmlSecSignTester::CXmlSecSign_VerifyXmlNodeLL),

	  ENTRY( "Test-VerifyXmlNodeLL_2L", CXmlSecSignTester::CXmlSecSign_VerifyXmlNodeL_2L),

	  ENTRY( "Test-VerifyXmlNodeKeyFromFileLL", CXmlSecSignTester::CXmlSecSign_VerifyXmlNodeKeyFromFileLL),

	  ENTRY( "Test-VerifyXmlNodeKeyFromBufferLL", CXmlSecSignTester::CXmlSecSign_VerifyXmlNodeKeyFromBufferLL),

	  ENTRY( "Test-VerifyXmlDocumentLL", CXmlSecSignTester::CXmlSecSign_VerifyXmlDocumentLL),

	  ENTRY( "Test-VerifyXmlDocumentKeyFromFileLL", CXmlSecSignTester::CXmlSecSign_VerifyXmlDocumentKeyFromFileLL),

	  ENTRY( "Test-VerifyXmlDocumentKeyFromBufferLL", CXmlSecSignTester::CXmlSecSign_VerifyXmlDocumentKeyFromBufferLL),

	  ENTRY( "Test-SetTemplateFromFileL_1L", CXmlSecSignTester::CXmlSecSign_SetTemplateFromFileL_1L),

	  ENTRY( "Test-SetTemplateFromFileL_2L", CXmlSecSignTester::CXmlSecSign_SetTemplateFromFileL_2L),

	  ENTRY( "Test-SetTemplateFromBufferLL", CXmlSecSignTester::CXmlSecSign_SetTemplateFromBufferLL),

	  ENTRY( "Test-SetTemplateLL", CXmlSecSignTester::CXmlSecSign_SetTemplateLL),

	  ENTRY( "Test-CreateTemplateL_1L", CXmlSecSignTester::CXmlSecSign_CreateTemplateL_1L),

	  ENTRY( "Test-CreateTemplateL_2L", CXmlSecSignTester::CXmlSecSign_CreateTemplateL_2L),

	  ENTRY( "Test-GetCurrentTemplateLL", CXmlSecSignTester::CXmlSecSign_GetCurrentTemplateLL),

	  ENTRY( "Test-SetKeyInfoL_1L", CXmlSecSignTester::CXmlSecSign_SetKeyInfoL_1L),

	  ENTRY( "Test-SetKeyInfoL_2L", CXmlSecSignTester::CXmlSecSign_SetKeyInfoL_2L),

	  ENTRY( "Test-SetKeyFromFileLL", CXmlSecSignTester::CXmlSecSign_SetKeyFromFileLL),

	  ENTRY( "Test-SetKeyFromBufferLL", CXmlSecSignTester::CXmlSecSign_SetKeyFromBufferLL),

	  ENTRY( "Test-SetCertFromFileLL", CXmlSecSignTester::CXmlSecSign_SetCertFromFileLL),

	  ENTRY( "Test-SetCertFromBufferLL", CXmlSecSignTester::CXmlSecSign_SetCertFromBufferLL),

	  ENTRY( "Test-AddTrustedCertFromFileLL", CXmlSecSignTester::CXmlSecSign_AddTrustedCertFromFileLL),

	  ENTRY( "Test-AddTrustedCertFromBufferLL", CXmlSecSignTester::CXmlSecSign_AddTrustedCertFromBufferLL),

		};

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }    

HBufC8* CXmlSecSignTester::ReadFileL(const TDesC& aFileName)

{

	// open fs and file

	RFs fs;

	User::LeaveIfError( fs.Connect() );

	CleanupClosePushL(fs);

	RFile file;

	User::LeaveIfError(file.Open(fs, aFileName, EFileStream));

	CleanupClosePushL(file);

	TInt size=0;

	User::LeaveIfError(file.Size(size));

	HBufC8* buf = HBufC8::NewLC(size);

	TPtr8 bufPtr = buf->Des();

	User::LeaveIfError(file.Read(bufPtr));

	CleanupStack::Pop(buf);

	// cleanup

	CleanupStack::PopAndDestroy(&file);

	CleanupStack::PopAndDestroy(&fs);

	return buf;

}

// CONSTRUCTION

//------------------------------------------------------------------------------

void CXmlSecSignTester::CXmlSecSign_NewLL()

    {

    XmlSecPushL();

    CXmlSecSign* sign = CXmlSecSign::NewL();

    CleanupStack::PushL(sign);

    CleanupStack::PopAndDestroy(sign);

    XmlSecPopAndDestroy();

    }

//------------------------------------------------------------------------------

//

void CXmlSecSignTester::CXmlSecSign_NewLCL()

    {

    XmlSecPushL();

    CXmlSecSign* sign = CXmlSecSign::NewLC();

    CleanupStack::PopAndDestroy(sign);

    XmlSecPopAndDestroy();

    }

//------------------------------------------------------------------------------

//

TInt CXmlSecSignTester::CXmlSecSign_SignXmlDocumentLL(CStifItemParser& aItem)

    {

    // key

   	TPtrC p_StrKey;

	  aItem.GetNextString(p_StrKey);

	  HBufC8* p_BufStrKey8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(p_StrKey);

	  CleanupStack::PushL(p_BufStrKey8);

	  TPtrC8 p_StrKey8 = p_BufStrKey8->Des();

    _LIT8(t4,"name");

    XmlSecPushL();

    CXmlSecSign* sign = CXmlSecSign::NewLC();

    //no document

    RXmlEngDocument doc;

    TXmlEngElement el;

    TRAPD(err,el=sign->SignXmlDocumentL(doc));

    LOCAL_ASSERT( err == KErrWrongParameter );

    RXmlEngDOMImplementation domImp;

    domImp.OpenL();

    doc.OpenL(domImp);

    CleanupClosePushL(doc);

    TXmlEngElement elem = doc.CreateElementL(_L8("test"));

    doc.SetDocumentElement(elem);

    sign->SetTemplateL(doc);

    //bad template

    TRAP(err,el=sign->SignXmlDocumentL(doc));

    LOCAL_ASSERT( err == KErrTemplate );

    //no key

    RXmlEngDocument doc2 = sign->CreateTemplateL(CXmlSecSign::ERSAPrivate);

    TRAP(err,el=sign->SignXmlDocumentL(doc));

    LOCAL_ASSERT( err == KErrSign );

    //no key  

    TRAP(err,el=sign->SignXmlDocumentL(doc,FALSE));

    LOCAL_ASSERT( err == KErrSign );

    //ok

    sign->SetKeyFromFileL(p_StrKey8,t4,CXmlSecSign::ERSAPrivate);

    TRAP(err,el=sign->SignXmlDocumentL(doc));

    LOCAL_ASSERT( err == KErrNone );

    LOCAL_ASSERT( !el.Name().Compare(_L8("Signature")));

    el.Remove();

    CleanupStack::PopAndDestroy(&doc);

    domImp.Close();

    CleanupStack::PopAndDestroy(sign);

    XmlSecPopAndDestroy();

    CleanupStack::PopAndDestroy(p_BufStrKey8);

    CloseSTDLIB();

    return KErrNone;

    }

//------------------------------------------------------------------------------

//

TInt CXmlSecSignTester::CXmlSecSign_SignXmlDocumentL_2L( CStifItemParser& aItem )

    {

    //key info

    TPtrC p_KeyInfo;

    aItem.GetNextString(p_KeyInfo);

    HBufC8* p_BufInf8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(p_KeyInfo);

	CleanupStack::PushL(p_BufInf8);

	TPtrC8 p_KeyInfo8 = p_BufInf8->Des();

	XmlSecPushL();

    CXmlSecSign* sign = CXmlSecSign::NewLC();

    TXmlEngElement el;

    RXmlEngDOMImplementation domImp;

    domImp.OpenL();

    RXmlEngDocument doc;

    doc.OpenL(domImp);

    CleanupClosePushL(doc);

    TXmlEngElement elem = doc.CreateElementL(_L8("test"));

    doc.SetDocumentElement(elem);

    sign->SetTemplateL(doc);

    //no key

    RXmlEngDocument doc2 = sign->CreateTemplateL(CXmlSecSign::ERSAPrivate);

    //key not ofund in keystore

    sign->SetKeyInfoL(p_KeyInfo8);

    TRAPD(err,el=sign->SignXmlDocumentL(doc,EFalse));

    LOCAL_ASSERT( err == KErrNotFound);

    CleanupStack::PopAndDestroy(&doc);

    domImp.Close();

    CleanupStack::PopAndDestroy(sign);

    XmlSecPopAndDestroy();

    CleanupStack::PopAndDestroy(p_BufInf8);

    CloseSTDLIB();

    return KErrNone;

    }    

//------------------------------------------------------------------------------

//

TInt CXmlSecSignTester::CXmlSecSign_SignXmlDocumentL_3L(  )

    {

    _LIT8(t4,"name");

    XmlSecPushL();

    CXmlSecSign* sign = CXmlSecSign::NewLC();

    TXmlEngElement el;

    RXmlEngDOMImplementation domImp;

    domImp.OpenL();

    RXmlEngDocument doc;

    doc.OpenL(domImp);

    CleanupClosePushL(doc);

    TXmlEngElement elem = doc.CreateElementL(_L8("test"));

    doc.SetDocumentElement(elem);

    sign->SetTemplateL(doc);

    //no key

    RXmlEngDocument doc2 = sign->CreateTemplateL(CXmlSecSign::ERSAPrivate);

    sign->SetKeyInfoL(t4);

    TRAPD(err,el=sign->SignXmlDocumentL(doc,FALSE));

    LOCAL_ASSERT( err == KErrNone);

    CleanupStack::PopAndDestroy(&doc);

    domImp.Close();

    CleanupStack::PopAndDestroy(sign);

    XmlSecPopAndDestroy();

    CloseSTDLIB();

    return KErrNone;

    }        

//------------------------------------------------------------------------------

//

TInt CXmlSecSignTester::CXmlSecSign_SignXmlDocumentKeyFromFileL_1L(CStifItemParser& aItem)

    {

    TPtrC p_StrKey;

	aItem.GetNextString(p_StrKey);

	HBufC8* p_BufStrKey8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(p_StrKey);

	CleanupStack::PushL( p_BufStrKey8 );

	TPtrC8 p_StrKey8 = p_BufStrKey8->Des();

    _LIT8(t4,"name");

    XmlSecPushL();

    CXmlSecSign* sign = CXmlSecSign::NewLC();

    RXmlEngDocument doc;

    RXmlEngDOMImplementation domImp;

    domImp.OpenL();

    doc.OpenL(domImp);

    CleanupClosePushL(doc);

    TXmlEngElement elem = doc.CreateElementL(_L8("test"));

    doc.SetDocumentElement(elem);

    RXmlEngDocument doc2 = sign->CreateTemplateL(CXmlSecSign::EHMAC,FALSE);

    RXmlEngDocument doc3 = doc2.CloneDocumentL();

    TXmlEngElement el;

    TRAPD(err,el=sign->SignXmlDocumentKeyFromFileL(doc,doc3,p_StrKey8,t4,CXmlSecSign::EHMAC)); 

    doc3.Close();

    LOCAL_ASSERT( err == KErrNone );

    LOCAL_ASSERT( !el.Name().Compare(_L8("Signature")));

    CleanupStack::PopAndDestroy(&doc);

    domImp.Close();

    CleanupStack::PopAndDestroy(sign);

    XmlSecPopAndDestroy();

    CleanupStack::PopAndDestroy(p_BufStrKey8);

    CloseSTDLIB();

    return KErrNone;

    }

//------------------------------------------------------------------------------

//

TInt CXmlSecSignTester::CXmlSecSign_SignXmlDocumentKeyFromFileL_2L(CStifItemParser& aItem)

    {

    TPtrC p_StrKey;

	aItem.GetNextString(p_StrKey);

	HBufC8* p_BufStrKey8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(p_StrKey);

	CleanupStack::PushL( p_BufStrKey8 );

	TPtrC8 p_StrKey8 = p_BufStrKey8->Des();

    _LIT8(t4,"name");

    XmlSecPushL();

    CXmlSecSign* sign = CXmlSecSign::NewLC();

    RXmlEngDocument doc;

    TXmlEngElement el;

    RXmlEngDOMImplementation domImp;

    domImp.OpenL();

    doc.OpenL(domImp);

    CleanupClosePushL(doc);

    TXmlEngElement elem = doc.CreateElementL(_L8("test"));

    doc.SetDocumentElement(elem);

    RXmlEngDocument doc2 = sign->CreateTemplateL(CXmlSecSign::EHMAC,FALSE);

    TRAPD(err,el=sign->SignXmlDocumentKeyFromFileL(doc,p_StrKey8,t4,CXmlSecSign::EHMAC)); 

    LOCAL_ASSERT( err == KErrNone );

    LOCAL_ASSERT( !el.Name().Compare(_L8("Signature")));

    CleanupStack::PopAndDestroy(&doc);

    domImp.Close();

    CleanupStack::PopAndDestroy(sign);

    XmlSecPopAndDestroy();

    CleanupStack::PopAndDestroy(p_BufStrKey8);

    CloseSTDLIB();

    return KErrNone;

    }

//------------------------------------------------------------------------------

//

TInt CXmlSecSignTester::CXmlSecSign_SignXmlDocumentKeyFromBufferL_1L(CStifItemParser& aItem)

    {

    TPtrC p_StrKey;

    aItem.GetNextString(p_StrKey);

	HBufC8* p_BufStrKey8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(p_StrKey);

	CleanupStack::PushL( p_BufStrKey8 );

    _LIT8(t4,"name");

    XmlSecPushL();

    CXmlSecSign* sign = CXmlSecSign::NewLC();

    RXmlEngDocument doc;

    TXmlEngElement el;

    RXmlEngDOMImplementation domImp;

    domImp.OpenL();

    doc.OpenL(domImp);

    CleanupClosePushL(doc);

    TXmlEngElement elem = doc.CreateElementL(_L8("test"));

    doc.SetDocumentElement(elem);

    RXmlEngDocument doc2 = sign->CreateTemplateL(CXmlSecSign::EHMAC,FALSE);

    RXmlEngDocument doc3 = doc2.CloneDocumentL();

    TRAPD(err,el=sign->SignXmlDocumentKeyFromBufferL(doc,doc3,*p_BufStrKey8,t4,CXmlSecSign::EHMAC)); 

    doc3.Close();

    LOCAL_ASSERT( err == KErrNone );

    LOCAL_ASSERT( !el.Name().Compare(_L8("Signature")));

    CleanupStack::PopAndDestroy(&doc);

    domImp.Close();

    CleanupStack::PopAndDestroy(sign);

    XmlSecPopAndDestroy();

    CleanupStack::PopAndDestroy(p_BufStrKey8);

    CloseSTDLIB();

    return KErrNone;

    }

//------------------------------------------------------------------------------

//

TInt CXmlSecSignTester::CXmlSecSign_SignXmlDocumentKeyFromBufferL_2L(CStifItemParser& aItem)

    {

    _LIT8(t4,"name");

    TPtrC p_StrKey;

	aItem.GetNextString(p_StrKey);

	HBufC8* p_BufStrKey8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(p_StrKey);

	CleanupStack::PushL( p_BufStrKey8 );

    XmlSecPushL();

    CXmlSecSign* sign = CXmlSecSign::NewLC();

    RXmlEngDocument doc;

    TXmlEngElement el;

    RXmlEngDOMImplementation domImp;

    domImp.OpenL();

    doc.OpenL(domImp);

    CleanupClosePushL(doc);

    TXmlEngElement elem = doc.CreateElementL(_L8("test"));

    doc.SetDocumentElement(elem);

    RXmlEngDocument doc2 = sign->CreateTemplateL(CXmlSecSign::EHMAC,FALSE);

    TRAPD(err,el=sign->SignXmlDocumentKeyFromBufferL(doc,*p_BufStrKey8,t4,CXmlSecSign::EHMAC));  

    LOCAL_ASSERT( err == KErrNone );

    LOCAL_ASSERT( !el.Name().Compare(_L8("Signature")));

    CleanupStack::PopAndDestroy(&doc);

    domImp.Close();

    CleanupStack::PopAndDestroy(sign);

    XmlSecPopAndDestroy();

    CleanupStack::PopAndDestroy(p_BufStrKey8);

    CloseSTDLIB();

    return KErrNone;

    }

//------------------------------------------------------------------------------

//    

TInt CXmlSecSignTester::CXmlSecSign_SignXmlNodesLL(CStifItemParser& aItem)

    {

    _LIT8(t4,"forsignnodesname");

    TPtrC p_StrKey;

	aItem.GetNextString(p_StrKey);

	HBufC8* p_BufStrKey8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(p_StrKey);

	CleanupStack::PushL( p_BufStrKey8 );

	TPtrC8 p_StrKey8 = p_BufStrKey8->Des();

    XmlSecPushL();

	CXmlSecSign* sign = CXmlSecSign::NewLC();

    //zero TXmlEngElements

    RXmlEngDocument doc;

    RArray<TXmlEngElement> arrayelem;

    TXmlEngElement el;

    TRAPD(err,el=sign->SignXmlNodesL(arrayelem));

    LOCAL_ASSERT( err == KErrWrongParameter );

    RXmlEngDOMImplementation domImp;

    domImp.OpenL();

    doc.OpenL(domImp);

    CleanupClosePushL(doc);

    TXmlEngElement elem = doc.CreateElementL(_L8("test"));

    doc.SetDocumentElement(elem);

    arrayelem.Append(elem);

    TXmlEngElement elem2 = doc.CreateElementL(_L8("test2"));

    //doc.SetDocumentElement(elem2);

    arrayelem.Append(elem2);

    RXmlEngDocument doc2 = sign->CreateTemplateL(CXmlSecSign::EHMAC,FALSE);

    //ok

    sign->SetKeyFromFileL(p_StrKey8,t4,CXmlSecSign::EHMAC);

    TRAP(err,el=sign->SignXmlNodesL(arrayelem));

    LOCAL_ASSERT( err == KErrNone );

    LOCAL_ASSERT( !el.Name().Compare(_L8("Signature")));

    arrayelem.Close();

    CleanupStack::PopAndDestroy(&doc);

    domImp.Close();

    CleanupStack::PopAndDestroy(sign);

    XmlSecPopAndDestroy();

    CleanupStack::PopAndDestroy(p_BufStrKey8);

    CloseSTDLIB();

    return KErrNone;

    }

//------------------------------------------------------------------------------

//

TInt CXmlSecSignTester::CXmlSecSign_VerifyXmlNodeLL( CStifItemParser& aItem )

    {

    _LIT8(t4,"name");

    TPtrC p_StrKey;

	aItem.GetNextString(p_StrKey);

	HBufC8* p_BufStrKey8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(p_StrKey);

	CleanupStack::PushL( p_BufStrKey8 );

	TPtrC8 p_StrKey8 = p_BufStrKey8->Des();

    TBool ver=EFalse;

    XmlSecPushL();

    CXmlSecSign* sign = CXmlSecSign::NewLC();

    RXmlEngDocument doc;

    TXmlEngElement el;

    RXmlEngDOMImplementation domImp;

    domImp.OpenL();

    doc.OpenL(domImp);

    CleanupClosePushL(doc);

    TXmlEngElement elem = doc.CreateElementL(_L8("test"));

    doc.SetDocumentElement(elem);

    RXmlEngDocument doc2 = sign->CreateTemplateL(CXmlSecSign::EHMAC,FALSE);

    el=sign->SignXmlDocumentKeyFromFileL(doc,p_StrKey8,t4,CXmlSecSign::EHMAC); 

    //no signature in doc     

    TRAPD(err,ver=sign->VerifyXmlNodeL(el));

    LOCAL_ASSERT(!ver); 

    doc.DocumentElement().AppendChildL(el);

    //ok

    ver=sign->VerifyXmlNodeL(el);

    LOCAL_ASSERT(ver); 

    TRAP(err,ver=sign->VerifyXmlNodeL(el,CXmlSecSign::ERootCertChain));

    LOCAL_ASSERT( err == KErrVerify );

    CleanupStack::PopAndDestroy(&doc);

    domImp.Close();

    CleanupStack::PopAndDestroy(sign);