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