加密与安全

一,URL编码 为什么要使用URL编码? 我们都知道Http协议中参数的传输是"key=value"这种简直对形式的,如果要传多个参数就需要用“&”符号对键值对进行分割。如 "?name1=value1&name2=va...

一,URL编码

为什么要使用URL编码?

我们都知道Http协议中参数的传输是"key=value"这种简直对形式的,如果要传多个参数就需要用“&”符号对键值对进行分割。如 "?name1=value1&name2=value2",这样在服务端在收到这种字符串的时候,会用“&”分割出每一个参数,然后再用“=”来分割出参数值。

现在有这样一个问题,如果我的参数值中就包含=或&这种特殊字符的时候该怎么办。
比如说“name1=value1”,其中value1的值是“va&lu=e1”字符串,那么实际在传输过程中就会变成这样“name1=va&lu=e1”。我们的本意是就只有一个键值对,但是服务端会解析成两个键值对,这样就产生了奇异。

如何解决上述问题带来的歧义呢?解决的办法就是对参数进行URL编码?

URL编码只是简单的在特殊字符的各个字节前加上%,例如,我们对上述会产生奇异的字符进行URL编码后结果:“name1=va%26lu%3D”,这样服务端会把紧跟在“%”后的字节当成普通的字节,就是不会把它当成各个参数或键值对的分隔符。

类似于这种

实际操作

public static void main(String[] args) {
    //url编码
    String str="测试";
    String urlStr=URLEncoder.encode(str);
    System.out.println("url编码之后:"+urlStr);
    String deStr=URLDecoder.decode(urlStr);
    System.out.println("url解码之后:"+deStr);
}

打印

url编码之后:%E6%B5%8B%E8%AF%95
url解密之后:测试

二,Base64编码

实际操作

    String str="测试";
    String b64=Base64.getEncoder().encodeToString(str.getBytes("utf-8"));
    System.out.println("base64编码之后:"+b64);
    String ori=new String(Base64.getDecoder().decode(b64),"utf-8");
    System.out.println("base64解码之后:"+ori);

打印

base64编码之后:5rWL6K+V
base64解码之后:测试

urlbase64编码

只需要把Base64.getEncoder()改为Base64.getUrlEncoder(),Base64.getDecoder()改为Base64.getUrlDecoder()即可。

Base64算法是编码算法,不是加密算法。Base64编码的目的是把任意二进制数据编码为文本(长度增加 1/3 ).

三,MD5加密

MD5是一种摘要算法,所谓摘要算法,就是输入任意长度数据,而输出的是固定长度数据。

举例:javaObject.hashCode()方法就是摘要算法。

有没有可能两个不同的输入得到了相同的输出?是有可能的,这也称之为碰撞!

常用的摘要算法

算法 长度一 长度二
MD5 128bits 16bits
SHA-1 160bits 20bits
SHA-256 256bits 32bits
RipeMD 160bits 20bits

实际操作

    String str="测试";
    //得到md5的实例
    MessageDigest md=MessageDigest.getInstance("MD5");
    //update的是byte类型的数组
    md.update(str.getBytes());
    //加密后返回
    byte[] r=md.digest();
    System.out.println(String.format("%032x", new BigInteger(1,r)));

打印

24f93872e1db308f75eb317e3649e814

说明:MD5的输入参数是byte数组,不是字符串。

四,SHA-1算法

SHA-1MD5其实加密过程是一样的,不过前者比后者安全一些,但是运行速度削微慢了那么一丢丢(约25%)。

只是把上面的MD5改为SHA-1即可。

实际操作

String str="测试";
    //得到md5的实例
    MessageDigest md=MessageDigest.getInstance("SHA-1");
    //update的是byte类型的数组
    md.update(str.getBytes());
    //加密后返回
    byte[] r=md.digest();
    System.out.println(String.format("%040x", new BigInteger(1,r)));

打印

0b5d7ed54bee16756a7579c6718ab01e3d1b75eb

五,对称加密算法

什么是对称加密?对称加密就是加密和解密使用的是同一个密钥。

通过传入一个密钥key和代加密的字符串进行加密。

解密:encrypt(key,message)--->得到加密后的结果

解密:decrypt(key,加密后的结果)---->解密后的结果

常用的对称加密算法

算法 密钥长度
DES 56/64
AES 128/192/256

密钥长度越长,该算法的加密力度越大,说明越安全!由于DES加密算法的密钥长度太短,以至于可以被人暴力破解,因此被淘汰弃用。

AES加密

实际操作

    String str="测试";
    //################## 加密  ######################
    //加密模式
    String CIPHER_NAME="AES/ECB/PKCS5Padding";
    //得到cipher实例
    Cipher cipher=Cipher.getInstance(CIPHER_NAME);
    //设置密钥
     byte[] keys="1234567890abcdef".getBytes();
    //得到key实例   参数是密钥(byte[]类型的)  和"AES"加密算法名
    SecretKeySpec key=new SecretKeySpec(keys, "AES");
    cipher.init(Cipher.ENCRYPT_MODE, key);
    //进行加密,得到的byte类型的
    byte[] b=cipher.doFinal(str.getBytes());
    System.out.println("加密后的密文(转化为Base64显示):"+Base64.getEncoder().encodeToString(b));
    
    //################### 解密   ########################
    //得到cipher实例
    Cipher ciphers=Cipher.getInstance(CIPHER_NAME);
    //得到key实例
    SecretKeySpec key1=new SecretKeySpec(keys, "AES");
    cipher.init(Cipher.DECRYPT_MODE, key1);
    //解密
    byte[] c=cipher.doFinal(b);
    System.out.println("解密后的明文:"+new String(c));

打印

加密后的密文(转化为Base64显示):6BIemWfPl6FUC/dqx79LVw==
解密后的明文:测试

六,非对称加密算法

RSA加密

RSA非对称加密认证

前提:A和B在私底下要互换对方的公钥,而私钥则自己持有!

加密:A给B发送消息,使用B的公钥加密,然后B收到消息后使用自己的私钥解密。

签名:A使用自己的私钥对数据进行签名,然后发送给B,然后B使用A的公钥进行验签,校验数据的完整性。

说明

使用公钥加密,使用私钥解密;使用私钥签名,使用公钥验签。

签名的作用:

A给B发送消息,加密之后发送给B,此时,一个黑客使用B的公钥加密了一些数据也发送给了B,那么B怎么才能知道收到的加密数据是A发送的而不是黑客?

这时就需要签名了,A加密后并对加密后的数据进行签名,使用A自己的私钥进行签名,发送到B之后,B再使用A的公钥进行验签,如果验签通过则说明加密数据是由A发送过来的。

朕给你们提供一个RSAUtil工具类,一切加密的起源都可以源于这个工具类。

本工具类说明书

方法一:string2PublicKey()将Base64编码的公钥转化为公钥对象

参数:(Base64格式的)公钥字符串 返回值:公钥对象

方法二:string2PrivateKey()将Base64编码的私钥转化为私钥对象

参数:(Base64格式的)私钥字符串 返回值:私钥对象

方法三:encrypt() 加密方法

参数:待加密的内容(字符串) 加密使用的密钥(对方公钥) 加密使用的模式(RSA)

返回值:内容加密后的Base64编码形式的字符串

方法四:decrypt() 解密方法

参数:待解密的内容的Base64编码形式的字符串 解密使用的密钥(自己私钥) 解密使用的模式(RSA)

返回值:原文字符串

方法五:handleData()分段处理加解密数据,放到输出流中(这里不做解释)

方法六:sign() 签名算法

参数:要签名的数据(原文或密文均可) 签名使用的密钥(自己私钥) 签名使用的模式(SHA1withRSA)

返回值:签名字符串

方法七:verifySign() 验签算法

参数:签名字符串 验签使用的密钥(对方公钥) 签名使用的模式(SHA1withRSA)

返回值:布尔类型

public class RSAUtil {
    //加密算法
    private static final String KEY_ALGORITHM = "RSA";
    //密钥长度
    private static final int KEY_SIZE = 1024;
    //分块加密,单块明文的最大字节数 (KEY_SIZE/8) - 11
    private static final int MAX_ENCRYPT_BLOCK = 117;
    //分块解密,单块密文的最大字节数 KEY_SIZE/8
    private static final int MAX_DECRYPT_BLOCK = 128;
    //加密算法
    public static final String encryptAlgorithm="RSA/ECB/PKCS1Padding";
    //签名算法
    public static final String signAlgorithm="SHA1withRSA";
    
    /**
     * 将Base64编码的公钥转化为公钥对象
     * create time: 2019年4月18日下午3:46:01
     * @param publicKeyStr
     * @return
     * @throws IOException
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    public static PublicKey string2PublicKey(String publicKeyStr) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
        //把base64格式的公钥进行base64解码转为byte类型
        byte[] keyBytes = Base64.decodeBase64(publicKeyStr);
        //根据给定的编码密钥创建一个新的 X509EncodedKeySpec对象
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        //getInstance  api解释:返回转换指定算法的 public/private 关键字的 KeyFactory 对象
        //keyFactory是密钥规范
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);//参数是加密算法RSA
        //根据提供的密钥规范(密钥材料)生成公钥对象
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }
    
    /**
     * 将Base64编码的私钥转化为私钥对象
     * create time: 2019年4月18日下午3:46:32
     * @param privateKeystr
     * @return
     * @throws IOException
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    public static PrivateKey string2PrivateKey(String privateKeystr) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
         //把base64格式的私钥进行base64解码转为byte类型
        byte[] keyBytes = Base64.decodeBase64(privateKeystr);
        //根据给定的编码密钥创建一个新的 PKCS8EncodedKeySpec对象
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        //getInstance  api解释:返回转换指定算法的 public/private 关键字的 KeyFactory 对象
        //keyFactory是密钥规范
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);//参数是加密算法RSA
        //根据提供的密钥规范(密钥材料)生成私钥对象
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }
    
    /**
     * RSA加密方法
     * create time: 2019年4月18日下午3:38:18
     * @param plainData     待加密的内容
     * @param key           加密使用的秘钥(对方的公钥)
     * @param algorithm     加密使用的模式
     * @return  内容加密后的Base64编码形式
     * @throws Exception
     */
    public static String encrypt(String plainData, Key key, String algorithm) throws Exception {
        //字节数组输出流在内存中创建一个字节数组缓冲区,所有发送到输出流的数据保存在该字节数组缓冲区中
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] chiperDataBytes;
        try {
            //得到cipher实例
            Cipher cipher = Cipher.getInstance(algorithm);//参数:加密算法RSA
            //初始化   ENCRYPT_MODE:用于将 Cipher 初始化为加密模式的常量   key:密钥(对方公钥)
            cipher.init(Cipher.ENCRYPT_MODE, key);
            //把要加密的字符串转换为byte数组
            byte[] plainDataBytes = plainData.getBytes("UTF-8");
            //调用分段加密方法进行加密
            //MAX_ENCRYPT_BLOCK:单块明文最大字节数
            //out 字节数组缓冲区,和stringbuffer类似用法
            handleData(out, cipher, plainDataBytes, MAX_ENCRYPT_BLOCK);
            //把字节数组输出流转为byte数组
            chiperDataBytes = out.toByteArray();
        } catch(Exception e) {
            throw new Exception(e);
        } finally {
            out.close();
        }
        //再把byte数组转为Base64编码格式的字符串并返回(加密后的Base64字符串)
        return Base64.encodeBase64String(chiperDataBytes);
    }

    /**
     * RSA分段解密方法
     * create time: 2019年4月18日下午3:40:52
     * @param cipherData    待解密的内容的Base64编码形式的数据
     * @param key           解密使用的秘钥 
     * @param algorithm     解密使用的模式
     * @return  解密后的内容
     * @throws Exception
     */
    public static String decrypt(String cipherData, Key key, String algorithm) throws Exception, IOException {
        //字节数组输出流在内存中创建一个字节数组缓冲区,所有发送到输出流的数据保存在该字节数组缓冲区中
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] plainDataBytes;
        try {
             //得到cipher实例
            Cipher cipher = Cipher.getInstance(algorithm);//参数:加密算法RSA
            //初始化   DECRYPT_MODE:用于将 Cipher 初始化为解密模式的常量   key:密钥(自己私钥)
            cipher.init(Cipher.DECRYPT_MODE, key);
            //把要解密的字符串转换为byte数组
            byte[] chiperDataBytes = Base64.decodeBase64(cipherData);
            //调用分段解密方法进行解密
            handleData(out, cipher, chiperDataBytes, MAX_DECRYPT_BLOCK);
            //把byte 数组输出流转为byte数组
            plainDataBytes = out.toByteArray();
        } catch(Exception e) {
            throw new Exception(e);
        } finally {
            out.close();
        }
        //再把byte数组转为字符串并返回(解密后的字符串)
        return new String(plainDataBytes);
    }
    
    /**
     * 分段处理加解密数据,放到输出流中
     * create time: 2019年4月18日下午3:42:37
     * @param out       输出流
     * @param cipher    加解密工具
     * @param dataBytes 要处理的数据
     * @param maxBlock  处理的块的最大字节数
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    private static void handleData(ByteArrayOutputStream out, Cipher cipher, byte[] dataBytes, int maxBlock) throws IllegalBlockSizeException, BadPaddingException {
        //计算待加密的byte数组的长度
        int inputLen = dataBytes.length;
        int offSet = 0;
        int i = 0;
        byte[] cache;
        //循环减去已经被加密的长度(剩余长度)
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > maxBlock) {
         //加密操作
         //处理dataBytes字节数组的缓冲区从offset开始(包含)的前maxBlock个字节
                cache = cipher.doFinal(dataBytes, offSet, maxBlock);
            } else {
                cache = cipher.doFinal(dataBytes, offSet, inputLen - offSet);
            }
            //将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此 byte 数组输出流
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * maxBlock;
        }
    }

    /**
     * 签名算法
     * @param attributes    属性数据   要签名的字符串
     * @param privateKey    签名使用的密钥   自己的私钥
     * @param algorithm     签名使用的模式  SHA1withRSA
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeyException
     * @throws SignatureException
     */
    public static String sign(String attributes, PrivateKey privateKey, String algorithm)
            throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
        //Signature对象可用来生成和验证数字签名
        Signature signature = Signature.getInstance(algorithm);
        //初始化这个用于签名的对象
        signature.initSign(privateKey);
        //使用指定的 byte 数组更新要签名或验证的数据
        signature.update(attributes.getBytes());
        //sign()方法:返回所有已更新数据的签名字节
        byte[] signedData = signature.sign();
        //把签名字节转为Base64编码格式的字符串
        return Base64.encodeBase64String(signedData);
    }

    /**
     * 验签算法
     * @param attributes    属性数据明文
     * @param signData      签名
     * @param publicKey     验签使用的公钥
     * @param algorithm     验签使用的模式
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeyException
     * @throws SignatureException
     */
    public static boolean verifySign(String attributes, String signData, PublicKey publicKey, String algorithm) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
        //Signature对象可用来生成和验证数字签名
        Signature signCheck = Signature.getInstance(algorithm);
        //使用来自给定证书的公钥初始化此用于验证的对象
        signCheck.initVerify(publicKey);
        //使用指定的 byte 数组更新要签名或验证的数据。
        signCheck.update(attributes.getBytes());
        //验证传入的签名
        return signCheck.verify(Base64.decodeBase64(signData));
    }
}

如果使用 RSA,对消息摘要算法则会有多种选择,因此,可以将签名算法指定为 MD2withRSAMD5withRSASHA1withRSA。因为没有默认的算法名称,所以必须为其指定名称。

开始加密签名

首先定义一下自己的私钥和对方的公钥。

     //自己的私钥
    public static final String privateKey="MIICdwIBADANBg.....";
    //对方的公钥
    public static final String thirdPublicKey="MIGfMA0GCSq.....";

加密和签名(传进的参数是待加密的数据【json串】)

 public Map jmqm(String jcxx) throws Exception {
        //得到PublicKey对象
        PublicKey publicKey = RSAUtil.string2PublicKey(thirdPublicKey);
        //进行加密并得到加密后的字符串
        String encryptParam = RSAUtil.encrypt(jcxx, publicKey, "RSA");
        //签名(这里对原文签名)
        PrivateKey privateKey = RSAUtil.string2PrivateKey(privateKey);
        String signature = RSAUtil.sign(jcxx, privateKey, "SHA1withRSA");
        Map map=new HashMap();
        map.put("encryptParam",encryptParam);
        map.put("signature",signature);
        return map;
    }

解密和验签

public String decryptData(String encryptData) throws Exception {
        JSONObject jsonObject = JSONObject.parseObject(encryptData);
        String encryptParam=(String) jsonObject.get("encryptParam");
        String signature=(String) jsonObject.get("signature");

        //第三方公钥转为Key对象
        PublicKey publicKey = RSAUtil.string2PublicKey(thirdPublicKey);
        //自己私钥转为Key对象
        PrivateKey privateKey = RSAUtil.string2PrivateKey(privateKey);
        //进行解密,返回解密后的原文字符串
        String plainData = RSAUtil.decrypt(encryptParam, privateKey, "RSA");
        log.info("反馈信息解密内容:"+plainData);
        //对原文进行验签
        boolean isTrue = RSAUtil.verifySign(plainData, signature, publicKey, "SHA1withRSA");
        if(isTrue){
            log.info("验签通过");
            return plainData;

        }else {
            log.info("验签失败");
            return "";
        }
    }

结束语:其实只要利用好RSAUtil这一个工具类即可,然后加解密以及签名验签的过程可以任意封装。

RSAUtil工具类中定义了一些静态变量,这些变量是要视情况而改变的。

KEY_ALGORITHM="RSA" 这是加解密算法

KEY_SIZE=1024 这是使用密钥的长度(1024 or 2048)

MAX_ENCRYPT_BLOCK 这是单块明文的最大字节数 (KEY_SIZE 除以 8 然后减去 11 )

MAX_DECRYPT_BLOCK 这是单块密文的最大字节数 (KEY_SIZE 除以 8 )

encryptAlgorithm="RSA/ECB/PKCS1Padding" 加密算法(这个没用到,用到的是第一个加密算法【RSA】)

signAlgorithm="SHA1withRSA" 这是签名算法

以上的所有静态变量都是调用加解密方法和签名验签方法时的参数,具体的RSA加密机制可以找时间抽空了解下,包括分段加解密,不过在这个RSAUtil工具类中已经写好了,不用过多操心这个问题了。

重点:当密钥使用的是1024位长度时,KEY_SIZE要设为1024,MAX_ENCRYPT_BLOCK要设为117,MAX_DECRYPT_BLOCK要设为128;当密钥使用的是2048位长度时,KEY_SIZE要设为2048,MAX_ENCRYPT_BLOCK要设为245,MAX_DECRYPT_BLOCK要设为256;

RSA加密明文最大长度117字节,解密要求密文最大长度为128字节,所以在加密和解密的过程中需要分块进行。RSA加密对明文的长度是有限制的,如果加密数据过大会抛出如下异常:

Exception in thread "main" javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes  
    at com.sun.crypto.provider.RSACipher.a(DashoA13*..)  
    at com.sun.crypto.provider.RSACipher.engineDoFinal(DashoA13*..)  
    at javax.crypto.Cipher.doFinal(DashoA13*..) 

转自网上的一篇帖子,对最大明文长度和最大密文长度做了详细的解释!

不管明文长度是多少,RSA 生成的密文长度总是固定的。但是明文长度不能超过密钥长度。比如 Java 默认的 RSA 加密实现不允许明文长度超过密钥长度减去 11(单位是字节,也就是 byte)。也就是说,如果我们定义的密钥(我们可以通过 java.security.KeyPairGenerator.initialize(int keysize)来定义密钥长度)长度为 1024(单位是位,也就是 bit),生成的密钥长度就是 1024位 / 8位/字节 = 128字节,那么我们需要加密的明文长度不能超过 128字节 -11 字节 = 117字节。也就是说,我们最大能将 117 字节长度的明文进行加密,否则会出问题(抛诸如 javax.crypto.IllegalBlockSizeException: Data must not be longer than 53 bytes的异常)。

自己总结

相反,如果密钥长度使用的是2048位 /(8位/字节) = 256字节 的话,那么最大单块密文长度就是256字节,最大单块明文长度就是256 - 11 = 245(字节)。

这里提供一个密钥对生成工具,在 <我的下载> 列表中,可以下载使用!

RSA分段加解密

上面引入网上的帖子可以看出,RSA加密一次最多只能加密明文的117字节(如果key长度为1024位的话),那么明文太多怎么办?只能分段加密了,很好懂的道理,把明文结成一段一段的,分别进行加密,加密之后把加密后的结果再进行拼接。

下面是分段加解密的过程。

 /**
     * 分段处理加解密数据,放到输出流中
     * create time: 2019年4月18日下午3:42:37
     * @param out       输出流
     * @param cipher    加解密工具
     * @param dataBytes 要处理的数据
     * @param maxBlock  处理的块的最大字节数
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    private static void handleData(ByteArrayOutputStream out, Cipher cipher, byte[] dataBytes, int maxBlock) throws IllegalBlockSizeException, BadPaddingException {
        //计算待加密的byte数组的长度
        int inputLen = dataBytes.length;
        int offSet = 0;
        int i = 0;
        byte[] cache;
        //循环减去已经被加密的长度(剩余长度)
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > maxBlock) {
         //加密操作
         //处理dataBytes字节数组的缓冲区从offset开始(包含)的前maxBlock个字节
                cache = cipher.doFinal(dataBytes, offSet, maxBlock);
            } else {
                cache = cipher.doFinal(dataBytes, offSet, inputLen - offSet);
            }
            //将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此 byte 数组输出流
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * maxBlock;
        }
    }

了解原理即可,会使用工具类就好啦!

七,SM4国密算法

此为对称加密算法。

该加密算法的验签方法值得一提!

签名:使用 SM3Util 的哈希算法对要签名的原文字符串进行计算得到签名字符串;

验签:对拿到的原文字符串再次进行签名,得到了一个新的签名字符串,对比前后两个签名是否一致。

该算法需要导入bcprov-jdk15on-1.59.jarmaven项目导入该jar包所对应的依赖。

        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk15on</artifactId>
            <version>1.64</version>
        </dependency>

SM4Util工具类

public class SM4Util {
    //算法名
    public static final String ALGORITHM_NAME = "SM4";
    public static final String ALGORITHM_NAME_ECB_PADDING = "SM4/ECB/PKCS5Padding";
    //密钥长度
    public static final int DEFAULT_KEY_SIZE = 128;

    //加密方法
     public static byte[] encrypt_Ecb_Padding(byte[] key, byte[] data)
        throws InvalidKeyException, NoSuchAlgorithmException, NoSuchProviderException,
        NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
        Cipher cipher = generateEcbCipher(ALGORITHM_NAME_ECB_PADDING, Cipher.ENCRYPT_MODE, key);
        return cipher.doFinal(data);
    }
    
    //解密方法
    public static byte[] decrypt_Ecb_Padding(byte[] key, byte[] cipherText)
        throws IllegalBlockSizeException, BadPaddingException, InvalidKeyException,
        NoSuchAlgorithmException, NoSuchProviderException, NoSuchPaddingException {
        Cipher cipher = generateEcbCipher(ALGORITHM_NAME_ECB_PADDING, Cipher.DECRYPT_MODE, key);
        return cipher.doFinal(cipherText);
    }
    
    //生成ECB暗号
     private static Cipher generateEcbCipher(String algorithmName, int mode, byte[] key)
        throws NoSuchAlgorithmException, NoSuchProviderException, NoSuchPaddingException,
        InvalidKeyException {
        Cipher cipher = Cipher.getInstance(algorithmName, BouncyCastleProvider.PROVIDER_NAME);
        Key sm4Key = new SecretKeySpec(key, ALGORITHM_NAME);
        cipher.init(mode, sm4Key);
        return cipher;
    }
    
    //生成指定长度的密钥
     public static byte[] generateKey() throws NoSuchAlgorithmException, NoSuchProviderException {
        return generateKey(DEFAULT_KEY_SIZE);
    }

    public static byte[] generateKey(int keySize) throws NoSuchAlgorithmException, NoSuchProviderException {
        KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM_NAME, BouncyCastleProvider.PROVIDER_NAME);
        kg.init(keySize, new SecureRandom());
        return kg.generateKey().getEncoded();
    }
}

SM3Util工具类

这是一个摘要算法,入参是待签名的byte[]数组,是签名使用的。

public class SM3Util  {
    public static byte[] hash(byte[] srcData) {
        SM3Digest digest = new SM3Digest();
        digest.update(srcData, 0, srcData.length);
        byte[] hash = new byte[digest.getDigestSize()];
        digest.doFinal(hash, 0);
        return hash;
    }
}

测试类

在下面的测试中,密钥key是现生成的,然后在调用加密和解密方法时直接传进去了,那么如何双方规定好指定的密钥key?比如说,A指定一个密钥key,A加密后把信息发送给B,B再使用该密钥Key进行解密,

所以,需要将生成的密钥(byte[] 数组类型)转为(字符串类型)并保存起来。

生成一个bKey进行加解密

public class DemoTest
{
    public static final String demo = "SM4加解密测试DEMO";
    public static void main(String[] args) throws Exception {

        // #######SM4加密#########
        //得到密钥key【bute[]数组类型的】
        byte[] bKey = SM4Util.generateKey();
        //进行加密
        byte[] sm4 = SM4Util.encrypt_Ecb_Padding(bKey,demo.getBytes("UTF-8"));
        String encData = Base64.encodeBase64String(sm4);
        System.out.println("密文:" + encData);
        //########SM4解密#########
        byte[] dd = SM4Util.decrypt_Ecb_Padding(bKey, Base64.decodeBase64(encData));
        String datainfo = new String(dd, "UTF-8");
        System.out.println("解密后的原文:" + datainfo);
        
        //########sign签名########
        byte[] signHash=SM3Util.hash(sortparam.getBytes("UTF-8"));
        StringBuilder signature = new StringBuilder();
        for (byte b : signHash) {
            signature.append(byteToHexString(b));
        }
        String sign=signature.toString();
        System.out.println("签名String值为:" + sign);
    }
        //######verify验签 省略#######
    
    public static String byteToHexString(byte ib) {
        char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
        char[] ob = new char[2];
        ob[0] = Digit[(ib >>> 4) & 0X0f];
        ob[1] = Digit[ib & 0X0F];
        String str = new String(ob);
        return str;
    }
}

如果上面的测试类报错的话,添加下面的代码块再试试!

static{
        Security.addProvider(new BouncyCastleProvider());
    }

把生成的bKey转成字符串保存起来(重复使用嘛,上面的是一次性的)

//生成key 
byte[] bKey = SM4Util.generateKey();
//把key转为字符串
String key = ByteUtils.toHexString(bKey);

然后把该字符串写入常量中

ByteUtils.fromHexString(bKey) 把字符串密钥转为byte【】数组

        String bKey="169b909483f5822975d316b6676b0a0a";
      byte[] sm4 = SM4Util.encrypt_Ecb_Padding(ByteUtils.fromHexString(bKey),demo.getBytes("UTF-8"));
        String encData = Base64.encodeBase64String(sm4);
        System.out.println("密文:" + encData);
byte[] dd = SM4Util.decrypt_Ecb_Padding(ByteUtils.fromHexString(bKey),Base64.decodeBase64(encData));
        String datainfo = new String(dd, "UTF-8");
        System.out.println("解密后的原文:" + datainfo);

看效果

  • 发表于 2020-01-19 18:01
  • 阅读 ( 273 )
  • 分类:网络文章

条评论

请先 登录 后评论
不写代码的码农
小编

篇文章

作家榜 »

  1. 小编 文章
返回顶部
部分文章转自于网络,若有侵权请联系我们删除