Encodeur/Décodeur Base64URL

Qu'est-ce que l'encodage Base64url ?

Base64url est une variante de l'encodage Base64 conçue spécifiquement pour les URL, les noms de fichiers et d'autres contextes où les caractères + et / du Base64 standard posent problème. Défini dans la RFC 4648 Section 5, Base64url remplace + par - (tiret) et / par _ (underscore), et omet les caractères de rembourrage = finaux. Le résultat est une chaîne qui peut être intégrée directement dans un paramètre de requête URL, un nom de fichier ou un en-tête HTTP sans nécessiter d'encodage en pourcentage supplémentaire.

Le Base64 standard (RFC 4648 Section 4) utilise 64 caractères : A-Z, a-z, 0-9, + et /. Les caractères + et / sont réservés dans les URL : + est interprété comme une espace dans les chaînes de requête (application/x-www-form-urlencoded), et / est un délimiteur de chemin. Utiliser du Base64 standard dans une URL nécessite donc d'encoder ces caractères en pourcentage (%2B, %2F), ce qui allonge la chaîne et la rend moins lisible. Base64url élimine ce problème en utilisant des caractères sûrs pour les URL dès le départ.

L'usage le plus répandu de Base64url est dans les JSON Web Tokens (JWT). Les trois segments d'un JWT — en-tête, charge utile et signature — sont encodés en Base64url. Les vérificateurs de code PKCE OAuth 2.0, les valeurs de challenge WebAuthn et de nombreux schémas de tokens API s'appuient également sur Base64url. Comprendre cet encodage est essentiel pour tout développeur qui travaille avec l'authentification, l'autorisation ou l'échange de données cryptographiques.

Pourquoi utiliser cet outil Base64url ?

Convertissez entre Base64url et du texte ou des données binaires directement dans votre navigateur. L'encodage et le décodage sont tous deux pris en charge, avec gestion automatique du rembourrage et de la substitution de caractères. Que vous déboguiez un token JWT, génériez un code challenge PKCE ou construisiez des identifiants sûrs pour les URL, cet outil traite tout localement dans votre navigateur sans aucune latence.

Cas d'usage de Base64url

Base64 standard vs Base64url

Base64url diffère du Base64 standard en exactement trois points. L'algorithme d'encodage est identique — seuls l'alphabet et le comportement du rembourrage changent :

Ces trois différences signifient que la conversion entre Base64 standard et Base64url est triviale : remplacez + par -, / par _, et supprimez les caractères = finaux. Dans le sens inverse, remplacez - par +, _ par /, et rajoutez le rembourrage pour que la longueur soit un multiple de 4. La plupart des langages offrent un support natif de Base64url, rendant la conversion manuelle inutile.

Tableau de comparaison d'encodage

Le tableau ci-dessous montre les mêmes entrées encodées avec Base64 standard et Base64url. Notez comment les caractères de rembourrage (=) sont supprimés et + / / sont remplacés par - / _ dans la variante URL-safe :

Exemples de code

Comment encoder et décoder des chaînes Base64url dans les langages courants. Chaque exemple produit une sortie sûre pour les URL, les noms de fichiers et les en-têtes 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!"
}

Questions fréquentes