密码学【java】初探究加密方式之非对称加密

我会带着你远行 2024-03-22 03:12 90阅读 0赞

#### 文章目录 ####

*  非对称加密
 *   *  1 常见算法
     *  2 生成公钥和私钥
     *  3 私钥加密
     *  4 私钥加密 公钥解密
     *  5 公钥和私钥的保存和读取
     *   *  5.1 \*\*保存公钥和私钥\*\*
         *  5.2 读取公钥和私钥

## 非对称加密 ##

1.  非对称加密算法又称现代加密算法。非对称加密是计算机通信安全的基石，保证了加密数据不会被破解。
2.  与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥(publickey) 和私有密(privatekey)
3.  公开密钥和私有密钥是一对。如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密。如果用私有密钥对数据进行加密，只有用对应的公开密钥才能解密。
4.  因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。

--------------------

*  特点
    
     *  加密和解密使用不同的密钥
     *  如果使用私钥加密, 只能使用公钥解密
     *  如果使用公钥加密, 只能使用私钥解密
     *  处理数据的速度较慢, 因为安全级别高

--------------------

*  示例
    
    1.  首先生成密钥对, 公钥为(5,14), 私钥为(11,14)，A希望将原文2发送给B
    2.  A使用公钥加密数据. 2的5次方mod 14 = 4 , 将密文4发送给B
    3.  B使用私钥解密数据. 4的11次方mod14 = 2, 得到原文2

--------------------

### 1 常见算法 ###

*  RSA
    
     *  RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。
     *  **RSA公开密钥密码体制是一种使用不同的加密密钥与解密密钥。**
     *  RSA能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密标准。只有短的RSA钥匙才可能被强力方式解破。世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长，用RSA加密的信息实际上是不能被解破的。
     *  **RSA算法基于一个十分简单的数论事实：将两个大质数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。**
     *  [RSA在线工具][RSA]
     *  希望深入学习RSA的小伙伴，请移步[公开密钥加密之RSA算法][RSA 1]
 *  ECC（Elliptic curve cryptography）
    
     *  椭圆曲线密码学（ECC），一种建立公开密钥加密的演算法，基于椭圆曲线数学。椭圆曲线在密码学中的使用是在1985年由Neal Koblitz和Victor Miller分别独立提出的。
     *  希望深入学习ECC的小伙伴，请移步[ECC椭圆曲线加解密原理详解(配图)][ECC]

### 2 生成公钥和私钥 ###

public static void main(String[] args) throws NoSuchAlgorithmException {
        
            // 加密算法
            String algorithm = "RSA";
            //  创建密钥对生成器对象
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
            // 生成密钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 生成私钥
            PrivateKey privateKey = keyPair.getPrivate();
            // 生成公钥
            PublicKey publicKey = keyPair.getPublic();
            // 获取私钥字节数组
            byte[] privateKeyEncoded = privateKey.getEncoded();
            // 获取公钥字节数组
            byte[] publicKeyEncoded = publicKey.getEncoded();
            // 对公私钥进行base64编码
            String privateKeyString = Base64.encodeBase64String(privateKeyEncoded);
            String publicKeyString = Base64.encodeBase64String(publicKeyEncoded);
            // 打印私钥
            System.out.println("私钥:"+privateKeyString);
            // 打印公钥
            System.out.println("共钥:"+publicKeyString);
        }

私钥:MIIG/QIBADANBgkqhkiG9w0BAQEFAASCBucwggbjAgEAAoIBgQC6hpkMQs+D0XefTNESooz3Cauz8Tpl7NaHKm3X8ZrqLO/QfCqW2ZoozlkXFi7nzNwPQ
    BfEv1VgXhiT5VOy+r24Lcc3oakNtSWXYuBoXraJXdpE7EqVKdPSZbxzT3OhSQ0QqX3F2Y19euz5RB8jD9GBEJ+VHTnBKIpugX4irCWj1TYKbB8XGbH85wcWG
    4uH2kn41DqM8IPw9TTDpMoyW7BEHShulOS+7G1Nd7rrtaf0tCyk9bVdms9Ou+JzKWRfCQFxuEH1sWvijW4R83OQYfpGa2kvJgiUQP0O9TQCmp0+ImWiThWfY
    biqrFyJVynIDko8mFXXWolmdfq1myuNg126sUe1wPmZhtIC595hp965K8bwTiSg8weuSXOkAXJ7Cr4OLCOimSrB4qdLueqjAhMcQWuHXbGZCqnrbtOFmzxxR
    NH8TWjhyPvtXldf7bK0CQaSuE2kfAi7YKwBwzI8iAbVomYh7EdVvMHq/YlwEPg8DqcuAJODaqcnZsy7omKuZWcCAwEAAQKCAYAIQ96URIGdfbKnRGgfQ0Srz
    anmF1JXId9/rcmgP/x1U/hsbJQWix3hoQMhmsIJU3KM2nIzLadC1eiQ5SCIVcQCXUTumiM7kENSKfd3qHq+K4J4e1/yrB/OuuNW2LZu9yW1D02bbsBuRvwpL
    3ORwimuZmYr3Vepz3oS23oTXz1rvQ7f91qJU4InirUtrZrJMksE06KkjCPMkZD8+lhbUuTEn+YiwEZCj4doX13RBAOlPDaeOKUIuMtm2bx3DeZ8r5Flbhas9
    n3/OELgIgJ6omKaipgHdWTVkaowbCZcJsUUoKyjQNHRZ4ae/0ie1I4IvhS9hml+8gcuPOu+kVpNyYvmUZZQoPFv9QaVyL16OSgGR80/7k4/JB3a7SldbEKqY
    Gasij3B8Agq0oXOY2oV5srs/wsum+HxzdKEFhAd+7YIYtxx82LzNes8NUg32NxaNMvoO2OqmSDqZo1Mu5lQBYWo/pPKJPxoT2oq2+9hAVgimvaUm1PoUEu2W
    /H6lOOKdQECgcEA0QtPgKtJc0LCxLInXBl286tspYPSbToGuBJe7/IVQjWlCEs0quX8xUcFeRAUSIDPGtKHfgVQoLd6XuizXvPYwHaJdgc/mqPyoyMhYwPQy
    Kr3njwDNLbI0jZTZVnz1iGEujYFbOCAsZraJLqgSeofxQHJNwy1v+DJj+6pn1k4rLjNrrRPgn8JdpCV9RttZ0xIZWpxYUO6z+wYvWLd8MXaGBT0UQcMK0Wh2
    hCT5XVOJ0RjucQ0dsq+xnQz6eSnpmDRAoHBAORsaKrfFfE1U9Foj39Qg5gcJUKh1UYwl6dt3utrETSKnP5g7t0XlqYcB4nTs7V+MA8ooAlUroXpWIm62v2PX
    ugda4qLtEZAF4uNcUX9a8kGfj4Cxqw0DCrLhN2KkoLKGdyyNoZQGqZCGqXU70G+UBkDrGTZwBt55GurhISZHBb7BJWL+Q4cPnEdwxSwDJxT1E0aCN6na+8HS
    laiFp8UL7Ewox5nHzHizsOEYx9ZRZb8Owd2J7hUzEm0ga0rNRgwtwKBwQDFgco755oeLJWZAjnt6qFY2D5uo33NdWWjxLeuPSuYwtaKX4QDdAi+27twBqEjX
    5BN51vc1Wi4cKJNyc6vh/Ti4xw9R9vwX7aALFD/HDvHXMFX35un0osrEej5eWPIjSK6TRATLoppQ8WXrjyDmZEqseVK/dc600edlgDtbX7+shyjU/lLcnuea
    j1EuAVF8+zy5P76xuNaT9eQGDlZo5XL6wBrDh2RRNkHD2KtCYgt0Y/nlFl9Y1Gcb24dLsy3hgECgcBUX/cJpv3j617aq1TWIld5iGv7AOxW0PwzzFHbg+EHF
    2yGSifxYxUypofiUWDAWaxG7SqwR6dvr5IUzgC2SI82Dif7NT+R83q/AbAlukZmKw/WuA/K7C7SX/rkGpuj1CNZcjrRwiUV5LUTLGR0VGgh1UmItyZO/+dwH
    hsFH8lQc8httRZ6L9Sg0+2LZrxBwnVZRZShKhakZH0BIz5X5Iz5Vo3qXQ0Y0D6v2ecDXWZnLyRezTY+0JPlZdfAr4UdOmECgcAYsuA5t2keukkeAR7qDZYsy
    stVIEsXujmevjPTlMHJxRySa5jpWzTeCqQS4zKpnu0ayogTCyUSYgGTYsYPYigAhr67dcQHzy95d9wF0bv0B9BYZmTYoHC4ThrElX1DPkYFU1JJjPS+BhNID
    GTK+vH4wZFFWHm8Fyhmgvexo4A6/yxAZWykDwBKG9NUDN/AoqUfJFcmRCD616Bt4FoNlzk7mfLg92W61pywvHQ+uxCuFWqwFVfUUInLJ6pfPvdm7u0=
    
    共钥:MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAuoaZDELPg9F3n0zREqKM9wmrs/E6ZezWhypt1/Ga6izv0HwqltmaKM5ZFxYu58zcD0AXxL9VY
    F4Yk+VTsvq9uC3HN6GpDbUll2LgaF62iV3aROxKlSnT0mW8c09zoUkNEKl9xdmNfXrs+UQfIw/RgRCflR05wSiKboF+Iqwlo9U2CmwfFxmx/OcHFhuLh9pJ+
    NQ6jPCD8PU0w6TKMluwRB0obpTkvuxtTXe667Wn9LQspPW1XZrPTrvicylkXwkBcbhB9bFr4o1uEfNzkGH6RmtpLyYIlED9DvU0ApqdPiJlok4Vn2G4qqxci
    VcpyA5KPJhV11qJZnX6tZsrjYNdurFHtcD5mYbSAufeYafeuSvG8E4koPMHrklzpAFyewq+DiwjopkqweKnS7nqowITHEFrh12xmQqp627ThZs8cUTR/E1o4
    cj77V5XX+2ytAkGkrhNpHwIu2CsAcMyPIgG1aJmIexHVbzB6v2JcBD4PA6nLgCTg2qnJ2bMu6JirmVnAgMBAAE=

### 3 私钥加密 ###

public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
        
            String input = "国泰民安";
            // 加密算法
            String algorithm = "RSA";
            //  创建密钥对生成器对象
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
            // 生成密钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 生成私钥
            PrivateKey privateKey = keyPair.getPrivate();
            // 生成公钥
            PublicKey publicKey = keyPair.getPublic();
    
            // 创建加密对象
            // 参数表示加密算法
            Cipher cipher = Cipher.getInstance(algorithm);
            // 初始化加密
            // 第一个参数:加密的模式
            // 第二个参数：使用私钥进行加密
            cipher.init(Cipher.ENCRYPT_MODE,privateKey);
            // 私钥加密
            byte[] bytes = cipher.doFinal(input.getBytes());
            System.out.println(Base64.encodeBase64String(bytes));
        }

gjfiD1F+DOFk2IHqrTWSKe+8qGLCihNuu+RrZY6CKji0H56RUhSL3P5fW2X3FXpCrY+CMsGg16HfmR3boeX1qY4e0NJU0JtE1Ch4uERigH1eM/MUCUaFaVI4
    9roDAcqbz0v+lnsX41mOCQ4YSd742XoIg7cJX1GcsHhkXDF3JCM/fDxdHYR63ApmSpzr+qfoelntnc+Xah90i3UR/PPiEZ6/6JWz7mU5DK/X5IVnqgGObNCl
    syH7tWcwl34IcrszFvK4ovtxeYVQken7IHgW8LMCxWGXWyDThC+9A/d9AV9vlLLuzZcYEvRYMS5BzZqr9gzdrgYE1hsRouFQ0yyuOUoVAbaqAjqhPRTTIj0E
    QUl2PpB7hi561x/j/58w9dsoI3gKp/G6SBl40yyuxbm5z/RGYxjeZhyIC4Lm/ddpCQpJ5qzZ/WX6N9fSqjwQLaHSQpgmsy5zdZRkZchxknw8LgONSzObwA5/
    F561oXgtHWD44+SzZHoOGY3hDSU3oKMT

### 4 私钥加密 公钥解密 ###

*  私钥加密，只能公钥解密

public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
        
            String input = "国泰民安";
            System.out.println(input);
            // 加密算法
            String algorithm = "RSA";
            //  创建密钥对生成器对象
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
            // 生成密钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 生成私钥
            PrivateKey privateKey = keyPair.getPrivate();
            // 生成公钥
            PublicKey publicKey = keyPair.getPublic();
    
            // 创建加密对象
            // 参数表示加密算法
            Cipher cipher = Cipher.getInstance(algorithm);
            // 初始化加密
            // 第一个参数:加密的模式
            // 第二个参数：使用私钥进行加密
            cipher.init(Cipher.ENCRYPT_MODE,privateKey);
            // 私钥加密
            byte[] bytes = cipher.doFinal(input.getBytes());
            System.out.println(Base64.encodeBase64String(bytes));
    
            // 私钥进行解密
            cipher.init(Cipher.DECRYPT_MODE,publicKey);
            // 对密文进行解密，不需要使用base64，因为原文不会乱码
            byte[] bytes1 = cipher.doFinal(bytes);
            System.out.println(new String(bytes1));
        }

国泰民安
    VfUXV9TiXxeRx5/gq13GtsNm76BSw/63e1SaOI1szLnb9DjE4hfCmim0qqqOQYSp5fyE45694Dlj37p7/+eu7gMAuJN5PYZfN7bYQZ+ZIJeXCiEO/IWXFzQW
    yIgoyqUjZ1i6ja0yfHhY0FXkBBJCr2SNwBiMW1lEQav0UE/i05Dj3+OOKDTKNbIgMLcsZfM3WPSNJWJq7bthnjO0KTPSdG5Dl+/eJictaSGTk0it5+D1l4G6
    N8CfTfshG9c3vWbfmqgmU8GaA5Iqo1eHINPpS9SZOoAAokGEzmDkx2VJQiQO3GELIdcCGvyWvZIm7PlAV8EYzxTQiHRSuwiCJyGGABC+I9iEFwDaZwYCTAh7
    roSwtpt1ax/KgQfbhv8vNE+/3ADnnvFgzDX6LfWuSl0vhclh9kl0ECnIICJd6dxKwCAZkctiwdOoPrbGnK4lWXbeTbdkxBpdw9LcnWMkCuCVy53k47OjB3S+
    t+Uktr2snJAjJDYG4ZZmrQpEIj17zLKZ
    国泰民安

### 5 公钥和私钥的保存和读取 ###

#### 5.1 **保存公钥和私钥** ####

public static void main(String[] args) throws Exception {
        
            String input = "硅谷";
            // 加密算法
            String algorithm = "RSA";
    
            //生成密钥对并保存在本地文件中
            generateKeyToFile(algorithm, "a.pub", "a.pri");
    
    
        }
    
        /**
         * 生成密钥对并保存在本地文件中
         *
         * @param algorithm : 算法
         * @param pubPath   : 公钥保存路径
         * @param priPath   : 私钥保存路径
         * @throws Exception
         */
        private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
        
            // 获取密钥对生成器
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
            // 获取密钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 获取公钥
            PublicKey publicKey = keyPair.getPublic();
            // 获取私钥
            PrivateKey privateKey = keyPair.getPrivate();
            // 获取byte数组
            byte[] publicKeyEncoded = publicKey.getEncoded();
            byte[] privateKeyEncoded = privateKey.getEncoded();
            // 进行Base64编码
            String publicKeyString = Base64.encodeBase64String(publicKeyEncoded);
            String privateKeyString = Base64.encodeBase64String(privateKeyEncoded);
            // 保存文件
            FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
            FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));
    
        }

--------------------

#### 5.2 读取公钥和私钥 ####

public static void main(String[] args) throws Exception {
        
            String input = "明德新民，止于至善";
            // 加密算法
            String algorithm = "RSA";
    
            //生成密钥对并保存在本地文件中
            generateKeyToFile(algorithm, "a.pub", "a.pri");
            //读取私钥
            PrivateKey privateKey = getPrivateKey("a.pri", algorithm);
            //读取公钥
            PublicKey publicKey = getPublicKey("a.pub", algorithm);
    
            String s = encryptRSA(algorithm, privateKey, input);
            String res = decryptRSA(algorithm, publicKey, s);
            System.out.println(res);
        }
    
        /**
         * 解密数据
         *
         * @param algorithm      : 算法
         * @param encrypted      : 密文
         * @param key            : 密钥
         * @return : 原文
         */
        public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
        
            // 创建加密对象
            // 参数表示加密算法
            Cipher cipher = Cipher.getInstance(algorithm);
            // 私钥进行解密
            cipher.init(Cipher.DECRYPT_MODE,key);
            // 由于密文进行了Base64编码, 在这里需要进行解码
            byte[] decode = Base64.decodeBase64(encrypted);
            // 对密文进行解密，不需要使用base64，因为原文不会乱码
            byte[] bytes1 = cipher.doFinal(decode);
            return new String(bytes1);
    
        }
        /**
         * 使用密钥加密数据
         *
         * @param algorithm      : 算法
         * @param input          : 原文
         * @param key            : 密钥
         * @return : 密文
         */
        public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
        
            // 创建加密对象
            // 参数表示加密算法
            Cipher cipher = Cipher.getInstance(algorithm);
            // 初始化加密
            // 第一个参数:加密的模式
            // 第二个参数：使用私钥进行加密
            cipher.init(Cipher.ENCRYPT_MODE,key);
            // 私钥加密
            byte[] bytes = cipher.doFinal(input.getBytes());
            // 对密文进行Base64编码
            return Base64.encodeBase64String(bytes);
        }
    
        public static PublicKey getPublicKey(String pulickPath,String algorithm) throws Exception{
        
            // 将文件内容转为字符串
            String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());
            // 获取密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
            // 构建密钥规范 进行Base64解码
            X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyString));
            // 生成公钥
            return keyFactory.generatePublic(spec);
        }
    
        /**
         * 生成密钥对并保存在本地文件中
         *
         * @param algorithm : 算法
         * @param pubPath   : 公钥保存路径
         * @param priPath   : 私钥保存路径
         * @throws Exception
         */
        private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
        
            // 获取密钥对生成器
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
            // 获取密钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 获取公钥
            PublicKey publicKey = keyPair.getPublic();
            // 获取私钥
            PrivateKey privateKey = keyPair.getPrivate();
            // 获取byte数组
            byte[] publicKeyEncoded = publicKey.getEncoded();
            byte[] privateKeyEncoded = privateKey.getEncoded();
            // 进行Base64编码
            String publicKeyString = Base64.encodeBase64String(publicKeyEncoded);
            String privateKeyString = Base64.encodeBase64String(privateKeyEncoded);
            // 保存文件
            FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
            FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));
    
        }
    
        public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
        
            // 将文件内容转为字符串
            String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
            // 获取密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
            // 构建密钥规范 进行Base64解码
            PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyString));
            // 生成私钥
            return keyFactory.generatePrivate(spec);
        }

![在这里插入图片描述][a6ababf8cfe94c35b52ef90adc624910.png]

[RSA]: https://try8.cn/tool/cipher/rsa
[RSA 1]: https://blog.csdn.net/m0_51607907/article/details/123884953
[ECC]: https://blog.csdn.net/sitebus/article/details/82835492
[a6ababf8cfe94c35b52ef90adc624910.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/f3fd8e9ac6934ca2a95be6459412c4a2.png