encoding.base64

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

const ALPHABET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

/// Bytes as standard base64 (RFC 4648 section 4), padded with "=".
///
/// # Panics
/// Panics if any value is outside 0-255.
pub fn base64_encode(bytes: &[i64]) -> String {
    if bytes.iter().any(|b| !(0..=255).contains(b)) {
        panic!("bytes must be a list of integers from 0 to 255");
    }
    let mut out = String::with_capacity((bytes.len() + 2) / 3 * 4);
    let push = |out: &mut String, n: i64, count: usize| {
        for k in 0..4 {
            if k < count {
                out.push(ALPHABET[((n >> (18 - 6 * k)) & 63) as usize] as char);
            } else {
                out.push('=');
            }
        }
    };
    let mut chunks = bytes.chunks_exact(3);
    for c in &mut chunks {
        push(&mut out, (c[0] << 16) | (c[1] << 8) | c[2], 4);
    }
    match chunks.remainder() {
        [a] => push(&mut out, a << 16, 2),
        [a, b] => push(&mut out, (a << 16) | (b << 8), 3),
        _ => {}
    }
    out
}

fn bytes_from_value(value: &Value, name: &str) -> Vec<i64> {
    match value {
        Value::Arr(items) => items
            .iter()
            .map(|item| match item {
                Value::Int(i) => *i,
                _ => panic!("{} must be a list of integers from 0 to 255", name),
            })
            .collect(),
        _ => panic!("{} must be a list of integers from 0 to 255", name),
    }
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::str(&base64_encode(&bytes_from_value(&args[0], "bytes")))
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

fn sextet(b: u8) -> i64 {
    match b {
        b'A'..=b'Z' => (b - b'A') as i64,
        b'a'..=b'z' => (b - b'a' + 26) as i64,
        b'0'..=b'9' => (b - b'0' + 52) as i64,
        b'+' => 62,
        b'/' => 63,
        _ => -1,
    }
}

/// Standard, padded base64 back to bytes, strictly: no whitespace, no
/// characters outside the alphabet, padding to a multiple of four, and zero
/// bits after the last byte, so every byte string has exactly one spelling.
///
/// # Panics
/// Panics on any of those.
pub fn base64_decode(text: &str) -> Vec<i64> {
    let mut values: Vec<i64> = Vec::with_capacity(text.len());
    let mut padding = 0usize;
    // Bytes, not chars: every accepted character is ASCII, and any byte of a
    // multi-byte character fails the alphabet check just as the character does.
    for &b in text.as_bytes() {
        if b == b'=' {
            padding += 1;
            continue;
        }
        let v = sextet(b);
        if v < 0 || padding > 0 {
            panic!("base64 text may only contain A-Z, a-z, 0-9, + and /, with = padding at the end");
        }
        values.push(v);
    }
    if text.len() % 4 != 0 {
        panic!("base64 text must be a multiple of 4 characters long, received {}", text.len());
    }
    if padding > 2 {
        panic!("base64 text has too much = padding");
    }
    let mut out = Vec::with_capacity(values.len() / 4 * 3);
    let mut chunks = values.chunks_exact(4);
    for c in &mut chunks {
        let n = (c[0] << 18) | (c[1] << 12) | (c[2] << 6) | c[3];
        out.extend_from_slice(&[(n >> 16) & 255, (n >> 8) & 255, n & 255]);
    }
    match chunks.remainder() {
        [a, b] => {
            if b & 15 != 0 {
                panic!("base64 text has non-zero bits after its last byte");
            }
            out.push(((a << 2) | (b >> 4)) & 255);
        }
        [a, b, c] => {
            if c & 3 != 0 {
                panic!("base64 text has non-zero bits after its last byte");
            }
            let n = (a << 18) | (b << 12) | (c << 6);
            out.extend_from_slice(&[(n >> 16) & 255, (n >> 8) & 255]);
        }
        _ => {}
    }
    out
}

pub fn fune_vector(args: &[Value]) -> Value {
    let text = match &args[0] {
        Value::Str(s) => s.as_str(),
        _ => panic!("base64 text must be a string"),
    };
    Value::Arr(base64_decode(text).into_iter().map(Value::Int).collect())
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::encoding_base64_base64_encode::base64_encode;  ← base64Encode, another function of this group · built into the same file, even by a slim install

/// Bytes as base64url (RFC 4648 section 5) without padding, as JWTs use it.
///
/// # Panics
/// Panics if any value is outside 0-255.
pub fn base64_url_encode(bytes: &[i64]) -> String {
    base64_encode(bytes)
        .trim_end_matches('=')
        .chars()
        .map(|c| match c {
            '+' => '-',
            '/' => '_',
            other => other,
        })
        .collect()
}

pub fn fune_vector(args: &[Value]) -> Value {
    let bytes: Vec<i64> = match &args[0] {
        Value::Arr(items) => items
            .iter()
            .map(|item| match item {
                Value::Int(i) => *i,
                _ => panic!("bytes must be a list of integers from 0 to 255"),
            })
            .collect(),
        _ => panic!("bytes must be a list of integers from 0 to 255"),
    };
    Value::str(&base64_url_encode(&bytes))
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::encoding_base64_base64_decode::base64_decode;  ← base64Decode, another function of this group · built into the same file, even by a slim install

/// base64url text back to bytes. Padding is optional, since JWTs leave it
/// off and some producers keep it, but padding that is present must be right.
///
/// # Panics
/// Panics on a character outside the URL-safe alphabet, an impossible
/// length, wrong padding, or non-zero bits after the last byte.
pub fn base64_url_decode(text: &str) -> Vec<i64> {
    let mut body = String::with_capacity(text.len() + 2);
    let mut padding = 0usize;
    for &b in text.as_bytes() {
        if b == b'=' {
            padding += 1;
            continue;
        }
        let ok = b.is_ascii_alphanumeric() || b == b'-' || b == b'_';
        if !ok || padding > 0 {
            panic!("base64url text may only contain A-Z, a-z, 0-9, - and _, with optional = padding at the end");
        }
        body.push(match b {
            b'-' => '+',
            b'_' => '/',
            other => other as char,
        });
    }
    if body.len() % 4 == 1 {
        panic!(
            "base64url text cannot be {} characters long; no number of bytes encodes to that",
            body.len()
        );
    }
    let needed = (4 - body.len() % 4) % 4;
    if padding != 0 && padding != needed {
        panic!("base64url text has the wrong amount of = padding");
    }
    for _ in 0..needed {
        body.push('=');
    }
    base64_decode(&body)
}

pub fn fune_vector(args: &[Value]) -> Value {
    let text = match &args[0] {
        Value::Str(s) => s.as_str(),
        _ => panic!("base64url text must be a string"),
    };
    Value::Arr(base64_url_decode(text).into_iter().map(Value::Int).collect())
}