public static async Task<ExternalLogin> GetExternalLoginAsync(this IAuthenticationManager manager, string xsrfKey, string expectedValue)
        {
            var authenticateResult = await manager.AuthenticateAsync(AuthenticationType.ExternalCookie);

            return authenticateResult?.Properties?.Dictionary == null 
                || !authenticateResult.Properties.Dictionary.ContainsKey(xsrfKey) 
                || authenticateResult.Properties.Dictionary[xsrfKey] != expectedValue ? 
                    null : 
                    GetExternalLogin(authenticateResult);
        }
 /// <summary>
 ///     Return the identity associated with the default external authentication type
 /// </summary>
 /// <returns></returns>
 public static async Task<ClaimsIdentity> GetExternalIdentityAsync(this IAuthenticationManager manager,
     string externalAuthenticationType)
 {
     if (manager == null)
     {
         throw new ArgumentNullException("manager");
     }
     var result = await manager.AuthenticateAsync(externalAuthenticationType);
     if (result != null && result.Identity != null &&
         result.Identity.FindFirst(ClaimTypes.NameIdentifier) != null)
     {
         return result.Identity;
     }
     return null;
 }
Beispiel #3
0
        public  static async Task<ExternalLoginInfo> GetExternalLoginInfoWithBeaerAsync(this IAuthenticationManager manager)
        {

            ExternalLoginInfo loginInfo = null;

            var result = await manager.AuthenticateAsync(DefaultAuthenticationTypes.ExternalBearer);

            if (result != null && result.Identity != null)
            {
                var idClaim = result.Identity.FindFirst(ClaimTypes.NameIdentifier);
                if (idClaim != null)
                {
                    loginInfo = new ExternalLoginInfo()
                    {
                        DefaultUserName = result.Identity.Name == null ? "" : result.Identity.Name.Replace(" ", ""),
                        Login = new UserLoginInfo(idClaim.Issuer, idClaim.Value)
                    };
                }
            }
            return loginInfo;
        }
 /// <summary>
 ///     Returns true if there is a TwoFactorRememberBrowser cookie for a user
 /// </summary>
 /// <param name="manager"></param>
 /// <param name="userId"></param>
 /// <returns></returns>
 public static async Task<bool> TwoFactorBrowserRememberedAsync(this IAuthenticationManager manager,
     string userId)
 {
     if (manager == null)
     {
         throw new ArgumentNullException("manager");
     }
     var result =
         await manager.AuthenticateAsync(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);
     return (result != null && result.Identity != null && result.Identity.GetUserId() == userId);
 }
 /// <summary>
 ///     Extracts login info out of an external identity
 /// </summary>
 /// <param name="manager"></param>
 /// <param name="xsrfKey">key that will be used to find the userId to verify</param>
 /// <param name="expectedValue">
 ///     the value expected to be found using the xsrfKey in the AuthenticationResult.Properties
 ///     dictionary
 /// </param>
 /// <returns></returns>
 public static async Task<ExternalLoginInfo> GetExternalLoginInfoAsync(this IAuthenticationManager manager,
     string xsrfKey, string expectedValue)
 {
     if (manager == null)
     {
         throw new ArgumentNullException("manager");
     }
     var result = await manager.AuthenticateAsync(DefaultAuthenticationTypes.ExternalCookie);
     // Verify that the userId is the same as what we expect if requested
     if (result != null &&
         result.Properties != null &&
         result.Properties.Dictionary != null &&
         result.Properties.Dictionary.ContainsKey(xsrfKey) &&
         result.Properties.Dictionary[xsrfKey] == expectedValue)
     {
         return GetExternalLoginInfo(result);
     }
     return null;
 }
 /// <summary>
 ///     Extracts login info out of an external identity
 /// </summary>
 /// <param name="manager"></param>
 /// <returns></returns>
 public static async Task<ExternalLoginInfo> GetExternalLoginInfoAsync(this IAuthenticationManager manager)
 {
     if (manager == null)
     {
         throw new ArgumentNullException("manager");
     }
     return GetExternalLoginInfo(await manager.AuthenticateAsync(DefaultAuthenticationTypes.ExternalCookie));
 }
        public static async Task<bool> TwoFactorBrowserRememberedAsync(this IAuthenticationManager manager, string userId)
        {
            var authenticateResult = await manager.AuthenticateAsync(AuthenticationType.TwoFactorRememberBrowserCookie);

            return authenticateResult?.Identity != null && authenticateResult.Identity.GetUserId() == userId;
        }
        public static async Task<ExternalLogin> GetExternalLoginAsync(this IAuthenticationManager manager)
        {
            var authenticateResult = await manager.AuthenticateAsync(AuthenticationType.ExternalCookie);

            return GetExternalLogin(authenticateResult);
        }
Beispiel #9
0
        public static async Task<string> GetTokenAsync(this AuthenticationManager manager, string signInScheme, string tokenName)
        {
            if (manager == null)
            {
                throw new ArgumentNullException(nameof(manager));
            }
            if (signInScheme == null)
            {
                throw new ArgumentNullException(nameof(signInScheme));
            }
            if (tokenName == null)
            {
                throw new ArgumentNullException(nameof(tokenName));
            }

            var authContext = new AuthenticateContext(signInScheme);
            await manager.AuthenticateAsync(authContext);
            return new AuthenticationProperties(authContext.Properties).GetTokenValue(tokenName);
        }