1 /*
2  * Copyright (c) 2022 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 
16 #include "hks_import_rsa_test.h"
17 #include "hks_test_adapt_for_de.h"
18 
19 #include <gtest/gtest.h>
20 #include <hks_log.h>
21 #ifdef L2_STANDARD
22 #include "file_ex.h"
23 #endif
24 
25 using namespace testing::ext;
26 namespace Unittest::ImportRsaTest {
27 class HksImportRsaTest : public testing::Test {
28 public:
29     static void SetUpTestCase(void);
30 
31     static void TearDownTestCase(void);
32 
33     void SetUp();
34 
35     void TearDown();
36 };
37 
SetUpTestCase(void)38 void HksImportRsaTest::SetUpTestCase(void)
39 {
40 }
41 
TearDownTestCase(void)42 void HksImportRsaTest::TearDownTestCase(void)
43 {
44 }
45 
SetUp()46 void HksImportRsaTest::SetUp()
47 {
48     EXPECT_EQ(HksInitialize(), 0);
49 }
50 
TearDown()51 void HksImportRsaTest::TearDown()
52 {
53 }
54 
55 #ifdef HKS_UNTRUSTED_RUNNING_ENV
56 static const uint8_t g_eData[] = { 0x01, 0x00, 0x01 };
57 
58 static const uint8_t g_nData512[] = {
59     0xb6, 0xd8, 0x9b, 0x33, 0x78, 0xa2, 0x63, 0x21, 0x84, 0x47, 0xa1, 0x72, 0x3d, 0x73, 0x10, 0xbd,
60     0xe9, 0x5d, 0x78, 0x44, 0x3d, 0x80, 0x18, 0x12, 0x60, 0xed, 0x29, 0x3e, 0xc7, 0x23, 0x0d, 0x3f,
61     0x02, 0x59, 0x28, 0xe2, 0x8f, 0x83, 0xdf, 0x37, 0x4b, 0x77, 0xce, 0x5f, 0xb6, 0xcd, 0x61, 0x72,
62     0xee, 0x01, 0xe2, 0x37, 0x4d, 0xfd, 0x4f, 0x39, 0xcf, 0xbd, 0xff, 0x84, 0x57, 0x44, 0xa5, 0x03,
63 };
64 
65 static const uint8_t g_dData512[] = {
66     0x35, 0x63, 0x89, 0xed, 0xbd, 0x8b, 0xac, 0xe6, 0x5c, 0x79, 0x8d, 0xea, 0x8d, 0x86, 0xcb, 0x9c,
67     0xa8, 0x47, 0x62, 0x96, 0x8a, 0x5e, 0x9c, 0xa8, 0xc1, 0x24, 0x7e, 0xa6, 0x95, 0xfe, 0xe6, 0x1e,
68     0xc0, 0xf3, 0x29, 0x76, 0xbb, 0x4d, 0xe4, 0xbc, 0x78, 0x64, 0xe1, 0x79, 0xcd, 0x8a, 0x45, 0xac,
69     0x5c, 0x88, 0xea, 0xb4, 0x10, 0xd8, 0x90, 0x65, 0x7b, 0x94, 0xe8, 0x87, 0x30, 0x2a, 0x04, 0x01,
70 };
71 
72 static const uint8_t g_nData768[] = {
73     0xc7, 0x06, 0x9c, 0x4b, 0x70, 0x57, 0x9a, 0xb9, 0xd0, 0x3a, 0x4b, 0x0b, 0xb8, 0x4b, 0x81, 0x54,
74     0xe7, 0xba, 0xfa, 0xda, 0xf5, 0x04, 0xf0, 0x28, 0x42, 0x6a, 0xb5, 0xb9, 0xf5, 0x1c, 0x5c, 0x2d,
75     0xc1, 0x11, 0xe6, 0xe6, 0xe6, 0xfc, 0xeb, 0x33, 0xa0, 0x45, 0xa9, 0x3b, 0xbf, 0x8f, 0x9d, 0x6e,
76     0xf5, 0x26, 0xe7, 0xa1, 0xf5, 0x8d, 0x48, 0x48, 0x7f, 0x2a, 0xf8, 0x05, 0x43, 0xd5, 0xea, 0x56,
77     0xf4, 0xcf, 0x95, 0xf7, 0x7e, 0x34, 0x0f, 0xee, 0x46, 0x34, 0x05, 0x42, 0x01, 0xce, 0xce, 0xa0,
78     0xa4, 0x70, 0x61, 0xb1, 0x99, 0x0d, 0xd8, 0x3c, 0xbf, 0xf9, 0xb2, 0x2a, 0x32, 0x51, 0x3d, 0xc5,
79 };
80 
81 static const uint8_t g_dData768[] = {
82     0x5b, 0x7c, 0xf0, 0x6f, 0xc5, 0x2e, 0xa0, 0x13, 0x76, 0x62, 0xb5, 0x88, 0xa7, 0xa9, 0x1d, 0xc4,
83     0x97, 0xd9, 0x5d, 0xe3, 0x34, 0xea, 0x96, 0x33, 0x0b, 0x84, 0xde, 0x10, 0xa3, 0x59, 0xec, 0x0d,
84     0xa4, 0x48, 0xc4, 0x69, 0xb4, 0x18, 0xe3, 0x4d, 0x92, 0x09, 0x33, 0xa8, 0x21, 0x80, 0xb5, 0x0f,
85     0x32, 0xd7, 0x04, 0xf3, 0x4e, 0x77, 0xba, 0x9b, 0xc5, 0x20, 0x2c, 0x1e, 0xf7, 0xb3, 0x87, 0x08,
86     0x03, 0x1f, 0x12, 0x63, 0x4a, 0xbe, 0x5f, 0x71, 0x4d, 0xf5, 0x5d, 0x3e, 0x4a, 0xaf, 0x84, 0x17,
87     0x50, 0x9a, 0x5e, 0x04, 0x9e, 0x1f, 0x5a, 0xbd, 0x63, 0xe7, 0x76, 0x0b, 0x00, 0x22, 0x77, 0xa9,
88 };
89 
90 static const uint8_t g_nData1024[] = {
91     0xc7, 0x5e, 0x46, 0xc3, 0x5b, 0x4f, 0x9f, 0x2f, 0x5a, 0xcf, 0x31, 0x65, 0xcc, 0x71, 0x6e, 0x47,
92     0x60, 0x17, 0x1d, 0x86, 0xb9, 0x8f, 0xe5, 0x4b, 0x85, 0x7a, 0x67, 0xfe, 0xa2, 0x03, 0x05, 0x55,
93     0x16, 0xab, 0x51, 0x20, 0x65, 0xc6, 0x83, 0x24, 0x82, 0x58, 0xda, 0x7a, 0xf9, 0x3f, 0x56, 0xa7,
94     0xcb, 0x02, 0x8c, 0xfc, 0x4c, 0xf0, 0x17, 0xdf, 0x8f, 0x80, 0x6a, 0xf3, 0x35, 0xc7, 0x52, 0xa8,
95     0x4c, 0xef, 0xba, 0x99, 0xc5, 0x2f, 0xc2, 0x9f, 0x78, 0x1d, 0xa5, 0x1a, 0xc0, 0x28, 0x66, 0x42,
96     0xa9, 0x65, 0x63, 0xe8, 0xc1, 0x9a, 0xe4, 0xb6, 0xa6, 0x89, 0xac, 0x59, 0xd0, 0xcf, 0x17, 0xc9,
97     0x93, 0x6e, 0x57, 0xeb, 0xa1, 0xc2, 0xe1, 0x23, 0x9a, 0x74, 0xbd, 0x60, 0xd1, 0x98, 0x9a, 0x41,
98     0xa5, 0x9d, 0xff, 0x71, 0x01, 0x94, 0x97, 0x65, 0x7e, 0xd9, 0xab, 0xa8, 0x64, 0xeb, 0x41, 0xe9,
99 };
100 
101 static const uint8_t g_dData1024[] = {
102     0xc5, 0x48, 0x0a, 0x37, 0xf8, 0x5c, 0x52, 0xc6, 0x16, 0x53, 0x1e, 0xab, 0x80, 0x61, 0xe2, 0x61,
103     0x68, 0xb9, 0x96, 0xf3, 0x21, 0x1e, 0x3e, 0x24, 0xbc, 0x41, 0x83, 0x34, 0xda, 0x76, 0xa8, 0xc9,
104     0x29, 0x34, 0x7f, 0x83, 0xd2, 0x92, 0x5c, 0x65, 0x3d, 0x42, 0xd5, 0x77, 0x88, 0xba, 0xdf, 0x72,
105     0x0c, 0x96, 0x4a, 0x92, 0xc3, 0x43, 0x76, 0x2c, 0x38, 0x21, 0x38, 0x33, 0xd0, 0xcc, 0x9b, 0x81,
106     0xc5, 0x87, 0xd7, 0x69, 0x8f, 0x1a, 0xb0, 0x59, 0xef, 0xb8, 0x57, 0x0f, 0x7f, 0xcd, 0x72, 0xfb,
107     0xf0, 0xe0, 0x9a, 0xa9, 0x92, 0x08, 0x58, 0x9a, 0xf1, 0xca, 0xe3, 0x6e, 0x87, 0x88, 0xfd, 0xb4,
108     0x99, 0xec, 0x37, 0xf0, 0x0b, 0x48, 0x9b, 0xf1, 0x85, 0x78, 0x20, 0x69, 0xb5, 0xe6, 0xdd, 0xe6,
109     0x9c, 0x71, 0x1c, 0x17, 0xc6, 0x3d, 0x18, 0x9b, 0xfa, 0x08, 0x7d, 0xe0, 0xd9, 0x05, 0x4c, 0x3d,
110 };
111 
112 static const uint8_t g_nData3072[] = {
113     0xda, 0xa5, 0x05, 0x33, 0x0c, 0x08, 0x77, 0x97, 0xf3, 0x9f, 0x11, 0xab, 0x2c, 0xb3, 0xc0, 0xd7,
114     0xd2, 0x4e, 0x84, 0x62, 0xd8, 0x40, 0x27, 0x4f, 0xb3, 0x3e, 0xa4, 0x61, 0x75, 0xa9, 0x20, 0x1f,
115     0xc4, 0xe2, 0x79, 0xe9, 0xf5, 0xba, 0xcc, 0x49, 0x30, 0x03, 0xf3, 0xd4, 0x1b, 0x81, 0xa2, 0x2e,
116     0xa3, 0x3a, 0x1e, 0xb9, 0x5e, 0xdc, 0xcd, 0x1b, 0xad, 0x64, 0xfb, 0xb6, 0x78, 0x2f, 0xf6, 0x14,
117     0x8d, 0x5f, 0x23, 0xca, 0xbd, 0x81, 0xa5, 0x66, 0xfa, 0x26, 0xc8, 0xe1, 0xa4, 0x16, 0x23, 0x78,
118     0x49, 0x00, 0xc1, 0xe5, 0xa8, 0xa0, 0x2f, 0xf7, 0xac, 0xcc, 0x82, 0x6f, 0xa1, 0x89, 0xd9, 0x2f,
119     0x44, 0x9f, 0x3d, 0x42, 0x81, 0xae, 0x0e, 0xcb, 0x83, 0xaf, 0x4c, 0x7a, 0x82, 0x2c, 0x8e, 0xc6,
120     0x88, 0x18, 0x09, 0xaf, 0x15, 0xd0, 0xe9, 0xfa, 0xb5, 0xc2, 0x67, 0xac, 0x49, 0x96, 0x5b, 0x42,
121     0x99, 0x20, 0x95, 0xb2, 0xf7, 0x26, 0x31, 0x83, 0x8c, 0x22, 0x09, 0xea, 0x63, 0xe4, 0x12, 0x8a,
122     0x42, 0x3a, 0x71, 0xc9, 0xa0, 0xb5, 0xb2, 0x45, 0xe6, 0x0d, 0xda, 0x94, 0xd3, 0x70, 0xcc, 0x7f,
123     0x31, 0xd4, 0x3f, 0xe6, 0xed, 0xf5, 0x43, 0x73, 0xf6, 0x06, 0x7f, 0x13, 0x65, 0x43, 0xd4, 0x35,
124     0xf2, 0xfc, 0x75, 0x3a, 0xfe, 0x8e, 0x14, 0x5e, 0xa1, 0xed, 0xd1, 0xd2, 0x96, 0x88, 0xbb, 0xe4,
125     0x23, 0x52, 0x51, 0x02, 0x81, 0xa6, 0xf9, 0xad, 0x81, 0xf4, 0xf0, 0xc0, 0x40, 0xbf, 0x4b, 0x97,
126     0x6f, 0x87, 0x8e, 0xc7, 0xbd, 0xf2, 0x73, 0x2f, 0xe5, 0x3c, 0x62, 0xba, 0x5f, 0xac, 0xb9, 0x83,
127     0x0c, 0x61, 0x74, 0xed, 0x0b, 0xbe, 0xff, 0x2a, 0xcf, 0x6d, 0xff, 0xc4, 0x16, 0x3b, 0xb4, 0x2b,
128     0x57, 0x62, 0x84, 0xa6, 0x6f, 0xfb, 0x32, 0x72, 0xd7, 0x61, 0xc2, 0x1d, 0x54, 0x3b, 0xa2, 0xd2,
129     0x47, 0xe0, 0x96, 0x72, 0xad, 0x28, 0x75, 0xfe, 0x47, 0xdf, 0xf6, 0xcb, 0xaf, 0x56, 0x9d, 0x2b,
130     0x1d, 0x62, 0x26, 0xd8, 0xe5, 0xa6, 0x2a, 0xc9, 0x0a, 0x85, 0x71, 0x63, 0x2e, 0x16, 0x17, 0xf4,
131     0x2f, 0x17, 0x01, 0x8a, 0x3d, 0x2f, 0xd2, 0xb2, 0x80, 0xa1, 0x04, 0x30, 0x38, 0x0c, 0xeb, 0x06,
132     0x2e, 0xc4, 0x4f, 0x80, 0xfb, 0x6b, 0xf7, 0x3c, 0x53, 0x41, 0x5e, 0xdc, 0xc1, 0xfd, 0x1a, 0xda,
133     0x0c, 0x58, 0xa5, 0xb0, 0x99, 0xb2, 0xcd, 0x8f, 0x52, 0x81, 0xd1, 0x82, 0xb2, 0x3b, 0x07, 0xaf,
134     0xd0, 0xd4, 0xd7, 0x92, 0xd3, 0x51, 0x87, 0x13, 0x4c, 0xf7, 0x87, 0xb9, 0x74, 0x42, 0xde, 0x8c,
135     0x65, 0xe2, 0x68, 0xce, 0x62, 0x5d, 0x02, 0xed, 0xa6, 0xff, 0xf2, 0x87, 0x2a, 0x00, 0xae, 0xbe,
136     0xe0, 0xda, 0xe5, 0xfe, 0xb4, 0xb8, 0x0a, 0xfb, 0xfe, 0x89, 0x43, 0xde, 0xd2, 0xb6, 0x4e, 0x81,
137 };
138 
139 static const uint8_t g_dData3072[] = {
140     0xd7, 0xd6, 0xbf, 0xe3, 0x3c, 0xa5, 0xbf, 0x29, 0xc9, 0xdd, 0xe5, 0xdb, 0x4d, 0x2d, 0xc5, 0xd9,
141     0x48, 0x4b, 0x2a, 0x75, 0x49, 0x75, 0x4b, 0x59, 0x6a, 0x61, 0x14, 0x75, 0x01, 0x6a, 0x0b, 0xc4,
142     0x50, 0xe0, 0x21, 0xe9, 0xcc, 0x22, 0xb3, 0x38, 0x2c, 0xa6, 0x3a, 0x35, 0xd1, 0x51, 0x8f, 0x80,
143     0xea, 0xb1, 0x9d, 0x52, 0xf1, 0x4a, 0x97, 0x50, 0x13, 0x43, 0xf5, 0x18, 0x94, 0x5d, 0x04, 0x58,
144     0x15, 0x97, 0x2e, 0x06, 0x1e, 0x3d, 0xb5, 0xc2, 0x8a, 0x7f, 0x6f, 0x1f, 0x10, 0x94, 0xaa, 0x3f,
145     0x3c, 0x11, 0xfb, 0x57, 0x73, 0xb7, 0x6e, 0xa2, 0xd9, 0x7a, 0xa9, 0xe8, 0xf9, 0x56, 0xd3, 0x87,
146     0xcd, 0xfe, 0x44, 0xc3, 0x3a, 0xb1, 0x50, 0xf9, 0xa6, 0xed, 0x8e, 0x5a, 0x01, 0xd7, 0x6a, 0xba,
147     0xa1, 0xee, 0xd8, 0xe0, 0x76, 0x70, 0xde, 0x0a, 0x19, 0x13, 0xe8, 0xb4, 0x33, 0x90, 0xb2, 0x56,
148     0x74, 0x43, 0xae, 0x84, 0x15, 0x67, 0x26, 0xc9, 0xed, 0xb4, 0x4c, 0x85, 0x8e, 0x46, 0xbf, 0xe6,
149     0xac, 0xaa, 0x75, 0x59, 0xcd, 0xc4, 0x90, 0x50, 0x60, 0x62, 0x9c, 0xbc, 0xfe, 0x5e, 0x04, 0x02,
150     0x2c, 0x76, 0x92, 0xfe, 0xad, 0x39, 0xc9, 0x74, 0xd8, 0x12, 0x61, 0xb0, 0x0b, 0xef, 0x81, 0xb6,
151     0x20, 0x41, 0x08, 0x99, 0x4c, 0x61, 0x85, 0xca, 0x45, 0xa0, 0x37, 0xd9, 0xe3, 0xb0, 0xe7, 0x88,
152     0xe3, 0x7c, 0xd0, 0x70, 0xc2, 0x38, 0x22, 0x50, 0xd8, 0xa8, 0xe8, 0xba, 0x76, 0x6e, 0x4b, 0x9d,
153     0x2b, 0x5c, 0x84, 0xf7, 0x0b, 0xce, 0xc9, 0x63, 0x5c, 0x6e, 0x27, 0xa3, 0xac, 0xad, 0x42, 0xfb,
154     0xa6, 0x6c, 0x48, 0xca, 0x10, 0xa2, 0x30, 0x29, 0xc3, 0x00, 0x07, 0x2c, 0xd8, 0x3f, 0xd1, 0x39,
155     0xee, 0x58, 0x9a, 0x8b, 0x54, 0x8b, 0xf0, 0xc4, 0x3a, 0xeb, 0x84, 0xda, 0x14, 0x63, 0x06, 0xe0,
156     0x03, 0xcb, 0x83, 0x75, 0x61, 0xa5, 0x54, 0x24, 0xc3, 0xb6, 0xd8, 0xa8, 0xbc, 0x26, 0x50, 0x74,
157     0x45, 0x9d, 0x7a, 0xea, 0xe2, 0x37, 0xf0, 0xfb, 0x5a, 0xd1, 0xff, 0x3b, 0x97, 0x43, 0xad, 0xf5,
158     0x19, 0xbf, 0x7a, 0x6f, 0xb7, 0x68, 0x50, 0xbb, 0x84, 0xaa, 0x6e, 0xc8, 0xf4, 0xd2, 0x4e, 0xd0,
159     0x5d, 0xd2, 0x19, 0x22, 0xaf, 0xf1, 0xd2, 0x39, 0x93, 0x7d, 0xfa, 0x00, 0x1b, 0x61, 0x02, 0x82,
160     0xcf, 0x13, 0xf1, 0xdf, 0x09, 0x9d, 0x73, 0xeb, 0x3a, 0x3a, 0x8b, 0x01, 0x02, 0xff, 0xf3, 0x1a,
161     0xa3, 0xb3, 0x3a, 0xe8, 0xac, 0xd1, 0x72, 0xe4, 0xac, 0x31, 0x25, 0x17, 0xe1, 0xdb, 0x7d, 0x9b,
162     0x04, 0x2d, 0x58, 0xbf, 0x27, 0xa2, 0x49, 0x4e, 0x3d, 0x84, 0x0b, 0xd6, 0xf0, 0x1d, 0xc9, 0x80,
163     0xfb, 0xf5, 0x80, 0xa5, 0x06, 0x75, 0x97, 0xf2, 0x09, 0x41, 0x4c, 0xe4, 0x10, 0x2b, 0xfc, 0x61,
164 };
165 
166 static const uint8_t g_pubData512[] = {
167     0x30, 0x5c, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05,
168     0x00, 0x03, 0x4b, 0x00, 0x30, 0x48, 0x02, 0x41, 0x00, 0xb6, 0xd8, 0x9b, 0x33, 0x78, 0xa2, 0x63,
169     0x21, 0x84, 0x47, 0xa1, 0x72, 0x3d, 0x73, 0x10, 0xbd, 0xe9, 0x5d, 0x78, 0x44, 0x3d, 0x80, 0x18,
170     0x12, 0x60, 0xed, 0x29, 0x3e, 0xc7, 0x23, 0x0d, 0x3f, 0x02, 0x59, 0x28, 0xe2, 0x8f, 0x83, 0xdf,
171     0x37, 0x4b, 0x77, 0xce, 0x5f, 0xb6, 0xcd, 0x61, 0x72, 0xee, 0x01, 0xe2, 0x37, 0x4d, 0xfd, 0x4f,
172     0x39, 0xcf, 0xbd, 0xff, 0x84, 0x57, 0x44, 0xa5, 0x03, 0x02, 0x03, 0x01, 0x00, 0x01,
173 };
174 
175 static const uint8_t g_pubData768[] = {
176     0x30, 0x7c, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05,
177     0x00, 0x03, 0x6b, 0x00, 0x30, 0x68, 0x02, 0x61, 0x00, 0xc7, 0x06, 0x9c, 0x4b, 0x70, 0x57, 0x9a,
178     0xb9, 0xd0, 0x3a, 0x4b, 0x0b, 0xb8, 0x4b, 0x81, 0x54, 0xe7, 0xba, 0xfa, 0xda, 0xf5, 0x04, 0xf0,
179     0x28, 0x42, 0x6a, 0xb5, 0xb9, 0xf5, 0x1c, 0x5c, 0x2d, 0xc1, 0x11, 0xe6, 0xe6, 0xe6, 0xfc, 0xeb,
180     0x33, 0xa0, 0x45, 0xa9, 0x3b, 0xbf, 0x8f, 0x9d, 0x6e, 0xf5, 0x26, 0xe7, 0xa1, 0xf5, 0x8d, 0x48,
181     0x48, 0x7f, 0x2a, 0xf8, 0x05, 0x43, 0xd5, 0xea, 0x56, 0xf4, 0xcf, 0x95, 0xf7, 0x7e, 0x34, 0x0f,
182     0xee, 0x46, 0x34, 0x05, 0x42, 0x01, 0xce, 0xce, 0xa0, 0xa4, 0x70, 0x61, 0xb1, 0x99, 0x0d, 0xd8,
183     0x3c, 0xbf, 0xf9, 0xb2, 0x2a, 0x32, 0x51, 0x3d, 0xc5, 0x02, 0x03, 0x01, 0x00, 0x01,
184 };
185 
186 static const uint8_t g_pubData1024[] = {
187     0x30, 0x81, 0x9f, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01,
188     0x05, 0x00, 0x03, 0x81, 0x8d, 0x00, 0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xc7, 0x5e, 0x46,
189     0xc3, 0x5b, 0x4f, 0x9f, 0x2f, 0x5a, 0xcf, 0x31, 0x65, 0xcc, 0x71, 0x6e, 0x47, 0x60, 0x17, 0x1d,
190     0x86, 0xb9, 0x8f, 0xe5, 0x4b, 0x85, 0x7a, 0x67, 0xfe, 0xa2, 0x03, 0x05, 0x55, 0x16, 0xab, 0x51,
191     0x20, 0x65, 0xc6, 0x83, 0x24, 0x82, 0x58, 0xda, 0x7a, 0xf9, 0x3f, 0x56, 0xa7, 0xcb, 0x02, 0x8c,
192     0xfc, 0x4c, 0xf0, 0x17, 0xdf, 0x8f, 0x80, 0x6a, 0xf3, 0x35, 0xc7, 0x52, 0xa8, 0x4c, 0xef, 0xba,
193     0x99, 0xc5, 0x2f, 0xc2, 0x9f, 0x78, 0x1d, 0xa5, 0x1a, 0xc0, 0x28, 0x66, 0x42, 0xa9, 0x65, 0x63,
194     0xe8, 0xc1, 0x9a, 0xe4, 0xb6, 0xa6, 0x89, 0xac, 0x59, 0xd0, 0xcf, 0x17, 0xc9, 0x93, 0x6e, 0x57,
195     0xeb, 0xa1, 0xc2, 0xe1, 0x23, 0x9a, 0x74, 0xbd, 0x60, 0xd1, 0x98, 0x9a, 0x41, 0xa5, 0x9d, 0xff,
196     0x71, 0x01, 0x94, 0x97, 0x65, 0x7e, 0xd9, 0xab, 0xa8, 0x64, 0xeb, 0x41, 0xe9, 0x02, 0x03, 0x01,
197     0x00, 0x01,
198 };
199 
200 static const uint8_t g_pubData2048[] = {
201     0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
202     0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01,
203     0x00, 0xc5, 0x35, 0x62, 0x48, 0xc4, 0x92, 0x87, 0x73, 0x0d, 0x42, 0x96, 0xfc, 0x7b, 0x11, 0x05,
204     0x06, 0x0f, 0x8d, 0x66, 0xc1, 0x0e, 0xad, 0x37, 0x44, 0x92, 0x95, 0x2f, 0x6a, 0x55, 0xba, 0xec,
205     0x1d, 0x54, 0x62, 0x0a, 0x4b, 0xd3, 0xc7, 0x05, 0xe4, 0x07, 0x40, 0xd9, 0xb7, 0xc2, 0x12, 0xcb,
206     0x9a, 0x90, 0xad, 0xe3, 0x24, 0xe8, 0x5e, 0xa6, 0xf8, 0xd0, 0x6e, 0xbc, 0xd1, 0x69, 0x7f, 0x6b,
207     0xe4, 0x2b, 0x4e, 0x1a, 0x65, 0xbb, 0x73, 0x88, 0x6b, 0x7c, 0xaf, 0x7e, 0xd0, 0x47, 0x26, 0xeb,
208     0xa5, 0xbe, 0xd6, 0xe8, 0xee, 0x9c, 0xa5, 0x66, 0xa5, 0xc9, 0xd3, 0x25, 0x13, 0xc4, 0x0e, 0x6c,
209     0xab, 0x50, 0xb6, 0x50, 0xc9, 0xce, 0x8f, 0x0a, 0x0b, 0xc6, 0x28, 0x69, 0xe9, 0x83, 0x69, 0xde,
210     0x42, 0x56, 0x79, 0x7f, 0xde, 0x86, 0x24, 0xca, 0xfc, 0xaa, 0xc0, 0xf3, 0xf3, 0x7f, 0x92, 0x8e,
211     0x8a, 0x12, 0x52, 0xfe, 0x50, 0xb1, 0x5e, 0x8c, 0x01, 0xce, 0xfc, 0x7e, 0xf2, 0x4f, 0x5f, 0x03,
212     0xfe, 0xa7, 0xcd, 0xa1, 0xfc, 0x94, 0x52, 0x00, 0x8b, 0x9b, 0x7f, 0x09, 0xab, 0xa8, 0xa4, 0xf5,
213     0xb4, 0xa5, 0xaa, 0xfc, 0x72, 0xeb, 0x17, 0x40, 0xa9, 0xee, 0xbe, 0x8f, 0xc2, 0xd1, 0x80, 0xc2,
214     0x0d, 0x44, 0xa9, 0x59, 0x44, 0x59, 0x81, 0x3b, 0x5d, 0x4a, 0xde, 0xfb, 0xae, 0x24, 0xfc, 0xa3,
215     0xd9, 0xbc, 0x57, 0x55, 0xc2, 0x26, 0xbc, 0x19, 0xa7, 0x9a, 0xc5, 0x59, 0xa3, 0xee, 0x5a, 0xef,
216     0x41, 0x80, 0x7d, 0xf8, 0x5e, 0xc1, 0x1d, 0x32, 0x38, 0x41, 0x5b, 0xb6, 0x92, 0xb8, 0xb7, 0x03,
217     0x0d, 0x3e, 0x59, 0x0f, 0x1c, 0xb3, 0xe1, 0x2a, 0x95, 0x1a, 0x3b, 0x50, 0x4f, 0xc4, 0x1d, 0xcf,
218     0x73, 0x7c, 0x14, 0xca, 0xe3, 0x0b, 0xa7, 0xc7, 0x1a, 0x41, 0x4a, 0xee, 0xbe, 0x1f, 0x43, 0xdd,
219     0xf9, 0x02, 0x03, 0x01, 0x00, 0x01,
220 };
221 
222 static const uint8_t g_pubData3072[] = {
223     0x30, 0x82, 0x01, 0xa2, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
224     0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x8f, 0x00, 0x30, 0x82, 0x01, 0x8a, 0x02, 0x82, 0x01, 0x81,
225     0x00, 0xda, 0xa5, 0x05, 0x33, 0x0c, 0x08, 0x77, 0x97, 0xf3, 0x9f, 0x11, 0xab, 0x2c, 0xb3, 0xc0,
226     0xd7, 0xd2, 0x4e, 0x84, 0x62, 0xd8, 0x40, 0x27, 0x4f, 0xb3, 0x3e, 0xa4, 0x61, 0x75, 0xa9, 0x20,
227     0x1f, 0xc4, 0xe2, 0x79, 0xe9, 0xf5, 0xba, 0xcc, 0x49, 0x30, 0x03, 0xf3, 0xd4, 0x1b, 0x81, 0xa2,
228     0x2e, 0xa3, 0x3a, 0x1e, 0xb9, 0x5e, 0xdc, 0xcd, 0x1b, 0xad, 0x64, 0xfb, 0xb6, 0x78, 0x2f, 0xf6,
229     0x14, 0x8d, 0x5f, 0x23, 0xca, 0xbd, 0x81, 0xa5, 0x66, 0xfa, 0x26, 0xc8, 0xe1, 0xa4, 0x16, 0x23,
230     0x78, 0x49, 0x00, 0xc1, 0xe5, 0xa8, 0xa0, 0x2f, 0xf7, 0xac, 0xcc, 0x82, 0x6f, 0xa1, 0x89, 0xd9,
231     0x2f, 0x44, 0x9f, 0x3d, 0x42, 0x81, 0xae, 0x0e, 0xcb, 0x83, 0xaf, 0x4c, 0x7a, 0x82, 0x2c, 0x8e,
232     0xc6, 0x88, 0x18, 0x09, 0xaf, 0x15, 0xd0, 0xe9, 0xfa, 0xb5, 0xc2, 0x67, 0xac, 0x49, 0x96, 0x5b,
233     0x42, 0x99, 0x20, 0x95, 0xb2, 0xf7, 0x26, 0x31, 0x83, 0x8c, 0x22, 0x09, 0xea, 0x63, 0xe4, 0x12,
234     0x8a, 0x42, 0x3a, 0x71, 0xc9, 0xa0, 0xb5, 0xb2, 0x45, 0xe6, 0x0d, 0xda, 0x94, 0xd3, 0x70, 0xcc,
235     0x7f, 0x31, 0xd4, 0x3f, 0xe6, 0xed, 0xf5, 0x43, 0x73, 0xf6, 0x06, 0x7f, 0x13, 0x65, 0x43, 0xd4,
236     0x35, 0xf2, 0xfc, 0x75, 0x3a, 0xfe, 0x8e, 0x14, 0x5e, 0xa1, 0xed, 0xd1, 0xd2, 0x96, 0x88, 0xbb,
237     0xe4, 0x23, 0x52, 0x51, 0x02, 0x81, 0xa6, 0xf9, 0xad, 0x81, 0xf4, 0xf0, 0xc0, 0x40, 0xbf, 0x4b,
238     0x97, 0x6f, 0x87, 0x8e, 0xc7, 0xbd, 0xf2, 0x73, 0x2f, 0xe5, 0x3c, 0x62, 0xba, 0x5f, 0xac, 0xb9,
239     0x83, 0x0c, 0x61, 0x74, 0xed, 0x0b, 0xbe, 0xff, 0x2a, 0xcf, 0x6d, 0xff, 0xc4, 0x16, 0x3b, 0xb4,
240     0x2b, 0x57, 0x62, 0x84, 0xa6, 0x6f, 0xfb, 0x32, 0x72, 0xd7, 0x61, 0xc2, 0x1d, 0x54, 0x3b, 0xa2,
241     0xd2, 0x47, 0xe0, 0x96, 0x72, 0xad, 0x28, 0x75, 0xfe, 0x47, 0xdf, 0xf6, 0xcb, 0xaf, 0x56, 0x9d,
242     0x2b, 0x1d, 0x62, 0x26, 0xd8, 0xe5, 0xa6, 0x2a, 0xc9, 0x0a, 0x85, 0x71, 0x63, 0x2e, 0x16, 0x17,
243     0xf4, 0x2f, 0x17, 0x01, 0x8a, 0x3d, 0x2f, 0xd2, 0xb2, 0x80, 0xa1, 0x04, 0x30, 0x38, 0x0c, 0xeb,
244     0x06, 0x2e, 0xc4, 0x4f, 0x80, 0xfb, 0x6b, 0xf7, 0x3c, 0x53, 0x41, 0x5e, 0xdc, 0xc1, 0xfd, 0x1a,
245     0xda, 0x0c, 0x58, 0xa5, 0xb0, 0x99, 0xb2, 0xcd, 0x8f, 0x52, 0x81, 0xd1, 0x82, 0xb2, 0x3b, 0x07,
246     0xaf, 0xd0, 0xd4, 0xd7, 0x92, 0xd3, 0x51, 0x87, 0x13, 0x4c, 0xf7, 0x87, 0xb9, 0x74, 0x42, 0xde,
247     0x8c, 0x65, 0xe2, 0x68, 0xce, 0x62, 0x5d, 0x02, 0xed, 0xa6, 0xff, 0xf2, 0x87, 0x2a, 0x00, 0xae,
248     0xbe, 0xe0, 0xda, 0xe5, 0xfe, 0xb4, 0xb8, 0x0a, 0xfb, 0xfe, 0x89, 0x43, 0xde, 0xd2, 0xb6, 0x4e,
249     0x81, 0x02, 0x03, 0x01, 0x00, 0x01,
250 };
251 
252 static const uint8_t g_pubData4096[] = {
253     0x30, 0x82, 0x02, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
254     0x01, 0x05, 0x00, 0x03, 0x82, 0x02, 0x0f, 0x00, 0x30, 0x82, 0x02, 0x0a, 0x02, 0x82, 0x02, 0x01,
255     0x00, 0xcd, 0x1f, 0x40, 0xcd, 0x37, 0x56, 0x2f, 0x78, 0xbb, 0x27, 0x1e, 0xba, 0x66, 0xba, 0x84,
256     0xc6, 0xdb, 0xa0, 0x72, 0xf3, 0x1b, 0x53, 0x8c, 0x46, 0x99, 0x65, 0x0d, 0xf7, 0xb4, 0xae, 0x19,
257     0x46, 0x1e, 0x05, 0xb0, 0xbc, 0xe1, 0x84, 0x9b, 0x44, 0xc5, 0x06, 0x18, 0xef, 0x68, 0x4b, 0x80,
258     0xf4, 0xfc, 0x00, 0x79, 0x8e, 0x21, 0x5e, 0x8f, 0x26, 0x65, 0x69, 0x09, 0x31, 0x4b, 0xa0, 0x95,
259     0x37, 0x53, 0xa2, 0xf5, 0x52, 0x78, 0xb5, 0x3c, 0xec, 0x58, 0x25, 0x1f, 0x23, 0x99, 0x89, 0xc1,
260     0x46, 0x29, 0x65, 0xbb, 0xbe, 0x59, 0x4c, 0xe4, 0x6f, 0xfc, 0xeb, 0x53, 0xe5, 0x33, 0x6e, 0x9a,
261     0x14, 0x57, 0x2a, 0x39, 0xc5, 0xec, 0x4e, 0xc3, 0x3e, 0xcf, 0x76, 0xa3, 0xe9, 0xf8, 0xe3, 0x8a,
262     0x40, 0x1b, 0x3d, 0x07, 0x0e, 0xe4, 0x8e, 0xc7, 0x03, 0xbe, 0xf0, 0x3b, 0xb1, 0x25, 0x4d, 0x20,
263     0x07, 0x9d, 0x2a, 0x18, 0x92, 0x4b, 0x62, 0x34, 0x73, 0xbc, 0x60, 0x3c, 0x18, 0xa2, 0xf8, 0x23,
264     0x3f, 0x43, 0xa5, 0xd8, 0x0c, 0x3f, 0x36, 0xd3, 0x4a, 0x83, 0xe8, 0x93, 0xce, 0x55, 0x6b, 0x31,
265     0xeb, 0x8e, 0x8d, 0xc0, 0x01, 0x96, 0xee, 0x4c, 0x15, 0xf1, 0x21, 0x5b, 0x34, 0xe9, 0x42, 0x1a,
266     0x4a, 0x7b, 0x6f, 0x58, 0x0b, 0x44, 0x4b, 0xc6, 0x9e, 0x15, 0x1c, 0xb9, 0x49, 0x97, 0x99, 0xfc,
267     0x4b, 0xac, 0x9e, 0xc8, 0xfe, 0x97, 0xf7, 0x56, 0x62, 0x7e, 0x8f, 0x0e, 0xd2, 0x8a, 0xc3, 0x65,
268     0x72, 0xe8, 0xcd, 0xb0, 0xbb, 0x21, 0x95, 0xb5, 0x4a, 0x6e, 0x57, 0x13, 0xf9, 0x68, 0x9f, 0xab,
269     0x53, 0xe8, 0xab, 0x10, 0x36, 0x6f, 0x0f, 0x53, 0x53, 0x0b, 0xcd, 0x9b, 0x16, 0x7f, 0x33, 0xfa,
270     0x45, 0x2d, 0x52, 0x4d, 0x67, 0x5d, 0x4e, 0xcd, 0x67, 0xef, 0x32, 0x09, 0x09, 0xe6, 0x26, 0x37,
271     0x63, 0x4e, 0x43, 0x4e, 0x70, 0xc1, 0xc8, 0xc7, 0xf1, 0x98, 0x81, 0xa3, 0x94, 0xa3, 0x3f, 0xe5,
272     0x40, 0x00, 0x26, 0xf9, 0xef, 0x37, 0x57, 0xdc, 0xf4, 0x14, 0x52, 0x8e, 0x24, 0xf2, 0x80, 0xf7,
273     0x09, 0x94, 0x29, 0x04, 0xc0, 0x93, 0xdc, 0xc4, 0xfb, 0x67, 0xa3, 0x93, 0x48, 0xfe, 0x3e, 0x50,
274     0x3e, 0x40, 0xbf, 0xa5, 0xfb, 0x73, 0xf7, 0x72, 0xad, 0x1e, 0x79, 0x95, 0x3d, 0x52, 0x06, 0x6c,
275     0xc1, 0xfa, 0x63, 0x92, 0xcd, 0xfc, 0xc8, 0x61, 0x9f, 0x8d, 0xc1, 0xc3, 0xce, 0x5d, 0x88, 0xcd,
276     0xf0, 0xce, 0x82, 0xb4, 0x2d, 0x17, 0x01, 0x03, 0x74, 0xb1, 0x4c, 0x7c, 0xeb, 0x53, 0xd6, 0x2a,
277     0x4c, 0x99, 0xb1, 0x17, 0x89, 0xb6, 0x50, 0x37, 0x51, 0xb4, 0xea, 0x54, 0x4f, 0x34, 0x5c, 0xc2,
278     0xa6, 0xe7, 0x15, 0x6c, 0x35, 0xa4, 0x18, 0x76, 0x44, 0x52, 0xda, 0x66, 0x0c, 0x18, 0x49, 0x2f,
279     0x7e, 0x54, 0x59, 0xfa, 0x9c, 0xbb, 0xc3, 0xf4, 0x57, 0x59, 0x53, 0x90, 0xca, 0x73, 0x62, 0xc6,
280     0xbd, 0xd4, 0x37, 0x0f, 0x6b, 0xb8, 0x6f, 0xbf, 0x24, 0xd4, 0xef, 0xde, 0x98, 0x9c, 0x05, 0x30,
281     0xc5, 0xa6, 0xb9, 0x39, 0xe8, 0x5b, 0xc5, 0x30, 0xb8, 0x18, 0xb0, 0x86, 0x33, 0x1f, 0x36, 0x64,
282     0xe7, 0x18, 0xd5, 0x05, 0xf5, 0x7d, 0x23, 0xe7, 0xdd, 0x96, 0x1a, 0x82, 0xf4, 0xfd, 0x90, 0x86,
283     0x69, 0xb5, 0x4b, 0x7b, 0xec, 0x4d, 0x1a, 0x78, 0xad, 0x6f, 0x55, 0x69, 0xc7, 0x8d, 0x69, 0x00,
284     0x8b, 0x56, 0x8e, 0x4c, 0xef, 0x1d, 0xe3, 0xa8, 0xbd, 0xa8, 0x93, 0xfc, 0xc8, 0xc9, 0x1f, 0x4c,
285     0x0c, 0x64, 0xc4, 0x42, 0x15, 0xdc, 0xfd, 0x57, 0x44, 0xe6, 0xf8, 0x83, 0xc5, 0xb5, 0x97, 0x2a,
286     0xd1, 0x0d, 0x30, 0xb4, 0xef, 0xac, 0x7f, 0xc8, 0xcf, 0x90, 0x83, 0x89, 0xb3, 0x2c, 0xc7, 0xb0,
287     0x5b, 0x02, 0x03, 0x01, 0x00, 0x01,
288 };
289 
290 static struct HksParam g_importRsaKeyParams[] = {
291     { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA },
292     { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
293     { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 },
294     { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS },
295     { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
296     { .tag = HKS_TAG_IMPORT_KEY_TYPE, .uint32Param = HKS_KEY_TYPE_PRIVATE_KEY },
297 };
298 
299 static struct HksParam g_importRsaKeyAnotherParams[] = {
300     { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA },
301     { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
302     { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 },
303     { .tag = HKS_TAG_IMPORT_KEY_TYPE, .uint32Param = HKS_KEY_TYPE_PRIVATE_KEY },
304 };
305 
306 static struct HksParam g_initOp1Params[] = {
307     { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA },
308     { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN },
309     { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 },
310     { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS },
311     { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
312 };
313 
314 static struct HksParam g_initOp2Params[] = {
315     { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA },
316     { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY },
317     { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 },
318     { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS },
319     { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
320 };
321 
322 static struct HksParam g_updateParams[] = {
323     { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA },
324 };
325 
326 static struct HksParam g_finishParams[] = {
327     { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA },
328 };
329 
CopyKey(const struct HksBlob * key,struct HksBlob * outKey)330 static int32_t CopyKey(const struct HksBlob *key, struct HksBlob *outKey)
331 {
332     uint8_t *outData = (uint8_t *)HksMalloc(key->size);
333     if (outData == nullptr) {
334         return HKS_ERROR_MALLOC_FAIL;
335     }
336 
337     (void)memcpy_s(outData, key->size, key->data, key->size);
338     outKey->data = outData;
339     outKey->size = key->size;
340 
341     return HKS_SUCCESS;
342 }
343 
ConstructPubKey(uint32_t keySize,struct HksBlob * outKey)344 static int32_t ConstructPubKey(uint32_t keySize, struct HksBlob *outKey)
345 {
346     struct HksBlob pubDataBlob = { 0, nullptr };
347     switch (keySize) {
348         case HKS_RSA_KEY_SIZE_512:
349             pubDataBlob.size = sizeof(g_pubData512);
350             pubDataBlob.data = (uint8_t *)g_pubData512;
351             break;
352         case HKS_RSA_KEY_SIZE_768:
353             pubDataBlob.size = sizeof(g_pubData768);
354             pubDataBlob.data = (uint8_t *)g_pubData768;
355             break;
356         case HKS_RSA_KEY_SIZE_1024:
357             pubDataBlob.size = sizeof(g_pubData1024);
358             pubDataBlob.data = (uint8_t *)g_pubData1024;
359             break;
360         case HKS_RSA_KEY_SIZE_2048:
361             pubDataBlob.size = sizeof(g_pubData2048);
362             pubDataBlob.data = (uint8_t *)g_pubData2048;
363             break;
364         case HKS_RSA_KEY_SIZE_3072:
365             pubDataBlob.size = sizeof(g_pubData3072);
366             pubDataBlob.data = (uint8_t *)g_pubData3072;
367             break;
368         case HKS_RSA_KEY_SIZE_4096:
369             pubDataBlob.size = sizeof(g_pubData4096);
370             pubDataBlob.data = (uint8_t *)g_pubData4096;
371             break;
372         default:
373             return HKS_ERROR_INVALID_KEY_SIZE;
374     }
375     return CopyKey(&pubDataBlob, outKey);
376 }
377 
ConstructKey(const struct HksBlob * nDataBlob,const struct HksBlob * dDataBlob,uint32_t keySize,struct HksBlob * outKey,bool isPriKey)378 static int32_t ConstructKey(const struct HksBlob *nDataBlob, const struct HksBlob *dDataBlob,
379     uint32_t keySize, struct HksBlob *outKey, bool isPriKey)
380 {
381     struct HksKeyMaterialRsa material;
382     material.keyAlg = HKS_ALG_RSA;
383     material.keySize = keySize;
384     material.nSize = nDataBlob->size;
385     material.eSize = isPriKey ? 0 : sizeof(g_eData);
386     material.dSize = dDataBlob->size;
387 
388     uint32_t sizeTest = sizeof(material) + material.nSize + material.eSize + material.dSize;
389     uint8_t *data = (uint8_t *)HksMalloc(sizeTest);
390     if (data == nullptr) {
391         return HKS_ERROR_MALLOC_FAIL;
392     }
393 
394     // copy struct material
395     if (memcpy_s(data, sizeTest, &material, sizeof(material)) != EOK) {
396         HKS_FREE(data);
397         return HKS_ERROR_BAD_STATE;
398     }
399 
400     uint32_t offset = sizeof(material);
401     // copy nData
402     if (memcpy_s(data + offset, sizeTest - offset, nDataBlob->data, nDataBlob->size) != EOK) {
403         HKS_FREE(data);
404         return HKS_ERROR_BAD_STATE;
405     }
406 
407     offset += material.nSize;
408     // copy eData
409     if (!isPriKey) {
410         if (memcpy_s(data + offset, sizeTest - offset, &g_eData, sizeof(g_eData)) != EOK) {
411             HKS_FREE(data);
412             return HKS_ERROR_BAD_STATE;
413         }
414         offset += material.eSize;
415     }
416 
417     // copy dData
418     if (memcpy_s(data + offset, sizeTest - offset, dDataBlob->data, dDataBlob->size) != EOK) {
419         HKS_FREE(data);
420         return HKS_ERROR_BAD_STATE;
421     }
422 
423     outKey->data = data;
424     outKey->size = sizeTest;
425     return HKS_SUCCESS;
426 }
427 
ConstructImportedKey(uint32_t keySize,uint32_t importType,struct HksBlob * outKey)428 static int32_t ConstructImportedKey(uint32_t keySize, uint32_t importType, struct HksBlob *outKey)
429 {
430     if (importType == HKS_KEY_TYPE_PUBLIC_KEY) {
431         return ConstructPubKey(keySize, outKey);
432     }
433 
434     struct HksBlob nDataBlob = { 0, nullptr };
435     struct HksBlob dDataBlob = { 0, nullptr };
436 
437     bool isPriKey = (importType == HKS_KEY_TYPE_PRIVATE_KEY) ? true : false;
438     switch (keySize) {
439         case HKS_RSA_KEY_SIZE_512:
440             nDataBlob.size = sizeof(g_nData512);
441             nDataBlob.data = (uint8_t *)g_nData512;
442             dDataBlob.size = sizeof(g_dData512);
443             dDataBlob.data = (uint8_t *)g_dData512;
444             break;
445         case HKS_RSA_KEY_SIZE_768:
446             nDataBlob.size = sizeof(g_nData768);
447             nDataBlob.data = (uint8_t *)g_nData768;
448             dDataBlob.size = sizeof(g_dData768);
449             dDataBlob.data = (uint8_t *)g_dData768;
450             break;
451         case HKS_RSA_KEY_SIZE_1024:
452             nDataBlob.size = sizeof(g_nData1024);
453             nDataBlob.data = (uint8_t *)g_nData1024;
454             dDataBlob.size = sizeof(g_dData1024);
455             dDataBlob.data = (uint8_t *)g_dData1024;
456             break;
457         case HKS_RSA_KEY_SIZE_2048:
458             nDataBlob.size = sizeof(g_nData2048);
459             nDataBlob.data = (uint8_t *)g_nData2048;
460             dDataBlob.size = sizeof(g_dData2048);
461             dDataBlob.data = (uint8_t *)g_dData2048;
462             break;
463         case HKS_RSA_KEY_SIZE_3072:
464             nDataBlob.size = sizeof(g_nData3072);
465             nDataBlob.data = (uint8_t *)g_nData3072;
466             dDataBlob.size = sizeof(g_dData3072);
467             dDataBlob.data = (uint8_t *)g_dData3072;
468             break;
469         case HKS_RSA_KEY_SIZE_4096:
470             nDataBlob.size = sizeof(g_nData4096);
471             nDataBlob.data = (uint8_t *)g_nData4096;
472             dDataBlob.size = sizeof(g_dData4096);
473             dDataBlob.data = (uint8_t *)g_dData4096;
474             break;
475         default:
476             return HKS_ERROR_INVALID_KEY_SIZE;
477     }
478 
479     return ConstructKey(&nDataBlob, &dDataBlob, keySize, outKey, isPriKey);
480 }
481 
ModifyImportParams(uint32_t purpose,uint32_t keySize,uint32_t padding,uint32_t digest,uint32_t importType)482 static void ModifyImportParams(uint32_t purpose, uint32_t keySize, uint32_t padding,
483     uint32_t digest, uint32_t importType)
484 {
485     g_importRsaKeyParams[TAG_PURPOSE_ID].uint32Param = purpose;
486     g_importRsaKeyParams[TAG_KEY_SIZE_ID].uint32Param = keySize;
487     g_importRsaKeyParams[TAG_PADDING_ID].uint32Param = padding;
488     g_importRsaKeyParams[TAG_DIGEST_ID].uint32Param = digest;
489     g_importRsaKeyParams[TAG_IMPOT_TYPE_ID].uint32Param = importType;
490 }
491 
ModifyImportAnotherParams(uint32_t purpose,uint32_t keySize,uint32_t importType)492 static void ModifyImportAnotherParams(uint32_t purpose, uint32_t keySize, uint32_t importType)
493 {
494     g_importRsaKeyAnotherParams[TAG_PURPOSE_ID].uint32Param = purpose;
495     g_importRsaKeyAnotherParams[TAG_KEY_SIZE_ID].uint32Param = keySize;
496     g_importRsaKeyAnotherParams[TAG_IMPORT_NEW_INDEX].uint32Param = importType;
497 }
498 
ModifyinitOp1Params(uint32_t purpose,uint32_t keySize,uint32_t padding,uint32_t digest)499 static void ModifyinitOp1Params(uint32_t purpose, uint32_t keySize, uint32_t padding, uint32_t digest)
500 {
501     g_initOp1Params[TAG_PURPOSE_ID].uint32Param = purpose;
502     g_initOp1Params[TAG_KEY_SIZE_ID].uint32Param = keySize;
503     g_initOp1Params[TAG_PADDING_ID].uint32Param = padding;
504     g_initOp1Params[TAG_DIGEST_ID].uint32Param = digest;
505 }
506 
ModifyinitOp2Params(uint32_t purpose,uint32_t keySize,uint32_t padding,uint32_t digest)507 static void ModifyinitOp2Params(uint32_t purpose, uint32_t keySize, uint32_t padding, uint32_t digest)
508 {
509     g_initOp2Params[TAG_PURPOSE_ID].uint32Param = purpose;
510     g_initOp2Params[TAG_KEY_SIZE_ID].uint32Param = keySize;
511     g_initOp2Params[TAG_PADDING_ID].uint32Param = padding;
512     g_initOp2Params[TAG_DIGEST_ID].uint32Param = digest;
513 }
514 
ImportKey(const struct HksBlob * keyAlias,const struct HksParam * params,uint32_t paramCount)515 static int32_t ImportKey(const struct HksBlob *keyAlias, const struct HksParam *params, uint32_t paramCount)
516 {
517     struct HksParamSet *paramSet = nullptr;
518     int32_t ret = InitParamSet(&paramSet, params, paramCount);
519     if (ret != HKS_SUCCESS) {
520         return ret;
521     }
522 
523     struct HksBlob key = { 0, nullptr };
524 
525     // The caller guarantees that the access will not cross the border
526     ret = ConstructImportedKey(params[TAG_KEY_SIZE_ID].uint32Param, params[TAG_IMPOT_TYPE_ID].uint32Param, &key);
527     if (ret != HKS_SUCCESS) {
528         HksFreeParamSet(&paramSet);
529         return ret;
530     }
531     ret = HksImportKeyForDe(keyAlias, paramSet, &key);
532     HKS_FREE(key.data);
533     HksFreeParamSet(&paramSet);
534     return ret;
535 }
536 
ImportKeyNew(const struct HksBlob * keyAlias,const struct HksParam * params,uint32_t paramCount)537 static int32_t ImportKeyNew(const struct HksBlob *keyAlias, const struct HksParam *params, uint32_t paramCount)
538 {
539     struct HksParamSet *paramSet = nullptr;
540     int32_t ret = InitParamSet(&paramSet, params, paramCount);
541     if (ret != HKS_SUCCESS) {
542         return ret;
543     }
544 
545     struct HksBlob key = { 0, nullptr };
546 
547     // The caller guarantees that the access will not cross the border
548     ret = ConstructImportedKey(params[TAG_KEY_SIZE_ID].uint32Param, params[TAG_KEY_SIZE_NEW_INDEX].uint32Param, &key);
549     if (ret != HKS_SUCCESS) {
550         HksFreeParamSet(&paramSet);
551         return ret;
552     }
553     ret = HksImportKeyForDe(keyAlias, paramSet, &key);
554     HKS_FREE(key.data);
555     HksFreeParamSet(&paramSet);
556     return ret;
557 }
558 
ConstructPurpose(uint32_t inputPurpose,uint32_t & outPurposePri,uint32_t & outPurposePair,uint32_t & outPurposePub)559 static int32_t ConstructPurpose(uint32_t inputPurpose, uint32_t &outPurposePri, uint32_t &outPurposePair,
560     uint32_t &outPurposePub)
561 {
562     outPurposePri = inputPurpose;
563     outPurposePair = inputPurpose;
564     outPurposePub = inputPurpose;
565     if (inputPurpose == (HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY)) {
566         outPurposePri = HKS_KEY_PURPOSE_SIGN;
567         outPurposePair = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY;
568         outPurposePub = HKS_KEY_PURPOSE_VERIFY;
569     } else if (inputPurpose == (HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT)) {
570         outPurposePri = HKS_KEY_PURPOSE_DECRYPT;
571         outPurposePair = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT;
572         outPurposePub = HKS_KEY_PURPOSE_ENCRYPT;
573     } else {
574         return HKS_ERROR_NOT_SUPPORTED;
575     }
576     return HKS_SUCCESS;
577 }
578 
ConstructOpPurpose(uint32_t inputPurpose,uint32_t & outOp1Purpose,uint32_t & outOp2Purpose)579 static int32_t ConstructOpPurpose(uint32_t inputPurpose, uint32_t &outOp1Purpose, uint32_t &outOp2Purpose)
580 {
581     outOp1Purpose = HKS_KEY_PURPOSE_SIGN;
582     outOp2Purpose = HKS_KEY_PURPOSE_VERIFY;
583     if (inputPurpose == (HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY)) {
584         outOp1Purpose = HKS_KEY_PURPOSE_SIGN;
585         outOp2Purpose = HKS_KEY_PURPOSE_VERIFY;
586     } else if (inputPurpose == (HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT)) {
587         outOp1Purpose = HKS_KEY_PURPOSE_ENCRYPT;
588         outOp2Purpose = HKS_KEY_PURPOSE_DECRYPT;
589     } else {
590         return HKS_ERROR_NOT_SUPPORTED;
591     }
592     return HKS_SUCCESS;
593 }
594 
ConstructParamSets(const struct HksParam * initParams,uint32_t initParamCount,struct HksParamSet ** initParamSetTest,struct HksParamSet ** updateParamSet,struct HksParamSet ** finishParamSet)595 static int32_t ConstructParamSets(const struct HksParam *initParams, uint32_t initParamCount,
596     struct HksParamSet **initParamSetTest, struct HksParamSet **updateParamSet, struct HksParamSet **finishParamSet)
597 {
598     int32_t ret = InitParamSet(initParamSetTest, initParams, initParamCount);
599     if (ret != HKS_SUCCESS) {
600         return ret;
601     }
602 
603     ret = InitParamSet(updateParamSet, g_updateParams, sizeof(g_updateParams) / sizeof(struct HksParam));
604     if (ret != HKS_SUCCESS) {
605         HksFreeParamSet(initParamSetTest);
606         return ret;
607     }
608 
609     ret = InitParamSet(finishParamSet, g_finishParams, sizeof(g_finishParams) / sizeof(struct HksParam));
610     if (ret != HKS_SUCCESS) {
611         HksFreeParamSet(initParamSetTest);
612         HksFreeParamSet(updateParamSet);
613     }
614     return ret;
615 }
616 
DoOpDetail(const struct HksBlob * keyAlias,const struct HksParam * initParams,uint32_t initParamCount,const struct HksBlob * inData,struct HksBlob * outData)617 static int32_t DoOpDetail(const struct HksBlob *keyAlias, const struct HksParam *initParams, uint32_t initParamCount,
618     const struct HksBlob *inData, struct HksBlob *outData)
619 {
620     struct HksParamSet *initParamSetTest = nullptr;
621     struct HksParamSet *updateParamSet = nullptr;
622     struct HksParamSet *finishParamSet = nullptr;
623     int32_t ret = ConstructParamSets(initParams, initParamCount, &initParamSetTest, &updateParamSet, &finishParamSet);
624     if (ret != HKS_SUCCESS) {
625         return ret;
626     }
627 
628     do {
629         uint64_t handleValue = 0;
630         struct HksBlob handle = { sizeof(uint64_t), (uint8_t *)&handleValue };
631         ret = HksInitForDe(keyAlias, initParamSetTest, &handle, nullptr);
632         if (ret != HKS_SUCCESS) {
633             break;
634         }
635 
636         uint8_t tempBuf[LENGTH_TO_BE_OPERATED] = {0};
637         struct HksBlob tmpBlob = { LENGTH_TO_BE_OPERATED, tempBuf };
638         struct HksBlob tmpBlob2 = { 0, nullptr };
639 
640         ret = HksUpdateForDe(&handle, updateParamSet, inData, &tmpBlob);
641         if (ret != HKS_SUCCESS) {
642             break;
643         }
644 
645         // The caller guarantees that the access will not cross the border
646         if (initParams[TAG_PURPOSE_ID].uint32Param == HKS_KEY_PURPOSE_VERIFY) {
647             ret = HksFinishForDe(&handle, finishParamSet, outData, &tmpBlob2);
648         } else {
649             ret = HksFinishForDe(&handle, finishParamSet, &tmpBlob2, outData);
650         }
651     } while (0);
652 
653     HksFreeParamSet(&initParamSetTest);
654     HksFreeParamSet(&updateParamSet);
655     HksFreeParamSet(&finishParamSet);
656     return ret;
657 }
658 
DoDecrpyt(const struct HksBlob * keyAlias,const struct HksBlob * cipherData,const struct HksBlob * pData)659 static int32_t DoDecrpyt(const struct HksBlob *keyAlias, const struct HksBlob *cipherData, const struct HksBlob *pData)
660 {
661     uint8_t *plainBuf = (uint8_t *)HksMalloc(LENGTH_MAX);
662     if (plainBuf == nullptr) {
663         return HKS_ERROR_MALLOC_FAIL;
664     }
665     struct HksBlob plainData = { LENGTH_MAX, plainBuf };
666 
667     int32_t ret = DoOpDetail(keyAlias, g_initOp2Params, sizeof(g_initOp2Params) / sizeof(struct HksParam),
668         cipherData, &plainData);
669     if (ret != HKS_SUCCESS) {
670         HKS_FREE(plainBuf);
671         return ret;
672     }
673 
674     if (plainData.size == pData->size && memcmp(plainData.data, pData->data, pData->size) == 0) {
675         ret = HKS_SUCCESS;
676     } else {
677         ret = HKS_FAILURE;
678     }
679 
680     HKS_FREE(plainBuf);
681     return ret;
682 }
683 
DoOperation(const struct HksBlob * priKeyAlias,const struct HksBlob * pairKeyAlias)684 static int32_t DoOperation(const struct HksBlob *priKeyAlias, const struct HksBlob *pairKeyAlias)
685 {
686     struct HksBlob keyAliasOp1 = { 0, nullptr };
687     struct HksBlob keyAliasOp2 = { 0, nullptr };
688     if (g_initOp1Params[TAG_PURPOSE_ID].uint32Param == HKS_KEY_PURPOSE_SIGN) {
689         keyAliasOp1 = *priKeyAlias;
690         keyAliasOp2 = *pairKeyAlias;
691     } else {
692         keyAliasOp1 = *pairKeyAlias;
693         keyAliasOp2 = *priKeyAlias;
694     }
695 
696     uint8_t *inDataBuf = (uint8_t *)HksMalloc(LENGTH_TO_BE_OPERATED);
697     if (inDataBuf == nullptr) {
698         return HKS_ERROR_MALLOC_FAIL;
699     }
700 
701     uint8_t *outDataBuf = (uint8_t *)HksMalloc(LENGTH_MAX);
702     if (outDataBuf == nullptr) {
703         HKS_FREE(inDataBuf);
704         return HKS_ERROR_MALLOC_FAIL;
705     }
706 
707     struct HksBlob inData = { LENGTH_TO_BE_OPERATED, inDataBuf };
708     struct HksBlob outData = { LENGTH_MAX, outDataBuf };
709     (void)HksGenerateRandom(nullptr, &inData);
710 
711     int32_t ret;
712     do {
713         /* operation 1: sign or encrypt */
714         ret = DoOpDetail(&keyAliasOp1, g_initOp1Params, sizeof(g_initOp1Params) / sizeof(struct HksParam),
715             &inData, &outData);
716         if (ret != HKS_SUCCESS) {
717             break;
718         }
719 
720         /* operation 2: verify or decrypt */
721         if (g_initOp2Params[TAG_PURPOSE_ID].uint32Param == HKS_KEY_PURPOSE_VERIFY) {
722             ret = DoOpDetail(&keyAliasOp2, g_initOp2Params, sizeof(g_initOp2Params) / sizeof(struct HksParam),
723                 &inData, &outData);
724         } else {
725             ret = DoDecrpyt(&keyAliasOp2, &outData, &inData);
726         }
727     } while (0);
728 
729     HKS_FREE(inDataBuf);
730     HKS_FREE(outDataBuf);
731     return ret;
732 }
733 
RsaImportPlainKeyAnotherTest(uint32_t purpose,uint32_t keySize,uint32_t padding,uint32_t digest)734 static void RsaImportPlainKeyAnotherTest(uint32_t purpose, uint32_t keySize, uint32_t padding, uint32_t digest)
735 {
736     uint32_t purposePri;
737     uint32_t purposePair;
738     uint32_t purposePub;
739     int32_t ret = ConstructPurpose(purpose, purposePri, purposePair, purposePub);
740     EXPECT_EQ(ret, HKS_SUCCESS) << "construct purpose failed";
741 
742     // import rsa private-key
743     uint8_t priAlias[] = "import_rsa_private_key";
744     struct HksBlob priKeyAlias = { sizeof(priAlias), priAlias };
745 
746     ModifyImportAnotherParams(purposePri, keySize, HKS_KEY_TYPE_PRIVATE_KEY);
747     ret = ImportKeyNew(&priKeyAlias, g_importRsaKeyAnotherParams,
748         sizeof(g_importRsaKeyAnotherParams) / sizeof(struct HksParam));
749     EXPECT_EQ(ret, HKS_SUCCESS) << "import pri key failed";
750 
751     // import rsa key-pair
752     uint8_t pairAlias[] = "import_rsa_key_pair";
753     struct HksBlob pairKeyAlias = { sizeof(pairAlias), pairAlias };
754 
755     ModifyImportAnotherParams(purposePair, keySize, HKS_KEY_TYPE_KEY_PAIR);
756     ret = ImportKeyNew(&pairKeyAlias, g_importRsaKeyAnotherParams,
757         sizeof(g_importRsaKeyAnotherParams) / sizeof(struct HksParam));
758 
759     EXPECT_EQ(ret, HKS_SUCCESS) << "import key pair failed";
760 
761     // import rsa pubKey
762     uint8_t pubAlias[] = "import_rsa_public_key";
763     struct HksBlob pubKeyAlias = { sizeof(pubAlias), pubAlias };
764 
765     ModifyImportAnotherParams(purposePub, keySize, HKS_KEY_TYPE_PUBLIC_KEY);
766     ret = ImportKeyNew(&pubKeyAlias, g_importRsaKeyAnotherParams,
767         sizeof(g_importRsaKeyAnotherParams) / sizeof(struct HksParam));
768     EXPECT_EQ(ret, HKS_SUCCESS) << "import key public failed";
769 
770     uint32_t purposeOp1;
771     uint32_t purposeTestOp2;
772     ret = ConstructOpPurpose(purpose, purposeOp1, purposeTestOp2);
773     EXPECT_EQ(ret, HKS_SUCCESS) << "construct operation purpose failed";
774 
775     ModifyinitOp1Params(purposeOp1, keySize, padding, digest);
776     ModifyinitOp2Params(purposeTestOp2, keySize, padding, digest);
777 
778     ret = DoOperation(&priKeyAlias, &pairKeyAlias);
779     EXPECT_EQ(ret, HKS_SUCCESS) << "operation failed";
780     ret = DoOperation(&priKeyAlias, &pubKeyAlias);
781     EXPECT_EQ(ret, HKS_SUCCESS) << "operation 2 failed";
782 
783     // export public key
784     uint8_t pubKeyTest[HKS_RSA_KEY_SIZE_1024] = {0};
785     struct HksBlob publicKey = { HKS_RSA_KEY_SIZE_1024, pubKeyTest };
786     ret = HksExportPublicKeyForDe(&pubKeyAlias, nullptr, &publicKey);
787     EXPECT_EQ(ret, HKS_SUCCESS) << "ExportPublicKey failed.";
788 
789     // delete keys
790     (void)HksDeleteKeyForDe(&priKeyAlias, nullptr);
791     (void)HksDeleteKeyForDe(&pairKeyAlias, nullptr);
792     (void)HksDeleteKeyForDe(&pubKeyAlias, nullptr);
793 }
794 
RsaImportPlainKeyTest(uint32_t purpose,uint32_t keySize,uint32_t padding,uint32_t digest)795 static void RsaImportPlainKeyTest(uint32_t purpose, uint32_t keySize, uint32_t padding, uint32_t digest)
796 {
797     uint32_t purposePri;
798     uint32_t purposePair;
799     uint32_t purposePub;
800     int32_t ret = ConstructPurpose(purpose, purposePri, purposePair, purposePub);
801     EXPECT_EQ(ret, HKS_SUCCESS) << "construct purpose failed";
802 
803     // import rsa private-key
804     uint8_t priAlias[] = "import_rsa_private_key";
805     struct HksBlob priKeyAlias = { sizeof(priAlias), priAlias };
806 
807     ModifyImportParams(purposePri, keySize, padding, digest, HKS_KEY_TYPE_PRIVATE_KEY);
808     ret = ImportKey(&priKeyAlias, g_importRsaKeyParams, sizeof(g_importRsaKeyParams) / sizeof(struct HksParam));
809     EXPECT_EQ(ret, HKS_SUCCESS) << "import pri key failed";
810 
811     // import rsa key-pair
812     uint8_t pairAlias[] = "import_rsa_key_pair";
813     struct HksBlob pairKeyAlias = { sizeof(pairAlias), pairAlias };
814     ModifyImportParams(purposePair, keySize, padding, digest, HKS_KEY_TYPE_KEY_PAIR);
815     ret = ImportKey(&pairKeyAlias, g_importRsaKeyParams, sizeof(g_importRsaKeyParams) / sizeof(struct HksParam));
816     EXPECT_EQ(ret, HKS_SUCCESS) << "import key pair failed";
817 
818     // import rsa pubKey
819     uint8_t pubAlias[] = "import_rsa_public_key";
820     struct HksBlob pubKeyAlias = { sizeof(pubAlias), pubAlias };
821     ModifyImportParams(purposePub, keySize, padding, digest, HKS_KEY_TYPE_PUBLIC_KEY);
822     ret = ImportKey(&pubKeyAlias, g_importRsaKeyParams, sizeof(g_importRsaKeyParams) / sizeof(struct HksParam));
823     EXPECT_EQ(ret, HKS_SUCCESS) << "import key public failed";
824 
825     uint32_t purposeOp1;
826     uint32_t purposeOp2;
827     ret = ConstructOpPurpose(purpose, purposeOp1, purposeOp2);
828     EXPECT_EQ(ret, HKS_SUCCESS) << "construct operation purpose failed";
829 
830     ModifyinitOp1Params(purposeOp1, keySize, padding, digest);
831     ModifyinitOp2Params(purposeOp2, keySize, padding, digest);
832 
833     ret = DoOperation(&priKeyAlias, &pairKeyAlias);
834     EXPECT_EQ(ret, HKS_SUCCESS) << "operation failed";
835     ret = DoOperation(&priKeyAlias, &pubKeyAlias);
836     EXPECT_EQ(ret, HKS_SUCCESS) << "operation 2 failed";
837 
838     // export public key
839     uint8_t pubKey[HKS_RSA_KEY_SIZE_1024] = {0};
840     struct HksBlob publicKey = { HKS_RSA_KEY_SIZE_1024, pubKey };
841     ret = HksExportPublicKeyForDe(&pubKeyAlias, nullptr, &publicKey);
842     EXPECT_EQ(ret, HKS_SUCCESS) << "ExportPublicKey failed.";
843 
844     // delete keys
845     (void)HksDeleteKeyForDe(&priKeyAlias, nullptr);
846     (void)HksDeleteKeyForDe(&pairKeyAlias, nullptr);
847     (void)HksDeleteKeyForDe(&pubKeyAlias, nullptr);
848 }
849 
ImportRsaPlainKeyTest(uint32_t purpose,uint32_t keySize,uint32_t padding,uint32_t digest)850 static void ImportRsaPlainKeyTest(uint32_t purpose, uint32_t keySize, uint32_t padding, uint32_t digest)
851 {
852     return RsaImportPlainKeyTest(purpose, keySize, padding, digest);
853 }
854 
ImportRsaPlainKeyAnotherTest(uint32_t purpose,uint32_t keySize,uint32_t padding,uint32_t digest)855 static void ImportRsaPlainKeyAnotherTest(uint32_t purpose, uint32_t keySize, uint32_t padding, uint32_t digest)
856 {
857     return RsaImportPlainKeyAnotherTest(purpose, keySize, padding, digest);
858 }
859 /**
860  * @tc.name: HksImportRsaTest.HksImportRsaTest001
861  * @tc.desc: import rsa 512-sign/verify-pss-sha256
862  * @tc.type: FUNC normal
863  */
864 HWTEST_F(HksImportRsaTest, HksImportRsaTest001, TestSize.Level0)
865 {
866     ImportRsaPlainKeyTest(HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, HKS_RSA_KEY_SIZE_512,
867         HKS_PADDING_PSS, HKS_DIGEST_SHA256);
868 }
869 
870 /**
871  * @tc.name: HksImportRsaTest.HksImportRsaTest002
872  * @tc.desc: import rsa 768-sign/verify-pss-sha256
873  * @tc.type: FUNC normal
874  */
875 HWTEST_F(HksImportRsaTest, HksImportRsaTest002, TestSize.Level0)
876 {
877     ImportRsaPlainKeyTest(HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, HKS_RSA_KEY_SIZE_768,
878         HKS_PADDING_PSS, HKS_DIGEST_SHA384);
879 }
880 
881 /**
882  * @tc.name: HksImportRsaTest.HksImportRsaTest003
883  * @tc.desc: import rsa 1024-sign/verify-pss-sha256
884  * @tc.type: FUNC normal
885  */
886 HWTEST_F(HksImportRsaTest, HksImportRsaTest003, TestSize.Level0)
887 {
888     ImportRsaPlainKeyTest(HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, HKS_RSA_KEY_SIZE_1024,
889         HKS_PADDING_PSS, HKS_DIGEST_SHA512);
890 }
891 
892 /**
893  * @tc.name: HksImportRsaTest.HksImportRsaTest004
894  * @tc.desc: import rsa 2048-encrypt/decrypt-oaep-sha256
895  * @tc.type: FUNC normal
896  */
897 HWTEST_F(HksImportRsaTest, HksImportRsaTest004, TestSize.Level0)
898 {
899     ImportRsaPlainKeyTest(HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, HKS_RSA_KEY_SIZE_2048,
900         HKS_PADDING_OAEP, HKS_DIGEST_SHA1);
901 }
902 
903 /**
904  * @tc.name: HksImportRsaTest.HksImportRsaTest005
905  * @tc.desc: import rsa 3072-encrypt/decrypt-oape-sha256
906  * @tc.type: FUNC normal
907  */
908 HWTEST_F(HksImportRsaTest, HksImportRsaTest005, TestSize.Level0)
909 {
910     ImportRsaPlainKeyTest(HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, HKS_RSA_KEY_SIZE_3072,
911         HKS_PADDING_OAEP, HKS_DIGEST_SHA256);
912 }
913 
914 /**
915  * @tc.name: HksImportRsaTest.HksImportRsaTest006
916  * @tc.desc: import rsa 4096-encrypt/decrypt-oape-sha256
917  * @tc.type: FUNC normal
918  */
919 HWTEST_F(HksImportRsaTest, HksImportRsaTest006, TestSize.Level0)
920 {
921     ImportRsaPlainKeyTest(HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, HKS_RSA_KEY_SIZE_4096,
922         HKS_PADDING_OAEP, HKS_DIGEST_SHA256);
923 }
924 #endif
925 
926 #ifdef HKS_UNTRUSTED_RUNNING_ENV
927 /**
928  * @tc.name: HksImportRsaTest.HksImportRsaTest007
929  * @tc.desc: import rsa 512-sign/verify-pss-sha256
930  * @tc.type: FUNC normal
931  * @tc.require:issueI611S5
932  */
933 HWTEST_F(HksImportRsaTest, HksImportRsaTest007, TestSize.Level0)
934 {
935     HKS_LOG_E("Enter HksImportRsaTest007");
936     ImportRsaPlainKeyAnotherTest(HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, HKS_RSA_KEY_SIZE_512,
937         HKS_PADDING_PSS, HKS_DIGEST_SHA256);
938 }
939 
940 /**
941  * @tc.name: HksImportRsaTest.HksImportRsaTest008
942  * @tc.desc: import rsa 768-sign/verify-pss-sha256
943  * @tc.type: FUNC normal
944  * @tc.require:issueI611S5
945  */
946 HWTEST_F(HksImportRsaTest, HksImportRsaTest008, TestSize.Level0)
947 {
948     HKS_LOG_E("Enter HksImportRsaTest008");
949     ImportRsaPlainKeyAnotherTest(HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, HKS_RSA_KEY_SIZE_768,
950         HKS_PADDING_PSS, HKS_DIGEST_SHA384);
951 }
952 
953 /**
954  * @tc.name: HksImportRsaTest.HksImportRsaTest009
955  * @tc.desc: import rsa 1024-sign/verify-pss-sha256
956  * @tc.type: FUNC normal
957  * @tc.require:issueI611S5
958  */
959 HWTEST_F(HksImportRsaTest, HksImportRsaTest009, TestSize.Level0)
960 {
961     HKS_LOG_E("Enter HksImportRsaTest009");
962     ImportRsaPlainKeyAnotherTest(HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, HKS_RSA_KEY_SIZE_1024,
963         HKS_PADDING_PSS, HKS_DIGEST_SHA384);
964 }
965 #endif
966 } // namespace Unittest::ImportRsaTest
967