1use alloc::vec::Vec;
29use core::fmt;
30
31pub const BASIC_AUTH_MIN_LEN: usize = 16;
33
34pub const BASIC_AUTH_MAX_LEN: usize = 64;
43
44pub const BASIC_AUTH_INTEROPERABLE_MAX_LEN: usize = 40;
49
50pub const AUTHORIZATION_KEY_MIN_BYTES: usize = 16;
52
53pub const AUTHORIZATION_KEY_MAX_BYTES: usize = 20;
55
56pub const PASSWORD_STRING_CHARSET: &[u8; 71] =
58 b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789*-_=:+|@.";
59
60#[derive(Clone, Copy, Debug, PartialEq, Eq)]
62#[non_exhaustive]
63pub enum CredentialError {
64 PasswordLength(usize),
67 Character(char),
69 NotHex,
71 KeyLength(usize),
74 Entropy,
76}
77
78impl fmt::Display for CredentialError {
79 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
80 match self {
81 CredentialError::PasswordLength(len) => write!(
82 f,
83 "BasicAuthPassword is {len} characters; OCPP 2.x allows {BASIC_AUTH_MIN_LEN} to the \
84 variable's maxLimit, at most {BASIC_AUTH_MAX_LEN} (A00.FR.205)"
85 ),
86 CredentialError::Character(c) => write!(
87 f,
88 "BasicAuthPassword contains {c:?}; a passwordString allows only a-z, A-Z, 0-9 and * - _ = : + | @ ."
89 ),
90 CredentialError::NotHex => {
91 f.write_str("the 1.6 AuthorizationKey must be an even-length hexadecimal string")
92 }
93 CredentialError::KeyLength(len) => write!(
94 f,
95 "the 1.6 AuthorizationKey is {len} bytes; it must be \
96 {AUTHORIZATION_KEY_MIN_BYTES}–{AUTHORIZATION_KEY_MAX_BYTES} (A00.FR.205)"
97 ),
98 CredentialError::Entropy => f.write_str("the operating system's entropy source failed"),
99 }
100 }
101}
102
103impl core::error::Error for CredentialError {}
104
105pub fn check_password(text: &str, max_len: usize) -> Result<(), CredentialError> {
111 if let Some(c) = text
112 .chars()
113 .find(|c| !c.is_ascii() || !PASSWORD_STRING_CHARSET.contains(&(*c as u8)))
114 {
115 return Err(CredentialError::Character(c));
116 }
117 if !(BASIC_AUTH_MIN_LEN..=max_len).contains(&text.len()) {
119 return Err(CredentialError::PasswordLength(text.len()));
120 }
121 Ok(())
122}
123
124pub fn authorization_key_octets(hex: &str) -> Result<Vec<u8>, CredentialError> {
128 let text = hex.trim().as_bytes();
129 if text.is_empty() || !text.len().is_multiple_of(2) {
130 return Err(CredentialError::NotHex);
131 }
132 let bytes = text
133 .chunks(2)
134 .map(|pair| Some(nibble(pair[0])? << 4 | nibble(pair[1])?))
135 .collect::<Option<Vec<u8>>>()
136 .ok_or(CredentialError::NotHex)?;
137 if !(AUTHORIZATION_KEY_MIN_BYTES..=AUTHORIZATION_KEY_MAX_BYTES).contains(&bytes.len()) {
138 return Err(CredentialError::KeyLength(bytes.len()));
139 }
140 Ok(bytes)
141}
142
143const fn nibble(digit: u8) -> Option<u8> {
144 match digit {
145 b'0'..=b'9' => Some(digit - b'0'),
146 b'a'..=b'f' => Some(digit - b'a' + 10),
147 b'A'..=b'F' => Some(digit - b'A' + 10),
148 _ => None,
149 }
150}
151
152#[cfg(test)]
153mod tests {
154 use super::*;
155
156 #[test]
157 fn the_charset_is_the_one_part_2_lists() {
158 assert_eq!(PASSWORD_STRING_CHARSET.len(), 71);
159 let mut sorted = PASSWORD_STRING_CHARSET.to_vec();
160 sorted.sort_unstable();
161 sorted.dedup();
162 assert_eq!(sorted.len(), 71, "no duplicates");
163 for c in b"*-_=:+|@." {
164 assert!(PASSWORD_STRING_CHARSET.contains(c));
165 }
166 }
167
168 #[test]
169 fn a_password_is_a_password_string_of_16_to_the_limit() {
170 assert!(check_password(&"a".repeat(16), 40).is_ok());
171 assert!(check_password(&"Z9*-_=:+|@.".repeat(4)[..40], 40).is_ok());
172 assert_eq!(
173 check_password(&"a".repeat(15), 40),
174 Err(CredentialError::PasswordLength(15))
175 );
176 assert_eq!(
177 check_password(&"a".repeat(41), 40),
178 Err(CredentialError::PasswordLength(41))
179 );
180 assert!(check_password(&"a".repeat(64), BASIC_AUTH_MAX_LEN).is_ok());
181 assert_eq!(
183 check_password("short!", 40),
184 Err(CredentialError::Character('!'))
185 );
186 assert_eq!(
187 check_password("sixteen chars ok", 40),
188 Err(CredentialError::Character(' '))
189 );
190 assert_eq!(
191 check_password("sixteen-chars-ü-ok", 40),
192 Err(CredentialError::Character('ü'))
193 );
194 }
195
196 #[test]
197 fn an_authorization_key_is_16_to_20_octets_of_hex() {
198 assert_eq!(
199 authorization_key_octets("000102030405060708090a0b0c0d0E0F").unwrap(),
200 (0..16).collect::<Vec<u8>>()
201 );
202 assert_eq!(
203 authorization_key_octets(" 00112233445566778899aabbccddeeff\n")
204 .unwrap()
205 .len(),
206 16
207 );
208 assert_eq!(authorization_key_octets("zz"), Err(CredentialError::NotHex));
209 assert_eq!(
210 authorization_key_octets("abc"),
211 Err(CredentialError::NotHex)
212 );
213 assert_eq!(authorization_key_octets(""), Err(CredentialError::NotHex));
214 assert_eq!(
215 authorization_key_octets(&"ab".repeat(15)),
216 Err(CredentialError::KeyLength(15))
217 );
218 assert_eq!(
219 authorization_key_octets(&"ab".repeat(21)),
220 Err(CredentialError::KeyLength(21))
221 );
222 assert!(authorization_key_octets(&"ab".repeat(20)).is_ok());
223 assert_eq!(
225 authorization_key_octets(&"0g".repeat(16)),
226 Err(CredentialError::NotHex)
227 );
228 }
229}