botan-sys 1.20250506.0

FFI wrapper for Botan cryptography 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

extern crate botan_sys;

use std::ffi::CString;

use botan_sys::*;

#[test]
fn test_hex() {
    let bin = vec![0x42, 0x23, 0x45, 0x8F];
    let mut out = vec![0; bin.len() * 2];

    unsafe {
        assert_eq!(
            botan_hex_encode(bin.as_ptr(), bin.len(), out.as_mut_ptr(), 0),
            0
        );
    }

    assert_eq!(out[0], '4' as _);
    assert_eq!(out[1], '2' as _);
    assert_eq!(out[2], '2' as _);
    assert_eq!(out[3], '3' as _);
    assert_eq!(out[4], '4' as _);
    assert_eq!(out[5], '5' as _);
    assert_eq!(out[6], '8' as _);
    assert_eq!(out[7], 'F' as _);

    let mut decoded = vec![0; 1024];
    let mut out_len = decoded.len();

    unsafe {
        assert_eq!(
            botan_hex_decode(out.as_ptr(), out.len(), decoded.as_mut_ptr(), &mut out_len),
            0
        );
    }

    assert_eq!(out_len, bin.len());
    decoded.resize(out_len, 0);
    assert_eq!(bin, decoded);
}

#[test]
fn test_hash() {
    unsafe {
        let mut hash = std::ptr::null_mut();
        let hash_name = CString::new("SHA-384").unwrap();
        assert_eq!(botan_hash_init(&mut hash, hash_name.as_ptr(), 0u32), 0);

        let input = [97, 98, 99];
        assert_eq!(botan_hash_update(hash, input.as_ptr(), input.len()), 0);
        assert_eq!(botan_hash_update(hash, input.as_ptr(), input.len()), 0);

        let mut output_len = 0;
        assert_eq!(botan_hash_output_length(hash, &mut output_len), 0);
        assert!(output_len == 48);

        let mut digest = vec![0u8; output_len];
        assert_eq!(botan_hash_final(hash, digest.as_mut_ptr()), 0);

        assert_eq!(digest[0], 0xCA);
        assert_eq!(digest[1], 0xF3);
        assert_eq!(digest[47], 0x8D);

        assert_eq!(botan_hash_destroy(hash), 0);
    }
}

#[test]
fn test_version() {
    unsafe {
        let api_version = botan_ffi_api_version();

        assert!(botan_ffi_supports_api(api_version) == 0);
        assert!(botan_ffi_supports_api(api_version + 1) != 0);
    }
}

#[test]
fn test_rng() {
    unsafe {
        let mut rng = std::ptr::null_mut();
        botan_rng_init(&mut rng, std::ptr::null());

        let mut rng1 = vec![0u8; 16];
        let mut rng2 = vec![0u8; 16];
        assert_eq!(botan_rng_get(rng, rng1.as_mut_ptr(), rng1.len()), 0);
        assert_eq!(botan_rng_get(rng, rng2.as_mut_ptr(), rng2.len()), 0);

        assert!(rng1 != rng2);

        assert_eq!(botan_rng_destroy(rng), 0);
    }
}