【鸿蒙实战开发】HarmonyOS非对称加密-RSA_鸿蒙 rsa加密

作者：煮酒与君饮 | 2024-08-04 01:47:59

踩

鸿蒙 rsa加密

1. 介绍

本篇将介绍RSA非对称加密，官方也给出了一些样例使用代码，可供开发者参考。

本篇从实践出发，完整的通过代码方式来深入了解HarmonyOS中的非对称加密用法。

在这里插入图片描述

2. 基础概念

字符串样例：RSA1024|PKCS1|MD5|MGF1_MD5

1.密钥算法 : RSA
2.密文组长度 : 1024
3.填充模式 : PKCS1
4.摘要: MD5
5.摘要掩码: MGF1_MD5

关于“RSA算法”，“填充模式”, “摘要”, "摘要掩码"的具体概念，可自行搜索。

3. 实践

加密使用的测试数据源有三个，具体见下图

1.“92字节” （即，占用了92个字节的字符串）
2.“117字节” （即，占用了117个字节的字符串）
3.“128字节” (即，占用了128个字节的字符串)

3.1 MMI入口

在这里插入图片描述

3.2 RSA加解密

●RSA加密算法密文分组长度有七种：512，718，1024，2048，3072，4096，8192；
●支持3种填充模式:NoPadding, PKCS1, PKCS1_OAEP;
●在PCKCS1_OAEP填充模式下，支持六种摘要:MD5, SHA1, SHA224, SHA256, SHA384, SHA512；
●在PCKCS1_OAEP填充模式下，支持六种摘要掩码:MGF1_MD5, MGF1_SHA1, MGF1_SHA224, MGF1_SHA256, MGF1_SHA384, MGF1_SHA512
本篇仅以1024密文组长度做为实践验证，默认选择“128字节”数据集

片段代码以 “RSA1024|PKCS1_OAEP|MD5|MGF1_MD5” 为例

在这里插入图片描述

3.2.1 加密

生成对动态密钥

//导入加密框架
import cryptoFramework from '@ohos.security.cryptoFramework';

......

//创建密钥生成器，参数为（密钥算法+密文组长度+素数，如：RSA1024|PRIMES_2）
let symKeyGenerator = cryptoFramework.createAsyKeyGenerator('RSA1024|PRIMES_2');

//生成对称密钥
let promiseSymKey = symKeyGenerator.generateKeyPair();

//获取密钥
promiseSymKey( key => {
   
 //密钥对
 this.keyPair = rsaKeyPair;

})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

初始化Cipher

//创建Cipher
globalCipher = cryptoFramework.createCipher('RSA1024|PKCS1_OAEP|MD5|MGF1_MD5');

//使用公钥初始化Cipher
let mode = cryptoFramework.CryptoMode.ENCRYPT_MODE; 
globalCipher.init(mode, this.keyPair.pubKey, null)

1
2
3
4
5
6
7

加密

//文字转换为Uint8Array
const encoder = new util.TextEncoder()
let u8a_encoder = encoder.encodeInto('测试')

//封装Uint8Array 数据，必须是一个带data属性的对象
let plainText = { data: u8a_encoder };

//开始加密
let promiseUpdate = globalCipher.doFinal(plainText);

//获取加密结果
promiseUpdate( result => {

   //密文
   let this.cipherText = result.data
   
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

至此，加密已经结束。

3.2.2 解密

生成密钥对象

//创建密钥生成器，参数为（密钥算法+密文组长度+素数，如：RSA1024|PRIMES_2）
let symKeyGenerator = cryptoFramework.createSymKeyGenerator('RSA1024|PRIMES_2');

//密钥生成器使用密钥数据，开始生成密钥对象
symKeyGenerator.convertKey(this.keyPair.pubKey.getEncoded(), this.keyPair.priKey.getEncoded()).then( key => {

   //key 为生成的密钥对象
   
})

1
2
3
4
5
6
7
8
9
10

初始化Cipher

//创建Cipher
globalCipher = cryptoFramework.createCipher('RSA1024|PKCS1_OAEP|MD5|MGF1_MD5');

//初始化Cipher，参数keyPair.priKey由第一步生成的
let mode = cryptoFramework.CryptoMode.DECRYPT_MODE;
globalCipher.init(mode, keyPair.priKey
, null)
1
2
3
4
5
6
7

解密

//this.cipherText 代表密文，本篇文章中，此值来源于上述加密结果
globalCipher.doFinal({ data: this.cipherText })
1
2

3.2.3 注意点

这些是基于RSA1024场景下，实践出的结论

1.NoPadding填充模式下，明文字节长度必须为128个字节长度
2.PKCS1填充模式下，明文字节长度最大为117个字节
3.PKCS1_OAEP填充模式下，明文字节长度最大为92个字节
4.摘要和摘要掩码只有在PKCS1_OAEP填充模式下，才会出现在初始化Cipher参数中

3.2.4 源码

import cryptoFramework from '@ohos.security.cryptoFramework';
import util from '@ohos.util';
import Logger from '../../common/Logger';
import OriginData from './OriginData';
import emitter from "@ohos.events.emitter";

/**
 * 非对称密钥
 *    密钥算法：RSA
 *    密钥规格格式：(密钥算法名称 + 密钥长度) | 素数
 *    密钥长度：512，718，1024, 2048, 3072, 4096, 8192
 *    密钥规格列表：AES512|PRIMES_2， RSA768|PRIMES_2， RSA1024|PRIMES_2, RSA1024|PRIMES_3, RSA2048|PRIMES_2
 *               RSA2048|PRIMES_3, RSA3072|PRIMES_2, RSA3072|PRIMES_3, RSA4096|PRIMES_2, RSA4096|PRIMES_3
 *               RSA4096|PRIMES_4, RSA8192|PRIMES_2, RSA8192|PRIMES_3, RSA8192|PRIMES_4, RSA8192|PRIMES_5
 *
 * 非对称对称加密
 *    加密算法：RSA
 *    加密规格格式：密钥算法名称 + 密钥长度 + 填充模式 + [摘要 + 摘要掩码]
 *    密钥长度：512，718，1024, 2048, 3072, 4096, 8192
 *    填充模式：NoPadding，PKCS1，PKCS1_OAEP
 *    摘要: MD5, SHA1, SHA224, SHA256, SHA384, SHA512
 *    摘要掩码: MGF1_MD5, MGF1_SHA1, MGF1_SHA224, MGF1_SHA256, MGF1_SHA384, MGF1_SHA512
 *    加密规格样例：RSA512｜NoPadding，RSA512|PKCS1，RSA512|PKCS1_OAEP|MD5|MGF1_SHA224
 *
 *
 */
class TestAsyRSAEncryptDecrypt {

  private  keyPair: cryptoFramework.KeyPair;

  private cipherText: Uint8Array;

  private algorithmWithLength: string = 'RSA1024'
  private paddingMode: string = 'NoPadding' //NoPadding，PKCS5，PKCS1_OAEP
  private digest: string = 'MD5' //MD5、SHA1、SHA224、SHA256、SHA384、SHA512
  private digestMask: string = 'MGF1_MD5' //MGF1_MD5、MGF1_SHA1、MGF1_SHA224、MGF1_SHA256、MGF1_SHA384、MGF1_SHA512

  //对称加密：RSA1024|PKCS1_OAEP|MD5|MGF1_MD5
  testAsyRASEncrypt(paddingMode: string, digest: string, digestMask, dataSource:number) {

    let globalCipher: cryptoFramework.Cipher

    let originData: string

    if(dataSource == 92){
      originData = OriginData.RSA_1024_CONTENT_92
    } else if(dataSource == 117){
      originData = OriginData.RSA_1024_CONTENT_117
    } else {
      originData = OriginData.RSA_1024_CONTENT_128
    }

    this.paddingMode = paddingMode
    this.digest = digest
    this.digestMask = digestMask

    let symKeyGenerator = cryptoFramework.createAsyKeyGenerator(this.algorithmWithLength+'|PRIMES_2');

    let promiseSymKey = symKeyGenerator.generateKeyPair();

    promiseSymKey.then( rsaKeyPair => {

      this.keyPair = rsaKeyPair;

      let p: string = ''

      for(let a of rsaKeyPair.priKey.getEncoded().data){
        p = p.concat(a+',')
      }
      Logger.d('原始私钥',p)

      let spec = ''
      if(this.paddingMode == 'PKCS1_OAEP'){
        spec = this.algorithmWithLength + '|' + this.paddingMode + '|' + this.digest + '|' + this.digestMask
      } else {
        spec = this.algorithmWithLength + '|' + this.paddingMode
      }

      console.log('加密规格：', spec)

      globalCipher = cryptoFramework.createCipher(spec);

      let mode = cryptoFramework.CryptoMode.ENCRYPT_MODE;

      return globalCipher.init(mode, this.keyPair.pubKey, null);

    }).then(() => {

        const encoder = new util.TextEncoder()
        let u8a_encoder = encoder.encodeInto(originData)

        Logger.d('开始加密')

        let plainText = { data: u8a_encoder };
        let promiseUpdate = globalCipher.doFinal(plainText);

        return promiseUpdate;

      }).then(updateOutput => {

        if(updateOutput != null && updateOutput.data != null){
          this.cipherText = updateOutput.data
          console.log('密文：', this.cipherText)
        }

      }).then(() => {

        this.testSymAESDecrypt()
        return

      }).catch( error => {
         console.error(`catch error, ${error.code}, ${error.message}`);
         this.notificationStatus('加密中-error',  error.code + '-' +  error.message)
      })

  }

  //非对称解密: RSA1024|PKCS1_OAEP|MD5|MGF1_MD5
  testSymAESDecrypt() {

    let globalCipher: cryptoFramework.Cipher

    let symKeyGenerator = cryptoFramework.createAsyKeyGenerator(this.algorithmWithLength);

    // 根据指定的二进制密钥数据，生成对称密钥对象
    symKeyGenerator.convertKey(this.keyPair.pubKey.getEncoded(), this.keyPair.priKey.getEncoded())
      .then( keyPair => {
        console.log('解密-初始化Cipher')
        let spec = ''
        if(this.paddingMode == 'PKCS1_OAEP'){
          spec = this.algorithmWithLength + '|' + this.paddingMode + '|' + this.digest + '|' + this.digestMask
        } else {
          spec = this.algorithmWithLength + '|' + this.paddingMode
        }
        globalCipher = cryptoFramework.createCipher(spec);

        let mode = cryptoFramework.CryptoMode.DECRYPT_MODE;

        let p: string = ''

        for(let a of keyPair.priKey.getEncoded().data){
          p = p.concat(a+',')
        }

        Logger.d('解密私钥',p)

        globalCipher.init(mode, keyPair.priKey, null);
        return

      })
      .then(() => {

        console.log('开始解密', '密文')
        return globalCipher.doFinal({ data: this.cipherText });

      })
      .then( updateOutput => {

        let textDecoder = util.TextDecoder.create()
        let key = textDecoder.decodeWithStream(updateOutput.data);

        Logger.d('解密完成1: ', key);
        this.notificationStatus('解密完成', key)

      })
      .catch(error => {
        console.error(`catch error, ${error.code}, ${error.message}`);
        this.notificationStatus('解密中-error',  error.code + '-' +  error.message)
      })

  }

   notificationStatus(status:string, result: string){
     // 定义一个eventId为1的事件，事件优先级为Low
     let event = {
       eventId: 202404063287,
       priority: emitter.EventPriority.HIGH
     };

     let eventData = {
       data: {
         "content": result,
         'status': status,
       }
     };

     // 发送eventId为1的事件，事件内容为eventData
     emitter.emit(event, eventData);
   }
}

export default new TestAsyRSAEncryptDecrypt();
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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

3.4 实践结果

以1024长度分组，“92字节”，“117字节”， “128字节”作为数据源

数据集

//117字节，PKCS1 M最大
public static readonly RSA_1024_CONTENT_117: string =
        "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567"

//92字节，PKCS1_OAEP 最大
public static readonly RSA_1024_CONTENT_92: string =
  "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012"

//128字节，RSA｜NoPadding 固定
public static readonly RSA_1024_CONTENT_128: string =
  "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
  + "1234567890123456789012345678"
1
2
3
4
5
6
7
8
9
10
11
12

组合实验结果

1.NoPadding填充模式下，使用“128字节”数据源， ✅
2.PKCS1填充模式下，使用“117字节”数据源，✅
3.PKCS1_OAEP填充模式下，使用“92字节”数据源，组合所有摘要和摘要掩码，✅

写在最后

有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？而且学习时频繁踩坑，最终浪费大量时间。所以有一份实用的鸿蒙（HarmonyOS NEXT）资料用来跟着学习是非常有必要的。

这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、openHarmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。