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;
}
