ASP.NET Coreでのトークンベースの認証


161

ASP.NET Coreアプリケーションを使用しています。トークンベースの認証を実装しようとしていますが、新しいセキュリティシステムを使用する方法がわかりません。私はを試してみましたが、彼らは私をあまり助けませんでした、彼らはクッキー認証または外部認証(GitHub、Microsoft、Twitter)のどちらかを使用しています。

私のシナリオは何ですか:angularjsアプリケーションは、/tokenユーザー名とパスワードを渡すURLを要求する必要があります。WebApiはユーザーを承認しaccess_token、次のリクエストでangularjsアプリが使用するものを返す必要があります。

ASP.NETの現在のバージョン-ASP.NET Web API 2、Owin、およびIdentityを使用したトークンベースの認証に必要なものを正確に実装することに関する優れた記事を見つけました。しかし、ASP.NET Coreで同じことをする方法は私には明らかではありません。

私の質問は、ASP.NET Core WebApiアプリケーションをトークンベースの認証で動作するように構成する方法ですか。


私は同じ問題を抱えて、私は自分自身が、FYI別の質問があることをすべて行う上で滑走た stackoverflow.com/questions/29055477/...が、無anserwはまだ、のが起こるか見てみましょう
Son_of_Sam


私も同じ問題に直面していますが、解決策がまだ見つかりません...トークンを認証する別のサービスを使用してカスタム認証を作成する必要があります。
Mayank Gupta

回答:


137

.Net Core 3.1の更新:

David Fowler(ASP .NET Coreチームのアーキテクト)は、JWTを示す単純なアプリケーションを含む、非常に単純な一連のタスクアプリケーションをまとめました。私は彼の更新と単純化したスタイルをこの投稿に組み込みます。

.Net Core 2用に更新:

この回答の以前のバージョンはRSAを使用していました。トークンを生成している同じコードがトークンを検証している場合、それは本当に必要ではありません。ただし、責任を分散する場合でも、おそらくのインスタンスを使用してこれを実行する必要がありますMicrosoft.IdentityModel.Tokens.RsaSecurityKey

  1. 後で使用する定数をいくつか作成します。これが私がしたことです:

    const string TokenAudience = "Myself";
    const string TokenIssuer = "MyProject";
  2. これをStartup.csに追加しますConfigureServices。後で依存性注入を使用して、これらの設定にアクセスします。私はあなたauthenticationConfigurationがデバッグまたは本番用に異なる設定を持つことができるようなオブジェクトConfigurationSectionまたはConfigurationオブジェクトであると想定しています。キーは安全に保管してください。任意の文字列を指定できます。

    var keySecret = authenticationConfiguration["JwtSigningKey"];
    var symmetricKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(keySecret));
    
    services.AddTransient(_ => new JwtSignInHandler(symmetricKey));
    
    services.AddAuthentication(options =>
    {
        // This causes the default authentication scheme to be JWT.
        // Without this, the Authorization header is not checked and
        // you'll get no results. However, this also means that if
        // you're already using cookies in your app, they won't be 
        // checked by default.
        options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    })
        .AddJwtBearer(options =>
        {
            options.TokenValidationParameters.ValidateIssuerSigningKey = true;
            options.TokenValidationParameters.IssuerSigningKey = symmetricKey;
            options.TokenValidationParameters.ValidAudience = JwtSignInHandler.TokenAudience;
            options.TokenValidationParameters.ValidIssuer = JwtSignInHandler.TokenIssuer;
        });

    他の回答が他の設定を変更するのを見ましたClockSkew。デフォルトは、クロックが正確に同期していない分散環境で機能するように設定されています。これらは、変更する必要がある唯一の設定です。

  3. 認証を設定します。Userなどの情報を必要とするミドルウェアの前に、この行が必要app.UseMvc()です。

    app.UseAuthentication();

    これにより、トークンがSignInManagerやその他で発行されることはありません。JWTを出力するための独自のメカニズムを提供する必要があります-以下を参照してください。

  4. を指定することができますAuthorizationPolicy。これにより、を使用した認証としてベアラートークンのみを許可するコントローラーとアクションを指定できます[Authorize("Bearer")]

    services.AddAuthorization(auth =>
    {
        auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
            .AddAuthenticationTypes(JwtBearerDefaults.AuthenticationType)
            .RequireAuthenticatedUser().Build());
    });
  5. ここでトリッキーな部分があります:トークンの構築です。

    class JwtSignInHandler
    {
        public const string TokenAudience = "Myself";
        public const string TokenIssuer = "MyProject";
        private readonly SymmetricSecurityKey key;
    
        public JwtSignInHandler(SymmetricSecurityKey symmetricKey)
        {
            this.key = symmetricKey;
        }
    
        public string BuildJwt(ClaimsPrincipal principal)
        {
            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
    
            var token = new JwtSecurityToken(
                issuer: TokenIssuer,
                audience: TokenAudience,
                claims: principal.Claims,
                expires: DateTime.Now.AddMinutes(20),
                signingCredentials: creds
            );
    
            return new JwtSecurityTokenHandler().WriteToken(token);
        }
    }

    次に、トークンが必要なコントローラーで、次のようにします。

    [HttpPost]
    public string AnonymousSignIn([FromServices] JwtSignInHandler tokenFactory)
    {
        var principal = new System.Security.Claims.ClaimsPrincipal(new[]
        {
            new System.Security.Claims.ClaimsIdentity(new[]
            {
                new System.Security.Claims.Claim(System.Security.Claims.ClaimTypes.Name, "Demo User")
            })
        });
        return tokenFactory.BuildJwt(principal);
    }

    ここでは、プリンシパルがすでにあると想定しています。あなたはアイデンティティを使用している場合は、使用することができIUserClaimsPrincipalFactory<>、あなたを変換するためUserClaimsPrincipal

  6. それをテストするには:トークンを取得し、jwt.ioのフォームに入れます。上記で提供した手順では、構成のシークレットを使用して署名を検証することもできます。

  7. これを.Net 4.5のベアラのみの認証と組み合わせてHTMLページの部分ビューでレンダリングしViewComponentていた場合は、a を使用して同じことを実行できます。上記のコントローラアクションコードとほとんど同じです。


1
IOptions<OAuthBearerAuthenticationOptions>オプションを使用するには、実際に注入する必要があります。オプションモデルフレームワークでサポートされている名前付き構成のため、オプションオブジェクトの直接使用はサポートされていません。
Matt DeKrey、2015年

2
私が使用しているものに更新されましたが、今は答えが書き直されるはずです。私を突いてくれてありがとう!
Matt DeKrey、2015年

5
#5は、Microsoft.AspNet.Authentication.OAuthBearer-ベータ5-6およびそれ以前のベータで次のように変更されていますが、まだ確認されていません。auth.AddPolicy( "Bearer"、new AuthorizationPolicyBuilder().AddAuthenticationSchemes(OAuthBearerAuthenticationDefaults.AuthenticationScheme).RequireAuthenticatedUser()。Build());
dynamiclynk 2015

5
@MattDeKrey私はこの回答を単純なトークンベースの認証の例の開始点として使用し、ベータ7に対して動作するように更新しました-github.com/mrsheepuk/ASPNETSelfCreatedTokenAuthExampleを参照してください-これらのコメントからのポインターのいくつかも組み込んでいます。
Mark Hughes、

2
RC1で再度更新-Beta7およびBeta8の古いバージョンがGitHubのブランチで入手可能。
Mark Hughes、

83

作業マットDekreyの素晴らしい答え、私はASP.NETコア(1.0.1)不利に働い、トークンベースの認証の完全に動作する例を作成しました。完全なコードはGitHubのこのリポジトリにあります1.0.0-rc1beta8beta7の代替ブランチ)が、簡単に言えば、重要な手順は次のとおりです。

アプリケーションのキーを生成する

私の例では、アプリが起動するたびにランダムなキーを生成します。ランダムなキーを生成してどこかに保存し、アプリケーションに提供する必要があります。ランダムキーを生成する方法と、.jsonファイルからインポートする方法については、このファイルを参照してください。@kspearrinのコメントで示唆されているように、Data Protection APIはキーを「正しく」管理するための理想的な候補のようですが、それが可能かどうかはまだわかりません。うまくいったらプルリクエストを送ってください!

Startup.cs-ConfigureServices

ここでは、トークンに署名するための秘密鍵をロードする必要があります。これは、トークンの提示時にトークンを検証するためにも使用します。キーはクラスレベルの変数に格納し、key以下のConfigureメソッドで再利用します。TokenAuthOptionsは、キーを作成するためにTokenControllerで必要な署名ID、対象ユーザー、発行者を保持する単純なクラスです。

// Replace this with some sort of loading from config / file.
RSAParameters keyParams = RSAKeyUtils.GetRandomKey();

// Create the key, and a set of token options to record signing credentials 
// using that key, along with the other parameters we will need in the 
// token controlller.
key = new RsaSecurityKey(keyParams);
tokenOptions = new TokenAuthOptions()
{
    Audience = TokenAudience,
    Issuer = TokenIssuer,
    SigningCredentials = new SigningCredentials(key, SecurityAlgorithms.Sha256Digest)
};

// Save the token options into an instance so they're accessible to the 
// controller.
services.AddSingleton<TokenAuthOptions>(tokenOptions);

// Enable the use of an [Authorize("Bearer")] attribute on methods and
// classes to protect.
services.AddAuthorization(auth =>
{
    auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
        .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme‌​)
        .RequireAuthenticatedUser().Build());
});

また[Authorize("Bearer")]、保護するエンドポイントとクラスで使用できるように承認ポリシーを設定しました。

Startup.cs-構成

ここでは、JwtBearerAuthenticationを構成する必要があります。

app.UseJwtBearerAuthentication(new JwtBearerOptions {
    TokenValidationParameters = new TokenValidationParameters {
        IssuerSigningKey = key,
        ValidAudience = tokenOptions.Audience,
        ValidIssuer = tokenOptions.Issuer,

        // When receiving a token, check that it is still valid.
        ValidateLifetime = true,

        // This defines the maximum allowable clock skew - i.e.
        // provides a tolerance on the token expiry time 
        // when validating the lifetime. As we're creating the tokens 
        // locally and validating them on the same machines which 
        // should have synchronised time, this can be set to zero. 
        // Where external tokens are used, some leeway here could be 
        // useful.
        ClockSkew = TimeSpan.FromMinutes(0)
    }
});

TokenController

トークンコントローラーには、Startup.csに読み込まれたキーを使用して署名済みキーを生成するメソッドが必要です。起動時にTokenAuthOptionsインスタンスを登録したので、それをTokenControllerのコンストラクターに挿入する必要があります。

[Route("api/[controller]")]
public class TokenController : Controller
{
    private readonly TokenAuthOptions tokenOptions;

    public TokenController(TokenAuthOptions tokenOptions)
    {
        this.tokenOptions = tokenOptions;
    }
...

次に、ログインエンドポイントのハンドラーでトークンを生成する必要があります。この例では、ユーザー名とパスワードを取得し、ifステートメントを使用してそれらを検証していますが、重要なことは、クレームを作成またはロードすることです。ベースのIDとそのためのトークンの生成:

public class AuthRequest
{
    public string username { get; set; }
    public string password { get; set; }
}

/// <summary>
/// Request a new token for a given username/password pair.
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
[HttpPost]
public dynamic Post([FromBody] AuthRequest req)
{
    // Obviously, at this point you need to validate the username and password against whatever system you wish.
    if ((req.username == "TEST" && req.password == "TEST") || (req.username == "TEST2" && req.password == "TEST"))
    {
        DateTime? expires = DateTime.UtcNow.AddMinutes(2);
        var token = GetToken(req.username, expires);
        return new { authenticated = true, entityId = 1, token = token, tokenExpires = expires };
    }
    return new { authenticated = false };
}

private string GetToken(string user, DateTime? expires)
{
    var handler = new JwtSecurityTokenHandler();

    // Here, you should create or look up an identity for the user which is being authenticated.
    // For now, just creating a simple generic identity.
    ClaimsIdentity identity = new ClaimsIdentity(new GenericIdentity(user, "TokenAuth"), new[] { new Claim("EntityID", "1", ClaimValueTypes.Integer) });

    var securityToken = handler.CreateToken(new Microsoft.IdentityModel.Tokens.SecurityTokenDescriptor() {
        Issuer = tokenOptions.Issuer,
        Audience = tokenOptions.Audience,
        SigningCredentials = tokenOptions.SigningCredentials,
        Subject = identity,
        Expires = expires
    });
    return handler.WriteToken(securityToken);
}

そして、それはそれであるはずです。[Authorize("Bearer")]保護するメソッドまたはクラスに追加するだけで、トークンが存在しない状態でアクセスしようとするとエラーが発生します。500エラーではなく401を返す場合は、ここでの例のように、カスタム例外ハンドラーを登録する必要があります


1
これは本当に優れた例であり、@ MattDeKreyの例を機能させるために必要なすべての欠けている部分が含まれています。まだbeta8ではなくbeta7をターゲットにしている人は、githubの履歴
ニックスプーン

1
@nickspoonを助けてくれてうれしい-もしそれで何か問題があったら、私に知らせてください、またはgithubにプルリクエストを入れてください。そうすれば更新します!
Mark Hughes、

2
このおかげで、ASP.Net 4 Web APIですぐに機能するものがASP.Net 5でかなりの構成を必要とする理由がよくわかりません。
JMK 2016年

1
彼らはASP.NET 5の「ソーシャル認証」を本当に推進していると思いますが、これはある意味理にかなっていると思いますが、適切ではないアプリケーションがあるので、私は彼らの方針に同意しません@JMK
Mark Hughes

1
@YuriyP私はこの回答をRC2に更新する必要があります-これを使用する内部アプリをまだRC2に更新していないため、何が関係しているのかわかりません。違い
Mark Hughes

3

JWTトークンを含むさまざまな認証メカニズムを処理する方法を示すOpenId接続サンプルを見ることができます。

https://github.com/aspnet-contrib/AspNet.Security.OpenIdConnect.Samples

Cordovaバックエンドプロジェクトを見ると、APIの構成は次のようになります。

           // Create a new branch where the registered middleware will be executed only for non API calls.
        app.UseWhen(context => !context.Request.Path.StartsWithSegments(new PathString("/api")), branch => {
            // Insert a new cookies middleware in the pipeline to store
            // the user identity returned by the external identity provider.
            branch.UseCookieAuthentication(new CookieAuthenticationOptions {
                AutomaticAuthenticate = true,
                AutomaticChallenge = true,
                AuthenticationScheme = "ServerCookie",
                CookieName = CookieAuthenticationDefaults.CookiePrefix + "ServerCookie",
                ExpireTimeSpan = TimeSpan.FromMinutes(5),
                LoginPath = new PathString("/signin"),
                LogoutPath = new PathString("/signout")
            });

            branch.UseGoogleAuthentication(new GoogleOptions {
                ClientId = "560027070069-37ldt4kfuohhu3m495hk2j4pjp92d382.apps.googleusercontent.com",
                ClientSecret = "n2Q-GEw9RQjzcRbU3qhfTj8f"
            });

            branch.UseTwitterAuthentication(new TwitterOptions {
                ConsumerKey = "6XaCTaLbMqfj6ww3zvZ5g",
                ConsumerSecret = "Il2eFzGIrYhz6BWjYhVXBPQSfZuS4xoHpSSyD9PI"
            });
        });

/Providers/AuthorizationProvider.csのロジックとそのプロジェクトのRessourceControllerも見てみる価値があります;)

または、次のコードを使用してトークンを検証することもできます(signalRで動作させるためのスニペットもあります)。

        // Add a new middleware validating access tokens.
        app.UseOAuthValidation(options =>
        {
            // Automatic authentication must be enabled
            // for SignalR to receive the access token.
            options.AutomaticAuthenticate = true;

            options.Events = new OAuthValidationEvents
            {
                // Note: for SignalR connections, the default Authorization header does not work,
                // because the WebSockets JS API doesn't allow setting custom parameters.
                // To work around this limitation, the access token is retrieved from the query string.
                OnRetrieveToken = context =>
                {
                    // Note: when the token is missing from the query string,
                    // context.Token is null and the JWT bearer middleware will
                    // automatically try to retrieve it from the Authorization header.
                    context.Token = context.Request.Query["access_token"];

                    return Task.FromResult(0);
                }
            };
        });

トークンを発行するには、openId Connectサーバーパッケージを次のように使用できます。

        // Add a new middleware issuing access tokens.
        app.UseOpenIdConnectServer(options =>
        {
            options.Provider = new AuthenticationProvider();
            // Enable the authorization, logout, token and userinfo endpoints.
            //options.AuthorizationEndpointPath = "/connect/authorize";
            //options.LogoutEndpointPath = "/connect/logout";
            options.TokenEndpointPath = "/connect/token";
            //options.UserinfoEndpointPath = "/connect/userinfo";

            // Note: if you don't explicitly register a signing key, one is automatically generated and
            // persisted on the disk. If the key cannot be persisted, an exception is thrown.
            // 
            // On production, using a X.509 certificate stored in the machine store is recommended.
            // You can generate a self-signed certificate using Pluralsight's self-cert utility:
            // https://s3.amazonaws.com/pluralsight-free/keith-brown/samples/SelfCert.zip
            // 
            // options.SigningCredentials.AddCertificate("7D2A741FE34CC2C7369237A5F2078988E17A6A75");
            // 
            // Alternatively, you can also store the certificate as an embedded .pfx resource
            // directly in this assembly or in a file published alongside this project:
            // 
            // options.SigningCredentials.AddCertificate(
            //     assembly: typeof(Startup).GetTypeInfo().Assembly,
            //     resource: "Nancy.Server.Certificate.pfx",
            //     password: "Owin.Security.OpenIdConnect.Server");

            // Note: see AuthorizationController.cs for more
            // information concerning ApplicationCanDisplayErrors.
            options.ApplicationCanDisplayErrors = true // in dev only ...;
            options.AllowInsecureHttp = true // in dev only...;
        });

編集:AureliaフロントエンドフレームワークとASP.NETコアを使用して、トークンベースの認証を実装した単一ページアプリケーションを実装しました。信号Rの永続的な接続もあります。ただし、DBの実装は行っていません。コードはここにあります: https //github.com/alexandre-spieser/AureliaAspNetCoreAuth

お役に立てれば、

ベスト、

アレックス


1

OpenIddictを見てください。これは、ASP.NET 5でJWTトークンとリフレッシュトークンの作成を簡単に構成できる(執筆時点での)新しいプロジェクトです。トークンの検証は他のソフトウェアによって処理されます。

で使用IdentityするEntity Framework場合、最後の行はConfigureServicesメソッドに追加するものです。

services.AddIdentity<ApplicationUser, ApplicationRole>()
    .AddEntityFrameworkStores<ApplicationDbContext>()
    .AddDefaultTokenProviders()
    .AddOpenIddictCore<Application>(config => config.UseEntityFramework());

ではConfigure、JWTトークンを提供するようにOpenIddictを設定します。

app.UseOpenIddictCore(builder =>
{
    // tell openiddict you're wanting to use jwt tokens
    builder.Options.UseJwtTokens();
    // NOTE: for dev consumption only! for live, this is not encouraged!
    builder.Options.AllowInsecureHttp = true;
    builder.Options.ApplicationCanDisplayErrors = true;
});

また、トークンの検証を次のように構成しますConfigure

// use jwt bearer authentication
app.UseJwtBearerAuthentication(options =>
{
    options.AutomaticAuthenticate = true;
    options.AutomaticChallenge = true;
    options.RequireHttpsMetadata = false;
    options.Audience = "http://localhost:58292/";
    options.Authority = "http://localhost:58292/";
});

DbContextがOpenIddictContextから派生する必要があるなど、他にも1つまたは2つの重要な点があります。

このブログ投稿で完全な説明を見ることができます:http : //capesean.co.za/blog/asp-net-5-jwt-tokens/

機能するデモは、https//github.com/capesean/openiddict-testで入手できます

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.