public static HashAlgorithm GetHashProvider(HashType type)
{
HashAlgorithm hash = null;
switch (type)
{
case HashType.MD5:
{
hash = new MD5CryptoServiceProvider();
break;
}
case HashType.SHA1:
{
hash = new SHA1CryptoServiceProvider();
break;
}
case HashType.SHA256:
{
hash = new SHA256CryptoServiceProvider();
break;
}
case HashType.SHA384:
{
hash = new SHA384CryptoServiceProvider();
break;
}
case HashType.SHA512:
{
hash = new SHA512CryptoServiceProvider();
break;
}
}
return hash;
}
private HashAlgorithm GetHashAlgorithm(string hashType)
{
HashAlgorithm hash = null;
string hashTypeLower = hashType.ToLowerInvariant();
switch (hashTypeLower)
{
case "md5":
hash = new MD5CryptoServiceProvider();
break;
case "ripemd160":
hash = new RIPEMD160Managed();
break;
case "sha1":
hash = new SHA1CryptoServiceProvider();
break;
case "sha256":
hash = new SHA256CryptoServiceProvider();
break;
case "sha384":
hash = new SHA384CryptoServiceProvider();
break;
case "sha512":
hash = new SHA512CryptoServiceProvider();
break;
default:
break;
}
return hash;
}
private static string GetHash(string s)
{
SHA512 sec = new SHA512CryptoServiceProvider();
ASCIIEncoding enc = new ASCIIEncoding();
byte[] bt = enc.GetBytes(s);
return GetHexString(sec.ComputeHash(bt));
}
public static ICryptoTransform CreateEncryptor(string key, CryptionType type)
{
ICryptoTransform transform;
SHA512 sha512 = new SHA512CryptoServiceProvider();
var bytes = sha512.ComputeHash(Sha1(key).ToAsciiBytes());
switch (type)
{
case CryptionType.Aes:
var aes = Rijndael.Create();
aes.Mode = CipherMode.CBC;
transform = aes.CreateEncryptor(bytes.Skip(17).Take(32).ToArray(), bytes.Skip(17).Take(16).ToArray());
aes.Clear();
break;
case CryptionType.Des:
var des = new DESCryptoServiceProvider { Mode = CipherMode.CBC };
transform = des.CreateEncryptor(bytes.Skip(17).Take(8).ToArray(), bytes.Skip(17).Take(16).ToArray());
des.Clear();
break;
default:
var tripleDes = new TripleDESCryptoServiceProvider { Mode = CipherMode.CBC };
transform = tripleDes.CreateEncryptor(bytes.Skip(17).Take(24).ToArray(), bytes.Skip(17).Take(16).ToArray());
tripleDes.Clear();
break;
}
return transform;
}
private static string Hash(byte[] clearBuffer, HashAlgorithm algorithm)
{
System.Security.Cryptography.HashAlgorithm hashAlgorithm;
switch (algorithm)
{
case HashAlgorithm.MD5:
hashAlgorithm = new MD5CryptoServiceProvider();
break;
case HashAlgorithm.SHA1:
default:
hashAlgorithm = new SHA1CryptoServiceProvider();
break;
case HashAlgorithm.SHA256:
hashAlgorithm = new SHA256CryptoServiceProvider();
break;
case HashAlgorithm.SHA384:
hashAlgorithm = new SHA384CryptoServiceProvider();
break;
case HashAlgorithm.SHA512:
hashAlgorithm = new SHA512CryptoServiceProvider();
break;
}
var encryptedBuffer = hashAlgorithm.ComputeHash(clearBuffer);
return Convert.ToBase64String(encryptedBuffer);
}
/// <summary>
/// 64字节,512位
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static string SHA512(string str)
{
byte[] buffer = Encoding.UTF8.GetBytes(str);
SHA512CryptoServiceProvider SHA512 = new SHA512CryptoServiceProvider();
byte[] byteArr = SHA512.ComputeHash(buffer);
return BitConverter.ToString(byteArr);
}
private static string SHA512Hashing(string text)
{
UnicodeEncoding UE = new UnicodeEncoding();
byte[] plaintBytes = UE.GetBytes(text);
SHA512CryptoServiceProvider sha512 = new SHA512CryptoServiceProvider();
byte[] cipherBytes = sha512.ComputeHash(plaintBytes);
return Convert.ToBase64String(cipherBytes);
}
public static string SHA512Encryptor(string plainText)
{
byte[] data = ASCIIEncoding.ASCII.GetBytes(plainText);
SHA512 sha512 = new SHA512CryptoServiceProvider();
byte[] result = sha512.ComputeHash(data);
return Convert.ToBase64String(result);
}
public static string CodificarPassword(string primerPassword)
{
string clave = "72ggbcye7364ç5%hgd/.83045,72!@847@9dmshfjsnc3/jd";
SHA512 sha512 = new SHA512CryptoServiceProvider();
byte[] inputBytes = (new UnicodeEncoding()).GetBytes(primerPassword+clave);
byte[] hash = sha512.ComputeHash(inputBytes);
return Convert.ToBase64String(hash);
}
/// <summary>
/// Creates a SHA2 hash out of a password defined as string
/// </summary>
/// <param name="password">The password</param>
/// <returns>The SHA2 hash of the password</returns>
public static string CreateSha2Hash(this string password)
{
var sha2 = new SHA512CryptoServiceProvider();
var clearPasswordAsByteArray = Encoding.ASCII.GetBytes(password);
var hashedPasswordAsByteArray = sha2.ComputeHash(clearPasswordAsByteArray);
return Convert.ToBase64String(hashedPasswordAsByteArray);
}
public string EncryptPassword(string unencryptedPassword)
{
SHA512CryptoServiceProvider x = new SHA512CryptoServiceProvider();
byte[] data = Encoding.ASCII.GetBytes(unencryptedPassword);
data = x.ComputeHash(data);
return Encoding.ASCII.GetString(data);
}
public static bool CheckHash(string path, string hash)
{
byte[] buffer = File.ReadAllBytes(path);
string res = "";
using (var cryptoProvider = new SHA512CryptoServiceProvider())
{
res = BitConverter.ToString(cryptoProvider.ComputeHash(buffer));
}
return res == hash;
}
private string CalculateHash(string phrase)
{
var Provider = new SHA512CryptoServiceProvider();
var passwordStream = Encoding.UTF8.GetBytes(phrase);
var hashStream = Provider.ComputeHash(passwordStream);
return Encoding.UTF8.GetString(hashStream);
}
/// <summary>
/// Creates SHA-512 for text
/// </summary>
/// <param name="text">Input text from which is created SHA1</param>
/// <param name="encoding">Encoding for text</param>
/// <returns>Cryptografic hash SHA-512</returns>
public static string CreateSHA512Hash(string text, Encoding encoding)
{
byte[] buffer = encoding.GetBytes(text);
var cryptoTransformSHA512 = new SHA512CryptoServiceProvider();
string hash = BitConverter.ToString(
cryptoTransformSHA512.ComputeHash(buffer)).Replace("-", "");
return hash;
}
public override byte[] ComputeFileHash(string[] filenames, int? bufferSize)
{
ValidateParameters(filenames, ref bufferSize);
using (SHA512CryptoServiceProvider cryptoProvider = new SHA512CryptoServiceProvider())
{
ICryptoTransform cryptoInterface = cryptoProvider;
ComputeHashes(filenames, cryptoInterface, bufferSize.Value);
return cryptoProvider.Hash;
}
}
public static string Compute(string source)
{
if (string.IsNullOrEmpty(source))
{
throw new ArgumentException("You might not want to hash empty string.", "source");
}
var provider = new SHA512CryptoServiceProvider();
var message = Encoding.UTF8.GetBytes(source);
var hash = provider.ComputeHash(message);
return Convert.ToBase64String(hash);
}
private static string GetHash(byte[] data)
{
SHA512 sha = new SHA512CryptoServiceProvider();
StringBuilder sb = new StringBuilder();
data = sha.ComputeHash(data);
foreach (byte by in data)
{
sb.Append(by.ToString("x2"));
}
return sb.ToString();
}
static void passwordsHash1(string password)
{
byte[] byteRepresentation = UnicodeEncoding.Unicode.GetBytes(password);
var sha512 = new SHA512CryptoServiceProvider();
var hash = sha512.ComputeHash(byteRepresentation);
string hashedText = Convert.ToBase64String(hash);
Console.WriteLine("Password Hash Simple.");
Console.WriteLine("Texto de Hash (base64): " + hashedText );
}
public static string Compute(object obj)
{
if (obj == null)
{
throw new ArgumentException("You might not want to hash empty object.", "obj");
}
var provider = new SHA512CryptoServiceProvider();
var message = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(obj));
var hash = provider.ComputeHash(message);
return Convert.ToBase64String(hash);
}
public static string HashPassword(string password)
{
using (var sha = new SHA512CryptoServiceProvider())
{
if (password == "")
{
return "nonexistent-password";
}
var bytes = sha.ComputeHash(Encoding.ASCII.GetBytes(password));
return bytes.Aggregate("", (s, b) => s + b.ToString("X2"));
}
}
/// <summary>
/// Calculates the SHA512-hash of the given string
/// </summary>
/// <returns>Hexadecimal representation of the SHA512-hash.</returns>
/// <param name="str">Input string.</param>
public static string SHA512(string str)
{
var bytes = Encoding.ASCII.GetBytes (str);
byte[] hash;
// We're using the native SHA512 implementation here.
using (var hasher = new SHA512CryptoServiceProvider ()) {
hash = hasher.ComputeHash (bytes);
}
return hash.ToHex ();
}
/// <summary>
/// Hashes a stream with SHA-512.
/// </summary>
/// <param name="stream">The stream to hash.</param>
/// <returns>The hash.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="stream" /> is <see langword="null" />.
/// </exception>
public static byte[] SHA512(this Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
using (var hasher = new SHA512CryptoServiceProvider())
{
return hasher.ComputeHash(stream);
}
}
public static string Sha512Encode(string pwd)
{
SHA512 sha512 = new SHA512CryptoServiceProvider();//建立一個SHA512
byte[] source = Encoding.Default.GetBytes(pwd);//將字串轉為Byte[]
byte[] crypto = sha512.ComputeHash(source);//進行SHA512加密
string result = Convert.ToBase64String(crypto);//把加密後的字串從Byte[]轉為字串
return result;
}
private static byte[] ComputeHash(string password)
{
using (MemoryStream ms = new MemoryStream())
using (StreamWriter sw = new StreamWriter(ms))
{
sw.Write(password);
sw.Flush();
ms.Position = 0;
using (SHA512CryptoServiceProvider provider = new SHA512CryptoServiceProvider())
return provider.ComputeHash(ms);
}
}
public static string GetSHA512(byte[] data)
{
System.Security.Cryptography.SHA512 sha = new System.Security.Cryptography.SHA512CryptoServiceProvider();
byte[] bytResult = sha.ComputeHash(data);
//转换成字符串，32位
string strResult = BitConverter.ToString(bytResult);
//BitConverter转换出来的字符串会在每个字符中间产生一个分隔符，需要去除掉
strResult = strResult.Replace("-", "");
return(strResult);
}
public static string EncodePassword(string originalPassword)
{ //Clave que se utilizará para encriptar el usuario y la contraseña
string clave = "7f9facc418f74439c5e9709832;0ab8a5:OCOdN5Wl,q8SLIQz8i|8agmu¬s13Q7ZXyno/";
//Se instancia el objeto sha512 para posteriormente usarlo para calcular la matriz de bytes especificada
SHA512 sha512 = new SHA512CryptoServiceProvider();
//Se crea un arreglo llamada inputbytes donde se convierte el usuario, la contraseña y la clave a una secuencia de bytes.
byte[] inputBytes = (new UnicodeEncoding()).GetBytes(originalPassword + clave);
//Se calcula la matriz de bytes del arreglo anterior y se encripta.
byte[] hash = sha512.ComputeHash(inputBytes);
//Convertimos el arreglo de bytes a cadena.
return Convert.ToBase64String(hash);
}
public string Sha512Encrypt(string phrase)
{
var bytes = Encoding.UTF8.GetBytes(phrase);
bytes = new SHA512CryptoServiceProvider().ComputeHash(bytes);
var hashBuilder = new StringBuilder();
foreach (byte b in bytes)
{
hashBuilder.Append(b.ToString("x2").ToLower());
}
return hashBuilder.ToString();
}
public static Stream Encrypt(Stream stream, out string seed_encoded, out string ident_encoded, string fileName)
{
RNGCryptoServiceProvider rngCsp = new RNGCryptoServiceProvider();
byte[] seed = new byte[16];
rngCsp.GetBytes(seed);
seed_encoded = UrlBase64Encode(seed);
SHA512CryptoServiceProvider sha512csp = new SHA512CryptoServiceProvider();
byte[] seed_result = sha512csp.ComputeHash(seed);
byte[] key = new byte[32];
Buffer.BlockCopy(seed_result, 0, key, 0, 32);
byte[] iv = new byte[16];
Buffer.BlockCopy(seed_result, 32, iv, 0, 16);
byte[] ident = new byte[16];
Buffer.BlockCopy(seed_result, 48, ident, 0, 16);
ident_encoded = UrlBase64Encode(ident);
var fi = new FileInfo(fileName);
Dictionary<string, string> args = new Dictionary<string, string>();
// text files aren't detected well by the "ClouDeveloper" mime type library, use ShareX's builtin list first.
if (Helpers.IsTextFile(fileName))
{
args["mime"] = "text/plain";
}
else
{
var mimeOpts = ClouDeveloper.Mime.MediaTypeNames.GetMediaTypeNames(fi.Extension).ToList();
args["mime"] = mimeOpts.Count > 0 ? mimeOpts[0] : "image/png";
}
args["name"] = fileName;
byte[] d = Encoding.BigEndianUnicode.GetBytes(JsonConvert.SerializeObject(args));
byte[] rawdata = d.Concat(new byte[] { 0, 0 }).Concat(stream.GetBytes()).ToArray();
int l = FindIVLen(rawdata.Length);
byte[] civ = new byte[l];
Array.Copy(iv, civ, l);
KeyParameter key_param = new KeyParameter(key);
var ccmparams = new CcmParameters(key_param, MacSize, civ, new byte[0]);
var ccmMode = new CcmBlockCipher(new AesFastEngine());
ccmMode.Init(true, ccmparams);
var encBytes = new byte[ccmMode.GetOutputSize(rawdata.Length)];
var res = ccmMode.ProcessBytes(rawdata, 0, rawdata.Length, encBytes, 0);
ccmMode.DoFinal(encBytes, res);
return new MemoryStream(encBytes);
}
/// <summary>
/// Computes the hash for the specified stream and compares
/// it to the value in this object. CRC hashes are not supported
/// because there is no built-in support in the .net framework and
/// a CRC implementation exceeds the scope of this project. If you
/// attempt to Verify() a CRC hash a NotImplemented() exception will
/// be thrown.
/// </summary>
/// <param name="istream">The stream to compute the hash for</param>
/// <returns>True if the computed hash matches what's stored in this object.</returns>
public bool Verify(Stream istream) {
if (IsValid) {
HashAlgorithm hashAlg = null;
switch (m_algorithm) {
case FtpHashAlgorithm.SHA1:
hashAlg = new SHA1CryptoServiceProvider();
break;
#if !NET2
case FtpHashAlgorithm.SHA256:
hashAlg = new SHA256CryptoServiceProvider();
break;
case FtpHashAlgorithm.SHA512:
hashAlg = new SHA512CryptoServiceProvider();
break;
#endif
case FtpHashAlgorithm.MD5:
hashAlg = new MD5CryptoServiceProvider();
break;
case FtpHashAlgorithm.CRC:
hashAlg = new Crc32();
break;
//throw new NotImplementedException("There is no built in support for computing CRC hashes.");
default:
throw new NotImplementedException("Unknown hash algorithm: " + m_algorithm.ToString());
}
try {
byte[] data = null;
string hash = "";
data = hashAlg.ComputeHash(istream);
if (data != null) {
foreach (byte b in data) {
hash += b.ToString("x2");
}
return (hash.ToUpper() == m_value.ToUpper());
}
}
finally {
#if !NET2 // .NET 2.0 doesn't provide access to Dispose() for HashAlgorithm
if (hashAlg != null)
hashAlg.Dispose();
#endif
}
}
return false;
}
private static byte[] GetTargetHash(int iteratioNo, byte[] initialHash)
{
var result = initialHash.Clone() as byte[];
using (var hash = new SHA512CryptoServiceProvider())
{
for (int i = 0; i < iteratioNo; ++i)
{
result = hash.ComputeHash(result);
}
}
return result;
}
static void Main(string[] args)
{
using(SHA512CryptoServiceProvider sha = new SHA512CryptoServiceProvider())
while (true)
{
string s = Console.ReadLine();
byte[] a = ASCIIEncoding.ASCII.GetBytes(s.ToCharArray());
byte[] b = Cript512.ComputeHash(new MemoryStream(a));
byte[] c = sha.ComputeHash(a);
Console.WriteLine("{0}\nRAW:{1}\n\nHASH:{2}\n\nSHA:{3}", s, BitConverter.ToString(a), BitConverter.ToString(b),BitConverter.ToString(c));
}
}
public AesEncryptionProvider(string key, int keyLength = 24)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentException("Key must have have a valid value.", nameof(key));
}
if (!validLengths.Contains(keyLength))
{
throw new ArgumentException("Invalid key length, key must be of sizes 16, 24 or 32", nameof(key));
}
using var hash = new Crypto.SHA512CryptoServiceProvider();
var hashed = hash.ComputeHash(Encoding.UTF8.GetBytes(key));
_aesKey = new byte[keyLength];
Array.ConstrainedCopy(hashed, 0, this._aesKey, 0, keyLength);
}
/// <summary>
/// 计算SHA-512码
/// </summary>
/// <param name="word">字符串</param>
/// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
/// <returns></returns>
public static string Hash_SHA_512(string word, bool toUpper = true)
{
try
{
System.Security.Cryptography.SHA512CryptoServiceProvider SHA512CSP
= new System.Security.Cryptography.SHA512CryptoServiceProvider();
byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
byte[] bytHash = SHA512CSP.ComputeHash(bytValue);
SHA512CSP.Clear();
//根据计算得到的Hash码翻译为SHA-1码
string sHash = "", sTemp = "";
for (int counter = 0; counter < bytHash.Count(); counter++)
{
long i = bytHash[counter] / 16;
if (i > 9)
{
sTemp = ((char)(i - 10 + 0x41)).ToString();
}
else
{
sTemp = ((char)(i + 0x30)).ToString();
}
i = bytHash[counter] % 16;
if (i > 9)
{
sTemp += ((char)(i - 10 + 0x41)).ToString();
}
else
{
sTemp += ((char)(i + 0x30)).ToString();
}
sHash += sTemp;
}
//根据大小写规则决定返回的字符串
return(toUpper ? sHash : sHash.ToLower());
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 获取文本SHA512
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static string GetTextSHA_512(string text)
{
if (string.IsNullOrEmpty(text))
{
return(string.Empty);
}
System.Security.Cryptography.SHA512CryptoServiceProvider SHA512CSP
= new System.Security.Cryptography.SHA512CryptoServiceProvider();
byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(text);
byte[] bytHash = SHA512CSP.ComputeHash(bytValue);
SHA512CSP.Clear();
//根据计算得到的Hash码翻译为SHA-1码
string sHash = ConvertHashBytes(bytHash);
//根据大小写规则决定返回的字符串
return(sHash.ToLower());
}
/// <summary>
/// Compute the hexadecimal SHA512 hash of the specified string.
/// </summary>
/// <remarks>
/// Uses a SHA512CryptoServiceProvider and a BitConverter.
/// </remarks>
/// <param name="s">The string to hash.</param>
/// <returns>The hexadecimal SHA512 hash of the specified string.</returns>
public static string SHA512Hash(this string s)
{
System.Security.Cryptography.SHA512CryptoServiceProvider hasha = new System.Security.Cryptography.SHA512CryptoServiceProvider();
return(BitConverter.ToString(hasha.ComputeHash(System.Text.Encoding.UTF8.GetBytes(s))).Replace("-", ""));
}