私钥加密公钥Java
1、默认 Java 中仅支持 128 位密钥，当使用 256 位密钥的时候，会报告密钥长度错误 Invalid AES key length 你需要下载一个支持更长密钥的包。这个包叫做 Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 6 看一下你的 JRE 环境，将 JRE 环境中 lib\lib\security 中的同名包替换掉。
2、Base64 问题 // 编码 String asB64 = new Base64().encodeToString("some string".getBytes("utf-8")); System.out.println(asB64); // 输出为: c29tZSBzdHJpbmc= 解码 // 解码 byte[] asBytes = new Base64().getDecoder().decode("c29tZSBzdHJpbmc="); System.out.println(new String(asBytes, "utf-8")); // 输出为: some string ...
B. JAVA公钥加密，私钥解密，该怎么解决
RSA算法，选取两个互质数
如p:6和q:5（最大公约数为1）
求出乘积n=30,欧拉函数值((p - 1) * (q - 1)) eul =20
选出一个和eul互质且小于eul大于1的数，如 e = 19
通过扩展欧几里得算法求逆元 此处求出一个逆元 d = 39
逆元就是满足公式 (e*d) % eul = 1的值(该公式可能有多个解，求出一个就行)
(n,e)组成公钥，(n,d)组成私钥
假定明文是一个数字m
计算 m的e次方模n 得到的余数就是密文 em
计算 em的d次方模n 得到的余数就是明文 m
因此可以使用公钥加密byte数组，使用私钥解密还原byte数组
byte数组组成了字符串、文件等
最后注意，要加密的明文二进制位数不能超过密钥的二进制位数
C. java中RSA用私钥加密公钥解密问题
公钥和私钥可以互换的用，用公钥加密私钥解密，用私钥加密公钥解密都ok，方法一样
D. JAVA公钥加密，私钥解密，该怎么解决
一个比较简单的实现:一个三个类KeyGenerater生成公钥私钥对，Signaturer类使用私钥签名，SignProvider用公钥验证。公钥和私钥使用Base64加密Base64这个类也在博客里面
public class KeyGenerater {
private byte[] priKey;
private byte[] pubKey;
public void generater() {
try {
Java.security.KeyPairGenerator keygen = java.security.KeyPairGenerator
.getInstance("RSA");
SecureRandom secrand = new SecureRandom();
secrand.setSeed("syj".getBytes()); // 初始化随机产生器
keygen.initialize(1024, secrand);
KeyPair keys = keygen.genKeyPair();
PublicKey pubkey = keys.getPublic();
PrivateKey prikey = keys.getPrivate();
pubKey = Base64.encodeToByte(pubkey.getEncoded());
priKey = Base64.encodeToByte(prikey.getEncoded());
System.out.println("pubKey = " + new String(pubKey));
System.out.println("priKey = " + new String(priKey));
} catch (java.lang.Exception e) {
System.out.println("生成密钥对失败");
e.printStackTrace();
}
}
public byte[] getPriKey() {
return priKey;
}
public byte[] getPubKey() {
return pubKey;
}
}
public class Signaturer {
/**
*
* Description:数字签名
*
* @param priKeyText
* @param plainText
* @return
* @author 孙钰佳
* @since：2007-12-27 上午10:51:48
*/
public static byte[] sign(byte[] priKeyText, String plainText) {
try {
PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64
.decode(priKeyText));
KeyFactory keyf = KeyFactory.getInstance("RSA");
PrivateKey prikey = keyf.generatePrivate(priPKCS8);
// 用私钥对信息生成数字签名
java.security.Signature signet = java.security.Signature
.getInstance("MD5withRSA");
signet.initSign(prikey);
signet.update(plainText.getBytes());
byte[] signed = Base64.encodeToByte(signet.sign());
return signed;
} catch (java.lang.Exception e) {
System.out.println("签名失败");
e.printStackTrace();
}
return null;
}
}
public class SignProvider {
private SignProvider() {
}
/**
*
* Description:校验数字签名,此方法不会抛出任务异常,成功返回true,失败返回false,要求全部参数不能为空
*
* @param pubKeyText
* 公钥,base64编码
* @param plainText
* 明文
* @param signTest
* 数字签名的密文,base64编码
* @return 校验成功返回true 失败返回false
* @author 孙钰佳
* @since：2007-12-27 上午09:33:55
*/
public static boolean verify(byte[] pubKeyText, String plainText,
byte[] signText) {
try {
// 解密由base64编码的公钥,并构造X509EncodedKeySpec对象
java.security.spec.X509EncodedKeySpec bobPubKeySpec = new java.security.spec.X509EncodedKeySpec(
Base64.decode(pubKeyText));
// RSA对称加密算法
java.security.KeyFactory keyFactory = java.security.KeyFactory
.getInstance("RSA");
// 取公钥匙对象
java.security.PublicKey pubKey = keyFactory
.generatePublic(bobPubKeySpec);
// 解密由base64编码的数字签名
byte[] signed = Base64.decode(signText);
java.security.Signature signatureChecker = java.security.Signature
.getInstance("MD5withRSA");
signatureChecker.initVerify(pubKey);
signatureChecker.update(plainText.getBytes());
// 验证签名是否正常
if (signatureChecker.verify(signed))
return true;
else
return false;
} catch (Throwable e) {
System.out.println("校验签名失败");
e.printStackTrace();
return false;
}
}
}
望采纳，谢谢。
E. JAVA公钥加密，私钥解密，该怎么解决
今天有空研究了下大家都在喊的AES加密！还以为是什么深奥的东西呢！终于了解了，心中释然了！跟大家一起分享下吧！DES其实就是：数据加密标准 英文的缩写！就是个加密的标注而已，AES就是 高级加密标准 英文的缩写咯，大家都叫缩写叫惯了，搞得我们这些没接触的人一头雾水！心里还真憋屈的慌呢！
这是在搜集资料的时候拿了个例子练手，不过有个问题就是，把这代码放到文本里用CMD运行的时候出现了乱码情况！所幸的是注释，不影响效果！但是，程序要真遇到这样的情况的话，就得转码了，因为文本的编码是GBK的，而我所要粘贴的代码的编码是UTF-8
[html] view plain
import java.util.*;
import java.io.*;
public class Test
{
private String encodeResult;//编码后字串
private String decodeResult;//解码后字串
public Test()
{
}
//编码设置
public void setEncodeResult(String encodeResult)
{
char[] src = encodeResult.toCharArray();//将待编码字串拆分成字符数组
StringBuilder sb = new StringBuilder();//保存编码后字符
//将待编码字串拆分成字符数组
for(int i = 0; i< src.length; i++)
{
if(Character.isDigit(src[i]))
{
if(i != src.length-1)
{//满足条件3
char[] temp = new char[Character.getNumericValue(src[i])+1];
Arrays.fill(temp,src[i+1]);
sb.append(temp);
sb.append("_");
}
else
{//满足条件2
sb.append(src[i]);
}
}
else if(src[i] == '_')//满足条件5
{
sb.append("\\UL");
sb.append("_");
}
else if(i == src.length-1)//满足条件1，且到了字串结尾
{
sb.append(src[i]);
}
else//满足条件1，且未到字串结尾
{
sb.append(src[i]);
sb.append("_");
}
}
this.encodeResult = new String(sb);//创建返回编码后字串
}
//获得编码后结果
public String getEncodeResult()
{
return encodeResult;
}
//解码设置
public void setDecodeResult(String encodeResult)
{
String[] temp = encodeResult.split("_");
StringBuilder sb = new StringBuilder();
for(int i = 0; i< temp.length; i++)
{
if(temp[i].equals("\\UL"))
sb.append("_");
else if(temp[i].length()>1)
sb.append(temp[i].length()-1);
else
sb.append(temp[i]);
}
this.decodeResult = new String(sb);
}
//获得解码后结果
public String getDecodeResult()
{
return decodeResult;
}
public static void main(String[] args)
{
System.out.println("请输入待编码字符串（以回车键结束）："); //此处存在一个乱码问题，在文本文档中的编码是GBK而它的编码是UTF-8，cmd不识别！
String source = "";
try
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
source = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
Test e = new Test();
e.setEncodeResult(source);
System.out.println("编码后结果："+e.getEncodeResult());
e.setDecodeResult(e.getEncodeResult());
System.out.println("解码后结果："+e.getDecodeResult());
}
}
[html] view plain
<pre name="code" class="html">请输入待编码字符串（以回车键结束）：
abcdc123
编码后结果：a_b_c_d_c_22_333_3
解码后结果：abcdc123
【最简单的加密】
1.简单的概念
明文：加密前的信息
密文：机密后的信息
算法：加密或解密的算法
密钥：算法使用的钥匙
例子：
将123456每位数字都加 1 后得到234567，
其中123456就是明文，
234567就是密文，
加密密钥就是1，
加密算法是每位加
[html] view plain
<span style="font-size:18px;">import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.SecretKeySpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/**
* 编码工具类
* 1.将byte[]转为各种进制的字符串
* 2.base 64 encode
* 3.base 64 decode
* 4.获取byte[]的md5值
* 5.获取字符串md5值
* 6.结合base64实现md5加密
* 7.AES加密
* 8.AES加密为base 64 code
* 9.AES解密
* 10.将base 64 code AES解密
* @author uikoo9
* @version 0.0.7.20140601
*/
public class Test {
public static void main(String[] args) throws Exception {
String content = "我爱你,祖国";
System.out.println("加密前：" + content);
String key = "123456";
System.out.println("加密密钥和解密密钥：" + key);
String encrypt = aesEncrypt(content, key);
System.out.println("加密后：" + encrypt);
String decrypt = aesDecrypt(encrypt, key);
System.out.println("解密后：" + decrypt);
}
/**
* AES加密为base 64 code
* @param content 待加密的内容
* @param encryptKey 加密密钥
* @return 加密后的base 64 code
* @throws Exception
*/
public static String aesEncrypt(String content, String encryptKey) throws Exception {
return base64Encode(aesEncryptToBytes(content, encryptKey));
}
/**
* AES加密
* @param content 待加密的内容
* @param encryptKey 加密密钥
* @return 加密后的byte[]
* @throws Exception
*/
public static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128, new SecureRandom(encryptKey.getBytes()));
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
return cipher.doFinal(content.getBytes("utf-8"));
}
/**
* base 64 encode
* @param bytes 待编码的byte[]
* @return 编码后的base 64 code
*/
public static String base64Encode(byte[] bytes){
return new BASE64Encoder().encode(bytes);
}
/**
* 将base 64 code AES解密
* @param encryptStr 待解密的base 64 code
* @param decryptKey 解密密钥
* @return 解密后的string
* @throws Exception
*/
public static String aesDecrypt(String encryptStr, String decryptKey) throws Exception {
return aesDecryptByBytes(base64Decode(encryptStr), decryptKey);
}
/**
* AES解密
* @param encryptBytes 待解密的byte[]
* @param decryptKey 解密密钥
* @return 解密后的String
* @throws Exception
*/
public static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128, new SecureRandom(decryptKey.getBytes()));
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
byte[] decryptBytes = cipher.doFinal(encryptBytes);
return new String(decryptBytes);
}
/**
* base 64 decode
* @param base64Code 待解码的base 64 code
* @return 解码后的byte[]
* @throws Exception
*/
public static byte[] base64Decode(String base64Code) throws Exception{
return new BASE64Decoder().decodeBuffer(base64Code);
}
}</span><span style="font-size:14px;">
</span>
F. JAVA公钥加密，私钥解密，该怎么解决
{
publicstaticfinalStringKEY_ALGORITHM="RSA";
_ALGORITHM="MD5withRSA";
_KEY="RSAPublicKey";
_KEY="RSAPrivateKey";
/**
*用私钥对信息生成数字签名
*
*@paramdata
*加密数据
*@paramprivateKey
*私钥
*
*@return
*@throwsException
*/
publicstaticStringsign(byte[]data,StringprivateKey)throwsException{
//解密由base64编码的私钥
byte[]keyBytes=decryptBASE64(privateKey);
//构造PKCS8EncodedKeySpec对象
=newPKCS8EncodedKeySpec(keyBytes);
//KEY_ALGORITHM指定的加密算法
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
//取私钥匙对象
PrivateKeypriKey=keyFactory.generatePrivate(pkcs8KeySpec);
//用私钥对信息生成数字签名
Signaturesignature=Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initSign(priKey);
signature.update(data);
returnencryptBASE64(signature.sign());
}
/**
*校验数字签名
*
*@paramdata
*加密数据
*@parampublicKey
*公钥
*@paramsign
*数字签名
*
*@return校验成功返回true失败返回false
*@throwsException
*
*/
publicstaticbooleanverify(byte[]data,StringpublicKey,Stringsign)
throwsException{
//解密由base64编码的公钥
byte[]keyBytes=decryptBASE64(publicKey);
//构造X509EncodedKeySpec对象
X509EncodedKeySpeckeySpec=newX509EncodedKeySpec(keyBytes);
//KEY_ALGORITHM指定的加密算法
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
//取公钥匙对象
PublicKeypubKey=keyFactory.generatePublic(keySpec);
Signaturesignature=Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initVerify(pubKey);
signature.update(data);
//验证签名是否正常
returnsignature.verify(decryptBASE64(sign));
}
/**
*解密
*用私钥解密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]decryptByPrivateKey(byte[]data,Stringkey)
throwsException{
//对密钥解密
byte[]keyBytes=decryptBASE64(key);
//取得私钥
=newPKCS8EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
KeyprivateKey=keyFactory.generatePrivate(pkcs8KeySpec);
//对数据解密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE,privateKey);
returncipher.doFinal(data);
}
/**
*解密
*用公钥解密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]decryptByPublicKey(byte[]data,Stringkey)
throwsException{
//对密钥解密
byte[]keyBytes=decryptBASE64(key);
//取得公钥
X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
KeypublicKey=keyFactory.generatePublic(x509KeySpec);
//对数据解密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE,publicKey);
returncipher.doFinal(data);
}
/**
*加密
*用公钥加密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]encryptByPublicKey(byte[]data,Stringkey)
throwsException{
//对公钥解密
byte[]keyBytes=decryptBASE64(key);
//取得公钥
X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
KeypublicKey=keyFactory.generatePublic(x509KeySpec);
//对数据加密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE,publicKey);
returncipher.doFinal(data);
}
/**
*加密
*用私钥加密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]encryptByPrivateKey(byte[]data,Stringkey)
throwsException{
//对密钥解密
byte[]keyBytes=decryptBASE64(key);
//取得私钥
=newPKCS8EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
KeyprivateKey=keyFactory.generatePrivate(pkcs8KeySpec);
//对数据加密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
returncipher.doFinal(data);
}
/**
*取得私钥
*
*@paramkeyMap
*@return
*@throwsException
*/
(Map<String,Object>keyMap)
throwsException{
Keykey=(Key)keyMap.get(PRIVATE_KEY);
returnencryptBASE64(key.getEncoded());
}
/**
*取得公钥
*
*@paramkeyMap
*@return
*@throwsException
*/
(Map<String,Object>keyMap)
throwsException{
Keykey=(Key)keyMap.get(PUBLIC_KEY);
returnencryptBASE64(key.getEncoded());
}
/**
*初始化密钥
*
*@return
*@throwsException
*/
publicstaticMap<String,Object>initKey()throwsException{
KeyPairGeneratorkeyPairGen=KeyPairGenerator
.getInstance(KEY_ALGORITHM);
keyPairGen.initialize(1024);
KeyPairkeyPair=keyPairGen.generateKeyPair();
//公钥
RSAPublicKeypublicKey=(RSAPublicKey)keyPair.getPublic();
//私钥
RSAPrivateKeyprivateKey=(RSAPrivateKey)keyPair.getPrivate();
Map<String,Object>keyMap=newHashMap<String,Object>(2);
keyMap.put(PUBLIC_KEY,publicKey);
keyMap.put(PRIVATE_KEY,privateKey);
returnkeyMap;
}
}
G. JAVA公钥加密，私钥解密，该怎么解决
RSA加密算法，是世界上第一个非对称加密算法，也是数论的第一个实际应用。它的算法如下：
1.找两个非常大的质数p和q（通常p和q都有155十进制位或都有512十进制位）并计算n=pq，k=(p-1)(q-1)。
2.将明文编码成整数M，保证M不小于0但是小于n。
3.任取一个整数e，保证e和k互质，而且e不小于0但是小于k。加密钥匙（称作公钥）是(e, n)。
4.找到一个整数d，使得ed除以k的余数是1（只要e和n满足上面条件，d肯定存在）。解密钥匙（称作密钥）是(d, n)。
加密过程： 加密后的编码C等于M的e次方除以n所得的余数。
解密过程： 解密后的编码N等于C的d次方除以n所得的余数。
只要e、d和n满足上面给定的条件。M等于N。
H. JAVA公钥加密，私钥解密，该怎么解决
public String encryptStringWithRSA(RSAPublicKey publicKey,
String str)
{
String key;
try
{
key =
encode(publicKey.getEncoded());
byte[] keyBytes =
decode(key);
X509EncodedKeySpec x509KeySpec = new
X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory =
KeyFactory.getInstance(RSA);
Key publicK =
keyFactory.generatePublic(x509KeySpec);
// 对数据加密
Cipher cipher =
Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE,
publicK);
byte[] data = str.getBytes();
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
parseByte2HexStr(encryptedData);
} catch (Exception
e)
{
e.printStackTrace();
}
return ERROR;
}
public
String decryptStringWithRSA(RSAPrivateKey privateKey, String str)
{
if
(!str.equals(""))
{
String key;
try
{
key =
encode(privateKey.getEncoded());
byte[] keyBytes =
decode(key);
PKCS8EncodedKeySpec pkcs8KeySpec = new
PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory =
KeyFactory.getInstance(RSA);
Key privateK =
keyFactory.generatePrivate(pkcs8KeySpec);
Cipher cipher =
Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE,
privateK);
byte[] encryptedData = parseHexStr2Byte(str);
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 new
String(decryptedData);
} catch (Exception
e)
{
e.printStackTrace();
}
} else
{
return
str;
}
return ERROR;
}收起
I. JAVA 公钥与私钥的问题
这个公钥和私钥如果是非对称加密的算法，那么用公钥加密的话，就需要用私钥才能解密了。如果是对称加密的话，就用加密的公钥就可以解密了。
SSL加密通信的过程一般都是首先双方确认大家支持的加密方式，然后采用一种大家都支持的，然后的话，就先用非对称加密将公钥加密然后发给client，然后client解密获得公钥。之后的话，大家就可以用公钥进行对称加密了。