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

Diff for /src/usr.bin/ssh/ssh-keygen.c between version 1.52 and 1.53

version 1.52, 2001/03/26 08:07:09 version 1.53, 2001/03/26 23:23:24
Line 19 
Line 19 
   
 #include "xmalloc.h"  #include "xmalloc.h"
 #include "key.h"  #include "key.h"
   #include "rsa.h"
 #include "authfile.h"  #include "authfile.h"
 #include "uuencode.h"  #include "uuencode.h"
 #include "buffer.h"  #include "buffer.h"
Line 165 
Line 166 
 {  {
         int bits = buffer_get_int(b);          int bits = buffer_get_int(b);
         int bytes = (bits + 7) / 8;          int bytes = (bits + 7) / 8;
   
         if (buffer_len(b) < bytes)          if (buffer_len(b) < bytes)
                 fatal("buffer_get_bignum_bits: input buffer too small");                  fatal("buffer_get_bignum_bits: input buffer too small: "
                       "need %d have %d", bytes, buffer_len(b));
         BN_bin2bn((u_char *)buffer_ptr(b), bytes, value);          BN_bin2bn((u_char *)buffer_ptr(b), bytes, value);
         buffer_consume(b, bytes);          buffer_consume(b, bytes);
 }  }
Line 175 
Line 178 
 do_convert_private_ssh2_from_blob(char *blob, int blen)  do_convert_private_ssh2_from_blob(char *blob, int blen)
 {  {
         Buffer b;          Buffer b;
         DSA *dsa;  
         Key *key = NULL;          Key *key = NULL;
         int ignore, magic, rlen;          int ignore, magic, rlen, ktype;
         char *type, *cipher;          char *type, *cipher;
   
         buffer_init(&b);          buffer_init(&b);
Line 195 
Line 197 
         ignore = buffer_get_int(&b);          ignore = buffer_get_int(&b);
         ignore = buffer_get_int(&b);          ignore = buffer_get_int(&b);
         ignore = buffer_get_int(&b);          ignore = buffer_get_int(&b);
         xfree(type);  
   
         if (strcmp(cipher, "none") != 0) {          if (strcmp(cipher, "none") != 0) {
                 error("unsupported cipher %s", cipher);                  error("unsupported cipher %s", cipher);
                 xfree(cipher);                  xfree(cipher);
                 buffer_free(&b);                  buffer_free(&b);
                   xfree(type);
                 return NULL;                  return NULL;
         }          }
         xfree(cipher);          xfree(cipher);
   
         key = key_new(KEY_DSA);          if (strstr(type, "dsa")) {
         dsa = key->dsa;                  ktype = KEY_DSA;
         dsa->priv_key = BN_new();          } else if (strstr(type, "rsa")) {
         if (dsa->priv_key == NULL) {                  ktype = KEY_RSA;
                 error("alloc priv_key failed");          } else {
                 key_free(key);                  xfree(type);
                 return NULL;                  return NULL;
         }          }
         buffer_get_bignum_bits(&b, dsa->p);          key = key_new_private(ktype);
         buffer_get_bignum_bits(&b, dsa->g);          xfree(type);
         buffer_get_bignum_bits(&b, dsa->q);  
         buffer_get_bignum_bits(&b, dsa->pub_key);          switch (key->type) {
         buffer_get_bignum_bits(&b, dsa->priv_key);          case KEY_DSA:
                   buffer_get_bignum_bits(&b, key->dsa->p);
                   buffer_get_bignum_bits(&b, key->dsa->g);
                   buffer_get_bignum_bits(&b, key->dsa->q);
                   buffer_get_bignum_bits(&b, key->dsa->pub_key);
                   buffer_get_bignum_bits(&b, key->dsa->priv_key);
                   break;
           case KEY_RSA:
                   if (!BN_set_word(key->rsa->e, (u_long) buffer_get_char(&b))) {
                           buffer_free(&b);
                           key_free(key);
                           return NULL;
                   }
                   buffer_get_bignum_bits(&b, key->rsa->d);
                   buffer_get_bignum_bits(&b, key->rsa->n);
                   buffer_get_bignum_bits(&b, key->rsa->iqmp);
                   buffer_get_bignum_bits(&b, key->rsa->q);
                   buffer_get_bignum_bits(&b, key->rsa->p);
                   generate_additional_parameters(key->rsa);
                   break;
           }
         rlen = buffer_len(&b);          rlen = buffer_len(&b);
         if(rlen != 0)          if(rlen != 0)
                 error("do_convert_private_ssh2_from_blob: remaining bytes in key blob %d", rlen);                  error("do_convert_private_ssh2_from_blob: "
                       "remaining bytes in key blob %d", rlen);
         buffer_free(&b);          buffer_free(&b);
   #ifdef DEBUG_PK
           {
                   u_int slen;
                   u_char *sig, data[10] = "abcde12345";
   
                   key_sign(key, &sig, &slen, data, sizeof data);
                   key_verify(key, sig, slen, data, sizeof data);
                   free(sig);
           }
   #endif
         return key;          return key;
 }  }
   
Line 284 
Line 317 
                 exit(1);                  exit(1);
         }          }
         ok = private ?          ok = private ?
             PEM_write_DSAPrivateKey(stdout, k->dsa, NULL, NULL, 0, NULL, NULL) :              (k->type == KEY_DSA ?
                    PEM_write_DSAPrivateKey(stdout, k->dsa, NULL, NULL, 0, NULL, NULL) :
                    PEM_write_RSAPrivateKey(stdout, k->rsa, NULL, NULL, 0, NULL, NULL)) :
             key_write(k, stdout);              key_write(k, stdout);
         if (!ok) {          if (!ok) {
                 fprintf(stderr, "key write failed");                  fprintf(stderr, "key write failed");
Legend:
Removed from v.1.52  
changed lines
  Added in v.1.53