2 * Copyright (c) 2018 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
16 #include <mbedtls/ssl.h>
17 #include <mbedtls/certs.h>
18 #include <mbedtls/entropy.h>
19 #include <mbedtls/ctr_drbg.h>
20 #include <mbedtls/timing.h>
21 #include <mbedtls/debug.h>
22 #include <vnet/plugin/plugin.h>
23 #include <vpp/app/version.h>
24 #include <vnet/tls/tls.h>
26 #define TLS_USE_OUR_MEM_FUNCS 0
28 typedef struct tls_ctx_mbedtls_
30 tls_ctx_t ctx; /**< First */
31 u32 mbedtls_ctx_index;
32 mbedtls_ssl_context ssl;
33 mbedtls_ssl_config conf;
34 mbedtls_x509_crt srvcert;
35 mbedtls_pk_context pkey;
38 typedef struct mbedtls_main_
40 mbedtls_ctx_t ***ctx_pool;
41 mbedtls_ctr_drbg_context *ctr_drbgs;
42 mbedtls_entropy_context *entropy_pools;
43 mbedtls_x509_crt cacert;
48 static mbedtls_main_t mbedtls_main;
50 #if TLS_USE_OUR_MEM_FUNCS
51 #include <mbedtls/platform.h>
54 mbedtls_calloc_fn (size_t n, size_t size)
57 ptr = clib_mem_alloc (n * size);
58 clib_memset (ptr, 0, sizeof (*ptr));
63 mbedtls_free_fn (void *ptr)
71 mbedtls_ctx_alloc (void)
73 u8 thread_index = vlib_get_thread_index ();
74 mbedtls_main_t *tm = &mbedtls_main;
77 pool_get_aligned_safe (tm->ctx_pool[thread_index], ctx,
78 CLIB_CACHE_LINE_BYTES);
80 *ctx = clib_mem_alloc (sizeof (mbedtls_ctx_t));
82 clib_memset (*ctx, 0, sizeof (mbedtls_ctx_t));
83 (*ctx)->ctx.c_thread_index = thread_index;
84 (*ctx)->ctx.tls_ctx_engine = CRYPTO_ENGINE_MBEDTLS;
85 (*ctx)->mbedtls_ctx_index = ctx - tm->ctx_pool[thread_index];
86 return ((*ctx)->mbedtls_ctx_index);
90 mbedtls_ctx_free (tls_ctx_t * ctx)
92 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
94 if (mc->ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER &&
95 !(ctx->flags & TLS_CONN_F_PASSIVE_CLOSE))
96 mbedtls_ssl_close_notify (&mc->ssl);
97 if (mc->ssl.conf->endpoint == MBEDTLS_SSL_IS_SERVER)
99 mbedtls_x509_crt_free (&mc->srvcert);
100 mbedtls_pk_free (&mc->pkey);
102 mbedtls_ssl_free (&mc->ssl);
103 mbedtls_ssl_config_free (&mc->conf);
105 vec_free (ctx->srv_hostname);
106 pool_put_index (mbedtls_main.ctx_pool[ctx->c_thread_index],
107 mc->mbedtls_ctx_index);
111 mbedtls_ctx_get (u32 ctx_index)
114 ctx = pool_elt_at_index (mbedtls_main.ctx_pool[vlib_get_thread_index ()],
120 mbedtls_ctx_get_w_thread (u32 ctx_index, u8 thread_index)
123 ctx = pool_elt_at_index (mbedtls_main.ctx_pool[thread_index], ctx_index);
128 tls_init_ctr_seed_drbgs (void)
130 u32 thread_index = vlib_get_thread_index ();
131 mbedtls_main_t *tm = &mbedtls_main;
134 pers = format (0, "vpp thread %u", thread_index);
136 mbedtls_entropy_init (&tm->entropy_pools[thread_index]);
137 mbedtls_ctr_drbg_init (&mbedtls_main.ctr_drbgs[thread_index]);
138 if ((rv = mbedtls_ctr_drbg_seed (&tm->ctr_drbgs[thread_index],
139 mbedtls_entropy_func,
140 &tm->entropy_pools[thread_index],
141 (const unsigned char *) pers,
142 vec_len (pers))) != 0)
145 TLS_DBG (1, " failed\n ! mbedtls_ctr_drbg_seed returned %d\n", rv);
152 mbedtls_ctr_drbg_context *
155 u8 thread_index = vlib_get_thread_index ();
156 if (PREDICT_FALSE (!mbedtls_main.ctr_drbgs[thread_index].f_entropy))
157 tls_init_ctr_seed_drbgs ();
158 return &mbedtls_main.ctr_drbgs[thread_index];
162 tls_net_send (void *ctx_indexp, const unsigned char *buf, size_t len)
164 session_t *tls_session;
169 ctx_index = pointer_to_uword (ctx_indexp);
170 ctx = mbedtls_ctx_get (ctx_index);
171 tls_session = session_get_from_handle (ctx->tls_session_handle);
172 rv = svm_fifo_enqueue (tls_session->tx_fifo, len, buf);
174 return MBEDTLS_ERR_SSL_WANT_WRITE;
175 tls_add_vpp_q_tx_evt (tls_session);
180 tls_net_recv (void *ctx_indexp, unsigned char *buf, size_t len)
182 session_t *tls_session;
187 ctx_index = pointer_to_uword (ctx_indexp);
188 ctx = mbedtls_ctx_get (ctx_index);
189 tls_session = session_get_from_handle (ctx->tls_session_handle);
190 rv = svm_fifo_dequeue (tls_session->rx_fifo, len, buf);
191 return (rv < 0) ? 0 : rv;
195 mbedtls_debug (void *ctx, int level, const char *file, int line,
199 fprintf ((FILE *) ctx, "%s:%04d: %s", file, line, str);
200 fflush ((FILE *) ctx);
204 mbedtls_ctx_init_client (tls_ctx_t * ctx)
206 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
207 mbedtls_main_t *mm = &mbedtls_main;
214 mbedtls_ssl_init (&mc->ssl);
215 mbedtls_ssl_config_init (&mc->conf);
216 if ((rv = mbedtls_ssl_config_defaults (&mc->conf, MBEDTLS_SSL_IS_CLIENT,
217 MBEDTLS_SSL_TRANSPORT_STREAM,
218 MBEDTLS_SSL_PRESET_DEFAULT)) != 0)
220 TLS_DBG (1, "failed\n ! mbedtls_ssl_config_defaults returned %d\n\n",
225 mbedtls_ssl_conf_authmode (&mc->conf, MBEDTLS_SSL_VERIFY_OPTIONAL);
226 mbedtls_ssl_conf_ca_chain (&mc->conf, &mm->cacert, NULL);
227 mbedtls_ssl_conf_rng (&mc->conf, mbedtls_ctr_drbg_random,
228 tls_get_ctr_drbg ());
229 mbedtls_ssl_conf_dbg (&mc->conf, mbedtls_debug, stdout);
231 if ((rv = mbedtls_ssl_setup (&mc->ssl, &mc->conf)) != 0)
233 TLS_DBG (1, "failed\n ! mbedtls_ssl_setup returned %d\n", rv);
237 if ((rv = mbedtls_ssl_set_hostname (&mc->ssl,
238 (const char *) ctx->srv_hostname)) != 0)
240 TLS_DBG (1, "failed\n ! mbedtls_ssl_set_hostname returned %d\n", rv);
244 ctx_ptr = uword_to_pointer (mc->mbedtls_ctx_index, void *);
245 mbedtls_ssl_set_bio (&mc->ssl, ctx_ptr, tls_net_send, tls_net_recv, NULL);
246 mbedtls_debug_set_threshold (TLS_DEBUG_LEVEL_CLIENT);
249 * 2. Do the first 2 steps in the handshake.
251 TLS_DBG (1, "Initiating handshake for [%u]%u", ctx->c_thread_index,
252 mc->mbedtls_ctx_index);
253 while (mc->ssl.state != MBEDTLS_SSL_HANDSHAKE_OVER)
255 rv = mbedtls_ssl_handshake_step (&mc->ssl);
259 TLS_DBG (2, "tls state for [%u]%u is %u", ctx->c_thread_index,
260 mc->mbedtls_ctx_index, mc->ssl.state);
265 mbedtls_start_listen (tls_ctx_t * lctx)
271 mbedtls_stop_listen (tls_ctx_t * lctx)
277 mbedtls_ctx_init_server (tls_ctx_t * ctx)
279 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
280 mbedtls_main_t *mm = &mbedtls_main;
281 app_cert_key_pair_t *ckpair;
285 mbedtls_ssl_init (&mc->ssl);
286 mbedtls_ssl_config_init (&mc->conf);
287 mbedtls_x509_crt_init (&mc->srvcert);
288 mbedtls_pk_init (&mc->pkey);
293 ckpair = app_cert_key_pair_get_if_valid (ctx->ckpair_index);
297 if (!ckpair->cert || !ckpair->key)
299 TLS_DBG (1, " failed\n ! tls cert and/or key not configured %d",
300 ctx->parent_app_wrk_index);
304 rv = mbedtls_x509_crt_parse (&mc->srvcert,
305 (const unsigned char *) ckpair->cert,
306 vec_len (ckpair->cert));
309 TLS_DBG (1, " failed\n ! mbedtls_x509_crt_parse returned %d", rv);
313 rv = mbedtls_pk_parse_key (&mc->pkey,
314 (const unsigned char *) ckpair->key,
315 vec_len (ckpair->key), NULL, 0);
318 TLS_DBG (1, " failed\n ! mbedtls_pk_parse_key returned %d", rv);
323 * 2. SSL context config
325 if ((rv = mbedtls_ssl_config_defaults (&mc->conf, MBEDTLS_SSL_IS_SERVER,
326 MBEDTLS_SSL_TRANSPORT_STREAM,
327 MBEDTLS_SSL_PRESET_DEFAULT)) != 0)
329 TLS_DBG (1, " failed\n ! mbedtls_ssl_config_defaults returned %d", rv);
333 mbedtls_ssl_conf_rng (&mc->conf, mbedtls_ctr_drbg_random,
334 tls_get_ctr_drbg ());
335 mbedtls_ssl_conf_dbg (&mc->conf, mbedtls_debug, stdout);
338 mbedtls_ssl_conf_session_cache( &ctx->conf, &cache,
339 mbedtls_ssl_cache_get,
340 mbedtls_ssl_cache_set );
343 mbedtls_ssl_conf_ca_chain (&mc->conf, &mm->cacert, NULL);
344 if ((rv = mbedtls_ssl_conf_own_cert (&mc->conf, &mc->srvcert, &mc->pkey))
347 TLS_DBG (1, " failed\n ! mbedtls_ssl_conf_own_cert returned %d", rv);
351 if ((rv = mbedtls_ssl_setup (&mc->ssl, &mc->conf)) != 0)
353 TLS_DBG (1, " failed\n ! mbedtls_ssl_setup returned %d", rv);
357 mbedtls_ssl_session_reset (&mc->ssl);
358 ctx_ptr = uword_to_pointer (mc->mbedtls_ctx_index, void *);
359 mbedtls_ssl_set_bio (&mc->ssl, ctx_ptr, tls_net_send, tls_net_recv, NULL);
360 mbedtls_debug_set_threshold (TLS_DEBUG_LEVEL_SERVER);
363 * 3. Start handshake state machine
365 TLS_DBG (1, "Initiating handshake for [%u]%u", ctx->c_thread_index,
366 mc->mbedtls_ctx_index);
367 while (mc->ssl.state != MBEDTLS_SSL_HANDSHAKE_OVER)
369 rv = mbedtls_ssl_handshake_step (&mc->ssl);
374 TLS_DBG (2, "tls state for [%u]%u is %u", ctx->c_thread_index,
375 mc->mbedtls_ctx_index, mc->ssl.state);
383 mbedtls_ctx_handshake_rx (tls_ctx_t * ctx)
385 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
388 while (mc->ssl.state != MBEDTLS_SSL_HANDSHAKE_OVER)
390 rv = mbedtls_ssl_handshake_step (&mc->ssl);
394 TLS_DBG (2, "tls state for %u is %u", mc->mbedtls_ctx_index, mc->ssl.state);
396 if (mc->ssl.state != MBEDTLS_SSL_HANDSHAKE_OVER)
402 if (mc->ssl.conf->endpoint == MBEDTLS_SSL_IS_CLIENT)
405 * Verify server certificate
407 if ((flags = mbedtls_ssl_get_verify_result (&mc->ssl)) != 0)
410 TLS_DBG (1, " failed\n");
411 mbedtls_x509_crt_verify_info (buf, sizeof (buf), " ! ", flags);
412 TLS_DBG (1, "%s\n", buf);
415 * Presence of hostname enforces strict certificate verification
417 if (ctx->srv_hostname)
419 tls_notify_app_connected (ctx, SESSION_E_TLS_HANDSHAKE);
423 tls_notify_app_connected (ctx, SESSION_E_NONE);
427 tls_notify_app_accept (ctx);
430 TLS_DBG (1, "Handshake for %u complete. TLS cipher is %x",
431 mc->mbedtls_ctx_index, mc->ssl.session->ciphersuite);
436 mbedtls_ctx_write (tls_ctx_t * ctx, session_t * app_session,
437 transport_send_params_t * sp)
439 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
440 u8 thread_index = ctx->c_thread_index;
441 mbedtls_main_t *mm = &mbedtls_main;
442 u32 enq_max, deq_max, deq_now;
443 session_t *tls_session;
446 ASSERT (mc->ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER);
448 deq_max = svm_fifo_max_dequeue_cons (app_session->tx_fifo);
452 deq_max = clib_min (deq_max, sp->max_burst_size);
453 tls_session = session_get_from_handle (ctx->tls_session_handle);
454 enq_max = svm_fifo_max_enqueue_prod (tls_session->tx_fifo);
455 deq_now = clib_min (deq_max, TLS_CHUNK_SIZE);
457 if (PREDICT_FALSE (enq_max == 0))
459 app_session->flags |= SESSION_F_CUSTOM_TX;
463 vec_validate (mm->tx_bufs[thread_index], deq_now);
464 svm_fifo_peek (app_session->tx_fifo, 0, deq_now, mm->tx_bufs[thread_index]);
466 wrote = mbedtls_ssl_write (&mc->ssl, mm->tx_bufs[thread_index], deq_now);
469 app_session->flags |= SESSION_F_CUSTOM_TX;
473 svm_fifo_dequeue_drop (app_session->tx_fifo, wrote);
474 vec_reset_length (mm->tx_bufs[thread_index]);
475 tls_add_vpp_q_tx_evt (tls_session);
477 if (deq_now < deq_max)
478 app_session->flags |= SESSION_F_CUSTOM_TX;
484 mbedtls_ctx_read (tls_ctx_t * ctx, session_t * tls_session)
486 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
487 mbedtls_main_t *mm = &mbedtls_main;
488 u8 thread_index = ctx->c_thread_index;
489 u32 deq_max, enq_max, enq_now;
490 session_t *app_session;
493 if (PREDICT_FALSE (mc->ssl.state != MBEDTLS_SSL_HANDSHAKE_OVER))
495 mbedtls_ctx_handshake_rx (ctx);
499 deq_max = svm_fifo_max_dequeue_cons (tls_session->rx_fifo);
503 app_session = session_get_from_handle (ctx->app_session_handle);
504 enq_max = svm_fifo_max_enqueue_prod (app_session->rx_fifo);
505 enq_now = clib_min (enq_max, TLS_CHUNK_SIZE);
507 if (PREDICT_FALSE (enq_now == 0))
509 tls_add_vpp_q_builtin_rx_evt (tls_session);
513 vec_validate (mm->rx_bufs[thread_index], enq_now);
514 read = mbedtls_ssl_read (&mc->ssl, mm->rx_bufs[thread_index], enq_now);
517 tls_add_vpp_q_builtin_rx_evt (tls_session);
521 enq = svm_fifo_enqueue (app_session->rx_fifo, read,
522 mm->rx_bufs[thread_index]);
523 ASSERT (enq == read);
524 vec_reset_length (mm->rx_bufs[thread_index]);
526 if (svm_fifo_max_dequeue_cons (tls_session->rx_fifo))
527 tls_add_vpp_q_builtin_rx_evt (tls_session);
530 tls_notify_app_enqueue (ctx, app_session);
536 mbedtls_handshake_is_over (tls_ctx_t * ctx)
538 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
539 return (mc->ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER);
543 mbedtls_transport_close (tls_ctx_t * ctx)
545 if (!mbedtls_handshake_is_over (ctx))
547 session_close (session_get_from_handle (ctx->tls_session_handle));
550 session_transport_closing_notify (&ctx->connection);
555 mbedtls_transport_reset (tls_ctx_t *ctx)
557 if (!mbedtls_handshake_is_over (ctx))
559 session_close (session_get_from_handle (ctx->tls_session_handle));
563 session_transport_reset_notify (&ctx->connection);
564 session_transport_closed_notify (&ctx->connection);
565 tls_disconnect_transport (ctx);
570 mbedtls_app_close (tls_ctx_t * ctx)
572 tls_disconnect_transport (ctx);
573 session_transport_delete_notify (&ctx->connection);
578 mbedtls_reinit_ca_chain (void)
580 /* Not supported Yet */
584 const static tls_engine_vft_t mbedtls_engine = {
585 .ctx_alloc = mbedtls_ctx_alloc,
586 .ctx_free = mbedtls_ctx_free,
587 .ctx_get = mbedtls_ctx_get,
588 .ctx_get_w_thread = mbedtls_ctx_get_w_thread,
589 .ctx_init_server = mbedtls_ctx_init_server,
590 .ctx_init_client = mbedtls_ctx_init_client,
591 .ctx_write = mbedtls_ctx_write,
592 .ctx_read = mbedtls_ctx_read,
593 .ctx_handshake_is_over = mbedtls_handshake_is_over,
594 .ctx_start_listen = mbedtls_start_listen,
595 .ctx_stop_listen = mbedtls_stop_listen,
596 .ctx_transport_close = mbedtls_transport_close,
597 .ctx_transport_reset = mbedtls_transport_reset,
598 .ctx_app_close = mbedtls_app_close,
599 .ctx_reinit_cachain = mbedtls_reinit_ca_chain,
605 #if TLS_USE_OUR_MEM_FUNCS
606 mbedtls_platform_set_calloc_free (mbedtls_calloc_fn, mbedtls_free_fn);
612 tls_init_ctr_drbgs_and_entropy (u32 num_threads)
614 mbedtls_main_t *mm = &mbedtls_main;
617 vec_validate (mm->ctr_drbgs, num_threads - 1);
618 vec_validate (mm->entropy_pools, num_threads - 1);
619 for (i = 0; i < num_threads; i++)
620 mm->ctr_drbgs[i].f_entropy = 0;
626 tls_init_ca_chain (void)
628 mbedtls_main_t *mm = &mbedtls_main;
629 tls_main_t *tm = vnet_tls_get_main ();
632 if (access (tm->ca_cert_path, F_OK | R_OK) == -1)
634 clib_warning ("Could not initialize TLS CA certificates");
638 mbedtls_x509_crt_init (&mm->cacert);
639 rv = mbedtls_x509_crt_parse_file (&mm->cacert, tm->ca_cert_path);
642 clib_warning ("Couldn't parse system CA certificates: -0x%x", -rv);
644 if (tm->use_test_cert_in_ca)
646 rv = mbedtls_x509_crt_parse (&mm->cacert,
647 (const unsigned char *) test_srv_crt_rsa,
648 test_srv_crt_rsa_len);
651 clib_warning ("Couldn't parse test certificate: -0x%x", -rv);
655 return (rv < 0 ? -1 : 0);
658 static clib_error_t *
659 tls_mbedtls_init (vlib_main_t * vm)
661 vlib_thread_main_t *vtm = vlib_get_thread_main ();
662 mbedtls_main_t *mm = &mbedtls_main;
665 num_threads = 1 /* main thread */ + vtm->n_threads;
667 if (tls_init_ca_chain ())
669 clib_warning ("failed to initialize TLS CA chain");
674 clib_warning ("failed to initialize mem");
677 if (tls_init_ctr_drbgs_and_entropy (num_threads))
679 clib_warning ("failed to initialize entropy and random generators");
683 vec_validate (mm->ctx_pool, num_threads - 1);
684 vec_validate (mm->rx_bufs, num_threads - 1);
685 vec_validate (mm->tx_bufs, num_threads - 1);
687 tls_register_engine (&mbedtls_engine, CRYPTO_ENGINE_MBEDTLS);
691 VLIB_INIT_FUNCTION (tls_mbedtls_init) =
693 .runs_after = VLIB_INITS("tls_init"),
696 VLIB_PLUGIN_REGISTER () = {
697 .version = VPP_BUILD_VER,
698 .description = "Transport Layer Security (TLS) Engine, Mbedtls Based",
702 * fd.io coding-style-patch-verification: ON
705 * eval: (c-set-style "gnu")