lockbox 0.1.0

Easy-to-use, secure, and efficient encryption and decryption using the AES-GCM (Galois/Counter Mode) algorithm.
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

/// TagEncoder for encoding tags using the TLV scheme inspired by DER encoding.
pub(crate) struct TagEncoder;

impl TagEncoder {
    const RESERVED: u8 = 1;
    const BYTE_LENGTH: usize = 256;
    const HALF_BYTE: usize = 128;

    /// Encodes a value using the TLV scheme inspired by DER encoding.
    pub fn encode(value: &[u8]) -> Vec<u8> {
        let value_len = value.len();

        if value_len >= Self::HALF_BYTE {
            let bitstring = Self::to_bitstring(value_len);
            Self::encode_with_bitstring(&bitstring, value)
        } else {
            // For value lengths less than 128, encode directly
            let mut encoded = Vec::with_capacity(2 + value_len);
            encoded.push(Self::RESERVED);
            encoded.push(value_len as u8); // Length byte
            encoded.extend_from_slice(value);
            encoded
        }
    }

    /// Handles encoding when the length of the value is 128 bytes or more.
    fn encode_with_bitstring(bitstring: &[u8], value: &[u8]) -> Vec<u8> {
        let bitstring_len = bitstring.len();
        let value_len = value.len();

        let mut encoded = Vec::with_capacity(2 + bitstring_len + value_len);
        encoded.push(Self::RESERVED);
        encoded.push((Self::HALF_BYTE + bitstring_len) as u8); // Length field with the most significant bit set
        encoded.extend_from_slice(bitstring); // Length bytes
        encoded.extend_from_slice(value); // Value bytes
        encoded
    }

    /// Converts a decimal value to its corresponding byte sequence.
    fn to_bitstring(decimal: usize) -> Vec<u8> {
        let mut result = Vec::new();
        let mut current = decimal;

        while current > 0 {
            result.push((current % Self::BYTE_LENGTH) as u8);
            current /= Self::BYTE_LENGTH;
        }

        result.reverse();
        result
    }
}

pub(crate) struct TagDecoder;

impl TagDecoder {
    const OFFSET: usize = 2;
    const BYTE_LENGTH: usize = 256;
    const HALF_BYTE: usize = 128;

    /// Decodes the message and extracts the tag and the remainder.
    pub fn decode(message: &[u8]) -> Result<(Vec<u8>, Vec<u8>), &'static str> {
        let length = Self::tag_length(message)?;

        if message.len() < length {
            return Err("Invalid message length");
        }

        // Split the message into TLV and remainder
        let (tlv, remainder) = message.split_at(length);

        // Extract the tag
        let tag = Self::tag(tlv)?;
        Ok((tag, remainder.to_vec()))
    }

    /// Calculates the length of the tag based on the TLV encoding.
    fn tag_length(message: &[u8]) -> Result<usize, &'static str> {
        if message.len() < 2 {
            return Err("Invalid message length");
        }

        let len = message[1] as usize;
        let rest = &message[2..];

        if len >= Self::HALF_BYTE {
            Ok(Self::OFFSET + len - Self::HALF_BYTE
                + Self::value_bytes(rest, len - Self::HALF_BYTE))
        } else {
            Ok(Self::OFFSET + len)
        }
    }

    /// Extracts the tag from the TLV encoded message.
    fn tag(tlv: &[u8]) -> Result<Vec<u8>, &'static str> {
        if tlv.len() < 2 {
            return Err("Invalid TLV format");
        }

        let len = tlv[1] as usize;
        let rest = &tlv[2..];

        if len >= Self::HALF_BYTE {
            let size = len - Self::HALF_BYTE;
            if rest.len() < size {
                return Err("Invalid TLV format");
            }

            Ok(rest[size..].to_vec())
        } else {
            Ok(rest.to_vec())
        }
    }

    /// Calculates the number of bytes needed to represent the value based on the list.
    fn value_bytes(list: &[u8], num_bytes: usize) -> usize {
        list.iter()
            .take(num_bytes)
            .fold(0, |acc, &value| acc * Self::BYTE_LENGTH + value as usize)
    }
}