Skip to main content

hyper64/
lib.rs

1#![no_std]
2#![doc = include_str!("../README.md")]
3
4#[cfg(feature = "alloc")]
5extern crate alloc;
6
7#[cfg(feature = "std")]
8extern crate std;
9
10pub mod alphabet;
11pub mod const_fn;
12pub mod constant_time;
13pub mod decode;
14pub mod display;
15pub mod encode;
16pub mod engine;
17pub mod error;
18pub mod permissive;
19pub mod scalar;
20pub mod simd;
21
22#[cfg(feature = "std")]
23pub mod io;
24
25#[cfg(feature = "serde")]
26pub mod serde;
27
28// Re-exports of key types
29pub use alphabet::{
30    Config, STANDARD_DECODE_TABLE, STANDARD_ENCODE_TABLE, URL_SAFE_DECODE_TABLE,
31    URL_SAFE_ENCODE_TABLE,
32};
33pub use constant_time::{ct_eq, decode_slice_ct as decode_constant_time};
34pub use decode::{decode_in_place, decode_to_slice};
35pub use display::{Base64Display, display, display_config, display_url_safe};
36pub use encode::{Base64ChunkIter, encode_iter, encode_to_slice};
37pub use engine::Engine;
38pub use error::DecodeError;
39pub use permissive::{PemBlock, decode_pem_in_place, decode_permissive_in_place};
40#[cfg(feature = "alloc")]
41pub use permissive::{decode_pem, decode_permissive};
42pub use scalar::encoded_len;
43pub use simd::{has_avx2, has_avx512, has_neon, has_ssse3, has_wasm_simd128};
44
45#[cfg(feature = "std")]
46pub use io::{DecoderReader, EncoderWriter};
47
48#[cfg(feature = "tokio")]
49pub use io::{AsyncDecoderReader, AsyncEncoderWriter};
50
51#[cfg(feature = "serde")]
52pub use crate::serde::Base64;
53
54// Default profile shortcuts
55pub const STANDARD: Config = Config::STANDARD;
56pub const STANDARD_NO_PAD: Config = Config::STANDARD_NO_PAD;
57pub const URL_SAFE: Config = Config::URL_SAFE;
58pub const URL_SAFE_NO_PAD: Config = Config::URL_SAFE_NO_PAD;
59
60/// Encodes input bytes to a standard Base64 [`alloc::string::String`].
61#[cfg(feature = "alloc")]
62#[inline]
63pub fn encode(input: impl AsRef<[u8]>) -> alloc::string::String {
64    encode::encode(input, &STANDARD)
65}
66
67/// Encodes input bytes using the specified configuration.
68#[cfg(feature = "alloc")]
69#[inline]
70pub fn encode_config(input: impl AsRef<[u8]>, config: &Config) -> alloc::string::String {
71    encode::encode(input, config)
72}
73
74/// Decodes standard Base64 bytes or string into a [`alloc::vec::Vec<u8>`].
75#[cfg(feature = "alloc")]
76#[inline]
77pub fn decode(input: impl AsRef<[u8]>) -> Result<alloc::vec::Vec<u8>, DecodeError> {
78    decode::decode(input, &STANDARD)
79}
80
81/// Decodes Base64 data using the specified configuration into a [`alloc::vec::Vec<u8>`].
82#[cfg(feature = "alloc")]
83#[inline]
84pub fn decode_config(
85    input: impl AsRef<[u8]>,
86    config: &Config,
87) -> Result<alloc::vec::Vec<u8>, DecodeError> {
88    decode::decode(input, config)
89}
90
91/// Constant-time encode for cryptographic/secret data (mitigates cache-timing attacks).
92#[inline]
93pub fn encode_constant_time(input: &[u8], output: &mut [u8]) -> usize {
94    constant_time::encode_slice_ct(input, output)
95}