/*

 * pki_crypto.c - PKI infrastructure using OpenSSL

 *

 * This file is part of the SSH Library

 *

 * Copyright (c) 2003-2009 by Aris Adamantiadis

 * Copyright (c) 2009-2013 by Andreas Schneider <asn@cryptomilk.org>

 *

 * The SSH Library is free software; you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation; either version 2.1 of the License, or (at your

 * option) any later version.

 *

 * The SSH Library is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public

 * License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with the SSH Library; see the file COPYING.  If not, write to

 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,

 * MA 02111-1307, USA.

 */

#ifndef _PKI_CRYPTO_H

#define _PKI_CRYPTO_H

#include "config.h"

#include "libssh/priv.h"

#include <openssl/pem.h>

#include <openssl/dsa.h>

#include <openssl/err.h>

#include <openssl/rsa.h>

#include "libcrypto-compat.h"

#ifdef HAVE_OPENSSL_EC_H

#include <openssl/ec.h>

#endif

#ifdef HAVE_OPENSSL_ECDSA_H

#include <openssl/ecdsa.h>

#endif

#include "libssh/libssh.h"

#include "libssh/buffer.h"

#include "libssh/session.h"

#include "libssh/pki.h"

#include "libssh/pki_priv.h"

#include "libssh/bignum.h"

struct pem_get_password_struct {

    ssh_auth_callback fn;

    void *data;

};

static int pem_get_password(char *buf, int size, int rwflag, void *userdata) {

    struct pem_get_password_struct *pgp = userdata;

    (void) rwflag; /* unused */

    if (buf == NULL) {

        return 0;

    }

    memset(buf, '\0', size);

    if (pgp) {

        int rc;

        rc = pgp->fn("Passphrase for private key:",

                     buf, size, 0, 0,

                     pgp->data);

        if (rc == 0) {

            return strlen(buf);

        }

    }

    return 0;

}

#ifdef HAVE_OPENSSL_ECC

static int pki_key_ecdsa_to_nid(EC_KEY *k)

{

    const EC_GROUP *g = EC_KEY_get0_group(k);

    int nid;

    nid = EC_GROUP_get_curve_name(g);

    if (nid) {

        return nid;

    }

    return -1;

}

static enum ssh_keytypes_e pki_key_ecdsa_to_key_type(EC_KEY *k)

{

    int nid;

    nid = pki_key_ecdsa_to_nid(k);

    switch (nid) {

        case NID_X9_62_prime256v1:

            return SSH_KEYTYPE_ECDSA_P256;

        case NID_secp384r1:

            return SSH_KEYTYPE_ECDSA_P384;

        case NID_secp521r1:

            return SSH_KEYTYPE_ECDSA_P521;

        default:

            return SSH_KEYTYPE_UNKNOWN;

    }

}

const char *pki_key_ecdsa_nid_to_name(int nid)

{

    switch (nid) {

        case NID_X9_62_prime256v1:

            return "ecdsa-sha2-nistp256";

        case NID_secp384r1:

            return "ecdsa-sha2-nistp384";

        case NID_secp521r1:

            return "ecdsa-sha2-nistp521";

        default:

            break;

    }

    return "unknown";

}

static const char *pki_key_ecdsa_nid_to_char(int nid)

{

    switch (nid) {

        case NID_X9_62_prime256v1:

            return "nistp256";

        case NID_secp384r1:

            return "nistp384";

        case NID_secp521r1:

            return "nistp521";

        default:

            break;

    }

    return "unknown";

}

int pki_key_ecdsa_nid_from_name(const char *name)

{

    if (strcmp(name, "nistp256") == 0) {

        return NID_X9_62_prime256v1;

    } else if (strcmp(name, "nistp384") == 0) {

        return NID_secp384r1;

    } else if (strcmp(name, "nistp521") == 0) {

        return NID_secp521r1;

    }

    return -1;

}

static ssh_string make_ecpoint_string(const EC_GROUP *g,

                                      const EC_POINT *p)

{

    ssh_string s;

    size_t len;

    len = EC_POINT_point2oct(g,

                             p,

                             POINT_CONVERSION_UNCOMPRESSED,

                             NULL,

                             0,

                             NULL);

    if (len == 0) {

        return NULL;

    }

    s = ssh_string_new(len);

    if (s == NULL) {

        return NULL;

    }

    len = EC_POINT_point2oct(g,

                             p,

                             POINT_CONVERSION_UNCOMPRESSED,

                             ssh_string_data(s),

                             ssh_string_len(s),

                             NULL);

    if (len != ssh_string_len(s)) {

        SSH_STRING_FREE(s);

        return NULL;

    }

    return s;

}

int pki_privkey_build_ecdsa(ssh_key key, int nid, ssh_string e, ssh_string exp)

{

    EC_POINT *p = NULL;

    const EC_GROUP *g = NULL;

    int ok;

    BIGNUM *bexp = NULL;

    key->ecdsa_nid = nid;

    key->type_c = pki_key_ecdsa_nid_to_name(nid);

    key->ecdsa = EC_KEY_new_by_curve_name(key->ecdsa_nid);

    if (key->ecdsa == NULL) {

        return -1;

    }

    g = EC_KEY_get0_group(key->ecdsa);

    p = EC_POINT_new(g);

    if (p == NULL) {

        return -1;

    }

    ok = EC_POINT_oct2point(g,

                            p,

                            ssh_string_data(e),

                            ssh_string_len(e),

                            NULL);

    if (!ok) {

        EC_POINT_free(p);

        return -1;

    }

    /* EC_KEY_set_public_key duplicates p */

    ok = EC_KEY_set_public_key(key->ecdsa, p);

    EC_POINT_free(p);

    if (!ok) {

        return -1;

    }

    bexp = ssh_make_string_bn(exp);

    if (bexp == NULL) {

        EC_KEY_free(key->ecdsa);

        return -1;

    }

    /* EC_KEY_set_private_key duplicates exp */

    ok = EC_KEY_set_private_key(key->ecdsa, bexp);

    BN_free(bexp);

    if (!ok) {

        EC_KEY_free(key->ecdsa);

        return -1;

    }

    return 0;

}

int pki_pubkey_build_ecdsa(ssh_key key, int nid, ssh_string e)

{

    EC_POINT *p = NULL;

    const EC_GROUP *g = NULL;

    int ok;

    key->ecdsa_nid = nid;

    key->type_c = pki_key_ecdsa_nid_to_name(nid);

    key->ecdsa = EC_KEY_new_by_curve_name(key->ecdsa_nid);

    if (key->ecdsa == NULL) {

        return -1;

    }

    g = EC_KEY_get0_group(key->ecdsa);

    p = EC_POINT_new(g);

    if (p == NULL) {

        return -1;

    }

    ok = EC_POINT_oct2point(g,

                            p,

                            ssh_string_data(e),

                            ssh_string_len(e),

                            NULL);

    if (!ok) {

        EC_POINT_free(p);

        return -1;

    }

    /* EC_KEY_set_public_key duplicates p */

    ok = EC_KEY_set_public_key(key->ecdsa, p);

    EC_POINT_free(p);

    if (!ok) {

        return -1;

    }

    return 0;

}

#endif

ssh_key pki_key_dup(const ssh_key key, int demote)

{

    ssh_key new;

    int rc;

    new = ssh_key_new();

    if (new == NULL) {

        return NULL;

    }

    new->type = key->type;

    new->type_c = key->type_c;

    if (demote) {

        new->flags = SSH_KEY_FLAG_PUBLIC;

    } else {

        new->flags = key->flags;

    }

    switch (key->type) {

    case SSH_KEYTYPE_DSS: {

        const BIGNUM *p = NULL, *q = NULL, *g = NULL,

          *pub_key = NULL, *priv_key = NULL;

        BIGNUM *np, *nq, *ng, *npub_key, *npriv_key;

        new->dsa = DSA_new();

        if (new->dsa == NULL) {

            goto fail;

        }

        /*

         * p        = public prime number

         * q        = public 160-bit subprime, q | p-1

         * g        = public generator of subgroup

         * pub_key  = public key y = g^x

         * priv_key = private key x

         */

        DSA_get0_pqg(key->dsa, &p, &q, &g);

        np = BN_dup(p);

        nq = BN_dup(q);

        ng = BN_dup(g);

        if (np == NULL || nq == NULL || ng == NULL) {

            BN_free(np);

            BN_free(nq);

            BN_free(ng);

            goto fail;

        }

        /* Memory management of np, nq and ng is transferred to DSA object */

        rc = DSA_set0_pqg(new->dsa, np, nq, ng);

        if (rc == 0) {

            BN_free(np);

            BN_free(nq);

            BN_free(ng);

            goto fail;

        }

        DSA_get0_key(key->dsa, &pub_key, &priv_key);

        npub_key = BN_dup(pub_key);

        if (npub_key == NULL) {

            goto fail;

        }

        /* Memory management of npubkey is transferred to DSA object */

        rc = DSA_set0_key(new->dsa, npub_key, NULL);

        if (rc == 0) {

            goto fail;

        }

        if (!demote && (key->flags & SSH_KEY_FLAG_PRIVATE)) {

            npriv_key = BN_dup(priv_key);

            if (npriv_key == NULL) {

                goto fail;

            }

            /* Memory management of npriv_key is transferred to DSA object */

            rc = DSA_set0_key(new->dsa, NULL, npriv_key);

            if (rc == 0) {

                goto fail;

            }

        }

        break;

    }

    case SSH_KEYTYPE_RSA:

    case SSH_KEYTYPE_RSA1: {

        const BIGNUM *n = NULL, *e = NULL, *d = NULL;

        BIGNUM *nn, *ne, *nd;

        new->rsa = RSA_new();

        if (new->rsa == NULL) {

            goto fail;

        }

        /*

         * n    = public modulus

         * e    = public exponent

         * d    = private exponent

         * p    = secret prime factor

         * q    = secret prime factor

         * dmp1 = d mod (p-1)

         * dmq1 = d mod (q-1)

         * iqmp = q^-1 mod p

         */

        RSA_get0_key(key->rsa, &n, &e, &d);

        nn = BN_dup(n);

        ne = BN_dup(e);

        if (nn == NULL || ne == NULL) {

            BN_free(nn);

            BN_free(ne);

            goto fail;

        }

        /* Memory management of nn and ne is transferred to RSA object */

        rc = RSA_set0_key(new->rsa, nn, ne, NULL);

        if (rc == 0) {

            BN_free(nn);

            BN_free(ne);

            goto fail;

        }

        if (!demote && (key->flags & SSH_KEY_FLAG_PRIVATE)) {

            const BIGNUM *p = NULL, *q = NULL, *dmp1 = NULL,

              *dmq1 = NULL, *iqmp = NULL;

            BIGNUM *np, *nq, *ndmp1, *ndmq1, *niqmp;

            nd = BN_dup(d);

            if (nd == NULL) {

                goto fail;

            }

            /* Memory management of nd is transferred to RSA object */

            rc = RSA_set0_key(new->rsa, NULL, NULL, nd);

            if (rc == 0) {

                goto fail;

            }

            /* p, q, dmp1, dmq1 and iqmp may be NULL in private keys, but the

             * RSA operations are much faster when these values are available.

             */

            RSA_get0_factors(key->rsa, &p, &q);

            if (p != NULL && q != NULL) { /* need to set both of them */

                np = BN_dup(p);

                nq = BN_dup(q);

                if (np == NULL || nq == NULL) {

                    BN_free(np);

                    BN_free(nq);

                    goto fail;

                }

                /* Memory management of np and nq is transferred to RSA object */

                rc = RSA_set0_factors(new->rsa, np, nq);

                if (rc == 0) {

                    BN_free(np);

                    BN_free(nq);

                    goto fail;

                }

            }

            RSA_get0_crt_params(key->rsa, &dmp1, &dmq1, &iqmp);

            if (dmp1 != NULL || dmq1 != NULL || iqmp != NULL) {

                ndmp1 = BN_dup(dmp1);

                ndmq1 = BN_dup(dmq1);

                niqmp = BN_dup(iqmp);

                if (ndmp1 == NULL || ndmq1 == NULL || niqmp == NULL) {

                    BN_free(ndmp1);

                    BN_free(ndmq1);

                    BN_free(niqmp);

                    goto fail;

                }

                /* Memory management of ndmp1, ndmq1 and niqmp is transferred

                 * to RSA object */

                rc =  RSA_set0_crt_params(new->rsa, ndmp1, ndmq1, niqmp);

                if (rc == 0) {

                    BN_free(ndmp1);

                    BN_free(ndmq1);

                    BN_free(niqmp);

                    goto fail;

                }

            }

        }

        break;

    }

    case SSH_KEYTYPE_ECDSA_P256:

    case SSH_KEYTYPE_ECDSA_P384:

    case SSH_KEYTYPE_ECDSA_P521:

#ifdef HAVE_OPENSSL_ECC

        new->ecdsa_nid = key->ecdsa_nid;

        /* privkey -> pubkey */

        if (demote && ssh_key_is_private(key)) {

            const EC_POINT *p;

            int ok;

            new->ecdsa = EC_KEY_new_by_curve_name(key->ecdsa_nid);

            if (new->ecdsa == NULL) {

                goto fail;

            }

            p = EC_KEY_get0_public_key(key->ecdsa);

            if (p == NULL) {

                goto fail;

            }

            ok = EC_KEY_set_public_key(new->ecdsa, p);

            if (!ok) {

                goto fail;

            }

        } else {

            new->ecdsa = EC_KEY_dup(key->ecdsa);

        }

        break;

#endif

    case SSH_KEYTYPE_ED25519:

        rc = pki_ed25519_key_dup(new, key);

        if (rc != SSH_OK) {

            goto fail;

        }

        break;

    case SSH_KEYTYPE_UNKNOWN:

    default:

        ssh_key_free(new);

        return NULL;

    }

    return new;

fail:

    ssh_key_free(new);

    return NULL;

}

int pki_key_generate_rsa(ssh_key key, int parameter){

	BIGNUM *e;

	int rc;

	e = BN_new();

	key->rsa = RSA_new();

	BN_set_word(e, 65537);

	rc = RSA_generate_key_ex(key->rsa, parameter, e, NULL);

	BN_free(e);

	if (rc <= 0 || key->rsa == NULL)

		return SSH_ERROR;

	return SSH_OK;

}

int pki_key_generate_dss(ssh_key key, int parameter){

    int rc;

#if OPENSSL_VERSION_NUMBER > 0x00908000L

    key->dsa = DSA_new();

    if (key->dsa == NULL) {

        return SSH_ERROR;

    }

    rc = DSA_generate_parameters_ex(key->dsa,

                                    parameter,

                                    NULL,  /* seed */

                                    0,     /* seed_len */

                                    NULL,  /* counter_ret */

                                    NULL,  /* h_ret */

                                    NULL); /* cb */

    if (rc != 1) {

        DSA_free(key->dsa);

        key->dsa = NULL;

        return SSH_ERROR;

    }

#else

    key->dsa = DSA_generate_parameters(parameter, NULL, 0, NULL, NULL,

            NULL, NULL);

    if(key->dsa == NULL){

        return SSH_ERROR;

    }

#endif

    rc = DSA_generate_key(key->dsa);

    if (rc != 1){

        DSA_free(key->dsa);

        key->dsa=NULL;

        return SSH_ERROR;

    }

    return SSH_OK;

}

#ifdef HAVE_OPENSSL_ECC

int pki_key_generate_ecdsa(ssh_key key, int parameter) {

    int ok;

    switch (parameter) {

        case 384:

            key->ecdsa_nid = NID_secp384r1;

            key->type = SSH_KEYTYPE_ECDSA_P384;

            break;

        case 521:

            key->ecdsa_nid = NID_secp521r1;

            key->type = SSH_KEYTYPE_ECDSA_P521;

            break;

        case 256:

            key->ecdsa_nid = NID_X9_62_prime256v1;

            key->type = SSH_KEYTYPE_ECDSA_P256;

            break;

        default:

            SSH_LOG(SSH_LOG_WARN, "Invalid parameter %d for ECDSA key "

                    "generation", parameter);

            return SSH_ERROR;

    }

    key->ecdsa = EC_KEY_new_by_curve_name(key->ecdsa_nid);

    if (key->ecdsa == NULL) {

        return SSH_ERROR;

    }

    ok = EC_KEY_generate_key(key->ecdsa);

    if (!ok) {

        EC_KEY_free(key->ecdsa);

        return SSH_ERROR;

    }

    EC_KEY_set_asn1_flag(key->ecdsa, OPENSSL_EC_NAMED_CURVE);

    return SSH_OK;

}

#endif

int pki_key_compare(const ssh_key k1,

                    const ssh_key k2,

                    enum ssh_keycmp_e what)

{

    switch (k1->type) {

        case SSH_KEYTYPE_DSS: {

            const BIGNUM *p1, *p2, *q1, *q2, *g1, *g2,

                *pub_key1, *pub_key2, *priv_key1, *priv_key2;

            if (DSA_size(k1->dsa) != DSA_size(k2->dsa)) {

                return 1;

            }

            DSA_get0_pqg(k1->dsa, &p1, &q1, &g1;;

            DSA_get0_pqg(k2->dsa, &p2, &q2, &g2;;

            if (bignum_cmp(p1, p2) != 0) {

                return 1;

            }

            if (bignum_cmp(q1, q2) != 0) {

                return 1;

            }

            if (bignum_cmp(g1, g2) != 0) {

                return 1;

            }

            DSA_get0_key(k1->dsa, &pub_key1, &priv_key1);

            DSA_get0_key(k2->dsa, &pub_key2, &priv_key2);

            if (bignum_cmp(pub_key1, pub_key2) != 0) {

                return 1;

            }

            if (what == SSH_KEY_CMP_PRIVATE) {

                if (bignum_cmp(priv_key1, priv_key2) != 0) {

                    return 1;

                }

            }

            break;

        }

        case SSH_KEYTYPE_RSA:

        case SSH_KEYTYPE_RSA1: {

            const BIGNUM *e1, *e2, *n1, *n2, *p1, *p2, *q1, *q2;

            if (RSA_size(k1->rsa) != RSA_size(k2->rsa)) {

                return 1;

            }

            RSA_get0_key(k1->rsa, &n1, &e1, NULL);

            RSA_get0_key(k2->rsa, &n2, &e2, NULL);

            if (bignum_cmp(e1, e2) != 0) {

                return 1;

            }

            if (bignum_cmp(n1, n2) != 0) {

                return 1;

            }

            if (what == SSH_KEY_CMP_PRIVATE) {

                RSA_get0_factors(k1->rsa, &p1, &q1;;

                RSA_get0_factors(k2->rsa, &p2, &q2;;

                if (bignum_cmp(p1, p2) != 0) {

                    return 1;

                }

                if (bignum_cmp(q1, q2) != 0) {

                    return 1;

                }

            }

            break;

        }

        case SSH_KEYTYPE_ECDSA_P256:

        case SSH_KEYTYPE_ECDSA_P384:

        case SSH_KEYTYPE_ECDSA_P521:

#ifdef HAVE_OPENSSL_ECC

            {

                const EC_POINT *p1 = EC_KEY_get0_public_key(k1->ecdsa);

                const EC_POINT *p2 = EC_KEY_get0_public_key(k2->ecdsa);

                const EC_GROUP *g1 = EC_KEY_get0_group(k1->ecdsa);

                const EC_GROUP *g2 = EC_KEY_get0_group(k2->ecdsa);

                if (p1 == NULL || p2 == NULL) {

                    return 1;

                }

                if (EC_GROUP_cmp(g1, g2, NULL) != 0) {

                    return 1;

                }

                if (EC_POINT_cmp(g1, p1, p2, NULL) != 0) {

                    return 1;

                }

                if (what == SSH_KEY_CMP_PRIVATE) {

                    if (bignum_cmp(EC_KEY_get0_private_key(k1->ecdsa),

                                   EC_KEY_get0_private_key(k2->ecdsa))) {

                        return 1;

                    }

                }

                break;

            }

#endif

        case SSH_KEYTYPE_ED25519:

            /* ed25519 keys handled globaly */

        case SSH_KEYTYPE_UNKNOWN:

        default:

            return 1;

    }

    return 0;

}

ssh_string pki_private_key_to_pem(const ssh_key key,

                                  const char *passphrase,

                                  ssh_auth_callback auth_fn,

                                  void *auth_data)

{

    ssh_string blob = NULL;

    BUF_MEM *buf = NULL;

    BIO *mem = NULL;

    EVP_PKEY *pkey = NULL;

    int rc;

    mem = BIO_new(BIO_s_mem());

    if (mem == NULL) {

        return NULL;

    }

    switch (key->type) {

        case SSH_KEYTYPE_DSS:

            pkey = EVP_PKEY_new();

            if (pkey == NULL) {

                goto err;

            }

            rc = EVP_PKEY_set1_DSA(pkey, key->dsa);

            break;

        case SSH_KEYTYPE_RSA:

        case SSH_KEYTYPE_RSA1:

            pkey = EVP_PKEY_new();

            if (pkey == NULL) {

                goto err;

            }

            rc = EVP_PKEY_set1_RSA(pkey, key->rsa);

            break;

#ifdef HAVE_ECC

        case SSH_KEYTYPE_ECDSA_P256:

        case SSH_KEYTYPE_ECDSA_P384:

        case SSH_KEYTYPE_ECDSA_P521:

            pkey = EVP_PKEY_new();

            if (pkey == NULL) {

                goto err;

            }

            rc = EVP_PKEY_set1_EC_KEY(pkey, key->ecdsa);

            break;

#endif

        case SSH_KEYTYPE_ED25519:

#ifdef HAVE_OPENSSL_ED25519

            /* In OpenSSL, the input is the private key seed only, which means

             * the first half of the SSH private key (the second half is the

             * public key) */

            pkey = EVP_PKEY_new_raw_private_key(EVP_PKEY_ED25519, NULL,

                    (const uint8_t *)key->ed25519_privkey,

                    ED25519_KEY_LEN);

            if (pkey == NULL) {

                SSH_LOG(SSH_LOG_TRACE,

                        "Failed to create ed25519 EVP_PKEY: %s",

                        ERR_error_string(ERR_get_error(), NULL));

                goto err;

            }

            /* Mark the operation as successful as for the other key types */

            rc = 1;

            break;

#else

            SSH_LOG(SSH_LOG_WARN, "PEM output not supported for key type ssh-ed25519");

            goto err;

#endif

        case SSH_KEYTYPE_DSS_CERT01:

        case SSH_KEYTYPE_RSA_CERT01:

        case SSH_KEYTYPE_ECDSA_P256_CERT01:

        case SSH_KEYTYPE_ECDSA_P384_CERT01:

        case SSH_KEYTYPE_ECDSA_P521_CERT01:

        case SSH_KEYTYPE_ED25519_CERT01:

        case SSH_KEYTYPE_UNKNOWN:

        default:

            SSH_LOG(SSH_LOG_WARN, "Unknown or invalid private key type %d", key->type);

            goto err;

    }

    if (rc != 1) {

        SSH_LOG(SSH_LOG_WARN, "Failed to initialize EVP_PKEY structure");

        goto err;

    }

    if (passphrase == NULL) {

        struct pem_get_password_struct pgp = { auth_fn, auth_data };

        rc = PEM_write_bio_PrivateKey(mem,

                                      pkey,

                                      NULL, /* cipher */

                                      NULL, /* kstr */

                                      0, /* klen */

                                      pem_get_password,

                                      &pgp);

    } else {

        rc = PEM_write_bio_PrivateKey(mem,

                                      pkey,

                                      EVP_aes_128_cbc(),

                                      NULL, /* kstr */

                                      0, /* klen */

                                      NULL, /* auth_fn */

                                      (void*) passphrase);

    }

    EVP_PKEY_free(pkey);

    pkey = NULL;

    if (rc != 1) {

        goto err;

    }

    BIO_get_mem_ptr(mem, &buf;;

    blob = ssh_string_new(buf->length);

    if (blob == NULL) {

        goto err;

    }

    ssh_string_fill(blob, buf->data, buf->length);

    BIO_free(mem);

    return blob;

err:

    EVP_PKEY_free(pkey);

    BIO_free(mem);

    return NULL;

}

ssh_key pki_private_key_from_base64(const char *b64_key,

                                    const char *passphrase,

                                    ssh_auth_callback auth_fn,

                                    void *auth_data)

{

    BIO *mem = NULL;

    DSA *dsa = NULL;

    RSA *rsa = NULL;

#ifdef HAVE_OPENSSL_ED25519

    uint8_t *ed25519 = NULL;

#else

    ed25519_privkey *ed25519 = NULL;

#endif

    ssh_key key = NULL;

    enum ssh_keytypes_e type = SSH_KEYTYPE_UNKNOWN;

#ifdef HAVE_OPENSSL_ECC

    EC_KEY *ecdsa = NULL;

#else

    void *ecdsa = NULL;

#endif

    EVP_PKEY *pkey = NULL;

    mem = BIO_new_mem_buf((void*)b64_key, -1);

    if (passphrase == NULL) {

        if (auth_fn) {

            struct pem_get_password_struct pgp = { auth_fn, auth_data };

            pkey = PEM_read_bio_PrivateKey(mem, NULL, pem_get_password, &pgp);

        } else {

            /* openssl uses its own callback to get the passphrase here */

            pkey = PEM_read_bio_PrivateKey(mem, NULL, NULL, NULL);

        }

    } else {

        pkey = PEM_read_bio_PrivateKey(mem, NULL, NULL, (void *) passphrase);

    }