Struct sequoia_openpgp::serialize::stream::Signer

pub struct Signer<'a> { /* fields omitted */ }

Signs a packet stream.

For every signing key, a signer writes a one-pass-signature packet, then hashes and emits the data stream, then for every key writes a signature packet.

Implementations

impl<'a> Signer<'a>

pub fn new<S>(inner: Message<'a, Cookie>, signer: S) -> Self where
    S: Signer + 'a, 

Creates a signer.

Example

extern crate sequoia_openpgp as openpgp;
use std::io::{Read, Write};
use openpgp::serialize::stream::{Message, Signer, LiteralWriter};
use openpgp::policy::StandardPolicy;

let p = &StandardPolicy::new();

let p = &StandardPolicy::new();

let mut o = vec![];
{
    let message = Message::new(&mut o);
    let signer = Signer::new(message, signing_keypair).build()?;
    let mut ls = LiteralWriter::new(signer).build()?;
    ls.write_all(b"Make it so, number one!")?;
    ls.finalize()?;
}

// Now check the signature.
struct Helper<'a>(&'a openpgp::Cert);
impl<'a> VerificationHelper for Helper<'a> {
    fn get_public_keys(&mut self, _: &[openpgp::KeyHandle])
                       -> openpgp::Result<Vec<openpgp::Cert>> {
        Ok(vec![self.0.clone()])
    }

    fn check(&mut self, structure: MessageStructure)
             -> openpgp::Result<()> {
        if let MessageLayer::SignatureGroup { ref results } =
            structure.iter().nth(0).unwrap()
        {
            results.get(0).unwrap().as_ref().unwrap();
            Ok(())
        } else { panic!() }
    }
}

let mut verifier = Verifier::from_bytes(p, &o, Helper(&cert), None)?;

let mut message = String::new();
verifier.read_to_string(&mut message)?;
assert_eq!(&message, "Make it so, number one!");

pub fn hash_algo(self, algo: HashAlgorithm) -> Result<Self>

Sets the hash algorithm to use for the signatures.

pub fn add_signer<S>(self, signer: S) -> Self where
    S: Signer + 'a, 

Adds an additional signer.

pub fn add_intended_recipient(self, recipient: &Cert) -> Self

Adds an intended recipient.

This signer emits signatures indicating the intended recipients of the encryption container containing the signature. This prevents forwarding a signed message using a different encryption context.

pub fn detached(self) -> Self

Creates a signer for a detached signature.

Example

extern crate sequoia_openpgp as openpgp;
use std::io::{Read, Write};
use openpgp::serialize::stream::{Message, Signer, LiteralWriter};
use sequoia_openpgp::policy::StandardPolicy;

let p = &StandardPolicy::new();

let mut o = vec![];
{
    let message = Message::new(&mut o);
    let mut signer =
        Signer::new(message, signing_keypair).detached().build()?;
    signer.write_all(b"Make it so, number one!")?;
    // In reality, just io::copy() the file to be signed.
    signer.finalize()?;
}

// Now check the signature.
struct Helper<'a>(&'a openpgp::Cert);
impl<'a> VerificationHelper for Helper<'a> {
    fn get_public_keys(&mut self, _: &[openpgp::KeyHandle])
                       -> openpgp::Result<Vec<openpgp::Cert>> {
        Ok(vec![self.0.clone()])
    }

    fn check(&mut self, structure: MessageStructure)
             -> openpgp::Result<()> {
        if let MessageLayer::SignatureGroup { ref results } =
            structure.iter().nth(0).unwrap()
        {
            results.get(0).unwrap().as_ref().unwrap();
            Ok(())
        } else { panic!() }
    }
}

let mut verifier =
    DetachedVerifier::from_bytes(p, &o, Helper(&cert), None)?;

verifier.verify_bytes(b"Make it so, number one!")?;

pub fn creation_time(self, creation_time: SystemTime) -> Self

Sets the signature's creation time to time.

Note: it is up to the caller to make sure the signing keys are actually valid as of time.

pub fn build(self) -> Result<Message<'a, Cookie>>

Finalizes the signer, returning the writer stack.

Trait Implementations

impl<'a> Debug for Signer<'a>

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

Formats the value using the given formatter.

impl<'a> Drop for Signer<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> Write for Signer<'a>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writeer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.