[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.99 and 1.99.2.1

version 1.99, 2002/03/26 15:58:46 version 1.99.2.1, 2002/06/26 15:30:39
Line 45 
Line 45 
 #include "match.h"  #include "match.h"
 #include "dispatch.h"  #include "dispatch.h"
 #include "canohost.h"  #include "canohost.h"
   #include "msg.h"
   #include "pathnames.h"
   
 /* import */  /* import */
 extern char *client_version_string;  extern char *client_version_string;
Line 154 
Line 156 
         int last_key_hint;          int last_key_hint;
         AuthenticationConnection *agent;          AuthenticationConnection *agent;
         /* hostbased */          /* hostbased */
         Key **keys;          Sensitive *sensitive;
         int nkeys;  
         /* kbd-interactive */          /* kbd-interactive */
         int info_req_seen;          int info_req_seen;
 };  };
Line 215 
Line 216 
   
 void  void
 ssh_userauth2(const char *local_user, const char *server_user, char *host,  ssh_userauth2(const char *local_user, const char *server_user, char *host,
     Key **keys, int nkeys)      Sensitive *sensitive)
 {  {
         Authctxt authctxt;          Authctxt authctxt;
         int type;          int type;
Line 255 
Line 256 
         authctxt.success = 0;          authctxt.success = 0;
         authctxt.method = authmethod_lookup("none");          authctxt.method = authmethod_lookup("none");
         authctxt.authlist = NULL;          authctxt.authlist = NULL;
         authctxt.keys = keys;          authctxt.sensitive = sensitive;
         authctxt.nkeys = nkeys;  
         authctxt.info_req_seen = 0;          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 299 
Line 299 
                 }                  }
         }          }
 }  }
   
 void  void
 input_userauth_error(int type, u_int32_t seq, 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, u_int32_t seq, void *ctxt)  input_userauth_banner(int type, u_int32_t seq, void *ctxt)
 {  {
Line 316 
Line 318 
         xfree(msg);          xfree(msg);
         xfree(lang);          xfree(lang);
 }  }
   
 void  void
 input_userauth_success(int type, u_int32_t seq, void *ctxt)  input_userauth_success(int type, u_int32_t seq, void *ctxt)
 {  {
Line 327 
Line 330 
         clear_auth_state(authctxt);          clear_auth_state(authctxt);
         authctxt->success = 1;                  /* break out */          authctxt->success = 1;                  /* break out */
 }  }
   
 void  void
 input_userauth_failure(int type, u_int32_t seq, void *ctxt)  input_userauth_failure(int type, u_int32_t seq, void *ctxt)
 {  {
Line 375 
Line 379 
         }          }
         packet_check_eom();          packet_check_eom();
   
         debug("input_userauth_pk_ok: pkalg %s blen %d lastkey %p hint %d",          debug("input_userauth_pk_ok: pkalg %s blen %u lastkey %p hint %d",
             pkalg, blen, authctxt->last_key, authctxt->last_key_hint);              pkalg, blen, authctxt->last_key, authctxt->last_key_hint);
   
         do {          do {
Line 395 
Line 399 
                 if (key->type != pktype) {                  if (key->type != pktype) {
                         error("input_userauth_pk_ok: type mismatch "                          error("input_userauth_pk_ok: type mismatch "
                             "for decoded key (received %d, expected %d)",                              "for decoded key (received %d, expected %d)",
                              key->type, pktype);                              key->type, pktype);
                         break;                          break;
                 }                  }
                 fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);                  fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
Line 463 
Line 467 
         packet_add_padding(64);          packet_add_padding(64);
         packet_send();          packet_send();
   
         dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,          dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,
             &input_userauth_passwd_changereq);              &input_userauth_passwd_changereq);
   
         return 1;          return 1;
Line 495 
Line 499 
         packet_put_cstring(authctxt->service);          packet_put_cstring(authctxt->service);
         packet_put_cstring(authctxt->method->name);          packet_put_cstring(authctxt->method->name);
         packet_put_char(1);                     /* additional info */          packet_put_char(1);                     /* additional info */
         snprintf(prompt, sizeof(prompt),          snprintf(prompt, sizeof(prompt),
             "Enter %.30s@%.128s's old password: ",              "Enter %.30s@%.128s's old password: ",
             authctxt->server_user, authctxt->host);              authctxt->server_user, authctxt->host);
         password = read_passphrase(prompt, 0);          password = read_passphrase(prompt, 0);
Line 504 
Line 508 
         xfree(password);          xfree(password);
         password = NULL;          password = NULL;
         while (password == NULL) {          while (password == NULL) {
                 snprintf(prompt, sizeof(prompt),                  snprintf(prompt, sizeof(prompt),
                     "Enter %.30s@%.128s's new password: ",                      "Enter %.30s@%.128s's new password: ",
                     authctxt->server_user, authctxt->host);                      authctxt->server_user, authctxt->host);
                 password = read_passphrase(prompt, RP_ALLOW_EOF);                  password = read_passphrase(prompt, RP_ALLOW_EOF);
Line 512 
Line 516 
                         /* bail out */                          /* bail out */
                         return;                          return;
                 }                  }
                 snprintf(prompt, sizeof(prompt),                  snprintf(prompt, sizeof(prompt),
                     "Retype %.30s@%.128s's new password: ",                      "Retype %.30s@%.128s's new password: ",
                     authctxt->server_user, authctxt->host);                      authctxt->server_user, authctxt->host);
                 retype = read_passphrase(prompt, 0);                  retype = read_passphrase(prompt, 0);
Line 530 
Line 534 
         xfree(password);          xfree(password);
         packet_add_padding(64);          packet_add_padding(64);
         packet_send();          packet_send();
   
         dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,          dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,
             &input_userauth_passwd_changereq);              &input_userauth_passwd_changereq);
 }  }
   
Line 893 
Line 897 
         packet_send();          packet_send();
 }  }
   
 /*  static int
  * this will be move to an external program (ssh-keysign) ASAP. ssh-keysign  ssh_keysign(Key *key, u_char **sigp, u_int *lenp,
  * will be setuid-root and the sbit can be removed from /usr/bin/ssh.      u_char *data, u_int datalen)
  */  {
           Buffer b;
           struct stat st;
           pid_t pid;
           int to[2], from[2], status, version = 2;
   
           debug("ssh_keysign called");
   
           if (stat(_PATH_SSH_KEY_SIGN, &st) < 0) {
                   error("ssh_keysign: no installed: %s", strerror(errno));
                   return -1;
           }
           if (fflush(stdout) != 0)
                   error("ssh_keysign: fflush: %s", strerror(errno));
           if (pipe(to) < 0) {
                   error("ssh_keysign: pipe: %s", strerror(errno));
                   return -1;
           }
           if (pipe(from) < 0) {
                   error("ssh_keysign: pipe: %s", strerror(errno));
                   return -1;
           }
           if ((pid = fork()) < 0) {
                   error("ssh_keysign: fork: %s", strerror(errno));
                   return -1;
           }
           if (pid == 0) {
                   seteuid(getuid());
                   setuid(getuid());
                   close(from[0]);
                   if (dup2(from[1], STDOUT_FILENO) < 0)
                           fatal("ssh_keysign: dup2: %s", strerror(errno));
                   close(to[1]);
                   if (dup2(to[0], STDIN_FILENO) < 0)
                           fatal("ssh_keysign: dup2: %s", strerror(errno));
                   close(from[1]);
                   close(to[0]);
                   execl(_PATH_SSH_KEY_SIGN, _PATH_SSH_KEY_SIGN, (char *) 0);
                   fatal("ssh_keysign: exec(%s): %s", _PATH_SSH_KEY_SIGN,
                       strerror(errno));
           }
           close(from[1]);
           close(to[0]);
   
           buffer_init(&b);
           buffer_put_int(&b, packet_get_connection_in()); /* send # of socket */
           buffer_put_string(&b, data, datalen);
           msg_send(to[1], version, &b);
   
           if (msg_recv(from[0], &b) < 0) {
                   error("ssh_keysign: no reply");
                   buffer_clear(&b);
                   return -1;
           }
           close(from[0]);
           close(to[1]);
   
           while (waitpid(pid, &status, 0) < 0)
                   if (errno != EINTR)
                           break;
   
           if (buffer_get_char(&b) != version) {
                   error("ssh_keysign: bad version");
                   buffer_clear(&b);
                   return -1;
           }
           *sigp = buffer_get_string(&b, lenp);
           buffer_clear(&b);
   
           return 0;
   }
   
 int  int
 userauth_hostbased(Authctxt *authctxt)  userauth_hostbased(Authctxt *authctxt)
 {  {
         Key *private = NULL;          Key *private = NULL;
           Sensitive *sensitive = authctxt->sensitive;
         Buffer b;          Buffer b;
         u_char *signature, *blob;          u_char *signature, *blob;
         char *chost, *pkalg, *p;          char *chost, *pkalg, *p;
Line 909 
Line 985 
         int ok, i, len, found = 0;          int ok, i, len, found = 0;
   
         /* check for a useful key */          /* check for a useful key */
         for (i = 0; i < authctxt->nkeys; i++) {          for (i = 0; i < sensitive->nkeys; i++) {
                 private = authctxt->keys[i];                  private = sensitive->keys[i];
                 if (private && private->type != KEY_RSA1) {                  if (private && private->type != KEY_RSA1) {
                         found = 1;                          found = 1;
                         /* we take and free the key */                          /* we take and free the key */
                         authctxt->keys[i] = NULL;                          sensitive->keys[i] = NULL;
                         break;                          break;
                 }                  }
         }          }
Line 956 
Line 1032 
 #ifdef DEBUG_PK  #ifdef DEBUG_PK
         buffer_dump(&b);          buffer_dump(&b);
 #endif  #endif
         ok = key_sign(private, &signature, &slen, buffer_ptr(&b), buffer_len(&b));          if (sensitive->external_keysign)
                   ok = ssh_keysign(private, &signature, &slen,
                       buffer_ptr(&b), buffer_len(&b));
           else
                   ok = key_sign(private, &signature, &slen,
                       buffer_ptr(&b), buffer_len(&b));
         key_free(private);          key_free(private);
         buffer_free(&b);          buffer_free(&b);
         if (ok != 0) {          if (ok != 0) {
Line 1019 
Line 1100 
 static Authmethod *current = NULL;  static Authmethod *current = NULL;
 static char *supported = NULL;  static char *supported = NULL;
 static char *preferred = NULL;  static char *preferred = NULL;
   
 /*  /*
  * Given the authentication method list sent by the server, return the   * Given the authentication method list sent by the server, return the
  * 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,
Legend:
Removed from v.1.99  
changed lines
  Added in v.1.99.2.1