/*

* 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));

switch (errno) {

case ENOENT:

case EACCES:

return SSH_EOF;

}

return SSH_ERROR;

}

if (sb.st_size > MAX_PRIVKEY_SIZE) {

SSH_LOG(SSH_LOG_WARN,

"Private key is bigger than 4M.");

fclose(file);

return SSH_ERROR;

}

key_buf = malloc(sb.st_size + 1);

if (key_buf == NULL) {

fclose(file);

SSH_LOG(SSH_LOG_WARN, "Out of memory!");

return SSH_ERROR;

}

size = fread(key_buf, 1, sb.st_size, file);

fclose(file);

if (size != sb.st_size) {

SAFE_FREE(key_buf);

SSH_LOG(SSH_LOG_WARN,

"Error reading %s: %s",

filename,

strerror(errno));

return SSH_ERROR;

}

key_buf[size] = 0;

rc = ssh_pki_import_privkey_base64(key_buf,

passphrase,

auth_fn,

auth_data,

pkey);

SAFE_FREE(key_buf);

return rc;

}

/**

* @brief Export a private key to a pem file on disk, 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[in] filename The path where to store the pem file.

*

* @return SSH_OK on success, SSH_ERROR on error.

*/

int ssh_pki_export_privkey_file(const ssh_key privkey,

const char *passphrase,

ssh_auth_callback auth_fn,

void *auth_data,

const char *filename)

{

ssh_string blob;

FILE *fp;

int rc;

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

return SSH_ERROR;

}

fp = fopen(filename, "wb");

if (fp == NULL) {

SSH_LOG(SSH_LOG_FUNCTIONS, "Error opening %s: %s",

filename, strerror(errno));

return SSH_EOF;

}

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) {

fclose(fp);

return -1;

}

rc = fwrite(ssh_string_data(blob), ssh_string_len(blob), 1, fp);

SSH_STRING_FREE(blob);

if (rc != 1 || ferror(fp)) {

fclose(fp);

unlink(filename);

return SSH_ERROR;

}

fclose(fp);

return SSH_OK;

}

/* temporary function to migrate seemlessly to ssh_key */

ssh_public_key ssh_pki_convert_key_to_publickey(const ssh_key key) {

ssh_public_key pub;

ssh_key tmp;

if(key == NULL) {

return NULL;

}