No confíes en el algoritmo que declara una licencia
Un token de licencia firmado que lleva su propio campo de algoritmo invita al clásico ataque de confusión de algoritmo: cámbialo a "none", o a HMAC con tu propia clave pública, y un verificador que despacha según ese campo deja pasar la falsificación. Este análisis muestra la falsificación exacta contra un token Ed25519, las dos líneas de C# que la hacen posible y por qué un verificador correcto fija el algoritmo en el despliegue y nunca lee el que el token declara.
Un token de licencia suele tener la forma de un JWT: una cabecera, una carga útil y una firma, cada una codificada en base64url y unida con puntos. La cabecera nombra el algoritmo —{"alg":"Ed25519"}— para que el verificador sepa qué ejecutar. Se lee limpio, es autodescriptivo y lleva consigo la idea más peligrosa de la seguridad de tokens. El campo de algoritmo viaja con el token, lo que significa que lo controla quien posea el token, lo que significa que un atacante puede elegir qué comprobación criptográfica ejecuta tu cliente. Esta es la familia de ataques de confusión de algoritmo, y ha roto silenciosamente código de licenciamiento real igual que rompió las primeras bibliotecas de JWT.
Conclusión clave: El algoritmo usado para verificar una firma es una propiedad de tu despliegue, no del token que tienes delante. Un verificador correcto fija el algoritmo y la clave pública en tiempo de compilación o despliegue y nunca despacha según el alg que el token declara. El ataque funciona precisamente porque el verificador ingenuo sí despacha según él: cambia el campo a none y la comprobación de firma se omite, o cámbialo a HMAC y el atacante firma con tu propia clave pública, que no es un secreto. La solución es borrar la rama que lee el campo.
La verdadera pregunta: ¿quién elige el algoritmo?
Considera un verificador que admite tres algoritmos de firma porque el producto ha publicado varios a lo largo de los años. Lee la cabecera, hace un switch sobre el nombre y llama a la comprobación correspondiente:
// VULNERABLE: the token chooses which check runs.
public static bool VerifyNaive(LicenseToken token, VerificationKeys keys)
{
string signingInput = token.HeaderB64 + "." + token.PayloadB64;
return token.Header.Alg switch
{
"none" => true, // skips verification entirely
"HS256" => HmacMatches(signingInput, token.Signature, // symmetric: key is the "secret"
keys.Ed25519PublicKey),
"ES256" => EcdsaVerify(signingInput, token.Signature, keys.EcdsaPublicKey),
"Ed25519" => Ed25519Verify(signingInput, token.Signature, keys.Ed25519PublicKey),
_ => false,
};
}
Cada línea aquí parece defensiva. Hay una lista blanca de algoritmos, un default => false explícito, verificación de firma real para los casos asimétricos. Y es falsificable de dos maneras distintas por cualquiera que haya recibido alguna vez un token válido y pueda leer la clave pública —lo cual, en un cliente con prioridad sin conexión, es todo el mundo, porque la clave pública está incrustada en el binario para que la aplicación pueda verificar sin servidor.
Falsificación uno: alg: none
La rama none existe porque en algún lugar, en algún momento, un token sin firmar resultó cómodo para un fixture de prueba. El atacante toma un token genuino, decodifica la cabecera de base64url, la reescribe a {"alg":"none"}, la vuelve a codificar y deja la carga útil con lo que quiera —"tier":"enterprise", una caducidad dentro de una década—. El segmento de firma puede quedar vacío. VerifyNaive ve none, devuelve true y la carga útil falsificada se confía. No se derrotó ninguna criptografía porque no se ejecutó ninguna.
Falsificación dos: confusión de clave
La segunda falsificación es la sutil, y es la razón por la que «simplemente elimina la rama none» no basta. El atacante declara un algoritmo simétrico —HS256— y explota la asimetría que el verificador olvidó. Una clave pública Ed25519 es pública: está en el cliente, para que una comprobación legítima sin conexión pueda ejecutarse. HMAC-SHA256 toma un secreto compartido. El verificador ingenuo, que no tiene clave HS256 propia, pasa la única clave que tiene —la clave pública Ed25519— a HmacMatches. Así que el atacante calcula el mismo HMAC sobre su entrada de firma elegida usando esos bytes exactos de la clave pública como secreto, y el verificador recalcula una etiqueta idéntica y la acepta.
alg del token elija la comprobación; la ruta fijada fija el algoritmo en el despliegue e ignora lo que el token declara.La falsificación son unas pocas líneas del propio código del atacante:
// Attacker side — needs only the public key shipped in the client.
string header = Base64Url(Encoding.UTF8.GetBytes("{\"alg\":\"HS256\"}"));
string payload = Base64Url(Encoding.UTF8.GetBytes("{\"tier\":\"enterprise\",\"exp\":\"2036-01-01\"}"));
string signingInput = header + "." + payload;
using var h = new HMACSHA256(ed25519PublicKeyBytes); // public key AS the HMAC secret
byte[] tag = h.ComputeHash(Encoding.ASCII.GetBytes(signingInput));
string forged = signingInput + "." + Base64Url(tag); // verifies against VerifyNaive
No ocurrió nada exótico. El atacante nunca vio la clave privada. Se apoyó en el hecho de que el verificador dejó que el token propusiera un esquema simétrico y luego le entregó el único material de clave que había a mano.
La solución: el verificador es dueño del algoritmo
El verificador correcto no tiene un switch. Sabe, como un hecho de este despliegue, que las licencias están firmadas con Ed25519 con una clave pública fijada, y ejecuta exactamente esa comprobación:
// SAFE: the deployment pins the algorithm; the token has no say.
public sealed class LicenseVerifier
{
private readonly PublicKey _pinned; // Ed25519, loaded once at startup
public LicenseVerifier(ReadOnlySpan<byte> ed25519PublicKey) =>
_pinned = PublicKey.Import(SignatureAlgorithm.Ed25519,
ed25519PublicKey, KeyBlobFormat.RawPublicKey);
public bool Verify(LicenseToken token)
{
byte[] input = Encoding.ASCII.GetBytes(token.HeaderB64 + "." + token.PayloadB64);
// token.Header.Alg is NEVER consulted to choose a path.
return SignatureAlgorithm.Ed25519.Verify(_pinned, input, token.Signature);
}
}
(La API anterior es NSec.Cryptography, que Keyright usa para Ed25519 en los frameworks donde System.Security.Cryptography aún no lo expone.) Un token falsificado alg: none no tiene una firma Ed25519 válida, así que Verify devuelve false. La falsificación HMAC produce 32 bytes que no son una firma Ed25519 de 64 bytes sobre la entrada, así que también falla. Ninguna falsificación sobrevive, porque ninguna puede hacer que la comprobación fijada pase sin la clave privada.
Si quieres conservar el campo alg para diagnósticos o una migración, léelo solo después de que un verificador fijado ya haya validado la firma, y úsalo únicamente para rechazar una discrepancia:
if (!verifier.Verify(token)) return LicenseResult.Invalid;
if (token.Header.Alg != "Ed25519") return LicenseResult.Invalid; // defence in depth, post-verify
Ese orden es toda la disciplina: criptografía primero, con un algoritmo que tú elegiste; nunca se confía en la autodescripción del token para dirigir la comprobación.
Cómo se aplica esto en Keyright
El verificador del SDK de Keyright está fijado por construcción. Le entregas la clave pública que recibiste al crear el producto, y solo ejecuta el algoritmo que esa clave es. No hay un conmutador de configuración que lea un algoritmo del token, así que ninguna de las dos falsificaciones anteriores tiene una superficie donde aterrizar. Para los equipos que arrastraron antes un esquema casero, esta es la vulnerabilidad más común que vemos en las auditorías de migración —una biblioteca de JWT configurada para aceptar «cualquier algoritmo compatible», dejada activa por defecto.
Si estás ejecutando más de un algoritmo durante una rotación de claves, fijas ambos y aceptas un token que cualquiera de los verificadores fijados valide. Eso sigue siendo el despliegue eligiendo su conjunto de confianza, no el token:
bool ok = _current.Verify(token) || _previousDuringOverlap.Verify(token);
La propia ventana de solapamiento de la rotación —emitir con la clave nueva mientras se sigue aceptando la antigua— se trata en el artículo de rotación de claves de firma; aquí lo único relevante es que nunca significa leer el algoritmo de la red.
Advertencias y los límites honestos
Esto no sustituye al resto de la verificación. Fijar el algoritmo detiene una firma falsificada. No hace nada contra la reproducción de un token genuino, una clave revocada que se sigue aceptando o una licencia caducada cuyo exp olvidaste comprobar. Fijar la firma es una puerta; la revocación y la caducidad son otras.
La comparación en tiempo constante sigue importando para las rutas simétricas que conserves. Si verificas legítimamente un HMAC en algún sitio —un webhook de facturación entrante, por ejemplo—, compara las etiquetas con CryptographicOperations.FixedTimeEquals, no con == ni SequenceEqual, para que una fuga de temporización byte a byte no entregue la etiqueta a un atacante. Ese es un error distinto de la confusión de algoritmo, pero vive en el mismo código.
Un verificador fijado no puede proteger a un cliente que ha sido parcheado. Si un atacante reescribe tu método Verify a return true, ninguna disciplina de algoritmo ayuda —eso es un problema de manipulación, no de firma—, y la respuesta es proteger la propia comprobación. Emparejar Keyright con la ofuscación y el antimanipulación de Nebula.NET es como se evita que el verificador sea el punto de parcheo.
Conclusión
Un token autodescriptivo es una comodidad que delega silenciosamente una decisión de seguridad en quien posea el token. El algoritmo usado para verificar una firma pertenece a tu despliegue, no a los bytes de la red: fíjalo, ejecútalo y nunca dejes que un switch lea el alg que el token declara —esa única rama es lo que convierte una clave pública en una herramienta de falsificación y un alg: none en un pase maestro—. Keyright incluye un verificador que está fijado por construcción, así que la rama no existe para ser explotada; la Community Edition es gratuita y autoalojada, lo que significa que puedes emitir una clave, inspeccionar el formato del token e intentar falsificar contra tu propio cliente de principio a fin antes de confiar en él en producción. La superficie completa del SDK está en la documentación de Keyright.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.