Java 加解密算法

最新推荐文章于 2022-05-29 23:47:27 发布

weixin_30352645

最新推荐文章于 2022-05-29 23:47:27 发布

阅读量65

点赞数

文章标签： java

原文链接：http://www.cnblogs.com/jiaowoxiaofeng/p/10582304.html

版权

目前加密算法中分两种

一种是对称加密，一种是非对称加密

那么什么是对称加密呢？对称加密可以理解为加密和解密用的是一个钥匙。

而非对称加密，加锁用的是一个钥匙，而解锁用的是另外一个钥匙。

目前市面上用的比较多的对称加密，比如Md5,SHA，AES下面就直接上代码

所需要引入的包为：

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.math.BigInteger;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.LinkedHashMap;
import java.util.Map;

写代码之前，要写一个工具类Base64,为什么要这个类呢？因为我们不管是对称加密

还是非对称加密，他加密后返回的默认都是二进制字节类型的。这种数据我们拿到也看不懂

所以，一般有两种解决方案第一种就是通过Base64把二进制字节转为字符串，另一种就是转为16进制字符串

这里我就以Base64作为转换，在写一个解码的。因为某些加密算法需要传入的是二进制字节

public class Base64Util {
//转换为Base64
public static String base64Enc(byte[] msg) {
return Base64.getEncoder().encodeToString(msg);
}
//解码
public static byte[] base64Dec(String msg) {
return Base64.getDecoder().decode(msg);
}
}

-----------------Md5加密代码

public class EncryptUtil {

public static final String SHA1 = "SHA-1";
public static final String SHA256 = "SHA-256";
public static final String SHA512 = "SHA-512";
public static final String ENCODING = "UTF-8"；

//公钥
public static final String PUBKEY = "publicKey";
//私钥
public static final String PRIKEY = "privateKey";

public static String md5Enc(String msg) {
try {
MessageDigest digest = MessageDigest.getInstance("MD5");
digest.update(msg.getBytes(ENCODING));
return new BigInteger(1, digest.digest()).toString(16);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}　　　　

-------------------SHA加密代码，参数是一个 SHA类型，目前有 1，256，521.z还有一个需要加密的字符串

具体代码为：

public static String SHAEnc(String type, String msg) {
try {
MessageDigest digest = MessageDigest.getInstance(type);
digest.update(msg.getBytes(ENCODING));
return new BigInteger(1, digest.digest()).toString(16);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}

测试结果

：

------------------------------AES 加密算法。这个是需要密钥生成器的。自己可以保管密钥。如果下要破解，必须

知道加密方式和密钥。相对前面两个安全级别要高许多

public static byte[] createAESKey() {
try {
// 创建秘钥生成器
KeyGenerator generator = KeyGenerator.getInstance("AES");
// 完成秘钥初始化 AES的128
generator.init(128);
// 生成秘钥
SecretKey key = generator.generateKey();
return key.getEncoded();
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}

// AES加密返回值base64
public static String AESEnc(byte[] key, String msg) {
// 转换秘钥
SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
try {
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, keySpec);
byte[] r = cipher.doFinal(msg.getBytes(ENCODING));
return Base64Util.base64Enc(r);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
// AES解密
public static String AESDec(byte[] key, String msg) {
// 转换秘钥
SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
try {
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, keySpec);
byte[] r = cipher.doFinal(Base64Util.base64Dec(msg));
return new String(r, ENCODING);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}

继续测试

以上的加密方式都是对称加密。只要拿到密钥就会有风险。

下面介绍一款号称最安全的加密方式就是RSA加密公钥加密私钥解密

或者私钥加密公钥解密。一般来说都是私钥加密，公钥解密不废话直接上代码

// RSA
// 创建秘钥
// 创建秘钥 1024
public static Map<String, String> createRSAKey() {
try {
// 创建秘钥生成器
KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
// 完成秘钥初始化
generator.initialize(1024);
// 生成秘钥
KeyPair keyPair = generator.generateKeyPair();

Map<String, String> map = new LinkedHashMap<String, String>();
// 获取公钥
map.put(PUBKEY, Base64Util.base64Enc(keyPair.getPublic().getEncoded()));
// 获取私钥
map.put(PRIKEY, Base64Util.base64Enc(keyPair.getPrivate().getEncoded()));
return map;
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
// 获取公钥
public static PublicKey getPubKey(String key) {
try {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64Util.base64Dec(key));
return (PublicKey) keyFactory.generatePublic(keySpec);
} catch (Exception e) {
// TODO: handle exception
}
return null;
}
// 获取私钥
public static PrivateKey getPriKey(String key) {
try {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64Util.base64Dec(key));
return (PrivateKey) keyFactory.generatePrivate(keySpec);
} catch (Exception e) {
// TODO: handle exception
}
return null;
}
// RSA 私钥加密返回值base64
public static String RSAEnc(String key, String msg) {
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, getPriKey(key));
byte[] r = cipher.doFinal(msg.getBytes(ENCODING));
return Base64Util.base64Enc(r);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
// RSA解密
public static String RSADec(String key, String msg) {
// 转换秘钥
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, getPubKey(key));
byte[] r = cipher.doFinal(Base64Util.base64Dec(msg));
return new String(r,ENCODING);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;