crypto/evp/e_des3.c

   1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   2  * All rights reserved.
   3  *
   4  * This package is an SSL implementation written
   5  * by Eric Young (eay@cryptsoft.com).
   6  * The implementation was written so as to conform with Netscapes SSL.
   7  *
   8  * This library is free for commercial and non-commercial use as long as
   9  * the following conditions are aheared to.  The following conditions
  10  * apply to all code found in this distribution, be it the RC4, RSA,
  11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  12  * included with this distribution is covered by the same copyright terms
  13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  14  *
  15  * Copyright remains Eric Young's, and as such any Copyright notices in
  16  * the code are not to be removed.
  17  * If this package is used in a product, Eric Young should be given attribution
  18  * as the author of the parts of the library used.
  19  * This can be in the form of a textual message at program startup or
  20  * in documentation (online or textual) provided with the package.
  21  *
  22  * Redistribution and use in source and binary forms, with or without
  23  * modification, are permitted provided that the following conditions
  24  * are met:
  25  * 1. Redistributions of source code must retain the copyright
  26  *    notice, this list of conditions and the following disclaimer.
  27  * 2. Redistributions in binary form must reproduce the above copyright
  28  *    notice, this list of conditions and the following disclaimer in the
  29  *    documentation and/or other materials provided with the distribution.
  30  * 3. All advertising materials mentioning features or use of this software
  31  *    must display the following acknowledgement:
  32  *    "This product includes cryptographic software written by
  33  *     Eric Young (eay@cryptsoft.com)"
  34  *    The word 'cryptographic' can be left out if the rouines from the library
  35  *    being used are not cryptographic related :-).
  36  * 4. If you include any Windows specific code (or a derivative thereof) from
  37  *    the apps directory (application code) you must include an acknowledgement:
  38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  50  * SUCH DAMAGE.
  51  *
  52  * The licence and distribution terms for any publically available version or
  53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  54  * copied and put under another distribution licence
  55  * [including the GNU Public Licence.]
  56  */
  57
  58 #include <stdio.h>
  59 #include "internal/cryptlib.h"
  60 #ifndef OPENSSL_NO_DES
  61 # include <openssl/evp.h>
  62 # include <openssl/objects.h>
  63 # include "internal/evp_int.h"
  64 # include <openssl/des.h>
  65 # include <openssl/rand.h>
  66
  67 typedef struct {
  68     union {
  69         double align;
  70         DES_key_schedule ks[3];
  71     } ks;
  72     union {
  73         void (*cbc) (const void *, void *, size_t, const void *, void *);
  74     } stream;
  75 } DES_EDE_KEY;
  76 # define ks1 ks.ks[0]
  77 # define ks2 ks.ks[1]
  78 # define ks3 ks.ks[2]
  79
  80 # if defined(AES_ASM) && (defined(__sparc) || defined(__sparc__))
  81 /* ---------^^^ this is not a typo, just a way to detect that
  82  * assembler support was in general requested... */
  83 #  include "sparc_arch.h"
  84
  85 extern unsigned int OPENSSL_sparcv9cap_P[];
  86
  87 #  define SPARC_DES_CAPABLE       (OPENSSL_sparcv9cap_P[1] & CFR_DES)
  88
  89 void des_t4_key_expand(const void *key, DES_key_schedule *ks);
  90 void des_t4_ede3_cbc_encrypt(const void *inp, void *out, size_t len,
  91                              DES_key_schedule *ks, unsigned char iv[8]);
  92 void des_t4_ede3_cbc_decrypt(const void *inp, void *out, size_t len,
  93                              DES_key_schedule *ks, unsigned char iv[8]);
  94 # endif
  95
  96 static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
  97                             const unsigned char *iv, int enc);
  98
  99 static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 100                              const unsigned char *iv, int enc);
 101
 102 static int des3_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr);
 103
 104 # define data(ctx) EVP_C_DATA(DES_EDE_KEY,ctx)
 105
 106 /*
 107  * Because of various casts and different args can't use
 108  * IMPLEMENT_BLOCK_CIPHER
 109  */
 110
 111 static int des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 112                               const unsigned char *in, size_t inl)
 113 {
 114     BLOCK_CIPHER_ecb_loop()
 115         DES_ecb3_encrypt((const_DES_cblock *)(in + i),
 116                          (DES_cblock *)(out + i),
 117                          &data(ctx)->ks1, &data(ctx)->ks2,
 118                          &data(ctx)->ks3, EVP_CIPHER_CTX_encrypting(ctx));
 119     return 1;
 120 }
 121
 122 static int des_ede_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 123                               const unsigned char *in, size_t inl)
 124 {
 125     while (inl >= EVP_MAXCHUNK) {
 126         int num = EVP_CIPHER_CTX_num(ctx);
 127         DES_ede3_ofb64_encrypt(in, out, (long)EVP_MAXCHUNK,
 128                                &data(ctx)->ks1, &data(ctx)->ks2,
 129                                &data(ctx)->ks3,
 130                                (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 131                                &num);
 132         EVP_CIPHER_CTX_set_num(ctx, num);
 133         inl -= EVP_MAXCHUNK;
 134         in += EVP_MAXCHUNK;
 135         out += EVP_MAXCHUNK;
 136     }
 137     if (inl) {
 138         int num = EVP_CIPHER_CTX_num(ctx);
 139         DES_ede3_ofb64_encrypt(in, out, (long)inl,
 140                                &data(ctx)->ks1, &data(ctx)->ks2,
 141                                &data(ctx)->ks3,
 142                                (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 143                                &num);
 144         EVP_CIPHER_CTX_set_num(ctx, num);
 145     }
 146     return 1;
 147 }
 148
 149 static int des_ede_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 150                               const unsigned char *in, size_t inl)
 151 {
 152     DES_EDE_KEY *dat = data(ctx);
 153
 154     if (dat->stream.cbc) {
 155         (*dat->stream.cbc) (in, out, inl, &dat->ks, EVP_CIPHER_CTX_iv_noconst(ctx));
 156         return 1;
 157     }
 158
 159     while (inl >= EVP_MAXCHUNK) {
 160         DES_ede3_cbc_encrypt(in, out, (long)EVP_MAXCHUNK,
 161                              &dat->ks1, &dat->ks2, &dat->ks3,
 162                              (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx), EVP_CIPHER_CTX_encrypting(ctx));
 163         inl -= EVP_MAXCHUNK;
 164         in += EVP_MAXCHUNK;
 165         out += EVP_MAXCHUNK;
 166     }
 167     if (inl)
 168         DES_ede3_cbc_encrypt(in, out, (long)inl,
 169                              &dat->ks1, &dat->ks2, &dat->ks3,
 170                              (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx), EVP_CIPHER_CTX_encrypting(ctx));
 171     return 1;
 172 }
 173
 174 static int des_ede_cfb64_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 175                                 const unsigned char *in, size_t inl)
 176 {
 177     while (inl >= EVP_MAXCHUNK) {
 178         int num = EVP_CIPHER_CTX_num(ctx);
 179         DES_ede3_cfb64_encrypt(in, out, (long)EVP_MAXCHUNK,
 180                                &data(ctx)->ks1, &data(ctx)->ks2,
 181                                &data(ctx)->ks3,
 182                                (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 183                                &num, EVP_CIPHER_CTX_encrypting(ctx));
 184         EVP_CIPHER_CTX_set_num(ctx, num);
 185         inl -= EVP_MAXCHUNK;
 186         in += EVP_MAXCHUNK;
 187         out += EVP_MAXCHUNK;
 188     }
 189     if (inl) {
 190         int num = EVP_CIPHER_CTX_num(ctx);
 191         DES_ede3_cfb64_encrypt(in, out, (long)inl,
 192                                &data(ctx)->ks1, &data(ctx)->ks2,
 193                                &data(ctx)->ks3,
 194                                (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 195                                &num, EVP_CIPHER_CTX_encrypting(ctx));
 196         EVP_CIPHER_CTX_set_num(ctx, num);
 197     }
 198     return 1;
 199 }
 200
 201 /*
 202  * Although we have a CFB-r implementation for 3-DES, it doesn't pack the
 203  * right way, so wrap it here
 204  */
 205 static int des_ede3_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 206                                 const unsigned char *in, size_t inl)
 207 {
 208     size_t n;
 209     unsigned char c[1], d[1];
 210
 211     for (n = 0; n < inl; ++n) {
 212         c[0] = (in[n / 8] & (1 << (7 - n % 8))) ? 0x80 : 0;
 213         DES_ede3_cfb_encrypt(c, d, 1, 1,
 214                              &data(ctx)->ks1, &data(ctx)->ks2,
 215                              &data(ctx)->ks3, (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 216                              EVP_CIPHER_CTX_encrypting(ctx));
 217         out[n / 8] = (out[n / 8] & ~(0x80 >> (unsigned int)(n % 8)))
 218             | ((d[0] & 0x80) >> (unsigned int)(n % 8));
 219     }
 220
 221     return 1;
 222 }
 223
 224 static int des_ede3_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 225                                 const unsigned char *in, size_t inl)
 226 {
 227     while (inl >= EVP_MAXCHUNK) {
 228         DES_ede3_cfb_encrypt(in, out, 8, (long)EVP_MAXCHUNK,
 229                              &data(ctx)->ks1, &data(ctx)->ks2,
 230                              &data(ctx)->ks3, (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 231                              EVP_CIPHER_CTX_encrypting(ctx));
 232         inl -= EVP_MAXCHUNK;
 233         in += EVP_MAXCHUNK;
 234         out += EVP_MAXCHUNK;
 235     }
 236     if (inl)
 237         DES_ede3_cfb_encrypt(in, out, 8, (long)inl,
 238                              &data(ctx)->ks1, &data(ctx)->ks2,
 239                              &data(ctx)->ks3, (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 240                              EVP_CIPHER_CTX_encrypting(ctx));
 241     return 1;
 242 }
 243
 244 BLOCK_CIPHER_defs(des_ede, DES_EDE_KEY, NID_des_ede, 8, 16, 8, 64,
 245                   EVP_CIPH_RAND_KEY | EVP_CIPH_FLAG_DEFAULT_ASN1,
 246                   des_ede_init_key, NULL, NULL, NULL, des3_ctrl)
 247 # define des_ede3_cfb64_cipher des_ede_cfb64_cipher
 248 # define des_ede3_ofb_cipher des_ede_ofb_cipher
 249 # define des_ede3_cbc_cipher des_ede_cbc_cipher
 250 # define des_ede3_ecb_cipher des_ede_ecb_cipher
 251     BLOCK_CIPHER_defs(des_ede3, DES_EDE_KEY, NID_des_ede3, 8, 24, 8, 64,
 252                   EVP_CIPH_RAND_KEY | EVP_CIPH_FLAG_DEFAULT_ASN1,
 253                   des_ede3_init_key, NULL, NULL, NULL, des3_ctrl)
 254
 255     BLOCK_CIPHER_def_cfb(des_ede3, DES_EDE_KEY, NID_des_ede3, 24, 8, 1,
 256                      EVP_CIPH_RAND_KEY | EVP_CIPH_FLAG_DEFAULT_ASN1,
 257                      des_ede3_init_key, NULL, NULL, NULL, des3_ctrl)
 258
 259     BLOCK_CIPHER_def_cfb(des_ede3, DES_EDE_KEY, NID_des_ede3, 24, 8, 8,
 260                      EVP_CIPH_RAND_KEY | EVP_CIPH_FLAG_DEFAULT_ASN1,
 261                      des_ede3_init_key, NULL, NULL, NULL, des3_ctrl)
 262
 263 static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 264                             const unsigned char *iv, int enc)
 265 {
 266     DES_cblock *deskey = (DES_cblock *)key;
 267     DES_EDE_KEY *dat = data(ctx);
 268
 269     dat->stream.cbc = NULL;
 270 # if defined(SPARC_DES_CAPABLE)
 271     if (SPARC_DES_CAPABLE) {
 272         int mode = EVP_CIPHER_CTX_mode(ctx);
 273
 274         if (mode == EVP_CIPH_CBC_MODE) {
 275             des_t4_key_expand(&deskey[0], &dat->ks1);
 276             des_t4_key_expand(&deskey[1], &dat->ks2);
 277             memcpy(&dat->ks3, &dat->ks1, sizeof(dat->ks1));
 278             dat->stream.cbc = enc ? des_t4_ede3_cbc_encrypt :
 279                 des_t4_ede3_cbc_decrypt;
 280             return 1;
 281         }
 282     }
 283 # endif
 284     DES_set_key_unchecked(&deskey[0], &dat->ks1);
 285     DES_set_key_unchecked(&deskey[1], &dat->ks2);
 286     memcpy(&dat->ks3, &dat->ks1, sizeof(dat->ks1));
 287     return 1;
 288 }
 289
 290 static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 291                              const unsigned char *iv, int enc)
 292 {
 293     DES_cblock *deskey = (DES_cblock *)key;
 294     DES_EDE_KEY *dat = data(ctx);
 295
 296     dat->stream.cbc = NULL;
 297 # if defined(SPARC_DES_CAPABLE)
 298     if (SPARC_DES_CAPABLE) {
 299         int mode = EVP_CIPHER_CTX_mode(ctx);
 300
 301         if (mode == EVP_CIPH_CBC_MODE) {
 302             des_t4_key_expand(&deskey[0], &dat->ks1);
 303             des_t4_key_expand(&deskey[1], &dat->ks2);
 304             des_t4_key_expand(&deskey[2], &dat->ks3);
 305             dat->stream.cbc = enc ? des_t4_ede3_cbc_encrypt :
 306                 des_t4_ede3_cbc_decrypt;
 307             return 1;
 308         }
 309     }
 310 # endif
 311     DES_set_key_unchecked(&deskey[0], &dat->ks1);
 312     DES_set_key_unchecked(&deskey[1], &dat->ks2);
 313     DES_set_key_unchecked(&deskey[2], &dat->ks3);
 314     return 1;
 315 }
 316
 317 static int des3_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
 318 {
 319
 320     DES_cblock *deskey = ptr;
 321
 322     switch (type) {
 323     case EVP_CTRL_RAND_KEY:
 324         if (RAND_bytes(ptr, EVP_CIPHER_CTX_key_length(ctx)) <= 0)
 325             return 0;
 326         DES_set_odd_parity(deskey);
 327         if (EVP_CIPHER_CTX_key_length(ctx) >= 16)
 328             DES_set_odd_parity(deskey + 1);
 329         if (EVP_CIPHER_CTX_key_length(ctx) >= 24)
 330             DES_set_odd_parity(deskey + 2);
 331         return 1;
 332
 333     default:
 334         return -1;
 335     }
 336 }
 337
 338 const EVP_CIPHER *EVP_des_ede(void)
 339 {
 340     return &des_ede_ecb;
 341 }
 342
 343 const EVP_CIPHER *EVP_des_ede3(void)
 344 {
 345     return &des_ede3_ecb;
 346 }
 347
 348
 349 # include <openssl/sha.h>
 350
 351 static const unsigned char wrap_iv[8] =
 352     { 0x4a, 0xdd, 0xa2, 0x2c, 0x79, 0xe8, 0x21, 0x05 };
 353
 354 static int des_ede3_unwrap(EVP_CIPHER_CTX *ctx, unsigned char *out,
 355                            const unsigned char *in, size_t inl)
 356 {
 357     unsigned char icv[8], iv[8], sha1tmp[SHA_DIGEST_LENGTH];
 358     int rv = -1;
 359     if (inl < 24)
 360         return -1;
 361     if (!out)
 362         return inl - 16;
 363     memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), wrap_iv, 8);
 364     /* Decrypt first block which will end up as icv */
 365     des_ede_cbc_cipher(ctx, icv, in, 8);
 366     /* Decrypt central blocks */
 367     /*
 368      * If decrypting in place move whole output along a block so the next
 369      * des_ede_cbc_cipher is in place.
 370      */
 371     if (out == in) {
 372         memmove(out, out + 8, inl - 8);
 373         in -= 8;
 374     }
 375     des_ede_cbc_cipher(ctx, out, in + 8, inl - 16);
 376     /* Decrypt final block which will be IV */
 377     des_ede_cbc_cipher(ctx, iv, in + inl - 8, 8);
 378     /* Reverse order of everything */
 379     BUF_reverse(icv, NULL, 8);
 380     BUF_reverse(out, NULL, inl - 16);
 381     BUF_reverse(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 8);
 382     /* Decrypt again using new IV */
 383     des_ede_cbc_cipher(ctx, out, out, inl - 16);
 384     des_ede_cbc_cipher(ctx, icv, icv, 8);
 385     /* Work out SHA1 hash of first portion */
 386     SHA1(out, inl - 16, sha1tmp);
 387
 388     if (!CRYPTO_memcmp(sha1tmp, icv, 8))
 389         rv = inl - 16;
 390     OPENSSL_cleanse(icv, 8);
 391     OPENSSL_cleanse(sha1tmp, SHA_DIGEST_LENGTH);
 392     OPENSSL_cleanse(iv, 8);
 393     OPENSSL_cleanse(EVP_CIPHER_CTX_iv_noconst(ctx), 8);
 394     if (rv == -1)
 395         OPENSSL_cleanse(out, inl - 16);
 396
 397     return rv;
 398 }
 399
 400 static int des_ede3_wrap(EVP_CIPHER_CTX *ctx, unsigned char *out,
 401                          const unsigned char *in, size_t inl)
 402 {
 403     unsigned char sha1tmp[SHA_DIGEST_LENGTH];
 404     if (!out)
 405         return inl + 16;
 406     /* Copy input to output buffer + 8 so we have space for IV */
 407     memmove(out + 8, in, inl);
 408     /* Work out ICV */
 409     SHA1(in, inl, sha1tmp);
 410     memcpy(out + inl + 8, sha1tmp, 8);
 411     OPENSSL_cleanse(sha1tmp, SHA_DIGEST_LENGTH);
 412     /* Generate random IV */
 413     if (RAND_bytes(EVP_CIPHER_CTX_iv_noconst(ctx), 8) <= 0)
 414         return -1;
 415     memcpy(out, EVP_CIPHER_CTX_iv_noconst(ctx), 8);
 416     /* Encrypt everything after IV in place */
 417     des_ede_cbc_cipher(ctx, out + 8, out + 8, inl + 8);
 418     BUF_reverse(out, NULL, inl + 16);
 419     memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), wrap_iv, 8);
 420     des_ede_cbc_cipher(ctx, out, out, inl + 16);
 421     return inl + 16;
 422 }
 423
 424 static int des_ede3_wrap_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 425                                 const unsigned char *in, size_t inl)
 426 {
 427     /*
 428      * Sanity check input length: we typically only wrap keys so EVP_MAXCHUNK
 429      * is more than will ever be needed. Also input length must be a multiple
 430      * of 8 bits.
 431      */
 432     if (inl >= EVP_MAXCHUNK || inl % 8)
 433         return -1;
 434     if (EVP_CIPHER_CTX_encrypting(ctx))
 435         return des_ede3_wrap(ctx, out, in, inl);
 436     else
 437         return des_ede3_unwrap(ctx, out, in, inl);
 438 }
 439
 440 static const EVP_CIPHER des3_wrap = {
 441     NID_id_smime_alg_CMS3DESwrap,
 442     8, 24, 0,
 443     EVP_CIPH_WRAP_MODE | EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER
 444         | EVP_CIPH_FLAG_DEFAULT_ASN1,
 445     des_ede3_init_key, des_ede3_wrap_cipher,
 446     NULL,
 447     sizeof(DES_EDE_KEY),
 448     NULL, NULL, NULL, NULL
 449 };
 450
 451 const EVP_CIPHER *EVP_des_ede3_wrap(void)
 452 {
 453     return &des3_wrap;
 454 }
 455
 456 #endif