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

Posted 2023-02-19

【中文标题】ASP.NET Core 中基于令牌的身份验证（刷新）

【英文标题】：Token Based Authentication in ASP.NET Core (refreshed)

【发布时间】：2015-08-13 07:42:52

【问题描述】：

我正在使用 ASP.NET Core 应用程序。我正在尝试实现基于令牌的身份验证，但不知道如何使用新的Security System。

我的场景： 客户端请求令牌。我的服务器应该授权用户并返回 access_token，客户端将在以下请求中使用它。

这里有两篇关于实现我所需要的很棒的文章：

Token Based Authentication using ASP.NET Web API 2, Owin, and Identity Using JSON Web tokens

问题是 - 对我来说如何在 ASP.NET Core 中做同样的事情并不明显。

我的问题是：如何配置 ASP.NET Core Web Api 应用程序以使用基于令牌的身份验证？我应该追求什么方向？你有没有写过关于最新版本的文章，或者知道在哪里可以找到？

谢谢！

【问题讨论】：

投票重新打开，因为作为重复链接的问题现在没有回答这个问题。由于命名空间的变化，截至 4 月的 MVC6 与现在有很大不同。此外，该问题中给出的答案在其通过 JWT 生成令牌和通过 JWT 使用令牌的示例中没有提供足够的详细信息。

https://***.com/questions/48153322/share-default-owin-tokens-in-net-core/54206566#54206566

【参考方案1】：

从Matt Dekrey's fabulous answer 开始，我创建了一个基于令牌的身份验证的完整工作示例，针对 ASP.NET Core (1.0.1)。您可以找到完整的代码in this repository on GitHub（1.0.0-rc1、beta8、beta7 的替代分支），但简而言之，重要的步骤是：

为您的应用程序生成密钥

在我的示例中，每次应用启动时我都会生成一个随机密钥，您需要生成一个并将其存储在某处并将其提供给您的应用程序。 See this file for how I'm generating a random key and how you might import it from a .json file。正如@kspearrin 在 cmets 中所建议的那样，Data Protection API 似乎是“正确”管理密钥的理想人选，但我还没有弄清楚这是否可能。如果你解决了，请提交一个拉取请求！

Startup.cs - 配置服务

在这里，我们需要为要签名的令牌加载一个私钥，我们还将使用它来验证令牌的出现。我们将密钥存储在类级变量key 中，我们将在下面的配置方法中重复使用该变量。 TokenAuthOptions 是一个简单的类，它包含我们在 TokenController 中创建密钥所需的签名身份、受众和颁发者。

// 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 中加载的密钥生成签名密钥。我们已经在 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 错误，则需要注册自定义异常处理程序 as I have in my example here。

【讨论】：

是否可以不添加 [Authorize("Bearer")] 来仅放置 [Authorize] ？

我相信@zoranpro 会起作用——前提是你只在你的 startup.cs 中注册了一个身份验证中间件。如果您有多个注册，那么 [Authorize] 将允许通过任何这些方法进行身份验证的人访问 - 根据您的使用情况，这可能很好。

好的，我找到了：Header 名称应该是：“Authorization”，值：“Bearer [token]”

这个和只有这个答案在互联网和同事寻找解决方案之后，适用于 ASP.NET 5 RC！非常感谢@MarkHughes，您应该真的用您的出色示例为这个答案编写自己的问答。

@MarkHughes 请更新 RC2，因为您的 UseJwtBearerAuthentication 语法不再有效

【参考方案2】：

这实际上是 another answer of mine 的复制品，随着它受到更多关注，我倾向于保持更新。那里的评论也可能对你有用！

为 .Net Core 2 更新：

此答案的先前版本使用 RSA；如果生成令牌的相同代码也在验证令牌，那真的没有必要。但是，如果您要分配责任，您可能仍希望使用 Microsoft.IdentityModel.Tokens.RsaSecurityKey 的实例来执行此操作。

创建一些我们稍后会用到的常量；这就是我所做的：

const string TokenAudience = "Myself";
const string TokenIssuer = "MyProject";

将此添加到您的 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；默认设置使其适用于时钟不完全同步的分布式环境。这些是您需要更改的唯一设置。

设置身份验证。您应该在任何需要您的User 信息的中间件之前添加此行，例如app.UseMvc()。

app.UseAuthentication();

请注意，这不会导致您的令牌与SignInManager 或其他任何内容一起发出。您需要提供自己的机制来输出您的 JWT - 见下文。

您可能需要指定AuthorizationPolicy。这将允许您指定仅允许 Bearer 令牌使用 [Authorize("Bearer")] 进行身份验证的控制器和操作。

services.AddAuthorization(auth =>

    auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
        .AddAuthenticationTypes(JwtBearerDefaults.AuthenticationType)
        .RequireAuthenticatedUser().Build());
);

这里是棘手的部分：构建令牌。

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。

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

1234563它与上面的 Controller Action 代码基本相同。

【讨论】：

非常感谢您的回答！我只是想知道 - 您如何看待使用 HMAC-SHA256 签署我自己的字符串并发布此类令牌？我只是想知道这是否是一个足够安全的解决方案:)

我绝不是安全专家 - 评论框没有足够的空间让我留下详尽的解释。这真的取决于你的用例，但我相信旧的 ASP.Net 使用机器密钥，iirc 在人们定制它时通常是 SHA256。

@MattDeKrey 请注意，RSACryptoServiceProvider.ToXmlString 和 RSACryptoServiceProvider.FromXmlString 尚未移植到 CoreCLR。这意味着您在使用这些方法时将无法定位 dnxcore50。

@Randolph 使用对称算法来签署您的访问令牌，如果资源服务器（也称为“API”）和授权服务器（创建令牌的组件）不属于相同的应用程序。正如 Matt 所建议的，您应该真正使用 RSA-SHA512。

@Randolph 最后一句话：如果您计划支持外部客户端（即您不拥有的客户端），您应该真正考虑采用像 OAuth2 或OpenID Connect，而不是创建您自己的端点。如果您需要更多信息，请参阅我的回答。

【参考方案3】：

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

我建议查看 AspNet.Security.OpenIdConnect.Server，这是您提到的教程中使用的 OAuth2 授权服务器中间件的实验性分支：有一个 OWIN/Katana 3 版本，以及支持net451（.NET 桌面）和netstandard1.4（与.NET Core 兼容）的 ASP.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-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"
  

祝你好运！

【讨论】：

已更新为面向 ASP.NET Core RTM 和 ASOS beta6。

【参考方案4】：

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

这基本上是您在Startup.cs 中需要的所有配置：

配置服务：

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/

【参考方案5】：

您可以查看 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

希望对你有帮助，

最好的，

亚历克斯

【讨论】：

直到我发现 Audience 没有该方案（所以 localhost:54540 而不是 localhost:54540）之前，它对我不起作用。当我改变它时，它就像一个魅力！