[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.2.3 and 1.86

version 1.85.2.3, 2003/04/03 22:35:17 version 1.86, 2002/06/05 16:08:07
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 68 
Line 66 
         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 78 
Line 75 
         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 99 
Line 94 
 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 139 
Line 115 
         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 161 
Line 129 
         return (NULL);          return (NULL);
 }  }
   
 /* Check confirmation of keysign request */  static void
 static int  free_identity(Identity *id)
 confirm_key(Identity *id)  
 {  {
         char *p, prompt[1024];          key_free(id->key);
         int ret = -1;          xfree(id->comment);
           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 190 
Line 142 
 process_request_identities(SocketEntry *e, int version)  process_request_identities(SocketEntry *e, int version)
 {  {
         Idtab *tab = idtab_lookup(version);          Idtab *tab = idtab_lookup(version);
         Identity *id;  
         Buffer msg;          Buffer msg;
           Identity *id;
   
         buffer_init(&msg);          buffer_init(&msg);
         buffer_put_char(&msg, (version == 1) ?          buffer_put_char(&msg, (version == 1) ?
Line 220 
Line 172 
 static void  static void
 process_authentication_challenge1(SocketEntry *e)  process_authentication_challenge1(SocketEntry *e)
 {  {
         u_char buf[32], mdbuf[16], session_id[16];  
         u_int response_type;  
         BIGNUM *challenge;  
         Identity *id;          Identity *id;
           Key *key;
           BIGNUM *challenge;
         int i, len;          int i, len;
         Buffer msg;          Buffer msg;
         MD5_CTX md;          MD5_CTX md;
         Key *key;          u_char buf[32], mdbuf[16], session_id[16];
           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");
   
         (void) buffer_get_int(&e->request);                     /* ignored */          buffer_get_int(&e->input);                              /* ignored */
         buffer_get_bignum(&e->request, key->rsa->e);          buffer_get_bignum(&e->input, key->rsa->e);
         buffer_get_bignum(&e->request, key->rsa->n);          buffer_get_bignum(&e->input, key->rsa->n);
         buffer_get_bignum(&e->request, challenge);          buffer_get_bignum(&e->input, challenge);
   
         /* Only protocol 1.1 is supported */          /* Only protocol 1.1 is supported */
         if (buffer_len(&e->request) == 0)          if (buffer_len(&e->input) == 0)
                 goto failure;                  goto failure;
         buffer_get(&e->request, session_id, 16);          buffer_get(&e->input, session_id, 16);
         response_type = buffer_get_int(&e->request);          response_type = buffer_get_int(&e->input);
         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 && (!id->confirm || confirm_key(id) == 0)) {          if (id != NULL) {
                 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 289 
Line 241 
 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;
         extern int datafellows;          int flags;
         int ok = -1, flags;  
         Buffer msg;          Buffer msg;
         Key *key;          int ok = -1;
   
         datafellows = 0;          datafellows = 0;
   
         blob = buffer_get_string(&e->request, &blen);          blob = buffer_get_string(&e->input, &blen);
         data = buffer_get_string(&e->request, &dlen);          data = buffer_get_string(&e->input, &dlen);
   
         flags = buffer_get_int(&e->request);          flags = buffer_get_int(&e->input);
         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 && (!id->confirm || confirm_key(id) == 0))                  if (id != NULL)
                         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 333 
Line 286 
 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->request);                  bits = buffer_get_int(&e->input);
                 buffer_get_bignum(&e->request, key->rsa->e);                  buffer_get_bignum(&e->input, key->rsa->e);
                 buffer_get_bignum(&e->request, key->rsa->n);                  buffer_get_bignum(&e->input, key->rsa->n);
   
                 if (bits != key_size(key))                  if (bits != key_size(key))
                         log("Warning: identity keysize mismatch: actual %u, announced %u",                          log("Warning: identity keysize mismatch: actual %d, announced %d",
                             key_size(key), bits);                              key_size(key), bits);
                 break;                  break;
         case 2:          case 2:
                 blob = buffer_get_string(&e->request, &blen);                  blob = buffer_get_string(&e->input, &blen);
                 key = key_from_blob(blob, blen);                  key = key_from_blob(blob, blen);
                 xfree(blob);                  xfree(blob);
                 break;                  break;
Line 401 
Line 355 
         /* 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)
 {  {
         Idtab *tab = idtab_lookup(version);  
         int type, success = 0, death = 0, confirm = 0;  
         char *type_name, *comment;  
         Key *k = NULL;          Key *k = NULL;
           char *type_name;
           char *comment;
           int type, success = 0;
           Idtab *tab = idtab_lookup(version);
   
         switch (version) {          switch (version) {
         case 1:          case 1:
                 k = key_new_private(KEY_RSA1);                  k = key_new_private(KEY_RSA1);
                 (void) buffer_get_int(&e->request);             /* ignored */                  buffer_get_int(&e->input);                      /* ignored */
                 buffer_get_bignum(&e->request, k->rsa->n);                  buffer_get_bignum(&e->input, k->rsa->n);
                 buffer_get_bignum(&e->request, k->rsa->e);                  buffer_get_bignum(&e->input, k->rsa->e);
                 buffer_get_bignum(&e->request, k->rsa->d);                  buffer_get_bignum(&e->input, k->rsa->d);
                 buffer_get_bignum(&e->request, k->rsa->iqmp);                  buffer_get_bignum(&e->input, k->rsa->iqmp);
   
                 /* SSH and SSL have p and q swapped */                  /* SSH and SSL have p and q swapped */
                 buffer_get_bignum(&e->request, k->rsa->q);      /* p */                  buffer_get_bignum(&e->input, k->rsa->q);        /* p */
                 buffer_get_bignum(&e->request, k->rsa->p);      /* q */                  buffer_get_bignum(&e->input, 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->request, NULL);                  type_name = buffer_get_string(&e->input, 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->request, k->dsa->p);                          buffer_get_bignum2(&e->input, k->dsa->p);
                         buffer_get_bignum2(&e->request, k->dsa->q);                          buffer_get_bignum2(&e->input, k->dsa->q);
                         buffer_get_bignum2(&e->request, k->dsa->g);                          buffer_get_bignum2(&e->input, k->dsa->g);
                         buffer_get_bignum2(&e->request, k->dsa->pub_key);                          buffer_get_bignum2(&e->input, k->dsa->pub_key);
                         buffer_get_bignum2(&e->request, k->dsa->priv_key);                          buffer_get_bignum2(&e->input, 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->request, k->rsa->n);                          buffer_get_bignum2(&e->input, k->rsa->n);
                         buffer_get_bignum2(&e->request, k->rsa->e);                          buffer_get_bignum2(&e->input, k->rsa->e);
                         buffer_get_bignum2(&e->request, k->rsa->d);                          buffer_get_bignum2(&e->input, k->rsa->d);
                         buffer_get_bignum2(&e->request, k->rsa->iqmp);                          buffer_get_bignum2(&e->input, k->rsa->iqmp);
                         buffer_get_bignum2(&e->request, k->rsa->p);                          buffer_get_bignum2(&e->input, k->rsa->p);
                         buffer_get_bignum2(&e->request, k->rsa->q);                          buffer_get_bignum2(&e->input, 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->request);                          buffer_clear(&e->input);
                         goto send;                          goto send;
                 }                  }
                 break;                  break;
         }          }
         /* enable blinding */          comment = buffer_get_string(&e->input, NULL);
         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 529 
Line 437 
             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)
 {  {
         char *sc_reader_id = NULL, *pin;  
         int i, version, success = 0;  
         Key **keys, *k;  
         Identity *id;          Identity *id;
         Idtab *tab;          Idtab *tab;
           Key **keys, *k;
           char *sc_reader_id = NULL, *pin;
           int i, version, success = 0;
   
         sc_reader_id = buffer_get_string(&e->request, NULL);          sc_reader_id = buffer_get_string(&e->input, NULL);
         pin = buffer_get_string(&e->request, NULL);          pin = buffer_get_string(&e->input, 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 599 
Line 466 
                         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 619 
Line 484 
 static void  static void
 process_remove_smartcard_key(SocketEntry *e)  process_remove_smartcard_key(SocketEntry *e)
 {  {
         char *sc_reader_id = NULL, *pin;  
         int i, version, success = 0;  
         Key **keys, *k = NULL;  
         Identity *id;          Identity *id;
         Idtab *tab;          Idtab *tab;
           Key **keys, *k = NULL;
           char *sc_reader_id = NULL, *pin;
           int i, version, success = 0;
   
         sc_reader_id = buffer_get_string(&e->request, NULL);          sc_reader_id = buffer_get_string(&e->input, NULL);
         pin = buffer_get_string(&e->request, NULL);          pin = buffer_get_string(&e->input, 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 640 
Line 505 
                 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 661 
Line 526 
 static void  static void
 process_message(SocketEntry *e)  process_message(SocketEntry *e)
 {  {
         u_int msg_len, type;          u_int msg_len;
           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) {
                 close_socket(e);                  shutdown(e->fd, SHUT_RDWR);
                   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);
         buffer_clear(&e->request);          type = buffer_get_char(&e->input);
         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 716 
Line 554 
                 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 733 
Line 570 
                 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 753 
Line 589 
         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->request);                  buffer_clear(&e->input);
                 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 764 
Line 600 
 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 777 
Line 612 
                         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 792 
Line 626 
         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 849 
Line 682 
 static void  static void
 after_select(fd_set *readset, fd_set *writeset)  after_select(fd_set *readset, fd_set *writeset)
 {  {
         struct sockaddr_un sunaddr;          u_int i;
           int len, sock;
         socklen_t slen;          socklen_t slen;
         char buf[1024];          char buf[1024];
         int len, sock;          struct sockaddr_un sunaddr;
         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 871 
Line 702 
                                             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 900 
Line 718 
                                         break;                                          break;
                                 } while (1);                                  } while (1);
                                 if (len <= 0) {                                  if (len <= 0) {
                                         close_socket(&sockets[i]);                                          shutdown(sockets[i].fd, SHUT_RDWR);
                                           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 914 
Line 736 
                                         break;                                          break;
                                 } while (1);                                  } while (1);
                                 if (len <= 0) {                                  if (len <= 0) {
                                         close_socket(&sockets[i]);                                          shutdown(sockets[i].fd, SHUT_RDWR);
                                           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 974 
Line 800 
         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, "  -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 c_flag = 0, d_flag = 0, k_flag = 0, s_flag = 0;          int sock, c_flag = 0, d_flag = 0, k_flag = 0, s_flag = 0, ch, nalloc;
         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;
         extern int optind;  
         extern char *optarg;  
         pid_t pid;          pid_t pid;
         char pidstrbuf[1 + 3 * sizeof pid];          char *shell, *format, *pidstr, pidstrbuf[1 + 3 * sizeof pid];
           char *agentsocket = NULL;
           extern int optind;
           fd_set *readsetp = NULL, *writesetp = NULL;
   
         /* drop */  
         setegid(getgid());  
         setgid(getgid());  
   
         SSLeay_add_all_algorithms();          SSLeay_add_all_algorithms();
   
         while ((ch = getopt(ac, av, "cdksa:t:")) != -1) {          while ((ch = getopt(ac, av, "cdksa:")) != -1) {
                 switch (ch) {                  switch (ch) {
                 case 'c':                  case 'c':
                         if (s_flag)                          if (s_flag)
Line 1021 
Line 840 
                 case 'a':                  case 'a':
                         agentsocket = optarg;                          agentsocket = optarg;
                         break;                          break;
                 case 't':  
                         if ((lifetime = convtime(optarg)) == -1) {  
                                 fprintf(stderr, "Invalid lifetime\n");  
                                 usage();  
                         }  
                         break;  
                 default:                  default:
                         usage();                          usage();
                 }                  }
Line 1062 
Line 875 
                 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 %ld killed;\n", (long)pid);                  printf("echo Agent pid %d killed;\n", pid);
                 exit(0);                  exit(0);
         }          }
         parent_pid = getpid();          parent_pid = getpid();
Line 1074 
Line 887 
                         perror("mkdtemp: private socket dir");                          perror("mkdtemp: private socket dir");
                         exit(1);                          exit(1);
                 }                  }
                 snprintf(socket_name, sizeof socket_name, "%s/agent.%ld", socket_dir,                  snprintf(socket_name, sizeof socket_name, "%s/agent.%d", socket_dir,
                     (long)parent_pid);                      parent_pid);
         } else {          } else {
                 /* Try to use specified agent socket */                  /* Try to use specified agent socket */
                 socket_dir[0] = '\0';                  socket_dir[0] = '\0';
Line 1098 
Line 911 
                 perror("bind");                  perror("bind");
                 cleanup_exit(1);                  cleanup_exit(1);
         }          }
         if (listen(sock, 128) < 0) {          if (listen(sock, 5) < 0) {
                 perror("listen");                  perror("listen");
                 cleanup_exit(1);                  cleanup_exit(1);
         }          }
Line 1112 
Line 925 
                 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 %ld;\n", (long)parent_pid);                  printf("echo Agent pid %d;\n", parent_pid);
                 goto skip;                  goto skip;
         }          }
         pid = fork();          pid = fork();
Line 1122 
Line 935 
         }          }
         if (pid != 0) {         /* Parent - execute the given command. */          if (pid != 0) {         /* Parent - execute the given command. */
                 close(sock);                  close(sock);
                 snprintf(pidstrbuf, sizeof pidstrbuf, "%ld", (long)pid);                  snprintf(pidstrbuf, sizeof pidstrbuf, "%d", 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 %ld;\n", (long)pid);                          printf("echo Agent pid %d;\n", 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 1150 
Line 963 
         }          }
   
         (void)chdir("/");          (void)chdir("/");
         if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {          close(0);
                 /* XXX might close listen socket */          close(1);
                 (void)dup2(fd, STDIN_FILENO);          close(2);
                 (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.2.3  
changed lines
  Added in v.1.86