Recordemos que dos días antes de realizar el proyecto, la certificación ha sido lugar relativamente dolor de cabeza.
Por lo que tomar el tiempo para leer algunos de los contenidos, a partir de autenticación forma, ver la identidad, el proceso es más que un simple navegador, pero antes de que el concepto se puede considerar que tienen algún profundizó.
De hecho, estos dos genio para saber, la autenticación de formulario ya es una cosa del pasado en .net, Identidad ha sido reemplazado. Después Sin embargo, he leído la autenticación de la forma, la certificación de todo el proceso es también tener un cierto conocimiento, pero aquí es bajar algún contenido identidad relacionada.
Owin
Owin identidad se basa en el marco. Owin realidad una especificación para lograr su .net, llamado Kantana, pero en realidad ellos usan, creo que en el fondo está interconectado.
Owin ya no dependen de canalización de solicitudes de IIS, sino un mecanismo de registro para personalizar los componentes de la persona que ya es similar a la práctica del núcleo .net.
Owin e IIS
Owin puede ejecutarse en IIS, también se puede ejecutar de forma independiente, Owin operar de forma independiente con sus propios componentes SelfHost, cuando basado en IIS, dependientes Owin Microsoft.Owin.Host.SystemWebbibliotecas completar la integración de IIS.
El IIS Global.asaxy Owin de StartUpdevoluciones de llamada también estar presentes al mismo tiempo, se llama.
Si se integran en el IIS, Owin la llamada de inicialización, casi desencadenada después del evento Application_Start.
clase a partir Owin
Owin la tubería está dispuesto en el proceso de configuración de la clase de partida.
Hay dos configuraciones, uno se especifica en nodo Web.config AppSettings:
<add key="owin:AppStartup" value="起始类" />
Otra configuración de propiedades por, que contiene Configurationpropiedades de etiquetado sobre los métodos de la clase
[assembly: OwinStartup(typeof(StartupDemo.TestStartup))]
Identidad
Identidad sustituir la autenticación original de la Forma, en cierta medida, pero si usted no utiliza Owin, todavía tengo que entender el uso de la autenticación de formularios.
La identidad es en realidad en respuesta a la aparición de certificación de tercera parte bajo el entorno de red (Google, fb, etc.) la demanda, autenticación de dos factores (2FA), la forma tradicional de la forma son menos propensos a expandirse.
La referencia a esta parte del SO, en cierta medida, la respuesta a esta pregunta
Identidad aumento componentes
Aparte Owin dependencia, identidad también en ADO.NET Entity Framework, requiere varios componentes Nuget:
- Microsoft.AspNet.Identity.Owin
- Microsoft.AspNet.Identity.EntityFramework
- Microsoft.Owin.Host.SystemWeb
Si tiene que usar MySQL, también es necesario instalar
- MySql.Data.Entity
Configuración e inicialización
perfiles
configuración web.config tiene que añadir un poco de contenido
volver entidad a esta parte del aumento automático de la instalación de la entidad, de hecho, no tiene que modificar manualmente:
<configSections>
<section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
</configSections>
En particular, el uso que se basa en la configuración de inicio Owin, por lo que en los AppSettings nodo aumenta mi disposición de pórtico
<add key="owin:AppStartup" value="Demo.WEBUI.IdentityConfig" />
Identidad mediante el curado de la información del usuario de entidad, es necesario configurar el ConnectionString Entidad utiliza, esto es parte de una convención común .NET:
<connectionStrings>
<add name="DefaultConnection" connectionString="server=localhost;database=dbname;uid=root;pwd=123456" providerName="MySql.Data.MySqlClient" />
</connectionStrings>
aumento en la entidad soporte para MySQL, por lo general se instala por defecto, es el SqlServer:
<entityFramework>
<defaultConnectionFactory type="MySql.Data.Entity.MySqlConnectionFactory, MySql.Data.Entity.EF6" />
<providers>
<provider invariantName="MySql.Data.MySqlClient" type="MySql.Data.MySqlClient.MySqlProviderServices, MySql.Data.Entity.EF6, Version=6.10.8.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" />
<provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
</providers>
</entityFramework>
También Entidad, aumentar DBPROVIDER, este nodo no encuentra una explicación mejor, pero no sin palabras.
<system.data>
<DbProviderFactories>
<remove invariant="MySql.Data.MySqlClient"></remove>
<add name="MySQL Data Provider" invariant="MySql.Data.MySqlClient" description=".Net Framework Data Provider for MySQL" type="MySql.Data.MySqlClient.MySqlClientFactory, MySql.Data, Version=6.10.8.0" />
</DbProviderFactories>
</system.data>
clase auxiliar
usuario
La identidad de la clase de usuario, se puede utilizar directamente IdentityUser, también se puede extender desde su fundación, añadir campos personalizados, que se unirán a la mesa del usuario, he añadido tres campos.
public class ApplicationUser : IdentityUser
{
public virtual DateTime? LastLoginTime { get; set; }
public virtual DateTime? RegistrationTime { get; set; }
public virtual bool IsEnabled { get; set; }
public async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser> manager)
{
// Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
// Add custom user claims here
return userIdentity;
}
}
Gestión de usuarios
la configuración de autenticación de usuario Aquí se han configurado, como el de la contraseña, el tiempo de caducidad de la cookie
public class ApplicationUserManager : UserManager<ApplicationUser>
{
private IUserStore<ApplicationUser> _store;
public ApplicationUserManager(IUserStore<ApplicationUser> store)
: base(store)
{
_store = store;
}
public static ApplicationUserManager Create(IdentityFactoryOptions<ApplicationUserManager> options, IOwinContext context)
{
var manager = new ApplicationUserManager(new UserStore<ApplicationUser>(context.Get<ApplicationDbContext>()));
// Configure validation logic for usernames
manager.UserValidator = new UserValidator<ApplicationUser>(manager)
{
AllowOnlyAlphanumericUserNames = true,
RequireUniqueEmail = false
};
// Configure validation logic for passwords
manager.PasswordValidator = new PasswordValidator
{
RequiredLength = 4,
RequireNonLetterOrDigit = false,
RequireDigit = false,
RequireLowercase = false,
RequireUppercase = false,
};
// Configure user lockout defaults
manager.UserLockoutEnabledByDefault = false;
//manager.DefaultAccountLockoutTimeSpan = TimeSpan.FromMinutes(5);
//manager.MaxFailedAccessAttemptsBeforeLockout = 5;
var dataProtectionProvider = options.DataProtectionProvider;
if (dataProtectionProvider != null)
{
manager.UserTokenProvider =
new DataProtectorTokenProvider<ApplicationUser>(dataProtectionProvider.Create("ASP.NET Identity"));
}
return manager;
}
}
Gestión de registros
de inicio de sesión de usuario llamadas a métodos, que dependerán de la etapa anteriorApplicationUserManager
public class ApplicationSignInManager : SignInManager<ApplicationUser, string>
{
public ApplicationSignInManager(ApplicationUserManager userManager, IAuthenticationManager authenticationManager)
: base(userManager, authenticationManager)
{
}
public override Task<ClaimsIdentity> CreateUserIdentityAsync(ApplicationUser user)
{
return user.GenerateUserIdentityAsync((ApplicationUserManager)UserManager);
}
public static ApplicationSignInManager Create(IdentityFactoryOptions<ApplicationSignInManager> options, IOwinContext context)
{
return new ApplicationSignInManager(context.GetUserManager<ApplicationUserManager>(), context.Authentication);
}
}
Administración de las funciones
Aquí no hice más extensiones. propia identidad no puede basados en papel, pero en el control de permisos de reclamación.
Por lo tanto, no se requiere que el papel de la gestión.
public class ApplicationRoleManager : RoleManager<IdentityRole, string>
{
public ApplicationRoleManager(IRoleStore<IdentityRole, string> roleStore)
: base(roleStore)
{
}
public static ApplicationRoleManager Create(IdentityFactoryOptions<ApplicationRoleManager> options, IOwinContext context)
{
return new ApplicationRoleManager(new RoleStore<IdentityRole, string, IdentityUserRole>(context.Get<ApplicationDbContext>()));
}
}
clase de inicialización
Si el nuevo proyecto con una autenticación de .NET MVC añadirá automáticamente la clase inicial.
Me Identidad complemento de un proyecto ya existente, donde la función de inicialización para inicializar la clase de copia vs creado de forma automática y no es necesario eliminar algunas de las funciones de inicio de sesión única (local).
public void Configuration(IAppBuilder app)
{
// Configure the db context, user manager and signin manager to use a single instance per request
app.CreatePerOwinContext(ApplicationDbContext.Create);
app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);
app.CreatePerOwinContext<ApplicationRoleManager>(ApplicationRoleManager.Create);
// Enable the application to use a cookie to store information for the signed in user
// and to use a cookie to temporarily store information about a user logging in with a third party login provider
// Configure the sign in cookie
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/Login/Login"),
Provider = new CookieAuthenticationProvider
{
// Enables the application to validate the security stamp when the user logs in.
// This is a security feature which is used when you change a password or add an external login to your account.
OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
validateInterval: TimeSpan.FromMinutes(30),
regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
}
});
//app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);
// Enables the application to temporarily store user information when they are verifying the second factor in the two-factor authentication process.
//app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));
// Enables the application to remember the second login verification factor such as phone or email.
// Once you check this option, your second step of verification during the login process will be remembered on the device where you logged in from.
// This is similar to the RememberMe option when you log in.
//app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);
}
uso
El foco principal ApplicationUserManager, ApplicationSignInManagerde inicio de sesión de registro de usuarios y otras operaciones en torno a la ApplicationRoleManagergestión de derechos de usuario.
registro
La lógica básica o en el domicilio contra el marco por defecto, pero añade algunas características personalizadas.
Aquí he aumentado configuración de las funciones de usuario y definir el primer usuario registrado como administrador, a continuación, para el usuario medio.
Aplicaciones, otros lugares de venir a juzgar la operación puede llevarse a cabo a través de las funciones de usuario.
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
try
{
var user = new ApplicationUser
{
UserName = model.UserName,
Email = model.Password,
IsEnabled = false, //default disabed
LastLoginTime = DateTime.Now,
RegistrationTime = DateTime.Now
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//init roles
if (!RoleManager.Roles.Any())
{
await RoleManager.CreateAsync(new IdentityRole(UserRole.NORMAL));
await RoleManager.CreateAsync(new IdentityRole(UserRole.ADMINISTRATOR));
}
var adminRoleId = (await RoleManager.FindByNameAsync(UserRole.ADMINISTRATOR)).Id;
var hasAdmin = UserManager.Users.Any(p => p.Roles.Any(x => x.RoleId == adminRoleId));
var userRole = UserRole.NORMAL;
if (!hasAdmin)
{
userRole = UserRole.ADMINISTRATOR;
//make the first admin enabled
user.IsEnabled = true;
await UserManager.UpdateAsync(user);
}
await UserManager.AddToRoleAsync(user.Id, userRole);
//let the user manual log in
//await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return RedirectToAction("Login", "Login");
}
AddErrors(result);
}
catch (System.Data.Entity.Validation.DbEntityValidationException e)
{
Console.WriteLine(e.ToString());
throw e;
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
acceder
Cuando defino un usuario agrega campos personalizados si el tiempo de inicio de sesión del usuario y el usuario habilitados.
Aquí los dos campos han hecho uso de.
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return View(model);
}
var user = await UserManager.FindByNameAsync(model.UserName);
if (null == user)
{
ModelState.AddModelError("", "登录失败.");
return View(model);
}
if ((!await UserManager.IsInRoleAsync(user.Id, UserRole.ADMINISTRATOR)) && !user.IsEnabled)
{
ModelState.AddModelError("", "账户未启用，请联系管理员.");
return View(model);
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, shouldLockout: false);
switch (result)
{
case SignInStatus.Success:
user.LastLoginTime = DateTime.Now;
await UserManager.UpdateAsync(user);
return RedirectToLocal(returnUrl);
default:
ModelState.AddModelError("", "登录失败.");
return View(model);
}
}
Algunas extensiones utilizan
Restablecer contraseña
la lógica de restablecimiento de contraseña más segura es por correo, teléfono, etc., pero yo estaba en el sistema, la forma más fácil es usar el conjunto de administrador directamente.
Es más común para contador puede ser enviada al usuario por medio de la conexión, mediante la conexión del usuario para cambiar manualmente la contraseña.
[HttpPost]
public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
if (!IsAdmin && !model.UserName.Equals(User.Identity.Name))
{
ModelState.AddModelError("", "无效的用户名");
return View();
}
var user = await UserManager.FindByNameAsync(model.UserName);
if (user == null)
{
return View();
}
var token = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
var result = await UserManager.ResetPasswordAsync(user.Id, token, model.Password);
if (!result.Succeeded)
{
AddErrors(result);
}
else
{
ViewBag.msg = "修改成功!";
}
return View();
}
El control de acceso
De hecho, basado en reclamación por cierto, pero el sistema es relativamente simple, controlado por Reclamación algo complicado, por lo que utiliza la vía directa de funciones.
Hay dos maneras, la primera es la Propiedades del usuario del controlador / WebViewPage el interior de un User.IsInRole(UserRole.ADMINISTRATOR);método para determinar los permisos de usuario, aquí es el nombre del rol entrante, no RoleId.
Otra es la ApplicationUserManager UserManager.GetRoles(user.Id)método, se puede obtener toda la Función Nombre de usuario, y luego determina uno deseado por rol.
problema
conexión de MySQL no tiene éxito
A veces se va a instalar la versión 8.xx NuGet para el sistema MySql.Data, buscar, he encontrado que muchas personas se encuentran con problemas en esta versión, rebaja a la versión 6.xx.
función RememberMe
Este problema no se ha resuelto, cuando un usuario inicia una sesión llamadas
var result = await SignInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, shouldLockout: false);
El tercer argumento de que aquí es la configuración de inicio de sesión válidas, la teoría de conjuntos false, el plazo de prescripción es de cookies currentSession, y trueentonces, será un largo período de tiempo.
De hecho, se encontró que pasa true, el tiempo de caducidad es de 15 días (esta relativamente normal), y pasaron false, sería válido N/A, nunca caducan. No hay manera de resolver el descubrimiento.