--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/test/dumpcryptoplugin/dumpcryptoplugin.cpp Thu Sep 10 14:01:51 2009 +0300
@@ -0,0 +1,477 @@
+/*
+* Copyright (c) 2007-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:
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+*/
+
+#include "dumpprocessor.h"
+#include <e32cons.h>
+#include <cryptospi/cryptospidef.h>
+#include <bacline.h>
+#include <cryptospi/cryptocharacteristics.h>
+#include <cryptospi/cryptospistateapi.h>
+
+using namespace CryptoSpi;
+
+//Copy-right, Tool name format
+_LIT(KShortName, "Dump CryptoSpi Tool");
+_LIT(KName, "Symbian Dump CryptoSpi Tool");
+_LIT(KCopyright, "Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.");
+_LIT(KDone, "Complete Dumping... \n");
+
+//dumpcryptoplugin options
+_LIT(KAll, "-all");
+_LIT(KAllShort, "-a");
+
+_LIT(KInterface, "-interface");
+_LIT(KInterfaceShort, "-i");
+
+_LIT(KAlgorithm, "-algorithm");
+_LIT(KAlgorithmShort, "-al");
+
+_LIT(KExtended, "-extended");
+_LIT(KExtendedShort, "-e");
+
+_LIT(KDll, "-dll");
+_LIT(KDllShort, "-d");
+
+_LIT(KHelp, "-help");
+_LIT(KHelpShort, "-h");
+
+_LIT(KOutputFile, "-out");
+_LIT(KOutputFileShort, "-o");
+
+
+//Error messages
+_LIT(KMissingInterfaceName, "Missing Interface Name. \n");
+_LIT(KInvalidInterfaceName, "Invalid Interface Name. \n");
+_LIT(KMissingAlgorithmName, "Missing Algorithm Name. \n");
+_LIT(KInvalidAlgorithmName, "Invalid Algorithm Name. \n");
+_LIT(KMissingDllName, "Missing Plugin Dll Name. \n");
+_LIT(KMissingOutputName, "Missing Output Name. \n");
+_LIT(KError, "Error=%d \n");
+
+/**
+The method converts the given interface name to interface uid
+*/
+TInt ConvertToInterfaceId(const TDesC& aInterfaceName, TInt32& aInterfaceId)
+ {
+ if (aInterfaceName.CompareF(KHash)==0)
+ {
+ aInterfaceId=KHashInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KRandom)==0)
+ {
+ aInterfaceId=KRandomInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KSymmetricCipher)==0)
+ {
+ aInterfaceId=KSymmetricCipherInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KAsymmetricCipher)==0)
+ {
+ aInterfaceId=KAsymmetricCipherInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KSigner)==0)
+ {
+ aInterfaceId=KSignerInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KVerifier)==0)
+ {
+ aInterfaceId=KVerifierInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KKeyPairGenerator)==0)
+ {
+ aInterfaceId=KKeypairGeneratorInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KKeyAgreement)==0)
+ {
+ aInterfaceId=KKeyAgreementInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KAsyncHash)==0)
+ {
+ aInterfaceId=KAsyncHashInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KAsyncRandom)==0)
+ {
+ aInterfaceId=KAsyncRandomInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KAsyncSymmetricCipher)==0)
+ {
+ aInterfaceId=KAsyncSymmetricCipherInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KAsyncAsymmetricCipher)==0)
+ {
+ aInterfaceId=KAsyncAsymmetricCipherInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KAsyncSigner)==0)
+ {
+ aInterfaceId=KAsyncSignerInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KAsyncVerifier)==0)
+ {
+ aInterfaceId=KAsyncVerifierInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KAsyncKeyPairGenerator)==0)
+ {
+ aInterfaceId=KAsyncKeypairGeneratorInterface;
+ return KErrNone;
+ }
+
+ if (aInterfaceName.CompareF(KAsyncKeyAgreement)==0)
+ {
+ aInterfaceId=KAsyncKeyAgreementInterface;
+ return KErrNone;
+ }
+
+ return KErrNotFound;
+ }
+
+/**
+The method converts the given algorithm name to algorithm uid
+*/
+TInt ConvertToAlgorithmId(const TDesC& aAlgorithmName, TInt32& aAlgorithmId)
+ {
+ if (aAlgorithmName.CompareF(KMd2)==0)
+ {
+ aAlgorithmId=KAlgorithmHashMd2;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KMd5)==0)
+ {
+ aAlgorithmId=KAlgorithmHashMd5;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KMd4)==0)
+ {
+ aAlgorithmId=KAlgorithmHashMd4;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KSha1)==0)
+ {
+ aAlgorithmId=KAlgorithmHashSha1;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KDes)==0)
+ {
+ aAlgorithmId=KAlgorithmCipherDes;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(K3Des)==0)
+ {
+ aAlgorithmId=KAlgorithmCipher3Des;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KRC2)==0)
+ {
+ aAlgorithmId=KAlgorithmCipherRc2;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KAes)==0)
+ {
+ aAlgorithmId=KAlgorithmCipherAes;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KRC4)==0)
+ {
+ aAlgorithmId=KAlgorithmCipherArc4;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KRsaCipher)==0)
+ {
+ aAlgorithmId=KAlgorithmCipherRsa;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KRsaSigner)==0)
+ {
+ aAlgorithmId=KAlgorithmSignerRsa;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KRsaVerifier)==0)
+ {
+ aAlgorithmId=KAlgorithmVerifierRsa;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KRsaKeyPair)==0)
+ {
+ aAlgorithmId=KAlgorithmRSAKeyPairGenerator;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KDsaSigner)==0)
+ {
+ aAlgorithmId=KAlgorithmSignerDsa;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KDsaVerifier)==0)
+ {
+ aAlgorithmId=KAlgorithmVerifierDsa;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KDsaKeyPair)==0)
+ {
+ aAlgorithmId=KAlgorithmDSAKeyPairGenerator;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KDhKeyPair)==0)
+ {
+ aAlgorithmId=KAlgorithmDHKeyPairGenerator;
+ return KErrNone;
+ }
+
+ if (aAlgorithmName.CompareF(KDhKeyAgreement)==0)
+ {
+ aAlgorithmId=KAlgorithmKeyAgreementDH;
+ return KErrNone;
+ }
+
+ return KErrNotFound;
+ }
+
+
+/**
+Displays tool name and copy-right informations.
+*/
+void BoilerPlate(CConsoleBase* console)
+ {
+ console->Printf(KNewLine);
+ console->Printf(KName);
+ console->Printf(KNewLine);
+ console->Printf(KCopyright);
+ console->Printf(KNewLine);
+ console->Printf(KNewLine);
+ }
+
+/**
+The method retrieves the command line parameters and build the CDumpToolParameters object.
+*/
+
+void ExtractOptionL(const CCommandLineArguments& aInput, CDumpToolParameters& aParam, CConsoleBase* aConsole)
+ {
+ TInt count=aInput.Count();
+ TInt i=0;
+ while (i<count-1)
+ {
+ i++;
+
+ //Handle -a and -all
+ if ((aInput.Arg(i).Compare(KAll)==0)||(aInput.Arg(i).Compare(KAllShort)==0))
+ {
+ continue;
+ }
+
+ //Handle -i and -interface
+ if ((aInput.Arg(i).Compare(KInterface)==0)||(aInput.Arg(i).Compare(KInterfaceShort)==0))
+ {
+ //Move to interface name
+ i++;
+ if (i>count-1)
+ {
+ aConsole->Printf(KMissingInterfaceName);
+ User::Leave(KErrArgument);
+ }
+
+ //Currently point to interface name
+ if (KErrNone!=ConvertToInterfaceId(aInput.Arg(i), aParam.iInterface))
+ {
+ //Invalid interface name
+ aConsole->Printf(KInvalidInterfaceName);
+ User::Leave(KErrArgument);
+ }
+ continue;
+ }
+
+ //Handle -al and -algorithm
+ if ((aInput.Arg(i).Compare(KAlgorithm)==0)||(aInput.Arg(i).Compare(KAlgorithmShort)==0))
+ {
+ //Move to algorithm name
+ i++;
+ if (i>count-1)
+ {
+ aConsole->Printf(KMissingAlgorithmName);
+ User::Leave(KErrArgument);
+ }
+
+ //Currently point to algorithm name
+ if (KErrNone!=ConvertToAlgorithmId(aInput.Arg(i), aParam.iAlgorithm))
+ {
+ //Invalid algorithm name
+ aConsole->Printf(KInvalidAlgorithmName);
+ User::Leave(KErrArgument);
+ }
+ continue;
+ }
+
+ //Handle -e and -extended
+ if ((aInput.Arg(i).Compare(KExtended)==0)||(aInput.Arg(i).Compare(KExtendedShort)==0))
+ {
+ aParam.iOptions.AppendL(CDumpToolParameters::EOptionExtendedCharacteristic);
+ continue;
+ }
+
+ //Handle -d and -dll
+ if ((aInput.Arg(i).Compare(KDll)==0)||(aInput.Arg(i).Compare(KDllShort)==0))
+ {
+ i++;
+ if (i>count-1)
+ {
+ aConsole->Printf(KMissingDllName);
+ User::Leave(KErrArgument);
+ }
+ aParam.iDllName=aInput.Arg(i);
+ continue;
+ }
+
+ //Handle -o and -out
+ if ((aInput.Arg(i).Compare(KOutputFile)==0)||(aInput.Arg(i).Compare(KOutputFileShort)==0))
+ {
+ i++;
+ if (i>count-1)
+ {
+ aConsole->Printf(KMissingOutputName);
+ User::Leave(KErrArgument);
+ }
+ aParam.iDumpFileName=aInput.Arg(i);
+ continue;
+ }
+
+ //Handle -h and -help
+ if ((aInput.Arg(i).Compare(KHelp)==0)||(aInput.Arg(i).Compare(KHelpShort)==0))
+ {
+ aParam.iOptions.AppendL(CDumpToolParameters::EOptionHelp);
+ continue;
+ }
+
+ HBufC* temp=aInput.Arg(i).AllocLC();
+ aParam.iInvalidOptions.AppendL(temp);
+ CleanupStack::Pop(temp);
+ }
+ }
+
+
+void DoProcessL(CConsoleBase* aConsole)
+ {
+ //Get the command line arguments
+ CCommandLineArguments* args = CCommandLineArguments::NewLC();
+
+ //Construct the parameters holder
+ CDumpToolParameters* params = CDumpToolParameters::NewLC();
+
+ //Retrieve the command line options
+ ExtractOptionL(*args, *params, aConsole);
+
+ //Process the command line and output the characteristics.
+ CDumpToolProcessor* processor=CDumpToolProcessor::NewLC(*params, aConsole);
+ processor->ProcessL();
+ aConsole->Printf(KNewLine);
+ CleanupStack::PopAndDestroy(processor);
+ CleanupStack::PopAndDestroy(2, args); // params, args,
+ }
+
+/**
+Main function to retrieve and log the characteristics
+*/
+void DoMainL()
+ {
+ //New a console and print tool information
+ CConsoleBase* console = Console::NewL(KShortName, TSize(KDefaultConsWidth, KDefaultConsHeight));
+ CleanupStack::PushL(console);
+ BoilerPlate(console);
+ TRAPD(err, DoProcessL(console));
+ if (err!=KErrArgument && err!=KErrNone)
+ {
+ console->Printf(KError, err);
+ }
+ if (err!=KErrNone)
+ {
+ console->Printf(KPressAnyKey);
+ console->Getch();
+ }
+ console->Printf(KDone);
+ //console->Getch();
+ CleanupStack::PopAndDestroy(console); // params, args, console
+ }
+
+/**
+@return KErrNone (0) if successful, KErrMemory if out of memory
+otherwise error result from DoMainL
+*/
+TInt E32Main()
+ {
+ __UHEAP_MARK;
+ CTrapCleanup* trapCleanup=CTrapCleanup::New();
+ if (!trapCleanup)
+ {
+ return KErrNoMemory;
+ }
+
+ TRAPD(err, DoMainL());
+ delete trapCleanup;
+ __UHEAP_MARKEND;
+ return err;
+ }
+
+
+
+
+