使用JWT建立安全的ASP.NET Core Web API
在本文中，你將學習如何在ASP.NET Core Web API中使用JWT身份驗證。我將在編寫程式碼時逐步簡化。我們將構建兩個終結點，一個用於客戶登入，另一個用於獲取客戶訂單。這些api將連線到在本地機器上執行的SQL Server Express資料庫。
JWT是什麼?
JWT或JSON Web Token基本上是格式化令牌的一種方式，令牌表示一種經過編碼的資料結構，該資料結構具有緊湊、url安全、安全且自包含特點。
JWT身份驗證是api和客戶端之間進行通訊的一種標準方式，因此雙方可以確保傳送/接收的資料是可信的和可驗證的。
JWT應該由伺服器發出，並使用加密的安全金鑰對其進行數字簽名，以便確保任何攻擊者都無法篡改在令牌內傳送的有效payload及模擬合法使用者。
JWT結構包括三個部分，用點隔開，每個部分都是一個base64 url編碼的字串，JSON格式:
Header.Payload.Signature：
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1laWQiOiIxIiwicm9sZSI6IkFjY291bnQgTWFuYWdlciIsIm5iZiI6MTYwNDAxMDE4NSwiZXhwIjoxNjA0MDExMDg1LCJpYXQiOjE2MDQwMTAxODV9.XJLeLeUIlOZQjYyQ2JT3iZ-AsXtBoQ9eI1tEtOkpyj8
Header:表示用於對祕鑰進行雜湊的演算法(例如HMACSHA256)
Payload:在客戶端和API之間傳輸的資料或宣告
Signature:Header和Payload連線的雜湊
因為JWT標記是用base64編碼的，所以可以使用jwt.io簡單地研究它們或通過任何線上base64解碼器。
由於這個特殊的原因，你不應該在JWT中儲存關於使用者的機密資訊。
準備工作：
下載並安裝Visual Studio 2019的最新版本(我使用的是Community Edition)。
下載並安裝SQL Server Management Studio和SQL Server Express的最新更新。
開始我們的教程
讓我們在Visual Studio 2019中建立一個新專案。專案命名為SecuringWebApiUsingJwtAuthentication。我們需要選擇ASP.NET Core Web API模板，然後按下建立。Visual Studio現在將建立新的ASP.NET Core Web API模板專案。讓我們刪除WeatherForecastController.cs和WeatherForecast.cs檔案，這樣我們就可以開始建立我們自己的控制器和模型。
準備資料庫
在你的機器上安裝SQL Server Express和SQL Management Studio，
現在，從物件資源管理器中，右鍵單擊資料庫並選擇new database，給資料庫起一個類似CustomersDb的名稱。
為了使這個過程更簡單、更快，只需執行下面的指令碼，它將建立表並將所需的資料插入到CustomersDb中。
USE [CustomersDb]
GO
/****** Object: Table [dbo].[Customer] Script Date: 11/9/2020 1:56:38 AM ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Customer](
[Id] [int] IDENTITY(1,1) NOT NULL,
[Username] [nvarchar](255) NOT NULL,
[Password] [nvarchar](255) NOT NULL,
[PasswordSalt] [nvarchar](50) NOT NULL,
[FirstName] [nvarchar](255) NOT NULL,
[LastName] [nvarchar](255) NOT NULL,
[Email] [nvarchar](255) NOT NULL,
[TS] [smalldatetime] NOT NULL,
[Active] [bit] NOT NULL,
[Blocked] [bit] NOT NULL,
CONSTRAINT [PK_Customer] PRIMARY KEY CLUSTERED
(
[Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, _
ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
/****** Object: Table [dbo].[Order] Script Date: 11/9/2020 1:56:38 AM ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Order](
[Id] [int] IDENTITY(1,1) NOT NULL,
[Status] [nvarchar](50) NOT NULL,
[Quantity] [int] NOT NULL,
[Total] [decimal](19, 4) NOT NULL,
[Currency] [char](3) NOT NULL,
[TS] [smalldatetime] NOT NULL,
[CustomerId] [int] NOT NULL,
CONSTRAINT [PK_Order] PRIMARY KEY CLUSTERED
(
[Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, _
ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
SET IDENTITY_INSERT [dbo].[Customer] ON
GO
INSERT [dbo].[Customer] ([Id], [Username], [Password], [PasswordSalt], _
[FirstName], [LastName], [Email], [TS], [Active], [Blocked]) _
VALUES (1, N'coding', N'ezVOZenPoBHuLjOmnRlaI3Q3i/WcGqHDjSB5dxWtJLQ=', _
N'MTIzNDU2Nzg5MTIzNDU2Nw==', N'Coding', N'Sonata', N'[email protected]', _
CAST(N'2020-10-30T00:00:00' AS SmallDateTime), 1, 1)
GO
INSERT [dbo].[Customer] ([Id], [Username], [Password], [PasswordSalt], _
[FirstName], [LastName], [Email], [TS], [Active], [Blocked]) _
VALUES (2, N'test', N'cWYaOOxmtWLC5DoXd3RZMzg/XS7Xi89emB7jtanDyAU=', _
N'OTUxNzUzODUyNDU2OTg3NA==', N'Test', N'Testing', N'[email protected]', _
CAST(N'2020-10-30T00:00:00' AS SmallDateTime), 1, 0)
GO
SET IDENTITY_INSERT [dbo].[Customer] OFF
GO
SET IDENTITY_INSERT [dbo].[Order] ON
GO
INSERT [dbo].[Order] ([Id], [Status], [Quantity], [Total], [Currency], [TS], _
[CustomerId]) VALUES (1, N'Processed', 5, CAST(120.0000 AS Decimal(19, 4)), _
N'USD', CAST(N'2020-10-25T00:00:00' AS SmallDateTime), 1)
GO
INSERT [dbo].[Order] ([Id], [Status], [Quantity], [Total], [Currency], [TS], _
[CustomerId]) VALUES (2, N'Completed', 2, CAST(750.0000 AS Decimal(19, 4)), _
N'USD', CAST(N'2020-10-25T00:00:00' AS SmallDateTime), 1)
GO
SET IDENTITY_INSERT [dbo].[Order] OFF
GO
ALTER TABLE [dbo].[Order] WITH CHECK ADD CONSTRAINT [FK_Order_Customer] _
FOREIGN KEY([CustomerId])
REFERENCES [dbo].[Customer] ([Id])
GO
ALTER TABLE [dbo].[Order] CHECK CONSTRAINT [FK_Order_Customer]
GO
準備資料庫模型和DbContext
建立實體資料夾，然後新增Customer.cs:
using System;
using System.Collections.Generic;
namespace SecuringWebApiUsingJwtAuthentication.Entities
{
public class Customer
{
public int Id { get; set; }
public string Username { get; set; }
public string Password { get; set; }
public string PasswordSalt { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public string Email { get; set; }
public DateTime TS { get; set; }
public bool Active { get; set; }
public bool Blocked { get; set; }
public ICollection<Order> Orders { get; set; }
}
}
新增Order.cs:
using System;
using System.Text.Json.Serialization;
namespace SecuringWebApiUsingJwtAuthentication.Entities
{
public class Order
{
public int Id { get; set; }
public string Status { get; set; }
public int Quantity { get; set; }
public decimal Total { get; set; }
public string Currency { get; set; }
public DateTime TS { get; set; }
public int CustomerId { get; set; }
[JsonIgnore]
public Customer Customer { get; set; }
}
}
我將JsonIgnore屬性新增到Customer物件，以便在對order物件進行Json序列化時隱藏它。
JsonIgnore屬性來自 System.Text.Json.Serialization 名稱空間，因此請確保將其包含在Order類的頂部。
現在我們將建立一個新類，它繼承了EFCore的DbContext，用於對映資料庫。
建立一個名為CustomersDbContext.cs的類:
using Microsoft.EntityFrameworkCore;
namespace SecuringWebApiUsingJwtAuthentication.Entities
{
public class CustomersDbContext : DbContext
{
public DbSet<Customer> Customers { get; set; }
public DbSet<Order> Orders { get; set; }
public CustomersDbContext
(DbContextOptions<CustomersDbContext> options) : base(options)
{
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Customer>().ToTable("Customer");
modelBuilder.Entity<Order>().ToTable("Order");
}
}
}
Visual Studio現在將開始丟擲錯誤，因為我們需要為EntityFramework Core和EntityFramework SQL Server引用NuGet包。
所以右鍵單擊你的專案名稱，選擇管理NuGet包，然後下載以下包:
-
Microsoft.EntityFrameworkCore
-
Microsoft.EntityFrameworkCore.SqlServer
一旦上述包在專案中被引用，就不會再看到VS的錯誤了。
現在轉到Startup.cs檔案，在ConfigureServices中將我們的dbcontext新增到服務容器:
services.AddDbContext<CustomersDbContext>(options=> options.UseSqlServer(Configuration.GetConnectionString("CustomersDbConnectionString")));
讓我們開啟appsettings.json檔案，並在ConnectionStrings中建立連線字串:
{
"ConnectionStrings": {
"CustomersDbConnectionString": "Server=Home\\SQLEXPRESS;Database=CustomersDb;
Trusted_Connection=True;MultipleActiveResultSets=true"
},
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft": "Warning",
"Microsoft.Hosting.Lifetime": "Information"
}
},
"AllowedHosts": "*"
}
現在我們已經完成了資料庫對映和連線部分。
我們將繼續準備服務中的業務邏輯。
建立服務
建立一個名稱帶有Requests的新資料夾。
我們在這裡有一個LoginRequest.cs類，它表示客戶將提供給登入的使用者名稱和密碼欄位。
namespace SecuringWebApiUsingJwtAuthentication.Requests
{
public class LoginRequest
{
public string Username { get; set; }
public string Password { get; set; }
}
}
為此,我們需要一個特殊的Response物件,返回有效的客戶包括基本使用者資訊和他們的access token(JWT格式),這樣他們就可以通過Authorization Header在後續請求授權api作為Bearer令牌。
因此，建立另一個資料夾，名稱為Responses ，在其中，建立一個新的檔案，名稱為LoginResponse.cs:
namespace SecuringWebApiUsingJwtAuthentication.Responses
{
public class LoginResponse
{
public string Username { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public string Token { get; set; }
}
}
建立一個Interfaces資料夾：
新增一個新的介面ICustomerService.cs，這將包括客戶登入的原型方法:
using SecuringWebApiUsingJwtAuthentication.Requests;
using SecuringWebApiUsingJwtAuthentication.Responses;
using System.Threading.Tasks;
namespace SecuringWebApiUsingJwtAuthentication.Interfaces
{
public interface ICustomerService
{
Task<LoginResponse> Login(LoginRequest loginRequest);
}
}
現在是實現ICustomerService的部分。
建立一個新資料夾並將其命名為Services。
新增一個名為CustomerService.cs的新類:
using SecuringWebApiUsingJwtAuthentication.Entities;
using SecuringWebApiUsingJwtAuthentication.Helpers;
using SecuringWebApiUsingJwtAuthentication.Interfaces;
using SecuringWebApiUsingJwtAuthentication.Requests;
using SecuringWebApiUsingJwtAuthentication.Responses;
using System.Linq;
using System.Threading.Tasks;
namespace SecuringWebApiUsingJwtAuthentication.Services
{
public class CustomerService : ICustomerService
{
private readonly CustomersDbContext customersDbContext;
public CustomerService(CustomersDbContext customersDbContext)
{
this.customersDbContext = customersDbContext;
}
public async Task<LoginResponse> Login(LoginRequest loginRequest)
{
var customer = customersDbContext.Customers.SingleOrDefault
(customer => customer.Active && customer.Username == loginRequest.Username);
if (customer == null)
{
return null;
}
var passwordHash = HashingHelper.HashUsingPbkdf2
(loginRequest.Password, customer.PasswordSalt);
if (customer.Password != passwordHash)
{
return null;
}
var token = await Task.Run( () => TokenHelper.GenerateToken(customer));
return new LoginResponse { Username = customer.Username,
FirstName = customer.FirstName, LastName = customer.LastName, Token = token };
}
}
}
上面的登入函式在資料庫中檢查客戶的使用者名稱、密碼，如果這些條件匹配，那麼我們將生成一個JWT並在LoginResponse中為呼叫者返回它，否則它將在LoginReponse中返回一個空值。
首先，讓我們建立一個名為Helpers的新資料夾。
新增一個名為HashingHelper.cs的類。
這將用於檢查登入請求中的密碼的雜湊值，以匹配資料庫中密碼的雜湊值和鹽值的雜湊值。
在這裡,我們使用的是基於派生函式(PBKDF2),它應用了HMac函式結合一個雜湊演算法(sha - 256)將密碼和鹽值(base64編碼的隨機數與大小128位)重複多次後作為迭代引數中指定的引數(是預設的10000倍)，運用在我們的示例中，並獲得一個隨機金鑰的產生結果。
派生函式(或密碼雜湊函式)，如PBKDF2或Bcrypt，由於隨著salt一起應用了大量的迭代，需要更長的計算時間和更多的資源來破解密碼。
注意:千萬不要將密碼以純文字儲存在資料庫中,要確保計算並儲存密碼的雜湊,並使用一個鍵派生函式雜湊演算法有一個很大的尺寸(例如,256位或更多)和隨機大型鹽值(64位或128位),使其難以破解。
此外，在構建使用者註冊螢幕或頁面時，應該確保應用強密碼(字母數字和特殊字元的組合)的驗證規則以及密碼保留策略，這甚至可以最大限度地提高儲存密碼的安全性。
using System;
using System.Security.Cryptography;
using System.Text;
namespace SecuringWebApiUsingJwtAuthentication.Helpers
{
public class HashingHelper
{
public static string HashUsingPbkdf2(string password, string salt)
{
using var bytes = new Rfc2898DeriveBytes
(password, Convert.FromBase64String(salt), 10000, HashAlgorithmName.SHA256);
var derivedRandomKey = bytes.GetBytes(32);
var hash = Convert.ToBase64String(derivedRandomKey);
return hash;
}
}
}
生成 JSON Web Token (JWT)
在Helpers 資料夾中新增另一個名為TokenHelper.cs的類。
這將包括我們的令牌生成函式:
using Microsoft.IdentityModel.Tokens;
using SecuringWebApiUsingJwtAuthentication.Entities;
using System;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Security.Cryptography;
namespace SecuringWebApiUsingJwtAuthentication.Helpers
{
public class TokenHelper
{
public const string Issuer = "http://codingsonata.com";
public const string Audience = "http://codingsonata.com";
public const string Secret =
"OFRC1j9aaR2BvADxNWlG2pmuD392UfQBZZLM1fuzDEzDlEpSsn+
btrpJKd3FfY855OMA9oK4Mc8y48eYUrVUSw==";
//Important note***************
//The secret is a base64-encoded string, always make sure to
//use a secure long string so no one can guess it. ever!.a very recommended approach
//to use is through the HMACSHA256() class, to generate such a secure secret,
//you can refer to the below function
//you can run a small test by calling the GenerateSecureSecret() function
//to generate a random secure secret once, grab it, and use it as the secret above
//or you can save it into appsettings.json file and then load it from them,
//the choice is yours
public static string GenerateSecureSecret()
{
var hmac = new HMACSHA256();
return Convert.ToBase64String(hmac.Key);
}
public static string GenerateToken(Customer customer)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Convert.FromBase64String(Secret);
var claimsIdentity = new ClaimsIdentity(new[] {
new Claim(ClaimTypes.NameIdentifier, customer.Id.ToString()),
new Claim("IsBlocked", customer.Blocked.ToString())
});
var signingCredentials = new SigningCredentials
(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = claimsIdentity,
Issuer = Issuer,
Audience = Audience,
Expires = DateTime.Now.AddMinutes(15),
SigningCredentials = signingCredentials,
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return tokenHandler.WriteToken(token);
}
}
}
我們需要引用這裡的另一個庫
-
Microsoft.AspNetCore.Authentication.JwtBearer
讓我們仔細看看GenerateToken函式:
在傳遞customer物件時，我們可以使用任意數量的屬性，並將它們新增到將嵌入到令牌中的聲明裡。但在本教程中，我們將只嵌入客戶的id屬性。
JWT依賴於數字簽名演算法，其中推薦的演算法之一，我們在這裡使用的是HMac雜湊演算法使用256位的金鑰大小。
我們從之前使用HMACSHA256類生成的隨機金鑰生成金鑰。你可以使用任何隨機字串，但要確保使用長且難以猜測的文字，最好使用前面程式碼示例中所示的HMACSHA256類。
你可以將生成的祕鑰儲存在常量或appsettings中，並將其載入到Startup.cs。
建立控制器
現在我們需要在CustomersController使用CustomerService的Login方法。
建立一個新資料夾並將其命名為Controllers。
新增一個新的檔案CustomersController.cs。如果登入成功，它將有一個POST方法接收使用者名稱和密碼並返回JWT令牌和其他客戶細節，否則它將返回404。
using Microsoft.AspNetCore.Mvc;
using SecuringWebApiUsingJwtAuthentication.Interfaces;
using SecuringWebApiUsingJwtAuthentication.Requests;
using System.Threading.Tasks;
namespace SecuringWebApiUsingJwtAuthentication.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class CustomersController : ControllerBase
{
private readonly ICustomerService customerService;
public CustomersController(ICustomerService customerService)
{
this.customerService = customerService;
}
[HttpPost]
[Route("login")]
public async Task<IActionResult> Login(LoginRequest loginRequest)
{
if (loginRequest == null || string.IsNullOrEmpty(loginRequest.Username) ||
string.IsNullOrEmpty(loginRequest.Password))
{
return BadRequest("Missing login details");
}
var loginResponse = await customerService.Login(loginRequest);
if (loginResponse == null)
{
return BadRequest($"Invalid credentials");
}
return Ok(loginResponse);
}
}
}
正如這裡看到的，我們定義了一個POST方法用來接收LoginRequest(使用者名稱和密碼)，它對輸入進行基本驗證，並呼叫客戶服務的 Login方法。
我們將使用介面ICustomerService通過控制器的建構函式注入CustomerService，我們需要在啟動的ConfigureServices函式中定義此注入:
services.AddScoped<ICustomerService, CustomerService>();
現在，在執行API之前，我們可以配置啟動URL，還可以知道IIS Express物件中http和https的埠號。
這就是你的launchsettings.json檔案:
{
"schema": "http://json.schemastore.org/launchsettings.json",
"iisSettings": {
"windowsAuthentication": false,
"anonymousAuthentication": true,
"iisExpress": {
"applicationUrl": "http://localhost:60057",
"sslPort": 44375
}
},
"profiles": {
"IIS Express": {
"commandName": "IISExpress",
"launchBrowser": true,
"launchUrl": "",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
},
"SecuringWebApiUsingJwtAuthentication": {
"commandName": "Project",
"launchBrowser": true,
"launchUrl": "",
"applicationUrl": "https://localhost:5001;http://localhost:5000",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
}
}
}
現在，如果你在本地機器上執行API，應該能夠呼叫login方法並生成第一個JSON Web Token。
通過PostMan測試Login
開啟瀏覽器，開啟PostMan。
開啟新的request選項卡，執行應用程式後，填寫設定中的本地主機和埠號。
從body中選擇raw和JSON，並填寫JSON物件，這將使用該物件通過我們的RESTful API登入到客戶資料庫。
以下是PostMan的請求/迴應
這是我們的第一個JWT。
讓我們準備API來接收這個token，然後驗證它，在其中找到一個宣告，然後為呼叫者返回一個響應。
可以通過許多方式驗證你的api、授權你的使用者:
1.根據.net core團隊的說法，基於策略的授權還可以包括定義角色和需求，這是通過細粒度方法實現API身份驗證的推薦方法。
2.擁有一個自定義中介軟體來驗證在帶有Authorize屬性修飾的api上傳遞的請求頭中的JWT。
3.在為JWT授權標頭驗證請求標頭集合的一個或多個控制器方法上設定自定義屬性。
在本教程中，我將以最簡單的形式使用基於策略的身份驗證，只是為了向你展示可以應用基於策略的方法來保護您的ASP.NET Core Web api。
身份驗證和授權之間的區別
身份驗證是驗證使用者是否有權訪問api的過程。
通常，試圖訪問api的未經身份驗證的使用者將收到一個http 401未經授權的響應。
授權是驗證經過身份驗證的使用者是否具有訪問特定API的正確許可權的過程。
通常，試圖訪問僅對特定角色或需求有效的API的未授權使用者將收到http 403 Forbidden響應。
配置身份驗證和授權
現在，讓我們在startup中新增身份驗證和授權配置。
在ConfigureServices方法中，我們需要定義身份驗證方案及其屬性，然後定義授權選項。
在身份驗證部分中,我們將使用預設JwtBearer的方案,我們將定義TokenValidationParamters,以便我們驗證IssuerSigningKey確保簽名了使用正確的Security Key。
在授權部分中，我們將新增一個策略，當指定一個帶有Authorize屬性的終結點上時，它將只對未被阻止的客戶進行授權。
被阻止的登入客戶仍然能夠訪問沒有定義策略的其他端點，但是對於定義了 OnlyNonBlockedCustomer策略的端點，被阻塞的客戶將被403 Forbidden響應拒絕訪問。
首先，建立一個資料夾並將其命名為Requirements。
新增一個名為 CustomerStatusRequirement.cs的新類。
using Microsoft.AspNetCore.Authorization;
namespace SecuringWebApiUsingJwtAuthentication.Requirements
{
public class CustomerBlockedStatusRequirement : IAuthorizationRequirement
{
public bool IsBlocked { get; }
public CustomerBlockedStatusRequirement(bool isBlocked)
{
IsBlocked = isBlocked;
}
}
}
然後建立另一個資料夾並將其命名為Handlers。
新增一個名為CustomerBlockedStatusHandler.cs的新類:
using Microsoft.AspNetCore.Authorization;
using SecuringWebApiUsingJwtAuthentication.Helpers;
using SecuringWebApiUsingJwtAuthentication.Requirements;
using System;
using System.Threading.Tasks;
namespace SecuringWebApiUsingJwtAuthentication.Handlers
{
public class CustomerBlockedStatusHandler :
AuthorizationHandler<CustomerBlockedStatusRequirement>
{
protected override Task HandleRequirementAsync
(AuthorizationHandlerContext context, CustomerBlockedStatusRequirement requirement)
{
var claim = context.User.FindFirst(c => c.Type == "IsBlocked" &&
c.Issuer == TokenHelper.Issuer);
if (!context.User.HasClaim(c => c.Type == "IsBlocked" &&
c.Issuer == TokenHelper.Issuer))
{
return Task.CompletedTask;
}
string value = context.User.FindFirst(c => c.Type == "IsBlocked" &&
c.Issuer == TokenHelper.Issuer).Value;
var customerBlockedStatus = Convert.ToBoolean(value);
if (customerBlockedStatus == requirement.IsBlocked)
{
context.Succeed(requirement);
}
return Task.CompletedTask;
}
}
}
最後，讓我們將所有身份驗證和授權配置新增到服務集合:
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidateAudience = true,
ValidateIssuerSigningKey = true,
ValidIssuer = TokenHelper.Issuer,
ValidAudience = TokenHelper.Audience,
IssuerSigningKey = new SymmetricSecurityKey
(Convert.FromBase64String(TokenHelper.Secret))
};
});
services.AddAuthorization(options =>
{
options.AddPolicy("OnlyNonBlockedCustomer", policy =>
{
policy.Requirements.Add(new CustomerBlockedStatusRequirement(false));
});
});
services.AddSingleton<IAuthorizationHandler, CustomerBlockedStatusHandler>();
為此，我們需要包括以下名稱空間:
-
using Microsoft.AspNetCore.Authorization;
-
using Microsoft.IdentityModel.Tokens;
-
using SecuringWebApiUsingJwtAuthentication.Helpers;
-
using SecuringWebApiUsingJwtAuthentication.Handlers;
-
using SecuringWebApiUsingJwtAuthentication.Requirements;
現在，上面的方法不能單獨工作，身份驗證和授權必須通過Startup中的Configure 方法包含在ASP.NET Core API管道:
app.UseAuthentication(); app.UseAuthorization();
這裡，我們完成了ASP.NET Core Web API使用JWT身份驗證。
建立OrderService
我們將需要一種專門處理訂單的新服務。
在Interfaces資料夾下建立一個名為IOrderService.cs的新介面:
using SecuringWebApiUsingJwtAuthentication.Entities;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace SecuringWebApiUsingJwtAuthentication.Interfaces
{
public interface IOrderService
{
Task<List<Order>> GetOrdersByCustomerId(int id);
}
}
該介面包括一個方法，該方法將根據客戶Id檢索指定客戶的訂單。
讓我們實現這個介面。
在Services 資料夾下建立一個名為OrderService.cs的新類:
using SecuringWebApiUsingJwtAuthentication.Entities;
using SecuringWebApiUsingJwtAuthentication.Interfaces;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;
using Microsoft.EntityFrameworkCore;
namespace SecuringWebApiUsingJwtAuthentication.Services
{
public class OrderService : IOrderService
{
private readonly CustomersDbContext customersDbContext;
public OrderService(CustomersDbContext customersDbContext)
{
this.customersDbContext = customersDbContext;
}
public async Task<List<Order>> GetOrdersByCustomerId(int id)
{
var orders = await customersDbContext.Orders.Where
(order => order.CustomerId == id).ToListAsync();
return orders;
}
}
}
建立OrdersController
現在我們需要建立一個新的終結點，它將使用Authorize屬性和OnlyNonBlockedCustomer策略。
在Controllers資料夾下新增一個新控制器，命名為OrdersController.cs:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using SecuringWebApiUsingJwtAuthentication.Interfaces;
namespace SecuringWebApiUsingJwtAuthentication.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class OrdersController : ControllerBase
{
private readonly IOrderService orderService;
public OrdersController(IOrderService orderService)
{
this.orderService = orderService;
}
[HttpGet()]
[Authorize(Policy = "OnlyNonBlockedCustomer")]
public async Task<IActionResult> Get()
{
var claimsIdentity = HttpContext.User.Identity as ClaimsIdentity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
if (claim == null)
{
return Unauthorized("Invalid customer");
}
var orders = await orderService.GetOrdersByCustomerId(int.Parse(claim.Value));
if (orders == null || !orders.Any())
{
return BadRequest($"No order was found");
}
return Ok(orders);
}
}
}
我們將建立一個GET方法，用於檢索客戶的訂單。
此方法將使用Authorize屬性進行修飾，並僅為非阻塞客戶定義訪問策略。
任何試圖獲取訂單的被阻止的登入客戶，即使該客戶經過了正確的身份驗證，也會收到一個403 Forbidden請求，因為該客戶沒有被授權訪問這個特定的端點。
我們需要在Startup.cs檔案中包含OrderService。
將下面的內容新增到CustomerService行下面。
services.AddScoped<IOrderService, OrderService>();
這是Startup.cs檔案的完整檢視，需要與你的檔案進行核對。
using System;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.IdentityModel.Tokens;
using SecuringWebApiUsingJwtAuthentication.Entities;
using SecuringWebApiUsingJwtAuthentication.Handlers;
using SecuringWebApiUsingJwtAuthentication.Helpers;
using SecuringWebApiUsingJwtAuthentication.Interfaces;
using SecuringWebApiUsingJwtAuthentication.Requirements;
using SecuringWebApiUsingJwtAuthentication.Services;
namespace SecuringWebApiUsingJwtAuthentication
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
// This method gets called by the runtime.
// Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<CustomersDbContext>
(options => options.UseSqlServer(Configuration.GetConnectionString
("CustomersDbConnectionString")));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidateAudience = true,
ValidateIssuerSigningKey = true,
ValidIssuer = TokenHelper.Issuer,
ValidAudience = TokenHelper.Audience,
IssuerSigningKey = new SymmetricSecurityKey
(Convert.FromBase64String(TokenHelper.Secret))
};
});
services.AddAuthorization(options =>
{
options.AddPolicy("OnlyNonBlockedCustomer", policy => {
policy.Requirements.Add(new CustomerBlockedStatusRequirement(false));
});
});
services.AddSingleton<IAuthorizationHandler, CustomerBlockedStatusHandler>();
services.AddScoped<ICustomerService, CustomerService>();
services.AddScoped<IOrderService, OrderService>();
services.AddControllers();
}
// This method gets called by the runtime.
// Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
}
}
通過PostMan測試
執行應用程式並開啟Postman。
讓我們嘗試用錯誤的密碼登入:
現在讓我們嘗試正確的憑證登入:
如果你使用上面的令牌並在jwt.io中進行驗證，你將看到header和payload細節:
現在讓我們測試get orders終結點，我們將獲取令牌字串並將其作為Bearer Token 在授權頭傳遞:
為什麼我們的API沒有返回403？
如果你回到前面的一步，你將注意到我們的客戶被阻止了(“IsBlocked”:True)，即只有非阻止的客戶才被授權訪問該端點。
為此，我們將解除該客戶的阻止，或者嘗試與另一個客戶登入。
返回資料庫，並將使用者的Blocked更改為False。
現在再次開啟Postman並以相同的使用者登入，這樣我們就得到一個新的JWT，其中包括IsBlocked型別的更新值。
接下來在jwt.io中重新檢視：
你現在注意到區別了嗎?
現在不再被阻止，因為我們獲得了一個新的JWT，其中包括從資料庫讀取的宣告。
讓我們嘗試使用這個新的JWT訪問我們的終結點。
它工作了!
已經成功通過了策略的要求，因此訂單現在顯示了。
讓我們看看如果使用者試圖訪問這個終結點而不傳遞授權頭會發生什麼:
JWT是防篡改的，所以沒有人可以糊弄它。
我希望本教程使你對API安全和JWT身份驗證有了很好的理解。
歡迎關注我的公眾號——碼農譯站，如果你有喜歡的外文技術文章，可以通過公眾號留言推薦給我。
原文連結：https://www.codeproject.com/Articles/5287315/Secure-ASP-NET-Core-Web-API-using-JWT-Authenticati