Bring the handling of <keygen> and support for the application/x-x509-user-ce...

net/base/x509_certificate_unittest.cc

 // Copyright (c) 2006-2008 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 "net/base/cert_status_flags.h"
 #include "net/base/cert_test_util.h"
@@ skipping 73 matching lines @@
   certs_dir = certs_dir.AppendASCII("net");
   certs_dir = certs_dir.AppendASCII("data");
   certs_dir = certs_dir.AppendASCII("ssl");
   certs_dir = certs_dir.AppendASCII("certificates");
   return certs_dir;
 }
 
 // Imports a certificate file in the src/net/data/ssl/certificates directory.
 // certs_dir represents the test certificates directory.  cert_file is the
 // name of the certificate file.
-X509Certificate* ImportCertFromFile(const FilePath& certs_dir,
-                                    const std::string& cert_file) {
+X509Certificate* ImportCertFromFile(
+    const FilePath& certs_dir,
+    const std::string& cert_file,
+    X509Certificate::CertificateFormat format) {
   FilePath cert_path = certs_dir.AppendASCII(cert_file);
   std::string cert_data;
   if (!file_util::ReadFileToString(cert_path, &cert_data))
     return NULL;
-  return X509Certificate::CreateFromBytes(cert_data.data(), cert_data.size());
+  return X509Certificate::CreateFromBytes(cert_data.data(), cert_data.size(),
+                                          format);
 }
 
-}  // namespace
-
-TEST(X509CertificateTest, GoogleCertParsing) {
-  scoped_refptr<X509Certificate> google_cert = X509Certificate::CreateFromBytes(
-      reinterpret_cast<const char*>(google_der), sizeof(google_der));
-
+void CheckGoogleCert(const scoped_refptr<X509Certificate>& google_cert,
+                     unsigned char* expected_fingerprint,
+                     double valid_from, double valid_to,
+                     bool check_chain) {
   ASSERT_NE(static_cast<X509Certificate*>(NULL), google_cert);
 
   const X509Certificate::Principal& subject = google_cert->subject();
   EXPECT_EQ("www.google.com", subject.common_name);
   EXPECT_EQ("Mountain View", subject.locality_name);
   EXPECT_EQ("California", subject.state_or_province_name);
   EXPECT_EQ("US", subject.country_name);
   EXPECT_EQ(0U, subject.street_addresses.size());
   EXPECT_EQ(1U, subject.organization_names.size());
   EXPECT_EQ("Google Inc", subject.organization_names[0]);
   EXPECT_EQ(0U, subject.organization_unit_names.size());
   EXPECT_EQ(0U, subject.domain_components.size());
 
   const X509Certificate::Principal& issuer = google_cert->issuer();
   EXPECT_EQ("Thawte SGC CA", issuer.common_name);
   EXPECT_EQ("", issuer.locality_name);
   EXPECT_EQ("", issuer.state_or_province_name);
   EXPECT_EQ("ZA", issuer.country_name);
   EXPECT_EQ(0U, issuer.street_addresses.size());
   EXPECT_EQ(1U, issuer.organization_names.size());
   EXPECT_EQ("Thawte Consulting (Pty) Ltd.", issuer.organization_names[0]);
   EXPECT_EQ(0U, issuer.organization_unit_names.size());
   EXPECT_EQ(0U, issuer.domain_components.size());
 
   // Use DoubleT because its epoch is the same on all platforms
   const Time& valid_start = google_cert->valid_start();
-  EXPECT_EQ(1238192407, valid_start.ToDoubleT());  // Mar 27 22:20:07 2009 GMT
+  EXPECT_EQ(valid_from, valid_start.ToDoubleT());
 
   const Time& valid_expiry = google_cert->valid_expiry();
-  EXPECT_EQ(1269728407, valid_expiry.ToDoubleT());  // Mar 27 22:20:07 2010 GMT
+  EXPECT_EQ(valid_to, valid_expiry.ToDoubleT());
 
   const X509Certificate::Fingerprint& fingerprint = google_cert->fingerprint();
   for (size_t i = 0; i < 20; ++i)
-    EXPECT_EQ(google_fingerprint[i], fingerprint.data[i]);
+    EXPECT_EQ(expected_fingerprint[i], fingerprint.data[i]);
 
   std::vector<std::string> dns_names;
   google_cert->GetDNSNames(&dns_names);
   EXPECT_EQ(1U, dns_names.size());
   EXPECT_EQ("www.google.com", dns_names[0]);
 
 #if TEST_EV
   // TODO(avi): turn this on for the Mac once EV checking is implemented.
   CertVerifyResult verify_result;
   int flags = X509Certificate::VERIFY_REV_CHECKING_ENABLED |
                 X509Certificate::VERIFY_EV_CERT;
   EXPECT_EQ(OK, google_cert->Verify("www.google.com", flags, &verify_result));
   EXPECT_EQ(0, verify_result.cert_status & CERT_STATUS_IS_EV);
 #endif
 }
 
+// The fingerprint for the parse tests is different than the fingerprint
+// included in test_certificate_data.h, as the parse test certificate is more
+// recent.
+unsigned char google_parse_fingerprint[] = {
+  0x40, 0x50, 0x62, 0xe5, 0xbe, 0xfd, 0xe4, 0xaf, 0x97, 0xe9, 0x38, 0x2a,
+  0xf1, 0x6c, 0xc8, 0x7c, 0x8f, 0xb7, 0xc4, 0xe2
+};
+
+// Dec 18 00:00:00 2009 GMT
+const double kGoogleParseValidFrom = 1261094400;
+// Dec 18 23:59:59 2011 GMT
+const double kGoogleParseValidTo = 1324252799;
+
+struct CertificateFormatTestData {
+  const char* file_name;
+  X509Certificate::CertificateFormat format;
+  bool should_test_chain;
+};
+
+const CertificateFormatTestData FormatTestData[] = {
+  { "google.der", X509Certificate::FORMAT_DER, false },
+  { "google.single.pem", X509Certificate::FORMAT_DER, false },
+
+  { "google.single.pem", X509Certificate::FORMAT_PEM, false },
+  { "google.chain.pem", X509Certificate::FORMAT_PEM, true },
+
+  { "google.binary.p7b", X509Certificate::FORMAT_PKCS7, true },
+  { "google.pem_cert.p7b", X509Certificate::FORMAT_PKCS7, true },
+  { "google.pem_pkcs7.p7b", X509Certificate::FORMAT_PKCS7, true },
+
+  { "google.der", X509Certificate::FORMAT_AUTO, false },
+  { "google.single.pem", X509Certificate::FORMAT_AUTO, false },
+  { "google.single.pem", X509Certificate::FORMAT_AUTO, false },
+  { "google.chain.pem", X509Certificate::FORMAT_AUTO, true },
+  { "google.binary.p7b", X509Certificate::FORMAT_AUTO, true },
+  { "google.pem_cert.p7b", X509Certificate::FORMAT_AUTO, true },
+  { "google.pem_pkcs7.p7b", X509Certificate::FORMAT_AUTO, true }
+};
+
+}  // namespace
+
+TEST(X509CertificateTest, GoogleCertParsing) {
+  scoped_refptr<X509Certificate> google_cert =
+      X509Certificate::CreateFromBytes(
+          reinterpret_cast<const char*>(google_der), sizeof(google_der),
+          X509Certificate::FORMAT_DER);
+
+  CheckGoogleCert(google_cert, google_fingerprint,
+                  1238192407,  // Mar 27 22:20:07 2009 GMT
+                  1269728407,  // Mar 27 22:20:07 2010 GMT
+                  false);
+}
+
 TEST(X509CertificateTest, WebkitCertParsing) {
   scoped_refptr<X509Certificate> webkit_cert = X509Certificate::CreateFromBytes(
-      reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der));
+      reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der),
+      X509Certificate::FORMAT_DER);
 
   ASSERT_NE(static_cast<X509Certificate*>(NULL), webkit_cert);
 
   const X509Certificate::Principal& subject = webkit_cert->subject();
   EXPECT_EQ("Cupertino", subject.locality_name);
   EXPECT_EQ("California", subject.state_or_province_name);
   EXPECT_EQ("US", subject.country_name);
   EXPECT_EQ(0U, subject.street_addresses.size());
   EXPECT_EQ(1U, subject.organization_names.size());
   EXPECT_EQ("Apple Inc.", subject.organization_names[0]);
@@ skipping 35 matching lines @@
   int flags = X509Certificate::VERIFY_REV_CHECKING_ENABLED |
                 X509Certificate::VERIFY_EV_CERT;
   CertVerifyResult verify_result;
   EXPECT_EQ(OK, webkit_cert->Verify("webkit.org", flags, &verify_result));
   EXPECT_EQ(0, verify_result.cert_status & CERT_STATUS_IS_EV);
 #endif
 }
 
 TEST(X509CertificateTest, ThawteCertParsing) {
   scoped_refptr<X509Certificate> thawte_cert = X509Certificate::CreateFromBytes(
-      reinterpret_cast<const char*>(thawte_der), sizeof(thawte_der));
+      reinterpret_cast<const char*>(thawte_der), sizeof(thawte_der),
+      X509Certificate::FORMAT_DER);
 
   ASSERT_NE(static_cast<X509Certificate*>(NULL), thawte_cert);
 
   const X509Certificate::Principal& subject = thawte_cert->subject();
   EXPECT_EQ("www.thawte.com", subject.common_name);
   EXPECT_EQ("Mountain View", subject.locality_name);
   EXPECT_EQ("California", subject.state_or_province_name);
   EXPECT_EQ("US", subject.country_name);
   EXPECT_EQ(0U, subject.street_addresses.size());
   EXPECT_EQ(1U, subject.organization_names.size());
@@ skipping 42 matching lines @@
   flags = X509Certificate::VERIFY_EV_CERT;
   EXPECT_EQ(OK, thawte_cert->Verify("www.thawte.com", flags, &verify_result));
   EXPECT_EQ(0, verify_result.cert_status & CERT_STATUS_IS_EV);
 #endif
 }
 
 TEST(X509CertificateTest, PaypalNullCertParsing) {
   scoped_refptr<X509Certificate> paypal_null_cert =
       X509Certificate::CreateFromBytes(
           reinterpret_cast<const char*>(paypal_null_der),
-          sizeof(paypal_null_der));
+          sizeof(paypal_null_der),
+          X509Certificate::FORMAT_DER);
 
   ASSERT_NE(static_cast<X509Certificate*>(NULL), paypal_null_cert);
 
   const X509Certificate::Fingerprint& fingerprint =
       paypal_null_cert->fingerprint();
   for (size_t i = 0; i < 20; ++i)
     EXPECT_EQ(paypal_null_fingerprint[i], fingerprint.data[i]);
 
   int flags = 0;
   CertVerifyResult verify_result;
   int error = paypal_null_cert->Verify("www.paypal.com", flags,
                                        &verify_result);
   EXPECT_NE(OK, error);
   // Either the system crypto library should correctly report a certificate
   // name mismatch, or our certificate blacklist should cause us to report an
   // invalid certificate.
 #if !defined(OS_MACOSX)
   EXPECT_NE(0, verify_result.cert_status &
             (CERT_STATUS_COMMON_NAME_INVALID | CERT_STATUS_INVALID));
 #endif
 }
 
 // A certificate whose AIA extension contains an LDAP URL without a host name.
 // This certificate will expire on 2011-09-08.
 TEST(X509CertificateTest, UnoSoftCertParsing) {
   FilePath certs_dir = GetTestCertsDirectory();
   scoped_refptr<X509Certificate> unosoft_hu_cert =
-      ImportCertFromFile(certs_dir, "unosoft_hu_cert.der");
+      ImportCertFromFile(certs_dir, "unosoft_hu_cert.der",
+                         X509Certificate::FORMAT_DER);
 
   ASSERT_NE(static_cast<X509Certificate*>(NULL), unosoft_hu_cert);
 
   const X509Certificate::Fingerprint& fingerprint =
       unosoft_hu_cert->fingerprint();
   for (size_t i = 0; i < 20; ++i)
     EXPECT_EQ(unosoft_hu_fingerprint[i], fingerprint.data[i]);
 
   int flags = 0;
   CertVerifyResult verify_result;
   int error = unosoft_hu_cert->Verify("www.unosoft.hu", flags,
                                       &verify_result);
   EXPECT_NE(OK, error);
   EXPECT_NE(0, verify_result.cert_status & CERT_STATUS_AUTHORITY_INVALID);
 }
 
 #if defined(USE_NSS)
 // A regression test for http://crbug.com/31497.
 // This certificate will expire on 2012-04-08.
 // TODO(wtc): we can't run this test on Mac because MacTrustedCertificates
 // can hold only one additional trusted root certificate for unit tests.
 // TODO(wtc): we can't run this test on Windows because LoadTemporaryRootCert
 // isn't implemented (http//crbug.com/8470).
 TEST(X509CertificateTest, IntermediateCARequireExplicitPolicy) {
   FilePath certs_dir = GetTestCertsDirectory();
 
   scoped_refptr<X509Certificate> server_cert =
-      ImportCertFromFile(certs_dir, "www_us_army_mil_cert.der");
+      ImportCertFromFile(certs_dir, "www_us_army_mil_cert.der",
+                         X509Certificate::FORMAT_DER);
   ASSERT_NE(static_cast<X509Certificate*>(NULL), server_cert);
 
   // The intermediate CA certificate's policyConstraints extension has a
   // requireExplicitPolicy field with SkipCerts=0.
   scoped_refptr<X509Certificate> intermediate_cert =
-      ImportCertFromFile(certs_dir, "dod_ca_17_cert.der");
+      ImportCertFromFile(certs_dir, "dod_ca_17_cert.der",
+                         X509Certificate::FORMAT_DER);
   ASSERT_NE(static_cast<X509Certificate*>(NULL), intermediate_cert);
 
   FilePath root_cert_path = certs_dir.AppendASCII("dod_root_ca_2_cert.der");
   scoped_refptr<X509Certificate> root_cert =
       LoadTemporaryRootCert(root_cert_path);
   ASSERT_NE(static_cast<X509Certificate*>(NULL), root_cert);
 
   int flags = 0;
   CertVerifyResult verify_result;
   int error = server_cert->Verify("www.us.army.mil", flags, &verify_result);
@@ skipping 54 matching lines @@
       reinterpret_cast<const char*>(google_der), sizeof(google_der));
   scoped_refptr<X509Certificate> cert5 = X509Certificate::CreateFromHandle(
       google_cert_handle, X509Certificate::SOURCE_FROM_NETWORK,
       X509Certificate::OSCertHandles());
 
   EXPECT_EQ(cert3, cert5);
 }
 
 TEST(X509CertificateTest, Pickle) {
   scoped_refptr<X509Certificate> cert1 = X509Certificate::CreateFromBytes(
-      reinterpret_cast<const char*>(google_der), sizeof(google_der));
+      reinterpret_cast<const char*>(google_der), sizeof(google_der),
+      X509Certificate::FORMAT_DER);
 
   Pickle pickle;
   cert1->Persist(&pickle);
 
   void* iter = NULL;
   scoped_refptr<X509Certificate> cert2 =
       X509Certificate::CreateFromPickle(pickle, &iter);
 
   EXPECT_EQ(cert1, cert2);
 }
 
 TEST(X509CertificateTest, Policy) {
   scoped_refptr<X509Certificate> google_cert = X509Certificate::CreateFromBytes(
-      reinterpret_cast<const char*>(google_der), sizeof(google_der));
+      reinterpret_cast<const char*>(google_der), sizeof(google_der),
+      X509Certificate::FORMAT_DER);
 
   scoped_refptr<X509Certificate> webkit_cert = X509Certificate::CreateFromBytes(
-      reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der));
+      reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der),
+      X509Certificate::FORMAT_DER);
 
   X509Certificate::Policy policy;
 
   EXPECT_EQ(policy.Check(google_cert.get()), X509Certificate::Policy::UNKNOWN);
   EXPECT_EQ(policy.Check(webkit_cert.get()), X509Certificate::Policy::UNKNOWN);
   EXPECT_FALSE(policy.HasAllowedCert());
   EXPECT_FALSE(policy.HasDeniedCert());
 
   policy.Allow(google_cert.get());
 
@@ skipping 10 matching lines @@
   EXPECT_TRUE(policy.HasDeniedCert());
 
   policy.Allow(webkit_cert.get());
 
   EXPECT_EQ(policy.Check(google_cert.get()), X509Certificate::Policy::DENIED);
   EXPECT_EQ(policy.Check(webkit_cert.get()), X509Certificate::Policy::ALLOWED);
   EXPECT_TRUE(policy.HasAllowedCert());
   EXPECT_TRUE(policy.HasDeniedCert());
 }
 
-#if defined(OS_MACOSX) || defined(OS_WIN)
 TEST(X509CertificateTest, IntermediateCertificates) {
   X509Certificate::OSCertHandle handle1, handle2, handle3, handle4;
 
   // Create object with no intermediates:
   handle1 = X509Certificate::CreateOSCertHandleFromBytes(
       reinterpret_cast<const char*>(google_der), sizeof(google_der));
   X509Certificate::OSCertHandles intermediates1;
   scoped_refptr<X509Certificate> cert1;
   cert1 = X509Certificate::CreateFromHandle(handle1,
       X509Certificate::SOURCE_FROM_NETWORK,
@@ skipping 20 matching lines @@
   // The cache should have stored cert2 'cause it has more intermediates:
   EXPECT_NE(cert1, cert2);
 
   // Verify it has all the intermediates:
   EXPECT_TRUE(cert2->HasIntermediateCertificate(handle2));
   EXPECT_TRUE(cert2->HasIntermediateCertificate(handle3));
   handle4 = X509Certificate::CreateOSCertHandleFromBytes(
       reinterpret_cast<const char*>(paypal_null_der), sizeof(paypal_null_der));
   EXPECT_FALSE(cert2->HasIntermediateCertificate(handle4));
 
+  X509Certificate::FreeOSCertHandle(handle2);
+  X509Certificate::FreeOSCertHandle(handle3);
+  X509Certificate::FreeOSCertHandle(handle4);
+
   // Create object with 1 intermediate:
   handle3 = X509Certificate::CreateOSCertHandleFromBytes(
       reinterpret_cast<const char*>(thawte_der), sizeof(thawte_der));
   X509Certificate::OSCertHandles intermediates3;
   intermediates2.push_back(handle3);
   scoped_refptr<X509Certificate> cert3;
   cert3 = X509Certificate::CreateFromHandle(
       X509Certificate::DupOSCertHandle(handle1),
       X509Certificate::SOURCE_FROM_NETWORK,
       intermediates3);
 
+  X509Certificate::FreeOSCertHandle(handle1);
+  X509Certificate::FreeOSCertHandle(handle3);
+
   // The cache should have returned cert2 'cause it has more intermediates:
   EXPECT_EQ(cert3, cert2);
 }
-#endif
+
+class X509CertificateParseTest :
+    public testing::TestWithParam<CertificateFormatTestData> {
+ public:
+  virtual ~X509CertificateParseTest() { }
+  virtual void SetUp() {
+    test_data_ = GetParam();
+  }
+  virtual void TearDown() { }
+
+ protected:
+  CertificateFormatTestData test_data_;
+};
+
+TEST_P(X509CertificateParseTest, CanParseFormat) {
+  FilePath certs_dir = GetTestCertsDirectory();
+  scoped_refptr<X509Certificate> google_cert =
+      ImportCertFromFile(certs_dir, test_data_.file_name, test_data_.format);
+  CheckGoogleCert(google_cert, google_parse_fingerprint,
+                  kGoogleParseValidFrom, kGoogleParseValidTo,
+                  test_data_.should_test_chain);
+}
+
+INSTANTIATE_TEST_CASE_P(, X509CertificateParseTest,
+                        testing::ValuesIn(FormatTestData));
 
 }  // namespace net