/*

 * messages.c - message parsing for client and server

 *

 * This file is part of the SSH Library

 *

 * Copyright (c) 2003-2013 by Aris Adamantiadis

 *

 * 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 <string.h>

#include <stdlib.h>

#ifndef _WIN32

#include <netinet/in.h>

#include <arpa/inet.h>

#endif

#include "libssh/libssh.h"

#include "libssh/priv.h"

#include "libssh/ssh2.h"

#include "libssh/buffer.h"

#include "libssh/packet.h"

#include "libssh/channels.h"

#include "libssh/session.h"

#include "libssh/misc.h"

#include "libssh/pki.h"

#include "libssh/dh.h"

#include "libssh/messages.h"

#ifdef WITH_SERVER

#include "libssh/server.h"

#include "libssh/gssapi.h"

#endif

/**

 * @defgroup libssh_messages The SSH message functions

 * @ingroup libssh

 *

 * This file contains the message parsing utilities for client and server

 * programs using libssh.

 *

 * On the server the the main loop of the program will call

 * ssh_message_get(session) to get messages as they come. They are not 1-1 with

 * the protocol messages. Then, the user will know what kind of a message it is

 * and use the appropriate functions to handle it (or use the default handlers

 * if you don't know what to do).

 *

 * @{

 */

static ssh_message ssh_message_new(ssh_session session)

{

    ssh_message msg = calloc(1, sizeof(struct ssh_message_struct));

    if (msg == NULL) {

        return NULL;

    }

    msg->session = session;

    /* Set states explicitly */

    msg->auth_request.signature_state = SSH_PUBLICKEY_STATE_NONE;

    return msg;

}

#ifndef WITH_SERVER

/* Reduced version of the reply default that only reply with

 * SSH_MSG_UNIMPLEMENTED

 */

static int ssh_message_reply_default(ssh_message msg) {

  SSH_LOG(SSH_LOG_FUNCTIONS, "Reporting unknown packet");

  if (ssh_buffer_add_u8(msg->session->out_buffer, SSH2_MSG_UNIMPLEMENTED) < 0)

    goto error;

  if (ssh_buffer_add_u32(msg->session->out_buffer,

      htonl(msg->session->recv_seq-1)) < 0)

    goto error;

  return ssh_packet_send(msg->session);

  error:

  return SSH_ERROR;

}

#endif

#ifdef WITH_SERVER

static int ssh_execute_server_request(ssh_session session, ssh_message msg)

{

    ssh_channel channel = NULL;

    int rc;

    switch(msg->type) {

        case SSH_REQUEST_AUTH:

            if (msg->auth_request.method == SSH_AUTH_METHOD_PASSWORD &&

                ssh_callbacks_exists(session->server_callbacks, auth_password_function)) {

                rc = session->server_callbacks->auth_password_function(session,

                        msg->auth_request.username, msg->auth_request.password,

                        session->server_callbacks->userdata);

                if (rc == SSH_AUTH_SUCCESS || rc == SSH_AUTH_PARTIAL) {

                    ssh_message_auth_reply_success(msg, rc == SSH_AUTH_PARTIAL);

                } else {

                    ssh_message_reply_default(msg);

                }

                return SSH_OK;

            } else if(msg->auth_request.method == SSH_AUTH_METHOD_PUBLICKEY &&

                      ssh_callbacks_exists(session->server_callbacks, auth_pubkey_function)) {

               rc = session->server_callbacks->auth_pubkey_function(session,

                       msg->auth_request.username, msg->auth_request.pubkey,

                       msg->auth_request.signature_state,

                       session->server_callbacks->userdata);

               if (msg->auth_request.signature_state != SSH_PUBLICKEY_STATE_NONE) {

                 if (rc == SSH_AUTH_SUCCESS || rc == SSH_AUTH_PARTIAL) {

                   ssh_message_auth_reply_success(msg, rc == SSH_AUTH_PARTIAL);

                 } else {

                   ssh_message_reply_default(msg);

                 }

               } else {

                 if (rc == SSH_AUTH_SUCCESS) {

                   ssh_message_auth_reply_pk_ok_simple(msg);

                 } else {

                   ssh_message_reply_default(msg);

                 }

               }

               return SSH_OK;

            } else if (msg->auth_request.method == SSH_AUTH_METHOD_NONE &&

                       ssh_callbacks_exists(session->server_callbacks, auth_none_function)) {

                rc = session->server_callbacks->auth_none_function(session,

                    msg->auth_request.username, session->server_callbacks->userdata);

                if (rc == SSH_AUTH_SUCCESS || rc == SSH_AUTH_PARTIAL){

                    ssh_message_auth_reply_success(msg, rc == SSH_AUTH_PARTIAL);

                } else {

                    ssh_message_reply_default(msg);

                }

                return SSH_OK;

            }

            break;

        case SSH_REQUEST_CHANNEL_OPEN:

            if (msg->channel_request_open.type == SSH_CHANNEL_SESSION &&

                ssh_callbacks_exists(session->server_callbacks, channel_open_request_session_function)) {

                channel = session->server_callbacks->channel_open_request_session_function(session,

                        session->server_callbacks->userdata);

                if (channel != NULL) {

                    rc = ssh_message_channel_request_open_reply_accept_channel(msg, channel);

                    if (rc != SSH_OK) {

                        SSH_LOG(SSH_LOG_WARNING,

                                "Failed to send reply for accepting a channel "

                                "open");

                    }

                    return SSH_OK;

                } else {

                    ssh_message_reply_default(msg);

                }

                return SSH_OK;

            }

            break;

        case SSH_REQUEST_CHANNEL:

            channel = msg->channel_request.channel;

            if (msg->channel_request.type == SSH_CHANNEL_REQUEST_PTY){

                ssh_callbacks_iterate(channel->callbacks,

                                      ssh_channel_callbacks,

                                      channel_pty_request_function) {

                    rc = ssh_callbacks_iterate_exec(channel_pty_request_function,

                                                    session,

                                                    channel,

                                                    msg->channel_request.TERM,

                                                    msg->channel_request.width,

                                                    msg->channel_request.height,

                                                    msg->channel_request.pxwidth,

                                                    msg->channel_request.pxheight);

                    if (rc == 0) {

                        ssh_message_channel_request_reply_success(msg);

                    } else {

                        ssh_message_reply_default(msg);

                    }

                    return SSH_OK;

                }

                ssh_callbacks_iterate_end();

            } else if (msg->channel_request.type == SSH_CHANNEL_REQUEST_SHELL){

                ssh_callbacks_iterate(channel->callbacks,

                                      ssh_channel_callbacks,

                                      channel_shell_request_function) {

                    rc = ssh_callbacks_iterate_exec(channel_shell_request_function,

                                                    session,

                                                    channel);

                    if (rc == 0) {

                        ssh_message_channel_request_reply_success(msg);

                    } else {

                        ssh_message_reply_default(msg);

                    }

                    return SSH_OK;

                }

                ssh_callbacks_iterate_end();

            } else if (msg->channel_request.type == SSH_CHANNEL_REQUEST_X11){

                ssh_callbacks_iterate(channel->callbacks,

                                      ssh_channel_callbacks,

                                      channel_x11_req_function) {

                    ssh_callbacks_iterate_exec(channel_x11_req_function,

                                               session,

                                               channel,

                                               msg->channel_request.x11_single_connection,

                                               msg->channel_request.x11_auth_protocol,

                                               msg->channel_request.x11_auth_cookie,

                                               msg->channel_request.x11_screen_number);

                    ssh_message_channel_request_reply_success(msg);

                    return SSH_OK;

                }

                ssh_callbacks_iterate_end();

            } else if (msg->channel_request.type == SSH_CHANNEL_REQUEST_WINDOW_CHANGE){

                ssh_callbacks_iterate(channel->callbacks,

                                      ssh_channel_callbacks,

                                      channel_pty_window_change_function) {

                    rc = ssh_callbacks_iterate_exec(channel_pty_window_change_function,

                                                    session,

                                                    channel,

                                                    msg->channel_request.width,

                                                    msg->channel_request.height,

                                                    msg->channel_request.pxwidth,

                                                    msg->channel_request.pxheight);

                    if (rc != SSH_OK) {

                        SSH_LOG(SSH_LOG_WARNING,

                                "Failed to iterate callbacks for window change");

                    }

                    return SSH_OK;

                }

                ssh_callbacks_iterate_end();

            } else if (msg->channel_request.type == SSH_CHANNEL_REQUEST_EXEC){

                ssh_callbacks_iterate(channel->callbacks,

                                      ssh_channel_callbacks,

                                      channel_exec_request_function) {

                    rc = ssh_callbacks_iterate_exec(channel_exec_request_function,

                                                    session,

                                                    channel,

                                                    msg->channel_request.command);

                    if (rc == 0) {

                        ssh_message_channel_request_reply_success(msg);

                    } else {

                        ssh_message_reply_default(msg);

                    }

                    return SSH_OK;

                }

                ssh_callbacks_iterate_end();

            } else if (msg->channel_request.type == SSH_CHANNEL_REQUEST_ENV){

                ssh_callbacks_iterate(channel->callbacks,

                                      ssh_channel_callbacks,

                                      channel_env_request_function) {

                    rc = ssh_callbacks_iterate_exec(channel_env_request_function,

                                                    session,

                                                    channel,

                                                    msg->channel_request.var_name,

                                                    msg->channel_request.var_value);

                    if (rc == 0) {

                        ssh_message_channel_request_reply_success(msg);

                    } else {

                        ssh_message_reply_default(msg);

                    }

                    return SSH_OK;

                }

                ssh_callbacks_iterate_end();

            } else if (msg->channel_request.type == SSH_CHANNEL_REQUEST_SUBSYSTEM){

                ssh_callbacks_iterate(channel->callbacks,

                                      ssh_channel_callbacks,

                                      channel_subsystem_request_function) {

                    rc = ssh_callbacks_iterate_exec(channel_subsystem_request_function,

                                                    session,

                                                    channel,

                                                    msg->channel_request.subsystem);

                    if (rc == 0) {

                        ssh_message_channel_request_reply_success(msg);

                    } else {

                        ssh_message_reply_default(msg);

                    }

                    return SSH_OK;

                }

                ssh_callbacks_iterate_end();

            }

            break;

        case SSH_REQUEST_SERVICE:

            if (ssh_callbacks_exists(session->server_callbacks, service_request_function)) {

                rc = session->server_callbacks->service_request_function(session,

                        msg->service_request.service, session->server_callbacks->userdata);

                if (rc == 0) {

                    ssh_message_reply_default(msg);

                } else {

                    ssh_disconnect(session);

                }

                return SSH_OK;

            }

            return SSH_AGAIN;

        case SSH_REQUEST_GLOBAL:

            break;

    }

    return SSH_AGAIN;

}

static int ssh_execute_client_request(ssh_session session, ssh_message msg)

{

    ssh_channel channel = NULL;

    int rc = SSH_AGAIN;

    if (msg->type == SSH_REQUEST_CHANNEL_OPEN

        && msg->channel_request_open.type == SSH_CHANNEL_X11

        && ssh_callbacks_exists(session->common.callbacks, channel_open_request_x11_function)) {

        channel = session->common.callbacks->channel_open_request_x11_function (session,

                msg->channel_request_open.originator,

                msg->channel_request_open.originator_port,

                session->common.callbacks->userdata);

        if (channel != NULL) {

            rc = ssh_message_channel_request_open_reply_accept_channel(msg, channel);

            return rc;

        } else {

            ssh_message_reply_default(msg);

        }

        return SSH_OK;

    } else if (msg->type == SSH_REQUEST_CHANNEL_OPEN

               && msg->channel_request_open.type == SSH_CHANNEL_AUTH_AGENT

               && ssh_callbacks_exists(session->common.callbacks, channel_open_request_auth_agent_function)) {

        channel = session->common.callbacks->channel_open_request_auth_agent_function (session,

                session->common.callbacks->userdata);

        if (channel != NULL) {

            rc = ssh_message_channel_request_open_reply_accept_channel(msg, channel);

            return rc;

        } else {

            ssh_message_reply_default(msg);

        }

        return SSH_OK;

    }

    return rc;

}

/** @internal

 * Executes the callbacks defined in session->server_callbacks, out of an ssh_message

 * I don't like ssh_message interface but it works.

 * @returns SSH_OK if the message has been handled, or SSH_AGAIN otherwise.

 */

static int ssh_execute_server_callbacks(ssh_session session, ssh_message msg){

    int rc = SSH_AGAIN;

    if (session->server_callbacks != NULL){

        rc = ssh_execute_server_request(session, msg);

    } else if (session->common.callbacks != NULL) {

        /* This one is in fact a client callback... */

        rc = ssh_execute_client_request(session, msg);

    }

    return rc;

}

#endif /* WITH_SERVER */

static int ssh_execute_message_callback(ssh_session session, ssh_message msg) {

	int ret;

    if(session->ssh_message_callback != NULL) {

        ret = session->ssh_message_callback(session, msg,

                session->ssh_message_callback_data);

        if(ret == 1) {

            ret = ssh_message_reply_default(msg);

            SSH_MESSAGE_FREE(msg);

            if(ret != SSH_OK) {

                return ret;

            }

        } else {

            SSH_MESSAGE_FREE(msg);

        }

    } else {

        ret = ssh_message_reply_default(msg);

        SSH_MESSAGE_FREE(msg);

        if(ret != SSH_OK) {

            return ret;

        }

    }

    return SSH_OK;

}

/**

 * @internal

 *

 * @brief Add a message to the current queue of messages to be parsed and/or call

 * the various callback functions.

 *

 * @param[in]  session  The SSH session to add the message.

 *

 * @param[in]  message  The message to add to the queue.

 */

static void ssh_message_queue(ssh_session session, ssh_message message)

{

#ifdef WITH_SERVER

    int ret;

#endif

    if (message == NULL) {

        return;

    }

#ifdef WITH_SERVER

    /* probably not the best place to execute server callbacks, but still better

     * than nothing.

     */

    ret = ssh_execute_server_callbacks(session, message);

    if (ret == SSH_OK) {

        SSH_MESSAGE_FREE(message);

        return;

    }

#endif /* WITH_SERVER */

    if (session->ssh_message_callback != NULL) {

        /* This will transfer the message, do not free. */

        ssh_execute_message_callback(session, message);

        return;

    }

    if (session->server_callbacks != NULL) {

        /* if we have server callbacks, but nothing was executed, it means we are

         * in non-synchronous mode, and we just don't care about the message we

         * received. Just send a default response. Do not queue it.

         */

        ssh_message_reply_default(message);

        SSH_MESSAGE_FREE(message);

        return;

    }

    if (session->ssh_message_list == NULL) {

        session->ssh_message_list = ssh_list_new();

        if (session->ssh_message_list == NULL) {

            /*

             * If the message list couldn't be allocated, the message can't be

             * enqueued

             */

            ssh_message_reply_default(message);

            ssh_set_error_oom(session);

            SSH_MESSAGE_FREE(message);

            return;

        }

    }

    /* This will transfer the message, do not free. */

    ssh_list_append(session->ssh_message_list, message);

    return;

}

/**

 * @internal

 *

 * @brief Pop a message from the message list and dequeue it.

 *

 * @param[in]  session  The SSH session to pop the message.

 *

 * @returns             The head message or NULL if it doesn't exist.

 */

ssh_message ssh_message_pop_head(ssh_session session){

  ssh_message msg=NULL;

  struct ssh_iterator *i;

  if(session->ssh_message_list == NULL)

    return NULL;

  i=ssh_list_get_iterator(session->ssh_message_list);

  if(i != NULL){

    msg=ssh_iterator_value(ssh_message,i);

    ssh_list_remove(session->ssh_message_list,i);

  }

  return msg;

}

/* Returns 1 if there is a message available */

static int ssh_message_termination(void *s){

  ssh_session session = s;

  struct ssh_iterator *it;

  if(session->session_state == SSH_SESSION_STATE_ERROR)

    return 1;

  it = ssh_list_get_iterator(session->ssh_message_list);

  if(!it)

    return 0;

  else

    return 1;

}

/**

 * @brief Retrieve a SSH message from a SSH session.

 *

 * @param[in]  session  The SSH session to get the message.

 *

 * @returns             The SSH message received, NULL in case of error, or timeout

 *                      elapsed.

 *

 * @warning This function blocks until a message has been received. Betterset up

 *          a callback if this behavior is unwanted.

 */

ssh_message ssh_message_get(ssh_session session) {

  ssh_message msg = NULL;

  int rc;

  msg=ssh_message_pop_head(session);

  if(msg) {

      return msg;

  }

  if(session->ssh_message_list == NULL) {

      session->ssh_message_list = ssh_list_new();

  }

  rc = ssh_handle_packets_termination(session, SSH_TIMEOUT_USER,

      ssh_message_termination, session);

  if(rc || session->session_state == SSH_SESSION_STATE_ERROR)

    return NULL;

  msg=ssh_list_pop_head(ssh_message, session->ssh_message_list);

  return msg;

}

/**

 * @brief Get the type of the message.

 *

 * @param[in] msg       The message to get the type from.

 *

 * @return              The message type or -1 on error.

 */

int ssh_message_type(ssh_message msg) {

  if (msg == NULL) {

    return -1;

  }

  return msg->type;

}

/**

 * @brief Get the subtype of the message.

 *

 * @param[in] msg       The message to get the subtype from.

 *

 * @return              The message type or -1 on error.

 */

int ssh_message_subtype(ssh_message msg) {

  if (msg == NULL) {

    return -1;

  }

  switch(msg->type) {

    case SSH_REQUEST_AUTH:

      return msg->auth_request.method;

    case SSH_REQUEST_CHANNEL_OPEN:

      return msg->channel_request_open.type;

    case SSH_REQUEST_CHANNEL:

      return msg->channel_request.type;

    case SSH_REQUEST_GLOBAL:

      return msg->global_request.type;

  }

  return -1;

}

/**

 * @brief Free a SSH message.

 *

 * @param[in] msg       The message to release the memory.

 */

void ssh_message_free(ssh_message msg){

  if (msg == NULL) {

    return;

  }

  switch(msg->type) {

    case SSH_REQUEST_AUTH:

      SAFE_FREE(msg->auth_request.username);

      if (msg->auth_request.password) {

        explicit_bzero(msg->auth_request.password,

                       strlen(msg->auth_request.password));

        SAFE_FREE(msg->auth_request.password);

      }

      ssh_key_free(msg->auth_request.pubkey);

      break;

    case SSH_REQUEST_CHANNEL_OPEN:

      SAFE_FREE(msg->channel_request_open.originator);

      SAFE_FREE(msg->channel_request_open.destination);

      break;

    case SSH_REQUEST_CHANNEL:

      SAFE_FREE(msg->channel_request.TERM);

      SAFE_FREE(msg->channel_request.modes);

      SAFE_FREE(msg->channel_request.var_name);

      SAFE_FREE(msg->channel_request.var_value);

      SAFE_FREE(msg->channel_request.command);

      SAFE_FREE(msg->channel_request.subsystem);

      switch (msg->channel_request.type) {

      case SSH_CHANNEL_REQUEST_EXEC:

          SAFE_FREE(msg->channel_request.command);

          break;

      case SSH_CHANNEL_REQUEST_ENV:

          SAFE_FREE(msg->channel_request.var_name);

          SAFE_FREE(msg->channel_request.var_value);

          break;

      case SSH_CHANNEL_REQUEST_PTY:

          SAFE_FREE(msg->channel_request.TERM);

          break;

      case SSH_CHANNEL_REQUEST_SUBSYSTEM:

          SAFE_FREE(msg->channel_request.subsystem);

          break;

      case SSH_CHANNEL_REQUEST_X11:

          SAFE_FREE(msg->channel_request.x11_auth_protocol);

          SAFE_FREE(msg->channel_request.x11_auth_cookie);

          break;

      }

      break;

    case SSH_REQUEST_SERVICE:

      SAFE_FREE(msg->service_request.service);

      break;

    case SSH_REQUEST_GLOBAL:

      SAFE_FREE(msg->global_request.bind_address);

      break;

  }

  ZERO_STRUCTP(msg);

  SAFE_FREE(msg);

}

#ifdef WITH_SERVER

SSH_PACKET_CALLBACK(ssh_packet_service_request)

{

    char *service_c = NULL;

    ssh_message msg = NULL;

    int rc;

    (void)type;

    (void)user;

    rc = ssh_buffer_unpack(packet,

                           "s",

                           &service_c);

    if (rc != SSH_OK) {

        ssh_set_error(session,

                      SSH_FATAL,

                      "Invalid SSH_MSG_SERVICE_REQUEST packet");

        goto error;

    }

    SSH_LOG(SSH_LOG_PACKET,

            "Received a SERVICE_REQUEST for service %s",

            service_c);

    msg = ssh_message_new(session);

    if (msg == NULL) {

        SAFE_FREE(service_c);

        goto error;

    }

    msg->type = SSH_REQUEST_SERVICE;

    msg->service_request.service = service_c;

    ssh_message_queue(session, msg);

error:

    return SSH_PACKET_USED;

}

/*

 * This function concats in a buffer the values needed to do a signature

 * verification.

 */

static ssh_buffer ssh_msg_userauth_build_digest(ssh_session session,

                                                ssh_message msg,

                                                const char *service,

                                                ssh_string algo)

{

    struct ssh_crypto_struct *crypto = NULL;

    ssh_buffer buffer;

    ssh_string str=NULL;

    int rc;

    crypto = ssh_packet_get_current_crypto(session, SSH_DIRECTION_IN);

    if (crypto == NULL) {

        return NULL;

    }

    buffer = ssh_buffer_new();

    if (buffer == NULL) {

        return NULL;

    }

    rc = ssh_pki_export_pubkey_blob(msg->auth_request.pubkey, &str);

    if (rc < 0) {

        SSH_BUFFER_FREE(buffer);

        return NULL;

    }

    rc = ssh_buffer_pack(buffer,

                         "dPbsssbsS",

                         crypto->digest_len, /* session ID string */

                         (size_t)crypto->digest_len, crypto->session_id,

                         SSH2_MSG_USERAUTH_REQUEST, /* type */

                         msg->auth_request.username,

                         service,

                         "publickey", /* method */

                         1, /* has to be signed (true) */

                         ssh_string_get_char(algo), /* pubkey algorithm */

                         str); /* public key as a blob */

    SSH_STRING_FREE(str);

    if (rc != SSH_OK) {

        ssh_set_error_oom(session);

        SSH_BUFFER_FREE(buffer);

        return NULL;

    }

    return buffer;

}

/**

 * @internal

 *

 * @brief Handle a SSH_MSG_MSG_USERAUTH_REQUEST packet and queue a

 * SSH Message

 */

SSH_PACKET_CALLBACK(ssh_packet_userauth_request){

  ssh_message msg = NULL;

  ssh_signature sig = NULL;

  char *service = NULL;

  char *method = NULL;

  int cmp;

  int rc;

  (void)user;

  (void)type;

  msg = ssh_message_new(session);

  if (msg == NULL) {

    ssh_set_error_oom(session);

    goto error;

  }

  msg->type = SSH_REQUEST_AUTH;

  rc = ssh_buffer_unpack(packet,

                         "sss",

                         &msg->auth_request.username,

                         &service,

                         &method);

  if (rc != SSH_OK) {

      goto error;

  }

  SSH_LOG(SSH_LOG_PACKET,

      "Auth request for service %s, method %s for user '%s'",

      service, method,

      msg->auth_request.username);

  cmp = strcmp(service, "ssh-connection");

  if (cmp != 0) {

      SSH_LOG(SSH_LOG_WARNING,

              "Invalid service request: %s",

              service);

      goto end;

  }

  if (strcmp(method, "none") == 0) {

    msg->auth_request.method = SSH_AUTH_METHOD_NONE;

    goto end;

  }

  if (strcmp(method, "password") == 0) {

    uint8_t tmp;

    msg->auth_request.method = SSH_AUTH_METHOD_PASSWORD;

    rc = ssh_buffer_unpack(packet, "bs", &tmp, &msg->auth_request.password);

    if (rc != SSH_OK) {

      goto error;

    }

    goto end;

  }

  if (strcmp(method, "keyboard-interactive") == 0) {

    ssh_string lang = NULL;

    ssh_string submethods = NULL;

    msg->auth_request.method = SSH_AUTH_METHOD_INTERACTIVE;

    lang = ssh_buffer_get_ssh_string(packet);

    if (lang == NULL) {

      goto error;

    }

    /* from the RFC 4256

     * 3.1.  Initial Exchange

     * "The language tag is deprecated and SHOULD be the empty string."

     */

    SSH_STRING_FREE(lang);

    submethods = ssh_buffer_get_ssh_string(packet);

    if (submethods == NULL) {

      goto error;

    }

    /* from the RFC 4256

     * 3.1.  Initial Exchange

     * "One possible implementation strategy of the submethods field on the

     *  server is that, unless the user may use multiple different

     *  submethods, the server ignores this field."

     */

    SSH_STRING_FREE(submethods);

    goto end;

  }

  if (strcmp(method, "publickey") == 0) {

    ssh_string algo = NULL;

    ssh_string pubkey_blob = NULL;

    uint8_t has_sign;

    msg->auth_request.method = SSH_AUTH_METHOD_PUBLICKEY;

    SAFE_FREE(method);

    rc = ssh_buffer_unpack(packet, "bSS",

            &has_sign,

            &algo,

            &pubkey_blob

            );

    if (rc != SSH_OK) {

      goto error;

    }

    rc = ssh_pki_import_pubkey_blob(pubkey_blob, &msg->auth_request.pubkey);

    SSH_STRING_FREE(pubkey_blob);

    pubkey_blob = NULL;

    if (rc < 0) {

        SSH_STRING_FREE(algo);

        algo = NULL;

        goto error;

    }

    msg->auth_request.signature_state = SSH_PUBLICKEY_STATE_NONE;

    // has a valid signature ?

    if(has_sign) {

        ssh_string sig_blob = NULL;

        ssh_buffer digest = NULL;

        sig_blob = ssh_buffer_get_ssh_string(packet);

        if(sig_blob == NULL) {

            SSH_LOG(SSH_LOG_PACKET, "Invalid signature packet from peer");

            msg->auth_request.signature_state = SSH_PUBLICKEY_STATE_ERROR;

            SSH_STRING_FREE(algo);

            algo = NULL;

            goto error;

        }

        digest = ssh_msg_userauth_build_digest(session, msg, service, algo);

        SSH_STRING_FREE(algo);

        algo = NULL;

        if (digest == NULL) {

            SSH_STRING_FREE(sig_blob);

            SSH_LOG(SSH_LOG_PACKET, "Failed to get digest");

            msg->auth_request.signature_state = SSH_PUBLICKEY_STATE_WRONG;

            goto error;

        }

        rc = ssh_pki_import_signature_blob(sig_blob,

                                           msg->auth_request.pubkey,

                                           &sig);

        if (rc == SSH_OK) {

            /* Check if the signature from client matches server preferences */

            if (session->opts.pubkey_accepted_types) {

                if (!ssh_match_group(session->opts.pubkey_accepted_types,

                            sig->type_c))