crypto/openssh/kex.c

   1 /* $OpenBSD: kex.c,v 1.109 2015/07/30 00:01:34 djm Exp $ */
   2 /*
   3  * Copyright (c) 2000, 2001 Markus Friedl.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "includes.h"
  27
  28 #include <sys/param.h>  /* MAX roundup */
  29
  30 #include <signal.h>
  31 #include <stdarg.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 #ifdef WITH_OPENSSL
  37 #include <openssl/crypto.h>
  38 #endif
  39
  40 #include "ssh2.h"
  41 #include "packet.h"
  42 #include "compat.h"
  43 #include "cipher.h"
  44 #include "sshkey.h"
  45 #include "kex.h"
  46 #include "log.h"
  47 #include "mac.h"
  48 #include "match.h"
  49 #include "misc.h"
  50 #include "dispatch.h"
  51 #include "monitor.h"
  52 #include "roaming.h"
  53
  54 #include "ssherr.h"
  55 #include "sshbuf.h"
  56 #include "digest.h"
  57
  58 #if OPENSSL_VERSION_NUMBER >= 0x00907000L
  59 # if defined(HAVE_EVP_SHA256)
  60 # define evp_ssh_sha256 EVP_sha256
  61 # else
  62 extern const EVP_MD *evp_ssh_sha256(void);
  63 # endif
  64 #endif
  65
  66 /* prototype */
  67 static int kex_choose_conf(struct ssh *);
  68 static int kex_input_newkeys(int, u_int32_t, void *);
  69
  70 struct kexalg {
  71         char *name;
  72         u_int type;
  73         int ec_nid;
  74         int hash_alg;
  75 };
  76 static const struct kexalg kexalgs[] = {
  77 #ifdef WITH_OPENSSL
  78         { KEX_DH1, KEX_DH_GRP1_SHA1, 0, SSH_DIGEST_SHA1 },
  79         { KEX_DH14, KEX_DH_GRP14_SHA1, 0, SSH_DIGEST_SHA1 },
  80         { KEX_DHGEX_SHA1, KEX_DH_GEX_SHA1, 0, SSH_DIGEST_SHA1 },
  81 #ifdef HAVE_EVP_SHA256
  82         { KEX_DHGEX_SHA256, KEX_DH_GEX_SHA256, 0, SSH_DIGEST_SHA256 },
  83 #endif /* HAVE_EVP_SHA256 */
  84 #ifdef OPENSSL_HAS_ECC
  85         { KEX_ECDH_SHA2_NISTP256, KEX_ECDH_SHA2,
  86             NID_X9_62_prime256v1, SSH_DIGEST_SHA256 },
  87         { KEX_ECDH_SHA2_NISTP384, KEX_ECDH_SHA2, NID_secp384r1,
  88             SSH_DIGEST_SHA384 },
  89 # ifdef OPENSSL_HAS_NISTP521
  90         { KEX_ECDH_SHA2_NISTP521, KEX_ECDH_SHA2, NID_secp521r1,
  91             SSH_DIGEST_SHA512 },
  92 # endif /* OPENSSL_HAS_NISTP521 */
  93 #endif /* OPENSSL_HAS_ECC */
  94 #endif /* WITH_OPENSSL */
  95 #if defined(HAVE_EVP_SHA256) || !defined(WITH_OPENSSL)
  96         { KEX_CURVE25519_SHA256, KEX_C25519_SHA256, 0, SSH_DIGEST_SHA256 },
  97 #endif /* HAVE_EVP_SHA256 || !WITH_OPENSSL */
  98         { NULL, -1, -1, -1},
  99 };
 100
 101 char *
 102 kex_alg_list(char sep)
 103 {
 104         char *ret = NULL, *tmp;
 105         size_t nlen, rlen = 0;
 106         const struct kexalg *k;
 107
 108         for (k = kexalgs; k->name != NULL; k++) {
 109                 if (ret != NULL)
 110                         ret[rlen++] = sep;
 111                 nlen = strlen(k->name);
 112                 if ((tmp = realloc(ret, rlen + nlen + 2)) == NULL) {
 113                         free(ret);
 114                         return NULL;
 115                 }
 116                 ret = tmp;
 117                 memcpy(ret + rlen, k->name, nlen + 1);
 118                 rlen += nlen;
 119         }
 120         return ret;
 121 }
 122
 123 static const struct kexalg *
 124 kex_alg_by_name(const char *name)
 125 {
 126         const struct kexalg *k;
 127
 128         for (k = kexalgs; k->name != NULL; k++) {
 129                 if (strcmp(k->name, name) == 0)
 130                         return k;
 131         }
 132         return NULL;
 133 }
 134
 135 /* Validate KEX method name list */
 136 int
 137 kex_names_valid(const char *names)
 138 {
 139         char *s, *cp, *p;
 140
 141         if (names == NULL || strcmp(names, "") == 0)
 142                 return 0;
 143         if ((s = cp = strdup(names)) == NULL)
 144                 return 0;
 145         for ((p = strsep(&cp, ",")); p && *p != '\0';
 146             (p = strsep(&cp, ","))) {
 147                 if (kex_alg_by_name(p) == NULL) {
 148                         error("Unsupported KEX algorithm \"%.100s\"", p);
 149                         free(s);
 150                         return 0;
 151                 }
 152         }
 153         debug3("kex names ok: [%s]", names);
 154         free(s);
 155         return 1;
 156 }
 157
 158 /*
 159  * Concatenate algorithm names, avoiding duplicates in the process.
 160  * Caller must free returned string.
 161  */
 162 char *
 163 kex_names_cat(const char *a, const char *b)
 164 {
 165         char *ret = NULL, *tmp = NULL, *cp, *p;
 166         size_t len;
 167
 168         if (a == NULL || *a == '\0')
 169                 return NULL;
 170         if (b == NULL || *b == '\0')
 171                 return strdup(a);
 172         if (strlen(b) > 1024*1024)
 173                 return NULL;
 174         len = strlen(a) + strlen(b) + 2;
 175         if ((tmp = cp = strdup(b)) == NULL ||
 176             (ret = calloc(1, len)) == NULL) {
 177                 free(tmp);
 178                 return NULL;
 179         }
 180         strlcpy(ret, a, len);
 181         for ((p = strsep(&cp, ",")); p && *p != '\0'; (p = strsep(&cp, ","))) {
 182                 if (match_list(ret, p, NULL) != NULL)
 183                         continue; /* Algorithm already present */
 184                 if (strlcat(ret, ",", len) >= len ||
 185                     strlcat(ret, p, len) >= len) {
 186                         free(tmp);
 187                         free(ret);
 188                         return NULL; /* Shouldn't happen */
 189                 }
 190         }
 191         free(tmp);
 192         return ret;
 193 }
 194
 195 /*
 196  * Assemble a list of algorithms from a default list and a string from a
 197  * configuration file. The user-provided string may begin with '+' to
 198  * indicate that it should be appended to the default.
 199  */
 200 int
 201 kex_assemble_names(const char *def, char **list)
 202 {
 203         char *ret;
 204
 205         if (list == NULL || *list == NULL || **list == '\0') {
 206                 *list = strdup(def);
 207                 return 0;
 208         }
 209         if (**list != '+') {
 210                 return 0;
 211         }
 212
 213         if ((ret = kex_names_cat(def, *list + 1)) == NULL)
 214                 return SSH_ERR_ALLOC_FAIL;
 215         free(*list);
 216         *list = ret;
 217         return 0;
 218 }
 219
 220 /* put algorithm proposal into buffer */
 221 int
 222 kex_prop2buf(struct sshbuf *b, char *proposal[PROPOSAL_MAX])
 223 {
 224         u_int i;
 225         int r;
 226
 227         sshbuf_reset(b);
 228
 229         /*
 230          * add a dummy cookie, the cookie will be overwritten by
 231          * kex_send_kexinit(), each time a kexinit is set
 232          */
 233         for (i = 0; i < KEX_COOKIE_LEN; i++) {
 234                 if ((r = sshbuf_put_u8(b, 0)) != 0)
 235                         return r;
 236         }
 237         for (i = 0; i < PROPOSAL_MAX; i++) {
 238                 if ((r = sshbuf_put_cstring(b, proposal[i])) != 0)
 239                         return r;
 240         }
 241         if ((r = sshbuf_put_u8(b, 0)) != 0 ||   /* first_kex_packet_follows */
 242             (r = sshbuf_put_u32(b, 0)) != 0)    /* uint32 reserved */
 243                 return r;
 244         return 0;
 245 }
 246
 247 /* parse buffer and return algorithm proposal */
 248 int
 249 kex_buf2prop(struct sshbuf *raw, int *first_kex_follows, char ***propp)
 250 {
 251         struct sshbuf *b = NULL;
 252         u_char v;
 253         u_int i;
 254         char **proposal = NULL;
 255         int r;
 256
 257         *propp = NULL;
 258         if ((proposal = calloc(PROPOSAL_MAX, sizeof(char *))) == NULL)
 259                 return SSH_ERR_ALLOC_FAIL;
 260         if ((b = sshbuf_fromb(raw)) == NULL) {
 261                 r = SSH_ERR_ALLOC_FAIL;
 262                 goto out;
 263         }
 264         if ((r = sshbuf_consume(b, KEX_COOKIE_LEN)) != 0) /* skip cookie */
 265                 goto out;
 266         /* extract kex init proposal strings */
 267         for (i = 0; i < PROPOSAL_MAX; i++) {
 268                 if ((r = sshbuf_get_cstring(b, &(proposal[i]), NULL)) != 0)
 269                         goto out;
 270                 debug2("kex_parse_kexinit: %s", proposal[i]);
 271         }
 272         /* first kex follows / reserved */
 273         if ((r = sshbuf_get_u8(b, &v)) != 0 ||  /* first_kex_follows */
 274             (r = sshbuf_get_u32(b, &i)) != 0)   /* reserved */
 275                 goto out;
 276         if (first_kex_follows != NULL)
 277                 *first_kex_follows = v;
 278         debug2("first_kex_follows %d ", v);
 279         debug2("reserved %u ", i);
 280         r = 0;
 281         *propp = proposal;
 282  out:
 283         if (r != 0 && proposal != NULL)
 284                 kex_prop_free(proposal);
 285         sshbuf_free(b);
 286         return r;
 287 }
 288
 289 void
 290 kex_prop_free(char **proposal)
 291 {
 292         u_int i;
 293
 294         if (proposal == NULL)
 295                 return;
 296         for (i = 0; i < PROPOSAL_MAX; i++)
 297                 free(proposal[i]);
 298         free(proposal);
 299 }
 300
 301 /* ARGSUSED */
 302 static int
 303 kex_protocol_error(int type, u_int32_t seq, void *ctxt)
 304 {
 305         error("Hm, kex protocol error: type %d seq %u", type, seq);
 306         return 0;
 307 }
 308
 309 static void
 310 kex_reset_dispatch(struct ssh *ssh)
 311 {
 312         ssh_dispatch_range(ssh, SSH2_MSG_TRANSPORT_MIN,
 313             SSH2_MSG_TRANSPORT_MAX, &kex_protocol_error);
 314         ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit);
 315 }
 316
 317 int
 318 kex_send_newkeys(struct ssh *ssh)
 319 {
 320         int r;
 321
 322         kex_reset_dispatch(ssh);
 323         if ((r = sshpkt_start(ssh, SSH2_MSG_NEWKEYS)) != 0 ||
 324             (r = sshpkt_send(ssh)) != 0)
 325                 return r;
 326         debug("SSH2_MSG_NEWKEYS sent");
 327         debug("expecting SSH2_MSG_NEWKEYS");
 328         ssh_dispatch_set(ssh, SSH2_MSG_NEWKEYS, &kex_input_newkeys);
 329         return 0;
 330 }
 331
 332 static int
 333 kex_input_newkeys(int type, u_int32_t seq, void *ctxt)
 334 {
 335         struct ssh *ssh = ctxt;
 336         struct kex *kex = ssh->kex;
 337         int r;
 338
 339         debug("SSH2_MSG_NEWKEYS received");
 340         ssh_dispatch_set(ssh, SSH2_MSG_NEWKEYS, &kex_protocol_error);
 341         if ((r = sshpkt_get_end(ssh)) != 0)
 342                 return r;
 343         kex->done = 1;
 344         sshbuf_reset(kex->peer);
 345         /* sshbuf_reset(kex->my); */
 346         kex->flags &= ~KEX_INIT_SENT;
 347         free(kex->name);
 348         kex->name = NULL;
 349         return 0;
 350 }
 351
 352 int
 353 kex_send_kexinit(struct ssh *ssh)
 354 {
 355         u_char *cookie;
 356         struct kex *kex = ssh->kex;
 357         int r;
 358
 359         if (kex == NULL)
 360                 return SSH_ERR_INTERNAL_ERROR;
 361         if (kex->flags & KEX_INIT_SENT)
 362                 return 0;
 363         kex->done = 0;
 364
 365         /* generate a random cookie */
 366         if (sshbuf_len(kex->my) < KEX_COOKIE_LEN)
 367                 return SSH_ERR_INVALID_FORMAT;
 368         if ((cookie = sshbuf_mutable_ptr(kex->my)) == NULL)
 369                 return SSH_ERR_INTERNAL_ERROR;
 370         arc4random_buf(cookie, KEX_COOKIE_LEN);
 371
 372         if ((r = sshpkt_start(ssh, SSH2_MSG_KEXINIT)) != 0 ||
 373             (r = sshpkt_putb(ssh, kex->my)) != 0 ||
 374             (r = sshpkt_send(ssh)) != 0)
 375                 return r;
 376         debug("SSH2_MSG_KEXINIT sent");
 377         kex->flags |= KEX_INIT_SENT;
 378         return 0;
 379 }
 380
 381 /* ARGSUSED */
 382 int
 383 kex_input_kexinit(int type, u_int32_t seq, void *ctxt)
 384 {
 385         struct ssh *ssh = ctxt;
 386         struct kex *kex = ssh->kex;
 387         const u_char *ptr;
 388         u_int i;
 389         size_t dlen;
 390         int r;
 391
 392         debug("SSH2_MSG_KEXINIT received");
 393         if (kex == NULL)
 394                 return SSH_ERR_INVALID_ARGUMENT;
 395
 396         ptr = sshpkt_ptr(ssh, &dlen);
 397         if ((r = sshbuf_put(kex->peer, ptr, dlen)) != 0)
 398                 return r;
 399
 400         /* discard packet */
 401         for (i = 0; i < KEX_COOKIE_LEN; i++)
 402                 if ((r = sshpkt_get_u8(ssh, NULL)) != 0)
 403                         return r;
 404         for (i = 0; i < PROPOSAL_MAX; i++)
 405                 if ((r = sshpkt_get_string(ssh, NULL, NULL)) != 0)
 406                         return r;
 407         /*
 408          * XXX RFC4253 sec 7: "each side MAY guess" - currently no supported
 409          * KEX method has the server move first, but a server might be using
 410          * a custom method or one that we otherwise don't support. We should
 411          * be prepared to remember first_kex_follows here so we can eat a
 412          * packet later.
 413          * XXX2 - RFC4253 is kind of ambiguous on what first_kex_follows means
 414          * for cases where the server *doesn't* go first. I guess we should
 415          * ignore it when it is set for these cases, which is what we do now.
 416          */
 417         if ((r = sshpkt_get_u8(ssh, NULL)) != 0 ||      /* first_kex_follows */
 418             (r = sshpkt_get_u32(ssh, NULL)) != 0 ||     /* reserved */
 419             (r = sshpkt_get_end(ssh)) != 0)
 420                         return r;
 421
 422         if (!(kex->flags & KEX_INIT_SENT))
 423                 if ((r = kex_send_kexinit(ssh)) != 0)
 424                         return r;
 425         if ((r = kex_choose_conf(ssh)) != 0)
 426                 return r;
 427
 428         if (kex->kex_type < KEX_MAX && kex->kex[kex->kex_type] != NULL)
 429                 return (kex->kex[kex->kex_type])(ssh);
 430
 431         return SSH_ERR_INTERNAL_ERROR;
 432 }
 433
 434 int
 435 kex_new(struct ssh *ssh, char *proposal[PROPOSAL_MAX], struct kex **kexp)
 436 {
 437         struct kex *kex;
 438         int r;
 439
 440         *kexp = NULL;
 441         if ((kex = calloc(1, sizeof(*kex))) == NULL)
 442                 return SSH_ERR_ALLOC_FAIL;
 443         if ((kex->peer = sshbuf_new()) == NULL ||
 444             (kex->my = sshbuf_new()) == NULL) {
 445                 r = SSH_ERR_ALLOC_FAIL;
 446                 goto out;
 447         }
 448         if ((r = kex_prop2buf(kex->my, proposal)) != 0)
 449                 goto out;
 450         kex->done = 0;
 451         kex_reset_dispatch(ssh);
 452         r = 0;
 453         *kexp = kex;
 454  out:
 455         if (r != 0)
 456                 kex_free(kex);
 457         return r;
 458 }
 459
 460 void
 461 kex_free_newkeys(struct newkeys *newkeys)
 462 {
 463         if (newkeys == NULL)
 464                 return;
 465         if (newkeys->enc.key) {
 466                 explicit_bzero(newkeys->enc.key, newkeys->enc.key_len);
 467                 free(newkeys->enc.key);
 468                 newkeys->enc.key = NULL;
 469         }
 470         if (newkeys->enc.iv) {
 471                 explicit_bzero(newkeys->enc.iv, newkeys->enc.block_size);
 472                 free(newkeys->enc.iv);
 473                 newkeys->enc.iv = NULL;
 474         }
 475         free(newkeys->enc.name);
 476         explicit_bzero(&newkeys->enc, sizeof(newkeys->enc));
 477         free(newkeys->comp.name);
 478         explicit_bzero(&newkeys->comp, sizeof(newkeys->comp));
 479         mac_clear(&newkeys->mac);
 480         if (newkeys->mac.key) {
 481                 explicit_bzero(newkeys->mac.key, newkeys->mac.key_len);
 482                 free(newkeys->mac.key);
 483                 newkeys->mac.key = NULL;
 484         }
 485         free(newkeys->mac.name);
 486         explicit_bzero(&newkeys->mac, sizeof(newkeys->mac));
 487         explicit_bzero(newkeys, sizeof(*newkeys));
 488         free(newkeys);
 489 }
 490
 491 void
 492 kex_free(struct kex *kex)
 493 {
 494         u_int mode;
 495
 496 #ifdef WITH_OPENSSL
 497         if (kex->dh)
 498                 DH_free(kex->dh);
 499 #ifdef OPENSSL_HAS_ECC
 500         if (kex->ec_client_key)
 501                 EC_KEY_free(kex->ec_client_key);
 502 #endif /* OPENSSL_HAS_ECC */
 503 #endif /* WITH_OPENSSL */
 504         for (mode = 0; mode < MODE_MAX; mode++) {
 505                 kex_free_newkeys(kex->newkeys[mode]);
 506                 kex->newkeys[mode] = NULL;
 507         }
 508         sshbuf_free(kex->peer);
 509         sshbuf_free(kex->my);
 510         free(kex->session_id);
 511         free(kex->client_version_string);
 512         free(kex->server_version_string);
 513         free(kex->failed_choice);
 514         free(kex);
 515 }
 516
 517 int
 518 kex_setup(struct ssh *ssh, char *proposal[PROPOSAL_MAX])
 519 {
 520         int r;
 521
 522         if ((r = kex_new(ssh, proposal, &ssh->kex)) != 0)
 523                 return r;
 524         if ((r = kex_send_kexinit(ssh)) != 0) {         /* we start */
 525                 kex_free(ssh->kex);
 526                 ssh->kex = NULL;
 527                 return r;
 528         }
 529         return 0;
 530 }
 531
 532 static int
 533 choose_enc(struct sshenc *enc, char *client, char *server)
 534 {
 535         char *name = match_list(client, server, NULL);
 536
 537         if (name == NULL)
 538                 return SSH_ERR_NO_CIPHER_ALG_MATCH;
 539         if ((enc->cipher = cipher_by_name(name)) == NULL)
 540                 return SSH_ERR_INTERNAL_ERROR;
 541         enc->name = name;
 542         enc->enabled = 0;
 543         enc->iv = NULL;
 544         enc->iv_len = cipher_ivlen(enc->cipher);
 545         enc->key = NULL;
 546         enc->key_len = cipher_keylen(enc->cipher);
 547         enc->block_size = cipher_blocksize(enc->cipher);
 548         return 0;
 549 }
 550
 551 static int
 552 choose_mac(struct ssh *ssh, struct sshmac *mac, char *client, char *server)
 553 {
 554         char *name = match_list(client, server, NULL);
 555
 556         if (name == NULL)
 557                 return SSH_ERR_NO_MAC_ALG_MATCH;
 558         if (mac_setup(mac, name) < 0)
 559                 return SSH_ERR_INTERNAL_ERROR;
 560         /* truncate the key */
 561         if (ssh->compat & SSH_BUG_HMAC)
 562                 mac->key_len = 16;
 563         mac->name = name;
 564         mac->key = NULL;
 565         mac->enabled = 0;
 566         return 0;
 567 }
 568
 569 static int
 570 choose_comp(struct sshcomp *comp, char *client, char *server)
 571 {
 572         char *name = match_list(client, server, NULL);
 573
 574         if (name == NULL)
 575                 return SSH_ERR_NO_COMPRESS_ALG_MATCH;
 576         if (strcmp(name, "zlib@openssh.com") == 0) {
 577                 comp->type = COMP_DELAYED;
 578         } else if (strcmp(name, "zlib") == 0) {
 579                 comp->type = COMP_ZLIB;
 580         } else if (strcmp(name, "none") == 0) {
 581                 comp->type = COMP_NONE;
 582         } else {
 583                 return SSH_ERR_INTERNAL_ERROR;
 584         }
 585         comp->name = name;
 586         return 0;
 587 }
 588
 589 static int
 590 choose_kex(struct kex *k, char *client, char *server)
 591 {
 592         const struct kexalg *kexalg;
 593
 594         k->name = match_list(client, server, NULL);
 595
 596         if (k->name == NULL)
 597                 return SSH_ERR_NO_KEX_ALG_MATCH;
 598         if ((kexalg = kex_alg_by_name(k->name)) == NULL)
 599                 return SSH_ERR_INTERNAL_ERROR;
 600         k->kex_type = kexalg->type;
 601         k->hash_alg = kexalg->hash_alg;
 602         k->ec_nid = kexalg->ec_nid;
 603         return 0;
 604 }
 605
 606 static int
 607 choose_hostkeyalg(struct kex *k, char *client, char *server)
 608 {
 609         char *hostkeyalg = match_list(client, server, NULL);
 610
 611         if (hostkeyalg == NULL)
 612                 return SSH_ERR_NO_HOSTKEY_ALG_MATCH;
 613         k->hostkey_type = sshkey_type_from_name(hostkeyalg);
 614         if (k->hostkey_type == KEY_UNSPEC)
 615                 return SSH_ERR_INTERNAL_ERROR;
 616         k->hostkey_nid = sshkey_ecdsa_nid_from_name(hostkeyalg);
 617         free(hostkeyalg);
 618         return 0;
 619 }
 620
 621 static int
 622 proposals_match(char *my[PROPOSAL_MAX], char *peer[PROPOSAL_MAX])
 623 {
 624         static int check[] = {
 625                 PROPOSAL_KEX_ALGS, PROPOSAL_SERVER_HOST_KEY_ALGS, -1
 626         };
 627         int *idx;
 628         char *p;
 629
 630         for (idx = &check[0]; *idx != -1; idx++) {
 631                 if ((p = strchr(my[*idx], ',')) != NULL)
 632                         *p = '\0';
 633                 if ((p = strchr(peer[*idx], ',')) != NULL)
 634                         *p = '\0';
 635                 if (strcmp(my[*idx], peer[*idx]) != 0) {
 636                         debug2("proposal mismatch: my %s peer %s",
 637                             my[*idx], peer[*idx]);
 638                         return (0);
 639                 }
 640         }
 641         debug2("proposals match");
 642         return (1);
 643 }
 644
 645 static int
 646 kex_choose_conf(struct ssh *ssh)
 647 {
 648         struct kex *kex = ssh->kex;
 649         struct newkeys *newkeys;
 650         char **my = NULL, **peer = NULL;
 651         char **cprop, **sprop;
 652         int nenc, nmac, ncomp;
 653         u_int mode, ctos, need, dh_need, authlen;
 654         int r, first_kex_follows;
 655
 656         if ((r = kex_buf2prop(kex->my, NULL, &my)) != 0 ||
 657             (r = kex_buf2prop(kex->peer, &first_kex_follows, &peer)) != 0)
 658                 goto out;
 659
 660         if (kex->server) {
 661                 cprop=peer;
 662                 sprop=my;
 663         } else {
 664                 cprop=my;
 665                 sprop=peer;
 666         }
 667
 668         /* Check whether server offers roaming */
 669         if (!kex->server) {
 670                 char *roaming = match_list(KEX_RESUME,
 671                     peer[PROPOSAL_KEX_ALGS], NULL);
 672
 673                 if (roaming) {
 674                         kex->roaming = 1;
 675                         free(roaming);
 676                 }
 677         }
 678
 679         /* Algorithm Negotiation */
 680         for (mode = 0; mode < MODE_MAX; mode++) {
 681                 if ((newkeys = calloc(1, sizeof(*newkeys))) == NULL) {
 682                         r = SSH_ERR_ALLOC_FAIL;
 683                         goto out;
 684                 }
 685                 kex->newkeys[mode] = newkeys;
 686                 ctos = (!kex->server && mode == MODE_OUT) ||
 687                     (kex->server && mode == MODE_IN);
 688                 nenc  = ctos ? PROPOSAL_ENC_ALGS_CTOS  : PROPOSAL_ENC_ALGS_STOC;
 689                 nmac  = ctos ? PROPOSAL_MAC_ALGS_CTOS  : PROPOSAL_MAC_ALGS_STOC;
 690                 ncomp = ctos ? PROPOSAL_COMP_ALGS_CTOS : PROPOSAL_COMP_ALGS_STOC;
 691                 if ((r = choose_enc(&newkeys->enc, cprop[nenc],
 692                     sprop[nenc])) != 0) {
 693                         kex->failed_choice = peer[nenc];
 694                         peer[nenc] = NULL;
 695                         goto out;
 696                 }
 697                 authlen = cipher_authlen(newkeys->enc.cipher);
 698                 /* ignore mac for authenticated encryption */
 699                 if (authlen == 0 &&
 700                     (r = choose_mac(ssh, &newkeys->mac, cprop[nmac],
 701                     sprop[nmac])) != 0) {
 702                         kex->failed_choice = peer[nmac];
 703                         peer[nmac] = NULL;
 704                         goto out;
 705                 }
 706                 if ((r = choose_comp(&newkeys->comp, cprop[ncomp],
 707                     sprop[ncomp])) != 0) {
 708                         kex->failed_choice = peer[ncomp];
 709                         peer[ncomp] = NULL;
 710                         goto out;
 711                 }
 712                 debug("kex: %s %s %s %s",
 713                     ctos ? "client->server" : "server->client",
 714                     newkeys->enc.name,
 715                     authlen == 0 ? newkeys->mac.name : "<implicit>",
 716                     newkeys->comp.name);
 717         }
 718         if ((r = choose_kex(kex, cprop[PROPOSAL_KEX_ALGS],
 719             sprop[PROPOSAL_KEX_ALGS])) != 0) {
 720                 kex->failed_choice = peer[PROPOSAL_KEX_ALGS];
 721                 peer[PROPOSAL_KEX_ALGS] = NULL;
 722                 goto out;
 723         }
 724         if ((r = choose_hostkeyalg(kex, cprop[PROPOSAL_SERVER_HOST_KEY_ALGS],
 725             sprop[PROPOSAL_SERVER_HOST_KEY_ALGS])) != 0) {
 726                 kex->failed_choice = peer[PROPOSAL_SERVER_HOST_KEY_ALGS];
 727                 peer[PROPOSAL_SERVER_HOST_KEY_ALGS] = NULL;
 728                 goto out;
 729         }
 730         need = dh_need = 0;
 731         for (mode = 0; mode < MODE_MAX; mode++) {
 732                 newkeys = kex->newkeys[mode];
 733                 need = MAX(need, newkeys->enc.key_len);
 734                 need = MAX(need, newkeys->enc.block_size);
 735                 need = MAX(need, newkeys->enc.iv_len);
 736                 need = MAX(need, newkeys->mac.key_len);
 737                 dh_need = MAX(dh_need, cipher_seclen(newkeys->enc.cipher));
 738                 dh_need = MAX(dh_need, newkeys->enc.block_size);
 739                 dh_need = MAX(dh_need, newkeys->enc.iv_len);
 740                 dh_need = MAX(dh_need, newkeys->mac.key_len);
 741         }
 742         /* XXX need runden? */
 743         kex->we_need = need;
 744         kex->dh_need = dh_need;
 745
 746         /* ignore the next message if the proposals do not match */
 747         if (first_kex_follows && !proposals_match(my, peer) &&
 748             !(ssh->compat & SSH_BUG_FIRSTKEX))
 749                 ssh->dispatch_skip_packets = 1;
 750         r = 0;
 751  out:
 752         kex_prop_free(my);
 753         kex_prop_free(peer);
 754         return r;
 755 }
 756
 757 static int
 758 derive_key(struct ssh *ssh, int id, u_int need, u_char *hash, u_int hashlen,
 759     const struct sshbuf *shared_secret, u_char **keyp)
 760 {
 761         struct kex *kex = ssh->kex;
 762         struct ssh_digest_ctx *hashctx = NULL;
 763         char c = id;
 764         u_int have;
 765         size_t mdsz;
 766         u_char *digest;
 767         int r;
 768
 769         if ((mdsz = ssh_digest_bytes(kex->hash_alg)) == 0)
 770                 return SSH_ERR_INVALID_ARGUMENT;
 771         if ((digest = calloc(1, roundup(need, mdsz))) == NULL) {
 772                 r = SSH_ERR_ALLOC_FAIL;
 773                 goto out;
 774         }
 775
 776         /* K1 = HASH(K || H || "A" || session_id) */
 777         if ((hashctx = ssh_digest_start(kex->hash_alg)) == NULL ||
 778             ssh_digest_update_buffer(hashctx, shared_secret) != 0 ||
 779             ssh_digest_update(hashctx, hash, hashlen) != 0 ||
 780             ssh_digest_update(hashctx, &c, 1) != 0 ||
 781             ssh_digest_update(hashctx, kex->session_id,
 782             kex->session_id_len) != 0 ||
 783             ssh_digest_final(hashctx, digest, mdsz) != 0) {
 784                 r = SSH_ERR_LIBCRYPTO_ERROR;
 785                 goto out;
 786         }
 787         ssh_digest_free(hashctx);
 788         hashctx = NULL;
 789
 790         /*
 791          * expand key:
 792          * Kn = HASH(K || H || K1 || K2 || ... || Kn-1)
 793          * Key = K1 || K2 || ... || Kn
 794          */
 795         for (have = mdsz; need > have; have += mdsz) {
 796                 if ((hashctx = ssh_digest_start(kex->hash_alg)) == NULL ||
 797                     ssh_digest_update_buffer(hashctx, shared_secret) != 0 ||
 798                     ssh_digest_update(hashctx, hash, hashlen) != 0 ||
 799                     ssh_digest_update(hashctx, digest, have) != 0 ||
 800                     ssh_digest_final(hashctx, digest + have, mdsz) != 0) {
 801                         r = SSH_ERR_LIBCRYPTO_ERROR;
 802                         goto out;
 803                 }
 804                 ssh_digest_free(hashctx);
 805                 hashctx = NULL;
 806         }
 807 #ifdef DEBUG_KEX
 808         fprintf(stderr, "key '%c'== ", c);
 809         dump_digest("key", digest, need);
 810 #endif
 811         *keyp = digest;
 812         digest = NULL;
 813         r = 0;
 814  out:
 815         if (digest)
 816                 free(digest);
 817         ssh_digest_free(hashctx);
 818         return r;
 819 }
 820
 821 #define NKEYS   6
 822 int
 823 kex_derive_keys(struct ssh *ssh, u_char *hash, u_int hashlen,
 824     const struct sshbuf *shared_secret)
 825 {
 826         struct kex *kex = ssh->kex;
 827         u_char *keys[NKEYS];
 828         u_int i, j, mode, ctos;
 829         int r;
 830
 831         for (i = 0; i < NKEYS; i++) {
 832                 if ((r = derive_key(ssh, 'A'+i, kex->we_need, hash, hashlen,
 833                     shared_secret, &keys[i])) != 0) {
 834                         for (j = 0; j < i; j++)
 835                                 free(keys[j]);
 836                         return r;
 837                 }
 838         }
 839         for (mode = 0; mode < MODE_MAX; mode++) {
 840                 ctos = (!kex->server && mode == MODE_OUT) ||
 841                     (kex->server && mode == MODE_IN);
 842                 kex->newkeys[mode]->enc.iv  = keys[ctos ? 0 : 1];
 843                 kex->newkeys[mode]->enc.key = keys[ctos ? 2 : 3];
 844                 kex->newkeys[mode]->mac.key = keys[ctos ? 4 : 5];
 845         }
 846         return 0;
 847 }
 848
 849 #ifdef WITH_OPENSSL
 850 int
 851 kex_derive_keys_bn(struct ssh *ssh, u_char *hash, u_int hashlen,
 852     const BIGNUM *secret)
 853 {
 854         struct sshbuf *shared_secret;
 855         int r;
 856
 857         if ((shared_secret = sshbuf_new()) == NULL)
 858                 return SSH_ERR_ALLOC_FAIL;
 859         if ((r = sshbuf_put_bignum2(shared_secret, secret)) == 0)
 860                 r = kex_derive_keys(ssh, hash, hashlen, shared_secret);
 861         sshbuf_free(shared_secret);
 862         return r;
 863 }
 864 #endif
 865
 866 #ifdef WITH_SSH1
 867 int
 868 derive_ssh1_session_id(BIGNUM *host_modulus, BIGNUM *server_modulus,
 869     u_int8_t cookie[8], u_int8_t id[16])
 870 {
 871         u_int8_t hbuf[2048], sbuf[2048], obuf[SSH_DIGEST_MAX_LENGTH];
 872         struct ssh_digest_ctx *hashctx = NULL;
 873         size_t hlen, slen;
 874         int r;
 875
 876         hlen = BN_num_bytes(host_modulus);
 877         slen = BN_num_bytes(server_modulus);
 878         if (hlen < (512 / 8) || (u_int)hlen > sizeof(hbuf) ||
 879             slen < (512 / 8) || (u_int)slen > sizeof(sbuf))
 880                 return SSH_ERR_KEY_BITS_MISMATCH;
 881         if (BN_bn2bin(host_modulus, hbuf) <= 0 ||
 882             BN_bn2bin(server_modulus, sbuf) <= 0) {
 883                 r = SSH_ERR_LIBCRYPTO_ERROR;
 884                 goto out;
 885         }
 886         if ((hashctx = ssh_digest_start(SSH_DIGEST_MD5)) == NULL) {
 887                 r = SSH_ERR_ALLOC_FAIL;
 888                 goto out;
 889         }
 890         if (ssh_digest_update(hashctx, hbuf, hlen) != 0 ||
 891             ssh_digest_update(hashctx, sbuf, slen) != 0 ||
 892             ssh_digest_update(hashctx, cookie, 8) != 0 ||
 893             ssh_digest_final(hashctx, obuf, sizeof(obuf)) != 0) {
 894                 r = SSH_ERR_LIBCRYPTO_ERROR;
 895                 goto out;
 896         }
 897         memcpy(id, obuf, ssh_digest_bytes(SSH_DIGEST_MD5));
 898         r = 0;
 899  out:
 900         ssh_digest_free(hashctx);
 901         explicit_bzero(hbuf, sizeof(hbuf));
 902         explicit_bzero(sbuf, sizeof(sbuf));
 903         explicit_bzero(obuf, sizeof(obuf));
 904         return r;
 905 }
 906 #endif
 907
 908 #if defined(DEBUG_KEX) || defined(DEBUG_KEXDH) || defined(DEBUG_KEXECDH)
 909 void
 910 dump_digest(char *msg, u_char *digest, int len)
 911 {
 912         fprintf(stderr, "%s\n", msg);
 913         sshbuf_dump_data(digest, len, stderr);
 914 }
 915 #endif