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; } shaM.Clear(); } return cr; }
//Creates and returns new User by Email public async Task <pix_dtmodel.Models.User> CreateNewUser(string email, string hashPass, string uname) { //Create model pix_dtmodel.Models.User usr = new pix_dtmodel.Models.User(); //Make a hasher SHA256 hasher = new SHA256Managed(); hasher.Initialize(); //Init the csp //hash email for use in the UID byte[] hashedBytes = hasher.ComputeHash(Encoding.ASCII.GetBytes(email)); //Use bit Converter to get hash string string hashString = BitConverter.ToString(hashedBytes).Replace("-", String.Empty); //Set fields usr.Uid = "USR" + hashString; //Check backend for duplicates if (userSession.GetRecordById(usr.Uid).Result != null) { //If query that returned a result than the user is taken return error return(null); } //Always store email in lowercase usr.Email = email.ToLower(); //Always store username in lowercase usr.Username = uname.ToLower(); //Contact google boi FirebaseAuthLink tempLink = await auth.CreateUserWithEmailAndPasswordAsync(email, hashPass, uname, true); //Now we've issued a request to create a new account using the hashed password, email and then a verification email will hopefully be issued out. usr.TimeLeft = tempLink.ExpiresIn + ""; //Expirary Date, refresh token when this gets too low. //apply token. usr.Token = tempLink.FirebaseToken; //set hash usr.HashWord = hashPass.Replace("-", String.Empty); //set Google id. usr.Gid = tempLink.User.LocalId; //Finally add to dbase userSession.Add(usr); //debug line Console.WriteLine("User " + uname + " expires in " + usr.TimeLeft); //cleanup? hasher.Clear(); hashedBytes = null; hashString = null; return(usr); }
private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) { string pin_base64 = ""; if (mPinLoaded) { pin_base64 = textBox_PIN.Text; } else { //计算pin的hash SHA256 sha256 = new SHA256Managed(); byte[] hash = sha256.ComputeHash(System.Text.Encoding.UTF8.GetBytes(textBox_PIN.Text)); sha256.Clear(); //Base64 pin_base64 = Convert.ToBase64String(hash); } if (!Form1.mClient.Connect()) { MessageBox.Show("无法连接到服务器!", "注册 云白板", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } string reason = ""; if (!Form1.mClient.Register(textBox_User.Text, pin_base64, ref reason)) { MessageBox.Show("操作失败:" + reason, "注册 云白板", MessageBoxButtons.OK, MessageBoxIcon.Error); } else { MessageBox.Show("注册成功。", "注册 云白板", MessageBoxButtons.OK, MessageBoxIcon.Information); } }
public EncryptSettingsProvider() { //read settings from configuration var useHashingString = ConfigurationManager.AppSettings["UseHashingForEncryption"]; var useHashing = System.String.Compare(useHashingString, "false", System.StringComparison.OrdinalIgnoreCase) != 0; _encryptionPrefix = ConfigurationManager.AppSettings["EncryptionPrefix"]; if (string.IsNullOrWhiteSpace(_encryptionPrefix)) { _encryptionPrefix = "encryptedHidden_"; } var key = ConfigurationManager.AppSettings["EncryptionKey"]; if (useHashing) { var hash = new SHA256Managed(); _encryptionKey = hash.ComputeHash(Encoding.UTF8.GetBytes(key)); hash.Clear(); hash.Dispose(); } else { _encryptionKey = Encoding.UTF8.GetBytes(key); } }
/// <summary> /// ハッシュを得る /// </summary> /// <param name="password">入力されたパスワード</param> /// <returns>ハッシュ化されたパスワード</returns> public static string Hash(string password) { if (password == null) { throw new ArgumentNullException("password"); } if (string.IsNullOrWhiteSpace(password)) { throw new ArgumentException("Value cannot be empty or whitespace only string.", "password"); } byte[] tmpByte; SHA256 sha256 = new SHA256Managed(); tmpByte = sha256.ComputeHash(GetKeyByteArray(password)); StringBuilder rst = new StringBuilder(); for (int i = 0; i < tmpByte.Length; i++) { rst.Append(tmpByte[i].ToString("x2")); } sha256.Clear(); return(rst.ToString()); }
public static String sha256(String s) { try { SHA256Managed crypt = new SHA256Managed(); Byte[] crypto = crypt.ComputeHash(Encoding.UTF8.GetBytes(s), 0, Encoding.UTF8.GetByteCount(s)); crypt.Clear(); crypt.Dispose(); StringBuilder hash = new StringBuilder(); foreach (Byte x in crypto) { hash.Append(x.ToString("x2")); } LastLogMsg = null; return(hash.ToString()); } catch (Exception ex) { #if DEBUG Console.WriteLine(ex.Message + " " + ex.StackTrace); #endif LastLogMsg = "Unhandled Exception!"; return(null); } }
private static string GetSha512Buffered(Stream p_streamIn) { string _result; Process.GetCurrentProcess(); const int _bufferSizeForMd5Hash = 1024 * 1024 * 8; using (var _md5Prov = new SHA256Managed()) { int _readCount; var _bytesTransfered = 0; var _buffer = new byte[_bufferSizeForMd5Hash]; while ((_readCount = p_streamIn.Read(_buffer, 0, _buffer.Length)) != 0) { if (_bytesTransfered + _readCount == p_streamIn.Length) { _md5Prov.TransformFinalBlock(_buffer, 0, _readCount); } else { _md5Prov.TransformBlock(_buffer, 0, _bufferSizeForMd5Hash, _buffer, 0); } _bytesTransfered += _readCount; } _result = BitConverter.ToString(_md5Prov.Hash).Replace("-", String.Empty).ToLower(); _md5Prov.Clear(); } return(_result); }
private bool TryLogin() { try { string userid = TxtBox_Account.Text.ToString(); string password = TxtBox_Password.Text.ToString(); /// var sha256 = new SHA256Managed(); var Asc = new ASCIIEncoding(); var tmpByte = Asc.GetBytes(password); var EncryptBytes = sha256.ComputeHash(tmpByte); password = BitConverter.ToString(EncryptBytes).Replace("-", ""); sha256.Clear(); /// if (ValidateAccount(userid, password)) { main.Login(new User(userid)); return(true); } return(false); } catch (Exception ex) { Console.WriteLine(ex.Message + ex.StackTrace); return(false); } }
public byte[] Encriptar(string contenido, string salt, int numhash) { //REALIZAMOS LA COMBINACION DE ENCRIPTADO CON SU SALT string textocompleto = contenido + salt; //DECLARAMOS EL OBJETO SHA256 SHA256Managed objsha = new SHA256Managed(); byte[] bytesalida = null; try { //CONVERTIMOS EL TEXTO A BYTES bytesalida = Encoding.UTF8.GetBytes(textocompleto); //Convert.FromBase64String(textocompleto); //ENCRIPTAMOS EL TEXTO 1000 VECES for (int i = 0; i < numhash; i++) { bytesalida = objsha.ComputeHash(bytesalida); } } finally { objsha.Clear(); } //DEVOLVEMOS LOS BYTES DE SALIDA return(bytesalida); }
public static string FromString(string input, HashType hashtype) { Byte[] clearBytes; Byte[] hashedBytes; string output = String.Empty; switch (hashtype) { case HashType.RIPEMD160: clearBytes = new UTF8Encoding().GetBytes(input); RIPEMD160 myRIPEMD160 = RIPEMD160Managed.Create(); hashedBytes = myRIPEMD160.ComputeHash(clearBytes); output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower(); break; case HashType.MD5: clearBytes = new UTF8Encoding().GetBytes(input); hashedBytes = ((HashAlgorithm)CryptoConfig.CreateFromName("MD5")).ComputeHash(clearBytes); output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower(); break; case HashType.SHA1: clearBytes = Encoding.UTF8.GetBytes(input); SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider(); sha1.ComputeHash(clearBytes); hashedBytes = sha1.Hash; sha1.Clear(); output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower(); break; case HashType.SHA256: clearBytes = Encoding.UTF8.GetBytes(input); SHA256 sha256 = new SHA256Managed(); sha256.ComputeHash(clearBytes); hashedBytes = sha256.Hash; sha256.Clear(); output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower(); break; case HashType.SHA384: clearBytes = Encoding.UTF8.GetBytes(input); SHA384 sha384 = new SHA384Managed(); sha384.ComputeHash(clearBytes); hashedBytes = sha384.Hash; sha384.Clear(); output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower(); break; case HashType.SHA512: clearBytes = Encoding.UTF8.GetBytes(input); SHA512 sha512 = new SHA512Managed(); sha512.ComputeHash(clearBytes); hashedBytes = sha512.Hash; sha512.Clear(); output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower(); break; } return(output); }
/// <summary> /// 生成指定字符串的SHA256散列值 /// </summary> /// <param name="srcValue">源字符串</param> /// <returns>SHA256值</returns> public static string Sha256Encode(string srcValue) { SHA256 sHa = new SHA256Managed(); byte[] inArray = sHa.ComputeHash(Encoding.Default.GetBytes(srcValue)); sHa.Clear(); return(Convert.ToBase64String(inArray)); }
public static string SHA256Encrypt(string strIN) { SHA256 sha = new SHA256Managed(); byte[] @byte = sha.ComputeHash(GetKeyByteArray(strIN)); sha.Clear(); return(GetStringValue(@byte)); }
/// <summary> /// ½øÐÐSHA256¼ÓÃÜ /// </summary> /// <param name="strIn">Òª¼ÓÃܵÄ×Ö·û´®</param> /// <returns>¼ÓÃܺóµÄ×Ö·û´®</returns> public static string SHA256Encrypt(string strIn) { SHA256 sha256 = new SHA256Managed(); var tmpByte = sha256.ComputeHash(strIn.ToASCIIBytes()); sha256.Clear(); return(tmpByte.ToHexUpperString()); }
/// <summary> /// Sha256加密 /// </summary> /// <param name="parameter">待加密参数</param> /// <param name="isReturnNum">是否返回为加密后字符的Byte代码</param> /// <returns></returns> public static string Sha256Encrypt(this string parameter, bool?isReturnNum = null) { SHA256 sha256 = new SHA256Managed(); var tmpByte = sha256.ComputeHash(GetKeyByteArray(parameter)); sha256.Clear(); return(GetStringValue(tmpByte, FindIsReturnNum(isReturnNum))); }
private static string HexEncodeSha256Hash(byte[] body) { SHA256 sha256 = new SHA256Managed(); var bytes = sha256.ComputeHash(body); sha256.Clear(); return(ToHexString(bytes)); }
public static string SHA256Encrypt(string str) { SHA256 sha = new SHA256Managed(); byte[] inArray = sha.ComputeHash(Encoding.Default.GetBytes(str)); sha.Clear(); return(Convert.ToBase64String(inArray)); }
protected string CreateBase64SHAHash(string Phrase) { SHA256Managed HashTool = new SHA256Managed(); Byte[] phraseAsByte = System.Text.Encoding.UTF8.GetBytes(string.Concat(Phrase)); Byte[] encryptedBytes = HashTool.ComputeHash(phraseAsByte); HashTool.Clear(); return(Convert.ToBase64String(encryptedBytes)); }
public static string SHA256Encrypt(string strIN) { byte[] tmpByte; SHA256 sha256 = new SHA256Managed(); tmpByte = sha256.ComputeHash(GetKeyByteArray(strIN)); sha256.Clear(); return(GetStringValue(tmpByte)); }
public static string SHA256(string sourceStr) { byte[] bytes = Encoding.UTF8.GetBytes(sourceStr); SHA256Managed managed = new SHA256Managed(); byte[] inArray = managed.ComputeHash(bytes); managed.Clear(); return(Convert.ToBase64String(inArray)); }
/// <summary> /// SHA256加密,不可逆转 /// </summary> /// <param name="encryptionString">被加密的字符串</param> /// <returns></returns> public static string SHA256_Encryption(string encryptionString) { using (SHA256 s256 = new SHA256Managed()) { byte[] byte1 = s256.ComputeHash(Encoding.Default.GetBytes(encryptionString)); s256.Clear(); return(Convert.ToBase64String(byte1)); } }
/// <summary> /// SHA256编码 /// </summary> /// <param name="sourceString">字符串</param> /// <returns></returns> public static string Sha256Encrypt(this string sourceString) { var bytes = Encoding.UTF8.GetBytes(sourceString); SHA256 sha256 = new SHA256Managed(); var tmpByte = sha256.ComputeHash(bytes); sha256.Clear(); return(Convert.ToBase64String(tmpByte)); }
/// <summary> /// SHA256加密字符串 /// </summary> /// <param name="sourceStr">要加密的字符串</param> /// <returns>SHA256加密后的字符串</returns> public static string SHA256(string sourceStr) { byte[] SHA256Data = Encoding.UTF8.GetBytes(sourceStr); SHA256Managed Sha256 = new SHA256Managed(); byte[] Result = Sha256.ComputeHash(SHA256Data); Sha256.Clear(); return(Convert.ToBase64String(Result)); //返回长度为44字节的字符串 }
/// <summary> /// SHA256加密,不可逆转 /// </summary> /// <param name="str">string str:被加密的字符串</param> /// <returns>返回加密后的字符串</returns> public string Sha256Encrypt(string str) { SHA256 s256 = new SHA256Managed(); byte[] bytes; bytes = s256.ComputeHash(Encoding.Default.GetBytes(str)); s256.Clear(); return(BitConverter.ToString(bytes).Replace("-", "").ToLower()); }
/// <summary> /// SHA256加密 /// </summary> /// <param name="sourceStr">待加密的字符串</param> /// <returns>加密后的字符串</returns> public static string SHA256(string sourceStr) { var sha256Byte = Encoding.UTF8.GetBytes(sourceStr); var sha256 = new SHA256Managed(); var result = sha256.ComputeHash(sha256Byte); sha256.Clear(); return(Convert.ToBase64String(result)); }
public string Encrypt(string password) { var hashlite = new SHA256Managed(); byte[] textWithSaltBytes = Encoding.UTF8.GetBytes(string.Concat(password, "URFMODE")); byte[] hashedBytes = hashlite.ComputeHash(textWithSaltBytes); hashlite.Clear(); return(Convert.ToBase64String(hashedBytes)); }
public static string SHA256Encrypt(string str, bool isReturnNum) { byte[] b = GetKeyByteArray(str); SHA256 sha256 = new SHA256Managed(); b = sha256.ComputeHash(b); sha256.Clear(); return(GetStringValue(b, isReturnNum)); }
/// <summary> /// SHA256加密,不可逆转 /// </summary> /// <param name="str">string str:被加密的字符串</param> /// <returns>返回加密后的字符串</returns> public static string SHA256Encrypt(string str) { SHA256 s256 = new SHA256Managed(); byte[] byte1; byte1 = s256.ComputeHash(Encoding.UTF8.GetBytes(str)); s256.Clear(); return(Convert.ToBase64String(byte1)); }
private static string CreateSHAHash(string plaintext) { SHA256Managed HashTool = new SHA256Managed(); Byte[] PhraseAsByte = System.Text.Encoding.UTF8.GetBytes(string.Concat(plaintext)); Byte[] EncryptedBytes = HashTool.ComputeHash(PhraseAsByte); HashTool.Clear(); return(Convert.ToBase64String(EncryptedBytes)); }
private string Sha256Hash(string rawString) { var rawStringBytes = Encoding.Unicode.GetBytes(rawString); var hashProvider = new SHA256Managed(); hashProvider.Initialize(); rawStringBytes = hashProvider.ComputeHash(rawStringBytes); hashProvider.Clear(); return(Convert.ToBase64String(rawStringBytes)); }
string StringToSign(string canonicalRequest, DateTime t) { SHA256 sha256 = new SHA256Managed(); var bytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(canonicalRequest)); sha256.Clear(); return($"{Algorithm}\n" + $"{t.ToUniversalTime().ToString(BasicDateFormat)}\n" + $"{ToHexString(bytes)}"); }
public static string HashPassword(string password) { Byte[] passwordBytes = Encoding.Unicode.GetBytes(password); SHA256Managed hashProvider = new SHA256Managed(); hashProvider.Initialize(); passwordBytes = hashProvider.ComputeHash(passwordBytes); hashProvider.Clear(); return(Convert.ToBase64String(passwordBytes)); }
//AIM: THIS FUNCTION IS USE to encrypt the string and create hask key using diff hash methods public string FromString(string input, HashType hashtype) { Byte[] clearBytes; Byte[] hashedBytes; string output = String.Empty; switch (hashtype) { case HashType.RIPEMD160: clearBytes = new UTF8Encoding().GetBytes(input); RIPEMD160 myRIPEMD160 = RIPEMD160Managed.Create(); hashedBytes = myRIPEMD160.ComputeHash(clearBytes); output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower(); break; case HashType.MD5: clearBytes = new UTF8Encoding().GetBytes(input); hashedBytes = ((HashAlgorithm)CryptoConfig.CreateFromName("MD5")).ComputeHash(clearBytes); output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower(); break; case HashType.SHA1: clearBytes = Encoding.UTF8.GetBytes(input); SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider(); sha1.ComputeHash(clearBytes); hashedBytes = sha1.Hash; sha1.Clear(); output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower(); break; case HashType.SHA256: clearBytes = Encoding.UTF8.GetBytes(input); SHA256 sha256 = new SHA256Managed(); sha256.ComputeHash(clearBytes); hashedBytes =sha256.Hash; sha256.Clear(); output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower(); break; case HashType.SHA384: clearBytes = Encoding.UTF8.GetBytes(input); SHA384 sha384 = new SHA384Managed(); sha384.ComputeHash(clearBytes); hashedBytes = sha384.Hash; sha384.Clear(); output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower(); break; case HashType.SHA512: clearBytes = Encoding.UTF8.GetBytes(input); SHA512 sha512 = new SHA512Managed(); sha512.ComputeHash(clearBytes); hashedBytes = sha512.Hash; sha512.Clear(); output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower(); break; } return output; }