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 mbedtls_ssl_context ssl;
32 mbedtls_ssl_config conf;
33 mbedtls_x509_crt srvcert;
34 mbedtls_pk_context pkey;
37 typedef struct mbedtls_main_
39 mbedtls_ctx_t ***ctx_pool;
40 mbedtls_ctr_drbg_context *ctr_drbgs;
41 mbedtls_entropy_context *entropy_pools;
42 mbedtls_x509_crt cacert;
45 static mbedtls_main_t mbedtls_main;
47 #if TLS_USE_OUR_MEM_FUNCS
48 #include <mbedtls/platform.h>
51 mbedtls_calloc_fn (size_t n, size_t size)
54 ptr = clib_mem_alloc (n * size);
55 memset (ptr, 0, sizeof (*ptr));
60 mbedtls_free_fn (void *ptr)
68 mbedtls_ctx_alloc (void)
70 u8 thread_index = vlib_get_thread_index ();
71 mbedtls_main_t *tm = &mbedtls_main;
74 pool_get (tm->ctx_pool[thread_index], ctx);
76 *ctx = clib_mem_alloc (sizeof (mbedtls_ctx_t));
78 memset (*ctx, 0, sizeof (mbedtls_ctx_t));
79 (*ctx)->ctx.c_thread_index = thread_index;
80 return ctx - tm->ctx_pool[thread_index];
84 mbedtls_ctx_free (tls_ctx_t * ctx)
86 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
88 if (mc->ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER && !ctx->is_passive_close)
89 mbedtls_ssl_close_notify (&mc->ssl);
90 if (mc->ssl.conf->endpoint == MBEDTLS_SSL_IS_SERVER)
92 mbedtls_x509_crt_free (&mc->srvcert);
93 mbedtls_pk_free (&mc->pkey);
95 mbedtls_ssl_free (&mc->ssl);
96 mbedtls_ssl_config_free (&mc->conf);
98 pool_put_index (mbedtls_main.ctx_pool[vlib_get_thread_index ()],
103 mbedtls_ctx_get (u32 ctx_index)
106 ctx = pool_elt_at_index (mbedtls_main.ctx_pool[vlib_get_thread_index ()],
112 mbedtls_ctx_get_w_thread (u32 ctx_index, u8 thread_index)
115 ctx = pool_elt_at_index (mbedtls_main.ctx_pool[thread_index], ctx_index);
120 tls_init_ctr_seed_drbgs (void)
122 u32 thread_index = vlib_get_thread_index ();
123 mbedtls_main_t *tm = &mbedtls_main;
126 pers = format (0, "vpp thread %u", thread_index);
128 mbedtls_entropy_init (&tm->entropy_pools[thread_index]);
129 mbedtls_ctr_drbg_init (&mbedtls_main.ctr_drbgs[thread_index]);
130 if ((rv = mbedtls_ctr_drbg_seed (&tm->ctr_drbgs[thread_index],
131 mbedtls_entropy_func,
132 &tm->entropy_pools[thread_index],
133 (const unsigned char *) pers,
134 vec_len (pers))) != 0)
137 TLS_DBG (1, " failed\n ! mbedtls_ctr_drbg_seed returned %d\n", rv);
144 mbedtls_ctr_drbg_context *
147 u8 thread_index = vlib_get_thread_index ();
148 if (PREDICT_FALSE (!mbedtls_main.ctr_drbgs[thread_index].f_entropy))
149 tls_init_ctr_seed_drbgs ();
150 return &mbedtls_main.ctr_drbgs[thread_index];
154 tls_net_send (void *ctx_indexp, const unsigned char *buf, size_t len)
156 stream_session_t *tls_session;
161 ctx_index = pointer_to_uword (ctx_indexp);
162 ctx = mbedtls_ctx_get (ctx_index);
163 tls_session = session_get_from_handle (ctx->tls_session_handle);
164 rv = svm_fifo_enqueue_nowait (tls_session->server_tx_fifo, len, buf);
166 return MBEDTLS_ERR_SSL_WANT_WRITE;
167 tls_add_vpp_q_evt (tls_session->server_tx_fifo, FIFO_EVENT_APP_TX);
172 tls_net_recv (void *ctx_indexp, unsigned char *buf, size_t len)
174 stream_session_t *tls_session;
179 ctx_index = pointer_to_uword (ctx_indexp);
180 ctx = mbedtls_ctx_get (ctx_index);
181 tls_session = session_get_from_handle (ctx->tls_session_handle);
182 rv = svm_fifo_dequeue_nowait (tls_session->server_rx_fifo, len, buf);
183 return (rv < 0) ? 0 : rv;
187 mbedtls_debug (void *ctx, int level, const char *file, int line,
191 fprintf ((FILE *) ctx, "%s:%04d: %s", file, line, str);
192 fflush ((FILE *) ctx);
196 mbedtls_ctx_init_client (tls_ctx_t * ctx)
198 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
199 mbedtls_main_t *mm = &mbedtls_main;
206 mbedtls_ssl_init (&mc->ssl);
207 mbedtls_ssl_config_init (&mc->conf);
208 if ((rv = mbedtls_ssl_config_defaults (&mc->conf, MBEDTLS_SSL_IS_CLIENT,
209 MBEDTLS_SSL_TRANSPORT_STREAM,
210 MBEDTLS_SSL_PRESET_DEFAULT)) != 0)
212 TLS_DBG (1, "failed\n ! mbedtls_ssl_config_defaults returned %d\n\n",
217 mbedtls_ssl_conf_authmode (&mc->conf, MBEDTLS_SSL_VERIFY_OPTIONAL);
218 mbedtls_ssl_conf_ca_chain (&mc->conf, &mm->cacert, NULL);
219 mbedtls_ssl_conf_rng (&mc->conf, mbedtls_ctr_drbg_random,
220 tls_get_ctr_drbg ());
221 mbedtls_ssl_conf_dbg (&mc->conf, mbedtls_debug, stdout);
223 if ((rv = mbedtls_ssl_setup (&mc->ssl, &mc->conf)) != 0)
225 TLS_DBG (1, "failed\n ! mbedtls_ssl_setup returned %d\n", rv);
229 if ((rv = mbedtls_ssl_set_hostname (&mc->ssl,
230 (const char *) ctx->srv_hostname)) != 0)
232 TLS_DBG (1, "failed\n ! mbedtls_ssl_set_hostname returned %d\n", rv);
236 ctx_ptr = uword_to_pointer (ctx->tls_ctx_idx, void *);
237 mbedtls_ssl_set_bio (&mc->ssl, ctx_ptr, tls_net_send, tls_net_recv, NULL);
238 mbedtls_debug_set_threshold (TLS_DEBUG_LEVEL_CLIENT);
241 * 2. Do the first 2 steps in the handshake.
243 TLS_DBG (1, "Initiating handshake for [%u]%u", ctx->c_thread_index,
245 while (mc->ssl.state != MBEDTLS_SSL_HANDSHAKE_OVER)
247 rv = mbedtls_ssl_handshake_step (&mc->ssl);
251 TLS_DBG (2, "tls state for [%u]%u is %u", ctx->c_thread_index,
252 ctx->tls_ctx_idx, mc->ssl.state);
257 mbedtls_ctx_init_server (tls_ctx_t * ctx)
259 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
260 mbedtls_main_t *mm = &mbedtls_main;
265 mbedtls_ssl_init (&mc->ssl);
266 mbedtls_ssl_config_init (&mc->conf);
267 mbedtls_x509_crt_init (&mc->srvcert);
268 mbedtls_pk_init (&mc->pkey);
273 app = application_get (ctx->parent_app_index);
274 if (!app->tls_cert || !app->tls_key)
276 TLS_DBG (1, " failed\n ! tls cert and/or key not configured %d",
277 ctx->parent_app_index);
281 rv = mbedtls_x509_crt_parse (&mc->srvcert,
282 (const unsigned char *) app->tls_cert,
283 vec_len (app->tls_cert));
286 TLS_DBG (1, " failed\n ! mbedtls_x509_crt_parse returned %d", rv);
290 rv = mbedtls_pk_parse_key (&mc->pkey,
291 (const unsigned char *) app->tls_key,
292 vec_len (app->tls_key), NULL, 0);
295 TLS_DBG (1, " failed\n ! mbedtls_pk_parse_key returned %d", rv);
300 * 2. SSL context config
302 if ((rv = mbedtls_ssl_config_defaults (&mc->conf, MBEDTLS_SSL_IS_SERVER,
303 MBEDTLS_SSL_TRANSPORT_STREAM,
304 MBEDTLS_SSL_PRESET_DEFAULT)) != 0)
306 TLS_DBG (1, " failed\n ! mbedtls_ssl_config_defaults returned %d", rv);
310 mbedtls_ssl_conf_rng (&mc->conf, mbedtls_ctr_drbg_random,
311 tls_get_ctr_drbg ());
312 mbedtls_ssl_conf_dbg (&mc->conf, mbedtls_debug, stdout);
315 mbedtls_ssl_conf_session_cache( &ctx->conf, &cache,
316 mbedtls_ssl_cache_get,
317 mbedtls_ssl_cache_set );
320 mbedtls_ssl_conf_ca_chain (&mc->conf, &mm->cacert, NULL);
321 if ((rv = mbedtls_ssl_conf_own_cert (&mc->conf, &mc->srvcert, &mc->pkey))
324 TLS_DBG (1, " failed\n ! mbedtls_ssl_conf_own_cert returned %d", rv);
328 if ((rv = mbedtls_ssl_setup (&mc->ssl, &mc->conf)) != 0)
330 TLS_DBG (1, " failed\n ! mbedtls_ssl_setup returned %d", rv);
334 mbedtls_ssl_session_reset (&mc->ssl);
335 ctx_ptr = uword_to_pointer (ctx->tls_ctx_idx, void *);
336 mbedtls_ssl_set_bio (&mc->ssl, ctx_ptr, tls_net_send, tls_net_recv, NULL);
337 mbedtls_debug_set_threshold (TLS_DEBUG_LEVEL_SERVER);
340 * 3. Start handshake state machine
342 TLS_DBG (1, "Initiating handshake for [%u]%u", ctx->c_thread_index,
344 while (mc->ssl.state != MBEDTLS_SSL_HANDSHAKE_OVER)
346 rv = mbedtls_ssl_handshake_step (&mc->ssl);
351 TLS_DBG (2, "tls state for [%u]%u is %u", ctx->c_thread_index,
352 ctx->tls_ctx_idx, mc->ssl.state);
360 mbedtls_handshake_rx (tls_ctx_t * ctx)
362 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
365 while (mc->ssl.state != MBEDTLS_SSL_HANDSHAKE_OVER)
367 rv = mbedtls_ssl_handshake_step (&mc->ssl);
371 TLS_DBG (2, "tls state for %u is %u", ctx->tls_ctx_idx, mc->ssl.state);
373 if (mc->ssl.state != MBEDTLS_SSL_HANDSHAKE_OVER)
374 return HANDSHAKE_NOT_OVER;
379 if (mc->ssl.conf->endpoint == MBEDTLS_SSL_IS_CLIENT)
382 * Verify server certificate
384 if ((flags = mbedtls_ssl_get_verify_result (&mc->ssl)) != 0)
387 TLS_DBG (1, " failed\n");
388 mbedtls_x509_crt_verify_info (buf, sizeof (buf), " ! ", flags);
389 TLS_DBG (1, "%s\n", buf);
392 * Presence of hostname enforces strict certificate verification
394 if (ctx->srv_hostname)
395 return CLIENT_HANDSHAKE_FAIL;
397 rv = CLIENT_HANDSHAKE_OK;
401 rv = SERVER_HANDSHAKE_OK;
404 TLS_DBG (1, "Handshake for %u complete. TLS cipher is %x",
405 ctx->tls_ctx_idx, mc->ssl.session->ciphersuite);
410 mbedtls_write (tls_ctx_t * ctx, u8 * buf, u32 len)
412 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
413 return mbedtls_ssl_write (&mc->ssl, buf, len);
417 mbedtls_read (tls_ctx_t * ctx, u8 * buf, u32 len)
419 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
420 return mbedtls_ssl_read (&mc->ssl, buf, len);
424 mbedtls_handshake_is_over (tls_ctx_t * ctx)
426 mbedtls_ctx_t *mc = (mbedtls_ctx_t *) ctx;
427 return (mc->ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER);
430 const static tls_engine_vft_t mbedtls_engine = {
431 .ctx_alloc = mbedtls_ctx_alloc,
432 .ctx_free = mbedtls_ctx_free,
433 .ctx_get = mbedtls_ctx_get,
434 .ctx_get_w_thread = mbedtls_ctx_get_w_thread,
435 .ctx_init_server = mbedtls_ctx_init_server,
436 .ctx_init_client = mbedtls_ctx_init_client,
437 .ctx_handshake_rx = mbedtls_handshake_rx,
438 .ctx_write = mbedtls_write,
439 .ctx_read = mbedtls_read,
440 .ctx_handshake_is_over = mbedtls_handshake_is_over,
446 #if TLS_USE_OUR_MEM_FUNCS
447 mbedtls_platform_set_calloc_free (mbedtls_calloc_fn, mbedtls_free_fn);
453 tls_init_ctr_drbgs_and_entropy (u32 num_threads)
455 mbedtls_main_t *mm = &mbedtls_main;
458 vec_validate (mm->ctr_drbgs, num_threads - 1);
459 vec_validate (mm->entropy_pools, num_threads - 1);
460 for (i = 0; i < num_threads; i++)
461 mm->ctr_drbgs[i].f_entropy = 0;
467 tls_init_ca_chain (void)
469 mbedtls_main_t *mm = &mbedtls_main;
470 tls_main_t *tm = vnet_tls_get_main ();
473 if (access (tm->ca_cert_path, F_OK | R_OK) == -1)
475 clib_warning ("Could not initialize TLS CA certificates");
479 mbedtls_x509_crt_init (&mm->cacert);
480 rv = mbedtls_x509_crt_parse_file (&mm->cacert, tm->ca_cert_path);
483 clib_warning ("Couldn't parse system CA certificates: -0x%x", -rv);
485 if (tm->use_test_cert_in_ca)
487 rv = mbedtls_x509_crt_parse (&mm->cacert,
488 (const unsigned char *) test_srv_crt_rsa,
489 test_srv_crt_rsa_len);
492 clib_warning ("Couldn't parse test certificate: -0x%x", -rv);
496 return (rv < 0 ? -1 : 0);
499 static clib_error_t *
500 tls_mbedtls_init (vlib_main_t * vm)
502 vlib_thread_main_t *vtm = vlib_get_thread_main ();
503 mbedtls_main_t *mm = &mbedtls_main;
507 num_threads = 1 /* main thread */ + vtm->n_threads;
509 if ((error = vlib_call_init_function (vm, tls_init)))
512 if (tls_init_ca_chain ())
514 clib_warning ("failed to initialize TLS CA chain");
519 clib_warning ("failed to initialize mem");
522 if (tls_init_ctr_drbgs_and_entropy (num_threads))
524 clib_warning ("failed to initialize entropy and random generators");
528 vec_validate (mm->ctx_pool, num_threads - 1);
529 tls_register_engine (&mbedtls_engine, TLS_ENGINE_MBEDTLS);
533 VLIB_INIT_FUNCTION (tls_mbedtls_init);
536 VLIB_PLUGIN_REGISTER () = {
537 .version = VPP_BUILD_VER,
538 .description = "mbedtls based TLS Engine",
543 * fd.io coding-style-patch-verification: ON
546 * eval: (c-set-style "gnu")