Struct Signer 

pub struct Signer { /* private fields */ }

Builder for signing operations.

Examples

Basic signing:

use libsignify_rs::{KeyGenerator, Signer};
use tempfile::tempdir;
use std::fs;

let dir = tempdir()?;
let pub_path = dir.path().join("key.pub");
let sec_path = dir.path().join("key.sec");
let msg_path = dir.path().join("msg.txt");
let sig_path = dir.path().join("msg.sig");

// Setup: Generate keys and message
KeyGenerator::new().rounds(0).generate(&pub_path, &sec_path)?;
fs::write(&msg_path, "test message")?;

// Sign
Signer::new()
    .seckey(&sec_path)
    .sign(&msg_path, &sig_path)?;

assert!(sig_path.exists());

Embedded signature:

Signer::new()
    .seckey(&sec_path)
    .embed(true)
    .sign(&msg_path, &sig_path)?;

Gzip signing:

use flate2::write::GzEncoder;
use flate2::Compression;
use std::fs::File;
use std::io::Write;

// Create a valid gzip file to sign
let f = File::create(&msg_path)?;
let mut e = GzEncoder::new(f, Compression::default());
e.write_all(b"compressed content")?;
e.finish()?;

Signer::new()
    .seckey(&sec_path)
    .gzip(true)
    .sign(&msg_path, &sig_path)?;

Implementations

impl Signer

pub fn new() -> Self

Create a new Signer.

pub fn seckey(self, path: impl Into<PathBuf>) -> Self

Set secret key path.

pub fn embed(self, embed: bool) -> Self

Set embed mode (signify -e).

If true, creates an embedded signature.

pub fn gzip(self, gzip: bool) -> Self

Set gzip mode (signify -z).

If true, signs a gzip archive.

pub fn key_id(self, key_id: i32) -> Self

Set key ID (for keyring support).

pub fn sign(self, msg_path: &Path, sig_path: &Path) -> Result<()>

Sign a file.

Errors

Returns errors if I/O, decryption, or signing fails.

Trait Implementations

impl Default for Signer

fn default() -> Self

Returns the “default value” for a type.