diff options
Diffstat (limited to 'chromium/net/cert/x509_cert_types_unittest.cc')
| -rw-r--r-- | chromium/net/cert/x509_cert_types_unittest.cc | 243 |
1 files changed, 243 insertions, 0 deletions
diff --git a/chromium/net/cert/x509_cert_types_unittest.cc b/chromium/net/cert/x509_cert_types_unittest.cc new file mode 100644 index 00000000000..38fd3e95266 --- /dev/null +++ b/chromium/net/cert/x509_cert_types_unittest.cc @@ -0,0 +1,243 @@ +// Copyright (c) 2010 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 "net/cert/x509_cert_types.h" + +#include "base/basictypes.h" +#include "base/strings/string_piece.h" +#include "base/time/time.h" +#include "net/test/test_certificate_data.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace net { + +namespace { + +#if defined(OS_MACOSX) && !defined(OS_IOS) +TEST(X509TypesTest, Matching) { + CertPrincipal spamco; + spamco.common_name = "SpamCo Dept. Of Certificization"; + spamco.country_name = "EB"; + spamco.organization_names.push_back("SpamCo Holding Company, LLC"); + spamco.organization_names.push_back("SpamCo Evil Masterminds"); + spamco.organization_unit_names.push_back("Class Z Obfuscation Authority"); + ASSERT_TRUE(spamco.Matches(spamco)); + + CertPrincipal bogus; + EXPECT_FALSE(bogus.Matches(spamco)); + EXPECT_FALSE(spamco.Matches(bogus)); + + bogus = spamco; + EXPECT_TRUE(bogus.Matches(spamco)); + EXPECT_TRUE(spamco.Matches(bogus)); + + bogus.organization_names.erase(bogus.organization_names.begin(), + bogus.organization_names.end()); + EXPECT_FALSE(bogus.Matches(spamco)); + EXPECT_FALSE(spamco.Matches(bogus)); + + bogus.organization_names.push_back("SpamCo Holding Company, LLC"); + bogus.organization_names.push_back("SpamCo Evil Masterminds"); + EXPECT_TRUE(bogus.Matches(spamco)); + EXPECT_TRUE(spamco.Matches(bogus)); + + bogus.locality_name = "Elbosdorf"; + EXPECT_FALSE(bogus.Matches(spamco)); + EXPECT_FALSE(spamco.Matches(bogus)); + + bogus.locality_name = ""; + bogus.organization_unit_names.push_back("Q Division"); + EXPECT_FALSE(bogus.Matches(spamco)); + EXPECT_FALSE(spamco.Matches(bogus)); +} +#endif + +#if (defined(OS_MACOSX) && !defined(OS_IOS)) || defined(OS_WIN) +TEST(X509TypesTest, ParseDNVerisign) { + CertPrincipal verisign; + EXPECT_TRUE(verisign.ParseDistinguishedName(VerisignDN, sizeof(VerisignDN))); + EXPECT_EQ("", verisign.common_name); + EXPECT_EQ("US", verisign.country_name); + ASSERT_EQ(1U, verisign.organization_names.size()); + EXPECT_EQ("VeriSign, Inc.", verisign.organization_names[0]); + ASSERT_EQ(1U, verisign.organization_unit_names.size()); + EXPECT_EQ("Class 1 Public Primary Certification Authority", + verisign.organization_unit_names[0]); +} + +TEST(X509TypesTest, ParseDNStartcom) { + CertPrincipal startcom; + EXPECT_TRUE(startcom.ParseDistinguishedName(StartComDN, sizeof(StartComDN))); + EXPECT_EQ("StartCom Certification Authority", startcom.common_name); + EXPECT_EQ("IL", startcom.country_name); + ASSERT_EQ(1U, startcom.organization_names.size()); + EXPECT_EQ("StartCom Ltd.", startcom.organization_names[0]); + ASSERT_EQ(1U, startcom.organization_unit_names.size()); + EXPECT_EQ("Secure Digital Certificate Signing", + startcom.organization_unit_names[0]); +} + +TEST(X509TypesTest, ParseDNUserTrust) { + CertPrincipal usertrust; + EXPECT_TRUE(usertrust.ParseDistinguishedName(UserTrustDN, + sizeof(UserTrustDN))); + EXPECT_EQ("UTN-USERFirst-Client Authentication and Email", + usertrust.common_name); + EXPECT_EQ("US", usertrust.country_name); + EXPECT_EQ("UT", usertrust.state_or_province_name); + EXPECT_EQ("Salt Lake City", usertrust.locality_name); + ASSERT_EQ(1U, usertrust.organization_names.size()); + EXPECT_EQ("The USERTRUST Network", usertrust.organization_names[0]); + ASSERT_EQ(1U, usertrust.organization_unit_names.size()); + EXPECT_EQ("http://www.usertrust.com", + usertrust.organization_unit_names[0]); +} + +TEST(X509TypesTest, ParseDNTurkTrust) { + // Note: This tests parsing UTF8STRINGs. + CertPrincipal turktrust; + EXPECT_TRUE(turktrust.ParseDistinguishedName(TurkTrustDN, + sizeof(TurkTrustDN))); + EXPECT_EQ("TÜRKTRUST Elektronik Sertifika Hizmet Sağlayıcısı", + turktrust.common_name); + EXPECT_EQ("TR", turktrust.country_name); + EXPECT_EQ("Ankara", turktrust.locality_name); + ASSERT_EQ(1U, turktrust.organization_names.size()); + EXPECT_EQ("TÜRKTRUST Bilgi İletişim ve Bilişim Güvenliği Hizmetleri A.Ş. (c) Kasım 2005", + turktrust.organization_names[0]); +} + +TEST(X509TypesTest, ParseDNATrust) { + // Note: This tests parsing 16-bit BMPSTRINGs. + CertPrincipal atrust; + EXPECT_TRUE(atrust.ParseDistinguishedName(ATrustQual01DN, + sizeof(ATrustQual01DN))); + EXPECT_EQ("A-Trust-Qual-01", + atrust.common_name); + EXPECT_EQ("AT", atrust.country_name); + ASSERT_EQ(1U, atrust.organization_names.size()); + EXPECT_EQ("A-Trust Ges. für Sicherheitssysteme im elektr. Datenverkehr GmbH", + atrust.organization_names[0]); + ASSERT_EQ(1U, atrust.organization_unit_names.size()); + EXPECT_EQ("A-Trust-Qual-01", + atrust.organization_unit_names[0]); +} + +TEST(X509TypesTest, ParseDNEntrust) { + // Note: This tests parsing T61STRINGs and fields with multiple values. + CertPrincipal entrust; + EXPECT_TRUE(entrust.ParseDistinguishedName(EntrustDN, + sizeof(EntrustDN))); + EXPECT_EQ("Entrust.net Certification Authority (2048)", + entrust.common_name); + EXPECT_EQ("", entrust.country_name); + ASSERT_EQ(1U, entrust.organization_names.size()); + EXPECT_EQ("Entrust.net", + entrust.organization_names[0]); + ASSERT_EQ(2U, entrust.organization_unit_names.size()); + EXPECT_EQ("www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)", + entrust.organization_unit_names[0]); + EXPECT_EQ("(c) 1999 Entrust.net Limited", + entrust.organization_unit_names[1]); +} +#endif + +const struct CertDateTestData { + CertDateFormat format; + const char* date_string; + bool is_valid; + base::Time::Exploded expected_result; +} kCertDateTimeData[] = { + { CERT_DATE_FORMAT_UTC_TIME, + "120101000000Z", + true, + { 2012, 1, 0, 1, 0, 0, 0 } }, + { CERT_DATE_FORMAT_GENERALIZED_TIME, + "20120101000000Z", + true, + { 2012, 1, 0, 1, 0, 0, 0 } }, + { CERT_DATE_FORMAT_UTC_TIME, + "490101000000Z", + true, + { 2049, 1, 0, 1, 0, 0, 0 } }, + { CERT_DATE_FORMAT_UTC_TIME, + "500101000000Z", + true, + { 1950, 1, 0, 1, 0, 0, 0 } }, + { CERT_DATE_FORMAT_GENERALIZED_TIME, + "19500101000000Z", + true, + { 1950, 1, 0, 1, 0, 0, 0 } }, + { CERT_DATE_FORMAT_UTC_TIME, + "AB0101000000Z", + false, + { 0 } }, + { CERT_DATE_FORMAT_GENERALIZED_TIME, + "19AB0101000000Z", + false, + { 0 } }, + { CERT_DATE_FORMAT_UTC_TIME, + "", + false, + { 0 } }, + { CERT_DATE_FORMAT_UTC_TIME, + "A", + false, + { 0 } }, + { CERT_DATE_FORMAT_GENERALIZED_TIME, + "20121301000000Z", + false, + { 0 } }, + { CERT_DATE_FORMAT_GENERALIZED_TIME, + "20120101123000Z", + true, + { 2012, 1, 0, 1, 12, 30, 0 } }, +}; + +// GTest pretty printer. +void PrintTo(const CertDateTestData& data, std::ostream* os) { + *os << " format: " << data.format + << "; date string: " << base::StringPiece(data.date_string) + << "; valid: " << data.is_valid + << "; expected date: " + << (data.is_valid ? + base::Time::FromUTCExploded(data.expected_result) + .ToInternalValue() : + 0U); +} + +class X509CertTypesDateTest : public testing::TestWithParam<CertDateTestData> { + public: + virtual ~X509CertTypesDateTest() {} + virtual void SetUp() { + test_data_ = GetParam(); + } + + protected: + CertDateTestData test_data_; +}; + +TEST_P(X509CertTypesDateTest, Parse) { + base::Time parsed_date; + bool parsed = ParseCertificateDate( + test_data_.date_string, test_data_.format, &parsed_date); + EXPECT_EQ(test_data_.is_valid, parsed); + if (!test_data_.is_valid) + return; + // Convert the expected value to a base::Time(). This ensures that systems + // systems that only support 32-bit times will pass the tests, by ensuring at + // least that the times have the same truncating behaviour. + // Note: Compared as internal values so that mismatches can be cleanly + // printed by GTest (eg: without PrintTo overrides). + EXPECT_EQ(base::Time::FromUTCExploded(test_data_.expected_result) + .ToInternalValue(), + parsed_date.ToInternalValue()); +} +INSTANTIATE_TEST_CASE_P(, + X509CertTypesDateTest, + testing::ValuesIn(kCertDateTimeData)); + +} // namespace + +} // namespace net |