Autenticación basada en tokens en ASP.NET Core

Estoy trabajando con la aplicación ASP.NET Core. Estoy intentando implementar la autenticación basada en tokens, pero no puedo descubrir cómo usar el nuevo sistema de seguridad para mi caso. Revisé ejemplos, pero no me ayudaron mucho, están usando la autenticación de cookies o la autenticación externa (GitHub, Microsoft, Twitter).

Cuál es mi escenario: la aplicación angularjs debe solicitar /token url pasando nombre de usuario y contraseña. WebApi debe autorizar al usuario y devolver access_token que será utilizado por la aplicación angularjs en las siguientes solicitudes.

Encontré un excelente artículo sobre cómo implementar exactamente lo que necesito en la versión actual de ASP.NET – Autenticación basada en tokens utilizando ASP.NET Web API 2, Owin e Identity . Pero no es obvio para mí cómo hacer lo mismo en ASP.NET Core.

Mi pregunta es: ¿cómo configurar la aplicación ASP.NET Core WebApi para trabajar con autenticación basada en token?

Actualizado para .Net Core 2:

Las versiones anteriores de esta respuesta usaban RSA; en realidad no es necesario si el mismo código que genera los tokens también está verificando los tokens. Sin embargo, si está distribuyendo la responsabilidad, probablemente aún desee hacerlo con una instancia de Microsoft.IdentityModel.Tokens.RsaSecurityKey .

  1. Cree algunas constantes que usaremos más tarde; esto es lo que hice:

     const string TokenAudience = "Myself"; const string TokenIssuer = "MyProject"; 
  2. Agregue esto a ConfigureServices su Startup.cs. Usaremos la dependency injection más tarde para acceder a estas configuraciones. Supongo que su authenticationConfiguration es un objeto ConfigurationSection o Configuration modo que puede tener una configuración diferente para la depuración y la producción. ¡Asegúrate de guardar tu llave de forma segura! Puede ser cualquier cadena.

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

    He visto otras respuestas cambiar otras configuraciones, como ClockSkew ; los valores predeterminados se establecen de manera que funcione en entornos distribuidos cuyos relojes no están exactamente sincronizados. Estas son las únicas configuraciones que necesita cambiar.

  3. Configurar la Autenticación Debería tener esta línea antes de cualquier middleware que requiera su información de User , como app.UseMvc() .

     app.UseAuthentication(); 

    Tenga en cuenta que esto no hará que su token se emita con SignInManager o cualquier otra cosa. Necesitará proporcionar su propio mecanismo para generar su JWT, ver a continuación.

  4. Es posible que desee especificar una AuthorizationPolicy . Esto le permitirá especificar controladores y acciones que solo permitan tokens de portador como autenticación mediante [Authorize("Bearer")] .

     services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationTypes(JwtBearerDefaults.AuthenticationType) .RequireAuthenticatedUser().Build()); }); 
  5. Aquí viene la parte difícil: construir el token.

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

    Luego, en su controlador donde quiere su token, algo como lo siguiente:

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

    Aquí, asumo que ya tienes un principal. Si está utilizando Identity, puede usar IUserClaimsPrincipalFactory<> para transformar su User en ClaimsPrincipal .

  6. Para probarlo : Obtenga un token, póngalo en el formulario en jwt.io. ¡Las instrucciones que proporcioné arriba también le permiten usar el secreto de su configuración para validar la firma!

  7. Si estaba representando esto en una vista parcial en su página HTML en combinación con la autenticación de solo portador en .Net 4.5, ahora puede usar un ViewComponent para hacer lo mismo. Es casi lo mismo que el código de acción del controlador anterior.

Trabajando a partir de la fabulosa respuesta de Matt Dekrey , he creado un ejemplo completamente funcional de autenticación basada en tokens, trabajando contra ASP.NET Core (1.0.1). Puede encontrar el código completo en este repository en GitHub (twigs alternativas para 1.0.0-rc1 , beta8 , beta7 ), pero en resumen, los pasos importantes son:

Genera una clave para tu aplicación

En mi ejemplo, genero una clave aleatoria cada vez que se inicia la aplicación, tendrá que generar una y almacenarla en algún lugar y proporcionarla a su aplicación. Consulte este archivo para saber cómo estoy generando una clave aleatoria y cómo puede importarla desde un archivo .json . Como se sugiere en los comentarios de @kspearrin, la API de protección de datos parece ser un candidato ideal para administrar las claves “correctamente”, pero aún no he resuelto si eso es posible. Por favor envíe una solicitud de extracción si lo resuelve!

Startup.cs – ConfigureServices

Aquí, debemos cargar una clave privada para que se firmen nuestros tokens, que también usaremos para verificar los tokens a medida que se presentan. Estamos almacenando la clave en una key variable de nivel de clase que volveremos a utilizar en el método Configure a continuación. TokenAuthOptions es una clase simple que contiene la identidad de firma, la audiencia y el emisor que necesitaremos en el TokenController para crear nuestras claves.

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

También hemos establecido una política de autorización que nos permite usar [Authorize("Bearer")] en los puntos finales y las clases que deseamos proteger.

Startup.cs – Configurar

Aquí, necesitamos configurar 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 - ie // 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

En el controlador de token, debe tener un método para generar claves firmadas utilizando la clave que se cargó en Startup.cs. Registramos una instancia de TokenAuthOptions en Inicio, por lo que necesitamos inyectar eso en el constructor de TokenController:

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

Entonces necesitarás generar el token en tu controlador para el punto final de inicio de sesión, en mi ejemplo tomo un nombre de usuario y contraseña y validarlos usando una statement if, pero la clave que debes hacer es crear o cargar un reclamo basada en identidad y generar el token para eso:

 public class AuthRequest { public string username { get; set; } public string password { get; set; } } ///  /// Request a new token for a given username/password pair. ///  ///  ///  [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); } 

Y eso debería ser. Simplemente agregue [Authorize("Bearer")] a cualquier método o clase que desee proteger, y debería obtener un error si intenta acceder sin un token presente. Si desea devolver un error 401 en lugar de 500, necesitará registrar un manejador de excepción personalizado como lo hice en mi ejemplo aquí .

Puede echar un vistazo a las muestras de conexión de OpenId que ilustran cómo tratar los diferentes mecanismos de autenticación, incluidos los tokens JWT:

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

Si nos fijamos en el proyecto Cordova Backend, la configuración para la API es así:

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

También vale la pena echarle un vistazo a la lógica en /Providers/AuthorizationProvider.cs y al RessourceController de ese proyecto;).

Alternativamente, también puede usar el siguiente código para validar tokens (también hay un fragmento para que funcione con 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); } }; }); 

Para emitir token, puede usar los paquetes del servidor de openId Connect de la siguiente manera:

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

EDITAR: He implementado una aplicación de una sola página con implementación de autenticación basada en token usando el framework de Aurelia front end y el núcleo de ASP.NET. También hay una señal de conexión persistente R. Sin embargo, no he hecho ninguna implementación de DB. El código se puede ver aquí: https://github.com/alexandre-spieser/AureliaAspNetCoreAuth

Espero que esto ayude,

Mejor,

Alex

Eche un vistazo a OpenIddict: es un proyecto nuevo (en el momento de redactar este informe) que facilita la configuración de la creación de tokens JWT y tokens de actualización en ASP.NET 5. La validación de los tokens es manejada por otro software.

Suponiendo que usa Identity con Entity Framework , la última línea es lo que agregaría a su método ConfigureServices :

 services.AddIdentity() .AddEntityFrameworkStores() .AddDefaultTokenProviders() .AddOpenIddictCore(config => config.UseEntityFramework()); 

En Configure , configura OpenIddict para servir tokens JWT:

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

También configura la validación de tokens en 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/"; }); 

Hay una o dos cosas menores, como su DbContext debe derivarse de OpenIddictContext.

Puedes ver una explicación completa en esta publicación de blog: http://capesean.co.za/blog/asp-net-5-jwt-tokens/

Una demostración funcional está disponible en: https://github.com/capesean/openiddict-test