gboolean p_gpg_valid_key(const char *const keyid, char **err_str) { gpgme_ctx_t ctx; gpgme_error_t error = gpgme_new(&ctx); if (error) { log_error("GPG: Failed to create gpgme context. %s %s", gpgme_strsource(error), gpgme_strerror(error)); *err_str = strdup(gpgme_strerror(error)); return FALSE; } gpgme_key_t key = NULL; error = gpgme_get_key(ctx, keyid, &key, 1); if (error || key == NULL) { log_error("GPG: Failed to get key. %s %s", gpgme_strsource(error), gpgme_strerror(error)); *err_str = strdup(gpgme_strerror(error)); gpgme_release(ctx); return FALSE; } if (key == NULL) { *err_str = strdup("Unknown error"); gpgme_release(ctx); return FALSE; } gpgme_release(ctx); gpgme_key_unref(key); return TRUE; }
gboolean sgpgme_has_secret_key(void) { gpgme_error_t err = 0; gpgme_ctx_t ctx; gpgme_key_t key; err = gpgme_new (&ctx); if (err) { debug_print("err : %s\n", gpgme_strerror(err)); return TRUE; } check_again: err = gpgme_op_keylist_start(ctx, NULL, TRUE); if (!err) err = gpgme_op_keylist_next(ctx, &key); gpgme_op_keylist_end(ctx); if (gpg_err_code(err) == GPG_ERR_EOF) { if (gpgme_get_protocol(ctx) != GPGME_PROTOCOL_CMS) { gpgme_set_protocol(ctx, GPGME_PROTOCOL_CMS); goto check_again; } gpgme_release(ctx); return FALSE; } else { gpgme_release(ctx); return TRUE; } }
int op_export_keys (const char *pattern[], const char *outfile) { /* @untested@ */ gpgme_ctx_t ctx=NULL; gpgme_data_t out=NULL; gpgme_error_t err; err = gpgme_new (&ctx); if (err) return err; err = gpgme_data_new (&out); if (err) { gpgme_release (ctx); return err; } gpgme_set_armor (ctx, 1); err = gpgme_op_export_ext (ctx, pattern, 0, out); if (!err) data_to_file (&out, outfile); gpgme_data_release (out); gpgme_release (ctx); return err; }
char *gpg_decrypt_msg(const char *data, long *plain_size) { gpgme_ctx_t ctx; gpgme_error_t err; size_t n = 0; char *temp, *str, *msg; gpgme_data_t plain, cipher; msg = add_gpg_headers(data); if (!msg) { return 0; } err = gpgme_new(&ctx); if (err) { return 0; } gpgme_set_protocol(ctx, GPGME_PROTOCOL_OpenPGP); gpgme_set_armor(ctx, 1); // char *p = getenv("GPG_AGENT_INFO"); // if (p) { // log_write("GPG_AGENT_INFO: %s\n", p); // } else { // setenv("GPG_AGENT_INFO", "/tmp/gpg-3FhMq6/S.gpg-agent:22765:1", 1); // log_write("NO GPG AGENT INFO FOUND\n"); // } gpgme_set_passphrase_cb(ctx, &passphrase_cb, 0); gpgme_data_new_from_mem(&cipher, msg, strlen(msg), 0); gpgme_data_new(&plain); err = gpgme_op_decrypt(ctx, cipher, plain); gpgme_decrypt_result_t res = gpgme_op_decrypt_result(ctx); gpgme_recipient_t recipient = res->recipients; while (recipient) { log_write(">>> recipient keyid: %s\n", recipient->keyid); recipient = recipient->next; } gpgme_data_release(cipher); free(msg); if (err) { log_write("gpgme_op_decrypt error: %s\n", gpgme_strerror(err)); gpgme_data_release(plain); gpgme_release(ctx); return 0; } temp = gpgme_data_release_and_get_mem(plain, &n); if (!temp) { gpgme_release(ctx); return 0; } *plain_size = n; str = strndup(temp, n); free(temp); gpgme_release(ctx); return str; }
/* ------------------ * check if a key is locally available * ------------------ */ int is_key_available(const char* fpr,int secret, int servermode, char** userid) { gpgme_error_t error; gpgme_ctx_t ctx; gpgme_key_t key; gpgme_key_t key_arr[2]; gpgme_keylist_mode_t current_keylist_mode; key_arr[0] = NULL; key_arr[1] = NULL; // connect to gpgme gpgme_check_version (NULL); error = gpgme_new(&ctx); if (error) { purple_debug_error(PLUGIN_ID,"gpgme_new failed: %s %s\n",gpgme_strsource (error), gpgme_strerror (error)); return FALSE; } // set to server search mode if servermode == TRUE if (servermode == TRUE) { purple_debug_info(PLUGIN_ID,"set keylist mode to server\n"); current_keylist_mode = gpgme_get_keylist_mode(ctx); gpgme_set_keylist_mode(ctx,(current_keylist_mode | GPGME_KEYLIST_MODE_EXTERN) &(~GPGME_KEYLIST_MODE_LOCAL)); } // get key by fingerprint error = gpgme_get_key(ctx,fpr,&key,secret); if (error || !key) { purple_debug_error(PLUGIN_ID,"gpgme_get_key failed: %s %s\n",gpgme_strsource (error), gpgme_strerror (error)); gpgme_release (ctx); return FALSE; } // if we have parameter, tell caller about userid if (userid != NULL) { *userid = g_strdup(key->uids->uid); } // import key key_arr[0] = key; error = gpgme_op_import_keys (ctx, key_arr); if (error) { purple_debug_error(PLUGIN_ID,"gpgme_op_import_keys failed: %s %s\n",gpgme_strsource (error), gpgme_strerror (error)); gpgme_release (ctx); return FALSE; } // close gpgme connection gpgme_release (ctx); // we got the key, YEAH :) return TRUE; }
GSList * get_available_keys () { init_gpgme (); gpgme_ctx_t ctx; gpgme_key_t key; gpgme_error_t err = gpgme_new (&ctx); if (err) { g_printerr ("%s:%d: %s: %s\n", __FILE__, __LINE__, gpgme_strsource (err), gpgme_strerror (err)); return GPGME_ERROR; } err = gpgme_op_keylist_start (ctx, NULL, 1); if (err) { g_printerr ("%s:%d: %s: %s\n", __FILE__, __LINE__, gpgme_strsource (err), gpgme_strerror (err)); gpgme_release (ctx); return GPGME_ERROR; } GSList *list = NULL; KeyInfo *key_info; while (1) { err = gpgme_op_keylist_next (ctx, &key); if (err) { break; } key_info = g_new0 (KeyInfo, 1); key_info->key_id = g_strdup (key->subkeys->keyid); if (key->uids && key->uids->name) { key_info->name = g_strdup (key->uids->name); } else { key_info->name = g_strdup ("none"); } if (key->uids && key->uids->email) { key_info->email = g_strdup (key->uids->email); } else { key_info->email = g_strdup ("none"); } key_info->key_fpr = g_strdup (key->subkeys->fpr); gssize bytes_to_copy = sizeof (KeyInfo) + g_utf8_strlen (key_info->name, -1) + g_utf8_strlen (key_info->email, -1) + g_utf8_strlen (key_info->key_id, -1) + g_utf8_strlen (key_info->key_fpr, -1) + 4; list = g_slist_append (list, g_memdup (key_info, bytes_to_copy)); g_free (key_info); gpgme_key_release (key); } gpgme_release (ctx); return list; }
/* ------------------ * get ascii armored public key * FREE MEMORY AFTER USAGE OF RETURN VALUE! * ------------------ */ char* get_key_armored(const char* fpr) { gpgme_error_t error; gpgme_ctx_t ctx; gpgme_data_t key_data; gpgme_key_t key; gpgme_key_t key_arr[2]; key_arr[0] = key_arr[1] = NULL; size_t len = 0; char* key_str = NULL; char* key_str_dup = NULL; // connect to gpgme gpgme_check_version (NULL); error = gpgme_new(&ctx); if (error) { purple_debug_error(PLUGIN_ID,"gpgme_new failed: %s %s\n",gpgme_strsource (error), gpgme_strerror (error)); return NULL; } // get key by fingerprint error = gpgme_get_key(ctx,fpr,&key,0); if (error || !key) { purple_debug_error(PLUGIN_ID,"gpgme_get_key failed: %s %s\n",gpgme_strsource (error), gpgme_strerror (error)); gpgme_release (ctx); return NULL; } key_arr[0] = key; // create data containers gpgme_data_new(&key_data); // export key gpgme_set_armor(ctx,1); error = gpgme_op_export_keys (ctx, key_arr, 0, key_data); if (error) { purple_debug_error(PLUGIN_ID,"gpgme_op_export_keys failed: %s %s\n",gpgme_strsource (error), gpgme_strerror (error)); gpgme_release (ctx); return NULL; } // release memory for data containers key_str = gpgme_data_release_and_get_mem(key_data,&len); if (key_str != NULL) { key_str[len] = 0; key_str_dup = g_strdup(key_str); } gpgme_free(key_str); // close gpgme connection gpgme_release (ctx); // we got the key, YEAH :) return key_str_dup; }
char *gpg_encrypt_msg(const char *msg, const char *fpr) { gpgme_ctx_t ctx; gpgme_data_t plain, cipher; gpgme_error_t err; char *temp, *str; char *ret = 0; gpgme_key_t key_arr[2] = {0, 0}; size_t n = 0; err = gpgme_new(&ctx); if (err) { return 0; } gpgme_set_protocol(ctx, GPGME_PROTOCOL_OpenPGP); gpgme_set_armor(ctx, 1); err = gpgme_get_key(ctx, fpr, &key_arr[0], 0); if (err) { gpgme_release(ctx); return 0; } err = gpgme_data_new_from_mem(&plain, msg, strlen(msg), 0); if (err) { goto end; } gpgme_data_new(&cipher); err = gpgme_op_encrypt(ctx, key_arr, GPGME_ENCRYPT_ALWAYS_TRUST, plain, cipher); gpgme_data_release(plain); if (err) { gpgme_data_release(cipher); goto end; } temp = gpgme_data_release_and_get_mem(cipher, &n); if (!temp) { goto end; } str = strndup(temp, n); gpgme_free(temp); if (!str) { goto end; } ret = drop_gpg_headers(str); free(str); end: gpgme_key_unref(key_arr[0]); gpgme_release(ctx); return ret; }
void p_gpg_verify(const char *const barejid, const char *const sign) { if (!sign) { return; } gpgme_ctx_t ctx; gpgme_error_t error = gpgme_new(&ctx); if (error) { log_error("GPG: Failed to create gpgme context. %s %s", gpgme_strsource(error), gpgme_strerror(error)); return; } char *sign_with_header_footer = _add_header_footer(sign, PGP_SIGNATURE_HEADER, PGP_SIGNATURE_FOOTER); gpgme_data_t sign_data; gpgme_data_new_from_mem(&sign_data, sign_with_header_footer, strlen(sign_with_header_footer), 1); free(sign_with_header_footer); gpgme_data_t plain_data; gpgme_data_new(&plain_data); error = gpgme_op_verify(ctx, sign_data, NULL, plain_data); gpgme_data_release(sign_data); gpgme_data_release(plain_data); if (error) { log_error("GPG: Failed to verify. %s %s", gpgme_strsource(error), gpgme_strerror(error)); gpgme_release(ctx); return; } gpgme_verify_result_t result = gpgme_op_verify_result(ctx); if (result) { if (result->signatures) { gpgme_key_t key = NULL; error = gpgme_get_key(ctx, result->signatures->fpr, &key, 0); if (error) { log_debug("Could not find PGP key with ID %s for %s", result->signatures->fpr, barejid); } else { log_debug("Fingerprint found for %s: %s ", barejid, key->subkeys->fpr); ProfPGPPubKeyId *pubkeyid = malloc(sizeof(ProfPGPPubKeyId)); pubkeyid->id = strdup(key->subkeys->keyid); pubkeyid->received = TRUE; g_hash_table_replace(pubkeys, strdup(barejid), pubkeyid); } gpgme_key_unref(key); } } gpgme_release(ctx); }
/* ------------------ * decrypt a plain string with the key found with fingerprint fpr * FREE MEMORY AFTER USAGE OF RETURN VALUE * ------------------ */ static char* decrypt(char* cipher_str) { gpgme_error_t error; gpgme_ctx_t ctx; gpgme_data_t plain,cipher; size_t len = 0; char* plain_str = NULL; char* plain_str_dup = NULL; char* armored_buffer; // add header and footer: armored_buffer = str_armor(cipher_str); // connect to gpgme gpgme_check_version (NULL); error = gpgme_new(&ctx); if (error) { purple_debug_error(PLUGIN_ID,"gpgme_new failed: %s %s\n",gpgme_strsource (error), gpgme_strerror (error)); return NULL; } // create data containers gpgme_data_new_from_mem (&cipher, armored_buffer,strlen(armored_buffer),1); gpgme_data_new(&plain); // decrypt error = gpgme_op_decrypt(ctx,cipher,plain); if (error) { purple_debug_error(PLUGIN_ID,"gpgme_op_decrypt failed: %s %s\n",gpgme_strsource (error), gpgme_strerror (error)); gpgme_release (ctx); return NULL; } // release memory for data containers gpgme_data_release(cipher); plain_str = gpgme_data_release_and_get_mem(plain,&len); if (plain_str != NULL) { plain_str[len] = 0; plain_str_dup = g_strdup(plain_str); } gpgme_free(plain_str); // close gpgme connection gpgme_release (ctx); return plain_str_dup; }
/** * Determine if we have a key is known in our local keyring. * @param handle the context handle * @param fpr the fingerprint key ID to look up * @return 1 if key is known, 0 if key is unknown, -1 on error */ static int key_in_keychain(alpm_handle_t *handle, const char *fpr) { gpgme_error_t err; gpgme_ctx_t ctx; gpgme_key_t key; int ret = -1; memset(&ctx, 0, sizeof(ctx)); err = gpgme_new(&ctx); CHECK_ERR(); _alpm_log(handle, ALPM_LOG_DEBUG, "looking up key %s locally\n", fpr); err = gpgme_get_key(ctx, fpr, &key, 0); if(gpg_err_code(err) == GPG_ERR_EOF) { _alpm_log(handle, ALPM_LOG_DEBUG, "key lookup failed, unknown key\n"); ret = 0; } else if(gpg_err_code(err) == GPG_ERR_NO_ERROR) { _alpm_log(handle, ALPM_LOG_DEBUG, "key lookup success, key exists\n"); ret = 1; } else { _alpm_log(handle, ALPM_LOG_DEBUG, "gpg error: %s\n", gpgme_strerror(err)); } gpgme_key_unref(key); error: gpgme_release(ctx); return ret; }
/* Return a GPGME key object matching PATTERN. If no key matches or the match is ambiguous, return NULL. */ gpgme_key_t op_get_one_key (char *pattern) { gpgme_error_t err; gpgme_ctx_t ctx; gpgme_key_t k, k2; err = gpgme_new (&ctx); if (err) return NULL; /* Error. */ err = gpgme_op_keylist_start (ctx, pattern, 0); if (!err) { err = gpgme_op_keylist_next (ctx, &k); if (!err && !gpgme_op_keylist_next (ctx, &k2)) { /* More than one matching key available. Return an error instead. */ gpgme_key_release (k); gpgme_key_release (k2); k = k2 = NULL; } } gpgme_op_keylist_end (ctx); gpgme_release (ctx); return k; }
gboolean p_gpg_addkey(const char *const jid, const char *const keyid) { gpgme_ctx_t ctx; gpgme_error_t error = gpgme_new(&ctx); if (error) { log_error("GPG: Failed to create gpgme context. %s %s", gpgme_strsource(error), gpgme_strerror(error)); return FALSE; } gpgme_key_t key = NULL; error = gpgme_get_key(ctx, keyid, &key, 0); gpgme_release(ctx); if (error || key == NULL) { log_error("GPG: Failed to get key. %s %s", gpgme_strsource(error), gpgme_strerror(error)); return FALSE; } // save to public key file g_key_file_set_string(pubkeyfile, jid, "keyid", keyid); _save_pubkeys(); // update in memory pubkeys list ProfPGPPubKeyId *pubkeyid = malloc(sizeof(ProfPGPPubKeyId)); pubkeyid->id = strdup(keyid); pubkeyid->received = FALSE; g_hash_table_replace(pubkeys, strdup(jid), pubkeyid); gpgme_key_unref(key); return TRUE; }
static void pygpgme_context_dealloc(PyGpgmeContext *self) { gpgme_passphrase_cb_t passphrase_cb; gpgme_progress_cb_t progress_cb; PyObject *callback; if (self->ctx) { /* free the passphrase callback */ gpgme_get_passphrase_cb(self->ctx, &passphrase_cb, (void **)&callback); if (passphrase_cb == pygpgme_passphrase_cb) { Py_DECREF(callback); } /* free the progress callback */ gpgme_get_progress_cb(self->ctx, &progress_cb, (void **)&callback); if (progress_cb == pygpgme_progress_cb) { Py_DECREF(callback); } gpgme_release(self->ctx); } self->ctx = NULL; PyObject_Del(self); }
/* * create a GpgME context for the passed protocol */ static gpgme_error_t gpgme_new_with_protocol(gpgme_ctx_t * ctx, gpgme_protocol_t protocol, GtkWindow * parent, GError ** error) { gpgme_error_t err; /* create the GpgME context */ if ((err = gpgme_new(ctx)) != GPG_ERR_NO_ERROR) { g_set_error_from_gpgme(error, err, _("could not create context")); } else { if ((err = gpgme_set_protocol(*ctx, protocol)) != GPG_ERR_NO_ERROR) { gchar *errmsg = g_strdup_printf(_("could not set protocol '%s'"), gpgme_get_protocol_name(protocol)); g_set_error_from_gpgme(error, err, errmsg); g_free(errmsg); gpgme_release(*ctx); } else { if (protocol == GPGME_PROTOCOL_OpenPGP) gpgme_set_passphrase_cb(*ctx, gpgme_passphrase_cb, parent); } } return err; }
static void cleanup (FILE *f1, GFile *f2, GFileOutputStream *ostream, gchar *buf, gpgme_key_t *sk, gpgme_ctx_t *ctx) { if (f1 != NULL) { fclose (f1); } if (f2 != NULL) { g_object_unref (f2); } if (ostream != NULL) { g_output_stream_close (G_OUTPUT_STREAM (ostream), NULL, NULL); g_object_unref (ostream); } if (buf != NULL) { g_free (buf); } if (sk != NULL) { gpgme_key_release (*sk); } if (ctx != NULL) { gpgme_release (*ctx); } }
/* Created a detached signature for INDATA and write it to OUTDATA. On termination of the signing command engine_private_finished() is called with FILTER as the first argument. */ int op_gpgme_sign (protocol_t protocol, gpgme_data_t indata, gpgme_data_t outdata, engine_filter_t filter, void *hwnd) { gpg_error_t err; closure_data_t cld; gpgme_ctx_t ctx = NULL; gpgme_key_t sign_key = NULL; (void)hwnd; if (signer_dialog_box (&sign_key, NULL, 0) == -1) { log_debug ("%s:%s: leave (dialog failed)\n", SRCNAME, __func__); return gpg_error (GPG_ERR_CANCELED); } cld = xcalloc (1, sizeof *cld); cld->closure = sign_closure; cld->filter = filter; err = gpgme_new (&ctx); if (err) goto leave; gpgme_set_progress_cb (ctx, NULL, cld); switch (protocol) { case PROTOCOL_OPENPGP: /* Gpgme's default. */ break; case PROTOCOL_SMIME: err = gpgme_set_protocol (ctx, GPGME_PROTOCOL_CMS); break; default: err = gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL); break; } if (err) goto leave; gpgme_set_armor (ctx, 1); gpgme_set_passphrase_cb (ctx, passphrase_callback_box, &cld->pw_cb); cld->pw_cb.ctx = ctx; cld->pw_cb.ttl = opt.passwd_ttl; err = gpgme_signers_add (ctx, sign_key); if (!err) err = gpgme_op_sign_start (ctx, indata, outdata, GPGME_SIG_MODE_DETACH); leave: if (err) { xfree (cld); gpgme_release (ctx); } else engine_private_set_cancel (filter, ctx); gpgme_key_unref (sign_key); return err; }
void GPGWrapper::deinit() { if (!initialized) return; gpgme_signers_clear(context); gpgme_release(context); }
void signatures_done(void) { #ifdef HAVE_LIBGPGME if (context != NULL) { gpgme_release(context); context = NULL; } #endif /* HAVE_LIBGPGME */ }
CGPGHelper::~CGPGHelper() { #ifdef HAVE_LIBGPGME if (mCtx) gpgme_release(mCtx); #endif if (mGPGPassphrase) free(mGPGPassphrase); mKeysIni.CloseFile(); }
/* ------------------ * verify a signed string with the key found with fingerprint fpr * FREE MEMORY AFTER USAGE OF RETURN VALUE! * ------------------ */ static char* verify(const char* sig_str) { gpgme_error_t error; gpgme_ctx_t ctx; gpgme_data_t plain,sig,sig_text; gpgme_verify_result_t result; char* fpr = NULL; char* armored_sig_str = NULL; if (sig_str == NULL) { purple_debug_error(PLUGIN_ID,"verify got null parameter\n"); return NULL; } // connect to gpgme gpgme_check_version (NULL); error = gpgme_new(&ctx); if (error) { purple_debug_error(PLUGIN_ID,"gpgme_new failed: %s %s\n",gpgme_strsource (error), gpgme_strerror (error)); return NULL; } // armor sig_str armored_sig_str = str_armor(sig_str); // create data containers gpgme_data_new_from_mem (&sig, armored_sig_str,strlen(armored_sig_str),1); gpgme_data_new(&plain); // try to verify error = gpgme_op_verify(ctx,sig,NULL,plain); if (error) { purple_debug_error(PLUGIN_ID,"gpgme_op_verify failed: %s %s\n",gpgme_strsource (error), gpgme_strerror (error)); gpgme_release (ctx); return NULL; } // get result result = gpgme_op_verify_result (ctx); if (result != NULL) { if (result->signatures != NULL) { // return the fingerprint of the key that made the signature fpr = g_strdup(result->signatures->fpr); } } // release memory for data containers gpgme_data_release(sig); gpgme_data_release(plain); return fpr; }
/* Decrypt data from INDATA to OUTDATE. If WITH_VERIFY is set, a signature of PGP/MIME combined message is also verified the same way as with op_gpgme_verify. */ int op_gpgme_decrypt (protocol_t protocol, gpgme_data_t indata, gpgme_data_t outdata, engine_filter_t filter, void *hwnd, int with_verify) { gpgme_error_t err; closure_data_t cld; gpgme_ctx_t ctx = NULL; (void)hwnd; cld = xcalloc (1, sizeof *cld); cld->closure = decrypt_closure; cld->filter = filter; cld->with_verify = with_verify; err = gpgme_new (&ctx); if (err) goto leave; gpgme_set_progress_cb (ctx, NULL, cld); switch (protocol) { case PROTOCOL_OPENPGP: /* Gpgme's default. */ break; case PROTOCOL_SMIME: err = gpgme_set_protocol (ctx, GPGME_PROTOCOL_CMS); break; default: err = gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL); break; } if (err) goto leave; /* Note: We do no error checking for the next call because some backends may not implement a command hanler at all. */ gpgme_set_passphrase_cb (ctx, passphrase_callback_box, &cld->pw_cb); cld->pw_cb.ctx = ctx; if (with_verify) err = gpgme_op_decrypt_verify_start (ctx, indata, outdata); else err = gpgme_op_decrypt_start (ctx, indata, outdata); leave: if (err) { xfree (cld); gpgme_release (ctx); } else engine_private_set_cancel (filter, ctx); return err; }
static gpgme_key_t prompt_signer () { gpgme_error_t gerr = 0; CryptUIKeyset *keyset; CryptUIKeyStore *ckstore; gpgme_key_t key = NULL; gpgme_ctx_t ctx = NULL; gchar *signer; gchar *id; guint count; GList *keys; keyset = cryptui_keyset_new ("openpgp", TRUE); ckstore = cryptui_key_store_new (keyset, TRUE, NULL); cryptui_key_store_set_filter (ckstore, signer_filter, NULL); count = cryptui_key_store_get_count (ckstore); if (count == 0) { cryptui_need_to_get_keys (); return NULL; } else if (count == 1) { keys = cryptui_key_store_get_all_keys (ckstore); signer = (gchar*) keys->data; g_list_free (keys); } else { signer = cryptui_prompt_signer (keyset, _("Choose Signer")); } if (signer) { id = cryptui_keyset_key_raw_keyid (keyset, signer); g_free (signer); gpgme_check_version (NULL); gerr = gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP); g_return_val_if_fail (gerr == 0, NULL); gerr = gpgme_new (&ctx); g_return_val_if_fail (gerr == 0, NULL); /* Load up the GPGME secret key */ gerr = gpgme_get_key (ctx, id, &key, 1); g_free (id); gpgme_release (ctx); if (gerr != 0) seahorse_util_handle_gpgme (gerr, _("Couldn't load keys")); } g_object_unref (ckstore); g_object_unref (keyset); return key; }
static void fu_keyring_finalize (GObject *object) { FuKeyring *keyring = FU_KEYRING (object); FuKeyringPrivate *priv = GET_PRIVATE (keyring); if (priv->ctx != NULL) gpgme_release (priv->ctx); G_OBJECT_CLASS (fu_keyring_parent_class)->finalize (object); }
/* ------------------ * import ascii armored key * ------------------ */ int import_key(char* armored_key) { gpgme_error_t error; gpgme_ctx_t ctx; gpgme_data_t keydata; gpgme_import_result_t result; // connect to gpgme gpgme_check_version (NULL); error = gpgme_new(&ctx); if (error) { purple_debug_error(PLUGIN_ID,"gpgme_new failed: %s %s\n",gpgme_strsource (error), gpgme_strerror (error)); return FALSE; } purple_debug_info(PLUGIN_ID,"try to import key: %s\n",armored_key); // create data containers gpgme_data_new_from_mem (&keydata, armored_key,strlen(armored_key),1); // import key, ascii armored gpgme_set_armor(ctx,1); error = gpgme_op_import (ctx, keydata); if (error) { purple_debug_error(PLUGIN_ID,"gpgme_op_import: %s %s\n",gpgme_strsource (error), gpgme_strerror (error)); gpgme_release (ctx); return FALSE; } result = gpgme_op_import_result (ctx); purple_debug_info(PLUGIN_ID,"considered keys: %d; imported keys: %d; not imported keys: %d\n",result->considered,result->imported,result->not_imported); // release memory for data containers gpgme_data_release(keydata); // close gpgme connection gpgme_release (ctx); return TRUE; }
/* Verify a detached message where the data is in the gpgme object DATA and the signature given as the string SIGNATUEE. */ int op_gpgme_verify (gpgme_protocol_t protocol, gpgme_data_t data, const char *signature, size_t sig_len, engine_filter_t filter, void *hwnd) { gpgme_error_t err; closure_data_t cld; gpgme_ctx_t ctx = NULL; gpgme_data_t sigobj = NULL; (void)hwnd; cld = xcalloc (1, sizeof *cld); cld->closure = verify_closure; cld->filter = filter; err = gpgme_new (&ctx); if (err) goto leave; gpgme_set_progress_cb (ctx, NULL, cld); switch (protocol) { case PROTOCOL_OPENPGP: /* Gpgme's default. */ break; case PROTOCOL_SMIME: err = gpgme_set_protocol (ctx, GPGME_PROTOCOL_CMS); break; default: err = gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL); break; } if (err) goto leave; err = gpgme_data_new_from_mem (&sigobj, signature, sig_len, 0); if (err) goto leave; cld->sigobj = sigobj; err = gpgme_op_verify_start (ctx, sigobj, data, NULL); leave: if (err) { gpgme_data_release (sigobj); xfree (cld); gpgme_release (ctx); } else engine_private_set_cancel (filter, ctx); return err; }
int main (int argc, char *argv[]) { gpgme_ctx_t ctx; gpgme_error_t err; gpgme_data_t in, out; gpgme_verify_result_t result; char *agent_info; int i; init_gpgme (GPGME_PROTOCOL_OpenPGP); err = gpgme_new (&ctx); fail_if_err (err); agent_info = getenv ("GPG_AGENT_INFO"); if (!(agent_info && strchr (agent_info, ':'))) gpgme_set_passphrase_cb (ctx, passphrase_cb, NULL); err = gpgme_data_new_from_mem (&in, "Hallo Leute\n", 12, 0); fail_if_err (err); err = gpgme_data_new (&out); fail_if_err (err); for (i = 0; i < sizeof (expected_notations) / sizeof (expected_notations[0]); i++) { err = gpgme_sig_notation_add (ctx, expected_notations[i].name, expected_notations[i].value, expected_notations[i].flags); fail_if_err (err); } err = gpgme_op_sign (ctx, in, out, GPGME_SIG_MODE_NORMAL); fail_if_err (err); gpgme_data_release (in); err = gpgme_data_new (&in); fail_if_err (err); gpgme_data_seek (out, 0, SEEK_SET); err = gpgme_op_verify (ctx, out, NULL, in); fail_if_err (err); result = gpgme_op_verify_result (ctx); check_result (result); gpgme_data_release (in); gpgme_data_release (out); gpgme_release (ctx); return 0; }
static void ostree_gpg_verify_result_finalize (GObject *object) { OstreeGpgVerifyResult *result = OSTREE_GPG_VERIFY_RESULT (object); if (result->context != NULL) gpgme_release (result->context); if (result->details != NULL) gpgme_result_unref (result->details); G_OBJECT_CLASS (ostree_gpg_verify_result_parent_class)->finalize (object); }
/** * gpgmegtk_recipient_selection: * @recp_names: A list of email addresses * * Select a list of recipients from a given list of email addresses. * This may pop up a window to present the user a choice, it will also * check that the recipients key are all valid. * * Return value: NULL on error or a list of list of recipients. **/ gpgme_key_t * gpgmegtk_recipient_selection (GSList *recp_names, SelectionResult *result, gpgme_protocol_t proto) { struct select_keys_s sk; gpgme_key_t key = NULL; memset (&sk, 0, sizeof sk); open_dialog (&sk); do { sk.pattern = recp_names? recp_names->data:NULL; sk.proto = proto; gtk_cmclist_clear (sk.clist); key = fill_clist (&sk, sk.pattern, proto); update_progress (&sk, 0, sk.pattern ? sk.pattern : "NULL"); if (!key) { gtk_widget_show_all (sk.window); gtk_main (); } else { gtk_widget_hide (sk.window); sk.kset = g_realloc(sk.kset, sizeof(gpgme_key_t) * (sk.num_keys + 1)); gpgme_key_ref(key); sk.kset[sk.num_keys] = key; sk.num_keys++; sk.okay = 1; sk.result = KEY_SELECTION_OK; gpgme_release (sk.select_ctx); sk.select_ctx = NULL; debug_print("used %s\n", key->uids->email); } key = NULL; if (recp_names) recp_names = recp_names->next; } while (sk.okay && recp_names); close_dialog (&sk); if (!sk.okay) { g_free(sk.kset); sk.kset = NULL; } else { sk.kset = g_realloc(sk.kset, sizeof(gpgme_key_t) * (sk.num_keys + 1)); sk.kset[sk.num_keys] = NULL; } if (result) *result = sk.result; return sk.kset; }
static void g_mime_pkcs7_context_finalize (GObject *object) { GMimePkcs7Context *ctx = (GMimePkcs7Context *) object; #ifdef ENABLE_SMIME if (ctx->priv->ctx) gpgme_release (ctx->priv->ctx); #endif g_slice_free (Pkcs7Ctx, ctx->priv); G_OBJECT_CLASS (parent_class)->finalize (object); }