--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/test/tpadding/tpaddingPKCS7.cpp Thu Sep 10 14:01:51 2009 +0300
@@ -0,0 +1,352 @@
+/*
+* 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
+ }
+