|
|
/* pinentry-gnome3.c
|
|
|
* Copyright (C) 2015 g10 Code GmbH
|
|
|
*
|
|
|
* pinentry-gnome-3 is a pinentry application for GNOME 3. It tries
|
|
|
* to follow the Gnome Human Interface Guide as close as possible.
|
|
|
*
|
|
|
* 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, see <https://www.gnu.org/licenses/>.
|
|
|
* SPDX-License-Identifier: GPL-2.0+
|
|
|
*/
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
# include "config.h"
|
|
|
#endif
|
|
|
|
|
|
#include <gcr/gcr-base.h>
|
|
|
|
|
|
#include <string.h>
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
#include <assuan.h>
|
|
|
|
|
|
#include "memory.h"
|
|
|
|
|
|
#include "pinentry.h"
|
|
|
|
|
|
#ifdef FALLBACK_CURSES
|
|
|
#include "pinentry-curses.h"
|
|
|
#endif
|
|
|
|
|
|
|
|
|
#define PGMNAME "pinentry-gnome3"
|
|
|
|
|
|
#ifndef VERSION
|
|
|
# define VERSION
|
|
|
#endif
|
|
|
|
|
|
|
|
|
struct pe_gnome3_run_s {
|
|
|
pinentry_t pinentry;
|
|
|
GcrPrompt *prompt;
|
|
|
GMainLoop *main_loop;
|
|
|
int ret;
|
|
|
guint timeout_id;
|
|
|
int timed_out;
|
|
|
};
|
|
|
|
|
|
static void pe_gcr_prompt_password_done (GObject *source_object,
|
|
|
GAsyncResult *res, gpointer user_data);
|
|
|
|
|
|
static void pe_gcr_prompt_confirm_done (GObject *source_object,
|
|
|
GAsyncResult *res, gpointer user_data);
|
|
|
static gboolean pe_gcr_timeout_done (gpointer user_data);
|
|
|
|
|
|
|
|
|
|
|
|
static gchar *
|
|
|
pinentry_utf8_validate (gchar *text)
|
|
|
{
|
|
|
gchar *result;
|
|
|
|
|
|
if (!text)
|
|
|
return NULL;
|
|
|
|
|
|
if (g_utf8_validate (text, -1, NULL))
|
|
|
return g_strdup (text);
|
|
|
|
|
|
/* Failure: Assume that it was encoded in the current locale and
|
|
|
convert it to utf-8. */
|
|
|
result = g_locale_to_utf8 (text, -1, NULL, NULL, NULL);
|
|
|
if (!result)
|
|
|
{
|
|
|
gchar *p;
|
|
|
|
|
|
result = p = g_strdup (text);
|
|
|
while (!g_utf8_validate (p, -1, (const gchar **) &p))
|
|
|
*p = '?';
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
|
|
|
static void
|
|
|
_propagate_g_error_to_pinentry (pinentry_t pe, GError *error,
|
|
|
gpg_err_code_t code, const char *loc)
|
|
|
{
|
|
|
char *t;
|
|
|
|
|
|
/* We can't return the result of g_strdup_printf directly, because
|
|
|
* this needs to be g_free'd, but the users of PE (e.g.,
|
|
|
* pinentry_reset in pinentry/pinentry.c) use free. */
|
|
|
t = g_strdup_printf ("%d: %s", error->code, error->message);
|
|
|
if (t)
|
|
|
{
|
|
|
/* If strdup fails, then PE->SPECIFIC_ERR_INFO will be NULL,
|
|
|
* which is exactly what we want if strdup fails. So, there is
|
|
|
* no need to check for failure. */
|
|
|
pe->specific_err_info = strdup (t);
|
|
|
g_free (t);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
pe->specific_err_info = NULL;
|
|
|
}
|
|
|
|
|
|
pe->specific_err = gpg_error (code);
|
|
|
pe->specific_err_loc = loc;
|
|
|
}
|
|
|
|
|
|
static GcrPrompt *
|
|
|
create_prompt (pinentry_t pe, int confirm)
|
|
|
{
|
|
|
GcrPrompt *prompt;
|
|
|
GError *error = NULL;
|
|
|
char *msg, *p;
|
|
|
char window_id[32];
|
|
|
|
|
|
/* Create the prompt. */
|
|
|
prompt = GCR_PROMPT (gcr_system_prompt_open (pe->timeout ? pe->timeout : -1, NULL, &error));
|
|
|
if (! prompt)
|
|
|
{
|
|
|
/* this means the timeout elapsed, but no prompt was ever shown. */
|
|
|
if (error->code == GCR_SYSTEM_PROMPT_IN_PROGRESS)
|
|
|
{
|
|
|
fprintf (stderr, "Timeout: the Gcr system prompter was already in use.\n");
|
|
|
pe->specific_err_info = strdup ("Timeout: the Gcr system prompter was already in use.");
|
|
|
/* not using GPG_ERR_TIMEOUT here because the user never saw
|
|
|
a prompt: */
|
|
|
pe->specific_err = gpg_error (GPG_ERR_PIN_ENTRY);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
fprintf (stderr, "couldn't create prompt for gnupg passphrase: %s\n",
|
|
|
error->message);
|
|
|
_propagate_g_error_to_pinentry (pe, error, GPG_ERR_CONFIGURATION,
|
|
|
"gcr_system_prompt_open");
|
|
|
}
|
|
|
g_error_free (error);
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
/* Set the messages for the various buttons, etc. */
|
|
|
p = pinentry_get_title (pe);
|
|
|
if (p)
|
|
|
{
|
|
|
msg = pinentry_utf8_validate (p);
|
|
|
if (msg)
|
|
|
{
|
|
|
gcr_prompt_set_title (prompt, msg);
|
|
|
g_free (msg);
|
|
|
}
|
|
|
free (p);
|
|
|
}
|
|
|
|
|
|
if (pe->description)
|
|
|
{
|
|
|
msg = pinentry_utf8_validate (pe->description);
|
|
|
gcr_prompt_set_description (prompt, msg);
|
|
|
g_free (msg);
|
|
|
}
|
|
|
|
|
|
/* An error occurred during the last prompt. */
|
|
|
if (pe->error)
|
|
|
{
|
|
|
msg = pinentry_utf8_validate (pe->error);
|
|
|
gcr_prompt_set_warning (prompt, msg);
|
|
|
g_free (msg);
|
|
|
}
|
|
|
|
|
|
if (! pe->prompt && confirm)
|
|
|
gcr_prompt_set_message (prompt, "Message");
|
|
|
else if (! pe->prompt && ! confirm)
|
|
|
gcr_prompt_set_message (prompt, "Enter Passphrase");
|
|
|
else
|
|
|
{
|
|
|
msg = pinentry_utf8_validate (pe->prompt);
|
|
|
gcr_prompt_set_message (prompt, msg);
|
|
|
g_free (msg);
|
|
|
}
|
|
|
|
|
|
if (! confirm)
|
|
|
gcr_prompt_set_password_new (prompt, !!pe->repeat_passphrase);
|
|
|
|
|
|
if (pe->ok || pe->default_ok)
|
|
|
{
|
|
|
msg = pinentry_utf8_validate (pe->ok ?: pe->default_ok);
|
|
|
gcr_prompt_set_continue_label (prompt, msg);
|
|
|
g_free (msg);
|
|
|
}
|
|
|
/* XXX: Disable this button if pe->one_button is set. */
|
|
|
if (pe->cancel || pe->default_cancel)
|
|
|
{
|
|
|
msg = pinentry_utf8_validate (pe->cancel ?: pe->default_cancel);
|
|
|
gcr_prompt_set_cancel_label (prompt, msg);
|
|
|
g_free (msg);
|
|
|
}
|
|
|
|
|
|
if (confirm && pe->notok)
|
|
|
{
|
|
|
/* XXX: Add support for the third option. */
|
|
|
}
|
|
|
|
|
|
/* gcr expects a string; we have a int. see gcr's
|
|
|
ui/frob-system-prompt.c for example conversion using %lu */
|
|
|
snprintf (window_id, sizeof (window_id), "%lu",
|
|
|
(long unsigned int)pe->parent_wid);
|
|
|
window_id[sizeof (window_id) - 1] = '\0';
|
|
|
gcr_prompt_set_caller_window (prompt, window_id);
|
|
|
|
|
|
#ifdef HAVE_LIBSECRET
|
|
|
if (! confirm && pe->allow_external_password_cache && pe->keyinfo)
|
|
|
{
|
|
|
if (pe->default_pwmngr)
|
|
|
{
|
|
|
msg = pinentry_utf8_validate (pe->default_pwmngr);
|
|
|
gcr_prompt_set_choice_label (prompt, msg);
|
|
|
g_free (msg);
|
|
|
}
|
|
|
else
|
|
|
gcr_prompt_set_choice_label
|
|
|
(prompt, "Automatically unlock this key, whenever I'm logged in");
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
return prompt;
|
|
|
}
|
|
|
|
|
|
static int
|
|
|
gnome3_cmd_handler (pinentry_t pe)
|
|
|
{
|
|
|
struct pe_gnome3_run_s state;
|
|
|
|
|
|
state.main_loop = g_main_loop_new (NULL, FALSE);
|
|
|
if (!state.main_loop)
|
|
|
{
|
|
|
pe->specific_err_info = strdup ("Failed to create GMainLoop");
|
|
|
pe->specific_err = gpg_error (GPG_ERR_PIN_ENTRY);
|
|
|
pe->specific_err_loc = "g_main_loop_new";
|
|
|
pe->canceled = 1;
|
|
|
return -1;
|
|
|
}
|
|
|
state.pinentry = pe;
|
|
|
state.ret = 0;
|
|
|
state.timeout_id = 0;
|
|
|
state.timed_out = 0;
|
|
|
state.prompt = create_prompt (pe, !(pe->pin));
|
|
|
if (!state.prompt)
|
|
|
{
|
|
|
pe->canceled = 1;
|
|
|
return -1;
|
|
|
}
|
|
|
if (pe->pin)
|
|
|
gcr_prompt_password_async (state.prompt, NULL, pe_gcr_prompt_password_done,
|
|
|
&state);
|
|
|
else
|
|
|
gcr_prompt_confirm_async (state.prompt, NULL, pe_gcr_prompt_confirm_done,
|
|
|
&state);
|
|
|
|
|
|
if (pe->timeout)
|
|
|
state.timeout_id = g_timeout_add_seconds (pe->timeout,
|
|
|
pe_gcr_timeout_done, &state);
|
|
|
g_main_loop_run (state.main_loop);
|
|
|
|
|
|
/* clean up state: */
|
|
|
if (state.timeout_id && !state.timed_out)
|
|
|
g_source_destroy
|
|
|
(g_main_context_find_source_by_id (NULL, state.timeout_id));
|
|
|
|
|
|
g_clear_object (&state.prompt);
|
|
|
g_main_loop_unref (state.main_loop);
|
|
|
return state.ret;
|
|
|
};
|
|
|
|
|
|
|
|
|
static void
|
|
|
pe_gcr_prompt_password_done (GObject *source_object,
|
|
|
GAsyncResult *res, gpointer user_data)
|
|
|
{
|
|
|
struct pe_gnome3_run_s *state = user_data;
|
|
|
GcrPrompt *prompt = GCR_PROMPT (source_object);
|
|
|
|
|
|
if (state && prompt && state->prompt == prompt)
|
|
|
{
|
|
|
const char *password;
|
|
|
GError *error = NULL;
|
|
|
pinentry_t pe = state->pinentry;
|
|
|
int ret = -1;
|
|
|
|
|
|
/* "The returned password is valid until the next time a method
|
|
|
is called to display another prompt." */
|
|
|
password = gcr_prompt_password_finish (prompt, res, &error);
|
|
|
if ((! password && ! error)
|
|
|
|| (error && error->code == G_IO_ERROR_CANCELLED))
|
|
|
{
|
|
|
/* operation was cancelled or timed out. */
|
|
|
ret = -1;
|
|
|
if (state->timed_out)
|
|
|
state->pinentry->specific_err = gpg_error (GPG_ERR_TIMEOUT);
|
|
|
if (error)
|
|
|
g_error_free (error);
|
|
|
}
|
|
|
else if (error)
|
|
|
{
|
|
|
_propagate_g_error_to_pinentry (pe, error,
|
|
|
GPG_ERR_PIN_ENTRY,
|
|
|
"gcr_system_password_finish");
|
|
|
g_error_free (error);
|
|
|
ret = -1;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
pinentry_setbufferlen (pe, strlen (password) + 1);
|
|
|
if (pe->pin)
|
|
|
strcpy (pe->pin, password);
|
|
|
|
|
|
if (pe->repeat_passphrase)
|
|
|
pe->repeat_okay = 1;
|
|
|
|
|
|
#ifdef HAVE_LIBSECRET
|
|
|
if (pe->allow_external_password_cache && pe->keyinfo)
|
|
|
pe->may_cache_password = gcr_prompt_get_choice_chosen (prompt);
|
|
|
#endif
|
|
|
|
|
|
ret = 1;
|
|
|
}
|
|
|
state->ret = ret;
|
|
|
}
|
|
|
|
|
|
if (state)
|
|
|
g_main_loop_quit (state->main_loop);
|
|
|
}
|
|
|
|
|
|
static void
|
|
|
pe_gcr_prompt_confirm_done (GObject *source_object, GAsyncResult *res,
|
|
|
gpointer user_data)
|
|
|
{
|
|
|
struct pe_gnome3_run_s *state = user_data;
|
|
|
GcrPrompt *prompt = GCR_PROMPT (source_object);
|
|
|
|
|
|
if (state && prompt && state->prompt == prompt)
|
|
|
{
|
|
|
GcrPromptReply reply;
|
|
|
GError *error = NULL;
|
|
|
pinentry_t pe = state->pinentry;
|
|
|
int ret = -1;
|
|
|
|
|
|
/* XXX: We don't support a third button! */
|
|
|
|
|
|
reply = gcr_prompt_confirm_finish (prompt, res, &error);
|
|
|
if (error)
|
|
|
{
|
|
|
if (error->code == G_IO_ERROR_CANCELLED)
|
|
|
{
|
|
|
pe->canceled = 1;
|
|
|
if (state->timed_out)
|
|
|
state->pinentry->specific_err = gpg_error (GPG_ERR_TIMEOUT);
|
|
|
}
|
|
|
else
|
|
|
_propagate_g_error_to_pinentry (state->pinentry, error, GPG_ERR_PIN_ENTRY,
|
|
|
"gcr_system_confirm_finish");
|
|
|
g_error_free (error);
|
|
|
ret = 0;
|
|
|
}
|
|
|
else if (reply == GCR_PROMPT_REPLY_CONTINUE
|
|
|
/* XXX: Hack since gcr doesn't yet support one button
|
|
|
message boxes treat cancel the same as okay. */
|
|
|
|| pe->one_button)
|
|
|
{
|
|
|
/* Confirmation. */
|
|
|
ret = 1;
|
|
|
}
|
|
|
else /* GCR_PROMPT_REPLY_CANCEL */
|
|
|
{
|
|
|
pe->canceled = 1;
|
|
|
if (state->timed_out)
|
|
|
state->pinentry->specific_err = gpg_error (GPG_ERR_TIMEOUT);
|
|
|
ret = 0;
|
|
|
}
|
|
|
state->ret = ret;
|
|
|
}
|
|
|
|
|
|
if (state)
|
|
|
g_main_loop_quit (state->main_loop);
|
|
|
}
|
|
|
|
|
|
static gboolean
|
|
|
pe_gcr_timeout_done (gpointer user_data)
|
|
|
{
|
|
|
struct pe_gnome3_run_s *state = user_data;
|
|
|
|
|
|
if (!state)
|
|
|
return FALSE;
|
|
|
|
|
|
state->timed_out = 1;
|
|
|
gcr_prompt_close (state->prompt);
|
|
|
|
|
|
return FALSE;
|
|
|
}
|
|
|
|
|
|
pinentry_cmd_handler_t pinentry_cmd_handler = gnome3_cmd_handler;
|
|
|
|
|
|
/* Test whether there is a GNOME screensaver running that happens to
|
|
|
* be locked. Note that if there is no GNOME screensaver running at
|
|
|
* all the answer is still FALSE. */
|
|
|
static gboolean
|
|
|
pe_gnome_screen_locked (void)
|
|
|
{
|
|
|
GDBusConnection *dbus;
|
|
|
GError *error = NULL;
|
|
|
GVariant *reply, *reply_bool;
|
|
|
gboolean ret;
|
|
|
|
|
|
dbus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
|
|
|
|
|
|
if (!dbus)
|
|
|
{
|
|
|
fprintf (stderr, "failed to connect to user session D-Bus (%d): %s",
|
|
|
error ? error->code : -1,
|
|
|
error ? error->message : "<no GError>");
|
|
|
if (error)
|
|
|
g_error_free (error);
|
|
|
return FALSE;
|
|
|
}
|
|
|
|
|
|
/* this is intended to be the equivalent of:
|
|
|
* dbus-send --print-reply=literal --session \
|
|
|
* --dest=org.gnome.ScreenSaver \
|
|
|
* /org/gnome/ScreenSaver \
|
|
|
* org.gnome.ScreenSaver.GetActive
|
|
|
*/
|
|
|
reply = g_dbus_connection_call_sync (dbus,
|
|
|
"org.gnome.ScreenSaver",
|
|
|
"/org/gnome/ScreenSaver",
|
|
|
"org.gnome.ScreenSaver",
|
|
|
"GetActive",
|
|
|
NULL,
|
|
|
((const GVariantType *) "(b)"),
|
|
|
G_DBUS_CALL_FLAGS_NO_AUTO_START,
|
|
|
0,
|
|
|
NULL,
|
|
|
&error);
|
|
|
g_object_unref(dbus);
|
|
|
if (!reply)
|
|
|
{
|
|
|
/* G_IO_ERROR_TIMED_OUT is the expected response when there is
|
|
|
* no gnome screensaver at all, don't be noisy in that case: */
|
|
|
if (!(error && error->code == G_IO_ERROR_TIMED_OUT))
|
|
|
fprintf (stderr, "Failed to get d-bus reply for org.gnome.ScreenSaver.GetActive (%d): %s\n",
|
|
|
error ? error->code : -1,
|
|
|
error ? error->message : "<no GError>");
|
|
|
if (error)
|
|
|
g_error_free (error);
|
|
|
return FALSE;
|
|
|
}
|
|
|
reply_bool = g_variant_get_child_value (reply, 0);
|
|
|
if (!reply_bool)
|
|
|
{
|
|
|
fprintf (stderr, "Failed to get d-bus boolean from org.gnome.ScreenSaver.GetActive; assuming screensaver is not locked\n");
|
|
|
ret = FALSE;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
ret = g_variant_get_boolean (reply_bool);
|
|
|
g_variant_unref (reply_bool);
|
|
|
}
|
|
|
|
|
|
g_variant_unref (reply);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
/* Test whether we can create a system prompt or not. This briefly
|
|
|
* does create a system prompt, which blocks other tools from making
|
|
|
* the same request concurrently, so we just create it to test if it is
|
|
|
* available, and quickly close it. */
|
|
|
static int
|
|
|
pe_gcr_system_prompt_available (void)
|
|
|
{
|
|
|
GcrSystemPrompt *prompt;
|
|
|
GError *error = NULL;
|
|
|
int ret = 0;
|
|
|
|
|
|
prompt = GCR_SYSTEM_PROMPT (gcr_system_prompt_open (0, NULL, &error));
|
|
|
if (prompt)
|
|
|
{
|
|
|
ret = 1;
|
|
|
if (!gcr_system_prompt_close (prompt, NULL, &error))
|
|
|
fprintf (stderr, "failed to close test Gcr System Prompt (%d): %s\n",
|
|
|
error ? error->code : -1,
|
|
|
error ? error->message : "<no GError>");
|
|
|
g_clear_object (&prompt);
|
|
|
}
|
|
|
else if (error && error->code == GCR_SYSTEM_PROMPT_IN_PROGRESS)
|
|
|
{
|
|
|
/* This one particular failure is OK; we're clearly capable of
|
|
|
* making a system prompt, even though someone else has the
|
|
|
* system prompter right now: */
|
|
|
ret = 1;
|
|
|
}
|
|
|
|
|
|
if (error)
|
|
|
g_error_free (error);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int
|
|
|
main (int argc, char *argv[])
|
|
|
{
|
|
|
pinentry_init (PGMNAME);
|
|
|
|
|
|
#ifdef FALLBACK_CURSES
|
|
|
if (!getenv ("DBUS_SESSION_BUS_ADDRESS"))
|
|
|
{
|
|
|
fprintf (stderr, "No $DBUS_SESSION_BUS_ADDRESS found,"
|
|
|
" falling back to curses\n");
|
|
|
pinentry_cmd_handler = curses_cmd_handler;
|
|
|
pinentry_set_flavor_flag ("curses");
|
|
|
}
|
|
|
else if (!pe_gcr_system_prompt_available ())
|
|
|
{
|
|
|
fprintf (stderr, "No Gcr System Prompter available,"
|
|
|
" falling back to curses\n");
|
|
|
pinentry_cmd_handler = curses_cmd_handler;
|
|
|
pinentry_set_flavor_flag ("curses");
|
|
|
}
|
|
|
else if (pe_gnome_screen_locked ())
|
|
|
{
|
|
|
fprintf (stderr, "GNOME screensaver is locked,"
|
|
|
" falling back to curses\n");
|
|
|
pinentry_cmd_handler = curses_cmd_handler;
|
|
|
pinentry_set_flavor_flag ("curses");
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
pinentry_parse_opts (argc, argv);
|
|
|
|
|
|
if (pinentry_loop ())
|
|
|
return 1;
|
|
|
|
|
|
return 0;
|
|
|
}
|
