static void Main(string[] args)
{
string password = "******";
PasswordPolicy p = new PasswordPolicy();
string newPassword = PasswordPolicy.Encrypt(password, 1204385);
}
private static bool IsValid(PasswordPolicy password)
{
var items = password.Password
.ToCharArray()
.GroupBy(x => x)
.ToDictionary(x => x.Key.ToString(), y => y.Count());
return(items.ContainsKey(password.Required) &&
items[password.Required] >= password.Minimum &&
items[password.Required] <= password.Maximum);
}
internal bool CheckResetOnFirstLogin(Guid TenantCode)
{
PasswordPolicy passwordpolicy = getPasswordPolicy(TenantCode, true);
var isnew = false;
if (passwordpolicy != null)
{
isnew = passwordpolicy.ResetOnFirstLogin.Value;
}
return(isnew);
}
public IEnumerable <ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
{
PasswordPolicy policy = Chimera.Authentication.Shared.Configuration.Settings.GetPasswordPolicy();
var rule = new ModelClientValidationRule();
rule.ValidationType = "passwordpolicy";
rule.ValidationParameters["policyexpr"] = policy.GetExpression();
rule.ErrorMessage = policy.GetDescription(metadata.DisplayName);
yield return(rule);
}
public void CanMatchMinNoOfNumbers()
{
// Arrange
PasswordPolicy policy = new PasswordPolicy
{
MinNoOfNumbers = 3
};
// Act + Assert
Assert.IsTrue(policy.IsValid("a12b3"));
Assert.IsFalse(policy.IsValid("a1xb3"));
}
public void CanMatchPasswordLength()
{
// Arrange
PasswordPolicy policy = new PasswordPolicy
{
MinPasswordLength = 5
};
// Act + Assert
Assert.IsTrue(policy.IsValid("12345"));
Assert.IsFalse(policy.IsValid("1234"));
}
public bool CheckPasswordRecoveryStatus(PasswordPolicy passwordpolicy)
{
bool isValid = false;
List <String> error = new List <String>();
if (passwordpolicy.AllowRecoveryViaMail != null)
{
isValid = passwordpolicy.AllowRecoveryViaMail.Value;
}
return(isValid);
}
public void CanMatchMaxNoOfAllowedCharacterRepetitions()
{
// Arrange
PasswordPolicy policy = new PasswordPolicy
{
MaxNoOfAllowedCharacterRepetitions = 2
};
// Act + Assert
Assert.IsTrue(policy.IsValid("aabb"));
Assert.IsFalse(policy.IsValid("xaaay"));
}
public bool Insert_Update_PasswordPolicy(PasswordPolicy InputData)
{
try
{
MasterBL bl = new MasterBL();
return(bl.Insert_Update_PasswordPolicy(InputData));
}
catch (Exception)
{
throw;
}
}
public void Should_parse_example_policies(
string policyString,
int expectedMin,
int expectedMax,
char expectedChar)
{
var policy = PasswordPolicy.Parse(policyString);
Assert.Equal(expectedMin, policy.Min);
Assert.Equal(expectedMax, policy.Max);
Assert.Equal(expectedChar, policy.Char);
}
public void IdentityManagementServiceGetAccountPasswordPolicy()
{
#region 5e4598c7-c425-431f-8af1-19073b3c4a5f
var response = client.GetAccountPasswordPolicy(new GetAccountPasswordPolicyRequest
{
});
PasswordPolicy passwordPolicy = response.PasswordPolicy;
#endregion
}
public void CanMatchPasswordLength()
{
// Arrange
PasswordPolicy policy = new PasswordPolicy
{
MinPasswordLength = 5
};
// Act + Assert
Assert.IsTrue(policy.IsValid("12345"));
Assert.IsFalse(policy.IsValid("1234"));
}
public void CanMatchMinNoOfNumbers()
{
// Arrange
PasswordPolicy policy = new PasswordPolicy
{
MinNoOfNumbers = 3
};
// Act + Assert
Assert.IsTrue(policy.IsValid("a12b3"));
Assert.IsFalse(policy.IsValid("a1xb3"));
}
public void ValidatePasswordPositions(int min, int max, char character, string password, bool expectedResult)
{
var validator = new PasswordValidator();
var policy = new PasswordPolicy
{
Min = min,
Max = max,
Character = character
};
Assert.Equal(expectedResult, validator.ValidatePasswordPositions(password, policy));
}
static void Main(string[] args)
{
IPasswordPolicy password = new PasswordPolicy(new NewPolicy());
for (int i = 0; i < 10; i++)
{
var pswd = password.Generate();
Console.WriteLine(password.ToString());
Console.WriteLine(pswd.GetPassword());
Console.WriteLine(pswd.SecurePassword);
pswd.SavePassword(x =>
{
Console.WriteLine("Password save method :: " + x);
});
Console.WriteLine("Password strength :: " + pswd.GetPasswordStrength());
Console.WriteLine("Password shuffle text :: " + pswd.ShuffleText());
Console.WriteLine("Password Validate as per policy :: " + password.IsValid(pswd.SecurePassword));
}
var userNameClass = new UserNameClass();
userNameClass = password.AutoSetPassword <UserNameClass>(userNameClass, x => x.Password);
List <UserNameClass> userNames = new List <UserNameClass>();
userNames.Add(new UserNameClass
{
UserName = "******"
});
userNames.Add(new UserNameClass
{
UserName = "******"
});
var userPassword = password.AutoSetPassword <UserNameClass>(userNames, x => x.Password);
var userNameClasss = password.RenderPassword <UserNameClass>(userNames, (u, s) =>
{
u.Password = s.SecurePassword;
});
string uniq = password.RenderUniquePassword(x =>
{
Console.WriteLine(x);
return(true);
}, 2);
Console.WriteLine("Hello World!");
Console.ReadLine();
}
private void CreateNUButton_Click(object sender, EventArgs e)
{
//New User Form Parameters = No Boxes Blank, PW and ConfirmPW must be same, PW requirements
//Validate all Text Box entries and New User create in SQL Database, return to LogIn Page
var username = usernameBox.Text;
var password = passwordBox.Text;
var confirmPw = confirmPwBox.Text;
var firstname = firstNameBox.Text;
var lastname = lastnameBox.Text;
var email = emailBox.Text;
var address = addressBox.Text;
var city = cityBox.Text;
var state = stateBox.Text;
var zipcode = zipCodeBox.Text;
bool passwordPolicy = PasswordPolicy.IsValid(password);
if (username == "" || password == "" || confirmPw == "" || firstname == "" || lastname == "" || email == "" || address == "" ||
city == "" || state == "" || zipcode == "")
{
MessageBox.Show("Empty Fields Detected! Please fill up all the fields");
return;
}
if (password != confirmPw)
{
MessageBox.Show("Password and Confirm does not match");
return;
}
if (passwordPolicy == false)
{
MessageBox.Show("Password must be at least 7 characters, must include at least one upper " +
"case letter, one lower case letter, one special character " +
"and one numeric digit.");
return;
}
bool r = validate_NewUser(username, password, firstname, lastname, email, address, city, state, zipcode);
if (r)
{
MessageBox.Show("New User Created!");
var logInPage = new LogIn();
Hide();
logInPage.Show();
}
else
{
MessageBox.Show("Fail");
}
}
public static bool ValidatePassword(string passwordstring)
{
PasswordPolicy policy = DecodeString(passwordstring);
int count = policy.Password.ToCharArray().Where(p => p == policy.Char).Count();
if (count < policy.Lower || count > policy.Upper)
{
return(false);
}
return(true);
}
public static (PasswordPolicy passwordPolicy, string password) Parse(string passwordAndPolicy)
{
var passWordAndPolicy = passwordAndPolicy.Split(": ");
var password = passWordAndPolicy[1];
var policyParts = passwordAndPolicy.Replace('-', ' ').Split(' ');
var min = int.Parse(policyParts[0]);
var max = int.Parse(policyParts[1]);
var character = policyParts[2][0];
var passwordPolicy = new PasswordPolicy(min, max, character);
return(passwordPolicy, password);
}
public override bool IsValid(object value)
{
string pwd = value as string;
if (pwd == null)
{
return(false);
}
PasswordPolicy policy = Configuration.Settings.GetPasswordPolicy();
return(policy.IsValid(pwd));
}
public void TestValidateNullPasswordFails()
{
var pp = new PasswordPolicy
{
MinimumPasswordLength = 5,
MustContainDigits = false,
MustContainLowerCaseCharacters = false,
MustContainSpecialCharacters = false,
MustContainUpperCaseCharacters = false
};
Assert.Throws <ValidationException>(() => PasswordPolicyHelper.ValidatePassword(pp, null));
}
public void TestValidateMustContainUpperCaseCharsPasses()
{
var pp = new PasswordPolicy
{
MinimumPasswordLength = 1,
MustContainDigits = false,
MustContainLowerCaseCharacters = false,
MustContainSpecialCharacters = false,
MustContainUpperCaseCharacters = true
};
Assert.DoesNotThrow(() => PasswordPolicyHelper.ValidatePassword(pp, "aaaaAA"));
}
public bool CheckPasswordChangeAccess(Guid tenantId)
{
PasswordPolicy passwordpolicy = getPasswordPolicy(tenantId, true);
bool isValid = true;
List <String> error = new List <String>();
if (passwordpolicy != null)
{
isValid = passwordpolicy.CanUserChangeOwnPassword.Value;
}
return(isValid);
}
public void CanMatchMinNoOfMinNoOfLowerCaseChars()
{
// Arrange
PasswordPolicy policy = new PasswordPolicy
{
MinNoOfLowerCaseChars = 3
};
// Act + Assert
Assert.IsTrue(policy.IsValid("1a2bc"));
Assert.IsFalse(policy.IsValid("1A2bC"));
Assert.IsFalse(policy.IsValid("1A2BC"));
}
/// <summary>
/// Tests the password for compliance against the supplied password policy
/// </summary>
/// <param name="password">The password to test for compliance</param>
/// <param name="pwdPolicy">The PasswordPolicy that we are testing that the Password complies with</param>
/// <param name="pwdPolicyException">The exception that will contain why the Password does not meet the PasswordPolicy</param>
/// <returns>True for Password Compliance with the Policy</returns>
public static Boolean TryPasswordPolicyCompliance(String password, PasswordPolicy pwdPolicy, ref PasswordPolicyException pwdPolicyException)
{
try
{
CheckPasswordPolicyCompliance(password, pwdPolicy);
return(true);
}
catch (PasswordPolicyException ex)
{
pwdPolicyException = ex;
return(false);
}
}
public void TestValidateAllFailsSpecial()
{
var pp = new PasswordPolicy
{
MinimumPasswordLength = 5,
MustContainDigits = true,
MustContainLowerCaseCharacters = true,
MustContainSpecialCharacters = true,
MustContainUpperCaseCharacters = true
};
Assert.Throws <ValidationException>(() => PasswordPolicyHelper.ValidatePassword(pp, "12345aA"));
}
/// <summary>
/// Tests the password for compliance against the supplied password policy
/// </summary>
/// <param name="password">The password to test for compliance</param>
/// <param name="pwdPolicy">The PasswordPolicy that we are testing that the Password complies with</param>
/// <returns>True for Password Compliance with the Policy</returns>
public static bool TryPasswordPolicyCompliance(string password, PasswordPolicy pwdPolicy)
{
try
{
PCheckPasswordPolicyCompliance(password, pwdPolicy);
return(true);
}
catch
{
}
return(false);
}
static bool CheckPasswordPolicy(PasswordPolicy passwordPolicy)
{
int count = 0;
foreach (char c in passwordPolicy.password)
{
if (c == passwordPolicy.c)
{
count++;
}
}
return(count >= passwordPolicy.num1 && count <= passwordPolicy.num2);
}
public static PasswordPolicy DecodeString(string passwordstring)
{
PasswordPolicy policy = new PasswordPolicy();
List <string> splitString = passwordstring.Split(" ").ToList();
policy.Lower = splitString[0].Split("-").First().ToInt();
policy.Upper = splitString[0].Split("-").Last().ToInt();
policy.Char = splitString[1].First();
policy.Password = splitString[2];
return(policy);
}
public void CanMatchMinNoOfMinNoOfLowerCaseChars()
{
// Arrange
PasswordPolicy policy = new PasswordPolicy
{
MinNoOfLowerCaseChars = 3
};
// Act + Assert
Assert.IsTrue(policy.IsValid("1a2bc"));
Assert.IsFalse(policy.IsValid("1A2bC"));
Assert.IsFalse(policy.IsValid("1A2BC"));
}
static bool CheckPasswordPolicy2(PasswordPolicy passwordPolicy)
{
int matchCount = 0;
if (passwordPolicy.password[passwordPolicy.num1 - 1] == passwordPolicy.c)
{
matchCount++;
}
if (passwordPolicy.password[passwordPolicy.num2 - 1] == passwordPolicy.c)
{
matchCount++;
}
return(matchCount == 1);
}
/// <summary>
/// Returns true if the user account password has expired, false otherwise.
/// </summary>
/// <param name="userAccount">The user account to check.</param>
/// <param name="passwordPolicy">The password policy.</param>
/// <returns>True if the password has expired, false otherwise.</returns>
private static bool HasAccountPasswordExpired(UserAccount userAccount, PasswordPolicy passwordPolicy)
{
if (userAccount == null)
{
throw new ArgumentNullException("userAccount");
}
if (passwordPolicy == null)
{
throw new ArgumentNullException("passwordPolicy");
}
return(DateTime.UtcNow > GetUserAccountPasswordExpiryDate(userAccount, passwordPolicy));
}
public void PasswordPolicy_IsValid_fails_invalidwords()
{
var policy = new PasswordPolicy();
policy.InvalidWords.Add("jim");
Assert.IsFalse(policy.IsValid("Password123"));
Assert.IsFalse(policy.IsValid("Pa$$word123"));
Assert.IsFalse(policy.IsValid("Pa$$w0rd123"));
Assert.IsFalse(policy.IsValid("Passw0rd123"));
Assert.IsFalse(policy.IsValid("P@ssword123"));
Assert.IsFalse(policy.IsValid("AdMin123!&*("));
Assert.IsFalse(policy.IsValid("adMin123!&*("));
Assert.IsFalse(policy.IsValid("@dMin123!&*("));
Assert.IsFalse(policy.IsValid("AdM1n123!&*("));
Assert.IsFalse(policy.IsValid("AdM!n123!&*("));
Assert.IsFalse(policy.IsValid("AdM!n123!&*("));
Assert.IsFalse(policy.IsValid("AdM!n123!&*("));
Assert.IsFalse(policy.IsValid("AdM!n123!&*("));
Assert.IsFalse(policy.IsValid("ådmin123!&*(M"));
Assert.IsFalse(policy.IsValid("àdmin123!&*(M"));
Assert.IsFalse(policy.IsValid("ádmin123!&*(M"));
Assert.IsFalse(policy.IsValid("ãdmin123!&*(M"));
Assert.IsFalse(policy.IsValid("ädmin123!&*(M"));
Assert.IsFalse(policy.IsValid("ạdmin123!&*(M"));
Assert.IsFalse(policy.IsValid("Jimbo456"));
Assert.IsFalse(policy.IsValid("J!mbo456"));
Assert.IsFalse(policy.IsValid("Jimb0456"));
Assert.IsFalse(policy.IsValid("jimbo456"));
Assert.IsFalse(policy.IsValid("qwerty345B;"));
Assert.IsFalse(policy.IsValid("qw3rty345B;"));
Assert.IsFalse(policy.IsValid("qwer7y345B;"));
Assert.IsFalse(policy.IsValid("qwerty345B;"));
Assert.IsFalse(policy.IsValid("princess"));
Assert.IsFalse(policy.IsValid("qw3rty345B;"));
Assert.IsFalse(policy.IsValid("qwer7y345B;"));
Assert.IsFalse(policy.IsValid("qwerty345B;"));
Assert.IsFalse(policy.IsValid("Fr@nk789!!", "frank"));
Assert.IsFalse(policy.IsValid("G3orge789!!", "frank", "george"));
Assert.IsFalse(policy.IsValid("acme789!!Bob", "frank", "george", "acme"));
Assert.IsFalse(policy.IsValid("cute!!BobFrank;;", "cute"));
Assert.IsFalse(policy.IsValid("çute!!BobFrank;;", "cute"));
Assert.IsFalse(policy.IsValid("ćute!!BobFrank;;", "cute"));
}
public static bool IsValid(string line, PasswordPolicy policy = PasswordPolicy.Old)
{
var parts = line.Split(" ");
var(a, b, letter, password) = (int.Parse(parts[0].Split("-")[0]), int.Parse(parts[0].Split("-")[1]), parts[1][0], parts[2]);
if (policy == PasswordPolicy.Old)
{
var letterCount = password.Count(l => l == letter);
return(letterCount >= a && letterCount <= b);
}
return((password[a - 1] == letter || password[b - 1] == letter) && !(password[a - 1] == letter && password[b - 1] == letter));
}
protected PasswordEntry PasswordEntryFromFileLine(string line)
{
var password = PasswordFromLine(line);
var policyletter = PolicyLetterFromLine(line);
var policyMax = PolicyMaxFromLine(line);
var policyMin = PolicyMinFromLine(line);
var passwordPolicy = new PasswordPolicy {
Letter = policyletter, Position2 = policyMax, Position1 = policyMin
};
return(new PasswordEntry {
Password = password, PwPolicy = passwordPolicy
});
}
/// <summary>
/// Tests the password for compliance against the supplied password policy
/// </summary>
/// <param name="password">The password to test for compliance</param>
/// <param name="pwdPolicy">The PasswordPolicy that we are testing that the Password complies with</param>
/// <returns>True for Password Compliance with the Policy</returns>
public static Boolean TryPasswordPolicyCompliance(String password, PasswordPolicy pwdPolicy)
{
Boolean isCompliant = true;
try
{
PCheckPasswordPolicyCompliance(password, pwdPolicy);
}
catch
{
isCompliant = false;
}
return isCompliant;
}
public void CanMatchMaxNoOfAllowedCharacterRepetitions()
{
// Arrange
PasswordPolicy policy = new PasswordPolicy
{
MaxNoOfAllowedCharacterRepetitions = 2
};
// Act + Assert
Assert.IsTrue(policy.IsValid("aabb"));
Assert.IsFalse(policy.IsValid("xaaay"));
}
public void LeveledCheck(string password, int expectedRate) {
var policy = new PasswordPolicy(password);
Console.WriteLine(policy);
Assert.AreEqual(expectedRate,policy.Rate);
}
/// <summary>
/// Tests the password for compliance against the supplied password policy
/// </summary>
/// <param name="password">The password to test for compliance</param>
/// <param name="pwdPolicy">The PasswordPolicy that we are testing that the Password complies with</param>
/// <returns>True for Password Compliance with the Policy</returns>
public static Boolean TryPasswordPolicyCompliance(String password, PasswordPolicy pwdPolicy)
{
try
{
PCheckPasswordPolicyCompliance(password, pwdPolicy);
return true;
}
catch
{
}
return false;
}
public void CanDescribeValidationRules()
{
// Arrange
PasswordPolicy policy1 = new PasswordPolicy { MinPasswordLength = 5 };
PasswordPolicy policy2 = new PasswordPolicy { MinNoOfLowerCaseChars = 2 };
PasswordPolicy policy3 = new PasswordPolicy { MinNoOfUpperCaseChars = 2 };
PasswordPolicy policy4 = new PasswordPolicy { MinNoOfNumbers = 2 };
PasswordPolicy policy5 = new PasswordPolicy { MaxNoOfAllowedCharacterRepetitions = 3 };
PasswordPolicy policy6 = new PasswordPolicy
{
MinPasswordLength = 1,
MinNoOfLowerCaseChars = 2,
MinNoOfUpperCaseChars = 3,
MinNoOfNumbers = 4,
MaxNoOfAllowedCharacterRepetitions = 5
};
PasswordPolicy policy7 = new PasswordPolicy();
// Act + Assert
Assert.AreEqual("password must be at least 5 characters long", policy1.GetDescription("password"));
Assert.AreEqual("password must contain at least 2 lower case characters", policy2.GetDescription("password"));
Assert.AreEqual("password must contain at least 2 upper case characters", policy3.GetDescription("password"));
Assert.AreEqual("password must contain at least 2 numbers", policy4.GetDescription("password"));
Assert.AreEqual("password must contain at most 3 character repetitions", policy5.GetDescription("password"));
Assert.AreEqual("password must be at least 1 characters long, contain at least 2 lower case characters, contain at least 3 upper case characters, contain at least 4 numbers, contain at most 5 character repetitions", policy6.GetDescription("password"));
Assert.IsNull(policy7.GetDescription("password"));
}
/// <summary>
/// Tests the password for compliance against the supplied password policy
/// </summary>
/// <param name="password">The password to test for compliance</param>
/// <param name="pwdPolicy">The PasswordPolicy that we are testing that the Password complies with</param>
/// <param name="pwdPolicyException">The exception that will contain why the Password does not meet the PasswordPolicy</param>
/// <returns>True for Password Compliance with the Policy</returns>
public static Boolean TryPasswordPolicyCompliance(String password, PasswordPolicy pwdPolicy, ref PasswordPolicyException pwdPolicyException)
{
try
{
PCheckPasswordPolicyCompliance(password, pwdPolicy);
return true;
}
catch(PasswordPolicyException ex)
{
pwdPolicyException = ex;
}
return false;
}
private static void PCheckPasswordPolicyCompliance(String password, PasswordPolicy pwdPolicy)
{
if (new Regex(CNumbersRegex).Matches(password).Count<pwdPolicy.ForceXNumeric)
{
throw new PasswordPolicyException("The password must contain "+pwdPolicy.ForceXNumeric+" numeric [0-9] characters");
}
if (new Regex(CNonAlphaNumericRegex).Matches(password).Count < pwdPolicy.ForceXNonAlphaNumeric)
{
throw new PasswordPolicyException("The password must contain "+pwdPolicy.ForceXNonAlphaNumeric+" special characters");
}
if (new Regex(CUppercaseRegex).Matches(password).Count < pwdPolicy.ForceXUpperCase)
{
throw new PasswordPolicyException("The password must contain "+pwdPolicy.ForceXUpperCase+" uppercase characters");
}
if (password.Length < pwdPolicy.PasswordMinLength)
{
throw new PasswordPolicyException("The password does not have a length of at least "+pwdPolicy.PasswordMinLength+" characters");
}
if (password.Length > pwdPolicy.PasswordMaxLength)
{
throw new PasswordPolicyException("The password is longer than "+pwdPolicy.PasswordMaxLength+" characters");
}
}
