Struct gpgme::context::Context

#[must_use]
pub struct Context(_);

A context for cryptographic operations

Methods

impl Context

pub unsafe fn from_raw(raw: gpgme_ctx_t) -> Self

pub fn as_raw(&self) -> gpgme_ctx_t

pub fn into_raw(self) -> gpgme_ctx_t

pub fn from_protocol(proto: Protocol) -> Result<Self>

pub fn protocol(&self) -> Protocol

pub fn armor(&self) -> bool

pub fn set_armor(&mut self, enabled: bool)

pub fn text_mode(&self) -> bool

pub fn set_text_mode(&mut self, enabled: bool)

pub fn offline(&self) -> bool

pub fn set_offline(&mut self, enabled: bool)

pub fn get_flag(
    &self,
    name: impl CStrArgument
) -> Result<&str, Option<Utf8Error>>

pub fn get_flag_raw(&self, name: impl CStrArgument) -> Option<&CStr>

pub fn set_flag(
    &mut self,
    name: impl CStrArgument,
    value: impl CStrArgument
) -> Result<()>

pub fn engine_info(&self) -> EngineInfo

pub fn set_engine_path(&mut self, path: impl CStrArgument) -> Result<()>

pub fn set_engine_home_dir(&mut self, home_dir: impl CStrArgument) -> Result<()>

pub fn set_engine_info(
    &mut self,
    path: Option<impl CStrArgument>,
    home_dir: Option<impl CStrArgument>
) -> Result<()>

pub fn pinentry_mode(&self) -> PinentryMode

pub fn set_pinentry_mode(&mut self, mode: PinentryMode) -> Result<()>

pub fn with_passphrase_provider<R, P>(
    &mut self,
    provider: P,
    f: impl FnOnce(&mut Context) -> R
) -> R where
    P: PassphraseProvider, 

Uses the specified provider to handle passphrase requests for the duration of the closure.

Examples

use std::io::prelude::*;

use gpgme::{Context, PassphraseRequest, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp).unwrap();
ctx.with_passphrase_provider(|_: PassphraseRequest, out: &mut Write| {
    out.write_all(b"some passphrase")?;
    Ok(())
}, |mut ctx| {
    // Do something with ctx requiring a passphrase, for example decryption
});

pub fn with_progress_handler<R, H>(
    &mut self,
    handler: H,
    f: impl FnOnce(&mut Context) -> R
) -> R where
    H: ProgressHandler, 

pub fn with_status_handler<R, H>(
    &mut self,
    handler: H,
    f: impl FnOnce(&mut Context) -> R
) -> R where
    H: StatusHandler, 

pub fn find_trust_items(
    &mut self,
    pattern: impl CStrArgument,
    max_level: i32
) -> Result<TrustItems>

pub fn key_list_mode(&self) -> KeyListMode

pub fn add_key_list_mode(&mut self, mask: KeyListMode) -> Result<()>

pub fn set_key_list_mode(&mut self, mode: KeyListMode) -> Result<()>

pub fn keys(&mut self) -> Result<Keys>

pub fn secret_keys(&mut self) -> Result<Keys>

pub fn refresh_key(&mut self, key: &Key) -> Result<Key>

pub fn get_key(&mut self, fpr: impl CStrArgument) -> Result<Key>

Returns the public key with the specified fingerprint, if such a key can be found. Otherwise, an error is returned.

pub fn get_secret_key(&mut self, fpr: impl CStrArgument) -> Result<Key>

Returns the secret key with the specified fingerprint, if such a key can be found. Otherwise, an error is returned.

pub fn find_key(&mut self, fpr: impl CStrArgument) -> Result<Key>

Deprecated since 0.8.0:

use get_key instead

pub fn find_secret_key(&mut self, fpr: impl CStrArgument) -> Result<Key>

Deprecated since 0.8.0:

use get_secret_key instead

pub fn find_keys<I>(&mut self, patterns: I) -> Result<Keys> where
    I: IntoIterator,
    I::Item: CStrArgument, 

Returns an iterator for a list of all public keys matching one or more of the specified patterns.

pub fn find_secret_keys<I>(&mut self, patterns: I) -> Result<Keys> where
    I: IntoIterator,
    I::Item: CStrArgument, 

Returns an iterator for a list of all secret keys matching one or more of the specified patterns.

pub fn read_keys<'d, D>(&mut self, src: D) -> Result<Keys<D::Output>> where
    D: IntoData<'d>, 

Returns an iterator over the keys encoded in the specified source.

Examples

use gpgme::{Context, Data, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp).unwrap();
let mut keyring = Data::load("somefile").unwrap();
for key in ctx.read_keys(&mut keyring).unwrap() {
    println!("{:?}", key);
}

pub fn generate_key<'d1, 'd2, D1, D2>(
    &mut self,
    params: impl CStrArgument,
    public: Option<D1>,
    secret: Option<D2>
) -> Result<KeyGenerationResult> where
    D1: IntoData<'d1>,
    D2: IntoData<'d2>, 

pub fn create_key(
    &mut self,
    userid: impl CStrArgument,
    algo: impl CStrArgument,
    expires: Option<SystemTime>
) -> Result<KeyGenerationResult>

Creates a new OpenPGP key.

Examples

use gpgme::{Context, Data, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp).unwrap();
let result = ctx.create_key("Example User <example@example.com>", "default", None).unwrap();
println!("Key Fingerprint: {}", result.fingerprint().unwrap());

pub fn create_key_with_flags(
    &mut self,
    userid: impl CStrArgument,
    algo: impl CStrArgument,
    expires: Option<SystemTime>,
    flags: CreateKeyFlags
) -> Result<KeyGenerationResult>

pub fn create_subkey(
    &mut self,
    key: &Key,
    algo: impl CStrArgument,
    expires: Option<SystemTime>
) -> Result<KeyGenerationResult>

pub fn create_subkey_with_flags(
    &mut self,
    key: &Key,
    algo: impl CStrArgument,
    expires: Option<SystemTime>,
    flags: CreateKeyFlags
) -> Result<KeyGenerationResult>

pub fn add_uid(&mut self, key: &Key, userid: impl CStrArgument) -> Result<()>

pub fn revoke_uid(&mut self, key: &Key, userid: impl CStrArgument) -> Result<()>

pub fn set_uid_flag(
    &mut self,
    key: &Key,
    userid: impl CStrArgument,
    name: impl CStrArgument,
    value: Option<impl CStrArgument>
) -> Result<()>

pub fn sign_key<I>(
    &mut self,
    key: &Key,
    userids: I,
    expires: Option<SystemTime>
) -> Result<()> where
    I: IntoIterator,
    I::Item: AsRef<[u8]>, 

Signs the given key with the default signing key, or the keys specified via add_signer.

pub fn sign_key_with_flags<I>(
    &mut self,
    key: &Key,
    userids: I,
    expires: Option<SystemTime>,
    flags: KeySigningFlags
) -> Result<()> where
    I: IntoIterator,
    I::Item: AsRef<[u8]>, 

pub fn change_key_tofu_policy(
    &mut self,
    key: &Key,
    policy: TofuPolicy
) -> Result<()>

pub fn change_key_passphrase(&mut self, key: &Key) -> Result<()>

pub fn edit_key<'a, E, D>(
    &mut self,
    key: &Key,
    interactor: E,
    data: D
) -> Result<()> where
    E: EditInteractor,
    D: IntoData<'a>, 

pub fn edit_card_key<'a, E, D>(
    &mut self,
    key: &Key,
    interactor: E,
    data: D
) -> Result<()> where
    E: EditInteractor,
    D: IntoData<'a>, 

pub fn edit_key_with<'a, D>(
    &mut self,
    key: &Key,
    editor: impl Editor,
    data: D
) -> Result<()> where
    D: IntoData<'a>, 

pub fn edit_card_key_with<'a, D>(
    &mut self,
    key: &Key,
    editor: impl Editor,
    data: D
) -> Result<()> where
    D: IntoData<'a>, 

pub fn interact<'a, I, D>(
    &mut self,
    key: &Key,
    interactor: I,
    data: D
) -> Result<()> where
    I: Interactor,
    D: IntoData<'a>, 

pub fn interact_with_card<'a, I, D>(
    &mut self,
    key: &Key,
    interactor: I,
    data: D
) -> Result<()> where
    I: Interactor,
    D: IntoData<'a>, 

pub fn delete_key(&mut self, key: &Key) -> Result<()>

pub fn delete_secret_key(&mut self, key: &Key) -> Result<()>

pub fn delete_key_with_flags(
    &mut self,
    key: &Key,
    flags: DeleteKeyFlags
) -> Result<()>

pub fn import<'a, D>(&mut self, src: D) -> Result<ImportResult> where
    D: IntoData<'a>, 

pub fn import_keys<'k, I>(&mut self, keys: I) -> Result<ImportResult> where
    I: IntoIterator<Item = &'k Key>, 

pub fn export_all_extern<I>(&mut self, mode: ExportMode) -> Result<()> where
    I: IntoIterator,
    I::Item: CStrArgument, 

pub fn export_extern<I>(&mut self, patterns: I, mode: ExportMode) -> Result<()> where
    I: IntoIterator,
    I::Item: CStrArgument, 

pub fn export_all<'a, D>(&mut self, mode: ExportMode, dst: D) -> Result<()> where
    D: IntoData<'a>, 

pub fn export<'a, I, D>(
    &mut self,
    patterns: I,
    mode: ExportMode,
    dst: D
) -> Result<()> where
    I: IntoIterator,
    I::Item: CStrArgument,
    D: IntoData<'a>, 

pub fn export_keys_extern<'k, I>(
    &mut self,
    keys: I,
    mode: ExportMode
) -> Result<()> where
    I: IntoIterator<Item = &'k Key>, 

pub fn export_keys<'k, 'a, I, D>(
    &mut self,
    keys: I,
    mode: ExportMode,
    dst: D
) -> Result<()> where
    I: IntoIterator<Item = &'k Key>,
    D: IntoData<'a>, 

pub fn clear_sender(&mut self) -> Result<()>

pub fn set_sender(&mut self, sender: impl CStrArgument) -> Result<()>

pub fn sender(&self) -> Result<&str, Option<Utf8Error>>

pub fn sender_raw(&self) -> Option<&CStr>

pub fn clear_signers(&mut self)

pub fn add_signer(&mut self, key: &Key) -> Result<()>

Important traits for Signers<'ctx>

impl<'ctx> Iterator for Signers<'ctx> type Item = Key;

pub fn signers(&self) -> Signers

pub fn clear_signature_notations(&mut self)

pub fn add_signature_notation(
    &mut self,
    name: impl CStrArgument,
    value: impl CStrArgument,
    flags: SignatureNotationFlags
) -> Result<()>

pub fn add_signature_policy_url(
    &mut self,
    url: impl CStrArgument,
    critical: bool
) -> Result<()>

pub fn signature_policy_url(&self) -> Result<&str, Option<Utf8Error>>

pub fn signature_policy_url_raw(&self) -> Option<&CStr>

Important traits for SignatureNotations<'a>

impl<'a> Iterator for SignatureNotations<'a> type Item = SignatureNotation<'a>;

pub fn signature_notations(&self) -> SignatureNotations

pub fn sign_clear<'p, 't, P, T>(
    &mut self,
    plaintext: P,
    signedtext: T
) -> Result<SigningResult> where
    P: IntoData<'p>,
    T: IntoData<'t>, 

pub fn sign_detached<'p, 's, P, S>(
    &mut self,
    plaintext: P,
    signature: S
) -> Result<SigningResult> where
    P: IntoData<'p>,
    S: IntoData<'s>, 

pub fn sign_normal<'p, 't, P, T>(
    &mut self,
    plaintext: P,
    signedtext: T
) -> Result<SigningResult> where
    P: IntoData<'p>,
    T: IntoData<'t>, 

pub fn sign<'p, 's, P, S>(
    &mut self,
    mode: SignMode,
    plaintext: P,
    signature: S
) -> Result<SigningResult> where
    P: IntoData<'p>,
    S: IntoData<'s>, 

pub fn verify_detached<'s, 't, S, T>(
    &mut self,
    signature: S,
    signedtext: T
) -> Result<VerificationResult> where
    S: IntoData<'s>,
    T: IntoData<'t>, 

pub fn verify_opaque<'s, 'p, S, P>(
    &mut self,
    signedtext: S,
    plaintext: P
) -> Result<VerificationResult> where
    S: IntoData<'s>,
    P: IntoData<'p>, 

pub fn encrypt<'k, 'p, 'c, I, P, C>(
    &mut self,
    recp: I,
    plaintext: P,
    ciphertext: C
) -> Result<EncryptionResult> where
    I: IntoIterator<Item = &'k Key>,
    P: IntoData<'p>,
    C: IntoData<'c>, 

Encrypts a message for the specified recipients.

Examples

use gpgme::{Context, Data, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp).unwrap();
let key = ctx.find_key("[some key fingerprint]").unwrap();
let (plaintext, mut ciphertext) = ("Hello, World!", Vec::new());
ctx.encrypt(Some(&key), plaintext, &mut ciphertext).unwrap();

pub fn encrypt_with_flags<'k, 'p, 'c, I, P, C>(
    &mut self,
    recp: I,
    plaintext: P,
    ciphertext: C,
    flags: EncryptFlags
) -> Result<EncryptionResult> where
    I: IntoIterator<Item = &'k Key>,
    P: IntoData<'p>,
    C: IntoData<'c>, 

pub fn encrypt_symmetric<'p, 'c, P, C>(
    &mut self,
    plaintext: P,
    ciphertext: C
) -> Result<()> where
    P: IntoData<'p>,
    C: IntoData<'c>, 

pub fn encrypt_symmetric_with_flags<'p, 'c, P, C>(
    &mut self,
    plaintext: P,
    ciphertext: C,
    flags: EncryptFlags
) -> Result<()> where
    P: IntoData<'p>,
    C: IntoData<'c>, 

pub fn sign_and_encrypt<'k, 'p, 'c, I, P, C>(
    &mut self,
    recp: I,
    plaintext: P,
    ciphertext: C
) -> Result<(EncryptionResult, SigningResult)> where
    I: IntoIterator<Item = &'k Key>,
    P: IntoData<'p>,
    C: IntoData<'c>, 

Encrypts and signs a message for the specified recipients.

Examples

use gpgme::{Context, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp).unwrap();
let key = ctx.find_key("[some key fingerprint]").unwrap();
let (plaintext, mut ciphertext) = ("Hello, World!", Vec::new());
ctx.sign_and_encrypt(Some(&key), plaintext, &mut ciphertext).unwrap();

pub fn sign_and_encrypt_with_flags<'k, 'p, 'c, I, P, C>(
    &mut self,
    recp: I,
    plaintext: P,
    ciphertext: C,
    flags: EncryptFlags
) -> Result<(EncryptionResult, SigningResult)> where
    I: IntoIterator<Item = &'k Key>,
    P: IntoData<'p>,
    C: IntoData<'c>, 

pub fn decrypt<'c, 'p, C, P>(
    &mut self,
    ciphertext: C,
    plaintext: P
) -> Result<DecryptionResult> where
    C: IntoData<'c>,
    P: IntoData<'p>, 

Decrypts a message.

Examples

use gpgme::{Context, Data, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp).unwrap();
let mut cipher = Data::load("some file").unwrap();
let mut plain = Vec::new();
ctx.decrypt(&mut cipher, &mut plain).unwrap();

pub fn decrypt_with_flags<'c, 'p, C, P>(
    &mut self,
    ciphertext: C,
    plaintext: P,
    flags: DecryptFlags
) -> Result<DecryptionResult> where
    C: IntoData<'c>,
    P: IntoData<'p>, 

pub fn decrypt_and_verify<'c, 'p, C, P>(
    &mut self,
    ciphertext: C,
    plaintext: P
) -> Result<(DecryptionResult, VerificationResult)> where
    C: IntoData<'c>,
    P: IntoData<'p>, 

Decrypts and verifies a message.

Examples

use gpgme::{Context, Data, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp).unwrap();
let mut cipher = Data::load("some file").unwrap();
let mut plain = Vec::new();
ctx.decrypt_and_verify(&mut cipher, &mut plain).unwrap();

pub fn decrypt_and_verify_with_flags<'c, 'p, C, P>(
    &mut self,
    ciphertext: C,
    plaintext: P,
    flags: DecryptFlags
) -> Result<(DecryptionResult, VerificationResult)> where
    C: IntoData<'c>,
    P: IntoData<'p>, 

pub fn query_swdb(
    &mut self,
    name: Option<impl CStrArgument>,
    installed_ver: Option<impl CStrArgument>
) -> Result<QuerySwdbResult>

pub fn get_audit_log<'a, D>(
    &mut self,
    dst: D,
    flags: AuditLogFlags
) -> Result<()> where
    D: IntoData<'a>, 

Trait Implementations

impl Drop for Context

fn drop(&mut self)

Executes the destructor for this type.

impl Debug for Context

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.