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

Diff for /src/usr.bin/ssh/authfd.c between version 1.29 and 1.29.2.3

version 1.29, 2000/10/09 21:51:00 version 1.29.2.3, 2001/03/21 19:46:22
Line 37 
Line 37 
 #include "includes.h"  #include "includes.h"
 RCSID("$OpenBSD$");  RCSID("$OpenBSD$");
   
   #include <openssl/evp.h>
   
 #include "ssh.h"  #include "ssh.h"
 #include "rsa.h"  #include "rsa.h"
 #include "buffer.h"  #include "buffer.h"
 #include "bufaux.h"  #include "bufaux.h"
 #include "xmalloc.h"  #include "xmalloc.h"
 #include "getput.h"  #include "getput.h"
   
 #include <openssl/rsa.h>  
 #include <openssl/dsa.h>  
 #include <openssl/evp.h>  
 #include "key.h"  #include "key.h"
 #include "authfd.h"  #include "authfd.h"
   #include "cipher.h"
 #include "kex.h"  #include "kex.h"
 #include "dsa.h"  
 #include "compat.h"  #include "compat.h"
   #include "log.h"
   #include "atomicio.h"
   
 /* helper */  /* helper */
 int     decode_reply(int type);  int     decode_reply(int type);
Line 63 
Line 63 
 /* Returns the number of the authentication fd, or -1 if there is none. */  /* Returns the number of the authentication fd, or -1 if there is none. */
   
 int  int
 ssh_get_authentication_socket()  ssh_get_authentication_socket(void)
 {  {
         const char *authsocket;          const char *authsocket;
         int sock, len;          int sock, len;
Line 75 
Line 75 
   
         sunaddr.sun_family = AF_UNIX;          sunaddr.sun_family = AF_UNIX;
         strlcpy(sunaddr.sun_path, authsocket, sizeof(sunaddr.sun_path));          strlcpy(sunaddr.sun_path, authsocket, sizeof(sunaddr.sun_path));
         sunaddr.sun_len = len = SUN_LEN(&sunaddr)+1;          len = SUN_LEN(&sunaddr)+1;
           sunaddr.sun_len = len;
   
         sock = socket(AF_UNIX, SOCK_STREAM, 0);          sock = socket(AF_UNIX, SOCK_STREAM, 0);
         if (sock < 0)          if (sock < 0)
Line 117 
Line 118 
         len = 4;          len = 4;
         while (len > 0) {          while (len > 0) {
                 l = read(auth->fd, buf + 4 - len, len);                  l = read(auth->fd, buf + 4 - len, len);
                   if (l == -1 && (errno == EAGAIN || errno == EINTR))
                           continue;
                 if (l <= 0) {                  if (l <= 0) {
                         error("Error reading response length from authentication socket.");                          error("Error reading response length from authentication socket.");
                         return 0;                          return 0;
Line 136 
Line 139 
                 if (l > sizeof(buf))                  if (l > sizeof(buf))
                         l = sizeof(buf);                          l = sizeof(buf);
                 l = read(auth->fd, buf, l);                  l = read(auth->fd, buf, l);
                   if (l == -1 && (errno == EAGAIN || errno == EINTR))
                           continue;
                 if (l <= 0) {                  if (l <= 0) {
                         error("Error reading response from authentication socket.");                          error("Error reading response from authentication socket.");
                         return 0;                          return 0;
Line 168 
Line 173 
  */   */
   
 AuthenticationConnection *  AuthenticationConnection *
 ssh_get_authentication_connection()  ssh_get_authentication_connection(void)
 {  {
         AuthenticationConnection *auth;          AuthenticationConnection *auth;
         int sock;          int sock;
Line 207 
Line 212 
  * Returns the first authentication identity held by the agent.   * Returns the first authentication identity held by the agent.
  */   */
   
 Key *  int
 ssh_get_first_identity(AuthenticationConnection *auth, char **comment, int version)  ssh_get_num_identities(AuthenticationConnection *auth, int version)
 {  {
         int type, code1 = 0, code2 = 0;          int type, code1 = 0, code2 = 0;
         Buffer request;          Buffer request;
Line 223 
Line 228 
                 code2 = SSH2_AGENT_IDENTITIES_ANSWER;                  code2 = SSH2_AGENT_IDENTITIES_ANSWER;
                 break;                  break;
         default:          default:
                 return NULL;                  return 0;
         }          }
   
         /*          /*
Line 236 
Line 241 
         buffer_clear(&auth->identities);          buffer_clear(&auth->identities);
         if (ssh_request_reply(auth, &request, &auth->identities) == 0) {          if (ssh_request_reply(auth, &request, &auth->identities) == 0) {
                 buffer_free(&request);                  buffer_free(&request);
                 return NULL;                  return 0;
         }          }
         buffer_free(&request);          buffer_free(&request);
   
         /* Get message type, and verify that we got a proper answer. */          /* Get message type, and verify that we got a proper answer. */
         type = buffer_get_char(&auth->identities);          type = buffer_get_char(&auth->identities);
         if (agent_failed(type)) {          if (agent_failed(type)) {
                 return NULL;                  return 0;
         } else if (type != code2) {          } else if (type != code2) {
                 fatal("Bad authentication reply message type: %d", type);                  fatal("Bad authentication reply message type: %d", type);
         }          }
Line 251 
Line 256 
         /* Get the number of entries in the response and check it for sanity. */          /* Get the number of entries in the response and check it for sanity. */
         auth->howmany = buffer_get_int(&auth->identities);          auth->howmany = buffer_get_int(&auth->identities);
         if (auth->howmany > 1024)          if (auth->howmany > 1024)
                 fatal("Too many identities in authentication reply: %d\n",                  fatal("Too many identities in authentication reply: %d",
                     auth->howmany);                      auth->howmany);
   
         /* Return the first entry (if any). */          return auth->howmany;
         return ssh_get_next_identity(auth, comment, version);  
 }  }
   
 Key *  Key *
   ssh_get_first_identity(AuthenticationConnection *auth, char **comment, int version)
   {
           /* get number of identities and return the first entry (if any). */
           if (ssh_get_num_identities(auth, version) > 0)
                   return ssh_get_next_identity(auth, comment, version);
           return NULL;
   }
   
   Key *
 ssh_get_next_identity(AuthenticationConnection *auth, char **comment, int version)  ssh_get_next_identity(AuthenticationConnection *auth, char **comment, int version)
 {  {
         unsigned int bits;          u_int bits;
         unsigned char *blob;          u_char *blob;
         unsigned int blen;          u_int blen;
         Key *key = NULL;          Key *key = NULL;
   
         /* Return failure if no more entries. */          /* Return failure if no more entries. */
Line 276 
Line 289 
          */           */
         switch(version){          switch(version){
         case 1:          case 1:
                 key = key_new(KEY_RSA);                  key = key_new(KEY_RSA1);
                 bits = buffer_get_int(&auth->identities);                  bits = buffer_get_int(&auth->identities);
                 buffer_get_bignum(&auth->identities, key->rsa->e);                  buffer_get_bignum(&auth->identities, key->rsa->e);
                 buffer_get_bignum(&auth->identities, key->rsa->n);                  buffer_get_bignum(&auth->identities, key->rsa->n);
Line 288 
Line 301 
         case 2:          case 2:
                 blob = buffer_get_string(&auth->identities, &blen);                  blob = buffer_get_string(&auth->identities, &blen);
                 *comment = buffer_get_string(&auth->identities, NULL);                  *comment = buffer_get_string(&auth->identities, NULL);
                 key = dsa_key_from_blob(blob, blen);                  key = key_from_blob(blob, blen);
                 xfree(blob);                  xfree(blob);
                 break;                  break;
         default:          default:
Line 311 
Line 324 
 int  int
 ssh_decrypt_challenge(AuthenticationConnection *auth,  ssh_decrypt_challenge(AuthenticationConnection *auth,
     Key* key, BIGNUM *challenge,      Key* key, BIGNUM *challenge,
     unsigned char session_id[16],      u_char session_id[16],
     unsigned int response_type,      u_int response_type,
     unsigned char response[16])      u_char response[16])
 {  {
         Buffer buffer;          Buffer buffer;
         int success = 0;          int success = 0;
         int i;          int i;
         int type;          int type;
   
         if (key->type != KEY_RSA)          if (key->type != KEY_RSA1)
                 return 0;                  return 0;
         if (response_type == 0) {          if (response_type == 0) {
                 log("Compatibility with ssh protocol version 1.0 no longer supported.");                  log("Compatibility with ssh protocol version 1.0 no longer supported.");
Line 362 
Line 375 
 int  int
 ssh_agent_sign(AuthenticationConnection *auth,  ssh_agent_sign(AuthenticationConnection *auth,
     Key *key,      Key *key,
     unsigned char **sigp, int *lenp,      u_char **sigp, int *lenp,
     unsigned char *data, int datalen)      u_char *data, int datalen)
 {  {
         extern int datafellows;          extern int datafellows;
         Buffer msg;          Buffer msg;
         unsigned char *blob;          u_char *blob;
         unsigned int blen;          u_int blen;
         int type, flags = 0;          int type, flags = 0;
         int ret = -1;          int ret = -1;
   
         if (dsa_make_key_blob(key, &blob, &blen) == 0)          if (key_to_blob(key, &blob, &blen) == 0)
                 return -1;                  return -1;
   
         if (datafellows & SSH_BUG_SIGBLOB)          if (datafellows & SSH_BUG_SIGBLOB)
Line 405 
Line 418 
 /* Encode key for a message to the agent. */  /* Encode key for a message to the agent. */
   
 void  void
 ssh_encode_identity_rsa(Buffer *b, RSA *key, const char *comment)  ssh_encode_identity_rsa1(Buffer *b, RSA *key, const char *comment)
 {  {
         buffer_clear(b);          buffer_clear(b);
         buffer_put_char(b, SSH_AGENTC_ADD_RSA_IDENTITY);          buffer_put_char(b, SSH_AGENTC_ADD_RSA_IDENTITY);
Line 421 
Line 434 
 }  }
   
 void  void
 ssh_encode_identity_dsa(Buffer *b, DSA *key, const char *comment)  ssh_encode_identity_ssh2(Buffer *b, Key *key, const char *comment)
 {  {
         buffer_clear(b);          buffer_clear(b);
         buffer_put_char(b, SSH2_AGENTC_ADD_IDENTITY);          buffer_put_char(b, SSH2_AGENTC_ADD_IDENTITY);
         buffer_put_cstring(b, KEX_DSS);          buffer_put_cstring(b, key_ssh_name(key));
         buffer_put_bignum2(b, key->p);          switch(key->type){
         buffer_put_bignum2(b, key->q);          case KEY_RSA:
         buffer_put_bignum2(b, key->g);                  buffer_put_bignum2(b, key->rsa->n);
         buffer_put_bignum2(b, key->pub_key);                  buffer_put_bignum2(b, key->rsa->e);
         buffer_put_bignum2(b, key->priv_key);                  buffer_put_bignum2(b, key->rsa->d);
         buffer_put_string(b, comment, strlen(comment));                  buffer_put_bignum2(b, key->rsa->iqmp);
                   buffer_put_bignum2(b, key->rsa->p);
                   buffer_put_bignum2(b, key->rsa->q);
                   break;
           case KEY_DSA:
                   buffer_put_bignum2(b, key->dsa->p);
                   buffer_put_bignum2(b, key->dsa->q);
                   buffer_put_bignum2(b, key->dsa->g);
                   buffer_put_bignum2(b, key->dsa->pub_key);
                   buffer_put_bignum2(b, key->dsa->priv_key);
                   break;
           }
           buffer_put_cstring(b, comment);
 }  }
   
 /*  /*
Line 448 
Line 473 
         buffer_init(&msg);          buffer_init(&msg);
   
         switch (key->type) {          switch (key->type) {
         case KEY_RSA:          case KEY_RSA1:
                 ssh_encode_identity_rsa(&msg, key->rsa, comment);                  ssh_encode_identity_rsa1(&msg, key->rsa, comment);
                 break;                  break;
           case KEY_RSA:
         case KEY_DSA:          case KEY_DSA:
                 ssh_encode_identity_dsa(&msg, key->dsa, comment);                  ssh_encode_identity_ssh2(&msg, key, comment);
                 break;                  break;
         default:          default:
                 buffer_free(&msg);                  buffer_free(&msg);
Line 478 
Line 504 
 {  {
         Buffer msg;          Buffer msg;
         int type;          int type;
         unsigned char *blob;          u_char *blob;
         unsigned int blen;          u_int blen;
   
         buffer_init(&msg);          buffer_init(&msg);
   
         if (key->type == KEY_RSA) {          if (key->type == KEY_RSA1) {
                 buffer_put_char(&msg, SSH_AGENTC_REMOVE_RSA_IDENTITY);                  buffer_put_char(&msg, SSH_AGENTC_REMOVE_RSA_IDENTITY);
                 buffer_put_int(&msg, BN_num_bits(key->rsa->n));                  buffer_put_int(&msg, BN_num_bits(key->rsa->n));
                 buffer_put_bignum(&msg, key->rsa->e);                  buffer_put_bignum(&msg, key->rsa->e);
                 buffer_put_bignum(&msg, key->rsa->n);                  buffer_put_bignum(&msg, key->rsa->n);
         } else if (key->type == KEY_DSA) {          } else if (key->type == KEY_DSA || key->type == KEY_RSA) {
                 dsa_make_key_blob(key, &blob, &blen);                  key_to_blob(key, &blob, &blen);
                 buffer_put_char(&msg, SSH2_AGENTC_REMOVE_IDENTITY);                  buffer_put_char(&msg, SSH2_AGENTC_REMOVE_IDENTITY);
                 buffer_put_string(&msg, blob, blen);                  buffer_put_string(&msg, blob, blen);
                 xfree(blob);                  xfree(blob);
Line 532 
Line 558 
         return decode_reply(type);          return decode_reply(type);
 }  }
   
 int  int
 decode_reply(int type)  decode_reply(int type)
 {  {
         switch (type) {          switch (type) {
Legend:
Removed from v.1.29  
changed lines
  Added in v.1.29.2.3