src/plugins/crypto_native/aes_cbc.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2019 Cisco and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *------------------------------------------------------------------
  16  */
  17
  18 #include <vlib/vlib.h>
  19 #include <vnet/plugin/plugin.h>
  20 #include <vnet/crypto/crypto.h>
  21 #include <x86intrin.h>
  22 #include <crypto_native/crypto_native.h>
  23 #include <crypto_native/aes.h>
  24
  25 #if __GNUC__ > 4  && !__clang__ && CLIB_DEBUG == 0
  26 #pragma GCC optimize ("O3")
  27 #endif
  28
  29 typedef struct
  30 {
  31   __m128i encrypt_key[15];
  32 #if __VAES__
  33   __m512i decrypt_key[15];
  34 #else
  35   __m128i decrypt_key[15];
  36 #endif
  37 } aes_cbc_key_data_t;
  38
  39 static_always_inline __m128i
  40 aes_block_load (u8 * p)
  41 {
  42   return _mm_loadu_si128 ((__m128i *) p);
  43 }
  44
  45 static_always_inline void
  46 aes_block_store (u8 * p, __m128i r)
  47 {
  48   _mm_storeu_si128 ((__m128i *) p, r);
  49 }
  50
  51 static_always_inline __m128i __clib_unused
  52 xor3 (__m128i a, __m128i b, __m128i c)
  53 {
  54 #if __AVX512F__
  55   return _mm_ternarylogic_epi32 (a, b, c, 0x96);
  56 #endif
  57   return a ^ b ^ c;
  58 }
  59
  60 #if __VAES__
  61 static_always_inline __m512i
  62 xor3_x4 (__m512i a, __m512i b, __m512i c)
  63 {
  64   return _mm512_ternarylogic_epi32 (a, b, c, 0x96);
  65 }
  66
  67 static_always_inline __m512i
  68 aes_block_load_x4 (u8 * src[], int i)
  69 {
  70   __m512i r = { };
  71   r = _mm512_inserti64x2 (r, aes_block_load (src[0] + i), 0);
  72   r = _mm512_inserti64x2 (r, aes_block_load (src[1] + i), 1);
  73   r = _mm512_inserti64x2 (r, aes_block_load (src[2] + i), 2);
  74   r = _mm512_inserti64x2 (r, aes_block_load (src[3] + i), 3);
  75   return r;
  76 }
  77
  78 static_always_inline void
  79 aes_block_store_x4 (u8 * dst[], int i, __m512i r)
  80 {
  81   aes_block_store (dst[0] + i, _mm512_extracti64x2_epi64 (r, 0));
  82   aes_block_store (dst[1] + i, _mm512_extracti64x2_epi64 (r, 1));
  83   aes_block_store (dst[2] + i, _mm512_extracti64x2_epi64 (r, 2));
  84   aes_block_store (dst[3] + i, _mm512_extracti64x2_epi64 (r, 3));
  85 }
  86 #endif
  87
  88 static_always_inline void __clib_unused
  89 aes_cbc_dec (__m128i * k, u8 * src, u8 * dst, u8 * iv, int count,
  90              aes_key_size_t rounds)
  91 {
  92   __m128i r0, r1, r2, r3, c0, c1, c2, c3, f;
  93   int i;
  94
  95   f = aes_block_load (iv);
  96
  97   while (count >= 64)
  98     {
  99       _mm_prefetch (src + 128, _MM_HINT_T0);
 100       _mm_prefetch (dst + 128, _MM_HINT_T0);
 101
 102       c0 = aes_block_load (src);
 103       c1 = aes_block_load (src + 16);
 104       c2 = aes_block_load (src + 32);
 105       c3 = aes_block_load (src + 48);
 106
 107       r0 = c0 ^ k[0];
 108       r1 = c1 ^ k[0];
 109       r2 = c2 ^ k[0];
 110       r3 = c3 ^ k[0];
 111
 112       for (i = 1; i < rounds; i++)
 113         {
 114           r0 = _mm_aesdec_si128 (r0, k[i]);
 115           r1 = _mm_aesdec_si128 (r1, k[i]);
 116           r2 = _mm_aesdec_si128 (r2, k[i]);
 117           r3 = _mm_aesdec_si128 (r3, k[i]);
 118         }
 119
 120       r0 = _mm_aesdeclast_si128 (r0, k[i]);
 121       r1 = _mm_aesdeclast_si128 (r1, k[i]);
 122       r2 = _mm_aesdeclast_si128 (r2, k[i]);
 123       r3 = _mm_aesdeclast_si128 (r3, k[i]);
 124
 125       aes_block_store (dst, r0 ^ f);
 126       aes_block_store (dst + 16, r1 ^ c0);
 127       aes_block_store (dst + 32, r2 ^ c1);
 128       aes_block_store (dst + 48, r3 ^ c2);
 129
 130       f = c3;
 131
 132       count -= 64;
 133       src += 64;
 134       dst += 64;
 135     }
 136
 137   while (count > 0)
 138     {
 139       c0 = aes_block_load (src);
 140       r0 = c0 ^ k[0];
 141       for (i = 1; i < rounds; i++)
 142         r0 = _mm_aesdec_si128 (r0, k[i]);
 143       r0 = _mm_aesdeclast_si128 (r0, k[i]);
 144       aes_block_store (dst, r0 ^ f);
 145       f = c0;
 146       count -= 16;
 147       src += 16;
 148       dst += 16;
 149     }
 150 }
 151
 152 #ifdef __VAES__
 153 static_always_inline void
 154 vaes_cbc_dec (__m512i * k, u8 * src, u8 * dst, u8 * iv, int count,
 155               aes_key_size_t rounds)
 156 {
 157   __m512i permute = { 6, 7, 8, 9, 10, 11, 12, 13 };
 158   __m512i r0, r1, r2, r3, c0, c1, c2, c3, f = { };
 159   __mmask8 m;
 160   int i, n_blocks = count >> 4;
 161
 162   f = _mm512_mask_loadu_epi64 (f, 0xc0, (__m512i *) (iv - 48));
 163
 164   while (n_blocks >= 16)
 165     {
 166       c0 = _mm512_loadu_si512 ((__m512i *) src);
 167       c1 = _mm512_loadu_si512 ((__m512i *) (src + 64));
 168       c2 = _mm512_loadu_si512 ((__m512i *) (src + 128));
 169       c3 = _mm512_loadu_si512 ((__m512i *) (src + 192));
 170
 171       r0 = c0 ^ k[0];
 172       r1 = c1 ^ k[0];
 173       r2 = c2 ^ k[0];
 174       r3 = c3 ^ k[0];
 175
 176       for (i = 1; i < rounds; i++)
 177         {
 178           r0 = _mm512_aesdec_epi128 (r0, k[i]);
 179           r1 = _mm512_aesdec_epi128 (r1, k[i]);
 180           r2 = _mm512_aesdec_epi128 (r2, k[i]);
 181           r3 = _mm512_aesdec_epi128 (r3, k[i]);
 182         }
 183
 184       r0 = _mm512_aesdeclast_epi128 (r0, k[i]);
 185       r1 = _mm512_aesdeclast_epi128 (r1, k[i]);
 186       r2 = _mm512_aesdeclast_epi128 (r2, k[i]);
 187       r3 = _mm512_aesdeclast_epi128 (r3, k[i]);
 188
 189       r0 ^= _mm512_permutex2var_epi64 (f, permute, c0);
 190       _mm512_storeu_si512 ((__m512i *) dst, r0);
 191
 192       r1 ^= _mm512_permutex2var_epi64 (c0, permute, c1);
 193       _mm512_storeu_si512 ((__m512i *) (dst + 64), r1);
 194
 195       r2 ^= _mm512_permutex2var_epi64 (c1, permute, c2);
 196       _mm512_storeu_si512 ((__m512i *) (dst + 128), r2);
 197
 198       r3 ^= _mm512_permutex2var_epi64 (c2, permute, c3);
 199       _mm512_storeu_si512 ((__m512i *) (dst + 192), r3);
 200       f = c3;
 201
 202       n_blocks -= 16;
 203       src += 256;
 204       dst += 256;
 205     }
 206
 207   while (n_blocks > 0)
 208     {
 209       m = (1 << (n_blocks * 2)) - 1;
 210       c0 = _mm512_mask_loadu_epi64 (c0, m, (__m512i *) src);
 211       f = _mm512_permutex2var_epi64 (f, permute, c0);
 212       r0 = c0 ^ k[0];
 213       for (i = 1; i < rounds; i++)
 214         r0 = _mm512_aesdec_epi128 (r0, k[i]);
 215       r0 = _mm512_aesdeclast_epi128 (r0, k[i]);
 216       _mm512_mask_storeu_epi64 ((__m512i *) dst, m, r0 ^ f);
 217       f = c0;
 218       n_blocks -= 4;
 219       src += 64;
 220       dst += 64;
 221     }
 222 }
 223 #endif
 224
 225 #ifdef __VAES__
 226 #define N 16
 227 #define u32xN u32x16
 228 #define u32xN_min_scalar u32x16_min_scalar
 229 #define u32xN_is_all_zero u32x16_is_all_zero
 230 #else
 231 #define N 4
 232 #define u32xN u32x4
 233 #define u32xN_min_scalar u32x4_min_scalar
 234 #define u32xN_is_all_zero u32x4_is_all_zero
 235 #endif
 236
 237 static_always_inline u32
 238 aesni_ops_enc_aes_cbc (vlib_main_t * vm, vnet_crypto_op_t * ops[],
 239                        u32 n_ops, aes_key_size_t ks)
 240 {
 241   crypto_native_main_t *cm = &crypto_native_main;
 242   crypto_native_per_thread_data_t *ptd =
 243     vec_elt_at_index (cm->per_thread_data, vm->thread_index);
 244   int rounds = AES_KEY_ROUNDS (ks);
 245   u8 dummy[8192];
 246   u32 i, j, count, n_left = n_ops;
 247   u32xN dummy_mask = { };
 248   u32xN len = { };
 249   vnet_crypto_key_index_t key_index[N];
 250   u8 *src[N] = { };
 251   u8 *dst[N] = { };
 252   /* *INDENT-OFF* */
 253   union
 254   {
 255     __m128i x1[N];
 256     __m512i x4[N / 4];
 257   } r = { }, k[15] = { };
 258   /* *INDENT-ON* */
 259
 260   for (i = 0; i < N; i++)
 261     key_index[i] = ~0;
 262
 263 more:
 264   for (i = 0; i < N; i++)
 265     if (len[i] == 0)
 266       {
 267         if (n_left == 0)
 268           {
 269             /* no more work to enqueue, so we are enqueueing dummy buffer */
 270             src[i] = dst[i] = dummy;
 271             len[i] = sizeof (dummy);
 272             dummy_mask[i] = 0;
 273           }
 274         else
 275           {
 276             if (ops[0]->flags & VNET_CRYPTO_OP_FLAG_INIT_IV)
 277               {
 278                 r.x1[i] = ptd->cbc_iv[i];
 279                 aes_block_store (ops[0]->iv, r.x1[i]);
 280                 ptd->cbc_iv[i] = _mm_aesenc_si128 (r.x1[i], r.x1[i]);
 281               }
 282             else
 283               r.x1[i] = aes_block_load (ops[0]->iv);
 284
 285             src[i] = ops[0]->src;
 286             dst[i] = ops[0]->dst;
 287             len[i] = ops[0]->len;
 288             dummy_mask[i] = ~0;
 289             if (key_index[i] != ops[0]->key_index)
 290               {
 291                 aes_cbc_key_data_t *kd;
 292                 key_index[i] = ops[0]->key_index;
 293                 kd = (aes_cbc_key_data_t *) cm->key_data[key_index[i]];
 294                 for (j = 0; j < rounds + 1; j++)
 295                   k[j].x1[i] = kd->encrypt_key[j];
 296               }
 297             ops[0]->status = VNET_CRYPTO_OP_STATUS_COMPLETED;
 298             n_left--;
 299             ops++;
 300           }
 301       }
 302
 303   count = u32xN_min_scalar (len);
 304
 305   ASSERT (count % 16 == 0);
 306
 307   for (i = 0; i < count; i += 16)
 308     {
 309 #ifdef __VAES__
 310       r.x4[0] = xor3_x4 (r.x4[0], aes_block_load_x4 (src, i), k[0].x4[0]);
 311       r.x4[1] = xor3_x4 (r.x4[1], aes_block_load_x4 (src, i), k[0].x4[1]);
 312       r.x4[2] = xor3_x4 (r.x4[2], aes_block_load_x4 (src, i), k[0].x4[2]);
 313       r.x4[3] = xor3_x4 (r.x4[3], aes_block_load_x4 (src, i), k[0].x4[3]);
 314
 315       for (j = 1; j < rounds; j++)
 316         {
 317           r.x4[0] = _mm512_aesenc_epi128 (r.x4[0], k[j].x4[0]);
 318           r.x4[1] = _mm512_aesenc_epi128 (r.x4[1], k[j].x4[1]);
 319           r.x4[2] = _mm512_aesenc_epi128 (r.x4[2], k[j].x4[2]);
 320           r.x4[3] = _mm512_aesenc_epi128 (r.x4[3], k[j].x4[3]);
 321         }
 322       r.x4[0] = _mm512_aesenclast_epi128 (r.x4[0], k[j].x4[0]);
 323       r.x4[1] = _mm512_aesenclast_epi128 (r.x4[1], k[j].x4[1]);
 324       r.x4[2] = _mm512_aesenclast_epi128 (r.x4[2], k[j].x4[2]);
 325       r.x4[3] = _mm512_aesenclast_epi128 (r.x4[3], k[j].x4[3]);
 326
 327       aes_block_store_x4 (dst, i, r.x4[0]);
 328       aes_block_store_x4 (dst + 4, i, r.x4[1]);
 329       aes_block_store_x4 (dst + 8, i, r.x4[2]);
 330       aes_block_store_x4 (dst + 12, i, r.x4[3]);
 331 #else
 332       r.x1[0] = xor3 (r.x1[0], aes_block_load (src[0] + i), k[0].x1[0]);
 333       r.x1[1] = xor3 (r.x1[1], aes_block_load (src[1] + i), k[0].x1[1]);
 334       r.x1[2] = xor3 (r.x1[2], aes_block_load (src[2] + i), k[0].x1[2]);
 335       r.x1[3] = xor3 (r.x1[3], aes_block_load (src[3] + i), k[0].x1[3]);
 336
 337       for (j = 1; j < rounds; j++)
 338         {
 339           r.x1[0] = _mm_aesenc_si128 (r.x1[0], k[j].x1[0]);
 340           r.x1[1] = _mm_aesenc_si128 (r.x1[1], k[j].x1[1]);
 341           r.x1[2] = _mm_aesenc_si128 (r.x1[2], k[j].x1[2]);
 342           r.x1[3] = _mm_aesenc_si128 (r.x1[3], k[j].x1[3]);
 343         }
 344
 345       r.x1[0] = _mm_aesenclast_si128 (r.x1[0], k[j].x1[0]);
 346       r.x1[1] = _mm_aesenclast_si128 (r.x1[1], k[j].x1[1]);
 347       r.x1[2] = _mm_aesenclast_si128 (r.x1[2], k[j].x1[2]);
 348       r.x1[3] = _mm_aesenclast_si128 (r.x1[3], k[j].x1[3]);
 349
 350       aes_block_store (dst[0] + i, r.x1[0]);
 351       aes_block_store (dst[1] + i, r.x1[1]);
 352       aes_block_store (dst[2] + i, r.x1[2]);
 353       aes_block_store (dst[3] + i, r.x1[3]);
 354 #endif
 355     }
 356
 357   for (i = 0; i < N; i++)
 358     {
 359       src[i] += count;
 360       dst[i] += count;
 361       len[i] -= count;
 362     }
 363
 364   if (n_left > 0)
 365     goto more;
 366
 367   if (!u32xN_is_all_zero (len & dummy_mask))
 368     goto more;
 369
 370   return n_ops;
 371 }
 372
 373 static_always_inline u32
 374 aesni_ops_dec_aes_cbc (vlib_main_t * vm, vnet_crypto_op_t * ops[],
 375                        u32 n_ops, aes_key_size_t ks)
 376 {
 377   crypto_native_main_t *cm = &crypto_native_main;
 378   int rounds = AES_KEY_ROUNDS (ks);
 379   vnet_crypto_op_t *op = ops[0];
 380   aes_cbc_key_data_t *kd = (aes_cbc_key_data_t *) cm->key_data[op->key_index];
 381   u32 n_left = n_ops;
 382
 383   ASSERT (n_ops >= 1);
 384
 385 decrypt:
 386 #ifdef __VAES__
 387   vaes_cbc_dec (kd->decrypt_key, op->src, op->dst, op->iv, op->len, rounds);
 388 #else
 389   aes_cbc_dec (kd->decrypt_key, op->src, op->dst, op->iv, op->len, rounds);
 390 #endif
 391   op->status = VNET_CRYPTO_OP_STATUS_COMPLETED;
 392
 393   if (--n_left)
 394     {
 395       op += 1;
 396       kd = (aes_cbc_key_data_t *) cm->key_data[op->key_index];
 397       goto decrypt;
 398     }
 399
 400   return n_ops;
 401 }
 402
 403 static_always_inline void *
 404 aesni_cbc_key_exp (vnet_crypto_key_t * key, aes_key_size_t ks)
 405 {
 406   __m128i e[15], d[15];
 407   aes_cbc_key_data_t *kd;
 408   kd = clib_mem_alloc_aligned (sizeof (*kd), CLIB_CACHE_LINE_BYTES);
 409   aes_key_expand (e, key->data, ks);
 410   aes_key_enc_to_dec (e, d, ks);
 411   for (int i = 0; i < AES_KEY_ROUNDS (ks) + 1; i++)
 412     {
 413 #if __VAES__
 414       kd->decrypt_key[i] = _mm512_broadcast_i64x2 (d[i]);
 415 #else
 416       kd->decrypt_key[i] = d[i];
 417 #endif
 418       kd->encrypt_key[i] = e[i];
 419     }
 420   return kd;
 421 }
 422
 423 #define foreach_aesni_cbc_handler_type _(128) _(192) _(256)
 424
 425 #define _(x) \
 426 static u32 aesni_ops_dec_aes_cbc_##x \
 427 (vlib_main_t * vm, vnet_crypto_op_t * ops[], u32 n_ops) \
 428 { return aesni_ops_dec_aes_cbc (vm, ops, n_ops, AES_KEY_##x); } \
 429 static u32 aesni_ops_enc_aes_cbc_##x \
 430 (vlib_main_t * vm, vnet_crypto_op_t * ops[], u32 n_ops) \
 431 { return aesni_ops_enc_aes_cbc (vm, ops, n_ops, AES_KEY_##x); } \
 432 static void * aesni_cbc_key_exp_##x (vnet_crypto_key_t *key) \
 433 { return aesni_cbc_key_exp (key, AES_KEY_##x); }
 434
 435 foreach_aesni_cbc_handler_type;
 436 #undef _
 437
 438 #include <fcntl.h>
 439
 440 clib_error_t *
 441 #ifdef __VAES__
 442 crypto_native_aes_cbc_init_vaes (vlib_main_t * vm)
 443 #elif __AVX512F__
 444 crypto_native_aes_cbc_init_avx512 (vlib_main_t * vm)
 445 #elif __AVX2__
 446 crypto_native_aes_cbc_init_avx2 (vlib_main_t * vm)
 447 #else
 448 crypto_native_aes_cbc_init_sse42 (vlib_main_t * vm)
 449 #endif
 450 {
 451   crypto_native_main_t *cm = &crypto_native_main;
 452   crypto_native_per_thread_data_t *ptd;
 453   clib_error_t *err = 0;
 454   int fd;
 455
 456   if ((fd = open ("/dev/urandom", O_RDONLY)) < 0)
 457     return clib_error_return_unix (0, "failed to open '/dev/urandom'");
 458
 459   /* *INDENT-OFF* */
 460   vec_foreach (ptd, cm->per_thread_data)
 461     {
 462       for (int i = 0; i < 4; i++)
 463         {
 464           if (read(fd, ptd->cbc_iv, sizeof (ptd->cbc_iv)) !=
 465               sizeof (ptd->cbc_iv))
 466             {
 467               err = clib_error_return_unix (0, "'/dev/urandom' read failure");
 468               goto error;
 469             }
 470         }
 471     }
 472   /* *INDENT-ON* */
 473
 474 #define _(x) \
 475   vnet_crypto_register_ops_handler (vm, cm->crypto_engine_index, \
 476                                     VNET_CRYPTO_OP_AES_##x##_CBC_ENC, \
 477                                     aesni_ops_enc_aes_cbc_##x); \
 478   vnet_crypto_register_ops_handler (vm, cm->crypto_engine_index, \
 479                                     VNET_CRYPTO_OP_AES_##x##_CBC_DEC, \
 480                                     aesni_ops_dec_aes_cbc_##x); \
 481   cm->key_fn[VNET_CRYPTO_ALG_AES_##x##_CBC] = aesni_cbc_key_exp_##x;
 482   foreach_aesni_cbc_handler_type;
 483 #undef _
 484
 485 error:
 486   close (fd);
 487   return err;
 488 }
 489
 490 /*
 491  * fd.io coding-style-patch-verification: ON
 492  *
 493  * Local Variables:
 494  * eval: (c-set-style "gnu")
 495  * End:
 496  */