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

Diff for /src/usr.bin/ssh/ssh-agent.c between version 1.85 and 1.85.2.3

version 1.85, 2002/04/02 11:49:39 version 1.85.2.3, 2003/04/03 22:35:17
Line 50 
Line 50 
 #include "authfd.h"  #include "authfd.h"
 #include "compat.h"  #include "compat.h"
 #include "log.h"  #include "log.h"
   #include "readpass.h"
   #include "misc.h"
   
 #ifdef SMARTCARD  #ifdef SMARTCARD
 #include "scard.h"  #include "scard.h"
Line 66 
Line 68 
         sock_type type;          sock_type type;
         Buffer input;          Buffer input;
         Buffer output;          Buffer output;
           Buffer request;
 } SocketEntry;  } SocketEntry;
   
 u_int sockets_alloc = 0;  u_int sockets_alloc = 0;
Line 75 
Line 78 
         TAILQ_ENTRY(identity) next;          TAILQ_ENTRY(identity) next;
         Key *key;          Key *key;
         char *comment;          char *comment;
           u_int death;
           u_int confirm;
 } Identity;  } Identity;
   
 typedef struct {  typedef struct {
Line 94 
Line 99 
 char socket_name[1024];  char socket_name[1024];
 char socket_dir[1024];  char socket_dir[1024];
   
   /* locking */
   int locked = 0;
   char *lock_passwd = NULL;
   
 extern char *__progname;  extern char *__progname;
   
   /* Default lifetime (0 == forever) */
   static int lifetime = 0;
   
 static void  static void
   close_socket(SocketEntry *e)
   {
           close(e->fd);
           e->fd = -1;
           e->type = AUTH_UNUSED;
           buffer_free(&e->input);
           buffer_free(&e->output);
           buffer_free(&e->request);
   }
   
   static void
 idtab_init(void)  idtab_init(void)
 {  {
         int i;          int i;
   
         for (i = 0; i <=2; i++) {          for (i = 0; i <=2; i++) {
                 TAILQ_INIT(&idtable[i].idlist);                  TAILQ_INIT(&idtable[i].idlist);
                 idtable[i].nentries = 0;                  idtable[i].nentries = 0;
Line 115 
Line 139 
         return &idtable[version];          return &idtable[version];
 }  }
   
   static void
   free_identity(Identity *id)
   {
           key_free(id->key);
           xfree(id->comment);
           xfree(id);
   }
   
 /* return matching private key for given public key */  /* return matching private key for given public key */
 static Identity *  static Identity *
 lookup_identity(Key *key, int version)  lookup_identity(Key *key, int version)
Line 129 
Line 161 
         return (NULL);          return (NULL);
 }  }
   
 static void  /* Check confirmation of keysign request */
 free_identity(Identity *id)  static int
   confirm_key(Identity *id)
 {  {
         key_free(id->key);          char *p, prompt[1024];
         xfree(id->comment);          int ret = -1;
         xfree(id);  
           p = key_fingerprint(id->key, SSH_FP_MD5, SSH_FP_HEX);
           snprintf(prompt, sizeof(prompt), "Allow use of key %s?\n"
               "Key fingerprint %s.", id->comment, p);
           xfree(p);
           p = read_passphrase(prompt, RP_ALLOW_EOF);
           if (p != NULL) {
                   /*
                    * Accept empty responses and responses consisting
                    * of the word "yes" as affirmative.
                    */
                   if (*p == '\0' || *p == '\n' || strcasecmp(p, "yes") == 0)
                           ret = 0;
                   xfree(p);
           }
           return (ret);
 }  }
   
 /* send list of supported public keys to 'client' */  /* send list of supported public keys to 'client' */
Line 142 
Line 190 
 process_request_identities(SocketEntry *e, int version)  process_request_identities(SocketEntry *e, int version)
 {  {
         Idtab *tab = idtab_lookup(version);          Idtab *tab = idtab_lookup(version);
         Buffer msg;  
         Identity *id;          Identity *id;
           Buffer msg;
   
         buffer_init(&msg);          buffer_init(&msg);
         buffer_put_char(&msg, (version == 1) ?          buffer_put_char(&msg, (version == 1) ?
Line 172 
Line 220 
 static void  static void
 process_authentication_challenge1(SocketEntry *e)  process_authentication_challenge1(SocketEntry *e)
 {  {
         Identity *id;          u_char buf[32], mdbuf[16], session_id[16];
         Key *key;          u_int response_type;
         BIGNUM *challenge;          BIGNUM *challenge;
           Identity *id;
         int i, len;          int i, len;
         Buffer msg;          Buffer msg;
         MD5_CTX md;          MD5_CTX md;
         u_char buf[32], mdbuf[16], session_id[16];          Key *key;
         u_int response_type;  
   
         buffer_init(&msg);          buffer_init(&msg);
         key = key_new(KEY_RSA1);          key = key_new(KEY_RSA1);
         if ((challenge = BN_new()) == NULL)          if ((challenge = BN_new()) == NULL)
                 fatal("process_authentication_challenge1: BN_new failed");                  fatal("process_authentication_challenge1: BN_new failed");
   
         buffer_get_int(&e->input);                              /* ignored */          (void) buffer_get_int(&e->request);                     /* ignored */
         buffer_get_bignum(&e->input, key->rsa->e);          buffer_get_bignum(&e->request, key->rsa->e);
         buffer_get_bignum(&e->input, key->rsa->n);          buffer_get_bignum(&e->request, key->rsa->n);
         buffer_get_bignum(&e->input, challenge);          buffer_get_bignum(&e->request, challenge);
   
         /* Only protocol 1.1 is supported */          /* Only protocol 1.1 is supported */
         if (buffer_len(&e->input) == 0)          if (buffer_len(&e->request) == 0)
                 goto failure;                  goto failure;
         buffer_get(&e->input, session_id, 16);          buffer_get(&e->request, session_id, 16);
         response_type = buffer_get_int(&e->input);          response_type = buffer_get_int(&e->request);
         if (response_type != 1)          if (response_type != 1)
                 goto failure;                  goto failure;
   
         id = lookup_identity(key, 1);          id = lookup_identity(key, 1);
         if (id != NULL) {          if (id != NULL && (!id->confirm || confirm_key(id) == 0)) {
                 Key *private = id->key;                  Key *private = id->key;
                 /* Decrypt the challenge using the private key. */                  /* Decrypt the challenge using the private key. */
                 if (rsa_private_decrypt(challenge, challenge, private->rsa) <= 0)                  if (rsa_private_decrypt(challenge, challenge, private->rsa) <= 0)
Line 241 
Line 289 
 static void  static void
 process_sign_request2(SocketEntry *e)  process_sign_request2(SocketEntry *e)
 {  {
         extern int datafellows;  
         Key *key;  
         u_char *blob, *data, *signature = NULL;          u_char *blob, *data, *signature = NULL;
         u_int blen, dlen, slen = 0;          u_int blen, dlen, slen = 0;
         int flags;          extern int datafellows;
           int ok = -1, flags;
         Buffer msg;          Buffer msg;
         int ok = -1;          Key *key;
   
         datafellows = 0;          datafellows = 0;
   
         blob = buffer_get_string(&e->input, &blen);          blob = buffer_get_string(&e->request, &blen);
         data = buffer_get_string(&e->input, &dlen);          data = buffer_get_string(&e->request, &dlen);
   
         flags = buffer_get_int(&e->input);          flags = buffer_get_int(&e->request);
         if (flags & SSH_AGENT_OLD_SIGNATURE)          if (flags & SSH_AGENT_OLD_SIGNATURE)
                 datafellows = SSH_BUG_SIGBLOB;                  datafellows = SSH_BUG_SIGBLOB;
   
         key = key_from_blob(blob, blen);          key = key_from_blob(blob, blen);
         if (key != NULL) {          if (key != NULL) {
                 Identity *id = lookup_identity(key, 2);                  Identity *id = lookup_identity(key, 2);
                 if (id != NULL)                  if (id != NULL && (!id->confirm || confirm_key(id) == 0))
                         ok = key_sign(id->key, &signature, &slen, data, dlen);                          ok = key_sign(id->key, &signature, &slen, data, dlen);
         }          }
         key_free(key);          key_free(key);
Line 286 
Line 333 
 static void  static void
 process_remove_identity(SocketEntry *e, int version)  process_remove_identity(SocketEntry *e, int version)
 {  {
           u_int blen, bits;
           int success = 0;
         Key *key = NULL;          Key *key = NULL;
         u_char *blob;          u_char *blob;
         u_int blen;  
         u_int bits;  
         int success = 0;  
   
         switch (version) {          switch (version) {
         case 1:          case 1:
                 key = key_new(KEY_RSA1);                  key = key_new(KEY_RSA1);
                 bits = buffer_get_int(&e->input);                  bits = buffer_get_int(&e->request);
                 buffer_get_bignum(&e->input, key->rsa->e);                  buffer_get_bignum(&e->request, key->rsa->e);
                 buffer_get_bignum(&e->input, key->rsa->n);                  buffer_get_bignum(&e->request, key->rsa->n);
   
                 if (bits != key_size(key))                  if (bits != key_size(key))
                         log("Warning: identity keysize mismatch: actual %d, announced %d",                          log("Warning: identity keysize mismatch: actual %u, announced %u",
                             key_size(key), bits);                              key_size(key), bits);
                 break;                  break;
         case 2:          case 2:
                 blob = buffer_get_string(&e->input, &blen);                  blob = buffer_get_string(&e->request, &blen);
                 key = key_from_blob(blob, blen);                  key = key_from_blob(blob, blen);
                 xfree(blob);                  xfree(blob);
                 break;                  break;
Line 355 
Line 401 
         /* Send success. */          /* Send success. */
         buffer_put_int(&e->output, 1);          buffer_put_int(&e->output, 1);
         buffer_put_char(&e->output, SSH_AGENT_SUCCESS);          buffer_put_char(&e->output, SSH_AGENT_SUCCESS);
         return;  
 }  }
   
 static void  static void
   reaper(void)
   {
           u_int now = time(NULL);
           Identity *id, *nxt;
           int version;
           Idtab *tab;
   
           for (version = 1; version < 3; version++) {
                   tab = idtab_lookup(version);
                   for (id = TAILQ_FIRST(&tab->idlist); id; id = nxt) {
                           nxt = TAILQ_NEXT(id, next);
                           if (id->death != 0 && now >= id->death) {
                                   TAILQ_REMOVE(&tab->idlist, id, next);
                                   free_identity(id);
                                   tab->nentries--;
                           }
                   }
           }
   }
   
   static void
 process_add_identity(SocketEntry *e, int version)  process_add_identity(SocketEntry *e, int version)
 {  {
         Key *k = NULL;  
         char *type_name;  
         char *comment;  
         int type, success = 0;  
         Idtab *tab = idtab_lookup(version);          Idtab *tab = idtab_lookup(version);
           int type, success = 0, death = 0, confirm = 0;
           char *type_name, *comment;
           Key *k = NULL;
   
         switch (version) {          switch (version) {
         case 1:          case 1:
                 k = key_new_private(KEY_RSA1);                  k = key_new_private(KEY_RSA1);
                 buffer_get_int(&e->input);                      /* ignored */                  (void) buffer_get_int(&e->request);             /* ignored */
                 buffer_get_bignum(&e->input, k->rsa->n);                  buffer_get_bignum(&e->request, k->rsa->n);
                 buffer_get_bignum(&e->input, k->rsa->e);                  buffer_get_bignum(&e->request, k->rsa->e);
                 buffer_get_bignum(&e->input, k->rsa->d);                  buffer_get_bignum(&e->request, k->rsa->d);
                 buffer_get_bignum(&e->input, k->rsa->iqmp);                  buffer_get_bignum(&e->request, k->rsa->iqmp);
   
                 /* SSH and SSL have p and q swapped */                  /* SSH and SSL have p and q swapped */
                 buffer_get_bignum(&e->input, k->rsa->q);        /* p */                  buffer_get_bignum(&e->request, k->rsa->q);      /* p */
                 buffer_get_bignum(&e->input, k->rsa->p);        /* q */                  buffer_get_bignum(&e->request, k->rsa->p);      /* q */
   
                 /* Generate additional parameters */                  /* Generate additional parameters */
                 rsa_generate_additional_parameters(k->rsa);                  rsa_generate_additional_parameters(k->rsa);
                 break;                  break;
         case 2:          case 2:
                 type_name = buffer_get_string(&e->input, NULL);                  type_name = buffer_get_string(&e->request, NULL);
                 type = key_type_from_name(type_name);                  type = key_type_from_name(type_name);
                 xfree(type_name);                  xfree(type_name);
                 switch (type) {                  switch (type) {
                 case KEY_DSA:                  case KEY_DSA:
                         k = key_new_private(type);                          k = key_new_private(type);
                         buffer_get_bignum2(&e->input, k->dsa->p);                          buffer_get_bignum2(&e->request, k->dsa->p);
                         buffer_get_bignum2(&e->input, k->dsa->q);                          buffer_get_bignum2(&e->request, k->dsa->q);
                         buffer_get_bignum2(&e->input, k->dsa->g);                          buffer_get_bignum2(&e->request, k->dsa->g);
                         buffer_get_bignum2(&e->input, k->dsa->pub_key);                          buffer_get_bignum2(&e->request, k->dsa->pub_key);
                         buffer_get_bignum2(&e->input, k->dsa->priv_key);                          buffer_get_bignum2(&e->request, k->dsa->priv_key);
                         break;                          break;
                 case KEY_RSA:                  case KEY_RSA:
                         k = key_new_private(type);                          k = key_new_private(type);
                         buffer_get_bignum2(&e->input, k->rsa->n);                          buffer_get_bignum2(&e->request, k->rsa->n);
                         buffer_get_bignum2(&e->input, k->rsa->e);                          buffer_get_bignum2(&e->request, k->rsa->e);
                         buffer_get_bignum2(&e->input, k->rsa->d);                          buffer_get_bignum2(&e->request, k->rsa->d);
                         buffer_get_bignum2(&e->input, k->rsa->iqmp);                          buffer_get_bignum2(&e->request, k->rsa->iqmp);
                         buffer_get_bignum2(&e->input, k->rsa->p);                          buffer_get_bignum2(&e->request, k->rsa->p);
                         buffer_get_bignum2(&e->input, k->rsa->q);                          buffer_get_bignum2(&e->request, k->rsa->q);
   
                         /* Generate additional parameters */                          /* Generate additional parameters */
                         rsa_generate_additional_parameters(k->rsa);                          rsa_generate_additional_parameters(k->rsa);
                         break;                          break;
                 default:                  default:
                         buffer_clear(&e->input);                          buffer_clear(&e->request);
                         goto send;                          goto send;
                 }                  }
                 break;                  break;
         }          }
         comment = buffer_get_string(&e->input, NULL);          /* enable blinding */
           switch (k->type) {
           case KEY_RSA:
           case KEY_RSA1:
                   if (RSA_blinding_on(k->rsa, NULL) != 1) {
                           error("process_add_identity: RSA_blinding_on failed");
                           key_free(k);
                           goto send;
                   }
                   break;
           }
           comment = buffer_get_string(&e->request, NULL);
         if (k == NULL) {          if (k == NULL) {
                 xfree(comment);                  xfree(comment);
                 goto send;                  goto send;
         }          }
         success = 1;          success = 1;
           while (buffer_len(&e->request)) {
                   switch (buffer_get_char(&e->request)) {
                   case SSH_AGENT_CONSTRAIN_LIFETIME:
                           death = time(NULL) + buffer_get_int(&e->request);
                           break;
                   case SSH_AGENT_CONSTRAIN_CONFIRM:
                           confirm = 1;
                           break;
                   default:
                           break;
                   }
           }
           if (lifetime && !death)
                   death = time(NULL) + lifetime;
         if (lookup_identity(k, version) == NULL) {          if (lookup_identity(k, version) == NULL) {
                 Identity *id = xmalloc(sizeof(Identity));                  Identity *id = xmalloc(sizeof(Identity));
                 id->key = k;                  id->key = k;
                 id->comment = comment;                  id->comment = comment;
                   id->death = death;
                   id->confirm = confirm;
                 TAILQ_INSERT_TAIL(&tab->idlist, id, next);                  TAILQ_INSERT_TAIL(&tab->idlist, id, next);
                 /* Increment the number of identities. */                  /* Increment the number of identities. */
                 tab->nentries++;                  tab->nentries++;
Line 437 
Line 529 
             success ? SSH_AGENT_SUCCESS : SSH_AGENT_FAILURE);              success ? SSH_AGENT_SUCCESS : SSH_AGENT_FAILURE);
 }  }
   
   /* XXX todo: encrypt sensitive data with passphrase */
   static void
   process_lock_agent(SocketEntry *e, int lock)
   {
           int success = 0;
           char *passwd;
   
           passwd = buffer_get_string(&e->request, NULL);
           if (locked && !lock && strcmp(passwd, lock_passwd) == 0) {
                   locked = 0;
                   memset(lock_passwd, 0, strlen(lock_passwd));
                   xfree(lock_passwd);
                   lock_passwd = NULL;
                   success = 1;
           } else if (!locked && lock) {
                   locked = 1;
                   lock_passwd = xstrdup(passwd);
                   success = 1;
           }
           memset(passwd, 0, strlen(passwd));
           xfree(passwd);
   
           buffer_put_int(&e->output, 1);
           buffer_put_char(&e->output,
               success ? SSH_AGENT_SUCCESS : SSH_AGENT_FAILURE);
   }
   
   static void
   no_identities(SocketEntry *e, u_int type)
   {
           Buffer msg;
   
           buffer_init(&msg);
           buffer_put_char(&msg,
               (type == SSH_AGENTC_REQUEST_RSA_IDENTITIES) ?
               SSH_AGENT_RSA_IDENTITIES_ANSWER : SSH2_AGENT_IDENTITIES_ANSWER);
           buffer_put_int(&msg, 0);
           buffer_put_int(&e->output, buffer_len(&msg));
           buffer_append(&e->output, buffer_ptr(&msg), buffer_len(&msg));
           buffer_free(&msg);
   }
   
 #ifdef SMARTCARD  #ifdef SMARTCARD
 static void  static void
 process_add_smartcard_key (SocketEntry *e)  process_add_smartcard_key (SocketEntry *e)
 {  {
         Identity *id;  
         Idtab *tab;  
         Key **keys, *k;  
         char *sc_reader_id = NULL, *pin;          char *sc_reader_id = NULL, *pin;
         int i, version, success = 0;          int i, version, success = 0;
           Key **keys, *k;
           Identity *id;
           Idtab *tab;
   
         sc_reader_id = buffer_get_string(&e->input, NULL);          sc_reader_id = buffer_get_string(&e->request, NULL);
         pin = buffer_get_string(&e->input, NULL);          pin = buffer_get_string(&e->request, NULL);
         keys = sc_get_keys(sc_reader_id, pin);          keys = sc_get_keys(sc_reader_id, pin);
         xfree(sc_reader_id);          xfree(sc_reader_id);
         xfree(pin);          xfree(pin);
Line 466 
Line 599 
                         id = xmalloc(sizeof(Identity));                          id = xmalloc(sizeof(Identity));
                         id->key = k;                          id->key = k;
                         id->comment = xstrdup("smartcard key");                          id->comment = xstrdup("smartcard key");
                           id->death = 0;
                           id->confirm = 0;
                         TAILQ_INSERT_TAIL(&tab->idlist, id, next);                          TAILQ_INSERT_TAIL(&tab->idlist, id, next);
                         tab->nentries++;                          tab->nentries++;
                         success = 1;                          success = 1;
Line 484 
Line 619 
 static void  static void
 process_remove_smartcard_key(SocketEntry *e)  process_remove_smartcard_key(SocketEntry *e)
 {  {
         Identity *id;  
         Idtab *tab;  
         Key **keys, *k = NULL;  
         char *sc_reader_id = NULL, *pin;          char *sc_reader_id = NULL, *pin;
         int i, version, success = 0;          int i, version, success = 0;
           Key **keys, *k = NULL;
           Identity *id;
           Idtab *tab;
   
         sc_reader_id = buffer_get_string(&e->input, NULL);          sc_reader_id = buffer_get_string(&e->request, NULL);
         pin = buffer_get_string(&e->input, NULL);          pin = buffer_get_string(&e->request, NULL);
         keys = sc_get_keys(sc_reader_id, pin);          keys = sc_get_keys(sc_reader_id, pin);
         xfree(sc_reader_id);          xfree(sc_reader_id);
         xfree(pin);          xfree(pin);
Line 505 
Line 640 
                 version = k->type == KEY_RSA1 ? 1 : 2;                  version = k->type == KEY_RSA1 ? 1 : 2;
                 if ((id = lookup_identity(k, version)) != NULL) {                  if ((id = lookup_identity(k, version)) != NULL) {
                         tab = idtab_lookup(version);                          tab = idtab_lookup(version);
                         TAILQ_REMOVE(&tab->idlist, id, next);                          TAILQ_REMOVE(&tab->idlist, id, next);
                         tab->nentries--;                          tab->nentries--;
                         free_identity(id);                          free_identity(id);
                         success = 1;                          success = 1;
Line 526 
Line 661 
 static void  static void
 process_message(SocketEntry *e)  process_message(SocketEntry *e)
 {  {
         u_int msg_len;          u_int msg_len, type;
         u_int type;  
         u_char *cp;          u_char *cp;
   
           /* kill dead keys */
           reaper();
   
         if (buffer_len(&e->input) < 5)          if (buffer_len(&e->input) < 5)
                 return;         /* Incomplete message. */                  return;         /* Incomplete message. */
         cp = buffer_ptr(&e->input);          cp = buffer_ptr(&e->input);
         msg_len = GET_32BIT(cp);          msg_len = GET_32BIT(cp);
         if (msg_len > 256 * 1024) {          if (msg_len > 256 * 1024) {
                 shutdown(e->fd, SHUT_RDWR);                  close_socket(e);
                 close(e->fd);  
                 e->type = AUTH_UNUSED;  
                 return;                  return;
         }          }
         if (buffer_len(&e->input) < msg_len + 4)          if (buffer_len(&e->input) < msg_len + 4)
                 return;                  return;
   
           /* move the current input to e->request */
         buffer_consume(&e->input, 4);          buffer_consume(&e->input, 4);
         type = buffer_get_char(&e->input);          buffer_clear(&e->request);
           buffer_append(&e->request, buffer_ptr(&e->input), msg_len);
           buffer_consume(&e->input, msg_len);
           type = buffer_get_char(&e->request);
   
           /* check wheter agent is locked */
           if (locked && type != SSH_AGENTC_UNLOCK) {
                   buffer_clear(&e->request);
                   switch (type) {
                   case SSH_AGENTC_REQUEST_RSA_IDENTITIES:
                   case SSH2_AGENTC_REQUEST_IDENTITIES:
                           /* send empty lists */
                           no_identities(e, type);
                           break;
                   default:
                           /* send a fail message for all other request types */
                           buffer_put_int(&e->output, 1);
                           buffer_put_char(&e->output, SSH_AGENT_FAILURE);
                   }
                   return;
           }
   
         debug("type %d", type);          debug("type %d", type);
         switch (type) {          switch (type) {
           case SSH_AGENTC_LOCK:
           case SSH_AGENTC_UNLOCK:
                   process_lock_agent(e, type == SSH_AGENTC_LOCK);
                   break;
         /* ssh1 */          /* ssh1 */
         case SSH_AGENTC_RSA_CHALLENGE:          case SSH_AGENTC_RSA_CHALLENGE:
                 process_authentication_challenge1(e);                  process_authentication_challenge1(e);
Line 554 
Line 716 
                 process_request_identities(e, 1);                  process_request_identities(e, 1);
                 break;                  break;
         case SSH_AGENTC_ADD_RSA_IDENTITY:          case SSH_AGENTC_ADD_RSA_IDENTITY:
           case SSH_AGENTC_ADD_RSA_ID_CONSTRAINED:
                 process_add_identity(e, 1);                  process_add_identity(e, 1);
                 break;                  break;
         case SSH_AGENTC_REMOVE_RSA_IDENTITY:          case SSH_AGENTC_REMOVE_RSA_IDENTITY:
Line 570 
Line 733 
                 process_request_identities(e, 2);                  process_request_identities(e, 2);
                 break;                  break;
         case SSH2_AGENTC_ADD_IDENTITY:          case SSH2_AGENTC_ADD_IDENTITY:
           case SSH2_AGENTC_ADD_ID_CONSTRAINED:
                 process_add_identity(e, 2);                  process_add_identity(e, 2);
                 break;                  break;
         case SSH2_AGENTC_REMOVE_IDENTITY:          case SSH2_AGENTC_REMOVE_IDENTITY:
Line 589 
Line 753 
         default:          default:
                 /* Unknown message.  Respond with failure. */                  /* Unknown message.  Respond with failure. */
                 error("Unknown message %d", type);                  error("Unknown message %d", type);
                 buffer_clear(&e->input);                  buffer_clear(&e->request);
                 buffer_put_int(&e->output, 1);                  buffer_put_int(&e->output, 1);
                 buffer_put_char(&e->output, SSH_AGENT_FAILURE);                  buffer_put_char(&e->output, SSH_AGENT_FAILURE);
                 break;                  break;
Line 600 
Line 764 
 new_socket(sock_type type, int fd)  new_socket(sock_type type, int fd)
 {  {
         u_int i, old_alloc;          u_int i, old_alloc;
   
         if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)          if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
                 error("fcntl O_NONBLOCK: %s", strerror(errno));                  error("fcntl O_NONBLOCK: %s", strerror(errno));
   
Line 612 
Line 777 
                         sockets[i].type = type;                          sockets[i].type = type;
                         buffer_init(&sockets[i].input);                          buffer_init(&sockets[i].input);
                         buffer_init(&sockets[i].output);                          buffer_init(&sockets[i].output);
                           buffer_init(&sockets[i].request);
                         return;                          return;
                 }                  }
         old_alloc = sockets_alloc;          old_alloc = sockets_alloc;
Line 626 
Line 792 
         sockets[old_alloc].fd = fd;          sockets[old_alloc].fd = fd;
         buffer_init(&sockets[old_alloc].input);          buffer_init(&sockets[old_alloc].input);
         buffer_init(&sockets[old_alloc].output);          buffer_init(&sockets[old_alloc].output);
           buffer_init(&sockets[old_alloc].request);
 }  }
   
 static int  static int
Line 682 
Line 849 
 static void  static void
 after_select(fd_set *readset, fd_set *writeset)  after_select(fd_set *readset, fd_set *writeset)
 {  {
         u_int i;          struct sockaddr_un sunaddr;
         int len, sock;  
         socklen_t slen;          socklen_t slen;
         char buf[1024];          char buf[1024];
         struct sockaddr_un sunaddr;          int len, sock;
           u_int i;
           uid_t euid;
           gid_t egid;
   
         for (i = 0; i < sockets_alloc; i++)          for (i = 0; i < sockets_alloc; i++)
                 switch (sockets[i].type) {                  switch (sockets[i].type) {
Line 702 
Line 871 
                                             strerror(errno));                                              strerror(errno));
                                         break;                                          break;
                                 }                                  }
                                   if (getpeereid(sock, &euid, &egid) < 0) {
                                           error("getpeereid %d failed: %s",
                                               sock, strerror(errno));
                                           close(sock);
                                           break;
                                   }
                                   if ((euid != 0) && (getuid() != euid)) {
                                           error("uid mismatch: "
                                               "peer euid %u != uid %u",
                                               (u_int) euid, (u_int) getuid());
                                           close(sock);
                                           break;
                                   }
                                 new_socket(AUTH_CONNECTION, sock);                                  new_socket(AUTH_CONNECTION, sock);
                         }                          }
                         break;                          break;
Line 718 
Line 900 
                                         break;                                          break;
                                 } while (1);                                  } while (1);
                                 if (len <= 0) {                                  if (len <= 0) {
                                         shutdown(sockets[i].fd, SHUT_RDWR);                                          close_socket(&sockets[i]);
                                         close(sockets[i].fd);  
                                         sockets[i].type = AUTH_UNUSED;  
                                         buffer_free(&sockets[i].input);  
                                         buffer_free(&sockets[i].output);  
                                         break;                                          break;
                                 }                                  }
                                 buffer_consume(&sockets[i].output, len);                                  buffer_consume(&sockets[i].output, len);
Line 736 
Line 914 
                                         break;                                          break;
                                 } while (1);                                  } while (1);
                                 if (len <= 0) {                                  if (len <= 0) {
                                         shutdown(sockets[i].fd, SHUT_RDWR);                                          close_socket(&sockets[i]);
                                         close(sockets[i].fd);  
                                         sockets[i].type = AUTH_UNUSED;  
                                         buffer_free(&sockets[i].input);  
                                         buffer_free(&sockets[i].output);  
                                         break;                                          break;
                                 }                                  }
                                 buffer_append(&sockets[i].input, buf, len);                                  buffer_append(&sockets[i].input, buf, len);
Line 799 
Line 973 
         fprintf(stderr, "  -s          Generate Bourne shell commands on stdout.\n");          fprintf(stderr, "  -s          Generate Bourne shell commands on stdout.\n");
         fprintf(stderr, "  -k          Kill the current agent.\n");          fprintf(stderr, "  -k          Kill the current agent.\n");
         fprintf(stderr, "  -d          Debug mode.\n");          fprintf(stderr, "  -d          Debug mode.\n");
           fprintf(stderr, "  -a socket   Bind agent socket to given name.\n");
           fprintf(stderr, "  -t life     Default identity lifetime (seconds).\n");
         exit(1);          exit(1);
 }  }
   
 int  int
 main(int ac, char **av)  main(int ac, char **av)
 {  {
         int sock, c_flag = 0, d_flag = 0, k_flag = 0, s_flag = 0, ch, nalloc;          int c_flag = 0, d_flag = 0, k_flag = 0, s_flag = 0;
           int sock, fd,  ch, nalloc;
           char *shell, *format, *pidstr, *agentsocket = NULL;
           fd_set *readsetp = NULL, *writesetp = NULL;
         struct sockaddr_un sunaddr;          struct sockaddr_un sunaddr;
         struct rlimit rlim;          struct rlimit rlim;
         pid_t pid;  
         char *shell, *format, *pidstr, pidstrbuf[1 + 3 * sizeof pid];  
         extern int optind;          extern int optind;
         fd_set *readsetp = NULL, *writesetp = NULL;          extern char *optarg;
           pid_t pid;
           char pidstrbuf[1 + 3 * sizeof pid];
   
           /* drop */
           setegid(getgid());
           setgid(getgid());
   
         SSLeay_add_all_algorithms();          SSLeay_add_all_algorithms();
   
         while ((ch = getopt(ac, av, "cdks")) != -1) {          while ((ch = getopt(ac, av, "cdksa:t:")) != -1) {
                 switch (ch) {                  switch (ch) {
                 case 'c':                  case 'c':
                         if (s_flag)                          if (s_flag)
Line 835 
Line 1018 
                                 usage();                                  usage();
                         d_flag++;                          d_flag++;
                         break;                          break;
                   case 'a':
                           agentsocket = optarg;
                           break;
                   case 't':
                           if ((lifetime = convtime(optarg)) == -1) {
                                   fprintf(stderr, "Invalid lifetime\n");
                                   usage();
                           }
                           break;
                 default:                  default:
                         usage();                          usage();
                 }                  }
Line 870 
Line 1062 
                 format = c_flag ? "unsetenv %s;\n" : "unset %s;\n";                  format = c_flag ? "unsetenv %s;\n" : "unset %s;\n";
                 printf(format, SSH_AUTHSOCKET_ENV_NAME);                  printf(format, SSH_AUTHSOCKET_ENV_NAME);
                 printf(format, SSH_AGENTPID_ENV_NAME);                  printf(format, SSH_AGENTPID_ENV_NAME);
                 printf("echo Agent pid %d killed;\n", pid);                  printf("echo Agent pid %ld killed;\n", (long)pid);
                 exit(0);                  exit(0);
         }          }
         parent_pid = getpid();          parent_pid = getpid();
   
         /* Create private directory for agent socket */          if (agentsocket == NULL) {
         strlcpy(socket_dir, "/tmp/ssh-XXXXXXXX", sizeof socket_dir);                  /* Create private directory for agent socket */
         if (mkdtemp(socket_dir) == NULL) {                  strlcpy(socket_dir, "/tmp/ssh-XXXXXXXX", sizeof socket_dir);
                 perror("mkdtemp: private socket dir");                  if (mkdtemp(socket_dir) == NULL) {
                 exit(1);                          perror("mkdtemp: private socket dir");
                           exit(1);
                   }
                   snprintf(socket_name, sizeof socket_name, "%s/agent.%ld", socket_dir,
                       (long)parent_pid);
           } else {
                   /* Try to use specified agent socket */
                   socket_dir[0] = '\0';
                   strlcpy(socket_name, agentsocket, sizeof socket_name);
         }          }
         snprintf(socket_name, sizeof socket_name, "%s/agent.%d", socket_dir,  
             parent_pid);  
   
         /*          /*
          * Create socket early so it will exist before command gets run from           * Create socket early so it will exist before command gets run from
Line 900 
Line 1098 
                 perror("bind");                  perror("bind");
                 cleanup_exit(1);                  cleanup_exit(1);
         }          }
         if (listen(sock, 5) < 0) {          if (listen(sock, 128) < 0) {
                 perror("listen");                  perror("listen");
                 cleanup_exit(1);                  cleanup_exit(1);
         }          }
Line 914 
Line 1112 
                 format = c_flag ? "setenv %s %s;\n" : "%s=%s; export %s;\n";                  format = c_flag ? "setenv %s %s;\n" : "%s=%s; export %s;\n";
                 printf(format, SSH_AUTHSOCKET_ENV_NAME, socket_name,                  printf(format, SSH_AUTHSOCKET_ENV_NAME, socket_name,
                     SSH_AUTHSOCKET_ENV_NAME);                      SSH_AUTHSOCKET_ENV_NAME);
                 printf("echo Agent pid %d;\n", parent_pid);                  printf("echo Agent pid %ld;\n", (long)parent_pid);
                 goto skip;                  goto skip;
         }          }
         pid = fork();          pid = fork();
Line 924 
Line 1122 
         }          }
         if (pid != 0) {         /* Parent - execute the given command. */          if (pid != 0) {         /* Parent - execute the given command. */
                 close(sock);                  close(sock);
                 snprintf(pidstrbuf, sizeof pidstrbuf, "%d", pid);                  snprintf(pidstrbuf, sizeof pidstrbuf, "%ld", (long)pid);
                 if (ac == 0) {                  if (ac == 0) {
                         format = c_flag ? "setenv %s %s;\n" : "%s=%s; export %s;\n";                          format = c_flag ? "setenv %s %s;\n" : "%s=%s; export %s;\n";
                         printf(format, SSH_AUTHSOCKET_ENV_NAME, socket_name,                          printf(format, SSH_AUTHSOCKET_ENV_NAME, socket_name,
                             SSH_AUTHSOCKET_ENV_NAME);                              SSH_AUTHSOCKET_ENV_NAME);
                         printf(format, SSH_AGENTPID_ENV_NAME, pidstrbuf,                          printf(format, SSH_AGENTPID_ENV_NAME, pidstrbuf,
                             SSH_AGENTPID_ENV_NAME);                              SSH_AGENTPID_ENV_NAME);
                         printf("echo Agent pid %d;\n", pid);                          printf("echo Agent pid %ld;\n", (long)pid);
                         exit(0);                          exit(0);
                 }                  }
                 if (setenv(SSH_AUTHSOCKET_ENV_NAME, socket_name, 1) == -1 ||                  if (setenv(SSH_AUTHSOCKET_ENV_NAME, socket_name, 1) == -1 ||
Line 952 
Line 1150 
         }          }
   
         (void)chdir("/");          (void)chdir("/");
         close(0);          if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {
         close(1);                  /* XXX might close listen socket */
         close(2);                  (void)dup2(fd, STDIN_FILENO);
                   (void)dup2(fd, STDOUT_FILENO);
                   (void)dup2(fd, STDERR_FILENO);
                   if (fd > 2)
                           close(fd);
           }
   
         /* deny core dumps, since memory contains unencrypted private keys */          /* deny core dumps, since memory contains unencrypted private keys */
         rlim.rlim_cur = rlim.rlim_max = 0;          rlim.rlim_cur = rlim.rlim_max = 0;
Legend:
Removed from v.1.85  
changed lines
  Added in v.1.85.2.3