├── .vscode
    └── settings.json
├── alipay.jpg
├── wechatpay.jpg
├── 第一部分 简介
    ├── 第06章 演示服务器和测试.md
    ├── 第05章 支持和咨询选项.md
    ├── 第02章 术语.md
    ├── 第07章 贡献.md
    ├── 第04章 打包和构建.md
    ├── 第03章 支持和规范.md
    └── 第01章 背景.md
├── 第五部分 参考
    ├── 第57章 GrantValidationResult.md
    ├── 第54章 身份资源.md
    ├── 第60章 设备流交互服务.md
    ├── 第63章 ASP.NET Identity 支持.md
    ├── 第55章  API资源.md
    ├── 第58章 Profile Service.md
    ├── 第59章 IdentityServer交互服务.md
    ├── 第61章 IdentityServer Options.md
    ├── 第56章 Client.md
    └── 第62章 EntityFramework支持.md
├── 第二部分 快速入门
    ├── 第08章 概述.md
    ├── 第17章 社区快速入门和模板.md
    ├── 第12章 添加对外部认证的支持.md
    ├── 第10章 使用密码保护API.md
    ├── 第13章 切换到混合流并添加API访问.md
    ├── 第15章 使用EntityFramework Core进行配置和操作数据.md
    ├── 第16章 使用ASP.NET Core Identity.md
    ├── 第11章 使用OpenID Connect添加用户身份验证.md
    ├── 第09章 使用客户端凭据保护API.md
    └── 第14章 添加JavaScript客户端.md
├── 第三部分 主题
    ├── 第45章 工具.md
    ├── 第37章 资源所有者密码验证(Resource Owner Password Validation).md
    ├── 第38章 刷新令牌.md
    ├── 第40章 自定义令牌请求验证和发布.md
    ├── 第42章 发现(discovery).md
    ├── 第39章 引用令牌.md
    ├── 第26章 联合注销.md
    ├── 第33章 密码学(Cryptography)，密钥(Keys)和HTTPS.md
    ├── 第23章 Windows身份验证.md
    ├── 第28章 确认(Consent).md
    ├── 第43章 添加更多API端点.md
    ├── 第30章 部署.md
    ├── 第31章 日志.md
    ├── 第27章 联合网关.md
    ├── 第41章 CORS.md
    ├── 第25章 退出外部身份提供商.md
    ├── 第44章 添加新协议.md
    ├── 第24章 退出.md
    ├── 第21章 登录.md
    ├── 第20章 定义客户端.md
    ├── 第35章 秘密(secrets).md
    ├── 第19章 定义资源.md
    ├── 第32章 事件.md
    ├── 第36章 扩展授权.md
    ├── 第18章 启动.md
    ├── 第34章 授予类型.md
    ├── 第29章 保护API.md
    └── 第22章 使用外部身份提供商登录.md
├── 第四部分 端点
    ├── 第46章 发现端点(Discovery Endpoint).md
    ├── 第52章 撤销端点(Revocation Endpoint).md
    ├── 第48章 UserInfo端点(UserInfo Endpoint).md
    ├── 第51章 内省端点(Introspection Endpoint).md
    ├── 第50章 设备授权端点(Device Authorization Endpoint).md
    ├── 第53章 结束会话端点(End Session Endpoint).md
    ├── 第49章 令牌端点(Token Endpoint).md
    └── 第47章 授权端点(Authorize Endpoint).md
├── 欢迎来到IdentityServer4.md
├── LICENSE
├── README.md
└── 第六部分 其它
    ├── 第64章 学习.md
    ├── 第66章 视频.md
    └── 第65章 博客帖子.md


/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 | }


--------------------------------------------------------------------------------
/alipay.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thinksjay/IdentityServer4/HEAD/alipay.jpg


--------------------------------------------------------------------------------
/wechatpay.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thinksjay/IdentityServer4/HEAD/wechatpay.jpg


--------------------------------------------------------------------------------
/第一部分 简介/第06章 演示服务器和测试.md:
--------------------------------------------------------------------------------
1 | # 第06章 演示服务器和测试
2 | 
3 | 您可以使用您喜欢的客户端库尝试IdentityServer4。我们在[demo.identityserver.io](https://demo.identityserver.io/)上有一个测试实例。在主页面上，您可以找到有关如何配置客户端以及如何调用API的说明。   
4 | 
5 | 此外，我们还有一个repo，可以运行各种IdentityServer和Web API组合（IdentityServer 3和4，ASP.NET Core和Katana）。我们使用此测试工具确保所有排列都有效。您可以通过克隆此[repo](https://github.com/IdentityServer/CrossVersionIntegrationTests)来进行测试。 
6 | 


--------------------------------------------------------------------------------
/第五部分 参考/第57章 GrantValidationResult.md:
--------------------------------------------------------------------------------
 1 | # 第57章 GrantValidationResult
 2 | 该`GrantValidationResult`类模型补助确认为扩展授权和资源所有者密码授权的结果。
 3 | 
 4 | 最常见的用法是使用身份验证（成功用例）：
 5 | 
 6 | ``` C#
 7 | context.Result = new GrantValidationResult(
 8 |     subject: "818727",
 9 |     authenticationMethod: "custom",
10 |     claims: optionalClaims);
11 | ``` 
12 | 
13 | ...或使用错误和描述（失败用例）：
14 | 
15 | ``` C#
16 | context.Result = new GrantValidationResult(
17 |     TokenRequestErrors.InvalidGrant,
18 |     "invalid custom credential");
19 | ```  
20 | 
21 | 在这两种情况下，您都可以传递将包含在令牌响应中的其他自定义值。


--------------------------------------------------------------------------------
/第五部分 参考/第54章 身份资源.md:
--------------------------------------------------------------------------------
 1 | # 第54章 身份资源
 2 | 此类为身份资源建模。   
 3 | 
 4 | * **`Enabled`**  
 5 | 指示此资源是否已启用且可以请求。默认为true。
 6 | 
 7 | * **`Name`**  
 8 | 标识资源的唯一名称。这是客户端将用于授权请求中的scope参数的值。
 9 | 
10 | * **`DisplayName`**  
11 | 该值将用于例如同意屏幕上。
12 | 
13 | * **`Description`**  
14 | 该值将用于例如同意屏幕上。
15 | 
16 | * **`Required`**  
17 | 指定用户是否可以在同意屏幕上取消选择范围（如果同意屏幕要实现此类功能）。默认为false。
18 | 
19 | * **`Emphasize`**  
20 | 指定同意屏幕是否会强调此范围（如果同意屏幕要实现此功能）。将此设置用于敏感或重要范围。默认为false。
21 | 
22 | * **`ShowInDiscoveryDocument`**  
23 | 指定此范围是否显示在发现文档中。默认为true。
24 | 
25 | * **`UserClaims`**  
26 | 应包含在身份令牌中的关联用户声明类型的列表。


--------------------------------------------------------------------------------
/第二部分 快速入门/第08章 概述.md:
--------------------------------------------------------------------------------
 1 | # 第08章 概述
 2 | 
 3 | 快速入门提供了各种常见IdentityServer方案的分步说明。他们从基础到复杂 - 建议您按顺序完成它们。
 4 | 
 5 | * 将IdentityServer添加到ASP\.NET Core应用程序
 6 | * 配置IdentityServer
 7 | * 为各种客户发放令牌
 8 | * 保护Web应用程序和API
 9 | * 添加对基于EntityFramework的配置的支持
10 | * 添加对ASP\.NET身份的支持
11 | * 添加AdminUI社区版以管理用户和配置   
12 | 
13 | 每个快速入门都有一个参考解决方案 - 您可以 在quickstarts文件夹中的[IdentityServer4.Samples](https://github.com/IdentityServer/IdentityServer4.Samples) repo中找到代码 。
14 | 
15 | ## 8.1 准备
16 | 你应该做的第一件事是安装我们的模板：
17 | 
18 | ``` shell
19 | dotnet new -i IdentityServer4.Templates
20 | ```   
21 | 
22 | 它们将被用作各种教程的起点。   
23 | 
24 | 好的 - 让我们开始吧！
25 | 


--------------------------------------------------------------------------------
/第三部分 主题/第45章 工具.md:
--------------------------------------------------------------------------------
 1 | # 第45章 工具
 2 | 该`IdentityServerTools`是为IdentityServer编写扩展代码时，你可能需要有效的内部工具的集合。要使用它，请将其注入代码，例如控制器：
 3 | 
 4 | ``` C#
 5 | public MyController(IdentityServerTools tools)
 6 | {
 7 |     _tools = tools;
 8 | }
 9 | ```   
10 | 
11 | 该`IssueJwtAsync`方法允许使用IdentityServer令牌创建引擎创建JWT令牌。这`IssueClientJwtAsync`是为服务器到服务器通信创建令牌的简单版本（例如，当您必须从代码中调用受IdentityServer保护的API时）：
12 | 
13 | ``` C#
14 | public async Task<IActionResult> MyAction()
15 | {
16 |     var token = await _tools.IssueClientJwtAsync(
17 |         clientId: "client_id",
18 |         lifetime: 3600,
19 |         audiences: new[] { "backend.api" });
20 | 
21 |     // more code
22 | }
23 | ```   
24 | 


--------------------------------------------------------------------------------
/第五部分 参考/第60章 设备流交互服务.md:
--------------------------------------------------------------------------------
 1 | # 第60章 设备流交互服务
 2 | 该`IDeviceFlowInteractionService`接口旨在提供用户界面用于在设备流授权期间与IdentityServer通信的服务。它可以从依赖注入系统获得，通常作为构造函数参数注入到IdentityServer的用户界面的MVC控制器中。
 3 | 
 4 | ## 60.1 IDeviceFlowInteractionService的APIs
 5 | * **`GetAuthorizationContextAsync`**  
 6 | 基于`userCode`返回`DeviceFlowAuthorizationRequest`传递给登录或同意页面。
 7 | 
 8 | * **`DeviceFlowInteractionResult`**  
 9 | 完成给定的设备授权`userCode`。
10 | 
11 | ## 60.2 DeviceFlowAuthorizationRequest 
12 | * **`ClientId`**  
13 | 发起请求的客户端标识符。
14 | 
15 | * **`ScopesRequested`**  
16 | 授权请求中请求的范围。
17 | 
18 | ## 60.3 DeviceFlowInteractionResult 
19 | * **`IsError`**  
20 | 指定授权请求是否出错。
21 | 
22 | * **`ErrorDescription`**  
23 | 失败时的错误描述。


--------------------------------------------------------------------------------
/第四部分 端点/第46章 发现端点(Discovery Endpoint).md:
--------------------------------------------------------------------------------
 1 | # 第46章 发现端点(Discovery Endpoint)
 2 | 发现端点可用于检索有关IdentityServer的元数据 - 它返回发布者名称，密钥材料，支持的范围等信息。有关详细信息，请参阅[规范](https://openid.net/specs/openid-connect-discovery-1_0.html)。
 3 | 
 4 | 发现端点可通过*/.well-known/openid-configuration*相对于基地址获得，例如：
 5 | 
 6 | ```
 7 | https://demo.identityserver.io/.well-known/openid-configuration
 8 | ```  
 9 | 
10 | > **注意**
11 | 您可以使用[IdentityModel](https://github.com/IdentityModel/IdentityModel2)客户端库以编程方式从.NET代码访问发现端点。有关更多信息，请查看IdentityModel[文档](https://github.com/thinksjay/IdentityModel/blob/master/%E7%AC%AC%E4%B8%80%E9%83%A8%E5%88%86%20%E5%8D%8F%E8%AE%AE%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%BA%93/%E7%AC%AC1%E7%AB%A0%20%E5%8F%91%E7%8E%B0%E7%AB%AF%E7%82%B9(Discovery%20Endpoint).md)。


--------------------------------------------------------------------------------
/第三部分 主题/第37章 资源所有者密码验证(Resource Owner Password Validation).md:
--------------------------------------------------------------------------------
 1 | # 第37章 资源所有者密码验证(Resource Owner Password Validation)
 2 | 如果要使用OAuth 2.0资源所有者密码凭据授权（aka `password`），则需要实现并注册`IResourceOwnerPasswordValidator`接口：
 3 | 
 4 | ``` C#
 5 | public interface IResourceOwnerPasswordValidator
 6 | {
 7 |     /// <summary>
 8 |     /// Validates the resource owner password credential
 9 |     /// </summary>
10 |     /// <param name="context">The context.</param>
11 |     Task ValidateAsync(ResourceOwnerPasswordValidationContext context);
12 | }
13 | ```  
14 | 
15 | 在上下文中，您将找到已解析的协议参数，如UserName和Password，以及原始请求，如果您想查看其他输入数据。
16 | 
17 | 然后，您的工作是实施密码验证并相应地设置`Result`上下文。请参阅[GrantValidationResult](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC57%E7%AB%A0%20GrantValidationResult.md)文档。


--------------------------------------------------------------------------------
/第三部分 主题/第38章 刷新令牌.md:
--------------------------------------------------------------------------------
 1 | # 第38章 刷新令牌
 2 | 由于访问令牌的生命周期有限，因此刷新令牌允许在没有用户交互的情况下请求新的访问令牌。
 3 | 
 4 | 以下流程支持刷新令牌：授权代码，混合和资源所有者密码凭据流。需要明确授权客户端通过设置`AllowOfflineAccess`来请求刷新令牌`true`。
 5 | 
 6 | ## 38.1 其他客户端设置
 7 | * **`AbsoluteRefreshTokenLifetime`**  
 8 | 刷新令牌的最长生命周期（秒）。默认为2592000秒/ 30天。零允许刷新令牌，当仅在*SlidingRefreshTokenLifetime*传递后使用时过期。`RefreshTokenExpiration = Sliding`
 9 | 
10 | * **`SlidingRefreshTokenLifetime`**  
11 | 以秒为单位滑动刷新令牌的生命周期。默认为1296000秒/ 15天
12 | 
13 | * **`RefreshTokenUsage`**  
14 | `ReUse` 刷新令牌时，刷新令牌句柄将保持不变
15 | `OneTime` 刷新令牌时将更新刷新令牌句柄
16 | 
17 | * **`RefreshTokenExpiration`**  
18 | `Absolute` 刷新令牌将在固定时间点到期（由AbsoluteRefreshTokenLifetime指定）
19 | `Sliding`刷新令牌时，将刷新刷新令牌的生命周期（按SlidingRefreshTokenLifetime中指定的数量）。生命周期不会超过
20 | *AbsoluteRefreshTokenLifetime*。
21 | 
22 | * **`UpdateAccessTokenClaimsOnRefresh`**  
23 | 获取或设置一个值，该值指示是否应在刷新令牌请求上更新访问令牌（及其声明）。


--------------------------------------------------------------------------------
/第三部分 主题/第40章 自定义令牌请求验证和发布.md:
--------------------------------------------------------------------------------
 1 | # 第40章 自定义令牌请求验证和发布
 2 | 您可以在令牌端点处将自定义代码作为令牌颁发管道的一部分运行。这允许例如
 3 | 
 4 | * 添加额外的验证逻辑
 5 | * 动态地改变某些参数（例如令牌生存期）  
 6 | 
 7 | 为此，实现（并注册）`ICustomTokenRequestValidator`接口：
 8 | 
 9 | ``` C#
10 | /// <summary>
11 | /// Allows inserting custom validation logic into token requests
12 | /// </summary>
13 | public interface ICustomTokenRequestValidator
14 | {
15 |     /// <summary>
16 |     /// Custom validation logic for a token request.
17 |     /// </summary>
18 |     /// <param name="context">The context.</param>
19 |     /// <returns>
20 |     /// The validation result
21 |     /// </returns>
22 |     Task ValidateAsync(CustomTokenRequestValidationContext context);
23 | }
24 | ```  
25 | 
26 | 上下文对象使您可以访问：
27 | 
28 | * 添加自定义响应参数
29 | * 返回错误和错误说明
30 | * 修改请求参数，例如访问令牌生存期和类型，客户端声明和确认方法  
31 | 
32 | 您可以使用配置构建器上的`AddCustomTokenRequestValidator`扩展方法注册验证程序的实现。


--------------------------------------------------------------------------------
/第四部分 端点/第52章 撤销端点(Revocation Endpoint).md:
--------------------------------------------------------------------------------
 1 | # 第52章 撤销端点(Revocation Endpoint)
 2 | 此端点允许撤消访问令牌（仅限引用令牌）和刷新令牌。它实现了令牌撤销规范（[RFC 7009](https://tools.ietf.org/html/rfc7009)）。
 3 | 
 4 | * **`token`**  
 5 | 要撤销的令牌（必填）
 6 | 
 7 | * **`token_type_hint`**  
 8 | `access_token`或`refresh_token`（可选）
 9 | 
10 | 示例
11 | 
12 | ```
13 | POST /connect/revocation HTTP/1.1
14 | Host: server.example.com
15 | Content-Type: application/x-www-form-urlencoded
16 | Authorization: Basic czZCaGRSa3F0MzpnWDFmQmF0M2JW
17 | 
18 | token=45ghiukldjahdnhzdauz&token_type_hint=refresh_token
19 | ```
20 | 
21 | > **注意**
22 | 您可以使用[IdentityModel](https://github.com/IdentityModel/IdentityModel2)客户端库以编程方式从.NET代码访问吊销端点。有关更多信息，请查看IdentityModel[文档](https://github.com/thinksjay/IdentityModel/blob/master/%E7%AC%AC%E4%B8%80%E9%83%A8%E5%88%86%20%E5%8D%8F%E8%AE%AE%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%BA%93/%E7%AC%AC6%E7%AB%A0%20%E4%BB%A4%E7%89%8C%E6%92%A4%E9%94%80%E7%AB%AF%E7%82%B9(Token%20Revocation%20Endpoint).md)。


--------------------------------------------------------------------------------
/第四部分 端点/第48章 UserInfo端点(UserInfo Endpoint).md:
--------------------------------------------------------------------------------
 1 | # 第48章 UserInfo端点(UserInfo Endpoint)
 2 | UserInfo端点可用于检索有关用户的身份信息（请参阅[规范](http://openid.net/specs/openid-connect-core-1_0.html#UserInfo)）。
 3 | 
 4 | 调用者需要发送代表用户的有效访问令牌。根据授予的范围，UserInfo端点将返回映射的声明（至少需要*openid*作用域）。
 5 | 
 6 | 示例
 7 | 
 8 | ```
 9 | GET /connect/userinfo
10 | Authorization: Bearer <access_token>
11 | HTTP/1.1 200 OK
12 | Content-Type: application/json
13 | 
14 | {
15 |     "sub": "248289761001",
16 |     "name": "Bob Smith",
17 |     "given_name": "Bob",
18 |     "family_name": "Smith",
19 |     "role": [
20 |         "user",
21 |         "admin"
22 |     ]
23 | }
24 | ```  
25 | 
26 | > **注意**
27 | 您可以使用[IdentityModel](https://github.com/IdentityModel/IdentityModel2)客户端库以编程方式从.NET代码访问userinfo端点。有关更多信息，请查看IdentityModel[文档](https://github.com/thinksjay/IdentityModel/blob/master/%E7%AC%AC%E4%B8%80%E9%83%A8%E5%88%86%20%E5%8D%8F%E8%AE%AE%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%BA%93/%E7%AC%AC7%E7%AB%A0%20UserInfo%E7%AB%AF%E7%82%B9(UserInfo%20Endpoint).md)。


--------------------------------------------------------------------------------
/第四部分 端点/第51章 内省端点(Introspection Endpoint).md:
--------------------------------------------------------------------------------
 1 | # 第51章 内省端点(Introspection Endpoint)
 2 | 内省端点是[RFC 7662](https://tools.ietf.org/html/rfc7662)的实现。
 3 | 
 4 | 它可用于验证引用令牌（如果消费者不支持适当的JWT或加密库，则可以使用JWT）。内省端点需要身份验证 - 因为内省端点的客户端是API，您可以在其上配置秘密`ApiResource`。
 5 | 
 6 | 示例
 7 | 
 8 | ```
 9 | POST /connect/introspect
10 | Authorization: Basic xxxyyy
11 | 
12 | token=<token>
13 | ```   
14 | 
15 | 成功的响应将返回状态代码200以及活动或非活动令牌：
16 | 
17 | ``` json
18 | {
19 |     "active": true,
20 |     "sub": "123"
21 | }
22 | ```   
23 | 
24 | 未知或过期的令牌将被标记为无效：
25 | 
26 | ``` json
27 | {
28 |     "active": false,
29 | }
30 | ```  
31 | 
32 | 无效请求将返回400，未授权请求401。
33 | 
34 | > **注意**
35 | 您可以使用[IdentityModel](https://github.com/IdentityModel/IdentityModel2)客户端库以编程方式从.NET代码访问内省端点。有关更多信息，请查看IdentityModel[文档](https://github.com/thinksjay/IdentityModel/blob/master/%E7%AC%AC%E4%B8%80%E9%83%A8%E5%88%86%20%E5%8D%8F%E8%AE%AE%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%BA%93/%E7%AC%AC5%E7%AB%A0%20%E4%BB%A4%E7%89%8C%E8%87%AA%E7%9C%81%E7%AB%AF%E7%82%B9(Token%20Introspection%20Endpoint).md)。


--------------------------------------------------------------------------------
/第五部分 参考/第63章 ASP.NET Identity 支持.md:
--------------------------------------------------------------------------------
 1 | # 第63章 ASP.NET Identity 支持
 2 | 提供了基于ASP.NET身份的实现，用于管理IdentityServer用户的身份数据库。此实现是IdentityServer中的扩展点，以便为用户加载身份数据以将声明发送到令牌。
 3 | 
 4 | 这个支持的仓储位于[此处](https://github.com/IdentityServer/IdentityServer4.AspNetIdentity/)，NuGet包就在[这里](https://www.nuget.org/packages/IdentityServer4.AspNetIdentity)。
 5 | 
 6 | 要使用此库，请正常配置ASP.NET Identity。然后在调用`AddIdentityServer`后使用`AddAspNetIdentity`扩展方法：
 7 | 
 8 | ``` C#
 9 | public void ConfigureServices(IServiceCollection services)
10 | {
11 |     services.AddIdentity<ApplicationUser, IdentityRole>()
12 |         .AddEntityFrameworkStores<ApplicationDbContext>()
13 |         .AddDefaultTokenProviders();
14 | 
15 |     services.AddIdentityServer()
16 |         .AddAspNetIdentity<ApplicationUser>();
17 | }
18 | ```  
19 | 
20 | `AddAspNetIdentity`需要作为通用参数，为您的用户建模ASP.NET Identity（以及传递给AddIdentityASP.NET Identity 的同一个用户）。这将配置IdentityServer使用实现`IUserClaimsPrincipalFactory`，`IResourceOwnerPasswordValidator`和`IProfileService`的ASP.NET Identity。它还配置了一些用于IdentityServer的ASP.NET Identity选项（例如要使用的声明类型和身份验证cookie设置）。


--------------------------------------------------------------------------------
/第三部分 主题/第42章 发现(discovery).md:
--------------------------------------------------------------------------------
 1 | # 第42章 发现(discovery)
 2 | 可以在*https://baseaddress/.well-known/openid-configuration*找到发现文档。它包含有关IdentityServer的端点，密钥材料和功能的信息。
 3 | 
 4 | 默认情况下，所有信息都包含在发现文档中，但通过使用配置选项，您可以隐藏各个部分，例如：
 5 | 
 6 | ``` C#
 7 | services.AddIdentityServer(options =>
 8 | {
 9 |     options.Discovery.ShowIdentityScopes = false;
10 |     options.Discovery.ShowApiScopes = false;
11 |     options.Discovery.ShowClaims = false;
12 |     options.Discovery.ShowExtensionGrantTypes = false;
13 | });
14 | ```  
15 | 
16 | ## 42.1扩展发现
17 | 您可以向发现文档添加自定义条目，例如：
18 | 
19 | ``` C#
20 | services.AddIdentityServer(options =>
21 | {
22 |     options.Discovery.CustomEntries.Add("my_setting", "foo");
23 |     options.Discovery.CustomEntries.Add("my_complex_setting",
24 |         new
25 |         {
26 |             foo = "foo",
27 |             bar = "bar"
28 |         });
29 | });
30 | ```   
31 | 
32 | 当您添加以~开头的自定义值时，它将扩展到IdentityServer基址以下的绝对路径，例如：
33 | 
34 | ``` C#
35 | options.Discovery.CustomEntries.Add("my_custom_endpoint", "~/custom");
36 | ```   
37 | 
38 | 如果要完全控制发现（和jwks）文档的呈现，可以实现`IDiscoveryResponseGenerator 接口（或从我们的默认实现派生）。


--------------------------------------------------------------------------------
/欢迎来到IdentityServer4.md:
--------------------------------------------------------------------------------
 1 | # 欢迎来到IdentityServer4
 2 | 
 3 | **<big>欢迎IdentityServer4</big>**     
 4 | 
 5 | <div align="center">
 6 | <img src="https://identityserver4.readthedocs.io/en/latest/_images/logo.png"/>
 7 | </div>   
 8 | 
 9 | IdentityServer4是ASP\.NET Core 2的OpenID Connect和OAuth 2.0框架。  
10 | 
11 | 它可以在您的应用程序中启用以下功能：   
12 | 
13 | **<big>身份验证服务</big>**
14 | 适用于所有应用程序（Web，本机，移动设备，服务）的集中登录逻辑和工作流程。IdentityServer是OpenID Connect 的官方认证实现。  
15 | 
16 | **<big>单点登录/注销</big>**
17 | 在多种应用程序类型上单点登录（和退出）。  
18 | 
19 | **<big>API的访问控制</big>**
20 | 为各种类型的客户端发出API访问令牌，例如服务器到服务器，Web应用程序，SPA和本机/移动应用程序。  
21 | 
22 | **<big>联合网关</big>**
23 | 支持Azure Active Directory，Google，Facebook等外部身份提供商。这可以保护您的应用程序免受如何连接到这些外部提供商的详细信息的影响。  
24 | 
25 | **<big>专注于定制</big>**
26 | 最重要的部分 - IdentityServer的许多方面都可以根据您的需求进行定制。由于IdentityServer是一个框架而不是盒装产品或SaaS，因此您可以编写代码以使系统适应您的方案。  
27 | 
28 | **<big>成熟的开源</big>**
29 | IdentityServer使用允许的[Apache 2](https://www.apache.org/licenses/LICENSE-2.0)许可证，允许在其上构建商业产品。它也是[.NET Foundation](https://dotnetfoundation.org/)的一部分，它提供治理和法律支持。  
30 | 
31 | **<big>免费和商业支持</big>**
32 | 如果您需要帮助构建或运行您的身份平台，请告知我们。我们可以通过多种方式为您提供帮助。


--------------------------------------------------------------------------------
/第四部分 端点/第50章 设备授权端点(Device Authorization Endpoint).md:
--------------------------------------------------------------------------------
 1 | # 第50章 设备授权端点(Device Authorization Endpoint)
 2 | 设备授权端点可用于请求设备和用户代码。此端点用于启动设备流授权过程。
 3 | 
 4 | > **注意**
 5 | 终端会话端点的URL可通过[发现端点](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC42%E7%AB%A0%20%E5%8F%91%E7%8E%B0(discovery).md)获得。
 6 | 
 7 | * **`client_id`**  
 8 | 客户标识符（必填）
 9 | 
10 | * **`client_secret`**  
11 | 客户端密钥可以在帖子正文中，也可以作为基本身份验证标头。可选的。
12 | 
13 | * **`scope`**  
14 | 一个或多个注册范围。如果未指定，将发出所有明确允许范围的标记。
15 | 
16 | 示例
17 | 
18 | ```
19 | POST /connect/deviceauthorization
20 | 
21 |     client_id=client1&
22 |     client_secret=secret&
23 |     scope=openid api1
24 | ```
25 | 
26 | （为了便于阅读，删除了表格编码并添加了换行符）
27 | 
28 | > **注意**
29 | 您可以使用[IdentityModel](https://github.com/IdentityModel/IdentityModel2)客户端库以编程方式从.NET代码访问设备授权终结点。有关更多信息，请查看IdentityModel[文档](https://github.com/thinksjay/IdentityModel/blob/master/%E7%AC%AC%E4%B8%80%E9%83%A8%E5%88%86%20%E5%8D%8F%E8%AE%AE%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%BA%93/%E7%AC%AC9%E7%AB%A0%20%E8%AE%BE%E5%A4%87%E6%8E%88%E6%9D%83%E7%AB%AF%E7%82%B9(Device%20Authorization%20Endpoint).md)。


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 thinksjay
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/第一部分 简介/第05章 支持和咨询选项.md:
--------------------------------------------------------------------------------
 1 | # 第05章 支持和咨询选项
 2 | 
 3 | 我们为IdentityServer提供了多种免费和商业支持和咨询选项。   
 4 | 
 5 | ## 5.1 免费支持
 6 | 免费支持是基于社区的，并使用公共论坛   
 7 | 
 8 | ### 5.1.1 StackOverflow
 9 | StackOverflow 社区里日益增多的 IdentityServer 用户在监视着上面的问题。如果时间允许，我们也会试着尽可能多地回答这些问题。   
10 | 
11 | 您可以使用此Feed订阅所有IdentityServer4相关问题：   
12 | 
13 | <https://stackoverflow.com/questions/tagged/?tagnames=identityserver4&sort=newest>   
14 | 
15 | 在提出新问题时请使用`IdentityServer4`标签   
16 | 
17 | ### 5.1.2 Gitter
18 | 
19 | 您可以在我们的Gitter聊天室中与其他IdentityServer4用户聊天：   
20 | 
21 | <https://gitter.im/IdentityServer/IdentityServer4>
22 | 
23 | ### 5.1.3 报告Bug
24 | 如果您认为自己发现了Bug或意外行为，请在Github 问题跟踪器上打开一个问题。我们会尽快回复您。请理解我们也有日常工作，可能太忙而无法立即回复。   
25 | 
26 | 你还可以在发布问题之前查看一下[贡献指南](https://github.com/IdentityServer/IdentityServer4/blob/dev/CONTRIBUTING.md)。   
27 | 
28 | ## 5.2 商业支持
29 | 我们正在围绕身份和访问控制架构进行咨询，指导和定制软件开发，特别是IdentityServer。请与我们[取得联系](mailto:identity@leastprivilege.com)以讨论可能的选项。   
30 | 
31 | ### 5.2.1 培训
32 | 我们经常围绕现代应用的身份和访问控制进行研讨会。在[这里](https://identityserver.io/training)查看议程和即将公布的日期 。我们也可以在贵公司私下进行培训。 联系我们以进行现场培训。   
33 | 
34 | ### 5.2.3 Admin UI，Identity Express和SAML2p支持
35 | 我们的合作伙伴提供了几种商业附加产品，请访问<https://www.identityserver.com/products/>。   
36 | 


--------------------------------------------------------------------------------
/第三部分 主题/第39章 引用令牌.md:
--------------------------------------------------------------------------------
 1 | # 第39章 引用令牌
 2 | 访问令牌有两种形式 - 自包含或引用。
 3 | 
 4 | JWT令牌将是一个自包含的访问令牌 - 它是一个带有声明和过期的受保护数据结构。一旦API了解了密钥材料，它就可以验证自包含的令牌，而无需与发行者进行通信。这使得JWT难以撤销。它们将一直有效，直到它们过期。
 5 | 
 6 | 使用引用令牌时 - IdentityServer会将令牌的内容存储在数据存储中，并且只会将此令牌的唯一标识符发回给客户端。然后，接收此引用的API必须打开与IdentityServer的反向通道通信以验证令牌。
 7 | 
 8 | <div align="center">
 9 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/reference_tokens.png"/>
10 | </div>
11 | 
12 | 您可以使用以下设置切换客户端的令牌类型：
13 | 
14 | ``` C#
15 | client.AccessTokenType = AccessTokenType.Reference;
16 | ```  
17 | 
18 | IdentityServer提供了OAuth 2.0内省规范的实现，该规范允许API取消引用令牌。您可以使用我们的专用[内省处理程序](https://github.com/IdentityModel/IdentityModel.AspNetCore.OAuth2Introspection) 或使用[身份服务器身份验证处理程序](https://github.com/IdentityServer/IdentityServer4.AccessTokenValidation)，它可以验证JWT和引用令牌。
19 | 
20 | 内省端点需要身份验证 - 因为内省端点的客户端是API，您可以在以下位置配置秘密`ApiResource`：
21 | 
22 | ``` C#
23 | var api = new ApiResource("api1")
24 | {
25 |     ApiSecrets = { new Secret("secret".Sha256()) }
26 | }
27 | ```  
28 | 
29 | 有关如何为API配置IdentityServer身份验证中间件的详细信息，请参阅[此处](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC29%E7%AB%A0%20%E4%BF%9D%E6%8A%A4API.md)。


--------------------------------------------------------------------------------
/第三部分 主题/第26章 联合注销.md:
--------------------------------------------------------------------------------
 1 | # 第26章 联合注销
 2 | 联合注销是指用户使用外部身份提供程序登录IdentityServer，然后用户通过IdentityServer未知的工作流程注销该外部身份提供程序的情况。当用户注销时，对IdentityServer进行通知将非常有用，这样它就可以将用户从IdentityServer和使用IdentityServer的所有应用程序中签出。
 3 | 
 4 | 并非所有外部身份提供商都支持联合注销，但那些提供的机制将提供通知客户端用户已注销的机制。此通知通常以`<iframe>`来自外部身份提供商的“已注销”页面的请求的形式出现。然后IdentityServer必须通知其所有客户（讨论[这里](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC21%E7%AB%A0%20%E7%99%BB%E5%BD%95.md)），也通常在一个请求的`<iframe>`形式从内外部身份提供的`<iframe>`。
 5 | 
 6 | 使联合注销成为特殊情况（与正常[注销](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC21%E7%AB%A0%20%E7%99%BB%E5%BD%95.md)相比）的原因是联合注销请求不是IdentityServer中的正常注销端点。实际上，每个外部IdentityProvider都将在IdentityServer主机中具有不同的端点。这是因为每个外部身份提供者可能使用不同的协议，并且每个中间件都在不同的端点上进行侦听。
 7 | 
 8 | 所有这些因素的效果是没有像正常注销工作流那样呈现“注销”页面，这意味着我们缺少对IdentityServer客户端的注销通知。我们必须为每个联合注销端点添加代码，以呈现必要的通知以实现联合注销。
 9 | 
10 | 幸运的是，IdentityServer已包含此代码。当请求进入IdentityServer并调用外部身份验证提供程序的处理程序时，IdentityServer检测这些请求是否是联合注销请求，如果是联合注销请求，它将自动呈现与此处描述的[注销](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC21%E7%AB%A0%20%E7%99%BB%E5%BD%95.md)相同的`<iframe>`。简而言之，自动支持联合注销。


--------------------------------------------------------------------------------
/第三部分 主题/第33章 密码学(Cryptography)，密钥(Keys)和HTTPS.md:
--------------------------------------------------------------------------------
 1 | # 第33章 密码学(Cryptography)，密钥(Keys)和HTTPS
 2 | IdentityServer依赖于几个加密机制来完成它的工作。
 3 | 
 4 | ## 33.1 令牌签名和验证
 5 | IdentityServer需要非对称密钥对来签署和验证JWT。此密钥对可以是证书/私钥组合或原始RSA密钥。无论如何，它必须支持带有SHA256的RSA。
 6 | 
 7 | 加载签名密钥和相应的验证部分是通过实现`ISigningCredentialStore`和`IValidationKeysStore`来完成的。如果要自定义加载密钥，可以实现这些接口并将其注册到DI。
 8 | 
 9 | DI构建器扩展有几种方便的方法来设置签名和验证密钥 - 请参阅[此处](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC18%20%E7%AB%A0%20%E5%90%AF%E5%8A%A8.md#182-%E5%AF%86%E9%92%A5%E6%9D%90%E6%96%99)。
10 | 
11 | ## 33.2 签名密钥翻转
12 | 虽然一次只能使用一个签名密钥，但您可以将多个验证密钥发布到发现文档。这对于密钥翻转很有用。
13 | 
14 | 翻转通常如下所示：
15 | 
16 | 1. 您请求/创建新的密钥材料
17 | 2. 除了当前的验证密钥之外，还要发布新的验证密钥。您可以使用`AddValidationKeys`构建器扩展方法。
18 | 3. 所有客户端和API现在都有机会在下次更新发现文档的本地副本时了解新密钥
19 | 4. 在一定时间（例如24小时）之后，所有客户端和API现在都应接受旧密钥材料和新密钥材料
20 | 5. 只要你愿意，就可以保留旧的密钥材料，也许你有需要验证的长寿命代币
21 | 6. 当旧密钥材料不再使用时，将其退出
22 | 7. 所有客户端和API将在下次更新发现文档的本地副本时“忘记”旧密钥  
23 | 
24 | 这要求客户端和API使用发现文档，并且还具有定期刷新其配置的功能。
25 | 
26 | ## 33.3 数据保护
27 | ASP.NET Core中的Cookie身份验证（或MVC中的防伪）使用ASP.NET Core数据保护功能。根据您的部署方案，这可能需要其他配置。有关更多信息，请参阅Microsoft[文档](https://docs.microsoft.com/en-us/aspnet/core/security/data-protection/configuration/overview)。
28 | 
29 | ## 33.4 HTTPS 
30 | 我们不强制使用HTTPS，但对于生产，它必须与IdentityServer进行每次交互。
31 | 
32 | 


--------------------------------------------------------------------------------
/第一部分 简介/第02章 术语.md:
--------------------------------------------------------------------------------
 1 | # 第02章 术语
 2 | 
 3 | 规范、文档和对象模型等都使用特定的术语来表述。   
 4 | 
 5 | <div align="center">
 6 | <img src="https://identityserver4.readthedocs.io/en/latest/_images/terminology.png"/>
 7 | </div>    
 8 | 
 9 | ## 2.1 IdentityServer
10 | IdentityServer是OpenID Connect提供程序 - 它实现OpenID Connect和OAuth 2.0协议。   
11 | 
12 | 对于相同的角色，不同的文献将使用不同的术语 —— 你可能也发现了安全令牌服务（Security Token Service），身份提供程序（Identity Provider），授权服务器（Authorization Server），IP-STS 等。   
13 | 
14 | 但它们完全相同：一种向客户发放安全令牌的软件。   
15 | 
16 | IdentityServer 包含一些职责和功能：   
17 | 
18 | * 保护你的资源
19 | * 使用本地帐户存储或外部身份提供程序对用户进行身份验证
20 | * 提供会话管理和单点登录(SSO)
21 | * 管理和验证客户端
22 | * 向客户端发放身份和访问令牌
23 | * 验证令牌   
24 | 
25 | ## 2.2 用户
26 | 用户是使用注册客户端访问资源的人。   
27 | 
28 | ## 2.3 客户端
29 | 客户端是从IdentityServer请求令牌的软件 - 用于验证用户（请求身份令牌）或访问资源（请求访问令牌）。客户端必须首先向IdentityServer注册，然后才能请求令牌。   
30 | 
31 | 客户端可以是Web应用程序、移动客户端或桌面应用程序、单页面应用程序（SPA，Single Page Application）、服务器进程等等。   
32 | 
33 | ## 2.4 资源
34 | 您希望使用IdentityServer保护资源 - 用户的身份数据或API。   
35 | 
36 | 每个资源都有一个唯一的名称 - 客户端使用此名称来指定他们希望访问哪些资源。   
37 | 
38 | **身份数据** 关于用户的身份信息（也称为声明），例如姓名或电子邮件地址。   
39 | 
40 | **API** API资源表示客户端要调用的功能 - 通常建模为Web API，但不一定。   
41 | 
42 | ## 2.5 身份令牌
43 | 身份令牌表示身份验证过程的结果。它至少包含用户的标识符（称为sub aka subject声明）以及有关用户如何以及何时进行身份验证的信息。它可以包含其他身份数据。   
44 | 
45 | ## 2.6 访问令牌
46 | 访问令牌允许访问API资源。客户端请求访问令牌并将其转发给API。访问令牌包含有关客户端和用户（如果存在）的信息。API使用该信息来授权访问其数据。 
47 | 


--------------------------------------------------------------------------------
/第三部分 主题/第23章 Windows身份验证.md:
--------------------------------------------------------------------------------
 1 | # 第23章 Windows身份验证
 2 | 在支持的平台上，您可以使用IdentityServer使用Windows身份验证对用户进行身份验证（例如，针对Active Directory）。当前使用以下命令托管IdentityServer时，Windows身份验证可用：   
 3 | 
 4 | * [Kestrel](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/servers/kestrel)在Windows上使用IIS和IIS集成包
 5 | * Windows上的[HTTP.sys](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/servers/httpsys)服务器  
 6 | 
 7 | 在这两种情况下，使用方案`“Windows”`在`HttpContext`上使用`ChallengeAsync` API来触发Windows身份验证。我们的[快速入门UI](https://github.com/IdentityServer/IdentityServer4.Quickstart.UI)中的帐户控制器实现了必要的逻辑。   
 8 | 
 9 | ## 23.1 使用 Kestrel
10 | 使用Kestrel时，必须运行“behind”IIS并使用IIS集成：   
11 | ``` C#
12 | var host = new WebHostBuilder()
13 |     .UseKestrel()
14 |     .UseUrls("http://localhost:5000")
15 |     .UseContentRoot(Directory.GetCurrentDirectory())
16 |     .UseIISIntegration()
17 |     .UseStartup<Startup>()
18 |     .Build();
19 | ```   
20 | 
21 | 使用该`WebHost.CreateDefaultBuilder`方法设置时，会自动配置`WebHostBuilder`。   
22 | 
23 | IIS（或IIS Express）中的虚拟目录也必须启用Windows并启用匿名身份验证。   
24 | 
25 | IIS集成层将Windows身份验证处理程序配置为DI，可以通过身份验证服务调用。通常在IdentityServer中，建议禁用此自动行为。这是在`ConfigureServices`：   
26 | 
27 | ``` C#
28 | services.Configure<IISOptions>(iis =>
29 | {
30 |     iis.AuthenticationDisplayName = "Windows";
31 |     iis.AutomaticAuthentication = false;
32 | });
33 | ```  
34 | 
35 | > **注意**
36 | 默认情况下，显示名称为空，Windows身份验证按钮不会显示在快速入门UI中。如果依赖于自动发现外部提供程序，则需要设置显示名称。


--------------------------------------------------------------------------------
/第一部分 简介/第07章 贡献.md:
--------------------------------------------------------------------------------
 1 | # 第07章 贡献
 2 | 
 3 | 我们对社区贡献非常开放，但您应该遵循一些指导原则，以便我们可以毫不费力地处理这个问题。   
 4 | 
 5 | ## 7.1 如何贡献？
 6 | 最简单的方法是打开一个问题并开始讨论。然后我们可以决定是否以及如何实现功能或更改。如果您应提交包含更改代码的pull请求，请从描述开始，仅进行最小的更改并提供涵盖这些更改的测试。   
 7 | 
 8 | 首先阅读：[成为一名优秀的开源公民](https://hackernoon.com/being-a-good-open-source-citizen-9060d0ab9732#.x3hocgw85)   
 9 | 
10 | ## 7.2 一般反馈和讨论？
11 | 请在 [核心仓库问题跟踪](https://github.com/IdentityServer/IdentityServer4/issues) 上开启一个讨论。   
12 |  
13 | ## 7.3 平台
14 | IdentityServer是针对ASP.NET Core 2构建的，可在.NET Framework 4.6.1（及更高版本）和.NET Core 2（及更高版本）上运行。   
15 | 
16 | ## 7.4 错误和功能请求？
17 | 请在相应的GitHub仓库中记录新问题：   
18 | 
19 | * [Core（核心）](https://github.com/IdentityServer/IdentityServer4)
20 | * [Samples（示例）](https://github.com/IdentityServer/IdentityServer4.Samples)
21 | * [AccessTokenValidation（访问令牌验证）](https://github.com/IdentityServer/IdentityServer4.AccessTokenValidation)
22 | 
23 | ## 7.5 其他讨论
24 | <https://gitter.im/IdentityServer/IdentityServer4>   
25 | 
26 | ## 7.6 贡献代码和内容
27 | 在您提供任何代码或内容之前，您需要签署贡献者许可协议。这是一个自动化过程，将在您打开拉取请求后启动。   
28 | 
29 | > **注意**
30 | > 我们只接受开发分支的PR。
31 | 
32 | ## 7.7 贡献项目
33 | 如果您启动贡献项目（例如，支持Database X或Configuration Store Y），我们非常感谢。告诉我们，我们可以在我们的文档中发推文和链接。   
34 | 
35 | 我们通常不会要你们贡献的库的所有权，为了支持核心项目，我们已经很忙了。   
36 | 
37 | **命名约定**
38 | 截至2017年10月，IdentityServer4。* nuget名称空间保留给我们的软件包。请使用以下命名约定：   
39 | 
40 | YourProjectName.IdentityServer4   
41 | 
42 | 要么   
43 | 
44 | IdentityServer4.Contrib.YourProjectName
45 | 


--------------------------------------------------------------------------------
/第一部分 简介/第04章 打包和构建.md:
--------------------------------------------------------------------------------
 1 | # 第04章 打包和构建
 2 | 
 3 | IdentityServer由许多nuget包组成。   
 4 | 
 5 | ## 4.1 IdentityServer4 
 6 | [nuget](https://www.nuget.org/packages/IdentityServer4/) | [github](https://github.com/identityserver/IdentityServer4)上   
 7 | 
 8 | 包含核心IdentityServer对象模型，服务和中间件。仅包含对内存配置和用户存储的支持 - 但您可以通过配置插入对其他存储的支持。这是其他仓库和程序包相关的内容。   
 9 | 
10 | ## 4.2 Quickstart UI
11 | [github](https://github.com/IdentityServer/IdentityServer4.Quickstart.UI)上   
12 | 
13 | 包含一个简单的入门UI，包括登录，注销和授权确认页面。   
14 | 
15 | ## 4.3 Access token validation handler
16 | [nuget](https://www.nuget.org/packages/IdentityServer4.AccessTokenValidation) | [github](https://github.com/IdentityServer/IdentityServer4.AccessTokenValidation)上   
17 | 
18 | 用于验证API中令牌的ASP.NET Core身份验证处理程序。处理程序允许在同一API中支持JWT和引用令牌。   
19 | 
20 | ## 4.4 ASP\.NET Core Identity
21 | [nuget](https://www.nuget.org/packages/IdentityServer4.AspNetIdentity) | [github](https://github.com/IdentityServer/IdentityServer4.AspNetIdentity)上   
22 | 
23 | IdentityServer的ASP\.NET Core Identity集成包。此包提供了一个简单的配置API，可以为IdentityServer用户使用ASP\.NET Identity管理库。
24 | 
25 | ## 4.5 EntityFramework Core
26 | [nuget](https://www.nuget.org/packages/IdentityServer4.EntityFramework) | [github](https://github.com/IdentityServer/IdentityServer4.EntityFramework)上   
27 | 
28 | IdentityServer 的 EntityFramework Core 仓储实现。此包为IdentityServer中的配置和操作存储提供EntityFramework实现。
29 | 
30 | ## 4.6 Dev builds
31 | 此外，我们将开发/临时构建发布到MyGet。可以添加以下程序包源到你的 Visual Studio 中：   
32 | 
33 | <https://www.myget.org/F/identity/>   
34 | 


--------------------------------------------------------------------------------
/第二部分 快速入门/第17章 社区快速入门和模板.md:
--------------------------------------------------------------------------------
 1 | # 第17章 社区快速入门和模板
 2 | IdentityServer组织不维护这些示例。IdentityServer组织愉快地链接到社区模板，但不能对模板做出任何保证。请直接与作者联系。   
 3 | 
 4 | ## 17.1 各种ASP.NET核心安全样本
 5 | <https://github.com/leastprivilege/AspNetCoreSecuritySamples>
 6 | 
 7 | ## 17.2 IdentityServer4 EF和ASP.NET Identity
 8 | [此示例](https://github.com/IdentityServer/IdentityServer4.Samples/tree/master/Quickstarts/Combined_AspId_and_EFStorage)结合了EF和ASP.NET Identity快速入门（＃6和＃8）。   
 9 | 
10 | ## 17.3 共同托管IdentityServer4和
11 | 此示例显示如何在与保护API的IdentityServer相同的主机中承载API。  
12 | <https://github.com/brockallen/IdentityServerAndApi>   
13 | 
14 | ## 17.4 MongoDB的IdentityServer4示例   
15 | IdentityServer4-mongo：与Quickstart＃8 EntityFramework配置类似，但使用MongoDB配置数据。
16 | IdentityServer4-mongo-AspIdentity：更详细的示例基于使用ASP.NET Identity进行身份管理，使用MongoDB作为配置数据
17 | <https://github.com/souzartn/IdentityServer4.Samples.Mongo>   
18 | 
19 | ## 17.5 从Facebook，Google和Twitter交换外部令牌
20 | 显示如何使用扩展授权将外部身份验证令牌交换到身份服务器访问令牌
21 | <https://github.com/waqaskhan540/IdentityServerExternalAuth>
22 | 
23 | ## 17.6 IdentityServer4 Quickstart UI的ASP.NET Core MVC RazorPages模板
24 | 基于Razor Pages的QuickStart样本由Martin Fletcher提供。
25 | 
26 | ## 17.7 .NET Core和ASP.NET Core“平台”场景
27 | 显示可信“内部”应用程序与“外部”应用程序与.NET Core 2.0和ASP.NET Core 2.0应用程序的交互
28 | <https://github.com/BenjaminAbt/Samples.AspNetCore-IdentityServer4>
29 | 
30 | ## 17.8 固定节点API与来自使用JWKS IdentityServer4令牌
31 | 演示如何使用IdentityServer4中的JWKS端点和RS256算法保护节点（Express）API。
32 | 使用更高质量的生产就绪模块提供IdentityServer4.Samples的NodeJsApi样本的替代方案。
33 | <https://github.com/lyphtec/idsvr4-node-jwks>


--------------------------------------------------------------------------------
/第一部分 简介/第03章 支持和规范.md:
--------------------------------------------------------------------------------
 1 | # 第03章 支持和规范
 2 | 
 3 | IdentityServer实现以下规范：   
 4 | 
 5 | ## 3.1 OpenID Connect
 6 | * OpenID Connect Core 1.0 ([规范](http://openid.net/specs/openid-connect-core-1_0.html))
 7 | * OpenID Connect Discovery 1.0 ([规范](http://openid.net/specs/openid-connect-discovery-1_0.html))
 8 | * OpenID Connect Session Management 1.0 - draft 28 ([规范](http://openid.net/specs/openid-connect-session-1_0.html))
 9 | * OpenID Connect Front-Channel Logout 1.0 - draft 02 ([规范](https://openid.net/specs/openid-connect-frontchannel-1_0.html))
10 | * OpenID Connect Back-Channel Logout 1.0 - draft 04 ([规范](https://openid.net/specs/openid-connect-backchannel-1_0.html))   
11 | 
12 | ## 3.2 OAuth 2.0
13 | * OAuth 2.0 ([RFC 6749](http://tools.ietf.org/html/rfc6749))
14 | * OAuth 2.0 Bearer Token Usage ([RFC 6750](http://tools.ietf.org/html/rfc6750))
15 | * OAuth 2.0 Multiple Response Types ([规范](http://openid.net/specs/oauth-v2-multiple-response-types-1_0.html))
16 | * OAuth 2.0 Form Post Response Mode ([规范](http://openid.net/specs/oauth-v2-form-post-response-mode-1_0.html))
17 | * OAuth 2.0 Token Revocation ([RFC 7009](https://tools.ietf.org/html/rfc7009))
18 | * OAuth 2.0 Token Introspection ([RFC 7662](https://tools.ietf.org/html/rfc7662))
19 | * Proof Key for Code Exchange ([RFC 7636](https://tools.ietf.org/html/rfc7636))
20 | * JSON Web Tokens for Client Authentication ([RFC 7523](https://tools.ietf.org/html/rfc7523))
21 | * OAuth 2.0 Device Flow for Browserless and Input Constrained Devices ([草稿](https://tools.ietf.org/html/draft-ietf-oauth-device-flow-13))   
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # 欢迎来到IdentityServer4
 2 | 
 3 | **<big>欢迎IdentityServer4</big>**     
 4 | 
 5 | <div align="center">
 6 | <img src="https://identityserver4.readthedocs.io/en/latest/_images/logo.png"/>
 7 | </div>   
 8 | 
 9 | IdentityServer4是ASP\.NET Core 2的OpenID Connect和OAuth 2.0框架。  
10 | 
11 | > **警告**  
12 | 从2020年10月1日起，我们成立了一家新的[公司](https://duendesoftware.com/) 。 所有新的主要功能工作都将在我们新的[组织](https://github.com/duendesoftware)中进行。 新的 Duende IdentityServer 可在 FOSS (RPL) 和商业许可下使用。 开发和测试始终免费。[联系](https://duendesoftware.com/contact)了解更多信息。  
13 | IdentityServer4将在2022年11月之前进行错误修复和安全更新。
14 | 
15 | > **注**  
16 | 本文档涵盖了主分支上的最新版本。这可能尚未发布。使用左下角的版本选择器选择特定版本的文档。  
17 | 
18 | 它在您的应用程序中启用以下功能：   
19 | 
20 | **<big>身份验证即服务</big>**
21 | 所有应用程序（Web、原生、移动、服务）的集中登录逻辑和工作流。
22 | IdentityServer 是 OpenID Connect 的官方 [认证](https://openid.net/certification/) 实现。  
23 | 
24 | **<big>单点登录/注销</big>**
25 | 通过多种应用程序类型进行单点登录（和注销）。  
26 | 
27 | **<big>API访问控制</big>**
28 | 为各种类型的客户端发布 API 的访问令牌，例如 服务器到服务器、Web 应用程序、SPA 和原生/移动应用程序。 
29 | 
30 | **<big>联合网关</big>**
31 | 支持外部身份提供商，如 Azure Active Directory、Google、Facebook 等。
32 | 这使您的应用程序免受如何连接到这些外部提供商的详细信息的影响。  
33 | 
34 | **<big>专注于定制</big>**
35 | 最重要的部分 - IdentityServer 的许多方面都可以定制以满足 您 的需求。由于 IdentityServer 是一个框架，而不是盒装产品或 SaaS，您可以编写代码来调整系统，使其适合您的场景。
36 | 
37 | **<big>成熟的开源</big>**
38 | IdentityServer使用允许的[Apache 2](https://www.apache.org/licenses/LICENSE-2.0)许可证，允许在其上构建商业产品。它也是[.NET Foundation](https://dotnetfoundation.org/)的一部分，它提供治理和法律支持。  
39 | 
40 | **<big>免费和商业支持</big>**
41 | 如果您需要帮助构建或运行您的身份平台，[请告诉我们](mailto:contact@identityserver.io) 。我们可以通过多种方式帮助您。
42 | 


--------------------------------------------------------------------------------
/第三部分 主题/第28章 确认(Consent).md:
--------------------------------------------------------------------------------
 1 | # 第28章 确认(Consent)
 2 | 在授权请求期间，如果IdentityServer需要用户同意，则浏览器将被重定向到同意页面。
 3 | 
 4 | 同意用于允许最终用户授予客户端对资源（身份或API）的访问权限。这通常仅对第三方客户端是必需的，并且可以在客户端设置上按客户端启用/禁用。
 5 | 
 6 | ## 28.1 确认页
 7 | 为了让用户同意，托管应用程序必须提供同意页面。该快速入门UI有一个批准页面的基本实现。
 8 | 
 9 | 同意页面通常呈现当前用户的显示名称，请求访问的客户端的显示名称，客户端的徽标，有关客户端的更多信息的链接以及客户端请求访问的资源列表。允许用户表明他们的同意应该被“记住”也是很常见的，因此将来不会再次提示同一客户。
10 | 
11 | 一旦用户提供了同意，同意页面必须通知IdentityServer同意，然后必须将浏览器重定向回授权端点。
12 | 
13 | ## 28.2 授权上下文
14 | IdentityServer将*returnUrl*参数（可在用户交互选项上配置）传递到包含授权请求参数的同意页面。这些参数提供了同意页面的上下文，可以在交互服务的帮助下阅读。该`GetAuthorizationContextAsync`API将返回的实例`AuthorizationRequest`。
15 | 
16 | 可以使用`IClientStore`和`IResourceStore`接口获取有关客户端或资源的其他详细信息。
17 | 
18 | ## 28.3 通知IdentityServer同意结果
19 | 该API允许'grantconsentasync'在[交互服务](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC59%E7%AB%A0%20IdentityServer%E4%BA%A4%E4%BA%92%E6%9C%8D%E5%8A%A1.md)页面通知identityserver同意的结果（这也可能是在客户端访问等）。
20 | 
21 | IdentityServer将暂时保留同意的结果。这种持久性默认使用cookie，因为它只需要持续足够长的时间来将结果传回给授权端点。这种临时持久性与用于“记住我的同意”功能的持久性不同（并且授权端点持续“记住我对用户的同意”）。如果您希望在同意页面和授权重定向之间使用其他一些持久性，那么您可以`IMessageStore<ConsentResponse>`在DI中实现并注册实现。
22 | 
23 | ## 28.4 将用户返回到授权端点
24 | 一旦同意页面通知IdentityServer结果，就可以将用户重定向回*returnUrl*。您的同意页面应通过验证*returnUrl*是否有效来防止打开重定向。这可以通过调用[交互服务](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC59%E7%AB%A0%20IdentityServer%E4%BA%A4%E4%BA%92%E6%9C%8D%E5%8A%A1.md)的`IsValidReturnUrl`来完成。此外，如果`GetAuthorizationContextAsync`返回非null结果，那么您还可以信任*returnUrl*有效。


--------------------------------------------------------------------------------
/第六部分 其它/第64章 学习.md:
--------------------------------------------------------------------------------
 1 | # 第64章 学习
 2 | 以下是一些在线，远程和课堂培训选项，以了解有关ASP.NET Core Identity和IdentityServer4的更多信息。
 3 | 
 4 | ## 64.1 现代应用程序的身份和访问控制（使用ASP.NET Core 2和IdentityServer4）
 5 | 这是我们为期三天的旗舰课程（包括广泛的实践实验室），我们作为会议，现场和远程的一部分提供。
 6 | 
 7 | 可在[此处](https://identityserver.io/training)找到公共培训的议程和日期，请[联系](mailto:identity@leastprivilege.com)我们参加私人研讨会。
 8 | 
 9 | ## 64.2 PluralSight课程
10 | PluralSight有一些关于身份，ASP.NET Core和IdentityServer的优秀课程。
11 | 
12 | * **新**
13 |     * [使用OpenID和OAuth2保护Angular应用程序](https://www.pluralsight.com/courses/openid-and-oauth2-securing-angular-apps)
14 |     * [ASP.NET核心身份管理手册](https://app.pluralsight.com/library/courses/aspnet-core-identity-management-playbook/table-of-contents)
15 |     * [ASP.NET Core和OAuth入门](https://www.pluralsight.com/courses/asp-dot-net-core-oauth/)
16 |     * [使用OAuth2和OpenID Connect保护ASP.NET Core](https://app.pluralsight.com/library/courses/asp-dotnet-core-oauth2-openid-connect-securing/)
17 |     * [了解ASP.NET核心安全性（使用令牌服务进行集中身份验证）](https://app.pluralsight.com/library/courses/asp-dot-net-core-security-understanding/)
18 | 
19 | * **旧的**
20 |     * [OAuth2，OpenID Connect和JSON Web令牌（JWT）简介](https://app.pluralsight.com/library/courses/oauth2-json-web-tokens-openid-connect-introduction/table-of-contents)
21 |     * [Web API v2安全性](https://app.pluralsight.com/library/courses/webapi-v2-security/table-of-contents)
22 |     * [使用OAuth保护ASP.NET API](https://app.pluralsight.com/library/courses/oauth-secure-asp-dot-net-api/table-of-contents)
23 |     * [Angular和ASP.NET的OAuth2和OpenID Connect策略](https://app.pluralsight.com/library/courses/oauth2-openid-connect-angular-aspdotnet/table-of-contents)


--------------------------------------------------------------------------------
/第三部分 主题/第43章 添加更多API端点.md:
--------------------------------------------------------------------------------
 1 | # 第43章 添加更多API端点
 2 | 您可以向托管IdentityServer4的应用程序添加更多API端点。
 3 | 
 4 | 您通常希望通过它们所托管的IdentityServer实例来保护这些API。这不是问题。只需将令牌验证处理程序添加到主机（请参阅[此处](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC29%E7%AB%A0%20%E4%BF%9D%E6%8A%A4API.md)）：
 5 | 
 6 | ``` C#
 7 | public void ConfigureServices(IServiceCollection services)
 8 | {
 9 |     services.AddMvc();
10 | 
11 |     // details omitted
12 |     services.AddIdentityServer();
13 | 
14 |     services.AddAuthentication()
15 |         .AddIdentityServerAuthentication("token", isAuth =>
16 |         {
17 |             isAuth.Authority = "base_address_of_identityserver";
18 |             isAuth.ApiName = "name_of_api";
19 |         });
20 | }
21 | ```   
22 | 
23 | 在您的API上，您需要添加`[Authorize]`属性并显式引用您要使用的身份验证方案（在此示例中`token`，您可以选择您喜欢的任何名称）：
24 | 
25 | ``` C#
26 | public class TestController : ControllerBase
27 | {
28 |     [Route("test")]
29 |     [Authorize(AuthenticationSchemes = "token")]
30 |     public IActionResult Get()
31 |     {
32 |         var claims = User.Claims.Select(c => new { c.Type, c.Value }).ToArray();
33 |         return Ok(new { message = "Hello API", claims });
34 |     }
35 | }
36 | ```  
37 | 
38 | 如果要从浏览器调用该API，则还需要配置CORS（请参阅[此处](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC41%E7%AB%A0%20CORS.md)）。
39 | 
40 | ## 43.1 发现
41 | 如果需要，您还可以将端点添加到发现文档中，例如：
42 | 
43 | ``` C#
44 | services.AddIdentityServer(options =>
45 | {
46 |     options.Discovery.CustomEntries.Add("custom_endpoint", "~/api/custom");
47 | })
48 | ```


--------------------------------------------------------------------------------
/第三部分 主题/第30章 部署.md:
--------------------------------------------------------------------------------
 1 | # 第30章 部署
 2 | 您的身份服务器只是一个标准的ASP.NET Core应用程序，包括IdentityServer中间件。首先阅读有关发布和部署的官方Microsoft [文档](https://docs.microsoft.com/en-us/aspnet/core/publishing)（尤其是有关负载平衡器和代理的[部分](https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/proxy-load-balancer?view=aspnetcore-2.2#scenarios-and-use-cases)）。
 3 | 
 4 | ## 30.1 典型架构
 5 | 通常，您将设计IdentityServer部署以实现高可用性：
 6 | 
 7 | <div align="center">
 8 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/deployment.png"/>
 9 | </div>
10 | 
11 | IdentityServer本身是无状态的，不需要服务器关联 - 但是有些数据需要在实例之间共享。
12 | 
13 | ## 30.2 配置数据
14 | 这通常包括：
15 | 
16 | * 资源
17 | * 客户
18 | * 启动配置，例如密钥材料，外部提供商设置等......  
19 | 
20 | 存储数据的方式取决于您的环境。在配置数据很少更改的情况下，我们建议使用内存存储和代码或配置文件。
21 | 
22 | 在高度动态的环境（例如Saas）中，我们建议使用数据库或配置服务动态加载配置。
23 | 
24 | IdentityServer支持开箱即用的代码配置和配置文件（请参阅[此处](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration)）。对于数据库，我们为基于[Entity Framework Core](https://github.com/IdentityServer/IdentityServer4.EntityFramework)的数据库提供支持。
25 | 
26 | 您还可以通过实现`IResourceStore`和`IClientStore`构建自己的配置存储。
27 | 
28 | ## 30.3 密钥材料
29 | 另一个重要的启动配置是您的主要材料，请参阅[此处](https://identityserver4.readthedocs.io/en/latest/topics/crypto.html#refcrypto)以获取有关密钥材料和加密的更多详细信息。
30 | 
31 | ## 30.4 运营数据
32 | 对于某些操作，IdentityServer需要持久性存储来保持状态，这包括：
33 | 
34 | * 发布授权码
35 | * 发出参考和刷新令牌
36 | * 存储同意  
37 | 
38 | 您既可以使用传统数据库来存储操作数据，也可以使用具有Redis等持久性功能的缓存。上面提到的EF Core实现也支持运营数据。
39 | 
40 | 您还可以通过实现`IPersistedGrantStore`对自己的自定义存储机制的支持- 默认情况下IdentityServer会注入内存中的版本。
41 | 
42 | ## 30.5 ASP.NET Core 数据保护
43 | ASP.NET Core本身需要共享密钥材料来保护敏感数据，如cookie，状态字符串等。请参阅[此处](https://docs.microsoft.com/en-us/aspnet/core/security/data-protection/)的官方文档。
44 | 
45 | 您可以重复使用上述持久性存储之一，也可以使用像共享文件这样的简单文件。


--------------------------------------------------------------------------------
/第三部分 主题/第31章 日志.md:
--------------------------------------------------------------------------------
 1 | # 第31章 日志
 2 | IdentityServer使用ASP.NET Core提供的标准日志记录工具。Microsoft[文档](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/logging)有一个很好的介绍和内置日志记录提供程序的描述。
 3 | 
 4 | 我们大致遵循Microsoft使用日志级别的指导原则：
 5 | 
 6 | * `Trace`仅供开发人员解决问题的信息。这些消息可能包含敏感的应用程序数据（如令牌），不应在生产环境中启用。
 7 | * `Debug`遵循内部流程并理解为何做出某些决定。在开发和调试过程中具有短期实用性。
 8 | * `Information`用于跟踪应用程序的一般流程。这些日志通常具有一些长期价值。
 9 | * `Warning`对于应用程序流中的异常或意外事件。这些可能包括错误或其他不会导致应用程序停止但可能需要调查的条件。
10 | * `Error`对于无法处理的错误和异常。示例：协议请求的验证失败。
11 | * `Critical`对于需要立即关注的故障。示例：缺少商店实施，无效的密钥材料......
12 | 
13 | ## 31.1 Serilog的设置
14 | 我们个人非常喜欢[Serilog](https://serilog.net/)。试试看。
15 | 
16 | ## 31.2 ASP.NET Core2.0+ 
17 | 对于以下配置，您需要`Serilog.AspNetCore`和`Serilog.Sinks.Console`包：
18 | 
19 | ``` C#
20 | public class Program
21 | {
22 |     public static void Main(string[] args)
23 |     {
24 |         Console.Title = "IdentityServer4";
25 | 
26 |         Log.Logger = new LoggerConfiguration()
27 |             .MinimumLevel.Debug()
28 |             .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
29 |             .MinimumLevel.Override("System", LogEventLevel.Warning)
30 |             .MinimumLevel.Override("Microsoft.AspNetCore.Authentication", LogEventLevel.Information)
31 |             .Enrich.FromLogContext()
32 |             .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}", theme: AnsiConsoleTheme.Literate)
33 |             .CreateLogger();
34 | 
35 |         BuildWebHost(args).Run();
36 |     }
37 | 
38 |     public static IWebHost BuildWebHost(string[] args)
39 |     {
40 |         return WebHost.CreateDefaultBuilder(args)
41 |                 .UseStartup<Startup>()
42 |                 .UseSerilog()
43 |                 .Build();
44 |     }
45 | }
46 | ```  
47 | 


--------------------------------------------------------------------------------
/第三部分 主题/第27章 联合网关.md:
--------------------------------------------------------------------------------
 1 | # 第27章 联合网关
 2 | 通用架构是所谓的联合网关。在此方法中，IdentityServer充当一个或多个外部身份提供商的网关。
 3 | 
 4 | <div align="center">
 5 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/federation_gateway.png" />
 6 | </div>
 7 | 
 8 | 该架构具有以下优点:
 9 | 
10 | * 您的应用程序只需要了解一个令牌服务（网关），并且屏蔽了有关连接到外部提供程序的所有详细信息。这也意味着您可以添加或更改这些外部提供程序，而无需更新您的应用程序。
11 | * 您控制网关（而不是某些外部服务提供商） - 这意味着您可以对其进行任何更改，并保护您的应用程序免受外部提供程序可能对其自己的服务所做的更改。
12 | * 大多数外部提供商仅支持一组固定的声明和声明类型 - 中间有一个网关允许对提供商的响应进行后处理，以转换/添加/修改特定于域的身份信息。
13 | * 某些提供商不支持访问令牌（例如社交提供商） - 因为网关知道您的API，它可以根据外部身份发出访问令牌。
14 | * 某些提供商根据您连接的应用程序数量收费。网关充当外部提供程序的单个应用程序。在内部，您可以根据需要连接任意数量的应用程序。
15 | * 一些提供商使用专有协议或对标准协议进行专有修改 - 通过网关，您只需要处理一个地方。
16 | * 通过一个地方强制进行每次身份验证（内部或外部），可以为身份映射提供极大的灵活性，为所有应用程序提供稳定的身份并处理新的需求  
17 | 
18 | 换句话说 - 拥有联合网关可以让您对身份基础结构进行大量控制。由于您的用户身份是您最重要的资产之一，我们建议您控制网关。
19 | 
20 | ## 27.1 实现
21 | 我们的[快速入门UI](https://github.com/IdentityServer/IdentityServer4.Quickstart.UI)使用了以下一些功能。另请参阅[外部身份验证快速入门](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%8C%E9%83%A8%E5%88%86%20%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8/%E7%AC%AC12%E7%AB%A0%20%E6%B7%BB%E5%8A%A0%E5%AF%B9%E5%A4%96%E9%83%A8%E8%AE%A4%E8%AF%81%E7%9A%84%E6%94%AF%E6%8C%81.md)和有关[外部提供程序](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC22%E7%AB%A0%20%E4%BD%BF%E7%94%A8%E5%A4%96%E9%83%A8%E8%BA%AB%E4%BB%BD%E6%8F%90%E4%BE%9B%E5%95%86%E7%99%BB%E5%BD%95.md)的文档。
22 | 
23 | * 您可以通过向IdentityServer应用程序添加身份验证处理程序来添加对外部身份提供程序的支持。
24 | * 你可以通过调用程序查询这些外部供应商`IAuthenticationSchemeProvider`。这允许基于已注册的外部提供程序动态呈现您的登录页面。
25 | * 我们的客户端配置模型允许基于每个客户端限制可用的提供者（使用该`IdentityProviderRestrictions`属性）。
26 | * 您还可以使用`EnableLocalLogin`客户端上的属性告诉您的UI是否应该呈现用户名/密码输入。
27 | * 我们的快速启动UI漏斗通过一个回调所有外部认证调用（见`ExternalLoginCallback`的`AccountController`类）。这允许单点进行后处理。


--------------------------------------------------------------------------------
/第一部分 简介/第01章 背景.md:
--------------------------------------------------------------------------------
 1 | # 第01章 背景
 2 | 
 3 | 大多数现代应用程序或多或少看起来像这样：
 4 | <div align="center">
 5 | <img src="https://identityserver4.readthedocs.io/en/latest/_images/appArch.png"/>
 6 | </div>   
 7 | 
 8 | 最常见的互动是：  
 9 |    
10 | * 浏览器与Web应用程序通信
11 | * Web应用程序与Web API进行通信（Web应用程序自身 或 代表用户 与 Web API 通信）
12 | * 基于浏览器的应用程序与Web API通信
13 | * 本地应用程序与Web API通信
14 | * 基于服务器的应用程序与Web API通信
15 | * Web API与Web API进行通信（WebAPI自身 或 代表用户与另一个WebAPI 通信）   
16 | 
17 | 通常，每个层（前端，中间层和后端）都必须保护资源并实现身份验证和授权 - 通常针对同一个用户存储。   
18 | 
19 | 将这些基本安全功能外包给安全令牌服务可防止在这些应用程序和端点之间复制该功能。   
20 | 
21 | 重构应用程序以支持安全令牌服务会产生以下体系结构和协议：   
22 | 
23 | <div align="center">
24 | <img src="https://identityserver4.readthedocs.io/en/latest/_images/protocols.png"/>
25 | </div>    
26 | 
27 | 这种设计将安全问题分为两部分：
28 | 
29 | ## 1.1 认证
30 | 当应用程序需要知道当前用户的身份时，需要进行身份验证。通常，这些应用程序代表该用户管理数据，并且需要确保该用户只能访问允许的数据。最常见的示例是（经典）Web应用程序 - 但是基于本地和JS的应用程序也需要身份验证。   
31 | 
32 | 最常见的身份验证协议是SAML2p，WS-Federation和OpenID Connect - SAML2p是最受欢迎和最广泛部署的。   
33 | 
34 | OpenID Connect是三者中的最新产品，但被认为是未来，因为它具有最大的现代应用潜力。它从一开始就为移动应用场景而构建，旨在实现API友好。
35 | 
36 | ## 1.2 API访问
37 | 应用程序有两种基本方式与API通信 - 使用应用程序标识或委派用户身份。有时两种方法都需要结合起来。   
38 | 
39 | OAuth2是一种协议，允许应用程序从安全令牌服务请求访问令牌，并使用它们与API通信。此委派降低了客户端应用程序和API的复杂性，因为身份验证和授权可以集中。
40 | 
41 | ## 1.3 OpenID Connect和OAuth 2.0 - 更好地结合在一起
42 | OpenID Connect和OAuth 2.0非常相似 - 事实上，OpenID Connect是OAuth 2.0之上的扩展。两个基本的安全问题，即身份验证和API访问，被合并为一个协议 - 通常只需一次往返安全令牌服务。   
43 | 
44 | 我们相信OpenID Connect和OAuth 2.0的结合是在可预见的未来保护现代应用程序的最佳方法。IdentityServer4是这两种协议的实现，经过高度优化，可以解决当今移动，本地和Web应用程序的典型安全问题。
45 | 
46 | ## 1.4 IdentityServer4如何提供帮助
47 | IdentityServer是一个中间件，可将符合规范的OpenID Connect和OAuth 2.0端点添加到任意ASP.NET Core应用程序中。   
48 | 
49 | 通常，您构建（或复用）包含登录和注销页面的应用程序（或者 授权确认页），并且IdentityServer 中间件会将需要的协议添加到页面头部，这样一来客户端应用程序就能够使用这些标准协议跟它协商了。
50 | 
51 | <div align="center">
52 | <img src="https://identityserver4.readthedocs.io/en/latest/_images/middleware.png"/>
53 | </div>    
54 | 
55 | 你可以根据你的需要使用尽可能复杂的宿主应用程序。但是，为了保持受攻击面尽可能小, 我们一般建议你只将认证相关的UI包含进来。
56 | 


--------------------------------------------------------------------------------
/第六部分 其它/第66章 视频.md:
--------------------------------------------------------------------------------
 1 | # 第66章 视频
 2 | ## 66.1 2019 
 3 | * [January [NDC] - 使用ASP.NET Core 2.2和3.0保护Web应用程序和API](https://www.youtube.com/watch?v=EYk3KTwwbFA)
 4 | * [1月[NDC] - 为基于OpenID Connect / OAuth 2的系统构建客户端](https://www.youtube.com/watch?v=BM091_OlX3o)
 5 | 
 6 | ## 66.2 2018
 7 | * [26/09 [DevConf] - 现代应用程序的授权](https://www.youtube.com/watch?v=Dlrf85NTuAU&feature=youtu.be)
 8 | * [17/01 [NDC伦敦] - ASP.NET Core v2上的IdentityServer v2 - 一个更新](https://vimeo.com/254635632)
 9 | * [17/01 [NDC London] - 实施Web应用程序和API授权（又名PolicyServer公告）](https://vimeo.com/254635640)
10 | * [17/01 [DotNetRocks] - DotNetRocks上的IdentityServer和PolicyServer](https://dotnetrocks.com/?show=1515)
11 | 
12 | ## 66.3 2017
13 | * [14/09 [Microsoft Learning] - IdentityServer for ASP.NET Core简介 - Brock Allen](https://mva.microsoft.com/en-US/training-courses/introduction-to-identityserver-for-aspnet-core-17945)
14 | * [14/06 [NDC Oslo] - 实施Web应用程序和API的授权](https://vimeo.com/223982185)
15 | * [22/02 [NDC Mini Copenhagen] - IdentityServer4：ASP.NET核心的新增和改进 - Dominick Baier](https://vimeo.com/215352044)
16 | * [02/02 [DotNetRocks] - DotNetRocks上的IdentityServer4](https://www.dotnetrocks.com/?show=1409)
17 | * [16/01 [NDC伦敦] - IdentityServer4：ASP.NET核心的新增功能和改进版](https://vimeo.com/204141878)
18 | * [16/01 [NDC London] - 为基于令牌的架构构建JavaScript和移动/本机客户端](https://vimeo.com/205451987)
19 | 
20 | ## 66.4 2016 
21 | * [.NET身份和IdentityServer Channel9采访的历史](https://channel9.msdn.com/events/Seth-on-the-Road/NDC-London-2016/Dominick-Baier-on-Identity-Server)
22 | * [本机和移动应用程序的身份验证和安全API访问 - Dominick Baier](https://vimeo.com/171942749)
23 | * [ASP.NET身份3 - Brock Allen](https://vimeo.com/172009501)
24 | * [IdentityServer3简介 - Brock Allen](https://vimeo.com/154172925)
25 | 
26 | ## 66.5 2015年
27 | * [保护Web API - 模式和反模式 - Dominick Baier](https://vimeo.com/131635255)
28 | * [现代JavaScript Web应用程序中的身份验证和授权 - 它有多难？ - 布洛克艾伦](https://vimeo.com/131636653)
29 | 
30 | ## 66.6 2014 
31 | * [使用OpenID Connect和OAuth 2统一移动，Web和桌面的身份验证和委托API访问 - Dominick Baier](https://vimeo.com/113604459)


--------------------------------------------------------------------------------
/第四部分 端点/第53章 结束会话端点(End Session Endpoint).md:
--------------------------------------------------------------------------------
 1 | # 第53章 结束会话端点(End Session Endpoint)
 2 | 结束会话端点可用于触发单点注销（请参阅[规范](https://openid.net/specs/openid-connect-session-1_0.html#RPLogout)）。  
 3 | 
 4 | 要使用结束会话端点，客户端应用程序会将用户的浏览器重定向到结束会话URL。用户在会话期间通过浏览器登录的所有应用程序都可以参与注销。
 5 | 
 6 | > **注意**
 7 | 终端会话端点的URL可通过[发现端点(discovery endpoint)]()获得。
 8 | 
 9 | ## 53.1 Parameters
10 | **id_token_hint**  
11 | 当用户被重定向到端点时，系统会提示他们是否真的想要注销。发送从身份验证收到的原始*id_token*的客户端可以绕过此提示。这是作为查询的字符串参数传递的`id_token_hint`。
12 | 
13 | **post_logout_redirect_uri**  
14 | 如果`id_token_hint`有效传递了，则客户端也可以发送`post_logout_redirect_uri`参数。这可用于允许用户在注销后重定向回客户端。该值必须与客户端预先配置的*PostLogoutRedirectUris*`*（[客户端文档](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC56%E7%AB%A0%20Client.md)）之一匹配。
15 | 
16 | **State**
17 | 如果`post_logout_redirect_uri`有效，则客户端也可以发送`state`参数。在用户重定向回客户端后，这将作为查询字符串参数返回给客户端。这通常由客户端用于跨重定向的往返状态。
18 | 
19 | 示例
20 | ```
21 | GET /connect/endsession?id_token_hint=eyJhbGciOiJSUzI1NiIsImtpZCI6IjdlOGFkZmMzMjU1OTEyNzI0ZDY4NWZmYmIwOThjNDEyIiwidHlwIjoiSldUIn0.eyJuYmYiOjE0OTE3NjUzMjEsImV4cCI6MTQ5MTc2NTYyMSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo1MDAwIiwiYXVkIjoianNfb2lkYyIsIm5vbmNlIjoiYTQwNGFjN2NjYWEwNGFmNzkzNmJjYTkyNTJkYTRhODUiLCJpYXQiOjE0OTE3NjUzMjEsInNpZCI6IjI2YTYzNWVmOTQ2ZjRiZGU3ZWUzMzQ2ZjFmMWY1NTZjIiwic3ViIjoiODg0MjExMTMiLCJhdXRoX3RpbWUiOjE0OTE3NjUzMTksImlkcCI6ImxvY2FsIiwiYW1yIjpbInB3ZCJdfQ.STzOWoeVYMtZdRAeRT95cMYEmClixWkmGwVH2Yyiks9BETotbSZiSfgE5kRh72kghN78N3-RgCTUmM2edB3bZx4H5ut3wWsBnZtQ2JLfhTwJAjaLE9Ykt68ovNJySbm8hjZhHzPWKh55jzshivQvTX0GdtlbcDoEA1oNONxHkpDIcr3pRoGi6YveEAFsGOeSQwzT76aId-rAALhFPkyKnVc-uB8IHtGNSyRWLFhwVqAdS3fRNO7iIs5hYRxeFSU7a5ZuUqZ6RRi-bcDhI-djKO5uAwiyhfpbpYcaY_TxXWoCmq8N8uAw9zqFsQUwcXymfOAi2UF3eFZt02hBu-shKA&post_logout_redirect_uri=http%3A%2F%2Flocalhost%3A7017%2Findex.html
22 | ```  
23 | 
24 | > **注意**
25 | 您可以使用[IdentityModel](https://github.com/IdentityModel/IdentityModel2)客户端库以编程方式创建end_session请求.NET代码。有关更多信息，请查看IdentityModel[文档](https://identitymodel.readthedocs.io/en/latest/client/end_session.html)。


--------------------------------------------------------------------------------
/第四部分 端点/第49章 令牌端点(Token Endpoint).md:
--------------------------------------------------------------------------------
 1 | # 第49章 令牌端点(Token Endpoint)
 2 | 令牌端点可用于以编程方式请求令牌。它支持`password`，`authorization_code`，`client_credentials`，`refresh_token`和`urn:ietf:params:oauth:grant-type:device_code`的类型。此外，可以扩展令牌端点以支持扩展授权类型。
 3 | 
 4 | > **注意**
 5 | IdentityServer支持OpenID Connect和OAuth 2.0令牌请​​求参数的子集。有关完整列表，请参见[此处](http://openid.net/specs/openid-connect-core-1_0.html#TokenRequest)。
 6 | 
 7 | * **`client_id`**  
 8 | 客户标识符（必填）
 9 | 
10 | * **`client_secret`**  
11 | 客户端密钥可以在帖子正文中，也可以作为基本身份验证标头。可选的。
12 | 
13 | * **`grant_type`**  
14 | `authorization_code`，`client_credentials`，`password`，`refresh_token`，`urn:ietf:params:oauth:grant-type:device_code`或自定义
15 | 
16 | * **`scope`**  
17 | 一个或多个注册范围。如果未指定，将发出所有明确允许范围的标记。
18 | 
19 | * **`redirect_uri`**  
20 | `authorization_code`授权类型所需
21 | 
22 | * **`code`**  
23 | 授权代码（`authorization_code`授权类型需要）
24 | 
25 | * **`code_verifier`**  
26 | PKCE证明密钥
27 | 
28 | * **`username`**  
29 | 资源所有者用户名（`password`授权类型所需）
30 | 
31 | * **`password`**  
32 | 资源所有者密码（`password`授予类型所需）
33 | 
34 | * **`acr_values`**  
35 | 允许传递`password`授权类型的其他身份验证相关信息- identityserver特殊情况下面的专有acr_values：
36 |     * `idp:name_of_idp` 绕过login/home领域页面并将用户直接转发到选定的身份提供者（如果允许每个客户端配置）
37 |     * `tenant:name_of_tenant` 可用于将租户名称传递给令牌端点
38 | 
39 | * **`refresh_token`**  
40 | 刷新令牌（`refresh_token`授予类型所需）
41 | 
42 | * **`device_code`**  
43 | 设备代码（`urn:ietf:params:oauth:grant-type:device_code`授权类型所需）
44 | 
45 | ## 48.1 示例
46 | 
47 | ```
48 | POST /connect/token
49 | 
50 |     client_id=client1&
51 |     client_secret=secret&
52 |     grant_type=authorization_code&
53 |     code=hdh922&
54 |     redirect_uri=https://myapp.com/callback
55 | ```
56 | 
57 | （为了便于阅读，删除了表格编码并添加了换行符）
58 | 
59 | > **注意**
60 | 您可以使用[IdentityModel](https://github.com/IdentityModel/IdentityModel2)客户端库以编程方式从.NET代码访问令牌端点。有关更多信息，请查看IdentityModel[文档](https://github.com/thinksjay/IdentityModel/blob/master/%E7%AC%AC%E4%B8%80%E9%83%A8%E5%88%86%20%E5%8D%8F%E8%AE%AE%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%BA%93/%E7%AC%AC4%E7%AB%A0%20%E4%BB%A4%E7%89%8C%E7%AB%AF%E7%82%B9(Token%20Endpoint).md)。


--------------------------------------------------------------------------------
/第五部分 参考/第55章  API资源.md:
--------------------------------------------------------------------------------
 1 | # 第55章 API资源
 2 | 此类建模API资源。   
 3 | 
 4 | * **`Enabled`**  
 5 | 指示此资源是否已启用且可以请求。默认为true。
 6 | 
 7 | * **`Name`**  
 8 | API的唯一名称。此值用于内省身份验证，并将添加到传出访问令牌的受众。
 9 | 
10 | * **`DisplayName`**  
11 | 该值可以在例如同意屏幕上使用。
12 | 
13 | * **`Description`**  
14 | 该值可以在例如同意屏幕上使用。
15 | 
16 | * **`ApiSecrets`**  
17 | API密钥用于内省端点。API可以使用API​​名称和密钥进行内省验证。
18 | 
19 | * **`UserClaims`**  
20 | 应包含在访问令牌中的关联用户声明类型的列表。
21 | 
22 | * **`Scopes`**  
23 | API必须至少有一个范围。每个范围可以有不同的设置。   
24 | 
25 | ## 55.1 范围
26 | 在简单的情况下，API只有一个范围。但是在某些情况下，您可能希望细分API的功能，并让不同的客户端访问不同的部分。  
27 | 
28 | * **`Name`**  
29 | 范围的唯一名称。这是客户端将用于授权/令牌请求中的scope参数的值。
30 | 
31 | * **`DisplayName`**  
32 | 该值可以在例如同意屏幕上使用。
33 | 
34 | * **`Description`**  
35 | 该值可以在例如同意屏幕上使用。
36 | 
37 | * **`Required`**  
38 | 指定用户是否可以在同意屏幕上取消选择范围（如果同意屏幕要实现此类功能）。默认为false。
39 | 
40 | * **`Emphasize`**  
41 | 指定同意屏幕是否会强调此范围（如果同意屏幕要实现此功能）。将此设置用于敏感或重要范围。默认为false。
42 | 
43 | * **`ShowInDiscoveryDocument`**  
44 | 指定此范围是否显示在发现文档中。默认为true。
45 | 
46 | * **`UserClaims`**  
47 | 应包含在访问令牌中的关联用户声明类型的列表。此处指定的声明将添加到为API指定的声明列表中。
48 | 
49 | ## 55.2 便利构造函数行为
50 | 只是关于为`ApiResource`类提供的构造函数的注释。  
51 | 
52 | 要完全控制数据`ApiResource`，请使用不带参数的默认构造函数。如果要为每个API配置多个范围，可以使用此方法。例如：   
53 | 
54 | ``` C#
55 | new ApiResource
56 | {
57 |     Name = "api2",
58 | 
59 |     Scopes =
60 |     {
61 |         new Scope()
62 |         {
63 |             Name = "api2.full_access",
64 |             DisplayName = "Full access to API 2"
65 |         },
66 |         new Scope
67 |         {
68 |             Name = "api2.read_only",
69 |             DisplayName = "Read only access to API 2"
70 |         }
71 |     }
72 | }
73 | ```   
74 | 
75 | 对于每个API只需要一个范围的简单方案，则提供了几个接受a的便捷构造函数`name`。例如：
76 | 
77 | ``` C#
78 | new ApiResource("api1", "Some API 1")
79 | ```   
80 | 
81 | 使用便利构造函数等同于：  
82 | 
83 | ``` C#
84 | new ApiResource
85 | {
86 |     Name = "api1",
87 |     DisplayName = "Some API 1",
88 | 
89 |     Scopes =
90 |     {
91 |         new Scope()
92 |         {
93 |             Name = "api1",
94 |             DisplayName = "Some API 1"
95 |         }
96 |     }
97 | }
98 | ```


--------------------------------------------------------------------------------
/第三部分 主题/第41章 CORS.md:
--------------------------------------------------------------------------------
 1 | # 第41章 CORS
 2 | IdentityServer中的许多端点将通过基于JavaScript的客户端的Ajax调用进行访问。鉴于IdentityServer最有可能托管在与这些客户端不同的源上，这意味着需要配置[跨源资源共享](http://www.html5rocks.com/en/tutorials/cors/)（CORS）。
 3 | 
 4 | ## 41.1 基于客户端的CORS配置
 5 | 配置CORS的一种方法是在[客户端配置](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC56%E7%AB%A0%20Client.md)上使用`AllowedCorsOrigins`该集合。只需将客户端的原点添加到集合中，IdentityServer中的默认配置将查询这些值以允许来自源的跨源调用。
 6 | 
 7 | > **注意**
 8 | 配置CORS时，请务必使用原点（不是URL）。例如：`https://foo:123/`是一个URL，而是`https://foo:123`一个原点。
 9 | 
10 | 如果您使用我们提供的“内存中”或基于EF的客户端配置，则将使用此默认CORS实现。如果您定义自己的`IClientStore`，那么您将需要实现自己的自定义CORS策略服务（见下文）。
11 | 
12 | ## 41.2 自定义Cors策略服务
13 | IdentityServer允许托管应用程序实现`ICorsPolicyService`完全控制CORS策略。
14 | 
15 | 要实现单一的方法是：`Task<bool> IsOriginAllowedAsync(string origin)`。如果允许原点则返回true，否则返回false
16 | 
17 | 实现后，只需在DI中注册实现，然后IdentityServer将使用您的自定义实现。
18 | 
19 | ### 41.2.1 DefaultCorsPolicyService
20 | 
21 | 如果您只是希望对一组允许的原点进行硬编码，那么您可以使用一个预先构建`ICorsPolicyService`的实现调用`DefaultCorsPolicyService`。这将被配置为DI单例，并以其硬编码的`AllowedOrigins`收集，或设置标志`AllowAll`为true允许所有的源点。例如，在`ConfigureServices`：
22 | 
23 | ``` C#
24 | var cors = new DefaultCorsPolicyService(_loggerFactory.CreateLogger<DefaultCorsPolicyService>())
25 | {
26 |     AllowedOrigins = { "https://foo", "https://bar" }
27 | };
28 | services.AddSingleton<ICorsPolicyService>(cors);
29 | ```   
30 | 
31 | > **注意**
32 | AllowAll谨慎使用。
33 | 
34 | ## 41.3 将IdentityServer的CORS策略与ASP.NET Core的CORS策略混合
35 | IdentityServer使用ASP.NET Core的CORS中间件来提供其CORS实现。托管IdentityServer的应用程序可能还需要CORS用于自己的自定义端点。通常，两者应该在同一个应用程序中一起工作。
36 | 
37 | 您的代码应使用ASP.NET Core中记录的CORS功能，而不考虑IdentityServer。这意味着您应该定义策略并正常注册中间件。如果您的应用程序在`ConfigureServices`中定义了策略，那么这些策略应继续在您使用它们的相同位置（在您配置CORS中间件的地方或在`EnableCors`控制器代码中使用MVC 属性的位置）。相反，如果您使用CORS中间件（通过策略构建器回调）定义内联策略，那么它也应该继续正常工作。
38 | 
39 | 您使用ASP.NET Core CORS服务与IdentityServer之间可能存在冲突的一种情况是您决定创建自定义`ICorsPolicyProvider`。鉴于ASP.NET Core的CORS服务和中间件的设计，IdentityServer实现了自己的自定义`ICorsPolicyProvider`并将其注册到DI系统中。幸运的是，IdentityServer实现旨在使用装饰器模式来包装`ICorsPolicyProvider`已在DI中注册的任何现有模式 。这意味着你也可以实现`ICorsPolicyProvider`，但它只需要在DI中的IdentityServer之前注册（例如，在`ConfigureServices`）。
40 | 
41 | 


--------------------------------------------------------------------------------
/第四部分 端点/第47章 授权端点(Authorize Endpoint).md:
--------------------------------------------------------------------------------
 1 | # 第47章 授权端点(Authorize Endpoint)
 2 | 授权端点可用于通过浏览器请求令牌或授权码。此过程通常涉及最终用户的身份验证和可选的同意。
 3 | 
 4 | > **注意**
 5 | IdentityServer支持OpenID Connect和OAuth 2.0授权请求参数的子集。有关完整列表，请参见[此处](https://openid.net/specs/openid-connect-core-1_0.html#AuthRequest)。
 6 | 
 7 | * **`client_id`**  
 8 | 客户的标识符（必填）。
 9 | 
10 | * **`scope`**  
11 | 一个或多个注册范围（必填）
12 | 
13 | * **`redirect_uri`**  
14 | 必须与该客户端允许的重定向URI之一完全匹配（必需）
15 | 
16 | * **`response_type`**  
17 |     * `id_token` 请求身份令牌（仅允许身份范围）
18 |     * `token` 请求访问令牌（仅允许资源范围）
19 |     * `id_token token` 请求身份令牌和访问令牌
20 |     * `code` 请求授权码
21 |     * `code id_token` 请求授权代码和身份令牌
22 |     * `code id_token token` 请求授权代码，身份令牌和访问令牌
23 | 
24 | * **`response_mode`**  
25 |     * `form_post` 将令牌响应作为表单发送而不是片段编码重定向（可选）
26 | 
27 | * **`state`**  
28 | identityserver将回显令牌响应的状态值，这是针对客户端和提供者之间的往返状态，关联请求和响应以及CSRF /重放保护。（推荐的）
29 | 
30 | * **`nonce`**  
31 | identityserver将回显身份令牌中的nonce值，这是为了重放保护）
32 | 通过隐式授权对身份令牌是必需的。
33 | 
34 | * **`prompt`**  
35 |     * `none`请求期间不会显示任何UI。如果这是不可能的（例如，因为用户必须登录或同意），则返回错误
36 |     * `login` 即使用户已登录并具有有效会话，也会显示登录UI
37 | 
38 | * **`code_challenge`**  
39 | 发送PKCE的代码质询
40 | 
41 | * **`code_challenge_method`**  
42 | plain表示挑战是使用纯文本（不推荐） S256表示使用SHA256对挑战进行哈希处理
43 | 
44 | * **`login_hint`**  
45 | 可用于预先填写登录页面上的用户名字段
46 | 
47 | * **`ui_locales`**  
48 | 提供有关登录UI所需显示语言的提示
49 | 
50 | * **`max_age`**  
51 | 如果用户的登录会话超过最大年龄（以秒为单位），将显示登录UI
52 | 
53 | * **`acr_values`**  
54 | 允许传递其他身份验证相关信息 - 身份服务器特殊情况下面的专有acr_values：
55 |     * `idp:name_of_idp` 绕过login / home领域屏幕并将用户直接转发到选定的身份提供者（如果允许每个客户端配置）
56 |     * `tenant:name_of_tenant` 可用于将租户名称传递给登录UI
57 | 
58 | 例
59 | 
60 | ```
61 | GET /connect/authorize?
62 |     client_id=client1&
63 |     scope=openid email api1&
64 |     response_type=id_token token&
65 |     redirect_uri=https://myapp/callback&
66 |     state=abc&
67 |     nonce=xyz
68 | ```   
69 | 
70 | （删除了URL编码，并添加了换行符以提高可读性）
71 | 
72 | > **注意**
73 | 您可以使用[IdentityModel](https://github.com/IdentityModel/IdentityModel2)客户端库以编程方式创建授权请求.NET代码。有关更多信息，请查看IdentityModel[文档](https://github.com/thinksjay/IdentityModel/blob/master/%E7%AC%AC%E4%B8%80%E9%83%A8%E5%88%86%20%E5%8D%8F%E8%AE%AE%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%BA%93/%E7%AC%AC2%E7%AB%A0%20%E6%8E%88%E6%9D%83%E7%AB%AF%E7%82%B9(Authorize%20Endpoint).md)。


--------------------------------------------------------------------------------
/第五部分 参考/第58章 Profile Service.md:
--------------------------------------------------------------------------------
 1 | # 第58章 Profile Service
 2 | IdentityServer通常在创建令牌或处理对userinfo或内省端点的请求时需要有关用户的身份信息。默认情况下，IdentityServer仅具有身份验证cookie中的声明，以便为此身份数据进行绘制。
 3 | 
 4 | 将用户所需的所有可能声明放入cookie中是不切实际的，因此IdentityServer定义了一个可扩展点，允许根据用户需要动态加载声明。这个可扩展点是`IProfileService`开发人员通常可以实现此接口来访问包含用户身份数据的自定义数据库或API。
 5 | 
 6 | ## 58.1 IProfileService APIs 
 7 | * **`GetProfileDataAsync`**  
 8 | 期望为用户加载声明的API。它传递了一个实例`ProfileDataRequestContext`。
 9 | 
10 | * **`IsActiveAsync`**  
11 | 预期用于指示当前是否允许用户获取令牌的API。它传递了一个实例`IsActiveContext`。  
12 | 
13 | ## 58.2 ProfileDataRequestContext  
14 | 模拟用户声明的请求，并且是返回这些声明的工具。它包含以下属性：
15 | 
16 | * **`Subject`**  
17 | 该`ClaimsPrincipal`模型的用户。
18 | 
19 | * **`Client`**  
20 | `Client`用于正被请求的声明。
21 | 
22 | * **`RequestedClaimTypes`**  
23 | 请求的声明类型集合。
24 | 
25 | * **`Caller`**  
26 | 正在请求声明的上下文的标识符（例如，身份令牌，访问令牌或用户信息端点）。常量`IdentityServerConstants.ProfileDataCallers`包含不同的常量值。
27 | 
28 | * **`IssuedClaims`**  
29 | 将返回`Claim`的列表。预计这将由自定义`IProfileService`实现填充。
30 | 
31 | * **`AddRequestedClaims`**  
32 | 扩展方法对`ProfileDataRequestContext`填充`IssuedClaims`，但首先根据索引过滤`RequestedClaimTypes`。
33 | 
34 | ## 58.3 请求的范围和声明映射
35 | 客户端请求的范围控制用户声明在令牌中返回给客户端的内容。该`GetProfileDataAsync`方法负责根据`ProfileDataRequestContext`上的`RequestedClaimTypes`集合动态获取这些声明。
36 | 
37 | 该`RequestedClaimTypes`集合是基于该定义的用户[声明资源](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC19%E7%AB%A0%20%E5%AE%9A%E4%B9%89%E8%B5%84%E6%BA%90.md)的范围进行建模。如果请求的范围是[身份资源](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC54%E7%AB%A0%20%E8%BA%AB%E4%BB%BD%E8%B5%84%E6%BA%90.md)，则将`RequestedClaimTypes`根据在`IdentityResource`中定义的用户声明类型填充声明中的声明。如果请求的范围是[API资源](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC55%E7%AB%A0%20%20API%E8%B5%84%E6%BA%90.md)，则将`RequestedClaimTypes`根据`ApiResource`中定义的用户声明类型填充声明中的声明`Scope`。
38 | 
39 | ## 58.4 IsActiveContext 
40 | 对要确定的请求建模是当前允许用户获取令牌。它包含以下属性：
41 | 
42 | * **`Subject`**  
43 | 该`ClaimsPrincipal`模型的用户。
44 | 
45 | * **`Client`**  
46 | `Client`用于正被请求的声明。
47 | 
48 | * **`Caller`**  
49 | 正在请求声明的上下文的标识符（例如，身份令牌，访问令牌或用户信息端点）。常量`IdentityServerConstants.ProfileDataCallers`包含不同的常量值。
50 | 
51 | * **`IsActive`**  
52 | 指示是否允许用户获取令牌的标志。预计这将由自定义`IProfileService`实现分配。


--------------------------------------------------------------------------------
/第三部分 主题/第25章 退出外部身份提供商.md:
--------------------------------------------------------------------------------
 1 | # 第25章 退出外部身份提供商
 2 | 当用户[注销](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC24%E7%AB%A0%20%E9%80%80%E5%87%BA.md) IdentityServer并且他们使用[外部身份提供程序](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC22%E7%AB%A0%20%E4%BD%BF%E7%94%A8%E5%A4%96%E9%83%A8%E8%BA%AB%E4%BB%BD%E6%8F%90%E4%BE%9B%E5%95%86%E7%99%BB%E5%BD%95.md)登录时，可能会将其重定向到注销外部提供程序。并非所有外部提供商都支持注销，因为它取决于它们支持的协议和功能。
 3 | 
 4 | 要检测是否必须将用户重定向到外部身份提供程序以进行注销通常是通过使用`idp`在IdentityServer中发布到cookie中的声明来完成的。设置到此声明中的值是`AuthenticationScheme`相应的身份验证中间件。在签出时，咨询此声明以了解是否需要外部签出。
 5 | 
 6 | 由于正常注销工作流程已经需要清理和状态管理，因此将用户重定向到外部身份提供商是有问题的。然后，在IdentityServer完成正常注销和清理过程的唯一方法是从外部身份提供程序请求在注销后将用户重定向回IdentityServer。并非所有外部提供商都支持退出后重定向，因为它取决于它们支持的协议和功能。
 7 | 
 8 | 然后，注销的工作流程将撤消IdentityServer的身份验证cookie，然后重定向到请求注销后重定向的外部提供程序。退出后重定向应保持此处描述的必要签出状态（即`logoutId`参数值）。要在外部提供程序注销后重定向回IdentityServer，`RedirectUri`应该AuthenticationProperties在使用ASP.NET Core的`SignOutAsyncAPI` 时使用，例如：
 9 | 
10 | ``` C#
11 | [HttpPost]
12 | [ValidateAntiForgeryToken]
13 | public async Task<IActionResult> Logout(LogoutInputModel model)
14 | {
15 |     // build a model so the logged out page knows what to display
16 |     var vm = await _account.BuildLoggedOutViewModelAsync(model.LogoutId);
17 | 
18 |     var user = HttpContext.User;
19 |     if (user?.Identity.IsAuthenticated == true)
20 |     {
21 |         // delete local authentication cookie
22 |         await HttpContext.SignOutAsync();
23 | 
24 |         // raise the logout event
25 |         await _events.RaiseAsync(new UserLogoutSuccessEvent(user.GetSubjectId(), user.GetName()));
26 |     }
27 | 
28 |     // check if we need to trigger sign-out at an upstream identity provider
29 |     if (vm.TriggerExternalSignout)
30 |     {
31 |         // build a return URL so the upstream provider will redirect back
32 |         // to us after the user has logged out. this allows us to then
33 |         // complete our single sign-out processing.
34 |         string url = Url.Action("Logout", new { logoutId = vm.LogoutId });
35 | 
36 |         // this triggers a redirect to the external provider for sign-out
37 |         return SignOut(new AuthenticationProperties { RedirectUri = url }, vm.ExternalAuthenticationScheme);
38 |     }
39 | 
40 |     return View("LoggedOut", vm);
41 | }
42 | ```   
43 | 
44 | 一旦用户退出外部提供程序然后重定向回来，IdentityServer的正常注销处理应该执行，这涉及处理`logoutId`和执行所有必要的清理。
45 | 
46 | 


--------------------------------------------------------------------------------
/第三部分 主题/第44章 添加新协议.md:
--------------------------------------------------------------------------------
 1 | # 第44章 添加新协议
 2 | 除了对OpenID Connect和OAuth 2.0的内置支持之外，IdentityServer4还允许添加对其他协议的支持。
 3 | 
 4 | 您可以将这些附加协议端点添加为中间件或使用例如MVC控制器。在这两种情况下，您都可以访问ASP.NET Core DI系统，该系统允许重用我们的内部服务，例如访问客户端定义或密钥材料。
 5 | 
 6 | 可以在[此处](https://github.com/IdentityServer/IdentityServer4.WsFederation)找到添加WS-Federation支持的示例。
 7 | 
 8 | ## 44.1 典型认证工作流程
 9 | 身份验证请求通常如下所示：
10 | 
11 | * 身份验证请求到达协议端点
12 | * 协议端点执行输入验证
13 | * **重定向到登录页面，返回URL设置回协议端点（如果用户是匿名的）**
14 |     * 通过访问当前请求详细信息 `IIdentityServerInteractionService`
15 |     * 用户身份验证（本地或通过外部身份验证中间件）
16 |     * 登录用户
17 |     * 重定向回协议端点
18 | * 创建协议响应（令牌创建和重定向回客户端）
19 | 
20 | ## 44.2 用IdentityServer服务
21 | 要实现上述工作流程，需要与IdentityServer建立一些交互点。
22 | 
23 | ### 44.2.1 访问配置并重定向到登录页面
24 | 
25 | 您可以通过将`IdentityServerOptions`类注入代码来访问IdentityServer配置。这个，例如具有登录页面的配置路径：
26 | 
27 | ``` C#
28 | var returnUrl = Url.Action("Index");
29 | returnUrl = returnUrl.AddQueryString(Request.QueryString.Value);
30 | 
31 | var loginUrl = _options.UserInteraction.LoginUrl;
32 | var url = loginUrl.AddQueryString(_options.UserInteraction.LoginReturnUrlParameter, returnUrl);
33 | 
34 | return Redirect(url);
35 | ```   
36 | 
37 | ### 44.2.2登录页面与当前协议请求之间的交互
38 | 
39 | 所述`IIdentityServerInteractionService`支撑件转动一个协议返回URL成解析和验证上下文对象：
40 | 
41 | ``` C#
42 | var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
43 | ```  
44 | 
45 | 默认情况下，交互服务仅了解OpenID Connect协议消息。要扩展支持，您可以自己编写`IReturnUrlParser`：
46 | 
47 | ``` C#
48 | public interface IReturnUrlParser
49 | {
50 |     bool IsValidReturnUrl(string returnUrl);
51 |     Task<AuthorizationRequest> ParseAsync(string returnUrl);
52 | }
53 | ```  
54 | 
55 | ..然后在DI中注册解析器：
56 | 
57 | ``` C#
58 | builder.Services.AddTransient<IReturnUrlParser, WsFederationReturnUrlParser>();
59 | ```   
60 | 
61 | 这允许登录页面获取客户端配置和其他协议参数等信息。
62 | 
63 | ### 44.2.3 访问用于创建协议响应的配置和密钥材料
64 | 
65 | 通过将`IKeyMaterialService`代码注入到代码中，您可以访问配置的签名凭据和验证密钥：
66 | 
67 | ``` C#
68 | var credential = await _keys.GetSigningCredentialsAsync();
69 | var key = credential.Key as Microsoft.IdentityModel.Tokens.X509SecurityKey;
70 | 
71 | var descriptor = new SecurityTokenDescriptor
72 | {
73 |     AppliesToAddress = result.Client.ClientId,
74 |     Lifetime = new Lifetime(DateTime.UtcNow, DateTime.UtcNow.AddSeconds(result.Client.IdentityTokenLifetime)),
75 |     ReplyToAddress = result.Client.RedirectUris.First(),
76 |     SigningCredentials = new X509SigningCredentials(key.Certificate, result.RelyingParty.SignatureAlgorithm, result.RelyingParty.DigestAlgorithm),
77 |     Subject = outgoingSubject,
78 |     TokenIssuerName = _contextAccessor.HttpContext.GetIdentityServerIssuerUri(),
79 |     TokenType = result.RelyingParty.TokenType
80 | };
81 | ```


--------------------------------------------------------------------------------
/第三部分 主题/第24章 退出.md:
--------------------------------------------------------------------------------
 1 | # 第24章 退出
 2 | 注销IdentityServer就像删除身份验证cookie一样简单，但是为了完成联合注销，我们必须考虑将用户从客户端应用程序（甚至可能是上游身份提供者）中签名。
 3 | 
 4 | ## 24.1 删除认证
 5 | 要删除身份验证cookie，只需使用`HttpContext`扩展方法`SignOutAsync`即可。您需要传递使用的方案（`IdentityServerConstants.DefaultCookieAuthenticationScheme`除非您已更改，否则提供此方案）：  
 6 | ``` C#
 7 | await HttpContext.SignOutAsync(IdentityServerConstants.DefaultCookieAuthenticationScheme);
 8 | ```   
 9 | 
10 | 或者您可以使用IdentityServer提供的便捷扩展方法：  
11 | ``` C#
12 | await HttpContext.SignOutAsync();
13 | ```  
14 | 
15 | > **注意**
16 | 通常，您应该提示用户注销（需要POST），否则攻击者可能会链接到您的注销页面，导致用户自动注销。
17 | 
18 | ## 24.2 通知客户端用户已注销
19 | 作为退出流程的一部分，您需要确保客户端应用程序被告知用户已退出。IdentityServer支持服务器端客户端的[前端通道](https://openid.net/specs/openid-connect-frontchannel-1_0.html)规范（例如MVC），服务器端客户端的[反向通道](https://openid.net/specs/openid-connect-backchannel-1_0.html) 规范（例如MVC），以及基于浏览器的JavaScript客户端的[会话管理](https://openid.net/specs/openid-connect-session-1_0.html)规范（例如SPA，React，Angular）等）。
20 | 
21 | ### 24.2.1 前端服务器端客户端
22 | 
23 | 要通过前端通道规范从服务器端注销客户端应用程序用户，IdentityServer中的“已注销”页面必须呈现`<iframe>`以通知客户端用户已注销。希望收到通知的客户端必须设置`FrontChannelLogoutUri`配置值。IdentityServer跟踪用户已登录的客户端，并提供在`IIdentityServerInteractionService`上（[详细信息](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC59%E7%AB%A0%20IdentityServer%E4%BA%A4%E4%BA%92%E6%9C%8D%E5%8A%A1.md)）调用`GetLogoutContextAsync`的API 。此API返回一个`LogoutRequest`对象，该对象具有`SignOutIFrameUrl`注销您的页面必须呈现为的`<iframe>`属性。
24 | 
25 | ### 24.2.2 反向通道服务器端客户端
26 | 
27 | 要通过反向通道规范从服务器端注销客户端应用程序用户，IdentityServer中的`SignOutIFrameUrl`端点将自动触发服务器到服务器调用，将签名的注销请求传递给客户端。这意味着即使如果没有前面通道的客户端中，“退出”，在IdentityServer页仍必须渲染`<iframe>`到`SignOutIFrameUrl`如上所述。希望收到通知的客户端必须设置`BackChannelLogoutUri`配置值。
28 | 
29 | ### 24.2.3 基于浏览器的JavaScript客户端
30 | 
31 | 鉴于[会话管理](https://openid.net/specs/openid-connect-session-1_0.html)规范的设计方式，IdentityServer中没有什么特别的，您需要做的是通知这些客户端用户已注销。但是，客户端必须对*check_session_iframe*执行监视，这是由[oidc-client JavaScript库](https://github.com/IdentityModel/oidc-client-js/)实现的。
32 | 
33 | ## 24.3 由客户端应用程序启动的注销
34 | 如果客户端应用程序启动了注销，则客户端首先将用户重定向到[结束会话端点](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E5%9B%9B%E9%83%A8%E5%88%86%20%E7%AB%AF%E7%82%B9/%E7%AC%AC53%E7%AB%A0%20%E7%BB%93%E6%9D%9F%E4%BC%9A%E8%AF%9D%E7%AB%AF%E7%82%B9(End%20Session%20Endpoint).md)。在结束会话端点处的处理可能需要通过重定向到注销页面来维护一些临时状态（例如，客户端的注销后重定向uri）。此状态可能对注销页面有用，并且状态的标识符通过*logoutId*参数传递到注销页面。
35 | 
36 | 在`GetLogoutContextAsync`上的API [交互服务](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC59%E7%AB%A0%20IdentityServer%E4%BA%A4%E4%BA%92%E6%9C%8D%E5%8A%A1.md)可以用来加载状态。感兴趣的`ShowSignoutPrompt`是`ShowSignoutPrompt`指示注销请求是否已经过身份验证，因此不会提示用户注销是安全的。
37 | 
38 | 默认情况下，此状态作为通过*logoutId*值传递的受保护数据结构进行管理。如果您希望在结束会话端点和注销页面之间使用其他一些持久性，那么您可以`IMessageStore<LogoutMessage>`在DI中实现并注册实现。


--------------------------------------------------------------------------------
/第二部分 快速入门/第12章 添加对外部认证的支持.md:
--------------------------------------------------------------------------------
 1 | # 第12章 添加对外部认证的支持
 2 | > **注意**
 3 | 对于任何先决条件（例如模板），首先要[查看](https://identityserver4.readthedocs.io/en/latest/quickstarts/0_overview.html#refquickstartoverview)概述。   
 4 | 
 5 | 接下来，我们将添加对外部认证的支持。这非常简单，因为您真正需要的是ASP.NET Core兼容的身份验证处理程序。   
 6 | 
 7 | ASP.NET Core本身支持Google，Facebook，Twitter，Microsoft Account和OpenID Connect。此外，你可以找到很多其他的认证供应商实现在[这里](https://github.com/aspnet-contrib/AspNet.Security.OAuth.Providers)。   
 8 | 
 9 | ## 12.1 添加Google支持
10 | 要使用Google进行身份验证，首先需要向他们注册。这是在他们的开发者[控制台](https://console.developers.google.com/)完成的。通过将/signin-google路径添加到您的基地址（例如[http//localhost5000/signin-google](http://localhost:5000/signin-google)），创建一个新项目，启用Google+ API并配置您本地IdentityServer的回调地址。   
11 | 
12 | 开发者控制台将向您显示由Google发布的客户端ID和密码 - 您将在下一步中使用该密码。
13 | 
14 | 将Google身份验证处理程序添加到IdentityServer主机的DI中。这是通过添加该代码段完成`Startup`的`ConfigureServices`：
15 | 
16 | ``` C#
17 | services.AddAuthentication()
18 |     .AddGoogle("Google", options =>
19 |     {
20 |         options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
21 | 
22 |         options.ClientId = "<insert here>";
23 |         options.ClientSecret = "<insert here>";
24 |     });
25 | ```   
26 | 
27 | 默认情况下，IdentityServer专门为外部身份验证的结果配置cookie处理程序（使用基于常量的方案`IdentityServerConstants.ExternalCookieAuthenticationSchem`e）。然后，Google处理程序的配置使用该cookie处理程序。   
28 | 
29 | 现在运行MVC客户端并尝试进行身份验证 - 您将在登录页面上看到一个Google按钮：
30 | 
31 | <div align="center">
32 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/4_login_page.png">
33 | </div>   
34 | 
35 | 在使用MVC客户端进行身份验证后，您可以看到声明现在来自Google数据。   
36 | 
37 | ## 12.2 进一步的实验
38 | 您可以添加其他外部提供程序。我们有一个云托管的IdentityServer4 演示版，您可以使用OpenID Connect进行集成。     
39 | 
40 | 将OpenId Connect处理程序添加到DI：   
41 | 
42 | ``` C#
43 | services.AddAuthentication()
44 |     .AddGoogle("Google", options =>
45 |     {
46 |         options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
47 | 
48 |         options.ClientId = "<insert here>";
49 |         options.ClientSecret = "<insert here>";
50 |     })
51 |     .AddOpenIdConnect("oidc", "OpenID Connect", options =>
52 |     {
53 |         options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
54 |         options.SignOutScheme = IdentityServerConstants.SignoutScheme;
55 |         options.SaveTokens = true;
56 | 
57 |         options.Authority = "https://demo.identityserver.io/";
58 |         options.ClientId = "implicit";
59 | 
60 |         options.TokenValidationParameters = new TokenValidationParameters
61 |         {
62 |             NameClaimType = "name",
63 |             RoleClaimType = "role"
64 |         };
65 |     });
66 | ```   
67 | 
68 | 现在，用户应该能够使用云托管的演示标识提供程序。   
69 | 
70 | > **注意**
71 | 快速入门UI自动配置外部用户。当外部用户首次登录时，将创建新的本地用户，并且所有外部声明都将复制并与新用户关联。你处理这种情况的方式完全取决于你。也许你想首先展示某种注册UI。可以在此处找到默认快速入门的源代码。可以在此处找到执行自动配置的控制器。


--------------------------------------------------------------------------------
/第五部分 参考/第59章 IdentityServer交互服务.md:
--------------------------------------------------------------------------------
  1 | # 第59章 IdentityServer交互服务
  2 | `IIdentityServerInteractionService`接口旨在提供用户界面用于与IdentityServer通信的服务，主要与用户交互有关。它可以从依赖注入系统获得，通常作为构造函数参数注入到IdentityServer的用户界面的MVC控制器中。
  3 | 
  4 | ## 59.1 IIdentityServerInteractionService APIs
  5 | * **`GetAuthorizationContextAsync`**  
  6 | 基于传递给登录或同意页面的`returnUrl`返回`AuthorizationRequest`。
  7 | 
  8 | * **`IsValidReturnUrl`**  
  9 | 指示在登录或同意后`returnUrl`是否为重定向的有效URL。
 10 | 
 11 | * **`GetErrorContextAsync`**  
 12 | 根据传递给错误页面的`errorId`返回`ErrorMessage`。
 13 | 
 14 | * **`GetLogoutContextAsync`**  
 15 | 根据传递给注销页面的`logoutId`返回`LogoutRequest`。
 16 | 
 17 | * **`CreateLogoutContextAsync`**  
 18 | 如果当前没有`logoutId`，则用于创建`logoutId`。这将创建一个cookie，捕获注销所需的所有当前状态，`logoutId`标识该cookie。这通常在没有当前`logoutId`时使用，并且注销页面必须捕获当前用户在重定向到外部身份提供程序以进行注销之前注销所需的状态。新创建的`logoutId`需要在注销时往返外部身份提供商，然后在注销回调页面上使用，就像在普通注销页面上一样。
 19 | 
 20 | * **`GrantConsentAsync`**  
 21 | 接受`ConsentResponse`以通知IdentityServer用户同意特定的`AuthorizationRequest`。
 22 | 
 23 | * **`GetAllUserConsentsAsync`**  
 24 | 返回用户的`Consent`集合。
 25 | 
 26 | * **`RevokeUserConsentAsync`**  
 27 | 撤消用户对客户端的所有同意和授权。
 28 | 
 29 | * **`RevokeTokensForCurrentSessionAsync`**  
 30 | 撤消用户在当前会话期间签署的客户的所有同意和授权。
 31 | 
 32 | ## 59.2 AuthorizationRequest
 33 | * **`ClientId`**  
 34 | 发起请求的客户端标识符。
 35 | 
 36 | * **`RedirectUri`**  
 37 | 成功授权后将用户重定向到的URI。
 38 | 
 39 | * **`DisplayMode`**  
 40 | 显示模式从授权请求传递。
 41 | 
 42 | * **`UiLocales`**  
 43 | 从授权请求传递的UI语言环境。
 44 | 
 45 | * **`IdP`**  
 46 | 外部身份提供者请求。这用于绕过家庭领域发现（HRD）。这是通过“idp：”前缀提供给授权请求的`acr_values`参数。
 47 | 
 48 | * **`Tenant`**  
 49 | 租户请求。这是通过“tenant：”前缀提供给授权请求上的`acr_values`参数。
 50 | 
 51 | * **`LoginHint`**  
 52 | 用户将用于登录的预期用户名。这是通过授权请求上的`login_hint`参数从客户端请求的。
 53 | 
 54 | * **`PromptMode`**  
 55 | 授权请求中请求的提示模式。
 56 | 
 57 | * **`AcrValues`**  
 58 | 从授权请求传递的acr值。
 59 | 
 60 | * **`ScopesRequested`**  
 61 | 授权请求中请求的范围。
 62 | 
 63 | * **`Parameters`**  
 64 | 整个参数集合传递给授权请求。
 65 | 
 66 | ## 59.3 ErrorMessage
 67 | * **`DisplayMode`**  
 68 | 显示模式从授权请求传递。
 69 | 
 70 | * **`UiLocales`**  
 71 | 从授权请求传递的UI语言环境。
 72 | 
 73 | * **`Error`**  
 74 | 错误代码。
 75 | 
 76 | * **`RequestId`**  
 77 | 每请求标识符。这可用于向最终用户显示，并可用于诊断。
 78 | 
 79 | ## 59.4 LogoutRequest
 80 | * **`ClientId`**  
 81 | 发起请求的客户端标识符。
 82 | 
 83 | * **`PostLogoutRedirectUri`**  
 84 | 用户在注销后将其重定向到的URL。
 85 | 
 86 | * **`SessionId`**  
 87 | 用户当前的会话ID。
 88 | 
 89 | * **`SignOutIFrameUrl`**  
 90 | 要在注销页面上的`<iframe>`中呈现以启用单点注销的URL。
 91 | 
 92 | * **`Parameters`**  
 93 | 整个参数集合传递给结束会话端点。
 94 | 
 95 | * **`ShowSignoutPrompt`**  
 96 | 指示是否应根据传递到结束会话端点的参数提示用户注销。
 97 | 
 98 | ## 59.5 ConsentResponse
 99 | * **`ScopesConsented`**  
100 | 用户同意的范围集合。
101 | 
102 | * **`RememberConsent`**  
103 | 指示是否持久保留用户同意的标志。
104 | 
105 | ## 59.6 Consent
106 | * **`SubjectId`**  
107 | 授予同意的主题ID。
108 | 
109 | * **`ClientId`**  
110 | 同意的客户端标识符。
111 | 
112 | * **`Scopes`**  
113 | 范围的集合同意。
114 | 
115 | * **`CreationTime`**  
116 | 获得同意的日期和时间。
117 | 
118 | * **`Expiration`**  
119 | 同意过期的日期和时间。


--------------------------------------------------------------------------------
/第二部分 快速入门/第10章 使用密码保护API.md:
--------------------------------------------------------------------------------
  1 | # 第10章 使用密码保护API
  2 | 
  3 | **OAuth 2.0资源所有者密码授权**允许客户端向令牌服务发送用户名和密码，并获取代表该用户的访问令牌。   
  4 | 
  5 | 除了无法承载浏览器的旧应用程序之外，规范通常建议不要使用资源所有者密码授予。一般来说，当您要对用户进行身份验证并请求访问令牌时，使用其中一个交互式**OpenID Connect**流程通常要好得多。   
  6 | 
  7 | 然而，这个授权类型允许我们在 IdentityServer 快速入门中引入 用户 的概念，这是我们要展示它的原因。    
  8 | 
  9 | ## 10.1 添加用户
 10 | 就像基于内存存储的资源（即 范围 Scopes）和客户端一样，对于用户也可以这样做。      
 11 | 
 12 | > **注意**
 13 | 有关如何正确存储和管理用户帐户的详细信息，请查看基于`ASP.NET Identity`的快速入门。   
 14 | 
 15 | `TestUser`类代表测试用户及其声明。让我们通过在`config`类中添加以下代码来创建几个用户：   
 16 | 
 17 | 首先将以下 `using`语句添加到*Config.cs*文件中：   
 18 | 
 19 | ``` C#
 20 | using IdentityServer4.Test;
 21 | 
 22 | public static List<TestUser> GetUsers()
 23 | {
 24 |     return new List<TestUser>
 25 |     {
 26 |         new TestUser
 27 |         {
 28 |             SubjectId = "1",
 29 |             Username = "alice",
 30 |             Password = "password"
 31 |         },
 32 |         new TestUser
 33 |         {
 34 |             SubjectId = "2",
 35 |             Username = "bob",
 36 |             Password = "password"
 37 |         }
 38 |     };
 39 | }
 40 | ```   
 41 | 
 42 | 然后使用IdentityServer注册测试用户：   
 43 | 
 44 | ``` C#
 45 | public void ConfigureServices(IServiceCollection services)
 46 | {
 47 |     // configure identity server with in-memory stores, keys, clients and scopes
 48 |     services.AddIdentityServer()
 49 |         .AddInMemoryApiResources(Config.GetApis())
 50 |         .AddInMemoryClients(Config.GetClients())
 51 |         .AddTestUsers(Config.GetUsers());
 52 | }
 53 | ```   
 54 | 
 55 | 该`AddTestUsers`扩展方法在背后做了以下几件事：   
 56 | 
 57 | * 添加对资源所有者密码授予的支持
 58 | * 添加对登录UI通常使用的用户相关服务的支持（我们将在下一个快速入门中使用它）
 59 | * 添加对基于测试用户的配置文件服务的支持（您将在下一个快速入门中了解更多信息）   
 60 | 
 61 | ## 10.2 为资源所有者密码授权添加客户端
 62 | 您可以通过更改`AllowedGrantTypes`属性，将授权类型的支持添加到现有客户端。 如果您需要您的客户端能够使用绝对支持的两种授权类型。
 63 | 
 64 | 我们正在为资源所有者用例创建一个单独的客户端，将以下内容添加到客户端配置中：   
 65 | 
 66 | ``` C#
 67 | public static IEnumerable<Client> GetClients()
 68 | {
 69 |     return new List<Client>
 70 |     {
 71 |         // other clients omitted...
 72 | 
 73 |         // resource owner password grant client
 74 |         new Client
 75 |         {
 76 |             ClientId = "ro.client",
 77 |             AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
 78 | 
 79 |             ClientSecrets =
 80 |             {
 81 |                 new Secret("secret".Sha256())
 82 |             },
 83 |             AllowedScopes = { "api1" }
 84 |         }
 85 |     };
 86 | }
 87 | ```   
 88 | 
 89 | ## 10.3 使用密码授权请求令牌
 90 | 在解决方案中添加新的控制台客户端。   
 91 | 
 92 | 新客户端看起来与我们为**客户端凭据授权**所做的非常相似。主要区别在于客户端会以某种方式收集用户的密码，并在令牌请求期间将其发送到令牌服务。   
 93 | 
 94 | `IdentityModel`再次可以在这里提供帮助：   
 95 | 
 96 | ``` C#
 97 | // request token
 98 | var tokenResponse = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
 99 | {
100 |     Address = disco.TokenEndpoint,
101 |     ClientId = "ro.client",
102 |     ClientSecret = "secret",
103 | 
104 |     UserName = "alice",
105 |     Password = "password",
106 |     Scope = "api1"
107 | });
108 | 
109 | if (tokenResponse.IsError)
110 | {
111 |     Console.WriteLine(tokenResponse.Error);
112 |     return;
113 | }
114 | 
115 | Console.WriteLine(tokenResponse.Json);
116 | ```   
117 | 
118 | 当您将令牌发送到身份API端点时，您会注意到与客户端凭据授权相比有一个小但重要的区别。访问令牌现在将包含sub唯一标识用户的声明。通过在调用API之后检查内容变量可以看到这个`sub`声明，并且控制器应用程序也会在屏幕上显示该声明。   
119 | 
120 | `sub`信息的存在（或缺失）使得 API 能够区分代表客户端的调用和代表用户的调用。
121 | 


--------------------------------------------------------------------------------
/第三部分 主题/第21章 登录.md:
--------------------------------------------------------------------------------
 1 | # 第21章 登录
 2 | 为了使IdentityServer能够代表用户发出令牌，该用户必须登录IdentityServer。
 3 | 
 4 | ## 21.1 Cookie身份验证
 5 | 使用由ASP\.NET Core中的cookie身份验证处理程序管理的cookie来跟踪身份验证。   
 6 | 
 7 | IdentityServer注册了两个cookie处理程序（一个用于身份验证会话，另一个用于临时外部cookie）。默认情况下使用它们，如果要手动引用它们，可以从`IdentityServerConstants`类（`DefaultCookieAuthenticationScheme`和`ExternalCookieAuthenticationScheme`）中获取它们的名称。  
 8 | 
 9 | 我们只公开这些cookie的基本设置（到期和滑动），如果您需要更多控制，您可以注册自己的cookie处理程序。当使用ASP\.NET Core中的`AddAuthentication`时，IdentityServer使用与`AuthenticationOptions`上配置的`DefaultAuthenticateScheme`匹配的cookie处理程序。
10 | 
11 | ## 21.2 覆盖cookie处理程序配置
12 | 如果您希望使用自己的cookie身份验证处理程序，则必须自己配置它。这必须在`ConfigureServices` DI（`AddIdentityServer`）中注册IdentityServer之后完成。例如：
13 | 
14 | ``` C#
15 | services.AddIdentityServer()
16 |     .AddInMemoryClients(Clients.Get())
17 |     .AddInMemoryIdentityResources(Resources.GetIdentityResources())
18 |     .AddInMemoryApiResources(Resources.GetApiResources())
19 |     .AddDeveloperSigningCredential()
20 |     .AddTestUsers(TestUsers.Users);
21 | 
22 | services.AddAuthentication("MyCookie")
23 |     .AddCookie("MyCookie", options =>
24 |     {
25 |         options.ExpireTimeSpan = ...;
26 |     });
27 | ```
28 | 
29 | > **注意**
30 | IdentityServer在内部使用自定义方案（通过常量`IdentityServerConstants.DefaultCookieAuthenticationScheme`）调用`AddAuthentication`和`AddCookie`，因此要覆盖它们，您必须在`AddIdentityServer`之后进行相同的调用。
31 | 
32 | ## 21.3 登录用户界面和身份管理系统
33 | IdentityServer不为用户身份验证提供任何用户界面或用户数据库。 这些是您希望自己提供或开发的东西。  
34 | 
35 | 如果您需要基本UI的起点（登录，注销，同意和管理授权），您可以使用我们的[快速入门UI](https://github.com/IdentityServer/IdentityServer4.Quickstart.UI)。
36 | 
37 | 快速入门UI针对内存数据库对用户进行身份验证。 您可以通过访问真实用户存储来替换这些位。 我们有[使用ASP.NET Identity](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%8C%E9%83%A8%E5%88%86%20%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8/%E7%AC%AC16%E7%AB%A0%20%E4%BD%BF%E7%94%A8ASP.NET%20Core%20Identity.md)的示例。
38 | 
39 | ## 21.4 登录工作流程
40 | 当IdentityServer在授权端点收到请求且未对用户进行身份验证时，将用户重定向到已配置的登录页面。 您必须通过[选项](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC61%E7%AB%A0%20IdentityServer%20Options.md)上的`UserInteraction`设置（默认`/account/login`）通知IdentityServer登录页面的路径。 将传递`returnUrl`参数，通知您的登录页面，一旦登录完成，应该重定向用户。
41 | 
42 | <div align="center">
43 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/signin_flow.png">
44 | </div>
45 | 
46 | 
47 | > **注意**
48 | 通过`returnUrl`参数注意[open-redirect attacks](https://en.wikipedia.org/wiki/URL_redirection#Security_issues)攻击。 您应该验证`returnUrl`是否引用了众所周知的位置。 请参阅API的[交互服务](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC59%E7%AB%A0%20IdentityServer%E4%BA%A4%E4%BA%92%E6%9C%8D%E5%8A%A1.md)以验证`returnUrl`参数。
49 | 
50 | ## 21.5 登录上下文
51 | 在您的登录页面上，您可能需要有关请求上下文的信息，以便自定义登录体验（例如客户端，提示参数，IdP提示或其他内容）。这可以通过[交互服务](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC59%E7%AB%A0%20IdentityServer%E4%BA%A4%E4%BA%92%E6%9C%8D%E5%8A%A1.md)上的`GetAuthorizationContextAsync` API获得。
52 | 
53 | ## 21。6 发行cookie和声明
54 | ASP\.NET Core上的`HttpContext`上有与身份验证相关的扩展方法，用于发出身份验证cookie并对用户进行签名。使用的身份验证方案必须与您正在使用的cookie处理程序匹配（请参见上文）。  
55 | 
56 | 当您签署用户时，您必须至少发出一个`sub`和一个`name`声明。 IdentityServer还在`HttpContext`上提供了一些`SignInAsync`扩展方法，以使这更方便。  
57 | 
58 | 您还可以选择发出`idp`声明（针对身份提供者名称），`amr`声明（针对所使用的身份验证方法）和/或`auth_time`声明（针对用户身份验证的纪元时间）。如果您不提供这些，IdentityServer将提供默认值。


--------------------------------------------------------------------------------
/第五部分 参考/第61章 IdentityServer Options.md:
--------------------------------------------------------------------------------
 1 | # 第61章 IdentityServer Options
 2 | * **`IssuerUri`**  
 3 | 设置将在发现文档和已颁发的JWT令牌中显示的颁发者名称。建议不要设置此属性，该属性从客户端使用的主机名中推断颁发者名称。
 4 | * **`PublicOrigin`**  
 5 | 此服务器实例的来源，例如<https://myorigin.com>。如果未设置，则从请求推断出原始名称。  
 6 | 
 7 | ## 61.1 端点(Endpoints)
 8 | 允许启用/禁用各个端点，例如令牌，授权，用户信息等。   
 9 | 
10 | 默认情况下，所有端点都已启用，但您可以通过禁用不需要的端点来锁定服务器。   
11 | 
12 | ## 61.2 发现(Discovery)
13 | 允许启用/禁用发现文档的各个部分，例如端点，范围，声明，授权类型等。   
14 | 
15 | 该`CustomEntries`字典允许将自定义元素添加到发现文档中。  
16 | 
17 | ## 61.3 认证(Authentication)
18 | * **`CookieLifetime`**  
19 | 身份验证cookie生存期（仅在使用IdentityServer提供的cookie处理程序时有效）。   
20 | 
21 | * **`CookieSlidingExpiration`**  
22 | 指定cookie是否应该滑动（仅在使用IdentityServer提供的cookie处理程序时有效）。  
23 | 
24 | * **`RequireAuthenticatedUserForSignOutMessage`**  
25 | 指示是否必须对用户进行身份验证以接受参数以结束会话端点。默认为false。   
26 | 
27 | * **`CheckSessionCookieName`**  
28 | 用于检查会话端点的cookie的名称。  
29 | 
30 | * **`RequireCspFrameSrcForSignout`**  
31 | 如果设置，将要求frame-src CSP标头在结束会话回调端点上发出，该端点向客户端呈现iframe以进行前端通道注销通知。默认为true。   
32 | 
33 | ## 61.4 事件(Events)
34 | 允许配置是否应将哪些事件提交到已注册的事件接收器。有关活动的更多信息，请参见[此处](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC32%E7%AB%A0%20%E4%BA%8B%E4%BB%B6.md)。   
35 | 
36 | ## 61.5 InputLengthRestrictions
37 | 允许设置各种协议参数的长度限制，如客户端ID，范围，重定向URI等。
38 | 
39 | ## 61.6 用户交互(UserInteraction)
40 | * **`LoginUrl`**，**`LogoutUrl`**，**`ConsentUrl`**，**`ErrorUrl`**，**`DeviceVerificationUrl`**  
41 | 设置登录，注销，同意，错误和设备验证页面的URL。  
42 | 
43 | * **`LoginReturnUrlParameter`**    
44 | 设置传递给登录页面的返回URL参数的名称。默认为returnUrl。  
45 | 
46 | * **`LogoutIdParameter`**  
47 | 设置传递给注销页面的注销消息id参数的名称。默认为logoutId。  
48 | 
49 | * **`ConsentReturnUrlParameter`**  
50 | 设置传递给同意页面的返回URL参数的名称。默认为returnUrl。  
51 | 
52 | * **`ErrorIdParameter`**  
53 | 设置传递给错误页面的错误消息id参数的名称。默认为errorId。  
54 | 
55 | * **`CustomRedirectReturnUrlParameter`**  
56 | 设置从授权端点传递给自定义重定向的返回URL参数的名称。默认为returnUrl。  
57 | 
58 | * **`DeviceVerificationUserCodeParameter`**  
59 | 设置传递给设备验证页面的用户代码参数的名称。默认为userCode。  
60 | 
61 | * **`CookieMessageThreshold`**  
62 | IdentityServer和某些UI页面之间的某些交互需要cookie来传递状态和上下文（上面具有可配置“message id”参数的任何页面）。由于浏览器对cookie的数量及其大小有限制，因此该设置用于防止创建过多的cookie。该值设置将创建的任何类型的消息cookie的最大数量。一旦达到限制，将清除最早的消息cookie。这有效地表示用户在使用IdentityServer时可以打开多少个选项卡。   
63 | 
64 | ## 61.7 缓存(Caching)
65 | 这些设置仅在启动时在服务配置中启用了相应的缓存时才适用。  
66 | 
67 | * **`ClientStoreExpiration`**  
68 | 从客户端存储加载的客户端配置的缓存持续时间。
69 | 
70 | * **`ResourceStoreExpiration`**  
71 | 缓存从资源存储加载的标识和API资源配置的持续时间。  
72 | 
73 | ## 61.8 CORS 
74 | IdentityServer支持某些端点的CORS。底层CORS实现由ASP.NET Core提供，因此它在依赖注入系统中自动注册。
75 | 
76 | * **`CorsPolicyName`**  
77 | 将为IdentityServer中的CORS请求评估的CORS策略的名称（默认为`"IdentityServer4"`）。处理此问题的策略提供程序是根据`ICorsPolicyService`依赖注入系统中注册的方式实现的。如果您希望自定义允许连接的CORS源集，那么建议您提供自定义实现`ICorsPolicyService`。   
78 | 
79 | * **`CorsPaths`**  
80 | IdentityServer中支持CORS的端点。默认为发现，用户信息，令牌和吊销端点。  
81 | 
82 | * **`PreflightCacheDuration`**  
83 | *Nullable\<TimeSpan\>*指示在预检*Access-Control-Max-Age*响应头中使用的值。默认为null，表示未在响应上设置缓存标头。  
84 | 
85 | ## 61.9 CSP（内容安全策略）
86 | 在适当的情况下，IdentityServer会为某些响应发出CSP标头。  
87 | 
88 | * **`Level`**  
89 | 要使用的CSP级别。默认情况下使用CSP级别2，但如果必须支持旧浏览器，则将其更改`CspLevel.One`为兼容它们。  
90 | 
91 | * **`AddDeprecatedHeader`**  
92 | 指示是否`X-Content-Security-Policy`还应发出较旧的CSP标头（除了基于标准的标头值）。默认为true。  
93 | 
94 |  ## 61.10 设备流程
95 | * **`DefaultUserCodeType`**  
96 | 要使用的用户代码类型，除非在客户端级别设置。默认为数字，9位数代码。  
97 | 
98 | * **`Interval`**  
99 | 定义令牌端点上允许的最小轮询间隔。默认为5。


--------------------------------------------------------------------------------
/第二部分 快速入门/第13章 切换到混合流并添加API访问.md:
--------------------------------------------------------------------------------
  1 | # 第13章 切换到混合流并添加API访问
  2 | 
  3 | 在之前的快速入门中，我们探讨了API访问和用户身份验证。现在我们想把这两个部分放在一起。   
  4 | 
  5 | OpenID Connect和OAuth 2.0组合的优点在于，您可以使用单个协议和使用令牌服务进行单次交换来实现这两者。   
  6 | 
  7 | 在之前的快速入门中，我们使用了OpenID Connect隐式流程。在隐式流程中，所有令牌都通过浏览器传输，这对于身份令牌来说是完全正确的。现在我们还想要一个访问令牌。   
  8 | 
  9 | 访问令牌比身份令牌更敏感，如果不需要，我们不希望将它们暴露给“外部”世界。OpenID Connect包含一个名为“混合流”的流程，它为我们提供了两全其美的优势，身份令牌通过浏览器渠道传输，因此客户端可以在进行任何更多工作之前对其进行验证。如果验证成功，客户端会打开令牌服务的反向通道以检索访问令牌。   
 10 | 
 11 | ## 13.1 修改客户端配置
 12 | 没有太多必要的修改。首先，我们希望允许客户端使用混合流，此外我们还希望客户端允许执行不在用户上下文中的服务器到服务器API调用（这与我们的客户端凭证快速启动非常相似）。这是使用该`AllowedGrantTypes`属性表示的。   
 13 | 
 14 | 接下来我们需要添加一个客户端密钥。这将用于检索反向通道上的访问令牌。   
 15 | 
 16 | 最后，我们还让客户端访问`offline_access`范围 - 这允许请求刷新令牌以实现长期存在的API访问：   
 17 | 
 18 | ``` C#
 19 | new Client
 20 | {
 21 |     ClientId = "mvc",
 22 |     ClientName = "MVC Client",
 23 |     AllowedGrantTypes = GrantTypes.Hybrid,
 24 | 
 25 |     ClientSecrets =
 26 |     {
 27 |         new Secret("secret".Sha256())
 28 |     },
 29 | 
 30 |     RedirectUris           = { "http://localhost:5002/signin-oidc" },
 31 |     PostLogoutRedirectUris = { "http://localhost:5002/signout-callback-oidc" },
 32 | 
 33 |     AllowedScopes =
 34 |     {
 35 |         IdentityServerConstants.StandardScopes.OpenId,
 36 |         IdentityServerConstants.StandardScopes.Profile,
 37 |         "api1"
 38 |     },
 39 |     AllowOfflineAccess = true
 40 | };
 41 | ```   
 42 | 
 43 | ## 13.2 修改MVC客户端
 44 | MVC客户端的修改也很少 - ASP\.NET Core OpenID Connect处理程序内置了对混合流的支持，因此我们只需要更改一些配置值。   
 45 | 
 46 | 我们配置 `ClientSecret` 以让它跟 IdentityServer 上的信息相匹配。添加 `offline_access` scopes，然后设置`ResponseType`为`code id_token`（基本的意思就是“使用混合流”）。要在我们的MVC客户端标识中保留网站声明，我们需要使用声明显式映射声明。   
 47 | 
 48 | ``` C#
 49 | .AddOpenIdConnect("oidc", options =>
 50 | {
 51 |     options.SignInScheme = "Cookies";
 52 | 
 53 |     options.Authority = "http://localhost:5000";
 54 |     options.RequireHttpsMetadata = false;
 55 | 
 56 |     options.ClientId = "mvc";
 57 |     options.ClientSecret = "secret";
 58 |     options.ResponseType = "code id_token";
 59 | 
 60 |     options.SaveTokens = true;
 61 |     options.GetClaimsFromUserInfoEndpoint = true;
 62 | 
 63 |     options.Scope.Add("api1");
 64 |     options.Scope.Add("offline_access");
 65 |     options.ClaimActions.MapJsonKey("website", "website");
 66 | });
 67 | ```   
 68 | 
 69 | 当你运行 MVC 客户端的时候，不会有太大的区别。除此之外，授权确认页现在还会向你请求访问 额外的 API 和 离线访问（offline access） scope。   
 70 | 
 71 | ## 13.3 使用访问令牌
 72 | OpenID Connect处理程序会自动为您保存令牌（在我们的案例中为身份，访问和刷新）。这就是`SaveTokens`设置的作用。   
 73 | 
 74 | cookie检查视图迭代这些值并在屏幕上显示它们。   
 75 | 
 76 | 从技术上讲，令牌存储在cookie的属性部分中。访问它们的最简单方法是使用`Microsoft.AspNetCore.Authentication`命名空间中的扩展方法。   
 77 | 
 78 | 例如：   
 79 | 
 80 | ``` C#
 81 | var accessToken = await HttpContext.GetTokenAsync("access_token")
 82 | var refreshToken = await HttpContext.GetTokenAsync("refresh_token");
 83 | ```   
 84 | 
 85 | 要使用访问令牌访问API，您需要做的就是检索令牌，并在HttpClient上设置它：   
 86 | 
 87 | ``` C#
 88 | public async Task<IActionResult> CallApi()
 89 | {
 90 |     var accessToken = await HttpContext.GetTokenAsync("access_token");
 91 | 
 92 |     var client = new HttpClient();
 93 |     client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
 94 |     var content = await client.GetStringAsync("http://localhost:5001/identity");
 95 | 
 96 |     ViewBag.Json = JArray.Parse(content).ToString();
 97 |     return View("json");
 98 | }
 99 | ```   
100 | 
101 | 创建一个名为*json.cshtml* 的视图，如下所示：   
102 | 
103 | ``` xml
104 | <pre>@ViewBag.Json</pre>
105 | ```   
106 | 
107 | 确保API正在运行，启动MVC客户端并/home/CallApi在身份验证后调用。


--------------------------------------------------------------------------------
/第三部分 主题/第20章 定义客户端.md:
--------------------------------------------------------------------------------
  1 | # 第20章 定义客户端
  2 | 客户端表示可以从您的身份服务器请求令牌的应用程序。
  3 | 
  4 | 详细信息各不相同，但您通常会为客户端定义以下常用设置：  
  5 | 
  6 | * 唯一的客户ID
  7 | * 如果需要的秘密
  8 | * 允许与令牌服务的交互（称为授权类型）
  9 | * 身份和/或访问令牌发送到的网络位置（称为重定向URI）
 10 | * 允许客户端访问的范围列表（也称为资源）   
 11 | 
 12 | > **注意**
 13 | 在运行时，通过实现来检索客户端`IClientStore`。这允许从任意数据源（如配置文件或数据库）加载它们。对于本文档，我们将使用客户端存储的内存版本。您可以通过`ConfigureServices`的`AddInMemoryClientsextensions`方法连接内存存储。
 14 | 
 15 | ## 20.1 定义服务器到服务器通信的客户端
 16 | 在这种情况下，没有交互式用户 - 服务（aka client）想要与API（aka scope）进行通信：
 17 | 
 18 | ``` C#
 19 | public class Clients
 20 | {
 21 |     public static IEnumerable<Client> Get()
 22 |     {
 23 |         return new List<Client>
 24 |         {
 25 |             new Client
 26 |             {
 27 |                 ClientId = "service.client",
 28 |                 ClientSecrets = { new Secret("secret".Sha256()) },
 29 | 
 30 |                 AllowedGrantTypes = GrantTypes.ClientCredentials,
 31 |                 AllowedScopes = { "api1", "api2.read_only" }
 32 |             }
 33 |         };
 34 |     }
 35 | }
 36 | ```   
 37 | 
 38 | ## 20.2 定义基于浏览器的JavaScript客户端（例如SPA）以进行用户身份验证和委托访问及API
 39 | 
 40 | 此客户端使用所谓的隐式流来从JavaScript请求身份和访问令牌：  
 41 | 
 42 | ``` C#
 43 | var jsClient = new Client
 44 | {
 45 |     ClientId = "js",
 46 |     ClientName = "JavaScript Client",
 47 |     ClientUri = "http://identityserver.io",
 48 | 
 49 |     AllowedGrantTypes = GrantTypes.Implicit,
 50 |     AllowAccessTokensViaBrowser = true,
 51 | 
 52 |     RedirectUris =           { "http://localhost:7017/index.html" },
 53 |     PostLogoutRedirectUris = { "http://localhost:7017/index.html" },
 54 |     AllowedCorsOrigins =     { "http://localhost:7017" },
 55 | 
 56 |     AllowedScopes =
 57 |     {
 58 |         IdentityServerConstants.StandardScopes.OpenId,
 59 |         IdentityServerConstants.StandardScopes.Profile,
 60 |         IdentityServerConstants.StandardScopes.Email,
 61 | 
 62 |         "api1", "api2.read_only"
 63 |     }
 64 | };
 65 | ```   
 66 | 
 67 | ## 20.3 定义服务器端Web应用程序（例如MVC）以使用身份验证和委托API访问
 68 | 交互式服务器端（或本地桌面/移动）应用程序使用混合流。此流程为您提供最佳安全性，因为访问令牌仅通过反向通道调用传输（并允许您访问刷新令牌）：   
 69 | 
 70 | ``` C#
 71 | var mvcClient = new Client
 72 | {
 73 |     ClientId = "mvc",
 74 |     ClientName = "MVC Client",
 75 |     ClientUri = "http://identityserver.io",
 76 | 
 77 |     AllowedGrantTypes = GrantTypes.Hybrid,
 78 |     AllowOfflineAccess = true,
 79 |     ClientSecrets = { new Secret("secret".Sha256()) },
 80 | 
 81 |     RedirectUris =           { "http://localhost:21402/signin-oidc" },
 82 |     PostLogoutRedirectUris = { "http://localhost:21402/" },
 83 |     FrontChannelLogoutUri =  "http://localhost:21402/signout-oidc",
 84 | 
 85 |     AllowedScopes =
 86 |     {
 87 |         IdentityServerConstants.StandardScopes.OpenId,
 88 |         IdentityServerConstants.StandardScopes.Profile,
 89 |         IdentityServerConstants.StandardScopes.Email,
 90 | 
 91 |         "api1", "api2.read_only"
 92 |     },
 93 | };
 94 | ```   
 95 | 
 96 | ## 20.4 在appsettings.json中定义客户端
 97 | 该`AddInMemoryClients`扩展方法也支持从ASP.NET Core配置文件中添加客户端。这允许您直接从*appsettings.json*文件定义静态客户端：   
 98 | 
 99 | ``` json
100 | "IdentityServer": {
101 |   "IssuerUri": "urn:sso.company.com",
102 |   "Clients": [
103 |     {
104 |       "Enabled": true,
105 |       "ClientId": "local-dev",
106 |       "ClientName": "Local Development",
107 |       "ClientSecrets": [ { "Value": "<Insert Sha256 hash of the secret encoded as Base64 string>" } ],
108 |       "AllowedGrantTypes": [ "implicit" ],
109 |       "AllowedScopes": [ "openid", "profile" ],
110 |       "RedirectUris": [ "https://localhost:5001/signin-oidc" ],
111 |       "RequireConsent": false
112 |     }
113 |   ]
114 | }
115 | ```   
116 | 
117 | 然后将配置部分传递给`AddInMemoryClients`方法：   
118 | 
119 | ``` C#
120 | AddInMemoryClients(configuration.GetSection("IdentityServer:Clients"))
121 | ```


--------------------------------------------------------------------------------
/第三部分 主题/第35章 秘密(secrets).md:
--------------------------------------------------------------------------------
  1 | # 第35章 秘密(secrets)
  2 | 在某些情况下，客户端需要使用身份服务器进行身份验证，例如
  3 | 
  4 | * 在令牌端点请求令牌的机密应用程序（也称为客户端）
  5 | * API在内省端点验证引用令牌
  6 | 
  7 | 为此，您可以将秘密列表分配给客户端或API资源。
  8 | 
  9 | 秘密解析和验证是身份服务器中的可扩展点，开箱即用它支持共享机密以及通过基本身份验证头或POST主体传输共享机密。
 10 | 
 11 | ## 35.1 创建共享密钥
 12 | 以下代码设置散列共享密钥：
 13 | 
 14 | ``` C#
 15 | var secret = new Secret("secret".Sha256());
 16 | ```  
 17 | 
 18 | 现在可以将此秘密分配给`Client`或`ApiResource`。请注意，它们不仅支持单个秘密，还支持多个秘密。这对于秘密翻转和轮换非常有用：
 19 | 
 20 | ``` C#
 21 | var client = new Client
 22 | {
 23 |     ClientId = "client",
 24 |     ClientSecrets = new List<Secret> { secret },
 25 | 
 26 |     AllowedGrantTypes = GrantTypes.ClientCredentials,
 27 |     AllowedScopes = new List<string>
 28 |     {
 29 |         "api1", "api2"
 30 |     }
 31 | };
 32 | ```  
 33 | 
 34 | 实际上，您还可以为秘密分配说明和到期日期。该描述将用于记录，以及用于实施秘密生存期的到期日期：
 35 | 
 36 | ``` C#
 37 | var secret = new Secret(
 38 |     "secret".Sha256(),
 39 |     "2016 secret",
 40 |     new DateTime(2016, 12, 31));
 41 | ```  
 42 | 
 43 | ## 35.2 使用共享密钥进行身份验证
 44 | 您可以将Client id/secret组合作为POST正文的一部分发送：
 45 | 
 46 | ```
 47 | POST /connect/token
 48 | 
 49 | client_id=client1&
 50 | client_secret=secret&
 51 | ...
 52 | ```  
 53 | 
 54 | ..或作为基本认证头：
 55 | 
 56 | ```
 57 | POST /connect/token
 58 | 
 59 | Authorization: Basic xxxxx
 60 | 
 61 | ...
 62 | ```
 63 | 
 64 | 您可以使用以下C＃代码手动创建基本身份验证标头：
 65 | 
 66 | ``` C#
 67 | var credentials = string.Format("{0}:{1}", clientId, clientSecret);
 68 | var headerValue = Convert.ToBase64String(Encoding.UTF8.GetBytes(credentials));
 69 | 
 70 | var client = new HttpClient();
 71 | client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", headerValue);
 72 | ```  
 73 | 
 74 | 该[IdentityModel](https://github.com/IdentityModel/IdentityModel2)库有一个叫做辅助类`TokenClient`和`IntrospectionClient`封装认证和协议消息。
 75 | 
 76 | ## 35.3 超越共享秘密
 77 | 还有其他技术来验证客户端，例如基于公钥/私钥密码术。IdentityServer包括对私钥JWT客户端机密的支持（请参阅[RFC 7523](https://tools.ietf.org/html/rfc7523)）。
 78 | 
 79 | 秘密可扩展性通常由三件事组成：
 80 | 
 81 | * 一个秘密的定义
 82 | * 一个知道如何从传入请求中提取秘密的秘密解析器
 83 | * 一个秘密验证器，知道如何根据定义验证解析的秘密  
 84 | 
 85 | 秘密解析器和验证器是`ISecretParser`和`ISecretValidator`接口的实现。要使它们可用于IdentityServer，您需要将它们注册到DI容器，例如：
 86 | 
 87 | ``` C#
 88 | builder.AddSecretParser<JwtBearerClientAssertionSecretParser>()
 89 | builder.AddSecretValidator<PrivateKeyJwtSecretValidator>()
 90 | ```  
 91 | 
 92 | 我们的默认私钥JWT秘密验证器期望完整（叶）证书作为秘密定义的base64。然后，此证书将用于验证自签名JWT上的签名，例如：
 93 | 
 94 | ``` C#
 95 | var client = new Client
 96 | {
 97 |     ClientId = "client.jwt",
 98 |     ClientSecrets =
 99 |     {
100 |         new Secret
101 |         {
102 |             Type = IdentityServerConstants.SecretTypes.X509CertificateBase64,
103 |             Value = "MIIDATCCAe2gAwIBAgIQoHUYAquk9rBJcq8W+F0FAzAJBgUrDgMCHQUAMBIxEDAOBgNVBAMTB0RldlJvb3QwHhcNMTAwMTIwMjMwMDAwWhcNMjAwMTIwMjMwMDAwWjARMQ8wDQYDVQQDEwZDbGllbnQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDSaY4x1eXqjHF1iXQcF3pbFrIbmNw19w/IdOQxbavmuPbhY7jX0IORu/GQiHjmhqWt8F4G7KGLhXLC1j7rXdDmxXRyVJBZBTEaSYukuX7zGeUXscdpgODLQVay/0hUGz54aDZPAhtBHaYbog+yH10sCXgV1Mxtzx3dGelA6pPwiAmXwFxjJ1HGsS/hdbt+vgXhdlzud3ZSfyI/TJAnFeKxsmbJUyqMfoBl1zFKG4MOvgHhBjekp+r8gYNGknMYu9JDFr1ue0wylaw9UwG8ZXAkYmYbn2wN/CpJl3gJgX42/9g87uLvtVAmz5L+rZQTlS1ibv54ScR2lcRpGQiQav/LAgMBAAGjXDBaMBMGA1UdJQQMMAoGCCsGAQUFBwMCMEMGA1UdAQQ8MDqAENIWANpX5DZ3bX3WvoDfy0GhFDASMRAwDgYDVQQDEwdEZXZSb290ghAsWTt7E82DjU1E1p427Qj2MAkGBSsOAwIdBQADggEBADLje0qbqGVPaZHINLn+WSM2czZk0b5NG80btp7arjgDYoWBIe2TSOkkApTRhLPfmZTsaiI3Ro/64q+Dk3z3Kt7w+grHqu5nYhsn7xQFAQUf3y2KcJnRdIEk0jrLM4vgIzYdXsoC6YO+9QnlkNqcN36Y8IpSVSTda6gRKvGXiAhu42e2Qey/WNMFOL+YzMXGt/nDHL/qRKsuXBOarIb++43DV3YnxGTx22llhOnPpuZ9/gnNY7KLjODaiEciKhaKqt/b57mTEz4jTF4kIg6BP03MUfDXeVlM1Qf1jB43G2QQ19n5lUiqTpmQkcfLfyci2uBZ8BkOhXr3Vk9HIk/xBXQ="
104 |         }
105 |     },
106 | 
107 |     AllowedGrantTypes = GrantTypes.ClientCredentials,
108 |     AllowedScopes = { "api1", "api2" }
109 | };
110 | ``` 
111 | 
112 | 您可以实现自己的秘密验证器（或扩展我们的秘密验证器）来实现例如链信任验证。


--------------------------------------------------------------------------------
/第三部分 主题/第19章 定义资源.md:
--------------------------------------------------------------------------------
  1 | # 第19章 定义资源
  2 | 您通常在系统中定义的第一件事是您要保护的资源。这可能是您的用户的身份信息，如个人资料数据或电子邮件地址，或访问API。
  3 | 
  4 | > **注意**
  5 | 您可以使用C#对象模型定义资源 - 或从数据存储加载它们。`IResourceStore`的一个实现处理这些低级细节。对于本文档，我们使用内存实现。
  6 | 
  7 | # 19.1 定义身份资源
  8 | 身份资源是用户的用户ID，名称或电子邮件地址等数据。标识资源具有唯一名称，您可以为其分配任意声明类型。然后，这些声明将包含在用户的身份令牌中。客户端将使用该`scope`参数来请求访问标识资源。  
  9 | 
 10 | OpenID Connect规范指定了几个[标准](https://openid.net/specs/openid-connect-core-1_0.html#ScopeClaims)身份资源。最低要求是，您为用户发送唯一ID提供支持 - 也称为主题ID。这是通过公开名为的标准身份资源来完成的`openid`：  
 11 | 
 12 | ``` C#
 13 | public static IEnumerable<IdentityResource> GetIdentityResources()
 14 | {
 15 |     return new List<IdentityResource>
 16 |     {
 17 |         new IdentityResources.OpenId()
 18 |     };
 19 | }
 20 | ```   
 21 | 
 22 | 该IdentityResources类支持的规范（OpenID，电子邮件，个人资料，电话和地址）中定义的所有范围。如果要全部支持它们，可以将它们添加到支持的身份资源列表中：
 23 | 
 24 | ``` C#
 25 | public static IEnumerable<IdentityResource> GetIdentityResources()
 26 | {
 27 |     return new List<IdentityResource>
 28 |     {
 29 |         new IdentityResources.OpenId(),
 30 |         new IdentityResources.Email(),
 31 |         new IdentityResources.Profile(),
 32 |         new IdentityResources.Phone(),
 33 |         new IdentityResources.Address()
 34 |     };
 35 | }
 36 | ```   
 37 | 
 38 | ## 19.2 定义自定义标识资源
 39 | 您还可以定义自定义标识资源。创建一个新的*IdentityResource*类，为其指定名称和可选的显示名称和描述，并定义在请求此资源时应将哪些用户声明包含在标识令牌中：
 40 | 
 41 | ``` C#
 42 | public static IEnumerable<IdentityResource> GetIdentityResources()
 43 | {
 44 |     var customProfile = new IdentityResource(
 45 |         name: "custom.profile",
 46 |         displayName: "Custom profile",
 47 |         claimTypes: new[] { "name", "email", "status" });
 48 | 
 49 |     return new List<IdentityResource>
 50 |     {
 51 |         new IdentityResources.OpenId(),
 52 |         new IdentityResources.Profile(),
 53 |         customProfile
 54 |     };
 55 | }
 56 | ```   
 57 | 
 58 | 有关身份资源设置的更多信息，请[参考](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC54%E7%AB%A0%20%E8%BA%AB%E4%BB%BD%E8%B5%84%E6%BA%90.md)。
 59 | 
 60 | ## 19.2 定义API资源
 61 | 要允许客户端请求API的访问令牌，您需要定义API资源，例如：
 62 | 
 63 | 要获取API的访问权限，您还需要将它们注册为范围。这次范围类型是*Resource*类型：
 64 | 
 65 | ``` C#
 66 | public static IEnumerable<ApiResource> GetApis()
 67 | {
 68 |     return new[]
 69 |     {
 70 |         // simple API with a single scope (in this case the scope name is the same as the api name)
 71 |         new ApiResource("api1", "Some API 1"),
 72 | 
 73 |         // expanded version if more control is needed
 74 |         new ApiResource
 75 |         {
 76 |             Name = "api2",
 77 | 
 78 |             // secret for using introspection endpoint
 79 |             ApiSecrets =
 80 |             {
 81 |                 new Secret("secret".Sha256())
 82 |             },
 83 | 
 84 |             // include the following using claims in access token (in addition to subject id)
 85 |             UserClaims = { JwtClaimTypes.Name, JwtClaimTypes.Email },
 86 | 
 87 |             // this API defines two scopes
 88 |             Scopes =
 89 |             {
 90 |                 new Scope()
 91 |                 {
 92 |                     Name = "api2.full_access",
 93 |                     DisplayName = "Full access to API 2",
 94 |                 },
 95 |                 new Scope
 96 |                 {
 97 |                     Name = "api2.read_only",
 98 |                     DisplayName = "Read only access to API 2"
 99 |                 }
100 |             }
101 |         }
102 |     };
103 | }
104 | ```   
105 | 
106 | 有关API资源设置的更多信息，请[参考](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC55%E7%AB%A0%20%20API%E8%B5%84%E6%BA%90.md)。
107 | 
108 | > **注意**
109 | 由资源定义的用户声明由[IProfileService](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%94%E9%83%A8%E5%88%86%20%E5%8F%82%E8%80%83/%E7%AC%AC58%E7%AB%A0%20Profile%20Service.md)扩展点加载。


--------------------------------------------------------------------------------
/第三部分 主题/第32章 事件.md:
--------------------------------------------------------------------------------
  1 | # 第32章 事件
  2 | 日志记录是更低级别的“printf”样式 - 事件代表有关IdentityServer中某些操作的更高级别信息。事件是结构化数据，包括事件ID，成功/失败信息，类别和详细信息。这使得查询和分析它们变得容易，并提取可用于进一步处理的有用信息。  
  3 | 
  4 | 活动适用于[ELK](https://www.elastic.co/webinars/introduction-elk-stack)，[Seq](https://getseq.net/)或[Splunk](https://www.splunk.com/)等活动商店。  
  5 | 
  6 | ## 32.1 发出事件
  7 | 默认情况下不会启用事件 - 但可以在`ConfigureServices`方法中进行全局配置，例如：   
  8 | 
  9 | ``` C#
 10 | services.AddIdentityServer(options =>
 11 | {
 12 |     options.Events.RaiseSuccessEvents = true;
 13 |     options.Events.RaiseFailureEvents = true;
 14 |     options.Events.RaiseErrorEvents = true;
 15 | });
 16 | ```   
 17 | 
 18 | 要发出事件，请使用`IEventService`DI容器并调用`RaiseAsync`方法，例如：  
 19 | 
 20 | ``` C#
 21 | public async Task<IActionResult> Login(LoginInputModel model)
 22 | {
 23 |     if (_users.ValidateCredentials(model.Username, model.Password))
 24 |     {
 25 |         // issue authentication cookie with subject ID and username
 26 |         var user = _users.FindByUsername(model.Username);
 27 |         await _events.RaiseAsync(new UserLoginSuccessEvent(user.Username, user.SubjectId, user.Username));
 28 |     }
 29 |     else
 30 |     {
 31 |         await _events.RaiseAsync(new UserLoginFailureEvent(model.Username, "invalid credentials"));
 32 |     }
 33 | }
 34 | ```   
 35 | 
 36 | ## 32.2 自定义接收器
 37 | 我们的默认事件接收器只是将事件类序列化为JSON并将其转发到ASP\.NET Core日志系统。如果要连接到自定义事件存储，请实现该`IEventSink`接口并将其注册到DI。  
 38 | 
 39 | 以下示例使用[Seq](https://getseq.net/)发出事件：   
 40 | 
 41 | ``` C#
 42 |  public class SeqEventSink : IEventSink
 43 | {
 44 |     private readonly Logger _log;
 45 | 
 46 |     public SeqEventSink()
 47 |     {
 48 |         _log = new LoggerConfiguration()
 49 |             .WriteTo.Seq("http://localhost:5341")
 50 |             .CreateLogger();
 51 |     }
 52 | 
 53 |     public Task PersistAsync(Event evt)
 54 |     {
 55 |         if (evt.EventType == EventTypes.Success ||
 56 |             evt.EventType == EventTypes.Information)
 57 |         {
 58 |             _log.Information("{Name} ({Id}), Details: {@details}",
 59 |                 evt.Name,
 60 |                 evt.Id,
 61 |                 evt);
 62 |         }
 63 |         else
 64 |         {
 65 |             _log.Error("{Name} ({Id}), Details: {@details}",
 66 |                 evt.Name,
 67 |                 evt.Id,
 68 |                 evt);
 69 |         }
 70 | 
 71 |         return Task.CompletedTask;
 72 |     }
 73 | }
 74 | ```   
 75 | 
 76 | 将`Serilog.Sinks.Seq`包添加到主机以使上述代码有效。   
 77 | 
 78 | ## 32.3 内置事件
 79 | IdentityServer中定义了以下事件：  
 80 | 
 81 | * **`ApiAuthenticationFailureEvent`** **＆** **`ApiAuthenticationSuccessEvent`**   
 82 | 获取内省端点上的成功/失败API身份验证。  
 83 | 
 84 | * **`ClientAuthenticationSuccessEvent`** **＆** **`ClientAuthenticationFailureEvent`**   
 85 | 获取在令牌端点处成功/失败的客户端身份验证。   
 86 | 
 87 | * **`TokenIssuedSuccessEvent`** **＆** **`TokenIssuedFailureEvent`**   
 88 | 获取成功/失败尝试请求身份令牌，访问令牌，刷新令牌和授权码。   
 89 | 
 90 | * **`TokenIntrospectionSuccessEvent`** **＆** **`TokenIntrospectionFailureEvent`**   
 91 | 获取成功的令牌内省请求。   
 92 | 
 93 | * **`TokenRevokedSuccessEvent`**   
 94 | 获取成功的令牌吊销请求。   
 95 | 
 96 | * **`UserLoginSuccessEvent ＆ UserLoginFailureEvent`**   
 97 | 成功/失败用户登录的快速入门UI引发。  
 98 | 
 99 | * **`UserLogoutSuccessEvent`**   
100 | 获取成功的注销请求。  
101 | 
102 | * **`ConsentGrantedEvent`** **＆** **`ConsentDeniedEvent`**   
103 | 在同意UI中引发。  
104 | 
105 | * **`UnhandledExceptionEvent`**   
106 | 获取未处理的异常。  
107 | 
108 | * **`DeviceAuthorizationFailureEvent`** **＆** **`DeviceAuthorizationSuccessEvent`**   
109 | 获取成功/失败的设备授权请求。  
110 | 
111 | ## 32.4 自定义事件
112 | 您可以创建自己的事件并通过我们的基础架构发出它们。  
113 | 
114 | 您需要从我们的基`Event`类派生，该基类注入活动ID，时间戳等上下文信息。您的派生类可以添加特定于事件上下文的任意数据字段：  
115 | 
116 | ``` C#
117 | public class UserLoginFailureEvent : Event
118 | {
119 |     public UserLoginFailureEvent(string username, string error)
120 |         : base(EventCategories.Authentication,
121 |                 "User Login Failure",
122 |                 EventTypes.Failure,
123 |                 EventIds.UserLoginFailure,
124 |                 error)
125 |     {
126 |         Username = username;
127 |     }
128 | 
129 |     public string Username { get; set; }
130 | }
131 | ```


--------------------------------------------------------------------------------
/第三部分 主题/第36章 扩展授权.md:
--------------------------------------------------------------------------------
  1 | # 第36章 扩展授权
  2 | OAuth 2.0为令牌端点定义了标准授权类型，例如`password`，`authorization_code`和`refresh_token`。扩展授权是一种添加对非标准令牌颁发方案（如令牌转换，委派或自定义凭据）的支持的方法。
  3 | 
  4 | 您可以通过实现`IExtensionGrantValidato`r接口添加对其他授权类型的支持：
  5 | 
  6 | ``` C#
  7 | public interface IExtensionGrantValidator
  8 | {
  9 |     /// <summary>
 10 |     /// Handles the custom grant request.
 11 |     /// </summary>
 12 |     /// <param name="request">The validation context.</param>
 13 |     Task ValidateAsync(ExtensionGrantValidationContext context);
 14 | 
 15 |     /// <summary>
 16 |     /// Returns the grant type this validator can deal with
 17 |     /// </summary>
 18 |     /// <value>
 19 |     /// The type of the grant.
 20 |     /// </value>
 21 |     string GrantType { get; }
 22 | }
 23 | ```  
 24 | 
 25 | 该`ExtensionGrantValidationContext`对象使您可以访问：
 26 | 
 27 | * 传入令牌请求 - 众所周知的验证值，以及任何自定义值（通过`Raw`集合）
 28 | * 结果 - 错误或成功
 29 | * 自定义响应参数 
 30 | 
 31 | 要注册扩展授权，请将其添加到DI：
 32 | 
 33 | ``` C# 
 34 | builder.AddExtensionGrantValidator<MyExtensionsGrantValidator>();
 35 | ```  
 36 | 
 37 | ## 36.1 示例：使用扩展授权的简单委派
 38 | 想象一下以下场景 - 前端客户端使用通过交互流（例如混合流）获取的令牌调用中间层API。此中间层API（API 1）现在希望代表交互式用户调用后端API（API 2）：
 39 | 
 40 | <div align="center">
 41 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/delegation.png"/>
 42 | </div>
 43 | 
 44 | 换句话说，中间层API（API 1）需要包含用户身份的访问令牌，但需要具有后端API（API 2）的范围。
 45 | 
 46 | > **注意**
 47 | 您可能听说过穷人代表团这一术语，前端的访问令牌只是转发到后端。这有一些缺点，例如API 2现在必须接受API 1范围，这将允许用户直接调用API 2。此外 - 您可能希望在令牌中添加一些特定于委托的声明，例如，调用路径是通过API 1的事实。
 48 | 
 49 | ### 36.1.1 实现扩展授权
 50 | 
 51 | 前端会将令牌发送到API 1，现在需要在IdentityServer上使用API​​ 2的新令牌交换此令牌。
 52 | 
 53 | 在线上，对交换的令牌服务的调用可能如下所示：
 54 | 
 55 | ```
 56 | POST /connect/token
 57 | 
 58 | grant_type=delegation&
 59 | scope=api2&
 60 | token=...&
 61 | client_id=api1.client
 62 | client_secret=secret
 63 | ```  
 64 | 
 65 | 扩展授权验证程序的工作是通过验证传入令牌来处理该请求，并返回表示新令牌的结果：
 66 | 
 67 | ``` C#
 68 | public class DelegationGrantValidator : IExtensionGrantValidator
 69 | {
 70 |     private readonly ITokenValidator _validator;
 71 | 
 72 |     public DelegationGrantValidator(ITokenValidator validator)
 73 |     {
 74 |         _validator = validator;
 75 |     }
 76 | 
 77 |     public string GrantType => "delegation";
 78 | 
 79 |     public async Task ValidateAsync(ExtensionGrantValidationContext context)
 80 |     {
 81 |         var userToken = context.Request.Raw.Get("token");
 82 | 
 83 |         if (string.IsNullOrEmpty(userToken))
 84 |         {
 85 |             context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant);
 86 |             return;
 87 |         }
 88 | 
 89 |         var result = await _validator.ValidateAccessTokenAsync(userToken);
 90 |         if (result.IsError)
 91 |         {
 92 |             context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant);
 93 |             return;
 94 |         }
 95 | 
 96 |         // get user's identity
 97 |         var sub = result.Claims.FirstOrDefault(c => c.Type == "sub").Value;
 98 | 
 99 |         context.Result = new GrantValidationResult(sub, GrantType);
100 |         return;
101 |     }
102 | }
103 | ```  
104 | 
105 | 不要忘记在DI上注册验证器。
106 | 
107 | ### 36.1.2 注册委托客户端
108 | 
109 | 您需要在IdentityServer中进行客户端注册，以允许客户端使用此新的扩展授权，例如：
110 | 
111 | ``` C#
112 | var client = new client
113 | {
114 |     ClientId = "api1.client",
115 |     ClientSecrets = new List<Secret>
116 |     {
117 |         new Secret("secret".Sha256())
118 |     },
119 | 
120 |     AllowedGrantTypes = { "delegation" },
121 | 
122 |     AllowedScopes = new List<string>
123 |     {
124 |         "api2"
125 |     }
126 | }
127 | ```   
128 | 
129 | ### 36.1.3 调用令牌端点
130 | 
131 | 在API 1中，您现在可以自己构建HTTP有效内容，或使用IdentityModel帮助程序库：
132 | 
133 | ``` C#
134 | public async Task<TokenResponse> DelegateAsync(string userToken)
135 | {
136 |     var payload = new
137 |     {
138 |         token = userToken
139 |     };
140 | 
141 |     // create token client
142 |     var client = new TokenClient(disco.TokenEndpoint, "api1.client", "secret");
143 | 
144 |     // send custom grant to token endpoint, return response
145 |     return await client.RequestCustomGrantAsync("delegation", "api2", payload);
146 | }
147 | ```   
148 | 
149 | 现在`TokenResponse.AccessToken`将包含委托访问令牌。


--------------------------------------------------------------------------------
/第五部分 参考/第56章 Client.md:
--------------------------------------------------------------------------------
  1 | # 第56章 Client
  2 | 该`Client`模型的OpenID Connect或OAuth 2.0 客户端-例如，本地应用，Web应用程序或基于JS的应用程序。
  3 | 
  4 | ## 56.1 Basics
  5 | * **`Enabled`**  
  6 | 指定是否启用客户端。默认为true。
  7 | 
  8 | * **`ClientId`**  
  9 | 客户端的唯一ID
 10 | 
 11 | * **`ClientSecrets`**  
 12 | 客户端机密列表 - 访问令牌端点的凭据。
 13 | 
 14 | * **`RequireClientSecret`**  
 15 | 指定此客户端是否需要密钥才能从令牌端点请求令牌（默认为`true`）
 16 | 
 17 | * **`AllowedGrantTypes`**  
 18 | 指定允许客户端使用的授权类型。使用`GrantTypes`该类进行常见组合。
 19 | 
 20 | * **`RequirePkce`**  
 21 | 指定使用基于授权代码的授权类型的客户端是否必须发送校验密钥
 22 | 
 23 | * **`AllowPlainTextPkce`**  
 24 | 指定使用PKCE的客户端是否可以使用纯文本代码质询（不推荐 - 默认为`false`）
 25 | 
 26 | * **`RedirectUris`**  
 27 | 指定允许的URI以返回令牌或授权码
 28 | 
 29 | * **`AllowedScopes`**  
 30 | 默认情况下，客户端无权访问任何资源 - 通过添加相应的范围名称来指定允许的资源
 31 | 
 32 | * **`AllowOfflineAccess`**  
 33 | 指定此客户端是否可以请求刷新令牌（请求`offline_access`范围）
 34 | 
 35 | * **`AllowAccessTokensViaBrowser`**  
 36 | 指定是否允许此客户端通过浏览器接收访问令牌。这对于强化允许多种响应类型的流是有用的（例如，通过禁止应该使用*code id_token*来添加令牌响应类型并因此将令牌泄漏到浏览器的混合流客户端。
 37 | 
 38 | * **`Properties`**  
 39 | 字典根据需要保存任何自定义客户端特定值。
 40 | 
 41 | ## 56.2 认证/注销
 42 | * **`PostLogoutRedirectUris`**  
 43 | 指定在注销后重定向到的允许URI。有关更多详细信息，请参阅[OIDC Connect会话管理规范](https://openid.net/specs/openid-connect-session-1_0.html)。
 44 | 
 45 | * **`FrontChannelLogoutUri`**  
 46 | 指定客户端的注销URI，以用于基于HTTP的前端通道注销。有关详细信息，请参阅[OIDC Front-Channel规范](https://openid.net/specs/openid-connect-frontchannel-1_0.html)。
 47 | 
 48 | * **`FrontChannelLogoutSessionRequired`**  
 49 | 指定是否应将用户的会话ID发送到`FrontChannelLogoutUri`。默认为`true`。
 50 | 
 51 | * **`BackChannelLogoutUri`**  
 52 | 指定客户端的注销URI，以用于基于HTTP的反向通道注销。有关更多详细信息，请参阅[OIDC Back-Channel规范](https://openid.net/specs/openid-connect-backchannel-1_0.html)。
 53 | 
 54 | * **`BackChannelLogoutSessionRequired`**  
 55 | 指定是否应在请求中将用户的会话ID发送到`BackChannelLogoutUri`。默认为`true`。
 56 | 
 57 | * **`EnableLocalLogin`**  
 58 | 指定此客户端是否可以仅使用本地帐户或外部IdP。默认为`true`。
 59 | 
 60 | * **`IdentityProviderRestrictions`**  
 61 | 指定可以与此客户端一起使用的外部IdP（如果列表为空，则允许所有IdP）。默认为空。
 62 | 
 63 | * **`UserSsoLifetime`*添加在2.3中***  
 64 | 自上次用户进行身份验证以来的最长持续时间（以秒为单位）。默认为`null`。您可以调整会话令牌的生命周期，以控制在使用Web应用程序时，用户需要重新输入凭据的时间和频率，而不是进行静默身份验证。
 65 | 
 66 | ## 56.3 Token
 67 | * **`IdentityTokenLifetime`**  
 68 | 身份令牌的生命周期，以秒为单位（默认为300秒/ 5分钟）
 69 | 
 70 | * **`AccessTokenLifetime`**  
 71 | 访问令牌的生命周期，以秒为单位（默认为3600秒/ 1小时）
 72 | 
 73 | * **`AuthorizationCodeLifetime`**  
 74 | 授权代码的生命周期，以秒为单位（默认为300秒/ 5分钟）
 75 | 
 76 | * **`AbsoluteRefreshTokenLifetime`**  
 77 | 刷新令牌的最长生命周期（秒）。默认为2592000秒/ 30天
 78 | 
 79 | * **`SlidingRefreshTokenLifetime`**  
 80 | 滑动刷新令牌的生命周期，以秒为单位。默认为1296000秒/ 15天
 81 | 
 82 | * **`RefreshTokenUsage`**  
 83 |     `ReUse` 刷新令牌时，刷新令牌句柄将保持不变
 84 | 
 85 |     `OneTime`刷新令牌时将更新刷新令牌句柄。这是默认值。
 86 | 
 87 | * **`RefreshTokenExpiration`**  
 88 |     `Absolute` 刷新令牌将在固定时间点到期（由AbsoluteRefreshTokenLifetime指定）  
 89 | 
 90 |     `Sliding`刷新令牌时，将刷新刷新令牌的生命周期（按SlidingRefreshTokenLifetime中指定的数量）。生命周期不会超过*AbsoluteRefreshTokenLifetime*。
 91 | 
 92 | * **`UpdateAccessTokenClaimsOnRefresh`**  
 93 | 获取或设置一个值，该值指示是否应在刷新令牌请求上更新访问令牌（及其声明）。
 94 | 
 95 | * **`AccessTokenType`**  
 96 | 指定访问令牌是引用令牌还是自包含JWT令牌（默认为Jwt）。
 97 | 
 98 | * **`IncludeJwtId`**  
 99 | 指定JWT访问令牌是否应具有嵌入的唯一ID（通过jti声明）。
100 | 
101 | * **`AllowedCorsOrigins`**  
102 | 如果指定，将由默认CORS策略服务实现（内存和EF）用于为JavaScript客户端构建CORS策略。
103 | 
104 | * **`Claims`**  
105 | 允许客户端的设置声明（将包含在访问令牌中）。
106 | 
107 | * **`AlwaysSendClientClaims`**  
108 | 如果设置，将为每个流发送客户端声明。如果不是，仅用于客户端凭证流（默认为`false`）
109 | 
110 | * **`AlwaysIncludeUserClaimsInIdToken`**  
111 | 在请求id token和access token时，如果用户声明始终将其添加到id token而不是请求客户端使用userinfo endpoint。默认值为*false*。
112 | 
113 | * **`ClientClaimsPrefix`**  
114 | 如果设置，将以前缀为前缀客户端声明类型。默认为*client_*。目的是确保它们不会意外地与用户声明冲突。
115 | 
116 | * **`PairWiseSubjectSalt`**  
117 | 对于此客户端的用户，在成对的subjectId生成中使用的salt值。
118 | 
119 | ## 56.4 确认页面
120 | * **`RequireConsent`**  
121 | 指定是否需要同意屏幕。默认为*true*。
122 | 
123 | * **`AllowRememberConsent`**  
124 | 指定用户是否可以选择存储同意决策。默认为*true*。
125 | 
126 | * **`ConsentLifetime`**  
127 | 用户同意的生命周期，以秒为单位。默认为null（无到期）。
128 | 
129 | * **`ClientName`**  
130 | 客户端显示名称（用于记录和同意屏幕）
131 | 
132 | * **`ClientUri`**  
133 | 有关客户端的更多信息的URI（在同意屏幕上使用）
134 | 
135 | * **`LogoUri`**  
136 | URI到客户端徽标（在同意屏幕上使用）
137 | 
138 | ## 56.5 设备流程
139 | * **`UserCodeType`**  
140 | 指定用于客户端的用户代码的类型。否则使用默认值。
141 | 
142 | * **`DeviceCodeLifetime`**  
143 | 设备代码的生命周期，以秒为单位（默认为300秒/ 5分钟）


--------------------------------------------------------------------------------
/第三部分 主题/第18章 启动.md:
--------------------------------------------------------------------------------
  1 | # 第18章 启动
  2 | IdentityServer是中间件和服务的组合。所有配置都在您的启动类中完成。   
  3 | 
  4 | ## 18.1 配置服务
  5 | 您可以通过调用以下方法将IdentityServer服务添加到DI系统：   
  6 | ``` C#
  7 | public void ConfigureServices(IServiceCollection services)
  8 | {
  9 |     var builder = services.AddIdentityServer();
 10 | }
 11 | ```   
 12 | 
 13 | 您可以选择将选项传入此调用。有关选项的详细信息，请参见[此](https://github.com/thinksjay/IdentityServer4/blob/master/%E5%8F%82%E8%80%83/%E7%AC%AC61%E7%AB%A0%20IdentityServer%20Options.md)   
 14 | 
 15 | 这将返回一个构建器对象，该构建器对象又有许多方便的方法来连接其他服务。   
 16 | 
 17 | ## 18.2 密钥材料
 18 | * **`AddSigningCredential`**    
 19 | 添加签名密钥服务，该服务为各种令牌创建/验证服务提供指定的密钥材料。您可以从证书存储中传入证书的`X509Certificate2`， `SigningCredential`或引用。   
 20 | 
 21 | * **`AddDeveloperSigningCredential`**   
 22 | 在启动时创建临时密钥材料。当您没有要使用的证书时，这仅适用于dev。生成的密钥将保留到文件系统，以便在服务器重新启动之间保持稳定（可以通过传递禁用false）。这解决了客户端/api元数据缓存在开发期间不同步时的问题。   
 23 | 
 24 | * **`AddValidationKey`**   
 25 | 添加用于验证令牌的密钥。它们将由内部令牌验证器使用，并将显示在发现文档中。您可以从证书存储中传入证书的  X509Certificate2`，`SigningCredential`或引用。这对于关键翻转场景非常有用。   
 26 | 
 27 | ## 18.3 内存配置存储
 28 | 各种“内存中”配置API允许从内存中的配置对象列表配置IdentityServer。这些“内存中”集合可以在宿主应用程序中进行硬编码，也可以从配置文件或数据库动态加载。但是，通过设计，这些集合仅在托管应用程序启动时创建。   
 29 | 
 30 | 这些配置API的使用旨在用于原型设计，开发和/或测试时，在运行时不需要为配置数据动态查询数据库。如果配置很少更改，则此配置模板也可能适用于生产方案，或者如果必须更改值，则要求重新启动应用程序并不方便。   
 31 | 
 32 | * **`AddInMemoryClients`**   
 33 | 基于配置对象的内存中集合的注册IClientStore和ICorsPolicyService实现Client。   
 34 | 
 35 | * **`AddInMemoryIdentityResources`**   
 36 | IResourceStore根据IdentityResource配置对象的内存中集合注册实现。   
 37 | 
 38 | * **`AddInMemoryApiResources`**   
 39 | IResourceStore根据ApiResource配置对象的内存中集合注册实现。   
 40 | 
 41 | ## 18.4 测试商店
 42 | 该TestUser是用户类，他们的凭据和声明在IdentityServer中。使用TestUser类似于“内存”存储的，因为它用于原型设计，开发或测试。TestUser在生产中不推荐使用。
 43 | 
 44 | * **`AddTestUsers`**   
 45 | `TestUserStore`基于`TestUser`对象集合的注册。 `TestUserStore`由默认的快速入门UI使用。还注册实现`IProfileService`和`IResourceOwnerPasswordValidator`。
 46 | ## 18.5 添加服务
 47 | * **`AddExtensionGrantValidator`**   
 48 | 添加`IExtensionGrantValidator`实现以用于扩展授权。   
 49 | 
 50 | * **`AddSecretParser`**   
 51 | 添加ISecretParser用于解析客户端或API资源凭据的实现。  
 52 | 
 53 | * **`AddSecretValidator`**  
 54 | 添加`ISecretValidator`用于针对凭证存储验证客户端或API资源凭证的实现。  
 55 | 
 56 | * **`AddResourceOwnerValidator`**  
 57 | 添加`IResourceOwnerPasswordValidator`用于验证资源所有者密码凭据授予类型的用户凭据的实现。  
 58 | 
 59 | * **`AddProfileService`**  
 60 | 添加`IProfileService`用于连接到自定义用户配置文件存储的实现。的`DefaultProfileService`类提供了依赖于验证cookie作为权利要求中的用于在令牌发行的唯一来源的默认实现。  
 61 | 
 62 | * **`AddAuthorizeInteractionResponseGenerator`**  
 63 | 添加`IAuthorizeInteractionResponseGenerator`实现以在授权端点处定制逻辑，以便在必须向用户显示错误，登录，同意或任何其他自定义页面的UI时。本`AuthorizeInteractionResponseGenerator`类提供了一个默认的实现，因此考虑从这个现有的类派生如果需要增强现有的行为。   
 64 | 
 65 | * **`AddCustomAuthorizeRequestValidator`**  
 66 | 添加`ICustomAuthorizeRequestValidator`实现以在授权端点处自定义请求参数验证。  
 67 | 
 68 | * **`AddCustomTokenRequestValidator`**  
 69 | 添加`ICustomTokenRequestValidator`实现以在令牌端点处自定义请求参数验证。  
 70 | 
 71 | * **`AddRedirectUriValidator`**  
 72 | 添加`IRedirectUriValidator`实现以自定义重定向URI验证。  
 73 | 
 74 | * **`AddAppAuthRedirectUriValidator`**  
 75 | 添加一个“AppAuth”（适用于Native Apps的OAuth 2.0）兼容的重定向URI验证器（进行严格验证，但也允许带有随机端口的http://127.0.0.1）。  
 76 | 
 77 | * **`AddJwtBearerClientAuthentication`**  
 78 | 使用JWT承载断言添加对客户端身份验证的支持。
 79 | 
 80 | ## 18.6 缓存
 81 | IdentityServer经常使用客户端和资源配置数据。如果从数据库或其他外部存储加载此数据，则频繁重新加载相同数据可能会很昂贵。
 82 | 
 83 | * **`AddInMemoryCaching`**  
 84 | 要使用下面描述的任何缓存，`ICache<T>`必须在DI中注册实现。此API注册了`ICache<T>`基于ASP.NET Core的默认内存实现`MemoryCache`。  
 85 | 
 86 | * **`AddClientStoreCache`**  
 87 | 注册一个`IClientStore`装饰器实现，它将维护`Client`配置对象的内存缓存。缓存持续时间可在``Caching配置选项上配置`IdentityServerOptions`。  
 88 | 
 89 | * **`AddResourceStoreCache`**  
 90 | 注册一个`IResourceStore`装饰器实现，它将维护内存缓存`IdentityResource`和`ApiResource`配置对象。缓存持续时间可在`Caching`配置选项上配置`IdentityServerOptions`。  
 91 | 
 92 | * **`AddCorsPolicyCache`**  
 93 | 注册`ICorsPolicyService`装饰器实现，该实现将维护**CORS**策略服务评估结果的内存缓存。缓存持续时间可在`Caching`配置选项上配置`IdentityServerOptions`。  
 94 | 
 95 | 可以进一步自定义缓存：  
 96 | 
 97 | 默认缓存依赖于`ICache<T>`实现。如果要自定义特定配置对象的缓存行为，可以在依赖项注入系统中替换此实现。
 98 | 
 99 | `ICache<T>`本身的默认实现依赖于.NET提供的`IMemoryCache`接口（和`MemoryCache`实现）。如果要自定义内存中缓存行为，可以替换`IMemoryCache`依赖项注入系统中的实现。
100 | 
101 | ## 18.7 配置管道
102 | 您需要通过调用以下方法将IdentityServer添加到管道：  
103 | 
104 | ``` C#
105 | public void Configure(IApplicationBuilder app)
106 | {
107 |     app.UseIdentityServer();
108 | }
109 | ```   
110 | 
111 | > **注意**
112 | `UseIdentityServer`包括`UseAuthentication`，所以没有必要同时使用。   
113 | 
114 | 中间件没有其他配置。   
115 | 
116 | 请注意，顺序在管道中很重要。例如，您需要在实现登录页面的UI框架之前添加IdentitySever。
117 | 


--------------------------------------------------------------------------------
/第三部分 主题/第34章 授予类型.md:
--------------------------------------------------------------------------------
  1 | # 第34章 授予类型
  2 | 授权类型是指定客户端如何与IdentityServer交互的方式。OpenID Connect和OAuth2.0规范定义了以下授权类型：
  3 | 
  4 | * Implicit
  5 | * Authorization code
  6 | * Hybrid
  7 | * Client credentials
  8 | * Resource owner password
  9 | * Device flow
 10 | * Refresh tokens
 11 | * Extension grants
 12 | 
 13 | 你可以在`Client`的配置中用`AllowedGrantTypes` 来指定授权类型。
 14 | 
 15 | 一个客户端可以指定不止一种授权类型（比如Hybrid用于以用户为中心的交互，client_credential用于服务端对服务端的交互），`GrantTypes`类里面有一些特有的授权类型：
 16 | ``` C#
 17 | Client.AllowedGrantTypes = GrantTypes.HybridAndClientCredentials;
 18 | ```   
 19 | 
 20 | 你也可以指定一个授权类型的列表：
 21 | 
 22 | ``` C#
 23 | Client.AllowedGrantTypes =
 24 | {
 25 |     GrantType.Hybrid,
 26 |     GrantType.ClientCredentials,
 27 |     "my_custom_grant_type"
 28 | };
 29 | ```
 30 | 
 31 | 如果想要通过浏览器通道传输access token，你需要显式的允许客户端做如下配置：
 32 | 
 33 | ``` C#
 34 | Client.AllowAccessTokensViaBrowser = true;
 35 | ```   
 36 | 
 37 | > **注意**
 38 | 处于安全的因素，不是所有的类型的组合（例如上面的那个列表）被允许的，具体看下面的解释。
 39 | 
 40 | 本文余下部分将简要描述授权类型，以及何时使用它们。此外，还建议阅读相应的规范，以便更好地理解其中的差异。
 41 | 
 42 | ## 34.1 Client credentials
 43 | 对于服务和服务之间的通讯来说Client credentials是最简单的一种使用场景。这种情况下请求token的是客户端，而不是用户。
 44 | 
 45 | 这种情况下向令牌端点（token endpoint）发送了一个令牌请求，并获得代表客户端的访问令牌。客户端通常需要使用其client id和secret对令牌端点进行身份验证。
 46 | 
 47 | 有关如何使用它的示例，请参阅[客户端凭据快速入门](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%8C%E9%83%A8%E5%88%86%20%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8/%E7%AC%AC9%E7%AB%A0%20%E4%BD%BF%E7%94%A8%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%87%AD%E6%8D%AE%E4%BF%9D%E6%8A%A4API.md)。
 48 | 
 49 | ## 34.2 Resource owner password
 50 | 这种授权类型允许一个客户端代表用户向令牌端点（token endpoint）发送一个用户名和密码。这是所谓的“非交互”认证，并且通常情况下也是不推荐的。
 51 | 
 52 | 它存在的一些理由包括一些遗留代码中或者一些集成的场景中，在这种情况下，这种授予类型是有用的，但是一般的建议是使用隐式或混合的交互流来代替用户身份验证。
 53 | 
 54 | 查看这里可以参考一些关于这方面的参考，通过实现`IResourceOwnerPasswordValidator`这个接口，你可以提供一些校验username/password的代码。您可以在[此处](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC37%E7%AB%A0%20%E8%B5%84%E6%BA%90%E6%89%80%E6%9C%89%E8%80%85%E5%AF%86%E7%A0%81%E9%AA%8C%E8%AF%81(Resource%20Owner%20Password%20Validation).md)找到有关此接口的更多信息。
 55 | 
 56 | ## 34.3 Implicit
 57 | 隐式的授权类型对基于浏览器的应用进行了优化，用于用户身份验证（包括服务器端和JavaScript应用程序），或身份验证和访问令牌请求（JavaScript应用程序）。
 58 | 
 59 | 在隐式流中，所有令牌都通过浏览器传输，因此不允许刷新令牌等高级功能。
 60 | 
 61 | [该](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%8C%E9%83%A8%E5%88%86%20%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8/%E7%AC%AC11%E7%AB%A0%20%E4%BD%BF%E7%94%A8OpenID%20Connect%E6%B7%BB%E5%8A%A0%E7%94%A8%E6%88%B7%E8%BA%AB%E4%BB%BD%E9%AA%8C%E8%AF%81.md)快速入门显示了服务器端的web应用程序的认证，而[这](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%8C%E9%83%A8%E5%88%86%20%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8/%E7%AC%AC14%E7%AB%A0%20%E6%B7%BB%E5%8A%A0JavaScript%E5%AE%A2%E6%88%B7%E7%AB%AF.md)个显示的JavaScript。
 62 | 
 63 | > **注意**
 64 | 对于基于JavaScript的应用程序，不再推荐使用Implicit。请使用PKCE使用授权码。
 65 | 
 66 | ## 34.4 Authorization code
 67 | 授权码流最初由OAuth2.0指定，并提供了一种在反向通道上检索令牌而不是浏览器前置通道的方法。它还支持客户端身份验证。
 68 | 
 69 | 虽然这种授权类型本身是受支持的，但通常建议您将其与身份令牌结合使用，将其转换为所谓的混合流。混合流程为您提供重要的额外功能，如签名协议响应。
 70 | 
 71 | ## 34.5 Hybrid
 72 | 混合流是隐式和授权代码流的组合 - 它使用多种授权类型的组合，最典型的是`code id_token`
 73 | 
 74 | 在混合流中，身份令牌通过浏览器通道传输，并包含签名的协议响应以及其他工件（如授权代码）的签名。这减轻了许多适用于浏览器通道的攻击。成功验证响应后，反向通道用于检索访问和刷新令牌。
 75 | 
 76 | 这是希望检索访问令牌（也可能是刷新令牌）的本机应用程序的推荐流程，用于服务器端Web应用程序和本机桌面/移动应用程序。
 77 | 
 78 | 有关将混合流与MVC一起使用的更多信息，请参阅[此](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%8C%E9%83%A8%E5%88%86%20%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8/%E7%AC%AC13%E7%AB%A0%20%E5%88%87%E6%8D%A2%E5%88%B0%E6%B7%B7%E5%90%88%E6%B5%81%E5%B9%B6%E6%B7%BB%E5%8A%A0API%E8%AE%BF%E9%97%AE.md)快速入门。
 79 | 
 80 | ## 34.6 Device flow
 81 | 设备流程专为无浏览器和输入受限设备而设计，设备无法安全地捕获用户凭据。此流程将用户身份验证和同意外包给外部设备（例如智能手机）。
 82 | 
 83 | 此流程通常由IoT设备使用，可以请求身份和API资源。
 84 | 
 85 | ## 34.7 Refresh tokens
 86 | 刷新令牌允许获得对API的长期访问。
 87 | 
 88 | 您通常希望尽可能缩短访问令牌的生命周期，但同时不要一次又一次地通过对IdentityServer进行前端通道往返请求新的令牌来打扰用户。
 89 | 
 90 | 刷新令牌允许在没有用户交互的情况下请求新的访问令牌。每次客户端刷新令牌时，都需要对IdentityServer进行（经过身份验证的）反向通道调用。这允许检查刷新令牌是否仍然有效，或者在此期间是否已被撤销。
 91 | 
 92 | 混合，授权代码，设备流和资源所有者密码流支持刷新令牌。要请求刷新令牌，客户端需要在令牌请求中包含`offline_access`范围（并且必须被授权请求该范围）。
 93 | 
 94 | ## 34.8 Extension grants
 95 | 扩展授权允许使用新的授权类型扩展令牌端点。有关详细信息，请参阅[此](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86%20%E4%B8%BB%E9%A2%98/%E7%AC%AC36%E7%AB%A0%20%E6%89%A9%E5%B1%95%E6%8E%88%E6%9D%83.md)
 96 | 
 97 | ## 34.9 Incompatible grant types
 98 | 禁止某些授权类型组合：
 99 | 
100 | * 混合使用隐式和授权码或混合将允许从更安全的基于代码的流降级到隐式。
101 | * 同样的问题也存在于允许授权码和混合


--------------------------------------------------------------------------------
/第三部分 主题/第29章 保护API.md:
--------------------------------------------------------------------------------
  1 | # 第29章 保护API
  2 | IdentityServer 默认以[JWT](https://tools.ietf.org/html/rfc7519)（JSON Web令牌）格式发出访问令牌。
  3 | 
  4 | 今天的每个相关平台都支持验证JWT令牌，[这里](https://jwt.io/)可以找到一个很好的JWT库列表。热门库例如：
  5 | 
  6 | * ASP.NET Core的[JWT bearer authentication handler](https://www.nuget.org/packages/Microsoft.AspNetCore.Authentication.JwtBearer/)
  7 | * Katana的[JWT bearer authentication middleware](https://www.nuget.org/packages/Microsoft.Owin.Security.Jwt)
  8 | * Katana的[IdentityServer authentication middleware](https://identityserver.github.io/Documentation/docsv2/consuming/overview.html)
  9 | * NodeJS的[jsonwebtoken](https://www.npmjs.com/package/jsonwebtoken) 
 10 | 
 11 | 保护基于ASP.NET Core的API只需在DI中配置JWT承载认证处理程序，并将认证中间件添加到管道：
 12 | 
 13 | ``` C#
 14 | public class Startup
 15 | {
 16 |     public void ConfigureServices(IServiceCollection services)
 17 |     {
 18 |         services.AddMvc();
 19 | 
 20 |         services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
 21 |             .AddJwtBearer(options =>
 22 |             {
 23 |                 // base-address of your identityserver
 24 |                 options.Authority = "https://demo.identityserver.io";
 25 | 
 26 |                 // name of the API resource
 27 |                 options.Audience = "api1";
 28 |             });
 29 |     }
 30 | 
 31 |     public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
 32 |     {
 33 |         app.UseAuthentication();
 34 |         app.UseMvc();
 35 |     }
 36 | }
 37 | ```  
 38 | 
 39 | ## 29.1 IdentityServer身份验证处理程序
 40 | 我们的身份验证处理程序与上述处理程序的用途相同（实际上它在内部使用Microsoft JWT库），但添加了一些其他功能：
 41 | 
 42 | * 支持JWT和参考令牌
 43 | * 用于引用标记的可扩展缓存
 44 | * 统一配置模型
 45 | * 范围验证  
 46 | 
 47 | 
 48 | 对于最简单的情况，我们的处理程序配置看起来非常类似于上面的代码段：
 49 | 
 50 | ``` C#
 51 | public class Startup
 52 | {
 53 |     public void ConfigureServices(IServiceCollection services)
 54 |     {
 55 |         services.AddMvc();
 56 | 
 57 |         services.AddAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme)
 58 |             .AddIdentityServerAuthentication(options =>
 59 |             {
 60 |                 // base-address of your identityserver
 61 |                 options.Authority = "https://demo.identityserver.io";
 62 | 
 63 |                 // name of the API resource
 64 |                 options.ApiName = "api1";
 65 |             });
 66 |     }
 67 | 
 68 |     public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
 69 |     {
 70 |         app.UseAuthentication();
 71 |         app.UseMvc();
 72 |     }
 73 | }
 74 | ```   
 75 | 
 76 | 你可以从[nuget](https://www.nuget.org/packages/IdentityServer4.AccessTokenValidation/)或[github](https://github.com/IdentityServer/IdentityServer4.AccessTokenValidation)获得包。
 77 | 
 78 | ## 29.2 支持引用标记
 79 | 如果传入令牌不是JWT，我们的中间件将联系发现文档中的内省端点以验证令牌。由于内省端点需要身份验证，因此您需要提供已配置的API密钥，例如：
 80 | 
 81 | ``` C#
 82 | .AddIdentityServerAuthentication(options =>
 83 | {
 84 |     // base-address of your identityserver
 85 |     options.Authority = "https://demo.identityserver.io";
 86 | 
 87 |     // name of the API resource
 88 |     options.ApiName = "api1";
 89 |     options.ApiSecret = "secret";
 90 | })
 91 | ```   
 92 | 
 93 | 通常，您不希望为每个传入请求执行到内省端点的往返。中间件有一个内置缓存，您可以像这样启用：
 94 | 
 95 | ``` C#
 96 | .AddIdentityServerAuthentication(options =>
 97 | {
 98 |     // base-address of your identityserver
 99 |     options.Authority = "https://demo.identityserver.io";
100 | 
101 |     // name of the API resource
102 |     options.ApiName = "api1";
103 |     options.ApiSecret = "secret";
104 | 
105 |     options.EnableCaching = true;
106 |     options.CacheDuration = TimeSpan.FromMinutes(10); // that's the default
107 | })
108 | ```
109 | 
110 | 处理程序将使用在DI容器中注册的任何*IDistributedCache*实现（例如标准的*MemoryDistributedCache*）。
111 | 
112 | ## 29.3 验证范围
113 | 所述*ApiName*属性检查该令牌具有匹配观众（或短`aud`），如权利要求。
114 | 
115 | 在IdentityServer中，您还可以将API细分为多个范围。如果需要该粒度，可以使用ASP.NET Core授权策略系统来检查范围。
116 | 
117 | ### 29.3.1 制定全球政策： 
118 | 
119 | ``` C#
120 | services
121 |     .AddMvcCore(options =>
122 |     {
123 |         // require scope1 or scope2
124 |         var policy = ScopePolicy.Create("scope1", "scope2");
125 |         options.Filters.Add(new AuthorizeFilter(policy));
126 |     })
127 |     .AddJsonFormatters()
128 |     .AddAuthorization();
129 | ```  
130 | 
131 | ### 29.3.2 制定范围政策：
132 | ``` C#
133 | services.AddAuthorization(options =>
134 | {
135 |     options.AddPolicy("myPolicy", builder =>
136 |     {
137 |         // require scope1
138 |         builder.RequireScope("scope1");
139 |         // and require scope2 or scope3
140 |         builder.RequireScope("scope2", "scope3");
141 |     });
142 | });
143 | ```


--------------------------------------------------------------------------------
/第五部分 参考/第62章 EntityFramework支持.md:
--------------------------------------------------------------------------------
  1 | # 第62章 EntityFramework支持
  2 | 为IdentityServer中的配置和操作数据扩展点提供了基于EntityFramework的实现。EntityFramework的使用允许任何EF支持的数据库与此库一起使用。
  3 | 
  4 | 这个库的仓库位于[这里](https://github.com/IdentityServer/IdentityServer4.EntityFramework/)，NuGet包就在[这里](https://www.nuget.org/packages/IdentityServer4.EntityFramework)。
  5 | 
  6 | 此库提供的功能分为两个主要区域：配置存储和操作存储支持。根据托管应用程序的需要，这两个不同的区域可以独立使用或一起使用。
  7 | 
  8 | ## 62.1 配置存储支持客户端，资源和CORS设置
  9 | 如果希望从EF支持的数据库加载客户端，标识资源，API资源或CORS数据（而不是使用内存配置），则可以使用配置存储。此支持提供了`IClientStore`和`IResourceStore`，以及`ICorsPolicyService`可扩展性点的实现。这些实现使用一个`DbContext`被调用的类`ConfigurationDbContext`来为数据库中的表建模。
 10 | 
 11 | 要使用配置存储支持，请在调用`AddIdentityServer`后使用`AddConfigurationStore`扩展方法：
 12 | 
 13 | ``` C#
 14 | public IServiceProvider ConfigureServices(IServiceCollection services)
 15 | {
 16 |     const string connectionString = @"Data Source=(LocalDb)\MSSQLLocalDB;database=IdentityServer4.EntityFramework-2.0.0;trusted_connection=yes;";
 17 |     var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name;
 18 | 
 19 |     services.AddIdentityServer()
 20 |         // this adds the config data from DB (clients, resources, CORS)
 21 |         .AddConfigurationStore(options =>
 22 |         {
 23 |             options.ConfigureDbContext = builder =>
 24 |                 builder.UseSqlServer(connectionString,
 25 |                     sql => sql.MigrationsAssembly(migrationsAssembly));
 26 |         });
 27 | }
 28 | ```  
 29 | 
 30 | 要配置配置存储，请使用`ConfigurationStoreOptions`的options对象传递给配置回调。
 31 | 
 32 | ## 62.2 ConfigurationStoreOptions 
 33 | 此选项类包含用于控制配置存储的属性和`ConfigurationDbContext`。
 34 | 
 35 | * **`ConfigureDbContext`**  
 36 | `Action<DbContextOptionsBuilder>`用作回调的类型委托来配置底层`ConfigurationDbContext`。`ConfigurationDbContext`如果直接使用EF，代理可以以相同的方式配置`AddDbContext`，这允许使用任何EF支持的数据库。
 37 | 
 38 | * **`DefaultSchema`**  
 39 | 允许为`ConfigurationDbContext`中的所有表设置默认数据库模式名称。
 40 | 
 41 | ``` C#
 42 | options.DefaultSchema = "myConfigurationSchema";
 43 | ```  
 44 | 
 45 | 如果需要更改迁移历史记录表的架构，可以将另一个操作链接到`UserSqlServer`：
 46 | 
 47 | ``` C#
 48 | options.ConfigureDbContext = b =>
 49 |     b.UseSqlServer(connectionString,
 50 |         sql => sql.MigrationsAssembly(migrationsAssembly).MigrationsHistoryTable("MyConfigurationMigrationTable", "myConfigurationSchema"));
 51 | ```  
 52 | 
 53 | ## 62.3 操作存储支持授权授予，同意和令牌（刷新和引用）
 54 | 如果希望从EF支持的数据库（而不是默认的内存数据库）加载授权授予，同意和令牌（刷新和引用），则可以使用操作存储。此支持提供了`IPersistedGrantStore`可扩展性点的实现。该实现使用一个`DbContext`被调用的类`PersistedGrantDbContext`来为数据库中的表建模。
 55 | 
 56 | 要使用操作性存储支持，请在调用`AddIdentityServer`后使用`AddOperationalStore`扩展方法：
 57 | 
 58 | ``` C#
 59 | public IServiceProvider ConfigureServices(IServiceCollection services)
 60 | {
 61 |     const string connectionString = @"Data Source=(LocalDb)\MSSQLLocalDB;database=IdentityServer4.EntityFramework-2.0.0;trusted_connection=yes;";
 62 |     var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name;
 63 | 
 64 |     services.AddIdentityServer()
 65 |         // this adds the operational data from DB (codes, tokens, consents)
 66 |         .AddOperationalStore(options =>
 67 |         {
 68 |             options.ConfigureDbContext = builder =>
 69 |                 builder.UseSqlServer(connectionString,
 70 |                     sql => sql.MigrationsAssembly(migrationsAssembly));
 71 | 
 72 |             // this enables automatic token cleanup. this is optional.
 73 |             options.EnableTokenCleanup = true;
 74 |             options.TokenCleanupInterval = 30; // interval in seconds
 75 |         });
 76 | }
 77 | ```   
 78 | 
 79 | 要配置操作存储，请使用`OperationalStoreOptions`的`options`对象传递给配置回调。
 80 | 
 81 | ## 62.4 OperationalStoreOptions 
 82 | 此选项类包含用于控制操作`PersistedGrantDbContext`存储的属性。
 83 | 
 84 | * **`ConfigureDbContext`**  
 85 | `Action<DbContextOptionsBuilder>`用作回调的类型委托来配置底层`PersistedGrantDbContext`。`PersistedGrantDbContext`如果直接使用EF，代理可以以相同的方式配置`AddDbContext`，这允许使用任何EF支持的数据库。
 86 | 
 87 | * **`DefaultSchema`**  
 88 | 允许为`PersistedGrantDbContext`中的所有表设置默认数据库模式名称。
 89 | 
 90 | * **`EnableTokenCleanup`**  
 91 | 指示是否将从数据库中自动清除过时条目。默认是false。
 92 | 
 93 | * **`TokenCleanupInterval`**  
 94 | 令牌清理间隔（以秒为单位）。默认值为3600（1小时）。
 95 | 
 96 | ## 62.5 跨不同版本的IdentityServer的数据库创建和模式更改
 97 | 跨不同版本的IdentityServer（以及EF支持）很可能会更改数据库架构以适应新的和不断变化的功能。
 98 | 
 99 | 我们不为创建数据库或将数据从一个版本迁移到另一个版本提供任何支持。您需要以组织认为合适的任何方式管理数据库创建，架构更改和数据迁移。
100 | 
101 | 使用EF迁移是一种可行的方法。如果您确实希望使用迁移，请参阅[EF快速入门](https://github.com/thinksjay/IdentityServer4/blob/master/%E7%AC%AC%E4%BA%8C%E9%83%A8%E5%88%86%20%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8/%E7%AC%AC15%E7%AB%A0%20%E4%BD%BF%E7%94%A8EntityFramework%20Core%E8%BF%9B%E8%A1%8C%E9%85%8D%E7%BD%AE%E5%92%8C%E6%93%8D%E4%BD%9C%E6%95%B0%E6%8D%AE.md)以获取有关如何入门的示例，或参阅有关EF迁移的Microsoft[文档](https://docs.microsoft.com/en-us/ef/core/managing-schemas/migrations/index)。
102 | 
103 | 我们还为当前版本的数据库模式发布了示例[SQL脚本](https://github.com/IdentityServer/IdentityServer4.EntityFramework.Storage/tree/dev/migrations/SqlServer/Migrations)。


--------------------------------------------------------------------------------
/第六部分 其它/第65章 博客帖子.md:
--------------------------------------------------------------------------------
 1 | # 第65章 博客帖子
 2 | ## 65.1 团队帖子
 3 | ### 65.1.1 2019 
 4 | * [IdentityServer中的范围和声明设计](https://brockallen.com/2019/02/25/scope-and-claims-design-in-identityserver/)
 5 | * [尝试使用IdentityServer4的设备流程](https://leastprivilege.com/2019/02/08/try-device-flow-with-identityserver4/)
 6 | * [OAuth2中隐含流的状态](https://brockallen.com/2019/01/03/the-state-of-the-implicit-flow-in-oauth2/)
 7 | * [另一种保护SPA的方法（使用ASP.NET Core，OpenID Connect，OAuth 2.0和ProxyKit](https://leastprivilege.com/2019/01/18/an-alternative-way-to-secure-spas-with-asp-net-core-openid-connect-oauth-2-0-and-proxykit/)
 8 | * [ASP.NET核心中的自动OAuth 2.0令牌管理](https://leastprivilege.com/2019/01/14/automatic-oauth-2-0-token-management-in-asp-net-core/)
 9 | * [加密IdentityServer4中的身份令牌](https://www.scottbrady91.com/Identity-Server/Encrypting-Identity-Tokens-in-IdentityServer4)
10 | 
11 | ### 65.1.2 2018
12 | * [IdentityServer4更新](https://leastprivilege.com/2018/01/17/ndc-london-2018-identityserver-update/)
13 | * [IdentityServer和Swagger](https://www.scottbrady91.com/Identity-Server/ASPNET-Core-Swagger-UI-Authorization-using-IdentityServer4)
14 | * [https://www.scottbrady91.com/OAuth/Removing-Shared-Secrets-for-OAuth-Client-Authentication](https://www.scottbrady91.com/OAuth/Removing-Shared-Secrets-for-OAuth-Client-Authentication)
15 | * [创建自己的IdentityServer4存储库](https://www.scottbrady91.com/Identity-Server/Creating-Your-Own-IdentityServer4-Storage-Library)
16 | 
17 | ### 65.1.1 2017
18 | * [可以运行IdentityServer4的平台](https://leastprivilege.com/2017/01/15/platforms-where-you-can-run-identityserver4/)
19 | * [优化令牌的大小](https://leastprivilege.com/2016/12/14/optimizing-identity-tokens-for-size/)
20 | * [身份与权限](https://leastprivilege.com/2016/12/16/identity-vs-permissions/)
21 | * [Bootstraping OpenID Connect：Discovery](https://leastprivilege.com/2017/01/06/bootstrapping-openid-connect-discovery/)
22 | * [使用WS-Federation支持扩展IdentityServer4](https://leastprivilege.com/2017/03/03/extending-identityserver4-with-ws-federation-support/)
23 | * [宣布IdentityServer4 RC1](https://leastprivilege.com/2016/09/06/identityserver4-rc1/)
24 | * [IdentityServer入门4](https://www.scottbrady91.com/Identity-Server/Getting-Started-with-IdentityServer-4)
25 | * [使用WS-Federation的IdentityServer 4 SharePoint集成](https://www.scottbrady91.com/Identity-Server/IdentityServer-4-SharePoint-Integration-using-WS-Federation)
26 | 
27 | ## 65.2 什么是新帖子
28 | * [IdentityServer4 v2中的新功能：负载均衡器或反向代理后面的简化配置](https://leastprivilege.com/2017/10/09/new-in-identityserver4-v2-simplified-configuration-behind-load-balancers-or-reverse-proxies/)
29 | * [IdentityServer4中的新功能：没有秘密的客户端](https://leastprivilege.com/2016/09/13/new-in-identityserver4-clients-without-secrets/)
30 | * [IdentityServer4中的新功能：默认范围](https://leastprivilege.com/2016/09/14/new-in-identityserver4-default-scopes/)
31 | * [IdentityServer4中的新功能：支持扩展授权](https://leastprivilege.com/2016/09/20/new-in-identityserver4-support-for-extension-grants/)
32 | * [IdentityServer4中的新功能：资源所有者密码验证](https://leastprivilege.com/2016/09/29/new-in-identityserver4-resource-owner-password-validation/)
33 | * [IdentityServer4中的新功能：基于资源的配置](https://leastprivilege.com/2016/12/01/new-in-identityserver4-resource-based-configuration/)
34 | * [IdentityServer4中的新功能：事件](https://leastprivilege.com/2017/03/30/new-in-identityserver4-events/)
35 | 
36 | ## 65.3 社区帖子
37 | * [OAuth 2.0 - OpenID Connect和IdentityServer](https://wp.me/p3mRWu-1Ag/)
38 | * [在Docker容器中运行IdentityServer4](https://espressocoder.com/2019/01/29/running-identityserver4-in-a-docker-container/)
39 | * [连接Zendesk和IdentityServer 4 SAML 2.0身份提供商](https://lurumad.github.io/connecting-zendesk-and-identityserver-4-saml2p-identity-provider)
40 | * [使用ui_locales进行IdentityServer本地化](https://damienbod.com/2017/11/11/identityserver4-localization-using-ui_locales-and-the-query-string)
41 | * [在IdentityServer4服务中自行发布IdentityServer4令牌](https://www.strathweb.com/2017/10/self-issuing-an-identityserver4-token-in-an-identityserver4-service/)
42 | * [ASP.NET团队博客上的IdentityServer4](https://blogs.msdn.microsoft.com/webdev/2017/01/23/asp-net-core-authentication-with-identityserver4/)
43 | * [Angular2 OpenID使用IdentityServer4连接隐式流](https://damienbod.com/2016/03/02/angular2-openid-connect-implicit-flow-with-identityserver4/)
44 | * [使用IdentityServer4和OpenID连接隐式流的完整服务器注销](https://damienbod.com/2016/09/16/full-server-logout-with-identityserver4-and-openid-connect-implicit-flow/)
45 | * [单个项目中的IdentityServer4，ASP.NET标识，Web API和Angular](https://damienbod.com/2016/10/01/identityserver4-webapi-and-angular2-in-a-single-asp-net-core-project/)
46 | * [使用IdentityServer 4保护您的.NETCore Web应用程序](https://social.technet.microsoft.com/wiki/contents/articles/37169.secure-your-netcore-web-applications-using-identityserver-4.aspx)
47 | * [具有自定义UserRepository的ASP.NET Core IdentityServer4资源所有者密码流](https://damienbod.com/2017/04/14/asp-net-core-identityserver4-resource-owner-password-flow-with-custom-userrepository/)
48 | * [使用IdentityServer4 OpenID Connect Hybrid Flow使用Angular保护ASP.NET Core MVC](https://damienbod.com/2017/05/06/secure-asp-net-core-mvc-with-angular-using-identityserver4-openid-connect-hybrid-flow//)
49 | * [将外部Microsoft登录添加到IdentityServer4](https://damienbod.com/2017/07/11/adding-an-external-microsoft-login-to-identityserver4/)
50 | * [使用IdentityServer4和Twilio实现双因素身份验证](https://damienbod.com/2017/07/14/implementing-two-factor-authentication-with-identityserver4-and-twilio/)
51 | * [使用gRPC和ASP.NET Core 3.0进行安全性实验](https://damienbod.com/2019/03/06/security-experiments-with-grpc-and-asp-net-core-3-0/)
52 | * [具有IdentityServer4的ASP.NET Core OAuth设备流客户端](https://damienbod.com/2019/02/20/asp-net-core-oauth-device-flow-client-with-identityserver4/)
53 | * [使用OpenID Connect代码流与PKCE和IdentityServer4保护Vue.js应用程序](https://damienbod.com/2019/01/29/securing-a-vue-js-app-using-openid-connect-code-flow-with-pkce-and-identityserver4/)
54 | * [使用带有ASP.NET Core API的OData客户端](https://damienbod.com/2018/10/18/using-an-odata-client-with-an-asp-net-core-api/)
55 | * [OpenID使用Azure Redis缓存和IdentityServer4连接反向通道注销](https://damienbod.com/2018/12/18/openid-connect-back-channel-logout-using-azure-redis-cache-and-identityserver4/)
56 | * [具有反向信道注销的IdentityServer4中的单点注销](https://blog.tretainfotech.com/posts/2018/august/single-sign-out-in-identityserver4-with-back-channel-logout/)
57 | 


--------------------------------------------------------------------------------
/第二部分 快速入门/第15章 使用EntityFramework Core进行配置和操作数据.md:
--------------------------------------------------------------------------------
  1 | # 第15章 使用EntityFramework Core进行配置和操作数据
  2 | IdentityServer旨在实现可扩展性，其中一个可扩展点是用于IdentityServer所需数据的存储机制。本快速入门展示了如何配置IdentityServer以使用EntityFramework Core（EF）作为此数据的存储机制（而不是使用我们迄今为止使用的内存中实现）。   
  3 | 
  4 | > **注意**
  5 | 除了手动配置EF支持外，还有一个IdentityServer模板可用于创建具有EF支持的新项目。使用创建它。有关更多信息，请参见[此处](https://www.github.com/IdentityServer/IdentityServer4.Templates)`dotnet new is4ef`  
  6 | 
  7 | ## 15.1 IdentityServer4.EntityFramework 
  8 | 我们要移动到数据库有两种类型的数据：   
  9 | 
 10 | * 配置数据
 11 | * 运营数据   
 12 | 
 13 | 配置数据是有关资源和客户端的配置信息。操作数据是IdentityServer在使用时生成的信息，例如令牌，代码和同意。这些存储使用接口建模，我们在`IdentityServer4.EntityFramework.Storage` Nuget包中提供这些接口的EF实现。   
 14 | 
 15 | 注册我们的EF实现的扩展方法包含在IdentityServer4.EntityFramework Nuget包中（引用`IdentityServer4.EntityFramework.Storage`）。立即从IdentityServer项目添加对`IdentityServer4.EntityFramework` Nuget包的引用：   
 16 | 
 17 | ``` shell
 18 | cd quickstart/src/IdentityServer
 19 | dotnet add package IdentityServer4.EntityFramework
 20 | ```   
 21 | 
 22 | ## 15.2 使用的SqlServer 
 23 | 鉴于EF的灵活性，您可以使用任何EF支持的数据库。对于本快速入门，我们将使用Visual Studio附带的SQLD的LocalDb版本。   
 24 | 
 25 | ## 15.3 数据库架构更改和使用EF迁移
 26 | 该`IdentityServer4.EntityFramework.Storage`包中包含从IdentityServer的模型映射实体类。作为IdentityServer模型变化，所以会在实体类`IdentityServer4.EntityFramework.Storage`。当您使用`IdentityServer4.EntityFramework.Storage`并随着时间的推移升级时，您将负责自己的数据库架构以及实体类更改时该架构所需的更改。管理这些更改的一种方法是使用[EF迁移](https://docs.microsoft.com/en-us/ef/core/managing-schemas/migrations/index)，此快速入门将显示如何完成此操作。如果迁移不是您的首选项，那么您可以以任何您认为合适的方式管理架构更改。   
 27 | 
 28 | > **注意**
 29 | 为`IdentityServer4.EntityFramework.Storage`中的实体维护SqlServer的最新SQL脚本。他们就在[这里](https://github.com/IdentityServer/IdentityServer4.EntityFramework.Storage/tree/master/migrations/SqlServer/Migrations)。
 30 | 
 31 | ## 15.4 配置存储
 32 | 接下来的步骤是，以取代当前`AddInMemoryClients`，`AddInMemoryIdentityResources`和`AddInMemoryApiResources`在在*Startup.cs*方法`ConfigureServices`。我们将使用以下代码替换它们：   
 33 | 
 34 | ``` C#
 35 | const string connectionString = @"Data Source=(LocalDb)\MSSQLLocalDB;database=IdentityServer4.Quickstart.EntityFramework-2.0.0;trusted_connection=yes;";
 36 | var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name;
 37 | 
 38 | // configure identity server with in-memory stores, keys, clients and scopes
 39 | services.AddIdentityServer()
 40 |     .AddTestUsers(Config.GetUsers())
 41 |     // this adds the config data from DB (clients, resources)
 42 |     .AddConfigurationStore(options =>
 43 |     {
 44 |         options.ConfigureDbContext = b =>
 45 |             b.UseSqlServer(connectionString,
 46 |                 sql => sql.MigrationsAssembly(migrationsAssembly));
 47 |     })
 48 |     // this adds the operational data from DB (codes, tokens, consents)
 49 |     .AddOperationalStore(options =>
 50 |     {
 51 |         options.ConfigureDbContext = b =>
 52 |             b.UseSqlServer(connectionString,
 53 |                 sql => sql.MigrationsAssembly(migrationsAssembly));
 54 | 
 55 |         // this enables automatic token cleanup. this is optional.
 56 |         options.EnableTokenCleanup = true;
 57 |     });
 58 | ```   
 59 | 
 60 | 您可能需要将这些命名空间添加到文件中：   
 61 | 
 62 | ``` C#
 63 | using Microsoft.EntityFrameworkCore;
 64 | using System.Reflection;
 65 | ```   
 66 | 
 67 | 上面的代码是对连接字符串进行硬编码，如果您愿意，您可以随意更改。   
 68 | 
 69 | `AddConfigurationStore`和`AddOperationalStore`注册EF支持的存储实现。   
 70 | 
 71 | 在添加存储的调用内部，`ConfigureDbContext`属性的赋值注册委托以配置数据库提供程序`DbContextOptionsBuilder`。在这种情况下，我们调用`UseSqlServer`注册SQLServer。您也可以看出，这是使用连接字符串的位置。   
 72 | 
 73 | 最后，假设将使用EF迁移（至少对于此快速入门），调用将`MigrationsAssembly`用于通知EF将包含迁移代码的主机项目（这是必需的，因为它与包含`DbContext`类的程序集不同）。   
 74 | 
 75 | 我们接下来会添加迁移。   
 76 | 
 77 | ## 15.5 添加迁移
 78 | 要创建迁移，请在IdentityServer项目目录中打开命令提示符。在命令提示符下运行以下两个命令：   
 79 | 
 80 | ``` shell
 81 | dotnet ef migrations add InitialIdentityServerPersistedGrantDbMigration -c PersistedGrantDbContext -o Data/Migrations/IdentityServer/PersistedGrantDb
 82 | dotnet ef migrations add InitialIdentityServerConfigurationDbMigration -c ConfigurationDbContext -o Data/Migrations/IdentityServer/ConfigurationDb
 83 | ```   
 84 | 
 85 | 您现在应该在项目中看到~/Data/Migrations/IdentityServer文件夹。其中包含新创建的迁移的代码。   
 86 | 
 87 | ## 15.6 初始化数据库
 88 | 现在我们已经进行了迁移，我们可以编写代码来从迁移中创建数据库。我们还将使用我们在之前的快速入门中定义的内存配置数据来为数据库设定种子。   
 89 | 
 90 | > **注意**
 91 | 本快速入门中使用的方法用于简化IdentityServer的启动和运行。您应该设计适合您的体系结构的数据库创建和维护策略。   
 92 | 
 93 | 在*Startup.cs*中添加此方法以帮助初始化数据库：   
 94 | 
 95 | ``` C#
 96 | private void InitializeDatabase(IApplicationBuilder app)
 97 | {
 98 |     using (var serviceScope = app.ApplicationServices.GetService<IServiceScopeFactory>().CreateScope())
 99 |     {
100 |         serviceScope.ServiceProvider.GetRequiredService<PersistedGrantDbContext>().Database.Migrate();
101 | 
102 |         var context = serviceScope.ServiceProvider.GetRequiredService<ConfigurationDbContext>();
103 |         context.Database.Migrate();
104 |         if (!context.Clients.Any())
105 |         {
106 |             foreach (var client in Config.GetClients())
107 |             {
108 |                 context.Clients.Add(client.ToEntity());
109 |             }
110 |             context.SaveChanges();
111 |         }
112 | 
113 |         if (!context.IdentityResources.Any())
114 |         {
115 |             foreach (var resource in Config.GetIdentityResources())
116 |             {
117 |                 context.IdentityResources.Add(resource.ToEntity());
118 |             }
119 |             context.SaveChanges();
120 |         }
121 | 
122 |         if (!context.ApiResources.Any())
123 |         {
124 |             foreach (var resource in Config.GetApis())
125 |             {
126 |                 context.ApiResources.Add(resource.ToEntity());
127 |             }
128 |             context.SaveChanges();
129 |         }
130 |     }
131 | }
132 | ```   
133 | 
134 | 上面的代码可能需要将这些命名空间添加到您的文件中：   
135 | ``` C# 
136 | using System.Linq;
137 | using IdentityServer4.EntityFramework.DbContexts;
138 | using IdentityServer4.EntityFramework.Mappers;
139 | ```   
140 | 
141 | 然后我们可以从`Configure`方法中调用它：  
142 | 
143 | ``` C#
144 | public void Configure(IApplicationBuilder app)
145 | {
146 |     // this will do the initial DB population
147 |     InitializeDatabase(app);
148 | 
149 |     // the rest of the code that was already here
150 |     // ...
151 | }
152 | ```   
153 | 
154 | 现在，如果运行IdentityServer项目，则应创建数据库并使用快速入门配置数据进行种子设定。您应该能够使用SQL Server Management Studio或Visual Studio来连接和检查数据。   
155 | 
156 | <div align="center">
157 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/7_database.png">
158 | </div>   
159 | 
160 | > **注意**
161 | 上面的`InitializeDatabase`辅助API可以方便地为数据库设定种子，但是这种方法并不适合每次运行应用程序时执行。填充数据库后，请考虑删除对API的调用。   
162 | 
163 | ## 15.7 运行客户端应用程序
164 | 您现在应该能够运行任何现有的客户端应用程序并登录，获取令牌并调用API - 所有这些都基于数据库配置。   
165 | 
166 | > **注意**
167 | 本节中的代码仍然依赖于`Config.cs`及其虚构用户Alice和Bob。如果您的用户列表很简短且静态，则调整后的`Config.cs`版本可能就足够了，但您可能希望在数据库中动态管理更大且更流畅的用户列表。ASP.NET Identity是一个需要考虑的选项，下一节的快速入门列出了此解决方案的示例实现。


--------------------------------------------------------------------------------
/第二部分 快速入门/第16章 使用ASP.NET Core Identity.md:
--------------------------------------------------------------------------------
  1 | # 第16章 使用ASP\.NET Core Identity
  2 | 
  3 | > **注意**
  4 | 对于任何先决条件（例如模板），首先要查看概述。
  5 | 
  6 | IdentityServer旨在提供灵活性，其中一部分允许您为用户及其数据（包括账户密码）使用所需的任何数据库。如果您从新的用户数据库开始，那么ASP.NET Identity是您可以选择的一个选项。本快速入门显示了如何在IdentityServer中使用ASP.NET Identity。
  7 | 
  8 | 本快速入门使用ASP.NET Identity的方法是为IdentityServer Host创建一个新项目。这个新项目将取代我们在之前的快速入门中构建的先前IdentityServer项目。这个新项目的原因是由于使用ASP.NET身份时UI资产的差异（主要是登录和注销的差异）。此解决方案中的所有其他项目（针对客户端和API）将保持不变。
  9 | 
 10 | > **注意**
 11 | 本快速入门假设您熟悉ASP\.NET Identity的工作原理。如果不是，建议您先了解它。
 12 | 
 13 | ## 16.1 ASP\.NET身份的新项目
 14 | 第一步是为您的解决方案添加ASP.NET Identity的新项目。我们提供了一个模板，其中包含ASP.NET Identity与IdentityServer所需的最小UI资产。您最终将删除IdentityServer的旧项目，但是您需要迁移一些项目。   
 15 | 
 16 | 首先创建一个将使用ASP.NET Identity的新IdentityServer项目：   
 17 | ``` shell
 18 | cd quickstart/src
 19 | dotnet new is4aspid -n IdentityServerAspNetIdentity
 20 | ```   
 21 | 
 22 | 当提示“seed”用户数据库时，选择“Y”表示“是”。这将使用我们的“alice”和“bob”用户填充用户数据库。他们的密码是“Pass123$”。   
 23 | 
 24 | > **注意**
 25 | 该模板使用Sqlite作为用户的数据库，并在模板中预先创建EF迁移。如果您希望使用其他数据库提供程序，则需要更改代码中使用的提供程序并重新创建EF迁移。   
 26 | 
 27 | ## 16.2 检查新项目
 28 | 在您选择的编辑器中打开新项目，并检查生成的代码。一定要看看：
 29 | 
 30 | ### 16.2.1 IdentityServerAspNetIdentity.csproj 
 31 | 请注意对IdentityServer4.AspNetIdentity的引用。此NuGet包中包含IdentityServer的ASP.NET Identity集成组件。
 32 | 
 33 | ### 16.2.2 Startup.cs 
 34 | 在`ConfigureServices`中，注意必要的`AddDbContext<ApplicationDbContext>`和调用以配置ASP\.NET Identity。`AddIdentity<ApplicationUser, IdentityRole>`   
 35 | 
 36 | 另请注意，您在之前的快速入门中完成的大部分相同IdentityServer配置已经完成。模板使用内存中的样式用于客户端和资源，这些样式来自`Config.cs`。    
 37 | 
 38 | 最后，注意添加新的`AddAspNetIdentity<ApplicationUser>`。 `AddAspNetIdentity`添加集成层以允许IdentityServer访问ASP.NET Identity用户数据库的用户数据。当IdentityServer必须将用户的声明添加到令牌时，这是必需的。   
 39 | 
 40 | ### 16.2.3 Config.cs 
 41 | *Config.cs*包含硬编码的内存客户端和资源定义。为了使相同的客户端和API与之前的快速入门保持一致，我们需要将旧IdentityServer项目中的配置数据复制到此项目中。现在就这样做，然后*Config.cs*看起来像这样：   
 42 | 
 43 | ``` C#
 44 | public static class Config
 45 | {
 46 |     public static IEnumerable<IdentityResource> GetIdentityResources()
 47 |     {
 48 |         return new List<IdentityResource>
 49 |         {
 50 |             new IdentityResources.OpenId(),
 51 |             new IdentityResources.Profile(),
 52 |         };
 53 |     }
 54 | 
 55 |     public static IEnumerable<ApiResource> GetApis()
 56 |     {
 57 |         return new List<ApiResource>
 58 |         {
 59 |             new ApiResource("api1", "My API")
 60 |         };
 61 |     }
 62 | 
 63 |     public static IEnumerable<Client> GetClients()
 64 |     {
 65 |         return new List<Client>
 66 |         {
 67 |             new Client
 68 |             {
 69 |                 ClientId = "client",
 70 | 
 71 |                 // no interactive user, use the clientid/secret for authentication
 72 |                 AllowedGrantTypes = GrantTypes.ClientCredentials,
 73 | 
 74 |                 // secret for authentication
 75 |                 ClientSecrets =
 76 |                 {
 77 |                     new Secret("secret".Sha256())
 78 |                 },
 79 | 
 80 |                 // scopes that client has access to
 81 |                 AllowedScopes = { "api1" }
 82 |             },
 83 |             // resource owner password grant client
 84 |             new Client
 85 |             {
 86 |                 ClientId = "ro.client",
 87 |                 AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
 88 | 
 89 |                 ClientSecrets =
 90 |                 {
 91 |                     new Secret("secret".Sha256())
 92 |                 },
 93 |                 AllowedScopes = { "api1" }
 94 |             },
 95 |             // OpenID Connect hybrid flow client (MVC)
 96 |             new Client
 97 |             {
 98 |                 ClientId = "mvc",
 99 |                 ClientName = "MVC Client",
100 |                 AllowedGrantTypes = GrantTypes.Hybrid,
101 | 
102 |                 ClientSecrets =
103 |                 {
104 |                     new Secret("secret".Sha256())
105 |                 },
106 | 
107 |                 RedirectUris           = { "http://localhost:5002/signin-oidc" },
108 |                 PostLogoutRedirectUris = { "http://localhost:5002/signout-callback-oidc" },
109 | 
110 |                 AllowedScopes =
111 |                 {
112 |                     IdentityServerConstants.StandardScopes.OpenId,
113 |                     IdentityServerConstants.StandardScopes.Profile,
114 |                     "api1"
115 |                 },
116 | 
117 |                 AllowOfflineAccess = true
118 |             },
119 |             // JavaScript Client
120 |             new Client
121 |             {
122 |                 ClientId = "js",
123 |                 ClientName = "JavaScript Client",
124 |                 AllowedGrantTypes = GrantTypes.Code,
125 |                 RequirePkce = true,
126 |                 RequireClientSecret = false,
127 | 
128 |                 RedirectUris =           { "http://localhost:5003/callback.html" },
129 |                 PostLogoutRedirectUris = { "http://localhost:5003/index.html" },
130 |                 AllowedCorsOrigins =     { "http://localhost:5003" },
131 | 
132 |                 AllowedScopes =
133 |                 {
134 |                     IdentityServerConstants.StandardScopes.OpenId,
135 |                     IdentityServerConstants.StandardScopes.Profile,
136 |                     "api1"
137 |                 }
138 |             }
139 |         };
140 |     }
141 | }
142 | ```   
143 | 
144 | 此时，您不再需要旧的IdentityServer项目。   
145 | 
146 | ### 16.2.4 Program.cs文件和SeedData.cs 
147 | *Program.cs*中的`Main`比大多数ASP.NET Core项目略有不同。请注意这是如何查找名为/ seed的命令行参数，该参数用作为ASP.NET Identity数据库中的用户设定种子的标志。
148 | 
149 | 查看`SeedData`类的代码，了解如何创建数据库以及创建第一个用户。
150 | 
151 | ### 16.2.5 AccountController 
152 | 要在此模板中检查的最后一个代码是`AccountController`。这包含与之前的快速入门和模板略有不同的登录和注销代码。请注意使用ASP.NET Identity `SignInManager<ApplicationUser>`和`UserManager<ApplicationUser>`来自ASP.NET Identity来验证凭据和管理身份验证会话。   
153 | 
154 | 其余大部分代码与之前的快速入门和模板相同。   
155 | 
156 | ## 16.3 使用MVC客户端登录
157 | 此时，您应该运行所有现有客户端和模板。一个例外是*ResourceOwnerClient* -密码将需要更新，更新`password`为`Pass123$`。   
158 | 
159 | 启动MVC客户端应用程序，您应该能够单击“安全”链接以登录。   
160 | 
161 | <div align="center">
162 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/8_mvc_client.png">
163 | </div>   
164 | 
165 | 您应该被重定向到ASP\.NET Identity登录页面。使用新创建的用户登录：   
166 | 
167 | <div align="center">
168 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/8_login.png">
169 | </div>   
170 | 
171 | 登录后，您会看到正常的同意页面。获得同意后，您将被重定向回MVC客户端应用程序，其中应列出您的用户声明。   
172 | 
173 | <div align="center">
174 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/8_claims.png">
175 | </div>   
176 | 
177 | 您还应该能够单击“使用应用程序标识调用API”来代表用户调用API：   
178 | 
179 | <div align="center">
180 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/8_api_claims.png">
181 | </div>    
182 | 
183 | 现在，您正在使用IdentityServer中的ASP.NET身份用户。
184 | 
185 | ## 16.4 少了什么东西？
186 | 此模板中的大部分代码与我们提供的其他快速入门和模板类似。您将注意到此模板中缺少的一件事是用户注册，密码重置以及您可能期望从Visual Studio ASP.NET Identity模板中获得的其他内容的UI代码。   
187 | 
188 | 鉴于需求的多样性和使用ASP.NET Identity的不同方法，我们的模板明确地不提供这些功能。您应该知道ASP.NET Identity如何充分地将这些功能添加到项目中。或者，您可以基于Visual Studio ASP.NET Identity模板创建新项目，并将您在这些快速入门中了解到的IdentityServer功能添加到该项目中。
189 | 
190 | 


--------------------------------------------------------------------------------
/第三部分 主题/第22章 使用外部身份提供商登录.md:
--------------------------------------------------------------------------------
  1 | # 第22章 使用外部身份提供商登录
  2 | ASP\.NET Core有一种灵活的方式来处理外部身份验证。这涉及几个步骤。  
  3 | 
  4 | > **注意**
  5 | 如果您使用的是ASP\.NET Identity，则会隐藏许多基础技术细节。建议您还阅读Microsoft [文档](https://docs.microsoft.com/en-us/aspnet/core/security/authentication/social/)并执行ASP\.NET Identity [快速入门](https://github.com/thinksjay/IdentityServer4/blob/master/%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8/%E7%AC%AC16%E7%AB%A0%20%E4%BD%BF%E7%94%A8ASP.NET%20Core%20Identity.md)。
  6 | 
  7 | ## 22.1 为外部提供者添加身份验证处理程序
  8 | 与外部提供者通信所需的协议实现封装在身份验证处理程序中。一些提供商使用专有协议（例如Facebook等社交提供商），有些提供商使用标准协议，例如OpenID Connect，WS-Federation或SAML2p。
  9 | 
 10 | 有关添加外部身份验证和配置它的分步说明，请参阅此[快速入门](https://github.com/thinksjay/IdentityServer4/blob/master/%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8/%E7%AC%AC12%E7%AB%A0%20%E6%B7%BB%E5%8A%A0%E5%AF%B9%E5%A4%96%E9%83%A8%E8%AE%A4%E8%AF%81%E7%9A%84%E6%94%AF%E6%8C%81.md)。
 11 | 
 12 | ## 22.2 cookies的作用   
 13 | 调用外部身份验证处理程序的一个选项`SignInScheme`，例如：  
 14 | 
 15 | ``` C#
 16 | services.AddAuthentication()
 17 |     .AddGoogle("Google", options =>
 18 |     {
 19 |         options.SignInScheme = "scheme of cookie handler to use";
 20 | 
 21 |         options.ClientId = "...";
 22 |         options.ClientSecret = "...";
 23 |     })
 24 | ```   
 25 | 
 26 | 登录方案指定将临时存储外部认证结果的cookie处理程序的名称，例如由外部提供者发送的声明。这是必要的，因为在完成外部身份验证过程之前通常会涉及一些重定向。  
 27 | 
 28 | 鉴于这是一种常见做法，IdentityServer专门为此外部提供程序工作流注册cookie处理程序。该方案通过`IdentityServerConstants.ExternalCookieAuthenticationScheme`常数表示。如果您要使用我们的外部cookie处理程序，那么对于`SignInScheme`上面的内容，您将赋值为`IdentityServerConstants.ExternalCookieAuthenticationScheme`常量：   
 29 | 
 30 | ``` C#
 31 | services.AddAuthentication()
 32 |     .AddGoogle("Google", options =>
 33 |     {
 34 |         options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
 35 | 
 36 |         options.ClientId = "...";
 37 |         options.ClientSecret = "...";
 38 |     })
 39 | ```   
 40 | 
 41 | 您也可以注册自己的自定义cookie处理程序，如下所示：   
 42 | 
 43 | ``` C#
 44 | services.AddAuthentication()
 45 |     .AddCookie("YourCustomScheme")
 46 |     .AddGoogle("Google", options =>
 47 |     {
 48 |         options.SignInScheme = "YourCustomScheme";
 49 | 
 50 |         options.ClientId = "...";
 51 |         options.ClientSecret = "...";
 52 |     })
 53 | ```   
 54 | 
 55 | > **注意**
 56 | 对于特殊情况，您还可以将外部cookie机制短路并将外部用户直接转发到主cookie处理程序。这通常涉及处理外部处理程序上的事件，以确保您从外部标识源执行正确的声明转换。
 57 | 
 58 | ## 22.3 触发认证处理程序
 59 | 您可以通过（或使用MVC`ChallengeResult` ）`HttpContext`上的`ChallengeAsync`扩展方法调用外部认证处理程序。
 60 | 
 61 | 您通常希望将一些选项传递给挑战操作，例如回调页面的路径和簿记提供者的名称，例如：   
 62 | 
 63 | ``` C#
 64 | var callbackUrl = Url.Action("ExternalLoginCallback");
 65 | 
 66 | var props = new AuthenticationProperties
 67 | {
 68 |     RedirectUri = callbackUrl,
 69 |     Items =
 70 |     {
 71 |         { "scheme", provider },
 72 |         { "returnUrl", returnUrl }
 73 |     }
 74 | };
 75 | 
 76 | return Challenge(provider, props);
 77 | ```  
 78 | 
 79 | ## 22.4 处理回调并签署用户
 80 | 在回调页面上，您的典型任务是：   
 81 | 
 82 | * 检查外部提供商返回的身份。
 83 | * 决定如何处理该用户。如果这是新用户或返回用户，则可能会有所不同。
 84 | * 新用户在被允许之前可能需要额外的步骤和UI。
 85 | * 可能会创建一个链接到外部提供程序的新内部用户帐户。
 86 | * 存储您要保留的外部声明。
 87 | * 删除临时cookie
 88 | * 登录用户
 89 | 
 90 | ### 22.4.1 检查外部身份：
 91 | ``` C#
 92 | // read external identity from the temporary cookie
 93 | var result = await HttpContext.AuthenticateAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);
 94 | if (result?.Succeeded != true)
 95 | {
 96 |     throw new Exception("External authentication error");
 97 | }
 98 | 
 99 | // retrieve claims of the external user
100 | var externalUser = result.Principal;
101 | if (externalUser == null)
102 | {
103 |     throw new Exception("External authentication error");
104 | }
105 | 
106 | // retrieve claims of the external user
107 | var claims = externalUser.Claims.ToList();
108 | 
109 | // try to determine the unique id of the external user - the most common claim type for that are the sub claim and the NameIdentifier
110 | // depending on the external provider, some other claim type might be used
111 | var userIdClaim = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Subject);
112 | if (userIdClaim == null)
113 | {
114 |     userIdClaim = claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier);
115 | }
116 | if (userIdClaim == null)
117 | {
118 |     throw new Exception("Unknown userid");
119 | }
120 | 
121 | var externalUserId = userIdClaim.Value;
122 | var externalProvider = userIdClaim.Issuer;
123 | 
124 | // use externalProvider and externalUserId to find your user, or provision a new user
125 | ```
126 | 
127 | ### 22.4.2 清理和登录：
128 | 
129 | ``` C#
130 | // issue authentication cookie for user
131 | await HttpContext.SignInAsync(user.SubjectId, user.Username, provider, props, additionalClaims.ToArray());
132 | 
133 | // delete temporary cookie used during external authentication
134 | await HttpContext.SignOutAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);
135 | 
136 | // validate return URL and redirect back to authorization endpoint or a local page
137 | if (_interaction.IsValidReturnUrl(returnUrl) || Url.IsLocalUrl(returnUrl))
138 | {
139 |     return Redirect(returnUrl);
140 | }
141 | 
142 | return Redirect("~/");
143 | ```   
144 | 
145 | ## 22.5 状态，URL长度和ISecureDataFormat 
146 | 重定向到外部提供程序进行登录时，必须经常从客户端应用程序进行往返状态。这意味着在离开客户端之前捕获状态并保留状态，直到用户返回到客户端应用程序。许多协议（包括OpenID Connect）允许将某种状态作为参数传递作为请求的一部分，并且身份提供者将在响应上返回该状态。ASP\.NET Core提供的OpenID Connect身份验证处理程序利用协议的这一功能，即它实现上述`returnUrl`功能的方式。  
147 | 
148 | 在请求参数中存储状态的问题是请求URL可能变得太大（超过2000个字符的公共限制）。OpenID Connect身份验证处理程序确实提供了一个可扩展点，用于在服务器中而不是在请求URL中存储状态。您可以通过`ISecureDataFormat<AuthenticationProperties>`在[OpenIdConnectOptions](https://github.com/aspnet/AspNetCore/blob/master/src/Security/Authentication/OpenIdConnect/src/OpenIdConnectOptions.cs#L249)上实现和配置它来自行实现。  
149 | 
150 | 幸运的是，IdentityServer为您提供了一个实现，由`IDistributedCache` DI容器中注册的实现（例如标准`MemoryDistributedCache`）支持。要使用IdentityServer提供的安全数据格式实现，只需在配置DI时调用`IServiceCollection`扩展`AddOidcStateDataFormatterCache`方法。如果未传递任何参数，则配置的所有OpenID Connect处理程序将使用IdentityServer提供的安全数据格式实现：   
151 | ``` C#
152 | public void ConfigureServices(IServiceCollection services)
153 | {
154 |     // configures the OpenIdConnect handlers to persist the state parameter into the server-side IDistributedCache.
155 |     services.AddOidcStateDataFormatterCache();
156 | 
157 |     services.AddAuthentication()
158 |         .AddOpenIdConnect("demoidsrv", "IdentityServer", options =>
159 |         {
160 |             // ...
161 |         })
162 |         .AddOpenIdConnect("aad", "Azure AD", options =>
163 |         {
164 |             // ...
165 |         })
166 |         .AddOpenIdConnect("adfs", "ADFS", options =>
167 |         {
168 |             // ...
169 |         });
170 | }
171 | ```   
172 | 
173 | 如果只配置特定方案，则将这些方案作为参数传递：
174 | ``` C#
175 | public void ConfigureServices(IServiceCollection services)
176 | {
177 |     // configures the OpenIdConnect handlers to persist the state parameter into the server-side IDistributedCache.
178 |     services.AddOidcStateDataFormatterCache("aad", "demoidsrv");
179 | 
180 |     services.AddAuthentication()
181 |         .AddOpenIdConnect("demoidsrv", "IdentityServer", options =>
182 |         {
183 |             // ...
184 |         })
185 |         .AddOpenIdConnect("aad", "Azure AD", options =>
186 |         {
187 |             // ...
188 |         })
189 |         .AddOpenIdConnect("adfs", "ADFS", options =>
190 |         {
191 |             // ...
192 |         });
193 | }
194 | ```
195 | 


--------------------------------------------------------------------------------
/第二部分 快速入门/第11章 使用OpenID Connect添加用户身份验证.md:
--------------------------------------------------------------------------------
  1 | # 第11章 使用OpenID Connect添加用户身份验证
  2 | 
  3 | 在本快速入门中，我们希望通过**OpenID Connect**协议向我们的IdentityServer添加对交互式用户身份验证的支持。   
  4 | 
  5 | 一旦到位，我们将创建一个将使用IdentityServer进行身份验证的MVC应用程序。   
  6 | 
  7 | ## 11.1 添加
  8 | IdentityServer 内置了 OpenID Connect 需要的所有协议支持。你需要提供必需的 UI 部分，包括 登录、注销、授权确认以及错误页。   
  9 | 
 10 | 因为在每个 IdentityServer 的实现中，视觉、感觉以及实际工作流可能总是有所不同的，所以我们提供了一套基于 MVC 的样例 UI，你可以将其作为启动点来使用。   
 11 | 
 12 | 这套 UI 可以在 快速入门仓库 找到。你还可以克隆或下载这个仓库，将其中的控制器、视图、模型以及 CSS 放到你的 Web 应用程序中。
 13 | 
 14 | 或者，您可以使用.NET CLI（从src/IdentityServer文件夹中运行）：
 15 | ``` shell
 16 | dotnet new is4ui
 17 | ```   
 18 | 
 19 | 添加MVC UI后，您还需要在DI系统和管道中启用MVC。当您查看时，*Startup.cs`\*您将在`ConfigureServices`和`Configure`方法中找到注释，告诉您如何启用MVC。
 20 | 
 21 | 运行IdentityServer应用程序，您现在应该看到一个主页。
 22 | 
 23 | 花一些时间检查控制器和模型，您越了解它们，就越容易进行未来的修改。大多数代码使用“feature folder”样式存在于“Quickstart”文件夹中。如果此样式不适合您，请随意以您想要的任何方式组织代码。
 24 | 
 25 | ## 11.2 创建MVC客户端
 26 | 接下来，您将向您的解决方案添加MVC应用程序。使用ASP.NET Core“Web应用程序”（即MVC）模板。不要在向导中配置“身份验证”设置 - 您将在此快速入门中手动执行此操作。创建项目后，将应用程序配置为在端口5002上运行。   
 27 | 
 28 | 要为OpenID Connect的认证支持添加到MVC应用程序，添加以下内容到`Startup`中`ConfigureServices`：   
 29 | 
 30 | ``` C#
 31 | public void ConfigureServices(IServiceCollection services)
 32 | {
 33 |     services.AddMvc();
 34 | 
 35 |     JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
 36 | 
 37 |     services.AddAuthentication(options =>
 38 |         {
 39 |             options.DefaultScheme = "Cookies";
 40 |             options.DefaultChallengeScheme = "oidc";
 41 |         })
 42 |         .AddCookie("Cookies")
 43 |         .AddOpenIdConnect("oidc", options =>
 44 |         {
 45 |             options.Authority = "http://localhost:5000";
 46 |             options.RequireHttpsMetadata = false;
 47 | 
 48 |             options.ClientId = "mvc";
 49 |             options.SaveTokens = true;
 50 |         });
 51 | }
 52 | ```  
 53 | 
 54 | `AddAuthentication`将身份验证服务添加到DI。我们使用`cookie`来本地登录用户（通过`"Cookies"`作为`DefaultScheme`），我们设置为`DefaultChallengeScheme`为`"oidc"`因为当我们需要用户登录时，我们将使用OpenID Connect协议。   
 55 | 
 56 | 然后`AddCookie`，我们使用添加可处理`cookie`的处理程序。   
 57 | 
 58 | 最后，`AddOpenIdConnect`用于配置执行OpenID Connect协议的处理程序。`Authority`表明我们信任IdentityServer。然后我们通过`ClientId`。识别这个客户。 `SaveTokens`用于在cookie中保留来自IdentityServer的令牌（稍后将需要它们）。   
 59 | 
 60 | 同样，我们已经关闭了JWT声明类型映射，以允许众所周知的声明（例如'sub'和'idp'）流畅地通过：   
 61 | 
 62 | ``` C#
 63 | JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
 64 | ```   
 65 | 
 66 | 然后要确保认证服务执行对每个请求，加入`UseAuthentication`到`Startup`中`Configure`：   
 67 | ``` C#
 68 | public void Configure(IApplicationBuilder app, IHostingEnvironment env)
 69 | {
 70 |     if (env.IsDevelopment())
 71 |     {
 72 |         app.UseDeveloperExceptionPage();
 73 |     }
 74 |     else
 75 |     {
 76 |         app.UseExceptionHandler("/Home/Error");
 77 |     }
 78 | 
 79 |     app.UseAuthentication();
 80 | 
 81 |     app.UseStaticFiles();
 82 |     app.UseMvcWithDefaultRoute();
 83 | }
 84 | ```   
 85 | 
 86 | 应在管道中的MVC之前添加认证中间件。   
 87 | 
 88 | 最后一步是触发身份验证握手。为此，请转到主控制器并添加`[Authorize]`其中一个操作。还要修改主视图以显示用户的声明以及cookie属性：   
 89 | 
 90 | ``` C# 
 91 | @using Microsoft.AspNetCore.Authentication
 92 | 
 93 | <h2>Claims</h2>
 94 | 
 95 | <dl>
 96 |     @foreach (var claim in User.Claims)
 97 |     {
 98 |         <dt>@claim.Type</dt>
 99 |         <dd>@claim.Value</dd>
100 |     }
101 | </dl>
102 | 
103 | <h2>Properties</h2>
104 | 
105 | <dl>
106 |     @foreach (var prop in (await Context.AuthenticateAsync()).Properties.Items)
107 |     {
108 |         <dt>@prop.Key</dt>
109 |         <dd>@prop.Value</dd>
110 |     }
111 | </dl>
112 | ```   
113 | 
114 | 如果您现在使用浏览器导航到该控制器，将尝试重定向到IdentityServer - 这将导致错误，因为MVC客户端尚未注册。
115 | 
116 | ## 11.3 添加对OpenID Connect标识范围的支持
117 | 与OAuth 2.0类似，OpenID Connect也使用范围(Scope)概念。同样，范围代表您想要保护的内容以及客户想要访问的内容。与OAuth相比，OIDC中的范围不代表API，而是代表用户ID，名称或电子邮件地址等身份数据。   
118 | 
119 | 通过修改方法，添加对标准`openid`（subject id）和`profile`（名字，姓氏等）范围(Scope)的支持：*Config.cs*中`GetIdentityResources`   
120 | 
121 | ``` C#
122 | public static IEnumerable<IdentityResource> GetIdentityResources()
123 | {
124 |     return new List<IdentityResource>
125 |     {
126 |         new IdentityResources.OpenId(),
127 |         new IdentityResources.Profile(),
128 |     };
129 | }
130 | ```
131 | 
132 | > **注意**
133 | 所有标准范围及其相应的声明都可以在OpenID Connect 规范中找到   
134 | 
135 | ## 11.4 为OpenID Connect隐式流添加客户端
136 | 最后一步是将MVC客户端的新配置条目添加到IdentityServer。   
137 | 
138 | 基于OpenID Connect的客户端与我们目前添加的OAuth 2.0客户端非常相似。但由于OIDC中的流程始终是交互式的，因此我们需要在配置中添加一些重定向URL。   
139 | 
140 | 将以下内容添加到客户端配置中：   
141 | 
142 | ``` C#
143 | public static IEnumerable<Client> GetClients()
144 | {
145 |     return new List<Client>
146 |     {
147 |         // other clients omitted...
148 | 
149 |         // OpenID Connect implicit flow client (MVC)
150 |         new Client
151 |         {
152 |             ClientId = "mvc",
153 |             ClientName = "MVC Client",
154 |             AllowedGrantTypes = GrantTypes.Implicit,
155 | 
156 |             // where to redirect to after login
157 |             RedirectUris = { "http://localhost:5002/signin-oidc" },
158 | 
159 |             // where to redirect to after logout
160 |             PostLogoutRedirectUris = { "http://localhost:5002/signout-callback-oidc" },
161 | 
162 |             AllowedScopes = new List<string>
163 |             {
164 |                 IdentityServerConstants.StandardScopes.OpenId,
165 |                 IdentityServerConstants.StandardScopes.Profile
166 |             }
167 |         }
168 |     };
169 | }
170 | ```
171 | 
172 | ## 11.5 测试客户端
173 | 现在终于应该为新的MVC客户端做好一切准备。   
174 | 
175 | 通过导航到受保护的控制器操作来触发身份验证握手。您应该会看到重定向到IdentityServer的登录页面。   
176 | 
177 | <div algin="center">
178 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/3_login.png">
179 | </div>   
180 | 
181 | 登录成功后，用户将在授权确认页中被呈现出来。在这里用户可以决定他是否想要发布他的身份信息给客户端应用程序。      
182 | 
183 | > **注意**
184 | 授权确认页可以通过客户端定义对象的`RequireConsent`属性被关闭（以每个客户端为单位）。   
185 | 
186 | <div algin="center">
187 | <image src="https://images2017.cnblogs.com/blog/585526/201708/585526-20170808013221674-147202649.png">
188 | </div>   
189 | 
190 | 之后，IdentityServer将重定向回MVC客户端，其中OpenID Connect身份验证处理程序处理响应并通过设置cookie在本地登录用户。最后，MVC视图将显示cookie的内容。   
191 |    
192 | <div algin="center">
193 | <image src="https://images2017.cnblogs.com/blog/585526/201708/585526-20170808013235565-1458521422.png">
194 | </div>   
195 | 
196 | 如您所见，cookie包含两部分，即用户的声明和一些元数据。此元数据还包含IdentityServer发出的原始令牌。随意将此令牌复制到<https://jwt.io>以检查其内容。   
197 | 
198 | ## 11.6 添加注销
199 | 最后一步是向MVC客户端添加注销。   
200 | 
201 | 使用IdentityServer等身份验证服务，仅清除本地应用程序cookie是不够的。此外，您还需要向IdentityServer进行往返以清除中央单点登录会话。   
202 | 
203 | 确切的协议步骤在OpenID Connect处理程序中实现，只需将以下代码添加到某个控制器即可触发注销：   
204 | 
205 | ``` C#
206 | public IActionResult Logout()
207 | {
208 |     return SignOut("Cookies", "oidc");
209 | }
210 | ```   
211 | 
212 | 这将清除本地cookie，然后重定向到IdentityServer。IdentityServer将清除其cookie，然后为用户提供返回MVC应用程序的链接。   
213 | 
214 | ## 11.7 进一步的实验
215 | 如上所述，OpenID Connect处理程序默认要求配置文件范围。此范围还包括名称或网站等声明。    
216 | 
217 | 让我们将这些声明添加到用户，以便IdentityServer可以将它们放入身份标记：    
218 | 
219 | ``` C#
220 | public static List<TestUser> GetUsers()
221 | {
222 |     return new List<TestUser>
223 |     {
224 |         new TestUser
225 |         {
226 |             SubjectId = "1",
227 |             Username = "alice",
228 |             Password = "password",
229 | 
230 |             Claims = new []
231 |             {
232 |                 new Claim("name", "Alice"),
233 |                 new Claim("website", "https://alice.com")
234 |             }
235 |         },
236 |         new TestUser
237 |         {
238 |             SubjectId = "2",
239 |             Username = "bob",
240 |             Password = "password",
241 | 
242 |             Claims = new []
243 |             {
244 |                 new Claim("name", "Bob"),
245 |                 new Claim("website", "https://bob.com")
246 |             }
247 |         }
248 |     };
249 | }
250 | ```    
251 | 
252 | 下次进行身份验证时，您的声明页面现在会显示其他声明。     
253 | 
254 | 请随意添加更多的身份信息 - 还有更多的scopes。OpenID Connect中间件上的`Scope`属性是你用来配置哪些Scopes将在认证期间被发送到IdentityServer的地方。
255 | 
256 | 值得注意的是，对令牌中身份信息的遍历是一个扩展点 - `IProfileService`。因为我们正在使用`AddTestUser`，所以默认使用的是`TestUserProfileService`。你可以检出这里的源代码来查看它的工作原理。


--------------------------------------------------------------------------------
/第二部分 快速入门/第09章 使用客户端凭据保护API.md:
--------------------------------------------------------------------------------
  1 | # 第09章 使用客户端凭据保护API
  2 | 
  3 | 快速入门介绍了使用IdentityServer保护API的最基本方案。 我们将定义一个API和一个想要访问它的客户端。 客户端将通过提供`ClientCredentials`在IdentityServer请求访问令牌，`ClientCredentials`充当客户端和IdentityServer都知道的秘密，并且它将使用该令牌来访问API。   
  4 | 
  5 | ## 9.1设置ASP.NET核心应用程序
  6 | 首先为应用程序创建一个目录 - 然后使用我们的模板创建一个包含基本IdentityServer设置的ASP\.NET Core应用程序，例如：   
  7 | 
  8 | ``` shell
  9 | md quickstart
 10 | cd quickstart
 11 | 
 12 | md src
 13 | cd src
 14 | 
 15 | dotnet new is4empty -n IdentityServer
 16 | ```   
 17 | 
 18 | 这将创建以下文件：   
 19 | 
 20 | * *IdentityServer.csproj*- 项目文件和*Properties\launchSettings.json*文件
 21 | * *Program.cs*和*Startup.cs*- 主要的应用程序入口点
 22 | * *Config.cs* - IdentityServer资源和客户端配置文件   
 23 | 
 24 | 您现在可以使用自己喜欢的文本编辑器来编辑或查看文件。如果您希望获得Visual Studio支持，可以添加如下解决方案文件：   
 25 | 
 26 | ``` shell
 27 | cd ..
 28 | dotnet new sln -n Quickstart
 29 | ```   
 30 | 
 31 | 然后让它添加你的IdentityServer项目（记住这个命令，因为我们将在下面创建其他项目）：   
 32 | 
 33 | ``` shell
 34 | dotnet sln add .\src\IdentityServer\IdentityServer.csproj
 35 | ```
 36 | 
 37 | > **注意**   
 38 |  此模板中使用的协议是`http`，当在`Kestrel`上运行时，端口设置为`5000`或`IISExpress`上的随机端口。您可以在`Properties\launchSettings.json`文件中更改它。但是，所有快速入门指令都假定您使用`Kestrel`上的默认端口以及`http`协议，该协议足以进行本地开发。   
 39 | 
 40 | ## 9.2 定义API资源
 41 | API是您要保护的系统中的资源。   
 42 | 
 43 | 资源定义可以通过多种方式加载，模板使用“代码作为配置”appproach。在[Config.cs](https://github.com/IdentityServer/IdentityServer4.Samples/blob/master/Quickstarts/1_ClientCredentials/src/IdentityServer/Config.cs)文件中，您可以找到一个名为GetApisAPI 的方法，如下所示：
 44 | ``` C#
 45 | public static IEnumerable<ApiResource> GetApis()
 46 | {
 47 |     return new List<ApiResource>
 48 |     {
 49 |         new ApiResource("api1", "My API")
 50 |     };
 51 | }
 52 | ```
 53 | ## 9.3 定义客户端
 54 | 下一步是定义可以访问此API的客户端。   
 55 | 
 56 | 对于此方案，客户端将不具有交互式用户，并将使用IdentityServer的所谓客户端密钥进行身份验证。将以下代码添加到[Config.cs](https://github.com/IdentityServer/IdentityServer4.Samples/blob/master/Quickstarts/1_ClientCredentials/src/IdentityServer/Config.cs)文件中：   
 57 | 
 58 | ``` C#
 59 | public static IEnumerable<Client> GetClients()
 60 | {
 61 |     return new List<Client>
 62 |     {
 63 |         new Client
 64 |         {
 65 |             ClientId = "client",
 66 | 
 67 |             // no interactive user, use the clientid/secret for authentication
 68 |             AllowedGrantTypes = GrantTypes.ClientCredentials,
 69 | 
 70 |             // secret for authentication
 71 |             ClientSecrets =
 72 |             {
 73 |                 new Secret("secret".Sha256())
 74 |             },
 75 | 
 76 |             // scopes that client has access to
 77 |             AllowedScopes = { "api1" }
 78 |         }
 79 |     };
 80 | }
 81 | ```   
 82 | 
 83 | ## 9.4 配置IdentityServer 
 84 | 在`Startup.cs`加载资源和客户端定义 - 模板已经为您执行此操作：   
 85 | 
 86 | ``` C#
 87 | public void ConfigureServices(IServiceCollection services)
 88 | {
 89 |     var builder = services.AddIdentityServer()
 90 |         .AddInMemoryIdentityResources(Config.GetIdentityResources())
 91 |         .AddInMemoryApiResources(Config.GetApis())
 92 |         .AddInMemoryClients(Config.GetClients());
 93 | 
 94 |     // rest omitted
 95 | }
 96 | ```   
 97 | 
 98 | 就是这样 - 如果您运行服务器并浏览浏览器 `http://localhost:5000/.well-known/openid-configuration`，您应该会看到所谓的**发现文档**。客户端和API将使用它来下载必要的配置数据。  
 99 | <div align="center">
100 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/1_discovery.png">
101 | </div>   
102 | 
103 | 首次启动时，IdentityServer将为您创建一个开发人员签名密钥，它是一个名为的文件`tempkey.rsa`。您不必将该文件检入源代码管理中，如果该文件不存在，将重新创建该文件。   
104 | 
105 | ## 9.5 添加API
106 | 接下来，为您的解决方案添加API。
107 | 
108 | 您可以使用Visual Studio中的ASP.NET Core Web API（或空）模板，也可以使用.NET CLI来创建API项目。从`src`文件夹中运行以下命令：   
109 | 
110 | ``` shell
111 | dotnet new web -n Api
112 | ```   
113 | 
114 | 然后通过运行以下命令将其添加到解决方案中：   
115 | 
116 | ``` shell
117 | cd ..
118 | dotnet sln add .\src\Api\Api.csproj
119 | ```   
120 | 
121 | 将API应用程序配置为`http://localhost:5001`仅运行。您可以通过编辑Properties文件夹中的`launchSettings.json`文件来完成此操作。将应用程序URL设置更改为：   
122 | 
123 | ``` json
124 | "applicationUrl": "http://localhost:5001"
125 | ```   
126 | 
127 | ## 9.6 控制器
128 | 在API项目中添加一个新文件夹Controllers和一个新控制器`IdentityController`：   
129 | 
130 | ``` C#
131 | [Route("identity")]
132 | [Authorize]
133 | public class IdentityController : ControllerBase
134 | {
135 |     [HttpGet]
136 |     public IActionResult Get()
137 |     {
138 |         return new JsonResult(from c in User.Claims select new { c.Type, c.Value });
139 |     }
140 | }
141 | ```   
142 | 
143 | 这个控制器将在后面被用于测试授权需求，同时通过API的眼睛（浏览工具）来可视化身份信息。
144 | 
145 | ## 9.7 配置
146 | 最后一步是将身份验证服务添加到DI和身份验证中间件到管道。这些将：  
147 | 
148 | * 验证输入的令牌以确保它来自可信任的发布者（IdentityServer）
149 | * 验证令牌是否可用于该 api（也就是 Scope）。   
150 | 
151 | 将`Startup`更新为如下所示：
152 | 
153 | ``` C#
154 | public class Startup
155 | {
156 |     public void ConfigureServices(IServiceCollection services)
157 |     {
158 |         services.AddMvcCore()
159 |             .AddAuthorization()
160 |             .AddJsonFormatters();
161 | 
162 |         services.AddAuthentication("Bearer")
163 |             .AddJwtBearer("Bearer", options =>
164 |             {
165 |                 options.Authority = "http://localhost:5000";
166 |                 options.RequireHttpsMetadata = false;
167 | 
168 |                 options.Audience = "api1";
169 |             });
170 |     }
171 | 
172 |     public void Configure(IApplicationBuilder app)
173 |     {
174 |         app.UseAuthentication();
175 | 
176 |         app.UseMvc();
177 |     }
178 | }
179 | ```   
180 | 
181 | `AddAuthentication`将身份验证服务添加到DI并配置`"Bearer"`为默认方案。 `UseAuthentication`将身份验证中间件添加到管道中，以便在每次调用主机时自动执行身份验证。   
182 | 
183 | `http://localhost:5001/identity`在浏览器上导航到控制器应返回401状态代码。这意味着您的API需要凭证，现在受IdentityServer保护。   
184 | 
185 | ## 9.8 创建客户端
186 | 最后一步是编写请求访问令牌的客户端，然后使用此令牌访问API。为此，在您的解决方案中添加一个控制台项目，请记住在以下位置创建它src：   
187 | 
188 | ``` shell
189 | dotnet new console -n Client
190 | ```   
191 | 
192 | 然后和以前一样，使用以下方法将其添加到您的解   
193 | 
194 | ``` shell
195 | cd ..
196 | dotnet sln add .\src\Client\Client.csproj
197 | ```   
198 | 
199 | 打开*Program.cs*并将内容从这里复制到它。   
200 | 
201 | 客户端程序异步调用`Main`方法以运行异步`http`调用。 从`C#7.1`开始，此功能可用，一旦您编辑*Client.csproj*以将以下行添加为`PropertyGroup`，它就可用：   
202 | 
203 | ``` xml
204 | <LangVersion>latest</LangVersion>
205 | ```   
206 | 
207 | IdentityServer的令牌端点实现**OAuth 2.0**协议，您可以使用原始HTTP来访问它。但是，我们有一个名为`IdentityModel`的客户端库，它将协议交互封装在易于使用的API中。   
208 | 
209 | 将`IdentityModel` NuGet包添加到您的客户端。这可以通过Visual Studio的nuget对话框，手动添加到*Client.csproj*文件，或使用CLI来完成：   
210 | 
211 | ``` shell
212 | dotnet add package IdentityModel
213 | ```   
214 | 
215 | IdentityModel包括用于发现端点的客户端库。这样您只需要知道IdentityServer的基地址 - 可以从元数据中读取实际的端点地址：   
216 | 
217 | ``` C#
218 | // discover endpoints from metadata
219 | var client = new HttpClient();
220 | var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
221 | if (disco.IsError)
222 | {
223 |     Console.WriteLine(disco.Error);
224 |     return;
225 | }
226 | ```   
227 | 
228 | 接下来，您可以使用**发现文档**中的信息向IdentityServer请求令牌以访问api1：   
229 | 
230 | ``` C#
231 | // request token
232 | var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
233 | {
234 |     Address = disco.TokenEndpoint,
235 | 
236 |     ClientId = "client",
237 |     ClientSecret = "secret",
238 |     Scope = "api1"
239 | });
240 | 
241 | if (tokenResponse.IsError)
242 | {
243 |     Console.WriteLine(tokenResponse.Error);
244 |     return;
245 | }
246 | 
247 | Console.WriteLine(tokenResponse.Json);
248 | ```   
249 | 
250 | > **注意**
251 | 将访问令牌从控制台复制并粘贴到<https://jwt.io/>以检查原始令牌。
252 | 
253 | ## 9.9 调用
254 | 要将访问令牌发送到API，通常使用HTTP `Authorization`标头。这是使用`SetBearerToken`扩展方法完成的：   
255 | 
256 | ``` C#
257 | // call api
258 | var client = new HttpClient();
259 | client.SetBearerToken(tokenResponse.AccessToken);
260 | 
261 | var response = await client.GetAsync("http://localhost:5001/identity");
262 | if (!response.IsSuccessStatusCode)
263 | {
264 |     Console.WriteLine(response.StatusCode);
265 | }
266 | else
267 | {
268 |     var content = await response.Content.ReadAsStringAsync();
269 |     Console.WriteLine(JArray.Parse(content));
270 | }
271 | ```   
272 | 
273 | 输出应如下所示：
274 | 
275 | <div align="center">
276 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/1_client_screenshot.png">
277 | </div>   
278 | 
279 | > **注意**
280 | 默认情况下，访问令牌将包含有关范围(scope)，生命周期（nbf和exp），客户端ID（client_id）和颁发者名称（iss）的声明。   
281 | 
282 | ## 9.10 进一步的实验
283 | 本演练重点介绍了迄今为止的成功之路   
284 | 
285 | * 客户端能够请求令牌
286 | * 客户端可以使用令牌来访问API   
287 | 
288 | 你现在可以尝试引发一些错误来学习系统的相关行为，比如：   
289 | 
290 | * 尝试在未运行时连接到IdentityServer（不可用）
291 | * 尝试使用无效的客户端ID或密码来请求令牌
292 | * 尝试在令牌请求期间请求无效范围
293 | * 尝试在API未运行时调用API（不可用）
294 | * 不要将令牌发送到API
295 | * 将API配置为需要与令牌中的范围不同的范围
296 | 


--------------------------------------------------------------------------------
/第二部分 快速入门/第14章 添加JavaScript客户端.md:
--------------------------------------------------------------------------------
  1 | # 第14章 添加JavaScript客户端
  2 | 本快速入门将展示如何构建基于浏览器的JavaScript客户端应用程序（有时称为“ SPA ”）。   
  3 | 
  4 | 用户将登录IdentityServer，使用IdentityServer发出的访问令牌调用We​​b API，并注销IdentityServer。所有这些都将来自浏览器中运行的JavaScript。   
  5 | 
  6 | ## 14.1 JavaScript客户端的新项目
  7 | 为JavaScript应用程序创建一个新项目。它可以只是一个空的Web项目，一个空的ASP.NET Core应用程序，或者像Node.js应用程序。本快速入门将使用ASP.NET Core应用程序。   
  8 | 
  9 | 在~/src目录中创建一个新的“空”ASP.NET Core Web应用程序。您可以使用Visual Studio或从命令行执行此操作：   
 10 | ``` shell
 11 | md JavaScriptClient
 12 | cd JavaScriptClient
 13 | dotnet new web
 14 | ```   
 15 | 
 16 | ## 14.2 修改宿主
 17 | 修改JavaScriptClient项目以在端口5003上运行。   
 18 | 
 19 | ## 14.3 添加静态文件中间件
 20 | 鉴于该项目旨在运行客户端，我们所需要的只是ASP.NET Core提供构成我们应用程序的静态HTML和JavaScript文件。静态文件中间件旨在实现此目的。   
 21 | 
 22 | 在`Startup.cs`中的`Configure`方法注册静态文件中间件（同时删除其他所有内容）：   
 23 | 
 24 | ``` C#
 25 | public void Configure(IApplicationBuilder app)
 26 | {
 27 |     app.UseDefaultFiles();
 28 |     app.UseStaticFiles();
 29 | }
 30 | ```   
 31 | 
 32 | 此中间件现在将从应用程序的~/wwwroot文件夹中提供静态文件。这是我们将放置HTML和JavaScript文件的地方。如果项目中不存在该文件夹，请立即创建。
 33 | 
 34 | ## 14.4 引用OIDC客户端
 35 | 在基于ASP\.NET Core MVC的客户端项目的前一个快速入门中，我们使用库来处理OpenID Connect协议。在JavaScriptClient项目的快速入门中，我们需要一个类似的库，除了一个在JavaScript中运行并且设计为在浏览器中运行的库。[oidc-client库](https://github.com/IdentityModel/oidc-client-js)就是这样一个库，可以通过[NPM](https://github.com/IdentityModel/oidc-client-js)，[Bower](https://bower.io/search/?q=oidc-client)等获取到该库，还可以直接从[github](https://github.com/IdentityModel/oidc-client-js/tree/release/dist)下载该库。   
 36 | 
 37 | ### 14.4.1 NPM
 38 | 如果要使用NPM下载oidc-client，请从JavaScriptClient项目目录运行以下命令：  
 39 | 
 40 | ``` shell
 41 | npm i oidc-client
 42 | copy node_modules\oidc-client\dist\* wwwroot
 43 | ```   
 44 | 
 45 | 这将在本地下载最新的oidc-client软件包，然后将相关的JavaScript文件复制到~/wwwroot中，以便它们可以由您的应用程序提供。   
 46 | 
 47 | ### 14.4.2 手动下载
 48 | 如果您只想手动下载oidc-client JavaScript文件，请浏览到[GitHub](https://github.com/IdentityModel/oidc-client-js/tree/master/dist)存储库 并下载JavaScript文件。下载后，将它们复制到~/wwwroot中，以便它们可以提供给您的应用程序。   
 49 | 
 50 | ## 14.5 添加HTML和JavaScript文件
 51 | 接下来是将您的HTML和JavaScript文件添加到~/ wwwroot。我们将有两个HTML文件和一个特定于应用程序的JavaScript文件（除了*oidc-client.js*库）。在~/wwwroot中，添加一个名为*index.html*和*callback.html*的HTML文件，并添加一个名为*app.js*的JavaScript文件。   
 52 | 
 53 | ### 14.5.1 index.html
 54 | 这将是我们应用程序中的主页面。它将只包含用于登录，注销和调用Web API的按钮的HTML。它还将包含`<script>`标记以包含我们的两个JavaScript文件。它还将包含`<pre>`用于向用户显示消息的用途。   
 55 | 
 56 | 它应该如下所示：   
 57 | 
 58 | ``` html
 59 | <!DOCTYPE html>
 60 | <html>
 61 | <head>
 62 |     <meta charset="utf-8" />
 63 |     <title></title>
 64 | </head>
 65 | <body>
 66 |     <button id="login">Login</button>
 67 |     <button id="api">Call API</button>
 68 |     <button id="logout">Logout</button>
 69 | 
 70 |     <pre id="results"></pre>
 71 | 
 72 |     <script src="oidc-client.js"></script>
 73 |     <script src="app.js"></script>
 74 | </body>
 75 | </html>
 76 | ```   
 77 | 
 78 | ### 14.5.2 app.js
 79 | 这将包含我们的应用程序的主要代码。第一件事是添加一个帮助函数来将消息记录到`<pre>`：   
 80 | 
 81 | ``` javascript
 82 | function log() {
 83 |     document.getElementById('results').innerText = '';
 84 | 
 85 |     Array.prototype.forEach.call(arguments, function (msg) {
 86 |         if (msg instanceof Error) {
 87 |             msg = "Error: " + msg.message;
 88 |         }
 89 |         else if (typeof msg !== 'string') {
 90 |             msg = JSON.stringify(msg, null, 2);
 91 |         }
 92 |         document.getElementById('results').innerHTML += msg + '\r\n';
 93 |     });
 94 | }
 95 | ```   
 96 | 
 97 | 接下来，添加代码以将`click`事件处理程序注册到三个按钮：
 98 | 
 99 | ``` javascript
100 | document.getElementById("login").addEventListener("click", login, false);
101 | document.getElementById("api").addEventListener("click", api, false);
102 | document.getElementById("logout").addEventListener("click", logout, false);
103 | ```   
104 | 
105 | 接下来，我们可以使用`UserManager`类从OIDC客户端库来管理OpenID Connect协议。它需要MVC Client中必需的类似配置（尽管具有不同的值）。添加此代码以配置和实例化UserManager：  
106 | 
107 | ``` javascript
108 | var config = {
109 |     authority: "http://localhost:5000",
110 |     client_id: "js",
111 |     redirect_uri: "http://localhost:5003/callback.html",
112 |     response_type: "code",
113 |     scope:"openid profile api1",
114 |     post_logout_redirect_uri : "http://localhost:5003/index.html",
115 | };
116 | var mgr = new Oidc.UserManager(config);
117 | ```   
118 | 
119 | 接下来，`UserManager`提供`getUserAPI`以了解用户是否登录到JavaScript应用程序。它使用JavaScript `Promise`以异步方式返回结果。返回的`User`对象具有`profile`包含用户声明的属性。添加此代码以检测用户是否已登录JavaScript应用程序：   
120 | 
121 | ``` javascript
122 | mgr.getUser().then(function (user) {
123 |     if (user) {
124 |         log("User logged in", user.profile);
125 |     }
126 |     else {
127 |         log("User not logged in");
128 |     }
129 | });
130 | ```   
131 | 
132 | 接下来，我们要实现的`login`，`api`和`logout`功能。在`UserManager`提供了`signinRedirect`登录用户，并且`signoutRedirect`以注销用户。`User`我们在上面的代码中获得的对象还具有`access_token`可用于向Web API进行身份验证的属性。在`access_token`将被传递给通过网络API 授权与头承载方案。添加此代码以在我们的应用程序中实现这三个功能：   
133 | 
134 | ``` javascript
135 | function login() {
136 |     mgr.signinRedirect();
137 | }
138 | 
139 | function api() {
140 |     mgr.getUser().then(function (user) {
141 |         var url = "http://localhost:5001/identity";
142 | 
143 |         var xhr = new XMLHttpRequest();
144 |         xhr.open("GET", url);
145 |         xhr.onload = function () {
146 |             log(xhr.status, JSON.parse(xhr.responseText));
147 |         }
148 |         xhr.setRequestHeader("Authorization", "Bearer " + user.access_token);
149 |         xhr.send();
150 |     });
151 | }
152 | 
153 | function logout() {
154 |     mgr.signoutRedirect();
155 | }
156 | ```   
157 | 
158 | > **注意**
159 | 有关如何创建上述代码中使用的api的信息，请参阅客户端凭据快速入门。   
160 | 
161 | ### 14.5.3 callback.html
162 | 
163 | `redirect_uri`用户登录IdentityServer后，此HTML文件是指定的页面。它将完成与IdentityServer的OpenID Connect协议登录握手。这个代码全部由`UserManager`我们之前使用的类提供。登录完成后，我们可以将用户重定向回主index.html页面。添加此代码以完成登录过程：   
164 | 
165 | ``` html
166 | <!DOCTYPE html>
167 | <html>
168 | <head>
169 |     <meta charset="utf-8" />
170 |     <title></title>
171 | </head>
172 | <body>
173 |     <script src="oidc-client.js"></script>
174 |     <script>
175 |         new Oidc.UserManager({response_mode:"query"}).signinRedirectCallback().then(function() {
176 |             window.location = "index.html";
177 |         }).catch(function(e) {
178 |             console.error(e);
179 |         });
180 |     </script>
181 | </body>
182 | </html>
183 | ```   
184 | 
185 | ## 14.6 客户注册加入IdentityServer的JavaScript客户端
186 | 既然客户端应用程序已经准备就绪，我们需要在IdentityServer中为这个新的JavaScript客户端定义一个配置条目。在IdentityServer项目中找到客户端配置（在*Config.cs*中）。将新客户端添加到我们的新JavaScript应用程序的列表中。它应该具有下面列出的配置：
187 | 
188 | ``` C#
189 | // JavaScript Client
190 | new Client
191 | {
192 |     ClientId = "js",
193 |     ClientName = "JavaScript Client",
194 |     AllowedGrantTypes = GrantTypes.Code,
195 |     RequirePkce = true,
196 |     RequireClientSecret = false,
197 | 
198 |     RedirectUris =           { "http://localhost:5003/callback.html" },
199 |     PostLogoutRedirectUris = { "http://localhost:5003/index.html" },
200 |     AllowedCorsOrigins =     { "http://localhost:5003" },
201 | 
202 |     AllowedScopes =
203 |     {
204 |         IdentityServerConstants.StandardScopes.OpenId,
205 |         IdentityServerConstants.StandardScopes.Profile,
206 |         "api1"
207 |     }
208 | }
209 | ```   
210 | 
211 | ## 14.7 允许Ajax以CORS的方式调用WebAPI
212 | 最后一点配置是在Web API项目中配置CORS。这将允许从http://localhost:5003到http://localhost:5001进行Ajax调用。
213 | 
214 | ### 14.7.1 配置CORS
215 | 
216 | `ConfigureServices`在*Startup.cs*中将CORS服务添加到依赖注入系统：   
217 | 
218 | ``` C#
219 | public void ConfigureServices(IServiceCollection services)
220 | {
221 |     services.AddMvcCore()
222 |         .AddAuthorization()
223 |         .AddJsonFormatters();
224 | 
225 |     services.AddAuthentication("Bearer")
226 |         .AddIdentityServerAuthentication(options =>
227 |         {
228 |             options.Authority = "http://localhost:5000";
229 |             options.RequireHttpsMetadata = false;
230 | 
231 |             options.ApiName = "api1";
232 |         });
233 | 
234 |     services.AddCors(options =>
235 |     {
236 |         // this defines a CORS policy called "default"
237 |         options.AddPolicy("default", policy =>
238 |         {
239 |             policy.WithOrigins("http://localhost:5003")
240 |                 .AllowAnyHeader()
241 |                 .AllowAnyMethod();
242 |         });
243 |     });
244 | }
245 | ```   
246 | 
247 | 将CORS中间件添加到管道中Configure：   
248 | 
249 | ``` C#
250 | public void Configure(IApplicationBuilder app)
251 | {
252 |     app.UseCors("default");
253 | 
254 |     app.UseAuthentication();
255 | 
256 |     app.UseMvc();
257 | }
258 | ```   
259 | 
260 | ## 14.8 运行JavaScript应用程序
261 | 现在您应该能够运行JavaScript客户端应用程序：   
262 | <div align="center">
263 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/6_not_logged_in.png">
264 | </div>   
265 | 
266 | 单击“登录”按钮以对用户进行签名。一旦用户返回到JavaScript应用程序，您应该看到他们的个人资料信息：   
267 | 
268 | <div align="center">
269 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/6_logged_in.png">
270 | </div>   
271 | 
272 | 然后单击“API”按钮以调用Web API：   
273 | 
274 | <div align="center">
275 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/6_api_results.png">
276 | </div>   
277 | 
278 | 最后点击“退出”以签署用户。   
279 | 
280 | <div align="center">
281 | <image src="https://identityserver4.readthedocs.io/en/latest/_images/6_signed_out.png">   
282 | 
283 | 您现在可以开始使用IdentityServer进行登录，注销和验证对Web API的调用的JavaScript客户端应用程序。
284 | 
285 | 


--------------------------------------------------------------------------------