wolfcrypt 0.1.4

RustCrypto trait implementations backed by wolfCrypt
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

//! Crypto callback (WOLF_CRYPTO_CB) integration tests.
//!
//! These tests verify the registration/unregistration lifecycle and
//! the callback dispatch mechanism.  Since the actual crypto operations
//! require wolfCrypt objects with devId set (which depends on the
//! wolfCrypt build having WOLF_CRYPTO_CB enabled), these tests focus
//! on the structural properties of the Rust wrapper.

#![cfg(all(feature = "cryptocb", wolfssl_cryptocb))]

use wolfcrypt::cryptocb::{
    register_device, unregister_device, CryptoCallbackResult, CryptoCallbacks, RngRequest,
};

use core::sync::atomic::{AtomicU32, Ordering};

// ---------------------------------------------------------------------------
// A test device that counts RNG calls
// ---------------------------------------------------------------------------

struct CountingRng {
    count: AtomicU32,
}

impl CountingRng {
    fn new() -> Self {
        Self {
            count: AtomicU32::new(0),
        }
    }

    fn call_count(&self) -> u32 {
        self.count.load(Ordering::Relaxed)
    }
}

impl CryptoCallbacks for CountingRng {
    fn rng(&self, req: RngRequest<'_>) -> CryptoCallbackResult {
        // Fill with deterministic pattern (0xAA) to prove it was called.
        for b in req.out.iter_mut() {
            *b = 0xAA;
        }
        self.count.fetch_add(1, Ordering::Relaxed);
        CryptoCallbackResult::Success
    }
    // All other operations fall through to NotAvailable (default).
}

// ---------------------------------------------------------------------------
// A device that returns NotAvailable for everything
// ---------------------------------------------------------------------------

struct NullDevice;

impl CryptoCallbacks for NullDevice {}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

/// Registration succeeds with a valid device ID.
#[test]
fn register_and_unregister() {
    let dev_id = 100; // arbitrary positive ID
    register_device(dev_id, NullDevice).expect("register should succeed");
    unregister_device(dev_id);
}

/// Registering the same device ID twice should succeed (overwrite).
#[test]
fn register_twice_overwrites() {
    let dev_id = 101;
    register_device(dev_id, NullDevice).expect("first register");
    register_device(dev_id, NullDevice).expect("second register (overwrite)");
    unregister_device(dev_id);
}

/// CryptoCallbackResult::to_c returns expected values.
#[test]
fn result_codes() {
    // We can't call to_c directly (it's private), but we can verify
    // the constants used.
    assert_eq!(CryptoCallbackResult::Success, CryptoCallbackResult::Success);
    assert_eq!(
        CryptoCallbackResult::NotAvailable,
        CryptoCallbackResult::NotAvailable
    );
    assert_ne!(
        CryptoCallbackResult::Success,
        CryptoCallbackResult::NotAvailable
    );
    assert_ne!(
        CryptoCallbackResult::Success,
        CryptoCallbackResult::Error(-1)
    );
}

/// The CryptoCallbacks trait has default methods that return NotAvailable.
#[test]
fn default_trait_methods_return_not_available() {
    let dev = NullDevice;
    let mut buf = [0u8; 16];
    assert_eq!(
        dev.rng(RngRequest { out: &mut buf }),
        CryptoCallbackResult::NotAvailable,
    );
}

/// A device that implements rng() returns Success and fills the buffer.
#[test]
fn custom_rng_callback_fills_buffer() {
    let dev = CountingRng::new();
    let mut buf = [0u8; 32];
    let result = dev.rng(RngRequest { out: &mut buf });
    assert_eq!(result, CryptoCallbackResult::Success);
    assert_eq!(buf, [0xAA; 32], "buffer should be filled by callback");
    assert_eq!(dev.call_count(), 1);
}

/// Registering with INVALID_DEVID should panic.
#[test]
#[should_panic(expected = "INVALID_DEVID")]
fn register_invalid_devid_panics() {
    register_device(-2, NullDevice).unwrap();
}

/// Multiple distinct devices can be registered simultaneously.
#[test]
fn multiple_devices() {
    let ids = [200, 201, 202];
    for &id in &ids {
        register_device(id, NullDevice).expect("register");
    }
    for &id in &ids {
        unregister_device(id);
    }
}