sha加密认证_spring提供的几种密码加密方式

㈠ sha256加密算法的证书怎么解密

1.浏览器将自己支持的一套加密规则发送给网站。
2.网站从中选出一组加密算法与HASH算法，并将自己的身份信息以证书的形式发回给浏览器。证书里面包含了网站地址，加密公钥，以及证书的颁发机构等信息。
3.浏览器获得网站证书之后浏览器要做以下工作：
a) 验证证书的合法性（颁发证书的机构是否合法，证书中包含的网站地址是否与正在访问的地址一致等），如果证书受信任，则浏览器栏里面会显示一个小锁头，否则会给出证书不受信的提示。
b) 如果证书受信任，或者是用户接受了不受信的证书，浏览器会生成一串随机数的密码，并用证书中提供的公钥加密。
c) 使用约定好的HASH算法计算握手消息，并使用生成的随机数对消息进行加密，最后将之前生成的所有信息发送给网站。
4.网站接收浏览器发来的数据之后要做以下的操作：
a) 使用自己的私钥将信息解密取出密码，使用密码解密浏览器发来的握手消息，并验证HASH是否与浏览器发来的一致。
b) 使用密码加密一段握手消息，发送给浏览器。
5.浏览器解密并计算握手消息的HASH，如果与服务端发来的HASH一致，此时握手过程结束，之后所有的通信数据将由之前浏览器生成的随机密码并利用对称加密算法进行加密。

㈡什么是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");
这样就可以和系统中所存储的识别码进行比较了!
--------北大青鸟西安华美---------

㈢ spring提供的几种密码加密方式

第一种：不使用任何加密方式的配置

[html]view plain

<beanid="AuthenticationProvider"
class="org.acegisecurity.providers..DaoAuthenticationProvider">
<propertyname="userDetailsService"ref="userDetailsService"/>
<!--<propertyname="passwordEncoder"><beanclass="org.acegisecurity.providers.encoding.PlaintextPasswordEncoder">
<propertyname="ignorePasswordCase"value="true"></property></bean></property>-->
</bean>

第二种：MD5方式加密

[html]view plain

<beanid="AuthenticationProvider"class="org.acegisecurity.providers..DaoAuthenticationProvider">
<propertyname="userDetailsService"ref="userDetailsService"/>
<propertyname="passwordEncoder">
<beanclass="org.acegisecurity.providers.encoding.Md5PasswordEncoder">
<propertyname="encodeHashAsBase64"value="false"/>
</bean>
</property>
</bean>

第三种：使用MD5加密，并添加全局加密盐

java代码

[html]view plain

<beanid="AuthenticationProvider"class="org.acegisecurity.providers..DaoAuthenticationProvider">
<propertyname="userDetailsService"ref="userDetailsService"/>
<propertyname="passwordEncoder">
<beanclass="org.acegisecurity.providers.encoding.Md5PasswordEncoder">
<propertyname="encodeHashAsBase64"value="false"/>
</bean>
</property>
<propertyname="saltSource">
<beanclass="org.acegisecurity.providers..salt.SystemWideSaltSource">
<propertyname="systemWideSalt"value="acegisalt"/>
</bean>
</property>
</bean>

第四种：使用MD5加密，并添加动态加密盐

[html]view plain

<beanid="AuthenticationProvider"class="org.acegisecurity.providers..DaoAuthenticationProvider">
<propertyname="userDetailsService"ref="userDetailsService"/>
<propertyname="passwordEncoder">
<beanclass="org.acegisecurity.providers.encoding.Md5PasswordEncoder">
<propertyname="encodeHashAsBase64"value="false"/>
</bean>
</property>
<propertyname="saltSource">
<beanclass="org.acegisecurity.providers..salt.ReflectionSaltSource">
<propertyname="userPropertyToUse"value="getUsername"/>
</bean>
</property>
</bean>

第五种：使用哈希算法加密，加密强度为256

[html]view plain

<beanid="AuthenticationProvider"class="org.acegisecurity.providers..DaoAuthenticationProvider">
<propertyname="userDetailsService"ref="userDetailsService"/>
<propertyname="passwordEncoder">
<beanclass="org.acegisecurity.providers.encoding.ShaPasswordEncoder">
<constructor-argvalue="256"/>
<propertyname="encodeHashAsBase64"value="false"/>
</bean>
</property>
</bean>

第六种：使用哈希算法加密，加密强度为SHA-256

[html]view plain

<beanid="AuthenticationProvider"class="org.acegisecurity.providers..DaoAuthenticationProvider">
<propertyname="userDetailsService"ref="userDetailsService"/>
<propertyname="passwordEncoder">
<beanclass="org.acegisecurity.providers.encoding.ShaPasswordEncoder">
<constructor-argvalue="SHA-256"/>
<propertyname="encodeHashAsBase64"value="false"/>
</bean>
</property>
</bean>

上述配置只是在Acegi通过表单提交的用户认证信息中的密码做各种加密操作。而我们存储用户密码的时候，可以通过一下程序完成用户密码操作：

[java]view plain

packageorg.hz.test;
importjava.security.NoSuchAlgorithmException;
importorg.springframework.security.authentication.encoding.Md5PasswordEncoder;
importorg.springframework.security.authentication.encoding.ShaPasswordEncoder;
publicclassMD5Test{
publicstaticvoidmd5(){
Md5PasswordEncodermd5=newMd5PasswordEncoder();
//false表示：生成32位的Hex版,这也是encodeHashAsBase64的,Acegi默认配置;true表示：生成24位的Base64版
md5.setEncodeHashAsBase64(false);
Stringpwd=md5.encodePassword("1234",null);
System.out.println("MD5:"+pwd+"len="+pwd.length());
}
publicstaticvoidsha_256(){
ShaPasswordEncodersha=newShaPasswordEncoder(256);
sha.setEncodeHashAsBase64(true);
Stringpwd=sha.encodePassword("1234",null);
System.out.println("哈希算法256:"+pwd+"len="+pwd.length());
}
publicstaticvoidsha_SHA_256(){
ShaPasswordEncodersha=newShaPasswordEncoder();
sha.setEncodeHashAsBase64(false);
Stringpwd=sha.encodePassword("1234",null);
System.out.println("哈希算法SHA-256:"+pwd+"len="+pwd.length());
}
publicstaticvoidmd5_SystemWideSaltSource(){
Md5PasswordEncodermd5=newMd5PasswordEncoder();
md5.setEncodeHashAsBase64(false);
//使用动态加密盐的只需要在注册用户的时候将第二个参数换成用户名即可
Stringpwd=md5.encodePassword("1234","acegisalt");
System.out.println("MD5SystemWideSaltSource:"+pwd+"len="+pwd.length());
}
publicstaticvoidmain(String[]args){
md5();//使用简单的MD5加密方式
sha_256();//使用256的哈希算法(SHA)加密
sha_SHA_256();//使用SHA-256的哈希算法(SHA)加密
md5_SystemWideSaltSource();//使用MD5再加全局加密盐加密的方式加密
}
}

㈣接口进行sha1加密是什么意思

sha1是一种常用的加密函数。
你可以查询你所使用的编程语言的手册去找sha1函数去处理数据然后将处理过的数据发送到接口即可。
没种语言的sha1函数名不一样。例如php的sha1函数名就交sha1()

㈤ php: sha1和 md5 两种加密的区别

MD5和SHA-1是目前使用比较广泛的散列(Hash)函数，也是在消息认证和数字签名中普遍使用的两种加密算法。本文基于AVR高速嵌入式单片机，实现了MD5和SHA-1两种加密算法的比较，并对算法进行了汇编语言的优化和改进。根据实验结果，对两种算法的

㈥ .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

}
}

㈦看加密中经常用到SHA-1，什么是SHA-1

要知道SHA-1首先要知道什么是Hash函数 hash函数

迭代Hash函数的结构

目前使用的大多数Hash函数（如MD5、SHA-1），其结构都是迭代型的，如下图所示，其中函数的输入M被分为L个分组Y0,Y1,Y2,…,YL-1，每一个分组的长度为b比特，如果最后一个分组的长度不够，需对其做填充。最后一个分组中还包括整个函数输入的长度值。这样，使得攻击者的攻击更为困难，即攻击者若想成功地产生假冒的消息，就必须保证假冒消息的Hash值与原消息的Hash值相同，而且长度也相等。

输出。消息的L个分组都被处理完后，最后一个分组的输出就是160比特的消息摘要。
（转载前请告知）

㈧为什么Google急着杀死加密算法SHA-1

大部分安全的网站正在使用一个不安全的算法，Google刚刚宣称这将是一个长周期的紧急情况。
大约90%采用SSL加密的网站使用SHA-1算法来防止自己的身份被冒充。当你去访问网址时，保证了你正在访问的确实是正品Facebook，而不是把自己的密码发送给攻击者。然而不幸的是，SHA-1算法是非常脆弱的，长期以来都是如此。该算法的安全性逐年降低，却仍然被广泛的应用在互联网上。它的替代者SHA-2足够坚固，理应被广泛支持。
最近谷歌声明如果你在使用Chrome浏览器，你将会注意到浏览器对大量安全的网站的警告会不断发生变化。

证书有效期至2017年的站点在Chrome中发生的变化

首批警告会在圣诞节之前出现，并且在接下来6个月内变得越来越严格。最终，甚至SHA-1证书有效期至2016的站点也会被给予黄色警告。

通过推出一系列警告，谷歌这正在宣布一个长周期的紧急情况，并督促人们在情况恶化之前更新他们的网站。这是件好事情，因为SHA-1是时候该退出历史舞台了，而且人们没有足够重视SHA-1的潜在风险。

如果你拥有一个使用SSL的网站，你可以使用我创建的SHA-1测试小工具来测试你的网站，它会告诉你应该怎么做。即使你没有网站，我仍然推荐你去读一读。在接下来的博文，我会介绍网站上SSL和SHA-1是如何一起工作的，为什么如谷歌说的那么紧急，和浏览器正在采取的措施。

同样重要的是，安全社区需要让证书更换过程少些痛苦和麻烦，因为网站的安全升级不必那么紧急和匆忙。

FreeBuf科普：安全散列算法与SHA-1

安全散列算法（英语：Secure Hash Algorithm）是一种能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。且若输入的消息不同，它们对应到不同字符串的机率很高；而SHA是FIPS所认证的五种安全散列算法。这些算法之所以称作“安全”是基于以下两点（根据官方标准的描述）：

1、由消息摘要反推原输入消息，从计算理论上来说是很困难的。
2、想要找到两组不同的消息对应到相同的消息摘要，从计算理论上来说也是很困难的。任何对输入消息的变动，都有很高的机率导致其产生的消息摘要迥异。
SHA (Secure Hash Algorithm，译作安全散列算法) 是美国国家安全局 (NSA) 设计，美国国家标准与技术研究院(NIST) 发布的一系列密码散列函数。

㈨ SHA512加密问题

你好SHA512不是加密算法，他是一个签名算法，加密和签名的区别是利用加密的结果加上密钥是可以得到明文的。但是利用签名的结果是无论如何也得不出明文的。签名算法很重要的一个特点就是输入有一点点的变化，输出就会发生很大的改变，所以基本上是不可以利用密文来推出明文的，这个也是这个为什么叫做签名算法的原因，一个输入对应一个结果，输入一变结果就变化很大。

㈩ SHA256 加密后能不能解密

SHA是散列算法，不是加密算法，不存在解密的问题。

原因：

对数据解密破解就是找到任意一个源数据，能够生成相同的目标数据。

SHA256基本上是不可破解的，即找不到（或概率极小）“碰撞”结果。

网站的解密规则：

网站从浏览器发送过来的信息当中选出一组加密算法与HASH算法，并将自己的身份信息以证书的形式发回给浏览器。证书里面包含了网站地址，加密公钥，以及证书的颁发机构等信息。

(10)sha加密认证扩展阅读：

加密解密过程中，浏览器对网站的验证：

1、验证证书的合法性（颁发证书的机构是否合法，证书中包含的网站地址是否与正在访问的地址一致等），如果证书受信任，则浏览器栏里面会显示一个小锁头，否则会给出证书不受信的提示。

2、如果证书受信任，或者是用户接受了不受信的证书，浏览器会生成一串随机数的密码，并用证书中提供的公钥加密。

3、使用约定好的HASH算法计算握手消息，并使用生成的随机数对消息进行加密，最后将之前生成的所有信息发送给网站。

导航:首页 > 文档加密 > sha加密认证

sha加密认证

与sha加密认证相关的资料