ASP.NET Coreでのトークンベース認証（更新）

Question

ASP.NET Coreアプリケーションを使用しています。トークンベースの認証を実装しようとしていますが、新しい セキュリティシステム の使用方法がわかりません。

私のシナリオ：クライアントがトークンを要求します。私のサーバーはユーザーを認証し、クライアントが次のリクエストで使用するaccess_tokenを返す必要があります。

必要なものを正確に実装することに関する2つの優れた記事を次に示します。

• ASP.NET Web API 2、Owin、およびIdentityを使用したトークンベースの認証
• JSON Webトークンを使用

問題は-ASP.NET Coreで同じことをどのように行うかは明らかではありません。

私の質問は次のとおりです：ASP.NET Core Web Apiアプリケーションをトークンベースの認証で動作するように設定する方法は？どの方向に進むべきですか？最新バージョンに関する記事を書いたり、どこで見つけられるかを知っていますか？

ありがとうございました！

Answer 1

Matt Dekreyのすばらしい回答 を元に、ASP.NET Core（1.0.1）に対して機能する、トークンベースの認証の完全に機能する例を作成しました。完全なコード は、GitHub （ 1.0.0-rc1 の代替ブランチ、 beta8 、 beta7 ）、しかし簡単に言えば、重要なステップは次のとおりです。

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

私の例では、アプリを起動するたびにランダムなキーを生成します。キーを生成してどこかに保存し、アプリケーションに提供する必要があります。 ランダムキーを生成する方法と、.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-Configure

ここで、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に読み込まれたキーを使用して署名付きキーを生成するメソッドが必要です。 Startupに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エラーを返したい場合、ここでの例のように、カスタム例外ハンドラー を登録する必要があります 。

Answer 2

これは、実際には 私のもう1つの答え の複製であり、注意を引くにつれて最新の状態に保つ傾向があります。そこにあるコメントも役に立つかもしれません！

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

   app.UseAuthentication();
   

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

4. AuthorizationPolicyを指定することもできます。これにより、[Authorize("Bearer")]を使用した認証として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);
   }
   

   ここでは、すでにプリンシパルを持っていると仮定しています。 Identityを使用している場合は、 IUserClaimsPrincipalFactory<> を使用して、UserをClaimsPrincipalに変換できます。

6. テストするには：トークンを取得し、 jwt.io の形式に入れます。上記の手順を使用すると、構成の秘密を使用して署名を検証することもできます！

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

Answer 3

説明した内容を実現するには、OAuth2/OpenID Connect承認サーバーと、APIのアクセストークンを検証するミドルウェアの両方が必要です。 KatanaはOAuthAuthorizationServerMiddlewareを提供していましたが、ASP.NET Coreにはもう存在しません。

AspNet.Security.OpenIdConnect.Serverをご覧になることをお勧めします。これは、あなたが言及したチュートリアルで使用されるOAuth2承認サーバーミドルウェアの実験的な分岐です。 OWIN/Katana 3バージョンと、net451（.NET Desktop）とnetstandard1.4（.NET Coreとの互換性）の両方をサポートするASP.NET Coreバージョンがあります。

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

AspNet.Security.OpenIdConnect.Serverを使用してOpenID Connect承認サーバーを構成する方法と、暗号化を検証する方法を示すMVCコアサンプルをお見逃しなくサーバーミドルウェアによって発行されたアクセストークン： https://github.com/aspnet-contrib/AspNet.Security.OpenIdConnect.Server/blob/dev/samples/Mvc/Mvc.Server/Startup.cs

また、このブログ投稿を読むこともできます。これは、リソース所有者パスワード付与の実装方法を説明しています。これは、基本認証に相当するOAuth2です。 http://kevinchalet.com/2016/07/13/creating-your- own-openid-connect-server-with-asos-implementing-the-resource-owner-password-credentials-grant /

Startup.cs

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddAuthentication();
    }

    public void Configure(IApplicationBuilder app)
    {
        // Add a new middleware validating the encrypted
        // access tokens issued by the OIDC server.
        app.UseOAuthValidation();

        // Add a new middleware issuing tokens.
        app.UseOpenIdConnectServer(options =>
        {
            options.TokenEndpointPath = "/connect/token";

            // Override OnValidateTokenRequest to skip client authentication.
            options.Provider.OnValidateTokenRequest = context =>
            {
                // Reject the token requests that don't use
                // grant_type=password or grant_type=refresh_token.
                if (!context.Request.IsPasswordGrantType() &&
                    !context.Request.IsRefreshTokenGrantType())
                {
                    context.Reject(
                        error: OpenIdConnectConstants.Errors.UnsupportedGrantType,
                        description: "Only grant_type=password and refresh_token " +
                                     "requests are accepted by this 
                    return Task.FromResult(0);
                }

                // Since there's only one application and since it's a public client
                // (i.e a client that cannot keep its credentials private),
                // call Skip() to inform the server the request should be
                // accepted without enforcing client authentication.
                context.Skip();

                return Task.FromResult(0);
            };

            // Override OnHandleTokenRequest to support
            // grant_type=password token requests.
            options.Provider.OnHandleTokenRequest = context =>
            {
                // Only handle grant_type=password token requests and let the
                // OpenID Connect server middleware handle the other grant types.
                if (context.Request.IsPasswordGrantType())
                {
                    // Do your credentials validation here.
                    // Note: you can call Reject() with a message
                    // to indicate that authentication failed.

                    var identity = new ClaimsIdentity(context.Options.AuthenticationScheme);
                    identity.AddClaim(OpenIdConnectConstants.Claims.Subject, "[unique id]");

                    // By default, claims are not serialized
                    // in the access and identity tokens.
                    // Use the overload taking a "destinations"
                    // parameter to make sure your claims
                    // are correctly inserted in the appropriate tokens.
                    identity.AddClaim("urn:customclaim", "value",
                        OpenIdConnectConstants.Destinations.AccessToken,
                        OpenIdConnectConstants.Destinations.IdentityToken);

                    var ticket = new AuthenticationTicket(
                        new ClaimsPrincipal(identity),
                        new AuthenticationProperties(),
                        context.Options.AuthenticationScheme);

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

                    context.Validate(ticket);
                }

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

project.json

{
  "dependencies": {
    "AspNet.Security.OAuth.Validation": "1.0.0",
    "AspNet.Security.OpenIdConnect.Server": "1.0.0"
  }
}

幸運を！

Answer 4

OpenIddict を使用してトークンを提供（ログイン）し、UseJwtBearerAuthenticationを使用してAPI/Controllerにアクセスしたときにトークンを検証できます。

これは、基本的にStartup.csで必要なすべての構成です。

ConfigureServices：

services.AddIdentity<ApplicationUser, ApplicationRole>()
    .AddEntityFrameworkStores<ApplicationDbContext>()
    .AddDefaultTokenProviders()
    // this line is added for OpenIddict to plug in
    .AddOpenIddictCore<Application>(config => config.UseEntityFramework());

設定

app.UseOpenIddictCore(builder =>
{
    // here you 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;
});

// use jwt bearer authentication to validate the tokens
app.UseJwtBearerAuthentication(options =>
{
    options.AutomaticAuthenticate = true;
    options.AutomaticChallenge = true;
    options.RequireHttpsMetadata = false;
    // must match the resource on your token request
    options.Audience = "http://localhost:58292/";
    options.Authority = "http://localhost:58292/";
});

DbContextがOpenIddictContext<ApplicationUser, Application, ApplicationRole, string>から派生する必要があるなど、1つまたは2つのマイナーなものがあります。

私のこのブログ投稿で完全な説明（機能するgithubリポジトリを含む）を見ることができます： http://capesean.co.za/blog/asp-net-5-jwt-tokens/

Answer 5

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

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

Cordova Backendプロジェクトを見ると、APIの構成は次のようになっています。

app.UseWhen(context => context.Request.Path.StartsWithSegments(new PathString("/api")), 
      branch => {
                branch.UseJwtBearerAuthentication(options => {
                    options.AutomaticAuthenticate = true;
                    options.AutomaticChallenge = true;
                    options.RequireHttpsMetadata = false;
                    options.Audience = "localhost:54540";
                    options.Authority = "localhost:54540";
                });
    });

/Providers/AuthorizationProvider.cs内のロジックとそのプロジェクトのRessourceControllerも、一見の価値があります;）。

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

お役に立てれば、

ベスト、

アレックス