asp.net core 2.0 web api基于JWT自定义策略授权

最新推荐文章于 2024-10-14 19:05:40 发布
最新推荐文章于 2024-10-14 19:05:40 发布
阅读量280 收藏
点赞数
原文链接：https://blog.51cto.com/axzxs/1965822?source=drh
版权

源码如下：

JwtToken.cs

    /// <summary>
    /// 获取基于JWT的Token
    /// </summary>
    /// <param name="username"></param>
    /// <returns></returns>
    public static dynamic BuildJwtToken(Claim[] claims, PermissionRequirement permissionRequirement)
    {
        var now = DateTime.UtcNow;
        var jwt = new JwtSecurityToken(
            issuer: permissionRequirement.Issuer,
            audience: permissionRequirement.Audience,
            claims: claims,
            notBefore: now,
            expires: now.Add(permissionRequirement.Expiration),
            signingCredentials: permissionRequirement.SigningCredentials
        );
        var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
        var response = new
        {
            Status = true,
            access_token = encodedJwt,
            expires_in = permissionRequirement.Expiration.TotalMilliseconds,
            token_type = "Bearer"
        };
        return response;
    }

Permission.cs

/// <summary>
/// 用户或角色或其他凭据实体
/// </summary>
public class Permission
{
    /// <summary>
    /// 用户或角色或其他凭据名称
    /// </summary>
    public virtual string Name
    { get; set; }
    /// <summary>
    /// 请求Url
    /// </summary>
    public virtual string Url
    { get; set; }
}

PermissionRequirement.cs

/// <summary>
/// 必要参数类
/// </summary>
public class PermissionRequirement : IAuthorizationRequirement
{
    /// <summary>
    /// 用户权限集合
    /// </summary>
    public List<Permission> Permissions { get; private set; }
    /// <summary>
    /// 无权限action
    /// </summary>
    public string DeniedAction { get; set; }
    /// <summary>
    /// 认证授权类型
    /// </summary>
    public string ClaimType { internal get; set; }
    /// <summary>
    /// 请求路径
    /// </summary>
    public string LoginPath { get; set; } = "/Api/Login";
    /// <summary>
    /// 发行人
    /// </summary>
    public string Issuer { get; set; }
    /// <summary>
    /// 订阅人
    /// </summary>
    public string Audience { get; set; }
    /// <summary>
    /// 过期时间
    /// </summary>
    public TimeSpan Expiration { get; set; } = TimeSpan.FromMinutes(5000);
    /// <summary>
    /// 签名验证
    /// </summary>
    public SigningCredentials SigningCredentials { get; set; }
    /// <summary>
    /// 构造
    /// </summary>
    /// <param name="deniedAction">无权限action</param>
    /// <param name="userPermissions">用户权限集合</param>
    /// <summary>
    /// 构造
    /// </summary>
    /// <param name="deniedAction">拒约请求的url</param>
    /// <param name="permissions">权限集合</param>
    /// <param name="claimType">声明类型</param>
    /// <param name="issuer">发行人</param>
    /// <param name="audience">订阅人</param>
    /// <param name="signingCredentials">签名验证实体</param>
    public PermissionRequirement(string deniedAction, List<Permission> permissions, string claimType, string issuer, string audience, SigningCredentials signingCredentials)
    {
        ClaimType = claimType;
        DeniedAction = deniedAction;
        Permissions = permissions;
        Issuer = issuer;
        Audience = audience;
        SigningCredentials = signingCredentials;
    }
}

自定义策略类PermissionHandler.cs

/// <summary>
/// 权限授权Handler
/// </summary>
public class PermissionHandler : AuthorizationHandler<PermissionRequirement>
{    
    /// <summary>
    /// 验证方案提供对象
    /// </summary>
    public IAuthenticationSchemeProvider Schemes { get; set; }
    /// <summary>
    /// 自定义策略参数
    /// </summary>
    public PermissionRequirement Requirement
    { get; set; }
    /// <summary>
    /// 构造
    /// </summary>
    /// <param name="schemes"></param>
    public PermissionHandler(IAuthenticationSchemeProvider schemes)
    {
        Schemes = schemes;
    }  
    protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, PermissionRequirement requirement)
    {
        赋值用户权限       
        Requirement = requirement;
        //从AuthorizationHandlerContext转成HttpContext，以便取出表求信息
        var httpContext = (context.Resource as Microsoft.AspNetCore.Mvc.Filters.AuthorizationFilterContext).HttpContext;
        //请求Url
        var questUrl = httpContext.Request.Path.Value.ToLower();  
        //判断请求是否停止
        var handlers = httpContext.RequestServices.GetRequiredService<IAuthenticationHandlerProvider>();
        foreach (var scheme in await Schemes.GetRequestHandlerSchemesAsync())
        {
            var handler = await handlers.GetHandlerAsync(httpContext, scheme.Name) as IAuthenticationRequestHandler;
            if (handler != null && await handler.HandleRequestAsync())
            {
                context.Fail();
                return;
            }
        }
        //判断请求是否拥有凭据，即有没有登录
        var defaultAuthenticate = await Schemes.GetDefaultAuthenticateSchemeAsync();
        if (defaultAuthenticate != null)
        {
            var result = await httpContext.AuthenticateAsync(defaultAuthenticate.Name);
            //result?.Principal不为空即登录成功
            if (result?.Principal != null)
            {
                httpContext.User = result.Principal;
                //权限中是否存在请求的url
                if (Requirement.Permissions.GroupBy(g => g.Url).Where(w => w.Key.ToLower() == questUrl).Count() > 0)
                {
                    var name = httpContext.User.Claims.SingleOrDefault(s => s.Type == requirement.ClaimType).Value;
                    //验证权限
                    if (Requirement.Permissions.Where(w => w.Name == name && w.Url.ToLower() == questUrl).Count() <= 0)
                    {
                        //无权限跳转到拒绝页面
                        httpContext.Response.Redirect(requirement.DeniedAction);
                    }
                }
                context.Succeed(requirement);
                return;
            }
        }
        //判断没有登录时，是否访问登录的url,并且是Post请求，并助是form表单提交类型，否则为失败
        if (!questUrl.Equals(Requirement.LoginPath.ToLower(), StringComparison.Ordinal) && (!httpContext.Request.Method.Equals("POST")
           || !httpContext.Request.HasFormContentType))
        {
            context.Fail();
            return;
        }
        context.Succeed(requirement);     
    }
}

先设置配置文件，用户可以定义密匙和发生人，订阅人

“Audience”: {

"Secret": "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890",

"Issuer": "gsw",

"Audience": "everone"

}

在ConfigureServices中注入验证（Authentication），授权（Authorization），和JWT(JwtBearer)

Startup.cs

    public void ConfigureServices(IServiceCollection services)
    {
        //读取配置文件
        var audienceConfig = Configuration.GetSection("Audience");
        var symmetricKeyAsBase64 = audienceConfig["Secret"];
        var keyByteArray = Encoding.ASCII.GetBytes(symmetricKeyAsBase64);
        var signingKey = new SymmetricSecurityKey(keyByteArray);
        var tokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = signingKey,
            ValidateIssuer = true,
            ValidIssuer = audienceConfig["Issuer"],
            ValidateAudience = true,
            ValidAudience = audienceConfig["Audience"],
            ValidateLifetime = true,
            ClockSkew = TimeSpan.Zero
        };
        var signingCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256);
        services.AddAuthorization(options =>
        {
            //这个集合模拟用户权限表,可从数据库中查询出来
            var permission = new List<Permission> {
                          new Permission {  Url="/", Name="admin"},
                          new Permission {  Url="/api/values", Name="admin"},
                          new Permission {  Url="/", Name="system"},
                          new Permission {  Url="/api/values1", Name="system"}
                      };
            //如果第三个参数，是ClaimTypes.Role，上面集合的每个元素的Name为角色名称，如果ClaimTypes.Name，即上面集合的每个元素的Name为用户名
            var permissionRequirement = new PermissionRequirement("/api/denied", permission, ClaimTypes.Role, audienceConfig["Issuer"], audienceConfig["Audience"], signingCredentials);
            options.AddPolicy("Permission",
                      policy => policy.Requirements.Add(permissionRequirement));
        }).AddAuthentication(options =>
        {
            options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
            options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
        })
        .AddJwtBearer(o =>
        {
            //不使用https
            o.RequireHttpsMetadata = false;
            o.TokenValidationParameters = tokenValidationParameters;
        });
        //注入授权Handler
        services.AddSingleton<IAuthorizationHandler, PermissionHandler>();
        services.AddMvc();
    }

在需要授的Controller上添加授权特性

[Authorize("Permission")]

PermissionController类有两个方法，一个是登录，验证用户名和密码是否正确，如果正确就发放Token，如果失败，验证失败，别一个成功登后的无权限导航action。

[Authorize("Permission")]
public class PermissionController : Controller
{
    /// <summary>
    /// 自定义策略参数
    /// </summary>
    PermissionRequirement _requirement;
    public PermissionController(IAuthorizationHandler authorizationHander)
    {
        _requirement = (authorizationHander as PermissionHandler).Requirement;
    }
    [AllowAnonymous]
    [HttpPost("/api/login")]
    public IActionResult Login(string username,string password,string role)
    { 
        var isValidated = username == "gsw" && password == "111111";
        if (!isValidated)
        {
            return new JsonResult(new
            {
                Status = false,
                Message = "认证失败"
            });
        }
        else
        { 
            //如果是基于角色的授权策略，这里要添加用户;如果是基于角色的授权策略，这里要添加角色
            var claims =new Claim[]{ new Claim(ClaimTypes.Name, username),new Claim(ClaimTypes.Role, role) };
            //用户标识
            var identity = new ClaimsIdentity(JwtBearerDefaults.AuthenticationScheme); 
            identity.AddClaims(claims);
            //登录
            HttpContext.SignInAsync(JwtBearerDefaults.AuthenticationScheme, new ClaimsPrincipal(identity));
            var token = JwtToken.BuildJwtToken(claims, _requirement);
            return new JsonResult(token);
        }
    }
    [AllowAnonymous]
    [HttpGet("/api/denied")]
    public IActionResult Denied()
    {
        return new JsonResult(new
        {
            Status = false,
            Message = "你无权限访问"
        });
    }
}

下面定义一个控制台（.NetFramewrok）程序，用RestSharp来访问我们定义的web api，其中1为admin角色登录，2为system角色登录，3为错误用户密码登录，4是一个查询功能，在startup.cs中，admin角色是具有查询/api/values的权限的，所以用admin登录是能正常访问的，用system登录，能成功登录，但没有权限访问/api/values，用户名密码错误，访问/aip/values，直接是没有授权的

class Program
{
///
/// 访问Url
///
static string _url = “http://localhost:39286”;
static void Main(string[] args)
{
dynamic token = null;
while (true)
{
Console.WriteLine("1、登录【admin】 2、登录【system】 3、登录【错误用户名密码】 4、查询数据 ");
var mark = Console.ReadLine();
var stopwatch = new Stopwatch();
stopwatch.Start();
switch (mark)
{
case “1”:
token = AdminLogin();
break;
case “2”:
token = SystemLogin();
break;
case “3”:
token = NullLogin();
break;
case “4”:
AdminInvock(token);
break;
}
stopwatch.Stop();
TimeSpan timespan = stopwatch.Elapsed;
Console.WriteLine(KaTeX parse error: Expected 'EOF', got '}' at position 46: …); }̲ } …“状态：{response.StatusCode} 返回结果：{content}”);
}
}
东莞网站建设www.zg886.cn

ting2909
关注
.NET Core Web API介绍+优缺点
赵玉的专栏
02-26 1459
ASP.NET Core 使用 Kestrel 作为默认的 Web 服务器，它是一个轻量级且高性能的服务器，非常适合处理大量的并发请求。：ASP.NET Core 是一个模块化且轻量级的框架，这意味着它只包含构建 Web 应用程序所需的核心组件，从而减少了不必要的开销。：由于 .NET Core 是开源的，它有一个庞大的开发者社区，这意味着有大量的教程、文档和第三方库可供参考和使用。：.NET Core 是开源的，并且有一个庞大的开发者社区，这意味着有大量的教程、文档和第三方库可供参考和使用。
.net core使用Jwt授权验证
10-30
.net core使用Jwt授权验证，使用版本为.net core2.2，微软已经集成使用很方便
.NET Core 中的 JWT 认证与授权
hy_4377的博客
08-16 1036
JWT 是一种基于 JSON 的开放标准（RFC 7519），用于在网络应用环境中传递声明信息。JWT 由三部分组成：Header（头部）、Payload（载荷）、Signature（签名）。这三部分通过点号（.）连接，形成一个 JWT 字符串。包含令牌的类型和使用的加密算法。包含声明信息，可以是用户信息，也可以是其他元数据。使用 Header 中指定的算法和一个密钥对 Header 和 Payload 进行签名，确保令牌的完整性和安全性。
ASP.NET Core 使用 JWT 自定义角色/策略授权需要实现的接口
dotNET跨平台
08-23 1585
目录① 存储角色/用户所能访问的 API② 实现 IAuthorizationRequirement 接口③ 实现 TokenValidationParameters④ ...
.NET CORE JWT
weixin_38141762的博客
10-14 382
nuget添加包：Microsoft.AspNetCore.Authentication.JwtBearer Startup.cs ConfigureServices services.Configure<TokenManagement>(Configuration.GetSection("tokenManagement")); var token = Configuration.GetSection("tokenManagement").Get<TokenManageme
.NET Core JWT
qq_36694046的博客
10-03 2337
标准中注册的声明： iss：jwt签发者 sub：jwt所面向的用户 aud：接收jwt的一方 exp：jwt的过期时间，这个过期时间必须要大于签发时间 nbf：定义在什么时间之前，该jwt都是不可用的 iat：jwt的签发时间 jti：jwt的唯一身份标识，主要用来作为一次性的token，从而回避重放攻击。 以上是转发别的博客 1.导入jwt包 2.staup设置 app.UseAuthentication(); app.UseAuthorization(); 3.配...
ASP.NET WebAPI Token JWT Bearer 认证失败和成功返回自定义数据 Json
04-17
asp.net WebAPI Token Oauth2.0授权自定义返回结果(包括登录正确返回，登录失败返回)。 详细参考：https://blog.csdn.net/u013546115/article/details/105580532
ASP.NET Core WebApi构建API接口服务实战演练
跟着阿笨一起玩NET
10-19 5072
一、ASP.NET Core WebApi课程介绍 人生苦短，我用.NET Core！提到Api接口，一般会想到以前用到的WebService和WCF服务，这三个技术都是用来创建服务接口，只不过WebAPI用起来更简单，更轻量级，更流行。构建一个优秀的API依赖于伟大的框架，今天我们的主角当然是微软的跨平台轻量级HTTP服务框架——Asp.net Core WebApi。今天阿笨将给大家带来的...
精通ASP.NET Core 2.0：MVC开发与实战指南
6. **身份验证与授权**：ASP.NET Core 2.0提供了强大的身份验证和授权框架，支持OAuth、OpenID Connect等标准，以及JWT（Json Web Tokens）和cookie认证方案，确保应用程序的安全性。 7. **依赖注入**：内置的依赖...
.net core jwt 授权验证
aifan2109的博客
05-22 268
代码我参考了一本书Modern API Design with ASP.NET Core 2 Building Cross-Platform Back-End Systems 网上也有一个很牛https://jasonwatmore.com/post/2018/08/14/aspnet-core-21-jwt-authentication-tutorial-with-exampl...
.net core 3.1 jwt刷新token
07-05
.net core 3.1 jwt刷新token
net core中 JWT
qq_43826626的博客
03-28 1708
在开发程序中需要，通常需要对程序进行身份验证和授权,JWT是一种安全传输标准，各种应用程序和服务之间安全地传输信息，例如用户身份验证和授权信息。在 .NET 中，我们可以使用 JWT 实现身份验证和授权，并基于声明式安全实现权限控制。通常的办法是使用session来实现，用户登陆后，生成唯一session保存在服务器内存中，当浏览器再次访问时，http中携带了session，服务器根据该id取到信息实现缺点：用户过多占用服务器资源 每次响应都要向服务器获取一次session。
.net core之JWT（一）
q3230034的博客
08-02 779
前言 jwt是无状态，jwt信息只需要保存在客户端，无状态登录优势：分布式部署，jwt是通过token进行，jwt最重要部分是数字数字签名（VERIFY SIGNATURE），数字签名是通过非对称加密算法RSA，需要通过服务器私钥进行验证，如果私钥不丢失，基本上绝对安全（因为token是明文）。 JWT优缺点 优点：无状态，简单，方便，完美支持分布式部署 非对称加密，Token安全性高 缺点：1：因为是无状态，一经发布无法取消。（无解） 2：明文传递，token安全性低，知识通过base64加密 （使用ht
.Net Core使用JWT
飞翔的学习笔记
08-08 6021
.Net Core使用JWT 1.新建WebApi项目JwtDemo 2.通过nuget安装JWT.Net 根据你的版本自行选择合适的版本 3.分别建立三个实体类LoginDto，PlayloadDto，TokenDto public class LoginDto { public string UserId { get; set; } public string Password { get; set; } } public c
net core 使用jwt
qq_51172697的博客
04-29 1688
1. 安装必要的包首先，确保你的.NET Core项目中安装了处理JWT相关的包，比如和。可以通过NuGet包管理器来安装。
.Net core 简单使用JWT
最新发布
10-14 325
JWT
.NET Core 实现 JWT 认证
rjcql的专栏
02-07 2167
JWT（JSON Web Token）是一种开放标准, 由三部分组成，分别是Header、Payload和Signature，它以 JSON 对象的方式在各方之间安全地传输信息。通俗的说，就是通过数字签名算法生产一个字符串，然后在网络请求的中被携带到服务端进行身份认证，功能上来说和 SessionId 认证方式很像。在.Net Core 中使用JWT 可以通过 NuGet 获取 Microsoft.AspNetCore.Authentication.JwtBearer 包。
使用.NET Core实现JWT身份验证和授权
library_git106的博客
09-20 389
在TokenValidationParameters中，我们可以设置一些验证选项，例如验证发行者（Issuer）和受众（Audience），验证令牌的生命周期，以及验证签名密钥等。通过配置身份验证服务和中间件，以及创建和验证JWT令牌，我们可以轻松地在.NET Core应用程序中实现安全的身份验证和授权机制。请注意，示例中的代码仅用于演示目的，实际应用中可能需要更复杂的逻辑来处理身份验证和授权。此外，为了安全起见，建议将密钥和其他敏感信息存储在安全的位置，并使用适当的加密和保护措施。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值