#include "config.h"

#ifdef HAVE_LIBGCRYPT

#include <assert.h>

#include <stdbool.h>

#include <string.h>

#include <stdlib.h>

#include <gcrypt.h>

#include <stdio.h>

#include "libssh/priv.h"

#include "libssh/buffer.h"

#include "libssh/session.h"

#include "libssh/wrapper.h"

#include "libssh/misc.h"

#include "libssh/pki.h"

#include "libssh/pki_priv.h"

#define MAXLINESIZE 80

#define RSA_HEADER_BEGIN "-----BEGIN RSA PRIVATE KEY-----"

#define RSA_HEADER_END "-----END RSA PRIVATE KEY-----"

#define DSA_HEADER_BEGIN "-----BEGIN DSA PRIVATE KEY-----"

#define DSA_HEADER_END "-----END DSA PRIVATE KEY-----"

#define ECDSA_HEADER_BEGIN "-----BEGIN EC PRIVATE KEY-----"

#define ECDSA_HEADER_END "-----END EC PRIVATE KEY-----"

#define MAX_KEY_SIZE 32

#define MAX_PASSPHRASE_SIZE 1024

#define ASN1_INTEGER 2

#define ASN1_BIT_STRING 3

#define ASN1_OCTET_STRING 4

#define ASN1_OBJECT_IDENTIFIER 6

#define ASN1_SEQUENCE 48

#define PKCS5_SALT_LEN 8

static int load_iv(const char *header, unsigned char *iv, int iv_len) {

int i;

int j;

int k;

memset(iv, 0, iv_len);

for (i = 0; i < iv_len; i++) {

if ((header[2*i] >= '0') && (header[2*i] <= '9'))

j = header[2*i] - '0';

else if ((header[2*i] >= 'A') && (header[2*i] <= 'F'))

j = header[2*i] - 'A' + 10;

else if ((header[2*i] >= 'a') && (header[2*i] <= 'f'))

j = header[2*i] - 'a' + 10;

else

return -1;

if ((header[2*i+1] >= '0') && (header[2*i+1] <= '9'))

k = header[2*i+1] - '0';

else if ((header[2*i+1] >= 'A') && (header[2*i+1] <= 'F'))

k = header[2*i+1] - 'A' + 10;

else if ((header[2*i+1] >= 'a') && (header[2*i+1] <= 'f'))

k = header[2*i+1] - 'a' + 10;

else

return -1;

iv[i] = (j << 4) + k;

}

return 0;

}

static uint32_t char_to_u32(unsigned char *data, uint32_t size) {

uint32_t ret;

uint32_t i;

for (i = 0, ret = 0; i < size; ret = ret << 8, ret += data[i++])

;

return ret;

}

static uint32_t asn1_get_len(ssh_buffer buffer) {

uint32_t len;

unsigned char tmp[4];

if (ssh_buffer_get_data(buffer,tmp,1) == 0) {

return 0;

}

if (tmp[0] > 127) {

len = tmp[0] & 127;

if (len > 4) {

return 0; /* Length doesn't fit in u32. Can this really happen? */

}

if (ssh_buffer_get_data(buffer,tmp,len) == 0) {

return 0;

}

len = char_to_u32(tmp, len);

} else {

len = char_to_u32(tmp, 1);

}

return len;

}

static ssh_string asn1_get(ssh_buffer buffer, unsigned char want) {

ssh_string str;

unsigned char type;

uint32_t size;

if (ssh_buffer_get_data(buffer, &type, 1) == 0 || type != want) {

return NULL;

}

size = asn1_get_len(buffer);

if (size == 0) {

return NULL;

}

str = ssh_string_new(size);

if (str == NULL) {

return NULL;

}

if (ssh_buffer_get_data(buffer, ssh_string_data(str), size) == 0) {

SSH_STRING_FREE(str);

return NULL;

}

return str;

}

static ssh_string asn1_get_int(ssh_buffer buffer) {

return asn1_get(buffer, ASN1_INTEGER);

}

static ssh_string asn1_get_bit_string(ssh_buffer buffer)

{

ssh_string str;

unsigned char type;

uint32_t size;

unsigned char unused, last, *p;

uint32_t len;

len = ssh_buffer_get_data(buffer, &type, 1);

if (len == 0 || type != ASN1_BIT_STRING) {

return NULL;

}

size = asn1_get_len(buffer);

if (size == 0) {

return NULL;

}

/* The first octet encodes the number of unused bits. */

size -= 1;

str = ssh_string_new(size);

if (str == NULL) {

return NULL;

}

len = ssh_buffer_get_data(buffer, &unused, 1);

if (len == 0) {

SSH_STRING_FREE(str);

return NULL;

}

if (unused == 0) {

len = ssh_buffer_get_data(buffer, ssh_string_data(str), size);

if (len == 0) {

SSH_STRING_FREE(str);

return NULL;

}

return str;

}

/* The bit string is padded at the end, we must shift the whole

for (p = ssh_string_data(str), last = 0; size; size--, p++) {

unsigned char c;

len = ssh_buffer_get_data(buffer, &c, 1);

if (len == 0) {

SSH_STRING_FREE(str);

return NULL;

}

*p = last | (c >> unused);

last = c << (8 - unused);

}

return str;

}

static int asn1_check_sequence(ssh_buffer buffer) {

unsigned char *j = NULL;

unsigned char tmp;

int i;

uint32_t size;

uint32_t padding;

if (ssh_buffer_get_data(buffer, &tmp, 1) == 0 || tmp != ASN1_SEQUENCE) {

return 0;

}

size = asn1_get_len(buffer);

if ((padding = ssh_buffer_get_len(buffer) - size) > 0) {

for (i = ssh_buffer_get_len(buffer) - size,

j = (unsigned char*)ssh_buffer_get(buffer) + size;

i;

i--, j++)

{

if (*j != padding) { /* padding is allowed */

return 0; /* but nothing else */

}

}

}

return 1;

}

static int asn1_check_tag(ssh_buffer buffer, unsigned char tag) {

unsigned char tmp;

uint32_t len;

len = ssh_buffer_get_data(buffer, &tmp, 1);

if (len == 0 || tmp != tag) {

return 0;

}

(void) asn1_get_len(buffer);

return 1;

}

static int passphrase_to_key(char *data, unsigned int datalen,

unsigned char *salt, unsigned char *key, unsigned int keylen) {

MD5CTX md;

unsigned char digest[MD5_DIGEST_LEN] = {0};

unsigned int i;

unsigned int j;

unsigned int md_not_empty;

for (j = 0, md_not_empty = 0; j < keylen; ) {

md = md5_init();

if (md == NULL) {

return -1;

}

if (md_not_empty) {

md5_update(md, digest, MD5_DIGEST_LEN);

} else {

md_not_empty = 1;

}

md5_update(md, data, datalen);

if (salt) {

md5_update(md, salt, PKCS5_SALT_LEN);

}

md5_final(digest, md);

for (i = 0; j < keylen && i < MD5_DIGEST_LEN; j++, i++) {

if (key) {

key[j] = digest[i];

}

}

}

return 0;

}

static int privatekey_decrypt(int algo, int mode, unsigned int key_len,

const char *desc)

{

char passphrase[MAX_PASSPHRASE_SIZE] = {0};

unsigned char key[MAX_KEY_SIZE] = {0};

unsigned char *tmp = NULL;

gcry_cipher_hd_t cipher;

int rc = -1;

if (!algo) {

return -1;

}

if (cb) {

rc = (*cb)(desc, passphrase, MAX_PASSPHRASE_SIZE, 0, 0, userdata);

if (rc < 0) {

return -1;

}

} else if (cb == NULL && userdata != NULL) {

snprintf(passphrase, MAX_PASSPHRASE_SIZE, "%s", (char *) userdata);

}

if (passphrase_to_key(passphrase, strlen(passphrase), iv, key, key_len) < 0) {

return -1;

}

if (gcry_cipher_open(&cipher, algo, mode, 0)

|| gcry_cipher_setkey(cipher, key, key_len)

|| gcry_cipher_setiv(cipher, iv, iv_len)

|| (tmp = calloc(ssh_buffer_get_len(data), sizeof(unsigned char))) == NULL

|| gcry_cipher_decrypt(cipher, tmp, ssh_buffer_get_len(data),

ssh_buffer_get(data), ssh_buffer_get_len(data))) {

gcry_cipher_close(cipher);

return -1;

}

memcpy(ssh_buffer_get(data), tmp, ssh_buffer_get_len(data));

SAFE_FREE(tmp);

gcry_cipher_close(cipher);

return 0;

}

static int privatekey_dek_header(const char *header, unsigned int header_len,

int *algo, int *mode, unsigned int *key_len, unsigned char **iv,

unsigned int *iv_len) {

unsigned int iv_pos;

if (header_len > 13 && !strncmp("DES-EDE3-CBC", header, 12))

{

*algo = GCRY_CIPHER_3DES;

iv_pos = 13;

*mode = GCRY_CIPHER_MODE_CBC;

*key_len = 24;

*iv_len = 8;

}

else if (header_len > 8 && !strncmp("DES-CBC", header, 7))

{

*algo = GCRY_CIPHER_DES;

iv_pos = 8;

*mode = GCRY_CIPHER_MODE_CBC;

*key_len = 8;

*iv_len = 8;

}

else if (header_len > 12 && !strncmp("AES-128-CBC", header, 11))

{

*algo = GCRY_CIPHER_AES128;

iv_pos = 12;

*mode = GCRY_CIPHER_MODE_CBC;

*key_len = 16;

*iv_len = 16;

}

else if (header_len > 12 && !strncmp("AES-192-CBC", header, 11))

{

*algo = GCRY_CIPHER_AES192;

iv_pos = 12;

*mode = GCRY_CIPHER_MODE_CBC;

*key_len = 24;

*iv_len = 16;

}

else if (header_len > 12 && !strncmp("AES-256-CBC", header, 11))

{

*algo = GCRY_CIPHER_AES256;

iv_pos = 12;

*mode = GCRY_CIPHER_MODE_CBC;

*key_len = 32;

*iv_len = 16;

} else {

return -1;

}

*iv = malloc(*iv_len);

if (*iv == NULL) {

return -1;

}

return load_iv(header + iv_pos, *iv, *iv_len);

}

#define get_next_line(p, len) { \

while(p[len] == '\n' || p[len] == '\r') /* skip empty lines */ \

len++; \

if(p[len] == '\0') /* EOL */ \

eol = true; \

else /* calculate length */ \

for(p += len, len = 0; p[len] && p[len] != '\n' \

&& p[len] != '\r'; len++); \

}

static ssh_buffer privatekey_string_to_buffer(const char *pkey, int type,

ssh_auth_callback cb, void *userdata, const char *desc) {

ssh_buffer buffer = NULL;

ssh_buffer out = NULL;

const char *p;

unsigned char *iv = NULL;

const char *header_begin;

const char *header_end;

unsigned int header_begin_size;

unsigned int header_end_size;

unsigned int key_len = 0;

unsigned int iv_len = 0;

int algo = 0;

int mode = 0;

bool eol = false;

size_t len;

buffer = ssh_buffer_new();

if (buffer == NULL) {

return NULL;

}

switch(type) {

case SSH_KEYTYPE_DSS:

header_begin = DSA_HEADER_BEGIN;

header_end = DSA_HEADER_END;

break;

case SSH_KEYTYPE_RSA:

header_begin = RSA_HEADER_BEGIN;

header_end = RSA_HEADER_END;

break;

case SSH_KEYTYPE_ECDSA_P256:

case SSH_KEYTYPE_ECDSA_P384:

case SSH_KEYTYPE_ECDSA_P521:

header_begin = ECDSA_HEADER_BEGIN;

header_end = ECDSA_HEADER_END;

break;

default:

SSH_BUFFER_FREE(buffer);

return NULL;

}

header_begin_size = strlen(header_begin);

header_end_size = strlen(header_end);

p = pkey;

len = 0;

get_next_line(p, len);

while(!eol && strncmp(p, header_begin, header_begin_size)) {

/* skip line */

get_next_line(p, len);

}

if (eol) {

SSH_BUFFER_FREE(buffer);

return NULL;

}

/* skip header line */

get_next_line(p, len);

if (eol) {

SSH_BUFFER_FREE(buffer);

return NULL;

}

if (len > 11 && strncmp("Proc-Type: 4,ENCRYPTED", p, 11) == 0) {

/* skip line */

get_next_line(p, len);

if (eol) {

SSH_BUFFER_FREE(buffer);

return NULL;

}

if (len > 10 && strncmp("DEK-Info: ", p, 10) == 0) {

p += 10;

len = 0;

get_next_line(p, len);

if (eol) {

SSH_BUFFER_FREE(buffer);

return NULL;

}

if (privatekey_dek_header(p, len, &algo, &mode, &key_len,

&iv, &iv_len) < 0) {

SSH_BUFFER_FREE(buffer);

SAFE_FREE(iv);

return NULL;

}

} else {

SSH_BUFFER_FREE(buffer);

SAFE_FREE(iv);

return NULL;

}

} else {

if(len > 0) {

if (ssh_buffer_add_data(buffer, p, len) < 0) {

SSH_BUFFER_FREE(buffer);

SAFE_FREE(iv);

return NULL;

}

}

}

get_next_line(p, len);

while(!eol && strncmp(p, header_end, header_end_size) != 0) {

if (ssh_buffer_add_data(buffer, p, len) < 0) {

SSH_BUFFER_FREE(buffer);

SAFE_FREE(iv);

return NULL;

}

get_next_line(p, len);

}

if (eol || strncmp(p, header_end, header_end_size) != 0) {

SSH_BUFFER_FREE(buffer);

SAFE_FREE(iv);

return NULL;

}

if (ssh_buffer_add_data(buffer, "\0", 1) < 0) {

SSH_BUFFER_FREE(buffer);

SAFE_FREE(iv);

return NULL;

}

out = base64_to_bin(ssh_buffer_get(buffer));

SSH_BUFFER_FREE(buffer);

if (out == NULL) {

SAFE_FREE(iv);

return NULL;

}

if (algo) {

if (privatekey_decrypt(algo, mode, key_len, iv, iv_len, out,

cb, userdata, desc) < 0) {

SSH_BUFFER_FREE(out);

SAFE_FREE(iv);

return NULL;

}

}

SAFE_FREE(iv);

return out;

}

static int b64decode_rsa_privatekey(const char *pkey, gcry_sexp_t *r,

ssh_auth_callback cb, void *userdata, const char *desc) {

const unsigned char *data;

ssh_string n = NULL;

ssh_string e = NULL;

ssh_string d = NULL;

ssh_string p = NULL;

ssh_string q = NULL;

ssh_string unused1 = NULL;

ssh_string unused2 = NULL;

ssh_string u = NULL;

ssh_string v = NULL;

ssh_buffer buffer = NULL;

int rc = 1;

buffer = privatekey_string_to_buffer(pkey, SSH_KEYTYPE_RSA, cb, userdata, desc);

if (buffer == NULL) {

return 0;

}

if (!asn1_check_sequence(buffer)) {

SSH_BUFFER_FREE(buffer);

return 0;

}

v = asn1_get_int(buffer);

if (v == NULL) {

SSH_BUFFER_FREE(buffer);

return 0;

}

data = ssh_string_data(v);

if (ssh_string_len(v) != 1 || data[0] != 0) {

SSH_STRING_FREE(v);

SSH_BUFFER_FREE(buffer);

return 0;

}

n = asn1_get_int(buffer);

e = asn1_get_int(buffer);

d = asn1_get_int(buffer);

q = asn1_get_int(buffer);

p = asn1_get_int(buffer);

unused1 = asn1_get_int(buffer);

unused2 = asn1_get_int(buffer);

u = asn1_get_int(buffer);

SSH_BUFFER_FREE(buffer);

if (n == NULL || e == NULL || d == NULL || p == NULL || q == NULL ||

unused1 == NULL || unused2 == NULL|| u == NULL) {

rc = 0;

goto error;

}

if (gcry_sexp_build(r, NULL,

"(private-key(rsa(n %b)(e %b)(d %b)(p %b)(q %b)(u %b)))",

ssh_string_len(n), ssh_string_data(n),

ssh_string_len(e), ssh_string_data(e),

ssh_string_len(d), ssh_string_data(d),

ssh_string_len(p), ssh_string_data(p),

ssh_string_len(q), ssh_string_data(q),

ssh_string_len(u), ssh_string_data(u))) {

rc = 0;

}

error:

ssh_string_burn(n);

SSH_STRING_FREE(n);

ssh_string_burn(e);

SSH_STRING_FREE(e);

ssh_string_burn(d);

SSH_STRING_FREE(d);

ssh_string_burn(p);

SSH_STRING_FREE(p);

ssh_string_burn(q);

SSH_STRING_FREE(q);

SSH_STRING_FREE(unused1);

SSH_STRING_FREE(unused2);

ssh_string_burn(u);

SSH_STRING_FREE(u);

SSH_STRING_FREE(v);

return rc;

}

static int b64decode_dsa_privatekey(const char *pkey, gcry_sexp_t *r, ssh_auth_callback cb,

void *userdata, const char *desc) {

const unsigned char *data;

ssh_buffer buffer = NULL;

ssh_string p = NULL;

ssh_string q = NULL;

ssh_string g = NULL;

ssh_string y = NULL;

ssh_string x = NULL;

ssh_string v = NULL;

int rc = 1;

buffer = privatekey_string_to_buffer(pkey, SSH_KEYTYPE_DSS, cb, userdata, desc);

if (buffer == NULL) {

return 0;

}

if (!asn1_check_sequence(buffer)) {

SSH_BUFFER_FREE(buffer);

return 0;

}

v = asn1_get_int(buffer);

if (v == NULL) {

SSH_BUFFER_FREE(buffer);

return 0;

}

data = ssh_string_data(v);

if (ssh_string_len(v) != 1 || data[0] != 0) {

SSH_STRING_FREE(v);

SSH_BUFFER_FREE(buffer);

return 0;

}

p = asn1_get_int(buffer);

q = asn1_get_int(buffer);

g = asn1_get_int(buffer);

y = asn1_get_int(buffer);

x = asn1_get_int(buffer);

SSH_BUFFER_FREE(buffer);

if (p == NULL || q == NULL || g == NULL || y == NULL || x == NULL) {

rc = 0;

goto error;

}

if (gcry_sexp_build(r, NULL,

"(private-key(dsa(p %b)(q %b)(g %b)(y %b)(x %b)))",

ssh_string_len(p), ssh_string_data(p),

ssh_string_len(q), ssh_string_data(q),

ssh_string_len(g), ssh_string_data(g),

ssh_string_len(y), ssh_string_data(y),

ssh_string_len(x), ssh_string_data(x))) {

rc = 0;

}

error:

ssh_string_burn(p);

SSH_STRING_FREE(p);

ssh_string_burn(q);

SSH_STRING_FREE(q);

ssh_string_burn(g);

SSH_STRING_FREE(g);

ssh_string_burn(y);

SSH_STRING_FREE(y);

ssh_string_burn(x);

SSH_STRING_FREE(x);

SSH_STRING_FREE(v);

return rc;

}

#ifdef HAVE_GCRYPT_ECC

static int pki_key_ecdsa_to_nid(gcry_sexp_t k)

{

gcry_sexp_t sexp;

const char *tmp;

size_t size;

sexp = gcry_sexp_find_token(k, "curve", 0);

if (sexp == NULL) {

return -1;

}

tmp = gcry_sexp_nth_data(sexp, 1, &size);

if (size == 10) {

int cmp;

cmp = memcmp("NIST P-256", tmp, size);

if (cmp == 0) {

gcry_sexp_release(sexp);

return NID_gcrypt_nistp256;

}

cmp = memcmp("NIST P-384", tmp, size);

if (cmp == 0) {

gcry_sexp_release(sexp);

return NID_gcrypt_nistp384;

}

cmp = memcmp("NIST P-521", tmp, size);

if (cmp == 0) {

gcry_sexp_release(sexp);

return NID_gcrypt_nistp521;

}

}

gcry_sexp_release(sexp);

return -1;

}

static enum ssh_keytypes_e pki_key_ecdsa_to_key_type(gcry_sexp_t k)

{

int nid;

nid = pki_key_ecdsa_to_nid(k);

switch (nid) {

case NID_gcrypt_nistp256:

return SSH_KEYTYPE_ECDSA_P256;

case NID_gcrypt_nistp384:

return SSH_KEYTYPE_ECDSA_P384;

case NID_gcrypt_nistp521:

return SSH_KEYTYPE_ECDSA_P521;

default:

return SSH_KEYTYPE_UNKNOWN;

}

}

static const char *pki_key_ecdsa_nid_to_gcrypt_name(int nid)

{

switch (nid) {

case NID_gcrypt_nistp256:

return "NIST P-256";

case NID_gcrypt_nistp384:

return "NIST P-384";

case NID_gcrypt_nistp521:

return "NIST P-521";

}

return "unknown";

}

const char *pki_key_ecdsa_nid_to_name(int nid)

{

switch (nid) {

case NID_gcrypt_nistp256:

return "ecdsa-sha2-nistp256";

case NID_gcrypt_nistp384:

return "ecdsa-sha2-nistp384";

case NID_gcrypt_nistp521:

return "ecdsa-sha2-nistp521";

}

return "unknown";

}

static const char *pki_key_ecdsa_nid_to_char(int nid)

{

switch (nid) {

case NID_gcrypt_nistp256:

return "nistp256";

case NID_gcrypt_nistp384:

return "nistp384";

case NID_gcrypt_nistp521:

return "nistp521";

default:

break;

}

return "unknown";

}

int pki_key_ecdsa_nid_from_name(const char *name)

{

int cmp;

cmp = strcmp(name, "nistp256");

if (cmp == 0) {

return NID_gcrypt_nistp256;

}

cmp = strcmp(name, "nistp384");

if (cmp == 0) {

return NID_gcrypt_nistp384;

}

cmp = strcmp(name, "nistp521");

if (cmp == 0) {

return NID_gcrypt_nistp521;

}

return -1;

}

static int asn1_oi_to_nid(const ssh_string oi)

{

static const struct {

int nid;

size_t length;

const char *identifier;

} *e, mapping[] = {

{NID_gcrypt_nistp256, 8, "\x2a\x86\x48\xce\x3d\x03\x01\x07"},

{NID_gcrypt_nistp384, 5, "\x2b\x81\x04\x00\x22"},

{NID_gcrypt_nistp521, 5, "\x2b\x81\x04\x00\x23"},

{0},

};

size_t len = ssh_string_len(oi);

for (e = mapping; e->length; e++) {

if (len == e->length

&& memcmp(ssh_string_data(oi), e->identifier, len) == 0) {

return e->nid;

}

}

return -1;

}

static int b64decode_ecdsa_privatekey(const char *pkey, gcry_sexp_t *r,

ssh_auth_callback cb,

void *userdata,

const char *desc)

{

const unsigned char *data;

ssh_buffer buffer = NULL;

gcry_error_t err = 0;

ssh_string v = NULL;

ssh_string d = NULL;

ssh_string oi = NULL;

int nid;

ssh_string q = NULL;

int valid = 0;

int ok;

buffer = privatekey_string_to_buffer(pkey,

SSH_KEYTYPE_ECDSA_P256,

cb,

userdata,

desc);

if (buffer == NULL) {

goto error;

}

ok = asn1_check_sequence(buffer);

if (!ok) {

goto error;

}

/* RFC5915 specifies version 1. */

v = asn1_get_int(buffer);

if (v == NULL) {

goto error;

}

data = ssh_string_data(v);

if (ssh_string_len(v) != 1 || data[0] != 1) {

goto error;

}

d = asn1_get(buffer, ASN1_OCTET_STRING);

if (!asn1_check_tag(buffer, 0xa0)) {

goto error;

}

oi = asn1_get(buffer, ASN1_OBJECT_IDENTIFIER);

nid = asn1_oi_to_nid(oi);

ok = asn1_check_tag(buffer, 0xa1);

if (!ok) {

goto error;

}

q = asn1_get_bit_string(buffer);

if (d == NULL || oi == NULL || nid == -1 || q == NULL) {

goto error;

}

err = gcry_sexp_build(r,

NULL,

"(private-key(ecdsa(curve %s)(d %b)(q %b)))",

pki_key_ecdsa_nid_to_gcrypt_name(nid),

ssh_string_len(d),

ssh_string_data(d),

ssh_string_len(q),

ssh_string_data(q));

if (err == 0) {

valid = 1;

}

error:

SSH_BUFFER_FREE(buffer);

SSH_STRING_FREE(v);

ssh_string_burn(d);

SSH_STRING_FREE(d);

SSH_STRING_FREE(oi);

ssh_string_burn(q);

SSH_STRING_FREE(q);

return valid;

}

ssh_string pki_private_key_to_pem(const ssh_key key,

const char *passphrase,

ssh_auth_callback auth_fn,

void *auth_data)

{

(void) key;

(void) passphrase;

(void) auth_fn;

(void) auth_data;

SSH_LOG(SSH_LOG_WARN, "PEM export not supported by gcrypt backend!");

return NULL;

}

ssh_key pki_private_key_from_base64(const char *b64_key,

const char *passphrase,

ssh_auth_callback auth_fn,

void *auth_data)

{

gcry_sexp_t dsa = NULL;

gcry_sexp_t rsa = NULL;

gcry_sexp_t ecdsa = NULL;

ssh_key key = NULL;

enum ssh_keytypes_e type;

int valid;

type = pki_privatekey_type_from_string(b64_key);

if (type == SSH_KEYTYPE_UNKNOWN) {

SSH_LOG(SSH_LOG_WARN, "Unknown or invalid private key.");

return NULL;

}

switch (type) {

case SSH_KEYTYPE_DSS:

if (passphrase == NULL) {

if (auth_fn) {

valid = b64decode_dsa_privatekey(b64_key, &dsa, auth_fn,

auth_data, "Passphrase for private key:");

} else {

valid = b64decode_dsa_privatekey(b64_key, &dsa, NULL, NULL,

NULL);

}

} else {

valid = b64decode_dsa_privatekey(b64_key, &dsa, NULL, (void *)

passphrase, NULL);

}

if (!valid) {

SSH_LOG(SSH_LOG_WARN, "Parsing private key");

goto fail;

}

break;

case SSH_KEYTYPE_RSA:

if (passphrase == NULL) {

if (auth_fn) {

valid = b64decode_rsa_privatekey(b64_key, &rsa, auth_fn,

auth_data, "Passphrase for private key:");

} else {

valid = b64decode_rsa_privatekey(b64_key, &rsa, NULL, NULL,

NULL);

}

} else {

valid = b64decode_rsa_privatekey(b64_key, &rsa, NULL,

(void *)passphrase, NULL);

}

if (!valid) {

SSH_LOG(SSH_LOG_WARN, "Parsing private key");

goto fail;