深海游弋的鱼 – 默默的点滴

ZipCrypto算法回顾

ZipCrypto，也称为 PKZIP Stream Cipher，是一种弱加密手段，在1994年就已经被攻破，该加密方式不能经受已知明文攻击（Known Plaintext Attack，KPA）。

明文攻击主要利用大于 12 字节的一段已知明文数据进行攻击，从而获取整个加密文档的数据。也就是说，如果手里有一个未知密码的压缩包和压缩包内某个文件的一部分明文（不一定非要从头开始，能确定偏移就行），那么就可以通过这种攻击来解开整个压缩包。比如压缩包里有一个常见的 license 文件，或者是某个常用的 dll 库，或者是带有固定头部的文件（比如 xml、exe、png 等容易推导出原始内容的文件），那么就可以运用这种攻击。

Biham和Kocher文中回顾了PKZIP Stream Cipher加密解密过程。

原始论文链接： A Known Plaintext Attack on the PKZIP Stream Cipher

本站链接： A Known Plaintext Attack on the PKZIP Stream Cipher

首先，文件压缩后形成压缩包，PKZIP在压缩包中每个文件头部加上12字节的文件头，用于随机化，也用于在解密时识别错误的密钥，然后该文件头和文件内容一起进行加密。

加密过程如下：

首先初始化，key为用户输入的二进制的密钥序列。key0，key1，key2为三个全局变量，在加/解密每个字节时都会用到。小写L表示第L个字节

Update_keys()函数定义如下，输入为一个字节。

然后就是加文件头，开始加密。Pi代表明文第i字节

解密过程如下：

首先初始化，和加密过程初始化完全相同
然后解密，Ci代表加密的内容。解密后P1-P12是文件头，仅留作校验，解密后不再需要

附上一段代码，实现PKZIP解密，加密类似。

import zlib

class weak_decrypt:
    def __init__(self) -> None:
        self.key_0 = 305419896
        self.key_1 = 591751049
        self.key_2 = 878082192
        self.crc32 = zlib.crc32
        self.bytes_c = bytes

    def update_keys(self,byte):
        self.key_0 = ~self.crc32(self.bytes_c((byte,)), ~self.key_0) & 0xFFFFFFFF
        self.key_1 = (self.key_1 + (self.key_0 & 0xFF)) & 0xFFFFFFFF
        self.key_1 = ((self.key_1 * 134775813) + 1) & 0xFFFFFFFF
        self.key_2 = ~self.crc32(self.bytes_c((self.key_1 >> 24,)), ~self.key_2) & 0xFFFFFFFF

    def decrypt(self,chunk):
        chunk = bytearray(chunk)
        for i, byte in enumerate(chunk):
            temp = self.key_2 | 2
            byte ^= ((temp * (temp ^ 1)) >> 8) & 0xFF
            self.update_keys(byte)
            chunk[i] = byte
        return bytes(chunk)
# usage:
# decrypter = weak_decrypt()
# cipher_text = b'aaaaa'
# password = b'pppp'
# for byte in password:
#    decrypter.update_keys(byte)
# plian_text = decrypter.decrypt(cipher_text)

import zlib

class weak_decrypt:

def __init__(self) -> None:

self.key_0 = 305419896

self.key_1 = 591751049

self.key_2 = 878082192

self.crc32 = zlib.crc32

self.bytes_c = bytes

def update_keys(self,byte):

self.key_0 = ~self.crc32(self.bytes_c((byte,)), ~self.key_0) & 0xFFFFFFFF

self.key_1 = (self.key_1 + (self.key_0 & 0xFF)) & 0xFFFFFFFF

self.key_1 = ((self.key_1 * 134775813) + 1) & 0xFFFFFFFF

self.key_2 = ~self.crc32(self.bytes_c((self.key_1 >> 24,)), ~self.key_2) & 0xFFFFFFFF

def decrypt(self,chunk):

chunk = bytearray(chunk)

for i, byte in enumerate(chunk):

temp = self.key_2 | 2

byte ^= ((temp * (temp ^ 1)) >> 8) & 0xFF

self.update_keys(byte)

chunk[i] = byte

return bytes(chunk)

# usage:

# decrypter = weak_decrypt()

# cipher_text = b'aaaaa'

# password = b'pppp'

# for byte in password:

# decrypter.update_keys(byte)

# plian_text = decrypter.decrypt(cipher_text)

总结：PKZIP Stream Cipher是一种按照文件顺序、逐个字节进行加密/解密的算法。实际使用中，还需要注意到每遇到一个压缩包内的文件，就会从头进行一遍加密/解密过程。实现一个已知密钥zip archive的解密还需要了解ZIP格式等问题，这里就不再赘述了。

参考链接

商用密码技术最佳实践白皮书

密码算法库是操作系统的基础组件，在系统安全领域的作用不言而喻。操作系统默认已经内置了大量的密码学库，比如OpenSSL，libgcrypt，gnulib，nettle 是被默认集成到基础操作系统的，它们有一些重复的功能，但也各有侧重的领域，是操作系统不可或缺的安全基石。

本小节会介绍一些支持国密算法的、非常主流的密码算法库，提供给开发者和用户更多的选择。

OpenSSL

官网：https://www.openssl.org

OpenSSL 是一个通用的、强大的、商业级的、功能齐全的工具包，用于通用加密和安全通信。

OpenSSL 的重要性众所周知，这里重点强调一下版本问题。

🟢 1.1.1 稳定版

目前主流发行版使用的仍然是 1.1.1 版本，这个版本在国密的支持上有一些固有的缺陷：

不支持 SM2 的签名验签，因为基于可辨别用户ID的Za值计算在这个版本中未实现
国外主流的发行版的包默认没有编译国密 SM2、SM4 模块，CentOS上就是如此

由于技术上和兼容性的原因，这个版本目前很难升级到最新的社区版本，因此在主流的发行版本中基本是无缘使用国密的。

🟢 3.0.x 稳定版

社区最新的稳定版本是 3.0，这个版本对国密的支持已经比较完善，并且支持了国密的指令集优化。用户如果自行编译可以完整使能国密的能力。

🟢 龙蜥社区 1.1.1 版本

从目前情况来看，对于一个操作系统发行版，要完全从 1.1.1 切换到 3.0 还需要较长的时间，因此龙蜥社区在 1.1.1 版本的基础上，在保证兼容性和稳定性的前提下，补全了国密能力上的缺陷，并且做为操作系统默认库在 Anolis OS 8.8 中集成发布，详细信息可参考Anolis OS 国密开发指南。

libgcrypt

官网：https://www.gnupg.org/software/libgcrypt/index.html

不像 OpenSSL 还包括了安全协议，libgcrypt 是一个纯粹的密码算法库，就国密算法的性能来说，libgcrypt 的国密算法优化是做的比较充分的，Linux 内核国密算法的部分优化也是先在 libgcrypt 实现后才移植到内核的。

Libgcrypt 是一个通用密码库，最初基于 GnuPG 的代码。它为几乎所有的密码提供支持：

对称密码算法 (AES、Arcfour、Blowfish、Camellia、CAST5、ChaCha20 DES、GOST28147、Salsa20、SEED、Serpent、Twofish、SM4)
模式 (ECB、CFB、CBC、OFB、CTR、CCM） ,GCM,OCB,POLY1305,AESWRAP)
哈希算法 (MD2, MD4, MD5, GOST R 34.11, RIPE-MD160, SHA-1, SHA2-224, SHA2-256, SHA2-384, SHA2-512, SHA3-224 , SHA3-256, SHA3-384, SHA3-512, SHAKE-128, SHAKE-256, TIGER-192, Whirlpool, SM3)
MAC (HMAC 用于所有哈希算法, CMAC 用于所有密码算法, GMAC-AES, GMAC-CAMELLIA, GMAC-TWOFISH、GMAC-SERPENT、GMAC-SEED、Poly1305、Poly1305-AES、Poly1305-CAMELLIA、Poly1305-TWOFISH、Poly1305-SERPENT、Poly1305-SEED)
公钥算法 (RSA、Elgamal、DSA、ECDSA、EdDSA、ECDH、SM2)
大整数函数、随机数和大量的支持函数

libgcrypt 是很多基础组件依赖的密码库，比如 gpg，systemd，qemu，postgresql，还有许多桌面环境的库，音视频组件，蓝牙都依赖于 libgcrypt 提供的密码安全机制，还有部分会选择依赖libgcrypt，比如 curl，cryptsetup 等会选择依赖 OpenSSL，libgcrypt 算法库，用户需要自行构建来选择不同的密码库。

libgcrypt 从 1.9.0 版本开始陆续支持了国密算法和国密的指令集优化。

GmSSL

项目地址：https://github.com/guanzhi/GmSSL

GmSSL 是一个开源密码工具包，为 GM/T 系列标准中规定的中国国家密码算法和协议提供一级支持。作为 OpenSSL 项目的一个分支，GmSSL 提供了与 OpenSSL 的 API 级兼容性并保持了所有的功能。现有项目（例如 Apache Web 服务器）可以轻松地移植到 GmSSL，只需进行少量修改和简单的重建。

自2014年底首次发布以来，GmSSL已入选开源中国六大推荐密码项目之一，并获得2015年中国Linux软件大奖。

该密码库的特点：

支持中国GM/T密码标准。
支持中国厂商的硬件密码模块。
具有商业友好的开源许可证。
由北京大学密码学研究组维护。

GmSSL 将支持以下所有 GM/T 加密算法：

SM3 (GM/T 0004-2012)：具有 256 位摘要长度的密码哈希函数。
SM4（GM/T 0002-2012）：密钥长度为128位，块大小为128位的块密码，也称为SMS4。
SM2（GM/T 0003-2012）：椭圆曲线密码方案，包括数字签名方案、公钥加密、（认证）密钥交换协议和一种推荐的256位素数域曲线sm2p256v1。
SM9（GM/T 0044-2016）：基于配对的密码方案，包括基于身份的数字签名、加密、（认证）密钥交换协议和一条256位推荐BN曲线。
ZUC（GM/T 0001-2012）：流密码，采用128-EEA3加密算法和128-EIA3完整性算法。
SM1和SSF33：密钥长度为128位，块大小为128位的块密码，没有公开说明，只随芯片提供。

GmSSL 支持许多有用的加密算法和方案：

公钥方案：Paillier、ECIES（椭圆曲线集成加密方案）
基于配对的密码学：BF-IBE、BB1-IBE
块密码和模式：Serpent、Speck
块密码模式：FPE（格式保护加密）
基于SM3/SM4的OTP（一次性密码）（GM/T 0021-2012）
编码：Base58

ECDSA、RSA、AES、SHA-1 等 OpenSSL 算法在 GmSSL 中仍然可用。

nettle

官网：http://www.lysator.liu.se/~nisse/nettle

Nettle 是一个相对低层的加密库，旨在轻松适应各种工具包和应用程序。它开始于2001年的lsh的低级加密函数的集合。自2009年6月以来，Nettle 成为 GNU 软件包。

Nettle 的定位跟 libgcrypt 有点类似，是很多基础组件选择依赖的一个密码学库。

从提供的 API 上来看，Nettle 没有对算法做更高层次的抽象，每个不同的算法都有一套更易理解的接口，开发者也会更容易上手。

Nettle 从 3.8 版本开始支持了 SM3 算法，最新的开发分支已经合入了 SM4 算法，会在下一个 release 版本发布。

gnulib

官网：https://www.gnu.org/software/gnulib

从名字可以看出，gnulib 并不是一个纯密码算法的库，它的定位是 GNU 的公共代码库，旨在 GNU 包的源代码级别之间共享。

之所以在这里提 gnulib，是因为这个库里面实现了常用的哈希算法，也包括SM3算法，gnulib 里的哈希算法主要是为 coreutils 包里的 sha*sum, md5sum 系列工具提供支持的，当然开发者也可以基于 gnulib 构建自己的程序。

gnulib 是在 2017 年 10 月支持了 SM3 算法，由阿里巴巴张佳贡献。

coreutils

coreutils 支持了大量的计算哈希的工具，比如 cksum，md5sum，b2sum，sha*sum 等，这些工具是紧密依赖于 gnulib 库的。

2017 年 10 月，在 gnulib 库支持了 SM3 之后，我们便向 coreutils 社区提交了 sm3sum 工具的支持，coreutils 社区却迟迟不愿接收，因为 SM3 算法的IV向量没有明确的来历说明，社区对算法的安全性有质疑，虽然彼时 SM3 已经是 ISO 的国际标准算法。社区人员认为 SM3 在 gnulib 中作为库提供给开发者是没有问题的，因为开发者具备也应该具备判断一个算法是否安全的能力，但是在 coreutils 中提供一个 sm3sum 的工具提供给终端用户会引起用户的误导，用户可能误认为算法安全性是得到保证的，尤其是在 SM3 算法安全性被质疑的前提下。

直到四年后的 2021 年 9 月，在包括Linux 内核，libgcrypt，OpenSSL 等主流的密码算法社区都支持了SM3算法后，在龙蜥的几次推动下，coreutils 社区终于不再质疑 SM3 的安全性问题，但是社区也不愿意再多引入一个工具，应该把这个哈希算法整合为一个工具，因为类似 *sum 的工具太多了。

因此，社区提出一个 cksum -a [algo] 的方案，通过给 cksum 工具添加一个算法参数，整合了目前 coreutils 中支持的所有哈希算法，为了兼容考虑，之前的 *sum 工具也继续保留了，SM3 是唯一仅在 cksum 工具中支持的算法，当然这并不是优点，使用习惯上也会有一些差异，用户需要通过 cksum -a sm3 来计算 SM3 哈希，除这个区别外，其它用法跟 md5sum 类似。

coreutils 从 9.0 版本开始支持 SM3 的哈希计算。

RustCrypto

这是一个纯 Rust 编写的密码算法库，供 Rust 开发者使用。

该项目维护着数十个流行的 crate，都提供密码算法的纯 Rust 实现，主要包括以下算法：

非对称加密：椭圆曲线、rsa
加密编码格式：const-oid、der、pem-rfc7468、pkcs8
数字签名：dsa、ecdsa、ed25519、rsa
椭圆曲线：k256、p256、p384
哈希函数：blake2、sha2、sha3、sm3
密钥派生函数：hkdf、pbkdf2
消息认证码：hmac
密码哈希：argon2、pbkdf2、scrypt
Sponge 函数：ascon、keccak
对称加密：aes-gcm、aes-gcm-siv、chacha20poly1305、sm4
Traits：aead、密码、摘要、密码哈希、签名

该算法库目前支持 SM3 和 SM4 算法。

Intel IPP

项目地址：https://github.com/intel/ipp-crypto

Intel Integrated Performance Primitives (Intel IPP) Cryptography 是一个安全、快速且轻量级的密码学库，针对各种 Intel CPU 进行了高度优化。

该库提供了一套全面的常用于加密操作的函数，包括：

对称密码学原语函数：
- AES（ECB、CBC、CTR、OFB、CFB、XTS、GCM、CCM、SIV）
- SM4（ECB、CBC、CTR、OFB、CFB、CCM）
- TDES（ECB、CBC、CTR、OFB、CFB）
- RC4
单向哈希原语：
- SHA-1、SHA-224、SHA-256、SHA-384、SHA-512
- MD5
- SM3
数据认证原语函数：
- HMAC
- AES-CMAC
公钥加密函数：
- RSA、RSA-OAEP、RSA-PKCS_v15、RSA-PSS
- DLP、DLP-DSA、DLP-DH
- ECC（NIST 曲线）、ECDSA、ECDH、EC-SM2
多缓冲区 RSA、ECDSA、SM3、x25519
有限域算术函数
大整数算术函数
PRNG/TRNG 和质数生成

使用英特尔 IPP 密码库的原因：

安全性（秘密处理功能的恒定时间执行）
专为小尺寸设计
针对不同的 Intel CPU 和指令集架构进行了优化（包括硬件加密指令 SSE 和 AVX 的支持）
可配置的 CPU 分配以获得最佳性能
内核模式兼容性
线程安全设计

参考链接

Java—bouncycastle支持国密SM2的公钥加密算法

java代码是依赖 BouncyCastle 类库，经修改此类库中的 SM2Engine 类的原码而来，用于支持 SM2 公钥加密算法，符合《GB/T 35276-2017: 信息安全技术 SM2密码算法使用规范》。

SM4 国标《GB/T 32907-2016 信息安全技术 SM4分组密码算法》。

可以使用 gmssl 工具进行交互测试(http://gmssl.org)

引入jar:

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

<groupId>org.bouncycastle</groupId>

<artifactId>bcprov-jdk15on</artifactId>

</dependency>

加解密工具类：

import java.io.IOException;
import java.math.BigInteger;
import java.security.SecureRandom;

import org.bouncycastle.asn1.ASN1EncodableVector;
import org.bouncycastle.asn1.ASN1InputStream;
import org.bouncycastle.asn1.ASN1Integer;
import org.bouncycastle.asn1.ASN1OctetString;
import org.bouncycastle.asn1.ASN1Sequence;
import org.bouncycastle.asn1.DEROctetString;
import org.bouncycastle.asn1.DERSequence;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.Digest;
import org.bouncycastle.crypto.InvalidCipherTextException;
import org.bouncycastle.crypto.digests.SM3Digest;
import org.bouncycastle.crypto.params.ECDomainParameters;
import org.bouncycastle.crypto.params.ECKeyParameters;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.crypto.params.ParametersWithRandom;
import org.bouncycastle.math.ec.ECFieldElement;
import org.bouncycastle.math.ec.ECMultiplier;
import org.bouncycastle.math.ec.ECPoint;
import org.bouncycastle.math.ec.FixedPointCombMultiplier;
import org.bouncycastle.util.Arrays;
import org.bouncycastle.util.BigIntegers;
import org.bouncycastle.util.Memoable;
import org.bouncycastle.util.Pack;


/**
 * 自义的 SM2 公钥加密、私钥解密引擎， 用于替换  BouncyCastle 中的 SM2Engine 的实现,
 * 可用于非 java 开发的系统之间交换数据时的公钥加密、私钥解密，完全符合 GM/T 以下两个标准：
 * <br/>
 * <li>《GM/T 0003.4-2012: SM2椭圆曲线公钥密钥算法：第4部分：公钥加密算法》</li>
 * <li>《GM/T 0009-2012: SM2密码算法使用规范》</li>
 * <br/>
 * <p/>
 * <li>1.加密密文默认为 C1||C3||C2, 输出内容为 ASN.1 编码。符合 《GM/T 0009-2012: SM2密码算法使用规范》 标准
 * </li>
 * <li>2.加密密文设置为 C1||C2||C3，则输出内容不是 ASN.1 编码。与 《GM/T 0009-2012 ...》 标准不兼容。</li>
 * <br/>
 * 建议可以使用 GmSSL 工具进行交互测试，请参考 {@code http://gmssl.org}
 * <p>
 * SM2 public key encryption engine - based on https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02.
 *
 *
 * @author YangHongFeng
 * @since 2020/5/28 creation
 */
public class MySm2Engine {

    public enum Mode {
        C1C2C3, C1C3C2;
    }

    private final Digest digest;
    private final Mode mode;

    private boolean forEncryption;
    private ECKeyParameters ecKey;
    private ECDomainParameters ecParams;
    private int curveLength;
    private SecureRandom random;

    /***
     * 默认采用国标：C1||C3||C2
     */
    public MySm2Engine() {
        this(new SM3Digest(), Mode.C1C3C2);
    }

    public MySm2Engine(Mode mode) {
        this(new SM3Digest(), mode);
    }

    public MySm2Engine(Digest digest) {
        this(digest, Mode.C1C2C3);
    }

    public MySm2Engine(Digest digest, Mode mode) {
        if (mode == null) {
            throw new IllegalArgumentException("mode cannot be NULL");
        }
        this.digest = digest;
        this.mode = mode;
    }

    /**
     * 初始化
     * @param forEncryption true-公钥加密, false-私钥解密
     * @param param 密码参数，从中获取公或私钥、及椭圆曲线相关参数
     */
    public void init(boolean forEncryption, CipherParameters param) {
        this.forEncryption = forEncryption;

        if (forEncryption) {
            ParametersWithRandom rParam = (ParametersWithRandom) param;

            ecKey = (ECKeyParameters) rParam.getParameters();
            ecParams = ecKey.getParameters();

            ECPoint s = ((ECPublicKeyParameters) ecKey).getQ().multiply(ecParams.getH());
            if (s.isInfinity()) {
                throw new IllegalArgumentException("invalid key: [h]Q at infinity");
            }

            random = rParam.getRandom();
        } else {
            ecKey = (ECKeyParameters) param;
            ecParams = ecKey.getParameters();
        }

        curveLength = (ecParams.getCurve().getFieldSize() + 7) / 8;
    }

    /**
     * 进行加密、或解密
     * @param in
     * @param inOff
     * @param inLen
     * @return
     * @throws InvalidCipherTextException
     */
    public byte[] processBlock(
            byte[] in,
            int inOff,
            int inLen)
            throws IOException, InvalidCipherTextException {
        if (forEncryption) {
            return encrypt(in, inOff, inLen);
        } else {
            return decrypt(in, inOff, inLen);
        }
    }

    public int getOutputSize(int inputLen) {
        return (1 + 2 * curveLength) + inputLen + digest.getDigestSize();
    }

    protected ECMultiplier createBasePointMultiplier() {
        return new FixedPointCombMultiplier();
    }

    private byte[] encrypt(byte[] in, int inOff, int inLen)
            throws IOException {
        byte[] c2 = new byte[inLen];

        System.arraycopy(in, inOff, c2, 0, c2.length);

        ECMultiplier multiplier = createBasePointMultiplier();

        ECPoint c1P;
        ECPoint kPB;
        do {
            BigInteger k = nextK();

            c1P = multiplier.multiply(ecParams.getG(), k).normalize();
            // c1 = c1P.getEncoded(false);

            kPB = ((ECPublicKeyParameters) ecKey).getQ().multiply(k).normalize();

            kdf(digest, kPB, c2);
        }

        while (notEncrypted(c2, in, inOff));

        byte[] c3 = new byte[digest.getDigestSize()];

        addFieldElement(digest, kPB.getAffineXCoord());
        digest.update(in, inOff, inLen);
        addFieldElement(digest, kPB.getAffineYCoord());

        digest.doFinal(c3, 0);

        switch (mode) {
        case C1C3C2:
            // 2020/06/01 按国标组装为 ANS.1 编码
            final ASN1EncodableVector vector = new ASN1EncodableVector();
            vector.add(new ASN1Integer(c1P.getXCoord().toBigInteger()));
            vector.add(new ASN1Integer(c1P.getYCoord().toBigInteger()));
            vector.add(new DEROctetString(c3));
            vector.add(new DEROctetString(c2));
            return new DERSequence(vector).getEncoded();
        default:
            byte[] c1 = c1P.getEncoded(false);
            return Arrays.concatenate(c1, c2, c3);
        }
    }

    private byte[] decrypt(byte[] in, int inOff, int inLen)
            throws InvalidCipherTextException, IOException {

        ECPoint c1P; // = ecParams.getCurve().decodePoint(c1);
        byte[] inHash ;
        byte[] inCipherData;

        if (mode == Mode.C1C3C2) {
            // 2020/06/01 按国标 ANS.1 编码 进行解码
            ASN1InputStream inputStream = new ASN1InputStream(in);
            ASN1Sequence seq = (ASN1Sequence) inputStream.readObject();
            if (seq.size() != 4){
                throw new InvalidCipherTextException("invalid cipher text");
            }
            int index = 0;

            // C1 == XCoordinate 、YCoordinate
            BigInteger x = ((ASN1Integer) seq.getObjectAt(index ++)).getPositiveValue();
            // YCoordinate
            BigInteger y = ((ASN1Integer) seq.getObjectAt(index ++)).getPositiveValue();

            // XCoord 、YCoord ==> CEPoint (C1)
            c1P = ecParams.getCurve().createPoint(x, y);

            // HASH (C3)
            inHash = ((ASN1OctetString)seq.getObjectAt(index ++)).getOctets();

            // CipherText (C2)
            inCipherData = ((ASN1OctetString)seq.getObjectAt(index)).getOctets();
        } else {
            // C1
            byte[] c1 = new byte[curveLength * 2 + 1];
            System.arraycopy(in, inOff, c1, 0, c1.length);
            c1P = ecParams.getCurve().decodePoint(c1);

            // C2 == inCipherData
            int digestSize = this.digest.getDigestSize();
            inCipherData = new byte[inLen - c1.length - digestSize];
            System.arraycopy(in, inOff + c1.length, inCipherData, 0, inCipherData.length);

            // C3 == Hash
            inHash = new byte[digestSize];
            System.arraycopy(in, inOff + c1.length + inCipherData.length, inHash, 0, inHash.length);
        }

        // 解密 ==> inCipherData;
        ECPoint s = c1P.multiply(ecParams.getH());
        if (s.isInfinity())
        {
            throw new InvalidCipherTextException("[h]C1 at infinity");
        }
        c1P = c1P.multiply(((ECPrivateKeyParameters)ecKey).getD()).normalize();
        kdf(digest, c1P, inCipherData);

        // 动态计算已解密的明文的摘要并比较
        byte[] cipherDigest = new byte[digest.getDigestSize()];

        addFieldElement(digest, c1P.getAffineXCoord());
        digest.update(inCipherData, 0, inCipherData.length);
        addFieldElement(digest, c1P.getAffineYCoord());

        digest.doFinal(cipherDigest, 0);

        int check = 0;
        if (mode == Mode.C1C3C2)
        {
            for (int i = 0; i != cipherDigest.length; i++) {
                check |= cipherDigest[i] ^ inHash[i];
            }
        } else {
            for (int i = 0; i != cipherDigest.length; i++) {
                check |= cipherDigest[i] ^ inHash[i];
            }
        }

        // Arrays.fill(c1, (byte)0);
        Arrays.fill(cipherDigest, (byte)0);

        if (check != 0)
        {
            Arrays.fill(inCipherData, (byte)0);
            throw new InvalidCipherTextException("invalid cipher text");
        }

        // return c2;
        return inCipherData;
    }

    private boolean notEncrypted(byte[] encData, byte[] in, int inOff) {
        for (int i = 0; i != encData.length; i++) {
            if (encData[i] != in[inOff + i]) {
                return false;
            }
        }

        return true;
    }

    private void kdf(Digest digest, ECPoint c1, byte[] encData) {
        int digestSize = digest.getDigestSize();
        byte[] buf = new byte[Math.max(4, digestSize)];
        int off = 0;

        Memoable memo = null;
        Memoable copy = null;

        if (digest instanceof Memoable) {
            addFieldElement(digest, c1.getAffineXCoord());
            addFieldElement(digest, c1.getAffineYCoord());
            memo = (Memoable) digest;
            copy = memo.copy();
        }

        int ct = 0;

        while (off < encData.length) {
            if (memo != null) {
                memo.reset(copy);
            } else {
                addFieldElement(digest, c1.getAffineXCoord());
                addFieldElement(digest, c1.getAffineYCoord());
            }

            Pack.intToBigEndian(++ct, buf, 0);
            digest.update(buf, 0, 4);
            digest.doFinal(buf, 0);

            int xorLen = Math.min(digestSize, encData.length - off);
            xor(encData, buf, off, xorLen);
            off += xorLen;
        }
    }

    private void xor(byte[] data, byte[] kdfOut, int dOff, int dRemaining) {
        for (int i = 0; i != dRemaining; i++) {
            data[dOff + i] ^= kdfOut[i];
        }
    }

    private BigInteger nextK() {
        int qBitLength = ecParams.getN().bitLength();

        BigInteger k;
        do {
            k = BigIntegers.createRandomBigInteger(qBitLength, random);
        }
        while (k.equals(BigIntegers.ZERO) || k.compareTo(ecParams.getN()) >= 0);

        return k;
    }

    private void addFieldElement(Digest digest, ECFieldElement v) {
        byte[] p = BigIntegers.asUnsignedByteArray(curveLength, v.toBigInteger());

        digest.update(p, 0, p.length);
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

import java.io.IOException;

import java.math.BigInteger;

import java.security.SecureRandom;

import org.bouncycastle.asn1.ASN1EncodableVector;

import org.bouncycastle.asn1.ASN1InputStream;

import org.bouncycastle.asn1.ASN1Integer;

import org.bouncycastle.asn1.ASN1OctetString;

import org.bouncycastle.asn1.ASN1Sequence;

import org.bouncycastle.asn1.DEROctetString;

import org.bouncycastle.asn1.DERSequence;

import org.bouncycastle.crypto.CipherParameters;

import org.bouncycastle.crypto.Digest;

import org.bouncycastle.crypto.InvalidCipherTextException;

import org.bouncycastle.crypto.digests.SM3Digest;

import org.bouncycastle.crypto.params.ECDomainParameters;

import org.bouncycastle.crypto.params.ECKeyParameters;

import org.bouncycastle.crypto.params.ECPrivateKeyParameters;

import org.bouncycastle.crypto.params.ECPublicKeyParameters;

import org.bouncycastle.crypto.params.ParametersWithRandom;

import org.bouncycastle.math.ec.ECFieldElement;

import org.bouncycastle.math.ec.ECMultiplier;

import org.bouncycastle.math.ec.ECPoint;

import org.bouncycastle.math.ec.FixedPointCombMultiplier;

import org.bouncycastle.util.Arrays;

import org.bouncycastle.util.BigIntegers;

import org.bouncycastle.util.Memoable;

import org.bouncycastle.util.Pack;

/**

* 自义的 SM2 公钥加密、私钥解密引擎，用于替换 BouncyCastle 中的 SM2Engine 的实现,

* 可用于非 java 开发的系统之间交换数据时的公钥加密、私钥解密，完全符合 GM/T 以下两个标准：

*

* <li>《GM/T 0003.4-2012: SM2椭圆曲线公钥密钥算法：第4部分：公钥加密算法》</li>

* <li>《GM/T 0009-2012: SM2密码算法使用规范》</li>

*

*

* <li>1.加密密文默认为 C1||C3||C2, 输出内容为 ASN.1 编码。符合《GM/T 0009-2012: SM2密码算法使用规范》标准

* </li>

* <li>2.加密密文设置为 C1||C2||C3，则输出内容不是 ASN.1 编码。与《GM/T 0009-2012 ...》标准不兼容。</li>

*

* 建议可以使用 GmSSL 工具进行交互测试，请参考 {@code http://gmssl.org}

*

* SM2 public key encryption engine - based on https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02.

* @author YangHongFeng

* @since 2020/5/28 creation

public class MySm2Engine {

public enum Mode {

C1C2C3, C1C3C2;

}

private final Digest digest;

private final Mode mode;

private boolean forEncryption;

private ECKeyParameters ecKey;

private ECDomainParameters ecParams;

private int curveLength;

private SecureRandom random;

/***

* 默认采用国标：C1||C3||C2

public MySm2Engine() {

this(new SM3Digest(), Mode.C1C3C2);

}

public MySm2Engine(Mode mode) {

this(new SM3Digest(), mode);

}

public MySm2Engine(Digest digest) {

this(digest, Mode.C1C2C3);

}

public MySm2Engine(Digest digest, Mode mode) {

if (mode == null) {

throw new IllegalArgumentException("mode cannot be NULL");

}

this.digest = digest;

this.mode = mode;

}

/**

* 初始化

* @param forEncryption true-公钥加密, false-私钥解密

* @param param 密码参数，从中获取公或私钥、及椭圆曲线相关参数

public void init(boolean forEncryption, CipherParameters param) {

this.forEncryption = forEncryption;

if (forEncryption) {

ParametersWithRandom rParam = (ParametersWithRandom) param;

ecKey = (ECKeyParameters) rParam.getParameters();

ecParams = ecKey.getParameters();

ECPoint s = ((ECPublicKeyParameters) ecKey).getQ().multiply(ecParams.getH());

if (s.isInfinity()) {

throw new IllegalArgumentException("invalid key: [h]Q at infinity");

}

random = rParam.getRandom();

} else {

ecKey = (ECKeyParameters) param;

ecParams = ecKey.getParameters();

}

curveLength = (ecParams.getCurve().getFieldSize() + 7) / 8;

}

/**

* 进行加密、或解密

* @param in

* @param inOff

* @param inLen

* @return

* @throws InvalidCipherTextException

public byte[] processBlock(

byte[] in,

int inOff,

int inLen)

throws IOException, InvalidCipherTextException {

if (forEncryption) {

return encrypt(in, inOff, inLen);

} else {

return decrypt(in, inOff, inLen);

}

public int getOutputSize(int inputLen) {

return (1 + 2 * curveLength) + inputLen + digest.getDigestSize();

}

protected ECMultiplier createBasePointMultiplier() {

return new FixedPointCombMultiplier();

}

private byte[] encrypt(byte[] in, int inOff, int inLen)

throws IOException {

byte[] c2 = new byte[inLen];

System.arraycopy(in, inOff, c2, 0, c2.length);

ECMultiplier multiplier = createBasePointMultiplier();

ECPoint c1P;

ECPoint kPB;

do {

BigInteger k = nextK();

c1P = multiplier.multiply(ecParams.getG(), k).normalize();

// c1 = c1P.getEncoded(false);

kPB = ((ECPublicKeyParameters) ecKey).getQ().multiply(k).normalize();

kdf(digest, kPB, c2);

}

while (notEncrypted(c2, in, inOff));

byte[] c3 = new byte[digest.getDigestSize()];

addFieldElement(digest, kPB.getAffineXCoord());

digest.update(in, inOff, inLen);

addFieldElement(digest, kPB.getAffineYCoord());

digest.doFinal(c3, 0);

switch (mode) {

case C1C3C2:

// 2020/06/01 按国标组装为 ANS.1 编码

final ASN1EncodableVector vector = new ASN1EncodableVector();

vector.add(new ASN1Integer(c1P.getXCoord().toBigInteger()));

vector.add(new ASN1Integer(c1P.getYCoord().toBigInteger()));

vector.add(new DEROctetString(c3));

vector.add(new DEROctetString(c2));

return new DERSequence(vector).getEncoded();

default:

byte[] c1 = c1P.getEncoded(false);

return Arrays.concatenate(c1, c2, c3);

}

private byte[] decrypt(byte[] in, int inOff, int inLen)

throws InvalidCipherTextException, IOException {

ECPoint c1P; // = ecParams.getCurve().decodePoint(c1);

byte[] inHash ;

byte[] inCipherData;

if (mode == Mode.C1C3C2) {

// 2020/06/01 按国标 ANS.1 编码进行解码

ASN1InputStream inputStream = new ASN1InputStream(in);

ASN1Sequence seq = (ASN1Sequence) inputStream.readObject();

if (seq.size() != 4){

throw new InvalidCipherTextException("invalid cipher text");

}

int index = 0;

// C1 == XCoordinate 、YCoordinate

BigInteger x = ((ASN1Integer) seq.getObjectAt(index ++)).getPositiveValue();

// YCoordinate

BigInteger y = ((ASN1Integer) seq.getObjectAt(index ++)).getPositiveValue();

// XCoord 、YCoord ==> CEPoint (C1)

c1P = ecParams.getCurve().createPoint(x, y);

// HASH (C3)

inHash = ((ASN1OctetString)seq.getObjectAt(index ++)).getOctets();

// CipherText (C2)

inCipherData = ((ASN1OctetString)seq.getObjectAt(index)).getOctets();

} else {

// C1

byte[] c1 = new byte[curveLength * 2 + 1];

System.arraycopy(in, inOff, c1, 0, c1.length);

c1P = ecParams.getCurve().decodePoint(c1);

// C2 == inCipherData

int digestSize = this.digest.getDigestSize();

inCipherData = new byte[inLen - c1.length - digestSize];

System.arraycopy(in, inOff + c1.length, inCipherData, 0, inCipherData.length);

// C3 == Hash

inHash = new byte[digestSize];

System.arraycopy(in, inOff + c1.length + inCipherData.length, inHash, 0, inHash.length);

}

// 解密 ==> inCipherData;

ECPoint s = c1P.multiply(ecParams.getH());

if (s.isInfinity())

{

throw new InvalidCipherTextException("[h]C1 at infinity");

}

c1P = c1P.multiply(((ECPrivateKeyParameters)ecKey).getD()).normalize();

kdf(digest, c1P, inCipherData);

// 动态计算已解密的明文的摘要并比较

byte[] cipherDigest = new byte[digest.getDigestSize()];

addFieldElement(digest, c1P.getAffineXCoord());

digest.update(inCipherData, 0, inCipherData.length);

addFieldElement(digest, c1P.getAffineYCoord());

digest.doFinal(cipherDigest, 0);

int check = 0;

if (mode == Mode.C1C3C2)

{

for (int i = 0; i != cipherDigest.length; i++) {

check |= cipherDigest[i] ^ inHash[i];

}

} else {

for (int i = 0; i != cipherDigest.length; i++) {

check |= cipherDigest[i] ^ inHash[i];

}

// Arrays.fill(c1, (byte)0);

Arrays.fill(cipherDigest, (byte)0);

if (check != 0)

{

Arrays.fill(inCipherData, (byte)0);

throw new InvalidCipherTextException("invalid cipher text");

}

// return c2;

return inCipherData;

}

private boolean notEncrypted(byte[] encData, byte[] in, int inOff) {

for (int i = 0; i != encData.length; i++) {

if (encData[i] != in[inOff + i]) {

return false;

}

return true;

}

private void kdf(Digest digest, ECPoint c1, byte[] encData) {

int digestSize = digest.getDigestSize();

byte[] buf = new byte[Math.max(4, digestSize)];

int off = 0;

Memoable memo = null;

Memoable copy = null;

if (digest instanceof Memoable) {

addFieldElement(digest, c1.getAffineXCoord());

addFieldElement(digest, c1.getAffineYCoord());

memo = (Memoable) digest;

copy = memo.copy();

}

int ct = 0;

while (off < encData.length) {

if (memo != null) {

memo.reset(copy);

} else {

addFieldElement(digest, c1.getAffineXCoord());

addFieldElement(digest, c1.getAffineYCoord());

}

Pack.intToBigEndian(++ct, buf, 0);

digest.update(buf, 0, 4);

digest.doFinal(buf, 0);

int xorLen = Math.min(digestSize, encData.length - off);

xor(encData, buf, off, xorLen);

off += xorLen;

}

private void xor(byte[] data, byte[] kdfOut, int dOff, int dRemaining) {

for (int i = 0; i != dRemaining; i++) {

data[dOff + i] ^= kdfOut[i];

}

private BigInteger nextK() {

int qBitLength = ecParams.getN().bitLength();

BigInteger k;

do {

k = BigIntegers.createRandomBigInteger(qBitLength, random);

}

while (k.equals(BigIntegers.ZERO) || k.compareTo(ecParams.getN()) >= 0);

return k;

}

private void addFieldElement(Digest digest, ECFieldElement v) {

byte[] p = BigIntegers.asUnsignedByteArray(curveLength, v.toBigInteger());

digest.update(p, 0, p.length);

}

工具类：

import org.bouncycastle.asn1.gm.GMNamedCurves;
import org.bouncycastle.asn1.x9.X9ECParameters;
import org.bouncycastle.crypto.InvalidCipherTextException;
import org.bouncycastle.crypto.params.ECDomainParameters;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.crypto.params.ParametersWithRandom;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.jce.spec.ECParameterSpec;
import org.bouncycastle.jce.spec.ECPrivateKeySpec;
import org.bouncycastle.jce.spec.ECPublicKeySpec;
import org.bouncycastle.util.encoders.Hex;

import java.io.IOException;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;


public class SM2Util {
    //椭圆曲线ECParameters ASN.1 结构
    private static final X9ECParameters x9ECParameters = GMNamedCurves.getByName("sm2p256v1");
    //椭圆曲线公钥或私钥的基本域参数。
    private static final ECParameterSpec ecDomainParameters = new ECParameterSpec(x9ECParameters.getCurve(), x9ECParameters.getG(), x9ECParameters.getN());

    /**
     * 公钥字符串转换为 BCECPublicKey 公钥对象
     *
     * @param pubKeyHex 64字节十六进制公钥字符串(如果公钥字符串为65字节首个字节为0x04：表示该公钥为非压缩格式，操作时需要删除)
     * @return BCECPublicKey SM2公钥对象
     */
    public static BCECPublicKey getECPublicKeyByPublicKeyHex(String pubKeyHex) {
        //截取64字节有效的SM2公钥（如果公钥首个字节为0x04）
        if (pubKeyHex.length() > 128) {
            pubKeyHex = pubKeyHex.substring(pubKeyHex.length() - 128);
        }
        //将公钥拆分为x,y分量（各32字节）
        String stringX = pubKeyHex.substring(0, 64);
        String stringY = pubKeyHex.substring(stringX.length());
        //将公钥x、y分量转换为BigInteger类型
        BigInteger x = new BigInteger(stringX, 16);
        BigInteger y = new BigInteger(stringY, 16);
        //通过公钥x、y分量创建椭圆曲线公钥规范
        ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(x9ECParameters.getCurve().createPoint(x, y), ecDomainParameters);
        //通过椭圆曲线公钥规范，创建出椭圆曲线公钥对象（可用于SM2加密及验签）
        return new BCECPublicKey("EC", ecPublicKeySpec, BouncyCastleProvider.CONFIGURATION);
    }


    /**
     * 私钥字符串转换为 BCECPrivateKey 私钥对象
     *
     * @param privateKeyHex: 32字节十六进制私钥字符串
     * @return BCECPrivateKey:SM2私钥对象
     */
    public static BCECPrivateKey getBCECPrivateKeyByPrivateKeyHex(String privateKeyHex) {
        //将十六进制私钥字符串转换为BigInteger对象
        BigInteger d = new BigInteger(privateKeyHex, 16);
        //通过私钥和私钥域参数集创建椭圆曲线私钥规范
        ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(d, ecDomainParameters);
        //通过椭圆曲线私钥规范，创建出椭圆曲线私钥对象（可用于SM2解密和签名）
        return new BCECPrivateKey("EC", ecPrivateKeySpec, BouncyCastleProvider.CONFIGURATION);
    }

    /**
     * SM2加密算法
     *
     * @param parameters 公钥参数
     * @param data       明文数据
     */
    public static String encrypt(ECPublicKeyParameters parameters, String data) throws InvalidCipherTextException, IOException {
        MySm2Engine sm2Engine = new MySm2Engine();
        sm2Engine.init(true, new ParametersWithRandom(parameters, new SecureRandom()));

        byte[] in = data.getBytes(StandardCharsets.UTF_8);
        return Hex.toHexString(sm2Engine.processBlock(in, 0, in.length));
    }

    /**
     * SM2加密算法
     *
     * @param publicKey 公钥
     * @param data      明文数据
     */
    public static String encrypt(PublicKey publicKey, String data) throws InvalidCipherTextException, IOException {
        ECPublicKeyParameters ecPublicKeyParameters = null;
        if (publicKey instanceof BCECPublicKey) {
            BCECPublicKey bcecPublicKey = (BCECPublicKey) publicKey;
            ECParameterSpec ecParameterSpec = bcecPublicKey.getParameters();
            ECDomainParameters ecDomainParameters = new ECDomainParameters(ecParameterSpec.getCurve(),
                    ecParameterSpec.getG(), ecParameterSpec.getN());
            ecPublicKeyParameters = new ECPublicKeyParameters(bcecPublicKey.getQ(), ecDomainParameters);
        }

        return encrypt(ecPublicKeyParameters, data);
    }

    /**
     * SM2解密算法
     *
     * @param privateKey 私钥
     * @param cipherData 密文数据
     */
    public static String decrypt(PrivateKey privateKey, String cipherData) throws InvalidCipherTextException, IOException {
        byte[] cipherDataByte = Hex.decode(cipherData);

        BCECPrivateKey bcecPrivateKey = (BCECPrivateKey) privateKey;
        ECParameterSpec ecParameterSpec = bcecPrivateKey.getParameters();

        ECDomainParameters ecDomainParameters = new ECDomainParameters(ecParameterSpec.getCurve(),
                ecParameterSpec.getG(), ecParameterSpec.getN());

        ECPrivateKeyParameters ecPrivateKeyParameters = new ECPrivateKeyParameters(bcecPrivateKey.getD(),
                ecDomainParameters);

        MySm2Engine sm2Engine = new MySm2Engine();
        sm2Engine.init(false, ecPrivateKeyParameters);

        byte[] arrayOfBytes = sm2Engine.processBlock(cipherDataByte, 0, cipherDataByte.length);
        return new String(arrayOfBytes, StandardCharsets.UTF_8);
    }

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

import org.bouncycastle.asn1.gm.GMNamedCurves;

import org.bouncycastle.asn1.x9.X9ECParameters;

import org.bouncycastle.crypto.InvalidCipherTextException;

import org.bouncycastle.crypto.params.ECDomainParameters;

import org.bouncycastle.crypto.params.ECPrivateKeyParameters;

import org.bouncycastle.crypto.params.ECPublicKeyParameters;

import org.bouncycastle.crypto.params.ParametersWithRandom;

import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;

import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import org.bouncycastle.jce.spec.ECParameterSpec;

import org.bouncycastle.jce.spec.ECPrivateKeySpec;

import org.bouncycastle.jce.spec.ECPublicKeySpec;

import org.bouncycastle.util.encoders.Hex;

import java.io.IOException;

import java.math.BigInteger;

import java.nio.charset.StandardCharsets;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.SecureRandom;

public class SM2Util {

//椭圆曲线ECParameters ASN.1 结构

private static final X9ECParameters x9ECParameters = GMNamedCurves.getByName("sm2p256v1");

//椭圆曲线公钥或私钥的基本域参数。

private static final ECParameterSpec ecDomainParameters = new ECParameterSpec(x9ECParameters.getCurve(), x9ECParameters.getG(), x9ECParameters.getN());

/**

* 公钥字符串转换为 BCECPublicKey 公钥对象

* @param pubKeyHex 64字节十六进制公钥字符串(如果公钥字符串为65字节首个字节为0x04：表示该公钥为非压缩格式，操作时需要删除)

* @return BCECPublicKey SM2公钥对象

public static BCECPublicKey getECPublicKeyByPublicKeyHex(String pubKeyHex) {

//截取64字节有效的SM2公钥（如果公钥首个字节为0x04）

if (pubKeyHex.length() > 128) {

pubKeyHex = pubKeyHex.substring(pubKeyHex.length() - 128);

}

//将公钥拆分为x,y分量（各32字节）

String stringX = pubKeyHex.substring(0, 64);

String stringY = pubKeyHex.substring(stringX.length());

//将公钥x、y分量转换为BigInteger类型

BigInteger x = new BigInteger(stringX, 16);

BigInteger y = new BigInteger(stringY, 16);

//通过公钥x、y分量创建椭圆曲线公钥规范

ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(x9ECParameters.getCurve().createPoint(x, y), ecDomainParameters);

//通过椭圆曲线公钥规范，创建出椭圆曲线公钥对象（可用于SM2加密及验签）

return new BCECPublicKey("EC", ecPublicKeySpec, BouncyCastleProvider.CONFIGURATION);

}

/**

* 私钥字符串转换为 BCECPrivateKey 私钥对象

* @param privateKeyHex: 32字节十六进制私钥字符串

* @return BCECPrivateKey:SM2私钥对象

public static BCECPrivateKey getBCECPrivateKeyByPrivateKeyHex(String privateKeyHex) {

//将十六进制私钥字符串转换为BigInteger对象

BigInteger d = new BigInteger(privateKeyHex, 16);

//通过私钥和私钥域参数集创建椭圆曲线私钥规范

ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(d, ecDomainParameters);

//通过椭圆曲线私钥规范，创建出椭圆曲线私钥对象（可用于SM2解密和签名）

return new BCECPrivateKey("EC", ecPrivateKeySpec, BouncyCastleProvider.CONFIGURATION);

}

/**

* SM2加密算法

* @param parameters 公钥参数

* @param data 明文数据

public static String encrypt(ECPublicKeyParameters parameters, String data) throws InvalidCipherTextException, IOException {

MySm2Engine sm2Engine = new MySm2Engine();

sm2Engine.init(true, new ParametersWithRandom(parameters, new SecureRandom()));

byte[] in = data.getBytes(StandardCharsets.UTF_8);

return Hex.toHexString(sm2Engine.processBlock(in, 0, in.length));

}

/**

* SM2加密算法

* @param publicKey 公钥

* @param data 明文数据

public static String encrypt(PublicKey publicKey, String data) throws InvalidCipherTextException, IOException {

ECPublicKeyParameters ecPublicKeyParameters = null;

if (publicKey instanceof BCECPublicKey) {

BCECPublicKey bcecPublicKey = (BCECPublicKey) publicKey;

ECParameterSpec ecParameterSpec = bcecPublicKey.getParameters();

ECDomainParameters ecDomainParameters = new ECDomainParameters(ecParameterSpec.getCurve(),

ecParameterSpec.getG(), ecParameterSpec.getN());

ecPublicKeyParameters = new ECPublicKeyParameters(bcecPublicKey.getQ(), ecDomainParameters);

}

return encrypt(ecPublicKeyParameters, data);

}

/**

* SM2解密算法

* @param privateKey 私钥

* @param cipherData 密文数据

public static String decrypt(PrivateKey privateKey, String cipherData) throws InvalidCipherTextException, IOException {

byte[] cipherDataByte = Hex.decode(cipherData);

BCECPrivateKey bcecPrivateKey = (BCECPrivateKey) privateKey;

ECParameterSpec ecParameterSpec = bcecPrivateKey.getParameters();

ECDomainParameters ecDomainParameters = new ECDomainParameters(ecParameterSpec.getCurve(),

ecParameterSpec.getG(), ecParameterSpec.getN());

ECPrivateKeyParameters ecPrivateKeyParameters = new ECPrivateKeyParameters(bcecPrivateKey.getD(),

ecDomainParameters);

MySm2Engine sm2Engine = new MySm2Engine();

sm2Engine.init(false, ecPrivateKeyParameters);

byte[] arrayOfBytes = sm2Engine.processBlock(cipherDataByte, 0, cipherDataByte.length);

return new String(arrayOfBytes, StandardCharsets.UTF_8);

}

测试例子：

import org.bouncycastle.crypto.InvalidCipherTextException;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import java.io.IOException;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.ECGenParameterSpec;

public class sm2_demo {

    public static void main(String[] args) throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidCipherTextException, IOException {

        final ECGenParameterSpec sm2Spec = new ECGenParameterSpec("sm2p256v1");
        // 获取一个椭圆曲线类型的密钥对生成器
        final KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", new BouncyCastleProvider());
        // 使用SM2参数初始化生成器
        kpg.initialize(sm2Spec);
        // 获取密钥对
        KeyPair keyPair = kpg.generateKeyPair();
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();
        String m = "lzc_SM2_demo";
        String data = SM2Util.encrypt(publicKey, m);
        System.out.println(data);
        String text = SM2Util.decrypt(privateKey, data);
        System.out.println(text);
    }
}

import org.bouncycastle.crypto.InvalidCipherTextException;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import java.io.IOException;

import java.security.InvalidAlgorithmParameterException;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.spec.ECGenParameterSpec;

public class sm2_demo {

public static void main(String[] args) throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidCipherTextException, IOException {

final ECGenParameterSpec sm2Spec = new ECGenParameterSpec("sm2p256v1");

// 获取一个椭圆曲线类型的密钥对生成器

final KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", new BouncyCastleProvider());

// 使用SM2参数初始化生成器

kpg.initialize(sm2Spec);

// 获取密钥对

KeyPair keyPair = kpg.generateKeyPair();

PublicKey publicKey = keyPair.getPublic();

PrivateKey privateKey = keyPair.getPrivate();

String m = "lzc_SM2_demo";

String data = SM2Util.encrypt(publicKey, m);

System.out.println(data);

String text = SM2Util.decrypt(privateKey, data);

System.out.println(text);

}

参考链接

一篇文章搞懂密码学基础及SSL/TLS协议

密码学基础

古典的密码

密码学的历史可以追溯到很久以前，早在罗马共和国时期，据说凯撒就使用凯撒密码和他的将军进行通信。

继续阅读一篇文章搞懂密码学基础及SSL/TLS协议

OpenSSL通过OCSP手动验证证书

这篇文章主要用来说明如何借助ocsp服务器来验证证书。ocsp（The Online Certificate Status Protocol）是一种验证证书状态的一种方式，也是CRL（certificate revocation list）证书吊销的一种替代方式。

与传统的CRL比较有以下特点：

由于相对于传统的CRL，一个ocsp响应包含的信息更少，故ocsp能够更有效利用网络和客户资源
用OCSP，客户无需自己解析CRL证书吊销列表，但是客户需要存储状态信息，而由于客户侧需要维护存储缓存，故导致存储信息很复杂。在实际使用中，这点带来的影响却很小，由于第三库提供的相关接口已经帮我们完成此类工作
OCSP通过专用网络、专用证书、在特定的时间公开其服务。OCSP不强制加密，故可能带来信息泄露的风险。

此文章中用到的openssl的版本为：OpenSSL 1.0.1g 7 Apr 2014

1、获取证书用于ocsp验证

首先，我们将从一个网站上获取一个证书，这里我们用Wikipedia作为样例来进行。我们获取证书通过如下命令：

$ openssl s_client -connect wikipedia.org:443 2>&1 < /dev/null | sed -n '/-----BEGIN/,/-----END/p'

1	$ openssl s_client -connect wikipedia.org:443 2>&1 < /dev/null \| sed -n '/-----BEGIN/,/-----END/p'

过该命令可以获取wikipedia.org的客户端证书

保存这个输出到wikipedia.pem文件中

$ openssl s_client -connect wikipedia.org:443 2>&1 < /dev/null | sed -n '/-----BEGIN/,/-----END/p' > wikipedia.pem

1	$ openssl s_client -connect wikipedia.org:443 2>&1 < /dev/null \| sed -n '/-----BEGIN/,/-----END/p' > wikipedia.pem

　现在，检查整个证书中是否包含ocsp网址

$ openssl x509 -noout -ocsp_uri -in wikipedia.pem

1	$ openssl x509 -noout -ocsp_uri -in wikipedia.pem

若执行正确则输出 http://ocsp.digicert.com ，否则你就不能通过ocsp验证这个证书

2、获取证书链

由于这个证书认证是一级一级逐层进行，故需要获得与这个证书相关的证书链。利用openssl s_client -showcerts 选项，能够查看到在该信任链上的所有相关证书

$ openssl s_client -connect wikipedia.org:443 -showcerts 2>&1 < /dev/null

1	$ openssl s_client -connect wikipedia.org:443 -showcerts 2>&1 < /dev/null

 1 s:/C=US/O=DigiCert Inc/OU=www.digicert.com/CN=DigiCert High Assurance CA-3
   i:/C=US/O=DigiCert Inc/OU=www.digicert.com/CN=DigiCert High Assurance EV Root CA
-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----

1 s:/C=US/O=DigiCert Inc/OU=www.digicert.com/CN=DigiCert High Assurance CA-3

i:/C=US/O=DigiCert Inc/OU=www.digicert.com/CN=DigiCert High Assurance EV Root CA

-----BEGIN CERTIFICATE-----

MIIGWDCCBUCgAwIBAgIQCl8RTQNbF5EX0u/UA4w/OzANBgkqhkiG9w0BAQUFADBs

MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3

d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j

ZSBFViBSb290IENBMB4XDTA4MDQwMjEyMDAwMFoXDTIyMDQwMzAwMDAwMFowZjEL

MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3

LmRpZ2ljZXJ0LmNvbTElMCMGA1UEAxMcRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug

Q0EtMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9hCikQH17+NDdR

CPge+yLtYb4LDXBMUGMmdRW5QYiXtvCgFbsIYOBC6AUpEIc2iihlqO8xB3RtNpcv

KEZmBMcqeSZ6mdWOw21PoF6tvD2Rwll7XjZswFPPAAgyPhBkWBATaccM7pxCUQD5

BUTuJM56H+2MEb0SqPMV9Bx6MWkBG6fmXcCabH4JnudSREoQOiPkm7YDr6ictFuf

1EutkozOtREqqjcYjbTCuNhcBoz4/yO9NV7UfD5+gw6RlgWYw7If48hl66l7XaAs

zPw82W3tzPpLQ4zJ1LilYRyyQLYoEt+5+F/+07LJ7z20Hkt8HEyZNp496+ynaF4d

32duXvsCAwEAAaOCAvowggL2MA4GA1UdDwEB/wQEAwIBhjCCAcYGA1UdIASCAb0w

ggG5MIIBtQYLYIZIAYb9bAEDAAIwggGkMDoGCCsGAQUFBwIBFi5odHRwOi8vd3d3

LmRpZ2ljZXJ0LmNvbS9zc2wtY3BzLXJlcG9zaXRvcnkuaHRtMIIBZAYIKwYBBQUH

AgIwggFWHoIBUgBBAG4AeQAgAHUAcwBlACAAbwBmACAAdABoAGkAcwAgAEMAZQBy

AHQAaQBmAGkAYwBhAHQAZQAgAGMAbwBuAHMAdABpAHQAdQB0AGUAcwAgAGEAYwBj

AGUAcAB0AGEAbgBjAGUAIABvAGYAIAB0AGgAZQAgAEQAaQBnAGkAQwBlAHIAdAAg

AEMAUAAvAEMAUABTACAAYQBuAGQAIAB0AGgAZQAgAFIAZQBsAHkAaQBuAGcAIABQ

AGEAcgB0AHkAIABBAGcAcgBlAGUAbQBlAG4AdAAgAHcAaABpAGMAaAAgAGwAaQBt

AGkAdAAgAGwAaQBhAGIAaQBsAGkAdAB5ACAAYQBuAGQAIABhAHIAZQAgAGkAbgBj

AG8AcgBwAG8AcgBhAHQAZQBkACAAaABlAHIAZQBpAG4AIABiAHkAIAByAGUAZgBl

AHIAZQBuAGMAZQAuMBIGA1UdEwEB/wQIMAYBAf8CAQAwNAYIKwYBBQUHAQEEKDAm

MCQGCCsGAQUFBzABhhhodHRwOi8vb2NzcC5kaWdpY2VydC5jb20wgY8GA1UdHwSB

hzCBhDBAoD6gPIY6aHR0cDovL2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0SGln

aEFzc3VyYW5jZUVWUm9vdENBLmNybDBAoD6gPIY6aHR0cDovL2NybDQuZGlnaWNl

cnQuY29tL0RpZ2lDZXJ0SGlnaEFzc3VyYW5jZUVWUm9vdENBLmNybDAfBgNVHSME

GDAWgBSxPsNpA/i/RwHUmCYaCALvY2QrwzAdBgNVHQ4EFgQUUOpzidsp+xCPnuUB

INTeeZlIg/cwDQYJKoZIhvcNAQEFBQADggEBAB7ipUiebNtTOA/vphoqrOIDQ+2a

vD6OdRvw/S4iWawTwGHi5/rpmc2HCXVUKL9GYNy+USyS8xuRfDEIcOI3ucFbqL2j

CwD7GhX9A61YasXHJJlIR0YxHpLvtF9ONMeQvzHB+LGEhtCcAarfilYGzjrpDq6X

dF3XcZpCdF/ejUN83ulV7WkAywXgemFhM9EZTfkI7qA5xSU1tyvED7Ld8aW3DiTE

JiiNeXf1L/BXunwH1OH8zVowV36GEEfdMR/X/KLCvzB8XSSq6PmuX2p0ws5rs0bY

Ib4p1I5eFdZCSucyb6Sxa1GDWL4/bcf72gMhy2oWGU4K8K2Eyl2Us1p292E=

-----END CERTIFICATE-----

如你所见，输出能够看到两个证书，number 1 和number 0，其中number 0就是我们刚刚获取的那个证书。如果你的网站有更多证书在认证链中，那么你将看到更多证书。为了发送证书，需要保存证书链中所有证书到一个文件chain.pem，按照刚刚命令输出的证书顺序，根证书总是在文件结尾。

3、发送ocsp认证请求

现在我们有ocsp认证请求的所有信息，使用下面命令发送ocsp认证请求。

$ openssl ocsp -issuer chain.pem -cert wikipedia.pem -text -url http://ocsp.digicert.com

1	$ openssl ocsp -issuer chain.pem -cert wikipedia.pem -text -url http://ocsp.digicert.com

其结果如下

OCSP Request Data:
    Version: 1 (0x0)
    Requestor List:
        Certificate ID:
          Hash Algorithm: sha1
          Issuer Name Hash: ED48ADDDCB7B00E20E842AA9B409F1AC3034CF96
          Issuer Key Hash: 50EA7389DB29FB108F9EE50120D4DE79994883F7
          Serial Number: 0114195F66FAFF8FD66E12496E516F4F
    Request Extensions:
        OCSP Nonce:
            0410DA634F2ADC31DC48AE89BE64E8252D12
OCSP Response Data:
    OCSP Response Status: successful (0x0)
    Response Type: Basic OCSP Response
    Version: 1 (0x0)
    Responder Id: 50EA7389DB29FB108F9EE50120D4DE79994883F7
    Produced At: Apr  9 08:45:00 2014 GMT
    Responses:
    Certificate ID:
      Hash Algorithm: sha1
      Issuer Name Hash: ED48ADDDCB7B00E20E842AA9B409F1AC3034CF96
      Issuer Key Hash: 50EA7389DB29FB108F9EE50120D4DE79994883F7
      Serial Number: 0114195F66FAFF8FD66E12496E516F4F
    Cert Status: good
    This Update: Apr  9 08:45:00 2014 GMT
    Next Update: Apr 16 09:00:00 2014 GMT


    Signature Algorithm: sha1WithRSAEncryption
         56:21:4c:dc:84:21:f7:a8:ac:a7:b9:bc:10:19:f8:19:f1:34:
         c1:63:ca:14:7f:8f:5a:85:2a:cc:02:b0:f8:b5:05:4a:0f:28:
         50:2a:4a:4d:04:01:b5:05:ef:a5:88:41:d8:9d:38:00:7d:76:
         1a:aa:ff:21:50:68:90:d2:0c:93:85:49:e7:8e:f1:58:08:77:
         a0:4e:e2:22:98:01:b7:e3:27:75:11:f5:b7:8f:e0:75:7d:19:
         9b:74:cf:05:dc:ae:1c:36:09:95:b6:08:bc:e7:3f:ea:a2:e3:
         ae:d7:8f:c0:9d:8e:c2:37:67:c7:5b:d8:b0:67:23:f1:51:53:
         26:c2:96:b0:1a:df:4e:fb:4e:e3:da:a3:98:26:59:a8:d7:17:
         69:87:a3:68:47:08:92:d0:37:04:6b:49:9a:96:9d:9c:b1:e8:
         cb:dc:68:7b:4a:4d:cb:08:f7:92:67:41:99:b6:54:56:80:0c:
         18:a7:24:53:ac:c6:da:1f:4d:f4:3c:7d:68:44:1d:a4:df:1d:
         48:07:85:52:86:59:46:d1:35:45:1a:c7:6b:6b:92:de:24:ae:
         c0:97:66:54:29:7a:c6:86:a6:da:9f:06:24:dc:ac:80:66:95:
         e0:eb:49:fd:fb:d4:81:6a:2b:81:41:57:24:78:3b:e0:66:70:
         d4:2e:52:92
wikipedia.pem: good
    This Update: Apr  9 08:45:00 2014 GMT
    Next Update: Apr 16 09:00:00 2014 GMT

OCSP Request Data:

Version: 1 (0x0)

Requestor List:

Certificate ID:

Hash Algorithm: sha1

Issuer Name Hash: ED48ADDDCB7B00E20E842AA9B409F1AC3034CF96

Issuer Key Hash: 50EA7389DB29FB108F9EE50120D4DE79994883F7

Serial Number: 0114195F66FAFF8FD66E12496E516F4F

Request Extensions:

OCSP Nonce:

0410DA634F2ADC31DC48AE89BE64E8252D12

OCSP Response Data:

OCSP Response Status: successful (0x0)

Response Type: Basic OCSP Response

Version: 1 (0x0)

Responder Id: 50EA7389DB29FB108F9EE50120D4DE79994883F7

Produced At: Apr 9 08:45:00 2014 GMT

Responses:

Certificate ID:

Hash Algorithm: sha1

Issuer Name Hash: ED48ADDDCB7B00E20E842AA9B409F1AC3034CF96

Issuer Key Hash: 50EA7389DB29FB108F9EE50120D4DE79994883F7

Serial Number: 0114195F66FAFF8FD66E12496E516F4F

Cert Status: good

This Update: Apr 9 08:45:00 2014 GMT

Next Update: Apr 16 09:00:00 2014 GMT

Signature Algorithm: sha1WithRSAEncryption

56:21:4c:dc:84:21:f7:a8:ac:a7:b9:bc:10:19:f8:19:f1:34:

c1:63:ca:14:7f:8f:5a:85:2a:cc:02:b0:f8:b5:05:4a:0f:28:

50:2a:4a:4d:04:01:b5:05:ef:a5:88:41:d8:9d:38:00:7d:76:

1a:aa:ff:21:50:68:90:d2:0c:93:85:49:e7:8e:f1:58:08:77:

a0:4e:e2:22:98:01:b7:e3:27:75:11:f5:b7:8f:e0:75:7d:19:

9b:74:cf:05:dc:ae:1c:36:09:95:b6:08:bc:e7:3f:ea:a2:e3:

ae:d7:8f:c0:9d:8e:c2:37:67:c7:5b:d8:b0:67:23:f1:51:53:

26:c2:96:b0:1a:df:4e:fb:4e:e3:da:a3:98:26:59:a8:d7:17:

69:87:a3:68:47:08:92:d0:37:04:6b:49:9a:96:9d:9c:b1:e8:

cb:dc:68:7b:4a:4d:cb:08:f7:92:67:41:99:b6:54:56:80:0c:

18:a7:24:53:ac:c6:da:1f:4d:f4:3c:7d:68:44:1d:a4:df:1d:

48:07:85:52:86:59:46:d1:35:45:1a:c7:6b:6b:92:de:24:ae:

c0:97:66:54:29:7a:c6:86:a6:da:9f:06:24:dc:ac:80:66:95:

e0:eb:49:fd:fb:d4:81:6a:2b:81:41:57:24:78:3b:e0:66:70:

d4:2e:52:92

wikipedia.pem: good

This Update: Apr 9 08:45:00 2014 GMT

Next Update: Apr 16 09:00:00 2014 GMT

如果你需要更简略的输出，去掉-text　选项，该选项一般用于调试

$ openssl ocsp -issuer chain.pem -cert wikipedia.pem -url http://ocsp.digicert.com
wikipedia.pem: good
    This Update: Apr  9 08:45:00 2014 GMT
    Next Update: Apr 16 09:00:00 2014 GMT

$ openssl ocsp -issuer chain.pem -cert wikipedia.pem -url http://ocsp.digicert.com

wikipedia.pem: good

This Update: Apr 9 08:45:00 2014 GMT

Next Update: Apr 16 09:00:00 2014 GMT

4、吊销证书

如果你有一个吊销的证书，你也可以测试该证书按照上述步骤，所得的响应如下：

Response verify OK
test-revoked.pem: revoked
    This Update: Apr  9 03:02:45 2014 GMT
    Next Update: Apr 10 03:02:45 2014 GMT
    Revocation Time: Mar 25 15:45:55 2014 GMT

Response verify OK

test-revoked.pem: revoked

This Update: Apr 9 03:02:45 2014 GMT

Next Update: Apr 10 03:02:45 2014 GMT

Revocation Time: Mar 25 15:45:55 2014 GMT

5、其他错误

如果证书和ocsp服务不匹配，验证将错误，使用-text选项可以查看具体错误。

参考链接

RSA算法原理

如果你问我，哪一种算法最重要？

我可能会回答"公钥加密算法"。

因为它是计算机通信安全的基石，保证了加密数据不会被破解。你可以想象一下，信用卡交易被破解的后果。

进入正题之前，我先简单介绍一下，什么是"公钥加密算法"。

一、一点历史

1976年以前，所有的加密方法都是同一种模式：

　　（1）甲方选择某一种加密规则，对信息进行加密；

　　（2）乙方使用同一种规则，对信息进行解密。

由于加密和解密使用同样规则（简称"密钥"），这被称为"对称加密算法"（Symmetric-Key Algorithm）。

这种加密模式有一个最大弱点：甲方必须把加密规则告诉乙方，否则无法解密。保存和传递密钥，就成了最头疼的问题。

1976年，两位美国计算机学家Whitfield Diffie 和 Martin Hellman，提出了一种崭新构思，可以在不直接传递密钥的情况下，完成解密。这被称为"Diffie-Hellman密钥交换算法"。这个算法启发了其他科学家。人们认识到，加密和解密可以使用不同的规则，只要这两种规则之间存在某种对应关系即可，这样就避免了直接传递密钥。

这种新的加密模式被称为"非对称加密算法"。

　　（1）乙方生成两把密钥（公钥和私钥）。公钥是公开的，任何人都可以获得，私钥则是保密的。

　　（2）甲方获取乙方的公钥，然后用它对信息加密。

　　（3）乙方得到加密后的信息，用私钥解密。

如果公钥加密的信息只有私钥解得开，那么只要私钥不泄漏，通信就是安全的。

1977年，三位数学家Rivest、Shamir 和 Adleman 设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字命名，叫做RSA算法。从那时直到现在，RSA算法一直是最广为使用的"非对称加密算法"。毫不夸张地说，只要有计算机网络的地方，就有RSA算法。

这种算法非常可靠，密钥越长，它就越难破解。根据已经披露的文献，目前被破解的最长RSA密钥是768个二进制位。也就是说，长度超过768位的密钥，还无法破解（至少没人公开宣布）。因此可以认为，1024位的RSA密钥基本安全，2048位的密钥极其安全。

下面，我就进入正题，解释RSA算法的原理。文章共分成两部分，今天是第一部分，介绍要用到的四个数学概念。你可以看到，RSA算法并不难，只需要一点数论知识就可以理解。

二、互质关系

如果两个正整数，除了1以外，没有其他公因子，我们就称这两个数是互质关系（coprime）。比如，15和32没有公因子，所以它们是互质关系。这说明，不是质数也可以构成互质关系。

关于互质关系，不难得到以下结论：

　　1. 任意两个质数构成互质关系，比如13和61。

　　2. 一个数是质数，另一个数只要不是前者的倍数，两者就构成互质关系，比如3和10。

　　3. 如果两个数之中，较大的那个数是质数，则两者构成互质关系，比如97和57。

　　4. 1和任意一个自然数是都是互质关系，比如1和99。

　　5. p是大于1的整数，则p和p-1构成互质关系，比如57和56。

　　6. p是大于1的奇数，则p和p-2构成互质关系，比如17和15。

三、欧拉函数

请思考以下问题：

　　任意给定正整数n，请问在小于等于n的正整数之中，有多少个与n构成互质关系？（比如，在1到8之中，有多少个数与8构成互质关系？）

计算这个值的方法就叫做欧拉函数，以$φ(n)$表示。在1到8之中，与8形成互质关系的是1、3、5、7，所以 $φ(n) = 4$。

$φ(n)$ 的计算方法并不复杂，但是为了得到最后那个公式，需要一步步讨论。

第一种情况

如果$n=1$，则 $\phi(1) = 1$ 。因为$1$与任何数（包括自身）都构成互质关系。

第二种情况

如果$n$是质数，则 $\Phi(n)=n-1$ 。因为质数与小于它的每一个数，都构成互质关系。比如5与1、2、3、4都构成互质关系。

第三种情况

如果$n$是质数的某一个次方，即 $n = p^k$ ($p$为质数，$k$为大于等于$1$的整数)，则

$\varPhi(p^k) {=} p^k - p^{k-1}$

比如 $φ(8) = φ(2^3) =2^3 - 2^2 = 8 -4 = 4$。

这是因为只有当一个数不包含质数p，才可能与n互质。而包含质数p的数一共有p^(k-1)个，即1×p、2×p、3×p、...、p^(k-1)×p，把它们去除，剩下的就是与n互质的数。

上面的式子还可以写成下面的形式：

$\varPhi(p^k) {=} p^k - p^{k-1} = p^k(1- \frac{1}{p})$

可以看出，上面的第二种情况是 k=1 时的特例。

第四种情况

如果n可以分解成两个互质的整数之积，

　　$n = p_1 * p_2$

则

　　$φ(n) = φ(p_1p_2) = φ(p_1)φ(p_2)$

即积的欧拉函数等于各个因子的欧拉函数之积。比如，φ(56)=φ(8×7)=φ(8)×φ(7)=4×6=24。

这一条的证明要用到"中国剩余定理"，这里就不展开了，只简单说一下思路：如果a与$p_1$互质(a<$p_1$)，b与$p_2$互质(b<$p_2$)，c与$p_1p_2$互质(c<$p_1p_2$)，则c与数对 (a,b) 是一一对应关系。由于a的值有$φ(p_1)$种可能，b的值有$φ(p_2)$种可能，则数对 (a,b) 有$φ(p_1)φ(p_2)$种可能，而c的值有$φ(p_1p_2)$种可能，所以$φ(p_1p_2)$就等于$φ(p_1)φ(p_2)$。

第五种情况

因为任意一个大于1的正整数，都可以写成一系列质数的积。

$n {=} p_1^{k_1} p_2^{k_2} \cdots p_r^{k_r}$

根据第4条的结论，得到

$\varPhi(n) {=} \varPhi(p_1^{k_1}) \varPhi(p_2^{k_2}) \cdots \varPhi(p_r^{k_r})$

再根据第3条的结论，得到

$\varPhi(n) {=} p_1^{k_1} p_2^{k_2} \cdots p_r^{k_r} (1- \frac{1}{p_1}) (1- \frac{1}{p_2}) \cdots (1- \frac{1}{p_r})$

也就等于

$\varPhi(n) {=} n(1- \frac{1}{p_1}) (1- \frac{1}{p_2}) \cdots (1- \frac{1}{p_r})$

这就是欧拉函数的通用计算公式。比如，1323的欧拉函数，计算过程如下：

$\varPhi(1323) {=} \varPhi(3^3 * 7^2) {=} 1323 (1- \frac{1}{3}) (1- \frac{1}{7}) = 756$

四、欧拉定理

欧拉函数的用处，在于欧拉定理。"欧拉定理"指的是：

如果两个正整数a和n互质，则n的欧拉函数 $φ(n)$ 可以让下面的等式成立：

$a^{\varPhi(n)} \equiv 1 \pmod{n}$

也就是说，a的φ(n)次方被n除的余数为1。或者说，a的φ(n)次方减去1，可以被n整除。比如，3和7互质，而7的欧拉函数φ(7)等于6，所以3的6次方（729）减去1，可以被7整除（728/7=104）。

欧拉定理的证明比较复杂，这里就省略了。我们只要记住它的结论就行了。

欧拉定理可以大大简化某些运算。比如，7和10互质，根据欧拉定理，

$7^{\varPhi(10)} \equiv 1 \pmod{10}$

已知 φ(10) 等于4，所以马上得到7的4倍数次方的个位数肯定是1。

$7^{4k} \equiv 1 \pmod{10}$

因此，7的任意次方的个位数（例如7的222次方），心算就可以算出来。

欧拉定理有一个特殊情况。

假设正整数a与质数p互质，因为质数p的φ(p)等于p-1，则欧拉定理可以写成

$a^{p-1} \equiv 1 \pmod{p}$

这就是著名的费马小定理。它是欧拉定理的特例。

欧拉定理是RSA算法的核心。理解了这个定理，就可以理解RSA。

五、模反元素

还剩下最后一个概念：

如果两个正整数a和n互质，那么一定可以找到整数b，使得 ab-1 被n整除，或者说ab被n除的余数是1。

$ab \equiv 1 \pmod{n}$

这时，b就叫做a的"模反元素"。

比如，3和11互质，那么3的模反元素就是4，因为 (3 × 4)-1 可以被11整除。显然，模反元素不止一个， 4加减11的整数倍都是3的模反元素 {...,-18,-7,4,15,26,...}，即如果b是a的模反元素，则 b+kn 都是a的模反元素。

欧拉定理可以用来证明模反元素必然存在。

$a^{\varPhi(n)} {=} a* a^{\varPhi(n)-1} \equiv 1 \pmod{n}$

可以看到，a的 $φ(n)-1$ 次方，就是a的模反元素。

==========================================

好了，需要用到的数学工具，全部介绍完了。RSA算法涉及的数学知识，就是上面这些，下一次我就来介绍公钥和私钥到底是怎么生成的。

有了这些知识，我们就可以看懂RSA算法。这是目前地球上最重要的加密算法。

六、密钥生成的步骤

我们通过一个例子，来理解RSA算法。假设爱丽丝要与鲍勃进行加密通信，她该怎么生成公钥和私钥呢？

第一步，随机选择两个不相等的质数p和q。

爱丽丝选择了61和53。（实际应用中，这两个质数越大，就越难破解。）

第二步，计算p和q的乘积n。

爱丽丝就把61和53相乘。

　　$n = 61*53 = 3233$

n的长度就是密钥长度。3233写成二进制是110010100001，一共有12位，所以这个密钥就是12位。实际应用中，RSA密钥一般是1024位，重要场合则为2048位。

第三步，计算n的欧拉函数φ(n)。

根据公式：

　　$\varPhi(n) = (p-1)(q-1)$

爱丽丝算出φ(3233)等于60×52，即3120。

第四步，随机选择一个整数e，条件是1< e < φ(n)，且e与φ(n) 互质。

爱丽丝就在1到3120之间，随机选择了17。（实际应用中，常常选择65537）

第五步，计算e对于φ(n)的模反元素d。

所谓"模反元素"就是指有一个整数d，可以使得ed被φ(n)除的余数为1。

　　$ed \equiv 1 \pmod{\varPhi(n)}$

这个式子等价于

　　$ed - 1 = k\varPhi(n)$

于是，找到模反元素d，实质上就是对下面这个二元一次方程求解。

　　$ex + \varPhi(n)y = 1$

已知 e=17, φ(n)=3120，

　　$17x + 3120y = 1$

这个方程可以用"扩展欧几里得算法"求解，此处省略具体过程。总之，爱丽丝算出一组整数解为 (x,y)=(2753,-15)，即 d=2753。

至此所有计算完成。

第六步，将n和e封装成公钥，n和d封装成私钥。

在爱丽丝的例子中，n=3233，e=17，d=2753，所以公钥就是 (3233,17)，私钥就是（3233, 2753）。

实际应用中，公钥和私钥的数据都采用ASN.1格式表达（实例）。

七、RSA算法的可靠性

回顾上面的密钥生成步骤，一共出现六个数字：

　　p
　　q
　　n
　　φ(n)
　　e
　　d

这六个数字之中，公钥用到了两个（n和e），其余四个数字都是不公开的。其中最关键的是d，因为n和d组成了私钥，一旦d泄漏，就等于私钥泄漏。

那么，有无可能在已知n和e的情况下，推导出d？

　　（1）ed≡1 (mod φ(n))。只有知道e和φ(n)，才能算出d。

　　（2）φ(n)=(p-1)(q-1)。只有知道p和q，才能算出φ(n)。

　　（3）n=pq。只有将n因数分解，才能算出p和q。

结论：如果n可以被因数分解，d就可以算出，也就意味着私钥被破解。

可是，大整数的因数分解，是一件非常困难的事情。目前，除了暴力破解，还没有发现别的有效方法。维基百科这样写道：

　　"对极大整数做因数分解的难度决定了RSA算法的可靠性。换言之，对一极大整数做因数分解愈困难，RSA算法愈可靠。

　　假如有人找到一种快速因数分解的算法，那么RSA的可靠性就会极度下降。但找到这样的算法的可能性是非常小的。今天只有短的RSA密钥才可能被暴力破解。到2008年为止，世界上还没有任何可靠的攻击RSA算法的方式。

　　只要密钥长度足够长，用RSA加密的信息实际上是不能被解破的。"

举例来说，你可以对3233进行因数分解（61×53），但是你没法对下面这个整数进行因数分解。

　　12301866845301177551304949
　　58384962720772853569595334
　　79219732245215172640050726
　　36575187452021997864693899
　　56474942774063845925192557
　　32630345373154826850791702
　　61221429134616704292143116
　　02221240479274737794080665
　　351419597459856902143413

它等于这样两个质数的乘积：

　　33478071698956898786044169
　　84821269081770479498371376
　　85689124313889828837938780
　　02287614711652531743087737
　　814467999489
　　　　×
　　36746043666799590428244633
　　79962795263227915816434308
　　76426760322838157396665112
　　79233373417143396810270092
　　798736308917

事实上，这大概是人类已经分解的最大整数（232个十进制位，768个二进制位）。比它更大的因数分解，还没有被报道过，因此目前被破解的最长RSA密钥就是768位。

八、加密和解密

有了公钥和密钥，就能进行加密和解密了。

（1）加密要用公钥 (n,e)

假设鲍勃要向爱丽丝发送加密信息m，他就要用爱丽丝的公钥 (n,e) 对m进行加密。这里需要注意，m必须是整数（字符串可以取ascii值或unicode值），且m必须小于n。

所谓"加密"，就是算出下式的c：

　　$m^e \equiv c \pmod{n}$

爱丽丝的公钥是 (3233, 17)，鲍勃的m假设是65，那么可以算出下面的等式：

　　$65^{17} \equiv 2790 \pmod{3233}$

于是，c等于2790，鲍勃就把2790发给了爱丽丝。

（2）解密要用私钥(n,d)

爱丽丝拿到鲍勃发来的2790以后，就用自己的私钥(3233, 2753) 进行解密。可以证明，下面的等式一定成立：

　　$c^d \equiv m \pmod{n}$

也就是说，c的d次方除以n的余数为m。现在，c等于2790，私钥是(3233, 2753)，那么，爱丽丝算出

　　$2790^{2753} \equiv 65 \pmod{3233}$

因此，爱丽丝知道了鲍勃加密前的原文就是65。

至此，"加密--解密"的整个过程全部完成。

我们可以看到，如果不知道d，就没有办法从c求出m。而前面已经说过，要知道d就必须分解n，这是极难做到的，所以RSA算法保证了通信安全。

你可能会问，公钥(n,e) 只能加密小于n的整数m，那么如果要加密大于n的整数，该怎么办？有两种解决方法：一种是把长信息分割成若干段短消息，每段分别加密；另一种是先选择一种"对称性加密算法"（比如DES），用这种算法的密钥加密信息，再用RSA公钥加密DES密钥。

九、私钥解密的证明

最后，我们来证明，为什么用私钥解密，一定可以正确地得到m。也就是证明下面这个式子：

　　$c^d \equiv m \pmod{n}$

因为，根据加密规则

　　$ｍ^e \equiv c \pmod{n}$

于是，c可以写成下面的形式：

　　$c = m^e - kn$

将c代入要我们要证明的那个解密规则：

　　$(m^e - kn)^d \equiv m \pmod{n}$

它等同于求证

　　$m^{ed} \equiv m \pmod{n}$

由于

　　$ed \equiv 1 \pmod{\varPhi(n)}$

所以

　　$ed = h\varPhi(n)+1$

将ed代入：

　　$m^{h\varPhi(n)+1} \equiv m \pmod{n}$

接下来，分成两种情况证明上面这个式子。

（1）m与n互质。

根据欧拉定理，此时

　　$m^{\varPhi(n)} \equiv 1 \pmod{n}$

得到

　　$(m^{\varPhi(n)})^h × m \equiv m \pmod{n}$

原式得到证明。

（2）m与n不是互质关系。

此时，由于n等于质数p和q的乘积，所以m必然等于kp或kq。

以 m = kp为例，考虑到这时k与q必然互质，则根据欧拉定理，下面的式子成立：

　　$(kp)^{q-1} \equiv 1 \pmod{q}$

进一步得到

　　$[(kp)^{q-1}]^{h(p-1)} * kp \equiv kp \pmod{q}$

即

　　$(kp)^{ed} \equiv kp \pmod{q}$

将它改写成下面的等式

　　$(kp)^{ed} = tq + kp$

这时t必然能被p整除，即 t=t'p

　　$(kp)^{ed} = t'pq + kp$

因为 m=kp，n=pq，所以

　　$m^{ed} \equiv m \pmod{n}$

原式得到证明。

参考链接

SM2的非对称加解密Java工具类(bcprov-jdk15on/bcprov-jdk16)

bcprov-jdk15on实现例子

Maven依赖:

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

<groupId>org.bouncycastle</groupId>

<artifactId>bcprov-jdk15on</artifactId>

</dependency>

Java实现如下:

import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.Arrays;
  
import org.bouncycastle.crypto.DerivationFunction;
import org.bouncycastle.crypto.digests.SHA256Digest;
import org.bouncycastle.crypto.digests.ShortenedDigest;
import org.bouncycastle.crypto.generators.KDF1BytesGenerator;
import org.bouncycastle.crypto.params.ISO18033KDFParameters;
import org.bouncycastle.math.ec.ECCurve;
import org.bouncycastle.math.ec.ECPoint;
  
/**
 *   <B>说 明<B/>:SM2的非对称加解密工具类，椭圆曲线方程为：y^2=x^3+ax+b 使用Fp-256
 */
public class SM2Util {
  
    /** 素数p */
    private static final BigInteger p = new BigInteger("FFFFFFFE" + "FFFFFFFF"
        + "FFFFFFFF" + "FFFFFFFF" + "FFFFFFFF" + "00000000" + "FFFFFFFF"
        + "FFFFFFFF", 16);
     
    /** 系数a */
    private static final BigInteger a = new BigInteger("FFFFFFFE" + "FFFFFFFF"
        + "FFFFFFFF" + "FFFFFFFF" + "FFFFFFFF" + "00000000" + "FFFFFFFF"
        + "FFFFFFFC", 16);
     
    /** 系数b */
    private static final BigInteger b = new BigInteger("28E9FA9E" + "9D9F5E34"
        + "4D5A9E4B" + "CF6509A7" + "F39789F5" + "15AB8F92" + "DDBCBD41"
        + "4D940E93", 16);
     
    /** 坐标x */
    private static final BigInteger xg = new BigInteger("32C4AE2C" + "1F198119"
        + "5F990446" + "6A39C994" + "8FE30BBF" + "F2660BE1" + "715A4589"
        + "334C74C7", 16);
     
    /** 坐标y */
    private static final BigInteger yg = new BigInteger("BC3736A2" + "F4F6779C"
        + "59BDCEE3" + "6B692153" + "D0A9877C" + "C62A4740" + "02DF32E5"
        + "2139F0A0", 16);
     
    /** 基点G, G=(xg,yg),其介记为n */
    private static final BigInteger n = new BigInteger("FFFFFFFE" + "FFFFFFFF"
            + "FFFFFFFF" + "FFFFFFFF" + "7203DF6B" + "21C6052B" + "53BBF409"
            + "39D54123", 16);
     
    private static SecureRandom random = new SecureRandom();
    private ECCurve.Fp curve;
    private ECPoint G;
  
    public static String printHexString(byte[] b) {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < b.length; i++) {
            String hex = Integer.toHexString(b[i] & 0xFF);
            if (hex.length() == 1) {
                builder.append('0'+hex);
            hex = '0' + hex;
        }
    //          System.out.print(hex.toUpperCase());
            System.out.print(hex.toUpperCase());
            builder.append(hex);
        }
        System.out.println();
        return builder.toString();
    }
  
    public BigInteger random(BigInteger max) {
        BigInteger r = new BigInteger(256, random);
        // int count = 1;
        while (r.compareTo(max) >= 0) {
            r = new BigInteger(128, random);
            // count++;
        }
        // System.out.println("count: " + count);
        return r;
    }
  
    private boolean allZero(byte[] buffer) {
        for (int i = 0; i < buffer.length; i++) {
            if (buffer[i] != 0)
            return false;
        }
        return true;
    }
  
    /**
     * 加密
     * @param input 待加密消息M
     * @param publicKey 公钥
     * @return byte[] 加密后的字节数组
     */
    public byte[] encrypt(String input, ECPoint publicKey) {
         
        System.out.println("publicKey is: "+publicKey);
     
        byte[] inputBuffer = input.getBytes();
        printHexString(inputBuffer);
     
        /* 1 产生随机数k，k属于[1, n-1] */
        BigInteger k = random(n);
        System.out.print("k: ");
        printHexString(k.toByteArray());
     
        /* 2 计算椭圆曲线点C1 = [k]G = (x1, y1) */
        ECPoint C1 = G.multiply(k);
        byte[] C1Buffer = C1.getEncoded(false);
        System.out.print("C1: ");
        printHexString(C1Buffer);
         
        // 3 计算椭圆曲线点 S = [h]Pb * curve没有指定余因子，h为空
          
    //           BigInteger h = curve.getCofactor(); System.out.print("h: ");
    //           printHexString(h.toByteArray()); if (publicKey != null) { ECPoint
    //           result = publicKey.multiply(h); if (!result.isInfinity()) {
    //           System.out.println("pass"); } else {
    //          System.err.println("计算椭圆曲线点 S = [h]Pb失败"); return null; } }
     
        /* 4 计算 [k]PB = (x2, y2) */
        ECPoint kpb = publicKey.multiply(k).normalize();
     
        /* 5 计算 t = KDF(x2||y2, klen) */
        byte[] kpbBytes = kpb.getEncoded(false);
        DerivationFunction kdf = new KDF1BytesGenerator(new ShortenedDigest(
        new SHA256Digest(), 20));
        byte[] t = new byte[inputBuffer.length];
        kdf.init(new ISO18033KDFParameters(kpbBytes));
        kdf.generateBytes(t, 0, t.length);
     
        if (allZero(t)) {
        System.err.println("all zero");
        }
     
        /* 6 计算C2=M^t */
        byte[] C2 = new byte[inputBuffer.length];
        for (int i = 0; i < inputBuffer.length; i++) {
        C2[i] = (byte) (inputBuffer[i] ^ t[i]);
        }
     
        /* 7 计算C3 = Hash(x2 || M || y2) */
        byte[] C3 = calculateHash(kpb.getXCoord().toBigInteger(), inputBuffer,
        kpb.getYCoord().toBigInteger());
     
        /* 8 输出密文 C=C1 || C2 || C3 */
        byte[] encryptResult = new byte[C1Buffer.length + C2.length + C3.length];
        System.arraycopy(C1Buffer, 0, encryptResult, 0, C1Buffer.length);
        System.arraycopy(C2, 0, encryptResult, C1Buffer.length, C2.length);
        System.arraycopy(C3, 0, encryptResult, C1Buffer.length + C2.length,
        C3.length);
     
        System.out.print("密文: ");
        printHexString(encryptResult);
  
        return encryptResult;
    }
  
    public void decrypt(byte[] encryptData, BigInteger privateKey) {
        System.out.println("privateKey is: "+privateKey);
        System.out.println("encryptData length: " + encryptData.length);
     
        byte[] C1Byte = new byte[65];
        System.arraycopy(encryptData, 0, C1Byte, 0, C1Byte.length);
     
        ECPoint C1 = curve.decodePoint(C1Byte).normalize();
     
        /* 计算[dB]C1 = (x2, y2) */
        ECPoint dBC1 = C1.multiply(privateKey).normalize();
     
        /* 计算t = KDF(x2 || y2, klen) */
        byte[] dBC1Bytes = dBC1.getEncoded(false);
        DerivationFunction kdf = new KDF1BytesGenerator(new ShortenedDigest(
        new SHA256Digest(), 20));
     
        int klen = encryptData.length - 65 - 20;
        System.out.println("klen = " + klen);
     
        byte[] t = new byte[klen];
        kdf.init(new ISO18033KDFParameters(dBC1Bytes));
        kdf.generateBytes(t, 0, t.length);
     
        if (allZero(t)) {
            System.err.println("all zero");
        }
     
        /* 5 计算M'=C2^t */
        byte[] M = new byte[klen];
        for (int i = 0; i < M.length; i++) {
            M[i] = (byte) (encryptData[C1Byte.length + i] ^ t[i]);
        }
     
        /* 6 计算 u = Hash(x2 || M' || y2) 判断 u == C3是否成立 */
        byte[] C3 = new byte[20];
        System.arraycopy(encryptData, encryptData.length - 20, C3, 0, 20);
        byte[] u = calculateHash(dBC1.getXCoord().toBigInteger(), M, dBC1
        .getYCoord().toBigInteger());
        if (Arrays.equals(u, C3)) {
            System.out.println("解密成功");
            System.out.println("M' = " + new String(M));
        } else {
            System.out.print("u = ");
            printHexString(u);
            System.out.print("C3 = ");
            printHexString(C3);
            System.err.println("解密验证失败");
        }
    }
  
    private byte[] calculateHash(BigInteger x2, byte[] M, BigInteger y2) {
        ShortenedDigest digest = new ShortenedDigest(new SHA256Digest(), 20);
        byte[] buf = x2.toByteArray();
        digest.update(buf, 0, buf.length);
        digest.update(M, 0, M.length);
        buf = y2.toByteArray();
        digest.update(buf, 0, buf.length);
     
        buf = new byte[20];
        digest.doFinal(buf, 0);
        return buf;
    }
  
    private boolean between(BigInteger param, BigInteger min, BigInteger max) {
        if (param.compareTo(min) >= 0 && param.compareTo(max) < 0) {
            return true;
        } else {
            return false;
        }
    }
     
    /**
     * 公钥校验
     * @param publicKey 公钥
     * @return boolean true或false
     */
    private boolean checkPublicKey(ECPoint publicKey) {
        if (!publicKey.isInfinity()) {
            BigInteger x = publicKey.getXCoord().toBigInteger();
            BigInteger y = publicKey.getYCoord().toBigInteger();
            if (between(x, new BigInteger("0"), p) && between(y, new BigInteger("0"), p)) {
                BigInteger xResult = x.pow(3).add(a.multiply(x)).add(b).mod(p);
                System.out.println("xResult: " + xResult.toString());
                BigInteger yResult = y.pow(2).mod(p);
                System.out.println("yResult: " + yResult.toString());
                if (yResult.equals(xResult) && publicKey.multiply(n).isInfinity()) {
                    return true;
                }
            }
            return false;
        } else {
            return false;
        }
    }
     
    /**
     * 获得公私钥对
     * @return
     */
    public SM2KeyPair generateKeyPair() {
        BigInteger d = random(n.subtract(new BigInteger("1")));
        SM2KeyPair keyPair = new SM2KeyPair(G.multiply(d).normalize(), d);
        if (checkPublicKey(keyPair.getPublicKey())) {
            System.out.println("generate key successfully");
            return keyPair;
        } else {
            System.err.println("generate key failed");
            return null;
        }
    }
  
    public SM2Util() {
        curve = new ECCurve.Fp(p, // q
        a, // a
        b); // b
        G = curve.createPoint(xg, yg);
    }
     
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

import java.math.BigInteger;

import java.security.SecureRandom;

import java.util.Arrays;

import org.bouncycastle.crypto.DerivationFunction;

import org.bouncycastle.crypto.digests.SHA256Digest;

import org.bouncycastle.crypto.digests.ShortenedDigest;

import org.bouncycastle.crypto.generators.KDF1BytesGenerator;

import org.bouncycastle.crypto.params.ISO18033KDFParameters;

import org.bouncycastle.math.ec.ECCurve;

import org.bouncycastle.math.ec.ECPoint;

/**

* 说明:SM2的非对称加解密工具类，椭圆曲线方程为：y^2=x^3+ax+b 使用Fp-256

public class SM2Util {

/** 素数p */

private static final BigInteger p = new BigInteger("FFFFFFFE" + "FFFFFFFF"

+ "FFFFFFFF" + "FFFFFFFF" + "FFFFFFFF" + "00000000" + "FFFFFFFF"

+ "FFFFFFFF", 16);

/** 系数a */

private static final BigInteger a = new BigInteger("FFFFFFFE" + "FFFFFFFF"

+ "FFFFFFFF" + "FFFFFFFF" + "FFFFFFFF" + "00000000" + "FFFFFFFF"

+ "FFFFFFFC", 16);

/** 系数b */

private static final BigInteger b = new BigInteger("28E9FA9E" + "9D9F5E34"

+ "4D5A9E4B" + "CF6509A7" + "F39789F5" + "15AB8F92" + "DDBCBD41"

+ "4D940E93", 16);

/** 坐标x */

private static final BigInteger xg = new BigInteger("32C4AE2C" + "1F198119"

+ "5F990446" + "6A39C994" + "8FE30BBF" + "F2660BE1" + "715A4589"

+ "334C74C7", 16);

/** 坐标y */

private static final BigInteger yg = new BigInteger("BC3736A2" + "F4F6779C"

+ "59BDCEE3" + "6B692153" + "D0A9877C" + "C62A4740" + "02DF32E5"

+ "2139F0A0", 16);

/** 基点G, G=(xg,yg),其介记为n */

private static final BigInteger n = new BigInteger("FFFFFFFE" + "FFFFFFFF"

+ "FFFFFFFF" + "FFFFFFFF" + "7203DF6B" + "21C6052B" + "53BBF409"

+ "39D54123", 16);

private static SecureRandom random = new SecureRandom();

private ECCurve.Fp curve;

private ECPoint G;

public static String printHexString(byte[] b) {

StringBuilder builder = new StringBuilder();

for (int i = 0; i < b.length; i++) {

String hex = Integer.toHexString(b[i] & 0xFF);

if (hex.length() == 1) {

builder.append('0'+hex);

hex = '0' + hex;

}

// System.out.print(hex.toUpperCase());

System.out.print(hex.toUpperCase());

builder.append(hex);

}

System.out.println();

return builder.toString();

}

public BigInteger random(BigInteger max) {

BigInteger r = new BigInteger(256, random);

// int count = 1;

while (r.compareTo(max) >= 0) {

r = new BigInteger(128, random);

// count++;

}

// System.out.println("count: " + count);

return r;

}

private boolean allZero(byte[] buffer) {

for (int i = 0; i < buffer.length; i++) {

if (buffer[i] != 0)

return false;

}

return true;

}

/**

* 加密

* @param input 待加密消息M

* @param publicKey 公钥

* @return byte[] 加密后的字节数组

public byte[] encrypt(String input, ECPoint publicKey) {

System.out.println("publicKey is: "+publicKey);

byte[] inputBuffer = input.getBytes();

printHexString(inputBuffer);

/* 1 产生随机数k，k属于[1, n-1] */

BigInteger k = random(n);

System.out.print("k: ");

printHexString(k.toByteArray());

/* 2 计算椭圆曲线点C1 = [k]G = (x1, y1) */

ECPoint C1 = G.multiply(k);

byte[] C1Buffer = C1.getEncoded(false);

System.out.print("C1: ");

printHexString(C1Buffer);

// 3 计算椭圆曲线点 S = [h]Pb * curve没有指定余因子，h为空

// BigInteger h = curve.getCofactor(); System.out.print("h: ");

// printHexString(h.toByteArray()); if (publicKey != null) { ECPoint

// result = publicKey.multiply(h); if (!result.isInfinity()) {

// System.out.println("pass"); } else {

// System.err.println("计算椭圆曲线点 S = [h]Pb失败"); return null; } }

/* 4 计算 [k]PB = (x2, y2) */

ECPoint kpb = publicKey.multiply(k).normalize();

/* 5 计算 t = KDF(x2||y2, klen) */

byte[] kpbBytes = kpb.getEncoded(false);

DerivationFunction kdf = new KDF1BytesGenerator(new ShortenedDigest(

new SHA256Digest(), 20));

byte[] t = new byte[inputBuffer.length];

kdf.init(new ISO18033KDFParameters(kpbBytes));

kdf.generateBytes(t, 0, t.length);

if (allZero(t)) {

System.err.println("all zero");

}

/* 6 计算C2=M^t */

byte[] C2 = new byte[inputBuffer.length];

for (int i = 0; i < inputBuffer.length; i++) {

C2[i] = (byte) (inputBuffer[i] ^ t[i]);

}

/* 7 计算C3 = Hash(x2 || M || y2) */

byte[] C3 = calculateHash(kpb.getXCoord().toBigInteger(), inputBuffer,

kpb.getYCoord().toBigInteger());

/* 8 输出密文 C=C1 || C2 || C3 */

byte[] encryptResult = new byte[C1Buffer.length + C2.length + C3.length];

System.arraycopy(C1Buffer, 0, encryptResult, 0, C1Buffer.length);

System.arraycopy(C2, 0, encryptResult, C1Buffer.length, C2.length);

System.arraycopy(C3, 0, encryptResult, C1Buffer.length + C2.length,

C3.length);

System.out.print("密文: ");

printHexString(encryptResult);

return encryptResult;

}

public void decrypt(byte[] encryptData, BigInteger privateKey) {

System.out.println("privateKey is: "+privateKey);

System.out.println("encryptData length: " + encryptData.length);

byte[] C1Byte = new byte[65];

System.arraycopy(encryptData, 0, C1Byte, 0, C1Byte.length);

ECPoint C1 = curve.decodePoint(C1Byte).normalize();

/* 计算[dB]C1 = (x2, y2) */

ECPoint dBC1 = C1.multiply(privateKey).normalize();

/* 计算t = KDF(x2 || y2, klen) */

byte[] dBC1Bytes = dBC1.getEncoded(false);

DerivationFunction kdf = new KDF1BytesGenerator(new ShortenedDigest(

new SHA256Digest(), 20));

int klen = encryptData.length - 65 - 20;

System.out.println("klen = " + klen);

byte[] t = new byte[klen];

kdf.init(new ISO18033KDFParameters(dBC1Bytes));

kdf.generateBytes(t, 0, t.length);

if (allZero(t)) {

System.err.println("all zero");

}

/* 5 计算M'=C2^t */

byte[] M = new byte[klen];

for (int i = 0; i < M.length; i++) {

M[i] = (byte) (encryptData[C1Byte.length + i] ^ t[i]);

}

/* 6 计算 u = Hash(x2 || M' || y2) 判断 u == C3是否成立 */

byte[] C3 = new byte[20];

System.arraycopy(encryptData, encryptData.length - 20, C3, 0, 20);

byte[] u = calculateHash(dBC1.getXCoord().toBigInteger(), M, dBC1

.getYCoord().toBigInteger());

if (Arrays.equals(u, C3)) {

System.out.println("解密成功");

System.out.println("M' = " + new String(M));

} else {

System.out.print("u = ");

printHexString(u);

System.out.print("C3 = ");

printHexString(C3);

System.err.println("解密验证失败");

}

private byte[] calculateHash(BigInteger x2, byte[] M, BigInteger y2) {

ShortenedDigest digest = new ShortenedDigest(new SHA256Digest(), 20);

byte[] buf = x2.toByteArray();

digest.update(buf, 0, buf.length);

digest.update(M, 0, M.length);

buf = y2.toByteArray();

digest.update(buf, 0, buf.length);

buf = new byte[20];

digest.doFinal(buf, 0);

return buf;

}

private boolean between(BigInteger param, BigInteger min, BigInteger max) {

if (param.compareTo(min) >= 0 && param.compareTo(max) < 0) {

return true;

} else {

return false;

}

/**

* 公钥校验

* @param publicKey 公钥

* @return boolean true或false

private boolean checkPublicKey(ECPoint publicKey) {

if (!publicKey.isInfinity()) {

BigInteger x = publicKey.getXCoord().toBigInteger();

BigInteger y = publicKey.getYCoord().toBigInteger();

if (between(x, new BigInteger("0"), p) && between(y, new BigInteger("0"), p)) {

BigInteger xResult = x.pow(3).add(a.multiply(x)).add(b).mod(p);

System.out.println("xResult: " + xResult.toString());

BigInteger yResult = y.pow(2).mod(p);

System.out.println("yResult: " + yResult.toString());

if (yResult.equals(xResult) && publicKey.multiply(n).isInfinity()) {

return true;

}

return false;

} else {

return false;

}

/**

* 获得公私钥对

* @return

public SM2KeyPair generateKeyPair() {

BigInteger d = random(n.subtract(new BigInteger("1")));

SM2KeyPair keyPair = new SM2KeyPair(G.multiply(d).normalize(), d);

if (checkPublicKey(keyPair.getPublicKey())) {

System.out.println("generate key successfully");

return keyPair;

} else {

System.err.println("generate key failed");

return null;

}

public SM2Util() {

curve = new ECCurve.Fp(p, // q

a, // a

b); // b

G = curve.createPoint(xg, yg);

}

import java.math.BigInteger;
  
import org.bouncycastle.math.ec.ECPoint;
  
/**
 *   <B>说 明<B/>:SM2公私钥实体类
 */
public class SM2KeyPair {
     
    /** 公钥 */
    private  ECPoint publicKey;
     
    /** 私钥 */
    private BigInteger privateKey;
  
    SM2KeyPair(ECPoint publicKey, BigInteger privateKey) {
        this.publicKey = publicKey;
        this.privateKey = privateKey;
    }
  
    public ECPoint getPublicKey() {
        return publicKey;
    }
  
    public BigInteger getPrivateKey() {
        return privateKey;
    }
     
}

import java.math.BigInteger;

import org.bouncycastle.math.ec.ECPoint;

/**

* 说明:SM2公私钥实体类

public class SM2KeyPair {

/** 公钥 */

private ECPoint publicKey;

/** 私钥 */

private BigInteger privateKey;

SM2KeyPair(ECPoint publicKey, BigInteger privateKey) {

this.publicKey = publicKey;

this.privateKey = privateKey;

}

public ECPoint getPublicKey() {

return publicKey;

}

public BigInteger getPrivateKey() {

return privateKey;

}

import java.util.Arrays;
  
/**
 *   <B>说 明<B/>:SM2非对称加解密工具类测试
 */
public class SM2UtilTest {
  
    /** 元消息串 */
    private static String M = "哈哈哈，&*&…………&、、//\\!@#$%^&*()物品woyebuzhidaowozijiqiaodesha!@#$%^&*())))))ooooooooppppppppppppppppppplllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkffffffffffffffffffffffffffffffffffffff";
     
    public static void main(String[] args) {
        SM2Util sm2 = new SM2Util();
        SM2KeyPair keyPair = sm2.generateKeyPair();
        byte[] data = sm2.encrypt(M,keyPair.getPublicKey());
        System.out.println("data is:"+Arrays.toString(data));
        sm2.decrypt(data, keyPair.getPrivateKey());//71017045908707391874054405929626258767106914144911649587813342322113806533034
    }
     
}

import java.util.Arrays;

/**

* 说明:SM2非对称加解密工具类测试

public class SM2UtilTest {

/** 元消息串 */

private static String M = "哈哈哈，&*&…………&、、//\\!@#$%^&*()物品woyebuzhidaowozijiqiaodesha!@#$%^&*())))))ooooooooppppppppppppppppppplllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkffffffffffffffffffffffffffffffffffffff";

public static void main(String[] args) {

SM2Util sm2 = new SM2Util();

SM2KeyPair keyPair = sm2.generateKeyPair();

byte[] data = sm2.encrypt(M,keyPair.getPublicKey());

System.out.println("data is:"+Arrays.toString(data));

sm2.decrypt(data, keyPair.getPrivateKey());//71017045908707391874054405929626258767106914144911649587813342322113806533034

}

bcprov-jdk16实现例子

<dependency>
	<groupId>org.bouncycastle</groupId>
	<artifactId>bcprov-jdk16</artifactId>
	<version>1.46</version>
</dependency>

<groupId>org.bouncycastle</groupId>

<artifactId>bcprov-jdk16</artifactId>

</dependency>

import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.math.ec.ECPoint;

import java.math.BigInteger;

public class Cipher {
    private int ct;
    private ECPoint p2;
    private SM3Digest sm3keybase;
    private SM3Digest sm3c3;
    private byte[] key;
    private byte keyOff;

    public Cipher() {
        this.ct = 1;
        this.key = new byte[32];
        this.keyOff = 0;
    }

    private void Reset() {
        this.sm3keybase = new SM3Digest();
        this.sm3c3 = new SM3Digest();

        byte[] p = Util.byteConvert32Bytes(p2.getX().toBigInteger());
        this.sm3keybase.update(p, 0, p.length);
        this.sm3c3.update(p, 0, p.length);

        p = Util.byteConvert32Bytes(p2.getY().toBigInteger());
        this.sm3keybase.update(p, 0, p.length);
        this.ct = 1;
        NextKey();
    }

    private void NextKey() {
        SM3Digest sm3keycur = new SM3Digest(this.sm3keybase);
        sm3keycur.update((byte) (ct >> 24 & 0xff));
        sm3keycur.update((byte) (ct >> 16 & 0xff));
        sm3keycur.update((byte) (ct >> 8 & 0xff));
        sm3keycur.update((byte) (ct & 0xff));
        sm3keycur.doFinal(key, 0);
        this.keyOff = 0;
        this.ct++;
    }

    public ECPoint Init_enc(SM2 sm2, ECPoint userKey) {
        AsymmetricCipherKeyPair key = sm2.ecc_key_pair_generator.generateKeyPair();
        ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters) key.getPrivate();
        ECPublicKeyParameters ecpub = (ECPublicKeyParameters) key.getPublic();
        BigInteger k = ecpriv.getD();
        ECPoint c1 = ecpub.getQ();
        this.p2 = userKey.multiply(k);
        Reset();
        return c1;
    }

    public void Encrypt(byte[] data) {
        this.sm3c3.update(data, 0, data.length);
        for (int i = 0; i < data.length; i++) {
            if (keyOff == key.length) {
                NextKey();
            }
            data[i] ^= key[keyOff++];
        }
    }

    public void Init_dec(BigInteger userD, ECPoint c1) {
        this.p2 = c1.multiply(userD);
        Reset();
    }

    public void Decrypt(byte[] data) {
        for (int i = 0; i < data.length; i++) {
            if (keyOff == key.length) {
                NextKey();
            }
            data[i] ^= key[keyOff++];
        }

        this.sm3c3.update(data, 0, data.length);
    }

    public void doFinal(byte[] c3) {
        byte[] p = Util.byteConvert32Bytes(p2.getY().toBigInteger());
        this.sm3c3.update(p, 0, p.length);
        this.sm3c3.doFinal(c3, 0);
        Reset();
    }
}

import org.bouncycastle.crypto.AsymmetricCipherKeyPair;

import org.bouncycastle.crypto.params.ECPrivateKeyParameters;

import org.bouncycastle.crypto.params.ECPublicKeyParameters;

import org.bouncycastle.math.ec.ECPoint;

import java.math.BigInteger;

public class Cipher {

private int ct;

private ECPoint p2;

private SM3Digest sm3keybase;

private SM3Digest sm3c3;

private byte[] key;

private byte keyOff;

public Cipher() {

this.ct = 1;

this.key = new byte[32];

this.keyOff = 0;

}

private void Reset() {

this.sm3keybase = new SM3Digest();

this.sm3c3 = new SM3Digest();

byte[] p = Util.byteConvert32Bytes(p2.getX().toBigInteger());

this.sm3keybase.update(p, 0, p.length);

this.sm3c3.update(p, 0, p.length);

p = Util.byteConvert32Bytes(p2.getY().toBigInteger());

this.sm3keybase.update(p, 0, p.length);

this.ct = 1;

NextKey();

}

private void NextKey() {

SM3Digest sm3keycur = new SM3Digest(this.sm3keybase);

sm3keycur.update((byte) (ct >> 24 & 0xff));

sm3keycur.update((byte) (ct >> 16 & 0xff));

sm3keycur.update((byte) (ct >> 8 & 0xff));

sm3keycur.update((byte) (ct & 0xff));

sm3keycur.doFinal(key, 0);

this.keyOff = 0;

this.ct++;

}

public ECPoint Init_enc(SM2 sm2, ECPoint userKey) {

AsymmetricCipherKeyPair key = sm2.ecc_key_pair_generator.generateKeyPair();

ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters) key.getPrivate();

ECPublicKeyParameters ecpub = (ECPublicKeyParameters) key.getPublic();

BigInteger k = ecpriv.getD();

ECPoint c1 = ecpub.getQ();

this.p2 = userKey.multiply(k);

Reset();

return c1;

}

public void Encrypt(byte[] data) {

this.sm3c3.update(data, 0, data.length);

for (int i = 0; i < data.length; i++) {

if (keyOff == key.length) {

NextKey();

}

data[i] ^= key[keyOff++];

}

public void Init_dec(BigInteger userD, ECPoint c1) {

this.p2 = c1.multiply(userD);

Reset();

}

public void Decrypt(byte[] data) {

for (int i = 0; i < data.length; i++) {

if (keyOff == key.length) {

NextKey();

}

data[i] ^= key[keyOff++];

}

this.sm3c3.update(data, 0, data.length);

}

public void doFinal(byte[] c3) {

byte[] p = Util.byteConvert32Bytes(p2.getY().toBigInteger());

this.sm3c3.update(p, 0, p.length);

this.sm3c3.doFinal(c3, 0);

Reset();

}

public class SM3 {
    public static final byte[] iv = {0x73, (byte) 0x80, 0x16, 0x6f, 0x49,
            0x14, (byte) 0xb2, (byte) 0xb9, 0x17, 0x24, 0x42, (byte) 0xd7,
            (byte) 0xda, (byte) 0x8a, 0x06, 0x00, (byte) 0xa9, 0x6f, 0x30,
            (byte) 0xbc, (byte) 0x16, 0x31, 0x38, (byte) 0xaa, (byte) 0xe3,
            (byte) 0x8d, (byte) 0xee, 0x4d, (byte) 0xb0, (byte) 0xfb, 0x0e,
            0x4e};

    public static int[] Tj = new int[64];

    static {
        for (int i = 0; i < 16; i++) {
            Tj[i] = 0x79cc4519;
        }

        for (int i = 16; i < 64; i++) {
            Tj[i] = 0x7a879d8a;
        }
    }

    public static byte[] CF(byte[] V, byte[] B) {
        int[] v, b;
        v = convert(V);
        b = convert(B);
        return convert(CF(v, b));
    }

    private static int[] convert(byte[] arr) {
        int[] out = new int[arr.length / 4];
        byte[] tmp = new byte[4];
        for (int i = 0; i < arr.length; i += 4) {
            System.arraycopy(arr, i, tmp, 0, 4);
            out[i / 4] = bigEndianByteToInt(tmp);
        }
        return out;
    }

    private static byte[] convert(int[] arr) {
        byte[] out = new byte[arr.length * 4];
        byte[] tmp = null;
        for (int i = 0; i < arr.length; i++) {
            tmp = bigEndianIntToByte(arr[i]);
            System.arraycopy(tmp, 0, out, i * 4, 4);
        }
        return out;
    }

    public static int[] CF(int[] V, int[] B) {
        int a, b, c, d, e, f, g, h;
        int ss1, ss2, tt1, tt2;
        a = V[0];
        b = V[1];
        c = V[2];
        d = V[3];
        e = V[4];
        f = V[5];
        g = V[6];
        h = V[7];

        int[][] arr = expand(B);
        int[] w = arr[0];
        int[] w1 = arr[1];

        for (int j = 0; j < 64; j++) {
            ss1 = (bitCycleLeft(a, 12) + e + bitCycleLeft(Tj[j], j));
            ss1 = bitCycleLeft(ss1, 7);
            ss2 = ss1 ^ bitCycleLeft(a, 12);
            tt1 = FFj(a, b, c, j) + d + ss2 + w1[j];
            tt2 = GGj(e, f, g, j) + h + ss1 + w[j];
            d = c;
            c = bitCycleLeft(b, 9);
            b = a;
            a = tt1;
            h = g;
            g = bitCycleLeft(f, 19);
            f = e;
            e = P0(tt2);  
		  
		            /*System.out.print(j+" "); 
		            System.out.print(Integer.toHexString(a)+" "); 
		            System.out.print(Integer.toHexString(b)+" "); 
		            System.out.print(Integer.toHexString(c)+" "); 
		            System.out.print(Integer.toHexString(d)+" "); 
		            System.out.print(Integer.toHexString(e)+" "); 
		            System.out.print(Integer.toHexString(f)+" "); 
		            System.out.print(Integer.toHexString(g)+" "); 
		            System.out.print(Integer.toHexString(h)+" "); 
		            System.out.println("");*/
        }
//		      System.out.println("");  

        int[] out = new int[8];
        out[0] = a ^ V[0];
        out[1] = b ^ V[1];
        out[2] = c ^ V[2];
        out[3] = d ^ V[3];
        out[4] = e ^ V[4];
        out[5] = f ^ V[5];
        out[6] = g ^ V[6];
        out[7] = h ^ V[7];

        return out;
    }

    private static int[][] expand(int[] B) {
        int[] W = new int[68];
        int[] W1 = new int[64];
        for (int i = 0; i < B.length; i++) {
            W[i] = B[i];
        }

        for (int i = 16; i < 68; i++) {
            W[i] = P1(W[i - 16] ^ W[i - 9] ^ bitCycleLeft(W[i - 3], 15))
                    ^ bitCycleLeft(W[i - 13], 7) ^ W[i - 6];
        }

        for (int i = 0; i < 64; i++) {
            W1[i] = W[i] ^ W[i + 4];
        }

        int[][] arr = new int[][]{W, W1};
        return arr;
    }

    private static byte[] bigEndianIntToByte(int num) {
        return back(Util.intToBytes(num));
    }

    private static int bigEndianByteToInt(byte[] bytes) {
        return Util.byteToInt(back(bytes));
    }

    private static int FFj(int X, int Y, int Z, int j) {
        if (j >= 0 && j <= 15) {
            return FF1j(X, Y, Z);
        } else {
            return FF2j(X, Y, Z);
        }
    }

    private static int GGj(int X, int Y, int Z, int j) {
        if (j >= 0 && j <= 15) {
            return GG1j(X, Y, Z);
        } else {
            return GG2j(X, Y, Z);
        }
    }

    // 逻辑位运算函数  
    private static int FF1j(int X, int Y, int Z) {
        int tmp = X ^ Y ^ Z;
        return tmp;
    }

    private static int FF2j(int X, int Y, int Z) {
        int tmp = ((X & Y) | (X & Z) | (Y & Z));
        return tmp;
    }

    private static int GG1j(int X, int Y, int Z) {
        int tmp = X ^ Y ^ Z;
        return tmp;
    }

    private static int GG2j(int X, int Y, int Z) {
        int tmp = (X & Y) | (~X & Z);
        return tmp;
    }

    private static int P0(int X) {
        int y = rotateLeft(X, 9);
        y = bitCycleLeft(X, 9);
        int z = rotateLeft(X, 17);
        z = bitCycleLeft(X, 17);
        int t = X ^ y ^ z;
        return t;
    }

    private static int P1(int X) {
        int t = X ^ bitCycleLeft(X, 15) ^ bitCycleLeft(X, 23);
        return t;
    }

    /**
     * 对最后一个分组字节数据padding
     *
     * @param in
     * @param bLen 分组个数
     * @return
     */
    public static byte[] padding(byte[] in, int bLen) {
        int k = 448 - (8 * in.length + 1) % 512;
        if (k < 0) {
            k = 960 - (8 * in.length + 1) % 512;
        }
        k += 1;
        byte[] padd = new byte[k / 8];
        padd[0] = (byte) 0x80;
        long n = in.length * 8 + bLen * 512;
        byte[] out = new byte[in.length + k / 8 + 64 / 8];
        int pos = 0;
        System.arraycopy(in, 0, out, 0, in.length);
        pos += in.length;
        System.arraycopy(padd, 0, out, pos, padd.length);
        pos += padd.length;
        byte[] tmp = back(Util.longToBytes(n));
        System.arraycopy(tmp, 0, out, pos, tmp.length);
        return out;
    }

    /**
     * 字节数组逆序
     *
     * @param in
     * @return
     */
    private static byte[] back(byte[] in) {
        byte[] out = new byte[in.length];
        for (int i = 0; i < out.length; i++) {
            out[i] = in[out.length - i - 1];
        }

        return out;
    }

    public static int rotateLeft(int x, int n) {
        return (x << n) | (x >> (32 - n));
    }

    private static int bitCycleLeft(int n, int bitLen) {
        bitLen %= 32;
        byte[] tmp = bigEndianIntToByte(n);
        int byteLen = bitLen / 8;
        int len = bitLen % 8;
        if (byteLen > 0) {
            tmp = byteCycleLeft(tmp, byteLen);
        }

        if (len > 0) {
            tmp = bitSmall8CycleLeft(tmp, len);
        }

        return bigEndianByteToInt(tmp);
    }

    private static byte[] bitSmall8CycleLeft(byte[] in, int len) {
        byte[] tmp = new byte[in.length];
        int t1, t2, t3;
        for (int i = 0; i < tmp.length; i++) {
            t1 = (byte) ((in[i] & 0x000000ff) << len);
            t2 = (byte) ((in[(i + 1) % tmp.length] & 0x000000ff) >> (8 - len));
            t3 = (byte) (t1 | t2);
            tmp[i] = (byte) t3;
        }

        return tmp;
    }

    private static byte[] byteCycleLeft(byte[] in, int byteLen) {
        byte[] tmp = new byte[in.length];
        System.arraycopy(in, byteLen, tmp, 0, in.length - byteLen);
        System.arraycopy(in, 0, tmp, in.length - byteLen, byteLen);
        return tmp;
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

public class SM3 {

public static final byte[] iv = {0x73, (byte) 0x80, 0x16, 0x6f, 0x49,

0x14, (byte) 0xb2, (byte) 0xb9, 0x17, 0x24, 0x42, (byte) 0xd7,

(byte) 0xda, (byte) 0x8a, 0x06, 0x00, (byte) 0xa9, 0x6f, 0x30,

(byte) 0xbc, (byte) 0x16, 0x31, 0x38, (byte) 0xaa, (byte) 0xe3,

(byte) 0x8d, (byte) 0xee, 0x4d, (byte) 0xb0, (byte) 0xfb, 0x0e,

0x4e};

public static int[] Tj = new int[64];

static {

for (int i = 0; i < 16; i++) {

Tj[i] = 0x79cc4519;

}

for (int i = 16; i < 64; i++) {

Tj[i] = 0x7a879d8a;

}

public static byte[] CF(byte[] V, byte[] B) {

int[] v, b;

v = convert(V);

b = convert(B);

return convert(CF(v, b));

}

private static int[] convert(byte[] arr) {

int[] out = new int[arr.length / 4];

byte[] tmp = new byte[4];

for (int i = 0; i < arr.length; i += 4) {

System.arraycopy(arr, i, tmp, 0, 4);

out[i / 4] = bigEndianByteToInt(tmp);

}

return out;

}

private static byte[] convert(int[] arr) {

byte[] out = new byte[arr.length * 4];

byte[] tmp = null;

for (int i = 0; i < arr.length; i++) {

tmp = bigEndianIntToByte(arr[i]);

System.arraycopy(tmp, 0, out, i * 4, 4);

}

return out;

}

public static int[] CF(int[] V, int[] B) {

int a, b, c, d, e, f, g, h;

int ss1, ss2, tt1, tt2;

a = V[0];

b = V[1];

c = V[2];

d = V[3];

e = V[4];

f = V[5];

g = V[6];

h = V[7];

int[][] arr = expand(B);

int[] w = arr[0];

int[] w1 = arr[1];

for (int j = 0; j < 64; j++) {

ss1 = (bitCycleLeft(a, 12) + e + bitCycleLeft(Tj[j], j));

ss1 = bitCycleLeft(ss1, 7);

ss2 = ss1 ^ bitCycleLeft(a, 12);

tt1 = FFj(a, b, c, j) + d + ss2 + w1[j];

tt2 = GGj(e, f, g, j) + h + ss1 + w[j];

d = c;

c = bitCycleLeft(b, 9);

b = a;

a = tt1;

h = g;

g = bitCycleLeft(f, 19);

f = e;

e = P0(tt2);

/*System.out.print(j+" ");

System.out.print(Integer.toHexString(a)+" ");

System.out.print(Integer.toHexString(b)+" ");

System.out.print(Integer.toHexString(c)+" ");

System.out.print(Integer.toHexString(d)+" ");

System.out.print(Integer.toHexString(e)+" ");

System.out.print(Integer.toHexString(f)+" ");

System.out.print(Integer.toHexString(g)+" ");

System.out.print(Integer.toHexString(h)+" ");

System.out.println("");*/

}

// System.out.println("");

int[] out = new int[8];

out[0] = a ^ V[0];

out[1] = b ^ V[1];

out[2] = c ^ V[2];

out[3] = d ^ V[3];

out[4] = e ^ V[4];

out[5] = f ^ V[5];

out[6] = g ^ V[6];

out[7] = h ^ V[7];

return out;

}

private static int[][] expand(int[] B) {

int[] W = new int[68];

int[] W1 = new int[64];

for (int i = 0; i < B.length; i++) {

W[i] = B[i];

}

for (int i = 16; i < 68; i++) {

W[i] = P1(W[i - 16] ^ W[i - 9] ^ bitCycleLeft(W[i - 3], 15))

^ bitCycleLeft(W[i - 13], 7) ^ W[i - 6];

}

for (int i = 0; i < 64; i++) {

W1[i] = W[i] ^ W[i + 4];

}

int[][] arr = new int[][]{W, W1};

return arr;

}

private static byte[] bigEndianIntToByte(int num) {

return back(Util.intToBytes(num));

}

private static int bigEndianByteToInt(byte[] bytes) {

return Util.byteToInt(back(bytes));

}

private static int FFj(int X, int Y, int Z, int j) {

if (j >= 0 && j <= 15) {

return FF1j(X, Y, Z);

} else {

return FF2j(X, Y, Z);

}

private static int GGj(int X, int Y, int Z, int j) {

if (j >= 0 && j <= 15) {

return GG1j(X, Y, Z);

} else {

return GG2j(X, Y, Z);

}

// 逻辑位运算函数

private static int FF1j(int X, int Y, int Z) {

int tmp = X ^ Y ^ Z;

return tmp;

}

private static int FF2j(int X, int Y, int Z) {

int tmp = ((X & Y) | (X & Z) | (Y & Z));

return tmp;

}

private static int GG1j(int X, int Y, int Z) {

int tmp = X ^ Y ^ Z;

return tmp;

}

private static int GG2j(int X, int Y, int Z) {

int tmp = (X & Y) | (~X & Z);

return tmp;

}

private static int P0(int X) {

int y = rotateLeft(X, 9);

y = bitCycleLeft(X, 9);

int z = rotateLeft(X, 17);

z = bitCycleLeft(X, 17);

int t = X ^ y ^ z;

return t;

}

private static int P1(int X) {

int t = X ^ bitCycleLeft(X, 15) ^ bitCycleLeft(X, 23);

return t;

}

/**

* 对最后一个分组字节数据padding

* @param in

* @param bLen 分组个数

* @return

public static byte[] padding(byte[] in, int bLen) {

int k = 448 - (8 * in.length + 1) % 512;

if (k < 0) {

k = 960 - (8 * in.length + 1) % 512;

}

k += 1;

byte[] padd = new byte[k / 8];

padd[0] = (byte) 0x80;

long n = in.length * 8 + bLen * 512;

byte[] out = new byte[in.length + k / 8 + 64 / 8];

int pos = 0;

System.arraycopy(in, 0, out, 0, in.length);

pos += in.length;

System.arraycopy(padd, 0, out, pos, padd.length);

pos += padd.length;

byte[] tmp = back(Util.longToBytes(n));

System.arraycopy(tmp, 0, out, pos, tmp.length);

return out;

}

/**

* 字节数组逆序

* @param in

* @return

private static byte[] back(byte[] in) {

byte[] out = new byte[in.length];

for (int i = 0; i < out.length; i++) {

out[i] = in[out.length - i - 1];

}

return out;

}

public static int rotateLeft(int x, int n) {

return (x << n) | (x >> (32 - n));

}

private static int bitCycleLeft(int n, int bitLen) {

bitLen %= 32;

byte[] tmp = bigEndianIntToByte(n);

int byteLen = bitLen / 8;

int len = bitLen % 8;

if (byteLen > 0) {

tmp = byteCycleLeft(tmp, byteLen);

}

if (len > 0) {

tmp = bitSmall8CycleLeft(tmp, len);

}

return bigEndianByteToInt(tmp);

}

private static byte[] bitSmall8CycleLeft(byte[] in, int len) {

byte[] tmp = new byte[in.length];

int t1, t2, t3;

for (int i = 0; i < tmp.length; i++) {

t1 = (byte) ((in[i] & 0x000000ff) << len);

t2 = (byte) ((in[(i + 1) % tmp.length] & 0x000000ff) >> (8 - len));

t3 = (byte) (t1 | t2);

tmp[i] = (byte) t3;

}

return tmp;

}

private static byte[] byteCycleLeft(byte[] in, int byteLen) {

byte[] tmp = new byte[in.length];

System.arraycopy(in, byteLen, tmp, 0, in.length - byteLen);

System.arraycopy(in, 0, tmp, in.length - byteLen, byteLen);

return tmp;

}

import org.bouncycastle.util.encoders.Hex;

public class SM3Digest {
    /**
     * SM3值的长度
     */
    private static final int BYTE_LENGTH = 32;

    /**
     * SM3分组长度
     */
    private static final int BLOCK_LENGTH = 64;

    /**
     * 缓冲区长度
     */
    private static final int BUFFER_LENGTH = BLOCK_LENGTH * 1;

    /**
     * 缓冲区
     */
    private byte[] xBuf = new byte[BUFFER_LENGTH];

    /**
     * 缓冲区偏移量
     */
    private int xBufOff;

    /**
     * 初始向量
     */
    private byte[] V = SM3.iv.clone();

    private int cntBlock = 0;

    public SM3Digest() {
    }

    public SM3Digest(SM3Digest t) {
        System.arraycopy(t.xBuf, 0, this.xBuf, 0, t.xBuf.length);
        this.xBufOff = t.xBufOff;
        System.arraycopy(t.V, 0, this.V, 0, t.V.length);
    }

    public static void main(String[] args) {
        byte[] md = new byte[32];
        byte[] msg1 = "ererfeiisgod".getBytes();
        SM3Digest sm3 = new SM3Digest();
        sm3.update(msg1, 0, msg1.length);
        sm3.doFinal(md, 0);
        String s = new String(Hex.encode(md));
        System.out.println(s.toUpperCase());
    }

    /**
     * SM3结果输出
     *
     * @param out    保存SM3结构的缓冲区
     * @param outOff 缓冲区偏移量
     * @return
     */
    public int doFinal(byte[] out, int outOff) {
        byte[] tmp = doFinal();
        System.arraycopy(tmp, 0, out, 0, tmp.length);
        return BYTE_LENGTH;
    }

    public void reset() {
        xBufOff = 0;
        cntBlock = 0;
        V = SM3.iv.clone();
    }

    /**
     * 明文输入
     *
     * @param in    明文输入缓冲区
     * @param inOff 缓冲区偏移量
     * @param len   明文长度
     */
    public void update(byte[] in, int inOff, int len) {
        int partLen = BUFFER_LENGTH - xBufOff;
        int inputLen = len;
        int dPos = inOff;
        if (partLen < inputLen) {
            System.arraycopy(in, dPos, xBuf, xBufOff, partLen);
            inputLen -= partLen;
            dPos += partLen;
            doUpdate();
            while (inputLen > BUFFER_LENGTH) {
                System.arraycopy(in, dPos, xBuf, 0, BUFFER_LENGTH);
                inputLen -= BUFFER_LENGTH;
                dPos += BUFFER_LENGTH;
                doUpdate();
            }
        }

        System.arraycopy(in, dPos, xBuf, xBufOff, inputLen);
        xBufOff += inputLen;
    }

    private void doUpdate() {
        byte[] B = new byte[BLOCK_LENGTH];
        for (int i = 0; i < BUFFER_LENGTH; i += BLOCK_LENGTH) {
            System.arraycopy(xBuf, i, B, 0, B.length);
            doHash(B);
        }
        xBufOff = 0;
    }

    private void doHash(byte[] B) {
        byte[] tmp = SM3.CF(V, B);
        System.arraycopy(tmp, 0, V, 0, V.length);
        cntBlock++;
    }

    private byte[] doFinal() {
        byte[] B = new byte[BLOCK_LENGTH];
        byte[] buffer = new byte[xBufOff];
        System.arraycopy(xBuf, 0, buffer, 0, buffer.length);
        byte[] tmp = SM3.padding(buffer, cntBlock);
        for (int i = 0; i < tmp.length; i += BLOCK_LENGTH) {
            System.arraycopy(tmp, i, B, 0, B.length);
            doHash(B);
        }
        return V;
    }

    public void update(byte in) {
        byte[] buffer = new byte[]{in};
        update(buffer, 0, 1);
    }

    public int getDigestSize() {
        return BYTE_LENGTH;
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

import org.bouncycastle.util.encoders.Hex;

public class SM3Digest {

/**

* SM3值的长度

private static final int BYTE_LENGTH = 32;

/**

* SM3分组长度

private static final int BLOCK_LENGTH = 64;

/**

* 缓冲区长度

private static final int BUFFER_LENGTH = BLOCK_LENGTH * 1;

/**

* 缓冲区

private byte[] xBuf = new byte[BUFFER_LENGTH];

/**

* 缓冲区偏移量

private int xBufOff;

/**

* 初始向量

private byte[] V = SM3.iv.clone();

private int cntBlock = 0;

public SM3Digest() {

}

public SM3Digest(SM3Digest t) {

System.arraycopy(t.xBuf, 0, this.xBuf, 0, t.xBuf.length);

this.xBufOff = t.xBufOff;

System.arraycopy(t.V, 0, this.V, 0, t.V.length);

}

public static void main(String[] args) {

byte[] md = new byte[32];

byte[] msg1 = "ererfeiisgod".getBytes();

SM3Digest sm3 = new SM3Digest();

sm3.update(msg1, 0, msg1.length);

sm3.doFinal(md, 0);

String s = new String(Hex.encode(md));

System.out.println(s.toUpperCase());

}

/**

* SM3结果输出

* @param out 保存SM3结构的缓冲区

* @param outOff 缓冲区偏移量

* @return

public int doFinal(byte[] out, int outOff) {

byte[] tmp = doFinal();

System.arraycopy(tmp, 0, out, 0, tmp.length);

return BYTE_LENGTH;

}

public void reset() {

xBufOff = 0;

cntBlock = 0;

V = SM3.iv.clone();

}

/**

* 明文输入

* @param in 明文输入缓冲区

* @param inOff 缓冲区偏移量

* @param len 明文长度

public void update(byte[] in, int inOff, int len) {

int partLen = BUFFER_LENGTH - xBufOff;

int inputLen = len;

int dPos = inOff;

if (partLen < inputLen) {

System.arraycopy(in, dPos, xBuf, xBufOff, partLen);

inputLen -= partLen;

dPos += partLen;

doUpdate();

while (inputLen > BUFFER_LENGTH) {

System.arraycopy(in, dPos, xBuf, 0, BUFFER_LENGTH);

inputLen -= BUFFER_LENGTH;

dPos += BUFFER_LENGTH;

doUpdate();

}

System.arraycopy(in, dPos, xBuf, xBufOff, inputLen);

xBufOff += inputLen;

}

private void doUpdate() {

byte[] B = new byte[BLOCK_LENGTH];

for (int i = 0; i < BUFFER_LENGTH; i += BLOCK_LENGTH) {

System.arraycopy(xBuf, i, B, 0, B.length);

doHash(B);

}

xBufOff = 0;

}

private void doHash(byte[] B) {

byte[] tmp = SM3.CF(V, B);

System.arraycopy(tmp, 0, V, 0, V.length);

cntBlock++;

}

private byte[] doFinal() {

byte[] B = new byte[BLOCK_LENGTH];

byte[] buffer = new byte[xBufOff];

System.arraycopy(xBuf, 0, buffer, 0, buffer.length);

byte[] tmp = SM3.padding(buffer, cntBlock);

for (int i = 0; i < tmp.length; i += BLOCK_LENGTH) {

System.arraycopy(tmp, i, B, 0, B.length);

doHash(B);

}

return V;

}

public void update(byte in) {

byte[] buffer = new byte[]{in};

update(buffer, 0, 1);

}

public int getDigestSize() {

return BYTE_LENGTH;

}

import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
import org.bouncycastle.crypto.params.ECDomainParameters;
import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
import org.bouncycastle.math.ec.ECCurve;
import org.bouncycastle.math.ec.ECFieldElement;
import org.bouncycastle.math.ec.ECFieldElement.Fp;
import org.bouncycastle.math.ec.ECPoint;

import java.math.BigInteger;
import java.security.SecureRandom;

public class SM2 {
    //测试参数  
//  public static final String[] ecc_param = {  
//      "8542D69E4C044F18E8B92435BF6FF7DE457283915C45517D722EDB8B08F1DFC3",   
//      "787968B4FA32C3FD2417842E73BBFEFF2F3C848B6831D7E0EC65228B3937E498",   
//      "63E4C6D3B23B0C849CF84241484BFE48F61D59A5B16BA06E6E12D1DA27C5249A",   
//      "8542D69E4C044F18E8B92435BF6FF7DD297720630485628D5AE74EE7C32E79B7",   
//      "421DEBD61B62EAB6746434EBC3CC315E32220B3BADD50BDC4C4E6C147FEDD43D",   
//      "0680512BCBB42C07D47349D2153B70C4E5D7FDFCBFA36EA1A85841B9E46E09A2"   
//  };  

    //正式参数  
    public static String[] ecc_param = {
            "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF",
            "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC",
            "28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93",
            "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123",
            "32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7",
            "BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0"
    };
    public final BigInteger ecc_p;
    public final BigInteger ecc_a;
    public final BigInteger ecc_b;
    public final BigInteger ecc_n;
    public final BigInteger ecc_gx;
    public final BigInteger ecc_gy;
    public final ECCurve ecc_curve;
    public final ECPoint ecc_point_g;
    public final ECDomainParameters ecc_bc_spec;
    public final ECKeyPairGenerator ecc_key_pair_generator;
    public final ECFieldElement ecc_gx_fieldelement;
    public final ECFieldElement ecc_gy_fieldelement;
    public SM2() {
        this.ecc_p = new BigInteger(ecc_param[0], 16);
        this.ecc_a = new BigInteger(ecc_param[1], 16);
        this.ecc_b = new BigInteger(ecc_param[2], 16);
        this.ecc_n = new BigInteger(ecc_param[3], 16);
        this.ecc_gx = new BigInteger(ecc_param[4], 16);
        this.ecc_gy = new BigInteger(ecc_param[5], 16);

        this.ecc_gx_fieldelement = new Fp(this.ecc_p, this.ecc_gx);
        this.ecc_gy_fieldelement = new Fp(this.ecc_p, this.ecc_gy);

        this.ecc_curve = new ECCurve.Fp(this.ecc_p, this.ecc_a, this.ecc_b);
        this.ecc_point_g = new ECPoint.Fp(this.ecc_curve, this.ecc_gx_fieldelement, this.ecc_gy_fieldelement);

        this.ecc_bc_spec = new ECDomainParameters(this.ecc_curve, this.ecc_point_g, this.ecc_n);

        ECKeyGenerationParameters ecc_ecgenparam;
        ecc_ecgenparam = new ECKeyGenerationParameters(this.ecc_bc_spec, new SecureRandom());

        this.ecc_key_pair_generator = new ECKeyPairGenerator();
        this.ecc_key_pair_generator.init(ecc_ecgenparam);
    }

    public static SM2 Instance() {
        return new SM2();
    }
}

import org.bouncycastle.crypto.generators.ECKeyPairGenerator;

import org.bouncycastle.crypto.params.ECDomainParameters;

import org.bouncycastle.crypto.params.ECKeyGenerationParameters;

import org.bouncycastle.math.ec.ECCurve;

import org.bouncycastle.math.ec.ECFieldElement;

import org.bouncycastle.math.ec.ECFieldElement.Fp;

import org.bouncycastle.math.ec.ECPoint;

import java.math.BigInteger;

import java.security.SecureRandom;

public class SM2 {

//测试参数

// public static final String[] ecc_param = {

// "8542D69E4C044F18E8B92435BF6FF7DE457283915C45517D722EDB8B08F1DFC3",

// "787968B4FA32C3FD2417842E73BBFEFF2F3C848B6831D7E0EC65228B3937E498",

// "63E4C6D3B23B0C849CF84241484BFE48F61D59A5B16BA06E6E12D1DA27C5249A",

// "8542D69E4C044F18E8B92435BF6FF7DD297720630485628D5AE74EE7C32E79B7",

// "421DEBD61B62EAB6746434EBC3CC315E32220B3BADD50BDC4C4E6C147FEDD43D",

// "0680512BCBB42C07D47349D2153B70C4E5D7FDFCBFA36EA1A85841B9E46E09A2"

// };

//正式参数

public static String[] ecc_param = {

"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF",

"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC",

"28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93",

"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123",

"32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7",

"BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0"

};

public final BigInteger ecc_p;

public final BigInteger ecc_a;

public final BigInteger ecc_b;

public final BigInteger ecc_n;

public final BigInteger ecc_gx;

public final BigInteger ecc_gy;

public final ECCurve ecc_curve;

public final ECPoint ecc_point_g;

public final ECDomainParameters ecc_bc_spec;

public final ECKeyPairGenerator ecc_key_pair_generator;

public final ECFieldElement ecc_gx_fieldelement;

public final ECFieldElement ecc_gy_fieldelement;

public SM2() {

this.ecc_p = new BigInteger(ecc_param[0], 16);

this.ecc_a = new BigInteger(ecc_param[1], 16);

this.ecc_b = new BigInteger(ecc_param[2], 16);

this.ecc_n = new BigInteger(ecc_param[3], 16);

this.ecc_gx = new BigInteger(ecc_param[4], 16);

this.ecc_gy = new BigInteger(ecc_param[5], 16);

this.ecc_gx_fieldelement = new Fp(this.ecc_p, this.ecc_gx);

this.ecc_gy_fieldelement = new Fp(this.ecc_p, this.ecc_gy);

this.ecc_curve = new ECCurve.Fp(this.ecc_p, this.ecc_a, this.ecc_b);

this.ecc_point_g = new ECPoint.Fp(this.ecc_curve, this.ecc_gx_fieldelement, this.ecc_gy_fieldelement);

this.ecc_bc_spec = new ECDomainParameters(this.ecc_curve, this.ecc_point_g, this.ecc_n);

ECKeyGenerationParameters ecc_ecgenparam;

ecc_ecgenparam = new ECKeyGenerationParameters(this.ecc_bc_spec, new SecureRandom());

this.ecc_key_pair_generator = new ECKeyPairGenerator();

this.ecc_key_pair_generator.init(ecc_ecgenparam);

}

public static SM2 Instance() {

return new SM2();

}

import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.math.ec.ECPoint;

import java.io.IOException;
import java.math.BigInteger;

public class SM2Utils {
    //生成随机秘钥对  
    public static void generateKeyPair() {
        SM2 sm2 = SM2.Instance();
        AsymmetricCipherKeyPair key = sm2.ecc_key_pair_generator.generateKeyPair();
        ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters) key.getPrivate();
        ECPublicKeyParameters ecpub = (ECPublicKeyParameters) key.getPublic();
        BigInteger privateKey = ecpriv.getD();
        ECPoint publicKey = ecpub.getQ();

        System.out.println("公钥: " + Util.byteToHex(publicKey.getEncoded()));
        System.out.println("私钥: " + Util.byteToHex(privateKey.toByteArray()));
    }

    //数据加密  
    public static String encrypt(byte[] publicKey, byte[] data) throws IOException {
        if (publicKey == null || publicKey.length == 0) {
            return null;
        }

        if (data == null || data.length == 0) {
            return null;
        }

        byte[] source = new byte[data.length];
        System.arraycopy(data, 0, source, 0, data.length);

        Cipher cipher = new Cipher();
        SM2 sm2 = SM2.Instance();
        ECPoint userKey = sm2.ecc_curve.decodePoint(publicKey);

        ECPoint c1 = cipher.Init_enc(sm2, userKey);
        cipher.Encrypt(source);
        byte[] c3 = new byte[32];
        cipher.doFinal(c3);

//      System.out.println("C1 " + Util.byteToHex(c1.getEncoded()));  
//      System.out.println("C2 " + Util.byteToHex(source));  
//      System.out.println("C3 " + Util.byteToHex(c3));  
        //C1 C2 C3拼装成加密字串  
        return Util.byteToHex(c1.getEncoded()) + Util.byteToHex(source) + Util.byteToHex(c3);

    }

    //数据解密
    //c3InFront 硬件为了方便加解密数据，把定长的C3放在变长的C2前面，由默认的C1C2C3调整成C1C3C2的格式
    public static byte[] decrypt(byte[] privateKey, byte[] encryptedData, boolean c3InFront) throws IOException {
        if (privateKey == null || privateKey.length == 0) {
            return null;
        }

        if (encryptedData == null || encryptedData.length == 0) {
            return null;
        }
        //加密字节数组转换为十六进制的字符串 长度变为encryptedData.length * 2  
        String data = Util.byteToHex(encryptedData);
        /***分解加密字串 
         * （C1 = C1标志位2位 + C1实体部分128位 = 130） 
         * （C3 = C3实体部分64位  = 64） 
         * （C2 = encryptedData.length * 2 - C1长度  - C2长度） 
         */
        byte[] c1Bytes = Util.hexToByte(data.substring(0, 130));
        byte[] c2;
        byte[] c3; 
        if (c3InFront) {
            c3 = Util.hexToByte(data.substring(130, 64));
            c2 = Util.hexToByte(data.substring(130 + 64));
        } else {
            /***C1 || C2 || C3 的意思就是拼在一起，而不是做什么或运算
             * 
             * 根据国密推荐的SM2椭圆曲线公钥密码算法，首先产生随机数计算出曲线点C1，
             * 2个32byte的BIGNUM大数，即为SM2加密结果的第1部分（C1）。
             * 第2部分则是真正的密文，是对明文的加密结果，长度和明文一样（C2）。
             * 第3部分是杂凑值，用来效验数据（C3）。按国密推荐的256位椭圆曲线，
             * 明文加密结果比原长度会大97byte（C1使用EC_POINT_point2oct转换）。
             * 
             */
            int c2Len = encryptedData.length - 97;
            c2 = Util.hexToByte(data.substring(130, 130 + 2 * c2Len));
            c3 = Util.hexToByte(data.substring(130 + 2 * c2Len, 194 + 2 * c2Len));
        }
        SM2 sm2 = SM2.Instance();
        BigInteger userD = new BigInteger(1, privateKey);

        //通过C1实体字节来生成ECPoint  
        ECPoint c1 = sm2.ecc_curve.decodePoint(c1Bytes);
        Cipher cipher = new Cipher();
        cipher.Init_dec(userD, c1);
        cipher.Decrypt(c2);
        cipher.doFinal(c3);

        //返回解密结果  
        return c2;
    }

    public static void main(String[] args) throws Exception {
        //生成密钥对  
        generateKeyPair();

        String plainText = "ererfeiisgod";
        byte[] sourceData = plainText.getBytes();

        //下面的秘钥可以使用generateKeyPair()生成的秘钥内容  
        // 国密规范正式私钥  
        String prik = "3690655E33D5EA3D9A4AE1A1ADD766FDEA045CDEAA43A9206FB8C430CEFE0D94";
        // 国密规范正式公钥  
        String pubk = "04F6E0C3345AE42B51E06BF50B98834988D54EBC7460FE135A48171BC0629EAE205EEDE253A530608178A98F1E19BB737302813BA39ED3FA3C51639D7A20C7391A";

        System.out.println("加密: ");
        String cipherText = SM2Utils.encrypt(Util.hexToByte(pubk), sourceData);
        System.out.println(cipherText);
        System.out.println("解密: ");
        plainText = new String(SM2Utils.decrypt(Util.hexToByte(prik), Util.hexToByte(cipherText), false));
        System.out.println(plainText);

    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

import org

2024 年 10 月
一	二	三	四	五	六	日
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30	31