/*

 * auth.c - Authentication with SSH protocols

 *

 * This file is part of the SSH Library

 *

 * Copyright (c) 2003-2013 by Aris Adamantiadis <aris@0xbadc0de.be>

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

 */

#include "config.h"

#include <stdio.h>

#ifndef _WIN32

#include <netinet/in.h>

#include <arpa/inet.h>

#endif

#include "libssh/priv.h"

#include "libssh/crypto.h"

#include "libssh/ssh2.h"

#include "libssh/buffer.h"

#include "libssh/agent.h"

#include "libssh/misc.h"

#include "libssh/packet.h"

#include "libssh/session.h"

#include "libssh/keys.h"

#include "libssh/auth.h"

#include "libssh/pki.h"

#include "libssh/gssapi.h"

#include "libssh/legacy.h"

/**

 * @defgroup libssh_auth The SSH authentication functions.

 * @ingroup libssh

 *

 * Functions to authenticate with a server.

 *

 * @{

 */

/**

 * @internal

 *

 * @brief Ask access to the ssh-userauth service.

 *

 * @param[in] session   The SSH session handle.

 *

 * @returns SSH_OK on success, SSH_ERROR on error.

 * @returns SSH_AGAIN on nonblocking mode, if calling that function

 * again is necessary

 */

static int ssh_userauth_request_service(ssh_session session) {

    int rc;

    rc = ssh_service_request(session, "ssh-userauth");

    if ((rc != SSH_OK) && (rc != SSH_AGAIN)) {

        SSH_LOG(SSH_LOG_WARN,

                "Failed to request \"ssh-userauth\" service");

    }

    return rc;

}

static int ssh_auth_response_termination(void *user) {

    ssh_session session = (ssh_session)user;

    switch (session->auth.state) {

        case SSH_AUTH_STATE_NONE:

        case SSH_AUTH_STATE_KBDINT_SENT:

        case SSH_AUTH_STATE_GSSAPI_REQUEST_SENT:

        case SSH_AUTH_STATE_GSSAPI_TOKEN:

        case SSH_AUTH_STATE_GSSAPI_MIC_SENT:

        case SSH_AUTH_STATE_PUBKEY_AUTH_SENT:

        case SSH_AUTH_STATE_PUBKEY_OFFER_SENT:

        case SSH_AUTH_STATE_PASSWORD_AUTH_SENT:

        case SSH_AUTH_STATE_AUTH_NONE_SENT:

            return 0;

        default:

            return 1;

    }

}

static const char *ssh_auth_get_current_method(ssh_session session)

{

    const char *method = "unknown";

    switch (session->auth.current_method) {

    case SSH_AUTH_METHOD_NONE:

        method = "none";

        break;

    case SSH_AUTH_METHOD_PASSWORD:

        method = "password";

        break;

    case SSH_AUTH_METHOD_PUBLICKEY:

        method = "publickey";

        break;

    case SSH_AUTH_METHOD_HOSTBASED:

        method = "hostbased";

        break;

    case SSH_AUTH_METHOD_INTERACTIVE:

        method = "keyboard interactive";

        break;

    case SSH_AUTH_METHOD_GSSAPI_MIC:

        method = "gssapi";

        break;

    default:

        break;

    }

    return method;

}

/**

 * @internal

 * @brief Wait for a response of an authentication function.

 *

 * @param[in] session   The SSH session.

 *

 * @returns SSH_AUTH_SUCCESS Authentication success, or pubkey accepted

 *          SSH_AUTH_PARTIAL Authentication succeeded but another mean

 *                           of authentication is needed.

 *          SSH_AUTH_INFO    Data for keyboard-interactive

 *          SSH_AUTH_AGAIN   In nonblocking mode, call has to be made again

 *          SSH_AUTH_ERROR   Error during the process.

 */

static int ssh_userauth_get_response(ssh_session session) {

    int rc = SSH_AUTH_ERROR;

    rc = ssh_handle_packets_termination(session, SSH_TIMEOUT_USER,

        ssh_auth_response_termination, session);

    if (rc == SSH_ERROR) {

        return SSH_AUTH_ERROR;

    }

    if (!ssh_auth_response_termination(session)) {

        return SSH_AUTH_AGAIN;

    }

    switch(session->auth.state) {

        case SSH_AUTH_STATE_ERROR:

            rc = SSH_AUTH_ERROR;

            break;

        case SSH_AUTH_STATE_FAILED:

            rc = SSH_AUTH_DENIED;

            break;

        case SSH_AUTH_STATE_INFO:

            rc = SSH_AUTH_INFO;

            break;

        case SSH_AUTH_STATE_PARTIAL:

            rc = SSH_AUTH_PARTIAL;

            break;

        case SSH_AUTH_STATE_PK_OK:

        case SSH_AUTH_STATE_SUCCESS:

            rc = SSH_AUTH_SUCCESS;

            break;

        case SSH_AUTH_STATE_KBDINT_SENT:

        case SSH_AUTH_STATE_GSSAPI_REQUEST_SENT:

        case SSH_AUTH_STATE_GSSAPI_TOKEN:

        case SSH_AUTH_STATE_GSSAPI_MIC_SENT:

        case SSH_AUTH_STATE_PUBKEY_OFFER_SENT:

        case SSH_AUTH_STATE_PUBKEY_AUTH_SENT:

        case SSH_AUTH_STATE_PASSWORD_AUTH_SENT:

        case SSH_AUTH_STATE_AUTH_NONE_SENT:

        case SSH_AUTH_STATE_NONE:

            /* not reached */

            rc = SSH_AUTH_ERROR;

            break;

    }

    return rc;

}

/**

 * @internal

 *

 * @brief Handles a SSH_USERAUTH_BANNER packet.

 *

 * This banner should be shown to user prior to authentication

 */

SSH_PACKET_CALLBACK(ssh_packet_userauth_banner) {

    ssh_string banner;

    (void)type;

    (void)user;

    banner = ssh_buffer_get_ssh_string(packet);

    if (banner == NULL) {

        SSH_LOG(SSH_LOG_WARN,

                "Invalid SSH_USERAUTH_BANNER packet");

    } else {

        SSH_LOG(SSH_LOG_DEBUG,

                "Received SSH_USERAUTH_BANNER packet");

        if (session->banner != NULL)

            ssh_string_free(session->banner);

        session->banner = banner;

    }

    return SSH_PACKET_USED;

}

/**

 * @internal

 *

 * @brief Handles a SSH_USERAUTH_FAILURE packet.

 *

 * This handles the complete or partial authentication failure.

 */

SSH_PACKET_CALLBACK(ssh_packet_userauth_failure) {

    const char *current_method = ssh_auth_get_current_method(session);

    char *auth_methods = NULL;

    uint8_t partial = 0;

    int rc;

    (void) type;

    (void) user;

    rc = ssh_buffer_unpack(packet, "sb", &auth_methods, &partial);

    if (rc != SSH_OK) {

        ssh_set_error(session, SSH_FATAL,

                      "Invalid SSH_MSG_USERAUTH_FAILURE message");

        session->auth.state = SSH_AUTH_STATE_ERROR;

        goto end;

    }

    if (partial) {

        session->auth.state = SSH_AUTH_STATE_PARTIAL;

        SSH_LOG(SSH_LOG_INFO,

                "Partial success for '%s'. Authentication that can continue: %s",

                current_method,

                auth_methods);

    } else {

        session->auth.state = SSH_AUTH_STATE_FAILED;

        ssh_set_error(session, SSH_REQUEST_DENIED,

                      "Access denied for '%s'. Authentication that can continue: %s",

                      current_method,

                      auth_methods);

        SSH_LOG(SSH_LOG_INFO,

                "%s",

                ssh_get_error(session));

    }

    session->auth.supported_methods = 0;

    if (strstr(auth_methods, "password") != NULL) {

        session->auth.supported_methods |= SSH_AUTH_METHOD_PASSWORD;

    }

    if (strstr(auth_methods, "keyboard-interactive") != NULL) {

        session->auth.supported_methods |= SSH_AUTH_METHOD_INTERACTIVE;

    }

    if (strstr(auth_methods, "publickey") != NULL) {

        session->auth.supported_methods |= SSH_AUTH_METHOD_PUBLICKEY;

    }

    if (strstr(auth_methods, "hostbased") != NULL) {

        session->auth.supported_methods |= SSH_AUTH_METHOD_HOSTBASED;

    }

    if (strstr(auth_methods, "gssapi-with-mic") != NULL) {

        session->auth.supported_methods |= SSH_AUTH_METHOD_GSSAPI_MIC;

    }

end:

    session->auth.current_method = SSH_AUTH_METHOD_UNKNOWN;

    SAFE_FREE(auth_methods);

    return SSH_PACKET_USED;

}

/**

 * @internal

 *

 * @brief Handles a SSH_USERAUTH_SUCCESS packet.

 *

 * It is also used to communicate the new to the upper levels.

 */

SSH_PACKET_CALLBACK(ssh_packet_userauth_success)

{

  struct ssh_crypto_struct *crypto = NULL;

  (void)packet;

  (void)type;

  (void)user;

  SSH_LOG(SSH_LOG_DEBUG, "Authentication successful");

  SSH_LOG(SSH_LOG_TRACE, "Received SSH_USERAUTH_SUCCESS");

  session->auth.state = SSH_AUTH_STATE_SUCCESS;

  session->session_state = SSH_SESSION_STATE_AUTHENTICATED;

  session->flags |= SSH_SESSION_FLAG_AUTHENTICATED;

  crypto = ssh_packet_get_current_crypto(session, SSH_DIRECTION_OUT);

  if (crypto != NULL && crypto->delayed_compress_out) {

      SSH_LOG(SSH_LOG_DEBUG, "Enabling delayed compression OUT");

      crypto->do_compress_out = 1;

  }

  crypto = ssh_packet_get_current_crypto(session, SSH_DIRECTION_IN);

  if (crypto != NULL && crypto->delayed_compress_in) {

      SSH_LOG(SSH_LOG_DEBUG, "Enabling delayed compression IN");

      crypto->do_compress_in = 1;

  }

    /* Reset errors by previous authentication methods. */

    ssh_reset_error(session);

    session->auth.current_method = SSH_AUTH_METHOD_UNKNOWN;

  return SSH_PACKET_USED;

}

/**

 * @internal

 *

 * @brief Handles a SSH_USERAUTH_PK_OK or SSH_USERAUTH_INFO_REQUEST packet.

 *

 * Since the two types of packets share the same code, additional work is done

 * to understand if we are in a public key or keyboard-interactive context.

 */

SSH_PACKET_CALLBACK(ssh_packet_userauth_pk_ok) {

    int rc;

    SSH_LOG(SSH_LOG_TRACE,

            "Received SSH_USERAUTH_PK_OK/INFO_REQUEST/GSSAPI_RESPONSE");

    if (session->auth.state == SSH_AUTH_STATE_KBDINT_SENT) {

        /* Assuming we are in keyboard-interactive context */

        SSH_LOG(SSH_LOG_TRACE,

                "keyboard-interactive context, "

                "assuming SSH_USERAUTH_INFO_REQUEST");

        rc = ssh_packet_userauth_info_request(session,type,packet,user);

#ifdef WITH_GSSAPI

    } else if (session->auth.state == SSH_AUTH_STATE_GSSAPI_REQUEST_SENT) {

        rc = ssh_packet_userauth_gssapi_response(session, type, packet, user);

#endif

    } else if (session->auth.state == SSH_AUTH_STATE_PUBKEY_OFFER_SENT) {

        session->auth.state = SSH_AUTH_STATE_PK_OK;

        SSH_LOG(SSH_LOG_TRACE, "Assuming SSH_USERAUTH_PK_OK");

        rc = SSH_PACKET_USED;

    } else {

        session->auth.state = SSH_AUTH_STATE_ERROR;

        SSH_LOG(SSH_LOG_TRACE, "SSH_USERAUTH_PK_OK received in wrong state");

        rc = SSH_PACKET_USED;

    }

    return rc;

}

/**

 * @brief Get available authentication methods from the server.

 *

 * This requires the function ssh_userauth_none() to be called before the

 * methods are available. The server MAY return a list of methods that may

 * continue.

 *

 * @param[in] session   The SSH session.

 *

 * @param[in] username  Deprecated, set to NULL.

 *

 * @returns             A bitfield of the fllowing values:

 *                      - SSH_AUTH_METHOD_PASSWORD

 *                      - SSH_AUTH_METHOD_PUBLICKEY

 *                      - SSH_AUTH_METHOD_HOSTBASED

 *                      - SSH_AUTH_METHOD_INTERACTIVE

 *

 * @warning Other reserved flags may appear in future versions.

 * @see ssh_userauth_none()

 */

int ssh_userauth_list(ssh_session session, const char *username)

{

    (void) username; /* unused */

    if (session == NULL) {

        return 0;

    }

    return session->auth.supported_methods;

}

/**

 * @brief Try to authenticate through the "none" method.

 *

 * @param[in] session   The ssh session to use.

 *

 * @param[in] username    The username, this SHOULD be NULL.

 *

 * @returns SSH_AUTH_ERROR:   A serious error happened.\n

 *          SSH_AUTH_DENIED:  Authentication failed: use another method\n

 *          SSH_AUTH_PARTIAL: You've been partially authenticated, you still

 *                            have to use another method\n

 *          SSH_AUTH_SUCCESS: Authentication success\n

 *          SSH_AUTH_AGAIN:   In nonblocking mode, you've got to call this again

 *                            later.

 *

 * @note Most server implementations do not permit changing the username during

 * authentication. The username should only be set with ssh_options_set() only

 * before you connect to the server.

 */

int ssh_userauth_none(ssh_session session, const char *username) {

    int rc;

    switch(session->pending_call_state) {

        case SSH_PENDING_CALL_NONE:

            break;

        case SSH_PENDING_CALL_AUTH_NONE:

            goto pending;

        default:

            ssh_set_error(session, SSH_FATAL,

                          "Wrong state (%d) during pending SSH call",

                          session->pending_call_state);

            return SSH_AUTH_ERROR;

    }

    rc = ssh_userauth_request_service(session);

    if (rc == SSH_AGAIN) {

        return SSH_AUTH_AGAIN;

    } else if (rc == SSH_ERROR) {

        return SSH_AUTH_ERROR;

    }

    /* request */

    rc = ssh_buffer_pack(session->out_buffer, "bsss",

            SSH2_MSG_USERAUTH_REQUEST,

            username ? username : session->opts.username,

            "ssh-connection",

            "none"

            );

    if (rc < 0) {

        goto fail;

    }

    session->auth.current_method = SSH_AUTH_METHOD_NONE;

    session->auth.state = SSH_AUTH_STATE_AUTH_NONE_SENT;

    session->pending_call_state = SSH_PENDING_CALL_AUTH_NONE;

    rc = ssh_packet_send(session);

    if (rc == SSH_ERROR) {

        return SSH_AUTH_ERROR;

    }

pending:

    rc = ssh_userauth_get_response(session);

    if (rc != SSH_AUTH_AGAIN) {

        session->pending_call_state = SSH_PENDING_CALL_NONE;

    }

    return rc;

fail:

    ssh_set_error_oom(session);

    ssh_buffer_reinit(session->out_buffer);

    return SSH_AUTH_ERROR;

}

/**

 * @brief Try to authenticate with the given public key.

 *

 * To avoid unnecessary processing and user interaction, the following method

 * is provided for querying whether authentication using the 'pubkey' would

 * be possible.

 *

 * @param[in] session     The SSH session.

 *

 * @param[in] username    The username, this SHOULD be NULL.

 *

 * @param[in] pubkey      The public key to try.

 *

 * @return  SSH_AUTH_ERROR:   A serious error happened.\n

 *          SSH_AUTH_DENIED:  The server doesn't accept that public key as an

 *                            authentication token. Try another key or another

 *                            method.\n

 *          SSH_AUTH_PARTIAL: You've been partially authenticated, you still

 *                            have to use another method.\n

 *          SSH_AUTH_SUCCESS: The public key is accepted, you want now to use

 *                            ssh_userauth_publickey().\n

 *          SSH_AUTH_AGAIN:   In nonblocking mode, you've got to call this again

 *                            later.

 *

 * @note Most server implementations do not permit changing the username during

 * authentication. The username should only be set with ssh_options_set() only

 * before you connect to the server.

 */

int ssh_userauth_try_publickey(ssh_session session,

                               const char *username,

                               const ssh_key pubkey)

{

    ssh_string pubkey_s = NULL;

    const char *sig_type_c = NULL;

    int rc;

    if (session == NULL) {

        return SSH_AUTH_ERROR;

    }

    if (pubkey == NULL || !ssh_key_is_public(pubkey)) {

        ssh_set_error(session, SSH_FATAL, "Invalid pubkey");

        return SSH_AUTH_ERROR;

    }

    switch(session->pending_call_state) {

        case SSH_PENDING_CALL_NONE:

            break;

        case SSH_PENDING_CALL_AUTH_OFFER_PUBKEY:

            goto pending;

        default:

            ssh_set_error(session,

                          SSH_FATAL,

                          "Wrong state (%d) during pending SSH call",

                          session->pending_call_state);

            return SSH_ERROR;

    }

    /* Check if the given public key algorithm is allowed */

    sig_type_c = ssh_key_get_signature_algorithm(session, pubkey->type);

    if (sig_type_c == NULL) {

        ssh_set_error(session, SSH_REQUEST_DENIED,

                      "Invalid key type (unknown)");

        return SSH_AUTH_DENIED;

    }

    if (!ssh_key_algorithm_allowed(session, sig_type_c)) {

        ssh_set_error(session, SSH_REQUEST_DENIED,

                      "The key algorithm '%s' is not allowed to be used by"

                      " PUBLICKEY_ACCEPTED_TYPES configuration option",

                      sig_type_c);

        return SSH_AUTH_DENIED;

    }

    rc = ssh_userauth_request_service(session);

    if (rc == SSH_AGAIN) {

        return SSH_AUTH_AGAIN;

    } else if (rc == SSH_ERROR) {

        return SSH_AUTH_ERROR;

    }

    /* public key */

    rc = ssh_pki_export_pubkey_blob(pubkey, &pubkey_s);

    if (rc < 0) {

        goto fail;

    }

    /* request */

    rc = ssh_buffer_pack(session->out_buffer, "bsssbsS",

            SSH2_MSG_USERAUTH_REQUEST,

            username ? username : session->opts.username,

            "ssh-connection",

            "publickey",

            0, /* private key ? */

            sig_type_c, /* algo */

            pubkey_s /* public key */

            );

    if (rc < 0) {

        goto fail;

    }

    ssh_string_free(pubkey_s);

    session->auth.current_method = SSH_AUTH_METHOD_PUBLICKEY;

    session->auth.state = SSH_AUTH_STATE_PUBKEY_OFFER_SENT;

    session->pending_call_state = SSH_PENDING_CALL_AUTH_OFFER_PUBKEY;

    rc = ssh_packet_send(session);

    if (rc == SSH_ERROR) {

        return SSH_AUTH_ERROR;

    }

pending:

    rc = ssh_userauth_get_response(session);

    if (rc != SSH_AUTH_AGAIN) {

        session->pending_call_state = SSH_PENDING_CALL_NONE;

    }

    return rc;

fail:

    ssh_string_free(pubkey_s);

    ssh_set_error_oom(session);

    ssh_buffer_reinit(session->out_buffer);

    return SSH_AUTH_ERROR;

}

/**

 * @brief Authenticate with public/private key or certificate.

 *

 * @param[in] session     The SSH session.

 *

 * @param[in] username    The username, this SHOULD be NULL.

 *

 * @param[in] privkey     The private key for authentication.

 *

 * @return  SSH_AUTH_ERROR:   A serious error happened.\n

 *          SSH_AUTH_DENIED:  The server doesn't accept that public key as an

 *                            authentication token. Try another key or another

 *                            method.\n

 *          SSH_AUTH_PARTIAL: You've been partially authenticated, you still

 *                            have to use another method.\n

 *          SSH_AUTH_SUCCESS: The public key is accepted.\n

 *          SSH_AUTH_AGAIN:   In nonblocking mode, you've got to call this again

 *                            later.

 *

 * @note Most server implementations do not permit changing the username during

 * authentication. The username should only be set with ssh_options_set() only

 * before you connect to the server.

 */

int ssh_userauth_publickey(ssh_session session,

                           const char *username,

                           const ssh_key privkey)

{

    ssh_string str = NULL;

    int rc;

    const char *sig_type_c = NULL;

    enum ssh_keytypes_e key_type;

    enum ssh_digest_e hash_type;

    if (session == NULL) {

        return SSH_AUTH_ERROR;

    }

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

        ssh_set_error(session, SSH_FATAL, "Invalid private key");

        return SSH_AUTH_ERROR;

    }

    switch(session->pending_call_state) {

        case SSH_PENDING_CALL_NONE:

            break;

        case SSH_PENDING_CALL_AUTH_PUBKEY:

            goto pending;

        default:

            ssh_set_error(session,

                          SSH_FATAL,

                          "Bad call during pending SSH call in ssh_userauth_try_publickey");

            return SSH_AUTH_ERROR;

    }

    /* Cert auth requires presenting the cert type name (*-cert@openssh.com) */

    key_type = privkey->cert != NULL ? privkey->cert_type : privkey->type;

    /* Check if the given public key algorithm is allowed */

    sig_type_c = ssh_key_get_signature_algorithm(session, key_type);

    if (sig_type_c == NULL) {

        ssh_set_error(session, SSH_REQUEST_DENIED,

                      "Invalid key type (unknown)");

        return SSH_AUTH_DENIED;

    }

    if (!ssh_key_algorithm_allowed(session, sig_type_c)) {

        ssh_set_error(session, SSH_REQUEST_DENIED,

                      "The key algorithm '%s' is not allowed to be used by"

                      " PUBLICKEY_ACCEPTED_TYPES configuration option",

                      sig_type_c);

        return SSH_AUTH_DENIED;

    }

    rc = ssh_userauth_request_service(session);

    if (rc == SSH_AGAIN) {

        return SSH_AUTH_AGAIN;

    } else if (rc == SSH_ERROR) {

        return SSH_AUTH_ERROR;

    }

    /* get public key or cert */

    rc = ssh_pki_export_pubkey_blob(privkey, &str);

    if (rc < 0) {

        goto fail;

    }

    /* request */

    rc = ssh_buffer_pack(session->out_buffer, "bsssbsS",

            SSH2_MSG_USERAUTH_REQUEST,

            username ? username : session->opts.username,

            "ssh-connection",

            "publickey",

            1, /* private key */

            sig_type_c, /* algo */

            str /* public key or cert */

            );

    if (rc < 0) {

        goto fail;

    }

    ssh_string_free(str);

    /* Get the hash type to be used in the signature based on the key type */

    hash_type = ssh_key_type_to_hash(session, privkey->type);

    /* sign the buffer with the private key */

    str = ssh_pki_do_sign(session, session->out_buffer, privkey, hash_type);

    if (str == NULL) {

        goto fail;

    }

    rc = ssh_buffer_add_ssh_string(session->out_buffer, str);

    ssh_string_free(str);

    str = NULL;

    if (rc < 0) {

        goto fail;

    }

    session->auth.current_method = SSH_AUTH_METHOD_PUBLICKEY;

    session->auth.state = SSH_AUTH_STATE_PUBKEY_AUTH_SENT;

    session->pending_call_state = SSH_PENDING_CALL_AUTH_PUBKEY;

    rc = ssh_packet_send(session);

    if (rc == SSH_ERROR) {

        return SSH_AUTH_ERROR;

    }

pending:

    rc = ssh_userauth_get_response(session);

    if (rc != SSH_AUTH_AGAIN) {

        session->pending_call_state = SSH_PENDING_CALL_NONE;

    }

    return rc;

fail:

    ssh_string_free(str);

    ssh_set_error_oom(session);

    ssh_buffer_reinit(session->out_buffer);

    return SSH_AUTH_ERROR;

}

#ifndef _WIN32

static int ssh_userauth_agent_publickey(ssh_session session,

                                        const char *username,

                                        ssh_key pubkey)

{

    ssh_string pubkey_s = NULL;

    ssh_string sig_blob = NULL;

    const char *sig_type_c = NULL;

    int rc;

    switch(session->pending_call_state) {

        case SSH_PENDING_CALL_NONE:

            break;

        case SSH_PENDING_CALL_AUTH_AGENT:

            goto pending;

        default:

            ssh_set_error(session,

                          SSH_FATAL,

                          "Bad call during pending SSH call in ssh_userauth_try_publickey");

            return SSH_ERROR;

    }

    rc = ssh_userauth_request_service(session);

    if (rc == SSH_AGAIN) {

        return SSH_AUTH_AGAIN;

    } else if (rc == SSH_ERROR) {

        return SSH_AUTH_ERROR;

    }

    /* public key */

    rc = ssh_pki_export_pubkey_blob(pubkey, &pubkey_s);

    if (rc < 0) {

        goto fail;

    }

    /* Check if the given public key algorithm is allowed */

    sig_type_c = ssh_key_get_signature_algorithm(session, pubkey->type);

    if (sig_type_c == NULL) {

        ssh_set_error(session, SSH_REQUEST_DENIED,

                      "Invalid key type (unknown)");

        SSH_STRING_FREE(pubkey_s);

        return SSH_AUTH_DENIED;

    }

    if (!ssh_key_algorithm_allowed(session, sig_type_c)) {

        ssh_set_error(session, SSH_REQUEST_DENIED,

                      "The key algorithm '%s' is not allowed to be used by"

                      " PUBLICKEY_ACCEPTED_TYPES configuration option",

                      sig_type_c);

        SSH_STRING_FREE(pubkey_s);

        return SSH_AUTH_DENIED;

    }

    /* request */

    rc = ssh_buffer_pack(session->out_buffer, "bsssbsS",

            SSH2_MSG_USERAUTH_REQUEST,

            username ? username : session->opts.username,

            "ssh-connection",

            "publickey",

            1, /* private key */

            sig_type_c, /* algo */

            pubkey_s /* public key */

            );

    SSH_STRING_FREE(pubkey_s);

    if (rc < 0) {

        goto fail;

    }

    /* sign the buffer with the private key */

    sig_blob = ssh_pki_do_sign_agent(session, session->out_buffer, pubkey);

    if (sig_blob == NULL) {

        goto fail;

    }

    rc = ssh_buffer_add_ssh_string(session->out_buffer, sig_blob);

    SSH_STRING_FREE(sig_blob);

    if (rc < 0) {

        goto fail;

    }

    session->auth.current_method = SSH_AUTH_METHOD_PUBLICKEY;

    session->auth.state = SSH_AUTH_STATE_PUBKEY_AUTH_SENT;

    session->pending_call_state = SSH_PENDING_CALL_AUTH_AGENT;

    rc = ssh_packet_send(session);

    if (rc == SSH_ERROR) {

        return SSH_AUTH_ERROR;

    }

pending:

    rc = ssh_userauth_get_response(session);

    if (rc != SSH_AUTH_AGAIN) {

        session->pending_call_state = SSH_PENDING_CALL_NONE;

    }

    return rc;

fail:

    ssh_set_error_oom(session);

    ssh_buffer_reinit(session->out_buffer);

    SSH_STRING_FREE(pubkey_s);

    return SSH_AUTH_ERROR;

}

enum ssh_agent_state_e {

    SSH_AGENT_STATE_NONE = 0,

    SSH_AGENT_STATE_PUBKEY,

    SSH_AGENT_STATE_AUTH

};

struct ssh_agent_state_struct {

    enum ssh_agent_state_e state;

    ssh_key pubkey;

    char *comment;

};

/* Internal function */

void ssh_agent_state_free(void *data) {

    struct ssh_agent_state_struct *state = data;

    if (state) {

        ssh_string_free_char(state->comment);

        ssh_key_free(state->pubkey);

        free (state);

    }

}

/**

 * @brief Try to do public key authentication with ssh agent.

 *

 * @param[in]  session  The ssh session to use.

 *

 * @param[in]  username The username, this SHOULD be NULL.

 *

 * @return  SSH_AUTH_ERROR:   A serious error happened.\n

 *          SSH_AUTH_DENIED:  The server doesn't accept that public key as an

 *                            authentication token. Try another key or another

 *                            method.\n

 *          SSH_AUTH_PARTIAL: You've been partially authenticated, you still

 *                            have to use another method.\n

 *          SSH_AUTH_SUCCESS: The public key is accepted, you want now to use

 *                            ssh_userauth_publickey().\n

 *          SSH_AUTH_AGAIN:   In nonblocking mode, you've got to call this again

 *                            later.

 *

 * @note Most server implementations do not permit changing the username during

 * authentication. The username should only be set with ssh_options_set() only

 * before you connect to the server.

 */

int ssh_userauth_agent(ssh_session session,

                       const char *username) {

    int rc = SSH_AUTH_ERROR;

    struct ssh_agent_state_struct *state;

    if (session == NULL) {

        return SSH_AUTH_ERROR;

    }

    if (!ssh_agent_is_running(session)) {