freebuf1.基础知识
密码学：主要是研究编制密码和 破译密码的学科
密码学的主要目的：简单的直接说就是，研究如何隐藏信息并且把信息传递出去的一个学科。
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>2.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 = 3; 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 = 3; 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 str1 = "a"; String str2 = "红"; ByteToBit(str2); } 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一个中文对应的是三个字节
这里修改一下代码byte[] bytes = str.getBytes("GBK");设置成GBK编码之后，就会变成两个字节，如果是GBK一个中文对应的是两个字节
如果是英文，就没有编码的概念了，全部对应的是一个字节
2.对称加密
采用单密钥系统的加密方法，同一个密钥可以同时加密和解密，也成单密钥加密。
常见加密算法
DES
AES
特点
加密速度快，可以加密大文件
密文可逆，一旦密钥文件泄露，就会导致数据暴露
加密后编码表找不到对应字符，出现乱码
一般结合Base64使用
2.1 DES
2.1.1 Cipher加密对象
根据java官方API的描述：该类提供加密和解密的加密密码的功能。 它构成了Java加密扩展（JCE）框架的核心。
为了创建一个Cipher对象，应用程序调用Cipher的getInstance方法，并将所请求的转换的名称传递给它。 可选地，可以指定提供者的名称。
转换是描述要在给定输入上执行的操作（或操作集）的字符串，以产生一些输出。 转换总是包括加密算法的名称（例如， DES），并且可以跟随有反馈模式和填充方案。
转换形式如下：
“ 算法/模式/填充”或
“ 算法”
（在后一种情况下，使用模式和填充方案的提供者特定的默认值）。 例如，以下是有效的转换：
Cipher c = Cipher.getInstance("DES/CBC/PKCS5Padding"); 我们新建一个Cipher的时候需要调用getInstance函数，里边的参数是“算法/模式/填充”或者仅仅是“算法”。
2.1.2 DES代码示例
加密一段数据，首先需要原文和密钥
public class DesDemo { public static void main(String[] args) throws NoSuchPaddingException, NoSuchAlgorithmException { String data = "小红爱JAVA"; String key = "12345678"; 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 = "12345678"; 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用到的就是这个构造方法
我们可以看到SecretKeySpec是实现了SecretKey接口，SecretKey接口继承的Key类，所以本质上还是一个Key.
现在有了一个加密的cipher对象之后，就要执行加密方法了就是doFinal()，需要传入原文的byte[]数组，也会返回一个byte[]数组。
加密后的代码是这个样子
public class DesDemo { public static void main(String[] args) throws Exception { String data = "小红爱JAVA"; String key = "12345678"; 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中找不到对应的字节编码
之后使用base64继续编码一下
public static void main(String[] args) throws Exception { String data = "小红爱JAVA"; String key = "12345678"; 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 = Base64.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.Base64; 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 = "12345678"; 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(Base64.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 = Base64.encode(bytes); return encode; } } 
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之间。
在base64中，需要设置一共是3个字节，为一组，如果在输出的时候，不够三个字节，就需要使用=进行补齐
public class Base64Demo { public static void main(String[] args) { //这里就一个字符,就需要填充两个等号 System.out.println(Base64.encode("1".getBytes())); System.out.println(Base64.encode("12".getBytes())); System.out.println(Base64.encode("123".getBytes())); System.out.println(Base64.encode("嘿嘿".getBytes())); } } 
2.3 toString()和new String()
首先看一下代码示例
public class Base64Demo { public static void main(String[] args) throws Exception{ String str = "SmF2YUNvZGVBdWRpdA=="; System.out.println("new String===>"+new String(Base64.decode(str.getBytes()))); System.out.println("toString=====>"+Base64.decode(str.getBytes()).toString()); } } 结果如下，可以看到new String得到的结果是正确的，那么为什么会是new String得到正确的结果呢
其实在调用toString的时候会调用的是Object的toString方法，调用的是hashcode()方法，得到的是一个哈希值
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==
更换到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 = Base64.encode(bytes); return encode; } 可以看到就不会报错了
3.消息摘要
消息摘要又称数字摘要
它是一个唯一对应一个消息或文本的固定长度的值，由一个单向的Hash加密函数对消息进行作用而产生
使用数字摘要生成的值是不可篡改的，为了保证文件或者值的安全性
消息摘要算法是不可逆的，常见的算法有
- MD5 - SHA1 - SHA256 - SHA512 使用的是MessageDigest，使用getInstace()方法传入参数algorithm表示加密类型
MessageDigest digest = MessageDigest.getInstance("SHA"); 
得到一个digest对象之后就能调用其digest方法，该方法的参数就是原文的字节数组
public class digestDemo { public static void main(String[] args) throws NoSuchAlgorithmException { String input = "java"; String algorithm = "MD5"; MessageDigest digest = MessageDigest.getInstance(algorithm); byte[] bytes = digest.digest(input.getBytes()); System.out.println(Base64.encode(bytes)); } } 
写一个直接生成MD5值的demo
public class digestDemo { public static void main(String[] args) throws NoSuchAlgorithmException { String input = "aa"; String algorithm = "MD5"; MessageDigest digest = MessageDigest.getInstance(algorithm); byte[] mdcryptData = digest.digest(input.getBytes()); StringBuilder sb = new StringBuilder(); for (byte b : mdcryptData) { String s = Integer.toHexString(b //将加密的byte数组转换成16进制的代码，返回String字符串 if(s.length()==1){ s = "0"+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 = "MD5"; String digest = getDigest(input, algorithm); System.out.println(digest); String sha1 = getDigest(input, "SHA-1"); System.out.println(sha1); String sha256 = getDigest(input, "SHA-256"); System.out.println(sha256); String sha512 = getDigest(input, "SHA-512"); System.out.println(sha512); } 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(Base64.encode(privateKey.getEncoded())); System.out.println(Base64.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(Base64.encode(bytes)); 这里就是最后得到的密文数据
4.1.3 使用公钥解密数据
非对称算法，私钥加密数据，必须使用公钥解密，否则会报错，有兴趣的朋友就自己动手试试了.
跟其他的解密一样，key设置为publicKey即可
cipher.init(Cipher.DECRYPT_MODE,publicKey); byte[] bytes1 = cipher.doFinal(bytes); System.out.println(new String(bytes1)); 
4.1.4 保存公钥和私钥
我们一直生成公钥和私钥就很不方便，所以一般是将公钥和私钥给保存下来
package com.red.javacodeaudit.encrypt.RSA; import com.sun.org.apache.xml.internal.security.utils.Base64; 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 = "Red256'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 = Base64.encode(privateKey.getEncoded()); String publickeyString = Base64.encode(publicKey.getEncoded()); //这里commins-IO的包中的方法 FileUtils.writeStringToFile(new File(pubFile),publickeyString, Charset.forName("UTF-8")); FileUtils.writeStringToFile(new File(priFile),privatekeyString,Charset.forName("UTF-8")); } } 成功的生成了公钥和私钥文件
4.1.5 抽取出加密解密方法
这里就是把都在main方法中的代码，封装成独立的方法了，没有什么值得说的。
package com.red.javacodeaudit.encrypt.RSA; import com.sun.org.apache.xml.internal.security.utils.Base64; 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 = "Red256'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 s1 = decryptRSA(algorithm, publicKey, s); System.out.println(s1); } /** * * @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(2,publicKey); byte[] decode = Base64.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 = Base64.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 = Base64.encode(privateKey.getEncoded()); String publicKeyString = Base64.encode(publicKey.getEncoded()); FileUtils.writeStringToFile(new File(pubFile),privateKeyString, Charset.forName("UTF-8")); FileUtils.writeStringToFile(new File(priFile),publicKeyString,Charset.forName("UTF-8")); } } 4.1.6 读取公钥私钥
写一个方法，读取出来文件中的内容，给私钥编码的规则是PKCS8EncodedKeySpec，官方API的介绍。
给公钥进行编码的规则是X509EncodedKeySpec，这里记住就好，下面是官方API的介绍
psvm(){ String input = "Red256'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, Base64DecodingException, InvalidKeySpecException { String privateKey = FileUtils.readFileToString(new File(privateKeyFile), Charset.defaultCharset()); //新建一个key工厂来生成key KeyFactory keyFactory = KeyFactory.getInstance(algorithm); //生成key的时候需要传入一个KeySpec规则，RSA私钥对应的就是PKCS8EncodedKeySpec这个规则 PKCS8EncodedKeySpec 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); X509EncodedKeySpec 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 = "123"; String priPath = "a.pri"; String algorithm = "RSA"; PrivateKey privateKey = RSADemo.getPrivateKey(priPath, algorithm); getSignature(a,"sha256withrsa",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 Base64.encode(sign); } } 运行结果如下，把得到的签名文件打印出来了。
4.2.2 校验数字签名
psvm(){ boolean b = verifySignature(a, "sha256withrsa", publicKey, signpriKey); System.out.println(b); } private static boolean verifySignature(String input, String algorithm, PublicKey publicKey, String signpriKey) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException, Base64DecodingException { Signature signature = Signature.getInstance(algorithm); signature.initVerify(publicKey);//这里是初始化校验 signature.update(input.getBytes()); return signature.verify(Base64.decode(signpriKey)); } 用私钥加密的数字签名，就要公钥来解密，于是校验的算法里传入的是公钥，跟私钥加密不同的地方在于initVerify是初始化校验，而不是签名的时候的initSign()方法，这里参数传入的是publicKey也就是公钥。并且校验方法比签名方法多了参数就是，密文参数，需要得到原文和密文才可以进行校验。
运行结果如下，判断是一致的签名。Github链接
转载请注明来自网盾网络安全培训，本文标题：《Java加密算法》
- 上一篇： 全网最全的Cobalt Strike使用教程系列-基础篇
- 下一篇： 后whois时代的证书狩猎技巧
- 关于我们
