常见加密算法
程序员文章站
2024-03-16 19:54:40
...
package com.test.encryptionTest;
import java.io.UnsupportedEncodingException;
import java.security.Key;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.KeySpec;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
/**
* <pre>
* md5\sha-1\byte2hex\base64\des\aes
* </pre>
* @Description: 常用加密算法
* @author lc
* @date 2018年8月4日 下午5:20:53
*/
public class EncryptTest {
/**
* MD5
*/
public static String getMD5(String plain){
try {
byte[] btIn=plain.getBytes("UTF-8");
MessageDigest md=MessageDigest.getInstance("MD5");
md.update(btIn);
return byteArr2HexStr(md.digest());
} catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* sha-1
*/
public static String getSha1(String plain){
try {
byte[] btIn=plain.getBytes("UTF-8");
MessageDigest md=MessageDigest.getInstance("SHA-1");
md.update(btIn);
return byteArr2HexStr(md.digest());
} catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 十六进制编码
*/
public static String byte2hex(byte[] bs){
StringBuilder sb=new StringBuilder();
String stmp;
for (int i = 0; bs!=null&& i < bs.length; i++) {
stmp=Integer.toHexString(bs[i]&0XFF);
if (stmp.length()==1) {
sb.append("0");
}
sb.append(stmp);
}
return sb.toString().toUpperCase();
}
/**
* Base64编码
*/
public static String encode(String origin){
return new String(new Base64().encode(origin.getBytes()));
}
/**
* Base64解码
*/
public static String decode(String encode){
return new String(new Base64().decode(encode.getBytes()));
}
/**
* DES加密
*/
public static String DESencrypt(String data,String secretKey){
try {
//创建一个密匙工厂，获取密匙key
Key key=SecretKeyFactory.getInstance("DES").generateSecret(new DESKeySpec(secretKey.getBytes()));
//Cipher对象
Cipher cipher=Cipher.getInstance("DES/CBC/PKCS5Padding");
IvParameterSpec iv=new IvParameterSpec(secretKey.getBytes());//KeySpec.getkey()
//用密匙初始化Cipher对象
cipher.init(Cipher.ENCRYPT_MODE, key, iv);
//获取数据并正式执行加密操作
return byteArr2HexStr(cipher.doFinal(data.getBytes("UTF-8")));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* DES解密
*/
public static String DESdecrypt(String encrypt,String secretKey){
try {
Key key=SecretKeyFactory.getInstance("DES").generateSecret(new DESKeySpec(secretKey.getBytes()));
Cipher cipher=Cipher.getInstance("DES/CBC/PKCS5Padding");
IvParameterSpec iv=new IvParameterSpec(secretKey.getBytes());//KeySpec.getkey()
cipher.init(Cipher.DECRYPT_MODE, key, iv);
return new String(cipher.doFinal(hexStr2ByteArr(encrypt)));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* byte[]转HEX
*/
public static String byteArr2HexStr(byte[] bytes) {
StringBuffer sb = new StringBuffer(bytes.length);
String sTemp;
for (int i = 0; i < bytes.length; i++) {
sTemp = Integer.toHexString(0xFF & bytes[i]);
if (sTemp.length() < 2)
sb.append(0);
sb.append(sTemp.toUpperCase());
}
return sb.toString();
}
/**
* HEX转byte[]
*/
public static byte[] hexStr2ByteArr(String strIn) throws Exception {
byte[] arrB = strIn.getBytes();
int iLen = arrB.length;
byte[] arrOut = new byte[iLen / 2];
for (int i = 0; i < iLen; i = i + 2) {
String strTmp = new String(arrB, i, 2);
arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
}
return arrOut;
}
/**
* AES加密
*/
public static String AESencrypt(String data,String secretKey){
try {
KeyGenerator kgen=KeyGenerator.getInstance("AES");
SecureRandom secureRandom=SecureRandom.getInstance("SHA1PRNG");
secureRandom.setSeed(secretKey.getBytes());
kgen.init(128, secureRandom); //keysize=128, 192 or 256
SecretKey secKey=kgen.generateKey();
byte[] encodeFormat=secKey.getEncoded();
SecretKeySpec key=new SecretKeySpec(encodeFormat, "AES");
Cipher cipher=Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, key);
return byteArr2HexStr(cipher.doFinal(data.getBytes("UTF-8")));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* AES解密
*/
public static String AESdecrypt(String encrypt,String secretKey){
try {
KeyGenerator kgen=KeyGenerator.getInstance("AES");
SecureRandom secureRandom=SecureRandom.getInstance("SHA1PRNG");
secureRandom.setSeed(secretKey.getBytes());
kgen.init(128, secureRandom); //keysize=128, 192 or 256
SecretKey secKey=kgen.generateKey();
byte[] encodeFormat=secKey.getEncoded();
SecretKeySpec key=new SecretKeySpec(encodeFormat, "AES");
Cipher cipher=Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, key);
return new String(cipher.doFinal(hexStr2ByteArr(encrypt)));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
public static void main(String[] args) throws UnsupportedEncodingException {
String origin="{'name':'孙悟空','value':'123456'}";
System.out.println("原数据="+origin);
//md5
System.out.println("原数据md5后="+getMD5(origin));
//sha1
System.out.println("原数据SHA-1后="+getSha1(origin));
//16进制
System.out.println("原数据16进制编码后="+byte2hex(origin.getBytes()));
//base64
String encode=encode(origin);
System.out.println("原数据BASE64编码后="+encode);
System.out.println("原数据BASE64解码后="+decode(encode));
final String secretKey="1234567$";//8个字节64位
//Aes
String aesEncrypt=AESencrypt(origin, secretKey);
System.out.println("原数据AES加密后="+aesEncrypt);
System.out.println("原数据AES解密后="+AESdecrypt(aesEncrypt, secretKey));
//des方法一
String data="{'name':'lc','value':'123456'}";
String encrypted=DESencrypt(data,secretKey);
System.out.println(encrypted+","+DESdecrypt(encrypted,secretKey));
//des方法二
byte[] encryptBytes=OtherDES.encrypt(data.getBytes("UTF-8"), secretKey.getBytes());
byte[] decryptBytes=OtherDES.decrypt(encryptBytes, secretKey.getBytes());
System.out.println("加密后的="+new String(encryptBytes,"UTF-8"));
System.out.println("解密后的="+new String(decryptBytes));
String encryp=byte2hex("123456".getBytes());
System.out.println(""+encryp);
}
/**
* DES算法另外一种实现
*/
static class OtherDES{
//加密算法名des
private static final String ALGORITHM = "DES";
//转换格式
private static final String TRANSFORMATION = "DES/ECB/PKCS5Padding";
//利用8个字节的key给src加密
public static byte[] encrypt(byte[] src,byte[]key)
{
try {
//加密
Cipher cipher = Cipher.getInstance(TRANSFORMATION);
SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(ALGORITHM);
KeySpec keySpec = new DESKeySpec(key);
SecretKey secretKey = secretKeyFactory.generateSecret(keySpec);
cipher.init(Cipher.ENCRYPT_MODE, secretKey,new SecureRandom());
byte[] enMsgBytes = cipher.doFinal(src);
return enMsgBytes;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
//利用8个字节的key给src解密
public static byte[] decrypt(byte[] encryptBytes,byte[]key){
try {
//解密
Cipher deCipher = Cipher.getInstance(TRANSFORMATION);
SecretKeyFactory deDecretKeyFactory = SecretKeyFactory.getInstance(ALGORITHM);
KeySpec deKeySpec = new DESKeySpec(key);
SecretKey deSecretKey = deDecretKeyFactory.generateSecret(deKeySpec);
deCipher.init(Cipher.DECRYPT_MODE, deSecretKey,new SecureRandom());
byte[] deMsgBytes = deCipher.doFinal(encryptBytes);
return deMsgBytes;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
}
RSA
package com.test.encryptionTest;
import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.io.IOUtils;
/**
* @Description: RSA加密算法
* @author lc
* @date 2018年8月5日 上午11:24:01
*/
public class RSAEncryptTest {
public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeySpecException {
Map<String, String> keyMap = RSAUtils.createKeys(1024);
String publicKey = keyMap.get("publicKey");
String privateKey = keyMap.get("privateKey");
System.out.println("公钥: \n\r" + publicKey);
System.out.println("私钥： \n\r" + privateKey);
System.out.println("公钥加密——私钥解密");
String str = "这有个方案，老板已经拍板了，马上要做，就是APP的主题啊，可以根据手机壳颜色来变化。\n"
+ ":\r可以，那你给我个手机壳颜色的接口吧。\n" + ":\r什么接口？\n" + ":\r你不给接口我怎么知道你手机现在什么颜色？\n"
+ ":\r你不能自动识别吗？？\n" + ":\r怎么识别，你告诉我？\n" + ":\r那我怎么知道，这是你们开发者的事情，我现在要说的是这个功能。";
System.out.println("\r明文：\n" + str);
System.out.println("\r明文大小：\n" + str.getBytes().length);
String encodedData = RSAUtils.publicEncrypt(str, RSAUtils.getPublicKey(publicKey));
System.out.println("密文：\r\n" + encodedData);
String decodedData = RSAUtils.privateDecrypt(encodedData, RSAUtils.getPrivateKey(privateKey));
System.out.println("解密后文字: \r\n" + decodedData);
}
}
class RSAUtils {
public static final String CHARSET = "UTF-8";
public static final String RSA_ALGORITHM = "RSA";
public static Map<String, String> createKeys(int keySize) {
// 为RSA算法创建一个KeyPairGenerator对象
KeyPairGenerator kpg;
try {
kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
} catch (NoSuchAlgorithmException e) {
throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
}
// 初始化KeyPairGenerator对象,**长度
kpg.initialize(keySize);
// 生成密匙对
KeyPair keyPair = kpg.generateKeyPair();
// 得到公钥
Key publicKey = keyPair.getPublic();
String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded());
// 得到私钥
Key privateKey = keyPair.getPrivate();
String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded());
Map<String, String> keyPairMap = new HashMap<String, String>();
keyPairMap.put("publicKey", publicKeyStr);
keyPairMap.put("privateKey", privateKeyStr);
return keyPairMap;
}
/**
* 得到公钥
*
* @param publicKey
* **字符串（经过base64编码）
* @throws Exception
*/
public static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
// 通过X509编码的Key指令获得公钥对象
KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
return key;
}
/**
* 得到私钥
*
* @param privateKey
* **字符串（经过base64编码）
* @throws Exception
*/
public static RSAPrivateKey getPrivateKey(String privateKey)
throws NoSuchAlgorithmException, InvalidKeySpecException {
// 通过PKCS#8编码的Key指令获得私钥对象
KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
return key;
}
/**
* 公钥加密
*
* @param data
* @param publicKey
* @return
*/
public static String publicEncrypt(String data, RSAPublicKey publicKey) {
try {
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET),
publicKey.getModulus().bitLength()));
} catch (Exception e) {
throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
}
}
/**
* 私钥解密
*
* @param data
* @param privateKey
* @return
*/
public static String privateDecrypt(String data, RSAPrivateKey privateKey) {
try {
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data),
privateKey.getModulus().bitLength()), CHARSET);
} catch (Exception e) {
throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
}
}
/**
* 私钥加密
*
* @param data
* @param privateKey
* @return
*/
public static String privateEncrypt(String data, RSAPrivateKey privateKey) {
try {
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET),
privateKey.getModulus().bitLength()));
} catch (Exception e) {
throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
}
}
/**
* 公钥解密
*
* @param data
* @param publicKey
* @return
*/
public static String publicDecrypt(String data, RSAPublicKey publicKey) {
try {
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, publicKey);
return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data),
publicKey.getModulus().bitLength()), CHARSET);
} catch (Exception e) {
throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
}
}
private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) {
int maxBlock = 0;
if (opmode == Cipher.DECRYPT_MODE) {
maxBlock = keySize / 8;
} else {
maxBlock = keySize / 8 - 11;
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] buff;
int i = 0;
try {
while (datas.length > offSet) {
if (datas.length - offSet > maxBlock) {
buff = cipher.doFinal(datas, offSet, maxBlock);
} else {
buff = cipher.doFinal(datas, offSet, datas.length - offSet);
}
out.write(buff, 0, buff.length);
i++;
offSet = i * maxBlock;
}
} catch (Exception e) {
throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常", e);
}
byte[] resultDatas = out.toByteArray();
IOUtils.closeQuietly(out);
return resultDatas;
}
}
转载于:https://my.oschina.net/u/3763771/blog/1865157