crypto/openssh/cipher.c

   1 /*
   2  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   3  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   4  *                    All rights reserved
   5  *
   6  * As far as I am concerned, the code I have written for this software
   7  * can be used freely for any purpose.  Any derived versions of this
   8  * software must be clearly marked as such, and if the derived work is
   9  * incompatible with the protocol description in the RFC file, it must be
  10  * called by a name other than "ssh" or "Secure Shell".
  11  *
  12  *
  13  * Copyright (c) 1999 Niels Provos.  All rights reserved.
  14  * Copyright (c) 1999, 2000 Markus Friedl.  All rights reserved.
  15  *
  16  * Redistribution and use in source and binary forms, with or without
  17  * modification, are permitted provided that the following conditions
  18  * are met:
  19  * 1. Redistributions of source code must retain the above copyright
  20  *    notice, this list of conditions and the following disclaimer.
  21  * 2. Redistributions in binary form must reproduce the above copyright
  22  *    notice, this list of conditions and the following disclaimer in the
  23  *    documentation and/or other materials provided with the distribution.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  26  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  27  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  28  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  29  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  31  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  34  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  */
  36
  37 #include "includes.h"
  38 RCSID("$OpenBSD: cipher.c,v 1.60 2002/06/23 03:26:52 deraadt Exp $");
  39 RCSID("$FreeBSD$");
  40
  41 #include "xmalloc.h"
  42 #include "log.h"
  43 #include "cipher.h"
  44
  45 #include <openssl/md5.h>
  46
  47 #if OPENSSL_VERSION_NUMBER < 0x00906000L
  48 #define SSH_OLD_EVP
  49 #define EVP_CIPHER_CTX_get_app_data(e)          ((e)->app_data)
  50 #endif
  51
  52 #if OPENSSL_VERSION_NUMBER < 0x00907000L
  53 #include "rijndael.h"
  54 static const EVP_CIPHER *evp_rijndael(void);
  55 #endif
  56 static const EVP_CIPHER *evp_ssh1_3des(void);
  57 static const EVP_CIPHER *evp_ssh1_bf(void);
  58
  59 struct Cipher {
  60         char    *name;
  61         int     number;         /* for ssh1 only */
  62         u_int   block_size;
  63         u_int   key_len;
  64         const EVP_CIPHER        *(*evptype)(void);
  65 } ciphers[] = {
  66         { "none",               SSH_CIPHER_NONE, 8, 0, EVP_enc_null },
  67         { "des",                SSH_CIPHER_DES, 8, 8, EVP_des_cbc },
  68         { "3des",               SSH_CIPHER_3DES, 8, 16, evp_ssh1_3des },
  69         { "blowfish",           SSH_CIPHER_BLOWFISH, 8, 32, evp_ssh1_bf },
  70
  71         { "3des-cbc",           SSH_CIPHER_SSH2, 8, 24, EVP_des_ede3_cbc },
  72         { "blowfish-cbc",       SSH_CIPHER_SSH2, 8, 16, EVP_bf_cbc },
  73         { "cast128-cbc",        SSH_CIPHER_SSH2, 8, 16, EVP_cast5_cbc },
  74         { "arcfour",            SSH_CIPHER_SSH2, 8, 16, EVP_rc4 },
  75 #if OPENSSL_VERSION_NUMBER < 0x00907000L
  76         { "aes128-cbc",         SSH_CIPHER_SSH2, 16, 16, evp_rijndael },
  77         { "aes192-cbc",         SSH_CIPHER_SSH2, 16, 24, evp_rijndael },
  78         { "aes256-cbc",         SSH_CIPHER_SSH2, 16, 32, evp_rijndael },
  79         { "rijndael-cbc@lysator.liu.se",
  80                                 SSH_CIPHER_SSH2, 16, 32, evp_rijndael },
  81 #else
  82         { "aes128-cbc",         SSH_CIPHER_SSH2, 16, 16, EVP_aes_128_cbc },
  83         { "aes192-cbc",         SSH_CIPHER_SSH2, 16, 24, EVP_aes_192_cbc },
  84         { "aes256-cbc",         SSH_CIPHER_SSH2, 16, 32, EVP_aes_256_cbc },
  85         { "rijndael-cbc@lysator.liu.se",
  86                                 SSH_CIPHER_SSH2, 16, 32, EVP_aes_256_cbc },
  87 #endif
  88
  89         { NULL,                 SSH_CIPHER_ILLEGAL, 0, 0, NULL }
  90 };
  91
  92 /*--*/
  93
  94 u_int
  95 cipher_blocksize(Cipher *c)
  96 {
  97         return (c->block_size);
  98 }
  99
 100 u_int
 101 cipher_keylen(Cipher *c)
 102 {
 103         return (c->key_len);
 104 }
 105
 106 u_int
 107 cipher_get_number(Cipher *c)
 108 {
 109         return (c->number);
 110 }
 111
 112 u_int
 113 cipher_mask_ssh1(int client)
 114 {
 115         u_int mask = 0;
 116         mask |= 1 << SSH_CIPHER_3DES;           /* Mandatory */
 117         mask |= 1 << SSH_CIPHER_BLOWFISH;
 118         if (client) {
 119                 mask |= 1 << SSH_CIPHER_DES;
 120         }
 121         return mask;
 122 }
 123
 124 Cipher *
 125 cipher_by_name(const char *name)
 126 {
 127         Cipher *c;
 128         for (c = ciphers; c->name != NULL; c++)
 129                 if (strcasecmp(c->name, name) == 0)
 130                         return c;
 131         return NULL;
 132 }
 133
 134 Cipher *
 135 cipher_by_number(int id)
 136 {
 137         Cipher *c;
 138         for (c = ciphers; c->name != NULL; c++)
 139                 if (c->number == id)
 140                         return c;
 141         return NULL;
 142 }
 143
 144 #define CIPHER_SEP      ","
 145 int
 146 ciphers_valid(const char *names)
 147 {
 148         Cipher *c;
 149         char *ciphers, *cp;
 150         char *p;
 151
 152         if (names == NULL || strcmp(names, "") == 0)
 153                 return 0;
 154         ciphers = cp = xstrdup(names);
 155         for ((p = strsep(&cp, CIPHER_SEP)); p && *p != '\0';
 156             (p = strsep(&cp, CIPHER_SEP))) {
 157                 c = cipher_by_name(p);
 158                 if (c == NULL || c->number != SSH_CIPHER_SSH2) {
 159                         debug("bad cipher %s [%s]", p, names);
 160                         xfree(ciphers);
 161                         return 0;
 162                 } else {
 163                         debug3("cipher ok: %s [%s]", p, names);
 164                 }
 165         }
 166         debug3("ciphers ok: [%s]", names);
 167         xfree(ciphers);
 168         return 1;
 169 }
 170
 171 /*
 172  * Parses the name of the cipher.  Returns the number of the corresponding
 173  * cipher, or -1 on error.
 174  */
 175
 176 int
 177 cipher_number(const char *name)
 178 {
 179         Cipher *c;
 180         if (name == NULL)
 181                 return -1;
 182         c = cipher_by_name(name);
 183         return (c==NULL) ? -1 : c->number;
 184 }
 185
 186 char *
 187 cipher_name(int id)
 188 {
 189         Cipher *c = cipher_by_number(id);
 190         return (c==NULL) ? "<unknown>" : c->name;
 191 }
 192
 193 void
 194 cipher_init(CipherContext *cc, Cipher *cipher,
 195     const u_char *key, u_int keylen, const u_char *iv, u_int ivlen,
 196     int encrypt)
 197 {
 198         static int dowarn = 1;
 199 #ifdef SSH_OLD_EVP
 200         EVP_CIPHER *type;
 201 #else
 202         const EVP_CIPHER *type;
 203 #endif
 204         int klen;
 205
 206         if (cipher->number == SSH_CIPHER_DES) {
 207                 if (dowarn) {
 208                         error("Warning: use of DES is strongly discouraged "
 209                             "due to cryptographic weaknesses");
 210                         dowarn = 0;
 211                 }
 212                 if (keylen > 8)
 213                         keylen = 8;
 214         }
 215         cc->plaintext = (cipher->number == SSH_CIPHER_NONE);
 216
 217         if (keylen < cipher->key_len)
 218                 fatal("cipher_init: key length %d is insufficient for %s.",
 219                     keylen, cipher->name);
 220         if (iv != NULL && ivlen < cipher->block_size)
 221                 fatal("cipher_init: iv length %d is insufficient for %s.",
 222                     ivlen, cipher->name);
 223         cc->cipher = cipher;
 224
 225         type = (*cipher->evptype)();
 226
 227         EVP_CIPHER_CTX_init(&cc->evp);
 228 #ifdef SSH_OLD_EVP
 229         if (type->key_len > 0 && type->key_len != keylen) {
 230                 debug("cipher_init: set keylen (%d -> %d)",
 231                     type->key_len, keylen);
 232                 type->key_len = keylen;
 233         }
 234         EVP_CipherInit(&cc->evp, type, (u_char *)key, (u_char *)iv,
 235             (encrypt == CIPHER_ENCRYPT));
 236 #else
 237         if (EVP_CipherInit(&cc->evp, type, NULL, (u_char *)iv,
 238             (encrypt == CIPHER_ENCRYPT)) == 0)
 239                 fatal("cipher_init: EVP_CipherInit failed for %s",
 240                     cipher->name);
 241         klen = EVP_CIPHER_CTX_key_length(&cc->evp);
 242         if (klen > 0 && keylen != klen) {
 243                 debug("cipher_init: set keylen (%d -> %d)", klen, keylen);
 244                 if (EVP_CIPHER_CTX_set_key_length(&cc->evp, keylen) == 0)
 245                         fatal("cipher_init: set keylen failed (%d -> %d)",
 246                             klen, keylen);
 247         }
 248         if (EVP_CipherInit(&cc->evp, NULL, (u_char *)key, NULL, -1) == 0)
 249                 fatal("cipher_init: EVP_CipherInit: set key failed for %s",
 250                     cipher->name);
 251 #endif
 252 }
 253
 254 void
 255 cipher_crypt(CipherContext *cc, u_char *dest, const u_char *src, u_int len)
 256 {
 257         if (len % cc->cipher->block_size)
 258                 fatal("cipher_encrypt: bad plaintext length %d", len);
 259 #ifdef SSH_OLD_EVP
 260         EVP_Cipher(&cc->evp, dest, (u_char *)src, len);
 261 #else
 262         if (EVP_Cipher(&cc->evp, dest, (u_char *)src, len) == 0)
 263                 fatal("evp_crypt: EVP_Cipher failed");
 264 #endif
 265 }
 266
 267 void
 268 cipher_cleanup(CipherContext *cc)
 269 {
 270 #ifdef SSH_OLD_EVP
 271         EVP_CIPHER_CTX_cleanup(&cc->evp);
 272 #else
 273         if (EVP_CIPHER_CTX_cleanup(&cc->evp) == 0)
 274                 error("cipher_cleanup: EVP_CIPHER_CTX_cleanup failed");
 275 #endif
 276 }
 277
 278 /*
 279  * Selects the cipher, and keys if by computing the MD5 checksum of the
 280  * passphrase and using the resulting 16 bytes as the key.
 281  */
 282
 283 void
 284 cipher_set_key_string(CipherContext *cc, Cipher *cipher,
 285     const char *passphrase, int encrypt)
 286 {
 287         MD5_CTX md;
 288         u_char digest[16];
 289
 290         MD5_Init(&md);
 291         MD5_Update(&md, (const u_char *)passphrase, strlen(passphrase));
 292         MD5_Final(digest, &md);
 293
 294         cipher_init(cc, cipher, digest, 16, NULL, 0, encrypt);
 295
 296         memset(digest, 0, sizeof(digest));
 297         memset(&md, 0, sizeof(md));
 298 }
 299
 300 /* Implementations for other non-EVP ciphers */
 301
 302 /*
 303  * This is used by SSH1:
 304  *
 305  * What kind of triple DES are these 2 routines?
 306  *
 307  * Why is there a redundant initialization vector?
 308  *
 309  * If only iv3 was used, then, this would till effect have been
 310  * outer-cbc. However, there is also a private iv1 == iv2 which
 311  * perhaps makes differential analysis easier. On the other hand, the
 312  * private iv1 probably makes the CRC-32 attack ineffective. This is a
 313  * result of that there is no longer any known iv1 to use when
 314  * choosing the X block.
 315  */
 316 struct ssh1_3des_ctx
 317 {
 318         EVP_CIPHER_CTX  k1, k2, k3;
 319 };
 320
 321 static int
 322 ssh1_3des_init(EVP_CIPHER_CTX *ctx, const u_char *key, const u_char *iv,
 323     int enc)
 324 {
 325         struct ssh1_3des_ctx *c;
 326         u_char *k1, *k2, *k3;
 327
 328         if ((c = EVP_CIPHER_CTX_get_app_data(ctx)) == NULL) {
 329                 c = xmalloc(sizeof(*c));
 330                 EVP_CIPHER_CTX_set_app_data(ctx, c);
 331         }
 332         if (key == NULL)
 333                 return (1);
 334         if (enc == -1)
 335                 enc = ctx->encrypt;
 336         k1 = k2 = k3 = (u_char *) key;
 337         k2 += 8;
 338         if (EVP_CIPHER_CTX_key_length(ctx) >= 16+8) {
 339                 if (enc)
 340                         k3 += 16;
 341                 else
 342                         k1 += 16;
 343         }
 344         EVP_CIPHER_CTX_init(&c->k1);
 345         EVP_CIPHER_CTX_init(&c->k2);
 346         EVP_CIPHER_CTX_init(&c->k3);
 347 #ifdef SSH_OLD_EVP
 348         EVP_CipherInit(&c->k1, EVP_des_cbc(), k1, NULL, enc);
 349         EVP_CipherInit(&c->k2, EVP_des_cbc(), k2, NULL, !enc);
 350         EVP_CipherInit(&c->k3, EVP_des_cbc(), k3, NULL, enc);
 351 #else
 352         if (EVP_CipherInit(&c->k1, EVP_des_cbc(), k1, NULL, enc) == 0 ||
 353             EVP_CipherInit(&c->k2, EVP_des_cbc(), k2, NULL, !enc) == 0 ||
 354             EVP_CipherInit(&c->k3, EVP_des_cbc(), k3, NULL, enc) == 0) {
 355                 memset(c, 0, sizeof(*c));
 356                 xfree(c);
 357                 EVP_CIPHER_CTX_set_app_data(ctx, NULL);
 358                 return (0);
 359         }
 360 #endif
 361         return (1);
 362 }
 363
 364 static int
 365 ssh1_3des_cbc(EVP_CIPHER_CTX *ctx, u_char *dest, const u_char *src, u_int len)
 366 {
 367         struct ssh1_3des_ctx *c;
 368
 369         if ((c = EVP_CIPHER_CTX_get_app_data(ctx)) == NULL) {
 370                 error("ssh1_3des_cbc: no context");
 371                 return (0);
 372         }
 373 #ifdef SSH_OLD_EVP
 374         EVP_Cipher(&c->k1, dest, (u_char *)src, len);
 375         EVP_Cipher(&c->k2, dest, dest, len);
 376         EVP_Cipher(&c->k3, dest, dest, len);
 377 #else
 378         if (EVP_Cipher(&c->k1, dest, (u_char *)src, len) == 0 ||
 379             EVP_Cipher(&c->k2, dest, dest, len) == 0 ||
 380             EVP_Cipher(&c->k3, dest, dest, len) == 0)
 381                 return (0);
 382 #endif
 383         return (1);
 384 }
 385
 386 static int
 387 ssh1_3des_cleanup(EVP_CIPHER_CTX *ctx)
 388 {
 389         struct ssh1_3des_ctx *c;
 390
 391         if ((c = EVP_CIPHER_CTX_get_app_data(ctx)) != NULL) {
 392                 memset(c, 0, sizeof(*c));
 393                 xfree(c);
 394                 EVP_CIPHER_CTX_set_app_data(ctx, NULL);
 395         }
 396         return (1);
 397 }
 398
 399 static const EVP_CIPHER *
 400 evp_ssh1_3des(void)
 401 {
 402         static EVP_CIPHER ssh1_3des;
 403
 404         memset(&ssh1_3des, 0, sizeof(EVP_CIPHER));
 405         ssh1_3des.nid = NID_undef;
 406         ssh1_3des.block_size = 8;
 407         ssh1_3des.iv_len = 0;
 408         ssh1_3des.key_len = 16;
 409         ssh1_3des.init = ssh1_3des_init;
 410         ssh1_3des.cleanup = ssh1_3des_cleanup;
 411         ssh1_3des.do_cipher = ssh1_3des_cbc;
 412 #ifndef SSH_OLD_EVP
 413         ssh1_3des.flags = EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH;
 414 #endif
 415         return (&ssh1_3des);
 416 }
 417
 418 /*
 419  * SSH1 uses a variation on Blowfish, all bytes must be swapped before
 420  * and after encryption/decryption. Thus the swap_bytes stuff (yuk).
 421  */
 422 static void
 423 swap_bytes(const u_char *src, u_char *dst, int n)
 424 {
 425         u_char c[4];
 426
 427         /* Process 4 bytes every lap. */
 428         for (n = n / 4; n > 0; n--) {
 429                 c[3] = *src++;
 430                 c[2] = *src++;
 431                 c[1] = *src++;
 432                 c[0] = *src++;
 433
 434                 *dst++ = c[0];
 435                 *dst++ = c[1];
 436                 *dst++ = c[2];
 437                 *dst++ = c[3];
 438         }
 439 }
 440
 441 static int (*orig_bf)(EVP_CIPHER_CTX *, u_char *, const u_char *, u_int) = NULL;
 442
 443 static int
 444 bf_ssh1_cipher(EVP_CIPHER_CTX *ctx, u_char *out, const u_char *in, u_int len)
 445 {
 446         int ret;
 447
 448         swap_bytes(in, out, len);
 449         ret = (*orig_bf)(ctx, out, out, len);
 450         swap_bytes(out, out, len);
 451         return (ret);
 452 }
 453
 454 static const EVP_CIPHER *
 455 evp_ssh1_bf(void)
 456 {
 457         static EVP_CIPHER ssh1_bf;
 458
 459         memcpy(&ssh1_bf, EVP_bf_cbc(), sizeof(EVP_CIPHER));
 460         orig_bf = ssh1_bf.do_cipher;
 461         ssh1_bf.nid = NID_undef;
 462         ssh1_bf.do_cipher = bf_ssh1_cipher;
 463         ssh1_bf.key_len = 32;
 464         return (&ssh1_bf);
 465 }
 466
 467 #if OPENSSL_VERSION_NUMBER < 0x00907000L
 468 /* RIJNDAEL */
 469 #define RIJNDAEL_BLOCKSIZE 16
 470 struct ssh_rijndael_ctx
 471 {
 472         rijndael_ctx    r_ctx;
 473         u_char          r_iv[RIJNDAEL_BLOCKSIZE];
 474 };
 475
 476 static int
 477 ssh_rijndael_init(EVP_CIPHER_CTX *ctx, const u_char *key, const u_char *iv,
 478     int enc)
 479 {
 480         struct ssh_rijndael_ctx *c;
 481
 482         if ((c = EVP_CIPHER_CTX_get_app_data(ctx)) == NULL) {
 483                 c = xmalloc(sizeof(*c));
 484                 EVP_CIPHER_CTX_set_app_data(ctx, c);
 485         }
 486         if (key != NULL) {
 487                 if (enc == -1)
 488                         enc = ctx->encrypt;
 489                 rijndael_set_key(&c->r_ctx, (u_char *)key,
 490                     8*EVP_CIPHER_CTX_key_length(ctx), enc);
 491         }
 492         if (iv != NULL)
 493                 memcpy(c->r_iv, iv, RIJNDAEL_BLOCKSIZE);
 494         return (1);
 495 }
 496
 497 static int
 498 ssh_rijndael_cbc(EVP_CIPHER_CTX *ctx, u_char *dest, const u_char *src,
 499     u_int len)
 500 {
 501         struct ssh_rijndael_ctx *c;
 502         u_char buf[RIJNDAEL_BLOCKSIZE];
 503         u_char *cprev, *cnow, *plain, *ivp;
 504         int i, j, blocks = len / RIJNDAEL_BLOCKSIZE;
 505
 506         if (len == 0)
 507                 return (1);
 508         if (len % RIJNDAEL_BLOCKSIZE)
 509                 fatal("ssh_rijndael_cbc: bad len %d", len);
 510         if ((c = EVP_CIPHER_CTX_get_app_data(ctx)) == NULL) {
 511                 error("ssh_rijndael_cbc: no context");
 512                 return (0);
 513         }
 514         if (ctx->encrypt) {
 515                 cnow  = dest;
 516                 plain = (u_char *)src;
 517                 cprev = c->r_iv;
 518                 for (i = 0; i < blocks; i++, plain+=RIJNDAEL_BLOCKSIZE,
 519                     cnow+=RIJNDAEL_BLOCKSIZE) {
 520                         for (j = 0; j < RIJNDAEL_BLOCKSIZE; j++)
 521                                 buf[j] = plain[j] ^ cprev[j];
 522                         rijndael_encrypt(&c->r_ctx, buf, cnow);
 523                         cprev = cnow;
 524                 }
 525                 memcpy(c->r_iv, cprev, RIJNDAEL_BLOCKSIZE);
 526         } else {
 527                 cnow  = (u_char *) (src+len-RIJNDAEL_BLOCKSIZE);
 528                 plain = dest+len-RIJNDAEL_BLOCKSIZE;
 529
 530                 memcpy(buf, cnow, RIJNDAEL_BLOCKSIZE);
 531                 for (i = blocks; i > 0; i--, cnow-=RIJNDAEL_BLOCKSIZE,
 532                     plain-=RIJNDAEL_BLOCKSIZE) {
 533                         rijndael_decrypt(&c->r_ctx, cnow, plain);
 534                         ivp = (i == 1) ? c->r_iv : cnow-RIJNDAEL_BLOCKSIZE;
 535                         for (j = 0; j < RIJNDAEL_BLOCKSIZE; j++)
 536                                 plain[j] ^= ivp[j];
 537                 }
 538                 memcpy(c->r_iv, buf, RIJNDAEL_BLOCKSIZE);
 539         }
 540         return (1);
 541 }
 542
 543 static int
 544 ssh_rijndael_cleanup(EVP_CIPHER_CTX *ctx)
 545 {
 546         struct ssh_rijndael_ctx *c;
 547
 548         if ((c = EVP_CIPHER_CTX_get_app_data(ctx)) != NULL) {
 549                 memset(c, 0, sizeof(*c));
 550                 xfree(c);
 551                 EVP_CIPHER_CTX_set_app_data(ctx, NULL);
 552         }
 553         return (1);
 554 }
 555
 556 static const EVP_CIPHER *
 557 evp_rijndael(void)
 558 {
 559         static EVP_CIPHER rijndal_cbc;
 560
 561         memset(&rijndal_cbc, 0, sizeof(EVP_CIPHER));
 562         rijndal_cbc.nid = NID_undef;
 563         rijndal_cbc.block_size = RIJNDAEL_BLOCKSIZE;
 564         rijndal_cbc.iv_len = RIJNDAEL_BLOCKSIZE;
 565         rijndal_cbc.key_len = 16;
 566         rijndal_cbc.init = ssh_rijndael_init;
 567         rijndal_cbc.cleanup = ssh_rijndael_cleanup;
 568         rijndal_cbc.do_cipher = ssh_rijndael_cbc;
 569 #ifndef SSH_OLD_EVP
 570         rijndal_cbc.flags = EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH |
 571             EVP_CIPH_ALWAYS_CALL_INIT;
 572 #endif
 573         return (&rijndal_cbc);
 574 }
 575 #endif
 576
 577 /*
 578  * Exports an IV from the CipherContext required to export the key
 579  * state back from the unprivileged child to the privileged parent
 580  * process.
 581  */
 582
 583 int
 584 cipher_get_keyiv_len(CipherContext *cc)
 585 {
 586         Cipher *c = cc->cipher;
 587         int ivlen;
 588
 589         if (c->number == SSH_CIPHER_3DES)
 590                 ivlen = 24;
 591         else
 592                 ivlen = EVP_CIPHER_CTX_iv_length(&cc->evp);
 593         return (ivlen);
 594 }
 595
 596 void
 597 cipher_get_keyiv(CipherContext *cc, u_char *iv, u_int len)
 598 {
 599         Cipher *c = cc->cipher;
 600         u_char *civ = NULL;
 601         int evplen;
 602
 603         switch (c->number) {
 604         case SSH_CIPHER_SSH2:
 605         case SSH_CIPHER_DES:
 606         case SSH_CIPHER_BLOWFISH:
 607                 evplen = EVP_CIPHER_CTX_iv_length(&cc->evp);
 608                 if (evplen == 0)
 609                         return;
 610                 if (evplen != len)
 611                         fatal("%s: wrong iv length %d != %d", __func__,
 612                             evplen, len);
 613
 614 #if OPENSSL_VERSION_NUMBER < 0x00907000L
 615                 if (c->evptype == evp_rijndael) {
 616                         struct ssh_rijndael_ctx *aesc;
 617
 618                         aesc = EVP_CIPHER_CTX_get_app_data(&cc->evp);
 619                         if (aesc == NULL)
 620                                 fatal("%s: no rijndael context", __func__);
 621                         civ = aesc->r_iv;
 622                 } else
 623 #endif
 624                 {
 625                         civ = cc->evp.iv;
 626                 }
 627                 break;
 628         case SSH_CIPHER_3DES: {
 629                 struct ssh1_3des_ctx *desc;
 630                 if (len != 24)
 631                         fatal("%s: bad 3des iv length: %d", __func__, len);
 632                 desc = EVP_CIPHER_CTX_get_app_data(&cc->evp);
 633                 if (desc == NULL)
 634                         fatal("%s: no 3des context", __func__);
 635                 debug3("%s: Copying 3DES IV", __func__);
 636                 memcpy(iv, desc->k1.iv, 8);
 637                 memcpy(iv + 8, desc->k2.iv, 8);
 638                 memcpy(iv + 16, desc->k3.iv, 8);
 639                 return;
 640         }
 641         default:
 642                 fatal("%s: bad cipher %d", __func__, c->number);
 643         }
 644         memcpy(iv, civ, len);
 645 }
 646
 647 void
 648 cipher_set_keyiv(CipherContext *cc, u_char *iv)
 649 {
 650         Cipher *c = cc->cipher;
 651         u_char *div = NULL;
 652         int evplen = 0;
 653
 654         switch (c->number) {
 655         case SSH_CIPHER_SSH2:
 656         case SSH_CIPHER_DES:
 657         case SSH_CIPHER_BLOWFISH:
 658                 evplen = EVP_CIPHER_CTX_iv_length(&cc->evp);
 659                 if (evplen == 0)
 660                         return;
 661
 662 #if OPENSSL_VERSION_NUMBER < 0x00907000L
 663                 if (c->evptype == evp_rijndael) {
 664                         struct ssh_rijndael_ctx *aesc;
 665
 666                         aesc = EVP_CIPHER_CTX_get_app_data(&cc->evp);
 667                         if (aesc == NULL)
 668                                 fatal("%s: no rijndael context", __func__);
 669                         div = aesc->r_iv;
 670                 } else
 671 #endif
 672                 {
 673                         div = cc->evp.iv;
 674                 }
 675                 break;
 676         case SSH_CIPHER_3DES: {
 677                 struct ssh1_3des_ctx *desc;
 678                 desc = EVP_CIPHER_CTX_get_app_data(&cc->evp);
 679                 if (desc == NULL)
 680                         fatal("%s: no 3des context", __func__);
 681                 debug3("%s: Installed 3DES IV", __func__);
 682                 memcpy(desc->k1.iv, iv, 8);
 683                 memcpy(desc->k2.iv, iv + 8, 8);
 684                 memcpy(desc->k3.iv, iv + 16, 8);
 685                 return;
 686         }
 687         default:
 688                 fatal("%s: bad cipher %d", __func__, c->number);
 689         }
 690         memcpy(div, iv, evplen);
 691 }
 692
 693 #if OPENSSL_VERSION_NUMBER < 0x00907000L
 694 #define EVP_X_STATE(evp)        &(evp).c
 695 #define EVP_X_STATE_LEN(evp)    sizeof((evp).c)
 696 #else
 697 #define EVP_X_STATE(evp)        (evp).cipher_data
 698 #define EVP_X_STATE_LEN(evp)    (evp).cipher->ctx_size
 699 #endif
 700
 701 int
 702 cipher_get_keycontext(CipherContext *cc, u_char *dat)
 703 {
 704         Cipher *c = cc->cipher;
 705         int plen = 0;
 706
 707         if (c->evptype == EVP_rc4) {
 708                 plen = EVP_X_STATE_LEN(cc->evp);
 709                 if (dat == NULL)
 710                         return (plen);
 711                 memcpy(dat, EVP_X_STATE(cc->evp), plen);
 712         }
 713         return (plen);
 714 }
 715
 716 void
 717 cipher_set_keycontext(CipherContext *cc, u_char *dat)
 718 {
 719         Cipher *c = cc->cipher;
 720         int plen;
 721
 722         if (c->evptype == EVP_rc4) {
 723                 plen = EVP_X_STATE_LEN(cc->evp);
 724                 memcpy(EVP_X_STATE(cc->evp), dat, plen);
 725         }
 726 }