65.9K
CodeProject 正在变化。 阅读更多。
Home

JSON Web Token 在 RESTful API .NET Core 7.0 中的身份验证

Farzad Niknam B
starIconstarIconstarIconstarIconstarIcon

5.00/5 (4投票s)

2023 年 8 月 19 日

CPOL

13分钟阅读

viewsIcon

14931

downloadIcon

338

使用 .NET 7.0 和 ASP.NET Core 创建 Web 应用程序

在本文中，我们将深入探讨使用 .NET 7.0 和 ASP.NET Core 创建一个引人注目的 Web 应用程序，同时还将协调强大的 JWT 身份验证的实现。我在本文中已一丝不苟地处理了最微小的细节。我完全了解您对其中大多数主题都很熟悉，但我旨在强调在整个项目中引起我注意的元素。JWT (JSON Web Token) 身份验证是主导当代 Web 应用程序和 API 的首要身份验证机制。它作为一种简洁、自包含的载体，通过 JSON 对象在各方之间交换信息。在 .NET Core 领域，JWT 身份验证的原则作为 API 的保护盾而日益突出，使用户和客户端能够无缝地进行身份验证并获得对受保护资源的授权访问。以下是 .NET Core 中 JWT 身份验证的概述

  1. Token 生成
  2. Token 结构
  3. Token 使用
  4. Token 验证
  5. 中间件和库
  6. JWT 的优势
  7. 安全注意事项

概述

  1. Token 生成：JWT Token 由服务器创建和签名。Token 包含声明（键值对），提供有关用户、其角色、权限等信息。Token 通常使用对称密钥进行签名，如果使用非对称加密，则使用私钥签名。

  2. Token 结构：JWT Token 由三个部分组成

    • header
    • payload（声明），以及
    • signature

    这些部分使用 base64 编码，并用句点连接。Header 通常包含 Token 类型（“typ”: “JWT”）和使用的签名算法（“alg”: “HS256” 代表 HMAC SHA-256）。Payload 包含定义用户属性和访问权限的声明。

  3. Token 使用：Token 在成功身份验证后发送给客户端。客户端在后续请求的 Authorization 标头中将 Token 作为 Bearer Token 发送（“Authorization: Bearer ”）。服务器验证 Token 的签名并检查其声明，以授权用户访问特定资源。

  4. Token 验证：服务器使用与签名时相同的对称密钥或公钥来验证 Token。服务器会检查 Token 的签名、过期时间（exp claim）和颁发者（iss claim）等声明。时钟偏移可用于处理服务器和 Token 创建时间之间的差异。

  5. 中间件和库：ASP.NET Core 提供了中间件（Microsoft.AspNetCore.Authentication.JwtBearer）来处理 JWT 身份验证。您可以配置中间件以满足必要的设置和验证要求。

  6. JWT 的优势：无状态：无需在服务器端存储 Token，使其可扩展。自包含：所有必需的信息都包含在 Token 本身中。广泛支持：JWT 是一种标准化格式，可在不同平台中使用。

  7. 安全注意事项：安全地存储密钥，并防止 Token 泄露。使用 HTTPS 加密通信。限制 Token 中存储的敏感信息量。以下是 ASP.NET Core 中 JWT 身份验证配置的高级示例

在 API 的领域，我将注入我的授权模型，注入强大的控制层。值得注意的是，对于这个项目，我引入了一个简单的用户实体。值得肯定的是，在真正的项目中，AspNetUser 身份验证实体自然会成为焦点。

在精心编排了流畅的 RESTful API 之后，我的下一步是引入一个 ClassLibrary 项目，专门用于创建数据层项目。在这个领域，画布将用实体和存储库来装饰，并优雅地辅以 UnitOfWorkFilter 类，我将在接下来的文章中揭示这个组件的重要性。最后的点睛之笔是 Context，它将编织成这个数据驱动的交响乐。在 JWTAuth API 项目中，正如下面的图片生动展示的那样，我已经战略性地集成了 AuthorizationContext。此添加的目的是利用强大的 Code-First 技术，从 API 将用户创建到数据库。

  1. Token 生成：JWT Token 由服务器创建和签名。Token 包含声明（键值对），提供有关用户、其角色、权限等信息。Token 通常使用对称密钥进行签名，如果使用非对称加密，则使用私钥签名。

  2. Token 结构：JWT Token 由三个部分组成

    • header，
    • payload（声明），以及
    • signature

    这些部分使用 base64 编码，并用句点连接。Header 通常包含 Token 类型（“typ”: “JWT”）和使用的签名算法（“alg”: “HS256” 代表 HMAC SHA-256）。Payload 包含定义用户属性和访问权限的声明。

  3. Token 使用：Token 在成功身份验证后发送给客户端。客户端在后续请求的 Authorization 标头中将 Token 作为 Bearer Token 发送（“Authorization: Bearer ”）。服务器验证 Token 的签名并检查其声明，以授权用户访问特定资源。

  4. Token 验证：服务器使用与签名时相同的对称密钥或公钥来验证 Token。服务器会检查 Token 的签名、过期时间（exp claim）和颁发者（iss claim）等声明。时钟偏移可用于处理服务器和 Token 创建时间之间的差异。

  5. 中间件和库：ASP.NET Core 提供了中间件（Microsoft.AspNetCore.Authentication.JwtBearer）来处理 JWT 身份验证。您可以配置中间件以满足必要的设置和验证要求。

  6. JWT 的优势：无状态：无需在服务器端存储 Token，使其可扩展。自包含：所有必需的信息都包含在 Token 本身中。广泛支持：JWT 是一种标准化格式，可在不同平台中使用。

  7. 安全注意事项：安全地存储密钥，并防止 Token 泄露。使用 HTTPS 加密通信。限制 Token 中存储的敏感信息量。

以下是 ASP.NET Core 中 JWT 身份验证配置的高级示例

image

image

在 API 的领域，我将注入我的授权模型，注入强大的控制层。值得注意的是，对于这个项目，我引入了一个简单的用户实体。值得肯定的是，在真正的项目中，AspNetUser 身份验证实体自然会成为焦点。

在精心编排了流畅的 RESTful API 之后，我的下一步是引入一个 ClassLibrary 项目，专门用于创建数据层项目。在这个领域，画布将用实体和存储库来装饰，并优雅地辅以 UnitOfWorkFilter 类。最后的点睛之笔是 Context，它将编织成这个数据驱动的交响乐。在 JWTAuth API 项目中，正如下面的图片生动展示的那样，我已经战略性地集成了 AuthorizationContext。此添加的目的是利用强大的 Code-First 技术，从 API 将用户创建到数据库。

迁移身份验证实体

为了实现这一目标，安装以下 NuGet 程序包势在必行。值得注意的是，在此上下文中我正在使用 PostgreSQL。

  • Microsoft.EntityFrameworkCore
  • Microsoft.EntityFrameworkCore.Design
  • Npgsql.EntityFrameworkCore.PostgreSQL
  • Microsoft.IdentityModel.Tokens
  • Microsoft.AspNetCore.Authentication.JwtBearer

为了对身份验证实体进行第一次迁移，我们必须将 PostgreSQL 连接字符串放在 appsettings.json 中，如下所示

"ConnectionStrings": {
    "SurveyConnectionString": "Host=localhost;Port=5432;
     Database=SurveyAuth;Username=postgres;Password=*****;"
  },
"AppSettings": {
    "SomeSetting": "SomeValue",
    "AnotherSetting": "AnotherValue",
    "ConnectionString": "Host=localhost;Port=5432;
     Database=SurveyAuth;Username=postgres;Password=*****;"
  },

在接下来的步骤中，当我们继续安装所需的 NuGet 程序包并将必要的要求输入 appsettings.json 文件后，我们还将为我们的 DataContext 引入依赖注入。为了提高程序代码的可读性，我已将内容组织成单独的类，并将其集成到 Program.cs 中。我的项目结构如下

image

Helpers 文件夹

包含各种辅助类。ConfigHelper.cs 是一个提供者类，旨在通过依赖注入 (DI) 促进 DbContext 和其他服务的添加。

using JWTAuth.Extensions;
using JWTAuth.Services;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;

namespace JWTAuth.Helpers
{
    public class ConfigHelper
    {
        public static void ConfigureService(WebApplicationBuilder builder)
        {
            var serviceProvider = builder.Services.AddOptions().Configure<AppSettings>
            (builder.Configuration.GetSection("AppSettings")).BuildServiceProvider();

            // Set the value in AppSettings
            var appSettings = serviceProvider.GetRequiredService
                                <IOptions<AppSettings>>().Value;

            // Add your DbContext and other services here
            builder.Services.AddDbContext<AuthorizeContexts>(options =>
                            options.UseNpgsql(appSettings.ConnectionString));

            builder.Services.AddScoped
                    <IConnectionStringProvider, ConnectionStringProvider>();

            serviceProvider.Dispose();
            PostgreSqlBootstrap.Initialize();

            // After the creation of SurveyRepo in the DataLayer project, 
            // it is essential to add this line
            builder.Services.AddScoped<ISurveyRepo, SurveyRepo>();
            builder.Services.UseOneTransactionPerHttpCall(appSettings);
        }
    }
}

Services 文件夹

包含解决方案中所有自定义服务，用于依赖注入 (DI)。

IConnectionStringProvider.cs

namespace JWTAuth.Services
{
    public interface IConnectionStringProvider
    {
        string GetConnectionString();
    }
}

ConnectionStringProvider.cs

namespace JWTAuth.Services
{
    public class ConnectionStringProvider : IConnectionStringProvider
    {
        private readonly IConfiguration _configuration;

        public ConnectionStringProvider(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        public string GetConnectionString()
        {
            var connectionString = _configuration.GetConnectionString
                                   ("SurveyConnectionString");
            return connectionString;
        }
    }
}

Extensions 文件夹

包含扩展类。ServiceCollectionExtensions.cs。此服务集合的扩展程序管理 PostgreSQL 的每个 HttpCall 的连接和事务状态。

using JWTAuth.Helpers;
using JWTAuth.Services;
using Npgsql;
using System.Data;

namespace JWTAuth.Extensions
{
    public static class ServiceCollectionExtensions
    {
        public static void UseOneTransactionPerHttpCall
        (this IServiceCollection serviceCollection, AppSettings _appSettings, 
         IsolationLevel level = IsolationLevel.ReadUncommitted)
        {
            serviceCollection.AddScoped<IDbTransaction>(serviceProvider =>
            {
                var connectionStringProvider = 
                serviceProvider.GetService<IConnectionStringProvider>();
                var connection = new NpgsqlConnection(_appSettings.ConnectionString);
            
                if (connection.State != ConnectionState.Open)
                    connection.Open();
            
                return connection.BeginTransaction(level);
            });
            
            serviceCollection.AddScoped(typeof(UnitOfWorkFilter), 
                                        typeof(UnitOfWorkFilter));
            
            serviceCollection.AddMvc(setup =>
            {
                setup.Filters.AddService<UnitOfWorkFilter>(1);
            });
        }
    }
}

在 Program.cs 中调用 ConfigHelper.ConfigureService(builder)

var builder = WebApplication.CreateBuilder(args);
ConfigHelper.ConfigureService(builder);

JWTAuth.Common 项目

此外，我们还需要一个 AppSettings.cs 文件，我们将将其放置在一个名为 JWTAuth.Common 的新类库项目中。该项目是所有通用类的存储库。

Helpers 文件夹

包含各种辅助类。AppSettings.cs。此实体充当在整个解决方案中携带配置信息的容器。

namespace JWTAuth.Common.Helper
{
    public class AppSettings
    {
        // Define your application settings properties here
        public string ConnectionString { get; set; }
        // ... other settings
    }
}

现在是时候将身份验证实体迁移到 PostgreSQL 并生成相应的表了。您可以选择使用 **Package Manager Console** 或 **Developer PowerShell**。要继续，请右键单击目标项目并选择 **Open Terminal** 选项。

可以通过执行以下命令来启动迁移

dotnet ef migrations add 'AuthFirstMigration'

image

执行此命令后，系统将在 JWTAuth 项目中生成一个 Migrations 文件夹，其中包含必要的迁移类。

image

通过使用以下命令，我们将创建包含身份验证表的数据库，该数据库位于 PostgreSQL 中。

dotnet ef database update -c AuthorizeContexts

如前所述，我打算为我的 DataLayer 创建一个类库项目，其中包含主要的实体、Context 和存储库。因此，我将在该项目中生成“**Survey Entity**”和其他相关元素。随后，我将采用与迁移身份验证实体到 PostgreSQL 数据库所使用的技术类似的技术。

揭秘 JWT 配置和使用

为了实现 JWT，第一步是在 appsettings.json 文件中添加 JWTSecurityToken，如下图所示

"JwtSecurityToken": {
    "Key": "K17T6p+mYlBuIll6EOQDUmAdM6xmzeHOpE+O35zsAvw=",
    "Issuer": "JWTAuthServer",
    "Audience": "JWTAuthClient",
    "Subject": "JWTAuthToken"
  },

JwtSecurityToken 配置的 Key 属性中使用的密钥应该是用于签名 JWT Token 的一个对称密钥。此对称密钥应保密，不得与他人共享。您使用的密钥类型取决于您选择的 Token 签名算法。JWT 支持不同的 Token 签名算法，包括对称算法和非对称算法。

  1. 对称密钥（本文中我们将使用对称密钥）
  2. 非对称密钥对

生成对称密钥

有几种方法可以生成对称密钥。您可以选择使用 Key 属性的现有值，或者用您自己的新密钥值替换它。如果您决定生成自定义密钥，则有多种技术可供您采用。让我们探讨其中的一些方法。对称密钥是用于签名和验证 Token 的单个对称密钥。它是 Token 发行者（服务器）和 Token 消费者（客户端）之间的共享密钥。常见的对称算法包括 HMAC SHA-256（HmacSha256）和 HMAC SHA-512（HmacSha512）。对称密钥通常比非对称密钥短，从而减小了 Token 的大小。

  • 生成随机对称密钥的简单方法：Convert.ToBase64String(Guid.NewGuid().ToByteArray())
  • 要生成用于 HMAC SHA-256 的对称密钥，您可以创建一个随机字节数组，然后将其编码为 Base64 字符串。这是一个简单的 C# 示例
using System;
using System.Security.Cryptography;
public static class JWTGenerator
{
    public static string Generate()
    {
        byte[] keyBytes = GenerateRandomKey();
        string base64Key = Convert.ToBase64String(keyBytes);

        return base64Key;
    }

    static byte[] GenerateRandomKey()
    {
        using (var hmac = new HMACSHA256())
        {
            return hmac.Key;
        }
    }
}
  • 使用 OpenSSL 生成新密钥 如果您使用的是 Windows 并且未安装 OpenSSL，则有几种选择
  • 使用在线工具：如果您只需要生成一次随机密钥，并且不想安装 OpenSSL，则可以使用在线工具生成 Base64 格式的随机密钥。
  • 使用 PowerShell 生成密钥：如果您更喜欢使用 PowerShell，可以使用以下方式生成随机密钥

我已在我的计算机上成功安装了 OpenSSL，并将其安装路径添加到操作系统 **System Variables** 的 **Path** 中作为新的路径。

有了此配置，您就可以在 **Windows Power Shell** 或 **Command Prompt** 中使用以下命令等命令，随时轻松生成新的加密密钥。

Windows Power Shell

image

Command Prompt

image

通过使用 OpenSSL，您可以生成各种类型的加密密钥。您可以选择任何首选方法来生成新的加密密钥。您只需将代码中的值替换为 appsettings.json 文件中 JwtSecurityToken 的 Key 属性的值。

设置 JWT

为了设置并有效使用 JWT，在 RESTful API 项目中安装以下 NuGet 程序包是必不可少的

  • Microsoft.AspNetCore.Authentication.JwtBearer
  • Microsoft.IdentityModel.Tokens
  • System.IdentityModel.Tokens.Jwt

现在，为了实现我的目标，配置 Authentication 和 JwtBearer 属性，我创建了一个单独的 static 类，其中包含必要的代码块。然后，此代码块在 Program.cs 文件中被调用以执行所需的设置。

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;

namespace JWTAuth.Helpers
{
    public class AuthenticationHelper
    {
        public static void ConfigureService(WebApplicationBuilder builder)
        {
            builder.Services.AddAuthentication(optiones =>
            {
                optiones.DefaultAuthenticateScheme = 
                         JwtBearerDefaults.AuthenticationScheme;
                optiones.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
                optiones.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
            })
            .AddJwtBearer(o =>
            {
                o.TokenValidationParameters = new TokenValidationParameters
                {
                    ValidAudience = builder.Configuration["JwtSecurityToken:Audience"],
                    ValidIssuer = builder.Configuration["JwtSecurityToken:Issuer"],
                    IssuerSigningKey = new SymmetricSecurityKey
                    (Encoding.UTF8.GetBytes(builder.Configuration["JwtSecurityToken:Key"])),
                    ValidateIssuer = true,
                    ValidateAudience = true,
                    ValidateIssuerSigningKey = true,
                    ValidateLifetime = true,
                    ClockSkew = TimeSpan.Zero,
                };
            });
        }
    }
}

在 Program.cs 文件中，我添加了以下代码行

AuthenticationHelper.ConfigureService(builder);

此代码行对于调用身份验证服务的配置设置至关重要，可确保正确实施必要的身份验证和授权配置。

此外，我还包含了自定义的 Swagger 配置类。这确保了 Swagger 文档和功能在项目中的无缝集成，同时还添加了安全要求，以增强其可访问性和可用性。

using Microsoft.OpenApi.Models;

namespace JWTAuth.Helpers
{
    public class SwaggerHelper
    {
        public static void ConfigureService(IServiceCollection service)
        {
            service.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo 
                            { Title = "WebAPIv7", Version = "v1" });
                c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
                {
                    Description =
                        "JWT Authorization header using the Bearer scheme. 
                         \r\n\r\n Enter 'Bearer' [space] and then your token in the 
                         text input below.\r\n\r\nExample: \"Bearer 12345abcdef\"",
                    Name = "Authorization",
                    In = ParameterLocation.Header,
                    Type = SecuritySchemeType.ApiKey,
                    Scheme = "Bearer"
                });

                c.AddSecurityRequirement(new OpenApiSecurityRequirement()
                {
                    {
                        new OpenApiSecurityScheme
                        {
                            Reference = new OpenApiReference
                            {
                                Type = ReferenceType.SecurityScheme,
                                Id = "Bearer"
                            },
                            Scheme = "oauth2",
                            Name = "Bearer",
                            In = ParameterLocation.Header,

                        },
                        new List<string>()
                    }
                });
            });
        }
    }
}

在 Program.cs 文件中，我添加了以下代码行

AuthenticationHelper.ConfigureService(builder);
SwaggerHelper.ConfigureService(builder.Services);
builder.Services.Configure<JwtSecurityTokenSettings>
        (builder.Configuration.GetSection("JwtSecurityToken"));

控制器

完成设置和配置要求后，我的下一步是创建 JWTokenController。此控制器将负责根据 appsetting.json 文件中提供的信息和登录凭据生成 Token。此类代码实现可能类似于下面的示例，或者根据特定要求，也可以使用其他方法来实现。

using JWTAuth.Authorization.Model.Entities;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

namespace JWTAuth.Controllers
{
    [Route("api/token")]
    [ApiController]
    public class JWTokenController : Controller
    {
        public IConfiguration _configuration;
        private readonly AuthorizeContexts _context;

        public JWTokenController(IConfiguration config, AuthorizeContexts context)
        {
            _configuration = config;
            _context = context;
        }

        [HttpPost]
        public async Task<IActionResult> Post(User _userData)
        {
            if (_userData != null && _userData.Username != null && 
                _userData.Password != null)
            {
                var user = await GetUser(_userData.Username, _userData.Password);

                if (user != null)
                {

                    var nowUtc = DateTime.UtcNow;
                    var expirationDuration = 
                        TimeSpan.FromMinutes(10); // Adjust as needed
                    var expirationUtc = nowUtc.Add(expirationDuration);

                    var claims = new List<Claim>
                    {
                        new Claim(JwtRegisteredClaimNames.Sub, 
                                  _configuration["JwtSecurityToken:Subject"]),
                        new Claim(JwtRegisteredClaimNames.Jti, 
                                  Guid.NewGuid().ToString()),
                        new Claim(JwtRegisteredClaimNames.Iat, 
                                  EpochTime.GetIntDate(nowUtc).ToString(), 
                                  ClaimValueTypes.Integer64),
                        new Claim(JwtRegisteredClaimNames.Exp, 
                                  EpochTime.GetIntDate(expirationUtc).ToString(), 
                                  ClaimValueTypes.Integer64),
                        new Claim(JwtRegisteredClaimNames.Iss, 
                                  _configuration["JwtSecurityToken:Issuer"]),
                        new Claim(JwtRegisteredClaimNames.Aud, 
                                  _configuration["JwtSecurityToken:Audience"]),
                        new Claim("UserId", user.UserId.ToString()),
                        new Claim("Username", user.Username)
                    };

                    var key = new SymmetricSecurityKey
                    (Encoding.UTF8.GetBytes(_configuration["JwtSecurityToken:Key"]));
                    var signIn = new SigningCredentials
                                 (key, SecurityAlgorithms.HmacSha256);

                    var token = new JwtSecurityToken(
                        issuer: _configuration["JwtSecurityToken:Issuer"],
                        audience: _configuration["JwtSecurityToken:Audience"],
                        claims: claims,
                        expires: expirationUtc,
                        signingCredentials: signIn);

                    var tokenHandler = new JwtSecurityTokenHandler();
                    var tokenString = tokenHandler.WriteToken(token);

                    return Ok(tokenString);
                }
                else
                {
                    return BadRequest("Invalid credentials");
                }
            }
            else
            {
                return BadRequest();
            }
        }

        private async Task<User> GetUser(string userName, string password)
        {
            return await _context.Users.FirstOrDefaultAsync
                   (u => u.Username == userName && u.Password == password);
        }
    }
}

此外，我正在创建 SurveyController。此控制器旨在方便测试我们既定的目标。为确保对其成员的受控访问，必须在控制器上方放置 [Authorize] 属性。此步骤在授予访问权限之前会验证 Token 的有效性。

using JWTAuth.Data.Repositories.GeneralRepositories;
using JWTAuth.Data.Repositories;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Authorization;
using JWTAuth.Data.Entities;

namespace JWTAuth.Controllers
{
    [Authorize]
    [Route("api/[controller]")]
    [ApiController]
    public class SurveyController : Controller
    {
        private readonly ISurveyRepo _surveyRepo;
        private readonly ILogger<SurveyController> _logger;
        private readonly UnitOfWorkFilter _uow;


        public SurveyController(ILogger<SurveyController> logger,
                                UnitOfWorkFilter unitOfWork,
                                ISurveyRepo surveyRepo)
        {
            _logger = logger;
            _uow = unitOfWork;
            _surveyRepo = surveyRepo;
        }

        // GET ALL: api/<SurveyController>
        [HttpGet]
        public async Task<IEnumerable<Survey>?> GetAll()
        {
            var surveys = await _surveyRepo.GetAllAsync();
            return surveys;
        }
        
        // GET api/<SurveyController>/5
        [HttpGet("{id}")]
        public async Task<Survey?> Get(int id)
        {
            var survey = await _surveyRepo.GetAsync(1);
            return survey;
        }
   }
}

生成解决方案并运行 JWTAuth RESTful API 项目。如图片所示，Swagger 显示如下

image

如果您在生成有效 Token 的情况下尝试访问此页面中的方法，将会遇到未经授权的错误。此安全措施确保只有授权用户才能与 Survey 的方法进行交互。

image

我复制了生成的 Token，并将其输入到通过单击 **Authorize** 按钮访问的弹出页面中的指定输入区域。

image

image

单击 **Authorize** 按钮，然后关闭弹出窗口。

现在，您可以尝试执行 SurveyController 中的方法。通过单击相应的 SurveyController 方法，如果您的 Token 有效，该方法将返回预期的结果值。反之，如果 Token 无效，则会遇到 Unauthorized 错误。

image

在某些情况下，即使在 Swagger 页面上仔细完成了所有必需的步骤，包括在授权段中生成 Token，在执行 Get/Post 程序时仍可能出现意外的障碍。此时，程序会尝试验证 Token，但却遇到异常，这在后续图片中有所体现。

image

在某些情况下，缺少一个关键元素：System.IdentityModel.Tokens.Jwt NuGet 包。令人惊讶的是，尽管编译和执行过程流畅，但 API 测试阶段却出现了“无效 Token”错误这一重大障碍。令人惊讶的是，仅仅安装 System.IdentityModel.Tokens.Jwt 包就使解决方案焕发生机，无需对代码库进行任何修改即可无缝地解决问题。您还可以参考以下链接获取更多信息。

总而言之，我诚挚地感谢每一位尊贵的读者抽出宝贵时间深入探讨在 ASP.NET Core 中使用 RESTful API 实现 JWT 的复杂性。愿您所面临的挑战都能得到勇敢的面对，愿您所克服的障碍都能得到坚定的决心，愿您所取得的成功都能带来成就感。在您的努力中，愿您找到通往目标的道路光芒四射，愿您继续追求卓越。感谢您参与本次讨论，我谨向您致以最美好的祝愿，祝您未来的所有事业都取得圆满成功。

© . All rights reserved.