/* -*- mode: C; c-file-style: "gnu" -*- */

/* dbus-auth.c Authentication

 *

 * Copyright (C) 2002, 2003, 2004 Red Hat Inc.

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * Licensed under the Academic Free License version 2.1

 * 

 * This program is free software; you can redistribute it and/or modify

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

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 * 

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

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#include "dbus-auth.h"

#include "dbus-string.h"

#include "dbus-list.h"

#include "dbus-internals.h"

#include "dbus-keyring.h"

#include "dbus-sha.h"

#include "dbus-protocol.h"

#include "dbus-userdb.h"

#ifdef __SYMBIAN32__

#include "config.h"

#endif //__SYMBIAN32__

/**

 * @defgroup DBusAuth Authentication

 * @ingroup  DBusInternals

 * @brief DBusAuth object

 *

 * DBusAuth manages the authentication negotiation when a connection

 * is first established, and also manage any encryption used over a

 * connection.

 *

 * @todo some SASL profiles require sending the empty string as a

 * challenge/response, but we don't currently allow that in our

 * protocol.

 *

 * @todo right now sometimes both ends will block waiting for input

 * from the other end, e.g. if there's an error during

 * DBUS_COOKIE_SHA1.

 *

 * @todo the cookie keyring needs to be cached globally not just

 * per-auth (which raises threadsafety issues too)

 * 

 * @todo grep FIXME in dbus-auth.c

 */

/**

 * @defgroup DBusAuthInternals Authentication implementation details

 * @ingroup  DBusInternals

 * @brief DBusAuth implementation details

 *

 * Private details of authentication code.

 *

 * @{

 */

/**

 * This function appends an initial client response to the given string

 */

typedef dbus_bool_t (* DBusInitialResponseFunction)  (DBusAuth         *auth,

                                                      DBusString       *response);

/**

 * This function processes a block of data received from the peer.

 * i.e. handles a DATA command.

 */

typedef dbus_bool_t (* DBusAuthDataFunction)     (DBusAuth         *auth,

                                                  const DBusString *data);

/**

 * This function encodes a block of data from the peer.

 */

typedef dbus_bool_t (* DBusAuthEncodeFunction)   (DBusAuth         *auth,

                                                  const DBusString *data,

                                                  DBusString       *encoded);

/**

 * This function decodes a block of data from the peer.

 */

typedef dbus_bool_t (* DBusAuthDecodeFunction)   (DBusAuth         *auth,

                                                  const DBusString *data,

                                                  DBusString       *decoded);

/**

 * This function is called when the mechanism is abandoned.

 */

typedef void        (* DBusAuthShutdownFunction) (DBusAuth       *auth);

/**

 * Virtual table representing a particular auth mechanism.

 */

typedef struct

{

  const char *mechanism; /**< Name of the mechanism */

  DBusAuthDataFunction server_data_func; /**< Function on server side for DATA */

  DBusAuthEncodeFunction server_encode_func; /**< Function on server side to encode */

  DBusAuthDecodeFunction server_decode_func; /**< Function on server side to decode */

  DBusAuthShutdownFunction server_shutdown_func; /**< Function on server side to shut down */

  DBusInitialResponseFunction client_initial_response_func; /**< Function on client side to handle initial response */

  DBusAuthDataFunction client_data_func; /**< Function on client side for DATA */

  DBusAuthEncodeFunction client_encode_func; /**< Function on client side for encode */

  DBusAuthDecodeFunction client_decode_func; /**< Function on client side for decode */

  DBusAuthShutdownFunction client_shutdown_func; /**< Function on client side for shutdown */

} DBusAuthMechanismHandler;

/**

 * Enumeration for the known authentication commands.

 */

typedef enum {

  DBUS_AUTH_COMMAND_AUTH,

  DBUS_AUTH_COMMAND_CANCEL,

  DBUS_AUTH_COMMAND_DATA,

  DBUS_AUTH_COMMAND_BEGIN,

  DBUS_AUTH_COMMAND_REJECTED,

  DBUS_AUTH_COMMAND_OK,

  DBUS_AUTH_COMMAND_ERROR,

  DBUS_AUTH_COMMAND_UNKNOWN

} DBusAuthCommand;

/**

 * Auth state function, determines the reaction to incoming events for

 * a particular state. Returns whether we had enough memory to

 * complete the operation.

 */

typedef dbus_bool_t (* DBusAuthStateFunction) (DBusAuth         *auth,

                                               DBusAuthCommand   command,

                                               const DBusString *args);

/**

 * Information about a auth state.

 */

typedef struct

{

  const char *name;               /**< Name of the state */

  DBusAuthStateFunction handler;  /**< State function for this state */

} DBusAuthStateData;

/**

 * Internal members of DBusAuth.

 */

struct DBusAuth

{

  int refcount;           /**< reference count */

  const char *side;       /**< Client or server */

  DBusString incoming;    /**< Incoming data buffer */

  DBusString outgoing;    /**< Outgoing data buffer */

  const DBusAuthStateData *state;         /**< Current protocol state */

  const DBusAuthMechanismHandler *mech;   /**< Current auth mechanism */

  DBusString identity;                   /**< Current identity we're authorizing

                                          *   as.

                                          */

  DBusCredentials credentials;      /**< Credentials read from socket,

                                     * fields may be -1

                                     */

  DBusCredentials authorized_identity; /**< Credentials that are authorized */

  DBusCredentials desired_identity;    /**< Identity client has requested */

  DBusString context;               /**< Cookie scope */

  DBusKeyring *keyring;             /**< Keyring for cookie mechanism. */

  int cookie_id;                    /**< ID of cookie to use */

  DBusString challenge;             /**< Challenge sent to client */

  char **allowed_mechs;             /**< Mechanisms we're allowed to use,

                                     * or #NULL if we can use any

                                     */

  unsigned int needed_memory : 1;   /**< We needed memory to continue since last

                                     * successful getting something done

                                     */

  unsigned int already_got_mechanisms : 1;       /**< Client already got mech list */

  unsigned int already_asked_for_initial_response : 1; /**< Already sent a blank challenge to get an initial response */

  unsigned int buffer_outstanding : 1; /**< Buffer is "checked out" for reading data into */

};

/**

 * "Subclass" of DBusAuth for client side

 */

typedef struct

{

  DBusAuth base;    /**< Parent class */

  DBusList *mechs_to_try; /**< Mechanisms we got from the server that we're going to try using */

  DBusString guid_from_server; /**< GUID received from server */

} DBusAuthClient;

/**

 * "Subclass" of DBusAuth for server side.

 */

typedef struct

{

  DBusAuth base;    /**< Parent class */

  int failures;     /**< Number of times client has been rejected */

  int max_failures; /**< Number of times we reject before disconnect */

  DBusString guid;  /**< Our globally unique ID in hex encoding */

} DBusAuthServer;

static void        goto_state                (DBusAuth                       *auth,

                                              const DBusAuthStateData        *new_state);

static dbus_bool_t send_auth                 (DBusAuth *auth,

                                              const DBusAuthMechanismHandler *mech);

static dbus_bool_t send_data                 (DBusAuth *auth,

                                              DBusString *data);

static dbus_bool_t send_rejected             (DBusAuth *auth);

static dbus_bool_t send_error                (DBusAuth *auth,

                                              const char *message);

static dbus_bool_t send_ok                   (DBusAuth *auth);

static dbus_bool_t send_begin                (DBusAuth *auth,

                                              const DBusString *args_from_ok);

static dbus_bool_t send_cancel               (DBusAuth *auth);

/**

 * Client states

 */

static dbus_bool_t handle_server_state_waiting_for_auth  (DBusAuth         *auth,

                                                          DBusAuthCommand   command,

                                                          const DBusString *args);

static dbus_bool_t handle_server_state_waiting_for_data  (DBusAuth         *auth,

                                                          DBusAuthCommand   command,

                                                          const DBusString *args);

static dbus_bool_t handle_server_state_waiting_for_begin (DBusAuth         *auth,

                                                          DBusAuthCommand   command,

                                                          const DBusString *args);

static const DBusAuthStateData server_state_waiting_for_auth = {

  "WaitingForAuth", handle_server_state_waiting_for_auth

};

static const DBusAuthStateData server_state_waiting_for_data = {

  "WaitingForData", handle_server_state_waiting_for_data

};

static const DBusAuthStateData server_state_waiting_for_begin = {

  "WaitingForBegin", handle_server_state_waiting_for_begin

};

/**

 * Client states

 */

static dbus_bool_t handle_client_state_waiting_for_data   (DBusAuth         *auth,

                                                           DBusAuthCommand   command,

                                                           const DBusString *args);

static dbus_bool_t handle_client_state_waiting_for_ok     (DBusAuth         *auth,

                                                           DBusAuthCommand   command,

                                                           const DBusString *args);

static dbus_bool_t handle_client_state_waiting_for_reject (DBusAuth         *auth,

                                                           DBusAuthCommand   command,

                                                           const DBusString *args);

static const DBusAuthStateData client_state_need_send_auth = {

  "NeedSendAuth", NULL

};

static const DBusAuthStateData client_state_waiting_for_data = {

  "WaitingForData", handle_client_state_waiting_for_data

};

static const DBusAuthStateData client_state_waiting_for_ok = {

  "WaitingForOK", handle_client_state_waiting_for_ok

};

static const DBusAuthStateData client_state_waiting_for_reject = {

  "WaitingForReject", handle_client_state_waiting_for_reject

};

/**

 * Common terminal states.  Terminal states have handler == NULL.

 */

static const DBusAuthStateData common_state_authenticated = {

  "Authenticated",  NULL

};

static const DBusAuthStateData common_state_need_disconnect = {

  "NeedDisconnect",  NULL

};

static const char auth_side_client[] = "client";

static const char auth_side_server[] = "server";

/**

 * @param auth the auth conversation

 * @returns #TRUE if the conversation is the server side

 */

#define DBUS_AUTH_IS_SERVER(auth) ((auth)->side == auth_side_server)

/**

 * @param auth the auth conversation

 * @returns #TRUE if the conversation is the client side

 */

#define DBUS_AUTH_IS_CLIENT(auth) ((auth)->side == auth_side_client)

/**

 * @param auth the auth conversation

 * @returns auth cast to DBusAuthClient

 */

#define DBUS_AUTH_CLIENT(auth)    ((DBusAuthClient*)(auth))

/**

 * @param auth the auth conversation

 * @returns auth cast to DBusAuthServer

 */

#define DBUS_AUTH_SERVER(auth)    ((DBusAuthServer*)(auth))

/**

 * The name of the auth ("client" or "server")

 * @param auth the auth conversation

 * @returns a string

 */

#define DBUS_AUTH_NAME(auth)      ((auth)->side)

static DBusAuth*

_dbus_auth_new (int size)

{

  DBusAuth *auth;

  auth = dbus_malloc0 (size);

  if (auth == NULL)

    return NULL;

  auth->refcount = 1;

  _dbus_credentials_clear (&auth->credentials);

  _dbus_credentials_clear (&auth->authorized_identity);

  _dbus_credentials_clear (&auth->desired_identity);

  auth->keyring = NULL;

  auth->cookie_id = -1;

  /* note that we don't use the max string length feature,

   * because you can't use that feature if you're going to

   * try to recover from out-of-memory (it creates

   * what looks like unrecoverable inability to alloc

   * more space in the string). But we do handle

   * overlong buffers in _dbus_auth_do_work().

   */

  if (!_dbus_string_init (&auth->incoming))

    goto enomem_0;

  if (!_dbus_string_init (&auth->outgoing))

    goto enomem_1;

  if (!_dbus_string_init (&auth->identity))

    goto enomem_2;

  if (!_dbus_string_init (&auth->context))

    goto enomem_3;

  if (!_dbus_string_init (&auth->challenge))

    goto enomem_4;

  /* default context if none is specified */

  if (!_dbus_string_append (&auth->context, "org_freedesktop_general"))

    goto enomem_5;

  return auth;

 enomem_5:

  _dbus_string_free (&auth->challenge);

 enomem_4:

  _dbus_string_free (&auth->context);

 enomem_3:

  _dbus_string_free (&auth->identity);

 enomem_2:

  _dbus_string_free (&auth->outgoing);

 enomem_1:

  _dbus_string_free (&auth->incoming);

 enomem_0:

  dbus_free (auth);

  return NULL;

}

static void

shutdown_mech (DBusAuth *auth)

{

  /* Cancel any auth */

  auth->already_asked_for_initial_response = FALSE;

  _dbus_string_set_length (&auth->identity, 0);

  _dbus_credentials_clear (&auth->authorized_identity);

  _dbus_credentials_clear (&auth->desired_identity);

  if (auth->mech != NULL)

    {

      _dbus_verbose ("%s: Shutting down mechanism %s\n",

                     DBUS_AUTH_NAME (auth), auth->mech->mechanism);

      if (DBUS_AUTH_IS_CLIENT (auth))

        (* auth->mech->client_shutdown_func) (auth);

      else

        (* auth->mech->server_shutdown_func) (auth);

      auth->mech = NULL;

    }

}

/* Returns TRUE but with an empty string hash if the

 * cookie_id isn't known. As with all this code

 * TRUE just means we had enough memory.

 */

static dbus_bool_t

sha1_compute_hash (DBusAuth         *auth,

                   int               cookie_id,

                   const DBusString *server_challenge,

                   const DBusString *client_challenge,

                   DBusString       *hash)

{

  DBusString cookie;

  DBusString to_hash;

  dbus_bool_t retval;

  _dbus_assert (auth->keyring != NULL);

  retval = FALSE;

  if (!_dbus_string_init (&cookie))

    return FALSE;

  if (!_dbus_keyring_get_hex_key (auth->keyring, cookie_id,

                                  &cookie))

    goto out_0;

  if (_dbus_string_get_length (&cookie) == 0)

    {

      retval = TRUE;

      goto out_0;

    }

  if (!_dbus_string_init (&to_hash))

    goto out_0;

  if (!_dbus_string_copy (server_challenge, 0,

                          &to_hash, _dbus_string_get_length (&to_hash)))

    goto out_1;

  if (!_dbus_string_append (&to_hash, ":"))

    goto out_1;

  if (!_dbus_string_copy (client_challenge, 0,

                          &to_hash, _dbus_string_get_length (&to_hash)))

    goto out_1;

  if (!_dbus_string_append (&to_hash, ":"))

    goto out_1;

  if (!_dbus_string_copy (&cookie, 0,

                          &to_hash, _dbus_string_get_length (&to_hash)))

    goto out_1;

  if (!_dbus_sha_compute (&to_hash, hash))

    goto out_1;

  retval = TRUE;

 out_1:

  _dbus_string_zero (&to_hash);

  _dbus_string_free (&to_hash);

 out_0:

  _dbus_string_zero (&cookie);

  _dbus_string_free (&cookie);

  return retval;

}

/** http://www.ietf.org/rfc/rfc2831.txt suggests at least 64 bits of

 * entropy, we use 128. This is the number of bytes in the random

 * challenge.

 */

#define N_CHALLENGE_BYTES (128/8)

static dbus_bool_t

sha1_handle_first_client_response (DBusAuth         *auth,

                                   const DBusString *data)

{

  /* We haven't sent a challenge yet, we're expecting a desired

   * username from the client.

   */

  DBusString tmp;

  DBusString tmp2;

  dbus_bool_t retval;

  DBusError error;

  retval = FALSE;

  _dbus_string_set_length (&auth->challenge, 0);

  if (_dbus_string_get_length (data) > 0)

    {

      if (_dbus_string_get_length (&auth->identity) > 0)

        {

          /* Tried to send two auth identities, wtf */

          _dbus_verbose ("%s: client tried to send auth identity, but we already have one\n",

                         DBUS_AUTH_NAME (auth));

          return send_rejected (auth);

        }

      else

        {

          /* this is our auth identity */

          if (!_dbus_string_copy (data, 0, &auth->identity, 0))

            return FALSE;

        }

    }

  if (!_dbus_credentials_from_username (data, &auth->desired_identity))

    {

      _dbus_verbose ("%s: Did not get a valid username from client\n",

                     DBUS_AUTH_NAME (auth));

      return send_rejected (auth);

    }

  if (!_dbus_string_init (&tmp))

    return FALSE;