`
crazier9527
  • 浏览: 1015224 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Java加密技术（五）

    博客分类：
  • Java
Java算法Securityjunit网络协议 
阅读更多

   接下来我们分析DH加密算法，一种适基于密钥一致协议的加密算法。
DH
Diffie-Hellman算法(D-H算法)，密钥一致协议。是由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。简单的说就是允许两名用户在公开媒体上交换信息以生成"一致"的、可以共享的密钥。换句话说，就是由甲方产出一对密钥（公钥、私钥），乙方依照甲方公钥产生乙方密钥对（公钥、私钥）。以此为基线，作为数据传输保密基础，同时双方使用同一种对称加密算法构建本地密钥（SecretKey）对数据加密。这样，在互通了本地密钥（SecretKey）算法后，甲乙双方公开自己的公钥，使用对方的公钥和刚才产生的私钥加密数据，同时可以使用对方的公钥和自己的私钥对数据解密。不单单是甲乙双方两方，可以扩展为多方共享数据通讯，这样就完成了网络交互数据的安全通讯！该算法源于中国的同余定理——中国馀数定理。 

流程分析：

1.甲方构建密钥对儿，将公钥公布给乙方，将私钥保留；双方约定数据加密算法；乙方通过甲方公钥构建密钥对儿，将公钥公布给甲方，将私钥保留。
2.甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给乙方加密后的数据；乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。
3.乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给甲方加密后的数据；甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。


通过java代码实现如下：Coder类见 Java加密技术（一）

Java代码 复制代码
  1. import java.security.Key;   
  2. import java.security.KeyFactory;   
  3. import java.security.KeyPair;   
  4. import java.security.KeyPairGenerator;   
  5. import java.security.PublicKey;   
  6. import java.security.spec.PKCS8EncodedKeySpec;   
  7. import java.security.spec.X509EncodedKeySpec;   
  8. import java.util.HashMap;   
  9. import java.util.Map;   
  10.   
  11. import javax.crypto.Cipher;   
  12. import javax.crypto.KeyAgreement;   
  13. import javax.crypto.SecretKey;   
  14. import javax.crypto.interfaces.DHPrivateKey;   
  15. import javax.crypto.interfaces.DHPublicKey;   
  16. import javax.crypto.spec.DHParameterSpec;   
  17.   
  18. /**  
  19.  * DH安全编码组件  
  20.  *   
  21.  * @author 梁栋  
  22.  * @version 1.0  
  23.  * @since 1.0  
  24.  */  
  25. public abstract class DHCoder extends Coder {   
  26.     public static final String ALGORITHM = "DH";   
  27.   
  28.     /**  
  29.      * 默认密钥字节数  
  30.      *   
  31.      * <pre>  
  32.      * DH  
  33.      * Default Keysize 1024    
  34.      * Keysize must be a multiple of 64, ranging from 512 to 1024 (inclusive).  
  35.      * </pre>  
  36.      */  
  37.     private static final int KEY_SIZE = 1024;   
  38.   
  39.     /**  
  40.      * DH加密下需要一种对称加密算法对数据加密，这里我们使用DES，也可以使用其他对称加密算法。  
  41.      */  
  42.     public static final String SECRET_ALGORITHM = "DES";   
  43.     private static final String PUBLIC_KEY = "DHPublicKey";   
  44.     private static final String PRIVATE_KEY = "DHPrivateKey";   
  45.   
  46.     /**  
  47.      * 初始化甲方密钥  
  48.      *   
  49.      * @return  
  50.      * @throws Exception  
  51.      */  
  52.     public static Map<String, Object> initKey() throws Exception {   
  53.         KeyPairGenerator keyPairGenerator = KeyPairGenerator   
  54.                 .getInstance(ALGORITHM);   
  55.         keyPairGenerator.initialize(KEY_SIZE);   
  56.   
  57.         KeyPair keyPair = keyPairGenerator.generateKeyPair();   
  58.   
  59.         // 甲方公钥   
  60.         DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();   
  61.   
  62.         // 甲方私钥   
  63.         DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();   
  64.   
  65.         Map<String, Object> keyMap = new HashMap<String, Object>(2);   
  66.   
  67.         keyMap.put(PUBLIC_KEY, publicKey);   
  68.         keyMap.put(PRIVATE_KEY, privateKey);   
  69.         return keyMap;   
  70.     }   
  71.   
  72.     /**  
  73.      * 初始化乙方密钥  
  74.      *   
  75.      * @param key  
  76.      *            甲方公钥  
  77.      * @return  
  78.      * @throws Exception  
  79.      */  
  80.     public static Map<String, Object> initKey(String key) throws Exception {   
  81.         // 解析甲方公钥   
  82.         byte[] keyBytes = decryptBASE64(key);   
  83.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);   
  84.         KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);   
  85.         PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);   
  86.   
  87.         // 由甲方公钥构建乙方密钥   
  88.         DHParameterSpec dhParamSpec = ((DHPublicKey) pubKey).getParams();   
  89.   
  90.         KeyPairGenerator keyPairGenerator = KeyPairGenerator   
  91.                 .getInstance(keyFactory.getAlgorithm());   
  92.         keyPairGenerator.initialize(dhParamSpec);   
  93.   
  94.         KeyPair keyPair = keyPairGenerator.generateKeyPair();   
  95.   
  96.         // 乙方公钥   
  97.         DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();   
  98.   
  99.         // 乙方私钥   
  100.         DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();   
  101.   
  102.         Map<String, Object> keyMap = new HashMap<String, Object>(2);   
  103.   
  104.         keyMap.put(PUBLIC_KEY, publicKey);   
  105.         keyMap.put(PRIVATE_KEY, privateKey);   
  106.   
  107.         return keyMap;   
  108.     }   
  109.   
  110.     /**  
  111.      * 加密<br>  
  112.      *   
  113.      * @param data  
  114.      *            待加密数据  
  115.      * @param publicKey  
  116.      *            甲方公钥  
  117.      * @param privateKey  
  118.      *            乙方私钥  
  119.      * @return  
  120.      * @throws Exception  
  121.      */  
  122.     public static byte[] encrypt(byte[] data, String publicKey,   
  123.             String privateKey) throws Exception {   
  124.   
  125.         // 生成本地密钥   
  126.         SecretKey secretKey = getSecretKey(publicKey, privateKey);   
  127.   
  128.         // 数据加密   
  129.         Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());   
  130.         cipher.init(Cipher.ENCRYPT_MODE, secretKey);   
  131.   
  132.         return cipher.doFinal(data);   
  133.     }   
  134.   
  135.     /**  
  136.      * 解密<br>  
  137.      *   
  138.      * @param data  
  139.      *            待解密数据  
  140.      * @param publicKey  
  141.      *            乙方公钥  
  142.      * @param privateKey  
  143.      *            乙方私钥  
  144.      * @return  
  145.      * @throws Exception  
  146.      */  
  147.     public static byte[] decrypt(byte[] data, String publicKey,   
  148.             String privateKey) throws Exception {   
  149.   
  150.         // 生成本地密钥   
  151.         SecretKey secretKey = getSecretKey(publicKey, privateKey);   
  152.         // 数据解密   
  153.         Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());   
  154.         cipher.init(Cipher.DECRYPT_MODE, secretKey);   
  155.   
  156.         return cipher.doFinal(data);   
  157.     }   
  158.   
  159.     /**  
  160.      * 构建密钥  
  161.      *   
  162.      * @param publicKey  
  163.      *            公钥  
  164.      * @param privateKey  
  165.      *            私钥  
  166.      * @return  
  167.      * @throws Exception  
  168.      */  
  169.     private static SecretKey getSecretKey(String publicKey, String privateKey)   
  170.             throws Exception {   
  171.         // 初始化公钥   
  172.         byte[] pubKeyBytes = decryptBASE64(publicKey);   
  173.   
  174.         KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);   
  175.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKeyBytes);   
  176.         PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);   
  177.   
  178.         // 初始化私钥   
  179.         byte[] priKeyBytes = decryptBASE64(privateKey);   
  180.   
  181.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKeyBytes);   
  182.         Key priKey = keyFactory.generatePrivate(pkcs8KeySpec);   
  183.   
  184.         KeyAgreement keyAgree = KeyAgreement.getInstance(keyFactory   
  185.                 .getAlgorithm());   
  186.         keyAgree.init(priKey);   
  187.         keyAgree.doPhase(pubKey, true);   
  188.   
  189.         // 生成本地密钥   
  190.         SecretKey secretKey = keyAgree.generateSecret(SECRET_ALGORITHM);   
  191.   
  192.         return secretKey;   
  193.     }   
  194.   
  195.     /**  
  196.      * 取得私钥  
  197.      *   
  198.      * @param keyMap  
  199.      * @return  
  200.      * @throws Exception  
  201.      */  
  202.     public static String getPrivateKey(Map<String, Object> keyMap)   
  203.             throws Exception {   
  204.         Key key = (Key) keyMap.get(PRIVATE_KEY);   
  205.   
  206.         return encryptBASE64(key.getEncoded());   
  207.     }   
  208.   
  209.     /**  
  210.      * 取得公钥  
  211.      *   
  212.      * @param keyMap  
  213.      * @return  
  214.      * @throws Exception  
  215.      */  
  216.     public static String getPublicKey(Map<String, Object> keyMap)   
  217.             throws Exception {   
  218.         Key key = (Key) keyMap.get(PUBLIC_KEY);   
  219.   
  220.         return encryptBASE64(key.getEncoded());   
  221.     }   
  222. }  
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";

	/**
	 * 默认密钥字节数
	 * 
	 * <pre>
	 * DH
	 * Default Keysize 1024  
	 * Keysize must be a multiple of 64, ranging from 512 to 1024 (inclusive).
	 * </pre>
	 */
	private static final int KEY_SIZE = 1024;

	/**
	 * 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(KEY_SIZE);

		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(keyFactory.getAlgorithm());
		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 {

		// 生成本地密钥
		SecretKey secretKey = getSecretKey(publicKey, privateKey);

		// 数据加密
		Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());
		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 {

		// 生成本地密钥
		SecretKey secretKey = getSecretKey(publicKey, privateKey);
		// 数据解密
		Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, secretKey);

		return cipher.doFinal(data);
	}

	/**
	 * 构建密钥
	 * 
	 * @param publicKey
	 *            公钥
	 * @param privateKey
	 *            私钥
	 * @return
	 * @throws Exception
	 */
	private static SecretKey getSecretKey(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(keyFactory
				.getAlgorithm());
		keyAgree.init(priKey);
		keyAgree.doPhase(pubKey, true);

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

		return secretKey;
	}

	/**
	 * 取得私钥
	 * 
	 * @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代码 复制代码
  1. import static org.junit.Assert.*;   
  2.   
  3. import java.util.Map;   
  4.   
  5. import org.junit.Test;   
  6.   
  7. /**  
  8.  *   
  9.  * @author 梁栋  
  10.  * @version 1.0  
  11.  * @since 1.0  
  12.  */  
  13. public class DHCoderTest {   
  14.   
  15.     @Test  
  16.     public void test() throws Exception {   
  17.         // 生成甲方密钥对儿   
  18.         Map<String, Object> aKeyMap = DHCoder.initKey();   
  19.         String aPublicKey = DHCoder.getPublicKey(aKeyMap);   
  20.         String aPrivateKey = DHCoder.getPrivateKey(aKeyMap);   
  21.   
  22.         System.err.println("甲方公钥:\r" + aPublicKey);   
  23.         System.err.println("甲方私钥:\r" + aPrivateKey);   
  24.            
  25.         // 由甲方公钥产生本地密钥对儿   
  26.         Map<String, Object> bKeyMap = DHCoder.initKey(aPublicKey);   
  27.         String bPublicKey = DHCoder.getPublicKey(bKeyMap);   
  28.         String bPrivateKey = DHCoder.getPrivateKey(bKeyMap);   
  29.            
  30.         System.err.println("乙方公钥:\r" + bPublicKey);   
  31.         System.err.println("乙方私钥:\r" + bPrivateKey);   
  32.            
  33.         String aInput = "abc ";   
  34.         System.err.println("原文: " + aInput);   
  35.   
  36.         // 由甲方公钥，乙方私钥构建密文   
  37.         byte[] aCode = DHCoder.encrypt(aInput.getBytes(), aPublicKey,   
  38.                 bPrivateKey);   
  39.   
  40.         // 由乙方公钥，甲方私钥解密   
  41.         byte[] aDecode = DHCoder.decrypt(aCode, bPublicKey, aPrivateKey);   
  42.         String aOutput = (new String(aDecode));   
  43.   
  44.         System.err.println("解密: " + aOutput);   
  45.   
  46.         assertEquals(aInput, aOutput);   
  47.   
  48.         System.err.println(" ===============反过来加密解密================== ");   
  49.         String bInput = "def ";   
  50.         System.err.println("原文: " + bInput);   
  51.   
  52.         // 由乙方公钥，甲方私钥构建密文   
  53.         byte[] bCode = DHCoder.encrypt(bInput.getBytes(), bPublicKey,   
  54.                 aPrivateKey);   
  55.   
  56.         // 由甲方公钥，乙方私钥解密   
  57.         byte[] bDecode = DHCoder.decrypt(bCode, aPublicKey, bPrivateKey);   
  58.         String bOutput = (new String(bDecode));   
  59.   
  60.         System.err.println("解密: " + bOutput);   
  61.   
  62.         assertEquals(bInput, bOutput);   
  63.     }   
  64.   
  65. }  
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代码 复制代码
  1. 甲方公钥:   
  2. MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz   
  3. W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG   
  4. kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAdAWBVmIzqcko   
  5. Ej6qFjLDL2+Y3FPq1iRbnOyOpDj71yKaK1K+FhTv04B0zy4DKcvAASV7/Gv0W+bgqdmffRkqrQ==   
  6.   
  7. 甲方私钥:   
  8. MIHRAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX   
  9. rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD   
  10. TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQyAjACJRfy1LyR   
  11. eHyD+4Hfb+xR0uoIGR1oL9i9Nk6g2AAuaDPgEVWHn+QXID13yL/uDos=   
  12.   
  13. 乙方公钥:   
  14. MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz   
  15. W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG   
  16. kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAVEYSfBA+I9nr   
  17. dWw3OBv475C+eBrWBBYqt0m6/eu4ptuDQHwV4MmUtKAC2wc2nNrdb1wmBhY1X8RnWkJ1XmdDbQ==   
  18.   
  19. 乙方私钥:   
  20. MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX   
  21. rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD   
  22. TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAqaZiCdXp   
  23. 2iNpdBlHRaO9ir70wo2n32xNlIzIX19VLSPCDdeUWkgRv4CEj/8k+/yd   
  24.   
  25. 原文: abc    
  26. 解密: abc    
  27.  ===============反过来加密解密==================    
  28. 原文: def    
  29. 解密: 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作为一种广泛应用的编程语言，在处理数据加密方面提供了多种工具和技术。本文将深入探讨Java中常用的加密技术，包括...

    Java加密技术

    Java加密技术

    java加密技术详解

    ### Java加密技术详解：以MD5为例 在Java中，加密技术是确保数据安全和完整性的关键工具之一。本文将深入探讨Java中的加密技术，特别是MD5加密算法，通过实例和代码片段，帮助读者理解其工作原理及如何在实际项目中...

    基于JAVA的加密算法（包括10种加密技术）

    Java加密技术（一） 关键字: java 加密基础, base64, md5, mac, sha, 单向加密 。。。。。。。。。。。。。。

    java加密技术大全

    Java加密技术是保护数据安全的重要工具，广泛应用于网络通信、数据存储、数字签名等领域。本资源包涵盖了Java中常见的加密算法和技术，包括基础的哈希算法、对称加密、非对称加密以及证书签名和SSL/TLS协议。下面将...

    java加密技术 （网页版）

    Java加密技术是软件开发中一个重要的安全领域，主要用于保护数据的隐私性和完整性。在这个网页版的资源中，可能涵盖了各种加密算法的Java实现，以及它们之间的比较。让我们深入探讨一下这些知识点。 首先，我们来看...

    运用加密技术保护java源代码

    因此，运用加密技术保护Java源代码成为了一项重要的课题。 ### Java源代码加密的重要性 Java源代码加密主要涉及两个层面：一是源代码本身的安全，二是编译后的字节码（.class文件）的安全。对于源代码，加密可以...

    JAVA加密技术.docx

    在Java编程中，加密技术是确保信息安全的关键组成部分。本文将探讨几种常见的加密算法，包括单向加密和对称及非对称加密算法。首先，我们来看基础的单向加密算法，如BASE64、MD5、SHA和HMAC。 **BASE64** 是一种...

    java加密技术研究

    java加密技术研究

    Java加密技术(一)

    总之，Java加密技术提供了丰富的工具和算法，可以帮助开发者构建安全的应用程序。然而，随着技术的发展，加密算法的安全性也需要不断更新，以抵御新的攻击手段。在设计系统时，应考虑最新的安全标准和最佳实践，确保...

    java加密技术

    Java加密技术是Java编程语言中用于保障数据安全的一系列加密方法和技术，它包括了单向加密算法、对称加密算法、非对称加密算法以及加密算法的高级应用如数字签名和数字证书等。本文将详细介绍这些加密技术，并结合...

    Java加密技术(四)

    总结来说，Java加密技术第四部分主要介绍了ECC加密技术的概念、其在Java中的有限支持，以及如何通过Java代码实现ECC的加密和解密操作。尽管Java的标准实现并不直接支持ECC的加密/解密，但可以通过扩展和利用非公开...

    Java加密技术全集

    Java加密技术是信息安全领域的重要组成部分，它用于保护数据的隐私性和完整性。在这个“Java加密技术全集”中，我们将会探讨MD5、SHA和BASE64等常见的加密算法及其在Java中的实现。 MD5（Message-Digest Algorithm ...

    Java加密技术(三)

    Java加密技术(三),相当有用的加密技术(三)，值得学习参考！希望对你有点帮助！

    Java加密技术 pdf版

    Java加密技术 pdf版 加密解密，曾经是我一个毕业设计的重要组件。在工作了多年以后回想当时那个加密、解密算法，实在是太单纯了。 言归正传，这里我们主要描述Java已经实现的一些加密解密算法，最后介绍数字证书

    Java加密技术（技巧与实例） pdf.rar

    Java加密技术是软件开发中一个至关重要的领域，特别是在保护数据安全、验证信息完整性和实现安全通信方面。本书“Java加密技术（技巧与实例）”深入浅出地探讨了这一主题，为开发者提供了丰富的实践指导。以下是一些...

    Java加密技术MD5/BASE64等加密技术

    Java加密技术是软件开发中的重要组成部分，特别是在保护数据安全、用户隐私以及确保网络通信的完整性方面。本资源主要关注两种常见的加密算法：MD5（Message-Digest Algorithm 5）和BASE64编码，它们在Java中有着...

    java加密狗读取例子

    Java加密狗读取例子主要涉及的是在Java编程环境中与硬件加密设备进行交互的技术。加密狗是一种硬件安全模块，用于保护软件免受非法复制和逆向工程。在这个特定的例子中，我们关注的是ET199型号的加密狗，它通常被...

    snowolf-Java 加密技术

    Java加密技术是软件开发中一个至关重要的领域，主要用于保护数据的安全性和隐私，防止未经授权的访问或篡改。本文将深入探讨Java中常见的加密技术，包括基础的单向加密算法、对称加密、非对称加密以及数字证书等相关...

Magicbox
Global site tag (gtag.js) - Google Analytics