providers/implementations/include/prov/ciphercommon.h

   1 /*
   2  * Copyright 2019-2021 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 <openssl/params.h>
  11 #include <openssl/core_dispatch.h>
  12 #include <openssl/core_names.h>
  13 #include <openssl/evp.h>
  14 #include "internal/cryptlib.h"
  15 #include "crypto/modes.h"
  16
  17 #define MAXCHUNK    ((size_t)1 << (sizeof(long) * 8 - 2))
  18 #define MAXBITCHUNK ((size_t)1 << (sizeof(size_t) * 8 - 4))
  19
  20 #define GENERIC_BLOCK_SIZE 16
  21 #define IV_STATE_UNINITIALISED 0  /* initial state is not initialized */
  22 #define IV_STATE_BUFFERED      1  /* iv has been copied to the iv buffer */
  23 #define IV_STATE_COPIED        2  /* iv has been copied from the iv buffer */
  24 #define IV_STATE_FINISHED      3  /* the iv has been used - so don't reuse it */
  25
  26 #define PROV_CIPHER_FUNC(type, name, args) typedef type (* OSSL_##name##_fn)args
  27
  28 typedef struct prov_cipher_hw_st PROV_CIPHER_HW;
  29 typedef struct prov_cipher_ctx_st PROV_CIPHER_CTX;
  30
  31 typedef int (PROV_CIPHER_HW_FN)(PROV_CIPHER_CTX *dat, unsigned char *out,
  32                                 const unsigned char *in, size_t len);
  33
  34 /* TODO(3.0): VERIFY ME */
  35 #define MAX_TLS_MAC_SIZE    48
  36
  37 struct prov_cipher_ctx_st {
  38     block128_f block;
  39     union {
  40         cbc128_f cbc;
  41         ctr128_f ctr;
  42         ecb128_f ecb;
  43     } stream;
  44
  45     unsigned int mode;
  46     size_t keylen;           /* key size (in bytes) */
  47     size_t ivlen;
  48     size_t blocksize;
  49     size_t bufsz;            /* Number of bytes in buf */
  50     unsigned int cts_mode;   /* Use to set the type for CTS modes */
  51     unsigned int pad : 1;    /* Whether padding should be used or not */
  52     unsigned int enc : 1;    /* Set to 1 for encrypt, or 0 otherwise */
  53     unsigned int iv_set : 1; /* Set when the iv is copied to the iv/oiv buffers */
  54     unsigned int updated : 1; /* Set to 1 during update for one shot ciphers */
  55
  56
  57     unsigned int tlsversion; /* If TLS padding is in use the TLS version number */
  58     unsigned char *tlsmac;   /* tls MAC extracted from the last record */
  59     int alloced;             /*
  60                               * Whether the tlsmac data has been allocated or
  61                               * points into the user buffer.
  62                               */
  63     size_t tlsmacsize;       /* Size of the TLS MAC */
  64     int removetlspad;        /* Whether TLS padding should be removed or not */
  65     size_t removetlsfixed;   /*
  66                               * Length of the fixed size data to remove when
  67                               * processing TLS data (equals mac size plus
  68                               * IV size if applicable)
  69                               */
  70
  71     /*
  72      * num contains the number of bytes of |iv| which are valid for modes that
  73      * manage partial blocks themselves.
  74      */
  75     unsigned int num;
  76     uint64_t flags;
  77
  78     /* The original value of the iv */
  79     unsigned char oiv[GENERIC_BLOCK_SIZE];
  80     /* Buffer of partial blocks processed via update calls */
  81     unsigned char buf[GENERIC_BLOCK_SIZE];
  82     unsigned char iv[GENERIC_BLOCK_SIZE];
  83     const PROV_CIPHER_HW *hw; /* hardware specific functions */
  84     const void *ks; /* Pointer to algorithm specific key data */
  85     OSSL_LIB_CTX *libctx;
  86 };
  87
  88 struct prov_cipher_hw_st {
  89     int (*init)(PROV_CIPHER_CTX *dat, const uint8_t *key, size_t keylen);
  90     PROV_CIPHER_HW_FN *cipher;
  91     void (*copyctx)(PROV_CIPHER_CTX *dst, const PROV_CIPHER_CTX *src);
  92 };
  93
  94 void ossl_cipher_generic_reset_ctx(PROV_CIPHER_CTX *ctx);
  95 OSSL_FUNC_cipher_encrypt_init_fn ossl_cipher_generic_einit;
  96 OSSL_FUNC_cipher_decrypt_init_fn ossl_cipher_generic_dinit;
  97 OSSL_FUNC_cipher_update_fn ossl_cipher_generic_block_update;
  98 OSSL_FUNC_cipher_final_fn ossl_cipher_generic_block_final;
  99 OSSL_FUNC_cipher_update_fn ossl_cipher_generic_stream_update;
 100 OSSL_FUNC_cipher_final_fn ossl_cipher_generic_stream_final;
 101 OSSL_FUNC_cipher_cipher_fn ossl_cipher_generic_cipher;
 102 OSSL_FUNC_cipher_get_ctx_params_fn ossl_cipher_generic_get_ctx_params;
 103 OSSL_FUNC_cipher_set_ctx_params_fn ossl_cipher_generic_set_ctx_params;
 104 OSSL_FUNC_cipher_gettable_params_fn     ossl_cipher_generic_gettable_params;
 105 OSSL_FUNC_cipher_gettable_ctx_params_fn ossl_cipher_generic_gettable_ctx_params;
 106 OSSL_FUNC_cipher_settable_ctx_params_fn ossl_cipher_generic_settable_ctx_params;
 107 OSSL_FUNC_cipher_set_ctx_params_fn ossl_cipher_var_keylen_set_ctx_params;
 108 OSSL_FUNC_cipher_settable_ctx_params_fn ossl_cipher_var_keylen_settable_ctx_params;
 109 OSSL_FUNC_cipher_gettable_ctx_params_fn ossl_cipher_aead_gettable_ctx_params;
 110 OSSL_FUNC_cipher_settable_ctx_params_fn ossl_cipher_aead_settable_ctx_params;
 111
 112 int ossl_cipher_generic_get_params(OSSL_PARAM params[], unsigned int md,
 113                               unsigned long flags,
 114                               size_t kbits, size_t blkbits, size_t ivbits);
 115 void ossl_cipher_generic_initkey(void *vctx, size_t kbits, size_t blkbits,
 116                             size_t ivbits, unsigned int mode, uint64_t flags,
 117                             const PROV_CIPHER_HW *hw, void *provctx);
 118
 119 #define IMPLEMENT_generic_cipher_func(alg, UCALG, lcmode, UCMODE, flags, kbits,\
 120                                       blkbits, ivbits, typ)                    \
 121 const OSSL_DISPATCH ossl_##alg##kbits##lcmode##_functions[] = {                \
 122     { OSSL_FUNC_CIPHER_NEWCTX,                                                 \
 123       (void (*)(void)) alg##_##kbits##_##lcmode##_newctx },                    \
 124     { OSSL_FUNC_CIPHER_FREECTX, (void (*)(void)) alg##_freectx },              \
 125     { OSSL_FUNC_CIPHER_DUPCTX, (void (*)(void)) alg##_dupctx },                \
 126     { OSSL_FUNC_CIPHER_ENCRYPT_INIT, (void (*)(void))ossl_cipher_generic_einit },   \
 127     { OSSL_FUNC_CIPHER_DECRYPT_INIT, (void (*)(void))ossl_cipher_generic_dinit },   \
 128     { OSSL_FUNC_CIPHER_UPDATE, (void (*)(void))ossl_cipher_generic_##typ##_update },\
 129     { OSSL_FUNC_CIPHER_FINAL, (void (*)(void))ossl_cipher_generic_##typ##_final },  \
 130     { OSSL_FUNC_CIPHER_CIPHER, (void (*)(void))ossl_cipher_generic_cipher },        \
 131     { OSSL_FUNC_CIPHER_GET_PARAMS,                                             \
 132       (void (*)(void)) alg##_##kbits##_##lcmode##_get_params },                \
 133     { OSSL_FUNC_CIPHER_GET_CTX_PARAMS,                                         \
 134       (void (*)(void))ossl_cipher_generic_get_ctx_params },                    \
 135     { OSSL_FUNC_CIPHER_SET_CTX_PARAMS,                                         \
 136       (void (*)(void))ossl_cipher_generic_set_ctx_params },                    \
 137     { OSSL_FUNC_CIPHER_GETTABLE_PARAMS,                                        \
 138       (void (*)(void))ossl_cipher_generic_gettable_params },                   \
 139     { OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS,                                    \
 140       (void (*)(void))ossl_cipher_generic_gettable_ctx_params },               \
 141     { OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS,                                    \
 142      (void (*)(void))ossl_cipher_generic_settable_ctx_params },                \
 143     { 0, NULL }                                                                \
 144 };
 145
 146 #define IMPLEMENT_var_keylen_cipher_func(alg, UCALG, lcmode, UCMODE, flags,    \
 147                                          kbits, blkbits, ivbits, typ)          \
 148 const OSSL_DISPATCH ossl_##alg##kbits##lcmode##_functions[] = {                \
 149     { OSSL_FUNC_CIPHER_NEWCTX,                                                 \
 150       (void (*)(void)) alg##_##kbits##_##lcmode##_newctx },                    \
 151     { OSSL_FUNC_CIPHER_FREECTX, (void (*)(void)) alg##_freectx },              \
 152     { OSSL_FUNC_CIPHER_DUPCTX, (void (*)(void)) alg##_dupctx },                \
 153     { OSSL_FUNC_CIPHER_ENCRYPT_INIT, (void (*)(void))ossl_cipher_generic_einit },\
 154     { OSSL_FUNC_CIPHER_DECRYPT_INIT, (void (*)(void))ossl_cipher_generic_dinit },\
 155     { OSSL_FUNC_CIPHER_UPDATE, (void (*)(void))ossl_cipher_generic_##typ##_update },\
 156     { OSSL_FUNC_CIPHER_FINAL, (void (*)(void))ossl_cipher_generic_##typ##_final },  \
 157     { OSSL_FUNC_CIPHER_CIPHER, (void (*)(void))ossl_cipher_generic_cipher },   \
 158     { OSSL_FUNC_CIPHER_GET_PARAMS,                                             \
 159       (void (*)(void)) alg##_##kbits##_##lcmode##_get_params },                \
 160     { OSSL_FUNC_CIPHER_GET_CTX_PARAMS,                                         \
 161       (void (*)(void))ossl_cipher_generic_get_ctx_params },                    \
 162     { OSSL_FUNC_CIPHER_SET_CTX_PARAMS,                                         \
 163       (void (*)(void))ossl_cipher_var_keylen_set_ctx_params },                 \
 164     { OSSL_FUNC_CIPHER_GETTABLE_PARAMS,                                        \
 165       (void (*)(void))ossl_cipher_generic_gettable_params },                   \
 166     { OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS,                                    \
 167       (void (*)(void))ossl_cipher_generic_gettable_ctx_params },               \
 168     { OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS,                                    \
 169      (void (*)(void))ossl_cipher_var_keylen_settable_ctx_params },             \
 170     { 0, NULL }                                                                \
 171 };
 172
 173
 174 #define IMPLEMENT_generic_cipher_genfn(alg, UCALG, lcmode, UCMODE, flags,      \
 175                                        kbits, blkbits, ivbits, typ)            \
 176 static OSSL_FUNC_cipher_get_params_fn alg##_##kbits##_##lcmode##_get_params;   \
 177 static int alg##_##kbits##_##lcmode##_get_params(OSSL_PARAM params[])          \
 178 {                                                                              \
 179     return ossl_cipher_generic_get_params(params, EVP_CIPH_##UCMODE##_MODE,    \
 180                                           flags, kbits, blkbits, ivbits);      \
 181 }                                                                              \
 182 static OSSL_FUNC_cipher_newctx_fn alg##_##kbits##_##lcmode##_newctx;           \
 183 static void * alg##_##kbits##_##lcmode##_newctx(void *provctx)                 \
 184 {                                                                              \
 185      PROV_##UCALG##_CTX *ctx = ossl_prov_is_running() ? OPENSSL_zalloc(sizeof(*ctx))\
 186                                                      : NULL;                   \
 187      if (ctx != NULL) {                                                        \
 188          ossl_cipher_generic_initkey(ctx, kbits, blkbits, ivbits,              \
 189                                      EVP_CIPH_##UCMODE##_MODE, flags,          \
 190                                      ossl_prov_cipher_hw_##alg##_##lcmode(kbits),\
 191                                      provctx);                                 \
 192      }                                                                         \
 193      return ctx;                                                               \
 194 }                                                                              \
 195
 196 #define IMPLEMENT_generic_cipher(alg, UCALG, lcmode, UCMODE, flags, kbits,     \
 197                                  blkbits, ivbits, typ)                         \
 198 IMPLEMENT_generic_cipher_genfn(alg, UCALG, lcmode, UCMODE, flags, kbits,       \
 199                                blkbits, ivbits, typ)                           \
 200 IMPLEMENT_generic_cipher_func(alg, UCALG, lcmode, UCMODE, flags, kbits,        \
 201                               blkbits, ivbits, typ)
 202
 203 #define IMPLEMENT_var_keylen_cipher(alg, UCALG, lcmode, UCMODE, flags, kbits,  \
 204                                     blkbits, ivbits, typ)                      \
 205 IMPLEMENT_generic_cipher_genfn(alg, UCALG, lcmode, UCMODE, flags, kbits,       \
 206                                blkbits, ivbits, typ)                           \
 207 IMPLEMENT_var_keylen_cipher_func(alg, UCALG, lcmode, UCMODE, flags, kbits,     \
 208                                  blkbits, ivbits, typ)
 209
 210 PROV_CIPHER_HW_FN ossl_cipher_hw_generic_cbc;
 211 PROV_CIPHER_HW_FN ossl_cipher_hw_generic_ecb;
 212 PROV_CIPHER_HW_FN ossl_cipher_hw_generic_ofb128;
 213 PROV_CIPHER_HW_FN ossl_cipher_hw_generic_cfb128;
 214 PROV_CIPHER_HW_FN ossl_cipher_hw_generic_cfb8;
 215 PROV_CIPHER_HW_FN ossl_cipher_hw_generic_cfb1;
 216 PROV_CIPHER_HW_FN ossl_cipher_hw_generic_ctr;
 217 PROV_CIPHER_HW_FN ossl_cipher_hw_chunked_cbc;
 218 PROV_CIPHER_HW_FN ossl_cipher_hw_chunked_cfb8;
 219 PROV_CIPHER_HW_FN ossl_cipher_hw_chunked_cfb128;
 220 PROV_CIPHER_HW_FN ossl_cipher_hw_chunked_ofb128;
 221 #define ossl_cipher_hw_chunked_ecb  ossl_cipher_hw_generic_ecb
 222 #define ossl_cipher_hw_chunked_ctr  ossl_cipher_hw_generic_ctr
 223 #define ossl_cipher_hw_chunked_cfb1 ossl_cipher_hw_generic_cfb1
 224
 225 #define IMPLEMENT_CIPHER_HW_OFB(MODE, NAME, CTX_NAME, KEY_NAME, FUNC_PREFIX)   \
 226 static int cipher_hw_##NAME##_##MODE##_cipher(PROV_CIPHER_CTX *ctx,            \
 227                                          unsigned char *out,                   \
 228                                          const unsigned char *in, size_t len)  \
 229 {                                                                              \
 230     int num = ctx->num;                                                        \
 231     KEY_NAME *key = &(((CTX_NAME *)ctx)->ks.ks);                               \
 232                                                                                \
 233     while (len >= MAXCHUNK) {                                                  \
 234         FUNC_PREFIX##_encrypt(in, out, MAXCHUNK, key, ctx->iv, &num);          \
 235         len -= MAXCHUNK;                                                       \
 236         in += MAXCHUNK;                                                        \
 237         out += MAXCHUNK;                                                       \
 238     }                                                                          \
 239     if (len > 0) {                                                             \
 240         FUNC_PREFIX##_encrypt(in, out, (long)len, key, ctx->iv, &num);         \
 241     }                                                                          \
 242     ctx->num = num;                                                            \
 243     return 1;                                                                  \
 244 }
 245
 246 #define IMPLEMENT_CIPHER_HW_ECB(MODE, NAME, CTX_NAME, KEY_NAME, FUNC_PREFIX)   \
 247 static int cipher_hw_##NAME##_##MODE##_cipher(PROV_CIPHER_CTX *ctx,            \
 248                                          unsigned char *out,                   \
 249                                          const unsigned char *in, size_t len)  \
 250 {                                                                              \
 251     size_t i, bl = ctx->blocksize;                                             \
 252     KEY_NAME *key = &(((CTX_NAME *)ctx)->ks.ks);                               \
 253                                                                                \
 254     if (len < bl)                                                              \
 255         return 1;                                                              \
 256     for (i = 0, len -= bl; i <= len; i += bl)                                  \
 257         FUNC_PREFIX##_encrypt(in + i, out + i, key, ctx->enc);                 \
 258     return 1;                                                                  \
 259 }
 260
 261 #define IMPLEMENT_CIPHER_HW_CBC(MODE, NAME, CTX_NAME, KEY_NAME, FUNC_PREFIX)   \
 262 static int cipher_hw_##NAME##_##MODE##_cipher(PROV_CIPHER_CTX *ctx,            \
 263                                          unsigned char *out,                   \
 264                                          const unsigned char *in, size_t len)  \
 265 {                                                                              \
 266     KEY_NAME *key = &(((CTX_NAME *)ctx)->ks.ks);                               \
 267                                                                                \
 268     while (len >= MAXCHUNK) {                                                  \
 269         FUNC_PREFIX##_encrypt(in, out, MAXCHUNK, key, ctx->iv, ctx->enc);      \
 270         len -= MAXCHUNK;                                                       \
 271         in += MAXCHUNK;                                                        \
 272         out += MAXCHUNK;                                                       \
 273     }                                                                          \
 274     if (len > 0)                                                               \
 275         FUNC_PREFIX##_encrypt(in, out, (long)len, key, ctx->iv, ctx->enc);     \
 276     return 1;                                                                  \
 277 }
 278
 279 #define IMPLEMENT_CIPHER_HW_CFB(MODE, NAME, CTX_NAME, KEY_NAME, FUNC_PREFIX)   \
 280 static int cipher_hw_##NAME##_##MODE##_cipher(PROV_CIPHER_CTX *ctx,            \
 281                                          unsigned char *out,                   \
 282                                          const unsigned char *in, size_t len)  \
 283 {                                                                              \
 284     size_t chunk = MAXCHUNK;                                                   \
 285     KEY_NAME *key = &(((CTX_NAME *)ctx)->ks.ks);                               \
 286     int num = ctx->num;                                                        \
 287                                                                                \
 288     if (len < chunk)                                                           \
 289         chunk = len;                                                           \
 290     while (len > 0 && len >= chunk) {                                          \
 291         FUNC_PREFIX##_encrypt(in, out, (long)chunk, key, ctx->iv, &num,        \
 292                               ctx->enc);                                       \
 293         len -= chunk;                                                          \
 294         in += chunk;                                                           \
 295         out += chunk;                                                          \
 296         if (len < chunk)                                                       \
 297             chunk = len;                                                       \
 298     }                                                                          \
 299     ctx->num = num;                                                            \
 300     return 1;                                                                  \
 301 }
 302
 303 #define IMPLEMENT_CIPHER_HW_COPYCTX(name, CTX_TYPE)                            \
 304 static void name(PROV_CIPHER_CTX *dst, const PROV_CIPHER_CTX *src)             \
 305 {                                                                              \
 306     CTX_TYPE *sctx = (CTX_TYPE *)src;                                          \
 307     CTX_TYPE *dctx = (CTX_TYPE *)dst;                                          \
 308                                                                                \
 309     *dctx = *sctx;                                                             \
 310     dst->ks = &dctx->ks.ks;                                                    \
 311 }
 312
 313 #define CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_START(name)                         \
 314 static const OSSL_PARAM name##_known_gettable_ctx_params[] = {                 \
 315     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),                         \
 316     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),                          \
 317     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),                          \
 318     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),                              \
 319     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),                    \
 320     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0),
 321
 322 #define CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_END(name)                           \
 323     OSSL_PARAM_END                                                             \
 324 };                                                                             \
 325 const OSSL_PARAM * name##_gettable_ctx_params(ossl_unused void *provctx)       \
 326 {                                                                              \
 327     return name##_known_gettable_ctx_params;                                   \
 328 }
 329
 330 #define CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(name)                         \
 331 static const OSSL_PARAM name##_known_settable_ctx_params[] = {                 \
 332     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),                          \
 333     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
 334 #define CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(name)                           \
 335     OSSL_PARAM_END                                                             \
 336 };                                                                             \
 337 const OSSL_PARAM * name##_settable_ctx_params(ossl_unused void *provctx)       \
 338 {                                                                              \
 339     return name##_known_settable_ctx_params;                                   \
 340 }
 341
 342 int ossl_cipher_generic_initiv(PROV_CIPHER_CTX *ctx, const unsigned char *iv,
 343                                size_t ivlen);
 344
 345 size_t fillblock(unsigned char *buf, size_t *buflen, size_t blocksize,
 346                  const unsigned char **in, size_t *inlen);
 347 int trailingdata(unsigned char *buf, size_t *buflen, size_t blocksize,
 348                  const unsigned char **in, size_t *inlen);
 349