providers/implementations/ciphers/ciphercommon.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  * Generic dispatch table functions for ciphers.
  12  */
  13
  14 #include "ciphercommon_local.h"
  15 #include "prov/provider_ctx.h"
  16 #include "prov/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  * Variable key length cipher functions for OSSL_PARAM settables
  76  */
  77
  78 int cipher_var_keylen_set_ctx_params(void *vctx, const OSSL_PARAM params[])
  79 {
  80     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
  81     const OSSL_PARAM *p;
  82
  83     if (!cipher_generic_set_ctx_params(vctx, params))
  84         return 0;
  85     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN);
  86     if (p != NULL) {
  87         size_t keylen;
  88
  89         if (!OSSL_PARAM_get_size_t(p, &keylen)) {
  90             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
  91             return 0;
  92         }
  93         ctx->keylen = keylen;
  94     }
  95     return 1;
  96 }
  97
  98 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(cipher_var_keylen)
  99 OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
 100 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(cipher_var_keylen)
 101
 102 /*-
 103  * AEAD cipher functions for OSSL_PARAM gettables and settables
 104  */
 105 static const OSSL_PARAM cipher_aead_known_gettable_ctx_params[] = {
 106     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
 107     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
 108     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
 109     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
 110     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
 111     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
 112     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN, NULL, 0),
 113     OSSL_PARAM_END
 114 };
 115 const OSSL_PARAM *cipher_aead_gettable_ctx_params(void)
 116 {
 117     return cipher_aead_known_gettable_ctx_params;
 118 }
 119
 120 static const OSSL_PARAM cipher_aead_known_settable_ctx_params[] = {
 121     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
 122     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
 123     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
 124     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, NULL, 0),
 125     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV, NULL, 0),
 126     OSSL_PARAM_END
 127 };
 128 const OSSL_PARAM *cipher_aead_settable_ctx_params(void)
 129 {
 130     return cipher_aead_known_settable_ctx_params;
 131 }
 132
 133 static int cipher_generic_init_internal(PROV_CIPHER_CTX *ctx,
 134                                         const unsigned char *key, size_t keylen,
 135                                         const unsigned char *iv, size_t ivlen,
 136                                         int enc)
 137 {
 138     ctx->enc = enc ? 1 : 0;
 139
 140     if (iv != NULL && ctx->mode != EVP_CIPH_ECB_MODE) {
 141         if (!cipher_generic_initiv(ctx, iv, ivlen))
 142             return 0;
 143     }
 144     if (key != NULL) {
 145         if ((ctx->flags & EVP_CIPH_VARIABLE_LENGTH) == 0) {
 146             if (keylen != ctx->keylen) {
 147                 ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEYLEN);
 148                 return 0;
 149             }
 150         } else {
 151             ctx->keylen = keylen;
 152         }
 153         return ctx->hw->init(ctx, key, ctx->keylen);
 154     }
 155     return 1;
 156 }
 157
 158 int cipher_generic_einit(void *vctx, const unsigned char *key, size_t keylen,
 159                          const unsigned char *iv, size_t ivlen)
 160 {
 161     return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
 162                                         iv, ivlen, 1);
 163 }
 164
 165 int cipher_generic_dinit(void *vctx, const unsigned char *key, size_t keylen,
 166                          const unsigned char *iv, size_t ivlen)
 167 {
 168     return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
 169                                         iv, ivlen, 0);
 170 }
 171
 172 int cipher_generic_block_update(void *vctx, unsigned char *out, size_t *outl,
 173                                 size_t outsize, const unsigned char *in,
 174                                 size_t inl)
 175 {
 176     size_t outlint = 0;
 177     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 178     size_t blksz = ctx->blocksize;
 179     size_t nextblocks;
 180
 181     if (ctx->bufsz != 0)
 182         nextblocks = fillblock(ctx->buf, &ctx->bufsz, blksz, &in, &inl);
 183     else
 184         nextblocks = inl & ~(blksz-1);
 185
 186     /*
 187      * If we're decrypting and we end an update on a block boundary we hold
 188      * the last block back in case this is the last update call and the last
 189      * block is padded.
 190      */
 191     if (ctx->bufsz == blksz && (ctx->enc || inl > 0 || !ctx->pad)) {
 192         if (outsize < blksz) {
 193             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 194             return 0;
 195         }
 196         if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
 197             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 198             return 0;
 199         }
 200         ctx->bufsz = 0;
 201         outlint = blksz;
 202         out += blksz;
 203     }
 204     if (nextblocks > 0) {
 205         if (!ctx->enc && ctx->pad && nextblocks == inl) {
 206             if (!ossl_assert(inl >= blksz)) {
 207                 ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 208                 return 0;
 209             }
 210             nextblocks -= blksz;
 211         }
 212         outlint += nextblocks;
 213         if (outsize < outlint) {
 214             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 215             return 0;
 216         }
 217     }
 218     if (nextblocks > 0) {
 219         if (!ctx->hw->cipher(ctx, out, in, nextblocks)) {
 220             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 221             return 0;
 222         }
 223         in += nextblocks;
 224         inl -= nextblocks;
 225     }
 226     if (inl != 0 && !trailingdata(ctx->buf, &ctx->bufsz, blksz, &in, &inl)) {
 227         /* ERR_raise already called */
 228         return 0;
 229     }
 230
 231     *outl = outlint;
 232     return inl == 0;
 233 }
 234
 235 int cipher_generic_block_final(void *vctx, unsigned char *out, size_t *outl,
 236                                size_t outsize)
 237 {
 238     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 239     size_t blksz = ctx->blocksize;
 240
 241     if (ctx->enc) {
 242         if (ctx->pad) {
 243             padblock(ctx->buf, &ctx->bufsz, blksz);
 244         } else if (ctx->bufsz == 0) {
 245             *outl = 0;
 246             return 1;
 247         } else if (ctx->bufsz != blksz) {
 248             ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
 249             return 0;
 250         }
 251
 252         if (outsize < blksz) {
 253             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 254             return 0;
 255         }
 256         if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
 257             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 258             return 0;
 259         }
 260         ctx->bufsz = 0;
 261         *outl = blksz;
 262         return 1;
 263     }
 264
 265     /* Decrypting */
 266     if (ctx->bufsz != blksz) {
 267         if (ctx->bufsz == 0 && !ctx->pad) {
 268             *outl = 0;
 269             return 1;
 270         }
 271         ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
 272         return 0;
 273     }
 274
 275     if (!ctx->hw->cipher(ctx, ctx->buf, ctx->buf, blksz)) {
 276         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 277         return 0;
 278     }
 279
 280     if (ctx->pad && !unpadblock(ctx->buf, &ctx->bufsz, blksz)) {
 281         /* ERR_raise already called */
 282         return 0;
 283     }
 284
 285     if (outsize < ctx->bufsz) {
 286         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 287         return 0;
 288     }
 289     memcpy(out, ctx->buf, ctx->bufsz);
 290     *outl = ctx->bufsz;
 291     ctx->bufsz = 0;
 292     return 1;
 293 }
 294
 295 int cipher_generic_stream_update(void *vctx, unsigned char *out, size_t *outl,
 296                                  size_t outsize, const unsigned char *in,
 297                                  size_t inl)
 298 {
 299     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 300
 301     if (inl == 0) {
 302         *outl = 0;
 303         return 1;
 304     }
 305
 306     if (outsize < inl) {
 307         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 308         return 0;
 309     }
 310
 311     if (!ctx->hw->cipher(ctx, out, in, inl)) {
 312         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 313         return 0;
 314     }
 315
 316     *outl = inl;
 317     return 1;
 318 }
 319 int cipher_generic_stream_final(void *vctx, unsigned char *out, size_t *outl,
 320                                 size_t outsize)
 321 {
 322     *outl = 0;
 323     return 1;
 324 }
 325
 326 int cipher_generic_cipher(void *vctx,
 327                           unsigned char *out, size_t *outl, size_t outsize,
 328                           const unsigned char *in, size_t inl)
 329 {
 330     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 331
 332     if (outsize < inl) {
 333         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 334         return 0;
 335     }
 336
 337     if (!ctx->hw->cipher(ctx, out, in, inl)) {
 338         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 339         return 0;
 340     }
 341
 342     *outl = inl;
 343     return 1;
 344 }
 345
 346 int cipher_generic_get_ctx_params(void *vctx, OSSL_PARAM params[])
 347 {
 348     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 349     OSSL_PARAM *p;
 350
 351     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
 352     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->ivlen)) {
 353         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 354         return 0;
 355     }
 356     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_PADDING);
 357     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->pad)) {
 358         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 359         return 0;
 360     }
 361     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV);
 362     if (p != NULL
 363         && !OSSL_PARAM_set_octet_ptr(p, &ctx->oiv, ctx->ivlen)
 364         && !OSSL_PARAM_set_octet_string(p, &ctx->oiv, ctx->ivlen)) {
 365         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 366         return 0;
 367     }
 368     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_NUM);
 369     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->num)) {
 370         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 371         return 0;
 372     }
 373     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
 374     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->keylen)) {
 375         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 376         return 0;
 377     }
 378     return 1;
 379 }
 380
 381 int cipher_generic_set_ctx_params(void *vctx, const OSSL_PARAM params[])
 382 {
 383     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 384     const OSSL_PARAM *p;
 385
 386     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_PADDING);
 387     if (p != NULL) {
 388         unsigned int pad;
 389
 390         if (!OSSL_PARAM_get_uint(p, &pad)) {
 391             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 392             return 0;
 393         }
 394         ctx->pad = pad ? 1 : 0;
 395     }
 396     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_NUM);
 397     if (p != NULL) {
 398         unsigned int num;
 399
 400         if (!OSSL_PARAM_get_uint(p, &num)) {
 401             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 402             return 0;
 403         }
 404         ctx->num = num;
 405     }
 406     return 1;
 407 }
 408
 409 int cipher_generic_initiv(PROV_CIPHER_CTX *ctx, const unsigned char *iv,
 410                           size_t ivlen)
 411 {
 412     if (ivlen != ctx->ivlen
 413         || ivlen > sizeof(ctx->iv)) {
 414         ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IVLEN);
 415         return 0;
 416     }
 417     ctx->iv_set = 1;
 418     memcpy(ctx->iv, iv, ivlen);
 419     memcpy(ctx->oiv, iv, ivlen);
 420     return 1;
 421 }
 422
 423 void cipher_generic_initkey(void *vctx, size_t kbits, size_t blkbits,
 424                             size_t ivbits, unsigned int mode, uint64_t flags,
 425                             const PROV_CIPHER_HW *hw, void *provctx)
 426 {
 427     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
 428
 429     ctx->flags = flags;
 430     ctx->pad = 1;
 431     ctx->keylen = ((kbits) / 8);
 432     ctx->ivlen = ((ivbits) / 8);
 433     ctx->hw = hw;
 434     ctx->mode = mode;
 435     ctx->blocksize = blkbits / 8;
 436     if (provctx != NULL)
 437         ctx->libctx = PROV_LIBRARY_CONTEXT_OF(provctx); /* used for rand */
 438 }