public static string Sha256_2(string bla)
{
byte[] ba = System.Text.Encoding.UTF8.GetBytes(bla);
using (System.Security.Cryptography.SHA256CryptoServiceProvider sha256 = new System.Security.Cryptography.SHA256CryptoServiceProvider())
{
ba = sha256.ComputeHash(ba);
ba = sha256.ComputeHash(ba);
} // End Using sha256
return(System.BitConverter.ToString(ba).Replace("-", "").ToLowerInvariant());
} // End Function Sha256_2
public static string Sha256(string path)
{
string strResult = "";
string strHashData = "";
byte[] arrbytHashValue;
System.IO.FileStream oFileStream = null;
System.Security.Cryptography.SHA256CryptoServiceProvider sha256Hasher = new System.Security.Cryptography.SHA256CryptoServiceProvider();
try
{
oFileStream = new System.IO.FileStream(path, System.IO.FileMode.Open);
arrbytHashValue = sha256Hasher.ComputeHash(oFileStream);
oFileStream.Close();
strHashData = System.BitConverter.ToString(arrbytHashValue);
strHashData = strHashData.Replace("-", "");
strResult = strHashData;
}
catch (System.Exception ex)
{
throw ex;
}
finally
{
oFileStream.Close();
}
return(strResult);
}
/// <summary>
/// SHA-256
/// </summary>
/// <param name="str"></param>
public static string SHA_256(string str)
{
System.Security.Cryptography.SHA256CryptoServiceProvider sha256Csp = new System.Security.Cryptography.SHA256CryptoServiceProvider();
byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(str);
byte[] bytHash = sha256Csp.ComputeHash(bytValue);
sha256Csp.Clear();
string hashStr = "";
for (int counter = 0; counter < bytHash.Count(); counter++)
{
long i = bytHash[counter] / 16;
var tempStr = "";
if (i > 9)
{
tempStr = ((char)(i - 10 + 0x41)).ToString();
}
else
{
tempStr = ((char)(i + 0x30)).ToString();
}
i = bytHash[counter] % 16;
if (i > 9)
{
tempStr += ((char)(i - 10 + 0x41)).ToString();
}
else
{
tempStr += ((char)(i + 0x30)).ToString();
}
hashStr += tempStr;
}
return(hashStr);
}
private static long GetInt64HashCode(string strText)
{
long hashCode = 0;
if (string.IsNullOrEmpty(strText))
{
return(hashCode);
}
//Unicode Encode Covering all character set
var byteContents = Encoding.Unicode.GetBytes(strText);
System.Security.Cryptography.SHA256 hash =
new System.Security.Cryptography.SHA256CryptoServiceProvider();
var hashText = hash.ComputeHash(byteContents);
//32Byte hashText separate
//hashCodeStart = 0~7 8Byte
//hashCodeMedium = 8~23 8Byte
//hashCodeEnd = 24~31 8Byte
//and Fold
var hashCodeStart = BitConverter.ToInt64(hashText, 0);
var hashCodeMedium = BitConverter.ToInt64(hashText, 8);
var hashCodeEnd = BitConverter.ToInt64(hashText, 24);
hashCode = hashCodeStart ^ hashCodeMedium ^ hashCodeEnd;
return(hashCode);
}
public static string aesDecryptBase64(string SourceStr, ulong Key)
{
string decrypt = "";
try
{
var aes = new System.Security.Cryptography.AesCryptoServiceProvider();
var md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
var sha256 = new System.Security.Cryptography.SHA256CryptoServiceProvider();
byte[] key = sha256.ComputeHash(BitConverter.GetBytes(Key));
byte[] iv = md5.ComputeHash(BitConverter.GetBytes(Key));
aes.Key = key;
aes.IV = iv;
byte[] dataByteArray = Convert.FromBase64String(SourceStr);
using (var ms = new System.IO.MemoryStream())
{
using (var cs = new System.Security.Cryptography.CryptoStream(ms, aes.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Write))
{
cs.Write(dataByteArray, 0, dataByteArray.Length);
cs.FlushFinalBlock();
decrypt = Encoding.UTF8.GetString(ms.ToArray());
}
}
}
catch (Exception e)
{
}
return(decrypt);
}
public byte[] Hash(HashAlgorithmName algName, byte[] inputDataBytes)
{
switch (algName)
{
case HashAlgorithmName.SHA256:
{
using (System.Security.Cryptography.SHA256CryptoServiceProvider hasher = new System.Security.Cryptography.SHA256CryptoServiceProvider())
{
return(hasher.ComputeHash(inputDataBytes));
}
}
case HashAlgorithmName.SHA512:
{
using (System.Security.Cryptography.SHA512CryptoServiceProvider hasher = new System.Security.Cryptography.SHA512CryptoServiceProvider())
{
return(hasher.ComputeHash(inputDataBytes));
}
}
case HashAlgorithmName.MD5:
default:
{
using (System.Security.Cryptography.MD5CryptoServiceProvider hasher = new System.Security.Cryptography.MD5CryptoServiceProvider()) // hash size 128
{
return(hasher.ComputeHash(inputDataBytes));
}
}
}
}
/// <summary>
/// 使用UTF-8进行SHA256签名
/// 加盐&key={sign_key}，若sign_key.IsNullOrWhiteSpace()则不加盐
/// </summary>
/// <param name="content">签名原文</param>
/// <param name="sign_key">签名密钥 为空则不加盐</param>
/// <param name="format">大小写格式化 默认：FromatSign.UPPER</param>
/// <returns></returns>
public static string Sign(string content, string sign_key, FromatSign format = FromatSign.UPPER)
{
if (content.IsNullOrWhiteSpace())
{
return(string.Empty);
}
if (!sign_key.IsNullOrWhiteSpace())
{
content = $"{content}&key={sign_key}";
}
var _format = format == FromatSign.UPPER
? "X2" /*大写*/
: "x2"; /*小写*/
var result = new StringBuilder();
using (var provider = new System.Security.Cryptography.SHA256CryptoServiceProvider())
{
var byte_sign = provider.ComputeHash(Encoding.UTF8.GetBytes(content));
// 把二进制转化为十六进制
for (int i = 0; i < byte_sign.Length; i++)
{
result.Append(byte_sign[i].ToString(format: _format));
}
}
return(result.ToString());
}
private Int64 CalculateTypeIdHash()
{
string strText = Name;
if (Properties.Count > 0)
{
var keys = Properties.Keys.ToList();
keys.Sort();
strText += keys.Aggregate((i, j) => i + j);
}
Int64 hashCode = 0;
if (!string.IsNullOrEmpty(strText))
{
//Unicode Encode Covering all characterset
byte[] byteContents = Encoding.Unicode.GetBytes(strText);
System.Security.Cryptography.SHA256 hash =
new System.Security.Cryptography.SHA256CryptoServiceProvider();
byte[] hashText = hash.ComputeHash(byteContents);
//32Byte hashText separate
//hashCodeStart = 0~7 8Byte
Int64 hashCodeStart = BitConverter.ToInt64(hashText, 0);
//hashCodeMedium = 8~23 8Byte
Int64 hashCodeMedium = BitConverter.ToInt64(hashText, 8);
//hashCodeEnd = 24~31 8Byte
Int64 hashCodeEnd = BitConverter.ToInt64(hashText, 24);
//and Fold
hashCode = hashCodeStart ^ hashCodeMedium ^ hashCodeEnd;
}
return(hashCode);
}
public Boolean ValidaSelloDigital(string selloDigital, string cert, string cadena, out Boolean MD5, out Boolean SHA256, out String Error)
{
Boolean Resultado = false;
MD5 = false;
SHA256 = false;
Error = null;
try
{
Byte[] sello_byte = Convert.FromBase64String(selloDigital);
Byte[] cert_byte = Convert.FromBase64String(cert);
System.Security.Cryptography.X509Certificates.X509Certificate2 certificado = new System.Security.Cryptography.X509Certificates.X509Certificate2(cert_byte);
String spk = certificado.PublicKey.Key.ToXmlString(false);
System.Security.Cryptography.AsymmetricAlgorithm pk = System.Security.Cryptography.AsymmetricAlgorithm.Create();
pk.FromXmlString(spk);
System.Security.Cryptography.RSACryptoServiceProvider rsa = (System.Security.Cryptography.RSACryptoServiceProvider)pk;
rsa.PersistKeyInCsp = false;
Byte[] cadena_byte = System.Text.Encoding.UTF8.GetBytes(cadena);
System.Security.Cryptography.SHA256CryptoServiceProvider x = new System.Security.Cryptography.SHA256CryptoServiceProvider();
Byte[] data = x.ComputeHash(cadena_byte);
System.Security.Cryptography.MD5CryptoServiceProvider x2 = new System.Security.Cryptography.MD5CryptoServiceProvider();
Byte[] data2 = x2.ComputeHash(cadena_byte);
MD5 = rsa.VerifyHash(data2, System.Security.Cryptography.CryptoConfig.MapNameToOID("MD5"), sello_byte);
SHA256 = rsa.VerifyHash(data, System.Security.Cryptography.CryptoConfig.MapNameToOID("SHA256"), sello_byte);
//if (MD5 || SHA1)
Resultado = true;
}
catch (Exception ex)
{
Error = "Error al desencriptar el sello digital Error:" + ex.Message;
}
return(Resultado);
}
public string SHA256(string str)
{
var sha256 = new System.Security.Cryptography.SHA256CryptoServiceProvider();
var bs = sha256.ComputeHash(System.Text.Encoding.UTF8.GetBytes(str));
sha256.Clear();
return bs.Aggregate("", (current, b) => current + (b.ToString("x2")));
}
private Boolean GenerarSelloSHA256(String CadenaOriginal, Certificado cert, out String Resultado, out List <String> ErrorSellado)
{
Boolean Devolver = false;
Resultado = String.Empty;
String SelloDigital = String.Empty;
String ErrorSellador = String.Empty;
ErrorSellado = new List <string>();
System.Security.Cryptography.SHA256CryptoServiceProvider EncriptaSHA256 = new System.Security.Cryptography.SHA256CryptoServiceProvider();
Byte[] CadenaOriginalEnBytes = EncriptaSHA256.ComputeHash(System.Text.Encoding.UTF8.GetBytes(CadenaOriginal));
System.Security.Cryptography.RSACryptoServiceProvider RSA = null;
byte[] keyblob = cert.bKey;
if (keyblob != null)
{
if (SSLKey.opensslkey.DecodeEncryptedPrivateKeyInfo(keyblob, cert.ContrasenaSegura, out RSA, out ErrorSellador))
{
//RSA.FromXmlString(LLavePrivada);
System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter(RSA);
RSAFormatter.SetHashAlgorithm("SHA256");
CadenaOriginalEnBytes = RSAFormatter.CreateSignature(CadenaOriginalEnBytes);
SelloDigital = Convert.ToBase64String(CadenaOriginalEnBytes);
Resultado = SelloDigital;
Devolver = true;
}
else
{
ErrorSellado.Add(ErrorSellador);
}
}
return(Devolver);
}
public static string Sha256Encrypt(string plainTxt)
{
var bytes = System.Text.Encoding.Default.GetBytes(plainTxt);
var sha256 = new System.Security.Cryptography.SHA256CryptoServiceProvider();
var encryptBytes = sha256.ComputeHash(bytes);
return(Convert.ToBase64String(encryptBytes));
}
/// <summary>
/// Calculates SHA256 hash for a byte[] and sets as ETag. Ensures Cache-Control: private header is added.
/// </summary>
/// <param name="response"></param>
/// <param name="content">If byte[] is null or empty, will only add cache-control</param>
public static void AddCacheHeader(this HttpResponse response, byte[] content)
{
if (content == null || content.Length <= 0)
{
return;
}
using var sha1 = new System.Security.Cryptography.SHA256CryptoServiceProvider();
response.Headers.Add("ETag", string.Concat(sha1.ComputeHash(content).Select(x => x.ToString("X2"))));
}
private static string GenerateFileHash(string hashType, string pathToFile)
{
try
{
using (var stream = new FileStream(pathToFile, FileMode.Open, FileAccess.Read, FileShare.None))
{
if (hashType == "md5")
{
using (var hash = new System.Security.Cryptography.MD5CryptoServiceProvider())
{
var data = hash.ComputeHash(stream);
return(BitConverter.ToString(data).Replace("-", "").ToLower());
}
}
else if (hashType == "sha1")
{
using (var hash = new System.Security.Cryptography.SHA1CryptoServiceProvider())
{
var data = hash.ComputeHash(stream);
return(BitConverter.ToString(data).Replace("-", "").ToLower());
}
}
else if (hashType == "sha256")
{
using (var hash = new System.Security.Cryptography.SHA256CryptoServiceProvider())
{
var data = hash.ComputeHash(stream);
return(BitConverter.ToString(data).Replace("-", "").ToLower());
}
}
else if (hashType == "sha384")
{
using (var hash = new System.Security.Cryptography.SHA384CryptoServiceProvider())
{
var data = hash.ComputeHash(stream);
return(BitConverter.ToString(data).Replace("-", "").ToLower());
}
}
else if (hashType == "sha512")
{
using (var hash = new System.Security.Cryptography.SHA512CryptoServiceProvider())
{
var data = hash.ComputeHash(stream);
return(BitConverter.ToString(data).Replace("-", "").ToLower());
}
}
else
{
throw new Exception("Unsupported hashType: " + hashType);
}
}
}
catch (Exception e)
{
return("Error: " + e.Message);
}
}
public virtual Dictionary <ProfileAttributeType, String> GetAttributes(String identifyer)
{
Dictionary <ProfileAttributeType, String> attributes = new Dictionary <ProfileAttributeType, String>();
System.Security.Cryptography.SHA256 sha256 = new System.Security.Cryptography.SHA256CryptoServiceProvider();
Byte[] inputBytes;
Byte[] outputBytes;
string outputString;
string data = "";
switch (Format)
{
case TimestampFormat.aaaammgghhmmss:
data = DateTime.Now.ToString("yyyyMMddHHmm");
break;
}
// Calcolo della chiave di hash
inputBytes = ASCIIEncoding.Default.GetBytes(identifyer + data + SecretKey);
outputBytes = sha256.ComputeHash(inputBytes);
outputString = Convert(outputBytes);
String url = RemoteApiUrl;
if (RemoteApiUrl.Contains("{0}") && RemoteApiUrl.Contains("{1}"))
{
try
{
WebClient webClient = new WebClient();
string json = webClient.DownloadString(String.Format(RemoteApiUrl, identifyer, outputString));
if (!String.IsNullOrEmpty(json) && json != "{\"result\":\"\"}")
{
var deserializer = new System.Web.Script.Serialization.JavaScriptSerializer();
var result = (Dictionary <String, object>)deserializer.DeserializeObject(json);
if (result != null && Attributes != null && Attributes.Where(a => a.Deleted == BaseStatusDeleted.None).Any())
{
foreach (Dictionary <String, object> jStruct in result.Values.Where(v => v != null))
{
foreach (String key in jStruct.Keys)
{
JsonAttribute attribute = Attributes.Where(a => a.Deleted == BaseStatusDeleted.None && a.Name == key.ToLower()).FirstOrDefault();
if (attribute != null)
{
attributes.Add(attribute.Type, jStruct[key].ToString());
}
}
}
}
}
}
catch (ArgumentException e)
{
}
}
return(attributes);
}
public static string GetHash(string input)
{
System.Security.Cryptography.HashAlgorithm hashAlgorithm = new System.Security.Cryptography.SHA256CryptoServiceProvider();
byte[] byteValue = System.Text.Encoding.UTF8.GetBytes(input);
byte[] byteHash = hashAlgorithm.ComputeHash(byteValue);
return(Convert.ToBase64String(byteHash));
}
private static Int64 ComputeTaskHash(string data)
{
if (String.IsNullOrEmpty(data))
{
return(0L);
}
byte[] rawHash;
using (var sha = new System.Security.Cryptography.SHA256CryptoServiceProvider())
rawHash = sha.ComputeHash(Encoding.Unicode.GetBytes(data));
return(BitConverter.ToInt64(rawHash, 0) ^ BitConverter.ToInt64(rawHash, 8) ^ BitConverter.ToInt64(rawHash, 24));
}
public static string Encrypt(string text)
{
if (string.IsNullOrWhiteSpace(text))
{
return("");
}
byte[] byteArray = Encoding.UTF8.GetBytes(text);
using (System.Security.Cryptography.SHA256CryptoServiceProvider shaCSP = new System.Security.Cryptography.SHA256CryptoServiceProvider())
{
return(BitConverter.ToString(shaCSP.ComputeHash(byteArray)).Replace("-", ""));
}
}
/// <summary>
/// It returns the entered data as SHA256 Hash.
/// </summary>
/// <param name="content">Text in string value to be converted to SHA256.</param>
/// <returns>SHA256 output will be returned.</returns>
public string Create(string content)
{
System.Security.Cryptography.SHA256 ee = new System.Security.Cryptography.SHA256CryptoServiceProvider();
ee.ComputeHash(UTF8Encoding.UTF8.GetBytes(content));
byte[] result = ee.Hash;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < result.Length; i++)
{
sb.Append(result[i].ToString("x2"));
}
return(sb.ToString());
}
/// <summary>
/// It is used to calculate the SHA256 Hash data of the file in the specified location.
/// </summary>
/// <param name="file">The location of the file in string value.</param>
/// <returns>SHA256 output of the file will be returned.</returns>
public string FileFingerprint(string file)
{
System.Security.Cryptography.SHA256 ee = new System.Security.Cryptography.SHA256CryptoServiceProvider();
ee.ComputeHash(File.ReadAllBytes(file));
byte[] result = ee.Hash;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < result.Length; i++)
{
sb.Append(result[i].ToString("x2"));
}
return(sb.ToString());
}
internal static bool CheckProcessSignature()
{
if (!IsAttached)
{
return(false);
}
// Create new instance of the SHA256 service provider
var shaCrypt = new System.Security.Cryptography.SHA256CryptoServiceProvider();
var stringHash = new StringBuilder();
try
{
// Read the executable data for the selected process
var exePath = MemorySharp.Modules.MainModule.Path;
var exeBytes = File.ReadAllBytes(exePath);
// Compute module hash
var moduleHash = shaCrypt.ComputeHash(exeBytes);
// Convert hash to string
foreach (var hashByte in moduleHash)
{
stringHash.Append(hashByte.ToString("X2"));
}
}
catch
{
var proceed = MessageBox.Show("An error occurred while validating the selected process:\n{ex.Message}\n\nWould you like to continue anyway?", "Process verification error",
MessageBoxButton.YesNo, MessageBoxImage.Exclamation);
return(proceed == MessageBoxResult.Yes);
}
// Compare against known hashes
if (!FFX_Hashes.Contains(stringHash.ToString()))
{
// No matching hash
Console.WriteLine("Hash: " + stringHash);
var proceed = MessageBox.Show("The selected process does not appear to match any known compatible processes.\n\n" +
"Farplane will attempt to calculate offsets automatically, but proceeding " +
"may cause errors or cause the game to crash. Now is a good time to make a " +
"backup of your saved games!\n\n" +
"Are you sure you wish to continue?", "Unknown process error",
MessageBoxButton.YesNo, MessageBoxImage.Exclamation);
return(proceed == MessageBoxResult.Yes);
}
return(true);
}
public static string GetHash(string url)
{
byte[] input = Encoding.ASCII.GetBytes(url);
var sha = new System.Security.Cryptography.SHA256CryptoServiceProvider();
byte[] hash = sha.ComputeHash(input);
string result = "";
for (int i = 0; i < Math.Min(hash.Length, 15); i++)
{
result = result + string.Format("{0:X2}", hash[i]);
}
return(result);
}
public static string RetornarHashSHA256(string valor)
{
string strSenha = Helpers.Configuracoes.Recuperar("SIAC_SECRET") + valor;
System.Security.Cryptography.SHA256 sha = new System.Security.Cryptography.SHA256CryptoServiceProvider();
System.Text.StringBuilder sb = new StringBuilder();
sha.ComputeHash(System.Text.ASCIIEncoding.ASCII.GetBytes(strSenha));
byte[] result = sha.Hash;
for (int i = 0; i < result.Length; i++)
{
sb.Append(result[i].ToString("x2"));
}
return(sb.ToString());
}
public static string Hash256Encrypt(string password)
{
var sha256 = new System.Security.Cryptography.SHA256CryptoServiceProvider();
byte[] hashedDataBytes;
hashedDataBytes = sha256.ComputeHash(Encoding.GetEncoding("UTF-8").GetBytes(password));
StringBuilder tmp = new StringBuilder();
foreach (byte i in hashedDataBytes)
{
tmp.Append(i.ToString("x2"));
}
return(tmp.ToString());
}
public ActionResult CreateAccPwd(int?id)
{
var data = rep.Find(id.Value);
data.帳號 = "qweerty0322";
var sha256 = new System.Security.Cryptography.SHA256CryptoServiceProvider(); //建立一個SHA256
byte[] source = System.Text.Encoding.Default.GetBytes("123456"); //將字串轉為Byte[]
byte[] crypto = sha256.ComputeHash(source); //進行SHA256加密
string result = Convert.ToBase64String(crypto); //把加密後的字串從Byte[]轉為字串
data.密碼 = result;
rep.UnitOfWork.Commit();
return(RedirectToAction("Index", "Home"));
}
/// <summary>
/// 获取字符串的唯一Hash值（比MD5快）
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static long GetLongHashCode(this string str)
{
if (string.IsNullOrEmpty(str))
{
return(0);
}
byte[] byteContents = Encoding.UTF8.GetBytes(str);
System.Security.Cryptography.SHA256 hash = new System.Security.Cryptography.SHA256CryptoServiceProvider();
byte[] hashText = hash.ComputeHash(byteContents);
long hashCodeStart = BitConverter.ToInt64(hashText, 0);
long hashCodeMedium = BitConverter.ToInt64(hashText, 8);
long hashCodeEnd = BitConverter.ToInt64(hashText, 24);
return(hashCodeStart ^ hashCodeMedium ^ hashCodeEnd);
}
public static string Generate(string name)
{
var bytes = Encoding.UTF8.GetBytes(name);
var sha256 = new System.Security.Cryptography.SHA256CryptoServiceProvider();
var hash = sha256.ComputeHash(bytes);
var sb = new StringBuilder();
for (var i = 1; i < 11; i++)
{
var n = BitEncoding.ByteToB64(hash[i] & 63);
sb.Append(n);
}
return(sb.ToString());
}
internal static ushort GetInt16HashCode(string source)
{
ushort hashCode = 0;
if (!string.IsNullOrEmpty(source))
{
byte[] byteContents = Encoding.Unicode.GetBytes(source);
System.Security.Cryptography.SHA256 hash = new System.Security.Cryptography.SHA256CryptoServiceProvider();
byte[] hashText = hash.ComputeHash(byteContents);
ushort hashCodeStart = BitConverter.ToUInt16(hashText, 0);
ushort hashCodeMedium = BitConverter.ToUInt16(hashText, 8);
ushort hashCodeEnd = BitConverter.ToUInt16(hashText, 24);
hashCode = (ushort)(hashCodeStart ^ hashCodeMedium ^ hashCodeEnd);
}
return(hashCode);
}
private string GetAppHash()
{
System.Security.Cryptography.SHA256CryptoServiceProvider sha2 = new System.Security.Cryptography.SHA256CryptoServiceProvider();
FileStream stream = new FileStream(Process.GetCurrentProcess().MainModule.FileName, FileMode.Open, FileAccess.Read);
sha2.ComputeHash(stream);
stream.Close();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < sha2.Hash.Length; i++)
{
sb.Append(sha2.Hash[i].ToString("x2"));
}
return(sb.ToString().ToUpperInvariant());
}
//- For sorting
public static long TextToNumber(string text)
{
Int64 hashCode = 0;
if (!string.IsNullOrEmpty(text))
{
//Unicode Encode Covering all characterset
byte[] byteContents = Encoding.Unicode.GetBytes(text);
System.Security.Cryptography.SHA256 hash =
new System.Security.Cryptography.SHA256CryptoServiceProvider();
byte[] hashText = hash.ComputeHash(byteContents);
Int64 hashCodeStart = BitConverter.ToInt64(hashText, 0);
Int64 hashCodeMedium = BitConverter.ToInt64(hashText, 8);
Int64 hashCodeEnd = BitConverter.ToInt64(hashText, 24);
hashCode = hashCodeStart ^ hashCodeMedium ^ hashCodeEnd;
}
return(hashCode);
}
public static string EncryptFile(string path)
{
try
{
byte[] ba;
using (var csp = new System.Security.Cryptography.SHA256CryptoServiceProvider())
{
using (FileStream fs = File.OpenRead(path))
ba = csp.ComputeHash(fs);
}
return(Convert.ByteArrayToString(ba));
}
catch (Exception ex)
{
Log.Debug(ex);
return(string.Empty);
}
}
/// <summary>
/// 计算SHA-256码
/// </summary>
/// <param name="word">字符串</param>
/// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
/// <returns></returns>
public static string Hash_SHA_256(string word, bool toUpper = true)
{
try
{
System.Security.Cryptography.SHA256CryptoServiceProvider SHA256CSP
= new System.Security.Cryptography.SHA256CryptoServiceProvider();
byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
byte[] bytHash = SHA256CSP.ComputeHash(bytValue);
SHA256CSP.Clear();
//根据计算得到的Hash码翻译为SHA-1码
string sHash = "", sTemp = "";
for (int counter = 0; counter < bytHash.Count(); counter++)
{
long i = bytHash[counter] / 16;
if (i > 9)
{
sTemp = ((char)(i - 10 + 0x41)).ToString();
}
else
{
sTemp = ((char)(i + 0x30)).ToString();
}
i = bytHash[counter] % 16;
if (i > 9)
{
sTemp += ((char)(i - 10 + 0x41)).ToString();
}
else
{
sTemp += ((char)(i + 0x30)).ToString();
}
sHash += sTemp;
}
//根据大小写规则决定返回的字符串
return toUpper ? sHash : sHash.ToLower();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private string GetFileHash(string filePath)
{
FileInfo fi = new System.IO.FileInfo(filePath);
String retVal = null;
// Bootstrapper is always signed with the SHA-256 algorithm, no matter which version of
// the .NET Framework we are targeting. In ideal situations, bootstrapper files will be
// pre-signed anwyay; this is a fallback in case we ever encounter a bootstrapper that is
// not signed.
System.Security.Cryptography.SHA256CryptoServiceProvider sha = new System.Security.Cryptography.SHA256CryptoServiceProvider();
using (Stream s = fi.OpenRead())
{
retVal = ByteArrayToString(sha.ComputeHash(s));
}
return retVal;
}
/// <summary>
/// Return unique Int64 value for input string
/// </summary>
/// <param name="strText"></param>
/// <returns></returns>
private static UInt64 GetInt64HashCode(string strText)
{
UInt64 hashCode = 0;
if (!string.IsNullOrEmpty(strText)) {
//Unicode Encode Covering all characterset
byte[] byteContents = Encoding.Unicode.GetBytes(strText);
System.Security.Cryptography.SHA256 hash = new System.Security.Cryptography.SHA256CryptoServiceProvider();
byte[] hashText = hash.ComputeHash(byteContents);
//32Byte hashText separate
//hashCodeStart = 0~7 8Byte
//hashCodeMedium = 8~23 8Byte
//hashCodeEnd = 24~31 8Byte
//and Fold
UInt64 hashCodeStart = BitConverter.ToUInt64(hashText, 0);
UInt64 hashCodeMedium = BitConverter.ToUInt64(hashText, 8);
UInt64 hashCodeEnd = BitConverter.ToUInt64(hashText, 24);
hashCode = hashCodeStart ^ hashCodeMedium ^ hashCodeEnd;
}
return (hashCode);
}
static Settings()
{
var props = from p in typeof(Settings).GetProperties(BindingFlags.Public | BindingFlags.Static)
let t = typeof(DefaultValueAttribute)
where p.IsDefined(t, inherit: false)
let a = p.GetCustomAttributes(t, inherit: false).Single() as DefaultValueAttribute
select new { PropertyInfo = p, DefaultValue = a };
foreach (var pair in props)
{
pair.PropertyInfo.SetValue(null, Convert.ChangeType(pair.DefaultValue.Value, pair.PropertyInfo.PropertyType), null);
}
// this assists in debug and is also good for prd, the version is a hash of the main assembly
string location;
try
{
location = typeof (Settings).Assembly.Location;
}
catch
{
location = HttpContext.Current.Server.MapPath("~/bin/MiniProfiler.dll");
}
try
{
List<string> files = new List<string>();
files.Add(location);
string customUITemplatesPath = "";
if (HttpContext.Current != null)
customUITemplatesPath = HttpContext.Current.Server.MapPath(MiniProfiler.Settings.CustomUITemplates);
if (System.IO.Directory.Exists(customUITemplatesPath))
{
files.AddRange(System.IO.Directory.EnumerateFiles(customUITemplatesPath));
}
using (var sha256 = new System.Security.Cryptography.SHA256CryptoServiceProvider())
{
byte[] hash = new byte[sha256.HashSize / 8];
foreach (string file in files)
{
// sha256 can throw a FIPS exception, but SHA256CryptoServiceProvider is FIPS BABY - FIPS
byte[] contents = System.IO.File.ReadAllBytes(file);
byte[] hashfile = sha256.ComputeHash(contents);
for (int i = 0; i < (sha256.HashSize / 8); i++)
{
hash[i] = (byte)(hashfile[i] ^ hash[i]);
}
}
Version = System.Convert.ToBase64String(hash);
}
}
catch
{
Version = Guid.NewGuid().ToString();
}
typesToExclude = new HashSet<string>
{
// while we like our Dapper friend, we don't want to see him all the time
"SqlMapper"
};
methodsToExclude = new HashSet<string>
{
"lambda_method",
".ctor"
};
assembliesToExclude = new HashSet<string>
{
// our assembly
typeof(Settings).Assembly.GetName().Name,
// reflection emit
"Anonymously Hosted DynamicMethods Assembly",
// the man
"System.Core",
"System.Data",
"System.Data.Linq",
"System.Web",
"System.Web.Mvc",
};
// for normal usage, this will return a System.Diagnostics.Stopwatch to collect times - unit tests can explicitly set how much time elapses
StopwatchProvider = StopwatchWrapper.StartNew;
}
private string HashString(string input)
{
string result = "";
using (System.Security.Cryptography.SHA256 sha = new System.Security.Cryptography.SHA256CryptoServiceProvider())
{
byte[] data = sha.ComputeHash(Encoding.UTF8.GetBytes(input));
StringBuilder stringBuilder = new StringBuilder();
for (int counter = 0; counter < data.Length; counter++)
{
stringBuilder.Append(data[counter].ToString("x2"));
}
result = stringBuilder.ToString();
}
return result;
}