Simple JWT authentication in ASP.NET Core 1.0 Web API

Question

I'm looking for the simplest way to setup a Web API server that uses JWTs for authentication in ASP.NET Core (aka ASP.NET 5). This project (blog post / github) does exactly what I'm looking for but it uses ASP.NET 4.

I just want to be able to:

1. setup a login route that can create a JWT token and return it in the header. I'm integrating this with an existing RESTful service that will tell me if the username and password are valid. In the ASP.NET 4 project I'm looking at this could be done with the following route https://github.com/stewartm83/Jwt-WebApi/blob/master/src/JwtWebApi/Controllers/AccountController.cs#L24-L54

2. Intercept incoming requests to routes that require authorization, decrypt and validate the JWT token coming in the header and make the user information in the JWT token's payload accessible to the route. e.g. something like this: https://github.com/stewartm83/Jwt-WebApi/blob/master/src/JwtWebApi/App_Start/AuthHandler.cs

All of the examples I've seen in ASP.NET Core are very complex and rely on some or all of OAuth, IS, OpenIddict, and EF which I would like to avoid.

Can anyone point me towards an example of how to do this in ASP.NET Core or help me get started with this?

EDIT: Answer I ended up using this answer: https://stackoverflow.com/a/33217340/373655

Answer 1

Note/Update:

The below code was for .NET Core 1.1
Since .NET Core 1 was so very RTM, authentication changed with the jump from .NET Core 1 to 2.0 (aka was [partially?] fixed with breaking changes).
That's why the bellow code does NOT work with .NET Core 2.0 anymore.
But it will still be a useful read.

2018 Update

Meanwhile, you can find a working example of ASP.NET Core 2.0 JWT-Cookie-Authentication on my github test repo. Comes complete with an implementation of the MS-RSA&MS-ECDSA abstract class with BouncyCastle, and a key-generator for RSA&ECDSA.

---

Necromancing.
I digged deeper into JWT. Here are my findings:

You need to add Microsoft.AspNetCore.Authentication.JwtBearer

then you can set

app.UseJwtBearerAuthentication(bearerOptions); 

in Startup.cs => Configure

where bearerOptions is defined by you, e.g. as

var bearerOptions = new JwtBearerOptions() {     AutomaticAuthenticate = true,     AutomaticChallenge = true,     TokenValidationParameters = tokenValidationParameters,     Events = new CustomBearerEvents() };  // Optional  // bearerOptions.SecurityTokenValidators.Clear(); // bearerOptions.SecurityTokenValidators.Add(new MyTokenHandler()); 

where CustomBearerEvents is the place where you could add token data to the httpContext/Route

// https://github.com/aspnet/Security/blob/master/src/Microsoft.AspNetCore.Authentication.JwtBearer/Events/JwtBearerEvents.cs public class CustomBearerEvents : Microsoft.AspNetCore.Authentication.JwtBearer.IJwtBearerEvents {      /// <summary>     /// Invoked if exceptions are thrown during request processing. The exceptions will be re-thrown after this event unless suppressed.     /// </summary>     public Func<AuthenticationFailedContext, Task> OnAuthenticationFailed { get; set; } = context => Task.FromResult(0);      /// <summary>     /// Invoked when a protocol message is first received.     /// </summary>     public Func<MessageReceivedContext, Task> OnMessageReceived { get; set; } = context => Task.FromResult(0);      /// <summary>     /// Invoked after the security token has passed validation and a ClaimsIdentity has been generated.     /// </summary>     public Func<TokenValidatedContext, Task> OnTokenValidated { get; set; } = context => Task.FromResult(0);       /// <summary>     /// Invoked before a challenge is sent back to the caller.     /// </summary>     public Func<JwtBearerChallengeContext, Task> OnChallenge { get; set; } = context => Task.FromResult(0);       Task IJwtBearerEvents.AuthenticationFailed(AuthenticationFailedContext context)     {         return OnAuthenticationFailed(context);     }      Task IJwtBearerEvents.Challenge(JwtBearerChallengeContext context)     {         return OnChallenge(context);     }      Task IJwtBearerEvents.MessageReceived(MessageReceivedContext context)     {         return OnMessageReceived(context);     }      Task IJwtBearerEvents.TokenValidated(TokenValidatedContext context)     {         return OnTokenValidated(context);     } } 

And tokenValidationParameters is defined by you, e.g.

var tokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters {     // The signing key must match!     ValidateIssuerSigningKey = true,     IssuerSigningKey = signingKey,      // Validate the JWT Issuer (iss) claim     ValidateIssuer = true,     ValidIssuer = "ExampleIssuer",      // Validate the JWT Audience (aud) claim     ValidateAudience = true,     ValidAudience = "ExampleAudience",      // Validate the token expiry     ValidateLifetime = true,      // If you want to allow a certain amount of clock drift, set that here:     ClockSkew = TimeSpan.Zero,  }; 

And MyTokenHandler is optionally defined by you, if you want to customize token validation, e.g.

// https://gist.github.com/pmhsfelix/4151369 public class MyTokenHandler : Microsoft.IdentityModel.Tokens.ISecurityTokenValidator {     private int m_MaximumTokenByteSize;      public MyTokenHandler()     { }      bool ISecurityTokenValidator.CanValidateToken     {         get         {             // throw new NotImplementedException();             return true;         }     }        int ISecurityTokenValidator.MaximumTokenSizeInBytes     {         get         {             return this.m_MaximumTokenByteSize;         }          set         {             this.m_MaximumTokenByteSize = value;         }     }      bool ISecurityTokenValidator.CanReadToken(string securityToken)     {         System.Console.WriteLine(securityToken);         return true;     }      ClaimsPrincipal ISecurityTokenValidator.ValidateToken(string securityToken, TokenValidationParameters validationParameters, out SecurityToken validatedToken)     {         JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();         // validatedToken = new JwtSecurityToken(securityToken);         try         {              tokenHandler.ValidateToken(securityToken, validationParameters, out validatedToken);             validatedToken = new JwtSecurityToken("jwtEncodedString");         }         catch (Exception ex)         {             System.Console.WriteLine(ex.Message);             throw;         }            ClaimsPrincipal principal = null;         // SecurityToken validToken = null;          validatedToken = null;           System.Collections.Generic.List<System.Security.Claims.Claim> ls =             new System.Collections.Generic.List<System.Security.Claims.Claim>();          ls.Add(             new System.Security.Claims.Claim(                 System.Security.Claims.ClaimTypes.Name, "IcanHazUsr_éèêëïàáâäåãæóòôöõõúùûüñçø_ÉÈÊËÏÀÁÂÄÅÃÆÓÒÔÖÕÕÚÙÛÜÑÇØ 你好，世界 Привет\tмир"             , System.Security.Claims.ClaimValueTypes.String             )         );          //           System.Security.Claims.ClaimsIdentity id = new System.Security.Claims.ClaimsIdentity("authenticationType");         id.AddClaims(ls);          principal = new System.Security.Claims.ClaimsPrincipal(id);          return principal;         throw new NotImplementedException();     }   } 

The tricky part is how to get the AsymmetricSecurityKey, because you don't want to pass a rsaCryptoServiceProvider, because you need interoperability in crypto format.

Creation goes along the lines of

// System.Security.Cryptography.X509Certificates.X509Certificate2 cert2 = new System.Security.Cryptography.X509Certificates.X509Certificate2(byte[] rawData); System.Security.Cryptography.X509Certificates.X509Certificate2 cert2 =      DotNetUtilities.CreateX509Cert2("mycert"); Microsoft.IdentityModel.Tokens.SecurityKey secKey = new X509SecurityKey(cert2); 

e.g. with BouncyCastle from a DER Certificate:

    // http://stackoverflow.com/questions/36942094/how-can-i-generate-a-self-signed-cert-without-using-obsolete-bouncycastle-1-7-0     public static System.Security.Cryptography.X509Certificates.X509Certificate2 CreateX509Cert2(string certName)     {          var keypairgen = new Org.BouncyCastle.Crypto.Generators.RsaKeyPairGenerator();         keypairgen.Init(new Org.BouncyCastle.Crypto.KeyGenerationParameters(             new Org.BouncyCastle.Security.SecureRandom(                 new Org.BouncyCastle.Crypto.Prng.CryptoApiRandomGenerator()                 )                 , 1024                 )         );          Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair keypair = keypairgen.GenerateKeyPair();          // --- Until here we generate a keypair            var random = new Org.BouncyCastle.Security.SecureRandom(                 new Org.BouncyCastle.Crypto.Prng.CryptoApiRandomGenerator()         );           // SHA1WITHRSA         // SHA256WITHRSA         // SHA384WITHRSA         // SHA512WITHRSA          // SHA1WITHECDSA         // SHA224WITHECDSA         // SHA256WITHECDSA         // SHA384WITHECDSA         // SHA512WITHECDSA          Org.BouncyCastle.Crypto.ISignatureFactory signatureFactory =              new Org.BouncyCastle.Crypto.Operators.Asn1SignatureFactory("SHA512WITHRSA", keypair.Private, random)         ;            var gen = new Org.BouncyCastle.X509.X509V3CertificateGenerator();           var CN = new Org.BouncyCastle.Asn1.X509.X509Name("CN=" + certName);         var SN = Org.BouncyCastle.Math.BigInteger.ProbablePrime(120, new Random());          gen.SetSerialNumber(SN);         gen.SetSubjectDN(CN);         gen.SetIssuerDN(CN);         gen.SetNotAfter(DateTime.Now.AddYears(1));         gen.SetNotBefore(DateTime.Now.Subtract(new TimeSpan(7, 0, 0, 0)));         gen.SetPublicKey(keypair.Public);           // -- Are these necessary ?           // public static readonly DerObjectIdentifier AuthorityKeyIdentifier = new DerObjectIdentifier("2.5.29.35");         // OID value: 2.5.29.35         // OID description: id-ce-authorityKeyIdentifier         // This extension may be used either as a certificate or CRL extension.          // It identifies the public key to be used to verify the signature on this certificate or CRL.         // It enables distinct keys used by the same CA to be distinguished (e.g., as key updating occurs).                   // http://stackoverflow.com/questions/14930381/generating-x509-certificate-using-bouncy-castle-java         gen.AddExtension(         Org.BouncyCastle.Asn1.X509.X509Extensions.AuthorityKeyIdentifier.Id,         false,         new Org.BouncyCastle.Asn1.X509.AuthorityKeyIdentifier(             Org.BouncyCastle.X509.SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keypair.Public),             new Org.BouncyCastle.Asn1.X509.GeneralNames(new Org.BouncyCastle.Asn1.X509.GeneralName(CN)),             SN         ));          // OID value: 1.3.6.1.5.5.7.3.1         // OID description: Indicates that a certificate can be used as an SSL server certificate.         gen.AddExtension(             Org.BouncyCastle.Asn1.X509.X509Extensions.ExtendedKeyUsage.Id,             false,             new Org.BouncyCastle.Asn1.X509.ExtendedKeyUsage(new ArrayList()             {             new Org.BouncyCastle.Asn1.DerObjectIdentifier("1.3.6.1.5.5.7.3.1")         }));          // -- End are these necessary ?           Org.BouncyCastle.X509.X509Certificate bouncyCert = gen.Generate(signatureFactory);          byte[] ba = bouncyCert.GetEncoded();         System.Security.Cryptography.X509Certificates.X509Certificate2 msCert = new System.Security.Cryptography.X509Certificates.X509Certificate2(ba);         return msCert;     } 

Subsequently, you can add a custom cookie-format that contains the JWT-Bearer:

app.UseCookieAuthentication(new CookieAuthenticationOptions() {     AuthenticationScheme = "MyCookieMiddlewareInstance",     CookieName = "SecurityByObscurityDoesntWork",     ExpireTimeSpan = new System.TimeSpan(15, 0, 0),     LoginPath = new Microsoft.AspNetCore.Http.PathString("/Account/Unauthorized/"),     AccessDeniedPath = new Microsoft.AspNetCore.Http.PathString("/Account/Forbidden/"),     AutomaticAuthenticate = true,     AutomaticChallenge = true,     CookieSecure = Microsoft.AspNetCore.Http.CookieSecurePolicy.SameAsRequest,     CookieHttpOnly = false,     TicketDataFormat = new CustomJwtDataFormat("foo", tokenValidationParameters)      // DataProtectionProvider = null,      // DataProtectionProvider = new DataProtectionProvider(new System.IO.DirectoryInfo(@"c:\shared-auth-ticket-keys\"),     //delegate (DataProtectionConfiguration options)     //{     //    var op = new Microsoft.AspNet.DataProtection.AuthenticatedEncryption.AuthenticatedEncryptionOptions();     //    op.EncryptionAlgorithm = Microsoft.AspNet.DataProtection.AuthenticatedEncryption.EncryptionAlgorithm.AES_256_GCM:     //    options.UseCryptographicAlgorithms(op);     //}     //), }); 

Where CustomJwtDataFormat is something along the lines of

public class CustomJwtDataFormat : ISecureDataFormat<AuthenticationTicket> {      private readonly string algorithm;     private readonly TokenValidationParameters validationParameters;      public CustomJwtDataFormat(string algorithm, TokenValidationParameters validationParameters)     {         this.algorithm = algorithm;         this.validationParameters = validationParameters;     }            // This ISecureDataFormat implementation is decode-only     string ISecureDataFormat<AuthenticationTicket>.Protect(AuthenticationTicket data)     {         return MyProtect(data, null);     }      string ISecureDataFormat<AuthenticationTicket>.Protect(AuthenticationTicket data, string purpose)     {         return MyProtect(data, purpose);     }      AuthenticationTicket ISecureDataFormat<AuthenticationTicket>.Unprotect(string protectedText)     {         return MyUnprotect(protectedText, null);     }      AuthenticationTicket ISecureDataFormat<AuthenticationTicket>.Unprotect(string protectedText, string purpose)     {         return MyUnprotect(protectedText, purpose);     }       private string MyProtect(AuthenticationTicket data, string purpose)     {         return "wadehadedudada";         throw new System.NotImplementedException();     }       // http://blogs.microsoft.co.il/sasha/2012/01/20/aggressive-inlining-in-the-clr-45-jit/     [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]     private AuthenticationTicket MyUnprotect(string protectedText, string purpose)     {         JwtSecurityTokenHandler handler = new JwtSecurityTokenHandler();         ClaimsPrincipal principal = null;         SecurityToken validToken = null;           System.Collections.Generic.List<System.Security.Claims.Claim> ls =              new System.Collections.Generic.List<System.Security.Claims.Claim>();          ls.Add(             new System.Security.Claims.Claim(                 System.Security.Claims.ClaimTypes.Name, "IcanHazUsr_éèêëïàáâäåãæóòôöõõúùûüñçø_ÉÈÊËÏÀÁÂÄÅÃÆÓÒÔÖÕÕÚÙÛÜÑÇØ 你好，世界 Привет\tмир"             , System.Security.Claims.ClaimValueTypes.String             )         );          //           System.Security.Claims.ClaimsIdentity id = new System.Security.Claims.ClaimsIdentity("authenticationType");         id.AddClaims(ls);          principal = new System.Security.Claims.ClaimsPrincipal(id);         return new AuthenticationTicket(principal, new AuthenticationProperties(), "MyCookieMiddlewareInstance");           try         {             principal = handler.ValidateToken(protectedText, this.validationParameters, out validToken);              JwtSecurityToken validJwt = validToken as JwtSecurityToken;              if (validJwt == null)             {                 throw new System.ArgumentException("Invalid JWT");             }              if (!validJwt.Header.Alg.Equals(algorithm, System.StringComparison.Ordinal))             {                 throw new System.ArgumentException($"Algorithm must be '{algorithm}'");             }              // Additional custom validation of JWT claims here (if any)         }         catch (SecurityTokenValidationException)         {             return null;         }         catch (System.ArgumentException)         {             return null;         }          // Validation passed. Return a valid AuthenticationTicket:         return new AuthenticationTicket(principal, new AuthenticationProperties(), "MyCookieMiddlewareInstance");     }   } 

And you can also create the JWT-token with Microsoft.IdentityModel.Token:

// https://github.com/aspnet/Security/blob/master/src/Microsoft.AspNetCore.Authentication.JwtBearer/Events/IJwtBearerEvents.cs // http://codereview.stackexchange.com/questions/45974/web-api-2-authentication-with-jwt public class TokenMaker {      class SecurityConstants     {         public static string TokenIssuer;         public static string TokenAudience;         public static int TokenLifetimeMinutes;     }       public static string IssueToken()     {         SecurityKey sSKey = null;          var claimList = new List<Claim>()         {             new Claim(ClaimTypes.Name, "userName"),             new Claim(ClaimTypes.Role, "role")     //Not sure what this is for         };          JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();         SecurityTokenDescriptor desc = makeSecurityTokenDescriptor(sSKey, claimList);          // JwtSecurityToken tok = tokenHandler.CreateJwtSecurityToken(desc);         return tokenHandler.CreateEncodedJwt(desc);     }           public static ClaimsPrincipal ValidateJwtToken(string jwtToken)     {         SecurityKey sSKey = null;         var tokenHandler = new JwtSecurityTokenHandler();          // Parse JWT from the Base64UrlEncoded wire form          //(<Base64UrlEncoded header>.<Base64UrlEncoded body>.<signature>)         JwtSecurityToken parsedJwt = tokenHandler.ReadToken(jwtToken) as JwtSecurityToken;          TokenValidationParameters validationParams =             new TokenValidationParameters()             {                 RequireExpirationTime = true,                 ValidAudience = SecurityConstants.TokenAudience,                 ValidIssuers = new List<string>() { SecurityConstants.TokenIssuer },                 ValidateIssuerSigningKey = true,                 ValidateLifetime = true,                 IssuerSigningKey = sSKey,                              };          SecurityToken secT;         return tokenHandler.ValidateToken("token", validationParams, out secT);     }       private static SecurityTokenDescriptor makeSecurityTokenDescriptor(SecurityKey sSKey, List<Claim> claimList)     {         var now = DateTime.UtcNow;         Claim[] claims = claimList.ToArray();         return new Microsoft.IdentityModel.Tokens.SecurityTokenDescriptor         {             Subject = new ClaimsIdentity(claims),             Issuer = SecurityConstants.TokenIssuer,             Audience = SecurityConstants.TokenAudience,             IssuedAt = System.DateTime.UtcNow,             Expires = System.DateTime.UtcNow.AddMinutes(SecurityConstants.TokenLifetimeMinutes),             NotBefore = System.DateTime.UtcNow.AddTicks(-1),              SigningCredentials = new SigningCredentials(sSKey, Microsoft.IdentityModel.Tokens.SecurityAlgorithms.EcdsaSha512Signature)         };                }  } 

Note that because you can give a different user in the cookie vs. http-headers (Bearer), or any other authentication method that you specify, you can actually have MORE than 1 user !

---

Take a look at this:
https://stormpath.com/blog/token-authentication-asp-net-core

it should be exactly what you're looking for.

There's also these two:

https://goblincoding.com/2016/07/03/issuing-and-authenticating-jwt-tokens-in-asp-net-core-webapi-part-i/

https://goblincoding.com/2016/07/07/issuing-and-authenticating-jwt-tokens-in-asp-net-core-webapi-part-ii/

and this one
http://blog.novanet.no/hooking-up-asp-net-core-1-rc1-web-api-with-auth0-bearer-tokens/

And the JWT-Bearer sources https://github.com/aspnet/Security/tree/master/src/Microsoft.AspNetCore.Authentication.JwtBearer

---

If you need ultra-high security, you should protect against replay-attacks by renewing the ticket on each request, and invalidate old tickets after a certain timeout, and after user logout (not just after validity expiration).

---

For those of you who end up from here via google, you can implement a TicketDataFormat in cookie-authentication when you want to use your own version of JWT.

I had to look into JWT for work, because we needed to secure our application.
Because I still had to use .NET 2.0, I had to write my own library.

I've ported the result of that to .NET Core this weekend. You find it here: https://github.com/ststeiger/Jwt_Net20/tree/master/CoreJWT

It doesn't use any database, that's not the job of a JWT libary.
Getting and setting DB data is your job.
The library allows for JWT authorization and verification in .NET Core with all algorithms specified in the JWT RFC listed on the IANA JOSE assignment.
As for adding authorization to the pipeline and adding values to route - these are two things which should be done separately, and I think you best do that yourselfs.

You can use custom authentication in ASP.NET Core.
Look into the "Security" category of docs on docs.asp.net.

Or you can look into the Cookie Middleware without ASP.NET Identity or into Custom Policy-Based Authorization.

You can also learn more in the auth workshop on github or in the social login section or in this channel 9 video tutorial.
If all else fails, the source code of asp.net security is on github.

---

The original project for .NET 3.5, which is where my library derives from, is here:
https://github.com/jwt-dotnet/jwt
I removed all references to LINQ + extension methods, because they are not supported in .NET 2.0. If you include either LINQ, or ExtensionAttribute in the sourcecode, then you can't just change the .NET runtime without getting warnings; that's why I have completely removed them.
Also, I've added RSA + ECDSA JWS-methods, for that reason the CoreJWT-project depends on BouncyCastle.
If you limit yourselfs to HMAC-SHA256 + HMAC-SHA384 + HMAC-SHA512, you can remove BouncyCastle.

JWE is not (yet) supported.

Usage is just like jwt-dotnet/jwt, except I changed the namespace JWT to CoreJWT.
I also added an internal copy of PetaJSON as serializer, so there is no interference with other people's project's dependencies.

Create a JWT-token:

var payload = new Dictionary<string, object>() {     { "claim1", 0 },     { "claim2", "claim2-value" } }; var secretKey = "GQDstcKsx0NHjPOuXOYg5MbeJ1XT0uFiwDVvVBrk"; string token = JWT.JsonWebToken.Encode(payload, secretKey, JWT.JwtHashAlgorithm.HS256); Console.WriteLine(token); 

Verify a JWT-token:

var token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJjbGFpbTEiOjAsImNsYWltMiI6ImNsYWltMi12YWx1ZSJ9.8pwBI_HtXqI3UgQHQ_rDRnSQRxFL1SR8fbQoS-5kM5s"; var secretKey = "GQDstcKsx0NHjPOuXOYg5MbeJ1XT0uFiwDVvVBrk"; try {     string jsonPayload = JWT.JsonWebToken.Decode(token, secretKey);     Console.WriteLine(jsonPayload); } catch (JWT.SignatureVerificationException) {     Console.WriteLine("Invalid token!"); } 

For RSA & ECSA, you'll have to pass the (BouncyCastle) RSA/ECDSA private key instead of secretKey.

namespace BouncyJWT {       public class JwtKey     {         public byte[] MacKeyBytes;         public Org.BouncyCastle.Crypto.AsymmetricKeyParameter RsaPrivateKey;         public Org.BouncyCastle.Crypto.Parameters.ECPrivateKeyParameters EcPrivateKey;           public string MacKey         {             get { return System.Text.Encoding.UTF8.GetString(this.MacKeyBytes); }             set { this.MacKeyBytes = System.Text.Encoding.UTF8.GetBytes(value); }         }           public JwtKey()         { }          public JwtKey(string macKey)         {             this.MacKey = macKey;         }          public JwtKey(byte[] macKey)         {             this.MacKeyBytes = macKey;         }          public JwtKey(Org.BouncyCastle.Crypto.AsymmetricKeyParameter rsaPrivateKey)         {             this.RsaPrivateKey = rsaPrivateKey;         }          public JwtKey(Org.BouncyCastle.Crypto.Parameters.ECPrivateKeyParameters ecPrivateKey)         {             this.EcPrivateKey = ecPrivateKey;         }     }   } 

For how to generate/export/import RSA/ECDSA-keys with BouncyCastle, see the project called "BouncyCastleTests" in the same repository. I leave it to you to safely store and retrieve your own RSA/ECDSA private keys.

I've verified my library's results for HMAC-ShaXXX and RSA-XXX with JWT.io - it looks like they are OK.
ECSD should be OK, too, but I didn't test it against anything.
I did not run extensive tests anyway, FYI.