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

Diff for /src/usr.bin/ssh/Attic/key.c between version 1.43 and 1.43.2.2

version 1.43, 2002/03/19 10:49:35 version 1.43.2.2, 2002/10/11 14:51:52
Line 89 
Line 89 
         }          }
         return k;          return k;
 }  }
   
 Key *  Key *
 key_new_private(int type)  key_new_private(int type)
 {  {
Line 120 
Line 121 
         }          }
         return k;          return k;
 }  }
   
 void  void
 key_free(Key *k)  key_free(Key *k)
 {  {
Line 169 
Line 171 
         return 0;          return 0;
 }  }
   
 static u_char*  static u_char *
 key_fingerprint_raw(Key *k, enum fp_type dgst_type, u_int *dgst_raw_length)  key_fingerprint_raw(Key *k, enum fp_type dgst_type, u_int *dgst_raw_length)
 {  {
         const EVP_MD *md = NULL;          const EVP_MD *md = NULL;
Line 225 
Line 227 
         return retval;          return retval;
 }  }
   
 static char*  static char *
 key_fingerprint_hex(u_char* dgst_raw, u_int dgst_raw_len)  key_fingerprint_hex(u_char *dgst_raw, u_int dgst_raw_len)
 {  {
         char *retval;          char *retval;
         int i;          int i;
Line 242 
Line 244 
         return retval;          return retval;
 }  }
   
 static char*  static char *
 key_fingerprint_bubblebabble(u_char* dgst_raw, u_int dgst_raw_len)  key_fingerprint_bubblebabble(u_char *dgst_raw, u_int dgst_raw_len)
 {  {
         char vowels[] = { 'a', 'e', 'i', 'o', 'u', 'y' };          char vowels[] = { 'a', 'e', 'i', 'o', 'u', 'y' };
         char consonants[] = { 'b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm',          char consonants[] = { 'b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm',
Line 289 
Line 291 
         return retval;          return retval;
 }  }
   
 char*  char *
 key_fingerprint(Key *k, enum fp_type dgst_type, enum fp_rep dgst_rep)  key_fingerprint(Key *k, enum fp_type dgst_type, enum fp_rep dgst_rep)
 {  {
         char *retval = NULL;          char *retval = NULL;
Line 359 
Line 361 
         *cpp = cp;          *cpp = cp;
         return 1;          return 1;
 }  }
   
 static int  static int
 write_bignum(FILE *f, BIGNUM *num)  write_bignum(FILE *f, BIGNUM *num)
 {  {
Line 485 
Line 488 
         }          }
         return success;          return success;
 }  }
   
 int  int
 key_write(Key *key, FILE *f)  key_write(Key *key, FILE *f)
 {  {
         int n, success = 0;          int n, success = 0;
         u_int len, bits = 0;          u_int len, bits = 0;
         u_char *blob, *uu;          u_char *blob;
           char *uu;
   
         if (key->type == KEY_RSA1 && key->rsa != NULL) {          if (key->type == KEY_RSA1 && key->rsa != NULL) {
                 /* size of modulus 'n' */                  /* size of modulus 'n' */
Line 516 
Line 521 
         }          }
         return success;          return success;
 }  }
   
 char *  char *
 key_type(Key *k)  key_type(Key *k)
 {  {
Line 532 
Line 538 
         }          }
         return "unknown";          return "unknown";
 }  }
   
 char *  char *
 key_ssh_name(Key *k)  key_ssh_name(Key *k)
 {  {
Line 545 
Line 552 
         }          }
         return "ssh-unknown";          return "ssh-unknown";
 }  }
   
 u_int  u_int
 key_size(Key *k)  key_size(Key *k)
 {  {
Line 722 
Line 730 
 {  {
         Buffer b;          Buffer b;
         int len;          int len;
         u_char *buf;  
   
         if (key == NULL) {          if (key == NULL) {
                 error("key_to_blob: key == NULL");                  error("key_to_blob: key == NULL");
Line 748 
Line 755 
                 return 0;                  return 0;
         }          }
         len = buffer_len(&b);          len = buffer_len(&b);
         buf = xmalloc(len);  
         memcpy(buf, buffer_ptr(&b), len);  
         memset(buffer_ptr(&b), 0, len);  
         buffer_free(&b);  
         if (lenp != NULL)          if (lenp != NULL)
                 *lenp = len;                  *lenp = len;
         if (blobp != NULL)          if (blobp != NULL) {
                 *blobp = buf;                  *blobp = xmalloc(len);
                   memcpy(*blobp, buffer_ptr(&b), len);
           }
           memset(buffer_ptr(&b), 0, len);
           buffer_free(&b);
         return len;          return len;
 }  }
   
Line 779 
Line 786 
         }          }
 }  }
   
   /*
    * key_verify returns 1 for a correct signature, 0 for an incorrect signature
    * and -1 on error.
    */
 int  int
 key_verify(  key_verify(
     Key *key,      Key *key,
Line 803 
Line 814 
 }  }
   
 /* Converts a private to a public key */  /* Converts a private to a public key */
   
 Key *  Key *
 key_demote(Key *k)  key_demote(Key *k)
 {  {
Legend:
Removed from v.1.43  
changed lines
  Added in v.1.43.2.2