Java加密与解密的艺术之参考代码
常用的代码就放在这了包括RSA，DES，DESede
证书的操作
package encryption;
import java.io.FileInputStream;
import java.security.KeyStore;
import java.security.PublicKey;
import java.security.PrivateKey;
import java.security.Signature;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import javax.crypto.Cipher;
/**
* Created with IntelliJ IDEA.
* User: ASUS
* Date: 14-5-14
* Time: 上午9:22
* To change this template use File | Settings | File Templates.
*/
public abstract class CertificateCoder {
// 类型证书X509
public static final String CERT_TYPE = "X.509";
/**
* 由KeyStore获得私钥
*
* @param keyStorePath 密钥库路径
* @param alias 别名
* @param password 密码
* @return PrivateKey 私钥
* @throws Exception
*/
private static PrivateKey getPrivateKeyByKeyStore(String keyStorePath, String alias, String password) throws Exception {
// 获得密钥库
KeyStore ks = getKeyStore(keyStorePath, password);
// 获得私钥
return (PrivateKey) ks.getKey(alias, password.toCharArray());
}
/**
* 由Certificate获得公钥
*
* @param certificatePath 证书路径
* @return PublicKey 公钥
* @throws Exception
*/
private static PublicKey getPublicKeyByCertificate(String certificatePath)
throws Exception {
// 获得证书
Certificate certificate = getCertificate(certificatePath);
// 获得公钥
return certificate.getPublicKey();
}
/**
* 获得Certificate
*
* @param certificatePath 证书路径
* @return Certificate 证书
*/
private static Certificate getCertificate(String certificatePath) throws Exception {
// 实例化证书工厂
CertificateFactory certificateFactory = CertificateFactory.getInstance(CERT_TYPE);
// 取得证书文件流
FileInputStream in = new FileInputStream(certificatePath);
// 生成证书
Certificate certificate = certificateFactory.generateCertificate(in);
// 关闭证书文件流
in.close();
return certificate;
}
/**
* 获得Certificate
*
* @param keyStorePath 密钥库路径
* @param alias 别名
* @param password 密码
* @return Certificate 证书
* @throws Exception
*/
private static Certificate getCertificate(String keyStorePath, String alias,
String password) throws Exception {
// 获得密钥库
KeyStore ks = getKeyStore(keyStorePath, password);
// 获得证书
return ks.getCertificate(alias);
}
/**
* 获得KeyStore
*
* @param keyStorePath 密钥库路径
* @param password 密码
* @return KeyStore 密钥库
* @throws Exception
*/
private static KeyStore getKeyStore(String keyStorePath, String password)
throws Exception {
// 实例化密钥库
KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
// 获得密钥库文件流
FileInputStream is = new FileInputStream(keyStorePath);
// 加载密钥库
ks.load(is, password.toCharArray());
// 关闭密钥库文件流
is.close();
return ks;
}
/**
* * 私钥加密
*
* @param data 待加密数据
* @param keyStorePath 密钥库路径
* @param alias 别名
* @param password 密码
* @return byte[] 加密数据
* @throws Exception
*/
public static byte[] encryptByPrivateKey(byte[] data, String keyStorePath,
String alias, String password) throws Exception {
// 取得私钥
PrivateKey privateKey = getPrivateKeyByKeyStore(keyStorePath, alias, password);
// 对数据加密
Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
/**
* 私钥解密
*
* @param data 待解密数据
* @param keyStorePath 密钥库路径
* @param alias 别名
* @param password 密码
* @return byte[] 解密数据
* @throws Exception
*/
public static byte[] decryptByPrivateKey(byte[] data, String keyStorePath,
String alias, String password) throws Exception {
// 取得私钥
PrivateKey privateKey = getPrivateKeyByKeyStore(keyStorePath, alias, password);
// 对数据加密
Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
/**
* 公钥加密
*
* @param data 待加密数据
* @param certificatePath 证书路径
* @return byte[] 加密数据
* @throws Exception
*/
public static byte[] encryptByPublicKey(byte[] data, String certificatePath)
throws Exception {
// 取得公钥
PublicKey publicKey = getPublicKeyByCertificate(certificatePath);
// 对数据加密
Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
return cipher.doFinal(data);
}
/**
* 公钥解密
*
* @param data 待解密数据
* @param certificatePath 证书路径
* @return byte[] 解密数据
* @throws Exception
*/
public static byte[] decryptByPublicKey(byte[] data, String certificatePath)
throws Exception {
// 取得公钥
PublicKey publicKey = getPublicKeyByCertificate(certificatePath);
// 对数据加密
Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, publicKey);
return cipher.doFinal(data);
}
/**
* 签名
*
* @param keyStorePath 密钥库路径
* @param alias 别名
* @param password 密码
* @return byte[] 签名
* @throws Exception
*/
public static byte[] sign(byte[] sign, String keyStorePath, String alias, String password) throws Exception {
// 获得证书
X509Certificate x509Certificate = (X509Certificate) getCertificate(keyStorePath, alias, password);
// 构建签名，由证书指定签名算法
Signature signature = Signature.getInstance(x509Certificate.getSigAlgName());
// 获取私钥
PrivateKey privateKey = getPrivateKeyByKeyStore(keyStorePath, alias, password);
// 初始化签名，由私钥构建
signature.initSign(privateKey);
signature.update(sign);
return signature.sign();
}
/**
* 验证签名
*
* @param data 数据
* @param sign 签名
* @param certificatePath 证书路径
* @return boolean 验证通过为真
* @throws Exception
*/
public static boolean verify(byte[] data, byte[] sign, String
certificatePath) throws Exception {
// 获得证书
X509Certificate x509Certificate = (X509Certificate) getCertificate(certificatePath);
// 由证书构建签名
Signature signature = Signature.getInstance(x509Certificate.getSigAlgName());
// 由证书初始化签名，实际上是使用了证书中的公钥
signature.initVerify(x509Certificate);
signature.update(data);
return signature.verify(sign);
}
}
三重DES加密
package encryption;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import java.security.Key;
/**
* DESede算法的别名Triple DES
* Created with IntelliJ IDEA.
* User: ASUS
* Date: 14-5-14
* Time: 下午10:07
* To change this template use File | Settings | File Templates.
*/
public class DESedeCoder {
/**
* 密钥算法
* Java6支持密钥长度为112位和168位
*/
public static final String KEY_ALGORITHM = "DESede";
/**
* 加密解密算法 、工作模式、填充方式
* Java6支持PKCS5Padding填充方式
*/
public static final String CIPHER_ALGORITHM = "DESede/ECB/PKCS5Padding";
/**
* 转换密钥
*
* @param key
* @return
* @throws Exception
*/
public static Key tokey(byte[] key) throws Exception {
//实例化DES密钥材料
DESedeKeySpec dks = new DESedeKeySpec(key);
//实例化密钥工厂
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(KEY_ALGORITHM);
return keyFactory.generateSecret(dks);
}
/**
* 解密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] decrypt(byte[] data, byte[] key) throws Exception {
//还原密钥
Key k = tokey(key);
/**
* 实例化
* 使用PKCS7Padding填充方式，按如下代码实现
* Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM,"BC");
*/
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, k);
return cipher.doFinal(data);
}
/**
* 加密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] encrypt(byte[] data, byte[] key) throws Exception {
//还原密钥
Key k = tokey(key);
/**
* 实例化
* 使用PKCS7Padding填充方式，按如下代码实现
* Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM,"BC");
*/
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, k);
return cipher.doFinal(data);
}
/**
* 生成密钥
*
* @return
* @throws Exception
*/
public static byte[] initKey() throws Exception {
/**
* 实例化
* 使用128位或192位长度密钥
* 按如下代码实现
* KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM,"BC");
*/
KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);
/**
* 初始化
* Java6支持密钥长度112位和168位
* 若使用128位或192为长度密钥，按如下代码实现
* kg.init(128);
* 或
* kg.init(192);
*/
kg.init(168);
SecretKey secretKey = kg.generateKey();
return secretKey.getEncoded();
}
}
RSA加密
package encryption;
import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
/**
* Created with IntelliJ IDEA.
* User: ASUS
* Date: 14-5-13
* Time: 下午6:58
* To change this template use File | Settings | File Templates.
*/
public class RSACoder {
//非对称加密密钥算法
public static final String KEY_ALGORITMA = "RSA";
//公钥
private static final String PUBLIC_KEY = "RSAPublicKey";
private static final String PRIVITE_KEY = "RSAPrivateKey";
/**
* RSA密钥长度
* 默认1024位
* 密钥长度必须是64的倍数
* 范围在512-65536之间
*/
private static final int KEY_SIZE = 512;
/**
* 私钥解密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception {
//取得私钥
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITMA);
//生成私钥
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
//对数据解密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
/**
* 公钥解密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception {
//取得公钥
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITMA);
//生成公钥
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
//对数据解密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, publicKey);
return cipher.doFinal(data);
}
/**
* 公钥加密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {
//取得公钥
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITMA);
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
//对数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
return cipher.doFinal(data);
}
/**
* 私钥加密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception {
//取得私钥
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITMA);
//生成私钥
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
//对数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
/**
* 取得私钥
*
* @param keyMap
* @return
* @throws Exception
*/
public static byte[] getPrivateKey(Map<String, Object> keyMap) throws Exception {
Key key = (Key) keyMap.get(PRIVITE_KEY);
return key.getEncoded();
}
/**
* 取得公钥
*
* @param keyMap
* @return
* @throws Exception
*/
public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
Key key = (Key) keyMap.get(PUBLIC_KEY);
return key.getEncoded();
}
/**
* 初始化密钥
*
* @return
* @throws Exception
*/
public static Map<String, Object> initKey() throws Exception {
//实例化密钥对生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITMA);
//初始化密钥对生成器
keyPairGenerator.initialize(KEY_SIZE);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
//公钥
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
//私钥
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
//封装密钥
Map<String, Object> keyMap = new HashMap<String, Object>();
keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVITE_KEY, privateKey);
return keyMap;
}
}
DES加密
package encryption;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import java.security.Key;
/**
* Created with IntelliJ IDEA.
* User: ASUS
* Date: 14-5-13
* Time: 下午8:19
* To change this template use File | Settings | File Templates.
*/
public class DESCoder {
/**
* 密钥算法
* java6只支持56位密钥
*/
public static final String KEY_ALGORITHM = "DES";
/**
* 加密解密算法、工作模式、填充方式
*/
public static final String CIPHER_ALGORITHM = "DES/ECB/PKCS5Padding";
/**
* 转换密钥
*
* @param key 二进制密钥
* @return 密钥
* @throws Exception
*/
private static Key toKey(byte[] key) throws Exception {
//实例化密钥材料
DESKeySpec dks = new DESKeySpec(key);
//实例化密钥工厂
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(KEY_ALGORITHM);
//生成秘密密钥
SecretKey secretKey = keyFactory.generateSecret(dks);
return secretKey;
}
/**
* 解密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] decrypt(byte[] data, byte[] key) throws Exception {
//还原密钥
Key k = toKey(key);
//实力化
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
//初始化，设置为解密模式
cipher.init(Cipher.DECRYPT_MODE, k);
//执行操作
return cipher.doFinal(data);
}
/**
* 加密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] encrypt(byte[] data, byte[] key) throws Exception {
Key k = toKey(key);
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, k);
return cipher.doFinal(data);
}
public static byte[] initKey() throws Exception {
/**
* 实例化密钥生成器
* 如要使用64位密钥注意替换
* KeyGenerator kg = KeyGenerator.getInstance(CIPHER_ALGORITHM,"BC");
*/
KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_ALGORITHM);
keyGenerator.init(56);
SecretKey secretKey = keyGenerator.generateKey();
return secretKey.getEncoded();
}
}
=======END=======