/*

 * pki.c

 * This file is part of the SSH Library

 *

 * Copyright (c) 2010 by Aris Adamantiadis

 * Copyright (c) 2011-2013 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.

 */

/**

 * @defgroup libssh_pki The SSH Public Key Infrastructure

 * @ingroup libssh

 *

 * Functions for the creation, importation and manipulation of public and

 * private keys in the context of the SSH protocol

 *

 * @{

 */

#include "config.h"

#include <errno.h>

#include <ctype.h>

#include <stdio.h>

#include <fcntl.h>

#include <sys/stat.h>

#include <sys/types.h>

#ifdef _WIN32

# ifdef HAVE_IO_H

#  include <io.h>

#  undef open

#  define open _open

#  undef close

#  define close _close

#  undef read

#  define read _read

#  undef unlink

#  define unlink _unlink

# endif /* HAVE_IO_H */

#endif

#include "libssh/libssh.h"

#include "libssh/session.h"

#include "libssh/priv.h"

#include "libssh/pki.h"

#include "libssh/pki_priv.h"

#include "libssh/keys.h"

#include "libssh/buffer.h"

#include "libssh/misc.h"

#include "libssh/agent.h"

enum ssh_keytypes_e pki_privatekey_type_from_string(const char *privkey)

{

    char *start = NULL;

    start = strstr(privkey, DSA_HEADER_BEGIN);

    if (start != NULL) {

        return SSH_KEYTYPE_DSS;

    }

    start = strstr(privkey, RSA_HEADER_BEGIN);

    if (start != NULL) {

        return SSH_KEYTYPE_RSA;

    }

    start = strstr(privkey, ECDSA_HEADER_BEGIN);

    if (start != 0) {

        /* We don't know what the curve is at this point, so we don't actually

         * know the type. We figure out the actual curve and fix things up in

         * pki_private_key_from_base64 */

        return SSH_KEYTYPE_ECDSA_P256;

    }

    return SSH_KEYTYPE_UNKNOWN;

}

/**

 * @brief returns the ECDSA key name ("ecdsa-sha2-nistp256" for example)

 *

 * @param[in] key the ssh_key whose ECDSA name to get

 *

 * @returns the ECDSA key name ("ecdsa-sha2-nistp256" for example)

 *

 * @returns "unknown" if the ECDSA key name is not known

 */

const char *ssh_pki_key_ecdsa_name(const ssh_key key)

{

    if (key == NULL) {

        return NULL;

    }

#ifdef HAVE_ECC /* FIXME Better ECC check needed */

    return pki_key_ecdsa_nid_to_name(key->ecdsa_nid);

#else

    return NULL;

#endif

}

/**

 * @brief creates a new empty SSH key

 * @returns an empty ssh_key handle, or NULL on error.

 */

ssh_key ssh_key_new (void) {

  ssh_key ptr = malloc (sizeof (struct ssh_key_struct));

  if (ptr == NULL) {

      return NULL;

  }

  ZERO_STRUCTP(ptr);

  return ptr;

}

ssh_key ssh_key_dup(const ssh_key key)

{

    if (key == NULL) {

        return NULL;

    }

    return pki_key_dup(key, 0);

}

/**

 * @brief clean up the key and deallocate all existing keys

 * @param[in] key ssh_key to clean

 */

void ssh_key_clean (ssh_key key){

    if(key == NULL)

        return;

#ifdef HAVE_LIBGCRYPT

    if(key->dsa) gcry_sexp_release(key->dsa);

    if(key->rsa) gcry_sexp_release(key->rsa);

    if(key->ecdsa) gcry_sexp_release(key->ecdsa);

#elif defined HAVE_LIBCRYPTO

    if(key->dsa) DSA_free(key->dsa);

    if(key->rsa) RSA_free(key->rsa);

#ifdef HAVE_OPENSSL_ECC

    if(key->ecdsa) EC_KEY_free(key->ecdsa);

#endif /* HAVE_OPENSSL_ECC */

#elif defined HAVE_LIBMBEDCRYPTO

    if (key->rsa != NULL) {

        mbedtls_pk_free(key->rsa);

        SAFE_FREE(key->rsa);

    }

    if (key->ecdsa != NULL) {

        mbedtls_ecdsa_free(key->ecdsa);

        SAFE_FREE(key->ecdsa);

    }

#endif

    if (key->ed25519_privkey != NULL){

#ifdef HAVE_OPENSSL_ED25519

        /* In OpenSSL implementation the private key is only the private

         * original seed. In the internal implementation the private key is the

         * concatenation of the original private seed with the public key.*/

        explicit_bzero(key->ed25519_privkey, ED25519_KEY_LEN);

#else

        explicit_bzero(key->ed25519_privkey, sizeof(ed25519_privkey));

#endif

        SAFE_FREE(key->ed25519_privkey);

    }

    SAFE_FREE(key->ed25519_pubkey);

    if (key->cert != NULL) {

        SSH_BUFFER_FREE(key->cert);

    }

    key->cert_type = SSH_KEYTYPE_UNKNOWN;

    key->flags=SSH_KEY_FLAG_EMPTY;

    key->type=SSH_KEYTYPE_UNKNOWN;

    key->ecdsa_nid = 0;

    key->type_c=NULL;

    key->dsa = NULL;

    key->rsa = NULL;

    key->ecdsa = NULL;

}

/**

 * @brief deallocate a SSH key

 * @param[in] key ssh_key handle to free

 */

void ssh_key_free (ssh_key key){

    if(key){

        ssh_key_clean(key);

        SAFE_FREE(key);

    }

}

/**

 * @brief returns the type of a ssh key

 * @param[in] key the ssh_key handle

 * @returns one of SSH_KEYTYPE_RSA, SSH_KEYTYPE_DSS,

 *          SSH_KEYTYPE_ECDSA_P256, SSH_KEYTYPE_ECDSA_P384,

 *          SSH_KEYTYPE_ECDSA_P521, SSH_KEYTYPE_ED25519, SSH_KEYTYPE_DSS_CERT01,

 *          SSH_KEYTYPE_RSA_CERT01, SSH_KEYTYPE_ECDSA_P256_CERT01,

 *          SSH_KEYTYPE_ECDSA_P384_CERT01, SSH_KEYTYPE_ECDSA_P521_CERT01, or

 *          SSH_KEYTYPE_ED25519_CERT01.

 * @returns SSH_KEYTYPE_UNKNOWN if the type is unknown

 */

enum ssh_keytypes_e ssh_key_type(const ssh_key key){

    if (key == NULL) {

        return SSH_KEYTYPE_UNKNOWN;

    }

    return key->type;

}

/**

 * @brief Convert a signature type to a string.

 *

 * @param[in]  type     The algorithm type to convert.

 *

 * @return              A string for the keytype or NULL if unknown.

 */

const char *

ssh_key_signature_to_char(enum ssh_keytypes_e type,

                          enum ssh_digest_e hash_type)

{

    switch (type) {

    case SSH_KEYTYPE_RSA:

        switch (hash_type) {

        case SSH_DIGEST_SHA256:

            return "rsa-sha2-256";

        case SSH_DIGEST_SHA512:

            return "rsa-sha2-512";

        case SSH_DIGEST_SHA1:

        case SSH_DIGEST_AUTO:

            return "ssh-rsa";

        default:

            return NULL;

        }

        break;

    case SSH_KEYTYPE_RSA_CERT01:

        switch (hash_type) {

        case SSH_DIGEST_SHA256:

            return "rsa-sha2-256-cert-v01@openssh.com";

        case SSH_DIGEST_SHA512:

            return "rsa-sha2-512-cert-v01@openssh.com";

        case SSH_DIGEST_SHA1:

        case SSH_DIGEST_AUTO:

            return "ssh-rsa-cert-v01@openssh.com";

        default:

            return NULL;

        }

        break;

    default:

        return ssh_key_type_to_char(type);

    }

    /* We should never reach this */

    return NULL;

}

/**

 * @brief Convert a key type to a string.

 *

 * @param[in]  type     The type to convert.

 *

 * @return              A string for the keytype or NULL if unknown.

 */

const char *ssh_key_type_to_char(enum ssh_keytypes_e type) {

  switch (type) {

    case SSH_KEYTYPE_DSS:

      return "ssh-dss";

    case SSH_KEYTYPE_RSA:

      return "ssh-rsa";

    case SSH_KEYTYPE_ECDSA:

      return "ssh-ecdsa"; /* deprecated. invalid value */

    case SSH_KEYTYPE_ECDSA_P256:

      return "ecdsa-sha2-nistp256";

    case SSH_KEYTYPE_ECDSA_P384:

      return "ecdsa-sha2-nistp384";

    case SSH_KEYTYPE_ECDSA_P521:

      return "ecdsa-sha2-nistp521";

    case SSH_KEYTYPE_ED25519:

      return "ssh-ed25519";

    case SSH_KEYTYPE_DSS_CERT01:

      return "ssh-dss-cert-v01@openssh.com";

    case SSH_KEYTYPE_RSA_CERT01:

      return "ssh-rsa-cert-v01@openssh.com";

    case SSH_KEYTYPE_ECDSA_P256_CERT01:

      return "ecdsa-sha2-nistp256-cert-v01@openssh.com";

    case SSH_KEYTYPE_ECDSA_P384_CERT01:

      return "ecdsa-sha2-nistp384-cert-v01@openssh.com";

    case SSH_KEYTYPE_ECDSA_P521_CERT01:

      return "ecdsa-sha2-nistp521-cert-v01@openssh.com";

    case SSH_KEYTYPE_ED25519_CERT01:

      return "ssh-ed25519-cert-v01@openssh.com";

    case SSH_KEYTYPE_RSA1:

    case SSH_KEYTYPE_UNKNOWN:

      return NULL;

  }

  /* We should never reach this */

  return NULL;

}

enum ssh_digest_e ssh_key_hash_from_name(const char *name)

{

    if (name == NULL) {

        /* TODO we should rather fail */

        return SSH_DIGEST_AUTO;

    }

    if (strcmp(name, "ssh-rsa") == 0) {

        return SSH_DIGEST_SHA1;

    } else if (strcmp(name, "ssh-dss") == 0) {

        return SSH_DIGEST_SHA1;

    } else if (strcmp(name, "rsa-sha2-256") == 0) {

        return SSH_DIGEST_SHA256;

    } else if (strcmp(name, "rsa-sha2-512") == 0) {

        return SSH_DIGEST_SHA512;

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

        return SSH_DIGEST_SHA256;

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

        return SSH_DIGEST_SHA384;

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

        return SSH_DIGEST_SHA512;

    } else if (strcmp(name, "ssh-ed25519") == 0) {

        return SSH_DIGEST_AUTO;

    }

    SSH_LOG(SSH_LOG_WARN, "Unknown signature name %s", name);

    /* TODO we should rather fail */

    return SSH_DIGEST_AUTO;

}

/**

 * @brief Checks the given key against the configured allowed

 * public key algorithm types

 *

 * @param[in] session The SSH session

 * @param[in] type    The key algorithm to check

 * @returns           1 if the key algorithm is allowed, 0 otherwise

 */

int ssh_key_algorithm_allowed(ssh_session session, const char *type)

{

    const char *allowed_list;

    if (session->client) {

        allowed_list = session->opts.pubkey_accepted_types;

        if (allowed_list == NULL) {

            if (ssh_fips_mode()) {

                allowed_list = ssh_kex_get_fips_methods(SSH_HOSTKEYS);

            } else {

                allowed_list = ssh_kex_get_default_methods(SSH_HOSTKEYS);

            }

        }

    }

#ifdef WITH_SERVER

    else if (session->server) {

        allowed_list = session->opts.wanted_methods[SSH_HOSTKEYS];

        if (allowed_list == NULL) {

            SSH_LOG(SSH_LOG_WARN, "Session invalid: no host key available");

            return 0;

        }

    }

#endif

    else {

        SSH_LOG(SSH_LOG_WARN, "Session invalid: not set as client nor server");

        return 0;

    }

    SSH_LOG(SSH_LOG_DEBUG, "Checking %s with list <%s>", type, allowed_list);

    return ssh_match_group(allowed_list, type);

}

/**

 * @brief Convert a key type to a hash type. This is usually unambiguous

 * for all the key types, unless the SHA2 extension (RFC 8332) is

 * negotiated during key exchange.

 *

 * @param[in]  session  SSH Session.

 *

 * @param[in]  type     The type to convert.

 *

 * @return              A hash type to be used.

 */

enum ssh_digest_e ssh_key_type_to_hash(ssh_session session,

                                       enum ssh_keytypes_e type)

{

    switch (type) {

    case SSH_KEYTYPE_DSS_CERT01:

    case SSH_KEYTYPE_DSS:

        return SSH_DIGEST_SHA1;

    case SSH_KEYTYPE_RSA_CERT01:

        /* If we are talking to an old OpenSSH version which does not support

         * SHA2 in certificates */

        if ((session->openssh > 0) &&

            (session->openssh < SSH_VERSION_INT(7, 2, 0)))

        {

            SSH_LOG(SSH_LOG_DEBUG,

                    "We are talking to an old OpenSSH (%x); "

                    "returning SSH_DIGEST_SHA1",

                    session->openssh);

            return SSH_DIGEST_SHA1;

        }

        FALL_THROUGH;

    case SSH_KEYTYPE_RSA:

        if (ssh_key_algorithm_allowed(session, "rsa-sha2-512") &&

            (session->extensions & SSH_EXT_SIG_RSA_SHA512)) {

            return SSH_DIGEST_SHA512;

        }

        if (ssh_key_algorithm_allowed(session, "rsa-sha2-256") &&

            (session->extensions & SSH_EXT_SIG_RSA_SHA256)) {

            return SSH_DIGEST_SHA256;

        }

        /* Default algorithm for RSA is SHA1 */

        return SSH_DIGEST_SHA1;

    case SSH_KEYTYPE_ECDSA_P256_CERT01:

    case SSH_KEYTYPE_ECDSA_P256:

        return SSH_DIGEST_SHA256;

    case SSH_KEYTYPE_ECDSA_P384_CERT01:

    case SSH_KEYTYPE_ECDSA_P384:

        return SSH_DIGEST_SHA384;

    case SSH_KEYTYPE_ECDSA_P521_CERT01:

    case SSH_KEYTYPE_ECDSA_P521:

        return SSH_DIGEST_SHA512;

    case SSH_KEYTYPE_ED25519_CERT01:

    case SSH_KEYTYPE_ED25519:

        return SSH_DIGEST_AUTO;

    case SSH_KEYTYPE_RSA1:

    case SSH_KEYTYPE_ECDSA:

    case SSH_KEYTYPE_UNKNOWN:

    default:

        SSH_LOG(SSH_LOG_WARN, "Digest algorithm to be used with key type %u "

                "is not defined", type);

    }

    /* We should never reach this */

    return SSH_DIGEST_AUTO;

}

/**

 * @brief Gets signature algorithm name to be used with the given

 *        key type.

 *

 * @param[in]  session  SSH session.

 * @param[in]  type     The algorithm type to convert.

 *

 * @return              A string for the keytype or NULL if unknown.

 */

const char *

ssh_key_get_signature_algorithm(ssh_session session,

                                enum ssh_keytypes_e type)

{

    enum ssh_digest_e hash_type;

    if (type == SSH_KEYTYPE_RSA_CERT01) {

        /* If we are talking to an old OpenSSH version which does not support

         * rsa-sha2-{256,512}-cert-v01@openssh.com */

        if ((session->openssh > 0) &&

            (session->openssh < SSH_VERSION_INT(7, 8, 0)))

        {

            SSH_LOG(SSH_LOG_DEBUG,

                    "We are talking to an old OpenSSH (%x); "

                    "using old cert format",

                    session->openssh);

            return "ssh-rsa-cert-v01@openssh.com";

        }

    }

    hash_type = ssh_key_type_to_hash(session, type);

    return ssh_key_signature_to_char(type, hash_type);

}

/**

 * @brief Convert a ssh key algorithm name to a ssh key algorithm type.

 *

 * @param[in] name      The name to convert.

 *

 * @return              The enum ssh key algorithm type.

 */

enum ssh_keytypes_e ssh_key_type_from_signature_name(const char *name) {

    if (name == NULL) {

        return SSH_KEYTYPE_UNKNOWN;

    }

    if ((strcmp(name, "rsa-sha2-256") == 0) ||

        (strcmp(name, "rsa-sha2-512") == 0)) {

        return SSH_KEYTYPE_RSA;

    }

    /* Otherwise the key type matches the signature type */

    return ssh_key_type_from_name(name);

}

/**

 * @brief Convert a ssh key name to a ssh key type.

 *

 * @param[in] name      The name to convert.

 *

 * @return              The enum ssh key type.

 */

enum ssh_keytypes_e ssh_key_type_from_name(const char *name) {

    if (name == NULL) {

        return SSH_KEYTYPE_UNKNOWN;

    }

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

        return SSH_KEYTYPE_RSA;

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

        return SSH_KEYTYPE_DSS;

    } else if (strcmp(name, "ssh-rsa") == 0) {

        return SSH_KEYTYPE_RSA;

    } else if (strcmp(name, "ssh-dss") == 0) {

        return SSH_KEYTYPE_DSS;

    } else if (strcmp(name, "ssh-ecdsa") == 0

            || strcmp(name, "ecdsa") == 0

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

        return SSH_KEYTYPE_ECDSA_P256;

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

        return SSH_KEYTYPE_ECDSA_P384;

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

        return SSH_KEYTYPE_ECDSA_P521;

    } else if (strcmp(name, "ssh-ed25519") == 0){

        return SSH_KEYTYPE_ED25519;

    } else if (strcmp(name, "ssh-dss-cert-v01@openssh.com") == 0) {

        return SSH_KEYTYPE_DSS_CERT01;

    } else if (strcmp(name, "ssh-rsa-cert-v01@openssh.com") == 0) {

        return SSH_KEYTYPE_RSA_CERT01;

    } else if (strcmp(name, "ecdsa-sha2-nistp256-cert-v01@openssh.com") == 0) {

        return SSH_KEYTYPE_ECDSA_P256_CERT01;

    } else if (strcmp(name, "ecdsa-sha2-nistp384-cert-v01@openssh.com") == 0) {

        return SSH_KEYTYPE_ECDSA_P384_CERT01;

    } else if (strcmp(name, "ecdsa-sha2-nistp521-cert-v01@openssh.com") == 0) {

        return SSH_KEYTYPE_ECDSA_P521_CERT01;

    } else if (strcmp(name, "ssh-ed25519-cert-v01@openssh.com") == 0) {

        return SSH_KEYTYPE_ED25519_CERT01;

    }

    return SSH_KEYTYPE_UNKNOWN;

}

/**

 * @brief Get the pubic key type corresponding to a certificate type.

 *

 * @param[in] type   The certificate or public key type.

 *

 * @return           The matching public key type.

 */

enum ssh_keytypes_e ssh_key_type_plain(enum ssh_keytypes_e type) {

    switch (type) {

        case SSH_KEYTYPE_DSS_CERT01:

            return SSH_KEYTYPE_DSS;

        case SSH_KEYTYPE_RSA_CERT01:

            return SSH_KEYTYPE_RSA;

        case SSH_KEYTYPE_ECDSA_P256_CERT01:

            return SSH_KEYTYPE_ECDSA_P256;

        case SSH_KEYTYPE_ECDSA_P384_CERT01:

            return SSH_KEYTYPE_ECDSA_P384;

        case SSH_KEYTYPE_ECDSA_P521_CERT01:

            return SSH_KEYTYPE_ECDSA_P521;

        case SSH_KEYTYPE_ED25519_CERT01:

            return SSH_KEYTYPE_ED25519;

        default:

            return type;

    }

}

/**

 * @brief Check if the key has/is a public key.

 *

 * @param[in] k         The key to check.

 *

 * @return              1 if it is a public key, 0 if not.

 */

int ssh_key_is_public(const ssh_key k) {

    if (k == NULL) {

        return 0;

    }

    return (k->flags & SSH_KEY_FLAG_PUBLIC) == SSH_KEY_FLAG_PUBLIC;

}

/**

 * @brief Check if the key is a private key.

 *

 * @param[in] k         The key to check.

 *

 * @return              1 if it is a private key, 0 if not.

 */

int ssh_key_is_private(const ssh_key k) {

    if (k == NULL) {

        return 0;

    }

    return (k->flags & SSH_KEY_FLAG_PRIVATE) == SSH_KEY_FLAG_PRIVATE;

}

/**

 * @brief Compare keys if they are equal.

 *

 * @param[in] k1        The first key to compare.

 *

 * @param[in] k2        The second key to compare.

 *

 * @param[in] what      What part or type of the key do you want to compare.

 *

 * @return              0 if equal, 1 if not.

 */

int ssh_key_cmp(const ssh_key k1,

                const ssh_key k2,

                enum ssh_keycmp_e what)

{

    if (k1 == NULL || k2 == NULL) {

        return 1;

    }

    if (k1->type != k2->type) {

        SSH_LOG(SSH_LOG_WARN, "key types don't match!");

        return 1;

    }

    if (what == SSH_KEY_CMP_PRIVATE) {

        if (!ssh_key_is_private(k1) ||

            !ssh_key_is_private(k2)) {

            return 1;

        }

    }

    if (k1->type == SSH_KEYTYPE_ED25519) {

        return pki_ed25519_key_cmp(k1, k2, what);

    }

    return pki_key_compare(k1, k2, what);

}

ssh_signature ssh_signature_new(void)

{

    struct ssh_signature_struct *sig;

    sig = malloc(sizeof(struct ssh_signature_struct));

    if (sig == NULL) {

        return NULL;

    }

    ZERO_STRUCTP(sig);

    return sig;

}

void ssh_signature_free(ssh_signature sig)

{

    if (sig == NULL) {

        return;

    }

    switch(sig->type) {

        case SSH_KEYTYPE_DSS:

#ifdef HAVE_LIBGCRYPT

            gcry_sexp_release(sig->dsa_sig);

#endif

            break;

        case SSH_KEYTYPE_RSA:

#ifdef HAVE_LIBGCRYPT

            gcry_sexp_release(sig->rsa_sig);

#elif defined HAVE_LIBMBEDCRYPTO

            SAFE_FREE(sig->rsa_sig);

#endif

            break;

        case SSH_KEYTYPE_ECDSA_P256:

        case SSH_KEYTYPE_ECDSA_P384:

        case SSH_KEYTYPE_ECDSA_P521:

#ifdef HAVE_GCRYPT_ECC

            gcry_sexp_release(sig->ecdsa_sig);

#elif defined HAVE_LIBMBEDCRYPTO

            bignum_safe_free(sig->ecdsa_sig.r);

            bignum_safe_free(sig->ecdsa_sig.s);

#endif

            break;

        case SSH_KEYTYPE_ED25519:

#ifndef HAVE_OPENSSL_ED25519

            /* When using OpenSSL, the signature is stored in sig->raw_sig */

            SAFE_FREE(sig->ed25519_sig);

#endif

            break;

        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_RSA1:

        case SSH_KEYTYPE_ECDSA:

        case SSH_KEYTYPE_UNKNOWN:

            break;

    }

    /* Explicitly zero the signature content before free */

    ssh_string_burn(sig->raw_sig);

    SSH_STRING_FREE(sig->raw_sig);

    SAFE_FREE(sig);

}

/**

 * @brief import a base64 formated key from a memory c-string

 *

 * @param[in]  b64_key  The c-string holding the base64 encoded key

 *

 * @param[in]  passphrase The passphrase to decrypt the key, or NULL

 *

 * @param[in]  auth_fn  An auth function you may want to use or NULL.

 *

 * @param[in]  auth_data Private data passed to the auth function.

 *

 * @param[out] pkey     A pointer where the allocated key can be stored. You

 *                      need to free the memory.

 *

 * @return  SSH_ERROR in case of error, SSH_OK otherwise.

 *

 * @see ssh_key_free()

 */

int ssh_pki_import_privkey_base64(const char *b64_key,

                                  const char *passphrase,

                                  ssh_auth_callback auth_fn,

                                  void *auth_data,

                                  ssh_key *pkey)

{

    ssh_key key;

    char *openssh_header = NULL;

    if (b64_key == NULL || pkey == NULL) {

        return SSH_ERROR;

    }

    if (b64_key == NULL || !*b64_key) {

        return SSH_ERROR;

    }

    SSH_LOG(SSH_LOG_INFO,

            "Trying to decode privkey passphrase=%s",

            passphrase ? "true" : "false");

    /* Test for OpenSSH key format first */

    openssh_header = strstr(b64_key, OPENSSH_HEADER_BEGIN);

    if (openssh_header != NULL) {

        key = ssh_pki_openssh_privkey_import(openssh_header,

                                             passphrase,

                                             auth_fn,

                                             auth_data);

    } else {

        /* fallback on PEM decoder */

        key = pki_private_key_from_base64(b64_key,

                                          passphrase,

                                          auth_fn,

                                          auth_data);

    }

    if (key == NULL) {

        return SSH_ERROR;

    }

    *pkey = key;

    return SSH_OK;

}

 /**

 * @brief Convert a private key to a pem base64 encoded key, or OpenSSH format for

 *        keytype ssh-ed25519

 *

 * @param[in]  privkey  The private key to export.

 *

 * @param[in]  passphrase The passphrase to use to encrypt the key with or

 *             NULL. An empty string means no passphrase.

 *

 * @param[in]  auth_fn  An auth function you may want to use or NULL.

 *

 * @param[in]  auth_data Private data passed to the auth function.

 *

 * @param[out] b64_key  A pointer to store the allocated base64 encoded key. You

 *                      need to free the buffer.

 *

 * @return     SSH_OK on success, SSH_ERROR on error.

 */

int ssh_pki_export_privkey_base64(const ssh_key privkey,

                                  const char *passphrase,

                                  ssh_auth_callback auth_fn,

                                  void *auth_data,

                                  char **b64_key)

{

    ssh_string blob = NULL;

    char *b64 = NULL;

    if (privkey == NULL || !ssh_key_is_private(privkey)) {

        return SSH_ERROR;

    }

    if (privkey->type == SSH_KEYTYPE_ED25519){

        blob = ssh_pki_openssh_privkey_export(privkey,

                                              passphrase,

                                              auth_fn,

                                              auth_data);

    } else {

        blob = pki_private_key_to_pem(privkey,

                                      passphrase,

                                      auth_fn,

                                      auth_data);

    }

    if (blob == NULL) {

        return SSH_ERROR;

    }

    b64 = strndup(ssh_string_data(blob), ssh_string_len(blob));

    SSH_STRING_FREE(blob);

    if (b64 == NULL) {

        return SSH_ERROR;

    }

    *b64_key = b64;

    return SSH_OK;

}

/**

 * @brief Import a key from a file.

 *

 * @param[in]  filename The filename of the the private key.

 *

 * @param[in]  passphrase The passphrase to decrypt the private key. Set to NULL

 *                        if none is needed or it is unknown.

 *

 * @param[in]  auth_fn  An auth function you may want to use or NULL.

 *

 * @param[in]  auth_data Private data passed to the auth function.

 *

 * @param[out] pkey     A pointer to store the allocated ssh_key. You need to

 *                      free the key.

 *

 * @returns SSH_OK on success, SSH_EOF if the file doesn't exist or permission

 *          denied, SSH_ERROR otherwise.

 *

 * @see ssh_key_free()

 **/

int ssh_pki_import_privkey_file(const char *filename,

                                const char *passphrase,

                                ssh_auth_callback auth_fn,

                                void *auth_data,

                                ssh_key *pkey) {

    struct stat sb;

    char *key_buf;

    FILE *file;

    off_t size;

    int rc;

    if (pkey == NULL || filename == NULL || *filename == '\0') {

        return SSH_ERROR;

    }

    file = fopen(filename, "rb");

    if (file == NULL) {

        SSH_LOG(SSH_LOG_WARN,

                "Error opening %s: %s",

                filename,

                strerror(errno));

        return SSH_EOF;

    }

    rc = fstat(fileno(file), &sb);

    if (rc < 0) {

        fclose(file);

        SSH_LOG(SSH_LOG_WARN,

                "Error getting stat of %s: %s",

                filename,

                strerror(errno));