【.NET Core項目實戰-統一認證平臺】第十一章 授權篇-密碼授權模式

来源:https://www.cnblogs.com/jackcao/archive/2018/12/18/10140688.html
-Advertisement-
Play Games

" 【.NET Core項目實戰 統一認證平臺】開篇及目錄索引 " 上篇文章介紹了基於 客戶端授權的原理及如何實現自定義的客戶端授權，並配合網關實現了統一的授權異常返回值和許可權配置等相關功能，本篇將介紹密碼授權模式，從使用場景、源碼剖析到具體實現詳細講解密碼授權模式的相關應用。 .netcore項目 ...


【.NET Core項目實戰-統一認證平臺】開篇及目錄索引

上篇文章介紹了基於Ids4客戶端授權的原理及如何實現自定義的客戶端授權，並配合網關實現了統一的授權異常返回值和許可權配置等相關功能，本篇將介紹密碼授權模式，從使用場景、源碼剖析到具體實現詳細講解密碼授權模式的相關應用。

.netcore項目實戰交流群（637326624），有興趣的朋友可以在群里交流討論。

一、使用場景？

由於密碼授權模式需要用戶在業務系統輸入賬號密碼，為了安全起見，對於使用密碼模式的業務系統，我們認為是絕對可靠的，不存在泄漏用戶名和密碼的風險，所以使用場景定位為公司內部系統或集團內部系統或公司內部app等內部應用，非內部應用，儘量不要開啟密碼授權模式，防止用戶賬戶泄漏。

  • 這種模式適用於用戶對應用程式高度信任的情況。比如是用戶系統的一部分。

二、Ids4密碼模式的預設實現剖析

在我們使用密碼授權模式之前，我們需要理解密碼模式是如何實現的，在上一篇中，我介紹了客戶端授權的實現及源碼剖析，相信我們已經對Ids4客戶端授權已經熟悉，今天繼續分析密碼模式是如何獲取到令牌的。

Ids4的所有授權都在TokenEndpoint方法中，密碼模式授權也是先校驗客戶端授權，如果客戶端校驗失敗，直接返回刪除信息，如果客戶端校驗成功，繼續校驗用戶名和密碼，詳細實現代碼如下。

  • 1、校驗是否存在grantType，然後根據不同的類型啟用不同的校驗方式。

    // TokenRequestValidator.cs
public async Task<TokenRequestValidationResult> ValidateRequestAsync(NameValueCollection parameters, ClientSecretValidationResult clientValidationResult)
{
  _logger.LogDebug("Start token request validation");

  _validatedRequest = new ValidatedTokenRequest
  {
      Raw = parameters ?? throw new ArgumentNullException(nameof(parameters)),
      Options = _options
  };

  if (clientValidationResult == null) throw new ArgumentNullException(nameof(clientValidationResult));

  _validatedRequest.SetClient(clientValidationResult.Client, clientValidationResult.Secret, clientValidationResult.Confirmation);

  /////////////////////////////////////////////
  // check client protocol type
  /////////////////////////////////////////////
  if (_validatedRequest.Client.ProtocolType != IdentityServerConstants.ProtocolTypes.OpenIdConnect)
  {
      LogError("Client {clientId} has invalid protocol type for token endpoint: expected {expectedProtocolType} but found {protocolType}",
               _validatedRequest.Client.ClientId,
               IdentityServerConstants.ProtocolTypes.OpenIdConnect,
               _validatedRequest.Client.ProtocolType);
      return Invalid(OidcConstants.TokenErrors.InvalidClient);
  }

  /////////////////////////////////////////////
  // check grant type
  /////////////////////////////////////////////
  var grantType = parameters.Get(OidcConstants.TokenRequest.GrantType);
  if (grantType.IsMissing())
  {
      LogError("Grant type is missing");
      return Invalid(OidcConstants.TokenErrors.UnsupportedGrantType);
  }

  if (grantType.Length > _options.InputLengthRestrictions.GrantType)
  {
      LogError("Grant type is too long");
      return Invalid(OidcConstants.TokenErrors.UnsupportedGrantType);
  }

  _validatedRequest.GrantType = grantType;

  switch (grantType)
  {
      case OidcConstants.GrantTypes.AuthorizationCode:
          return await RunValidationAsync(ValidateAuthorizationCodeRequestAsync, parameters);
      case OidcConstants.GrantTypes.ClientCredentials:
          return await RunValidationAsync(ValidateClientCredentialsRequestAsync, parameters);
      case OidcConstants.GrantTypes.Password:  //1、密碼授權模式調用方法
          return await RunValidationAsync(ValidateResourceOwnerCredentialRequestAsync, parameters);
      case OidcConstants.GrantTypes.RefreshToken:
          return await RunValidationAsync(ValidateRefreshTokenRequestAsync, parameters);
      default:
          return await RunValidationAsync(ValidateExtensionGrantRequestAsync, parameters);
  }
}

  • 2、啟用密碼授權模式校驗規則，首先校驗傳輸的參數和scope是否存在，然後校驗用戶名密碼是否準確，最後校驗用戶是否可用。

    private async Task<TokenRequestValidationResult> ValidateResourceOwnerCredentialRequestAsync(NameValueCollection parameters)
{
    _logger.LogDebug("Start resource owner password token request validation");

    /////////////////////////////////////////////
    // 校驗授權模式
    /////////////////////////////////////////////
    if (!_validatedRequest.Client.AllowedGrantTypes.Contains(GrantType.ResourceOwnerPassword))
    {
        LogError("{clientId} not authorized for resource owner flow, check the AllowedGrantTypes of client", _validatedRequest.Client.ClientId);
        return Invalid(OidcConstants.TokenErrors.UnauthorizedClient);
    }

    /////////////////////////////////////////////
    // 校驗客戶端是否允許這些scope
    /////////////////////////////////////////////
    if (!(await ValidateRequestedScopesAsync(parameters)))
    {
        return Invalid(OidcConstants.TokenErrors.InvalidScope);
    }

    /////////////////////////////////////////////
    // 校驗參數是否為定義的用戶名或密碼參數
    /////////////////////////////////////////////
    var userName = parameters.Get(OidcConstants.TokenRequest.UserName);
    var password = parameters.Get(OidcConstants.TokenRequest.Password);

    if (userName.IsMissing() || password.IsMissing())
    {
        LogError("Username or password missing");
        return Invalid(OidcConstants.TokenErrors.InvalidGrant);
    }

    if (userName.Length > _options.InputLengthRestrictions.UserName ||
        password.Length > _options.InputLengthRestrictions.Password)
    {
        LogError("Username or password too long");
        return Invalid(OidcConstants.TokenErrors.InvalidGrant);
    }

    _validatedRequest.UserName = userName;


    /////////////////////////////////////////////
    // 校驗用戶名和密碼是否準確
    /////////////////////////////////////////////
    var resourceOwnerContext = new ResourceOwnerPasswordValidationContext
    {
        UserName = userName,
        Password = password,
        Request = _validatedRequest
    };
    //預設使用的是 TestUserResourceOwnerPasswordValidator
    await _resourceOwnerValidator.ValidateAsync(resourceOwnerContext);

    if (resourceOwnerContext.Result.IsError)
    {
        if (resourceOwnerContext.Result.Error == OidcConstants.TokenErrors.UnsupportedGrantType)
        {
            LogError("Resource owner password credential grant type not supported");
            await RaiseFailedResourceOwnerAuthenticationEventAsync(userName, "password grant type not supported");

            return Invalid(OidcConstants.TokenErrors.UnsupportedGrantType, customResponse: resourceOwnerContext.Result.CustomResponse);
        }

        var errorDescription = "invalid_username_or_password";

        if (resourceOwnerContext.Result.ErrorDescription.IsPresent())
        {
            errorDescription = resourceOwnerContext.Result.ErrorDescription;
        }

        LogInfo("User authentication failed: {error}", errorDescription ?? resourceOwnerContext.Result.Error);
        await RaiseFailedResourceOwnerAuthenticationEventAsync(userName, errorDescription);

        return Invalid(resourceOwnerContext.Result.Error, errorDescription, resourceOwnerContext.Result.CustomResponse);
    }

    if (resourceOwnerContext.Result.Subject == null)
    {
        var error = "User authentication failed: no principal returned";
        LogError(error);
        await RaiseFailedResourceOwnerAuthenticationEventAsync(userName, error);

        return Invalid(OidcConstants.TokenErrors.InvalidGrant);
    }

    /////////////////////////////////////////////
    // 設置用戶可用,比如用戶授權後被鎖定，可以通過此方法實現 預設實現 TestUserProfileService
    /////////////////////////////////////////////
    var isActiveCtx = new IsActiveContext(resourceOwnerContext.Result.Subject, _validatedRequest.Client, IdentityServerConstants.ProfileIsActiveCallers.ResourceOwnerValidation);
    await _profile.IsActiveAsync(isActiveCtx);

    if (isActiveCtx.IsActive == false)
    {
        LogError("User has been disabled: {subjectId}", resourceOwnerContext.Result.Subject.GetSubjectId());
        await RaiseFailedResourceOwnerAuthenticationEventAsync(userName, "user is inactive");

        return Invalid(OidcConstants.TokenErrors.InvalidGrant);
    }

    _validatedRequest.UserName = userName;
    _validatedRequest.Subject = resourceOwnerContext.Result.Subject;

    await RaiseSuccessfulResourceOwnerAuthenticationEventAsync(userName, resourceOwnerContext.Result.Subject.GetSubjectId());
    _logger.LogDebug("Resource owner password token request validation success.");
    return Valid(resourceOwnerContext.Result.CustomResponse);
}

  • 3、運行自定義上下文驗證

    private async Task<TokenRequestValidationResult> RunValidationAsync(Func<NameValueCollection, Task<TokenRequestValidationResult>> validationFunc, NameValueCollection parameters)
{
    // 執行步驟2驗證
    var result = await validationFunc(parameters);
    if (result.IsError)
    {
        return result;
    }

    // 運行自定義驗證，Ids4 預設有個 DefaultCustomTokenRequestValidator 實現，如果需要擴充其他驗證，可以集成ICustomTokenRequestValidator單獨實現。
    _logger.LogTrace("Calling into custom request validator: {type}", _customRequestValidator.GetType().FullName);

    var customValidationContext = new CustomTokenRequestValidationContext { Result = result };
    await _customRequestValidator.ValidateAsync(customValidationContext);

    if (customValidationContext.Result.IsError)
    {
        if (customValidationContext.Result.Error.IsPresent())
        {
            LogError("Custom token request validator error {error}", customValidationContext.Result.Error);
        }
        else
        {
            LogError("Custom token request validator error");
        }

        return customValidationContext.Result;
    }

    LogSuccess();
    return customValidationContext.Result;
}

    通過源碼剖析可以發現，Ids4給了我們很多的驗證方式，並且預設也實現的驗證和自定義的擴展，這樣如果我們需要使用密碼授權模式，就可以重寫IResourceOwnerPasswordValidator來實現系統內部用戶系統的驗證需求。如果需要確認用戶在登錄以後是否被註銷時，可以重寫IProfileService介面實現，這個驗證主要是生成token校驗時檢查。

  • 4、最終生成Token

    根據不同的授權模式，生成不同的token記錄。

    /// <summary>
/// Processes the response.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
public virtual async Task<TokenResponse> ProcessAsync(TokenRequestValidationResult request)
{
    switch (request.ValidatedRequest.GrantType)
    {
        case OidcConstants.GrantTypes.ClientCredentials:
            return await ProcessClientCredentialsRequestAsync(request);
        case OidcConstants.GrantTypes.Password: //生成密碼授權模式token
            return await ProcessPasswordRequestAsync(request);
        case OidcConstants.GrantTypes.AuthorizationCode:
            return await ProcessAuthorizationCodeRequestAsync(request);
        case OidcConstants.GrantTypes.RefreshToken:
            return await ProcessRefreshTokenRequestAsync(request);
        default:
            return await ProcessExtensionGrantRequestAsync(request);
    }
}

/// <summary>
/// Creates the response for a password request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
protected virtual Task<TokenResponse> ProcessPasswordRequestAsync(TokenRequestValidationResult request)
{
    Logger.LogTrace("Creating response for password request");

    return ProcessTokenRequestAsync(request);
}

/// <summary>
/// Creates the response for a token request.
/// </summary>
/// <param name="validationResult">The validation result.</param>
/// <returns></returns>
protected virtual async Task<TokenResponse> ProcessTokenRequestAsync(TokenRequestValidationResult validationResult)
{
    (var accessToken, var refreshToken) = await CreateAccessTokenAsync(validationResult.ValidatedRequest);
    var response = new TokenResponse
    {
        AccessToken = accessToken,
        AccessTokenLifetime = validationResult.ValidatedRequest.AccessTokenLifetime,
        Custom = validationResult.CustomResponse
    };

    if (refreshToken.IsPresent())
    {
        response.RefreshToken = refreshToken;
    }

    return response;
}

    根據請求的scope判斷是否生成refreshToken，如果標記了offline_access，則生成refreshToken，否則不生成。

    /// <summary>
/// Creates the access/refresh token.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
/// <exception cref="System.InvalidOperationException">Client does not exist anymore.</exception>
protected virtual async Task<(string accessToken, string refreshToken)> CreateAccessTokenAsync(ValidatedTokenRequest request)
{
    TokenCreationRequest tokenRequest;
    bool createRefreshToken;
  //授權碼模式
    if (request.AuthorizationCode != null)
    {//是否包含RefreshToken
        createRefreshToken = request.AuthorizationCode.RequestedScopes.Contains(IdentityServerConstants.StandardScopes.OfflineAccess);

        // load the client that belongs to the authorization code
        Client client = null;
        if (request.AuthorizationCode.ClientId != null)
        {
            client = await Clients.FindEnabledClientByIdAsync(request.AuthorizationCode.ClientId);
        }
        if (client == null)
        {
            throw new InvalidOperationException("Client does not exist anymore.");
        }

        var resources = await Resources.FindEnabledResourcesByScopeAsync(request.AuthorizationCode.RequestedScopes);

        tokenRequest = new TokenCreationRequest
        {
            Subject = request.AuthorizationCode.Subject,
            Resources = resources,
            ValidatedRequest = request
        };
    }
    else
    {//是否包含RefreshToken
        createRefreshToken = request.ValidatedScopes.ContainsOfflineAccessScope;

        tokenRequest = new TokenCreationRequest
        {
            Subject = request.Subject,
            Resources = request.ValidatedScopes.GrantedResources,
            ValidatedRequest = request
        };
    }

    var at = await TokenService.CreateAccessTokenAsync(tokenRequest);
    var accessToken = await TokenService.CreateSecurityTokenAsync(at);

    if (createRefreshToken)
    {
        var refreshToken = await RefreshTokenService.CreateRefreshTokenAsync(tokenRequest.Subject, at, request.Client);
        return (accessToken, refreshToken);
    }

    return (accessToken, null);
}

  • 5、RefreshToken持久化

    當我們使用了offline_access時，就需要生成RefreshToken併進行持久化，詳細的實現代碼如下。

    public virtual async Task<string> CreateRefreshTokenAsync(ClaimsPrincipal subject, Token accessToken, Client client)
{
    _logger.LogDebug("Creating refresh token");

    int lifetime;
    if (client.RefreshTokenExpiration == TokenExpiration.Absolute)
    {
        _logger.LogDebug("Setting an absolute lifetime: " + client.AbsoluteRefreshTokenLifetime);
        lifetime = client.AbsoluteRefreshTokenLifetime;
    }
    else
    {
        _logger.LogDebug("Setting a sliding lifetime: " + client.SlidingRefreshTokenLifetime);
        lifetime = client.SlidingRefreshTokenLifetime;
    }

    var refreshToken = new RefreshToken
    {
        CreationTime = Clock.UtcNow.UtcDateTime,
        Lifetime = lifetime,
        AccessToken = accessToken
    };
  //存儲RefreshToken並返回值
    var handle = await RefreshTokenStore.StoreRefreshTokenAsync(refreshToken);
    return handle;
}

/// <summary>
/// 存儲RefreshToken並返回
/// </summary>
/// <param name="refreshToken">The refresh token.</param>
/// <returns></returns>
public async Task<string> StoreRefreshTokenAsync(RefreshToken refreshToken)
{
    return await CreateItemAsync(refreshToken, refreshToken.ClientId, refreshToken.SubjectId, refreshToken.CreationTime, refreshToken.Lifetime);
}

/// <summary>
/// 創建Item
/// </summary>
/// <param name="item">The item.</param>
/// <param name="clientId">The client identifier.</param>
/// <param name="subjectId">The subject identifier.</param>
/// <param name="created">The created.</param>
/// <param name="lifetime">The lifetime.</param>
/// <returns></returns>
protected virtual async Task<string> CreateItemAsync(T item, string clientId, string subjectId, DateTime created, int lifetime)
{
    var handle = await HandleGenerationService.GenerateAsync(); //生成隨機值
    await StoreItemAsync(handle, item, clientId, subjectId, created, created.AddSeconds(lifetime)); //存儲
    return handle;
}

/// <summary>
/// 存儲RefreshToken
/// </summary>
/// <param name="key">The key.</param>
/// <param name="item">The item.</param>
/// <param name="clientId">The client identifier.</param>
/// <param name="subjectId">The subject identifier.</param>
/// <param name="created">The created.</param>
/// <param name="expiration">The expiration.</param>
/// <returns></returns>
protected virtual async Task StoreItemAsync(string key, T item, string clientId, string subjectId, DateTime created, DateTime? expiration)
{
    key = GetHashedKey(key);

    var json = Serializer.Serialize(item);

    var grant = new PersistedGrant
    {
        Key = key,
        Type = GrantType,
        ClientId = clientId,
        SubjectId = subjectId,
        CreationTime = created,
        Expiration = expiration,
        Data = json
    };

    await Store.StoreAsync(grant);
}

//IPersistedGrantStore 我們在dapper持久化時已經實現了StoreAsync方式，是不是都關聯起來了。

    至此，我們整個密碼授權模式全部講解完成，相信大家跟我一樣完全掌握了授權的整個流程，如果需要持久化如何進行持久化流程。

理解了完整的密碼授權模式流程後，使用自定義的用戶體系就得心應手了，下麵就開始完整的實現自定義帳戶授權。

三、設計自定義的賬戶信息並應用

為了演示方便，我這裡就設計簡單的用戶帳戶信息，作為自定義的哦帳戶基礎，如果正式環境中使用，請根據各自業務使用各自的帳戶體系即可。

-- 創建用戶表
CREATE TABLE CzarUsers
(
    Uid INT IDENTITY(1,1),            --用戶主鍵    
    uAccount varchar(11),             --用戶賬號
    uPassword varchar(200),           --用戶密碼
    uNickName varchar(50),            --用戶昵稱
    uMobile varchar(11),              --用戶手機號
    uEmail varchar(100),              --用戶郵箱
    uStatus int not null default(1)   -- 用戶狀態 1 正常 0 不可用
)

添加用戶實體代碼如下所示。

/// <summary>
/// 授權用戶信息
/// </summary>
public class CzarUsers
{
    public CzarUsers() { }

    public int Uid { get; set; }
    public string uAccount { get; set; }
    public string uPassword { get; set; }
    public string uNickName { get; set; }
    public string uMobile { get; set; }
    public string uEmail { get; set; }
    public string uStatus { get; set; }
}

下麵開始密碼授權模式開發，首先需要重新實現IResourceOwnerPasswordValidator介面，使用我們定義的用戶表來驗證請求的用戶名和密碼信息。

/// <summary>
/// 金焰的世界
/// 2018-12-18
/// 自定義用戶名密碼校驗
/// </summary>
public class CzarResourceOwnerPasswordValidator : IResourceOwnerPasswordValidator
    {
        private readonly ICzarUsersServices _czarUsersServices;
        public CzarResourceOwnerPasswordValidator(ICzarUsersServices czarUsersServices)
        {
            _czarUsersServices = czarUsersServices;
        }
        /// <summary>
        /// 驗證用戶身份
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
        {
            var user = _czarUsersServices.FindUserByuAccount(context.UserName, context.Password);
            if (user != null)
            {
                context.Result = new GrantValidationResult(
                    user.Uid.ToString(),
                    OidcConstants.AuthenticationMethods.Password, 
                    DateTime.UtcNow);
            }
            return Task.CompletedTask;
        }
    }

編寫完自定義校驗後，我們需要註入到具體的實現，詳細代碼如下。

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton(Configuration);
    services.Configure<CzarConfig>(Configuration.GetSection("CzarConfig"));
    services.AddIdentityServer(option=> {
        option.PublicOrigin = Configuration["CzarConfig:PublicOrigin"];
    })
        .AddDeveloperSigningCredential()
        .AddDapperStore(option =>
                        {
                            option.DbConnectionStrings = Configuration["CzarConfig:DbConnectionStrings"];
                        })
        //使用自定義的密碼校驗
        .AddResourceOwnerValidator<CzarResourceOwnerPasswordValidator>()
        ;
    //  .UseMySql();


    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}

剩下的就是把ICzarUsersServices介面實現並註入即可。詳細代碼如下。

/// <summary>
/// 金焰的世界
/// 2018-12-18
/// 用戶服務介面
/// </summary>
public interface ICzarUsersServices
{
    /// <summary>
    /// 根據賬號密碼獲取用戶實體
    /// </summary>
    /// <param name="uaccount">賬號</param>
    /// <param name="upassword">密碼</param>
    /// <returns></returns>
    CzarUsers FindUserByuAccount(string uaccount, string upassword);

    /// <summary>
    /// 根據用戶主鍵獲取用戶實體
    /// </summary>
    /// <param name="sub">用戶標識</param>
    /// <returns></returns>
    CzarUsers FindUserByUid(string sub);
}

/// <summary>
/// 金焰的世界
/// 2018-12-18
/// 用戶服務實現
/// </summary>
public class CzarUsersServices : ICzarUsersServices
    {
        private readonly ICzarUsersRepository _czarUsersRepository;
        public CzarUsersServices(ICzarUsersRepository czarUsersRepository)
        {
            _czarUsersRepository = czarUsersRepository;
        }

        /// <summary>
        /// 根據賬號密碼獲取用戶實體
        /// </summary>
        /// <param name="uaccount">賬號</param>
        /// <param name="upassword">密碼</param>
        /// <returns></returns>
        public CzarUsers FindUserByuAccount(string uaccount, string upassword)
        {
            return _czarUsersRepository.FindUserByuAccount(uaccount, upassword);
        }

        /// <summary>
        /// 根據用戶主鍵獲取用戶實體
        /// </summary>
        /// <param name="sub">用戶標識</param>
        /// <returns></returns>
        public CzarUsers FindUserByUid(string sub)
        {
            return _czarUsersRepository.FindUserByUid(sub);
        }
    }

最後我們實現倉儲介面和方法，即可完成校驗流程。

/// <summary>
/// 金焰的世界
/// 2018-12-18
/// 用戶倉儲介面
/// </summary>
public interface ICzarUsersRepository
{
    /// <summary>
    /// 根據賬號密碼獲取用戶實體
    /// </summary>
    /// <param name="uaccount">賬號</param>
    /// <param name="upassword">密碼</param>
    /// <returns></returns>
    CzarUsers FindUserByuAccount(string uaccount, string upassword);

    /// <summary>
    /// 根據用戶主鍵獲取用戶實體
    /// </summary>
    /// <param name="sub">用戶標識</param>
    /// <returns></returns>
    CzarUsers FindUserByUid(string sub);
}

/// <summary>
/// 金焰的世界
/// 2018-12-18
/// 用戶實體基於SQLSERVER的實現
/// </summary>
public class CzarUsersRepository : ICzarUsersRepository
    {
        private readonly string DbConn = "";
        public CzarUsersRepository(IOptions<CzarConfig> czarConfig)
        {
            DbConn = czarConfig.Value.DbConnectionStrings;
        }
        /// <summary>
        /// 根據賬號密碼獲取用戶實體
        /// </summary>
        /// <param name="uaccount">賬號</param>
        /// <param name="upassword">密碼</param>
        /// <returns></returns>
        public CzarUsers FindUserByuAccount(string uaccount, string upassword)
        {
            using (var connection = new SqlConnection(DbConn))
            {
                string sql = @"SELECT * from CzarUsers where uAccount=@uaccount and uPassword=upassword and uStatus=1";
                var result = connection.QueryFirstOrDefault<CzarUsers>(sql, new { uaccount, upassword = SecretHelper.ToMD5(upassword) });
                return result;
            }
        }

        /// <summary>
        /// 根據用戶主鍵獲取用戶實體
        /// </summary>
        /// <param name="sub">用戶標識</param>
        /// <returns></returns>
        public CzarUsers FindUserByUid(string sub)
        {
            using (var connection = new SqlConnection(DbConn))
            {
                string sql = @"SELECT * from CzarUsers where uid=@uid";
                var result = connection.QueryFirstOrDefault<CzarUsers>(sql, new { uid=sub });
                return result;
            }
        }
    }

現在萬事俱備，之前註入和插入測試用戶數據進行測試了，為了方便註入，我們採用autofac程式集註冊。

/// <summary>
/// 金焰的世界
/// 2018-12-18
/// 使用程式集註冊
/// </summary>
public class CzarModule : Autofac.Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            //註冊Repository程式集
            builder.RegisterAssemblyTypes(typeof(CzarUsersRepository).GetTypeInfo().Assembly).AsImplementedInterfaces().InstancePerLifetimeScope();
            //註冊Services程式集
            builder.RegisterAssemblyTypes(typeof(CzarUsersServices).GetTypeInfo().Assembly).AsImplementedInterfaces().InstancePerLifetimeScope();
        }
    }

然後需要修改ConfigureServices代碼如下,就完成了倉儲和服務層的註入。

public IServiceProvider ConfigureServices(IServiceCollection services)
{
    services.AddSingleton(Configuration);
    services.Configure<CzarConfig>(Configuration.GetSection("CzarConfig"));
    services.AddIdentityServer(option=> {
        option.PublicOrigin = Configuration["CzarConfig:PublicOrigin"];
    })
        .AddDeveloperSigningCredential()
        .AddDapperStore(option =>
                        {
                            option.DbConnectionStrings = Configuration["CzarConfig:DbConnectionStrings"];
                        })
        .AddResourceOwnerValidator<CzarResourceOwnerPasswordValidator>()
        ;
    //  .UseMySql();


    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);

    //使用Autofac進行註入
    var container = new ContainerBuilder();
    container.RegisterModule(new CzarModule());
    container.Populate(services);
    return new AutofacServiceProvider(container.Build());
}

為了驗證密碼授權模式信息，這裡需要往資料庫插入測試的用戶數據，插入腳本如下。

--密碼123456  MD5加密結果
INSERT INTO CzarUsers VALUES('13888888888','E10ADC3949BA59ABBE56E057F20F883E','金焰的世界','13888888888','[email protected]',1);

四、測試密碼授權模式

註意：測試密碼授權模式之前，我們需要對測試的客戶端ClientGrantTypes表添加password授權方式。

打開我們的測試神器Postman,然後開始調試密碼授權模式，測試結果如下圖所示。

是不是很完美，得到了我們想要的授權結果，那我們查看下這個access_token是什麼信息，可以使用https://jwt.io/查看到詳細的內容，發現除了客戶端信息和用戶主鍵無其他附加信息，那如何添加自定義的Claim信息呢？

先修改下CzarUsers實體，增加如下代碼，如果有其他屬性可自行擴展。

public List<Claim> Claims
        {
            get
            {
                return new List<Claim>() {
                    new Claim("nickname",uNickName??""),
                    new Claim("email",uEmail??""),
                    new Claim("mobile",uMobile??"")
                };
            }
        }

再修改校驗方法，增加Claim輸出，CzarResourceOwnerPasswordValidator修改代碼如下。

/// <summary>
/// 驗證用戶身份
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
{
    var user = _czarUsersServices.FindUserByuAccount(context.UserName, context.Password);
    if (user != null)
    {
        context.Result = new GrantValidationResult(
            user.Uid.ToString(),
            OidcConstants.AuthenticationMethods.Password, 
            DateTime.UtcNow,
            user.Claims);
    }
    return Task.CompletedTask;
}

然後需要把用戶的claims應用到Token，這裡我們需要重寫IProfileService，然後把用戶的claim輸出，實現代碼如下。

public class CzarProfileService : IProfileService
    {
        public Task GetProfileDataAsync(ProfileDataRequestContext context)
        {
            //把用戶返回的Claims應用到返回
            context.IssuedClaims = context.Subject.Claims.ToList();
            return Task.CompletedTask;
        }

        /// <summary>
        /// 驗證用戶是否有效
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public Task IsActiveAsync(IsActiveContext context)
        {
            context.IsActive = true;
            return Task.CompletedTask;
        }
    }

然後別忘了註入.AddProfileService<CzarProfileService>()，好了現在我們再次測試下授權，最終得到的結果如下所示。

奈斯，得到了我們預期授權結果。

那如何獲取refresh_token呢？通過前面的介紹，我們需要增加scope為offline_access，並且需要設置客戶端支持，因此AllowOfflineAccess屬性需要設置為True，現在來測試下獲取的授權結果。

最終完成了refresh_token的獲取，至此整個密碼授權模式全部講解並實現完成。

五、總結及思考

本篇文章我們從密碼授權模式使用場景、源碼剖析、自定義用戶授權來講解了密碼授權模式的詳細思路和代碼實現，從中不難發現Ids4設計的巧妙，在預設實現的同時也預留了很多自定義擴展，本篇的自定義用戶體系也是重新實現介面然後註入就完成集成工作。本篇主要難點就是要理解Ids4的實現思路和資料庫的相關配置，希望通過本篇的講解讓我們熟練掌握密碼驗證的流程，便於應用到實際生產環境。

上篇的客戶端授權模式和本篇的密碼授權模式都講解完可能有人會存在以下幾個疑問。

  • 1、如何校驗令牌信息的有效性？
  • 2、如何強制有效令牌過期？
  • 3、如何實現單機登錄？

下篇文章我將會從這3個疑問出發，來詳細講解下這三個問題的實現思路和代碼。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 合併兩個有序鏈表的golang實現
    將兩個有序鏈表合併為一個新的有序鏈表並返回。新鏈表是通過拼接給定的兩個鏈表的所有節點組成的。 註意： 兩個鏈表都是有序的 如果某個鏈表為空，那就直接返回另外一個有序鏈表 然後我們就要比較兩個鏈表的節點的順序了 首先，我們定義一個result指針 比較兩個鏈表的第一個元素哪個比較小 result指向小 ...
  • php+ajax實現登錄按鈕載入loading效果
    php+ajax實現登錄按鈕載入loading效果，一個提高用戶體驗，二個避免重覆提交表單，ajax判斷載入是否完成。 ...
  • 一篇教你看懂spring bean工廠和aop
    這篇文章為spring回顧總結的第二篇,本篇主要分為兩個部分,分別是spring的bean工廠的實現.spring的aop實現原理,這兩部分也是面試當中問的比較多的. spring的bean工廠的實現 spring的bean工廠的實現可以有以下三種方式 1. 靜態工廠實現 配置文件: 2. 實例工廠 ...
  • day 16 初試面試對象
    1.初識面向對象 面向過程: 一切以事物的發展流程為中心 面向對象: 一切以對象為中心.一切皆為對象.具體的某一個事務就是對象 打比方: 大象進冰箱 步驟:第一步:開門, 第二步:裝大象,第三:關門 面向對象: 大象,進冰箱 , 此時主語是大象,我操縱的是大象,此時的大象就是對象 2.類,對象 類: ...
  • java三大版本和核心優勢
    javaSE（java standard Edition）：標準版，定位在個人電腦上的應用。 javaEE（java Enterprise Edition）：企業版，定位在伺服器端的應用。*********************************** javaME（java Micro E ...
  • 系統移植——uboot常用命令
    flash的一般分區： print(可縮寫為：pri)：列印查看uboot這個軟體中集成的環境變數setenv、saveenv：設置、保存環境變數 如:設置環境變數： setenv abc 100刪除環境變數： setenv abc保存環境變數到存儲器：saveenv abc 100網路層的設置： ...
  • Docker + .NET Core(一)
    前言： 環境：centos7.5 64 位 正文： 拉取 microsoft/dotnet, 安裝完畢後執行 docker images 可以看到本地已經包含 microsoft/dotnet 使用 docker run 鏡像名 可以啟動鏡像，通過指定參數 it 以交互模式（進入容器內部）啟動。依次 ...
  • Asp.Net Core 輕鬆學-在.Net Core 中使用鉤子
    Host startup hook，是2.2中提供的一項新的功能，通過使用主機啟動鉤子，允許開發人員在不修改代碼的情況下，在服務啟動之前註入代碼；通過使用鉤子，可以對已部署好的服務在服務啟動期間自定義托管程式的行為；通過使用鉤子，可以對服務進行跟蹤或者遙測，也可以在服務啟動前對托管環境進行健康檢查；... ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類