常见的⼏种安全加密算法
本⽂整理了常见的安全算法，包括MD5、SHA、DES、AES、RSA等，并写了完整的⼯具类（Java 版），⼯具类包含测试，⼤家可以放⼼使⽤。
⼀、数字摘要算法
数字摘要也称为消息摘要，它是⼀个唯⼀对应⼀个消息或⽂本的固定长度的值，它由⼀个单向Hash函数对消息进⾏计算⽽产⽣。如果消息在传递的途中改变了，接收者通过对收到消息采⽤相同的Hash重新计算，新产⽣的摘要与原摘要进⾏⽐较，就可知道消息是否被篡改了，因此消息摘要能够验证消息的完整性。消息摘要采⽤单向Hash函数将需要计算的内容”摘要”成固定长度的串，这个串亦称为数字指纹。这个串有固定的长度，且不同的明⽂摘要成密⽂，其结果总是不同的(相对的)，⽽同样的明⽂其摘要必定⼀致。这样这串摘要便可成为验证明⽂是否是”真⾝”的”指纹”了。
1. Md5
MD5即Message Digest Algorithm 5(信息摘要算法5)，是数字摘要算法⼀种实现，⽤于确保信息传输完整性和⼀致性，摘要长度为128位。 MD5由MD4、 MD3、 MD2改进⽽来，主要增强算法复杂度和不可逆性，该算法因其普遍、稳定、快速的特点，在产业界得到了极为⼴泛的使⽤，⽬前主流的编程语⾔普遍都已有MD5算法实现。
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
/**
* Message Digest Algorithm 5(信息摘要算法5)
*/
public class MD5Util {
/**
* Constructs the MD5Util object and sets the string whose MD5Util is to be
* computed.
*
* @param inStr
*    the <code>String</code> whose MD5Util is to be computed
*/
public final static String COMMON_KEY="zhongzhuoxin#@!321";
public MD5Util() {
}
public final static String str2MD5(String inStr) {
char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f' };
try {
byte[] strTemp = Bytes("UTF-8");
MessageDigest mdTemp = Instance("MD5");
mdTemp.update(strTemp);
byte[] md = mdTemp.digest();
int j = md.length;
char str[] = new char[j * 2];
int k = 0;
for (int i = 0; i < j; i++) {
byte byte0 = md[i];
str[k++] = hexDigits[byte0 >>> 4 & 0xf];
str[k++] = hexDigits[byte0 & 0xf];
}
return new String(str);
} catch (Exception e) {
return null;
}
}
//--MD5Util
private static final char HEX_DIGITS[] = { '0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
public static String toHexString(byte[] b) { // String to byte
StringBuilder sb = new StringBuilder(b.length * 2);
for (int i = 0; i < b.length; i++) {
sb.append(HEX_DIGITS[(b[i] & 0xf0) >>> 4]);
sb.append(HEX_DIGITS[b[i] & 0x0f]);
}
String();
}
public static String AndroidMd5(String s) {
try {
// Create MD5Util Hash
MessageDigest digest = MessageDigest
.getInstance("MD5");
digest.Bytes());
byte messageDigest[] = digest.digest();
return toHexString(messageDigest);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return"";
}
public static void main(String[] args) {
String m = MD5Util.str2MD5("swwwwwwwwwwdkinner");
System.out.print(m.length() + "    ");
System.out.println(m);
}
}
2.SHA
SHA的全称是Secure Hash Algorithm，即安全散列算法。 1993年，安全散列算法(SHA)由美国国家标准和技术协会（NIST)提出，并作为联邦信息处理标准(FIPS PUB 180)公布， 1995年⼜发布了⼀个修订版FIPS PUB 180-1，通常称之为SHA-1。 SHA-1是基于MD4算法的，现在已成为公认的最安全的散列算法之⼀，并被⼴泛使⽤。SHA-1算法⽣成的摘要信息的长度为160位，由于⽣成的摘要信息更长，运算的过程更加复杂，在相同的硬件上， SHA-1的运⾏速度⽐MD5更慢，但是也更为安全。
lemon.base.Strings;
import java.security.MessageDigest;
/**
* SHA的全称是Secure Hash Algorithm，即安全散列算法
* Created by fangzhipeng on 2017/3/21.
*/
public class SHAUtil {
* 定义加密⽅式
*/
private final static String KEY_SHA = "SHA";
private final static String KEY_SHA1 = "SHA-1";
/**
* 全局数组
*/
private final static String[] hexDigits = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
/**
* 构造函数
*/
public SHAUtil() {
}
/**
* SHA 加密
* @param data 需要加密的字节数组
* @return加密之后的字节数组
* @throws Exception
*/
public static byte[] encryptSHA(byte[] data) throws Exception {
// 创建具有指定算法名称的信息摘要
/
/        MessageDigest sha = Instance(KEY_SHA);        MessageDigest sha = Instance(KEY_SHA1);
// 使⽤指定的字节数组对摘要进⾏最后更新
sha.update(data);
// 完成摘要计算并返回
return sha.digest();
}
/**
* SHA 加密
* @param data 需要加密的字符串
* @return加密之后的字符串
* @throws Exception
*/
public static String encryptSHA(String data) throws Exception {
// 验证传⼊的字符串
if (Strings.isNullOrEmpty(data)) {
return"";
}
// 创建具有指定算法名称的信息摘要
MessageDigest sha = Instance(KEY_SHA);
// 使⽤指定的字节数组对摘要进⾏最后更新
sha.Bytes());
// 完成摘要计算
byte[] bytes = sha.digest();
java加密方式有哪些// 将得到的字节数组变成字符串返回
return byteArrayToHexString(bytes);
}
/**
* 将⼀个字节转化成⼗六进制形式的字符串
* @param b 字节数组
* @return字符串
*/
private static String byteToHexString(byte b) {
int ret = b;
/
/System.out.println("ret = " + ret);
if (ret < 0) {
ret += 256;
int m = ret / 16;
int n = ret % 16;
return hexDigits[m] + hexDigits[n];
}
/**
* 转换字节数组为⼗六进制字符串
* @param bytes 字节数组
* @return⼗六进制字符串
*/
private static String byteArrayToHexString(byte[] bytes) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < bytes.length; i++) {
sb.append(byteToHexString(bytes[i]));
}
String();
}
/**
* 测试⽅法
* @param args
*/
public static void main(String[] args) throws Exception {
String key = "123";
System.out.println(encryptSHA(key));
}
}
⼆、对称加密
对称加密算法是应⽤较早的加密算法，技术成熟。在对称加密算法中，数据发送⽅将明⽂(原始数据)和加密密钥⼀起经过特殊加密算法处理后，⽣成复杂的加密密⽂进⾏发送，数据接收⽅收到密⽂后，若想读取原⽂，则需要使⽤加密使⽤的密钥及相同算法的逆算法对加密的密⽂进⾏解密，才能使其恢复成可读明⽂。在对称加密算法中，使⽤的密钥只有⼀个，发送和接收双⽅都使⽤这个密钥对数据进⾏加密和解密，这就要求加密和解密⽅事先都必须知道加密的密钥。
1. DES算法
1973 年，美国国家标准局(NBS)在认识到建⽴数据保护标准既明显⼜急迫的情况下，开始征集联邦数据加密标准的⽅案。 1975 年3⽉17⽇， NBS公布了IBM公司提供的密码算法，以标准建议的形式在全国范围内征求意见。经过两年多的公开讨论之后， 1977 年7⽉15⽇， NBS宣布接受这建议，作为联邦信息处理标准46 号数据加密标准(Data Encryptin Standard)，即DES正式颁布，供商业界和⾮国防性政府部门使⽤。DES算法属于对称加密算法，明⽂按64位进⾏分组，密钥长64位，但事实上只有56位参与DES运算(第8、 16、 24、 32、 40、 48、 56、 64位是校验位，使得每个密钥都有奇数个1)，分组后的明⽂和56位的密钥按位替代或交换的⽅法形成密⽂。由于计算机运算能⼒的增强，原版DES密码的密钥长度变得容易被暴⼒破解，因此演变出了3DES算法。 3DES是DES向AES过渡的加密算法，它使⽤3条56位的密钥对数据进⾏三次加密，是DES的⼀个更安全的变形。
import java.io.IOException;
import java.security.SecureRandom;
pto.Cipher;
pto.SecretKey;
pto.SecretKeyFactory;
pto.spec.DESKeySpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/**
* Data Encryptin Standard
* 数据加密标准
*/
public class DESUtil {
private final static String DES = "DES";
/**
* Description 根据键值进⾏加密
*
* @param data
* @param key  加密键byte数组
* @return
* @throws Exception
*/
public static String encrypt(String data, String key) throws Exception {
byte[] bt = Bytes(), Bytes());
String strs = new BASE64Encoder().encode(bt);
return strs;
}
/
**
* Description 根据键值进⾏解密
*
* @param data
* @param key  加密键byte数组
* @return
* @throws IOException
* @throws Exception
*/
public static String decrypt(String data, String key) throws Exception,
Exception {
if (data == null)
return null;
BASE64Decoder decoder = new BASE64Decoder();
byte[] buf = decoder.decodeBuffer(data);
byte[] bt = decrypt(buf, Bytes());
return new String(bt);
}
/**
* Description 根据键值进⾏加密
*
* @param data
* @param key  加密键byte数组
* @return
* @throws Exception
*/
private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
// ⽣成⼀个可信任的随机数源
SecureRandom sr = new SecureRandom();
// 从原始密钥数据创建DESKeySpec对象
DESKeySpec dks = new DESKeySpec(key);
// 创建⼀个密钥⼯⼚，然后⽤它把DESKeySpec转换成SecretKey对象        SecretKeyFactory keyFactory = Instance(DES);        SecretKey securekey = ateSecret(dks);
// Cipher对象实际完成加密操作
Cipher cipher = Instance(DES);
// ⽤密钥初始化Cipher对象
cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。