c# - existing - .NET Core Identity como UI cancelando Registro

asp.net identity

Question

Quiero cancelar la opción ''Registrar'' en una aplicación .NET Core 2.1 + Identity como UI.

Por supuesto, puedo simplemente quitar el botón de la página, la pregunta es: ¿es seguro?

Si no, ¿cuáles son mis otras opciones? ¿Debo usar andamios para generar el código de registro y luego deshabilitarlo allí?

(lo mismo ocurre con SetPassword, etc.)

Gracias

Answer 1

Desafortunadamente, las otras dos respuestas son incorrectas: la pregunta en realidad se refiere a la nueva extensión AddDefaultIdentity () que utiliza las páginas de Razor para ofrecer una IU predeterminada. La respuesta que resuelva esto no eliminará la funcionalidad de registro como se solicita en la pregunta.

Fondo

AddDefaultIdentity funciona de manera similar a AddIdentity, pero también incluye una llamada a AddDefaultUI que le da a su aplicación acceso a las nuevas vistas de la máquina de afeitar de Identidad (actualmente 28 de ellas), están en una nueva biblioteca de clases de máquinas de afeitar. Tenga en cuenta que esta no es la única diferencia entre AddDefaultIdentity y AddIdentity (ver más adelante).

Para cambiar las vistas predeterminadas, debe anular ("andamio") las vistas en su proyecto y luego puede modificarlas. Si no anula las vistas, o si las anula y luego elimina los archivos cshtml, simplemente volverá a las versiones de la interfaz de usuario predeterminadas. Incluso si elimina los enlaces para, por ejemplo, registrarse, el usuario todavía puede navegar a la vista de registro predeterminada si adivina la URL.

Opción 1 - Anular vistas

Si desea conservar algunas de las vistas predeterminadas y corregir o eliminar otras, puede anular las vistas de la siguiente manera ( de este documento ):

1. Haga clic con el botón derecho en su proyecto> Agregar> Nuevo elemento de andamio
2. En el panel izquierdo del cuadro de diálogo Agregar andamio, seleccione Identidad> Agregar
3. En el cuadro de diálogo Agregar identidad, seleccione las opciones que desee

Ahora puede simplemente cambiar el aspecto y la funcionalidad de la vista que ha invalidado, o para "eliminarlo" puede hacer que devuelva un 404 o un redireccionamiento a otro lugar. Si elimina esta vista anulada, la IU predeterminada volverá.

Este enfoque puede ensuciarse rápidamente si desea anular todas las vistas.

Opción 2 - No agregar IU predeterminada

Otra opción es volver a la antigua forma de agregar identidad que no hace una llamada a AddDefaultUI, la desventaja es que tendrá que agregar todas las vistas usted mismo. Puede hacer esto de la siguiente manera ( de este documento , aunque ignore la primera línea sobre la anulación de todas las vistas, que se aplica a la opción 1 anterior):

//remove this: services.AddDefaultIdentity<IdentityUser>()
//use this instead to get the Identity basics without any default UI:
services.AddIdentity<IdentityUser, IdentityRole>()
    .AddEntityFrameworkStores<ApplicationDbContext>()
    .AddDefaultTokenProviders();

//this assumes you want to continue using razor views for your identity UI
//it specifies areas can be used with razor pages and then adds an 
//authorize filter with a default policy for the folder /Account/Manage and
//the page /Account/Logout.cshtml (both of which live in Areas/Identity/Pages)
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1)
    .AddRazorPagesOptions(options =>
    {
        options.AllowAreas = true;
        options.Conventions.AuthorizeAreaFolder("Identity", "/Account/Manage");
        options.Conventions.AuthorizeAreaPage("Identity", "/Account/Logout");
    });

//configures the application cookie to redirect on challenge, etc.
services.ConfigureApplicationCookie(options =>
{
    options.LoginPath = $"/Identity/Account/Login";
    options.LogoutPath = $"/Identity/Account/Logout";
    options.AccessDeniedPath = $"/Identity/Account/AccessDenied";
});

//configures an email sender for e.g. password resets
services.AddSingleton<IEmailSender, EmailSender>();

Tenga en cuenta que tampoco estoy convencido al 100% de que este segundo enfoque sea sin problemas, como se mencionó anteriormente, existen otras diferencias entre AddDefaultIdentity y AddIdentity. Por ejemplo, el último agrega el servicio RoleManager mientras que el primero no lo hace. Además, no me queda claro si estos dos enfoques serán compatibles y se mantendrán igualmente en el futuro.

Si tiene dudas sobre lo que están haciendo las opciones anteriores (y si tiene algunas horas que matar), puede consultar la fuente de AddDefaultIdentity (que también se llama AddIdentityCookies y AddIdentityCore ) en comparación con el AddIdentity anterior.

Opción 3 - Enfoque híbrido

La mejor opción actualmente es probablemente combinar los 2 anteriores, de la siguiente manera:

1. Configura tu proyecto para usar la identidad por defecto
2. Scaffold solo las vistas que desea incluir y editarlas en consecuencia
3. Cambie a la antigua llamada AddIdentity e incluya las opciones de maquinilla de afeitar como se muestra en la opción 2 (ajuste según sea necesario dependiendo de las vistas que haya incluido

Ahora tiene solo las vistas que desea y se basan en las implementaciones predeterminadas, lo que significa que la mayoría del trabajo se realiza por usted para estas vistas.

Answer 2

Para las páginas web de ASP.NET, este es un complemento para la respuesta anterior que incluye las páginas web de afeitar de ASP.Net. Los he separado como si alguien los necesitara y no se confundieran entre ellos. Las páginas web son diferentes, ya que incluye el código que hay detrás de los formularios web.

Primero editaremos las Páginas> _LoginPartial.cshtml

Eliminar la línea <li><a asp-page="/Account/Register">Register</a></li>

Siguiente Editar Páginas> Cuenta> Login.cshtml. Quita lo siguiente:

                <div class="form-group">
                <p>
                    <a asp-page="./ForgotPassword">Forgot your password?</a>
                </p>
                <p>
                    <a asp-page="./Register" asp-route-returnUrl="@Model.ReturnUrl">Register as a new user</a>
                </p>
            </div>

También eliminar:

<div class="col-md-6 col-md-offset-2">
    <section>
        <h4>Use another service to log in.</h4>
        <hr />
        @{
            if ((Model.ExternalLogins?.Count ?? 0) == 0)
            {
                <div>
                    <p>
                        There are no external authentication services configured. See <a href="https://go.microsoft.com/fwlink/?LinkID=532715">this article</a>
                        for details on setting up this ASP.NET application to support logging in via external services.
                    </p>
                </div>
            }
            else
            {
                <form asp-page="./ExternalLogin" asp-route-returnUrl="@Model.ReturnUrl" method="post" class="form-horizontal">
                    <div>
                        <p>
                            @foreach (var provider in Model.ExternalLogins)
                            {
                                <button type="submit" class="btn btn-default" name="provider" value="@provider.Name" title="Log in using your @provider.DisplayName account">@provider.DisplayName</button>
                            }
                        </p>
                    </div>
                </form>
            }
        }
    </section>
</div>

Ahora edite el código detrás de Login.cshtml.cs. Retirar:

public IList<AuthenticationScheme> ExternalLogins { get; set; }

También quitar:

// Clear the existing external cookie to ensure a clean login process
        await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);

        ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();

Editar páginas> Cuenta> Administrar> _ManageNav.cshtml

Retirar:

    @if (hasExternalLogins)
{
    <li class="@ManageNavPages.ExternalLoginsNavClass(ViewContext)"><a asp-page="./ExternalLogins">External logins</a></li>
}

A continuación, eliminaremos los siguientes archivos del directorio Páginas> Cuenta:

• ExternalLogin.cshtml
• ForgotPassword.cshtml
• ForgotPasswordConfirmation.cshtml
• Register.cshtml
• ResetPassword.cshtml
• ResetPasswordConfirmation.cshtml

Elimine los siguientes archivos del directorio Páginas> Cuenta> Administrar:

• ExternalLogin.cshtml

Answer 3

Supongo que está hablando de una aplicación web de Model-View-Controller. Puedo decirles que no es seguro simplemente quitar el botón o incluso las vistas para tal.

También asumo que desea eliminar el inicio de sesión de terceros que también crearía un usuario registrado.

Yo haría lo siguiente:

En su controlador de cuenta elimine lo siguiente

[HttpGet]
    [AllowAnonymous]
    public IActionResult Register(string returnUrl = null)
    {
        ViewData["ReturnUrl"] = returnUrl;
        return View();
    }

    [HttpPost]
    [AllowAnonymous]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Register(RegisterViewModel model, string returnUrl = null)
    {
        ViewData["ReturnUrl"] = returnUrl;
        if (ModelState.IsValid)
        {
            var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
            var result = await _userManager.CreateAsync(user, model.Password);
            if (result.Succeeded)
            {
                _logger.LogInformation("User created a new account with password.");

                var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
                var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
                await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);

                await _signInManager.SignInAsync(user, isPersistent: false);
                _logger.LogInformation("User created a new account with password.");
                return RedirectToLocal(returnUrl);
            }
            AddErrors(result);
        }

        // If we got this far, something failed, redisplay form
        return View(model);
    }

También en el Controlador de Cuenta, más abajo, elimina lo siguiente:

[HttpPost]
    [AllowAnonymous]
    [ValidateAntiForgeryToken]
    public IActionResult ExternalLogin(string provider, string returnUrl = null)
    {
        // Request a redirect to the external login provider.
        var redirectUrl = Url.Action(nameof(ExternalLoginCallback), "Account", new { returnUrl });
        var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl);
        return Challenge(properties, provider);
    }

    [HttpGet]
    [AllowAnonymous]
    public async Task<IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null)
    {
        if (remoteError != null)
        {
            ErrorMessage = $"Error from external provider: {remoteError}";
            return RedirectToAction(nameof(Login));
        }
        var info = await _signInManager.GetExternalLoginInfoAsync();
        if (info == null)
        {
            return RedirectToAction(nameof(Login));
        }

        // Sign in the user with this external login provider if the user already has a login.
        var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent: false, bypassTwoFactor: true);
        if (result.Succeeded)
        {
            _logger.LogInformation("User logged in with {Name} provider.", info.LoginProvider);
            return RedirectToLocal(returnUrl);
        }
        if (result.IsLockedOut)
        {
            return RedirectToAction(nameof(Lockout));
        }
        else
        {
            // If the user does not have an account, then ask the user to create an account.
            ViewData["ReturnUrl"] = returnUrl;
            ViewData["LoginProvider"] = info.LoginProvider;
            var email = info.Principal.FindFirstValue(ClaimTypes.Email);
            return View("ExternalLogin", new ExternalLoginViewModel { Email = email });
        }
    }

    [HttpPost]
    [AllowAnonymous]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> ExternalLoginConfirmation(ExternalLoginViewModel model, string returnUrl = null)
    {
        if (ModelState.IsValid)
        {
            // Get the information about the user from the external login provider
            var info = await _signInManager.GetExternalLoginInfoAsync();
            if (info == null)
            {
                throw new ApplicationException("Error loading external login information during confirmation.");
            }
            var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
            var result = await _userManager.CreateAsync(user);
            if (result.Succeeded)
            {
                result = await _userManager.AddLoginAsync(user, info);
                if (result.Succeeded)
                {
                    await _signInManager.SignInAsync(user, isPersistent: false);
                    _logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
                    return RedirectToLocal(returnUrl);
                }
            }
            AddErrors(result);
        }

        ViewData["ReturnUrl"] = returnUrl;
        return View(nameof(ExternalLogin), model);
    }

también quitar

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

    [HttpPost]
    [AllowAnonymous]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> ForgotPassword(ForgotPasswordViewModel model)
    {
        if (ModelState.IsValid)
        {
            var user = await _userManager.FindByEmailAsync(model.Email);
            if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
            {
                // Don''t reveal that the user does not exist or is not confirmed
                return RedirectToAction(nameof(ForgotPasswordConfirmation));
            }

            // For more information on how to enable account confirmation and password reset please
            // visit https://go.microsoft.com/fwlink/?LinkID=532713
            var code = await _userManager.GeneratePasswordResetTokenAsync(user);
            var callbackUrl = Url.ResetPasswordCallbackLink(user.Id, code, Request.Scheme);
            await _emailSender.SendEmailAsync(model.Email, "Reset Password",
               $"Please reset your password by clicking here: <a href=''{callbackUrl}''>link</a>");
            return RedirectToAction(nameof(ForgotPasswordConfirmation));
        }

        // If we got this far, something failed, redisplay form
        return View(model);
    }

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

    [HttpGet]
    [AllowAnonymous]
    public IActionResult ResetPassword(string code = null)
    {
        if (code == null)
        {
            throw new ApplicationException("A code must be supplied for password reset.");
        }
        var model = new ResetPasswordViewModel { Code = code };
        return View(model);
    }

    [HttpPost]
    [AllowAnonymous]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> ResetPassword(ResetPasswordViewModel model)
    {
        if (!ModelState.IsValid)
        {
            return View(model);
        }
        var user = await _userManager.FindByEmailAsync(model.Email);
        if (user == null)
        {
            // Don''t reveal that the user does not exist
            return RedirectToAction(nameof(ResetPasswordConfirmation));
        }
        var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
        if (result.Succeeded)
        {
            return RedirectToAction(nameof(ResetPasswordConfirmation));
        }
        AddErrors(result);
        return View();
    }

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

Ahora en Modelos puedes borrar los siguientes archivos:

• ExternalLoginViewModel
• Olvidó la contraseña para ver el modelo
• RegistrarseViewModel
• ResetPasswordViewModel

En Vistas, eliminaría:

• Confirmar correo electrónico
• ExternalLogin
• Se te olvidó tu contraseña
• Contraseña olvidadaConfirmación
• Registro
• Restablecer la contraseña
• ResetPasswordConfirmation

También en Vistas de cuenta, edite Login.cshtml y elimine lo siguiente:

                <div class="form-group">
                <p>
                    <a asp-page="./ForgotPassword">Forgot your password?</a>
                </p>
                <p>
                    <a asp-page="./Register" asp-route-returnUrl="@Model.ReturnUrl">Register as a new user</a>
                </p>
            </div>

También eliminar:

<div class="col-md-6 col-md-offset-2">
    <section>
        <h4>Use another service to log in.</h4>
        <hr />
        @{
            if ((Model.ExternalLogins?.Count ?? 0) == 0)
            {
                <div>
                    <p>
                        There are no external authentication services configured. See <a href="https://go.microsoft.com/fwlink/?LinkID=532715">this article</a>
                        for details on setting up this ASP.NET application to support logging in via external services.
                    </p>
                </div>
            }
            else
            {
                <form asp-page="./ExternalLogin" asp-route-returnUrl="@Model.ReturnUrl" method="post" class="form-horizontal">
                    <div>
                        <p>
                            @foreach (var provider in Model.ExternalLogins)
                            {
                                <button type="submit" class="btn btn-default" name="provider" value="@provider.Name" title="Log in using your @provider.DisplayName account">@provider.DisplayName</button>
                            }
                        </p>
                    </div>
                </form>
            }
        }
    </section>
</div>

Ahora, bajo sus Vistas compartidas, abra _LoginPartial.cshtml y elimine lo siguiente:

<li><a asp-area="" asp-controller="Account" asp-action="Register">Register</a></li>

En Administrar vistas _ManageNav.cshtml, elimine lo siguiente:

    @if (hasExternalLogins)
{
    <li class="@ManageNavPages.ExternalLoginsNavClass(ViewContext)"><a asp-action="ExternalLogins">External logins</a></li>
}

Ahora, incluso si accede a la URL yourapp.com/Account/Register obtendrá una página 404.

Espero que esto ayude.