public string GetHashSha256(string token) { var bytes = Encoding.UTF8.GetBytes(token); var hasher = new SHA256Managed(); var hash = hasher.ComputeHash(bytes); return hash.Aggregate(string.Empty, (current, x) => current + string.Format("{0:x2}", x)); }
/// <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)); }
public static string HexSha256(string text) { const string salt = "jk#=¤)\"gld\"2347X#Z472\\!"; var hash = new SHA256Managed().ComputeHash(Encoding.ASCII.GetBytes(text + salt)); return hash.Aggregate("", (current, x) => current + string.Format("{0:x2}", x)); }
/// <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 ActionResult UserMGMT() { var users = (from u in dbContext.users join o in dbContext.organizations on u.organization_id equals o.organization_id join r in dbContext.roles on u.role_id equals r.role_id where u.active == true select new User { Email = u.email, OrganizationId = u.organization_id, Password = u.password, RoleId = u.role_id, UserId = u.user_id, RoleName = r.role_name, OrgName = o.orginization_name }); byte[] data; foreach (var u in users) { data = System.Text.Encoding.ASCII.GetBytes(u.Password); data = new System.Security.Cryptography.SHA256Managed().ComputeHash(data); String hash = System.Text.Encoding.ASCII.GetString(data); u.Password = hash; } return(View(users)); }
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 byte[] Encrypt(byte[] payload, CryptoContext cryptoContext) { var csEncrypt = cryptoContext.CryptoStreamOut; var output = cryptoContext.OutputStream; output.Position = 0; output.SetLength(0); using (MemoryStream hashStream = new MemoryStream()) { // hash SHA256Managed crypt = new SHA256Managed(); hashStream.Write(BitConverter.GetBytes(Interlocked.Increment(ref cryptoContext.SendCounter)), 0, 8); hashStream.Write(payload, 0, payload.Length); hashStream.Write(cryptoContext.Algorithm.Key, 0, cryptoContext.Algorithm.Key.Length); var hashBuffer = hashStream.ToArray(); byte[] validationCheckSum = crypt.ComputeHash(hashBuffer, 0, hashBuffer.Length); byte[] content = payload.Concat(validationCheckSum.Take(8)).ToArray(); csEncrypt.Write(content, 0, content.Length); csEncrypt.Flush(); } return output.ToArray(); }
public string sha256encrypt(string phrase) { SHA256Managed sha256 = new SHA256Managed(); byte[] hashedData = sha256.ComputeHash(encoder.GetBytes(phrase)); return byteArrayToString(hashedData); }
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()); }
public static string Encryption(string source, out string salt) { salt = Guid.NewGuid().ToString(); byte[] passwordAndSaltBytes = Encoding.UTF8.GetBytes(source + salt); byte[] hasBytes = new System.Security.Cryptography.SHA256Managed().ComputeHash(passwordAndSaltBytes); return(Convert.ToBase64String(hasBytes)); }
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 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 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); }
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(); }
/// <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); }
private string HashValues(string Value1, string Value2, string HashingAlgorithm) { string sHashingAlgorithm = ""; if (String.IsNullOrEmpty(HashingAlgorithm)) sHashingAlgorithm = "SHA-1"; else sHashingAlgorithm = HashingAlgorithm; byte[] arrByte; if (sHashingAlgorithm == "SHA-1") { SHA1Managed hash = new SHA1Managed(); arrByte = hash.ComputeHash(ASCIIEncoding.ASCII.GetBytes(Value1 + Value2)); } else { SHA256Managed hash = new SHA256Managed(); arrByte = hash.ComputeHash(ASCIIEncoding.ASCII.GetBytes(Value1 + Value2)); } string s = ""; for (int i = 0; i < arrByte.Length; i++) { s += arrByte[i].ToString("x2"); } return s; }
//public static string SecurePublishCode(string input, String salt) //{ // return GenerateSHA256Hash(input + salt); //} public static string GenerateSHA256Hash(string input) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(input); SHA256Managed sha256hashstring = new SHA256Managed(); byte[] hash = sha256hashstring.ComputeHash(bytes); return Encoding.Default.GetString(hash); }
private static string createHash(string password) { SHA256Managed hash = new SHA256Managed(); byte[] passwordBytes = Encoding.UTF8.GetBytes(password); byte[] hashBytes = hash.ComputeHash(passwordBytes); return Encoding.UTF8.GetString(hashBytes); }
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); }
//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> /// 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字节的字符串 }
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', '.'); }
/// <summary> /// konstruktor obiektu Server /// </summary> public Server() { requestReceived += Server_requestReceived; aesKeyGenerator = new AesManaged(); hashAlgorithm = new SHA256Managed(); rsaKeyGenerator = new RSACryptoServiceProvider(); }
//this method checks that passwords match in a login attempt public bool checkPassword() { Credentials userCredentials = SecurityUserDAO.getUserCredentials(username); if (userCredentials != null) { byte[] dbPass = Convert.FromBase64String(userCredentials.getPassword()); byte[] userPass = createByteArrayFromString(password); byte[] dbSalt = createByteArrayFromString(userCredentials.getSalt()); byte[] userSaltedPass = userPass.Concat(dbSalt).ToArray(); HashAlgorithm algorithm = new SHA256Managed(); byte[] hasheduserPass = algorithm.ComputeHash(userSaltedPass); bool match = compareByteArrays(dbPass, hasheduserPass); if (match) { userId = userCredentials.getUserId(); } return match; } else { return false; } }
public static byte[] SHA256(byte[] data, int offset, int count) { using (var sha = new SHA256Managed()) { return sha.ComputeHash(data, offset, count); } }
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)); }
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 static string sha256Hash(string strToHash) { SHA256Managed crypt = new SHA256Managed(); string hash = String.Empty; byte[] crypto = crypt.ComputeHash(Encoding.ASCII.GetBytes(strToHash), 0, Encoding.ASCII.GetByteCount(strToHash)); return crypto.Aggregate(hash, (current, theByte) => current + theByte.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(); } }
/// <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×Ö½ÚµÄ×Ö·û´® }
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(); }
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 Encryption(string source, out string salt) { salt = Guid.NewGuid().ToString(); byte[] passwordAndSaltBytes = Encoding.UTF8.GetBytes(source + salt); byte[] hasBytes = new System.Security.Cryptography.SHA256Managed().ComputeHash(passwordAndSaltBytes); return Convert.ToBase64String(hasBytes); }
// 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 static string Sha256Hash(byte[] ba) { SHA256Managed sha2 = new SHA256Managed(); byte[] ba2 = sha2.ComputeHash(ba); sha2 = null; return BitConverter.ToString(ba2).Replace("-", string.Empty).ToLower(); }
public void ButtonRegister_Click() { string username = "******"; string password = "******"; // random salt string salt = Guid.NewGuid().ToString(); // random salt // you can also use RNGCryptoServiceProvider class //System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider(); //byte[] saltBytes = new byte[36]; //rng.GetBytes(saltBytes); //string salt = Convert.ToBase64String(saltBytes); //string salt = ToHexString(saltBytes); byte[] passwordAndSaltBytes = System.Text.Encoding.UTF8.GetBytes(password + salt); byte[] hashBytes = new System.Security.Cryptography.SHA256Managed().ComputeHash(passwordAndSaltBytes); string hashString = Convert.ToBase64String(hashBytes); Console.WriteLine(hashString); Console.WriteLine(salt); // you can also use ToHexString to convert byte[] to string //string hashString = ToHexString(hashBytes); //连接数据库 //var db = new TestEntities(); //usercredential newRecord = usercredential.Createusercredential(username, hashString, salt); //db.usercredentials.AddObject(newRecord); //db.SaveChanges(); }
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()); }
public static byte[] SHA256(string str) { SHA256 sha = new SHA256Managed(); sha.Initialize(); //return sha.ComputeHash(str.ToByteArray()); return sha.ComputeHash(Encoding.UTF8.GetBytes(str)); }
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); }
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); }
/// <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)); }
//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 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加密返回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); }
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); }
//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 string GenPassword(string password) { byte[] data = System.Text.Encoding.ASCII.GetBytes(password); data = new System.Security.Cryptography.SHA256Managed().ComputeHash(data); String hash = System.Text.Encoding.ASCII.GetString(data); return(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))); } }
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 CreatePasswordHash(string inputString, string salt) { byte[] data = System.Text.Encoding.ASCII.GetBytes(salt + inputString); data = new System.Security.Cryptography.SHA256Managed().ComputeHash(data); String hash = System.Text.Encoding.ASCII.GetString(data); return(hash); }
/// <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 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 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)); }
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)); }
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加密,不可逆转 /// </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 static string getHashString(string password, string salt) { byte[] passwordAndSaltBytes = System.Text.Encoding.UTF8.GetBytes(password + salt); byte[] hashBytes = new System.Security.Cryptography.SHA256Managed().ComputeHash(passwordAndSaltBytes); string hashString = Convert.ToBase64String(hashBytes); return(hashString); }
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)); } }