src/third_party/webrtc/base/sslidentity_unittest.cc

   1 /*
   2  *  Copyright 2011 The WebRTC Project Authors. All rights reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include <string>
  12
  13 #include "webrtc/base/gunit.h"
  14 #include "webrtc/base/ssladapter.h"
  15 #include "webrtc/base/sslidentity.h"
  16
  17 using rtc::SSLIdentity;
  18
  19 const char kTestCertificate[] = "-----BEGIN CERTIFICATE-----\n"
  20     "MIIB6TCCAVICAQYwDQYJKoZIhvcNAQEEBQAwWzELMAkGA1UEBhMCQVUxEzARBgNV\n"
  21     "BAgTClF1ZWVuc2xhbmQxGjAYBgNVBAoTEUNyeXB0U29mdCBQdHkgTHRkMRswGQYD\n"
  22     "VQQDExJUZXN0IENBICgxMDI0IGJpdCkwHhcNMDAxMDE2MjIzMTAzWhcNMDMwMTE0\n"
  23     "MjIzMTAzWjBjMQswCQYDVQQGEwJBVTETMBEGA1UECBMKUXVlZW5zbGFuZDEaMBgG\n"
  24     "A1UEChMRQ3J5cHRTb2Z0IFB0eSBMdGQxIzAhBgNVBAMTGlNlcnZlciB0ZXN0IGNl\n"
  25     "cnQgKDUxMiBiaXQpMFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJ+zw4Qnlf8SMVIP\n"
  26     "Fe9GEcStgOY2Ww/dgNdhjeD8ckUJNP5VZkVDTGiXav6ooKXfX3j/7tdkuD8Ey2//\n"
  27     "Kv7+ue0CAwEAATANBgkqhkiG9w0BAQQFAAOBgQCT0grFQeZaqYb5EYfk20XixZV4\n"
  28     "GmyAbXMftG1Eo7qGiMhYzRwGNWxEYojf5PZkYZXvSqZ/ZXHXa4g59jK/rJNnaVGM\n"
  29     "k+xIX8mxQvlV0n5O9PIha5BX5teZnkHKgL8aKKLKW1BK7YTngsfSzzaeame5iKfz\n"
  30     "itAE+OjGF+PFKbwX8Q==\n"
  31     "-----END CERTIFICATE-----\n";
  32
  33 const unsigned char kTestCertSha1[] = {0xA6, 0xC8, 0x59, 0xEA,
  34                                        0xC3, 0x7E, 0x6D, 0x33,
  35                                        0xCF, 0xE2, 0x69, 0x9D,
  36                                        0x74, 0xE6, 0xF6, 0x8A,
  37                                        0x9E, 0x47, 0xA7, 0xCA};
  38
  39 class SSLIdentityTest : public testing::Test {
  40  public:
  41   SSLIdentityTest() :
  42       identity1_(), identity2_() {
  43   }
  44
  45   ~SSLIdentityTest() {
  46   }
  47
  48   virtual void SetUp() {
  49     identity1_.reset(SSLIdentity::Generate("test1"));
  50     identity2_.reset(SSLIdentity::Generate("test2"));
  51
  52     ASSERT_TRUE(identity1_);
  53     ASSERT_TRUE(identity2_);
  54
  55     test_cert_.reset(
  56         rtc::SSLCertificate::FromPEMString(kTestCertificate));
  57     ASSERT_TRUE(test_cert_);
  58   }
  59
  60   void TestGetSignatureDigestAlgorithm() {
  61     std::string digest_algorithm;
  62     // Both NSSIdentity::Generate and OpenSSLIdentity::Generate are
  63     // hard-coded to generate RSA-SHA1 certificates.
  64     ASSERT_TRUE(identity1_->certificate().GetSignatureDigestAlgorithm(
  65         &digest_algorithm));
  66     ASSERT_EQ(rtc::DIGEST_SHA_1, digest_algorithm);
  67     ASSERT_TRUE(identity2_->certificate().GetSignatureDigestAlgorithm(
  68         &digest_algorithm));
  69     ASSERT_EQ(rtc::DIGEST_SHA_1, digest_algorithm);
  70
  71     // The test certificate has an MD5-based signature.
  72     ASSERT_TRUE(test_cert_->GetSignatureDigestAlgorithm(&digest_algorithm));
  73     ASSERT_EQ(rtc::DIGEST_MD5, digest_algorithm);
  74   }
  75
  76   void TestDigest(const std::string &algorithm, size_t expected_len,
  77                   const unsigned char *expected_digest = NULL) {
  78     unsigned char digest1[64];
  79     unsigned char digest1b[64];
  80     unsigned char digest2[64];
  81     size_t digest1_len;
  82     size_t digest1b_len;
  83     size_t digest2_len;
  84     bool rv;
  85
  86     rv = identity1_->certificate().ComputeDigest(algorithm,
  87                                                  digest1, sizeof(digest1),
  88                                                  &digest1_len);
  89     EXPECT_TRUE(rv);
  90     EXPECT_EQ(expected_len, digest1_len);
  91
  92     rv = identity1_->certificate().ComputeDigest(algorithm,
  93                                                  digest1b, sizeof(digest1b),
  94                                                  &digest1b_len);
  95     EXPECT_TRUE(rv);
  96     EXPECT_EQ(expected_len, digest1b_len);
  97     EXPECT_EQ(0, memcmp(digest1, digest1b, expected_len));
  98
  99
 100     rv = identity2_->certificate().ComputeDigest(algorithm,
 101                                                  digest2, sizeof(digest2),
 102                                                  &digest2_len);
 103     EXPECT_TRUE(rv);
 104     EXPECT_EQ(expected_len, digest2_len);
 105     EXPECT_NE(0, memcmp(digest1, digest2, expected_len));
 106
 107     // If we have an expected hash for the test cert, check it.
 108     if (expected_digest) {
 109       unsigned char digest3[64];
 110       size_t digest3_len;
 111
 112       rv = test_cert_->ComputeDigest(algorithm, digest3, sizeof(digest3),
 113                                     &digest3_len);
 114       EXPECT_TRUE(rv);
 115       EXPECT_EQ(expected_len, digest3_len);
 116       EXPECT_EQ(0, memcmp(digest3, expected_digest, expected_len));
 117     }
 118   }
 119
 120  private:
 121   rtc::scoped_ptr<SSLIdentity> identity1_;
 122   rtc::scoped_ptr<SSLIdentity> identity2_;
 123   rtc::scoped_ptr<rtc::SSLCertificate> test_cert_;
 124 };
 125
 126 TEST_F(SSLIdentityTest, DigestSHA1) {
 127   TestDigest(rtc::DIGEST_SHA_1, 20, kTestCertSha1);
 128 }
 129
 130 // HASH_AlgSHA224 is not supported in the chromium linux build.
 131 #if SSL_USE_NSS
 132 TEST_F(SSLIdentityTest, DISABLED_DigestSHA224) {
 133 #else
 134 TEST_F(SSLIdentityTest, DigestSHA224) {
 135 #endif
 136   TestDigest(rtc::DIGEST_SHA_224, 28);
 137 }
 138
 139 TEST_F(SSLIdentityTest, DigestSHA256) {
 140   TestDigest(rtc::DIGEST_SHA_256, 32);
 141 }
 142
 143 TEST_F(SSLIdentityTest, DigestSHA384) {
 144   TestDigest(rtc::DIGEST_SHA_384, 48);
 145 }
 146
 147 TEST_F(SSLIdentityTest, DigestSHA512) {
 148   TestDigest(rtc::DIGEST_SHA_512, 64);
 149 }
 150
 151 TEST_F(SSLIdentityTest, FromPEMStrings) {
 152   static const char kRSA_PRIVATE_KEY_PEM[] =
 153       "-----BEGIN RSA PRIVATE KEY-----\n"
 154       "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAMYRkbhmI7kVA/rM\n"
 155       "czsZ+6JDhDvnkF+vn6yCAGuRPV03zuRqZtDy4N4to7PZu9PjqrRl7nDMXrG3YG9y\n"
 156       "rlIAZ72KjcKKFAJxQyAKLCIdawKRyp8RdK3LEySWEZb0AV58IadqPZDTNHHRX8dz\n"
 157       "5aTSMsbbkZ+C/OzTnbiMqLL/vg6jAgMBAAECgYAvgOs4FJcgvp+TuREx7YtiYVsH\n"
 158       "mwQPTum2z/8VzWGwR8BBHBvIpVe1MbD/Y4seyI2aco/7UaisatSgJhsU46/9Y4fq\n"
 159       "2TwXH9QANf4at4d9n/R6rzwpAJOpgwZgKvdQjkfrKTtgLV+/dawvpxUYkRH4JZM1\n"
 160       "CVGukMfKNrSVH4Ap4QJBAOJmGV1ASPnB4r4nc99at7JuIJmd7fmuVUwUgYi4XgaR\n"
 161       "WhScBsgYwZ/JoywdyZJgnbcrTDuVcWG56B3vXbhdpMsCQQDf9zeJrjnPZ3Cqm79y\n"
 162       "kdqANep0uwZciiNiWxsQrCHztywOvbFhdp8iYVFG9EK8DMY41Y5TxUwsHD+67zao\n"
 163       "ZNqJAkEA1suLUP/GvL8IwuRneQd2tWDqqRQ/Td3qq03hP7e77XtF/buya3Ghclo5\n"
 164       "54czUR89QyVfJEC6278nzA7n2h1uVQJAcG6mztNL6ja/dKZjYZye2CY44QjSlLo0\n"
 165       "MTgTSjdfg/28fFn2Jjtqf9Pi/X+50LWI/RcYMC2no606wRk9kyOuIQJBAK6VSAim\n"
 166       "1pOEjsYQn0X5KEIrz1G3bfCbB848Ime3U2/FWlCHMr6ch8kCZ5d1WUeJD3LbwMNG\n"
 167       "UCXiYxSsu20QNVw=\n"
 168       "-----END RSA PRIVATE KEY-----\n";
 169
 170   static const char kCERT_PEM[] =
 171       "-----BEGIN CERTIFICATE-----\n"
 172       "MIIBmTCCAQKgAwIBAgIEbzBSAjANBgkqhkiG9w0BAQsFADARMQ8wDQYDVQQDEwZX\n"
 173       "ZWJSVEMwHhcNMTQwMTAyMTgyNDQ3WhcNMTQwMjAxMTgyNDQ3WjARMQ8wDQYDVQQD\n"
 174       "EwZXZWJSVEMwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMYRkbhmI7kVA/rM\n"
 175       "czsZ+6JDhDvnkF+vn6yCAGuRPV03zuRqZtDy4N4to7PZu9PjqrRl7nDMXrG3YG9y\n"
 176       "rlIAZ72KjcKKFAJxQyAKLCIdawKRyp8RdK3LEySWEZb0AV58IadqPZDTNHHRX8dz\n"
 177       "5aTSMsbbkZ+C/OzTnbiMqLL/vg6jAgMBAAEwDQYJKoZIhvcNAQELBQADgYEAUflI\n"
 178       "VUe5Krqf5RVa5C3u/UTAOAUJBiDS3VANTCLBxjuMsvqOG0WvaYWP3HYPgrz0jXK2\n"
 179       "LJE/mGw3MyFHEqi81jh95J+ypl6xKW6Rm8jKLR87gUvCaVYn/Z4/P3AqcQTB7wOv\n"
 180       "UD0A8qfhfDM+LK6rPAnCsVN0NRDY3jvd6rzix9M=\n"
 181       "-----END CERTIFICATE-----\n";
 182
 183   rtc::scoped_ptr<SSLIdentity> identity(
 184       SSLIdentity::FromPEMStrings(kRSA_PRIVATE_KEY_PEM, kCERT_PEM));
 185   EXPECT_TRUE(identity);
 186   EXPECT_EQ(kCERT_PEM, identity->certificate().ToPEMString());
 187 }
 188
 189 TEST_F(SSLIdentityTest, PemDerConversion) {
 190   std::string der;
 191   EXPECT_TRUE(SSLIdentity::PemToDer("CERTIFICATE", kTestCertificate, &der));
 192
 193   EXPECT_EQ(kTestCertificate, SSLIdentity::DerToPem(
 194       "CERTIFICATE",
 195       reinterpret_cast<const unsigned char*>(der.data()), der.length()));
 196 }
 197
 198 TEST_F(SSLIdentityTest, GetSignatureDigestAlgorithm) {
 199   TestGetSignatureDigestAlgorithm();
 200 }