/**
* seahorse_context_object_from_dbus:
* @sctx: A #SeahorseContext
* @key: the string id of the object to get
*
* Finds an object basing on the @key
*
* Returns: The #SeahorseObject found. NULL on not found.
*/
SeahorseObject*
seahorse_context_object_from_dbus (SeahorseContext *sctx, const gchar *key)
{
SeahorseObject *sobj;
/* This will always get the most preferred key */
sobj = seahorse_context_find_object (sctx, g_quark_from_string (key),
SEAHORSE_LOCATION_INVALID);
return sobj;
}
guint
seahorse_pgp_signature_get_sigtype (SeahorsePgpSignature *self)
{
SeahorseObject *sobj;
GQuark id;
g_return_val_if_fail (SEAHORSE_IS_PGP_SIGNATURE (self), 0);
id = seahorse_pgp_key_canonize_id (self->pv->keyid);
sobj = seahorse_context_find_object (SCTX_APP (), id, SEAHORSE_LOCATION_LOCAL);
if (sobj) {
if (seahorse_object_get_usage (sobj) == SEAHORSE_USAGE_PRIVATE_KEY)
return SKEY_PGPSIG_TRUSTED | SKEY_PGPSIG_PERSONAL;
if (seahorse_object_get_flags (sobj) & SEAHORSE_FLAG_TRUSTED)
return SKEY_PGPSIG_TRUSTED;
}
return 0;
}
/**
* seahorse_context_get_default_key:
* @sctx: Current #SeahorseContext
*
* Returns: the secret key that's the default key
*
* Deprecated: No replacement
*/
SeahorseObject*
seahorse_context_get_default_key (SeahorseContext *sctx)
{
SeahorseObject *sobj = NULL;
gchar *id;
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_val_if_fail (SEAHORSE_IS_CONTEXT (sctx), NULL);
/* TODO: All of this needs to take multiple key types into account */
id = seahorse_gconf_get_string (SEAHORSE_DEFAULT_KEY);
if (id != NULL && id[0]) {
GQuark keyid = g_quark_from_string (id);
sobj = seahorse_context_find_object (sctx, keyid, SEAHORSE_LOCATION_LOCAL);
}
g_free (id);
return sobj;
}
/**
* crypto: the crypto service (#SeahorseServiceCrypto)
* recipients: A list of recipients (keyids "openpgp:B8098FB063E2C811")
* Must be empty when symmetric encryption is used.
* signer: optional, the keyid of the signer
* flags: FLAG_SYMMETRIC to perform symmetric encryption
* 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;
gboolean symmetric = FALSE;
gpgme_data_t plain, cipher;
gpgme_error_t gerr;
gboolean ret = TRUE;
GSettings *settings;
gchar *keyid;
if ((flags & FLAG_SYMMETRIC) == FLAG_SYMMETRIC)
symmetric = TRUE;
if (symmetric && recipients[0] != NULL) {
g_set_error (error, SEAHORSE_DBUS_ERROR, SEAHORSE_DBUS_ERROR_INVALID,
_("Recipients specified for symmetric encryption"));
return FALSE;
}
/* 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;
}
}
if (!symmetric) {
/* 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);
if (symmetric) {
/* gpgme_op_encrypt{_sign,}_start() will perform symmetric encryption
* when no recipients are specified. */
recips = NULL;
} else {
/* Add the default key if set and necessary */
settings = g_settings_new ("org.gnome.crypto.pgp");
if (g_settings_get_boolean (settings, "encrypt-to-self")) {
keyid = g_settings_get_string (settings, "default-key");
if (keyid && keyid[0]) {
skey = seahorse_context_find_object (NULL, g_quark_from_string (keyid),
SEAHORSE_LOCATION_LOCAL);
if (SEAHORSE_IS_PGP_KEY (skey))
recipkeys = g_list_append (recipkeys, skey);
}
g_free (keyid);
}
g_object_unref (settings);
/* 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;
}
