providers/implementations/ciphers/cipher_aes_xts_hw.c

   1 /*
   2  * Copyright 2019-2020 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_xts.h"
  17
  18 #define XTS_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     size_t bytes = keylen / 2;                                                 \
  22     size_t bits = bytes * 8;                                                   \
  23                                                                                \
  24     if (ctx->enc) {                                                            \
  25         fn_set_enc_key(key, bits, &xctx->ks1.ks);                              \
  26         xctx->xts.block1 = (block128_f)fn_block_enc;                           \
  27     } else {                                                                   \
  28         fn_set_dec_key(key, bits, &xctx->ks1.ks);                              \
  29         xctx->xts.block1 = (block128_f)fn_block_dec;                           \
  30     }                                                                          \
  31     fn_set_enc_key(key + bytes, bits, &xctx->ks2.ks);                          \
  32     xctx->xts.block2 = (block128_f)fn_block_enc;                               \
  33     xctx->xts.key1 = &xctx->ks1;                                               \
  34     xctx->xts.key2 = &xctx->ks2;                                               \
  35     xctx->stream = ctx->enc ? fn_stream_enc : fn_stream_dec;                   \
  36 }
  37
  38 static int cipher_hw_aes_xts_generic_initkey(PROV_CIPHER_CTX *ctx,
  39                                              const unsigned char *key,
  40                                              size_t keylen)
  41 {
  42     PROV_AES_XTS_CTX *xctx = (PROV_AES_XTS_CTX *)ctx;
  43     OSSL_xts_stream_fn stream_enc = NULL;
  44     OSSL_xts_stream_fn stream_dec = NULL;
  45
  46 #ifdef AES_XTS_ASM
  47     stream_enc = AES_xts_encrypt;
  48     stream_dec = AES_xts_decrypt;
  49 #endif /* AES_XTS_ASM */
  50
  51 #ifdef HWAES_CAPABLE
  52     if (HWAES_CAPABLE) {
  53 # ifdef HWAES_xts_encrypt
  54         stream_enc = HWAES_xts_encrypt;
  55 # endif /* HWAES_xts_encrypt */
  56 # ifdef HWAES_xts_decrypt
  57         stream_dec = HWAES_xts_decrypt;
  58 # endif /* HWAES_xts_decrypt */
  59         XTS_SET_KEY_FN(HWAES_set_encrypt_key, HWAES_set_decrypt_key,
  60                        HWAES_encrypt, HWAES_decrypt,
  61                        stream_enc, stream_dec);
  62     } else
  63 #endif /* HWAES_CAPABLE */
  64
  65 #ifdef BSAES_CAPABLE
  66     if (BSAES_CAPABLE) {
  67         stream_enc = bsaes_xts_encrypt;
  68         stream_dec = bsaes_xts_decrypt;
  69     }
  70 #endif /* BSAES_CAPABLE */
  71
  72 #ifdef VPAES_CAPABLE
  73     if (VPAES_CAPABLE) {
  74         XTS_SET_KEY_FN(vpaes_set_encrypt_key, vpaes_set_decrypt_key,
  75                        vpaes_encrypt, vpaes_decrypt, stream_enc, stream_dec);
  76     } else
  77 #endif /* VPAES_CAPABLE */
  78     {
  79         XTS_SET_KEY_FN(AES_set_encrypt_key, AES_set_decrypt_key,
  80                        AES_encrypt, AES_decrypt, stream_enc, stream_dec);
  81     }
  82     return 1;
  83 }
  84
  85 static void cipher_hw_aes_xts_copyctx(PROV_CIPHER_CTX *dst,
  86                                       const PROV_CIPHER_CTX *src)
  87 {
  88     PROV_AES_XTS_CTX *sctx = (PROV_AES_XTS_CTX *)src;
  89     PROV_AES_XTS_CTX *dctx = (PROV_AES_XTS_CTX *)dst;
  90
  91     *dctx = *sctx;
  92     dctx->xts.key1 = &dctx->ks1.ks;
  93     dctx->xts.key2 = &dctx->ks2.ks;
  94 }
  95
  96 #if defined(AESNI_CAPABLE)
  97
  98 static int cipher_hw_aesni_xts_initkey(PROV_CIPHER_CTX *ctx,
  99                                        const unsigned char *key, size_t keylen)
 100 {
 101     PROV_AES_XTS_CTX *xctx = (PROV_AES_XTS_CTX *)ctx;
 102
 103     XTS_SET_KEY_FN(aesni_set_encrypt_key, aesni_set_decrypt_key,
 104                    aesni_encrypt, aesni_decrypt,
 105                    aesni_xts_encrypt, aesni_xts_decrypt);
 106     return 1;
 107 }
 108
 109 # define PROV_CIPHER_HW_declare_xts()                                          \
 110 static const PROV_CIPHER_HW aesni_xts = {                                      \
 111     cipher_hw_aesni_xts_initkey,                                               \
 112     NULL,                                                                      \
 113     cipher_hw_aes_xts_copyctx                                                  \
 114 };
 115 # define PROV_CIPHER_HW_select_xts()                                           \
 116 if (AESNI_CAPABLE)                                                             \
 117     return &aesni_xts;
 118
 119 # elif defined(SPARC_AES_CAPABLE)
 120
 121 static int cipher_hw_aes_xts_t4_initkey(PROV_CIPHER_CTX *ctx,
 122                                         const unsigned char *key, size_t keylen)
 123 {
 124     PROV_AES_XTS_CTX *xctx = (PROV_AES_XTS_CTX *)ctx;
 125     OSSL_xts_stream_fn stream_enc = NULL;
 126     OSSL_xts_stream_fn stream_dec = NULL;
 127
 128     /* Note: keylen is the size of 2 keys */
 129     switch (keylen) {
 130     case 32:
 131         stream_enc = aes128_t4_xts_encrypt;
 132         stream_dec = aes128_t4_xts_decrypt;
 133         break;
 134     case 64:
 135         stream_enc = aes256_t4_xts_encrypt;
 136         stream_dec = aes256_t4_xts_decrypt;
 137         break;
 138     default:
 139         return 0;
 140     }
 141
 142     XTS_SET_KEY_FN(aes_t4_set_encrypt_key, aes_t4_set_decrypt_key,
 143                    aes_t4_encrypt, aes_t4_decrypt,
 144                    stream_enc, stream_dec);
 145     return 1;
 146 }
 147
 148 # define PROV_CIPHER_HW_declare_xts()                                          \
 149 static const PROV_CIPHER_HW aes_xts_t4 = {                                     \
 150     cipher_hw_aes_xts_t4_initkey,                                              \
 151     NULL,                                                                      \
 152     cipher_hw_aes_xts_copyctx                                                  \
 153 };
 154 # define PROV_CIPHER_HW_select_xts()                                           \
 155 if (SPARC_AES_CAPABLE)                                                         \
 156     return &aes_xts_t4;
 157 # else
 158 /* The generic case */
 159 # define PROV_CIPHER_HW_declare_xts()
 160 # define PROV_CIPHER_HW_select_xts()
 161 #endif
 162
 163 static const PROV_CIPHER_HW aes_generic_xts = {
 164     cipher_hw_aes_xts_generic_initkey,
 165     NULL,
 166     cipher_hw_aes_xts_copyctx
 167 };
 168 PROV_CIPHER_HW_declare_xts()
 169 const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_xts(size_t keybits)
 170 {
 171     PROV_CIPHER_HW_select_xts()
 172     return &aes_generic_xts;
 173 }