/*

 * Copyright (c) 2004-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 <random.h>

 #include <padding.h>

 #include <securityerr.h>

 #include "tpaddingPKCS7.h"

 #include <cryptopanic.h>

 static void GenerateInput(TInt aBytes, TPtr8& in)

  	{

  	for (TInt j = 0; j < aBytes; j++)

  		{

  		TInt text('a'+j%25);

  		in.Append(text);

  		}

  	}

 CTestPadPKCS7::CTestPadPKCS7()

 	{

 	SetTestStepName(KPadPKCS7);

 	}

 CTestPadPKCS7::~CTestPadPKCS7()

 	{

 	}

 TVerdict CTestPadPKCS7::doTestStepL()

 	{

 	SetTestStepResult(EPass);

 	__UHEAP_MARK;

 	INFO_PRINTF1(_L("Test of PKCS7  padding"));

 	for (TInt i = 1; i < 255; i++)

 		{

 		TestPKCS7Padding(i);

 		}

 	__UHEAP_MARKEND;

 	return TestStepResult();

 	}

 void CTestPadPKCS7::TestPKCS7Padding(TInt aBlockSize)

 	{

    	CPaddingPKCS7 *padding = CPaddingPKCS7::NewLC(aBlockSize);

 	// Starts with zero input size(total block data is filled/padded with block size) 

 	for (TInt i = 0 ; i <= aBlockSize; i++)

 		{

 		HBufC8 *padInData = HBufC8::NewLC(i);

 		HBufC8 *padOutData = HBufC8::NewLC(i+(aBlockSize-i%aBlockSize));

 		TPtr8 in(padInData->Des());

 		TPtr8 out(padOutData->Des());

 		GenerateInput(i, in);

 		TRAPD(err, padding->PadL(in, out));

 		TEST(err == KErrNone);

 		TInt totalLength = out.Length();

 		TUint paddingLength = aBlockSize - in.Length()%aBlockSize;

 		// Test that the total length is a multiple of blockSize

 		TEST((totalLength % aBlockSize) == 0);

 		// Test that the padding bytes are equal in value to the paddingLength,

 		// ie, if padding length is 5 the 5 last octets in the out array should be 0x05

 		for (TInt j = paddingLength; j > 0 ; j--)

 			{

 			TEST(out[out.Length()-j] == paddingLength);

 			}

 		// Test that the data has not been corrupted

 		TEST(in == out.Left(out.Length() - paddingLength));

 		CleanupStack::PopAndDestroy(2, padInData); // padInData, padOutData

 		}

 	CleanupStack::PopAndDestroy(padding);

 	}

 CTestUnpadPKCS7::CTestUnpadPKCS7()

 	{

    	SetTestStepName(KUnpadPKCS7);

 	}

 CTestUnpadPKCS7::~CTestUnpadPKCS7()

 	{

 	}

 TVerdict CTestUnpadPKCS7::doTestStepL()

 	{

 	SetTestStepResult(EPass);

 	__UHEAP_MARK;

 	INFO_PRINTF1(_L("Test of PKCS7 unpadding"));

 	for (TInt i = 1; i < 255; i++)

 		{

 		TestPKCS7Unpadding(i);

 		}

 	__UHEAP_MARKEND;

 	return TestStepResult();

 	}

 void CTestUnpadPKCS7::TestPKCS7Unpadding(TInt aBlockSize)

 	{

 	CPaddingPKCS7 *padding = CPaddingPKCS7::NewLC(aBlockSize);

 	// Input must be < aBlockSize otherwise this wouldn't be 

 	// a padded block

 	for (TInt i = 0 ; i < aBlockSize; i++)

 		{

 		// Input to un-padding should always be an entire block

 		// for correctly data.

 		HBufC8 *padInData = HBufC8::NewLC(aBlockSize);

 		HBufC8 *padOutData = HBufC8::NewLC(i);

 		HBufC8 *padCompareData = HBufC8::NewLC(i);

 		TPtr8 in(padInData->Des());

 		TPtr8 out(padOutData->Des());

 		TPtr8 comp(padCompareData->Des());

 		GenerateInput(i, in);

 		comp.Copy(in);		

 		in.SetLength(aBlockSize);

 		TInt paddingBytes = aBlockSize - (i % aBlockSize);

 		for (TInt j = 1; j <= paddingBytes; j++)

 			{

 			in[in.Length()-j] = (TUint8)paddingBytes;

 			}

 		TRAPD(err, padding->UnPadL(in, out));

 		if (err != KErrNone)

 			{

 			INFO_PRINTF3(_L("The Error returned for block size %d is %d"), aBlockSize,err);

 			}

 		TEST(err == KErrNone); // Verify UnPadL leave code 

 		TEST(out == comp); // Verify  UnPadL output data with expected data

 		CleanupStack::PopAndDestroy(3, padInData); // padInData, padOutData, padCompareData

 		}

 	CleanupStack::PopAndDestroy(padding);

 	}

 CTestUnpadCorruptPKCS7::CTestUnpadCorruptPKCS7()

 	{

 	SetTestStepName(KUnpadCorruptPKCS7);

 	}

 CTestUnpadCorruptPKCS7::~CTestUnpadCorruptPKCS7()

 	{

 	}

 TVerdict CTestUnpadCorruptPKCS7::doTestStepL()

  	{

  	SetTestStepResult(EPass);

  	__UHEAP_MARK;

  	TInt blockSize;

  	TInt textSize;

  	TInt paddingNum = 0;

  	if (GetIntFromConfig(ConfigSection(), _L("blocksize"), blockSize))

  		{

  		if (GetIntFromConfig(ConfigSection(), _L("textsize"), textSize))

  			{

  			if (GetIntFromConfig(ConfigSection(), _L("paddingbyte"), paddingNum))

  				{

  				INFO_PRINTF1(_L("Test of PKCS7 unpadding with corrupt data"));

  				TUint8 paddingByte = Min(paddingNum, 255);

    				TestCorruptPKCS7Unpadding(blockSize, textSize, paddingByte);	  					

  				}				

  			else

  				{

  				ERR_PRINTF1(_L("Missing parameter - paddingbyte"));

  				}

  			}

  		else

  			{

  			ERR_PRINTF1(_L("Missing parameter - textsize"));

  			}

  		}

  	else

 		{

  		ERR_PRINTF1(_L("Missing parameter - blocksize"));

  		}

  	__UHEAP_MARKEND;

  	return TestStepResult();

  	}

 void CTestUnpadCorruptPKCS7::TestCorruptPKCS7Unpadding(TInt aBlockSize, TInt aTextSize, TUint8 aPaddingByte)

 	{

  	CPaddingPKCS7 *padding = CPaddingPKCS7::NewLC(aBlockSize);

  	TInt paddingBytes = (aBlockSize - aTextSize % aBlockSize);

 	HBufC8 *padInData = HBufC8::NewLC(aTextSize + paddingBytes);

  	HBufC8 *padOutData = HBufC8::NewLC(aTextSize);

  	TPtr8 in(padInData->Des());

  	TPtr8 out(padOutData->Des());

  	GenerateInput(aTextSize, in);

  	in.SetLength(in.Length() + paddingBytes);

  	for (TInt j = 1; j <= paddingBytes; j++)

  		{

  		in[in.Length()-j] = (TUint8) aPaddingByte;

  		}

  	TRAPD(err, padding->UnPadL(in, out));

  	if ( err == KErrInvalidPadding )

 		{

   		INFO_PRINTF2(_L("The PKCS7 unpadding UnPadL method returned error is %d"), err);

   		TEST(err == KErrInvalidPadding);

   		SetTestStepResult(EPass);

   		}

 	else if ( err == KErrNone )

 		{

 		TEST(err == KErrNone);

 		}

 	CleanupStack::PopAndDestroy(3, padding); // padding, padInData, padOutData

 	}

 CTestPaddingCorruptPKCS7::CTestPaddingCorruptPKCS7()

 	{

 	SetTestStepName(KPaddingCorruptPKCS7);

 	}

 CTestPaddingCorruptPKCS7::~CTestPaddingCorruptPKCS7()

 	{

 	}

 TVerdict CTestPaddingCorruptPKCS7::doTestStepL()

  	{

  	SetTestStepResult(EPass);

  	__UHEAP_MARK;

  	TInt blockSize;

  	TInt textSize;

  	if (GetIntFromConfig(ConfigSection(), _L("blocksize"), blockSize))

  		{

  		if (GetIntFromConfig(ConfigSection(), _L("textsize"), textSize))

  			{

  			INFO_PRINTF1(_L("Test of PKCS7 unpadding with corrupt data"));

    			TestCorruptPKCS7padding(blockSize, textSize);	  					

  			}

  		else

  			{

  			ERR_PRINTF1(_L("Missing parameter - textsize"));

  			}

  		}

  	else

 		{

  		ERR_PRINTF1(_L("Missing parameter - blocksize"));

  		}

  	__UHEAP_MARKEND;

  	return TestStepResult();

  	}

 void CTestPaddingCorruptPKCS7::TestCorruptPKCS7padding(TInt aBlockSize, TInt aTextSize)

 	{

 	CPaddingPKCS7 *padding = CPaddingPKCS7::NewLC(aBlockSize);

 	TInt paddingBytes = 0;

 	//Divide by 0 is undefined.

 	if(aBlockSize != 0)

 		{

 		paddingBytes = aBlockSize - (aTextSize % aBlockSize);

 		}

  	HBufC8 *padOutData = HBufC8::NewLC(aTextSize + paddingBytes);

  	HBufC8 *padInData = HBufC8::NewLC(aTextSize);

  	TPtr8 in(padInData->Des());

  	TPtr8 out(padOutData->Des());

  	GenerateInput(aTextSize, in);

  	TRAPD(err, padding->PadL(in, out));

 	INFO_PRINTF2(_L("The PKCS7 padding PadL method returned error is %d"), err);

 	//check expected result

 	TPtrC expectedContent;

  	if (GetStringFromConfig(ConfigSection(), _L("case"), expectedContent))

  		{

  		if(expectedContent.Compare(_L("InvalidPadding")) ==0)

  			{

  			TEST(err == KErrInvalidPadding);

  			}

  		else if(expectedContent.Compare(_L("Valid")) ==0)

  			{

  			TEST(err == KErrNone);

  			}

  		else if(expectedContent.Compare(_L("CorruptBlockSize")) ==0)

  			{

  			TEST(err == KErrArgument);

  			}

  		}

  	//skip the checking on padded data if padding is unsuccessful(no padding is done), 

  	//otherwise the erroneous operation on output descriptor will panic.

  	if(err != KErrNone)

  		{

  		CleanupStack::PopAndDestroy(3, padding);

  		return;

  		}

 	TInt totalLength = out.Length();

 	TInt inLength = in.Length();

 	TUint paddingLength = 0;

 	//Divide by 0 is undefined.

 	if(aBlockSize != 0)

 		{

 		paddingLength = aBlockSize - inLength%aBlockSize;

 		// Test that the total length is a multiple of blockSize

 		TEST((totalLength % aBlockSize) == 0);

 		}			

  	// Test that the padding bytes are equal in value to the paddingLength,

 	// ie, if padding length is 5 the 5 last octets in the out array should be 0x05

 	for (TInt j = paddingLength; j > 0 ; j--)

 		{

 		TEST(out[out.Length()-j] == paddingLength);

 		}

  	// Test that the data has not been corrupted

 	TEST(in == out.Left(out.Length() - paddingLength));

  	CleanupStack::PopAndDestroy(3, padding); // padInData, padOutData, padCompareData, padding

 	}