/// <summary>
/// Get the hash representing the string
/// </summary>
/// <param name="target">The bytes array to hash</param>
/// <param name="algorithm">The hash algortihm to use</param>
/// <returns>The hash value</returns>
public static string GetHash(this byte[] target, HashAlgorithms algorithm)
{
if (algorithm == HashAlgorithms.Md5)
{
var md5 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
var buffer = CryptographicBuffer.CreateFromByteArray(target);
var hashed = md5.HashData(buffer);
return(CryptographicBuffer.EncodeToHexString(hashed));
}
else if (algorithm == HashAlgorithms.Sha512 || algorithm == HashAlgorithms.Sha256)
{
var sha = HashAlgorithmProvider.OpenAlgorithm(algorithm == HashAlgorithms.Sha512 ? HashAlgorithmNames.Sha256 : HashAlgorithmNames.Sha512);
var buffer = CryptographicBuffer.CreateFromByteArray(target);
var hashed = sha.HashData(buffer);
byte[] bytes;
CryptographicBuffer.CopyToByteArray(hashed, out bytes);
return(Convert.ToBase64String(bytes));
}
else
{
throw new NotSupportedException("Unsupported hash algorithm");
}
}
private static string GetFileHash(HashAlgorithms hashAlgorithmSelected, FileInfo inputFile)
{
HashAlgorithm hashAlgorithm;
switch (hashAlgorithmSelected)
{
case HashAlgorithms.md5:
hashAlgorithm = MD5.Create();
break;
case HashAlgorithms.sha1:
hashAlgorithm = SHA1.Create();
break;
case HashAlgorithms.sha384:
hashAlgorithm = SHA384.Create();
break;
case HashAlgorithms.sha512:
hashAlgorithm = SHA512.Create();
break;
default:
hashAlgorithm = SHA256.Create();
break;
}
try
{
// Create a fileStream for the file.
FileStream fileStream = inputFile.Open(FileMode.Open, FileAccess.Read);
// Be sure it's positioned to the beginning of the stream.
fileStream.Position = 0;
// Compute the hash of the fileStream.
byte[] hashValue = hashAlgorithm.ComputeHash(fileStream);
// Create a new Stringbuilder to collect the bytes
// and create a string.
StringBuilder sBuilder = new StringBuilder();
// Loop through each byte of the hashed data
// and format each one as a hexadecimal string.
for (int i = 0; i < hashValue.Length; i++)
{
sBuilder.Append(hashValue[i].ToString("x2"));
}
// Close the file.
fileStream.Close();
// Return the hexadecimal string.
return(sBuilder.ToString());
}
catch (Exception e)
{
return(e.GetType().Name);
}
finally
{
hashAlgorithm.Dispose();
}
}
public static byte[] Create(string message, HashAlgorithms hashAlgorithm, X509Certificate2 certificate)
{
RSACryptoServiceProvider csp = (RSACryptoServiceProvider)certificate.PrivateKey;
if (csp == null)
{
throw new Exception("Valid certificate was not found");
}
UnicodeEncoding encoding = new UnicodeEncoding();
byte[] data = encoding.GetBytes(message); //current message encripted in bytes
byte[] hash = null; //hash result
if (hashAlgorithm.Equals(HashAlgorithms.SHA1))
{
SHA1Managed sha1 = new SHA1Managed();
hash = sha1.ComputeHash(data);
}
else if (hashAlgorithm.Equals(HashAlgorithms.SHA256))
{
SHA256Managed sha256 = new SHA256Managed();
hash = sha256.ComputeHash(data);
}
return(csp.SignHash(hash, CryptoConfig.MapNameToOID(hashAlgorithm.ToString())));
}
private static HashAlgorithm GetHashAlgorithm(HashAlgorithms hashAlgorithm)
{
switch (hashAlgorithm)
{
#if NETFRAMEWORK
case HashAlgorithms.MD5:
return(new MD5Cng());
case HashAlgorithms.RIPEMD160:
return(new RIPEMD160Managed());
case HashAlgorithms.SHA1:
return(new SHA1Cng());
case HashAlgorithms.SHA256:
return(new SHA256Cng());
case HashAlgorithms.SHA384:
return(new SHA384Cng());
case HashAlgorithms.SHA512:
return(new SHA512Cng());
#endif
default:
throw new InvalidOperationException(Resources.UnsupportedHashAlgorithmException);
}
}
//=================================================================
//=================================================
//
// CRYPTOGRAPHY FACTORIES
//
//=================================================
//---------------------------------------------------------------------
public static HashAlgorithm Create_HashAlgorithm(HashAlgorithms HashAlgorithm_in)
{
switch (HashAlgorithm_in)
{
case HashAlgorithms.None:
return(null);
case HashAlgorithms.MD5_128:
return(new MD5CryptoServiceProvider());
case HashAlgorithms.SHA1_160:
return(new SHA1CryptoServiceProvider());
case HashAlgorithms.SHA_256:
return(new SHA256Managed());
case HashAlgorithms.SHA_384:
return(new SHA384Managed());
case HashAlgorithms.SHA_512:
return(new SHA512Managed());
default:
return(null);
}
}
public AsyncHasher(HashAlgorithms algorithm)
{
switch (algorithm)
{
case HashAlgorithms.MD5:
_hashAlgorithm = MD5.Create();
break;
case HashAlgorithms.SHA1:
_hashAlgorithm = SHA1.Create();
break;
case HashAlgorithms.SHA256:
_hashAlgorithm = SHA256.Create();
break;
case HashAlgorithms.SHA512:
_hashAlgorithm = SHA512.Create();
break;
case HashAlgorithms.CRC32:
_hashAlgorithm = new Crc32();
break;
case HashAlgorithms.CRC64:
_hashAlgorithm = new Crc64Iso();
break;
}
}
/// <summary>
/// 指定哈希算法，哈希指定的。
/// </summary>
/// <param name="alog">哈希算法。</param>
/// <param name="bytes">要计算其哈希代码的输入。</param>
/// <returns>计算所得的哈希代码。</returns>
public static byte[] Crypto(HashAlgorithms alog, byte[] bytes)
{
HashAlgorithm algorithm;
switch (alog)
{
case HashAlgorithms.SHA1:
algorithm = CreateSHA1();
break;
case HashAlgorithms.SHA256:
algorithm = CreateSHA256();
break;
case HashAlgorithms.SHA384:
algorithm = CreateSHA384();
break;
case HashAlgorithms.SHA512:
algorithm = CreateSHA512();
break;
case HashAlgorithms.MD5:
algorithm = CreateMD5();
break;
default: throw new NotSupportedException();
}
using (algorithm)
{
return(algorithm.ComputeHash(bytes));
}
}
public static CalculateHash Create(HashAlgorithms algorithm = HashAlgorithms.SHA256)
{
HashAlgorithmName algorithmName;
switch (algorithm)
{
case HashAlgorithms.MD5:
algorithmName = HashAlgorithmName.MD5;
break;
case HashAlgorithms.SHA1:
algorithmName = HashAlgorithmName.SHA1;
break;
default:
case HashAlgorithms.SHA256:
algorithmName = HashAlgorithmName.SHA256;
break;
case HashAlgorithms.SHA384:
algorithmName = HashAlgorithmName.SHA384;
break;
case HashAlgorithms.SHA512:
algorithmName = HashAlgorithmName.SHA512;
break;
}
return(new CalculateHash(algorithmName));
}
/// <summary>
/// Create a new wireless communication module.
/// </summary>
/// <param name="HashAlgorithm">The used hash algorithm.</param>
/// <param name="IssuerNameHash">The hashed value of the issuer distinguished name (DN).</param>
/// <param name="IssuerKeyHash">The hashed value of the issuers public key.</param>
/// <param name="SerialNumber">The serial number of the certificate to verify.</param>
/// <param name="ResponderURL">The case-insensitive responder URL.</param>
/// <param name="CustomData">An optional custom data object to allow to store any kind of customer specific data.</param>
public OCSPRequestData(HashAlgorithms HashAlgorithm,
String IssuerNameHash,
String IssuerKeyHash,
String SerialNumber,
String ResponderURL,
CustomData CustomData = null)
{
this.HashAlgorithm = HashAlgorithm;
this.IssuerNameHash = IssuerNameHash?.Trim();
this.IssuerKeyHash = IssuerKeyHash?.Trim();
this.SerialNumber = SerialNumber?.Trim();
this.ResponderURL = ResponderURL?.Trim();
this.CustomData = CustomData;
if (this.IssuerNameHash.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(IssuerNameHash), "The given issuer name hash must not be null or empty!");
}
if (this.IssuerKeyHash.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(IssuerKeyHash), "The given issuer key hash must not be null or empty!");
}
if (this.SerialNumber.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(SerialNumber), "The given serial number must not be null or empty!");
}
if (this.ResponderURL.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(ResponderURL), "The given responder URL must not be null or empty!");
}
}
public static string HashInputString(string input, HashAlgorithms alg = HashAlgorithms.MD5)
{
HashAlgorithm hashAlgorithm = null;
switch (alg)
{
case HashAlgorithms.MD5:
hashAlgorithm = MD5.Create();
break;
case HashAlgorithms.SHA1:
hashAlgorithm = SHA1.Create();
break;
case HashAlgorithms.SHA256:
hashAlgorithm = SHA256.Create();
break;
case HashAlgorithms.SHA512:
hashAlgorithm = SHA512.Create();
break;
}
byte[] data = Encoding.UTF8.GetBytes(input);
byte[] output = hashAlgorithm.ComputeHash(data);
return(MakeHashString(output));
}
public static byte[] GetHashBytes(this object obj, HashAlgorithms algoName, int saltLength)
{
byte[] hashBytes = obj.GetHashBytes(algoName);
byte[] salt = new byte[saltLength];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetBytes(salt);
byte[] hashAndSalt = new byte[hashBytes.Length + salt.Length];
for (int i = 0; i < hashAndSalt.Length; i++)
{
if (i < hashBytes.Length)
{
hashAndSalt[i] = hashBytes[i];
}
else
{
int saltIndex = i - hashBytes.Length;
hashAndSalt[i] = salt[saltIndex];
}
}
return(hashAndSalt);
}
public static byte[] GetHashBytes(this object obj, HashAlgorithms algoName)
{
HashAlgorithm algo;
switch (algoName)
{
case HashAlgorithms.SHA512:
algo = new SHA512Managed();
break;
case HashAlgorithms.SHA256:
algo = new SHA256Managed();
break;
case HashAlgorithms.SHA384:
algo = new SHA384Managed();
break;
default:
algo = new SHA512Managed();
break;
}
byte[] hashBytes;
if (obj is byte[])
{
hashBytes = obj as byte[];
}
else
{
byte[] bytes = obj.ToByteArray();
hashBytes = algo.ComputeHash(bytes);
}
return(hashBytes);
}
//---------------------------------------------------------------------
public static byte[] Create_CryptographicIV(HashAlgorithms HashAlgorithm_in, int IVBitSize_in, byte[] PasswordBytes_in)
{
// Derive an IV by XOR-ing the Key with a predefined mask
byte[] KeyMask_256 =
{
30, 2, 141, 78, 82, 33, 76, 248, 56, 182,
254, 34, 59, 188, 225, 1, 180, 209, 15, 220,
52, 69, 2, 188, 235, 27, 175, 116, 234, 127,
28, 179
};
byte[] KeyBase = new byte[PasswordBytes_in.Length];
int ndxPassword = 0;
int ndxMask = 0;
for (ndxPassword = PasswordBytes_in.GetLowerBound(0); ndxPassword <= PasswordBytes_in.GetUpperBound(0); ndxPassword++)
{
KeyBase[ndxPassword] = (byte)(PasswordBytes_in[ndxPassword] ^ KeyMask_256[ndxMask]);
ndxMask += 1;
if ((ndxMask == KeyMask_256.Length))
{
ndxMask = 0;
}
}
return(Create_CryptographicKey(HashAlgorithm_in, IVBitSize_in, KeyBase));
}
private static HashAlgorithm GetHashAlgorithm(HashAlgorithms hashAlgorithm)
{
switch (hashAlgorithm)
{
case HashAlgorithms.MD5:
return(new MD5Cng());
case HashAlgorithms.RIPEMD160:
return(new RIPEMD160Managed());
case HashAlgorithms.SHA1:
return(new SHA1Cng());
case HashAlgorithms.SHA256:
return(new SHA256Cng());
case HashAlgorithms.SHA384:
return(new SHA384Cng());
case HashAlgorithms.SHA512:
return(new SHA512Cng());
default:
throw new InvalidOperationException();
}
}
/// <summary>
/// Term order. Comparision is pairwise using the term ordering of <see cref="HashAlgorithms.CompareValues" />.
/// </summary>
/// <param name="obj"></param>
/// <returns>-1 if less than, 0 if equal, 1 if greater than</returns>
/// <exception cref="System.ArgumentException">Thrown if <paramref name="obj"/> is not of the same type as this triple.</exception>
/// <seealso cref="HashAlgorithms.CompareValues" />
public int CompareTo(object obj)
{
if ((object)obj == null)
{
return(1);
}
if (!(obj is Triple <T, S, R>))
{
throw new ArgumentException("Incomparable argument");
}
Triple <T, S, R> other = (Triple <T, S, R>)obj;
int f1 = HashAlgorithms.CompareValues(this.first, other.first);
if (f1 != 0)
{
return(f1);
}
int f2 = HashAlgorithms.CompareValues(this.second, other.second);
if (f2 != 0)
{
return(f2);
}
int f3 = HashAlgorithms.CompareValues(this.third, other.third);
//^ assert f3 == 0 ==> Object.Equals(this, other);
return(f3);
}
/*
* Supported Hash Algorithms
* ---------------------------
* MD5 (MD5-128)
* SHA0 (SHA0-160)
* SHA1 (SHA1-160)
* SHA2-224 (SHA-224)
* SHA2-256 (SHA-256)
* SHA2-384 (SHA-384)
* SHA2-512 (SHA-512)
* SHA2-512/224 (SHA-512/224)
* SHA2-512/256 (SHA-512/256)
* SHA3-224
* SHA3-256
* SHA3-384
* SHA3-512
*/
#region Methods
public string Hash(string message, HashAlgorithms algorithm, Encoding encoding)
{
HashAlgorithm hashAlgorithm;
switch (algorithm)
{
case HashAlgorithms.MD5:
hashAlgorithm = new MD5CryptoServiceProvider();
break;
case HashAlgorithms.SHA0:
throw new NotSupportedException("Not supported hash algorithm :(");
case HashAlgorithms.SHA1:
hashAlgorithm = new SHA1Managed();
break;
case HashAlgorithms.SHA2_224:
throw new NotSupportedException("Not supported hash algorithm :(");
case HashAlgorithms.SHA2_256:
hashAlgorithm = new SHA256Managed();
break;
case HashAlgorithms.SHA2_384:
hashAlgorithm = new SHA384Managed();
break;
case HashAlgorithms.SHA2_512:
hashAlgorithm = new SHA512Managed();
break;
case HashAlgorithms.SHA2_512_224:
throw new NotSupportedException("Not supported hash algorithm :(");
case HashAlgorithms.SHA2_512_256:
throw new NotSupportedException("Not supported hash algorithm :(");
case HashAlgorithms.SHA3_224:
throw new NotSupportedException("Not supported hash algorithm :(");
case HashAlgorithms.SHA3_256:
throw new NotSupportedException("Not supported hash algorithm :(");
case HashAlgorithms.SHA3_384:
throw new NotSupportedException("Not supported hash algorithm :(");
case HashAlgorithms.SHA3_512:
throw new NotSupportedException("Not supported hash algorithm :(");
default:
throw new NotSupportedException("Not supported hash algorithm :(");
}
byte[] bytes = hashAlgorithm.ComputeHash(encoding.GetBytes(message));
string hash = BitConverter.ToString(bytes).Replace("-", string.Empty).ToLower();
return(hash);
}
/// <summary>
/// Get the hash representing the string
/// </summary>
/// <param name="target">The string to hash</param>
/// <param name="algorithm">The hash algortihm to use</param>
/// <returns>The hash value</returns>
public static string GetHash(this string target, HashAlgorithms algorithm)
{
#if NETCORE
return(UTF8Encoding.UTF8.GetBytes(target).GetHash(algorithm));
#else
return(UTF8Encoding.UTF8.GetBytes(target).GetHash(algorithm));
#endif
}
internal static string HashBytes(byte[] val, HashAlgorithms hashAlgorithm)
{
using (HashAlgorithm hasher = Crypt.Hash.GetHashAlgorithm(hashAlgorithm))
{
byte[] hash = hasher.ComputeHash(val, 0, val.Length);
return(Convert.ToBase64String(hash));
}
}
/// <summary>
/// Get the first checksum algorithm mutually supported by both servers.
/// </summary>
private FtpHashAlgorithm GetFirstMutualChecksum(FtpClient destination)
{
// special handling for HASH command which is a meta-command supporting all hash types
if (HasFeature(FtpCapability.HASH) && destination.HasFeature(FtpCapability.HASH))
{
if (HashAlgorithms.HasFlag(FtpHashAlgorithm.MD5) && destination.HashAlgorithms.HasFlag(FtpHashAlgorithm.MD5))
{
return(FtpHashAlgorithm.MD5);
}
if (HashAlgorithms.HasFlag(FtpHashAlgorithm.SHA1) && destination.HashAlgorithms.HasFlag(FtpHashAlgorithm.SHA1))
{
return(FtpHashAlgorithm.SHA1);
}
if (HashAlgorithms.HasFlag(FtpHashAlgorithm.SHA256) && destination.HashAlgorithms.HasFlag(FtpHashAlgorithm.SHA256))
{
return(FtpHashAlgorithm.SHA256);
}
if (HashAlgorithms.HasFlag(FtpHashAlgorithm.SHA512) && destination.HashAlgorithms.HasFlag(FtpHashAlgorithm.SHA512))
{
return(FtpHashAlgorithm.SHA512);
}
if (HashAlgorithms.HasFlag(FtpHashAlgorithm.CRC) && destination.HashAlgorithms.HasFlag(FtpHashAlgorithm.CRC))
{
return(FtpHashAlgorithm.CRC);
}
}
// handling for non-standard specific hashing commands
if (HasFeature(FtpCapability.MD5) && destination.HasFeature(FtpCapability.MD5))
{
return(FtpHashAlgorithm.MD5);
}
if (HasFeature(FtpCapability.XMD5) && destination.HasFeature(FtpCapability.XMD5))
{
return(FtpHashAlgorithm.MD5);
}
if (HasFeature(FtpCapability.MMD5) && destination.HasFeature(FtpCapability.MMD5))
{
return(FtpHashAlgorithm.MD5);
}
if (HasFeature(FtpCapability.XSHA1) && destination.HasFeature(FtpCapability.XSHA1))
{
return(FtpHashAlgorithm.SHA1);
}
if (HasFeature(FtpCapability.XSHA256) && destination.HasFeature(FtpCapability.XSHA256))
{
return(FtpHashAlgorithm.SHA256);
}
if (HasFeature(FtpCapability.XSHA512) && destination.HasFeature(FtpCapability.XSHA512))
{
return(FtpHashAlgorithm.SHA512);
}
if (HasFeature(FtpCapability.XCRC) && destination.HasFeature(FtpCapability.XCRC))
{
return(FtpHashAlgorithm.CRC);
}
return(FtpHashAlgorithm.NONE);
}
byte[] ComputeHash(string str, HashAlgorithms algorithm)
{
HashAlgorithm hasher = GetHasher(algorithm);
byte[] buffer = Encoding.UTF8.GetBytes(str);
byte[] hash = hasher.ComputeHash(buffer);
//hasher.Dispose();
return(hash);
}
public HashProvider(HashAlgorithms HashAlgorithm)
{
switch (HashAlgorithm)
{
case HashAlgorithms.MD5: _Hash = MD5.Create(); break;
case HashAlgorithms.SHA512: _Hash = SHA512.Create(); break;
case HashAlgorithms.SHA256: _Hash = SHA256.Create(); break;
}
}
public static bool VerifyHash(string plainText, HashAlgorithms hashAlgorithm, string hashValue)
{
// Base64-encoded hash
byte[] hashWithSaltBytes = Convert.FromBase64String(hashValue);
// Hash without Salt
int hashSizeInBits, hashSizeInBytes;
// Size of hash is based on the specified algorithm.
switch (hashAlgorithm)
{
case HashAlgorithms.SHA1:
hashSizeInBits = 160;
break;
case HashAlgorithms.SHA256:
hashSizeInBits = 256;
break;
case HashAlgorithms.SHA384:
hashSizeInBits = 384;
break;
case HashAlgorithms.SHA512:
hashSizeInBits = 512;
break;
default: // MD5
hashSizeInBits = 128;
break;
}
// Convert to bytes.
hashSizeInBytes = hashSizeInBits / 8;
// Verify Hash Length
if (hashWithSaltBytes.Length < hashSizeInBytes)
{
return(false);
}
// Array to hold Salt
byte[] saltBytes = new byte[hashWithSaltBytes.Length - hashSizeInBytes];
// Salt to New Array
for (int i = 0; i < saltBytes.Length; i++)
{
saltBytes[i] = hashWithSaltBytes[hashSizeInBytes + i];
}
string expectedHashString = ComputeHash(plainText, hashAlgorithm, saltBytes);
return(hashValue == expectedHashString);
}
/// <summary>
/// Computes a Hash of the Data using the specified Algorithm
/// </summary>
/// <param name="Data">The Data to Hash</param>
/// <param name="Algorithm">The Hash Algorithm to use</param>
/// <param name="Base64Encode">True to return a Base64 Encoded string (for use in Xml files).</param>
/// <returns></returns>
public static string Hash(string Data, HashAlgorithms Algorithm, bool Base64Encode)
{
// Determine the Hash Algorithm
HashAlgorithm hashAlgorithm = null;
switch (Algorithm)
{
case HashAlgorithms.MD5:
hashAlgorithm = new MD5CryptoServiceProvider();
break;
case HashAlgorithms.SHA1:
hashAlgorithm = new SHA1Managed();
break;
case HashAlgorithms.SHA256:
hashAlgorithm = new SHA256Managed();
break;
case HashAlgorithms.SHA384:
hashAlgorithm = new SHA384Managed();
break;
case HashAlgorithms.SHA512:
hashAlgorithm = new SHA512Managed();
break;
}
try
{
byte[] hashData = System.Text.Encoding.UTF8.GetBytes(Data);
hashData = hashAlgorithm.ComputeHash(hashData);
if (Base64Encode)
{
return(Convert.ToBase64String(hashData));
}
else
{
return(System.Text.Encoding.UTF8.GetString(hashData));
}
}
catch
{
return(string.Empty);
}
finally
{
if (hashAlgorithm != null)
{
hashAlgorithm.Clear();
hashAlgorithm = null;
}
}
}
private void ValidateHashAlgorithm(FtpHashAlgorithm algorithm)
{
// if NO hashing algos or commands supported, throw here
if (!HasFeature(FtpCapability.HASH) &&
!HasFeature(FtpCapability.MD5) &&
!HasFeature(FtpCapability.XMD5) &&
!HasFeature(FtpCapability.MMD5) &&
!HasFeature(FtpCapability.XSHA1) &&
!HasFeature(FtpCapability.XSHA256) &&
!HasFeature(FtpCapability.XSHA512) &&
!HasFeature(FtpCapability.XCRC))
{
throw new FtpHashUnsupportedException();
}
// only if the user has specified a certain hash algorithm
var useFirst = (algorithm == FtpHashAlgorithm.NONE);
if (!useFirst)
{
// first check if the HASH command supports the required algo
if (HasFeature(FtpCapability.HASH) && HashAlgorithms.HasFlag(algorithm))
{
// we are good
}
else
{
// second check if the special FTP command is supported based on the algo
if (algorithm == FtpHashAlgorithm.MD5 && !HasFeature(FtpCapability.MD5) &&
!HasFeature(FtpCapability.XMD5) && !HasFeature(FtpCapability.MMD5))
{
throw new FtpHashUnsupportedException(FtpHashAlgorithm.MD5, "MD5, XMD5, MMD5");
}
if (algorithm == FtpHashAlgorithm.SHA1 && !HasFeature(FtpCapability.XSHA1))
{
throw new FtpHashUnsupportedException(FtpHashAlgorithm.SHA1, "XSHA1");
}
if (algorithm == FtpHashAlgorithm.SHA256 && !HasFeature(FtpCapability.XSHA256))
{
throw new FtpHashUnsupportedException(FtpHashAlgorithm.SHA256, "XSHA256");
}
if (algorithm == FtpHashAlgorithm.SHA512 && !HasFeature(FtpCapability.XSHA512))
{
throw new FtpHashUnsupportedException(FtpHashAlgorithm.SHA512, "XSHA512");
}
if (algorithm == FtpHashAlgorithm.CRC && !HasFeature(FtpCapability.XCRC))
{
throw new FtpHashUnsupportedException(FtpHashAlgorithm.CRC, "XCRC");
}
// we are good
}
}
}
public static string BuildHash(Info di, HashAlgorithms hashAlgorithm)
{
var ids = di.GetIdentities().Select(did => did.Key).ToList();
var features = di.GetFeatures().Select(df => df.Var).ToList();
var forms = di.GetDataForms().Select(form => form.GetField("FORM_TYPE").GetValue()).ToList();
// sort everything now
ids.Sort();
features.Sort();
forms.Sort();
var sb = new StringBuilder();
foreach (string s in ids)
{
sb.Append(s + "<");
}
foreach (string s in features)
{
sb.Append(s + "<");
}
foreach (string s in forms)
{
sb.Append(s + "<");
}
foreach (string formType in forms)
{
string ftype = formType;
var data = di.GetDataForms().FirstOrDefault(f => f.GetField("FORM_TYPE").GetValue() == ftype);
var fields = (
from field in data.GetFields()
where field.Var != "FORM_TYPE"
orderby field.Var
select field.Var
).ToList();
foreach (string field in fields)
{
sb.Append(field + "<");
foreach (string val in data.GetField(field).GetValues())
{
sb.Append(val + "<");
}
}
}
string ret = HashBytes(Encoding.UTF8.GetBytes(sb.ToString()), hashAlgorithm);
return(ret);
}
public static bool IsFipsCompliant(HashAlgorithms hashAlgorithm)
{
switch (hashAlgorithm)
{
case HashAlgorithms.MD5:
case HashAlgorithms.RIPEMD160:
return(false);
default:
return(true);
}
}
HashAlgorithm GetHasher(HashAlgorithms algorithm)
{
switch (algorithm)
{
case HashAlgorithms.MD5: return(MD5.Create());
case HashAlgorithms.SHA1: return(SHA1.Create());
case HashAlgorithms.SHA256: return(SHA256.Create());
default: return(null);
}
}
private const int PBKDF2_Iterations = 10000; // Value recommended in literature.
public static byte[] HashData(HashAlgorithms hashAlgorithm, byte[] inputBytes)
{
byte[] result;
using (HashAlgorithm algorithm = GetHashAlgorithm(hashAlgorithm))
{
result = algorithm.ComputeHash(inputBytes);
algorithm.Clear();
}
return(result);
}
void IssueComputeHash(HashAlgorithms algorithm)
{
lock (this.computations)
{
ComputationProgress computation = new ComputationProgress(algorithm);
Thread thread = new Thread(AsyncComputeHash);
thread.IsBackground = true;
thread.Start(computation);
this.computations.Add(computation);
}
}
public static bool IsFipsCompliant(HashAlgorithms hashAlgorithm)
{
switch (hashAlgorithm)
{
#if NETFRAMEWORK
case HashAlgorithms.MD5:
case HashAlgorithms.RIPEMD160:
return(false);
#endif
default:
return(true);
}
}
public HashAlgorithm GetHashAlgorithm(HashAlgorithms hashAlgorithm)
{
return HashAlgorithmProviders[hashAlgorithm].Build();
}
public void StartHashing(string file, HashAlgorithms method, int tb)
{
this.Text = "Checksum - Calculating Hash...";
foreach (Control c in this.Controls)
{
if (c.GetType() != typeof(LinkLabel))
c.Enabled = false;
}
thd = new Thread(() => CalculateHash(file, method, tb));
thd.Start();
}
public void CalculateHash(string file, HashAlgorithms method, int tb)
{
output = "";
if (!System.IO.File.Exists(file))
return;
switch (method)
{
case HashAlgorithms.SHA1:
output = CalculateSHA1Hash(file);
break;
case HashAlgorithms.SHA256:
output = CalculateSHA256Hash(file);
break;
case HashAlgorithms.SHA512:
output = CalculateSHA512Hash(file);
break;
case HashAlgorithms.MD5:
output = CalculateMD5Hash(file);
break;
}
EnableForm();
if (tb == 1)
SetText1();
else
SetText2();
lastFileLocation = System.IO.Path.GetFullPath(file);
}
