Codificatore/Decodificatore Base64URL

Cos'è la codifica Base64url?

Base64url è una variante della codifica Base64 progettata specificamente per l'uso in URL, nomi di file e altri contesti in cui i caratteri standard Base64 + e / creano problemi. Definita nella RFC 4648 Sezione 5, Base64url sostituisce + con - (trattino) e / con _ (underscore), e omette i caratteri di padding = finali. Il risultato è una stringa che può essere incorporata direttamente in un parametro di query URL, un nome di file o un header HTTP senza richiedere ulteriore percent-encoding.

Il Base64 standard (RFC 4648 Sezione 4) utilizza 64 caratteri: A-Z, a-z, 0-9, + e /. I caratteri + e / sono riservati negli URL: + viene interpretato come spazio nelle query string (application/x-www-form-urlencoded), e / è un delimitatore di percorso. Usare Base64 standard all'interno di un URL richiede quindi la percent-encoding di questi caratteri (%2B, %2F), il che aumenta la lunghezza della stringa e la rende più difficile da leggere. Base64url elimina completamente questo problema usando dall'inizio caratteri sicuri per gli URL.

L'uso più importante di Base64url è nei JSON Web Token (JWT). Tutti e tre i segmenti di un JWT — header, payload e firma — sono codificati in Base64url. I code verifier OAuth 2.0 PKCE, i valori challenge WebAuthn e molti schemi di token API fanno anch'essi affidamento su Base64url. Comprendere questa codifica è essenziale per qualsiasi sviluppatore che lavora con autenticazione, autorizzazione o scambio di dati crittografici.

Perché usare questo strumento Base64url?

Converti tra Base64url e testo o dati binari direttamente nel tuo browser. Sono supportate sia la codifica che la decodifica, con gestione automatica del padding e della sostituzione dei caratteri. Che tu stia analizzando un token JWT, generando un code challenge PKCE o costruendo identificatori sicuri per URL, questo strumento elabora tutto localmente nel tuo browser con latenza zero e senza alcun round-trip verso il server.

Casi d'uso di Base64url

Base64 standard vs Base64url

Base64url differisce dal Base64 standard in esattamente tre modi. L'algoritmo di codifica è identico — cambiano solo l'alfabeto e il comportamento del padding:

Queste tre differenze significano che la conversione tra Base64 standard e Base64url è banale: sostituisci + con -, / con _, e rimuovi i caratteri = finali. Al contrario, sostituisci - con +, _ con /, e riaggiungi il padding per rendere la lunghezza un multiplo di 4. La maggior parte dei linguaggi offre supporto nativo a Base64url, rendendo la conversione manuale non necessaria. Entrambe le conversioni sono completamente reversibili e senza perdita di dati, preservando esattamente la sequenza di byte originale.

Tabella di confronto della codifica

La tabella seguente mostra gli stessi input codificati con Base64 standard e Base64url. Nota come i caratteri di padding (=) vengano rimossi e + / / vengano sostituiti con - / _ nella variante URL-safe:

Esempi di codice

Come codificare e decodificare stringhe Base64url nei linguaggi più diffusi. Ogni esempio produce output sicuro per l'uso in URL, nomi di file e header HTTP:

// Encode to Base64url
function toBase64url(str) {
  return btoa(unescape(encodeURIComponent(str)))
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '')
}
toBase64url('Hello!') // → "SGVsbG8h"

// Decode from Base64url
function fromBase64url(b64url) {
  const b64 = b64url.replace(/-/g, '+').replace(/_/g, '/')
  const pad = (4 - b64.length % 4) % 4
  return decodeURIComponent(escape(atob(b64 + '='.repeat(pad))))
}
fromBase64url('SGVsbG8h') // → "Hello!"

// Native base64url support since Node 15.7
const encoded = Buffer.from('Hello!').toString('base64url')
// → "SGVsbG8h"

const decoded = Buffer.from('SGVsbG8h', 'base64url').toString()
// → "Hello!"

// Decode a JWT payload
const jwt = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0...'
const payload = JSON.parse(Buffer.from(jwt.split('.')[1], 'base64url').toString())
// → { sub: "1234567890" }

import base64

# Encode to Base64url (no padding)
encoded = base64.urlsafe_b64encode(b'Hello!').rstrip(b'=').decode()
# → "SGVsbG8h"

# Decode from Base64url (re-add padding)
def b64url_decode(s: str) -> bytes:
    s += '=' * (4 - len(s) % 4)  # restore padding
    return base64.urlsafe_b64decode(s)

b64url_decode('SGVsbG8h')  # → b'Hello!'

package main

import (
    "encoding/base64"
    "fmt"
)

func main() {
    // Encode to Base64url (no padding)
    encoded := base64.RawURLEncoding.EncodeToString([]byte("Hello!"))
    fmt.Println(encoded) // → "SGVsbG8h"

    // Decode from Base64url
    decoded, _ := base64.RawURLEncoding.DecodeString("SGVsbG8h")
    fmt.Println(string(decoded)) // → "Hello!"
}

Domande frequenti