#base64 #byte-array #aliri #buffer #serialization #utilities


Wrappers that make debugging and using byte arrays a bit nicer

9 releases

0.1.8 Apr 12, 2024
0.1.7 May 27, 2023
0.1.6 Jun 15, 2022
0.1.5 Feb 21, 2022
0.1.3 Apr 29, 2021

#1784 in Encoding

Download history 39295/week @ 2024-03-14 37709/week @ 2024-03-21 48843/week @ 2024-03-28 42135/week @ 2024-04-04 46200/week @ 2024-04-11 48034/week @ 2024-04-18 43224/week @ 2024-04-25 38084/week @ 2024-05-02 42375/week @ 2024-05-09 41252/week @ 2024-05-16 31384/week @ 2024-05-23 32239/week @ 2024-05-30 31142/week @ 2024-06-06 34185/week @ 2024-06-13 32265/week @ 2024-06-20 30763/week @ 2024-06-27

132,965 downloads per month
Used in 8 crates (4 directly)


289 lines

Aliri Base64

Esperanto for "access"


Aliri is a family of crates intended to help build access control, particularly of web APIs, where a token is the primary means of providing access.


The aliri_base64 crate provides some utilities for more easily working with byte arrays and buffers that need to be serialized using Base64 encoding. This is particularly necessary for many of the types that aliri works with, but may also be of use to others as well.

The underlying encoding/decoding mechanism is provided by the base64 crate.

Supported encodings

Base64 and Base64Ref wrap owned and borrowed byte arrays that must be serialized in the standard Base64 encoding with padding.

Base64Url and Base64UrlRef wrap owned and borrowed byte arrays that must be serialized in the URL-safe Base64 encoding with no padding.

Additional encodings may be added in the future, but these were the two primary encodings required to support my base set of use cases.

Unsafe code

Aliri Base64 makes use of two lines of unsafe code. This unsafe code is limited to the functions that allow the Base64Ref and Base64UrlRef to wrap borrowed byte slices. This reinterpretation is safe because these types are transparent wrappers around [u8], use #[repr(transparent)], and thus share the exact same representation as the underlying slice. This is currently necessary as there is currently no way to transmute equivalent representations of dynamically sized values in safe Rust.

For the above reason, this crate uses #![deny(unsafe_code)] rather than #![forbid(unsafe_code)]. The only #![allow(unsafe_code)] in the crate can be located in the private b64_builder! macro.

Note that, because cargo-geiger has difficulty parsing out unsafe usage from within macros, that tool won't report these crates as "radioactive", but probably should. Do your due diligence.