providers/common/ciphers/gcm_hw.c

   1 /*
   2  * Copyright 2001-2019 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 #include "ciphers_locl.h"
  11 #include "internal/aes_platform.h"
  12
  13 static const PROV_GCM_HW aes_gcm;
  14
  15 static int gcm_setiv(PROV_GCM_CTX *ctx, const unsigned char *iv, size_t ivlen);
  16 static int gcm_aad_update(PROV_GCM_CTX *ctx, const unsigned char *aad,
  17                           size_t aad_len);
  18 static int gcm_cipher_final(PROV_GCM_CTX *ctx, unsigned char *tag);
  19 static int gcm_one_shot(PROV_GCM_CTX *ctx, unsigned char *aad, size_t aad_len,
  20                         const unsigned char *in, size_t in_len,
  21                         unsigned char *out, unsigned char *tag, size_t tag_len);
  22 static int gcm_cipher_update(PROV_GCM_CTX *ctx, const unsigned char *in,
  23                              size_t len, unsigned char *out);
  24
  25 #define SET_KEY_CTR_FN(ks, fn_set_enc_key, fn_block, fn_ctr)                   \
  26     ctx->ks = ks;                                                              \
  27     fn_set_enc_key(key, keylen * 8, ks);                                       \
  28     CRYPTO_gcm128_init(&ctx->gcm, ks, (block128_f)fn_block);                   \
  29     ctx->ctr = (ctr128_f)fn_ctr;                                               \
  30     ctx->key_set = 1;
  31
  32 #if defined(AESNI_CAPABLE)
  33
  34 /* AES-NI section */
  35 static int aesni_gcm_init_key(PROV_GCM_CTX *ctx, const unsigned char *key,
  36                               size_t keylen)
  37 {
  38     PROV_AES_GCM_CTX *actx = (PROV_AES_GCM_CTX *)ctx;
  39     AES_KEY *ks = &actx->ks.ks;
  40
  41     SET_KEY_CTR_FN(ks, aesni_set_encrypt_key, aesni_encrypt,
  42                    aesni_ctr32_encrypt_blocks);
  43     return 1;
  44 }
  45
  46 static const PROV_GCM_HW aesni_gcm = {
  47     aesni_gcm_init_key,
  48     gcm_setiv,
  49     gcm_aad_update,
  50     gcm_cipher_update,
  51     gcm_cipher_final,
  52     gcm_one_shot
  53 };
  54
  55 const PROV_GCM_HW *PROV_AES_HW_gcm(size_t keybits)
  56 {
  57     return AESNI_CAPABLE ? &aesni_gcm : &aes_gcm;
  58 }
  59
  60 #elif defined(AES_ASM) && (defined(__sparc) || defined(__sparc__))
  61
  62 /* Fujitsu SPARC64 X support */
  63
  64 static int t4_aes_gcm_init_key(PROV_GCM_CTX *ctx, const unsigned char *key,
  65                                size_t keylen)
  66 {
  67     ctr128_f ctr;
  68     PROV_AES_GCM_CTX *actx = (PROV_AES_GCM_CTX *)ctx;
  69     AES_KEY *ks = &actx->ks.ks;
  70
  71
  72     switch (keylen) {
  73     case 16:
  74         ctr = (ctr128_f)aes128_t4_ctr32_encrypt;
  75         break;
  76     case 24:
  77         ctr = (ctr128_f)aes192_t4_ctr32_encrypt;
  78         break;
  79     case 32:
  80         ctr = (ctr128_f)aes256_t4_ctr32_encrypt;
  81         break;
  82     default:
  83         return 0;
  84     }
  85
  86     SET_KEY_CTR_FN(ks, aes_t4_set_encrypt_key, aes_t4_encrypt, ctr);
  87     return 1;
  88 }
  89
  90 static const PROV_GCM_HW t4_aes_gcm = {
  91     t4_aes_gcm_init_key,
  92     gcm_setiv,
  93     gcm_aad_update,
  94     gcm_cipher_update,
  95     gcm_cipher_final,
  96     gcm_one_shot
  97 };
  98 const PROV_GCM_HW *PROV_AES_HW_gcm(size_t keybits)
  99 {
 100     return SPARC_AES_CAPABLE ? &t4_aes_gcm : &aes_gcm;
 101 }
 102
 103 #elif defined(OPENSSL_CPUID_OBJ) && defined(__s390__)
 104 # include "gcm_s390x.c"
 105 #else
 106 const PROV_GCM_HW *PROV_AES_HW_gcm(size_t keybits)
 107 {
 108     return &aes_gcm;
 109 }
 110 #endif
 111
 112 static int generic_aes_gcm_init_key(PROV_GCM_CTX *ctx, const unsigned char *key,
 113                                     size_t keylen)
 114 {
 115     PROV_AES_GCM_CTX *actx = (PROV_AES_GCM_CTX *)ctx;
 116     AES_KEY *ks = &actx->ks.ks;
 117
 118 # ifdef HWAES_CAPABLE
 119     if (HWAES_CAPABLE) {
 120 #  ifdef HWAES_ctr32_encrypt_blocks
 121         SET_KEY_CTR_FN(ks, HWAES_set_encrypt_key, HWAES_encrypt,
 122                        HWAES_ctr32_encrypt_blocks);
 123 #  else
 124         SET_KEY_CTR_FN(ks, HWAES_set_encrypt_key, HWAES_encrypt, NULL);
 125 #  endif /* HWAES_ctr32_encrypt_blocks */
 126     } else
 127 # endif /* HWAES_CAPABLE */
 128
 129 # ifdef BSAES_CAPABLE
 130     if (BSAES_CAPABLE) {
 131         SET_KEY_CTR_FN(ks, AES_set_encrypt_key, AES_encrypt,
 132                        bsaes_ctr32_encrypt_blocks);
 133     } else
 134 # endif /* BSAES_CAPABLE */
 135
 136 # ifdef VPAES_CAPABLE
 137     if (VPAES_CAPABLE) {
 138         SET_KEY_CTR_FN(ks, vpaes_set_encrypt_key, vpaes_encrypt, NULL);
 139     } else
 140 # endif /* VPAES_CAPABLE */
 141
 142     {
 143 # ifdef AES_CTR_ASM
 144         SET_KEY_CTR_FN(ks, AES_set_encrypt_key, AES_encrypt, AES_ctr32_encrypt);
 145 # else
 146         SET_KEY_CTR_FN(ks, AES_set_encrypt_key, AES_encrypt, NULL);
 147 # endif /* AES_CTR_ASM */
 148     }
 149     ctx->key_set = 1;
 150     return 1;
 151 }
 152
 153 static int gcm_setiv(PROV_GCM_CTX *ctx, const unsigned char *iv, size_t ivlen)
 154 {
 155     CRYPTO_gcm128_setiv(&ctx->gcm, iv, ivlen);
 156     return 1;
 157 }
 158
 159 static int gcm_aad_update(PROV_GCM_CTX *ctx,
 160                           const unsigned char *aad, size_t aad_len)
 161 {
 162     return CRYPTO_gcm128_aad(&ctx->gcm, aad, aad_len) == 0;
 163 }
 164
 165 static int gcm_cipher_update(PROV_GCM_CTX *ctx, const unsigned char *in,
 166                              size_t len, unsigned char *out)
 167 {
 168     if (ctx->enc) {
 169         if (ctx->ctr != NULL) {
 170 #if defined(AES_GCM_ASM)
 171             size_t bulk = 0;
 172
 173             if (len >= 32 && AES_GCM_ASM(ctx)) {
 174                 size_t res = (16 - ctx->gcm.mres) % 16;
 175
 176                 if (CRYPTO_gcm128_encrypt(&ctx->gcm, in, out, res))
 177                     return 0;
 178                 bulk = aesni_gcm_encrypt(in + res, out + res, len - res,
 179                                          ctx->gcm.key,
 180                                          ctx->gcm.Yi.c, ctx->gcm.Xi.u);
 181                 ctx->gcm.len.u[1] += bulk;
 182                 bulk += res;
 183             }
 184             if (CRYPTO_gcm128_encrypt_ctr32(&ctx->gcm, in + bulk, out + bulk,
 185                                             len - bulk, ctx->ctr))
 186                 return 0;
 187 #else
 188             if (CRYPTO_gcm128_encrypt_ctr32(&ctx->gcm, in, out, len, ctx->ctr))
 189                 return 0;
 190 #endif /* AES_GCM_ASM */
 191         } else {
 192             if (CRYPTO_gcm128_encrypt(&ctx->gcm, in, out, len))
 193                 return 0;
 194         }
 195     } else {
 196         if (ctx->ctr != NULL) {
 197 #if defined(AES_GCM_ASM)
 198             size_t bulk = 0;
 199
 200             if (len >= 16 && AES_GCM_ASM(ctx)) {
 201                 size_t res = (16 - ctx->gcm.mres) % 16;
 202
 203                 if (CRYPTO_gcm128_decrypt(&ctx->gcm, in, out, res))
 204                     return -1;
 205
 206                 bulk = aesni_gcm_decrypt(in + res, out + res, len - res,
 207                                          ctx->gcm.key,
 208                                          ctx->gcm.Yi.c, ctx->gcm.Xi.u);
 209                 ctx->gcm.len.u[1] += bulk;
 210                 bulk += res;
 211             }
 212             if (CRYPTO_gcm128_decrypt_ctr32(&ctx->gcm, in + bulk, out + bulk,
 213                                             len - bulk, ctx->ctr))
 214                 return 0;
 215 #else
 216             if (CRYPTO_gcm128_decrypt_ctr32(&ctx->gcm, in, out, len, ctx->ctr))
 217                 return 0;
 218 #endif /* AES_GCM_ASM */
 219         } else {
 220             if (CRYPTO_gcm128_decrypt(&ctx->gcm, in, out, len))
 221                 return 0;
 222         }
 223     }
 224     return 1;
 225 }
 226
 227 static int gcm_cipher_final(PROV_GCM_CTX *ctx, unsigned char *tag)
 228 {
 229     if (ctx->enc) {
 230         CRYPTO_gcm128_tag(&ctx->gcm, tag, GCM_TAG_MAX_SIZE);
 231         ctx->taglen = GCM_TAG_MAX_SIZE;
 232     } else {
 233         if (ctx->taglen < 0
 234             || CRYPTO_gcm128_finish(&ctx->gcm, tag, ctx->taglen) != 0)
 235             return 0;
 236     }
 237     return 1;
 238 }
 239
 240 static int gcm_one_shot(PROV_GCM_CTX *ctx, unsigned char *aad, size_t aad_len,
 241                         const unsigned char *in, size_t in_len,
 242                         unsigned char *out, unsigned char *tag, size_t tag_len)
 243 {
 244     int ret = 0;
 245
 246     /* Use saved AAD */
 247     if (!ctx->hw->aadupdate(ctx, aad, aad_len))
 248         goto err;
 249     if (!ctx->hw->cipherupdate(ctx, in, in_len, out))
 250         goto err;
 251     ctx->taglen = GCM_TAG_MAX_SIZE;
 252     if (!ctx->hw->cipherfinal(ctx, tag))
 253         goto err;
 254     ret = 1;
 255
 256 err:
 257     return ret;
 258 }
 259
 260 static const PROV_GCM_HW aes_gcm = {
 261     generic_aes_gcm_init_key,
 262     gcm_setiv,
 263     gcm_aad_update,
 264     gcm_cipher_update,
 265     gcm_cipher_final,
 266     gcm_one_shot
 267 };
 268
 269 #if !defined(OPENSSL_NO_ARIA) && !defined(FIPS_MODE)
 270
 271 static int aria_gcm_init_key(PROV_GCM_CTX *ctx, const unsigned char *key,
 272                              size_t keylen)
 273 {
 274     PROV_ARIA_GCM_CTX *actx = (PROV_ARIA_GCM_CTX *)ctx;
 275     ARIA_KEY *ks = &actx->ks.ks;
 276
 277     SET_KEY_CTR_FN(ks, aria_set_encrypt_key, aria_encrypt, NULL);
 278     return 1;
 279 }
 280
 281 static int aria_cipher_update(PROV_GCM_CTX *ctx, const unsigned char *in,
 282                               size_t len, unsigned char *out)
 283 {
 284     if (ctx->enc) {
 285         if (CRYPTO_gcm128_encrypt(&ctx->gcm, in, out, len))
 286             return 0;
 287     } else {
 288         if (CRYPTO_gcm128_decrypt(&ctx->gcm, in, out, len))
 289             return 0;
 290     }
 291     return 1;
 292 }
 293
 294 static const PROV_GCM_HW aria_gcm = {
 295     aria_gcm_init_key,
 296     gcm_setiv,
 297     gcm_aad_update,
 298     aria_cipher_update,
 299     gcm_cipher_final,
 300     gcm_one_shot
 301 };
 302 const PROV_GCM_HW *PROV_ARIA_HW_gcm(size_t keybits)
 303 {
 304     return &aria_gcm;
 305 }
 306
 307 #endif /* !defined(OPENSSL_NO_ARIA) && !defined(FIPS_MODE) */