用于支持JWT密钥轮换的承载令牌身份验证的Owin中间件

Question

我正在寻找一些指导，配置owin中间件承载令牌身份验证，以支持Open Id Connect密钥旋转。

Opend Id Connect规范说明了以下有关关键点旋转的内容：

签名密钥的旋转可以通过以下方法完成。签名者在其jwks_uri位置的JWK集中发布其密钥，并在每条消息的JOSE头中包含签名密钥的kid，以向验证者指示将使用哪个密钥验证签名。可以通过定期向jwks_uri位置的JWK集合添加新键来滚动键。签名者可以自行决定开始使用新密钥，并使用kid值向验证器发送更改信号。当验证器看到一个不熟悉的kid值时，它知道返回jwks_uri位置重新检索密钥。

关于这个问题，我能找到的最相似的问题是：连接到Google的OWIN OpenID Connect中间件中的SecurityTokenSignatureKeyNotFoundException

该解决方案不太管用，因为在发出新私钥和客户端刷新其公钥缓存之间，您会遇到错误。

因此，我想将客户端配置为在发现有效、正确签名、未过期的JWT令牌时下载丢失的公共JWK密钥，该令牌包含未在本地缓存的kid。

我目前正在使用标识符服务器3。访问令牌验证，但当客户端用它不认识的孩子回收令牌时，它不会下载新密钥。

我快速浏览了一下微软。Owin.安全。Jwt-

我正在寻找一些方向来扩展/配置上述任何包，以支持键旋转。

Answer 1

我用这个系统算出了。IdentityModel。代币。Jwt图书馆。我在版本控制方面遇到了很多麻烦，所以我包括了我最终使用的nuget包。我和微软有很多问题。IdentityModel。代币。所以我放弃了这种方法。无论如何，以下是软件包：

<package id="Microsoft.IdentityModel.Protocol.Extensions" version="1.0.2.206221351" targetFramework="net462" />
<package id="Microsoft.Win32.Primitives" version="4.0.1" targetFramework="net462" />
<package id="System.IdentityModel.Tokens.Jwt" version="4.0.2.206221351" targetFramework="net462" />
<package id="System.Net.Http" version="4.1.0" targetFramework="net462" />
<package id="System.Security.Cryptography.Algorithms" version="4.2.0" targetFramework="net462" />
<package id="System.Security.Cryptography.Encoding" version="4.0.0" targetFramework="net462" />
<package id="System.Security.Cryptography.Primitives" version="4.0.0" targetFramework="net462" />
<package id="System.Security.Cryptography.X509Certificates" version="4.1.0" targetFramework="net462" />

这是代码。其工作方式是设置自定义密钥解析程序。每次传入令牌时，都会调用此密钥解析程序。当我们得到一个kid缓存未命中时，我们向令牌服务发出一个新请求，以下载最新的密钥集。起初，我想先检查密钥的各个部分（即未过期/有效的颁发者），但后来决定不这样做，因为如果我们无法确认令牌已正确签名，那么添加这些检查是毫无意义的。攻击者可以设置他们想要的任何内容。

using Microsoft.IdentityModel.Protocols;
using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Threading;
using System.Threading.Tasks;

public class ValidationMiddleware
{
    private readonly Func<IDictionary<string, object>, Task> next;
    private readonly Func<string> tokenAccessor;
    private readonly ConfigurationManager<OpenIdConnectConfiguration> configurationManager;

    private readonly Object locker = new Object();
    private Dictionary<string, SecurityKey> securityKeys = new Dictionary<string, SecurityKey>();

    public ValidationMiddleware(Func<IDictionary<string, object>, Task> next, Func<string> tokenAccessor)
    {
        this.next = next;
        this.tokenAccessor = tokenAccessor;

        configurationManager = new ConfigurationManager<OpenIdConnectConfiguration>(
            "url to open id connect token service", 
            new HttpClient(new WebRequestHandler()))
        {
            // Refresh the keys once an hour
            AutomaticRefreshInterval = new TimeSpan(1, 0, 0)
        };
    }

    public async Task Invoke(IDictionary<string, object> environment)
    {
        var token = tokenAccessor();

        var validationParameters = new TokenValidationParameters
        {
            ValidAudience = "my valid audience",
            ValidIssuer = "url to open id connect token service",
            ValidateLifetime = true,
            RequireSignedTokens = true,
            RequireExpirationTime = true,
            ValidateAudience = true,
            ValidateIssuer = true,
            IssuerSigningKeyResolver = MySigningKeyResolver, // Key resolver gets called for every token
        };

        JwtSecurityTokenHandler.InboundClaimTypeMap.Clear();

        var tokenHandler = new JwtSecurityTokenHandler(); 
        var claimsPrincipal = tokenHandler.ValidateToken(token, validationParameters, out SecurityToken validatedToken);

        // Assign Claims Principal to the context.

        await next.Invoke(environment);
    }

    private SecurityKey MySigningKeyResolver(string token, SecurityToken securityToken, SecurityKeyIdentifier keyIdentifier, TokenValidationParameters validationParameters)
    {
        var kid = keyIdentifier.OfType<NamedKeySecurityKeyIdentifierClause>().FirstOrDefault().Id;

        if (!securityKeys.TryGetValue(kid, out SecurityKey securityKey))
        {
            lock (locker)
            {
                // Double lock check to ensure that only the first thread to hit the lock gets the latest keys.
                if (!securityKeys.TryGetValue(kid, out securityKey))
                {
                    // TODO - Add throttling around this so that an attacker can't force tonnes of page requests.

                    // Microsoft's Async Helper
                    var result = AsyncHelper.RunSync(async () => await configurationManager.GetConfigurationAsync());

                    var latestSecurityKeys = new Dictionary<string, SecurityKey>();
                    foreach (var key in result.JsonWebKeySet.Keys)
                    {
                        var rsa = RSA.Create();
                        rsa.ImportParameters(new RSAParameters
                        {
                            Exponent = Base64UrlEncoder.DecodeBytes(key.E),
                            Modulus = Base64UrlEncoder.DecodeBytes(key.N),
                        });
                        latestSecurityKeys.Add(key.Kid, new RsaSecurityKey(rsa));

                        if (kid == key.Kid)
                        {
                            securityKey = new RsaSecurityKey(rsa);
                        }
                    }

                    // Explicitly state that this assignment needs to be atomic.
                    Interlocked.Exchange(ref securityKeys, latestSecurityKeys);
                }
            }
        }

        return securityKey;
    }
}

对获取密钥进行一些限制对于阻止恶意用户强制多次往返令牌服务是有意义的。