public virtual LoginResult Login(string login, string password)
{
if (string.IsNullOrWhiteSpace(login) || string.IsNullOrWhiteSpace(password))
{
return(new LoginResult(false, new List <string> {
"Password or login is empty"
}));
}
ValidateUserResult userResult = CheckIfUserExists(login);
if (!userResult.IsSuccess || string.IsNullOrWhiteSpace(userResult.HashedPasswordFromDb))
{
return(new LoginResult(userResult.IsSuccess, userResult.Errors));
}
bool isPasswordOk = CheckPasswords(password, userResult.HashedPasswordFromDb);
if (!isPasswordOk)
{
return(new LoginResult(false, new List <string> {
"Login or password incorrect"
}));
}
return(LogInUser(login));
}
/// <summary>
/// Valida o usuário no provedor de identidade
/// </summary>
/// <param name="userName">Nome de usuário</param>
/// <param name="password">Senha</param>
/// <param name="servicesContext">Nome do contexto de serviços que será usado na autenticação.</param>
/// <param name="parameters">Demais informações necessárias</param>
/// <returns></returns>
public ValidateUserResultWrapper ValidateUser(string userName, string password, string servicesContext, SecurityParameter[] parameters)
{
IValidateUserResult result = null;
try
{
result = Membership.ValidateUser(userName, password, parameters);
}
catch (Exception ex)
{
result = new ValidateUserResult {
Message = ex.Message,
Status = AuthenticationStatus.ErrorInValidate
};
}
LogRequest(userName, result.Status);
Colosoft.Net.ServiceAddress userProviderServiceAddress = null;
Colosoft.Net.ServiceAddress profileProviderServiceAddress = null;
Colosoft.Net.ServiceAddress serviceAddressProviderServiceAddress = null;
if (result.Status == AuthenticationStatus.PasswordWarning || result.Status == AuthenticationStatus.Success)
{
userProviderServiceAddress = GetServiceAddress(_configurationSection.UserProviderServiceName, servicesContext);
profileProviderServiceAddress = GetServiceAddress(_configurationSection.ProfileProviderServiceName, servicesContext);
serviceAddressProviderServiceAddress = GetServiceAddress(_configurationSection.ServiceAddressProviderServiceName, servicesContext);
}
return(new ValidateUserResultWrapper(result, userProviderServiceAddress, profileProviderServiceAddress, serviceAddressProviderServiceAddress));
}
public bool Validate(out string errorMessage, IUserDao userDao, string expectVerifyCode)
{
if (OrnamentContext.Configuration.ApplicationSetting.EnableVerifyCode)
{
if (string.IsNullOrEmpty(expectVerifyCode))
{
errorMessage = Resources.error_expireVerifyCode;
return(false);
}
if (expectVerifyCode.ToLower() != VerifyCode.ToLower())
{
errorMessage = Resources.error_notMatchVerifyCode;
return(false);
}
}
User user = userDao.GetByLoginId(User);
if (user == null)
{
errorMessage = MemberShip.Properties.Resources.error_LoginError;
return(false);
}
ValidateUserResult result = user.Security.ValidateUser(Password, out errorMessage);
CultureInfo languae = OrnamentContext.MemberShip.CurrentLanguage();
if (languae != null && user.Language != null && user.Language.ToLower() != languae.Name.ToLower())
{
OrnamentContext.MemberShip.SwitchLanguage(languae);
}
return(result == ValidateUserResult.Success);
}
public ValidateUserResult ValidateNew(User newUser)
{
var result = new ValidateUserResult
{
Id = new ValidateResult(),
Account = ValidateAccount(newUser.Account),
Password = ValidatePassword(newUser.Password),
Name = ValidateName(newUser.Name),
};
return(result);
}
public void CanLoginTest()
{
var target = new User("kkkkk", "123456");
string inputPassword = "******";
string message;
ValidateUserResult actual = target.Security.ValidateUser(inputPassword, out message);
Assert.AreEqual(ValidateUserResult.Success, actual);
Assert.AreEqual(ValidateUserResult.InvalidatePasswordOrAccount,
target.Security.ValidateUser("error_password", out message));
}
public virtual ValidateUserResult ValidateUser(string inputPassword, out string errorMessage)
{
if (String.IsNullOrEmpty(inputPassword))
{
throw new ArgumentNullException("inputPassword");
}
if (User.IsDeny)
{
errorMessage = Resources.error_UserIsDeny;
return(ValidateUserResult.DenyUser);
}
if (IsLocked)
{
errorMessage = Resources.error_UserIsLockout;
if (ValidateUserPolicy.EnabledPasswordAtteempts)
{
errorMessage += String.Format(Resources.error_UserIsLockout_retry_after_mins, ValidateUserPolicy.PasswordAttemptWindow);
}
else
{
errorMessage += "," + Resources.error_UserIsLockout_contact_administrator;
}
return(ValidateUserResult.LockedUser);
}
ValidateUserResult result =
ValidateUserPolicy.ValidateUser(User, inputPassword, out errorMessage);
switch (result)
{
case ValidateUserResult.Success:
LastLoginDate = DateTime.Now;
InvalidPasswordAttempts = 0;
break;
case ValidateUserResult.InvalidatePasswordOrAccount:
InvalidPasswordAttempts += 1;
if (InvalidPasswordAttempts == ValidateUserPolicy.MaxInvalidPasswordAttempts)
{
LastLockoutDate = DateTime.Now;
}
break;
}
return(result);
}
public void CanLoginTest_Lockout()
{
var target = new User("kkkkk", "123456");
string message;
for (int i = 0; i < 31; i++)
{
target.Security.ValidateUser("incorrect-pwd", out message);
}
string inputPassword = "******";
ValidateUserResult actual = target.Security.ValidateUser(inputPassword, out message);
Assert.AreEqual(ValidateUserResult.MaxInValidatePasswordAttempt, actual);
}
/// <summary>
/// Valida os dados do token.
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
public virtual IValidateUserResult ValidateToken(string token)
{
IValidateUserResult result = new ValidateUserResult();
var currentUser = GetUserByToken(token, false) as Security.Authentication.IAutheticableUser;
if ((currentUser == null) || (String.IsNullOrEmpty(currentUser.UserKey)))
{
return(new ValidateUserResult()
{
Status = AuthenticationStatus.InvalidUserNameOrPassword,
Message = Resources.Invalid_UsernameOrPassword,
User = null
});
}
var identityProvider = Microsoft.Practices.ServiceLocation.ServiceLocator.Current.GetInstance <IIdentityProviderManager>().GetProviderById(currentUser.IdentityProviderId);
if (identityProvider == null)
{
return(new ValidateUserResult()
{
Status = AuthenticationStatus.UnknownError,
Message = string.Format(Resources.Error_IdentityProviderNotFound, token),
User = null
});
}
if (currentUser != null)
{
var identityProviderExists = false;
lock (_providers)
identityProviderExists = _providers.ContainsKey(identityProvider.FullName);
if (!identityProviderExists)
{
try
{
var authenticateInstance = Activator.CreateInstance(identityProvider.Type) as IAuthenticate;
lock (_providers)
{
if (!_providers.ContainsKey(identityProvider.FullName))
{
_providers.Add(identityProvider.FullName, authenticateInstance);
authenticateInstance = null;
}
}
if (authenticateInstance != null && authenticateInstance is IDisposable)
{
((IDisposable)authenticateInstance).Dispose();
}
}
catch (Exception ex)
{
return(new ValidateUserResult()
{
Status = AuthenticationStatus.ErrorInValidate,
Message = ex.Message
});
}
}
IAuthenticate provider = null;
lock (_providers)
provider = _providers[identityProvider.FullName];
result = provider.ValidateToken(token);
}
else
{
result.Status = AuthenticationStatus.InvalidUserNameOrPassword;
result.Message = Resources.Invalid_UsernameOrPassword;
result.User = null;
}
return(result);
}
/// <summary>
/// Valida o usuário no provedor de identidade
/// </summary>
/// <param name="userName">Nome de usuário</param>
/// <param name="password">Senha</param>
/// <param name="parameters">Demais informações necessárias</param>
/// <returns></returns>
public virtual IValidateUserResult ValidateUser(string userName, string password, SecurityParameter[] parameters)
{
IValidateUserResult result = new ValidateUserResult();
var currentUser = GetUser(userName, false) as Security.Authentication.IAutheticableUser;
if ((currentUser == null) || (String.IsNullOrEmpty(currentUser.UserKey)))
{
return(new ValidateUserResult()
{
Status = AuthenticationStatus.InvalidUserNameOrPassword,
Message = Resources.Invalid_UsernameOrPassword,
User = null
});
}
var identityProvider = Microsoft.Practices.ServiceLocation.ServiceLocator.Current.GetInstance <IIdentityProviderManager>().GetProviderById(currentUser.IdentityProviderId);
if (identityProvider == null)
{
return(new ValidateUserResult()
{
Status = AuthenticationStatus.UnknownError,
Message = string.Format(Resources.Error_IdentityProviderNotFound, userName),
User = null
});
}
if (currentUser != null)
{
var captcha = Microsoft.Practices.ServiceLocation.ServiceLocator.Current.GetInstance <ICaptcha>();
if (!currentUser.IgnoreCaptcha)
{
if ((InvalidLogin.ContainsKey(userName)) && (InvalidLogin[userName] >= 3))
{
string captchaStr = GetParameterValue(parameters, "CaptchaString") ?? String.Empty;
string guidStr = GetParameterValue(parameters, "CaptchaGuid") ?? String.Empty;
if ((!String.IsNullOrEmpty(captchaStr)) && (!String.IsNullOrEmpty(guidStr)))
{
Guid guid = new Guid(guidStr);
if (!captcha.IsCorrect(guid, captchaStr))
{
result.Status = AuthenticationStatus.InvalidCaptcha;
result.Message = Resources.Invalid_Captcha;
result.Captcha = CreateCaptcha(parameters, captcha);
return(result);
}
}
else
{
result.Status = AuthenticationStatus.CaptchaRequired;
result.Message = Resources.Captcha_Necessary;
result.Captcha = CreateCaptcha(parameters, captcha);
return(result);
}
}
}
var identityProviderExists = false;
lock (_providers)
identityProviderExists = _providers.ContainsKey(identityProvider.FullName);
if (!identityProviderExists)
{
if (identityProvider.Type == null)
{
return new ValidateUserResult()
{
Status = AuthenticationStatus.ErrorInValidate,
Message = ResourceMessageFormatter.Create(() => Properties.Resources.Error_IdentityProviderTypeUndefined).Format()
}
}
;
try
{
var authenticateInstance = Activator.CreateInstance(identityProvider.Type) as IAuthenticate;
lock (_providers)
{
if (!_providers.ContainsKey(identityProvider.FullName))
{
_providers.Add(identityProvider.FullName, authenticateInstance);
authenticateInstance = null;
}
}
if (authenticateInstance != null && authenticateInstance is IDisposable)
{
((IDisposable)authenticateInstance).Dispose();
}
}
catch (Exception ex)
{
return(new ValidateUserResult()
{
Status = AuthenticationStatus.ErrorInValidate,
Message = ex.Message
});
}
}
IAuthenticate provider = null;
lock (_providers)
provider = _providers[identityProvider.FullName];
result = provider.ValidateUser(userName, password, parameters);
if (result.Status == AuthenticationStatus.Success)
{
if (InvalidLogin.ContainsKey(userName))
{
InvalidLogin.Remove(userName);
}
if ((result.ExpireDate.HasValue) && (result.ExpireDate.Value > DateTime.Today) && (identityProvider.WarningDays > 0) && (System.DateTime.Today.AddDays(identityProvider.WarningDays) >= result.ExpireDate))
{
result.Message = String.Format(Resources.Warning_Password, result.ExpireDate.Value.Subtract(ServerData.GetDate()).Days);
result.Status = AuthenticationStatus.PasswordWarning;
}
Security.ITokenProvider tokenFramework = Microsoft.Practices.ServiceLocation.ServiceLocator.Current.GetInstance <ITokenProvider>();
string oldToken = tokenFramework.GetToken(Convert.ToInt32(currentUser.UserKey));
if (!String.IsNullOrEmpty(oldToken))
{
if ((GetParameterValue(parameters, "ForceToken") ?? "False").ToUpper().Equals("TRUE"))
{
tokenFramework.Close(oldToken);
}
else
{
result.Status = AuthenticationStatus.DuplicateToken;
result.Message = Resources.Error_TokenDuplicate;
return(result);
}
}
do
{
result.Token = tokenFramework.Create(256);
}while (tokenFramework.Check(result.Token).Success);
result.User = currentUser;
tokenFramework.CloseUserTokens(Convert.ToInt32(result.User.UserKey));
if (!tokenFramework.Insert(result.Token, Convert.ToInt32(result.User.UserKey)))
{
result.Status = AuthenticationStatus.ErrorTokenControl;
result.Message = Resources.Error_TokenCreate;
result.User = null;
}
}
else if (result.Status == AuthenticationStatus.InvalidUserNameOrPassword)
{
if (!currentUser.IgnoreCaptcha)
{
if (!InvalidLogin.ContainsKey(userName))
{
InvalidLogin.Add(userName, 1);
}
else
{
InvalidLogin[userName]++;
}
if (InvalidLogin[userName] >= 3)
{
result.Captcha = CreateCaptcha(parameters, captcha);
}
}
}
}
else
{
result.Status = AuthenticationStatus.InvalidUserNameOrPassword;
result.Message = Resources.Invalid_UsernameOrPassword;
result.User = null;
}
return(result);
}
