Struct message_verifier::Verifier

pub struct Verifier { /* private fields */ }

Verifier struct; similiar to ActiveSupport::MessageVerifier.

Implementations

impl Verifier

pub fn new(secret: &str) -> Verifier

Create a new Verifier object.

Examples found in repository

examples/generate_encrypt.rs (line 10)

fn main() {
    let key_base = "helloworld";
    let salt = "test salt";
    let sign_salt = "test signed salt";

    let verifier = Verifier::new(key_base);

    let dkp = DerivedKeyParams::default();
    let encryptor = AesHmacEncryptor::new(key_base, salt, sign_salt, dkp).unwrap();

    let message = "{\"key\":\"value\"}";

    println!("{}", verifier.generate(message).expect("Verifier failed"));
    println!(
        "{}",
        encryptor
            .encrypt_and_sign(message)
            .expect("Encryptor failed")
    );
}

examples/verify_decrypt.rs (line 13)

fn main() {
    let key_base = "helloworld";
    let salt = "test salt";
    let sign_salt = "test signed salt";

    let verifier = Verifier::new(key_base);

    let dkp = DerivedKeyParams::default();
    let encryptor = AesHmacEncryptor::new(key_base, salt, sign_salt, dkp).unwrap();

    let mut input: Vec<String> = vec![];
    let mut buffer = String::new();

    for _ in 0..2 {
        match io::stdin().read_line(&mut buffer) {
            Ok(_) => {
                input.push(buffer.clone());

                buffer.clear();
            }

            Err(_) => panic!("Read failed"),
        }
    }

    let (msg1, msg2) = match (input.first(), input.last()) {
        (Some(m1), Some(m2)) => (m1, m2),

        _ => panic!("Missing input"),
    };

    match verifier.verify(msg1) {
        Ok(verified_result) => match encryptor.decrypt_and_verify(msg2) {
            Ok(ref decrypted_result) => {
                println!(
                    "Verified Message: {}",
                    str::from_utf8(&verified_result).expect("Verifier failed")
                );
                println!(
                    "Decrypted Message: {}",
                    str::from_utf8(decrypted_result).expect("Encryptor failed")
                );
            }

            Err(e) => panic!("Encryptor Error: {:?}", e),
        },

        Err(e) => panic!("Verifier Error: {:?}", e),
    }
}

pub fn verify(&self, message: &str) -> Result<Vec<u8>>

Verify a signed message generated by a compatible verifier.

Examples found in repository

examples/verify_decrypt.rs (line 39)

fn main() {
    let key_base = "helloworld";
    let salt = "test salt";
    let sign_salt = "test signed salt";

    let verifier = Verifier::new(key_base);

    let dkp = DerivedKeyParams::default();
    let encryptor = AesHmacEncryptor::new(key_base, salt, sign_salt, dkp).unwrap();

    let mut input: Vec<String> = vec![];
    let mut buffer = String::new();

    for _ in 0..2 {
        match io::stdin().read_line(&mut buffer) {
            Ok(_) => {
                input.push(buffer.clone());

                buffer.clear();
            }

            Err(_) => panic!("Read failed"),
        }
    }

    let (msg1, msg2) = match (input.first(), input.last()) {
        (Some(m1), Some(m2)) => (m1, m2),

        _ => panic!("Missing input"),
    };

    match verifier.verify(msg1) {
        Ok(verified_result) => match encryptor.decrypt_and_verify(msg2) {
            Ok(ref decrypted_result) => {
                println!(
                    "Verified Message: {}",
                    str::from_utf8(&verified_result).expect("Verifier failed")
                );
                println!(
                    "Decrypted Message: {}",
                    str::from_utf8(decrypted_result).expect("Encryptor failed")
                );
            }

            Err(e) => panic!("Encryptor Error: {:?}", e),
        },

        Err(e) => panic!("Verifier Error: {:?}", e),
    }
}

pub fn is_valid_message( &self, encoded_data: &str, signature: &str ) -> Result<bool>

Check if the given signature is valid for some encoded data.

pub fn generate(&self, message: &str) -> Result<String>

Generate a signed message from the input message. This message can be consumed and verified by a compatible verifier.

Examples found in repository

examples/generate_encrypt.rs (line 17)

fn main() {
    let key_base = "helloworld";
    let salt = "test salt";
    let sign_salt = "test signed salt";

    let verifier = Verifier::new(key_base);

    let dkp = DerivedKeyParams::default();
    let encryptor = AesHmacEncryptor::new(key_base, salt, sign_salt, dkp).unwrap();

    let message = "{\"key\":\"value\"}";

    println!("{}", verifier.generate(message).expect("Verifier failed"));
    println!(
        "{}",
        encryptor
            .encrypt_and_sign(message)
            .expect("Encryptor failed")
    );
}