1 /*
2  * Copyright (C) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *    http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "rsa_common_param_spec.h"
16 #include <gtest/gtest.h>
17 #include "securec.h"
18 
19 #include "asy_key_generator.h"
20 #include "asy_key_generator_spi.h"
21 #include "blob.h"
22 #include "detailed_rsa_key_params.h"
23 #include "memory.h"
24 #include "openssl_class.h"
25 #include "openssl_common.h"
26 
RemoveLastChar(const unsigned char * str,unsigned char * dest,uint32_t destLen)27 void RemoveLastChar(const unsigned char *str, unsigned char *dest, uint32_t destLen)
28 {
29     for (size_t i = 0; i < destLen; i++) {
30         dest[i] = str[i];
31     }
32     return;
33 }
34 
EndianSwap(unsigned char * pData,int startIndex,int length)35 void EndianSwap(unsigned char *pData, int startIndex, int length)
36 {
37     int cnt = length / 2;
38     int start = startIndex;
39     int end  = startIndex + length - 1;
40     for (int i = 0; i < cnt; i++) {
41         unsigned char tmp = pData[start + i];
42         pData[start + i] = pData[end - i];
43         pData[end - i] = tmp;
44     }
45 }
46 
47 // 512 defined the length of byte array
GenerateRsa512CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)48 void GenerateRsa512CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
49 {
50     if (dataN == nullptr) {
51         return;
52     }
53     RemoveLastChar(CORRECT_512_N, dataN, RSA_512_N_BYTE_SIZE);
54     if (!IsBigEndian()) {
55         // the device is not big endian
56         EndianSwap(dataN, 0, RSA_512_N_BYTE_SIZE);
57     }
58     returnSpec->n.data = dataN;
59     returnSpec->n.len = RSA_512_N_BYTE_SIZE;
60     returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
61     returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
62     return;
63 }
64 
GenerateRsa512CorrectPubKeySpec(unsigned char * dataN,unsigned char * dataE,HcfRsaPubKeyParamsSpec * returnPubSpec)65 void GenerateRsa512CorrectPubKeySpec(unsigned char *dataN, unsigned char *dataE,
66     HcfRsaPubKeyParamsSpec *returnPubSpec)
67 {
68     HcfRsaCommParamsSpec rsaCommSpec = {};
69     GenerateRsa512CorrectCommonKeySpec(dataN, &rsaCommSpec);
70     RemoveLastChar(CORRECT_E, dataE, RSA_512_E_BYTE_SIZE);
71     if (!IsBigEndian()) {
72         // the device is not big endian
73         EndianSwap(dataE, 0, RSA_512_E_BYTE_SIZE);
74     }
75     returnPubSpec->pk.data = dataE;
76     returnPubSpec->pk.len = RSA_512_E_BYTE_SIZE;
77     returnPubSpec->base = rsaCommSpec;
78     returnPubSpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
79 }
80 
GenerateRsa512CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)81 void GenerateRsa512CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
82     HcfRsaKeyPairParamsSpec *returnPairSpec)
83 {
84     HcfRsaCommParamsSpec rsaCommSpec = {};
85     GenerateRsa512CorrectCommonKeySpec(dataN, &rsaCommSpec);
86     RemoveLastChar(CORRECT_E, dataE, RSA_512_E_BYTE_SIZE);
87     RemoveLastChar(CORRECT_512_D, dataD, RSA_512_D_BYTE_SIZE);
88     if (!IsBigEndian()) {
89         // the device is not big endian
90         EndianSwap(dataE, 0, RSA_512_E_BYTE_SIZE);
91         EndianSwap(dataD, 0, RSA_512_D_BYTE_SIZE);
92     }
93     returnPairSpec->pk.data = dataE;
94     returnPairSpec->pk.len = RSA_512_E_BYTE_SIZE;
95     returnPairSpec->sk.data = dataD;
96     returnPairSpec->sk.len = RSA_512_D_BYTE_SIZE;
97     returnPairSpec->base = rsaCommSpec;
98     returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
99 }
100 
101 // 768 defined the length of byte array
GenerateRsa768CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)102 void GenerateRsa768CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
103 {
104     RemoveLastChar(CORRECT_768_N, dataN, RSA_768_N_BYTE_SIZE);
105     if (!IsBigEndian()) {
106         // the device is not big endian
107         EndianSwap(dataN, 0, RSA_768_N_BYTE_SIZE);
108     }
109     returnSpec->n.data = dataN;
110     returnSpec->n.len = RSA_768_N_BYTE_SIZE;
111     returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
112     returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
113     return;
114 }
115 
GenerateRsa768CorrectPubKeySpec(unsigned char * dataN,unsigned char * dataE,HcfRsaPubKeyParamsSpec * returnPubSpec)116 void GenerateRsa768CorrectPubKeySpec(unsigned char *dataN, unsigned char *dataE,
117     HcfRsaPubKeyParamsSpec *returnPubSpec)
118 {
119     HcfRsaCommParamsSpec rsaCommSpec = {};
120     GenerateRsa768CorrectCommonKeySpec(dataN, &rsaCommSpec);
121     RemoveLastChar(CORRECT_E, dataE, RSA_768_E_BYTE_SIZE);
122     if (!IsBigEndian()) {
123         // the device is not big endian
124         EndianSwap(dataE, 0, RSA_768_E_BYTE_SIZE);
125     }
126     returnPubSpec->pk.data = dataE;
127     returnPubSpec->pk.len = RSA_768_E_BYTE_SIZE;
128     returnPubSpec->base = rsaCommSpec;
129     returnPubSpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
130 }
131 
GenerateRsa768CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)132 void GenerateRsa768CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
133     HcfRsaKeyPairParamsSpec *returnPairSpec)
134 {
135     HcfRsaCommParamsSpec rsaCommSpec = {};
136     GenerateRsa768CorrectCommonKeySpec(dataN, &rsaCommSpec);
137     RemoveLastChar(CORRECT_E, dataE, RSA_768_E_BYTE_SIZE);
138     RemoveLastChar(CORRECT_768_D, dataD, RSA_768_D_BYTE_SIZE);
139     if (!IsBigEndian()) {
140         // the device is not big endian
141         EndianSwap(dataE, 0, RSA_768_E_BYTE_SIZE);
142         EndianSwap(dataD, 0, RSA_768_D_BYTE_SIZE);
143     }
144     returnPairSpec->pk.data = dataE;
145     returnPairSpec->pk.len = RSA_768_E_BYTE_SIZE;
146     returnPairSpec->sk.data = dataD;
147     returnPairSpec->sk.len = RSA_768_D_BYTE_SIZE;
148     returnPairSpec->base = rsaCommSpec;
149     returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
150 }
151 
152 // 1024 defined the length of byte array
GenerateRsa1024CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)153 void GenerateRsa1024CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
154 {
155     RemoveLastChar(CORRECT_1024_N, dataN, RSA_1024_N_BYTE_SIZE);
156     if (!IsBigEndian()) {
157         // the device is not big endian
158         EndianSwap(dataN, 0, RSA_1024_N_BYTE_SIZE);
159     }
160     returnSpec->n.data = dataN;
161     returnSpec->n.len = RSA_1024_N_BYTE_SIZE;
162     returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
163     returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
164     return;
165 }
166 
GenerateRsa1024CorrectPubKeySpec(unsigned char * dataN,unsigned char * dataE,HcfRsaPubKeyParamsSpec * returnPubSpec)167 void GenerateRsa1024CorrectPubKeySpec(unsigned char *dataN, unsigned char *dataE,
168     HcfRsaPubKeyParamsSpec *returnPubSpec)
169 {
170     HcfRsaCommParamsSpec rsaCommSpec = {};
171     GenerateRsa1024CorrectCommonKeySpec(dataN, &rsaCommSpec);
172     RemoveLastChar(CORRECT_E, dataE, RSA_1024_E_BYTE_SIZE);
173     if (!IsBigEndian()) {
174         // the device is not big endian
175         EndianSwap(dataE, 0, RSA_1024_E_BYTE_SIZE);
176     }
177     returnPubSpec->pk.data = dataE;
178     returnPubSpec->pk.len = RSA_1024_E_BYTE_SIZE;
179     returnPubSpec->base = rsaCommSpec;
180     returnPubSpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
181 }
182 
GenerateRsa1024CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)183 void GenerateRsa1024CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
184     HcfRsaKeyPairParamsSpec *returnPairSpec)
185 {
186     HcfRsaCommParamsSpec rsaCommSpec = {};
187     GenerateRsa1024CorrectCommonKeySpec(dataN, &rsaCommSpec);
188     RemoveLastChar(CORRECT_E, dataE, RSA_1024_E_BYTE_SIZE);
189     RemoveLastChar(CORRECT_1024_D, dataD, RSA_1024_D_BYTE_SIZE);
190     if (!IsBigEndian()) {
191         // the device is not big endian
192         EndianSwap(dataE, 0, RSA_1024_E_BYTE_SIZE);
193         EndianSwap(dataD, 0, RSA_1024_D_BYTE_SIZE);
194     }
195     returnPairSpec->pk.data = dataE;
196     returnPairSpec->pk.len = RSA_1024_E_BYTE_SIZE;
197     returnPairSpec->sk.data = dataD;
198     returnPairSpec->sk.len = RSA_1024_D_BYTE_SIZE;
199     returnPairSpec->base = rsaCommSpec;
200     returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
201 }
202 
203 // 2048 defined the length of byte array
GenerateRsa2048CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)204 void GenerateRsa2048CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
205 {
206     RemoveLastChar(CORRECT_2048_N, dataN, RSA_2048_N_BYTE_SIZE);
207     if (!IsBigEndian()) {
208         // the device is not big endian
209         EndianSwap(dataN, 0, RSA_2048_N_BYTE_SIZE);
210     }
211     returnSpec->n.data = dataN;
212     returnSpec->n.len = RSA_2048_N_BYTE_SIZE;
213     returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
214     returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
215     return;
216 }
217 
GenerateRsa2048CorrectPubKeySpec(unsigned char * dataN,unsigned char * dataE,HcfRsaPubKeyParamsSpec * returnPubSpec)218 void GenerateRsa2048CorrectPubKeySpec(unsigned char *dataN, unsigned char *dataE,
219     HcfRsaPubKeyParamsSpec *returnPubSpec)
220 {
221     HcfRsaCommParamsSpec rsaCommSpec = {};
222     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
223     RemoveLastChar(CORRECT_E, dataE, RSA_2048_E_BYTE_SIZE);
224     if (!IsBigEndian()) {
225         // the device is not big endian
226         EndianSwap(dataE, 0, RSA_2048_E_BYTE_SIZE);
227     }
228     returnPubSpec->pk.data = dataE;
229     returnPubSpec->pk.len = RSA_2048_E_BYTE_SIZE;
230     returnPubSpec->base = rsaCommSpec;
231     returnPubSpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
232 }
233 
GenerateRsa2048CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)234 void GenerateRsa2048CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
235     HcfRsaKeyPairParamsSpec *returnPairSpec)
236 {
237     HcfRsaCommParamsSpec rsaCommSpec = {};
238     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
239     RemoveLastChar(CORRECT_E, dataE, RSA_2048_E_BYTE_SIZE);
240     RemoveLastChar(CORRECT_2048_D, dataD, RSA_2048_D_BYTE_SIZE);
241     if (!IsBigEndian()) {
242         // the device is not big endian
243         EndianSwap(dataE, 0, RSA_2048_E_BYTE_SIZE);
244         EndianSwap(dataD, 0, RSA_2048_D_BYTE_SIZE);
245     }
246     returnPairSpec->pk.data = dataE;
247     returnPairSpec->pk.len = RSA_2048_E_BYTE_SIZE;
248     returnPairSpec->sk.data = dataD;
249     returnPairSpec->sk.len = RSA_2048_D_BYTE_SIZE;
250     returnPairSpec->base = rsaCommSpec;
251     returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
252 }
253 
254 // 3072 defined the length of byte array
GenerateRsa3072CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)255 void GenerateRsa3072CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
256 {
257     RemoveLastChar(CORRECT_3072_N, dataN, RSA_3072_N_BYTE_SIZE);
258     if (!IsBigEndian()) {
259         // the device is not big endian
260         EndianSwap(dataN, 0, RSA_3072_N_BYTE_SIZE);
261     }
262     returnSpec->n.data = dataN;
263     returnSpec->n.len = RSA_3072_N_BYTE_SIZE;
264     returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
265     returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
266     return;
267 }
268 
GenerateRsa3072CorrectPubKeySpec(unsigned char * dataN,unsigned char * dataE,HcfRsaPubKeyParamsSpec * returnPubSpec)269 void GenerateRsa3072CorrectPubKeySpec(unsigned char *dataN, unsigned char *dataE,
270     HcfRsaPubKeyParamsSpec *returnPubSpec)
271 {
272     HcfRsaCommParamsSpec rsaCommSpec = {};
273     GenerateRsa3072CorrectCommonKeySpec(dataN, &rsaCommSpec);
274     RemoveLastChar(CORRECT_E, dataE, RSA_3072_E_BYTE_SIZE);
275     if (!IsBigEndian()) {
276         // the device is not big endian
277         EndianSwap(dataE, 0, RSA_3072_E_BYTE_SIZE);
278     }
279     returnPubSpec->pk.data = dataE;
280     returnPubSpec->pk.len = RSA_3072_E_BYTE_SIZE;
281     returnPubSpec->base = rsaCommSpec;
282     returnPubSpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
283 }
284 
GenerateRsa3072CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)285 void GenerateRsa3072CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
286     HcfRsaKeyPairParamsSpec *returnPairSpec)
287 {
288     HcfRsaCommParamsSpec rsaCommSpec = {};
289     GenerateRsa3072CorrectCommonKeySpec(dataN, &rsaCommSpec);
290     RemoveLastChar(CORRECT_E, dataE, RSA_3072_E_BYTE_SIZE);
291     RemoveLastChar(CORRECT_3072_D, dataD, RSA_3072_D_BYTE_SIZE);
292     if (!IsBigEndian()) {
293         // the device is not big endian
294         EndianSwap(dataE, 0, RSA_3072_E_BYTE_SIZE);
295         EndianSwap(dataD, 0, RSA_3072_D_BYTE_SIZE);
296     }
297     returnPairSpec->pk.data = dataE;
298     returnPairSpec->pk.len = RSA_3072_E_BYTE_SIZE;
299     returnPairSpec->sk.data = dataD;
300     returnPairSpec->sk.len = RSA_3072_D_BYTE_SIZE;
301     returnPairSpec->base = rsaCommSpec;
302     returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
303 }
304 
305 // 4096 defined the length of byte array
GenerateRsa4096CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)306 void GenerateRsa4096CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
307 {
308     RemoveLastChar(CORRECT_4096_N, dataN, RSA_4096_N_BYTE_SIZE);
309     if (!IsBigEndian()) {
310         // the device is not big endian
311         EndianSwap(dataN, 0, RSA_4096_N_BYTE_SIZE);
312     }
313     returnSpec->n.data = dataN;
314     returnSpec->n.len = RSA_4096_N_BYTE_SIZE;
315     returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
316     returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
317     return;
318 }
319 
GenerateRsa4096CorrectPubKeySpec(unsigned char * dataN,unsigned char * dataE,HcfRsaPubKeyParamsSpec * returnPubSpec)320 void GenerateRsa4096CorrectPubKeySpec(unsigned char *dataN, unsigned char *dataE,
321     HcfRsaPubKeyParamsSpec *returnPubSpec)
322 {
323     HcfRsaCommParamsSpec rsaCommSpec = {};
324     GenerateRsa4096CorrectCommonKeySpec(dataN, &rsaCommSpec);
325     RemoveLastChar(CORRECT_E, dataE, RSA_4096_E_BYTE_SIZE);
326     if (!IsBigEndian()) {
327         // the device is not big endian
328         EndianSwap(dataE, 0, RSA_4096_E_BYTE_SIZE);
329     }
330     returnPubSpec->pk.data = dataE;
331     returnPubSpec->pk.len = RSA_4096_E_BYTE_SIZE;
332     returnPubSpec->base = rsaCommSpec;
333     returnPubSpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
334 }
335 
GenerateRsa4096CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)336 void GenerateRsa4096CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
337     HcfRsaKeyPairParamsSpec *returnPairSpec)
338 {
339     HcfRsaCommParamsSpec rsaCommSpec = {};
340     GenerateRsa4096CorrectCommonKeySpec(dataN, &rsaCommSpec);
341     RemoveLastChar(CORRECT_E, dataE, RSA_4096_E_BYTE_SIZE);
342     RemoveLastChar(CORRECT_4096_D, dataD, RSA_4096_D_BYTE_SIZE);
343     if (!IsBigEndian()) {
344         // the device is not big endian
345         EndianSwap(dataE, 0, RSA_4096_E_BYTE_SIZE);
346         EndianSwap(dataD, 0, RSA_4096_D_BYTE_SIZE);
347     }
348     returnPairSpec->pk.data = dataE;
349     returnPairSpec->pk.len = RSA_4096_E_BYTE_SIZE;
350     returnPairSpec->sk.data = dataD;
351     returnPairSpec->sk.len = RSA_4096_D_BYTE_SIZE;
352     returnPairSpec->base = rsaCommSpec;
353     returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
354 }
355 
356 // 8192 defined the length of byte array
GenerateRsa8192CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)357 void GenerateRsa8192CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
358 {
359     RemoveLastChar(CORRECT_8192_N, dataN, RSA_8192_N_BYTE_SIZE);
360     if (!IsBigEndian()) {
361         // the device is not big endian
362         EndianSwap(dataN, 0, RSA_8192_N_BYTE_SIZE);
363     }
364     returnSpec->n.data = dataN;
365     returnSpec->n.len = RSA_8192_N_BYTE_SIZE;
366     returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
367     returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
368     return;
369 }
370 
GenerateRsa8192CorrectPubKeySpec(unsigned char * dataN,unsigned char * dataE,HcfRsaPubKeyParamsSpec * returnPubSpec)371 void GenerateRsa8192CorrectPubKeySpec(unsigned char *dataN, unsigned char *dataE,
372     HcfRsaPubKeyParamsSpec *returnPubSpec)
373 {
374     HcfRsaCommParamsSpec rsaCommSpec = {};
375     GenerateRsa8192CorrectCommonKeySpec(dataN, &rsaCommSpec);
376     RemoveLastChar(CORRECT_E, dataE, RSA_8192_E_BYTE_SIZE);
377     if (!IsBigEndian()) {
378         // the device is not big endian
379         EndianSwap(dataE, 0, RSA_8192_E_BYTE_SIZE);
380     }
381     returnPubSpec->pk.data = dataE;
382     returnPubSpec->pk.len = RSA_8192_E_BYTE_SIZE;
383     returnPubSpec->base = rsaCommSpec;
384     returnPubSpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
385 }
386 
GenerateRsa8192CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)387 void GenerateRsa8192CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
388     HcfRsaKeyPairParamsSpec *returnPairSpec)
389 {
390     HcfRsaCommParamsSpec rsaCommSpec = {};
391     GenerateRsa8192CorrectCommonKeySpec(dataN, &rsaCommSpec);
392     RemoveLastChar(CORRECT_E, dataE, RSA_8192_E_BYTE_SIZE);
393     RemoveLastChar(CORRECT_8192_D, dataD, RSA_8192_D_BYTE_SIZE);
394     if (!IsBigEndian()) {
395         // the device is not big endian
396         EndianSwap(dataE, 0, RSA_8192_E_BYTE_SIZE);
397         EndianSwap(dataD, 0, RSA_8192_D_BYTE_SIZE);
398     }
399     returnPairSpec->pk.data = dataE;
400     returnPairSpec->pk.len = RSA_8192_E_BYTE_SIZE;
401     returnPairSpec->sk.data = dataD;
402     returnPairSpec->sk.len = RSA_8192_D_BYTE_SIZE;
403     returnPairSpec->base = rsaCommSpec;
404     returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
405 }
406 
CheckGeneratorBySpecKeyFunc(HcfAsyKeyGeneratorBySpec * generator)407 bool CheckGeneratorBySpecKeyFunc(HcfAsyKeyGeneratorBySpec *generator)
408 {
409     if (generator->generateKeyPair == nullptr || generator->generatePriKey == nullptr ||
410         generator->generatePubKey == nullptr) {
411         return false;
412     }
413     return true;
414 }