java加密解密工具类_项目中用到的加密解密工具类

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.UnsupportedEncodingException;

import java.security.Key;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.Signature;

import java.security.spec.InvalidKeySpecException;

import java.security.spec.KeySpec;

import javax.crypto.Cipher;

import javax.crypto.CipherInputStream;

import javax.crypto.CipherOutputStream;

import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey;

import javax.crypto.SecretKeyFactory;

import javax.crypto.spec.DESedeKeySpec;

import sun.misc.BASE64Decoder;

import sun.misc.BASE64Encoder;

/**

* 安全工具(加密解密)

*

* @author wangzhengzhen

* @version 1.0.0

*/

public class SecurityUtils {

/**

* 默认数字签名算法(指纹认证)，可用MD5、SHA

*/

public static final String ALGORITHM_SHA = "SHA";

/**

* 操作模式，加密或解密

*/

public static enum CIPHER_MODE {

ENCRYPT_MODE, DECRYPT_MODE

}

/**

* 数字签名

* @param algorithm 算法，如：md5、sha

* @param encoding

* @param src

* @return

*/

public static byte[] digest(String algorithm, String encoding, String src) {

byte[] b = null;

try {

MessageDigest md = MessageDigest.getInstance(algorithm);

b = md.digest(src.getBytes(encoding));

} catch (Exception e) {

e.printStackTrace();

}

return b;

}

/**

* BASE64加密

* @param src

* @param encoding

* @return

*/

private static BASE64Encoder b64encoder = new BASE64Encoder();

public static String base64Encoder(String src, String encoding) {

String ciphertext = null;

try {

ciphertext = b64encoder.encode(src.getBytes(encoding));

} catch (UnsupportedEncodingException e) {

e.printStackTrace();

}

return ciphertext;

}

/**

* BASE64加密

* @param src

* @return

*/

public static String base64Encoder(byte[] src) {

return b64encoder.encode(src);

}

/**

* BASE64解密

* @param dest

* @param encoding

* @return

*/

private static BASE64Decoder b64decoder = new BASE64Decoder();

public static String base64Decoder(String dest, String encoding) {

byte[] b = null;

try {

b = b64decoder.decodeBuffer(dest);

} catch (IOException e) {

e.printStackTrace();

}

String plaintext = null;

try {

plaintext = new String(b, encoding);

} catch (UnsupportedEncodingException e) {

e.printStackTrace();

}

return plaintext;

}

/**

* BASE64解密

* @param dest

* @return

*/

public static byte[] base64Decoder(String dest) {

byte[] b = null;

try {

b = b64decoder.decodeBuffer(dest);

} catch (IOException e) {

e.printStackTrace();

}

return b;

}

/**

* 构造DESede对称密钥

*

* @param keyStr

* @return

*/

public static SecretKey getDESedeKey(byte[] key) {

SecretKey desKey = null;

try {

DESedeKeySpec desKeySpec = new DESedeKeySpec(key);

desKey = SecretKeyFactory.getInstance("DESede").generateSecret(desKeySpec);

} catch (Exception e) {

e.printStackTrace();

}

return desKey;

}

/**

* 生成非对称密钥，使用时注意公钥和私钥

*

* @param algorithm 非对称密钥算法，如：RSA

* @return

*/

public static KeyPair createKeyPair(String algorithm) {

KeyPair key = null;

try {

key = KeyPairGenerator.getInstance(algorithm).generateKeyPair();

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

return key;

}

/**

* 生成对称密钥

* @param algorithm 对称密钥算法，如：DES，DESede

* @return

*/

public static SecretKey createSecretKey(String algorithm) {

SecretKey key = null;

try {

key = KeyGenerator.getInstance(algorithm).generateKey();

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

return key;

}

/**

* 使用keySpec创建对称密钥

* @param algorithm

* @param keySpec

* @return

*/

public static SecretKey createSecretKey(String algorithm, KeySpec keySpec) {

SecretKey key = null;

try {

SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(algorithm);

key = keyFactory.generateSecret(keySpec);

} catch (Exception e) {

e.printStackTrace();

}

return key;

}

/**

* 读取X509公钥

* @param algorithm

* @return

*/

public static PublicKey getPublicKey(String algorithm, KeySpec keySpec) {

PublicKey pubKey = null;

try {

pubKey = KeyFactory.getInstance(algorithm).generatePublic(keySpec);

} catch (InvalidKeySpecException e) {

e.printStackTrace();

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

return pubKey;

}

/**

* 获得私钥

* @param algorithm

* @param keySpec

* @return

*/

public static PrivateKey getPrivateKey(String algorithm, KeySpec keySpec) {

PrivateKey priKey = null;

try {

priKey = KeyFactory.getInstance(algorithm).generatePrivate(keySpec);

} catch (InvalidKeySpecException e) {

e.printStackTrace();

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

return priKey;

}

/**

* 加密或解密字符串

*

* @param plaintext

* @return

*/

public static byte[] doFinal(Key key, byte[] plaintext, CIPHER_MODE opmod) {

byte[] ciphertext = null;

try {

Cipher cipher = Cipher.getInstance(key.getAlgorithm());

// 操作模式(加密或解密)

if (opmod == CIPHER_MODE.ENCRYPT_MODE) {

cipher.init(Cipher.ENCRYPT_MODE, key);

} else if (opmod == CIPHER_MODE.DECRYPT_MODE) {

cipher.init(Cipher.DECRYPT_MODE, key);

}

ciphertext = cipher.doFinal(plaintext);

} catch (Exception e) {

e.printStackTrace();

}

return ciphertext;

}

/**

* 得到加密或解密输入流

*

* @param key

* @param inputFilename

* @param outputFilename

* @throws IOException

*/

public static CipherInputStream doFinal(Key key, InputStream is, CIPHER_MODE opmod) {

CipherInputStream cis = null;

try {

Cipher cipher = Cipher.getInstance(key.getAlgorithm());

// 操作模式(加密或解密)

if (opmod == CIPHER_MODE.ENCRYPT_MODE) {

cipher.init(Cipher.ENCRYPT_MODE, key);

} else if (opmod == CIPHER_MODE.DECRYPT_MODE) {

cipher.init(Cipher.DECRYPT_MODE, key);

}

cis = new CipherInputStream(is, cipher);

} catch (Exception e) {

e.printStackTrace();

}

return cis;

}

/**

* 得到加密或解密输出流

*

* @param key

* @param inputFilename

* @param outputFilename

*/

public static CipherOutputStream doFinal(Key key, OutputStream os,

CIPHER_MODE opmod) {

CipherOutputStream cos = null;

try {

Cipher cipher = Cipher.getInstance(key.getAlgorithm());

// 操作模式(加密或解密)

if (opmod == CIPHER_MODE.ENCRYPT_MODE) {

cipher.init(Cipher.ENCRYPT_MODE, key);

} else if (opmod == CIPHER_MODE.DECRYPT_MODE) {

cipher.init(Cipher.DECRYPT_MODE, key);

}

cos = new CipherOutputStream(os, cipher);

} catch (Exception e) {

e.printStackTrace();

}

return cos;

}

/**

* 验证数字签名

*

* @param publicKey

* @param algorithm

*            签名算法

* @param sign

*            私钥签名的signature

* @param data

*            签名的数据

* @return

*/

public static boolean signVerify(PublicKey publicKey, String algorithm, byte[] sign, byte[] data) {

boolean flag = false;

try {

Signature signagure = Signature.getInstance(algorithm);

signagure.initVerify(publicKey);

signagure.update(data);

flag = signagure.verify(sign);

} catch (Exception e) {

e.printStackTrace();

}

return flag;

}

/**

* 用私钥对信息进行数字签名

*

* @param key

* @param algorithm

*            签名算法

* @param data

*            签名的数据

* @return

*/

public static byte[] sign(PrivateKey privateKey, String algorithm,

byte[] data) {

byte[] sign = null;

try {

Signature signature = Signature.getInstance(algorithm);

signature.initSign(privateKey);

signature.update(data);

sign = signature.sign();

} catch (Exception e) {

e.printStackTrace();

}

return sign;

}

/**

* SHA数字签名

* @author panguixiang

* @param src

* @return

* @throws Exception

*/

public static byte[] shaDigest(String src) {

byte[] b = null;

try {

MessageDigest md = MessageDigest.getInstance(ALGORITHM_SHA);

b = md.digest(src.getBytes());

} catch (Exception e) {

e.printStackTrace();

}

return b;

}

/**

* 字节数组转为最大写16进制字符串

* @author panguixiang

* @param b

* @return

*/

public static String byte2HexStr(byte[] b) {

StringBuilder sb = new StringBuilder();

for (int i = 0; i < b.length; i++) {

String s = Integer.toHexString(b[i] & 0xFF);

if (s.length() == 1) {

sb.append("0");

}

sb.append(s.toUpperCase());

}

return sb.toString();

}

}