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

Diff for /src/usr.bin/ssh/sshconnect2.c between version 1.27.2.7 and 1.27.2.8

version 1.27.2.7, 2001/11/15 22:50:30 version 1.27.2.8, 2002/03/08 17:04:43
Line 25 
Line 25 
 #include "includes.h"  #include "includes.h"
 RCSID("$OpenBSD$");  RCSID("$OpenBSD$");
   
 #include <openssl/bn.h>  
 #include <openssl/md5.h>  
 #include <openssl/dh.h>  
 #include <openssl/hmac.h>  
   
 #include "ssh.h"  #include "ssh.h"
 #include "ssh2.h"  #include "ssh2.h"
 #include "xmalloc.h"  #include "xmalloc.h"
 #include "rsa.h"  
 #include "buffer.h"  #include "buffer.h"
 #include "packet.h"  #include "packet.h"
 #include "uidswap.h"  
 #include "compat.h"  #include "compat.h"
 #include "bufaux.h"  #include "bufaux.h"
 #include "cipher.h"  #include "cipher.h"
 #include "kex.h"  #include "kex.h"
 #include "myproposal.h"  #include "myproposal.h"
 #include "key.h"  
 #include "sshconnect.h"  #include "sshconnect.h"
 #include "authfile.h"  #include "authfile.h"
 #include "dh.h"  #include "dh.h"
Line 111 
Line 103 
                 myproposal[PROPOSAL_MAC_ALGS_STOC] = options.macs;                  myproposal[PROPOSAL_MAC_ALGS_STOC] = options.macs;
         }          }
         if (options.hostkeyalgorithms != NULL)          if (options.hostkeyalgorithms != NULL)
                 myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] =                  myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] =
                     options.hostkeyalgorithms;                      options.hostkeyalgorithms;
   
         /* start key exchange */          /* start key exchange */
Line 146 
Line 138 
   
 typedef int sign_cb_fn(  typedef int sign_cb_fn(
     Authctxt *authctxt, Key *key,      Authctxt *authctxt, Key *key,
     u_char **sigp, int *lenp, u_char *data, int datalen);      u_char **sigp, u_int *lenp, u_char *data, u_int datalen);
   
 struct Authctxt {  struct Authctxt {
         const char *server_user;          const char *server_user;
Line 174 
Line 166 
         int     *batch_flag;    /* flag in option struct that disables method */          int     *batch_flag;    /* flag in option struct that disables method */
 };  };
   
 void    input_userauth_success(int type, int plen, void *ctxt);  void    input_userauth_success(int, u_int32_t, void *);
 void    input_userauth_failure(int type, int plen, void *ctxt);  void    input_userauth_failure(int, u_int32_t, void *);
 void    input_userauth_banner(int type, int plen, void *ctxt);  void    input_userauth_banner(int, u_int32_t, void *);
 void    input_userauth_error(int type, int plen, void *ctxt);  void    input_userauth_error(int, u_int32_t, void *);
 void    input_userauth_info_req(int type, int plen, void *ctxt);  void    input_userauth_info_req(int, u_int32_t, void *);
 void    input_userauth_pk_ok(int type, int plen, void *ctxt);  void    input_userauth_pk_ok(int, u_int32_t, void *);
   
 int     userauth_none(Authctxt *authctxt);  int     userauth_none(Authctxt *);
 int     userauth_pubkey(Authctxt *authctxt);  int     userauth_pubkey(Authctxt *);
 int     userauth_passwd(Authctxt *authctxt);  int     userauth_passwd(Authctxt *);
 int     userauth_kbdint(Authctxt *authctxt);  int     userauth_kbdint(Authctxt *);
 int     userauth_hostbased(Authctxt *authctxt);  int     userauth_hostbased(Authctxt *);
   
 void    userauth(Authctxt *authctxt, char *authlist);  void    userauth(Authctxt *, char *);
   
 static int sign_and_send_pubkey(Authctxt *, Key *, sign_cb_fn *);  static int sign_and_send_pubkey(Authctxt *, Key *, sign_cb_fn *);
 static void clear_auth_state(Authctxt *);  static void clear_auth_state(Authctxt *);
Line 226 
Line 218 
 {  {
         Authctxt authctxt;          Authctxt authctxt;
         int type;          int type;
         int plen;  
   
         if (options.challenge_response_authentication)          if (options.challenge_response_authentication)
                 options.kbd_interactive_authentication = 1;                  options.kbd_interactive_authentication = 1;
Line 236 
Line 227 
         packet_put_cstring("ssh-userauth");          packet_put_cstring("ssh-userauth");
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
         type = packet_read(&plen);          type = packet_read();
         if (type != SSH2_MSG_SERVICE_ACCEPT) {          if (type != SSH2_MSG_SERVICE_ACCEPT) {
                 fatal("denied SSH2_MSG_SERVICE_ACCEPT: %d", type);                  fatal("denied SSH2_MSG_SERVICE_ACCEPT: %d", type);
         }          }
         if (packet_remaining() > 0) {          if (packet_remaining() > 0) {
                 char *reply = packet_get_string(&plen);                  char *reply = packet_get_string(NULL);
                 debug("service_accept: %s", reply);                  debug("service_accept: %s", reply);
                 xfree(reply);                  xfree(reply);
         } else {          } else {
                 debug("buggy server: service_accept w/o service");                  debug("buggy server: service_accept w/o service");
         }          }
         packet_done();          packet_check_eom();
         debug("got SSH2_MSG_SERVICE_ACCEPT");          debug("got SSH2_MSG_SERVICE_ACCEPT");
   
         if (options.preferred_authentications == NULL)          if (options.preferred_authentications == NULL)
Line 308 
Line 299 
         }          }
 }  }
 void  void
 input_userauth_error(int type, int plen, void *ctxt)  input_userauth_error(int type, u_int32_t seq, void *ctxt)
 {  {
         fatal("input_userauth_error: bad message during authentication: "          fatal("input_userauth_error: bad message during authentication: "
            "type %d", type);             "type %d", type);
 }  }
 void  void
 input_userauth_banner(int type, int plen, void *ctxt)  input_userauth_banner(int type, u_int32_t seq, void *ctxt)
 {  {
         char *msg, *lang;          char *msg, *lang;
         debug3("input_userauth_banner");          debug3("input_userauth_banner");
Line 325 
Line 316 
         xfree(lang);          xfree(lang);
 }  }
 void  void
 input_userauth_success(int type, int plen, void *ctxt)  input_userauth_success(int type, u_int32_t seq, void *ctxt)
 {  {
         Authctxt *authctxt = ctxt;          Authctxt *authctxt = ctxt;
         if (authctxt == NULL)          if (authctxt == NULL)
Line 336 
Line 327 
         authctxt->success = 1;                  /* break out */          authctxt->success = 1;                  /* break out */
 }  }
 void  void
 input_userauth_failure(int type, int plen, void *ctxt)  input_userauth_failure(int type, u_int32_t seq, void *ctxt)
 {  {
         Authctxt *authctxt = ctxt;          Authctxt *authctxt = ctxt;
         char *authlist = NULL;          char *authlist = NULL;
Line 347 
Line 338 
   
         authlist = packet_get_string(NULL);          authlist = packet_get_string(NULL);
         partial = packet_get_char();          partial = packet_get_char();
         packet_done();          packet_check_eom();
   
         if (partial != 0)          if (partial != 0)
                 log("Authenticated with partial success.");                  log("Authenticated with partial success.");
Line 357 
Line 348 
         userauth(authctxt, authlist);          userauth(authctxt, authlist);
 }  }
 void  void
 input_userauth_pk_ok(int type, int plen, void *ctxt)  input_userauth_pk_ok(int type, u_int32_t seq, void *ctxt)
 {  {
         Authctxt *authctxt = ctxt;          Authctxt *authctxt = ctxt;
         Key *key = NULL;          Key *key = NULL;
         Buffer b;          Buffer b;
         int alen, blen, sent = 0;          int pktype, sent = 0;
         char *pkalg, *pkblob, *fp;          u_int alen, blen;
           char *pkalg, *fp;
           u_char *pkblob;
   
         if (authctxt == NULL)          if (authctxt == NULL)
                 fatal("input_userauth_pk_ok: no authentication context");                  fatal("input_userauth_pk_ok: no authentication context");
Line 379 
Line 372 
                 pkalg = packet_get_string(&alen);                  pkalg = packet_get_string(&alen);
                 pkblob = packet_get_string(&blen);                  pkblob = packet_get_string(&blen);
         }          }
         packet_done();          packet_check_eom();
   
         debug("input_userauth_pk_ok: pkalg %s blen %d lastkey %p hint %d",          debug("input_userauth_pk_ok: pkalg %s blen %d lastkey %p hint %d",
             pkalg, blen, authctxt->last_key, authctxt->last_key_hint);              pkalg, blen, authctxt->last_key, authctxt->last_key_hint);
Line 390 
Line 383 
                         debug("no last key or no sign cb");                          debug("no last key or no sign cb");
                         break;                          break;
                 }                  }
                 if (key_type_from_name(pkalg) == KEY_UNSPEC) {                  if ((pktype = key_type_from_name(pkalg)) == KEY_UNSPEC) {
                         debug("unknown pkalg %s", pkalg);                          debug("unknown pkalg %s", pkalg);
                         break;                          break;
                 }                  }
Line 398 
Line 391 
                         debug("no key from blob. pkalg %s", pkalg);                          debug("no key from blob. pkalg %s", pkalg);
                         break;                          break;
                 }                  }
                   if (key->type != pktype) {
                           error("input_userauth_pk_ok: type mismatch "
                               "for decoded key (received %d, expected %d)",
                                key->type, pktype);
                           break;
                   }
                 fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);                  fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
                 debug2("input_userauth_pk_ok: fp %s", fp);                  debug2("input_userauth_pk_ok: fp %s", fp);
                 xfree(fp);                  xfree(fp);
Line 407 
Line 406 
                 }                  }
                 sent = sign_and_send_pubkey(authctxt, key,                  sent = sign_and_send_pubkey(authctxt, key,
                    authctxt->last_key_sign);                     authctxt->last_key_sign);
         } while(0);          } while (0);
   
         if (key != NULL)          if (key != NULL)
                 key_free(key);                  key_free(key);
Line 446 
Line 445 
         if (attempt++ >= options.number_of_password_prompts)          if (attempt++ >= options.number_of_password_prompts)
                 return 0;                  return 0;
   
         if(attempt != 1)          if (attempt != 1)
                 error("Permission denied, please try again.");                  error("Permission denied, please try again.");
   
         snprintf(prompt, sizeof(prompt), "%.30s@%.128s's password: ",          snprintf(prompt, sizeof(prompt), "%.30s@%.128s's password: ",
Line 483 
Line 482 
 {  {
         Buffer b;          Buffer b;
         u_char *blob, *signature;          u_char *blob, *signature;
         int bloblen, slen;          u_int bloblen, slen;
         int skip = 0;          int skip = 0;
         int ret = -1;          int ret = -1;
         int have_sig = 1;          int have_sig = 1;
Line 568 
Line 567 
     int hint)      int hint)
 {  {
         u_char *blob;          u_char *blob;
         int bloblen, have_sig = 0;          u_int bloblen, have_sig = 0;
   
         debug3("send_pubkey_test");          debug3("send_pubkey_test");
   
Line 613 
Line 612 
                 if (options.batch_mode)                  if (options.batch_mode)
                         return NULL;                          return NULL;
                 snprintf(prompt, sizeof prompt,                  snprintf(prompt, sizeof prompt,
                      "Enter passphrase for key '%.100s': ", filename);                      "Enter passphrase for key '%.100s': ", filename);
                 for (i = 0; i < options.number_of_password_prompts; i++) {                  for (i = 0; i < options.number_of_password_prompts; i++) {
                         passphrase = read_passphrase(prompt, 0);                          passphrase = read_passphrase(prompt, 0);
                         if (strcmp(passphrase, "") != 0) {                          if (strcmp(passphrase, "") != 0) {
Line 635 
Line 634 
 }  }
   
 static int  static int
 identity_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, int *lenp,  identity_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, u_int *lenp,
     u_char *data, int datalen)      u_char *data, u_int datalen)
 {  {
         Key *private;          Key *private;
         int idx, ret;          int idx, ret;
Line 646 
Line 645 
                 return -1;                  return -1;
   
         /* private key is stored in external hardware */          /* private key is stored in external hardware */
         if (options.identity_keys[idx]->flags & KEY_FLAG_EXT)          if (options.identity_keys[idx]->flags & KEY_FLAG_EXT)
                 return key_sign(options.identity_keys[idx], sigp, lenp, data, datalen);                  return key_sign(options.identity_keys[idx], sigp, lenp, data, datalen);
   
         private = load_identity_file(options.identity_files[idx]);          private = load_identity_file(options.identity_files[idx]);
Line 658 
Line 657 
 }  }
   
 static int  static int
 agent_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, int *lenp,  agent_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, u_int *lenp,
     u_char *data, int datalen)      u_char *data, u_int datalen)
 {  {
         return ssh_agent_sign(authctxt->agent, key, sigp, lenp, data, datalen);          return ssh_agent_sign(authctxt->agent, key, sigp, lenp, data, datalen);
 }  }
   
 static int  static int
 key_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, int *lenp,  key_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, u_int *lenp,
     u_char *data, int datalen)      u_char *data, u_int datalen)
 {  {
         return key_sign(key, sigp, lenp, data, datalen);          return key_sign(key, sigp, lenp, data, datalen);
 }  }
Line 710 
Line 709 
         if (authctxt->agent != NULL) {          if (authctxt->agent != NULL) {
                 do {                  do {
                         sent = userauth_pubkey_agent(authctxt);                          sent = userauth_pubkey_agent(authctxt);
                 } while(!sent && authctxt->agent->howmany > 0);                  } while (!sent && authctxt->agent->howmany > 0);
         }          }
         while (!sent && idx < options.num_identity_files) {          while (!sent && idx < options.num_identity_files) {
                 key = options.identity_keys[idx];                  key = options.identity_keys[idx];
Line 768 
Line 767 
  * parse INFO_REQUEST, prompt user and send INFO_RESPONSE   * parse INFO_REQUEST, prompt user and send INFO_RESPONSE
  */   */
 void  void
 input_userauth_info_req(int type, int plen, void *ctxt)  input_userauth_info_req(int type, u_int32_t seq, void *ctxt)
 {  {
         Authctxt *authctxt = ctxt;          Authctxt *authctxt = ctxt;
         char *name, *inst, *lang, *prompt, *response;          char *name, *inst, *lang, *prompt, *response;
Line 815 
Line 814 
                 xfree(response);                  xfree(response);
                 xfree(prompt);                  xfree(prompt);
         }          }
         packet_done(); /* done with parsing incoming message. */          packet_check_eom(); /* done with parsing incoming message. */
   
         packet_add_padding(64);          packet_add_padding(64);
         packet_send();          packet_send();
Line 957 
Line 956 
 {  {
   
         char *name = NULL;          char *name = NULL;
         int next;          u_int next;
   
         /* Use a suitable default if we're passed a nil list.  */          /* Use a suitable default if we're passed a nil list.  */
         if (authlist == NULL || strlen(authlist) == 0)          if (authlist == NULL || strlen(authlist) == 0)
Line 992 
Line 991 
         }          }
 }  }
   
   
 #define DELIM   ","  
   
 static char *  static char *
 authmethods_get(void)  authmethods_get(void)
 {  {
         Authmethod *method = NULL;          Authmethod *method = NULL;
         char buf[1024];          Buffer b;
           char *list;
   
         buf[0] = '\0';          buffer_init(&b);
         for (method = authmethods; method->name != NULL; method++) {          for (method = authmethods; method->name != NULL; method++) {
                 if (authmethod_is_enabled(method)) {                  if (authmethod_is_enabled(method)) {
                         if (buf[0] != '\0')                          if (buffer_len(&b) > 0)
                                 strlcat(buf, DELIM, sizeof buf);                                  buffer_append(&b, ",", 1);
                         strlcat(buf, method->name, sizeof buf);                          buffer_append(&b, method->name, strlen(method->name));
                 }                  }
         }          }
         return xstrdup(buf);          buffer_append(&b, "\0", 1);
           list = xstrdup(buffer_ptr(&b));
           buffer_free(&b);
           return list;
 }  }
Legend:
Removed from v.1.27.2.7  
changed lines
  Added in v.1.27.2.8