Decodificación y verificación del token JWT usando System.IdentityModel.Tokens.Jwt

He estado usando la biblioteca JWT para decodificar un Json Web Token y me gustaría cambiar a la implementación oficial de JWT de Microsoft, System.IdentityModel.Tokens.Jwt .

La documentación es muy escasa, por lo que me cuesta trabajo averiguar cómo lograr lo que he estado haciendo con la biblioteca JWT. Con la biblioteca JWT, existe un método Decode que toma el JWT codificado en base64 y lo convierte en JSON, que luego puede deserializarse. Me gustaría hacer algo similar usando System.IdentityModel.Tokens.Jwt, pero después de una buena cantidad de excavación, no puedo averiguar cómo.

Por lo que vale, estoy leyendo el token JWT de una cookie, para usar con el marco de identidad de Google.

Cualquier ayuda sería apreciada.

Dentro del paquete hay una clase llamada JwtSecurityTokenHandlerque deriva de System.IdentityModel.Tokens.SecurityTokenHandler. En WIF, esta es la clase principal para deserializar y serializar tokens de seguridad.

La clase tiene un ReadToken(String)método que tomará su cadena JWT codificada en base64 y devuelve un SecurityTokenque representa el JWT.

El SecurityTokenHandlertambién tiene un ValidateToken(SecurityToken)método que lleva su SecurityTokeny crea una ReadOnlyCollection<ClaimsIdentity>. Por lo general, para JWT, esto contendrá un solo ClaimsIdentityobjeto que tiene un conjunto de reclamos que representan las propiedades del JWT original.

JwtSecurityTokenHandlerdefine algunas sobrecargas adicionales ValidateToken, en particular, tiene una ClaimsPrincipal ValidateToken(JwtSecurityToken, TokenValidationParameters)sobrecarga. El TokenValidationParametersargumento le permite especificar el certificado de firma del token (como una lista de X509SecurityTokens). También tiene una sobrecarga que toma el JWT como stringunSecurityToken .

El código para hacer esto es bastante complicado, pero se puede encontrar en el código ( TokenValidationHandlerclase) Global.asax.cx en la muestra del desarrollador llamada "ADAL - Aplicación nativa al servicio REST - Autenticación con ACS a través del cuadro de diálogo del navegador", ubicado en

http://code.msdn.microsoft.com/AAL-Native-App-to-REST-de57f2cc

Alternativamente, la JwtSecurityTokenclase tiene métodos adicionales que no están en la SecurityTokenclase base , como una Claimspropiedad que obtiene las notificaciones contenidas sin pasar por la ClaimsIdentitycolección. También tiene una Payloadpropiedad que devuelve unJwtPayload objeto que le permite obtener el JSON sin procesar del token. Depende de su escenario cuál es el enfoque más adecuado.

La documentación general (es decir, no específica de JWT) para la SecurityTokenHandlerclase está en

http://msdn.microsoft.com/en-us/library/system.identitymodel.tokens.securitytokenhandler.aspx

Dependiendo de su aplicación, puede configurar el controlador JWT en la canalización WIF exactamente como cualquier otro controlador.

Hay 3 muestras en uso en diferentes tipos de aplicación en

http://code.msdn.microsoft.com/site/search?f%5B0%5D.Type=SearchText&f%5B0%5D.Value=aal&f%5B1%5D.Type=User&f%5B1%5D.Value=Azure% 20AD% 20Desarrollador% 20Experiencia% 20Team &f% 5B1% 5D.Text = Azure% 20AD% 20Desarrollador% 20Experiencia% 20Team

Probablemente, uno se adaptará a sus necesidades o al menos se adaptará a ellas.

Me pregunto por qué usar algunas bibliotecas para la decodificación y verificación de tokens JWT.

El token JWT codificado se puede crear usando el siguiente pseudocódigo

var headers = base64URLencode(myHeaders);
var claims = base64URLencode(myClaims);
var payload = header + "." + claims;

var signature = base64URLencode(HMACSHA256(payload, secret));

var encodedJWT = payload + "." + signature;

Es muy fácil hacerlo sin una biblioteca específica. Usando el siguiente código:

using System;
using System.Text;
using System.Security.Cryptography;

public class Program
{   
    // More info: https://stormpath.com/blog/jwt-the-right-way/
    public static void Main()
    {           
        var header = "{\"typ\":\"JWT\",\"alg\":\"HS256\"}";
        var claims = "{\"sub\":\"1047986\",\"email\":\"jon.doe@eexample.com\",\"given_name\":\"John\",\"family_name\":\"Doe\",\"primarysid\":\"b521a2af99bfdc65e04010ac1d046ff5\",\"iss\":\"http://example.com\",\"aud\":\"myapp\",\"exp\":1460555281,\"nbf\":1457963281}";

        var b64header = Convert.ToBase64String(Encoding.UTF8.GetBytes(header))
            .Replace('+', '-')
            .Replace('/', '_')
            .Replace("=", "");
        var b64claims = Convert.ToBase64String(Encoding.UTF8.GetBytes(claims))
            .Replace('+', '-')
            .Replace('/', '_')
            .Replace("=", "");

        var payload = b64header + "." + b64claims;
        Console.WriteLine("JWT without sig:    " + payload);

        byte[] key = Convert.FromBase64String("mPorwQB8kMDNQeeYO35KOrMMFn6rFVmbIohBphJPnp4=");
        byte[] message = Encoding.UTF8.GetBytes(payload);

        string sig = Convert.ToBase64String(HashHMAC(key, message))
            .Replace('+', '-')
            .Replace('/', '_')
            .Replace("=", "");

        Console.WriteLine("JWT with signature: " + payload + "." + sig);        
    }

    private static byte[] HashHMAC(byte[] key, byte[] message)
    {
        var hash = new HMACSHA256(key);
        return hash.ComputeHash(message);
    }
}

La decodificación del token es la versión inversa del código anterior. Para verificar la firma, necesitará la misma y comparar la parte de la firma con la firma calculada.

ACTUALIZACIÓN: Para aquellos que tienen dificultades para realizar la codificación / decodificación segura de URL en base64, consulte otra pregunta SO , y también wiki y RFC