providers/implementations/ciphers/cipher_aes_cbc_hmac_sha.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  * AES low level APIs are deprecated for public use, but still ok for internal
  12  * use where we're using them to implement the higher level EVP interface, as is
  13  * the case here.
  14  */
  15 #include "internal/deprecated.h"
  16
  17 /* Dispatch functions for AES_CBC_HMAC_SHA ciphers */
  18
  19 /* Only for SSL3_VERSION and TLS1_VERSION */
  20 #include <openssl/ssl.h>
  21 #include "cipher_aes_cbc_hmac_sha.h"
  22 #include "prov/implementations.h"
  23 #include "prov/providercommon.h"
  24
  25 #ifndef AES_CBC_HMAC_SHA_CAPABLE
  26 # define IMPLEMENT_CIPHER(nm, sub, kbits, blkbits, ivbits, flags)              \
  27 const OSSL_DISPATCH ossl_##nm##kbits##sub##_functions[] = {                    \
  28     { 0, NULL }                                                                \
  29 };
  30 #else
  31 # include "prov/providercommonerr.h"
  32
  33 /* TODO(3.0) Figure out what flags are required */
  34 # define AES_CBC_HMAC_SHA_FLAGS (EVP_CIPH_CBC_MODE                             \
  35                                  | EVP_CIPH_FLAG_DEFAULT_ASN1                  \
  36                                  | EVP_CIPH_FLAG_AEAD_CIPHER                   \
  37                                  | EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)
  38
  39 static OSSL_FUNC_cipher_freectx_fn aes_cbc_hmac_sha1_freectx;
  40 static OSSL_FUNC_cipher_freectx_fn aes_cbc_hmac_sha256_freectx;
  41 static OSSL_FUNC_cipher_get_ctx_params_fn aes_get_ctx_params;
  42 static OSSL_FUNC_cipher_gettable_ctx_params_fn aes_gettable_ctx_params;
  43 static OSSL_FUNC_cipher_set_ctx_params_fn aes_set_ctx_params;
  44 static OSSL_FUNC_cipher_settable_ctx_params_fn aes_settable_ctx_params;
  45 # define aes_gettable_params cipher_generic_gettable_params
  46 # define aes_einit cipher_generic_einit
  47 # define aes_dinit cipher_generic_dinit
  48 # define aes_update cipher_generic_stream_update
  49 # define aes_final cipher_generic_stream_final
  50 # define aes_cipher cipher_generic_cipher
  51
  52 static const OSSL_PARAM cipher_aes_known_settable_ctx_params[] = {
  53     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_MAC_KEY, NULL, 0),
  54     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
  55 # if !defined(OPENSSL_NO_MULTIBLOCK)
  56     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT, NULL),
  57     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD, NULL),
  58     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, NULL),
  59     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC, NULL, 0),
  60     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN, NULL, 0),
  61 # endif /* !defined(OPENSSL_NO_MULTIBLOCK) */
  62     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
  63     OSSL_PARAM_END
  64 };
  65 const OSSL_PARAM *aes_settable_ctx_params(ossl_unused void *provctx)
  66 {
  67     return cipher_aes_known_settable_ctx_params;
  68 }
  69
  70 static int aes_set_ctx_params(void *vctx, const OSSL_PARAM params[])
  71 {
  72     PROV_AES_HMAC_SHA_CTX *ctx = (PROV_AES_HMAC_SHA_CTX *)vctx;
  73     PROV_CIPHER_HW_AES_HMAC_SHA *hw =
  74        (PROV_CIPHER_HW_AES_HMAC_SHA *)ctx->hw;
  75     const OSSL_PARAM *p;
  76     int ret = 1;
  77 # if !defined(OPENSSL_NO_MULTIBLOCK)
  78     EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
  79 # endif
  80
  81     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_MAC_KEY);
  82     if (p != NULL) {
  83         if (p->data_type != OSSL_PARAM_OCTET_STRING) {
  84             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
  85             return 0;
  86         }
  87         hw->init_mac_key(ctx, p->data, p->data_size);
  88     }
  89
  90 # if !defined(OPENSSL_NO_MULTIBLOCK)
  91     p = OSSL_PARAM_locate_const(params,
  92             OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT);
  93     if (p != NULL
  94             && !OSSL_PARAM_get_size_t(p, &ctx->multiblock_max_send_fragment)) {
  95         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
  96         return 0;
  97     }
  98     /*
  99      * The inputs to tls1_multiblock_aad are:
 100      *   mb_param->inp
 101      *   mb_param->len
 102      *   mb_param->interleave
 103      * The outputs of tls1_multiblock_aad are written to:
 104      *   ctx->multiblock_interleave
 105      *   ctx->multiblock_aad_packlen
 106      */
 107     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD);
 108     if (p != NULL) {
 109         const OSSL_PARAM *p1 = OSSL_PARAM_locate_const(params,
 110                                    OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE);
 111         if (p->data_type != OSSL_PARAM_OCTET_STRING
 112             || p1 == NULL
 113             || !OSSL_PARAM_get_uint(p1, &mb_param.interleave)) {
 114             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 115             return 0;
 116         }
 117         mb_param.inp = p->data;
 118         mb_param.len = p->data_size;
 119         if (hw->tls1_multiblock_aad(vctx, &mb_param) <= 0)
 120             return 0;
 121     }
 122
 123     /*
 124      * The inputs to tls1_multiblock_encrypt are:
 125      *   mb_param->inp
 126      *   mb_param->len
 127      *   mb_param->interleave
 128      *   mb_param->out
 129      * The outputs of tls1_multiblock_encrypt are:
 130      *   ctx->multiblock_encrypt_len
 131      */
 132     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC);
 133     if (p != NULL) {
 134         const OSSL_PARAM *p1 = OSSL_PARAM_locate_const(params,
 135                                    OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE);
 136         const OSSL_PARAM *pin = OSSL_PARAM_locate_const(params,
 137                                     OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN);
 138
 139         if (p->data_type != OSSL_PARAM_OCTET_STRING
 140             || pin == NULL
 141             || pin->data_type != OSSL_PARAM_OCTET_STRING
 142             || p1 == NULL
 143             || !OSSL_PARAM_get_uint(p1, &mb_param.interleave)) {
 144             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 145             return 0;
 146         }
 147         mb_param.out = p->data;
 148         mb_param.inp = pin->data;
 149         mb_param.len = pin->data_size;
 150         if (hw->tls1_multiblock_encrypt(vctx, &mb_param) <= 0)
 151             return 0;
 152     }
 153 # endif /* !defined(OPENSSL_NO_MULTIBLOCK) */
 154
 155     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TLS1_AAD);
 156     if (p != NULL) {
 157         if (p->data_type != OSSL_PARAM_OCTET_STRING) {
 158             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 159             return 0;
 160         }
 161         if (hw->set_tls1_aad(ctx, p->data, p->data_size) <= 0)
 162             return 0;
 163     }
 164
 165     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN);
 166     if (p != NULL) {
 167         size_t keylen;
 168
 169         if (!OSSL_PARAM_get_size_t(p, &keylen)) {
 170             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 171             return 0;
 172         }
 173         if (ctx->base.keylen != keylen) {
 174             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
 175             return 0;
 176         }
 177     }
 178
 179     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_VERSION);
 180     if (p != NULL) {
 181         if (!OSSL_PARAM_get_uint(p, &ctx->base.tlsversion)) {
 182             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 183             return 0;
 184         }
 185         if (ctx->base.tlsversion == SSL3_VERSION
 186                 || ctx->base.tlsversion == TLS1_VERSION) {
 187             if (!ossl_assert(ctx->base.removetlspad >= AES_BLOCK_SIZE)) {
 188                 ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR);
 189                 return 0;
 190             }
 191             /*
 192              * There is no explicit IV with these TLS versions, so don't attempt
 193              * to remove it.
 194              */
 195             ctx->base.removetlspad -= AES_BLOCK_SIZE;
 196         }
 197     }
 198     return ret;
 199 }
 200
 201 static int aes_get_ctx_params(void *vctx, OSSL_PARAM params[])
 202 {
 203     PROV_AES_HMAC_SHA_CTX *ctx = (PROV_AES_HMAC_SHA_CTX *)vctx;
 204     OSSL_PARAM *p;
 205
 206 # if !defined(OPENSSL_NO_MULTIBLOCK)
 207     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE);
 208     if (p != NULL) {
 209         PROV_CIPHER_HW_AES_HMAC_SHA *hw =
 210            (PROV_CIPHER_HW_AES_HMAC_SHA *)ctx->hw;
 211         size_t len = hw->tls1_multiblock_max_bufsize(ctx);
 212
 213         if (!OSSL_PARAM_set_size_t(p, len)) {
 214             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 215             return 0;
 216         }
 217     }
 218
 219     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE);
 220     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->multiblock_interleave)) {
 221         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 222         return 0;
 223     }
 224
 225     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN);
 226     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->multiblock_aad_packlen)) {
 227         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 228         return 0;
 229     }
 230
 231     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN);
 232     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->multiblock_encrypt_len)) {
 233         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 234         return 0;
 235     }
 236 # endif /* !defined(OPENSSL_NO_MULTIBLOCK) */
 237
 238     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD);
 239     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->tls_aad_pad)) {
 240         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 241         return 0;
 242     }
 243     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
 244     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->base.keylen)) {
 245         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 246         return 0;
 247     }
 248     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
 249     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->base.ivlen)) {
 250         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 251         return 0;
 252     }
 253     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV);
 254     if (p != NULL
 255         && !OSSL_PARAM_set_octet_string(p, ctx->base.oiv, ctx->base.ivlen)
 256         && !OSSL_PARAM_set_octet_ptr(p, &ctx->base.oiv, ctx->base.ivlen)) {
 257         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 258         return 0;
 259     }
 260     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV_STATE);
 261     if (p != NULL
 262         && !OSSL_PARAM_set_octet_string(p, ctx->base.iv, ctx->base.ivlen)) {
 263         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 264         return 0;
 265     }
 266     return 1;
 267 }
 268
 269 static const OSSL_PARAM cipher_aes_known_gettable_ctx_params[] = {
 270 # if !defined(OPENSSL_NO_MULTIBLOCK)
 271     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE, NULL),
 272     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, NULL),
 273     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN, NULL),
 274     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN, NULL),
 275 # endif /* !defined(OPENSSL_NO_MULTIBLOCK) */
 276     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
 277     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
 278     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
 279     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
 280     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV_STATE, NULL, 0),
 281     OSSL_PARAM_END
 282 };
 283 const OSSL_PARAM *aes_gettable_ctx_params(ossl_unused void *provctx)
 284 {
 285     return cipher_aes_known_gettable_ctx_params;
 286 }
 287
 288 static void base_init(void *provctx, PROV_AES_HMAC_SHA_CTX *ctx,
 289                       const PROV_CIPHER_HW_AES_HMAC_SHA *meths,
 290                       size_t kbits, size_t blkbits, size_t ivbits,
 291                       uint64_t flags)
 292 {
 293     cipher_generic_initkey(&ctx->base, kbits, blkbits, ivbits,
 294                            EVP_CIPH_CBC_MODE, flags,
 295                            &meths->base, provctx);
 296     ctx->hw = (PROV_CIPHER_HW_AES_HMAC_SHA *)ctx->base.hw;
 297 }
 298
 299 static void *aes_cbc_hmac_sha1_newctx(void *provctx, size_t kbits,
 300                                       size_t blkbits, size_t ivbits,
 301                                       uint64_t flags)
 302 {
 303     PROV_AES_HMAC_SHA1_CTX *ctx;
 304
 305     if (!ossl_prov_is_running())
 306         return NULL;
 307
 308     ctx = OPENSSL_zalloc(sizeof(*ctx));
 309     if (ctx != NULL)
 310         base_init(provctx, &ctx->base_ctx,
 311                   ossl_prov_cipher_hw_aes_cbc_hmac_sha1(), kbits, blkbits,
 312                   ivbits, flags);
 313     return ctx;
 314 }
 315
 316 static void aes_cbc_hmac_sha1_freectx(void *vctx)
 317 {
 318     PROV_AES_HMAC_SHA1_CTX *ctx = (PROV_AES_HMAC_SHA1_CTX *)vctx;
 319
 320     if (ctx != NULL) {
 321         cipher_generic_reset_ctx((PROV_CIPHER_CTX *)vctx);
 322         OPENSSL_clear_free(ctx, sizeof(*ctx));
 323     }
 324 }
 325
 326 static void *aes_cbc_hmac_sha256_newctx(void *provctx, size_t kbits,
 327                                         size_t blkbits, size_t ivbits,
 328                                         uint64_t flags)
 329 {
 330     PROV_AES_HMAC_SHA256_CTX *ctx;
 331
 332     if (!ossl_prov_is_running())
 333         return NULL;
 334
 335     ctx = OPENSSL_zalloc(sizeof(*ctx));
 336     if (ctx != NULL)
 337         base_init(provctx, &ctx->base_ctx,
 338                   ossl_prov_cipher_hw_aes_cbc_hmac_sha256(), kbits, blkbits,
 339                   ivbits, flags);
 340     return ctx;
 341 }
 342
 343 static void aes_cbc_hmac_sha256_freectx(void *vctx)
 344 {
 345     PROV_AES_HMAC_SHA256_CTX *ctx = (PROV_AES_HMAC_SHA256_CTX *)vctx;
 346
 347     if (ctx != NULL) {
 348         cipher_generic_reset_ctx((PROV_CIPHER_CTX *)vctx);
 349         OPENSSL_clear_free(ctx, sizeof(*ctx));
 350     }
 351 }
 352
 353 # define IMPLEMENT_CIPHER(nm, sub, kbits, blkbits, ivbits, flags)              \
 354 static OSSL_FUNC_cipher_newctx_fn nm##_##kbits##_##sub##_newctx;               \
 355 static void *nm##_##kbits##_##sub##_newctx(void *provctx)                      \
 356 {                                                                              \
 357     return nm##_##sub##_newctx(provctx, kbits, blkbits, ivbits, flags);        \
 358 }                                                                              \
 359 static OSSL_FUNC_cipher_get_params_fn nm##_##kbits##_##sub##_get_params;       \
 360 static int nm##_##kbits##_##sub##_get_params(OSSL_PARAM params[])              \
 361 {                                                                              \
 362     return cipher_generic_get_params(params, EVP_CIPH_CBC_MODE,                \
 363                                      flags, kbits, blkbits, ivbits);           \
 364 }                                                                              \
 365 const OSSL_DISPATCH ossl_##nm##kbits##sub##_functions[] = {                    \
 366     { OSSL_FUNC_CIPHER_NEWCTX, (void (*)(void))nm##_##kbits##_##sub##_newctx },\
 367     { OSSL_FUNC_CIPHER_FREECTX, (void (*)(void))nm##_##sub##_freectx },        \
 368     { OSSL_FUNC_CIPHER_ENCRYPT_INIT, (void (*)(void))nm##_einit },             \
 369     { OSSL_FUNC_CIPHER_DECRYPT_INIT, (void (*)(void))nm##_dinit },             \
 370     { OSSL_FUNC_CIPHER_UPDATE, (void (*)(void))nm##_update },                  \
 371     { OSSL_FUNC_CIPHER_FINAL, (void (*)(void))nm##_final },                    \
 372     { OSSL_FUNC_CIPHER_CIPHER, (void (*)(void))nm##_cipher },                  \
 373     { OSSL_FUNC_CIPHER_GET_PARAMS,                                             \
 374         (void (*)(void))nm##_##kbits##_##sub##_get_params },                   \
 375     { OSSL_FUNC_CIPHER_GETTABLE_PARAMS,                                        \
 376         (void (*)(void))nm##_gettable_params },                                \
 377     { OSSL_FUNC_CIPHER_GET_CTX_PARAMS,                                         \
 378          (void (*)(void))nm##_get_ctx_params },                                \
 379     { OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS,                                    \
 380         (void (*)(void))nm##_gettable_ctx_params },                            \
 381     { OSSL_FUNC_CIPHER_SET_CTX_PARAMS,                                         \
 382         (void (*)(void))nm##_set_ctx_params },                                 \
 383     { OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS,                                    \
 384         (void (*)(void))nm##_settable_ctx_params },                            \
 385     { 0, NULL }                                                                \
 386 };
 387
 388 #endif /* AES_CBC_HMAC_SHA_CAPABLE */
 389
 390 /* ossl_aes128cbc_hmac_sha1_functions */
 391 IMPLEMENT_CIPHER(aes, cbc_hmac_sha1, 128, 128, 128, AES_CBC_HMAC_SHA_FLAGS)
 392 /* ossl_aes256cbc_hmac_sha1_functions */
 393 IMPLEMENT_CIPHER(aes, cbc_hmac_sha1, 256, 128, 128, AES_CBC_HMAC_SHA_FLAGS)
 394 /* ossl_aes128cbc_hmac_sha256_functions */
 395 IMPLEMENT_CIPHER(aes, cbc_hmac_sha256, 128, 128, 128, AES_CBC_HMAC_SHA_FLAGS)
 396 /* ossl_aes256cbc_hmac_sha256_functions */
 397 IMPLEMENT_CIPHER(aes, cbc_hmac_sha256, 256, 128, 128, AES_CBC_HMAC_SHA_FLAGS)