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; }