blob: 3b4232b06be86d9282cec0bc445a1da20af6d851 [file] [log] [blame]
henrike@webrtc.orgf0488722014-05-13 18:00:261/*
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// Handling of certificates and keypairs for SSLStreamAdapter's peer mode.
Steve Anton10542f22019-01-11 17:11:0012#include "rtc_base/ssl_identity.h"
henrike@webrtc.orgf0488722014-05-13 18:00:2613
Taylor Brandstetter165c6182020-12-11 00:23:0314#include <openssl/ossl_typ.h>
Yves Gerey988cc082018-10-23 10:03:0115#include <string.h>
16#include <time.h>
henrike@webrtc.orgf0488722014-05-13 18:00:2617
Ali Tofigh7fa90572022-03-17 14:47:4918#include "absl/strings/string_view.h"
Yves Gerey988cc082018-10-23 10:03:0119#include "rtc_base/checks.h"
Taylor Brandstetter165c6182020-12-11 00:23:0320#ifdef OPENSSL_IS_BORINGSSL
21#include "rtc_base/boringssl_identity.h"
22#else
Steve Anton10542f22019-01-11 17:11:0023#include "rtc_base/openssl_identity.h"
Taylor Brandstetter165c6182020-12-11 00:23:0324#endif
Steve Anton10542f22019-01-11 17:11:0025#include "rtc_base/ssl_certificate.h"
Yves Gerey988cc082018-10-23 10:03:0126#include "rtc_base/strings/string_builder.h"
27#include "rtc_base/third_party/base64/base64.h"
Steve Anton10542f22019-01-11 17:11:0028#include "rtc_base/time_utils.h"
deadbeeff33491e2017-01-21 01:01:4529
henrike@webrtc.orgf0488722014-05-13 18:00:2630namespace rtc {
31
Benjamin Wrightd6f86e82018-05-08 20:12:2532//////////////////////////////////////////////////////////////////////
Benjamin Wright22a8f982018-10-29 01:39:0033// Helper Functions
34//////////////////////////////////////////////////////////////////////
35
36namespace {
Artem Titov96e3b992021-07-26 14:03:1437// Read `n` bytes from ASN1 number string at *`pp` and return the numeric value.
38// Update *`pp` and *`np` to reflect number of read bytes.
Benjamin Wright22a8f982018-10-29 01:39:0039// TODO(bugs.webrtc.org/9860) - Remove this code.
40inline int ASN1ReadInt(const unsigned char** pp, size_t* np, size_t n) {
41 const unsigned char* p = *pp;
42 int x = 0;
43 for (size_t i = 0; i < n; i++) {
44 x = 10 * x + p[i] - '0';
45 }
46 *pp = p + n;
47 *np = *np - n;
48 return x;
49}
50
51} // namespace
52
53// TODO(bugs.webrtc.org/9860) - Remove this code.
54int64_t ASN1TimeToSec(const unsigned char* s, size_t length, bool long_format) {
55 size_t bytes_left = length;
56 // Make sure the string ends with Z. Doing it here protects the strspn call
57 // from running off the end of the string in Z's absense.
58 if (length == 0 || s[length - 1] != 'Z') {
59 return -1;
60 }
61 // Make sure we only have ASCII digits so that we don't need to clutter the
62 // code below and ASN1ReadInt with error checking.
63 size_t n = strspn(reinterpret_cast<const char*>(s), "0123456789");
64 if (n + 1 != length) {
65 return -1;
66 }
67 // Read out ASN1 year, in either 2-char "UTCTIME" or 4-char "GENERALIZEDTIME"
68 // format. Both format use UTC in this context.
69 int year = 0;
70 if (long_format) {
71 // ASN1 format: yyyymmddhh[mm[ss[.fff]]]Z where the Z is literal, but
72 // RFC 5280 requires us to only support exactly yyyymmddhhmmssZ.
73 if (bytes_left < 11) {
74 return -1;
75 }
76 year = ASN1ReadInt(&s, &bytes_left, 4);
77 year -= 1900;
78 } else {
79 // ASN1 format: yymmddhhmm[ss]Z where the Z is literal, but RFC 5280
80 // requires us to only support exactly yymmddhhmmssZ.
81 if (bytes_left < 9) {
82 return -1;
83 }
84 year = ASN1ReadInt(&s, &bytes_left, 2);
85 // Per RFC 5280 4.1.2.5.1
86 if (year < 50) {
87 year += 100;
88 }
89 }
90
Artem Titov96e3b992021-07-26 14:03:1491 // Read out remaining ASN1 time data and store it in `tm` in documented
Benjamin Wright22a8f982018-10-29 01:39:0092 // std::tm format.
93 tm tm;
94 tm.tm_year = year;
95 tm.tm_mon = ASN1ReadInt(&s, &bytes_left, 2) - 1;
96 tm.tm_mday = ASN1ReadInt(&s, &bytes_left, 2);
97 tm.tm_hour = ASN1ReadInt(&s, &bytes_left, 2);
98 tm.tm_min = ASN1ReadInt(&s, &bytes_left, 2);
99 tm.tm_sec = ASN1ReadInt(&s, &bytes_left, 2);
100
101 // Now just Z should remain. Its existence was asserted above.
102 if (bytes_left != 1) {
103 return -1;
104 }
105 return TmToSeconds(tm);
106}
107
108//////////////////////////////////////////////////////////////////////
Benjamin Wrightd6f86e82018-05-08 20:12:25109// KeyParams
110//////////////////////////////////////////////////////////////////////
111
henrike@webrtc.orgf0488722014-05-13 18:00:26112const char kPemTypeCertificate[] = "CERTIFICATE";
113const char kPemTypeRsaPrivateKey[] = "RSA PRIVATE KEY";
Torbjorn Granlundb6d4ec42015-08-17 12:08:59114const char kPemTypeEcPrivateKey[] = "EC PRIVATE KEY";
henrike@webrtc.orgf0488722014-05-13 18:00:26115
torbjorng4e572472015-10-08 16:42:49116KeyParams::KeyParams(KeyType key_type) {
117 if (key_type == KT_ECDSA) {
118 type_ = KT_ECDSA;
119 params_.curve = EC_NIST_P256;
120 } else if (key_type == KT_RSA) {
121 type_ = KT_RSA;
122 params_.rsa.mod_size = kRsaDefaultModSize;
123 params_.rsa.pub_exp = kRsaDefaultExponent;
124 } else {
Artem Titovd3251962021-11-15 15:57:07125 RTC_DCHECK_NOTREACHED();
torbjorng4e572472015-10-08 16:42:49126 }
127}
128
129// static
130KeyParams KeyParams::RSA(int mod_size, int pub_exp) {
131 KeyParams kt(KT_RSA);
132 kt.params_.rsa.mod_size = mod_size;
133 kt.params_.rsa.pub_exp = pub_exp;
134 return kt;
135}
136
137// static
138KeyParams KeyParams::ECDSA(ECCurve curve) {
139 KeyParams kt(KT_ECDSA);
140 kt.params_.curve = curve;
141 return kt;
142}
143
144bool KeyParams::IsValid() const {
145 if (type_ == KT_RSA) {
146 return (params_.rsa.mod_size >= kRsaMinModSize &&
147 params_.rsa.mod_size <= kRsaMaxModSize &&
148 params_.rsa.pub_exp > params_.rsa.mod_size);
149 } else if (type_ == KT_ECDSA) {
150 return (params_.curve == EC_NIST_P256);
151 }
152 return false;
153}
154
155RSAParams KeyParams::rsa_params() const {
156 RTC_DCHECK(type_ == KT_RSA);
157 return params_.rsa;
158}
159
160ECCurve KeyParams::ec_curve() const {
161 RTC_DCHECK(type_ == KT_ECDSA);
162 return params_.curve;
163}
164
Henrik Boström9b5476d2015-09-22 12:12:57165KeyType IntKeyTypeFamilyToKeyType(int key_type_family) {
166 return static_cast<KeyType>(key_type_family);
167}
168
Benjamin Wrightd6f86e82018-05-08 20:12:25169//////////////////////////////////////////////////////////////////////
170// SSLIdentity
171//////////////////////////////////////////////////////////////////////
172
Ali Tofigh7fa90572022-03-17 14:47:49173bool SSLIdentity::PemToDer(absl::string_view pem_type,
174 absl::string_view pem_string,
henrike@webrtc.orgf0488722014-05-13 18:00:26175 std::string* der) {
Benjamin Wright22a8f982018-10-29 01:39:00176 // Find the inner body. We need this to fulfill the contract of returning
177 // pem_length.
Ali Tofigh98bfd992022-07-22 20:10:49178 std::string pem_type_str(pem_type);
Ali Tofigh7fa90572022-03-17 14:47:49179 size_t header = pem_string.find("-----BEGIN " + pem_type_str + "-----");
180 if (header == absl::string_view::npos) {
henrike@webrtc.orgf0488722014-05-13 18:00:26181 return false;
Benjamin Wright22a8f982018-10-29 01:39:00182 }
Mirko Bonadei37ec55e2019-01-28 10:43:52183 size_t body = pem_string.find('\n', header);
Ali Tofigh7fa90572022-03-17 14:47:49184 if (body == absl::string_view::npos) {
henrike@webrtc.orgf0488722014-05-13 18:00:26185 return false;
Benjamin Wright22a8f982018-10-29 01:39:00186 }
Ali Tofigh7fa90572022-03-17 14:47:49187 size_t trailer = pem_string.find("-----END " + pem_type_str + "-----");
188 if (trailer == absl::string_view::npos) {
henrike@webrtc.orgf0488722014-05-13 18:00:26189 return false;
Benjamin Wright22a8f982018-10-29 01:39:00190 }
Ali Tofigh98bfd992022-07-22 20:10:49191 std::string inner(pem_string.substr(body + 1, trailer - (body + 1)));
Yves Gerey665174f2018-06-19 13:03:05192 *der = Base64::Decode(inner, Base64::DO_PARSE_WHITE | Base64::DO_PAD_ANY |
193 Base64::DO_TERM_BUFFER);
henrike@webrtc.orgf0488722014-05-13 18:00:26194 return true;
195}
196
Ali Tofigh7fa90572022-03-17 14:47:49197std::string SSLIdentity::DerToPem(absl::string_view pem_type,
henrike@webrtc.orgf0488722014-05-13 18:00:26198 const unsigned char* data,
199 size_t length) {
Jonas Olsson366a50c2018-09-06 11:41:30200 rtc::StringBuilder result;
henrike@webrtc.orgf0488722014-05-13 18:00:26201 result << "-----BEGIN " << pem_type << "-----\n";
202
203 std::string b64_encoded;
204 Base64::EncodeFromArray(data, length, &b64_encoded);
Benjamin Wright22a8f982018-10-29 01:39:00205 // Divide the Base-64 encoded data into 64-character chunks, as per 4.3.2.4
206 // of RFC 1421.
henrike@webrtc.orgf0488722014-05-13 18:00:26207 static const size_t kChunkSize = 64;
208 size_t chunks = (b64_encoded.size() + (kChunkSize - 1)) / kChunkSize;
209 for (size_t i = 0, chunk_offset = 0; i < chunks;
210 ++i, chunk_offset += kChunkSize) {
211 result << b64_encoded.substr(chunk_offset, kChunkSize);
212 result << "\n";
213 }
henrike@webrtc.orgf0488722014-05-13 18:00:26214 result << "-----END " << pem_type << "-----\n";
Jonas Olsson84df1c72018-09-14 14:59:32215 return result.Release();
henrike@webrtc.orgf0488722014-05-13 18:00:26216}
217
Torbjorn Granlunda3dc79e2016-02-16 12:33:53218// static
Ali Tofigh7fa90572022-03-17 14:47:49219std::unique_ptr<SSLIdentity> SSLIdentity::Create(absl::string_view common_name,
Harald Alvestrand8515d5a2020-03-20 21:51:32220 const KeyParams& key_param,
221 time_t certificate_lifetime) {
Taylor Brandstetter165c6182020-12-11 00:23:03222#ifdef OPENSSL_IS_BORINGSSL
223 return BoringSSLIdentity::CreateWithExpiration(common_name, key_param,
224 certificate_lifetime);
225#else
Harald Alvestrand8515d5a2020-03-20 21:51:32226 return OpenSSLIdentity::CreateWithExpiration(common_name, key_param,
227 certificate_lifetime);
Taylor Brandstetter165c6182020-12-11 00:23:03228#endif
Harald Alvestrand8515d5a2020-03-20 21:51:32229}
230
231// static
Ali Tofigh7fa90572022-03-17 14:47:49232std::unique_ptr<SSLIdentity> SSLIdentity::Create(absl::string_view common_name,
Harald Alvestrand8515d5a2020-03-20 21:51:32233 const KeyParams& key_param) {
Taylor Brandstetter165c6182020-12-11 00:23:03234 return Create(common_name, key_param, kDefaultCertificateLifetimeInSeconds);
Harald Alvestrand8515d5a2020-03-20 21:51:32235}
236
237// static
Ali Tofigh7fa90572022-03-17 14:47:49238std::unique_ptr<SSLIdentity> SSLIdentity::Create(absl::string_view common_name,
Harald Alvestrand8515d5a2020-03-20 21:51:32239 KeyType key_type) {
Taylor Brandstetter165c6182020-12-11 00:23:03240 return Create(common_name, KeyParams(key_type),
241 kDefaultCertificateLifetimeInSeconds);
Harald Alvestrand8515d5a2020-03-20 21:51:32242}
243
244// static
245std::unique_ptr<SSLIdentity> SSLIdentity::CreateForTest(
246 const SSLIdentityParams& params) {
Taylor Brandstetter165c6182020-12-11 00:23:03247#ifdef OPENSSL_IS_BORINGSSL
248 return BoringSSLIdentity::CreateForTest(params);
249#else
Harald Alvestrand8515d5a2020-03-20 21:51:32250 return OpenSSLIdentity::CreateForTest(params);
Taylor Brandstetter165c6182020-12-11 00:23:03251#endif
Harald Alvestrand8515d5a2020-03-20 21:51:32252}
253
254// Construct an identity from a private key and a certificate.
255// static
256std::unique_ptr<SSLIdentity> SSLIdentity::CreateFromPEMStrings(
Ali Tofigh7fa90572022-03-17 14:47:49257 absl::string_view private_key,
258 absl::string_view certificate) {
Taylor Brandstetter165c6182020-12-11 00:23:03259#ifdef OPENSSL_IS_BORINGSSL
260 return BoringSSLIdentity::CreateFromPEMStrings(private_key, certificate);
261#else
Harald Alvestrand8515d5a2020-03-20 21:51:32262 return OpenSSLIdentity::CreateFromPEMStrings(private_key, certificate);
Taylor Brandstetter165c6182020-12-11 00:23:03263#endif
Harald Alvestrand8515d5a2020-03-20 21:51:32264}
265
266// Construct an identity from a private key and a certificate chain.
267// static
268std::unique_ptr<SSLIdentity> SSLIdentity::CreateFromPEMChainStrings(
Ali Tofigh7fa90572022-03-17 14:47:49269 absl::string_view private_key,
270 absl::string_view certificate_chain) {
Taylor Brandstetter165c6182020-12-11 00:23:03271#ifdef OPENSSL_IS_BORINGSSL
272 return BoringSSLIdentity::CreateFromPEMChainStrings(private_key,
273 certificate_chain);
274#else
Harald Alvestrand8515d5a2020-03-20 21:51:32275 return OpenSSLIdentity::CreateFromPEMChainStrings(private_key,
276 certificate_chain);
Taylor Brandstetter165c6182020-12-11 00:23:03277#endif
Harald Alvestrand8515d5a2020-03-20 21:51:32278}
279
hbos6b470a92016-04-28 12:14:21280bool operator==(const SSLIdentity& a, const SSLIdentity& b) {
Taylor Brandstetter165c6182020-12-11 00:23:03281#ifdef OPENSSL_IS_BORINGSSL
282 return static_cast<const BoringSSLIdentity&>(a) ==
283 static_cast<const BoringSSLIdentity&>(b);
284#else
hbos6b470a92016-04-28 12:14:21285 return static_cast<const OpenSSLIdentity&>(a) ==
286 static_cast<const OpenSSLIdentity&>(b);
Taylor Brandstetter165c6182020-12-11 00:23:03287#endif
hbos6b470a92016-04-28 12:14:21288}
289bool operator!=(const SSLIdentity& a, const SSLIdentity& b) {
290 return !(a == b);
291}
292
henrike@webrtc.orgf0488722014-05-13 18:00:26293} // namespace rtc