vrf 0.2.5

Fast and extensible Verifiable Random Function (VRF) library; currently supporting secp256k1, secp256r1 and sect163k1 curves
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

//! # Client example
//!
//! This example shows a command line client usage of the `vrf-rs` crate:
//!
//! 1. Instantiate the `ECVRF` by specifying the `CipherSuite`
//! 2. Generate a VRF proof by using the `prove()` function
//! 3. (Optional) Convert the VRF proof to a hash (e.g. to be used as pseudo-random value)
//! 4. Verify a VRF proof by using `verify()` function

#[macro_use]
extern crate clap;
use hex;
use vrf::{
    openssl::{CipherSuite, ECVRF},
    VRF,
};

macro_rules! gen_validator {
    ($name:ident : $type:ty) => {
        gen_validator!($name, str::parse::<$type>);
    };
    ($name:ident, $expr:expr) => {
        fn $name(obj: String) -> Result<(), String> {
            $expr(&obj).map(drop).map_err(|x| format!("{}", x))
        }
    };
}
gen_validator!(is_hex_ok, hex::decode);

fn main() {
    let matches = clap_app!(vrf =>
        (version: crate_version!())
        (author: "Vixify Network")
        (about: "Client to Verifiable Random Functions")
        (@arg VERBOSE: -v --verbose "Log verbosely to stderr.  This command does not currently log anything, so this option currently has no affect.")
        (@arg SECRET_KEY: +required {is_hex_ok} "Secret key to be used to print or validate proof" )
        (@arg MESSAGE: +required "Message to be used to print or validate proof." )
        (@arg PROOF: {is_hex_ok} "Optional VRF Proof to be validated. If missing, proof is printed for secret and message." )
    )
    .get_matches();

    let mut vrf = ECVRF::from_suite(CipherSuite::SECP256K1_SHA256_TAI).unwrap();
    // Inputs: Secret Key, Public Key (derived) & Message
    let secret_key = hex::decode(&matches.value_of("SECRET_KEY").unwrap()).unwrap();
    let public_key = vrf.derive_public_key(&secret_key).unwrap();
    let message = &matches.value_of("MESSAGE").unwrap().as_bytes();

    let mut pi = vrf.prove(&secret_key, &message).unwrap();
    let hash = vrf.proof_to_hash(&pi).unwrap();

    // VRF proof and hash output
    let proof_given = matches.value_of("PROOF") != None;
    if proof_given {
        pi = hex::decode(&matches.value_of("PROOF").unwrap()).unwrap();
    } else {
        println!("{}", hex::encode(&pi));
    }

    let beta = vrf.verify(&public_key, &pi, &message);

    if proof_given {
        match beta {
            Ok(beta) => {
                println!("VRF proof is valid!");
                assert_eq!(hash, beta);
            }
            Err(_e) => {
                println!("VRF proof is not valid!");
            }
        }
    }
}