Struct gpgme::Context [−][src]
pub struct Context(_);
Expand description
A context for cryptographic operations.
Upstream documentation:
gpgme_ctx_t
Implementations
Creates a new context and initializes it to work with the specified protocol.
Upstream documentation: gpgme_new
and gpgme_set_protocol
Upstream documentation:
gpgme_get_protocol
Upstream documentation:
gpgme_get_armor
Upstream documentation:
gpgme_set_armor
Upstream documentation:
gpgme_get_textmode
Upstream documentation:
gpgme_set_textmode
Upstream documentation:
gpgme_get_offline
Upstream documentation:
gpgme_set_offline
Upstream documentation:
gpgme_get_ctx_flag
Upstream documentation:
gpgme_get_ctx_flag
Upstream documentation:
gpgme_set_ctx_flag
Upstream documentation:
gpgme_ctx_get_engine_info
pub fn set_engine_info(
&mut self,
path: Option<impl CStrArgument>,
home_dir: Option<impl CStrArgument>
) -> Result<()>
pub fn set_engine_info(
&mut self,
path: Option<impl CStrArgument>,
home_dir: Option<impl CStrArgument>
) -> Result<()>
Upstream documentation:
gpgme_ctx_set_engine_info
Upstream documentation:
gpgme_get_pinentry_mode
Upstream documentation:
gpgme_set_pinentry_mode
Upstream documentation:
gpgme_set_passphrase_cb
pub fn set_passphrase_provider<'a, P>(
self,
provider: P
) -> ContextWithCallbacks<'a> where
P: PassphraseProvider + 'a,
pub fn set_passphrase_provider<'a, P>(
self,
provider: P
) -> ContextWithCallbacks<'a> where
P: PassphraseProvider + 'a,
Upstream documentation:
gpgme_set_passphrase_cb
pub fn with_passphrase_provider<R, P>(
&mut self,
provider: P,
f: impl FnOnce(&mut Context) -> R
) -> R where
P: PassphraseProvider,
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.
Upstream documentation:
gpgme_set_passphrase_cb
Examples
use std::io::prelude::*; use gpgme::{Context, PassphraseRequest, Protocol}; let mut ctx = Context::from_protocol(Protocol::OpenPgp)?; ctx.with_passphrase_provider(|_: PassphraseRequest, out: &mut dyn Write| { out.write_all(b"some passphrase")?; Ok(()) }, |mut ctx| { // Do something with ctx requiring a passphrase, for example decryption });
Upstream documentation:
gpgme_set_progress_cb
pub fn set_progress_reporter<'a, P>(
self,
reporter: P
) -> ContextWithCallbacks<'a> where
P: ProgressReporter + 'a,
pub fn set_progress_reporter<'a, P>(
self,
reporter: P
) -> ContextWithCallbacks<'a> where
P: ProgressReporter + 'a,
Upstream documentation:
gpgme_set_progress_cb
pub fn with_progress_reporter<R, H>(
&mut self,
handler: H,
f: impl FnOnce(&mut Context) -> R
) -> R where
H: ProgressReporter,
pub fn with_progress_reporter<R, H>(
&mut self,
handler: H,
f: impl FnOnce(&mut Context) -> R
) -> R where
H: ProgressReporter,
Upstream documentation:
gpgme_set_progress_cb
pub fn with_progress_handler<R, H>(
&mut self,
handler: H,
f: impl FnOnce(&mut Context) -> R
) -> R where
H: ProgressHandler,
👎 Deprecated since 0.9.2: use with_progress_reporter
instead
pub fn with_progress_handler<R, H>(
&mut self,
handler: H,
f: impl FnOnce(&mut Context) -> R
) -> R where
H: ProgressHandler,
use with_progress_reporter
instead
Upstream documentation:
gpgme_set_progress_cb
Upstream documentation:
gpgme_set_status_cb
pub fn set_status_handler<'a, H>(self, handler: H) -> ContextWithCallbacks<'a> where
H: StatusHandler + 'a,
pub fn set_status_handler<'a, H>(self, handler: H) -> ContextWithCallbacks<'a> where
H: StatusHandler + 'a,
Upstream documentation:
gpgme_set_status_cb
pub fn with_status_handler<R, H>(
&mut self,
handler: H,
f: impl FnOnce(&mut Context) -> R
) -> R where
H: StatusHandler,
pub fn with_status_handler<R, H>(
&mut self,
handler: H,
f: impl FnOnce(&mut Context) -> R
) -> R where
H: StatusHandler,
Upstream documentation:
gpgme_set_status_cb
Upstream documentation:
gpgme_get_keylist_mode
Adds all flags set in the provided key listing mode to the Context
’s current mode.
Upstream documentation:
gpgme_set_keylist_mode
Upstream documentation:
gpgme_set_keylist_mode
Returns an iterator over all public keys available in the keyring.
Returns an iterator over all secret keys available in the keyring.
Returns an updated version of the provided key.
Returns the public key with the specified fingerprint, if such a key can be found. Otherwise, an error is returned.
Upstream documentation:
gpgme_get_key
Returns the secret key with the specified fingerprint, if such a key can be found. Otherwise, an error is returned.
Upstream documentation:
gpgme_get_key
👎 Deprecated since 0.8.0: use get_key
instead
use get_key
instead
Upstream documentation:
gpgme_get_key
👎 Deprecated since 0.8.0: use get_secret_key
instead
use get_secret_key
instead
Upstream documentation:
gpgme_get_key
pub fn find_keys<I>(&mut self, patterns: I) -> Result<Keys<'_>> where
I: IntoIterator,
I::Item: CStrArgument,
pub fn find_keys<I>(&mut self, patterns: I) -> Result<Keys<'_>> where
I: IntoIterator,
I::Item: CStrArgument,
Returns an iterator over a list of all public keys matching one or more of the specified patterns.
Upstream documentation:
gpgme_op_keylist_ext_start
pub fn find_secret_keys<I>(&mut self, patterns: I) -> Result<Keys<'_>> where
I: IntoIterator,
I::Item: CStrArgument,
pub fn find_secret_keys<I>(&mut self, patterns: I) -> Result<Keys<'_>> where
I: IntoIterator,
I::Item: CStrArgument,
Returns an iterator over a list of all secret keys matching one or more of the specified patterns.
Upstream documentation:
gpgme_op_keylist_ext_start
Returns an iterator over the keys encoded in the specified source.
Upstream documentation:
gpgme_op_keylist_from_data_start
Examples
use gpgme::{Context, Data, Protocol}; let mut ctx = Context::from_protocol(Protocol::OpenPgp)?; let mut keyring = Data::load("somefile")?; for key in ctx.read_keys(&mut keyring)? { 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 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>,
Upstream documentation:
gpgme_op_genkey
pub fn create_key(
&mut self,
userid: impl CStrArgument,
algo: impl CStrArgument,
expires: Duration
) -> Result<KeyGenerationResult>
pub fn create_key(
&mut self,
userid: impl CStrArgument,
algo: impl CStrArgument,
expires: Duration
) -> Result<KeyGenerationResult>
Creates a new OpenPGP key.
Upstream documentation:
gpgme_op_createkey
Examples
use gpgme::{Context, Data, Protocol}; let mut ctx = Context::from_protocol(Protocol::OpenPgp)?; let result = ctx.create_key("Example User <example@example.com>", "default", Default::default())?; println!("Key Fingerprint: {}", result.fingerprint().unwrap());
pub fn create_key_with_flags(
&mut self,
userid: impl CStrArgument,
algo: impl CStrArgument,
expires: Duration,
flags: CreateKeyFlags
) -> Result<KeyGenerationResult>
pub fn create_key_with_flags(
&mut self,
userid: impl CStrArgument,
algo: impl CStrArgument,
expires: Duration,
flags: CreateKeyFlags
) -> Result<KeyGenerationResult>
Upstream documentation:
gpgme_op_createkey
pub fn create_subkey(
&mut self,
key: &Key,
algo: impl CStrArgument,
expires: Duration
) -> Result<KeyGenerationResult>
pub fn create_subkey(
&mut self,
key: &Key,
algo: impl CStrArgument,
expires: Duration
) -> Result<KeyGenerationResult>
Upstream documentation:
gpgme_op_createsubkey
pub fn create_subkey_with_flags(
&mut self,
key: &Key,
algo: impl CStrArgument,
expires: Duration,
flags: CreateKeyFlags
) -> Result<KeyGenerationResult>
pub fn create_subkey_with_flags(
&mut self,
key: &Key,
algo: impl CStrArgument,
expires: Duration,
flags: CreateKeyFlags
) -> Result<KeyGenerationResult>
Upstream documentation:
gpgme_op_createsubkey
Upstream documentation:
gpgme_op_setexpire
pub fn set_expire<I>(
&mut self,
key: &Key,
expires: Duration,
subkeys: I
) -> Result<()> where
I: IntoIterator,
I::Item: CStrArgument,
pub fn set_expire<I>(
&mut self,
key: &Key,
expires: Duration,
subkeys: I
) -> Result<()> where
I: IntoIterator,
I::Item: CStrArgument,
Upstream documentation:
gpgme_op_setexpire
Upstream documentation:
gpgme_op_adduid
Upstream documentation:
gpgme_op_revuid
pub fn set_uid_flag(
&mut self,
key: &Key,
userid: impl CStrArgument,
name: impl CStrArgument,
value: Option<impl CStrArgument>
) -> Result<()>
pub fn set_uid_flag(
&mut self,
key: &Key,
userid: impl CStrArgument,
name: impl CStrArgument,
value: Option<impl CStrArgument>
) -> Result<()>
Upstream documentation:
gpgme_op_set_uid_flag
pub fn sign_key<I>(
&mut self,
key: &Key,
userids: I,
expires: Duration
) -> Result<()> where
I: IntoIterator,
I::Item: CStrArgument,
pub fn sign_key<I>(
&mut self,
key: &Key,
userids: I,
expires: Duration
) -> Result<()> where
I: IntoIterator,
I::Item: CStrArgument,
Signs the given key with the default signing key, or the keys specified via
add_signer
.
Upstream documentation:
gpgme_op_keysign
pub fn sign_key_with_flags<I>(
&mut self,
key: &Key,
userids: I,
expires: Duration,
flags: KeySigningFlags
) -> Result<()> where
I: IntoIterator,
I::Item: CStrArgument,
pub fn sign_key_with_flags<I>(
&mut self,
key: &Key,
userids: I,
expires: Duration,
flags: KeySigningFlags
) -> Result<()> where
I: IntoIterator,
I::Item: CStrArgument,
Signs the given key with the default signing key, or the keys specified via
add_signer
.
Upstream documentation:
gpgme_op_keysign
pub fn revoke_signature<I>(
&mut self,
key: &Key,
signing_key: &Key,
userids: I
) -> Result<()> where
I: IntoIterator,
I::Item: CStrArgument,
pub fn revoke_signature<I>(
&mut self,
key: &Key,
signing_key: &Key,
userids: I
) -> Result<()> where
I: IntoIterator,
I::Item: CStrArgument,
Upstream documentation:
gpgme_op_revsig
Upstream documentation:
gpgme_op_tofu_policy
Upstream documentation:
gpgme_op_passwd
pub fn edit_key<'a, E, D>(
&mut self,
key: &Key,
interactor: E,
data: D
) -> Result<()> where
E: EditInteractor,
D: IntoData<'a>,
👎 Deprecated since 0.9.2: use interact
instead
pub fn edit_key<'a, E, D>(
&mut self,
key: &Key,
interactor: E,
data: D
) -> Result<()> where
E: EditInteractor,
D: IntoData<'a>,
use interact
instead
Upstream documentation:
gpgme_op_edit
pub fn edit_card_key<'a, E, D>(
&mut self,
key: &Key,
interactor: E,
data: D
) -> Result<()> where
E: EditInteractor,
D: IntoData<'a>,
👎 Deprecated since 0.9.2: use interact_with_card
instead
pub fn edit_card_key<'a, E, D>(
&mut self,
key: &Key,
interactor: E,
data: D
) -> Result<()> where
E: EditInteractor,
D: IntoData<'a>,
use interact_with_card
instead
Upstream documentation:
gpgme_op_card_edit
pub fn edit_key_with<'a, D>(
&mut self,
key: &Key,
editor: impl Editor,
data: D
) -> Result<()> where
D: IntoData<'a>,
👎 Deprecated since 0.9.2: use interact
instead
pub fn edit_key_with<'a, D>(
&mut self,
key: &Key,
editor: impl Editor,
data: D
) -> Result<()> where
D: IntoData<'a>,
use interact
instead
Upstream documentation:
gpgme_op_edit
pub fn edit_card_key_with<'a, D>(
&mut self,
key: &Key,
editor: impl Editor,
data: D
) -> Result<()> where
D: IntoData<'a>,
👎 Deprecated since 0.9.2: use interact_with_card
instead
pub fn edit_card_key_with<'a, D>(
&mut self,
key: &Key,
editor: impl Editor,
data: D
) -> Result<()> where
D: IntoData<'a>,
use interact_with_card
instead
Upstream documentation:
gpgme_op_card_edit
Upstream documentation:
gpgme_op_interact
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 interact_with_card<'a, I, D>(
&mut self,
key: &Key,
interactor: I,
data: D
) -> Result<()> where
I: Interactor,
D: IntoData<'a>,
Upstream documentation:
gpgme_op_interact
Upstream documentation:
gpgme_op_delete
Upstream documentation:
gpgme_op_delete
Upstream documentation:
gpgme_op_delete_ext
Upstream documentation:
gpgme_op_import
pub fn import_keys<'k, I>(&mut self, keys: I) -> Result<ImportResult> where
I: IntoIterator<Item = &'k Key>,
pub fn import_keys<'k, I>(&mut self, keys: I) -> Result<ImportResult> where
I: IntoIterator<Item = &'k Key>,
Upstream documentation:
gpgme_op_import_keys
pub fn export_all_extern<I>(&mut self, mode: ExportMode) -> Result<()> where
I: IntoIterator,
I::Item: CStrArgument,
pub fn export_all_extern<I>(&mut self, mode: ExportMode) -> Result<()> where
I: IntoIterator,
I::Item: CStrArgument,
Upstream documentation:
gpgme_op_export_ext
pub fn export_extern<I>(&mut self, patterns: I, 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,
Upstream documentation:
gpgme_op_export_ext
pub fn export_all<'a, D>(&mut self, mode: ExportMode, dst: D) -> Result<()> where
D: IntoData<'a>,
pub fn export_all<'a, D>(&mut self, mode: ExportMode, dst: D) -> Result<()> where
D: IntoData<'a>,
Upstream documentation:
gpgme_op_export_ext
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<'a, I, D>(
&mut self,
patterns: I,
mode: ExportMode,
dst: D
) -> Result<()> where
I: IntoIterator,
I::Item: CStrArgument,
D: IntoData<'a>,
Upstream documentation:
gpgme_op_export_ext
pub fn export_keys_extern<'k, I>(
&mut self,
keys: I,
mode: ExportMode
) -> Result<()> where
I: IntoIterator<Item = &'k Key>,
pub fn export_keys_extern<'k, I>(
&mut self,
keys: I,
mode: ExportMode
) -> Result<()> where
I: IntoIterator<Item = &'k Key>,
Upstream documentation:
gpgme_op_export_keys
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 export_keys<'k, 'a, I, D>(
&mut self,
keys: I,
mode: ExportMode,
dst: D
) -> Result<()> where
I: IntoIterator<Item = &'k Key>,
D: IntoData<'a>,
Upstream documentation:
gpgme_op_export_keys
Upstream documentation:
gpgme_set_sender
Upstream documentation:
gpgme_set_sender
Upstream documentation:
gpgme_get_sender
Upstream documentation:
gpgme_get_sender
Upstream documentation:
gpgme_signers_clear
Upstream documentation:
gpgme_signers_add
Upstream documentation:
gpgme_signers_enum
Upstream documentation:
gpgme_sig_notation_clear
pub fn add_signature_notation(
&mut self,
name: impl CStrArgument,
value: impl CStrArgument,
flags: SignatureNotationFlags
) -> Result<()>
pub fn add_signature_notation(
&mut self,
name: impl CStrArgument,
value: impl CStrArgument,
flags: SignatureNotationFlags
) -> Result<()>
Upstream documentation:
gpgme_sig_notation_add
pub fn add_signature_policy_url(
&mut self,
url: impl CStrArgument,
critical: bool
) -> Result<()>
pub fn add_signature_policy_url(
&mut self,
url: impl CStrArgument,
critical: bool
) -> Result<()>
Upstream documentation:
gpgme_sig_notation_add
Upstream documentation:
gpgme_sig_notation_get
Upstream documentation:
gpgme_sig_notation_get
pub fn signature_notations(&self) -> SignatureNotations<'_>ⓘNotable traits for SignatureNotations<'a>impl<'a> Iterator for SignatureNotations<'a> type Item = SignatureNotation<'a>;
pub fn signature_notations(&self) -> SignatureNotations<'_>ⓘNotable traits for SignatureNotations<'a>impl<'a> Iterator for SignatureNotations<'a> type Item = SignatureNotation<'a>;
impl<'a> Iterator for SignatureNotations<'a> type Item = SignatureNotation<'a>;
Upstream documentation:
gpgme_sig_notation_get
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_clear<'p, 't, P, T>(
&mut self,
plaintext: P,
signedtext: T
) -> Result<SigningResult> where
P: IntoData<'p>,
T: IntoData<'t>,
Creates a clear text signature.
Upstream documentation:
gpgme_op_sign
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_detached<'p, 's, P, S>(
&mut self,
plaintext: P,
signature: S
) -> Result<SigningResult> where
P: IntoData<'p>,
S: IntoData<'s>,
Creates a detached signature.
Upstream documentation:
gpgme_op_sign
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_normal<'p, 't, P, T>(
&mut self,
plaintext: P,
signedtext: T
) -> Result<SigningResult> where
P: IntoData<'p>,
T: IntoData<'t>,
Creates a normal signature.
Upstream documentation:
gpgme_op_sign
Creates a signature for the text stored in the data object plaintext
and writes it to the
data object signature
.
The type of the signature created is determined by the ASCII armor (or, if that is not set, by the encoding specified for sig), the text mode attributes set for the context and the requested signature mode.
Information about the results of the operation are returned in the SigningResult
structure.
Upstream documentation:
gpgme_op_sign
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_detached<'s, 't, S, T>(
&mut self,
signature: S,
signedtext: T
) -> Result<VerificationResult> where
S: IntoData<'s>,
T: IntoData<'t>,
Upstream documentation:
gpgme_op_verify
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 verify_opaque<'s, 'p, S, P>(
&mut self,
signedtext: S,
plaintext: P
) -> Result<VerificationResult> where
S: IntoData<'s>,
P: IntoData<'p>,
Upstream documentation:
gpgme_op_verify
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>,
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.
Upstream documentation:
gpgme_op_encrypt
Examples
use gpgme::{Context, Data, Protocol}; let mut ctx = Context::from_protocol(Protocol::OpenPgp)?; let key = ctx.find_key("[some key fingerprint]")?; let (plaintext, mut ciphertext) = ("Hello, World!", Vec::new()); ctx.encrypt(Some(&key), plaintext, &mut ciphertext)?;
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_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>,
Upstream documentation:
gpgme_op_encrypt
Upstream documentation:
gpgme_op_encrypt
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 encrypt_symmetric_with_flags<'p, 'c, P, C>(
&mut self,
plaintext: P,
ciphertext: C,
flags: EncryptFlags
) -> Result<()> where
P: IntoData<'p>,
C: IntoData<'c>,
Upstream documentation:
gpgme_op_encrypt
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>,
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.
Upstream documentation:
gpgme_op_encrypt_sign
Examples
use gpgme::{Context, Protocol}; let mut ctx = Context::from_protocol(Protocol::OpenPgp)?; let key = ctx.find_key("[some key fingerprint]")?; let (plaintext, mut ciphertext) = ("Hello, World!", Vec::new()); ctx.sign_and_encrypt(Some(&key), plaintext, &mut ciphertext)?;
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 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>,
Upstream documentation:
gpgme_op_encrypt_sign
Decrypts a message.
Upstream documentation:
gpgme_op_decrypt
Examples
use gpgme::{Context, Data, Protocol}; let mut ctx = Context::from_protocol(Protocol::OpenPgp)?; let mut cipher = Data::load("some file")?; let mut plain = Vec::new(); ctx.decrypt(&mut cipher, &mut plain)?;
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_with_flags<'c, 'p, C, P>(
&mut self,
ciphertext: C,
plaintext: P,
flags: DecryptFlags
) -> Result<DecryptionResult> where
C: IntoData<'c>,
P: IntoData<'p>,
Upstream documentation:
gpgme_op_decrypt_ext
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>,
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.
Upstream documentation:
gpgme_op_decrypt_verify
Examples
use gpgme::{Context, Data, Protocol}; let mut ctx = Context::from_protocol(Protocol::OpenPgp)?; let mut cipher = Data::load("some file")?; let mut plain = Vec::new(); ctx.decrypt_and_verify(&mut cipher, &mut plain)?;
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 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>,
Upstream documentation:
gpgme_op_decrypt_ext
pub fn query_swdb(
&mut self,
name: Option<impl CStrArgument>,
installed_ver: Option<impl CStrArgument>
) -> Result<QuerySwdbResult>
pub fn query_swdb(
&mut self,
name: Option<impl CStrArgument>,
installed_ver: Option<impl CStrArgument>
) -> Result<QuerySwdbResult>
Upstream documentation:
gpgme_op_query_swdb
pub fn get_audit_log<'a, D>(
&mut self,
dst: D,
flags: AuditLogFlags
) -> Result<()> where
D: IntoData<'a>,
pub fn get_audit_log<'a, D>(
&mut self,
dst: D,
flags: AuditLogFlags
) -> Result<()> where
D: IntoData<'a>,
Upstream documentation:
gpgme_op_getauditlog
Trait Implementations
Auto Trait Implementations
impl RefUnwindSafe for Context
impl UnwindSafe for Context
Blanket Implementations
Convert the given value into an approximately equivalent representation.
impl<Dst, Src, Scheme> ApproxInto<Dst, Scheme> for Src where
Dst: ApproxFrom<Src, Scheme>,
Scheme: ApproxScheme,
impl<Dst, Src, Scheme> ApproxInto<Dst, Scheme> for Src where
Dst: ApproxFrom<Src, Scheme>,
Scheme: ApproxScheme,
type Err = <Dst as ApproxFrom<Src, Scheme>>::Err
type Err = <Dst as ApproxFrom<Src, Scheme>>::Err
The error type produced by a failed conversion.
Convert the subject into an approximately equivalent representation.
Mutably borrows from an owned value. Read more
Approximate the subject with the default scheme.
fn approx_by<Scheme>(self) -> Result<Dst, Self::Err> where
Self: ApproxInto<Dst, Scheme>,
Scheme: ApproxScheme,
fn approx_by<Scheme>(self) -> Result<Dst, Self::Err> where
Self: ApproxInto<Dst, Scheme>,
Scheme: ApproxScheme,
Approximate the subject with a specific scheme.
Approximate the subject to a given type with the default scheme.
fn approx_as_by<Dst, Scheme>(self) -> Result<Dst, Self::Err> where
Self: ApproxInto<Dst, Scheme>,
Scheme: ApproxScheme,
fn approx_as_by<Dst, Scheme>(self) -> Result<Dst, Self::Err> where
Self: ApproxInto<Dst, Scheme>,
Scheme: ApproxScheme,
Approximate the subject to a given type with a specific scheme.
Attempt to convert the subject to a given type.