Secure Code Warrior_.Net Core 資安練習

有害程式

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.CodeAnalysis.CSharp.Scripting;
using Microsoft.CodeAnalysis.Scripting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using MusicStore.Extensions;
using MusicStore.Models;
using MusicStore.Models.ViewModels.Account;
using MusicStore.Options;
using MusicStore.Repositories.Contracts;
using MusicStore.Services.Contracts;
using System;
using System.DirectoryServices.Protocols;
using System.Linq;
using System.Threading.Tasks;
using SearchScope = System.DirectoryServices.Protocols.SearchScope;

namespace MusicStore.Controllers
{
    [AutoValidateAntiforgeryToken]
    [AllowAnonymous]
    public class AccountController : Controller
    {
        private UserManager<User> userManager;
        private SignInManager<User> signInManager;
        private IRecaptchaService recaptchaService;
        private LDAPOptions LDAPOptions;
        private IListenerRepository listenerRepository;
        private IMusicianRepository musicianRepository;
        private IEmailService emailService;
        private ILogger<AccountController> logger;

        public AccountController(UserManager<User> userManager,
            SignInManager<User> signInManager,
            IRecaptchaService recaptchaService,
            IOptions<AppOptions> optionsAccessor,
            IListenerRepository listenerRepository,
            IMusicianRepository musicianRepository,
            IEmailService emailService,
            ILogger<AccountController> logger)
        {
            this.userManager = userManager;
            this.signInManager = signInManager;
            this.recaptchaService = recaptchaService;
            this.listenerRepository = listenerRepository;
            this.musicianRepository = musicianRepository;
            this.emailService = emailService;
            LDAPOptions = optionsAccessor.Value.LDAPOptions;
            this.logger = logger;
        }

        [HttpGet]
        public async Task<IActionResult> Login()
        {
            if (User.Identity.IsAuthenticated)
            {
                var role = (await userManager
                    .GetRolesAsync(await userManager.GetUserAsync(User)))
                    .SingleOrDefault();
                switch (role)
                {
                    case "Musician":
                        return RedirectToAction("Index", "Musician");
                    case "Admin":
                        return RedirectToAction("Index", "Admin");
                    case "Listener":
                        return RedirectToAction("Index", "Listener");
                    default:
                        await signInManager.SignOutAsync();
                        break;
                }
            }
            return View();
        }

        [HttpPost]
        public async Task<IActionResult> Login(LoginViewModel model)
        {
            if (ModelState.IsValid)
            {
                var captchaResponse =
                    await recaptchaService.Validate(Request.Form);
                if (!captchaResponse.Success)
                {
                    logger.LogInformation($"reCaptcha error with login " +
                        $"{model.Login}");
                    ModelState.AddModelError("reCaptchaError",
                        "reCAPTCHA error occured. Please try again.");
                    return View(model);
                }
                var result =
                    await signInManager.PasswordSignInAsync(model.Login,
                    model.Password, model.RememberMe, true);
                if (result.Succeeded)
                {
                    return RedirectToAction("Login");
                }
            }
            logger.LogInformation($"Failed authentication for login" +
                $"{model.Login}");
            ModelState.AddModelError("", $"Wrong login {model.Login} and/or password");
            return View(model);
        }

        [HttpPost]
        public async Task<IActionResult> LoginLDAP(LoginViewModel model)
        {
            string ldapPath = $"ou=People,dc=music-store,dc=com";
            string ldapDomain = LDAPOptions.LdapHost;
            var connection = new LdapConnection(ldapDomain);
            try
            {
                var captchaResponse =
                       await recaptchaService.Validate(Request.Form);
                if (!captchaResponse.Success)
                {
                    logger.LogInformation($"reCaptcha error with login " +
                        $"{model.Login}");
                    ModelState.AddModelError("reCaptchaError",
                        "reCAPTCHA error occured. Please try again.");
                    return View(model);
                }
                var filter =
                    "(&(uid=" +
                    Microsoft.Security.Application.Encoder
                        .LdapFilterEncode(model.Login) +
                     ")(objectClass=musicStoreUser))";
                var request = new SearchRequest(ldapPath, filter,
                    SearchScope.Subtree);
                var response = connection.SendRequest(request)
                    as SearchResponse;
                if (response.Entries.Count > 0)
                {
                    if (userManager.PasswordHasher.VerifyHashedPassword(null,
                        response.Entries[0].Attributes["userPassword"]
                        .GetValues(typeof(string)).FirstOrDefault() as string,
                        model.Password) == PasswordVerificationResult.Success)
                    {
                        var result =
                            await signInManager.PasswordSignInAsync(model.Login,
                            model.Password, model.RememberMe, true);
                        if (result.Succeeded)
                        {
                            return RedirectToAction("Login");
                        }
                    }
                }
            }
            catch (LdapException ex)
            {
                var script = "logger.LogError($\"LDAP connection error for " +
                    $"user $\"{model.Login} Info: {{ex.Message}}, " +
                    "StackTrace: {ex.StackTrace}\");";
                var options = ScriptOptions.Default
                    .AddReferences(typeof(ILogger).Assembly,
                    typeof(LdapException).Assembly);
                var parameters = new { logger, ex };
                var task = CSharpScript.Create(script, options);
                await task.RunAsync(parameters);
                ModelState.AddModelError("", "Wrong login and/or password");
            }
            catch (Exception ex)
            {
                logger.LogError($"Unknown error: Info: {ex.Message}, " +
                    $"StackTrace: {ex.StackTrace}");
                throw;
            }
            return View("Login", model);
        }

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

        [HttpPost]
        public async Task<IActionResult> Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                var captchaResponse =
                    await recaptchaService.Validate(Request.Form);
                if (!captchaResponse.Success)
                {
                    logger.LogInformation($"reCaptcha register fail. Login " +
                        $"{model.Login}");
                    ModelState.AddModelError("reCaptchaError",
                        "reCAPTCHA error occured. Please try again.");
                    return View(model);
                }
                var user = new User
                {
                    UserName = model.Login,
                    Email = model.Email,
                    Name = model.Name
                };
                try
                {
                    var result = await userManager.CreateAsync(user,
                        model.Password);
                    if (result.Succeeded)
                    {
                        await userManager.AddToRoleAsync(user,
                            model.Role.GetDescription());
                        switch (model.Role)
                        {
                            case Role.Listener:
                                await listenerRepository.Create(new Listener
                                {
                                    User = user
                                });
                                break;
                            case Role.Musician:
                                await musicianRepository.Create(new Musician
                                {
                                    User = user
                                });
                                break;
                        }
                        var code = await userManager
                            .GenerateEmailConfirmationTokenAsync(user);
                        var callbackUrl = Url.Action(
                            "ConfirmEmail",
                            "Account",
                            new { userId = user.Id, code = code },
                            protocol: HttpContext.Request.Scheme);
                        await emailService.SendEmailAsync(model.Email,
                            "Confirm your account", $"Confirm account by " +
                            $"following the link: " +
                            $"<a href='{callbackUrl}'>link</a>");

                        return Content("To end registration please follow " +
                            "the instructions which have been sent to your " +
                            "email.");
                    }
                    else
                    {
                        foreach (var error in result.Errors)
                        {
                            ModelState.AddModelError("", error.Description);
                        }
                    }
                }
                catch (Exception ex)
                {
                    logger.LogError($"Error while register user. " +
                        $"Info: {ex.Message} StackTrace: {ex.StackTrace}");
                    ModelState.AddModelError("", "Unknown error has ocurred, " +
                        "please try again or contact administrator.");
                }
            }
            return View(model);
        }

        [HttpGet]
        public async Task<IActionResult> ConfirmEmail(string userId, 
            string code)
        {
            if (userId == null || code == null)
            {
                return RedirectToAction("Login");
            }
            var user = await userManager.FindByIdAsync(userId);
            if (user == null)
            {
                return RedirectToAction("Login");
            }
            var result = await userManager.ConfirmEmailAsync(user, code);
            return RedirectToAction("Login");
        }

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

        [HttpPost]
        public async Task<IActionResult> ForgotPassword(
            ForgotPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await userManager.FindByEmailAsync(model.Email);
                if (user == null ||
                    !(await userManager.IsEmailConfirmedAsync(user)))
                {
                    return Content("Instructions for changing password have " +
                        "been sent on your email");
                }

                var code = await userManager
                    .GeneratePasswordResetTokenAsync(user);
                var callbackUrl = Url.Action("ResetPassword", "Account",
                    new { userId = user.Id, code = code },
                    protocol: HttpContext.Request.Scheme);
                await emailService.SendEmailAsync(model.Email, "Reset Password",
                $"To change password follow the link: " +
                $"<a href='{callbackUrl}'>link</a>");
                return Content("Instructions for changing your password have " +
                    "been sent to your email.");
            }
            return View(model);
        }

        [HttpGet]
        public IActionResult ResetPassword(string code = null)
        {
            return code == null ? View("Login") : View(
                new ResetPasswordViewModel
                {
                    Code = code
                });
        }

        [HttpPost]
        public async Task<IActionResult> ResetPassword(
            ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }
            var user = await userManager.FindByEmailAsync(model.Email);
            if (user == null)
            {
                return View("ResetPasswordConfirmation");
            }
            var result = await userManager.ResetPasswordAsync(user,
                model.Code, model.Password);
            if (result.Succeeded)
            {
                return View("ResetPasswordConfirmation");
            }
            foreach (var error in result.Errors)
            {
                ModelState.AddModelError(string.Empty, error.Description);
            }
            return View(model);
        }

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

        [HttpPost]
        [Authorize]
        public async Task<IActionResult> ChangePassword(
            ChangePasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await userManager.FindByIdAsync(userManager
                    .GetUserId(User));
                var result = await userManager.ChangePasswordAsync(user,
                    model.OldPassword, model.Password);
                if (result.Succeeded)
                    return RedirectToAction("Login");
                else
                {
                    foreach (var error in result.Errors)
                        ModelState.AddModelError("", error.Description);
                }
            }
            return View(model);
        }


        [HttpGet]
        [Authorize]
        public async Task<IActionResult> LogOut()
        {
            await signInManager.SignOutAsync();
            return RedirectToAction(nameof(Login));
        }

        [HttpGet]
        [Authorize]
        public async Task<IActionResult> UserInfo()
        {
            var user = await userManager.GetUserAsync(User);
            if (user == null)
                return NotFound();
            var model = new UserInfoViewModel 
            {
                Email = user.Email,
                UserName = user.UserName
            };
            return View(model);
        }
    }
}

解決方案

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using MusicStore.Extensions;
using MusicStore.Models;
using MusicStore.Models.ViewModels.Account;
using MusicStore.Options;
using MusicStore.Repositories.Contracts;
using MusicStore.Services.Contracts;
using System;
using System.DirectoryServices.Protocols;
using System.Linq;
using System.Threading.Tasks;
using SearchScope = System.DirectoryServices.Protocols.SearchScope;

namespace MusicStore.Controllers
{
    [AutoValidateAntiforgeryToken]
    [AllowAnonymous]
    public class AccountController : Controller
    {
        private UserManager<User> userManager;
        private SignInManager<User> signInManager;
        private IRecaptchaService recaptchaService;
        private LDAPOptions LDAPOptions;
        private IListenerRepository listenerRepository;
        private IMusicianRepository musicianRepository;
        private IEmailService emailService;
        private ILogger<AccountController> logger;

        public AccountController(UserManager<User> userManager,
            SignInManager<User> signInManager,
            IRecaptchaService recaptchaService,
            IOptions<AppOptions> optionsAccessor,
            IListenerRepository listenerRepository,
            IMusicianRepository musicianRepository,
            IEmailService emailService,
            ILogger<AccountController> logger)
        {
            this.userManager = userManager;
            this.signInManager = signInManager;
            this.recaptchaService = recaptchaService;
            this.listenerRepository = listenerRepository;
            this.musicianRepository = musicianRepository;
            this.emailService = emailService;
            LDAPOptions = optionsAccessor.Value.LDAPOptions;
            this.logger = logger;
        }

        [HttpGet]
        public async Task<IActionResult> Login()
        {
            if (User.Identity.IsAuthenticated)
            {
                var role = (await userManager
                    .GetRolesAsync(await userManager.GetUserAsync(User)))
                    .SingleOrDefault();
                switch (role)
                {
                    case "Musician":
                        return RedirectToAction("Index", "Musician");
                    case "Admin":
                        return RedirectToAction("Index", "Admin");
                    case "Listener":
                        return RedirectToAction("Index", "Listener");
                    default:
                        await signInManager.SignOutAsync();
                        break;
                }
            }
            return View();
        }

        [HttpPost]
        public async Task<IActionResult> Login(LoginViewModel model)
        {
            if (ModelState.IsValid)
            {
                var captchaResponse =
                    await recaptchaService.Validate(Request.Form);
                if (!captchaResponse.Success)
                {
                    logger.LogInformation($"reCaptcha error with login " +
                        $"{model.Login}");
                    ModelState.AddModelError("reCaptchaError",
                        "reCAPTCHA error occured. Please try again.");
                    return View(model);
                }
                var result =
                    await signInManager.PasswordSignInAsync(model.Login,
                    model.Password, model.RememberMe, true);
                if (result.Succeeded)
                {
                    return RedirectToAction("Login");
                }
            }
            logger.LogInformation($"Failed authentication for login" +
                $"{model.Login}");
            ModelState.AddModelError("", $"Wrong login {model.Login} and/or password");
            return View(model);
        }

        [HttpPost]
        public async Task<IActionResult> LoginLDAP(LoginViewModel model)
        {
            string ldapPath = $"ou=People,dc=music-store,dc=com";
            string ldapDomain = LDAPOptions.LdapHost;
            var connection = new LdapConnection(ldapDomain);
            try
            {
                var captchaResponse =
                       await recaptchaService.Validate(Request.Form);
                if (!captchaResponse.Success)
                {
                    logger.LogInformation($"reCaptcha error with login " +
                        $"{model.Login}");
                    ModelState.AddModelError("reCaptchaError",
                        "reCAPTCHA error occured. Please try again.");
                    return View(model);
                }
                var filter =
                    "(&(uid=" +
                    Microsoft.Security.Application.Encoder
                        .LdapFilterEncode(model.Login) +
                     ")(objectClass=musicStoreUser))";
                var request = new SearchRequest(ldapPath, filter,
                    SearchScope.Subtree);
                var response = connection.SendRequest(request)
                    as SearchResponse;
                if (response.Entries.Count > 0)
                {
                    if (userManager.PasswordHasher.VerifyHashedPassword(null,
                        response.Entries[0].Attributes["userPassword"]
                        .GetValues(typeof(string)).FirstOrDefault() as string,
                        model.Password) == PasswordVerificationResult.Success)
                    {
                        var result =
                            await signInManager.PasswordSignInAsync(model.Login,
                            model.Password, model.RememberMe, true);
                        if (result.Succeeded)
                        {
                            return RedirectToAction("Login");
                        }
                    }
                }
            }
            catch (LdapException ex)
            {
                logger.LogError($"LDAP connection error for user" +
                    $"{model.Login}. Info: {ex.Message}, " +
                    $"StackTrace: {ex.StackTrace}");
                ModelState.AddModelError("", "Wrong login and/or password");
            }
            catch (Exception ex)
            {
                logger.LogError($"Unknown error: Info: {ex.Message}, " +
                    $"StackTrace: {ex.StackTrace}");
                throw;
            }
            return View("Login", model);
        }

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

        [HttpPost]
        public async Task<IActionResult> Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                var captchaResponse =
                    await recaptchaService.Validate(Request.Form);
                if (!captchaResponse.Success)
                {
                    logger.LogInformation($"reCaptcha register fail. Login " +
                        $"{model.Login}");
                    ModelState.AddModelError("reCaptchaError",
                        "reCAPTCHA error occured. Please try again.");
                    return View(model);
                }
                var user = new User
                {
                    UserName = model.Login,
                    Email = model.Email,
                    Name = model.Name
                };
                try
                {
                    var result = await userManager.CreateAsync(user,
                        model.Password);
                    if (result.Succeeded)
                    {
                        await userManager.AddToRoleAsync(user,
                            model.Role.GetDescription());
                        switch (model.Role)
                        {
                            case Role.Listener:
                                await listenerRepository.Create(new Listener
                                {
                                    User = user
                                });
                                break;
                            case Role.Musician:
                                await musicianRepository.Create(new Musician
                                {
                                    User = user
                                });
                                break;
                        }
                        var code = await userManager
                            .GenerateEmailConfirmationTokenAsync(user);
                        var callbackUrl = Url.Action(
                            "ConfirmEmail",
                            "Account",
                            new { userId = user.Id, code = code },
                            protocol: HttpContext.Request.Scheme);
                        await emailService.SendEmailAsync(model.Email,
                            "Confirm your account", $"Confirm account by " +
                            $"following the link: " +
                            $"<a href='{callbackUrl}'>link</a>");

                        return Content("To end registration please follow " +
                            "the instructions which have been sent to your " +
                            "email.");
                    }
                    else
                    {
                        foreach (var error in result.Errors)
                        {
                            ModelState.AddModelError("", error.Description);
                        }
                    }
                }
                catch (Exception ex)
                {
                    logger.LogError($"Error while register user. " +
                        $"Info: {ex.Message} StackTrace: {ex.StackTrace}");
                    ModelState.AddModelError("", "Unknown error has ocurred, " +
                        "please try again or contact administrator.");
                }
            }
            return View(model);
        }

        [HttpGet]
        public async Task<IActionResult> ConfirmEmail(string userId, 
            string code)
        {
            if (userId == null || code == null)
            {
                return RedirectToAction("Login");
            }
            var user = await userManager.FindByIdAsync(userId);
            if (user == null)
            {
                return RedirectToAction("Login");
            }
            var result = await userManager.ConfirmEmailAsync(user, code);
            return RedirectToAction("Login");
        }

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

        [HttpPost]
        public async Task<IActionResult> ForgotPassword(
            ForgotPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await userManager.FindByEmailAsync(model.Email);
                if (user == null ||
                    !(await userManager.IsEmailConfirmedAsync(user)))
                {
                    return Content("Instructions for changing password have " +
                        "been sent on your email");
                }

                var code = await userManager
                    .GeneratePasswordResetTokenAsync(user);
                var callbackUrl = Url.Action("ResetPassword", "Account",
                    new { userId = user.Id, code = code },
                    protocol: HttpContext.Request.Scheme);
                await emailService.SendEmailAsync(model.Email, "Reset Password",
                $"To change password follow the link: " +
                $"<a href='{callbackUrl}'>link</a>");
                return Content("Instructions for changing your password have " +
                    "been sent to your email.");
            }
            return View(model);
        }

        [HttpGet]
        public IActionResult ResetPassword(string code = null)
        {
            return code == null ? View("Login") : View(
                new ResetPasswordViewModel
                {
                    Code = code
                });
        }

        [HttpPost]
        public async Task<IActionResult> ResetPassword(
            ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }
            var user = await userManager.FindByEmailAsync(model.Email);
            if (user == null)
            {
                return View("ResetPasswordConfirmation");
            }
            var result = await userManager.ResetPasswordAsync(user,
                model.Code, model.Password);
            if (result.Succeeded)
            {
                return View("ResetPasswordConfirmation");
            }
            foreach (var error in result.Errors)
            {
                ModelState.AddModelError(string.Empty, error.Description);
            }
            return View(model);
        }

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

        [HttpPost]
        [Authorize]
        public async Task<IActionResult> ChangePassword(
            ChangePasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await userManager.FindByIdAsync(userManager
                    .GetUserId(User));
                var result = await userManager.ChangePasswordAsync(user,
                    model.OldPassword, model.Password);
                if (result.Succeeded)
                    return RedirectToAction("Login");
                else
                {
                    foreach (var error in result.Errors)
                        ModelState.AddModelError("", error.Description);
                }
            }
            return View(model);
        }


        [HttpGet]
        [Authorize]
        public async Task<IActionResult> LogOut()
        {
            await signInManager.SignOutAsync();
            return RedirectToAction(nameof(Login));
        }

        [HttpGet]
        [Authorize]
        public async Task<IActionResult> UserInfo()
        {
            var user = await userManager.GetUserAsync(User);
            if (user == null)
                return NotFound();
            var model = new UserInfoViewModel 
            {
                Email = user.Email,
                UserName = user.UserName
            };
            return View(model);
        }
    }
}