Parse individual X.509 name components on Windows, rather than their stringified form

net/base/x509_certificate_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/pickle.h"
 #include "base/sha1.h"
 #include "base/string_number_conversions.h"
@@ skipping 357 matching lines @@
   EXPECT_TRUE(verify_result.cert_status & CERT_STATUS_IS_EV);
   // Consequently, if we don't have revocation checking enabled, we can't claim
   // any cert is EV.
   flags = X509Certificate::VERIFY_EV_CERT;
   EXPECT_EQ(OK, thawte_cert->Verify("www.thawte.com", flags, NULL,
                                     &verify_result));
   EXPECT_FALSE(verify_result.cert_status & CERT_STATUS_IS_EV);
 #endif
 }
 
+// Test that all desired AttributeAndValue pairs can be extracted when only
+// a single RelativeDistinguishedName is present. "Normally" there is only
+// one AVA per RDN, but some CAs place all AVAs within a single RDN.
+// This is a regression test for http://crbug.com/101009
+TEST(X509CertificateTest, InfonotaryCertParsing) {
+  FilePath certs_dir = GetTestCertsDirectory();
+
+  scoped_refptr<X509Certificate> infonotary_cert =
+      ImportCertFromFile(certs_dir, "infonotary.pem");
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), infonotary_cert);
+
+  const CertPrincipal& subject = infonotary_cert->subject();
+  EXPECT_EQ("Vladislav Ivanov Evgeniev", subject.common_name);
+  EXPECT_EQ("", subject.locality_name);
+  EXPECT_EQ("", subject.state_or_province_name);
+  EXPECT_EQ("", subject.country_name);
+  EXPECT_EQ(0U, subject.street_addresses.size());
+  EXPECT_EQ(0U, subject.organization_names.size());
+  EXPECT_EQ(0U, subject.organization_unit_names.size());
+  ASSERT_EQ(1U, subject.domain_components.size());
+  EXPECT_EQ("identity-ca", subject.domain_components[0]);
+
+  const CertPrincipal& issuer = infonotary_cert->issuer();
+  EXPECT_EQ("i-Notary TrustPath Validated Identity CA", issuer.common_name);
+  EXPECT_EQ("", issuer.locality_name);
+  EXPECT_EQ("", issuer.state_or_province_name);
+  EXPECT_EQ("BG", issuer.country_name);
+  EXPECT_EQ(0U, issuer.street_addresses.size());
+  ASSERT_EQ(1U, issuer.organization_names.size());
+  EXPECT_EQ("InfoNotary PLC", issuer.organization_names[0]);
+  ASSERT_EQ(1U, issuer.organization_unit_names.size());
+  EXPECT_EQ("i-Notary TrustPath Validated Identity CA",
+            issuer.organization_unit_names[0]);
+  ASSERT_EQ(1U, issuer.domain_components.size());
+  EXPECT_EQ("identity-ca", issuer.domain_components[0]);
+}
+
+// Test that characters which would normally be escaped in the string form,
+// such as = or ", are not escaped when parsed as individual components.

[wtc, 2011/12/01 23:59:41]

Nit: put = and " in single quotes?

+// This is a regression test for http://crbug.com/102839
+TEST(X509CertificateTest, BonaireCertParsing) {
+  FilePath certs_dir = GetTestCertsDirectory();
+
+  scoped_refptr<X509Certificate> bonairexl_cert =
+      ImportCertFromFile(certs_dir, "bonairexl.pem");
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), bonairexl_cert);
+
+  const CertPrincipal& subject = bonairexl_cert->subject();
+  EXPECT_EQ("www.bonairexl.com", subject.common_name);
+  EXPECT_EQ("Bergen", subject.locality_name);
+  EXPECT_EQ("Noord-Holland", subject.state_or_province_name);
+  EXPECT_EQ("NL", subject.country_name);
+  ASSERT_EQ(1U, subject.street_addresses.size());
+  EXPECT_EQ("Eeuwigelaan 3", subject.street_addresses[0]);
+  ASSERT_EQ(1U, subject.organization_names.size());
+  EXPECT_EQ("Aan Zee \"Gezellige Vakantiehuizen\" B.V.",
+            subject.organization_names[0]);
+  ASSERT_EQ(2U, subject.organization_unit_names.size());
+  EXPECT_EQ("ICT", subject.organization_unit_names[0]);
+  EXPECT_EQ("COMODO EV SSL", subject.organization_unit_names[1]);
+  EXPECT_EQ(0U, subject.domain_components.size());
+
+  const CertPrincipal& issuer = bonairexl_cert->issuer();
+  EXPECT_EQ("COMODO Extended Validation Secure Server CA", issuer.common_name);
+  EXPECT_EQ("Salford", issuer.locality_name);
+  EXPECT_EQ("Greater Manchester", issuer.state_or_province_name);
+  EXPECT_EQ("GB", issuer.country_name);
+  EXPECT_EQ(0U, issuer.street_addresses.size());
+  ASSERT_EQ(1U, issuer.organization_names.size());
+  EXPECT_EQ("COMODO CA Limited", issuer.organization_names[0]);
+  EXPECT_EQ(0U, issuer.organization_unit_names.size());
+  EXPECT_EQ(0U, issuer.domain_components.size());
+}
+
 TEST(X509CertificateTest, PaypalNullCertParsing) {
   scoped_refptr<X509Certificate> paypal_null_cert(
       X509Certificate::CreateFromBytes(
           reinterpret_cast<const char*>(paypal_null_der),
           sizeof(paypal_null_der)));
 
   ASSERT_NE(static_cast<X509Certificate*>(NULL), paypal_null_cert);
 
   const SHA1Fingerprint& fingerprint =
       paypal_null_cert->fingerprint();
@@ skipping 1313 matching lines @@
 #define MAYBE_VerifyMixed DISABLED_VerifyMixed
 #else
 #define MAYBE_VerifyMixed VerifyMixed
 #endif
 WRAPPED_INSTANTIATE_TEST_CASE_P(
     MAYBE_VerifyMixed,
     X509CertificateWeakDigestTest,
     testing::ValuesIn(kVerifyMixedTestData));
 
 }  // namespace net