18 releases

new 0.5.15 Mar 25, 2020
0.5.14 Nov 25, 2019
0.5.12 Aug 19, 2019
0.5.11 Jun 20, 2019
0.3.1 Apr 28, 2019

#37 in Cryptography

Download history 252/week @ 2019-12-02 345/week @ 2019-12-09 211/week @ 2019-12-16 80/week @ 2019-12-23 82/week @ 2019-12-30 346/week @ 2020-01-06 713/week @ 2020-01-13 375/week @ 2020-01-20 332/week @ 2020-01-27 271/week @ 2020-02-03 357/week @ 2020-02-10 370/week @ 2020-02-17 492/week @ 2020-02-24 522/week @ 2020-03-02 739/week @ 2020-03-09 456/week @ 2020-03-16

1,841 downloads per month
Used in 13 crates (4 directly)

MIT license

175KB
5K SLoC

Build status Last version Documentation

rust-minisign

A pure Rust implementation of the Minisign signature system.

This is a crate, designed to be used within by applications.

For a command-line tool reimplementing the Minisign utility in Rust, and based on this crate, check out rsign2.

For a minimal crate that to only verify signatures, check out minisign-verify.

API documentation

API documentation on docs.rs

Example

fn main() {
    extern crate minisign;
    use minisign::{KeyPair, PublicKeyBox, SecretKeyBox, SignatureBox};
    use std::io::Cursor;

    // Generate and return a new key pair
    // The key is encrypted using a password.
    // If `None` is given, the password will be asked for interactively.
    let KeyPair { pk, sk } =
        KeyPair::generate_encrypted_keypair(Some("key password".to_string())).unwrap();

    // In order to be stored to disk, keys have to be converted to "boxes".
    // A box is just a container, with some metadata about its content.
    // Boxes can be converted to/from strings, making them convenient to use for storage.
    let pk_box_str = pk.to_box().unwrap().to_string();
    let sk_box_str = sk
        .to_box(None) // Optional comment about the key
        .unwrap()
        .to_string();

    // `pk_box_str` and `sk_box_str` can now be saved to disk.
    // This is a long-term key pair, that can be used to sign as many files as needed.
    // For conveniency, the `KeyPair::generate_and_write_encrypted_keypair()` function
    // is available: it generates a new key pair, and saves it to disk (or any `Writer`)
    // before returning it.

    // Assuming that `sk_box_str` is something we previously saved and just reloaded,
    // it can be converted back to a secret key box:
    let sk_box = SecretKeyBox::from_string(&sk_box_str).unwrap();

    // and the box can be opened using the password to reveal the original secret key:
    let sk = sk_box
        .into_secret_key(Some("key password".to_string()))
        .unwrap();

    // Now, we can use the secret key to sign anything.
    let data = b"lorem ipsum";
    let data_reader = Cursor::new(data);
    let signature_box = minisign::sign(None, &sk, data_reader, false, None, None).unwrap();

    // We have a signature! Let's inspect it a little bit.
    println!(
        "Untrusted comment: [{}]",
        signature_box.untrusted_comment().unwrap()
    );
    println!(
        "Trusted comment: [{}]",
        signature_box.trusted_comment().unwrap()
    );

    // Converting the signature box to a string in order to save it is easy.
    let signature_box_str = signature_box.into_string();

    // Now, let's verify the signature.
    // Assuming we just loaded it into `signature_box_str`, get the box back.
    let signature_box = SignatureBox::from_string(&signature_box_str).unwrap();

    // Load the public key from the string.
    let pk_box = PublicKeyBox::from_string(&pk_box_str).unwrap();
    let pk = pk_box.into_public_key().unwrap();

    // And verify the data.
    let data_reader = Cursor::new(data);
    let verified = minisign::verify(&pk, &signature_box, data_reader, true, false);
    match verified {
        Ok(()) => println!("Success!"),
        Err(_) => println!("Verification failed"),
    };
}

Dependencies

~725KB
~14K SLoC