支付对接常用的加密方式介绍-凯发app官方网站

package aes;
import java.io.unsupportedencodingexception;
import java.nio.charset.standardcharsets;
import java.security.invalidkeyexception;
import java.security.nosuchalgorithmexception;
import java.security.securerandom;
import java.util.base64;
import javax.crypto.badpaddingexception;
import javax.crypto.cipher;
import javax.crypto.illegalblocksizeexception;
import javax.crypto.keygenerator;
import javax.crypto.nosuchpaddingexception;
import javax.crypto.secretkey;
import javax.crypto.spec.secretkeyspec;
public class aesutil {
    /**
     * aes加密字符串
     *
     * @param content
     *            需要被加密的字符串
     * @param password
     *            加密需要的密码
     * @return 密文
     */
    public static byte[] encrypt(string content, string password) {
        try {
            keygenerator kgen = keygenerator.getinstance("aes");// 创建aes的key生产者
            kgen.init(128, new securerandom(password.getbytes()));// 利用用户密码作为随机数初始化出
            //加密没关系，securerandom是生成安全随机数序列，password.getbytes()是种子，只要种子相同，序列就一样，所以解密只要有password就行
            secretkey secretkey = kgen.generatekey();// 根据用户密码，生成一个密钥
            byte[] encodeformat = secretkey.getencoded();// 返回基本编码格式的密钥，如果此密钥不支持编码，则返回
            secretkeyspec key = new secretkeyspec(encodeformat, "aes");// 转换为aes专用密钥
            cipher cipher = cipher.getinstance("aes");// 创建密码器
            byte[] bytecontent = content.getbytes("utf-8");
            cipher.init(cipher.encrypt_mode, key);// 初始化为加密模式的密码器
            byte[] result = cipher.dofinal(bytecontent);// 加密
            return result;
        } catch (nosuchpaddingexception e) {
            e.printstacktrace();
        } catch (nosuchalgorithmexception e) {
            e.printstacktrace();
        } catch (unsupportedencodingexception e) {
            e.printstacktrace();
        } catch (invalidkeyexception e) {
            e.printstacktrace();
        } catch (illegalblocksizeexception e) {
            e.printstacktrace();
        } catch (badpaddingexception e) {
            e.printstacktrace();
        }
        return null;
    }
    /**
     * 解密aes加密过的字符串
     *
     * @param content
     *            aes加密过过的内容
     * @param password
     *            加密时的密码
     * @return 明文
     */
    public static byte[] decrypt(byte[] content, string password) {
        try {
            keygenerator kgen = keygenerator.getinstance("aes");// 创建aes的key生产者
            kgen.init(128, new securerandom(password.getbytes()));
            secretkey secretkey = kgen.generatekey();// 根据用户密码，生成一个密钥
            byte[] encodeformat = secretkey.getencoded();// 返回基本编码格式的密钥
            secretkeyspec key = new secretkeyspec(encodeformat, "aes");// 转换为aes专用密钥
            cipher cipher = cipher.getinstance("aes");// 创建密码器
            cipher.init(cipher.decrypt_mode, key);// 初始化为解密模式的密码器
            byte[] result = cipher.dofinal(content);
            return result; // 明文   
        } catch (nosuchalgorithmexception e) {
            e.printstacktrace();
        } catch (nosuchpaddingexception e) {
            e.printstacktrace();
        } catch (invalidkeyexception e) {
            e.printstacktrace();
        } catch (illegalblocksizeexception e) {
            e.printstacktrace();
        } catch (badpaddingexception e) {
            e.printstacktrace();
        }
        return null;
    }
    public static void main(string[] args) throws exception {
        string a = base64.getencoder().encodetostring("435678(*&*&^*&^%&^$%^#%#!@#$%^&%�|8752$".getbytes(standardcharsets.utf_8));
        string b = new string(base64.getdecoder().decode(a.getbytes(standardcharsets.utf_8)));
        system.out.println(a ":" b);
        string content = "{'aaa':'111','bbb':'222'}";
        string secretkey = "43567890|8752$";
        system.out.println("需要加密的内容："   content);
        byte[] encrypt = encrypt(content, secretkey);
        system.out.println("加密后的2进制密文：");
        system.out.println(new string(encrypt));
        string hexstr = base64.getencoder().encodetostring(encrypt);
        system.out.println("base64编码后密文:"   hexstr);
        byte[] byte2 = base64.getdecoder().decode(hexstr);
        system.out.println("解码后转换为2进制后密文：");
        system.out.println(new string(byte2));
        byte[] decrypt = decrypt(byte2, secretkey);
        system.out.println("解密后的内容："   new string(decrypt,"utf-8"));
    }
} 

 result = generatersakey(default_rsa_key_size);\n        string publickey = result.get(\"publickey\");\n        string privatekey = result.get(\"privatekey\");\n//        string publickey = \"miibijanbgkqhkig9w0baqefaaocaq8amiibcgkcaqeauazymb25s/ueifwmm2h74736dqqe4bvrdgnfwltm4pzdunc84ntav41qegbztby47o57m/ydvf6vmxjh25ejlsbbhls7fd7xhtkorskzqlekh0xcs2xa/akdwllbewunzvwmuqy8x3j2vnrilxzvjvqyxkfy0itmo8fq1xso6b/s5/raekpttiepfb2ciu9vmrtlocsnjvotupdwcoc79lts0g1q5bv4dn+uca+8/gubhs7vbth3olzt6gxtrjjrpxht4lqwsczqwkqhpg/8jqgnfqs7+r0kcyemg/411iazi9wyrgtsqji8sq2q7halzrxvjn+as7jjpvyi67jgkwidaqab\";\n//        string privatekey = \"miievqibadanbgkqhkig9w0baqefaascbkcwggsjageaaoibaqc5rpkyhbmz+54h/awzyfvjvfp1bathu9eoa19aw0zg/n240lzie1q/jwosbtm1vljs7nub9gnv/q8xckfbl6owweggwzsupvedoq6uyrmot6qftekzbfr9qr3cwvt7bq3o9yy5dlxfepzwesgtfnwo+pjgqvjsk0yjx+rxfi7oh9ln9fp4qlo0h6kuhzwht28yu0ugkyenwho491zyglv0u1lsdvdkfxh2f5rxr7z+bruflu9u2hegtm3qbdngmms/gfpiwpawjmrcrac8b/wlcccwqzv5hqpzj6yb/jxuhpkj1zhezoxcolyxdarsccvlfe8mf4czumk+/klrskyragmbaaecggeabjc+8dvj4j1n+2iu4g2tqt2pqsf+lcx/3tc7+b49jo8puuucvwy3znuhktkzrxzisxv2aralslnicgswyrreigmmjb00jgs/llm/sxkhwxmt7iezxbmjuvtnc7jy+3qcrti+9vh4w1kehaqb8opl8hvobiu3m2kglog20a7sym5gpicub3eq6p30u47y7i2wsbmnmmu79rpu3q7lsneob9kdvv6ea6vukl3chy1qxfh6ofzs1ynjfjxy5rxt8u5juhr5lyrnop8mevptbtrh34ssm0uyckkgj6josrdjqo/dj**xixj+bwgg5/xbnq3pfeyeaqkrtzy+fmhsufoaqkbgqdpqpxpl05mduxcnc7i6f8lzqjnjzu1h9zwkuqe94fs3i3siws62sjx1pz66p9eeiost0t4ye9ndx2x04yyfucenhydftq5m5m9e2q1kkdnebut6xy4wcribkozuq07mlysn0kdbuimp/erp2w3hl5nzu/elkdjt7ym0otv3upp5wkbgqdlbyc4hcvk+f1kd/xjq2ljwf+c8khhfrllripf7qtb24dcrauwxbagbbckxx2g+3waswyf09ndaliwab/juuuhjm0ygxyr0k5lhci0/ec7hd3twtl/hryef3umkzekbqypzneyme6t0lsqjl3mxfqlqumu4h677qa9/dnh7dyhhqkbgqcfam/bj6s7iba6jvfmozpi91bkvraawlgbxl7nt/nu0ncgzc0vd6wxgj3hqorgltu0krfv8pfp45qkphnwga8xd5gduiw68500zum8chdygeqejvvjvnuhqfnfexmirpfjnpqkcnrqxwk5cvmtci7+ys/fw0uwddivamcbn4auawkbgcogvaivnk6wefeeqqtsl6uozjaypbionek4src2fpinmdnlgmyvbmm51/lzealqa5p6fv2ipd4gae4nmznew+4qprswgudk3+ijw1sfk7qdwkzpeivpvddawyeshb8a22tpwwvae5er3m459avup8ubvw4rodxd4ka6gu1fh31paogaynpkjncrdosqh0nkh0ld44ch6hd+zcztoad2eqk0t2spnkbsis1s9w0adreoxuv1edo/hn3p/bctucaax7ijtscs2f0atc/nia6ljbnk7oubbzib9v21l72zvz5st4c/h7izbqcxfs81489a7tthp+e1hzs/xepfto0pakr1gj0=\";\n        system.out.println(\"公钥为：\" + publickey);\n        system.out.println(\"私钥为：\" + privatekey);\n        string plaintext = \"{'a':'1111','b':'2222'}\";\n        string ciphertext = null;\n        try {\n            system.out.println(\"开始加密明文：\"+plaintext);\n            ciphertext = encrypt(plaintext,publickey);\n        } catch (exception e) {\n            system.out.println(\"加密失败\");\n            throw new runtimeexception(e);\n        }\n        system.out.println(\"得到的密文为：\"+ciphertext);\n        string deciphering = decrypt(ciphertext,privatekey);\n        system.out.println(\"解密后：\"+deciphering);\n    }\n    /**\n     * 生成rsa 公私钥,可选长度为1025,2048位.\n     */\n    public static map generatersakey(int keysize) {\n        map result = new hashmap<>(2);\n        try {\n            keypairgenerator keypairgen = keypairgenerator.getinstance(key_algorithm);\n            // 初始化密钥对生成器，密钥大小为1024 2048位\n            keypairgen.initialize(keysize, new securerandom());\n            // 生成一个密钥对，保存在keypair中\n            keypair keypair = keypairgen.generatekeypair();\n            // 得到公钥字符串\n            result.put(\"publickey\", new string(base64.getencoder().encode(keypair.getpublic().getencoded())));\n            // 得到私钥字符串\n            result.put(\"privatekey\", new string(base64.getencoder().encode(keypair.getprivate().getencoded())));\n        } catch (generalsecurityexception e) {\n            e.printstacktrace();\n        }\n        return result;\n    }\n\n    /**\n     * rsa私钥解密\n     * @param str  解密字符串\n     * @param privatekey  私钥\n     * @return 明文\n     */\n    public static string decrypt(string str, string privatekey) {\n        //64位解码加密后的字符串\n        byte[] inputbyte;\n        string outstr = \"\";\n        try {\n            inputbyte = base64.getdecoder().decode(str.getbytes(\"utf-8\"));\n            //base64编码的私钥\n            byte[] decoded = base64.getdecoder().decode(privatekey);\n            rsaprivatekey prikey = (rsaprivatekey) keyfactory.getinstance(\"rsa\").generateprivate(new pkcs8encodedkeyspec(decoded));\n            //rsa解密\n            cipher cipher = cipher.getinstance(\"rsa\");\n            cipher.init(cipher.decrypt_mode, prikey);\n            outstr = new string(cipher.dofinal(inputbyte));\n        } catch (unsupportedencodingexception | nosuchpaddingexception | invalidkeyexception | illegalblocksizeexception | badpaddingexception | invalidkeyspecexception | nosuchalgorithmexception e) {\n            e.printstacktrace();\n        }\n        return outstr;\n    }\n\n    /**\n     *  rsa公钥加密\n     * @param str 需要加密的字符串\n     * @param publickey 公钥\n     * @return 密文\n     * @throws exception 加密过程中的异常信息\n     */\n    public static string encrypt(string str, string publickey) throws exception {\n        //base64编码的公钥\n        byte[] decoded = base64.getdecoder().decode(publickey);\n        rsapublickey pubkey = (rsapublickey) keyfactory.getinstance(\"rsa\").generatepublic(new x509encodedkeyspec(decoded));\n        //rsa加密\n        cipher cipher = cipher.getinstance(\"rsa\");\n        cipher.init(cipher.encrypt_mode, pubkey);\n        string outstr = base64.getencoder().encodetostring(cipher.dofinal(str.getbytes(\"utf-8\")));\n        return outstr;\n    }\n    public static string sign(string data, string prikey) throws exception {\n        byte[] decoded = base64.getdecoder().decode(prikey);\n        keyfactory keyfactory = keyfactory.getinstance(\"rsa\");\n        privatekey privatekey = keyfactory.generateprivate(new x509encodedkeyspec(decoded));\n        signature signature = signature.getinstance(\"md5withrsa\");\n        signature.initsign(privatekey);\n        signature.update(data.getbytes());\n\n        return new string(base64.getencoder().encode(signature.sign()));\n    }\n    public static boolean verify(string pubkey, string sign, string data) throws exception{\n        //获取keyfactory，指定rsa算法\n        keyfactory keyfactory = keyfactory.getinstance(\"rsa\");\n        //将base64编码的公钥字符串进行解码\n        byte[] encodebyte = base64.getdecoder().decode(pubkey);\n        //将base64解码后的字节数组，构造成x509encodedkeyspec对象，生成公钥对象\n        publickey publickey = keyfactory.generatepublic(new x509encodedkeyspec(encodebyte));\n        signature signature = signature.getinstance(\"md5withrsa\");\n        //加载公钥\n        signature.initverify(publickey);\n        //更新原数据\n        signature.update(data.getbytes(\"utf-8\"));\n        //公钥验签（true-验签通过；false-验签失败）\n        return signature.verify(base64.getdecoder().decode(sign));\n    }\n}\n\n","classes":null}" data-cke-widget-keep-attr="0" data-cke-widget-upcasted="1" data-widget="codesnippet">package rsasha256;
import javax.crypto.badpaddingexception;
import javax.crypto.cipher;
import javax.crypto.illegalblocksizeexception;
import javax.crypto.nosuchpaddingexception;
import java.io.unsupportedencodingexception;
import java.security.*;
import java.security.interfaces.rsaprivatekey;
import java.security.interfaces.rsapublickey;
import java.security.spec.invalidkeyspecexception;
import java.security.spec.pkcs8encodedkeyspec;
import java.security.spec.x509encodedkeyspec;
import java.util.base64;
import java.util.hashmap;
import java.util.map;
public class rsautil {
    private static final int default_rsa_key_size = 2048;
    private static final string key_algorithm = "rsa";
    private static final string signature_algorithm = "md5withrsa";
    public static void main(string [] args){
        map result = generatersakey(default_rsa_key_size);
        string publickey = result.get("publickey");
        string privatekey = result.get("privatekey");
//        string publickey = "miibijanbgkqhkig9w0baqefaaocaq8amiibcgkcaqeauazymb25s/ueifwmm2h74736dqqe4bvrdgnfwltm4pzdunc84ntav41qegbztby47o57m/ydvf6vmxjh25ejlsbbhls7fd7xhtkorskzqlekh0xcs2xa/akdwllbewunzvwmuqy8x3j2vnrilxzvjvqyxkfy0itmo8fq1xso6b/s5/raekpttiepfb2ciu9vmrtlocsnjvotupdwcoc79lts0g1q5bv4dn uca 8/gubhs7vbth3olzt6gxtrjjrpxht4lqwsczqwkqhpg/8jqgnfqs7 r0kcyemg/411iazi9wyrgtsqji8sq2q7halzrxvjn as7jjpvyi67jgkwidaqab";
//        string privatekey = "miievqibadanbgkqhkig9w0baqefaascbkcwggsjageaaoibaqc5rpkyhbmz 54h/awzyfvjvfp1bathu9eoa19aw0zg/n240lzie1q/jwosbtm1vljs7nub9gnv/q8xckfbl6owweggwzsupvedoq6uyrmot6qftekzbfr9qr3cwvt7bq3o9yy5dlxfepzwesgtfnwo pjgqvjsk0yjx rxfi7oh9ln9fp4qlo0h6kuhzwht28yu0ugkyenwho491zyglv0u1lsdvdkfxh2f5rxr7z bruflu9u2hegtm3qbdngmms/gfpiwpawjmrcrac8b/wlcccwqzv5hqpzj6yb/jxuhpkj1zhezoxcolyxdarsccvlfe8mf4czumk /klrskyragmbaaecggeabjc 8dvj4j1n 2iu4g2tqt2pqsf lcx/3tc7 b49jo8puuucvwy3znuhktkzrxzisxv2aralslnicgswyrreigmmjb00jgs/llm/sxkhwxmt7iezxbmjuvtnc7jy 3qcrti 9vh4w1kehaqb8opl8hvobiu3m2kglog20a7sym5gpicub3eq6p30u47y7i2wsbmnmmu79rpu3q7lsneob9kdvv6ea6vukl3chy1qxfh6ofzs1ynjfjxy5rxt8u5juhr5lyrnop8mevptbtrh34ssm0uyckkgj6josrdjqo/dj**xixj bwgg5/xbnq3pfeyeaqkrtzy fmhsufoaqkbgqdpqpxpl05mduxcnc7i6f8lzqjnjzu1h9zwkuqe94fs3i3siws62sjx1pz66p9eeiost0t4ye9ndx2x04yyfucenhydftq5m5m9e2q1kkdnebut6xy4wcribkozuq07mlysn0kdbuimp/erp2w3hl5nzu/elkdjt7ym0otv3upp5wkbgqdlbyc4hcvk f1kd/xjq2ljwf c8khhfrllripf7qtb24dcrauwxbagbbckxx2g 3waswyf09ndaliwab/juuuhjm0ygxyr0k5lhci0/ec7hd3twtl/hryef3umkzekbqypzneyme6t0lsqjl3mxfqlqumu4h677qa9/dnh7dyhhqkbgqcfam/bj6s7iba6jvfmozpi91bkvraawlgbxl7nt/nu0ncgzc0vd6wxgj3hqorgltu0krfv8pfp45qkphnwga8xd5gduiw68500zum8chdygeqejvvjvnuhqfnfexmirpfjnpqkcnrqxwk5cvmtci7 ys/fw0uwddivamcbn4auawkbgcogvaivnk6wefeeqqtsl6uozjaypbionek4src2fpinmdnlgmyvbmm51/lzealqa5p6fv2ipd4gae4nmznew 4qprswgudk3 ijw1sfk7qdwkzpeivpvddawyeshb8a22tpwwvae5er3m459avup8ubvw4rodxd4ka6gu1fh31paogaynpkjncrdosqh0nkh0ld44ch6hd zcztoad2eqk0t2spnkbsis1s9w0adreoxuv1edo/hn3p/bctucaax7ijtscs2f0atc/nia6ljbnk7oubbzib9v21l72zvz5st4c/h7izbqcxfs81489a7tthp e1hzs/xepfto0pakr1gj0=";
        system.out.println("公钥为："   publickey);
        system.out.println("私钥为："   privatekey);
        string plaintext = "{'a':'1111','b':'2222'}";
        string ciphertext = null;
        try {
            system.out.println("开始加密明文：" plaintext);
            ciphertext = encrypt(plaintext,publickey);
        } catch (exception e) {
            system.out.println("加密失败");
            throw new runtimeexception(e);
        }
        system.out.println("得到的密文为：" ciphertext);
        string deciphering = decrypt(ciphertext,privatekey);
        system.out.println("解密后：" deciphering);
    }
    /**
     * 生成rsa 公私钥,可选长度为1025,2048位.
     */
    public static map generatersakey(int keysize) {
        map result = new hashmap<>(2);
        try {
            keypairgenerator keypairgen = keypairgenerator.getinstance(key_algorithm);
            // 初始化密钥对生成器，密钥大小为1024 2048位
            keypairgen.initialize(keysize, new securerandom());
            // 生成一个密钥对，保存在keypair中
            keypair keypair = keypairgen.generatekeypair();
            // 得到公钥字符串
            result.put("publickey", new string(base64.getencoder().encode(keypair.getpublic().getencoded())));
            // 得到私钥字符串
            result.put("privatekey", new string(base64.getencoder().encode(keypair.getprivate().getencoded())));
        } catch (generalsecurityexception e) {
            e.printstacktrace();
        }
        return result;
    }
    /**
     * rsa私钥解密
     * @param str  解密字符串
     * @param privatekey  私钥
     * @return 明文
     */
    public static string decrypt(string str, string privatekey) {
        //64位解码加密后的字符串
        byte[] inputbyte;
        string outstr = "";
        try {
            inputbyte = base64.getdecoder().decode(str.getbytes("utf-8"));
            //base64编码的私钥
            byte[] decoded = base64.getdecoder().decode(privatekey);
            rsaprivatekey prikey = (rsaprivatekey) keyfactory.getinstance("rsa").generateprivate(new pkcs8encodedkeyspec(decoded));
            //rsa解密
            cipher cipher = cipher.getinstance("rsa");
            cipher.init(cipher.decrypt_mode, prikey);
            outstr = new string(cipher.dofinal(inputbyte));
        } catch (unsupportedencodingexception | nosuchpaddingexception | invalidkeyexception | illegalblocksizeexception | badpaddingexception | invalidkeyspecexception | nosuchalgorithmexception e) {
            e.printstacktrace();
        }
        return outstr;
    }
    /**
     *  rsa公钥加密
     * @param str 需要加密的字符串
     * @param publickey 公钥
     * @return 密文
     * @throws exception 加密过程中的异常信息
     */
    public static string encrypt(string str, string publickey) throws exception {
        //base64编码的公钥
        byte[] decoded = base64.getdecoder().decode(publickey);
        rsapublickey pubkey = (rsapublickey) keyfactory.getinstance("rsa").generatepublic(new x509encodedkeyspec(decoded));
        //rsa加密
        cipher cipher = cipher.getinstance("rsa");
        cipher.init(cipher.encrypt_mode, pubkey);
        string outstr = base64.getencoder().encodetostring(cipher.dofinal(str.getbytes("utf-8")));
        return outstr;
    }
    public static string sign(string data, string prikey) throws exception {
        byte[] decoded = base64.getdecoder().decode(prikey);
        keyfactory keyfactory = keyfactory.getinstance("rsa");
        privatekey privatekey = keyfactory.generateprivate(new x509encodedkeyspec(decoded));
        signature signature = signature.getinstance("md5withrsa");
        signature.initsign(privatekey);
        signature.update(data.getbytes());
        return new string(base64.getencoder().encode(signature.sign()));
    }
    public static boolean verify(string pubkey, string sign, string data) throws exception{
        //获取keyfactory，指定rsa算法
        keyfactory keyfactory = keyfactory.getinstance("rsa");
        //将base64编码的公钥字符串进行解码
        byte[] encodebyte = base64.getdecoder().decode(pubkey);
        //将base64解码后的字节数组，构造成x509encodedkeyspec对象，生成公钥对象
        publickey publickey = keyfactory.generatepublic(new x509encodedkeyspec(encodebyte));
        signature signature = signature.getinstance("md5withrsa");
        //加载公钥
        signature.initverify(publickey);
        //更新原数据
        signature.update(data.getbytes("utf-8"));
        //公钥验签（true-验签通过；false-验签失败）
        return signature.verify(base64.getdecoder().decode(sign));
    }
} 

package md5;
import java.nio.charset.standardcharsets;
import java.security.messagedigest;
import java.security.nosuchalgorithmexception;
public class md5util {
    public static void main(string[] args) {
        string sha256str = getsha256str("123456");
        system.out.println(sha256str);
    }
    /**
     * sha256加密
     *
     * @param str 要加密的字符串
     * @return 加密后的字符串
     */
    public static string getsha256str(string str) {
        messagedigest messagedigest;
        string encodestr = "";
        try {
            messagedigest = messagedigest.getinstance("md5");
            messagedigest.update(str.getbytes(standardcharsets.utf_8));
            encodestr = byte2hex(messagedigest.digest());
        } catch (nosuchalgorithmexception e) {
            e.printstacktrace();
        }
        return encodestr;
    }
    /**
     * sha256加密 将byte转为16进制
     *
     * @param bytes 字节码
     * @return 加密后的字符串
     */
    private static string byte2hex(byte[] bytes) {
        stringbuilder stringbuilder = new stringbuilder();
        string temp;
        for (byte abyte : bytes) {
            temp = integer.tohexstring(abyte & 0xff);
            if (temp.length() == 1) {
                //1得到一位的进行补0操作
                stringbuilder.append("0");
            }
            stringbuilder.append(temp);
        }
        return stringbuilder.tostring();
    }
} 

package rsasha256;
import java.nio.charset.standardcharsets;
import java.security.messagedigest;
import java.security.nosuchalgorithmexception;
public class sha256util {
    public static void main(string[] args) {
        string sha256str = getsha256str("123456");
        system.out.println(sha256str);
    }
    /**
     * sha256加密
     *
     * @param str 要加密的字符串
     * @return 加密后的字符串
     */
    public static string getsha256str(string str) {
        messagedigest messagedigest;
        string encodestr = "";
        try {
            messagedigest = messagedigest.getinstance("sha-256"); 
            messagedigest.update(str.getbytes(standardcharsets.utf_8));
            encodestr = byte2hex(messagedigest.digest());
        } catch (nosuchalgorithmexception e) {
            e.printstacktrace();
        }
        return encodestr;
    }
    /**
     * sha256加密 将byte转为16进制
     *
     * @param bytes 字节码
     * @return 加密后的字符串
     */
    private static string byte2hex(byte[] bytes) {
        stringbuilder stringbuilder = new stringbuilder();
        string temp;
        for (byte abyte : bytes) {
            temp = integer.tohexstring(abyte & 0xff);
            if (temp.length() == 1) {
                //1得到一位的进行补0操作
                stringbuilder.append("0");
            }
            stringbuilder.append(temp);
        }
        return stringbuilder.tostring();
    }
} 

package gmsm;
import org.bouncycastle.asn1.gm.gmnamedcurves;
import org.bouncycastle.asn1.x9.x9ecparameters;
import org.bouncycastle.crypto.cryptoexception;
import org.bouncycastle.crypto.invalidciphertextexception;
import org.bouncycastle.crypto.engines.sm2engine;
import org.bouncycastle.crypto.params.*;
import org.bouncycastle.crypto.signers.sm2signer;
import org.bouncycastle.jce.provider.bouncycastleprovider;
import org.bouncycastle.math.ec.eccurve;
import org.bouncycastle.math.ec.ecpoint;
import org.bouncycastle.util.strings;
import org.bouncycastle.util.encoders.base64;
import org.bouncycastle.util.encoders.hex;
import java.math.biginteger;
import java.nio.charset.charset;
import java.security.keypair;
import java.security.keypairgenerator;
import java.security.nosuchalgorithmexception;
import java.security.securerandom;
import java.security.spec.ecgenparameterspec;
/**
 * sm2 工具类
 * */
public class sm2util {
    //sm2推荐曲线名称
    static string sm2_curve_name = "sm2p256v1";
    public static final charset utf_8 = charset.forname("utf-8");
    /**
     * 生成密钥
     *
     * @return
     * @throws exception
     */
    public static  keypair genkeypair() throws exception {
        final ecgenparameterspec sm2spec = new ecgenparameterspec(sm2_curve_name);
        // 获取一个椭圆曲线类型的密钥对生成器
        final keypairgenerator kpg = keypairgenerator.getinstance("ec", new bouncycastleprovider());
        securerandom random = new securerandom();
        // 使用sm2的算法区域初始化密钥生成器
        kpg.initialize(sm2spec, random);
        // 获取密钥对
        keypair keypair = kpg.generatekeypair();
        return keypair;
    }
    /**sm2根据公钥加密
     * param: message 待加密内容 ， publickey 加密公钥（base64编码）
     * return: 加密信息的base64编码
     * @throws invalidciphertextexception 
     * */
    public static string  encryptbysm2(string message, string publickey) throws invalidciphertextexception  {
        ecdomainparameters domin = getdomain();
        //公钥对象
        ecpublickeyparameters pubkeyparameters = getpubkey(publickey,domin);
        byte[] cipherbytes  = new byte[0];
        
        cipherbytes = encrypt(sm2engine.mode.c1c3c2, pubkeyparameters, message.getbytes(utf_8));
        
        return base64.tobase64string(cipherbytes);
    }
    /**
     * sm2根据私钥解密
     * param： ciphertext 待解密密文   privatekey-私钥（base64编码）
     * */
    public static string decryptbysm2(string ciphertext, string privatekey) throws invalidciphertextexception {
        biginteger d = new biginteger(1,base64.decode(privatekey));
        ecdomainparameters domin = getdomain();
        //私钥对象
        ecprivatekeyparameters ecprivatekeyparameters = new ecprivatekeyparameters(d, domin);
        byte[] decrypt = decrypt(sm2engine.mode.c1c3c2, ecprivatekeyparameters, base64.decode(ciphertext));
        return new string(decrypt,utf_8);
    }
    /**
    * 根据公钥字符串创建公钥对象
    *
    * */
    public static ecpublickeyparameters getpubkey(string publickey, ecdomainparameters domain) {
        eccurve curve = domain.getcurve();
        ecpoint point = curve.decodepoint(base64.decode(publickey));
        ecpublickeyparameters publickey = new ecpublickeyparameters(point, domain);
        return publickey;
    }
    /**
     * @param mode             指定密文结构，旧标准的为c1c2c3，新的[《sm2密码算法使用规范》 gm/t 0009-2012]标准为c1c3c2
     * @param pubkeyparameters 公钥
     * @param srcdata          原文
     * @return 根据mode不同，输出的密文c1c2c3排列顺序不同。c1为65字节第1字节为压缩标识，这里固定为0x04，后面64字节为xy分量各32字节。c3为32字节。c2长度与原文一致。
     * @throws invalidciphertextexception
     */
    public static byte[] encrypt(sm2engine.mode mode, ecpublickeyparameters pubkeyparameters, byte[] srcdata)
            throws invalidciphertextexception {
        sm2engine engine = new sm2engine(mode);
        parameterswithrandom pwr = new parameterswithrandom(pubkeyparameters, new securerandom());
        engine.init(true, pwr);
        return engine.processblock(srcdata, 0, srcdata.length);
    }
    /**
     * @param mode             指定密文结构，旧标准的为c1c2c3，新的[《sm2密码算法使用规范》 gm/t 0009-2012]标准为c1c3c2
     * @param prikeyparameters 私钥
     * @param sm2cipher        根据mode不同，需要输入的密文c1c2c3排列顺序不同。c1为65字节第1字节为压缩标识，这里固定为0x04，后面64字节为xy分量各32字节。c3为32字节。c2长度与原文一致。
     * @return 原文。sm2解密返回了数据则一定是原文，因为sm2自带校验，如果密文被篡改或者密钥对不上，都是会直接报异常的。
     * @throws invalidciphertextexception
     */
    public static byte[] decrypt(sm2engine.mode mode, ecprivatekeyparameters prikeyparameters, byte[] sm2cipher)
            throws invalidciphertextexception {
        sm2engine engine = new sm2engine(mode);
        engine.init(false, prikeyparameters);
        return engine.processblock(sm2cipher, 0, sm2cipher.length);
    }
    public static ecdomainparameters getdomain() {
        //获取一条sm2曲线参数
        x9ecparameters x9ecparameters = gmnamedcurves.getbyname(sm2_curve_name);
        //构造domain参数
        ecdomainparameters domain = new ecdomainparameters(
                x9ecparameters.getcurve(),
                x9ecparameters.getg(),
                x9ecparameters.getn(),
                x9ecparameters.geth()
        );
        return domain;
    }
    /**
     * 私钥签名
     * @param privatekey    私钥
     * @param content       待签名内容
     * @return
     */
    public static string sign(string privatekey, string content) throws cryptoexception, cryptoexception {
        //待签名内容转为字节数组
        byte[] message = content.getbytes();
        biginteger domainparameters = new biginteger(1,base64.decode(privatekey));
        ecdomainparameters domin = getdomain();
        //私钥对象
        ecprivatekeyparameters privatekeyparameters = new ecprivatekeyparameters(domainparameters, domin);
        //创建签名实例
        sm2signer sm2signer = new sm2signer();
        //初始化签名实例,带上id,国密的要求,id默认值:1234567812345678
        try {
            sm2signer.init(true, new parameterswithid(new parameterswithrandom(privatekeyparameters, securerandom.getinstance("sha1prng")), strings.tobytearray("1234567812345678")));
        } catch (nosuchalgorithmexception e) {
            e.printstacktrace();
        }
        sm2signer.update(message, 0, message.length);
        //生成签名,签名分为两部分r和s,分别对应索引0和1的数组
        byte[] signbytes = sm2signer.generatesignature();
        string sign = base64.tobase64string(signbytes);
        return sign;
    }
    /**
     * 验证签名
     * @param publickey     公钥
     * @param content       待签名内容
     * @param sign          签名值
     * @return
     */
    public static boolean verify(string publickey, string content, string sign) {
        //待签名内容
        byte[] message = content.getbytes();
        byte[] signdata = base64.decode(sign);
        // 获取一条sm2曲线参数
        x9ecparameters sm2ecparameters = gmnamedcurves.getbyname(sm2_curve_name);
        // 构造domain参数
        ecdomainparameters domainparameters = new ecdomainparameters(sm2ecparameters.getcurve(),
                sm2ecparameters.getg(),
                sm2ecparameters.getn());
        //提取公钥点
        ecpoint pukpoint = sm2ecparameters.getcurve().decodepoint(java.util.base64.getdecoder().decode(publickey));
        // 公钥前面的02或者03表示是压缩公钥，04表示未压缩公钥, 04的时候，可以去掉前面的04
        ecpublickeyparameters publickeyparameters = new ecpublickeyparameters(pukpoint, domainparameters);
        //创建签名实例
        sm2signer sm2signer = new sm2signer();
        parameterswithid parameterswithid = new parameterswithid(publickeyparameters, strings.tobytearray("1234567812345678"));
        sm2signer.init(false, parameterswithid);
        sm2signer.update(message, 0, message.length);
        //验证签名结果
        boolean verify = sm2signer.verifysignature(signdata);
        return verify;
    }
} 

package gmsm;
import org.bouncycastle.crypto.digests.sm3digest;
import org.bouncycastle.util.encoders.hex;
import java.util.arrays;
public class sm3util {
    /**
     * 计算sm3摘要值
     *
     * @param srcdata 原文
     * @return 摘要值，对于sm3算法来说是32字节
     */
    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;
    }
    /**
     * 验证摘要
     *
     * @param srcdata 原文
     * @param sm3hash 摘要值
     * @return 返回true标识验证成功，false标识验证失败
     */
    public static boolean verify(byte[] srcdata, byte[] sm3hash) {
        byte[] newhash = hash(srcdata);
        system.out.println(hex.tohexstring(newhash));
        system.out.println(hex.tohexstring(sm3hash));
        if (arrays.equals(newhash, sm3hash)) {
            return true;
        } else {
            return false;
        }
    }
} 

package gmsm;
import org.bouncycastle.jce.provider.bouncycastleprovider;
import javax.crypto.cipher;
import javax.crypto.keygenerator;
import javax.crypto.spec.ivparameterspec;
import javax.crypto.spec.secretkeyspec;
import java.security.*;
public class sm4util {
    static {
        security.addprovider(new bouncycastleprovider());
    }
    public static final string algorithm_name = "sm4"; // aes
    public static final string default_key = "random_seed";
    // 128-32位16进制；256-64位16进制
    public static final int default_key_size = 128;
    public static byte[] generatekey() throws nosuchalgorithmexception, nosuchproviderexception {
        return generatekey(default_key, default_key_size);
    }
    public static byte[] generatekey(string seed) throws nosuchalgorithmexception, nosuchproviderexception {
        return generatekey(seed, default_key_size);
    }
    public static byte[] generatekey(string seed, int keysize) throws nosuchalgorithmexception, nosuchproviderexception {
        keygenerator kg = keygenerator.getinstance(algorithm_name, bouncycastleprovider.provider_name);
        securerandom random = securerandom.getinstance("sha1prng");
        if (null != seed && !"".equals(seed)) {
            random.setseed(seed.getbytes());
        }
        kg.init(keysize, random);
        return kg.generatekey().getencoded();
    }
    /**
     * @description 加密
     */
    public static byte[] encrypt(string algorithmname, byte[] key, byte[] iv, byte[] data) throws exception {
        return sm4core(algorithmname, cipher.encrypt_mode, key, iv, data);
    }
    /**
     * @description 解密
     */
    public static byte[] decrypt(string algorithmname, byte[] key, byte[] iv, byte[] data) throws exception {
        return sm4core(algorithmname, cipher.decrypt_mode, key, iv, data);
    }
    private static byte[] sm4core(string algorithmname, int type, byte[] key, byte[] iv, byte[] data) throws exception {
        cipher cipher = cipher.getinstance(algorithmname, bouncycastleprovider.provider_name);
        key sm4key = new secretkeyspec(key, algorithm_name);
        if (algorithmname.contains("/ecb/")) {
            cipher.init(type, sm4key);
        } else {
            if(iv == null ){
                cipher.init(type, sm4key);
            }else{
                ivparameterspec ivparameterspec = new ivparameterspec(iv);
                cipher.init(type, sm4key, ivparameterspec);
            }
        }
        return cipher.dofinal(data);
    }
} 

{
    "data": "auwpdinowtdseztfccr8b1opsevje1mqivoln56wdvw3gjkssjkpmgp4lpyiqzkj9g2ptayc2dzsiyhbjtlvfnje54mzz649gtwqvihan5fzv8vs3jl3kf9wb0br9ebr07qrfglwcvkkgktmtfds/4qqgywn7tvq3eh6hwqi7kuf0glz9cycyhki4/f61s6h9hws cprhchgfjmhnu 835dsvs4ijona 0s5jxwven/is5i5cmxfb3ruyzbfpu 7jldgcxlc8onkizxse1axhofmj4cttycyrxkncd015fnbmkh 7tyheksyyybtvjkpqdeczgt3z qvj9vdyuzb1q==",
    "sign": "d3b36e7a837d6241445e506faf72c8d8e3467ee9c11efae0c67dfb5b15f44b6e"
} 

 jsondata = new hashmap<>();\n\n        string publickey = \"miibijanbgkqhkig9w0baqefaaocaq8amiibcgkcaqeauazymb25s/ueifwmm2h74736dqqe4bvrdgnfwltm4pzdunc84ntav41qegbztby47o57m/ydvf6vmxjh25ejlsbbhls7fd7xhtkorskzqlekh0xcs2xa/akdwllbewunzvwmuqy8x3j2vnrilxzvjvqyxkfy0itmo8fq1xso6b/s5/raekpttiepfb2ciu9vmrtlocsnjvotupdwcoc79lts0g1q5bv4dn+uca+8/gubhs7vbth3olzt6gxtrjjrpxht4lqwsczqwkqhpg/8jqgnfqs7+r0kcyemg/411iazi9wyrgtsqji8sq2q7halzrxvjn+as7jjpvyi67jgkwidaqab\";\n        string privatekey = \"miievqibadanbgkqhkig9w0baqefaascbkcwggsjageaaoibaqc5rpkyhbmz+54h/awzyfvjvfp1bathu9eoa19aw0zg/n240lzie1q/jwosbtm1vljs7nub9gnv/q8xckfbl6owweggwzsupvedoq6uyrmot6qftekzbfr9qr3cwvt7bq3o9yy5dlxfepzwesgtfnwo+pjgqvjsk0yjx+rxfi7oh9ln9fp4qlo0h6kuhzwht28yu0ugkyenwho491zyglv0u1lsdvdkfxh2f5rxr7z+bruflu9u2hegtm3qbdngmms/gfpiwpawjmrcrac8b/wlcccwqzv5hqpzj6yb/jxuhpkj1zhezoxcolyxdarsccvlfe8mf4czumk+/klrskyragmbaaecggeabjc+8dvj4j1n+2iu4g2tqt2pqsf+lcx/3tc7+b49jo8puuucvwy3znuhktkzrxzisxv2aralslnicgswyrreigmmjb00jgs/llm/sxkhwxmt7iezxbmjuvtnc7jy+3qcrti+9vh4w1kehaqb8opl8hvobiu3m2kglog20a7sym5gpicub3eq6p30u47y7i2wsbmnmmu79rpu3q7lsneob9kdvv6ea6vukl3chy1qxfh6ofzs1ynjfjxy5rxt8u5juhr5lyrnop8mevptbtrh34ssm0uyckkgj6josrdjqo/dj**xixj+bwgg5/xbnq3pfeyeaqkrtzy+fmhsufoaqkbgqdpqpxpl05mduxcnc7i6f8lzqjnjzu1h9zwkuqe94fs3i3siws62sjx1pz66p9eeiost0t4ye9ndx2x04yyfucenhydftq5m5m9e2q1kkdnebut6xy4wcribkozuq07mlysn0kdbuimp/erp2w3hl5nzu/elkdjt7ym0otv3upp5wkbgqdlbyc4hcvk+f1kd/xjq2ljwf+c8khhfrllripf7qtb24dcrauwxbagbbckxx2g+3waswyf09ndaliwab/juuuhjm0ygxyr0k5lhci0/ec7hd3twtl/hryef3umkzekbqypzneyme6t0lsqjl3mxfqlqumu4h677qa9/dnh7dyhhqkbgqcfam/bj6s7iba6jvfmozpi91bkvraawlgbxl7nt/nu0ncgzc0vd6wxgj3hqorgltu0krfv8pfp45qkphnwga8xd5gduiw68500zum8chdygeqejvvjvnuhqfnfexmirpfjnpqkcnrqxwk5cvmtci7+ys/fw0uwddivamcbn4auawkbgcogvaivnk6wefeeqqtsl6uozjaypbionek4src2fpinmdnlgmyvbmm51/lzealqa5p6fv2ipd4gae4nmznew+4qprswgudk3+ijw1sfk7qdwkzpeivpvddawyeshb8a22tpwwvae5er3m459avup8ubvw4rodxd4ka6gu1fh31paogaynpkjncrdosqh0nkh0ld44ch6hd+zcztoad2eqk0t2spnkbsis1s9w0adreoxuv1edo/hn3p/bctucaax7ijtscs2f0atc/nia6ljbnk7oubbzib9v21l72zvz5st4c/h7izbqcxfs81489a7tthp+e1hzs/xepfto0pakr1gj0=\";\n\n        string salt = \"e4bvrdg\";\n        system.out.println(\"公钥为：\" + publickey);\n        string plaintext = \"{'a':'1111','b':'2222'}\";\n        string ciphertext = null;\n        string sign = null;\n        try {\n            ciphertext = rsautil.encrypt(plaintext,publickey);\n            jsondata.put(\"data\",ciphertext);\n            system.out.println(\"第一步，使用对方的rsa公钥对明文进行加密，得到的密文进行base64编码，作为data:\"+jsondata.get(\"data\"));\n            sign = sha256util.getsha256str(ciphertext+salt);\n            jsondata.put(\"sign\",sign);\n            system.out.println(\"第二步，将data的值加上约定好的盐，使用sha256算法进行签名，得到的签名是16进制的串，放到sign:\"+jsondata.get(\"sign\"));\n\n        } catch (exception e) {\n            system.out.println(\"加密失败\");\n            throw new runtimeexception(e);\n        }\n        system.out.println(\"得到的密文和签名为：\"+jsondata);\n        system.out.println(\"模拟另一方收到密文和签名之后..........\");\n        system.out.println(\"私钥为：\" + privatekey);\n        string ciphertext1 = jsondata.get(\"data\");\n        string sign1 = jsondata.get(\"sign\");\n        string deciphering1 = null;\n        if(sign1.equals(sha256util.getsha256str(ciphertext1+salt))){\n            system.out.println(\"签名验证成功\");\n            deciphering1 = rsautil.decrypt(ciphertext1,privatekey);\n            system.out.printf(\"数据解密成功，data值为：\"+deciphering1);\n\n        }else{\n            system.out.println(\"签名验证失败，解密失败\");\n        }\n\n    }\n}\n\n\n\n","classes":null}" data-cke-widget-keep-attr="0" data-cke-widget-upcasted="1" data-widget="codesnippet">package rsasha256;
import java.util.hashmap;
import java.util.map;
public class rsasha256test {
    public static void main(string[] args) {
        map jsondata = new hashmap<>();
        string publickey = "miibijanbgkqhkig9w0baqefaaocaq8amiibcgkcaqeauazymb25s/ueifwmm2h74736dqqe4bvrdgnfwltm4pzdunc84ntav41qegbztby47o57m/ydvf6vmxjh25ejlsbbhls7fd7xhtkorskzqlekh0xcs2xa/akdwllbewunzvwmuqy8x3j2vnrilxzvjvqyxkfy0itmo8fq1xso6b/s5/raekpttiepfb2ciu9vmrtlocsnjvotupdwcoc79lts0g1q5bv4dn uca 8/gubhs7vbth3olzt6gxtrjjrpxht4lqwsczqwkqhpg/8jqgnfqs7 r0kcyemg/411iazi9wyrgtsqji8sq2q7halzrxvjn as7jjpvyi67jgkwidaqab";
        string privatekey = "miievqibadanbgkqhkig9w0baqefaascbkcwggsjageaaoibaqc5rpkyhbmz 54h/awzyfvjvfp1bathu9eoa19aw0zg/n240lzie1q/jwosbtm1vljs7nub9gnv/q8xckfbl6owweggwzsupvedoq6uyrmot6qftekzbfr9qr3cwvt7bq3o9yy5dlxfepzwesgtfnwo pjgqvjsk0yjx rxfi7oh9ln9fp4qlo0h6kuhzwht28yu0ugkyenwho491zyglv0u1lsdvdkfxh2f5rxr7z bruflu9u2hegtm3qbdngmms/gfpiwpawjmrcrac8b/wlcccwqzv5hqpzj6yb/jxuhpkj1zhezoxcolyxdarsccvlfe8mf4czumk /klrskyragmbaaecggeabjc 8dvj4j1n 2iu4g2tqt2pqsf lcx/3tc7 b49jo8puuucvwy3znuhktkzrxzisxv2aralslnicgswyrreigmmjb00jgs/llm/sxkhwxmt7iezxbmjuvtnc7jy 3qcrti 9vh4w1kehaqb8opl8hvobiu3m2kglog20a7sym5gpicub3eq6p30u47y7i2wsbmnmmu79rpu3q7lsneob9kdvv6ea6vukl3chy1qxfh6ofzs1ynjfjxy5rxt8u5juhr5lyrnop8mevptbtrh34ssm0uyckkgj6josrdjqo/dj**xixj bwgg5/xbnq3pfeyeaqkrtzy fmhsufoaqkbgqdpqpxpl05mduxcnc7i6f8lzqjnjzu1h9zwkuqe94fs3i3siws62sjx1pz66p9eeiost0t4ye9ndx2x04yyfucenhydftq5m5m9e2q1kkdnebut6xy4wcribkozuq07mlysn0kdbuimp/erp2w3hl5nzu/elkdjt7ym0otv3upp5wkbgqdlbyc4hcvk f1kd/xjq2ljwf c8khhfrllripf7qtb24dcrauwxbagbbckxx2g 3waswyf09ndaliwab/juuuhjm0ygxyr0k5lhci0/ec7hd3twtl/hryef3umkzekbqypzneyme6t0lsqjl3mxfqlqumu4h677qa9/dnh7dyhhqkbgqcfam/bj6s7iba6jvfmozpi91bkvraawlgbxl7nt/nu0ncgzc0vd6wxgj3hqorgltu0krfv8pfp45qkphnwga8xd5gduiw68500zum8chdygeqejvvjvnuhqfnfexmirpfjnpqkcnrqxwk5cvmtci7 ys/fw0uwddivamcbn4auawkbgcogvaivnk6wefeeqqtsl6uozjaypbionek4src2fpinmdnlgmyvbmm51/lzealqa5p6fv2ipd4gae4nmznew 4qprswgudk3 ijw1sfk7qdwkzpeivpvddawyeshb8a22tpwwvae5er3m459avup8ubvw4rodxd4ka6gu1fh31paogaynpkjncrdosqh0nkh0ld44ch6hd zcztoad2eqk0t2spnkbsis1s9w0adreoxuv1edo/hn3p/bctucaax7ijtscs2f0atc/nia6ljbnk7oubbzib9v21l72zvz5st4c/h7izbqcxfs81489a7tthp e1hzs/xepfto0pakr1gj0=";
        string salt = "e4bvrdg";
        system.out.println("公钥为："   publickey);
        string plaintext = "{'a':'1111','b':'2222'}";
        string ciphertext = null;
        string sign = null;
        try {
            ciphertext = rsautil.encrypt(plaintext,publickey);
            jsondata.put("data",ciphertext);
            system.out.println("{banned}中国第一步，使用对方的rsa公钥对明文进行加密，得到的密文进行base64编码，作为data:" jsondata.get("data"));
            sign = sha256util.getsha256str(ciphertext salt);
            jsondata.put("sign",sign);
            system.out.println("第二步，将data的值加上约定好的盐，使用sha256算法进行签名，得到的签名是16进制的串，放到sign:" jsondata.get("sign"));
        } catch (exception e) {
            system.out.println("加密失败");
            throw new runtimeexception(e);
        }
        system.out.println("得到的密文和签名为：" jsondata);
        system.out.println("模拟另一方收到密文和签名之后..........");
        system.out.println("私钥为："   privatekey);
        string ciphertext1 = jsondata.get("data");
        string sign1 = jsondata.get("sign");
        string deciphering1 = null;
        if(sign1.equals(sha256util.getsha256str(ciphertext1 salt))){
            system.out.println("签名验证成功");
            deciphering1 = rsautil.decrypt(ciphertext1,privatekey);
            system.out.printf("数据解密成功，data值为：" deciphering1);
        }else{
            system.out.println("签名验证失败，解密失败");
        }
    }
} 

{
    "texttodecrypt": "cu0ymfmho3hxmvq0hwdhvzg9olsuzt19glbkcvhzdz4=",
    "signature": "meucia8no1g705b3zzmayv7yk8jajz9r2fkuvspzliy8k1xbaiea0noaeibos3fu7rwet81jtjwlrql tbqfy77vk/h/es4=",
    "keyciphertext": "bjv91ulad6fnchtkf/ b1jw2o7il0hjbr6erqry96s8qrdrke7y6epgzm/ey1oumnsr6vbruk0wx6yo8fq3qapyhzu5x1lzjgymc aicnhzut5v3xxz4yd0m1zx2d4ljaonjtded4ns5ku2 c5vff81dyzvdmww6zq=="
} 

 jsondata = new hashmap<>();\n        byte[] keyb = sm4util.generatekey(null);\n        string key = base64.getencoder().encodetostring(keyb);\n        string algorithmname = (\"sm4/ecb/pkcs5padding\");\n\n        system.out.println(\"第一步，随机生成一个sm4秘钥:\"+key);\n        system.out.println(\"选定算法:\"+algorithmname);\n\n        // 用随机生成的sm4秘钥加密\n        byte[] encryptmsg = sm4util.encrypt(algorithmname, keyb, null, messge.getbytes());\n        jsondata.put(\"texttodecrypt\",base64.getencoder().encodetostring(encryptmsg));\n        system.out.println(\"第二步，使用sm4密钥加密明文，得到的密文进行base64编码，作为texttodecrypt :\"+jsondata.get(\"texttodecrypt\"));\n\n        // 将随机生成的sm4秘钥，使用对方的sm2公钥进行加密\n        string keyciphertext = sm2util.encryptbysm2(key, otherpubk);\n        jsondata.put(\"keyciphertext\",keyciphertext);\n        system.out.println(\"第三步,将sm4密钥进行base64编码后，再使用对方的sm2公钥对这个base64串进行加密，得到的密文进行base64编码，作为 keyciphertext；\"+jsondata.get(\"keyciphertext\"));\n\n        // 对明文使用自己的sm2私钥进行签名 如果有需要，可以加点盐\n        string signature = sm2util.sign(prik,messge);\n        jsondata.put(\"signature\",signature);\n        system.out.println(\"第四步,对第二步的明文使用对方sm2私钥签名，得到的签名进行base64编码后作为 signature:\"+jsondata.get(\"signature\"));\n\n        system.out.println(\"完整json串:\"+jsondata);\n\n        // 模拟接到json传之后的处理\n        // 对方拿到的，你的公钥，和对方自己的私钥\n        string pubk = \"bntfr3oo1xm3bigoqqnk20qjfbfvk4hnfgs1dkzjuut9pw8i7k0d9l9p4mw+tqhwwfjld/nsx3by+orif1b25ba=\";\n        string otherprik = \"i0shzcdm+os2fiahflxxkwji1abrhrxeys1axpztlnw=\";\n\n        // 将sm4秘钥进行解密\n        string keyciphertext1 = sm2util.decryptbysm2(jsondata.get(\"keyciphertext\"), otherprik);\n        system.out.println(\"对方使用sm2私钥解密sm4秘钥：\"+keyciphertext1);\n\n        // 通过sm4秘钥解密数据密文\n        byte[] texttodecrypts = sm4util.decrypt(algorithmname, base64.getdecoder().decode(keyciphertext1), null, base64.getdecoder().decode(jsondata.get(\"texttodecrypt\").getbytes()));\n        string texttodecryptss = new string(texttodecrypts);\n        system.out.println(\"对方使用sm4秘钥解密后的数据：\"+ texttodecryptss);\n\n        // 验证签名\n        boolean proving = sm2util.verify(pubk, texttodecryptss, jsondata.get(\"signature\"));\n        system.out.println(\"验证签名是否通过：\"+proving);\n\n\n    }\n\n}\n\n\n\n","classes":null}" data-cke-widget-keep-attr="0" data-cke-widget-upcasted="1" data-widget="codesnippet">package gmsm;
import java.util.hashmap;
import java.util.map;
import java.util.base64;
public class gmsmtest {
    public static void main(string[] args) throws exception {
//        你这边拿到的sm2公私钥，对方的公钥和自己的私钥
        string prik = "amz5m/wogpgyixnlckc7 zdvzxnqymbcwxt1n7khfdvo";
        string otherpubk = "bjkvgu87s7xhlrfci8mgpzp2x lizte 2so52cq1tveddqoe q4vdqxglv2jtiozewc/be8rzdo29svmtj8 7ma=";
        string messge = "{'aaa':'111','bbb':'222'}";
        map jsondata = new hashmap<>();
        byte[] keyb = sm4util.generatekey(null);
        string key = base64.getencoder().encodetostring(keyb);
        string algorithmname = ("sm4/ecb/pkcs5padding");
        system.out.println("{banned}中国第一步，随机生成一个sm4秘钥:" key);
        system.out.println("选定算法:" algorithmname);
        // 用随机生成的sm4秘钥加密
        byte[] encryptmsg = sm4util.encrypt(algorithmname, keyb, null, messge.getbytes());
        jsondata.put("texttodecrypt",base64.getencoder().encodetostring(encryptmsg));
        system.out.println("第二步，使用sm4密钥加密明文，得到的密文进行base64编码，作为texttodecrypt :" jsondata.get("texttodecrypt"));
        // 将随机生成的sm4秘钥，使用对方的sm2公钥进行加密
        string keyciphertext = sm2util.encryptbysm2(key, otherpubk);
        jsondata.put("keyciphertext",keyciphertext);
        system.out.println("第三步,将sm4密钥进行base64编码后，再使用对方的sm2公钥对这个base64串进行加密，得到的密文进行base64编码，作为 keyciphertext；" jsondata.get("keyciphertext"));
        // 对明文使用自己的sm2私钥进行签名 如果有需要，可以加点盐
        string signature = sm2util.sign(prik,messge);
        jsondata.put("signature",signature);
        system.out.println("第四步,对第二步的明文使用对方sm2私钥签名，得到的签名进行base64编码后作为 signature:" jsondata.get("signature"));
        system.out.println("完整json串:" jsondata);
        // 模拟接到json传之后的处理
        // 对方拿到的，你的公钥，和对方自己的私钥
        string pubk = "bntfr3oo1xm3bigoqqnk20qjfbfvk4hnfgs1dkzjuut9pw8i7k0d9l9p4mw tqhwwfjld/nsx3by orif1b25ba=";
        string otherprik = "i0shzcdm os2fiahflxxkwji1abrhrxeys1axpztlnw=";
        // 将sm4秘钥进行解密
        string keyciphertext1 = sm2util.decryptbysm2(jsondata.get("keyciphertext"), otherprik);
        system.out.println("对方使用sm2私钥解密sm4秘钥：" keyciphertext1);
        // 通过sm4秘钥解密数据密文
        byte[] texttodecrypts = sm4util.decrypt(algorithmname, base64.getdecoder().decode(keyciphertext1), null, base64.getdecoder().decode(jsondata.get("texttodecrypt").getbytes()));
        string texttodecryptss = new string(texttodecrypts);
        system.out.println("对方使用sm4秘钥解密后的数据："  texttodecryptss);
        // 验证签名
        boolean proving = sm2util.verify(pubk, texttodecryptss, jsondata.get("signature"));
        system.out.println("验证签名是否通过：" proving);
    }
} 

\n\t\n\t\tcom.google.guava\n\t\tguava\n\t\t30.1-jre\n\t\n\t\n\t\torg.bouncycastle\n\t\tbcprov-jdk15on\n\t\t1.70\n\t\n\n\n","classes":null}" data-cke-widget-keep-attr="0" data-cke-widget-upcasted="1" data-widget="codesnippet">
	
		com.google.guava
		guava
		30.1-jre
	
	
		org.bouncycastle
		bcprov-jdk15on
		1.70