providers/implementations/ciphers/cipher_aes_ocb_hw.c

   1 /*
   2  * Copyright 2019-2024 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /*
  11  * This file uses the low level AES functions (which are deprecated for
  12  * non-internal use) in order to implement provider AES ciphers.
  13  */
  14 #include "internal/deprecated.h"
  15
  16 #include "cipher_aes_ocb.h"
  17
  18 #define OCB_SET_KEY_FN(fn_set_enc_key, fn_set_dec_key,                         \
  19                        fn_block_enc, fn_block_dec,                             \
  20                        fn_stream_enc, fn_stream_dec)                           \
  21 CRYPTO_ocb128_cleanup(&ctx->ocb);                                              \
  22 fn_set_enc_key(key, keylen * 8, &ctx->ksenc.ks);                               \
  23 fn_set_dec_key(key, keylen * 8, &ctx->ksdec.ks);                               \
  24 if (!CRYPTO_ocb128_init(&ctx->ocb, &ctx->ksenc.ks, &ctx->ksdec.ks,             \
  25                         (block128_f)fn_block_enc, (block128_f)fn_block_dec,    \
  26                         ctx->base.enc ? (ocb128_f)fn_stream_enc :              \
  27                                         (ocb128_f)fn_stream_dec))              \
  28     return 0;                                                                  \
  29 ctx->key_set = 1
  30
  31
  32 static int cipher_hw_aes_ocb_generic_initkey(PROV_CIPHER_CTX *vctx,
  33                                              const unsigned char *key,
  34                                              size_t keylen)
  35 {
  36     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
  37
  38 /*
  39  * We set both the encrypt and decrypt key here because decrypt
  40  * needs both. (i.e- AAD uses encrypt).
  41  */
  42 # ifdef HWAES_CAPABLE
  43     if (HWAES_CAPABLE) {
  44         OCB_SET_KEY_FN(HWAES_set_encrypt_key, HWAES_set_decrypt_key,
  45                        HWAES_encrypt, HWAES_decrypt,
  46                        HWAES_ocb_encrypt, HWAES_ocb_decrypt);
  47     } else
  48 # endif
  49 # ifdef VPAES_CAPABLE
  50     if (VPAES_CAPABLE) {
  51         OCB_SET_KEY_FN(vpaes_set_encrypt_key, vpaes_set_decrypt_key,
  52                        vpaes_encrypt, vpaes_decrypt, NULL, NULL);
  53     } else
  54 # endif
  55     {
  56         OCB_SET_KEY_FN(AES_set_encrypt_key, AES_set_decrypt_key,
  57                        AES_encrypt, AES_decrypt, NULL, NULL);
  58     }
  59     return 1;
  60 }
  61
  62 # if defined(AESNI_CAPABLE)
  63
  64 static int cipher_hw_aes_ocb_aesni_initkey(PROV_CIPHER_CTX *vctx,
  65                                            const unsigned char *key,
  66                                            size_t keylen)
  67 {
  68     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
  69
  70     OCB_SET_KEY_FN(aesni_set_encrypt_key, aesni_set_decrypt_key,
  71                    aesni_encrypt, aesni_decrypt,
  72                    aesni_ocb_encrypt, aesni_ocb_decrypt);
  73     return 1;
  74 }
  75
  76 # define PROV_CIPHER_HW_declare()                                              \
  77 static const PROV_CIPHER_HW aesni_ocb = {                                      \
  78     cipher_hw_aes_ocb_aesni_initkey,                                           \
  79     NULL                                                                       \
  80 };
  81 # define PROV_CIPHER_HW_select()                                               \
  82     if (AESNI_CAPABLE)                                                         \
  83         return &aesni_ocb;
  84
  85 #elif defined(SPARC_AES_CAPABLE)
  86
  87 static int cipher_hw_aes_ocb_t4_initkey(PROV_CIPHER_CTX *vctx,
  88                                         const unsigned char *key,
  89                                         size_t keylen)
  90 {
  91     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
  92
  93     OCB_SET_KEY_FN(aes_t4_set_encrypt_key, aes_t4_set_decrypt_key,
  94                    aes_t4_encrypt, aes_t4_decrypt, NULL, NULL);
  95     return 1;
  96 }
  97
  98 # define PROV_CIPHER_HW_declare()                                              \
  99 static const PROV_CIPHER_HW aes_t4_ocb = {                                     \
 100     cipher_hw_aes_ocb_t4_initkey,                                              \
 101     NULL                                                                       \
 102 };
 103 # define PROV_CIPHER_HW_select()                                               \
 104     if (SPARC_AES_CAPABLE)                                                     \
 105         return &aes_t4_ocb;
 106
 107 #elif defined(OPENSSL_CPUID_OBJ) && defined(__riscv) && __riscv_xlen == 64
 108
 109 static int cipher_hw_aes_ocb_rv64i_zknd_zkne_initkey(PROV_CIPHER_CTX *vctx,
 110                                                      const unsigned char *key,
 111                                                      size_t keylen)
 112 {
 113     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
 114
 115     OCB_SET_KEY_FN(rv64i_zkne_set_encrypt_key, rv64i_zknd_set_decrypt_key,
 116                    rv64i_zkne_encrypt, rv64i_zknd_decrypt, NULL, NULL);
 117     return 1;
 118 }
 119
 120 static int cipher_hw_aes_ocb_rv64i_zvkned_initkey(PROV_CIPHER_CTX *vctx,
 121                                                      const unsigned char *key,
 122                                                      size_t keylen)
 123 {
 124     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
 125
 126     /* Zvkned only supports 128 and 256 bit keys. */
 127     if (keylen * 8 == 128 || keylen * 8 == 256) {
 128         OCB_SET_KEY_FN(rv64i_zvkned_set_encrypt_key,
 129                        rv64i_zvkned_set_decrypt_key,
 130                        rv64i_zvkned_encrypt, rv64i_zvkned_decrypt,
 131                        NULL, NULL);
 132     } else {
 133         OCB_SET_KEY_FN(AES_set_encrypt_key, AES_set_encrypt_key,
 134                        rv64i_zvkned_encrypt, rv64i_zvkned_decrypt,
 135                        NULL, NULL);
 136     }
 137     return 1;
 138 }
 139
 140 # define PROV_CIPHER_HW_declare()                                              \
 141 static const PROV_CIPHER_HW aes_rv64i_zknd_zkne_ocb = {                        \
 142     cipher_hw_aes_ocb_rv64i_zknd_zkne_initkey,                                 \
 143     NULL                                                                       \
 144 };                                                                             \
 145 static const PROV_CIPHER_HW aes_rv64i_zvkned_ocb = {                           \
 146     cipher_hw_aes_ocb_rv64i_zvkned_initkey,                                    \
 147     NULL                                                                       \
 148 };
 149 # define PROV_CIPHER_HW_select()                                               \
 150     if (RISCV_HAS_ZVKNED() && riscv_vlen() >= 128)                             \
 151         return &aes_rv64i_zvkned_ocb;                                          \
 152     else if (RISCV_HAS_ZKND_AND_ZKNE())                                        \
 153         return &aes_rv64i_zknd_zkne_ocb;
 154
 155 #elif defined(OPENSSL_CPUID_OBJ) && defined(__riscv) && __riscv_xlen == 32
 156
 157 static int cipher_hw_aes_ocb_rv32i_zknd_zkne_initkey(PROV_CIPHER_CTX *vctx,
 158                                                      const unsigned char *key,
 159                                                      size_t keylen)
 160 {
 161     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
 162
 163     OCB_SET_KEY_FN(rv32i_zkne_set_encrypt_key, rv32i_zknd_zkne_set_decrypt_key,
 164                    rv32i_zkne_encrypt, rv32i_zknd_decrypt, NULL, NULL);
 165     return 1;
 166 }
 167
 168 static int cipher_hw_aes_ocb_rv32i_zbkb_zknd_zkne_initkey(PROV_CIPHER_CTX *vctx,
 169                                                           const unsigned char *key,
 170                                                           size_t keylen)
 171 {
 172     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
 173
 174     OCB_SET_KEY_FN(rv32i_zbkb_zkne_set_encrypt_key, rv32i_zbkb_zknd_zkne_set_decrypt_key,
 175                    rv32i_zkne_encrypt, rv32i_zknd_decrypt, NULL, NULL);
 176     return 1;
 177 }
 178
 179 # define PROV_CIPHER_HW_declare()                                              \
 180 static const PROV_CIPHER_HW aes_rv32i_zknd_zkne_ocb = {                        \
 181     cipher_hw_aes_ocb_rv32i_zknd_zkne_initkey,                                 \
 182     NULL                                                                       \
 183 };                                                                             \
 184 static const PROV_CIPHER_HW aes_rv32i_zbkb_zknd_zkne_ocb = {                   \
 185     cipher_hw_aes_ocb_rv32i_zbkb_zknd_zkne_initkey,                            \
 186     NULL                                                                       \
 187 };
 188 # define PROV_CIPHER_HW_select()                                               \
 189     if (RISCV_HAS_ZBKB_AND_ZKND_AND_ZKNE())                                    \
 190         return &aes_rv32i_zbkb_zknd_zkne_ocb;                                  \
 191     if (RISCV_HAS_ZKND_AND_ZKNE())                                             \
 192         return &aes_rv32i_zknd_zkne_ocb;
 193 #else
 194 # define PROV_CIPHER_HW_declare()
 195 # define PROV_CIPHER_HW_select()
 196 # endif
 197
 198 static const PROV_CIPHER_HW aes_generic_ocb = {
 199     cipher_hw_aes_ocb_generic_initkey,
 200     NULL
 201 };
 202 PROV_CIPHER_HW_declare()
 203 const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_ocb(size_t keybits)
 204 {
 205     PROV_CIPHER_HW_select()
 206     return &aes_generic_ocb;
 207 }
 208
 209