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 *

    16 */

    17 

    18 

    19 #include "tcertwriter.h"

    20 #include <x509keys.h>

    21 #include <asn1dec.h>

    22 

    23 EXPORT_C CertWriter::CertWriter(Output* aOut)

    24 	:iOut(aOut)

    25 	{

    26 	}

    27 

    28 EXPORT_C void CertWriter::SetOut(Output* aOut)

    29 	{

    30 	iOut = aOut;

    31 	}

    32 

    33 EXPORT_C void CertWriter::WriteCert(const CX509Certificate& aCertificate)

    34 	{

    35 

    36 	CX509Certificate* cert = CX509Certificate::NewLC(aCertificate);

    37 //	iOut->writeString(_L("\n Certificate Version = ")):

    38 //	iOut->writeNum(cert->Version());

    39 //	iOut.writeNewLine();

    40 	WriteEncodings(*cert);

    41 	iOut->writeNewLine();	

    42 	ShowSerialNumber(cert->SerialNumber());

    43 	ShowValidityPeriod(*cert);

    44 	iOut->writeString(_L("Issuer Name = "));

    45 	iOut->writeNewLine();	

    46 	ShowDN(cert->IssuerName());	

    47 	iOut->writeString(_L("Subject Name = "));

    48 	iOut->writeNewLine();	

    49 	ShowDN(cert->SubjectName());

    50 	ShowSigningAlgorithm(cert->SigningAlgorithm());

    51 	ShowExtensions(*cert);

    52 	ShowPublicKey(*cert);

    53 	iOut->writeNewLine();	

    54 	ShowFingerprint(*cert);

    55 	ShowSignature(*cert);

    56 

    57 /*	CalculateSignature(*cert);

    58 	if (IsSelfSigned(*cert))

    59 		{

    60 		iOut->writeString(_L("\nSelf-signed\n"));

    61 		}

    62 	else

    63 		{

    64 		iOut->writeString(_L("\nNot self-signed\n"));

    65 		}

    66 */

    67 	

    68 	iOut->writeString(_L("Short Issuer Name = "));

    69 	HBufC* issuer = cert->IssuerL();

    70 	iOut->writeString(*issuer);

    71 	iOut->writeNewLine();

    72 	delete issuer;

    73 

    74 	iOut->writeString(_L("Short Subject Name = "));

    75 	HBufC* subject = cert->SubjectL();

    76 	iOut->writeString(*subject);

    77 	iOut->writeNewLine();

    78 	delete subject;

    79 

    80 	iOut->writeNewLine();

    81 	CleanupStack::PopAndDestroy();//cert

    82 	}

    83 

    84 EXPORT_C void CertWriter::ShowPublicKey(const CX509Certificate& aCertificate)

    85 	{

    86 	const CSubjectPublicKeyInfo& spki = aCertificate.PublicKey();

    87 	switch(spki.AlgorithmId())

    88 		{

    89 		case ERSA:

    90 			ShowRSAKey(spki);

    91 			break;

    92 			

    93 		case EDSA:

    94 			ShowDSAKey(spki);

    95 			break;

    96 		

    97 		case EDH:

    98 			ShowDHKey(spki);

    99 			break;

   100 			

   101 		default:

   102 			User::Panic(_L("CertWriter"), 1);

   103 			break;

   104 		}

   105 	}

   106 

   107 

   108 void CertWriter::ShowRSAKey(const CSubjectPublicKeyInfo& aSpki)

   109 	{

   110 	CX509RSAPublicKey* key = CX509RSAPublicKey::NewLC(aSpki.KeyData());

   111 	iOut->writeString(_L("RSA Key:"));

   112 	iOut->writeNewLine();

   113 	iOut->writeSpaces(4);

   114 	iOut->writeString(_L("Modulus = "));

   115 	iOut->writeNewLine();

   116 	const TInteger& mod = key->N();

   117 	HBufC8* mBuf = mod.BufferLC();

   118 	iOut->writeOctetStringL(mBuf->Des());

   119 	iOut->writeNewLine();	

   120 

   121 	iOut->writeSpaces(4);

   122 	iOut->writeString(_L("Exponent = "));

   123 	iOut->writeNewLine();

   124 	const TInteger& exp = key->E();

   125 	HBufC8* eBuf = exp.BufferLC();

   126 	iOut->writeOctetStringL(eBuf->Des());

   127 	iOut->writeNewLine();	

   128 	CleanupStack::PopAndDestroy(eBuf);

   129 	CleanupStack::PopAndDestroy(mBuf);

   130 	CleanupStack::PopAndDestroy(key);

   131 	}

   132 

   133 void CertWriter::ShowDSAKey(const CSubjectPublicKeyInfo& aSpki)

   134 	{

   135 	const TDesC8& encParams = aSpki.EncodedParams();

   136 	if (encParams.Length() != 0)

   137 		{

   138 		CDSAPublicKey* key = CX509DSAPublicKey::NewLC(encParams, aSpki.KeyData());

   139 		iOut->writeString(_L("DSA Key:"));

   140 		iOut->writeNewLine();

   141 		iOut->writeSpaces(4);

   142 		iOut->writeString(_L("Y = "));

   143 		iOut->writeNewLine();

   144 		const TInteger& y = key->Y();

   145 		HBufC8* yBuf = y.BufferLC();

   146 		iOut->writeOctetStringL(yBuf->Des());

   147 		iOut->writeNewLine();	

   148 

   149 		iOut->writeSpaces(4);

   150 		iOut->writeString(_L("Params = "));

   151 		iOut->writeNewLine();

   152 

   153 		iOut->writeSpaces(8);

   154 		iOut->writeString(_L("P = "));

   155 		iOut->writeNewLine();

   156 		const TInteger& p = key->P();

   157 		HBufC8* pBuf = p.BufferLC();

   158 		iOut->writeOctetStringL(pBuf->Des());

   159 		iOut->writeNewLine();

   160 

   161 		iOut->writeSpaces(8);

   162 		iOut->writeString(_L("Q = "));

   163 		iOut->writeNewLine();

   164 		const TInteger& q = key->Q();

   165 		HBufC8* qBuf = q.BufferLC();

   166 		iOut->writeOctetStringL(qBuf->Des());

   167 		iOut->writeNewLine();

   168 

   169 		iOut->writeSpaces(8);

   170 		iOut->writeString(_L("G = "));

   171 		iOut->writeNewLine();

   172 		const TInteger& g = key->G();

   173 		HBufC8* gBuf = g.BufferLC();

   174 		iOut->writeOctetStringL(gBuf->Des());

   175 		iOut->writeNewLine();

   176 

   177 		CleanupStack::PopAndDestroy(5);

   178 		}

   179 	}

   180 

   181 void CertWriter::ShowDHKey(const CSubjectPublicKeyInfo& aSpki)

   182 	{

   183 	TASN1DecInteger encInt;

   184 	TInt pos = 0;

   185 	RInteger keyVal = encInt.DecodeDERLongL(aSpki.KeyData(), pos);

   186 	CleanupStack::PushL(keyVal);

   187 	HBufC8* keyValBuf = keyVal.BufferLC();

   188 	iOut->writeString(_L("Y = "));

   189 	iOut->writeNewLine();

   190 	iOut->writeOctetStringL(keyValBuf->Des());

   191 	CleanupStack::PopAndDestroy(2, &keyVal);

   192 

   193 	CX509DHDomainParams* params = CX509DHDomainParams::NewLC(aSpki.EncodedParams());

   194 	const TInteger& p = params->P();

   195 	const TInteger& g = params->G();

   196 	const TInteger& q = params->Q();

   197 	const TInteger& j = params->J();

   198 	const CX509DHValidationParams* valParams = params->ValidationParams();

   199 

   200 	iOut->writeNewLine();

   201 	iOut->writeString(_L("Params = "));

   202 	iOut->writeNewLine();

   203 

   204 	iOut->writeString(_L("P = "));

   205 	iOut->writeNewLine();

   206 	HBufC8* pBuf = p.BufferLC();

   207 	iOut->writeOctetStringL(pBuf->Des());

   208 	iOut->writeNewLine();

   209 	CleanupStack::PopAndDestroy();

   210 

   211 	iOut->writeString(_L("G = "));

   212 	iOut->writeNewLine();

   213 	HBufC8* gBuf = g.BufferLC();

   214 	iOut->writeOctetStringL(gBuf->Des());

   215 	iOut->writeNewLine();

   216 	CleanupStack::PopAndDestroy();

   217 

   218 	iOut->writeString(_L("Q = "));

   219 	iOut->writeNewLine();

   220 	HBufC8* qBuf = q.BufferLC();

   221 	iOut->writeOctetStringL(qBuf->Des());

   222 	iOut->writeNewLine();

   223 	CleanupStack::PopAndDestroy();

   224 

   225 	iOut->writeString(_L("J = "));

   226 	iOut->writeNewLine();

   227 	HBufC8* jBuf = j.BufferLC();

   228 	iOut->writeOctetStringL(jBuf->Des());

   229 	iOut->writeNewLine();

   230 	CleanupStack::PopAndDestroy();

   231 		

   232 	if (valParams)

   233 		{

   234 		iOut->writeString(_L("Seed = "));

   235 		iOut->writeNewLine();

   236 		iOut->writeOctetStringL(valParams->Seed());

   237 		iOut->writeNewLine();

   238 		const TInteger& pGC = valParams->PGenCounter();

   239 		HBufC8* pgBuf = pGC.BufferLC();

   240 		iOut->writeString(_L("pGenCounter = "));

   241 		iOut->writeNewLine();

   242 		iOut->writeOctetStringL(pgBuf->Des());

   243 		iOut->writeNewLine();

   244 		CleanupStack::PopAndDestroy();

   245 		}

   246 	CleanupStack::PopAndDestroy();

   247 	}

   248 

   249 

   250 EXPORT_C void CertWriter::ShowSigningAlgorithm(const CSigningAlgorithmIdentifier& aSigningAlgorithm)

   251 	{

   252 	iOut->writeString(_L("Signed using: "));

   253 	iOut->writeNewLine();

   254 	iOut->writeSpaces(4);

   255 	iOut->writeString(_L("Asymmetric algorithm = "));

   256 	const CAlgorithmIdentifier& algId = aSigningAlgorithm.AsymmetricAlgorithm();

   257 	switch(algId.Algorithm())

   258 		{

   259 		case ERSA:

   260 			iOut->writeString(_L("RSA"));

   261 			break;

   262 		

   263 		case EDSA:

   264 			iOut->writeString(_L("DSA"));

   265 			break;

   266 		

   267 		case EDH:

   268 			iOut->writeString(_L("DH"));

   269 			break;

   270 						

   271 		default:

   272 			User::Panic(_L("CertWriter"), 1);

   273 			break;

   274 		}

   275 	iOut->writeNewLine();

   276 	iOut->writeSpaces(4);

   277 	iOut->writeString(_L("Digest algorithm = "));

   278 	const CAlgorithmIdentifier& digestId = aSigningAlgorithm.DigestAlgorithm();

   279 	switch(digestId.Algorithm())

   280 		{

   281 		case EMD2:

   282 			iOut->writeString(_L("MD2"));

   283 			break;

   284 		

   285 		case EMD5:

   286 			iOut->writeString(_L("MD5"));

   287 			break;

   288 		

   289 		case ESHA1:

   290 			iOut->writeString(_L("SHA1"));

   291 			break;

   292 		

   293 		default:

   294 			User::Panic(_L("CertWriter"), 1);

   295 			break;

   296 		}

   297 	iOut->writeNewLine();

   298 	}

   299 

   300 EXPORT_C void CertWriter::ShowSerialNumber(const TPtrC8& aSerialNumber)

   301 	{

   302 	iOut->writeString(_L("Serial Number = "));

   303 	iOut->writeOctetStringL(aSerialNumber);

   304 	iOut->writeNewLine();

   305 	}

   306 

   307 //dn display code

   308 EXPORT_C void CertWriter::ShowAVA(const CX520AttributeTypeAndValue& aAva)

   309 	{

   310 	iOut->writeString(aAva.Type());

   311 	HBufC* val = aAva.ValueL();

   312 	CleanupStack::PushL(val);

   313 	iOut->writeString(_L(" = "));

   314 	iOut->writeString(val->Des());

   315 	CleanupStack::PopAndDestroy();

   316 	}

   317 

   318 EXPORT_C void CertWriter::ShowDN(const CX500DistinguishedName& aName)

   319 	{

   320 	iOut->writeNewLine();

   321 	TInt count = aName.Count();

   322 	for (TInt i = 0; i < count; i++)

   323 		{

   324   		const CX520AttributeTypeAndValue& ava = aName.Element(i);

   325 		iOut->writeSpaces(4);

   326 		ShowAVA(ava);

   327 		iOut->writeNewLine();

   328 		}

   329 	}

   330 

   331 EXPORT_C void CertWriter::ShowAKI(const CX509Certificate& aCert)

   332 	{

   333 	const CX509CertExtension* akiExt = aCert.Extension(KAuthorityKeyId);

   334 	if (akiExt)

   335 		{

   336 		iOut->writeString(_L("Authority Key ID = "));

   337 		iOut->writeNewLine();

   338 		const CX509AuthorityKeyIdExt* ext = CX509AuthorityKeyIdExt::NewLC(akiExt->Data());

   339 		const CArrayPtrFlat<CX509GeneralName>& authorityName = ext->AuthorityName();

   340 		TInt count = authorityName.Count();

   341 		if (count > 0)

   342 			{

   343 			iOut->writeSpaces(4);

   344 			iOut->writeString(_L("Authority name = "));

   345 			iOut->writeNewLine();

   346 			for (TInt i = 0; i < count; i++)

   347 				{

   348 				ShowGN(*(authorityName.At(i)));

   349 				}

   350 			}

   351 		if (ext->AuthorityCertSerialNumber().Length() > 0)

   352 			{

   353 			iOut->writeSpaces(4);

   354 			iOut->writeString(_L("Authority cert serial no = "));

   355 			iOut->writeOctetStringL(ext->AuthorityCertSerialNumber());

   356 			iOut->writeNewLine();

   357 			}

   358 		iOut->writeSpaces(4);

   359 		iOut->writeString(_L("Key Id = "));

   360 		iOut->writeOctetStringL(ext->KeyId());

   361 		iOut->writeNewLine();

   362 		CleanupStack::PopAndDestroy();

   363 		}

   364 	}

   365 

   366 EXPORT_C void CertWriter::ShowSKI(const CX509Certificate& aCert)

   367 	{

   368 	const CX509CertExtension* skiExt = aCert.Extension(KSubjectKeyId);

   369 	if (skiExt)

   370 		{

   371 		iOut->writeString(_L("Subject Key ID = "));

   372 		iOut->writeNewLine();

   373 		const CX509SubjectKeyIdExt* ext = CX509SubjectKeyIdExt::NewLC(skiExt->Data());

   374 		iOut->writeSpaces(4);

   375 		iOut->writeString(_L("Key Id = "));

   376 		iOut->writeOctetStringL(ext->KeyId());

   377 		iOut->writeNewLine();

   378 		CleanupStack::PopAndDestroy();

   379 		}

   380 	}

   381 

   382 EXPORT_C void CertWriter::ShowGN(const CX509GeneralName& aName)

   383 	{

   384 	iOut->writeSpaces(4);

   385 	switch(aName.Tag())

   386 		{

   387 		case 1:

   388 			{

   389 			//rfc822

   390 			CX509RFC822NameSubtree* email = CX509RFC822NameSubtree::NewLC(aName.Data());

   391 			iOut->writeString(email->Name());

   392 			iOut->writeNewLine();

   393 			CleanupStack::PopAndDestroy();//email

   394 			break;

   395 			}

   396 		case 2:

   397 			{

   398 			//dns name

   399 			CX509DNSNameSubtree* dns = CX509DNSNameSubtree::NewLC(aName.Data());

   400 			iOut->writeString(dns->Name());

   401 			CleanupStack::PopAndDestroy();//dns

   402 			break;

   403 			}

   404 		case 4:

   405 			{

   406 			//DN

   407 			CX500DistinguishedName* dN = CX500DistinguishedName::NewLC(aName.Data());

   408 			ShowDN(*dN);

   409 			CleanupStack::PopAndDestroy();

   410 			break;

   411 			}

   412 		case 6:

   413 			{

   414 			//uri

   415 			CX509IPBasedURI* uri = CX509IPBasedURI::NewLC(aName.Data());

   416 			iOut->writeString(uri->Name());

   417 			iOut->writeNewLine();

   418 			iOut->writeString(_L("Host="));

   419 			iOut->writeString(uri->Host().Name());

   420 			iOut->writeNewLine();

   421 			CleanupStack::PopAndDestroy();//uri

   422 			break;

   423 			}

   424 		case 7:

   425 			{

   426 			CX509IPAddress* ip = CX509IPAddress::NewLC(aName.Data());

   427 			TPtrC8 addressStr(ip->Address());

   428 			// IPv6 output not implemented yet

   429 			iOut->write(_L("IP=%d.%d.%d.%d"), addressStr[0], addressStr[1], addressStr[2], addressStr[3]);

   430 			iOut->writeNewLine();			

   431 			CleanupStack::PopAndDestroy();

   432 			break;

   433 			}

   434 		}

   435 	}

   436 

   437 

   438 EXPORT_C void CertWriter::ShowFingerprint(const CX509Certificate& aCertificate)

   439 	{

   440 	iOut->writeString(_L("Fingerprint:"));

   441 	iOut->writeNewLine();

   442 	iOut->writeOctetString(aCertificate.Fingerprint());

   443 	iOut->writeNewLine();

   444 	}

   445 

   446 EXPORT_C void CertWriter::ShowValidityPeriod(const CX509Certificate& aCertificate)

   447 	{

   448 	const CValidityPeriod& vp = aCertificate.ValidityPeriod();

   449 	iOut->writeString(_L("Validity Period = "));

   450 	iOut->writeNewLine();

   451 	const TTime& start = vp.Start();

   452 	const TTime& finish = vp.Finish();

   453 	TBuf<30> dateString1;

   454 	start.FormatL(dateString1,(_L("%H%:1%T:%S %*E%*D %X%*N%Y %1 %2 %3")));

   455 

   456 	iOut->writeSpaces(4);

   457 	iOut->writeString(_L("Valid From = "));

   458 	iOut->writeString(dateString1);

   459 	iOut->writeNewLine();

   460 

   461 	TBuf<30> dateString2;

   462 	finish.FormatL(dateString2,(_L("%H%:1%T:%S %*E%*D %X%*N%Y %1 %2 %3")));

   463 

   464 	iOut->writeSpaces(4);

   465 	iOut->writeString(_L("Valid Until = "));

   466 

   467 	iOut->writeString(dateString2);

   468 	iOut->writeNewLine();

   469 	}

   470 

   471 //extensions

   472 EXPORT_C void CertWriter::ShowExtensions(const CX509Certificate& aCertificate)

   473 	{

   474 	const CArrayPtrFlat<CX509CertExtension>& exts = aCertificate.Extensions();

   475 	TInt count = exts.Count();

   476 	for (TInt i = 0; i < count; i++)

   477 		{

   478 		const CX509CertExtension* ext = exts.At(i);

   479 		iOut->writeString(_L("extension"));

   480 		iOut->writeNum(i);

   481 		if (!(ext->Critical()))

   482 			{

   483 			iOut->writeString(_L(" not"));

   484 			}

   485 		iOut->writeString(_L(" critical"));

   486 		iOut->writeString(_L(" ID = "));

   487 		TPtrC id(ext->Id());

   488 		iOut->writeString(id);

   489 		iOut->writeNewLine();

   490 		if (id == KBasicConstraints)

   491 			{

   492 			ShowBC(*ext);

   493 			}

   494 		if (id == KSubjectAltName)

   495 			{

   496 			iOut->writeString(_L("SubjectAltName: "));

   497 			iOut->writeNewLine();

   498 			ShowAltName(*ext);

   499 			}

   500 		if (id == KIssuerAltName)

   501 			{

   502 			iOut->writeString(_L("IssuerAltName: "));

   503 			iOut->writeNewLine();

   504 			ShowAltName(*ext);

   505 			}

   506 		if (id == KKeyUsage)

   507 			{

   508 			ShowKU(*ext);

   509 			}

   510 		if (id == KNameConstraints)

   511 			{

   512 			ShowNC(*ext);

   513 			}

   514 		if (id == KPolicyConstraints)

   515 			{

   516 			ShowPC(*ext);

   517 			}

   518 		if (id == KCertPolicies)

   519 			{

   520 			ShowCP(*ext);

   521 			}

   522 		if (id == KPolicyMapping)

   523 			{

   524 			ShowPM(*ext);

   525 			}

   526 		if (id == KAuthorityKeyId)

   527 			{

   528 			ShowAKI(aCertificate);

   529 			}

   530 		if (id == KSubjectKeyId)

   531 			{

   532 			ShowSKI(aCertificate);

   533 			}

   534 		if (id == KExtendedKeyUsage)

   535 			{

   536 			ShowEKU(*ext);

   537 			}

   538 		}

   539 	}

   540 

   541 EXPORT_C void CertWriter::ShowBC(const CX509CertExtension& aExt)

   542 	{

   543 	iOut->writeString(_L("Basic Constraints:"));

   544 	iOut->writeNewLine();

   545 	CX509BasicConstraintsExt* ext = CX509BasicConstraintsExt::NewLC(aExt.Data());

   546 	if (ext->IsCA())

   547 		{

   548 		iOut->writeSpaces(4);

   549 		iOut->writeString(_L("CA cert"));

   550 		iOut->writeNewLine();

   551 		if (ext->MaxChainLength() < KMaxTInt)

   552 			{

   553 			iOut->writeSpaces(4);

   554 			iOut->writeString(_L("Max Chain Length = "));

   555 			iOut->writeNum(ext->MaxChainLength());

   556 			iOut->writeNewLine();

   557 			}

   558 		}

   559 	else

   560 		{

   561 		iOut->writeSpaces(4);

   562 		iOut->writeString(_L("EE cert"));

   563 		iOut->writeNewLine();

   564 		}

   565 	CleanupStack::PopAndDestroy();

   566 	}

   567 

   568 EXPORT_C void CertWriter::ShowAltName(const CX509CertExtension& aExt)

   569 	{

   570 	CX509AltNameExt* ext = CX509AltNameExt::NewLC(aExt.Data());

   571 	const CArrayPtrFlat<CX509GeneralName>& names = ext->AltName();

   572 	TInt count = names.Count();

   573 	for (TInt i = 0; i < count; i++)

   574 		{

   575 		ShowGN(*(names.At(i)));

   576 		}

   577 	CleanupStack::PopAndDestroy();

   578 	}

   579 

   580 

   581 _LIT(KDigSig, "digital signature");

   582 _LIT(KNonRep, "non-repudiation");

   583 _LIT(KKeyEnc, "key encipherment");

   584 _LIT(KDataEnc, "data encipherment");

   585 _LIT(KKeyAgree, "key agreement");

   586 _LIT(KCertSign, "key cert sign");

   587 _LIT(KCRLSign, "crl sign");

   588 _LIT(KEnciph, "encipher only");

   589 _LIT(KDeciph, "decipher only");

   590 

   591 EXPORT_C void CertWriter::ShowKU(const CX509CertExtension& aExt)

   592 	{

   593 	iOut->writeString(_L("Key Usage:"));

   594 	iOut->writeNewLine();

   595 	CX509KeyUsageExt* ext = CX509KeyUsageExt::NewLC(aExt.Data());

   596 		if (ext->IsSet(EX509DigitalSignature))

   597 			{

   598 			iOut->writeSpaces(4);

   599 			iOut->writeString(KDigSig);

   600 			iOut->writeNewLine();

   601 			}

   602 		if (ext->IsSet(EX509NonRepudiation))

   603 			{

   604 			iOut->writeSpaces(4);

   605 			iOut->writeString(KNonRep);

   606 			iOut->writeNewLine();

   607 			}

   608 		if (ext->IsSet(EX509KeyEncipherment))

   609 			{

   610 			iOut->writeSpaces(4);

   611 			iOut->writeString(KKeyEnc);

   612 			iOut->writeNewLine();

   613 			}

   614 		if (ext->IsSet(EX509DataEncipherment))

   615 			{

   616 			iOut->writeSpaces(4);

   617 			iOut->writeString(KDataEnc);

   618 			iOut->writeNewLine();

   619 			}

   620 		if (ext->IsSet(EX509KeyAgreement))

   621 			{

   622 			iOut->writeSpaces(4);

   623 			iOut->writeString(KKeyAgree);

   624 			iOut->writeNewLine();

   625 			}

   626 		if (ext->IsSet(EX509KeyCertSign))

   627 			{

   628 			iOut->writeSpaces(4);

   629 			iOut->writeString(KCertSign);

   630 			iOut->writeNewLine();

   631 			}

   632 		if (ext->IsSet(EX509CRLSign))

   633 			{

   634 			iOut->writeSpaces(4);

   635 			iOut->writeString(KCRLSign);

   636 			iOut->writeNewLine();

   637 			}

   638 		if (ext->IsSet(EX509EncipherOnly))

   639 			{

   640 			iOut->writeSpaces(4);

   641 			iOut->writeString(KEnciph);

   642 			iOut->writeNewLine();

   643 			}

   644 		if (ext->IsSet(EX509DecipherOnly))

   645 			{

   646 			iOut->writeSpaces(4);

   647 			iOut->writeString(KDeciph);

   648 			iOut->writeNewLine();

   649 			}		

   650 	CleanupStack::PopAndDestroy();//ext

   651 	}

   652 

   653 EXPORT_C void CertWriter::ShowSubtrees(const CArrayPtrFlat<CX509GeneralSubtree>& aSubtrees)

   654 	{

   655 	TInt count = aSubtrees.Count();

   656 	for (TInt i = 0; i < count; i++)

   657 		{

   658 		const CX509GeneralSubtree* subtree = aSubtrees.At(i);

   659 		ShowGN(subtree->Name());

   660 		///!!!!!don't write these outFile either!!

   661 		}

   662 	}

   663 

   664 EXPORT_C void CertWriter::ShowNC(const CX509CertExtension& aExt)

   665 	{//!!!!don't write these outFile

   666 

   667 	CX509NameConstraintsExt* ext = CX509NameConstraintsExt::NewLC(aExt.Data());

   668 	ShowSubtrees(ext->ExcludedSubtrees());

   669 	ShowSubtrees(ext->PermittedSubtrees());

   670 	CleanupStack::PopAndDestroy();

   671 	}

   672 

   673 EXPORT_C void CertWriter::ShowPC(const CX509CertExtension& /*aExt*/)

   674 	{//!!!!don't write these outFile

   675 //	CX509PolicyConstraintsExt* ext = CX509PolicyConstraintsExt::NewLC(aExt.Data());

   676 //	TX509PolicyConstraint required = ext->ExplicitPolicyRequired();

   677 //	TX509PolicyConstraint mapping = ext->InhibitPolicyMapping();

   678 //	CleanupStack::PopAndDestroy();

   679 	}

   680 

   681 EXPORT_C void CertWriter::ShowCP(const CX509CertExtension& aExt)

   682 	{

   683 	iOut->writeString(_L("Cert Policies = "));

   684 	iOut->writeNewLine();

   685 

   686 	CX509CertPoliciesExt* ext = CX509CertPoliciesExt::NewLC(aExt.Data());

   687 	const CArrayPtrFlat<CX509CertPolicyInfo>& policies = ext->Policies();

   688 	TInt count = policies.Count();

   689 	for (TInt i = 0; i < count; i++)

   690 		{

   691 		const CX509CertPolicyInfo* policy = policies.At(i);

   692 		

   693 		iOut->writeSpaces(4);

   694 		iOut->writeString(_L("Policy ID = "));

   695 		iOut->writeString(policy->Id());

   696 		iOut->writeNewLine();

   697 		const CArrayPtrFlat<CX509PolicyQualifierInfo>& qualifiers = policy->Qualifiers();

   698 		TInt qCount = qualifiers.Count();

   699 

   700 		if (qCount > 0)

   701 			{

   702 

   703 			iOut->writeSpaces(4);

   704 			iOut->writeString(_L("Qualified by: "));

   705 			iOut->writeNewLine();

   706 			}

   707 

   708 		for (TInt i = 0; i < qCount; i++)

   709 			{

   710 			iOut->writeSpaces(8);

   711 			iOut->writeString(_L("Qualifier ID = "));

   712 			iOut->writeString(policy->Id());

   713 			iOut->writeNewLine();

   714 			}

   715 		}

   716 	CleanupStack::PopAndDestroy();//ext

   717 	}

   718 

   719 EXPORT_C void CertWriter::ShowPM(const CX509CertExtension& aExt)

   720 	{

   721 	iOut->writeString(_L("Policy Mappings = "));

   722 	CX509PolicyMappingExt* ext = CX509PolicyMappingExt::NewLC(aExt.Data());

   723 	const CArrayPtrFlat<CX509PolicyMapping>& mappings = ext->Mappings();

   724 	TInt count = mappings.Count();

   725 	for (TInt i = 0; i < count; i++)

   726 		{

   727 		const CX509PolicyMapping* mapping = mappings.At(i);

   728 		iOut->writeString(_L("Issuer Policy = "));

   729 		iOut->writeString(mapping->IssuerPolicy());

   730 		iOut->writeNewLine();

   731 		iOut->writeString(_L("Subject Policy = "));

   732 		iOut->writeString(mapping->SubjectPolicy());

   733 		iOut->writeNewLine();

   734 		}

   735 	iOut->writeNewLine();

   736 	CleanupStack::PopAndDestroy();

   737 	}

   738 

   739 

   740 EXPORT_C void CertWriter::ShowEKU(const CX509CertExtension& aExt)

   741 	{

   742 	iOut->writeString(_L("Extended Key Usage = "));

   743 	iOut->writeNewLine();

   744 

   745 	CX509ExtendedKeyUsageExt* ext = CX509ExtendedKeyUsageExt::NewLC(aExt.Data());

   746 	const CArrayPtrFlat<HBufC>& usages = ext->KeyUsages();

   747 	TInt count = usages.Count();

   748 	for (TInt i = 0; i < count; i++)

   749 		{

   750 		iOut->writeSpaces(4);

   751 		iOut->writeString(usages.At(i)->Des());

   752 		iOut->writeNewLine();

   753 		}

   754 	CleanupStack::PopAndDestroy();

   755 	}

   756 

   757 EXPORT_C void CertWriter::ShowSignature(const CX509Certificate& aCert)

   758 	{

   759 	iOut->writeString(_L("Signature:"));

   760 	iOut->writeNewLine();

   761 	const TPtrC8 sig = aCert.Signature();

   762 	iOut->writeOctetStringL(sig);

   763 	iOut->writeNewLine();

   764 	}

   765 

   766 void CertWriter::CalculateSignature(const CX509Certificate& aCert)

   767 	{

   768 	TBool res = EFalse;;

   769 	TRAPD(err, res = aCert.VerifySignatureL(aCert.PublicKey().KeyData()));

   770 	if (err != KErrNone)

   771 		{

   772 		iOut->writeString(_L("\nsignature verification could not be performed\n"));

   773 		if (err != KErrArgument)

   774 			{

   775 			User::Leave(err);

   776 			}

   777 		}

   778 	else

   779 		{

   780 		if (res)

   781 			{

   782 			iOut->writeString(_L("\nself-signed\n"));

   783 			}

   784 		else

   785 			{

   786 			iOut->writeString(_L("\n not self-signed\n"));

   787 			}

   788 		}

   789 	}

   790 

   791 EXPORT_C TBool CertWriter::IsSelfSigned(const CX509Certificate& aCert)

   792 	{

   793 	TBool res = EFalse;

   794 	const CX500DistinguishedName& subject = aCert.SubjectName();

   795 	if (subject.Count() > 0)

   796 		{

   797 		res = subject.ExactMatchL(aCert.IssuerName());

   798 		}

   799 	else

   800 		{

   801 		const CX509CertExtension* subjectExt = aCert.Extension(KIssuerAltName);

   802 		const CX509CertExtension* issuerExt = aCert.Extension(KSubjectAltName);

   803 		if ((!subjectExt) || (!issuerExt))

   804 			{

   805 			}

   806 		else

   807 			{

   808 			const CX509AltNameExt* issuerAltName = CX509AltNameExt::NewLC(subjectExt->Data());

   809 			const CX509AltNameExt* subjectAltName = CX509AltNameExt::NewLC(issuerExt->Data());

   810 			if (subjectAltName->Match(*issuerAltName))

   811 				{

   812 				res = ETrue;

   813 				}

   814 			CleanupStack::PopAndDestroy(2);//subjectAltName, issuerAltName

   815 			}		

   816 		}

   817 	return res;

   818 	}

   819 /*		EVersionNumber = 0,

   820 		ESerialNumber = 1,

   821 		EAlgorithmId = 2,

   822 		EIssuerName = 3,

   823 		EValidityPeriod = 4,

   824 		ESubjectName = 5,

   825 		ESubjectPublicKeyInfo = 6,

   826 		EIssuerUID = 7,

   827 		ESubjectUID = 8,

   828 		EExtensionList = 9

   829 */

   830 void CertWriter::WriteEncodings(const CX509Certificate& aCertificate)

   831 	{

   832 	iOut->writeString(_L("Version:"));

   833 	iOut->writeNewLine();

   834 	WriteEncoding(aCertificate, CX509Certificate::EVersionNumber);

   835 	iOut->writeNewLine();

   836 

   837 	iOut->writeString(_L("Serial Number:"));

   838 	iOut->writeNewLine();

   839 	WriteEncoding(aCertificate, CX509Certificate::ESerialNumber);

   840 	iOut->writeNewLine();

   841 

   842 	iOut->writeString(_L("Algorithm:"));

   843 	iOut->writeNewLine();

   844 	WriteEncoding(aCertificate, CX509Certificate::EAlgorithmId);

   845 	iOut->writeNewLine();

   846 

   847 	iOut->writeString(_L("Issuer:"));

   848 	iOut->writeNewLine();

   849 	WriteEncoding(aCertificate, CX509Certificate::EIssuerName);

   850 	iOut->writeNewLine();

   851 

   852 	iOut->writeString(_L("Validity:"));

   853 	iOut->writeNewLine();

   854 	WriteEncoding(aCertificate, CX509Certificate::EValidityPeriod);

   855 	iOut->writeNewLine();

   856 

   857 	iOut->writeString(_L("Subject:"));

   858 	iOut->writeNewLine();

   859 	WriteEncoding(aCertificate, CX509Certificate::ESubjectName);

   860 	iOut->writeNewLine();

   861 

   862 	iOut->writeString(_L("Public Key:"));

   863 	iOut->writeNewLine();

   864 	WriteEncoding(aCertificate, CX509Certificate::ESubjectPublicKeyInfo);

   865 	iOut->writeNewLine();

   866 

   867 	iOut->writeString(_L("Issuer ID:"));

   868 	iOut->writeNewLine();

   869 	WriteEncoding(aCertificate, CX509Certificate::EIssuerUID);

   870 	iOut->writeNewLine();

   871 	

   872 	iOut->writeString(_L("Subject ID:"));

   873 	iOut->writeNewLine();

   874 	WriteEncoding(aCertificate, CX509Certificate::ESubjectUID);

   875 	iOut->writeNewLine();

   876 

   877 	iOut->writeString(_L("Extensions:"));

   878 	iOut->writeNewLine();

   879 	WriteEncoding(aCertificate, CX509Certificate::EExtensionList);

   880 	iOut->writeNewLine();

   881 	}

   882 

   883 void CertWriter::WriteEncoding(const CX509Certificate& aCertificate, const TUint aIndex)

   884 	{

   885 	if (aCertificate.DataElementEncoding(aIndex))

   886 		{

   887 		iOut->writeOctetStringL(*(aCertificate.DataElementEncoding(aIndex)));

   888 		}

   889 	}