Java加密算法

Java
374
0
0
2023-07-22
浅析Java反射
上一篇
10种流行的Java框架
下一篇

1.基础知识

密码学：主要是研究 编制密码 和 破译密码 的学科

密码学的主要目的：简单的直接说就是，研究如何隐藏信息并且把信息传递出去的一个学科。

1.1密码学的历史

1.1.1古典密码学

古代就开始使用密码，目的：就是希望保护信息。

核心原理：替换法，移位法

①替换法：

就是使用固定的信息，将原文替换成密文。

例如：bee，将b替换成w，e替换成p，单词就变成了wpp。

替换法的加密方式： 单表替换 、 多表替换

  • 单表替换：原文和密文使用的是同一张表
  • 例如：abcde ——> swtrp
  • 多表替换：表示有多张表，原文和密文进行对比
  • 表单1：abcde-swtrp、表单2：abcde-chfhk、表单3：abcde-jftou
  • 原文：bee
  • 密钥：312
  • 密文：fpk

②移位法：

移位法是按照字母，在字母表上面的位置，进行移动

凯撒加密

1.1.2近代密码学

1.1.3现代密码学

  • 散列函数

MD5，SHA-1，SHA-256，SHA-512

  • 对称加密加密方式和解密方式，使用的是同一把密钥

DES加密和解密，AES加密和解密

对称加密的核心原理：流加密，块加密

toString()和new String()核心原理和区别

加密模式：ECB CBC

填充模式：NoPadding和PKCS5padding

  • 非对称加密有两把密钥，使用公钥加密，必须使用私钥解密，或者，私钥加密，必须使用公钥解密

非对称加密的特点

RSA算法和ECC算法

数字摘要

base64核心加密原则，和base64原理

数字签名和数字证书

keytool工具的使用

1.2 ASCII编码

JAVA代码例子

maven依赖

首先导入一下commons-io的maven依赖 

 <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>.11.0</version>
</dependency>

JavaDemo

charDemo

 package com.red.javacodeaudit.encode;

public class AsciiDemo {
    public static void main(String[] args) {
        char a = 'A';
        int b = a;
        //打印出来A字母的ascii编码的大小
        System.out.println(b);
    }
}

可以看到就是A->65，这里直接对char和int类型进行转换。

StringDemo

 public class AsciiDemo {
    public static void main(String[] args) {
        String str = "rebeyond";
        char[] chars = str.toCharArray();
        for (char aChar : chars) {
            int i = aChar;
            System.out.println(i);
        }
    }
}

其实平时我们基本不会总是用到char来定义字符，更多的都是用到String来定义字符串，这里利用了toCharArray方法来返回一个char[]数组，然后转化成ascii形式

凯撒加密

CaesarDemo

 public static void main(String[] args) {
        String input = "Hello World";
        int key =;
        char[] chars = input.toCharArray();
        StringBuilder sb = new StringBuilder();
        for (char aChar : chars) {
            int b = aChar;
            b = b + key;
            char newchar = (char) b;
            sb.append(newchar);
        }
        System.out.println(sb.toString());
}

我们知道凯撒加密就是简单的移位法，然后这里key设置成3，强调一个知识点就是StringBuilder这个类，我们将char数组想要转换成String类型的字符串的时候是需要这个类的append方法来实现的。这里就是加密之后的数据Khoor#Zruog

凯撒解密

知道这里需要传入一个密文，和一个解密的key，参数就是这两个，然后返回的是一个String类型的明文 

 private static String decryptCaesar(String newStr, int key) {
        char[] chars = newStr.toCharArray();
        StringBuilder sb = new StringBuilder();
        for (char aChar : chars) {
            int i = aChar;
            i -= key;
            char newChar = (char) i;
            sb.append(newChar);
        }
        return sb.toString();
}

完整Demo代码

 package com.red.javacodeaudit.encode;

public class CaesarDemo {
    public static void main(String[] args) {
        String input = "Hello World";
        int key =;
        String newStr = encryptCaesar(input, key);
        System.out.println("密文===>"+newStr);
        String str = decryptCaesar(newStr,key);
        System.out.println("明文===>"+str);
    }

    private static String decryptCaesar(String newStr, int key) {
        char[] chars = newStr.toCharArray();
        StringBuilder sb = new StringBuilder();
        for (char aChar : chars) {
            int i = aChar;
            i -= key;
            char newChar = (char) i;
            sb.append(newChar);
        }
        return sb.toString();
    }

    private static String encryptCaesar(String input, int key) {
        char[] chars = input.toCharArray();
        StringBuilder sb = new StringBuilder();
        for (char aChar : chars) {
            int b = aChar;
            b = b + key;
            char newchar = (char) b;
            //            System.out.print(newchar);
            sb.append(newchar);
        }
        return sb.toString();
    }
}

1.3 频率分析法

目的：在不知道密钥的情况下，也想破解秘文

我认为这里我应该自己写出来这个工具类，来完善一下自己的java开发水平

原理 ：字母e，出现的频率是最高的，第二高的是t，然后就是a

这里代码我就放到github上了这里就不具体演示了，知道怎么做就好.

Github链接，第一次写这种项目，写的非常的乱

1.4 byte和bit的关系

byte：就是所谓的 字节 ，数据存储的基本单位，比如移动硬盘1T，单位事byte

bit： 比特 ，又叫做 位 ，一位要么是0要么是1。数据传输的单位，比如家里的宽带是100MB，下载速度并没有达到100MB，一般都是12-13MB，那是因为需要100/8的速度来看。

1byte = 8bit

代码示例

 public static void main(String[] args) {
        String str = "a";
        byte[] bytes = str.getBytes();
        for (byte aByte : bytes) {
            int c = aByte;
            System.out.println(c);
        }
}

这里输出的结果就是97，对应a的ascii编码。

之后我看查看一下97的bit形式,Integer类下有一个toBinaryString()方法，可以将字节转化成比特，然后返回一个字符串

String s = Integer.toBinaryString(c);得到结果1100001.

1.5 中文英文对应的字节

这里代码先写出来，然后显示一下红的字节编码 

 package com.red.javacodeaudit.encode.ByteBit;

public class bytebit {
    public static void main(String[] args) {
        String str = "a";
        String str = "红";

        ByteToBit(str);
    }

    public static void ByteToBit(String str){
        byte[] bytes = str.getBytes();
        for (byte aByte : bytes) {
            System.out.println(aByte);
            String s = Integer.toBinaryString(aByte);
            System.out.println(s);
        }
    }
}

可以看到这里是一个中文汉字是3个字节，因为这里是UTF-8编码，如果是UTF-8一个中文对应的是三个字节

Java加密算法

这里修改一下代码byte[] bytes = str.getBytes(“GBK”);设置成GBK编码之后，就会变成两个字节，如果是GBK一个中文对应的是两个字节

Java加密算法

如果是英文，就没有编码的概念了，全部对应的是一个字节

2.对称加密

  • 采用单密钥系统的加密方法，同一个密钥可以同时加密和解密，也成单密钥加密。
  • 常见加密算法DESAES
  • 特点加密速度快，可以加密大文件密文可逆，一旦密钥文件泄露，就会导致数据暴露加密后编码表找不到对应字符，出现乱码一般结合Base64使用

2.1 DES

2.1.1 Cipher加密对象

根据java官方API的描述：该类提供加密和解密的加密密码的功能。 它构成了Java加密扩展（JCE）框架的核心。

为了创建一个Cipher对象，应用程序调用Cipher的getInstance方法，并将所请求的转换的名称传递给它。 可选地，可以指定提供者的名称。

转换是描述要在给定输入上执行的操作（或操作集）的字符串，以产生一些输出。 转换总是包括加密算法的名称（例如， DES），并且可以跟随有反馈模式和填充方案。

转换形式如下：

  • “ 算法/模式/填充”或
  • “ 算法”

（在后一种情况下，使用模式和填充方案的提供者特定的默认值）。 例如，以下是有效的转换： 

 Cipher c = Cipher.getInstance("DES/CBC/PKCSPadding");

我们新建一个Cipher的时候需要调用getInstance函数，里边的参数是“算法/模式/填充”或者仅仅是“算法”。

2.1.2 DES代码示例

加密一段数据，首先需要原文和密钥 

 public class DesDemo {
    public static void main(String[] args) throws NoSuchPaddingException, NoSuchAlgorithmException {
        String data = "小红爱JAVA";
        String key = "";
        String transformation = "DES";//这里是加密算法
      	String algoritm = "DES";//这里是加密规则，跟加密算法是有区别的，但是这里先理解成是一个东西
        Cipher cipher = Cipher.getInstance(transformation);
    }
}

这里就得到了一个完整的cipher对象，之后需要对对象进行init，其中有两个参数

  • 行为模式—>ENCRYPT_MODE就是加密，因为cipher对象可以加密也可以解密，所以需要声明这个对象是用来加密的还是解密的
  • 加密规则—>SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algoritm)这里就是new一个加密规则。 
 String data = "小红爱JAVA";
String key = "";
String transformation = "DES";
String algoritm = "DES";
Cipher cipher = Cipher.getInstance(transformation);
SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algoritm);//new一个加密规则
cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec);

这里的init用到的就是这个构造方法

Java加密算法

我们可以看到SecretKeySpec是实现了SecretKey接口，SecretKey接口继承的Key类，所以本质上还是一个Key.

Java加密算法

现在有了一个加密的cipher对象之后，就要执行加密方法了就是doFinal()，需要传入原文的byte[]数组，也会返回一个byte[]数组。

加密后的代码是这个样子 

 public class DesDemo {
    public static void main(String[] args) throws Exception {
        String data = "小红爱JAVA";
        String key = "";
        String transformation = "DES";
        String algoritm = "DES";
        Cipher cipher = Cipher.getInstance(transformation);
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algoritm);
        cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec);
        byte[] bytes = cipher.doFinal(data.getBytes());
        System.out.println(new String(bytes));
    }
}

执行结果是乱码，因为ascii中找不到对应的字节编码

Java加密算法

之后使用base64继续编码一下 

 public static void main(String[] args) throws Exception {
        String data = "小红爱JAVA";
        String key = "";
        String transformation = "DES";
        String algoritm = "DES";
        Cipher cipher = Cipher.getInstance(transformation);
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algoritm);
        cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec);
        byte[] bytes = cipher.doFinal(data.getBytes());
        byte[] encode = Base.encodeBase64(bytes);
        System.out.println(new String(encode));
}

注意这里有一个坑是，使用DES加密的时候密钥key必须是8位数，其他位数会报错

加密解密完整代码

 package com.red.javacodeaudit.encode.DesAes;

import com.sun.org.apache.xml.internal.security.utils.Base;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.security.NoSuchAlgorithmException;

public class DesDemo {
    public static void main(String[] args) throws Exception {
        String data = "小红爱JAVA";
        String key = "";
        String transformation = "DES";
        String algoritm = "DES";
      	String encryptData = encryptDes(data,key,transformation,algoritm);
        System.out.println("加密后的数据："+encryptData);
        String finaldata = decryptDes(encryptData,key,transformation,algoritm);
        System.out.println("解密后的数据："+finaldata);
    }

    /**
     *
     * @param encryptData 密文
     * @param key
     * @param transformation
     * @param algoritm
     */

    private static String decryptDes(String encryptData, String key, String transformation, String algoritm) throws Exception{
        Cipher cipher = Cipher.getInstance(transformation);
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algoritm);
        cipher.init(Cipher.DECRYPT_MODE,secretKeySpec);
        byte[] bytes = cipher.doFinal(Base.decode(encryptData));
        return new String(bytes);
    }

    /**
     * 用DES算法加密文本
     * @param data
     * @param key
     * @param transformation
     * @param algoritm
     * @return
     * @throws Exception
     * @throws NoSuchAlgorithmException
     */
    private static String encryptDes(String data, String key, String transformation, String algoritm) throws Exception, NoSuchAlgorithmException {
        Cipher cipher = Cipher.getInstance(transformation);
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algoritm);
        cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec);
        byte[] bytes = cipher.doFinal(data.getBytes());
        String encode = Base.encode(bytes);
        return encode;
    }
}

Java加密算法

2.2 Base64

base64不是加密算法，是可读性算法。目的不是保护我们的数据，目的是为了 可读性

Base64 由64个字符组成，大写A-Z，小写a-z，数字0-9，两个符号 + 和 / 。其实还有=是填充字符

Base64 编码原理：Base64是3个字节为一组，一个字节是8位，一共就是24位，base64把三个字节，转换为4组，每组6位，一个字节，应该是8位，缺少2位，在高位进行补0，这样做的好处就是，base64取后面6位，前面的两位都是0，不进行计算，可以把base64控制在0-63之间。

Java加密算法

在base64中，需要设置一共是3个字节，为一组，如果在输出的时候，不够三个字节，就需要使用=进行补齐 

 public class BaseDemo {
    public static void main(String[] args) {
        //这里就一个字符,就需要填充两个等号
        System.out.println(Base.encode("1".getBytes()));
        System.out.println(Base.encode("12".getBytes()));
        System.out.println(Base.encode("123".getBytes()));
        System.out.println(Base.encode("嘿嘿".getBytes()));
    }
}

2.3 toString()和new String()

首先看一下代码示例 

 public class BaseDemo {
    public static void main(String[] args) throws Exception{
        String str = "SmFYUNvZGVBdWRpdA==";
        System.out.println("new String===>"+new String(Base.decode(str.getBytes())));
        System.out.println("toString=====>"+Base.decode(str.getBytes()).toString());
    }
}

结果如下，可以看到new String得到的结果是正确的，那么为什么会是new String得到正确的结果呢

Java加密算法

其实在调用toString的时候会调用的是Object的toString方法，调用的是hashcode()方法，得到的是一个哈希值

Java加密算法

new String方法：是根据参数，参数是一个字节数组，使用JVM虚拟机默认编码格式，会把这个字节数组进行decode，找到对应的字符，如果虚拟机的编码格式，如果是ISO-8859-1，会去找ascii里面的编码进行参照，找到对应的字符。

new String():一般在进行转码的时候，需要使用

toString():做对象打印的时候，或者想得到地址的时候，就使用toString().

2.4 AES

这里跟DES没有区别，就是将代码里的变量改成AES就可以，但是key注意要改成16位的，否则会报错。

2.5 加密模式

2.5.1 ECB（电子密码本）

ECB：把一段文本进行分拆加密，使用同一个key，分别进行加密，然后组合到一起

  • 优点：可以并行处理数据
  • 缺点：同样的原文生成同样的密文，不能很好的保护数据
  • 同时加密，原文是一样的，加密出来的密文也是一样的

2.5.2 CBC（密码块链接）

每个明文块先与前一个密文块进行异或后，再进行加密。在这种方法中，每个密文块都依赖于它前面的所有明文块。这里存在一个IV向量来加密原文

  • 优点：安全系数很高，同样的原文产生的密文是不同的
  • 缺点：串行处理数据，加密速度很慢

2.6 填充模式

当需要按照块处理的数据，数据长度不符合块处理需求时，按照一定的方法填充满块长的规则

2.6.1 NoPadding

  • 不填充
  • 在DES算法中，要求原文长度必须是8byte的整数倍
  • 在AES算法中，要求原文长度必须是16byte的整数倍

2.6.2 PKCS5Padding

数据块的大小为8位，不够就补齐

TIPS：

  • 如果没有设置加密模式和填充模式就默认使用ECB/PKCS5Padding模式

代码示例

这里看到单纯的使用DES加密的结果是OaaGdLrz6BRTP49DWl2Q6w==

Java加密算法

更换到DES/ECB/PKCS5Padding加密模式和填充模式的时候，密文还是没有变化，说明默认就是这个加密模式和填充模式

现在来看CBC加密模式，仅仅更换加密模式的话会产生错误，因为我们知道CBC加密是需要一个IV向量的。

new IvParameterSpec(key.getBytes());得到一个iv，参数就是key的字节数组，然后在cipher.init的时候加入iv，同样解密的方法里也需要一个iv 

 IvParameterSpec iv = new IvParameterSpec(key.getBytes());
cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec,iv);
 private static String encryptDes(String data, String key, String transformation, String algoritm) throws Exception, NoSuchAlgorithmException {
        Cipher cipher = Cipher.getInstance(transformation);
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algoritm);
        IvParameterSpec iv = new IvParameterSpec(key.getBytes());
        cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec,iv);
        byte[] bytes = cipher.doFinal(data.getBytes());
        String encode = Base.encode(bytes);
        return encode;
}

可以看到就不会报错了

3.消息摘要

  • 消息摘要又称数字摘要
  • 它是一个唯一对应一个消息或文本的固定长度的值，由一个单向的Hash加密函数对消息进行作用而产生
  • 使用数字摘要生成的值是不可篡改的， 为了保证文件或者值的安全性

消息摘要算法是不可逆的，常见的算法有 

 - MD
- SHA
- SHA
- SHA

使用的是MessageDigest，使用getInstace()方法传入参数algorithm表示加密类型 

 MessageDigest digest = MessageDigest.getInstance("SHA");

Java加密算法

得到一个digest对象之后就能调用其digest方法，该方法的参数就是原文的字节数组 

 public class digestDemo {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        String input = "java";
        String algorithm = "MD";
        MessageDigest digest = MessageDigest.getInstance(algorithm);
        byte[] bytes = digest.digest(input.getBytes());
        System.out.println(Base.encode(bytes));
    }
}

写一个直接生成MD5值的demo 

 public class digestDemo {
   public static void main(String[] args) throws NoSuchAlgorithmException {
       String input = "aa";
       String algorithm = "MD";
       MessageDigest digest = MessageDigest.getInstance(algorithm);
       byte[] mdcryptData = digest.digest(input.getBytes());
       StringBuilder sb = new StringBuilder();
       for (byte b : mdcryptData) {
           String s = Integer.toHexString(b &xff);//将加密的byte数组转换成16进制的代码，返回String字符串
           if(s.length()==){
               s = ""+s;//对单个的字符高位进行补0，否则会出现问题
           }
           sb.append(s);
       }
       System.out.println(sb.toString()); 
   }
}

完整案例

 package com.red.javacodeaudit.encrypt.digest;


import com.sun.org.apache.xerces.internal.impl.dv.util.HexBin;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class digestDemo {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        String input = "java";
        String algorithm = "MD";
        String digest = getDigest(input, algorithm);
        System.out.println(digest);
        String sha = getDigest(input, "SHA-1");
        System.out.println(sha);
        String sha = getDigest(input, "SHA-256");
        System.out.println(sha);
        String sha = getDigest(input, "SHA-512");
        System.out.println(sha);

    }
    private static String getDigest(String input,String algorithm) throws NoSuchAlgorithmException {
        MessageDigest digest = MessageDigest.getInstance(algorithm);
        byte[] cryptData = digest.digest(input.getBytes());
        String encode = HexBin.encode(cryptData);
        return encode;
    }
}

这里分别是各种加密算法加密出来的数据。

4.非对称加密

简介：

1.非对称加密，又叫现在加密算法

2.必须要有两个密钥，一个公钥，一个私钥

3.公钥和私钥是一对，我们叫做密钥对

4.如果使用公钥加密，必须使用私钥解密

5.如果使用私钥加密，必须使用公钥解密

常见的非对劲加密算法

  • RSA
  • ECC

4.1 RSA

4.1.1 获取公钥私钥

我们知道非对劲加密有一个密钥对，需要生成一对密钥，就先要拿到密钥对生成器，也就是KeyPairGenerator.

对于KeyPairGenerator，API中是这么说的：KeyPairGenerator类用于生成公钥和私钥对。 密钥对生成器使用getInstance工厂方法（返回给定类的实例的静态方法）构造。

通过getInstace(algorithm)方法生成一个密钥对生成器，这里algorithm是我们自己定义的RSA算法

KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);

得到了keyPairGenerator对象是生成器，来生成密钥对，调用keyPairGenerator.generateKeyPair();方法来获取到密钥对keyPair

然后得到密钥对之后，我们就可以调用getPrivate和getPublic方法来获取到 私钥 和 公钥 了，获取到的公钥和私钥有getEncoded()方法可以将其转换成byte[]数组之后进行Base64编码显示。 

 public static void main(String[] args) throws Exception{
        String algorithm = "RSA";
        //获取到密钥对
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();
        System.out.println(Base.encode(privateKey.getEncoded()));
        System.out.println(Base.encode(publicKey.getEncoded()));
}

4.1.2 使用私钥加密数据

Java中只要是想加密，就需要创建加密对象也就是Cipher对象，现在就需要先getInstance一个cipher.之后的步骤跟前面类似 

 Cipher cipher = Cipher.getInstance(algorithm);
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
byte[] bytes = cipher.doFinal(input.getBytes());
System.out.println(Base.encode(bytes));

这里就是最后得到的密文数据

4.1.3 使用公钥解密数据

非对称算法，私钥加密数据，必须使用公钥解密，否则会报错，有兴趣的朋友就自己动手试试了.

跟其他的解密一样，key设置为publicKey即可 

 cipher.init(Cipher.DECRYPT_MODE,publicKey);
byte[] bytes = cipher.doFinal(bytes);
System.out.println(new String(bytes));

4.1.4 保存公钥和私钥

我们一直生成公钥和私钥就很不方便，所以一般是将公钥和私钥给保存下来 

 package com.red.javacodeaudit.encrypt.RSA;


import com.sun.org.apache.xml.internal.security.utils.Base;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.security.*;

public class RSADemo {
    public static void main(String[] args) throws Exception{
        String input = "Red's Java";
        String algorithm = "RSA";
        String publicKeyFile = "a.pub";
        String privateKeyFile = "a.pri";
        generatorKeyFile(algorithm,publicKeyFile,privateKeyFile);

    }
    private static void generatorKeyFile(String algorithm,String pubFile,String priFile) throws NoSuchAlgorithmException, IOException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();
        String privatekeyString = Base.encode(privateKey.getEncoded());
        String publickeyString = Base.encode(publicKey.getEncoded());
      //这里commins-IO的包中的方法
        FileUtils.writeStringToFile(new File(pubFile),publickeyString, Charset.forName("UTF-"));
        FileUtils.writeStringToFile(new File(priFile),privatekeyString,Charset.forName("UTF-"));
    }
}

成功的生成了公钥和私钥文件

4.1.5 抽取出加密解密方法

这里就是把都在main方法中的代码，封装成独立的方法了，没有什么值得说的。 

 package com.red.javacodeaudit.encrypt.RSA;


import com.sun.org.apache.xml.internal.security.utils.Base;
import org.apache.commons.io.FileUtils;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.security.*;

public class RSADemo {
    public static void main(String[] args) throws Exception{
        String input = "Red's Java";
        String algorithm = "RSA";
        String publicKeyFile = "a.pub";
        String privateKeyFile = "a.pri";
        //        generatorKeyFile(algorithm,publicKeyFile,privateKeyFile);

        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();
        String s = encryptRSA(algorithm, privateKey, input);
        System.out.println(s);
        String s = decryptRSA(algorithm, publicKey, s);
        System.out.println(s);

    }

    /**
     *
     * @param algorithm     加密规则
     * @param publicKey     公钥
     * @param encrypted     密文
     * @return
     */
    private static String decryptRSA(String algorithm,Key publicKey,String encrypted) throws Exception{
        Cipher cipher = Cipher.getInstance(algorithm);
        cipher.init(,publicKey);
        byte[] decode = Base.decode(encrypted);
        byte[] bytes = cipher.doFinal(decode);
        return new String(bytes);
    }
    /**
     *
     * @param algorithm     加密规则
     * @param privateKey    私钥
     * @param input         原文
     * @return
     */
    private static String encryptRSA(String algorithm,Key privateKey,String input) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        Cipher cipher = Cipher.getInstance(algorithm);
        cipher.init(Cipher.ENCRYPT_MODE,privateKey);
        byte[] bytes = cipher.doFinal(input.getBytes());
        String encode = Base.encode(bytes);
        return encode;
    }
    private static void generatorKeyFile(String algorithm,String pubFile,String priFile) throws NoSuchAlgorithmException, IOException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();
        String privateKeyString = Base.encode(privateKey.getEncoded());
        String publicKeyString = Base.encode(publicKey.getEncoded());
        FileUtils.writeStringToFile(new File(pubFile),privateKeyString, Charset.forName("UTF-"));
        FileUtils.writeStringToFile(new File(priFile),publicKeyString,Charset.forName("UTF-"));
    }
}

4.1.6 读取公钥私钥

写一个方法，读取出来文件中的内容，给私钥编码的规则是PKCS8EncodedKeySpec，官方API的介绍。

Java加密算法

给公钥进行编码的规则是X509EncodedKeySpec，这里记住就好，下面是官方API的介绍 

 psvm(){
  String input = "Red's Java";
        String algorithm = "RSA";
        String publicKeyFile = "a.pub";
        String privateKeyFile = "a.pri";
        PrivateKey privateKey = getPrivateKey(privateKeyFile,algorithm);
  			PublicKey publicKey = getPublicKey(publicKeyFile,algorithm);
}
/**
     * 文件中读取私钥
     * @param privateKeyFile 私钥文件
     * @return
     * @throws IOException
     */
private static PrivateKey getPrivateKey(String privateKeyFile,String algorithm) throws IOException, NoSuchAlgorithmException, BaseDecodingException, InvalidKeySpecException {
        String privateKey = FileUtils.readFileToString(new File(privateKeyFile), Charset.defaultCharset());
  			//新建一个key工厂来生成key
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
  			//生成key的时候需要传入一个KeySpec规则，RSA私钥对应的就是PKCSEncodedKeySpec这个规则
        PKCSEncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
        return keyFactory.generatePrivate(keySpec);
}

 private static PublicKey getPublicKey(String publicKeyFile, String algorithm) throws Exception {
        String publicKeyString = FileUtils.readFileToString(new File(publicKeyFile), Charset.defaultCharset());
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        XEncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
}

4.2 数字签名

数字签名：公钥数字签名，只有信息的发送者，才能产生别人无法伪造的一段数字串，类似于写在纸上的普通物理签名

阮一峰老师图解数字签名，讲解的毁更加的详细。

4.2.1 代码生成数字签名

使用Java生成数字签名的时候，会用到Signature这个类，Java的API是这么对它解释的。而且签名算法跟加密算法还是有区别的常见的签名算法是sha256withrsa

根据API中的描述，给得到一个私钥的数字签名分为三步

  • 初始化 —>getInstance这里的参数就是算法，常见的就是sha256withrsa—>initSign初始化的时候需要传入一个私钥
  • 更新—->update(input.getBytes)，更新原文数据转换成字节数组更新到其中
  • 签名—>sign方法，进行签名，返回字节数组。 
 public class SignatureDemo {
    public static void main(String[] args) throws Exception {
        String a = "";
        String priPath = "a.pri";
        String algorithm = "RSA";
        PrivateKey privateKey = RSADemo.getPrivateKey(priPath, algorithm);

        getSignature(a,"shawithrsa",privateKey);
    }

    private static String getSignature(String input, String algorithm, PrivateKey privateKey) throws Exception {
        Signature signature = Signature.getInstance(algorithm);
        signature.initSign(privateKey);
        signature.update(input.getBytes());
        byte[] sign = signature.sign();
        return Base.encode(sign);
    }
}

运行结果如下，把得到的签名文件打印出来了。

4.2.2 校验数字签名

 psvm(){
 boolean b = verifySignature(a, "shawithrsa", publicKey, signpriKey);
 System.out.println(b);
}
private static boolean verifySignature(String input, String algorithm, PublicKey publicKey, String signpriKey) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException, BaseDecodingException {
       Signature signature = Signature.getInstance(algorithm);
       signature.initVerify(publicKey);//这里是初始化校验
       signature.update(input.getBytes());
       return signature.verify(Base.decode(signpriKey));
}

用私钥加密的数字签名，就要公钥来解密，于是校验的算法里传入的是公钥，跟私钥加密不同的地方在于initVerify是初始化校验，而不是签名的时候的initSign()方法，这里参数传入的是publicKey也就是公钥。并且校验方法比签名方法多了参数就是，密文参数，需要得到原文和密文才可以进行校验。

运行结果如下，判断是一致的签名。Github链接

浅析Java反射
上一篇
10种流行的Java框架
下一篇