MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/security/crypto/weakcrypto/test/tasymmetric/trsaparams.cpp
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     1 /*

     2 * Copyright (c) 1998-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 * tdsasignfb.cpp

    16 *

    17 */

    18 

    19 

    20 #include "t_input.h"

    21 #include "t_output.h"

    22 #include <asymmetric.h>

    23 #include "tvectorutils.h"

    24 #include "trsaparams.h"

    25 

    26 _LIT8(KModStart, "<modulus>");

    27 _LIT8(KModEnd, "</modulus>");

    28 _LIT8(KPubExpStart, "<publicExponent>");

    29 _LIT8(KPubExpEnd, "</publicExponent>");

    30 _LIT8(KPrivExpStart, "<privateExponent>");

    31 _LIT8(KPrivExpEnd, "</privateExponent>");

    32 _LIT8(KPStart, "<P>");

    33 _LIT8(KPEnd, "</P>");

    34 _LIT8(KQStart, "<Q>");

    35 _LIT8(KQEnd, "</Q>");

    36 _LIT8(KdPStart, "<dP>");

    37 _LIT8(KdPEnd, "</dP>");

    38 _LIT8(KdQStart, "<dQ>");

    39 _LIT8(KdQEnd, "</dQ>");

    40 _LIT8(KqInvStart, "<qInv>");

    41 _LIT8(KqInvEnd, "</qInv>");

    42 _LIT8(KReturnCodeStart, "<return>");

    43 _LIT8(KReturnCodeEnd, "</return>");

    44 _LIT8(KErrArgumentString, "KErrArgument");

    45 

    46 CTestAction* CRSATestPublicKey::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

    47 	const TTestActionSpec& aTestActionSpec)

    48 	{

    49 	CTestAction* self = CRSATestPublicKey::NewLC(aFs, aConsole,

    50 		aOut, aTestActionSpec);

    51 	CleanupStack::Pop();

    52 	return self;

    53 	}

    54 

    55 CTestAction* CRSATestPublicKey::NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

    56 	const TTestActionSpec& aTestActionSpec)

    57 	{

    58 	CRSATestPublicKey* self = new(ELeave) CRSATestPublicKey(aFs, aConsole, aOut);

    59 	CleanupStack::PushL(self);

    60 	self->ConstructL(aTestActionSpec);

    61 	return self;

    62 	}

    63 

    64 CRSATestPublicKey::~CRSATestPublicKey()

    65 	{

    66 	delete iBody;

    67 	}

    68 

    69 CRSATestPublicKey::CRSATestPublicKey(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

    70 	: CTestAction(aConsole, aOut), iFs(aFs)

    71 	{

    72 	}

    73 

    74 void CRSATestPublicKey::ConstructL(const TTestActionSpec& aTestActionSpec)

    75 	{

    76 	CTestAction::ConstructL(aTestActionSpec);

    77 	iBody = HBufC8::NewL(aTestActionSpec.iActionBody.Length());

    78 	iBody->Des().Copy(aTestActionSpec.iActionBody);

    79 

    80 	iExpectedReturnValue = KErrNone;

    81 	TPtrC8 returnValue = Input::ParseElement(aTestActionSpec.iActionResult, KReturnCodeStart, KReturnCodeEnd);

    82 	if(returnValue.Compare(KErrArgumentString) == 0)

    83 		{

    84 		iExpectedReturnValue = KErrArgument;

    85 		}

    86 

    87 	}

    88 

    89 void CRSATestPublicKey::DoPerformPrerequisite(TRequestStatus& aStatus)

    90 	{

    91 	TRequestStatus* status = &aStatus;

    92 	User::RequestComplete(status, KErrNone);

    93 	iActionState = CTestAction::EAction;

    94 	}

    95 

    96 void CRSATestPublicKey::DoPerformPostrequisite(TRequestStatus& aStatus)

    97 	{

    98 	TRequestStatus* status = &aStatus;

    99 

   100 	iFinished = ETrue;

   101 	User::RequestComplete(status, KErrNone);

   102 	}

   103 

   104 void CRSATestPublicKey::DoReportAction(void)

   105 	{

   106 	}

   107 

   108 void CRSATestPublicKey::DoCheckResult(TInt)

   109 	{

   110 	if (iResult)

   111 		iConsole.Printf(_L("."));

   112 	else

   113 		iConsole.Printf(_L("X"));

   114 	}

   115 

   116 void CRSATestPublicKey::PerformAction(TRequestStatus& aStatus)

   117 	{

   118 	__UHEAP_MARK;

   119 	TRequestStatus* status = &aStatus;

   120 	iResult = EFalse;

   121 

   122 	TPtrC8 modIn = Input::ParseElement(*iBody, KModStart, KModEnd);

   123     RInteger mod = VectorUtils::ParseIntegerL(modIn);

   124 	CleanupStack::PushL(mod);

   125 

   126 	TPtrC8 expIn = Input::ParseElement(*iBody, KPubExpStart, KPubExpEnd);

   127     RInteger exp = VectorUtils::ParseIntegerL(expIn);

   128 	CleanupStack::PushL(exp);

   129 

   130 

   131 	CRSAPublicKey* key = NULL;

   132 	TRAPD(err, key = CRSAPublicKey::NewL(mod, exp));

   133 	if(err == iExpectedReturnValue)

   134 		{

   135 		iResult=ETrue;

   136 		}

   137 	else

   138 		{

   139 		iOut.writeString(_L("CRSAPublicKey construction did not return expected result\n"));

   140 		}

   141 	if(err != KErrNone)

   142 		{

   143 		CleanupStack::PopAndDestroy(2);

   144 		}

   145 	else

   146 		{

   147 		CleanupStack::PushL(key);

   148 		CleanupStack::PopAndDestroy(3);	

   149 		}

   150 		

   151 	User::RequestComplete(status, KErrNone);

   152 	iActionState = CTestAction::EPostrequisite;

   153 	__UHEAP_MARKEND;

   154 	}

   155 

   156 

   157 CTestAction* CRSATestPrivateKey::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

   158 	const TTestActionSpec& aTestActionSpec)

   159 	{

   160 	CTestAction* self = CRSATestPrivateKey::NewLC(aFs, aConsole,

   161 		aOut, aTestActionSpec);

   162 	CleanupStack::Pop();

   163 	return self;

   164 	}

   165 

   166 CTestAction* CRSATestPrivateKey::NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

   167 	const TTestActionSpec& aTestActionSpec)

   168 	{

   169 	CRSATestPrivateKey* self = new(ELeave) CRSATestPrivateKey(aFs, aConsole, aOut);

   170 	CleanupStack::PushL(self);

   171 	self->ConstructL(aTestActionSpec);

   172 	return self;

   173 	}

   174 

   175 CRSATestPrivateKey::~CRSATestPrivateKey()

   176 	{

   177 	delete iBody;

   178 	}

   179 

   180 CRSATestPrivateKey::CRSATestPrivateKey(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

   181 	: CTestAction(aConsole, aOut), iFs(aFs)

   182 	{

   183 	}

   184 

   185 void CRSATestPrivateKey::ConstructL(const TTestActionSpec& aTestActionSpec)

   186 	{

   187 	CTestAction::ConstructL(aTestActionSpec);

   188 	iBody = HBufC8::NewL(aTestActionSpec.iActionBody.Length());

   189 	iBody->Des().Copy(aTestActionSpec.iActionBody);

   190 

   191 	iExpectedReturnValue = KErrNone;

   192 	TPtrC8 returnValue = Input::ParseElement(aTestActionSpec.iActionResult, KReturnCodeStart, KReturnCodeEnd);

   193 	if(returnValue.Compare(KErrArgumentString) == 0)

   194 		{

   195 		iExpectedReturnValue = KErrArgument;

   196 		}

   197 

   198 	}

   199 

   200 void CRSATestPrivateKey::DoPerformPrerequisite(TRequestStatus& aStatus)

   201 	{

   202 	TRequestStatus* status = &aStatus;

   203 	User::RequestComplete(status, KErrNone);

   204 	iActionState = CTestAction::EAction;

   205 	}

   206 

   207 void CRSATestPrivateKey::DoPerformPostrequisite(TRequestStatus& aStatus)

   208 	{

   209 	TRequestStatus* status = &aStatus;

   210 

   211 	iFinished = ETrue;

   212 	User::RequestComplete(status, KErrNone);

   213 	}

   214 

   215 void CRSATestPrivateKey::DoReportAction(void)

   216 	{

   217 	}

   218 

   219 void CRSATestPrivateKey::DoCheckResult(TInt)

   220 	{

   221 	if (iResult)

   222 		iConsole.Printf(_L("."));

   223 	else

   224 		iConsole.Printf(_L("X"));

   225 	}

   226 

   227 void CRSATestPrivateKey::PerformAction(TRequestStatus& aStatus)

   228 	{

   229 	__UHEAP_MARK;

   230 	TRequestStatus* status = &aStatus;

   231 	iResult = EFalse;

   232 

   233 	TPtrC8 modIn = Input::ParseElement(*iBody, KModStart, KModEnd);

   234     RInteger mod = VectorUtils::ParseIntegerL(modIn);

   235 	CleanupStack::PushL(mod);

   236 

   237 	TPtrC8 expIn = Input::ParseElement(*iBody, KPrivExpStart, KPrivExpEnd);

   238     RInteger exp = VectorUtils::ParseIntegerL(expIn);

   239 	CleanupStack::PushL(exp);

   240 

   241 

   242 	CRSAPrivateKeyStandard* key = NULL;

   243 	TRAPD(err, key = CRSAPrivateKeyStandard::NewL(mod, exp));

   244 	if(err == iExpectedReturnValue)

   245 		{

   246 		iResult=ETrue;

   247 		}

   248 	else

   249 		{

   250 		iOut.writeString(_L("CRSAPrivateKey construction did not return expected result\n"));

   251 		}

   252 	if(err != KErrNone)

   253 		{

   254 		CleanupStack::PopAndDestroy(2);

   255 		}

   256 	else

   257 		{

   258 		CleanupStack::PushL(key);

   259 		CleanupStack::PopAndDestroy(3);	

   260 		}

   261 		

   262 	User::RequestComplete(status, KErrNone);

   263 	iActionState = CTestAction::EPostrequisite;

   264 	__UHEAP_MARKEND;

   265 	}

   266 

   267 CTestAction* CRSATestPrivateKeyCRT::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

   268 	const TTestActionSpec& aTestActionSpec)

   269 	{

   270 	CTestAction* self = CRSATestPrivateKeyCRT::NewLC(aFs, aConsole,

   271 		aOut, aTestActionSpec);

   272 	CleanupStack::Pop();

   273 	return self;

   274 	}

   275 

   276 CTestAction* CRSATestPrivateKeyCRT::NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

   277 	const TTestActionSpec& aTestActionSpec)

   278 	{

   279 	CRSATestPrivateKeyCRT* self = new(ELeave) CRSATestPrivateKeyCRT(aFs, aConsole, aOut);

   280 	CleanupStack::PushL(self);

   281 	self->ConstructL(aTestActionSpec);

   282 	return self;

   283 	}

   284 

   285 CRSATestPrivateKeyCRT::~CRSATestPrivateKeyCRT()

   286 	{

   287 	delete iBody;

   288 	}

   289 

   290 CRSATestPrivateKeyCRT::CRSATestPrivateKeyCRT(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

   291 	: CTestAction(aConsole, aOut), iFs(aFs)

   292 	{

   293 	}

   294 

   295 void CRSATestPrivateKeyCRT::ConstructL(const TTestActionSpec& aTestActionSpec)

   296 	{

   297 	CTestAction::ConstructL(aTestActionSpec);

   298 	iBody = HBufC8::NewL(aTestActionSpec.iActionBody.Length());

   299 	iBody->Des().Copy(aTestActionSpec.iActionBody);

   300 

   301 	iExpectedReturnValue = KErrNone;

   302 	TPtrC8 returnValue = Input::ParseElement(aTestActionSpec.iActionResult, KReturnCodeStart, KReturnCodeEnd);

   303 	if(returnValue.Compare(KErrArgumentString) == 0)

   304 		{

   305 		iExpectedReturnValue = KErrArgument;

   306 		}

   307 

   308 	}

   309 

   310 void CRSATestPrivateKeyCRT::DoPerformPrerequisite(TRequestStatus& aStatus)

   311 	{

   312 	TRequestStatus* status = &aStatus;

   313 	User::RequestComplete(status, KErrNone);

   314 	iActionState = CTestAction::EAction;

   315 	}

   316 

   317 void CRSATestPrivateKeyCRT::DoPerformPostrequisite(TRequestStatus& aStatus)

   318 	{

   319 	TRequestStatus* status = &aStatus;

   320 

   321 	iFinished = ETrue;

   322 	User::RequestComplete(status, KErrNone);

   323 	}

   324 

   325 void CRSATestPrivateKeyCRT::DoReportAction(void)

   326 	{

   327 	}

   328 

   329 void CRSATestPrivateKeyCRT::DoCheckResult(TInt)

   330 	{

   331 	if (iResult)

   332 		iConsole.Printf(_L("."));

   333 	else

   334 		iConsole.Printf(_L("X"));

   335 	}

   336 

   337 void CRSATestPrivateKeyCRT::PerformAction(TRequestStatus& aStatus)

   338 	{

   339 	__UHEAP_MARK;

   340 	TRequestStatus* status = &aStatus;

   341 	iResult = EFalse;

   342 

   343 	TPtrC8 modIn = Input::ParseElement(*iBody, KModStart, KModEnd);

   344     RInteger mod = VectorUtils::ParseIntegerL(modIn);

   345 	CleanupStack::PushL(mod);

   346 

   347 	TPtrC8 PIn = Input::ParseElement(*iBody, KPStart, KPEnd);

   348     RInteger P = VectorUtils::ParseIntegerL(PIn);

   349 	CleanupStack::PushL(P);

   350 

   351 	TPtrC8 QIn = Input::ParseElement(*iBody, KQStart, KQEnd);

   352     RInteger Q = VectorUtils::ParseIntegerL(QIn);

   353 	CleanupStack::PushL(Q);

   354 

   355 	TPtrC8 dPIn = Input::ParseElement(*iBody, KdPStart, KdPEnd);

   356     RInteger dP = VectorUtils::ParseIntegerL(dPIn);

   357 	CleanupStack::PushL(dP);

   358 

   359 	TPtrC8 dQIn = Input::ParseElement(*iBody, KdQStart, KdQEnd);

   360     RInteger dQ = VectorUtils::ParseIntegerL(dQIn);

   361 	CleanupStack::PushL(dQ);

   362 

   363 	TPtrC8 QInvIn = Input::ParseElement(*iBody, KqInvStart, KqInvEnd);

   364     RInteger QInv = VectorUtils::ParseIntegerL(QInvIn);

   365 	CleanupStack::PushL(QInv);

   366 

   367 

   368 	CRSAPrivateKeyCRT* key = NULL;

   369 	TRAPD(err, key = CRSAPrivateKeyCRT::NewL(mod, P, Q, dP, dQ, QInv));

   370 	if(err == iExpectedReturnValue)

   371 		{

   372 		iResult=ETrue;

   373 		}

   374 	else

   375 		{

   376 		iOut.writeString(_L("CRSAPrivateKeyCRT construction did not return expected result\n"));

   377 		}

   378 	if(err != KErrNone)

   379 		{

   380 		CleanupStack::PopAndDestroy(6);

   381 		}

   382 	else

   383 		{

   384 		CleanupStack::PushL(key);

   385 		CleanupStack::PopAndDestroy(7);	

   386 		}

   387 		

   388 	User::RequestComplete(status, KErrNone);

   389 	iActionState = CTestAction::EPostrequisite;

   390 	__UHEAP_MARKEND;

   391 	}

   392
Symaptic