Base64 URL-safe

Vad är Base64url-kodning?

Base64url är en variant av Base64-kodning som är specifikt utformad för användning i URL:er, filnamn och andra sammanhang där standardtecknen + och / i Base64 orsakar problem. Definierad i RFC 4648 avsnitt 5 ersätter Base64url + med - (bindestreck) och / med _ (understreck), och utelämnar avslutande = utfyllnadstecken. Resultatet är en sträng som kan bäddas in direkt i en URL-frågeparameter, ett filnamn eller en HTTP-header utan ytterligare procentkodning.

Standard-Base64 (RFC 4648 avsnitt 4) använder 64 tecken: A–Z, a–z, 0–9, + och /. Tecknen + och / är reserverade i URL:er: + tolkas som ett blanksteg i frågesträngar (application/x-www-form-urlencoded) och / är en sökvägsseparator. Att använda standard-Base64 inuti en URL kräver därför procentkodning av dessa tecken (%2B, %2F), vilket ökar stränglängden och gör den svårare att läsa. Base64url eliminerar detta problem helt genom att från början använda URL-säkra tecken.

Den mest framträdande användningen av Base64url är i JSON Web Tokens (JWT). Alla tre segment i en JWT — header, payload och signatur — är Base64url-kodade. OAuth 2.0 PKCE-kodverifierare, WebAuthn-utmaningsvärden och många API-tokensystem förlitar sig också på Base64url. Att förstå denna kodning är grundläggande för alla utvecklare som arbetar med autentisering, auktorisering eller kryptografiskt datautbyte.

Varför använda det här Base64url-verktyget?

Konvertera mellan Base64url och text eller binärdata direkt i webbläsaren. Både kodning och avkodning stöds, med automatisk hantering av utfyllnad och teckenbyte. Oavsett om du felsöker en JWT-token, genererar en PKCE-kodutmaning eller skapar URL-säkra identifierare för lösenordsåterställningslänkar, bearbetar det här verktyget allt lokalt i din webbläsare med noll latens och utan serverbegäranden. Ingen data du klistrar in här överförs någonsin utanför din enhet.

Användningsfall för Base64url

Standard-Base64 vs Base64url

Base64url skiljer sig från standard-Base64 på exakt tre sätt. Kodningsalgoritmen är identisk — bara alfabetet och utfyllnadsbeteendet ändras:

Dessa tre skillnader innebär att konvertering mellan standard-Base64 och Base64url är trivial: ersätt + med -, / med _, och ta bort avslutande = tecken. I omvänd ordning, ersätt - med +, _ med /, och lägg tillbaka utfyllnad för att göra längden till en multipel av 4. De flesta moderna språk erbjuder inbyggt Base64url-stöd, vilket gör manuell konvertering onödig. Båda konverteringarna är helt reversibla och förlustfria och bevarar den ursprungliga bytesekvensen exakt. Denna interoperabilitet garanteras av RFC 4648-specifikationen, som definierar båda kodningsvarianterna. I praktiken tillhandahåller de flesta moderna programmeringsspråk och ramverk inbyggt Base64url-stöd, så manuell konvertering behövs sällan.

Jämförelsetabell för kodning

Tabellen nedan visar samma indata kodade med standard-Base64 och Base64url. Observera hur utfyllnadstecken (=) tas bort och + / / ersätts med - / _ i den URL-säkra varianten:

Kodexempel

Hur man kodar och avkodar Base64url-strängar i populära språk. Varje exempel producerar utdata som är säkra att använda i URL:er, filnamn och HTTP-headers:

// 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!"
}

Vanliga frågor