[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.30

version 1.29, 2000/10/09 21:51:00 version 1.30, 2000/11/12 19:50:37
Line 50 
Line 50 
 #include "key.h"  #include "key.h"
 #include "authfd.h"  #include "authfd.h"
 #include "kex.h"  #include "kex.h"
 #include "dsa.h"  
 #include "compat.h"  #include "compat.h"
   
 /* helper */  /* helper */
Line 207 
Line 206 
  * 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 222 
                 code2 = SSH2_AGENT_IDENTITIES_ANSWER;                  code2 = SSH2_AGENT_IDENTITIES_ANSWER;
                 break;                  break;
         default:          default:
                 return NULL;                  return 0;
         }          }
   
         /*          /*
Line 236 
Line 235 
         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 254 
Line 253 
                 fatal("Too many identities in authentication reply: %d\n",                  fatal("Too many identities in authentication reply: %d\n",
                     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;          unsigned int bits;
Line 276 
Line 283 
          */           */
         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 295 
         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 320 
Line 327 
         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 372 
Line 379 
         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 412 
 /* 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 428 
 }  }
   
 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 467 
         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 483 
Line 503 
   
         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);
Legend:
Removed from v.1.29  
changed lines
  Added in v.1.30