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; }
public static string CreateHashedPassword(string password, string salt) { var sha256 = new SHA256CryptoServiceProvider(); byte[] passwordBytes = System.Text.Encoding.UTF8.GetBytes(password + salt); byte[] hashedPasswordBytes = sha256.ComputeHash(passwordBytes); return Convert.ToBase64String(hashedPasswordBytes); }
/// <summary> /// Hashes the specified arguments. /// </summary> /// <param name="args">The arguments.</param> /// <returns>The hash</returns> public static string Hash(params object[] args) { HashAlgorithm hashAlg = new SHA256CryptoServiceProvider(); byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(String.Concat(args)); byte[] bytHash = hashAlg.ComputeHash(bytValue); return Convert.ToBase64String(bytHash); }
static async Task MainAsync(string[] args) { var keyClient = new KeyVaultClient((authority, resource, scope) => { var adCredential = new ClientCredential(applicationId, applicationSecret); var authenticationContext = new AuthenticationContext(authority, null); return authenticationContext.AcquireToken(resource, adCredential).AccessToken; }); // Get the key details var keyIdentifier = "https://testvaultrahul.vault.azure.net/keys/rahulkey/0f653b06c1d94159bc7090596bbf7784"; var key = await keyClient.GetKeyAsync(keyIdentifier); var publicKey = Convert.ToBase64String(key.Key.N); using (var rsa = new RSACryptoServiceProvider()) { var p = new RSAParameters() { Modulus = key.Key.N, Exponent = key.Key.E }; rsa.ImportParameters(p); var byteData = Encoding.Unicode.GetBytes(textToEncrypt); // Encrypt and Decrypt var encryptedText = rsa.Encrypt(byteData, true); var decryptedData = await keyClient.DecryptDataAsync(keyIdentifier, "RSA_OAEP", encryptedText); var decryptedText = Encoding.Unicode.GetString(decryptedData.Result); // Sign and Verify var hasher = new SHA256CryptoServiceProvider(); var digest = hasher.ComputeHash(byteData); var signature = await keyClient.SignAsync(keyIdentifier, "RS256", digest); var isVerified = rsa.VerifyHash(digest, "Sha256", signature.Result); } }
internal static string GenerateHash(this string input) { HashAlgorithm hashAlgorithm = new SHA256CryptoServiceProvider(); var byteValue = System.Text.Encoding.UTF8.GetBytes(input); var byteHash = hashAlgorithm.ComputeHash(byteValue); return Convert.ToBase64String(byteHash); }
protected void TestButton_Click(object sender, EventArgs e) { // Define key and data string. var k = "test key"; var s = "Encoding-编码-암호화-表現形式"; var kb = System.Text.Encoding.UTF8.GetBytes(k); var sb = System.Text.Encoding.UTF8.GetBytes(s); // Test SHA256. WriteLog("// Create SHA256 Algorithm"); var sha256 = new System.Security.Cryptography.SHA256CryptoServiceProvider(); var hash = System.BitConverter.ToString(sha256.ComputeHash(sb)); WriteLog("sha256.ComputeHash('" + s + "') = " + hash); //WriteLog("// Create SHA256 Algorithm"); //var sha2 = new SHA256Managed(); //hash = System.BitConverter.ToString(sha2.ComputeHash(sb)); //WriteLog("sha2.ComputeHash('" + s + "') = " + hash); //WriteLog(sha2.Log.ToString()); // Test HMACSHA256. Trace.Write("// Create HMAC-SHA256 Algorithm"); var hmac = new System.Security.Cryptography.HMACSHA256(kb); hash = System.BitConverter.ToString(hmac.ComputeHash(sb)); WriteLog("hmac.ComputeHash('" + k + "','" + s + "') = " + hash); }
protected string GenerateCacheKeyHash(int tabId, string cacheKey) { byte[] hash = Encoding.ASCII.GetBytes(cacheKey); var sha256 = new SHA256CryptoServiceProvider(); hash = sha256.ComputeHash(hash); return string.Concat(tabId.ToString(), "_", ByteArrayToString(hash)); }
private String EncriptarPassword(String password) { byte[] passwordBytes = Encoding.UTF8.GetBytes(password); SHA256 sha256 = new SHA256CryptoServiceProvider(); byte[] hashedPassword = sha256.ComputeHash(passwordBytes); return BitConverter.ToString(hashedPassword).Replace("-",""); }
public static string Encrypt(string clearText) { byte[] arrbyte = new byte[clearText.Length]; SHA256 hash = new SHA256CryptoServiceProvider(); arrbyte = hash.ComputeHash(Encoding.UTF8.GetBytes(clearText)); return Convert.ToBase64String(arrbyte); }
public static string Hash(this string clear_text) { using (HashAlgorithm hash = new SHA256CryptoServiceProvider()) { return Convert.ToBase64String(hash.ComputeHash(Encoding.UTF8.GetBytes(clear_text))); } }
public string CreateDoctorAcccount(string email, string dname, string pwd, string cfmpwd, string mobileno, string dob, string pip) { if (dname.Length == 0) returnMessage += "Therapist Name cannot be blank <br />"; if (pwd.Length == 0) returnMessage += "Password cannot be blank <br/>"; if (cfmpwd.Length == 0) returnMessage += "Cofirm Passowrd cannot be blank <br/>"; if (mobileno.Length == 0) returnMessage += "Mobile Number cannot be blank <br/>"; if (dob.Length == 0) returnMessage += "Date of Birth cannnot be blank <br/>"; if (pip.Length == 0) returnMessage += "Please Upload an image <br/>"; if (pwd != cfmpwd) returnMessage += "Your passwords dont match <br/>"; if (returnMessage.Length == 0) { SHA256 sha = new SHA256CryptoServiceProvider(); byte[] data = Encoding.ASCII.GetBytes(pwd); byte[] result = sha.ComputeHash(data); string hashedpwd = Convert.ToBase64String(result); AzureUserDAL doc = new AzureUserDAL(email, dname, hashedpwd, mobileno, dob, pip); int noofRows = 0; noofRows = doc.CreateDoctorProfile(); if (noofRows > 0) returnMessage = "You Signed Up Succuesfully."; else returnMessage = "Error,Please try again"; } return returnMessage; }
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; }
public static bool ValidatePathWithEncodedRSAPKCS1SignatureAndPublicRSAKey(string path, string base64Signature, string publicKey) { try { byte[] signature = Convert.FromBase64String(base64Signature); byte[] data = File.ReadAllBytes(path); SHA256CryptoServiceProvider cryptoTransformSHA256 = new SHA256CryptoServiceProvider(); byte[] sha256Hash = cryptoTransformSHA256.ComputeHash(data); string cleanKey = ""; string[] lines = publicKey.Split(new char[] {'\n', '\r'}); foreach (string line in lines) { cleanKey += line.Trim(); } byte[] publicKeyData = Convert.FromBase64String(cleanKey); RSACryptoServiceProvider provider = new RSACryptoServiceProvider(); provider.ImportCspBlob(publicKeyData); RSAPKCS1SignatureDeformatter formatter = new RSAPKCS1SignatureDeformatter(provider); formatter.SetHashAlgorithm("SHA256"); return formatter.VerifySignature(sha256Hash, signature); } catch (Exception ex) { Console.WriteLine(ex.Message); return false; } }
public static string CalculateSha256(string text, Encoding enc) { byte[] buffer = enc.GetBytes(text); using (var cryptoTransformSha1 = new SHA256CryptoServiceProvider()) return BitConverter.ToString(cryptoTransformSha1.ComputeHash(buffer)).Replace("-", ""); }
public static void Signature(Stream input, Stream output, string privateKey) { using (var sha = new SHA256CryptoServiceProvider()) using (var rsa = new RSACryptoServiceProvider()) { // Compute hash var buffer = ReadAllBytes(input); var hash = sha.ComputeHash(buffer); // RSA Initialize rsa.FromXmlString(privateKey); // format var formatter = new RSAPKCS1SignatureFormatter(rsa); formatter.SetHashAlgorithm("SHA256"); var signature = formatter.CreateSignature(hash); // Krile Signature Package var magic = MagicStr + ":" + signature.Length + ":"; var magicbytes = Encoding.UTF8.GetBytes(magic); if (magicbytes.Length > 64) throw new Exception("Magic bits too long."); output.Write(magicbytes, 0, magicbytes.Length); var padding = new byte[64 - magicbytes.Length]; output.Write(padding, 0, padding.Length); output.Write(signature, 0, signature.Length); output.Write(buffer, 0, buffer.Length); } }
/// <summary> /// Encrypts the given string with SHA256. /// </summary> /// <param name="str">The string</param> /// <returns>The encrypted</returns> private string Encrypt(string str) { UTF8Encoding encoder = new UTF8Encoding() ; SHA256CryptoServiceProvider crypto = new SHA256CryptoServiceProvider() ; byte[] bytes = crypto.ComputeHash(encoder.GetBytes(str)) ; return Convert.ToBase64String(bytes) ; }
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); }
private string GenerateCacheKeyHash(int tabModuleId, string cacheKey) { byte[] hash = Encoding.ASCII.GetBytes(cacheKey); var sha256 = new SHA256CryptoServiceProvider(); hash = sha256.ComputeHash(hash); return tabModuleId + "_" + ByteArrayToString(hash); }
public string SHA256(string input) { HashAlgorithm algorithm = new SHA256CryptoServiceProvider(); Byte[] inputBytes = Encoding.UTF8.GetBytes(input); Byte[] hashedBytes = algorithm.ComputeHash(inputBytes); return BitConverter.ToString(hashedBytes); }
public static string GetHash(string input) { HashAlgorithm has = new SHA256CryptoServiceProvider(); byte[] byteValue = System.Text.Encoding.UTF8.GetBytes(input); byte[] byteHash = has.ComputeHash(byteValue); return Convert.ToBase64String(byteHash); }
public static string HashStringSHA256(string valueUTF8) { byte[] valueBytes = Encoding.UTF8.GetBytes(valueUTF8); SHA256CryptoServiceProvider shar2 = new SHA256CryptoServiceProvider(); byte[] hashBytes = shar2.ComputeHash(valueBytes); return BitConverter.ToString(hashBytes).Replace("-", ""); }
protected void btnSubmit_Click(object sender, EventArgs e) { using (DefaultConnection db = new DefaultConnection()) { Instructor objI = new Instructor(); objI.FirstName = txtFirstName.Text; objI.LastName = txtLastName.Text; objI.Username = txtUsername.Text; objI.DepartmentID = Convert.ToInt32(ddlDepartment.SelectedValue); String password = txtPassword.Text; String salt = CreateSalt(8); String pass_and_salt = password + salt; // Create a new instance of the hash crypto service provider. HashAlgorithm hashAlg = new SHA256CryptoServiceProvider(); // Convert the data to hash to an array of Bytes. byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(pass_and_salt); // Compute the Hash. This returns an array of Bytes. byte[] bytHash = hashAlg.ComputeHash(bytValue); // Optionally, represent the hash value as a base64-encoded string, // For example, if you need to display the value or transmit it over a network. string base64 = Convert.ToBase64String(bytHash); objI.Password = base64; objI.Salt = salt; db.Instructors.Add(objI); db.SaveChanges(); } }
public static string GenerateToken(string @namespace, string eventHub, string publisher, string sharedAccessKeyName, string sharedAccessKey, DateTimeOffset expiry) { var unixEpoch = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero); var timeSinceEpoch = expiry - unixEpoch; var timeSinceEpochInMilliseconds = (long)timeSinceEpoch.TotalMilliseconds; var url = Helper.BuildUrl(@namespace, eventHub, publisher); var encodedUrl = HttpUtility.UrlEncode(url); var signatureContent = string.Format("{0}\n{1}", encodedUrl, timeSinceEpochInMilliseconds); var signatureContentAsBytes = Encoding.UTF8.GetBytes(signatureContent); var provider = new SHA256CryptoServiceProvider(); var signatureAsBytes = provider.ComputeHash(signatureContentAsBytes); var signature = Convert.ToBase64String(signatureAsBytes); var token = string.Format( "sr={0}&sig={1}&se={2}&skn={3}", HttpUtility.UrlEncode(url), HttpUtility.UrlEncode(signature), timeSinceEpochInMilliseconds, HttpUtility.UrlEncode(sharedAccessKeyName) ); return token; }
public static String SHA256Encrypt(String pwd) { //Encryption //SHA256 //One-way hash //Password Token: // (hash(hash(userName+ pwd)+salt)) String SALT ="buy2easy"; // SHA256CryptoServiceProvider provider = new SHA256CryptoServiceProvider(); // pwd Byte[] inputByteArray = Encoding.UTF8.GetBytes(pwd); // salt Byte[] saltByteArray = Encoding.UTF8.GetBytes(SALT); // hash Byte[] hashedBytesArray1 = provider.ComputeHash(inputByteArray); // Combine salt and input bytes Byte[] inputBytesWithSalt = new Byte[hashedBytesArray1.Length + saltByteArray.Length]; hashedBytesArray1.CopyTo(inputBytesWithSalt, 0); saltByteArray.CopyTo(inputBytesWithSalt, hashedBytesArray1.Length); // hash again Byte[] hashedBytesArray2 = provider.ComputeHash(inputBytesWithSalt); // return double hash encrypted string. return BitConverter.ToString(hashedBytesArray2); }
private NewPassword HashPassword(NewPassword np) { HashAlgorithm hashAlg = null; try { hashAlg = new SHA256CryptoServiceProvider(); byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(np.GetSaltPassword()); byte[] bytHash = hashAlg.ComputeHash(bytValue); np.SaltedHashedPassword = Convert.ToBase64String(bytHash); } catch (Exception e) { throw e; } finally { if (hashAlg != null) { hashAlg.Clear(); hashAlg.Dispose(); hashAlg = null; } } return np; }
public static string SHA256(string str) { byte[] buffer = Encoding.UTF8.GetBytes(str); SHA256CryptoServiceProvider SHA256 = new SHA256CryptoServiceProvider(); byte[] byteArr = SHA256.ComputeHash(buffer); return BitConverter.ToString(byteArr); }
public string sha256(string input) { System.Security.Cryptography.SHA256 sha = new System.Security.Cryptography.SHA256CryptoServiceProvider(); Byte[] inputBytes = Encoding.UTF8.GetBytes(input); Byte[] hashedBytes = sha.ComputeHash(inputBytes); return(BitConverter.ToString(hashedBytes).Replace("-", "").ToLower()); }
/// <summary> /// SHA1编码 /// </summary> /// <param name="value">明文</param> /// <param name="bit">位长</param> /// <returns></returns> public static string Get(string value, SHA1Bit bit) { StringBuilder sBuilder = new StringBuilder(); if (bit == SHA1Bit.L160) { System.Security.Cryptography.SHA1 sha = new System.Security.Cryptography.SHA1CryptoServiceProvider(); // This is one implementation of the abstract class SHA1. byte[] result = sha.ComputeHash(Encoding.Default.GetBytes(value)); sBuilder.Append(BitConverter.ToString(result).Replace("-", "")); } if (bit == SHA1Bit.L256) { System.Security.Cryptography.SHA256 sha256 = new System.Security.Cryptography.SHA256CryptoServiceProvider(); // This is one implementation of the abstract class SHA1. byte[] result = sha256.ComputeHash(Encoding.Default.GetBytes(value)); sBuilder.Append(BitConverter.ToString(result).Replace("-", "")); } if (bit == SHA1Bit.L384) { System.Security.Cryptography.SHA384 sha384 = new System.Security.Cryptography.SHA384CryptoServiceProvider(); // This is one implementation of the abstract class SHA1. byte[] result = sha384.ComputeHash(Encoding.Default.GetBytes(value)); sBuilder.Append(BitConverter.ToString(result).Replace("-", "")); } return(sBuilder.ToString()); }
public static string Sha256(string text) { var bits = Encoding.UTF8.GetBytes(text); var hash = new SHA256CryptoServiceProvider().ComputeHash(bits); return BitConverter.ToString(hash).Replace("-", "").ToLower(); }
public static string EncryptString(string message, string passphrase = null) { if (string.IsNullOrEmpty(message)) { throw new ArgumentException("message is empty!", message); } if (string.IsNullOrEmpty(passphrase)) { passphrase = ConfigurationManager.AppSettings.Get("Common.Cryptography.DefaultPassPhrase"); } // First hash the passphrase to get a 256bit key var sha = new SHA256CryptoServiceProvider(); var passphraseHash = sha.ComputeHash(Encoding.UTF8.GetBytes(passphrase)); var aes = new AesCryptoServiceProvider { KeySize = 256, Key = passphraseHash }; var memoryStream = new MemoryStream(); var cryptoStream = new CryptoStream(memoryStream, aes.CreateEncryptor(), CryptoStreamMode.Write); using (var writer = new StreamWriter(cryptoStream, Encoding.UTF8)) { writer.Write(message); } var results = memoryStream.ToArray(); var finalArray = new byte[aes.IV.Length + results.Length]; Array.Copy(aes.IV, 0, finalArray, 0, aes.IV.Length); Array.Copy(results, 0, finalArray, aes.IV.Length, results.Length); return HttpServerUtility.UrlTokenEncode(finalArray); }
public static string HashPassword(string password, string saltValue) { if (String.IsNullOrEmpty(password)) throw new ArgumentException("Password is null"); var encoding = new UnicodeEncoding(); var hash = new SHA256CryptoServiceProvider(); if (saltValue == null) { saltValue = GenerateSaltValue(); } byte[] binarySaltValue = Convert.FromBase64String(saltValue); byte[] valueToHash = new byte[SaltValueSize + encoding.GetByteCount(password)]; byte[] binaryPassword = encoding.GetBytes(password); binarySaltValue.CopyTo(valueToHash, 0); binaryPassword.CopyTo(valueToHash, SaltValueSize); byte[] hashValue = hash.ComputeHash(valueToHash); var hashedPassword = String.Empty; foreach (byte hexdigit in hashValue) { hashedPassword += hexdigit.ToString("X2", CultureInfo.InvariantCulture.NumberFormat); } return hashedPassword; }
protected void btnLogin_Click(object sender, EventArgs e) { //connect using (DefaultConnection db = new DefaultConnection()) { //create instructor object Staff objS = new Staff(); //first get salt value for this username String username = txtUsername.Text; objS = (from s in db.Staff where s.username == username select s).FirstOrDefault(); //did we find this username? if (objS != null) { String salt = objS.salt; //salt and hash the plain text password String password = txtPassword.Text; String pass_and_salt = password + salt; // Create a new instance of the hash crypto service provider. HashAlgorithm hashAlg = new SHA256CryptoServiceProvider(); // Convert the data to hash to an array of Bytes. byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(pass_and_salt); // Compute the Hash. This returns an array of Bytes. byte[] bytHash = hashAlg.ComputeHash(bytValue); // Optionally, represent the hash value as a base64-encoded string, // For example, if you need to display the value or transmit it over a network. string base64 = Convert.ToBase64String(bytHash); //check if the password we just salted and hashed matches the password in the db if (objS.hashed == base64) { //lblError.Text = "Valid Login"; //store the identity in the session object Session["AdminID"] = objS.AdminID; //redirect to departments page Response.Redirect("welcome.aspx"); } else { lblError.Text = "Invalid Login"; } } else { lblError.Text = "Invalid Login"; } } }
protected void btnLogin_Click(object sender, EventArgs e) { //connect using (DefaultConnection db = new DefaultConnection()) { //create user object User objU = new User(); //get salt value for this username String Username = txtUsername.Text; objU = (from u in db.Users where u.Username == Username select u).FirstOrDefault(); //find match for username if (objU != null) { String salt = objU.Salt; //salt and hash plain text pw String password = txtPassword.Text; String pass_and_salt = password + salt; // Create a new instance of the hash crypto service provider. HashAlgorithm hashAlg = new SHA256CryptoServiceProvider(); // Convert the data to hash to an array of Bytes. byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(pass_and_salt); // Compute the Hash. This returns an array of Bytes. byte[] bytHash = hashAlg.ComputeHash(bytValue); // Optionally, represent the hash value as a base64-encoded string, // For example, if you need to display the value or transmit it over a network. string base64 = Convert.ToBase64String(bytHash); //check if the passwords match if (objU.Password == base64) { //store identity in session obj Session["UserID"] = objU.UserID; Session["Name"] = objU.Name; //redirect to standings page Response.Redirect("standings.aspx"); } else { lblError.Text = "Invalid Login"; } } else { lblError.Text = "Invalid Login"; } } }
/// <summary> /// 计算SHA-256码 /// </summary> /// <param name="word">字符串</param> /// <param name="toUpper">返回哈希值格式 true:英文大写,false:英文小写</param> /// <returns></returns> public string Hash_SHA_256(string word, bool toUpper = true) { try { byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(word); System.Security.Cryptography.SHA256CryptoServiceProvider SHA256 = new System.Security.Cryptography.SHA256CryptoServiceProvider(); byte[] bytHash = SHA256.ComputeHash(bytValue); SHA256.Clear(); StringBuilder sb = new StringBuilder(); foreach (var b in bytHash) { sb.Append(b.ToString("X2")); } string sHash = sb.ToString(); #region //根据计算得到的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; * }*/ #endregion //根据大小写规则决定返回的字符串 return(toUpper ? sHash : sHash.ToLower()); } catch (Exception ex) { throw new Exception(ex.Message); } }
private string EncryptSHA256(string pass) { System.Security.Cryptography.SHA256CryptoServiceProvider x = new System.Security.Cryptography.SHA256CryptoServiceProvider(); //However in WinXp says "SHA256CryptoServiceProvider not supported for this platform" //System.Security.Cryptography.MD5CryptoServiceProvider x = new System.Security.Cryptography.MD5CryptoServiceProvider(); byte[] data = System.Text.Encoding.ASCII.GetBytes(pass); data = x.ComputeHash(data); String sha256Hash = System.Text.Encoding.ASCII.GetString(data); return(sha256Hash); }
public static string GetSHA256(byte[] data) { System.Security.Cryptography.SHA256 sha = new System.Security.Cryptography.SHA256CryptoServiceProvider(); byte[] bytResult = sha.ComputeHash(data); //转换成字符串,32位 string strResult = BitConverter.ToString(bytResult); //BitConverter转换出来的字符串会在每个字符中间产生一个分隔符,需要去除掉 strResult = strResult.Replace("-", ""); return(strResult); }
public static string SHA256(byte[] data) { SHA256CryptoServiceProvider x = new System.Security.Cryptography.SHA256CryptoServiceProvider(); byte[] bs = data; bs = x.ComputeHash(bs); System.Text.StringBuilder s = new System.Text.StringBuilder(); foreach (byte b in bs) { s.Append(b.ToString("x2").ToLower()); } return(s.ToString()); }
public static String PlainToSHA256(String Stringa) { if (Stringa == null || String.IsNullOrEmpty(Stringa)) { return(null); } else { System.Security.Cryptography.SHA256 sha = new System.Security.Cryptography.SHA256CryptoServiceProvider(); System.Text.Encoding objEncoding = System.Text.Encoding.UTF8; byte[] pwHashed = sha.ComputeHash(objEncoding.GetBytes(Stringa)); return(System.Convert.ToBase64String(pwHashed)); } }
static byte[] Get8BytesHashCode(string strText) { byte[] hashCode = null; if (!string.IsNullOrEmpty(strText)) { byte[] byteContents = Encoding.Unicode.GetBytes(strText); System.Security.Cryptography.SHA256 hash = new System.Security.Cryptography.SHA256CryptoServiceProvider(); byte[] hashText = hash.ComputeHash(byteContents); Int64 hashCodeStart = BitConverter.ToInt64(hashText, 0); Int64 hashCodeMedium = BitConverter.ToInt64(hashText, 8); Int64 hashCodeEnd = BitConverter.ToInt64(hashText, 24); hashCode = BitConverter.GetBytes(hashCodeStart ^ hashCodeMedium ^ hashCodeEnd); } return(hashCode); }
/************************************************************************************************************* ************************************************************************************************************** **************************************************************************************************************/ public string GetSHA256Hash(string input) { //Umwandlung des Eingastring in den SHA256 Hash System.Security.Cryptography.SHA256 SHA256 = new System.Security.Cryptography.SHA256CryptoServiceProvider(); byte[] textToHash = Encoding.Default.GetBytes(input); byte[] result = SHA256.ComputeHash(textToHash); //SHA256 Hash in String konvertieren System.Text.StringBuilder s = new System.Text.StringBuilder(); foreach (byte b in result) { s.Append(b.ToString("x2").ToLower()); } return(s.ToString()); }
public bool VerifySHA256Hash(string input, string hash) { System.Security.Cryptography.SHA256 SHA256 = new System.Security.Cryptography.SHA256CryptoServiceProvider(); // Hash the input. string hashOfInput = GetSHA256Hash(input); // Create a StringComparer an compare the hashes. StringComparer comparer = StringComparer.CurrentCulture;//.OrdinalIgnoreCase; if (0 == comparer.Compare(hashOfInput, hash)) { return(true); } else { return(false); } }
/// <summary> /// 获取文本SHA256 /// </summary> /// <param name="text"></param> /// <returns></returns> public static string GetTextSHA_256(string text) { if (string.IsNullOrEmpty(text)) { return(""); } System.Security.Cryptography.SHA256CryptoServiceProvider SHA256CSP = new System.Security.Cryptography.SHA256CryptoServiceProvider(); byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(text); byte[] bytHash = SHA256CSP.ComputeHash(bytValue); SHA256CSP.Clear(); //根据计算得到的Hash码翻译为SHA-1码 string sHash = ConvertHashBytes(bytHash); //根据大小写规则决定返回的字符串 return(sHash.ToLower()); }
/// <summary> /// 计算SHA-256码 /// </summary> /// <param name="word">字符串</param> /// <param name="toUpper">返回哈希值格式 true:英文大写,false:英文小写</param> /// <returns></returns> public static string Hash_SHA_256(string word, bool toUpper = true) { try { System.Security.Cryptography.SHA256CryptoServiceProvider SHA256CSP = new System.Security.Cryptography.SHA256CryptoServiceProvider(); byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(word); byte[] bytHash = SHA256CSP.ComputeHash(bytValue); SHA256CSP.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> /// Makes the Int64 hash code from the provided string. /// </summary> /// <param name="str">The string.</param> /// <returns></returns> public static long MakeInt64HashCode(this string str) { // http://www.codeproject.com/Articles/34309/Convert-String-to-64bit-Integer long hashCode = 0; if (!string.IsNullOrEmpty(str)) { // Unicode Encode Covering all characterset byte[] byteContents = Encoding.Unicode.GetBytes(str); System.Security.Cryptography.SHA256 hash = new System.Security.Cryptography.SHA256CryptoServiceProvider(); byte[] hashText = hash.ComputeHash(byteContents); long hashCodeStart = BitConverter.ToInt64(hashText, 0); long hashCodeMedium = BitConverter.ToInt64(hashText, 8); long hashCodeEnd = BitConverter.ToInt64(hashText, 24); hashCode = hashCodeStart ^ hashCodeMedium ^ hashCodeEnd; } return(hashCode); }
/// <summary> /// Signs JWT token using the private key and returns the serialized assertion. /// </summary> /// <param name="payload">the JWT payload to sign.</param> private string CreateAssertionFromPayload(JsonWebSignature.Payload payload) { string serializedHeader = CreateSerializedHeader(); string serializedPayload = NewtonsoftJsonSerializer.Instance.Serialize(payload); StringBuilder assertion = new StringBuilder(); assertion.Append(UrlSafeBase64Encode(serializedHeader)) .Append(".") .Append(UrlSafeBase64Encode(serializedPayload)); // Sign the header and the payload. //SHA256CryptoServiceProvider var hashAlg = new System.Security.Cryptography.SHA256CryptoServiceProvider(); byte[] assertionHash = hashAlg.ComputeHash(Encoding.ASCII.GetBytes(assertion.ToString())); var signature = UrlSafeBase64Encode(key.SignHash(assertionHash, "2.16.840.1.101.3.4.2.1" /* SHA256 OIG */)); assertion.Append(".").Append(signature); return(assertion.ToString()); }
/// <summary> /// Return unique Int64 value for input string /// </summary> /// <param name="text"></param> /// <returns></returns> public static Int64 GetInt64HashCode(string text) { Int64 hashCode = 0; if (!string.IsNullOrEmpty(text)) { //Unicode Encode Covering all characterset byte[] byteContents = Encoding.Unicode.GetBytes(text); System.Security.Cryptography.SHA256 hash = new System.Security.Cryptography.SHA256CryptoServiceProvider(); byte[] hashText = hash.ComputeHash(byteContents); //32Byte hashText separate //hashCodeStart = 0~7 8Byte //hashCodeMedium = 8~23 8Byte //hashCodeEnd = 24~31 8Byte //and Fold Int64 hashCodeStart = BitConverter.ToInt64(hashText, 0); Int64 hashCodeMedium = BitConverter.ToInt64(hashText, 8); Int64 hashCodeEnd = BitConverter.ToInt64(hashText, 24); hashCode = hashCodeStart ^ hashCodeMedium ^ hashCodeEnd; } return(hashCode); }
public void TestRfc7515Example_A_2_1() { string protectedSample = // From the RFC example "{\"alg\":\"RS256\"}"; byte[] protectedBytesExpected = // From the RFC example { 123, 34, 97, 108, 103, 34, 58, 34, 82, 83, 50, 53, 54, 34, 125 }; byte[] protectedBytesActual = Encoding.UTF8.GetBytes(protectedSample); CollectionAssert.AreEqual(protectedBytesExpected, protectedBytesActual); string protectedB64uExpected = "eyJhbGciOiJSUzI1NiJ9"; // From the RFC example string protectedB64uActual = CryptoHelper.Base64.UrlEncode(protectedBytesActual); Assert.AreEqual(protectedB64uExpected, protectedB64uActual); string payloadSample = // From the RFC example "{\"iss\":\"joe\",\r\n" + " \"exp\":1300819380,\r\n" + " \"http://example.com/is_root\":true}"; byte[] payloadBytesActual = Encoding.UTF8.GetBytes(payloadSample); string payloadB64uActual = CryptoHelper.Base64.UrlEncode(payloadBytesActual); string signingInput = $"{protectedB64uActual}.{payloadB64uActual}"; byte[] signingBytesExpected = // From the RFC example { 101, 121, 74, 104, 98, 71, 99, 105, 79, 105, 74, 83, 85, 122, 73, 49, 78, 105, 74, 57, 46, 101, 121, 74, 112, 99, 51, 77, 105, 79,105, 74, 113, 98, 50, 85, 105, 76, 65, 48, 75, 73, 67, 74, 108, 101, 72, 65, 105, 79, 106, 69, 122, 77, 68, 65, 52, 77, 84, 107, 122, 79, 68, 65, 115, 68, 81, 111, 103, 73, 109, 104, 48, 100, 72, 65, 54, 76, 121, 57, 108, 101, 71, 70, 116, 99, 71, 120, 108, 76, 109, 78, 118, 98, 83, 57, 112, 99, 49, 57, 121, 98, 50, 57, 48, 73, 106, 112, 48, 99, 110, 86, 108, 102, 81 }; byte[] signingBytesActual = Encoding.ASCII.GetBytes(signingInput); CollectionAssert.AreEqual(signingBytesExpected, signingBytesActual); byte[] sigExpected = // From the RFC example { 112, 46, 33, 137, 67, 232, 143, 209, 30, 181, 216, 45, 191, 120, 69, 243, 65, 6, 174, 27, 129, 255, 247, 115, 17, 22, 173, 209, 113, 125, 131, 101, 109, 66, 10, 253, 60, 150, 238, 221, 115, 162, 102, 62, 81, 102, 104, 123, 0, 11, 135, 34, 110, 1, 135, 237, 16, 115, 249, 69, 229, 130, 173, 252, 239, 22, 216, 90, 121, 142, 232, 198, 109, 219, 61, 184, 151, 91, 23, 208, 148, 2, 190, 237, 213, 217, 217, 112, 7, 16, 141, 178, 129, 96, 213, 248, 4, 12, 167, 68, 87, 98, 184, 31, 190, 127, 249, 217, 46, 10, 231, 111, 36, 242, 91, 51, 187, 230, 244, 74, 230, 30, 177, 4, 10, 203, 32, 4, 77, 62, 249, 18, 142, 212,1, 48, 121, 91, 212, 189, 59, 65, 238, 202, 208, 102, 171, 101, 25, 129, 253, 228, 141, 247, 127, 55, 45, 195, 139, 159, 175, 221, 59, 239, 177, 139, 93, 163, 204, 60, 46, 176, 47, 158, 58, 65, 214, 18, 202, 173, 21, 145, 18, 115, 160, 95, 35, 185, 232, 56, 250, 175, 132, 157, 105, 132, 41, 239, 90, 30, 136, 121, 130, 54, 195, 212, 14, 96, 69, 34, 165, 68, 200, 242, 122, 122, 45, 184, 6, 99, 209, 108, 247, 202, 234, 86, 222, 64, 92, 178, 33, 90, 69, 178, 194, 85, 102, 181, 90, 193, 167, 72, 160, 112, 223, 200, 163, 42, 70, 149, 67, 208, 25, 238, 251, 71 }; byte[] sigActual = null; using (var rsa = new System.Security.Cryptography.RSACryptoServiceProvider()) { rsa.ImportParameters(GetRsaParamsForRfc7515Example_A_2_1()); using (var sha256 = new System.Security.Cryptography.SHA256CryptoServiceProvider()) { sigActual = rsa.SignData(signingBytesExpected, sha256); } } CollectionAssert.AreEqual(sigExpected, sigActual); string sigB64uExpected = // From the RFC example "cC4hiUPoj9Eetdgtv3hF80EGrhuB__dzERat0XF9g2VtQgr9PJbu3XOiZj5RZmh7" + "AAuHIm4Bh-0Qc_lF5YKt_O8W2Fp5jujGbds9uJdbF9CUAr7t1dnZcAcQjbKBYNX4" + "BAynRFdiuB--f_nZLgrnbyTyWzO75vRK5h6xBArLIARNPvkSjtQBMHlb1L07Qe7K" + "0GarZRmB_eSN9383LcOLn6_dO--xi12jzDwusC-eOkHWEsqtFZESc6BfI7noOPqv" + "hJ1phCnvWh6IeYI2w9QOYEUipUTI8np6LbgGY9Fs98rqVt5AXLIhWkWywlVmtVrB" + "p0igcN_IoypGlUPQGe77Rw"; string sigB64uActual = CryptoHelper.Base64.UrlEncode(sigActual); Assert.AreEqual(sigB64uExpected, sigB64uActual); }