openssh/packet.c

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