[System.Security.SecuritySafeCritical] // auto-generated
public HMACSHA384 (byte[] key) {
m_hashName = "SHA384";
m_hash1 = new SHA384Managed();
m_hash2 = new SHA384Managed();
HashSizeValue = 384;
BlockSizeValue = BlockSize;
base.InitializeKey(key);
}
[System.Security.SecuritySafeCritical] // auto-generated
public HMACSHA384 (byte[] key) {
m_hashName = "SHA384";
#if FULL_AOT_RUNTIME
m_hash1 = new SHA384Managed();
m_hash2 = new SHA384Managed();
#else
m_hash1 = GetHashAlgorithmWithFipsFallback(() => new SHA384Managed(), () => HashAlgorithm.Create("System.Security.Cryptography.SHA384CryptoServiceProvider"));
m_hash2 = GetHashAlgorithmWithFipsFallback(() => new SHA384Managed(), () => HashAlgorithm.Create("System.Security.Cryptography.SHA384CryptoServiceProvider"));
#endif
HashSizeValue = 384;
BlockSizeValue = BlockSize;
base.InitializeKey(key);
}
SHA384Managed (SHA384Managed other)
{
xBuf = new byte [other.xBuf.Length];
Array.Copy (other.xBuf, xBuf, xBuf.Length);
xBufOff = other.xBufOff;
byteCount1 = other.byteCount1;
byteCount2 = other.byteCount2;
H1 = other.H1;
H2 = other.H2;
H3 = other.H3;
H4 = other.H4;
H5 = other.H5;
H6 = other.H6;
H7 = other.H7;
H8 = other.H8;
W = new ulong [other.W.Length];
Array.Copy (other.W, W, W.Length);
wOff = other.wOff;
}
//AIM: THIS FUNCTION IS USE to encrypt the string and create hask key using diff hash methods
public string FromString(string input, HashType hashtype)
{
Byte[] clearBytes;
Byte[] hashedBytes;
string output = String.Empty;
switch (hashtype)
{
case HashType.RIPEMD160:
clearBytes = new UTF8Encoding().GetBytes(input);
RIPEMD160 myRIPEMD160 = RIPEMD160Managed.Create();
hashedBytes = myRIPEMD160.ComputeHash(clearBytes);
output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
break;
case HashType.MD5:
clearBytes = new UTF8Encoding().GetBytes(input);
hashedBytes = ((HashAlgorithm)CryptoConfig.CreateFromName("MD5")).ComputeHash(clearBytes);
output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
break;
case HashType.SHA1:
clearBytes = Encoding.UTF8.GetBytes(input);
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
sha1.ComputeHash(clearBytes);
hashedBytes = sha1.Hash;
sha1.Clear();
output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
break;
case HashType.SHA256:
clearBytes = Encoding.UTF8.GetBytes(input);
SHA256 sha256 = new SHA256Managed();
sha256.ComputeHash(clearBytes);
hashedBytes =sha256.Hash;
sha256.Clear();
output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
break;
case HashType.SHA384:
clearBytes = Encoding.UTF8.GetBytes(input);
SHA384 sha384 = new SHA384Managed();
sha384.ComputeHash(clearBytes);
hashedBytes = sha384.Hash;
sha384.Clear();
output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
break;
case HashType.SHA512:
clearBytes = Encoding.UTF8.GetBytes(input);
SHA512 sha512 = new SHA512Managed();
sha512.ComputeHash(clearBytes);
hashedBytes = sha512.Hash;
sha512.Clear();
output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
break;
}
return output;
}
public static IHtmlString SRIResourceWithTags(this HtmlHelper helper, string linkWithTags)
{
if (_dictionary.ContainsKey(linkWithTags))
{
var foo = _dictionary[linkWithTags];
if (foo != "local")
{
return(new HtmlString(_dictionary[linkWithTags]));
}
else
{
return(new HtmlString(linkWithTags));
}
}
if (string.IsNullOrWhiteSpace(linkWithTags))
{
return(new HtmlString(string.Empty));
}
if (ConfigHelper.SriThrowIfUsed)
{
throw new Exception("SubResourceIntegrityHelper is in use for link: " + linkWithTags);
}
var filePath = ConfigHelper.SriFilePath;
if (filePath != null && !filePath.Contains(Path.DirectorySeparatorChar))
{
try
{
var p = helper.ViewContext.Controller.ControllerContext.HttpContext.Server.MapPath("/");
var localPath = Path.Combine(p, filePath);
if (!File.Exists(localPath))
{
filePath = null;
}
else
{
filePath = localPath;
}
}
catch (Exception)
{
try
{
var loc = typeof(SubResourceIntegrityHelper).Assembly.Location;
var p = Path.GetDirectoryName(loc);
var localPath = Path.Combine(p, filePath);
if (!File.Exists(localPath))
{
filePath = null;
}
else
{
filePath = localPath;
}
}
catch (Exception)
{
filePath = null;
}
}
}
if (filePath != null)
{
if (File.Exists(filePath))
{
var lines = File.ReadAllLines(filePath);
foreach (var line in lines)
{
if (!string.IsNullOrWhiteSpace(line) && line.Contains("\t"))
{
var parts = line.Split('\t');
if (parts.Length == 2)
{
if (!_dictionary.ContainsKey(parts[0]))
{
_dictionary.Add(parts[0], parts[1]);
}
}
}
}
}
else
{
try
{
if (filePath != null)
{
using (var fs = File.Create(filePath))
{
}
}
}
catch (Exception)
{
return(new HtmlString(
"<script src=\"CAN NOT WRITE TO SubResourceIntegrityHelper_FilePath\" />"));
}
}
if (_dictionary.ContainsKey(linkWithTags))
{
return(new HtmlString(_dictionary[linkWithTags]));
}
if (ConfigHelper.SriDownloadIfNotPresentInFile)
{
var r = Regex.Match(linkWithTags, ".*(<script|<link){1}.*(src=\"|href=\"){1}([^\"]*)(.*)",
RegexOptions.IgnoreCase);
if (r.Groups.Count == 5)
{
var isScript = string.Compare(r.Groups[1].Value, "<script",
StringComparison.InvariantCultureIgnoreCase) == 0;
var uriInLink = r.Groups[3].Value;
if (!string.IsNullOrWhiteSpace(uriInLink))
{
string uriToGet = null;
if (!(CultureInfo.CurrentCulture.CompareInfo.IndexOf(uriInLink, "integrity=\"", CompareOptions.IgnoreCase) >= 0))
{
bool isLocalUri = !uriInLink.StartsWith("http", true, CultureInfo.CurrentCulture);
if (isLocalUri)
{
var basePath = ConfigHelper.SriInsteadOfTilde;
if (string.IsNullOrWhiteSpace(basePath))
{
if (uriInLink.StartsWith("~"))
{
uriInLink = System.Web.VirtualPathUtility.ToAbsolute(uriInLink);
if (isScript)
{
return(SRIScriptLink(helper, uriInLink));
}
else
{
return(SRICssLink(helper, uriInLink));
}
}
if (!_dictionary.ContainsKey(linkWithTags))
{
_dictionary.Add(linkWithTags,
"local"); //vi undviker att spara till fil eftersom lokal sökväg inte bör existera annat än i utveckling
}
return(new HtmlString(linkWithTags));
}
if (uriInLink.StartsWith("~"))
{
uriInLink = uriInLink.Substring(1, uriInLink.Length - 1);
}
if (!basePath.EndsWith("/"))
{
basePath = basePath + "/";
}
if (uriInLink.StartsWith("/"))
{
uriInLink = uriInLink.Substring(1, uriInLink.Length - 1);
}
uriToGet = basePath + uriInLink;
}
else
{
uriToGet = uriInLink;
}
bool success = false;
byte[] bytes = null;
using (var client = new WebClient())
{
try
{
bytes = client.DownloadData(uriToGet);
success = true;
}
catch (Exception)
{
success = false;
}
}
if (success)
{
byte[] result = null;
using (SHA384 shaM = new SHA384Managed())
{
result = shaM.ComputeHash(bytes);
var hashBase64 = Convert.ToBase64String(result);
string pre, post;
if (linkWithTags.Contains("/>"))
{
var index = linkWithTags.LastIndexOf(">");
index = index - 1;
pre = linkWithTags.Substring(0, index);
post = "/>";
}
else
{
var index = linkWithTags.IndexOf(">");
pre = linkWithTags.Substring(0, index);
post = linkWithTags.Substring(index);
}
StringBuilder sb = new StringBuilder();
sb.Append(pre);
sb.Append(" ");
sb.Append("integrity=\"");
sb.Append("sha384-");
sb.Append(hashBase64);
sb.Append("\"");
if (!linkWithTags.Contains("crossorigin=\""))
{
sb.Append(" crossorigin=\"anonymous\"");
}
sb.Append(" ");
sb.Append(post);
var theNewLink = sb.ToString();
if (!_dictionary.ContainsKey(linkWithTags))
{
try
{
using (var fs = File.Open(filePath, FileMode.Append))
{
using (var sw = new StreamWriter(fs))
{
sw.WriteLine(linkWithTags + "\t" + theNewLink);
}
}
_dictionary.Add(linkWithTags, theNewLink);
}
catch (Exception)
{
return(new HtmlString(
"<script src=\"CAN NOT WRITE TO SubResourceIntegrityHelper_FilePath\" />"));
}
}
return(new HtmlString(theNewLink));
}
}
}
}
}
}
}
return(new HtmlString(linkWithTags));
}
public static string ComputeHash(string plainText, string hashAlgorithm, byte[] saltBytes)
{
// If salt is not specified, generate it.
if (saltBytes == null)
{
// Define min and max salt sizes.
int minSaltSize = 4;
int maxSaltSize = 8;
// Generate a random number for the size of the salt.
Random random = new Random();
int saltSize = random.Next(minSaltSize, maxSaltSize);
// Allocate a byte array, which will hold the salt.
saltBytes = new byte[saltSize];
// Initialize a random number generator.
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
// Fill the salt with cryptographically strong byte values.
rng.GetNonZeroBytes(saltBytes);
}
// Convert plain text into a byte array.
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
// Allocate array, which will hold plain text and salt.
byte[] plainTextWithSaltBytes =
new byte[plainTextBytes.Length + saltBytes.Length];
// Copy plain text bytes into resulting array.
for (int i = 0; i < plainTextBytes.Length; i++)
{
plainTextWithSaltBytes[i] = plainTextBytes[i];
}
// Append salt bytes to the resulting array.
for (int i = 0; i < saltBytes.Length; i++)
{
plainTextWithSaltBytes[plainTextBytes.Length + i] = saltBytes[i];
}
HashAlgorithm hash;
// Make sure hashing algorithm name is specified.
if (hashAlgorithm == null)
{
hashAlgorithm = "";
}
// Initialize appropriate hashing algorithm class.
switch (hashAlgorithm.ToUpper())
{
case "SHA384":
hash = new SHA384Managed();
break;
case "SHA512":
hash = new SHA512Managed();
break;
default:
hash = new MD5CryptoServiceProvider();
break;
}
// Compute hash value of our plain text with appended salt.
byte[] hashBytes = hash.ComputeHash(plainTextWithSaltBytes);
// Create array which will hold hash and original salt bytes.
byte[] hashWithSaltBytes = new byte[hashBytes.Length +
saltBytes.Length];
// Copy hash bytes into resulting array.
for (int i = 0; i < hashBytes.Length; i++)
{
hashWithSaltBytes[i] = hashBytes[i];
}
// Append salt bytes to the result.
for (int i = 0; i < saltBytes.Length; i++)
{
hashWithSaltBytes[hashBytes.Length + i] = saltBytes[i];
}
// Convert result into a base64-encoded string.
string hashValue = Convert.ToBase64String(hashWithSaltBytes);
// Return the result.
return(hashValue);
}
/// <summary>
/// Generates hash string for given value and algorith with encoding type
/// Supported Algorithm: SHA1, SHA256, SHA384, MD5 and SHA512
/// Supported Encoding Types: HEX and BASE_64
/// </summary>
/// <param name="Content">Content for hash</param>
/// <param name="algorithm">Supported Algorithm: SHA1, SHA256, SHA384, MD5 and SHA512</param>
/// <param name="et">Supported Encoding Types: HEX and BASE_64</param>
/// <returns>Generated hash</returns>
public static string GenerateHashString(string Content, Algorithm algorithm, EncodingType et)
{
string _content;
if (Content == null || Content.Equals(string.Empty))
{
throw new CryptographicException(ERR_NO_CONTENT);
}
HashAlgorithm hashAlgorithm = null;
switch (algorithm)
{
case Algorithm.SHA1:
hashAlgorithm = new SHA1CryptoServiceProvider();
break;
case Algorithm.SHA256:
hashAlgorithm = new SHA256Managed();
break;
case Algorithm.SHA384:
hashAlgorithm = new SHA384Managed();
break;
case Algorithm.SHA512:
hashAlgorithm = new SHA512Managed();
break;
case Algorithm.MD5:
hashAlgorithm = new MD5CryptoServiceProvider();
break;
default:
throw new CryptographicException(ERR_INVALID_PROVIDER);
}
try
{
byte[] hash = ComputeHash(hashAlgorithm, Content);
if (et == EncodingType.HEX)
{
_content = BytesToHex(hash);
}
else
{
_content = System.Convert.ToBase64String(hash);
}
hashAlgorithm.Clear();
return(_content);
}
catch (CryptographicException cge)
{
throw cge;
}
catch (Exception ex)
{
throw ex;
}
finally
{
hashAlgorithm.Clear();
}
}
/// <summary>
/// public override void GenerateKey(string secretKey, AlgorithmKeyType type)
/// </summary>
/// <param name="secretKey"></param>
/// <param name="type"></param>
public override void GenerateKey(string secretKey, AlgorithmKeyType type)
{
Key = new byte[24];
IV = new byte[8];
byte[] bKey = Encoding.UTF8.GetBytes(secretKey);
switch (type)
{
case AlgorithmKeyType.MD5: //16 byte
using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
{
md5.ComputeHash(bKey);
byte[] rmd5 = md5.Hash;
for (int i = 0; i < 16; i++)
{
Key[i] = rmd5[i];
}
for (int j = 15; j >= 8; j--)
{
IV[15 - j] = rmd5[j];
}
}
break;
case AlgorithmKeyType.SHA1: //20 byte
using (SHA1Managed sha1 = new SHA1Managed())
{
sha1.ComputeHash(bKey);
byte[] rsha1 = sha1.Hash;
for (int i = 0; i < 20; i++)
{
Key[i] = rsha1[i];
}
for (int j = 16; j > 8; j--)
{
IV[16 - j] = rsha1[j];
}
}
break;
case AlgorithmKeyType.SHA256: //32 byte
using (SHA256Managed sha256 = new SHA256Managed())
{
sha256.ComputeHash(bKey);
byte[] rsha256 = sha256.Hash;
for (int i = 0; i < 24; i++)
{
Key[i] = rsha256[i];
}
for (int j = 31; j >= 24; j--)
{
IV[31 - j] = rsha256[j];
}
}
break;
case AlgorithmKeyType.SHA384: //48 byte
using (SHA384Managed sha384 = new SHA384Managed())
{
sha384.ComputeHash(bKey);
byte[] rsha384 = sha384.Hash;
for (int i = 0; i < 24; i++)
{
Key[i] = rsha384[i];
}
for (int j = 47; j > 39; j--)
{
IV[47 - j] = rsha384[j];
}
}
break;
case AlgorithmKeyType.SHA512: //64 byte
using (SHA512Managed sha512 = new SHA512Managed())
{
sha512.ComputeHash(bKey);
byte[] rsha512 = sha512.Hash;
for (int i = 0; i < 24; i++)
{
Key[i] = rsha512[i];
}
for (int j = 63; j > 55; j--)
{
IV[63 - j] = rsha512[j];
}
}
break;
default:
break;
}
}
protected override void SetUp()
{
hash = new SHA384Managed();
}
public static string HashFile(string filepath, HashTypes hashtype = HashTypes.Md5)
{
if (File.Exists(filepath))
{
try
{
using (FileStream fs = new FileStream(filepath, FileMode.Open))
using (BufferedStream bs = new BufferedStream(fs))
{
switch (hashtype)
{
case HashTypes.Md5:
using (var md = MD5.Create())
{
var comp = md.ComputeHash(bs);
var hash = new StringBuilder();
foreach (byte b in comp)
{
hash.Append(b.ToString("X2"));
}
return(hash.ToString());
}
case HashTypes.Sha1:
using (SHA1Managed sha = new SHA1Managed())
{
var comp = sha.ComputeHash(bs);
var hash = new StringBuilder(comp.Length * 2);
foreach (byte b in comp)
{
hash.Append(b.ToString("X2"));
}
return(hash.ToString());
}
case HashTypes.Sha256:
using (SHA256Managed sha = new SHA256Managed())
{
var comp = sha.ComputeHash(bs);
var hash = new StringBuilder(comp.Length * 2);
foreach (byte b in comp)
{
hash.Append(b.ToString("X2"));
}
return(hash.ToString());
}
case HashTypes.Sha384:
using (SHA384Managed sha = new SHA384Managed())
{
var comp = sha.ComputeHash(bs);
var hash = new StringBuilder(comp.Length * 2);
foreach (byte b in comp)
{
hash.Append(b.ToString("X2"));
}
return(hash.ToString());
}
case HashTypes.Sha512:
using (SHA512Managed sha = new SHA512Managed())
{
var comp = sha.ComputeHash(bs);
var hash = new StringBuilder(comp.Length * 2);
foreach (byte b in comp)
{
hash.Append(b.ToString("X2"));
}
return(hash.ToString());
}
default:
return("hashError");
}
}
}
catch (Exception)
{
return("hashError");
}
}
return("fileNotFound");
}
private static string ComputeHash(string plainText,
string hashAlgorithm,
byte[] saltBytes)
{
if (saltBytes == null)
{
int minSaltSize = 4;
int maxSaltSize = 8;
Random random = new Random();
int saltSize = random.Next(minSaltSize, maxSaltSize);
saltBytes = new byte[saltSize];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetNonZeroBytes(saltBytes);
}
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
byte[] plainTextWithSaltBytes =
new byte[plainTextBytes.Length + saltBytes.Length];
for (int i = 0; i < plainTextBytes.Length; i++)
{
plainTextWithSaltBytes[i] = plainTextBytes[i];
}
for (int i = 0; i < saltBytes.Length; i++)
{
plainTextWithSaltBytes[plainTextBytes.Length + i] = saltBytes[i];
}
HashAlgorithm hash;
if (hashAlgorithm == null)
{
hashAlgorithm = "";
}
switch (hashAlgorithm.ToUpper())
{
case "SHA1":
hash = new SHA1Managed();
break;
case "SHA256":
hash = new SHA256Managed();
break;
case "SHA384":
hash = new SHA384Managed();
break;
case "SHA512":
hash = new SHA512Managed();
break;
default:
hash = new MD5CryptoServiceProvider();
break;
}
byte[] hashBytes = hash.ComputeHash(plainTextWithSaltBytes);
byte[] hashWithSaltBytes = new byte[hashBytes.Length +
saltBytes.Length];
for (int i = 0; i < hashBytes.Length; i++)
{
hashWithSaltBytes[i] = hashBytes[i];
}
for (int i = 0; i < saltBytes.Length; i++)
{
hashWithSaltBytes[hashBytes.Length + i] = saltBytes[i];
}
string hashValue = Convert.ToBase64String(hashWithSaltBytes);
return(hashValue);
}
/// <summary>
/// Hashes a byte array through SHA-384.
/// </summary>
/// <param name="input">The byte array for which to calculate the hash</param>
/// <returns>The SHA-384 digest.</returns>
public static byte[] SHA384(byte[] input)
{
using SHA384Managed sha384 = new SHA384Managed();
return(sha384.ComputeHash(input));
}
public string ComputeHash(string plaintext, string hashalgo, byte[] saltbyte)
{
if (saltbyte == null)
{
Random rand = new Random();
int saltsize = rand.Next(2, 10);
saltbyte = new byte[saltsize];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetNonZeroBytes(saltbyte);
}
byte[] plaintextbytes = Encoding.UTF8.GetBytes(plaintext);
byte[] plaintextsaltbytes = new byte[plaintextbytes.Length + saltbyte.Length];
for (int i = 0; i < plaintextbytes.Length; i++)
{
plaintextsaltbytes[i] = plaintextbytes[i];
}
for (int i = 0; i < saltbyte.Length; i++)
{
plaintextsaltbytes[i + plaintextbytes.Length] = saltbyte[i];
}
HashAlgorithm hash;
if (hashalgo == null)
{
hashalgo = "";
}
switch (hashalgo.ToUpper())
{
case "SHA1":
hash = new SHA1Managed();
break;
case "SHA256":
hash = new SHA256Managed();
break;
case "SHA384":
hash = new SHA384Managed();
break;
case "SHA512":
hash = new SHA512Managed();
break;
default:
hash = new MD5CryptoServiceProvider();
break;
}
byte[] hashbytes = hash.ComputeHash(plaintextsaltbytes);
byte[] hashWithSaltBytes = new byte[hashbytes.Length +
saltbyte.Length];
for (int i = 0; i < hashbytes.Length; i++)
{
hashWithSaltBytes[i] = hashbytes[i];
}
for (int i = 0; i < saltbyte.Length; i++)
{
hashWithSaltBytes[hashbytes.Length + i] = saltbyte[i];
}
string hashValue = Convert.ToBase64String(hashWithSaltBytes);
return(hashValue);
}
/// <summary>
/// Calculates the hash of a data using SHA hash algorithm.
/// </summary>
/// <param name="data">The data to hash.</param>
/// <param name="offset">The offset.</param>
/// <param name="length">The length.</param>
/// <param name="hashSize">Size of the hash.</param>
/// <returns>
/// Calculated hash
/// </returns>
private static byte[] CalculateHashSha(this byte[] data, int offset, int length, int hashSize)
{
data.CannotBeNullOrEmpty();
offset.MustBeGreaterThanOrEqualTo(0);
length.MustBeGreaterThanOrEqualTo(0);
hashSize.MustBeOneOf(128, 256, 384, 512);
byte[] hashRaw = null;
if (data != null)
{
if (hashSize == 128)
{
#pragma warning disable CA5350 // Do not use insecure cryptographic algorithm SHA1.
using (HashAlgorithm sha = new SHA1CryptoServiceProvider())
#pragma warning restore CA5350 // Do not use insecure cryptographic algorithm SHA1.
{
hashRaw = CalculateHash(data, offset, length, sha);
}
}
else if (hashSize == 256)
{
try
{
using (HashAlgorithm sha = new SHA256CryptoServiceProvider())
{
hashRaw = CalculateHash(data, offset, length, sha);
}
}
catch (PlatformNotSupportedException)
{
// Fall back to the managed version if the CSP
// is not supported on this platform.
using (HashAlgorithm sha = new SHA256Managed())
{
hashRaw = CalculateHash(data, offset, length, sha);
}
}
}
else if (hashSize == 384)
{
try
{
using (HashAlgorithm sha = new SHA384CryptoServiceProvider())
{
hashRaw = CalculateHash(data, offset, length, sha);
}
}
catch (PlatformNotSupportedException)
{
// Fall back to the managed version if the CSP
// is not supported on this platform.
using (HashAlgorithm sha = new SHA384Managed())
{
hashRaw = CalculateHash(data, offset, length, sha);
}
}
}
else if (hashSize == 512)
{
try
{
using (HashAlgorithm sha = new SHA512CryptoServiceProvider())
{
hashRaw = CalculateHash(data, offset, length, sha);
}
}
catch (PlatformNotSupportedException)
{
// Fall back to the managed version if the CSP
// is not supported on this platform.
using (HashAlgorithm sha = new SHA512Managed())
{
hashRaw = CalculateHash(data, offset, length, sha);
}
}
}
}
return hashRaw;
}
/// <summary>
/// Validates the signature using the public part of the asymmetric key given as parameter.
/// </summary>
/// <param name="key">The key.</param>
/// <returns><code>true</code> if the signature is present and can be verified using the given key.
/// <code>false</code> if the signature is present, but can't be verified using the given key.</returns>
/// <exception cref="InvalidOperationException">If the query is not signed, and therefore cannot have its signature verified. Use
/// the <code>IsSigned</code> property to check for this situation before calling this method.</exception>
public bool CheckSignature(AsymmetricAlgorithm key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
if (!(key is DSA || key is RSACryptoServiceProvider))
{
throw new ArgumentException("The key must be an instance of either DSA or RSACryptoServiceProvider.");
}
if (!IsSigned)
{
throw new InvalidOperationException("Query is not signed, so there is no signature to verify.");
}
byte[] hash = null;
string algorithm = null;
var toSign = Encoding.UTF8.GetBytes(_signedquery);
switch (SignatureAlgorithm)
{
case SignedXml.XmlDsigRSASHA1Url:
case SignedXml.XmlDsigDSAUrl:
hash = new SHA1Managed().ComputeHash(toSign);
algorithm = "SHA1";
break;
case "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256":
hash = new SHA256Managed().ComputeHash(toSign);
algorithm = "SHA256";
break;
case "http://www.w3.org/2001/04/xmldsig-more#rsa-sha384":
hash = new SHA384Managed().ComputeHash(toSign);
algorithm = "SHA384";
break;
case "http://www.w3.org/2001/04/xmldsig-more#rsa-sha512":
hash = new SHA512Managed().ComputeHash(toSign);
algorithm = "SHA512";
break;
default:
hash = new SHA256Managed().ComputeHash(toSign);
algorithm = "SHA256";
break;
}
if (key is RSACryptoServiceProvider)
{
RSACryptoServiceProvider rsaClear = new RSACryptoServiceProvider();
rsaClear.ImportParameters(((RSACryptoServiceProvider)key).ExportParameters(false));
return(rsaClear.VerifyHash(hash, algorithm, DecodeSignature()));
}
else
{
var dsa = (DSA)key;
return(dsa.VerifySignature(hash, DecodeSignature()));
}
}
// Konstruktor initierar de tre objekt i klassen
public HashGenerator()
{
sha256 = new SHA256Managed();
sha384 = new SHA384Managed();
sha512 = new SHA512Managed();
}
public SHA384Hash()
{
_objHashObject = new SHA384Managed();
}
public static string ComputeHash(string plainText, Supported_HA hash, byte[] salt)
{
int minSaltLength = 4, maxSaltLength = 16;
byte[] saltBytes = null;
if (salt != null)
{
saltBytes = salt;
}
else
{
saltBytes = SALT_BYTES;
}
byte[] plainData = ASCIIEncoding.UTF8.GetBytes(plainText);
byte[] plainDataWithSalt = new byte[plainData.Length + saltBytes.Length];
for (int x = 0; x < plainData.Length; x++)
{
plainDataWithSalt[x] = plainData[x];
}
for (int n = 0; n < saltBytes.Length; n++)
{
plainDataWithSalt[plainData.Length + n] = saltBytes[n];
}
byte[] hashValue = null;
switch (hash)
{
case Supported_HA.SHA256:
SHA256Managed sha = new SHA256Managed();
hashValue = sha.ComputeHash(plainDataWithSalt);
sha.Dispose();
break;
case Supported_HA.SHA384:
SHA384Managed sha1 = new SHA384Managed();
hashValue = sha1.ComputeHash(plainDataWithSalt);
sha1.Dispose();
break;
case Supported_HA.SHA512:
SHA512Managed sha2 = new SHA512Managed();
hashValue = sha2.ComputeHash(plainDataWithSalt);
sha2.Dispose();
break;
}
byte[] result = new byte[hashValue.Length + saltBytes.Length];
for (int x = 0; x < hashValue.Length; x++)
{
result[x] = hashValue[x];
}
for (int n = 0; n < saltBytes.Length; n++)
{
result[hashValue.Length + n] = saltBytes[n];
}
return(Convert.ToBase64String(result));
}
public static string Hash(HashType hashAlgorithm, string text, byte[] salt)
{
int index;
// Convert plain text into a byte array.
byte[] textBytes = Encoding.UTF8.GetBytes(text);
// Allocate array, which will hold plain text and salt.
byte[] textWithSalt = new byte[textBytes.Length + salt.Length];
// Copy plain text bytes into resulting array.
for (index = 0; index < textBytes.Length; index++)
{
textWithSalt[index] = textBytes[index];
}
// Append salt bytes to the resulting array.
for (index = 0; index < salt.Length; index++)
{
textWithSalt[textBytes.Length + index] = salt[index];
}
// Because we support multiple hashing algorithms, we must define
// hash object as a common (abstract) base class. We will specify the
// actual hashing algorithm class later during object creation.
HashAlgorithm hash;
// Initialize appropriate hashing algorithm class.
switch (hashAlgorithm)
{
case HashType.SHA1:
hash = new SHA1Managed();
break;
case HashType.SHA256:
hash = new SHA256Managed();
break;
case HashType.SHA384:
hash = new SHA384Managed();
break;
case HashType.SHA512:
hash = new SHA512Managed();
break;
default:
hash = new MD5CryptoServiceProvider();
break;
}
// Compute hash value of our plain text with appended salt.
byte[] hashBytes = hash.ComputeHash(textWithSalt);
// Create array which will hold hash and original salt bytes.
byte[] hashWithsalt = new byte[hashBytes.Length + salt.Length];
// Copy hash bytes into resulting array.
for (index = 0; index < hashBytes.Length; index++)
{
hashWithsalt[index] = hashBytes[index];
}
// Append salt bytes to the result.
for (index = 0; index < salt.Length; index++)
{
hashWithsalt[hashBytes.Length + index] = salt[index];
}
// Convert result into a base64-encoded string.
return(Encoding.Unicode.GetString(hashBytes) + Encoding.Unicode.GetString(salt));
}
public IList <byte> ComputeHashToBytes(string value)
{
HashAlgorithm sHA1Managed;
IList <byte> nums;
var nums1 = new List <byte>(Encoding.Unicode.GetBytes(value));
switch (HashSize)
{
case EnumHashSize.SHA1:
case EnumHashSize.FOLD32:
case EnumHashSize.FOLD16:
{
sHA1Managed = new SHA1Managed();
break;
}
case EnumHashSize.SHA256:
{
sHA1Managed = new SHA256Managed();
break;
}
case EnumHashSize.SHA384:
{
sHA1Managed = new SHA384Managed();
break;
}
case EnumHashSize.SHA512:
{
sHA1Managed = new SHA512Managed();
break;
}
default:
{
throw new NotImplementedException();
}
}
using (sHA1Managed)
{
var nums2 = new List <byte>(sHA1Managed.ComputeHash(nums1.ToArray()));
int item;
switch (HashSize)
{
case EnumHashSize.FOLD32:
{
for (var i = 0; i < 4; i++)
{
item = 0;
for (var j = 0; j < 5; j++)
{
item = item + nums2[j * 4 + i];
}
nums2[i] = (byte)(item % 256);
}
nums2.RemoveRange(4, nums2.Count - 4);
break;
}
case EnumHashSize.FOLD16:
{
for (var k = 0; k < 2; k++)
{
item = 0;
for (var l = 0; l < 10; l++)
{
item = item + nums2[l * 2 + k];
}
nums2[k] = (byte)(item % 256);
}
nums2.RemoveRange(2, nums2.Count - 2);
break;
}
}
nums = nums2;
}
return(nums);
}
private byte[] ComputeHash(string password, byte[] passwordSalt)
{
// Convert plain text into a byte array.
byte[] passwordBytes = Encoding.UTF8.GetBytes(password);
// Allocate array, which will hold plain text and salt.
byte[] passwordWithSaltBytes =
new byte[passwordBytes.Length + passwordSalt.Length];
// Copy plain text bytes into resulting array.
for (int i = 0; i < passwordBytes.Length; i++)
{
passwordWithSaltBytes[i] = passwordBytes[i];
}
// Append salt bytes to the resulting array.
for (int i = 0; i < passwordSalt.Length; i++)
{
passwordWithSaltBytes[passwordBytes.Length + i] = passwordSalt[i];
}
// Because we support multiple hashing algorithms, we must define
// hash object as a common (abstract) base class. We will specify the
// actual hashing algorithm class later during object creation.
HashAlgorithm hash;
// Initialize appropriate hashing algorithm class.
switch (hashAlgorithm.ToUpper())
{
case "SHA1":
hash = new SHA1Managed();
break;
case "SHA256":
hash = new SHA256Managed();
break;
case "SHA384":
hash = new SHA384Managed();
break;
case "SHA512":
hash = new SHA512Managed();
break;
default:
hash = new MD5CryptoServiceProvider();
break;
}
// Compute hash value of our plain text with appended salt.
byte[] hashBytes = hash.ComputeHash(passwordWithSaltBytes);
// Create array which will hold hash and original salt bytes.
byte[] passwordHash = new byte[hashBytes.Length +
passwordSalt.Length];
// Copy hash bytes into resulting array.
for (int i = 0; i < hashBytes.Length; i++)
{
passwordHash[i] = hashBytes[i];
}
// Append salt bytes to the result.
for (int i = 0; i < passwordSalt.Length; i++)
{
passwordHash[hashBytes.Length + i] = passwordSalt[i];
}
// Convert result into a base64-encoded string.
return(passwordHash);
}
public static string ComputeHash(string plainText, Supported_HA hash, byte[] salt)
{
int minSaltLength = 4;
int maxSaltLength = 16;
byte[] SaltBytes = null;
if (salt != null)
{
SaltBytes = salt;
}
else
{
Random r = new Random();
int SaltLength = r.Next(minSaltLength, maxSaltLength);
SaltBytes = new byte[SaltLength];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetNonZeroBytes(SaltBytes);
rng.Dispose();
}
byte[] plainData = ASCIIEncoding.UTF8.GetBytes(plainText);
byte[] plainDataAndSalt = new byte[plainData.Length + SaltBytes.Length];
for (int x = 0; x < plainData.Length; x++)
{
plainDataAndSalt[x] = plainData[x];
}
for (int n = 0; n < SaltBytes.Length; n++)
{
plainDataAndSalt[plainData.Length + n] = SaltBytes[n];
}
byte[] hashValue = null;
switch (hash)
{
case Supported_HA.SHA256:
SHA256Managed sha256 = new SHA256Managed();
hashValue = sha256.ComputeHash(plainDataAndSalt);
sha256.Dispose();
break;
case Supported_HA.SHA384:
SHA384Managed sha384 = new SHA384Managed();
hashValue = sha384.ComputeHash(plainDataAndSalt);
sha384.Dispose();
break;
case Supported_HA.SHA512:
SHA512Managed sha512 = new SHA512Managed();
hashValue = sha512.ComputeHash(plainDataAndSalt);
sha512.Dispose();
break;
}
byte[] result = new byte[hashValue.Length + SaltBytes.Length];
for (int i = 0; i < hashValue.Length; i++)
{
result[i] = hashValue[i];
}
for (int j = 0; j < SaltBytes.Length; j++)
{
result[hashValue.Length + j] = SaltBytes[j];
}
return(Convert.ToBase64String(result));
}
public static string HashSHA384(this byte[] Data)
{
using (var SHA384 = new SHA384Managed())
return(SHA384.ComputeHash(Data).GetText());
}
public static string HashString(string content, HashTypes hashtype = HashTypes.Md5)
{
try
{
switch (hashtype)
{
case HashTypes.Md5:
using (var md = MD5.Create())
{
var comp = md.ComputeHash(Encoding.UTF8.GetBytes(content));
StringBuilder hash = new StringBuilder();
foreach (byte b in comp)
{
hash.Append(b.ToString("X2"));
}
return(hash.ToString());
}
case HashTypes.Sha1:
using (SHA1Managed sha = new SHA1Managed())
{
var comp = sha.ComputeHash(Encoding.UTF8.GetBytes(content));
var hash = new StringBuilder(comp.Length * 2);
foreach (byte b in comp)
{
hash.Append(b.ToString("X2"));
}
return(hash.ToString());
}
case HashTypes.Sha256:
using (SHA256Managed sha = new SHA256Managed())
{
var comp = sha.ComputeHash(Encoding.UTF8.GetBytes(content));
var hash = new StringBuilder(comp.Length * 2);
foreach (byte b in comp)
{
hash.Append(b.ToString("X2"));
}
return(hash.ToString());
}
case HashTypes.Sha384:
{
using (SHA384Managed sha = new SHA384Managed())
{
var comp = sha.ComputeHash(Encoding.UTF8.GetBytes(content));
var hash = new StringBuilder(comp.Length * 2);
foreach (byte b in comp)
{
hash.Append(b.ToString("X2"));
}
return(hash.ToString());
}
}
case HashTypes.Sha512:
using (SHA512Managed sha = new SHA512Managed())
{
var comp = sha.ComputeHash(Encoding.UTF8.GetBytes(content));
var hash = new StringBuilder(comp.Length * 2);
foreach (byte b in comp)
{
hash.Append(b.ToString("X2"));
}
return(hash.ToString());
}
default:
return("hashError");
}
}
catch (Exception)
{
return("hashError");
}
}
public static string ComputeHash(string plainText,
string hashAlgorithm,
string salt)
{
byte[] saltBytes = Convert.FromBase64String(salt);
// Convert plain text into a byte array.
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
// Allocate array, which will hold plain text and salt.
byte[] plainTextWithSaltBytes =
new byte[plainTextBytes.Length + saltBytes.Length];
// Copy plain text bytes into resulting array.
for (int i = 0; i < plainTextBytes.Length; i++)
{
plainTextWithSaltBytes[i] = plainTextBytes[i];
}
// Append salt bytes to the resulting array.
for (int i = 0; i < saltBytes.Length; i++)
{
plainTextWithSaltBytes[plainTextBytes.Length + i] = saltBytes[i];
}
// Because we support multiple hashing algorithms, we must define
// hash object as a common (abstract) base class. We will specify the
// actual hashing algorithm class later during object creation.
HashAlgorithm hash;
// Make sure hashing algorithm name is specified.
if (hashAlgorithm == null)
{
hashAlgorithm = "";
}
// Initialize appropriate hashing algorithm class.
switch (hashAlgorithm.ToUpper())
{
case "SHA1":
hash = new SHA1Managed();
break;
case "SHA256":
hash = new SHA256Managed();
break;
case "SHA384":
hash = new SHA384Managed();
break;
case "SHA512":
hash = new SHA512Managed();
break;
default:
hash = new MD5CryptoServiceProvider();
break;
}
// Compute hash value of our plain text with appended salt.
byte[] hashBytes = hash.ComputeHash(plainTextWithSaltBytes);
// Create array which will hold hash and original salt bytes.
byte[] hashWithSaltBytes = new byte[hashBytes.Length +
saltBytes.Length];
// Copy hash bytes into resulting array.
for (int i = 0; i < hashBytes.Length; i++)
{
hashWithSaltBytes[i] = hashBytes[i];
}
// Append salt bytes to the result.
for (int i = 0; i < saltBytes.Length; i++)
{
hashWithSaltBytes[hashBytes.Length + i] = saltBytes[i];
}
// Convert result into a base64-encoded string.
string hashValue = Convert.ToBase64String(hashWithSaltBytes);
// Return the result.
return(hashValue);
}
/// <summary>
/// Generates a hash for the given plain text value and returns a
/// base64-encoded result. Before the hash is computed, a random salt
/// is generated and appended to the plain text. This salt is stored at
/// the end of the hash value, so it can be used later for hash
/// verification.
/// </summary>
/// <param name="plainText">
/// Plaintext value to be hashed. The function does not check whether
/// this parameter is null.
/// </param>
/// <param name="hashAlgorithm">
/// Name of the hash algorithm. Allowed values are: "MD5", "SHA1",
/// "SHA256", "SHA384", and "SHA512" (if any other value is specified
/// MD5 hashing algorithm will be used). This value is case-insensitive.
/// </param>
/// <param name="saltBytes">
/// Salt bytes. This parameter can be null, in which case a random salt
/// value will be generated.
/// </param>
/// <returns>
/// Hash value formatted as a base64-encoded string.
/// </returns>
public static string ComputeHash(string plainText,
HashingAlgorithm hashAlgorithm,
byte[] saltBytes)
{
// If salt is not specified, generate it on the fly.
if (saltBytes == null)
{
// Define min and max salt sizes.
int minSaltSize = 4;
int maxSaltSize = 8;
// Generate a random number for the size of the salt.
Random random = new Random();
int saltSize = random.Next(minSaltSize, maxSaltSize);
// Allocate a byte array, which will hold the salt.
saltBytes = new byte[saltSize];
// Initialize a random number generator.
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
// Fill the salt with cryptographically strong byte values.
rng.GetNonZeroBytes(saltBytes);
}
// Convert plain text into a byte array.
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
// Allocate array, which will hold plain text and salt.
byte[] plainTextWithSaltBytes =
new byte[plainTextBytes.Length + saltBytes.Length];
// Copy plain text bytes into resulting array.
for (int i = 0; i < plainTextBytes.Length; i++)
{
plainTextWithSaltBytes[i] = plainTextBytes[i];
}
// Append salt bytes to the resulting array.
for (int i = 0; i < saltBytes.Length; i++)
{
plainTextWithSaltBytes[plainTextBytes.Length + i] = saltBytes[i];
}
// Because we support multiple hashing algorithms, we must define
// hash object as a common (abstract) base class. We will specify the
// actual hashing algorithm class later during object creation.
HashAlgorithm hash;
// Initialize appropriate hashing algorithm class.
switch (hashAlgorithm)
{
case HashingAlgorithm.SHA1:
hash = new SHA1Managed();
break;
case HashingAlgorithm.SHA256:
hash = new SHA256Managed();
break;
case HashingAlgorithm.SHA384:
hash = new SHA384Managed();
break;
case HashingAlgorithm.SHA512:
hash = new SHA512Managed();
break;
default:
hash = new MD5CryptoServiceProvider();
break;
}
// Compute hash value of our plain text with appended salt.
byte[] hashBytes = hash.ComputeHash(plainTextWithSaltBytes);
// Create array which will hold hash and original salt bytes.
byte[] hashWithSaltBytes = new byte[hashBytes.Length +
saltBytes.Length];
// Copy hash bytes into resulting array.
for (int i = 0; i < hashBytes.Length; i++)
{
hashWithSaltBytes[i] = hashBytes[i];
}
// Append salt bytes to the result.
for (int i = 0; i < saltBytes.Length; i++)
{
hashWithSaltBytes[hashBytes.Length + i] = saltBytes[i];
}
// Convert result into a base64-encoded string.
string hashValue = Convert.ToBase64String(hashWithSaltBytes);
// Return the result.
return(hashValue);
}
/// <summary>
/// Generates a hash for the given plain text value and returns a
/// base64-encoded result. Before the hash is computed, a random salt
/// is generated and appended to the plain text. This salt is stored at
/// the end of the hash value, so it can be used later for hash
/// verification.
/// </summary>
/// <param name="plainText">
/// Plaintext value to be hashed.
/// </param>
/// <param name="hashAlgorithm">
/// Name of the hash algorithm. Allowed values are: "MD5", "SHA1",
/// "SHA256", "SHA384", and "SHA512" (if any other value is specified
/// MD5 hashing algorithm will be used). This value is case-insensitive.
/// </param>
/// <param name="saltBytes">
/// Optinoal salt bytes to apply to the hash. If not passed the
/// raw encoding is used.
/// </param>
/// <returns>
/// Hash value formatted as a base64-encoded string.
/// </returns>
public static string ComputeHash(string plainText,
string hashAlgorithm,
byte[] saltBytes,
bool useBinHex = false)
{
if (string.IsNullOrEmpty(plainText))
{
return(plainText);
}
// Convert plain text into a byte array.
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
byte[] plainTextWithSaltBytes;
if (saltBytes != null)
{
// Allocate array, which will hold plain text and salt.
plainTextWithSaltBytes =
new byte[plainTextBytes.Length + saltBytes.Length];
// Copy plain text bytes into resulting array.
for (int i = 0; i < plainTextBytes.Length; i++)
{
plainTextWithSaltBytes[i] = plainTextBytes[i];
}
// Append salt bytes to the resulting array.
for (int i = 0; i < saltBytes.Length; i++)
{
plainTextWithSaltBytes[plainTextBytes.Length + i] = saltBytes[i];
}
}
else
{
plainTextWithSaltBytes = plainTextBytes;
}
HashAlgorithm hash;
// Make sure hashing algorithm name is specified.
if (hashAlgorithm == null)
{
hashAlgorithm = "";
}
// Initialize appropriate hashing algorithm class.
switch (hashAlgorithm.ToUpper())
{
case "SHA1":
hash = new SHA1Managed();
break;
case "SHA256":
hash = new SHA256Managed();
break;
case "SHA384":
hash = new SHA384Managed();
break;
case "SHA512":
hash = new SHA512Managed();
break;
default:
// default to MD5
hash = new MD5CryptoServiceProvider();
break;
}
byte[] hashBytes = hash.ComputeHash(plainTextWithSaltBytes);
if (useBinHex)
{
return(BinaryToBinHex(hashBytes));
}
return(Convert.ToBase64String(hashBytes));
}
public override void SetUp()
{
hash = new SHA384Managed();
}
public static string ComputeHash(string plainText, string hashAlgorithm, byte[] saltBytes)
{
if (saltBytes == null)
{
int minSaltSize = 4;
int maxSaltSize = 8;
Random random = new Random();
int saltSize = random.Next(minSaltSize, maxSaltSize);
saltBytes = new byte[saltSize];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetNonZeroBytes(saltBytes);
}
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
byte[] plainTextWithSaltBytes = new byte[plainTextBytes.Length + saltBytes.Length];
for (int i = 0; i < plainTextBytes.Length; i++)
plainTextWithSaltBytes[i] = plainTextBytes[i];
for (int i = 0; i < saltBytes.Length; i++)
plainTextWithSaltBytes[plainTextBytes.Length + i] = saltBytes[i];
HashAlgorithm hash;
if (hashAlgorithm == null)
hashAlgorithm = "";
switch (hashAlgorithm.ToUpper())
{
case "SHA1":
hash = new SHA1Managed();
break;
case "SHA256":
hash = new SHA256Managed();
break;
case "SHA384":
hash = new SHA384Managed();
break;
case "SHA512":
hash = new SHA512Managed();
break;
default:
hash = new MD5CryptoServiceProvider();
break;
}
byte[] hashBytes = hash.ComputeHash(plainTextWithSaltBytes);
byte[] hashWithSaltBytes = new byte[hashBytes.Length + saltBytes.Length];
for (int i = 0; i < hashBytes.Length; i++)
hashWithSaltBytes[i] = hashBytes[i];
for (int i = 0; i < saltBytes.Length; i++)
hashWithSaltBytes[hashBytes.Length + i] = saltBytes[i];
string hashValue = Convert.ToBase64String(hashWithSaltBytes);
return hashValue;
}
public static byte[] Sha384(byte[] data)
{
SHA384 sha = new SHA384Managed();
return(sha.ComputeHash(data));
}
byte[] IHashAlgorithm.GetRunningHash ()
{
var copy = new SHA384Managed (this);
copy.TransformFinalBlock (empty, 0, 0);
return copy.Hash;
}
/// <summary>
/// 获取Hash后的字节数组
/// </summary>
/// <param name="type">哈希类型</param>
/// <param name="key">key</param>
/// <param name="bytes">原字节数组</param>
/// <returns></returns>
public static byte[] GetHashedBytes(HashType type, byte[] bytes, byte[] key)
{
if (null == bytes || bytes.Length == 0)
{
return(bytes);
}
HashAlgorithm algorithm = null;
try
{
if (key == null)
{
switch (type)
{
case HashType.MD5:
algorithm = MD5.Create();
break;
case HashType.SHA1:
algorithm = new SHA1Managed();
break;
case HashType.SHA256:
algorithm = new SHA256Managed();
break;
case HashType.SHA384:
algorithm = new SHA384Managed();
break;
case HashType.SHA512:
algorithm = new SHA512Managed();
break;
default:
algorithm = MD5.Create();
break;
}
}
else
{
switch (type)
{
case HashType.MD5:
algorithm = new HMACMD5(key);
break;
case HashType.SHA1:
algorithm = new HMACSHA1(key);
break;
case HashType.SHA256:
algorithm = new HMACSHA256(key);
break;
case HashType.SHA384:
algorithm = new HMACSHA384(key);
break;
case HashType.SHA512:
algorithm = new HMACSHA512(key);
break;
default:
algorithm = new HMACMD5(key);
break;
}
}
return(algorithm.ComputeHash(bytes));
}
finally
{
algorithm?.Dispose();
}
}
public static string ComputeHash(string plainText, string hash, byte[] salt)
{
int minSaltLength = 4, maxSaltLength = 16;
byte[] saltBytes = null;
if (salt != null)
{
saltBytes = salt;
}
else
{
Random r = new Random();
int SaltLength = r.Next(minSaltLength, maxSaltLength);
saltBytes = new byte[SaltLength];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetNonZeroBytes(saltBytes);
rng.Dispose();
}
byte[] plainData = ASCIIEncoding.UTF8.GetBytes(plainText);
byte[] plainDataWithSalt = new byte[plainData.Length + saltBytes.Length];
for (int x = 0; x < plainData.Length; x++)
{
plainDataWithSalt[x] = plainData[x];
}
for (int n = 0; n < saltBytes.Length; n++)
{
plainDataWithSalt[plainData.Length + n] = saltBytes[n];
}
byte[] hashValue = null;
switch (hash)
{
case "SHA256":
SHA256Managed sha = new SHA256Managed();
hashValue = sha.ComputeHash(plainDataWithSalt);
sha.Dispose();
break;
case "SHA384":
SHA384Managed sha1 = new SHA384Managed();
hashValue = sha1.ComputeHash(plainDataWithSalt);
sha1.Dispose();
break;
case "SHA512":
SHA512Managed sha2 = new SHA512Managed();
hashValue = sha2.ComputeHash(plainDataWithSalt);
sha2.Dispose();
break;
}
byte[] result = new byte[hashValue.Length + saltBytes.Length];
for (int x = 0; x < hashValue.Length; x++)
{
result[x] = hashValue[x];
}
for (int n = 0; n < saltBytes.Length; n++)
{
result[hashValue.Length + n] = saltBytes[n];
}
return(Convert.ToBase64String(result));
}
/// <summary>
/// Generates a hash for the given plain text value and returns a
/// base64-encoded result. Before the hash is computed, a random salt
/// is generated and appended to the plain text. This salt is stored at
/// the end of the hash value, so it can be used later for hash
/// verification.
/// </summary>
/// <param name="byteData">
/// Plaintext value to be hashed.
/// </param>
/// <param name="hashAlgorithm">
/// Name of the hash algorithm. Allowed values are: "MD5", "SHA1",
/// "SHA256", "SHA384", "SHA512", "HMACMD5", "HMACSHA1", "HMACSHA256",
/// "HMACSHA512" (if any other value is specified MD5 will be used).
///
/// HMAC algorithms uses Hash-based Message Authentication Code.
/// The HMAC process mixes a secret key with the message data, hashes
/// the result with the hash function, mixes that hash value with
/// the secret key again, and then applies the hash function
/// a second time. HMAC hashes are fixed lenght and generally
/// much longer than non-HMAC hashes of the same type.
///
/// https://msdn.microsoft.com/en-us/library/system.security.cryptography.hmacsha256(v=vs.110).aspx
///
/// This value is case-insensitive.
/// </param>
/// <param name="saltBytes">
/// Optional but recommended salt bytes to apply to the hash. If not passed the
/// raw encoding is used. If salt is nullthe raw algorithm is used (useful for
/// file hashes etc.) HMAC versions REQUIRE that salt is passed.
/// </param>
/// <param name="useBinHex">if true returns the data as BinHex byte pair string. Otherwise Base64 is returned.</param>
/// <returns>
/// Hash value formatted as a base64-encoded or BinHex stringstring.
/// </returns>
public static string ComputeHash(byte[] byteData,
string hashAlgorithm,
byte[] saltBytes,
bool useBinHex = false)
{
if (byteData == null)
{
return(null);
}
// Convert plain text into a byte array.
byte[] plainTextWithSaltBytes;
if (saltBytes != null && !hashAlgorithm.StartsWith("HMAC"))
{
// Allocate array, which will hold plain text and salt.
plainTextWithSaltBytes =
new byte[byteData.Length + saltBytes.Length];
// Copy plain text bytes into resulting array.
for (int i = 0; i < byteData.Length; i++)
{
plainTextWithSaltBytes[i] = byteData[i];
}
// Append salt bytes to the resulting array.
for (int i = 0; i < saltBytes.Length; i++)
{
plainTextWithSaltBytes[byteData.Length + i] = saltBytes[i];
}
}
else
{
plainTextWithSaltBytes = byteData;
}
HashAlgorithm hash;
// Make sure hashing algorithm name is specified.
if (hashAlgorithm == null)
{
hashAlgorithm = "";
}
// Initialize appropriate hashing algorithm class.
switch (hashAlgorithm.ToUpper())
{
case "SHA1":
hash = new SHA1Managed();
break;
case "SHA256":
hash = new SHA256Managed();
break;
case "SHA384":
hash = new SHA384Managed();
break;
case "SHA512":
hash = new SHA512Managed();
break;
case "HMACMD5":
hash = new HMACMD5(saltBytes);
break;
case "HMACSHA1":
hash = new HMACSHA1(saltBytes);
break;
case "HMACSHA256":
hash = new HMACSHA256(saltBytes);
break;
case "HMACSHA512":
hash = new HMACSHA512(saltBytes);
break;
default:
// default to MD5
hash = new MD5CryptoServiceProvider();
break;
}
byte[] hashBytes = hash.ComputeHash(plainTextWithSaltBytes);
hash.Dispose();
if (useBinHex)
{
return(BinaryToBinHex(hashBytes));
}
return(Convert.ToBase64String(hashBytes));
}
/// <summary>
/// Concatenate a set of blobs - specified either via their prefix or an explicit list of blob names - to a single destination blob
/// Source blobs must be from a single container. However because of the way the Azure Storage Block Blob works, you can call
/// this function multiple times, specifying different sets of source blobs each time, and they will simply be "appended" to the destination blob.
/// </summary>
/// <param name="sourceStorageAccountName"></param>
/// <param name="sourceStorageContainerName"></param>
/// <param name="sourceStorageAccountKey"></param>
/// <param name="sourceBlobPrefix"></param>
/// <param name="sortBlobs"></param>
/// <param name="sourceBlobNames"></param>
/// <param name="destStorageAccountName"></param>
/// <param name="destStorageAccountKey"></param>
/// <param name="destStorageContainerName"></param>
/// <param name="destBlobName"></param>
public static bool BlobToBlob(string sourceStorageAccountName,
string sourceStorageContainerName,
string sourceStorageAccountKey,
string sourceBlobPrefix,
bool sortBlobs,
List <string> sourceBlobNames,
string destStorageAccountName,
string destStorageAccountKey,
string destStorageContainerName,
string destBlobName)
{
// this will be used to compute a unique blockId for the source blocks
var shaHasher = new SHA384Managed();
GlobalOptimizations();
// TODO remove hard-coding of core.windows.net
string sourceAzureStorageConnStr = $"DefaultEndpointsProtocol=https;AccountName={sourceStorageAccountName};AccountKey={sourceStorageAccountKey};EndpointSuffix=core.windows.net";
string destAzureStorageConnStr = $"DefaultEndpointsProtocol=https;AccountName={destStorageAccountName};AccountKey={destStorageAccountKey};EndpointSuffix=core.windows.net";
var destStorageAccount = CloudStorageAccount.Parse(destAzureStorageConnStr);
var destBlobClient = destStorageAccount.CreateCloudBlobClient();
var destContainer = destBlobClient.GetContainerReference(destStorageContainerName);
var destBlob = destContainer.GetBlockBlobReference(destBlobName);
List <string> destBlockList = new List <string>();
// check if the blob exists, in which case we need to also get the list of blocks associated with that blob
// this will help to skip blocks which were already completed, and thereby help with resume
// TODO Block IDs are not unique across files - this will trip up the logic
if (destBlob.ExistsAsync().GetAwaiter().GetResult())
{
// only get committed blocks to be sure
destBlockList = (from b in (destBlob.DownloadBlockListAsync(BlockListingFilter.Committed, null, null, null).GetAwaiter().GetResult()) select b.Name).ToList();
}
// create a place holder for the final block list (to be eventually used for put block list) and pre-populate it with the known list of blocks
// already associated with the destination blob
var finalBlockList = new List <string>();
finalBlockList.AddRange(destBlockList);
var sourceStorageAccount = CloudStorageAccount.Parse(sourceAzureStorageConnStr);
var sourceBlobClient = sourceStorageAccount.CreateCloudBlobClient();
var sourceContainer = sourceBlobClient.GetContainerReference(sourceStorageContainerName);
var blobListing = new List <IListBlobItem>();
BlobContinuationToken continuationToken = null;
// check if there is a specific list of blobs given by the user, in which case the immediate 'if' code below will be skipped
if (sourceBlobNames is null || sourceBlobNames.Count == 0)
{
// we have a prefix specified, so get a of blobs with a specific prefix and then add them to a list
do
{
var response = sourceContainer.ListBlobsSegmentedAsync(sourceBlobPrefix, true, BlobListingDetails.None, null, continuationToken, null, null).GetAwaiter().GetResult();
continuationToken = response.ContinuationToken;
blobListing.AddRange(response.Results);
}while (continuationToken != null);
// now just get the blob names, that's all we need for further processing
sourceBlobNames = (from b in blobListing.OfType <CloudBlockBlob>() select b.Name).ToList();
// if the user specified to sort the input blobs (only valid for the prefix case) then we will happily do that!
// The gotcha here is that this is a string sort. So if blobs have names like blob_9, blob_13, blob_6, blob_3, blob_1
// the sort order will result in blob_1, blob_13, blob_3, blob_6, blob_9.
// To avoid issues like this the user must 0-prefix the numbers embedded in the filenames.
if (sortBlobs)
{
sourceBlobNames.Sort();
}
}
// iterate through each source blob, one at a time.
foreach (var sourceBlobName in sourceBlobNames)
{
Debug.WriteLine($"{DateTime.Now}: START {sourceBlobName}");
var sourceBlob = sourceContainer.GetBlockBlobReference(sourceBlobName);
// first we get the block list of the source blob. we use this to later parallelize the download / copy operation
var sourceBlockList = sourceBlob.DownloadBlockListAsync(BlockListingFilter.Committed, null, null, null).GetAwaiter().GetResult();
// in case the source blob is smaller then 256 MB (for latest API) then the blob is stored directly without any block list
// so in this case the sourceBlockList is 0-length and we need to fake a BlockListItem as null, which will later be handled below
if (sourceBlockList.Count() == 0 && sourceBlob.Properties.Length > 0)
{
ListBlockItem fakeBlockItem = null;
sourceBlockList = sourceBlockList.Concat(new[] { fakeBlockItem });
}
var blockRanges = new List <BlockRange>();
long currentOffset = 0;
// iterate through the list of blocks and compute their effective offsets in the final file.
int chunkIndex = 0;
foreach (var blockListItem in sourceBlockList)
{
// handle special case when the sourceBlob was put using PutBlob and has no blocks
var blockLength = blockListItem == null ? sourceBlob.Properties.Length : blockListItem.Length;
// compute a unique blockId based on blob account + container + blob name (includes path) + block length + block "number"
// TODO also include the endpoint when we generalize for all clouds
var hashBasis = System.Text.Encoding.UTF8.GetBytes(string.Concat(sourceStorageAccountName, sourceStorageContainerName, sourceBlobName, blockLength, chunkIndex));
var newBlockId = Convert.ToBase64String(shaHasher.ComputeHash(hashBasis));
var newBlockRange = new BlockRange()
{
Name = newBlockId,
StartOffset = currentOffset,
Length = blockLength
};
// increment this here itself as we may potentially skip to the next blob
chunkIndex++;
currentOffset += blockLength;
// check if this block has already been copied + committed at the destination, and in that case, skip it
if (destBlockList.Contains(newBlockId))
{
continue;
}
else
{
blockRanges.Add(newBlockRange);
}
}
Debug.WriteLine($"Number of ranges: {blockRanges.Count}");
// reset back to 0 to actually execute the copies
currentOffset = 0;
// proceed to copy blocks in parallel. to do this, we download to a local memory stream and then push that back out to the destination blob
Parallel.ForEach <BlockRange, MD5CryptoServiceProvider>(blockRanges, new ParallelOptions()
{
MaxDegreeOfParallelism = Environment.ProcessorCount * 8
},
() =>
{
// this will be a "task-local" copy. Better than creating this within the task, as that will be slighly expensive.
return(new MD5CryptoServiceProvider());
},
(currRange, loopState, hasher) =>
{
// TODO do we really need this copy?
var sourceBlobLocalCopy = sourceBlob; // sourceContainer.GetBlockBlobReference(sourceBlobName);
// TODO verify cast
using (var memStream = new MemoryStream((int)currRange.Length))
{
sourceBlobLocalCopy.DownloadRangeToStreamAsync(memStream, currRange.StartOffset, currRange.Length).GetAwaiter().GetResult();
// compute the hash, for which we need to reset the memory stream
memStream.Position = 0;
var md5Checksum = hasher.ComputeHash(memStream);
// reset the memory stream again to 0 and then call Azure Storage to put this as a block with the given block ID and MD5 hash
memStream.Position = 0;
Debug.WriteLine($"Putting block {currRange.Name}");
destBlob.PutBlockAsync(currRange.Name, memStream, Convert.ToBase64String(md5Checksum)).GetAwaiter().GetResult();
}
return(hasher);
},
(hasherFinally) => { }
);
// keep adding the blocks we just copied, to the final block list
finalBlockList.AddRange(from r in blockRanges select r.Name);
// TODO review this whether we put this for each source file or at the end of all source files
// when we are all done, execute a "commit" by using Put Block List operation
destBlob.PutBlockListAsync(finalBlockList).GetAwaiter().GetResult();
Debug.WriteLine($"{DateTime.Now}: END {sourceBlobName}");
// TODO optionally allow user to specify extra character(s) to append in between files. This is typically needed when the source files do not have a trailing \n character.
}
// release the SHA hasher resources
shaHasher.Dispose();
// TODO handle failures.
return(true);
}
/// <summary>
/// Generates a hash for the given plain text value and returns a
/// base64-encoded result. Before the hash is computed, a random salt
/// is generated and appended to the plain text. This salt is stored at
/// the end of the hash value, so it can be used later for hash
/// verification.
/// </summary>
/// <param name="plainText">
/// Plaintext value to be hashed.
/// </param>
/// <param name="hashAlgorithm">
/// Name of the hash algorithm. Allowed values are: "MD5", "SHA1",
/// "SHA256", "SHA384", and "SHA512" (if any other value is specified
/// MD5 hashing algorithm will be used). This value is case-insensitive.
/// </param>
/// <param name="saltBytes">
/// Salt bytes. This parameter can be null, in which case a random salt
/// value will be generated.
/// </param>
/// <returns>
/// Hash value formatted as a base64-encoded string.
/// </returns>
/// <remarks>
/// ComputeHash code provided as an example by Obviex at
/// http://www.obviex.com/samples/hash.aspx
/// As noted by Obviex themselves, code is definitely not optimally efficient.
/// Should performance requirements necessitate improvement, this should
/// be improved.
/// </remarks>
public static string ComputeHash(string plainText,
string hashAlgorithm,
byte[] saltBytes)
{
if (plainText == null)
return null;
// If salt is not specified, generate it on the fly.
if (saltBytes == null)
{
// Define min and max salt sizes.
int minSaltSize = 4;
int maxSaltSize = 8;
// Generate a random number for the size of the salt.
Random random = new Random();
int saltSize = random.Next(minSaltSize, maxSaltSize);
// Allocate a byte array, which will hold the salt.
saltBytes = new byte[saltSize];
// Initialize a random number generator.
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
// Fill the salt with cryptographically strong byte values.
rng.GetNonZeroBytes(saltBytes);
}
// Convert plain text into a byte array.
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
// Allocate array, which will hold plain text and salt.
byte[] plainTextWithSaltBytes =
new byte[plainTextBytes.Length + saltBytes.Length];
// Copy plain text bytes into resulting array.
for (int i = 0; i < plainTextBytes.Length; i++)
plainTextWithSaltBytes[i] = plainTextBytes[i];
// Append salt bytes to the resulting array.
for (int i = 0; i < saltBytes.Length; i++)
plainTextWithSaltBytes[plainTextBytes.Length + i] = saltBytes[i];
// Because we support multiple hashing algorithms, we must define
// hash object as a common (abstract) base class. We will specify the
// actual hashing algorithm class later during object creation.
HashAlgorithm hash;
// Make sure hashing algorithm name is specified.
if (hashAlgorithm == null)
hashAlgorithm = "";
// Initialize appropriate hashing algorithm class.
switch (hashAlgorithm.ToUpper())
{
case "SHA1":
hash = new SHA1Managed();
break;
case "SHA256":
hash = new SHA256Managed();
break;
case "SHA384":
hash = new SHA384Managed();
break;
case "SHA512":
hash = new SHA512Managed();
break;
default:
hash = new MD5CryptoServiceProvider();
break;
}
// Compute hash value of our plain text with appended salt.
byte[] hashBytes = hash.ComputeHash(plainTextWithSaltBytes);
// Create array which will hold hash and original salt bytes.
byte[] hashWithSaltBytes = new byte[hashBytes.Length +
saltBytes.Length];
// Copy hash bytes into resulting array.
for (int i = 0; i < hashBytes.Length; i++)
hashWithSaltBytes[i] = hashBytes[i];
// Append salt bytes to the result.
for (int i = 0; i < saltBytes.Length; i++)
hashWithSaltBytes[hashBytes.Length + i] = saltBytes[i];
// Convert result into a base64-encoded string.
string hashValue = Convert.ToBase64String(hashWithSaltBytes);
// Return the result.
return hashValue;
}
public override void GenerateKey(string secretKey, AlgorithmKeyType type)
{
this.Key = new byte[24];
this.IV = new byte[8];
byte[] bytes = Encoding.UTF8.GetBytes(secretKey);
switch (type)
{
case AlgorithmKeyType.SHA1:
using (SHA1Managed shA1Managed = new SHA1Managed())
{
shA1Managed.ComputeHash(bytes);
byte[] hash = shA1Managed.Hash;
for (int index = 0; index < 20; ++index)
{
this.Key[index] = hash[index];
}
for (int index = 16; index > 8; --index)
{
this.IV[16 - index] = hash[index];
}
break;
}
case AlgorithmKeyType.SHA256:
using (SHA256Managed shA256Managed = new SHA256Managed())
{
shA256Managed.ComputeHash(bytes);
byte[] hash = shA256Managed.Hash;
for (int index = 0; index < 24; ++index)
{
this.Key[index] = hash[index];
}
for (int index = 31; index >= 24; --index)
{
this.IV[31 - index] = hash[index];
}
break;
}
case AlgorithmKeyType.SHA384:
using (SHA384Managed shA384Managed = new SHA384Managed())
{
shA384Managed.ComputeHash(bytes);
byte[] hash = shA384Managed.Hash;
for (int index = 0; index < 24; ++index)
{
this.Key[index] = hash[index];
}
for (int index = 47; index > 39; --index)
{
this.IV[47 - index] = hash[index];
}
break;
}
case AlgorithmKeyType.SHA512:
using (SHA512Managed shA512Managed = new SHA512Managed())
{
shA512Managed.ComputeHash(bytes);
byte[] hash = shA512Managed.Hash;
for (int index = 0; index < 24; ++index)
{
this.Key[index] = hash[index];
}
for (int index = 63; index > 55; --index)
{
this.IV[63 - index] = hash[index];
}
break;
}
case AlgorithmKeyType.MD5:
using (MD5CryptoServiceProvider cryptoServiceProvider = new MD5CryptoServiceProvider())
{
cryptoServiceProvider.ComputeHash(bytes);
byte[] hash = cryptoServiceProvider.Hash;
for (int index = 0; index < 16; ++index)
{
this.Key[index] = hash[index];
}
for (int index = 15; index >= 8; --index)
{
this.IV[15 - index] = hash[index];
}
break;
}
}
}