ASP.NET Core中基于令牌的身份验证（刷新）

67

我正在使用ASP.NET Core应用程序。我正在尝试实施基于令牌的身份验证，但无法弄清楚如何使用新的安全系统。

我的情况： 客户端请求令牌。我的服务器应授权用户并返回access_token，客户端将在随后的请求中使用它。

这是有关实现我真正需要的两篇很棒的文章：

问题是-对我来说，如何在ASP.NET Core中执行相同的操作并不明显。

我的问题是：如何配置ASP.NET Core Web Api应用程序以与基于令牌的身份验证一起使用？我应该朝哪个方向前进？您是否撰写了有关最新版本的文章，或者知道在哪里可以找到这些文章？

谢谢！

c#  authentication  asp.net-web-api  authorization  asp.net-core 
— 帕特里克（Patryk Golebiowski）
source
6
投票重开，因为链接为重复的问题现在无法回答。由于命名空间的更改，截止到4月的MVC6与现在的非常不同。同样，在该问题中给出的答案在通过JWT生成令牌和通过JWT消耗令牌的示例中未提供足够的详细信息。
— 亚当
— turgayozgur

Answers:

71

根据Matt Dekrey的出色回答，我创建了一个完全有效的基于令牌的身份验证示例，该示例针对ASP.NET Core（1.0.1）。你可以找到完整的代码在这个仓库在GitHub上（替代分支1.0.0-RC1，beta8，β7的），但在短暂的，重要的步骤是：

为您的应用生成密钥

在我的示例中，每次应用启动时，我都会生成一个随机密钥，您需要生成一个并将其存储在某个位置，然后将其提供给您的应用。有关如何生成随机密钥以及如何从.json文件导入它的信息，请参见此文件。正如@kspearrin在评论中所建议的那样，Data Protection API似乎是“正确”管理密钥的理想候选者，但是我还没有解决这个问题。如果解决了，请提交拉取请求！

Startup.cs-ConfigureServices

在这里，我们需要为签名的令牌加载一个私钥，当令牌出现时，我们还将使用该私钥来验证令牌。我们将密钥存储在类级别的变量中key，该变量将在下面的Configure方法中重复使用。TokenAuthOptions是一个简单的类，其中包含我们需要在T​​okenController中创建签名的签名身份，受众和发行者。

// 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)
    }
});

令牌控制器

在令牌控制器中，您需要一种方法来使用Startup.cs中加载的密钥生成签名密钥。我们已经在Startup中注册了TokenAuthOptions实例，因此我们需要将其注入TokenController的构造函数中：

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

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

然后，您需要在处理程序中为登录端点生成令牌，在我的示例中，我使用用户名和密码，并使用if语句验证用户名和密码，但是您需要做的关键是创建或加载声明身份并为此生成令牌：

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")]到要保护的任何方法或类中，如果在没有令牌的情况下尝试访问它，将会出现错误。如果要返回401错误而不是500错误，则需要注册一个自定义异常处理程序，如我在此处的示例所示。

— 马克·休斯
source
2
有可能代替添加[Authorize（“ Bearer”）]仅放置[Authorize]吗？
— zoranpro
2
我相信这会工作@zoranpro-只要您在startup.cs中注册了一个身份验证中间件。如果您有多个注册，则[授权]将允许通过这些方法中的任何一种进行身份验证的人访问-这可能很好，具体取决于您的用法。
— Mark Hughes
3
好的，我找到了：标头名称应为：“ Authorization”，值：“ Bearer [token]”
— Piotrek，2016年
4
这和只有这个答案对于ASP.NET 5 RC的工作，已经鞭打互联网及联营公司的解决方案后！谢谢你这么多，@MarkHughes你应该真正写自己的Q＆A对于这个答案，你的很好的例子。
— 托马斯·哈格斯特伦（ThomasHagström）'16年
2
@MarkHughes请为RC2更新，因为您的UseJwtBearerAuthentication语法不再起作用
— Camilo Terevinto
24

这实际上是我的另一个答案的副本，随着人们的关注，我倾向于保持最新。那里的评论可能对您也有用！

已针对.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。这将允许您使用来指定仅允许Bearer令牌作为身份验证的控制器和操作[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);
}

    在这里，我假设您已经有一个校长。如果您使用的是Identity，则可以使用IUserClaimsPrincipalFactory<>将转换User为ClaimsPrincipal。

  6. 测试它：获取令牌，将其放入jwt.io的表单中。我上面提供的说明还允许您使用配置中的密码来验证签名！

  7. 如果要在HTML页面的部分视图中呈现此视图，并与.Net 4.5中的仅承载身份验证结合使用，则现在可以使用ViewComponent做相同的事情。它与上面的Controller Action代码基本相同。

— 马特·德克莱
source
非常感谢您的回答！我只是在想-您如何看待用HMAC-SHA256签名自己的字符串并释放此类令牌？我只是想知道这是否足够安全：)
— Patryk Golebiowski
1
我绝不是安全专家-注释框没有足够的空间让我留下详尽的解释。它确实取决于您的用例，但是我相信旧的ASP.Net使用了机器密钥，当人们定制它时，iirc通常为SHA256。
— Matt DeKrey 2015年
2
@MattDeKrey注意，RSACryptoServiceProvider.ToXmlString并且RSACryptoServiceProvider.FromXmlString尚未移植到CoreCLR。这意味着dnxcore50使用这些方法时将无法定位。
— 凯文木屋
1
如果资源服务器（又名“ API”）和授权服务器（创建令牌的组件）不属于同一应用程序，则不建议使用@Randolph使用对称算法对您的访问令牌进行签名。正如Matt所建议的，您应该真正使用RSA-SHA512。
— 凯文木屋
1
@Randolph最后一句话：如果您打算支持外部客户端（即您不拥有的客户端），则应该真正考虑采用OAuth2或OpenID Connect之类的标准协议，而不是创建自己的终结点。如果您需要更多信息，请参阅我的答案。
— 凯文木屋
4

要实现您所描述的内容，您将需要OAuth2 / OpenID Connect授权服务器和验证API的访问令牌的中间件。Katana曾经提供OAuthAuthorizationServerMiddleware，但在ASP.NET Core中已不存在。

我建议您看一下AspNet.Security.OpenIdConnect.Server，这是您提到的教程所使用的OAuth2授权服务器中间件的实验性分支：有一个OWIN / Katana 3版本和一个同时支持这两个版本的ASP.NET Core版本net451（.NET桌面）和netstandard1.4（与.NET Core兼容）。

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

不要错过MVC Core示例，该示例显示了如何使用AspNet.Security.OpenIdConnect.Server配置OpenID Connect授权服务器以及如何验证服务器中间件发出的加密访问令牌：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-将服务器与asos一起实施资源所有者密码凭证授予/

启动文件

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"
  }
}

祝好运！

— 凯文木屋
source
已更新为针对ASP.NET Core RTM和ASOS beta6。
— 凯文木屋
3

您可以使用OpenIddict提供令牌（登录），然后UseJwtBearerAuthentication在访问API /控制器时用于验证令牌。

这实际上是您需要的所有配置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>。

您可以在我的此博客文章中看到完整的说明（包括运行中的github存储库）：http : //capesean.co.za/blog/asp-net-5-jwt-tokens/

— 肖恩
source
2

您可以看一下OpenId连接示例，这些示例说明了如何处理不同的身份验证机制，包括JWT令牌：

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持久连接。但是我还没有执行任何数据库实现。可以在这里查看代码：https : //github.com/alexandre-spieser/AureliaAspNetCoreAuth

希望这可以帮助，

最好，

亚历克斯

— 达克斯塔
source
直到我发现Audience没有该方案（对localhost：54540而不是localhost：54540），它对我才起作用。当我更改它时，它就像一种魅力！
— kloarubeek
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.