taler-rust

base64.rs (5629B)

---

 /*
   This file is part of TALER
   Copyright (C) 2026 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use std::fmt::Display;
 
 pub const BASE64_ALPHABET: &[u8] =
     b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 /** Encoded bytes len of base64 with padding */
 #[inline]
 const fn encoded_len(len: usize) -> usize {
     (len * 4).div_ceil(3).next_multiple_of(4)
 }
 
 /** Encode a chunk using base64 */
 #[inline(always)]
 fn encode_chunk(chunk: &[u8], encoded: &mut [u8]) {
     let mut buf = [0u8; 3];
     for (i, &b) in chunk.iter().enumerate() {
         buf[i] = b;
     }
     encoded[0] = BASE64_ALPHABET[((buf[0] & 0xFC) >> 2) as usize];
     encoded[1] = BASE64_ALPHABET[(((buf[0] & 0x03) << 4) | ((buf[1] & 0xF0) >> 4)) as usize];
     if chunk.len() > 1 {
         encoded[2] = BASE64_ALPHABET[(((buf[1] & 0x0F) << 2) | ((buf[2] & 0xC0) >> 6)) as usize];
     }
     if chunk.len() > 2 {
         encoded[3] = BASE64_ALPHABET[(buf[2] & 0x3F) as usize];
     }
 }
 
 /** Encode bytes using standard base64 with `=` padding */
 pub fn encode(bytes: impl AsRef<[u8]>) -> String {
     let bytes = bytes.as_ref();
     let mut buf = vec![b'='; encoded_len(bytes.len())];
 
     for (chunk, buf) in bytes.chunks(3).zip(buf.chunks_exact_mut(4)) {
         encode_chunk(chunk, buf)
     }
 
     // SAFETY: only contains ASCII characters from BASE64_ALPHABET or b'='
     unsafe { String::from_utf8_unchecked(buf) }
 }
 
 /** Format bytes using standard base64 with `=` padding */
 pub fn fmt(bytes: impl AsRef<[u8]>) -> impl Display {
     std::fmt::from_fn(move |f| {
         for chunk in bytes.as_ref().chunks(3) {
             let mut tmp = [0u8; 3];
             for (i, &b) in chunk.iter().enumerate() {
                 tmp[i] = b;
             }
 
             let mut out = [b'='; 4];
             out[0] = BASE64_ALPHABET[((tmp[0] & 0xFC) >> 2) as usize];
             out[1] = BASE64_ALPHABET[(((tmp[0] & 0x03) << 4) | ((tmp[1] & 0xF0) >> 4)) as usize];
             if chunk.len() > 1 {
                 out[2] =
                     BASE64_ALPHABET[(((tmp[1] & 0x0F) << 2) | ((tmp[2] & 0xC0) >> 6)) as usize];
             }
             if chunk.len() > 2 {
                 out[3] = BASE64_ALPHABET[(tmp[2] & 0x3F) as usize];
             }
 
             // SAFETY: out contains only ASCII characters from BASE64_ALPHABET or b'='
             f.write_str(unsafe { std::str::from_utf8_unchecked(&out) })?;
         }
         Ok(())
     })
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
 pub enum Base64Error {
     #[error("invalid base64 format")]
     Format,
     #[error("invalid length: base64 input must be a multiple of 4")]
     Length,
 }
 
 const BASE64_INV: [u8; 256] = {
     let mut table = [255u8; 256];
     let mut i = 0;
     while i < 64 {
         table[BASE64_ALPHABET[i] as usize] = i as u8;
         i += 1;
     }
     table
 };
 
 /** Unpadded decoded length from a padded base64 string */
 fn decoded_len(encoded: &[u8]) -> usize {
     let padding = encoded.iter().rev().take_while(|&&b| b == b'=').count();
     encoded.len() * 3 / 4 - padding
 }
 
 /** Decode a standard base64 string (with `=` padding) */
 pub fn decode(encoded: impl AsRef<[u8]>) -> Result<Vec<u8>, Base64Error> {
     let encoded = encoded.as_ref();
     if encoded.len() % 4 != 0 {
         return Err(Base64Error::Length);
     }
 
     let out_len = decoded_len(encoded);
     let mut decoded = Vec::with_capacity(out_len);
     let mut invalid = false;
 
     for chunk in encoded.chunks(4) {
         let mut buf = [0u8; 4];
         // Lookup chunk
         for (i, &b) in chunk.iter().enumerate() {
             buf[i] = if b == b'=' { 0 } else { BASE64_INV[b as usize] };
         }
 
         // Check chunk validity
         invalid |= buf.contains(&255);
 
         // Decode chunk
         decoded.push((buf[0] << 2) | (buf[1] >> 4));
         if chunk[2] != b'=' {
             decoded.push((buf[1] << 4) | (buf[2] >> 2));
         }
         if chunk[3] != b'=' {
             decoded.push((buf[2] << 6) | buf[3]);
         }
     }
 
     if invalid {
         return Err(Base64Error::Format);
     }
 
     Ok(decoded)
 }
 
 #[cfg(test)]
 mod test {
     use crate::encoding::base64::{Base64Error, decode, encode, fmt};
 
     #[test]
     fn base64() {
         // RFC test vectors
         for (decoded, encoded) in [
             ("", ""),
             ("f", "Zg=="),
             ("fo", "Zm8="),
             ("foo", "Zm9v"),
             ("foob", "Zm9vYg=="),
             ("fooba", "Zm9vYmE="),
             ("foobar", "Zm9vYmFy"),
         ] {
             assert_eq!(encode(decoded.as_bytes()), encoded);
             assert_eq!(fmt(decoded).to_string(), encoded);
             assert_eq!(decode(encoded.as_bytes()).unwrap(), decoded.as_bytes());
         }
 
         // Invalid length
         assert_eq!(decode(b"Zg="), Err(Base64Error::Length));
         assert_eq!(decode(b"Z"), Err(Base64Error::Length));
 
         // Invalid characters
         assert_eq!(decode(b"Zg=!"), Err(Base64Error::Format));
         assert_eq!(decode(b"Z\x00=="), Err(Base64Error::Format));
     }
 }