internal static byte[] ToAesKey(this SecureString password) { using (SHA256Cng sha256 = new SHA256Cng()) { byte[] passwordBytes = password.ToArray(); byte[] passwordHash = sha256.ComputeHash(passwordBytes); byte[] passwordHash2 = sha256.ComputeHash(passwordHash); Array.Clear(passwordBytes, 0, passwordBytes.Length); Array.Clear(passwordHash, 0, passwordHash.Length); return passwordHash2; } }
public static byte[] ToAesKey(this string password) { using (SHA256Cng sha256 = new SHA256Cng()) { byte[] passwordBytes = Encoding.UTF8.GetBytes(password); byte[] passwordHash = sha256.ComputeHash(passwordBytes); byte[] passwordHash2 = sha256.ComputeHash(passwordHash); Array.Clear(passwordBytes, 0, passwordBytes.Length); Array.Clear(passwordHash, 0, passwordHash.Length); return passwordHash2; } }
/// <summary> /// Hash function: H(data) /// </summary> public static string Hash(string message) { using (SHA256Cng sha256 = new SHA256Cng()) { return Convert.ToBase64String(sha256.ComputeHash(Encoding.Unicode.GetBytes(message))); } }
static void Main(string[] args) { Console.WriteLine("MD5 und SHA Beispiel - Salt & Pepper"); Console.WriteLine("===================================="); //sollte aus einer anderen Quelle gelesen werden. Der Einfachheit halber wird ein String verwendet var pepper = "@ktdRdotewStee31223!!!33sdrt532sv224vvl420094"; //Eingabe lesen und in ein Byte-Array verwandeln var salt = Salt("Benutzer"); var bytes = new ASCIIEncoding().GetBytes(string.Format("{0}{1}{2}",Input(), salt, pepper)); //MD5 var md5 = new MD5Cng(); string md5Hash = BitConverter.ToString(md5.ComputeHash(bytes)).Replace("-", "").ToLower(); Console.WriteLine("MD5-Hash:\t{0}", md5Hash); //SHA1 var sha1Cng = new SHA1Cng(); string sha1Hash = BitConverter.ToString(sha1Cng.ComputeHash(bytes)).Replace("-","").ToLower(); Console.WriteLine("SHA1-Hash:\t{0}", sha1Hash); //SHA256 var sha256 = new SHA256Cng(); string sha256Hash = BitConverter.ToString(sha256.ComputeHash(bytes)).Replace("-", "").ToLower(); Console.WriteLine("SHA256-Hash:\t{0}", sha256Hash); Console.WriteLine("Beliebige Taste drücken zum beenden"); Console.ReadKey(); }
static void Main(string[] args) { Console.WriteLine("MD5 und SHA Beispiel"); Console.WriteLine("===================="); //Eingabe lesen und in ein Byte-Array verwandeln var bytes = new ASCIIEncoding().GetBytes(Input()); //MD5 var md5 = new MD5Cng(); string md5Hash = BitConverter.ToString(md5.ComputeHash(bytes)).Replace("-", "").ToLower(); Console.WriteLine("MD5-Hash:\t{0}", md5Hash); //SHA1 var sha1Cng = new SHA1Cng(); string sha1Hash = BitConverter.ToString(sha1Cng.ComputeHash(bytes)).Replace("-","").ToLower(); Console.WriteLine("SHA1-Hash:\t{0}", sha1Hash); //SHA256 var sha256 = new SHA256Cng(); string sha256Hash = BitConverter.ToString(sha256.ComputeHash(bytes)).Replace("-", "").ToLower(); Console.WriteLine("SHA256-Hash:\t{0}", sha256Hash); Console.WriteLine("Beliebige Taste drücken zum beenden"); Console.ReadKey(); }
public String hashearSHA256(String input) { SHA256Cng encriptador = new SHA256Cng(); byte[] inputEnBytes = System.Text.Encoding.UTF8.GetBytes(input); byte[] inputHashBytes = encriptador.ComputeHash(inputEnBytes); return BitConverter.ToString(inputHashBytes).Replace("-", string.Empty).ToLower(); }
public static byte[] HashString(string input) { using (var hasher = new SHA256Cng()) { return hasher.ComputeHash(Encoding.UTF8.GetBytes(input)); } }
public static string Hash(byte[] data) { using (SHA256Cng sha256 = new SHA256Cng()) { return Convert.ToBase64String(sha256.ComputeHash(data)); } }
public void HashPassword() { const string password = "******"; var algorithm = new SHA256Cng(); var unicoding = new UnicodeEncoding(); var hash = unicoding.GetString(algorithm.ComputeHash(unicoding.GetBytes(password))); Log(hash); }
public string CreateSha256Hash(string input) { using (SHA256Cng sha = new SHA256Cng()) { UTF8Encoding encoding = new UTF8Encoding(); return Convert.ToBase64String(sha.ComputeHash(encoding.GetBytes(input))); } }
public static byte[] GetHash([NotNull] string input, [CanBeNull] HashAlgorithm algorithm = null) { byte[] buffer = Encoding.Unicode.GetBytes(input); if (algorithm != null) return algorithm.ComputeHash(buffer); using (algorithm = new SHA256Cng()) return algorithm.ComputeHash(buffer); }
public CtVerifier(byte[] publicKey) { var key = DecodeSubjectPublicKeyInfo(publicKey); if (key == null) { throw new ArgumentException("Could not decode public key.", nameof(publicKey)); } _key = key; using (var sha = new SHA256Cng()) { LogId = sha.ComputeHash(publicKey); } }
public ActionResult Unlock(UnlockerModel model) { var algorithm = new SHA256Cng(); var unicoding = new UnicodeEncoding(); var hashed = unicoding.GetString(algorithm.ComputeHash(unicoding.GetBytes(model.Passphrase))); if (hashed == "嘃ᥐ倹⦦듑ꈳ囬쀺诫谾臭ᰠ屯") { FormsAuthentication.SetAuthCookie("Manager", false); var url = Handy.BaseUrl() + (model.ReturnUrl ?? Url.Action("Unlock")); return Redirect(url); } ModelState.AddModelError("AuthenticationFailed", "Wrong Passphrase"); return View(); }
/// <summary>Gets the SHA-2 Hash of a file.</summary> /// <param name="str">The string to calculate hash.</param> /// <returns>The SHA-2 Hash.</returns> public static string GetHash(string str) { var buff = new StringBuilder(10); using (var sha2 = new SHA256Cng()) { sha2.ComputeHash(Encoding.Unicode.GetBytes(str)); foreach (byte hashByte in sha2.Hash) { buff.Append(string.Format(CultureInfo.InvariantCulture, "{0:X1}", hashByte)); } } return buff.ToString(); }
public static HashData ComputeHashes(string fileName) { try { using (FileStream stream = File.OpenRead(fileName)) { using (var bufferedStream = new BufferedStream(stream, 1024 * 32)) { string md5, sha1, sha256; byte[] checksum; using (var md5Cng = new MD5Cng()) { checksum = md5Cng.ComputeHash(bufferedStream); md5 = BitConverter.ToString(checksum).Replace("-", string.Empty); } stream.Seek(0, SeekOrigin.Begin); bufferedStream.Seek(0, SeekOrigin.Begin); using (var sha1Cng = new SHA1Cng()) { checksum = sha1Cng.ComputeHash(bufferedStream); sha1 = BitConverter.ToString(checksum).Replace("-", string.Empty); } stream.Seek(0, SeekOrigin.Begin); bufferedStream.Seek(0, SeekOrigin.Begin); using (var sha256Cng = new SHA256Cng()) { checksum = sha256Cng.ComputeHash(bufferedStream); sha256 = BitConverter.ToString(checksum).Replace("-", string.Empty); } return new HashData(md5, sha1, sha256); } } } catch (IOException) { } catch (UnauthorizedAccessException) { } return null; }
public static string ComputeSha256Hash(string fileName) { string sha256Hash = null; try { using (FileStream stream = File.OpenRead(fileName)) { using (var bufferedStream = new BufferedStream(stream, 1024 * 32)) { var sha = new SHA256Cng(); byte[] checksum = sha.ComputeHash(bufferedStream); sha256Hash = BitConverter.ToString(checksum).Replace("-", String.Empty); } } } catch (IOException) { } catch (UnauthorizedAccessException) { } return sha256Hash; }
/// <summary> /// Gets the input string as a SHA256 Base64 encoded string. /// </summary> /// <param name="input">The input to hash.</param> /// <param name="isCaseSensitive">If set to <c>false</c> the function will produce the same value for any casing of input.</param> /// <returns>The hashed value.</returns> public static string GetHashedId(string input, bool isCaseSensitive = false) { // for nulls, return an empty string, else hash. if (input == null) { return string.Empty; } using (SHA256 hasher = new SHA256Cng()) { string temp = input; if (isCaseSensitive == false) { temp = input.ToUpperInvariant(); } byte[] buffer = hasher.ComputeHash(Encoding.UTF8.GetBytes(temp)); return new SoapBase64Binary(buffer).ToString(); } }
public static byte[] ComputeSHA256(IList<string> parameters) { using (MemoryStream ms = new MemoryStream()) { using (BinaryWriter bw = new BinaryWriter(ms)) { foreach (string parameter in parameters) { bw.Write(parameter); // also writes the length as a prefix; unambiguous } bw.Flush(); using (SHA256Cng sha256 = new SHA256Cng()) { byte[] retVal = sha256.ComputeHash(ms.GetBuffer(), 0, checked((int)ms.Length)); return retVal; } } } }
public static byte[] ComputeSHA256(IList<string> parameters) { byte[] result; using (MemoryStream memoryStream = new MemoryStream()) { using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream)) { foreach (string current in parameters) { binaryWriter.Write(current); } binaryWriter.Flush(); using (SHA256Cng sHA256Cng = new SHA256Cng()) { byte[] array = sHA256Cng.ComputeHash(memoryStream.GetBuffer(), 0, checked((int)memoryStream.Length)); result = array; } } } return result; }
private string GetImageHash(byte[] image) { var sha256 = new SHA256Cng(); return Encoding.Default.GetString(sha256.ComputeHash(image)); }
private static byte[] ComputeHash(string hashAlgorithmName, string fileName) { HashAlgorithm hashAlgorithm = null; switch (hashAlgorithmName) { case StrMd5: hashAlgorithm = new MD5Cng(); break; case StrSha1: hashAlgorithm = new SHA1Cng(); break; case StrSha256: hashAlgorithm = new SHA256Cng(); break; } if (null != hashAlgorithm) { using (var stream = File.OpenRead(fileName)) { return hashAlgorithm.ComputeHash(stream); } } var message = String.Format("Invalid hash algorithm name: {0}", hashAlgorithmName); throw new ApplicationException(message); }
private static string EncryptAES(string decrypted) { if (string.IsNullOrEmpty(decrypted)) { ASF.ArchiLogger.LogNullError(nameof(decrypted)); return null; } try { byte[] key; using (SHA256Cng sha256 = new SHA256Cng()) { key = sha256.ComputeHash(EncryptionKey); } byte[] encryptedData = Encoding.UTF8.GetBytes(decrypted); encryptedData = SteamKit2.CryptoHelper.SymmetricEncrypt(encryptedData, key); return Convert.ToBase64String(encryptedData); } catch (Exception e) { ASF.ArchiLogger.LogGenericException(e); return null; } }
public static byte[] ComputeHash(string password, byte[] salt) { var sha = new SHA256Cng(); return sha.ComputeHash(sha.ComputeHash(Encoding.UTF8.GetBytes(password)).Select((b, i) => (byte)(b ^ salt[i])).ToArray()); }
public static string CreateSessionId() { var sha = new SHA256Cng(); return sha.ComputeHash(Guid.NewGuid().ToByteArray()).Aggregate("", (s, b) => s += b.ToString("X")); }
private static string DecryptAES(string encrypted) { if (string.IsNullOrEmpty(encrypted)) { Logging.LogNullError(nameof(encrypted)); return null; } try { byte[] key; using (SHA256Cng sha256 = new SHA256Cng()) { key = sha256.ComputeHash(EncryptionKey); } byte[] decryptedData = Convert.FromBase64String(encrypted); decryptedData = SteamKit2.CryptoHelper.SymmetricDecrypt(decryptedData, key); return Encoding.UTF8.GetString(decryptedData); } catch (Exception e) { Logging.LogGenericException(e); return null; } }
private string ComputePasswordHash(string password, string salt) { var sha256 = new SHA256Cng(); password += salt; byte[] hash = sha256.ComputeHash(Encoding.Default.GetBytes(password)); return BitConverter.ToString(hash, 0); }
public static byte[] GetHash([NotNull]Stream inputStream, [CanBeNull] HashAlgorithm algorithm = null) { if (algorithm != null) return algorithm.ComputeHash(inputStream); using (algorithm = new SHA256Cng()) return algorithm.ComputeHash(inputStream); }
static Byte[] ComputeFIPS(Byte[] bytes) { SHA256Cng sha256 = new SHA256Cng(); return sha256.ComputeHash(bytes); }
public static byte[] GetHash([NotNull]byte[] buffer, int offset = 0, int count = -1, [CanBeNull] HashAlgorithm algorithm = null) { if (count < 0) count = buffer.Length; // ReSharper disable AssignNullToNotNullAttribute if (algorithm != null) return offset != 0 || count != buffer.Length ? algorithm.ComputeHash(buffer, offset, count) : algorithm.ComputeHash(buffer); using (algorithm = new SHA256Cng()) return offset != 0 || count != buffer.Length ? algorithm.ComputeHash(buffer, offset, count) : algorithm.ComputeHash(buffer); // ReSharper restore AssignNullToNotNullAttribute }
internal string GetChildActionUniqueId(ActionExecutingContext filterContext) { StringBuilder uniqueIdBuilder = new StringBuilder(); // Start with a prefix, presuming that we share the cache with other users uniqueIdBuilder.Append(CacheKeyPrefix); // Unique ID of the action description uniqueIdBuilder.Append(filterContext.ActionDescriptor.UniqueId); // Unique ID from the VaryByCustom settings, if any uniqueIdBuilder.Append(DescriptorUtil.CreateUniqueId(VaryByCustom)); if (!String.IsNullOrEmpty(VaryByCustom)) { string varyByCustomResult = filterContext.HttpContext.ApplicationInstance.GetVaryByCustomString(HttpContext.Current, VaryByCustom); uniqueIdBuilder.Append(varyByCustomResult); } // Unique ID from the VaryByParam settings, if any uniqueIdBuilder.Append(GetUniqueIdFromActionParameters(filterContext, SplitVaryByParam(VaryByParam))); // The key is typically too long to be useful, so we use a cryptographic hash // as the actual key (better randomization and key distribution, so small vary // values will generate dramtically different keys). using (SHA256Cng sha = new SHA256Cng()) { return Convert.ToBase64String(sha.ComputeHash(Encoding.UTF8.GetBytes(uniqueIdBuilder.ToString()))); } }