tlock 0.0.8

Rust encryption library for practical time-lock encryption.
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion};

#[cfg(unix)]
use pprof::criterion::{Output, PProfProfiler};

fn criterion_benchmark(c: &mut Criterion) {
    let pk_bytes = hex::decode("8200fc249deb0148eb918d6e213980c5d01acd7fc251900d9260136da3b54836ce125172399ddc69c4e3e11429b62c11").unwrap();
    let signature = hex::decode("a4721e6c3eafcd823f138cd29c6c82e8c5149101d0bb4bafddbac1c2d1fe3738895e4e21dd4b8b41bf007046440220910bb1cdb91f50a84a0d7f33ff2e8577aa62ac64b35a291a728a9db5ac91e06d1312b48a376138d77b4d6ad27c24221afe").unwrap();

    c.bench_function("lock with TLE", |b| {
        b.iter_batched_ref(
            || {
                let mut msg = vec![0u8; 16];
                msg.fill_with(rand::random);
                msg
            },
            |msg| {
                let mut encrypted = vec![];
                tlock::encrypt(
                    black_box(&mut encrypted),
                    black_box(msg.as_slice()),
                    black_box(&pk_bytes),
                    black_box(1000),
                )
                .unwrap();
                assert_ne!(encrypted.len(), 0);
            },
            BatchSize::SmallInput,
        )
    });

    c.bench_function("unlock with TLE", |b| {
        b.iter_batched_ref(
            || {
                let mut msg = vec![0u8; 16];
                msg.fill_with(rand::random);

                let mut encrypted = vec![];
                tlock::encrypt(
                    black_box(&mut encrypted),
                    black_box(msg.as_slice()),
                    black_box(&pk_bytes),
                    black_box(1000),
                )
                .unwrap();
                (msg, encrypted)
            },
            |(msg, encrypted)| {
                let mut decrypted = vec![];
                tlock::decrypt(
                    black_box(&mut decrypted),
                    black_box(encrypted.as_slice()),
                    black_box(&signature),
                )
                .unwrap();
                decrypted.resize(msg.len(), 0);
                assert_eq!(msg.as_slice(), decrypted);
            },
            BatchSize::SmallInput,
        )
    });

    c.bench_function("lock unlock with TLE", |b| {
        b.iter_batched_ref(
            || {
                let mut msg = vec![0u8; 16];
                msg.fill_with(rand::random);
                msg
            },
            |msg| {
                let mut encrypted = vec![];
                tlock::encrypt(
                    black_box(&mut encrypted),
                    black_box(msg.as_slice()),
                    black_box(&pk_bytes),
                    black_box(1000),
                )
                .unwrap();
                let mut decrypted = vec![];
                tlock::decrypt(
                    black_box(&mut decrypted),
                    black_box(encrypted.as_slice()),
                    black_box(&signature),
                )
                .unwrap();
                decrypted.resize(msg.len(), 0);
                assert_eq!(msg.as_slice(), decrypted);
            },
            BatchSize::SmallInput,
        )
    });
}

#[cfg(unix)]
criterion_group!(
    name = benches;
    config = Criterion::default()
        .with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
    targets = criterion_benchmark
);
#[cfg(not(unix))]
criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);