crypto/openssl/crypto/evp/enc_min.c

   1 /* crypto/evp/enc_min.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 #include <stdio.h>
  60 #include "cryptlib.h"
  61 #include <openssl/evp.h>
  62 #include <openssl/err.h>
  63 #include <openssl/rand.h>
  64 #ifndef OPENSSL_NO_ENGINE
  65 # include <openssl/engine.h>
  66 #endif
  67 #include "evp_locl.h"
  68
  69 void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx)
  70 {
  71 #ifdef OPENSSL_FIPS
  72     FIPS_selftest_check();
  73 #endif
  74     memset(ctx, 0, sizeof(EVP_CIPHER_CTX));
  75     /* ctx->cipher=NULL; */
  76 }
  77
  78 #ifdef OPENSSL_FIPS
  79
  80 /*
  81  * The purpose of these is to trap programs that attempt to use non FIPS
  82  * algorithms in FIPS mode and ignore the errors.
  83  */
  84
  85 static int bad_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
  86                     const unsigned char *iv, int enc)
  87 {
  88     FIPS_ERROR_IGNORED("Cipher init");
  89     return 0;
  90 }
  91
  92 static int bad_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
  93                          const unsigned char *in, unsigned int inl)
  94 {
  95     FIPS_ERROR_IGNORED("Cipher update");
  96     return 0;
  97 }
  98
  99 /* NB: no cleanup because it is allowed after failed init */
 100
 101 static int bad_set_asn1(EVP_CIPHER_CTX *ctx, ASN1_TYPE *typ)
 102 {
 103     FIPS_ERROR_IGNORED("Cipher set_asn1");
 104     return 0;
 105 }
 106
 107 static int bad_get_asn1(EVP_CIPHER_CTX *ctx, ASN1_TYPE *typ)
 108 {
 109     FIPS_ERROR_IGNORED("Cipher get_asn1");
 110     return 0;
 111 }
 112
 113 static int bad_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
 114 {
 115     FIPS_ERROR_IGNORED("Cipher ctrl");
 116     return 0;
 117 }
 118
 119 static const EVP_CIPHER bad_cipher = {
 120     0,
 121     0,
 122     0,
 123     0,
 124     0,
 125     bad_init,
 126     bad_do_cipher,
 127     NULL,
 128     0,
 129     bad_set_asn1,
 130     bad_get_asn1,
 131     bad_ctrl,
 132     NULL
 133 };
 134
 135 #endif
 136
 137 #ifndef OPENSSL_NO_ENGINE
 138
 139 # ifdef OPENSSL_FIPS
 140
 141 static int do_engine_null(ENGINE *impl)
 142 {
 143     return 0;
 144 }
 145
 146 static int do_evp_enc_engine_null(EVP_CIPHER_CTX *ctx,
 147                                   const EVP_CIPHER **pciph, ENGINE *impl)
 148 {
 149     return 1;
 150 }
 151
 152 static int (*do_engine_finish) (ENGINE *impl)
 153     = do_engine_null;
 154
 155 static int (*do_evp_enc_engine)
 156  (EVP_CIPHER_CTX *ctx, const EVP_CIPHER **pciph, ENGINE *impl)
 157     = do_evp_enc_engine_null;
 158
 159 void int_EVP_CIPHER_set_engine_callbacks(int (*eng_ciph_fin) (ENGINE *impl),
 160                                          int (*eng_ciph_evp)
 161                                           (EVP_CIPHER_CTX *ctx,
 162                                            const EVP_CIPHER **pciph,
 163                                            ENGINE *impl))
 164 {
 165     do_engine_finish = eng_ciph_fin;
 166     do_evp_enc_engine = eng_ciph_evp;
 167 }
 168
 169 # else
 170
 171 #  define do_engine_finish ENGINE_finish
 172
 173 static int do_evp_enc_engine(EVP_CIPHER_CTX *ctx, const EVP_CIPHER **pcipher,
 174                              ENGINE *impl)
 175 {
 176     if (impl) {
 177         if (!ENGINE_init(impl)) {
 178             EVPerr(EVP_F_DO_EVP_ENC_ENGINE, EVP_R_INITIALIZATION_ERROR);
 179             return 0;
 180         }
 181     } else
 182         /* Ask if an ENGINE is reserved for this job */
 183         impl = ENGINE_get_cipher_engine((*pcipher)->nid);
 184     if (impl) {
 185         /* There's an ENGINE for this job ... (apparently) */
 186         const EVP_CIPHER *c = ENGINE_get_cipher(impl, (*pcipher)->nid);
 187         if (!c) {
 188             /*
 189              * One positive side-effect of US's export control history, is
 190              * that we should at least be able to avoid using US mispellings
 191              * of "initialisation"?
 192              */
 193             EVPerr(EVP_F_DO_EVP_ENC_ENGINE, EVP_R_INITIALIZATION_ERROR);
 194             return 0;
 195         }
 196         /* We'll use the ENGINE's private cipher definition */
 197         *pcipher = c;
 198         /*
 199          * Store the ENGINE functional reference so we know 'cipher' came
 200          * from an ENGINE and we need to release it when done.
 201          */
 202         ctx->engine = impl;
 203     } else
 204         ctx->engine = NULL;
 205     return 1;
 206 }
 207
 208 # endif
 209
 210 #endif
 211
 212 int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 213                       ENGINE *impl, const unsigned char *key,
 214                       const unsigned char *iv, int enc)
 215 {
 216     if (enc == -1)
 217         enc = ctx->encrypt;
 218     else {
 219         if (enc)
 220             enc = 1;
 221         ctx->encrypt = enc;
 222     }
 223 #ifdef OPENSSL_FIPS
 224     if (FIPS_selftest_failed()) {
 225         FIPSerr(FIPS_F_EVP_CIPHERINIT_EX, FIPS_R_FIPS_SELFTEST_FAILED);
 226         ctx->cipher = &bad_cipher;
 227         return 0;
 228     }
 229 #endif
 230 #ifndef OPENSSL_NO_ENGINE
 231     /*
 232      * Whether it's nice or not, "Inits" can be used on "Final"'d contexts so
 233      * this context may already have an ENGINE! Try to avoid releasing the
 234      * previous handle, re-querying for an ENGINE, and having a
 235      * reinitialisation, when it may all be unecessary.
 236      */
 237     if (ctx->engine && ctx->cipher && (!cipher ||
 238                                        (cipher
 239                                         && (cipher->nid ==
 240                                             ctx->cipher->nid))))
 241         goto skip_to_init;
 242 #endif
 243     if (cipher) {
 244         /*
 245          * Ensure a context left lying around from last time is cleared (the
 246          * previous check attempted to avoid this if the same ENGINE and
 247          * EVP_CIPHER could be used).
 248          */
 249         EVP_CIPHER_CTX_cleanup(ctx);
 250
 251         /* Restore encrypt field: it is zeroed by cleanup */
 252         ctx->encrypt = enc;
 253 #ifndef OPENSSL_NO_ENGINE
 254         if (!do_evp_enc_engine(ctx, &cipher, impl))
 255             return 0;
 256 #endif
 257
 258         ctx->cipher = cipher;
 259         if (ctx->cipher->ctx_size) {
 260             ctx->cipher_data = OPENSSL_malloc(ctx->cipher->ctx_size);
 261             if (!ctx->cipher_data) {
 262                 EVPerr(EVP_F_EVP_CIPHERINIT_EX, ERR_R_MALLOC_FAILURE);
 263                 return 0;
 264             }
 265         } else {
 266             ctx->cipher_data = NULL;
 267         }
 268         ctx->key_len = cipher->key_len;
 269         ctx->flags = 0;
 270         if (ctx->cipher->flags & EVP_CIPH_CTRL_INIT) {
 271             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) {
 272                 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
 273                 return 0;
 274             }
 275         }
 276     } else if (!ctx->cipher) {
 277         EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_NO_CIPHER_SET);
 278         return 0;
 279     }
 280 #ifndef OPENSSL_NO_ENGINE
 281  skip_to_init:
 282 #endif
 283     /* we assume block size is a power of 2 in *cryptUpdate */
 284     OPENSSL_assert(ctx->cipher->block_size == 1
 285                    || ctx->cipher->block_size == 8
 286                    || ctx->cipher->block_size == 16);
 287
 288     if (!(EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_CUSTOM_IV)) {
 289         switch (EVP_CIPHER_CTX_mode(ctx)) {
 290
 291         case EVP_CIPH_STREAM_CIPHER:
 292         case EVP_CIPH_ECB_MODE:
 293             break;
 294
 295         case EVP_CIPH_CFB_MODE:
 296         case EVP_CIPH_OFB_MODE:
 297
 298             ctx->num = 0;
 299             /* fall-through */
 300
 301         case EVP_CIPH_CBC_MODE:
 302
 303             OPENSSL_assert(EVP_CIPHER_CTX_iv_length(ctx) <=
 304                            (int)sizeof(ctx->iv));
 305             if (iv)
 306                 memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
 307             memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));
 308             break;
 309
 310         default:
 311             return 0;
 312             break;
 313         }
 314     }
 315 #ifdef OPENSSL_FIPS
 316     /*
 317      * After 'key' is set no further parameters changes are permissible. So
 318      * only check for non FIPS enabling at this point.
 319      */
 320     if (key && FIPS_mode()) {
 321         if (!(ctx->cipher->flags & EVP_CIPH_FLAG_FIPS)
 322             & !(ctx->flags & EVP_CIPH_FLAG_NON_FIPS_ALLOW)) {
 323             EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_DISABLED_FOR_FIPS);
 324 # if 0
 325             ERR_add_error_data(2, "cipher=", EVP_CIPHER_name(ctx->cipher));
 326 # endif
 327             ctx->cipher = &bad_cipher;
 328             return 0;
 329         }
 330     }
 331 #endif
 332
 333     if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) {
 334         if (!ctx->cipher->init(ctx, key, iv, enc))
 335             return 0;
 336     }
 337     ctx->buf_len = 0;
 338     ctx->final_used = 0;
 339     ctx->block_mask = ctx->cipher->block_size - 1;
 340     return 1;
 341 }
 342
 343 int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c)
 344 {
 345     if (c->cipher != NULL) {
 346         if (c->cipher->cleanup && !c->cipher->cleanup(c))
 347             return 0;
 348         /* Cleanse cipher context data */
 349         if (c->cipher_data)
 350             OPENSSL_cleanse(c->cipher_data, c->cipher->ctx_size);
 351     }
 352     if (c->cipher_data)
 353         OPENSSL_free(c->cipher_data);
 354 #ifndef OPENSSL_NO_ENGINE
 355     if (c->engine)
 356         /*
 357          * The EVP_CIPHER we used belongs to an ENGINE, release the
 358          * functional reference we held for this reason.
 359          */
 360         do_engine_finish(c->engine);
 361 #endif
 362     memset(c, 0, sizeof(EVP_CIPHER_CTX));
 363     return 1;
 364 }
 365
 366 int EVP_Cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 367                const unsigned char *in, unsigned int inl)
 368 {
 369 #ifdef OPENSSL_FIPS
 370     FIPS_selftest_check();
 371 #endif
 372     return ctx->cipher->do_cipher(ctx, out, in, inl);
 373 }
 374
 375 int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
 376 {
 377     int ret;
 378     if (!ctx->cipher) {
 379         EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET);
 380         return 0;
 381     }
 382
 383     if (!ctx->cipher->ctrl) {
 384         EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED);
 385         return 0;
 386     }
 387
 388     ret = ctx->cipher->ctrl(ctx, type, arg, ptr);
 389     if (ret == -1) {
 390         EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL,
 391                EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED);
 392         return 0;
 393     }
 394     return ret;
 395 }
 396
 397 unsigned long EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)
 398 {
 399     return ctx->cipher->flags;
 400 }
 401
 402 int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
 403 {
 404     return ctx->cipher->iv_len;
 405 }
 406
 407 int EVP_CIPHER_nid(const EVP_CIPHER *cipher)
 408 {
 409     return cipher->nid;
 410 }