[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.37.2.5 and 1.37.2.6

version 1.37.2.5, 2001/09/27 00:15:42 version 1.37.2.6, 2002/03/08 17:04:43
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 36 
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 46 
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"
   
Line 61 
Line 56 
 #include "scard.h"  #include "scard.h"
 #endif  #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 73 
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 101 
Line 101 
 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;
         }          }
 }  }
Line 117 
Line 117 
 }  }
   
 /* return matching private key for given public key */  /* return matching private key for given public key */
 static 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' */
 static 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 168 
Line 173 
 static 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 178 
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 188 
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 235 
Line 243 
 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 253 
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 279 
Line 287 
 static 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 303 
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 314 
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 340 
Line 340 
 static 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 387 
Line 388 
                 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 420 
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 449 
Line 447 
         Key *n = NULL, *k = NULL;          Key *n = NULL, *k = NULL;
         char *sc_reader_id = NULL;          char *sc_reader_id = NULL;
         int success = 0;          int success = 0;
   
         sc_reader_id = buffer_get_string(&e->input, NULL);          sc_reader_id = buffer_get_string(&e->input, NULL);
         k = sc_get_key(sc_reader_id);          k = sc_get_key(sc_reader_id);
         xfree(sc_reader_id);          xfree(sc_reader_id);
Line 462 
Line 460 
   
         tab = idtab_lookup(1);          tab = idtab_lookup(1);
         k->type = KEY_RSA1;          k->type = KEY_RSA1;
         if (lookup_private_key(k, NULL, 1) == NULL) {          if (lookup_identity(k, 1) == NULL) {
                 if (tab->nentries == 0)                  Identity *id = xmalloc(sizeof(Identity));
                         tab->identities = xmalloc(sizeof(Identity));  
                 else  
                         tab->identities = xrealloc(tab->identities,  
                             (tab->nentries + 1) * sizeof(Identity));  
                 n = key_new(KEY_RSA1);                  n = key_new(KEY_RSA1);
                 BN_copy(n->rsa->n, k->rsa->n);                  BN_copy(n->rsa->n, k->rsa->n);
                 BN_copy(n->rsa->e, k->rsa->e);                  BN_copy(n->rsa->e, k->rsa->e);
                 RSA_set_method(n->rsa, sc_get_engine());                  RSA_set_method(n->rsa, sc_get_engine());
                 tab->identities[tab->nentries].key = n;                  id->key = n;
                 tab->identities[tab->nentries].comment =                  id->comment = xstrdup("rsa1 smartcard");
                     xstrdup("rsa1 smartcard");                  TAILQ_INSERT_TAIL(&tab->idlist, id, next);
                 tab->nentries++;                  tab->nentries++;
         }          }
         k->type = KEY_RSA;          k->type = KEY_RSA;
         tab = idtab_lookup(2);          tab = idtab_lookup(2);
         if (lookup_private_key(k, NULL, 2) == NULL) {          if (lookup_identity(k, 2) == NULL) {
                 if (tab->nentries == 0)                  Identity *id = xmalloc(sizeof(Identity));
                         tab->identities = xmalloc(sizeof(Identity));  
                 else  
                         tab->identities = xrealloc(tab->identities,  
                             (tab->nentries + 1) * sizeof(Identity));  
                 n = key_new(KEY_RSA);                  n = key_new(KEY_RSA);
                 BN_copy(n->rsa->n, k->rsa->n);                  BN_copy(n->rsa->n, k->rsa->n);
                 BN_copy(n->rsa->e, k->rsa->e);                  BN_copy(n->rsa->e, k->rsa->e);
                 RSA_set_method(n->rsa, sc_get_engine());                  RSA_set_method(n->rsa, sc_get_engine());
                 tab->identities[tab->nentries].key = n;                  id->key = n;
                 tab->identities[tab->nentries].comment =                  id->comment = xstrdup("rsa smartcard");
                     xstrdup("rsa smartcard");                  TAILQ_INSERT_TAIL(&tab->idlist, id, next);
                 tab->nentries++;                  tab->nentries++;
         }          }
         key_free(k);          key_free(k);
Line 504 
Line 494 
 static void  static void
 process_remove_smartcard_key(SocketEntry *e)  process_remove_smartcard_key(SocketEntry *e)
 {  {
         Key *k = NULL, *private;          Key *k = NULL;
         int idx;  
         int success = 0;          int success = 0;
         char *sc_reader_id = NULL;          char *sc_reader_id = NULL;
   
Line 516 
Line 505 
         if (k == NULL) {          if (k == NULL) {
                 error("sc_get_pubkey failed");                  error("sc_get_pubkey failed");
         } else {          } else {
                   Identity *id;
                 k->type = KEY_RSA1;                  k->type = KEY_RSA1;
                 private = lookup_private_key(k, &idx, 1);                  id = lookup_identity(k, 1);
                 if (private != NULL) {                  if (id != NULL) {
                         Idtab *tab = idtab_lookup(1);                          Idtab *tab = idtab_lookup(1);
                         key_free(tab->identities[idx].key);                          TAILQ_REMOVE(&tab->idlist, id, next);
                         xfree(tab->identities[idx].comment);                          free_identity(id);
                         if (idx != tab->nentries)  
                                 tab->identities[idx] = tab->identities[tab->nentries];  
                         tab->nentries--;                          tab->nentries--;
                         success = 1;                          success = 1;
                 }                  }
                 k->type = KEY_RSA;                  k->type = KEY_RSA;
                 private = lookup_private_key(k, &idx, 2);                  id = lookup_identity(k, 2);
                 if (private != NULL) {                  if (id != NULL) {
                         Idtab *tab = idtab_lookup(2);                          Idtab *tab = idtab_lookup(2);
                         key_free(tab->identities[idx].key);                          TAILQ_REMOVE(&tab->idlist, id, next);
                         xfree(tab->identities[idx].comment);                          free_identity(id);
                         if (idx != tab->nentries)  
                                 tab->identities[idx] = tab->identities[tab->nentries];  
                         tab->nentries--;                          tab->nentries--;
                         success = 1;                          success = 1;
                 }                  }
Line 557 
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 607 
Line 593 
 #ifdef SMARTCARD  #ifdef SMARTCARD
         case SSH_AGENTC_ADD_SMARTCARD_KEY:          case SSH_AGENTC_ADD_SMARTCARD_KEY:
                 process_add_smartcard_key(e);                  process_add_smartcard_key(e);
                 break;                  break;
         case SSH_AGENTC_REMOVE_SMARTCARD_KEY:          case SSH_AGENTC_REMOVE_SMARTCARD_KEY:
                 process_remove_smartcard_key(e);                  process_remove_smartcard_key(e);
                 break;                  break;
 #endif /* SMARTCARD */  #endif /* SMARTCARD */
         default:          default:
                 /* Unknown message.  Respond with failure. */                  /* Unknown message.  Respond with failure. */
Line 623 
Line 609 
 }  }
   
 static 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 724 
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 778 
Line 765 
 }  }
   
 static void  static void
 cleanup_socket(void)  cleanup_socket(void *p)
 {  {
         if (socket_name[0])          if (socket_name[0])
                 unlink(socket_name);                  unlink(socket_name);
Line 789 
Line 776 
 static void  static void
 cleanup_exit(int i)  cleanup_exit(int i)
 {  {
         cleanup_socket();          cleanup_socket(NULL);
         exit(i);          exit(i);
 }  }
   
 static void  static void
 cleanup_handler(int sig)  cleanup_handler(int sig)
 {  {
         cleanup_socket();          cleanup_socket(NULL);
         _exit(2);          _exit(2);
 }  }
   
Line 945 
Line 932 
         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 968 
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) {          if (setsid() == -1) {
                 perror("setsid");                  error("setsid: %s", strerror(errno));
                 cleanup_exit(1);                  cleanup_exit(1);
         }          }
   
Line 982 
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);
         }          }
   
 skip:  skip:
         if (atexit(cleanup_socket) < 0) {          fatal_add_cleanup(cleanup_socket, NULL);
                 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);
Line 1009 
Line 995 
                 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.37.2.5  
changed lines
  Added in v.1.37.2.6