public static byte[] Encrypt(string s)
{
var alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1);
var data = Encoding.GetEncoding("iso-8859-1").GetBytes(s);
var buff = CryptographicBuffer.CreateFromByteArray(data);
var hashed = alg.HashData(buff);
var res = CryptographicBuffer.EncodeToHexString(hashed);
return(Encoding.GetEncoding("iso-8859-1").GetBytes(res));
}
public static byte[] HashCore(byte[] bytes)
{
var alg = HashAlgorithmProvider.OpenAlgorithm("MD5");
var buff = CryptographicBuffer.CreateFromByteArray(bytes);
var hashed = alg.HashData(buff);
byte[] result;
CryptographicBuffer.CopyToByteArray(hashed, out result);
return(result);
}
/// <summary>
/// Хеширование текста
/// </summary>
/// <param name="SourceText">Исходный текст для хэширования</param>
/// <param name="HashAlgName">Название алгоритма хеширования</param>
/// <returns>Хэш сообщения</returns>
public string HashMode(string SourceText, string HashAlgName)
{
// Create a HashAlgorithmProvider object.
HashAlgorithmProvider Hash = HashAlgorithmProvider.OpenAlgorithm(HashAlgName);
IBuffer SourceTextBuffer = CryptographicBuffer.ConvertStringToBinary(SourceText, BinaryStringEncoding.Utf16LE);
// IBuffer SourceTextBuffer = CryptographicBuffer.DecodeFromBase64String(SourceText);
IBuffer HashBuffer = Hash.HashData(SourceTextBuffer);
return(CryptographicBuffer.EncodeToHexString(HashBuffer));
}
public static byte[] ComputeMD5(byte[] data)
{
#if WINDOWS_PHONE
var md5 = new MD5Managed();
return(md5.ComputeHash(data));
#elif WIN_RT
var md5 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
return(md5.HashData(data.AsBuffer()).ToArray());
#endif
}
public static string CreateMD5(string param, string salt)
{
var alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
IBuffer buff = CryptographicBuffer.ConvertStringToBinary(
param + salt, BinaryStringEncoding.Utf8);
var hashed = alg.HashData(buff);
var res = CryptographicBuffer.EncodeToHexString(hashed);
return(res);
}
public static string GetDeviceId()
{
HardwareToken token = HardwareIdentification.GetPackageSpecificToken(null);
IBuffer hardwareId = token.Id;
HashAlgorithmProvider hasher = HashAlgorithmProvider.OpenAlgorithm("MD5");
IBuffer hashed = hasher.HashData(hardwareId);
return(CryptographicBuffer.EncodeToHexString(hashed));
}
public static byte[] sha1(byte[] input)
{
IBuffer buffer = CryptographicBuffer.CreateFromByteArray(input);
HashAlgorithmProvider provider = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1);
IBuffer hash = provider.HashData(buffer);
byte[] ret;
CryptographicBuffer.CopyToByteArray(hash, out ret);
return(ret);
}
/// <summary>
/// Krypterer streng med MD5-hashalgoritme
/// </summary>
/// <param name="streng">Tager streng som parameter</param>
/// <returns>Returnerer krypteret streng</returns>
public static string KrypterStreng(string streng)
{
const string salt = "WmkqCmP4y4oi483xXOnb";
var alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
IBuffer buff = CryptographicBuffer.ConvertStringToBinary(streng + salt, BinaryStringEncoding.Utf8);
var hashed = alg.HashData(buff);
var resultat = CryptographicBuffer.EncodeToHexString(hashed);
return(resultat);
}
private static string CalculateSHA1(string text)
{
IBuffer buffer = CryptographicBuffer.ConvertStringToBinary(text, BinaryStringEncoding.Utf8);
HashAlgorithmProvider hashAlgorithm = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1);
IBuffer hashBuffer = hashAlgorithm.HashData(buffer);
var hashHex = CryptographicBuffer.EncodeToHexString(hashBuffer);
return(hashHex);
}
public static string MD5Hash(string message)
{
IBuffer buffer = CryptographicBuffer.ConvertStringToBinary(message, BinaryStringEncoding.Utf8);
HashAlgorithmProvider hashAlgorithm = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
IBuffer hashBuffer = hashAlgorithm.HashData(buffer);
var strHashBase64 = CryptographicBuffer.EncodeToBase64String(hashBuffer);
return(strHashBase64);
}
/// <summary>
/// 计算文件是否匹配
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
private static string Md5(string str)
{
HashAlgorithmProvider hashAlgorithm =
HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
CryptographicHash cryptographic = hashAlgorithm.CreateHash();
IBuffer buffer = CryptographicBuffer.ConvertStringToBinary(str, BinaryStringEncoding.Utf8);
cryptographic.Append(buffer);
return(CryptographicBuffer.EncodeToHexString(cryptographic.GetValueAndReset()));
}
public static string ConvertStringToHash(string password, string salt)
{
byte[] data = Encoding.UTF8.GetBytes(password + "" + salt);
HashAlgorithmProvider alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha512);
IBuffer buffer = CryptographicBuffer.ConvertStringToBinary(password + salt, BinaryStringEncoding.Utf8);
IBuffer hashed = alg.HashData(buffer);
string res = CryptographicBuffer.EncodeToHexString(hashed);
return(res);
}
public static string HashPassword(string toBeHashed)
{
{
var alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
IBuffer buff = Windows.Security.Cryptography.CryptographicBuffer.ConvertStringToBinary(toBeHashed, BinaryStringEncoding.Utf8);
var hashed = alg.HashData(buff);
var res = CryptographicBuffer.EncodeToHexString(hashed);
return(res);
}
}
public static string ComputeSHA1Hash(this string input)
{
IBuffer buffer = CryptographicBuffer.ConvertStringToBinary(input, BinaryStringEncoding.Utf8);
HashAlgorithmProvider provider = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1);
//hash it
IBuffer hash = provider.HashData(buffer);
return(CryptographicBuffer.EncodeToHexString(hash).ToUpperInvariant());
}
/// <summary>
/// Computes hash algorithm for the source string
/// </summary>
/// <param name="source">Source string to compute hash from</param>
/// <param name="algorithm">HashAlgorithmNames.Sha1</param>
/// <returns>hash from the source string</returns>
public static string ComputeHash(string source, string algorithm)
{
HashAlgorithmProvider sha1 = HashAlgorithmProvider.OpenAlgorithm(algorithm);
byte[] bytes = Encoding.UTF8.GetBytes(source);
IBuffer bytesBuffer = CryptographicBuffer.CreateFromByteArray(bytes);
IBuffer hashBuffer = sha1.HashData(bytesBuffer);
return(CryptographicBuffer.EncodeToHexString(hashBuffer));
}
private static string Md5Encrypt(string stringToEncrypt)
{
IBuffer buffUtf8Msg = CryptographicBuffer.ConvertStringToBinary(stringToEncrypt, BinaryStringEncoding.Utf8);
HashAlgorithmProvider objAlgProv = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
IBuffer buffHash = objAlgProv.HashData(buffUtf8Msg);
string result = CryptographicBuffer.EncodeToHexString(buffHash);
return(result);
}
private string CreateCodeChallenge()
{
_codeVerifier = RandomNumberGenerator.CreateUniqueId();
var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
var challengeBuffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(Encoding.UTF8.GetBytes(_codeVerifier)));
byte[] challengeBytes;
CryptographicBuffer.CopyToByteArray(challengeBuffer, out challengeBytes);
return(Base64Url.Encode(challengeBytes));
}
/// <summary>
/// 对指定 utf-8 字符串执行 MD5 校验
/// </summary>
/// <param name="str">注意编码格式为 utf-8</param>
/// <returns></returns>
public static string ComputeMD5(string str)
{
var alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
IBuffer buff = CryptographicBuffer.CreateFromByteArray(Encoding.UTF8.GetBytes(str));
var hashed = alg.HashData(buff);
var res = CryptographicBuffer.EncodeToHexString(hashed);
return(res);
}
internal MD5Wrapper()
{
#if WINDOWS_RT
this.hash = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash();
#elif WINDOWS_PHONE
throw new NotSupportedException(SR.WindowsPhoneDoesNotSupportMD5);
#else
this.hash = this.version1MD5 ? MD5.Create() : new NativeMD5();
#endif
}
public string GetDeviceID()
{
var token = HardwareIdentification.GetPackageSpecificToken(null);
IBuffer buffer = token.Id;
var md5Provider = HashAlgorithmProvider.OpenAlgorithm("MD5");
var hashdata = md5Provider.HashData(buffer);
return(CryptographicBuffer.EncodeToHexString(hashdata));
}
public static byte[] ComputeSHA1(byte[] data)
{
#if WINDOWS_PHONE
var sha1 = new SHA1Managed(); // to avoid thread sync problems http://stackoverflow.com/questions/12644257/sha1managed-computehash-occasionally-different-on-different-servers
return(sha1.ComputeHash(data));
#elif WIN_RT
var sha1 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1);
return(sha1.HashData(data.AsBuffer()).ToArray());
#endif
}
private static string GenerateEncryptedPincode(string pincode)
{
HashAlgorithmProvider alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
IBuffer buff = CryptographicBuffer.ConvertStringToBinary(pincode, BinaryStringEncoding.Utf8);
IBuffer hashed = alg.HashData(buff);
string res = CryptographicBuffer.EncodeToHexString(hashed);
LoggingService.Log("Pincode generated, now encrypting and returning it", LoggingLevel.Verbose);
return(EncryptionService.Encrypt(res));
}
private string EncryptPassword(string password)
{
var input = CryptographicBuffer.ConvertStringToBinary(password,
BinaryStringEncoding.Utf8);
var hasher = HashAlgorithmProvider.OpenAlgorithm("SHA256");
var hashed = hasher.HashData(input);
var pwd = CryptographicBuffer.EncodeToBase64String(hashed);
return(pwd.ToString());
}
/// <summary>
/// Asynchonrously computes the security token data represented by the password
/// </summary>
/// <returns>The SHA256 hash of the plaintext password</returns>
public Task <IBuffer> GetBufferAsync()
{
var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
var hash = sha256.CreateHash();
IBuffer passwordData = CryptographicBuffer.ConvertStringToBinary(this._password, BinaryStringEncoding.Utf8);
hash.Append(passwordData);
return(Task.FromResult(hash.GetValueAndReset()));
}
public static byte[] Sha1(string value)
{
HashAlgorithmProvider provider = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1);
var data = CryptographicBuffer.ConvertStringToBinary(value, BinaryStringEncoding.Utf8);
var hash = provider.HashData(data);
byte[] result;
CryptographicBuffer.CopyToByteArray(hash, out result);
return(result);
}
private async Task CloudFileUploadFromStreamAsync(CloudFileShare share, int size, long?copyLength, AccessCondition accessCondition, OperationContext operationContext, int startOffset)
{
byte[] buffer = GetRandomBuffer(size);
#if ASPNET_K
MD5 hasher = MD5.Create();
string md5 = Convert.ToBase64String(hasher.ComputeHash(buffer, startOffset, copyLength.HasValue ? (int)copyLength : buffer.Length - startOffset));
#else
CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash();
hasher.Append(buffer.AsBuffer(startOffset, copyLength.HasValue ? (int)copyLength.Value : buffer.Length - startOffset));
string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset());
#endif
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
file.StreamWriteSizeInBytes = 512;
using (MemoryStream originalFileStream = new MemoryStream())
{
originalFileStream.Write(buffer, startOffset, buffer.Length - startOffset);
using (MemoryStream sourceStream = new MemoryStream(buffer))
{
sourceStream.Seek(startOffset, SeekOrigin.Begin);
FileRequestOptions options = new FileRequestOptions()
{
StoreFileContentMD5 = true,
};
if (copyLength.HasValue)
{
await file.UploadFromStreamAsync(sourceStream, copyLength.Value, accessCondition, options, operationContext);
}
else
{
await file.UploadFromStreamAsync(sourceStream, accessCondition, options, operationContext);
}
}
await file.FetchAttributesAsync();
Assert.AreEqual(md5, file.Properties.ContentMD5);
using (MemoryStream downloadedFileStream = new MemoryStream())
{
await file.DownloadToStreamAsync(downloadedFileStream);
Assert.AreEqual(copyLength ?? originalFileStream.Length, downloadedFileStream.Length);
TestHelper.AssertStreamsAreEqualAtIndex(
originalFileStream,
downloadedFileStream,
0,
0,
copyLength.HasValue ? (int)copyLength : (int)originalFileStream.Length);
}
}
}
public static byte[] ComputeMD5(string data)
{
var input = CryptographicBuffer.ConvertStringToBinary(data, BinaryStringEncoding.Utf8);
var hasher = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
var hashed = hasher.HashData(input);
byte[] digest;
CryptographicBuffer.CopyToByteArray(hashed, out digest);
return(digest);
}
static string ComputeHash(byte[] bytes)
{
HashAlgorithmProvider hasher = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha512);
IBuffer buffer = bytes.AsBuffer();
IBuffer buffHash = hasher.HashData(buffer);
String strHashBase64 = CryptographicBuffer.EncodeToBase64String(buffHash);
return(strHashBase64);
}
private string GenerateWebSocketAccept(HttpContext httpContext)
{
var webSocketKey = httpContext.Request.Headers[HttpHeaderName.SecWebSocketKey];
var responseKey = webSocketKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
var responseKeyBuffer = Encoding.ASCII.GetBytes(responseKey).AsBuffer();
var sha1 = HashAlgorithmProvider.OpenAlgorithm("SHA1");
var sha1Buffer = sha1.HashData(responseKeyBuffer);
return(Convert.ToBase64String(sha1Buffer.ToArray()));
}
/// <summary>
/// Получить уникальный ID.
/// </summary>
/// <param name="src">Данные.</param>
/// <returns>ID.</returns>
public static string CreateIdString(byte[] src)
{
var prov = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1);
var hash = prov.CreateHash();
hash.Append(CryptographicBuffer.CreateFromByteArray(src));
var result = hash.GetValueAndReset();
var bytes = result.ToArray();
return(ToHexString(bytes));
}
