private static List <string> GetCharacterGroups(PasswordGenerationOptions options)
{
List <string> groups = new List <string>();
if (options.UpperCase)
{
groups.Add(UpperCaseChars);
}
if (options.LowerCase)
{
groups.Add(LowerCaseChars);
}
if (options.Digits)
{
groups.Add(DigitChars);
}
if (options.Minus)
{
groups.Add(MinusChars);
}
if (options.Underline)
{
groups.Add(UnderlineChars);
}
if (options.Space)
{
groups.Add(SpaceChars);
}
if (options.Specials)
{
groups.Add(SpecialChars);
}
if (options.SpecialsExtended)
{
groups.Add(ExtendedChars);
}
if (options.Brackets)
{
groups.Add(BracketChars);
}
if (options.ExcludeLookAlike)
{
for (int i = 0; i < groups.Count; i++)
{
groups[i] = String.Join("", groups[i].Except("Il1|8B6GO0"));
}
}
return(groups);
}
//--------------------------------------------------
// constructor
public PasswordGenerator(PasswordGenerationOptions pgo)
{
this.pgo = pgo;
FillCharsets();
Init();
}
EnforcePasswordGeneratorPoliciesOnOptionsAsync(PasswordGenerationOptions options)
{
var enforcedPolicyOptions = await GetPasswordGeneratorPolicyOptions();
if (enforcedPolicyOptions != null)
{
if (options.Length < enforcedPolicyOptions.MinLength)
{
options.Length = enforcedPolicyOptions.MinLength;
}
if (enforcedPolicyOptions.UseUppercase)
{
options.Uppercase = true;
}
if (enforcedPolicyOptions.UseLowercase)
{
options.Lowercase = true;
}
if (enforcedPolicyOptions.UseNumbers)
{
options.Number = true;
}
if (options.MinNumber < enforcedPolicyOptions.NumberCount)
{
options.MinNumber = enforcedPolicyOptions.NumberCount;
}
if (enforcedPolicyOptions.UseSpecial)
{
options.Special = true;
}
if (options.MinSpecial < enforcedPolicyOptions.SpecialCount)
{
options.MinSpecial = enforcedPolicyOptions.SpecialCount;
}
// Must normalize these fields because the receiving call expects all options to pass the current rules
if (options.MinSpecial + options.MinNumber > options.Length)
{
options.MinSpecial = options.Length - options.MinNumber;
}
}
else
{
// UI layer expects an instantiated object to prevent more explicit null checks
enforcedPolicyOptions = new PasswordGeneratorPolicyOptions();
}
return(options, enforcedPolicyOptions);
}
private void AssertPasswords(PasswordGenerationOptions options, Action <string, PasswordGenerationOptions> assertAction)
{
using (PasswordGenerator pg = new PasswordGenerator())
{
string pass;
for (int i = 0; i < NumberOfRunsPerTest; i++)
{
pass = pg.Generate(options);
assertAction(pass, options);
}
}
}
public string GeneratePassword(PasswordGenerationOptions options)
{
var pwProfile = new PwProfile
{
GeneratorType = PasswordGeneratorType.CharSet,
Length = (uint)options.PasswordLength,
CharSet = new PwCharSet()
};
if (options.UpperCasePatternSelected)
{
pwProfile.CharSet.Add(PwCharSet.UpperCase);
}
if (options.LowerCasePatternSelected)
{
pwProfile.CharSet.Add(PwCharSet.LowerCase);
}
if (options.DigitsPatternSelected)
{
pwProfile.CharSet.Add(PwCharSet.Digits);
}
if (options.SpecialPatternSelected)
{
pwProfile.CharSet.Add(PwCharSet.Special);
}
if (options.MinusPatternSelected)
{
pwProfile.CharSet.Add('-');
}
if (options.UnderscorePatternSelected)
{
pwProfile.CharSet.Add('_');
}
if (options.SpacePatternSelected)
{
pwProfile.CharSet.Add(' ');
}
if (options.BracketsPatternSelected)
{
pwProfile.CharSet.Add(PwCharSet.Brackets);
}
pwProfile.CharSet.Add(options.CustomChars);
ProtectedString password;
PwGenerator.Generate(out password, pwProfile, null, new CustomPwGeneratorPool());
return(password.ReadString());
}
private void AssertSinglePasswordGroups(string password, PasswordGenerationOptions options)
{
Assert.True(password.Length == (int)options.Length, "Length is not ok");
int numberOfUpper = password.Count(options.ValidUpperCase.Contains);
int numberOfLower = password.Count(options.ValidLowerCase.Contains);
int numberOfSymbols = password.Count(options.ValidSymbols.Contains);
int numberOfNumbers = password.Count("0123456789".Contains);
Assert.True(numberOfLower >= options.MinLowerCase, "Number of lower case is less than minimum");
Assert.True(numberOfUpper >= options.MinUpperCase, "Number of upper case is less than minimum");
Assert.True(numberOfSymbols >= options.MinSymbols, "Number of symbols is less than minimum");
Assert.True(numberOfNumbers >= options.MinNumbers, "Number of numbers is less than minimum");
}
public void Merge(PasswordGenerationOptions defaults)
{
Length = Length ?? defaults.Length;
Ambiguous = Ambiguous ?? defaults.Ambiguous;
Number = Number ?? defaults.Number;
MinNumber = MinNumber ?? defaults.MinNumber;
Uppercase = Uppercase ?? defaults.Uppercase;
MinUppercase = MinUppercase ?? defaults.MinUppercase;
Lowercase = Lowercase ?? defaults.Lowercase;
MinLowercase = MinLowercase ?? defaults.MinLowercase;
Special = Special ?? defaults.Special;
MinSpecial = MinSpecial ?? defaults.MinSpecial;
Type = Type ?? defaults.Type;
NumWords = NumWords ?? defaults.NumWords;
WordSeparator = WordSeparator ?? defaults.WordSeparator;
}
public async Task <PasswordGenerationOptions> GetOptionsAsync()
{
if (_optionsCache == null)
{
var options = await _storageService.GetAsync <PasswordGenerationOptions>(Keys_Options);
if (options == null)
{
_optionsCache = _defaultOptions;
}
else
{
options.Merge(_defaultOptions);
_optionsCache = options;
}
}
return(_optionsCache);
}
public string Handle(GeneratePasswordCommand message)
{
var options = new PasswordGenerationOptions
{
PasswordLength = message.PasswordLength,
BracketsPatternSelected = message.BracketsPatternSelected,
CustomChars = message.CustomChars,
DigitsPatternSelected = message.DigitsPatternSelected,
LowerCasePatternSelected = message.LowerCasePatternSelected,
MinusPatternSelected = message.MinusPatternSelected,
SpacePatternSelected = message.SpacePatternSelected,
SpecialPatternSelected = message.SpecialPatternSelected,
UnderscorePatternSelected = message.UnderscorePatternSelected,
UpperCasePatternSelected = message.UpperCasePatternSelected
};
return(_security.GeneratePassword(options));
}
public void Merge(PasswordGenerationOptions defaults)
{
Length = Length ?? defaults.Length;
AllowAmbiguousChar = AllowAmbiguousChar ?? defaults.AllowAmbiguousChar;
Number = Number ?? defaults.Number;
MinNumber = MinNumber ?? defaults.MinNumber;
Uppercase = Uppercase ?? defaults.Uppercase;
MinUppercase = MinUppercase ?? defaults.MinUppercase;
Lowercase = Lowercase ?? defaults.Lowercase;
MinLowercase = MinLowercase ?? defaults.MinLowercase;
Special = Special ?? defaults.Special;
MinSpecial = MinSpecial ?? defaults.MinSpecial;
Type = Type ?? defaults.Type;
NumWords = NumWords ?? defaults.NumWords;
WordSeparator = WordSeparator ?? defaults.WordSeparator;
Capitalize = Capitalize ?? defaults.Capitalize;
IncludeNumber = IncludeNumber ?? defaults.IncludeNumber;
}
private bool IsSinglePasswordInRange(string password, PasswordGenerationOptions options)
{
Func <IEnumerable <int>, bool> areIndexesInRange = (numbers) =>
{
if (numbers.Count() == 0)
{
return(false);
}
if (numbers.Count() != numbers.Distinct().Count())
{
throw new ArgumentException("numbers are not unique");
}
return(numbers.Max() - numbers.Min() == numbers.Count() - 1);
};
Func <string, List <int> > getGroupIndexes = (string group) =>
{
List <int> indexes = new List <int>();
for (int i = 0; i < password.Length; i++)
{
if (group.Contains(password[i]))
{
indexes.Add(i);
}
}
return(indexes);
};
Func <string, bool> isGroupInRange = (group) =>
{
var indexes = getGroupIndexes(group);
return(areIndexesInRange(indexes));
};
bool lowerAreInRange = isGroupInRange(options.ValidLowerCase);
bool upperAreInRange = isGroupInRange(options.ValidUpperCase);
bool symbolsAreIsInRange = isGroupInRange(options.ValidSymbols);
bool numbersAreInRange = isGroupInRange("0123456789");
return(lowerAreInRange && upperAreInRange && symbolsAreIsInRange && numbersAreInRange);
}
public async Task <string> GeneratePassphraseAsync(PasswordGenerationOptions options)
{
options.Merge(_defaultOptions);
if (options.NumWords.GetValueOrDefault() <= 2)
{
options.NumWords = _defaultOptions.NumWords;
}
if (options.WordSeparator == null || options.WordSeparator.Length == 0 || options.WordSeparator.Length > 1)
{
options.WordSeparator = " ";
}
if (options.Capitalize == null)
{
options.Capitalize = false;
}
if (options.IncludeNumber == null)
{
options.IncludeNumber = false;
}
var listLength = EEFLongWordList.Instance.List.Count - 1;
var wordList = new List <string>();
for (int i = 0; i < options.NumWords.GetValueOrDefault(); i++)
{
var wordIndex = await _cryptoService.RandomNumberAsync(0, listLength);
if (options.Capitalize.GetValueOrDefault())
{
wordList.Add(Capitalize(EEFLongWordList.Instance.List[wordIndex]));
}
else
{
wordList.Add(EEFLongWordList.Instance.List[wordIndex]);
}
}
if (options.IncludeNumber.GetValueOrDefault())
{
await AppendRandomNumberToRandomWordAsync(wordList);
}
return(string.Join(options.WordSeparator, wordList));
}
public async Task <string> GeneratePassphraseAsync(PasswordGenerationOptions options)
{
options.Merge(_defaultOptions);
if (options.NumWords.GetValueOrDefault() <= 2)
{
options.NumWords = _defaultOptions.NumWords;
}
if (options.WordSeparator == null || options.WordSeparator.Length == 0 || options.WordSeparator.Length > 1)
{
options.WordSeparator = " ";
}
var listLength = WordList.EEFLongWordList.Count - 1;
var wordList = new List <string>();
for (int i = 0; i < options.NumWords.GetValueOrDefault(); i++)
{
var wordIndex = await _cryptoService.RandomNumberAsync(0, listLength);
wordList.Add(WordList.EEFLongWordList[wordIndex]);
}
return(string.Join(options.WordSeparator, wordList));
}
public async Task <(PasswordGenerationOptions, PasswordGeneratorPolicyOptions)> GetOptionsAsync()
{
if (_optionsCache == null)
{
var options = await _storageService.GetAsync <PasswordGenerationOptions>(Keys_Options);
if (options == null)
{
_optionsCache = _defaultOptions;
}
else
{
options.Merge(_defaultOptions);
_optionsCache = options;
}
}
var(enforcedOptions, enforcedPolicyOptions) = await EnforcePasswordGeneratorPoliciesOnOptionsAsync(
_optionsCache);
_optionsCache = enforcedOptions;
return(_optionsCache, enforcedPolicyOptions);
}
public void NormalizeOptions(PasswordGenerationOptions options,
PasswordGeneratorPolicyOptions enforcedPolicyOptions)
{
options.MinLowercase = 0;
options.MinUppercase = 0;
if (!options.Uppercase.GetValueOrDefault() && !options.Lowercase.GetValueOrDefault() &&
!options.Number.GetValueOrDefault() && !options.Special.GetValueOrDefault())
{
options.Lowercase = true;
}
var length = options.Length.GetValueOrDefault();
if (length < 5)
{
options.Length = 5;
}
else if (length > 128)
{
options.Length = 128;
}
if (options.Length < enforcedPolicyOptions.MinLength)
{
options.Length = enforcedPolicyOptions.MinLength;
}
if (options.MinNumber == null)
{
options.MinNumber = 0;
}
else if (options.MinNumber > options.Length)
{
options.MinNumber = options.Length;
}
else if (options.MinNumber > 9)
{
options.MinNumber = 9;
}
if (options.MinNumber < enforcedPolicyOptions.NumberCount)
{
options.MinNumber = enforcedPolicyOptions.NumberCount;
}
if (options.MinSpecial == null)
{
options.MinSpecial = 0;
}
else if (options.MinSpecial > options.Length)
{
options.MinSpecial = options.Length;
}
else if (options.MinSpecial > 9)
{
options.MinSpecial = 9;
}
if (options.MinSpecial < enforcedPolicyOptions.SpecialCount)
{
options.MinSpecial = enforcedPolicyOptions.SpecialCount;
}
if (options.MinSpecial + options.MinNumber > options.Length)
{
options.MinSpecial = options.Length - options.MinNumber;
}
if (options.NumWords == null || options.Length < 3)
{
options.NumWords = 3;
}
else if (options.NumWords > 20)
{
options.NumWords = 20;
}
if (options.NumWords < enforcedPolicyOptions.MinNumberOfWords)
{
options.NumWords = enforcedPolicyOptions.MinNumberOfWords;
}
if (options.WordSeparator != null && options.WordSeparator.Length > 1)
{
options.WordSeparator = options.WordSeparator[0].ToString();
}
SanitizePasswordLength(options, false);
}
public async Task SaveOptionsAsync(PasswordGenerationOptions options)
{
await _storageService.SaveAsync(Keys_Options, options);
_optionsCache = options;
}
public async Task <string> GeneratePasswordAsync(PasswordGenerationOptions options)
{
// Overload defaults with given options
options.Merge(_defaultOptions);
if (options.Type == "passphrase")
{
return(await GeneratePassphraseAsync(options));
}
// Sanitize
SanitizePasswordLength(options, true);
var positionsBuilder = new StringBuilder();
if (options.Lowercase.GetValueOrDefault() && options.MinLowercase.GetValueOrDefault() > 0)
{
for (int i = 0; i < options.MinLowercase.GetValueOrDefault(); i++)
{
positionsBuilder.Append("l");
}
}
if (options.Uppercase.GetValueOrDefault() && options.MinUppercase.GetValueOrDefault() > 0)
{
for (int i = 0; i < options.MinUppercase.GetValueOrDefault(); i++)
{
positionsBuilder.Append("u");
}
}
if (options.Number.GetValueOrDefault() && options.MinNumber.GetValueOrDefault() > 0)
{
for (int i = 0; i < options.MinNumber.GetValueOrDefault(); i++)
{
positionsBuilder.Append("n");
}
}
if (options.Special.GetValueOrDefault() && options.MinSpecial.GetValueOrDefault() > 0)
{
for (int i = 0; i < options.MinSpecial.GetValueOrDefault(); i++)
{
positionsBuilder.Append("s");
}
}
while (positionsBuilder.Length < options.Length.GetValueOrDefault())
{
positionsBuilder.Append("a");
}
// Shuffle
var positions = positionsBuilder.ToString().ToCharArray()
.OrderBy(a => _cryptoFunctionService.RandomNumber()).ToArray();
// Build out other character sets
var allCharSet = string.Empty;
var lowercaseCharSet = LowercaseCharSet;
if (options.Ambiguous.GetValueOrDefault())
{
lowercaseCharSet = string.Concat(lowercaseCharSet, "l");
}
if (options.Lowercase.GetValueOrDefault())
{
allCharSet = string.Concat(allCharSet, lowercaseCharSet);
}
var uppercaseCharSet = UppercaseCharSet;
if (options.Ambiguous.GetValueOrDefault())
{
uppercaseCharSet = string.Concat(uppercaseCharSet, "IO");
}
if (options.Uppercase.GetValueOrDefault())
{
allCharSet = string.Concat(allCharSet, uppercaseCharSet);
}
var numberCharSet = NumberCharSet;
if (options.Ambiguous.GetValueOrDefault())
{
numberCharSet = string.Concat(numberCharSet, "01");
}
if (options.Number.GetValueOrDefault())
{
allCharSet = string.Concat(allCharSet, numberCharSet);
}
var specialCharSet = SpecialCharSet;
if (options.Special.GetValueOrDefault())
{
allCharSet = string.Concat(allCharSet, specialCharSet);
}
var password = new StringBuilder();
for (var i = 0; i < options.Length.GetValueOrDefault(); i++)
{
var positionChars = string.Empty;
switch (positions[i])
{
case 'l':
positionChars = lowercaseCharSet;
break;
case 'u':
positionChars = uppercaseCharSet;
break;
case 'n':
positionChars = numberCharSet;
break;
case 's':
positionChars = specialCharSet;
break;
case 'a':
positionChars = allCharSet;
break;
}
var randomCharIndex = await _cryptoService.RandomNumberAsync(0, positionChars.Length - 1);
password.Append(positionChars[randomCharIndex]);
}
return(password.ToString());
}
EnforcePasswordGeneratorPoliciesOnOptionsAsync(PasswordGenerationOptions options)
{
var enforcedPolicyOptions = await GetPasswordGeneratorPolicyOptions();
if (enforcedPolicyOptions != null)
{
if (options.Length < enforcedPolicyOptions.MinLength)
{
options.Length = enforcedPolicyOptions.MinLength;
}
if (enforcedPolicyOptions.UseUppercase)
{
options.Uppercase = true;
}
if (enforcedPolicyOptions.UseLowercase)
{
options.Lowercase = true;
}
if (enforcedPolicyOptions.UseNumbers)
{
options.Number = true;
}
if (options.MinNumber < enforcedPolicyOptions.NumberCount)
{
options.MinNumber = enforcedPolicyOptions.NumberCount;
}
if (enforcedPolicyOptions.UseSpecial)
{
options.Special = true;
}
if (options.MinSpecial < enforcedPolicyOptions.SpecialCount)
{
options.MinSpecial = enforcedPolicyOptions.SpecialCount;
}
// Must normalize these fields because the receiving call expects all options to pass the current rules
if (options.MinSpecial + options.MinNumber > options.Length)
{
options.MinSpecial = options.Length - options.MinNumber;
}
if (options.NumWords < enforcedPolicyOptions.MinNumberOfWords)
{
options.NumWords = enforcedPolicyOptions.MinNumberOfWords;
}
if (enforcedPolicyOptions.Capitalize)
{
options.Capitalize = true;
}
if (enforcedPolicyOptions.IncludeNumber)
{
options.IncludeNumber = true;
}
// Force default type if password/passphrase selected via policy
if (enforcedPolicyOptions.DefaultType == "password" || enforcedPolicyOptions.DefaultType == "passphrase")
{
options.Type = enforcedPolicyOptions.DefaultType;
}
}
else
{
// UI layer expects an instantiated object to prevent more explicit null checks
enforcedPolicyOptions = new PasswordGeneratorPolicyOptions();
}
return(options, enforcedPolicyOptions);
}
protected bool Equals(PasswordGenerationOptions other)
{
return(Length == other.Length && UpperCase == other.UpperCase && LowerCase == other.LowerCase && Digits == other.Digits && Minus == other.Minus && Underline == other.Underline && Space == other.Space && Specials == other.Specials && SpecialsExtended == other.SpecialsExtended && Brackets == other.Brackets && ExcludeLookAlike == other.ExcludeLookAlike && AtLeastOneFromEachGroup == other.AtLeastOneFromEachGroup);
}
public void ClearCache()
{
_optionsCache = null;
_history = null;
}
public async Task <(PasswordGenerationOptions, PasswordGeneratorPolicyOptions)> GetOptionsAsync()
{
if (_optionsCache == null)
{
var options = await _storageService.GetAsync <PasswordGenerationOptions>(Keys_Options);
if (options == null)
{
_optionsCache = _defaultOptions;
}
else
{
options.Merge(_defaultOptions);
_optionsCache = options;
}
}
var enforcedPolicyOptions = await GetPasswordGeneratorPolicyOptions();
if (enforcedPolicyOptions != null)
{
if (_optionsCache.Length < enforcedPolicyOptions.MinLength)
{
_optionsCache.Length = enforcedPolicyOptions.MinLength;
}
if (enforcedPolicyOptions.UseUppercase)
{
_optionsCache.Uppercase = true;
}
if (enforcedPolicyOptions.UseLowercase)
{
_optionsCache.Lowercase = true;
}
if (enforcedPolicyOptions.UseNumbers)
{
_optionsCache.Number = true;
}
if (_optionsCache.MinNumber < enforcedPolicyOptions.NumberCount)
{
_optionsCache.MinNumber = enforcedPolicyOptions.NumberCount;
}
if (enforcedPolicyOptions.UseSpecial)
{
_optionsCache.Special = true;
}
if (_optionsCache.MinSpecial < enforcedPolicyOptions.SpecialCount)
{
_optionsCache.MinSpecial = enforcedPolicyOptions.SpecialCount;
}
// Must normalize these fields because the receiving call expects all options to pass the current rules
if (_optionsCache.MinSpecial + _optionsCache.MinNumber > _optionsCache.Length)
{
_optionsCache.MinSpecial = _optionsCache.Length - _optionsCache.MinNumber;
}
}
else
{
// UI layer expects an instantiated object to prevent more explicit null checks
enforcedPolicyOptions = new PasswordGeneratorPolicyOptions();
}
return(_optionsCache, enforcedPolicyOptions);
}
private void AssertPasswordGroups(PasswordGenerationOptions options) => AssertPasswords(options, AssertSinglePasswordGroups);
public string GetCharacterSet(PasswordGenerationOptions options, List <string> groups)
{
var characterSet = String.Join("", groups);
return(characterSet);
}
private void SanitizePasswordLength(PasswordGenerationOptions options, bool forGeneration)
{
var minUppercaseCalc = 0;
var minLowercaseCalc = 0;
var minNumberCalc = options.MinNumber;
var minSpecialCalc = options.MinNumber;
if (options.Uppercase.GetValueOrDefault() && options.MinUppercase.GetValueOrDefault() <= 0)
{
minUppercaseCalc = 1;
}
else if (!options.Uppercase.GetValueOrDefault())
{
minUppercaseCalc = 0;
}
if (options.Lowercase.GetValueOrDefault() && options.MinLowercase.GetValueOrDefault() <= 0)
{
minLowercaseCalc = 1;
}
else if (!options.Lowercase.GetValueOrDefault())
{
minLowercaseCalc = 0;
}
if (options.Number.GetValueOrDefault() && options.MinNumber.GetValueOrDefault() <= 0)
{
minNumberCalc = 1;
}
else if (!options.Number.GetValueOrDefault())
{
minNumberCalc = 0;
}
if (options.Special.GetValueOrDefault() && options.MinSpecial.GetValueOrDefault() <= 0)
{
minSpecialCalc = 1;
}
else if (!options.Special.GetValueOrDefault())
{
minSpecialCalc = 0;
}
// This should never happen but is a final safety net
if (options.Length.GetValueOrDefault() < 1)
{
options.Length = 10;
}
var minLength = minUppercaseCalc + minLowercaseCalc + minNumberCalc + minSpecialCalc;
// Normalize and Generation both require this modification
if (options.Length < minLength)
{
options.Length = minLength;
}
// Apply other changes if the options object passed in is for generation
if (forGeneration)
{
options.MinUppercase = minUppercaseCalc;
options.MinLowercase = minLowercaseCalc;
options.MinNumber = minNumberCalc;
options.MinSpecial = minSpecialCalc;
}
}
public async Task SaveOptionsAsync(PasswordGenerationOptions options)
{
await _stateService.SetPasswordGenerationOptionsAsync(options);
_optionsCache = options;
}
public void NormalizeOptions(PasswordGenerationOptions options)
{
options.MinLowercase = 0;
options.MinUppercase = 0;
if (!options.Uppercase.GetValueOrDefault() && !options.Lowercase.GetValueOrDefault() &&
!options.Number.GetValueOrDefault() && !options.Special.GetValueOrDefault())
{
options.Lowercase = true;
}
var length = options.Length.GetValueOrDefault();
if (length < 5)
{
options.Length = 5;
}
else if (length > 128)
{
options.Length = 128;
}
if (options.MinNumber == null)
{
options.MinNumber = 0;
}
else if (options.MinNumber > options.Length)
{
options.MinNumber = options.Length;
}
else if (options.MinNumber > 9)
{
options.MinNumber = 9;
}
if (options.MinSpecial == null)
{
options.MinSpecial = 0;
}
else if (options.MinSpecial > options.Length)
{
options.MinSpecial = options.Length;
}
else if (options.MinSpecial > 9)
{
options.MinSpecial = 9;
}
if (options.MinSpecial + options.MinNumber > options.Length)
{
options.MinSpecial = options.Length - options.MinNumber;
}
if (options.NumWords == null || options.Length < 3)
{
options.NumWords = 3;
}
else if (options.NumWords > 20)
{
options.NumWords = 20;
}
if (options.WordSeparator != null && options.WordSeparator.Length > 1)
{
options.WordSeparator = options.WordSeparator[0].ToString();
}
}
