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 31 namespace 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. 37 static const int KEY_LENGTH = 1024; 38 39 // Random bits for certificate serial number 40 static const int SERIAL_RAND_BITS = 64; 41 42 // Certificate validity lifetime 43 static 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. 46 static const int CERTIFICATE_WINDOW = -60*60*24; 47 48 // Generate a key pair. Caller is responsible for freeing the returned object. 49 static 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. 72 static 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. 131 static 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 141 OpenSSLKeyPair* 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 150 OpenSSLKeyPair::~OpenSSLKeyPair() { 151 EVP_PKEY_free(pkey_); 152 } 153 154 void 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. 160 static 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 175 OpenSSLCertificate* 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 195 OpenSSLCertificate* 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. 215 bool OpenSSLCertificate::GetSignatureDigestAlgorithm( 216 std::string* algorithm) const { 217 return OpenSSLDigest::GetDigestName( 218 EVP_get_digestbyobj(x509_->sig_alg->algorithm), algorithm); 219 } 220 221 bool 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 228 bool 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 249 OpenSSLCertificate::~OpenSSLCertificate() { 250 X509_free(x509_); 251 } 252 253 std::string OpenSSLCertificate::ToPEMString() const { 254 BIO* bio = BIO_new(BIO_s_mem()); 255 if (!bio) { 256 UNREACHABLE(); 257 return std::string(); 258 } 259 if (!PEM_write_bio_X509(bio, x509_)) { 260 BIO_free(bio); 261 UNREACHABLE(); 262 return std::string(); 263 } 264 BIO_write(bio, "\0", 1); 265 char* buffer; 266 BIO_get_mem_data(bio, &buffer); 267 std::string ret(buffer); 268 BIO_free(bio); 269 return ret; 270 } 271 272 void OpenSSLCertificate::ToDER(Buffer* der_buffer) const { 273 // In case of failure, make sure to leave the buffer empty. 274 der_buffer->SetData(NULL, 0); 275 276 // Calculates the DER representation of the certificate, from scratch. 277 BIO* bio = BIO_new(BIO_s_mem()); 278 if (!bio) { 279 UNREACHABLE(); 280 return; 281 } 282 if (!i2d_X509_bio(bio, x509_)) { 283 BIO_free(bio); 284 UNREACHABLE(); 285 return; 286 } 287 char* data; 288 size_t length = BIO_get_mem_data(bio, &data); 289 der_buffer->SetData(data, length); 290 BIO_free(bio); 291 } 292 293 void OpenSSLCertificate::AddReference() const { 294 ASSERT(x509_ != NULL); 295 CRYPTO_add(&x509_->references, 1, CRYPTO_LOCK_X509); 296 } 297 298 OpenSSLIdentity* OpenSSLIdentity::GenerateInternal( 299 const SSLIdentityParams& params) { 300 OpenSSLKeyPair *key_pair = OpenSSLKeyPair::Generate(); 301 if (key_pair) { 302 OpenSSLCertificate *certificate = OpenSSLCertificate::Generate( 303 key_pair, params); 304 if (certificate) 305 return new OpenSSLIdentity(key_pair, certificate); 306 delete key_pair; 307 } 308 LOG(LS_INFO) << "Identity generation failed"; 309 return NULL; 310 } 311 312 OpenSSLIdentity* OpenSSLIdentity::Generate(const std::string& common_name) { 313 SSLIdentityParams params; 314 params.common_name = common_name; 315 params.not_before = CERTIFICATE_WINDOW; 316 params.not_after = CERTIFICATE_LIFETIME; 317 return GenerateInternal(params); 318 } 319 320 OpenSSLIdentity* OpenSSLIdentity::GenerateForTest( 321 const SSLIdentityParams& params) { 322 return GenerateInternal(params); 323 } 324 325 SSLIdentity* OpenSSLIdentity::FromPEMStrings( 326 const std::string& private_key, 327 const std::string& certificate) { 328 scoped_ptr<OpenSSLCertificate> cert( 329 OpenSSLCertificate::FromPEMString(certificate)); 330 if (!cert) { 331 LOG(LS_ERROR) << "Failed to create OpenSSLCertificate from PEM string."; 332 return NULL; 333 } 334 335 BIO* bio = BIO_new_mem_buf(const_cast<char*>(private_key.c_str()), -1); 336 if (!bio) { 337 LOG(LS_ERROR) << "Failed to create a new BIO buffer."; 338 return NULL; 339 } 340 BIO_set_mem_eof_return(bio, 0); 341 EVP_PKEY *pkey = PEM_read_bio_PrivateKey(bio, NULL, NULL, 342 const_cast<char*>("\0")); 343 BIO_free(bio); // Frees the BIO, but not the pointed-to string. 344 345 if (!pkey) { 346 LOG(LS_ERROR) << "Failed to create the private key from PEM string."; 347 return NULL; 348 } 349 350 return new OpenSSLIdentity(new OpenSSLKeyPair(pkey), 351 cert.release()); 352 } 353 354 bool OpenSSLIdentity::ConfigureIdentity(SSL_CTX* ctx) { 355 // 1 is the documented success return code. 356 if (SSL_CTX_use_certificate(ctx, certificate_->x509()) != 1 || 357 SSL_CTX_use_PrivateKey(ctx, key_pair_->pkey()) != 1) { 358 LogSSLErrors("Configuring key and certificate"); 359 return false; 360 } 361 return true; 362 } 363 364 } // namespace rtc 365 366 #endif // HAVE_OPENSSL_SSL_H 367