1 /*
2 *
3 * Copyright 2015 gRPC authors.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 */
18
19 #include <grpc/support/port_platform.h>
20
21 #include "src/core/tsi/ssl_transport_security.h"
22
23 #include <limits.h>
24 #include <string.h>
25
26 /* TODO(jboeuf): refactor inet_ntop into a portability header. */
27 /* Note: for whomever reads this and tries to refactor this, this
28 can't be in grpc, it has to be in gpr. */
29 #ifdef GPR_WINDOWS
30 #include <ws2tcpip.h>
31 #else
32 #include <arpa/inet.h>
33 #include <sys/socket.h>
34 #endif
35
36 #include <string>
37
38 #include <grpc/grpc_security.h>
39 #include <grpc/support/alloc.h>
40 #include <grpc/support/log.h>
41 #include <grpc/support/string_util.h>
42 #include <grpc/support/sync.h>
43 #include <grpc/support/thd_id.h>
44
45 #include "absl/strings/match.h"
46 #include "absl/strings/string_view.h"
47
48 extern "C" {
49 #include <openssl/bio.h>
50 #include <openssl/crypto.h> /* For OPENSSL_free */
51 #include <openssl/engine.h>
52 #include <openssl/err.h>
53 #include <openssl/ssl.h>
54 #include <openssl/tls1.h>
55 #include <openssl/x509.h>
56 #include <openssl/x509v3.h>
57 }
58
59 #include "src/core/lib/gpr/useful.h"
60 #include "src/core/tsi/ssl/session_cache/ssl_session_cache.h"
61 #include "src/core/tsi/ssl_types.h"
62 #include "src/core/tsi/transport_security.h"
63
64 /* --- Constants. ---*/
65
66 #define TSI_SSL_MAX_PROTECTED_FRAME_SIZE_UPPER_BOUND 16384
67 #define TSI_SSL_MAX_PROTECTED_FRAME_SIZE_LOWER_BOUND 1024
68 #define TSI_SSL_HANDSHAKER_OUTGOING_BUFFER_INITIAL_SIZE 1024
69
70 /* Putting a macro like this and littering the source file with #if is really
71 bad practice.
72 TODO(jboeuf): refactor all the #if / #endif in a separate module. */
73 #ifndef TSI_OPENSSL_ALPN_SUPPORT
74 #define TSI_OPENSSL_ALPN_SUPPORT 1
75 #endif
76
77 /* TODO(jboeuf): I have not found a way to get this number dynamically from the
78 SSL structure. This is what we would ultimately want though... */
79 #define TSI_SSL_MAX_PROTECTION_OVERHEAD 100
80
81 /* --- Structure definitions. ---*/
82
83 struct tsi_ssl_root_certs_store {
84 X509_STORE* store;
85 };
86
87 struct tsi_ssl_handshaker_factory {
88 const tsi_ssl_handshaker_factory_vtable* vtable;
89 gpr_refcount refcount;
90 };
91
92 struct tsi_ssl_client_handshaker_factory {
93 tsi_ssl_handshaker_factory base;
94 SSL_CTX* ssl_context;
95 unsigned char* alpn_protocol_list;
96 size_t alpn_protocol_list_length;
97 grpc_core::RefCountedPtr<tsi::SslSessionLRUCache> session_cache;
98 };
99
100 struct tsi_ssl_server_handshaker_factory {
101 /* Several contexts to support SNI.
102 The tsi_peer array contains the subject names of the server certificates
103 associated with the contexts at the same index. */
104 tsi_ssl_handshaker_factory base;
105 SSL_CTX** ssl_contexts;
106 tsi_peer* ssl_context_x509_subject_names;
107 size_t ssl_context_count;
108 unsigned char* alpn_protocol_list;
109 size_t alpn_protocol_list_length;
110 };
111
112 struct tsi_ssl_handshaker {
113 tsi_handshaker base;
114 SSL* ssl;
115 BIO* network_io;
116 tsi_result result;
117 unsigned char* outgoing_bytes_buffer;
118 size_t outgoing_bytes_buffer_size;
119 tsi_ssl_handshaker_factory* factory_ref;
120 };
121 struct tsi_ssl_handshaker_result {
122 tsi_handshaker_result base;
123 SSL* ssl;
124 BIO* network_io;
125 unsigned char* unused_bytes;
126 size_t unused_bytes_size;
127 };
128 struct tsi_ssl_frame_protector {
129 tsi_frame_protector base;
130 SSL* ssl;
131 BIO* network_io;
132 unsigned char* buffer;
133 size_t buffer_size;
134 size_t buffer_offset;
135 };
136 /* --- Library Initialization. ---*/
137
138 static gpr_once g_init_openssl_once = GPR_ONCE_INIT;
139 static int g_ssl_ctx_ex_factory_index = -1;
140 static const unsigned char kSslSessionIdContext[] = {'g', 'r', 'p', 'c'};
141 #if !defined(OPENSSL_IS_BORINGSSL) && !defined(OPENSSL_NO_ENGINE)
142 static const char kSslEnginePrefix[] = "engine:";
143 #endif
144
145 #if OPENSSL_VERSION_NUMBER < 0x10100000
146 static gpr_mu* g_openssl_mutexes = nullptr;
147 static void openssl_locking_cb(int mode, int type, const char* file,
148 int line) GRPC_UNUSED;
149 static unsigned long openssl_thread_id_cb(void) GRPC_UNUSED;
150
openssl_locking_cb(int mode,int type,const char * file,int line)151 static void openssl_locking_cb(int mode, int type, const char* file, int line) {
152 if (mode & CRYPTO_LOCK) {
153 gpr_mu_lock(&g_openssl_mutexes[type]);
154 } else {
155 gpr_mu_unlock(&g_openssl_mutexes[type]);
156 }
157 }
158
openssl_thread_id_cb(void)159 static unsigned long openssl_thread_id_cb(void) {
160 return static_cast<unsigned long>(gpr_thd_currentid());
161 }
162 #endif
163
init_openssl(void)164 static void init_openssl(void) {
165 #if OPENSSL_VERSION_NUMBER >= 0x10100000
166 OPENSSL_init_ssl(0, nullptr);
167 #else
168 SSL_library_init();
169 SSL_load_error_strings();
170 OpenSSL_add_all_algorithms();
171 #endif
172 #if OPENSSL_VERSION_NUMBER < 0x10100000
173 if (!CRYPTO_get_locking_callback()) {
174 int num_locks = CRYPTO_num_locks();
175 GPR_ASSERT(num_locks > 0);
176 g_openssl_mutexes = static_cast<gpr_mu*>(
177 gpr_malloc(static_cast<size_t>(num_locks) * sizeof(gpr_mu)));
178 for (int i = 0; i < num_locks; i++) {
179 gpr_mu_init(&g_openssl_mutexes[i]);
180 }
181 CRYPTO_set_locking_callback(openssl_locking_cb);
182 CRYPTO_set_id_callback(openssl_thread_id_cb);
183 } else {
184 gpr_log(GPR_INFO, "OpenSSL callback has already been set.");
185 }
186 #endif
187 g_ssl_ctx_ex_factory_index =
188 SSL_CTX_get_ex_new_index(0, nullptr, nullptr, nullptr, nullptr);
189 GPR_ASSERT(g_ssl_ctx_ex_factory_index != -1);
190 }
191
192 /* --- Ssl utils. ---*/
193
ssl_error_string(int error)194 static const char* ssl_error_string(int error) {
195 switch (error) {
196 case SSL_ERROR_NONE:
197 return "SSL_ERROR_NONE";
198 case SSL_ERROR_ZERO_RETURN:
199 return "SSL_ERROR_ZERO_RETURN";
200 case SSL_ERROR_WANT_READ:
201 return "SSL_ERROR_WANT_READ";
202 case SSL_ERROR_WANT_WRITE:
203 return "SSL_ERROR_WANT_WRITE";
204 case SSL_ERROR_WANT_CONNECT:
205 return "SSL_ERROR_WANT_CONNECT";
206 case SSL_ERROR_WANT_ACCEPT:
207 return "SSL_ERROR_WANT_ACCEPT";
208 case SSL_ERROR_WANT_X509_LOOKUP:
209 return "SSL_ERROR_WANT_X509_LOOKUP";
210 case SSL_ERROR_SYSCALL:
211 return "SSL_ERROR_SYSCALL";
212 case SSL_ERROR_SSL:
213 return "SSL_ERROR_SSL";
214 default:
215 return "Unknown error";
216 }
217 }
218
219 /* TODO(jboeuf): Remove when we are past the debugging phase with this code. */
ssl_log_where_info(const SSL * ssl,int where,int flag,const char * msg)220 static void ssl_log_where_info(const SSL* ssl, int where, int flag,
221 const char* msg) {
222 if ((where & flag) && GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
223 gpr_log(GPR_INFO, "%20.20s - %30.30s - %5.10s", msg,
224 SSL_state_string_long(ssl), SSL_state_string(ssl));
225 }
226 }
227
228 /* Used for debugging. TODO(jboeuf): Remove when code is mature enough. */
ssl_info_callback(const SSL * ssl,int where,int ret)229 static void ssl_info_callback(const SSL* ssl, int where, int ret) {
230 if (ret == 0) {
231 gpr_log(GPR_ERROR, "ssl_info_callback: error occurred.\n");
232 return;
233 }
234
235 ssl_log_where_info(ssl, where, SSL_CB_LOOP, "LOOP");
236 ssl_log_where_info(ssl, where, SSL_CB_HANDSHAKE_START, "HANDSHAKE START");
237 ssl_log_where_info(ssl, where, SSL_CB_HANDSHAKE_DONE, "HANDSHAKE DONE");
238 }
239
240 /* Returns 1 if name looks like an IP address, 0 otherwise.
241 This is a very rough heuristic, and only handles IPv6 in hexadecimal form. */
looks_like_ip_address(absl::string_view name)242 static int looks_like_ip_address(absl::string_view name) {
243 size_t dot_count = 0;
244 size_t num_size = 0;
245 for (size_t i = 0; i < name.size(); ++i) {
246 if (name[i] == ':') {
247 /* IPv6 Address in hexadecimal form, : is not allowed in DNS names. */
248 return 1;
249 }
250 if (name[i] >= '0' && name[i] <= '9') {
251 if (num_size > 3) return 0;
252 num_size++;
253 } else if (name[i] == '.') {
254 if (dot_count > 3 || num_size == 0) return 0;
255 dot_count++;
256 num_size = 0;
257 } else {
258 return 0;
259 }
260 }
261 if (dot_count < 3 || num_size == 0) return 0;
262 return 1;
263 }
264
265 /* Gets the subject CN from an X509 cert. */
ssl_get_x509_common_name(X509 * cert,unsigned char ** utf8,size_t * utf8_size)266 static tsi_result ssl_get_x509_common_name(X509* cert, unsigned char** utf8,
267 size_t* utf8_size) {
268 int common_name_index = -1;
269 X509_NAME_ENTRY* common_name_entry = nullptr;
270 ASN1_STRING* common_name_asn1 = nullptr;
271 X509_NAME* subject_name = X509_get_subject_name(cert);
272 int utf8_returned_size = 0;
273 if (subject_name == nullptr) {
274 gpr_log(GPR_INFO, "Could not get subject name from certificate.");
275 return TSI_NOT_FOUND;
276 }
277 common_name_index =
278 X509_NAME_get_index_by_NID(subject_name, NID_commonName, -1);
279 if (common_name_index == -1) {
280 gpr_log(GPR_INFO, "Could not get common name of subject from certificate.");
281 return TSI_NOT_FOUND;
282 }
283 common_name_entry = X509_NAME_get_entry(subject_name, common_name_index);
284 if (common_name_entry == nullptr) {
285 gpr_log(GPR_ERROR, "Could not get common name entry from certificate.");
286 return TSI_INTERNAL_ERROR;
287 }
288 common_name_asn1 = X509_NAME_ENTRY_get_data(common_name_entry);
289 if (common_name_asn1 == nullptr) {
290 gpr_log(GPR_ERROR,
291 "Could not get common name entry asn1 from certificate.");
292 return TSI_INTERNAL_ERROR;
293 }
294 utf8_returned_size = ASN1_STRING_to_UTF8(utf8, common_name_asn1);
295 if (utf8_returned_size < 0) {
296 gpr_log(GPR_ERROR, "Could not extract utf8 from asn1 string.");
297 return TSI_OUT_OF_RESOURCES;
298 }
299 *utf8_size = static_cast<size_t>(utf8_returned_size);
300 return TSI_OK;
301 }
302
303 /* Gets the subject CN of an X509 cert as a tsi_peer_property. */
peer_property_from_x509_common_name(X509 * cert,tsi_peer_property * property)304 static tsi_result peer_property_from_x509_common_name(
305 X509* cert, tsi_peer_property* property) {
306 unsigned char* common_name;
307 size_t common_name_size;
308 tsi_result result =
309 ssl_get_x509_common_name(cert, &common_name, &common_name_size);
310 if (result != TSI_OK) {
311 if (result == TSI_NOT_FOUND) {
312 common_name = nullptr;
313 common_name_size = 0;
314 } else {
315 return result;
316 }
317 }
318 result = tsi_construct_string_peer_property(
319 TSI_X509_SUBJECT_COMMON_NAME_PEER_PROPERTY,
320 common_name == nullptr ? "" : reinterpret_cast<const char*>(common_name),
321 common_name_size, property);
322 OPENSSL_free(common_name);
323 return result;
324 }
325
326 /* Gets the X509 cert in PEM format as a tsi_peer_property. */
add_pem_certificate(X509 * cert,tsi_peer_property * property)327 static tsi_result add_pem_certificate(X509* cert, tsi_peer_property* property) {
328 BIO* bio = BIO_new(BIO_s_mem());
329 if (!PEM_write_bio_X509(bio, cert)) {
330 BIO_free(bio);
331 return TSI_INTERNAL_ERROR;
332 }
333 char* contents;
334 long len = BIO_get_mem_data(bio, &contents);
335 if (len <= 0) {
336 BIO_free(bio);
337 return TSI_INTERNAL_ERROR;
338 }
339 tsi_result result = tsi_construct_string_peer_property(
340 TSI_X509_PEM_CERT_PROPERTY, contents, static_cast<size_t>(len), property);
341 BIO_free(bio);
342 return result;
343 }
344
345 /* Gets the subject SANs from an X509 cert as a tsi_peer_property. */
add_subject_alt_names_properties_to_peer(tsi_peer * peer,GENERAL_NAMES * subject_alt_names,size_t subject_alt_name_count,int * current_insert_index)346 static tsi_result add_subject_alt_names_properties_to_peer(
347 tsi_peer* peer, GENERAL_NAMES* subject_alt_names,
348 size_t subject_alt_name_count, int* current_insert_index) {
349 size_t i;
350 tsi_result result = TSI_OK;
351
352 for (i = 0; i < subject_alt_name_count; i++) {
353 GENERAL_NAME* subject_alt_name =
354 sk_GENERAL_NAME_value(subject_alt_names, TSI_SIZE_AS_SIZE(i));
355 if (subject_alt_name->type == GEN_DNS ||
356 subject_alt_name->type == GEN_EMAIL ||
357 subject_alt_name->type == GEN_URI) {
358 unsigned char* name = nullptr;
359 int name_size;
360 if (subject_alt_name->type == GEN_DNS) {
361 name_size = ASN1_STRING_to_UTF8(&name, subject_alt_name->d.dNSName);
362 } else if (subject_alt_name->type == GEN_EMAIL) {
363 name_size = ASN1_STRING_to_UTF8(&name, subject_alt_name->d.rfc822Name);
364 } else {
365 name_size = ASN1_STRING_to_UTF8(
366 &name, subject_alt_name->d.uniformResourceIdentifier);
367 }
368 if (name_size < 0) {
369 gpr_log(GPR_ERROR, "Could not get utf8 from asn1 string.");
370 result = TSI_INTERNAL_ERROR;
371 break;
372 }
373 result = tsi_construct_string_peer_property(
374 TSI_X509_SUBJECT_ALTERNATIVE_NAME_PEER_PROPERTY,
375 reinterpret_cast<const char*>(name), static_cast<size_t>(name_size),
376 &peer->properties[(*current_insert_index)++]);
377 if (result != TSI_OK) {
378 OPENSSL_free(name);
379 break;
380 }
381 if (subject_alt_name->type == GEN_URI) {
382 result = tsi_construct_string_peer_property(
383 TSI_X509_URI_PEER_PROPERTY, reinterpret_cast<const char*>(name),
384 static_cast<size_t>(name_size),
385 &peer->properties[(*current_insert_index)++]);
386 }
387 OPENSSL_free(name);
388 } else if (subject_alt_name->type == GEN_IPADD) {
389 char ntop_buf[INET6_ADDRSTRLEN];
390 int af;
391
392 if (subject_alt_name->d.iPAddress->length == 4) {
393 af = AF_INET;
394 } else if (subject_alt_name->d.iPAddress->length == 16) {
395 af = AF_INET6;
396 } else {
397 gpr_log(GPR_ERROR, "SAN IP Address contained invalid IP");
398 result = TSI_INTERNAL_ERROR;
399 break;
400 }
401 const char* name = inet_ntop(af, subject_alt_name->d.iPAddress->data,
402 ntop_buf, INET6_ADDRSTRLEN);
403 if (name == nullptr) {
404 gpr_log(GPR_ERROR, "Could not get IP string from asn1 octet.");
405 result = TSI_INTERNAL_ERROR;
406 break;
407 }
408
409 result = tsi_construct_string_peer_property_from_cstring(
410 TSI_X509_SUBJECT_ALTERNATIVE_NAME_PEER_PROPERTY, name,
411 &peer->properties[(*current_insert_index)++]);
412 } else {
413 result = tsi_construct_string_peer_property_from_cstring(
414 TSI_X509_SUBJECT_ALTERNATIVE_NAME_PEER_PROPERTY, "other types of SAN",
415 &peer->properties[(*current_insert_index)++]);
416 }
417 if (result != TSI_OK) break;
418 }
419 return result;
420 }
421
422 /* Gets information about the peer's X509 cert as a tsi_peer object. */
peer_from_x509(X509 * cert,int include_certificate_type,tsi_peer * peer)423 static tsi_result peer_from_x509(X509* cert, int include_certificate_type,
424 tsi_peer* peer) {
425 /* TODO(jboeuf): Maybe add more properties. */
426 GENERAL_NAMES* subject_alt_names = static_cast<GENERAL_NAMES*>(
427 X509_get_ext_d2i(cert, NID_subject_alt_name, nullptr, nullptr));
428 int subject_alt_name_count =
429 (subject_alt_names != nullptr)
430 ? static_cast<int>(sk_GENERAL_NAME_num(subject_alt_names))
431 : 0;
432 size_t property_count;
433 tsi_result result;
434 GPR_ASSERT(subject_alt_name_count >= 0);
435 property_count = (include_certificate_type ? static_cast<size_t>(1) : 0) +
436 2 /* common name, certificate */ +
437 static_cast<size_t>(subject_alt_name_count);
438 for (int i = 0; i < subject_alt_name_count; i++) {
439 GENERAL_NAME* subject_alt_name =
440 sk_GENERAL_NAME_value(subject_alt_names, TSI_SIZE_AS_SIZE(i));
441 if (subject_alt_name->type == GEN_URI) {
442 property_count += 1;
443 }
444 }
445 result = tsi_construct_peer(property_count, peer);
446 if (result != TSI_OK) return result;
447 int current_insert_index = 0;
448 do {
449 if (include_certificate_type) {
450 result = tsi_construct_string_peer_property_from_cstring(
451 TSI_CERTIFICATE_TYPE_PEER_PROPERTY, TSI_X509_CERTIFICATE_TYPE,
452 &peer->properties[current_insert_index++]);
453 if (result != TSI_OK) break;
454 }
455 result = peer_property_from_x509_common_name(
456 cert, &peer->properties[current_insert_index++]);
457 if (result != TSI_OK) break;
458
459 result =
460 add_pem_certificate(cert, &peer->properties[current_insert_index++]);
461 if (result != TSI_OK) break;
462
463 if (subject_alt_name_count != 0) {
464 result = add_subject_alt_names_properties_to_peer(
465 peer, subject_alt_names, static_cast<size_t>(subject_alt_name_count),
466 ¤t_insert_index);
467 if (result != TSI_OK) break;
468 }
469 } while (false);
470
471 if (subject_alt_names != nullptr) {
472 sk_GENERAL_NAME_pop_free(subject_alt_names, GENERAL_NAME_free);
473 }
474 if (result != TSI_OK) tsi_peer_destruct(peer);
475
476 GPR_ASSERT((int)peer->property_count == current_insert_index);
477 return result;
478 }
479
480 /* Logs the SSL error stack. */
log_ssl_error_stack(void)481 static void log_ssl_error_stack(void) {
482 unsigned long err;
483 while ((err = ERR_get_error()) != 0) {
484 char details[256];
485 ERR_error_string_n(static_cast<uint32_t>(err), details, sizeof(details));
486 gpr_log(GPR_ERROR, "%s", details);
487 }
488 }
489
490 /* Performs an SSL_read and handle errors. */
do_ssl_read(SSL * ssl,unsigned char * unprotected_bytes,size_t * unprotected_bytes_size)491 static tsi_result do_ssl_read(SSL* ssl, unsigned char* unprotected_bytes,
492 size_t* unprotected_bytes_size) {
493 int read_from_ssl;
494 GPR_ASSERT(*unprotected_bytes_size <= INT_MAX);
495 read_from_ssl = SSL_read(ssl, unprotected_bytes,
496 static_cast<int>(*unprotected_bytes_size));
497 if (read_from_ssl <= 0) {
498 read_from_ssl = SSL_get_error(ssl, read_from_ssl);
499 switch (read_from_ssl) {
500 case SSL_ERROR_ZERO_RETURN: /* Received a close_notify alert. */
501 case SSL_ERROR_WANT_READ: /* We need more data to finish the frame. */
502 *unprotected_bytes_size = 0;
503 return TSI_OK;
504 case SSL_ERROR_WANT_WRITE:
505 gpr_log(
506 GPR_ERROR,
507 "Peer tried to renegotiate SSL connection. This is unsupported.");
508 return TSI_UNIMPLEMENTED;
509 case SSL_ERROR_SSL:
510 gpr_log(GPR_ERROR, "Corruption detected.");
511 log_ssl_error_stack();
512 return TSI_DATA_CORRUPTED;
513 default:
514 gpr_log(GPR_ERROR, "SSL_read failed with error %s.",
515 ssl_error_string(read_from_ssl));
516 return TSI_PROTOCOL_FAILURE;
517 }
518 }
519 *unprotected_bytes_size = static_cast<size_t>(read_from_ssl);
520 return TSI_OK;
521 }
522
523 /* Performs an SSL_write and handle errors. */
do_ssl_write(SSL * ssl,unsigned char * unprotected_bytes,size_t unprotected_bytes_size)524 static tsi_result do_ssl_write(SSL* ssl, unsigned char* unprotected_bytes,
525 size_t unprotected_bytes_size) {
526 int ssl_write_result;
527 GPR_ASSERT(unprotected_bytes_size <= INT_MAX);
528 ssl_write_result = SSL_write(ssl, unprotected_bytes,
529 static_cast<int>(unprotected_bytes_size));
530 if (ssl_write_result < 0) {
531 ssl_write_result = SSL_get_error(ssl, ssl_write_result);
532 if (ssl_write_result == SSL_ERROR_WANT_READ) {
533 gpr_log(GPR_ERROR,
534 "Peer tried to renegotiate SSL connection. This is unsupported.");
535 return TSI_UNIMPLEMENTED;
536 } else {
537 gpr_log(GPR_ERROR, "SSL_write failed with error %s.",
538 ssl_error_string(ssl_write_result));
539 return TSI_INTERNAL_ERROR;
540 }
541 }
542 return TSI_OK;
543 }
544
545 /* Loads an in-memory PEM certificate chain into the SSL context. */
ssl_ctx_use_certificate_chain(SSL_CTX * context,const char * pem_cert_chain,size_t pem_cert_chain_size)546 static tsi_result ssl_ctx_use_certificate_chain(SSL_CTX* context,
547 const char* pem_cert_chain,
548 size_t pem_cert_chain_size) {
549 tsi_result result = TSI_OK;
550 X509* certificate = nullptr;
551 BIO* pem;
552 GPR_ASSERT(pem_cert_chain_size <= INT_MAX);
553 pem = BIO_new_mem_buf(pem_cert_chain, static_cast<int>(pem_cert_chain_size));
554 if (pem == nullptr) return TSI_OUT_OF_RESOURCES;
555
556 do {
557 certificate =
558 PEM_read_bio_X509_AUX(pem, nullptr, nullptr, const_cast<char*>(""));
559 if (certificate == nullptr) {
560 result = TSI_INVALID_ARGUMENT;
561 break;
562 }
563 if (!SSL_CTX_use_certificate(context, certificate)) {
564 result = TSI_INVALID_ARGUMENT;
565 break;
566 }
567 while (true) {
568 X509* certificate_authority =
569 PEM_read_bio_X509(pem, nullptr, nullptr, const_cast<char*>(""));
570 if (certificate_authority == nullptr) {
571 ERR_clear_error();
572 break; /* Done reading. */
573 }
574 if (!SSL_CTX_add_extra_chain_cert(context, certificate_authority)) {
575 X509_free(certificate_authority);
576 result = TSI_INVALID_ARGUMENT;
577 break;
578 }
579 /* We don't need to free certificate_authority as its ownership has been
580 transferred to the context. That is not the case for certificate
581 though.
582 */
583 }
584 } while (false);
585
586 if (certificate != nullptr) X509_free(certificate);
587 BIO_free(pem);
588 return result;
589 }
590
591 #if !defined(OPENSSL_IS_BORINGSSL) && !defined(OPENSSL_NO_ENGINE)
ssl_ctx_use_engine_private_key(SSL_CTX * context,const char * pem_key,size_t pem_key_size)592 static tsi_result ssl_ctx_use_engine_private_key(SSL_CTX* context,
593 const char* pem_key,
594 size_t pem_key_size) {
595 tsi_result result = TSI_OK;
596 EVP_PKEY* private_key = nullptr;
597 ENGINE* engine = nullptr;
598 char* engine_name = nullptr;
599 // Parse key which is in following format engine:<engine_id>:<key_id>
600 do {
601 char* engine_start = (char*)pem_key + strlen(kSslEnginePrefix);
602 char* engine_end = (char*)strchr(engine_start, ':');
603 if (engine_end == nullptr) {
604 result = TSI_INVALID_ARGUMENT;
605 break;
606 }
607 char* key_id = engine_end + 1;
608 int engine_name_length = engine_end - engine_start;
609 if (engine_name_length == 0) {
610 result = TSI_INVALID_ARGUMENT;
611 break;
612 }
613 engine_name = static_cast<char*>(gpr_zalloc(engine_name_length + 1));
614 memcpy(engine_name, engine_start, engine_name_length);
615 gpr_log(GPR_DEBUG, "ENGINE key: %s", engine_name);
616 ENGINE_load_dynamic();
617 engine = ENGINE_by_id(engine_name);
618 if (engine == nullptr) {
619 // If not available at ENGINE_DIR, use dynamic to load from
620 // current working directory.
621 engine = ENGINE_by_id("dynamic");
622 if (engine == nullptr) {
623 gpr_log(GPR_ERROR, "Cannot load dynamic engine");
624 result = TSI_INVALID_ARGUMENT;
625 break;
626 }
627 if (!ENGINE_ctrl_cmd_string(engine, "ID", engine_name, 0) ||
628 !ENGINE_ctrl_cmd_string(engine, "DIR_LOAD", "2", 0) ||
629 !ENGINE_ctrl_cmd_string(engine, "DIR_ADD", ".", 0) ||
630 !ENGINE_ctrl_cmd_string(engine, "LIST_ADD", "1", 0) ||
631 !ENGINE_ctrl_cmd_string(engine, "LOAD", NULL, 0)) {
632 gpr_log(GPR_ERROR, "Cannot find engine");
633 result = TSI_INVALID_ARGUMENT;
634 break;
635 }
636 }
637 if (!ENGINE_set_default(engine, ENGINE_METHOD_ALL)) {
638 gpr_log(GPR_ERROR, "ENGINE_set_default with ENGINE_METHOD_ALL failed");
639 result = TSI_INVALID_ARGUMENT;
640 break;
641 }
642 if (!ENGINE_init(engine)) {
643 gpr_log(GPR_ERROR, "ENGINE_init failed");
644 result = TSI_INVALID_ARGUMENT;
645 break;
646 }
647 private_key = ENGINE_load_private_key(engine, key_id, 0, 0);
648 if (private_key == nullptr) {
649 gpr_log(GPR_ERROR, "ENGINE_load_private_key failed");
650 result = TSI_INVALID_ARGUMENT;
651 break;
652 }
653 if (!SSL_CTX_use_PrivateKey(context, private_key)) {
654 gpr_log(GPR_ERROR, "SSL_CTX_use_PrivateKey failed");
655 result = TSI_INVALID_ARGUMENT;
656 break;
657 }
658 } while (0);
659 if (engine != nullptr) ENGINE_free(engine);
660 if (private_key != nullptr) EVP_PKEY_free(private_key);
661 if (engine_name != nullptr) gpr_free(engine_name);
662 return result;
663 }
664 #endif /* !defined(OPENSSL_IS_BORINGSSL) && !defined(OPENSSL_NO_ENGINE) */
665
ssl_ctx_use_pem_private_key(SSL_CTX * context,const char * pem_key,size_t pem_key_size)666 static tsi_result ssl_ctx_use_pem_private_key(SSL_CTX* context,
667 const char* pem_key,
668 size_t pem_key_size) {
669 tsi_result result = TSI_OK;
670 EVP_PKEY* private_key = nullptr;
671 BIO* pem;
672 GPR_ASSERT(pem_key_size <= INT_MAX);
673 pem = BIO_new_mem_buf(pem_key, static_cast<int>(pem_key_size));
674 if (pem == nullptr) return TSI_OUT_OF_RESOURCES;
675 do {
676 private_key =
677 PEM_read_bio_PrivateKey(pem, nullptr, nullptr, const_cast<char*>(""));
678 if (private_key == nullptr) {
679 result = TSI_INVALID_ARGUMENT;
680 break;
681 }
682 if (!SSL_CTX_use_PrivateKey(context, private_key)) {
683 result = TSI_INVALID_ARGUMENT;
684 break;
685 }
686 } while (false);
687 if (private_key != nullptr) EVP_PKEY_free(private_key);
688 BIO_free(pem);
689 return result;
690 }
691
692 /* Loads an in-memory PEM private key into the SSL context. */
ssl_ctx_use_private_key(SSL_CTX * context,const char * pem_key,size_t pem_key_size)693 static tsi_result ssl_ctx_use_private_key(SSL_CTX* context, const char* pem_key,
694 size_t pem_key_size) {
695 // BoringSSL does not have ENGINE support
696 #if !defined(OPENSSL_IS_BORINGSSL) && !defined(OPENSSL_NO_ENGINE)
697 if (strncmp(pem_key, kSslEnginePrefix, strlen(kSslEnginePrefix)) == 0) {
698 return ssl_ctx_use_engine_private_key(context, pem_key, pem_key_size);
699 } else
700 #endif /* !defined(OPENSSL_IS_BORINGSSL) && !defined(OPENSSL_NO_ENGINE) */
701 {
702 return ssl_ctx_use_pem_private_key(context, pem_key, pem_key_size);
703 }
704 }
705
706 /* Loads in-memory PEM verification certs into the SSL context and optionally
707 returns the verification cert names (root_names can be NULL). */
x509_store_load_certs(X509_STORE * cert_store,const char * pem_roots,size_t pem_roots_size,STACK_OF (X509_NAME)** root_names)708 static tsi_result x509_store_load_certs(X509_STORE* cert_store,
709 const char* pem_roots,
710 size_t pem_roots_size,
711 STACK_OF(X509_NAME) * *root_names) {
712 tsi_result result = TSI_OK;
713 size_t num_roots = 0;
714 X509* root = nullptr;
715 X509_NAME* root_name = nullptr;
716 BIO* pem;
717 GPR_ASSERT(pem_roots_size <= INT_MAX);
718 pem = BIO_new_mem_buf(pem_roots, static_cast<int>(pem_roots_size));
719 if (cert_store == nullptr) return TSI_INVALID_ARGUMENT;
720 if (pem == nullptr) return TSI_OUT_OF_RESOURCES;
721 if (root_names != nullptr) {
722 *root_names = sk_X509_NAME_new_null();
723 if (*root_names == nullptr) return TSI_OUT_OF_RESOURCES;
724 }
725
726 while (true) {
727 root = PEM_read_bio_X509_AUX(pem, nullptr, nullptr, const_cast<char*>(""));
728 if (root == nullptr) {
729 ERR_clear_error();
730 break; /* We're at the end of stream. */
731 }
732 if (root_names != nullptr) {
733 root_name = X509_get_subject_name(root);
734 if (root_name == nullptr) {
735 gpr_log(GPR_ERROR, "Could not get name from root certificate.");
736 result = TSI_INVALID_ARGUMENT;
737 break;
738 }
739 root_name = X509_NAME_dup(root_name);
740 if (root_name == nullptr) {
741 result = TSI_OUT_OF_RESOURCES;
742 break;
743 }
744 sk_X509_NAME_push(*root_names, root_name);
745 root_name = nullptr;
746 }
747 ERR_clear_error();
748 if (!X509_STORE_add_cert(cert_store, root)) {
749 unsigned long error = ERR_get_error();
750 if (ERR_GET_LIB(error) != ERR_LIB_X509 ||
751 ERR_GET_REASON(error) != X509_R_CERT_ALREADY_IN_HASH_TABLE) {
752 gpr_log(GPR_ERROR, "Could not add root certificate to ssl context.");
753 result = TSI_INTERNAL_ERROR;
754 break;
755 }
756 }
757 X509_free(root);
758 num_roots++;
759 }
760 if (num_roots == 0) {
761 gpr_log(GPR_ERROR, "Could not load any root certificate.");
762 result = TSI_INVALID_ARGUMENT;
763 }
764
765 if (result != TSI_OK) {
766 if (root != nullptr) X509_free(root);
767 if (root_names != nullptr) {
768 sk_X509_NAME_pop_free(*root_names, X509_NAME_free);
769 *root_names = nullptr;
770 if (root_name != nullptr) X509_NAME_free(root_name);
771 }
772 }
773 BIO_free(pem);
774 return result;
775 }
776
ssl_ctx_load_verification_certs(SSL_CTX * context,const char * pem_roots,size_t pem_roots_size,STACK_OF (X509_NAME)** root_name)777 static tsi_result ssl_ctx_load_verification_certs(SSL_CTX* context,
778 const char* pem_roots,
779 size_t pem_roots_size,
780 STACK_OF(X509_NAME) *
781 *root_name) {
782 X509_STORE* cert_store = SSL_CTX_get_cert_store(context);
783 X509_STORE_set_flags(cert_store,
784 X509_V_FLAG_PARTIAL_CHAIN | X509_V_FLAG_TRUSTED_FIRST);
785 return x509_store_load_certs(cert_store, pem_roots, pem_roots_size,
786 root_name);
787 }
788
789 /* Populates the SSL context with a private key and a cert chain, and sets the
790 cipher list and the ephemeral ECDH key. */
populate_ssl_context(SSL_CTX * context,const tsi_ssl_pem_key_cert_pair * key_cert_pair,const char * cipher_list)791 static tsi_result populate_ssl_context(
792 SSL_CTX* context, const tsi_ssl_pem_key_cert_pair* key_cert_pair,
793 const char* cipher_list) {
794 tsi_result result = TSI_OK;
795 if (key_cert_pair != nullptr) {
796 if (key_cert_pair->cert_chain != nullptr) {
797 result = ssl_ctx_use_certificate_chain(context, key_cert_pair->cert_chain,
798 strlen(key_cert_pair->cert_chain));
799 if (result != TSI_OK) {
800 gpr_log(GPR_ERROR, "Invalid cert chain file.");
801 return result;
802 }
803 }
804 if (key_cert_pair->private_key != nullptr) {
805 result = ssl_ctx_use_private_key(context, key_cert_pair->private_key,
806 strlen(key_cert_pair->private_key));
807 if (result != TSI_OK || !SSL_CTX_check_private_key(context)) {
808 gpr_log(GPR_ERROR, "Invalid private key.");
809 return result != TSI_OK ? result : TSI_INVALID_ARGUMENT;
810 }
811 }
812 }
813 if ((cipher_list != nullptr) &&
814 !SSL_CTX_set_cipher_list(context, cipher_list)) {
815 gpr_log(GPR_ERROR, "Invalid cipher list: %s.", cipher_list);
816 return TSI_INVALID_ARGUMENT;
817 }
818 {
819 EC_KEY* ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
820 if (!SSL_CTX_set_tmp_ecdh(context, ecdh)) {
821 gpr_log(GPR_ERROR, "Could not set ephemeral ECDH key.");
822 EC_KEY_free(ecdh);
823 return TSI_INTERNAL_ERROR;
824 }
825 SSL_CTX_set_options(context, SSL_OP_SINGLE_ECDH_USE);
826 EC_KEY_free(ecdh);
827 }
828 return TSI_OK;
829 }
830
831 /* Extracts the CN and the SANs from an X509 cert as a peer object. */
tsi_ssl_extract_x509_subject_names_from_pem_cert(const char * pem_cert,tsi_peer * peer)832 tsi_result tsi_ssl_extract_x509_subject_names_from_pem_cert(
833 const char* pem_cert, tsi_peer* peer) {
834 tsi_result result = TSI_OK;
835 X509* cert = nullptr;
836 BIO* pem;
837 pem = BIO_new_mem_buf(pem_cert, static_cast<int>(strlen(pem_cert)));
838 if (pem == nullptr) return TSI_OUT_OF_RESOURCES;
839
840 cert = PEM_read_bio_X509(pem, nullptr, nullptr, const_cast<char*>(""));
841 if (cert == nullptr) {
842 gpr_log(GPR_ERROR, "Invalid certificate");
843 result = TSI_INVALID_ARGUMENT;
844 } else {
845 result = peer_from_x509(cert, 0, peer);
846 }
847 if (cert != nullptr) X509_free(cert);
848 BIO_free(pem);
849 return result;
850 }
851
852 /* Builds the alpn protocol name list according to rfc 7301. */
build_alpn_protocol_name_list(const char ** alpn_protocols,uint16_t num_alpn_protocols,unsigned char ** protocol_name_list,size_t * protocol_name_list_length)853 static tsi_result build_alpn_protocol_name_list(
854 const char** alpn_protocols, uint16_t num_alpn_protocols,
855 unsigned char** protocol_name_list, size_t* protocol_name_list_length) {
856 uint16_t i;
857 unsigned char* current;
858 *protocol_name_list = nullptr;
859 *protocol_name_list_length = 0;
860 if (num_alpn_protocols == 0) return TSI_INVALID_ARGUMENT;
861 for (i = 0; i < num_alpn_protocols; i++) {
862 size_t length =
863 alpn_protocols[i] == nullptr ? 0 : strlen(alpn_protocols[i]);
864 if (length == 0 || length > 255) {
865 gpr_log(GPR_ERROR, "Invalid protocol name length: %d.",
866 static_cast<int>(length));
867 return TSI_INVALID_ARGUMENT;
868 }
869 *protocol_name_list_length += length + 1;
870 }
871 *protocol_name_list =
872 static_cast<unsigned char*>(gpr_malloc(*protocol_name_list_length));
873 if (*protocol_name_list == nullptr) return TSI_OUT_OF_RESOURCES;
874 current = *protocol_name_list;
875 for (i = 0; i < num_alpn_protocols; i++) {
876 size_t length = strlen(alpn_protocols[i]);
877 *(current++) = static_cast<uint8_t>(length); /* max checked above. */
878 memcpy(current, alpn_protocols[i], length);
879 current += length;
880 }
881 /* Safety check. */
882 if ((current < *protocol_name_list) ||
883 (static_cast<uintptr_t>(current - *protocol_name_list) !=
884 *protocol_name_list_length)) {
885 return TSI_INTERNAL_ERROR;
886 }
887 return TSI_OK;
888 }
889
890 // The verification callback is used for clients that don't really care about
891 // the server's certificate, but we need to pull it anyway, in case a higher
892 // layer wants to look at it. In this case the verification may fail, but
893 // we don't really care.
NullVerifyCallback(int,X509_STORE_CTX *)894 static int NullVerifyCallback(int /*preverify_ok*/, X509_STORE_CTX* /*ctx*/) {
895 return 1;
896 }
897
898 // Sets the min and max TLS version of |ssl_context| to |min_tls_version| and
899 // |max_tls_version|, respectively. Calling this method is a no-op when using
900 // OpenSSL versions < 1.1.
tsi_set_min_and_max_tls_versions(SSL_CTX * ssl_context,tsi_tls_version min_tls_version,tsi_tls_version max_tls_version)901 static tsi_result tsi_set_min_and_max_tls_versions(
902 SSL_CTX* ssl_context, tsi_tls_version min_tls_version,
903 tsi_tls_version max_tls_version) {
904 if (ssl_context == nullptr) {
905 gpr_log(GPR_INFO,
906 "Invalid nullptr argument to |tsi_set_min_and_max_tls_versions|.");
907 return TSI_INVALID_ARGUMENT;
908 }
909 #if OPENSSL_VERSION_NUMBER >= 0x10100000
910 // Set the min TLS version of the SSL context if using OpenSSL version
911 // >= 1.1.0. This OpenSSL version is required because the
912 // |SSL_CTX_set_min_proto_version| and |SSL_CTX_set_max_proto_version| APIs
913 // only exist in this version range.
914 switch (min_tls_version) {
915 case tsi_tls_version::TSI_TLS1_2:
916 SSL_CTX_set_min_proto_version(ssl_context, TLS1_2_VERSION);
917 break;
918 #if defined(TLS1_3_VERSION)
919 // If the library does not support TLS 1.3 and the caller requests a minimum
920 // of TLS 1.3, then return an error because the caller's request cannot be
921 // satisfied.
922 case tsi_tls_version::TSI_TLS1_3:
923 SSL_CTX_set_min_proto_version(ssl_context, TLS1_3_VERSION);
924 break;
925 #endif
926 default:
927 gpr_log(GPR_INFO, "TLS version is not supported.");
928 return TSI_FAILED_PRECONDITION;
929 }
930
931 // Set the max TLS version of the SSL context.
932 switch (max_tls_version) {
933 case tsi_tls_version::TSI_TLS1_2:
934 SSL_CTX_set_max_proto_version(ssl_context, TLS1_2_VERSION);
935 break;
936 case tsi_tls_version::TSI_TLS1_3:
937 #if defined(TLS1_3_VERSION)
938 SSL_CTX_set_max_proto_version(ssl_context, TLS1_3_VERSION);
939 #else
940 // If the library does not support TLS 1.3, then set the max TLS version
941 // to TLS 1.2 instead.
942 SSL_CTX_set_max_proto_version(ssl_context, TLS1_2_VERSION);
943 #endif
944 break;
945 default:
946 gpr_log(GPR_INFO, "TLS version is not supported.");
947 return TSI_FAILED_PRECONDITION;
948 }
949 #endif
950 return TSI_OK;
951 }
952
953 /* --- tsi_ssl_root_certs_store methods implementation. ---*/
954
tsi_ssl_root_certs_store_create(const char * pem_roots)955 tsi_ssl_root_certs_store* tsi_ssl_root_certs_store_create(
956 const char* pem_roots) {
957 if (pem_roots == nullptr) {
958 gpr_log(GPR_ERROR, "The root certificates are empty.");
959 return nullptr;
960 }
961 tsi_ssl_root_certs_store* root_store = static_cast<tsi_ssl_root_certs_store*>(
962 gpr_zalloc(sizeof(tsi_ssl_root_certs_store)));
963 if (root_store == nullptr) {
964 gpr_log(GPR_ERROR, "Could not allocate buffer for ssl_root_certs_store.");
965 return nullptr;
966 }
967 root_store->store = X509_STORE_new();
968 if (root_store->store == nullptr) {
969 gpr_log(GPR_ERROR, "Could not allocate buffer for X509_STORE.");
970 gpr_free(root_store);
971 return nullptr;
972 }
973 tsi_result result = x509_store_load_certs(root_store->store, pem_roots,
974 strlen(pem_roots), nullptr);
975 if (result != TSI_OK) {
976 gpr_log(GPR_ERROR, "Could not load root certificates.");
977 X509_STORE_free(root_store->store);
978 gpr_free(root_store);
979 return nullptr;
980 }
981 return root_store;
982 }
983
tsi_ssl_root_certs_store_destroy(tsi_ssl_root_certs_store * self)984 void tsi_ssl_root_certs_store_destroy(tsi_ssl_root_certs_store* self) {
985 if (self == nullptr) return;
986 X509_STORE_free(self->store);
987 gpr_free(self);
988 }
989
990 /* --- tsi_ssl_session_cache methods implementation. ---*/
991
tsi_ssl_session_cache_create_lru(size_t capacity)992 tsi_ssl_session_cache* tsi_ssl_session_cache_create_lru(size_t capacity) {
993 /* Pointer will be dereferenced by unref call. */
994 return reinterpret_cast<tsi_ssl_session_cache*>(
995 tsi::SslSessionLRUCache::Create(capacity).release());
996 }
997
tsi_ssl_session_cache_ref(tsi_ssl_session_cache * cache)998 void tsi_ssl_session_cache_ref(tsi_ssl_session_cache* cache) {
999 /* Pointer will be dereferenced by unref call. */
1000 reinterpret_cast<tsi::SslSessionLRUCache*>(cache)->Ref().release();
1001 }
1002
tsi_ssl_session_cache_unref(tsi_ssl_session_cache * cache)1003 void tsi_ssl_session_cache_unref(tsi_ssl_session_cache* cache) {
1004 reinterpret_cast<tsi::SslSessionLRUCache*>(cache)->Unref();
1005 }
1006
1007 /* --- tsi_frame_protector methods implementation. ---*/
1008
ssl_protector_protect(tsi_frame_protector * self,const unsigned char * unprotected_bytes,size_t * unprotected_bytes_size,unsigned char * protected_output_frames,size_t * protected_output_frames_size)1009 static tsi_result ssl_protector_protect(tsi_frame_protector* self,
1010 const unsigned char* unprotected_bytes,
1011 size_t* unprotected_bytes_size,
1012 unsigned char* protected_output_frames,
1013 size_t* protected_output_frames_size) {
1014 tsi_ssl_frame_protector* impl =
1015 reinterpret_cast<tsi_ssl_frame_protector*>(self);
1016 int read_from_ssl;
1017 size_t available;
1018 tsi_result result = TSI_OK;
1019
1020 /* First see if we have some pending data in the SSL BIO. */
1021 int pending_in_ssl = static_cast<int>(BIO_pending(impl->network_io));
1022 if (pending_in_ssl > 0) {
1023 *unprotected_bytes_size = 0;
1024 GPR_ASSERT(*protected_output_frames_size <= INT_MAX);
1025 read_from_ssl = BIO_read(impl->network_io, protected_output_frames,
1026 static_cast<int>(*protected_output_frames_size));
1027 if (read_from_ssl < 0) {
1028 gpr_log(GPR_ERROR,
1029 "Could not read from BIO even though some data is pending");
1030 return TSI_INTERNAL_ERROR;
1031 }
1032 *protected_output_frames_size = static_cast<size_t>(read_from_ssl);
1033 return TSI_OK;
1034 }
1035
1036 /* Now see if we can send a complete frame. */
1037 available = impl->buffer_size - impl->buffer_offset;
1038 if (available > *unprotected_bytes_size) {
1039 /* If we cannot, just copy the data in our internal buffer. */
1040 memcpy(impl->buffer + impl->buffer_offset, unprotected_bytes,
1041 *unprotected_bytes_size);
1042 impl->buffer_offset += *unprotected_bytes_size;
1043 *protected_output_frames_size = 0;
1044 return TSI_OK;
1045 }
1046
1047 /* If we can, prepare the buffer, send it to SSL_write and read. */
1048 memcpy(impl->buffer + impl->buffer_offset, unprotected_bytes, available);
1049 result = do_ssl_write(impl->ssl, impl->buffer, impl->buffer_size);
1050 if (result != TSI_OK) return result;
1051
1052 GPR_ASSERT(*protected_output_frames_size <= INT_MAX);
1053 read_from_ssl = BIO_read(impl->network_io, protected_output_frames,
1054 static_cast<int>(*protected_output_frames_size));
1055 if (read_from_ssl < 0) {
1056 gpr_log(GPR_ERROR, "Could not read from BIO after SSL_write.");
1057 return TSI_INTERNAL_ERROR;
1058 }
1059 *protected_output_frames_size = static_cast<size_t>(read_from_ssl);
1060 *unprotected_bytes_size = available;
1061 impl->buffer_offset = 0;
1062 return TSI_OK;
1063 }
1064
ssl_protector_protect_flush(tsi_frame_protector * self,unsigned char * protected_output_frames,size_t * protected_output_frames_size,size_t * still_pending_size)1065 static tsi_result ssl_protector_protect_flush(
1066 tsi_frame_protector* self, unsigned char* protected_output_frames,
1067 size_t* protected_output_frames_size, size_t* still_pending_size) {
1068 tsi_result result = TSI_OK;
1069 tsi_ssl_frame_protector* impl =
1070 reinterpret_cast<tsi_ssl_frame_protector*>(self);
1071 int read_from_ssl = 0;
1072 int pending;
1073
1074 if (impl->buffer_offset != 0) {
1075 result = do_ssl_write(impl->ssl, impl->buffer, impl->buffer_offset);
1076 if (result != TSI_OK) return result;
1077 impl->buffer_offset = 0;
1078 }
1079
1080 pending = static_cast<int>(BIO_pending(impl->network_io));
1081 GPR_ASSERT(pending >= 0);
1082 *still_pending_size = static_cast<size_t>(pending);
1083 if (*still_pending_size == 0) return TSI_OK;
1084
1085 GPR_ASSERT(*protected_output_frames_size <= INT_MAX);
1086 read_from_ssl = BIO_read(impl->network_io, protected_output_frames,
1087 static_cast<int>(*protected_output_frames_size));
1088 if (read_from_ssl <= 0) {
1089 gpr_log(GPR_ERROR, "Could not read from BIO after SSL_write.");
1090 return TSI_INTERNAL_ERROR;
1091 }
1092 *protected_output_frames_size = static_cast<size_t>(read_from_ssl);
1093 pending = static_cast<int>(BIO_pending(impl->network_io));
1094 GPR_ASSERT(pending >= 0);
1095 *still_pending_size = static_cast<size_t>(pending);
1096 return TSI_OK;
1097 }
1098
ssl_protector_unprotect(tsi_frame_protector * self,const unsigned char * protected_frames_bytes,size_t * protected_frames_bytes_size,unsigned char * unprotected_bytes,size_t * unprotected_bytes_size)1099 static tsi_result ssl_protector_unprotect(
1100 tsi_frame_protector* self, const unsigned char* protected_frames_bytes,
1101 size_t* protected_frames_bytes_size, unsigned char* unprotected_bytes,
1102 size_t* unprotected_bytes_size) {
1103 tsi_result result = TSI_OK;
1104 int written_into_ssl = 0;
1105 size_t output_bytes_size = *unprotected_bytes_size;
1106 size_t output_bytes_offset = 0;
1107 tsi_ssl_frame_protector* impl =
1108 reinterpret_cast<tsi_ssl_frame_protector*>(self);
1109
1110 /* First, try to read remaining data from ssl. */
1111 result = do_ssl_read(impl->ssl, unprotected_bytes, unprotected_bytes_size);
1112 if (result != TSI_OK) return result;
1113 if (*unprotected_bytes_size == output_bytes_size) {
1114 /* We have read everything we could and cannot process any more input. */
1115 *protected_frames_bytes_size = 0;
1116 return TSI_OK;
1117 }
1118 output_bytes_offset = *unprotected_bytes_size;
1119 unprotected_bytes += output_bytes_offset;
1120 *unprotected_bytes_size = output_bytes_size - output_bytes_offset;
1121
1122 /* Then, try to write some data to ssl. */
1123 GPR_ASSERT(*protected_frames_bytes_size <= INT_MAX);
1124 written_into_ssl = BIO_write(impl->network_io, protected_frames_bytes,
1125 static_cast<int>(*protected_frames_bytes_size));
1126 if (written_into_ssl < 0) {
1127 gpr_log(GPR_ERROR, "Sending protected frame to ssl failed with %d",
1128 written_into_ssl);
1129 return TSI_INTERNAL_ERROR;
1130 }
1131 *protected_frames_bytes_size = static_cast<size_t>(written_into_ssl);
1132
1133 /* Now try to read some data again. */
1134 result = do_ssl_read(impl->ssl, unprotected_bytes, unprotected_bytes_size);
1135 if (result == TSI_OK) {
1136 /* Don't forget to output the total number of bytes read. */
1137 *unprotected_bytes_size += output_bytes_offset;
1138 }
1139 return result;
1140 }
1141
ssl_protector_destroy(tsi_frame_protector * self)1142 static void ssl_protector_destroy(tsi_frame_protector* self) {
1143 tsi_ssl_frame_protector* impl =
1144 reinterpret_cast<tsi_ssl_frame_protector*>(self);
1145 if (impl->buffer != nullptr) gpr_free(impl->buffer);
1146 if (impl->ssl != nullptr) SSL_free(impl->ssl);
1147 if (impl->network_io != nullptr) BIO_free(impl->network_io);
1148 gpr_free(self);
1149 }
1150
1151 static const tsi_frame_protector_vtable frame_protector_vtable = {
1152 ssl_protector_protect,
1153 ssl_protector_protect_flush,
1154 ssl_protector_unprotect,
1155 ssl_protector_destroy,
1156 };
1157
1158 /* --- tsi_server_handshaker_factory methods implementation. --- */
1159
tsi_ssl_handshaker_factory_destroy(tsi_ssl_handshaker_factory * factory)1160 static void tsi_ssl_handshaker_factory_destroy(
1161 tsi_ssl_handshaker_factory* factory) {
1162 if (factory == nullptr) return;
1163
1164 if (factory->vtable != nullptr && factory->vtable->destroy != nullptr) {
1165 factory->vtable->destroy(factory);
1166 }
1167 /* Note, we don't free(self) here because this object is always directly
1168 * embedded in another object. If tsi_ssl_handshaker_factory_init allocates
1169 * any memory, it should be free'd here. */
1170 }
1171
tsi_ssl_handshaker_factory_ref(tsi_ssl_handshaker_factory * factory)1172 static tsi_ssl_handshaker_factory* tsi_ssl_handshaker_factory_ref(
1173 tsi_ssl_handshaker_factory* factory) {
1174 if (factory == nullptr) return nullptr;
1175 gpr_refn(&factory->refcount, 1);
1176 return factory;
1177 }
1178
tsi_ssl_handshaker_factory_unref(tsi_ssl_handshaker_factory * factory)1179 static void tsi_ssl_handshaker_factory_unref(
1180 tsi_ssl_handshaker_factory* factory) {
1181 if (factory == nullptr) return;
1182
1183 if (gpr_unref(&factory->refcount)) {
1184 tsi_ssl_handshaker_factory_destroy(factory);
1185 }
1186 }
1187
1188 static tsi_ssl_handshaker_factory_vtable handshaker_factory_vtable = {nullptr};
1189
1190 /* Initializes a tsi_ssl_handshaker_factory object. Caller is responsible for
1191 * allocating memory for the factory. */
tsi_ssl_handshaker_factory_init(tsi_ssl_handshaker_factory * factory)1192 static void tsi_ssl_handshaker_factory_init(
1193 tsi_ssl_handshaker_factory* factory) {
1194 GPR_ASSERT(factory != nullptr);
1195
1196 factory->vtable = &handshaker_factory_vtable;
1197 gpr_ref_init(&factory->refcount, 1);
1198 }
1199
1200 /* Gets the X509 cert chain in PEM format as a tsi_peer_property. */
tsi_ssl_get_cert_chain_contents(STACK_OF (X509)* peer_chain,tsi_peer_property * property)1201 tsi_result tsi_ssl_get_cert_chain_contents(STACK_OF(X509) * peer_chain,
1202 tsi_peer_property* property) {
1203 BIO* bio = BIO_new(BIO_s_mem());
1204 const auto peer_chain_len = sk_X509_num(peer_chain);
1205 for (auto i = decltype(peer_chain_len){0}; i < peer_chain_len; i++) {
1206 if (!PEM_write_bio_X509(bio, sk_X509_value(peer_chain, i))) {
1207 BIO_free(bio);
1208 return TSI_INTERNAL_ERROR;
1209 }
1210 }
1211 char* contents;
1212 long len = BIO_get_mem_data(bio, &contents);
1213 if (len <= 0) {
1214 BIO_free(bio);
1215 return TSI_INTERNAL_ERROR;
1216 }
1217 tsi_result result = tsi_construct_string_peer_property(
1218 TSI_X509_PEM_CERT_CHAIN_PROPERTY, contents, static_cast<size_t>(len),
1219 property);
1220 BIO_free(bio);
1221 return result;
1222 }
1223
1224 /* --- tsi_handshaker_result methods implementation. ---*/
ssl_handshaker_result_extract_peer(const tsi_handshaker_result * self,tsi_peer * peer)1225 static tsi_result ssl_handshaker_result_extract_peer(
1226 const tsi_handshaker_result* self, tsi_peer* peer) {
1227 tsi_result result = TSI_OK;
1228 const unsigned char* alpn_selected = nullptr;
1229 unsigned int alpn_selected_len;
1230 const tsi_ssl_handshaker_result* impl =
1231 reinterpret_cast<const tsi_ssl_handshaker_result*>(self);
1232 X509* peer_cert = SSL_get_peer_certificate(impl->ssl);
1233 if (peer_cert != nullptr) {
1234 result = peer_from_x509(peer_cert, 1, peer);
1235 X509_free(peer_cert);
1236 if (result != TSI_OK) return result;
1237 }
1238 #if TSI_OPENSSL_ALPN_SUPPORT
1239 SSL_get0_alpn_selected(impl->ssl, &alpn_selected, &alpn_selected_len);
1240 #endif /* TSI_OPENSSL_ALPN_SUPPORT */
1241 if (alpn_selected == nullptr) {
1242 /* Try npn. */
1243 SSL_get0_next_proto_negotiated(impl->ssl, &alpn_selected,
1244 &alpn_selected_len);
1245 }
1246 // When called on the client side, the stack also contains the
1247 // peer's certificate; When called on the server side,
1248 // the peer's certificate is not present in the stack
1249 STACK_OF(X509)* peer_chain = SSL_get_peer_cert_chain(impl->ssl);
1250 // 1 is for session reused property.
1251 size_t new_property_count = peer->property_count + 3;
1252 if (alpn_selected != nullptr) new_property_count++;
1253 if (peer_chain != nullptr) new_property_count++;
1254 tsi_peer_property* new_properties = static_cast<tsi_peer_property*>(
1255 gpr_zalloc(sizeof(*new_properties) * new_property_count));
1256 for (size_t i = 0; i < peer->property_count; i++) {
1257 new_properties[i] = peer->properties[i];
1258 }
1259 if (peer->properties != nullptr) gpr_free(peer->properties);
1260 peer->properties = new_properties;
1261 // Add peer chain if available
1262 if (peer_chain != nullptr) {
1263 result = tsi_ssl_get_cert_chain_contents(
1264 peer_chain, &peer->properties[peer->property_count]);
1265 if (result == TSI_OK) peer->property_count++;
1266 }
1267 if (alpn_selected != nullptr) {
1268 result = tsi_construct_string_peer_property(
1269 TSI_SSL_ALPN_SELECTED_PROTOCOL,
1270 reinterpret_cast<const char*>(alpn_selected), alpn_selected_len,
1271 &peer->properties[peer->property_count]);
1272 if (result != TSI_OK) return result;
1273 peer->property_count++;
1274 }
1275 // Add security_level peer property.
1276 result = tsi_construct_string_peer_property_from_cstring(
1277 TSI_SECURITY_LEVEL_PEER_PROPERTY,
1278 tsi_security_level_to_string(TSI_PRIVACY_AND_INTEGRITY),
1279 &peer->properties[peer->property_count]);
1280 if (result != TSI_OK) return result;
1281 peer->property_count++;
1282
1283 const char* session_reused = SSL_session_reused(impl->ssl) ? "true" : "false";
1284 result = tsi_construct_string_peer_property_from_cstring(
1285 TSI_SSL_SESSION_REUSED_PEER_PROPERTY, session_reused,
1286 &peer->properties[peer->property_count]);
1287 if (result != TSI_OK) return result;
1288 peer->property_count++;
1289 return result;
1290 }
1291
ssl_handshaker_result_create_frame_protector(const tsi_handshaker_result * self,size_t * max_output_protected_frame_size,tsi_frame_protector ** protector)1292 static tsi_result ssl_handshaker_result_create_frame_protector(
1293 const tsi_handshaker_result* self, size_t* max_output_protected_frame_size,
1294 tsi_frame_protector** protector) {
1295 size_t actual_max_output_protected_frame_size =
1296 TSI_SSL_MAX_PROTECTED_FRAME_SIZE_UPPER_BOUND;
1297 tsi_ssl_handshaker_result* impl =
1298 reinterpret_cast<tsi_ssl_handshaker_result*>(
1299 const_cast<tsi_handshaker_result*>(self));
1300 tsi_ssl_frame_protector* protector_impl =
1301 static_cast<tsi_ssl_frame_protector*>(
1302 gpr_zalloc(sizeof(*protector_impl)));
1303
1304 if (max_output_protected_frame_size != nullptr) {
1305 if (*max_output_protected_frame_size >
1306 TSI_SSL_MAX_PROTECTED_FRAME_SIZE_UPPER_BOUND) {
1307 *max_output_protected_frame_size =
1308 TSI_SSL_MAX_PROTECTED_FRAME_SIZE_UPPER_BOUND;
1309 } else if (*max_output_protected_frame_size <
1310 TSI_SSL_MAX_PROTECTED_FRAME_SIZE_LOWER_BOUND) {
1311 *max_output_protected_frame_size =
1312 TSI_SSL_MAX_PROTECTED_FRAME_SIZE_LOWER_BOUND;
1313 }
1314 actual_max_output_protected_frame_size = *max_output_protected_frame_size;
1315 }
1316 protector_impl->buffer_size =
1317 actual_max_output_protected_frame_size - TSI_SSL_MAX_PROTECTION_OVERHEAD;
1318 protector_impl->buffer =
1319 static_cast<unsigned char*>(gpr_malloc(protector_impl->buffer_size));
1320 if (protector_impl->buffer == nullptr) {
1321 gpr_log(GPR_ERROR,
1322 "Could not allocated buffer for tsi_ssl_frame_protector.");
1323 gpr_free(protector_impl);
1324 return TSI_INTERNAL_ERROR;
1325 }
1326
1327 /* Transfer ownership of ssl and network_io to the frame protector. */
1328 protector_impl->ssl = impl->ssl;
1329 impl->ssl = nullptr;
1330 protector_impl->network_io = impl->network_io;
1331 impl->network_io = nullptr;
1332 protector_impl->base.vtable = &frame_protector_vtable;
1333 *protector = &protector_impl->base;
1334 return TSI_OK;
1335 }
1336
ssl_handshaker_result_get_unused_bytes(const tsi_handshaker_result * self,const unsigned char ** bytes,size_t * bytes_size)1337 static tsi_result ssl_handshaker_result_get_unused_bytes(
1338 const tsi_handshaker_result* self, const unsigned char** bytes,
1339 size_t* bytes_size) {
1340 const tsi_ssl_handshaker_result* impl =
1341 reinterpret_cast<const tsi_ssl_handshaker_result*>(self);
1342 *bytes_size = impl->unused_bytes_size;
1343 *bytes = impl->unused_bytes;
1344 return TSI_OK;
1345 }
1346
ssl_handshaker_result_destroy(tsi_handshaker_result * self)1347 static void ssl_handshaker_result_destroy(tsi_handshaker_result* self) {
1348 tsi_ssl_handshaker_result* impl =
1349 reinterpret_cast<tsi_ssl_handshaker_result*>(self);
1350 SSL_free(impl->ssl);
1351 BIO_free(impl->network_io);
1352 gpr_free(impl->unused_bytes);
1353 gpr_free(impl);
1354 }
1355
1356 static const tsi_handshaker_result_vtable handshaker_result_vtable = {
1357 ssl_handshaker_result_extract_peer,
1358 nullptr, /* create_zero_copy_grpc_protector */
1359 ssl_handshaker_result_create_frame_protector,
1360 ssl_handshaker_result_get_unused_bytes,
1361 ssl_handshaker_result_destroy,
1362 };
1363
ssl_handshaker_result_create(tsi_ssl_handshaker * handshaker,unsigned char * unused_bytes,size_t unused_bytes_size,tsi_handshaker_result ** handshaker_result)1364 static tsi_result ssl_handshaker_result_create(
1365 tsi_ssl_handshaker* handshaker, unsigned char* unused_bytes,
1366 size_t unused_bytes_size, tsi_handshaker_result** handshaker_result) {
1367 if (handshaker == nullptr || handshaker_result == nullptr ||
1368 (unused_bytes_size > 0 && unused_bytes == nullptr)) {
1369 return TSI_INVALID_ARGUMENT;
1370 }
1371 tsi_ssl_handshaker_result* result =
1372 static_cast<tsi_ssl_handshaker_result*>(gpr_zalloc(sizeof(*result)));
1373 result->base.vtable = &handshaker_result_vtable;
1374 /* Transfer ownership of ssl and network_io to the handshaker result. */
1375 result->ssl = handshaker->ssl;
1376 handshaker->ssl = nullptr;
1377 result->network_io = handshaker->network_io;
1378 handshaker->network_io = nullptr;
1379 /* Transfer ownership of |unused_bytes| to the handshaker result. */
1380 result->unused_bytes = unused_bytes;
1381 result->unused_bytes_size = unused_bytes_size;
1382 *handshaker_result = &result->base;
1383 return TSI_OK;
1384 }
1385
1386 /* --- tsi_handshaker methods implementation. ---*/
1387
ssl_handshaker_get_bytes_to_send_to_peer(tsi_ssl_handshaker * impl,unsigned char * bytes,size_t * bytes_size)1388 static tsi_result ssl_handshaker_get_bytes_to_send_to_peer(
1389 tsi_ssl_handshaker* impl, unsigned char* bytes, size_t* bytes_size) {
1390 int bytes_read_from_ssl = 0;
1391 if (bytes == nullptr || bytes_size == nullptr || *bytes_size == 0 ||
1392 *bytes_size > INT_MAX) {
1393 return TSI_INVALID_ARGUMENT;
1394 }
1395 GPR_ASSERT(*bytes_size <= INT_MAX);
1396 bytes_read_from_ssl =
1397 BIO_read(impl->network_io, bytes, static_cast<int>(*bytes_size));
1398 if (bytes_read_from_ssl < 0) {
1399 *bytes_size = 0;
1400 if (!BIO_should_retry(impl->network_io)) {
1401 impl->result = TSI_INTERNAL_ERROR;
1402 return impl->result;
1403 } else {
1404 return TSI_OK;
1405 }
1406 }
1407 *bytes_size = static_cast<size_t>(bytes_read_from_ssl);
1408 return BIO_pending(impl->network_io) == 0 ? TSI_OK : TSI_INCOMPLETE_DATA;
1409 }
1410
ssl_handshaker_get_result(tsi_ssl_handshaker * impl)1411 static tsi_result ssl_handshaker_get_result(tsi_ssl_handshaker* impl) {
1412 if ((impl->result == TSI_HANDSHAKE_IN_PROGRESS) &&
1413 SSL_is_init_finished(impl->ssl)) {
1414 impl->result = TSI_OK;
1415 }
1416 return impl->result;
1417 }
1418
ssl_handshaker_process_bytes_from_peer(tsi_ssl_handshaker * impl,const unsigned char * bytes,size_t * bytes_size)1419 static tsi_result ssl_handshaker_process_bytes_from_peer(
1420 tsi_ssl_handshaker* impl, const unsigned char* bytes, size_t* bytes_size) {
1421 int bytes_written_into_ssl_size = 0;
1422 if (bytes == nullptr || bytes_size == nullptr || *bytes_size > INT_MAX) {
1423 return TSI_INVALID_ARGUMENT;
1424 }
1425 GPR_ASSERT(*bytes_size <= INT_MAX);
1426 bytes_written_into_ssl_size =
1427 BIO_write(impl->network_io, bytes, static_cast<int>(*bytes_size));
1428 if (bytes_written_into_ssl_size < 0) {
1429 gpr_log(GPR_ERROR, "Could not write to memory BIO.");
1430 impl->result = TSI_INTERNAL_ERROR;
1431 return impl->result;
1432 }
1433 *bytes_size = static_cast<size_t>(bytes_written_into_ssl_size);
1434
1435 if (ssl_handshaker_get_result(impl) != TSI_HANDSHAKE_IN_PROGRESS) {
1436 impl->result = TSI_OK;
1437 return impl->result;
1438 } else {
1439 /* Get ready to get some bytes from SSL. */
1440 int ssl_result = SSL_do_handshake(impl->ssl);
1441 ssl_result = SSL_get_error(impl->ssl, ssl_result);
1442 switch (ssl_result) {
1443 case SSL_ERROR_WANT_READ:
1444 if (BIO_pending(impl->network_io) == 0) {
1445 /* We need more data. */
1446 return TSI_INCOMPLETE_DATA;
1447 } else {
1448 return TSI_OK;
1449 }
1450 case SSL_ERROR_NONE:
1451 return TSI_OK;
1452 default: {
1453 char err_str[256];
1454 ERR_error_string_n(ERR_get_error(), err_str, sizeof(err_str));
1455 gpr_log(GPR_ERROR, "Handshake failed with fatal error %s: %s.",
1456 ssl_error_string(ssl_result), err_str);
1457 impl->result = TSI_PROTOCOL_FAILURE;
1458 return impl->result;
1459 }
1460 }
1461 }
1462 }
1463
ssl_handshaker_destroy(tsi_handshaker * self)1464 static void ssl_handshaker_destroy(tsi_handshaker* self) {
1465 tsi_ssl_handshaker* impl = reinterpret_cast<tsi_ssl_handshaker*>(self);
1466 SSL_free(impl->ssl);
1467 BIO_free(impl->network_io);
1468 gpr_free(impl->outgoing_bytes_buffer);
1469 tsi_ssl_handshaker_factory_unref(impl->factory_ref);
1470 gpr_free(impl);
1471 }
1472
1473 // Removes the bytes remaining in |impl->SSL|'s read BIO and writes them to
1474 // |bytes_remaining|.
ssl_bytes_remaining(tsi_ssl_handshaker * impl,unsigned char ** bytes_remaining,size_t * bytes_remaining_size)1475 static tsi_result ssl_bytes_remaining(tsi_ssl_handshaker* impl,
1476 unsigned char** bytes_remaining,
1477 size_t* bytes_remaining_size) {
1478 if (impl == nullptr || bytes_remaining == nullptr ||
1479 bytes_remaining_size == nullptr) {
1480 return TSI_INVALID_ARGUMENT;
1481 }
1482 // Atempt to read all of the bytes in SSL's read BIO. These bytes should
1483 // contain application data records that were appended to a handshake record
1484 // containing the ClientFinished or ServerFinished message.
1485 size_t bytes_in_ssl = BIO_pending(SSL_get_rbio(impl->ssl));
1486 if (bytes_in_ssl == 0) return TSI_OK;
1487 *bytes_remaining = static_cast<uint8_t*>(gpr_malloc(bytes_in_ssl));
1488 int bytes_read = BIO_read(SSL_get_rbio(impl->ssl), *bytes_remaining,
1489 static_cast<int>(bytes_in_ssl));
1490 // If an unexpected number of bytes were read, return an error status and free
1491 // all of the bytes that were read.
1492 if (bytes_read < 0 || static_cast<size_t>(bytes_read) != bytes_in_ssl) {
1493 gpr_log(GPR_ERROR,
1494 "Failed to read the expected number of bytes from SSL object.");
1495 gpr_free(*bytes_remaining);
1496 *bytes_remaining = nullptr;
1497 return TSI_INTERNAL_ERROR;
1498 }
1499 *bytes_remaining_size = static_cast<size_t>(bytes_read);
1500 return TSI_OK;
1501 }
1502
ssl_handshaker_next(tsi_handshaker * self,const unsigned char * received_bytes,size_t received_bytes_size,const unsigned char ** bytes_to_send,size_t * bytes_to_send_size,tsi_handshaker_result ** handshaker_result,tsi_handshaker_on_next_done_cb,void *)1503 static tsi_result ssl_handshaker_next(
1504 tsi_handshaker* self, const unsigned char* received_bytes,
1505 size_t received_bytes_size, const unsigned char** bytes_to_send,
1506 size_t* bytes_to_send_size, tsi_handshaker_result** handshaker_result,
1507 tsi_handshaker_on_next_done_cb /*cb*/, void* /*user_data*/) {
1508 /* Input sanity check. */
1509 if ((received_bytes_size > 0 && received_bytes == nullptr) ||
1510 bytes_to_send == nullptr || bytes_to_send_size == nullptr ||
1511 handshaker_result == nullptr) {
1512 return TSI_INVALID_ARGUMENT;
1513 }
1514 /* If there are received bytes, process them first. */
1515 tsi_ssl_handshaker* impl = reinterpret_cast<tsi_ssl_handshaker*>(self);
1516 tsi_result status = TSI_OK;
1517 size_t bytes_consumed = received_bytes_size;
1518 if (received_bytes_size > 0) {
1519 status = ssl_handshaker_process_bytes_from_peer(impl, received_bytes,
1520 &bytes_consumed);
1521 if (status != TSI_OK) return status;
1522 }
1523 /* Get bytes to send to the peer, if available. */
1524 size_t offset = 0;
1525 do {
1526 size_t to_send_size = impl->outgoing_bytes_buffer_size - offset;
1527 status = ssl_handshaker_get_bytes_to_send_to_peer(
1528 impl, impl->outgoing_bytes_buffer + offset, &to_send_size);
1529 offset += to_send_size;
1530 if (status == TSI_INCOMPLETE_DATA) {
1531 impl->outgoing_bytes_buffer_size *= 2;
1532 impl->outgoing_bytes_buffer = static_cast<unsigned char*>(gpr_realloc(
1533 impl->outgoing_bytes_buffer, impl->outgoing_bytes_buffer_size));
1534 }
1535 } while (status == TSI_INCOMPLETE_DATA);
1536 if (status != TSI_OK) return status;
1537 *bytes_to_send = impl->outgoing_bytes_buffer;
1538 *bytes_to_send_size = offset;
1539 /* If handshake completes, create tsi_handshaker_result. */
1540 if (ssl_handshaker_get_result(impl) == TSI_HANDSHAKE_IN_PROGRESS) {
1541 *handshaker_result = nullptr;
1542 } else {
1543 // Any bytes that remain in |impl->ssl|'s read BIO after the handshake is
1544 // complete must be extracted and set to the unused bytes of the handshaker
1545 // result. This indicates to the gRPC stack that there are bytes from the
1546 // peer that must be processed.
1547 unsigned char* unused_bytes = nullptr;
1548 size_t unused_bytes_size = 0;
1549 status = ssl_bytes_remaining(impl, &unused_bytes, &unused_bytes_size);
1550 if (status != TSI_OK) return status;
1551 if (unused_bytes_size > received_bytes_size) {
1552 gpr_log(GPR_ERROR, "More unused bytes than received bytes.");
1553 gpr_free(unused_bytes);
1554 return TSI_INTERNAL_ERROR;
1555 }
1556 status = ssl_handshaker_result_create(impl, unused_bytes, unused_bytes_size,
1557 handshaker_result);
1558 if (status == TSI_OK) {
1559 /* Indicates that the handshake has completed and that a handshaker_result
1560 * has been created. */
1561 self->handshaker_result_created = true;
1562 }
1563 }
1564 return status;
1565 }
1566
1567 static const tsi_handshaker_vtable handshaker_vtable = {
1568 nullptr, /* get_bytes_to_send_to_peer -- deprecated */
1569 nullptr, /* process_bytes_from_peer -- deprecated */
1570 nullptr, /* get_result -- deprecated */
1571 nullptr, /* extract_peer -- deprecated */
1572 nullptr, /* create_frame_protector -- deprecated */
1573 ssl_handshaker_destroy,
1574 ssl_handshaker_next,
1575 nullptr, /* shutdown */
1576 };
1577
1578 /* --- tsi_ssl_handshaker_factory common methods. --- */
1579
tsi_ssl_handshaker_resume_session(SSL * ssl,tsi::SslSessionLRUCache * session_cache)1580 static void tsi_ssl_handshaker_resume_session(
1581 SSL* ssl, tsi::SslSessionLRUCache* session_cache) {
1582 const char* server_name = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
1583 if (server_name == nullptr) {
1584 return;
1585 }
1586 tsi::SslSessionPtr session = session_cache->Get(server_name);
1587 if (session != nullptr) {
1588 // SSL_set_session internally increments reference counter.
1589 SSL_set_session(ssl, session.get());
1590 }
1591 }
1592
create_tsi_ssl_handshaker(SSL_CTX * ctx,int is_client,const char * server_name_indication,tsi_ssl_handshaker_factory * factory,tsi_handshaker ** handshaker)1593 static tsi_result create_tsi_ssl_handshaker(SSL_CTX* ctx, int is_client,
1594 const char* server_name_indication,
1595 tsi_ssl_handshaker_factory* factory,
1596 tsi_handshaker** handshaker) {
1597 SSL* ssl = SSL_new(ctx);
1598 BIO* network_io = nullptr;
1599 BIO* ssl_io = nullptr;
1600 tsi_ssl_handshaker* impl = nullptr;
1601 *handshaker = nullptr;
1602 if (ctx == nullptr) {
1603 gpr_log(GPR_ERROR, "SSL Context is null. Should never happen.");
1604 return TSI_INTERNAL_ERROR;
1605 }
1606 if (ssl == nullptr) {
1607 return TSI_OUT_OF_RESOURCES;
1608 }
1609 SSL_set_info_callback(ssl, ssl_info_callback);
1610
1611 if (!BIO_new_bio_pair(&network_io, 0, &ssl_io, 0)) {
1612 gpr_log(GPR_ERROR, "BIO_new_bio_pair failed.");
1613 SSL_free(ssl);
1614 return TSI_OUT_OF_RESOURCES;
1615 }
1616 SSL_set_bio(ssl, ssl_io, ssl_io);
1617 if (is_client) {
1618 int ssl_result;
1619 SSL_set_connect_state(ssl);
1620 if (server_name_indication != nullptr) {
1621 if (!SSL_set_tlsext_host_name(ssl, server_name_indication)) {
1622 gpr_log(GPR_ERROR, "Invalid server name indication %s.",
1623 server_name_indication);
1624 SSL_free(ssl);
1625 BIO_free(network_io);
1626 return TSI_INTERNAL_ERROR;
1627 }
1628 }
1629 tsi_ssl_client_handshaker_factory* client_factory =
1630 reinterpret_cast<tsi_ssl_client_handshaker_factory*>(factory);
1631 if (client_factory->session_cache != nullptr) {
1632 tsi_ssl_handshaker_resume_session(ssl,
1633 client_factory->session_cache.get());
1634 }
1635 ssl_result = SSL_do_handshake(ssl);
1636 ssl_result = SSL_get_error(ssl, ssl_result);
1637 if (ssl_result != SSL_ERROR_WANT_READ) {
1638 gpr_log(GPR_ERROR,
1639 "Unexpected error received from first SSL_do_handshake call: %s",
1640 ssl_error_string(ssl_result));
1641 SSL_free(ssl);
1642 BIO_free(network_io);
1643 return TSI_INTERNAL_ERROR;
1644 }
1645 } else {
1646 SSL_set_accept_state(ssl);
1647 }
1648
1649 impl = static_cast<tsi_ssl_handshaker*>(gpr_zalloc(sizeof(*impl)));
1650 impl->ssl = ssl;
1651 impl->network_io = network_io;
1652 impl->result = TSI_HANDSHAKE_IN_PROGRESS;
1653 impl->outgoing_bytes_buffer_size =
1654 TSI_SSL_HANDSHAKER_OUTGOING_BUFFER_INITIAL_SIZE;
1655 impl->outgoing_bytes_buffer =
1656 static_cast<unsigned char*>(gpr_zalloc(impl->outgoing_bytes_buffer_size));
1657 impl->base.vtable = &handshaker_vtable;
1658 impl->factory_ref = tsi_ssl_handshaker_factory_ref(factory);
1659 *handshaker = &impl->base;
1660 return TSI_OK;
1661 }
1662
select_protocol_list(const unsigned char ** out,unsigned char * outlen,const unsigned char * client_list,size_t client_list_len,const unsigned char * server_list,size_t server_list_len)1663 static int select_protocol_list(const unsigned char** out,
1664 unsigned char* outlen,
1665 const unsigned char* client_list,
1666 size_t client_list_len,
1667 const unsigned char* server_list,
1668 size_t server_list_len) {
1669 const unsigned char* client_current = client_list;
1670 while (static_cast<unsigned int>(client_current - client_list) <
1671 client_list_len) {
1672 unsigned char client_current_len = *(client_current++);
1673 const unsigned char* server_current = server_list;
1674 while ((server_current >= server_list) &&
1675 static_cast<uintptr_t>(server_current - server_list) <
1676 server_list_len) {
1677 unsigned char server_current_len = *(server_current++);
1678 if ((client_current_len == server_current_len) &&
1679 !memcmp(client_current, server_current, server_current_len)) {
1680 *out = server_current;
1681 *outlen = server_current_len;
1682 return SSL_TLSEXT_ERR_OK;
1683 }
1684 server_current += server_current_len;
1685 }
1686 client_current += client_current_len;
1687 }
1688 return SSL_TLSEXT_ERR_NOACK;
1689 }
1690
1691 /* --- tsi_ssl_client_handshaker_factory methods implementation. --- */
1692
tsi_ssl_client_handshaker_factory_create_handshaker(tsi_ssl_client_handshaker_factory * factory,const char * server_name_indication,tsi_handshaker ** handshaker)1693 tsi_result tsi_ssl_client_handshaker_factory_create_handshaker(
1694 tsi_ssl_client_handshaker_factory* factory,
1695 const char* server_name_indication, tsi_handshaker** handshaker) {
1696 return create_tsi_ssl_handshaker(factory->ssl_context, 1,
1697 server_name_indication, &factory->base,
1698 handshaker);
1699 }
1700
tsi_ssl_client_handshaker_factory_unref(tsi_ssl_client_handshaker_factory * factory)1701 void tsi_ssl_client_handshaker_factory_unref(
1702 tsi_ssl_client_handshaker_factory* factory) {
1703 if (factory == nullptr) return;
1704 tsi_ssl_handshaker_factory_unref(&factory->base);
1705 }
1706
tsi_ssl_client_handshaker_factory_destroy(tsi_ssl_handshaker_factory * factory)1707 static void tsi_ssl_client_handshaker_factory_destroy(
1708 tsi_ssl_handshaker_factory* factory) {
1709 if (factory == nullptr) return;
1710 tsi_ssl_client_handshaker_factory* self =
1711 reinterpret_cast<tsi_ssl_client_handshaker_factory*>(factory);
1712 if (self->ssl_context != nullptr) SSL_CTX_free(self->ssl_context);
1713 if (self->alpn_protocol_list != nullptr) gpr_free(self->alpn_protocol_list);
1714 self->session_cache.reset();
1715 gpr_free(self);
1716 }
1717
client_handshaker_factory_npn_callback(SSL *,unsigned char ** out,unsigned char * outlen,const unsigned char * in,unsigned int inlen,void * arg)1718 static int client_handshaker_factory_npn_callback(
1719 SSL* /*ssl*/, unsigned char** out, unsigned char* outlen,
1720 const unsigned char* in, unsigned int inlen, void* arg) {
1721 tsi_ssl_client_handshaker_factory* factory =
1722 static_cast<tsi_ssl_client_handshaker_factory*>(arg);
1723 return select_protocol_list(const_cast<const unsigned char**>(out), outlen,
1724 factory->alpn_protocol_list,
1725 factory->alpn_protocol_list_length, in, inlen);
1726 }
1727
1728 /* --- tsi_ssl_server_handshaker_factory methods implementation. --- */
1729
tsi_ssl_server_handshaker_factory_create_handshaker(tsi_ssl_server_handshaker_factory * factory,tsi_handshaker ** handshaker)1730 tsi_result tsi_ssl_server_handshaker_factory_create_handshaker(
1731 tsi_ssl_server_handshaker_factory* factory, tsi_handshaker** handshaker) {
1732 if (factory->ssl_context_count == 0) return TSI_INVALID_ARGUMENT;
1733 /* Create the handshaker with the first context. We will switch if needed
1734 because of SNI in ssl_server_handshaker_factory_servername_callback. */
1735 return create_tsi_ssl_handshaker(factory->ssl_contexts[0], 0, nullptr,
1736 &factory->base, handshaker);
1737 }
1738
tsi_ssl_server_handshaker_factory_unref(tsi_ssl_server_handshaker_factory * factory)1739 void tsi_ssl_server_handshaker_factory_unref(
1740 tsi_ssl_server_handshaker_factory* factory) {
1741 if (factory == nullptr) return;
1742 tsi_ssl_handshaker_factory_unref(&factory->base);
1743 }
1744
tsi_ssl_server_handshaker_factory_destroy(tsi_ssl_handshaker_factory * factory)1745 static void tsi_ssl_server_handshaker_factory_destroy(
1746 tsi_ssl_handshaker_factory* factory) {
1747 if (factory == nullptr) return;
1748 tsi_ssl_server_handshaker_factory* self =
1749 reinterpret_cast<tsi_ssl_server_handshaker_factory*>(factory);
1750 size_t i;
1751 for (i = 0; i < self->ssl_context_count; i++) {
1752 if (self->ssl_contexts[i] != nullptr) {
1753 SSL_CTX_free(self->ssl_contexts[i]);
1754 tsi_peer_destruct(&self->ssl_context_x509_subject_names[i]);
1755 }
1756 }
1757 if (self->ssl_contexts != nullptr) gpr_free(self->ssl_contexts);
1758 if (self->ssl_context_x509_subject_names != nullptr) {
1759 gpr_free(self->ssl_context_x509_subject_names);
1760 }
1761 if (self->alpn_protocol_list != nullptr) gpr_free(self->alpn_protocol_list);
1762 gpr_free(self);
1763 }
1764
does_entry_match_name(absl::string_view entry,absl::string_view name)1765 static int does_entry_match_name(absl::string_view entry,
1766 absl::string_view name) {
1767 if (entry.empty()) return 0;
1768
1769 /* Take care of '.' terminations. */
1770 if (name.back() == '.') {
1771 name.remove_suffix(1);
1772 }
1773 if (entry.back() == '.') {
1774 entry.remove_suffix(1);
1775 if (entry.empty()) return 0;
1776 }
1777
1778 if (absl::EqualsIgnoreCase(name, entry)) {
1779 return 1; /* Perfect match. */
1780 }
1781 if (entry.front() != '*') return 0;
1782
1783 /* Wildchar subdomain matching. */
1784 if (entry.size() < 3 || entry[1] != '.') { /* At least *.x */
1785 gpr_log(GPR_ERROR, "Invalid wildchar entry.");
1786 return 0;
1787 }
1788 size_t name_subdomain_pos = name.find('.');
1789 if (name_subdomain_pos == absl::string_view::npos) return 0;
1790 if (name_subdomain_pos >= name.size() - 2) return 0;
1791 absl::string_view name_subdomain =
1792 name.substr(name_subdomain_pos + 1); /* Starts after the dot. */
1793 entry.remove_prefix(2); /* Remove *. */
1794 size_t dot = name_subdomain.find('.');
1795 if (dot == absl::string_view::npos || dot == name_subdomain.size() - 1) {
1796 gpr_log(GPR_ERROR, "Invalid toplevel subdomain: %s",
1797 std::string(name_subdomain).c_str());
1798 return 0;
1799 }
1800 if (name_subdomain.back() == '.') {
1801 name_subdomain.remove_suffix(1);
1802 }
1803 return !entry.empty() && absl::EqualsIgnoreCase(name_subdomain, entry);
1804 }
1805
ssl_server_handshaker_factory_servername_callback(SSL * ssl,int *,void * arg)1806 static int ssl_server_handshaker_factory_servername_callback(SSL* ssl,
1807 int* /*ap*/,
1808 void* arg) {
1809 tsi_ssl_server_handshaker_factory* impl =
1810 static_cast<tsi_ssl_server_handshaker_factory*>(arg);
1811 size_t i = 0;
1812 const char* servername = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
1813 if (servername == nullptr || strlen(servername) == 0) {
1814 return SSL_TLSEXT_ERR_NOACK;
1815 }
1816
1817 for (i = 0; i < impl->ssl_context_count; i++) {
1818 if (tsi_ssl_peer_matches_name(&impl->ssl_context_x509_subject_names[i],
1819 servername)) {
1820 SSL_set_SSL_CTX(ssl, impl->ssl_contexts[i]);
1821 return SSL_TLSEXT_ERR_OK;
1822 }
1823 }
1824 gpr_log(GPR_ERROR, "No match found for server name: %s.", servername);
1825 return SSL_TLSEXT_ERR_NOACK;
1826 }
1827
1828 #if TSI_OPENSSL_ALPN_SUPPORT
server_handshaker_factory_alpn_callback(SSL *,const unsigned char ** out,unsigned char * outlen,const unsigned char * in,unsigned int inlen,void * arg)1829 static int server_handshaker_factory_alpn_callback(
1830 SSL* /*ssl*/, const unsigned char** out, unsigned char* outlen,
1831 const unsigned char* in, unsigned int inlen, void* arg) {
1832 tsi_ssl_server_handshaker_factory* factory =
1833 static_cast<tsi_ssl_server_handshaker_factory*>(arg);
1834 return select_protocol_list(out, outlen, in, inlen,
1835 factory->alpn_protocol_list,
1836 factory->alpn_protocol_list_length);
1837 }
1838 #endif /* TSI_OPENSSL_ALPN_SUPPORT */
1839
server_handshaker_factory_npn_advertised_callback(SSL *,const unsigned char ** out,unsigned int * outlen,void * arg)1840 static int server_handshaker_factory_npn_advertised_callback(
1841 SSL* /*ssl*/, const unsigned char** out, unsigned int* outlen, void* arg) {
1842 tsi_ssl_server_handshaker_factory* factory =
1843 static_cast<tsi_ssl_server_handshaker_factory*>(arg);
1844 *out = factory->alpn_protocol_list;
1845 GPR_ASSERT(factory->alpn_protocol_list_length <= UINT_MAX);
1846 *outlen = static_cast<unsigned int>(factory->alpn_protocol_list_length);
1847 return SSL_TLSEXT_ERR_OK;
1848 }
1849
1850 /// This callback is called when new \a session is established and ready to
1851 /// be cached. This session can be reused for new connections to similar
1852 /// servers at later point of time.
1853 /// It's intended to be used with SSL_CTX_sess_set_new_cb function.
1854 ///
1855 /// It returns 1 if callback takes ownership over \a session and 0 otherwise.
server_handshaker_factory_new_session_callback(SSL * ssl,SSL_SESSION * session)1856 static int server_handshaker_factory_new_session_callback(
1857 SSL* ssl, SSL_SESSION* session) {
1858 SSL_CTX* ssl_context = SSL_get_SSL_CTX(ssl);
1859 if (ssl_context == nullptr) {
1860 return 0;
1861 }
1862 void* arg = SSL_CTX_get_ex_data(ssl_context, g_ssl_ctx_ex_factory_index);
1863 tsi_ssl_client_handshaker_factory* factory =
1864 static_cast<tsi_ssl_client_handshaker_factory*>(arg);
1865 const char* server_name = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
1866 if (server_name == nullptr) {
1867 return 0;
1868 }
1869 factory->session_cache->Put(server_name, tsi::SslSessionPtr(session));
1870 // Return 1 to indicate transferred ownership over the given session.
1871 return 1;
1872 }
1873
1874 /* --- tsi_ssl_handshaker_factory constructors. --- */
1875
1876 static tsi_ssl_handshaker_factory_vtable client_handshaker_factory_vtable = {
1877 tsi_ssl_client_handshaker_factory_destroy};
1878
tsi_create_ssl_client_handshaker_factory(const tsi_ssl_pem_key_cert_pair * pem_key_cert_pair,const char * pem_root_certs,const char * cipher_suites,const char ** alpn_protocols,uint16_t num_alpn_protocols,tsi_ssl_client_handshaker_factory ** factory)1879 tsi_result tsi_create_ssl_client_handshaker_factory(
1880 const tsi_ssl_pem_key_cert_pair* pem_key_cert_pair,
1881 const char* pem_root_certs, const char* cipher_suites,
1882 const char** alpn_protocols, uint16_t num_alpn_protocols,
1883 tsi_ssl_client_handshaker_factory** factory) {
1884 tsi_ssl_client_handshaker_options options;
1885 options.pem_key_cert_pair = pem_key_cert_pair;
1886 options.pem_root_certs = pem_root_certs;
1887 options.cipher_suites = cipher_suites;
1888 options.alpn_protocols = alpn_protocols;
1889 options.num_alpn_protocols = num_alpn_protocols;
1890 return tsi_create_ssl_client_handshaker_factory_with_options(&options,
1891 factory);
1892 }
1893
tsi_create_ssl_client_handshaker_factory_with_options(const tsi_ssl_client_handshaker_options * options,tsi_ssl_client_handshaker_factory ** factory)1894 tsi_result tsi_create_ssl_client_handshaker_factory_with_options(
1895 const tsi_ssl_client_handshaker_options* options,
1896 tsi_ssl_client_handshaker_factory** factory) {
1897 SSL_CTX* ssl_context = nullptr;
1898 tsi_ssl_client_handshaker_factory* impl = nullptr;
1899 tsi_result result = TSI_OK;
1900
1901 gpr_once_init(&g_init_openssl_once, init_openssl);
1902
1903 if (factory == nullptr) return TSI_INVALID_ARGUMENT;
1904 *factory = nullptr;
1905 if (options->pem_root_certs == nullptr && options->root_store == nullptr) {
1906 return TSI_INVALID_ARGUMENT;
1907 }
1908
1909 #if OPENSSL_VERSION_NUMBER >= 0x10100000
1910 ssl_context = SSL_CTX_new(TLS_method());
1911 #else
1912 ssl_context = SSL_CTX_new(TLSv1_2_method());
1913 #endif
1914 result = tsi_set_min_and_max_tls_versions(
1915 ssl_context, options->min_tls_version, options->max_tls_version);
1916 if (result != TSI_OK) return result;
1917 if (ssl_context == nullptr) {
1918 gpr_log(GPR_ERROR, "Could not create ssl context.");
1919 return TSI_INVALID_ARGUMENT;
1920 }
1921
1922 impl = static_cast<tsi_ssl_client_handshaker_factory*>(
1923 gpr_zalloc(sizeof(*impl)));
1924 tsi_ssl_handshaker_factory_init(&impl->base);
1925 impl->base.vtable = &client_handshaker_factory_vtable;
1926 impl->ssl_context = ssl_context;
1927 if (options->session_cache != nullptr) {
1928 // Unref is called manually on factory destruction.
1929 impl->session_cache =
1930 reinterpret_cast<tsi::SslSessionLRUCache*>(options->session_cache)
1931 ->Ref();
1932 SSL_CTX_set_ex_data(ssl_context, g_ssl_ctx_ex_factory_index, impl);
1933 SSL_CTX_sess_set_new_cb(ssl_context,
1934 server_handshaker_factory_new_session_callback);
1935 SSL_CTX_set_session_cache_mode(ssl_context, SSL_SESS_CACHE_CLIENT);
1936 }
1937
1938 do {
1939 result = populate_ssl_context(ssl_context, options->pem_key_cert_pair,
1940 options->cipher_suites);
1941 if (result != TSI_OK) break;
1942
1943 #if OPENSSL_VERSION_NUMBER >= 0x10100000
1944 // X509_STORE_up_ref is only available since OpenSSL 1.1.
1945 if (options->root_store != nullptr) {
1946 X509_STORE_up_ref(options->root_store->store);
1947 SSL_CTX_set_cert_store(ssl_context, options->root_store->store);
1948 }
1949 #endif
1950 if (OPENSSL_VERSION_NUMBER < 0x10100000 || options->root_store == nullptr) {
1951 result = ssl_ctx_load_verification_certs(
1952 ssl_context, options->pem_root_certs, strlen(options->pem_root_certs),
1953 nullptr);
1954 if (result != TSI_OK) {
1955 gpr_log(GPR_ERROR, "Cannot load server root certificates.");
1956 break;
1957 }
1958 }
1959
1960 if (options->num_alpn_protocols != 0) {
1961 result = build_alpn_protocol_name_list(
1962 options->alpn_protocols, options->num_alpn_protocols,
1963 &impl->alpn_protocol_list, &impl->alpn_protocol_list_length);
1964 if (result != TSI_OK) {
1965 gpr_log(GPR_ERROR, "Building alpn list failed with error %s.",
1966 tsi_result_to_string(result));
1967 break;
1968 }
1969 #if TSI_OPENSSL_ALPN_SUPPORT
1970 GPR_ASSERT(impl->alpn_protocol_list_length < UINT_MAX);
1971 if (SSL_CTX_set_alpn_protos(
1972 ssl_context, impl->alpn_protocol_list,
1973 static_cast<unsigned int>(impl->alpn_protocol_list_length))) {
1974 gpr_log(GPR_ERROR, "Could not set alpn protocol list to context.");
1975 result = TSI_INVALID_ARGUMENT;
1976 break;
1977 }
1978 #endif /* TSI_OPENSSL_ALPN_SUPPORT */
1979 SSL_CTX_set_next_proto_select_cb(
1980 ssl_context, client_handshaker_factory_npn_callback, impl);
1981 }
1982 } while (false);
1983 if (result != TSI_OK) {
1984 tsi_ssl_handshaker_factory_unref(&impl->base);
1985 return result;
1986 }
1987 if (options->skip_server_certificate_verification) {
1988 SSL_CTX_set_verify(ssl_context, SSL_VERIFY_PEER, NullVerifyCallback);
1989 } else {
1990 SSL_CTX_set_verify(ssl_context, SSL_VERIFY_PEER, nullptr);
1991 }
1992 /* TODO(jboeuf): Add revocation verification. */
1993
1994 *factory = impl;
1995 return TSI_OK;
1996 }
1997
1998 static tsi_ssl_handshaker_factory_vtable server_handshaker_factory_vtable = {
1999 tsi_ssl_server_handshaker_factory_destroy};
2000
tsi_create_ssl_server_handshaker_factory(const tsi_ssl_pem_key_cert_pair * pem_key_cert_pairs,size_t num_key_cert_pairs,const char * pem_client_root_certs,int force_client_auth,const char * cipher_suites,const char ** alpn_protocols,uint16_t num_alpn_protocols,tsi_ssl_server_handshaker_factory ** factory)2001 tsi_result tsi_create_ssl_server_handshaker_factory(
2002 const tsi_ssl_pem_key_cert_pair* pem_key_cert_pairs,
2003 size_t num_key_cert_pairs, const char* pem_client_root_certs,
2004 int force_client_auth, const char* cipher_suites,
2005 const char** alpn_protocols, uint16_t num_alpn_protocols,
2006 tsi_ssl_server_handshaker_factory** factory) {
2007 return tsi_create_ssl_server_handshaker_factory_ex(
2008 pem_key_cert_pairs, num_key_cert_pairs, pem_client_root_certs,
2009 force_client_auth ? TSI_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY
2010 : TSI_DONT_REQUEST_CLIENT_CERTIFICATE,
2011 cipher_suites, alpn_protocols, num_alpn_protocols, factory);
2012 }
2013
tsi_create_ssl_server_handshaker_factory_ex(const tsi_ssl_pem_key_cert_pair * pem_key_cert_pairs,size_t num_key_cert_pairs,const char * pem_client_root_certs,tsi_client_certificate_request_type client_certificate_request,const char * cipher_suites,const char ** alpn_protocols,uint16_t num_alpn_protocols,tsi_ssl_server_handshaker_factory ** factory)2014 tsi_result tsi_create_ssl_server_handshaker_factory_ex(
2015 const tsi_ssl_pem_key_cert_pair* pem_key_cert_pairs,
2016 size_t num_key_cert_pairs, const char* pem_client_root_certs,
2017 tsi_client_certificate_request_type client_certificate_request,
2018 const char* cipher_suites, const char** alpn_protocols,
2019 uint16_t num_alpn_protocols, tsi_ssl_server_handshaker_factory** factory) {
2020 tsi_ssl_server_handshaker_options options;
2021 options.pem_key_cert_pairs = pem_key_cert_pairs;
2022 options.num_key_cert_pairs = num_key_cert_pairs;
2023 options.pem_client_root_certs = pem_client_root_certs;
2024 options.client_certificate_request = client_certificate_request;
2025 options.cipher_suites = cipher_suites;
2026 options.alpn_protocols = alpn_protocols;
2027 options.num_alpn_protocols = num_alpn_protocols;
2028 return tsi_create_ssl_server_handshaker_factory_with_options(&options,
2029 factory);
2030 }
2031
tsi_create_ssl_server_handshaker_factory_with_options(const tsi_ssl_server_handshaker_options * options,tsi_ssl_server_handshaker_factory ** factory)2032 tsi_result tsi_create_ssl_server_handshaker_factory_with_options(
2033 const tsi_ssl_server_handshaker_options* options,
2034 tsi_ssl_server_handshaker_factory** factory) {
2035 tsi_ssl_server_handshaker_factory* impl = nullptr;
2036 tsi_result result = TSI_OK;
2037 size_t i = 0;
2038
2039 gpr_once_init(&g_init_openssl_once, init_openssl);
2040
2041 if (factory == nullptr) return TSI_INVALID_ARGUMENT;
2042 *factory = nullptr;
2043 if (options->num_key_cert_pairs == 0 ||
2044 options->pem_key_cert_pairs == nullptr) {
2045 return TSI_INVALID_ARGUMENT;
2046 }
2047
2048 impl = static_cast<tsi_ssl_server_handshaker_factory*>(
2049 gpr_zalloc(sizeof(*impl)));
2050 tsi_ssl_handshaker_factory_init(&impl->base);
2051 impl->base.vtable = &server_handshaker_factory_vtable;
2052
2053 impl->ssl_contexts = static_cast<SSL_CTX**>(
2054 gpr_zalloc(options->num_key_cert_pairs * sizeof(SSL_CTX*)));
2055 impl->ssl_context_x509_subject_names = static_cast<tsi_peer*>(
2056 gpr_zalloc(options->num_key_cert_pairs * sizeof(tsi_peer)));
2057 if (impl->ssl_contexts == nullptr ||
2058 impl->ssl_context_x509_subject_names == nullptr) {
2059 tsi_ssl_handshaker_factory_unref(&impl->base);
2060 return TSI_OUT_OF_RESOURCES;
2061 }
2062 impl->ssl_context_count = options->num_key_cert_pairs;
2063
2064 if (options->num_alpn_protocols > 0) {
2065 result = build_alpn_protocol_name_list(
2066 options->alpn_protocols, options->num_alpn_protocols,
2067 &impl->alpn_protocol_list, &impl->alpn_protocol_list_length);
2068 if (result != TSI_OK) {
2069 tsi_ssl_handshaker_factory_unref(&impl->base);
2070 return result;
2071 }
2072 }
2073
2074 for (i = 0; i < options->num_key_cert_pairs; i++) {
2075 do {
2076 #if OPENSSL_VERSION_NUMBER >= 0x10100000
2077 impl->ssl_contexts[i] = SSL_CTX_new(TLS_method());
2078 #else
2079 impl->ssl_contexts[i] = SSL_CTX_new(TLSv1_2_method());
2080 #endif
2081 result = tsi_set_min_and_max_tls_versions(impl->ssl_contexts[i],
2082 options->min_tls_version,
2083 options->max_tls_version);
2084 if (result != TSI_OK) return result;
2085 if (impl->ssl_contexts[i] == nullptr) {
2086 gpr_log(GPR_ERROR, "Could not create ssl context.");
2087 result = TSI_OUT_OF_RESOURCES;
2088 break;
2089 }
2090 result = populate_ssl_context(impl->ssl_contexts[i],
2091 &options->pem_key_cert_pairs[i],
2092 options->cipher_suites);
2093 if (result != TSI_OK) break;
2094
2095 // TODO(elessar): Provide ability to disable session ticket keys.
2096
2097 // Allow client cache sessions (it's needed for OpenSSL only).
2098 int set_sid_ctx_result = SSL_CTX_set_session_id_context(
2099 impl->ssl_contexts[i], kSslSessionIdContext,
2100 GPR_ARRAY_SIZE(kSslSessionIdContext));
2101 if (set_sid_ctx_result == 0) {
2102 gpr_log(GPR_ERROR, "Failed to set session id context.");
2103 result = TSI_INTERNAL_ERROR;
2104 break;
2105 }
2106
2107 if (options->session_ticket_key != nullptr) {
2108 if (SSL_CTX_set_tlsext_ticket_keys(
2109 impl->ssl_contexts[i],
2110 const_cast<char*>(options->session_ticket_key),
2111 options->session_ticket_key_size) == 0) {
2112 gpr_log(GPR_ERROR, "Invalid STEK size.");
2113 result = TSI_INVALID_ARGUMENT;
2114 break;
2115 }
2116 }
2117
2118 if (options->pem_client_root_certs != nullptr) {
2119 STACK_OF(X509_NAME)* root_names = nullptr;
2120 result = ssl_ctx_load_verification_certs(
2121 impl->ssl_contexts[i], options->pem_client_root_certs,
2122 strlen(options->pem_client_root_certs), &root_names);
2123 if (result != TSI_OK) {
2124 gpr_log(GPR_ERROR, "Invalid verification certs.");
2125 break;
2126 }
2127 SSL_CTX_set_client_CA_list(impl->ssl_contexts[i], root_names);
2128 }
2129 switch (options->client_certificate_request) {
2130 case TSI_DONT_REQUEST_CLIENT_CERTIFICATE:
2131 SSL_CTX_set_verify(impl->ssl_contexts[i], SSL_VERIFY_NONE, nullptr);
2132 break;
2133 case TSI_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY:
2134 SSL_CTX_set_verify(impl->ssl_contexts[i], SSL_VERIFY_PEER,
2135 NullVerifyCallback);
2136 break;
2137 case TSI_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY:
2138 SSL_CTX_set_verify(impl->ssl_contexts[i], SSL_VERIFY_PEER, nullptr);
2139 break;
2140 case TSI_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY:
2141 SSL_CTX_set_verify(impl->ssl_contexts[i],
2142 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2143 NullVerifyCallback);
2144 break;
2145 case TSI_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY:
2146 SSL_CTX_set_verify(impl->ssl_contexts[i],
2147 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2148 nullptr);
2149 break;
2150 }
2151 /* TODO(jboeuf): Add revocation verification. */
2152
2153 result = tsi_ssl_extract_x509_subject_names_from_pem_cert(
2154 options->pem_key_cert_pairs[i].cert_chain,
2155 &impl->ssl_context_x509_subject_names[i]);
2156 if (result != TSI_OK) break;
2157
2158 SSL_CTX_set_tlsext_servername_callback(
2159 impl->ssl_contexts[i],
2160 ssl_server_handshaker_factory_servername_callback);
2161 SSL_CTX_set_tlsext_servername_arg(impl->ssl_contexts[i], impl);
2162 #if TSI_OPENSSL_ALPN_SUPPORT
2163 SSL_CTX_set_alpn_select_cb(impl->ssl_contexts[i],
2164 server_handshaker_factory_alpn_callback, impl);
2165 #endif /* TSI_OPENSSL_ALPN_SUPPORT */
2166 SSL_CTX_set_next_protos_advertised_cb(
2167 impl->ssl_contexts[i],
2168 server_handshaker_factory_npn_advertised_callback, impl);
2169 } while (false);
2170
2171 if (result != TSI_OK) {
2172 tsi_ssl_handshaker_factory_unref(&impl->base);
2173 return result;
2174 }
2175 }
2176
2177 *factory = impl;
2178 return TSI_OK;
2179 }
2180
2181 /* --- tsi_ssl utils. --- */
2182
tsi_ssl_peer_matches_name(const tsi_peer * peer,absl::string_view name)2183 int tsi_ssl_peer_matches_name(const tsi_peer* peer, absl::string_view name) {
2184 size_t i = 0;
2185 size_t san_count = 0;
2186 const tsi_peer_property* cn_property = nullptr;
2187 int like_ip = looks_like_ip_address(name);
2188
2189 /* Check the SAN first. */
2190 for (i = 0; i < peer->property_count; i++) {
2191 const tsi_peer_property* property = &peer->properties[i];
2192 if (property->name == nullptr) continue;
2193 if (strcmp(property->name,
2194 TSI_X509_SUBJECT_ALTERNATIVE_NAME_PEER_PROPERTY) == 0) {
2195 san_count++;
2196
2197 absl::string_view entry(property->value.data, property->value.length);
2198 if (!like_ip && does_entry_match_name(entry, name)) {
2199 return 1;
2200 } else if (like_ip && name == entry) {
2201 /* IP Addresses are exact matches only. */
2202 return 1;
2203 }
2204 } else if (strcmp(property->name,
2205 TSI_X509_SUBJECT_COMMON_NAME_PEER_PROPERTY) == 0) {
2206 cn_property = property;
2207 }
2208 }
2209
2210 /* If there's no SAN, try the CN, but only if its not like an IP Address */
2211 if (san_count == 0 && cn_property != nullptr && !like_ip) {
2212 if (does_entry_match_name(absl::string_view(cn_property->value.data,
2213 cn_property->value.length),
2214 name)) {
2215 return 1;
2216 }
2217 }
2218
2219 return 0; /* Not found. */
2220 }
2221
2222 /* --- Testing support. --- */
tsi_ssl_handshaker_factory_swap_vtable(tsi_ssl_handshaker_factory * factory,tsi_ssl_handshaker_factory_vtable * new_vtable)2223 const tsi_ssl_handshaker_factory_vtable* tsi_ssl_handshaker_factory_swap_vtable(
2224 tsi_ssl_handshaker_factory* factory,
2225 tsi_ssl_handshaker_factory_vtable* new_vtable) {
2226 GPR_ASSERT(factory != nullptr);
2227 GPR_ASSERT(factory->vtable != nullptr);
2228
2229 const tsi_ssl_handshaker_factory_vtable* orig_vtable = factory->vtable;
2230 factory->vtable = new_vtable;
2231 return orig_vtable;
2232 }
2233