private IodineObject sha256 (VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length <= 0) { vm.RaiseException (new IodineArgumentException (1)); return null; } byte[] bytes = new byte[]{}; byte[] hash = null; SHA256Managed hashstring = new SHA256Managed(); if (args[0] is IodineString) { bytes = System.Text.Encoding.UTF8.GetBytes (args[0].ToString ()); hash = hashstring.ComputeHash(bytes); } else if (args[0] is IodineByteArray) { bytes = ((IodineByteArray)args[0]).Array; hash = hashstring.ComputeHash(bytes); } else if (args[0] is IodineStream) { hash = hashstring.ComputeHash(((IodineStream)args[0]).File); } else { vm.RaiseException (new IodineTypeException ("Str")); return null; } return new IodineByteArray (hash); }
public static CompareResult Compare(Bitmap bmp1, Bitmap bmp2) { CompareResult cr = CompareResult.ciCompareOk; //Test to see if we have the same size of image if (bmp1.Size != bmp2.Size) { cr = CompareResult.ciSizeMismatch; } else { //Convert each image to a byte array System.Drawing.ImageConverter ic = new System.Drawing.ImageConverter(); byte[] btImage1 = new byte[1]; btImage1 = (byte[])ic.ConvertTo(bmp1, btImage1.GetType()); byte[] btImage2 = new byte[1]; btImage2 = (byte[])ic.ConvertTo(bmp2, btImage2.GetType()); //Compute a hash for each image SHA256Managed shaM = new SHA256Managed(); byte[] hash1 = shaM.ComputeHash(btImage1); byte[] hash2 = shaM.ComputeHash(btImage2); //Compare the hash values for (int i = 0; i < hash1.Length && i < hash2.Length && cr == CompareResult.ciCompareOk; i++) { if (hash1[i] != hash2[i]) cr = CompareResult.ciPixelMismatch; } } return cr; }
public static void DoubleSha256Test() { var innerExpected = new byte[] { 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad, }; var vector = Encoding.ASCII.GetBytes("abc"); var hasher = new SHA256Managed(); var innerDigest = hasher.ComputeHash(vector); Assert.Equal(innerDigest, innerExpected); var outerExpected = new byte[] { 0x4f, 0x8b, 0x42, 0xc2, 0x2d, 0xd3, 0x72, 0x9b, 0x51, 0x9b, 0xa6, 0xf6, 0x8d, 0x2d, 0xa7, 0xcc, 0x5b, 0x2d, 0x60, 0x6d, 0x05, 0xda, 0xed, 0x5a, 0xd5, 0x12, 0x8c, 0xc0, 0x3e, 0x6c, 0x63, 0x58, }; var outerDigest = hasher.ComputeHash(innerDigest); Assert.Equal(outerDigest, outerExpected); Assert.Equal(outerDigest, WalletSeed.DoubleSha256(vector)); }
private static readonly string[] Salts = { "QJhwzAtXL", "XzUhGYdFp", "NoCanLook" }; //lol, new salt isn't really being used #endregion Fields #region Methods public static List<byte[]> Retrieve(SQLiteConnection connection) { using (var sha256 = new SHA256Managed()) { var combinedSalt = Salts[1] + Salts[2]; //XzUhGYdFpNoCanLook var combinedHash = sha256.ComputeHash(Encoding.ASCII.GetBytes(combinedSalt)).ToHexString(); //8bd007187bc88b3a2e1371b6f5f4fa0719f8b45104841b382b18e671f8ba2057 var realSalt = combinedHash.Substring(11, 9); //88b3a2e13 var macs = NetworkInterface.GetAllNetworkInterfaces() .Where(iface => iface.NetworkInterfaceType != NetworkInterfaceType.Loopback) .Select(iface => iface.GetPhysicalAddress().ToMacString()) .Distinct() .Where(addr => !string.IsNullOrEmpty(addr)) .ToList(); var secrets = macs.Select(mac => realSalt + mac).ToList(); //88b3a2e13FF:FF:FF:FF:FF:FF //should select first active ethernet adapter var deviceIds = secrets.Select(secret => sha256.ComputeHash(Encoding.ASCII.GetBytes(secret)).ToHexString()).ToList(); var userIds = new List<string>(); using (var cmd = new SQLiteCommand("select UserID from user", connection)) using (var reader = cmd.ExecuteReader()) while (reader.Read()) userIds.Add(reader["UserID"] as string); var result = ( from userId in userIds from deviceId in deviceIds select Encoding.UTF8.GetBytes((deviceId + userId).Trim()) into key select sha256.ComputeHash(key) into hash select hash.Copy(hash.Length - 16) ).ToList(); //var strResult = result.Select(b => b.ToHexString()).Distinct().ToList(); return result; } }
public static String FromByteArray(Byte[] b, Byte version) { SHA256 sha256 = new SHA256Managed(); b = (new Byte[] { version }).Concat(b).ToArray(); Byte[] hash = sha256.ComputeHash(sha256.ComputeHash(b)).Take(4).ToArray(); return Base58String.FromByteArray(b.Concat(hash).ToArray()); }
// Returned array contains the double SHA256 hash. public static byte[] DoubleSha256(byte[] value) { using (var hasher = new SHA256Managed()) { var intermediateHash = hasher.ComputeHash(value); return hasher.ComputeHash(intermediateHash); } }
public static PrivateKey FromMiniKey(String s) { SHA256 sha256 = new SHA256Managed(); Byte[] b = Encoding.ASCII.GetBytes(s); if (sha256.ComputeHash(b.Concat(new Byte[] { (Byte)'?' }).ToArray()).First() != 0x00) throw new ArgumentException("Invalid miniKey"); return new PrivateKey(sha256.ComputeHash(b)); }
/// <summary> /// Calculates SHA256(SHA256(byte range 1 + byte range 2)). /// </summary> public static byte[] DoubleDigestTwoBuffers(byte[] input1, int offset1, int length1, byte[] input2, int offset2, int length2) { var algorithm = new SHA256Managed(); var buffer = new byte[length1 + length2]; Array.Copy(input1, offset1, buffer, 0, length1); Array.Copy(input2, offset2, buffer, length1, length2); var first = algorithm.ComputeHash(buffer, 0, buffer.Length); return algorithm.ComputeHash(first); }
public static byte[] Hash(byte[] bytes, int offset, int count) { using (var x = new SHA256Managed()) { var hash1 = x.ComputeHash(bytes, offset, count); var hash2 = x.ComputeHash(hash1); return hash2; } }
public static Byte[] ToByteArray(String s, out Byte version) { SHA256 sha256 = new SHA256Managed(); Byte[] b = Base58String.ToByteArray(s); Byte[] hash = sha256.ComputeHash(sha256.ComputeHash(b.Take(b.Length - 4).ToArray())); if (!hash.Take(4).SequenceEqual(b.Skip(b.Length - 4).Take(4))) throw new ArgumentException("Invalid Base58Check String"); version = b.First(); return b.Skip(1).Take(b.Length - 5).ToArray(); }
public Message(String command, IPayload payload, bool TestNet = false) { SHA256 sha256 = new SHA256Managed(); Byte[] payloadBytes = payload.ToBytes(); if (!TestNet) this.magic = 0xD9B4BEF9; else this.magic = 0x0709110B; this.command = Encoding.ASCII.GetBytes(command).Concat(new Byte[12 - command.Length]).ToArray(); this.length = (UInt32)payloadBytes.Length; this.checksum = sha256.ComputeHash(sha256.ComputeHash(payloadBytes)).Take(4).ToArray(); this.payload = payload; }
public static string GetHash(string secretKey,string date, string body) { byte[] hashArray; using (var encryptor = new SHA256Managed()) { var payloadByteArray = Encoding.UTF8.GetBytes(string.Concat(secretKey,secretKey)); var payload = string.Concat(Convert.ToBase64String(encryptor.ComputeHash(payloadByteArray)), date, body); payloadByteArray = Encoding.UTF8.GetBytes(payload); hashArray = encryptor.ComputeHash(payloadByteArray); } var hash = Convert.ToBase64String(hashArray); return hash; }
public string HashFile(string path) { try { var fi = new FileInfo(path); byte[] bytes = new byte[3072]; string raw = ""; string hash = ""; var sha256 = new SHA256Managed(); FileStream fs = System.IO.File.OpenRead(path); if (fi.Length > 3072) { long middle = (long)Math.Floor((double)fi.Length / (double)2); long last = fi.Length - 1024; fs.Seek(0, SeekOrigin.Begin); fs.Read(bytes, 0, 1024); fs.Seek(middle, SeekOrigin.Current); fs.Read(bytes, 1024, 1024); fs.Seek(last, SeekOrigin.Current); fs.Read(bytes, 2048, 1024); raw = ByteToString(bytes); hash = ByteToString(sha256.ComputeHash(Encoding.UTF8.GetBytes(raw))) + fi.Length.ToString(); } else { hash = ByteToString(sha256.ComputeHash(fs)) + fi.Length.ToString(); } fs.Close(); return hash; } catch (FileNotFoundException ex) { // file not found Logger.Write(ex.Message); } catch (IOException ex) { // file could not be accessed // warn user and try again on OK Logger.Write("Error, " + ex.Message); } return null; }
public static byte[] SHA256(string str) { byte[] SHA256Data = Encoding.UTF8.GetBytes(str); System.Security.Cryptography.SHA256Managed Sha256 = new System.Security.Cryptography.SHA256Managed(); byte[] by = Sha256.ComputeHash(SHA256Data); return(by); }
public static string SHA256(string strToHash) { System.Security.Cryptography.SHA256Managed sha256Obj = new System.Security.Cryptography.SHA256Managed(); byte[] bytesToHash = System.Text.Encoding.UTF8.GetBytes(strToHash); bytesToHash = sha256Obj.ComputeHash(bytesToHash); return(BitConverter.ToString(bytesToHash).Replace("-", "").ToUpper()); }
/// <summary> /// </summary> /// <param name="data"></param> /// <returns></returns> public static string Sha256(string data) { byte[] bytes = Encoding.UTF8.GetBytes(data); var hashstring = new SHA256Managed(); byte[] hash = hashstring.ComputeHash(bytes); return hash.Aggregate(string.Empty, (current, x) => current + String.Format("{0:x2}", x)); }
protected virtual string GetBundleVirtualPath(string prefix, string postfix, string[] parts) { if (parts == null || parts.Length == 0) throw new ArgumentException("parts"); //calculate hash var hash = ""; using (SHA256 sha = new SHA256Managed()) { // string concatenation var hashInput = ""; foreach (var part in parts) { hashInput += part; hashInput += ","; } byte[] input = sha.ComputeHash(Encoding.Unicode.GetBytes(hashInput)); hash = HttpServerUtility.UrlTokenEncode(input); } //ensure only valid chars hash = SeoExtensions.GetSeName(hash); var sb = new StringBuilder(prefix); sb.Append(hash); sb.Append(postfix); return sb.ToString(); }
public static string Sha256(string password) { SHA256Managed crypt = new SHA256Managed(); string hash = String.Empty; byte[] crypto = crypt.ComputeHash(Encoding.UTF8.GetBytes(password), 0, Encoding.UTF8.GetByteCount(password)); return crypto.Aggregate(hash, (current, bit) => current + bit.ToString("x2")); }
public override string Encrypt(string data) { SHA256Managed sha256hasher = new SHA256Managed(); try { UTF8Encoding encoder = new UTF8Encoding(); byte[] hashedDataBytes = sha256hasher.ComputeHash(encoder.GetBytes(string.Format(base.hashFormat, data))); return Convert.ToBase64String(hashedDataBytes); } catch (Exception e) { var exception = new CryptologyException("SHA256Encryptor.Encrypt()", "An error occurred while encrypting.", e); exception.Data.Add("hashFormat", hashFormat); exception.Data.Add("data", data); throw exception; } finally { sha256hasher.Dispose(); } }
public static string SHA256(string str) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(str); System.Security.Cryptography.SHA256Managed sHA256Managed = new System.Security.Cryptography.SHA256Managed(); byte[] inArray = sHA256Managed.ComputeHash(bytes); return(System.Convert.ToBase64String(inArray)); }
public static string GenerateSaltedHash(string userName, string pssWd) { if (userName ==null || pssWd == null) { return null; } byte[] userNameBytes = GetBytes(userName); byte[] pssWdBytes = GetBytes(pssWd); HashAlgorithm algorithm = new SHA256Managed(); byte[] plainTextWithSaltBytes = new byte[userNameBytes.Length + pssWdBytes.Length]; for (int i = 0; i < userNameBytes.Length; i++) { plainTextWithSaltBytes[i] = userNameBytes[i]; } for (int i = 0; i < pssWdBytes.Length; i++) { plainTextWithSaltBytes[userNameBytes.Length + i] = pssWdBytes[i]; } byte[] hash = algorithm.ComputeHash(plainTextWithSaltBytes); StringBuilder sBuilder = new StringBuilder(); for (int i = 0; i < hash.Length; i++) { sBuilder.Append(hash[i].ToString("x2")); } return sBuilder.ToString(); }
public static string sha256encrypt(string phrase) { UTF8Encoding encoder = new UTF8Encoding(); SHA256Managed sha256hasher = new SHA256Managed(); byte[] hashedDataBytes = sha256hasher.ComputeHash(encoder.GetBytes(phrase)); return byteArrayToString(hashedDataBytes); }
public static string EncryptPassword(string password, byte[] salt) { // Convert the plain string pwd into bytes byte[] plainTextBytes = Encoding.UTF8.GetBytes(password); // Append salt to pwd before hashing byte[] combinedBytes = new byte[plainTextBytes.Length + salt.Length]; System.Buffer.BlockCopy(plainTextBytes, 0, combinedBytes, 0, plainTextBytes.Length); System.Buffer.BlockCopy(salt, 0, combinedBytes, plainTextBytes.Length, salt.Length); // Create hash for the pwd+salt System.Security.Cryptography.HashAlgorithm hashAlgo = new System.Security.Cryptography.SHA256Managed(); byte[] hash = hashAlgo.ComputeHash(combinedBytes); var hashString = GetString(hash); var saltString = GetString(salt); var passwordHash = string.IsNullOrWhiteSpace(saltString) ? hashString : $"{hashString}.{saltString}"; var hashBytes = GetBytes(hashString).ToArray(); var hashString2 = GetString(hashBytes); if (hashString != hashString2) { throw new SecurityException("Hashes are not equal. There is some bug."); } return(passwordHash); }
public static String SHA256(String text) { UTF8Encoding encoder = new UTF8Encoding(); SHA256Managed sha256hasher = new SHA256Managed(); byte[] hashedDataBytes = sha256hasher.ComputeHash(encoder.GetBytes(text)); return System.Convert.ToBase64String(hashedDataBytes); }
/// <summary> /// check user password /// </summary> /// <param name="password">submitted password</param> /// <returns>hashed password</returns> public string CheckUserPassword(string password) { //return FormsAuthentication.HashPasswordForStoringInConfigFile(password, "md5"); //string salt = GenerateSalt(); //start hash creation: System.Security.Cryptography.SHA256 sha256 = new System.Security.Cryptography.SHA256Managed(); // password string to bytes byte[] sha256Bytes = System.Text.Encoding.UTF8.GetBytes(password); //password bytes to hash byte[] cryString = sha256.ComputeHash(sha256Bytes); // start final encrypted password string sha256Str = string.Empty; // create final encrypted password: bytes to hex string for (int i = 0; i < cryString.Length; i++) { sha256Str += cryString[i].ToString("X"); } // concatenate hashed password + salt // sha256Str = sha256Str + salt; return(sha256Str); }
public string sha256encrypt(string phrase) { SHA256Managed sha256 = new SHA256Managed(); byte[] hashedData = sha256.ComputeHash(encoder.GetBytes(phrase)); return byteArrayToString(hashedData); }
//pass in entered PW as parameter; hashes it and compared to stored PW public bool comparePW(string enteredPW)//returns true if match; false if not { bool ret; if (IsHashed == false) { hashPW(); } using (var sha = new System.Security.Cryptography.SHA256Managed()) { byte[] textData = System.Text.Encoding.UTF8.GetBytes(enteredPW); byte[] hash = sha.ComputeHash(textData); enteredPW = BitConverter.ToString(hash).Replace("-", String.Empty); } if (enteredPW == PW) { ret = true; } else { ret = false; } return(ret); }
/// <summary> /// Encrypts the user's password /// </summary> /// <param name="password"></param> /// <returns></returns> public string EncryptUserPassword(string password) { //return FormsAuthentication.HashPasswordForStoringInConfigFile(password, "md5"); string salt = GenerateSalt(); //start hash creation: System.Security.Cryptography.SHA256 sha256 = new System.Security.Cryptography.SHA256Managed(); // password string to bytes byte[] sha256Bytes = System.Text.Encoding.UTF8.GetBytes(password); //password bytes to hash byte[] cryString = sha256.ComputeHash(sha256Bytes); // start final encrypted password string sha256Str = string.Empty; // create final encrypted password: bytes to hex string for (int i = 0; i < cryString.Length; i++) { sha256Str += cryString[i].ToString("X"); } // concatenate hashed password + salt // sha256Str = sha256Str + salt; return sha256Str; }
public static string Sha256Hash(byte[] ba) { SHA256Managed sha2 = new SHA256Managed(); byte[] ba2 = sha2.ComputeHash(ba); sha2 = null; return BitConverter.ToString(ba2).Replace("-", string.Empty).ToLower(); }
private string GetHash(string key) { using var sha = new System.Security.Cryptography.SHA256Managed(); byte[] textData = System.Text.Encoding.UTF8.GetBytes(key); byte[] hash = sha.ComputeHash(textData); return(BitConverter.ToString(hash).Replace("-", string.Empty)); }
/// <summary> /// SHA256º¯Êý /// </summary> /// /// /// <param name="str">Ôʼ×Ö·û´®</param> /// <returns>SHA256½á¹û</returns> public static string SHA256(string str) { var SHA256Data = Encoding.UTF8.GetBytes(str); var Sha256 = new SHA256Managed(); var Result = Sha256.ComputeHash(SHA256Data); return Convert.ToBase64String(Result); //·µ»Ø³¤¶ÈΪ44×Ö½ÚµÄ×Ö·û´® }
protected string ComputeHashString(string rawString) { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); SHA256 hashM = new SHA256Managed(); return encoding.GetString(hashM.ComputeHash(encoding.GetBytes(rawString))). Replace(',', '.').Replace('\r', '.').Replace('\n', '.'); }
public static void ExecuteMongo() { const string connectionString = "mongodb://localhost"; var client = new MongoClient(connectionString); var server = client.GetServer(); var database = server.GetDatabase("Polyglot"); var directory = database.GetCollection<RootDirectory>("rootdirectory"); directory.Remove(new QueryDocument()); byte[] inputBytes = System.Text.Encoding.Unicode.GetBytes("password");//will need to change to being the user input SHA256Managed hashstring = new SHA256Managed(); byte[] dbHash = hashstring.ComputeHash(inputBytes); directory.Insert(new RootDirectory() { _id = ObjectId.GenerateNewId().ToString(), un = "harageth", pw = System.Text.Encoding.UTF8.GetString(dbHash),//need to encrypt this password folders = new List<Folder>() { new Folder() { folderName = "firstFolder", files = new List<string>() { "temp1.txt", "file1.txt" } }, new Folder() { folderName = "secondFolder", files = new List<string>() { "temp2.txt", "file2.txt" } }, new Folder() { folderName = "thirdFolder", files = new List<string>() { "temp3.txt", "file3.txt" } } }, files = new List<string>( ) { "temp.txt", "file.txt" } }); directory.Insert(new RootDirectory() { _id = ObjectId.GenerateNewId().ToString(), un = "Guest", //folders = new List<Folder>() { new Folder() { folderName = "firstFolder", files = new List<string>() { "temp1.txt", "file1.txt" } }, new Folder() { folderName = "secondFolder", files = new List<string>() { "temp2.txt", "file2.txt" } }, new Folder() { folderName = "thirdFolder", files = new List<string>() { "temp3.txt", "file3.txt" } } }, //files = new List<string>() { "temp.txt", "file.txt" } }); }
protected virtual string GetBundleVirtualPath(string prefix, string extension, string[] parts) { if (parts == null || parts.Length == 0) throw new ArgumentException("parts"); //calculate hash var hash = ""; using (SHA256 sha = new SHA256Managed()) { // string concatenation var hashInput = ""; foreach (var part in parts) { hashInput += part; hashInput += ","; } byte[] input = sha.ComputeHash(Encoding.Unicode.GetBytes(hashInput)); hash = HttpServerUtility.UrlTokenEncode(input); } //ensure only valid chars hash = SeoExtensions.GetSeName(hash); var sb = new StringBuilder(prefix); sb.Append(hash); //we used "extension" when we had "runAllManagedModulesForAllRequests" set to "true" in web.config //now we disabled it. hence we should not use "extension" //sb.Append(extension); return sb.ToString(); }
/// <summary> /// SHA256函数 /// </summary> /// /// <param name="str">原始字符串</param> /// <returns>SHA256结果</returns> public static string SHA256(string str) { byte[] SHA256Data = Encoding.UTF8.GetBytes(str); SHA256Managed Sha256 = new SHA256Managed(); byte[] Result = Sha256.ComputeHash(SHA256Data); return Convert.ToBase64String(Result); //返回长度为44字节的字符串 }
// Taken from http://dotnetpulse.blogspot.com/2007/12/sha1-hash-calculation-in-c.html private static string Sha1HashOfString(string input) { byte[] buffer = Encoding.Unicode.GetBytes(input); var crypto = new SHA256Managed(); return BitConverter.ToString(crypto.ComputeHash(buffer)).Replace("-", ""); }
public ActionResult DevEditPost(DevEditViewModel editVm) { var repo = new Repository(); var original = GetDevEditViewModel(editVm.Id); original.Message = editVm.Message; var asc = new WebClient().DownloadData(repo.GetASCLink(editVm.Id)); string extracted; if(!CryptoHelper.VerifySig(asc, editVm.Message, out extracted)) { ModelState.AddModelError("Message", "Incorrectly signed"); } else { byte[] hash = null; using(SHA256 sha = new SHA256Managed()) { hash = sha.ComputeHash(Encoding.UTF8.GetBytes(extracted)); } if(repo.SaveHash(hash)) { repo.UpdateDevViewModel(original); return RedirectToAction("Dev", "Main", new { devId = editVm.Id }); } else { ModelState.AddModelError("Message", "You can't replay an old message"); } } return View("DevEdit", original); }
public static byte[] Sha256(string hashInput) { System.Security.Cryptography.SHA256 sha256 = new System.Security.Cryptography.SHA256Managed(); byte[] hash; hash = Encoding.ASCII.GetBytes(hashInput); hash = sha256.ComputeHash(hash); return(hash); }
public static byte[] Sha256b(string input) { var crypt = new System.Security.Cryptography.SHA256Managed(); var hash = new System.Text.StringBuilder(); byte[] crypto = crypt.ComputeHash(System.Text.Encoding.ASCII.GetBytes(input)); return(crypto); }
/// <summary> /// SHA256加密,不可逆转 /// </summary> /// <param name="str">string str:被加密的字符串</param> /// <returns>返回加密后的字符串</returns> private static string SHA256Encrypt(string str) { System.Security.Cryptography.SHA256 s256 = new System.Security.Cryptography.SHA256Managed(); byte[] byte1; byte1 = s256.ComputeHash(Encoding.Default.GetBytes(str)); s256.Clear(); return(Convert.ToBase64String(byte1)); }
/// <summary> /// SHA256加密 /// </summary> /// <param name="data">数据</param> /// <returns></returns> // ReSharper disable once InconsistentNaming public static string SHA256(string data) { var byteData = Encoding.UTF8.GetBytes(data); var sha256 = new SHA256Managed(); var result = sha256.ComputeHash(byteData); return(BitConverter.ToString(result).Replace("-", "").ToLower()); }
//public string GenerateSHA256Hash(string secretkey, string timestamp, string apiKey) //{ // try // { // var secretKeyByteArray = Convert.FromBase64String(secretkey); // //var secretKeyByteArray = Encoding.UTF8.GetBytes(secretkey); // string input = $"{apiKey}{timestamp}"; // byte[] signature = Encoding.UTF8.GetBytes(input); // using (HMACSHA256 hmac = new HMACSHA256(secretKeyByteArray)) // { // byte[] signatureBytes = hmac.ComputeHash(signature); // return Convert.ToBase64String(signatureBytes); // } // } // catch (Exception ex) // { // logger.Error(ex); // return ""; // } //} public string GenerateSHA256Hash(string secretkey, string timestamp, string apikey, string recieptref) { string input = $"{secretkey}{timestamp}{apikey}{recieptref}"; var shama = new System.Security.Cryptography.SHA256Managed(); byte[] crypto = shama.ComputeHash(Encoding.UTF8.GetBytes(input)); return(Convert.ToBase64String(crypto)); }
public string GenerateSHA256Hash(String input, String salt) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(input + salt); System.Security.Cryptography.SHA256Managed sHAHashString = new System.Security.Cryptography.SHA256Managed(); byte[] hash = sHAHashString.ComputeHash(bytes); return(ByteArrayToHexString(hash)); }
/// <summary> /// sha256加密返回base64编码 /// </summary> /// <param name="strIN"></param> /// <returns></returns> public static byte[] SHA256EncryptOutByte(string strIN) { System.Security.Cryptography.SHA256 s256 = new System.Security.Cryptography.SHA256Managed(); byte[] byte1; byte1 = s256.ComputeHash(Encoding.Default.GetBytes(strIN)); s256.Clear(); return(byte1); }
/// <summary> /// SHA256加密,不可逆转 /// </summary> /// <param name="obj"></param> /// <returns></returns> public static string ToSHA256(this string obj) { System.Security.Cryptography.SHA256 s256 = new System.Security.Cryptography.SHA256Managed(); byte[] byte1; byte1 = s256.ComputeHash(Encoding.Default.GetBytes(obj)); s256.Clear(); return(BitConverter.ToString(byte1).Replace("-", "")); }
private String GenerateSHA256Hash(String input, String salt) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(input + salt); System.Security.Cryptography.SHA256Managed hashString = new System.Security.Cryptography.SHA256Managed(); byte[] hash = hashString.ComputeHash(bytes); return(Convert.ToBase64String(hash)); }
public static string SHA256Hash(string textinput, string salted) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(textinput + salted); System.Security.Cryptography.SHA256Managed sha256str = new System.Security.Cryptography.SHA256Managed(); byte[] hash = sha256str.ComputeHash(bytes); return(ByteArrayToHexString(hash)); }
static byte[] GenerateSaltedHash(String passwordString, byte[] salt) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(passwordString + salt); System.Security.Cryptography.SHA256Managed bytesToHash = new System.Security.Cryptography.SHA256Managed(); byte[] hash = bytesToHash.ComputeHash(bytes); return(hash); }
//concatena un string y un salt y los hashea juntos. public static string HashIt(string toHash, string salt) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(toHash + salt); System.Security.Cryptography.SHA256Managed sha256String = new System.Security.Cryptography.SHA256Managed(); byte[] newhash = sha256String.ComputeHash(bytes); return(Convert.ToBase64String(newhash)); }
public static string SHA256Encrypt(string str) { System.Security.Cryptography.SHA256 s256 = new System.Security.Cryptography.SHA256Managed(); byte[] byte1; byte1 = s256.ComputeHash(Encoding.Default.GetBytes(str)); s256.Clear(); return(BitConverter.ToString(byte1).Replace("-", "").ToLower()); //64 }
public static String GenerateSHA256(String input, String salt) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(input + salt); System.Security.Cryptography.SHA256Managed sha256hashstring = new System.Security.Cryptography.SHA256Managed(); byte[] hash = sha256hashstring.ComputeHash(bytes); return(BitConverter.ToString(hash)); }
private static Byte[] obtenerEncriptacion(String value) { // ToDo: Mejorar esta seccion para una mejor encriptacion. using (var sha = new System.Security.Cryptography.SHA256Managed( )) { return(sha.ComputeHash(Encoding.UTF8.GetBytes(value))); } }
public string HashPassword(string givenPassword, string salt) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(givenPassword + salt); System.Security.Cryptography.SHA256Managed sha256hashString = new System.Security.Cryptography.SHA256Managed(); byte[] hash = sha256hashString.ComputeHash(bytes); return(ByteArrayToHexString(hash)); }
public static string HashSHA256(string password) { using (System.Security.Cryptography.SHA256Managed crypt = new System.Security.Cryptography.SHA256Managed()) { System.Text.StringBuilder hash = new System.Text.StringBuilder(); byte[] bytes = crypt.ComputeHash(Encoding.UTF8.GetBytes(password), 0, Encoding.UTF8.GetByteCount(password)); return(ExtensionsString.BytesToHex(bytes)); } }
private static string encryptPassword(string password, string salt) { byte[] bytes = Encoding.UTF8.GetBytes(password + salt); var sha256HashString = new System.Security.Cryptography.SHA256Managed(); byte[] hash = sha256HashString.ComputeHash(bytes); return(Convert.ToBase64String(hash) + " " + salt); }
public String GjeneroSHA256Hashin(String hyrja, String salt) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(hyrja + salt); System.Security.Cryptography.SHA256Managed sha256hashstring = new System.Security.Cryptography.SHA256Managed(); byte[] hash = sha256hashstring.ComputeHash(bytes); return(Convert.ToBase64String(hash)); }
public static string GetStringSha256Hash(string text) { using (var sha = new System.Security.Cryptography.SHA256Managed()) { byte[] textData = System.Text.Encoding.UTF8.GetBytes(text); byte[] hash = sha.ComputeHash(textData); return(BitConverter.ToString(hash).Replace("-", string.Empty)); } }
public static string GenerateSHA256Hash(string input) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(input); System.Security.Cryptography.SHA256Managed sha256hashstring = new System.Security.Cryptography.SHA256Managed(); byte[] hash = sha256hashstring.ComputeHash(bytes); string base64 = Convert.ToBase64String(hash); return(base64); }
public string GetFileSHA256(Stream stream) { using (var bufferedStream = new BufferedStream(stream, 1024 * 32)) { var sha = new System.Security.Cryptography.SHA256Managed(); byte[] checksum = sha.ComputeHash(bufferedStream); return(BitConverter.ToString(checksum).Replace("-", String.Empty).ToLower()); } }
public static byte[] Encrypt(byte[] Data, byte[] Password) { System.Security.Cryptography.HashAlgorithm hashType = new System.Security.Cryptography.SHA256Managed(); byte[] Hash = hashType.ComputeHash(Password); var Result = new byte[Data.Length]; int p = 0; for (int i = 0; i < Data.Length - 1; i++) { Result[i] = (byte)(Data[i] ^ Hash[p]); p += 1; if (p == Hash.Length) { p = 0; Hash = hashType.ComputeHash(Hash); } } return(Result); }