providers/common/ciphers/cipher_common.c

   1 /*
   2  * Copyright 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 /*
  11  * Generic dispatch table functions for ciphers.
  12  */
  13
  14 #include "cipher_local.h"
  15 #include "internal/provider_ctx.h"
  16 #include "internal/providercommonerr.h"
  17
  18 /*-
  19  * Generic cipher functions for OSSL_PARAM gettables and settables
  20  */
  21 static const OSSL_PARAM cipher_known_gettable_params[] = {
  22     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_MODE, NULL),
  23     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
  24     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
  25     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_BLOCK_SIZE, NULL),
  26     OSSL_PARAM_ulong(OSSL_CIPHER_PARAM_FLAGS, NULL),
  27     OSSL_PARAM_END
  28 };
  29 const OSSL_PARAM *cipher_generic_gettable_params(void)
  30 {
  31     return cipher_known_gettable_params;
  32 }
  33
  34 int cipher_generic_get_params(OSSL_PARAM params[], unsigned int md,
  35                               unsigned long flags,
  36                               size_t kbits, size_t blkbits, size_t ivbits)
  37 {
  38     OSSL_PARAM *p;
  39
  40     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_MODE);
  41     if (p != NULL && !OSSL_PARAM_set_uint(p, md)) {
  42         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  43         return 0;
  44     }
  45     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_FLAGS);
  46     if (p != NULL && !OSSL_PARAM_set_ulong(p, flags)) {
  47         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  48         return 0;
  49     }
  50     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
  51     if (p != NULL && !OSSL_PARAM_set_size_t(p, kbits / 8)) {
  52         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  53         return 0;
  54     }
  55     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_BLOCK_SIZE);
  56     if (p != NULL && !OSSL_PARAM_set_size_t(p, blkbits / 8)) {
  57         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  58         return 0;
  59     }
  60     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
  61     if (p != NULL && !OSSL_PARAM_set_size_t(p, ivbits / 8)) {
  62         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
  63         return 0;
  64     }
  65     return 1;
  66 }
  67
  68 CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_START(cipher_generic)
  69 CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_END(cipher_generic)
  70
  71 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(cipher_generic)
  72 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(cipher_generic)
  73
  74 /*-
  75  * AEAD cipher functions for OSSL_PARAM gettables and settables
  76  */
  77 static const OSSL_PARAM cipher_aead_known_gettable_ctx_params[] = {
  78     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
  79     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
  80     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
  81     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
  82     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
  83     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
  84     OSSL_PARAM_END
  85 };
  86 const OSSL_PARAM *cipher_aead_gettable_ctx_params(void)
  87 {
  88     return cipher_aead_known_gettable_ctx_params;
  89 }
  90
  91 static const OSSL_PARAM cipher_aead_known_settable_ctx_params[] = {
  92     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
  93     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
  94     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
  95     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
  96     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, NULL, 0),
  97     OSSL_PARAM_END
  98 };
  99 const OSSL_PARAM *cipher_aead_settable_ctx_params(void)
 100 {
 101     return cipher_aead_known_settable_ctx_params;
 102 }
 103
 104 static int cipher_generic_init_internal(PROV_CIPHER_CTX *ctx,
 105                                         const unsigned char *key, size_t keylen,
 106                                         const unsigned char *iv, size_t ivlen,
 107                                         int enc)
 108 {
 109     ctx->enc = enc ? 1 : 0;
 110
 111     if (iv != NULL && ctx->mode != EVP_CIPH_ECB_MODE) {
 112         if (ivlen != ctx->ivlen) {
 113             ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR);
 114             return 0;
 115         }
 116         memcpy(ctx->iv, iv, ctx->ivlen);
 117     }
 118     if (key != NULL) {
 119         if ((ctx->flags & EVP_CIPH_VARIABLE_LENGTH) == 0) {
 120             if (keylen != ctx->keylen) {
 121                 ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEYLEN);
 122                 return 0;
 123             }
 124         } else {
 125             ctx->keylen = keylen;
 126         }
 127         return ctx->hw->init(ctx, key, ctx->keylen);
 128     }
 129     return 1;
 130 }
 131
 132 int cipher_generic_einit(void *vctx, const unsigned char *key, size_t keylen,
 133                          const unsigned char *iv, size_t ivlen)
 134 {
 135     return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
 136                                         iv, ivlen, 1);
 137 }
 138
 139 int cipher_generic_dinit(void *vctx, const unsigned char *key, size_t keylen,
 140                          const unsigned char *iv, size_t ivlen)
 141 {
 142     return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
 143                                         iv, ivlen, 0);
 144 }
 145
 146 int cipher_generic_block_update(void *vctx, unsigned char *out, size_t *outl,
 147                                 size_t outsize, const unsigned char *in,
 148                                 size_t inl)
 149 {
 150     size_t outlint = 0;
 151     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 152     size_t blksz = ctx->blocksize;
 153     size_t nextblocks = fillblock(ctx->buf, &ctx->bufsz, blksz, &in, &inl);
 154
 155     /*
 156      * If we're decrypting and we end an update on a block boundary we hold
 157      * the last block back in case this is the last update call and the last
 158      * block is padded.
 159      */
 160     if (ctx->bufsz == blksz && (ctx->enc || inl > 0 || !ctx->pad)) {
 161         if (outsize < blksz) {
 162             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 163             return 0;
 164         }
 165         if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
 166             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 167             return 0;
 168         }
 169         ctx->bufsz = 0;
 170         outlint = blksz;
 171         out += blksz;
 172     }
 173     if (nextblocks > 0) {
 174         if (!ctx->enc && ctx->pad && nextblocks == inl) {
 175             if (!ossl_assert(inl >= blksz)) {
 176                 ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 177                 return 0;
 178             }
 179             nextblocks -= blksz;
 180         }
 181         outlint += nextblocks;
 182         if (outsize < outlint) {
 183             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 184             return 0;
 185         }
 186         if (!ctx->hw->cipher(ctx, out, in, nextblocks)) {
 187             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 188             return 0;
 189         }
 190         in += nextblocks;
 191         inl -= nextblocks;
 192     }
 193     if (!trailingdata(ctx->buf, &ctx->bufsz, blksz, &in, &inl)) {
 194         /* ERR_raise already called */
 195         return 0;
 196     }
 197
 198     *outl = outlint;
 199     return inl == 0;
 200 }
 201
 202 int cipher_generic_block_final(void *vctx, unsigned char *out, size_t *outl,
 203                                size_t outsize)
 204 {
 205     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 206     size_t blksz = ctx->blocksize;
 207
 208     if (ctx->enc) {
 209         if (ctx->pad) {
 210             padblock(ctx->buf, &ctx->bufsz, blksz);
 211         } else if (ctx->bufsz == 0) {
 212             *outl = 0;
 213             return 1;
 214         } else if (ctx->bufsz != blksz) {
 215             ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
 216             return 0;
 217         }
 218
 219         if (outsize < blksz) {
 220             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 221             return 0;
 222         }
 223         if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
 224             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 225             return 0;
 226         }
 227         ctx->bufsz = 0;
 228         *outl = blksz;
 229         return 1;
 230     }
 231
 232     /* Decrypting */
 233     if (ctx->bufsz != blksz) {
 234         if (ctx->bufsz == 0 && !ctx->pad) {
 235             *outl = 0;
 236             return 1;
 237         }
 238         ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
 239         return 0;
 240     }
 241
 242     if (!ctx->hw->cipher(ctx, ctx->buf, ctx->buf, blksz)) {
 243         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 244         return 0;
 245     }
 246
 247     if (ctx->pad && !unpadblock(ctx->buf, &ctx->bufsz, blksz)) {
 248         /* ERR_raise already called */
 249         return 0;
 250     }
 251
 252     if (outsize < ctx->bufsz) {
 253         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 254         return 0;
 255     }
 256     memcpy(out, ctx->buf, ctx->bufsz);
 257     *outl = ctx->bufsz;
 258     ctx->bufsz = 0;
 259     return 1;
 260 }
 261
 262 int cipher_generic_stream_update(void *vctx, unsigned char *out, size_t *outl,
 263                                  size_t outsize, const unsigned char *in,
 264                                  size_t inl)
 265 {
 266     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 267
 268     if (outsize < inl) {
 269         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 270         return 0;
 271     }
 272
 273     if (!ctx->hw->cipher(ctx, out, in, inl)) {
 274         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 275         return 0;
 276     }
 277
 278     *outl = inl;
 279     return 1;
 280 }
 281 int cipher_generic_stream_final(void *vctx, unsigned char *out, size_t *outl,
 282                                 size_t outsize)
 283 {
 284     *outl = 0;
 285     return 1;
 286 }
 287
 288 int cipher_generic_cipher(void *vctx,
 289                           unsigned char *out, size_t *outl, size_t outsize,
 290                           const unsigned char *in, size_t inl)
 291 {
 292     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 293
 294     if (outsize < inl) {
 295         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 296         return 0;
 297     }
 298
 299     if (!ctx->hw->cipher(ctx, out, in, inl)) {
 300         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 301         return 0;
 302     }
 303
 304     *outl = inl;
 305     return 1;
 306 }
 307
 308 int cipher_generic_get_ctx_params(void *vctx, OSSL_PARAM params[])
 309 {
 310     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 311     OSSL_PARAM *p;
 312
 313     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
 314     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->ivlen)) {
 315         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 316         return 0;
 317     }
 318     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_PADDING);
 319     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->pad)) {
 320         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 321         return 0;
 322     }
 323     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV);
 324     if (p != NULL
 325         && !OSSL_PARAM_set_octet_ptr(p, &ctx->iv, ctx->ivlen)
 326         && !OSSL_PARAM_set_octet_string(p, &ctx->iv, ctx->ivlen)) {
 327         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 328         return 0;
 329     }
 330     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_NUM);
 331     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->num)) {
 332         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 333         return 0;
 334     }
 335     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
 336     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->keylen)) {
 337         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 338         return 0;
 339     }
 340
 341     return 1;
 342 }
 343
 344 int cipher_generic_set_ctx_params(void *vctx, const OSSL_PARAM params[])
 345 {
 346     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 347     const OSSL_PARAM *p;
 348
 349     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_PADDING);
 350     if (p != NULL) {
 351         unsigned int pad;
 352
 353         if (!OSSL_PARAM_get_uint(p, &pad)) {
 354             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 355             return 0;
 356         }
 357         ctx->pad = pad ? 1 : 0;
 358     }
 359     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_NUM);
 360     if (p != NULL) {
 361         unsigned int num;
 362
 363         if (!OSSL_PARAM_get_uint(p, &num)) {
 364             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 365             return 0;
 366         }
 367         ctx->num = num;
 368     }
 369     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN);
 370     if (p != NULL) {
 371         size_t keylen;
 372
 373         if (!OSSL_PARAM_get_size_t(p, &keylen)) {
 374             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 375             return 0;
 376         }
 377         ctx->keylen = keylen;
 378     }
 379     return 1;
 380 }
 381
 382 void cipher_generic_initkey(void *vctx, size_t kbits, size_t blkbits,
 383                             size_t ivbits, unsigned int mode, uint64_t flags,
 384                             const PROV_CIPHER_HW *hw, void *provctx)
 385 {
 386     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 387
 388     ctx->flags = flags;
 389     ctx->pad = 1;
 390     ctx->keylen = ((kbits) / 8);
 391     ctx->ivlen = ((ivbits) / 8);
 392     ctx->hw = hw;
 393     ctx->mode = mode;
 394     ctx->blocksize = blkbits / 8;
 395     if (provctx != NULL)
 396         ctx->libctx = PROV_LIBRARY_CONTEXT_OF(provctx); /* used for rand */
 397 }