Identity Server4 笔记

文章目录

• • 一.角色
  • • • 1.身份认证服务器
      • 2.用户
      • 3.客户端
      • 4. 资源
      • 5.Identity Token（身份令牌）
      • 6.Access Token（访问令牌）
  • 二.客户端凭据的认证方式
  • • • 1.建立 IdentityServer4
      • 2.建立受保护的API
  • 4.保护WPF客户端
  • • • 1.流程
      • 2.为MVC刷新 token
      • • • 1.在MVC 客户端进行设置
          • 2.对受保护的 API进行设置
          • 3.刷新 Token
  • 5.Implicit Flow
  • 6. Hybrid Flow
  • • • 1.客户端类型
      • 2.返回类型
      • 3.角色和策略
      • • 3.1基于角色
        • 3.2基于策略
      • 4.使用混合流保护客户端
  • 参考文献

---

一.角色

1.身份认证服务器

简而言之，他就是一个向客户端发送安全令牌的软件。

身份认证服务器的主要功能

• 保护您的资源
• 使用本地帐户存储或通过外部身份提供商对用户进行身份验证（例如微信登录）
• 提供会话管理和单点登录
• 管理和认证客户
• 向客户端发布身份和访问令牌
• 验证令牌

主要支持的协议

• OpenID Connect
• OAuth 2.0

2.用户

使用客户端的人

3.客户端

客户端是一种从IdentityServer请求令牌的软件-用于认证用户（请求身份令牌）或访问资源（请求访问令牌）。客户端必须先向授权服务器注册，然后才能请求令牌。

客户端可以是 web 应用程序，或者桌面应用程序，或移动程序

4. 资源

ID4 要保护的 API 或 身份数据 （因为我主要是webapi，所以后边主要使用 webapi 举例子）
每一个 API 都有一个独一无二的名字，客户端使用这个名字来指定他要访问的是哪个 API。

5.Identity Token（身份令牌）

表示身份认证完成后的结果

他至少包括用户的身份信息，什么时候和怎么样去使用权限。

6.Access Token（访问令牌）

Access Token 是用来获取 API 的。客户端接受 access token，并将将她专送给 受保护的 API。

Access Token 里面包含客户端和使用者的信息（如果有的话），

如何理解 Identity token 和 Access Token 的关系？
可以把 Identity token 想象成在门卫那里领到的，证明你身份的条，而 Access Token是你可以 要进入 API 的钥匙 。(这是我自己的理解，不一定准确)

id4官方给的例子 https://demo.identityserver.io/

网址 https://gitee.com/rush_peng/identity-server4-example.git

---

二.客户端凭据的认证方式

没有用户参与的程序。使用的是 Client Credentials（客户端证书）这种授权方式。

里面用到的三个项目的 nuget 包是不一样的。

• IdentityServer ： IdentityServer4
• API ：JwtBearer （解析jwt文件）
• Client ： IdentityModel （方便寻找 identityserver 的 api 接口的）

1.建立 IdentityServer4

1.用类的方式，声明配置文佳

 public static class Config
    {
        //定义API
        public static IEnumerable<ApiScope> ApiScopes =>
            new List<ApiScope>
            {
                  new ApiScope("api1", "My API")
            };


        //定义客户端

        // 定义访问 API 的客户端应用
        // 这种情况下，客户端没有交互式的用户，只能通过客户端密钥进行身份验证。

        // ClientId 和 Client Secret 可以视为登录名和密码。让身份认证服务器知道是哪个用户。
        public static IEnumerable<Client> Clients => new List<Client>
         {
        new Client
        {
            // 定义一个客户端
            ClientId = "client",

            // 认证类型。
            //使用客户端密钥的方式进行验证。

            AllowedGrantTypes = GrantTypes.ClientCredentials,

            // 认证的密码
            ClientSecrets =
            {
                new Secret("secret".Sha256())
            },
            // 这个客户端端可以访问的 API
            AllowedScopes = { "api1" }
        }
    };

2.在 Startup 里面做调用设置

  public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
              services.AddControllers();
            var builder = services.AddIdentityServer()
                  .AddInMemoryApiScopes(Config.ApiScopes) // 那个api可以使用
                  .AddInMemoryClients(Config.Clients)// 哪个client可以使用
                  .AddDeveloperSigningCredential() ;//解决连接不上的问题，实际中，签名需要一对公钥和私钥，他会帮我们将公钥和私钥存储到硬盘上
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            app.UseRouting();
            app.UseIdentityServer();//使用 Identity 4

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }

重生成，而使用命令行运行一下

dotnet … --urls http://*:5001

2.建立受保护的API

1.建立要访问受保护的 Action

    [ApiController]
    public class IdentityController : ControllerBase
    {
        [HttpGet("identity")]
        [Authorize]
        public IActionResult Get()
        {
            return new JsonResult(from c in User.Claims select new { c.Type, c.Value });
        }

        [Authorize]
        [HttpGet("test")]
        public string Getst()
        {
            return "受保护的 API 访问成功";
        }
    }

2.在startup 里面进行配置

  public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();

            //接受授服务器发送的任何访问令牌。
            services.AddAuthentication("Bearer")
           .AddJwtBearer("Bearer", options =>
           {
               options.Authority = "https://localhost:5001";

               options.TokenValidationParameters = new TokenValidationParameters
               {
                   ValidateAudience = false
               };
           });

           // 允许检测客户端请求的令牌中是否存在作用域
            services.AddAuthorization(options =>
            {
                options.AddPolicy("ApiScope", policy =>
                {
                    policy.RequireAuthenticatedUser();
                    policy.RequireClaim("scope", "api1");
                });
            });
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();
            app.UseAuthentication();//每次都要执行身份验证.
            app.UseAuthorization(); //授权，确保匿名客户端无法访问我们的 api 端点

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }

3.建立用来访问的客户端

  public class Program
    {
  
        // IdentityModel包括一个与发现端点一起使用的客户端库。这样，您只需要知道IdentityServer的基地址-可以从元数据中读取实际的端点地址：
      
        //找到授权的服务器
        public static async System.Threading.Tasks.Task Main(string[] args)
        {

            //找到授权服务器
            var client = new HttpClient();
            var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5001");  //异步的方法名前边必须声明 async
            if (disco.IsError)
            {
                Console.WriteLine($"连接失败****{disco.Error}");
                return;
            }


            //向授权服务器请求 token
            var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
            {
                Address = disco.TokenEndpoint,

                ClientId = "client",
                ClientSecret = "secret",
                Scope = "api1"
            });
            if (tokenResponse.IsError)
            {
                Console.WriteLine("token返回错误", tokenResponse.Error);
                return;
            }
            Console.WriteLine(tokenResponse.Json);


            //将访问令牌发送给 API
            var apiClient = new HttpClient();
            apiClient.SetBearerToken(tokenResponse.AccessToken);

            var response = await apiClient.GetAsync("http://localhost:6001/test");
            if (!response.IsSuccessStatusCode)
            {
                Console.WriteLine(response.StatusCode);
                Console.WriteLine("访问失败");
            }
            else
            {
                var content = await response.Content.ReadAsStringAsync();
                Console.WriteLine("访问成功");
                // Console.WriteLine(JArray.Parse(content));
                Console.WriteLine(content);
            }

            Console.ReadLine();
        }

具体查看gitee代码：

4.保护WPF客户端

这种是有用户参与的，使用的是 Password Grant （用名名密码）这种授权方式。

1.流程

运行的顺序和字母的顺序是一致的：

• 浏览器要将请求传到用户代理
• 用户代理再连接 身份认证服务器，并将返回信息返回给用户代理，由用户决定要不要授权。
• 如果用户点了同意，那么，用户代理 就会再跳回浏览器，并带有 Authorization Code 。
• 然后浏览器带着 Authorization code 到 身份认证服务器。请求 access token。

所以在这个过程之中，即对用户进行身份认证，也对浏览器进行身份认证。

具体操作看代码吧。我也没用过MVC

2.为MVC刷新 token

使用 Refresh Token 刷新 Access Token。

1.在MVC 客户端进行设置

 new Client
                {
                    ClientId = "mvc client",
                    ClientName = "ASP.NET Core MVC Client", // 随便写

                    AllowedGrantTypes = GrantTypes.CodeAndClientCredentials,//允许两种授权方式.
                    ClientSecrets = { new Secret("mvc secret".Sha256()) },//密码.


                    //下边都是固定的地址。
                    RedirectUris = { "http://localhost:5002/signin-oidc" },
                    FrontChannelLogoutUri = "http://localhost:5002/signout-oidc",
                    PostLogoutRedirectUris = 
                    { "http://localhost:5002/signout-callback-oidc" },
                    
                    AlwaysIncludeUserClaimsInIdToken = true,

                    AllowOfflineAccess = true, // offline_access

                    //默认是一个小时。现在改成 60s 。
                    AccessTokenLifetime = 60, // 60 seconds

                    AllowedScopes =
                    {
                        "api1",
                        IdentityServerConstants.StandardScopes.OpenId,
                        IdentityServerConstants.StandardScopes.Email,
                        IdentityServerConstants.StandardScopes.Address,
                        IdentityServerConstants.StandardScopes.Phone,
                        IdentityServerConstants.StandardScopes.Profile
                    }
                },

但是仅仅这样设置，过了一分钟以后，进入 MVC ，依然还能得到 API 的相关信息 。这是因为我们的 API 没有设置对于 对于token检验。

2.对受保护的 API进行设置

        services.AddAuthentication("Bearer")//bearer 的授权方式。
                .AddJwtBearer("Bearer", options =>
                {
                    options.Authority = "https://localhost:5000";
                    
                    options.RequireHttpsMetadata = false;//不需要https

                    options.TokenValidationParameters = new         TokenValidationParameters
                    {
                        ValidateAudience = false
                    };

                    //每隔一分钟，验证一次这个token
                    options.TokenValidationParameters.RequireExpirationTime = true;
                    
                    //必须要有超时时间这个参数。
                    options.TokenValidationParameters.ClockSkew = TimeSpan.FromMinutes(1);

                });

3.刷新 Token

在 MVC 的控制器里面，再添加一个 action ，用来刷新 Token。

   //刷新 token
        private async Task<string> RenewTokensAsync()
        {
            //发现文档
            var client = new HttpClient();
            var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
            if (disco.IsError)
            {
                throw new Exception(disco.Error);
            }


            //获取 refreshToken
            var refreshToken = await HttpContext.GetTokenAsync(OpenIdConnectParameterNames.RefreshToken);

            //请求token
            var tokenResponse = await client.RequestRefreshTokenAsync(new RefreshTokenRequest
            {
                Address = disco.TokenEndpoint,
                ClientId = "mvc client",
                ClientSecret = "mvc secret",
                Scope = "api1 openid profile email phone address",
                GrantType = OpenIdConnectGrantTypes.RefreshToken,
                RefreshToken = refreshToken
            });

            if (tokenResponse.IsError)
            {
                throw new Exception(tokenResponse.Error);
            }

            //超时时间，使用的是 UTC 时间。
            var expiresAt = DateTime.UtcNow + TimeSpan.FromSeconds(tokenResponse.ExpiresIn);

            // 把 token 数组全部集中起来，做成一个数组。
            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)
                }
            };

            // 获取身份认证的结果，包含当前的pricipal和properties
            var currentAuthenticateResult =
                await HttpContext.AuthenticateAsync(CookieAuthenticationDefaults.AuthenticationScheme);

            // 把获得的token再更新一遍。
            currentAuthenticateResult.Properties.StoreTokens(tokens);

            // 再进行以下登录动作.
            await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme,
                currentAuthenticateResult.Principal, currentAuthenticateResult.Properties);
            // 再把 access token 返回过去.
            return tokenResponse.AccessToken;
        }

在前边用到token的地方，再更新一下这个方法：

 var response = await client.GetAsync("http://localhost:5001/identity");
            if (!response.IsSuccessStatusCode)
            {
                if (response.StatusCode == HttpStatusCode.Unauthorized)
                {
                    await RenewTokensAsync();
                    return RedirectToAction();
                }

                throw new Exception(response.ReasonPhrase);
            }

5.Implicit Flow

• 用于公共客户端 ，比如用 Angular 这种做的。CS 的文件。如果有些保密文件，可以很容易的获取。
• 最好是客户端可以直接从浏览器 访问资源。
• 没有显示的客户端身份认证。
  
  

6. Hybrid Flow

• 访问被保护资源
• 刷新 Access Token
• 处理 Claims
• 基于策略的权限

使用 Hybrid 保护 api 资源。

之前使用的 OpenId Connect 隐式流，所有的令牌都是通过浏览器来传输，这对于 ID token 来说当然没有问题，但是我们还想请求一个 access token，accesstoken 更加敏感，所以在没有必要的时候，我们不会想把他暴露给外部世界， OpenID Connect 包含了一个叫做 “混合流（Hybrid flowe）”，它为我们提供了两方面的优点，身份令牌通过浏览器频道来传输，这样客户端就能能够在做任何工作前验证他，如果验证成功，客户端就会打开一个后端通道，来链接令牌，以检索访问令牌。

1.客户端类型

1. 机密客户端：这种客户端有能力维护其凭据的机密性。位于服务端，例如服务器端的 Web 应用，例如 MVC。
2. 公开客户端：这种客户端无法维持其凭据的机密性，位于客户端设备，例如 JS 应用，移动应用，原生应用和软件等。

---

OAuth2.和相比OpenID 就是相当于多出来一个 hybirid Flow

---

---

---

2.返回类型

根据 respons_type 的不同，分为三种情况：

• response_type = code Id_token
• response_type = code token
• response_type = code id_token token

3.角色和策略

• 角色：规定几个角色，然后每个角色里面添加若干个用户。一个用户可以处于不同的角色。
• 通过策略授予权限，可以将多个属性后者

3.1基于角色

---

在注册的用户里面直接声明 管理员角色

使用的时候，直接声明；

       [Authorize(Roles ="管理员，普通用户")]
        [HttpGet("test")]
        public string Getst()
        {
            return "受保护的 API 访问成功";
        }

3.2基于策略

比如：定义把名字为Smith，地址为Somewhere的作为条件。

总的来讲，基于策略的更加的灵活，我们可以自己定义：比如只让 firstname== “ 张 ”的人登录

在客户端声明：

       services.AddAuthorization(options =>
          {
             options.AddPolicy("SmithInSomewhere", builder =>
             {
               builder.RequireAuthenticatedUser();
               builder.RequireClaim(JwtClaimTypes.FamilyName, "Smith");
               builder.RequireClaim("location", "somewhere");
             });  

在API调用

  [Authorize(Policy ="sithInSomewhere")]
        public IActionResult Index()
        {
            var user = User.Identity;
            return View();
        }

4.使用混合流保护客户端

参考文献

[1] Identity4 官方文档
[2] identityserver4
[3] 杨旭视频
[4] identityServer4 中文文档