sha加密演算法實現

❶ php的SHA1加密演算法

substr(md5($SHA1),5,20) 試試這個

❷ openssl sha256加密演算法怎麼使用

C#自帶的類庫實現sha265會返回一個byte[] 數組 這個數組的長度是32，js的sha265是64，是把每個byte直接轉換成了2個hex字元串。 C#中加密後是44位是因為把這個數組用base64編碼成了字元串。 C#中也直接把byte轉換成對應的hex字元串就和js中一樣了

❸ 密碼加密的方法有那些

用戶密碼加密方式

用戶密碼保存到資料庫時，常見的加密方式有哪些?以下幾種方式是常見的密碼保存方式：

1. 明文保存

比如用戶設置的密碼是「123456」，直接將「123456」保存在資料庫中，這種是最簡單的保存方式，也是最不安全的方式。但實際上不少互聯網公司，都可能採取的是這種方式。

2. 對稱加密演算法來保存

比如3DES、AES等演算法，使用這種方式加密是可以通過解密來還原出原始密碼的，當然前提條件是需要獲取到密鑰。不過既然大量的用戶信息已經泄露了，密鑰很可能也會泄露，當然可以將一般數據和密鑰分開存儲、分開管理，但要完全保護好密鑰也是一件非常復雜的事情，所以這種方式並不是很好的方式。

總結

採用PBKDF2、bcrypt、scrypt等演算法可以有效抵禦彩虹表攻擊，即使數據泄露，最關鍵的「用戶密碼」仍然可以得到有效的保護，黑客無法大批量破解用戶密碼，從而切斷撞庫掃號的根源。

【加密軟體編輯推薦】
易控網盾加密軟體--重要文件防泄密專家！輕松實現單位內部文件自動加密保護，加密後的文件在單位內部正常流轉使用。未經許可，任何私自拷貝加密文件外發出去，都將打開為亂碼，無法使用！對於發送給客戶等第三方的文件，可實現控制打開時間和打開次數等防泄密參數！同時可設置對員工電腦文件自動備份，防止惡意刪除造成核心數據的遺失！從源頭防止企業核心文件被外泄！
相關頁面：加密軟體，文件加密，文檔加密，圖紙加密軟體，防泄密軟體，CAD加密軟體，文件外發加密

❹ 有沒有 sha2048 加密方式

SHA2048 是可以有的，但是有沒有必要用這個演算法就是一個問題了，因為SHA本身不是加密，它只是用來計算一個輸入對應的唯一的哈希數組。從而保證我們收到的數據沒有被修改過。從這個演算法的作用上來說sha256已經足夠好了，沒有必要使用SHA2048.

❺ 什麼是SHA1加密技術

Algorithm)又叫安全哈希加密技術，是當今世界最先近的加密演算法。主要用於文件身份識別、數字簽名和口令加密等。
對於明文信息A，通過SHA1演算法，生成一條160位長的識別碼B。且明文信息A和識別碼B之間同時滿足以下條件:
1、對於任意兩條不同的明文信息A1、A2，其識別碼B1、B2都不相同。
2、無法通過逆向演算法由識別碼B倒推出明文信息A。
MOONCRM的用戶密碼採用SHA1加密存儲，即伺服器上存儲的只是
由用戶密碼生成的識別碼，而用戶密碼本身並沒有存儲在伺服器上。用戶輸入登陸口令時，系統會根據輸入口令生成相應識別碼並與系統中所存儲的識別碼進行比較，如二者一致，則認為口令正確。系統中沒有存儲用戶原始的口令值，即使有人獲得口令文件，也無法破解用戶登陸密碼，確保用戶密碼絕對安全。
在ASP.NET中，可以通過以下命令來加密密碼字元串:
//passwordString是密碼字元串
System.Web.Security.FormsAuthentication.
(passwordString,
"SHA1");
這樣就可以和系統中所存儲的識別碼進行比較了!
--------北大青鳥西安華美---------

❻ 如何使用java進行sha1加密

使用下面的語句即可：
digestutils.shahex(要加密的字元);加密參數最好用位元組數組，畢竟sha1演算法是使用位元組為單位進行運算的，字元串轉位元組還與字元編碼有關。

❼ 求php的SHA-1加密演算法。

SHA-1與MD5都是摘要演算法，且為不可逆演算法；

應用角度來講，適用性比安全性重要，兩個演算法長度有所不同，SHA-1160位，MD5128位。

如果從安全形度，在計算出摘要後，對摘要進行簽名，可以增加抗抵賴、防篡改的能力，詳情請查看數字簽名的資料。

❽ 如何使用C#的SHA1對字元串加密

private static string SHA1(string text)
{
byte[] cleanBytes = Encoding.Default.GetBytes(text);
byte[] hashedBytes = System.Security.Cryptography.SHA1.Create().ComputeHash(cleanBytes);
return BitConverter.ToString(hashedBytes).Replace("-", "");
}

調用這個函數就可以得到你要的sha1值了。
另外還有個概念要澄清，SHA1是散列演算法，不是加密。

❾ 在C#中的sha256加密和js中的sha256加密

C#自帶的類庫實現sha265會返回一個byte[] 數組

這個數組的長度是32，js的sha265是64，是把每個byte直接轉換成了2個hex字元串。

C#中加密後是44位是因為把這個數組用base64編碼成了字元串。

C#中也直接把byte轉換成對應的hex字元串就和js中一樣了。

另外，把str轉換成byte[]數組的Encoding 如果不同，sha是不同的，一般js的都是utf8.

請參考

publicstaticstringSHA256(stringstr)
{
//如果str有中文，不同Encoding的sha是不同的！！
byte[]SHA256Data=Encoding.UTF8.GetBytes(str);

SHA256ManagedSha256=newSHA256Managed();
byte[]by=Sha256.ComputeHash(SHA256Data);

returnBitConverter.ToString(by).Replace("-","").ToLower();//64
//returnConvert.ToBase64String(by);//44
}

staticvoidMain(string[]args)
{
strings="helloworld";
//sha265=
stringsha=SHA256(s);
Console.WriteLine("{0}
{1}
Length:{2}",s,sha,sha.Length);
}

❿ .net sdk實現sha1加密演算法和簽名驗證

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security.Cryptography;
using System.Text;

//xlding, 2013/07/25

namespace Gemr.Utils
{
public class CommonAlgorithms
{
#region Sort

public static string[] BubbleSort(string[] array)
{
int length = array.Length;
for (int i = 0; i <= length - 1; i++)
{
for (int j = length - 1; j > i; j--)
{
if (array[j].CompareTo(array[j - 1]) < 0)
{
string temp = array[j];
array[j] = array[j - 1];

array[j - 1] = temp;
}
}
}
return array;
}

#endregion Sort

private static char[] constant =
{
'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'
};

public byte[] ConvertStringToByteArray(string str)
{
if (string.IsNullOrEmpty(str)) return null;

byte[] byteArray = System.Text.Encoding.Default.GetBytes(str);

return byteArray;

}

public static string GenerateRandom(int Length)
{
System.Text.StringBuilder newRandom = new System.Text.StringBuilder(52);
Random rd = new Random();
for (int i = 0; i < Length; i++)
{
newRandom.Append(constant[rd.Next(52)]);
}
return newRandom.ToString();
}

/// <summary>
/// Put the object serialization for byte array
/// </summary>
public static byte[] SerializeObject(object obj)
{
if (obj == null)
return null;
MemoryStream ms = new MemoryStream();
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(ms, obj);
ms.Position = 0;
byte[] bytes = new byte[ms.Length];
ms.Read(bytes, 0, bytes.Length);
ms.Close();
return bytes;
}

/// <summary>
/// Byte array reverse serialized into object
/// </summary>
public static object DeserializeObject(byte[] bytes)
{
object obj = null;
if (bytes == null)
return obj;
MemoryStream ms = new MemoryStream(bytes);
ms.Position = 0;
BinaryFormatter formatter = new BinaryFormatter();
obj = formatter.Deserialize(ms);
ms.Close();
return obj;
}

public static string ConvertByteArrayToString(byte[] byteArray)
{
if (byteArray == null || byteArray.Length == 0) return null;

string str = System.Text.Encoding.Default.GetString(byteArray);

return str;
}

//public static string ByteToString(byte[] value)
//{
// StringBuilder sb = new StringBuilder();
// for (int i = 0; i < value.Length; i++)
// {
// sb.Append(value[i].ToString("x2"));
// }
// return sb.ToString();
//}

#region SHA1 (數字簽名)

public static string GetSHA1(string strSource)
{
string strResult = "";

//Create
System.Security.Cryptography.SHA1 sha = System.Security.Cryptography.SHA1.Create();
byte[] bytResult = sha.ComputeHash(System.Text.Encoding.UTF8.GetBytes(strSource));
for (int i = 0; i < bytResult.Length; i++)
{
strResult = strResult + bytResult[i].ToString("X2");
}
return strResult;
}

public static byte[] GetSHA1(byte[] value)
{
System.Security.Cryptography.SHA1 sha = System.Security.Cryptography.SHA1.Create();
return sha.ComputeHash(value);
}

#endregion SHA1

#region DES

/**/
/// <summary>
/// DES加密
/// </summary>
/// <param name="encryptString"></param>
/// <returns></returns>
public static string DesEncrypt(string encryptString, string sKey)
{

using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
{
byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
des.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
System.IO.MemoryStream ms = new System.IO.MemoryStream();
using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
cs.Close();
}
string str = Convert.ToBase64String(ms.ToArray());
ms.Close();
return str;
}

}

/**/
/// <summary>
/// DES解密
/// </summary>
/// <param name="decryptString"></param>
/// <returns></returns>
public static string DesDecrypt(string decryptString, string sKey)
{

byte[] inputByteArray = Convert.FromBase64String(decryptString);
using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
{
des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
des.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
System.IO.MemoryStream ms = new System.IO.MemoryStream();
using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
cs.Close();
}
string str = Encoding.UTF8.GetString(ms.ToArray());
ms.Close();
return str;
}

}

#endregion DES

#region AES

#region Use static key

private static readonly byte[] aesKey = { 0x03, 0x00, 0x52, 0xc3, 0x03, 0x00, 0x52, 0xc3, 0x03, 0x00, 0x52, 0xc3,

0x03, 0x00, 0x52, 0xc3 };

public static string StaticAeskey
{
get { return System.Text.Encoding.Default.GetString(aesKey); }
}

/// <summary>
/// AES encode.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static string AesEncode(string value)
{
using (Aes aes = Aes.Create())
{
using (ICryptoTransform encryptor = aes.CreateEncryptor(aesKey, aesKey))
{
byte[] buffer = Encoding.UTF8.GetBytes(value);
buffer = encryptor.TransformFinalBlock(buffer, 0, buffer.Length);
return Convert.ToBase64String(buffer);
}
}
}

/// <summary>
/// AES decode.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static string AesDecode(string value)
{
using (Aes aes = Aes.Create())
{
using (ICryptoTransform decryptor = aes.CreateDecryptor(aesKey, aesKey))
{
byte[] buffer = Convert.FromBase64String(value);
buffer = decryptor.TransformFinalBlock(buffer, 0, buffer.Length);
return Encoding.UTF8.GetString(buffer);
}
}
}

#endregion Use static key

public static byte[] GetKey()
{

Random rd = new Random();
byte[] key = new byte[16];
rd.NextBytes(key);
return key;
}

public static byte[] AesEncode(byte[] key, byte[] value)
{
using (Aes aes = Aes.Create())
{
using (ICryptoTransform encryptor = aes.CreateEncryptor(key, key))
{
return encryptor.TransformFinalBlock(value, 0, value.Length);
}
}
}

public static byte[] AesDecode(byte[] key, byte[] value)
{
using (Aes aes = Aes.Create())
{
using (ICryptoTransform decryptor = aes.CreateDecryptor(key, key))
{
return decryptor.TransformFinalBlock(value, 0, value.Length);
}
}
}

#endregion AES

}
}