base64

Base64 encoding and decoding following the standard Base64 alphabet (RFC 4648). Encodes binary data to ASCII text and decodes it back.

Usage

import base64

fn main() {
    let src = "Hello, World!"
    let src_len = 13

    // Calculate output size and allocate
    let enc_len = b64_encoded_len(src_len)
    let enc: &i8 = alloc_pages(1)

    // Encode
    let n = b64_encode(src, src_len, enc)
    // enc[0..n] contains "SGVsbG8sIFdvcmxkIQ=="
    syscall(1, 1, enc, n)

    // Decode
    let dec: &i8 = alloc_pages(1)
    let m = b64_decode(enc, n, dec)
    // dec[0..m] contains "Hello, World!"
    syscall(1, 1, dec, m)
}

Function Reference

Detailed API

b64_encode

fn b64_encode(src: &i8, src_len: i64, dst: &i8) -> i64

Encode src_len bytes from src into Base64, writing the result to dst. The output includes = padding to make the output length a multiple of 4. The caller must ensure dst has enough space (use b64_encoded_len to calculate).

let enc: &i8 = alloc_pages(1)

// Encode "Man"
let n = b64_encode("Man", 3, enc)
// enc[0..n] contains "TWFu"
print(n)   // 4

// Encode with padding
let n2 = b64_encode("Ma", 2, enc)
// enc[0..n2] contains "TWE="
print(n2)  // 4

// Single byte
let n3 = b64_encode("M", 1, enc)
// enc[0..n3] contains "TQ=="
print(n3)  // 4

Returns: Number of bytes written to dst.

b64_decode

fn b64_decode(src: &i8, src_len: i64, dst: &i8) -> i64

Decode Base64 text from src back into binary bytes, writing to dst. Handles = padding. The caller must ensure dst has enough space (use b64_decoded_len).

let dec: &i8 = alloc_pages(1)

let n = b64_decode("TWFu", 4, dec)
// dec[0..n] contains "Man"
print(n)   // 3

let n2 = b64_decode("SGVsbG8=", 8, dec)
// dec[0..n2] contains "Hello"
print(n2)  // 5

Returns: Number of decoded bytes written to dst.

b64_encoded_len

fn b64_encoded_len(src_len: i64) -> i64

Calculate the length of the Base64-encoded output for a given input length. The result is always a multiple of 4 (includes padding).

print(b64_encoded_len(3))    // 4
print(b64_encoded_len(4))    // 8
print(b64_encoded_len(1))    // 4
print(b64_encoded_len(0))    // 0

Returns: Encoded output length in bytes.

b64_decoded_len

fn b64_decoded_len(src_len: i64) -> i64

Calculate the maximum length of decoded output for a given Base64 input length. The actual decoded length may be slightly shorter due to padding.

print(b64_decoded_len(4))    // 3
print(b64_decoded_len(8))    // 6

Returns: Maximum decoded output length.

b64_char

fn b64_char(idx: i64) -> i64

Get the Base64 alphabet character at index 0-63. The standard Base64 alphabet is A-Z, a-z, 0-9, +, /.

print(b64_char(0))    // 65 (ASCII 'A')
print(b64_char(26))   // 97 (ASCII 'a')
print(b64_char(62))   // 43 (ASCII '+')
print(b64_char(63))   // 47 (ASCII '/')

b64_val

fn b64_val(ch: i64) -> i64

Decode a single Base64 character to its 6-bit value (0-63). Returns -1 for padding (=) or invalid characters.

print(b64_val(65))    // 0  (ASCII 'A')
print(b64_val(97))    // 26 (ASCII 'a')
print(b64_val(48))    // 52 (ASCII '0')
print(b64_val(61))    // -1 (ASCII '=', padding)