Gibt es ein Beispiel für ein JSON-Web-Token (JWT) in C #?

101

Ich habe das Gefühl, ich nehme hier verrückte Pillen. Normalerweise schweben für eine bestimmte Aufgabe immer eine Million Bibliotheken und Samples im Web. Ich versuche, die Authentifizierung mit einem Google "Service Account" mithilfe von JSON Web Tokens (JWT) wie hier beschrieben zu implementieren .

Es gibt jedoch nur Client-Bibliotheken in PHP, Python und Java. Selbst bei der Suche nach JWT-Beispielen außerhalb der Google-Authentifizierung gibt es nur Grillen und Entwürfe zum JWT-Konzept. Ist das wirklich so neu und möglicherweise ein von Google entwickeltes System?

Das Java-Sample, das mir am nächsten kommt, sieht ziemlich intensiv und einschüchternd aus. Es muss etwas in C # geben, mit dem ich zumindest anfangen könnte. Jede Hilfe dabei wäre toll!

Levitikon
quelle
2
Peter hat deine Antwort. JWT ist ein relativ neues Token-Format, weshalb Samples immer noch etwas schwer zu bekommen sind, aber es wächst sehr schnell, da JWTs ein dringend benötigter Ersatz für SWTs sind. Microsoft unterstützt das Token-Format, die Live-Connect-APIs verwenden beispielsweise JWTs.
Andrew Lavers
Hat das etwas mit App Engine zu tun?
Nick Johnson
Mögliches Duplikat der Validierung
Thomas

Antworten:

74

Vielen Dank an alle. Ich habe eine Basisimplementierung eines Json-Web-Tokens gefunden und diese mit der Google-Variante erweitert. Ich habe es immer noch nicht vollständig geklappt, aber es ist zu 97% da. Dieses Projekt hat seinen Dampf verloren, also wird dies hoffentlich jemand anderem helfen, einen guten Vorsprung zu erlangen:

Hinweis: Änderungen, die ich an der Basisimplementierung vorgenommen habe (ich kann mich nicht erinnern, wo ich sie gefunden habe), sind:

  1. HS256 geändert -> RS256
  2. Die Reihenfolge von JWT und Alg in der Kopfzeile wurde vertauscht. Ich bin mir nicht sicher, wer es falsch verstanden hat, Google oder die Spezifikation, aber Google nimmt es so, wie es unten ist.
public enum JwtHashAlgorithm
{
    RS256,
    HS384,
    HS512
}

public class JsonWebToken
{
    private static Dictionary<JwtHashAlgorithm, Func<byte[], byte[], byte[]>> HashAlgorithms;

    static JsonWebToken()
    {
        HashAlgorithms = new Dictionary<JwtHashAlgorithm, Func<byte[], byte[], byte[]>>
            {
                { JwtHashAlgorithm.RS256, (key, value) => { using (var sha = new HMACSHA256(key)) { return sha.ComputeHash(value); } } },
                { JwtHashAlgorithm.HS384, (key, value) => { using (var sha = new HMACSHA384(key)) { return sha.ComputeHash(value); } } },
                { JwtHashAlgorithm.HS512, (key, value) => { using (var sha = new HMACSHA512(key)) { return sha.ComputeHash(value); } } }
            };
    }

    public static string Encode(object payload, string key, JwtHashAlgorithm algorithm)
    {
        return Encode(payload, Encoding.UTF8.GetBytes(key), algorithm);
    }

    public static string Encode(object payload, byte[] keyBytes, JwtHashAlgorithm algorithm)
    {
        var segments = new List<string>();
        var header = new { alg = algorithm.ToString(), typ = "JWT" };

        byte[] headerBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(header, Formatting.None));
        byte[] payloadBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(payload, Formatting.None));
        //byte[] payloadBytes = Encoding.UTF8.GetBytes(@"{"iss":"761326798069-r5mljlln1rd4lrbhg75efgigp36m78j5@developer.gserviceaccount.com","scope":"https://www.googleapis.com/auth/prediction","aud":"https://accounts.google.com/o/oauth2/token","exp":1328554385,"iat":1328550785}");

        segments.Add(Base64UrlEncode(headerBytes));
        segments.Add(Base64UrlEncode(payloadBytes));

        var stringToSign = string.Join(".", segments.ToArray());

        var bytesToSign = Encoding.UTF8.GetBytes(stringToSign);

        byte[] signature = HashAlgorithms[algorithm](keyBytes, bytesToSign);
        segments.Add(Base64UrlEncode(signature));

        return string.Join(".", segments.ToArray());
    }

    public static string Decode(string token, string key)
    {
        return Decode(token, key, true);
    }

    public static string Decode(string token, string key, bool verify)
    {
        var parts = token.Split('.');
        var header = parts[0];
        var payload = parts[1];
        byte[] crypto = Base64UrlDecode(parts[2]);

        var headerJson = Encoding.UTF8.GetString(Base64UrlDecode(header));
        var headerData = JObject.Parse(headerJson);
        var payloadJson = Encoding.UTF8.GetString(Base64UrlDecode(payload));
        var payloadData = JObject.Parse(payloadJson);

        if (verify)
        {
            var bytesToSign = Encoding.UTF8.GetBytes(string.Concat(header, ".", payload));
            var keyBytes = Encoding.UTF8.GetBytes(key);
            var algorithm = (string)headerData["alg"];

            var signature = HashAlgorithms[GetHashAlgorithm(algorithm)](keyBytes, bytesToSign);
            var decodedCrypto = Convert.ToBase64String(crypto);
            var decodedSignature = Convert.ToBase64String(signature);

            if (decodedCrypto != decodedSignature)
            {
                throw new ApplicationException(string.Format("Invalid signature. Expected {0} got {1}", decodedCrypto, decodedSignature));
            }
        }

        return payloadData.ToString();
    }

    private static JwtHashAlgorithm GetHashAlgorithm(string algorithm)
    {
        switch (algorithm)
        {
            case "RS256": return JwtHashAlgorithm.RS256;
            case "HS384": return JwtHashAlgorithm.HS384;
            case "HS512": return JwtHashAlgorithm.HS512;
            default: throw new InvalidOperationException("Algorithm not supported.");
        }
    }

    // from JWT spec
    private static string Base64UrlEncode(byte[] input)
    {
        var output = Convert.ToBase64String(input);
        output = output.Split('=')[0]; // Remove any trailing '='s
        output = output.Replace('+', '-'); // 62nd char of encoding
        output = output.Replace('/', '_'); // 63rd char of encoding
        return output;
    }

    // from JWT spec
    private static byte[] Base64UrlDecode(string input)
    {
        var output = input;
        output = output.Replace('-', '+'); // 62nd char of encoding
        output = output.Replace('_', '/'); // 63rd char of encoding
        switch (output.Length % 4) // Pad with trailing '='s
        {
            case 0: break; // No pad chars in this case
            case 2: output += "=="; break; // Two pad chars
            case 3: output += "="; break; // One pad char
            default: throw new System.Exception("Illegal base64url string!");
        }
        var converted = Convert.FromBase64String(output); // Standard base64 decoder
        return converted;
    }
}

Und dann meine google-spezifische JWT-Klasse:

public class GoogleJsonWebToken
{
    public static string Encode(string email, string certificateFilePath)
    {
        var utc0 = new DateTime(1970,1,1,0,0,0,0, DateTimeKind.Utc);
        var issueTime = DateTime.Now;

        var iat = (int)issueTime.Subtract(utc0).TotalSeconds;
        var exp = (int)issueTime.AddMinutes(55).Subtract(utc0).TotalSeconds; // Expiration time is up to 1 hour, but lets play on safe side

        var payload = new
        {
            iss = email,
            scope = "https://www.googleapis.com/auth/gan.readonly",
            aud = "https://accounts.google.com/o/oauth2/token",
            exp = exp,
            iat = iat
        };

        var certificate = new X509Certificate2(certificateFilePath, "notasecret");

        var privateKey = certificate.Export(X509ContentType.Cert);

        return JsonWebToken.Encode(payload, privateKey, JwtHashAlgorithm.RS256);
    }
}
Levitikon
quelle
9
Die ursprüngliche Implementierung scheint John Sheehans JWT-Bibliothek zu sein: github.com/johnsheehan/jwt
Torbjørn
John's unterstützt anscheinend keine RS-Verschlüsselungsalgorithmen (Alg-Flag), aber diese Version tut dies.
Ryan
14
Diese Version unterstützt den RS256-Signaturalgorithmus NICHT korrekt! Die Eingabe wird nur mit den Schlüsselbytes als Geheimnis gehasht, anstatt den Hash ordnungsgemäß zu verschlüsseln, wie dies in der PKI erfolgen sollte. Es wird lediglich das HS256-Label gegen das RS256-Label ausgetauscht, ohne dass eine ordnungsgemäße Implementierung erforderlich ist.
Hans Z.
1
Der obige Code unterliegt teilweise dem von ihr beschriebenen Sicherheitsangriff: auth0.com/blog/2015/03/31/… Er ist anfällig für „Wenn ein Server ein mit RSA signiertes Token erwartet, aber tatsächlich ein mit HMAC signiertes Token empfängt wird der öffentliche Schlüssel tatsächlich ein geheimer HMAC-Schlüssel sein. “
BennyBechDk
@Levitikon Gibt es eine Idee, wie ich den von Google in der JSON-Datei bereitgestellten privaten Schlüssel dekodieren kann? Danke
bibscy
46

Nachdem all diese Monate nach der ursprünglichen Frage vergangen sind, ist es nun erwähnenswert, dass Microsoft eine eigene Lösung entwickelt hat. Siehe http://blogs.msdn.com/b/vbertocci/archive/2012/11/20/introducing-the-developer-preview-of-the-json-web-token-handler-for-the-microsoft-net -framework-4-5.aspx für Details.

Jouni Heikniemi
quelle
7
Das Nuget-Paket in diesem Blog ist abgeschrieben. Ich glaube, der neue ist nuget.org/packages/System.IdentityModel.Tokens.Jwt/…
Stan
3
@Stan dieser Link ist großartig, aber auf eine bestimmte (und jetzt veraltete) Version eingestellt. Dies zeigt immer auf die neueste Version. nuget.org/packages/System.IdentityModel.Tokens.Jwt
Jeffrey Harmon
3
Einige Codefragmente, die die Verwendung demonstrieren (Codierung / Decodierung, symmetrisch / asymmetrisch), wären sehr nützlich.
Ohad Schneider
6

Dies ist meine Implementierung der (Google) JWT-Validierung in .NET. Es basiert auf anderen Implementierungen in Stack Overflow- und GitHub-Gists.

using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Net.Http;
using System.Security.Claims;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;

namespace QuapiNet.Service
{
    public class JwtTokenValidation
    {
        public async Task<Dictionary<string, X509Certificate2>> FetchGoogleCertificates()
        {
            using (var http = new HttpClient())
            {
                var response = await http.GetAsync("https://www.googleapis.com/oauth2/v1/certs");

                var dictionary = await response.Content.ReadAsAsync<Dictionary<string, string>>();
                return dictionary.ToDictionary(x => x.Key, x => new X509Certificate2(Encoding.UTF8.GetBytes(x.Value)));
            }
        }

        private string CLIENT_ID = "xxx.apps.googleusercontent.com";

        public async Task<ClaimsPrincipal> ValidateToken(string idToken)
        {
            var certificates = await this.FetchGoogleCertificates();

            TokenValidationParameters tvp = new TokenValidationParameters()
            {
                ValidateActor = false, // check the profile ID

                ValidateAudience = true, // check the client ID
                ValidAudience = CLIENT_ID,

                ValidateIssuer = true, // check token came from Google
                ValidIssuers = new List<string> { "accounts.google.com", "https://accounts.google.com" },

                ValidateIssuerSigningKey = true,
                RequireSignedTokens = true,
                IssuerSigningKeys = certificates.Values.Select(x => new X509SecurityKey(x)),
                IssuerSigningKeyResolver = (token, securityToken, kid, validationParameters) =>
                {
                    return certificates
                    .Where(x => x.Key.ToUpper() == kid.ToUpper())
                    .Select(x => new X509SecurityKey(x.Value));
                },
                ValidateLifetime = true,
                RequireExpirationTime = true,
                ClockSkew = TimeSpan.FromHours(13)
            };

            JwtSecurityTokenHandler jsth = new JwtSecurityTokenHandler();
            SecurityToken validatedToken;
            ClaimsPrincipal cp = jsth.ValidateToken(idToken, tvp, out validatedToken);

            return cp;
        }
    }
}

Beachten Sie, dass Sie zur Verwendung einen Verweis auf das NuGet-Paket hinzufügen müssen System.Net.Http.Formatting.Extension. Ohne dies erkennt der Compiler die ReadAsAsync<>Methode nicht.

Thomas
quelle
Warum müssten Sie einstellen, IssuerSigningKeyswenn das IssuerSigningKeyResolverzur Verfügung gestellt wird?
AsifM
@AsifMD Weiß nicht wirklich und kann es im Moment nicht testen. Möglicherweise funktioniert es, ohne IssuerSigningKey festzulegen. Sie müssen auch den Resolver-Code ändern, um die Zertifikate anzufordern, da sonst innerhalb weniger Tage eine Fehlermeldung angezeigt wird, wenn Google die Zertifikate ändert.
Thomas
+1 für diesen einfachsten Ansatz. Verwendet PM> Install-Package System.IdentityModel.Tokens.Jwt -Version 5.2.4 zur Unterstützung von System.IdentityModel
Karthick Jayaraman
1

Es wäre besser, Standard- und berühmte Bibliotheken zu verwenden, als den Code von Grund auf neu zu schreiben.

  1. JWT zum Codieren und Decodieren von JWT-Token
  2. Hüpfburg unterstützt die Verschlüsselung und Entschlüsselung, insbesondere RS256 sie bekommen hier

Mit diesen Bibliotheken können Sie ein JWT-Token generieren und mit RS256 wie folgt signieren.

    public string GenerateJWTToken(string rsaPrivateKey)
    {
        var rsaParams = GetRsaParameters(rsaPrivateKey);
        var encoder = GetRS256JWTEncoder(rsaParams);

        // create the payload according to the Google's doc
        var payload = new Dictionary<string, object>
        {
            { "iss", ""},
            { "sub", "" },
            // and other key-values according to the doc
        };

        // add headers. 'alg' and 'typ' key-values are added automatically.
        var header = new Dictionary<string, object>
        {
            { "kid", "{your_private_key_id}" },
        };

        var token = encoder.Encode(header,payload, new byte[0]);

        return token;
    }

    private static IJwtEncoder GetRS256JWTEncoder(RSAParameters rsaParams)
    {
        var csp = new RSACryptoServiceProvider();
        csp.ImportParameters(rsaParams);

        var algorithm = new RS256Algorithm(csp, csp);
        var serializer = new JsonNetSerializer();
        var urlEncoder = new JwtBase64UrlEncoder();
        var encoder = new JwtEncoder(algorithm, serializer, urlEncoder);

        return encoder;
    }

    private static RSAParameters GetRsaParameters(string rsaPrivateKey)
    {
        var byteArray = Encoding.ASCII.GetBytes(rsaPrivateKey);
        using (var ms = new MemoryStream(byteArray))
        {
            using (var sr = new StreamReader(ms))
            {
                // use Bouncy Castle to convert the private key to RSA parameters
                var pemReader = new PemReader(sr);
                var keyPair = pemReader.ReadObject() as AsymmetricCipherKeyPair;
                return DotNetUtilities.ToRSAParameters(keyPair.Private as RsaPrivateCrtKeyParameters);
            }
        }
    }

ps: Der private RSA-Schlüssel sollte das folgende Format haben:

----- RSA PRIVATE KEY BEGINNEN ----- {Base64-formatierter Wert} ----- END RSA PRIVATE KEY -----

Ehsan Mirsaeedi
quelle
0

Hier ist ein weiteres REST- Beispiel für Google Service-Konten, die auf G Suite- Benutzer und -Gruppen zugreifen und sich über JWT authentifizieren . Dies war nur durch Reflexion von Google-Bibliotheken möglich, da die Google-Dokumentation dieser APIs mehr als schrecklich ist . Jeder, der mit dem Codieren in MS-Technologien vertraut ist, wird es schwer haben, herauszufinden, wie alles in den Google-Diensten zusammenpasst.

$iss = "<name>@<serviceaccount>.iam.gserviceaccount.com"; # The email address of the service account.
$sub = "[email protected]"; # The user to impersonate (required).
$scope = "https://www.googleapis.com/auth/admin.directory.user.readonly https://www.googleapis.com/auth/admin.directory.group.readonly";
$certPath = "D:\temp\mycertificate.p12";
$grantType = "urn:ietf:params:oauth:grant-type:jwt-bearer";

# Auxiliary functions
function UrlSafeEncode([String] $Data) {
    return $Data.Replace("=", [String]::Empty).Replace("+", "-").Replace("/", "_");
}

function UrlSafeBase64Encode ([String] $Data) {
    return (UrlSafeEncode -Data ([Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($Data))));
}

function KeyFromCertificate([System.Security.Cryptography.X509Certificates.X509Certificate2] $Certificate) {
    $privateKeyBlob = $Certificate.PrivateKey.ExportCspBlob($true);
    $key = New-Object System.Security.Cryptography.RSACryptoServiceProvider;
    $key.ImportCspBlob($privateKeyBlob);
    return $key;
}

function CreateSignature ([Byte[]] $Data, [System.Security.Cryptography.X509Certificates.X509Certificate2] $Certificate) {
    $sha256 = [System.Security.Cryptography.SHA256]::Create();
    $key = (KeyFromCertificate $Certificate);
    $assertionHash = $sha256.ComputeHash($Data);
    $sig = [Convert]::ToBase64String($key.SignHash($assertionHash, "2.16.840.1.101.3.4.2.1"));
    $sha256.Dispose();
    return $sig;
}

function CreateAssertionFromPayload ([String] $Payload, [System.Security.Cryptography.X509Certificates.X509Certificate2] $Certificate) {
    $header = @"
{"alg":"RS256","typ":"JWT"}
"@;
    $assertion = New-Object System.Text.StringBuilder;

    $assertion.Append((UrlSafeBase64Encode $header)).Append(".").Append((UrlSafeBase64Encode $Payload)) | Out-Null;
    $signature = (CreateSignature -Data ([System.Text.Encoding]::ASCII.GetBytes($assertion.ToString())) -Certificate $Certificate);
    $assertion.Append(".").Append((UrlSafeEncode $signature)) | Out-Null;
    return $assertion.ToString();
}

$baseDateTime = New-Object DateTime(1970, 1, 1, 0, 0, 0, [DateTimeKind]::Utc);
$timeInSeconds = [Math]::Truncate([DateTime]::UtcNow.Subtract($baseDateTime).TotalSeconds);

$jwtClaimSet = @"
{"scope":"$scope","email_verified":false,"iss":"$iss","sub":"$sub","aud":"https://oauth2.googleapis.com/token","exp":$($timeInSeconds + 3600),"iat":$timeInSeconds}
"@;


$cert = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2($certPath, "notasecret", [System.Security.Cryptography.X509Certificates.X509KeyStorageFlags]::Exportable);
$jwt = CreateAssertionFromPayload -Payload $jwtClaimSet -Certificate $cert;


# Retrieve the authorization token.
$authRes = Invoke-WebRequest -Uri "https://oauth2.googleapis.com/token" -Method Post -ContentType "application/x-www-form-urlencoded" -UseBasicParsing -Body @"
assertion=$jwt&grant_type=$([Uri]::EscapeDataString($grantType))
"@;
$authInfo = ConvertFrom-Json -InputObject $authRes.Content;

$resUsers = Invoke-WebRequest -Uri "https://www.googleapis.com/admin/directory/v1/users?domain=<required_domain_name_dont_trust_google_documentation_on_this>" -Method Get -Headers @{
    "Authorization" = "$($authInfo.token_type) $($authInfo.access_token)"
}

$users = ConvertFrom-Json -InputObject $resUsers.Content;

$users.users | ft primaryEmail, isAdmin, suspended;
Vinicius
quelle
0

Hier ist die Liste der Klassen und Funktionen:

open System
open System.Collections.Generic
open System.Linq
open System.Threading.Tasks
open Microsoft.AspNetCore.Mvc
open Microsoft.Extensions.Logging
open Microsoft.AspNetCore.Authorization
open Microsoft.AspNetCore.Authentication
open Microsoft.AspNetCore.Authentication.JwtBearer
open Microsoft.IdentityModel.Tokens
open System.IdentityModel.Tokens
open System.IdentityModel.Tokens.Jwt
open Microsoft.IdentityModel.JsonWebTokens
open System.Text
open Newtonsoft.Json
open System.Security.Claims
    let theKey = "VerySecretKeyVerySecretKeyVerySecretKey"
    let securityKey = SymmetricSecurityKey(Encoding.UTF8.GetBytes(theKey))
    let credentials = SigningCredentials(securityKey, SecurityAlgorithms.RsaSsaPssSha256)
    let expires = DateTime.UtcNow.AddMinutes(123.0) |> Nullable
    let token = JwtSecurityToken(
                    "lahoda-pro-issuer", 
                    "lahoda-pro-audience",
                    claims = null,
                    expires =  expires,
                    signingCredentials = credentials
        )

    let tokenString = JwtSecurityTokenHandler().WriteToken(token)
Dzmitry Lahoda
quelle