`
Huaqingfly
  • 浏览: 57228 次
社区版块
存档分类
最新评论

JAVA加密算法5

阅读更多
关键字: dh, 公钥, 私钥, 非对称加密, 密钥一致协议
    接下来我们分析DH加密算法,一种适用于网络交互的加密算法。
DH
Diffie-Hellman算法(D-H算法),密钥一致协议。是由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。简单的说就是允许两名用户在公开媒体上交换信息以生成"一致"的、可以共享的密钥。换句话说,就是由甲方产出一对密钥(公钥、私钥),乙方依照甲方公钥产生乙方密钥对(公钥、私钥)。以此为基线,作为数据传输保密基础,同时双方使用同一种对称加密算法构建本地密钥(SecretKey)对数据加密。这样,在互通了本地密钥(SecretKey)算法后,甲乙双方公开自己的公钥,使用对方的公钥和刚才产生的私钥加密数据,同时可以使用对方的公钥和自己的私钥对数据解密。不单单是甲乙双方两方,可以扩展为多方共享数据通讯,这样就完成了网络交互数据的安全通讯!
    当讲到RSA的时候,我们就有一个疑问?如果公钥只能加密,私钥只能解密,但是双方都需要互通加密数据该怎么办?使用DH加密算法!在我看来,这就是他最大的特色!据说该算法源于中国的同余定理——中国馀数定理。

通过java代码实现如下:Coder类见 java加密技术(一)
Java代码
import java.security.Key;  
import java.security.KeyFactory;  
import java.security.KeyPair;  
import java.security.KeyPairGenerator;  
import java.security.PublicKey;  
import java.security.spec.PKCS8EncodedKeySpec;  
import java.security.spec.X509EncodedKeySpec;  
import java.util.HashMap;  
import java.util.Map;  
 
import javax.crypto.Cipher;  
import javax.crypto.KeyAgreement;  
import javax.crypto.SecretKey;  
import javax.crypto.interfaces.DHPrivateKey;  
import javax.crypto.interfaces.DHPublicKey;  
import javax.crypto.spec.DHParameterSpec;  
 
/** 
* DH安全编码组件 
*  
* @author 梁栋 
* @version 1.0 
* @since 1.0 
*/ 
public abstract class DHCoder extends Coder {  
    public static final String ALGORITHM = "DH";  
 
    /** 
     * DH加密下需要一种对称加密算法对数据加密,这里我们使用DES,也可以使用其他对称加密算法。 
     */ 
    public static final String SECRET_ALGORITHM = "DES";  
    private static final String PUBLIC_KEY = "DHPublicKey";  
    private static final String PRIVATE_KEY = "DHPrivateKey";  
 
    /** 
     * 初始化甲方密钥 
     *  
     * @return 
     * @throws Exception 
     */ 
    public static Map<String, Object> initKey() throws Exception {  
        KeyPairGenerator keyPairGenerator = KeyPairGenerator  
                .getInstance(ALGORITHM);  
        keyPairGenerator.initialize(512);  
 
        KeyPair keyPair = keyPairGenerator.generateKeyPair();  
 
        // 甲方公钥  
        DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();  
 
        // 甲方私钥  
        DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();  
 
        Map<String, Object> keyMap = new HashMap<String, Object>(2);  
 
        keyMap.put(PUBLIC_KEY, publicKey);  
        keyMap.put(PRIVATE_KEY, privateKey);  
        return keyMap;  
    }  
 
    /** 
     * 初始化乙方密钥 
     *  
     * @param key 
     *            甲方公钥 
     * @return 
     * @throws Exception 
     */ 
    public static Map<String, Object> initKey(String key) throws Exception {  
        // 解析甲方公钥  
        byte[] keyBytes = decryptBASE64(key);  
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);  
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);  
 
        // 由甲方公钥构建乙方密钥  
        DHParameterSpec dhParamSpec = ((DHPublicKey) pubKey).getParams();  
 
        KeyPairGenerator keyPairGenerator = KeyPairGenerator  
                .getInstance(ALGORITHM);  
        keyPairGenerator.initialize(dhParamSpec);  
 
        KeyPair keyPair = keyPairGenerator.generateKeyPair();  
 
        // 乙方公钥  
        DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();  
 
        // 乙方私钥  
        DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();  
 
        Map<String, Object> keyMap = new HashMap<String, Object>(2);  
 
        keyMap.put(PUBLIC_KEY, publicKey);  
        keyMap.put(PRIVATE_KEY, privateKey);  
 
        return keyMap;  
    }  
 
    /** 
     * 加密<br> 
     *  
     * @param data 
     * @param publicKey 
     *            甲方公钥 
     * @param privateKey 
     *            乙方私钥 
     * @return 
     * @throws Exception 
     */ 
    public static byte[] encrypt(byte[] data, String publicKey,  
            String privateKey) throws Exception {  
 
        // 初始化公钥  
        byte[] pubKeyBytes = decryptBASE64(publicKey);  
 
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);  
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKeyBytes);  
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);  
 
        // 初始化私钥  
        byte[] priKeyBytes = decryptBASE64(privateKey);  
 
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKeyBytes);  
        Key priKey = keyFactory.generatePrivate(pkcs8KeySpec);  
 
        KeyAgreement keyAgree = KeyAgreement.getInstance(ALGORITHM);  
        keyAgree.init(priKey);  
        keyAgree.doPhase(pubKey, true);  
 
        // 生成本地密钥  
        SecretKey secretKey = keyAgree.generateSecret(SECRET_ALGORITHM);  
 
        // 数据加密  
        Cipher cipher = Cipher.getInstance(SECRET_ALGORITHM);  
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);  
 
        return cipher.doFinal(data);  
    }  
 
    /** 
     * 解密<br> 
     *  
     * @param data 
     * @param publicKey 
     *            乙方公钥 
     * @param privateKey 
     *            乙方私钥 
     * @return 
     * @throws Exception 
     */ 
    public static byte[] decrypt(byte[] data, String publicKey,  
            String privateKey) throws Exception {  
 
        // 初始化公钥  
        byte[] pubKeyBytes = decryptBASE64(publicKey);  
 
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);  
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKeyBytes);  
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);  
 
        // 初始化私钥  
        byte[] priKeyBytes = decryptBASE64(privateKey);  
 
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKeyBytes);  
        Key priKey = keyFactory.generatePrivate(pkcs8KeySpec);  
 
        KeyAgreement keyAgree = KeyAgreement.getInstance(ALGORITHM);  
        keyAgree.init(priKey);  
        keyAgree.doPhase(pubKey, true);  
 
        // 生成本地密钥  
        SecretKey secretKey = keyAgree.generateSecret(SECRET_ALGORITHM);  
 
        // 数据解密  
        Cipher cipher = Cipher.getInstance(SECRET_ALGORITHM);  
        cipher.init(Cipher.DECRYPT_MODE, secretKey);  
 
        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());  
    }  


import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.SecretKey;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;

/**
* DH安全编码组件
*
* @author 梁栋
* @version 1.0
* @since 1.0
*/
public abstract class DHCoder extends Coder {
public static final String ALGORITHM = "DH";

/**
* DH加密下需要一种对称加密算法对数据加密,这里我们使用DES,也可以使用其他对称加密算法。
*/
public static final String SECRET_ALGORITHM = "DES";
private static final String PUBLIC_KEY = "DHPublicKey";
private static final String PRIVATE_KEY = "DHPrivateKey";

/**
* 初始化甲方密钥
*
* @return
* @throws Exception
*/
public static Map<String, Object> initKey() throws Exception {
KeyPairGenerator keyPairGenerator = KeyPairGenerator
.getInstance(ALGORITHM);
keyPairGenerator.initialize(512);

KeyPair keyPair = keyPairGenerator.generateKeyPair();

// 甲方公钥
DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();

// 甲方私钥
DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();

Map<String, Object> keyMap = new HashMap<String, Object>(2);

keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);
return keyMap;
}

/**
* 初始化乙方密钥
*
* @param key
*            甲方公钥
* @return
* @throws Exception
*/
public static Map<String, Object> initKey(String key) throws Exception {
// 解析甲方公钥
byte[] keyBytes = decryptBASE64(key);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

// 由甲方公钥构建乙方密钥
DHParameterSpec dhParamSpec = ((DHPublicKey) pubKey).getParams();

KeyPairGenerator keyPairGenerator = KeyPairGenerator
.getInstance(ALGORITHM);
keyPairGenerator.initialize(dhParamSpec);

KeyPair keyPair = keyPairGenerator.generateKeyPair();

// 乙方公钥
DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();

// 乙方私钥
DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();

Map<String, Object> keyMap = new HashMap<String, Object>(2);

keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);

return keyMap;
}

/**
* 加密<br>
*
* @param data
* @param publicKey
*            甲方公钥
* @param privateKey
*            乙方私钥
* @return
* @throws Exception
*/
public static byte[] encrypt(byte[] data, String publicKey,
String privateKey) throws Exception {

// 初始化公钥
byte[] pubKeyBytes = decryptBASE64(publicKey);

KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKeyBytes);
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

// 初始化私钥
byte[] priKeyBytes = decryptBASE64(privateKey);

PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKeyBytes);
Key priKey = keyFactory.generatePrivate(pkcs8KeySpec);

KeyAgreement keyAgree = KeyAgreement.getInstance(ALGORITHM);
keyAgree.init(priKey);
keyAgree.doPhase(pubKey, true);

// 生成本地密钥
SecretKey secretKey = keyAgree.generateSecret(SECRET_ALGORITHM);

// 数据加密
Cipher cipher = Cipher.getInstance(SECRET_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, secretKey);

return cipher.doFinal(data);
}

/**
* 解密<br>
*
* @param data
* @param publicKey
*            乙方公钥
* @param privateKey
*            乙方私钥
* @return
* @throws Exception
*/
public static byte[] decrypt(byte[] data, String publicKey,
String privateKey) throws Exception {

// 初始化公钥
byte[] pubKeyBytes = decryptBASE64(publicKey);

KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKeyBytes);
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

// 初始化私钥
byte[] priKeyBytes = decryptBASE64(privateKey);

PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKeyBytes);
Key priKey = keyFactory.generatePrivate(pkcs8KeySpec);

KeyAgreement keyAgree = KeyAgreement.getInstance(ALGORITHM);
keyAgree.init(priKey);
keyAgree.doPhase(pubKey, true);

// 生成本地密钥
SecretKey secretKey = keyAgree.generateSecret(SECRET_ALGORITHM);

// 数据解密
Cipher cipher = Cipher.getInstance(SECRET_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, secretKey);

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());
}
}


再给出一个测试类:
Java代码
import static org.junit.Assert.*;  
 
import java.util.Map;  
 
import org.junit.Test;  
 
/** 
*  
* @author 梁栋 
* @version 1.0 
* @since 1.0 
*/ 
public class DHCoderTest {  
 
    @Test 
    public void test() throws Exception {  
        // 生成甲方密钥对儿  
        Map<String, Object> aKeyMap = DHCoder.initKey();  
        String aPublicKey = DHCoder.getPublicKey(aKeyMap);  
        String aPrivateKey = DHCoder.getPrivateKey(aKeyMap);  
 
        System.err.println("甲方公钥:\r" + aPublicKey);  
        System.err.println("甲方私钥:\r" + aPrivateKey);  
          
        // 由甲方公钥产生本地密钥对儿  
        Map<String, Object> bKeyMap = DHCoder.initKey(aPublicKey);  
        String bPublicKey = DHCoder.getPublicKey(bKeyMap);  
        String bPrivateKey = DHCoder.getPrivateKey(bKeyMap);  
          
        System.err.println("乙方公钥:\r" + bPublicKey);  
        System.err.println("乙方私钥:\r" + bPrivateKey);  
          
        String aInput = "abc ";  
        System.err.println("原文: " + aInput);  
 
        // 由甲方公钥,乙方私钥构建密文  
        byte[] aCode = DHCoder.encrypt(aInput.getBytes(), aPublicKey,  
                bPrivateKey);  
 
        // 由乙方公钥,甲方私钥解密  
        byte[] aDecode = DHCoder.decrypt(aCode, bPublicKey, aPrivateKey);  
        String aOutput = (new String(aDecode));  
 
        System.err.println("解密: " + aOutput);  
 
        assertEquals(aInput, aOutput);  
 
        System.err.println(" ===============反过来加密解密================== ");  
        String bInput = "def ";  
        System.err.println("原文: " + bInput);  
 
        // 由乙方公钥,甲方私钥构建密文  
        byte[] bCode = DHCoder.encrypt(bInput.getBytes(), bPublicKey,  
                aPrivateKey);  
 
        // 由甲方公钥,乙方私钥解密  
        byte[] bDecode = DHCoder.decrypt(bCode, aPublicKey, bPrivateKey);  
        String bOutput = (new String(bDecode));  
 
        System.err.println("解密: " + bOutput);  
 
        assertEquals(bInput, bOutput);  
    }  
 


import static org.junit.Assert.*;

import java.util.Map;

import org.junit.Test;

/**
*
* @author 梁栋
* @version 1.0
* @since 1.0
*/
public class DHCoderTest {

@Test
public void test() throws Exception {
// 生成甲方密钥对儿
Map<String, Object> aKeyMap = DHCoder.initKey();
String aPublicKey = DHCoder.getPublicKey(aKeyMap);
String aPrivateKey = DHCoder.getPrivateKey(aKeyMap);

System.err.println("甲方公钥:\r" + aPublicKey);
System.err.println("甲方私钥:\r" + aPrivateKey);

// 由甲方公钥产生本地密钥对儿
Map<String, Object> bKeyMap = DHCoder.initKey(aPublicKey);
String bPublicKey = DHCoder.getPublicKey(bKeyMap);
String bPrivateKey = DHCoder.getPrivateKey(bKeyMap);

System.err.println("乙方公钥:\r" + bPublicKey);
System.err.println("乙方私钥:\r" + bPrivateKey);

String aInput = "abc ";
System.err.println("原文: " + aInput);

// 由甲方公钥,乙方私钥构建密文
byte[] aCode = DHCoder.encrypt(aInput.getBytes(), aPublicKey,
bPrivateKey);

// 由乙方公钥,甲方私钥解密
byte[] aDecode = DHCoder.decrypt(aCode, bPublicKey, aPrivateKey);
String aOutput = (new String(aDecode));

System.err.println("解密: " + aOutput);

assertEquals(aInput, aOutput);

System.err.println(" ===============反过来加密解密================== ");
String bInput = "def ";
System.err.println("原文: " + bInput);

// 由乙方公钥,甲方私钥构建密文
byte[] bCode = DHCoder.encrypt(bInput.getBytes(), bPublicKey,
aPrivateKey);

// 由甲方公钥,乙方私钥解密
byte[] bDecode = DHCoder.decrypt(bCode, aPublicKey, bPrivateKey);
String bOutput = (new String(bDecode));

System.err.println("解密: " + bOutput);

assertEquals(bInput, bOutput);
}

}


控制台输出:
Console代码
甲方公钥:  
MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz  
W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG  
kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAdAWBVmIzqcko  
Ej6qFjLDL2+Y3FPq1iRbnOyOpDj71yKaK1K+FhTv04B0zy4DKcvAASV7/Gv0W+bgqdmffRkqrQ==  
 
甲方私钥:  
MIHRAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX  
rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD  
TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQyAjACJRfy1LyR  
eHyD+4Hfb+xR0uoIGR1oL9i9Nk6g2AAuaDPgEVWHn+QXID13yL/uDos=  
 
乙方公钥:  
MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz  
W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG  
kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAVEYSfBA+I9nr  
dWw3OBv475C+eBrWBBYqt0m6/eu4ptuDQHwV4MmUtKAC2wc2nNrdb1wmBhY1X8RnWkJ1XmdDbQ==  
 
乙方私钥:  
MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX  
rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD  
TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAqaZiCdXp  
2iNpdBlHRaO9ir70wo2n32xNlIzIX19VLSPCDdeUWkgRv4CEj/8k+/yd  
 
原文: abc   
解密: abc   
===============反过来加密解密==================   
原文: def   
解密: def  

甲方公钥:
MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz
W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG
kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAdAWBVmIzqcko
Ej6qFjLDL2+Y3FPq1iRbnOyOpDj71yKaK1K+FhTv04B0zy4DKcvAASV7/Gv0W+bgqdmffRkqrQ==

甲方私钥:
MIHRAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX
rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD
TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQyAjACJRfy1LyR
eHyD+4Hfb+xR0uoIGR1oL9i9Nk6g2AAuaDPgEVWHn+QXID13yL/uDos=

乙方公钥:
MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz
W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG
kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAVEYSfBA+I9nr
dWw3OBv475C+eBrWBBYqt0m6/eu4ptuDQHwV4MmUtKAC2wc2nNrdb1wmBhY1X8RnWkJ1XmdDbQ==

乙方私钥:
MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX
rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD
TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAqaZiCdXp
2iNpdBlHRaO9ir70wo2n32xNlIzIX19VLSPCDdeUWkgRv4CEj/8k+/yd

原文: abc
解密: abc
===============反过来加密解密==================
原文: def
解密: def


如我所言,甲乙双方在获得对方公钥后可以对发送给对方的数据加密,同时也能对接收到的数据解密,达到了数据安全通信的目的!
分享到:
评论

相关推荐

    JAVA 加密算法(很好的算法,经典摘要)

    Java加密算法是信息安全领域中的重要组成部分,用于保护数据的隐私性和完整性。在Java平台上,有多种内置的加密库,如Java Cryptography Extension (JCE) 和 Java Cryptography Architecture (JCA),它们为开发者...

    Java加密算法(源代码)

    Java加密算法是信息安全领域的重要组成部分,它涉及到数据的保护、隐私的维护以及网络通信的安全。在Java中,我们可以使用多种加密技术来实现数据的加密和解密,包括对称加密、非对称加密以及数字签名等。下面将详细...

    Java加密算法学习笔记的源码包

    Java加密算法是信息安全领域的重要组成部分,它在保护数据隐私、验证数据完整性和确认发送者身份等方面发挥着关键作用。这个名为"Java加密算法学习笔记的源码包"的压缩文件包含了关于Java中几种主要加密算法的实践...

    java加密算法实现

    在Java编程语言中,加密算法是信息安全领域的重要组成部分,用于保护数据的隐私和安全。本文将详细介绍Java中常见的加密算法的实现,以及如何在JDK 1.8环境下进行操作。 1. **对称加密算法** 对称加密是最基础的...

    java 加密算法及原理.jar

    Java加密算法及原理是信息安全领域中的重要组成部分,用于保护数据的隐私性和完整性。在Java中,我们可以使用多种加密算法来实现数据的安全传输和存储。以下将详细介绍几种常见的Java加密算法及其工作原理。 1. **...

    java加密算法源码

    Java加密算法源码是开发人员在进行数据安全处理时常用的一种工具,涵盖了多种常见的加密算法,包括AES(高级加密标准)、DES(数据加密标准)、MD5(消息摘要算法5)、RSA(公钥加密技术)以及SHA(安全散列算法)。...

    java加密算法分析

    加密加密算法调研以及 加密算法 代码实现,其中包括rsa、des、hash等算法

    基于Java实现的同态加密算法的实现

    在"research_encrypt-code"这个压缩包中,很可能包含了Java实现同态加密算法的源代码,包括密钥管理、加密、解密和操作加密数据的函数。通过研究这些代码,我们可以深入了解如何在实际应用中利用Java来构建安全的...

    JAVA加密算法

    ### JAVA加密算法详解 #### 一、概述 在信息技术领域,加密技术是保障信息安全的关键手段之一。本篇文章将深入探讨JAVA平台上的加密算法实现,并重点介绍单钥密码体制及其应用场景。 #### 二、单钥密码体制...

    java加密算法及常用知识学习杂记

    Java加密算法是信息安全领域的重要组成部分,它用于保护数据的隐私性和完整性。在Java中,有多种加密算法可供选择,如AES、DES和RSA,每种都有其特定的应用场景和优势。下面将详细介绍这些算法以及相关的学习要点。 ...

    java常用几种加密算法

    本文将详细介绍几种常用的Java加密算法及其应用实例,包括MD5、SHA及RSA。 #### 1. MD5加密 **简介**:MD5(Message-Digest Algorithm 5)是一种广泛使用的散列函数,能够将任意长度的数据转换成一个固定长度...

    java c++互通的加密算法

    本主题探讨的是如何在 Java 和 C++ 中实现相同的加密算法,以便在这两个环境中可以无缝地交换加密数据。这里我们将专注于一种常见的加密标准——AES(高级加密标准),它在3个文件中被实现。 AES,全称为Advanced ...

    java加密算法:Base64加密\数字签名\对称加密算法\非对称加密算法\消息摘要算法

    java关于加密的算法demo代码(Base64加密\数字签名\对称加密算法\非对称加密算法\消息摘要算法) JAVA安全实现三种方式: 1.JDK 2.Commons Codec 3.Bouncy Castle 一。非对称加密算法: 1.DH 2.RSA 3.ELGamal 二。...

    java 加密算法的代码实现

    Java加密算法是信息安全领域的重要组成部分,它用于保护数据的隐私和完整性。在Java中,有多种加密技术可供选择,如消息摘要、对称加密、非对称加密以及数字签名。以下将详细介绍这些加密方法。 首先,消息摘要算法...

    java 凯撒加密算法

    Java 凯撒加密算法 Java 凯撒加密算法是一种基于凯撒密码的加密算法,它在 Java 环境下实现了凯撒密码的加密过程。下面是该算法的详细介绍: 凯撒密码流程图 凯撒密码流程图是指凯撒密码的加密过程的图形表示。该...

    JAVA上加密算法的实现用例.rar_java 加密_加密_加密算法 java

    四、Java加密算法实现步骤 1. 导入相关类库:如`javax.crypto.Cipher`、`java.security.KeyPairGenerator`等。 2. 选择加密算法:如AES、RSA等。 3. 初始化Cipher对象:根据加密模式(ECB、CBC等)和填充模式...

    java自定义加密算法

    ### Java自定义加密算法知识点详解 #### 一、概述 在信息安全领域,数据加密是保护数据安全的重要手段之一。本文将详细介绍一个Java实现的自定义加密算法案例,该算法通过组合数字、小写字母、大写字母以及特殊...

    基于JAVA实现的加密算法【课程设计】

    为了实现这些加密算法,你需要对Java编程有扎实的基础,理解字符编码、字符串操作,以及如何使用Java的IO流进行数据处理。同时,对于RSA,还需要了解数论基础,特别是关于大整数的运算。在物联网安全背景下,这些...

Global site tag (gtag.js) - Google Analytics