cesr-rs 0.8.0

CESR + KERI primitives for Rust as a single feature-gated, no_std-capable crate
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

use super::{alphabet::b64_index_to_char, error::Error};
#[cfg(feature = "alloc")]
#[allow(
    unused_imports,
    reason = "alloc prelude items; subset used per cfg/feature combination"
)]
use alloc::string::String;
use core::num::NonZeroUsize;

/// Encodes a binary byte stream into a Base64 URL-safe string of exactly
/// `length` characters.
///
/// # Errors
///
/// Returns [`Error::ShortBinaryStream`] if `stream` has fewer bytes than needed
/// to produce `length` Base64 characters.
#[allow(
    clippy::as_conversions,
    clippy::cast_possible_truncation,
    reason = "sextet is masked to 6 bits, always fits u8"
)]
pub fn encode_binary(stream: &[u8], length: NonZeroUsize) -> Result<String, Error> {
    let n = (length.get() * 3).div_ceil(4);
    if n > stream.len() {
        return Err(Error::ShortBinaryStream);
    }
    let mut output = String::with_capacity(length.get());
    let mut accumulator: u32 = 0;
    let mut bits_in_accumulator: u8 = 0;
    for &byte in &stream[..n] {
        accumulator = (accumulator << 8) | u32::from(byte);
        bits_in_accumulator += 8;
        while bits_in_accumulator >= 6 && output.len() < length.get() {
            let shift = bits_in_accumulator - 6;
            let sextet = (accumulator >> shift) as u8;
            let ch = b64_index_to_char(sextet)?;
            output.push(ch);
            bits_in_accumulator -= 6;
            accumulator &= (1 << bits_in_accumulator) - 1;
        }
    }
    Ok(output)
}

#[cfg(test)]
#[allow(
    clippy::shadow_reuse,
    clippy::shadow_same,
    clippy::as_conversions,
    clippy::cast_possible_truncation,
    clippy::unreadable_literal,
    reason = "test code: shadowing for ergonomics, as casts in proptest strategies, long literals from spec"
)]
mod test {
    use super::encode_binary;
    use core::num::NonZeroUsize;
    use rstest::rstest;

    #[rstest]
    #[case(&[0xf8, 0x10, 0x02], 4, "-BAC")]
    #[case(&[0xf8, 0x10, 0x00], 3, "-BA")]
    #[case(&[0xf8, 0x10],2, "-B")]
    #[case(&[0xf8],1, "-")]
    fn code_binary_to_base64_test(
        #[case] stream: &[u8],
        #[case] len: usize,
        #[case] expected: &str,
    ) {
        let length = NonZeroUsize::new(len).unwrap();
        let result = encode_binary(stream, length);
        assert!(result.is_ok());
        let actual = result.unwrap();
        assert_eq!(actual, expected);
    }

    // --- encode_binary edge cases ---

    #[test]
    fn encode_binary_rejects_short_stream() {
        // Request 4 chars (needs ceil(4*3/4) = 3 bytes) but provide only 2
        let len = NonZeroUsize::new(4).unwrap();
        let result = encode_binary(&[0xf8, 0x10], len);
        assert!(result.is_err());
    }

    #[test]
    fn encode_binary_single_byte() {
        let len = NonZeroUsize::new(1).unwrap();
        let result = encode_binary(&[0x00], len).unwrap();
        assert_eq!(result, "A");
    }

    #[test]
    fn encode_binary_all_ones() {
        let len = NonZeroUsize::new(4).unwrap();
        let result = encode_binary(&[0xff, 0xff, 0xff], len).unwrap();
        assert_eq!(result, "____");
    }

    #[test]
    fn encode_binary_all_zeros() {
        let len = NonZeroUsize::new(4).unwrap();
        let result = encode_binary(&[0x00, 0x00, 0x00], len).unwrap();
        assert_eq!(result, "AAAA");
    }
}