IdentityServer4

OAuth&OpenIDConnect是什么？

最近因为工作的原因，大概有两个月时间没写博客了，本来今年给自己的目标是每个月写一篇，或许记录工作中踩过的一些坑，或许学习一些新的技术框架。说实话IDS4的源码我是在几天前才开始看的，因为工作需要实现一个认证授权服务中心，临时抱佛脚研究了几天源码和查了一些资料，我个人的习惯是三方的开源框架，如果不了解源码实现，一般情况下不敢贸然使用。以下内容如果有说的不对的地方，希望大家及时指出。接下来我就结合OAuth&OIDC以及IDS4的源码跟大家剖析一下Identityserver4（以下简称IDS4）的实现原理。

在介绍IDS4之前，我们先来看下OAuth和OpenIDConnect（以下简称OIDC）协议的一些概念，因为只有在理解这两个协议规范的基础之上才能理解IDS4。

 

OAuth是什么？最直接的方式，我们可以通过查看OAuth2的官方文档，地址是 https://oauth.net/2/。官方文档是英文版的，建议大家在阅读IDS4的源码之前多少看看这个文档，我个人的理解是OAuth是一个开放式授权委托协议，是一种规范，它可以让资源所有者委托应用软件（注意是委托），从IDP（IDP是一种服务提供商，NETCORE平台下的实现是IDS4）获取授权AccessToken访问资源所有者受保护的资源。接下来我们一起看看OAuth的授权流程。

 

OAuth2的授权流程

在官方文档里边大概有这么一张图片，描述了OAuth2的整个授权流程。

在介绍授权流程之前，我想先简单解释以下OAuth2授权里边涉及的这么4个角色，我用红圈标注了。1.Client我们可以把它理解为客户端应用；2.ResourceOwner也就是前面描述的资源所有者；3.AuthorizationServer就是授权服务提供商简称IDP，在本篇文章里面就是IDS4；4.ResourceServer资源服务器，资源所有者受保护的资源就在这里。下边我们一起看看授权流程。

我们以WEB-ASPNETCORE应用为例，ResourceOwner（用户）操作Client（WEB应用）去访问ResourceServer（资源服务器）上面的某个受保护的资源，这时候因为ASPNETCORE内置的认证系统会重定向到AuthorizationServer（授权服务器），当然在授权之前还需要身份认证，OAuth2它不管认证，只管授权，一般情况下在认证通过之后，会跳转到一个授权页面，里面一般包含了Scope也就是你的权限范围，最后完成授权。关于整个授权流程里面涉及的参数以及返回值我在后续实例会详细说。下面我们来看下OAuth2里边支持哪些授权类型？

 

OAuth2的授权类型（模式）

从官方文档的定义来看，OAuth2的授权类型主要包含6种，但是我们常见的只有4种。1.AuthorizationCode授权码类型，也是我们常用的授权模式，一般是通过授权服务器中介完成，典型的场景就是我上面的例子WEB-ASPNETCORE应用，该模式主要是通过授权码获取AccessToken访问令牌，而且授权码是一次性的；2.Implicit简化授权类型，有些朋友称之为隐式授权类型，它应该是code类型的简化版本，没有授权码这个过程，授权服务器直接返回AccessToken到浏览器，安全相一般，但是使用方便，它的应用场景主要是浏览器内的客户端应用，比如Angular等；3.ResourceOwnerPasswordCredentials密码授权类型，名字比较长，安全系数不高，需要用户与应用具有高度的信任的环境；4.ClientCredentials客户端授权类型，一般应用场景就是资源不属于某个所有者但是客户端又需要获取。授权类型概念也差不多简单介绍完了，下面我们再看看OAuth2端点这个概念。

 

OAuth2端点（EndPoint）

OAuth2端点主要分为3个AuthorizationEndPoint（授权端点）和TokenPoint（令牌端点）以及RedirectionEndpoint（重定向端点）。授权端点一般是在浏览器里面进行交互和处理，通俗一点说就是资源所有者委托客户端从授权服务器那登录以及授权，可以使用Post|Get请求，必须支持Get请求。令牌端点一般是客户端应用与授权服务器进行交互，通俗来说就是客户端和授权服务器交换令牌token的过程都是需要tokenendpoint参与完成，必须使用Post请求。以上介绍的4种授权类型只有Implicit简化授权类型没有采用令牌端点，其他均访问了令牌端点。OAuth2授权协议就介绍到这吧，下边我们看看OIDC。

 

什么是OIDC？

OIDC它是基于OAuth2的协议之上构建的一个简单身份层，通俗的说就是身份认证协议，简单理解就是OIDC = Authentication + Authorization + OAuth2。在OAuth2 in Action 这本书里面把授权比喻成巧克力，这个巧克力不是最终的产品还是一种原料，身份认证被比喻成软糖，按照这本书的理解，我们要制作巧克力软糖，也就是需要一个基于OAuth2的身份认证协议，而OpenIDConnect就是这样协议规范，它可以工作在不同的身份认证供应商之间。关于OIDC和OAuth2角色映射自己查下资料吧，就是叫法不同，没什么暗箱操作，OIDC协议需要注意的是它定义了3个流程，AuthorizationCodeFlow、HybridFlow、ImplicitFlow，其实这3个流程对应的就是OAuth2的几种授权类型，比如HybridFlow它叫混合流程，包含OAuth2授权类型里面的code & implicit，概念就到这吧。

 

什么是IDS4?

IdentityServer4 是ASPNETCore2.X系列量身打造的一款基于OpenIDConnect和OAuth2认证框架，也就是OIDC认证服务提供商。它实现了OpenIDConnect和OAuth2的大部分协议，同时遵循Apache2的这么一个开源协议，github地址是https://github.com/IdentityServer/IdentityServer4，大家如果下载建议先Star以下。上面说了这么多，还不如一张图来的实在。

这张图不是我画的，是从IDS4官网扣的。引用官方的描述IDS4大概可以为我们做这么几件事。

1.保护你的资源

2.使用本地帐户或通过外部身份提供程序对用户进行身份验证

3.提供会话管理和单点登录

4.管理和验证客户机

5.向客户发出标识和访问令牌

6.验证令牌

接下来我们具体看看IDS4是如何实现OAuth2和OIDC完成我们的统一身份认证和授权的，我会从OAuth2常见的授权类型里面抽取两个授权类型实例加以讲解，并且结合IDS4框架源码加以分析，我们先从简单的开始吧。

 

ClientCredentials

实例代码是IDS4源码里面Samples文件下的Demo工程，大家可以自行下载，GITHUB地址我在上面已经贴出来了。

ClientCredentials实例解决方案下面有3个工程文件夹，分别是API对应我们OAuth2里面的受保护资源，Client对应我们OAuth2里面的客户端应用，在这里是控制台程序，IdentityServer不用多说就是IDS4，认证授权服务。

 

请求流程

ClientCredentials授权类型的请求流程很简单，自己看吧。下面我们一起看看实例代码。

 

Client端代码

private static async Task Main()
        {
            // 其他代码...
            var client = new HttpClient();
            // 没啥说的，OIDC协议规范定义的端点发现机制，当然你也可以绕过这步，感兴趣的可以看看这个方法的实现
            var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
          
            // 通过clientid secret tokenendpoint等信息获取accesstoken访问令牌
            var tokenResponse = await client.RequestClientCredentialsTokenAsync(new  ClientCredentialsTokenRequest
            {
                Address = disco.TokenEndpoint,
                ClientId = "client",
                ClientSecret = "secret",
                Scope = "api1"
            });
            Console.WriteLine(tokenResponse.Json);
            // 通过accesstoken 调用 受保护的api
            var apiClient = new HttpClient();
            apiClient.SetBearerToken(tokenResponse.AccessToken);
            var response = await apiClient.GetAsync("http://localhost:5001/identity");
            if (!response.IsSuccessStatusCode)
            {
                Console.WriteLine(response.StatusCode);
            }
            else
            {
                var content = await response.Content.ReadAsStringAsync();
                Console.WriteLine(JArray.Parse(content));
            }
        }

client代码很简单，我也大概做了注释和删掉一些验证的代码，相信大家一看就明白了。接下来我们继续看IDS4这边的代码。

 

IdentityServer代码

// 注入服务
        public void ConfigureServices(IServiceCollection services)
        {
            // 注入IDS4的基础服务
            var builder = services.AddIdentityServer()
                // 注入resource资源到内存，该资源我们可以理解为ids4本地资源，比如用户信息等
                .AddInMemoryIdentityResources(Config.GetIdentityResources())
                // 注入api资源，也就是那些受保护的api
                .AddInMemoryApiResources(Config.GetApis())
                // 注入client客户端资源
                .AddInMemoryClients(Config.GetClients());
            if (Environment.IsDevelopment())
            {
                // 临时开发环境下的证书
                builder.AddDeveloperSigningCredential();
            }
        }
        // 注入中间件
        public void Configure(IApplicationBuilder app)
        {
            // 注册ids4中间件
            app.UseIdentityServer();
        }

以上代码注释的比较详细，就不加以说明了，需要注意的一个地方就是这些资源都是从config这个类里面加载出来的，我们下面看看资源具体是什么样。题外话，上边这两方法来源于Starpup启动类的两个方法，关于Starpup的加载执行机制可以看我上一篇文章。

 

Config代码

public static class Config
    {
        public static IEnumerable<IdentityResource> GetIdentityResources()
        {
            return new IdentityResource[]
            {
                new IdentityResources.OpenId()
            };
        }
        public static IEnumerable<ApiResource> GetApis()
        {
            return new List<ApiResource>
            {
                // 注意api1这个名称，需要跟api资源Audience的名称一样，包括下边的scope里面的名称
                new ApiResource("api1", "My API")
            };
        }
        public static IEnumerable<Client> GetClients()
        {
            return new List<Client>
            {
                new Client
                {
                    // 客户端id
                    ClientId = "client",
                    // 授权类型
                    AllowedGrantTypes = GrantTypes.ClientCredentials,
                    // secret
                    ClientSecrets =
                    {
                        new Secret("secret".Sha256())
                    },
                    // scope授权范围
                    AllowedScopes = { "api1" }
                }
            };
        }
    }

由于是示例代码，所以资源都是以硬编码的方式写死在了config类里边，代码简单不多说，生产环境下建议用数据库或者redis缓存，关于efcore的版本github上面有开源代码，有兴趣的朋友可以自行查看。最后我们一起看下api这个工程里边的代码。

 

API代码

public void ConfigureServices(IServiceCollection services)
        {
            // 注入mvc的核心服务
            services.AddMvcCore()
                // 注入aspnetcore认证服务
                .AddAuthorization()
                .AddJsonFormatters();
            // 注入jwtbearer基础服务
            services.AddAuthentication("Bearer")
                .AddJwtBearer("Bearer", options =>
                {
                    // ids4地址，用于验证accesstoken
                    options.Authority = "http://localhost:5000";
                    // 非必须使用https
                    options.RequireHttpsMetadata = false;
                    // api资源名称
                    options.Audience = "api1";
                });
        }
        public void Configure(IApplicationBuilder app)
        {
            // 注入aspnetcore认证中间件
            app.UseAuthentication();
            app.UseMvc();
        }
 
    [Route("identity")]
    [Authorize] // 需要认证应用携带正确的accesstoken才能访问
    public class IdentityController : ControllerBase
    {
        public IActionResult Get()
        {
            return new JsonResult(from c in User.Claims select new { c.Type, c.Value });
        }
    }

api代码的风格类似ids4认证服务，我注释的也很详细，关于aspnetcore的认证机制可以查看我上一篇文章。以上代码就是IDS4的ClientCredentials的授权，下边我们重点看看IDS4的源代码实现。

 

ClientCredentials授权IDS4源码分析

在分析ids4源码之前，我们先看看OAuth协议针对ClientCredentials客户端授权的一些参数&返回值规范。

Request：
POST /token HTTP/1.1
Host: authorization-server.com
grant_type=client_credentials // 必须
&client_id=xxxxxxxxxx // 必须
&client_secret=xxxxxxxxxx // 必须

Response：

HTTP/1.1 200 OK
Content-Type: application/json
Cache-Control: no-store
Pragma: no-cache
{
  "access_token":"MTQ0NjJkZmQ5OTM2NDE1ZTZjNGZmZjI3", // 必须
  "token_type":"bearer", // 必须
  "expires_in":3600, // 
  "refresh_token":"IwOGYzYTlmM2YxOTQ5MGE3YmNmMDFkNTVk",
  "scope":"create"
}

Request&Response我是从OAuth官方文档上面扒下来的，可能有朋友会好奇，我为什么要贴这一部分东西？我个人觉得读ids4的源码和aspnetcore或者其他开源代码有一些区别，ids4的源代码代码量并不多，也没有很多逻辑，但是它是遵循OAuth2和OIDC这两个协议规范实现的这么一个框架，换句话说如果你完全不了解这两个协议规范的情况下去阅读ids4，你会被它跳晕。即便你能看懂里面的逻辑，你也不知道它为什么要这么干。下面我们通过Fiddler工具查看ClientCredentials授权类型的请求和响应报文。

从Fiddler上的请求监控来看，ClientCredentials授权类型一共有6个请求，其中前面4个是client发起的，后面2个是api资源向ids4发起的请求。下面我们具体看看这些请求涉及的报文。

 

openid-configuration&openid-configuration/jwks

configuration响应报文

从响应内容来看，这个请求只是获取ids4的端点信息和对OAuth2&OIDC协议的支持信息。

 

jwks响应报文

这个请求其实就是从ids4获取公钥，用户验证jwt的数字签名部分。

 

connect/token

请求报文

响应报文

以上两段报文信息内容比较简单，这里我想简单说下这个accesstoken访问令牌，它是由ids4框架里面的tokenendpoint端点负责生成，这个令牌就是后续请求受保护资源api的这么一个通行证。它的生成机制，在后续的ids4源码分析里面我会详细介绍。

 

/identity

请求头

携带了上一个请求返回的accesstoken，并且token类型是Bearer。

 

响应内容

这个没啥特别的，就是api资源返回的内容。需要注意的地方，在此之前，也就是当前请求响应之前，api资源向ids4授权服务器发起了2个请求，也就是前面图里边显示的最后两个请求。这两个请求其实际是JwtBearer认证的范畴，因为我们在api工程的startup启动类里边配置了它的认证类型是JwtBearer并且identitycontroller上面配置授权特性[Authorize]，熟悉aspnetcore认证授权机制的朋友应该知道，在执行action之前会做认证授权处理，因为未认证直接返回challenge，最终处理由认证handler子类JwtBearerHandler接管，在JwtBearerHandler处理逻辑中，通过调用我们api资源服务JwtBearer的options配置的Authority地址，获取ids4公钥（也就是后面的jwks请求）做accesstoken签名校验，后面两个请求我就不贴图片了，跟上面的两个请求一样。关于aspnetcore认证机制可以看我上一篇帖子。接下来我们来看一个稍微复杂一点的实例。

 

Hybrid Flow & AuthorizationCode Implicit

Hybrid Flow认证流程非常适合WEB服务器应用，OIDC官方文档描述HybridFlow流程其实是OAuth2 Code和Implicit授权类型的组合，也是最常用的一种认证流程吧。这个实例解决方案包含3个工程，client为aspnetcoremvc，api为webapicore，idp为ids4，该Demo实例支持自定义策略授权而且支持ReferenceToken刷新AccessToken，登出等操作，首先我们看下Hybrid Flow流程大致请求原理，见下图

这副图引用的是园子里边solenovex大神的，请求逻辑在这副图上已经描述的很清楚了，我就不再介绍，但是这里有个地方需要注意，response_type这个参数有3种组合，图示里面展示的是最多的一种情况，code（授权码）、id_token（用户token）、token（就是accesstoken），细心的朋友发现accesstoken、idtoken返回了两次，其实它们的值是不同的，最终访问受保护的api资源用的是下一个accesstoken。下面我们直接上代码吧。

 

identityserver

public void ConfigureServices(IServiceCollection services)
        {
             services.AddMvc().SetCompatibilityVersion(Microsoft.AspNetCore.Mvc.CompatibilityVersion.Version_2_1);
            // 其他代码...
            // 注入ids4基础服务
            var builder = services.AddIdentityServer(options =>
            {
                options.Events.RaiseErrorEvents = true;
                options.Events.RaiseInformationEvents = true;
                options.Events.RaiseFailureEvents = true;
                options.Events.RaiseSuccessEvents = true;
            })
            // 测试用户
           .AddTestUsers(TestUsers.Users);
            // 这些个类似第一个实例
            builder.AddInMemoryIdentityResources(Config.GetIdentityResources());
            builder.AddInMemoryApiResources(Config.GetApis());
            builder.AddInMemoryClients(Config.GetClients());
            // 临时开发证书，生成环境建议使用机构颁发的证书
            if (Environment.IsDevelopment())
            {
                builder.AddDeveloperSigningCredential();
            }
        }
        public void Configure(IApplicationBuilder app)
        {
            if (Environment.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            // 注册ids4中间件
            app.UseIdentityServer();
            app.UseStaticFiles();
            app.UseMvcWithDefaultRoute();
        }

startup里面的代码跟上一个实例的代码几乎一样，这个实例里面我们着重看看这些资源。

 

resources

public static IEnumerable<IdentityResource> GetIdentityResources()
        {
            // 身份资源，类似上一个实例
            return new IdentityResource[]
            {
                new IdentityResources.OpenId(),
                new IdentityResources.Profile(),
                new IdentityResources.Address(),
                new IdentityResources.Phone(),
                new IdentityResources.Email(),
                // 策略资源，也是身份资源的一种吧
                new IdentityResource("names", "姓名", new List<string> { "FamilyName" }),
            };
        }
        public static IEnumerable<ApiResource> GetApis()
        {
            return new ApiResource[]
            {
                new ApiResource("api1", "testapi", new List<string> { "FamilyName" })
                {
                    // 这个secrets主要是用于api在ids4上的验证，因为需要referencetoken刷新accesstoken
                    ApiSecrets = { new Secret("api1 secret".Sha256()) }
                }
            };
        }
        public static IEnumerable<Client> GetClients()
        {
            return new[]
            {
                new Client
                {
                    ClientId = "hybrid client mvc",
                    ClientSecrets = {new Secret("hybrid secret".Sha256()) },
                    AllowedGrantTypes = GrantTypes.Hybrid, // 混合认证流程，OIDC协议
                    AccessTokenType = AccessTokenType.Jwt, // accesstoken类型jwt，还有referencetoken类型
                    AllowAccessTokensViaBrowser = true, 
                    AccessTokenLifetime = 60, // 时间单位是秒，表示accesstoken60秒后过期
                    RedirectUris = // 跳转登录地址
                    {
                        "http://localhost:5002/signin-oidc"
                    },
                    PostLogoutRedirectUris = // 跳转登出地址
                    {
                        "http://localhost:5002/signout-callback-oidc"
                    },
                    AllowOfflineAccess = true,
                    AlwaysIncludeUserClaimsInIdToken = true,
                    AllowedScopes =
                    {
                        "api1",
                        IdentityServerConstants.StandardScopes.OpenId,
                        IdentityServerConstants.StandardScopes.Email,
                        IdentityServerConstants.StandardScopes.Address,
                        IdentityServerConstants.StandardScopes.Phone,
                        IdentityServerConstants.StandardScopes.Profile,
                        "names" // 策略scope
                    }
                }
            };
        }
 
        // 测试用户
        public static List<TestUser> Users = new List<TestUser>
        {
            new TestUser{
                SubjectId = "1", Username = "test", Password = "test",
                Claims =
                {
                    new Claim(JwtClaimTypes.Name, "test"),
                    new Claim(JwtClaimTypes.FamilyName, "test"),
                    new Claim(JwtClaimTypes.Email, "test@email.com"),
                    new Claim(JwtClaimTypes.EmailVerified, "true",  ClaimValueTypes.Boolean),
                    new Claim(JwtClaimTypes.Address, @"{ '街道': '万家丽', '地址': '长沙','country': '大中国' }", IdentityServer4.IdentityServerConstants.ClaimValueTypes.Json), 
                }
            },
            new TestUser{
                SubjectId = "2", Username = "demo", Password = "demo",
                Claims =
                {
                    new Claim(JwtClaimTypes.Name, "demo"),
                    new Claim(JwtClaimTypes.FamilyName, "demo"),
                    new Claim(JwtClaimTypes.Email, "demo@email.com"),
                    new Claim(JwtClaimTypes.EmailVerified, "true",  ClaimValueTypes.Boolean),
                    new Claim(JwtClaimTypes.Address, @"{ '街道': '五一广场', '地址': '长沙','country': '大中国' }", IdentityServer4.IdentityServerConstants.ClaimValueTypes.Json),
                    new Claim("name", "FamilyName"),  // 授权策略claim
                }
            }
        };
    }

代码也很简单，跟上一个实例的资源代码有一定的区别，注释的地方需要多看一下。

 

Client

public void ConfigureServices(IServiceCollection services)
        {
            // 其他代码...
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
            JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear(); // 清空jwt用户信息的映射关系。
            services.AddAuthentication(options =>
                {
                    // 注册cookiesScheme，表示本地认证采用cookie认证
                    options.DefaultScheme =  CookieAuthenticationDefaults.AuthenticationScheme;
                    // 注册oidcscheme，表示远程认证采用oidc认证
                    options.DefaultChallengeScheme =  OpenIdConnectDefaults.AuthenticationScheme;
                })
                // 注入cookie认证处理器，
                .AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, options =>
                    {
                        options.AccessDeniedPath = "/Unauthorized/AccessDenied";  // 指定未授权的页面路由地址
                    })
                    // 注入oidc认证处理器
                .AddOpenIdConnect(OpenIdConnectDefaults.AuthenticationScheme, options =>
                {
                    // 认证成功登录到本地cookie，主要是解决本地认证的问题。
                    options.SignInScheme =  CookieAuthenticationDefaults.AuthenticationScheme;
                    options.Authority = "http://localhost:5000"; // ids4 base地址
                    options.RequireHttpsMetadata = false;
                    options.ClientId = "hybrid client mvc";
                    options.ClientSecret = "hybrid secret";
                    options.SaveTokens = true; // 保存token到store
                    options.ResponseType = "code id_token token"; // responsetype有三种组合，这里使用的是组合最多的一种，可以看前面一张图
                    options.Scope.Clear();
                    options.Scope.Add("api1");
                    options.Scope.Add(OidcConstants.StandardScopes.OpenId);
                    options.Scope.Add(OidcConstants.StandardScopes.Profile);
                    options.Scope.Add(OidcConstants.StandardScopes.Email);
                    options.Scope.Add(OidcConstants.StandardScopes.Phone);
                    options.Scope.Add(OidcConstants.StandardScopes.Address);
                    options.Scope.Add("names"); // ids4那边定义的策略名称
                    options.Scope.Add(OidcConstants.StandardScopes.OfflineAccess);
                });
            services.AddAuthorization(options =>
            {
                options.AddPolicy("FamilyNamePolicy", builder => // 注入自定义策略
                    {
                        builder.AddRequirements(new NameRequirement());
                    });
            });
            // 注入策略处理器
            services.AddSingleton<IAuthorizationHandler, NameHandler>();
        }
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
            }
            app.UseStaticFiles();
            // 注入认证中间件
            app.UseAuthentication();
            app.UseCookiePolicy();
            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "default",
                    template: "{controller=Home}/{action=Index}/{id?}");
            });
        }

客户端的startup里边的代码我也做了详细注释，需要注意的是更前面一个实例的client代码截然不同，比较绕的地方主要是对aspnetcore的认证授权系统的理解，由于篇幅问题，AddOpenidConnect这个方法里面的源码我就不贴了，我大概讲一下源码的实现逻辑，AddOpenidConnect方法内部其实际是注入了OIDC认证的处理器，这个处理器是OpenIdConnectHandler，这个handler跟jwthandler或者cookiehandler在aspnetcore平台里面的结构是一样样的，只是它们核心方法的自身逻辑处理各有不同，比如cookiehandler的认证方法，其内部实现是处理本地cookie并设置context，在授权阶段如果发现未认证返回challangeresult，最后由cookiehandler的challanger接管，跳转未认证页面，类似的oidc差别不大，它在认证阶段发生跳转，跳转到我们在options指定的地址，并完成认证，想要更多了解aspnetcore认证机制请参考我前面的文章，记得推介呵呵。下面我们看下授权策略怎么应用。

// homecontroller
public class HomeController : Controller
    {
        // 其他成员
 
        public IActionResult Index()
        {
            var user = User.Identity;
            return View();
        }
        // 没什么特别的，其实就是aspnetcore内置那套策略机制
        [Authorize(Policy = "FamilyNamePolicy")]
        public IActionResult Privacy()
        {
            return View();
        }
    }
 
// 自定义策略规则
public class NameHandler : AuthorizationHandler<NameRequirement >
    {
        // 自定义策略处理器
        protected override Task HandleRequirementAsync(AuthorizationHandlerContext  context,
            NameRequirement  requirement)
        {
            var familyName = context.User.Claims.FirstOrDefault(c => c.Type ==  JwtClaimTypes.FamilyName)?.Value;
            if (familyName == "demo" && context.User.Identity.IsAuthenticated) // 规则为claim familyname为demo&为登录用户
            {
                context.Succeed(requirement);
                return Task.CompletedTask;
            }
            context.Fail();
            return Task.CompletedTask;
        }
    }

早期版本我们在做授权的时候一般是基于角色，就灵活性而已，策略更具灵活性，目前是aspnetcore授权主流。说完策略授权之后，我们简单来看下accesstoken过期的刷新的问题。

// 刷新accesstoken
private async Task GetNewTokensAsync()
        {
            var client = new HttpClient();
            var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
            if (disco.IsError)
            { }
            var refreshToken = await HttpContext.GetTokenAsync(OpenIdConnectParameterNames.RefreshToken);
            // 获取新的token，包含idtoken accesstoken referencetoken等信息
            var tokenResponse = await client.RequestRefreshTokenAsync(new  RefreshTokenRequest
            {
                Address = disco.TokenEndpoint,
                ClientId = "hybrid client mvc",
                ClientSecret = "hybrid secret",
                Scope = "api1 openid profile email phone address names",
                GrantType = OpenIdConnectGrantTypes.RefreshToken,
                RefreshToken = refreshToken
            });
            if (tokenResponse.IsError)
            { }
            // 刷新过期时间
            var expiresAt = DateTime.UtcNow +  TimeSpan.FromSeconds(tokenResponse.ExpiresIn);
            var tokens = new[]
            {
                new AuthenticationToken
                {
                    Name = OpenIdConnectParameterNames.IdToken,
                    Value = tokenResponse.IdentityToken
                },
                new AuthenticationToken
                {
                    Name = OpenIdConnectParameterNames.AccessToken,
                    Value = tokenResponse.AccessToken
                },
                new AuthenticationToken
                {
                    Name = OpenIdConnectParameterNames.RefreshToken,
                    Value = tokenResponse.RefreshToken
                },
                new AuthenticationToken
                {
                    Name = "expires_at",
                    Value = expiresAt.ToString("o", CultureInfo.InvariantCulture)
                }
            };
            // 本地重新cookie认证
            var currentAuthenticateResult =
                await  HttpContext.AuthenticateAsync(CookieAuthenticationDefaults.AuthenticationScheme);
            // 本地存储token
            currentAuthenticateResult.Properties.StoreTokens(tokens);
            // 重新登录
             await  HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme,
                currentAuthenticateResult.Principal,  currentAuthenticateResult.Properties);
            return;
        }

最后我们来看下api资源的代码。

 

API受保护的资源

// startup启动类
public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
            services.AddMvcCore()
            .AddAuthorization()
            .AddJsonFormatters();
             services.AddAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme)
                .AddIdentityServerAuthentication(options => // 之前这个地方是jwtbeare，我猜只是ids4的扩展方法对jwtbeare换了个马甲，后续源码分析会介绍
                {
                    options.Authority = "http://localhost:5000"; // ids4 base基地址
                    options.ApiName = "api1"; // 刷新token需要提供api名称
                    options.RequireHttpsMetadata = false;
                    options.ApiSecret = "api1 secret"; // 需要刷新token ids4需要提供secret
                    options.JwtValidationClockSkew = TimeSpan.FromMinutes(1); // 检查时间，也就是api到ids4token验证时间间隔
                });
            services.AddMemoryCache();
        }
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            // 注册中间件 
            app.UseAuthentication();
            app.UseMvc();
        }

 ClientCredentials & HybridFlow认证流程的两个实例到此就全部介绍完毕，Fiddler监控图片我就比贴了，自行看下OAuth2和OIDC协议就行，请求和响应都是严格按照这两协议来实现的，接下来做个简单的总结吧。从ClientCredentials & HybridFlow这两个实例代码来看，其代码本身并不复杂，只需一些简单配置即可。IDS4遵循和实现了OAuth2 & OIDC大部协议，如果想要更好的理解IDS4源代码，首先建议看下OAUTH2和OIDC的一些协议规范，其次就是自身平台的认证授权系统，比如如果我的client或者api是netframework | netcore，那我们就需要熟悉这个平台自身的认证授权系统，其他异构平台均一样。最后一个环节，ids4源码分析。

 

IDS4源码分析

我个人在看netcore平台上面源码的时候，首先就是找到starpup启动类，然后找到对应的Middleware中间件，在IDS4这个框架里边有一个叫IdentityServerMiddleware的这么一个中间件，其实它就是我们要找的这个中间件，ids4认证授权的入口。下面我们看下它的定义。

public class IdentityServerMiddleware
    {
        // 其他成员...
        public IdentityServerMiddleware(RequestDelegate next,  ILogger<IdentityServerMiddleware> logger)
        {
            _next = next;
            _logger = logger;
        }
        
        public async Task Invoke(HttpContext context, IEndpointRouter router, IUserSession  session, IEventService events)
        {
            // 从本地cookie读取认证信息，如果以认证直接设置请求上下文
            await session.EnsureSessionIdCookieAsync();
            try
            {
                // 这个地方我们把它理解为请求路由查找对应的endpoint端点，有点类似拦截，因为如果匹配到请求地址，endpoint端点处理完之后直接response
                var endpoint = router.Find(context);
                if (endpoint != null)
                {
                    // 如果匹配到由端点处理，比如我们上面介绍的tokenendpoint在处理完请求之后直接通过executeasync把accesstoken等信息直接写入response
                    var result = await endpoint.ProcessAsync(context);
                    if (result != null)
                    {
                        // 写入response
                        await result.ExecuteAsync(context);
                    }
 
                    return;
                }
            }
            catch (Exception ex)
            {
                await events.RaiseAsync(new UnhandledExceptionEvent(ex));
                _logger.LogCritical(ex, "Unhandled exception: {exception}", ex.Message);
                throw;
            }
 
            // 如果未被路由端点匹配，传递到下一个中间件。
            await _next(context);
        }
    }

从IdentityServerMiddleware中间件的定义来看，特别的地方就是这些端点以及它们的处理，我们的OAuth2 & OIDC 的大部分协议就实现在这里边，接下来我们看看具体有哪些端点？在startup的configureservices方法里边，注入了这么一个方法叫addidentityserver，在这个扩展方法里面注入了端点，看代码。

// 注入平台默认的端点
public static IIdentityServerBuilder AddDefaultEndpoints(this IIdentityServerBuilder  builder)
        {
            builder.Services.AddTransient<IEndpointRouter, EndpointRouter>();
            builder.AddEndpoint<AuthorizeCallbackEndpoint>(EndpointNames.Authorize,  ProtocolRoutePaths.AuthorizeCallback.EnsureLeadingSlash());
            builder.AddEndpoint<AuthorizeEndpoint>(EndpointNames.Authorize,  ProtocolRoutePaths.Authorize.EnsureLeadingSlash());
            builder.AddEndpoint<CheckSessionEndpoint>(EndpointNames.CheckSession,  ProtocolRoutePaths.CheckSession.EnsureLeadingSlash());
             builder.AddEndpoint<DeviceAuthorizationEndpoint>(EndpointNames.DeviceAuthorization,  ProtocolRoutePaths.DeviceAuthorization.EnsureLeadingSlash());
            builder.AddEndpoint<DiscoveryKeyEndpoint>(EndpointNames.Discovery,  ProtocolRoutePaths.DiscoveryWebKeys.EnsureLeadingSlash());
            builder.AddEndpoint<DiscoveryEndpoint>(EndpointNames.Discovery,  ProtocolRoutePaths.DiscoveryConfiguration.EnsureLeadingSlash());
            builder.AddEndpoint<EndSessionCallbackEndpoint>(EndpointNames.EndSession,  ProtocolRoutePaths.EndSessionCallback.EnsureLeadingSlash());
            builder.AddEndpoint<EndSessionEndpoint>(EndpointNames.EndSession,  ProtocolRoutePaths.EndSession.EnsureLeadingSlash());
            builder.AddEndpoint<IntrospectionEndpoint>(EndpointNames.Introspection,  ProtocolRoutePaths.Introspection.EnsureLeadingSlash());
            builder.AddEndpoint<TokenRevocationEndpoint>(EndpointNames.Revocation,  ProtocolRoutePaths.Revocation.EnsureLeadingSlash());
            builder.AddEndpoint<TokenEndpoint>(EndpointNames.Token,  ProtocolRoutePaths.Token.EnsureLeadingSlash());
            builder.AddEndpoint<UserInfoEndpoint>(EndpointNames.UserInfo,  ProtocolRoutePaths.UserInfo.EnsureLeadingSlash());
            return builder;
        }

OAuth2协议里边定义的端点，大部分都在这里，tokenendpoint、authorizeendpoint等等还有oidc协议里边的userinfoendpoint等，接下来我们就从里面挑一两个详细介绍。

 

TokenEndPoint端点

TokenEndPoint端点就是我们那些token的生成都是由它来完成的，老套路，先看定义。

internal class TokenEndpoint : IEndpointHandler
    {
        private readonly IClientSecretValidator _clientValidator;
        private readonly ITokenRequestValidator _requestValidator;
        private readonly ITokenResponseGenerator _responseGenerator;
        private readonly IEventService _events;
        private readonly ILogger _logger;
        
        // 其他成员...
        
        public TokenEndpoint(
            IClientSecretValidator clientValidator,
            ITokenRequestValidator requestValidator,
            ITokenResponseGenerator responseGenerator,
            IEventService events,
            ILogger<TokenEndpoint> logger)
        {
            _clientValidator = clientValidator;
            _requestValidator = requestValidator;
            _responseGenerator = responseGenerator;
            _events = events;
            _logger = logger;
        }
      
        // tokenendpoint端点处理请求入口方法
        public async Task<IEndpointResult> ProcessAsync(HttpContext context)
        {
           
            // 首先验证http操作，非post 表单提交直接返回错误
            if (!HttpMethods.IsPost(context.Request.Method) ||  !context.Request.HasFormContentType)
            {
                _logger.LogWarning("Invalid HTTP request for token endpoint");
                return Error(OidcConstants.TokenErrors.InvalidRequest);
            }
            // 进一步验证
            return await ProcessTokenRequestAsync(context);
        }
 
        private async Task<IEndpointResult> ProcessTokenRequestAsync(HttpContext context)
        {
            // 首先验证client 就是oauth2协议里边定义的clientid secret等
            var clientResult = await _clientValidator.ValidateAsync(context);
            if (clientResult.Client == null) // 如果验证未通过直接返回invalidclient
            {
                return Error(OidcConstants.TokenErrors.InvalidClient);
            }
            var form = (await context.Request.ReadFormAsync()).AsNameValueCollection();
            _logger.LogTrace("Calling into token request validator: {type}",  _requestValidator.GetType().FullName);
            // 然后验证请求参数，这些参数可以查看OAuth2，根据不同的GrantType启动不同的验证规则，并且生成AuthorizationCode
            var requestResult = await _requestValidator.ValidateRequestAsync(form,  clientResult);
            if (requestResult.IsError)
            {
                await _events.RaiseAsync(new TokenIssuedFailureEvent(requestResult));
                return Error(requestResult.Error, requestResult.ErrorDescription,  requestResult.CustomResponse);
            }
            // create response
            _logger.LogTrace("Calling into token request response generator: {type}",  _responseGenerator.GetType().FullName);
            // 生成accesstoken，如果有需要还会生成refencetoken id token等
            var response = await _responseGenerator.ProcessAsync(requestResult);
            await _events.RaiseAsync(new TokenIssuedSuccessEvent(response,  requestResult));
            LogTokens(response, requestResult);
            // return result
            _logger.LogDebug("Token request success.");
            // 返回
            return new TokenResult(response);
        }
    }

接下来我们看看client的验证规则，client的验证规则由IClientSecretValidator接口实现，下面我们看下它的定义。

public interface IClientSecretValidator
    {
        // 验证
        Task<ClientSecretValidationResult> ValidateAsync(HttpContext context);
    }

就干一件事验证。它的具体实现由它子类ClientSecretValidator完成。我们继续看。

public class ClientSecretValidator : IClientSecretValidator
    {
       // 其他成员...
        public ClientSecretValidator(IClientStore clients, SecretParser parser,  SecretValidator validator, IEventService events, ILogger<ClientSecretValidator> logger)
        {
            _clients = clients;
            _parser = parser;
            _validator = validator;
            _events = events;
            _logger = logger;
        }
        // client验证实现
        public async Task<ClientSecretValidationResult> ValidateAsync(HttpContext context)
        {
            _logger.LogDebug("Start client validation");
            var fail = new ClientSecretValidationResult
            {
                IsError = true
            };
            // 默认预设4种parser，这里为PostBodySecretParser，验证context form是否包含clien secret
            var parsedSecret = await _parser.ParseAsync(context);
            if (parsedSecret == null)
            {
                await RaiseFailureEventAsync("unknown", "No client id found");
                _logger.LogError("No client identifier found");
                return fail;
            }
            // 从内存或者其他存储介质通过id获取client，默认是内存里面加载，如果未重写资源存储
            var client = await _clients.FindEnabledClientByIdAsync(parsedSecret.Id);
            if (client == null)
            {
                await RaiseFailureEventAsync(parsedSecret.Id, "Unknown client");
                _logger.LogError("No client with id '{clientId}' found. aborting",  parsedSecret.Id);
                return fail;
            }
            SecretValidationResult secretValidationResult = null;
            if (!client.RequireClientSecret || client.IsImplicitOnly())
            {
                _logger.LogDebug("Public Client - skipping secret validation success");
            }
            else
            {
                secretValidationResult = await _validator.ValidateAsync(parsedSecret,  client.ClientSecrets);
                if (secretValidationResult.Success == false)
                {
                    await RaiseFailureEventAsync(client.ClientId, "Invalid client  secret");
                    _logger.LogError("Client secret validation failed for client:  {clientId}.", client.ClientId);
                    return fail;
                }
            }
            _logger.LogDebug("Client validation success");
            // 返回clientresult这么一个对象    
            var success = new ClientSecretValidationResult
            {
                IsError = false,
                Client = client,
                Secret = parsedSecret,
                Confirmation = secretValidationResult?.Confirmation
            };
            await RaiseSuccessEventAsync(client.ClientId, parsedSecret.Type);
            return success;
        }
    }

认证完client之后，接着验证request请求，request请求被定义在接口ITokenRequestValidator这个接口里面，我们看看它的定义。

  

 public interface ITokenRequestValidator
    {
        
        Task<TokenRequestValidationResult> ValidateRequestAsync(NameValueCollection  parameters, ClientSecretValidationResult clientValidationResult);
    }

这个接口办事也是非常专一的，就这么一个方法，接下来我们看看它的实现类 TokenRequestValidator。

internal class TokenRequestValidator : ITokenRequestValidator
    {
                // 其他代码
        public async Task<TokenRequestValidationResult> ValidateRequestAsync(NameValueCollection parameters, ClientSecretValidationResult clientValidationResult)
        {
            
            _validatedRequest = new ValidatedTokenRequest
            {
                Raw = parameters ?? throw new ArgumentNullException(nameof(parameters)),
                Options = _options
            };
 
            if (clientValidationResult == null) throw new ArgumentNullException(nameof(clientValidationResult));
 
            _validatedRequest.SetClient(clientValidationResult.Client, clientValidationResult.Secret, clientValidationResult.Confirmation);
            // 验证protocoltype是发oidc
            if (_validatedRequest.Client.ProtocolType != IdentityServerConstants.ProtocolTypes.OpenIdConnect)
            {
                LogError("Invalid protocol type for client",
                    new
                    {
                        clientId = _validatedRequest.Client.ClientId,
                        expectedProtocolType = IdentityServerConstants.ProtocolTypes.OpenIdConnect,
                        actualProtocolType = _validatedRequest.Client.ProtocolType
                    });
 
 
                return Invalid(OidcConstants.TokenErrors.InvalidClient);
            }
                        
                        // grantType是否为空
            var grantType = parameters.Get(OidcConstants.TokenRequest.GrantType);
            if (grantType.IsMissing())
            {
                LogError("Grant type is missing");
                return Invalid(OidcConstants.TokenErrors.UnsupportedGrantType);
            }
            // 验证granttype字符串长度
            if (grantType.Length > _options.InputLengthRestrictions.GrantType)
            {
                LogError("Grant type is too long");
                return Invalid(OidcConstants.TokenErrors.UnsupportedGrantType);
            }
 
            _validatedRequest.GrantType = grantType;
            // 根据不同的granttype，执行指定的验证规则
            switch (grantType)
            {
                case OidcConstants.GrantTypes.AuthorizationCode:
                    return await RunValidationAsync(ValidateAuthorizationCodeRequestAsync, parameters);
                case OidcConstants.GrantTypes.ClientCredentials:
                    return await RunValidationAsync(ValidateClientCredentialsRequestAsync, parameters);
                case OidcConstants.GrantTypes.Password:
                    return await RunValidationAsync(ValidateResourceOwnerCredentialRequestAsync, parameters);
                case OidcConstants.GrantTypes.RefreshToken:
                    return await RunValidationAsync(ValidateRefreshTokenRequestAsync, parameters);
                case OidcConstants.GrantTypes.DeviceCode:
                    return await RunValidationAsync(ValidateDeviceCodeRequestAsync, parameters);
                default:
                    return await RunValidationAsync(ValidateExtensionGrantRequestAsync, parameters);
            }
        }
 
    }

TokenRequestValidator代码比较多，我删掉了大部分，都是验证相关的。接下来我们看看AuthorizationCode具体的验证。

private async Task<TokenRequestValidationResult> RunValidationAsync(Func<NameValueCollection, Task<TokenRequestValidationResult>> validationFunc, NameValueCollection parameters)
        {
            // 还是验证，包括AllowedGrantTypes 生成code等等，具体就不贴代码了。
            var result = await validationFunc(parameters);
            if (result.IsError)
            {
                return result;
            }
 
            // run custom validation
            _logger.LogTrace("Calling into custom request validator: {type}", _customRequestValidator.GetType().FullName);
 
            // 自定义验证，验证到天荒地老，还好默认没有实现。
            var customValidationContext = new CustomTokenRequestValidationContext { Result = result };
            await _customRequestValidator.ValidateAsync(customValidationContext);
 
            if (customValidationContext.Result.IsError)
            {
                if (customValidationContext.Result.Error.IsPresent())
                {
                    LogError("Custom token request validator", new { error = customValidationContext.Result.Error });
                }
                else
                {
                    LogError("Custom token request validator error");
                }
 
                return customValidationContext.Result;
            }
 
            LogSuccess();
            return customValidationContext.Result;
        }

终于验证完了，接下来我们看看验证返回的TokenRequestValidationResult这个对象。

public class TokenRequestValidationResult : ValidationResult
    {
       // 其他代码...
                // 这个属性就包含了前面疯狂验证的那些参数
        public ValidatedTokenRequest ValidatedRequest { get; }
 
        public Dictionary<string, object> CustomResponse { get; set; }
    }

疯狂验证完之后就返回这么一个对象TokenRequestValidationResult，里面囊括了所有request这些验证过的参数还有个response字典。验证完之后，包括一些初始化完成之后，接下来就是创建response了。response的创建是由具有这么一个定义的接口ITokenResponseGenerator实现。

  

 public interface ITokenResponseGenerator
    {
        Task<TokenResponse> ProcessAsync(TokenRequestValidationResult validationResult);
    }

比较低调，就一个方法。我们来看下它的实现类TokenResponseGenerator。

public class TokenResponseGenerator : ITokenResponseGenerator
    {
        // 其他代码...
        public virtual async Task<TokenResponse> ProcessAsync(TokenRequestValidationResult  request)
        {
            switch (request.ValidatedRequest.GrantType)
            {
                case OidcConstants.GrantTypes.ClientCredentials:
                    return await ProcessClientCredentialsRequestAsync(request);
                case OidcConstants.GrantTypes.Password:
                    return await ProcessPasswordRequestAsync(request);
                case OidcConstants.GrantTypes.AuthorizationCode:
                    return await ProcessAuthorizationCodeRequestAsync(request);
                case OidcConstants.GrantTypes.RefreshToken:
                    return await ProcessRefreshTokenRequestAsync(request);
                case OidcConstants.GrantTypes.DeviceCode:
                    return await ProcessDeviceCodeRequestAsync(request);
                default:
                    return await ProcessExtensionGrantRequestAsync(request);
            }
        }
    }

这个类里面代码量也不小，其他我都删掉了，就留下这个入口方法ProcessAsync。接下来我们看看ProcessAuthorizationCodeRequestAsync方法的实现。

protected virtual async Task<TokenResponse>  ProcessAuthorizationCodeRequestAsync(TokenRequestValidationResult request)
        {
                        // 生成accesstoken机制，时间比较晚了，生成代码我就不贴了，我大概说下逻辑吧，jwt为列，header部分不用说，ploay部分是Claim身份声明信息，签名部分由rsa私钥做的签名，
            // refreshtoken 如果配置需要生成，则生成，配置要求我在实例里面已经注释了。
            (var accessToken, var refreshToken) = await  CreateAccessTokenAsync(request.ValidatedRequest);
            var response = new TokenResponse
            {
                AccessToken = accessToken,
                AccessTokenLifetime = request.ValidatedRequest.AccessTokenLifetime,
                Custom = request.CustomResponse,
                Scope =  request.ValidatedRequest.AuthorizationCode.RequestedScopes.ToSpaceSeparatedString(),
            };
                        // 如果需要生成refreshtoken就设置值
            if (refreshToken.IsPresent())
            {
                response.RefreshToken = refreshToken;
            }
                        // AuthorizationCode授权的生成idtoken，包括Hybridflow等
            if (request.ValidatedRequest.AuthorizationCode.IsOpenId)
            {
                Client client = null;
                if (request.ValidatedRequest.AuthorizationCode.ClientId != null)
                {
                    client = await  Clients.FindEnabledClientByIdAsync(request.ValidatedRequest.AuthorizationCode.ClientId);
                }
                if (client == null)
                {
                    throw new InvalidOperationException("Client does not exist anymore.");
                }
                var resources = await  Resources.FindEnabledResourcesByScopeAsync(request.ValidatedRequest.AuthorizationCode.RequestedScopes);
                var tokenRequest = new TokenCreationRequest
                {
                    Subject = request.ValidatedRequest.AuthorizationCode.Subject,
                    Resources = resources,
                    Nonce = request.ValidatedRequest.AuthorizationCode.Nonce,
                    AccessTokenToHash = response.AccessToken,
                    ValidatedRequest = request.ValidatedRequest
                };
                var idToken = await TokenService.CreateIdentityTokenAsync(tokenRequest);
                var jwt = await TokenService.CreateSecurityTokenAsync(idToken);
                response.IdentityToken = jwt;
            }
            // 返回response
            return response;
        }

response生成完之后，通过TokenResult包装并返回，接下来我们看看TokenResult对象的定义。

internal class TokenResult : IEndpointResult
    {
        public TokenResponse Response { get; set; }
        public TokenResult(TokenResponse response)
        {
            if (response == null) throw new ArgumentNullException(nameof(response));
            Response = response;
        }
                // 把tokenresponse写入context输出流，json格式
        public async Task ExecuteAsync(HttpContext context)
        {
            context.Response.SetNoCache();
            var dto = new ResultDto
            {
                id_token = Response.IdentityToken,
                access_token = Response.AccessToken,
                refresh_token = Response.RefreshToken,
                expires_in = Response.AccessTokenLifetime,
                token_type = OidcConstants.TokenResponse.BearerTokenType,
                scope = Response.Scope
            };
            if (Response.Custom.IsNullOrEmpty())
            {
                await context.Response.WriteJsonAsync(dto);
            }
            else
            {
                var jobject = ObjectSerializer.ToJObject(dto);
                jobject.AddDictionary(Response.Custom);
                await context.Response.WriteJsonAsync(jobject);
            }
        }
                // ids4的团队也有点随意啊。 
        internal class ResultDto
        {
            public string id_token { get; set; }
            public string access_token { get; set; }
            public int expires_in { get; set; }
            public string token_type { get; set; }
            public string refresh_token { get; set; }
            public string scope { get; set; }
        }
    }

到此，这篇随笔算是写完了。

最后来个大总结吧，还是那句话，ids4本身代码不是那么的复杂，前提是其一要对OAuth2 & OIDC协议有所了解，虽然是英文版本的没关系，我英语也相当差，不是有有道吗？而且自己多少也认识几个单词啊。其二自身平台的认证授权机制要比较熟悉，毕竟跟ids4有太多的交互，而且安全要求也比较高，本来打算还讲下扩展资源存储到sqlserver或者mysql，时间太晚了，明天还要上班不写了，下个月见。谢谢各位看官支持， 有帮到你请点个推介，要求不高呵呵，谢谢。