java中的加解密操作

      java中，加解密方式有五种，Base64、消息摘要、对称加密、非对称加密、数字签名。

   消息摘要加密有两种算法：MD和SHA

   对称加密有四种算法：DES、3DES、AES、PBE

   非对称加密有两种算法：DH、RSA

   数字签名有三种算法:RSA、DSA、ECDSA

    

   

public class EncodeUtil {
/**
* Base64
* @param code
* @return
*/
public static String base64Encode(String code){
byte[] encode=null;
//bc
encode =org.bouncycastle.util.encoders.Base64.encode(code.getBytes());
//cc
encode=Base64.encodeBase64(code.getBytes());
return new String(encode);

}

/***
* MD5
* @param code
* @return
*/
public static String md5Encode(String code){
byte[] md5Encode = null;
//jdk
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md5Encode=md.digest(code.getBytes());
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
//bc
MD5Digest digest = new MD5Digest();
digest.update(code.getBytes(),0,code.getBytes().length);
md5Encode=new byte[digest.getDigestSize()];
digest.doFinal(md5Encode,0);
//cc
md5Encode =DigestUtils.md5(code.getBytes());
return Hex.encodeHexString(md5Encode);
}

/**
* SHA
* @param code
* @return
*/
public static String shaEncode(String code){
byte[] shaEncode=null;
//jdk
try {
MessageDigest messageDigest=MessageDigest.getInstance("SHA");
shaEncode=messageDigest.digest(code.getBytes());
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
//bc
Digest digest = new SHA1Digest();
digest.update(code.getBytes(),0,code.getBytes().length);
shaEncode = new byte[digest.getDigestSize()];
digest.doFinal(shaEncode,0);
//cc
shaEncode =DigestUtils.sha1(code);
return Hex.encodeHexString(shaEncode);
}
/***
* 对称加密
* 第一步：生成Key
* 第二步：转换Key
* 第三步：加解密的操作
*/
public static String desEncode(String code){
byte[] desEncode=null;
try {
//jdk
//生成Key
KeyGenerator keygenerator=KeyGenerator.getInstance("DES");
keygenerator.init(56);
SecretKey secretKey=keygenerator.generateKey();
byte[] byteKey=secretKey.getEncoded();

//Key的转换
DESKeySpec desKetSpec= new DESKeySpec(byteKey);
SecretKeyFactory secretKeyFactory=SecretKeyFactory.getInstance("DES");
Key convertKey=secretKeyFactory.generateSecret(desKetSpec);

//加密
Cipher cipher=Cipher.getInstance("DES/ECB/PKCSPadding");
cipher.init(Cipher.ENCRYPT_MODE,convertKey);
desEncode=cipher.doFinal(code.getBytes());
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
}
return Hex.encodeHexString(desEncode);
}
public static String threedesEncode(String code){
byte[] desEncode=null;
try {
//jdk
//生成Key
KeyGenerator keygenerator=KeyGenerator.getInstance("DESede");
keygenerator.init(168);
SecretKey secretKey=keygenerator.generateKey();
byte[] byteKey=secretKey.getEncoded();

//Key的转换
DESedeKeySpec desKetSpec= new DESedeKeySpec(byteKey);
SecretKeyFactory secretKeyFactory=SecretKeyFactory.getInstance("DESede");
Key convertKey=secretKeyFactory.generateSecret(desKetSpec);

//加密
Cipher cipher=Cipher.getInstance("DESede/ECB/PKCSPadding");
cipher.init(Cipher.ENCRYPT_MODE,convertKey);
desEncode=cipher.doFinal(code.getBytes());
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
}
return Hex.encodeHexString(desEncode);
}
public static String aesEncode(String code){
byte[] aesEncode=null;
//jdk
try {
//生成Key
KeyGenerator keyGenerator=KeyGenerator.getInstance("AES");
keyGenerator.init(new SecureRandom());
SecretKey secretKey=keyGenerator.generateKey();
byte[] keyByte=secretKey.getEncoded();

//key的转换
Key key = new SecretKeySpec(keyByte,"AES");

//加密
Cipher cipher=Cipher.getInstance("AES/ECB/PKS5Padding");
cipher.init(Cipher.ENCRYPT_MODE,key);
aesEncode=cipher.doFinal(code.getBytes());
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
}
return Hex.encodeHexString(aesEncode);
}
public static String pbeEncoder(String code){
byte[] pbeEncode=null;
try {
//jdk
//初始化盐
SecureRandom secureRam = new SecureRandom();
byte[] salt = secureRam.generateSeed(8);

//口令与密钥
String password="123456";
PBEKeySpec pbeKeySpec= new PBEKeySpec(password.toCharArray());
SecretKeyFactory factory =SecretKeyFactory.getInstance("PBEWITHMD5andDES");

//生成Key
Key key=factory.generateSecret(pbeKeySpec);

//加密
PBEParameterSpec pbeParameterSpec= new PBEParameterSpec(salt,100);
Cipher cipher = Cipher.getInstance("PBEWITHMD5andAES");
cipher.init(Cipher.ENCRYPT_MODE,key,pbeParameterSpec);
pbeEncode =cipher.doFinal(code.getBytes());
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (InvalidAlgorithmParameterException e) {
e.printStackTrace();
}
return Hex.encodeHexString(pbeEncode);
}
/***
* 非对称加密。
* 第一步：发送方生成sendPublicKeyEnc
* 第二步：接收方根据发送方的sendPublicKeyEnc构建自己的本地密钥以及receiverPublicKeyEnc
* 第三步：发送方根据接收方的receiverPublicKeyEnc构建自己的本地密钥
*/
public static String dhEncoder(String code){
byte[] dhEncoder=null;
try {
//初始化发送方sendPublicKeyEnc。
KeyPairGenerator sendKeyPairGenerator=KeyPairGenerator.getInstance("DH");
sendKeyPairGenerator.initialize(512);
KeyPair sendKeyPair = sendKeyPairGenerator.genKeyPair();
byte[] sendPublicKeyEnc= sendKeyPair.getPublic().getEncoded();

//解析发送方的PublicKeyEnc
KeyFactory receiveKeyFactory= KeyFactory.getInstance("DH");
X509EncodedKeySpec x509EncoderKeySpec=new X509EncodedKeySpec(sendPublicKeyEnc);
PublicKey receiverPublicKey = receiveKeyFactory.generatePublic(x509EncoderKeySpec);
DHParameterSpec dhParameterSpec=((DHPublicKey)receiverPublicKey).getParams();
KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");
receiverKeyPairGenerator.initialize(dhParameterSpec);
KeyPair receiverKeyPair = receiverKeyPairGenerator.generateKeyPair();

//密钥构建以及生成receiverPublicKeyEnc
KeyAgreement receiverKeyAgreement=KeyAgreement.getInstance("DH");
PrivateKey receiverPrivateKey=receiverKeyPair.getPrivate();
receiverKeyAgreement.init(receiverPrivateKey);
receiverKeyAgreement.doPhase(receiverPublicKey, true);
SecretKey receiverDesKey = receiverKeyAgreement.generateSecret("DES");
byte[] receiverPublicKeyEnc = receiverKeyPair.getPublic().getEncoded();

//发送方收到接收方的receiverPublicKeyEnc，生成自己的本地密钥
KeyFactory sendKeyFactory = KeyFactory.getInstance("DH");
x509EncoderKeySpec=new X509EncodedKeySpec(receiverPublicKeyEnc);
PublicKey sendPublicKey = sendKeyFactory.generatePublic(x509EncoderKeySpec);
KeyAgreement sendKeyAgreement = KeyAgreement.getInstance("DH");
sendKeyAgreement.init(sendKeyPair.getPrivate());
sendKeyAgreement.doPhase(sendPublicKey, true);
//发送方本地密钥
SecretKey sendDesKey=sendKeyAgreement.generateSecret("DES");

//加密
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE,sendDesKey);
dhEncoder=cipher.doFinal(code.getBytes());
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
} catch (InvalidAlgorithmParameterException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
}
return Hex.encodeHexString(dhEncoder);
}
public static String rsaEncoder(String code){
byte[] rsaEncoder=null;
//jdk
try {
//初始化密钥
KeyPairGenerator keyPairGrnerator=KeyPairGenerator.getInstance("RSA");
keyPairGrnerator.initialize(512);
KeyPair keyPair = keyPairGrnerator.generateKeyPair();
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

//私钥加密，公钥解密----加密
PKCS8EncodedKeySpec pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
KeyFactory keyFactory=KeyFactory.getInstance("RSA");
PrivateKey privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
rsaEncoder = cipher.doFinal(code.getBytes());

//私钥加密，公钥解密----解密
X509EncodedKeySpec x509EncodedKeySpec= new X509EncodedKeySpec(rsaPublicKey.getEncoded());
keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
cipher=Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, publicKey);
rsaEncoder =cipher.doFinal(rsaEncoder);

//公钥加密，私钥解密----加密
x509EncodedKeySpec= new X509EncodedKeySpec(rsaPublicKey.getEncoded());
keyFactory = KeyFactory.getInstance("RSA");
publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
cipher=Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE,publicKey);
rsaEncoder=cipher.doFinal(code.getBytes());
//公钥加密，私钥解密----解密
pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
keyFactory=KeyFactory.getInstance("RSA");
privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);
cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE,privateKey);
rsaEncoder = cipher.doFinal(rsaEncoder);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
}
return Hex.encodeHexString(rsaEncoder);
}
/***
* 数字签名算法 RSA DSA ECDSA
*/
public static String signRsaEncoder(String code){
byte[] signRsaEncode=null;
try {
//jdk
//初始化密钥
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(512);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey rsaPrivateKey= (java.security.interfaces.RSAPrivateKey) keyPair.getPrivate();

//执行私钥签名
PKCS8EncodedKeySpec pkcS8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
KeyFactory keyFactory=KeyFactory.getInstance("RSA");
PrivateKey privateKey=keyFactory.generatePrivate(pkcS8EncodedKeySpec);
Signature signature= Signature.getInstance("MD5withRSA");
signature.initSign(privateKey);
signature.update(code.getBytes());
signRsaEncode=signature.sign();

//公钥验证签名
X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());
keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
signature = Signature.getInstance("MD5withRSA");
signature.initVerify(publicKey);
signature.update(code.getBytes());
boolean isTrue =signature.verify(signRsaEncode);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (SignatureException e) {
e.printStackTrace();
}
return Hex.encodeHexString(signRsaEncode);
}
public static String signDsaEncode(String code){
byte[] signDsaEncode=null;
try {
//初始化密钥
KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("DSA");
keyPairGenerator.initialize(512);
KeyPair keyPair=keyPairGenerator.generateKeyPair();
DSAPublicKey dsaPublicKey= (DSAPublicKey) keyPair.getPublic();
DSAPrivateKey dsaPrivateKey= (DSAPrivateKey) keyPair.getPrivate();
//执行签名
PKCS8EncodedKeySpec pkcS8EncodedKeySpec=new PKCS8EncodedKeySpec(dsaPrivateKey.getEncoded());
KeyFactory keyFactory=KeyFactory.getInstance("DSA");
PrivateKey privateKey=keyFactory.generatePrivate(pkcS8EncodedKeySpec);
Signature signnatrue=Signature.getInstance("SHA1withDSA");
signnatrue.initSign(privateKey);
signnatrue.update(code.getBytes());
signDsaEncode=signnatrue.sign();
//验证签名
X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(dsaPublicKey.getEncoded());
keyFactory = KeyFactory.getInstance("DSA");
PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
signnatrue = Signature.getInstance("SHA1withDSA");
signnatrue.initVerify(publicKey);
signnatrue.update(code.getBytes());
boolean isTrue =signnatrue.verify(signDsaEncode);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (SignatureException e) {
e.printStackTrace();
}
return Hex.encodeHexString(signDsaEncode);
}
public static String signEcDsaEncode(String code){
byte[] signEcDsaEncode=null;
try {
//初始化密钥
KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("DSA");
keyPairGenerator.initialize(512);
KeyPair keyPair=keyPairGenerator.generateKeyPair();
ECPublicKey ecPublicKey= (ECPublicKey) keyPair.getPublic();
ECPrivateKey ecPrivateKey= (ECPrivateKey) keyPair.getPrivate();
//执行签名
PKCS8EncodedKeySpec pkcS8EncodedKeySpec=new PKCS8EncodedKeySpec(ecPrivateKey.getEncoded());
KeyFactory keyFactory=KeyFactory.getInstance("EC");
PrivateKey privateKey=keyFactory.generatePrivate(pkcS8EncodedKeySpec);
Signature signnatrue=Signature.getInstance("SHA1withECDSA");
signnatrue.initSign(privateKey);
signnatrue.update(code.getBytes());
signEcDsaEncode=signnatrue.sign();
//验证签名
X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(ecPublicKey.getEncoded());
keyFactory = KeyFactory.getInstance("EC");
PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
signnatrue = Signature.getInstance("SHA1withECDSA");
signnatrue.initVerify(publicKey);
signnatrue.update(code.getBytes());
boolean isTrue =signnatrue.verify(signEcDsaEncode);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (SignatureException e) {
e.printStackTrace();
}
return Hex.encodeHexString(signEcDsaEncode);
}
}