c# - route - tag helpers asp net core

Autenticación personalizada en ASP.Net-Core

Question

Estoy trabajando en una aplicación web que necesita integrarse con una base de datos de usuarios existente. Todavía me gustaría usar los atributos [Authorize] , pero no quiero usar el marco de Identidad. Si quisiera usar el marco de Identity, agregaría algo como esto en el archivo startup.cs:

services.AddIdentity<ApplicationUser, IdentityRole>(options =>
{
options.Password.RequireNonLetterOrDigit = false;
}).AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders();

¿Asumo que tengo que agregar algo más allí y luego crear algún tipo de clase que implemente una interfaz específica? ¿Alguien puede señalarme en la dirección correcta? Estoy usando RC1 de asp.net 5 en este momento.

Answer 1

De lo que aprendí después de varios días de investigación, aquí está la guía para la autenticación de usuario personalizada ASP .Net Core MVC 2.x

En Startup.cs :

Agregue las siguientes líneas al método ConfigureServices :

public void ConfigureServices(IServiceCollection services)
{
services.AddAuthentication(
CookieAuthenticationDefaults.AuthenticationScheme
).AddCookie(CookieAuthenticationDefaults.AuthenticationScheme,
options =>
{
options.LoginPath = "/Account/Login";
options.LogoutPath = "/Account/Logout";
});
services.AddMvc();
// authentication
services.AddAuthentication(options =>
{
options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
});
services.AddTransient(
m => new UserManager(
Configuration
.GetValue<string>(
DEFAULT_CONNECTIONSTRING //this is a string constant
)
)
);
services.AddDistributedMemoryCache();
}

tenga en cuenta que en el código anterior dijimos que si algún usuario no autenticado solicita una acción anotada con [Authorize] , bien forzará la redirección a /Account/Login URL de /Account/Login .

Agregue las siguientes líneas para Configure método:

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler(ERROR_URL);
}
app.UseStaticFiles();
app.UseAuthentication();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: DEFAULT_ROUTING);
});
}

Cree su clase de UserManager que también gestionará el inicio y cierre de sesión. debería verse como el siguiente fragmento (tenga en cuenta que estoy usando dapper):

public class UserManager
{
string _connectionString;
public UserManager(string connectionString)
{
_connectionString = connectionString;
}
public async void SignIn(HttpContext httpContext, UserDbModel user, bool isPersistent = false)
{
using (var con = new SqlConnection(_connectionString))
{
var queryString = "sp_user_login";
var dbUserData = con.Query<UserDbModel>(
queryString,
new
{
UserEmail = user.UserEmail,
UserPassword = user.UserPassword,
UserCellphone = user.UserCellphone
},
commandType: CommandType.StoredProcedure
).FirstOrDefault();
ClaimsIdentity identity = new ClaimsIdentity(this.GetUserClaims(dbUserData), CookieAuthenticationDefaults.AuthenticationScheme);
ClaimsPrincipal principal = new ClaimsPrincipal(identity);
await httpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal);
}
}
public async void SignOut(HttpContext httpContext)
{
await httpContext.SignOutAsync();
}
private IEnumerable<Claim> GetUserClaims(UserDbModel user)
{
List<Claim> claims = new List<Claim>();
claims.Add(new Claim(ClaimTypes.NameIdentifier, user.Id().ToString()));
claims.Add(new Claim(ClaimTypes.Name, user.UserFirstName));
claims.Add(new Claim(ClaimTypes.Email, user.UserEmail));
claims.AddRange(this.GetUserRoleClaims(user));
return claims;
}
private IEnumerable<Claim> GetUserRoleClaims(UserDbModel user)
{
List<Claim> claims = new List<Claim>();
claims.Add(new Claim(ClaimTypes.NameIdentifier, user.Id().ToString()));
claims.Add(new Claim(ClaimTypes.Role, user.UserPermissionType.ToString()));
return claims;
}
}

Entonces, tal vez tenga un AccountController que tenga una Acción de Login que debería verse a continuación:

public class AccountController : Controller
{
UserManager _userManager;
public AccountController(UserManager userManager)
{
_userManager = userManager;
}
[HttpPost]
public IActionResult LogIn(LogInViewModel form)
{
if (!ModelState.IsValid)
return View(form);
try
{
//authenticate
var user = new UserDbModel()
{
UserEmail = form.Email,
UserCellphone = form.Cellphone,
UserPassword = form.Password
};
_userManager.SignIn(this.HttpContext, user);
return RedirectToAction("Search", "Home", null);
}
catch (Exception ex)
{
ModelState.AddModelError("summary", ex.Message);
return View(form);
}
}
}

Ahora puede usar la anotación [Authorize] en cualquier Action o Controller .

Siéntase libre de comentar cualquier pregunta o error.

Answer 2

La creación de autenticación personalizada en ASP.NET Core se puede hacer de varias maneras. Si desea construir a partir de componentes existentes (pero no quiere usar identidad), consulte la categoría de "Seguridad" de los documentos en docs.asp.net. https://docs.asp.net/en/latest/security/index.html

Algunos artículos que pueden resultarle útiles:

Usar Cookie Middleware sin identidad ASP.NET

Autorización personalizada basada en políticas

Y, por supuesto, si eso falla o los documentos no son lo suficientemente claros, el código fuente se encuentra en https://github.com/aspnet/Security que incluye algunas muestras.