/// <summary>
/// SHA1CryptoServiceProvider 类的哈希大小为 160 位
/// 此类型的任何公共static成员都是线程安全的。但不保证所有实例成员都是线程安全的
/// </summary>
private static string Encrypt_static(string clearText, Encoding encode)
{
SHA1 sha = null;
try
{
byte[] originalBytes = encode.GetBytes(clearText); //Encoding.UTF8.GetBytes(clearText);
sha = new SHA1CryptoServiceProvider();
byte[] data = sha.ComputeHash(originalBytes);
//return BitConverter.ToString(data); //将指定的字节数组的每个元素的数值转换为它的等效十六进制字符串表示形式
StringBuilder builder = new StringBuilder();
foreach (var item in data)
{
builder.Append(item.ToString("X2"));//将该哈希作为 32 字符的十六进制格式字符串返回
}
return builder.ToString();
}
catch (ArgumentNullException) { return clearText; }
catch (EncoderFallbackException) { return clearText; }
catch (ObjectDisposedException) { return clearText; }
catch (Exception) { return clearText; }
finally
{
if (sha != null)
{
sha.Clear();
sha.Dispose();
}
sha = null;
}
}
/// <summary>
/// Computes a hash using SHA1
/// </summary>
/// <param name="Input">Input string</param>
/// <returns>A hash of the input string using SHA1</returns>
public static string ComputeHash(string Input)
{
SHA1CryptoServiceProvider SHA1 = new SHA1CryptoServiceProvider();
byte[] InputArray = System.Text.Encoding.ASCII.GetBytes(Input);
byte[] HashedArray = SHA1.ComputeHash(InputArray);
SHA1.Clear();
return BitConverter.ToString(HashedArray).Replace("-", "");
}
public static string encriptarCadena(string cadena)
{
SHA1CryptoServiceProvider elProveedor = new SHA1CryptoServiceProvider();
byte[] vectoBytes = System.Text.Encoding.UTF8.GetBytes(cadena);
byte[] inArray = elProveedor.ComputeHash(vectoBytes);
elProveedor.Clear();
return Convert.ToBase64String(inArray);
}
public static string HashStringSHA1(string textToHash)
{
System.Security.Cryptography.SHA1CryptoServiceProvider SHA1 = new System.Security.Cryptography.SHA1CryptoServiceProvider();
byte[] byteValue = System.Text.Encoding.UTF8.GetBytes(textToHash);
byte[] byteHash = SHA1.ComputeHash(byteValue);
SHA1.Clear();
return Convert.ToBase64String(byteHash);
}
public static string HashStringSHA1(string textToHash)
{
System.Security.Cryptography.SHA1CryptoServiceProvider SHA1 = new System.Security.Cryptography.SHA1CryptoServiceProvider();
byte[] byteValue = System.Text.Encoding.UTF8.GetBytes(textToHash);
byte[] byteHash = SHA1.ComputeHash(byteValue);
SHA1.Clear();
return(Convert.ToBase64String(byteHash));
}
/// <summary>
/// SHA1加密
/// </summary>
/// <param name="insertStr"></param>
/// <returns></returns>
public static string SHA1Encrypt(string insertStr)
{
byte[] tmpByte;
SHA1 sha1 = new SHA1CryptoServiceProvider();
tmpByte = sha1.ComputeHash(GetKeyByteArray(insertStr));
sha1.Clear();
return GetStringValue(tmpByte);
}
public void ComputingResult()
{
UTF8Encoding utf8 = new UTF8Encoding();
byte[] textWithSaltBytes = utf8.GetBytes(string.Concat(PlainText, Salt));
HashAlgorithm hasher = new SHA1CryptoServiceProvider();
byte[] hashedBytes = hasher.ComputeHash(textWithSaltBytes);
hasher.Clear();
result = Convert.ToBase64String(hashedBytes);
}
public static string EncryptToSHA1(string str)
{
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
byte[] str1 = Encoding.UTF8.GetBytes(str);
byte[] str2 = sha1.ComputeHash(str1);
sha1.Clear();
(sha1 as IDisposable).Dispose();
return ToHexString(str2);
}
///
/// SHA1 加密（不可逆加密）
///
/// 要加密的原始字串
///
public static string SHA1Encrypt(string pass)
{
System.Security.Cryptography.SHA1 sha1 = new System.Security.Cryptography.SHA1CryptoServiceProvider();
byte[] bytResult = sha1.ComputeHash(System.Text.Encoding.UTF8.GetBytes(pass));
sha1.Clear();
string strResult = BitConverter.ToString(bytResult);
strResult = strResult.Replace("-", "");
return(strResult);
}
/// <summary>
/// Encripta una Cadena con el Método Hash
/// </summary>
/// <param name="cadena">Cadena a encriptar</param>
public static string Encriptar(string cadena)
{
HashAlgorithm hashValue = new SHA1CryptoServiceProvider();
byte[] byteValue = Encoding.UTF8.GetBytes(cadena);
byte[] byteHash = hashValue.ComputeHash(byteValue);
hashValue.Clear();
return Convert.ToBase64String(byteHash);
}
byte[] GenKey(byte[] key)
{
for (int x = 0; x < 10000; x++)
{
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
sha1.TransformBlock(key, 0, key.Length, key, 0);
key = sha1.TransformFinalBlock(ASCIIEncoding.ASCII.GetBytes("fuckoff"), 0, 7);
sha1.Clear();
}
return key;
}
/// <summary>
/// Creates a slated version of an input Password
/// </summary>
/// <param name="salt">Salt of Password</param>
/// <param name="password">Clear Password</param>
/// <param name="iterations">Number of times to iterate Salt</param>
/// <returns></returns>
public string CreateSaltedPassword(string salt, string password, int iterations)
{
SHA1CryptoServiceProvider SHA1 = new SHA1CryptoServiceProvider();
byte[] byteValue = System.Text.Encoding.UTF8.GetBytes(salt + password);
do
{
byteValue = SHA1.ComputeHash(byteValue);
} while (--iterations > 0);
SHA1.Clear();
return Convert.ToBase64String(byteValue);
}
public static String HashText(String TextToHash)
{
SHA1CryptoServiceProvider SHA1 = new System.Security.Cryptography.SHA1CryptoServiceProvider();
Byte[] bytValue = Encoding.UTF8.GetBytes(TextToHash);
Byte[] bytHash = SHA1.ComputeHash(bytValue);
SHA1.Clear();
//Return a base 64 encoded string of the Hash value
return(Convert.ToBase64String(bytHash));
}
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;
}
public static String ComputeHash(byte[] buffer)
{
SHA1CryptoServiceProvider hashProvider1 = new SHA1CryptoServiceProvider();
byte[] sha1Hash = hashProvider1.ComputeHash(buffer);
StringBuilder sha1Text = new StringBuilder();
foreach (byte iByte in sha1Hash)
{
sha1Text.AppendFormat("{0:x2}", iByte);
}
hashProvider1.Clear();
return sha1Text.ToString();
}
public static string Salt(string salt, string password)
{
var sha1 = new SHA1CryptoServiceProvider();
var byteValue = Encoding.UTF8.GetBytes(salt + password);
var byteHash = sha1.ComputeHash(byteValue);
sha1.Clear();
return Convert.ToBase64String(byteHash);
}
internal static string Salt(string salt, string password)
{
var sha1 = new SHA1CryptoServiceProvider();
// Convert the string into an array of bytes.
byte[] byteValue = Encoding.UTF8.GetBytes(salt + password);
// Compute the hash value.
byte[] byteHash = sha1.ComputeHash(byteValue);
// Dispose the unmanaged cryptographic object.
sha1.Clear();
// Convert the byte array back into a string.
return Convert.ToBase64String(byteHash);
}
/// <summary>
/// sha1 加密字符串
/// </summary>
/// <param name="sourceString"></param>
/// <returns></returns>
public static string SHA1Encrypt(string sourceString)
{
if (string.IsNullOrEmpty(sourceString))
return string.Empty;
byte[] bytRes = Encoding.UTF8.GetBytes(sourceString);
HashAlgorithm iSHA = new SHA1CryptoServiceProvider();
byte[] bytHash = iSHA.ComputeHash(bytRes);
iSHA.Clear();
StringBuilder sbEnText = new StringBuilder();
foreach (byte byt in bytHash)
{
sbEnText.AppendFormat("{0:x2}", byt);
}
return sbEnText.ToString();
}
/// <summary>
/// 获取文本SHA1
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static string GetTextSHA_1(string text)
{
if (string.IsNullOrEmpty(text))
{
return("");
}
System.Security.Cryptography.SHA1CryptoServiceProvider SHA1CSP = new System.Security.Cryptography.SHA1CryptoServiceProvider();
byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(text);
byte[] bytHash = SHA1CSP.ComputeHash(bytValue);
SHA1CSP.Clear();
//根据计算得到的Hash码翻译为SHA-1码
string sHash = ConvertHashBytes(bytHash);
//根据大小写规则决定返回的字符串
return(sHash.ToLower());
}
/// <summary>
/// 计算SHA-1码
/// </summary>
/// <param name="word">字符串</param>
/// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
/// <returns></returns>
public static string Hash_SHA_1(string word, bool toUpper = true)
{
try
{
System.Security.Cryptography.SHA1CryptoServiceProvider SHA1CSP
= new System.Security.Cryptography.SHA1CryptoServiceProvider();
byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
byte[] bytHash = SHA1CSP.ComputeHash(bytValue);
SHA1CSP.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);
}
}
public static string GetUrlHash(string url)
{
if (url != null && url.Length > 0)
{
string hash = String.Empty;
byte[] buffer = Encoding.ASCII.GetBytes(url.Replace("http://www.", ""));
using (var sha = new SHA1CryptoServiceProvider())
{
hash = BitConverter.ToString(sha.ComputeHash(buffer));
sha.Clear();
}
return hash.Replace("-", "").ToLower();
}
else
{
return null;
}
}
/// <summary>
/// Encrypts a string using DES
/// </summary>
/// <param name="Input">String to encrypt</param>
/// <param name="Key">Key to encrypt with (must be at least 8 bytes)</param>
/// <returns>An encrypted string</returns>
public static string Encrypt(string Input, string Key)
{
if (string.IsNullOrEmpty(Input) || string.IsNullOrEmpty(Key))
{
throw new ArgumentNullException("The input/key string can not be empty.");
}
ASCIIEncoding Encoding = new ASCIIEncoding();
byte[] KeyHashArray = Encoding.GetBytes(Key);
byte[] KeyArray = new byte[8];
byte[] Key2Array = new byte[8];
SHA1CryptoServiceProvider SHA = new SHA1CryptoServiceProvider();
byte[] Hash = SHA.ComputeHash(KeyHashArray);
SHA.Clear();
for (int x = 0; x < 8; ++x)
{
KeyArray[x] = Hash[x];
Key2Array[x] = Hash[x + 8];
}
byte[] Text = null;
DESCryptoServiceProvider Encryptor = new DESCryptoServiceProvider();
using (MemoryStream Stream = new MemoryStream())
{
using (CryptoStream DESStream = new CryptoStream(Stream, Encryptor.CreateEncryptor(KeyArray, Key2Array), CryptoStreamMode.Write))
{
using (StreamWriter Writer = new StreamWriter(DESStream))
{
Writer.Write(Input);
Writer.Flush();
DESStream.FlushFinalBlock();
Writer.Flush();
Text = Stream.GetBuffer();
}
}
}
Encryptor.Clear();
return Convert.ToBase64String(Text, 0, (int)Text.Length);
}
/// <summary>
/// Decrypts a string using DES
/// </summary>
/// <param name="Input">Input string</param>
/// <param name="Key">Key to use in decryption (must be at least 8 bytes)</param>
/// <returns>A decrypted string</returns>
public static string Decrypt(string Input,string Key)
{
if (string.IsNullOrEmpty(Input) || string.IsNullOrEmpty(Key))
{
throw new ArgumentNullException("The input/key string can not be empty.");
}
try
{
ASCIIEncoding Encoding = new ASCIIEncoding();
byte[] KeyHashArray = Encoding.GetBytes(Key);
byte[] KeyArray = new byte[8];
byte[] Key2Array = new byte[8];
SHA1CryptoServiceProvider SHA = new SHA1CryptoServiceProvider();
byte[] Hash = SHA.ComputeHash(KeyHashArray);
SHA.Clear();
for (int x = 0; x < 8; ++x)
{
KeyArray[x] = Hash[x];
Key2Array[x] = Hash[x + 8];
}
string Text = null;
DESCryptoServiceProvider Decryptor = new DESCryptoServiceProvider();
using (MemoryStream Stream = new MemoryStream(Convert.FromBase64String(Input)))
{
using (CryptoStream DESStream = new CryptoStream(Stream, Decryptor.CreateDecryptor(KeyArray, Key2Array), CryptoStreamMode.Read))
{
using (StreamReader Reader = new StreamReader(DESStream))
{
Text = Reader.ReadToEnd();
}
}
}
Decryptor.Clear();
return Text;
}
catch { throw; }
}
private static string DecryptString(string Message, string Passphrase)
{
byte[] Results;
using (var HashProvider = new SHA1CryptoServiceProvider())
{
byte[] TDESKey = HashProvider.ComputeHash(Encoding.UTF8.GetBytes(Passphrase));
Array.Resize(ref TDESKey, 16);
// Step 2. Create a new TripleDESCryptoServiceProvider object
using (TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider())
{
// Step 3. Setup the decoder
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
// Step 4. Convert the input string to a byte[]
byte[] DataToDecrypt = Convert.FromBase64String(Message);
// Step 5. Attempt to decrypt the string
try
{
using (ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor())
{
Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
}
}
finally
{
// Clear the TripleDes and Hashprovider services of any sensitive information
TDESAlgorithm.Clear();
HashProvider.Clear();
}
}
}
// Step 6. Return the decrypted string in UTF8 format
return Encoding.UTF8.GetString(Results, 0, Results.Length);
}
private bool Verify(int version, string privateMac, string privateHash,
string passphrase, string keyTypeName, string encryptionName, string comment, byte[] publicBlob, byte[] privateBlob)
{
byte[] macData;
using (MemoryStream macDataBuff = new MemoryStream()) {
if (version == 1) {
WriteMacData(macDataBuff, privateBlob);
}
else {
WriteMacData(macDataBuff, keyTypeName);
WriteMacData(macDataBuff, encryptionName);
WriteMacData(macDataBuff, comment);
WriteMacData(macDataBuff, publicBlob);
WriteMacData(macDataBuff, privateBlob);
}
macDataBuff.Close();
macData = macDataBuff.ToArray();
}
if (privateMac != null) {
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
byte[] a = Encoding.ASCII.GetBytes("putty-private-key-file-mac-key");
sha1.TransformBlock(a, 0, a.Length, null, 0);
byte[] b = Encoding.UTF8.GetBytes(passphrase);
sha1.TransformFinalBlock(b, 0, b.Length);
byte[] key = sha1.Hash;
sha1.Clear();
System.Security.Cryptography.HMACSHA1 hmacsha1 = new System.Security.Cryptography.HMACSHA1(key);
byte[] hash = hmacsha1.ComputeHash(macData);
hmacsha1.Clear();
string mac = BinToHex(hash);
return mac == privateMac;
}
else if (privateHash != null) {
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
byte[] hash = sha1.ComputeHash(macData);
sha1.Clear();
string mac = BinToHex(hash);
return mac == privateHash;
}
else {
return true;
}
}
private bool ValidateSignature(string token)
{
bool validate = false;
string[] arrTemp = new string[3];
arrTemp[0] = token;
string signature = Parameters.ContainsKey("signature") ? Parameters["signature"].ToString() : null;
arrTemp[1] = Parameters.ContainsKey("timestamp") ? Parameters["timestamp"].ToString() : null;
arrTemp[2] = Parameters.ContainsKey("nonce") ? Parameters["nonce"].ToString() : null;
//字典排序
Array.Sort(arrTemp);
string tmpStr = string.Join("", arrTemp);
byte[] sha1In = UTF8Encoding.Default.GetBytes(tmpStr);
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
byte[] sha1Out = sha1.ComputeHash(sha1In);
sha1.Clear();
tmpStr = BitConverter.ToString(sha1Out);
tmpStr = tmpStr.Replace("-", "").ToLower();
if (tmpStr == signature)
validate = true;
return validate;
}
/// <summary>
///
/// </summary>
/// <param name="FilePath"></param>
/// <returns></returns>
private static string getSha1Hash(string FilePath)
{
byte[] bs;
using (FileStream fs = new FileStream(FilePath, FileMode.Open, FileAccess.Read))
{
//SHA1CryptoServiceProviderオブジェクト
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
bs = sha1.ComputeHash(fs);
sha1.Clear();
}
StringBuilder result = new StringBuilder();
foreach (byte b in bs)
{
result.Append(b.ToString("x2"));
}
return (result.ToString());
}
private static byte[] PuTTYPassphraseToKey(string passphrase)
{
const int HASH_SIZE = 20;
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
byte[] pp = Encoding.UTF8.GetBytes(passphrase);
byte[] buf = new byte[HASH_SIZE * 2];
sha1.TransformBlock(new byte[] { 0, 0, 0, 0 }, 0, 4, null, 0);
sha1.TransformFinalBlock(pp, 0, pp.Length);
Buffer.BlockCopy(sha1.Hash, 0, buf, 0, HASH_SIZE);
sha1.Initialize();
sha1.TransformBlock(new byte[] { 0, 0, 0, 1 }, 0, 4, null, 0);
sha1.TransformFinalBlock(pp, 0, pp.Length);
Buffer.BlockCopy(sha1.Hash, 0, buf, HASH_SIZE, HASH_SIZE);
sha1.Clear();
byte[] key = new byte[32];
Buffer.BlockCopy(buf, 0, key, 0, key.Length);
return key;
}
/// <summary>
/// Takes a string of plain text and then returns a MD5 hash value
/// </summary>
/// <param name="plainText"></param>
/// <returns></returns>
public static string HashForKey(string plainText)
{
SHA1CryptoServiceProvider SHA1 = new SHA1CryptoServiceProvider();
byte[] byteV = System.Text.Encoding.UTF8.GetBytes(plainText);
byte[] byteH = SHA1.ComputeHash(byteV);
SHA1.Clear();
return Convert.ToBase64String(byteH);
}
/// <summary>
/// SHA1加密，等效于 PHP 的 SHA1() 代码
/// </summary>
/// <param name="source">被加密的字符串</param>
/// <returns>加密后的字符串</returns>
public static string SHA1_Encrypt(string source)
{
byte[] temp = Encoding.UTF8.GetBytes(source);
SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider();
byte[] temp2 = sha.ComputeHash(temp);
sha.Clear();
string output = BitConverter.ToString(temp2);
output = output.Replace("-","");
return output.ToLower();
}
/// <summary>
/// Determines whether the specified AssemblyInfo file in the given
/// <see cref="Stream" /> needs to be persisted.
/// </summary>
/// <param name="generatedAsmInfoStream"><see cref="Stream" /> holding the newly generated AssemblyInfo source.</param>
/// <returns>
/// <see langword="true" /> if the generated AssemblyInfo source needs
/// to be persisted; otherwise, <see langword="false" />.
/// </returns>
private bool NeedsPersisting(Stream generatedAsmInfoStream) {
// if output file doesn't exist, the stream will always need to be
// persisted to the filesystem.
if (!Output.Exists) {
Log(Level.Verbose, ResourceUtils.GetString("String_OutputFileDoesNotExist"),
Output.FullName);
return true;
}
byte[] existingAssemblyInfoHash = null;
byte[] generatedAssemblyInfoHash = null;
SHA1 hasher = new SHA1CryptoServiceProvider();
// hash existing AssemblyInfo source
using (FileStream fs = new FileStream(Output.FullName, FileMode.Open, FileAccess.Read)) {
existingAssemblyInfoHash = hasher.ComputeHash(fs);
}
// hash generated AssemblyInfo source
generatedAsmInfoStream.Position = 0;
generatedAssemblyInfoHash = hasher.ComputeHash(generatedAsmInfoStream);
// release all resources
hasher.Clear();
//compare hash of generated source with of existing source
if (Convert.ToBase64String(generatedAssemblyInfoHash) != Convert.ToBase64String(existingAssemblyInfoHash)) {
Log(Level.Verbose, ResourceUtils.GetString("String_OutputFileNotUpToDate"),
Output.FullName);
return true;
} else {
return false;
}
}
/// <summary>
/// SHA1加密，不可逆转
/// </summary>
/// <param name="str">string str:被加密的字符串</param>
/// <returns>返回加密后的字符串</returns>
public static string SHA1(string str)
{
System.Security.Cryptography.SHA1 s1 = new System.Security.Cryptography.SHA1CryptoServiceProvider();
byte[] byte1;
byte1 = s1.ComputeHash(Encoding.Default.GetBytes(str));
s1.Clear();
return Convert.ToBase64String(byte1);
}
public static string GetSignature(string accesstoken, string appId, string url, long timeStamp, string nonceStr)
{
var sb = new StringBuilder();
sb.Append("accesstoken=").Append(accesstoken).Append("&")
.Append("appid=").Append(appId).Append("&")
.Append("noncestr=").Append(nonceStr).Append("&")
.Append("timestamp=").Append(timeStamp.ToString()).Append("&")
.Append("url=")
.Append(url.Split('#')[0]);
byte[] temp1 = Encoding.UTF8.GetBytes(sb.ToString());
var sha = new SHA1CryptoServiceProvider();
var temp2 = sha.ComputeHash(temp1);
sha.Clear();
// 注意， 不能用这个
//string output = Convert.ToBase64String(temp2);
string output = BitConverter.ToString(temp2);
output = output.Replace("-", "");
output = output.ToLower();
return output;
}
/// <summary>
/// SHA1 加密
/// </summary>
/// <param name="password">要加密的字符串</param>
/// <returns>等效于此实例经过 SHA1 加密</returns>
public static string SHA1EncryptPassword(string password)
{
if (password == null)
{
throw new ArgumentNullException("password");
}
SHA1CryptoServiceProvider ServiceProvider = new SHA1CryptoServiceProvider();
string NewPassword = BitConverter.ToString(ServiceProvider.ComputeHash(Encoding.UTF8.GetBytes(password)));
ServiceProvider.Clear();
return NewPassword.Replace("-", null);
}
/// <summary>
///
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static string SHA1_Encrypt(string source)
{
byte[] bytes = Encoding.UTF8.GetBytes(source);
SHA1CryptoServiceProvider sHA1CryptoServiceProvider = new SHA1CryptoServiceProvider();
byte[] value = sHA1CryptoServiceProvider.ComputeHash(bytes);
sHA1CryptoServiceProvider.Clear();
string text = BitConverter.ToString(value);
text = text.Replace("-", "");
return text.ToLower();
}
