ciphern 0.2.1

Enterprise-grade cryptographic library
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

// Copyright (c) 2025 Kirky.X
//
// Licensed under the MIT License
// See LICENSE file in the project root for full license information.

use ciphern::random::{is_hardware_rng_available, BulkHardwareRng, HardwareRng};
use ciphern::{Algorithm, Cipher, KeyManager};
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use rand::RngCore;
use std::hint::black_box;

fn bench_aes256_encrypt(c: &mut Criterion) {
    let mut group = c.benchmark_group("aes256_encrypt");
    let key_manager = KeyManager::new().unwrap();
    let key_id = key_manager.generate_key(Algorithm::AES256GCM).unwrap();
    let cipher = Cipher::new(Algorithm::AES256GCM).unwrap();

    for size in [1024, 10240, 102400, 1048576].iter() {
        group.throughput(criterion::Throughput::Bytes(*size as u64));

        group.bench_with_input(BenchmarkId::from_parameter(size), size, |b, &size| {
            let plaintext = vec![0u8; size];
            b.iter(|| {
                cipher
                    .encrypt(&key_manager, &key_id, black_box(&plaintext))
                    .unwrap()
            });
        });
    }

    group.finish();
}

fn bench_sm4_encrypt(c: &mut Criterion) {
    let mut group = c.benchmark_group("sm4_encrypt");
    let key_manager = KeyManager::new().unwrap();
    let key_id = key_manager.generate_key(Algorithm::SM4GCM).unwrap();
    let cipher = Cipher::new(Algorithm::SM4GCM).unwrap();

    for size in [1024, 10240, 102400, 1048576].iter() {
        group.throughput(criterion::Throughput::Bytes(*size as u64));

        group.bench_with_input(BenchmarkId::from_parameter(size), size, |b, &size| {
            let plaintext = vec![0u8; size];
            b.iter(|| {
                cipher
                    .encrypt(&key_manager, &key_id, black_box(&plaintext))
                    .unwrap()
            });
        });
    }

    group.finish();
}

fn bench_hardware_rng(c: &mut Criterion) {
    let mut group = c.benchmark_group("hardware_rng");

    if !is_hardware_rng_available() {
        // Skip if hardware RNG is not available
        group.bench_function("software_fallback", |b| {
            b.iter(|| {
                let mut rng = HardwareRng::new().unwrap();
                let mut buf = [0u8; 32];
                rng.fill_bytes(&mut buf);
            });
        });
        group.finish();
        return;
    }

    // Benchmark single u64 generation
    group.bench_function("next_u64", |b| {
        let mut rng = HardwareRng::new().unwrap();
        b.iter(|| {
            let _ = rng.next_u64();
        });
    });

    // Benchmark fill_bytes for different sizes
    for size in [32, 64, 128, 256, 512, 1024].iter() {
        group.throughput(criterion::Throughput::Bytes(*size as u64));

        group.bench_with_input(BenchmarkId::from_parameter(size), size, |b, &size| {
            let mut rng = HardwareRng::new().unwrap();
            b.iter(|| {
                let mut buf = vec![0u8; size];
                rng.fill_bytes(&mut buf);
            });
        });
    }

    // Benchmark raw hardware_fill_bytes
    for size in [32, 64, 128, 256, 512, 1024].iter() {
        group.throughput(criterion::Throughput::Bytes(*size as u64));

        group.bench_with_input(
            BenchmarkId::from_parameter(format!("raw_{}", size)),
            size,
            |b, &size| {
                b.iter(|| {
                    let mut buf = vec![0u8; size];
                    ciphern::hardware_fill_bytes(&mut buf).unwrap();
                });
            },
        );
    }

    group.finish();
}

fn bench_bulk_hardware_rng(c: &mut Criterion) {
    let mut group = c.benchmark_group("bulk_hardware_rng");

    if !is_hardware_rng_available() {
        return;
    }

    for buffer_size in [256, 512, 1024, 2048, 4096].iter() {
        group.throughput(criterion::Throughput::Bytes(*buffer_size as u64));

        group.bench_with_input(
            BenchmarkId::from_parameter(buffer_size),
            buffer_size,
            |b, &buffer_size| {
                let mut rng = BulkHardwareRng::new(buffer_size).unwrap();
                b.iter(|| {
                    let mut dest = vec![0u8; 4096];
                    rng.fill(&mut dest).unwrap();
                });
            },
        );
    }

    group.finish();
}

criterion_group!(
    benches,
    bench_aes256_encrypt,
    bench_sm4_encrypt,
    bench_hardware_rng,
    bench_bulk_hardware_rng
);
criterion_main!(benches);