crypto/evp/e_des3.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (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 <stdio.h>
  11 #include "internal/cryptlib.h"
  12 #ifndef OPENSSL_NO_DES
  13 # include <openssl/evp.h>
  14 # include <openssl/objects.h>
  15 # include "internal/evp_int.h"
  16 # include <openssl/des.h>
  17 # include <openssl/rand.h>
  18 # include <openssl/rand_drbg.h>
  19 # include "evp_locl.h"
  20
  21 typedef struct {
  22     union {
  23         double align;
  24         DES_key_schedule ks[3];
  25     } ks;
  26     union {
  27         void (*cbc) (const void *, void *, size_t,
  28                      const DES_key_schedule *, unsigned char *);
  29     } stream;
  30 } DES_EDE_KEY;
  31 # define ks1 ks.ks[0]
  32 # define ks2 ks.ks[1]
  33 # define ks3 ks.ks[2]
  34
  35 # if defined(AES_ASM) && (defined(__sparc) || defined(__sparc__))
  36 /* ---------^^^ this is not a typo, just a way to detect that
  37  * assembler support was in general requested... */
  38 #  include "sparc_arch.h"
  39
  40 extern unsigned int OPENSSL_sparcv9cap_P[];
  41
  42 #  define SPARC_DES_CAPABLE       (OPENSSL_sparcv9cap_P[1] & CFR_DES)
  43
  44 void des_t4_key_expand(const void *key, DES_key_schedule *ks);
  45 void des_t4_ede3_cbc_encrypt(const void *inp, void *out, size_t len,
  46                              const DES_key_schedule ks[3], unsigned char iv[8]);
  47 void des_t4_ede3_cbc_decrypt(const void *inp, void *out, size_t len,
  48                              const DES_key_schedule ks[3], unsigned char iv[8]);
  49 # endif
  50
  51 static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
  52                             const unsigned char *iv, int enc);
  53
  54 static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
  55                              const unsigned char *iv, int enc);
  56
  57 static int des3_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr);
  58
  59 # define data(ctx) EVP_C_DATA(DES_EDE_KEY,ctx)
  60
  61 /*
  62  * Because of various casts and different args can't use
  63  * IMPLEMENT_BLOCK_CIPHER
  64  */
  65
  66 static int des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
  67                               const unsigned char *in, size_t inl)
  68 {
  69     BLOCK_CIPHER_ecb_loop()
  70         DES_ecb3_encrypt((const_DES_cblock *)(in + i),
  71                          (DES_cblock *)(out + i),
  72                          &data(ctx)->ks1, &data(ctx)->ks2,
  73                          &data(ctx)->ks3, EVP_CIPHER_CTX_encrypting(ctx));
  74     return 1;
  75 }
  76
  77 static int des_ede_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
  78                               const unsigned char *in, size_t inl)
  79 {
  80     while (inl >= EVP_MAXCHUNK) {
  81         int num = EVP_CIPHER_CTX_num(ctx);
  82         DES_ede3_ofb64_encrypt(in, out, (long)EVP_MAXCHUNK,
  83                                &data(ctx)->ks1, &data(ctx)->ks2,
  84                                &data(ctx)->ks3,
  85                                (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
  86                                &num);
  87         EVP_CIPHER_CTX_set_num(ctx, num);
  88         inl -= EVP_MAXCHUNK;
  89         in += EVP_MAXCHUNK;
  90         out += EVP_MAXCHUNK;
  91     }
  92     if (inl) {
  93         int num = EVP_CIPHER_CTX_num(ctx);
  94         DES_ede3_ofb64_encrypt(in, out, (long)inl,
  95                                &data(ctx)->ks1, &data(ctx)->ks2,
  96                                &data(ctx)->ks3,
  97                                (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
  98                                &num);
  99         EVP_CIPHER_CTX_set_num(ctx, num);
 100     }
 101     return 1;
 102 }
 103
 104 static int des_ede_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 105                               const unsigned char *in, size_t inl)
 106 {
 107     DES_EDE_KEY *dat = data(ctx);
 108
 109     if (dat->stream.cbc != NULL) {
 110         (*dat->stream.cbc) (in, out, inl, dat->ks.ks,
 111                             EVP_CIPHER_CTX_iv_noconst(ctx));
 112         return 1;
 113     }
 114
 115     while (inl >= EVP_MAXCHUNK) {
 116         DES_ede3_cbc_encrypt(in, out, (long)EVP_MAXCHUNK,
 117                              &dat->ks1, &dat->ks2, &dat->ks3,
 118                              (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 119                              EVP_CIPHER_CTX_encrypting(ctx));
 120         inl -= EVP_MAXCHUNK;
 121         in += EVP_MAXCHUNK;
 122         out += EVP_MAXCHUNK;
 123     }
 124     if (inl)
 125         DES_ede3_cbc_encrypt(in, out, (long)inl,
 126                              &dat->ks1, &dat->ks2, &dat->ks3,
 127                              (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 128                              EVP_CIPHER_CTX_encrypting(ctx));
 129     return 1;
 130 }
 131
 132 static int des_ede_cfb64_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 133                                 const unsigned char *in, size_t inl)
 134 {
 135     while (inl >= EVP_MAXCHUNK) {
 136         int num = EVP_CIPHER_CTX_num(ctx);
 137         DES_ede3_cfb64_encrypt(in, out, (long)EVP_MAXCHUNK,
 138                                &data(ctx)->ks1, &data(ctx)->ks2,
 139                                &data(ctx)->ks3,
 140                                (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 141                                &num, EVP_CIPHER_CTX_encrypting(ctx));
 142         EVP_CIPHER_CTX_set_num(ctx, num);
 143         inl -= EVP_MAXCHUNK;
 144         in += EVP_MAXCHUNK;
 145         out += EVP_MAXCHUNK;
 146     }
 147     if (inl) {
 148         int num = EVP_CIPHER_CTX_num(ctx);
 149         DES_ede3_cfb64_encrypt(in, out, (long)inl,
 150                                &data(ctx)->ks1, &data(ctx)->ks2,
 151                                &data(ctx)->ks3,
 152                                (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 153                                &num, EVP_CIPHER_CTX_encrypting(ctx));
 154         EVP_CIPHER_CTX_set_num(ctx, num);
 155     }
 156     return 1;
 157 }
 158
 159 /*
 160  * Although we have a CFB-r implementation for 3-DES, it doesn't pack the
 161  * right way, so wrap it here
 162  */
 163 static int des_ede3_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 164                                 const unsigned char *in, size_t inl)
 165 {
 166     size_t n;
 167     unsigned char c[1], d[1];
 168
 169     if (!EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS))
 170             inl *= 8;
 171     for (n = 0; n < inl; ++n) {
 172         c[0] = (in[n / 8] & (1 << (7 - n % 8))) ? 0x80 : 0;
 173         DES_ede3_cfb_encrypt(c, d, 1, 1,
 174                              &data(ctx)->ks1, &data(ctx)->ks2,
 175                              &data(ctx)->ks3,
 176                              (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 177                              EVP_CIPHER_CTX_encrypting(ctx));
 178         out[n / 8] = (out[n / 8] & ~(0x80 >> (unsigned int)(n % 8)))
 179             | ((d[0] & 0x80) >> (unsigned int)(n % 8));
 180     }
 181
 182     return 1;
 183 }
 184
 185 static int des_ede3_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 186                                 const unsigned char *in, size_t inl)
 187 {
 188     while (inl >= EVP_MAXCHUNK) {
 189         DES_ede3_cfb_encrypt(in, out, 8, (long)EVP_MAXCHUNK,
 190                              &data(ctx)->ks1, &data(ctx)->ks2,
 191                              &data(ctx)->ks3,
 192                              (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 193                              EVP_CIPHER_CTX_encrypting(ctx));
 194         inl -= EVP_MAXCHUNK;
 195         in += EVP_MAXCHUNK;
 196         out += EVP_MAXCHUNK;
 197     }
 198     if (inl)
 199         DES_ede3_cfb_encrypt(in, out, 8, (long)inl,
 200                              &data(ctx)->ks1, &data(ctx)->ks2,
 201                              &data(ctx)->ks3,
 202                              (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
 203                              EVP_CIPHER_CTX_encrypting(ctx));
 204     return 1;
 205 }
 206
 207 BLOCK_CIPHER_defs(des_ede, DES_EDE_KEY, NID_des_ede, 8, 16, 8, 64,
 208                   EVP_CIPH_RAND_KEY | EVP_CIPH_FLAG_DEFAULT_ASN1,
 209                   des_ede_init_key, NULL, NULL, NULL, des3_ctrl)
 210 # define des_ede3_cfb64_cipher des_ede_cfb64_cipher
 211 # define des_ede3_ofb_cipher des_ede_ofb_cipher
 212 # define des_ede3_cbc_cipher des_ede_cbc_cipher
 213 # define des_ede3_ecb_cipher des_ede_ecb_cipher
 214     BLOCK_CIPHER_defs(des_ede3, DES_EDE_KEY, NID_des_ede3, 8, 24, 8, 64,
 215                   EVP_CIPH_RAND_KEY | EVP_CIPH_FLAG_DEFAULT_ASN1,
 216                   des_ede3_init_key, NULL, NULL, NULL, des3_ctrl)
 217
 218     BLOCK_CIPHER_def_cfb(des_ede3, DES_EDE_KEY, NID_des_ede3, 24, 8, 1,
 219                      EVP_CIPH_RAND_KEY | EVP_CIPH_FLAG_DEFAULT_ASN1,
 220                      des_ede3_init_key, NULL, NULL, NULL, des3_ctrl)
 221
 222     BLOCK_CIPHER_def_cfb(des_ede3, DES_EDE_KEY, NID_des_ede3, 24, 8, 8,
 223                      EVP_CIPH_RAND_KEY | EVP_CIPH_FLAG_DEFAULT_ASN1,
 224                      des_ede3_init_key, NULL, NULL, NULL, des3_ctrl)
 225
 226 static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 227                             const unsigned char *iv, int enc)
 228 {
 229     DES_cblock *deskey = (DES_cblock *)key;
 230     DES_EDE_KEY *dat = data(ctx);
 231
 232     dat->stream.cbc = NULL;
 233 # if defined(SPARC_DES_CAPABLE)
 234     if (SPARC_DES_CAPABLE) {
 235         int mode = EVP_CIPHER_CTX_mode(ctx);
 236
 237         if (mode == EVP_CIPH_CBC_MODE) {
 238             des_t4_key_expand(&deskey[0], &dat->ks1);
 239             des_t4_key_expand(&deskey[1], &dat->ks2);
 240             memcpy(&dat->ks3, &dat->ks1, sizeof(dat->ks1));
 241             dat->stream.cbc = enc ? des_t4_ede3_cbc_encrypt :
 242                 des_t4_ede3_cbc_decrypt;
 243             return 1;
 244         }
 245     }
 246 # endif
 247     DES_set_key_unchecked(&deskey[0], &dat->ks1);
 248     DES_set_key_unchecked(&deskey[1], &dat->ks2);
 249     memcpy(&dat->ks3, &dat->ks1, sizeof(dat->ks1));
 250     return 1;
 251 }
 252
 253 static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 254                              const unsigned char *iv, int enc)
 255 {
 256     DES_cblock *deskey = (DES_cblock *)key;
 257     DES_EDE_KEY *dat = data(ctx);
 258
 259     dat->stream.cbc = NULL;
 260 # if defined(SPARC_DES_CAPABLE)
 261     if (SPARC_DES_CAPABLE) {
 262         int mode = EVP_CIPHER_CTX_mode(ctx);
 263
 264         if (mode == EVP_CIPH_CBC_MODE) {
 265             des_t4_key_expand(&deskey[0], &dat->ks1);
 266             des_t4_key_expand(&deskey[1], &dat->ks2);
 267             des_t4_key_expand(&deskey[2], &dat->ks3);
 268             dat->stream.cbc = enc ? des_t4_ede3_cbc_encrypt :
 269                 des_t4_ede3_cbc_decrypt;
 270             return 1;
 271         }
 272     }
 273 # endif
 274     DES_set_key_unchecked(&deskey[0], &dat->ks1);
 275     DES_set_key_unchecked(&deskey[1], &dat->ks2);
 276     DES_set_key_unchecked(&deskey[2], &dat->ks3);
 277     return 1;
 278 }
 279
 280 static int des3_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
 281 {
 282
 283     DES_cblock *deskey = ptr;
 284
 285     switch (type) {
 286     case EVP_CTRL_RAND_KEY:
 287         if (ctx->drbg != NULL) {
 288             if (RAND_DRBG_bytes(ctx->drbg, ptr, EVP_CIPHER_CTX_key_length(ctx)) == 0)
 289                 return 0;
 290         } else if (RAND_bytes(ptr, EVP_CIPHER_CTX_key_length(ctx)) <= 0) {
 291             return 0;
 292         }
 293         DES_set_odd_parity(deskey);
 294         if (EVP_CIPHER_CTX_key_length(ctx) >= 16)
 295             DES_set_odd_parity(deskey + 1);
 296         if (EVP_CIPHER_CTX_key_length(ctx) >= 24)
 297             DES_set_odd_parity(deskey + 2);
 298         return 1;
 299
 300     default:
 301         return -1;
 302     }
 303 }
 304
 305 const EVP_CIPHER *EVP_des_ede(void)
 306 {
 307     return &des_ede_ecb;
 308 }
 309
 310 const EVP_CIPHER *EVP_des_ede3(void)
 311 {
 312     return &des_ede3_ecb;
 313 }
 314
 315
 316 # include <openssl/sha.h>
 317
 318 static const unsigned char wrap_iv[8] =
 319     { 0x4a, 0xdd, 0xa2, 0x2c, 0x79, 0xe8, 0x21, 0x05 };
 320
 321 static int des_ede3_unwrap(EVP_CIPHER_CTX *ctx, unsigned char *out,
 322                            const unsigned char *in, size_t inl)
 323 {
 324     unsigned char icv[8], iv[8], sha1tmp[SHA_DIGEST_LENGTH];
 325     int rv = -1;
 326     if (inl < 24)
 327         return -1;
 328     if (out == NULL)
 329         return inl - 16;
 330     memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), wrap_iv, 8);
 331     /* Decrypt first block which will end up as icv */
 332     des_ede_cbc_cipher(ctx, icv, in, 8);
 333     /* Decrypt central blocks */
 334     /*
 335      * If decrypting in place move whole output along a block so the next
 336      * des_ede_cbc_cipher is in place.
 337      */
 338     if (out == in) {
 339         memmove(out, out + 8, inl - 8);
 340         in -= 8;
 341     }
 342     des_ede_cbc_cipher(ctx, out, in + 8, inl - 16);
 343     /* Decrypt final block which will be IV */
 344     des_ede_cbc_cipher(ctx, iv, in + inl - 8, 8);
 345     /* Reverse order of everything */
 346     BUF_reverse(icv, NULL, 8);
 347     BUF_reverse(out, NULL, inl - 16);
 348     BUF_reverse(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 8);
 349     /* Decrypt again using new IV */
 350     des_ede_cbc_cipher(ctx, out, out, inl - 16);
 351     des_ede_cbc_cipher(ctx, icv, icv, 8);
 352     /* Work out SHA1 hash of first portion */
 353     SHA1(out, inl - 16, sha1tmp);
 354
 355     if (!CRYPTO_memcmp(sha1tmp, icv, 8))
 356         rv = inl - 16;
 357     OPENSSL_cleanse(icv, 8);
 358     OPENSSL_cleanse(sha1tmp, SHA_DIGEST_LENGTH);
 359     OPENSSL_cleanse(iv, 8);
 360     OPENSSL_cleanse(EVP_CIPHER_CTX_iv_noconst(ctx), 8);
 361     if (rv == -1)
 362         OPENSSL_cleanse(out, inl - 16);
 363
 364     return rv;
 365 }
 366
 367 static int des_ede3_wrap(EVP_CIPHER_CTX *ctx, unsigned char *out,
 368                          const unsigned char *in, size_t inl)
 369 {
 370     unsigned char sha1tmp[SHA_DIGEST_LENGTH];
 371     if (out == NULL)
 372         return inl + 16;
 373     /* Copy input to output buffer + 8 so we have space for IV */
 374     memmove(out + 8, in, inl);
 375     /* Work out ICV */
 376     SHA1(in, inl, sha1tmp);
 377     memcpy(out + inl + 8, sha1tmp, 8);
 378     OPENSSL_cleanse(sha1tmp, SHA_DIGEST_LENGTH);
 379     /* Generate random IV */
 380     if (ctx->drbg != NULL) {
 381         if (RAND_DRBG_bytes(ctx->drbg, EVP_CIPHER_CTX_iv_noconst(ctx), 8) == 0)
 382             return -1;
 383     } else if (RAND_bytes(EVP_CIPHER_CTX_iv_noconst(ctx), 8) <= 0) {
 384         return -1;
 385     }
 386     memcpy(out, EVP_CIPHER_CTX_iv_noconst(ctx), 8);
 387     /* Encrypt everything after IV in place */
 388     des_ede_cbc_cipher(ctx, out + 8, out + 8, inl + 8);
 389     BUF_reverse(out, NULL, inl + 16);
 390     memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), wrap_iv, 8);
 391     des_ede_cbc_cipher(ctx, out, out, inl + 16);
 392     return inl + 16;
 393 }
 394
 395 static int des_ede3_wrap_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 396                                 const unsigned char *in, size_t inl)
 397 {
 398     /*
 399      * Sanity check input length: we typically only wrap keys so EVP_MAXCHUNK
 400      * is more than will ever be needed. Also input length must be a multiple
 401      * of 8 bits.
 402      */
 403     if (inl >= EVP_MAXCHUNK || inl % 8)
 404         return -1;
 405
 406     if (is_partially_overlapping(out, in, inl)) {
 407         EVPerr(EVP_F_DES_EDE3_WRAP_CIPHER, EVP_R_PARTIALLY_OVERLAPPING);
 408         return 0;
 409     }
 410
 411     if (EVP_CIPHER_CTX_encrypting(ctx))
 412         return des_ede3_wrap(ctx, out, in, inl);
 413     else
 414         return des_ede3_unwrap(ctx, out, in, inl);
 415 }
 416
 417 static const EVP_CIPHER des3_wrap = {
 418     NID_id_smime_alg_CMS3DESwrap,
 419     8, 24, 0,
 420     EVP_CIPH_WRAP_MODE | EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER
 421         | EVP_CIPH_FLAG_DEFAULT_ASN1,
 422     des_ede3_init_key, des_ede3_wrap_cipher,
 423     NULL,
 424     sizeof(DES_EDE_KEY),
 425     NULL, NULL, NULL, NULL
 426 };
 427
 428 const EVP_CIPHER *EVP_des_ede3_wrap(void)
 429 {
 430     return &des3_wrap;
 431 }
 432
 433 #endif