web-dev-qa-db-ja.com

OpenId Connectで更新トークンを使用して、asp.netコアで期限切れのアクセストークンを処理する方法

"Microsoft.AspNetCore.Authentication.OpenIdConnect"： "1.0.0 and" Microsoft.AspNetCore.Authentication.Cookies "：" 1.0.0 "を使用するASOS OpenIdConnectサーバーとasp.netコアmvc​​アプリを構成しました。 「Authorization Code」ワークフローをテストしましたが、すべてが機能します。

クライアントWebアプリは認証を期待どおりに処理し、id_token、access_token、およびrefresh_tokenを格納するCookieを作成します。

Microsoft.AspNetCore.Authentication.OpenIdConnectが期限切れになったときに新しいaccess_tokenを要求するように強制するにはどうすればよいですか？

Asp.netコアmvc​​アプリは、期限切れのaccess_tokenを無視します。

Openidconnectで期限切れのaccess_tokenを確認し、更新トークンを使用して呼び出しを行い、新しいaccess_tokenを取得します。また、Cookieの値も更新する必要があります。更新トークン要求が失敗した場合、openidconnectがCookieを「ログアウト」する（それを削除するなど）と予想します。

app.UseCookieAuthentication(new CookieAuthenticationOptions
        {
            AutomaticAuthenticate = true,
            AutomaticChallenge = true,
            AuthenticationScheme = "Cookies"
        });

app.UseOpenIdConnectAuthentication(new OpenIdConnectOptions
        {
            ClientId = "myClient",
            ClientSecret = "secret_secret_secret",
            PostLogoutRedirectUri = "http://localhost:27933/",
            RequireHttpsMetadata = false,
            GetClaimsFromUserInfoEndpoint = true,
            SaveTokens = true,
            ResponseType = OpenIdConnectResponseType.Code,
            AuthenticationMethod = OpenIdConnectRedirectBehavior.RedirectGet,
            Authority = http://localhost:27933,
            MetadataAddress = "http://localhost:27933/connect/config",
            Scope = { "email", "roles", "offline_access" },
        });
cookiesasp.net-coreopenid-connectaspnet-contrib
13
longday

Asp.netコアのopenidconnect認証には、受信後にサーバー上のaccess_tokenを管理するプログラミングがないようです。

Cookie検証イベントをインターセプトして、アクセストークンの有効期限が切れていないかどうかを確認できることがわかりました。その場合は、grant_type = refresh_tokenを使用して、トークンエンドポイントに手動でHTTP呼び出しを行います。

Context.ShouldRenew = true;を呼び出す。これにより、Cookieが更新され、応答でクライアントに送り返されます。

私は自分が行ったことの基礎を提供しました。すべての作業が解決されたら、この回答を更新するよう努めます。

app.UseCookieAuthentication(new CookieAuthenticationOptions
        {
            AutomaticAuthenticate = true,
            AutomaticChallenge = true,
            AuthenticationScheme = "Cookies",
            ExpireTimeSpan = new TimeSpan(0, 0, 20),
            SlidingExpiration = false,
            CookieName = "WebAuth",
            Events = new CookieAuthenticationEvents()
            {
                OnValidatePrincipal = context =>
                {
                    if (context.Properties.Items.ContainsKey(".Token.expires_at"))
                    {
                        var expire = DateTime.Parse(context.Properties.Items[".Token.expires_at"]);
                        if (expire > DateTime.Now) //TODO:change to check expires in next 5 mintues.
                        {
                            logger.Warn($"Access token has expired, user: {context.HttpContext.User.Identity.Name}");

                            //TODO: send refresh token to ASOS. Update tokens in context.Properties.Items
                            //context.Properties.Items["Token.access_token"] = newToken;
                            context.ShouldRenew = true;
                        }
                    }
                    return Task.FromResult(0);
                }
            }
        });
15
longday

Startup.csを設定して、refresh_tokenの生成を有効にする必要があります。

  • 値をAuthorizationEndpointPath = "/ connect/authorize"に設定します。 // refreshtokenに必要
  • TokenEndpointPath = "/ connect/token"に値を設定します。 //標準トークンのエンドポイント名

トークンプロバイダーで、HandleTokenrequestメソッドの最後でトークンリクエストを検証する前に、オフラインスコープを設定したことを確認します。

        // Call SetScopes with the list of scopes you want to grant
        // (specify offline_access to issue a refresh token).
        ticket.SetScopes(
            OpenIdConnectConstants.Scopes.Profile,
            OpenIdConnectConstants.Scopes.OfflineAccess);

これが正しく設定されている場合、パスワードgrant_typeでログインすると、refresh_tokenが返されます。

次に、クライアントから次のリクエストを発行する必要があります（私はAureliaを使用しています）：

refreshToken() {
    let baseUrl = yourbaseUrl;

    let data = "client_id=" + this.appState.clientId
               + "&grant_type=refresh_token"
               + "&refresh_token=myRefreshToken";

    return this.http.fetch(baseUrl + 'connect/token', {
        method: 'post',
        body : data,
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
            'Accept': 'application/json' 
        }
    });
}

それだけです。HandleRequestTokenの認証プロバイダーがタイプrefresh_tokenのリクエストを操作しようとしていないことを確認してください。

    public override async Task HandleTokenRequest(HandleTokenRequestContext context)
    {
        if (context.Request.IsPasswordGrantType())
        {
            // Password type request processing only
            // code that shall not touch any refresh_token request
        }
        else if(!context.Request.IsRefreshTokenGrantType())
        {
            context.Reject(
                    error: OpenIdConnectConstants.Errors.InvalidGrant,
                    description: "Invalid grant type.");
            return;
        }

        return;
    }

Refresh_tokenは、このメソッドを通過できるだけで、refresh_tokenを処理する別のミドルウェアによって処理されます。

認証サーバーが何をしているかについてさらに深く知りたい場合は、OpenIdConnectServerHandlerのコードを見ることができます。

https://github.com/aspnet-contrib/AspNet.Security.OpenIdConnect.Server/blob/master/src/AspNet.Security.OpenIdConnect.Server/OpenIdConnectServerHandler.Exchange.cs

クライアント側では、トークンの自動更新も処理できる必要があります。これは、Angular 1.Xのhttpインターセプターの例です。401の応答を処理し、トークンを更新します。 、次にリクエストを再試行します。

'use strict';
app.factory('authInterceptorService',
    ['$q', '$injector', '$location', 'localStorageService',
    function ($q, $injector, $location, localStorageService) {

    var authInterceptorServiceFactory = {};
    var $http;

    var _request = function (config) {

        config.headers = config.headers || {};

        var authData = localStorageService.get('authorizationData');
        if (authData) {
            config.headers.Authorization = 'Bearer ' + authData.token;
        }

        return config;
    };

    var _responseError = function (rejection) {
        var deferred = $q.defer();
        if (rejection.status === 401) {
            var authService = $injector.get('authService');
            console.log("calling authService.refreshToken()");
            authService.refreshToken().then(function (response) {
                console.log("token refreshed, retrying to connect");
                _retryHttpRequest(rejection.config, deferred);
            }, function () {
                console.log("that didn't work, logging out.");
                authService.logOut();

                $location.path('/login');
                deferred.reject(rejection);
            });
        } else {
            deferred.reject(rejection);
        }
        return deferred.promise;
    };

    var _retryHttpRequest = function (config, deferred) {
        console.log('autorefresh');
        $http = $http || $injector.get('$http');
        $http(config).then(function (response) {
            deferred.resolve(response);
        },
        function (response) {
            deferred.reject(response);
        });
    }

    authInterceptorServiceFactory.request = _request;
    authInterceptorServiceFactory.responseError = _responseError;
    authInterceptorServiceFactory.retryHttpRequest = _retryHttpRequest;

    return authInterceptorServiceFactory;
}]);

次に、Aureliaで行った例を示します。今回は、トークンが期限切れかどうかをチェックするhttpハンドラーにHTTPクライアントをラップしました。有効期限が切れている場合は、最初にトークンを更新してから、リクエストを実行します。クライアント側のデータサービスとのインターフェースの一貫性を維持するためにpromiseを使用します。このハンドラーは、aurelia-fetchクライアントと同じインターフェースを公開します。

import {inject} from 'aurelia-framework';
import {HttpClient} from 'aurelia-fetch-client';
import {AuthService} from './authService';

@inject(HttpClient, AuthService)
export class HttpHandler {

    constructor(httpClient, authService) {
        this.http = httpClient;
        this.authService = authService;
    }

    fetch(url, options){
        let _this = this;
        if(this.authService.tokenExpired()){
            console.log("token expired");
            return new Promise(
                function(resolve, reject) {
                    console.log("refreshing");
                    _this.authService.refreshToken()
                    .then(
                       function (response) {
                           console.log("token refreshed");
                        _this.http.fetch(url, options).then(
                            function (success) { 
                                console.log("call success", url);
                                resolve(success);
                            }, 
                            function (error) { 
                                console.log("call failed", url);
                                reject(error); 
                            }); 
                       }, function (error) {
                           console.log("token refresh failed");
                           reject(error);
                    });
                }
            );
        } 
        else {
            // token is not expired, we return the promise from the fetch client
            return this.http.fetch(url, options); 
        }
    }
}

Jqueryの場合、jquery oAuthを見ることができます：

https://github.com/esbenp/jquery-oauth

お役に立てれば。

2
Darxtar

@longdayの回答に続いて、私はこのコードを使用して、オープンIDエンドポイントを手動でクエリする必要なく、クライアントを強制的に更新することに成功しました。

OnValidatePrincipal = context =>
{
    if (context.Properties.Items.ContainsKey(".Token.expires_at"))
    {
        var expire = DateTime.Parse(context.Properties.Items[".Token.expires_at"]);
        if (expire > DateTime.Now) //TODO:change to check expires in next 5 mintues.
        {
            context.ShouldRenew = true;
            context.RejectPrincipal();
        }
    }

    return Task.FromResult(0);
}
0
Shane