Implementacje base64url

ASP.NET Core

W ASP.NET Core najwygodniej użyć WebEncoders.

using System.Text;
using Microsoft.AspNetCore.WebUtilities;

var plain = "FV/2026/03/001";

var encoded = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(plain));
var decoded = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(encoded));

Console.WriteLine(encoded); // RlYvMjAyNi8wMy8wMDE
Console.WriteLine(decoded); // FV/2026/03/001

Elixir

Elixir posiada wbudowaną obsługę base64url w bibliotece standardowej.

plain = "FV/2026/03/001"

encoded = Base.url_encode64(plain, padding: false)
Base.url_decode64(encoded, padding: false)
{:ok, "FV/2026/03/001"}

Go

Go ma wbudowaną obsługę base64url w bibliotece standardowej.

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	plain := "FV/2026/03/001"

	encoded := base64.RawURLEncoding.EncodeToString([]byte(plain))

	decodedBytes, err := base64.RawURLEncoding.DecodeString(encoded)
	if err != nil {
		panic(err)
	}

	decoded := string(decodedBytes)

	fmt.Println(encoded) // RlYvMjAyNi8wMy8wMDE
	fmt.Println(decoded) // FV/2026/03/001
}

Java

Java ma wbudowaną obsługę base64url w bibliotece standardowej.

import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Base64UrlExample {

    public static String encode(String value) {
        return Base64.getUrlEncoder()
                .withoutPadding()
                .encodeToString(value.getBytes(StandardCharsets.UTF_8));
    }

    public static String decode(String value) {
        byte[] decoded = Base64.getUrlDecoder().decode(value);
        return new String(decoded, StandardCharsets.UTF_8);
    }

    public static void main(String[] args) {
        String plain = "FV/2026/03/001";

        String encoded = encode(plain);
        String decoded = decode(encoded);

        System.out.println(encoded); // RlYvMjAyNi8wMy8wMDE
        System.out.println(decoded); // FV/2026/03/001
    }
}

JavaScript (przeglądarka)

Można zastosować pakiet universal-base64url.

import { decode, encode } from "universal-base64url";

encode("test"); //=> "dGVzdA"
decode("dGVzdA"); //=> "test"

Node.js

Node.js ma wbudowaną obsługę base64url przez Buffer.

const plain = "FV/2026/03/001";

const encoded = Buffer.from(plain, "utf8").toString("base64url");
const decoded = Buffer.from(encoded, "base64url").toString("utf8");

console.log(encoded); // RlYvMjAyNi8wMy8wMDE
console.log(decoded); // FV/2026/03/001

PHP

W PHP można użyć biblioteki base64url.

Python

Python ma wbudowaną obsługę base64url w bibliotece standardowej ale wymaga ona usunięcia padding.

import base64

def encode_base64url(value: str) -> str:
    encoded = base64.urlsafe_b64encode(value.encode("utf-8"))
    return encoded.rstrip(b"=").decode("ascii")

def decode_base64url(value: str) -> str:
    padding = "=" * (-len(value) % 4)
    decoded = base64.urlsafe_b64decode((value + padding).encode("ascii"))
    return decoded.decode("utf-8")


plain = "FV/2026/03/001"

encoded = encode_base64url(plain)
decoded = decode_base64url(encoded)

print(encoded)  # RlYvMjAyNi8wMy8wMDE
print(decoded)  # FV/2026/03/001

Ruby

Ruby ma wbudowaną obsługę base64url w bibliotece standardowej.

require 'base64'

plain = 'FV/2026/03/001'

encoded = Base64.urlsafe_encode64(plain, padding: false)
decoded = Base64.urlsafe_decode64(encoded)

puts encoded # RlYvMjAyNi8wMy8wMDE
puts decoded # FV/2026/03/001