Symaptic: os/security/cryptoservices/asnpkcs/test/tpkcs8enc/pkcs8Tester.cpp@260cb5ec6c19

     1 /*

     2 * Copyright (c) 2005-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 * Test program for PKCS8 Encoding

    16 *

    17 */

    20 /**

    21  @file

    22 */

    24 #include <e32test.h>

    25 #include <e32std.h>

    26 #include <U32STD.H>

    27 #include <asn1enc.h>

    28 #include <asnpkcs.h>

    29 #include <pbe.h>

    30 #include <pbebase.h>

    31 #include <pbedata.h>

    32 #include <random.h>

    33 #include <asymmetrickeys.h>

    34 #include <bigint.h>

    35 #include <securityerr.h>

    37 #include "pkcs8tester.h"

    39 const TInt KErrEmptyKeyFile = -99990;

    41 /**

    42  * Extracts the nPos command line argument.

    43  */

    44  HBufC* Pkcs8Utils::GetArgumentL(TInt nPos)

    45         {

    46 		HBufC *argv = HBufC::NewLC(User::CommandLineLength());

    47 		TPtr cmd(argv->Des());

    48 		User::CommandLine(cmd);

    49         TLex arguments(cmd);

    51         // finds nth parameter

    52         while(nPos && !arguments.Eos())

    53                 {

    54                 TPtrC token = arguments.NextToken();

    55                 if(token.Length() > 0)

    56                         nPos--;

    57                 }

    59         HBufC* result = NULL;

    60         if(!arguments.Eos())

    61                 {

    62                 TPtrC testfile(arguments.NextToken());

    64                 if(testfile.Length() > 0)

    65                         result = testfile.AllocL();

    66                 };

    68         // no parameter found, but must return something so..

    69         if(!result)

    70                 result = HBufC::NewL(0);

    72         CleanupStack::PopAndDestroy(argv);

    74         return result;

    75         }

    77  CDecPKCS8Data* Pkcs8Utils::getPkcsDataL(TDesC& fileName)

    78 	{

    79 	// First import a PKCS8 private key from file

    80 	RFs fs;

    81 	CleanupClosePushL(fs);

    82 	User::LeaveIfError(fs.Connect());

    84 	RFile file;

    85 	CleanupClosePushL(file);

    86 	TInt r = file.Open(fs, fileName, EFileRead);

    87 	User::LeaveIfError(r);

    89 	TInt fileSize = 0;

    90 	User::LeaveIfError(file.Size(fileSize));

    92 	if (fileSize <= 0)

    93 	{

    94 		User::Leave(KErrEmptyKeyFile);

    95 	}

    97 	HBufC8* buf = HBufC8::NewMaxLC(fileSize);

    98 	TPtr8 data(buf->Des());

    99 	data.FillZ();

   100 	User::LeaveIfError(file.Read(data, fileSize));

   102 	CDecPKCS8Data* decoded = TASN1DecPKCS8::DecodeDERL(buf->Des());

   104 	CleanupStack::PopAndDestroy(buf);

   105 	CleanupStack::PopAndDestroy(&file);

   106 	CleanupStack::PopAndDestroy(&fs);

   107 	//CleanupStack::PopAndDestroy(fileName);

   109 	return decoded;

   110 	}

   112  void Pkcs8Utils::WriteSequenceL(const TDesC& fn, CASN1EncSequence& seq)

   113 {

   114 	HBufC8* seqBufc = HBufC8::NewLC(seq.LengthDER());

   115 	TPtr8 seqBuf(seqBufc->Des());

   116 	seqBuf.SetLength(seq.LengthDER());

   117 	TUint pos = 0;

   119 	seq.WriteDERL(seqBuf, pos);

   122 	RFs fs2;

   123 	CleanupClosePushL(fs2);

   124 	User::LeaveIfError(fs2.Connect());

   126 	RFile file2;

   127 	CleanupClosePushL(file2);

   128 	TRAPD(err, file2.Create(fs2, fn, EFileRead));

   129 	if (err==KErrNotFound)

   130 	{

   131 		User::LeaveIfError(err);

   132 	}

   133 	file2.Close();

   135 	RFileWriteStream writer;

   136 	writer.PushL();

   138     	User::LeaveIfError(writer.Open(fs2, fn, EFileWrite));

   140 	writer.WriteL(seqBuf);

   141 	writer.Close();

   143 	CleanupStack::PopAndDestroy(4, seqBufc);

   144 }

   148 LOCAL_D void DoTestsDSAEncryptedL(CDecPKCS8Data& decoded)

   149 	{

   150 	CPKCS8KeyPairDSA* keypair = static_cast<CPKCS8KeyPairDSA*>(decoded.KeyPairData());

   152 	const CDSAPrivateKey& priv = keypair->PrivateKey();

   154 	TPBPassword pass(_L(""));

   156 	CSystemRandom* rand = CSystemRandom::NewLC();

   157 	HBufC8* saltc = HBufC8::NewMaxLC(16);

   158 	TPtr8 salt(saltc->Des());

   159 	salt.FillZ();

   160 	TRAPD(err, rand->GenerateBytesL(salt));

   161 	if((err != KErrNone) && (err != KErrNotSecure))

   162 		User::Leave(err);

   164 	HBufC8* ivc = HBufC8::NewMaxLC(8);

   166 	TPtr8 iv(ivc->Des());

   167 	iv.FillZ();

   168 	//rand->GenerateBytesL(iv);

   170 	CPBEncryptParms* params = CPBEncryptParms::NewLC(ECipher3DES_CBC, salt, iv, 2048);

   171 	CPBEncryptElement* encryptElement = CPBEncryptElement::NewLC(pass, *params);

   172 	CPBEncryptor* encryptor = encryptElement->NewEncryptLC();

   174 	CASN1EncSequence* seq =  TASN1EncPKCS8::EncodeEncryptedL(priv, *encryptor, *params);

   176 	CleanupStack::PopAndDestroy(encryptor);

   177 	CleanupStack::PopAndDestroy(encryptElement);

   178 	CleanupStack::PopAndDestroy(params);

   179 	CleanupStack::PopAndDestroy(ivc);

   180 	CleanupStack::PopAndDestroy(saltc);

   181 	CleanupStack::PopAndDestroy(rand);

   183 	CleanupStack::PushL(seq);

   184 	_LIT(fn, "ExportedDSA_Encrypted.txt");

   185 	Pkcs8Utils::WriteSequenceL(fn, *seq);

   186 	CleanupStack::PopAndDestroy(seq);

   187 	}

   190 LOCAL_D void DoTestsDSAL(CDecPKCS8Data& decoded)

   191 {

   192 	CPKCS8KeyPairDSA* keypair = static_cast<CPKCS8KeyPairDSA*>(decoded.KeyPairData());

   194 	const CDSAPrivateKey& priv = keypair->PrivateKey();

   196 	// Now Export it

   197 	CASN1EncSequence* seq =  TASN1EncPKCS8::EncodeL(priv);

   199 	CleanupStack::PushL(seq);

   200 	Pkcs8Utils::WriteSequenceL(_L("ExportedDSA.txt"), *seq);

   201 	CleanupStack::PopAndDestroy(seq);

   202 }

   204 LOCAL_D void DoTestsRSAL(CDecPKCS8Data& decoded)

   205 {

   206 	CPKCS8KeyPairRSA* keypair = static_cast<CPKCS8KeyPairRSA*>(decoded.KeyPairData());

   208 	const CRSAPrivateKeyCRT& priv = static_cast<const CRSAPrivateKeyCRT&>(keypair->PrivateKey());

   210 	const CRSAPublicKey& pub = keypair->PublicKey();

   212 	// Now Export it

   213 	CASN1EncSequence* seq =  TASN1EncPKCS8::EncodeL(priv, pub);

   215 	CleanupStack::PushL(seq);

   216 	Pkcs8Utils::WriteSequenceL(_L("ExportedRSA.txt"), *seq);

   217 	CleanupStack::PopAndDestroy(seq);

   218 }

   221 LOCAL_D void DoTestsRSAEncryptedL(CDecPKCS8Data& decoded)

   222 {

   223 	CPKCS8KeyPairRSA* keypair = static_cast<CPKCS8KeyPairRSA*>(decoded.KeyPairData());

   225 	const CRSAPrivateKeyCRT& priv = static_cast<const CRSAPrivateKeyCRT&>(keypair->PrivateKey());

   226 	const CRSAPublicKey& pub = keypair->PublicKey();

   228 	TPBPassword pass(_L(""));

   230 	CSystemRandom* rand = CSystemRandom::NewLC();

   231 	HBufC8* saltc = HBufC8::NewMaxLC(16);

   232 	TPtr8 salt(saltc->Des());

   233 	salt.FillZ();

   234 	TRAPD(err, rand->GenerateBytesL(salt));

   235 	if((err != KErrNone) && (err != KErrNotSecure))

   236 		User::Leave(err);

   238 	HBufC8* ivc = HBufC8::NewMaxLC(8);

   240 	TPtr8 iv(ivc->Des());

   241 	iv.FillZ();

   242 	TRAP(err, rand->GenerateBytesL(iv));

   243 	if((err != KErrNone) && (err != KErrNotSecure))

   244 		User::Leave(err);

   246 	CPBEncryptParms* params = CPBEncryptParms::NewLC(ECipher3DES_CBC, salt, iv, 2048);

   247 	CPBEncryptElement* encryptElement = CPBEncryptElement::NewLC(pass, *params);

   248 	CPBEncryptor* encryptor = encryptElement->NewEncryptLC();

   250 	CASN1EncSequence* seq =  TASN1EncPKCS8::EncodeEncryptedL(priv, pub, *encryptor, *params);

   252 	CleanupStack::PopAndDestroy(encryptor);

   253 	CleanupStack::PopAndDestroy(encryptElement);

   254 	CleanupStack::PopAndDestroy(params);

   255 	CleanupStack::PopAndDestroy(ivc);

   256 	CleanupStack::PopAndDestroy(saltc);

   257 	CleanupStack::PopAndDestroy(rand);

   259 	CleanupStack::PushL(seq);

   260 	_LIT(fn, "ExportedRSA_Encrypted.txt");

   261 	Pkcs8Utils::WriteSequenceL(fn, *seq);

   262 	CleanupStack::PopAndDestroy(seq);

   263 }

   266 /**

   267  * 1st parameter dsa cleartext key

   268  * 2nd parameter dsa encrypted key

   269  * 3rd parameter rsa cleartext key

   270  * 4th parameter rsa encrypted key

   271  */

   272 LOCAL_D void DoTestsL()

   273 {

   274 	HBufC* fileName = Pkcs8Utils::GetArgumentL(0);

   275 	CleanupStack::PushL(fileName);

   277 	CDecPKCS8Data* decoded = Pkcs8Utils::getPkcsDataL(*fileName);

   278 	CleanupStack::PopAndDestroy(fileName);

   280 	CleanupStack::PushL(decoded);

   281 	DoTestsDSAL(*decoded);

   283 	DoTestsDSAEncryptedL(*decoded);

   284 	CleanupStack::PopAndDestroy(decoded);

   286 	 fileName = Pkcs8Utils::GetArgumentL(1);

   287 	CleanupStack::PushL(fileName);

   289 	decoded = Pkcs8Utils::getPkcsDataL(*fileName);

   290 	CleanupStack::PopAndDestroy(fileName);

   292 	CleanupStack::PushL(decoded);

   293 	DoTestsRSAL(*decoded);

   295 	DoTestsRSAEncryptedL(*decoded);

   296 	CleanupStack::PopAndDestroy(decoded);

   297 }

   299 LOCAL_C void  ProcessL()

   300 	{

   301 	HBufC* arg = Pkcs8Utils::GetArgumentL(0);

   302 	_LIT(attr, "-attribute");

   303 	if (arg->Find(attr)!=KErrNotFound)

   304 		{

   305 		TRAPD(err, GenerateAndSaveL(*Pkcs8Utils::GetArgumentL(1), *Pkcs8Utils::GetArgumentL(2)));

   306 		}

   307 	else

   308 		{

   309 		TRAPD(err, DoTestsL());

   310 		}

   311 	delete arg;

   312 	}

   316 /**

   317 * Command line parameters are

   318 * [0] -attribute [1] pkcs8 original file name [2] output file name

   319 * or

   320 * ...

   321 */

   322 GLDEF_C TInt E32Main() // main function called by E32

   323     {

   324 	__UHEAP_MARK;

   325 	CTrapCleanup* cleanup=CTrapCleanup::New(); // get clean-up stack

   327 	TRAPD(err, ProcessL());

   329 	delete cleanup; // destroy clean-up stack

   330 	__UHEAP_MARKEND;

   331 	return 0; // and return

   332     }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--