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