src/usr.bin/ssh/authfile.c - diff

Return to authfile.c CVS log

Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/authfile.c between version 1.2 and 1.3

version 1.2, 1999/09/26 21:02:15

version 1.3, 1999/09/28 04:45:35

Line 17

#include "includes.h"

RCSID("$Id$");

#include <gmp.h>

#include <ssl/bn.h>

#include "xmalloc.h"

#include "buffer.h"

#include "bufaux.h"

Line 32

will precede the key to provide identification of the key without

needing a passphrase. */

int save_private_key(const char *filename, const char *passphrase,

int

RSAPrivateKey *key, const char *comment,

save_private_key(const char *filename, const char *passphrase,

RandomState *state)

RSA *key, const char *comment)

{

Buffer buffer, encrypted;

char buf[100], *cp;

int f, i;

CipherContext cipher;

int cipher_type;

u_int32_t rand;

/* If the passphrase is empty, use SSH_CIPHER_NONE to ease converting to

another cipher; otherwise use SSH_AUTHFILE_CIPHER. */

Line 53

Line 54

buffer_init(&buffer);

/* Put checkbytes for checking passphrase validity. */

buf[0] = random_get_byte(state);

rand = arc4random();

buf[1] = random_get_byte(state);

buf[0] = rand & 0xff;

buf[1] = (rand >> 8) & 0xff;

buf[2] = buf[0];

buf[3] = buf[1];

buffer_append(&buffer, buf, 4);

Line 62

Line 64

/* Store the private key (n and e will not be stored because they will

be stored in plain text, and storing them also in encrypted format

would just give known plaintext). */

buffer_put_mp_int(&buffer, &key->d);

buffer_put_bignum(&buffer, key->d);

buffer_put_mp_int(&buffer, &key->u);

buffer_put_bignum(&buffer, key->iqmp);

buffer_put_mp_int(&buffer, &key->p);

buffer_put_bignum(&buffer, key->q); /* reverse from SSL p */

buffer_put_mp_int(&buffer, &key->q);

buffer_put_bignum(&buffer, key->p); /* reverse from SSL q */

/* Pad the part to be encrypted until its size is a multiple of 8. */

while (buffer_len(&buffer) % 8 != 0)

Line 85

Line 87

buffer_put_int(&encrypted, 0); /* For future extension */

/* Store public key. This will be in plain text. */

buffer_put_int(&encrypted, key->bits);

buffer_put_int(&encrypted, BN_num_bits(key->n));

buffer_put_mp_int(&encrypted, &key->n);

buffer_put_bignum(&encrypted, key->n);

buffer_put_mp_int(&encrypted, &key->e);

buffer_put_bignum(&encrypted, key->e);

buffer_put_string(&encrypted, comment, strlen(comment));

/* Allocate space for the private part of the key in the buffer. */

Line 127

Line 129

was encountered (the file does not exist or is not readable), and

non-zero otherwise. */

int load_public_key(const char *filename, RSAPublicKey *pub,

int

char **comment_return)

load_public_key(const char *filename, RSA *pub,

char **comment_return)

{

int f, i;

unsigned long len;

Line 179

Line 182

(void)buffer_get_int(&buffer); /* reserved */

/* Read the public key from the buffer. */

pub->bits = buffer_get_int(&buffer);

buffer_get_int(&buffer);

mpz_init(&pub->n);

pub->n = BN_new();

buffer_get_mp_int(&buffer, &pub->n);

buffer_get_bignum(&buffer, pub->n);

mpz_init(&pub->e);

pub->e = BN_new();

buffer_get_mp_int(&buffer, &pub->e);

buffer_get_bignum(&buffer, pub->e);

if (comment_return)

*comment_return = buffer_get_string(&buffer, NULL);

/* The encrypted private part is not parsed by this function. */

Line 197

Line 200

(file does not exist or is not readable, or passphrase is bad).

This initializes the private key. */

int load_private_key(const char *filename, const char *passphrase,

int

RSAPrivateKey *prv, char **comment_return)

load_private_key(const char *filename, const char *passphrase,

RSA *prv, char **comment_return)

{

int f, i, check1, check2, cipher_type;

unsigned long len;

Buffer buffer, decrypted;

char *cp;

CipherContext cipher;

BN_CTX *ctx;

BIGNUM *aux;

/* Read the file into the buffer. */

f = open(filename, O_RDONLY);

Line 250

Line 256

(void)buffer_get_int(&buffer); /* Reserved data. */

/* Read the public key from the buffer. */

prv->bits = buffer_get_int(&buffer);

buffer_get_int(&buffer);

mpz_init(&prv->n);

prv->n = BN_new();

buffer_get_mp_int(&buffer, &prv->n);

buffer_get_bignum(&buffer, prv->n);

mpz_init(&prv->e);

prv->e = BN_new();

buffer_get_mp_int(&buffer, &prv->e);

buffer_get_bignum(&buffer, prv->e);

if (comment_return)

*comment_return = buffer_get_string(&buffer, NULL);

else

Line 291

Line 297

/* Bad passphrase. */

buffer_free(&decrypted);

fail:

mpz_clear(&prv->n);

BN_clear_free(prv->n);

mpz_clear(&prv->e);

BN_clear_free(prv->e);

if (comment_return)

xfree(*comment_return);

return 0;

}

/* Read the rest of the private key. */

mpz_init(&prv->d);

prv->d = BN_new();

buffer_get_mp_int(&decrypted, &prv->d);

buffer_get_bignum(&decrypted, prv->d);

mpz_init(&prv->u);

prv->iqmp = BN_new();

buffer_get_mp_int(&decrypted, &prv->u);

buffer_get_bignum(&decrypted, prv->iqmp); /* u */

mpz_init(&prv->p);

/* in SSL and SSH p and q are exchanged */

buffer_get_mp_int(&decrypted, &prv->p);

prv->q = BN_new();

mpz_init(&prv->q);

buffer_get_bignum(&decrypted, prv->q); /* p */

buffer_get_mp_int(&decrypted, &prv->q);

prv->p = BN_new();

buffer_get_bignum(&decrypted, prv->p); /* q */

ctx = BN_CTX_new();

aux = BN_new();

BN_sub(aux, prv->q, BN_value_one());

prv->dmq1 = BN_new();

BN_mod(prv->dmq1, prv->d, aux, ctx);

BN_sub(aux, prv->p, BN_value_one());

prv->dmp1 = BN_new();

BN_mod(prv->dmp1, prv->d, aux, ctx);

BN_clear_free(aux);

BN_CTX_free(ctx);

buffer_free(&decrypted);