/* #############################################################################
*
* Description initialize the GPGME library
* Author Harry Brueckner
* Date 2005-03-30
* Arguments void
* Return void
*/
void initGPG(void)
{
gpgme_error_t error;
gpgme_check_version(NULL);
TRACE(99, "initGPG()", NULL);
error = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
if (error)
{
gpgError(error);
exit(1);
}
if (!gpgme_check_version(GPG_VERSION_MINIMUM))
{
fprintf(stderr, _("GpgMe error: invalid library version (%s).\n"),
gpgme_check_version(NULL));
exit(1);
}
retries = 0;
signers = 0;
lastrealm = NULL;
}
void GPGWrapper::init()
{
if (initialized)
return;
initialized = true;
gpgme_check_version(NULL);
setlocale(LC_ALL, "");
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
#ifdef LC_MESSAGES
gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
#endif
gpgme_error_t error = gpgme_new(&context);
fail_if_err(error, L"Nie uda³o siê zainicjowaæ kontekstu GPG.");
gpgme_set_textmode(context, 1);
gpgme_set_armor(context, 1);
error = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
fail_if_err(error, L"Nie zainstalowano OpenPGP.");
error = gpgme_set_protocol(context, GPGME_PROTOCOL_OpenPGP);
fail_if_err(error, L"Nie uda³o siê ustawiæ OpenPGP.");
privateKey = getPrivateKey(privateKeyId.c_str());
error = gpgme_signers_add(context, privateKey);
fail_if_err(error, L"Nie uda³o siê ustawiæ klucza prywatnego.");
}
/* First part of the gpgme initialization. This is sufficient if we
only use the gpgme_data_t stuff. */
int
op_gpgme_basic_init (void)
{
if (basic_init_done)
return 0;
if (!gpgme_check_version (NEED_GPGME_VERSION))
{
log_debug ("gpgme is too old (need %s, have %s)\n",
NEED_GPGME_VERSION, gpgme_check_version (NULL) );
return gpg_error (GPG_ERR_GENERAL);
}
basic_init_done = 1;
return 0;
}
int
main (int argc, char **argv )
{
gpgme_engine_info_t info;
gpgme_error_t err;
gpgme_check_version (NULL);
err = gpgme_get_engine_info (&info);
fail_if_err (err);
check_engine_info (info, GPGME_PROTOCOL_OpenPGP, GPG_PATH, NEED_GPG_VERSION);
info = info->next;
#ifdef GPGSM_PATH
check_engine_info (info, GPGME_PROTOCOL_CMS, GPGSM_PATH, NEED_GPGSM_VERSION);
#else
if (info)
{
fprintf (stderr, "Unexpected engine info.\n");
exit (1);
}
#endif
return 0;
}
CryptPlugWrapper::Config::Config(gpgme_protocol_t proto)
{
signatureAlgorithm = SignAlg_SHA1;
if(proto == GPGME_PROTOCOL_CMS)
signatureCompoundMode = SignatureCompoundMode_Opaque;
else
signatureCompoundMode = SignatureCompoundMode_Detached;
sendCertificates = SendCert_SendChainWithRoot;
saveSentSignatures = true;
warnNoCertificate = true;
signatureUseCRLs = true;
encryptionAlgorithm = EncryptAlg_RSA;
encryptEmail = EncryptEmail_Ask;
saveMessagesEncrypted = true;
encryptionUseCRLs = true;
encryptionCRLExpiryNearWarning = false;
encryptionCRLNearExpiryInterval = NEAR_EXPIRY;
certificateSource = CertSrc_Server;
warnSendUnsigned = true;
signatureCertificateExpiryNearWarning = true;
signatureCertificateExpiryNearInterval = NEAR_EXPIRY;
cACertificateExpiryNearWarning = true;
cACertificateExpiryNearInterval = NEAR_EXPIRY;
rootCertificateExpiryNearWarning = true;
rootCertificateExpiryNearInterval = NEAR_EXPIRY;
warnSendUnencrypted = false;
checkCertificatePath = true;
receiverCertificateExpiryNearWarning = true;
receiverCertificateExpiryNearWarningInterval = NEAR_EXPIRY;
certificateInChainExpiryNearWarning = true;
certificateInChainExpiryNearWarningInterval = NEAR_EXPIRY;
receiverEmailAddressNotInCertificateWarning = true;
libVersion = gpgme_check_version(NULL);
}
/**
* Initialize the GPGME library.
* This can be safely called multiple times; however it is not thread-safe.
* @param handle the context handle
* @return 0 on success, -1 on error
*/
static int init_gpgme(alpm_handle_t *handle)
{
static int init = 0;
const char *version, *sigdir;
gpgme_error_t gpg_err;
gpgme_engine_info_t enginfo;
if(init) {
/* we already successfully initialized the library */
return 0;
}
sigdir = handle->gpgdir;
if(_alpm_access(handle, sigdir, "pubring.gpg", R_OK)
|| _alpm_access(handle, sigdir, "trustdb.gpg", R_OK)) {
handle->pm_errno = ALPM_ERR_NOT_A_FILE;
_alpm_log(handle, ALPM_LOG_DEBUG, "Signature verification will fail!\n");
_alpm_log(handle, ALPM_LOG_WARNING,
_("Public keyring not found; have you run '%s'?\n"),
"pacman-key --init");
}
/* calling gpgme_check_version() returns the current version and runs
* some internal library setup code */
version = gpgme_check_version(NULL);
_alpm_log(handle, ALPM_LOG_DEBUG, "GPGME version: %s\n", version);
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
#ifdef LC_MESSAGES
gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
#endif
/* NOTE:
* The GPGME library installs a SIGPIPE signal handler automatically if
* the default signal hander is in use. The only time we set a handler
* for SIGPIPE is in dload.c, and we reset it when we are done. Given that
* we do this, we can let GPGME do its automagic. However, if we install
* a library-wide SIGPIPE handler, we will have to be careful.
*/
/* check for OpenPGP support (should be a no-brainer, but be safe) */
gpg_err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
CHECK_ERR();
/* set and check engine information */
gpg_err = gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP, NULL, sigdir);
CHECK_ERR();
gpg_err = gpgme_get_engine_info(&enginfo);
CHECK_ERR();
_alpm_log(handle, ALPM_LOG_DEBUG, "GPGME engine info: file=%s, home=%s\n",
enginfo->file_name, enginfo->home_dir);
init = 1;
return 0;
gpg_error:
_alpm_log(handle, ALPM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(gpg_err));
RET_ERR(handle, ALPM_ERR_GPGME, -1);
}
/* ------------------
* 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;
}
/* ------------------
* 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;
}
/* ------------------
* 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 checkSignature(char *path, struct memory_identifier *memory)
{
gpgme_ctx_t context;
gpgme_error_t err;
gpgme_data_t signature, iso;
FILE *file = fopen(path, "r");
if (file == NULL) {
fprintf(stderr, "File %s not found!\n", path);
fatal("Unable to open file!\n");
}
gpgme_check_version(NULL);
err = gpgme_new(&context);
switch (err) {
case GPG_ERR_NO_ERROR:
break;
case GPG_ERR_ENOMEM:
fatal("There is not enough memory available to initialize gpgme. Aborting...\n");
default:
break;
}
gpgme_set_protocol(context, GPGME_PROTOCOL_OpenPGP);
err = gpgme_data_new_from_stream(&iso, file);
if (err == GPG_ERR_ENOMEM)
fatal("There was not enough memory to crate a new data buffer for gpgme. Aborting...\n");
err = gpgme_ctx_set_engine_info(context, GPGME_PROTOCOL_OpenPGP, "/usr/bin/gpg",
"/etc/pacman.d/gnupg/");
if (err != GPG_ERR_NO_ERROR) {
printf("Something went wrong while setting the engine info.\n");
return 1;
}
err = gpgme_data_new_from_mem(&signature, memory->chunk, memory->length, 1);
if (err == GPG_ERR_ENOMEM)
fatal("There was not enough memory to crate a new data buffer for gpgme. Aborting...\n");
err = gpgme_op_verify(context, signature, iso, NULL);
if (err == GPG_ERR_NO_ERROR)
return 0;
else
return 1;
}
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
init_gpgme ()
{
setlocale (LC_ALL, "");
gpgme_check_version (NULL);
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
#ifdef LC_MESSAGES
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
}
c_gpgme::c_gpgme() {
setlocale (LC_ALL, "");
gpgme_set_locale(nullptr, LC_CTYPE, setlocale (LC_CTYPE, nullptr));
gpgme_check_version(nullptr);
m_error_code = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
m_error_code = gpgme_new(&m_ctx);
assert(m_ctx != nullptr);
#ifdef __CYGWIN__
m_error_code = gpgme_ctx_set_engine_info (m_ctx, GPGME_PROTOCOL_OpenPGP,
"./gpg.exe", nullptr);
#endif
}
static gpgme_error_t geanypg_init_gpgme(void)
{
/* Initialize the locale environment. */
setlocale(LC_ALL, "");
fprintf(stderr, "GeanyPG: %s %s\n", _("Using libgpgme version:"),
gpgme_check_version("1.1.0"));
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
#ifdef LC_MESSAGES /* only necessary for portability to W32 systems */
gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
#endif
return gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
}
/* ------------------
* 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;
}
/* ------------------
* preferences dialog function
* ------------------ */
static PurplePluginPrefFrame *
get_plugin_pref_frame(PurplePlugin *plugin) {
PurplePluginPrefFrame *frame;
PurplePluginPref *ppref;
gpgme_error_t error;
gpgme_ctx_t ctx;
gpgme_key_t key;
// create preferences frame
frame = purple_plugin_pref_frame_new();
// 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 key chooser preference
ppref = purple_plugin_pref_new_with_name_and_label(PREF_MY_KEY,"My key");
purple_plugin_pref_set_type(ppref, PURPLE_PLUGIN_PREF_CHOICE);
purple_plugin_pref_add_choice(ppref, "None", "");
// list keys (secret keys)
error = gpgme_op_keylist_start (ctx,NULL,1);
if (error == GPG_ERR_NO_ERROR)
{
while (!error)
{
error = gpgme_op_keylist_next (ctx, &key);
if (error) break;
// add key to preference chooser
//TODO: find something better for g_strdup, or some possibility to free memory after preferences dialog closed
purple_plugin_pref_add_choice(ppref, g_strdup(key->uids->uid), g_strdup(key->subkeys->fpr));
purple_debug_info(PLUGIN_ID,"Found secret key for: %s has fpr %s\n",key->uids->uid,key->subkeys->fpr);
gpgme_key_release (key);
}
}else
{
purple_debug_error(PLUGIN_ID,"gpgme_op_keylist_start failed: %s %s\n",gpgme_strsource (error), gpgme_strerror (error));
}
// close gpgme connection
gpgme_release (ctx);
purple_plugin_pref_frame_add(frame, ppref);
return frame;
}
int
main (int argc, char **argv )
{
gpgme_check_version (NULL);
setlocale (LC_ALL, "");
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
#ifndef HAVE_W32_SYSTEM
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
print_gpgconf_string ("gpg", "group");
return 0;
}
static int init_gpgme(alpm_handle_t *handle)
{
static int init = 0;
const char *version, *sigdir;
gpgme_error_t err;
gpgme_engine_info_t enginfo;
if(init) {
/* we already successfully initialized the library */
return 0;
}
sigdir = alpm_option_get_gpgdir(handle);
/* calling gpgme_check_version() returns the current version and runs
* some internal library setup code */
version = gpgme_check_version(NULL);
_alpm_log(handle, ALPM_LOG_DEBUG, "GPGME version: %s\n", version);
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
#ifdef LC_MESSAGES
gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
#endif
/* NOTE:
* The GPGME library installs a SIGPIPE signal handler automatically if
* the default signal hander is in use. The only time we set a handler
* for SIGPIPE is in dload.c, and we reset it when we are done. Given that
* we do this, we can let GPGME do its automagic. However, if we install
* a library-wide SIGPIPE handler, we will have to be careful.
*/
/* check for OpenPGP support (should be a no-brainer, but be safe) */
err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
CHECK_ERR();
/* set and check engine information */
err = gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP, NULL, sigdir);
CHECK_ERR();
err = gpgme_get_engine_info(&enginfo);
CHECK_ERR();
_alpm_log(handle, ALPM_LOG_DEBUG, "GPGME engine info: file=%s, home=%s\n",
enginfo->file_name, enginfo->home_dir);
init = 1;
return 0;
error:
_alpm_log(handle, ALPM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(err));
RET_ERR(handle, ALPM_ERR_GPGME, 1);
}
/* ------------------
* initialize gpgme lib on module load
* ------------------ */
static void init_gpgme ()
{
const char* version;
/* Initialize the locale environment. */
setlocale (LC_ALL, "");
version = gpgme_check_version (NULL);
purple_debug_info(PLUGIN_ID,"Found gpgme version: %s\n",version);
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
// For W32 portability.
#ifdef LC_MESSAGES
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
}
gboolean init_gpgme() {
gpgme_error_t err;
gpgme_check_version(NULL);
setlocale(LC_ALL, "");
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
if (err) {
return FALSE;
}
return TRUE;
}
void
init_gpgme (gpgme_protocol_t proto)
{
gpgme_error_t err;
gpgme_check_version (NULL);
setlocale (LC_ALL, "");
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
#ifndef HAVE_W32_SYSTEM
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
err = gpgme_engine_check_version (proto);
fail_if_err (err);
}
void KGpgMe::init(gpgme_protocol_t proto)
{
gpgme_error_t err;
gpgme_check_version(NULL);
setlocale(LC_ALL, "");
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
err = gpgme_engine_check_version(proto);
if(err) {
KMessageBox::error(kapp->activeWindow(), QString("%1: %2")
.arg(gpgme_strsource(err)).arg(gpgme_strerror(err)));
}
}
void
p_gpg_init(void)
{
libversion = gpgme_check_version(NULL);
log_debug("GPG: Found gpgme version: %s", libversion);
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
pubkeys = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)_p_gpg_free_pubkeyid);
key_ac = autocomplete_new();
GHashTable *keys = p_gpg_list_keys();
p_gpg_free_keys(keys);
passphrase = NULL;
passphrase_attempt = NULL;
}
int
init_gpgme(fko_ctx_t fko_ctx)
{
gpgme_error_t err;
/* If we already have a context, we are done.
*/
if(fko_ctx->have_gpgme_context)
return(FKO_SUCCESS);
/* Because the gpgme manual says you should.
*/
gpgme_check_version(NULL);
/* Check for OpenPGP support
*/
err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
if(gpg_err_code(err) != GPG_ERR_NO_ERROR)
{
/* GPG engine is not available.
*/
fko_ctx->gpg_err = err;
return(FKO_ERROR_GPGME_NO_OPENPGP);
}
/* Extract the current gpgme engine information.
*/
gpgme_set_engine_info(
GPGME_PROTOCOL_OpenPGP,
(fko_ctx->gpg_exe != NULL) ? fko_ctx->gpg_exe : GPG_EXE,
fko_ctx->gpg_home_dir /* If this is NULL, the default is used */
);
/* Create our gpgme context
*/
err = gpgme_new(&(fko_ctx->gpg_ctx));
if(gpg_err_code(err) != GPG_ERR_NO_ERROR)
{
fko_ctx->gpg_err = err;
return(FKO_ERROR_GPGME_CONTEXT);
}
fko_ctx->have_gpgme_context = 1;
return(FKO_SUCCESS);
}
int setup(gpgme_ctx_t* ctx)
{
char *p;
gpgme_error_t err;
gpgme_engine_info_t enginfo;
setlocale (LC_ALL, "");
p = (char *) gpgme_check_version(NULL);
printf("version=%s\n",p);
/* set locale, because tests do also */
gpgme_set_locale(NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
/* check for OpenPGP support */
err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
if(err != GPG_ERR_NO_ERROR) return 1;
p = (char *) gpgme_get_protocol_name(GPGME_PROTOCOL_OpenPGP);
printf("Protocol name: %s\n",p);
/* get engine information */
err = gpgme_get_engine_info(&enginfo);
if(err != GPG_ERR_NO_ERROR) return 2;
printf("file=%s, home=%s\n",enginfo->file_name,enginfo->home_dir);
/* create our own context */
err = gpgme_new(ctx);
if(err != GPG_ERR_NO_ERROR) return 3;
/* set protocol to use in our context */
err = gpgme_set_protocol(*ctx,GPGME_PROTOCOL_OpenPGP);
if(err != GPG_ERR_NO_ERROR) return 4;
/* set engine info in our context; I changed it for ceof like this:
err = gpgme_ctx_set_engine_info (*ctx, GPGME_PROTOCOL_OpenPGP,
"/usr/bin/gpg","/home/user/nico/.ceof/gpg/");
but I'll use standard values for this example: */
err = gpgme_ctx_set_engine_info (*ctx, GPGME_PROTOCOL_OpenPGP,
enginfo->file_name,enginfo->home_dir);
if(err != GPG_ERR_NO_ERROR) return 5;
return 0;
}
void setup(gpgme_ctx_t * context, telem_gpg_opts * options) {
gpgme_error_t error;
// gpgme_engine_info_t info;
// Set the defaults
setup_options(options);
/* Initializes gpgme */
gpgme_check_version (NULL);
/* Initialize the locale environment. */
setlocale (LC_ALL, "");
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
#ifdef LC_MESSAGES
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
error = gpgme_new(context);
fail_if_err(error);
/* Setting the output type must be done at the beginning */
gpgme_set_armor(*context, 1);
/* Check OpenPGP */
// error = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
// fail_if_err(error);
// error = gpgme_get_engine_info (&info);
// fail_if_err(error);
// while (info && info->protocol != gpgme_get_protocol(*context)) {
// info = info->next;
// }
// /* TODO: we should test there *is* a suitable protocol */
// fprintf (stderr, "Engine OpenPGP %s is installed at %s\n", info->version,
// info->file_name); /* And not "path" as the documentation says */
// Create the keyring_dir is it doesnt exist
mkdirs(options->keyring_dir);
/* Initializes the context */
error = gpgme_ctx_set_engine_info(
*context,
GPGME_PROTOCOL_OpenPGP,
NULL,
options->keyring_dir
);
fail_if_err(error);
}
/* ------------------
* 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;
}
void CGPGHelper::Start()
{
#ifdef HAVE_LIBGPGME
char buf[MAX_LINE_LEN];
snprintf(buf, MAX_LINE_LEN, "%s/licq_gpg.conf", BASE_DIR);
mKeysIni.LoadFile(buf);
mKeysIni.SetSection("gpg");
mKeysIni.ReadStr("passphrase", buf); mGPGPassphrase = strdup(buf);
const char *gpgme_ver = gpgme_check_version(0);
gLog.Info("%s[GPG] gpgme library found: %s\n", L_INITxSTR, gpgme_ver);
if (gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP) != GPG_ERR_NO_ERROR)
gLog.Error("%s[GPG] gpgme engine OpenPGP not found!\n", L_ERRORxSTR);
gpgme_new(&mCtx);
gpgme_set_protocol(mCtx, GPGME_PROTOCOL_OpenPGP);
gpgme_set_armor(mCtx, 1);
gpgme_set_passphrase_cb(mCtx, PassphraseCallback, 0);
#endif
}
retvalue signature_init(bool allowpassphrase){
#ifdef HAVE_LIBGPGME
gpg_error_t err;
if (context != NULL)
return RET_NOTHING;
gpgme_check_version(NULL);
err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
if (err != 0)
return gpgerror(err);
err = gpgme_new(&context);
if (err != 0)
return gpgerror(err);
err = gpgme_set_protocol(context, GPGME_PROTOCOL_OpenPGP);
if (err != 0)
return gpgerror(err);
if (allowpassphrase)
gpgme_set_passphrase_cb(context, signature_getpassphrase,
NULL);
gpgme_set_armor(context, 1);
#endif /* HAVE_LIBGPGME */
return RET_OK;
}
int
main (int argc, char **argv)
{
gpgme_error_t err;
gpgme_error_t op_err;
gpgme_ctx_t ctx;
const char *command;
gpgme_check_version (NULL);
#ifndef HAVE_W32_SYSTEM
setlocale (LC_ALL, "");
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
if (argc)
{
argc--;
argv++;
}
command = argc? *argv : "NOP";
err = gpgme_new (&ctx);
fail_if_err (err);
err = gpgme_set_protocol (ctx, GPGME_PROTOCOL_ASSUAN);
fail_if_err (err);
err = gpgme_op_assuan_transact_ext (ctx, command, data_cb, NULL,
inq_cb, NULL, status_cb, NULL, &op_err);
fail_if_err (err || op_err);
gpgme_release (ctx);
return 0;
}
