[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.124 and 1.124.2.2

version 1.124, 2003/08/25 10:33:33 version 1.124.2.2, 2004/08/19 22:37:33
Line 41 
Line 41 
 #include "authfd.h"  #include "authfd.h"
 #include "log.h"  #include "log.h"
 #include "readconf.h"  #include "readconf.h"
 #include "readpass.h"  #include "misc.h"
 #include "match.h"  #include "match.h"
 #include "dispatch.h"  #include "dispatch.h"
 #include "canohost.h"  #include "canohost.h"
Line 118 
Line 118 
         /* start key exchange */          /* start key exchange */
         kex = kex_setup(myproposal);          kex = kex_setup(myproposal);
         kex->kex[KEX_DH_GRP1_SHA1] = kexdh_client;          kex->kex[KEX_DH_GRP1_SHA1] = kexdh_client;
           kex->kex[KEX_DH_GRP14_SHA1] = kexdh_client;
         kex->kex[KEX_DH_GEX_SHA1] = kexgex_client;          kex->kex[KEX_DH_GEX_SHA1] = kexgex_client;
         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;
Line 220 
Line 221 
   
 Authmethod authmethods[] = {  Authmethod authmethods[] = {
 #ifdef GSSAPI  #ifdef GSSAPI
         {"gssapi",          {"gssapi-with-mic",
                 userauth_gssapi,                  userauth_gssapi,
                 &options.gss_authentication,                  &options.gss_authentication,
                 NULL},                  NULL},
Line 356 
Line 357 
 input_userauth_banner(int type, u_int32_t seq, 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");
         msg = packet_get_string(NULL);          msg = packet_get_string(NULL);
         lang = packet_get_string(NULL);          lang = packet_get_string(NULL);
         logit("%s", msg);          if (options.log_level > SYSLOG_LEVEL_QUIET)
                   fprintf(stderr, "%s", msg);
         xfree(msg);          xfree(msg);
         xfree(lang);          xfree(lang);
 }  }
Line 370 
Line 373 
         Authctxt *authctxt = ctxt;          Authctxt *authctxt = ctxt;
         if (authctxt == NULL)          if (authctxt == NULL)
                 fatal("input_userauth_success: no authentication context");                  fatal("input_userauth_success: no authentication context");
         if (authctxt->authlist)          if (authctxt->authlist) {
                 xfree(authctxt->authlist);                  xfree(authctxt->authlist);
         if (authctxt->methoddata)                  authctxt->authlist = NULL;
           }
           if (authctxt->methoddata) {
                 xfree(authctxt->methoddata);                  xfree(authctxt->methoddata);
                   authctxt->methoddata = NULL;
           }
         authctxt->success = 1;                  /* break out */          authctxt->success = 1;                  /* break out */
 }  }
   
Line 445 
Line 452 
         debug2("input_userauth_pk_ok: fp %s", fp);          debug2("input_userauth_pk_ok: fp %s", fp);
         xfree(fp);          xfree(fp);
   
         TAILQ_FOREACH(id, &authctxt->keys, next) {          /*
            * search keys in the reverse order, because last candidate has been
            * moved to the end of the queue.  this also avoids confusion by
            * duplicate keys
            */
           TAILQ_FOREACH_REVERSE(id, &authctxt->keys, next, idlist) {
                 if (key_equal(key, id->key)) {                  if (key_equal(key, id->key)) {
                         sent = sign_and_send_pubkey(authctxt, id);                          sent = sign_and_send_pubkey(authctxt, id);
                         break;                          break;
Line 463 
Line 475 
 }  }
   
 #ifdef GSSAPI  #ifdef GSSAPI
 int  int
 userauth_gssapi(Authctxt *authctxt)  userauth_gssapi(Authctxt *authctxt)
 {  {
         Gssctxt *gssctxt = NULL;          Gssctxt *gssctxt = NULL;
         static gss_OID_set supported = NULL;          static gss_OID_set gss_supported = NULL;
         static int mech = 0;          static int mech = 0;
         OM_uint32 min;          OM_uint32 min;
         int ok = 0;          int ok = 0;
Line 475 
Line 487 
         /* Try one GSSAPI method at a time, rather than sending them all at          /* Try one GSSAPI method at a time, rather than sending them all at
          * once. */           * once. */
   
         if (supported == NULL)          if (gss_supported == NULL)
                 gss_indicate_mechs(&min, &supported);                  gss_indicate_mechs(&min, &gss_supported);
   
         /* Check to see if the mechanism is usable before we offer it */          /* Check to see if the mechanism is usable before we offer it */
         while (mech<supported->count && !ok) {          while (mech < gss_supported->count && !ok) {
                 if (gssctxt)                  if (gssctxt)
                         ssh_gssapi_delete_ctx(&gssctxt);                          ssh_gssapi_delete_ctx(&gssctxt);
                 ssh_gssapi_build_ctx(&gssctxt);                  ssh_gssapi_build_ctx(&gssctxt);
                 ssh_gssapi_set_oid(gssctxt, &supported->elements[mech]);                  ssh_gssapi_set_oid(gssctxt, &gss_supported->elements[mech]);
   
                 /* My DER encoding requires length<128 */                  /* My DER encoding requires length<128 */
                 if (supported->elements[mech].length < 128 &&                  if (gss_supported->elements[mech].length < 128 &&
                     !GSS_ERROR(ssh_gssapi_import_name(gssctxt,                      !GSS_ERROR(ssh_gssapi_import_name(gssctxt,
                     authctxt->host))) {                      authctxt->host))) {
                         ok = 1; /* Mechanism works */                          ok = 1; /* Mechanism works */
Line 506 
Line 518 
   
         packet_put_int(1);          packet_put_int(1);
   
         /* Some servers encode the OID incorrectly (as we used to) */          packet_put_int((gss_supported->elements[mech].length) + 2);
         if (datafellows & SSH_BUG_GSSAPI_BER) {          packet_put_char(SSH_GSS_OIDTYPE);
                 packet_put_string(supported->elements[mech].elements,          packet_put_char(gss_supported->elements[mech].length);
                     supported->elements[mech].length);          packet_put_raw(gss_supported->elements[mech].elements,
         } else {              gss_supported->elements[mech].length);
                 packet_put_int((supported->elements[mech].length)+2);  
                 packet_put_char(SSH_GSS_OIDTYPE);  
                 packet_put_char(supported->elements[mech].length);  
                 packet_put_raw(supported->elements[mech].elements,  
                     supported->elements[mech].length);  
         }  
   
         packet_send();          packet_send();
   
Line 530 
Line 536 
         return 1;          return 1;
 }  }
   
   static OM_uint32
   process_gssapi_token(void *ctxt, gss_buffer_t recv_tok)
   {
           Authctxt *authctxt = ctxt;
           Gssctxt *gssctxt = authctxt->methoddata;
           gss_buffer_desc send_tok = GSS_C_EMPTY_BUFFER;
           gss_buffer_desc gssbuf, mic;
           OM_uint32 status, ms, flags;
           Buffer b;
   
           status = ssh_gssapi_init_ctx(gssctxt, options.gss_deleg_creds,
               recv_tok, &send_tok, &flags);
   
           if (send_tok.length > 0) {
                   if (GSS_ERROR(status))
                           packet_start(SSH2_MSG_USERAUTH_GSSAPI_ERRTOK);
                   else
                           packet_start(SSH2_MSG_USERAUTH_GSSAPI_TOKEN);
   
                   packet_put_string(send_tok.value, send_tok.length);
                   packet_send();
                   gss_release_buffer(&ms, &send_tok);
           }
   
           if (status == GSS_S_COMPLETE) {
                   /* send either complete or MIC, depending on mechanism */
                   if (!(flags & GSS_C_INTEG_FLAG)) {
                           packet_start(SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE);
                           packet_send();
                   } else {
                           ssh_gssapi_buildmic(&b, authctxt->server_user,
                               authctxt->service, "gssapi-with-mic");
   
                           gssbuf.value = buffer_ptr(&b);
                           gssbuf.length = buffer_len(&b);
   
                           status = ssh_gssapi_sign(gssctxt, &gssbuf, &mic);
   
                           if (!GSS_ERROR(status)) {
                                   packet_start(SSH2_MSG_USERAUTH_GSSAPI_MIC);
                                   packet_put_string(mic.value, mic.length);
   
                                   packet_send();
                           }
   
                           buffer_free(&b);
                           gss_release_buffer(&ms, &mic);
                   }
           }
   
           return status;
   }
   
 void  void
 input_gssapi_response(int type, u_int32_t plen, void *ctxt)  input_gssapi_response(int type, u_int32_t plen, void *ctxt)
 {  {
         Authctxt *authctxt = ctxt;          Authctxt *authctxt = ctxt;
         Gssctxt *gssctxt;          Gssctxt *gssctxt;
         OM_uint32 status, ms;  
         int oidlen;          int oidlen;
         char *oidv;          char *oidv;
         gss_buffer_desc send_tok = GSS_C_EMPTY_BUFFER;  
   
         if (authctxt == NULL)          if (authctxt == NULL)
                 fatal("input_gssapi_response: no authentication context");                  fatal("input_gssapi_response: no authentication context");
Line 547 
Line 604 
         /* Setup our OID */          /* Setup our OID */
         oidv = packet_get_string(&oidlen);          oidv = packet_get_string(&oidlen);
   
         if (datafellows & SSH_BUG_GSSAPI_BER) {          if (oidlen <= 2 ||
                 if (!ssh_gssapi_check_oid(gssctxt, oidv, oidlen))              oidv[0] != SSH_GSS_OIDTYPE ||
                         fatal("Server returned different OID than expected");              oidv[1] != oidlen - 2) {
         } else {                  xfree(oidv);
                 if(oidv[0] != SSH_GSS_OIDTYPE || oidv[1] != oidlen-2) {                  debug("Badly encoded mechanism OID received");
                         debug("Badly encoded mechanism OID received");                  userauth(authctxt, NULL);
                         userauth(authctxt, NULL);                  return;
                         xfree(oidv);  
                         return;  
                 }  
                 if (!ssh_gssapi_check_oid(gssctxt, oidv+2, oidlen-2))  
                         fatal("Server returned different OID than expected");  
         }          }
   
           if (!ssh_gssapi_check_oid(gssctxt, oidv + 2, oidlen - 2))
                   fatal("Server returned different OID than expected");
   
         packet_check_eom();          packet_check_eom();
   
         xfree(oidv);          xfree(oidv);
   
         status = ssh_gssapi_init_ctx(gssctxt, options.gss_deleg_creds,          if (GSS_ERROR(process_gssapi_token(ctxt, GSS_C_NO_BUFFER))) {
             GSS_C_NO_BUFFER, &send_tok, NULL);  
         if (GSS_ERROR(status)) {  
                 if (send_tok.length > 0) {  
                         packet_start(SSH2_MSG_USERAUTH_GSSAPI_ERRTOK);  
                         packet_put_string(send_tok.value, send_tok.length);  
                         packet_send();  
                         gss_release_buffer(&ms, &send_tok);  
                 }  
                 /* Start again with next method on list */                  /* Start again with next method on list */
                 debug("Trying to start again");                  debug("Trying to start again");
                 userauth(authctxt, NULL);                  userauth(authctxt, NULL);
                 return;                  return;
         }          }
   
         /* We must have data to send */  
         packet_start(SSH2_MSG_USERAUTH_GSSAPI_TOKEN);  
         packet_put_string(send_tok.value, send_tok.length);  
         packet_send();  
         gss_release_buffer(&ms, &send_tok);  
 }  }
   
 void  void
 input_gssapi_token(int type, u_int32_t plen, void *ctxt)  input_gssapi_token(int type, u_int32_t plen, void *ctxt)
 {  {
         Authctxt *authctxt = ctxt;          Authctxt *authctxt = ctxt;
         Gssctxt *gssctxt;  
         gss_buffer_desc send_tok = GSS_C_EMPTY_BUFFER;  
         gss_buffer_desc recv_tok;          gss_buffer_desc recv_tok;
         OM_uint32 status, ms;          OM_uint32 status;
         u_int slen;          u_int slen;
   
         if (authctxt == NULL)          if (authctxt == NULL)
                 fatal("input_gssapi_response: no authentication context");                  fatal("input_gssapi_response: no authentication context");
         gssctxt = authctxt->methoddata;  
   
         recv_tok.value = packet_get_string(&slen);          recv_tok.value = packet_get_string(&slen);
         recv_tok.length = slen; /* safe typecast */          recv_tok.length = slen; /* safe typecast */
   
         packet_check_eom();          packet_check_eom();
   
         status=ssh_gssapi_init_ctx(gssctxt, options.gss_deleg_creds,          status = process_gssapi_token(ctxt, &recv_tok);
             &recv_tok, &send_tok, NULL);  
   
         xfree(recv_tok.value);          xfree(recv_tok.value);
   
         if (GSS_ERROR(status)) {          if (GSS_ERROR(status)) {
                 if (send_tok.length > 0) {  
                         packet_start(SSH2_MSG_USERAUTH_GSSAPI_ERRTOK);  
                         packet_put_string(send_tok.value, send_tok.length);  
                         packet_send();  
                         gss_release_buffer(&ms, &send_tok);  
                 }  
                 /* Start again with the next method in the list */                  /* Start again with the next method in the list */
                 userauth(authctxt, NULL);                  userauth(authctxt, NULL);
                 return;                  return;
         }          }
   
         if (send_tok.length > 0) {  
                 packet_start(SSH2_MSG_USERAUTH_GSSAPI_TOKEN);  
                 packet_put_string(send_tok.value, send_tok.length);  
                 packet_send();  
                 gss_release_buffer(&ms, &send_tok);  
         }  
   
         if (status == GSS_S_COMPLETE) {  
                 /* If that succeeded, send a exchange complete message */  
                 packet_start(SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE);  
                 packet_send();  
         }  
 }  }
   
 void  void
Line 1014 
Line 1032 
                     key = ssh_get_next_identity(ac, &comment, 2)) {                      key = ssh_get_next_identity(ac, &comment, 2)) {
                         found = 0;                          found = 0;
                         TAILQ_FOREACH(id, &files, next) {                          TAILQ_FOREACH(id, &files, next) {
                                 /* agent keys from the config file are preferred */                                  /* agent keys from the config file are preferred */
                                 if (key_equal(key, id->key)) {                                  if (key_equal(key, id->key)) {
                                         key_free(key);                                          key_free(key);
                                         xfree(comment);                                          xfree(comment);
Line 1025 
Line 1043 
                                         break;                                          break;
                                 }                                  }
                         }                          }
                         if (!found) {                          if (!found && !options.identities_only) {
                                 id = xmalloc(sizeof(*id));                                  id = xmalloc(sizeof(*id));
                                 memset(id, 0, sizeof(*id));                                  memset(id, 0, sizeof(*id));
                                 id->key = key;                                  id->key = key;
Line 1078 
Line 1096 
         while ((id = TAILQ_FIRST(&authctxt->keys))) {          while ((id = TAILQ_FIRST(&authctxt->keys))) {
                 if (id->tried++)                  if (id->tried++)
                         return (0);                          return (0);
                   /* move key to the end of the queue */
                 TAILQ_REMOVE(&authctxt->keys, id, next);                  TAILQ_REMOVE(&authctxt->keys, id, next);
                 TAILQ_INSERT_TAIL(&authctxt->keys, id, next);                  TAILQ_INSERT_TAIL(&authctxt->keys, id, next);
                 /*                  /*
Line 1242 
Line 1261 
         buffer_init(&b);          buffer_init(&b);
         buffer_put_int(&b, packet_get_connection_in()); /* send # of socket */          buffer_put_int(&b, packet_get_connection_in()); /* send # of socket */
         buffer_put_string(&b, data, datalen);          buffer_put_string(&b, data, datalen);
         ssh_msg_send(to[1], version, &b);          if (ssh_msg_send(to[1], version, &b) == -1)
                   fatal("ssh_keysign: couldn't send request");
   
         if (ssh_msg_recv(from[0], &b) < 0) {          if (ssh_msg_recv(from[0], &b) < 0) {
                 error("ssh_keysign: no reply");                  error("ssh_keysign: no reply");
                 buffer_clear(&b);                  buffer_free(&b);
                 return -1;                  return -1;
         }          }
         close(from[0]);          close(from[0]);
Line 1258 
Line 1278 
   
         if (buffer_get_char(&b) != version) {          if (buffer_get_char(&b) != version) {
                 error("ssh_keysign: bad version");                  error("ssh_keysign: bad version");
                 buffer_clear(&b);                  buffer_free(&b);
                 return -1;                  return -1;
         }          }
         *sigp = buffer_get_string(&b, lenp);          *sigp = buffer_get_string(&b, lenp);
         buffer_clear(&b);          buffer_free(&b);
   
         return 0;          return 0;
 }  }
Legend:
Removed from v.1.124  
changed lines
  Added in v.1.124.2.2