public Unhash(
NFSRaiderForm sender, HashFactory hashFactory, bool checkForHashesInFile, bool tryToBruteForce, string txtPrefixes, string txtSuffixes, string txtVariations,
string txtWordsBetweenVariations, string txtMinVariations, string txtMaxVariations, string processorCount, GenerateOption generateOption, Endianness unhashingEndianness, CaseOptions caseOption)
{
Sender = sender;
HashFactory = hashFactory;
CaseOption = caseOption;
Hashes = new HashSet <uint>();
Prefixes = new HashSet <string>(txtPrefixes.SplitBy(new[] { ',' }, '\\'));
Suffixes = new HashSet <string>(txtSuffixes.SplitBy(new[] { ',' }, '\\'));
WordsBetweenVariations = new HashSet <string>(txtWordsBetweenVariations.SplitBy(new[] { ',' }, '\\'));
ProcessorCount = Convert.ToInt32(processorCount);
VariationsGroups = new List <Variation>();
VariationModel = new Variation
{
MinVariations = Convert.ToInt32(txtMinVariations),
MaxVariations = Convert.ToInt32(txtMaxVariations),
GenerateOption = generateOption,
};
UnhashingEndianness = unhashingEndianness;
CheckForHashesInFile = checkForHashesInFile;
TryToBruteForce = tryToBruteForce;
InitializeVariatons(txtVariations.SplitBy(new[] { ',' }, '\\'));
}
public Dictionary <uint, string> ReadHashesFile(HashFactory hashFactory, CaseOptions caseOption)
{
var hashes = new BuildTruncatedStrings().GetAllTruncatedStrings();
if (!File.Exists(UserFileName))
{
File.Create(UserFileName).Close();
}
if (!File.Exists(FileName))
{
GetStrings();
GC.Collect();
}
var files = new List <string>()
{
UserFileName, FileName
};
var caseFactory = CaseFactory.GetCaseType(caseOption);
var collisions = new HashSet <string>();
uint currentHexValue;
foreach (var file in files)
{
using (var fileStream = File.OpenRead(file))
using (var streamReader = new StreamReader(fileStream, Encoding.UTF8, true))
{
var line = string.Empty;
while ((line = streamReader.ReadLine()) != null)
{
line = caseFactory.ChangeCase(line);
currentHexValue = hashFactory.Hash(line);
if (hashes.ContainsKey(currentHexValue))
{
if (hashes[currentHexValue] != line)
{
collisions.Add(line);
}
}
else
{
hashes.Add(currentHexValue, line);
}
}
}
}
foreach (var collision in collisions)
{
currentHexValue = hashFactory.Hash(collision);
hashes[currentHexValue] += " / " + collision;
}
return(hashes);
}
/// <summary>
/// 根据大小写选项决定字符串查找选项
/// </summary>
/// <param name="caseOption"></param>
/// <returns></returns>
public static StringComparison ToStringComparison(this CaseOptions caseOption)
{
if (caseOption == CaseOptions.CaseSensitive)
{
return(StringComparison.Ordinal);
}
else
{
return(StringComparison.OrdinalIgnoreCase);
}
}
/// <summary>
/// 字符串是否与数组中的任意一项相等
/// </summary>
/// <param name="s"></param>
/// <param name="option">大小写选项</param>
/// <param name="array"></param>
/// <returns></returns>
public static bool In(this string s, CaseOptions option, params string[] array)
{
StringComparison comparison = option.ToStringComparison();
foreach (string i in array)
{
if (i.Equals(s, comparison))
{
return(true);
}
}
return(false);
}
public static CaseFactory GetCaseType(CaseOptions caseOption)
{
switch (caseOption)
{
case CaseOptions.Lowercase:
return(new LowerCase());
case CaseOptions.Uppercase:
return(new UpperCase());
default:
return(new KeepCase());
}
}
public CaseService(OnlineSalesContext context,
IHttpContextAccessor httpContext,
IRoleCache roleCache,
ILogger <CaseService> logger,
ListQuery <OnlineOrder, CaseDTO> q,
IIndusService indus,
IOptions <CaseOptions> options,
IMailerService mail)
: base(httpContext, context)
{
_logger = logger;
_query = q;
_roleCache = roleCache;
_indus = indus;
_mail = mail;
_options = options.Value;
}
public async Task <IList <Model.Case> > IndexData(
long?id = null,
long?source = null,
DateTimeOffset?from = null,
DateTimeOffset?to = null,
[FromQuery] long[] status = null,
[FromQuery] Guid[] offenceType = null,
[FromQuery] Guid[] assignedTo = null,
[FromQuery] Guid[] managedBy = null)
{
var options = new CaseOptions
{
ID = id,
OffenceType = offenceType,
Source = source,
ManagedBy = managedBy,
AssignedTo = assignedTo,
Status = status,
From = from,
To = to
};
return(await _caseService.Query(options));
}
/// <summary>
/// 字符串不是数组中的任意一项
/// </summary>
/// <param name="s"></param>
/// <param name="option"></param>
/// <param name="array"></param>
/// <returns></returns>
public static bool NotIn(this string s, CaseOptions option, params string[] array)
{
return(!s.In(option, array));
}
public async Task <IEnumerable <Model.Case> > SelectCase(CaseOptions options)
{
return(await Execute(new SelectCaseCommand(options)));
}
/// <summary>
/// 分隔字符串
/// </summary>
/// <param name="s">要分隔的字符串</param>
/// <param name="separator">分隔符</param>
/// <param name="caseOption">大小写选项</param>
/// <param name="separatorOption">分隔符选项</param>
/// <returns>分隔后的字符串数组</returns>
public static string[] Split(this string s, string separator, CaseOptions caseOption, SeparatorOptions separatorOption)
{
//根据大小写选项决定字符串查找选项
StringComparison comparison = caseOption.ToStringComparison();
//查找起始索引
int startIndex = 0;
//找到的分隔符索引
int separatorIndex = 0;
//分隔出来的字符串列表
List <string> result = new List <string>();
//在文本中查找分隔符
while ((separatorIndex = s.IndexOf(separator, startIndex, comparison)) > -1)
{
//字符串截取起始索引
int substringStartIndex = startIndex;
//字符串截取长度
int substringCount = separatorIndex - startIndex;
//根据分隔符选项决定截取起始索引和截取长度
switch (separatorOption)
{
case SeparatorOptions.NoSeparator:
break;
case SeparatorOptions.PostSeparator:
substringCount += separator.Length;
break;
case SeparatorOptions.PreSeparator:
substringStartIndex -= separator.Length;
substringCount += separator.Length;
break;
}
//如果分隔符不在位置0
//把分隔符前的内容加入结果队列
if (separatorIndex > 0)
{
result.Add(s.Substring(substringStartIndex, substringCount));
}
//更新起始索引
startIndex = separatorIndex + separator.Length;
}
//剩余长度
int restCount = s.Length - startIndex;
//如果还有剩余内容
//把剩余的内容加入结果队列
if (restCount > 0)
{
result.Add(s.Substring(startIndex, restCount));
}
return(result.ToArray());
}
/// <summary>
/// 分隔字符串
/// </summary>
/// <param name="s">要分隔的字符串</param>
/// <param name="separator">分隔符</param>
/// <param name="caseOption">大小写选项</param>
/// <returns>分隔后的字符串数组</returns>
public static string[] Split(this string s, string separator, CaseOptions caseOption)
{
return(s.Split(separator, caseOption, SeparatorOptions.NoSeparator));
}
/// <summary>
/// 替换文本中的字符串
/// </summary>
/// <param name="s">文本</param>
/// <param name="oldValue">要替换的字符串</param>
/// <param name="newValue">取而代之的字符串</param>
/// <param name="caseOption">大小写选项</param>
/// <returns>替换之后的文本</returns>
public static string Replace(this string s, string oldValue, string newValue, CaseOptions caseOption)
{
//根据大小写选项决定字符串查找选项
StringComparison comparison = caseOption.ToStringComparison();
//查找起始索引
int startIndex = 0;
//找到的旧值索引
int oldValueIndex = 0;
//替换处理之后的结果
string result = "";
//在文本中查找要替换的字符串
while ((oldValueIndex = s.IndexOf(oldValue, startIndex, comparison)) >= 0)
{
//把旧值索引前的内容追加到结果中
(oldValueIndex - startIndex).Each(index =>
{
result += s[startIndex + index];
});
//再追加新值
result += newValue;
//更新起始索引
startIndex = oldValueIndex + oldValue.Length;
}
//把剩余的内容追加到结果中
(s.Length - startIndex).Each(index =>
{
result += s[startIndex + index];
});
return(result.ToString());
}
/// <summary>
/// 清除字符串中的指定字符串
/// </summary>
/// <param name="s">字符串</param>
/// <param name="stringToClear">指定字符串</param>
/// <param name="caseOption">大小写选项</param>
/// <returns></returns>
public static string Clear(this string s, string stringToClear, CaseOptions caseOption)
{
return(s.Replace(stringToClear, string.Empty, caseOption));
}
public static List <RaiderResult> UnhashFromFile(Endianness unhashingEndianness, HashFactory hashFactory, uint[] arrayFromFile, CaseOptions caseOption)
{
var allStrings = new AllStrings().ReadHashesFile(hashFactory, caseOption);
var listBox = new List <RaiderResult>();
var isKnown = false;
void AddResult(uint hash)
{
if (allStrings.TryGetValue(hash, out var result))
{
isKnown = true;
}
else
{
if (hash == 0 || hash == uint.MaxValue)
{
result = "--------";
isKnown = true;
}
else
{
result = "HASH_UNKNOWN";
isKnown = false;
}
}
listBox.Add(new RaiderResult()
{
Hash = hash, Value = result, IsKnown = isKnown
});
}
if (unhashingEndianness == Endianness.BigEndian)
{
foreach (var hash in arrayFromFile)
{
AddResult(hash);
}
}
else
{
foreach (var hash in arrayFromFile)
{
AddResult(hash.Reverse());
}
}
return(listBox);
}
public async Task <IEnumerable <Model.Case> > Select(CaseOptions options)
{
var mapper = new CaseMapper();
var assignedToTable = new DataTable();
var managedByTable = new DataTable();
var offenceTypeTable = new DataTable();
var statusTable = new DataTable();
assignedToTable.Columns.Add("Val", typeof(Guid));
managedByTable.Columns.Add("Val", typeof(Guid));
offenceTypeTable.Columns.Add("Val", typeof(Guid));
statusTable.Columns.Add("Val", typeof(long));
if (options.AssignedTo?.Any() ?? false)
{
foreach (var assignedTo in options.AssignedTo)
{
assignedToTable.Rows.Add(assignedTo);
}
}
if (options.ManagedBy?.Any() ?? false)
{
foreach (var managedBy in options.ManagedBy)
{
managedByTable.Rows.Add(managedBy);
}
}
if (options.OffenceType?.Any() ?? false)
{
foreach (var offenceType in options.OffenceType)
{
offenceTypeTable.Rows.Add(offenceType);
}
}
if (options.Status?.Any() ?? false)
{
foreach (var statustype in options.Status)
{
statusTable.Rows.Add(statustype);
}
}
var param = new DynamicParameters();
param.Add("@ID", options.ID);
param.Add("@OffenceType", offenceTypeTable.AsTableValuedParameter("dbo.UniqueIdentifierType"));
param.Add("@Source", options.Source);
param.Add("@ManagedBy", managedByTable.AsTableValuedParameter("dbo.UniqueIdentifierType"));
param.Add("@AssignedTO", assignedToTable.AsTableValuedParameter("dbo.UniqueIdentifierType"));
param.Add("@Status", statusTable.AsTableValuedParameter("dbo.BigIntType"));
param.Add("@From", options.From);
param.Add("@To", options.To);
return((await SqlMapper.QueryAsync(_unitOfWork.Connection,
"SelectCase",
new[]
{
typeof(Model.Case),
typeof(Officer),
typeof(Officer),
typeof(Person),
typeof(Master),
typeof(Master),
typeof(Offender),
},
obj =>
{
return mapper.Map(obj[0] as Model.Case,
obj[6] as Offender,
null,
obj[1] as Officer,
obj[2] as Officer,
obj[3] as Person,
null,
obj[4] as Master,
obj[5] as Master);
},
param,
splitOn: "managedByID,assignedToID,reporterID,breachID,offences,offenderID",
commandType: CommandType.StoredProcedure,
transaction: _unitOfWork.Transaction)).Distinct());
}
private void Button_Click_3(object sender, RoutedEventArgs e)
{
CaseOptions caseOptions = new CaseOptions();
this.NavigationService.Navigate(caseOptions);
}
public async Task <IList <Model.Case> > Query(CaseOptions options)
{
var result = await _apiClient.CaseSdk.Query(options);
return(result);
}
