java用btc的公鑰來加密
㈠ 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 公鑰進行加密
.NET無法調用JAVA產生的RSA公鑰，必須將RSA演算法在.NET裡面重寫才行，在.NET裡面RSA的公鑰長度是128位的，但是你給出的JAVA公鑰卻是159位長度，非常的不標准，公鑰長度不滿足128的肯定無法給.NET使用。
這里最多幫做個對應解析，數據是肯定無法用的：
將java的RSA公鑰最後四個字母AQAB分割開，用.NET的xml格式表示就是
<RSAKeyValue><Molus>
/qp
jLFfDCu3qytxf+/IoCYE
+Hf4hsEDUKV2kkhRJsnwwID</Molus><Exponent>AQAB</Exponent>
</RSAKeyValue>
這里的數據都是用的BASE64編碼，你用BASE64解碼後可以得到byte[]，就可以看到密鑰長度了，實際密鑰要轉換為BigInteger後才能參與RSA核心運算
㈢ 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));
}
/**
*解密<br>
*用私鑰解密
*
*@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);
}
/**
*解密<br>
*用公鑰解密
*
*@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);
}
/**
*加密<br>
*用公鑰加密
*
*@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);
}
/**
*加密<br>
*用私鑰加密
*
*@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;
}
}
㈣ Java 第三方公鑰 RSA加密求助
下面是RSA加密代碼。
/**
* RSA演算法，實現數據的加密解密。
* @author ShaoJiang
*
*/
public class RSAUtil {
private static Cipher cipher;
static{
try {
cipher = Cipher.getInstance("RSA");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
}
}
/**
* 生成密鑰對
* @param filePath 生成密鑰的路徑
* @return
*/
public static Map<String,String> generateKeyPair(String filePath){
try {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
// 密鑰位數
keyPairGen.initialize(1024);
// 密鑰對
KeyPair keyPair = keyPairGen.generateKeyPair();
// 公鑰
PublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
// 私鑰
PrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
//得到公鑰字元串
String publicKeyString = getKeyString(publicKey);
//得到私鑰字元串
String privateKeyString = getKeyString(privateKey);
FileWriter pubfw = new FileWriter(filePath+"/publicKey.keystore");
FileWriter prifw = new FileWriter(filePath+"/privateKey.keystore");
BufferedWriter pubbw = new BufferedWriter(pubfw);
BufferedWriter pribw = new BufferedWriter(prifw);
pubbw.write(publicKeyString);
pribw.write(privateKeyString);
pubbw.flush();
pubbw.close();
pubfw.close();
pribw.flush();
pribw.close();
prifw.close();
//將生成的密鑰對返回
Map<String,String> map = new HashMap<String,String>();
map.put("publicKey",publicKeyString);
map.put("privateKey",privateKeyString);
return map;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 得到公鑰
*
* @param key
* 密鑰字元串（經過base64編碼）
* @throws Exception
*/
public static PublicKey getPublicKey(String key) throws Exception {
byte[] keyBytes;
keyBytes = (new BASE64Decoder()).decodeBuffer(key);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(keySpec);
return publicKey;
}
/**
* 得到私鑰
*
* @param key
* 密鑰字元串（經過base64編碼）
* @throws Exception
*/
public static PrivateKey getPrivateKey(String key) throws Exception {
byte[] keyBytes;
keyBytes = (new BASE64Decoder()).decodeBuffer(key);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
return privateKey;
}
/**
* 得到密鑰字元串（經過base64編碼）
*
* @return
*/
public static String getKeyString(Key key) throws Exception {
byte[] keyBytes = key.getEncoded();
String s = (new BASE64Encoder()).encode(keyBytes);
return s;
}
/**
* 使用公鑰對明文進行加密，返回BASE64編碼的字元串
* @param publicKey
* @param plainText
* @return
*/
public static String encrypt(PublicKey publicKey,String plainText){
try {
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] enBytes = cipher.doFinal(plainText.getBytes());
return (new BASE64Encoder()).encode(enBytes);
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
/**
* 使用keystore對明文進行加密
* @param publicKeystore 公鑰文件路徑
* @param plainText 明文
* @return
*/
public static String encrypt(String publicKeystore,String plainText){
try {
FileReader fr = new FileReader(publicKeystore);
BufferedReader br = new BufferedReader(fr);
String publicKeyString="";
String str;
while((str=br.readLine())!=null){
publicKeyString+=str;
}
br.close();
fr.close();
cipher.init(Cipher.ENCRYPT_MODE,getPublicKey(publicKeyString));
byte[] enBytes = cipher.doFinal(plainText.getBytes());
return (new BASE64Encoder()).encode(enBytes);
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 使用私鑰對明文密文進行解密
* @param privateKey
* @param enStr
* @return
*/
public static String decrypt(PrivateKey privateKey,String enStr){
try {
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));
return new String(deBytes);
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* 使用keystore對密文進行解密
* @param privateKeystore 私鑰路徑
* @param enStr 密文
* @return
*/
public static String decrypt(String privateKeystore,String enStr){
try {
FileReader fr = new FileReader(privateKeystore);
BufferedReader br = new BufferedReader(fr);
String privateKeyString="";
String str;
while((str=br.readLine())!=null){
privateKeyString+=str;
}
br.close();
fr.close();
cipher.init(Cipher.DECRYPT_MODE, getPrivateKey(privateKeyString));
byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));
return new String(deBytes);
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
㈤ JAVA 公鑰與私鑰的問題
這個公鑰和私鑰如果是非對稱加密的演算法，那麼用公鑰加密的話，就需要用私鑰才能解密了。如果是對稱加密的話，就用加密的公鑰就可以解密了。
SSL加密通信的過程一般都是首先雙方確認大家支持的加密方式，然後採用一種大家都支持的，然後的話，就先用非對稱加密將公鑰加密然後發給client，然後client解密獲得公鑰。之後的話，大家就可以用公鑰進行對稱加密了。
㈥ JAVA寫RSA加密，公鑰私鑰都是一樣的，為什麼每次加密的結果不一樣
JAVA寫RSA加密，私鑰都是一樣的，公鑰每次加密的結果不一樣跟對數據的padding（填充）有關。
㈦ C#用JavaRSA公鑰加密得到的密文再用Java去解可以嗎
RSA 加密的話，一共有幾個參數，你需要看看你的填充（padding）是不是配置成一樣的，另外就是你的塊長度是不是兩邊一樣了。一般來說解密不對都是因為這些配置沒有對。
㈧ 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>
㈨ java程序報錯後 base64encode 使用公鑰加密 加密值為一樣的 怎麼回事
在開發的時候遇到個現象。對方用PHPbase64_encode()對字元串進行加米。但我這邊是用Java解馬。導致出現問題。問題如下：[java]viewplainpackagecom.tudou.test;importjava.io.IOException;/***javabase64編碼和解碼的演示類*
㈩ java 中的Cipher類RSA方式能不能用私鑰加密公鑰解密，完整解釋下
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個參數就可以。
但是我要提醒樓主，你要公鑰解密，公鑰是公開的，相當於任何人都查到公鑰可以解密。
你是想做簽名是吧。