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

Diff for /src/usr.bin/ssh/kex.c between version 1.12 and 1.12.2.2

version 1.12, 2000/10/11 20:27:23 version 1.12.2.2, 2001/02/19 17:18:59
Line 25 
Line 25 
 #include "includes.h"  #include "includes.h"
 RCSID("$OpenBSD$");  RCSID("$OpenBSD$");
   
 #include "ssh.h"  
 #include "ssh2.h"  
 #include "xmalloc.h"  
 #include "buffer.h"  
 #include "bufaux.h"  
 #include "packet.h"  
 #include "compat.h"  
   
 #include <openssl/bn.h>  
 #include <openssl/dh.h>  
   
 #include <openssl/crypto.h>  #include <openssl/crypto.h>
 #include <openssl/bio.h>  #include <openssl/bio.h>
 #include <openssl/bn.h>  #include <openssl/bn.h>
 #include <openssl/dh.h>  #include <openssl/dh.h>
 #include <openssl/pem.h>  #include <openssl/pem.h>
   
   #include "ssh2.h"
   #include "xmalloc.h"
   #include "buffer.h"
   #include "bufaux.h"
   #include "packet.h"
   #include "compat.h"
   #include "cipher.h"
 #include "kex.h"  #include "kex.h"
   #include "key.h"
   #include "log.h"
   #include "mac.h"
   
 #define KEX_COOKIE_LEN  16  #define KEX_COOKIE_LEN  16
   
Line 50 
Line 49 
 kex_init(char *myproposal[PROPOSAL_MAX])  kex_init(char *myproposal[PROPOSAL_MAX])
 {  {
         int first_kex_packet_follows = 0;          int first_kex_packet_follows = 0;
         unsigned char cookie[KEX_COOKIE_LEN];          u_char cookie[KEX_COOKIE_LEN];
         u_int32_t rand = 0;          u_int32_t rand = 0;
         int i;          int i;
         Buffer *ki = xmalloc(sizeof(*ki));          Buffer *ki = xmalloc(sizeof(*ki));
Line 81 
Line 80 
   
         debug("send KEXINIT");          debug("send KEXINIT");
         packet_start(SSH2_MSG_KEXINIT);          packet_start(SSH2_MSG_KEXINIT);
         packet_put_raw(buffer_ptr(my_kexinit), buffer_len(my_kexinit));          packet_put_raw(buffer_ptr(my_kexinit), buffer_len(my_kexinit));
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
         debug("done");          debug("done");
Line 138 
Line 137 
         return 0;          return 0;
 }  }
   
 DH *  void
 dh_gen_key(DH *dh)  dh_gen_key(DH *dh)
 {  {
         int tries = 0;          int tries = 0;
Line 149 
Line 148 
                 if (tries++ > 10)                  if (tries++ > 10)
                         fatal("dh_new_group1: too many bad keys: giving up");                          fatal("dh_new_group1: too many bad keys: giving up");
         } while (!dh_pub_is_valid(dh, dh->pub_key));          } while (!dh_pub_is_valid(dh, dh->pub_key));
         return dh;  
 }  }
   
 DH *  DH *
Line 167 
Line 165 
         if ((ret = BN_hex2bn(&dh->g, gen)) < 0)          if ((ret = BN_hex2bn(&dh->g, gen)) < 0)
                 fatal("BN_hex2bn g");                  fatal("BN_hex2bn g");
   
         return (dh_gen_key(dh));          return (dh);
 }  }
   
   /*
    * This just returns the group, we still need to generate the exchange
    * value.
    */
   
 DH *  DH *
 dh_new_group(BIGNUM *gen, BIGNUM *modulus)  dh_new_group(BIGNUM *gen, BIGNUM *modulus)
 {  {
Line 181 
Line 184 
         dh->p = modulus;          dh->p = modulus;
         dh->g = gen;          dh->g = gen;
   
         return (dh_gen_key(dh));          return (dh);
 }  }
   
 DH *  DH *
 dh_new_group1()  dh_new_group1(void)
 {  {
         static char *gen = "2", *group1 =          static char *gen = "2", *group1 =
             "FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" "C4C6628B" "80DC1CD1"              "FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" "C4C6628B" "80DC1CD1"
Line 198 
Line 201 
         return (dh_new_group_asc(gen, group1));          return (dh_new_group_asc(gen, group1));
 }  }
   
   #ifdef DEBUG_KEX
 void  void
 dump_digest(unsigned char *digest, int len)  dump_digest(u_char *digest, int len)
 {  {
         int i;          int i;
         for (i = 0; i< len; i++){          for (i = 0; i< len; i++){
Line 209 
Line 213 
         }          }
         fprintf(stderr, "\n");          fprintf(stderr, "\n");
 }  }
   #endif
   
 unsigned char *  u_char *
 kex_hash(  kex_hash(
     char *client_version_string,      char *client_version_string,
     char *server_version_string,      char *server_version_string,
Line 222 
Line 227 
     BIGNUM *shared_secret)      BIGNUM *shared_secret)
 {  {
         Buffer b;          Buffer b;
         static unsigned char digest[EVP_MAX_MD_SIZE];          static u_char digest[EVP_MAX_MD_SIZE];
         EVP_MD *evp_md = EVP_sha1();          EVP_MD *evp_md = EVP_sha1();
         EVP_MD_CTX md;          EVP_MD_CTX md;
   
Line 242 
Line 247 
         buffer_put_bignum2(&b, client_dh_pub);          buffer_put_bignum2(&b, client_dh_pub);
         buffer_put_bignum2(&b, server_dh_pub);          buffer_put_bignum2(&b, server_dh_pub);
         buffer_put_bignum2(&b, shared_secret);          buffer_put_bignum2(&b, shared_secret);
   
 #ifdef DEBUG_KEX  #ifdef DEBUG_KEX
         buffer_dump(&b);          buffer_dump(&b);
 #endif  #endif
Line 259 
Line 264 
         return digest;          return digest;
 }  }
   
 unsigned char *  u_char *
 kex_hash_gex(  kex_hash_gex(
     char *client_version_string,      char *client_version_string,
     char *server_version_string,      char *server_version_string,
Line 272 
Line 277 
     BIGNUM *shared_secret)      BIGNUM *shared_secret)
 {  {
         Buffer b;          Buffer b;
         static unsigned char digest[EVP_MAX_MD_SIZE];          static u_char digest[EVP_MAX_MD_SIZE];
         EVP_MD *evp_md = EVP_sha1();          EVP_MD *evp_md = EVP_sha1();
         EVP_MD_CTX md;          EVP_MD_CTX md;
   
Line 295 
Line 300 
         buffer_put_bignum2(&b, client_dh_pub);          buffer_put_bignum2(&b, client_dh_pub);
         buffer_put_bignum2(&b, server_dh_pub);          buffer_put_bignum2(&b, server_dh_pub);
         buffer_put_bignum2(&b, shared_secret);          buffer_put_bignum2(&b, shared_secret);
   
 #ifdef DEBUG_KEX  #ifdef DEBUG_KEX
         buffer_dump(&b);          buffer_dump(&b);
 #endif  #endif
Line 312 
Line 317 
         return digest;          return digest;
 }  }
   
 unsigned char *  u_char *
 derive_key(int id, int need, char unsigned *hash, BIGNUM *shared_secret)  derive_key(int id, int need, u_char *hash, BIGNUM *shared_secret)
 {  {
         Buffer b;          Buffer b;
         EVP_MD *evp_md = EVP_sha1();          EVP_MD *evp_md = EVP_sha1();
Line 321 
Line 326 
         char c = id;          char c = id;
         int have;          int have;
         int mdsz = evp_md->md_size;          int mdsz = evp_md->md_size;
         unsigned char *digest = xmalloc(((need+mdsz-1)/mdsz)*mdsz);          u_char *digest = xmalloc(((need+mdsz-1)/mdsz)*mdsz);
   
         buffer_init(&b);          buffer_init(&b);
         buffer_put_bignum2(&b, shared_secret);          buffer_put_bignum2(&b, shared_secret);
Line 364 
Line 369 
         c = cp = xstrdup(client);          c = cp = xstrdup(client);
         s = sp = xstrdup(server);          s = sp = xstrdup(server);
   
         for ((p = strsep(&sp, SEP)), i=0; p && *p != '\0';          for ((p = strsep(&sp, SEP)), i=0; p && *p != '\0';
              (p = strsep(&sp, SEP)), i++) {               (p = strsep(&sp, SEP)), i++) {
                 if (i < MAX_PROP)                  if (i < MAX_PROP)
                         sproposals[i] = p;                          sproposals[i] = p;
Line 373 
Line 378 
         }          }
         nproposals = i;          nproposals = i;
   
         for ((p = strsep(&cp, SEP)), i=0; p && *p != '\0';          for ((p = strsep(&cp, SEP)), i=0; p && *p != '\0';
              (p = strsep(&cp, SEP)), i++) {               (p = strsep(&cp, SEP)), i++) {
                 for (j = 0; j < nproposals; j++) {                  for (j = 0; j < nproposals; j++) {
                         if (strcmp(p, sproposals[j]) == 0) {                          if (strcmp(p, sproposals[j]) == 0) {
Line 408 
Line 413 
         char *name = get_match(client, server);          char *name = get_match(client, server);
         if (name == NULL)          if (name == NULL)
                 fatal("no matching mac found: client %s server %s", client, server);                  fatal("no matching mac found: client %s server %s", client, server);
         if (strcmp(name, "hmac-md5") == 0) {          if (mac_init(mac, name) < 0)
                 mac->md = EVP_md5();  
         } else if (strcmp(name, "hmac-sha1") == 0) {  
                 mac->md = EVP_sha1();  
         } else if (strcmp(name, "hmac-ripemd160@openssh.com") == 0) {  
                 mac->md = EVP_ripemd160();  
         } else {  
                 fatal("unsupported mac %s", name);                  fatal("unsupported mac %s", name);
         }          /* truncate the key */
           if (datafellows & SSH_BUG_HMAC)
                   mac->key_len = 16;
         mac->name = name;          mac->name = name;
         mac->mac_len = mac->md->md_size;  
         mac->key_len = (datafellows & SSH_BUG_HMAC) ? 16 : mac->mac_len;  
         mac->key = NULL;          mac->key = NULL;
         mac->enabled = 0;          mac->enabled = 0;
 }  }
Line 454 
Line 453 
 void  void
 choose_hostkeyalg(Kex *k, char *client, char *server)  choose_hostkeyalg(Kex *k, char *client, char *server)
 {  {
         k->hostkeyalg = get_match(client, server);          char *hostkeyalg = get_match(client, server);
         if (k->hostkeyalg == NULL)          if (hostkeyalg == NULL)
                 fatal("no hostkey alg");                  fatal("no hostkey alg");
         if (strcmp(k->hostkeyalg, KEX_DSS) != 0)          k->hostkey_type = key_type_from_name(hostkeyalg);
                 fatal("bad hostkey alg %s", k->hostkeyalg);          if (k->hostkey_type == KEY_UNSPEC)
                   fatal("bad hostkey alg '%s'", hostkeyalg);
           xfree(hostkeyalg);
 }  }
   
 Kex *  Kex *
Line 506 
Line 507 
 }  }
   
 int  int
 kex_derive_keys(Kex *k, unsigned char *hash, BIGNUM *shared_secret)  kex_derive_keys(Kex *k, u_char *hash, BIGNUM *shared_secret)
 {  {
         int i;          int i;
         int mode;          int mode;
         int ctos;          int ctos;
         unsigned char *keys[NKEYS];          u_char *keys[NKEYS];
   
         for (i = 0; i < NKEYS; i++)          for (i = 0; i < NKEYS; i++)
                 keys[i] = derive_key('A'+i, k->we_need, hash, shared_secret);                  keys[i] = derive_key('A'+i, k->we_need, hash, shared_secret);
Legend:
Removed from v.1.12  
changed lines
  Added in v.1.12.2.2