密码学和Java加密与解密技术

密码学大概像中国的历史发展一样，可分为古典密码学、近代密码学、现代密码学。

古典密码主要是替换密码和移位密码。核心原理也就是替换法、移位法。

替换法也有两种，单表替换和多表替换。
单表替换即原文和密文用的同一张表
如表：j替换u，a替换q，v替换为f
所以明文java替换后变密文uqfq。
也有多表替换，即原文和密文用的是多张表
如：表 abcdef---swtrpv、abcdef---chfhkd、abcdef---jftoud
秘钥为 312
表示分别替换第三张表、第一张表、第二张表
则明文的abc替换后为密文sht。

移位法就是将原文所有字母在字母表上按照一个固定数组进行前后移位，得出密文。
如：明文abcde变为密文cdefg，就是在字母表里每个字母分别往后移动两位。
典型的移位法应用有"恺撒加密"。

java 代码实现"恺撒加密"

package javaweb.com.demo;

public class Encryption {
    public static void main(String[] args) throws Exception {
        String a = "cseroad";
        int key = 3;
        char[] chars = a.toCharArray();
        //字符串变成字节数组
        StringBuilder sb = new StringBuilder();
        for (char c : chars) {
            int ascii = c;
            ascii = ascii + key;
            //向右移动三位后的ascii
            char newa =  (char)ascii;
            //System.out.println(newa);
            sb.append(newa);
        }
        System.out.println("密文："+sb.toString());
        //转化为String对象
    }
}

恩尼格玛机，本质上使用的还是替换和移位。后被图灵破解。

我们知道在计算机中，存储数据都是用二进制表示的（即0和1）。那么像我们平时用到的字母、数字也是需要用二进制表示。于是有了ASCII编码表来统一进行换算。

java实现求字符对应的ASCII编码：

package javaweb.com.demo;

public class Encryption {
    public static void main(String[] args) throws Exception {
        char a = 'a';
        int b = a;
        System.out.println(b);
    }
}

即char字符类型自动转化为int类型。
字符a的ASCII码为97，存储到计算机的二进制为0110 0001。

Unicode编码

那么汉字、日文、韩文又是怎么在计算机中存储的呢？
这就有了Unicode编码表，也被称为万国码。为每种语言每个字符设置了统一并唯一的二进制编码。包含ASCII码，从0到127的字符。如上面的a的ASCII码为97，十六进制为61，则unicode编码为0x0061。该编码一般用十六进制表示。

package javaweb.com.demo;

public class Encryption {
    public static void main(String[] args) throws Exception {
        char a = '经';
        int b = a;
        System.out.println(b);
    }
}

汉字"经"的十六进制为0x7ecf，转化十进制就是32463，即输出值。
但是char只能存储单一的字符。如果遇到字符串呢?

java实现求字符串对应的ASCII编码：

package javaweb.com.demo;

public class Encryption {
    public static void main(String[] args) throws Exception {
        String a = "cseroad";
        char[] chars = a.toCharArray();
        //字符串转化为字节数组，然后遍历字符
        for (char c : chars) {
            int ascii = c;
            System.out.println(ascii);
        }
        
    }
}

需要补充的是，UTF-8是Unicode实现的方式之一。两者之间也是通过程序进行转换的。
转换规则参考 字符编码笔记：ASCII，Unicode 和 UTF-8

不管是什么编码方式，运行在计算机里只能是二进制数。

java 实现求某字符串二进制数：

package javaweb.com.demo;

public class Encryption {
    public static void main(String[] args) throws Exception {
        String a = "经";
        byte[] bytes = a.getBytes("UTF-8");
        for (byte c : bytes) {
            int ascii = c;
            String s = Integer.toBinaryString(ascii);
            System.out.println("二进制值："+s);
        }
        
    }
}

UTF-8编码格式下，一个中文等于3个字节，一个字节等于8个二进制位。
GBK 编码格式下，一个中文等于2个字节，一个字节等于8个二进制位。

char

• 字符数据类型，占两个字节，无符号
• 范围在0-65535之间
• 不可以表示负数，但是可以表示中文

byte

• 字节数据类型，有符号
• 范围在-128-127之间
• 可以和 ASCII 码相互转换，不可以表示中文
• 一字节等于8个二进制位

url编码指的是浏览器发送到服务器时使用的编码，用来便于浏览器和服务器进行通信。
url编码就是一个字符ascii码的十六进制，每个字节前面添加%。

java 实现url编码：

package javaweb.com.demo;

import java.net.URLDecoder;
import java.net.URLEncoder;

public class Encryption {

    public static void main(String[] args) throws Exception {
        String old = "url 编码";
        String encode = URLEncoder.encode(old,"UTF-8");
        System.out.println(encode);
        
        String decode = URLDecoder.decode(encode,"UTF-8");
        System.out.println(decode);
    }

}

base64编码是一种基于64个字符把二进制数据用文本表示的编码算法，方便传输，提高可读性。
分别是A-Z、a-z、0-9、两个字符+和/，正好64个字符。

原理
每3个8位二进制转化为4个6位二进制数，然后在每个6位二进制数都填两个高位0，得到4个8位二进制数，如果缺位则补0。再将其分别转化为十进制，最后通过base64编码表获取编码后字符。

如：

字符串"中国" 的utf-8编码对应的十六进制为e4b8ad、e59bbd，转化二进制为111001001011100010101101、111001011001101110111101，然后每6个二进制位为1组。

111001
001011
100010
101101
111001
011001
101110
111101

再分别填补两个高位0。

00111001
00001011
00100010
00101101
00111001
00011001
00101110
00111101

再转化十进制为57、11、34、45、57、25、46、61，按照base64编码表转为5Lit5Zu9。

java 实现base64编码：

package javaweb.com.demo;

import java.util.Base64;

public class Encryption {

    public static void main(String[] args) throws Exception {
        String old = "中国";
        //encode
        String bs64 = Base64.getEncoder().encodeToString(old.getBytes("UTF-8"));
        System.out.println(bs64);
        
        //decode
        String ori = new String(Base64.getDecoder().decode(bs64),"UTF-8");
        System.out.println(ori);
    }

}

消息摘要算法也叫散列算法、哈希函数、单向函数。是一种将任意长度输入转换为固定长度输出的算法。

主要作用不是用于加密与解密，而是用于验证信息的完整性。常用于密码加密、文件校验。
消息摘要算法主要分为三类，MD（消息摘要算法）、SHA（安全散列算法）、MAC（消息认证码算法）

常见的消息摘要算法有MD5、SHA-1、SHA-256、SHA-512等等。

md5的长度默认为128个二进制位，这样表达是很不友好的，所以将二进制转成了16进制，每4个二进制位表示一个16进制，所以就变为32位了。

package javaweb.com.demo;

import java.security.MessageDigest;

public class Encryption {

    public static void main(String[] args) throws Exception {
        String input = "cseroad";
        //明文
        String algorithm = "MD5";
        //加密类型
        MessageDigest md = MessageDigest.getInstance(algorithm);
        //初始化
        md.update(input.getBytes("UTF-8"));
        //更新摘要
        byte[]  r = md.digest();
        //获得密文完成哈希计算
        StringBuilder sb = new StringBuilder();
        for (byte b : r) {
            String s = Integer.toHexString(b & 0xff);
            //密文10进制转16进制
            if (s.length() == 1) {
                s = "0"+s;
            }
            //判断如果密文长度为1，高位需要补0
            sb.append(s);
        }
        
        System.out.println(sb.toString());
    }
}

要点

使用MessageDigest类用于为应用程序提供信息摘要算法的功能。要实现SHA-1、SHA-256、SHA-512 替换algorithm变量即可。

也可以通过BigInteger类处理任意精度的整数运算，这样代码比较简洁。

java 实现MD5加密：

package javaweb.com.demo;

import java.math.BigInteger;
import java.security.MessageDigest;

public class Encryption {

    public static void main(String[] args) throws Exception {
        String input = "cseroad";
        String algorithm = "MD5";
        MessageDigest md = MessageDigest.getInstance(algorithm);
        md.update(input.getBytes("UTF-8"));
        byte[]  r = md.digest();
        BigInteger a = new BigInteger(1,r);
        //转化为16进制
        System.out.println(String.format("%032x",a));
    } 
}

java实现SHA-1加密：

package javaweb.com.demo;

import java.math.BigInteger;
import java.security.MessageDigest;

public class Encryption {

    public static void main(String[] args) throws Exception {
        String input = "cseroad";
        String algorithm = "SHA-1";
        MessageDigest md = MessageDigest.getInstance(algorithm);
        md.update(input.getBytes("UTF-8"));
        byte[]  r = md.digest();
        BigInteger a = new BigInteger(1,r);
        //转化为16进制
        System.out.println(String.format("%040x",a));
    } 
}

SHA-1的返回值时160位二进制位，同样和MD5一样，每四个二进制位换算为一个16进制，所以结果为40位。

在密码学中，是指通过在任意固定位置插入特定的字符串，让散列后的结果和使用原始密码的散列结果不相符，这种过程称之为"加盐"。
注意加盐的目的是为了增加攻击者破解的难度，所以盐值不能太短，也不能使用固定盐值。

位运算指的是内存中二进制为的操作。

与运算 &   0&0=0，0&1=0，1&0=0，1&1=1
异或运算 ^  同为假，异为真。0&0=0，0&1=1，1&0=1，1&1=0
非运算 ~   取反运算，1变0，0变1
或运算 |   0&0=0，0&1=1，1&0=1，1&1=1

举个例子：

99 ^ 2 = 97
转化二进制位进行异或运算
01100011^00000010 = 01100001 

java实现异或运算：

package javaweb.com.demo;

public class Encryption {

    public static void main(String[] args) throws Exception {
         int len,i;
         char[] newstr;
         char[] str = {'a','b','c'};//定义char类型数组
         char n = 2;//定义秘钥
         len = str.length;
         newstr = new char[len];//定义数组
         for(i=0;i 
转化为char类型直接和密码进行运算。
 
java实现位运算加解密：
 
package javaweb.com.demo;


public class Encryption {

    public static void main(String[] args) throws Exception {
        String strs = "cseroad";
        int key = 10;
        //加密
        char[] newchr = strs.toCharArray();
        for (int i = 0; i < newchr.length; i++) {
            newchr[i] = (char) (newchr[i]^key);
        }
        System.out.println("加密结果如下："+new String(newchr));
        
        //解密
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < newchr.length; i++) {
            char oldchr = (char) (newchr[i]^key);
            sb.append(oldchr);
        }
        System.out.println(sb);
        
    } 
}
 
怎么位运算加密的，就怎么位运算解密。
 
六、对称加密 
对称密码体制分为两种：
 一种对明文字节进行运算，称为流加密，也叫序列加密；
 一种把明文信息划分不同的组或块后再进行加密，称为分组加密。
 如123456789，流加密就是先对1加密，再对2加密，往后依次，最后拼成密文。
 块加密是把该数字分成不同的块，如123成块，456成块，789成块，再对不同的块加密，最后形成密文。
 DES、AES都是常见的对称加密算法，且属于分组加密。
 分组加密总共有五种工作模式：电子密码本模式ECB、密文链接模式CBC、密文反馈模式CFB、输出反馈模式OFB、计数器模式CTR。
 
AES加密 
先看代码，java 实现AES加解密：
 
package javaweb.com.demo;


import java.util.Base64;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

public class Encryption {
    public static void main(String[] args) throws Exception {
        String input = "cseroad";
        //原文
        String key = "1234567890abcdef";
        //秘钥
        String transformation = "AES";
        //AES算法
        String algorithm = "AES";
        //加密类型
        
        //加密方法
        String encryptdes = encryptDES(input,key,transformation,algorithm);
        System.out.println("AES加密："+encryptdes);
        //解密方法
        String decryptdes = decryptDES(encryptdes,key,transformation,algorithm);
        System.out.println("AES解密："+decryptdes);
    }

    private static String encryptDES(String input,String key,String transformation,String algorithm) throws Exception {
        Cipher cipher = Cipher.getInstance(transformation);
        //创建加密对象
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algorithm);
        //创建加密规则。第一个参数key秘钥，第二个参数加密的类型
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
        //加密初始化。第一个参数表示加密模式，第二个参数表示加密规则
        byte[] bytes = cipher.doFinal(input.getBytes());
        //原文字节数组进行加密
        String bs64 = Base64.getEncoder().encodeToString(bytes);
        //直接打印出现乱码，采用base64编码后输出
        return bs64;
        //打印密文
    }
    
    private static String decryptDES(String encryptdes, String key, String transformation, String algorithm) throws Exception {
        Cipher cipher = Cipher.getInstance(transformation);
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algorithm);
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
        byte[] old = Base64.getDecoder().decode(encryptdes);
        byte[] bytes = cipher.doFinal(old);
        return  new String(bytes);
    }
    
}
 
 
要点
 
使用Cipher这个类实现对AES、DES的加解密。
 
AES的秘钥key长度必须是16byte。
 
算法transformation变量这里是AES，其完整格式应该为AES/ECB/PKCS5Padding，也是默认值
 
第一个参数加密算法：
 
AES，DES，DESede(DES3)和 RSA 四种
第二个参数工作模式，就是上面介绍的那五种。这里再说一下经常使用的ECB、CBC工作模式：
 
ECB 电子密码本，需要加密的消息按照块密码的块大小分成数块，并对块独立加密。
CBC 密码块链接，每个明文块先与前一个密文块进行异或后，再进行加密。
第三个参数填充模式：
 
Nopadding 不填充，默认值
PKCS5Padding 填充，加密内容不足8位就填充。
如果要使用CBC加密模式，需要定义一个IvParameterSpec对象，向量模式也可以简单理解为偏移量。
 
代码如下：
 
package javaweb.com.demo;


import java.util.Base64;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class Encryption {
    public static void main(String[] args) throws Exception {
        String input = "cseroad";
        //原文
        String key = "1234567890abcdef";
        //秘钥
        String transformation = "AES/CBC/PKCS5Padding";
        //AES算法
        String algorithm = "AES";
        //加密类型
        
        //加密方法
        String encryptdes = encryptDES(input,key,transformation,algorithm);
        System.out.println("AES加密："+encryptdes);
        //解密方法
        String decryptdes = decryptDES(encryptdes,key,transformation,algorithm);
        System.out.println("AES解密："+decryptdes);
    }

    private static String encryptDES(String input,String key,String transformation,String algorithm) throws Exception {
        Cipher cipher = Cipher.getInstance(transformation);
        //创建加密对象
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algorithm);
        //创建加密规则。第一个参数key字节，第二个参数加密的类型
        IvParameterSpec iv = new IvParameterSpec("9876543210qwerty".getBytes());
        //创建IV向量
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec,iv);
        //加密初始化。第一个参数表示加密模式，第二个参数表示加密规则
        byte[] bytes = cipher.doFinal(input.getBytes("UTF-8"));
        //原文字节数组进行加密
        String bs64 = Base64.getEncoder().encodeToString(bytes);
        //直接打印出现乱码，采用base64编码后输出
        return bs64;
        //打印密文
    }
    
    private static String decryptDES(String encryptdes, String key, String transformation, String algorithm) throws Exception {
        Cipher cipher = Cipher.getInstance(transformation);
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algorithm);
        IvParameterSpec iv = new IvParameterSpec("9876543210qwerty".getBytes());
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec,iv);
        byte[] old = Base64.getDecoder().decode(encryptdes);
        byte[] bytes = cipher.doFinal(old);
        return  new String(bytes);
    }
    
}
 
 
要点
 
iv向量长度必须16个字节。
 
DES 加密 
DES加密和上面的AES大同小异，直接替换AES就可以。需要注意的是DES的秘钥key必须是8位byte。
 
七、非对称加密 
非对称加密中，加密解密使用不同的秘钥。对外公开的秘钥为公钥，对外保密的秘钥为私钥。
 公钥加密，私钥解密；私钥加密，公钥解密。
 
常见的非对称加密方式：RSA、DSA、ECC。
 
RSA 加密 
使用KeyPairGenerator类创建密码对。
 
package javaweb.com.demo;

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;

import javax.crypto.Cipher;

public class Encryption {

    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();
        //获取私钥自己数组
        byte[] privateKeyEncode = privateKey.getEncoded();
        //获取公钥自己数组
        byte[] publicKeyEncode = publicKey.getEncoded();
        //base64编码
        String privateKeyEncodeString = Base64.getEncoder().encodeToString(privateKeyEncode);
        System.out.println(privateKeyEncodeString);
        
        String publicKeyEncodeString = Base64.getEncoder().encodeToString(publicKeyEncode);
        System.out.println(publicKeyEncodeString);      
    } 
}
 
base64编码输出。
 
java 实现私钥加密，公钥解密：
 
package javaweb.com.demo;

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;
import javax.crypto.Cipher;

public class Encryption {

    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();
        
        //原文
        String input = "cseroad";
        //创建加密对象
        Cipher cipher = Cipher.getInstance(algorithm);
        //加密初始化，使用私钥加密
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        byte[] bytes = cipher.doFinal(input.getBytes("UTF-8"));
        String bs64 = Base64.getEncoder().encodeToString(bytes);
        System.out.println("密文"+bs64);
        
        //解密 
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        byte[] bytes1 = cipher.doFinal(bytes);
        System.out.println("原文"+new String(bytes1));
        
    } 
    
}
 
 
DSA 加密 
DSA是一种更高级的验证方式，用作数字签名。不单单只有公钥、私钥，还有数字签名。私钥加密生成数字签名，公钥验证数据及签名。
 
java实现DSA加密并数字签名的认证，部分代码参考github：
 
package javaweb.com.demo;

import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.Signature;
import java.security.interfaces.DSAPrivateKey;
import java.security.interfaces.DSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class Encryption {

    private static String PUBLIC_KEY = "MIIBuDCCASwGByqGSM44BAEwggEfAoGBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2USZpRV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4O1fnxqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAhUAl2BQjxUjC8yykrmCouuEC/BYHPUCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoDgYUAAoGBAOgR1bl0s3/9tsxVU2tkq5/nfOKZ2z8jT6cLG/axihbSEOAhmXTgPTD3V3bSLtK9O2CIwvR6Ljz70Sl/LUFI0+YBIFGB/jASCJ2av/Im0SItyRDiT+n8GDo6OHc8SyTSwxPv4tVGGy52lqdHO9IqK6QpFZ00LNaPy+5IRfoZrMZh";
    private static String PRIVATE_KEY = "MIIBSwIBADCCASwGByqGSM44BAEwggEfAoGBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2USZpRV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4O1fnxqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAhUAl2BQjxUjC8yykrmCouuEC/BYHPUCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoEFgIUcwvMm8OVRd1UsTx+q/IgcIUlsns=";
    public static void main(String[] args) {
        //随机生成成对密钥
        genKeyPair();
        String sign=sign("cseroad", PRIVATE_KEY);
        System.out.println("数字签名:" + sign);
        //字符串解码
        System.out.println("数字签名校验:" + verify("cseroad",sign,PUBLIC_KEY));
    }
    
    public static void genKeyPair() {
        try {
            // KeyPairGenerator类用于生成公钥和私钥对，基于DSA算法生成对象 可以使用RSA算法生成 成对出现就好
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DSA");
            // 初始化密钥对生成器，密钥大小为96-1024位 可自定义随机产生器 SecureRandom
            keyPairGen.initialize(1024);
            // 生成一个密钥对，保存在keyPair中
            KeyPair keyPair = keyPairGen.generateKeyPair();
            // 得到私钥
            DSAPrivateKey privateKey = (DSAPrivateKey) keyPair.getPrivate();
            // 得到公钥
            DSAPublicKey publicKey = (DSAPublicKey) keyPair.getPublic();
            // 得到公钥字符串
            String publicKeyString = new String(Base64.getEncoder().encode(publicKey.getEncoded()));
            // 得到私钥字符串
            String privateKeyString = new String(Base64.getEncoder().encode((privateKey.getEncoded())));
            // 打印公钥和私钥
            System.out.println("公匙:" + publicKeyString);
            System.out.println("私匙:" + privateKeyString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    
    public static String sign(String str, String privateKey) {
        try {
            byte[] bytes = str.getBytes();
            //获得DSA公匙
            DSAPrivateKey keyFactory = (DSAPrivateKey) KeyFactory.getInstance("DSA").generatePrivate(new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey.getBytes())));
            Signature signature = Signature.getInstance("DSA");
            signature.initSign(keyFactory);
            signature.update(bytes);
            return new String(Base64.getEncoder().encode(signature.sign()));
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

    }

    
    public static boolean verify(String str, String sign,String publicKey) {
        try {
            byte[] bytes = Base64.getDecoder().decode(sign);
            DSAPublicKey keyFactory = (DSAPublicKey) KeyFactory.getInstance("DSA").generatePublic(new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey.getBytes())));
            Signature signature=Signature.getInstance("DSA");
            signature.initVerify(keyFactory);
            signature.update(str.getBytes());
            return signature.verify(bytes);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

}
 
 
八、数字证书 
数字证书是由权威的CA（Certificate Authority）机构颁布的一种证书。集合了多种密码学算法，用来加解密、身份认证、签名等功能。
 
非对称加密：对数据加解密
 签名算法：确保数据完整性
 摘要算法：确保数据没有篡改
 
我们熟知的HTTPS协议就是应用了数字证书。
 
数字证书的格式遵循X.509 标准
 
证书的发布机构
证书的有效期
公钥
证书所有者（Subject）
签名所使用的算法
指纹以及指纹算法
 
注意证书链的验证是从根证书开始的。