[BACK]Return to packet.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/packet.c between version 1.24 and 1.25

version 1.24, 2000/04/03 07:07:15 version 1.25, 2000/04/03 20:12:55
Line 11 
Line 11 
  *   *
  * This file contains code implementing the packet protocol and communication   * This file contains code implementing the packet protocol and communication
  * with the other side.  This same code is used both on client and server side.   * with the other side.  This same code is used both on client and server side.
  *   *
    * SSH2 packet format added by Markus Friedl.
    *
  */   */
   
 #include "includes.h"  #include "includes.h"
Line 30 
Line 32 
 #include "deattack.h"  #include "deattack.h"
 #include "channels.h"  #include "channels.h"
   
   #include "compat.h"
   #include "ssh2.h"
   
   #include <ssl/bn.h>
   #include <ssl/dh.h>
   #include <ssl/hmac.h>
   #include "buffer.h"
   #include "kex.h"
   #include "hmac.h"
   
   #ifdef PACKET_DEBUG
   #define DBG(x) x
   #else
   #define DBG(x)
   #endif
   
 /*  /*
  * This variable contains the file descriptors used for communicating with   * This variable contains the file descriptors used for communicating with
  * the other side.  connection_in is used for reading; connection_out for   * the other side.  connection_in is used for reading; connection_out for
Line 81 
Line 99 
 /* Set to true if the connection is interactive. */  /* Set to true if the connection is interactive. */
 static int interactive_mode = 0;  static int interactive_mode = 0;
   
   /* True if SSH2 packet format is used */
   int use_ssh2_packet_format = 0;
   
   /* Session key information for Encryption and MAC */
   Kex     *kex = NULL;
   
   void
   packet_set_kex(Kex *k)
   {
           if( k->mac[MODE_IN ].key == NULL ||
               k->enc[MODE_IN ].key == NULL ||
               k->enc[MODE_IN ].iv  == NULL ||
               k->mac[MODE_OUT].key == NULL ||
               k->enc[MODE_OUT].key == NULL ||
               k->enc[MODE_OUT].iv  == NULL)
                   fatal("bad KEX");
           kex = k;
   }
   void
   clear_enc_keys(Enc *enc, int len)
   {
           memset(enc->iv,  0, len);
           memset(enc->key, 0, len);
           xfree(enc->iv);
           xfree(enc->key);
           enc->iv = NULL;
           enc->key = NULL;
   }
   void
   packet_set_ssh2_format(void)
   {
           debug("use_ssh2_packet_format");
           use_ssh2_packet_format = 1;
   }
   
 /*  /*
  * Sets the descriptors used for communication.  Disables encryption until   * Sets the descriptors used for communication.  Disables encryption until
  * packet_set_encryption_key is called.   * packet_set_encryption_key is called.
  */   */
   
 void  void
 packet_set_connection(int fd_in, int fd_out)  packet_set_connection(int fd_in, int fd_out)
 {  {
Line 225 
Line 277 
  * Level is compression level 1 (fastest) - 9 (slow, best) as in gzip.   * Level is compression level 1 (fastest) - 9 (slow, best) as in gzip.
  */   */
   
   /*** XXXXX todo: kex means re-init */
 void  void
 packet_start_compression(int level)  packet_start_compression(int level)
 {  {
Line 242 
Line 295 
   
 void  void
 packet_encrypt(CipherContext * cc, void *dest, void *src,  packet_encrypt(CipherContext * cc, void *dest, void *src,
                unsigned int bytes)      unsigned int bytes)
 {  {
         cipher_encrypt(cc, dest, src, bytes);          cipher_encrypt(cc, dest, src, bytes);
 }  }
Line 254 
Line 307 
   
 void  void
 packet_decrypt(CipherContext * cc, void *dest, void *src,  packet_decrypt(CipherContext * cc, void *dest, void *src,
                unsigned int bytes)      unsigned int bytes)
 {  {
         int i;          int i;
   
Line 266 
Line 319 
          * (C)1998 CORE-SDI, Buenos Aires Argentina Ariel Futoransky(futo@core-sdi.com)           * (C)1998 CORE-SDI, Buenos Aires Argentina Ariel Futoransky(futo@core-sdi.com)
          */           */
   
         switch (cc->type) {          if (cc->type == SSH_CIPHER_NONE || compat20) {
         case SSH_CIPHER_NONE:  
                 i = DEATTACK_OK;                  i = DEATTACK_OK;
                 break;          } else {
         default:  
                 i = detect_attack(src, bytes, NULL);                  i = detect_attack(src, bytes, NULL);
                 break;  
         }          }
   
         if (i == DEATTACK_DETECTED)          if (i == DEATTACK_DETECTED)
                 packet_disconnect("crc32 compensation attack: network attack detected");                  packet_disconnect("crc32 compensation attack: network attack detected");
   
Line 289 
Line 338 
   
 void  void
 packet_set_encryption_key(const unsigned char *key, unsigned int keylen,  packet_set_encryption_key(const unsigned char *key, unsigned int keylen,
                           int cipher)      int cipher)
 {  {
           if (keylen < 20)
                   fatal("keylen too small: %d", keylen);
   
         /* All other ciphers use the same key in both directions for now. */          /* All other ciphers use the same key in both directions for now. */
         cipher_set_key(&receive_context, cipher, key, keylen, 0);          cipher_set_key(&receive_context, cipher, key, keylen, 0);
         cipher_set_key(&send_context, cipher, key, keylen, 1);          cipher_set_key(&send_context, cipher, key, keylen, 1);
Line 299 
Line 351 
 /* Starts constructing a packet to send. */  /* Starts constructing a packet to send. */
   
 void  void
 packet_start(int type)  packet_start1(int type)
 {  {
         char buf[9];          char buf[9];
   
Line 309 
Line 361 
         buffer_append(&outgoing_packet, buf, 9);          buffer_append(&outgoing_packet, buf, 9);
 }  }
   
   void
   packet_start2(int type)
   {
           char buf[4+1+1];
   
           buffer_clear(&outgoing_packet);
           memset(buf, 0, sizeof buf);
           /* buf[0..3] = payload_len; */
           /* buf[4] =    pad_len; */
           buf[5] = type & 0xff;
           buffer_append(&outgoing_packet, buf, sizeof buf);
   }
   
   void
   packet_start(int type)
   {
           DBG(debug("packet_start[%d]",type));
           if (use_ssh2_packet_format)
                   packet_start2(type);
           else
                   packet_start1(type);
   }
   
 /* Appends a character to the packet data. */  /* Appends a character to the packet data. */
   
 void  void
Line 365 
Line 440 
  */   */
   
 void  void
 packet_send()  packet_send1()
 {  {
         char buf[8], *cp;          char buf[8], *cp;
         int i, padding, len;          int i, padding, len;
Line 436 
Line 511 
 }  }
   
 /*  /*
    * Finalize packet in SSH2 format (compress, mac, encrypt, enqueue)
    */
   void
   packet_send2()
   {
           unsigned char *macbuf = NULL;
           char *cp;
           unsigned int packet_length = 0;
           unsigned int i, padlen, len;
           u_int32_t rand = 0;
           static unsigned int seqnr = 0;
           int type;
           Enc *enc   = NULL;
           Mac *mac   = NULL;
           Comp *comp = NULL;
           int block_size;
   
           if (kex != NULL) {
                   enc  = &kex->enc[MODE_OUT];
                   mac  = &kex->mac[MODE_OUT];
                   comp = &kex->comp[MODE_OUT];
           }
           block_size = enc ? enc->block_size : 8;
   
           cp = buffer_ptr(&outgoing_packet);
           type = cp[5] & 0xff;
   
   #ifdef PACKET_DEBUG
           fprintf(stderr, "plain:     ");
           buffer_dump(&outgoing_packet);
   #endif
   
           if (comp && comp->enabled) {
                   len = buffer_len(&outgoing_packet);
                   /* skip header, compress only payload */
                   buffer_consume(&outgoing_packet, 5);
                   buffer_clear(&compression_buffer);
                   buffer_compress(&outgoing_packet, &compression_buffer);
                   buffer_clear(&outgoing_packet);
                   buffer_append(&outgoing_packet, "\0\0\0\0\0", 5);
                   buffer_append(&outgoing_packet, buffer_ptr(&compression_buffer),
                       buffer_len(&compression_buffer));
                   DBG(debug("compression: raw %d compressed %d", len,
                       buffer_len(&outgoing_packet)));
           }
   
           /* sizeof (packet_len + pad_len + payload) */
           len = buffer_len(&outgoing_packet);
   
           /*
            * calc size of padding, alloc space, get random data,
            * minimum padding is 4 bytes
            */
           padlen = block_size - (len % block_size);
           if (padlen < 4)
                   padlen += block_size;
           buffer_append_space(&outgoing_packet, &cp, padlen);
           if (enc && enc->type != SSH_CIPHER_NONE) {
                   for (i = 0; i < padlen; i++) {
                           if (i % 4 == 0)
                                   rand = arc4random();
                           cp[i] = rand & 0xff;
                           rand <<= 8;
                   }
           }
           /* packet_length includes payload, padding and padding length field */
           packet_length = buffer_len(&outgoing_packet) - 4;
           cp = buffer_ptr(&outgoing_packet);
           PUT_32BIT(cp, packet_length);
           cp[4] = padlen & 0xff;
           DBG(debug("send: len %d (includes padlen %d)", packet_length+4, padlen));
   
           /* compute MAC over seqnr and packet(length fields, payload, padding) */
           if (mac && mac->enabled) {
                   macbuf = hmac( mac->md, seqnr,
                       (unsigned char *) buffer_ptr(&outgoing_packet),
                       buffer_len(&outgoing_packet),
                       mac->key, mac->key_len
                   );
                   DBG(debug("done calc HMAC out #%d", seqnr));
           }
           /* encrypt packet and append to output buffer. */
           buffer_append_space(&output, &cp, buffer_len(&outgoing_packet));
           packet_encrypt(&send_context, cp, buffer_ptr(&outgoing_packet),
               buffer_len(&outgoing_packet));
           /* append unencrypted MAC */
           if (mac && mac->enabled)
                   buffer_append(&output, (char *)macbuf, mac->mac_len);
   #ifdef PACKET_DEBUG
           fprintf(stderr, "encrypted: ");
           buffer_dump(&output);
   #endif
           /* increment sequence number for outgoing packets */
           if (++seqnr == 0)
                   log("outgoing seqnr wraps around");
           buffer_clear(&outgoing_packet);
   
           if (type == SSH2_MSG_NEWKEYS) {
                   if (kex==NULL || mac==NULL || enc==NULL || comp==NULL)
                           fatal("packet_send2: no KEX");
                   if (mac->md != NULL)
                           mac->enabled = 1;
                   debug("cipher_set_key_iv send_context");
                   cipher_set_key_iv(&send_context, enc->type,
                       enc->key, enc->key_len,
                       enc->iv, enc->iv_len);
                   clear_enc_keys(enc, kex->we_need);
                   if (comp->type != 0 && comp->enabled == 0) {
                           comp->enabled = 1;
                           if (! packet_compression)
                                   packet_start_compression(6);
                   }
           }
   }
   
   void
   packet_send()
   {
           if (use_ssh2_packet_format)
                   packet_send2();
           else
                   packet_send1();
           DBG(debug("packet_send done"));
   }
   
   void
   packet_send_and_wait()
   {
           packet_send();
           packet_write_wait();
   }
   
   /*
  * Waits until a packet has been received, and returns its type.  Note that   * Waits until a packet has been received, and returns its type.  Note that
  * no other data is processed until this returns, so this function should not   * no other data is processed until this returns, so this function should not
  * be used during the interactive session.   * be used during the interactive session.
Line 447 
Line 655 
         int type, len;          int type, len;
         fd_set set;          fd_set set;
         char buf[8192];          char buf[8192];
           DBG(debug("packet_read()"));
   
         /* Since we are blocking, ensure that all written packets have been sent. */          /* Since we are blocking, ensure that all written packets have been sent. */
         packet_write_wait();          packet_write_wait();
Line 500 
Line 709 
         type = packet_read(payload_len_ptr);          type = packet_read(payload_len_ptr);
         if (type != expected_type)          if (type != expected_type)
                 packet_disconnect("Protocol error: expected packet type %d, got %d",                  packet_disconnect("Protocol error: expected packet type %d, got %d",
                                   expected_type, type);                      expected_type, type);
 }  }
   
 /* Checks if a full packet is available in the data received so far via  /* Checks if a full packet is available in the data received so far via
Line 519 
Line 728 
  */   */
   
 int  int
 packet_read_poll(int *payload_len_ptr)  packet_read_poll1(int *payload_len_ptr)
 {  {
         unsigned int len, padded_len;          unsigned int len, padded_len;
         unsigned char *ucp;          unsigned char *ucp;
         char buf[8], *cp, *msg;          char buf[8], *cp;
         unsigned int checksum, stored_checksum;          unsigned int checksum, stored_checksum;
   
 restart:  
   
         /* Check if input size is less than minimum packet size. */          /* Check if input size is less than minimum packet size. */
         if (buffer_len(&input) < 4 + 8)          if (buffer_len(&input) < 4 + 8)
                 return SSH_MSG_NONE;                  return SSH_MSG_NONE;
Line 560 
Line 767 
   
         /* Compute packet checksum. */          /* Compute packet checksum. */
         checksum = crc32((unsigned char *) buffer_ptr(&incoming_packet),          checksum = crc32((unsigned char *) buffer_ptr(&incoming_packet),
                          buffer_len(&incoming_packet) - 4);              buffer_len(&incoming_packet) - 4);
   
         /* Skip padding. */          /* Skip padding. */
         buffer_consume(&incoming_packet, 8 - len % 8);          buffer_consume(&incoming_packet, 8 - len % 8);
Line 569 
Line 776 
   
         if (len != buffer_len(&incoming_packet))          if (len != buffer_len(&incoming_packet))
                 packet_disconnect("packet_read_poll: len %d != buffer_len %d.",                  packet_disconnect("packet_read_poll: len %d != buffer_len %d.",
                                   len, buffer_len(&incoming_packet));                      len, buffer_len(&incoming_packet));
   
         ucp = (unsigned char *) buffer_ptr(&incoming_packet) + len - 4;          ucp = (unsigned char *) buffer_ptr(&incoming_packet) + len - 4;
         stored_checksum = GET_32BIT(ucp);          stored_checksum = GET_32BIT(ucp);
Line 583 
Line 790 
                 buffer_uncompress(&incoming_packet, &compression_buffer);                  buffer_uncompress(&incoming_packet, &compression_buffer);
                 buffer_clear(&incoming_packet);                  buffer_clear(&incoming_packet);
                 buffer_append(&incoming_packet, buffer_ptr(&compression_buffer),                  buffer_append(&incoming_packet, buffer_ptr(&compression_buffer),
                               buffer_len(&compression_buffer));                      buffer_len(&compression_buffer));
         }          }
         /* Get packet type. */          /* Get packet type. */
         buffer_get(&incoming_packet, &buf[0], 1);          buffer_get(&incoming_packet, &buf[0], 1);
Line 591 
Line 798 
         /* Return length of payload (without type field). */          /* Return length of payload (without type field). */
         *payload_len_ptr = buffer_len(&incoming_packet);          *payload_len_ptr = buffer_len(&incoming_packet);
   
         /* Handle disconnect message. */          /* Return type. */
         if ((unsigned char) buf[0] == SSH_MSG_DISCONNECT) {          return (unsigned char) buf[0];
                 msg = packet_get_string(NULL);  }
                 log("Received disconnect: %.900s", msg);  
                 xfree(msg);  
                 fatal_cleanup();  
         }  
   
         /* Ignore ignore messages. */  int
         if ((unsigned char) buf[0] == SSH_MSG_IGNORE)  packet_read_poll2(int *payload_len_ptr)
                 goto restart;  {
           unsigned int padlen, need;
           unsigned char buf[8], *macbuf;
           unsigned char *ucp;
           char *cp;
           static unsigned int packet_length = 0;
           static unsigned int seqnr = 0;
           int type;
           int maclen, block_size;
           Enc *enc   = NULL;
           Mac *mac   = NULL;
           Comp *comp = NULL;
   
         /* Send debug messages as debugging output. */          if (kex != NULL) {
         if ((unsigned char) buf[0] == SSH_MSG_DEBUG) {                  enc  = &kex->enc[MODE_IN];
                 msg = packet_get_string(NULL);                  mac  = &kex->mac[MODE_IN];
                 debug("Remote: %.900s", msg);                  comp = &kex->comp[MODE_IN];
                 xfree(msg);  
                 goto restart;  
         }          }
         /* Return type. */          maclen = mac && mac->enabled ? mac->mac_len : 0;
         return (unsigned char) buf[0];          block_size = enc ? enc->block_size : 8;
   
           if (packet_length == 0) {
                   /*
                    * check if input size is less than the cipher block size,
                    * decrypt first block and extract length of incoming packet
                    */
                   if (buffer_len(&input) < block_size)
                           return SSH_MSG_NONE;
                   buffer_clear(&incoming_packet);
                   buffer_append_space(&incoming_packet, &cp, block_size);
                   packet_decrypt(&receive_context, cp, buffer_ptr(&input),
                       block_size);
                   ucp = (unsigned char *) buffer_ptr(&incoming_packet);
                   packet_length = GET_32BIT(ucp);
                   if (packet_length < 1 + 4 || packet_length > 256 * 1024) {
                           buffer_dump(&incoming_packet);
                           packet_disconnect("Bad packet length %d.", packet_length);
                   }
                   DBG(debug("input: packet len %d", packet_length+4));
                   buffer_consume(&input, block_size);
           }
           /* we have a partial packet of block_size bytes */
           need = 4 + packet_length - block_size;
           DBG(debug("partial packet %d, need %d, maclen %d", block_size,
               need, maclen));
           if (need % block_size != 0)
                   fatal("padding error: need %d block %d mod %d",
                       need, block_size, need % block_size);
           /*
            * check if the entire packet has been received and
            * decrypt into incoming_packet
            */
           if (buffer_len(&input) < need + maclen)
                   return SSH_MSG_NONE;
   #ifdef PACKET_DEBUG
           fprintf(stderr, "read_poll enc/full: ");
           buffer_dump(&input);
   #endif
           buffer_append_space(&incoming_packet, &cp, need);
           packet_decrypt(&receive_context, cp, buffer_ptr(&input), need);
           buffer_consume(&input, need);
           /*
            * compute MAC over seqnr and packet,
            * increment sequence number for incoming packet
            */
           if (mac && mac->enabled) {
                   macbuf = hmac( mac->md, seqnr,
                       (unsigned char *) buffer_ptr(&incoming_packet),
                       buffer_len(&incoming_packet),
                       mac->key, mac->key_len
                   );
                   if (memcmp(macbuf, buffer_ptr(&input), mac->mac_len) != 0)
                           packet_disconnect("Corrupted HMAC on input.");
                   DBG(debug("HMAC #%d ok", seqnr));
                   buffer_consume(&input, mac->mac_len);
           }
           if (++seqnr == 0)
                   log("incoming seqnr wraps around");
   
           /* get padlen */
           cp = buffer_ptr(&incoming_packet) + 4;
           padlen = *cp & 0xff;
           DBG(debug("input: padlen %d", padlen));
           if (padlen < 4)
                   packet_disconnect("Corrupted padlen %d on input.", padlen);
   
           /* skip packet size + padlen, discard padding */
           buffer_consume(&incoming_packet, 4 + 1);
           buffer_consume_end(&incoming_packet, padlen);
   
           DBG(debug("input: len before de-compress %d", buffer_len(&incoming_packet)));
           if (comp && comp->enabled) {
                   buffer_clear(&compression_buffer);
                   buffer_uncompress(&incoming_packet, &compression_buffer);
                   buffer_clear(&incoming_packet);
                   buffer_append(&incoming_packet, buffer_ptr(&compression_buffer),
                       buffer_len(&compression_buffer));
                   DBG(debug("input: len after de-compress %d", buffer_len(&incoming_packet)));
           }
           /*
            * get packet type, implies consume.
            * return length of payload (without type field)
            */
           buffer_get(&incoming_packet, (char *)&buf[0], 1);
           *payload_len_ptr = buffer_len(&incoming_packet);
   
           /* reset for next packet */
           packet_length = 0;
   
           /* extract packet type */
           type = (unsigned char)buf[0];
   
           if (type == SSH2_MSG_NEWKEYS) {
                   if (kex==NULL || mac==NULL || enc==NULL || comp==NULL)
                           fatal("packet_read_poll2: no KEX");
                   if (mac->md != NULL)
                           mac->enabled = 1;
                   debug("cipher_set_key_iv receive_context");
                   cipher_set_key_iv(&receive_context, enc->type,
                       enc->key, enc->key_len,
                       enc->iv, enc->iv_len);
                   clear_enc_keys(enc, kex->we_need);
                   if (comp->type != 0 && comp->enabled == 0) {
                           comp->enabled = 1;
                           if (! packet_compression)
                                   packet_start_compression(6);
                   }
           }
   
   #ifdef PACKET_DEBUG
           fprintf(stderr, "read/plain[%d]:\r\n",type);
           buffer_dump(&incoming_packet);
   #endif
           return (unsigned char)type;
 }  }
   
   int
   packet_read_poll(int *payload_len_ptr)
   {
           char *msg;
           for (;;) {
                   int type = use_ssh2_packet_format ?
                       packet_read_poll2(payload_len_ptr):
                       packet_read_poll1(payload_len_ptr);
   
                   if(compat20) {
                           int reason;
                           if (type != 0)
                                   DBG(debug("received packet type %d", type));
                           switch(type) {
                           case SSH2_MSG_IGNORE:
                                   break;
                           case SSH2_MSG_DEBUG:
                                   packet_get_char();
                                   msg = packet_get_string(NULL);
                                   debug("Remote: %.900s", msg);
                                   xfree(msg);
                                   msg = packet_get_string(NULL);
                                   xfree(msg);
                                   break;
                           case SSH2_MSG_DISCONNECT:
                                   reason = packet_get_int();
                                   msg = packet_get_string(NULL);
                                   log("Received disconnect: %d: %.900s", reason, msg);
                                   xfree(msg);
                                   fatal_cleanup();
                                   break;
                           default:
                                   return type;
                                   break;
                           }
                   } else {
                           switch(type) {
                           case SSH_MSG_IGNORE:
                                   break;
                           case SSH_MSG_DEBUG:
                                   msg = packet_get_string(NULL);
                                   debug("Remote: %.900s", msg);
                                   xfree(msg);
                                   break;
                           case SSH_MSG_DISCONNECT:
                                   msg = packet_get_string(NULL);
                                   log("Received disconnect: %.900s", msg);
                                   fatal_cleanup();
                                   xfree(msg);
                                   break;
                           default:
                                   if (type != 0)
                                           DBG(debug("received packet type %d", type));
                                   return type;
                                   break;
                           }
                   }
           }
   }
   
 /*  /*
  * Buffers the given amount of input characters.  This is intended to be used   * Buffers the given amount of input characters.  This is intended to be used
  * together with packet_read_poll.   * together with packet_read_poll.
Line 733 
Line 1119 
         va_end(args);          va_end(args);
   
         /* Send the disconnect message to the other side, and wait for it to get sent. */          /* Send the disconnect message to the other side, and wait for it to get sent. */
         packet_start(SSH_MSG_DISCONNECT);          if (compat20) {
         packet_put_string(buf, strlen(buf));                  packet_start(SSH2_MSG_DISCONNECT);
                   packet_put_int(SSH2_DISCONNECT_PROTOCOL_ERROR);
                   packet_put_cstring(buf);
                   packet_put_cstring("");
           } else {
                   packet_start(SSH_MSG_DISCONNECT);
                   packet_put_string(buf, strlen(buf));
           }
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
   
Line 865 
Line 1258 
 {  {
         static int called = 0;          static int called = 0;
         if (called) {          if (called) {
                 log("packet_set_maxsize: called twice: old %d new %d", max_packet_size, s);                  log("packet_set_maxsize: called twice: old %d new %d",
                       max_packet_size, s);
                 return -1;                  return -1;
         }          }
         if (s < 4 * 1024 || s > 1024 * 1024) {          if (s < 4 * 1024 || s > 1024 * 1024) {
Legend:
Removed from v.1.24  
changed lines
  Added in v.1.25