providers/common/include/internal/ciphers/ciphercommon.h

   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 #include <openssl/params.h>
  11 #include <openssl/core_numbers.h>
  12 #include <openssl/core_names.h>
  13 #include <openssl/evp.h>
  14 #include "internal/cryptlib.h"
  15 #include "crypto/modes.h"
  16 #include "crypto/ciphermode_platform.h"
  17
  18 #define MAXCHUNK    ((size_t)1 << (sizeof(long) * 8 - 2))
  19 #define MAXBITCHUNK ((size_t)1 << (sizeof(size_t) * 8 - 4))
  20
  21 #define GENERIC_BLOCK_SIZE 16
  22 #define IV_STATE_UNINITIALISED 0  /* initial state is not initialized */
  23 #define IV_STATE_BUFFERED      1  /* iv has been copied to the iv buffer */
  24 #define IV_STATE_COPIED        2  /* iv has been copied from the iv buffer */
  25 #define IV_STATE_FINISHED      3  /* the iv has been used - so don't reuse it */
  26
  27 #define PROV_CIPHER_FUNC(type, name, args) typedef type (* OSSL_##name##_fn)args
  28
  29 typedef struct prov_cipher_hw_st PROV_CIPHER_HW;
  30 typedef struct prov_cipher_ctx_st PROV_CIPHER_CTX;
  31
  32 typedef int (PROV_CIPHER_HW_FN)(PROV_CIPHER_CTX *dat, unsigned char *out,
  33                                 const unsigned char *in, size_t len);
  34
  35 struct prov_cipher_ctx_st {
  36     block128_f block;
  37     union {
  38         cbc128_f cbc;
  39         ctr128_f ctr;
  40     } stream;
  41
  42     unsigned int mode;
  43     size_t keylen;           /* key size (in bytes) */
  44     size_t ivlen;
  45     size_t blocksize;
  46     size_t bufsz;            /* Number of bytes in buf */
  47     unsigned int pad : 1;    /* Whether padding should be used or not */
  48     unsigned int enc : 1;    /* Set to 1 for encrypt, or 0 otherwise */
  49     unsigned int iv_set : 1; /* Set when the iv is copied to the iv/oiv buffers */
  50
  51     /*
  52      * num contains the number of bytes of |iv| which are valid for modes that
  53      * manage partial blocks themselves.
  54      */
  55     unsigned int num;
  56     uint64_t flags;
  57
  58     /* The original value of the iv */
  59     unsigned char oiv[GENERIC_BLOCK_SIZE];
  60     /* Buffer of partial blocks processed via update calls */
  61     unsigned char buf[GENERIC_BLOCK_SIZE];
  62     unsigned char iv[GENERIC_BLOCK_SIZE];
  63     const PROV_CIPHER_HW *hw; /* hardware specific functions */
  64     const void *ks; /* Pointer to algorithm specific key data */
  65     OPENSSL_CTX *libctx;
  66 };
  67
  68 struct prov_cipher_hw_st {
  69     int (*init)(PROV_CIPHER_CTX *dat, const uint8_t *key, size_t keylen);
  70     PROV_CIPHER_HW_FN *cipher;
  71 };
  72
  73 OSSL_OP_cipher_encrypt_init_fn cipher_generic_einit;
  74 OSSL_OP_cipher_decrypt_init_fn cipher_generic_dinit;
  75 OSSL_OP_cipher_update_fn cipher_generic_block_update;
  76 OSSL_OP_cipher_final_fn cipher_generic_block_final;
  77 OSSL_OP_cipher_update_fn cipher_generic_stream_update;
  78 OSSL_OP_cipher_final_fn cipher_generic_stream_final;
  79 OSSL_OP_cipher_cipher_fn cipher_generic_cipher;
  80 OSSL_OP_cipher_get_ctx_params_fn cipher_generic_get_ctx_params;
  81 OSSL_OP_cipher_set_ctx_params_fn cipher_generic_set_ctx_params;
  82 OSSL_OP_cipher_gettable_params_fn     cipher_generic_gettable_params;
  83 OSSL_OP_cipher_gettable_ctx_params_fn cipher_generic_gettable_ctx_params;
  84 OSSL_OP_cipher_settable_ctx_params_fn cipher_generic_settable_ctx_params;
  85 OSSL_OP_cipher_gettable_ctx_params_fn cipher_aead_gettable_ctx_params;
  86 OSSL_OP_cipher_settable_ctx_params_fn cipher_aead_settable_ctx_params;
  87 int cipher_generic_get_params(OSSL_PARAM params[], unsigned int md,
  88                               unsigned long flags,
  89                               size_t kbits, size_t blkbits, size_t ivbits);
  90 void cipher_generic_initkey(void *vctx, size_t kbits, size_t blkbits,
  91                             size_t ivbits, unsigned int mode, uint64_t flags,
  92                             const PROV_CIPHER_HW *hw, void *provctx);
  93
  94 #define IMPLEMENT_generic_cipher_func(alg, UCALG, lcmode, UCMODE, flags, kbits,\
  95                                       blkbits, ivbits, typ)                    \
  96 const OSSL_DISPATCH alg##kbits##lcmode##_functions[] = {                       \
  97     { OSSL_FUNC_CIPHER_NEWCTX,                                                 \
  98       (void (*)(void)) alg##_##kbits##_##lcmode##_newctx },                    \
  99     { OSSL_FUNC_CIPHER_FREECTX, (void (*)(void)) alg##_freectx },              \
 100     { OSSL_FUNC_CIPHER_DUPCTX, (void (*)(void)) alg##_dupctx },                \
 101     { OSSL_FUNC_CIPHER_ENCRYPT_INIT, (void (*)(void))cipher_generic_einit },   \
 102     { OSSL_FUNC_CIPHER_DECRYPT_INIT, (void (*)(void))cipher_generic_dinit },   \
 103     { OSSL_FUNC_CIPHER_UPDATE, (void (*)(void))cipher_generic_##typ##_update },\
 104     { OSSL_FUNC_CIPHER_FINAL, (void (*)(void))cipher_generic_##typ##_final },  \
 105     { OSSL_FUNC_CIPHER_CIPHER, (void (*)(void))cipher_generic_cipher },        \
 106     { OSSL_FUNC_CIPHER_GET_PARAMS,                                             \
 107       (void (*)(void)) alg##_##kbits##_##lcmode##_get_params },                \
 108     { OSSL_FUNC_CIPHER_GET_CTX_PARAMS,                                         \
 109       (void (*)(void))cipher_generic_get_ctx_params },                         \
 110     { OSSL_FUNC_CIPHER_SET_CTX_PARAMS,                                         \
 111       (void (*)(void))cipher_generic_set_ctx_params },                         \
 112     { OSSL_FUNC_CIPHER_GETTABLE_PARAMS,                                        \
 113       (void (*)(void))cipher_generic_gettable_params },                        \
 114     { OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS,                                    \
 115       (void (*)(void))cipher_generic_gettable_ctx_params },                    \
 116     { OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS,                                    \
 117      (void (*)(void))cipher_generic_settable_ctx_params },                     \
 118     { 0, NULL }                                                                \
 119 };
 120
 121 #define IMPLEMENT_generic_cipher(alg, UCALG, lcmode, UCMODE, flags, kbits,     \
 122                                  blkbits, ivbits, typ)                         \
 123 static OSSL_OP_cipher_get_params_fn alg##_##kbits##_##lcmode##_get_params;     \
 124 static int alg##_##kbits##_##lcmode##_get_params(OSSL_PARAM params[])          \
 125 {                                                                              \
 126     return cipher_generic_get_params(params, EVP_CIPH_##UCMODE##_MODE, flags,  \
 127                                      kbits, blkbits, ivbits);                  \
 128 }                                                                              \
 129 static OSSL_OP_cipher_newctx_fn alg##_##kbits##_##lcmode##_newctx;             \
 130 static void * alg##_##kbits##_##lcmode##_newctx(void *provctx)                 \
 131 {                                                                              \
 132      PROV_##UCALG##_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));                   \
 133      if (ctx != NULL) {                                                        \
 134          cipher_generic_initkey(ctx, kbits, blkbits, ivbits,                   \
 135                                 EVP_CIPH_##UCMODE##_MODE, flags,               \
 136                                 PROV_CIPHER_HW_##alg##_##lcmode(kbits), NULL); \
 137      }                                                                         \
 138      return ctx;                                                               \
 139 }                                                                              \
 140 IMPLEMENT_generic_cipher_func(alg, UCALG, lcmode, UCMODE, flags, kbits,        \
 141                               blkbits, ivbits, typ)
 142
 143 PROV_CIPHER_HW_FN cipher_hw_generic_cbc;
 144 PROV_CIPHER_HW_FN cipher_hw_generic_ecb;
 145 PROV_CIPHER_HW_FN cipher_hw_generic_ofb128;
 146 PROV_CIPHER_HW_FN cipher_hw_generic_cfb128;
 147 PROV_CIPHER_HW_FN cipher_hw_generic_cfb8;
 148 PROV_CIPHER_HW_FN cipher_hw_generic_cfb1;
 149 PROV_CIPHER_HW_FN cipher_hw_generic_ctr;
 150 PROV_CIPHER_HW_FN cipher_hw_chunked_cbc;
 151 PROV_CIPHER_HW_FN cipher_hw_chunked_cfb8;
 152 PROV_CIPHER_HW_FN cipher_hw_chunked_cfb128;
 153 PROV_CIPHER_HW_FN cipher_hw_chunked_ofb128;
 154 #define cipher_hw_chunked_ecb  cipher_hw_generic_ecb
 155 #define cipher_hw_chunked_ctr  cipher_hw_generic_ctr
 156 #define cipher_hw_chunked_cfb1 cipher_hw_generic_cfb1
 157
 158 #define IMPLEMENT_CIPHER_HW_OFB(MODE, NAME, CTX_NAME, KEY_NAME, FUNC_PREFIX)   \
 159 static int cipher_hw_##NAME##_##MODE##_cipher(PROV_CIPHER_CTX *ctx,            \
 160                                          unsigned char *out,                   \
 161                                          const unsigned char *in, size_t len)  \
 162 {                                                                              \
 163     int num = ctx->num;                                                        \
 164     KEY_NAME *key = &(((CTX_NAME *)ctx)->ks.ks);                               \
 165                                                                                \
 166     while (len >= MAXCHUNK) {                                                  \
 167         FUNC_PREFIX##_encrypt(in, out, MAXCHUNK, key, ctx->iv, &num);          \
 168         len -= MAXCHUNK;                                                       \
 169         in += MAXCHUNK;                                                        \
 170         out += MAXCHUNK;                                                       \
 171     }                                                                          \
 172     if (len > 0) {                                                             \
 173         FUNC_PREFIX##_encrypt(in, out, (long)len, key, ctx->iv, &num);         \
 174     }                                                                          \
 175     ctx->num = num;                                                            \
 176     return 1;                                                                  \
 177 }
 178
 179 #define IMPLEMENT_CIPHER_HW_ECB(MODE, NAME, CTX_NAME, KEY_NAME, FUNC_PREFIX)   \
 180 static int cipher_hw_##NAME##_##MODE##_cipher(PROV_CIPHER_CTX *ctx,            \
 181                                          unsigned char *out,                   \
 182                                          const unsigned char *in, size_t len)  \
 183 {                                                                              \
 184     size_t i, bl = ctx->blocksize;                                             \
 185     KEY_NAME *key = &(((CTX_NAME *)ctx)->ks.ks);                               \
 186                                                                                \
 187     if (len < bl)                                                              \
 188         return 1;                                                              \
 189     for (i = 0, len -= bl; i <= len; i += bl)                                  \
 190         FUNC_PREFIX##_encrypt(in + i, out + i, key, ctx->enc);                 \
 191     return 1;                                                                  \
 192 }
 193
 194 #define IMPLEMENT_CIPHER_HW_CBC(MODE, NAME, CTX_NAME, KEY_NAME, FUNC_PREFIX)   \
 195 static int cipher_hw_##NAME##_##MODE##_cipher(PROV_CIPHER_CTX *ctx,            \
 196                                          unsigned char *out,                   \
 197                                          const unsigned char *in, size_t len)  \
 198 {                                                                              \
 199     KEY_NAME *key = &(((CTX_NAME *)ctx)->ks.ks);                               \
 200                                                                                \
 201     while (len >= MAXCHUNK) {                                                  \
 202         FUNC_PREFIX##_encrypt(in, out, MAXCHUNK, key, ctx->iv, ctx->enc);      \
 203         len -= MAXCHUNK;                                                       \
 204         in += MAXCHUNK;                                                        \
 205         out += MAXCHUNK;                                                       \
 206     }                                                                          \
 207     if (len > 0)                                                               \
 208         FUNC_PREFIX##_encrypt(in, out, (long)len, key, ctx->iv, ctx->enc);     \
 209     return 1;                                                                  \
 210 }
 211
 212 #define IMPLEMENT_CIPHER_HW_CFB(MODE, NAME, CTX_NAME, KEY_NAME, FUNC_PREFIX)   \
 213 static int cipher_hw_##NAME##_##MODE##_cipher(PROV_CIPHER_CTX *ctx,            \
 214                                          unsigned char *out,                   \
 215                                          const unsigned char *in, size_t len)  \
 216 {                                                                              \
 217     size_t chunk = MAXCHUNK;                                                   \
 218     KEY_NAME *key = &(((CTX_NAME *)ctx)->ks.ks);                               \
 219     int num = ctx->num;                                                        \
 220                                                                                \
 221     if (len < chunk)                                                           \
 222         chunk = len;                                                           \
 223     while (len > 0 && len >= chunk) {                                          \
 224         FUNC_PREFIX##_encrypt(in, out, (long)chunk, key, ctx->iv, &num,        \
 225                               ctx->enc);                                       \
 226         len -= chunk;                                                          \
 227         in += chunk;                                                           \
 228         out += chunk;                                                          \
 229         if (len < chunk)                                                       \
 230             chunk = len;                                                       \
 231     }                                                                          \
 232     ctx->num = num;                                                            \
 233     return 1;                                                                  \
 234 }
 235
 236 #define CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_START(name)                         \
 237 static const OSSL_PARAM name##_known_gettable_ctx_params[] = {                 \
 238     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),                         \
 239     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),                          \
 240     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),                          \
 241     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),                              \
 242     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
 243
 244 #define CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_END(name)                           \
 245     OSSL_PARAM_END                                                             \
 246 };                                                                             \
 247 const OSSL_PARAM * name##_gettable_ctx_params(void)                            \
 248 {                                                                              \
 249     return name##_known_gettable_ctx_params;                                   \
 250 }
 251
 252 #define CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(name)                         \
 253 static const OSSL_PARAM name##_known_settable_ctx_params[] = {                 \
 254     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),                         \
 255     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),                          \
 256     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
 257 #define CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(name)                           \
 258     OSSL_PARAM_END                                                             \
 259 };                                                                             \
 260 const OSSL_PARAM * name##_settable_ctx_params(void)                            \
 261 {                                                                              \
 262     return name##_known_settable_ctx_params;                                   \
 263 }
 264
 265 int cipher_generic_initiv(PROV_CIPHER_CTX *ctx, const unsigned char *iv,
 266                           size_t ivlen);
 267
 268 size_t fillblock(unsigned char *buf, size_t *buflen, size_t blocksize,
 269                  const unsigned char **in, size_t *inlen);
 270 int trailingdata(unsigned char *buf, size_t *buflen, size_t blocksize,
 271                  const unsigned char **in, size_t *inlen);
 272