public static final String KEY_ALGORITHM = "RSA"
public static final String SIGNATURE_ALGORITHM = "MD5withRSA"
private static final String PUBLIC_KEY = "RSAPublicKey"
private static final String PRIVATE_KEY = "RSAPrivateKey"
/**
* 用私钥对信息生成数字签名
*
* @param data
* 加密数据
* @param privateKey
* 私钥
*
* @return
* @throws Exception
*/
public static String sign(byte[] data, String privateKey) throws Exception {
// 解密由base64编码的私钥
byte[] keyBytes = decryptBASE64(privateKey)
// 构造PKCS8EncodedKeySpec对象
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes)
// KEY_ALGORITHM 指定的加密算法
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM)
// 取私钥匙对象
PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec)
// 用私钥对信息生成数字签名
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM)
signature.initSign(priKey)
signature.update(data)
return encryptBASE64(signature.sign())
}
/**
* 校验数字签名
*
* @param data
* 加密数据
* @param publicKey
* 公钥
* @param sign
* 数字签名
*
* @return 校验成功返回true 失败返回false
* @throws Exception
*
*/
public static boolean verify(byte[] data, String publicKey, String sign)
throws Exception {
// 解密由base64编码的公钥
byte[] keyBytes = decryptBASE64(publicKey)
// 构造X509EncodedKeySpec对象
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes)
// KEY_ALGORITHM 指定的加密算法
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM)
// 取公钥匙对象
PublicKey pubKey = keyFactory.generatePublic(keySpec)
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM)
signature.initVerify(pubKey)
signature.update(data)
// 验证签名是否正常
return signature.verify(decryptBASE64(sign))
}
/**
* 解密<br>
* 用私钥解密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] decryptByPrivateKey(byte[] data, String key)
throws Exception {
// 对密钥解密
byte[] keyBytes = decryptBASE64(key)
// 取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes)
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM)
Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec)
// 对数据解密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm())
cipher.init(Cipher.DECRYPT_MODE, privateKey)
return cipher.doFinal(data)
}
/**
* 解密<br>
* 用公钥解密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] decryptByPublicKey(byte[] data, String key)
throws Exception {
// 对密钥解密
byte[] keyBytes = decryptBASE64(key)
// 取得公钥
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes)
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM)
Key publicKey = keyFactory.generatePublic(x509KeySpec)
// 对数据解密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm())
cipher.init(Cipher.DECRYPT_MODE, publicKey)
return cipher.doFinal(data)
}
/**
* 加密<br>
* 用公钥加密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] encryptByPublicKey(byte[] data, String key)
throws Exception {
// 对公钥解密
byte[] keyBytes = decryptBASE64(key)
// 取得公钥
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes)
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM)
Key publicKey = keyFactory.generatePublic(x509KeySpec)
// 对数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm())
cipher.init(Cipher.ENCRYPT_MODE, publicKey)
return cipher.doFinal(data)
}
/**
* 加密<br>
* 用私钥加密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] encryptByPrivateKey(byte[] data, String key)
throws Exception {
// 对密钥解密
byte[] keyBytes = decryptBASE64(key)
// 取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes)
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM)
Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec)
// 对数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm())
cipher.init(Cipher.ENCRYPT_MODE, privateKey)
return cipher.doFinal(data)
}
/**
* 取得私钥
*
* @param keyMap
* @return
* @throws Exception
*/
public static String getPrivateKey(Map<String, Object> keyMap)
throws Exception {
Key key = (Key) keyMap.get(PRIVATE_KEY)
return encryptBASE64(key.getEncoded())
}
/**
* 取得公钥
*
* @param keyMap
* @return
* @throws Exception
*/
public static String getPublicKey(Map<String, Object> keyMap)
throws Exception {
Key key = (Key) keyMap.get(PUBLIC_KEY)
return encryptBASE64(key.getEncoded())
}
/**
* 初始化密钥
*
* @return
* @throws Exception
*/
public static Map<String, Object> initKey() throws Exception {
KeyPairGenerator keyPairGen = KeyPairGenerator
.getInstance(KEY_ALGORITHM)
keyPairGen.initialize(1024)
KeyPair keyPair = keyPairGen.generateKeyPair()
// 公钥
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic()
// 私钥
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate()
Map<String, Object> keyMap = new HashMap<String, Object>(2)
keyMap.put(PUBLIC_KEY, publicKey)
keyMap.put(PRIVATE_KEY, privateKey)
return keyMap
}
}
JAVA写RSA加密，私钥都是一样的，公钥每次加密的结果不一样跟对数据的padding（填充）有关。
1、Padding (填充)属性定义元素边框与元素内容之间的空间。
2、padding 简写属性在一个声明中设置所有内边距属性。设置所有当前或者指定元素内边距属性。该属性可以有1到4个值。
3、当元素的 Padding(填充)(内边距)被清除时，所"释放"的区域将会受到元素背景颜色的填充。
4、单独使用填充属性是在一个声明中设置元素的所内边距属性。缩写填充属性也可以使用，一旦改变一个数值，则padding对应的距离都会改变。
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA")keyGen.initialize(1024)
KeyPair key = keyGen.generateKeyPair()
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding")
//把第二个参数改为 key.getPrivate()
cipher.init(Cipher.ENCRYPT_MODE, key.getPublic())
byte[] cipherText = cipher.doFinal("Message".getBytes("UTF8"))
System.out.println(new String(cipherText, "UTF8"))
//把第二个参数改为key.getPublic()
cipher.init(Cipher.DECRYPT_MODE, key.getPrivate())
byte[] newPlainText = cipher.doFinal(cipherText)
System.out.println(new String(newPlainText, "UTF8"))
正常的用公钥加密私钥解密就是这个过程，如果按私钥加密公钥解密，只要按备注改2个参数就可以。
但是我要提醒楼主，你要公钥解密，公钥是公开的，相当于任何人都查到公钥可以解密。
你是想做签名是吧。
