Struct Base64UrlBytes 

pub struct Base64UrlBytes(/* private fields */);

A wrapper around raw bytes that serializes to/from base64url encoding.

This type provides:

• Base64url encoding without padding (per RFC 7517)
• Constant-time base64 operations via base64ct
• Automatic memory zeroing on drop via zeroize
• Explicit constant-time byte comparison via Base64UrlBytes::ct_eq

Security Note

PartialEq for this type is a regular byte equality check and is not guaranteed to be constant-time. For secret-dependent comparisons, use Base64UrlBytes::ct_eq.

Examples

use jwk_simple::encoding::Base64UrlBytes;

// Create from raw bytes
let bytes = Base64UrlBytes::new(vec![1, 2, 3, 4]);

// Serialize to JSON (base64url encoded)
let json = serde_json::to_string(&bytes).unwrap();
assert_eq!(json, "\"AQIDBA\"");

// Deserialize from JSON
let decoded: Base64UrlBytes = serde_json::from_str(&json).unwrap();
assert_eq!(decoded.as_bytes(), &[1, 2, 3, 4]);

Implementations

impl Base64UrlBytes

pub fn new(bytes: Vec<u8>) -> Self

Creates a new Base64UrlBytes from raw bytes.

Examples

use jwk_simple::encoding::Base64UrlBytes;

let bytes = Base64UrlBytes::new(vec![0x01, 0x02, 0x03]);
assert_eq!(bytes.len(), 3);

pub fn from_base64url(encoded: &str) -> Result<Self>

Creates a Base64UrlBytes by decoding a base64url string.

Errors

Returns an error if the input is not valid base64url.

Examples

use jwk_simple::encoding::Base64UrlBytes;

let bytes = Base64UrlBytes::from_base64url("AQIDBA").unwrap();
assert_eq!(bytes.as_bytes(), &[1, 2, 3, 4]);

pub fn to_base64url(&self) -> String

Encodes the bytes as a base64url string (without padding).

Examples

use jwk_simple::encoding::Base64UrlBytes;

let bytes = Base64UrlBytes::new(vec![1, 2, 3, 4]);
assert_eq!(bytes.to_base64url(), "AQIDBA");

pub fn as_bytes(&self) -> &[u8]

Returns a reference to the underlying bytes.

Examples

use jwk_simple::encoding::Base64UrlBytes;

let bytes = Base64UrlBytes::new(vec![1, 2, 3]);
assert_eq!(bytes.as_bytes(), &[1, 2, 3]);

pub fn len(&self) -> usize

Returns the length of the underlying bytes.

Examples

use jwk_simple::encoding::Base64UrlBytes;

let bytes = Base64UrlBytes::new(vec![1, 2, 3]);
assert_eq!(bytes.len(), 3);

pub fn is_empty(&self) -> bool

Returns true if the underlying bytes are empty.

Examples

use jwk_simple::encoding::Base64UrlBytes;

let empty = Base64UrlBytes::new(vec![]);
assert!(empty.is_empty());

let not_empty = Base64UrlBytes::new(vec![1]);
assert!(!not_empty.is_empty());

pub fn into_bytes(self) -> Zeroizing<Vec<u8>>

Consumes the wrapper and returns the underlying bytes.

The returned bytes are wrapped in Zeroizing to ensure they are zeroized on drop, preserving the security guarantees of this type.

Examples

use jwk_simple::encoding::Base64UrlBytes;

let bytes = Base64UrlBytes::new(vec![1, 2, 3]);
let raw = bytes.into_bytes();
assert_eq!(&*raw, &vec![1, 2, 3]);

pub fn ct_eq(&self, other: &Self) -> bool

Performs a constant-time equality comparison.

Use this method for secret-dependent decisions.

Trait Implementations

impl AsRef<[u8]> for Base64UrlBytes

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Base64UrlBytes

fn clone(&self) -> Base64UrlBytes

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ConstantTimeEq for Base64UrlBytes

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl Debug for Base64UrlBytes

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Base64UrlBytes

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Drop for Base64UrlBytes

fn drop(&mut self)

Executes the destructor for this type.

impl From<&[u8]> for Base64UrlBytes

fn from(bytes: &[u8]) -> Self

Converts to this type from the input type.

impl From<Vec<u8>> for Base64UrlBytes

fn from(bytes: Vec<u8>) -> Self

Converts to this type from the input type.

impl Hash for Base64UrlBytes

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Base64UrlBytes

fn eq(&self, other: &Base64UrlBytes) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Base64UrlBytes

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Zeroize for Base64UrlBytes

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Eq for Base64UrlBytes

impl StructuralPartialEq for Base64UrlBytes