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)); }
public static byte[] SHA384(byte[] data) { using (var sha = new SHA384CryptoServiceProvider()) { return(sha.ComputeHash(data)); } }
internal static string ComputeSHA384(string Input) { SHA384CryptoServiceProvider CryptoSrv = new SHA384CryptoServiceProvider(); byte[] Bytes = CryptoSrv.ComputeHash(Encoding.ASCII.GetBytes(Input)); return(BuildString(Bytes)); }
public override string ComputeHash(string plainText) { var alg = new SHA384CryptoServiceProvider(); var hash = alg.ComputeHash(Encoding.UTF8.GetBytes(plainText)); return($"{Convert.ToBase64String(hash)}"); }
public User(string name, string password, string email) : base() { Name = name ?? throw new ArgumentNullException(nameof(name)); byte[] salt1 = new byte[32]; using (RNGCryptoServiceProvider rngCsp = new RNGCryptoServiceProvider()) { rngCsp.GetBytes(salt1); } Salt = Encoding.Default.GetString(salt1); password += Salt; SHA384 sha1 = new SHA384CryptoServiceProvider(); byte[] hashbytes = sha1.ComputeHash(Encoding.Default.GetBytes(password)); Password = 0; for (int i = 0; i < hashbytes.Length; i++) { Password += hashbytes[i]; } Email = email ?? throw new ArgumentNullException(nameof(email)); }
/// <summary> /// 48字节,384位 /// </summary> /// <param name="str">内容</param> /// <returns></returns> public static string SHA384(string str) { byte[] buffer = Encoding.UTF8.GetBytes(str); using SHA384CryptoServiceProvider SHA384 = new SHA384CryptoServiceProvider(); byte[] byteArr = SHA384.ComputeHash(buffer); return(BitConverter.ToString(byteArr)); }
public static string[] GetSHAHash(string Message) { string[] sha = new string[4]; try { SHA1 sha1 = new SHA1CryptoServiceProvider(); SHA256 sha256 = new SHA256CryptoServiceProvider(); SHA384 sha384 = new SHA384CryptoServiceProvider(); SHA512 sha512 = new SHA512CryptoServiceProvider(); byte[] sha_in = UTF8Encoding.Default.GetBytes(Message); byte[] sha1_out = sha1.ComputeHash(sha_in); byte[] sha256_out = sha256.ComputeHash(sha_in); byte[] sha384_out = sha384.ComputeHash(sha_in); byte[] sha512_out = sha512.ComputeHash(sha_in); sha[0] = BitConverter.ToString(sha1_out).Replace("-", ""); sha[1] = BitConverter.ToString(sha256_out).Replace("-", ""); sha[2] = BitConverter.ToString(sha384_out).Replace("-", ""); sha[3] = BitConverter.ToString(sha512_out).Replace("-", ""); return(sha); } catch { MessageBox.Show("校验失败"); return(sha); } }
static HashAlgorithm GetHashAlgorithm(string algorithm) { HashAlgorithm hashAlgorithm; if (algorithm == ("SHA1")) { hashAlgorithm = new SHA1CryptoServiceProvider(); } else if (algorithm == ("SHA256")) { hashAlgorithm = new SHA256CryptoServiceProvider(); } else if (algorithm == ("SHA384")) { hashAlgorithm = new SHA384CryptoServiceProvider(); } else if (algorithm == ("SHA512")) { hashAlgorithm = new SHA512CryptoServiceProvider(); } else { hashAlgorithm = new SHA1CryptoServiceProvider(); } return(hashAlgorithm); }
public static byte[] ComputeHash(byte[] buffer, HashAlgorithm algorithm) { System.Security.Cryptography.HashAlgorithm hashAlgorithm; switch (algorithm) { case HashAlgorithm.MD5: hashAlgorithm = new MD5CryptoServiceProvider(); break; case HashAlgorithm.SHA1: hashAlgorithm = new SHA1CryptoServiceProvider(); break; case HashAlgorithm.SHA256: hashAlgorithm = new SHA256CryptoServiceProvider(); break; case HashAlgorithm.SHA384: hashAlgorithm = new SHA384CryptoServiceProvider(); break; default: case HashAlgorithm.SHA512: hashAlgorithm = new SHA512CryptoServiceProvider(); break; } return(hashAlgorithm.ComputeHash(buffer)); }
public static string Hash(this string str, HashAlgorithm algorithm = HashAlgorithm.SHA512) { var inputBytes = Encoding.ASCII.GetBytes(str); System.Security.Cryptography.HashAlgorithm hashAlgorithm = new SHA512CryptoServiceProvider(); switch (algorithm) { case HashAlgorithm.MD5: hashAlgorithm = new MD5CryptoServiceProvider(); break; case HashAlgorithm.SHA1: 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 result = hashAlgorithm.ComputeHash(inputBytes); return(result.ToHexString()); }
private static string SHA384_Hash(byte[] source) { SHA384 sha384 = new SHA384CryptoServiceProvider(); //建立SHA384 byte[] crypto = sha384.ComputeHash(source); //進行SHA384加密 return(Convert.ToBase64String(crypto)); //把加密後的字串從Byte[]轉為字串 }
public static string SHA384(this string content, string salt = null) { using (var provider = new SHA384CryptoServiceProvider()) { return(BitConverter.ToString(provider.ComputeHash(Encoding.UTF8.GetBytes(content + salt))).Replace("-", "")); } }
/// <summary> /// 创建Hash算法 /// </summary> /// <param name="hashProvider"></param> /// <returns></returns> internal static HashAlgorithm CreateHashAlgorithm(EnumHashProvider hashProvider) { HashAlgorithm hashAlgorithm = null; switch (hashProvider) { case EnumHashProvider.MD5CryptoServiceProvider: hashAlgorithm = new MD5CryptoServiceProvider(); break; //case EnumHashProvider.RIPEMD160Managed: //not exist in .net core // hashAlgorithm = RIPEMD160Managed(); // break; case EnumHashProvider.SHA1CryptoServiceProvider: hashAlgorithm = new SHA1CryptoServiceProvider(); break; case EnumHashProvider.SHA1Managed: hashAlgorithm = new SHA1Managed(); break; case EnumHashProvider.SHA256Managed: hashAlgorithm = new SHA256CryptoServiceProvider(); break; case EnumHashProvider.SHA384Managed: hashAlgorithm = new SHA384CryptoServiceProvider(); break; case EnumHashProvider.SHA512Managed: hashAlgorithm = new SHA512CryptoServiceProvider(); break; } return(hashAlgorithm); }
public static string GetHashCodeString(this byte[] bytes, HashType type = HashType.MD5) { switch (type) { case HashType.SHA1: SHA1 sha1 = new SHA1CryptoServiceProvider(); return(BitConverter.ToString(sha1.ComputeHash(bytes))); case HashType.SHA256: SHA256 sha256 = new SHA256CryptoServiceProvider(); return(BitConverter.ToString(sha256.ComputeHash(bytes))); case HashType.SHA384: SHA384 sha384 = new SHA384CryptoServiceProvider(); return(BitConverter.ToString(sha384.ComputeHash(bytes))); case HashType.SHA512: SHA512 sha512 = new SHA512CryptoServiceProvider(); return(BitConverter.ToString(sha512.ComputeHash(bytes))); default: MD5 md5 = MD5.Create(); return(BitConverter.ToString(md5.ComputeHash(bytes))); } }
/// <summary> /// SHA384 /// </summary> /// <param name="data"></param> /// <returns></returns> public string SHA384(byte[] data) { using (var hashAlgorithm = new SHA384CryptoServiceProvider()) { return(ComputeHash(data, hashAlgorithm)); } }
public static byte[] HashRaw(EHashType type, Stream bs, bool seekBegin) { if (bs == null) { return(null); } HashAlgorithm cmd5 = null; switch (type) { case EHashType.Md5: cmd5 = new MD5CryptoServiceProvider(); break; case EHashType.Sha1: cmd5 = new SHA1CryptoServiceProvider(); break; case EHashType.Sha256: cmd5 = new SHA256CryptoServiceProvider(); break; case EHashType.Sha384: cmd5 = new SHA384CryptoServiceProvider(); break; case EHashType.Sha512: cmd5 = new SHA512CryptoServiceProvider(); break; } if (seekBegin) { bs.Seek(0, SeekOrigin.Begin); } byte[] bsh = cmd5.ComputeHash(bs); cmd5.Dispose(); return(bsh); }
/// <summary> /// 加密 /// </summary> /// <param name="source"></param> /// <param name="type"></param> /// <remarks>64Base</remarks> /// <returns></returns> public static string Encrypt(string source, SHA2Type type = SHA2Type.Use256) { string encrypt = string.Empty; byte[] bytes = Encoding.Default.GetBytes(source); byte[] temp = null; switch (type) { case SHA2Type.Use256: temp = new SHA256CryptoServiceProvider().ComputeHash(bytes); break; case SHA2Type.Use384: temp = new SHA384CryptoServiceProvider().ComputeHash(bytes); break; case SHA2Type.Use512: temp = new SHA512CryptoServiceProvider().ComputeHash(bytes); break; } encrypt = Convert.ToBase64String(temp); return(encrypt); }
public static byte[] ComputeHash(byte[] bytesToHash, HashSize hashSize = HashSize.S160) { if (bytesToHash == null || bytesToHash.Length <= 0) { throw new ArgumentNullException("bytesToHash"); } HashAlgorithm hasher; switch (hashSize) { case HashSize.S256: hasher = new SHA256CryptoServiceProvider(); break; case HashSize.S384: hasher = new SHA384CryptoServiceProvider(); break; case HashSize.S512: hasher = new SHA512CryptoServiceProvider(); break; default: //HashSize.S160: hasher = new SHA1CryptoServiceProvider(); break; } byte[] hash = hasher.ComputeHash(bytesToHash); hasher.Dispose(); return(hash); }
public static byte[] HashRaw(EHashType type, byte[] bs, int index, int length) { if (bs == null) { return(null); } HashAlgorithm cmd5 = null; switch (type) { case EHashType.Md5: cmd5 = new MD5CryptoServiceProvider(); break; case EHashType.Sha1: cmd5 = new SHA1CryptoServiceProvider(); break; case EHashType.Sha256: cmd5 = new SHA256CryptoServiceProvider(); break; case EHashType.Sha384: cmd5 = new SHA384CryptoServiceProvider(); break; case EHashType.Sha512: cmd5 = new SHA512CryptoServiceProvider(); break; } bs = cmd5.ComputeHash(bs, index, length); cmd5.Dispose(); return(bs); }
/// <summary> /// Method for creating a detached signature. /// </summary> /// <param name="messageToSign">The message to sign</param> /// <param name="signingKey">The <see cref="X509Certificate2"/> containing the private key</param> /// <param name="signatureAlgorithm">The <see cref="SignatureAlgorithm"/> to use for signing the message</param> /// <returns>A string containing the detached signature value</returns> public static string SignDetached(string messageToSign, X509Certificate2 signingKey, SignatureAlgorithm signatureAlgorithm) { // Get the certificate private key RSACryptoServiceProvider privateKey = signingKey.PrivateKey as RSACryptoServiceProvider; // Get the bytes and encrypt byte[] buffer = Encoding.UTF8.GetBytes(messageToSign); object algorithm = null; switch (signatureAlgorithm) { case SignatureAlgorithm.Sha1: algorithm = new SHA1CryptoServiceProvider(); break; case SignatureAlgorithm.Sha256: algorithm = new SHA256CryptoServiceProvider(); break; case SignatureAlgorithm.Sha384: algorithm = new SHA384CryptoServiceProvider(); break; case SignatureAlgorithm.Sha512: algorithm = new SHA512CryptoServiceProvider(); break; } byte[] encryptedBytes = privateKey.SignData(buffer, algorithm); return(Convert.ToBase64String(encryptedBytes)); }
/// <summary> /// Extensão que computa um hash de um vetor de bytes. /// </summary> /// <param name="bytes">Objeto referenciado</param> /// <param name="hashAlgoritm">Algoritmo utilizado no cálculo de hash. Veja <see cref="HashAlgorithmName"/></param> /// <returns>Hash gerado para o byte array informado</returns> public static byte[] ComputeHash(this byte[] bytes, HashAlgorithmName hashAlgoritm) { var hasher = default(HashAlgorithm); switch (hashAlgoritm.Name) { case "MD5": hasher = new MD5CryptoServiceProvider(); break; case "SHA1": hasher = new SHA1CryptoServiceProvider(); break; case "SHA256": hasher = new SHA256CryptoServiceProvider(); break; case "SHA384": hasher = new SHA384CryptoServiceProvider(); break; case "SHA512": hasher = new SHA512CryptoServiceProvider(); break; default: break; } return(hasher.ComputeHash(bytes)); }
private string HashPass(string Password) { HashAlgorithm algorithm = SHA384CryptoServiceProvider.Create(); byte[] bytePassword = algorithm.ComputeHash(Encoding.UTF8.GetBytes(Password)); return(Convert.ToBase64String(bytePassword)); }
public static string[] GetSHAHashFromFile(string fileName) { string[] sha = new string[4]; try { SHA1 sha1 = new SHA1CryptoServiceProvider(); SHA256 sha256 = new SHA256CryptoServiceProvider(); SHA384 sha384 = new SHA384CryptoServiceProvider(); SHA512 sha512 = new SHA512CryptoServiceProvider(); FileStream file = new FileStream(fileName, FileMode.Open); byte[] sha1_out = sha1.ComputeHash(file); file.Close(); file = new FileStream(fileName, FileMode.Open); byte[] sha256_out = sha256.ComputeHash(file); file.Close(); file = new FileStream(fileName, FileMode.Open); byte[] sha384_out = sha384.ComputeHash(file); file.Close(); file = new FileStream(fileName, FileMode.Open); byte[] sha512_out = sha512.ComputeHash(file); file.Close(); sha[0] = BitConverter.ToString(sha1_out).Replace("-", ""); sha[1] = BitConverter.ToString(sha256_out).Replace("-", ""); sha[2] = BitConverter.ToString(sha384_out).Replace("-", ""); sha[3] = BitConverter.ToString(sha512_out).Replace("-", ""); return(sha); } catch { MessageBox.Show("校验失败"); return(sha); } }
/// <summary> /// Generate KDF. /// </summary> /// <param name="securitySuite">Security suite.</param> /// <param name="z">z Shared Secret.</param> /// <param name="otherInfo">Other info.</param> /// <returns></returns> public static byte[] GenerateKDF(SecuritySuite securitySuite, byte[] z, byte[] otherInfo) { GXByteBuffer bb = new GXByteBuffer(); bb.SetUInt32(1); bb.Set(z); bb.Set(otherInfo); if (securitySuite == SecuritySuite.Ecdsa256) { using (SHA256 sha = new SHA256CryptoServiceProvider()) { return(sha.ComputeHash(bb.Array())); } } else if (securitySuite == SecuritySuite.Ecdsa384) { using (SHA384 sha = new SHA384CryptoServiceProvider()) { return(sha.ComputeHash(bb.Array())); } } else { throw new ArgumentOutOfRangeException("Invalid sevurity suite."); } }
public static string SHA384Encrypt(this string normalTxt) { var bytes = Encoding.Default.GetBytes(normalTxt); var SHA384 = new SHA384CryptoServiceProvider(); var encryptbytes = SHA384.ComputeHash(bytes); return(Base64To16(encryptbytes)); }
// SHA384 public static string SHA384(string str) { SHA384CryptoServiceProvider provider = new SHA384CryptoServiceProvider(); byte[] input = ASCIIEncoding.Default.GetBytes(str); byte[] output = provider.ComputeHash(input); return(BitConverter.ToString(output).Replace("-", "").ToLower()); }
/// <summary> /// SHA384,384 bits 加密 /// </summary> /// <param name="text"></param> public string ToSHA384(string text) { SHA384 sha384 = new SHA384CryptoServiceProvider(); //建立一個SHA384 byte[] source = Encoding.Default.GetBytes(text); //將字串轉為Byte[] byte[] crypto = sha384.ComputeHash(source); //進行SHA384加密 return(Convert.ToBase64String(crypto)); //把加密後的字串從Byte[]轉為字串 }
public string ToSHA384(string text) { SHA384 sha384 = new SHA384CryptoServiceProvider(); byte[] source = Encoding.Default.GetBytes(text); byte[] crypto = sha384.ComputeHash(source); return(Convert.ToBase64String(crypto)); }
/// <summary> /// SHA384加密 /// </summary> /// <param name="normalTxt"></param> /// <returns></returns> public static string SHA384Encrypt(string normalTxt) { var bytes = Encoding.Unicode.GetBytes(normalTxt); var SHA384 = new SHA384CryptoServiceProvider(); var encryptbytes = SHA384.ComputeHash(bytes); return(Convert.ToBase64String(encryptbytes)); }
public static string SHA384Encrypt(this string source, string strFormat = "X2") { var bytes = Encoding.Default.GetBytes(source); var SHA384 = new SHA384CryptoServiceProvider(); var data = SHA384.ComputeHash(bytes); return(data.ToString(strFormat)); }