RSAUtil类

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.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

import javax.crypto.Cipher;

public class RsaUtils {

/** /
/*

• 加密算法RSA
  */
  public static final String KEY_ALGORITHM = "RSA";

/** /
/*

• 签名算法
  */
  public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

/** /
/*

• RSA最大加密明文大小
  */
  private static final int MAX_ENCRYPT_BLOCK = 117;

/** /
/*

• RSA最大解密密文大小
  */
  private static final int MAX_DECRYPT_BLOCK = 128;

org.apache.commons.codec.binary.Base64 bb;

/**

• 生成公私钥对

• @return
  */
  public static String[] genKeyPairs() {

  try {
  KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
  keyPairGen.initialize(1024);
  KeyPair keyPair = keyPairGen.generateKeyPair();
  RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
  RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
  return new String[] { Base64.getEncoder().encodeToString(publicKey.getEncoded()),
  Base64.getEncoder().encodeToString(privateKey.getEncoded()) };
  } catch (NoSuchAlgorithmException e) {
  e.printStackTrace();
  }
  return null;
  }

/** /
/*

• 用私钥对信息生成数字签名
• @param data 已加密数据
• @param privateKey 私钥(BASE64编码)
• @return
• @throws Exception
  */
  public static String sign(byte[] data, String privateKey) throws Exception {
  byte[] keyBytes = Base64.getDecoder().decode(privateKey);
  PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  signature.initSign(privateK);
  signature.update(data);
  return Base64.getEncoder().encodeToString(signature.sign());
  }

/** /
/*

• 校验数字签名
• @param data 已加密数据
• @param publicKey 公钥(BASE64编码)
• @param sign 数字签名
• @return
• @throws Exception

*/
public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
byte[] keyBytes = Base64.getDecoder().decode(publicKey);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PublicKey publicK = keyFactory.generatePublic(keySpec);
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initVerify(publicK);
signature.update(data);
return signature.verify(Base64.getDecoder().decode(sign));
}

/** /
/*

• 私钥解密
• @param encryptedData 已加密数据
• @param privateKey 私钥(BASE64编码)
• @return
• @throws Exception
  */
  public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
  byte[] keyBytes = Base64.getDecoder().decode(privateKey);
  PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  cipher.init(Cipher.DECRYPT_MODE, privateK);
  int inputLen = encryptedData.length;
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  int offSet = 0;
  byte[] cache;
  int i = 0;
  // 对数据分段解密
  while (inputLen - offSet > 0) {
  if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  } else {
  cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  }
  out.write(cache, 0, cache.length);
  i++;
  offSet = i * MAX_DECRYPT_BLOCK;
  }
  byte[] decryptedData = out.toByteArray();
  out.close();
  return decryptedData;
  }

/** /
/*

• 公钥解密
• @param encryptedData 已加密数据
• @param publicKey 公钥(BASE64编码)
• @return
• @throws Exception
  */
  public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
  byte[] keyBytes = Base64.getDecoder().decode(publicKey);
  X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  Key publicK = keyFactory.generatePublic(x509KeySpec);
  Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  cipher.init(Cipher.DECRYPT_MODE, publicK);
  int inputLen = encryptedData.length;
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  int offSet = 0;
  byte[] cache;
  int i = 0;
  // 对数据分段解密
  while (inputLen - offSet > 0) {
  if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  } else {
  cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  }
  out.write(cache, 0, cache.length);
  i++;
  offSet = i * MAX_DECRYPT_BLOCK;
  }
  byte[] decryptedData = out.toByteArray();
  out.close();
  return decryptedData;
  }

/** /
/*

• 公钥加密
• @param data 源数据
• @param publicKey 公钥(BASE64编码)
• @return
• @throws Exception
  */
  public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
  byte[] keyBytes = Base64.getDecoder().decode(publicKey);
  X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  Key publicK = keyFactory.generatePublic(x509KeySpec);
  // 对数据加密
  Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  cipher.init(Cipher.ENCRYPT_MODE, publicK);
  int inputLen = data.length;
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  int offSet = 0;
  byte[] cache;
  int i = 0;
  // 对数据分段加密
  while (inputLen - offSet > 0) {
  if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  } else {
  cache = cipher.doFinal(data, offSet, inputLen - offSet);
  }
  out.write(cache, 0, cache.length);
  i++;
  offSet = i * MAX_ENCRYPT_BLOCK;
  }
  byte[] encryptedData = out.toByteArray();
  out.close();
  return encryptedData;
  }

/** /
/*

• 私钥加密
• @param data 源数据
• @param privateKey 私钥(BASE64编码)
• @return
• @throws Exception
  */
  public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
  byte[] keyBytes = Base64.getDecoder().decode(privateKey);
  PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  cipher.init(Cipher.ENCRYPT_MODE, privateK);
  int inputLen = data.length;
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  int offSet = 0;
  byte[] cache;
  int i = 0;
  // 对数据分段加密
  while (inputLen - offSet > 0) {
  if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  } else {
  cache = cipher.doFinal(data, offSet, inputLen - offSet);
  }
  out.write(cache, 0, cache.length);
  i++;
  offSet = i * MAX_ENCRYPT_BLOCK;
  }
  byte[] encryptedData = out.toByteArray();
  out.close();
  return encryptedData;
  }

/**

• 对文本进行加密
• @param text
• @param publicKey
• @return
  */
  public static String encryptByPublicKey(String text, String publicKey) {
  try {
  byte[] bs = encryptByPublicKey(text.getBytes("UTF-8"), publicKey);
  return Base64.getEncoder().encodeToString(bs);
  } catch (Exception e) {
  e.printStackTrace();
  }
  return null;
  }

/**

• 对文本进行加密
• @param text
• @param publicKey
• @return
  */
  public static String encryptByPrivateKey(String text, String privateKey) {
  try {
  byte[] bs = encryptByPrivateKey(text.getBytes("UTF-8"), privateKey);
  return Base64.getEncoder().encodeToString(bs);
  } catch (Exception e) {
  e.printStackTrace();
  }
  return null;
  }

/**

• 对文本进行解密
• @param text
• @param privateKey
• @return
  */
  public static String decryptByPrivateKey(String text, String privateKey) {
  byte bs[] = Base64.getDecoder().decode(text);
  try {
  byte[] dbs = decryptByPrivateKey(bs, privateKey);
  return new String(dbs, "Utf-8");
  } catch (Exception e) {
  e.printStackTrace();
  }
  return null;
  }

/**

• 对文本进行解密
• @param text
• @param privateKey
• @return
  */
  public static String decryptByPublicKey(String text, String publicKey) {
  byte bs[] = Base64.getDecoder().decode(text);
  try {
  byte[] dbs = decryptByPublicKey(bs, publicKey);
  return new String(dbs, "Utf-8");
  } catch (Exception e) {
  e.printStackTrace();
  }
  return null;
  }

}