Java加密技术（四）非对称加密算法RSA

RSA

这样的算法1978年就出现了。它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作。也非常流行。算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman。

这样的加密算法的特点主要是密钥的变化，上文我们看到DES仅仅有一个密钥。相当于仅仅有一把钥匙。假设这把钥匙丢了，数据也就不安全了。RSA同一时候有两把钥匙，公钥与私钥。

同一时候支持数字签名。

数字签名的意义在于。对传输过来的数据进行校验。确保数据在传输project中不被改动。

流程分析：

甲方构建密钥对儿，将公钥发布给乙方，将私钥保留。
甲方使用私钥加密数据，然后用私钥对加密后的数据签名，发送给乙方签名以及加密后的数据。乙方使用公钥、签名来验证待解密数据是否有效，假设有效使用公钥对数据解密。
乙方使用公钥加密数据，向甲方发送经过加密后的数据。甲方获得加密数据，通过私钥解密。

按如上步骤给出序列图，例如以下：

通过java代码实现例如以下：

package com.somnus.cipher;

import java.io.InputStream;

import java.security.Key;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.Signature;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Map;

import javax.crypto.Cipher;

import org.apache.commons.codec.binary.Base64;

import org.apache.commons.codec.binary.Hex;

/** 非对称加密算法RSA

 * @Title: RsaEncrypt.java

 * @Description: TODO

 * @author Somnus

 * @date 2015年6月5日 下午2:02:44

 * @version V1.0

 */

public class RSAUtil {

    public static final String ALGORITHM = "RSA";

    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";  

    private static final String PUBLIC_KEY = "RSAPublicKey";

    private static final String PRIVATE_KEY = "RSAPrivateKey";  

    private static final String PUBLIC_KEY_PATH = "public.cer";

    private static final String PRIVATE_KEY_PATH = "private.key";

    /**

     * 用私钥对信息生成数字签名

     *

     * @param data

     *            加密数据

     * @param privateKey

     *            私钥

     * @return

     * @throws Exception

     */

    public static String sign(String data) throws Exception {

        // 解密由base64编码的私钥

        byte[] keyBytes = Base64.decodeBase64(getPrivateKey());

        // 构造PKCS8EncodedKeySpec对象

        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

        // ALGORITHM 指定的加密算法

        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);

        // 取私钥匙对象

        PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);

        // 用私钥对信息生成数字签名

        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

        signature.initSign(priKey);

        signature.update(Hex.decodeHex(data.toCharArray()));

        return Base64.encodeBase64String(signature.sign());

    }  

    /**

     * 校验数字签名

     *

     * @param data

     *            加密数据

     * @param publicKey

     *            公钥

     * @param sign

     *            数字签名

     *

     * @return 校验成功返回true 失败返回false

     * @throws Exception

     *

     */

    public static boolean verify(String data,String sign)throws Exception {

        // 解密由base64编码的公钥

        byte[] keyBytes = Base64.decodeBase64(getPublicKey());

        // 构造X509EncodedKeySpec对象

        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

        // ALGORITHM 指定的加密算法

        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);

        // 取公钥匙对象

        PublicKey pubKey = keyFactory.generatePublic(keySpec);

        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

        signature.initVerify(pubKey);

        signature.update(Hex.decodeHex(data.toCharArray()));

        // 验证签名是否正常

        return signature.verify(Base64.decodeBase64(sign));

    }  

    /**

     * 解密<br>

     * 用私钥解密

     *

     * @param data

     * @return

     * @throws Exception

     */

    public static String decryptByPrivateKey(String data)throws Exception {

        // 对密钥解密

        byte[] keyBytes = Base64.decodeBase64(getPrivateKey());

        // 取得私钥

        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);

        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

        //初始化Cipher对象，设置为解密模式

        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        // 运行解密操作

        byte[] buff = cipher.doFinal(Hex.decodeHex(data.toCharArray()));

        System.out.println(Arrays.toString(buff));

        return new String(buff);

    }  

    /**

     * 解密<br>

     * 用公钥解密

     *

     * @param data

     * @return

     * @throws Exception

     */

    public static String decryptByPublicKey(String data)throws Exception {

        // 对密钥解密

        byte[] keyBytes = Base64.decodeBase64(getPublicKey());

        // 取得公钥

        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);

        Key publicKey = keyFactory.generatePublic(x509KeySpec);

        //初始化Cipher对象，设置为解密模式

        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        cipher.init(Cipher.DECRYPT_MODE, publicKey);

        // 运行解密操作

        byte[] buff = cipher.doFinal(Hex.decodeHex(data.toCharArray()));

        System.out.println(Arrays.toString(buff));

        return new String(buff);

    }  

    /**

     * 加密<br>

     * 用公钥加密

     *

     * @param data

     * @return

     * @throws Exception

     */

    public static String encryptByPublicKey(String data)throws Exception {

        // 对公钥解密

        byte[] keyBytes = Base64.decodeBase64(getPublicKey());

        // 取得公钥

        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);

        Key publicKey = keyFactory.generatePublic(x509KeySpec);

        // 实例化Cipher对象，它用于完毕实际的加密操作

        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        byte[] buff = cipher.doFinal(data.getBytes());

        System.out.println(Arrays.toString(buff));

        // 运行加密操作。

加密后的结果通常都会用Base64编码进行传输

        return Hex.encodeHexString(buff);

    }  

    /**

     * 加密<br>

     * 用私钥加密

     *

     * @param data

     * @return

     * @throws Exception

     */

    public static String encryptByPrivateKey(String data) throws Exception {

        // 对密钥解密

        byte[] keyBytes = Base64.decodeBase64(getPrivateKey());

        // 取得私钥

        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);

        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

        // 对数据加密

        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        cipher.init(Cipher.ENCRYPT_MODE, privateKey);

        byte[] buff = cipher.doFinal(data.getBytes());

        System.out.println(Arrays.toString(buff));

        // 运行加密操作。

加密后的结果通常都会用Base64编码进行传输

        return Hex.encodeHexString(buff);

    }  

    /**

     * 取得私钥

     *

     * @param keyMap

     * @return

     * @throws Exception

     */

    public static String getPrivateKey()throws Exception{

        Key key = (Key)initKey().get(PRIVATE_KEY);

        return Base64.encodeBase64String(key.getEncoded());

    }  

    /**

     * 取得公钥

     *

     * @param keyMap

     * @return

     * @throws Exception

     */

    public static String getPublicKey()throws Exception {

        Key key = (Key) initKey().get(PUBLIC_KEY);

        return Base64.encodeBase64String(key.getEncoded());

    }  

    /**

     * 初始化密钥

     *

     * @return

     * @throws Exception

     * @throws Exception

     */

    public static Map<String, Object> initKey() throws Exception{

        InputStream in1 = RSAUtil.class.getClassLoader().getResourceAsStream(PUBLIC_KEY_PATH);

        InputStream in2 = RSAUtil.class.getClassLoader().getResourceAsStream(PRIVATE_KEY_PATH);

        try {

            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);

            /*生成公钥*/

            byte[] encodedpubkey = new byte[in1.available()];

            in1.read(encodedpubkey);

            X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(encodedpubkey);

            PublicKey publicKey = keyFactory.generatePublic(pubKeySpec);

            /*生成私钥*/

            byte[] encodedprikey = new byte[in2.available()];

            in2.read(encodedprikey);

            PKCS8EncodedKeySpec priKeySpec = new PKCS8EncodedKeySpec(encodedprikey);

            PrivateKey privateKey = keyFactory.generatePrivate(priKeySpec);

            /*封装进map*/

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

            keyMap.put(PUBLIC_KEY, publicKey);

            keyMap.put(PRIVATE_KEY, privateKey);

            return keyMap;

        } catch(Exception e){

            e.printStackTrace();

            throw e;

        } finally {

            in1.close();

            in2.close();

        }

    }

    /**

     * 初始化密钥 2

     * @return

     * @throws Exception

     */

    public static Map<String, Object> initKey2() throws Exception {

        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(ALGORITHM);

        keyPairGen.initialize(1024);

        KeyPair keyPair = keyPairGen.generateKeyPair();

        // 公钥

        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

        // 私钥

        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

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

        keyMap.put(PUBLIC_KEY, publicKey);

        keyMap.put(PRIVATE_KEY, privateKey);

        return keyMap;

    }  

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

        String publicKey = getPublicKey();

        String privateKey = getPrivateKey();

        System.out.println("公钥:\r" + publicKey);

        System.out.println("私钥:\r" + privateKey); 

        System.out.println("公钥加密————————————————————私钥解密");

        String data = "Somnus";

        System.out.println("原文: " + data);

        String encryptData = encryptByPublicKey(data);

        System.out.println("加密后: " + encryptData);

        String decryptData = decryptByPrivateKey(encryptData);

        System.out.println("解密后: " + decryptData);

        System.out.println("私钥加密————————————————————公钥解密");

        System.out.println("原文: " + data);

        String encryptData2 = encryptByPrivateKey(data);

        System.out.println("加密后: " + encryptData2);

        String decryptData2 = decryptByPublicKey(encryptData2);

        System.out.println("解密后: " + decryptData2);

        System.out.println("私钥签名——公钥验证签名");

        // 产生签名

        String sign = sign(encryptData2);

        System.out.println("签名:\r" + sign);

        // 验证签名

        boolean status = verify(encryptData2,sign);

        System.out.println("状态:" + status);

    }

}

控制台输出：

公钥加密————————————————————私钥解密

原文: Somnus

[82, 112, 47, -49, -44, 28, 117, 87, -32, -5, -116, 56, -60, 87, -1, -36, 89, 84, -9, 17, -66, 64, -115, -114, 72, -86, 79, 63, -15, -35, -14, 40, -50, 16, -105, 73, 80, 7, -48, 75, -114, -64, 80, 74, 6, -74, 24, -59, -59, 31, 121, -63, 45, 93, 20, 25, -116, 51, -74, -40, 22, 55, -31, -106]

加密后: 52702fcfd41c7557e0fb8c38c457ffdc5954f711be408d8e48aa4f3ff1ddf228ce1097495007d04b8ec0504a06b618c5c51f79c12d5d14198c33b6d81637e196

[83, 111, 109, 110, 117, 115]

解密后: Somnus

私钥加密————————————————————公钥解密

原文: Somnus

[69, -38, -21, -84, -56, -1, 50, -33, -46, 11, 124, 37, -106, 53, 67, 81, -9, 39, -15, -89, 59, -49, 102, 71, 89, -7, 22, 42, 49, -29, 28, 114, -36, -1, -123, -7, 124, -104, -38, 83, 12, 76, 61, -117, 118, -54, 99, 99, 47, -118, 28, -119, 83, -5, 124, 122, -3, 109, 45, -38, -31, 98, 99, -107]

加密后: 45daebacc8ff32dfd20b7c2596354351f727f1a73bcf664759f9162a31e31c72dcff85f97c98da530c4c3d8b76ca63632f8a1c8953fb7c7afd6d2ddae1626395

[83, 111, 109, 110, 117, 115]

解密后: Somnus

私钥签名——公钥验证签名

签名:

GfLuZt88KdtRoTL7nJoeoRYGW0Lqu9eV4o9J8OVzH9jbHHGa/ZZDlCAjqS1jwkMYaXrut+W2a8v867mZDvQJtw==

状态:true

简要总结一下，使用公钥加密、私钥解密，完毕了乙方到甲方的一次数据传递，通过私钥加密、公钥解密，同一时候通过私钥签名、公钥验证签名。完毕了一次甲方到乙方的数据传递与验证，两次数据传递完毕一整套的数据交互！

类似数字签名。数字信封是这样描写叙述的：

数字信封

　　数字信封用加密技术来保证仅仅有特定的收信人才干阅读信的内容。

流程：

信息发送方採用对称密钥来加密信息。然后再用接收方的公钥来加密此对称密钥（这部分称为数字信封）。再将它和信息一起发送给接收方。接收方先用对应的私钥打开数字信封，得到对称密钥，然后使用对称密钥再解开信息。

Java加密技术（四）非对称加密算法RSA的更多相关文章

Java进阶(七)Java加密技术之非对称加密算法RSA
Java加密技术(四)--非对称加密算法RSA 非对称加密算法--RSA 基本概念非对称加密算法是一种密钥的保密方法. 非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(priv ...
Java加密技术（一）——BASE64与单向加密算法MD5&SHA&MAC
Java加密技术(一)——BASE64与单向加密算法MD5&SHA&MAC 博客分类: Java/Security Javabase64macmd5sha 加密解密,曾经是我一 ...
JAVA 非对称加密算法RSA
非对称加密算法 RSA过程 : 以甲乙双方为例 1.初始化密钥构建密钥对,生成公钥.私钥保存到keymap中 KeyPairGenerator ---> KeyPair --> RSAP ...
Java加密技术
相关链接: Java加密技术(一)——BASE64与单向加密算法MD5&SHA&MAC Java加密技术(二)——对称加密DES&AES Java加密技术(三)——PBE算法 ...
Java加密技术（八）——数字证书
原文:http://snowolf.iteye.com/blog/391931 请大家在阅读本篇内容时先阅读 Java加密技术(四),预先了解RSA加密算法. 在构建Java代码实现前,我们需要完成证 ...
非对称加密算法-RSA算法
一.概述 1.RSA是基于大数因子分解难题.目前各种主流计算机语言都支持RSA算法的实现 2.java6支持RSA算法 3.RSA算法可以用于数据加密和数字签名 4.RSA算法相对于DES/AES等对 ...
如何综合运用对称加密技术、非对称加密技术（公钥密码体制）和Hash函数保证信息的保密性、完整性、可用性和不可否认性？
一.几个问题在提出问题之前,先创建一个使用场景,发送方(甲方)要给接收方(乙方)发送投标书.大家知道,投标书都包括发送方的标的,这个标的是不能被竞标者知晓,更不能被竞标者修改的.在传输的投标书时,提 ...
非对称加密算法——RSA
RSA 这种算法1978年就出现了,它是第一个既能用于数据加密也能用于数字签名的算法.它易于理解和操作,也很流行.算法的名字以发明者的名字命名:Ron Rivest, AdiShamir 和L ...
非对称加密算法RSA使用注意事项
原文:非对称加密算法RSA使用注意事项第一个问题,也是最重要的一个——RSA无法对超过117字节的数据进行加密!切记!其实也勿需要求对更大数据的加密,虽然网上已经有相关解决方案,比如BigInteg ...

随机推荐

firefox配置
Firefox23取消了一个很人性化的功能,就是在GUI界面中禁用JavaScript,对于这点我很不能理解!JavaScript是所有网页木马的源头,防人之心不可无,FireFox就这么确信能防住 ...
Oracle配置客户端
一.引言当我们需要连接远程的Oracle数据库服务器时,就需要在自己的机器上安装Oracle客户端了. 二.安装步骤与配置参考:http://blog.csdn.net/luiseradl/art ...
JSON学习【转自慕课网】
视频网址从慕课网视频里的PPT截图过来的,因为是用PHP讲的,而且后面讲的一般,所以只截取了前两节课的基础内容,其实只看一下第一张PPT就可以了.
TCP/IP各层协议数据格式
ISO规范里定义了7层网络模型,实际常用的仍为TCPIP四层网络模型. 注:本文章插图均来自<图解TCP/IP>. 数据链路层帧格式经常说的帧格式为以太网帧格式,由于类型和帧长度字段不重 ...
Tuning 14 Using Oracle Data Storage Structures Efficiently
90% 是Heap table Cluster 集群表, index-organized table: 就是把索引和表和二为一了. partitioned table:表非常大, 逻辑上是一个大表, ...
CNN图像分割总结
深度学习(三十三)CRF as RNN语义分割-未完待续 http://blog.csdn.net/hjimce/article/details/50888915 Fully Convolutiona ...
第二百二十三节，jQuery EasyUI，ComboBox(下拉列表框)组件
jQuery EasyUI,ComboBox(下拉列表框)组件,可以远程加载数据的下拉列表组件学习要点: 1.加载方式 2.属性列表 3.事件列表 4.方法列表本节课重点了解 EasyUI 中 C ...
解决java.lang.ClassNotFoundException: com.microsoft.sqlserver.jdbc.SQLServerDriver问题
今天在做项目的时候突然遇到解决java.lang.ClassNotFoundException: com.microsoft.sqlserver.jdbc.SQLServerDriver问题,知道是j ...
使用StringTokenizer分解字符串
Java切割字符串.一般使用substring.split.StringTokenizer来处理,前两种是String对象的方法,使用字符串能够直接处理,本文介绍下StringTokenizer的使用 ...
win7(64位)+vs2008配置Directshow
参考链接:http://zhuyanfeng.com/archives/1663 PC环境:win7 64bit + vs2008 1.下载64位的win7 SDK2.安装过程中遇到错误(必须要卸载v ...

Java加密技术（四）非对称加密算法RSA

Java加密技术（四）非对称加密算法RSA的更多相关文章

随机推荐

热门专题