/* Copyright (C) 2009, 2010 Simon Josefsson

* Copyright (C) 2006, 2007 The Written Word, Inc. All rights reserved.

* Copyright (c) 2004-2006, Sara Golemon <sarag@libssh2.org>

*

* Author: Simon Josefsson

*

* Redistribution and use in source and binary forms,

* with or without modification, are permitted provided

* that the following conditions are met:

*

* Redistributions of source code must retain the above

* copyright notice, this list of conditions and the

* following disclaimer.

*

* Redistributions in binary form must reproduce the above

* copyright notice, this list of conditions and the following

* disclaimer in the documentation and/or other materials

* provided with the distribution.

*

* Neither the name of the copyright holder nor the names

* of any other contributors may be used to endorse or

* promote products derived from this software without

* specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE

* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY

* OF SUCH DAMAGE.

*/

#include "libssh2_priv.h"

#ifdef LIBSSH2_OPENSSL /* compile only if we build with openssl */

#include <string.h>

#include "misc.h"

#ifndef EVP_MAX_BLOCK_LENGTH

#define EVP_MAX_BLOCK_LENGTH 32

#endif

int

read_openssh_private_key_from_memory(void **key_ctx, LIBSSH2_SESSION *session,

const char *key_type,

const char *filedata,

size_t filedata_len,

unsigned const char *passphrase);

static unsigned char *

write_bn(unsigned char *buf, const BIGNUM *bn, int bn_bytes)

{

unsigned char *p = buf;

/* Left space for bn size which will be written below. */

p += 4;

*p = 0;

BN_bn2bin(bn, p + 1);

if(!(*(p + 1) & 0x80)) {

memmove(p, p + 1, --bn_bytes);

}

_libssh2_htonu32(p - 4, bn_bytes); /* Post write bn size. */

return p + bn_bytes;

}

int

_libssh2_rsa_new(libssh2_rsa_ctx ** rsa,

const unsigned char *edata,

unsigned long elen,

const unsigned char *ndata,

unsigned long nlen,

const unsigned char *ddata,

unsigned long dlen,

const unsigned char *pdata,

unsigned long plen,

const unsigned char *qdata,

unsigned long qlen,

const unsigned char *e1data,

unsigned long e1len,

const unsigned char *e2data,

unsigned long e2len,

const unsigned char *coeffdata, unsigned long coefflen)

{

BIGNUM * e;

BIGNUM * n;

BIGNUM * d = 0;

BIGNUM * p = 0;

BIGNUM * q = 0;

BIGNUM * dmp1 = 0;

BIGNUM * dmq1 = 0;

BIGNUM * iqmp = 0;

e = BN_new();

BN_bin2bn(edata, elen, e);

n = BN_new();

BN_bin2bn(ndata, nlen, n);

if(ddata) {

d = BN_new();

BN_bin2bn(ddata, dlen, d);

p = BN_new();

BN_bin2bn(pdata, plen, p);

q = BN_new();

BN_bin2bn(qdata, qlen, q);

dmp1 = BN_new();

BN_bin2bn(e1data, e1len, dmp1);

dmq1 = BN_new();

BN_bin2bn(e2data, e2len, dmq1);

iqmp = BN_new();

BN_bin2bn(coeffdata, coefflen, iqmp);

}

*rsa = RSA_new();

#ifdef HAVE_OPAQUE_STRUCTS

RSA_set0_key(*rsa, n, e, d);

#else

(*rsa)->e = e;

(*rsa)->n = n;

(*rsa)->d = d;

#endif

#ifdef HAVE_OPAQUE_STRUCTS

RSA_set0_factors(*rsa, p, q);

#else

(*rsa)->p = p;

(*rsa)->q = q;

#endif

#ifdef HAVE_OPAQUE_STRUCTS

RSA_set0_crt_params(*rsa, dmp1, dmq1, iqmp);

#else

(*rsa)->dmp1 = dmp1;

(*rsa)->dmq1 = dmq1;

(*rsa)->iqmp = iqmp;

#endif

return 0;

}

int

_libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsactx,

const unsigned char *sig,

unsigned long sig_len,

const unsigned char *m, unsigned long m_len)

{

unsigned char hash[SHA_DIGEST_LENGTH];

int ret;

if(_libssh2_sha1(m, m_len, hash))

return -1; /* failure */

ret = RSA_verify(NID_sha1, hash, SHA_DIGEST_LENGTH,

(unsigned char *) sig, sig_len, rsactx);

return (ret == 1) ? 0 : -1;

}

#if LIBSSH2_DSA

int

_libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,

const unsigned char *p,

unsigned long p_len,

const unsigned char *q,

unsigned long q_len,

const unsigned char *g,

unsigned long g_len,

const unsigned char *y,

unsigned long y_len,

const unsigned char *x, unsigned long x_len)

{

BIGNUM * p_bn;

BIGNUM * q_bn;

BIGNUM * g_bn;

BIGNUM * pub_key;

BIGNUM * priv_key = NULL;

p_bn = BN_new();

BN_bin2bn(p, p_len, p_bn);

q_bn = BN_new();

BN_bin2bn(q, q_len, q_bn);

g_bn = BN_new();

BN_bin2bn(g, g_len, g_bn);

pub_key = BN_new();

BN_bin2bn(y, y_len, pub_key);

if(x_len) {

priv_key = BN_new();

BN_bin2bn(x, x_len, priv_key);

}

*dsactx = DSA_new();

#ifdef HAVE_OPAQUE_STRUCTS

DSA_set0_pqg(*dsactx, p_bn, q_bn, g_bn);

#else

(*dsactx)->p = p_bn;

(*dsactx)->g = g_bn;

(*dsactx)->q = q_bn;

#endif

#ifdef HAVE_OPAQUE_STRUCTS

DSA_set0_key(*dsactx, pub_key, priv_key);

#else

(*dsactx)->pub_key = pub_key;

(*dsactx)->priv_key = priv_key;

#endif

return 0;

}

int

_libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,

const unsigned char *sig,

const unsigned char *m, unsigned long m_len)

{

unsigned char hash[SHA_DIGEST_LENGTH];

DSA_SIG * dsasig;

BIGNUM * r;

BIGNUM * s;

int ret = -1;

r = BN_new();

BN_bin2bn(sig, 20, r);

s = BN_new();

BN_bin2bn(sig + 20, 20, s);

dsasig = DSA_SIG_new();

#ifdef HAVE_OPAQUE_STRUCTS

DSA_SIG_set0(dsasig, r, s);

#else

dsasig->r = r;

dsasig->s = s;

#endif

if(!_libssh2_sha1(m, m_len, hash))

/* _libssh2_sha1() succeeded */

ret = DSA_do_verify(hash, SHA_DIGEST_LENGTH, dsasig, dsactx);

DSA_SIG_free(dsasig);

return (ret == 1) ? 0 : -1;

}

#endif /* LIBSSH_DSA */

#if LIBSSH2_ECDSA

/* _libssh2_ecdsa_get_curve_type

*

* returns key curve type that maps to libssh2_curve_type

*

*/

libssh2_curve_type

_libssh2_ecdsa_get_curve_type(libssh2_ecdsa_ctx *ec_ctx)

{

const EC_GROUP *group = EC_KEY_get0_group(ec_ctx);

return EC_GROUP_get_curve_name(group);

}

/* _libssh2_ecdsa_curve_type_from_name

*

* returns 0 for success, key curve type that maps to libssh2_curve_type

*

*/

int

_libssh2_ecdsa_curve_type_from_name(const char *name,

libssh2_curve_type *out_type)

{

int ret = 0;

libssh2_curve_type type;

if(name == NULL || strlen(name) != 19)

return -1;

if(strcmp(name, "ecdsa-sha2-nistp256") == 0)

type = LIBSSH2_EC_CURVE_NISTP256;

else if(strcmp(name, "ecdsa-sha2-nistp384") == 0)

type = LIBSSH2_EC_CURVE_NISTP384;

else if(strcmp(name, "ecdsa-sha2-nistp521") == 0)

type = LIBSSH2_EC_CURVE_NISTP521;

else {

ret = -1;

}

if(ret == 0 && out_type) {

*out_type = type;

}

return ret;

}

/* _libssh2_ecdsa_curve_name_with_octal_new

*

* Creates a new public key given an octal string, length and type

*

*/

int

_libssh2_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx ** ec_ctx,

const unsigned char *k,

size_t k_len, libssh2_curve_type curve)

{

int ret = 0;

const EC_GROUP *ec_group = NULL;

EC_KEY *ec_key = EC_KEY_new_by_curve_name(curve);

EC_POINT *point = NULL;

if(ec_key) {

ec_group = EC_KEY_get0_group(ec_key);

point = EC_POINT_new(ec_group);

ret = EC_POINT_oct2point(ec_group, point, k, k_len, NULL);

ret = EC_KEY_set_public_key(ec_key, point);

if(point != NULL)

EC_POINT_free(point);

if(ec_ctx != NULL)

*ec_ctx = ec_key;

}

return (ret == 1) ? 0 : -1;

}

#define LIBSSH2_ECDSA_VERIFY(digest_type) \

{ \

unsigned char hash[SHA##digest_type##_DIGEST_LENGTH]; \

libssh2_sha##digest_type(m, m_len, hash); \

ret = ECDSA_do_verify(hash, SHA##digest_type##_DIGEST_LENGTH, \

ecdsa_sig, ec_key); \

\

}

int

_libssh2_ecdsa_verify(libssh2_ecdsa_ctx * ctx,

const unsigned char *r, size_t r_len,

const unsigned char *s, size_t s_len,

const unsigned char *m, size_t m_len)

{

int ret = 0;

EC_KEY *ec_key = (EC_KEY*)ctx;

libssh2_curve_type type = _libssh2_ecdsa_get_curve_type(ec_key);

#ifdef HAVE_OPAQUE_STRUCTS

ECDSA_SIG *ecdsa_sig = ECDSA_SIG_new();

BIGNUM *pr = BN_new();

BIGNUM *ps = BN_new();

BN_bin2bn(r, r_len, pr);

BN_bin2bn(s, s_len, ps);

ECDSA_SIG_set0(ecdsa_sig, pr, ps);

#else

ECDSA_SIG ecdsa_sig_;

ECDSA_SIG *ecdsa_sig = &ecdsa_sig_;

ecdsa_sig_.r = BN_new();

BN_bin2bn(r, r_len, ecdsa_sig_.r);

ecdsa_sig_.s = BN_new();

BN_bin2bn(s, s_len, ecdsa_sig_.s);

#endif

if(type == LIBSSH2_EC_CURVE_NISTP256) {

LIBSSH2_ECDSA_VERIFY(256);

}

else if(type == LIBSSH2_EC_CURVE_NISTP384) {

LIBSSH2_ECDSA_VERIFY(384);

}

else if(type == LIBSSH2_EC_CURVE_NISTP521) {

LIBSSH2_ECDSA_VERIFY(512);

}

#ifdef HAVE_OPAQUE_STRUCTS

if(ecdsa_sig)

ECDSA_SIG_free(ecdsa_sig);

#else

BN_clear_free(ecdsa_sig_.s);

BN_clear_free(ecdsa_sig_.r);

#endif

return (ret == 1) ? 0 : -1;

}

#endif /* LIBSSH2_ECDSA */

int

_libssh2_cipher_init(_libssh2_cipher_ctx * h,

_libssh2_cipher_type(algo),

unsigned char *iv, unsigned char *secret, int encrypt)

{

#ifdef HAVE_OPAQUE_STRUCTS

*h = EVP_CIPHER_CTX_new();

return !EVP_CipherInit(*h, algo(), secret, iv, encrypt);

#else

EVP_CIPHER_CTX_init(h);

return !EVP_CipherInit(h, algo(), secret, iv, encrypt);

#endif

}

int

_libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,

_libssh2_cipher_type(algo),

int encrypt, unsigned char *block, size_t blocksize)

{

unsigned char buf[EVP_MAX_BLOCK_LENGTH];

int ret;

(void) algo;

(void) encrypt;

#ifdef HAVE_OPAQUE_STRUCTS

ret = EVP_Cipher(*ctx, buf, block, blocksize);

#else

ret = EVP_Cipher(ctx, buf, block, blocksize);

#endif

#if defined(OPENSSL_VERSION_MAJOR) && OPENSSL_VERSION_MAJOR >= 3

if(ret != -1) {

#else

if(ret == 1) {

#endif

memcpy(block, buf, blocksize);

}

#if defined(OPENSSL_VERSION_MAJOR) && OPENSSL_VERSION_MAJOR >= 3

return ret != -1 ? 0 : 1;

#else

return ret == 1 ? 0 : 1;

#endif

}

#if LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR)

#include <openssl/aes.h>

#include <openssl/evp.h>

typedef struct

{

AES_KEY key;

EVP_CIPHER_CTX *aes_ctx;

unsigned char ctr[AES_BLOCK_SIZE];

} aes_ctr_ctx;

static EVP_CIPHER * aes_128_ctr_cipher = NULL;

static EVP_CIPHER * aes_192_ctr_cipher = NULL;

static EVP_CIPHER * aes_256_ctr_cipher = NULL;

static int

aes_ctr_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,

const unsigned char *iv, int enc) /* init key */

{

/*

* variable "c" is leaked from this scope, but is later freed

* in aes_ctr_cleanup

*/

aes_ctr_ctx *c;

const EVP_CIPHER *aes_cipher;

(void) enc;

switch(EVP_CIPHER_CTX_key_length(ctx)) {

case 16:

aes_cipher = EVP_aes_128_ecb();

break;

case 24:

aes_cipher = EVP_aes_192_ecb();

break;

case 32:

aes_cipher = EVP_aes_256_ecb();

break;

default:

return 0;

}

c = malloc(sizeof(*c));

if(c == NULL)

return 0;

#ifdef HAVE_OPAQUE_STRUCTS

c->aes_ctx = EVP_CIPHER_CTX_new();

#else

c->aes_ctx = malloc(sizeof(EVP_CIPHER_CTX));

#endif

if(c->aes_ctx == NULL) {

free(c);

return 0;

}

if(EVP_EncryptInit(c->aes_ctx, aes_cipher, key, NULL) != 1) {

#ifdef HAVE_OPAQUE_STRUCTS

EVP_CIPHER_CTX_free(c->aes_ctx);

#else

free(c->aes_ctx);

#endif

free(c);

return 0;

}

EVP_CIPHER_CTX_set_padding(c->aes_ctx, 0);

memcpy(c->ctr, iv, AES_BLOCK_SIZE);

EVP_CIPHER_CTX_set_app_data(ctx, c);

return 1;

}

static int

aes_ctr_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,

const unsigned char *in,

size_t inl) /* encrypt/decrypt data */

{

aes_ctr_ctx *c = EVP_CIPHER_CTX_get_app_data(ctx);

unsigned char b1[AES_BLOCK_SIZE];

int outlen = 0;

if(inl != 16) /* libssh2 only ever encrypt one block */

return 0;

if(c == NULL) {

return 0;

}

/*

To encrypt a packet P=P1||P2||...||Pn (where P1, P2, ..., Pn are each

blocks of length L), the encryptor first encrypts <X> with <cipher>

to obtain a block B1. The block B1 is then XORed with P1 to generate

the ciphertext block C1. The counter X is then incremented

*/

if(EVP_EncryptUpdate(c->aes_ctx, b1, &outlen,

c->ctr, AES_BLOCK_SIZE) != 1) {

return 0;

}

_libssh2_xor_data(out, in, b1, AES_BLOCK_SIZE);

_libssh2_aes_ctr_increment(c->ctr, AES_BLOCK_SIZE);

return 1;

}

static int

aes_ctr_cleanup(EVP_CIPHER_CTX *ctx) /* cleanup ctx */

{

aes_ctr_ctx *c = EVP_CIPHER_CTX_get_app_data(ctx);

if(c == NULL) {

return 1;

}

if(c->aes_ctx != NULL) {

#ifdef HAVE_OPAQUE_STRUCTS

EVP_CIPHER_CTX_free(c->aes_ctx);

#else

_libssh2_cipher_dtor(c->aes_ctx);

free(c->aes_ctx);

#endif

}

free(c);

return 1;

}

static const EVP_CIPHER *

make_ctr_evp (size_t keylen, EVP_CIPHER **aes_ctr_cipher, int type)

{

#ifdef HAVE_OPAQUE_STRUCTS

*aes_ctr_cipher = EVP_CIPHER_meth_new(type, 16, keylen);

if(*aes_ctr_cipher) {

EVP_CIPHER_meth_set_iv_length(*aes_ctr_cipher, 16);

EVP_CIPHER_meth_set_init(*aes_ctr_cipher, aes_ctr_init);

EVP_CIPHER_meth_set_do_cipher(*aes_ctr_cipher, aes_ctr_do_cipher);

EVP_CIPHER_meth_set_cleanup(*aes_ctr_cipher, aes_ctr_cleanup);

}

#else

(*aes_ctr_cipher)->nid = type;

(*aes_ctr_cipher)->block_size = 16;

(*aes_ctr_cipher)->key_len = keylen;

(*aes_ctr_cipher)->iv_len = 16;

(*aes_ctr_cipher)->init = aes_ctr_init;

(*aes_ctr_cipher)->do_cipher = aes_ctr_do_cipher;

(*aes_ctr_cipher)->cleanup = aes_ctr_cleanup;

#endif

return *aes_ctr_cipher;

}

const EVP_CIPHER *

_libssh2_EVP_aes_128_ctr(void)

{

#ifdef HAVE_OPAQUE_STRUCTS

return !aes_128_ctr_cipher ?

make_ctr_evp(16, &aes_128_ctr_cipher, NID_aes_128_ctr) :

aes_128_ctr_cipher;

#else

static EVP_CIPHER aes_ctr_cipher;

if(!aes_128_ctr_cipher) {

aes_128_ctr_cipher = &aes_ctr_cipher;

make_ctr_evp(16, &aes_128_ctr_cipher, 0);

}

return aes_128_ctr_cipher;

#endif

}

const EVP_CIPHER *

_libssh2_EVP_aes_192_ctr(void)

{

#ifdef HAVE_OPAQUE_STRUCTS

return !aes_192_ctr_cipher ?

make_ctr_evp(24, &aes_192_ctr_cipher, NID_aes_192_ctr) :

aes_192_ctr_cipher;

#else

static EVP_CIPHER aes_ctr_cipher;

if(!aes_192_ctr_cipher) {

aes_192_ctr_cipher = &aes_ctr_cipher;

make_ctr_evp(24, &aes_192_ctr_cipher, 0);

}

return aes_192_ctr_cipher;

#endif

}

const EVP_CIPHER *

_libssh2_EVP_aes_256_ctr(void)

{

#ifdef HAVE_OPAQUE_STRUCTS

return !aes_256_ctr_cipher ?

make_ctr_evp(32, &aes_256_ctr_cipher, NID_aes_256_ctr) :

aes_256_ctr_cipher;

#else

static EVP_CIPHER aes_ctr_cipher;

if(!aes_256_ctr_cipher) {

aes_256_ctr_cipher = &aes_ctr_cipher;

make_ctr_evp(32, &aes_256_ctr_cipher, 0);

}

return aes_256_ctr_cipher;

#endif

}

#endif /* LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR) */

void _libssh2_openssl_crypto_init(void)

{

#if OPENSSL_VERSION_NUMBER >= 0x10100000L && \

!defined(LIBRESSL_VERSION_NUMBER)

#ifndef OPENSSL_NO_ENGINE

ENGINE_load_builtin_engines();

ENGINE_register_all_complete();

#endif

#else

OpenSSL_add_all_algorithms();

OpenSSL_add_all_ciphers();

OpenSSL_add_all_digests();

#ifndef OPENSSL_NO_ENGINE

ENGINE_load_builtin_engines();

ENGINE_register_all_complete();

#endif

#endif

#if LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR)

aes_128_ctr_cipher = (EVP_CIPHER *) _libssh2_EVP_aes_128_ctr();

aes_192_ctr_cipher = (EVP_CIPHER *) _libssh2_EVP_aes_192_ctr();

aes_256_ctr_cipher = (EVP_CIPHER *) _libssh2_EVP_aes_256_ctr();

#endif

}

void _libssh2_openssl_crypto_exit(void)

{

#if LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR)

#ifdef HAVE_OPAQUE_STRUCTS

if(aes_128_ctr_cipher) {

EVP_CIPHER_meth_free(aes_128_ctr_cipher);

}

if(aes_192_ctr_cipher) {

EVP_CIPHER_meth_free(aes_192_ctr_cipher);

}

if(aes_256_ctr_cipher) {

EVP_CIPHER_meth_free(aes_256_ctr_cipher);

}

#endif

aes_128_ctr_cipher = NULL;

aes_192_ctr_cipher = NULL;

aes_256_ctr_cipher = NULL;

#endif

}

/* TODO: Optionally call a passphrase callback specified by the

* calling program

*/

static int

passphrase_cb(char *buf, int size, int rwflag, char *passphrase)

{

int passphrase_len = strlen(passphrase);

(void) rwflag;

if(passphrase_len > (size - 1)) {

passphrase_len = size - 1;

}

memcpy(buf, passphrase, passphrase_len);

buf[passphrase_len] = '\0';

return passphrase_len;

}

typedef void * (*pem_read_bio_func)(BIO *, void **, pem_password_cb *,

void *u);

static int

read_private_key_from_memory(void **key_ctx,

pem_read_bio_func read_private_key,

const char *filedata,

size_t filedata_len,

unsigned const char *passphrase)

{

BIO * bp;

*key_ctx = NULL;

bp = BIO_new_mem_buf((char *)filedata, filedata_len);

if(!bp) {

return -1;

}

*key_ctx = read_private_key(bp, NULL, (pem_password_cb *) passphrase_cb,

(void *) passphrase);

BIO_free(bp);

return (*key_ctx) ? 0 : -1;

}

static int

read_private_key_from_file(void **key_ctx,

pem_read_bio_func read_private_key,

const char *filename,

unsigned const char *passphrase)

{

BIO * bp;

*key_ctx = NULL;

bp = BIO_new_file(filename, "r");

if(!bp) {

return -1;

}

*key_ctx = read_private_key(bp, NULL, (pem_password_cb *) passphrase_cb,

(void *) passphrase);

BIO_free(bp);

return (*key_ctx) ? 0 : -1;

}

int

_libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx ** rsa,

LIBSSH2_SESSION * session,

const char *filedata, size_t filedata_len,

unsigned const char *passphrase)

{

int rc;

pem_read_bio_func read_rsa =

(pem_read_bio_func) &PEM_read_bio_RSAPrivateKey;

_libssh2_init_if_needed();

rc = read_private_key_from_memory((void **) rsa, read_rsa,

filedata, filedata_len, passphrase);

if(rc) {

rc = read_openssh_private_key_from_memory((void **)rsa, session,

"ssh-rsa", filedata, filedata_len, passphrase);

}

return rc;

}

static unsigned char *

gen_publickey_from_rsa(LIBSSH2_SESSION *session, RSA *rsa,

size_t *key_len)

{

int e_bytes, n_bytes;

unsigned long len;

unsigned char *key;

unsigned char *p;

const BIGNUM * e;

const BIGNUM * n;

#ifdef HAVE_OPAQUE_STRUCTS

RSA_get0_key(rsa, &n, &e, NULL);

#else

e = rsa->e;

n = rsa->n;

#endif

e_bytes = BN_num_bytes(e) + 1;

n_bytes = BN_num_bytes(n) + 1;

/* Key form is "ssh-rsa" + e + n. */

len = 4 + 7 + 4 + e_bytes + 4 + n_bytes;

key = LIBSSH2_ALLOC(session, len);

if(key == NULL) {

return NULL;

}

/* Process key encoding. */

p = key;

_libssh2_htonu32(p, 7); /* Key type. */

p += 4;

memcpy(p, "ssh-rsa", 7);

p += 7;

p = write_bn(p, e, e_bytes);

p = write_bn(p, n, n_bytes);

*key_len = (size_t)(p - key);

return key;

}

static int

gen_publickey_from_rsa_evp(LIBSSH2_SESSION *session,

unsigned char **method,

size_t *method_len,

unsigned char **pubkeydata,

size_t *pubkeydata_len,

EVP_PKEY *pk)

{

RSA* rsa = NULL;

unsigned char *key;

unsigned char *method_buf = NULL;

size_t key_len;

_libssh2_debug(session,

LIBSSH2_TRACE_AUTH,

"Computing public key from RSA private key envelope");

rsa = EVP_PKEY_get1_RSA(pk);

if(rsa == NULL) {

/* Assume memory allocation error... what else could it be ? */

goto __alloc_error;

}

method_buf = LIBSSH2_ALLOC(session, 7); /* ssh-rsa. */

if(method_buf == NULL) {

goto __alloc_error;

}

key = gen_publickey_from_rsa(session, rsa, &key_len);

if(key == NULL) {

goto __alloc_error;

}

RSA_free(rsa);

memcpy(method_buf, "ssh-rsa", 7);

*method = method_buf;

*method_len = 7;

*pubkeydata = key;

*pubkeydata_len = key_len;

return 0;

__alloc_error:

if(rsa != NULL) {

RSA_free(rsa);

}

if(method_buf != NULL) {

LIBSSH2_FREE(session, method_buf);

}

return _libssh2_error(session,

LIBSSH2_ERROR_ALLOC,

"Unable to allocate memory for private key data");

}

static int _libssh2_rsa_new_additional_parameters(RSA *rsa)

{

BN_CTX *ctx = NULL;

BIGNUM *aux = NULL;

BIGNUM *dmp1 = NULL;

BIGNUM *dmq1 = NULL;

const BIGNUM *p = NULL;

const BIGNUM *q = NULL;

const BIGNUM *d = NULL;

int rc = 0;

#ifdef HAVE_OPAQUE_STRUCTS

RSA_get0_key(rsa, NULL, NULL, &d);

RSA_get0_factors(rsa, &p, &q);

#else

d = (*rsa).d;

p = (*rsa).p;

q = (*rsa).q;

#endif

ctx = BN_CTX_new();

if(ctx == NULL)

return -1;

aux = BN_new();

if(aux == NULL) {

rc = -1;

goto out;

}

dmp1 = BN_new();

if(dmp1 == NULL) {

rc = -1;

goto out;

}

dmq1 = BN_new();

if(dmq1 == NULL) {

rc = -1;

goto out;

}

if((BN_sub(aux, q, BN_value_one()) == 0) ||

(BN_mod(dmq1, d, aux, ctx) == 0) ||

(BN_sub(aux, p, BN_value_one()) == 0) ||

(BN_mod(dmp1, d, aux, ctx) == 0)) {

rc = -1;

goto out;

}

#ifdef HAVE_OPAQUE_STRUCTS

RSA_set0_crt_params(rsa, dmp1, dmq1, NULL);

#else

(*rsa).dmp1 = dmp1;

(*rsa).dmq1 = dmq1;

#endif

out:

if(aux)

BN_clear_free(aux);

BN_CTX_free(ctx);

if(rc != 0) {

if(dmp1)

BN_clear_free(dmp1);

if(dmq1)

BN_clear_free(dmq1);

}

return rc;

}

static int

gen_publickey_from_rsa_openssh_priv_data(LIBSSH2_SESSION *session,

struct string_buf *decrypted,

unsigned char **method,

size_t *method_len,

unsigned char **pubkeydata,

size_t *pubkeydata_len,

libssh2_rsa_ctx **rsa_ctx)

{

int rc = 0;

size_t nlen, elen, dlen, plen, qlen, coefflen, commentlen;

unsigned char *n, *e, *d, *p, *q, *coeff, *comment;

RSA *rsa = NULL;

_libssh2_debug(session,

LIBSSH2_TRACE_AUTH,

"Computing RSA keys from private key data");

/* public key data */

if(_libssh2_get_bignum_bytes(decrypted, &n, &nlen)) {

_libssh2_error(session, LIBSSH2_ERROR_PROTO,

"RSA no n");

return -1;

}

if(_libssh2_get_bignum_bytes(decrypted, &e, &elen)) {

_libssh2_error(session, LIBSSH2_ERROR_PROTO,

"RSA no e");

return -1;

}

/* private key data */

if(_libssh2_get_bignum_bytes(decrypted, &d, &dlen)) {

_libssh2_error(session, LIBSSH2_ERROR_PROTO,

"RSA no d");

return -1;

}

if(_libssh2_get_bignum_bytes(decrypted, &coeff, &coefflen)) {

_libssh2_error(session, LIBSSH2_ERROR_PROTO,

"RSA no coeff");