1 /*

     2 * Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include <padding.h>

    20 #include "tpaddingSSLv3.h"

    21 #include <securityerr.h>

    22 

    23 CTestPadSSLv3::CTestPadSSLv3()

    24 	{

    25    SetTestStepName(KPadSSLv3);

    26 	}

    27 

    28 CTestPadSSLv3::~CTestPadSSLv3()

    29 	{

    30 	}

    31 

    32 TVerdict CTestPadSSLv3::doTestStepL()

    33 	{

    34     SetTestStepResult(EPass);

    35     __UHEAP_MARK;

    36 

    37 	INFO_PRINTF1(_L("Test of padding with type SSLv3"));

    38 

    39 	TInt blockSize;

    40     TInt textSize;

    41 

    42 	if (!GetStringFromConfig(ConfigSection(), _L("TestCaseName"), iTestCaseName))

    43  		{

    44  		INFO_PRINTF1(_L("Could not find TestCaseName in tpadSSLv3.ini"));

    45       	return EFail;

    46  		}

    47    

    48     if (!GetIntFromConfig(ConfigSection(), _L("BlockSize"), blockSize))

    49  		{

    50  		INFO_PRINTF1(_L("Could not find blocksize in tpadSSLv3.ini"));

    51       	return EFail;

    52  		}

    53  		

    54   	if(iTestCaseName.Compare(_L("CipherAES_CBC"))==0 || iTestCaseName.Compare(_L("CipherDES_CBC"))==0 || iTestCaseName.Compare(_L("CipherRC2_CBC"))==0)

    55  		{

    56  		TestSSLv3Padding(blockSize);

    57  		}

    58  	else

    59  		{

    60  		if (!GetIntFromConfig(ConfigSection(), _L("TextSize"), textSize))

    61    			{

    62       		INFO_PRINTF1(_L("Could not find TextSize in tpadSSLv3.ini"));

    63       		return EFail;

    64    			}

    65    		if (!GetStringFromConfig(ConfigSection(), _L("ExpectedResult"), iExpectedResult))

    66  			{

    67  			INFO_PRINTF1(_L("Could not find TextSize in tpadSSLv3.ini"));

    68       		return EFail;

    69  			}

    70  		TestSSLv3CorruptPadding(blockSize, textSize);	

    71  		}

    72 	__UHEAP_MARKEND;

    73 	return TestStepResult();

    74 	}

    75 

    76 void CTestPadSSLv3::TestSSLv3Padding(TInt aBlockSize)

    77 	{

    78 	CPaddingSSLv3 *padding = CPaddingSSLv3::NewLC(aBlockSize);

    79 

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

    81 		{

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

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

    84 		TPtr8 in(padInData->Des());

    85 		TPtr8 out(padOutData->Des());

    86 		TInt j;

    87       

    88 		for (j = 0; j < i; j++)

    89 			{

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

    91 			in.Append(text);

    92 			}

    93 		TRAPD(err, padding->DoPadL(in, out));

    94 		INFO_PRINTF3(_L("The error returned for input size %d is %d"), i, err);

    95 		TEST(err == KErrNone);

    96 

    97 		TInt totalLength = out.Length();

    98 		TInt paddingLength = aBlockSize - in.Length()%aBlockSize;

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

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

   101       

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

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

   104 		// This is according to RFC2246 (TLS1.0). The padding content in SSL3.0 is arbitrary.

   105 		for (TInt i = paddingLength; i > 0 ; i--)

   106 			{

   107 			TEST(out[out.Length()-i] == paddingLength - 1);

   108 			}

   109 

   110 		// Test that the data has not been corrupted

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

   112       

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

   114 		}

   115 	CleanupStack::PopAndDestroy(padding);

   116 	}

   117 

   118 void CTestPadSSLv3::TestSSLv3CorruptPadding(TInt aBlockSize, TInt aTextSize)

   119 	{

   120 	CPaddingSSLv3 *padding = CPaddingSSLv3::NewLC(aBlockSize);

   121 

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

   123 	TInt paddingBytes = 0;

   124 	//If BlockSize is 0, Divide by 0 is undefined

   125 	if(aBlockSize != 0)

   126 		{

   127 		paddingBytes = (aBlockSize - aTextSize % aBlockSize);

   128 		}

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

   130 	TPtr8 in(padInData->Des());

   131 	TPtr8 out(padOutData->Des());

   132 	TInt j;

   133       

   134 	for (j = 0; j < aTextSize; j++)

   135    		{

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

   137 	 	in.Append(text);

   138       	}

   139 	TRAPD(err, padding->DoPadL(in, out));

   140   

   141 	if(iExpectedResult.Compare(_L("CorruptBlockSize")) ==0)

   142  		{

   143  		TEST(err == KErrArgument);

   144  		}

   145 	else if(iExpectedResult.Compare(_L("Valid")) ==0)

   146  		{

   147  		TEST(err == KErrNone);

   148  		}

   149 	else if(iExpectedResult.Compare(_L("InvalidPadding")) == 0)

   150 		{

   151 		TEST(err == KErrInvalidPadding);

   152 		}	

   153 

   154 	TInt totalLength = out.Length();

   155 	TInt paddingLength = 0;

   156 	//If BlockSize is 0, Divide by 0 is undefined

   157 	if(aBlockSize != 0)

   158 		{

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

   160 		}

   161 	//If BlockSize is 0, Divide by 0 is undefined

   162 	if(aBlockSize != 0)

   163 		{

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

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

   166 		}

   167       

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

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

   170 	// This is according to RFC2246 (TLS1.0). The padding content in SSL3.0 is arbitrary.

   171 	for (TInt i = paddingLength; i > 0 ; i--)

   172 		{

   173 	 	TEST(out[out.Length()-i] == paddingLength - 1);

   174       	}

   175 

   176 	if(aBlockSize > 0)

   177    		{

   178    		// Test that the data has not been corrupted

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

   180    		}

   181           

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

   183 	CleanupStack::PopAndDestroy(padding);

   184 	}

   185 

   186 CTestUnpadSSLv3::CTestUnpadSSLv3()

   187 	{

   188 	SetTestStepName(KUnpadSSLv3);

   189 	}

   190 

   191 CTestUnpadSSLv3::~CTestUnpadSSLv3()

   192 	{

   193 	}

   194 

   195 TVerdict CTestUnpadSSLv3::doTestStepL()

   196 	{

   197 	SetTestStepResult(EPass);

   198 	__UHEAP_MARK;

   199 

   200 	INFO_PRINTF1(_L("Test of unpadding with type SSLv3"));

   201 

   202 	TInt blockSize;

   203 	TInt textSize;

   204 	if (!GetIntFromConfig(ConfigSection(), _L("BlockSize"), blockSize))

   205  		{

   206  		INFO_PRINTF1(_L("Could not find blocksize in tpadSSLv3.ini"));

   207       	return EFail;

   208  		}

   209  		

   210  	if (!GetStringFromConfig(ConfigSection(), _L("TestCaseName"), iTestCaseName))

   211  		{

   212  		INFO_PRINTF1(_L("Could not find TestCaseName in tpadSSLv3.ini"));

   213       	return EFail;

   214  		}	

   215  	

   216  	if(iTestCaseName.Compare(_L("CipherAES_CBC"))==0 || iTestCaseName.Compare(_L("CipherDES_CBC"))==0 || iTestCaseName.Compare(_L("CipherRC2_CBC"))==0)

   217  		{

   218  		TestSSLv3Unpadding(blockSize);

   219  		}

   220  	else

   221  		{

   222  		if (!GetIntFromConfig(ConfigSection(), _L("TextSize"), textSize))

   223    			{

   224       		INFO_PRINTF1(_L("Could not find TextSize in tpadSSLv3.ini"));

   225       		return EFail;

   226    			}

   227    			

   228    		if (!GetStringFromConfig(ConfigSection(), _L("ExpectedResult"), iExpectedResult))

   229  			{

   230  			INFO_PRINTF1(_L("Could not find TextSize in tpadSSLv3.ini"));

   231       		return EFail;

   232  			}

   233  		TestSSLv3CorruptUnpadding(blockSize, textSize);	

   234  		}

   235 

   236 	__UHEAP_MARKEND;

   237 	return TestStepResult();

   238 	}

   239 

   240 void CTestUnpadSSLv3::TestSSLv3Unpadding(TInt aBlockSize)

   241 	{

   242 	CPaddingSSLv3 *padding = CPaddingSSLv3::NewLC(aBlockSize);

   243 

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

   245 		{

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

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

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

   249 		TPtr8 in(padInData->Des());

   250 		TPtr8 out(padOutData->Des());

   251 		TPtr8 comp(padCompareData->Des());

   252 		TInt j;

   253       

   254 		// build up a padded string here

   255 		for (j = 0; j < i; j++)

   256 			{

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

   258 			in.Append(text);

   259 			}

   260 		comp.Append(in);

   261       

   262 		TInt paddingBytes = aBlockSize - i%aBlockSize;

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

   264 

   265 		// pad with arbitary data, to test unpadding of SSL 3.0 padded data

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

   267 		for (j = 2; j <= paddingBytes; j++)

   268 			{

   269 			in[in.Length()-j] = (TUint8) ('a' + j%25);

   270 			}

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

   272 		INFO_PRINTF3(_L("The error returned for input size %d is %d"), i, err);

   273 		TEST(err == KErrNone);

   274 

   275 		// test if the unpadding was correct.

   276 		TEST(out == comp);

   277       

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

   279 		}

   280 	CleanupStack::PopAndDestroy(padding);

   281 	}

   282 

   283 void CTestUnpadSSLv3::TestSSLv3CorruptUnpadding(TInt aBlockSize, TInt aTextSize)

   284 	{

   285 	CPaddingSSLv3 *padding = CPaddingSSLv3::NewLC(aBlockSize);

   286    

   287 	TInt paddingBytes = 0;

   288 	//If BlockSize is 0, Divide by 0 is undefined

   289 	if(aBlockSize != 0)

   290    		{

   291    		paddingBytes = aBlockSize - aTextSize%aBlockSize;

   292    		}

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

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

   295 	HBufC8 *padCompareData = HBufC8::NewLC(aTextSize);

   296 	TPtr8 in(padInData->Des());

   297 	TPtr8 out(padOutData->Des());

   298 	TPtr8 comp(padCompareData->Des());

   299 	TInt j;

   300    

   301 	if(in.Length() < aTextSize)

   302 		{

   303 		for (j = 0; j < in.Length(); j++)

   304    			{

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

   306 	 		in.Append(text);

   307       		}

   308 		}

   309 	else

   310 		{

   311 		// build up a padded string here

   312 		for (j = 0; j < aTextSize; j++)

   313    			{

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

   315 	 		in.Append(text);

   316       		}

   317 		}

   318 	comp.Append(in);

   319    

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

   321 

   322 	if(aBlockSize > 0)

   323   		{

   324    		// pad with arbitary data, to test unpadding of SSL 3.0 padded data

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

   326    		for (j = 2; j <= paddingBytes; j++)

   327    			{

   328 	 		in[in.Length()-j] = (TUint8) ('a' + j%25);

   329       		}

   330   		 }  

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

   332    

   333     if(iExpectedResult.Compare(_L("CorruptBlockSize")) ==0)

   334  		{

   335  		TEST(err == KErrArgument);

   336  		}

   337 	else if(iExpectedResult.Compare(_L("Valid")) ==0)

   338  		{

   339  		TEST(err == KErrNone);

   340  		}

   341 	else if(iExpectedResult.Compare(_L("InvalidPadding")) == 0)

   342 		{

   343 		TEST(err == KErrInvalidPadding);

   344 		}

   345 	// test if the unpadding was correct.

   346 	TEST(out == comp);

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

   348 	CleanupStack::PopAndDestroy(padding);

   349 	}