Struct sequoia_openpgp::parse::stream::DetachedVerifier

pub struct DetachedVerifier<'a, H: VerificationHelper> { /* private fields */ }

Verifies a detached signature.

To create a DetachedVerifier, create a DetachedVerifierBuilder using Parse, and customize it to your needs.

See GoodChecksum for what it means for a signature to be considered valid. When the signature(s) are processed, VerificationHelper::check will be called with a MessageStructure containing exactly one layer, a signature group.

Examples

use std::io::{self, Read};
use sequoia_openpgp as openpgp;
use openpgp::{KeyHandle, Cert, Result};
use openpgp::parse::{Parse, stream::*};
use sequoia_openpgp::policy::StandardPolicy;

let p = &StandardPolicy::new();

// This fetches keys and computes the validity of the verification.
struct Helper {};
impl VerificationHelper for Helper {
    fn get_certs(&mut self, _ids: &[KeyHandle]) -> Result<Vec<Cert>> {
        Ok(Vec::new()) // Feed the Certs to the verifier here...
    }
    fn check(&mut self, structure: MessageStructure) -> Result<()> {
        Ok(()) // Implement your verification policy here.
    }
}

let signature =
   b"-----BEGIN PGP SIGNATURE-----

     wnUEABYKACcFglt+z/EWoQSOjDP6RiYzeXbZeXgGnAw0jdgsGQmQBpwMNI3YLBkA
     AHmUAP9mpj2wV0/ekDuzxZrPQ0bnobFVaxZGg7YzdlksSOERrwEA6v6czXQjKcv2
     KOwGTamb+ajTLQ3YRG9lh+ZYIXynvwE=
     =IJ29
     -----END PGP SIGNATURE-----";

let data = b"Hello World!";
let h = Helper {};
let mut v = DetachedVerifierBuilder::from_bytes(&signature[..])?
    .with_policy(p, None, h)?;
v.verify_bytes(data)?;

Implementations

impl<'a, H: VerificationHelper> DetachedVerifier<'a, H>

pub fn verify_reader<R: Read + Send + Sync>(&mut self, reader: R) -> Result<()>

Verifies the given data.

pub fn verify_file<P: AsRef<Path>>(&mut self, path: P) -> Result<()>

Verifies the given data.

pub fn verify_bytes<B: AsRef<[u8]>>(&mut self, buf: B) -> Result<()>

Verifies the given data.

pub fn helper_ref(&self) -> &H

Returns a reference to the helper.

pub fn helper_mut(&mut self) -> &mut H

Returns a mutable reference to the helper.

pub fn into_helper(self) -> H

Recovers the helper.