.net core identity 集成 github (一)

首先 nuget 需要引用相关的包

EF

Microsoft.EntityFrameworkCore

Microsoft.EntityFrameworkCore.Tools

Microsoft.EntityFrameworkCore.SqlServer

Microsoft.EntityFrameworkCore.Design

支持延迟加载

Microsoft.EntityFrameworkCore.Proxies

 

Identity

Microsoft.AspNetCore.Identity

Microsoft.AspNetCore.Identity.EntityFrameworkCore

集成GitHub

AspNet.Security.OAuth.GitHub

配置GitHub 应用 ClientID ClientSecrets

登录GitHub

 

 

 

 按自己的需要配置

 

配置完 就有 ClientID ClientSecrets

 

appsettings.json GitHub配置

  "Authentication": {
    "GitHub": {
      "AppID": "你的ID",
      "ClientID": "你的ClientID",
      "ClientSecrets": "你的ClientSecrets"

    },

核心代码

//身份验证配置
builder.Services.AddAuthentication(options =>
{
    //cookie解决方案
    options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;

}).AddCookie(options =>
{
    //过期时间 60分钟
    options.ExpireTimeSpan = TimeSpan.FromMinutes(60);
    //开启滑动过期
    options.SlidingExpiration = true;
}).AddGitHub(options =>
{
    //集成GitHub
    options.ClientId = builder.Configuration["Authentication:GitHub:ClientID"];
    options.ClientSecret = builder.Configuration["Authentication:GitHub:ClientSecrets"];
    //读取 email 默认没有设置读取不到
    options.Scope.Add("user:email");
});
//数据库设置和注入
builder.Services.AddDbContext<ShopAppContext>(options =>
{
    string con = builder.Configuration.GetConnectionString("con");
    options.UseLazyLoadingProxies();
    options.UseSqlServer(con);
});
//identity设置
builder.Services.Configure<IdentityOptions>(options =>
{
    //最多失误次数锁定
    options.Lockout.MaxFailedAccessAttempts = 5;
    //每次锁定15分钟
    options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(15);
    //登陆必须是邮件确认的
    options.SignIn.RequireConfirmedEmail = true;

    //自定义邮箱token生成提供程序
    options.Tokens.EmailConfirmationTokenProvider = "CustomEmailConfirmation";

    //密码设置
    options.Password.RequiredLength = 6;
    options.Password.RequiredUniqueChars = 3;
    options.Password.RequireNonAlphanumeric = false;
    options.Password.RequireLowercase = false;
    options.Password.RequireUppercase = false;
    options.Password.RequireDigit = false;

});
//identity注入
builder.Services.AddIdentity<ApplicationUser, IdentityRole>()
    .AddErrorDescriber<CustomIdentityErrorDescriber>()
    .AddEntityFrameworkStores<ShopAppContext>()
    .AddDefaultTokenProviders()
  //  .AddTokenProvider<CustomEmailConfirmationTokenProvider<ApplicationUser>>("CustomEmailConfirmation")
    ;

 

AccountController 

 public class AccountController : Controller
    {
        private readonly SignInManager<ApplicationUser> _signInManager;
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly ILogger<AccountController> _logger;
        public AccountController(UserManager<ApplicationUser> userManager,
            SignInManager<ApplicationUser> signInManager,
            ILogger<AccountController> logger)
        {
            _userManager = userManager;
            _signInManager = signInManager;
            _logger = logger;
        }

        [HttpGet]
        public IActionResult Register()
        {
            return View();
        }


        [HttpPost]
        public async Task<IActionResult> RegisterAsync(RegisterViewModel viewModel)
        {
            if (ModelState.IsValid)
            {
                ApplicationUser user = await this._userManager.FindByNameAsync(viewModel.Email);
                if (user != null)
                {
                    ModelState.AddModelError("error", $"Email:{viewModel.Email}，已注册！");
                    return View();
                }
                else
                {
                    user = new ApplicationUser
                    {
                        UserName = viewModel.Email,
                        Email = viewModel.Email,
                    };
                    var result = await _userManager.CreateAsync(user, viewModel.Password);
                    if (result.Succeeded)
                    {

                        string token = await this._userManager.GenerateEmailConfirmationTokenAsync(user);
                        string confirmEmailLink = Url.Action("ConfirmEmail", "Account", new { userID = user.Id, token = token }, Request.Scheme);
                        this._logger.Log(LogLevel.Error, confirmEmailLink);
                        ViewBag.ErrorTitle = "注册成功";
                        ViewBag.ErrorMessage = $"在你登入系统前,我们已经给您发了一份邮件，需要您先进行邮件验证，点击确认链接即可完成。";
                        return View("Error");
                        //await _signInManager.SignInAsync(user, isPersistent: false);
                        //bool s = _signInManager.IsSignedIn(User);
                        //return RedirectToAction("Index", "Home");
                    }
                    foreach (var error in result.Errors)
                    {
                        ModelState.AddModelError("error", error.Description);
                    }
                }
            }
            return View();
        }




        [HttpGet]
        public async Task<IActionResult> LogoutAsync()
        {
            await _signInManager.SignOutAsync();
            return RedirectToAction("Index", "Home");
        }


        [HttpGet]
        public async Task<IActionResult> LoginAsync(string ReturlUrl)
        {
            LoginViewModel loginViewModel = new LoginViewModel
            {
                ReturnUrl = ReturlUrl,
                ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList()
            };

            return View(loginViewModel);
        }


        //[HttpPost]
        //public async Task<IActionResult> LoginAsync(LoginViewModel viewModel)
        //{
        //    if (ModelState.IsValid)
        //    {
        //        var result = await _signInManager.PasswordSignInAsync(viewModel.Email, viewModel.Password, viewModel.RememberMe, true);
        //        if (result.Succeeded)
        //        {
        //            return RedirectToAction("Index", "Home");
        //        }
        //        else
        //        {
        //            ModelState.AddModelError("error", "登录失败请重试");
        //        }
        //    }
        //    return View(viewModel);
        //}

        [HttpPost]
        [AllowAnonymous]
        public async Task<IActionResult> LoginAsync(LoginViewModel viewModel, string? ReturlUrl)
        {
            viewModel.ExternalLogins = (await this._signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
            if (ModelState.IsValid)
            {
                ApplicationUser applicationUser = new ApplicationUser
                {
                    UserName = viewModel.Email,
                    Email = viewModel.Email,
                };
                ApplicationUser resultUser = await this._userManager.FindByEmailAsync(viewModel.Email);
                bool checkPasswordResult = await this._userManager.CheckPasswordAsync(applicationUser, viewModel.Password);
                //1:通过邮箱查找的用户不能为空2:验证密码用户是否存在3:邮箱是否确认
                if (resultUser != null && !resultUser.EmailConfirmed && checkPasswordResult)
                {
                    ModelState.AddModelError("error", "邮箱未确认");
                    return View(viewModel);
                }
                //开启锁定
                var signInResult = await this._signInManager.PasswordSignInAsync(resultUser,
                    viewModel.Password,
                     viewModel.RememberMe, true);
                if (signInResult.Succeeded)
                {
                    if (!string.IsNullOrEmpty(ReturlUrl))
                    {
                        LocalRedirect(ReturlUrl);
                    }
                    else
                    {
                        return RedirectToAction("Index", "Home");
                    }
                }



                //如果用户已经锁定了
                if (signInResult.IsLockedOut)
                {
                    return View("AccountLocked");
                }


                ModelState.AddModelError("error", "登陆失败");
            }
            return View(viewModel);
        }


        /// <summary>
        /// 外部登录
        /// </summary>
        /// <param name="provider"></param>
        /// <param name="returnUrl"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult ExternalLogin(string provider, string returnUrl)
        {
            var redirectUrl = Url.Action("ExternalLoginCallback", "Account",
                                new { ReturnUrl = returnUrl });
            var properties = _signInManager
                .ConfigureExternalAuthenticationProperties(provider, redirectUrl);
            return new ChallengeResult(provider, properties);
        }

        /// <summary>
        /// 外部登录回调
        /// </summary>
        /// <param name="returnUrl"></param>
        /// <param name="remoteError"></param>
        /// <returns></returns>
    /*    public async Task<IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null)
        {
            returnUrl = returnUrl ?? Url.Content("~/");
            LoginViewModel loginViewModel = new LoginViewModel
            {
                ReturnUrl = returnUrl,
                ExternalLogins = (await this._signInManager.GetExternalAuthenticationSchemesAsync()).ToList()
            };
            ExternalLoginInfo info = await this._signInManager.GetExternalLoginInfoAsync();
            //获取第三方用户的邮箱
            string email = info.Principal.FindFirstValue(ClaimTypes.Email);
            if (!string.IsNullOrEmpty(email))
            {

                //查找第三方用户的邮箱 本地数据库中是否有该用户
                ApplicationUser user = await this._userManager.FindByEmailAsync(email);
                //如果该用户邮箱没有确认
                if (user != null && !user.EmailConfirmed)
                //if (user != null)
                {
                    ModelState.AddModelError(string.Empty, "您的电子邮箱还未进行验证。");
                    return View("Login", loginViewModel);
                }
            }
            var signResult = await this._signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, false, bypassTwoFactor: true);
            if (signResult.Succeeded)
            {
                //如果登录了就不用创建用户 直接跳转
                return LocalRedirect(returnUrl);
            }
            else
            {             
                ApplicationUser applicationUser = new ApplicationUser
                {
                    UserName = info.Principal.FindFirstValue(ClaimTypes.Email),
                    Email = info.Principal.FindFirstValue(ClaimTypes.Email)
                };
                var createResult = await this._userManager.CreateAsync(applicationUser);
                if (createResult.Succeeded)
                {
                    await this._userManager.AddLoginAsync(applicationUser, info);
                    await this._signInManager.SignInAsync(applicationUser, isPersistent: false);
                }
                return RedirectToAction("Index", "Home");
            }
            ViewBag.ErrorTitle = $"我们无法从提供商:{info.LoginProvider}中解析到您的邮件地址 ";
            ViewBag.ErrorMessage = "请通过联系 ltm@ddxc.org 寻求技术支持。";
            return View("Error");
        }
*/


        /// <summary>
        /// 外部登录回调
        /// </summary>
        /// <param name="returnUrl"></param>
        /// <param name="remoteError"></param>
        /// <returns></returns>
        public async Task<IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null)
        {
            returnUrl = returnUrl ?? Url.Content("~/");
            var externalInfo = await this._signInManager.GetExternalLoginInfoAsync();
            string externalEmail = externalInfo.Principal.FindFirstValue(ClaimTypes.Email);
            ApplicationUser applicationUser = null;
            if (externalEmail != null)
            {
                //如果 第三方邮箱不等于空 我要判断该邮箱在本地是否确认过
                applicationUser = await this._userManager.FindByEmailAsync(externalEmail);
                if (applicationUser != null && !applicationUser.EmailConfirmed)
                {
                    //用户不等于空 并且邮箱没有确认
                    ModelState.AddModelError(string.Empty, "您的电子邮箱还未进行验证。");
                    LoginViewModel loginViewModel = new LoginViewModel
                    {
                        ExternalLogins = (await this._signInManager.GetExternalAuthenticationSchemesAsync()).ToList(),
                        ReturnUrl = returnUrl
                    };
                    return View("Login", loginViewModel);
                }
            }
            //如果邮箱确认过 我需要判断 该用户否有已经登陆
            var externalLoginSignResult = await this._signInManager
                .ExternalLoginSignInAsync(externalInfo.LoginProvider,
                externalInfo.ProviderKey, false, true);
            if (externalLoginSignResult.Succeeded)
            {
                return LocalRedirect(returnUrl);
            }
            else
            {
                if (externalEmail != null)
                {
                    if (applicationUser == null)
                    {
                        applicationUser = new ApplicationUser
                        {
                            UserName = externalInfo.Principal.FindFirstValue(ClaimTypes.Email),
                            Email = externalInfo.Principal.FindFirstValue(ClaimTypes.Email),
                        };
                        await this._userManager.CreateAsync(applicationUser);
                        string token = await this._userManager.GenerateEmailConfirmationTokenAsync(applicationUser);
                        
                        string confirmationLink = Url.Action("ConfirmEmail", "Account",
                             new { userID = applicationUser.Id, token = token }, Request.Scheme);
                        _logger.Log(LogLevel.Warning, confirmationLink);
                        ViewBag.ErrorTitle = "注册成功";
                        ViewBag.ErrorMessage = $"在你登入系统前,我们已经给您发了一份邮件，需要您先进行邮件验证，点击确认链接即可完成。";
                        return View("Error");
                    }

                    //如果 applicationUser 不等于空 我就直接登陆
                    await this._userManager.AddLoginAsync(applicationUser, externalInfo);
                    await this._signInManager.SignInAsync(applicationUser, false);
                    return LocalRedirect(returnUrl);
                }
                // 如果我们获取不到电子邮件地址，我们需要将请求重定向到错误视图中。
                ViewBag.ErrorTitle = $"我们无法从提供商:{externalInfo.LoginProvider}中解析到您的邮件地址 ";
                ViewBag.ErrorMessage = "请通过联系 ltm@ddxc.org 寻求技术支持。";
                return View("Error");
            }

        }


        /// <summary>
        /// 确认邮件
        /// </summary>
        /// <param name="userID"></param>
        /// <param name="token"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<IActionResult> ConfirmEmailAsync(string userID, string token)
        {
            if (string.IsNullOrEmpty(userID) && string.IsNullOrEmpty(token))
            {
                return RedirectToAction("Index", "Home");
            }

            var user = await this._userManager.FindByIdAsync(userID);
            if (user == null)
            {
                ViewBag.ErrorTitle = $"当前id{userID}无效";
                ViewBag.ErrorMessage = "请通过联系 ltm@ddxc.org 寻求技术支持。";
                return View("Error");
            }

            var result = await this._userManager.ConfirmEmailAsync(user, token);
            if (result.Succeeded)
            {
                return View();
            }
            else
            {
                ViewBag.ErrorTitle = $"邮箱验证失败";
                ViewBag.ErrorMessage = $"邮箱验证失败";
                return View("Error");
            }
        }



        /// <summary>
        /// 拒绝访问
        /// </summary>
        /// <param name="ReturnUrl"></param>
        /// <returns></returns>
        [HttpGet]
        public IActionResult AccessDenied(string ReturnUrl)
        {
            //防止开放式攻击
            if (!string.IsNullOrEmpty(ReturnUrl) && Url.IsLocalUrl(ReturnUrl))
            {
                if (ReturnUrl.Contains("Back"))
                {
                    return RedirectToAction("Index", "Home");
                }
                else
                {
                    return Redirect(ReturnUrl);
                }
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }


        #region 激活用户
        [HttpGet]
        public IActionResult ActivateUserEmail()
        {
            return View();
        }


        [HttpPost]
        public async Task<IActionResult> ActivateUserEmail(EmailAddressViewModel emailAddress)
        {
            if (ModelState.IsValid)
            {
                var user = await this._userManager.FindByEmailAsync(emailAddress.Email);
                if (user != null)
                {
                    bool isConfirmedResult = await this._userManager.IsEmailConfirmedAsync(user);
                    if (!isConfirmedResult)
                    {
                        string token = await this._userManager.GenerateEmailConfirmationTokenAsync(user);

                        string urlStr = Url.Action("ConfirmEmail", "Acccount", new { userID = user.Id, token = token }, Request.Scheme);

                        ViewBag.Message = "如果你在我们系统有注册账户，我们已经发了邮件到您的邮箱中，请前往邮箱激活您的用户。";
                        //重定向用户到忘记密码确认视图
                        return View("ActivateUserEmailConfirmation", ViewBag.Message);
                    }
                }
            }

            ViewBag.Message = "请确认邮箱是否存在异常，现在我们无法给您发送激活链接。";
            // 为了避免帐户枚举和暴力攻击，所以不进行用户不存在或邮箱未验证的提示
            return View("ActivateUserEmailConfirmation", ViewBag.Message);
        }
        #endregion

        #region 忘记密码功能 

        [HttpGet]

        public IActionResult ForgotPassword()
        {
            return View();
        }

        [HttpPost]

        public async Task<IActionResult> ForgotPassword(EmailAddressViewModel emailAddress)
        {
            if (ModelState.IsValid)
            {
                var user = await this._userManager.FindByEmailAsync(emailAddress.Email);
                if (user != null && user.EmailConfirmed)
                {
                    string token = await this._userManager.GeneratePasswordResetTokenAsync(user);
                    string passwordResetLink = Url.Action("ResetPassword", "Acccount", new { userID = user.Id, token = token }, Request.Scheme);
                    // 将密码重置链接记录到文件中
                    _logger.Log(LogLevel.Warning, passwordResetLink);

                    //重定向用户到忘记密码确认视图
                    return View("ForgotPasswordConfirmation");
                }
                // 为了避免帐户枚举和暴力攻击，所以不进行用户不存在或邮箱未验证的提示
                return View("ForgotPasswordConfirmation");
            }
            return View(emailAddress);
        }


        [HttpGet]
        public IActionResult ResetPassword(string token, string email)
        {

            //如果密码重置令牌或电子邮件为空，则有可能是用户在试图篡改密码重置链接
            if (token == null || email == null)
            {
                ModelState.AddModelError("", "无效的密码重置令牌");
            }
            return View();
        }
        [HttpPost]
        public async Task<IActionResult> ResetPassword(ResetPasswordViewModel viewModel)
        {

            if (ModelState.IsValid)
            {
                var user = await this._userManager.FindByEmailAsync(viewModel.Email);
                if (user != null)
                {
                    var result = await this._userManager.ResetPasswordAsync(user, viewModel.Token, viewModel.ConfirmPassword);

                    if (result.Succeeded)
                    {
                        if (await this._userManager.IsLockedOutAsync(user))
                        {
                            //重置 锁定时间
                            await this._userManager.SetLockoutEndDateAsync(user, DateTime.UtcNow);
                            //重置 锁定次数
                            await this._userManager.ResetAccessFailedCountAsync(user);
                        }
                        return View("ResetPasswordConfirmation");
                    }
                    //显示验证错误信息。触发行为，当密码重置令牌已用，或密码复杂性规则不符合标准时
                    foreach (var error in result.Errors)
                    {
                        ModelState.AddModelError("", error.Description);
                    }
                    return View(viewModel);
                }
                // 为了避免帐户枚举和暴力攻击，不要提示用户不存在               
                return View("ResetPasswordConfirmation");
            }


            return View(viewModel);
        }


        #endregion
    }

 

Login.cshtml 视图

@using Shop.ViewModels
@model LoginViewModel
<h4>登录</h4>
<form class="form-horizontal" method="post">
    <div class="alert" asp-validation-summary="All"></div>
    <div class="control-group">
        <label class="control-label" asp-for="Email">邮箱</label>
        <div class="controls">
            <input type="text" asp-for="Email" placeholder="Email">
        </div>
    </div>
    <div class="control-group">
        <label class="control-label" asp-for="Password">密码</label>
        <div class="controls">
            <input type="password" asp-for="Password" placeholder="Password">
        </div>
    </div>
    <div class="control-group">
        <div class="controls">
            <label class="checkbox">
                <input type="checkbox" asp-for="RememberMe">记住我
            </label>
            <button type="submit" class="btn">登录</button>
        </div>
    </div>
</form>

<div class="col-md-6 border-left ">
    <h1>扩展登录</h1><hr />
    <form class="mt-3" method="post" asp-action="ExternalLogin" asp-controller="Account" asp-route-returnUrl="@Model.ReturnUrl">
        <div>

            @foreach (var provider in Model.ExternalLogins)
            {
                <button type="submit" class="btn btn-info"
                    name="provider" value="@provider.Name"
                    title="Log in using your @provider.DisplayName account">
                    @provider.DisplayName
                </button>
            }
        </div>
    </form>
</div>

Register.cshtml 视图

@using Shop.ViewModels
@model RegisterViewModel
@{
    ViewBag.Title = "注册";
}


<h1>用户注册</h1>

<div class="row">
    <div class="col-md-12">
        <form method="post">
            <div asp-validation-summary="All" class="text-danger"></div>
            <div class="form-group">
                <label asp-for="Email"></label>
                <input asp-for="Email" class="form-control" />
                <span asp-validation-for="Email" class="text-danger"></span>
            </div>
            <div class="form-group">
                <label asp-for="Password"></label>
                <input asp-for="Password" class="form-control" />
                <span asp-validation-for="Password" class="text-danger"></span>
            </div>
            <div class="form-group">
                <label asp-for="ConfirmPassword"></label>
                <input asp-for="ConfirmPassword" class="form-control" />
                <span asp-validation-for="ConfirmPassword" class="text-danger"></span>
            </div>
            <button type="submit" class="btn btn-primary">注册</button>
        </form>
    </div>
</div>

ResetPassword.cshtml 视图

@using Shop.ViewModels
@model ResetPasswordViewModel

<h2>重置密码</h2>
<hr />
<div class="row">
    <div class="col-md-12">
        <form method="post">
            <div asp-validation-summary="All" class="text-danger"></div>
            <input asp-for="Token" type="hidden" />
            <input asp-for="Email" type="hidden" />
            <div class="form-group">
                <label asp-for="Password"></label>
                <input asp-for="Password" class="form-control" />
                <span asp-validation-for="Password" class="text-danger"></span>
            </div>
            <div class="form-group">
                <label asp-for="ConfirmPassword"></label>
                <input asp-for="ConfirmPassword" class="form-control" />
                <span asp-validation-for="ConfirmPassword" class="text-danger"></span>
            </div>
            <button type="submit" class="btn btn-primary">重置</button>
        </form>
    </div>
</div>

ResetPasswordConfirmation.cshtml 视图

@using Shop.ViewModels
@model ResetPasswordViewModel

<h2>重置密码</h2>
<hr />
<div class="row">
    <div class="col-md-12">
        <form method="post">
            <div asp-validation-summary="All" class="text-danger"></div>
            <input asp-for="Token" type="hidden" />
            <input asp-for="Email" type="hidden" />
            <div class="form-group">
                <label asp-for="Password"></label>
                <input asp-for="Password" class="form-control" />
                <span asp-validation-for="Password" class="text-danger"></span>
            </div>
            <div class="form-group">
                <label asp-for="ConfirmPassword"></label>
                <input asp-for="ConfirmPassword" class="form-control" />
                <span asp-validation-for="ConfirmPassword" class="text-danger"></span>
            </div>
            <button type="submit" class="btn btn-primary">重置</button>
        </form>
    </div>
</div>

AccountLocked.cshtml 视图

<label class="error">账户被锁定</label>

<a asp-action="ForgotPassword" asp-controller="Account">点击重置密码</a>

ActivateUserEmail.cshtml 视图

@using Shop.ViewModels
@model EmailAddressViewModel

<h2>激活邮箱</h2>
<hr />
<div class="row">
    <div class="col-md-12">
        <form method="post">
            <div asp-validation-summary="All" class="text-danger"></div>
            <div class="form-group">
                <label asp-for="Email"></label>
                <input asp-for="Email" class="form-control" />
                <span asp-validation-for="Email" class="text-danger"></span>
            </div>
            <button type="submit" class="btn btn-primary">提交</button>
        </form>
    </div>
</div>

ActivateUserEmailConfirmation.cshtml 视图

<h1 class="text-info">邮件发送通知</h1>
<h4 class="text-secondary">
    @ViewBag.Message

</h4>

ForgotPassword.cshtml 视图 这个没写

@{
}

 

测试

 

 

 

 邮箱验证

 

 验证成功集成github用户