[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.54 and 1.54.2.2

version 1.54, 2001/04/03 13:56:11 version 1.54.2.2, 2002/03/09 00:20:45
Line 1 
Line 1 
 /*      $OpenBSD$       */  
   
 /*  /*
  * Author: Tatu Ylonen <ylo@cs.hut.fi>   * Author: Tatu Ylonen <ylo@cs.hut.fi>
  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland   * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
Line 12 
Line 10 
  * incompatible with the protocol description in the RFC file, it must be   * incompatible with the protocol description in the RFC file, it must be
  * called by a name other than "ssh" or "Secure Shell".   * called by a name other than "ssh" or "Secure Shell".
  *   *
  * SSH2 implementation,   * Copyright (c) 2000, 2001 Markus Friedl.  All rights reserved.
  * Copyright (c) 2000 Markus Friedl.  All rights reserved.  
  *   *
  * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions   * modification, are permitted provided that the following conditions
Line 37 
Line 34 
  */   */
   
 #include "includes.h"  #include "includes.h"
   #include <sys/queue.h>
 RCSID("$OpenBSD$");  RCSID("$OpenBSD$");
   
 #include <openssl/evp.h>  #include <openssl/evp.h>
Line 47 
Line 45 
 #include "buffer.h"  #include "buffer.h"
 #include "bufaux.h"  #include "bufaux.h"
 #include "xmalloc.h"  #include "xmalloc.h"
 #include "packet.h"  
 #include "getput.h"  #include "getput.h"
 #include "mpaux.h"  
 #include "key.h"  #include "key.h"
 #include "authfd.h"  #include "authfd.h"
 #include "cipher.h"  
 #include "kex.h"  
 #include "compat.h"  #include "compat.h"
 #include "log.h"  #include "log.h"
   
   #ifdef SMARTCARD
   #include <openssl/engine.h>
   #include "scard.h"
   #endif
   
   typedef enum {
           AUTH_UNUSED,
           AUTH_SOCKET,
           AUTH_CONNECTION
   } sock_type;
   
 typedef struct {  typedef struct {
         int fd;          int fd;
         enum {          sock_type type;
                 AUTH_UNUSED, AUTH_SOCKET, AUTH_CONNECTION  
         } type;  
         Buffer input;          Buffer input;
         Buffer output;          Buffer output;
 } SocketEntry;  } SocketEntry;
Line 69 
Line 72 
 u_int sockets_alloc = 0;  u_int sockets_alloc = 0;
 SocketEntry *sockets = NULL;  SocketEntry *sockets = NULL;
   
 typedef struct {  typedef struct identity {
           TAILQ_ENTRY(identity) next;
         Key *key;          Key *key;
         char *comment;          char *comment;
 } Identity;  } Identity;
   
 typedef struct {  typedef struct {
         int nentries;          int nentries;
         Identity *identities;          TAILQ_HEAD(idqueue, identity) idlist;
 } Idtab;  } Idtab;
   
 /* private key table, one per protocol version */  /* private key table, one per protocol version */
Line 93 
Line 97 
   
 extern char *__progname;  extern char *__progname;
   
 int     prepare_select(fd_set **, fd_set **, int *);  static void
   
 void  
 idtab_init(void)  idtab_init(void)
 {  {
         int i;          int i;
         for (i = 0; i <=2; i++){          for (i = 0; i <=2; i++) {
                 idtable[i].identities = NULL;                  TAILQ_INIT(&idtable[i].idlist);
                 idtable[i].nentries = 0;                  idtable[i].nentries = 0;
         }          }
 }  }
   
 /* return private key table for requested protocol version */  /* return private key table for requested protocol version */
 Idtab *  static Idtab *
 idtab_lookup(int version)  idtab_lookup(int version)
 {  {
         if (version < 1 || version > 2)          if (version < 1 || version > 2)
Line 115 
Line 117 
 }  }
   
 /* return matching private key for given public key */  /* return matching private key for given public key */
 Key *  static Identity *
 lookup_private_key(Key *key, int *idx, int version)  lookup_identity(Key *key, int version)
 {  {
         int i;          Identity *id;
   
         Idtab *tab = idtab_lookup(version);          Idtab *tab = idtab_lookup(version);
         for (i = 0; i < tab->nentries; i++) {          TAILQ_FOREACH(id, &tab->idlist, next) {
                 if (key_equal(key, tab->identities[i].key)) {                  if (key_equal(key, id->key))
                         if (idx != NULL)                          return (id);
                                 *idx = i;  
                         return tab->identities[i].key;  
                 }  
         }          }
         return NULL;          return (NULL);
 }  }
   
   static void
   free_identity(Identity *id)
   {
           key_free(id->key);
           xfree(id->comment);
           xfree(id);
   }
   
 /* send list of supported public keys to 'client' */  /* send list of supported public keys to 'client' */
 void  static void
 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;          Buffer msg;
         int i;          Identity *id;
   
         buffer_init(&msg);          buffer_init(&msg);
         buffer_put_char(&msg, (version == 1) ?          buffer_put_char(&msg, (version == 1) ?
             SSH_AGENT_RSA_IDENTITIES_ANSWER : SSH2_AGENT_IDENTITIES_ANSWER);              SSH_AGENT_RSA_IDENTITIES_ANSWER : SSH2_AGENT_IDENTITIES_ANSWER);
         buffer_put_int(&msg, tab->nentries);          buffer_put_int(&msg, tab->nentries);
         for (i = 0; i < tab->nentries; i++) {          TAILQ_FOREACH(id, &tab->idlist, next) {
                 Identity *id = &tab->identities[i];  
                 if (id->key->type == KEY_RSA1) {                  if (id->key->type == KEY_RSA1) {
                         buffer_put_int(&msg, BN_num_bits(id->key->rsa->n));                          buffer_put_int(&msg, BN_num_bits(id->key->rsa->n));
                         buffer_put_bignum(&msg, id->key->rsa->e);                          buffer_put_bignum(&msg, id->key->rsa->e);
Line 163 
Line 170 
 }  }
   
 /* ssh1 only */  /* ssh1 only */
 void  static void
 process_authentication_challenge1(SocketEntry *e)  process_authentication_challenge1(SocketEntry *e)
 {  {
         Key *key, *private;          Identity *id;
           Key *key;
         BIGNUM *challenge;          BIGNUM *challenge;
         int i, len;          int i, len;
         Buffer msg;          Buffer msg;
Line 176 
Line 184 
   
         buffer_init(&msg);          buffer_init(&msg);
         key = key_new(KEY_RSA1);          key = key_new(KEY_RSA1);
         challenge = BN_new();          if ((challenge = BN_new()) == NULL)
                   fatal("process_authentication_challenge1: BN_new failed");
   
         buffer_get_int(&e->input);                              /* ignored */          buffer_get_int(&e->input);                              /* ignored */
         buffer_get_bignum(&e->input, key->rsa->e);          buffer_get_bignum(&e->input, key->rsa->e);
Line 186 
Line 195 
         /* Only protocol 1.1 is supported */          /* Only protocol 1.1 is supported */
         if (buffer_len(&e->input) == 0)          if (buffer_len(&e->input) == 0)
                 goto failure;                  goto failure;
         buffer_get(&e->input, (char *) session_id, 16);          buffer_get(&e->input, session_id, 16);
         response_type = buffer_get_int(&e->input);          response_type = buffer_get_int(&e->input);
         if (response_type != 1)          if (response_type != 1)
                 goto failure;                  goto failure;
   
         private = lookup_private_key(key, NULL, 1);          id = lookup_identity(key, 1);
         if (private != NULL) {          if (id != NULL) {
                   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)
                         goto failure;                          goto failure;
Line 229 
Line 239 
 }  }
   
 /* ssh2 only */  /* ssh2 only */
 void  static void
 process_sign_request2(SocketEntry *e)  process_sign_request2(SocketEntry *e)
 {  {
         extern int datafellows;          extern int datafellows;
         Key *key, *private;          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;          int flags;
Line 251 
Line 261 
   
         key = key_from_blob(blob, blen);          key = key_from_blob(blob, blen);
         if (key != NULL) {          if (key != NULL) {
                 private = lookup_private_key(key, NULL, 2);                  Identity *id = lookup_identity(key, 2);
                 if (private != NULL)                  if (id != NULL)
                         ok = key_sign(private, &signature, &slen, data, dlen);                          ok = key_sign(id->key, &signature, &slen, data, dlen);
         }          }
         key_free(key);          key_free(key);
         buffer_init(&msg);          buffer_init(&msg);
Line 274 
Line 284 
 }  }
   
 /* shared */  /* shared */
 void  static void
 process_remove_identity(SocketEntry *e, int version)  process_remove_identity(SocketEntry *e, int version)
 {  {
         Key *key = NULL, *private;          Key *key = NULL;
         u_char *blob;          u_char *blob;
         u_int blen;          u_int blen;
         u_int bits;          u_int bits;
         int success = 0;          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->input);
Line 301 
Line 311 
                 break;                  break;
         }          }
         if (key != NULL) {          if (key != NULL) {
                 int idx;                  Identity *id = lookup_identity(key, version);
                 private = lookup_private_key(key, &idx, version);                  if (id != NULL) {
                 if (private != NULL) {  
                         /*                          /*
                          * We have this key.  Free the old key.  Since we                           * We have this key.  Free the old key.  Since we
                          * don\'t want to leave empty slots in the middle of                           * don\'t want to leave empty slots in the middle of
Line 312 
Line 321 
                          * of the array.                           * of the array.
                          */                           */
                         Idtab *tab = idtab_lookup(version);                          Idtab *tab = idtab_lookup(version);
                         key_free(tab->identities[idx].key);  
                         xfree(tab->identities[idx].comment);  
                         if (tab->nentries < 1)                          if (tab->nentries < 1)
                                 fatal("process_remove_identity: "                                  fatal("process_remove_identity: "
                                     "internal error: tab->nentries %d",                                      "internal error: tab->nentries %d",
                                     tab->nentries);                                      tab->nentries);
                         if (idx != tab->nentries - 1) {                          TAILQ_REMOVE(&tab->idlist, id, next);
                                 int i;                          free_identity(id);
                                 for (i = idx; i < tab->nentries - 1; i++)  
                                         tab->identities[i] = tab->identities[i+1];  
                         }  
                         tab->identities[tab->nentries - 1].key = NULL;  
                         tab->identities[tab->nentries - 1].comment = NULL;  
                         tab->nentries--;                          tab->nentries--;
                         success = 1;                          success = 1;
                 }                  }
Line 335 
Line 337 
             success ? SSH_AGENT_SUCCESS : SSH_AGENT_FAILURE);              success ? SSH_AGENT_SUCCESS : SSH_AGENT_FAILURE);
 }  }
   
 void  static void
 process_remove_all_identities(SocketEntry *e, int version)  process_remove_all_identities(SocketEntry *e, int version)
 {  {
         u_int i;  
         Idtab *tab = idtab_lookup(version);          Idtab *tab = idtab_lookup(version);
           Identity *id;
   
         /* Loop over all identities and clear the keys. */          /* Loop over all identities and clear the keys. */
         for (i = 0; i < tab->nentries; i++) {          for (id = TAILQ_FIRST(&tab->idlist); id;
                 key_free(tab->identities[i].key);              id = TAILQ_FIRST(&tab->idlist)) {
                 xfree(tab->identities[i].comment);                  TAILQ_REMOVE(&tab->idlist, id, next);
                   free_identity(id);
         }          }
   
         /* Mark that there are no identities. */          /* Mark that there are no identities. */
Line 356 
Line 359 
         return;          return;
 }  }
   
 void  static void
 process_add_identity(SocketEntry *e, int version)  process_add_identity(SocketEntry *e, int version)
 {  {
         Key *k = NULL;          Key *k = NULL;
Line 379 
Line 382 
                 buffer_get_bignum(&e->input, k->rsa->p);        /* q */                  buffer_get_bignum(&e->input, k->rsa->p);        /* q */
   
                 /* Generate additional parameters */                  /* Generate additional parameters */
                 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->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->input, k->dsa->p);                          buffer_get_bignum2(&e->input, k->dsa->p);
Line 404 
Line 407 
                         buffer_get_bignum2(&e->input, k->rsa->q);                          buffer_get_bignum2(&e->input, k->rsa->q);
   
                         /* Generate additional parameters */                          /* Generate additional parameters */
                         generate_additional_parameters(k->rsa);                          rsa_generate_additional_parameters(k->rsa);
                         break;                          break;
                 default:                  default:
                         buffer_clear(&e->input);                          buffer_clear(&e->input);
Line 418 
Line 421 
                 goto send;                  goto send;
         }          }
         success = 1;          success = 1;
         if (lookup_private_key(k, NULL, version) == NULL) {          if (lookup_identity(k, version) == NULL) {
                 if (tab->nentries == 0)                  Identity *id = xmalloc(sizeof(Identity));
                         tab->identities = xmalloc(sizeof(Identity));                  id->key = k;
                 else                  id->comment = comment;
                         tab->identities = xrealloc(tab->identities,                  TAILQ_INSERT_TAIL(&tab->idlist, id, next);
                             (tab->nentries + 1) * sizeof(Identity));  
                 tab->identities[tab->nentries].key = k;  
                 tab->identities[tab->nentries].comment = comment;  
                 /* Increment the number of identities. */                  /* Increment the number of identities. */
                 tab->nentries++;                  tab->nentries++;
         } else {          } else {
Line 438 
Line 438 
             success ? SSH_AGENT_SUCCESS : SSH_AGENT_FAILURE);              success ? SSH_AGENT_SUCCESS : SSH_AGENT_FAILURE);
 }  }
   
   
   #ifdef SMARTCARD
   static void
   process_add_smartcard_key (SocketEntry *e)
   {
           Idtab *tab;
           Key *n = NULL, *k = NULL;
           char *sc_reader_id = NULL;
           int success = 0;
   
           sc_reader_id = buffer_get_string(&e->input, NULL);
           k = sc_get_key(sc_reader_id);
           xfree(sc_reader_id);
   
           if (k == NULL) {
                   error("sc_get_pubkey failed");
                   goto send;
           }
           success = 1;
   
           tab = idtab_lookup(1);
           k->type = KEY_RSA1;
           if (lookup_identity(k, 1) == NULL) {
                   Identity *id = xmalloc(sizeof(Identity));
                   n = key_new(KEY_RSA1);
                   BN_copy(n->rsa->n, k->rsa->n);
                   BN_copy(n->rsa->e, k->rsa->e);
                   RSA_set_method(n->rsa, sc_get_engine());
                   id->key = n;
                   id->comment = xstrdup("rsa1 smartcard");
                   TAILQ_INSERT_TAIL(&tab->idlist, id, next);
                   tab->nentries++;
           }
           k->type = KEY_RSA;
           tab = idtab_lookup(2);
           if (lookup_identity(k, 2) == NULL) {
                   Identity *id = xmalloc(sizeof(Identity));
                   n = key_new(KEY_RSA);
                   BN_copy(n->rsa->n, k->rsa->n);
                   BN_copy(n->rsa->e, k->rsa->e);
                   RSA_set_method(n->rsa, sc_get_engine());
                   id->key = n;
                   id->comment = xstrdup("rsa smartcard");
                   TAILQ_INSERT_TAIL(&tab->idlist, id, next);
                   tab->nentries++;
           }
           key_free(k);
   send:
           buffer_put_int(&e->output, 1);
           buffer_put_char(&e->output,
               success ? SSH_AGENT_SUCCESS : SSH_AGENT_FAILURE);
   }
   
   static void
   process_remove_smartcard_key(SocketEntry *e)
   {
           Key *k = NULL;
           int success = 0;
           char *sc_reader_id = NULL;
   
           sc_reader_id = buffer_get_string(&e->input, NULL);
           k = sc_get_key(sc_reader_id);
           xfree(sc_reader_id);
   
           if (k == NULL) {
                   error("sc_get_pubkey failed");
           } else {
                   Identity *id;
                   k->type = KEY_RSA1;
                   id = lookup_identity(k, 1);
                   if (id != NULL) {
                           Idtab *tab = idtab_lookup(1);
                           TAILQ_REMOVE(&tab->idlist, id, next);
                           free_identity(id);
                           tab->nentries--;
                           success = 1;
                   }
                   k->type = KEY_RSA;
                   id = lookup_identity(k, 2);
                   if (id != NULL) {
                           Idtab *tab = idtab_lookup(2);
                           TAILQ_REMOVE(&tab->idlist, id, next);
                           free_identity(id);
                           tab->nentries--;
                           success = 1;
                   }
                   key_free(k);
           }
   
           buffer_put_int(&e->output, 1);
           buffer_put_char(&e->output,
               success ? SSH_AGENT_SUCCESS : SSH_AGENT_FAILURE);
   }
   #endif /* SMARTCARD */
   
 /* dispatch incoming messages */  /* dispatch incoming messages */
   
 void  static void
 process_message(SocketEntry *e)  process_message(SocketEntry *e)
 {  {
         u_int msg_len;          u_int msg_len;
Line 448 
Line 543 
         u_char *cp;          u_char *cp;
         if (buffer_len(&e->input) < 5)          if (buffer_len(&e->input) < 5)
                 return;         /* Incomplete message. */                  return;         /* Incomplete message. */
         cp = (u_char *) 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);                  shutdown(e->fd, SHUT_RDWR);
Line 461 
Line 556 
         buffer_consume(&e->input, 4);          buffer_consume(&e->input, 4);
         type = buffer_get_char(&e->input);          type = buffer_get_char(&e->input);
   
           debug("type %d", type);
         switch (type) {          switch (type) {
         /* ssh1 */          /* ssh1 */
         case SSH_AGENTC_RSA_CHALLENGE:          case SSH_AGENTC_RSA_CHALLENGE:
Line 494 
Line 590 
         case SSH2_AGENTC_REMOVE_ALL_IDENTITIES:          case SSH2_AGENTC_REMOVE_ALL_IDENTITIES:
                 process_remove_all_identities(e, 2);                  process_remove_all_identities(e, 2);
                 break;                  break;
   #ifdef SMARTCARD
           case SSH_AGENTC_ADD_SMARTCARD_KEY:
                   process_add_smartcard_key(e);
                   break;
           case SSH_AGENTC_REMOVE_SMARTCARD_KEY:
                   process_remove_smartcard_key(e);
                   break;
   #endif /* SMARTCARD */
         default:          default:
                 /* Unknown message.  Respond with failure. */                  /* Unknown message.  Respond with failure. */
                 error("Unknown message %d", type);                  error("Unknown message %d", type);
Line 504 
Line 608 
         }          }
 }  }
   
 void  static void
 new_socket(int 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)
Line 536 
Line 640 
         buffer_init(&sockets[old_alloc].output);          buffer_init(&sockets[old_alloc].output);
 }  }
   
 int  static int
 prepare_select(fd_set **fdrp, fd_set **fdwp, int *fdl)  prepare_select(fd_set **fdrp, fd_set **fdwp, int *fdl, int *nallocp)
 {  {
         u_int i, sz;          u_int i, sz;
         int n = 0;          int n = 0;
Line 557 
Line 661 
         }          }
   
         sz = howmany(n+1, NFDBITS) * sizeof(fd_mask);          sz = howmany(n+1, NFDBITS) * sizeof(fd_mask);
         if (*fdrp == NULL || n > *fdl) {          if (*fdrp == NULL || sz > *nallocp) {
                 if (*fdrp)                  if (*fdrp)
                         xfree(*fdrp);                          xfree(*fdrp);
                 if (*fdwp)                  if (*fdwp)
                         xfree(*fdwp);                          xfree(*fdwp);
                 *fdrp = xmalloc(sz);                  *fdrp = xmalloc(sz);
                 *fdwp = xmalloc(sz);                  *fdwp = xmalloc(sz);
                 *fdl = n;                  *nallocp = sz;
         }          }
           if (n < *fdl)
                   debug("XXX shrink: %d < %d", n, *fdl);
           *fdl = n;
         memset(*fdrp, 0, sz);          memset(*fdrp, 0, sz);
         memset(*fdwp, 0, sz);          memset(*fdwp, 0, sz);
   
Line 584 
Line 691 
         return (1);          return (1);
 }  }
   
 void  static void
 after_select(fd_set *readset, fd_set *writeset)  after_select(fd_set *readset, fd_set *writeset)
 {  {
         u_int i;          u_int i;
Line 603 
Line 710 
                                 sock = accept(sockets[i].fd,                                  sock = accept(sockets[i].fd,
                                     (struct sockaddr *) &sunaddr, &slen);                                      (struct sockaddr *) &sunaddr, &slen);
                                 if (sock < 0) {                                  if (sock < 0) {
                                         perror("accept from AUTH_SOCKET");                                          error("accept from AUTH_SOCKET: %s",
                                               strerror(errno));
                                         break;                                          break;
                                 }                                  }
                                 new_socket(AUTH_CONNECTION, sock);                                  new_socket(AUTH_CONNECTION, sock);
Line 656 
Line 764 
                 }                  }
 }  }
   
 void  static void
 check_parent_exists(int sig)  cleanup_socket(void *p)
 {  {
         int save_errno = errno;  
   
         if (parent_pid != -1 && kill(parent_pid, 0) < 0) {  
                 /* printf("Parent has died - Authentication agent exiting.\n"); */  
                 exit(1);  
         }  
         signal(SIGALRM, check_parent_exists);  
         alarm(10);  
         errno = save_errno;  
 }  
   
 void  
 cleanup_socket(void)  
 {  
         if (socket_name[0])          if (socket_name[0])
                 unlink(socket_name);                  unlink(socket_name);
         if (socket_dir[0])          if (socket_dir[0])
                 rmdir(socket_dir);                  rmdir(socket_dir);
 }  }
   
 void  static void
 cleanup_exit(int i)  cleanup_exit(int i)
 {  {
         cleanup_socket();          cleanup_socket(NULL);
         exit(i);          exit(i);
 }  }
   
 void  static void
 cleanup_handler(int sig)  cleanup_handler(int sig)
 {  {
         cleanup_socket();          cleanup_socket(NULL);
         _exit(2);          _exit(2);
 }  }
   
 void  static void
   check_parent_exists(int sig)
   {
           int save_errno = errno;
   
           if (parent_pid != -1 && kill(parent_pid, 0) < 0) {
                   /* printf("Parent has died - Authentication agent exiting.\n"); */
                   cleanup_handler(sig); /* safe */
           }
           signal(SIGALRM, check_parent_exists);
           alarm(10);
           errno = save_errno;
   }
   
   static void
 usage(void)  usage(void)
 {  {
         fprintf(stderr, "ssh-agent version %s\n", SSH_VERSION);          fprintf(stderr, "Usage: %s [options] [command [args ...]]\n",
         fprintf(stderr, "Usage: %s [-c | -s] [-k] [command {args...]]\n",  
             __progname);              __progname);
           fprintf(stderr, "Options:\n");
           fprintf(stderr, "  -c          Generate C-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, "  -d          Debug mode.\n");
         exit(1);          exit(1);
 }  }
   
 int  int
 main(int ac, char **av)  main(int ac, char **av)
 {  {
         int sock, c_flag = 0, k_flag = 0, s_flag = 0, ch;          int sock, c_flag = 0, d_flag = 0, k_flag = 0, s_flag = 0, ch, nalloc;
         struct sockaddr_un sunaddr;          struct sockaddr_un sunaddr;
         struct rlimit rlim;          struct rlimit rlim;
         pid_t pid;          pid_t pid;
Line 715 
Line 827 
   
         SSLeay_add_all_algorithms();          SSLeay_add_all_algorithms();
   
         while ((ch = getopt(ac, av, "cks")) != -1) {          while ((ch = getopt(ac, av, "cdks")) != -1) {
                 switch (ch) {                  switch (ch) {
                 case 'c':                  case 'c':
                         if (s_flag)                          if (s_flag)
Line 730 
Line 842 
                                 usage();                                  usage();
                         s_flag++;                          s_flag++;
                         break;                          break;
                   case 'd':
                           if (d_flag)
                                   usage();
                           d_flag++;
                           break;
                 default:                  default:
                         usage();                          usage();
                 }                  }
Line 737 
Line 854 
         ac -= optind;          ac -= optind;
         av += optind;          av += optind;
   
         if (ac > 0 && (c_flag || k_flag || s_flag))          if (ac > 0 && (c_flag || k_flag || s_flag || d_flag))
                 usage();                  usage();
   
         if (ac == 0 && !c_flag && !k_flag && !s_flag) {          if (ac == 0 && !c_flag && !k_flag && !s_flag && !d_flag) {
                 shell = getenv("SHELL");                  shell = getenv("SHELL");
                 if (shell != NULL && strncmp(shell + strlen(shell) - 3, "csh", 3) == 0)                  if (shell != NULL && strncmp(shell + strlen(shell) - 3, "csh", 3) == 0)
                         c_flag = 1;                          c_flag = 1;
Line 804 
Line 921 
          * Fork, and have the parent execute the command, if any, or present           * Fork, and have the parent execute the command, if any, or present
          * the socket data.  The child continues as the authentication agent.           * the socket data.  The child continues as the authentication agent.
          */           */
           if (d_flag) {
                   log_init(__progname, SYSLOG_LEVEL_DEBUG1, SYSLOG_FACILITY_AUTH, 1);
                   format = c_flag ? "setenv %s %s;\n" : "%s=%s; export %s;\n";
                   printf(format, SSH_AUTHSOCKET_ENV_NAME, socket_name,
                       SSH_AUTHSOCKET_ENV_NAME);
                   printf("echo Agent pid %d;\n", parent_pid);
                   goto skip;
           }
         pid = fork();          pid = fork();
         if (pid == -1) {          if (pid == -1) {
                 perror("fork");                  perror("fork");
                 exit(1);                  cleanup_exit(1);
         }          }
         if (pid != 0) {         /* Parent - execute the given command. */          if (pid != 0) {         /* Parent - execute the given command. */
                 close(sock);                  close(sock);
Line 830 
Line 955 
                 perror(av[0]);                  perror(av[0]);
                 exit(1);                  exit(1);
         }          }
           /* child */
           log_init(__progname, SYSLOG_LEVEL_INFO, SYSLOG_FACILITY_AUTH, 0);
   
           if (setsid() == -1) {
                   error("setsid: %s", strerror(errno));
                   cleanup_exit(1);
           }
   
           (void)chdir("/");
         close(0);          close(0);
         close(1);          close(1);
         close(2);          close(2);
Line 837 
Line 971 
         /* 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;
         if (setrlimit(RLIMIT_CORE, &rlim) < 0) {          if (setrlimit(RLIMIT_CORE, &rlim) < 0) {
                 perror("setrlimit rlimit_core failed");                  error("setrlimit RLIMIT_CORE: %s", strerror(errno));
                 cleanup_exit(1);                  cleanup_exit(1);
         }          }
         if (setsid() == -1) {  
                 perror("setsid");  skip:
                 cleanup_exit(1);          fatal_add_cleanup(cleanup_socket, NULL);
         }  
         if (atexit(cleanup_socket) < 0) {  
                 perror("atexit");  
                 cleanup_exit(1);  
         }  
         new_socket(AUTH_SOCKET, sock);          new_socket(AUTH_SOCKET, sock);
         if (ac > 0) {          if (ac > 0) {
                 signal(SIGALRM, check_parent_exists);                  signal(SIGALRM, check_parent_exists);
                 alarm(10);                  alarm(10);
         }          }
         idtab_init();          idtab_init();
         signal(SIGINT, SIG_IGN);          if (!d_flag)
                   signal(SIGINT, SIG_IGN);
         signal(SIGPIPE, SIG_IGN);          signal(SIGPIPE, SIG_IGN);
         signal(SIGHUP, cleanup_handler);          signal(SIGHUP, cleanup_handler);
         signal(SIGTERM, cleanup_handler);          signal(SIGTERM, cleanup_handler);
           nalloc = 0;
   
         while (1) {          while (1) {
                 prepare_select(&readsetp, &writesetp, &max_fd);                  prepare_select(&readsetp, &writesetp, &max_fd, &nalloc);
                 if (select(max_fd + 1, readsetp, writesetp, NULL, NULL) < 0) {                  if (select(max_fd + 1, readsetp, writesetp, NULL, NULL) < 0) {
                         if (errno == EINTR)                          if (errno == EINTR)
                                 continue;                                  continue;
                         exit(1);                          fatal("select: %s", strerror(errno));
                 }                  }
                 after_select(readsetp, writesetp);                  after_select(readsetp, writesetp);
         }          }
Legend:
Removed from v.1.54  
changed lines
  Added in v.1.54.2.2