internal CharacterSet GetFont(Guid?FontID)
{
if (FontID == null)
{
throw new ArgumentNullException();
}
return(CharSets.FirstOrDefault(set => set.UID == FontID));
}
private CaptchaControl(bool ignoreCase, CharSets charSets, int charCount, int width, int height, string guid)
{
Guid = guid;
IgnoreCase = ignoreCase;
CharCount = charCount;
this.Width = new Unit(width);
this.Height = new Unit(height);
Password = this.GetType().AssemblyQualifiedName;
CharSet = CharSet;
}
public void GetPassword(int length, CharSets sets)
{
if (sets == CharSets.None) throw new Exception("No acceptable characters defined");
var chars = new List<char>();
if (sets.HasFlag(CharSets.N123)) chars.AddRange("0123456789".ToCharArray());
if (sets.HasFlag(CharSets.ABC)) chars.AddRange("ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray());
if (sets.HasFlag(CharSets.abc)) chars.AddRange("abcdefghijklmnopqrstuvwxyz".ToCharArray());
if (sets.HasFlag(CharSets.Other)) chars.AddRange("!@#$%^&*()_+".ToCharArray());
var result = "";
var buffer = CryptographicBuffer.GenerateRandom((uint)length);
//foreach(var b in buffer)
//{
// result += chars[b % chars.Count];
//}
}
public static string GenerateEntropy(string password, string salt, CharSets sets,
uint keySize, Algorithms digest, int length, uint iterations)
{
string algorithm;
switch (digest)
{
case Algorithms.Sha256:
algorithm = KeyDerivationAlgorithmNames.Pbkdf2Sha256;
break;
case Algorithms.Sha384:
algorithm = KeyDerivationAlgorithmNames.Pbkdf2Sha384;
break;
case Algorithms.Sha512:
algorithm = KeyDerivationAlgorithmNames.Pbkdf2Sha512;
break;
default:
throw new ArgumentOutOfRangeException();
}
KeyDerivationAlgorithmProvider provider = KeyDerivationAlgorithmProvider.OpenAlgorithm(algorithm);
// This is our secret password
IBuffer buffSecret = CryptographicBuffer.ConvertStringToBinary(password, BinaryStringEncoding.Utf8);
// Use the provided salt
IBuffer buffSalt = CryptographicBuffer.ConvertStringToBinary(salt, BinaryStringEncoding.Utf8);
// Create the derivation parameters.
KeyDerivationParameters pbkdf2Params = KeyDerivationParameters.BuildForPbkdf2(buffSalt, iterations);
// Create a key from the secret value.
CryptographicKey keyOriginal = provider.CreateKey(buffSecret);
// Derive a key based on the original key and the derivation parameters.
IBuffer keyDerived = CryptographicEngine.DeriveKeyMaterial(
keyOriginal,
pbkdf2Params,
keySize
);
// Return the buffer as a hex string
return(CryptographicBuffer.EncodeToHexString(keyDerived));
}
public static string RenderPassword(CharSets sets, string entropy, int maxLength)
{
// Compute password
BigInteger quotient = BigInteger.Parse('0' + entropy, NumberStyles.AllowHexSpecifier);
char[] possibleChars = GetCharacterSet(sets, out var allSets);
int setsCount = allSets.Length;
maxLength -= setsCount;
char[] passwordChars = new char[maxLength];
int charsLength = possibleChars.Length;
for (int i = 0; i < maxLength; i++)
{
quotient = BigInteger.DivRem(quotient, charsLength, out BigInteger remainder);
passwordChars[i] = possibleChars[(int)remainder];
}
// Add one char per rule
char[] additionalChars = new char[setsCount];
for (int i = 0; i < setsCount; i++)
{
char[] set = allSets[i];
quotient = BigInteger.DivRem(quotient, set.Length, out BigInteger remainder);
additionalChars[i] = set[(int)remainder];
}
// Randomly distribute rule-chars into password-chars
string password = new string(passwordChars);
for (int i = 0; i < setsCount; i++)
{
quotient = BigInteger.DivRem(quotient, password.Length, out BigInteger remainder);
int iRem = (int)remainder;
password = string.Concat(
password.Substring(0, iRem), additionalChars[i].ToString(), password.Substring(iRem)
);
}
return(password);
}
public void Load(String fileName)
{
Clear(false);
Path = fileName;
XElement xml = XElement.Load(fileName);
foreach (XElement node in xml.Elements("font"))
{
AddCharSet(CharacterSet.Load(this, node), false);
}
foreach (XElement node in xml.Elements("include"))
{
AddInclude(node.Value, false);
}
foreach (XElement node in xml.Elements("map"))
{
Map loadedMap = MapDeserializer.Load(this, node);
AddMap(loadedMap, false);
CharacterSet characterSet = CharSets.FirstOrDefault(set => set.UID == loadedMap.FontID);
if (characterSet == null)
{
MessageBox.Show("Unknown font: " + loadedMap.FontID);
}
}
IsNew = false;
IsDirty = false;
StrutureTreeChanged?.Invoke(this, null);
}
public static char[] GetCharacterSet(CharSets sets, out char[][] allSets)
{
int length = 0;
int allSetsLength = 0;
// Compute length in advance
if ((sets & CharSets.Lowercase) == CharSets.Lowercase)
{
length += 26;
allSetsLength++;
}
if ((sets & CharSets.Uppercase) == CharSets.Uppercase)
{
length += 26;
allSetsLength++;
}
if ((sets & CharSets.Numbers) == CharSets.Numbers)
{
length += 10;
allSetsLength++;
}
if ((sets & CharSets.Symbols) == CharSets.Symbols)
{
length += 32;
allSetsLength++;
}
// Make string
int index = 0;
int setIndex = 0;
char[] buffer = new char[length];
allSets = new char[allSetsLength][];
if ((sets & CharSets.Lowercase) == CharSets.Lowercase)
{
LowercaseLetters.CopyTo(0, buffer, 0, 26);
index += 26;
allSets[setIndex++] = LowercaseLetters.ToCharArray();
}
if ((sets & CharSets.Uppercase) == CharSets.Uppercase)
{
UppercaseLetters.CopyTo(0, buffer, index, 26);
index += 26;
allSets[setIndex++] = UppercaseLetters.ToCharArray();
}
if ((sets & CharSets.Numbers) == CharSets.Numbers)
{
Numbers.CopyTo(0, buffer, index, 10);
index += 10;
allSets[setIndex++] = Numbers.ToCharArray();
}
if ((sets & CharSets.Symbols) == CharSets.Symbols)
{
Symbols.CopyTo(0, buffer, index, 32);
allSets[setIndex] = Symbols.ToCharArray();
}
return(buffer);
}
public static Task <string> GenerateAsync(string password, string salt, CharSets sets = CharSets.All,
uint keySize = 32, Algorithms digest = Algorithms.Sha256, int length = 16, uint iterations = 100_000,
public static string Generate(string password, string salt, CharSets sets = CharSets.All,
uint keySize = 32, Algorithms digest = Algorithms.Sha256, int length = 16, uint iterations = 100_000)
{
return(RenderPassword(sets, GenerateEntropy(password, salt, sets, keySize, digest, length, iterations), length));
}
private CharacterSet findExistingCharsetByFileName(string fontFileName)
{
string exactFontPath = PathHelper.GetExactPath(Path, fontFileName);
return(CharSets.FirstOrDefault(set => set.Path.Equals(exactFontPath, StringComparison.OrdinalIgnoreCase)));
}
//protected override object SaveViewState()
//{
// object baseState = base.SaveViewState();
// object[] allStates = new object[3];
// allStates[0] = baseState;
// allStates[1] = CaptchaHelper.EncryptString(_code, Password);
// allStates[2] = this.ImageUrl;
// return allStates;
//}
//protected override void LoadViewState(object savedState)
//{
// if (savedState != null)
// {
// object[] myState = (object[])savedState;
// if (myState[0] != null)
// base.LoadViewState(myState[0]);
// if (myState[1] != null)
// _code = CaptchaHelper.DecryptString((string)myState[1], Password);
// if (myState[2] != null)
// ImageUrl = (string)myState[2];
// }
//}
public static CaptchaControl CreateControl(bool ignoreCase, CharSets charSets, int charCount, int width, int height, string guid)
{
CaptchaControl control = new CaptchaControl(ignoreCase, charSets, charCount, width, height, guid);
return(control);
}
