mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-15 05:46:15 +01:00
5cddde1fb2
Prevent the situation where errno is set by function A, then function B is called (which is typically _(), but could be anything else) and it overwrites errno, then errno is checked by the caller. errno is a horrific API, and we need to be careful to save its value as soon as a function call (which might set it) returns. i.e. Follow the pattern: int errsv, ret; ret = some_call_which_might_set_errno (); errsv = errno; if (ret < 0) puts (strerror (errsv)); This patch implements that pattern throughout GLib. There might be a few places in the test code which still use errno directly. They should be ported as necessary. It doesn’t modify all the call sites like this: if (some_call_which_might_set_errno () && errno == ESOMETHING) since the refactoring involved is probably more harmful than beneficial there. It does, however, refactor other call sites regardless of whether they were originally buggy. https://bugzilla.gnome.org/show_bug.cgi?id=785577
1228 lines
37 KiB
C
1228 lines
37 KiB
C
/* GDBus - GLib D-Bus Library
|
||
*
|
||
* Copyright (C) 2008-2010 Red Hat, Inc.
|
||
*
|
||
* This 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.
|
||
*
|
||
* This 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 this library; if not, see <http://www.gnu.org/licenses/>.
|
||
*
|
||
* Author: David Zeuthen <davidz@redhat.com>
|
||
*/
|
||
|
||
#include "config.h"
|
||
|
||
#include <string.h>
|
||
#include <fcntl.h>
|
||
#include <errno.h>
|
||
#include <sys/types.h>
|
||
|
||
#include <glib/gstdio.h>
|
||
|
||
#ifdef G_OS_UNIX
|
||
#include <unistd.h>
|
||
#endif
|
||
#ifdef G_OS_WIN32
|
||
#include <io.h>
|
||
#endif
|
||
|
||
#include "gdbusauthmechanismsha1.h"
|
||
#include "gcredentials.h"
|
||
#include "gdbuserror.h"
|
||
#include "gioenumtypes.h"
|
||
#include "gioerror.h"
|
||
#include "gdbusprivate.h"
|
||
|
||
#include "glibintl.h"
|
||
|
||
struct _GDBusAuthMechanismSha1Private
|
||
{
|
||
gboolean is_client;
|
||
gboolean is_server;
|
||
GDBusAuthMechanismState state;
|
||
|
||
/* used on the client side */
|
||
gchar *to_send;
|
||
|
||
/* used on the server side */
|
||
gchar *cookie;
|
||
gchar *server_challenge;
|
||
};
|
||
|
||
static gint mechanism_get_priority (void);
|
||
static const gchar *mechanism_get_name (void);
|
||
|
||
static gboolean mechanism_is_supported (GDBusAuthMechanism *mechanism);
|
||
static gchar *mechanism_encode_data (GDBusAuthMechanism *mechanism,
|
||
const gchar *data,
|
||
gsize data_len,
|
||
gsize *out_data_len);
|
||
static gchar *mechanism_decode_data (GDBusAuthMechanism *mechanism,
|
||
const gchar *data,
|
||
gsize data_len,
|
||
gsize *out_data_len);
|
||
static GDBusAuthMechanismState mechanism_server_get_state (GDBusAuthMechanism *mechanism);
|
||
static void mechanism_server_initiate (GDBusAuthMechanism *mechanism,
|
||
const gchar *initial_response,
|
||
gsize initial_response_len);
|
||
static void mechanism_server_data_receive (GDBusAuthMechanism *mechanism,
|
||
const gchar *data,
|
||
gsize data_len);
|
||
static gchar *mechanism_server_data_send (GDBusAuthMechanism *mechanism,
|
||
gsize *out_data_len);
|
||
static gchar *mechanism_server_get_reject_reason (GDBusAuthMechanism *mechanism);
|
||
static void mechanism_server_shutdown (GDBusAuthMechanism *mechanism);
|
||
static GDBusAuthMechanismState mechanism_client_get_state (GDBusAuthMechanism *mechanism);
|
||
static gchar *mechanism_client_initiate (GDBusAuthMechanism *mechanism,
|
||
gsize *out_initial_response_len);
|
||
static void mechanism_client_data_receive (GDBusAuthMechanism *mechanism,
|
||
const gchar *data,
|
||
gsize data_len);
|
||
static gchar *mechanism_client_data_send (GDBusAuthMechanism *mechanism,
|
||
gsize *out_data_len);
|
||
static void mechanism_client_shutdown (GDBusAuthMechanism *mechanism);
|
||
|
||
/* ---------------------------------------------------------------------------------------------------- */
|
||
|
||
G_DEFINE_TYPE_WITH_PRIVATE (GDBusAuthMechanismSha1, _g_dbus_auth_mechanism_sha1, G_TYPE_DBUS_AUTH_MECHANISM)
|
||
|
||
/* ---------------------------------------------------------------------------------------------------- */
|
||
|
||
static void
|
||
_g_dbus_auth_mechanism_sha1_finalize (GObject *object)
|
||
{
|
||
GDBusAuthMechanismSha1 *mechanism = G_DBUS_AUTH_MECHANISM_SHA1 (object);
|
||
|
||
g_free (mechanism->priv->to_send);
|
||
|
||
g_free (mechanism->priv->cookie);
|
||
g_free (mechanism->priv->server_challenge);
|
||
|
||
if (G_OBJECT_CLASS (_g_dbus_auth_mechanism_sha1_parent_class)->finalize != NULL)
|
||
G_OBJECT_CLASS (_g_dbus_auth_mechanism_sha1_parent_class)->finalize (object);
|
||
}
|
||
|
||
static void
|
||
_g_dbus_auth_mechanism_sha1_class_init (GDBusAuthMechanismSha1Class *klass)
|
||
{
|
||
GObjectClass *gobject_class;
|
||
GDBusAuthMechanismClass *mechanism_class;
|
||
|
||
gobject_class = G_OBJECT_CLASS (klass);
|
||
gobject_class->finalize = _g_dbus_auth_mechanism_sha1_finalize;
|
||
|
||
mechanism_class = G_DBUS_AUTH_MECHANISM_CLASS (klass);
|
||
mechanism_class->get_priority = mechanism_get_priority;
|
||
mechanism_class->get_name = mechanism_get_name;
|
||
mechanism_class->is_supported = mechanism_is_supported;
|
||
mechanism_class->encode_data = mechanism_encode_data;
|
||
mechanism_class->decode_data = mechanism_decode_data;
|
||
mechanism_class->server_get_state = mechanism_server_get_state;
|
||
mechanism_class->server_initiate = mechanism_server_initiate;
|
||
mechanism_class->server_data_receive = mechanism_server_data_receive;
|
||
mechanism_class->server_data_send = mechanism_server_data_send;
|
||
mechanism_class->server_get_reject_reason = mechanism_server_get_reject_reason;
|
||
mechanism_class->server_shutdown = mechanism_server_shutdown;
|
||
mechanism_class->client_get_state = mechanism_client_get_state;
|
||
mechanism_class->client_initiate = mechanism_client_initiate;
|
||
mechanism_class->client_data_receive = mechanism_client_data_receive;
|
||
mechanism_class->client_data_send = mechanism_client_data_send;
|
||
mechanism_class->client_shutdown = mechanism_client_shutdown;
|
||
}
|
||
|
||
static void
|
||
_g_dbus_auth_mechanism_sha1_init (GDBusAuthMechanismSha1 *mechanism)
|
||
{
|
||
mechanism->priv = _g_dbus_auth_mechanism_sha1_get_instance_private (mechanism);
|
||
}
|
||
|
||
/* ---------------------------------------------------------------------------------------------------- */
|
||
|
||
static gint
|
||
mechanism_get_priority (void)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
static const gchar *
|
||
mechanism_get_name (void)
|
||
{
|
||
return "DBUS_COOKIE_SHA1";
|
||
}
|
||
|
||
static gboolean
|
||
mechanism_is_supported (GDBusAuthMechanism *mechanism)
|
||
{
|
||
g_return_val_if_fail (G_IS_DBUS_AUTH_MECHANISM_SHA1 (mechanism), FALSE);
|
||
return TRUE;
|
||
}
|
||
|
||
static gchar *
|
||
mechanism_encode_data (GDBusAuthMechanism *mechanism,
|
||
const gchar *data,
|
||
gsize data_len,
|
||
gsize *out_data_len)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
|
||
static gchar *
|
||
mechanism_decode_data (GDBusAuthMechanism *mechanism,
|
||
const gchar *data,
|
||
gsize data_len,
|
||
gsize *out_data_len)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
/* ---------------------------------------------------------------------------------------------------- */
|
||
|
||
static gint
|
||
random_ascii (void)
|
||
{
|
||
gint ret;
|
||
ret = g_random_int_range (0, 60);
|
||
if (ret < 25)
|
||
ret += 'A';
|
||
else if (ret < 50)
|
||
ret += 'a' - 25;
|
||
else
|
||
ret += '0' - 50;
|
||
return ret;
|
||
}
|
||
|
||
static gchar *
|
||
random_ascii_string (guint len)
|
||
{
|
||
GString *challenge;
|
||
guint n;
|
||
|
||
challenge = g_string_new (NULL);
|
||
for (n = 0; n < len; n++)
|
||
g_string_append_c (challenge, random_ascii ());
|
||
return g_string_free (challenge, FALSE);
|
||
}
|
||
|
||
static gchar *
|
||
random_blob (guint len)
|
||
{
|
||
GString *challenge;
|
||
guint n;
|
||
|
||
challenge = g_string_new (NULL);
|
||
for (n = 0; n < len; n++)
|
||
g_string_append_c (challenge, g_random_int_range (0, 256));
|
||
return g_string_free (challenge, FALSE);
|
||
}
|
||
|
||
/* ---------------------------------------------------------------------------------------------------- */
|
||
|
||
/* ensure keyring dir exists and permissions are correct */
|
||
static gchar *
|
||
ensure_keyring_directory (GError **error)
|
||
{
|
||
gchar *path;
|
||
const gchar *e;
|
||
|
||
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
||
|
||
e = g_getenv ("G_DBUS_COOKIE_SHA1_KEYRING_DIR");
|
||
if (e != NULL)
|
||
{
|
||
path = g_strdup (e);
|
||
}
|
||
else
|
||
{
|
||
path = g_build_filename (g_get_home_dir (),
|
||
".dbus-keyrings",
|
||
NULL);
|
||
}
|
||
|
||
if (g_file_test (path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))
|
||
{
|
||
if (g_getenv ("G_DBUS_COOKIE_SHA1_KEYRING_DIR_IGNORE_PERMISSION") == NULL)
|
||
{
|
||
#ifdef G_OS_UNIX
|
||
struct stat statbuf;
|
||
if (stat (path, &statbuf) != 0)
|
||
{
|
||
int errsv = errno;
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
g_io_error_from_errno (errsv),
|
||
_("Error when getting information for directory “%s”: %s"),
|
||
path,
|
||
g_strerror (errsv));
|
||
g_free (path);
|
||
path = NULL;
|
||
goto out;
|
||
}
|
||
if ((statbuf.st_mode & 0777) != 0700)
|
||
{
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
G_IO_ERROR_FAILED,
|
||
_("Permissions on directory “%s” are malformed. Expected mode 0700, got 0%o"),
|
||
path,
|
||
statbuf.st_mode & 0777);
|
||
g_free (path);
|
||
path = NULL;
|
||
goto out;
|
||
}
|
||
#else
|
||
#ifdef __GNUC__
|
||
#warning Please implement permission checking on this non-UNIX platform
|
||
#endif
|
||
#endif
|
||
}
|
||
goto out;
|
||
}
|
||
|
||
if (g_mkdir (path, 0700) != 0)
|
||
{
|
||
int errsv = errno;
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
g_io_error_from_errno (errsv),
|
||
_("Error creating directory “%s”: %s"),
|
||
path,
|
||
g_strerror (errsv));
|
||
g_free (path);
|
||
path = NULL;
|
||
goto out;
|
||
}
|
||
|
||
out:
|
||
return path;
|
||
}
|
||
|
||
/* ---------------------------------------------------------------------------------------------------- */
|
||
|
||
static void
|
||
append_nibble (GString *s, gint val)
|
||
{
|
||
g_string_append_c (s, val >= 10 ? ('a' + val - 10) : ('0' + val));
|
||
}
|
||
|
||
static gchar *
|
||
hexencode (const gchar *str,
|
||
gssize len)
|
||
{
|
||
guint n;
|
||
GString *s;
|
||
|
||
if (len == -1)
|
||
len = strlen (str);
|
||
|
||
s = g_string_new (NULL);
|
||
for (n = 0; n < len; n++)
|
||
{
|
||
gint val;
|
||
gint upper_nibble;
|
||
gint lower_nibble;
|
||
|
||
val = ((const guchar *) str)[n];
|
||
upper_nibble = val >> 4;
|
||
lower_nibble = val & 0x0f;
|
||
|
||
append_nibble (s, upper_nibble);
|
||
append_nibble (s, lower_nibble);
|
||
}
|
||
|
||
return g_string_free (s, FALSE);
|
||
}
|
||
|
||
/* ---------------------------------------------------------------------------------------------------- */
|
||
|
||
/* looks up an entry in the keyring */
|
||
static gchar *
|
||
keyring_lookup_entry (const gchar *cookie_context,
|
||
gint cookie_id,
|
||
GError **error)
|
||
{
|
||
gchar *ret;
|
||
gchar *keyring_dir;
|
||
gchar *contents;
|
||
gchar *path;
|
||
guint n;
|
||
gchar **lines;
|
||
|
||
g_return_val_if_fail (cookie_context != NULL, NULL);
|
||
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
||
|
||
ret = NULL;
|
||
path = NULL;
|
||
contents = NULL;
|
||
lines = NULL;
|
||
|
||
keyring_dir = ensure_keyring_directory (error);
|
||
if (keyring_dir == NULL)
|
||
goto out;
|
||
|
||
path = g_build_filename (keyring_dir, cookie_context, NULL);
|
||
|
||
if (!g_file_get_contents (path,
|
||
&contents,
|
||
NULL,
|
||
error))
|
||
{
|
||
g_prefix_error (error,
|
||
_("Error opening keyring “%s” for reading: "),
|
||
path);
|
||
goto out;
|
||
}
|
||
g_assert (contents != NULL);
|
||
|
||
lines = g_strsplit (contents, "\n", 0);
|
||
for (n = 0; lines[n] != NULL; n++)
|
||
{
|
||
const gchar *line = lines[n];
|
||
gchar **tokens;
|
||
gchar *endp;
|
||
gint line_id;
|
||
guint64 line_when;
|
||
|
||
if (line[0] == '\0')
|
||
continue;
|
||
|
||
tokens = g_strsplit (line, " ", 0);
|
||
if (g_strv_length (tokens) != 3)
|
||
{
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
G_IO_ERROR_FAILED,
|
||
_("Line %d of the keyring at “%s” with content “%s” is malformed"),
|
||
n + 1,
|
||
path,
|
||
line);
|
||
g_strfreev (tokens);
|
||
goto out;
|
||
}
|
||
|
||
line_id = g_ascii_strtoll (tokens[0], &endp, 10);
|
||
if (*endp != '\0')
|
||
{
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
G_IO_ERROR_FAILED,
|
||
_("First token of line %d of the keyring at “%s” with content “%s” is malformed"),
|
||
n + 1,
|
||
path,
|
||
line);
|
||
g_strfreev (tokens);
|
||
goto out;
|
||
}
|
||
|
||
line_when = g_ascii_strtoll (tokens[1], &endp, 10);
|
||
line_when = line_when; /* To avoid -Wunused-but-set-variable */
|
||
if (*endp != '\0')
|
||
{
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
G_IO_ERROR_FAILED,
|
||
_("Second token of line %d of the keyring at “%s” with content “%s” is malformed"),
|
||
n + 1,
|
||
path,
|
||
line);
|
||
g_strfreev (tokens);
|
||
goto out;
|
||
}
|
||
|
||
if (line_id == cookie_id)
|
||
{
|
||
/* YAY, success */
|
||
ret = tokens[2]; /* steal pointer */
|
||
tokens[2] = NULL;
|
||
g_strfreev (tokens);
|
||
goto out;
|
||
}
|
||
|
||
g_strfreev (tokens);
|
||
}
|
||
|
||
/* BOOH, didn't find the cookie */
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
G_IO_ERROR_FAILED,
|
||
_("Didn’t find cookie with id %d in the keyring at “%s”"),
|
||
cookie_id,
|
||
path);
|
||
|
||
out:
|
||
g_free (keyring_dir);
|
||
g_free (path);
|
||
g_free (contents);
|
||
g_strfreev (lines);
|
||
return ret;
|
||
}
|
||
|
||
/* function for logging important events that the system administrator should take notice of */
|
||
G_GNUC_PRINTF(1, 2)
|
||
static void
|
||
_log (const gchar *message,
|
||
...)
|
||
{
|
||
gchar *s;
|
||
va_list var_args;
|
||
|
||
va_start (var_args, message);
|
||
s = g_strdup_vprintf (message, var_args);
|
||
va_end (var_args);
|
||
|
||
/* TODO: might want to send this to syslog instead */
|
||
g_printerr ("GDBus-DBUS_COOKIE_SHA1: %s\n", s);
|
||
g_free (s);
|
||
}
|
||
|
||
static gint
|
||
keyring_acquire_lock (const gchar *path,
|
||
GError **error)
|
||
{
|
||
gchar *lock;
|
||
gint ret;
|
||
guint num_tries;
|
||
guint num_create_tries;
|
||
int errsv;
|
||
|
||
g_return_val_if_fail (path != NULL, FALSE);
|
||
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
||
|
||
ret = -1;
|
||
lock = g_strdup_printf ("%s.lock", path);
|
||
|
||
/* This is what the D-Bus spec says
|
||
*
|
||
* Create a lockfile name by appending ".lock" to the name of the
|
||
* cookie file. The server should attempt to create this file using
|
||
* O_CREAT | O_EXCL. If file creation fails, the lock
|
||
* fails. Servers should retry for a reasonable period of time,
|
||
* then they may choose to delete an existing lock to keep users
|
||
* from having to manually delete a stale lock. [1]
|
||
*
|
||
* [1] : Lockfiles are used instead of real file locking fcntl() because
|
||
* real locking implementations are still flaky on network filesystems
|
||
*/
|
||
|
||
num_create_tries = 0;
|
||
#ifdef EEXISTS
|
||
again:
|
||
#endif
|
||
num_tries = 0;
|
||
while (g_file_test (lock, G_FILE_TEST_EXISTS))
|
||
{
|
||
/* sleep 10ms, then try again */
|
||
g_usleep (1000*10);
|
||
num_tries++;
|
||
if (num_tries == 50)
|
||
{
|
||
/* ok, we slept 50*10ms = 0.5 seconds. Conclude that the lock file must be
|
||
* stale (nuke the it from orbit)
|
||
*/
|
||
if (g_unlink (lock) != 0)
|
||
{
|
||
errsv = errno;
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
g_io_error_from_errno (errsv),
|
||
_("Error deleting stale lock file “%s”: %s"),
|
||
lock,
|
||
g_strerror (errsv));
|
||
goto out;
|
||
}
|
||
_log ("Deleted stale lock file '%s'", lock);
|
||
break;
|
||
}
|
||
}
|
||
|
||
ret = g_open (lock, O_CREAT |
|
||
#ifdef O_EXCL
|
||
O_EXCL,
|
||
#else
|
||
0,
|
||
#endif
|
||
0700);
|
||
errsv = errno;
|
||
if (ret == -1)
|
||
{
|
||
#ifdef EEXISTS
|
||
/* EEXIST: pathname already exists and O_CREAT and O_EXCL were used. */
|
||
if (errsv == EEXISTS)
|
||
{
|
||
num_create_tries++;
|
||
if (num_create_tries < 5)
|
||
goto again;
|
||
}
|
||
#endif
|
||
num_create_tries = num_create_tries; /* To avoid -Wunused-but-set-variable */
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
g_io_error_from_errno (errsv),
|
||
_("Error creating lock file “%s”: %s"),
|
||
lock,
|
||
g_strerror (errsv));
|
||
goto out;
|
||
}
|
||
|
||
out:
|
||
g_free (lock);
|
||
return ret;
|
||
}
|
||
|
||
static gboolean
|
||
keyring_release_lock (const gchar *path,
|
||
gint lock_fd,
|
||
GError **error)
|
||
{
|
||
gchar *lock;
|
||
gboolean ret;
|
||
|
||
g_return_val_if_fail (path != NULL, FALSE);
|
||
g_return_val_if_fail (lock_fd != -1, FALSE);
|
||
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
||
|
||
ret = FALSE;
|
||
lock = g_strdup_printf ("%s.lock", path);
|
||
if (close (lock_fd) != 0)
|
||
{
|
||
int errsv = errno;
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
g_io_error_from_errno (errsv),
|
||
_("Error closing (unlinked) lock file “%s”: %s"),
|
||
lock,
|
||
g_strerror (errsv));
|
||
goto out;
|
||
}
|
||
if (g_unlink (lock) != 0)
|
||
{
|
||
int errsv = errno;
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
g_io_error_from_errno (errsv),
|
||
_("Error unlinking lock file “%s”: %s"),
|
||
lock,
|
||
g_strerror (errsv));
|
||
goto out;
|
||
}
|
||
|
||
ret = TRUE;
|
||
|
||
out:
|
||
g_free (lock);
|
||
return ret;
|
||
}
|
||
|
||
|
||
/* adds an entry to the keyring, taking care of locking and deleting stale/future entries */
|
||
static gboolean
|
||
keyring_generate_entry (const gchar *cookie_context,
|
||
gint *out_id,
|
||
gchar **out_cookie,
|
||
GError **error)
|
||
{
|
||
gboolean ret;
|
||
gchar *keyring_dir;
|
||
gchar *path;
|
||
gchar *contents;
|
||
GError *local_error;
|
||
gchar **lines;
|
||
gint max_line_id;
|
||
GString *new_contents;
|
||
guint64 now;
|
||
gboolean have_id;
|
||
gint use_id;
|
||
gchar *use_cookie;
|
||
gboolean changed_file;
|
||
gint lock_fd;
|
||
|
||
g_return_val_if_fail (cookie_context != NULL, FALSE);
|
||
g_return_val_if_fail (out_id != NULL, FALSE);
|
||
g_return_val_if_fail (out_cookie != NULL, FALSE);
|
||
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
||
|
||
ret = FALSE;
|
||
path = NULL;
|
||
contents = NULL;
|
||
lines = NULL;
|
||
new_contents = NULL;
|
||
have_id = FALSE;
|
||
use_id = 0;
|
||
use_cookie = NULL;
|
||
lock_fd = -1;
|
||
|
||
keyring_dir = ensure_keyring_directory (error);
|
||
if (keyring_dir == NULL)
|
||
goto out;
|
||
|
||
path = g_build_filename (keyring_dir, cookie_context, NULL);
|
||
|
||
lock_fd = keyring_acquire_lock (path, error);
|
||
if (lock_fd == -1)
|
||
goto out;
|
||
|
||
local_error = NULL;
|
||
contents = NULL;
|
||
if (!g_file_get_contents (path,
|
||
&contents,
|
||
NULL,
|
||
&local_error))
|
||
{
|
||
if (local_error->domain == G_FILE_ERROR && local_error->code == G_FILE_ERROR_NOENT)
|
||
{
|
||
/* file doesn't have to exist */
|
||
g_error_free (local_error);
|
||
}
|
||
else
|
||
{
|
||
g_propagate_prefixed_error (error,
|
||
local_error,
|
||
_("Error opening keyring “%s” for writing: "),
|
||
path);
|
||
goto out;
|
||
}
|
||
}
|
||
|
||
new_contents = g_string_new (NULL);
|
||
now = time (NULL);
|
||
changed_file = FALSE;
|
||
|
||
max_line_id = 0;
|
||
if (contents != NULL)
|
||
{
|
||
guint n;
|
||
lines = g_strsplit (contents, "\n", 0);
|
||
for (n = 0; lines[n] != NULL; n++)
|
||
{
|
||
const gchar *line = lines[n];
|
||
gchar **tokens;
|
||
gchar *endp;
|
||
gint line_id;
|
||
guint64 line_when;
|
||
gboolean keep_entry;
|
||
|
||
if (line[0] == '\0')
|
||
continue;
|
||
|
||
tokens = g_strsplit (line, " ", 0);
|
||
if (g_strv_length (tokens) != 3)
|
||
{
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
G_IO_ERROR_FAILED,
|
||
_("Line %d of the keyring at “%s” with content “%s” is malformed"),
|
||
n + 1,
|
||
path,
|
||
line);
|
||
g_strfreev (tokens);
|
||
goto out;
|
||
}
|
||
|
||
line_id = g_ascii_strtoll (tokens[0], &endp, 10);
|
||
if (*endp != '\0')
|
||
{
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
G_IO_ERROR_FAILED,
|
||
_("First token of line %d of the keyring at “%s” with content “%s” is malformed"),
|
||
n + 1,
|
||
path,
|
||
line);
|
||
g_strfreev (tokens);
|
||
goto out;
|
||
}
|
||
|
||
line_when = g_ascii_strtoll (tokens[1], &endp, 10);
|
||
if (*endp != '\0')
|
||
{
|
||
g_set_error (error,
|
||
G_IO_ERROR,
|
||
G_IO_ERROR_FAILED,
|
||
_("Second token of line %d of the keyring at “%s” with content “%s” is malformed"),
|
||
n + 1,
|
||
path,
|
||
line);
|
||
g_strfreev (tokens);
|
||
goto out;
|
||
}
|
||
line_when = line_when; /* To avoid -Wunused-but-set-variable */
|
||
|
||
|
||
/* D-Bus spec says:
|
||
*
|
||
* Once the lockfile has been created, the server loads the
|
||
* cookie file. It should then delete any cookies that are
|
||
* old (the timeout can be fairly short), or more than a
|
||
* reasonable time in the future (so that cookies never
|
||
* accidentally become permanent, if the clock was set far
|
||
* into the future at some point). If no recent keys remain,
|
||
* the server may generate a new key.
|
||
*
|
||
*/
|
||
keep_entry = TRUE;
|
||
if (line_when > now)
|
||
{
|
||
/* Oddball case: entry is more recent than our current wall-clock time..
|
||
* This is OK, it means that another server on another machine but with
|
||
* same $HOME wrote the entry.
|
||
*
|
||
* So discard the entry if it's more than 1 day in the future ("reasonable
|
||
* time in the future").
|
||
*/
|
||
if (line_when - now > 24*60*60)
|
||
{
|
||
keep_entry = FALSE;
|
||
_log ("Deleted SHA1 cookie from %" G_GUINT64_FORMAT " seconds in the future", line_when - now);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/* Discard entry if it's older than 15 minutes ("can be fairly short") */
|
||
if (now - line_when > 15*60)
|
||
{
|
||
keep_entry = FALSE;
|
||
}
|
||
}
|
||
|
||
if (!keep_entry)
|
||
{
|
||
changed_file = FALSE;
|
||
}
|
||
else
|
||
{
|
||
g_string_append_printf (new_contents,
|
||
"%d %" G_GUINT64_FORMAT " %s\n",
|
||
line_id,
|
||
line_when,
|
||
tokens[2]);
|
||
max_line_id = MAX (line_id, max_line_id);
|
||
/* Only reuse entry if not older than 10 minutes.
|
||
*
|
||
* (We need a bit of grace time compared to 15 minutes above.. otherwise
|
||
* there's a race where we reuse the 14min59.9 secs old entry and a
|
||
* split-second later another server purges the now 15 minute old entry.)
|
||
*/
|
||
if (now - line_when < 10 * 60)
|
||
{
|
||
if (!have_id)
|
||
{
|
||
use_id = line_id;
|
||
use_cookie = tokens[2]; /* steal memory */
|
||
tokens[2] = NULL;
|
||
have_id = TRUE;
|
||
}
|
||
}
|
||
}
|
||
g_strfreev (tokens);
|
||
}
|
||
} /* for each line */
|
||
|
||
ret = TRUE;
|
||
|
||
if (have_id)
|
||
{
|
||
*out_id = use_id;
|
||
*out_cookie = use_cookie;
|
||
use_cookie = NULL;
|
||
}
|
||
else
|
||
{
|
||
gchar *raw_cookie;
|
||
*out_id = max_line_id + 1;
|
||
raw_cookie = random_blob (32);
|
||
*out_cookie = hexencode (raw_cookie, 32);
|
||
g_free (raw_cookie);
|
||
|
||
g_string_append_printf (new_contents,
|
||
"%d %" G_GUINT64_FORMAT " %s\n",
|
||
*out_id,
|
||
(guint64) time (NULL),
|
||
*out_cookie);
|
||
changed_file = TRUE;
|
||
}
|
||
|
||
/* and now actually write the cookie file if there are changes (this is atomic) */
|
||
if (changed_file)
|
||
{
|
||
if (!g_file_set_contents (path,
|
||
new_contents->str,
|
||
-1,
|
||
error))
|
||
{
|
||
*out_id = 0;
|
||
*out_cookie = 0;
|
||
g_free (*out_cookie);
|
||
ret = FALSE;
|
||
goto out;
|
||
}
|
||
}
|
||
|
||
out:
|
||
|
||
if (lock_fd != -1)
|
||
{
|
||
GError *local_error;
|
||
local_error = NULL;
|
||
if (!keyring_release_lock (path, lock_fd, &local_error))
|
||
{
|
||
if (error != NULL)
|
||
{
|
||
if (*error == NULL)
|
||
{
|
||
*error = local_error;
|
||
}
|
||
else
|
||
{
|
||
g_prefix_error (error,
|
||
_("(Additionally, releasing the lock for “%s” also failed: %s) "),
|
||
path,
|
||
local_error->message);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
g_error_free (local_error);
|
||
}
|
||
}
|
||
}
|
||
|
||
g_free (keyring_dir);
|
||
g_free (path);
|
||
g_strfreev (lines);
|
||
g_free (contents);
|
||
if (new_contents != NULL)
|
||
g_string_free (new_contents, TRUE);
|
||
g_free (use_cookie);
|
||
return ret;
|
||
}
|
||
|
||
/* ---------------------------------------------------------------------------------------------------- */
|
||
|
||
static gchar *
|
||
generate_sha1 (const gchar *server_challenge,
|
||
const gchar *client_challenge,
|
||
const gchar *cookie)
|
||
{
|
||
GString *str;
|
||
gchar *sha1;
|
||
|
||
str = g_string_new (server_challenge);
|
||
g_string_append_c (str, ':');
|
||
g_string_append (str, client_challenge);
|
||
g_string_append_c (str, ':');
|
||
g_string_append (str, cookie);
|
||
sha1 = g_compute_checksum_for_string (G_CHECKSUM_SHA1, str->str, -1);
|
||
g_string_free (str, TRUE);
|
||
|
||
return sha1;
|
||
}
|
||
|
||
/* ---------------------------------------------------------------------------------------------------- */
|
||
|
||
static GDBusAuthMechanismState
|
||
mechanism_server_get_state (GDBusAuthMechanism *mechanism)
|
||
{
|
||
GDBusAuthMechanismSha1 *m = G_DBUS_AUTH_MECHANISM_SHA1 (mechanism);
|
||
|
||
g_return_val_if_fail (G_IS_DBUS_AUTH_MECHANISM_SHA1 (mechanism), G_DBUS_AUTH_MECHANISM_STATE_INVALID);
|
||
g_return_val_if_fail (m->priv->is_server && !m->priv->is_client, G_DBUS_AUTH_MECHANISM_STATE_INVALID);
|
||
|
||
return m->priv->state;
|
||
}
|
||
|
||
static void
|
||
mechanism_server_initiate (GDBusAuthMechanism *mechanism,
|
||
const gchar *initial_response,
|
||
gsize initial_response_len)
|
||
{
|
||
GDBusAuthMechanismSha1 *m = G_DBUS_AUTH_MECHANISM_SHA1 (mechanism);
|
||
|
||
g_return_if_fail (G_IS_DBUS_AUTH_MECHANISM_SHA1 (mechanism));
|
||
g_return_if_fail (!m->priv->is_server && !m->priv->is_client);
|
||
|
||
m->priv->is_server = TRUE;
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_REJECTED;
|
||
|
||
if (initial_response != NULL && strlen (initial_response) > 0)
|
||
{
|
||
#ifdef G_OS_UNIX
|
||
gint64 uid;
|
||
gchar *endp;
|
||
|
||
uid = g_ascii_strtoll (initial_response, &endp, 10);
|
||
if (*endp == '\0')
|
||
{
|
||
if (uid == getuid ())
|
||
{
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_HAVE_DATA_TO_SEND;
|
||
}
|
||
}
|
||
#elif defined(G_OS_WIN32)
|
||
gchar *sid;
|
||
sid = _g_dbus_win32_get_user_sid ();
|
||
if (g_strcmp0 (initial_response, sid) == 0)
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_HAVE_DATA_TO_SEND;
|
||
g_free (sid);
|
||
#else
|
||
#error Please implement for your OS
|
||
#endif
|
||
}
|
||
}
|
||
|
||
static void
|
||
mechanism_server_data_receive (GDBusAuthMechanism *mechanism,
|
||
const gchar *data,
|
||
gsize data_len)
|
||
{
|
||
GDBusAuthMechanismSha1 *m = G_DBUS_AUTH_MECHANISM_SHA1 (mechanism);
|
||
gchar **tokens;
|
||
const gchar *client_challenge;
|
||
const gchar *alleged_sha1;
|
||
gchar *sha1;
|
||
|
||
g_return_if_fail (G_IS_DBUS_AUTH_MECHANISM_SHA1 (mechanism));
|
||
g_return_if_fail (m->priv->is_server && !m->priv->is_client);
|
||
g_return_if_fail (m->priv->state == G_DBUS_AUTH_MECHANISM_STATE_WAITING_FOR_DATA);
|
||
|
||
tokens = NULL;
|
||
sha1 = NULL;
|
||
|
||
tokens = g_strsplit (data, " ", 0);
|
||
if (g_strv_length (tokens) != 2)
|
||
{
|
||
g_warning ("Malformed data '%s'", data);
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_REJECTED;
|
||
goto out;
|
||
}
|
||
|
||
client_challenge = tokens[0];
|
||
alleged_sha1 = tokens[1];
|
||
|
||
sha1 = generate_sha1 (m->priv->server_challenge, client_challenge, m->priv->cookie);
|
||
|
||
if (g_strcmp0 (sha1, alleged_sha1) == 0)
|
||
{
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_ACCEPTED;
|
||
}
|
||
else
|
||
{
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_REJECTED;
|
||
}
|
||
|
||
out:
|
||
g_strfreev (tokens);
|
||
g_free (sha1);
|
||
}
|
||
|
||
static gchar *
|
||
mechanism_server_data_send (GDBusAuthMechanism *mechanism,
|
||
gsize *out_data_len)
|
||
{
|
||
GDBusAuthMechanismSha1 *m = G_DBUS_AUTH_MECHANISM_SHA1 (mechanism);
|
||
gchar *s;
|
||
gint cookie_id;
|
||
const gchar *cookie_context;
|
||
GError *error;
|
||
|
||
g_return_val_if_fail (G_IS_DBUS_AUTH_MECHANISM_SHA1 (mechanism), NULL);
|
||
g_return_val_if_fail (m->priv->is_server && !m->priv->is_client, NULL);
|
||
g_return_val_if_fail (m->priv->state == G_DBUS_AUTH_MECHANISM_STATE_HAVE_DATA_TO_SEND, NULL);
|
||
|
||
s = NULL;
|
||
|
||
/* TODO: use GDBusAuthObserver here to get the cookie context to use? */
|
||
cookie_context = "org_gtk_gdbus_general";
|
||
|
||
cookie_id = -1;
|
||
error = NULL;
|
||
if (!keyring_generate_entry (cookie_context,
|
||
&cookie_id,
|
||
&m->priv->cookie,
|
||
&error))
|
||
{
|
||
g_warning ("Error adding entry to keyring: %s", error->message);
|
||
g_error_free (error);
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_REJECTED;
|
||
goto out;
|
||
}
|
||
|
||
m->priv->server_challenge = random_ascii_string (16);
|
||
s = g_strdup_printf ("%s %d %s",
|
||
cookie_context,
|
||
cookie_id,
|
||
m->priv->server_challenge);
|
||
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_WAITING_FOR_DATA;
|
||
|
||
out:
|
||
return s;
|
||
}
|
||
|
||
static gchar *
|
||
mechanism_server_get_reject_reason (GDBusAuthMechanism *mechanism)
|
||
{
|
||
GDBusAuthMechanismSha1 *m = G_DBUS_AUTH_MECHANISM_SHA1 (mechanism);
|
||
|
||
g_return_val_if_fail (G_IS_DBUS_AUTH_MECHANISM_SHA1 (mechanism), NULL);
|
||
g_return_val_if_fail (m->priv->is_server && !m->priv->is_client, NULL);
|
||
g_return_val_if_fail (m->priv->state == G_DBUS_AUTH_MECHANISM_STATE_REJECTED, NULL);
|
||
|
||
/* can never end up here because we are never in the REJECTED state */
|
||
g_assert_not_reached ();
|
||
|
||
return NULL;
|
||
}
|
||
|
||
static void
|
||
mechanism_server_shutdown (GDBusAuthMechanism *mechanism)
|
||
{
|
||
GDBusAuthMechanismSha1 *m = G_DBUS_AUTH_MECHANISM_SHA1 (mechanism);
|
||
|
||
g_return_if_fail (G_IS_DBUS_AUTH_MECHANISM_SHA1 (mechanism));
|
||
g_return_if_fail (m->priv->is_server && !m->priv->is_client);
|
||
|
||
m->priv->is_server = FALSE;
|
||
}
|
||
|
||
/* ---------------------------------------------------------------------------------------------------- */
|
||
|
||
static GDBusAuthMechanismState
|
||
mechanism_client_get_state (GDBusAuthMechanism *mechanism)
|
||
{
|
||
GDBusAuthMechanismSha1 *m = G_DBUS_AUTH_MECHANISM_SHA1 (mechanism);
|
||
|
||
g_return_val_if_fail (G_IS_DBUS_AUTH_MECHANISM_SHA1 (mechanism), G_DBUS_AUTH_MECHANISM_STATE_INVALID);
|
||
g_return_val_if_fail (m->priv->is_client && !m->priv->is_server, G_DBUS_AUTH_MECHANISM_STATE_INVALID);
|
||
|
||
return m->priv->state;
|
||
}
|
||
|
||
static gchar *
|
||
mechanism_client_initiate (GDBusAuthMechanism *mechanism,
|
||
gsize *out_initial_response_len)
|
||
{
|
||
GDBusAuthMechanismSha1 *m = G_DBUS_AUTH_MECHANISM_SHA1 (mechanism);
|
||
gchar *initial_response;
|
||
|
||
g_return_val_if_fail (G_IS_DBUS_AUTH_MECHANISM_SHA1 (mechanism), NULL);
|
||
g_return_val_if_fail (!m->priv->is_server && !m->priv->is_client, NULL);
|
||
|
||
m->priv->is_client = TRUE;
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_WAITING_FOR_DATA;
|
||
|
||
*out_initial_response_len = -1;
|
||
|
||
#ifdef G_OS_UNIX
|
||
initial_response = g_strdup_printf ("%" G_GINT64_FORMAT, (gint64) getuid ());
|
||
#elif defined (G_OS_WIN32)
|
||
initial_response = _g_dbus_win32_get_user_sid ();
|
||
#else
|
||
#error Please implement for your OS
|
||
#endif
|
||
g_assert (initial_response != NULL);
|
||
|
||
return initial_response;
|
||
}
|
||
|
||
static void
|
||
mechanism_client_data_receive (GDBusAuthMechanism *mechanism,
|
||
const gchar *data,
|
||
gsize data_len)
|
||
{
|
||
GDBusAuthMechanismSha1 *m = G_DBUS_AUTH_MECHANISM_SHA1 (mechanism);
|
||
gchar **tokens;
|
||
const gchar *cookie_context;
|
||
guint cookie_id;
|
||
const gchar *server_challenge;
|
||
gchar *client_challenge;
|
||
gchar *endp;
|
||
gchar *cookie;
|
||
GError *error;
|
||
gchar *sha1;
|
||
|
||
g_return_if_fail (G_IS_DBUS_AUTH_MECHANISM_SHA1 (mechanism));
|
||
g_return_if_fail (m->priv->is_client && !m->priv->is_server);
|
||
g_return_if_fail (m->priv->state == G_DBUS_AUTH_MECHANISM_STATE_WAITING_FOR_DATA);
|
||
|
||
tokens = NULL;
|
||
cookie = NULL;
|
||
client_challenge = NULL;
|
||
|
||
tokens = g_strsplit (data, " ", 0);
|
||
if (g_strv_length (tokens) != 3)
|
||
{
|
||
g_warning ("Malformed data '%s'", data);
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_REJECTED;
|
||
goto out;
|
||
}
|
||
|
||
cookie_context = tokens[0];
|
||
cookie_id = g_ascii_strtoll (tokens[1], &endp, 10);
|
||
if (*endp != '\0')
|
||
{
|
||
g_warning ("Malformed cookie_id '%s'", tokens[1]);
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_REJECTED;
|
||
goto out;
|
||
}
|
||
server_challenge = tokens[2];
|
||
|
||
error = NULL;
|
||
cookie = keyring_lookup_entry (cookie_context, cookie_id, &error);
|
||
if (cookie == NULL)
|
||
{
|
||
g_warning ("Problems looking up entry in keyring: %s", error->message);
|
||
g_error_free (error);
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_REJECTED;
|
||
goto out;
|
||
}
|
||
|
||
client_challenge = random_ascii_string (16);
|
||
sha1 = generate_sha1 (server_challenge, client_challenge, cookie);
|
||
m->priv->to_send = g_strdup_printf ("%s %s", client_challenge, sha1);
|
||
g_free (sha1);
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_HAVE_DATA_TO_SEND;
|
||
|
||
out:
|
||
g_strfreev (tokens);
|
||
g_free (cookie);
|
||
g_free (client_challenge);
|
||
}
|
||
|
||
static gchar *
|
||
mechanism_client_data_send (GDBusAuthMechanism *mechanism,
|
||
gsize *out_data_len)
|
||
{
|
||
GDBusAuthMechanismSha1 *m = G_DBUS_AUTH_MECHANISM_SHA1 (mechanism);
|
||
|
||
g_return_val_if_fail (G_IS_DBUS_AUTH_MECHANISM_SHA1 (mechanism), NULL);
|
||
g_return_val_if_fail (m->priv->is_client && !m->priv->is_server, NULL);
|
||
g_return_val_if_fail (m->priv->state == G_DBUS_AUTH_MECHANISM_STATE_HAVE_DATA_TO_SEND, NULL);
|
||
|
||
g_assert (m->priv->to_send != NULL);
|
||
|
||
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_ACCEPTED;
|
||
|
||
return g_strdup (m->priv->to_send);
|
||
}
|
||
|
||
static void
|
||
mechanism_client_shutdown (GDBusAuthMechanism *mechanism)
|
||
{
|
||
GDBusAuthMechanismSha1 *m = G_DBUS_AUTH_MECHANISM_SHA1 (mechanism);
|
||
|
||
g_return_if_fail (G_IS_DBUS_AUTH_MECHANISM_SHA1 (mechanism));
|
||
g_return_if_fail (m->priv->is_client && !m->priv->is_server);
|
||
|
||
m->priv->is_client = FALSE;
|
||
}
|
||
|
||
/* ---------------------------------------------------------------------------------------------------- */
|