如何在.net6webapi中配置Jwt实现鉴权验证

Posted SaoJian

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了如何在.net6webapi中配置Jwt实现鉴权验证相关的知识，希望对你有一定的参考价值。

JWT（Json Web Token）

jwt是一种用于身份验证的开放标准，他可以在网络之间传递信息，jwt由三部分组成：头部，载荷，签名。头部包含了令牌的类型和加密算法，载荷包含了用户的信息，签名则是对头部和载荷的加密结果。

jwt鉴权验证是指在用户登录成功后，服务器生成一个jwt令牌并返回给客户端，客户端在后续的请求中携带该令牌，服务通过令牌的签名来确定用户的身份和权限。这种方式可以避免在每个请求中都需要进行身份验证，提高了系统的性能和安全性。

jwt具有以下优点：

1.无状态：jwt令牌包含了所有必要的信息，服务器不需要再每个请求中都进行身份验证，避免了服务器存储会话信息的开销。

2.可扩展性：jwt令牌可以包含任意的信息，可以根据需要添加自定义的字段。

3.安全性：jwt令牌使用签名来保证数据的完整性和真实性，防止数据被篡改或伪造。

4.跨平台：jwt令牌是基于json格式的，可以再不同的变成语言和平台之间进行传递和解析。

如何在webapi中使用JWT？

1.首先在项目中添加如下两个包

dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer
dotnet add package System.IdentityModel.Tokens.Jwt

也可以直接在Nuget包管理工具中搜索

2.创建JwtOptions模型类，同时在appsetting.json中添加对应配置

    public class JwtOptions
    
        /// <summary>
        /// 签发者
        /// </summary>
        public string Issuer  get; set; 

        /// <summary>
        /// 接收者
        /// </summary>
        public string Audience  get; set; 

        /// <summary>
        /// 密钥
        /// </summary>
        public string Key  get; set; 

        /// <summary>
        /// 过期时间
        /// </summary>
        public int ExpireSeconds  get; set; 
    
  "JWT": 
    "Issuer": "签发方",
    "Audience": "接受方",
    "Key": "A86DA130-1B95-4748-B3B2-1B6AA9F2F743",//加密密钥
    "ExpireSeconds": 600 //密钥过期时间

3.创建JWTExtensions静态类，添加AddJWTAuthentication扩展方法

    public static class JWTExtensions
    
        public static AuthenticationBuilder AddJWTAuthentication(this IServiceCollection services, JwtOptions jwtOptions)
        
            return services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
                .AddJwtBearer(x =>
                
                    x.TokenValidationParameters = new()
                    
                        ValidateIssuer = true,//是否验证发行商
                        ValidateAudience = true,//是否验证受众者
                        ValidateLifetime = true,//是否验证失效时间
                        ValidateIssuerSigningKey = true,//是否验证签名键
                        ValidIssuer = jwtOptions.Issuer,
                        ValidAudience = jwtOptions.Audience,
                        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtOptions.Key))
                    ;
                );

4.创建SwaggerGenOptionsExtensions静态类，添加AddAuthenticationHeader扩展方法，为swagger增加Authentication报文头

 

    public static class SwaggerGenOptionsExtensions
    
        /// <summary>
        /// 为swagger增加Authentication报文头
        /// </summary>
        /// <param name="option"></param>
        public static void AddAuthenticationHeader(this SwaggerGenOptions option)
        
            option.AddSecurityDefinition("Authorization",
                new OpenApiSecurityScheme
                
                    Description = "Authorization header. \\r\\nExample:Bearer 12345ABCDE",
                    Name = "Authorization",
                    In = ParameterLocation.Header,
                    Type = SecuritySchemeType.ApiKey,
                    Scheme = "Authorization"
                
                ); ;

            option.AddSecurityRequirement(new OpenApiSecurityRequirement()
            
                
                    new OpenApiSecurityScheme
                    
                        Reference=new OpenApiReference
                        
                            Type=ReferenceType.SecurityScheme,
                            Id="Authorization"
                        ,
                        Scheme="oauth2",
                        Name="Authorization",
                        In=ParameterLocation.Header,
                    ,
                    new List<string>()
                
            );

5.创建IJwtService接口及实现JwtService类，其为构建token服务

    public interface IJwtService
    
        string BuildToken(IEnumerable<Claim> claims, JwtOptions options);
    
    public class JwtService : IJwtService
    
        public string BuildToken(IEnumerable<Claim> claims, JwtOptions options)
        
            //过期时间
            TimeSpan timeSpan = TimeSpan.FromSeconds(options.ExpireSeconds);//token过期时间
            var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(options.Key));//加密的token密钥
            var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256Signature);//签名证书，其值为securityKey和HmacSha256Signature算法
            var tokenDescriptor = new JwtSecurityToken(options.Issuer, options.Audience, claims, expires: DateTime.Now.Add(timeSpan), signingCredentials: credentials);//表示jwt token的描述信息，其值包括Issuer签发方，Audience接收方，Claims载荷，过期时间和签名证书
            return new JwtSecurityTokenHandler().WriteToken(tokenDescriptor);//使用该方法转换为字符串形式的jwt token返回

6.将上述服务尽数注册

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddScoped<IJwtService, JwtService>();
JwtOptions jwtOpt = builder.Configuration.GetSection("JWT").Get<JwtOptions>();
builder.Services.AddJWTAuthentication(jwtOpt);
builder.Services.Configure<SwaggerGenOptions>(c =>

    c.AddAuthenticationHeader();
);

var app = builder.Build();
app.UseSwagger();
app.UseSwaggerUI();
app.UseHttpsRedirection();
app.UseAuthentication();//注意，一定得先启动这个
app.UseAuthorization();
//以下回答来自GPT
//app.UseAuthentication()是启用身份验证中间件，它会验证请求中的身份信息，并将身份信息存储在HttpContext.User属性中。而app.UseAuthorization()是启用授权中间件，它会检查HttpContext.User中的身份信息是否有访问当前请求所需的权限。
//一定要先启用身份验证中间件再启用授权中间件，因为授权中间件需要使用身份验证中间件存储的身份信息来进行权限验证。如果没有启用身份验证中间件，授权中间件将无法获取到身份信息，从而无法进行权限验证。
app.MapControllers();
app.Run();

7.在控制器中添加[ApiController]特性开启jwt鉴权，在登录接口中返回token

    [ApiController]
    [Route("[controller]/[action]")]
    [Authorize]
    public class WeatherForecastController : ControllerBase
    
        private static readonly string[] Summaries = new[]
        
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    ;

        private readonly ILogger<WeatherForecastController> _logger;
        //jwt服务

        private readonly IJwtService _jwtService;

        private readonly IConfiguration _configuration;

        public WeatherForecastController(ILogger<WeatherForecastController> logger, IJwtService jwtService, IConfiguration configuration)
        
            _logger = logger;
            _jwtService = jwtService;
            _configuration = configuration;
        

        [HttpGet]
        public IEnumerable<WeatherForecast> Get()
        
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
            )
            .ToArray();
        

        //AllowAnonymous允许匿名访问
        [AllowAnonymous, HttpGet]
        public string GetToken()
        
            var jwtopntion = _configuration.GetSection("JWT").Get<JwtOptions>();
            List<Claim> claims = new List<Claim>();
            claims.Add(new Claim(ClaimTypes.Name, "用户1"));
            claims.Add(new Claim(ClaimTypes.Role, "超级管理员"));
            return _jwtService.BuildToken(claims, jwtopntion);

效果测试

 

直接调用Get方法返回401，鉴权失败

 

 调用GetToken方法，取得token

 点击右上角绿色按钮

 value中输入的值为bearer，空一格，加上之前取得的token，点击授权

 调用成功

JWT鉴权如何来写一个token令牌认证登录？

目录

一. 🦁 话题引入

在做项目过程中，我们一般都是最先编写登录注册功能，登录功能最重要的是登录成功后，系统还会保存该登录用户信息，这种保存用户信息的逻辑可以有两种：

  1. 最简单的一种就是使用Session来保存用户信息，然后使用filter来验证用户是否登录，但是这种方法只能是单体架构的项目适用，性能也不会很好。在分布式项目中，会有很多子模块并且部署在不同的服务器中，这样是无法使用session保存的，因为sessio不能共享。
  2. 使用单点登录技术就能很好地解决这个弊端。
  • 单点登录（Single Sign On）简称为 SSO。即在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。JWT是一种常用的单点登录解决方案。

1.2 什么是JWT？

JWT是Json Web Token的简称，是一种令牌生成算法。使用JWT能够保证Token的安全性，且能够进行Token时效性的检验。使用JWT时，登录成功后将用户信息生成一串令牌字符串。将该字符串返回给客户端，客户端每次请求时都在请求头携带该令牌字符串。在其他模块验证令牌，通过则证明用户处于登录状态，并拿到解析后的用户信息，未通过证明用户处于未登录状态。

二. 🦁 技术体现

要实现JWT鉴权，就得实现如下步骤：

  • 引入JWT工具类，编写生成令牌和解析令牌的方法。
  • 用户登录成功后生成令牌字符串返回给前端。
  • 前端每次请求时都在请求头带入令牌字符串。
  • 在通用模块编写拦截器，解析请求头中的令牌字符串。
  • 在Api模块配置拦截器，配置拦截器拦截哪些接口，即这些接口需要登录才能访问。

现在来编写代码实现

2.1 引入依赖

<dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.4.0</version>
        </dependency>

2.2 编写JWT工具类

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.Claim;
import com.itbaizhan.shopping_common.exception.BusException;
import com.itbaizhan.shopping_common.pojo.ShoppingUser;
import com.itbaizhan.shopping_common.result.CodeEnum;

import java.util.Date;

public class JWTUtil 
    //token过期时间，一天
    private static final Long EXPIRE_DATE = 1000*60*60*24L;
    // 秘钥
    private static final String SECRET = "jackie";
    // 签发者
    private static final String ISSUER = "JACKIE";

    /**
     * 签名生成
     * @param shoppingUser
     * @return
     */
    public static String sign(ShoppingUser shoppingUser)
        String token = JWT.create()
                .withIssuer(ISSUER) // 签发者
                .withIssuedAt(new Date()) // 签发时间
                .withExpiresAt(new Date(new Date().getTime() + EXPIRE_DATE)) // 过期时间
                .withSubject(shoppingUser.getUsername()) // 保存用户名
                .withClaim("userId",shoppingUser.getId()) // 保存用户id
                .sign(Algorithm.HMAC256(SECRET)); // 秘钥
        return token;
    

    /**
     * 签名解析
     * @param token 签名字符串
     * @return 解析得出的用户名
     */
    public static String verify(String token)
        try 
            String username = JWT
                    .require(Algorithm.HMAC256(SECRET))
                    .withIssuer(ISSUER)
                    .build()
                    .verify(token)
                    .getSubject();
            return username;
         catch (Exception e)
            throw new BusException(CodeEnum.VERIFY_TOKEN_ERROR);
        
    

    /**
     * 签名解析，获取用户id
     * @param token 签名字符串
     * @return 用户id
     */
    public static Long getId(String token)
        try 
            Long userId = JWT
                    .require(Algorithm.HMAC256(SECRET))
                    .withIssuer(ISSUER)
                    .build()
                    .verify(token)
                    .getClaim("userId")
                    .asLong();
            return userId;
         catch (Exception e)
            throw new BusException(CodeEnum.VERIFY_TOKEN_ERROR);

这个utils有三个方法，一个是生成token字符串，一个是解析该字符串获取登录的用户名，还要就是获取登录用户的id。

2.3 编写登录方法

如果使用Session存储用户信息，在验证完名字和密码后，直接将该登录对象setAttribute(“users”,users)里面。

而使用单点登录，则是直接调用JWTUtil.sign(user)，生成JWT令牌，返回该令牌给前端用户。
标准代码：

服务层:

 @Override
    public String loginPassword(String username, String password) 
        // 1.验证用户名
        QueryWrapper<ShoppingUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("username",username);
        ShoppingUser shoppingUser = shoppingUserMapper.selectOne(queryWrapper);
        if (shoppingUser == null)
            throw new BusException(CodeEnum.LOGIN_NAME_PASSWORD_ERROR);
        
        // 2.验证密码
        boolean verify = Md5Util.verify(password, shoppingUser.getPassword());
        if (!verify)
            throw new BusException(CodeEnum.LOGIN_NAME_PASSWORD_ERROR);
        
        // 3.生成JWT令牌，返回令牌
        String sign = JWTUtil.sign(shoppingUser);
        return sign;

控制层：

 /**
     * 用户名密码登录
     * @param shoppingUser 用户对象
     * @return 登录结果
     */
    @PostMapping("/loginPassword")
    public BaseResult loginPassword(@RequestBody ShoppingUser shoppingUser)
        String sign = shoppingUserService.loginPassword(shoppingUser.getUsername(), shoppingUser.getPassword());
        return BaseResult.ok(sign);

2.4 编写JWT拦截器验证令牌

这里验证令牌的方式是拦截所有的请求，如果 JWTUtil.verify(token)不抛异常则通过这个请求。

// 拦截器，验证令牌
public class JWTInterceptor implements HandlerInterceptor 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception 
        // 获取请求头中的token
        String token = request.getHeader("token");
        // 验证令牌
        JWTUtil.verify(token);
        return true;

2.5 编写要配置拦截的接口

我们在用户模块配置该模块要拦截的接口（如果是单体架构，拦截器和该部分可以写在一起）。

除了这种方式，还有一种编写方式，你想知道吗？

在User模块先实例化一个InterceptorConfig配置类，实现WebMvcConfigurer接口，将上面写的拦截器在addInterceptor(new JWTInterceptor())方法里面实例化，然后拦截所有的接口（ .addPathPatterns(“/**”)），再放行不需要认证的接口。

// 拦截器配置
@Configuration
public class InterceptorConfig implements WebMvcConfigurer 
    @Override
    public void addInterceptors(InterceptorRegistry registry) 
        registry.addInterceptor(new JWTInterceptor())
                .addPathPatterns("/**") // 拦截的接口
                .excludePathPatterns(
                       "填写需要放行的接口url"
                ); //放行的接口

至此，一个令牌认证就完成啦。

三. 🦁 话题终结

又一篇业务逻辑类的文章表述，希望路过的您看到了觉得还行，给个三连哦 🌹。

以上是关于如何在.net6webapi中配置Jwt实现鉴权验证的主要内容，如果未能解决你的问题，请参考以下文章

security + oauth2 + jwt + gateway 实现统一身份认证和鉴权（基础）

JWT鉴权如何来写一个token令牌认证登录？

实现JWT鉴权机制

SpringCloud系列之网关gateway-12.实现JWT鉴权

鉴权/授权基于角色的简单授权认证

用户登录鉴权JWT代码实现