Home | History | Annotate | Download | only in base 
      1 /*
      2  * libjingle
      3  * Copyright 2012, Google Inc.
      4  * Copyright 2012, RTFM, Inc.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions are met:
      8  *
      9  *  1. Redistributions of source code must retain the above copyright notice,
     10  *     this list of conditions and the following disclaimer.
     11  *  2. Redistributions in binary form must reproduce the above copyright notice,
     12  *     this list of conditions and the following disclaimer in the documentation
     13  *     and/or other materials provided with the distribution.
     14  *  3. The name of the author may not be used to endorse or promote products
     15  *     derived from this software without specific prior written permission.
     16  *
     17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
     18  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
     20  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
     23  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
     25  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
     26  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27  */
     28 
     29 #if HAVE_CONFIG_H
     30 #include "config.h"
     31 #endif  // HAVE_CONFIG_H
     32 
     33 #if HAVE_NSS_SSL_H
     34 
     35 #include "talk/base/nssidentity.h"
     36 
     37 #include <string>
     38 
     39 #include "cert.h"
     40 #include "cryptohi.h"
     41 #include "keyhi.h"
     42 #include "nss.h"
     43 #include "pk11pub.h"
     44 #include "sechash.h"
     45 
     46 #include "talk/base/logging.h"
     47 #include "talk/base/helpers.h"
     48 #include "talk/base/nssstreamadapter.h"
     49 
     50 namespace talk_base {
     51 
     52 NSSKeyPair::~NSSKeyPair() {
     53   if (privkey_)
     54     SECKEY_DestroyPrivateKey(privkey_);
     55   if (pubkey_)
     56     SECKEY_DestroyPublicKey(pubkey_);
     57 }
     58 
     59 NSSKeyPair *NSSKeyPair::Generate() {
     60   SECKEYPrivateKey *privkey = NULL;
     61   SECKEYPublicKey *pubkey = NULL;
     62   PK11RSAGenParams rsaparams;
     63   rsaparams.keySizeInBits = 1024;
     64   rsaparams.pe = 0x010001;  // 65537 -- a common RSA public exponent.
     65 
     66   privkey = PK11_GenerateKeyPair(NSSContext::GetSlot(),
     67                                  CKM_RSA_PKCS_KEY_PAIR_GEN,
     68                                  &rsaparams, &pubkey, PR_FALSE /*permanent*/,
     69                                  PR_FALSE /*sensitive*/, NULL);
     70   if (!privkey) {
     71     LOG(LS_ERROR) << "Couldn't generate key pair";
     72     return NULL;
     73   }
     74 
     75   return new NSSKeyPair(privkey, pubkey);
     76 }
     77 
     78 // Just make a copy.
     79 NSSKeyPair *NSSKeyPair::GetReference() {
     80   SECKEYPrivateKey *privkey = SECKEY_CopyPrivateKey(privkey_);
     81   if (!privkey)
     82     return NULL;
     83 
     84   SECKEYPublicKey *pubkey = SECKEY_CopyPublicKey(pubkey_);
     85   if (!pubkey) {
     86     SECKEY_DestroyPrivateKey(privkey);
     87     return NULL;
     88   }
     89 
     90   return new NSSKeyPair(privkey, pubkey);
     91 }
     92 
     93 NSSCertificate *NSSCertificate::FromPEMString(const std::string &pem_string) {
     94   std::string der;
     95   if (!SSLIdentity::PemToDer(kPemTypeCertificate, pem_string, &der))
     96     return NULL;
     97 
     98   SECItem der_cert;
     99   der_cert.data = reinterpret_cast<unsigned char *>(const_cast<char *>(
    100       der.data()));
    101   der_cert.len = der.size();
    102   CERTCertificate *cert = CERT_NewTempCertificate(CERT_GetDefaultCertDB(),
    103       &der_cert, NULL, PR_FALSE, PR_TRUE);
    104 
    105   if (!cert)
    106     return NULL;
    107 
    108   return new NSSCertificate(cert);
    109 }
    110 
    111 NSSCertificate *NSSCertificate::GetReference() const {
    112   CERTCertificate *certificate = CERT_DupCertificate(certificate_);
    113   if (!certificate)
    114     return NULL;
    115 
    116   return new NSSCertificate(certificate);
    117 }
    118 
    119 std::string NSSCertificate::ToPEMString() const {
    120   return SSLIdentity::DerToPem(kPemTypeCertificate,
    121                                certificate_->derCert.data,
    122                                certificate_->derCert.len);
    123 }
    124 
    125 bool NSSCertificate::GetDigestLength(const std::string &algorithm,
    126                                      std::size_t *length) {
    127   const SECHashObject *ho;
    128 
    129   if (!GetDigestObject(algorithm, &ho))
    130     return false;
    131 
    132   *length = ho->length;
    133 
    134   return true;
    135 }
    136 
    137 bool NSSCertificate::ComputeDigest(const std::string &algorithm,
    138                                    unsigned char *digest, std::size_t size,
    139                                    std::size_t *length) const {
    140   const SECHashObject *ho;
    141 
    142   if (!GetDigestObject(algorithm, &ho))
    143     return false;
    144 
    145   if (size < ho->length)  // Sanity check for fit
    146     return false;
    147 
    148   SECStatus rv = HASH_HashBuf(ho->type, digest,
    149                               certificate_->derCert.data,
    150                               certificate_->derCert.len);
    151   if (rv != SECSuccess)
    152     return false;
    153 
    154   *length = ho->length;
    155 
    156   return true;
    157 }
    158 
    159 bool NSSCertificate::Equals(const NSSCertificate *tocompare) const {
    160   if (!certificate_->derCert.len)
    161     return false;
    162   if (!tocompare->certificate_->derCert.len)
    163     return false;
    164 
    165   if (certificate_->derCert.len != tocompare->certificate_->derCert.len)
    166     return false;
    167 
    168   return memcmp(certificate_->derCert.data,
    169                 tocompare->certificate_->derCert.data,
    170                 certificate_->derCert.len) == 0;
    171 }
    172 
    173 
    174 bool NSSCertificate::GetDigestObject(const std::string &algorithm,
    175                                      const SECHashObject **hop) {
    176   const SECHashObject *ho;
    177   HASH_HashType hash_type;
    178 
    179   if (algorithm == DIGEST_SHA_1) {
    180     hash_type = HASH_AlgSHA1;
    181   // HASH_AlgSHA224 is not supported in the chromium linux build system.
    182 #if 0
    183   } else if (algorithm == DIGEST_SHA_224) {
    184     hash_type = HASH_AlgSHA224;
    185 #endif
    186   } else if (algorithm == DIGEST_SHA_256) {
    187     hash_type = HASH_AlgSHA256;
    188   } else if (algorithm == DIGEST_SHA_384) {
    189     hash_type = HASH_AlgSHA384;
    190   } else if (algorithm == DIGEST_SHA_512) {
    191     hash_type = HASH_AlgSHA512;
    192   } else {
    193     return false;
    194   }
    195 
    196   ho = HASH_GetHashObject(hash_type);
    197 
    198   ASSERT(ho->length >= 20);  // Can't happen
    199   *hop = ho;
    200 
    201   return true;
    202 }
    203 
    204 
    205 NSSIdentity *NSSIdentity::Generate(const std::string &common_name) {
    206   std::string subject_name_string = "CN=" + common_name;
    207   CERTName *subject_name = CERT_AsciiToName(
    208       const_cast<char *>(subject_name_string.c_str()));
    209   NSSIdentity *identity = NULL;
    210   CERTSubjectPublicKeyInfo *spki = NULL;
    211   CERTCertificateRequest *certreq = NULL;
    212   CERTValidity *validity;
    213   CERTCertificate *certificate = NULL;
    214   NSSKeyPair *keypair = NSSKeyPair::Generate();
    215   SECItem inner_der;
    216   SECStatus rv;
    217   PLArenaPool* arena;
    218   SECItem signed_cert;
    219   PRTime not_before, not_after;
    220   PRTime now = PR_Now();
    221   PRTime one_day;
    222 
    223   inner_der.len = 0;
    224   inner_der.data = NULL;
    225 
    226   if (!keypair) {
    227     LOG(LS_ERROR) << "Couldn't generate key pair";
    228     goto fail;
    229   }
    230 
    231   if (!subject_name) {
    232     LOG(LS_ERROR) << "Couldn't convert subject name " << subject_name;
    233     goto fail;
    234   }
    235 
    236   spki = SECKEY_CreateSubjectPublicKeyInfo(keypair->pubkey());
    237   if (!spki) {
    238     LOG(LS_ERROR) << "Couldn't create SPKI";
    239     goto fail;
    240   }
    241 
    242   certreq = CERT_CreateCertificateRequest(subject_name, spki, NULL);
    243   if (!certreq) {
    244     LOG(LS_ERROR) << "Couldn't create certificate signing request";
    245     goto fail;
    246   }
    247 
    248   one_day = 86400;
    249   one_day *= PR_USEC_PER_SEC;
    250   not_before = now - one_day;
    251   not_after = now + 30 * one_day;
    252 
    253   validity = CERT_CreateValidity(not_before, not_after);
    254   if (!validity) {
    255     LOG(LS_ERROR) << "Couldn't create validity";
    256     goto fail;
    257   }
    258 
    259   unsigned long serial;
    260   // Note: This serial in principle could collide, but it's unlikely
    261   rv = PK11_GenerateRandom(reinterpret_cast<unsigned char *>(&serial),
    262                            sizeof(serial));
    263   if (rv != SECSuccess) {
    264     LOG(LS_ERROR) << "Couldn't generate random serial";
    265     goto fail;
    266   }
    267 
    268   certificate = CERT_CreateCertificate(serial, subject_name, validity, certreq);
    269   if (!certificate) {
    270     LOG(LS_ERROR) << "Couldn't create certificate";
    271     goto fail;
    272   }
    273 
    274   arena = certificate->arena;
    275 
    276   rv = SECOID_SetAlgorithmID(arena, &certificate->signature,
    277                              SEC_OID_PKCS1_SHA1_WITH_RSA_ENCRYPTION, NULL);
    278   if (rv != SECSuccess)
    279     goto fail;
    280 
    281   // Set version to X509v3.
    282   *(certificate->version.data) = 2;
    283   certificate->version.len = 1;
    284 
    285   if (!SEC_ASN1EncodeItem(arena, &inner_der, certificate,
    286                           SEC_ASN1_GET(CERT_CertificateTemplate)))
    287     goto fail;
    288 
    289   rv = SEC_DerSignData(arena, &signed_cert, inner_der.data, inner_der.len,
    290                        keypair->privkey(),
    291                        SEC_OID_PKCS1_SHA1_WITH_RSA_ENCRYPTION);
    292   if (rv != SECSuccess) {
    293     LOG(LS_ERROR) << "Couldn't sign certificate";
    294     goto fail;
    295   }
    296   certificate->derCert = signed_cert;
    297 
    298   identity = new NSSIdentity(keypair, new NSSCertificate(certificate));
    299 
    300   goto done;
    301 
    302  fail:
    303   delete keypair;
    304   CERT_DestroyCertificate(certificate);
    305 
    306  done:
    307   if (subject_name) CERT_DestroyName(subject_name);
    308   if (spki) SECKEY_DestroySubjectPublicKeyInfo(spki);
    309   if (certreq) CERT_DestroyCertificateRequest(certreq);
    310   if (validity) CERT_DestroyValidity(validity);
    311   return identity;
    312 }
    313 
    314 SSLIdentity* NSSIdentity::FromPEMStrings(const std::string& private_key,
    315                                          const std::string& certificate) {
    316   std::string private_key_der;
    317   if (!SSLIdentity::PemToDer(
    318       kPemTypeRsaPrivateKey, private_key, &private_key_der))
    319     return NULL;
    320 
    321   SECItem private_key_item;
    322   private_key_item.data =
    323       reinterpret_cast<unsigned char *>(
    324           const_cast<char *>(private_key_der.c_str()));
    325   private_key_item.len = private_key_der.size();
    326 
    327   const unsigned int key_usage = KU_KEY_ENCIPHERMENT | KU_DATA_ENCIPHERMENT |
    328       KU_DIGITAL_SIGNATURE;
    329 
    330   SECKEYPrivateKey* privkey = NULL;
    331   SECStatus rv =
    332       PK11_ImportDERPrivateKeyInfoAndReturnKey(NSSContext::GetSlot(),
    333                                                &private_key_item,
    334                                                NULL, NULL, PR_FALSE, PR_FALSE,
    335                                                key_usage, &privkey, NULL);
    336   if (rv != SECSuccess) {
    337     LOG(LS_ERROR) << "Couldn't import private key";
    338     return NULL;
    339   }
    340 
    341   SECKEYPublicKey *pubkey = SECKEY_ConvertToPublicKey(privkey);
    342   if (rv != SECSuccess) {
    343     SECKEY_DestroyPrivateKey(privkey);
    344     LOG(LS_ERROR) << "Couldn't convert private key to public key";
    345     return NULL;
    346   }
    347 
    348   // Assign to a scoped_ptr so we don't leak on error.
    349   scoped_ptr<NSSKeyPair> keypair(new NSSKeyPair(privkey, pubkey));
    350 
    351   scoped_ptr<NSSCertificate> cert(NSSCertificate::FromPEMString(certificate));
    352   if (!cert) {
    353     LOG(LS_ERROR) << "Couldn't parse certificate";
    354     return NULL;
    355   }
    356 
    357   // TODO(ekr (at) rtfm.com): Check the public key against the certificate.
    358 
    359   return new NSSIdentity(keypair.release(), cert.release());
    360 }
    361 
    362 NSSIdentity *NSSIdentity::GetReference() const {
    363   NSSKeyPair *keypair = keypair_->GetReference();
    364   if (!keypair)
    365     return NULL;
    366 
    367   NSSCertificate *certificate = certificate_->GetReference();
    368   if (!certificate) {
    369     delete keypair;
    370     return NULL;
    371   }
    372 
    373   return new NSSIdentity(keypair, certificate);
    374 }
    375 
    376 
    377 NSSCertificate &NSSIdentity::certificate() const {
    378   return *certificate_;
    379 }
    380 
    381 
    382 }  // talk_base namespace
    383 
    384 #endif  // HAVE_NSS_SSL_H
    385 
    386