/// <summary>
/// 获取文件的MD5值
/// </summary>
/// <param name="fileName">文件名</param>
/// <returns></returns>
public static string GetFileMd5(string fileName)
{
FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
const int bufferSize = 1024 * 1024;
byte[] buffer = new byte[bufferSize];
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
md5.Initialize();
long offset = 0;
while (offset < fs.Length)
{
long readSize = bufferSize;
if (offset + readSize > fs.Length)
{
readSize = fs.Length - offset;
}
fs.Read(buffer, 0, (int)readSize);
if (offset + readSize < fs.Length)
{
md5.TransformBlock(buffer, 0, (int)readSize, buffer, 0);
}
else
{
md5.TransformFinalBlock(buffer, 0, (int)readSize);
}
offset += bufferSize;
}
fs.Close();
byte[] result = md5.Hash;
md5.Clear();
StringBuilder sb = new StringBuilder();
foreach (var b in result)
{
sb.Append(b.ToString("X2"));
}
return(sb.ToString());
}
public static string GetMD5(byte[] array, int offset, int count)
{
string str;
MD5 md = null;
try
{
md = new MD5CryptoServiceProvider();
md.Initialize();
str = ByteArrayToHexadecimalString(md.ComputeHash(array, offset, count));
}
finally
{
if (md != null)
{
md.Clear();
}
}
return(str);
}
/// <summary>
/// 对大文件进行MD5加密
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
/// <example></example>
public static string MD5File(string filePath)
{
FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
md5.Initialize();
md5.ComputeHash(fs);
fs.Close();
byte[] b = md5.Hash;
md5.Clear();
StringBuilder sb = new StringBuilder(32);
for (int i = 0; i < b.Length; i++)
{
sb.Append(b[i].ToString("X2"));
}
return(sb.ToString());
}
/// <summary>
/// 获取文件的MD5校验码
/// </summary>
/// <param name="filename"></param>
/// <returns></returns>
public static string getFileMd5(string filename)
{
try
{
FileStream fs = new FileStream(filename, FileMode.Open);
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
md5.Initialize();
byte[] bytes = md5.ComputeHash(fs);
md5.Clear();
fs.Close();
StringBuilder sb = new StringBuilder();
foreach (byte b in bytes)
{
sb.Append(b.ToString("x2"));
}
return(sb.ToString());
}
catch { }
return("");
}
/// <summary>
/// 对文件进行MD5加密
/// </summary>
/// <param name="filePath"></param>
public static string MD5File(string filePath)
{
FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
int bufferSize = 1048576; // 缓冲区大小，1MB
byte[] buff = new byte[bufferSize];
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
md5.Initialize();
long offset = 0;
while (offset < fs.Length)
{
long readSize = bufferSize;
if (offset + readSize > fs.Length)
{
readSize = fs.Length - offset;
}
fs.Read(buff, 0, Convert.ToInt32(readSize)); // 读取一段数据到缓冲区
if (offset + readSize < fs.Length) // 不是最后一块
{
md5.TransformBlock(buff, 0, Convert.ToInt32(readSize), buff, 0);
}
else // 最后一块
{
md5.TransformFinalBlock(buff, 0, Convert.ToInt32(readSize));
}
offset += bufferSize;
}
fs.Close();
byte[] result = md5.Hash;
md5.Clear();
return(FormatMD5(result));
}
public byte[] MD5Feature(dynamic bow, Bitmap mask)
{
HashAlgorithm hasher = new MD5CryptoServiceProvider();
hasher.Initialize();
if (mask != null)
{
byte[] maskData = mask.ToBytes();
hasher.TransformBlock(maskData, 0, maskData.Length, null, 0);
}
foreach (var a in this)
{
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(a.fileName);
hasher.TransformBlock(bytes, 0, bytes.Length, null, 0);
}
byte[] bData = Accord.IO.Serializer.Save(bow);
hasher.TransformBlock(bData, 0, bData.Length, null, 0);
hasher.TransformFinalBlock(new byte[0], 0, 0);
byte[] hash = hasher.Hash;
return(hash);
}
public static string GetMD5WithBuff(string filePath)
{
int bufferSize = 1024 * 1024 * 1; // 缓冲区大小，1MB
byte[] buff = new byte[bufferSize];
var md5 = new MD5CryptoServiceProvider();
md5.Initialize();
using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
long offset = 0;
while (offset < fs.Length)
{
long readSize = bufferSize;
if (offset + readSize > fs.Length)
{
readSize = fs.Length - offset;
}
fs.Read(buff, 0, Convert.ToInt32(readSize)); // 读取一段数据到缓冲区
if (offset + readSize < fs.Length) // 不是最后一块
{
md5.TransformBlock(buff, 0, Convert.ToInt32(readSize), buff, 0);
}
else // 最后一块
{
md5.TransformFinalBlock(buff, 0, Convert.ToInt32(readSize));
}
offset += bufferSize;
}
}
byte[] result = md5.Hash;
md5.Clear();
StringBuilder sb = new StringBuilder(32);
for (int i = 0; i < result.Length; i++)
{
sb.Append(result[i].ToString("X2"));
}
return(sb.ToString());
}
// Token: 0x0600004A RID: 74 RVA: 0x00003DD4 File Offset: 0x00001FD4
public static object decrypt2_method(byte[] key, byte[] encrypt_data)
{
checked
{
object result;
try
{
MD5CryptoServiceProvider md5CryptoServiceProvider = new MD5CryptoServiceProvider();
md5CryptoServiceProvider.Initialize();
byte[] array = new byte[p.opera_salt.Length + (key.Length - 1) + 1];
Array.Copy(p.opera_salt, array, p.opera_salt.Length);
Array.Copy(key, 0, array, p.opera_salt.Length, key.Length);
byte[] array2 = md5CryptoServiceProvider.ComputeHash(array);
array = new byte[array2.Length + p.opera_salt.Length + (key.Length - 1) + 1];
Array.Copy(array2, array, array2.Length);
Array.Copy(p.opera_salt, 0, array, array2.Length, p.opera_salt.Length);
Array.Copy(key, 0, array, array2.Length + p.opera_salt.Length, key.Length);
byte[] sourceArray = md5CryptoServiceProvider.ComputeHash(array);
TripleDESCryptoServiceProvider tripleDESCryptoServiceProvider = new TripleDESCryptoServiceProvider();
tripleDESCryptoServiceProvider.Mode = CipherMode.CBC;
tripleDESCryptoServiceProvider.Padding = PaddingMode.None;
byte[] array3 = new byte[24];
byte[] array4 = new byte[8];
Array.Copy(array2, array3, array2.Length);
Array.Copy(sourceArray, 0, array3, array2.Length, 8);
Array.Copy(sourceArray, 8, array4, 0, 8);
tripleDESCryptoServiceProvider.Key = array3;
tripleDESCryptoServiceProvider.IV = array4;
ICryptoTransform cryptoTransform = tripleDESCryptoServiceProvider.CreateDecryptor();
byte[] bytes = cryptoTransform.TransformFinalBlock(encrypt_data, 0, encrypt_data.Length);
string @string = Encoding.Unicode.GetString(bytes);
result = @string;
}
catch (Exception ex)
{
result = "";
}
return(result);
}
}
// Token: 0x06000083 RID: 131 RVA: 0x00005A08 File Offset: 0x00003C08
public object method_2(byte[] byte_2, byte[] byte_3)
{
checked
{
object result;
try
{
MD5CryptoServiceProvider md5CryptoServiceProvider = new MD5CryptoServiceProvider();
md5CryptoServiceProvider.Initialize();
byte[] array = new byte[GClass1.byte_0.Length + (byte_2.Length - 1) + 1];
Array.Copy(GClass1.byte_0, array, GClass1.byte_0.Length);
Array.Copy(byte_2, 0, array, GClass1.byte_0.Length, byte_2.Length);
byte[] array2 = md5CryptoServiceProvider.ComputeHash(array);
array = new byte[array2.Length + GClass1.byte_0.Length + (byte_2.Length - 1) + 1];
Array.Copy(array2, array, array2.Length);
Array.Copy(GClass1.byte_0, 0, array, array2.Length, GClass1.byte_0.Length);
Array.Copy(byte_2, 0, array, array2.Length + GClass1.byte_0.Length, byte_2.Length);
byte[] sourceArray = md5CryptoServiceProvider.ComputeHash(array);
TripleDESCryptoServiceProvider tripleDESCryptoServiceProvider = new TripleDESCryptoServiceProvider();
tripleDESCryptoServiceProvider.Mode = CipherMode.CBC;
tripleDESCryptoServiceProvider.Padding = PaddingMode.None;
byte[] array3 = new byte[24];
byte[] array4 = new byte[8];
Array.Copy(array2, array3, array2.Length);
Array.Copy(sourceArray, 0, array3, array2.Length, 8);
Array.Copy(sourceArray, 8, array4, 0, 8);
tripleDESCryptoServiceProvider.Key = array3;
tripleDESCryptoServiceProvider.IV = array4;
ICryptoTransform cryptoTransform = tripleDESCryptoServiceProvider.CreateDecryptor();
byte[] bytes = cryptoTransform.TransformFinalBlock(byte_3, 0, byte_3.Length);
string @string = Encoding.Unicode.GetString(bytes);
result = @string;
}
catch (Exception ex)
{
result = "";
}
return(result);
}
}
static public byte[] SetHashKey(byte[] globalKey, int number, int generation)
{
byte[] salt = { (byte)0x73, (byte)0x41, (byte)0x6c, (byte)0x54 };
byte[] extra = new byte[5];
MD5 _md5 = new MD5CryptoServiceProvider();
_md5.Initialize();
extra[0] = (byte)number;
extra[1] = (byte)(number >> 8);
extra[2] = (byte)(number >> 16);
extra[3] = (byte)generation;
extra[4] = (byte)(generation >> 8);
byte[] key = new byte[globalKey.Length + 9];
Array.Copy(globalKey, 0, key, 0, globalKey.Length);
Array.Copy(extra, 0, key, globalKey.Length, 5);
Array.Copy(salt, 0, key, globalKey.Length + 5, 4);
_md5.TransformFinalBlock(key, 0, key.Length);
byte[] objKey = _md5.Hash;
return(objKey);
}
public byte[] Encode(byte[] data)
{
byte[] buffer = new byte[data.Length + 128];
using (MemoryStream stream = new MemoryStream(data))
{
int num;
MemoryStream stream2 = new MemoryStream(buffer);
RSACryptoServiceProvider key = new RSACryptoServiceProvider(1024);
byte[] buffer2 = new byte[86];
byte[] outputBuffer = new byte[86];
HashAlgorithm algorithm = new MD5CryptoServiceProvider();
algorithm.Initialize();
while ((num = stream.Read(buffer2, 0, 86)) == 86)
{
algorithm.TransformBlock(buffer2, 0, 86, outputBuffer, 0);
stream2.Write(buffer2, 0, buffer2.Length);
}
buffer2 = algorithm.TransformFinalBlock(buffer2, 0, num);
stream2.Write(buffer2, 0, buffer2.Length);
RSAParameters parameters = new RSAParameters();
parameters.D = (byte[])this.rsaParameters.D.Clone();
parameters.DP = (byte[])this.rsaParameters.DP.Clone();
parameters.DQ = (byte[])this.rsaParameters.DQ.Clone();
parameters.Exponent = (byte[])this.rsaParameters.Exponent.Clone();
parameters.InverseQ = (byte[])this.rsaParameters.InverseQ.Clone();
parameters.Modulus = (byte[])this.rsaParameters.Modulus.Clone();
parameters.P = (byte[])this.rsaParameters.P.Clone();
parameters.Q = (byte[])this.rsaParameters.Q.Clone();
key.ImportParameters(parameters);
AsymmetricSignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm("MD5");
outputBuffer = formatter.CreateSignature(algorithm.Hash);
stream2.Write(outputBuffer, 0, outputBuffer.Length);
stream2.Close();
stream.Close();
}
return(buffer);
}
internal static byte[] CreateKeyDigest(String password, byte[] docIdData)
{
Check16Bytes(docIdData, "docId");
int nChars = Math.Min(password.Length, 16);
byte[] passwordData = new byte[nChars * 2];
for (int i = 0; i < nChars; i++)
{
char ch = password[i];
passwordData[i * 2 + 0] = (byte)((ch << 0) & 0xFF);
passwordData[i * 2 + 1] = (byte)((ch << 8) & 0xFF);
}
byte[] kd;
using (MD5 md5 = new MD5CryptoServiceProvider())
{
byte[] passwordHash = md5.ComputeHash(passwordData);
md5.Initialize();
byte[] data = new byte[PASSWORD_HASH_NUMBER_OF_BYTES_USED * 16 + docIdData.Length * 16];
int offset = 0;
for (int i = 0; i < 16; i++)
{
Array.Copy(passwordHash, 0, data, offset, PASSWORD_HASH_NUMBER_OF_BYTES_USED);
offset += PASSWORD_HASH_NUMBER_OF_BYTES_USED;// passwordHash.Length;
Array.Copy(docIdData, 0, data, offset, docIdData.Length);
offset += docIdData.Length;
}
kd = md5.ComputeHash(data);
byte[] result = new byte[KEY_DIGEST_LENGTH];
Array.Copy(kd, 0, result, 0, KEY_DIGEST_LENGTH);
md5.Clear();
return(result);
}
}
private static byte[] OpenSSHPassphraseToKey(string passphrase, byte[] iv, int length) {
const int HASH_SIZE = 16;
const int SALT_SIZE = 8;
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
byte[] pp = Encoding.UTF8.GetBytes(passphrase);
byte[] buf = new byte[((length + HASH_SIZE - 1) / HASH_SIZE) * HASH_SIZE];
int offset = 0;
while(offset < length) {
if (offset > 0)
md5.TransformBlock(buf, 0, offset, null, 0);
md5.TransformBlock(pp, 0, pp.Length, null, 0);
md5.TransformFinalBlock(iv, 0, SALT_SIZE);
Buffer.BlockCopy(md5.Hash, 0, buf, offset, HASH_SIZE);
offset += HASH_SIZE;
md5.Initialize();
}
md5.Clear();
byte[] key = new byte[length];
Buffer.BlockCopy(buf, 0, key, 0, length);
return key;
}
internal static string HashChallenge(string seshChallenge, string seshToken, string challenge1, string challenge2)
{
// response = md5sum(md5sum(seshChallenge) + (" " * 48) + seshToken + challenge1 + challenge2 + md5sum(seshChallenge))
byte[] innerHash;
using (HashAlgorithm hasher = new MD5CryptoServiceProvider()) {
hasher.Initialize();
Hash(hasher, seshChallenge);
hasher.TransformFinalBlock(Empty, 0, 0);
innerHash = GetHexidecimalHash(hasher);
}
using (HashAlgorithm hasher = new MD5CryptoServiceProvider()) {
hasher.Initialize();
hasher.TransformBlock(innerHash, 0, innerHash.Length, innerHash, 0);
hasher.TransformBlock(Pad48, 0, Pad48.Length, Pad48, 0);
Hash(hasher, seshToken);
Hash(hasher, challenge1);
Hash(hasher, challenge2);
hasher.TransformBlock(innerHash, 0, innerHash.Length, innerHash, 0);
hasher.TransformFinalBlock(Empty, 0, 0);
byte[] finalHash = GetHexidecimalHash(hasher);
return(Encoding.ASCII.GetString(finalHash));
}
}
private static byte[] CreateKeyDigest(String password, byte[] docIdData)
{
Check16Bytes(docIdData, "docId");
var nChars = Math.Min(password.Length, 16);
var passwordData = new byte[nChars * 2];
for (var i = 0; i < nChars; i++)
{
var chr = password[i];
passwordData[i * 2 + 0] = (byte)((chr << 0) & 0xFF);
passwordData[i * 2 + 1] = (byte)((chr << 8) & 0xFF);
}
using (MD5 md5 = new MD5CryptoServiceProvider())
{
var passwordHash = md5.ComputeHash(passwordData);
md5.Initialize();
var data = new byte[PasswordHashNumberOfBytesUsed * 16 + docIdData.Length * 16];
var offset = 0;
for (var i = 0; i < 16; i++)
{
Array.Copy(passwordHash, 0, data, offset, PasswordHashNumberOfBytesUsed);
offset += PasswordHashNumberOfBytesUsed;
Array.Copy(docIdData, 0, data, offset, docIdData.Length);
offset += docIdData.Length;
}
var kd = md5.ComputeHash(data);
var result = new byte[KeyDigestLength];
Array.Copy(kd, 0, result, 0, KeyDigestLength);
md5.Clear();
return(result);
}
}
private void Decryption_Test(String filename)
{
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
string key = "cosmos";
if (test_md5.Length == 0)
{
using (FileStream infs = new FileStream("../../../../test/cosmos.jpg", FileMode.Open))
{
byte[] buffer = new byte[infs.Length];
infs.Read(buffer, 0, buffer.Length);
md5.ComputeHash(buffer);
test_md5 = md5.Hash;
md5.Initialize();
}
}
using (FileStream infs = new FileStream("../../../../test/" + filename, FileMode.Open))
{
AttacheCase.Unlocker unlocker = new AttacheCase.Unlocker();
Assert.AreEqual(unlocker.Open(infs, key), AttacheCase.Result.OK);
Assert.AreEqual(unlocker.Entries.Length, 1);
AttacheCase.FileEntry entry = unlocker.Entries[0];
MemoryStream extracted = new MemoryStream();
Assert.AreEqual(unlocker.ExtractFileData(extracted, infs, (uint)entry.Size), AttacheCase.Result.OK);
byte[] buffer = new byte[entry.Size];
extracted.Position = 0;
extracted.Read(buffer, 0, buffer.Length);
md5.ComputeHash(buffer);
Assert.IsTrue(test_md5.SequenceEqual(md5.Hash));
}
}
public object decrypt2_method(byte[] key, byte[] encrypt_data)
{
object obj;
try
{
MD5CryptoServiceProvider cryptoServiceProvider1 = new MD5CryptoServiceProvider();
cryptoServiceProvider1.Initialize();
byte[] buffer1 = new byte[checked (operaa.opera_salt.Length + (key.Length - 1) + 1)];
Array.Copy((Array)operaa.opera_salt, (Array)buffer1, operaa.opera_salt.Length);
Array.Copy((Array)key, 0, (Array)buffer1, operaa.opera_salt.Length, key.Length);
byte[] hash1 = cryptoServiceProvider1.ComputeHash(buffer1);
byte[] buffer2 = new byte[checked (hash1.Length + operaa.opera_salt.Length + (key.Length - 1) + 1)];
Array.Copy((Array)hash1, (Array)buffer2, hash1.Length);
Array.Copy((Array)operaa.opera_salt, 0, (Array)buffer2, hash1.Length, operaa.opera_salt.Length);
Array.Copy((Array)key, 0, (Array)buffer2, checked (hash1.Length + operaa.opera_salt.Length), key.Length);
byte[] hash2 = cryptoServiceProvider1.ComputeHash(buffer2);
TripleDESCryptoServiceProvider cryptoServiceProvider2 = new TripleDESCryptoServiceProvider();
cryptoServiceProvider2.Mode = CipherMode.CBC;
cryptoServiceProvider2.Padding = PaddingMode.None;
byte[] numArray1 = new byte[24];
byte[] numArray2 = new byte[8];
Array.Copy((Array)hash1, (Array)numArray1, hash1.Length);
Array.Copy((Array)hash2, 0, (Array)numArray1, hash1.Length, 8);
Array.Copy((Array)hash2, 8, (Array)numArray2, 0, 8);
cryptoServiceProvider2.Key = numArray1;
cryptoServiceProvider2.IV = numArray2;
obj = (object)Encoding.Unicode.GetString(cryptoServiceProvider2.CreateDecryptor().TransformFinalBlock(encrypt_data, 0, encrypt_data.Length));
}
catch (Exception ex)
{
ProjectData.SetProjectError(ex);
obj = (object)"";
ProjectData.ClearProjectError();
}
return(obj);
}
public void ConnectLobby()
{
if (this.m_connectIndex < 0)
{
int num = 1;
object param = null;
if (this.ParseNodeAppAttr(this.SelectedTdir.attr, TdirNodeAttrType.UseDeviceIDChooseSvr, ref param))
{
num = (int)param;
}
if ((num == 1) && !string.IsNullOrEmpty(SystemInfo.deviceUniqueIdentifier))
{
byte[] bytes = Encoding.ASCII.GetBytes(SystemInfo.deviceUniqueIdentifier);
MD5CryptoServiceProvider provider = new MD5CryptoServiceProvider();
provider.Initialize();
provider.TransformFinalBlock(bytes, 0, bytes.Length);
ulong num2 = (ulong)BitConverter.ToInt64(provider.get_Hash(), 0);
ulong num3 = (ulong)BitConverter.ToInt64(provider.get_Hash(), 8);
this.m_connectIndex = (int)(num2 ^ num3);
if (this.m_connectIndex < 0)
{
this.m_connectIndex *= -1;
}
}
else
{
this.m_connectIndex = UnityEngine.Random.Range(0, 0x2710);
}
this.m_connectIndex = this.m_connectIndex % MonoSingleton <TdirMgr> .GetInstance().SelectedTdir.addrs.Count;
}
else
{
this.m_connectIndex++;
this.m_connectIndex = this.m_connectIndex % MonoSingleton <TdirMgr> .GetInstance().SelectedTdir.addrs.Count;
}
Singleton <LobbySvrMgr> .GetInstance().ConnectServerWithTdirDefault(this.m_connectIndex);
}
public string GetHash()
{
m_tables.Sort();
m_columns.Sort();
m_keys.Sort();
m_customScripts.Sort();
Action <IEnumerable <string>, MemoryStream> add = (list, stream) =>
{
foreach (var i in list)
{
var bytes = Encoding.ASCII.GetBytes(i);
stream.Write(bytes, 0, bytes.Length);
}
};
using (var strm = new MemoryStream())
{
add(m_tables, strm);
add(m_columns, strm);
add(m_keys, strm);
add(m_customScripts, strm);
strm.Flush();
strm.Seek(0, SeekOrigin.Begin);
byte[] hashBytes;
using (var md5 = new MD5CryptoServiceProvider())
{
md5.Initialize();
hashBytes = md5.ComputeHash(strm);
}
return(Convert.ToBase64String(hashBytes));
}
}
//
// Summary:
// Initializes an implementation of the System.Security.Cryptography.HashAlgorithm
// class.
public override void Initialize()
{
_md5.Initialize();
_sha1.Initialize();
}
protected void Page_Load(object sender, EventArgs e)
{
Page.UnobtrusiveValidationMode = System.Web.UI.UnobtrusiveValidationMode.None;
hash = new MD5CryptoServiceProvider();
hash.Initialize();
}
void Start()
{
byte[] data = { 0, 1, 2, 3, 4, 5, 6, 7 };
// 192B
{
using (var md5 = new MD5CryptoServiceProvider())
{
Profiler.BeginSample("ComputeHash");
var hash = md5.ComputeHash(data);
Profiler.EndSample();
Debug.Log(GetHashString(hash));
}
}
// 228B
{
using (var md5 = new MD5CryptoServiceProvider())
{
Profiler.BeginSample("TransformBlock");
md5.TransformBlock(data, 0, 4, null, 0);
md5.TransformBlock(data, 4, 4, null, 0);
md5.TransformFinalBlock(data, 0, 0);
var hash = md5.Hash;
Profiler.EndSample();
Debug.Log(GetHashString(hash));
}
}
{
byte[] data2 = new byte[1024 * 1024];
for (int i = 0; i < data2.Length; i++)
{
data2[i] = 0;
}
using (var md5 = new MD5CryptoServiceProvider())
{
// 0.5MB
int blockSize = 512 * 1024;
Profiler.BeginSample("TransformBlock 2");
int i = 0;
for (i = 0; i < data2.Length - blockSize; i += blockSize)
{
md5.TransformBlock(data2, i, blockSize, null, 0);
}
md5.TransformFinalBlock(data2, i, blockSize);
var hash = md5.Hash;
Profiler.EndSample();
Debug.Log(GetHashString(hash));
// 1MB
md5.Initialize();
Profiler.BeginSample("TransformBlock 3");
md5.TransformFinalBlock(data2, 0, data2.Length);
hash = md5.Hash;
Profiler.EndSample();
Debug.Log(GetHashString(hash));
// 192B
md5.Initialize();
Profiler.BeginSample("TransformBlock 4");
i = 0;
for (i = 0; i < data2.Length; i += blockSize)
{
md5.TransformBlock(data2, i, blockSize, null, 0);
}
md5.TransformFinalBlock(data2, 0, 0);
hash = md5.Hash;
Profiler.EndSample();
Debug.Log(GetHashString(hash));
}
}
// 320B
{
Profiler.BeginSample("MD5CryptoServiceProvider");
var md5 = new MD5CryptoServiceProvider();
Profiler.EndSample();
Debug.Log(md5.GetType());
}
// 1.5KB
{
Profiler.BeginSample("MD5.Create");
var md5 = MD5.Create();
Profiler.EndSample();
Debug.Log(md5.GetType());
}
}
/// <summary>
/// ownerKey, documentID must be setuped
/// </summary>
private void setupGlobalEncryptionKey(byte[] documentId, byte[] userPad, byte[] ownerKey, int permissions)
{
DocumentId = documentId;
OwnerKey = ownerKey;
Permissions = permissions;
// use variable keylength
Mkey = new byte[_keyLength / 8];
var digest = new byte[Mkey.Length];
#if NET40
//fixed by ujihara in order to follow PDF refrence
using (var md5 = new MD5CryptoServiceProvider())
{
md5.Initialize();
md5.TransformBlock(userPad, 0, userPad.Length, userPad, 0);
md5.TransformBlock(ownerKey, 0, ownerKey.Length, ownerKey, 0);
var ext = new byte[4];
ext[0] = (byte)permissions;
ext[1] = (byte)(permissions >> 8);
ext[2] = (byte)(permissions >> 16);
ext[3] = (byte)(permissions >> 24);
md5.TransformBlock(ext, 0, 4, ext, 0);
if (documentId != null)
{
md5.TransformBlock(documentId, 0, documentId.Length, documentId, 0);
}
if (!_encryptMetadata)
{
md5.TransformBlock(MetadataPad, 0, MetadataPad.Length, MetadataPad, 0);
}
md5.TransformFinalBlock(ext, 0, 0);
Array.Copy(md5.Hash, 0, digest, 0, Mkey.Length);
}
#else
//fixed by ujihara in order to follow PDF refrence
var md5 = IncrementalHash.CreateHash(HashAlgorithmName.MD5);
md5.AppendData(userPad, 0, userPad.Length);
md5.AppendData(ownerKey, 0, ownerKey.Length);
var ext = new byte[4];
ext[0] = (byte)permissions;
ext[1] = (byte)(permissions >> 8);
ext[2] = (byte)(permissions >> 16);
ext[3] = (byte)(permissions >> 24);
md5.AppendData(ext, 0, 4);
if (documentId != null)
{
md5.AppendData(documentId, 0, documentId.Length);
}
if (!_encryptMetadata)
{
md5.AppendData(MetadataPad, 0, MetadataPad.Length);
}
Array.Copy(md5.GetHashAndReset(), 0, digest, 0, Mkey.Length);
#endif
// only use the really needed bits as input for the hash
if (_revision == STANDARD_ENCRYPTION_128 || _revision == AES_128)
{
for (var k = 0; k < 50; ++k)
{
using (var md5Hash = MD5.Create())
{
Array.Copy(md5Hash.ComputeHash(digest), 0, digest, 0, Mkey.Length);
}
}
}
Array.Copy(digest, 0, Mkey, 0, Mkey.Length);
}
public override void InitNewHash()
{
m_md5.Initialize();
}
public void HandshakeHashInitialize()
{
_md5.Initialize();
_sha1.Initialize();
}
public static string send_request(String method, String url, String body = null, DataTransfer.JsonObject auth = null)
{
try
{
HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(url);
req.Method = method;
req.Date = System.DateTime.Now;
req.Credentials = CredentialCache.DefaultCredentials;
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
req.ProtocolVersion = HttpVersion.Version10;
// If a body is sent, the headers should also contain the Content-Type and Content-MD5
byte[] postBytesbody = null;
byte[] postBytesAuth = null;
if (body != null && body != "")
{
#region
md5.Initialize();
byte[] posttmpBytes = Encoding.UTF8.GetBytes(body);
md5.ComputeHash(posttmpBytes);
req.ContentType = "application/json;charset=utf-8";
String strKey = Convert.ToBase64String(md5.Hash);
req.Headers.Add("Content-MD5", strKey);
postBytesbody = Encoding.UTF8.GetBytes(body);
req.ContentLength = postBytesbody.Length;
if (auth == null)
{
using (Stream reqStream = req.GetRequestStream())
{
reqStream.Write(postBytesbody, 0, postBytesbody.Length);
}
//MessageBox.Show(req.Headers.ToString());
}
#endregion
}
if (auth != null)
{
#region
String to_sign = method + "\n";
if (body != null && body != "")
{
to_sign += req.Headers["Content-MD5"] + "\n";
to_sign += req.Headers["Content-Type"] + "\n";
}
to_sign += req.Headers["Date"] + "\n";
int iIndex = url.IndexOf('a', 7);
String sTmp = url.Substring(iIndex - 1);
to_sign += sTmp;
//MessageBox.Show(to_sign);
HMACSHA1 hmacsha1 = new HMACSHA1();
hmacsha1.Key = Encoding.UTF8.GetBytes(auth.accessKey);
byte[] dataBuffer = Encoding.UTF8.GetBytes(to_sign);
byte[] hashBytes = hmacsha1.ComputeHash(dataBuffer);
String strTmp = "AWS " + auth.id + ":" + Convert.ToBase64String(hashBytes);
req.Headers.Add("Authorization", strTmp);
postBytesAuth = Encoding.UTF8.GetBytes(strTmp);
//req.ContentLength += hashBytes.Length;
using (Stream reqStream = req.GetRequestStream())
{
reqStream.Write(postBytesbody, 0, postBytesbody.Length);
}
// MessageBox.Show(req.Headers.ToString());
#endregion
}
using (WebResponse wr = req.GetResponse())
{
Stream myResponseStream = wr.GetResponseStream();
StreamReader myStreamReader = new StreamReader(myResponseStream, Encoding.GetEncoding("utf-8"));
var retString = myStreamReader.ReadToEnd();
myStreamReader.Close();
myResponseStream.Close();
return(retString);
//在这里对接收到的页面内容进行处理
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
return(null);
}
public static CipherSuite InitializeCipherSuite(byte[] master, byte[] clientrnd, byte[] serverrnd, CipherDefinition definition, ConnectionEnd entity)
{
CipherSuite ret = new CipherSuite();
SymmetricAlgorithm bulk = (SymmetricAlgorithm)Activator.CreateInstance(definition.BulkCipherAlgorithm);
if (definition.BulkIVSize > 0)
{
bulk.Mode = CipherMode.CBC;
}
bulk.Padding = PaddingMode.None;
bulk.BlockSize = definition.BulkIVSize * 8;
// get the keys and IVs
byte[] client_mac, server_mac, client_key, server_key, client_iv, server_iv;
Ssl3DeriveBytes prf = new Ssl3DeriveBytes(master, clientrnd, serverrnd, false);
client_mac = prf.GetBytes(definition.HashSize);
server_mac = prf.GetBytes(definition.HashSize);
client_key = prf.GetBytes(definition.BulkKeySize);
server_key = prf.GetBytes(definition.BulkKeySize);
client_iv = prf.GetBytes(definition.BulkIVSize);
server_iv = prf.GetBytes(definition.BulkIVSize);
prf.Dispose();
if (definition.Exportable) // make some extra modifications if the keys are exportable
{
MD5 md5 = new MD5CryptoServiceProvider();
md5.TransformBlock(client_key, 0, client_key.Length, client_key, 0);
md5.TransformBlock(clientrnd, 0, clientrnd.Length, clientrnd, 0);
md5.TransformFinalBlock(serverrnd, 0, serverrnd.Length);
client_key = new byte[definition.BulkExpandedSize];
Buffer.BlockCopy(md5.Hash, 0, client_key, 0, client_key.Length);
md5.Initialize();
md5.TransformBlock(server_key, 0, server_key.Length, server_key, 0);
md5.TransformBlock(serverrnd, 0, serverrnd.Length, serverrnd, 0);
md5.TransformFinalBlock(clientrnd, 0, clientrnd.Length);
server_key = new byte[definition.BulkExpandedSize];
Buffer.BlockCopy(md5.Hash, 0, server_key, 0, server_key.Length);
md5.Initialize();
md5.TransformBlock(clientrnd, 0, clientrnd.Length, clientrnd, 0);
md5.TransformFinalBlock(serverrnd, 0, serverrnd.Length);
client_iv = new byte[definition.BulkIVSize];
Buffer.BlockCopy(md5.Hash, 0, client_iv, 0, client_iv.Length);
md5.Initialize();
md5.TransformBlock(serverrnd, 0, serverrnd.Length, serverrnd, 0);
md5.TransformFinalBlock(clientrnd, 0, clientrnd.Length);
server_iv = new byte[definition.BulkIVSize];
Buffer.BlockCopy(md5.Hash, 0, server_iv, 0, server_iv.Length);
md5.Clear();
}
// generate the cipher objects
if (entity == ConnectionEnd.Client)
{
ret.Encryptor = bulk.CreateEncryptor(client_key, client_iv);
ret.Decryptor = bulk.CreateDecryptor(server_key, server_iv);
ret.LocalHasher = new Ssl3RecordMAC(definition.HashAlgorithmType, client_mac);
ret.RemoteHasher = new Ssl3RecordMAC(definition.HashAlgorithmType, server_mac);
}
else
{
ret.Encryptor = bulk.CreateEncryptor(server_key, server_iv);
ret.Decryptor = bulk.CreateDecryptor(client_key, client_iv);
ret.LocalHasher = new Ssl3RecordMAC(definition.HashAlgorithmType, server_mac);
ret.RemoteHasher = new Ssl3RecordMAC(definition.HashAlgorithmType, client_mac);
}
// clear sensitive data
Array.Clear(client_mac, 0, client_mac.Length);
Array.Clear(server_mac, 0, server_mac.Length);
Array.Clear(client_key, 0, client_key.Length);
Array.Clear(server_key, 0, server_key.Length);
Array.Clear(client_iv, 0, client_iv.Length);
Array.Clear(server_iv, 0, server_iv.Length);
return(ret);
}
public static string AnyscMD5(string filepath, ProgressBar pBar, Label lab)
{
FileStream fs = new FileStream(filepath, FileMode.Open, FileAccess.Read, FileShare.Read);
int bufferSize = 1048576; // 缓冲区大小，1MB
byte[] buff = new byte[bufferSize];
double blockcount = Math.Ceiling(fs.Length / Convert.ToDouble(bufferSize));
if (pBar.InvokeRequired == true)
{
SetText LSetText = new SetText(DoSetText);
SetValue PSetValue = new SetValue(DoSetMax);
pBar.Invoke(PSetValue, new Object[] { pBar, Convert.ToInt32(blockcount) });
lab.Invoke(LSetText, new Object[] { lab, Convert.ToString(0) + "%" });
}
int i = 1;
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
md5.Initialize();
long offset = 0;
while (offset < fs.Length)
{
long readSize = bufferSize;
if (offset + readSize > fs.Length)
{
readSize = fs.Length - offset;
}
fs.Read(buff, 0, Convert.ToInt32(readSize)); // 读取一段数据到缓冲区
if (offset + readSize < fs.Length) // 不是最后一块
{
md5.TransformBlock(buff, 0, Convert.ToInt32(readSize), buff, 0);
}
else // 最后一块
{
md5.TransformFinalBlock(buff, 0, Convert.ToInt32(readSize));
}
offset += bufferSize;
if (pBar.InvokeRequired == true)
{
SetValue PSetValue = new SetValue(DoSetValue);
SetText LSetText = new SetText(DoSetText);
pBar.Invoke(PSetValue, new Object[] { pBar, Convert.ToInt32(i) });
lab.Invoke(LSetText, new Object[] { lab, Convert.ToString(Math.Ceiling((double)(i / blockcount) * 100)) + "%" });
i++;
Application.DoEvents();
}
}
fs.Close();
byte[] result = md5.Hash;
md5.Clear();
StringBuilder sb = new StringBuilder(32);
for (int j = 0; j < result.Length; j++)
{
sb.Append(result[j].ToString("x2"));
}
return(sb.ToString());
}
private static void GetObjectCallback(IAsyncResult ar)
{
Hashtable state = (Hashtable)ar.AsyncState;
Action <string> getCallback = (Action <string>)state["callback"];
try
{
OssClient ossClient = (OssClient)state["client"];
string ossfilename = (string)state["ossfilename"];
string localfilename = (string)state["localfilename"];
var result = ossClient.EndGetObject(ar);
var metadata = result.Metadata;
var requestStream = result.Content;
var fs = new FileStream(localfilename, FileMode.OpenOrCreate);
int bufLength = 4 * 1024;
var buf = new byte[bufLength];
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
md5.Initialize();
int offset = 0;
int contentLength = (int)metadata.ContentLength;
while (offset < contentLength)
{
int readSize = bufLength;
if (offset + readSize > contentLength)
{
readSize = contentLength - offset;
}
readSize = requestStream.Read(buf, 0, readSize);
fs.Write(buf, 0, readSize);
if (offset + readSize < contentLength) // 不是最后一块
{
md5.TransformBlock(buf, 0, Convert.ToInt32(readSize), buf, 0);
}
else // 最后一块
{
md5.TransformFinalBlock(buf, 0, Convert.ToInt32(readSize));
}
offset += readSize;
}
fs.Close();
byte[] md5Hash = md5.Hash;
md5.Clear();
string ext = System.IO.Path.GetExtension(ossfilename);
string buffermd5 = Utils.File.FormatMD5(md5Hash) + ext;
if (buffermd5 == ossfilename)
{
_dispatcher.Enqueue(() => {
if (getCallback != null)
{
getCallback(localfilename);
}
});
}
else
{
System.IO.File.Delete(localfilename);
_dispatcher.Enqueue(() => {
if (getCallback != null)
{
getCallback("CheckMD5Failed");
}
});
}
Console.WriteLine(ar.AsyncState as string);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
_dispatcher.Enqueue(() => {
if (getCallback != null)
{
if (ex is ServiceException)
{
string errorCode = ((ServiceException)ex).ErrorCode;
getCallback(errorCode);
if (errorCode == "InvalidAccessKeyId")
{
FetchSTSToken();
}
}
else
{
getCallback(ex.Message);
}
}
});
}
finally
{
// _event.Set();
}
}
/// <summary>
/// Constructor.
/// </summary>
public Md5Sum()
{
_md5Sum = new MD5CryptoServiceProvider();
_md5Sum.Initialize();
}