openEuler 21.03 特性解读 | 毕昇 JDK8 支持鲲鹏硬件加解密特性详解和使用介绍

Posted 2021-10-02 宋宝华

毕昇 JDK8 2021 年第一个重要版本 8u282 已在 2021.3.30 日发布，请参考 2021 年毕昇 JDK8、JDK11 第一个重要发布来了!，其中 KAEProvider 作为新特性为用户提供了一种利用鲲鹏硬件来进行加解密的加密实现，为了使用户更好的理解其实现细节和使用该特性，本文对 KAEProvider 的实现原理和使用方法进行说明。

前言

KAE（Kunpeng Accelerate Engine）加解密是鲲鹏处理器提供的硬件加速方案，可以显著降低处理器消耗，提高处理器效率。此外，KAE 对应用层屏蔽其内部实现细节，并通过 OpenSSL 标准接口向用户提供[1]。但由于 OpenSSL 对外提供的是 C 接口，Java 用户需要通过 JNI 的方式才能够对其进行调用，使用不便。

JCA(Java Cryptography Architecture)是一套 Java 为用户提供加解密实现的 API，开发者只需要实现 JDK 中加解密相关的 SPI(Service Provider Interface)接口，并在自己的 CSP(Cryptographic Service Provider, 下文简称 Provider)中进行注册，即可让用户通过 JCA 接口使用到自己的加解密实现。

毕昇 JDK 基于 JCA 框架，为用户提供使用 KAE 来进行加解密的 KAEProvider，用户只需要在 java.security 文件中进行配置，或者简单修改代码即可使用 KAE 带来的加速效果，使用方便。

原理

JCA 通过定义密码学中的“引擎(engine)”为用户提供密码学服务，例如消息摘要和加密等，用户只需要使用引擎类提供的标准 API，就能够获得特定的密码服务，而不用关心实现这些服务的算法[2]。与 KAEProvider 相关的引擎类主要有以下几种：

引擎类	说明
MessageDigest	计算摘要信息，目前支持 MD5,SHA-256,SHA-384
Cipher	进行加解密运算，目前支持 AES, RSA
Mac	计算消息验证码(MAC)，目前支持 HmacMD5,HmacSHA1,HmacSHA224，HmacSHA256,HmacSHA384,HmacSHA512
KeyPairGenerator	产生指定算法的公私钥，目前支持 RSAKeyPairGenerator,后续版本将支持 DHKeyPairGenerator 和 ECKeyPairGenerator
Signature	提供签名和验证签名功能,目前暂无实现，后续版本将支持 RSAPSSSignature
KeyAgreement	提供秘钥协商功能，目前暂无实现，后续版本将支持 DH 和 ECDH

引擎类提供的应用程序接口由 SPI 实现，对于每一个引擎类，都有一个 SPI 类来定义密码服务提供者需要实现的接口，SPI 类的名字与相应引擎类的名字相一致，并后跟 Spi，例如，MessageDigest 引擎类对应的 SPI 类为 MessageDigestSpi.当开发者需要提供自己的加解密实现时，只需要实现对应的 SPI 类，并在 Provider 中进行注册即可。如下为消息摘要类的继承关系图：

如下为消息摘要类在 KAEProvider 中的注册代码：

public class KAEProvider extends Provider {
 public KAEProvider() {
        super("KAEProvider", 1.8d, "KAE provider");
        ...
        putMessageDigest();
    }
    private void putMessageDigest() {
        put("MessageDigest.MD5", "org.openeuler.security.openssl.KAEDigest$MD5");
        put("MessageDigest.SHA-256", "org.openeuler.security.openssl.KAEDigest$SHA256");
        put("MessageDigest.SHA-384", "org.openeuler.security.openssl.KAEDigest$SHA384");
    }
}

当用户通过引擎类 MessageDigest 使用摘要服务时，如通过MessageDigest.getInstance("SHA-256")获取 message digest 对象时，JCA 会依次搜索注册的 Provider，直到找到一种实现为止，大体过程如下[3]:

用户可通过 java.security 文件指定各个 Provider 的优先级，或者在代码中通过Security.insertProviderAt(Provider, int)接口指定.也可以在获取摘要对象时手动指定从哪个 Provider 中获取，如MessageDigest.getInstance("SHA-256", new KAEProvider()),这种情况下，JCA 将优先使用 KAEProvider 中的 SHA-256 实现.

架构

毕昇 JDK 基于 JCA 框架，提供了包括消息摘要、消息验证码、加密等多种加密服务实现，整体架构图如下：

• JDK 层包括 Java 实现和 JNI 实现，其中 Java 实现通过 JCA 的引擎类对外提供加密服务接口，JNI 则将 Java 接口转换为 OpenSSL 对应的实现接口。

• OpenSSL 层作为中间层，向上提供 OpenSSL 接口，向下通过 OpenSSL 引擎机制调用 KAE 提供的驱动接口。

• KAE 将 OpenSSL 中的接口转换为芯片加速子系统提供的寄存器接口，进而使用鲲鹏处理器提供的加速能力。

实现和使用介绍

毕昇 JDK 当前版本包含如下 SPI 类的实现：

SPI类	实现类	说明
MessageDigestSpi	KAEDigest	通过静态内部类的形式支持MD5, SHA-256, SHA-384算法
CipherSpi	KAEAESCipher	通过静态内部类的形式支持ECB、CBC、CTR加密模式
	KAERSACipherSpi	当前支持512、1024、2048、3072、4096位的秘钥大小
MACSpi	KAEMac	通过静态内部类的形式支持HmacMD5,HmacSHA1,HmacSHA224，HmacSHA256,HmacSHA384,HmacSHA512
KeyPairGeneratorSpi	KAERSAKeyPairGenerator	当前支持生成512、1024、2048、3072、4096位的秘钥

下面对这些实现类一一进行详解。

KAEDigest

实现

KAEDigest 是 MessageDigestSpi 的实现类，主要的实现方法有如下几类：

• update方法：主要用来提供需要进行摘要运算的数据

• digest方法：用来获取摘要的结果

当用户调用引擎类 MessageDigest 对象的 update 方法时，会调用到 KAEDigest 中的 update 方法，当调用引擎类的 digest 方法时，则会调用到 KAEDigest 的 digest 方法。

使用介绍

可通过如下方式使用 KAEProvider 计算信息摘要：

import java.security.*;
import java.util.Arrays;
import java.security.Security;
import org.openeuler.security.openssl.KAEProvider;

public class Test {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        Security.insertProviderAt(new KAEProvider(), 1);
        String algorithm = "MD5"; // or SHA-256, SHA-384
        MessageDigest md = MessageDigest.getInstance(algorithm);
        md.update("helloWorld".getBytes());
        byte[] res = md.digest();
        System.out.println("res = " + Arrays.toString(res));
    }
}

使用java -Djava.security.debug=all Test运行，可以得到 KAEProvider 计算 helloworld 的摘要结果：

KAEAESCipher

实现

KAEAESCipher 是 CipherSpi 的实现类，主要实现的方法有如下几类：

• init 方法：主要根据加密模式(加密或解密)和秘钥初始化加密对象

• update 方法：对数据进行加密，该方法可以被多次调用

• final 方法：对数据进行加密，该方法经常被用于获取最后一组数据的加密结果。

• wrap 和 unwrap：wrap 方法主要用来将指定的 key 封装为字节，方便进行安全传输，unwrap 则是将已封装的秘钥解析为对应的 key 对象

用户需要加密数据时，与其他引擎类一样，可以通过Cipher.getInstance(String transformation, Provider provider)方法获取 cipher 对象，参数 transformation 是一个包含加密算法名称、加密模式和填充方式的字符串，如 AES/CTR/NoPadding, 当不指定加密模式或者填充方式时，则使用 Provider 默认提供的加密模式和填充方式，在 KAEProvider 中为 ECB 和 PKCS5Padding，即如下两条声明语句是等价的:

Cipher a = Cipher.getInstance("AES", new KAEProvider());
Cipher b = Cipher.getInstance("AES/ECB/PKCS5Padding", new KAEProvider())

当用户调用引擎类 Cipher 对象的 init 方法时，会调用到 KAEAESCipher 的 init 类方法，当调用引擎类的 update 方法时，会调用到 KAEAESCipher 中的 update 方法，当调用引擎类的 doFinal 方法时，则会调用到 KAECipher 的 final 类方法。

使用介绍

可通过如下方式使用 KAEProvider 的 AES 对数据进行加解密：

import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.util.*;
import org.openeuler.security.openssl.KAEProvider;

public class Test {
    public static void main(String[] args) throws Exception {
        Security.insertProviderAt(new KAEProvider(), 1);
        byte[] keystring = "aesEncryptionKey".getBytes();  // 16 bytes
        SecretKeySpec ks = new SecretKeySpec(keystring, "AES");
// or AES/ECB/PKCS5Padding, AES/ECB/NoPadding,AES/CBC/NoPadding,AES/CBC/PKCS5Padding
        String algorithm = "AES/CTR/NoPadding";
        Cipher encryptCipher = Cipher.getInstance(algorithm);
        encryptCipher.init(Cipher.ENCRYPT_MODE, ks);
        byte[] cipher1 = encryptCipher.update("hello".getBytes());
        byte[] cipher2 = encryptCipher.doFinal("world".getBytes());
        byte[] cipher = new byte[cipher1.length + cipher2.length];
        System.arraycopy(cipher1, 0, cipher, 0, cipher1.length);
        System.arraycopy(cipher2, 0, cipher, cipher1.length, cipher2.length);
        System.out.println("plainText = " + "helloWorld");
        System.out.println("cipherText = " + Arrays.toString(cipher));

        Cipher decryptCipher = Cipher.getInstance(algorithm);
        decryptCipher.init(Cipher.DECRYPT_MODE, ks, encryptCipher.getParameters());
        String plainText = new String(decryptCipher.doFinal(cipher));
        System.out.println("decrypt result = " + plainText);
    }
}

使用java -Djava.security.debug=all Test运行，可以得到 KAEProvider 使用 AES 对 helloworld 进行加密和解密的结果：

KAERSACipher

实现

KAERSACipher 也是 CipherSpi 的实现类，与 KAEAESCipher 类似，这里不再说明。

使用介绍

可通过如下方式使用 KAEProvider 的 RSA 对数据进行加解密：

import java.security.*;
import java.util.Arrays;
import javax.crypto.Cipher;
import org.openeuler.security.openssl.KAEProvider;

public class Test {
    public static void main(String[] args) throws Exception {
        Security.insertProviderAt(new KAEProvider(), 1);
        int keyLength = 512; // or 1024,2048,3072,4096
        String algorithm = "RSA";
        KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
        kpg.initialize(keyLength);
        KeyPair keyPair = kpg.generateKeyPair();

        Cipher encryptCipher = Cipher.getInstance(algorithm);
        encryptCipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic());
        byte[] cipher1 = encryptCipher.update("hello".getBytes());
        byte[] cipher2 = encryptCipher.doFinal("world".getBytes());
        byte[] cipher = new byte[cipher1.length + cipher2.length];
        System.arraycopy(cipher1, 0, cipher, 0, cipher1.length);
        System.arraycopy(cipher2, 0, cipher, cipher1.length, cipher2.length);
        System.out.println("plainText = " + "helloWorld");
        System.out.println("cipherText = " + Arrays.toString(cipher));

        Cipher decryptCipher = Cipher.getInstance(algorithm);
        decryptCipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
        String plainText = new String(decryptCipher.doFinal(cipher));
        System.out.println("decrypt result = " + plainText);
    }
}

使用java -Djava.security.debug=all Test运行，可以得到 KAEProvider 使用 RSA 对 helloworld 进行加密和解密的结果：

KAEMac

实现

KAEMac 是 MACSpi 的实现类，主要实现的方法有以下几类：

• init 方法：主要根据 key 来初始化 Mac 对象，key 可以为实现 javax.crypto.SecretKey 接口的任何秘钥对象，既可以由 javax.crypto.KeyGenerator.generateKey 方法生成，也可以是 javax.crypto.KeyAgreement.generateSecret 方法秘钥协商的结果

• update 方法：提供 MAC 计算需要的数据

• final 方法：用来获取计算的结果

当用户调用引擎类 Mac 对象的 init 方法时，会调用到 KAEMac 的 init 类方法，当调用引擎类的 update 方法时，会调用到 KAEMac 中的 update 方法，当调用引擎类的 doFinal 方法时，则会调用到 KAEMac 的 final 类方法。

使用介绍

可通过如下方式使用 KAEProvider 来进行 MAC 计算。

import java.security.Security;
import java.util.Arrays;
import javax.crypto.*;
import org.openeuler.security.openssl.KAEProvider;

public class Test {
    public static void main(String[] args) throws Exception {
        Security.insertProviderAt(new KAEProvider(), 1);
        String algorithm = "HmacMD5"; // or HmacSHA1,HmacSHA224,HmacSHA256,HmacSHA384,HmacSHA512
        Mac mac = Mac.getInstance(algorithm);
        mac.init(KeyGenerator.getInstance(algorithm).generateKey());
        mac.update("hello".getBytes());
        byte[] res = mac.doFinal("world".getBytes());
        System.out.println("res = " + Arrays.toString(res));
    }
}

使用java -Djava.security.debug=all Test运行，可以得到 KAEProvider 计算 helloworld 的 Mac 结果：

KAERSAKeyPairGenerator

实现

KAERSAKeyPairGenerator 是 KeyPairGeneratorSpi 的实现类，主要实现的方法有如下几类：

• init 方法：通过秘钥大小来初始化 KeyPairGenerator 对象

• generateKeyPair 方法：用来生成 RSA 需要的秘钥对，秘钥对中包含公钥和私钥

当用户获取引擎类 KeyPairGenerator 对象传入的算法参数为 RSA 时，调用引擎类的 initialize 方法，会调用到 KAERSAKeyPairGenerator 的 init 类方法，调用引擎类的 generateKeyPair 方法，则会调用到 KAERSAKeyPairGenerator 中的 generateKeyPair 类方法。

使用介绍

可通过如下方式使用 KAEProvider 生成 RSA 需要的秘钥对。

import java.security.*;
import org.openeuler.security.openssl.KAEProvider;

public class Test {
    public static void main(String[] args) throws Exception {
        Security.insertProviderAt(new KAEProvider(), 1);
        String algorithm = "RSA";
        int keySize = 512; // or 512,1024,2048,3072,4096
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        keyPairGenerator.initialize(keySize);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        System.out.println("publicKey = " + keyPair.getPublic());
        System.out.println("privateKey = " + keyPair.getPrivate());
    }
}

使用java -Djava.security.debug=all Test运行，可以得到 KAEProvider 生成的 RSA 秘钥对结果：

性能测试

KAEProvider 相关的 JMH 测试用例已放入 openeuler 社区[4]，用户可以下载进行测试，由于自带用例包含了多种算法、多种秘钥长度的测试，执行起来会需要较长的时间，用户在使用时可以对其进行简单修改。对于 KAE 不支持的算法，将会采用 OpenSSL 来进行加解密。下面在 Kunpeng 920 的机器上进行测试：

测试环境：

• CPU: Kunpeng 920

• OS: openenuler 20.03

• KAE: v1.3.10 ,下载链接见[5]

• JDK: 毕昇 JDK 1.8.0_282

测试步骤：

• 创建 jmh 的 maven 项目

mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jmh -DarchetypeArtifactId=jmh-java-benchmark-archetype -DgroupId=org.openeuler.bench.security.openssl -DartifactId=kae-benchmark -Dversion=1.0

• 删除项目中自带的测试用例，并将 KAEProvider 的 JMH 用例拷贝至项目目录

rm -rf kae-benchmark/src/main/java/org/openeuler/bench/security/openssl/MyBenchmark.java
cp BenchmarkBase.java RSACipherBenchmark.java RSAKeyPairGeneratorBenchmark.java DigestBenchmark.java HMacBenchmark.java AESBenchmark.java kae-benchmark/src/main/java/org/openeuler/bench/security/openssl/

• 进入 maven 项目进行编译和打包

mvn install

• 对 RSA 加解密进行测试： java -jar target/benchmarks.jar RSACipherBenchmark

图中第 1、3、 5 等单数行为 JDK 默认 Provider 每秒可完成加解密的次数(Score 列)，第 2、4、6 等双数行为 KAEProvider 每秒可完成加解密的次数。 可以看到，相比 JDK 默认的 Provider，KAEProvider 的解密操作平均提升 400%左右，加密操作平均提升 150%左右。

• 对 RSA 秘钥生成进行测试：java -jar target/benchmarks.jar RSAKeyPairGenerator

图中第 1、3 行为 JDK 默认 Provider 每秒可以生成秘钥对的次数(Score 列)，第 2、4 行为 KAEProvider 每秒可生成秘钥对的次数。 可以看到，相比 JDK 默认的 Provider，KAEProvider 生成 RSA 秘钥对的效率平均提升 40%.

参考

1. 鲲鹏加速引擎介绍：https://support.huaweicloud.com/devg-kunpengaccel/kunpengaccel_16_0002.html

2. 深入java2平台安全--体系架构api设计和实现(第二版):https://book.douban.com/subject/1182592/

3. java cryptography architecture (jca) reference guide：https://docs.oracle.com/javase/8/docs/technotes/guides/security/crypto/CryptoSpec.html

4. kaeprovider benchmark：https://gitee.com/openeuler/bishengjdk-8/blob/master/jdk/test/micro/org/openeuler/bench/security/openssl/

5. kae下载链接：https://github.com/kunpengcompute/KAE/releases

交流群：

欢迎加入 Compiler SIG 交流群，一起交流编译器、虚拟机技术。或添加微信：pengchenghan99，回复"加群"，进入 Compiler SIG 交流群。