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

Diff for /src/usr.bin/ssh/kexdh.c between version 1.18 and 1.19

version 1.18, 2002/03/18 17:50:31 version 1.19, 2003/02/16 17:09:57
Line 25 
Line 25 
 #include "includes.h"  #include "includes.h"
 RCSID("$OpenBSD$");  RCSID("$OpenBSD$");
   
 #include <openssl/crypto.h>  #include <openssl/evp.h>
 #include <openssl/bn.h>  
   
 #include "xmalloc.h"  
 #include "buffer.h"  #include "buffer.h"
 #include "bufaux.h"  #include "bufaux.h"
 #include "key.h"  
 #include "kex.h"  
 #include "log.h"  
 #include "packet.h"  
 #include "dh.h"  
 #include "ssh2.h"  #include "ssh2.h"
 #include "monitor_wrap.h"  #include "kex.h"
   
 static u_char *  u_char *
 kex_dh_hash(  kex_dh_hash(
     char *client_version_string,      char *client_version_string,
     char *server_version_string,      char *server_version_string,
Line 85 
Line 78 
         dump_digest("hash", digest, EVP_MD_size(evp_md));          dump_digest("hash", digest, EVP_MD_size(evp_md));
 #endif  #endif
         return digest;          return digest;
 }  
   
 /* client */  
   
 static void  
 kexdh_client(Kex *kex)  
 {  
         BIGNUM *dh_server_pub = NULL, *shared_secret = NULL;  
         DH *dh;  
         Key *server_host_key;  
         u_char *server_host_key_blob = NULL, *signature = NULL;  
         u_char *kbuf, *hash;  
         u_int klen, kout, slen, sbloblen;  
   
         /* generate and send 'e', client DH public key */  
         dh = dh_new_group1();  
         dh_gen_key(dh, kex->we_need * 8);  
         packet_start(SSH2_MSG_KEXDH_INIT);  
         packet_put_bignum2(dh->pub_key);  
         packet_send();  
   
         debug("sending SSH2_MSG_KEXDH_INIT");  
 #ifdef DEBUG_KEXDH  
         DHparams_print_fp(stderr, dh);  
         fprintf(stderr, "pub= ");  
         BN_print_fp(stderr, dh->pub_key);  
         fprintf(stderr, "\n");  
 #endif  
   
         debug("expecting SSH2_MSG_KEXDH_REPLY");  
         packet_read_expect(SSH2_MSG_KEXDH_REPLY);  
   
         /* key, cert */  
         server_host_key_blob = packet_get_string(&sbloblen);  
         server_host_key = key_from_blob(server_host_key_blob, sbloblen);  
         if (server_host_key == NULL)  
                 fatal("cannot decode server_host_key_blob");  
         if (server_host_key->type != kex->hostkey_type)  
                 fatal("type mismatch for decoded server_host_key_blob");  
         if (kex->verify_host_key == NULL)  
                 fatal("cannot verify server_host_key");  
         if (kex->verify_host_key(server_host_key) == -1)  
                 fatal("server_host_key verification failed");  
   
         /* DH paramter f, server public DH key */  
         if ((dh_server_pub = BN_new()) == NULL)  
                 fatal("dh_server_pub == NULL");  
         packet_get_bignum2(dh_server_pub);  
   
 #ifdef DEBUG_KEXDH  
         fprintf(stderr, "dh_server_pub= ");  
         BN_print_fp(stderr, dh_server_pub);  
         fprintf(stderr, "\n");  
         debug("bits %d", BN_num_bits(dh_server_pub));  
 #endif  
   
         /* signed H */  
         signature = packet_get_string(&slen);  
         packet_check_eom();  
   
         if (!dh_pub_is_valid(dh, dh_server_pub))  
                 packet_disconnect("bad server public DH value");  
   
         klen = DH_size(dh);  
         kbuf = xmalloc(klen);  
         kout = DH_compute_key(kbuf, dh_server_pub, dh);  
 #ifdef DEBUG_KEXDH  
         dump_digest("shared secret", kbuf, kout);  
 #endif  
         if ((shared_secret = BN_new()) == NULL)  
                 fatal("kexdh_client: BN_new failed");  
         BN_bin2bn(kbuf, kout, shared_secret);  
         memset(kbuf, 0, klen);  
         xfree(kbuf);  
   
         /* calc and verify H */  
         hash = kex_dh_hash(  
             kex->client_version_string,  
             kex->server_version_string,  
             buffer_ptr(&kex->my), buffer_len(&kex->my),  
             buffer_ptr(&kex->peer), buffer_len(&kex->peer),  
             server_host_key_blob, sbloblen,  
             dh->pub_key,  
             dh_server_pub,  
             shared_secret  
         );  
         xfree(server_host_key_blob);  
         BN_clear_free(dh_server_pub);  
         DH_free(dh);  
   
         if (key_verify(server_host_key, signature, slen, hash, 20) != 1)  
                 fatal("key_verify failed for server_host_key");  
         key_free(server_host_key);  
         xfree(signature);  
   
         /* save session id */  
         if (kex->session_id == NULL) {  
                 kex->session_id_len = 20;  
                 kex->session_id = xmalloc(kex->session_id_len);  
                 memcpy(kex->session_id, hash, kex->session_id_len);  
         }  
   
         kex_derive_keys(kex, hash, shared_secret);  
         BN_clear_free(shared_secret);  
         kex_finish(kex);  
 }  
   
 /* server */  
   
 static void  
 kexdh_server(Kex *kex)  
 {  
         BIGNUM *shared_secret = NULL, *dh_client_pub = NULL;  
         DH *dh;  
         Key *server_host_key;  
         u_char *kbuf, *hash, *signature = NULL, *server_host_key_blob = NULL;  
         u_int sbloblen, klen, kout;  
         u_int slen;  
   
         /* generate server DH public key */  
         dh = dh_new_group1();  
         dh_gen_key(dh, kex->we_need * 8);  
   
         debug("expecting SSH2_MSG_KEXDH_INIT");  
         packet_read_expect(SSH2_MSG_KEXDH_INIT);  
   
         if (kex->load_host_key == NULL)  
                 fatal("Cannot load hostkey");  
         server_host_key = kex->load_host_key(kex->hostkey_type);  
         if (server_host_key == NULL)  
                 fatal("Unsupported hostkey type %d", kex->hostkey_type);  
   
         /* key, cert */  
         if ((dh_client_pub = BN_new()) == NULL)  
                 fatal("dh_client_pub == NULL");  
         packet_get_bignum2(dh_client_pub);  
         packet_check_eom();  
   
 #ifdef DEBUG_KEXDH  
         fprintf(stderr, "dh_client_pub= ");  
         BN_print_fp(stderr, dh_client_pub);  
         fprintf(stderr, "\n");  
         debug("bits %d", BN_num_bits(dh_client_pub));  
 #endif  
   
 #ifdef DEBUG_KEXDH  
         DHparams_print_fp(stderr, dh);  
         fprintf(stderr, "pub= ");  
         BN_print_fp(stderr, dh->pub_key);  
         fprintf(stderr, "\n");  
 #endif  
         if (!dh_pub_is_valid(dh, dh_client_pub))  
                 packet_disconnect("bad client public DH value");  
   
         klen = DH_size(dh);  
         kbuf = xmalloc(klen);  
         kout = DH_compute_key(kbuf, dh_client_pub, dh);  
 #ifdef DEBUG_KEXDH  
         dump_digest("shared secret", kbuf, kout);  
 #endif  
         if ((shared_secret = BN_new()) == NULL)  
                 fatal("kexdh_server: BN_new failed");  
         BN_bin2bn(kbuf, kout, shared_secret);  
         memset(kbuf, 0, klen);  
         xfree(kbuf);  
   
         key_to_blob(server_host_key, &server_host_key_blob, &sbloblen);  
   
         /* calc H */  
         hash = kex_dh_hash(  
             kex->client_version_string,  
             kex->server_version_string,  
             buffer_ptr(&kex->peer), buffer_len(&kex->peer),  
             buffer_ptr(&kex->my), buffer_len(&kex->my),  
             server_host_key_blob, sbloblen,  
             dh_client_pub,  
             dh->pub_key,  
             shared_secret  
         );  
         BN_clear_free(dh_client_pub);  
   
         /* save session id := H */  
         /* XXX hashlen depends on KEX */  
         if (kex->session_id == NULL) {  
                 kex->session_id_len = 20;  
                 kex->session_id = xmalloc(kex->session_id_len);  
                 memcpy(kex->session_id, hash, kex->session_id_len);  
         }  
   
         /* sign H */  
         /* XXX hashlen depends on KEX */  
         PRIVSEP(key_sign(server_host_key, &signature, &slen, hash, 20));  
   
         /* destroy_sensitive_data(); */  
   
         /* send server hostkey, DH pubkey 'f' and singed H */  
         packet_start(SSH2_MSG_KEXDH_REPLY);  
         packet_put_string(server_host_key_blob, sbloblen);  
         packet_put_bignum2(dh->pub_key);        /* f */  
         packet_put_string(signature, slen);  
         packet_send();  
   
         xfree(signature);  
         xfree(server_host_key_blob);  
         /* have keys, free DH */  
         DH_free(dh);  
   
         kex_derive_keys(kex, hash, shared_secret);  
         BN_clear_free(shared_secret);  
         kex_finish(kex);  
 }  
   
 void  
 kexdh(Kex *kex)  
 {  
         if (kex->server)  
                 kexdh_server(kex);  
         else  
                 kexdh_client(kex);  
 }  }
Legend:
Removed from v.1.18  
changed lines
  Added in v.1.19