static public void TestStringHash64()
{
StringHashing.ClearReverseLookup();
int collisionCount = 0;
StringHashing.SetOnCollision((a, b, s, h) => collisionCount++);
for (int i = -1000; i <= 1000; ++i)
{
new StringHash64(i.ToString());
}
string allText = File.ReadAllText("Assets/Editor/words.txt");
foreach (var word in StringSlice.EnumeratedSplit(allText, new char[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries))
{
word.Hash64();
}
if (collisionCount > 0)
{
Debug.LogErrorFormat("[StringTests] {0} collisions with hash size 16", collisionCount);
}
StringHashing.SetOnCollision(null);
}
public static string CalculateHash(string tbInput, string cbAlgo, string cbEncFormat, bool rbPosStartChecked, bool rbPosEndChecked, string cbEncTypes, string tbSalt, bool addSalt)
{
ResetBaseData();
SetBaseData(tbInput, "Input Value", cbAlgo, cbEncFormat, rbPosStartChecked, rbPosEndChecked, cbEncTypes, tbSalt, addSalt);
return(StringHashing.ComputeHash(_plainText, _hashAlgorithm, _salt, _encryptionFormat, _encodingType, _saltPosition, _addSaltToHash));
}
public void OnBeforeSerialize()
{
if (m_Hash == 0 && !string.IsNullOrEmpty(m_Source))
{
m_Hash = StringHashing.Hash32(m_Source, 0, m_Source.Length);
}
#if !DEVELOPMENT_BUILD && !DEVELOPMENT
// TODO: Figure out a way of selectively stripping strings from the non-debug builds
// if (!BuildPipeline.isBuildingPlayer)
// return;
// m_Source = string.Empty;
#endif // !DEVELOPMENT_BUILD && !DEVELOPMENT
}
private static string SaveHashedFile(string tbImport)
{
string fileOutputName = GetOutputFileName(tbImport);
if (File.Exists(tbImport))
{
StreamReader sReader = new StreamReader(tbImport);
StreamWriter sWriter = new StreamWriter(fileOutputName);
while (!sReader.EndOfStream)
{
string plainPwd = sReader.ReadLine();
string hashedPwd = StringHashing.ComputeHash(plainPwd, _hashAlgorithm, _salt, _encryptionFormat, _encodingType, _saltPosition, _addSaltToHash);
sWriter.WriteLine(plainPwd + ";" + hashedPwd);
}
sWriter.Close();
sReader.Close();
}
return(fileOutputName);
}
public StringHash64(string inString)
{
m_HashValue = StringHashing.StoreHash64(inString, 0, inString == null ? 0 : inString.Length);
}
public string ToDebugString()
{
return(StringHashing.ReverseLookup64(m_HashValue));
}
internal ulong AppendHash64(ulong inHash)
{
return(StringHashing.AppendHash64(inHash, m_Source, m_StartIndex, Length));
}
internal ulong CalculateHash64()
{
return(StringHashing.StoreHash64(m_Source, m_StartIndex, Length));
}
internal uint AppendHash32(uint inHash)
{
return(StringHashing.AppendHash32(inHash, m_Source, m_StartIndex, Length));
}
internal uint CalculateHash32()
{
return(StringHashing.StoreHash32(m_Source, m_StartIndex, Length));
}
public static byte[] GetSaltByte(string tbSalt, StringUtil.ENCODING_TYPES encodingType)
{
return(!string.IsNullOrWhiteSpace(tbSalt) ? StringUtil.GetEncoder(encodingType).GetBytes(tbSalt) : StringHashing.GenerateRandomSalt());
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
label = EditorGUI.BeginProperty(position, label, property);
Rect propRect = position;
propRect.width -= TypeDisplayWidth - 4;
Rect typeRect = new Rect(propRect.xMax + 4, propRect.y, TypeDisplayWidth, propRect.height);
// type
int lastIndent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
EditorGUI.BeginChangeCheck();
var typeProp = property.FindPropertyRelative("m_Type");
VariantType type = (VariantType)typeProp.intValue;
type = (VariantType)EditorGUI.EnumPopup(typeRect, type);
if (EditorGUI.EndChangeCheck())
{
typeProp.intValue = (int)type;
}
EditorGUI.indentLevel = lastIndent;
// value
var rawProp = property.FindPropertyRelative("m_RawValue");
uint rawValue = (uint)rawProp.longValue;
switch (type)
{
case VariantType.Null:
{
EditorGUI.LabelField(propRect, label, new GUIContent("Null value"));
break;
}
case VariantType.Int:
{
int intVal = GetInt(rawValue);
int newVal = EditorGUI.IntField(propRect, label, intVal);
if (newVal != intVal)
{
rawProp.longValue = GetRaw(newVal);
}
break;
}
case VariantType.UInt:
{
uint uintVal = rawValue;
uint newVal = (uint)EditorGUI.LongField(propRect, label, uintVal);
if (newVal != uintVal)
{
rawProp.longValue = newVal;
}
break;
}
case VariantType.Float:
{
float floatVal = GetFloat(rawValue);
float newVal = EditorGUI.FloatField(propRect, label, floatVal);
if (newVal != floatVal)
{
rawProp.longValue = GetRaw(newVal);
}
break;
}
case VariantType.Bool:
{
bool boolVal = GetBool(rawValue);
bool bNewVal = EditorGUI.Toggle(propRect, label, boolVal);
if (bNewVal != boolVal)
{
rawProp.longValue = GetRaw(bNewVal);
}
break;
}
case VariantType.StringHash:
{
var stringProp = property.FindPropertyRelative("m_StringHashSource");
string stringVal = stringProp.stringValue;
string newVal = EditorGUI.TextField(propRect, label, stringVal);
if (stringVal != newVal)
{
stringProp.stringValue = newVal;
rawProp.longValue = StringHashing.Hash32(newVal, 0, newVal.Length);
}
break;
}
}
EditorGUI.EndProperty();
}
