lib/librte_ipsec/crypto.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #ifndef _CRYPTO_H_
   6 #define _CRYPTO_H_
   7
   8 /**
   9  * @file crypto.h
  10  * Contains crypto specific functions/structures/macros used internally
  11  * by ipsec library.
  12  */
  13
  14  /*
  15   * AES-GCM devices have some specific requirements for IV and AAD formats.
  16   * Ideally that to be done by the driver itself.
  17   */
  18
  19 struct aead_gcm_iv {
  20         uint32_t salt;
  21         uint64_t iv;
  22         uint32_t cnt;
  23 } __attribute__((packed));
  24
  25 struct aead_gcm_aad {
  26         uint32_t spi;
  27         /*
  28          * RFC 4106, section 5:
  29          * Two formats of the AAD are defined:
  30          * one for 32-bit sequence numbers, and one for 64-bit ESN.
  31          */
  32         union {
  33                 uint32_t u32[2];
  34                 uint64_t u64;
  35         } sqn;
  36         uint32_t align0; /* align to 16B boundary */
  37 } __attribute__((packed));
  38
  39 struct gcm_esph_iv {
  40         struct esp_hdr esph;
  41         uint64_t iv;
  42 } __attribute__((packed));
  43
  44
  45 static inline void
  46 aead_gcm_iv_fill(struct aead_gcm_iv *gcm, uint64_t iv, uint32_t salt)
  47 {
  48         gcm->salt = salt;
  49         gcm->iv = iv;
  50         gcm->cnt = rte_cpu_to_be_32(1);
  51 }
  52
  53 /*
  54  * RFC 4106, 5 AAD Construction
  55  * spi and sqn should already be converted into network byte order.
  56  * Make sure that not used bytes are zeroed.
  57  */
  58 static inline void
  59 aead_gcm_aad_fill(struct aead_gcm_aad *aad, rte_be32_t spi, rte_be64_t sqn,
  60         int esn)
  61 {
  62         aad->spi = spi;
  63         if (esn)
  64                 aad->sqn.u64 = sqn;
  65         else {
  66                 aad->sqn.u32[0] = sqn_low32(sqn);
  67                 aad->sqn.u32[1] = 0;
  68         }
  69         aad->align0 = 0;
  70 }
  71
  72 static inline void
  73 gen_iv(uint64_t iv[IPSEC_MAX_IV_QWORD], rte_be64_t sqn)
  74 {
  75         iv[0] = sqn;
  76         iv[1] = 0;
  77 }
  78
  79 /*
  80  * from RFC 4303 3.3.2.1.4:
  81  * If the ESN option is enabled for the SA, the high-order 32
  82  * bits of the sequence number are appended after the Next Header field
  83  * for purposes of this computation, but are not transmitted.
  84  */
  85
  86 /*
  87  * Helper function that moves ICV by 4B below, and inserts SQN.hibits.
  88  * icv parameter points to the new start of ICV.
  89  */
  90 static inline void
  91 insert_sqh(uint32_t sqh, void *picv, uint32_t icv_len)
  92 {
  93         uint32_t *icv;
  94         int32_t i;
  95
  96         RTE_ASSERT(icv_len % sizeof(uint32_t) == 0);
  97
  98         icv = picv;
  99         icv_len = icv_len / sizeof(uint32_t);
 100         for (i = icv_len; i-- != 0; icv[i] = icv[i - 1])
 101                 ;
 102
 103         icv[i] = sqh;
 104 }
 105
 106 /*
 107  * Helper function that moves ICV by 4B up, and removes SQN.hibits.
 108  * icv parameter points to the new start of ICV.
 109  */
 110 static inline void
 111 remove_sqh(void *picv, uint32_t icv_len)
 112 {
 113         uint32_t i, *icv;
 114
 115         RTE_ASSERT(icv_len % sizeof(uint32_t) == 0);
 116
 117         icv = picv;
 118         icv_len = icv_len / sizeof(uint32_t);
 119         for (i = 0; i != icv_len; i++)
 120                 icv[i] = icv[i + 1];
 121 }
 122
 123 #endif /* _CRYPTO_H_ */