Base64 seguro para URL

¿Qué es la codificación Base64url?

Base64url es una variante de la codificación Base64 diseñada específicamente para su uso en URLs, nombres de archivo y otros contextos donde los caracteres estándar de Base64 + y / causan problemas. Definida en la Sección 5 de RFC 4648, Base64url reemplaza + por - (guion) y / por _ (guion bajo), y omite los caracteres de relleno = al final. El resultado es una cadena que puede incrustarse directamente en un parámetro de consulta de URL, un nombre de archivo o un encabezado HTTP sin necesitar codificación de porcentaje adicional.

El Base64 estándar (Sección 4 de RFC 4648) utiliza 64 caracteres: A-Z, a-z, 0-9, + y /. Los caracteres + y / están reservados en las URLs: + se interpreta como un espacio en cadenas de consulta (application/x-www-form-urlencoded) y / es un delimitador de ruta. Usar Base64 estándar dentro de una URL requiere por tanto codificar esos caracteres con porcentaje (%2B, %2F), lo que aumenta la longitud de la cadena y dificulta su lectura. Base64url elimina este problema por completo al utilizar desde el principio caracteres seguros para URLs.

El uso más destacado de Base64url es en los JSON Web Tokens (JWT). Los tres segmentos de un JWT — encabezado, carga útil y firma — están codificados en Base64url. Los verificadores de código PKCE de OAuth 2.0, los valores de desafío de WebAuthn y muchos esquemas de tokens de API también dependen de Base64url. Comprender esta codificación es esencial para cualquier desarrollador que trabaje con autenticación, autorización o intercambio de datos criptográficos.

¿Por qué usar esta herramienta Base64url?

Convierte entre Base64url y texto o datos binarios directamente en tu navegador. Se admiten tanto la codificación como la decodificación, con manejo automático del relleno y la sustitución de caracteres. Ya sea que estés depurando un token JWT, generando un code challenge para PKCE, o construyendo identificadores seguros para URLs, esta herramienta procesa todo localmente en tu navegador con latencia cero y sin dependencias externas.

Casos de uso de Base64url

Base64 estándar vs Base64url

Base64url difiere del Base64 estándar en exactamente tres aspectos. El algoritmo de codificación es idéntico — solo cambian el alfabeto y el comportamiento del relleno:

Estas tres diferencias significan que convertir entre Base64 estándar y Base64url es trivial: reemplaza + por -, / por _, y elimina los caracteres = finales. A la inversa, reemplaza - por +, _ por /, y vuelve a añadir el relleno para que la longitud sea múltiplo de 4. La mayoría de lenguajes ofrecen soporte nativo para Base64url, lo que hace innecesaria la conversión manual.

Tabla comparativa de codificación

La siguiente tabla muestra las mismas entradas codificadas con Base64 estándar y Base64url. Observa cómo los caracteres de relleno (=) se eliminan y + / / se reemplazan por - / _ en la variante segura para URL:

Ejemplos de código

Cómo codificar y decodificar cadenas Base64url en los lenguajes más populares. Todos los ejemplos producen resultados seguros para su uso en URLs, nombres de archivo y encabezados 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!"
}

Preguntas frecuentes