src/plugins/crypto_native/aes_cbc_neon.h

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2020 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 #ifdef __aarch64__
  19
  20 static_always_inline void
  21 aes_cbc_dec (u8x16 * k, u8 * src, u8 * dst, u8 * iv, int count, int rounds)
  22 {
  23   u8x16 r0, r1, r2, r3, c0, c1, c2, c3, f;
  24
  25   f = vld1q_u8 (iv);
  26
  27   while (count >= 64)
  28     {
  29       c0 = r0 = vld1q_u8 (src);
  30       c1 = r1 = vld1q_u8 (src + 16);
  31       c2 = r2 = vld1q_u8 (src + 32);
  32       c3 = r3 = vld1q_u8 (src + 48);
  33       for (int i = 0; i < rounds - 1; i++)
  34         {
  35           r0 = vaesimcq_u8 (vaesdq_u8 (r0, k[i]));
  36           r1 = vaesimcq_u8 (vaesdq_u8 (r1, k[i]));
  37           r2 = vaesimcq_u8 (vaesdq_u8 (r2, k[i]));
  38           r3 = vaesimcq_u8 (vaesdq_u8 (r3, k[i]));
  39         }
  40       r0 = vaesdq_u8 (r0, k[rounds - 1]) ^ k[rounds];
  41       r1 = vaesdq_u8 (r1, k[rounds - 1]) ^ k[rounds];
  42       r2 = vaesdq_u8 (r2, k[rounds - 1]) ^ k[rounds];
  43       r3 = vaesdq_u8 (r3, k[rounds - 1]) ^ k[rounds];
  44       vst1q_u8 (dst, r0 ^ f);
  45       vst1q_u8 (dst + 16, r1 ^ c0);
  46       vst1q_u8 (dst + 32, r2 ^ c1);
  47       vst1q_u8 (dst + 48, r3 ^ c2);
  48       f = c3;
  49
  50       src += 64;
  51       dst += 64;
  52       count -= 64;
  53     }
  54
  55   while (count >= 16)
  56     {
  57       c0 = r0 = vld1q_u8 (src);
  58       for (int i = 0; i < rounds - 1; i++)
  59         r0 = vaesimcq_u8 (vaesdq_u8 (r0, k[i]));
  60       r0 = vaesdq_u8 (r0, k[rounds - 1]) ^ k[rounds];
  61       vst1q_u8 (dst, r0 ^ f);
  62       f = c0;
  63
  64       src += 16;
  65       dst += 16;
  66       count -= 16;
  67     }
  68 }
  69
  70 static_always_inline u32
  71 aesni_ops_enc_aes_cbc (vlib_main_t * vm, vnet_crypto_op_t * ops[],
  72                        u32 n_ops, aes_key_size_t ks)
  73 {
  74   crypto_native_main_t *cm = &crypto_native_main;
  75   crypto_native_per_thread_data_t *ptd =
  76     vec_elt_at_index (cm->per_thread_data, vm->thread_index);
  77   int rounds = AES_KEY_ROUNDS (ks);
  78   u8 dummy[8192];
  79   u32 i, j, count, n_left = n_ops;
  80   u32x4 dummy_mask = { };
  81   u32x4 len = { };
  82   vnet_crypto_key_index_t key_index[4];
  83   u8 *src[4] = { };
  84   u8 *dst[4] = { };
  85   u8x16 r[4] = { };
  86   u8x16 k[15][4] = { };
  87
  88   for (i = 0; i < 4; i++)
  89     key_index[i] = ~0;
  90
  91 more:
  92   for (i = 0; i < 4; i++)
  93     if (len[i] == 0)
  94       {
  95         if (n_left == 0)
  96           {
  97             /* no more work to enqueue, so we are enqueueing dummy buffer */
  98             src[i] = dst[i] = dummy;
  99             len[i] = sizeof (dummy);
 100             dummy_mask[i] = 0;
 101           }
 102         else
 103           {
 104             if (ops[0]->flags & VNET_CRYPTO_OP_FLAG_INIT_IV)
 105               {
 106                 r[i] = ptd->cbc_iv[i];
 107                 vst1q_u8 (ops[0]->iv, r[i]);
 108                 ptd->cbc_iv[i] = vaeseq_u8 (r[i], r[i]);
 109               }
 110             else
 111               r[i] = vld1q_u8 (ops[0]->iv);
 112
 113             src[i] = ops[0]->src;
 114             dst[i] = ops[0]->dst;
 115             len[i] = ops[0]->len;
 116             dummy_mask[i] = ~0;
 117             if (key_index[i] != ops[0]->key_index)
 118               {
 119                 aes_cbc_key_data_t *kd;
 120                 key_index[i] = ops[0]->key_index;
 121                 kd = (aes_cbc_key_data_t *) cm->key_data[key_index[i]];
 122                 for (j = 0; j < rounds + 1; j++)
 123                   k[j][i] = kd->encrypt_key[j];
 124               }
 125             ops[0]->status = VNET_CRYPTO_OP_STATUS_COMPLETED;
 126             n_left--;
 127             ops++;
 128           }
 129       }
 130
 131   count = u32x4_min_scalar (len);
 132
 133   ASSERT (count % 16 == 0);
 134
 135   for (i = 0; i < count; i += 16)
 136     {
 137       r[0] ^= vld1q_u8 (src[0] + i);
 138       r[1] ^= vld1q_u8 (src[1] + i);
 139       r[2] ^= vld1q_u8 (src[2] + i);
 140       r[3] ^= vld1q_u8 (src[3] + i);
 141       for (j = 0; j < rounds - 1; j++)
 142         {
 143           r[0] = vaesmcq_u8 (vaeseq_u8 (r[0], k[j][0]));
 144           r[1] = vaesmcq_u8 (vaeseq_u8 (r[1], k[j][1]));
 145           r[2] = vaesmcq_u8 (vaeseq_u8 (r[2], k[j][2]));
 146           r[3] = vaesmcq_u8 (vaeseq_u8 (r[3], k[j][3]));
 147         }
 148       r[0] = vaeseq_u8 (r[0], k[j][0]) ^ k[rounds][0];
 149       r[1] = vaeseq_u8 (r[1], k[j][1]) ^ k[rounds][1];
 150       r[2] = vaeseq_u8 (r[2], k[j][2]) ^ k[rounds][2];
 151       r[3] = vaeseq_u8 (r[3], k[j][3]) ^ k[rounds][3];
 152       vst1q_u8 (dst[0] + i, r[0]);
 153       vst1q_u8 (dst[1] + i, r[1]);
 154       vst1q_u8 (dst[2] + i, r[2]);
 155       vst1q_u8 (dst[3] + i, r[3]);
 156     }
 157
 158   for (i = 0; i < 4; i++)
 159     {
 160       src[i] += count;
 161       dst[i] += count;
 162       len[i] -= count;
 163     }
 164
 165   if (n_left > 0)
 166     goto more;
 167
 168   if (!u32x4_is_all_zero (len & dummy_mask))
 169     goto more;
 170
 171   return n_ops;
 172 }
 173
 174 static_always_inline u32
 175 aesni_ops_dec_aes_cbc (vlib_main_t * vm, vnet_crypto_op_t * ops[],
 176                        u32 n_ops, aes_key_size_t ks)
 177 {
 178   crypto_native_main_t *cm = &crypto_native_main;
 179   int rounds = AES_KEY_ROUNDS (ks);
 180   vnet_crypto_op_t *op = ops[0];
 181   aes_cbc_key_data_t *kd = (aes_cbc_key_data_t *) cm->key_data[op->key_index];
 182   u32 n_left = n_ops;
 183
 184   ASSERT (n_ops >= 1);
 185
 186 decrypt:
 187   aes_cbc_dec (kd->decrypt_key, op->src, op->dst, op->iv, op->len, rounds);
 188   op->status = VNET_CRYPTO_OP_STATUS_COMPLETED;
 189
 190   if (--n_left)
 191     {
 192       op += 1;
 193       kd = (aes_cbc_key_data_t *) cm->key_data[op->key_index];
 194       goto decrypt;
 195     }
 196
 197   return n_ops;
 198 }
 199
 200 #endif
 201
 202 /*
 203  * fd.io coding-style-patch-verification: ON
 204  *
 205  * Local Variables:
 206  * eval: (c-set-style "gnu")
 207  * End:
 208  */