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 * This file contains code implementing the packet protocol and communication 6 * with the other side. This same code is used both on client and server side. 7 * 8 * As far as I am concerned, the code I have written for this software 9 * can be used freely for any purpose. Any derived versions of this 10 * software must be clearly marked as such, and if the derived work is 11 * incompatible with the protocol description in the RFC file, it must be 12 * called by a name other than "ssh" or "Secure Shell". 13 * 14 * 15 * SSH2 packet format added by Markus Friedl. 16 * Copyright (c) 2000, 2001 Markus Friedl. All rights reserved. 17 * 18 * Redistribution and use in source and binary forms, with or without 19 * modification, are permitted provided that the following conditions 20 * are met: 21 * 1. Redistributions of source code must retain the above copyright 22 * notice, this list of conditions and the following disclaimer. 23 * 2. Redistributions in binary form must reproduce the above copyright 24 * notice, this list of conditions and the following disclaimer in the 25 * documentation and/or other materials provided with the distribution. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 28 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 29 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 30 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 31 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 32 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 33 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 34 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 35 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 36 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include "includes.h" 40 RCSID("$OpenBSD: packet.c,v 1.112 2003/09/23 20:17:11 markus Exp $"); 41 42 #include "openbsd-compat/sys-queue.h" 43 44 #include "xmalloc.h" 45 #include "buffer.h" 46 #include "packet.h" 47 #include "bufaux.h" 48 #include "crc32.h" 49 #include "getput.h" 50 51 #include "compress.h" 52 #include "deattack.h" 53 #include "channels.h" 54 55 #include "compat.h" 56 #include "ssh1.h" 57 #include "ssh2.h" 58 59 #include "cipher.h" 60 #include "kex.h" 61 #include "mac.h" 62 #include "log.h" 63 #include "canohost.h" 64 #include "misc.h" 65 #include "ssh.h" 66 67 #ifdef PACKET_DEBUG 68 #define DBG(x) x 69 #else 70 #define DBG(x) 71 #endif 72 73 /* 74 * This variable contains the file descriptors used for communicating with 75 * the other side. connection_in is used for reading; connection_out for 76 * writing. These can be the same descriptor, in which case it is assumed to 77 * be a socket. 78 */ 79 static int connection_in = -1; 80 static int connection_out = -1; 81 82 /* Protocol flags for the remote side. */ 83 static u_int remote_protocol_flags = 0; 84 85 /* Encryption context for receiving data. This is only used for decryption. */ 86 static CipherContext receive_context; 87 88 /* Encryption context for sending data. This is only used for encryption. */ 89 static CipherContext send_context; 90 91 /* Buffer for raw input data from the socket. */ 92 Buffer input; 93 94 /* Buffer for raw output data going to the socket. */ 95 Buffer output; 96 97 /* Buffer for the partial outgoing packet being constructed. */ 98 static Buffer outgoing_packet; 99 100 /* Buffer for the incoming packet currently being processed. */ 101 static Buffer incoming_packet; 102 103 /* Scratch buffer for packet compression/decompression. */ 104 static Buffer compression_buffer; 105 static int compression_buffer_ready = 0; 106 107 /* Flag indicating whether packet compression/decompression is enabled. */ 108 static int packet_compression = 0; 109 110 /* default maximum packet size */ 111 u_int max_packet_size = 32768; 112 113 /* Flag indicating whether this module has been initialized. */ 114 static int initialized = 0; 115 116 /* Set to true if the connection is interactive. */ 117 static int interactive_mode = 0; 118 119 /* Session key information for Encryption and MAC */ 120 Newkeys *newkeys[MODE_MAX]; 121 static struct packet_state { 122 u_int32_t seqnr; 123 u_int32_t packets; 124 u_int64_t blocks; 125 } p_read, p_send; 126 127 static u_int64_t max_blocks_in, max_blocks_out; 128 static u_int32_t rekey_limit; 129 130 /* Session key for protocol v1 */ 131 static u_char ssh1_key[SSH_SESSION_KEY_LENGTH]; 132 static u_int ssh1_keylen; 133 134 /* roundup current message to extra_pad bytes */ 135 static u_char extra_pad = 0; 136 137 struct packet { 138 TAILQ_ENTRY(packet) next; 139 u_char type; 140 Buffer payload; 141 }; 142 TAILQ_HEAD(, packet) outgoing; 143 144 /* 145 * Sets the descriptors used for communication. Disables encryption until 146 * packet_set_encryption_key is called. 147 */ 148 void 149 packet_set_connection(int fd_in, int fd_out) 150 { 151 Cipher *none = cipher_by_name("none"); 152 153 if (none == NULL) 154 fatal("packet_set_connection: cannot load cipher 'none'"); 155 connection_in = fd_in; 156 connection_out = fd_out; 157 cipher_init(&send_context, none, "", 0, NULL, 0, CIPHER_ENCRYPT); 158 cipher_init(&receive_context, none, "", 0, NULL, 0, CIPHER_DECRYPT); 159 newkeys[MODE_IN] = newkeys[MODE_OUT] = NULL; 160 if (!initialized) { 161 initialized = 1; 162 buffer_init(&input); 163 buffer_init(&output); 164 buffer_init(&outgoing_packet); 165 buffer_init(&incoming_packet); 166 TAILQ_INIT(&outgoing); 167 } 168 } 169 170 /* Returns 1 if remote host is connected via socket, 0 if not. */ 171 172 int 173 packet_connection_is_on_socket(void) 174 { 175 struct sockaddr_storage from, to; 176 socklen_t fromlen, tolen; 177 178 /* filedescriptors in and out are the same, so it's a socket */ 179 if (connection_in == connection_out) 180 return 1; 181 fromlen = sizeof(from); 182 memset(&from, 0, sizeof(from)); 183 if (getpeername(connection_in, (struct sockaddr *)&from, &fromlen) < 0) 184 return 0; 185 tolen = sizeof(to); 186 memset(&to, 0, sizeof(to)); 187 if (getpeername(connection_out, (struct sockaddr *)&to, &tolen) < 0) 188 return 0; 189 if (fromlen != tolen || memcmp(&from, &to, fromlen) != 0) 190 return 0; 191 if (from.ss_family != AF_INET && from.ss_family != AF_INET6) 192 return 0; 193 return 1; 194 } 195 196 /* 197 * Exports an IV from the CipherContext required to export the key 198 * state back from the unprivileged child to the privileged parent 199 * process. 200 */ 201 202 void 203 packet_get_keyiv(int mode, u_char *iv, u_int len) 204 { 205 CipherContext *cc; 206 207 if (mode == MODE_OUT) 208 cc = &send_context; 209 else 210 cc = &receive_context; 211 212 cipher_get_keyiv(cc, iv, len); 213 } 214 215 int 216 packet_get_keycontext(int mode, u_char *dat) 217 { 218 CipherContext *cc; 219 220 if (mode == MODE_OUT) 221 cc = &send_context; 222 else 223 cc = &receive_context; 224 225 return (cipher_get_keycontext(cc, dat)); 226 } 227 228 void 229 packet_set_keycontext(int mode, u_char *dat) 230 { 231 CipherContext *cc; 232 233 if (mode == MODE_OUT) 234 cc = &send_context; 235 else 236 cc = &receive_context; 237 238 cipher_set_keycontext(cc, dat); 239 } 240 241 int 242 packet_get_keyiv_len(int mode) 243 { 244 CipherContext *cc; 245 246 if (mode == MODE_OUT) 247 cc = &send_context; 248 else 249 cc = &receive_context; 250 251 return (cipher_get_keyiv_len(cc)); 252 } 253 void 254 packet_set_iv(int mode, u_char *dat) 255 { 256 CipherContext *cc; 257 258 if (mode == MODE_OUT) 259 cc = &send_context; 260 else 261 cc = &receive_context; 262 263 cipher_set_keyiv(cc, dat); 264 } 265 int 266 packet_get_ssh1_cipher(void) 267 { 268 return (cipher_get_number(receive_context.cipher)); 269 } 270 271 void 272 packet_get_state(int mode, u_int32_t *seqnr, u_int64_t *blocks, u_int32_t *packets) 273 { 274 struct packet_state *state; 275 276 state = (mode == MODE_IN) ? &p_read : &p_send; 277 *seqnr = state->seqnr; 278 *blocks = state->blocks; 279 *packets = state->packets; 280 } 281 282 void 283 packet_set_state(int mode, u_int32_t seqnr, u_int64_t blocks, u_int32_t packets) 284 { 285 struct packet_state *state; 286 287 state = (mode == MODE_IN) ? &p_read : &p_send; 288 state->seqnr = seqnr; 289 state->blocks = blocks; 290 state->packets = packets; 291 } 292 293 /* returns 1 if connection is via ipv4 */ 294 295 int 296 packet_connection_is_ipv4(void) 297 { 298 struct sockaddr_storage to; 299 socklen_t tolen = sizeof(to); 300 301 memset(&to, 0, sizeof(to)); 302 if (getsockname(connection_out, (struct sockaddr *)&to, &tolen) < 0) 303 return 0; 304 if (to.ss_family == AF_INET) 305 return 1; 306 #ifdef IPV4_IN_IPV6 307 if (to.ss_family == AF_INET6 && 308 IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)&to)->sin6_addr)) 309 return 1; 310 #endif 311 return 0; 312 } 313 314 /* Sets the connection into non-blocking mode. */ 315 316 void 317 packet_set_nonblocking(void) 318 { 319 /* Set the socket into non-blocking mode. */ 320 if (fcntl(connection_in, F_SETFL, O_NONBLOCK) < 0) 321 error("fcntl O_NONBLOCK: %.100s", strerror(errno)); 322 323 if (connection_out != connection_in) { 324 if (fcntl(connection_out, F_SETFL, O_NONBLOCK) < 0) 325 error("fcntl O_NONBLOCK: %.100s", strerror(errno)); 326 } 327 } 328 329 /* Returns the socket used for reading. */ 330 331 int 332 packet_get_connection_in(void) 333 { 334 return connection_in; 335 } 336 337 /* Returns the descriptor used for writing. */ 338 339 int 340 packet_get_connection_out(void) 341 { 342 return connection_out; 343 } 344 345 /* Closes the connection and clears and frees internal data structures. */ 346 347 void 348 packet_close(void) 349 { 350 if (!initialized) 351 return; 352 initialized = 0; 353 if (connection_in == connection_out) { 354 shutdown(connection_out, SHUT_RDWR); 355 close(connection_out); 356 } else { 357 close(connection_in); 358 close(connection_out); 359 } 360 buffer_free(&input); 361 buffer_free(&output); 362 buffer_free(&outgoing_packet); 363 buffer_free(&incoming_packet); 364 if (compression_buffer_ready) { 365 buffer_free(&compression_buffer); 366 buffer_compress_uninit(); 367 } 368 cipher_cleanup(&send_context); 369 cipher_cleanup(&receive_context); 370 } 371 372 /* Sets remote side protocol flags. */ 373 374 void 375 packet_set_protocol_flags(u_int protocol_flags) 376 { 377 remote_protocol_flags = protocol_flags; 378 } 379 380 /* Returns the remote protocol flags set earlier by the above function. */ 381 382 u_int 383 packet_get_protocol_flags(void) 384 { 385 return remote_protocol_flags; 386 } 387 388 /* 389 * Starts packet compression from the next packet on in both directions. 390 * Level is compression level 1 (fastest) - 9 (slow, best) as in gzip. 391 */ 392 393 static void 394 packet_init_compression(void) 395 { 396 if (compression_buffer_ready == 1) 397 return; 398 compression_buffer_ready = 1; 399 buffer_init(&compression_buffer); 400 } 401 402 void 403 packet_start_compression(int level) 404 { 405 if (packet_compression && !compat20) 406 fatal("Compression already enabled."); 407 packet_compression = 1; 408 packet_init_compression(); 409 buffer_compress_init_send(level); 410 buffer_compress_init_recv(); 411 } 412 413 /* 414 * Causes any further packets to be encrypted using the given key. The same 415 * key is used for both sending and reception. However, both directions are 416 * encrypted independently of each other. 417 */ 418 419 void 420 packet_set_encryption_key(const u_char *key, u_int keylen, 421 int number) 422 { 423 Cipher *cipher = cipher_by_number(number); 424 425 if (cipher == NULL) 426 fatal("packet_set_encryption_key: unknown cipher number %d", number); 427 if (keylen < 20) 428 fatal("packet_set_encryption_key: keylen too small: %d", keylen); 429 if (keylen > SSH_SESSION_KEY_LENGTH) 430 fatal("packet_set_encryption_key: keylen too big: %d", keylen); 431 memcpy(ssh1_key, key, keylen); 432 ssh1_keylen = keylen; 433 cipher_init(&send_context, cipher, key, keylen, NULL, 0, CIPHER_ENCRYPT); 434 cipher_init(&receive_context, cipher, key, keylen, NULL, 0, CIPHER_DECRYPT); 435 } 436 437 u_int 438 packet_get_encryption_key(u_char *key) 439 { 440 if (key == NULL) 441 return (ssh1_keylen); 442 memcpy(key, ssh1_key, ssh1_keylen); 443 return (ssh1_keylen); 444 } 445 446 /* Start constructing a packet to send. */ 447 void 448 packet_start(u_char type) 449 { 450 u_char buf[9]; 451 int len; 452 453 DBG(debug("packet_start[%d]", type)); 454 len = compat20 ? 6 : 9; 455 memset(buf, 0, len - 1); 456 buf[len - 1] = type; 457 buffer_clear(&outgoing_packet); 458 buffer_append(&outgoing_packet, buf, len); 459 } 460 461 /* Append payload. */ 462 void 463 packet_put_char(int value) 464 { 465 char ch = value; 466 467 buffer_append(&outgoing_packet, &ch, 1); 468 } 469 void 470 packet_put_int(u_int value) 471 { 472 buffer_put_int(&outgoing_packet, value); 473 } 474 void 475 packet_put_string(const void *buf, u_int len) 476 { 477 buffer_put_string(&outgoing_packet, buf, len); 478 } 479 void 480 packet_put_cstring(const char *str) 481 { 482 buffer_put_cstring(&outgoing_packet, str); 483 } 484 void 485 packet_put_raw(const void *buf, u_int len) 486 { 487 buffer_append(&outgoing_packet, buf, len); 488 } 489 void 490 packet_put_bignum(BIGNUM * value) 491 { 492 buffer_put_bignum(&outgoing_packet, value); 493 } 494 void 495 packet_put_bignum2(BIGNUM * value) 496 { 497 buffer_put_bignum2(&outgoing_packet, value); 498 } 499 500 /* 501 * Finalizes and sends the packet. If the encryption key has been set, 502 * encrypts the packet before sending. 503 */ 504 505 static void 506 packet_send1(void) 507 { 508 u_char buf[8], *cp; 509 int i, padding, len; 510 u_int checksum; 511 u_int32_t rand = 0; 512 513 /* 514 * If using packet compression, compress the payload of the outgoing 515 * packet. 516 */ 517 if (packet_compression) { 518 buffer_clear(&compression_buffer); 519 /* Skip padding. */ 520 buffer_consume(&outgoing_packet, 8); 521 /* padding */ 522 buffer_append(&compression_buffer, "\0\0\0\0\0\0\0\0", 8); 523 buffer_compress(&outgoing_packet, &compression_buffer); 524 buffer_clear(&outgoing_packet); 525 buffer_append(&outgoing_packet, buffer_ptr(&compression_buffer), 526 buffer_len(&compression_buffer)); 527 } 528 /* Compute packet length without padding (add checksum, remove padding). */ 529 len = buffer_len(&outgoing_packet) + 4 - 8; 530 531 /* Insert padding. Initialized to zero in packet_start1() */ 532 padding = 8 - len % 8; 533 if (!send_context.plaintext) { 534 cp = buffer_ptr(&outgoing_packet); 535 for (i = 0; i < padding; i++) { 536 if (i % 4 == 0) 537 rand = arc4random(); 538 cp[7 - i] = rand & 0xff; 539 rand >>= 8; 540 } 541 } 542 buffer_consume(&outgoing_packet, 8 - padding); 543 544 /* Add check bytes. */ 545 checksum = ssh_crc32(buffer_ptr(&outgoing_packet), 546 buffer_len(&outgoing_packet)); 547 PUT_32BIT(buf, checksum); 548 buffer_append(&outgoing_packet, buf, 4); 549 550 #ifdef PACKET_DEBUG 551 fprintf(stderr, "packet_send plain: "); 552 buffer_dump(&outgoing_packet); 553 #endif 554 555 /* Append to output. */ 556 PUT_32BIT(buf, len); 557 buffer_append(&output, buf, 4); 558 cp = buffer_append_space(&output, buffer_len(&outgoing_packet)); 559 cipher_crypt(&send_context, cp, buffer_ptr(&outgoing_packet), 560 buffer_len(&outgoing_packet)); 561 562 #ifdef PACKET_DEBUG 563 fprintf(stderr, "encrypted: "); 564 buffer_dump(&output); 565 #endif 566 567 buffer_clear(&outgoing_packet); 568 569 /* 570 * Note that the packet is now only buffered in output. It won\'t be 571 * actually sent until packet_write_wait or packet_write_poll is 572 * called. 573 */ 574 } 575 576 void 577 set_newkeys(int mode) 578 { 579 Enc *enc; 580 Mac *mac; 581 Comp *comp; 582 CipherContext *cc; 583 u_int64_t *max_blocks; 584 int encrypt; 585 586 debug2("set_newkeys: mode %d", mode); 587 588 if (mode == MODE_OUT) { 589 cc = &send_context; 590 encrypt = CIPHER_ENCRYPT; 591 p_send.packets = p_send.blocks = 0; 592 max_blocks = &max_blocks_out; 593 } else { 594 cc = &receive_context; 595 encrypt = CIPHER_DECRYPT; 596 p_read.packets = p_read.blocks = 0; 597 max_blocks = &max_blocks_in; 598 } 599 if (newkeys[mode] != NULL) { 600 debug("set_newkeys: rekeying"); 601 cipher_cleanup(cc); 602 enc = &newkeys[mode]->enc; 603 mac = &newkeys[mode]->mac; 604 comp = &newkeys[mode]->comp; 605 memset(mac->key, 0, mac->key_len); 606 xfree(enc->name); 607 xfree(enc->iv); 608 xfree(enc->key); 609 xfree(mac->name); 610 xfree(mac->key); 611 xfree(comp->name); 612 xfree(newkeys[mode]); 613 } 614 newkeys[mode] = kex_get_newkeys(mode); 615 if (newkeys[mode] == NULL) 616 fatal("newkeys: no keys for mode %d", mode); 617 enc = &newkeys[mode]->enc; 618 mac = &newkeys[mode]->mac; 619 comp = &newkeys[mode]->comp; 620 if (mac->md != NULL) 621 mac->enabled = 1; 622 DBG(debug("cipher_init_context: %d", mode)); 623 cipher_init(cc, enc->cipher, enc->key, enc->key_len, 624 enc->iv, enc->block_size, encrypt); 625 /* Deleting the keys does not gain extra security */ 626 /* memset(enc->iv, 0, enc->block_size); 627 memset(enc->key, 0, enc->key_len); */ 628 if (comp->type != 0 && comp->enabled == 0) { 629 packet_init_compression(); 630 if (mode == MODE_OUT) 631 buffer_compress_init_send(6); 632 else 633 buffer_compress_init_recv(); 634 comp->enabled = 1; 635 } 636 /* 637 * The 2^(blocksize*2) limit is too expensive for 3DES, 638 * blowfish, etc, so enforce a 1GB limit for small blocksizes. 639 */ 640 if (enc->block_size >= 16) 641 *max_blocks = (u_int64_t)1 << (enc->block_size*2); 642 else 643 *max_blocks = ((u_int64_t)1 << 30) / enc->block_size; 644 if (rekey_limit) 645 *max_blocks = MIN(*max_blocks, rekey_limit / enc->block_size); 646 } 647 648 /* 649 * Finalize packet in SSH2 format (compress, mac, encrypt, enqueue) 650 */ 651 static void 652 packet_send2_wrapped(void) 653 { 654 u_char type, *cp, *macbuf = NULL; 655 u_char padlen, pad; 656 u_int packet_length = 0; 657 u_int i, len; 658 u_int32_t rand = 0; 659 Enc *enc = NULL; 660 Mac *mac = NULL; 661 Comp *comp = NULL; 662 int block_size; 663 664 if (newkeys[MODE_OUT] != NULL) { 665 enc = &newkeys[MODE_OUT]->enc; 666 mac = &newkeys[MODE_OUT]->mac; 667 comp = &newkeys[MODE_OUT]->comp; 668 } 669 block_size = enc ? enc->block_size : 8; 670 671 cp = buffer_ptr(&outgoing_packet); 672 type = cp[5]; 673 674 #ifdef PACKET_DEBUG 675 fprintf(stderr, "plain: "); 676 buffer_dump(&outgoing_packet); 677 #endif 678 679 if (comp && comp->enabled) { 680 len = buffer_len(&outgoing_packet); 681 /* skip header, compress only payload */ 682 buffer_consume(&outgoing_packet, 5); 683 buffer_clear(&compression_buffer); 684 buffer_compress(&outgoing_packet, &compression_buffer); 685 buffer_clear(&outgoing_packet); 686 buffer_append(&outgoing_packet, "\0\0\0\0\0", 5); 687 buffer_append(&outgoing_packet, buffer_ptr(&compression_buffer), 688 buffer_len(&compression_buffer)); 689 DBG(debug("compression: raw %d compressed %d", len, 690 buffer_len(&outgoing_packet))); 691 } 692 693 /* sizeof (packet_len + pad_len + payload) */ 694 len = buffer_len(&outgoing_packet); 695 696 /* 697 * calc size of padding, alloc space, get random data, 698 * minimum padding is 4 bytes 699 */ 700 padlen = block_size - (len % block_size); 701 if (padlen < 4) 702 padlen += block_size; 703 if (extra_pad) { 704 /* will wrap if extra_pad+padlen > 255 */ 705 extra_pad = roundup(extra_pad, block_size); 706 pad = extra_pad - ((len + padlen) % extra_pad); 707 debug3("packet_send2: adding %d (len %d padlen %d extra_pad %d)", 708 pad, len, padlen, extra_pad); 709 padlen += pad; 710 extra_pad = 0; 711 } 712 cp = buffer_append_space(&outgoing_packet, padlen); 713 if (enc && !send_context.plaintext) { 714 /* random padding */ 715 for (i = 0; i < padlen; i++) { 716 if (i % 4 == 0) 717 rand = arc4random(); 718 cp[i] = rand & 0xff; 719 rand >>= 8; 720 } 721 } else { 722 /* clear padding */ 723 memset(cp, 0, padlen); 724 } 725 /* packet_length includes payload, padding and padding length field */ 726 packet_length = buffer_len(&outgoing_packet) - 4; 727 cp = buffer_ptr(&outgoing_packet); 728 PUT_32BIT(cp, packet_length); 729 cp[4] = padlen; 730 DBG(debug("send: len %d (includes padlen %d)", packet_length+4, padlen)); 731 732 /* compute MAC over seqnr and packet(length fields, payload, padding) */ 733 if (mac && mac->enabled) { 734 macbuf = mac_compute(mac, p_send.seqnr, 735 buffer_ptr(&outgoing_packet), 736 buffer_len(&outgoing_packet)); 737 DBG(debug("done calc MAC out #%d", p_send.seqnr)); 738 } 739 /* encrypt packet and append to output buffer. */ 740 cp = buffer_append_space(&output, buffer_len(&outgoing_packet)); 741 cipher_crypt(&send_context, cp, buffer_ptr(&outgoing_packet), 742 buffer_len(&outgoing_packet)); 743 /* append unencrypted MAC */ 744 if (mac && mac->enabled) 745 buffer_append(&output, (char *)macbuf, mac->mac_len); 746 #ifdef PACKET_DEBUG 747 fprintf(stderr, "encrypted: "); 748 buffer_dump(&output); 749 #endif 750 /* increment sequence number for outgoing packets */ 751 if (++p_send.seqnr == 0) 752 logit("outgoing seqnr wraps around"); 753 if (++p_send.packets == 0) 754 if (!(datafellows & SSH_BUG_NOREKEY)) 755 fatal("XXX too many packets with same key"); 756 p_send.blocks += (packet_length + 4) / block_size; 757 buffer_clear(&outgoing_packet); 758 759 if (type == SSH2_MSG_NEWKEYS) 760 set_newkeys(MODE_OUT); 761 } 762 763 static void 764 packet_send2(void) 765 { 766 static int rekeying = 0; 767 struct packet *p; 768 u_char type, *cp; 769 770 cp = buffer_ptr(&outgoing_packet); 771 type = cp[5]; 772 773 /* during rekeying we can only send key exchange messages */ 774 if (rekeying) { 775 if (!((type >= SSH2_MSG_TRANSPORT_MIN) && 776 (type <= SSH2_MSG_TRANSPORT_MAX))) { 777 debug("enqueue packet: %u", type); 778 p = xmalloc(sizeof(*p)); 779 p->type = type; 780 memcpy(&p->payload, &outgoing_packet, sizeof(Buffer)); 781 buffer_init(&outgoing_packet); 782 TAILQ_INSERT_TAIL(&outgoing, p, next); 783 return; 784 } 785 } 786 787 /* rekeying starts with sending KEXINIT */ 788 if (type == SSH2_MSG_KEXINIT) 789 rekeying = 1; 790 791 packet_send2_wrapped(); 792 793 /* after a NEWKEYS message we can send the complete queue */ 794 if (type == SSH2_MSG_NEWKEYS) { 795 rekeying = 0; 796 while ((p = TAILQ_FIRST(&outgoing))) { 797 type = p->type; 798 debug("dequeue packet: %u", type); 799 buffer_free(&outgoing_packet); 800 memcpy(&outgoing_packet, &p->payload, 801 sizeof(Buffer)); 802 TAILQ_REMOVE(&outgoing, p, next); 803 xfree(p); 804 packet_send2_wrapped(); 805 } 806 } 807 } 808 809 void 810 packet_send(void) 811 { 812 if (compat20) 813 packet_send2(); 814 else 815 packet_send1(); 816 DBG(debug("packet_send done")); 817 } 818 819 /* 820 * Waits until a packet has been received, and returns its type. Note that 821 * no other data is processed until this returns, so this function should not 822 * be used during the interactive session. 823 */ 824 825 int 826 packet_read_seqnr(u_int32_t *seqnr_p) 827 { 828 int type, len; 829 fd_set *setp; 830 char buf[8192]; 831 DBG(debug("packet_read()")); 832 833 setp = (fd_set *)xmalloc(howmany(connection_in+1, NFDBITS) * 834 sizeof(fd_mask)); 835 836 /* Since we are blocking, ensure that all written packets have been sent. */ 837 packet_write_wait(); 838 839 /* Stay in the loop until we have received a complete packet. */ 840 for (;;) { 841 /* Try to read a packet from the buffer. */ 842 type = packet_read_poll_seqnr(seqnr_p); 843 if (!compat20 && ( 844 type == SSH_SMSG_SUCCESS 845 || type == SSH_SMSG_FAILURE 846 || type == SSH_CMSG_EOF 847 || type == SSH_CMSG_EXIT_CONFIRMATION)) 848 packet_check_eom(); 849 /* If we got a packet, return it. */ 850 if (type != SSH_MSG_NONE) { 851 xfree(setp); 852 return type; 853 } 854 /* 855 * Otherwise, wait for some data to arrive, add it to the 856 * buffer, and try again. 857 */ 858 memset(setp, 0, howmany(connection_in + 1, NFDBITS) * 859 sizeof(fd_mask)); 860 FD_SET(connection_in, setp); 861 862 /* Wait for some data to arrive. */ 863 while (select(connection_in + 1, setp, NULL, NULL, NULL) == -1 && 864 (errno == EAGAIN || errno == EINTR)) 865 ; 866 867 /* Read data from the socket. */ 868 len = read(connection_in, buf, sizeof(buf)); 869 if (len == 0) { 870 logit("Connection closed by %.200s", get_remote_ipaddr()); 871 cleanup_exit(255); 872 } 873 if (len < 0) 874 fatal("Read from socket failed: %.100s", strerror(errno)); 875 /* Append it to the buffer. */ 876 packet_process_incoming(buf, len); 877 } 878 /* NOTREACHED */ 879 } 880 881 int 882 packet_read(void) 883 { 884 return packet_read_seqnr(NULL); 885 } 886 887 /* 888 * Waits until a packet has been received, verifies that its type matches 889 * that given, and gives a fatal error and exits if there is a mismatch. 890 */ 891 892 void 893 packet_read_expect(int expected_type) 894 { 895 int type; 896 897 type = packet_read(); 898 if (type != expected_type) 899 packet_disconnect("Protocol error: expected packet type %d, got %d", 900 expected_type, type); 901 } 902 903 /* Checks if a full packet is available in the data received so far via 904 * packet_process_incoming. If so, reads the packet; otherwise returns 905 * SSH_MSG_NONE. This does not wait for data from the connection. 906 * 907 * SSH_MSG_DISCONNECT is handled specially here. Also, 908 * SSH_MSG_IGNORE messages are skipped by this function and are never returned 909 * to higher levels. 910 */ 911 912 static int 913 packet_read_poll1(void) 914 { 915 u_int len, padded_len; 916 u_char *cp, type; 917 u_int checksum, stored_checksum; 918 919 /* Check if input size is less than minimum packet size. */ 920 if (buffer_len(&input) < 4 + 8) 921 return SSH_MSG_NONE; 922 /* Get length of incoming packet. */ 923 cp = buffer_ptr(&input); 924 len = GET_32BIT(cp); 925 if (len < 1 + 2 + 2 || len > 256 * 1024) 926 packet_disconnect("Bad packet length %u.", len); 927 padded_len = (len + 8) & ~7; 928 929 /* Check if the packet has been entirely received. */ 930 if (buffer_len(&input) < 4 + padded_len) 931 return SSH_MSG_NONE; 932 933 /* The entire packet is in buffer. */ 934 935 /* Consume packet length. */ 936 buffer_consume(&input, 4); 937 938 /* 939 * Cryptographic attack detector for ssh 940 * (C)1998 CORE-SDI, Buenos Aires Argentina 941 * Ariel Futoransky(futo@core-sdi.com) 942 */ 943 if (!receive_context.plaintext && 944 detect_attack(buffer_ptr(&input), padded_len, NULL) == DEATTACK_DETECTED) 945 packet_disconnect("crc32 compensation attack: network attack detected"); 946 947 /* Decrypt data to incoming_packet. */ 948 buffer_clear(&incoming_packet); 949 cp = buffer_append_space(&incoming_packet, padded_len); 950 cipher_crypt(&receive_context, cp, buffer_ptr(&input), padded_len); 951 952 buffer_consume(&input, padded_len); 953 954 #ifdef PACKET_DEBUG 955 fprintf(stderr, "read_poll plain: "); 956 buffer_dump(&incoming_packet); 957 #endif 958 959 /* Compute packet checksum. */ 960 checksum = ssh_crc32(buffer_ptr(&incoming_packet), 961 buffer_len(&incoming_packet) - 4); 962 963 /* Skip padding. */ 964 buffer_consume(&incoming_packet, 8 - len % 8); 965 966 /* Test check bytes. */ 967 if (len != buffer_len(&incoming_packet)) 968 packet_disconnect("packet_read_poll1: len %d != buffer_len %d.", 969 len, buffer_len(&incoming_packet)); 970 971 cp = (u_char *)buffer_ptr(&incoming_packet) + len - 4; 972 stored_checksum = GET_32BIT(cp); 973 if (checksum != stored_checksum) 974 packet_disconnect("Corrupted check bytes on input."); 975 buffer_consume_end(&incoming_packet, 4); 976 977 if (packet_compression) { 978 buffer_clear(&compression_buffer); 979 buffer_uncompress(&incoming_packet, &compression_buffer); 980 buffer_clear(&incoming_packet); 981 buffer_append(&incoming_packet, buffer_ptr(&compression_buffer), 982 buffer_len(&compression_buffer)); 983 } 984 type = buffer_get_char(&incoming_packet); 985 return type; 986 } 987 988 static int 989 packet_read_poll2(u_int32_t *seqnr_p) 990 { 991 static u_int packet_length = 0; 992 u_int padlen, need; 993 u_char *macbuf, *cp, type; 994 int maclen, block_size; 995 Enc *enc = NULL; 996 Mac *mac = NULL; 997 Comp *comp = NULL; 998 999 if (newkeys[MODE_IN] != NULL) { 1000 enc = &newkeys[MODE_IN]->enc; 1001 mac = &newkeys[MODE_IN]->mac; 1002 comp = &newkeys[MODE_IN]->comp; 1003 } 1004 maclen = mac && mac->enabled ? mac->mac_len : 0; 1005 block_size = enc ? enc->block_size : 8; 1006 1007 if (packet_length == 0) { 1008 /* 1009 * check if input size is less than the cipher block size, 1010 * decrypt first block and extract length of incoming packet 1011 */ 1012 if (buffer_len(&input) < block_size) 1013 return SSH_MSG_NONE; 1014 buffer_clear(&incoming_packet); 1015 cp = buffer_append_space(&incoming_packet, block_size); 1016 cipher_crypt(&receive_context, cp, buffer_ptr(&input), 1017 block_size); 1018 cp = buffer_ptr(&incoming_packet); 1019 packet_length = GET_32BIT(cp); 1020 if (packet_length < 1 + 4 || packet_length > 256 * 1024) { 1021 #ifdef PACKET_DEBUG 1022 buffer_dump(&incoming_packet); 1023 #endif 1024 packet_disconnect("Bad packet length %u.", packet_length); 1025 } 1026 DBG(debug("input: packet len %u", packet_length+4)); 1027 buffer_consume(&input, block_size); 1028 } 1029 /* we have a partial packet of block_size bytes */ 1030 need = 4 + packet_length - block_size; 1031 DBG(debug("partial packet %d, need %d, maclen %d", block_size, 1032 need, maclen)); 1033 if (need % block_size != 0) 1034 fatal("padding error: need %d block %d mod %d", 1035 need, block_size, need % block_size); 1036 /* 1037 * check if the entire packet has been received and 1038 * decrypt into incoming_packet 1039 */ 1040 if (buffer_len(&input) < need + maclen) 1041 return SSH_MSG_NONE; 1042 #ifdef PACKET_DEBUG 1043 fprintf(stderr, "read_poll enc/full: "); 1044 buffer_dump(&input); 1045 #endif 1046 cp = buffer_append_space(&incoming_packet, need); 1047 cipher_crypt(&receive_context, cp, buffer_ptr(&input), need); 1048 buffer_consume(&input, need); 1049 /* 1050 * compute MAC over seqnr and packet, 1051 * increment sequence number for incoming packet 1052 */ 1053 if (mac && mac->enabled) { 1054 macbuf = mac_compute(mac, p_read.seqnr, 1055 buffer_ptr(&incoming_packet), 1056 buffer_len(&incoming_packet)); 1057 if (memcmp(macbuf, buffer_ptr(&input), mac->mac_len) != 0) 1058 packet_disconnect("Corrupted MAC on input."); 1059 DBG(debug("MAC #%d ok", p_read.seqnr)); 1060 buffer_consume(&input, mac->mac_len); 1061 } 1062 if (seqnr_p != NULL) 1063 *seqnr_p = p_read.seqnr; 1064 if (++p_read.seqnr == 0) 1065 logit("incoming seqnr wraps around"); 1066 if (++p_read.packets == 0) 1067 if (!(datafellows & SSH_BUG_NOREKEY)) 1068 fatal("XXX too many packets with same key"); 1069 p_read.blocks += (packet_length + 4) / block_size; 1070 1071 /* get padlen */ 1072 cp = buffer_ptr(&incoming_packet); 1073 padlen = cp[4]; 1074 DBG(debug("input: padlen %d", padlen)); 1075 if (padlen < 4) 1076 packet_disconnect("Corrupted padlen %d on input.", padlen); 1077 1078 /* skip packet size + padlen, discard padding */ 1079 buffer_consume(&incoming_packet, 4 + 1); 1080 buffer_consume_end(&incoming_packet, padlen); 1081 1082 DBG(debug("input: len before de-compress %d", buffer_len(&incoming_packet))); 1083 if (comp && comp->enabled) { 1084 buffer_clear(&compression_buffer); 1085 buffer_uncompress(&incoming_packet, &compression_buffer); 1086 buffer_clear(&incoming_packet); 1087 buffer_append(&incoming_packet, buffer_ptr(&compression_buffer), 1088 buffer_len(&compression_buffer)); 1089 DBG(debug("input: len after de-compress %d", 1090 buffer_len(&incoming_packet))); 1091 } 1092 /* 1093 * get packet type, implies consume. 1094 * return length of payload (without type field) 1095 */ 1096 type = buffer_get_char(&incoming_packet); 1097 if (type == SSH2_MSG_NEWKEYS) 1098 set_newkeys(MODE_IN); 1099 #ifdef PACKET_DEBUG 1100 fprintf(stderr, "read/plain[%d]:\r\n", type); 1101 buffer_dump(&incoming_packet); 1102 #endif 1103 /* reset for next packet */ 1104 packet_length = 0; 1105 return type; 1106 } 1107 1108 int 1109 packet_read_poll_seqnr(u_int32_t *seqnr_p) 1110 { 1111 u_int reason, seqnr; 1112 u_char type; 1113 char *msg; 1114 1115 for (;;) { 1116 if (compat20) { 1117 type = packet_read_poll2(seqnr_p); 1118 if (type) 1119 DBG(debug("received packet type %d", type)); 1120 switch (type) { 1121 case SSH2_MSG_IGNORE: 1122 break; 1123 case SSH2_MSG_DEBUG: 1124 packet_get_char(); 1125 msg = packet_get_string(NULL); 1126 debug("Remote: %.900s", msg); 1127 xfree(msg); 1128 msg = packet_get_string(NULL); 1129 xfree(msg); 1130 break; 1131 case SSH2_MSG_DISCONNECT: 1132 reason = packet_get_int(); 1133 msg = packet_get_string(NULL); 1134 logit("Received disconnect from %s: %u: %.400s", 1135 get_remote_ipaddr(), reason, msg); 1136 xfree(msg); 1137 cleanup_exit(255); 1138 break; 1139 case SSH2_MSG_UNIMPLEMENTED: 1140 seqnr = packet_get_int(); 1141 debug("Received SSH2_MSG_UNIMPLEMENTED for %u", 1142 seqnr); 1143 break; 1144 default: 1145 return type; 1146 break; 1147 } 1148 } else { 1149 type = packet_read_poll1(); 1150 switch (type) { 1151 case SSH_MSG_IGNORE: 1152 break; 1153 case SSH_MSG_DEBUG: 1154 msg = packet_get_string(NULL); 1155 debug("Remote: %.900s", msg); 1156 xfree(msg); 1157 break; 1158 case SSH_MSG_DISCONNECT: 1159 msg = packet_get_string(NULL); 1160 logit("Received disconnect from %s: %.400s", 1161 get_remote_ipaddr(), msg); 1162 cleanup_exit(255); 1163 xfree(msg); 1164 break; 1165 default: 1166 if (type) 1167 DBG(debug("received packet type %d", type)); 1168 return type; 1169 break; 1170 } 1171 } 1172 } 1173 } 1174 1175 int 1176 packet_read_poll(void) 1177 { 1178 return packet_read_poll_seqnr(NULL); 1179 } 1180 1181 /* 1182 * Buffers the given amount of input characters. This is intended to be used 1183 * together with packet_read_poll. 1184 */ 1185 1186 void 1187 packet_process_incoming(const char *buf, u_int len) 1188 { 1189 buffer_append(&input, buf, len); 1190 } 1191 1192 /* Returns a character from the packet. */ 1193 1194 u_int 1195 packet_get_char(void) 1196 { 1197 char ch; 1198 1199 buffer_get(&incoming_packet, &ch, 1); 1200 return (u_char) ch; 1201 } 1202 1203 /* Returns an integer from the packet data. */ 1204 1205 u_int 1206 packet_get_int(void) 1207 { 1208 return buffer_get_int(&incoming_packet); 1209 } 1210 1211 /* 1212 * Returns an arbitrary precision integer from the packet data. The integer 1213 * must have been initialized before this call. 1214 */ 1215 1216 void 1217 packet_get_bignum(BIGNUM * value) 1218 { 1219 buffer_get_bignum(&incoming_packet, value); 1220 } 1221 1222 void 1223 packet_get_bignum2(BIGNUM * value) 1224 { 1225 buffer_get_bignum2(&incoming_packet, value); 1226 } 1227 1228 void * 1229 packet_get_raw(int *length_ptr) 1230 { 1231 int bytes = buffer_len(&incoming_packet); 1232 1233 if (length_ptr != NULL) 1234 *length_ptr = bytes; 1235 return buffer_ptr(&incoming_packet); 1236 } 1237 1238 int 1239 packet_remaining(void) 1240 { 1241 return buffer_len(&incoming_packet); 1242 } 1243 1244 /* 1245 * Returns a string from the packet data. The string is allocated using 1246 * xmalloc; it is the responsibility of the calling program to free it when 1247 * no longer needed. The length_ptr argument may be NULL, or point to an 1248 * integer into which the length of the string is stored. 1249 */ 1250 1251 void * 1252 packet_get_string(u_int *length_ptr) 1253 { 1254 return buffer_get_string(&incoming_packet, length_ptr); 1255 } 1256 1257 /* 1258 * Sends a diagnostic message from the server to the client. This message 1259 * can be sent at any time (but not while constructing another message). The 1260 * message is printed immediately, but only if the client is being executed 1261 * in verbose mode. These messages are primarily intended to ease debugging 1262 * authentication problems. The length of the formatted message must not 1263 * exceed 1024 bytes. This will automatically call packet_write_wait. 1264 */ 1265 1266 void 1267 packet_send_debug(const char *fmt,...) 1268 { 1269 char buf[1024]; 1270 va_list args; 1271 1272 if (compat20 && (datafellows & SSH_BUG_DEBUG)) 1273 return; 1274 1275 va_start(args, fmt); 1276 vsnprintf(buf, sizeof(buf), fmt, args); 1277 va_end(args); 1278 1279 if (compat20) { 1280 packet_start(SSH2_MSG_DEBUG); 1281 packet_put_char(0); /* bool: always display */ 1282 packet_put_cstring(buf); 1283 packet_put_cstring(""); 1284 } else { 1285 packet_start(SSH_MSG_DEBUG); 1286 packet_put_cstring(buf); 1287 } 1288 packet_send(); 1289 packet_write_wait(); 1290 } 1291 1292 /* 1293 * Logs the error plus constructs and sends a disconnect packet, closes the 1294 * connection, and exits. This function never returns. The error message 1295 * should not contain a newline. The length of the formatted message must 1296 * not exceed 1024 bytes. 1297 */ 1298 1299 void 1300 packet_disconnect(const char *fmt,...) 1301 { 1302 char buf[1024]; 1303 va_list args; 1304 static int disconnecting = 0; 1305 1306 if (disconnecting) /* Guard against recursive invocations. */ 1307 fatal("packet_disconnect called recursively."); 1308 disconnecting = 1; 1309 1310 /* 1311 * Format the message. Note that the caller must make sure the 1312 * message is of limited size. 1313 */ 1314 va_start(args, fmt); 1315 vsnprintf(buf, sizeof(buf), fmt, args); 1316 va_end(args); 1317 1318 /* Display the error locally */ 1319 logit("Disconnecting: %.100s", buf); 1320 1321 /* Send the disconnect message to the other side, and wait for it to get sent. */ 1322 if (compat20) { 1323 packet_start(SSH2_MSG_DISCONNECT); 1324 packet_put_int(SSH2_DISCONNECT_PROTOCOL_ERROR); 1325 packet_put_cstring(buf); 1326 packet_put_cstring(""); 1327 } else { 1328 packet_start(SSH_MSG_DISCONNECT); 1329 packet_put_cstring(buf); 1330 } 1331 packet_send(); 1332 packet_write_wait(); 1333 1334 /* Stop listening for connections. */ 1335 channel_close_all(); 1336 1337 /* Close the connection. */ 1338 packet_close(); 1339 cleanup_exit(255); 1340 } 1341 1342 /* Checks if there is any buffered output, and tries to write some of the output. */ 1343 1344 void 1345 packet_write_poll(void) 1346 { 1347 int len = buffer_len(&output); 1348 1349 if (len > 0) { 1350 len = write(connection_out, buffer_ptr(&output), len); 1351 if (len <= 0) { 1352 if (errno == EAGAIN) 1353 return; 1354 else 1355 fatal("Write failed: %.100s", strerror(errno)); 1356 } 1357 buffer_consume(&output, len); 1358 } 1359 } 1360 1361 /* 1362 * Calls packet_write_poll repeatedly until all pending output data has been 1363 * written. 1364 */ 1365 1366 void 1367 packet_write_wait(void) 1368 { 1369 fd_set *setp; 1370 1371 setp = (fd_set *)xmalloc(howmany(connection_out + 1, NFDBITS) * 1372 sizeof(fd_mask)); 1373 packet_write_poll(); 1374 while (packet_have_data_to_write()) { 1375 memset(setp, 0, howmany(connection_out + 1, NFDBITS) * 1376 sizeof(fd_mask)); 1377 FD_SET(connection_out, setp); 1378 while (select(connection_out + 1, NULL, setp, NULL, NULL) == -1 && 1379 (errno == EAGAIN || errno == EINTR)) 1380 ; 1381 packet_write_poll(); 1382 } 1383 xfree(setp); 1384 } 1385 1386 /* Returns true if there is buffered data to write to the connection. */ 1387 1388 int 1389 packet_have_data_to_write(void) 1390 { 1391 return buffer_len(&output) != 0; 1392 } 1393 1394 /* Returns true if there is not too much data to write to the connection. */ 1395 1396 int 1397 packet_not_very_much_data_to_write(void) 1398 { 1399 if (interactive_mode) 1400 return buffer_len(&output) < 16384; 1401 else 1402 return buffer_len(&output) < 128 * 1024; 1403 } 1404 1405 1406 static void 1407 packet_set_tos(int interactive) 1408 { 1409 #if defined(IP_TOS) && !defined(IP_TOS_IS_BROKEN) 1410 int tos = interactive ? IPTOS_LOWDELAY : IPTOS_THROUGHPUT; 1411 1412 if (!packet_connection_is_on_socket() || 1413 !packet_connection_is_ipv4()) 1414 return; 1415 if (setsockopt(connection_in, IPPROTO_IP, IP_TOS, &tos, 1416 sizeof(tos)) < 0) 1417 error("setsockopt IP_TOS %d: %.100s:", 1418 tos, strerror(errno)); 1419 #endif 1420 } 1421 1422 /* Informs that the current session is interactive. Sets IP flags for that. */ 1423 1424 void 1425 packet_set_interactive(int interactive) 1426 { 1427 static int called = 0; 1428 1429 if (called) 1430 return; 1431 called = 1; 1432 1433 /* Record that we are in interactive mode. */ 1434 interactive_mode = interactive; 1435 1436 /* Only set socket options if using a socket. */ 1437 if (!packet_connection_is_on_socket()) 1438 return; 1439 if (interactive) 1440 set_nodelay(connection_in); 1441 packet_set_tos(interactive); 1442 } 1443 1444 /* Returns true if the current connection is interactive. */ 1445 1446 int 1447 packet_is_interactive(void) 1448 { 1449 return interactive_mode; 1450 } 1451 1452 u_int 1453 packet_set_maxsize(u_int s) 1454 { 1455 static int called = 0; 1456 1457 if (called) { 1458 logit("packet_set_maxsize: called twice: old %d new %d", 1459 max_packet_size, s); 1460 return -1; 1461 } 1462 if (s < 4 * 1024 || s > 1024 * 1024) { 1463 logit("packet_set_maxsize: bad size %d", s); 1464 return -1; 1465 } 1466 called = 1; 1467 debug("packet_set_maxsize: setting to %d", s); 1468 max_packet_size = s; 1469 return s; 1470 } 1471 1472 /* roundup current message to pad bytes */ 1473 void 1474 packet_add_padding(u_char pad) 1475 { 1476 extra_pad = pad; 1477 } 1478 1479 /* 1480 * 9.2. Ignored Data Message 1481 * 1482 * byte SSH_MSG_IGNORE 1483 * string data 1484 * 1485 * All implementations MUST understand (and ignore) this message at any 1486 * time (after receiving the protocol version). No implementation is 1487 * required to send them. This message can be used as an additional 1488 * protection measure against advanced traffic analysis techniques. 1489 */ 1490 void 1491 packet_send_ignore(int nbytes) 1492 { 1493 u_int32_t rand = 0; 1494 int i; 1495 1496 packet_start(compat20 ? SSH2_MSG_IGNORE : SSH_MSG_IGNORE); 1497 packet_put_int(nbytes); 1498 for (i = 0; i < nbytes; i++) { 1499 if (i % 4 == 0) 1500 rand = arc4random(); 1501 packet_put_char(rand & 0xff); 1502 rand >>= 8; 1503 } 1504 } 1505 1506 #define MAX_PACKETS (1<<31) 1507 int 1508 packet_need_rekeying(void) 1509 { 1510 if (datafellows & SSH_BUG_NOREKEY) 1511 return 0; 1512 return 1513 (p_send.packets > MAX_PACKETS) || 1514 (p_read.packets > MAX_PACKETS) || 1515 (max_blocks_out && (p_send.blocks > max_blocks_out)) || 1516 (max_blocks_in && (p_read.blocks > max_blocks_in)); 1517 } 1518 1519 void 1520 packet_set_rekey_limit(u_int32_t bytes) 1521 { 1522 rekey_limit = bytes; 1523 } 1524