刷新浏览器时，如何处理Blazor Server中的用户OIDC令牌，而Cookie的令牌是无效的？

Question

Microsoft建议不要在Blazor Server中使用httpcontext（在这里）。要解决如何将用户令牌传递到Blazor Server应用程序的问题，Microsoft建议将令牌存储在scoped服务中（在这里）。乔恩·麦奎尔（Jon McGuire）的博客提出了一种类似的方法，该方法将令牌存储在cache中（在这里）。

只要用户留在同一Blazor服务器连接中，Microsoft的方法就可以正常工作。 但是，如果access_token被刷新，然后用户通过按F5或将URL粘贴到地址栏来重新加载页面，然后尝试试图检索令牌来自饼干。到这个时候， access_token和cookie中的refresh_token不再有效。乔恩·麦奎尔（Jon McGuire 。他给出了可能的解决方案的提示，但非常适合实施说明。该帖子的底部有很多评论，无法实施解决方案，没有明显的工作解决方案。我花了很多时间寻找解决方案，我发现的只是有人要求一个解决方案而没有收到任何有效的答案。

找到了一个似乎运行良好的解决方案，而且似乎也很有原则，我认为可能值得在这里分享我的解决方案。我欢迎对任何重大改进的建设性批评或建议。

Answer 1

编辑20220715：在对Dominic Baier的方法进行了一些反馈之后，我们删除了scoped userSubProvider服务，有利于使用authEthationalticationStateProvider。这简化了我们的方法。我已经编辑了以下答案，以反映这一更改。

---

这种方法结合了Microsoft关于如何将令牌传递给Blazor Server应用程序的建议（在此），服务器端存储的存储singleton中的令牌为所有用户提供服务（受多米尼克·拜尔（Dominick Baier）的Blazor Server示例项目的启发在这里）。

我们没有在 _host.cshtml 文件中捕获代币并将其存储在scoped服务中（例如Microsoft在示例中执行），我们使用ontokenvalidated 事件的方式与Dominick Baier的样本类似，将令牌存储在singleton服务中，该服务可容纳所有人用户，我们调用此服务serversIdEtokenstore。

当我们使用httpclient调用API时，它需要access_token（或refresh_token），然后将其检索user 从注射authenticationStateProvider中使用它来调用serversIdeTokenStore.getTokenSasync（），返回usertokenProvider（类似于Microsoft的tokenProvider）包含代币。如果httpclient需要刷新令牌，则它将填充userTokenProvider，并通过调用serversideTekenStore.setTokensSync（）来保存它。

我们遇到的另一个问题是，如果应用程序重新启动时，Web浏览器的单独实例是打开的（因此，丢失了在serversideTokenstore中持有的数据），则使用cookie进行身份验证，但是我们已经通过丢失access_token和refresh_token。如果重新启动应用程序，则可能在生产中发生，但是在开发环境中发生的频率更高。如果我们无法获得合适的access_token，我们通过处理onvalidatePrincipal onvalidatePrincipal 来解决此问题。这迫使往返身份服务器，提供新的access_token和refresh_token。这种方法来自此堆栈溢出线程。

某些代码不包括一些标准错误处理，日志记录等。

（

为了清晰/焦点，遵循的 代码> sub 从注射AuthenticationStateProvider中要求。它使用userub字符串时，呼叫serversIdeTokenStore.getToKensAsync（）和serversIdeTokenStore.setTokensAsync（）。

    var state = await AuthenticationStateProvider.GetAuthenticationStateAsync();
    string userSub = state.User.FindFirst("sub")?.Value;

usertokenProvider

    public class UserTokenProvider
    {
        public string AccessToken { get; set; }
        public string RefreshToken { get; set; }
        public DateTimeOffset Expiration { get; set; }
    }

serversIdeTokenstore

    public class ServerSideTokenStore
    {
        private readonly ConcurrentDictionary<string, UserTokenProvider> UserTokenProviders = new();
    
        public Task ClearTokensAsync(string userSub)
        {
            UserTokenProviders.TryRemove(userSub, out _);
            return Task.CompletedTask;
        }
    
        public Task<UserTokenProvider> GetTokensAsync(string userSub)
        {
            UserTokenProviders.TryGetValue(userSub, out var value);
            return Task.FromResult(value);
        }
    
        public Task StoreTokensAsync(string userSub, UserTokenProvider userTokenProvider)
        {
            UserTokenProviders[userSub] = userTokenProvider;
            Return Task.CompletedTask;
        }
    }

startup.cs configureservices（或使用.NET 6/whitch）

    public void ConfigureServices(IServiceCollection services)
    {
        // …
        services.AddAuthentication(…)
        .AddCookie(“Cookies”, options =>
        {
            // …
            options.Events.OnValidatePrincipal = async context =>
            {
                if (context.Principal.Identity.IsAuthenticated)
                {
                    // get user sub 
                    var userSub = context.Principal.FindFirst(“sub”).Value;
                    // get user's tokens from server side token store
                    var tokenStore =
                        context.HttpContext.RequestServices.GetRequiredService<IServerSideTokenStore>();
                    var tokens = await tokenStore.GetTokenAsync(userSub);
                    if (tokens?.AccessToken == null 
                        || tokens?.Expiration == null 
                        || tokens?.RefreshToken == null)
                    {
                        // if we lack either an access or refresh token,
                        // then reject the Principal (forcing a round trip to the id server)
                        context.RejectPrincipal();
                        return;
                    }
                    // if the access token has expired, attempt to refresh it
                    if (tokens.Expiration < DateTimeOffset.UtcNow) 
                    {
                        // we have a custom API client that takes care of refreshing our tokens 
                        // and storing them in ServerSideTokenStore, we call that here
                        // …
                        // check the tokens have been updated
                        var newTokens = await tokenStore.GetTokenAsync(userSubProvider.UserSub);
                        if (newTokens?.AccessToken == null 
                            || newTokens?.Expiration == null 
                            || newTokens.Expiration < DateTimeOffset.UtcNow)
                        {
                            // if we lack an access token or it was not successfully renewed, 
                            // then reject the Principal (forcing a round trip to the id server)
                            context.RejectPrincipal();
                            return;
                        }
                    }
                }
            }
        }
        .AddOpenIdConnect(“oidc”, options =>
        {
            // …
            options.Events.OnTokenValidated = async n =>
            {
                var svc = n.HttpContext.RequestServices.GetRequiredService<IServerSideTokenStore>();
                var culture = new CultureInfo(“EN”) ;
                var exp = DateTimeOffset
                          .UtcNow
                          .AddSeconds(double.Parse(n.TokenEndpointResponse !.ExpiresIn, culture));
                var userTokenProvider = new UserTokenProvider() 
                {
                    AcessToken = n.TokenEndpointResponse.AccessToken,
                    Expiration = exp,
                    RefreshToken = n.TokenEndpointResponse.RefreshToken
                }
                await svc.StoreTokensAsync(n.Principal.FindFirst(“sub”).Value, userTokenProvider);
            };
            // …
        });
        // …
    }