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     } else
  70 #endif /* BSAES_CAPABLE */
  71 #ifdef VPAES_CAPABLE
  72     if (VPAES_CAPABLE) {
  73         XTS_SET_KEY_FN(vpaes_set_encrypt_key, vpaes_set_decrypt_key,
  74                        vpaes_encrypt, vpaes_decrypt, stream_enc, stream_dec);
  75         return 1;
  76     } else
  77 #endif /* VPAES_CAPABLE */
  78     {
  79         (void)0;
  80     }
  81     {
  82         XTS_SET_KEY_FN(AES_set_encrypt_key, AES_set_decrypt_key,
  83                        AES_encrypt, AES_decrypt, stream_enc, stream_dec);
  84     }
  85     return 1;
  86 }
  87
  88 static void cipher_hw_aes_xts_copyctx(PROV_CIPHER_CTX *dst,
  89                                       const PROV_CIPHER_CTX *src)
  90 {
  91     PROV_AES_XTS_CTX *sctx = (PROV_AES_XTS_CTX *)src;
  92     PROV_AES_XTS_CTX *dctx = (PROV_AES_XTS_CTX *)dst;
  93
  94     *dctx = *sctx;
  95     dctx->xts.key1 = &dctx->ks1.ks;
  96     dctx->xts.key2 = &dctx->ks2.ks;
  97 }
  98
  99 #if defined(AESNI_CAPABLE)
 100
 101 static int cipher_hw_aesni_xts_initkey(PROV_CIPHER_CTX *ctx,
 102                                        const unsigned char *key, size_t keylen)
 103 {
 104     PROV_AES_XTS_CTX *xctx = (PROV_AES_XTS_CTX *)ctx;
 105
 106     XTS_SET_KEY_FN(aesni_set_encrypt_key, aesni_set_decrypt_key,
 107                    aesni_encrypt, aesni_decrypt,
 108                    aesni_xts_encrypt, aesni_xts_decrypt);
 109     return 1;
 110 }
 111
 112 # define PROV_CIPHER_HW_declare_xts()                                          \
 113 static const PROV_CIPHER_HW aesni_xts = {                                      \
 114     cipher_hw_aesni_xts_initkey,                                               \
 115     NULL,                                                                      \
 116     cipher_hw_aes_xts_copyctx                                                  \
 117 };
 118 # define PROV_CIPHER_HW_select_xts()                                           \
 119 if (AESNI_CAPABLE)                                                             \
 120     return &aesni_xts;
 121
 122 # elif defined(SPARC_AES_CAPABLE)
 123
 124 static int cipher_hw_aes_xts_t4_initkey(PROV_CIPHER_CTX *ctx,
 125                                         const unsigned char *key, size_t keylen)
 126 {
 127     PROV_AES_XTS_CTX *xctx = (PROV_AES_XTS_CTX *)ctx;
 128     OSSL_xts_stream_fn stream_enc = NULL;
 129     OSSL_xts_stream_fn stream_dec = NULL;
 130
 131     /* Note: keylen is the size of 2 keys */
 132     switch (keylen) {
 133     case 32:
 134         stream_enc = aes128_t4_xts_encrypt;
 135         stream_dec = aes128_t4_xts_decrypt;
 136         break;
 137     case 64:
 138         stream_enc = aes256_t4_xts_encrypt;
 139         stream_dec = aes256_t4_xts_decrypt;
 140         break;
 141     default:
 142         return 0;
 143     }
 144
 145     XTS_SET_KEY_FN(aes_t4_set_encrypt_key, aes_t4_set_decrypt_key,
 146                    aes_t4_encrypt, aes_t4_decrypt,
 147                    stream_enc, stream_dec);
 148     return 1;
 149 }
 150
 151 # define PROV_CIPHER_HW_declare_xts()                                          \
 152 static const PROV_CIPHER_HW aes_xts_t4 = {                                     \
 153     cipher_hw_aes_xts_t4_initkey,                                              \
 154     NULL,                                                                      \
 155     cipher_hw_aes_xts_copyctx                                                  \
 156 };
 157 # define PROV_CIPHER_HW_select_xts()                                           \
 158 if (SPARC_AES_CAPABLE)                                                         \
 159     return &aes_xts_t4;
 160 # else
 161 /* The generic case */
 162 # define PROV_CIPHER_HW_declare_xts()
 163 # define PROV_CIPHER_HW_select_xts()
 164 #endif
 165
 166 static const PROV_CIPHER_HW aes_generic_xts = {
 167     cipher_hw_aes_xts_generic_initkey,
 168     NULL,
 169     cipher_hw_aes_xts_copyctx
 170 };
 171 PROV_CIPHER_HW_declare_xts()
 172 const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_xts(size_t keybits)
 173 {
 174     PROV_CIPHER_HW_select_xts()
 175     return &aes_generic_xts;
 176 }