1 /* $OpenBSD: kex.c,v 1.131 2017/03/15 07:07:39 markus 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 29 #include <signal.h> 30 #include <stdarg.h> 31 #include <stdio.h> 32 #include <stdlib.h> 33 #include <string.h> 34 35 #ifdef WITH_OPENSSL 36 #include <openssl/crypto.h> 37 #include <openssl/dh.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 53 #include "ssherr.h" 54 #include "sshbuf.h" 55 #include "digest.h" 56 57 #if OPENSSL_VERSION_NUMBER >= 0x00907000L 58 # if defined(HAVE_EVP_SHA256) 59 # define evp_ssh_sha256 EVP_sha256 60 # else 61 extern const EVP_MD *evp_ssh_sha256(void); 62 # endif 63 #endif 64 65 /* prototype */ 66 static int kex_choose_conf(struct ssh *); 67 static int kex_input_newkeys(int, u_int32_t, void *); 68 69 static const char *proposal_names[PROPOSAL_MAX] = { 70 "KEX algorithms", 71 "host key algorithms", 72 "ciphers ctos", 73 "ciphers stoc", 74 "MACs ctos", 75 "MACs stoc", 76 "compression ctos", 77 "compression stoc", 78 "languages ctos", 79 "languages stoc", 80 }; 81 82 struct kexalg { 83 char *name; 84 u_int type; 85 int ec_nid; 86 int hash_alg; 87 }; 88 static const struct kexalg kexalgs[] = { 89 #ifdef WITH_OPENSSL 90 { KEX_DH1, KEX_DH_GRP1_SHA1, 0, SSH_DIGEST_SHA1 }, 91 { KEX_DH14_SHA1, KEX_DH_GRP14_SHA1, 0, SSH_DIGEST_SHA1 }, 92 { KEX_DH14_SHA256, KEX_DH_GRP14_SHA256, 0, SSH_DIGEST_SHA256 }, 93 { KEX_DH16_SHA512, KEX_DH_GRP16_SHA512, 0, SSH_DIGEST_SHA512 }, 94 { KEX_DH18_SHA512, KEX_DH_GRP18_SHA512, 0, SSH_DIGEST_SHA512 }, 95 { KEX_DHGEX_SHA1, KEX_DH_GEX_SHA1, 0, SSH_DIGEST_SHA1 }, 96 #ifdef HAVE_EVP_SHA256 97 { KEX_DHGEX_SHA256, KEX_DH_GEX_SHA256, 0, SSH_DIGEST_SHA256 }, 98 #endif /* HAVE_EVP_SHA256 */ 99 #ifdef OPENSSL_HAS_ECC 100 { KEX_ECDH_SHA2_NISTP256, KEX_ECDH_SHA2, 101 NID_X9_62_prime256v1, SSH_DIGEST_SHA256 }, 102 { KEX_ECDH_SHA2_NISTP384, KEX_ECDH_SHA2, NID_secp384r1, 103 SSH_DIGEST_SHA384 }, 104 # ifdef OPENSSL_HAS_NISTP521 105 { KEX_ECDH_SHA2_NISTP521, KEX_ECDH_SHA2, NID_secp521r1, 106 SSH_DIGEST_SHA512 }, 107 # endif /* OPENSSL_HAS_NISTP521 */ 108 #endif /* OPENSSL_HAS_ECC */ 109 #endif /* WITH_OPENSSL */ 110 #if defined(HAVE_EVP_SHA256) || !defined(WITH_OPENSSL) 111 { KEX_CURVE25519_SHA256, KEX_C25519_SHA256, 0, SSH_DIGEST_SHA256 }, 112 { KEX_CURVE25519_SHA256_OLD, KEX_C25519_SHA256, 0, SSH_DIGEST_SHA256 }, 113 #endif /* HAVE_EVP_SHA256 || !WITH_OPENSSL */ 114 { NULL, -1, -1, -1}, 115 }; 116 117 char * 118 kex_alg_list(char sep) 119 { 120 char *ret = NULL, *tmp; 121 size_t nlen, rlen = 0; 122 const struct kexalg *k; 123 124 for (k = kexalgs; k->name != NULL; k++) { 125 if (ret != NULL) 126 ret[rlen++] = sep; 127 nlen = strlen(k->name); 128 if ((tmp = realloc(ret, rlen + nlen + 2)) == NULL) { 129 free(ret); 130 return NULL; 131 } 132 ret = tmp; 133 memcpy(ret + rlen, k->name, nlen + 1); 134 rlen += nlen; 135 } 136 return ret; 137 } 138 139 static const struct kexalg * 140 kex_alg_by_name(const char *name) 141 { 142 const struct kexalg *k; 143 144 for (k = kexalgs; k->name != NULL; k++) { 145 if (strcmp(k->name, name) == 0) 146 return k; 147 } 148 return NULL; 149 } 150 151 /* Validate KEX method name list */ 152 int 153 kex_names_valid(const char *names) 154 { 155 char *s, *cp, *p; 156 157 if (names == NULL || strcmp(names, "") == 0) 158 return 0; 159 if ((s = cp = strdup(names)) == NULL) 160 return 0; 161 for ((p = strsep(&cp, ",")); p && *p != '\0'; 162 (p = strsep(&cp, ","))) { 163 if (kex_alg_by_name(p) == NULL) { 164 error("Unsupported KEX algorithm \"%.100s\"", p); 165 free(s); 166 return 0; 167 } 168 } 169 debug3("kex names ok: [%s]", names); 170 free(s); 171 return 1; 172 } 173 174 /* 175 * Concatenate algorithm names, avoiding duplicates in the process. 176 * Caller must free returned string. 177 */ 178 char * 179 kex_names_cat(const char *a, const char *b) 180 { 181 char *ret = NULL, *tmp = NULL, *cp, *p, *m; 182 size_t len; 183 184 if (a == NULL || *a == '\0') 185 return NULL; 186 if (b == NULL || *b == '\0') 187 return strdup(a); 188 if (strlen(b) > 1024*1024) 189 return NULL; 190 len = strlen(a) + strlen(b) + 2; 191 if ((tmp = cp = strdup(b)) == NULL || 192 (ret = calloc(1, len)) == NULL) { 193 free(tmp); 194 return NULL; 195 } 196 strlcpy(ret, a, len); 197 for ((p = strsep(&cp, ",")); p && *p != '\0'; (p = strsep(&cp, ","))) { 198 if ((m = match_list(ret, p, NULL)) != NULL) { 199 free(m); 200 continue; /* Algorithm already present */ 201 } 202 if (strlcat(ret, ",", len) >= len || 203 strlcat(ret, p, len) >= len) { 204 free(tmp); 205 free(ret); 206 return NULL; /* Shouldn't happen */ 207 } 208 } 209 free(tmp); 210 return ret; 211 } 212 213 /* 214 * Assemble a list of algorithms from a default list and a string from a 215 * configuration file. The user-provided string may begin with '+' to 216 * indicate that it should be appended to the default or '-' that the 217 * specified names should be removed. 218 */ 219 int 220 kex_assemble_names(const char *def, char **list) 221 { 222 char *ret; 223 224 if (list == NULL || *list == NULL || **list == '\0') { 225 *list = strdup(def); 226 return 0; 227 } 228 if (**list == '+') { 229 if ((ret = kex_names_cat(def, *list + 1)) == NULL) 230 return SSH_ERR_ALLOC_FAIL; 231 free(*list); 232 *list = ret; 233 } else if (**list == '-') { 234 if ((ret = match_filter_list(def, *list + 1)) == NULL) 235 return SSH_ERR_ALLOC_FAIL; 236 free(*list); 237 *list = ret; 238 } 239 240 return 0; 241 } 242 243 /* put algorithm proposal into buffer */ 244 int 245 kex_prop2buf(struct sshbuf *b, char *proposal[PROPOSAL_MAX]) 246 { 247 u_int i; 248 int r; 249 250 sshbuf_reset(b); 251 252 /* 253 * add a dummy cookie, the cookie will be overwritten by 254 * kex_send_kexinit(), each time a kexinit is set 255 */ 256 for (i = 0; i < KEX_COOKIE_LEN; i++) { 257 if ((r = sshbuf_put_u8(b, 0)) != 0) 258 return r; 259 } 260 for (i = 0; i < PROPOSAL_MAX; i++) { 261 if ((r = sshbuf_put_cstring(b, proposal[i])) != 0) 262 return r; 263 } 264 if ((r = sshbuf_put_u8(b, 0)) != 0 || /* first_kex_packet_follows */ 265 (r = sshbuf_put_u32(b, 0)) != 0) /* uint32 reserved */ 266 return r; 267 return 0; 268 } 269 270 /* parse buffer and return algorithm proposal */ 271 int 272 kex_buf2prop(struct sshbuf *raw, int *first_kex_follows, char ***propp) 273 { 274 struct sshbuf *b = NULL; 275 u_char v; 276 u_int i; 277 char **proposal = NULL; 278 int r; 279 280 *propp = NULL; 281 if ((proposal = calloc(PROPOSAL_MAX, sizeof(char *))) == NULL) 282 return SSH_ERR_ALLOC_FAIL; 283 if ((b = sshbuf_fromb(raw)) == NULL) { 284 r = SSH_ERR_ALLOC_FAIL; 285 goto out; 286 } 287 if ((r = sshbuf_consume(b, KEX_COOKIE_LEN)) != 0) /* skip cookie */ 288 goto out; 289 /* extract kex init proposal strings */ 290 for (i = 0; i < PROPOSAL_MAX; i++) { 291 if ((r = sshbuf_get_cstring(b, &(proposal[i]), NULL)) != 0) 292 goto out; 293 debug2("%s: %s", proposal_names[i], proposal[i]); 294 } 295 /* first kex follows / reserved */ 296 if ((r = sshbuf_get_u8(b, &v)) != 0 || /* first_kex_follows */ 297 (r = sshbuf_get_u32(b, &i)) != 0) /* reserved */ 298 goto out; 299 if (first_kex_follows != NULL) 300 *first_kex_follows = v; 301 debug2("first_kex_follows %d ", v); 302 debug2("reserved %u ", i); 303 r = 0; 304 *propp = proposal; 305 out: 306 if (r != 0 && proposal != NULL) 307 kex_prop_free(proposal); 308 sshbuf_free(b); 309 return r; 310 } 311 312 void 313 kex_prop_free(char **proposal) 314 { 315 u_int i; 316 317 if (proposal == NULL) 318 return; 319 for (i = 0; i < PROPOSAL_MAX; i++) 320 free(proposal[i]); 321 free(proposal); 322 } 323 324 /* ARGSUSED */ 325 static int 326 kex_protocol_error(int type, u_int32_t seq, void *ctxt) 327 { 328 struct ssh *ssh = active_state; /* XXX */ 329 int r; 330 331 error("kex protocol error: type %d seq %u", type, seq); 332 if ((r = sshpkt_start(ssh, SSH2_MSG_UNIMPLEMENTED)) != 0 || 333 (r = sshpkt_put_u32(ssh, seq)) != 0 || 334 (r = sshpkt_send(ssh)) != 0) 335 return r; 336 return 0; 337 } 338 339 static void 340 kex_reset_dispatch(struct ssh *ssh) 341 { 342 ssh_dispatch_range(ssh, SSH2_MSG_TRANSPORT_MIN, 343 SSH2_MSG_TRANSPORT_MAX, &kex_protocol_error); 344 } 345 346 static int 347 kex_send_ext_info(struct ssh *ssh) 348 { 349 int r; 350 char *algs; 351 352 if ((algs = sshkey_alg_list(0, 1, 1, ',')) == NULL) 353 return SSH_ERR_ALLOC_FAIL; 354 if ((r = sshpkt_start(ssh, SSH2_MSG_EXT_INFO)) != 0 || 355 (r = sshpkt_put_u32(ssh, 1)) != 0 || 356 (r = sshpkt_put_cstring(ssh, "server-sig-algs")) != 0 || 357 (r = sshpkt_put_cstring(ssh, algs)) != 0 || 358 (r = sshpkt_send(ssh)) != 0) 359 goto out; 360 /* success */ 361 r = 0; 362 out: 363 free(algs); 364 return r; 365 } 366 367 int 368 kex_send_newkeys(struct ssh *ssh) 369 { 370 int r; 371 372 kex_reset_dispatch(ssh); 373 if ((r = sshpkt_start(ssh, SSH2_MSG_NEWKEYS)) != 0 || 374 (r = sshpkt_send(ssh)) != 0) 375 return r; 376 debug("SSH2_MSG_NEWKEYS sent"); 377 debug("expecting SSH2_MSG_NEWKEYS"); 378 ssh_dispatch_set(ssh, SSH2_MSG_NEWKEYS, &kex_input_newkeys); 379 if (ssh->kex->ext_info_c) 380 if ((r = kex_send_ext_info(ssh)) != 0) 381 return r; 382 return 0; 383 } 384 385 int 386 kex_input_ext_info(int type, u_int32_t seq, void *ctxt) 387 { 388 struct ssh *ssh = ctxt; 389 struct kex *kex = ssh->kex; 390 u_int32_t i, ninfo; 391 char *name, *val, *found; 392 int r; 393 394 debug("SSH2_MSG_EXT_INFO received"); 395 ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, &kex_protocol_error); 396 if ((r = sshpkt_get_u32(ssh, &ninfo)) != 0) 397 return r; 398 for (i = 0; i < ninfo; i++) { 399 if ((r = sshpkt_get_cstring(ssh, &name, NULL)) != 0) 400 return r; 401 if ((r = sshpkt_get_cstring(ssh, &val, NULL)) != 0) { 402 free(name); 403 return r; 404 } 405 debug("%s: %s=<%s>", __func__, name, val); 406 if (strcmp(name, "server-sig-algs") == 0) { 407 found = match_list("rsa-sha2-256", val, NULL); 408 if (found) { 409 kex->rsa_sha2 = 256; 410 free(found); 411 } 412 found = match_list("rsa-sha2-512", val, NULL); 413 if (found) { 414 kex->rsa_sha2 = 512; 415 free(found); 416 } 417 } 418 free(name); 419 free(val); 420 } 421 return sshpkt_get_end(ssh); 422 } 423 424 static int 425 kex_input_newkeys(int type, u_int32_t seq, void *ctxt) 426 { 427 struct ssh *ssh = ctxt; 428 struct kex *kex = ssh->kex; 429 int r; 430 431 debug("SSH2_MSG_NEWKEYS received"); 432 ssh_dispatch_set(ssh, SSH2_MSG_NEWKEYS, &kex_protocol_error); 433 ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit); 434 if ((r = sshpkt_get_end(ssh)) != 0) 435 return r; 436 if ((r = ssh_set_newkeys(ssh, MODE_IN)) != 0) 437 return r; 438 kex->done = 1; 439 sshbuf_reset(kex->peer); 440 /* sshbuf_reset(kex->my); */ 441 kex->flags &= ~KEX_INIT_SENT; 442 free(kex->name); 443 kex->name = NULL; 444 return 0; 445 } 446 447 int 448 kex_send_kexinit(struct ssh *ssh) 449 { 450 u_char *cookie; 451 struct kex *kex = ssh->kex; 452 int r; 453 454 if (kex == NULL) 455 return SSH_ERR_INTERNAL_ERROR; 456 if (kex->flags & KEX_INIT_SENT) 457 return 0; 458 kex->done = 0; 459 460 /* generate a random cookie */ 461 if (sshbuf_len(kex->my) < KEX_COOKIE_LEN) 462 return SSH_ERR_INVALID_FORMAT; 463 if ((cookie = sshbuf_mutable_ptr(kex->my)) == NULL) 464 return SSH_ERR_INTERNAL_ERROR; 465 arc4random_buf(cookie, KEX_COOKIE_LEN); 466 467 if ((r = sshpkt_start(ssh, SSH2_MSG_KEXINIT)) != 0 || 468 (r = sshpkt_putb(ssh, kex->my)) != 0 || 469 (r = sshpkt_send(ssh)) != 0) 470 return r; 471 debug("SSH2_MSG_KEXINIT sent"); 472 kex->flags |= KEX_INIT_SENT; 473 return 0; 474 } 475 476 /* ARGSUSED */ 477 int 478 kex_input_kexinit(int type, u_int32_t seq, void *ctxt) 479 { 480 struct ssh *ssh = ctxt; 481 struct kex *kex = ssh->kex; 482 const u_char *ptr; 483 u_int i; 484 size_t dlen; 485 int r; 486 487 debug("SSH2_MSG_KEXINIT received"); 488 if (kex == NULL) 489 return SSH_ERR_INVALID_ARGUMENT; 490 491 ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, NULL); 492 ptr = sshpkt_ptr(ssh, &dlen); 493 if ((r = sshbuf_put(kex->peer, ptr, dlen)) != 0) 494 return r; 495 496 /* discard packet */ 497 for (i = 0; i < KEX_COOKIE_LEN; i++) 498 if ((r = sshpkt_get_u8(ssh, NULL)) != 0) 499 return r; 500 for (i = 0; i < PROPOSAL_MAX; i++) 501 if ((r = sshpkt_get_string(ssh, NULL, NULL)) != 0) 502 return r; 503 /* 504 * XXX RFC4253 sec 7: "each side MAY guess" - currently no supported 505 * KEX method has the server move first, but a server might be using 506 * a custom method or one that we otherwise don't support. We should 507 * be prepared to remember first_kex_follows here so we can eat a 508 * packet later. 509 * XXX2 - RFC4253 is kind of ambiguous on what first_kex_follows means 510 * for cases where the server *doesn't* go first. I guess we should 511 * ignore it when it is set for these cases, which is what we do now. 512 */ 513 if ((r = sshpkt_get_u8(ssh, NULL)) != 0 || /* first_kex_follows */ 514 (r = sshpkt_get_u32(ssh, NULL)) != 0 || /* reserved */ 515 (r = sshpkt_get_end(ssh)) != 0) 516 return r; 517 518 if (!(kex->flags & KEX_INIT_SENT)) 519 if ((r = kex_send_kexinit(ssh)) != 0) 520 return r; 521 if ((r = kex_choose_conf(ssh)) != 0) 522 return r; 523 524 if (kex->kex_type < KEX_MAX && kex->kex[kex->kex_type] != NULL) 525 return (kex->kex[kex->kex_type])(ssh); 526 527 return SSH_ERR_INTERNAL_ERROR; 528 } 529 530 int 531 kex_new(struct ssh *ssh, char *proposal[PROPOSAL_MAX], struct kex **kexp) 532 { 533 struct kex *kex; 534 int r; 535 536 *kexp = NULL; 537 if ((kex = calloc(1, sizeof(*kex))) == NULL) 538 return SSH_ERR_ALLOC_FAIL; 539 if ((kex->peer = sshbuf_new()) == NULL || 540 (kex->my = sshbuf_new()) == NULL) { 541 r = SSH_ERR_ALLOC_FAIL; 542 goto out; 543 } 544 if ((r = kex_prop2buf(kex->my, proposal)) != 0) 545 goto out; 546 kex->done = 0; 547 kex_reset_dispatch(ssh); 548 ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit); 549 r = 0; 550 *kexp = kex; 551 out: 552 if (r != 0) 553 kex_free(kex); 554 return r; 555 } 556 557 void 558 kex_free_newkeys(struct newkeys *newkeys) 559 { 560 if (newkeys == NULL) 561 return; 562 if (newkeys->enc.key) { 563 explicit_bzero(newkeys->enc.key, newkeys->enc.key_len); 564 free(newkeys->enc.key); 565 newkeys->enc.key = NULL; 566 } 567 if (newkeys->enc.iv) { 568 explicit_bzero(newkeys->enc.iv, newkeys->enc.iv_len); 569 free(newkeys->enc.iv); 570 newkeys->enc.iv = NULL; 571 } 572 free(newkeys->enc.name); 573 explicit_bzero(&newkeys->enc, sizeof(newkeys->enc)); 574 free(newkeys->comp.name); 575 explicit_bzero(&newkeys->comp, sizeof(newkeys->comp)); 576 mac_clear(&newkeys->mac); 577 if (newkeys->mac.key) { 578 explicit_bzero(newkeys->mac.key, newkeys->mac.key_len); 579 free(newkeys->mac.key); 580 newkeys->mac.key = NULL; 581 } 582 free(newkeys->mac.name); 583 explicit_bzero(&newkeys->mac, sizeof(newkeys->mac)); 584 explicit_bzero(newkeys, sizeof(*newkeys)); 585 free(newkeys); 586 } 587 588 void 589 kex_free(struct kex *kex) 590 { 591 u_int mode; 592 593 #ifdef WITH_OPENSSL 594 if (kex->dh) 595 DH_free(kex->dh); 596 #ifdef OPENSSL_HAS_ECC 597 if (kex->ec_client_key) 598 EC_KEY_free(kex->ec_client_key); 599 #endif /* OPENSSL_HAS_ECC */ 600 #endif /* WITH_OPENSSL */ 601 for (mode = 0; mode < MODE_MAX; mode++) { 602 kex_free_newkeys(kex->newkeys[mode]); 603 kex->newkeys[mode] = NULL; 604 } 605 sshbuf_free(kex->peer); 606 sshbuf_free(kex->my); 607 free(kex->session_id); 608 free(kex->client_version_string); 609 free(kex->server_version_string); 610 free(kex->failed_choice); 611 free(kex->hostkey_alg); 612 free(kex->name); 613 free(kex); 614 } 615 616 int 617 kex_setup(struct ssh *ssh, char *proposal[PROPOSAL_MAX]) 618 { 619 int r; 620 621 if ((r = kex_new(ssh, proposal, &ssh->kex)) != 0) 622 return r; 623 if ((r = kex_send_kexinit(ssh)) != 0) { /* we start */ 624 kex_free(ssh->kex); 625 ssh->kex = NULL; 626 return r; 627 } 628 return 0; 629 } 630 631 /* 632 * Request key re-exchange, returns 0 on success or a ssherr.h error 633 * code otherwise. Must not be called if KEX is incomplete or in-progress. 634 */ 635 int 636 kex_start_rekex(struct ssh *ssh) 637 { 638 if (ssh->kex == NULL) { 639 error("%s: no kex", __func__); 640 return SSH_ERR_INTERNAL_ERROR; 641 } 642 if (ssh->kex->done == 0) { 643 error("%s: requested twice", __func__); 644 return SSH_ERR_INTERNAL_ERROR; 645 } 646 ssh->kex->done = 0; 647 return kex_send_kexinit(ssh); 648 } 649 650 static int 651 choose_enc(struct sshenc *enc, char *client, char *server) 652 { 653 char *name = match_list(client, server, NULL); 654 655 if (name == NULL) 656 return SSH_ERR_NO_CIPHER_ALG_MATCH; 657 if ((enc->cipher = cipher_by_name(name)) == NULL) { 658 free(name); 659 return SSH_ERR_INTERNAL_ERROR; 660 } 661 enc->name = name; 662 enc->enabled = 0; 663 enc->iv = NULL; 664 enc->iv_len = cipher_ivlen(enc->cipher); 665 enc->key = NULL; 666 enc->key_len = cipher_keylen(enc->cipher); 667 enc->block_size = cipher_blocksize(enc->cipher); 668 return 0; 669 } 670 671 static int 672 choose_mac(struct ssh *ssh, struct sshmac *mac, char *client, char *server) 673 { 674 char *name = match_list(client, server, NULL); 675 676 if (name == NULL) 677 return SSH_ERR_NO_MAC_ALG_MATCH; 678 if (mac_setup(mac, name) < 0) { 679 free(name); 680 return SSH_ERR_INTERNAL_ERROR; 681 } 682 /* truncate the key */ 683 if (ssh->compat & SSH_BUG_HMAC) 684 mac->key_len = 16; 685 mac->name = name; 686 mac->key = NULL; 687 mac->enabled = 0; 688 return 0; 689 } 690 691 static int 692 choose_comp(struct sshcomp *comp, char *client, char *server) 693 { 694 char *name = match_list(client, server, NULL); 695 696 if (name == NULL) 697 return SSH_ERR_NO_COMPRESS_ALG_MATCH; 698 if (strcmp(name, "zlib@openssh.com") == 0) { 699 comp->type = COMP_DELAYED; 700 } else if (strcmp(name, "zlib") == 0) { 701 comp->type = COMP_ZLIB; 702 } else if (strcmp(name, "none") == 0) { 703 comp->type = COMP_NONE; 704 } else { 705 free(name); 706 return SSH_ERR_INTERNAL_ERROR; 707 } 708 comp->name = name; 709 return 0; 710 } 711 712 static int 713 choose_kex(struct kex *k, char *client, char *server) 714 { 715 const struct kexalg *kexalg; 716 717 k->name = match_list(client, server, NULL); 718 719 debug("kex: algorithm: %s", k->name ? k->name : "(no match)"); 720 if (k->name == NULL) 721 return SSH_ERR_NO_KEX_ALG_MATCH; 722 if ((kexalg = kex_alg_by_name(k->name)) == NULL) 723 return SSH_ERR_INTERNAL_ERROR; 724 k->kex_type = kexalg->type; 725 k->hash_alg = kexalg->hash_alg; 726 k->ec_nid = kexalg->ec_nid; 727 return 0; 728 } 729 730 static int 731 choose_hostkeyalg(struct kex *k, char *client, char *server) 732 { 733 k->hostkey_alg = match_list(client, server, NULL); 734 735 debug("kex: host key algorithm: %s", 736 k->hostkey_alg ? k->hostkey_alg : "(no match)"); 737 if (k->hostkey_alg == NULL) 738 return SSH_ERR_NO_HOSTKEY_ALG_MATCH; 739 k->hostkey_type = sshkey_type_from_name(k->hostkey_alg); 740 if (k->hostkey_type == KEY_UNSPEC) 741 return SSH_ERR_INTERNAL_ERROR; 742 k->hostkey_nid = sshkey_ecdsa_nid_from_name(k->hostkey_alg); 743 return 0; 744 } 745 746 static int 747 proposals_match(char *my[PROPOSAL_MAX], char *peer[PROPOSAL_MAX]) 748 { 749 static int check[] = { 750 PROPOSAL_KEX_ALGS, PROPOSAL_SERVER_HOST_KEY_ALGS, -1 751 }; 752 int *idx; 753 char *p; 754 755 for (idx = &check[0]; *idx != -1; idx++) { 756 if ((p = strchr(my[*idx], ',')) != NULL) 757 *p = '\0'; 758 if ((p = strchr(peer[*idx], ',')) != NULL) 759 *p = '\0'; 760 if (strcmp(my[*idx], peer[*idx]) != 0) { 761 debug2("proposal mismatch: my %s peer %s", 762 my[*idx], peer[*idx]); 763 return (0); 764 } 765 } 766 debug2("proposals match"); 767 return (1); 768 } 769 770 static int 771 kex_choose_conf(struct ssh *ssh) 772 { 773 struct kex *kex = ssh->kex; 774 struct newkeys *newkeys; 775 char **my = NULL, **peer = NULL; 776 char **cprop, **sprop; 777 int nenc, nmac, ncomp; 778 u_int mode, ctos, need, dh_need, authlen; 779 int r, first_kex_follows; 780 781 debug2("local %s KEXINIT proposal", kex->server ? "server" : "client"); 782 if ((r = kex_buf2prop(kex->my, NULL, &my)) != 0) 783 goto out; 784 debug2("peer %s KEXINIT proposal", kex->server ? "client" : "server"); 785 if ((r = kex_buf2prop(kex->peer, &first_kex_follows, &peer)) != 0) 786 goto out; 787 788 if (kex->server) { 789 cprop=peer; 790 sprop=my; 791 } else { 792 cprop=my; 793 sprop=peer; 794 } 795 796 /* Check whether client supports ext_info_c */ 797 if (kex->server) { 798 char *ext; 799 800 ext = match_list("ext-info-c", peer[PROPOSAL_KEX_ALGS], NULL); 801 kex->ext_info_c = (ext != NULL); 802 free(ext); 803 } 804 805 /* Algorithm Negotiation */ 806 if ((r = choose_kex(kex, cprop[PROPOSAL_KEX_ALGS], 807 sprop[PROPOSAL_KEX_ALGS])) != 0) { 808 kex->failed_choice = peer[PROPOSAL_KEX_ALGS]; 809 peer[PROPOSAL_KEX_ALGS] = NULL; 810 goto out; 811 } 812 if ((r = choose_hostkeyalg(kex, cprop[PROPOSAL_SERVER_HOST_KEY_ALGS], 813 sprop[PROPOSAL_SERVER_HOST_KEY_ALGS])) != 0) { 814 kex->failed_choice = peer[PROPOSAL_SERVER_HOST_KEY_ALGS]; 815 peer[PROPOSAL_SERVER_HOST_KEY_ALGS] = NULL; 816 goto out; 817 } 818 for (mode = 0; mode < MODE_MAX; mode++) { 819 if ((newkeys = calloc(1, sizeof(*newkeys))) == NULL) { 820 r = SSH_ERR_ALLOC_FAIL; 821 goto out; 822 } 823 kex->newkeys[mode] = newkeys; 824 ctos = (!kex->server && mode == MODE_OUT) || 825 (kex->server && mode == MODE_IN); 826 nenc = ctos ? PROPOSAL_ENC_ALGS_CTOS : PROPOSAL_ENC_ALGS_STOC; 827 nmac = ctos ? PROPOSAL_MAC_ALGS_CTOS : PROPOSAL_MAC_ALGS_STOC; 828 ncomp = ctos ? PROPOSAL_COMP_ALGS_CTOS : PROPOSAL_COMP_ALGS_STOC; 829 if ((r = choose_enc(&newkeys->enc, cprop[nenc], 830 sprop[nenc])) != 0) { 831 kex->failed_choice = peer[nenc]; 832 peer[nenc] = NULL; 833 goto out; 834 } 835 authlen = cipher_authlen(newkeys->enc.cipher); 836 /* ignore mac for authenticated encryption */ 837 if (authlen == 0 && 838 (r = choose_mac(ssh, &newkeys->mac, cprop[nmac], 839 sprop[nmac])) != 0) { 840 kex->failed_choice = peer[nmac]; 841 peer[nmac] = NULL; 842 goto out; 843 } 844 if ((r = choose_comp(&newkeys->comp, cprop[ncomp], 845 sprop[ncomp])) != 0) { 846 kex->failed_choice = peer[ncomp]; 847 peer[ncomp] = NULL; 848 goto out; 849 } 850 debug("kex: %s cipher: %s MAC: %s compression: %s", 851 ctos ? "client->server" : "server->client", 852 newkeys->enc.name, 853 authlen == 0 ? newkeys->mac.name : "<implicit>", 854 newkeys->comp.name); 855 } 856 need = dh_need = 0; 857 for (mode = 0; mode < MODE_MAX; mode++) { 858 newkeys = kex->newkeys[mode]; 859 need = MAXIMUM(need, newkeys->enc.key_len); 860 need = MAXIMUM(need, newkeys->enc.block_size); 861 need = MAXIMUM(need, newkeys->enc.iv_len); 862 need = MAXIMUM(need, newkeys->mac.key_len); 863 dh_need = MAXIMUM(dh_need, cipher_seclen(newkeys->enc.cipher)); 864 dh_need = MAXIMUM(dh_need, newkeys->enc.block_size); 865 dh_need = MAXIMUM(dh_need, newkeys->enc.iv_len); 866 dh_need = MAXIMUM(dh_need, newkeys->mac.key_len); 867 } 868 /* XXX need runden? */ 869 kex->we_need = need; 870 kex->dh_need = dh_need; 871 872 /* ignore the next message if the proposals do not match */ 873 if (first_kex_follows && !proposals_match(my, peer) && 874 !(ssh->compat & SSH_BUG_FIRSTKEX)) 875 ssh->dispatch_skip_packets = 1; 876 r = 0; 877 out: 878 kex_prop_free(my); 879 kex_prop_free(peer); 880 return r; 881 } 882 883 static int 884 derive_key(struct ssh *ssh, int id, u_int need, u_char *hash, u_int hashlen, 885 const struct sshbuf *shared_secret, u_char **keyp) 886 { 887 struct kex *kex = ssh->kex; 888 struct ssh_digest_ctx *hashctx = NULL; 889 char c = id; 890 u_int have; 891 size_t mdsz; 892 u_char *digest; 893 int r; 894 895 if ((mdsz = ssh_digest_bytes(kex->hash_alg)) == 0) 896 return SSH_ERR_INVALID_ARGUMENT; 897 if ((digest = calloc(1, ROUNDUP(need, mdsz))) == NULL) { 898 r = SSH_ERR_ALLOC_FAIL; 899 goto out; 900 } 901 902 /* K1 = HASH(K || H || "A" || session_id) */ 903 if ((hashctx = ssh_digest_start(kex->hash_alg)) == NULL || 904 ssh_digest_update_buffer(hashctx, shared_secret) != 0 || 905 ssh_digest_update(hashctx, hash, hashlen) != 0 || 906 ssh_digest_update(hashctx, &c, 1) != 0 || 907 ssh_digest_update(hashctx, kex->session_id, 908 kex->session_id_len) != 0 || 909 ssh_digest_final(hashctx, digest, mdsz) != 0) { 910 r = SSH_ERR_LIBCRYPTO_ERROR; 911 goto out; 912 } 913 ssh_digest_free(hashctx); 914 hashctx = NULL; 915 916 /* 917 * expand key: 918 * Kn = HASH(K || H || K1 || K2 || ... || Kn-1) 919 * Key = K1 || K2 || ... || Kn 920 */ 921 for (have = mdsz; need > have; have += mdsz) { 922 if ((hashctx = ssh_digest_start(kex->hash_alg)) == NULL || 923 ssh_digest_update_buffer(hashctx, shared_secret) != 0 || 924 ssh_digest_update(hashctx, hash, hashlen) != 0 || 925 ssh_digest_update(hashctx, digest, have) != 0 || 926 ssh_digest_final(hashctx, digest + have, mdsz) != 0) { 927 r = SSH_ERR_LIBCRYPTO_ERROR; 928 goto out; 929 } 930 ssh_digest_free(hashctx); 931 hashctx = NULL; 932 } 933 #ifdef DEBUG_KEX 934 fprintf(stderr, "key '%c'== ", c); 935 dump_digest("key", digest, need); 936 #endif 937 *keyp = digest; 938 digest = NULL; 939 r = 0; 940 out: 941 free(digest); 942 ssh_digest_free(hashctx); 943 return r; 944 } 945 946 #define NKEYS 6 947 int 948 kex_derive_keys(struct ssh *ssh, u_char *hash, u_int hashlen, 949 const struct sshbuf *shared_secret) 950 { 951 struct kex *kex = ssh->kex; 952 u_char *keys[NKEYS]; 953 u_int i, j, mode, ctos; 954 int r; 955 956 for (i = 0; i < NKEYS; i++) { 957 if ((r = derive_key(ssh, 'A'+i, kex->we_need, hash, hashlen, 958 shared_secret, &keys[i])) != 0) { 959 for (j = 0; j < i; j++) 960 free(keys[j]); 961 return r; 962 } 963 } 964 for (mode = 0; mode < MODE_MAX; mode++) { 965 ctos = (!kex->server && mode == MODE_OUT) || 966 (kex->server && mode == MODE_IN); 967 kex->newkeys[mode]->enc.iv = keys[ctos ? 0 : 1]; 968 kex->newkeys[mode]->enc.key = keys[ctos ? 2 : 3]; 969 kex->newkeys[mode]->mac.key = keys[ctos ? 4 : 5]; 970 } 971 return 0; 972 } 973 974 #ifdef WITH_OPENSSL 975 int 976 kex_derive_keys_bn(struct ssh *ssh, u_char *hash, u_int hashlen, 977 const BIGNUM *secret) 978 { 979 struct sshbuf *shared_secret; 980 int r; 981 982 if ((shared_secret = sshbuf_new()) == NULL) 983 return SSH_ERR_ALLOC_FAIL; 984 if ((r = sshbuf_put_bignum2(shared_secret, secret)) == 0) 985 r = kex_derive_keys(ssh, hash, hashlen, shared_secret); 986 sshbuf_free(shared_secret); 987 return r; 988 } 989 #endif 990 991 #ifdef WITH_SSH1 992 int 993 derive_ssh1_session_id(BIGNUM *host_modulus, BIGNUM *server_modulus, 994 u_int8_t cookie[8], u_int8_t id[16]) 995 { 996 u_int8_t hbuf[2048], sbuf[2048], obuf[SSH_DIGEST_MAX_LENGTH]; 997 struct ssh_digest_ctx *hashctx = NULL; 998 size_t hlen, slen; 999 int r; 1000 1001 hlen = BN_num_bytes(host_modulus); 1002 slen = BN_num_bytes(server_modulus); 1003 if (hlen < (512 / 8) || (u_int)hlen > sizeof(hbuf) || 1004 slen < (512 / 8) || (u_int)slen > sizeof(sbuf)) 1005 return SSH_ERR_KEY_BITS_MISMATCH; 1006 if (BN_bn2bin(host_modulus, hbuf) <= 0 || 1007 BN_bn2bin(server_modulus, sbuf) <= 0) { 1008 r = SSH_ERR_LIBCRYPTO_ERROR; 1009 goto out; 1010 } 1011 if ((hashctx = ssh_digest_start(SSH_DIGEST_MD5)) == NULL) { 1012 r = SSH_ERR_ALLOC_FAIL; 1013 goto out; 1014 } 1015 if (ssh_digest_update(hashctx, hbuf, hlen) != 0 || 1016 ssh_digest_update(hashctx, sbuf, slen) != 0 || 1017 ssh_digest_update(hashctx, cookie, 8) != 0 || 1018 ssh_digest_final(hashctx, obuf, sizeof(obuf)) != 0) { 1019 r = SSH_ERR_LIBCRYPTO_ERROR; 1020 goto out; 1021 } 1022 memcpy(id, obuf, ssh_digest_bytes(SSH_DIGEST_MD5)); 1023 r = 0; 1024 out: 1025 ssh_digest_free(hashctx); 1026 explicit_bzero(hbuf, sizeof(hbuf)); 1027 explicit_bzero(sbuf, sizeof(sbuf)); 1028 explicit_bzero(obuf, sizeof(obuf)); 1029 return r; 1030 } 1031 #endif 1032 1033 #if defined(DEBUG_KEX) || defined(DEBUG_KEXDH) || defined(DEBUG_KEXECDH) 1034 void 1035 dump_digest(char *msg, u_char *digest, int len) 1036 { 1037 fprintf(stderr, "%s\n", msg); 1038 sshbuf_dump_data(digest, len, stderr); 1039 } 1040 #endif 1041