1/* 2 * Copyright 2004 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#if HAVE_OPENSSL_SSL_H 12 13#include "webrtc/base/opensslidentity.h" 14 15// Must be included first before openssl headers. 16#include "webrtc/base/win32.h" // NOLINT 17 18#include <openssl/bio.h> 19#include <openssl/err.h> 20#include <openssl/pem.h> 21#include <openssl/bn.h> 22#include <openssl/rsa.h> 23#include <openssl/crypto.h> 24 25#include "webrtc/base/checks.h" 26#include "webrtc/base/helpers.h" 27#include "webrtc/base/logging.h" 28#include "webrtc/base/openssl.h" 29#include "webrtc/base/openssldigest.h" 30 31namespace rtc { 32 33// We could have exposed a myriad of parameters for the crypto stuff, 34// but keeping it simple seems best. 35 36// Strength of generated keys. Those are RSA. 37static const int KEY_LENGTH = 1024; 38 39// Random bits for certificate serial number 40static const int SERIAL_RAND_BITS = 64; 41 42// Certificate validity lifetime 43static const int CERTIFICATE_LIFETIME = 60*60*24*30; // 30 days, arbitrarily 44// Certificate validity window. 45// This is to compensate for slightly incorrect system clocks. 46static const int CERTIFICATE_WINDOW = -60*60*24; 47 48// Generate a key pair. Caller is responsible for freeing the returned object. 49static EVP_PKEY* MakeKey() { 50 LOG(LS_INFO) << "Making key pair"; 51 EVP_PKEY* pkey = EVP_PKEY_new(); 52 // RSA_generate_key is deprecated. Use _ex version. 53 BIGNUM* exponent = BN_new(); 54 RSA* rsa = RSA_new(); 55 if (!pkey || !exponent || !rsa || 56 !BN_set_word(exponent, 0x10001) || // 65537 RSA exponent 57 !RSA_generate_key_ex(rsa, KEY_LENGTH, exponent, NULL) || 58 !EVP_PKEY_assign_RSA(pkey, rsa)) { 59 EVP_PKEY_free(pkey); 60 BN_free(exponent); 61 RSA_free(rsa); 62 return NULL; 63 } 64 // ownership of rsa struct was assigned, don't free it. 65 BN_free(exponent); 66 LOG(LS_INFO) << "Returning key pair"; 67 return pkey; 68} 69 70// Generate a self-signed certificate, with the public key from the 71// given key pair. Caller is responsible for freeing the returned object. 72static X509* MakeCertificate(EVP_PKEY* pkey, const SSLIdentityParams& params) { 73 LOG(LS_INFO) << "Making certificate for " << params.common_name; 74 X509* x509 = NULL; 75 BIGNUM* serial_number = NULL; 76 X509_NAME* name = NULL; 77 78 if ((x509=X509_new()) == NULL) 79 goto error; 80 81 if (!X509_set_pubkey(x509, pkey)) 82 goto error; 83 84 // serial number 85 // temporary reference to serial number inside x509 struct 86 ASN1_INTEGER* asn1_serial_number; 87 if ((serial_number = BN_new()) == NULL || 88 !BN_pseudo_rand(serial_number, SERIAL_RAND_BITS, 0, 0) || 89 (asn1_serial_number = X509_get_serialNumber(x509)) == NULL || 90 !BN_to_ASN1_INTEGER(serial_number, asn1_serial_number)) 91 goto error; 92 93 if (!X509_set_version(x509, 0L)) // version 1 94 goto error; 95 96 // There are a lot of possible components for the name entries. In 97 // our P2P SSL mode however, the certificates are pre-exchanged 98 // (through the secure XMPP channel), and so the certificate 99 // identification is arbitrary. It can't be empty, so we set some 100 // arbitrary common_name. Note that this certificate goes out in 101 // clear during SSL negotiation, so there may be a privacy issue in 102 // putting anything recognizable here. 103 if ((name = X509_NAME_new()) == NULL || 104 !X509_NAME_add_entry_by_NID( 105 name, NID_commonName, MBSTRING_UTF8, 106 (unsigned char*)params.common_name.c_str(), -1, -1, 0) || 107 !X509_set_subject_name(x509, name) || 108 !X509_set_issuer_name(x509, name)) 109 goto error; 110 111 if (!X509_gmtime_adj(X509_get_notBefore(x509), params.not_before) || 112 !X509_gmtime_adj(X509_get_notAfter(x509), params.not_after)) 113 goto error; 114 115 if (!X509_sign(x509, pkey, EVP_sha1())) 116 goto error; 117 118 BN_free(serial_number); 119 X509_NAME_free(name); 120 LOG(LS_INFO) << "Returning certificate"; 121 return x509; 122 123 error: 124 BN_free(serial_number); 125 X509_NAME_free(name); 126 X509_free(x509); 127 return NULL; 128} 129 130// This dumps the SSL error stack to the log. 131static void LogSSLErrors(const std::string& prefix) { 132 char error_buf[200]; 133 unsigned long err; 134 135 while ((err = ERR_get_error()) != 0) { 136 ERR_error_string_n(err, error_buf, sizeof(error_buf)); 137 LOG(LS_ERROR) << prefix << ": " << error_buf << "\n"; 138 } 139} 140 141OpenSSLKeyPair* OpenSSLKeyPair::Generate() { 142 EVP_PKEY* pkey = MakeKey(); 143 if (!pkey) { 144 LogSSLErrors("Generating key pair"); 145 return NULL; 146 } 147 return new OpenSSLKeyPair(pkey); 148} 149 150OpenSSLKeyPair::~OpenSSLKeyPair() { 151 EVP_PKEY_free(pkey_); 152} 153 154void OpenSSLKeyPair::AddReference() { 155 CRYPTO_add(&pkey_->references, 1, CRYPTO_LOCK_EVP_PKEY); 156} 157 158#ifdef _DEBUG 159// Print a certificate to the log, for debugging. 160static void PrintCert(X509* x509) { 161 BIO* temp_memory_bio = BIO_new(BIO_s_mem()); 162 if (!temp_memory_bio) { 163 LOG_F(LS_ERROR) << "Failed to allocate temporary memory bio"; 164 return; 165 } 166 X509_print_ex(temp_memory_bio, x509, XN_FLAG_SEP_CPLUS_SPC, 0); 167 BIO_write(temp_memory_bio, "\0", 1); 168 char* buffer; 169 BIO_get_mem_data(temp_memory_bio, &buffer); 170 LOG(LS_VERBOSE) << buffer; 171 BIO_free(temp_memory_bio); 172} 173#endif 174 175OpenSSLCertificate* OpenSSLCertificate::Generate( 176 OpenSSLKeyPair* key_pair, const SSLIdentityParams& params) { 177 SSLIdentityParams actual_params(params); 178 if (actual_params.common_name.empty()) { 179 // Use a random string, arbitrarily 8chars long. 180 actual_params.common_name = CreateRandomString(8); 181 } 182 X509* x509 = MakeCertificate(key_pair->pkey(), actual_params); 183 if (!x509) { 184 LogSSLErrors("Generating certificate"); 185 return NULL; 186 } 187#ifdef _DEBUG 188 PrintCert(x509); 189#endif 190 OpenSSLCertificate* ret = new OpenSSLCertificate(x509); 191 X509_free(x509); 192 return ret; 193} 194 195OpenSSLCertificate* OpenSSLCertificate::FromPEMString( 196 const std::string& pem_string) { 197 BIO* bio = BIO_new_mem_buf(const_cast<char*>(pem_string.c_str()), -1); 198 if (!bio) 199 return NULL; 200 BIO_set_mem_eof_return(bio, 0); 201 X509 *x509 = PEM_read_bio_X509(bio, NULL, NULL, 202 const_cast<char*>("\0")); 203 BIO_free(bio); // Frees the BIO, but not the pointed-to string. 204 205 if (!x509) 206 return NULL; 207 208 OpenSSLCertificate* ret = new OpenSSLCertificate(x509); 209 X509_free(x509); 210 return ret; 211} 212 213// NOTE: This implementation only functions correctly after InitializeSSL 214// and before CleanupSSL. 215bool OpenSSLCertificate::GetSignatureDigestAlgorithm( 216 std::string* algorithm) const { 217 return OpenSSLDigest::GetDigestName( 218 EVP_get_digestbyobj(x509_->sig_alg->algorithm), algorithm); 219} 220 221bool OpenSSLCertificate::ComputeDigest(const std::string& algorithm, 222 unsigned char* digest, 223 size_t size, 224 size_t* length) const { 225 return ComputeDigest(x509_, algorithm, digest, size, length); 226} 227 228bool OpenSSLCertificate::ComputeDigest(const X509* x509, 229 const std::string& algorithm, 230 unsigned char* digest, 231 size_t size, 232 size_t* length) { 233 const EVP_MD *md; 234 unsigned int n; 235 236 if (!OpenSSLDigest::GetDigestEVP(algorithm, &md)) 237 return false; 238 239 if (size < static_cast<size_t>(EVP_MD_size(md))) 240 return false; 241 242 X509_digest(x509, md, digest, &n); 243 244 *length = n; 245 246 return true; 247} 248 249OpenSSLCertificate::~OpenSSLCertificate() { 250 X509_free(x509_); 251} 252 253std::string OpenSSLCertificate::ToPEMString() const { 254 BIO* bio = BIO_new(BIO_s_mem()); 255 if (!bio) { 256 FATAL() << "unreachable code"; 257 } 258 if (!PEM_write_bio_X509(bio, x509_)) { 259 BIO_free(bio); 260 FATAL() << "unreachable code"; 261 } 262 BIO_write(bio, "\0", 1); 263 char* buffer; 264 BIO_get_mem_data(bio, &buffer); 265 std::string ret(buffer); 266 BIO_free(bio); 267 return ret; 268} 269 270void OpenSSLCertificate::ToDER(Buffer* der_buffer) const { 271 // In case of failure, make sure to leave the buffer empty. 272 der_buffer->SetData(NULL, 0); 273 274 // Calculates the DER representation of the certificate, from scratch. 275 BIO* bio = BIO_new(BIO_s_mem()); 276 if (!bio) { 277 FATAL() << "unreachable code"; 278 } 279 if (!i2d_X509_bio(bio, x509_)) { 280 BIO_free(bio); 281 FATAL() << "unreachable code"; 282 } 283 char* data; 284 size_t length = BIO_get_mem_data(bio, &data); 285 der_buffer->SetData(data, length); 286 BIO_free(bio); 287} 288 289void OpenSSLCertificate::AddReference() const { 290 ASSERT(x509_ != NULL); 291 CRYPTO_add(&x509_->references, 1, CRYPTO_LOCK_X509); 292} 293 294OpenSSLIdentity* OpenSSLIdentity::GenerateInternal( 295 const SSLIdentityParams& params) { 296 OpenSSLKeyPair *key_pair = OpenSSLKeyPair::Generate(); 297 if (key_pair) { 298 OpenSSLCertificate *certificate = OpenSSLCertificate::Generate( 299 key_pair, params); 300 if (certificate) 301 return new OpenSSLIdentity(key_pair, certificate); 302 delete key_pair; 303 } 304 LOG(LS_INFO) << "Identity generation failed"; 305 return NULL; 306} 307 308OpenSSLIdentity* OpenSSLIdentity::Generate(const std::string& common_name) { 309 SSLIdentityParams params; 310 params.common_name = common_name; 311 params.not_before = CERTIFICATE_WINDOW; 312 params.not_after = CERTIFICATE_LIFETIME; 313 return GenerateInternal(params); 314} 315 316OpenSSLIdentity* OpenSSLIdentity::GenerateForTest( 317 const SSLIdentityParams& params) { 318 return GenerateInternal(params); 319} 320 321SSLIdentity* OpenSSLIdentity::FromPEMStrings( 322 const std::string& private_key, 323 const std::string& certificate) { 324 scoped_ptr<OpenSSLCertificate> cert( 325 OpenSSLCertificate::FromPEMString(certificate)); 326 if (!cert) { 327 LOG(LS_ERROR) << "Failed to create OpenSSLCertificate from PEM string."; 328 return NULL; 329 } 330 331 BIO* bio = BIO_new_mem_buf(const_cast<char*>(private_key.c_str()), -1); 332 if (!bio) { 333 LOG(LS_ERROR) << "Failed to create a new BIO buffer."; 334 return NULL; 335 } 336 BIO_set_mem_eof_return(bio, 0); 337 EVP_PKEY *pkey = PEM_read_bio_PrivateKey(bio, NULL, NULL, 338 const_cast<char*>("\0")); 339 BIO_free(bio); // Frees the BIO, but not the pointed-to string. 340 341 if (!pkey) { 342 LOG(LS_ERROR) << "Failed to create the private key from PEM string."; 343 return NULL; 344 } 345 346 return new OpenSSLIdentity(new OpenSSLKeyPair(pkey), 347 cert.release()); 348} 349 350bool OpenSSLIdentity::ConfigureIdentity(SSL_CTX* ctx) { 351 // 1 is the documented success return code. 352 if (SSL_CTX_use_certificate(ctx, certificate_->x509()) != 1 || 353 SSL_CTX_use_PrivateKey(ctx, key_pair_->pkey()) != 1) { 354 LogSSLErrors("Configuring key and certificate"); 355 return false; 356 } 357 return true; 358} 359 360} // namespace rtc 361 362#endif // HAVE_OPENSSL_SSL_H 363