[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.72 and 1.72.2.4

version 1.72, 2001/04/18 23:43:26 version 1.72.2.4, 2002/03/09 00:20:45
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 "cli.h"  
 #include "dh.h"  #include "dh.h"
 #include "authfd.h"  #include "authfd.h"
 #include "log.h"  #include "log.h"
Line 72 
Line 63 
   
 Kex *xxx_kex = NULL;  Kex *xxx_kex = NULL;
   
 int  static int
 check_host_key_callback(Key *hostkey)  verify_host_key_callback(Key *hostkey)
 {  {
         check_host_key(xxx_host, xxx_hostaddr, hostkey,          if (verify_host_key(xxx_host, xxx_hostaddr, hostkey) == -1)
             options.user_hostfile2, options.system_hostfile2);                  fatal("Host key verification failed.");
         return 0;          return 0;
 }  }
   
Line 112 
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 */
         kex = kex_setup(myproposal);          kex = kex_setup(myproposal);
         kex->client_version_string=client_version_string;          kex->client_version_string=client_version_string;
         kex->server_version_string=server_version_string;          kex->server_version_string=server_version_string;
         kex->check_host_key=&check_host_key_callback;          kex->verify_host_key=&verify_host_key_callback;
   
         xxx_kex = kex;          xxx_kex = kex;
   
Line 147 
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 165 
Line 156 
         /* hostbased */          /* hostbased */
         Key **keys;          Key **keys;
         int nkeys;          int nkeys;
           /* kbd-interactive */
           int info_req_seen;
 };  };
 struct Authmethod {  struct Authmethod {
         char    *name;          /* string to compare against server's list */          char    *name;          /* string to compare against server's list */
Line 173 
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 *);
   
 int  static int sign_and_send_pubkey(Authctxt *, Key *, sign_cb_fn *);
 sign_and_send_pubkey(Authctxt *authctxt, Key *k,  static void clear_auth_state(Authctxt *);
     sign_cb_fn *sign_callback);  
 void    clear_auth_state(Authctxt *authctxt);  
   
 Authmethod *authmethod_get(char *authlist);  static Authmethod *authmethod_get(char *authlist);
 Authmethod *authmethod_lookup(const char *name);  static Authmethod *authmethod_lookup(const char *name);
 char *authmethods_get(void);  static char *authmethods_get(void);
   
 Authmethod authmethods[] = {  Authmethod authmethods[] = {
           {"hostbased",
                   userauth_hostbased,
                   &options.hostbased_authentication,
                   NULL},
         {"publickey",          {"publickey",
                 userauth_pubkey,                  userauth_pubkey,
                 &options.pubkey_authentication,                  &options.pubkey_authentication,
                 NULL},                  NULL},
         {"password",  
                 userauth_passwd,  
                 &options.password_authentication,  
                 &options.batch_mode},  
         {"keyboard-interactive",          {"keyboard-interactive",
                 userauth_kbdint,                  userauth_kbdint,
                 &options.kbd_interactive_authentication,                  &options.kbd_interactive_authentication,
                 &options.batch_mode},                  &options.batch_mode},
         {"hostbased",          {"password",
                 userauth_hostbased,                  userauth_passwd,
                 &options.hostbased_authentication,                  &options.password_authentication,
                 NULL},                  &options.batch_mode},
         {"none",          {"none",
                 userauth_none,                  userauth_none,
                 NULL,                  NULL,
Line 227 
Line 218 
 {  {
         Authctxt authctxt;          Authctxt authctxt;
         int type;          int type;
         int plen;  
   
         if (options.challenge_reponse_authentication)          if (options.challenge_response_authentication)
                 options.kbd_interactive_authentication = 1;                  options.kbd_interactive_authentication = 1;
   
         debug("send SSH2_MSG_SERVICE_REQUEST");          debug("send SSH2_MSG_SERVICE_REQUEST");
Line 237 
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)
                 options.preferred_authentications = authmethods_get();                  options.preferred_authentications = authmethods_get();
   
         /* setup authentication context */          /* setup authentication context */
           memset(&authctxt, 0, sizeof(authctxt));
         authctxt.agent = ssh_get_authentication_connection();          authctxt.agent = ssh_get_authentication_connection();
         authctxt.server_user = server_user;          authctxt.server_user = server_user;
         authctxt.local_user = local_user;          authctxt.local_user = local_user;
Line 265 
Line 256 
         authctxt.authlist = NULL;          authctxt.authlist = NULL;
         authctxt.keys = keys;          authctxt.keys = keys;
         authctxt.nkeys = nkeys;          authctxt.nkeys = nkeys;
           authctxt.info_req_seen = 0;
         if (authctxt.method == NULL)          if (authctxt.method == NULL)
                 fatal("ssh_userauth2: internal error: cannot send userauth none request");                  fatal("ssh_userauth2: internal error: cannot send userauth none request");
   
Line 307 
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 324 
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 335 
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 346 
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 356 
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 378 
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 389 
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 397 
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 406 
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 445 
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 459 
Line 459 
         packet_put_cstring(password);          packet_put_cstring(password);
         memset(password, 0, strlen(password));          memset(password, 0, strlen(password));
         xfree(password);          xfree(password);
         packet_inject_ignore(64);          packet_add_padding(64);
         packet_send();          packet_send();
         return 1;          return 1;
 }  }
   
 void  static void
 clear_auth_state(Authctxt *authctxt)  clear_auth_state(Authctxt *authctxt)
 {  {
         /* XXX clear authentication state */          /* XXX clear authentication state */
Line 477 
Line 477 
         authctxt->last_key_sign = NULL;          authctxt->last_key_sign = NULL;
 }  }
   
 int  static int
 sign_and_send_pubkey(Authctxt *authctxt, Key *k, sign_cb_fn *sign_callback)  sign_and_send_pubkey(Authctxt *authctxt, Key *k, sign_cb_fn *sign_callback)
 {  {
         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 562 
Line 562 
         return 1;          return 1;
 }  }
   
 int  static int
 send_pubkey_test(Authctxt *authctxt, Key *k, sign_cb_fn *sign_callback,  send_pubkey_test(Authctxt *authctxt, Key *k, sign_cb_fn *sign_callback,
     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 595 
Line 595 
         return 1;          return 1;
 }  }
   
 Key *  static Key *
 load_identity_file(char *filename)  load_identity_file(char *filename)
 {  {
         Key *private;          Key *private;
Line 612 
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 633 
Line 633 
         return private;          return private;
 }  }
   
 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 643 
Line 643 
         idx = authctxt->last_key_hint;          idx = authctxt->last_key_hint;
         if (idx < 0)          if (idx < 0)
                 return -1;                  return -1;
   
           /* private key is stored in external hardware */
           if (options.identity_keys[idx]->flags & KEY_FLAG_EXT)
                   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]);
         if (private == NULL)          if (private == NULL)
                 return -1;                  return -1;
Line 651 
Line 656 
         return ret;          return ret;
 }  }
   
 int agent_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, int *lenp,  static int
     u_char *data, int datalen)  agent_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, u_int *lenp,
       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);
 }  }
   
 int key_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, int *lenp,  static int
     u_char *data, int datalen)  key_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, u_int *lenp,
       u_char *data, u_int datalen)
 {  {
         return key_sign(key, sigp, lenp, data, datalen);          return key_sign(key, sigp, lenp, data, datalen);
 }  }
   
 int  static int
 userauth_pubkey_agent(Authctxt *authctxt)  userauth_pubkey_agent(Authctxt *authctxt)
 {  {
         static int called = 0;          static int called = 0;
Line 702 
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 735 
Line 742 
   
         if (attempt++ >= options.number_of_password_prompts)          if (attempt++ >= options.number_of_password_prompts)
                 return 0;                  return 0;
           /* disable if no SSH2_MSG_USERAUTH_INFO_REQUEST has been seen */
           if (attempt > 1 && !authctxt->info_req_seen) {
                   debug3("userauth_kbdint: disable: no info_req_seen");
                   dispatch_set(SSH2_MSG_USERAUTH_INFO_REQUEST, NULL);
                   return 0;
           }
   
         debug2("userauth_kbdint");          debug2("userauth_kbdint");
         packet_start(SSH2_MSG_USERAUTH_REQUEST);          packet_start(SSH2_MSG_USERAUTH_REQUEST);
Line 754 
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 766 
Line 779 
         if (authctxt == NULL)          if (authctxt == NULL)
                 fatal("input_userauth_info_req: no authentication context");                  fatal("input_userauth_info_req: no authentication context");
   
           authctxt->info_req_seen = 1;
   
         name = packet_get_string(NULL);          name = packet_get_string(NULL);
         inst = packet_get_string(NULL);          inst = packet_get_string(NULL);
         lang = packet_get_string(NULL);          lang = packet_get_string(NULL);
         if (strlen(name) > 0)          if (strlen(name) > 0)
                 cli_mesg(name);                  log("%s", name);
         if (strlen(inst) > 0)          if (strlen(inst) > 0)
                 cli_mesg(inst);                  log("%s", inst);
         xfree(name);          xfree(name);
         xfree(inst);          xfree(inst);
         xfree(lang);          xfree(lang);
Line 787 
Line 802 
         packet_start(SSH2_MSG_USERAUTH_INFO_RESPONSE);          packet_start(SSH2_MSG_USERAUTH_INFO_RESPONSE);
         packet_put_int(num_prompts);          packet_put_int(num_prompts);
   
           debug2("input_userauth_info_req: num_prompts %d", num_prompts);
         for (i = 0; i < num_prompts; i++) {          for (i = 0; i < num_prompts; i++) {
                 prompt = packet_get_string(NULL);                  prompt = packet_get_string(NULL);
                 echo = packet_get_char();                  echo = packet_get_char();
   
                 response = cli_prompt(prompt, echo);                  response = read_passphrase(prompt, echo ? RP_ECHO : 0);
   
                 packet_put_cstring(response);                  packet_put_cstring(response);
                 memset(response, 0, strlen(response));                  memset(response, 0, strlen(response));
                 xfree(response);                  xfree(response);
                 xfree(prompt);                  xfree(prompt);
         }          }
         packet_done(); /* done with parsing incoming message. */          packet_check_eom(); /* done with parsing incoming message. */
   
         packet_inject_ignore(64);          packet_add_padding(64);
         packet_send();          packet_send();
 }  }
   
Line 819 
Line 835 
         u_int blen, slen;          u_int blen, slen;
         int ok, i, len, found = 0;          int ok, i, len, found = 0;
   
         p = get_local_name(packet_get_connection_in());  
         if (p == NULL) {  
                 error("userauth_hostbased: cannot get local ipaddr/name");  
                 return 0;  
         }  
         len = strlen(p) + 2;  
         chost = xmalloc(len);  
         strlcpy(chost, p, len);  
         strlcat(chost, ".", len);  
         debug2("userauth_hostbased: chost %s", chost);  
         /* check for a useful key */          /* check for a useful key */
         for (i = 0; i < authctxt->nkeys; i++) {          for (i = 0; i < authctxt->nkeys; i++) {
                 private = authctxt->keys[i];                  private = authctxt->keys[i];
Line 840 
Line 846 
                 }                  }
         }          }
         if (!found) {          if (!found) {
                 xfree(chost);                  debug("userauth_hostbased: no more client hostkeys");
                 return 0;                  return 0;
         }          }
         if (key_to_blob(private, &blob, &blen) == 0) {          if (key_to_blob(private, &blob, &blen) == 0) {
                 key_free(private);                  key_free(private);
                 xfree(chost);  
                 return 0;                  return 0;
         }          }
           /* figure out a name for the client host */
           p = get_local_name(packet_get_connection_in());
           if (p == NULL) {
                   error("userauth_hostbased: cannot get local ipaddr/name");
                   key_free(private);
                   return 0;
           }
           len = strlen(p) + 2;
           chost = xmalloc(len);
           strlcpy(chost, p, len);
           strlcat(chost, ".", len);
           debug2("userauth_hostbased: chost %s", chost);
   
         service = datafellows & SSH_BUG_HBSERVICE ? "ssh-userauth" :          service = datafellows & SSH_BUG_HBSERVICE ? "ssh-userauth" :
             authctxt->service;              authctxt->service;
         pkalg = xstrdup(key_ssh_name(private));          pkalg = xstrdup(key_ssh_name(private));
Line 865 
Line 883 
 #ifdef DEBUG_PK  #ifdef DEBUG_PK
         buffer_dump(&b);          buffer_dump(&b);
 #endif  #endif
         debug2("xxx: chost %s", chost);  
         ok = key_sign(private, &signature, &slen, buffer_ptr(&b), buffer_len(&b));          ok = key_sign(private, &signature, &slen, buffer_ptr(&b), buffer_len(&b));
         key_free(private);          key_free(private);
         buffer_free(&b);          buffer_free(&b);
Line 899 
Line 916 
  * given auth method name, if configurable options permit this method fill   * given auth method name, if configurable options permit this method fill
  * in auth_ident field and return true, otherwise return false.   * in auth_ident field and return true, otherwise return false.
  */   */
 int  static int
 authmethod_is_enabled(Authmethod *method)  authmethod_is_enabled(Authmethod *method)
 {  {
         if (method == NULL)          if (method == NULL)
Line 913 
Line 930 
         return 1;          return 1;
 }  }
   
 Authmethod *  static Authmethod *
 authmethod_lookup(const char *name)  authmethod_lookup(const char *name)
 {  {
         Authmethod *method = NULL;          Authmethod *method = NULL;
Line 934 
Line 951 
  * next method we should try.  If the server initially sends a nil list,   * next method we should try.  If the server initially sends a nil list,
  * use a built-in default list.   * use a built-in default list.
  */   */
 Authmethod *  static Authmethod *
 authmethod_get(char *authlist)  authmethod_get(char *authlist)
 {  {
   
         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 974 
Line 991 
         }          }
 }  }
   
   static char *
 #define DELIM   ","  
 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.72  
changed lines
  Added in v.1.72.2.4