欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期

程序员文章站 2022-09-27 18:54:06
" 【.NET Core项目实战 统一认证平台】开篇及目录索引 " 上一篇我介绍了 的生成验证及流程内容,相信大家也对 非常熟悉了,今天将从一个小众的需求出发,介绍如何强制令牌过期的思路和实现过程。 .netcore项目实战交流群(637326624),有兴趣的朋友可以在群里交流讨论。 一、前言 众 ......

【.net core项目实战-统一认证平台】开篇及目录索引

上一篇我介绍了jwt的生成验证及流程内容,相信大家也对jwt非常熟悉了,今天将从一个小众的需求出发,介绍如何强制令牌过期的思路和实现过程。

.netcore项目实战交流群(637326624),有兴趣的朋友可以在群里交流讨论。

一、前言

众所周知,identityserver4 默认支持两种类型的 token,一种是 reference token,一种是 jwt token 。前者的特点是 token 的有效与否是由 token 颁发服务集中化控制的,颁发的时候会持久化 token,然后每次验证都需要将 token 传递到颁发服务进行验证,是一种中心化的验证方式。jwt token的特点与前者相反,每个资源服务不需要每次都要都去颁发服务进行验证 token 的有效性验证,上一篇也介绍了,该 token 由三部分组成,其中最后一部分包含了一个签名,是在颁发的时候采用非对称加密算法进行数据的签名,保证了 token 的不可篡改性,校验时与颁发服务的交互,仅仅是获取公钥用于验证签名,且该公钥获取以后可以自己缓存,持续使用,不用再去交互获得,除非数字证书发生变化。

二、reference token的用法

上一篇已经介绍了jwt token的整个生成过程,为了演示强制过期策略,这里需要了解下reference token是如何生成和存储的,这样可以帮助掌握identityserver4所有的工作方式。

1、新增测试客户端

由于我们已有数据库,为了方便演示,我直接使用sql脚本新增。

--新建客户端(accesstokentype 0 jwt 1 reference token)
insert into clients(accesstokentype,accesstokenlifetime,clientid,clientname,enabled) values(1,3600,'clientref','测试ref客户端',1);

-- select * from clients where clientid='clientref'

--2、添加客户端密钥,密码为(secreta) sha256
insert into clientsecrets values(23,'',null,'sharedsecret','2tytaaysa0zadunthsfldjeetzsyww8wzbzm8pftgni=');

--3、增加客户端授权权限
insert into clientgranttypes values(23,'client_credentials');

--4、增加客户端能够访问scope
insert into clientscopes values(23,'mpc_gateway');

这里添加了认证类型为reference token客户端为clientref,并分配了客户端授权和能访问的scope,然后我们使用postman测试下客户端。

【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期

如上图所示,可以正确的返回access_token,且有标记的过期时间。

2、如何校验token的有效性?

identityserver4给已经提供了token的校验地址http://xxxxxx/connect/introspect,可以通过访问此地址来校验token的有效性,使用前需要了解传输的参数和校验方式。

在授权篇开始时我介绍了identityserver4的源码剖析,相信都掌握了看源码的方式,这里就不详细介绍了。

核心代码为introspectionendpoint,标注出校验的核心代码,用到的几个校验方式已经注释出来了。

private async task<iendpointresult> processintrospectionrequestasync(httpcontext context)
{
    _logger.logdebug("starting introspection request.");

    // 校验apiresources信息,支持 basic 和 form两种方式,和授权时一样
    var apiresult = await _apisecretvalidator.validateasync(context);
    if (apiresult.resource == null)
    {
        _logger.logerror("api unauthorized to call introspection endpoint. aborting.");
        return new statuscoderesult(httpstatuscode.unauthorized);
    }

    var body = await context.request.readformasync();
    if (body == null)
    {
        _logger.logerror("malformed request body. aborting.");
        await _events.raiseasync(new tokenintrospectionfailureevent(apiresult.resource.name, "malformed request body"));

        return new statuscoderesult(httpstatuscode.badrequest);
    }

    // 验证access_token的有效性,根据
    _logger.logtrace("calling into introspection request validator: {type}", _requestvalidator.gettype().fullname);
    var validationresult = await _requestvalidator.validateasync(body.asnamevaluecollection(), apiresult.resource);
    if (validationresult.iserror)
    {
        logfailure(validationresult.error, apiresult.resource.name);
        await _events.raiseasync(new tokenintrospectionfailureevent(apiresult.resource.name, validationresult.error));

        return new badrequestresult(validationresult.error);
    }

    // response generation
    _logger.logtrace("calling into introspection response generator: {type}", _responsegenerator.gettype().fullname);
    var response = await _responsegenerator.processasync(validationresult);

    // render result
    logsuccess(validationresult.isactive, validationresult.api.name);
    return new introspectionresult(response);
}

//校验token有效性核心代码
public async task<tokenvalidationresult> validateaccesstokenasync(string token, string expectedscope = null)
{
    _logger.logtrace("start access token validation");

    _log.expectedscope = expectedscope;
    _log.validatelifetime = true;

    tokenvalidationresult result;

    if (token.contains("."))
    {//jwt
        if (token.length > _options.inputlengthrestrictions.jwt)
        {
            _logger.logerror("jwt too long");

            return new tokenvalidationresult
            {
                iserror = true,
                error = oidcconstants.protectedresourceerrors.invalidtoken,
                errordescription = "token too long"
            };
        }

        _log.accesstokentype = accesstokentype.jwt.tostring();
        result = await validatejwtasync(
            token,
            string.format(constants.accesstokenaudience, _context.httpcontext.getidentityserverissueruri().ensuretrailingslash()),
            await _keys.getvalidationkeysasync());
    }
    else
    {//reference token
        if (token.length > _options.inputlengthrestrictions.tokenhandle)
        {
            _logger.logerror("token handle too long");

            return new tokenvalidationresult
            {
                iserror = true,
                error = oidcconstants.protectedresourceerrors.invalidtoken,
                errordescription = "token too long"
            };
        }

        _log.accesstokentype = accesstokentype.reference.tostring();
        result = await validatereferenceaccesstokenasync(token);
    }

    _log.claims = result.claims.toclaimsdictionary();

    if (result.iserror)
    {
        return result;
    }

    // make sure client is still active (if client_id claim is present)
    var clientclaim = result.claims.firstordefault(c => c.type == jwtclaimtypes.clientid);
    if (clientclaim != null)
    {
        var client = await _clients.findenabledclientbyidasync(clientclaim.value);
        if (client == null)
        {
            _logger.logerror("client deleted or disabled: {clientid}", clientclaim.value);

            result.iserror = true;
            result.error = oidcconstants.protectedresourceerrors.invalidtoken;
            result.claims = null;

            return result;
        }
    }

    // make sure user is still active (if sub claim is present)
    var subclaim = result.claims.firstordefault(c => c.type == jwtclaimtypes.subject);
    if (subclaim != null)
    {
        var principal = principal.create("tokenvalidator", result.claims.toarray());

        if (result.referencetokenid.ispresent())
        {
            principal.identities.first().addclaim(new claim(jwtclaimtypes.referencetokenid, result.referencetokenid));
        }

        var isactivectx = new isactivecontext(principal, result.client, identityserverconstants.profileisactivecallers.accesstokenvalidation);
        await _profile.isactiveasync(isactivectx);

        if (isactivectx.isactive == false)
        {
            _logger.logerror("user marked as not active: {subject}", subclaim.value);

            result.iserror = true;
            result.error = oidcconstants.protectedresourceerrors.invalidtoken;
            result.claims = null;

            return result;
        }
    }

    // check expected scope(s)
    if (expectedscope.ispresent())
    {
        var scope = result.claims.firstordefault(c => c.type == jwtclaimtypes.scope && c.value == expectedscope);
        if (scope == null)
        {
            logerror(string.format("checking for expected scope {0} failed", expectedscope));
            return invalid(oidcconstants.protectedresourceerrors.insufficientscope);
        }
    }

    _logger.logdebug("calling into custom token validator: {type}", _customvalidator.gettype().fullname);
    var customresult = await _customvalidator.validateaccesstokenasync(result);

    if (customresult.iserror)
    {
        logerror("custom validator failed: " + (customresult.error ?? "unknown"));
        return customresult;
    }

    // add claims again after custom validation
    _log.claims = customresult.claims.toclaimsdictionary();

    logsuccess();
    return customresult;
}

有了上面的校验代码,就可以很容易掌握使用的参数和校验的方式,现在我们就分别演示jwt tokenreference token两个校验方式及返回的值。

首先需要新增资源端的授权记录,因为校验时需要,我们就以mpc_gateway为例新增授权记录,为了方便演示,直接使用sql语句。

-- select * from dbo.apiresources where name='mpc_gateway'
insert into dbo.apisecrets values(28,null,null,'sharedsecret','2tytaaysa0zadunthsfldjeetzsyww8wzbzm8pftgni=');

首先我们测试刚才使用reference token生成的access_token,参数如下图所示。
【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期

查看是否校验成功,从返回的状态码和active结果判断,如果为true校验成功,如果为false或者401校验失败。

我们直接从数据库里删除刚才授权的记录,然后再次提交查看结果,返回结果校验失败。

  delete from persistedgrants where clientid='clientref'

【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期

然后我们校验下jwt token,同样的方式,先生成jwt token,然后进行校验,结果如下图所示。
【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期

可以得到预期结果。

三、强制过期的方式

1、简易黑名单模式

在每次有token请求时,资源服务器对请求的token进行校验,在校验有效性校验通过后,再在黑名单里校验是否强制过期,如果存在黑名单里,返回授权过期提醒。资源服务器提示token无效。注意由于每次请求都会校验token的有效性,因此黑名单最好使用比如redis缓存进行保存。

实现方式:

此种方式只需要重写token验证方式即可实现。

优点

实现简单,改造少。

缺点

1、不好维护黑名单列表

2、对认证服务器请求压力太大

2、策略黑名单模式

建议黑名单有一个最大的弊端是每次请求都需要对服务器进行访问,会对服务器端造成很大的请求压力,而实际请求数据中99%都是正常访问,对于可疑的请求我们才需要进行服务器端验证,所以我们要在客户端校验出可疑的请求再提交到服务器校验,可以在claim里增加客户端ip信息,当请求的客户端ip和token里的客户端ip不一致时,我们标记为可疑token,这时候再发起token校验请求,校验token是否过期,后续流程和简易黑名单模式完成一致。

实现方式

此种方式需要增加token生成的claim,增加自定义的ip的claim字段,然后再重写验证方式。

优点

可以有效的减少服务器端压力

缺点

不好维护黑名单列表

3、强化白名单模式

通常不管使用客户端、密码、混合模式等方式登录,都可以获取到有效的token,这样会造成签发的不同token可以重复使用,且很难把这些历史的token手工加入黑名单里,防止被其他人利用。那如何保证一个客户端同一时间点只有一个有效token呢?我们只需要把最新的token加入白名单,然后验证时直接验证白名单,未命中白名单校验失败。校验时使用策略黑名单模式,满足条件再请求验证,为了减轻认证服务器的压力,可以根据需求在本地缓存一定时间(比如10分钟)。

实现方式

此种方式需要重写token生成方式,重写自定义验证方式。

优点

服务器端请求不频繁,验证块,自动管理黑名单。

缺点

实现起来比较改造的东西较多

综上分析后,为了网关的功能全面和性能,建议采用强化白名单模式来实现强制过期策略。

四、强制过期的实现

1.增加白名单功能

为了增加强制过期功能,我们需要在配置文件里标记是否开启此功能,默认设置为不开启。

/// <summary>
/// 金焰的世界
/// 2018-12-03
/// 配置存储信息
/// </summary>
public class dapperstoreoptions
{
    /// <summary>
    /// 是否启用自定清理token
    /// </summary>
    public bool enabletokencleanup { get; set; } = false;

    /// <summary>
    /// 清理token周期(单位秒),默认1小时
    /// </summary>
    public int tokencleanupinterval { get; set; } = 3600;

    /// <summary>
    /// 连接字符串
    /// </summary>
    public string dbconnectionstrings { get; set; }

    /// <summary>
    /// 是否启用强制过期策略,默认不开启
    /// </summary>
    public bool enableforceexpire { get; set; } = false;
    
    /// <summary>
    /// redis缓存连接
    /// </summary>
    public list<string> redisconnectionstrings { get; set; }
}

然后重写token生成策略,增加白名单功能,并使用redis存储白名单。白名单的存储的key格式为clientid+sub+amr,详细实现代码如下。

using czar.identityserver4.options;
using identitymodel;
using identityserver4.responsehandling;
using identityserver4.services;
using identityserver4.stores;
using identityserver4.validation;
using microsoft.aspnetcore.authentication;
using microsoft.extensions.logging;
using system;
using system.threading.tasks;

namespace czar.identityserver4.responsehandling
{
    public class czartokenresponsegenerator : tokenresponsegenerator
    {

        private readonly dapperstoreoptions _config;
        private readonly icache<czartoken> _cache;
        public czartokenresponsegenerator(isystemclock clock, itokenservice tokenservice, irefreshtokenservice refreshtokenservice, iresourcestore resources, iclientstore clients, ilogger<tokenresponsegenerator> logger, dapperstoreoptions config, icache<czartoken> cache) : base(clock, tokenservice, refreshtokenservice, resources, clients, logger)
        {
            _config = config;
            _cache = cache;
        }

        /// <summary>
        /// processes the response.
        /// </summary>
        /// <param name="request">the request.</param>
        /// <returns></returns>
        public override async task<tokenresponse> processasync(tokenrequestvalidationresult request)
        {
            var result = new tokenresponse();
            switch (request.validatedrequest.granttype)
            {
                case oidcconstants.granttypes.clientcredentials:
                    result = await processclientcredentialsrequestasync(request);
                    break;
                case oidcconstants.granttypes.password:
                    result = await processpasswordrequestasync(request);
                    break;
                case oidcconstants.granttypes.authorizationcode:
                    result = await processauthorizationcoderequestasync(request);
                    break;
                case oidcconstants.granttypes.refreshtoken:
                    result = await processrefreshtokenrequestasync(request);
                    break;
                default:
                    result = await processextensiongrantrequestasync(request);
                    break;
            }
            if (_config.enableforceexpire)
            {//增加白名单
                var token = new czartoken();
                string key = request.validatedrequest.client.clientid;
                var _claim = request.validatedrequest.subject?.findfirst(e => e.type == "sub");
                if (_claim != null)
                {
                    //提取amr
                    var amrval = request.validatedrequest.subject.findfirst(p => p.type == "amr");
                    if (amrval != null)
                    {
                        key += amrval.value;
                    }
                    key += _claim.value;
                }
                //加入缓存
                if (!string.isnullorempty(result.accesstoken))
                {
                    token.token = result.accesstoken;
                    await _cache.setasync(key, token, timespan.fromseconds(result.accesstokenlifetime));
                }
            }
            return result;
        }
    }
}

然后定一个通用缓存方法,默认使用redis实现。

using czar.identityserver4.options;
using identityserver4.services;
using system;
using system.threading.tasks;

namespace czar.identityserver4.caches
{
    /// <summary>
    /// 金焰的世界
    /// 2019-01-11
    /// 使用redis存储缓存
    /// </summary>
    public class czarrediscache<t> : icache<t>
        where t : class
    {
        private const string keyseparator = ":";
        public czarrediscache(dapperstoreoptions configurationstoreoptions)
        {
            csredis.csredisclient csredis;
            if (configurationstoreoptions.redisconnectionstrings.count == 1)
            {
                //普通模式
                csredis = new csredis.csredisclient(configurationstoreoptions.redisconnectionstrings[0]);
            }
            else
            {
                csredis = new csredis.csredisclient(null, configurationstoreoptions.redisconnectionstrings.toarray());
            }
            //初始化 redishelper
            redishelper.initialization(csredis);
        }

        private string getkey(string key)
        {
            return typeof(t).fullname + keyseparator + key;
        }

        public async task<t> getasync(string key)
        {
            key = getkey(key);
            var result = await redishelper.getasync<t>(key);
            return result;
        }

        public async task setasync(string key, t item, timespan expiration)
        {
            key = getkey(key);
            await redishelper.setasync(key, item, (int)expiration.totalseconds);
        }
    }
}

然后重新注入下itokenresponsegenerator实现。

builder.services.addsingleton<itokenresponsegenerator, czartokenresponsegenerator>();
builder.services.addtransient(typeof(icache<>), typeof(czarrediscache<>));

现在我们来测试下生成token,查看redis里是否生成了白名单?

reference token生成
【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期
【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期

客户端模式生成
【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期
【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期

密码模式生成
【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期

【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期

从结果中可以看出来,无论那种认证方式,都可以生成白名单,且只保留最新的报名单记录。

2.改造校验接口来适配白名单校验

前面介绍了认证原理后,实现校验非常简单,只需要重写下iintrospectionrequestvalidator接口即可,增加白名单校验策略,详细实现代码如下。

using czar.identityserver4.options;
using czar.identityserver4.responsehandling;
using identityserver4.models;
using identityserver4.services;
using identityserver4.validation;
using microsoft.extensions.logging;
using system.collections.specialized;
using system.linq;
using system.threading.tasks;

namespace czar.identityserver4.validation
{
    /// <summary>
    /// 金焰的世界
    /// 2019-01-14
    /// token请求校验增加白名单校验
    /// </summary>
    public class czarintrospectionrequestvalidator : iintrospectionrequestvalidator
    {
        private readonly ilogger _logger;
        private readonly itokenvalidator _tokenvalidator;
        private readonly dapperstoreoptions _config;
        private readonly icache<czartoken> _cache;
        public czarintrospectionrequestvalidator(itokenvalidator tokenvalidator, dapperstoreoptions config, icache<czartoken> cache, ilogger<czarintrospectionrequestvalidator> logger)
        {
            _tokenvalidator = tokenvalidator;
            _config = config;
            _cache = cache;
            _logger = logger;
        }

        public async task<introspectionrequestvalidationresult> validateasync(namevaluecollection parameters, apiresource api)
        {
            _logger.logdebug("introspection request validation started.");

            // retrieve required token
            var token = parameters.get("token");
            if (token == null)
            {
                _logger.logerror("token is missing");

                return new introspectionrequestvalidationresult
                {
                    iserror = true,
                    api = api,
                    error = "missing_token",
                    parameters = parameters
                };
            }

            // validate token
            var tokenvalidationresult = await _tokenvalidator.validateaccesstokenasync(token);

            // invalid or unknown token
            if (tokenvalidationresult.iserror)
            {
                _logger.logdebug("token is invalid.");

                return new introspectionrequestvalidationresult
                {
                    isactive = false,
                    iserror = false,
                    token = token,
                    api = api,
                    parameters = parameters
                };
            }

            _logger.logdebug("introspection request validation successful.");

            if (_config.enableforceexpire)
            {//增加白名单校验判断
                var _key = tokenvalidationresult.claims.firstordefault(t => t.type == "client_id").value;
                var _amr = tokenvalidationresult.claims.firstordefault(t => t.type == "amr");
                if (_amr != null)
                {
                    _key += _amr.value;
                }
                var _sub = tokenvalidationresult.claims.firstordefault(t => t.type == "sub");
                if (_sub != null)
                {
                    _key += _sub.value;
                }
                var _token = await _cache.getasync(_key);
                if (_token == null || _token.token != token)
                {//已加入黑名单
                    _logger.logdebug("token已经强制失效");
                    return new introspectionrequestvalidationresult
                    {
                        isactive = false,
                        iserror = false,
                        token = token,
                        api = api,
                        parameters = parameters
                    };
                }
            }
            // valid token
            return new introspectionrequestvalidationresult
            {
                isactive = true,
                iserror = false,
                token = token,
                claims = tokenvalidationresult.claims,
                api = api,
                parameters = parameters
            };
        }
    }
}

然后把接口重新注入,即可实现白名单的校验功能。

 builder.services.addtransient<iintrospectionrequestvalidator, czarintrospectionrequestvalidator>();

只要几句代码就完成了功能校验,现在可以使用postman测试白名单功能。首先使用刚生成的token测试,可以正确的返回结果。
【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期

紧接着,我从新生成token,然后再次请求,结果如下图所示。
【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期

【.NET Core项目实战-统一认证平台】第十三章 授权篇-如何强制有效令牌过期

发现校验失败,提示token已经失效,和我们预期的结果完全一致。

现在获取的token只有最新的是白名单,其他的有效信息自动加入认定为黑名单,如果想要强制token失效,只要删除或修改redis值即可。

有了这个认证结果,现在只需要在认证策略里增加合理的校验规则即可,比如5分钟请求一次验证或者使用ip策略发起校验等,这里就比较简单了,就不一一实现了,如果在使用中遇到问题可以联系我。

五、总结与思考

本篇我介绍了identityserver4里token认证的接口及实现过程,然后介绍强制有效token过期的实现思路,并使用了白名单模式实现了强制过期策略。但是这种实现方式不一定是非常合理的实现方式,也希望有更好实现的朋友批评指正并告知本人。

实际生产环境中如果使用jwt token,建议还是使用token颁发的过期策略来强制token过期,比如对安全要求较高的设置几分钟或者几十分钟过期等,避免token泄漏造成的安全问题。

至于单机登录,其实只要开启强制过期策略就基本实现了,因为只要最新的登录会自动把之前的登录token强制失效,如果再配合signalr强制下线即可。

项目源代码地址:https://github.com/jinyancao/czar.identityserver4