Something went wrong. Try again.
Identities for entities did.bot
agent llm did
Something went wrong. Try again.
6.8 kB · 194 lines
Rust
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195//! Base32 and base64, in the two exact dialects atproto uses.//!//! Both are strict, because the one property this whole crate exists to hold//! is that a value has exactly one encoding. Each refuses padding, and each//! refuses a final character whose unused low bits are set, which would//! decode to the same bytes and re-encode to a different string.//!//! * base32, lowercase, no padding, RFC 4648 alphabet. This is multibase `b`,//! which is the only string form atproto permits for a CID.//! * base64, standard alphabet (`+` and `/`, not the URL-safe pair), no//! padding. This is the `$bytes` representation in the JSON form of the//! data model, and the `base64` crate's `STANDARD_NO_PAD` engine, which//! refuses both.
use base64::engine::general_purpose::STANDARD_NO_PAD;use base64::Engine as _;
/// Why a string is not valid lowercase unpadded base32.#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]pub enum DecodeError { /// A character outside the alphabet, including `=`: padding is refused /// rather than tolerated, because the protocol specifies unpadded and a /// padded string is a second encoding of the same bytes. #[error("invalid character {0:?}")] InvalidCharacter(char), /// A length that no whole number of bytes can produce, such as a single /// leftover character. The value is how many bits were left over. #[error("truncated: {0} leftover bits encode no whole byte")] Truncated(u32), /// The final character carries bits that the decoded bytes do not use. /// Decoding would silently discard them and re-encoding would produce a /// different string, so it is refused. #[error("the final character has {0} non-zero unused bits")] UnusedBits(u32),}
/// The lowercase RFC 4648 base32 alphabet, which is multibase `b`.const BASE32: &[u8; 32] = b"abcdefghijklmnopqrstuvwxyz234567";
/// Decodes a bit-packed string in `alphabet`, `bits` bits per character,/// under both strictness rules: no padding, and no set bits beyond the last/// whole byte.fn decode(text: &str, alphabet: &[u8], bits: u32) -> Result<Vec<u8>, DecodeError> { let mut out = Vec::with_capacity(text.len() * bits as usize / 8); let mut buffer: u32 = 0; let mut held: u32 = 0; for ch in text.chars() { let value = alphabet .iter() .position(|c| char::from(*c) == ch) .ok_or(DecodeError::InvalidCharacter(ch))?; buffer = (buffer << bits) | value as u32; held += bits; if held >= 8 { held -= 8; out.push((buffer >> held) as u8); } } // What is left in `buffer` is the tail of the last character. It must be // zero, and there must not be enough of it to have been a whole byte. if held >= bits { return Err(DecodeError::Truncated(held)); } let leftover = buffer & ((1 << held) - 1); if leftover != 0 { return Err(DecodeError::UnusedBits(leftover.count_ones())); } Ok(out)}
/// Encodes bytes bit-packed into `alphabet`, `bits` bits per character.fn encode(bytes: &[u8], alphabet: &[u8], bits: u32) -> String { let mut out = String::with_capacity(bytes.len() * 8 / bits as usize + 1); let mut buffer: u32 = 0; let mut held: u32 = 0; for byte in bytes { buffer = (buffer << 8) | u32::from(*byte); held += 8; while held >= bits { held -= bits; out.push(alphabet[((buffer >> held) & ((1 << bits) - 1)) as usize] as char); } } if held > 0 { let index = (buffer << (bits - held)) & ((1 << bits) - 1); out.push(alphabet[index as usize] as char); } out}
/// Decodes lowercase unpadded base32.pub fn base32_decode(text: &str) -> Result<Vec<u8>, DecodeError> { decode(text, BASE32, 5)}
/// Encodes lowercase unpadded base32.pub fn base32_encode(bytes: &[u8]) -> String { encode(bytes, BASE32, 5)}
/// Decodes standard unpadded base64.pub fn base64_decode(text: &str) -> Result<Vec<u8>, base64::DecodeError> { STANDARD_NO_PAD.decode(text)}
/// Encodes standard unpadded base64.pub fn base64_encode(bytes: &[u8]) -> String { STANDARD_NO_PAD.encode(bytes)}
#[cfg(test)]mod tests { use super::*;
#[test] fn base64_round_trips_every_tail_length() { for len in 0..8usize { let bytes: Vec<u8> = (0..len) .map(|i| (i as u8).wrapping_mul(37).wrapping_add(9)) .collect(); let text = base64_encode(&bytes); assert!(!text.contains('='), "{text:?} is padded"); assert_eq!(base64_decode(&text), Ok(bytes)); } }
#[test] fn base32_round_trips_every_tail_length() { for len in 0..8usize { let bytes: Vec<u8> = (0..len) .map(|i| (i as u8).wrapping_mul(53).wrapping_add(3)) .collect(); let text = base32_encode(&bytes); assert_eq!(base32_decode(&text), Ok(bytes)); } }
#[test] fn padding_is_refused() { assert_eq!( base64_decode("YWJjZA=="), Err(base64::DecodeError::InvalidPadding) ); }
#[test] fn a_set_bit_beyond_the_last_byte_is_refused() { // "QQ" decodes to one byte and leaves four bits; "QR" sets one of // them. A lenient decoder returns the same byte for both, which is // two strings for one value. assert_eq!(base64_decode("QQ"), Ok(vec![0x41])); assert_eq!( base64_decode("QR"), Err(base64::DecodeError::InvalidLastSymbol(1, b'R')) ); }
#[test] fn a_lone_trailing_character_encodes_no_byte() { assert_eq!( base64_decode("QQQQQ"), Err(base64::DecodeError::InvalidLength(5)) ); }
#[test] fn the_url_safe_alphabet_is_not_the_one_atproto_uses() { assert_eq!( base64_decode("-_"), Err(base64::DecodeError::InvalidByte(0, b'-')) ); }
/// The base32 half of the same rules, which this file decodes itself. #[test] fn base32_refuses_padding_and_set_unused_bits() { assert_eq!( base32_decode("mfrgg==="), Err(DecodeError::InvalidCharacter('=')) ); // "ae" decodes to one byte and leaves two bits; "af" sets one. assert_eq!(base32_decode("ae"), Ok(vec![0x01])); assert_eq!(base32_decode("af"), Err(DecodeError::UnusedBits(1))); assert_eq!(base32_decode("a"), Err(DecodeError::Truncated(5))); }
#[test] fn uppercase_base32_is_a_different_multibase() { assert_eq!( base32_decode("MFRGG"), Err(DecodeError::InvalidCharacter('M')) ); }}