国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

JAVA加密算法（4）- 非對稱加密算法（DH，RSA）

Lucky_Boy / 1337人閱讀

摘要：非對稱密碼概念發送者使用接收者的公鑰加密，接收者使用自己的私鑰解密。

非對稱密碼概念 
發送者使用接收者的公鑰加密，接收者使用自己的私鑰解密。


需要兩個密鑰進行加密或解密，分為公鑰和私鑰


特點：安全性高，速度慢
常用算法

DH密鑰交換算法

RSA算法

ElGamal算法那

用途

密鑰交換（DH）

雙方在沒有確定共同密鑰的情況下，生成密鑰，不提供加密工作，加解密還需要其他對稱加密算法實現

加密/解密（RSA）

數字簽名（RSA）

DH算法示例 
import javax.crypto.KeyAgreement;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

//1 生成源密鑰
//2 把源公鑰交給目標，目標通過源公鑰，生成目標公鑰和私鑰
//3 把目標公鑰交給源
//4 雙方使用對方的公鑰和和自己的私鑰，生成本地密鑰
//5 如果雙方生成本地密鑰相同則完成密鑰交換
public class DHUtil {

    public static final String PUBLIC_KEY = "DH_Public_Key";
    public static final String PRIVATE_KEY = "DH_Private_key";

    /**
     * 生成源密鑰對
     * @return
     * @throws Exception
     */
    public static Map initSourceKey() throws Exception{
        //創建KeyPairGenerator的實例，選用DH算法
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");

        //初始化密鑰長度，默認1024，可選范圍512-65536 & 64的倍數
        keyPairGenerator.initialize(1024);

        //生成密鑰對
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        DHPublicKey dhPublicKey = (DHPublicKey) keyPair.getPublic();
        DHPrivateKey dhPrivateKey = (DHPrivateKey) keyPair.getPrivate();

        //將密鑰對放入Map
        Map keyMap = new HashMap();
        keyMap.put(PUBLIC_KEY, dhPublicKey);
        keyMap.put(PRIVATE_KEY, dhPrivateKey);
        return keyMap;
    }

    /**
     * 通過源公鑰 生成 目標密鑰對
     * @param sourcePublicKey
     * @return
     * @throws Exception
     */
    public static Map initTargetKey(byte[] sourcePublicKey) throws Exception {

        KeyFactory keyFactory = KeyFactory.getInstance("DH");

        //通過源公鑰，生成keySpec，使用KeyFactory生成源PublicKey相關信息
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(sourcePublicKey);
        DHPublicKey sourcePublic = (DHPublicKey) keyFactory.generatePublic(keySpec);

        DHParameterSpec dhPublicKeyParams = sourcePublic.getParams();

        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
        keyPairGenerator.initialize(dhPublicKeyParams);

        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        DHPublicKey dhPublicKey = (DHPublicKey) keyPair.getPublic();
        DHPrivateKey dhPrivateKey = (DHPrivateKey) keyPair.getPrivate();

        //將密鑰對放入Map
        Map keyMap = new HashMap();
        keyMap.put(PUBLIC_KEY, dhPublicKey);
        keyMap.put(PRIVATE_KEY, dhPrivateKey);
        return keyMap;
    }

    /**
     * 使用一方的公鑰和另一方的私鑰，生成本地密鑰
     * @return
     */
    public static byte[] generateLocalSecretKey(byte[] aPublicKey, byte[] bPrivateKey) throws Exception{
        KeyFactory keyFactory = KeyFactory.getInstance("DH");

        //通過A公鑰，生成keySpec，使用KeyFactory生成A PublicKey相關信息
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(aPublicKey);
        PublicKey publicKey = keyFactory.generatePublic(keySpec);

        //通過B私鑰，生成B PrivateKey相關信息
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(bPrivateKey);
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

        //通過KeyAgreement對A的PublicKey和B的PrivateKey進行加密
        KeyAgreement keyAgreement = KeyAgreement.getInstance("DH");
        keyAgreement.init(privateKey);
        keyAgreement.doPhase(publicKey,true);


        return keyAgreement.generateSecret("AES").getEncoded();//算法使用對稱加密算法（DES，DESede，AES）
        //return keyAgreement.generateSecret();                // 也可以不選擇算法，使用默認方法計算
    }

    //獲取公鑰字節數組
    public static byte[] getPublicKey(Map map){
        return ((DHPublicKey) map.get(PUBLIC_KEY)).getEncoded();
    }

    //獲取私鑰字節數組
    public static byte[] getPrivateKey(Map map){
        return ((DHPrivateKey) map.get(PRIVATE_KEY)).getEncoded();
    }

    public static void main(String[] args) throws Exception {

        byte[] source_public_key;
        byte[] source_private_key;
        byte[] source_local_key;

        byte[] target_public_key;
        byte[] target_private_key;
        byte[] target_local_key;

        Map sourceKey = initSourceKey();
        source_public_key = getPublicKey(sourceKey);
        source_private_key = getPrivateKey(sourceKey);

        System.out.println("源公鑰："+BytesToHex.fromBytesToHex(source_public_key));
        System.out.println("源私鑰："+BytesToHex.fromBytesToHex(source_private_key));

        Map targetKey = initTargetKey(getPublicKey(sourceKey));
        target_public_key = getPublicKey(targetKey);
        target_private_key = getPrivateKey(targetKey);

        System.out.println("目標公鑰："+BytesToHex.fromBytesToHex(target_public_key));
        System.out.println("目標私鑰："+BytesToHex.fromBytesToHex(target_private_key));

        source_local_key = generateLocalSecretKey(target_public_key, source_private_key);
        target_local_key = generateLocalSecretKey(source_public_key, target_private_key);

        System.out.println("源本地密鑰："+BytesToHex.fromBytesToHex(source_local_key));
        System.out.println("目標本地密鑰："+BytesToHex.fromBytesToHex(target_local_key));
    }
}
RSA 加密/解密 示例 
公鑰加密，私鑰解密
import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.HashMap;
import java.util.Map;

/**
 * RSA加密工具
 */
public class RSAUtil {

    public static final String PUBLIC_KEY = "RSA_Public_Key";
    public static final String PRIVATE_KEY = "RSA_Private_Key";

    /**
     * 初始化密鑰
     * @return
     * @throws Exception
     */
    public static Map initKey() throws Exception{
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(1024);//512-65536 & 64的倍數
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        Map keyMap = new HashMap();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    public static RSAPublicKey getPublicKey(Map keyMap) {
        return (RSAPublicKey) keyMap.get(PUBLIC_KEY);
    }

    public static RSAPrivateKey getPrivateKey(Map keyMap){
        return (RSAPrivateKey) keyMap.get(PRIVATE_KEY);
    }

    /**
     * 使用公鑰對數據進行加密
     * @param data
     * @param publicKey
     * @return
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, RSAPublicKey publicKey) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE,publicKey);
        return cipher.doFinal(data);
    }

    /**
     * 使用私鑰解密
     * @param data
     * @param privateKey
     * @return
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, RSAPrivateKey privateKey) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE,privateKey);
        return cipher.doFinal(data);
    }

    public static void main(String[] args) throws Exception {
        String data = "周杰倫-東風破";
        Map keyMap = initKey();

        byte[] miwen = encrypt(data.getBytes(),getPublicKey(keyMap));
        System.out.println("加密后的內容："+BytesToHex.fromBytesToHex(miwen));

        byte[] plain = decrypt(miwen, getPrivateKey(keyMap));
        System.out.println("解密后的內容："+new String(plain));

    }
}

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/66233.html

相關文章

  • 慕課網_《Java實現非對稱加密》學習總結

    摘要：時間年月日星期三說明本文部分內容均來自慕課網。秘密密鑰，生成一個分組的秘密密鑰。 時間：2017年4月12日星期三說明：本文部分內容均來自慕課網。@慕課網：http://www.imooc.com教學示例源碼：https://github.com/zccodere/s...個人學習源碼：https://github.com/zccodere/s... 第一章：概述 1-1 概述 非對稱...

    dailybird 評論0 收藏0

  • 沒那么淺地談談HTTP與HTTPS【三】

    摘要：公開密鑰加密的出現大大減輕了交換對稱密鑰的困難，公鑰可以公開透過不安全可被竊聽的渠道發送，用以加密明文。當與配合使用，稱之為，與配合則稱為，以此類推。這步沒有簽名，服務端收到數據后不會發現被篡改。對于認證機構，一旦私鑰外泄，將可能導致整未濟，亨。小狐汔濟，濡其尾，無攸利?！兑住妨?、密鑰管理當不再擔心身份會被冒充、篡改之后，我們再來詳細談談網絡通信中對于加密算法的密鑰管理。在密鑰被簽發后，...

    Tecode 評論0 收藏0

  • JAVA加密算法（1）- 密碼學概述及BASE64算法使用

    密碼學綜述 密碼學基本功能 機密性、鑒別、報文完整性、不可否認性 基本模型 sender-->加密算法 --> 密文 --> 解密算法 --> receiver 密鑰源 密碼學算法分類： 消息編碼：Base64 消息摘要：MD類，SHA類，MAC 對稱加密：DES，3DES，AES 非對稱加密：RSA，DH密鑰交換 數字簽名：RSA signature，DSA signature 密碼學...

    sevi_stuo 評論0 收藏0

  • Swoole 源碼分析——Server模塊之OpenSSL (上)

    摘要：另一方比如小明得到公鑰之后，雙方就可以通信。然而，中間人還是可能截獲公鑰，然后自己弄一對秘鑰，然后告訴小明說是小紅的公鑰。這樣，小亮在簽署小紅的身份證的時候，可以在小紅身份證后面附上自己的身份證。一般來說，自簽名的根身份證用于公司內部使用。 前言 自從 Lets Encrypt 上線之后，HTTPS 網站數量占比越來越高，相信不久的未來就可以實現全網 HTTPS，大部分主流瀏覽器也對 ...

    ky0ncheng 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<