src/plugins/tlspicotls/tls_picotls.c

   1 #include <math.h>
   2
   3 #include "certs.h"
   4 #include "tls_picotls.h"
   5 #include "pico_vpp_crypto.h"
   6
   7 picotls_main_t picotls_main;
   8
   9 #define MAX_QUEUE 12000
  10 #define PTLS_MAX_PLAINTEXT_RECORD_SIZE 16384
  11
  12 static u32
  13 picotls_ctx_alloc (void)
  14 {
  15   u8 thread_id = vlib_get_thread_index ();
  16   picotls_main_t *pm = &picotls_main;
  17   picotls_ctx_t **ctx;
  18
  19   pool_get (pm->ctx_pool[thread_id], ctx);
  20   if (!(*ctx))
  21     *ctx = clib_mem_alloc (sizeof (picotls_ctx_t));
  22
  23   clib_memset (*ctx, 0, sizeof (picotls_ctx_t));
  24   (*ctx)->ctx.c_thread_index = thread_id;
  25   (*ctx)->ctx.tls_ctx_engine = CRYPTO_ENGINE_PICOTLS;
  26   (*ctx)->ctx.app_session_handle = SESSION_INVALID_HANDLE;
  27   (*ctx)->ptls_ctx_idx = ctx - pm->ctx_pool[thread_id];
  28   return (*ctx)->ptls_ctx_idx;
  29 }
  30
  31 static void
  32 picotls_ctx_free (tls_ctx_t * ctx)
  33 {
  34   picotls_ctx_t *ptls_ctx = (picotls_ctx_t *) ctx;
  35   free (ptls_ctx->rx_content);
  36   pool_put_index (picotls_main.ctx_pool[ctx->c_thread_index],
  37                   ptls_ctx->ptls_ctx_idx);
  38 }
  39
  40 static u32
  41 picotls_listen_ctx_alloc (void)
  42 {
  43   picotls_main_t *pm = &picotls_main;
  44   picotls_listen_ctx_t *ptls_lctx;
  45
  46   pool_get (pm->lctx_pool, ptls_lctx);
  47
  48   clib_memset (ptls_lctx, 0, sizeof (picotls_listen_ctx_t));
  49   ptls_lctx->ptls_lctx_index = ptls_lctx - pm->lctx_pool;
  50   return ptls_lctx->ptls_lctx_index;
  51 }
  52
  53 static void
  54 picotls_listen_ctx_free (picotls_listen_ctx_t * lctx)
  55 {
  56   pool_put_index (picotls_main.lctx_pool, lctx->ptls_lctx_index);
  57 }
  58
  59 tls_ctx_t *
  60 picotls_ctx_get (u32 ctx_index)
  61 {
  62   picotls_ctx_t **ctx;
  63   ctx =
  64     pool_elt_at_index (picotls_main.ctx_pool[vlib_get_thread_index ()],
  65                        ctx_index);
  66   return &(*ctx)->ctx;
  67 }
  68
  69 picotls_listen_ctx_t *
  70 picotls_lctx_get (u32 lctx_index)
  71 {
  72   return pool_elt_at_index (picotls_main.lctx_pool, lctx_index);
  73 }
  74
  75 static u8
  76 picotls_handshake_is_over (tls_ctx_t * ctx)
  77 {
  78   picotls_ctx_t *ptls_ctx = (picotls_ctx_t *) ctx;
  79   assert (ptls_ctx->tls);
  80   return ptls_handshake_is_complete (ptls_ctx->tls);
  81 }
  82
  83 static int
  84 picotls_try_handshake_write (picotls_ctx_t * ptls_ctx,
  85                              session_t * tls_session, ptls_buffer_t * buf)
  86 {
  87   u32 enq_max, enq_now;
  88   svm_fifo_t *f;
  89   int write, buf_left;
  90
  91   if (buf->off <= 0)
  92     return 0;
  93
  94   f = tls_session->tx_fifo;
  95   buf_left = buf->off;
  96   enq_max = svm_fifo_max_enqueue_prod (f);
  97   if (!enq_max)
  98     return 0;
  99
 100   enq_now = clib_min (svm_fifo_max_write_chunk (f), enq_max);
 101   enq_now = clib_min (enq_now, buf_left);
 102   write = svm_fifo_enqueue (f, enq_now, buf->base);
 103   buf_left -= write;
 104   tls_add_vpp_q_tx_evt (tls_session);
 105   return write;
 106 }
 107
 108 static int
 109 picotls_start_listen (tls_ctx_t * lctx)
 110 {
 111   picotls_listen_ctx_t *ptls_lctx;
 112   ptls_context_t *ptls_ctx;
 113   u32 ptls_lctx_idx;
 114   app_cert_key_pair_t *ckpair;
 115   static ptls_key_exchange_algorithm_t *key_exchange[] = {
 116 #ifdef PTLS_OPENSSL_HAVE_X25519
 117     &ptls_openssl_x25519,
 118 #endif
 119 #ifdef PTLS_OPENSSL_HAVE_SECP256r1
 120     &ptls_openssl_secp256r1,
 121 #endif
 122 #ifdef PTLS_OPENSSL_HAVE_SECP384r1
 123     &ptls_openssl_secp384r1,
 124 #endif
 125 #ifdef PTLS_OPENSSL_HAVE_SECP521r1
 126     &ptls_openssl_secp521r1
 127 #endif
 128   };
 129
 130   ckpair = app_cert_key_pair_get_if_valid (lctx->ckpair_index);
 131   if (!ckpair || !ckpair->cert || !ckpair->key)
 132     {
 133       TLS_DBG (1, "tls cert and/or key not configured %d",
 134                lctx->parent_app_wrk_index);
 135       return -1;
 136     }
 137
 138   ptls_lctx_idx = picotls_listen_ctx_alloc ();
 139   ptls_lctx = picotls_lctx_get (ptls_lctx_idx);
 140   ptls_ctx = malloc (sizeof (ptls_context_t));
 141   ptls_lctx->ptls_ctx = ptls_ctx;
 142
 143   memset (ptls_ctx, 0, sizeof (ptls_context_t));
 144   ptls_ctx->update_open_count = NULL;
 145
 146   /*
 147    * Process certificate & private key.
 148    */
 149   load_bio_certificate_chain (ptls_ctx, (char *) ckpair->cert);
 150   load_bio_private_key (ptls_ctx, (char *) ckpair->key);
 151
 152   /* setup protocol related functions */
 153   ptls_ctx->key_exchanges = key_exchange;
 154   ptls_ctx->random_bytes = ptls_openssl_random_bytes;
 155   ptls_ctx->cipher_suites = ptls_vpp_crypto_cipher_suites;
 156   ptls_ctx->get_time = &ptls_get_time;
 157
 158   lctx->tls_ssl_ctx = ptls_lctx_idx;
 159
 160   return 0;
 161 }
 162
 163 static int
 164 picotls_stop_listen (tls_ctx_t * lctx)
 165 {
 166   u32 ptls_lctx_index;
 167   picotls_listen_ctx_t *ptls_lctx;
 168
 169   ptls_lctx_index = lctx->tls_ssl_ctx;
 170   ptls_lctx = picotls_lctx_get (ptls_lctx_index);
 171
 172   picotls_listen_ctx_free (ptls_lctx);
 173
 174   return 0;
 175 }
 176
 177 static void
 178 picotls_handle_handshake_failure (tls_ctx_t * ctx)
 179 {
 180   session_free (session_get (ctx->c_s_index, ctx->c_thread_index));
 181   ctx->no_app_session = 1;
 182   ctx->c_s_index = SESSION_INVALID_INDEX;
 183   tls_disconnect_transport (ctx);
 184 }
 185
 186 static void
 187 picotls_confirm_app_close (tls_ctx_t * ctx)
 188 {
 189   tls_disconnect_transport (ctx);
 190   session_transport_closed_notify (&ctx->connection);
 191 }
 192
 193 static int
 194 picotls_transport_close (tls_ctx_t * ctx)
 195 {
 196   if (!picotls_handshake_is_over (ctx))
 197     {
 198       picotls_handle_handshake_failure (ctx);
 199       return 0;
 200     }
 201   picotls_ctx_t *ptls_ctx = (picotls_ctx_t *) ctx;
 202   ptls_free (ptls_ctx->tls);
 203   session_transport_closed_notify (&ctx->connection);
 204   return 0;
 205 }
 206
 207 static int
 208 picotls_app_close (tls_ctx_t * ctx)
 209 {
 210   session_t *app_session;
 211
 212   app_session = session_get_from_handle (ctx->app_session_handle);
 213   if (!svm_fifo_max_dequeue_cons (app_session->tx_fifo))
 214     picotls_confirm_app_close (ctx);
 215   else
 216     ctx->app_closed = 1;
 217
 218   return 0;
 219 }
 220
 221 static inline int
 222 picotls_do_handshake (picotls_ctx_t * ptls_ctx, session_t * tls_session,
 223                       u8 * input, int input_len)
 224 {
 225   ptls_t *tls = ptls_ctx->tls;
 226   ptls_buffer_t buf;
 227   int rv = PTLS_ERROR_IN_PROGRESS;
 228   int write = 0, off;
 229
 230   do
 231     {
 232       off = 0;
 233       do
 234         {
 235           ptls_buffer_init (&buf, "", 0);
 236           size_t consumed = input_len - off;
 237           rv = ptls_handshake (tls, &buf, input + off, &consumed, NULL);
 238           off += consumed;
 239           ptls_ctx->rx_offset += consumed;
 240           if ((rv == 0 || rv == PTLS_ERROR_IN_PROGRESS) && buf.off != 0)
 241             {
 242               write = picotls_try_handshake_write (ptls_ctx, tls_session,
 243                                                    &buf);
 244             }
 245           ptls_buffer_dispose (&buf);
 246         }
 247       while (rv == PTLS_ERROR_IN_PROGRESS && input_len != off);
 248     }
 249   while (rv == PTLS_ERROR_IN_PROGRESS);
 250
 251   return write;
 252 }
 253
 254 static inline int
 255 picotls_ctx_read (tls_ctx_t * ctx, session_t * tls_session)
 256 {
 257   picotls_ctx_t *ptls_ctx = (picotls_ctx_t *) ctx;
 258   int from_tls_len = 0, to_app_len = 0, off, crypto_len, ret;
 259   u32 deq_max, deq_now;
 260   u32 enq_max, enq_now;
 261   ptls_buffer_t _buf, *buf = &_buf;
 262   svm_fifo_t *tls_rx_fifo, *app_rx_fifo;
 263   session_t *app_session;
 264
 265   tls_rx_fifo = tls_session->rx_fifo;
 266
 267   if (!picotls_handshake_is_over (ctx))
 268     {
 269       deq_max = svm_fifo_max_dequeue_cons (tls_rx_fifo);
 270       deq_now = clib_min (deq_max, svm_fifo_max_read_chunk (tls_rx_fifo));
 271       if (!deq_now)
 272         goto done_hs;
 273
 274       off = svm_fifo_dequeue (tls_rx_fifo, deq_now, TLS_RX_LEN (ptls_ctx));
 275       from_tls_len += off;
 276       ptls_ctx->rx_len += off;
 277       if (from_tls_len <= 0)
 278         {
 279           tls_add_vpp_q_builtin_rx_evt (tls_session);
 280           goto done_hs;
 281         }
 282       if (from_tls_len < deq_max)
 283         {
 284           deq_now = clib_min (svm_fifo_max_read_chunk (tls_rx_fifo),
 285                               deq_max - from_tls_len);
 286           off = svm_fifo_dequeue (tls_rx_fifo, deq_now,
 287                                   TLS_RX_LEN (ptls_ctx));
 288           from_tls_len += off;
 289           ptls_ctx->rx_len += off;
 290         }
 291       picotls_do_handshake (ptls_ctx, tls_session, TLS_RX_OFFSET (ptls_ctx),
 292                             from_tls_len);
 293       if (picotls_handshake_is_over (ctx))
 294         tls_notify_app_accept (ctx);
 295
 296     done_hs:
 297       if (!TLS_RX_IS_LEFT (ptls_ctx))
 298         return 0;
 299     }
 300
 301   app_session = session_get_from_handle (ctx->app_session_handle);
 302   app_rx_fifo = app_session->rx_fifo;
 303
 304   ptls_buffer_init (buf, "", 0);
 305
 306   if (!TLS_RX_IS_LEFT (ptls_ctx))
 307     {
 308       deq_max = svm_fifo_max_dequeue_cons (tls_rx_fifo);
 309       if (!deq_max)
 310         goto app_fifo;
 311
 312       deq_now = clib_min (deq_max, svm_fifo_max_read_chunk (tls_rx_fifo));
 313
 314       off = svm_fifo_dequeue (tls_rx_fifo, deq_now, TLS_RX_LEN (ptls_ctx));
 315       from_tls_len = off;
 316       ptls_ctx->rx_len += off;
 317
 318       if (from_tls_len < deq_max)
 319         {
 320           deq_now =
 321             clib_min (svm_fifo_max_read_chunk (tls_rx_fifo),
 322                       deq_max - from_tls_len);
 323           off =
 324             svm_fifo_dequeue (tls_rx_fifo, deq_now, TLS_RX_LEN (ptls_ctx));
 325           from_tls_len += off;
 326           ptls_ctx->rx_len += off;
 327         }
 328
 329       if (from_tls_len < deq_max)
 330         tls_add_vpp_q_builtin_rx_evt (tls_session);
 331     }
 332
 333 app_fifo:
 334
 335   enq_max = svm_fifo_max_enqueue_prod (app_rx_fifo);
 336   if (!enq_max)
 337     {
 338       tls_add_vpp_q_builtin_rx_evt (tls_session);
 339       goto final;
 340     }
 341
 342   crypto_len = clib_min (enq_max, TLS_RX_LEFT_LEN (ptls_ctx));
 343   off = 0;
 344
 345   do
 346     {
 347       size_t consumed = crypto_len - off;
 348       ret =
 349         ptls_receive (ptls_ctx->tls, buf,
 350                       TLS_RX_OFFSET (ptls_ctx), &consumed);
 351       off += consumed;
 352       ptls_ctx->rx_offset += off;
 353     }
 354   while (ret == 0 && off < crypto_len);
 355
 356   if (ret == 0)
 357     {
 358       enq_now = clib_min (buf->off, svm_fifo_max_write_chunk (app_rx_fifo));
 359       to_app_len = svm_fifo_enqueue (app_rx_fifo, enq_now, buf->base);
 360       if (to_app_len < buf->off)
 361         {
 362           enq_now =
 363             clib_min (svm_fifo_max_write_chunk (app_rx_fifo),
 364                       buf->off - to_app_len);
 365           to_app_len +=
 366             svm_fifo_enqueue (app_rx_fifo, enq_now, buf->base + to_app_len);
 367         }
 368       if (ptls_ctx->rx_len != 0 && !TLS_RX_IS_LEFT (ptls_ctx))
 369         {
 370           ptls_ctx->rx_len = 0;
 371           ptls_ctx->rx_offset = 0;
 372         }
 373
 374     }
 375
 376 final:
 377   ptls_buffer_dispose (buf);
 378
 379   if (app_session->session_state >= SESSION_STATE_READY)
 380     tls_notify_app_enqueue (ctx, app_session);
 381
 382   if (TLS_RX_IS_LEFT (ptls_ctx))
 383     tls_add_vpp_q_builtin_rx_evt (tls_session);
 384
 385   return from_tls_len;
 386 }
 387
 388 static inline int
 389 picotls_content_process (picotls_ctx_t * ptls_ctx, svm_fifo_t * src_fifo,
 390                          svm_fifo_t * dst_fifo, int content_len,
 391                          int total_record_overhead, int is_no_copy)
 392 {
 393   ptls_buffer_t *buf = &ptls_ctx->write_buffer;
 394   int total_length = content_len + total_record_overhead;
 395   int to_dst_len;
 396   if (is_no_copy)
 397     {
 398       ptls_buffer_init (buf, svm_fifo_tail (dst_fifo), total_length);
 399       ptls_send (ptls_ctx->tls, buf, svm_fifo_head (src_fifo), content_len);
 400
 401       assert (!buf->is_allocated);
 402       assert (buf->base == svm_fifo_tail (dst_fifo));
 403
 404       svm_fifo_dequeue_drop (src_fifo, content_len);
 405       svm_fifo_enqueue_nocopy (dst_fifo, buf->off);
 406       to_dst_len = buf->off;
 407     }
 408   else
 409     {
 410       assert (!TLS_WRITE_IS_LEFT (ptls_ctx));
 411       vec_validate (ptls_ctx->write_content, total_length);
 412       ptls_buffer_init (buf, ptls_ctx->write_content, total_length);
 413
 414       ptls_send (ptls_ctx->tls, buf, svm_fifo_head (src_fifo), content_len);
 415       svm_fifo_dequeue_drop (src_fifo, content_len);
 416
 417       to_dst_len = svm_fifo_enqueue (dst_fifo, buf->off, buf->base);
 418     }
 419   ptls_ctx->write_buffer_offset += to_dst_len;
 420   return to_dst_len;
 421 }
 422
 423 static inline int
 424 picotls_ctx_write (tls_ctx_t * ctx, session_t * app_session)
 425 {
 426   picotls_ctx_t *ptls_ctx = (picotls_ctx_t *) ctx;
 427   u32 deq_max, deq_now;
 428   u32 enq_max, enq_now;
 429   int from_app_len = 0, to_tls_len = 0, is_nocopy = 0;
 430   svm_fifo_t *tls_tx_fifo, *app_tx_fifo;
 431   session_t *tls_session;
 432
 433   int record_overhead = ptls_get_record_overhead (ptls_ctx->tls);
 434   int num_records, total_overhead;
 435
 436   tls_session = session_get_from_handle (ctx->tls_session_handle);
 437   tls_tx_fifo = tls_session->tx_fifo;
 438   app_tx_fifo = app_session->tx_fifo;
 439
 440   if (PREDICT_FALSE (TLS_WRITE_IS_LEFT (ptls_ctx)))
 441     {
 442       enq_max = svm_fifo_max_enqueue_prod (tls_tx_fifo);
 443       int to_write = clib_min (enq_max,
 444                                ptls_ctx->write_buffer.off -
 445                                ptls_ctx->write_buffer_offset);
 446       to_tls_len =
 447         svm_fifo_enqueue (tls_tx_fifo, to_write, TLS_WRITE_OFFSET (ptls_ctx));
 448       if (to_tls_len < 0)
 449         {
 450           tls_add_vpp_q_builtin_tx_evt (app_session);
 451           return 0;
 452         }
 453       ptls_ctx->write_buffer_offset += to_tls_len;
 454
 455       if (TLS_WRITE_IS_LEFT (ptls_ctx))
 456         {
 457           tls_add_vpp_q_builtin_tx_evt (app_session);
 458           return to_tls_len;
 459         }
 460       else
 461         {
 462           ptls_buffer_init (&ptls_ctx->write_buffer, "", 0);
 463           ptls_ctx->write_buffer_offset = 0;
 464         }
 465
 466     }
 467
 468   deq_max = svm_fifo_max_dequeue_cons (app_tx_fifo);
 469   if (!deq_max)
 470     return deq_max;
 471   deq_now = clib_min (deq_max, svm_fifo_max_read_chunk (app_tx_fifo));
 472
 473   enq_max = svm_fifo_max_enqueue_prod (tls_tx_fifo);
 474     /** There is no engough enqueue space for one record **/
 475   if (enq_max <= record_overhead)
 476     {
 477       tls_add_vpp_q_builtin_tx_evt (app_session);
 478       return 0;
 479     }
 480
 481   enq_now = clib_min (enq_max, svm_fifo_max_write_chunk (tls_tx_fifo));
 482
 483     /** Allowed to execute no-copy crypto operation **/
 484   if (enq_now > record_overhead)
 485     {
 486       is_nocopy = 1;
 487       from_app_len = clib_min (deq_now, enq_now);
 488       num_records =
 489         ceil ((f64) from_app_len / PTLS_MAX_PLAINTEXT_RECORD_SIZE);
 490       total_overhead = num_records * record_overhead;
 491       if (from_app_len + total_overhead > enq_now)
 492         from_app_len = enq_now - total_overhead;
 493     }
 494   else
 495     {
 496       from_app_len = clib_min (deq_now, enq_max);
 497       num_records =
 498         ceil ((f64) from_app_len / PTLS_MAX_PLAINTEXT_RECORD_SIZE);
 499       total_overhead = num_records * record_overhead;
 500       if (from_app_len + total_overhead > enq_max)
 501         from_app_len = enq_max - total_overhead;
 502     }
 503
 504   to_tls_len =
 505     picotls_content_process (ptls_ctx, app_tx_fifo, tls_tx_fifo,
 506                              from_app_len, total_overhead, is_nocopy);
 507   if (!TLS_WRITE_IS_LEFT (ptls_ctx))
 508     {
 509       ptls_ctx->write_buffer_offset = 0;
 510       ptls_buffer_init (&ptls_ctx->write_buffer, "", 0);
 511     }
 512
 513   if (svm_fifo_needs_deq_ntf (app_tx_fifo, from_app_len))
 514     session_dequeue_notify (app_session);
 515
 516   if (to_tls_len)
 517     tls_add_vpp_q_tx_evt (tls_session);
 518
 519   if (from_app_len < deq_max || TLS_WRITE_IS_LEFT (ptls_ctx))
 520     tls_add_vpp_q_builtin_tx_evt (app_session);
 521
 522   if (ctx->app_closed)
 523     picotls_app_close (ctx);
 524
 525   return 0;
 526 }
 527
 528 static int
 529 picotls_ctx_init_server (tls_ctx_t * ctx)
 530 {
 531   picotls_ctx_t *ptls_ctx = (picotls_ctx_t *) ctx;
 532   u32 ptls_lctx_idx = ctx->tls_ssl_ctx;
 533   picotls_listen_ctx_t *ptls_lctx;
 534
 535   ptls_lctx = picotls_lctx_get (ptls_lctx_idx);
 536   ptls_ctx->tls = ptls_new (ptls_lctx->ptls_ctx, 1);
 537   if (ptls_ctx->tls == NULL)
 538     {
 539       TLS_DBG (1, "Failed to initialize ptls_ssl structure");
 540       return -1;
 541     }
 542
 543   ptls_ctx->rx_len = 0;
 544   ptls_ctx->rx_offset = 0;
 545
 546   ptls_ctx->rx_content = malloc (MAX_QUEUE);
 547
 548   ptls_ctx->write_buffer_offset = 0;
 549   return 0;
 550 }
 551
 552 tls_ctx_t *
 553 picotls_ctx_get_w_thread (u32 ctx_index, u8 thread_index)
 554 {
 555   picotls_ctx_t **ctx;
 556   ctx = pool_elt_at_index (picotls_main.ctx_pool[thread_index], ctx_index);
 557   return &(*ctx)->ctx;
 558 }
 559
 560 const static tls_engine_vft_t picotls_engine = {
 561   .ctx_alloc = picotls_ctx_alloc,
 562   .ctx_free = picotls_ctx_free,
 563   .ctx_get = picotls_ctx_get,
 564   .ctx_get_w_thread = picotls_ctx_get_w_thread,
 565   .ctx_handshake_is_over = picotls_handshake_is_over,
 566   .ctx_start_listen = picotls_start_listen,
 567   .ctx_stop_listen = picotls_stop_listen,
 568   .ctx_init_server = picotls_ctx_init_server,
 569   .ctx_read = picotls_ctx_read,
 570   .ctx_write = picotls_ctx_write,
 571   .ctx_transport_close = picotls_transport_close,
 572   .ctx_app_close = picotls_app_close,
 573 };
 574
 575 static clib_error_t *
 576 tls_picotls_init (vlib_main_t * vm)
 577 {
 578   vlib_thread_main_t *vtm = vlib_get_thread_main ();
 579   picotls_main_t *pm = &picotls_main;
 580   clib_error_t *error = 0;
 581   u32 num_threads;
 582
 583   num_threads = 1 + vtm->n_threads;
 584
 585   vec_validate (pm->ctx_pool, num_threads - 1);
 586
 587   tls_register_engine (&picotls_engine, CRYPTO_ENGINE_PICOTLS);
 588
 589   return error;
 590 }
 591
 592 /* *INDENT-OFF* */
 593 VLIB_INIT_FUNCTION (tls_picotls_init) = {
 594   .runs_after = VLIB_INITS ("tls_init"),
 595 };
 596 /* *INDENT-ON* */
 597
 598 /* *INDENT-OFF* */
 599 VLIB_PLUGIN_REGISTER () = {
 600   .version = VPP_BUILD_VER,
 601   .description = "Transport Layer Security (TLS) Engine, Picotls Based",
 602 };
 603 /* *INDENT-ON* */
 604
 605 /*
 606  * fd.io coding-style-patch-verification: ON
 607  *
 608  * Local Variables:
 609  * eval: (c-set-style "gnu")
 610  * End:
 611  */