static void
seahorse_hkp_operation_init (SeahorseHKPOperation *hop)
{
SoupURI *uri;
gchar *host;
#if DEBUG_HKP_ENABLE
SoupLogger *logger;
#endif
if (seahorse_gconf_get_boolean (GCONF_USE_HTTP_PROXY)) {
host = seahorse_gconf_get_string (GCONF_HTTP_PROXY_HOST);
if (host) {
uri = soup_uri_new (NULL);
if (!uri) {
g_warning ("creation of SoupURI from '%s' failed", host);
} else {
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTP);
soup_uri_set_host (uri, host);
g_free (host);
soup_uri_set_port (uri, seahorse_gconf_get_integer (GCONF_PROXY_PORT));
if (seahorse_gconf_get_boolean (GCONF_USE_AUTH)) {
char *user, *pass;
user = seahorse_gconf_get_string (GCONF_AUTH_USER);
soup_uri_set_user (uri, user);
g_free (user);
pass = seahorse_gconf_get_string (GCONF_AUTH_PASS);
soup_uri_set_password (uri, pass);
g_free (pass);
}
hop->session = soup_session_async_new_with_options (SOUP_SESSION_PROXY_URI, uri, NULL);
soup_uri_free (uri);
}
}
}
/* Without a proxy */
if (!hop->session)
hop->session = soup_session_async_new ();
#if DEBUG_HKP_ENABLE
logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
soup_logger_attach (logger, hop->session);
g_object_unref (logger);
#endif
}
static void
update_icon (SeahorseApplet *sapplet)
{
SeahorseAppletPrivate *priv = SEAHORSE_APPLET_GET_PRIVATE (sapplet);
const char *stock = NULL;
if (seahorse_gconf_get_boolean (SHOW_CLIPBOARD_STATE_KEY)) {
switch (priv->clipboard_contents) {
case SEAHORSE_TEXT_TYPE_NONE:
stock = ICON_CLIPBOARD_UNKNOWN;
break;
case SEAHORSE_TEXT_TYPE_PLAIN:
stock = ICON_CLIPBOARD_TEXT;
break;
case SEAHORSE_TEXT_TYPE_KEY:
stock = ICON_CLIPBOARD_KEY;
break;
case SEAHORSE_TEXT_TYPE_MESSAGE:
stock = ICON_CLIPBOARD_ENCRYPTED;
break;
case SEAHORSE_TEXT_TYPE_SIGNED:
stock = ICON_CLIPBOARD_SIGNED;
break;
default:
g_assert_not_reached ();
return;
};
} else {
stock = ICON_CLIPBOARD_DEFAULT;
}
gtk_image_set_from_stock (GTK_IMAGE (priv->image), stock, GTK_ICON_SIZE_LARGE_TOOLBAR);
}
static void
handle_clipboard_owner_change(GtkClipboard *clipboard, GdkEvent *event,
SeahorseApplet *sapplet)
{
SeahorseAppletPrivate *priv = SEAHORSE_APPLET_GET_PRIVATE (sapplet);
priv->board = clipboard;
if (seahorse_gconf_get_boolean (SHOW_CLIPBOARD_STATE_KEY))
gtk_clipboard_request_text (clipboard,
(GtkClipboardTextReceivedFunc)detect_received, sapplet);
else
update_icon (sapplet);
}
static void
encrypt_received (GtkClipboard *board, const gchar *text, SeahorseApplet *sapplet)
{
gchar *signer = NULL;
gchar *enctext = NULL;
gchar **keys = NULL;
gboolean ret;
GError *err = NULL;
/* No text on clipboard */
if (!text)
return;
/* Get the recipient list */
if (cryptui_keyset_get_count (dbus_keyset) == 0)
cryptui_need_to_get_keys ();
else
keys = cryptui_prompt_recipients (dbus_keyset, _("Choose Recipient Keys"), &signer);
/* User may have cancelled */
if (keys && *keys) {
ret = dbus_g_proxy_call (dbus_crypto_proxy, "EncryptText", &err,
G_TYPE_STRV, keys,
G_TYPE_STRING, signer,
G_TYPE_INT, 0,
G_TYPE_STRING, text,
G_TYPE_INVALID,
G_TYPE_STRING, &enctext,
G_TYPE_INVALID);
if (ret) {
/* And finish up */
gtk_clipboard_set_text (board, enctext, strlen (enctext));
detect_received (board, enctext, sapplet);
if (seahorse_gconf_get_boolean (DISPLAY_CLIPBOARD_ENC_KEY) == TRUE)
display_text (_("Encrypted Text"), enctext, FALSE);
} else {
notification_error (_("Encryption Failed"), _("The clipboard could not be encrypted."),
sapplet, err);
g_clear_error (&err);
}
g_strfreev(keys);
g_free (signer);
g_free (enctext);
}
}
static gboolean
encrypt_sign_start (SeahorseToolMode *mode, const gchar *uri, gpgme_data_t uridata,
SeahorsePGPOperation *pop, GError **err)
{
gpgme_data_t cipher;
gpgme_error_t gerr;
gchar *touri;
g_assert (mode->recipients && mode->recipients[0]);
/* File to encrypt to */
touri = seahorse_util_add_suffix (uri, SEAHORSE_CRYPT_SUFFIX,
_("Choose Encrypted File Name for '%s'"));
if (!touri)
return FALSE;
/* Open necessary files, release these with the operation */
cipher = seahorse_vfs_data_create (touri, SEAHORSE_VFS_WRITE | SEAHORSE_VFS_DELAY, err);
g_free (touri);
if (!cipher)
return FALSE;
g_object_set_data_full (G_OBJECT (pop), "cipher-data", cipher,
(GDestroyNotify)gpgme_data_release);
gpgme_set_armor (pop->gctx, seahorse_gconf_get_boolean (ARMOR_KEY));
gpgme_set_textmode (pop->gctx, FALSE);
/* Start actual encryption */
gpgme_signers_clear (pop->gctx);
if (mode->signer) {
gpgme_signers_add (pop->gctx, mode->signer);
gerr = gpgme_op_encrypt_sign_start (pop->gctx, mode->recipients,
GPGME_ENCRYPT_ALWAYS_TRUST, uridata, cipher);
} else {
gerr = gpgme_op_encrypt_start (pop->gctx, mode->recipients,
GPGME_ENCRYPT_ALWAYS_TRUST, uridata, cipher);
}
if (gerr != 0) {
seahorse_util_gpgme_to_error (gerr, err);
return FALSE;
}
return TRUE;
}
static void
sign_received (GtkClipboard *board, const gchar *text, SeahorseApplet *sapplet)
{
gchar *signer = NULL;
gchar *enctext = NULL;
gboolean ret;
GError *err = NULL;
/* No text on clipboard */
if (!text)
return;
if (cryptui_keyset_get_count (dbus_keyset) == 0)
cryptui_need_to_get_keys (dbus_keyset);
else
signer = cryptui_prompt_signer (dbus_keyset, _("Choose Key to Sign with"));
if (signer == NULL)
return;
/* Perform the signing */
ret = dbus_g_proxy_call (dbus_crypto_proxy, "SignText", &err,
G_TYPE_STRING, signer,
G_TYPE_INT, 0,
G_TYPE_STRING, text,
G_TYPE_INVALID,
G_TYPE_STRING, &enctext,
G_TYPE_INVALID);
if (ret) {
/* And finish up */
gtk_clipboard_set_text (board, enctext, strlen (enctext));
detect_received (board, enctext, sapplet);
if (seahorse_gconf_get_boolean (DISPLAY_CLIPBOARD_ENC_KEY) == TRUE)
display_text (_("Signed Text"), enctext, FALSE);
} else {
notification_error (_("Signing Failed"), _("The clipboard could not be Signed."),
sapplet, err);
g_clear_error (&err);
}
g_free (signer);
g_free (enctext);
}
static void
dvi_received (GtkClipboard *board, const gchar *text, SeahorseApplet *sapplet)
{
SeahorseTextType type; /* Type of the current block */
gchar *rawtext = NULL; /* Replacement text */
guint keys = 0; /* Number of keys imported */
const gchar *start; /* Pointer to start of the block */
const gchar *end; /* Pointer to end of the block */
/* Try to figure out what clipboard contains */
if (text == NULL)
type = SEAHORSE_TEXT_TYPE_NONE;
else
type = detect_text_type (text, -1, &start, &end);
if (type == SEAHORSE_TEXT_TYPE_NONE || type == SEAHORSE_TEXT_TYPE_PLAIN) {
seahorse_notification_display(_("No PGP key or message was found on clipboard"),
_("No PGP data found."), FALSE, NULL, GTK_WIDGET(sapplet));
return;
}
switch (type) {
/* A key, import it */
case SEAHORSE_TEXT_TYPE_KEY:
keys = import_keys (text, sapplet);
break;
/* A message decrypt it */
case SEAHORSE_TEXT_TYPE_MESSAGE:
rawtext = decrypt_text (text, sapplet);
break;
/* A message verify it */
case SEAHORSE_TEXT_TYPE_SIGNED:
rawtext = verify_text (text, sapplet);
break;
default:
g_assert_not_reached ();
break;
};
/* We got replacement text */
if (rawtext) {
gtk_clipboard_set_text (board, rawtext, strlen (rawtext));
detect_received (board, rawtext, sapplet);
if (((type == SEAHORSE_TEXT_TYPE_MESSAGE) &&
(seahorse_gconf_get_boolean (DISPLAY_CLIPBOARD_DEC_KEY) == TRUE)) ||
((type == SEAHORSE_TEXT_TYPE_SIGNED) &&
(seahorse_gconf_get_boolean (DISPLAY_CLIPBOARD_VER_KEY) == TRUE))) {
/* TRANSLATORS: This means 'The text that was decrypted' */
display_text (_("Decrypted Text"), rawtext, TRUE);
}
g_free (rawtext);
rawtext = NULL;
}
}
/**
* crypto: the crypto service (#SeahorseServiceCrypto)
* recipients: A list of recipients (keyids "openpgp:B8098FB063E2C811")
* signer: optional, the keyid of the signer
* flags: 0, not used
* cleartext: the text to encrypt
* clearlength: Length of the cleartext
* crypttext: the encrypted text (out)
* cryptlength: the length of this text (out)
* textmode: TRUE if gpgme should use textmode
* ascii_armor: TRUE if GPGME should use ascii armor
* error: The Error
*
* Handles encryption in a generic way. Can be used by several DBus APIs
*
* Returns TRUE on success
**/
static gboolean
crypto_encrypt_generic (SeahorseServiceCrypto *crypto,
const char **recipients, const char *signer,
int flags, const char *cleartext, gsize clearlength,
char **crypttext, gsize *cryptlength, gboolean textmode,
gboolean ascii_armor, GError **error)
{
GList *recipkeys = NULL;
SeahorseGpgmeOperation *pop;
SeahorseObject *signkey = NULL;
SeahorseObject *skey;
gpgme_key_t *recips;
gpgme_data_t plain, cipher;
gpgme_error_t gerr;
gboolean ret = TRUE;
/*
* TODO: Once we support different kinds of keys that support encryption
* then all this logic will need to change.
*/
/* The signer */
if (signer && signer[0]) {
signkey = seahorse_context_object_from_dbus (SCTX_APP (), signer);
if (!signkey) {
g_set_error (error, SEAHORSE_DBUS_ERROR, SEAHORSE_DBUS_ERROR_INVALID,
_("Invalid or unrecognized signer: %s"), signer);
return FALSE;
}
if (!SEAHORSE_IS_GPGME_KEY (signkey) ||
!(seahorse_object_get_flags (signkey) & SEAHORSE_FLAG_CAN_SIGN)) {
g_set_error (error, SEAHORSE_DBUS_ERROR, SEAHORSE_DBUS_ERROR_INVALID,
_("Key is not valid for signing: %s"), signer);
return FALSE;
}
}
/* The recipients */
for( ; recipients[0]; recipients++)
{
skey = seahorse_context_object_from_dbus (SCTX_APP (), recipients[0]);
if (!skey) {
g_list_free (recipkeys);
g_set_error (error, SEAHORSE_DBUS_ERROR, SEAHORSE_DBUS_ERROR_INVALID,
_("Invalid or unrecognized recipient: %s"), recipients[0]);
return FALSE;
}
if (!SEAHORSE_IS_GPGME_KEY (skey) ||
!(seahorse_object_get_flags (skey) & SEAHORSE_FLAG_CAN_ENCRYPT)) {
g_list_free (recipkeys);
g_set_error (error, SEAHORSE_DBUS_ERROR, SEAHORSE_DBUS_ERROR_INVALID,
_("Key is not a valid recipient for encryption: %s"), recipients[0]);
return FALSE;
}
recipkeys = g_list_prepend (recipkeys, SEAHORSE_PGP_KEY (skey));
}
if (!recipkeys) {
g_set_error (error, SEAHORSE_DBUS_ERROR, SEAHORSE_DBUS_ERROR_INVALID,
_("No recipients specified"));
return FALSE;
}
pop = seahorse_gpgme_operation_new (NULL);
/* new data form text */
gerr = gpgme_data_new_from_mem (&plain, cleartext, clearlength, FALSE);
g_return_val_if_fail (GPG_IS_OK (gerr), FALSE);
gerr = gpgme_data_new (&cipher);
g_return_val_if_fail (GPG_IS_OK (gerr), FALSE);
/* encrypt with armor */
gpgme_set_textmode (pop->gctx, textmode);
gpgme_set_armor (pop->gctx, ascii_armor);
/* Add the default key if set and necessary */
if (seahorse_gconf_get_boolean (ENCRYPTSELF_KEY)) {
skey = SEAHORSE_OBJECT (seahorse_context_get_default_key (SCTX_APP ()));
if (SEAHORSE_IS_PGP_KEY (skey))
recipkeys = g_list_append (recipkeys, skey);
}
/* Make keys into the right format for GPGME */
recips = keylist_to_keys (recipkeys);
g_list_free (recipkeys);
/* Do the encryption */
if (signkey) {
gpgme_signers_add (pop->gctx, seahorse_gpgme_key_get_private (SEAHORSE_GPGME_KEY (signkey)));
gerr = gpgme_op_encrypt_sign_start (pop->gctx, recips, GPGME_ENCRYPT_ALWAYS_TRUST,
plain, cipher);
} else {
gerr = gpgme_op_encrypt_start (pop->gctx, recips, GPGME_ENCRYPT_ALWAYS_TRUST,
plain, cipher);
}
free_keys (recips);
/* Frees cipher */
ret = process_crypto_result (pop, gerr, cipher, crypttext, cryptlength, error);
g_object_unref (pop);
gpgme_data_release (plain);
return ret;
}
/**
* seahorse_context_discover_objects:
* @sctx: the context to work with (can be NULL)
* @ktype: the type of key to discover
* @rawids: a list of ids to discover
*
* Downloads a list of keys from the keyserver
*
* Returns: The imported keys
*/
GList*
seahorse_context_discover_objects (SeahorseContext *sctx, GQuark ktype,
GSList *rawids)
{
SeahorseOperation *op = NULL;
GList *robjects = NULL;
GQuark id = 0;
GSList *todiscover = NULL;
GList *toimport = NULL;
SeahorseSource *sksrc;
SeahorseObject* sobj;
SeahorseLocation loc;
GSList *l;
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_val_if_fail (SEAHORSE_IS_CONTEXT (sctx), NULL);
/* Check all the ids */
for (l = rawids; l; l = g_slist_next (l)) {
id = seahorse_context_canonize_id (ktype, (gchar*)l->data);
if (!id) {
/* TODO: Try and match this partial id */
g_warning ("invalid id: %s", (gchar*)l->data);
continue;
}
/* Do we know about this object? */
sobj = seahorse_context_find_object (sctx, id, SEAHORSE_LOCATION_INVALID);
/* No such object anywhere, discover it */
if (!sobj) {
todiscover = g_slist_prepend (todiscover, GUINT_TO_POINTER (id));
id = 0;
continue;
}
/* Our return value */
robjects = g_list_prepend (robjects, sobj);
/* We know about this object, check where it is */
loc = seahorse_object_get_location (sobj);
g_assert (loc != SEAHORSE_LOCATION_INVALID);
/* Do nothing for local objects */
if (loc >= SEAHORSE_LOCATION_LOCAL)
continue;
/* Remote objects get imported */
else if (loc >= SEAHORSE_LOCATION_REMOTE)
toimport = g_list_prepend (toimport, sobj);
/* Searching objects are ignored */
else if (loc >= SEAHORSE_LOCATION_SEARCHING)
continue;
/* TODO: Should we try SEAHORSE_LOCATION_MISSING objects again? */
}
/* Start an import process on all toimport */
if (toimport) {
op = seahorse_context_transfer_objects (sctx, toimport, NULL);
g_list_free (toimport);
/* Running operations ref themselves */
g_object_unref (op);
}
/* Start a discover process on all todiscover */
if (seahorse_gconf_get_boolean (AUTORETRIEVE_KEY) && todiscover) {
op = seahorse_context_retrieve_objects (sctx, ktype, todiscover, NULL);
/* Running operations ref themselves */
g_object_unref (op);
}
/* Add unknown objects for all these */
sksrc = seahorse_context_find_source (sctx, ktype, SEAHORSE_LOCATION_MISSING);
for (l = todiscover; l; l = g_slist_next (l)) {
if (sksrc) {
sobj = seahorse_unknown_source_add_object (SEAHORSE_UNKNOWN_SOURCE (sksrc),
GPOINTER_TO_UINT (l->data), op);
robjects = g_list_prepend (robjects, sobj);
}
}
g_slist_free (todiscover);
return robjects;
}
