src/plugins/quic/quic_crypto.c

   1 /*
   2  * Copyright (c) 2019 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:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   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.
  14  */
  15
  16 #include <quic/quic_crypto.h>
  17 #include <quic/quic.h>
  18
  19 #include <vnet/crypto/crypto.h>
  20
  21 #include <picotls/openssl.h>
  22 #include <quicly.h>
  23
  24 typedef void (*quicly_do_transform_fn) (ptls_cipher_context_t *, void *,
  25                                         const void *, size_t);
  26
  27 struct cipher_context_t
  28 {
  29   ptls_cipher_context_t super;
  30   vnet_crypto_op_t op;
  31   u32 key_index;
  32 };
  33
  34 struct aead_crypto_context_t
  35 {
  36   ptls_aead_context_t super;
  37   vnet_crypto_op_t op;
  38   u32 key_index;
  39 };
  40
  41 vnet_crypto_main_t *cm = &crypto_main;
  42
  43 static void
  44 quic_crypto_cipher_do_init (ptls_cipher_context_t * _ctx, const void *iv)
  45 {
  46   struct cipher_context_t *ctx = (struct cipher_context_t *) _ctx;
  47
  48   vnet_crypto_op_id_t id;
  49   if (!strcmp (ctx->super.algo->name, "AES128-CTR"))
  50     {
  51       id = VNET_CRYPTO_OP_AES_128_CTR_ENC;
  52     }
  53   else if (!strcmp (ctx->super.algo->name, "AES256-CTR"))
  54     {
  55       id = VNET_CRYPTO_OP_AES_256_CTR_ENC;
  56     }
  57   else
  58     {
  59       QUIC_DBG (1, "%s, Invalid crypto cipher : ", __FUNCTION__,
  60                 _ctx->algo->name);
  61       assert (0);
  62     }
  63
  64   vnet_crypto_op_init (&ctx->op, id);
  65   ctx->op.iv = (u8 *) iv;
  66   ctx->op.key_index = ctx->key_index;
  67 }
  68
  69 static void
  70 quic_crypto_cipher_dispose (ptls_cipher_context_t * _ctx)
  71 {
  72   /* Do nothing */
  73 }
  74
  75 static void
  76 quic_crypto_cipher_encrypt (ptls_cipher_context_t * _ctx, void *output,
  77                             const void *input, size_t _len)
  78 {
  79   vlib_main_t *vm = vlib_get_main ();
  80   struct cipher_context_t *ctx = (struct cipher_context_t *) _ctx;
  81
  82   ctx->op.src = (u8 *) input;
  83   ctx->op.dst = output;
  84   ctx->op.len = _len;
  85
  86   vnet_crypto_process_ops (vm, &ctx->op, 1);
  87 }
  88
  89 static int
  90 quic_crypto_cipher_setup_crypto (ptls_cipher_context_t * _ctx, int is_enc,
  91                                  const void *key, const EVP_CIPHER * cipher,
  92                                  quicly_do_transform_fn do_transform)
  93 {
  94   struct cipher_context_t *ctx = (struct cipher_context_t *) _ctx;
  95
  96   ctx->super.do_dispose = quic_crypto_cipher_dispose;
  97   ctx->super.do_init = quic_crypto_cipher_do_init;
  98   ctx->super.do_transform = do_transform;
  99
 100   vlib_main_t *vm = vlib_get_main ();
 101   vnet_crypto_alg_t algo;
 102   if (!strcmp (ctx->super.algo->name, "AES128-CTR"))
 103     {
 104       algo = VNET_CRYPTO_ALG_AES_128_CTR;
 105     }
 106   else if (!strcmp (ctx->super.algo->name, "AES256-CTR"))
 107     {
 108       algo = VNET_CRYPTO_ALG_AES_256_CTR;
 109     }
 110   else
 111     {
 112       QUIC_DBG (1, "%s, Invalid crypto cipher : ", __FUNCTION__,
 113                 _ctx->algo->name);
 114       assert (0);
 115     }
 116
 117   ctx->key_index = vnet_crypto_key_add (vm, algo,
 118                                         (u8 *) key, _ctx->algo->key_size);
 119
 120   return 0;
 121 }
 122
 123 static int
 124 aes128ctr_setup_crypto (ptls_cipher_context_t * ctx, int is_enc,
 125                         const void *key)
 126 {
 127   return quic_crypto_cipher_setup_crypto (ctx, 1, key, EVP_aes_128_ctr (),
 128                                           quic_crypto_cipher_encrypt);
 129 }
 130
 131 static int
 132 aes256ctr_setup_crypto (ptls_cipher_context_t * ctx, int is_enc,
 133                         const void *key)
 134 {
 135   return quic_crypto_cipher_setup_crypto (ctx, 1, key, EVP_aes_256_ctr (),
 136                                           quic_crypto_cipher_encrypt);
 137 }
 138
 139 size_t
 140 quic_crypto_aead_encrypt (ptls_aead_context_t * _ctx, void *output,
 141                           const void *input, size_t inlen, uint64_t seq,
 142                           const void *iv, const void *aad, size_t aadlen)
 143 {
 144   vlib_main_t *vm = vlib_get_main ();
 145   struct aead_crypto_context_t *ctx = (struct aead_crypto_context_t *) _ctx;
 146
 147   vnet_crypto_op_id_t id;
 148   if (!strcmp (ctx->super.algo->name, "AES128-GCM"))
 149     {
 150       id = VNET_CRYPTO_OP_AES_128_GCM_ENC;
 151     }
 152   else if (!strcmp (ctx->super.algo->name, "AES256-GCM"))
 153     {
 154       id = VNET_CRYPTO_OP_AES_256_GCM_ENC;
 155     }
 156   else
 157     {
 158       assert (0);
 159     }
 160
 161   vnet_crypto_op_init (&ctx->op, id);
 162   ctx->op.aad = (u8 *) aad;
 163   ctx->op.aad_len = aadlen;
 164   ctx->op.iv = (u8 *) iv;
 165
 166   ctx->op.src = (u8 *) input;
 167   ctx->op.dst = output;
 168   ctx->op.key_index = ctx->key_index;
 169   ctx->op.len = inlen;
 170
 171   ctx->op.tag_len = ctx->super.algo->tag_size;
 172   ctx->op.tag = ctx->op.src + inlen;
 173
 174   vnet_crypto_process_ops (vm, &ctx->op, 1);
 175
 176   return ctx->op.len + ctx->op.tag_len;
 177 }
 178
 179 size_t
 180 quic_crypto_aead_decrypt (ptls_aead_context_t * _ctx, void *_output,
 181                           const void *input, size_t inlen, const void *iv,
 182                           const void *aad, size_t aadlen)
 183 {
 184   vlib_main_t *vm = vlib_get_main ();
 185   struct aead_crypto_context_t *ctx = (struct aead_crypto_context_t *) _ctx;
 186
 187   vnet_crypto_op_id_t id;
 188   if (!strcmp (ctx->super.algo->name, "AES128-GCM"))
 189     {
 190       id = VNET_CRYPTO_OP_AES_128_GCM_DEC;
 191     }
 192   else if (!strcmp (ctx->super.algo->name, "AES256-GCM"))
 193     {
 194       id = VNET_CRYPTO_OP_AES_256_GCM_DEC;
 195     }
 196   else
 197     {
 198       assert (0);
 199     }
 200
 201   vnet_crypto_op_init (&ctx->op, id);
 202   ctx->op.aad = (u8 *) aad;
 203   ctx->op.aad_len = aadlen;
 204   ctx->op.iv = (u8 *) iv;
 205
 206   ctx->op.src = (u8 *) input;
 207   ctx->op.dst = _output;
 208   ctx->op.key_index = ctx->key_index;
 209   ctx->op.len = inlen - ctx->super.algo->tag_size;
 210
 211   ctx->op.tag_len = ctx->super.algo->tag_size;
 212   ctx->op.tag = ctx->op.src + ctx->op.len;
 213
 214   vnet_crypto_process_ops (vm, &ctx->op, 1);
 215
 216   return ctx->op.len;
 217 }
 218
 219 static void
 220 quic_crypto_aead_dispose_crypto (ptls_aead_context_t * _ctx)
 221 {
 222
 223 }
 224
 225 static int
 226 quic_crypto_aead_setup_crypto (ptls_aead_context_t * _ctx, int is_enc,
 227                                const void *key, const EVP_CIPHER * cipher)
 228 {
 229   vlib_main_t *vm = vlib_get_main ();
 230   struct aead_crypto_context_t *ctx = (struct aead_crypto_context_t *) _ctx;
 231
 232   vnet_crypto_alg_t algo;
 233   if (!strcmp (ctx->super.algo->name, "AES128-GCM"))
 234     {
 235       algo = VNET_CRYPTO_ALG_AES_128_GCM;
 236     }
 237   else if (!strcmp (ctx->super.algo->name, "AES256-GCM"))
 238     {
 239       algo = VNET_CRYPTO_ALG_AES_256_GCM;
 240     }
 241   else
 242     {
 243       QUIC_DBG (1, "%s, invalied aead cipher %s", __FUNCTION__,
 244                 _ctx->algo->name);
 245       assert (0);
 246     }
 247
 248   ctx->super.do_decrypt = quic_crypto_aead_decrypt;
 249   ctx->super.do_encrypt = quic_crypto_aead_encrypt;
 250   ctx->super.dispose_crypto = quic_crypto_aead_dispose_crypto;
 251
 252   ctx->key_index = vnet_crypto_key_add (vm, algo,
 253                                         (u8 *) key, _ctx->algo->key_size);
 254
 255   return 0;
 256 }
 257
 258 static int
 259 quic_crypto_aead_aes128gcm_setup_crypto (ptls_aead_context_t * ctx,
 260                                          int is_enc, const void *key)
 261 {
 262   return quic_crypto_aead_setup_crypto (ctx, is_enc, key, EVP_aes_128_gcm ());
 263 }
 264
 265 static int
 266 quic_crypto_aead_aes256gcm_setup_crypto (ptls_aead_context_t * ctx,
 267                                          int is_enc, const void *key)
 268 {
 269   return quic_crypto_aead_setup_crypto (ctx, is_enc, key, EVP_aes_256_gcm ());
 270 }
 271
 272 ptls_cipher_algorithm_t quic_crypto_aes128ctr = { "AES128-CTR",
 273   PTLS_AES128_KEY_SIZE,
 274   1, PTLS_AES_IV_SIZE,
 275   sizeof (struct cipher_context_t),
 276   aes128ctr_setup_crypto
 277 };
 278
 279 ptls_cipher_algorithm_t quic_crypto_aes256ctr = { "AES256-CTR",
 280   PTLS_AES256_KEY_SIZE,
 281   1 /* block size */ ,
 282   PTLS_AES_IV_SIZE,
 283   sizeof (struct cipher_context_t),
 284   aes256ctr_setup_crypto
 285 };
 286
 287 ptls_aead_algorithm_t quic_crypto_aes128gcm = { "AES128-GCM",
 288   &quic_crypto_aes128ctr,
 289   NULL,
 290   PTLS_AES128_KEY_SIZE,
 291   PTLS_AESGCM_IV_SIZE,
 292   PTLS_AESGCM_TAG_SIZE,
 293   sizeof (struct aead_crypto_context_t),
 294   quic_crypto_aead_aes128gcm_setup_crypto
 295 };
 296
 297 ptls_aead_algorithm_t quic_crypto_aes256gcm = { "AES256-GCM",
 298   &quic_crypto_aes256ctr,
 299   NULL,
 300   PTLS_AES256_KEY_SIZE,
 301   PTLS_AESGCM_IV_SIZE,
 302   PTLS_AESGCM_TAG_SIZE,
 303   sizeof (struct aead_crypto_context_t),
 304   quic_crypto_aead_aes256gcm_setup_crypto
 305 };
 306
 307 ptls_cipher_suite_t quic_crypto_aes128gcmsha256 =
 308   { PTLS_CIPHER_SUITE_AES_128_GCM_SHA256,
 309   &quic_crypto_aes128gcm,
 310   &ptls_openssl_sha256
 311 };
 312
 313 ptls_cipher_suite_t quic_crypto_aes256gcmsha384 =
 314   { PTLS_CIPHER_SUITE_AES_256_GCM_SHA384,
 315   &quic_crypto_aes256gcm,
 316   &ptls_openssl_sha384
 317 };
 318
 319 ptls_cipher_suite_t *quic_crypto_cipher_suites[] =
 320   { &quic_crypto_aes256gcmsha384,
 321   &quic_crypto_aes128gcmsha256,
 322   NULL
 323 };
 324
 325 /*
 326  * fd.io coding-style-patch-verification: ON
 327  *
 328  * Local Variables:
 329  * eval: (c-set-style "gnu")
 330  * End:
 331  */