私鑰加密公鑰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解密獲得公鑰。之後的話，大家就可以用公鑰進行對稱加密了。