os/security/crypto/weakcryptospi/test/dumpcryptoplugin/dumpcryptoplugin.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib.
     1 /*
     2 * Copyright (c) 2007-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 /**
    20  @file
    21  @internalComponent
    22 */
    23 
    24 #include "dumpprocessor.h"
    25 #include <e32cons.h>
    26 #include <cryptospi/cryptospidef.h>
    27 #include <bacline.h>
    28 #include <cryptospi/cryptocharacteristics.h>
    29 #include <cryptospi/cryptospistateapi.h>
    30 
    31 using namespace CryptoSpi;
    32 
    33 //Copy-right, Tool name format
    34 _LIT(KShortName, "Dump CryptoSpi Tool");
    35 _LIT(KName, "Symbian Dump CryptoSpi Tool");
    36 _LIT(KCopyright, "Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).  All rights reserved.");
    37 _LIT(KDone, "Complete Dumping... \n");
    38 
    39 //dumpcryptoplugin options
    40 _LIT(KAll, "-all");
    41 _LIT(KAllShort, "-a");
    42 
    43 _LIT(KInterface, "-interface");
    44 _LIT(KInterfaceShort, "-i");
    45 
    46 _LIT(KAlgorithm, "-algorithm");
    47 _LIT(KAlgorithmShort, "-al");
    48 
    49 _LIT(KExtended, "-extended");
    50 _LIT(KExtendedShort, "-e");
    51 
    52 _LIT(KDll, "-dll");
    53 _LIT(KDllShort, "-d");
    54 
    55 _LIT(KHelp, "-help");
    56 _LIT(KHelpShort, "-h");
    57 
    58 _LIT(KOutputFile, "-out");
    59 _LIT(KOutputFileShort, "-o");
    60 
    61 
    62 //Error messages
    63 _LIT(KMissingInterfaceName, "Missing Interface Name. \n");
    64 _LIT(KInvalidInterfaceName, "Invalid Interface Name. \n");
    65 _LIT(KMissingAlgorithmName, "Missing Algorithm Name. \n");
    66 _LIT(KInvalidAlgorithmName, "Invalid Algorithm Name. \n");
    67 _LIT(KMissingDllName, "Missing Plugin Dll Name. \n");
    68 _LIT(KMissingOutputName, "Missing Output Name. \n");
    69 _LIT(KError, "Error=%d \n");
    70 
    71 /**
    72 The method converts the given interface name to interface uid
    73 */
    74 TInt ConvertToInterfaceId(const TDesC& aInterfaceName, TInt32& aInterfaceId)
    75 	{
    76 	if (aInterfaceName.CompareF(KHash)==0)
    77 		{
    78 		aInterfaceId=KHashInterface;
    79 		return KErrNone;
    80 		}
    81 	
    82 	if (aInterfaceName.CompareF(KRandom)==0)
    83 		{
    84 		aInterfaceId=KRandomInterface;
    85 		return KErrNone;
    86 		}
    87 
    88 	if (aInterfaceName.CompareF(KSymmetricCipher)==0)
    89 		{
    90 		aInterfaceId=KSymmetricCipherInterface;
    91 		return KErrNone;
    92 		}
    93 
    94 	if (aInterfaceName.CompareF(KAsymmetricCipher)==0)
    95 		{
    96 		aInterfaceId=KAsymmetricCipherInterface;
    97 		return KErrNone;
    98 		}
    99 	
   100 	if (aInterfaceName.CompareF(KSigner)==0)
   101 		{
   102 		aInterfaceId=KSignerInterface;
   103 		return KErrNone;
   104 		}
   105 
   106 	if (aInterfaceName.CompareF(KVerifier)==0)
   107 		{
   108 		aInterfaceId=KVerifierInterface;
   109 		return KErrNone;
   110 		}
   111 
   112 	if (aInterfaceName.CompareF(KKeyPairGenerator)==0)
   113 		{
   114 		aInterfaceId=KKeypairGeneratorInterface;
   115 		return KErrNone;
   116 		}
   117 
   118 	if (aInterfaceName.CompareF(KKeyAgreement)==0)
   119 		{
   120 		aInterfaceId=KKeyAgreementInterface;
   121 		return KErrNone;
   122 		}
   123 
   124 	if (aInterfaceName.CompareF(KAsyncHash)==0)
   125 		{
   126 		aInterfaceId=KAsyncHashInterface;
   127 		return KErrNone;
   128 		}
   129 	
   130 	if (aInterfaceName.CompareF(KAsyncRandom)==0)
   131 		{
   132 		aInterfaceId=KAsyncRandomInterface;
   133 		return KErrNone;
   134 		}
   135 
   136 	if (aInterfaceName.CompareF(KAsyncSymmetricCipher)==0)
   137 		{
   138 		aInterfaceId=KAsyncSymmetricCipherInterface;
   139 		return KErrNone;
   140 		}
   141 
   142 	if (aInterfaceName.CompareF(KAsyncAsymmetricCipher)==0)
   143 		{
   144 		aInterfaceId=KAsyncAsymmetricCipherInterface;
   145 		return KErrNone;
   146 		}
   147 	
   148 	if (aInterfaceName.CompareF(KAsyncSigner)==0)
   149 		{
   150 		aInterfaceId=KAsyncSignerInterface;
   151 		return KErrNone;
   152 		}
   153 
   154 	if (aInterfaceName.CompareF(KAsyncVerifier)==0)
   155 		{
   156 		aInterfaceId=KAsyncVerifierInterface;
   157 		return KErrNone;
   158 		}
   159 
   160 	if (aInterfaceName.CompareF(KAsyncKeyPairGenerator)==0)
   161 		{
   162 		aInterfaceId=KAsyncKeypairGeneratorInterface;
   163 		return KErrNone;
   164 		}
   165 
   166 	if (aInterfaceName.CompareF(KAsyncKeyAgreement)==0)
   167 		{
   168 		aInterfaceId=KAsyncKeyAgreementInterface;
   169 		return KErrNone;
   170 		}
   171 		
   172 	return KErrNotFound;
   173 	}
   174 
   175 /**
   176 The method converts the given algorithm name to algorithm uid
   177 */
   178 TInt ConvertToAlgorithmId(const TDesC& aAlgorithmName, TInt32& aAlgorithmId)
   179 	{
   180 	if (aAlgorithmName.CompareF(KMd2)==0)
   181 		{
   182 		aAlgorithmId=KAlgorithmHashMd2;
   183 		return KErrNone;
   184 		}
   185 		
   186 	if (aAlgorithmName.CompareF(KMd5)==0)
   187 		{
   188 		aAlgorithmId=KAlgorithmHashMd5;
   189 		return KErrNone;
   190 		}
   191 
   192 	if (aAlgorithmName.CompareF(KMd4)==0)
   193 		{
   194 		aAlgorithmId=KAlgorithmHashMd4;
   195 		return KErrNone;
   196 		}
   197 		
   198 	if (aAlgorithmName.CompareF(KSha1)==0)
   199 		{
   200 		aAlgorithmId=KAlgorithmHashSha1;
   201 		return KErrNone;
   202 		}
   203 
   204 	if (aAlgorithmName.CompareF(KDes)==0)
   205 		{
   206 		aAlgorithmId=KAlgorithmCipherDes;
   207 		return KErrNone;
   208 		}
   209 
   210 	if (aAlgorithmName.CompareF(K3Des)==0)
   211 		{
   212 		aAlgorithmId=KAlgorithmCipher3Des;
   213 		return KErrNone;
   214 		}
   215 		
   216 	if (aAlgorithmName.CompareF(KRC2)==0)
   217 		{
   218 		aAlgorithmId=KAlgorithmCipherRc2;
   219 		return KErrNone;
   220 		}
   221 		
   222 	if (aAlgorithmName.CompareF(KAes)==0)
   223 		{
   224 		aAlgorithmId=KAlgorithmCipherAes;
   225 		return KErrNone;
   226 		}
   227 
   228 	if (aAlgorithmName.CompareF(KRC4)==0)
   229 		{
   230 		aAlgorithmId=KAlgorithmCipherArc4;
   231 		return KErrNone;
   232 		}
   233 
   234 	if (aAlgorithmName.CompareF(KRsaCipher)==0)
   235 		{
   236 		aAlgorithmId=KAlgorithmCipherRsa;
   237 		return KErrNone;
   238 		}
   239 
   240 	if (aAlgorithmName.CompareF(KRsaSigner)==0)
   241 		{
   242 		aAlgorithmId=KAlgorithmSignerRsa;
   243 		return KErrNone;
   244 		}
   245 		
   246 	if (aAlgorithmName.CompareF(KRsaVerifier)==0)
   247 		{
   248 		aAlgorithmId=KAlgorithmVerifierRsa;
   249 		return KErrNone;
   250 		}
   251 
   252 	if (aAlgorithmName.CompareF(KRsaKeyPair)==0)
   253 		{
   254 		aAlgorithmId=KAlgorithmRSAKeyPairGenerator;
   255 		return KErrNone;
   256 		}
   257 		
   258 	if (aAlgorithmName.CompareF(KDsaSigner)==0)
   259 		{
   260 		aAlgorithmId=KAlgorithmSignerDsa;
   261 		return KErrNone;
   262 		}
   263 
   264 	if (aAlgorithmName.CompareF(KDsaVerifier)==0)
   265 		{
   266 		aAlgorithmId=KAlgorithmVerifierDsa;
   267 		return KErrNone;
   268 		}
   269 		
   270 	if (aAlgorithmName.CompareF(KDsaKeyPair)==0)
   271 		{
   272 		aAlgorithmId=KAlgorithmDSAKeyPairGenerator;
   273 		return KErrNone;
   274 		}
   275 
   276 	if (aAlgorithmName.CompareF(KDhKeyPair)==0)
   277 		{
   278 		aAlgorithmId=KAlgorithmDHKeyPairGenerator;
   279 		return KErrNone;
   280 		}
   281 
   282 	if (aAlgorithmName.CompareF(KDhKeyAgreement)==0)
   283 		{
   284 		aAlgorithmId=KAlgorithmKeyAgreementDH;
   285 		return KErrNone;
   286 		}
   287 		
   288 	return KErrNotFound;
   289 	}
   290 
   291 
   292 /**
   293 Displays tool name and copy-right informations.
   294 */
   295 void BoilerPlate(CConsoleBase* console) 
   296 	{
   297 	console->Printf(KNewLine);
   298 	console->Printf(KName);
   299 	console->Printf(KNewLine);	
   300 	console->Printf(KCopyright);
   301 	console->Printf(KNewLine);
   302 	console->Printf(KNewLine);
   303 	}
   304 
   305 /**
   306 The method retrieves the command line parameters and build the CDumpToolParameters object.
   307 */
   308 
   309 void ExtractOptionL(const CCommandLineArguments& aInput, CDumpToolParameters& aParam, CConsoleBase* aConsole)
   310 	{
   311 	TInt count=aInput.Count();
   312 	TInt i=0;
   313 	while (i<count-1)
   314 	 	{
   315 		i++;
   316 		
   317 		//Handle -a and -all		
   318 		if ((aInput.Arg(i).Compare(KAll)==0)||(aInput.Arg(i).Compare(KAllShort)==0))
   319 			{
   320 			continue;
   321 			}		
   322 		
   323 		//Handle -i and -interface
   324 		if ((aInput.Arg(i).Compare(KInterface)==0)||(aInput.Arg(i).Compare(KInterfaceShort)==0))
   325 			{
   326 			//Move to interface name
   327 			i++;
   328 			if (i>count-1)
   329 				{
   330 				aConsole->Printf(KMissingInterfaceName);
   331 				User::Leave(KErrArgument);	
   332 				}
   333 			
   334 			//Currently point to interface name
   335 			if (KErrNone!=ConvertToInterfaceId(aInput.Arg(i), aParam.iInterface))
   336 				{
   337 				//Invalid interface name
   338 				aConsole->Printf(KInvalidInterfaceName);
   339 				User::Leave(KErrArgument);
   340 				}
   341 			continue;
   342 			}
   343 			
   344 		//Handle -al and -algorithm
   345 		if ((aInput.Arg(i).Compare(KAlgorithm)==0)||(aInput.Arg(i).Compare(KAlgorithmShort)==0))
   346 			{
   347 			//Move to algorithm name
   348 			i++;
   349 			if (i>count-1)
   350 				{
   351 				aConsole->Printf(KMissingAlgorithmName);
   352 				User::Leave(KErrArgument);	
   353 				}
   354 			
   355 			//Currently point to algorithm name
   356 			if (KErrNone!=ConvertToAlgorithmId(aInput.Arg(i), aParam.iAlgorithm))
   357 				{
   358 				//Invalid algorithm name
   359 				aConsole->Printf(KInvalidAlgorithmName);
   360 				User::Leave(KErrArgument);
   361 				}
   362 			continue;
   363 			}
   364 		
   365 		//Handle -e and -extended
   366 		if ((aInput.Arg(i).Compare(KExtended)==0)||(aInput.Arg(i).Compare(KExtendedShort)==0))
   367 			{
   368 			aParam.iOptions.AppendL(CDumpToolParameters::EOptionExtendedCharacteristic);
   369 			continue;
   370 			}		
   371 		
   372 		//Handle -d and -dll
   373 		if ((aInput.Arg(i).Compare(KDll)==0)||(aInput.Arg(i).Compare(KDllShort)==0))
   374 			{
   375 			i++;
   376 			if (i>count-1)
   377 				{
   378 				aConsole->Printf(KMissingDllName);
   379 				User::Leave(KErrArgument);	
   380 				}
   381 			aParam.iDllName=aInput.Arg(i);
   382 			continue;
   383 			}
   384 
   385 		//Handle -o and -out
   386 		if ((aInput.Arg(i).Compare(KOutputFile)==0)||(aInput.Arg(i).Compare(KOutputFileShort)==0))
   387 			{
   388 			i++;
   389 			if (i>count-1)
   390 				{
   391 				aConsole->Printf(KMissingOutputName);
   392 				User::Leave(KErrArgument);	
   393 				}
   394 			aParam.iDumpFileName=aInput.Arg(i);
   395 			continue;
   396 			}
   397 		
   398 		//Handle -h and -help
   399  		if ((aInput.Arg(i).Compare(KHelp)==0)||(aInput.Arg(i).Compare(KHelpShort)==0))
   400  			{
   401   			aParam.iOptions.AppendL(CDumpToolParameters::EOptionHelp);
   402   			continue;
   403    			}
   404    			
   405    		HBufC* temp=aInput.Arg(i).AllocLC();
   406    		aParam.iInvalidOptions.AppendL(temp);
   407    		CleanupStack::Pop(temp);
   408 	 	}
   409 	}
   410 
   411 
   412 void DoProcessL(CConsoleBase* aConsole)
   413 	{
   414 	//Get the command line arguments
   415 	CCommandLineArguments* args = CCommandLineArguments::NewLC();
   416 	
   417 	//Construct the parameters holder
   418 	CDumpToolParameters* params = CDumpToolParameters::NewLC();
   419 	
   420 	//Retrieve the command line options
   421 	ExtractOptionL(*args, *params, aConsole);
   422 	
   423 	//Process the command line and output the characteristics.
   424 	CDumpToolProcessor* processor=CDumpToolProcessor::NewLC(*params, aConsole);
   425 	processor->ProcessL();
   426 	aConsole->Printf(KNewLine);
   427 	CleanupStack::PopAndDestroy(processor);			
   428 	CleanupStack::PopAndDestroy(2, args); //	params, args, 
   429 	}
   430 
   431 /**
   432 Main function to retrieve and log the characteristics
   433 */
   434 void DoMainL()
   435 	{
   436 	//New a console and print tool information
   437 	CConsoleBase* console = Console::NewL(KShortName, TSize(KDefaultConsWidth, KDefaultConsHeight));
   438 	CleanupStack::PushL(console);
   439 	BoilerPlate(console);
   440 	TRAPD(err, DoProcessL(console));
   441 	if (err!=KErrArgument && err!=KErrNone)
   442 		{
   443 		console->Printf(KError, err);
   444 		}
   445 	if (err!=KErrNone)
   446 		{
   447 		console->Printf(KPressAnyKey);
   448 		console->Getch();			
   449 		}
   450 	console->Printf(KDone);
   451 	//console->Getch();
   452 	CleanupStack::PopAndDestroy(console); //	params, args, console
   453 	}
   454 
   455 /**
   456 @return KErrNone (0) if successful, KErrMemory if out of memory
   457 otherwise error result from DoMainL
   458 */
   459 TInt E32Main()
   460 	{
   461 	__UHEAP_MARK;
   462 	CTrapCleanup* trapCleanup=CTrapCleanup::New();
   463 	if (!trapCleanup)
   464 		{
   465 		return KErrNoMemory;
   466 		}
   467 				
   468 	TRAPD(err, DoMainL());
   469 	delete trapCleanup;
   470 	__UHEAP_MARKEND;
   471 	return err;
   472 	}
   473 		
   474 
   475 
   476 
   477