1 /*
2 * Copyright (c) 2025 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 <stdlib.h>
16 #include <stdio.h>
17 #include <pthread.h>
18 #include <string.h>
19 #include <unistd.h>
20
21 #include "crypto_framework_asym_cipher_test.h"
22 #include "crypto_rand.h"
23 #include "blob.h"
24 #include "log.h"
25
26 #include <gtest/gtest.h>
27
28 using namespace testing::ext;
29 namespace Unittest::CryptoFrameworkAsymCipherNapiTest {
30 class OHCryptoFrameworkAsymCipherNapiTest : public testing::Test {
31 public:
SetUpTestCase()32 static void SetUpTestCase() {};
TearDownTestCase()33 static void TearDownTestCase() {};
SetUp()34 void SetUp() {};
TearDown()35 void TearDown() {};
36 };
37
38 class ASYMKEY_ASYM_CIPHER_TEST : public testing::TestWithParam<AsymCipherSpec> {
39 public:
SetUpTestCase()40 static void SetUpTestCase() {}
TearDownTestCase()41 static void TearDownTestCase() {}
42 };
43
44 class ASYMKEY_ASYM_SEG_CIPHER_TEST : public testing::TestWithParam<AsymSegmentCipherSpec> {
45 public:
SetUpTestCase()46 static void SetUpTestCase() {}
TearDownTestCase()47 static void TearDownTestCase() {}
48 };
49
OHTEST_GenAsymKey(const char * algoName)50 static OH_CryptoKeyPair *OHTEST_GenAsymKey(const char *algoName)
51 {
52 OH_CryptoKeyPair *keyPair = nullptr;
53 OH_CryptoAsymKeyGenerator *ctx = nullptr;
54
55 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Create(algoName, &ctx), CRYPTO_SUCCESS);
56 if (strcmp(algoName, "RSA8192") == 0) {
57 Crypto_DataBlob pubKeyBlob = { .data = g_rsa8192pubKey, .len = sizeof(g_rsa8192pubKey) };
58 Crypto_DataBlob priKeyBlob = { .data = g_rsa8192priKey, .len = sizeof(g_rsa8192priKey) };
59 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, &pubKeyBlob, &priKeyBlob, &keyPair), CRYPTO_SUCCESS);
60 } else if (strcmp(algoName, "RSA4096") == 0) {
61 Crypto_DataBlob pubKeyBlob = { .data = g_rsa4096pubKey, .len = sizeof(g_rsa4096pubKey) };
62 Crypto_DataBlob priKeyBlob = { .data = g_rsa4096priKey, .len = sizeof(g_rsa4096priKey) };
63 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, &pubKeyBlob, &priKeyBlob, &keyPair), CRYPTO_SUCCESS);
64 } else if (strcmp(algoName, "RSA3072") == 0) {
65 Crypto_DataBlob pubKeyBlob = { .data = g_rsa3072pubKey, .len = sizeof(g_rsa3072pubKey) };
66 Crypto_DataBlob priKeyBlob = { .data = g_rsa3072priKey, .len = sizeof(g_rsa3072priKey) };
67 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, &pubKeyBlob, &priKeyBlob, &keyPair), CRYPTO_SUCCESS);
68 } else {
69 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair), CRYPTO_SUCCESS);
70 }
71
72 OH_CryptoAsymKeyGenerator_Destroy(ctx);
73 return keyPair;
74 }
75
OHTEST_DoAsymCipher(const char * algoName,OH_CryptoKeyPair * keyPair,Crypto_CipherMode mode,const Crypto_DataBlob * msg,Crypto_DataBlob * cipherData)76 static void OHTEST_DoAsymCipher(const char *algoName, OH_CryptoKeyPair *keyPair,
77 Crypto_CipherMode mode, const Crypto_DataBlob *msg, Crypto_DataBlob *cipherData)
78 {
79 OH_CryptoAsymCipher *ctx = nullptr;
80
81 EXPECT_EQ(OH_CryptoAsymCipher_Create(algoName, &ctx), CRYPTO_SUCCESS);
82 EXPECT_TRUE(ctx != nullptr);
83 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, mode, keyPair), CRYPTO_SUCCESS);
84 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, msg, cipherData), CRYPTO_SUCCESS);
85
86 OH_CryptoAsymCipher_Destroy(ctx);
87 }
88
OHTEST_DoSegmentAsymCipher(const char * algoName,OH_CryptoKeyPair * keyPair,size_t blockSize,Crypto_CipherMode mode,Crypto_DataBlob * msg,Crypto_DataBlob * cipherText)89 static void OHTEST_DoSegmentAsymCipher(const char *algoName, OH_CryptoKeyPair *keyPair,
90 size_t blockSize, Crypto_CipherMode mode, Crypto_DataBlob *msg, Crypto_DataBlob *cipherText)
91 {
92 OH_CryptoAsymCipher *ctx = nullptr;
93 int quotient = msg->len / blockSize;
94 int remainder = msg->len % blockSize;
95 uint8_t *data = msg->data;
96 size_t len = msg->len;
97 Crypto_DataBlob *dataBlob = msg;
98 size_t cipherLen = 0;
99 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
100
101 cipherText->data = (uint8_t *)malloc(cipherText->len);
102 uint8_t *tmp = cipherText->data;
103 EXPECT_TRUE(cipherText->data != nullptr);
104 EXPECT_EQ(OH_CryptoAsymCipher_Create(algoName, &ctx), CRYPTO_SUCCESS);
105 EXPECT_TRUE(ctx != nullptr);
106 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, mode, keyPair), CRYPTO_SUCCESS);
107 for (int i = 0; i < quotient; i++) {
108 dataBlob->len = blockSize;
109 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, dataBlob, &cipherData), CRYPTO_SUCCESS);
110 (void)memcpy(cipherText->data, cipherData.data, cipherData.len);
111 cipherText->data += cipherData.len;
112 cipherLen += cipherData.len;
113 dataBlob->data += blockSize;
114 OH_Crypto_FreeDataBlob(&cipherData);
115 }
116 if (remainder) {
117 dataBlob->len = remainder;
118 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, dataBlob, &cipherData), CRYPTO_SUCCESS);
119 cipherLen += cipherData.len;
120 (void)memcpy(cipherText->data, cipherData.data, cipherData.len);
121 }
122
123 dataBlob->data = data;
124 dataBlob->len = len;
125 cipherText->data = tmp;
126 cipherText->len = cipherLen;
127 OH_CryptoAsymCipher_Destroy(ctx);
128 OH_Crypto_FreeDataBlob(&cipherData);
129 }
130
131 AsymCipherSpec g_asymCipherSpec[] = {
132 /* RSA NoPadding */
133 {"RSA512", "RSA512|NoPadding", OHTEST_RSA_512_KEYSIZE},
134 {"RSA768", "RSA768|NoPadding", OHTEST_RSA_768_KEYSIZE},
135 {"RSA1024", "RSA1024|NoPadding", OHTEST_RSA_1024_KEYSIZE},
136 {"RSA2048", "RSA2048|NoPadding", OHTEST_RSA_2048_KEYSIZE},
137 {"RSA3072", "RSA3072|NoPadding", OHTEST_RSA_3072_KEYSIZE},
138 {"RSA4096", "RSA4096|NoPadding", OHTEST_RSA_4096_KEYSIZE},
139 {"RSA8192", "RSA8192|NoPadding", OHTEST_RSA_8192_KEYSIZE},
140 {"RSA512", "RSA|NoPadding", OHTEST_RSA_512_KEYSIZE},
141 /* RSA PKCS1 */
142 {"RSA512", "RSA512|PKCS1", OHTEST_RSA_512_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
143 {"RSA768", "RSA768|PKCS1", OHTEST_RSA_768_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
144 {"RSA1024", "RSA1024|PKCS1", OHTEST_RSA_1024_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
145 {"RSA2048", "RSA2048|PKCS1", OHTEST_RSA_2048_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
146 {"RSA3072", "RSA3072|PKCS1", OHTEST_RSA_3072_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
147 {"RSA4096", "RSA4096|PKCS1", OHTEST_RSA_4096_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
148 {"RSA8192", "RSA8192|PKCS1", OHTEST_RSA_8192_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
149 {"RSA512", "RSA|PKCS1", OHTEST_RSA_512_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
150 /* RSA512 PKCS1_OAEP */
151 {"RSA512", "RSA512|PKCS1_OAEP|MD5|MGF1_MD5", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
152 {"RSA512", "RSA512|PKCS1_OAEP|MD5|MGF1_SHA1", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
153 {"RSA512", "RSA512|PKCS1_OAEP|MD5|MGF1_SHA224", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
154 {"RSA512", "RSA512|PKCS1_OAEP|MD5|MGF1_SHA256", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
155 {"RSA512", "RSA512|PKCS1_OAEP|SHA1|MGF1_MD5", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
156 {"RSA512", "RSA512|PKCS1_OAEP|SHA1|MGF1_SHA1", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
157 {"RSA512", "RSA512|PKCS1_OAEP|SHA1|MGF1_SHA224", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
158 {"RSA512", "RSA512|PKCS1_OAEP|SHA1|MGF1_SHA256", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
159 {"RSA512", "RSA512|PKCS1_OAEP|SHA224|MGF1_MD5", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
160 {"RSA512", "RSA512|PKCS1_OAEP|SHA224|MGF1_SHA1", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
161 {"RSA512", "RSA512|PKCS1_OAEP|SHA224|MGF1_SHA224", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
162 {"RSA512", "RSA512|PKCS1_OAEP|SHA224|MGF1_SHA256", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
163 {"RSA512", "RSA|PKCS1_OAEP|SHA224|MGF1_SHA256", OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
164 /* RSA768 PKCS1_OAEP */
165 {"RSA768", "RSA768|PKCS1_OAEP|MD5|MGF1_MD5", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
166 {"RSA768", "RSA768|PKCS1_OAEP|MD5|MGF1_SHA1", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
167 {"RSA768", "RSA768|PKCS1_OAEP|MD5|MGF1_SHA224", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
168 {"RSA768", "RSA768|PKCS1_OAEP|MD5|MGF1_SHA256", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
169 {"RSA768", "RSA768|PKCS1_OAEP|MD5|MGF1_SHA384", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
170 {"RSA768", "RSA768|PKCS1_OAEP|MD5|MGF1_SHA512", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
171 {"RSA768", "RSA768|PKCS1_OAEP|SHA1|MGF1_MD5", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
172 {"RSA768", "RSA768|PKCS1_OAEP|SHA1|MGF1_SHA1", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
173 {"RSA768", "RSA768|PKCS1_OAEP|SHA1|MGF1_SHA224", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
174 {"RSA768", "RSA768|PKCS1_OAEP|SHA1|MGF1_SHA256", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
175 {"RSA768", "RSA768|PKCS1_OAEP|SHA1|MGF1_SHA384", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
176 {"RSA768", "RSA768|PKCS1_OAEP|SHA1|MGF1_SHA512", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
177 {"RSA768", "RSA768|PKCS1_OAEP|SHA224|MGF1_MD5", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
178 {"RSA768", "RSA768|PKCS1_OAEP|SHA224|MGF1_SHA1", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
179 {"RSA768", "RSA768|PKCS1_OAEP|SHA224|MGF1_SHA224", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
180 {"RSA768", "RSA768|PKCS1_OAEP|SHA224|MGF1_SHA256", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
181 {"RSA768", "RSA768|PKCS1_OAEP|SHA224|MGF1_SHA384", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
182 {"RSA768", "RSA768|PKCS1_OAEP|SHA224|MGF1_SHA512", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
183 {"RSA768", "RSA768|PKCS1_OAEP|SHA256|MGF1_MD5", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
184 {"RSA768", "RSA768|PKCS1_OAEP|SHA256|MGF1_SHA1", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
185 {"RSA768", "RSA768|PKCS1_OAEP|SHA256|MGF1_SHA224", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
186 {"RSA768", "RSA768|PKCS1_OAEP|SHA256|MGF1_SHA256", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
187 {"RSA768", "RSA768|PKCS1_OAEP|SHA256|MGF1_SHA384", OHTEST_RSA_768_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
188 /* RSA1024 PKCS1_OAEP */
189 {"RSA1024", "RSA1024|PKCS1_OAEP|MD5|MGF1_MD5", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
190 {"RSA1024", "RSA1024|PKCS1_OAEP|MD5|MGF1_SHA1", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
191 {"RSA1024", "RSA1024|PKCS1_OAEP|MD5|MGF1_SHA224", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
192 {"RSA1024", "RSA1024|PKCS1_OAEP|MD5|MGF1_SHA256", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
193 {"RSA1024", "RSA1024|PKCS1_OAEP|MD5|MGF1_SHA384", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
194 {"RSA1024", "RSA1024|PKCS1_OAEP|MD5|MGF1_SHA512", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
195 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA1|MGF1_MD5", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
196 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA1", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
197 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA224", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
198 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA256", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
199 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA384", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
200 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA512", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
201 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA224|MGF1_MD5", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
202 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA224|MGF1_SHA1", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
203 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA224|MGF1_SHA224", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
204 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA224|MGF1_SHA256", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
205 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA224|MGF1_SHA384", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
206 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA224|MGF1_SHA512", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
207 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA256|MGF1_MD5", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
208 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA1", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
209 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA224", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
210 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
211 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA384", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
212 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA512", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
213 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA384|MGF1_MD5", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
214 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA384|MGF1_SHA1", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
215 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA384|MGF1_SHA224", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
216 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA384|MGF1_SHA256", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
217 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA384|MGF1_SHA384", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
218 {"RSA1024", "RSA1024|PKCS1_OAEP|SHA384|MGF1_SHA512", OHTEST_RSA_1024_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
219 /* RSA2048 PKCS1_OAEP */
220 {"RSA2048", "RSA2048|PKCS1_OAEP|MD5|MGF1_MD5", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
221 {"RSA2048", "RSA2048|PKCS1_OAEP|MD5|MGF1_SHA1", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
222 {"RSA2048", "RSA2048|PKCS1_OAEP|MD5|MGF1_SHA224", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
223 {"RSA2048", "RSA2048|PKCS1_OAEP|MD5|MGF1_SHA256", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
224 {"RSA2048", "RSA2048|PKCS1_OAEP|MD5|MGF1_SHA384", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
225 {"RSA2048", "RSA2048|PKCS1_OAEP|MD5|MGF1_SHA512", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
226 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA1|MGF1_MD5", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
227 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA1|MGF1_SHA1", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
228 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA1|MGF1_SHA224", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
229 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA1|MGF1_SHA256", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
230 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA1|MGF1_SHA384", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
231 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA1|MGF1_SHA512", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
232 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA224|MGF1_MD5", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
233 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA224|MGF1_SHA1", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
234 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA224|MGF1_SHA224", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
235 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA224|MGF1_SHA256", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
236 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA224|MGF1_SHA384", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
237 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA224|MGF1_SHA512", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
238 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA256|MGF1_MD5", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
239 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA1", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
240 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA224", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
241 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
242 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA384", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
243 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA512", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
244 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA384|MGF1_MD5", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
245 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA384|MGF1_SHA1", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
246 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA384|MGF1_SHA224", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
247 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA384|MGF1_SHA256", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
248 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA384|MGF1_SHA384", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
249 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA384|MGF1_SHA512", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
250 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA512|MGF1_MD5", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
251 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA512|MGF1_SHA1", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
252 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA512|MGF1_SHA224", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
253 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA512|MGF1_SHA256", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
254 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA512|MGF1_SHA384", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
255 {"RSA2048", "RSA2048|PKCS1_OAEP|SHA512|MGF1_SHA512", OHTEST_RSA_2048_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
256 /* RSA3072 PKCS1_OAEP */
257 {"RSA3072", "RSA3072|PKCS1_OAEP|MD5|MGF1_MD5", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
258 {"RSA3072", "RSA3072|PKCS1_OAEP|MD5|MGF1_SHA1", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
259 {"RSA3072", "RSA3072|PKCS1_OAEP|MD5|MGF1_SHA224", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
260 {"RSA3072", "RSA3072|PKCS1_OAEP|MD5|MGF1_SHA256", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
261 {"RSA3072", "RSA3072|PKCS1_OAEP|MD5|MGF1_SHA384", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
262 {"RSA3072", "RSA3072|PKCS1_OAEP|MD5|MGF1_SHA512", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
263 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA1|MGF1_MD5", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
264 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA1|MGF1_SHA1", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
265 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA1|MGF1_SHA224", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
266 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA1|MGF1_SHA256", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
267 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA1|MGF1_SHA384", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
268 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA1|MGF1_SHA512", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
269 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA224|MGF1_MD5", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
270 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA224|MGF1_SHA1", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
271 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA224|MGF1_SHA224", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
272 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA224|MGF1_SHA256", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
273 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA224|MGF1_SHA384", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
274 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA224|MGF1_SHA512", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
275 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA256|MGF1_MD5", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
276 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA256|MGF1_SHA1", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
277 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA256|MGF1_SHA224", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
278 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA256|MGF1_SHA256", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
279 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA256|MGF1_SHA384", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
280 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA256|MGF1_SHA512", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
281 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA384|MGF1_MD5", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
282 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA384|MGF1_SHA1", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
283 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA384|MGF1_SHA224", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
284 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA384|MGF1_SHA256", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
285 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA384|MGF1_SHA384", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
286 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA384|MGF1_SHA512", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
287 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA512|MGF1_MD5", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
288 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA512|MGF1_SHA1", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
289 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA512|MGF1_SHA224", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
290 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA512|MGF1_SHA256", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
291 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA512|MGF1_SHA384", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
292 {"RSA3072", "RSA3072|PKCS1_OAEP|SHA512|MGF1_SHA512", OHTEST_RSA_3072_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
293 /* RSA4096 PKCS1_OAEP */
294 {"RSA4096", "RSA4096|PKCS1_OAEP|MD5|MGF1_MD5", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
295 {"RSA4096", "RSA4096|PKCS1_OAEP|MD5|MGF1_SHA1", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
296 {"RSA4096", "RSA4096|PKCS1_OAEP|MD5|MGF1_SHA224", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
297 {"RSA4096", "RSA4096|PKCS1_OAEP|MD5|MGF1_SHA256", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
298 {"RSA4096", "RSA4096|PKCS1_OAEP|MD5|MGF1_SHA384", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
299 {"RSA4096", "RSA4096|PKCS1_OAEP|MD5|MGF1_SHA512", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
300 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA1|MGF1_MD5", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
301 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA1|MGF1_SHA1", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
302 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA1|MGF1_SHA224", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
303 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA1|MGF1_SHA256", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
304 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA1|MGF1_SHA384", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
305 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA1|MGF1_SHA512", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
306 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA224|MGF1_MD5", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
307 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA224|MGF1_SHA1", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
308 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA224|MGF1_SHA224", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
309 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA224|MGF1_SHA256", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
310 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA224|MGF1_SHA384", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
311 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA224|MGF1_SHA512", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
312 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA256|MGF1_MD5", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
313 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA256|MGF1_SHA1", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
314 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA256|MGF1_SHA224", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
315 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA256|MGF1_SHA256", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
316 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA256|MGF1_SHA384", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
317 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA256|MGF1_SHA512", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
318 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA384|MGF1_MD5", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
319 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA384|MGF1_SHA1", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
320 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA384|MGF1_SHA224", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
321 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA384|MGF1_SHA256", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
322 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA384|MGF1_SHA384", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
323 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA384|MGF1_SHA512", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
324 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA512|MGF1_MD5", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
325 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA512|MGF1_SHA1", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
326 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA512|MGF1_SHA224", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
327 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA512|MGF1_SHA256", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
328 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA512|MGF1_SHA384", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
329 {"RSA4096", "RSA4096|PKCS1_OAEP|SHA512|MGF1_SHA512", OHTEST_RSA_4096_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
330 /* RSA8192 PKCS1_OAEP */
331 {"RSA8192", "RSA8192|PKCS1_OAEP|MD5|MGF1_MD5", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
332 {"RSA8192", "RSA8192|PKCS1_OAEP|MD5|MGF1_SHA1", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
333 {"RSA8192", "RSA8192|PKCS1_OAEP|MD5|MGF1_SHA224", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
334 {"RSA8192", "RSA8192|PKCS1_OAEP|MD5|MGF1_SHA256", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
335 {"RSA8192", "RSA8192|PKCS1_OAEP|MD5|MGF1_SHA384", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
336 {"RSA8192", "RSA8192|PKCS1_OAEP|MD5|MGF1_SHA512", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2},
337 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA1|MGF1_MD5", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
338 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA1|MGF1_SHA1", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
339 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA1|MGF1_SHA224", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
340 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA1|MGF1_SHA256", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
341 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA1|MGF1_SHA384", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
342 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA1|MGF1_SHA512", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2},
343 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA224|MGF1_MD5", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
344 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA224|MGF1_SHA1", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
345 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA224|MGF1_SHA224", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
346 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA224|MGF1_SHA256", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
347 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA224|MGF1_SHA384", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
348 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA224|MGF1_SHA512", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA224_DIGIESTSIZE - 2},
349 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA256|MGF1_MD5", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
350 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA256|MGF1_SHA1", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
351 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA256|MGF1_SHA224", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
352 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA256|MGF1_SHA256", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
353 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA256|MGF1_SHA384", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
354 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA256|MGF1_SHA512", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA256_DIGIESTSIZE - 2},
355 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA384|MGF1_MD5", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
356 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA384|MGF1_SHA1", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
357 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA384|MGF1_SHA224", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
358 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA384|MGF1_SHA256", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
359 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA384|MGF1_SHA384", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
360 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA384|MGF1_SHA512", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA384_DIGIESTSIZE - 2},
361 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA512|MGF1_MD5", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
362 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA512|MGF1_SHA1", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
363 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA512|MGF1_SHA224", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
364 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA512|MGF1_SHA256", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
365 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA512|MGF1_SHA384", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
366 {"RSA8192", "RSA8192|PKCS1_OAEP|SHA512|MGF1_SHA512", OHTEST_RSA_8192_KEYSIZE - 2 * OHTEST_SHA512_DIGIESTSIZE - 2},
367 /* SM2_256 */
368 {"SM2_256", "SM2_256|MD5", 256},
369 {"SM2_256", "SM2_256|SHA1", 256},
370 {"SM2_256", "SM2_256|SHA224", 256},
371 {"SM2_256", "SM2_256|SHA256", 256},
372 {"SM2_256", "SM2_256|SHA384", 256},
373 {"SM2_256", "SM2_256|SHA512", 256},
374 {"SM2_256", "SM2_256|SM3", 256},
375 {"SM2_256", "SM2|SM3", 256},
376 };
377
378 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkAsymCipherNapiTest, ASYMKEY_ASYM_CIPHER_TEST, ::testing::ValuesIn(g_asymCipherSpec));
379
380 /**
381 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0100
382 * @tc.name OHCryptoFrameworkAsymCipherNapiTest/ASYMKEY_ASYM_CIPHER_TEST.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0100/x
383 * @tc.desc algorithm is Asym Key
384 * @tc.size Medium
385 * @tc.type Func
386 * @tc.level Level0
387 */
388 HWTEST_P(ASYMKEY_ASYM_CIPHER_TEST, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0100, TestSize.Level0)
389 {
390 AsymCipherSpec AsymCipherData = GetParam();
391 OH_CryptoRand *randCtx = nullptr;
392 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
393 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
394 Crypto_DataBlob plainData = {.data = nullptr, .len = 0};
395
396 OH_CryptoKeyPair *keyPair = OHTEST_GenAsymKey(AsymCipherData.algoName);
397 EXPECT_TRUE(keyPair != nullptr);
398 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
399 EXPECT_TRUE(randCtx != nullptr);
400 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, AsymCipherData.pkLen, &msgBlob), CRYPTO_SUCCESS);
401 EXPECT_TRUE(msgBlob.data != nullptr);
402 EXPECT_TRUE(msgBlob.len == AsymCipherData.pkLen);
403 msgBlob.data[0] = 0x00;
404 (void)OHTEST_DoAsymCipher(AsymCipherData.cipherName, keyPair, CRYPTO_ENCRYPT_MODE, &msgBlob, &cipherData);
405 (void)OHTEST_DoAsymCipher(AsymCipherData.cipherName, keyPair, CRYPTO_DECRYPT_MODE, &cipherData, &plainData);
406 if (msgBlob.len == plainData.len) {
407 EXPECT_TRUE(memcmp(plainData.data, msgBlob.data, msgBlob.len) == 0);
408 }
409 EXPECT_TRUE(msgBlob.len == plainData.len);
410
411 OH_CryptoKeyPair_Destroy(keyPair);
412 OH_CryptoRand_Destroy(randCtx);
413 OH_Crypto_FreeDataBlob(&msgBlob);
414 OH_Crypto_FreeDataBlob(&cipherData);
415 OH_Crypto_FreeDataBlob(&plainData);
416 }
417
418 AsymSegmentCipherSpec g_asymSegmentCipherSpec[] = {
419 /* RSA PKCS1 */
420 {"RSA512", "RSA512|PKCS1", OHTEST_RSA_512_KEYSIZE, OHTEST_RSA_512_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
421 {"RSA768", "RSA768|PKCS1", OHTEST_RSA_768_KEYSIZE, OHTEST_RSA_768_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
422 {"RSA1024", "RSA1024|PKCS1", OHTEST_RSA_1024_KEYSIZE, OHTEST_RSA_1024_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
423 {"RSA2048", "RSA2048|PKCS1", OHTEST_RSA_2048_KEYSIZE, OHTEST_RSA_2048_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
424 {"RSA3072", "RSA3072|PKCS1", OHTEST_RSA_3072_KEYSIZE, OHTEST_RSA_3072_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
425 {"RSA4096", "RSA4096|PKCS1", OHTEST_RSA_4096_KEYSIZE, OHTEST_RSA_4096_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
426 {"RSA8192", "RSA8192|PKCS1", OHTEST_RSA_8192_KEYSIZE, OHTEST_RSA_8192_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
427 {"RSA512", "RSA|PKCS1", OHTEST_RSA_512_KEYSIZE, OHTEST_RSA_512_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE},
428 };
429 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkAsymCipherNapiTest, ASYMKEY_ASYM_SEG_CIPHER_TEST, ::testing::ValuesIn(g_asymSegmentCipherSpec));
430
431 /**
432 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0200
433 * @tc.name OHCryptoFrameworkAsymCipherNapiTest/ASYMKEY_ASYM_SEG_CIPHER_TEST.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0200/x
434 * @tc.desc algorithm is Asym Key
435 * @tc.size Medium
436 * @tc.type Func
437 * @tc.level Level0
438 */
439 HWTEST_P(ASYMKEY_ASYM_SEG_CIPHER_TEST, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0200, TestSize.Level0)
440 {
441 AsymSegmentCipherSpec AsymCipherData = GetParam();
442 OH_CryptoRand *randCtx = nullptr;
443 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
444 Crypto_DataBlob cipherData = {.data = nullptr, .len = 2048 * 1024};
445 Crypto_DataBlob plainData = {.data = nullptr, .len = 1024};
446 size_t blockSize = 20;
447
448 OH_CryptoKeyPair *keyPair = OHTEST_GenAsymKey(AsymCipherData.algoName);
449 EXPECT_TRUE(keyPair != nullptr);
450 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
451 EXPECT_TRUE(randCtx != nullptr);
452 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, AsymCipherData.len, &msgBlob), CRYPTO_SUCCESS);
453 EXPECT_TRUE(msgBlob.data != nullptr);
454 EXPECT_TRUE(msgBlob.len == AsymCipherData.len);
455 (void)OHTEST_DoSegmentAsymCipher(AsymCipherData.cipherName, keyPair, blockSize, CRYPTO_ENCRYPT_MODE, &msgBlob, &cipherData);
456 (void)OHTEST_DoSegmentAsymCipher(AsymCipherData.cipherName, keyPair, AsymCipherData.pkLen, CRYPTO_DECRYPT_MODE, &cipherData, &plainData);
457 EXPECT_TRUE(memcmp(plainData.data, msgBlob.data, msgBlob.len) == 0);
458 EXPECT_EQ(msgBlob.len, plainData.len);
459
460 OH_CryptoKeyPair_Destroy(keyPair);
461 OH_CryptoRand_Destroy(randCtx);
462 OH_Crypto_FreeDataBlob(&msgBlob);
463 OH_Crypto_FreeDataBlob(&cipherData);
464 OH_Crypto_FreeDataBlob(&plainData);
465 }
466
OHTEST_DoSM2EncryptCipher(const char * algoName,OH_CryptoKeyPair * keyPair,size_t blockSize,Crypto_DataBlob * msg,Crypto_DataBlob * cipherText,int * cipherIndex)467 static void OHTEST_DoSM2EncryptCipher(const char *algoName, OH_CryptoKeyPair *keyPair,
468 size_t blockSize, Crypto_DataBlob *msg, Crypto_DataBlob *cipherText, int *cipherIndex)
469 {
470 OH_CryptoAsymCipher *ctx = nullptr;
471 int quotient = msg->len / blockSize;
472 int remainder = msg->len % blockSize;
473 uint8_t *data = msg->data;
474 size_t len = msg->len;
475 Crypto_DataBlob *dataBlob = msg;
476 size_t cipherLen = 0;
477 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
478 int i = 0;
479
480 cipherText->data = (uint8_t *)malloc(cipherText->len);
481 uint8_t *tmp = cipherText->data;
482 EXPECT_TRUE(cipherText->data != nullptr);
483 EXPECT_EQ(OH_CryptoAsymCipher_Create(algoName, &ctx), CRYPTO_SUCCESS);
484 EXPECT_TRUE(ctx != nullptr);
485 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_ENCRYPT_MODE, keyPair), CRYPTO_SUCCESS);
486 for (i = 0; i < quotient; i++) {
487 dataBlob->len = blockSize;
488 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, dataBlob, &cipherData), CRYPTO_SUCCESS);
489 (void)memcpy(cipherText->data, cipherData.data, cipherData.len);
490 cipherText->data += cipherData.len;
491 cipherLen += cipherData.len;
492 dataBlob->data += blockSize;
493 cipherIndex[i] = cipherData.len;
494 OH_Crypto_FreeDataBlob(&cipherData);
495 }
496 if (remainder) {
497 dataBlob->len = remainder;
498 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, dataBlob, &cipherData), CRYPTO_SUCCESS);
499 cipherLen += cipherData.len;
500 cipherIndex[i] = cipherData.len;
501 (void)memcpy(cipherText->data, cipherData.data, cipherData.len);
502 }
503
504 dataBlob->data = data;
505 dataBlob->len = len;
506 cipherText->data = tmp;
507 cipherText->len = cipherLen;
508 OH_CryptoAsymCipher_Destroy(ctx);
509 OH_Crypto_FreeDataBlob(&cipherData);
510 }
511
OHTEST_DoSM2DecryptCipher(const char * algoName,OH_CryptoKeyPair * keyPair,Crypto_DataBlob * msg,Crypto_DataBlob * cipherText,int * cipherIndex)512 static void OHTEST_DoSM2DecryptCipher(const char *algoName, OH_CryptoKeyPair *keyPair,
513 Crypto_DataBlob *msg, Crypto_DataBlob *cipherText, int *cipherIndex)
514 {
515 OH_CryptoAsymCipher *ctx = nullptr;
516 uint8_t *data = msg->data;
517 size_t len = msg->len;
518 Crypto_DataBlob *dataBlob = msg;
519 size_t cipherLen = 0;
520 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
521 int i = 0;
522
523 cipherText->data = (uint8_t *)malloc(cipherText->len);
524 uint8_t *tmp = cipherText->data;
525 EXPECT_TRUE(cipherText->data != nullptr);
526 EXPECT_EQ(OH_CryptoAsymCipher_Create(algoName, &ctx), CRYPTO_SUCCESS);
527 EXPECT_TRUE(ctx != nullptr);
528 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_DECRYPT_MODE, keyPair), CRYPTO_SUCCESS);
529 while (cipherIndex[i] != 0) {
530 dataBlob->len = cipherIndex[i];
531 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, dataBlob, &cipherData), CRYPTO_SUCCESS);
532 (void)memcpy(cipherText->data, cipherData.data, cipherData.len);
533 cipherText->data += cipherData.len;
534 cipherLen += cipherData.len;
535 dataBlob->data += cipherIndex[i];
536 i++;
537 OH_Crypto_FreeDataBlob(&cipherData);
538 }
539
540 dataBlob->data = data;
541 dataBlob->len = len;
542 cipherText->data = tmp;
543 cipherText->len = cipherLen;
544 OH_CryptoAsymCipher_Destroy(ctx);
545 OH_Crypto_FreeDataBlob(&cipherData);
546 }
547
548 /**
549 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0300
550 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0300
551 * @tc.desc algorithm is Asym Key
552 * @tc.size Medium
553 * @tc.type Func
554 * @tc.level Level0
555 */
556 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0300, TestSize.Level0)
557 {
558 const char *algoName = "SM2_256";
559 const char *cipherName = "SM2_256|SM3";
560 OH_CryptoRand *randCtx = nullptr;
561 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
562 Crypto_DataBlob cipherData = {.data = nullptr, .len = 2048};
563 Crypto_DataBlob plainData = {.data = nullptr, .len = 1024};
564 size_t blockSize = 20;
565 size_t msgLen = 53;
566 int cipherIndex[64] = {0};
567
568 OH_CryptoKeyPair *keyPair = OHTEST_GenAsymKey(algoName);
569 EXPECT_TRUE(keyPair != nullptr);
570 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
571 EXPECT_TRUE(randCtx != nullptr);
572 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, msgLen, &msgBlob), CRYPTO_SUCCESS);
573 EXPECT_TRUE(msgBlob.data != nullptr);
574 EXPECT_TRUE(msgBlob.len == msgLen);
575 (void)OHTEST_DoSM2EncryptCipher(cipherName, keyPair, blockSize, &msgBlob, &cipherData, cipherIndex);
576 (void)OHTEST_DoSM2DecryptCipher(cipherName, keyPair, &cipherData, &plainData, cipherIndex);
577 EXPECT_TRUE(memcmp(plainData.data, msgBlob.data, msgBlob.len) == 0);
578 EXPECT_EQ(msgBlob.len, plainData.len);
579
580 OH_CryptoKeyPair_Destroy(keyPair);
581 OH_CryptoRand_Destroy(randCtx);
582 OH_Crypto_FreeDataBlob(&msgBlob);
583 OH_Crypto_FreeDataBlob(&cipherData);
584 OH_Crypto_FreeDataBlob(&plainData);
585 }
586
587 /**
588 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0400
589 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0400
590 * @tc.desc algorithm is Asym Key
591 * @tc.size Medium
592 * @tc.type Func
593 * @tc.level Level0
594 */
595 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0400, TestSize.Level0)
596 {
597 const char *algoName = "RSA512";
598 const char *cipherName = "RSA512|NoPadding";
599 OH_CryptoRand *randCtx = nullptr;
600 OH_CryptoAsymCipher *ctx = nullptr;
601 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
602 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
603 size_t msgLen = OHTEST_RSA_512_KEYSIZE - 1;
604
605 OH_CryptoKeyPair *keyPair = OHTEST_GenAsymKey(algoName);
606 EXPECT_TRUE(keyPair != nullptr);
607 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
608 EXPECT_TRUE(randCtx != nullptr);
609 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, msgLen, &msgBlob), CRYPTO_SUCCESS);
610 EXPECT_TRUE(msgBlob.data != nullptr);
611 EXPECT_TRUE(msgBlob.len == msgLen);
612 msgBlob.data[0] = 0x00;
613 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName, &ctx), CRYPTO_SUCCESS);
614 EXPECT_TRUE(ctx != nullptr);
615 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_ENCRYPT_MODE, keyPair), CRYPTO_SUCCESS);
616 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &msgBlob, &cipherData), CRYPTO_OPERTION_ERROR);
617
618 OH_CryptoAsymCipher_Destroy(ctx);
619 OH_CryptoKeyPair_Destroy(keyPair);
620 OH_CryptoRand_Destroy(randCtx);
621 OH_Crypto_FreeDataBlob(&msgBlob);
622 OH_Crypto_FreeDataBlob(&cipherData);
623 }
624
625 /**
626 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0500
627 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0500
628 * @tc.desc algorithm is Asym Key
629 * @tc.size Medium
630 * @tc.type Func
631 * @tc.level Level0
632 */
633 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0500, TestSize.Level0)
634 {
635 const char *algoName = "RSA512";
636 const char *cipherName = "RSA512|PKCS1";
637 OH_CryptoRand *randCtx = nullptr;
638 OH_CryptoAsymCipher *ctx = nullptr;
639 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
640 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
641 size_t msgLen = OHTEST_RSA_512_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE + 1;
642
643 OH_CryptoKeyPair *keyPair = OHTEST_GenAsymKey(algoName);
644 EXPECT_TRUE(keyPair != nullptr);
645 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
646 EXPECT_TRUE(randCtx != nullptr);
647 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, msgLen, &msgBlob), CRYPTO_SUCCESS);
648 EXPECT_TRUE(msgBlob.data != nullptr);
649 EXPECT_TRUE(msgBlob.len == msgLen);
650 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName, &ctx), CRYPTO_SUCCESS);
651 EXPECT_TRUE(ctx != nullptr);
652 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_ENCRYPT_MODE, keyPair), CRYPTO_SUCCESS);
653 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &msgBlob, &cipherData), CRYPTO_OPERTION_ERROR);
654
655 OH_CryptoAsymCipher_Destroy(ctx);
656 OH_CryptoKeyPair_Destroy(keyPair);
657 OH_CryptoRand_Destroy(randCtx);
658 OH_Crypto_FreeDataBlob(&msgBlob);
659 OH_Crypto_FreeDataBlob(&cipherData);
660 }
661
662 /**
663 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0600
664 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0600
665 * @tc.desc algorithm is Asym Key
666 * @tc.size Medium
667 * @tc.type Func
668 * @tc.level Level0
669 */
670 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0600, TestSize.Level0)
671 {
672 const char *algoName = "RSA512";
673 const char *cipherName = "RSA512|PKCS1_OAEP|MD5|MGF1_MD5";
674 OH_CryptoRand *randCtx = nullptr;
675 OH_CryptoAsymCipher *ctx = nullptr;
676 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
677 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
678 size_t msgLen = OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_MD5_DIGIESTSIZE - 2 + 1;
679
680 OH_CryptoKeyPair *keyPair = OHTEST_GenAsymKey(algoName);
681 EXPECT_TRUE(keyPair != nullptr);
682 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
683 EXPECT_TRUE(randCtx != nullptr);
684 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, msgLen, &msgBlob), CRYPTO_SUCCESS);
685 EXPECT_TRUE(msgBlob.data != nullptr);
686 EXPECT_TRUE(msgBlob.len == msgLen);
687 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName, &ctx), CRYPTO_SUCCESS);
688 EXPECT_TRUE(ctx != nullptr);
689 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_ENCRYPT_MODE, keyPair), CRYPTO_SUCCESS);
690 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &msgBlob, &cipherData), CRYPTO_OPERTION_ERROR);
691
692 OH_CryptoAsymCipher_Destroy(ctx);
693 OH_CryptoKeyPair_Destroy(keyPair);
694 OH_CryptoRand_Destroy(randCtx);
695 OH_Crypto_FreeDataBlob(&msgBlob);
696 OH_Crypto_FreeDataBlob(&cipherData);
697 }
698
699 /**
700 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0700
701 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0700
702 * @tc.desc algorithm is Asym Key
703 * @tc.size Medium
704 * @tc.type Func
705 * @tc.level Level0
706 */
707 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0700, TestSize.Level0)
708 {
709 const char *algoName = "RSA512";
710 const char *cipherName = "RSA512|PKCS1";
711 OH_CryptoRand *randCtx = nullptr;
712 OH_CryptoAsymCipher *ctx = nullptr;
713 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
714 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
715 Crypto_DataBlob plainData = {.data = nullptr, .len = 0};
716 size_t msgLen = OHTEST_RSA_512_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE;
717
718 OH_CryptoKeyPair *keyPair1 = OHTEST_GenAsymKey(algoName);
719 OH_CryptoKeyPair *keyPair2 = OHTEST_GenAsymKey(algoName);
720 EXPECT_TRUE(keyPair1 != nullptr && keyPair2 != nullptr);
721 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
722 EXPECT_TRUE(randCtx != nullptr);
723 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, msgLen, &msgBlob), CRYPTO_SUCCESS);
724 EXPECT_TRUE(msgBlob.data != nullptr);
725 EXPECT_TRUE(msgBlob.len == msgLen);
726 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName, &ctx), CRYPTO_SUCCESS);
727 EXPECT_TRUE(ctx != nullptr);
728 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_ENCRYPT_MODE, keyPair1), CRYPTO_SUCCESS);
729 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &msgBlob, &cipherData), CRYPTO_SUCCESS);
730 OH_CryptoAsymCipher_Destroy(ctx);
731 ctx = nullptr;
732 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName, &ctx), CRYPTO_SUCCESS);
733 EXPECT_TRUE(ctx != nullptr);
734 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_DECRYPT_MODE, keyPair2), CRYPTO_SUCCESS);
735 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &cipherData, &plainData), CRYPTO_OPERTION_ERROR);
736
737 OH_CryptoAsymCipher_Destroy(ctx);
738 OH_CryptoKeyPair_Destroy(keyPair1);
739 OH_CryptoKeyPair_Destroy(keyPair2);
740 OH_CryptoRand_Destroy(randCtx);
741 OH_Crypto_FreeDataBlob(&msgBlob);
742 OH_Crypto_FreeDataBlob(&plainData);
743 OH_Crypto_FreeDataBlob(&cipherData);
744 }
745
746 /**
747 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0800
748 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0800
749 * @tc.desc algorithm is Asym Key
750 * @tc.size Medium
751 * @tc.type Func
752 * @tc.level Level0
753 */
754 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0800, TestSize.Level0)
755 {
756 const char *algoName1 = "RSA512";
757 const char *algoName2 = "RSA768";
758 const char *cipherName = "RSA512|PKCS1";
759 OH_CryptoRand *randCtx = nullptr;
760 OH_CryptoAsymCipher *ctx = nullptr;
761 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
762 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
763 Crypto_DataBlob plainData = {.data = nullptr, .len = 0};
764 size_t msgLen = OHTEST_RSA_512_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE;
765
766 OH_CryptoKeyPair *keyPair1 = OHTEST_GenAsymKey(algoName1);
767 OH_CryptoKeyPair *keyPair2 = OHTEST_GenAsymKey(algoName2);
768 EXPECT_TRUE(keyPair1 != nullptr && keyPair2 != nullptr);
769 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
770 EXPECT_TRUE(randCtx != nullptr);
771 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, msgLen, &msgBlob), CRYPTO_SUCCESS);
772 EXPECT_TRUE(msgBlob.data != nullptr);
773 EXPECT_TRUE(msgBlob.len == msgLen);
774 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName, &ctx), CRYPTO_SUCCESS);
775 EXPECT_TRUE(ctx != nullptr);
776 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_ENCRYPT_MODE, keyPair1), CRYPTO_SUCCESS);
777 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &msgBlob, &cipherData), CRYPTO_SUCCESS);
778 OH_CryptoAsymCipher_Destroy(ctx);
779 ctx = nullptr;
780 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName, &ctx), CRYPTO_SUCCESS);
781 EXPECT_TRUE(ctx != nullptr);
782 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_DECRYPT_MODE, keyPair2), CRYPTO_SUCCESS);
783 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &cipherData, &plainData), CRYPTO_OPERTION_ERROR);
784
785 OH_CryptoAsymCipher_Destroy(ctx);
786 OH_CryptoKeyPair_Destroy(keyPair1);
787 OH_CryptoKeyPair_Destroy(keyPair2);
788 OH_CryptoRand_Destroy(randCtx);
789 OH_Crypto_FreeDataBlob(&msgBlob);
790 OH_Crypto_FreeDataBlob(&plainData);
791 OH_Crypto_FreeDataBlob(&cipherData);
792 }
793
794 /**
795 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0900
796 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0900
797 * @tc.desc algorithm is Asym Key
798 * @tc.size Medium
799 * @tc.type Func
800 * @tc.level Level0
801 */
802 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_0900, TestSize.Level0)
803 {
804 const char *algoName = "RSA512";
805 const char *cipherName = "RSA512|PKCS1";
806 OH_CryptoRand *randCtx = nullptr;
807 OH_CryptoAsymCipher *ctx = nullptr;
808 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
809 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
810 Crypto_DataBlob plainData = {.data = nullptr, .len = 0};
811 size_t msgLen = OHTEST_RSA_512_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE;
812
813 OH_CryptoKeyPair *keyPair = OHTEST_GenAsymKey(algoName);
814 EXPECT_TRUE(keyPair != nullptr);
815 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
816 EXPECT_TRUE(randCtx != nullptr);
817 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, msgLen, &msgBlob), CRYPTO_SUCCESS);
818 EXPECT_TRUE(msgBlob.data != nullptr);
819 EXPECT_TRUE(msgBlob.len == msgLen);
820 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName, &ctx), CRYPTO_SUCCESS);
821 EXPECT_TRUE(ctx != nullptr);
822 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_ENCRYPT_MODE, keyPair), CRYPTO_SUCCESS);
823 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &msgBlob, &cipherData), CRYPTO_SUCCESS);
824 OH_CryptoAsymCipher_Destroy(ctx);
825 ctx = nullptr;
826 cipherData.data[0]++;
827 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName, &ctx), CRYPTO_SUCCESS);
828 EXPECT_TRUE(ctx != nullptr);
829 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_DECRYPT_MODE, keyPair), CRYPTO_SUCCESS);
830 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &cipherData, &plainData), CRYPTO_OPERTION_ERROR);
831 cipherData.data[0]--;
832 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &cipherData, &plainData), CRYPTO_SUCCESS);
833 EXPECT_TRUE(memcmp(plainData.data, msgBlob.data, msgBlob.len) == 0);
834 EXPECT_EQ(msgBlob.len, plainData.len);
835
836 OH_CryptoAsymCipher_Destroy(ctx);
837 OH_CryptoKeyPair_Destroy(keyPair);
838 OH_CryptoRand_Destroy(randCtx);
839 OH_Crypto_FreeDataBlob(&msgBlob);
840 OH_Crypto_FreeDataBlob(&plainData);
841 OH_Crypto_FreeDataBlob(&cipherData);
842 }
843
844 /**
845 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1000
846 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1000
847 * @tc.desc algorithm is Asym Key
848 * @tc.size Medium
849 * @tc.type Func
850 * @tc.level Level0
851 */
852 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1000, TestSize.Level0)
853 {
854 const char *algoName = "RSA512";
855 const char *cipherName1 = "RSA512|PKCS1";
856 const char *cipherName2 = "RSA512|NoPadding";
857 OH_CryptoRand *randCtx = nullptr;
858 OH_CryptoAsymCipher *ctx = nullptr;
859 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
860 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
861 Crypto_DataBlob plainData = {.data = nullptr, .len = 0};
862 size_t msgLen = OHTEST_RSA_512_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE;
863
864 OH_CryptoKeyPair *keyPair = OHTEST_GenAsymKey(algoName);
865 EXPECT_TRUE(keyPair != nullptr);
866 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
867 EXPECT_TRUE(randCtx != nullptr);
868 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, msgLen, &msgBlob), CRYPTO_SUCCESS);
869 EXPECT_TRUE(msgBlob.data != nullptr);
870 EXPECT_TRUE(msgBlob.len == msgLen);
871 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName1, &ctx), CRYPTO_SUCCESS);
872 EXPECT_TRUE(ctx != nullptr);
873 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_ENCRYPT_MODE, keyPair), CRYPTO_SUCCESS);
874 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &msgBlob, &cipherData), CRYPTO_SUCCESS);
875 OH_CryptoAsymCipher_Destroy(ctx);
876 ctx = nullptr;
877 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName2, &ctx), CRYPTO_SUCCESS);
878 EXPECT_TRUE(ctx != nullptr);
879 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_DECRYPT_MODE, keyPair), CRYPTO_SUCCESS);
880 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &cipherData, &plainData), CRYPTO_SUCCESS);
881 EXPECT_TRUE(memcmp(plainData.data, msgBlob.data, msgBlob.len) != 0);
882 EXPECT_EQ(OHTEST_RSA_512_KEYSIZE, plainData.len);
883
884 OH_CryptoAsymCipher_Destroy(ctx);
885 OH_CryptoKeyPair_Destroy(keyPair);
886 OH_CryptoRand_Destroy(randCtx);
887 OH_Crypto_FreeDataBlob(&msgBlob);
888 OH_Crypto_FreeDataBlob(&plainData);
889 OH_Crypto_FreeDataBlob(&cipherData);
890 }
891
892 /**
893 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1100
894 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1100
895 * @tc.desc algorithm is Asym Key
896 * @tc.size Medium
897 * @tc.type Func
898 * @tc.level Level0
899 */
900 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1100, TestSize.Level0)
901 {
902 const char *algoName = "RSA512";
903 const char *cipherName1 = "RSA512|PKCS1";
904 const char *cipherName2 = "RSA512|PKCS1_OAEP|MD5|MGF1_MD5";
905 OH_CryptoRand *randCtx = nullptr;
906 OH_CryptoAsymCipher *ctx = nullptr;
907 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
908 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
909 Crypto_DataBlob plainData = {.data = nullptr, .len = 0};
910 size_t msgLen = OHTEST_RSA_512_KEYSIZE - OHTEST_RSA_PKCS1_PADDING_SIZE;
911
912 OH_CryptoKeyPair *keyPair = OHTEST_GenAsymKey(algoName);
913 EXPECT_TRUE(keyPair != nullptr);
914 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
915 EXPECT_TRUE(randCtx != nullptr);
916 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, msgLen, &msgBlob), CRYPTO_SUCCESS);
917 EXPECT_TRUE(msgBlob.data != nullptr);
918 EXPECT_TRUE(msgBlob.len == msgLen);
919 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName1, &ctx), CRYPTO_SUCCESS);
920 EXPECT_TRUE(ctx != nullptr);
921 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_ENCRYPT_MODE, keyPair), CRYPTO_SUCCESS);
922 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &msgBlob, &cipherData), CRYPTO_SUCCESS);
923 OH_CryptoAsymCipher_Destroy(ctx);
924 ctx = nullptr;
925 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName2, &ctx), CRYPTO_SUCCESS);
926 EXPECT_TRUE(ctx != nullptr);
927 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_DECRYPT_MODE, keyPair), CRYPTO_SUCCESS);
928 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &cipherData, &plainData), CRYPTO_OPERTION_ERROR);
929
930 OH_CryptoAsymCipher_Destroy(ctx);
931 OH_CryptoKeyPair_Destroy(keyPair);
932 OH_CryptoRand_Destroy(randCtx);
933 OH_Crypto_FreeDataBlob(&msgBlob);
934 OH_Crypto_FreeDataBlob(&plainData);
935 OH_Crypto_FreeDataBlob(&cipherData);
936 }
937
938 /**
939 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1200
940 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1200
941 * @tc.desc algorithm is Asym Key
942 * @tc.size Medium
943 * @tc.type Func
944 * @tc.level Level0
945 */
946 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1200, TestSize.Level0)
947 {
948 const char *algoName = "RSA512";
949 const char *cipherName1 = "RSA512|PKCS1_OAEP|SHA1|MGF1_MD5";
950 const char *cipherName2 = "RSA512|PKCS1_OAEP|MD5|MGF1_MD5";
951 OH_CryptoRand *randCtx = nullptr;
952 OH_CryptoAsymCipher *ctx = nullptr;
953 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
954 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
955 Crypto_DataBlob plainData = {.data = nullptr, .len = 0};
956 size_t msgLen = OHTEST_RSA_512_KEYSIZE - 2 * OHTEST_SHA1_DIGIESTSIZE - 2;
957
958 OH_CryptoKeyPair *keyPair = OHTEST_GenAsymKey(algoName);
959 EXPECT_TRUE(keyPair != nullptr);
960 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
961 EXPECT_TRUE(randCtx != nullptr);
962 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, msgLen, &msgBlob), CRYPTO_SUCCESS);
963 EXPECT_TRUE(msgBlob.data != nullptr);
964 EXPECT_TRUE(msgBlob.len == msgLen);
965 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName1, &ctx), CRYPTO_SUCCESS);
966 EXPECT_TRUE(ctx != nullptr);
967 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_ENCRYPT_MODE, keyPair), CRYPTO_SUCCESS);
968 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &msgBlob, &cipherData), CRYPTO_SUCCESS);
969 OH_CryptoAsymCipher_Destroy(ctx);
970 ctx = nullptr;
971 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName2, &ctx), CRYPTO_SUCCESS);
972 EXPECT_TRUE(ctx != nullptr);
973 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_DECRYPT_MODE, keyPair), CRYPTO_SUCCESS);
974 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &cipherData, &plainData), CRYPTO_OPERTION_ERROR);
975
976 OH_CryptoAsymCipher_Destroy(ctx);
977 OH_CryptoKeyPair_Destroy(keyPair);
978 OH_CryptoRand_Destroy(randCtx);
979 OH_Crypto_FreeDataBlob(&msgBlob);
980 OH_Crypto_FreeDataBlob(&plainData);
981 OH_Crypto_FreeDataBlob(&cipherData);
982 }
983
984 /**
985 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1300
986 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1300
987 * @tc.desc algorithm is Asym Key
988 * @tc.size Medium
989 * @tc.type Func
990 * @tc.level Level0
991 */
992 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1300, TestSize.Level0)
993 {
994 const char *algoName = "RSA512";
995 const char *cipherName2 = "RSA512|PKCS1";
996 const char *cipherName1 = "RSA512|NoPadding";
997 OH_CryptoRand *randCtx = nullptr;
998 OH_CryptoAsymCipher *ctx = nullptr;
999 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
1000 Crypto_DataBlob cipherData = {.data = nullptr, .len = 0};
1001 Crypto_DataBlob plainData = {.data = nullptr, .len = 0};
1002 size_t msgLen = OHTEST_RSA_512_KEYSIZE;
1003
1004 OH_CryptoKeyPair *keyPair = OHTEST_GenAsymKey(algoName);
1005 EXPECT_TRUE(keyPair != nullptr);
1006 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
1007 EXPECT_TRUE(randCtx != nullptr);
1008 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, msgLen, &msgBlob), CRYPTO_SUCCESS);
1009 EXPECT_TRUE(msgBlob.data != nullptr);
1010 EXPECT_TRUE(msgBlob.len == msgLen);
1011 msgBlob.data[0] = 0x00;
1012 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName1, &ctx), CRYPTO_SUCCESS);
1013 EXPECT_TRUE(ctx != nullptr);
1014 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_ENCRYPT_MODE, keyPair), CRYPTO_SUCCESS);
1015 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &msgBlob, &cipherData), CRYPTO_SUCCESS);
1016 OH_CryptoAsymCipher_Destroy(ctx);
1017 ctx = nullptr;
1018 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName2, &ctx), CRYPTO_SUCCESS);
1019 EXPECT_TRUE(ctx != nullptr);
1020 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_DECRYPT_MODE, keyPair), CRYPTO_SUCCESS);
1021 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &cipherData, &plainData), CRYPTO_OPERTION_ERROR);
1022
1023 OH_CryptoAsymCipher_Destroy(ctx);
1024 OH_CryptoKeyPair_Destroy(keyPair);
1025 OH_CryptoRand_Destroy(randCtx);
1026 OH_Crypto_FreeDataBlob(&msgBlob);
1027 OH_Crypto_FreeDataBlob(&plainData);
1028 OH_Crypto_FreeDataBlob(&cipherData);
1029 }
1030
1031 /**
1032 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1400
1033 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1400
1034 * @tc.desc algorithm is Asym Key
1035 * @tc.size Medium
1036 * @tc.type Func
1037 * @tc.level Level0
1038 */
1039 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1400, TestSize.Level0)
1040 {
1041 const char *algoName = "SM2_256";
1042 const char *cipherName = "SM2_256|SM3";
1043 OH_CryptoRand *randCtx = nullptr;
1044 OH_CryptoAsymCipher *ctx = nullptr;
1045 Crypto_DataBlob msgBlob = {.data = nullptr, .len = 0};
1046 Crypto_DataBlob cipherData = {.data = nullptr, .len = 2048};
1047 Crypto_DataBlob plainData = {.data = nullptr, .len = 0};
1048 size_t blockSize = 20;
1049 size_t msgLen = 53;
1050 int cipherIndex[64] = {0};
1051
1052 OH_CryptoKeyPair *keyPair = OHTEST_GenAsymKey(algoName);
1053 EXPECT_TRUE(keyPair != nullptr);
1054 EXPECT_EQ(OH_CryptoRand_Create(&randCtx), CRYPTO_SUCCESS);
1055 EXPECT_TRUE(randCtx != nullptr);
1056 EXPECT_EQ(OH_CryptoRand_GenerateRandom(randCtx, msgLen, &msgBlob), CRYPTO_SUCCESS);
1057 EXPECT_TRUE(msgBlob.data != nullptr);
1058 EXPECT_TRUE(msgBlob.len == msgLen);
1059 (void)OHTEST_DoSM2EncryptCipher(cipherName, keyPair, blockSize, &msgBlob, &cipherData, cipherIndex);
1060 EXPECT_EQ(OH_CryptoAsymCipher_Create(cipherName, &ctx), CRYPTO_SUCCESS);
1061 EXPECT_TRUE(ctx != nullptr);
1062 EXPECT_EQ(OH_CryptoAsymCipher_Init(ctx, CRYPTO_DECRYPT_MODE, keyPair), CRYPTO_SUCCESS);
1063 cipherData.len = 100;
1064 EXPECT_EQ(OH_CryptoAsymCipher_Final(ctx, &cipherData, &plainData), CRYPTO_OPERTION_ERROR);
1065
1066 OH_CryptoAsymCipher_Destroy(ctx);
1067 OH_CryptoKeyPair_Destroy(keyPair);
1068 OH_CryptoRand_Destroy(randCtx);
1069 OH_Crypto_FreeDataBlob(&msgBlob);
1070 OH_Crypto_FreeDataBlob(&cipherData);
1071 OH_Crypto_FreeDataBlob(&plainData);
1072 }
1073
1074 /**
1075 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1500
1076 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1500
1077 * @tc.desc algorithm is Asym Key
1078 * @tc.size Medium
1079 * @tc.type Func
1080 * @tc.level Level0
1081 */
1082 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1500, TestSize.Level0)
1083 {
1084 OH_CryptoSm2CiphertextSpec *spec = nullptr;
1085 uint8_t data[] = {
1086 0x30, 0x79, 0x02, 0x21, 0x00, 0x9b, 0x17, 0xa5, 0xd3, 0xac, 0xcc, 0xf3, 0x3c, 0x2e, 0x36, 0x23,
1087 0x99, 0x78, 0x17, 0x50, 0xc9, 0xdc, 0x3e, 0x1b, 0x57, 0x0e, 0xc9, 0x0b, 0x04, 0x1c, 0x18, 0x24,
1088 0x5e, 0x71, 0xe9, 0x02, 0x8c, 0x02, 0x20, 0x78, 0xc6, 0x6f, 0xda, 0x59, 0x82, 0xae, 0x5e, 0xb3,
1089 0x17, 0xd2, 0xe1, 0x9b, 0x73, 0xf6, 0x77, 0xed, 0x57, 0xd5, 0xe3, 0x46, 0xde, 0x6c, 0xc4, 0x19,
1090 0x38, 0x80, 0x96, 0x4c, 0x13, 0x6d, 0x2c, 0x04, 0x20, 0xf0, 0xb2, 0x80, 0xed, 0x0b, 0xbe, 0xac,
1091 0xac, 0x80, 0x1c, 0x3c, 0xe0, 0xaa, 0x9f, 0x01, 0x47, 0xfc, 0xd7, 0x86, 0x1d, 0x33, 0x21, 0x2b,
1092 0x36, 0xeb, 0x8f, 0x16, 0x36, 0x94, 0x1a, 0x4d, 0xaf, 0x04, 0x10, 0xf5, 0x89, 0xc8, 0xb5, 0xdf,
1093 0xc6, 0x5e, 0x12, 0xc8, 0x55, 0x6a, 0x1c, 0xe4, 0x6f, 0x47, 0x32
1094 };
1095 Crypto_DataBlob sm2Ciphertext = {.data = data, .len = sizeof(data)/sizeof(data[0])};
1096 Crypto_DataBlob c1_x = {.data = nullptr, .len = 0};
1097 Crypto_DataBlob c1_y = {.data = nullptr, .len = 0};
1098 Crypto_DataBlob c2 = {.data = nullptr, .len = 0};
1099 Crypto_DataBlob c3 = {.data = nullptr, .len = 0};
1100 Crypto_DataBlob new_c1_x = {.data = nullptr, .len = 0};
1101 Crypto_DataBlob new_c1_y = {.data = nullptr, .len = 0};
1102 Crypto_DataBlob new_c2 = {.data = nullptr, .len = 0};
1103 Crypto_DataBlob new_c3 = {.data = nullptr, .len = 0};
1104 Crypto_DataBlob new_sm2Ciphertext = {.data = nullptr, .len = 0};
1105
1106 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Create(&sm2Ciphertext, &spec), CRYPTO_SUCCESS);
1107 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_GetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_X, &c1_x), CRYPTO_SUCCESS);
1108 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_GetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_Y, &c1_y), CRYPTO_SUCCESS);
1109 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_GetItem(spec, CRYPTO_SM2_CIPHERTEXT_C2, &c2), CRYPTO_SUCCESS);
1110 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_GetItem(spec, CRYPTO_SM2_CIPHERTEXT_C3, &c3), CRYPTO_SUCCESS);
1111 OH_CryptoSm2CiphertextSpec_Destroy(spec);
1112 spec = nullptr;
1113 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Create(nullptr, &spec), CRYPTO_SUCCESS);
1114 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_X, &c1_x), CRYPTO_SUCCESS);
1115 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_Y, &c1_y), CRYPTO_SUCCESS);
1116 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C2, &c2), CRYPTO_SUCCESS);
1117 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C3, &c3), CRYPTO_SUCCESS);
1118 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Encode(spec, &new_sm2Ciphertext), CRYPTO_SUCCESS);
1119 EXPECT_TRUE(memcmp(new_sm2Ciphertext.data, sm2Ciphertext.data, new_sm2Ciphertext.len) == 0);
1120 EXPECT_EQ(new_sm2Ciphertext.len, sm2Ciphertext.len);
1121 OH_CryptoSm2CiphertextSpec_Destroy(spec);
1122 spec = nullptr;
1123 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Create(&new_sm2Ciphertext, &spec), CRYPTO_SUCCESS);
1124 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_GetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_X, &new_c1_x), CRYPTO_SUCCESS);
1125 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_GetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_Y, &new_c1_y), CRYPTO_SUCCESS);
1126 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_GetItem(spec, CRYPTO_SM2_CIPHERTEXT_C2, &new_c2), CRYPTO_SUCCESS);
1127 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_GetItem(spec, CRYPTO_SM2_CIPHERTEXT_C3, &new_c3), CRYPTO_SUCCESS);
1128 EXPECT_TRUE(memcmp(new_c1_x.data, c1_x.data, new_c1_x.len) == 0);
1129 EXPECT_TRUE(memcmp(new_c1_y.data, c1_y.data, new_c1_y.len) == 0);
1130 EXPECT_TRUE(memcmp(new_c2.data, c2.data, c2.len) == 0);
1131 EXPECT_TRUE(memcmp(new_c3.data, c3.data, new_c3.len) == 0);
1132 EXPECT_TRUE(new_c3.len == c3.len && new_c1_x.len == c1_x.len && new_c2.len == c2.len && new_c1_y.len == c1_y.len);
1133
1134 OH_CryptoSm2CiphertextSpec_Destroy(spec);
1135 OH_Crypto_FreeDataBlob(&new_c1_x);
1136 OH_Crypto_FreeDataBlob(&new_c1_y);
1137 OH_Crypto_FreeDataBlob(&new_c2);
1138 OH_Crypto_FreeDataBlob(&new_c3);
1139 OH_Crypto_FreeDataBlob(&c1_x);
1140 OH_Crypto_FreeDataBlob(&c1_y);
1141 OH_Crypto_FreeDataBlob(&c2);
1142 OH_Crypto_FreeDataBlob(&c3);
1143 OH_Crypto_FreeDataBlob(&new_sm2Ciphertext);
1144 }
1145
1146 /**
1147 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1600
1148 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1600
1149 * @tc.desc algorithm is Asym Key
1150 * @tc.size Medium
1151 * @tc.type Func
1152 * @tc.level Level0
1153 */
1154 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1600, TestSize.Level0)
1155 {
1156 OH_CryptoSm2CiphertextSpec *spec = nullptr;
1157 uint8_t c1_y_data[] = {
1158 0x2c, 0x6d, 0x13, 0x4c, 0x96, 0x80, 0x38, 0x19, 0xc4, 0x6c, 0xde, 0x46, 0xe3, 0xd5, 0x57, 0xed,
1159 0x77, 0xf6, 0x73, 0x9b, 0xe1, 0xd2, 0x17, 0xb3, 0x5e, 0xae, 0x82, 0x59, 0xda, 0x6f, 0xc6, 0x7
1160 };
1161 uint8_t c2_data[] = {
1162 0xf5, 0x89, 0xc8, 0xb5, 0xdf, 0xc6, 0x5e, 0x12, 0xc8, 0x55, 0x6a, 0x1c, 0xe4, 0x6f, 0x47, 0x32
1163 };
1164 uint8_t c3_data[] = {
1165 0xf0, 0xb2, 0x80, 0xed, 0x0b, 0xbe, 0xac, 0xac, 0x80, 0x1c, 0x3c, 0xe0, 0xaa, 0x9f, 0x01, 0x47,
1166 0xfc, 0xd7, 0x86, 0x1d, 0x33, 0x21, 0x2b, 0x36, 0xeb, 0x8f, 0x16, 0x36, 0x94, 0x1a, 0x4d, 0xaf
1167 };
1168 Crypto_DataBlob c1_y = {.data = c1_y_data, .len = sizeof(c1_y_data)/sizeof(c1_y_data[0])};
1169 Crypto_DataBlob c2 = {.data = c2_data, .len = sizeof(c2_data)/sizeof(c2_data[0])};
1170 Crypto_DataBlob c3 = {.data = c3_data, .len = sizeof(c3_data)/sizeof(c3_data[0])};
1171 Crypto_DataBlob sm2Ciphertext = {.data = nullptr, .len = 0};
1172
1173 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Create(nullptr, &spec), CRYPTO_SUCCESS);
1174 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_Y, &c1_y), CRYPTO_SUCCESS);
1175 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C2, &c2), CRYPTO_SUCCESS);
1176 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C3, &c3), CRYPTO_SUCCESS);
1177 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Encode(spec, &sm2Ciphertext), CRYPTO_PARAMETER_CHECK_FAILED);
1178
1179 OH_CryptoSm2CiphertextSpec_Destroy(spec);
1180 OH_Crypto_FreeDataBlob(&sm2Ciphertext);
1181 }
1182
1183 /**
1184 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1700
1185 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1700
1186 * @tc.desc algorithm is Asym Key
1187 * @tc.size Medium
1188 * @tc.type Func
1189 * @tc.level Level0
1190 */
1191 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1700, TestSize.Level0)
1192 {
1193 OH_CryptoSm2CiphertextSpec *spec = nullptr;
1194 uint8_t c1_x_data[] = {
1195 0x8c, 0x02, 0xe9, 0x71, 0x5e, 0x24, 0x18, 0x1c, 0x04, 0x0b, 0xc9, 0x0e, 0x57, 0x1b, 0x3e, 0xdc,
1196 0xc9, 0x50, 0x17, 0x78, 0x99, 0x23, 0x36, 0x2e, 0x3c, 0xf3, 0xcc, 0xac, 0xd3, 0xa5, 0x17, 0x9b
1197 };
1198 uint8_t c1_y_data[] = {
1199 0x2c, 0x6d, 0x13, 0x4c, 0x96, 0x80, 0x38, 0x19, 0xc4, 0x6c, 0xde, 0x46, 0xe3, 0xd5, 0x57, 0xed,
1200 0x77, 0xf6, 0x73, 0x9b, 0xe1, 0xd2, 0x17, 0xb3, 0x5e, 0xae, 0x82, 0x59, 0xda, 0x6f, 0xc6, 0x7
1201 };
1202 uint8_t c3_data[] = {
1203 0xf0, 0xb2, 0x80, 0xed, 0x0b, 0xbe, 0xac, 0xac, 0x80, 0x1c, 0x3c, 0xe0, 0xaa, 0x9f, 0x01, 0x47,
1204 0xfc, 0xd7, 0x86, 0x1d, 0x33, 0x21, 0x2b, 0x36, 0xeb, 0x8f, 0x16, 0x36, 0x94, 0x1a, 0x4d, 0xaf
1205 };
1206 Crypto_DataBlob c1_x = {.data = c1_x_data, .len = sizeof(c1_x_data)/sizeof(c1_x_data[0])};
1207 Crypto_DataBlob c1_y = {.data = c1_y_data, .len = sizeof(c1_y_data)/sizeof(c1_y_data[0])};
1208 Crypto_DataBlob c3 = {.data = c3_data, .len = sizeof(c3_data)/sizeof(c3_data[0])};
1209 Crypto_DataBlob sm2Ciphertext = {.data = nullptr, .len = 0};
1210
1211 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Create(nullptr, &spec), CRYPTO_SUCCESS);
1212 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_X, &c1_x), CRYPTO_SUCCESS);
1213 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_Y, &c1_y), CRYPTO_SUCCESS);
1214 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C3, &c3), CRYPTO_SUCCESS);
1215 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Encode(spec, &sm2Ciphertext), CRYPTO_PARAMETER_CHECK_FAILED);
1216
1217 OH_CryptoSm2CiphertextSpec_Destroy(spec);
1218 OH_Crypto_FreeDataBlob(&sm2Ciphertext);
1219 }
1220
1221 /**
1222 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1800
1223 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1800
1224 * @tc.desc algorithm is Asym Key
1225 * @tc.size Medium
1226 * @tc.type Func
1227 * @tc.level Level0
1228 */
1229 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1800, TestSize.Level0)
1230 {
1231 OH_CryptoSm2CiphertextSpec *spec = nullptr;
1232 uint8_t c1_x_data[] = {
1233 0x8c, 0x02, 0xe9, 0x71, 0x5e, 0x24, 0x18, 0x1c, 0x04, 0x0b, 0xc9, 0x0e, 0x57, 0x1b, 0x3e, 0xdc,
1234 0xc9, 0x50, 0x17, 0x78, 0x99, 0x23, 0x36, 0x2e, 0x3c, 0xf3, 0xcc, 0xac, 0xd3, 0xa5, 0x17, 0x9b
1235 };
1236 uint8_t c2_data[] = {
1237 0xf5, 0x89, 0xc8, 0xb5, 0xdf, 0xc6, 0x5e, 0x12, 0xc8, 0x55, 0x6a, 0x1c, 0xe4, 0x6f, 0x47, 0x32
1238 };
1239 uint8_t c3_data[] = {
1240 0xf0, 0xb2, 0x80, 0xed, 0x0b, 0xbe, 0xac, 0xac, 0x80, 0x1c, 0x3c, 0xe0, 0xaa, 0x9f, 0x01, 0x47,
1241 0xfc, 0xd7, 0x86, 0x1d, 0x33, 0x21, 0x2b, 0x36, 0xeb, 0x8f, 0x16, 0x36, 0x94, 0x1a, 0x4d, 0xaf
1242 };
1243 Crypto_DataBlob c1_x = {.data = c1_x_data, .len = sizeof(c1_x_data)/sizeof(c1_x_data[0])};
1244 Crypto_DataBlob c2 = {.data = c2_data, .len = sizeof(c2_data)/sizeof(c2_data[0])};
1245 Crypto_DataBlob c3 = {.data = c3_data, .len = sizeof(c3_data)/sizeof(c3_data[0])};
1246 Crypto_DataBlob sm2Ciphertext = {.data = nullptr, .len = 0};
1247
1248 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Create(nullptr, &spec), CRYPTO_SUCCESS);
1249 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_X, &c1_x), CRYPTO_SUCCESS);
1250 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C2, &c2), CRYPTO_SUCCESS);
1251 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C3, &c3), CRYPTO_SUCCESS);
1252 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Encode(spec, &sm2Ciphertext), CRYPTO_PARAMETER_CHECK_FAILED);
1253
1254 OH_CryptoSm2CiphertextSpec_Destroy(spec);
1255 OH_Crypto_FreeDataBlob(&sm2Ciphertext);
1256 }
1257
1258 /**
1259 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1900
1260 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1900
1261 * @tc.desc algorithm is Asym Key
1262 * @tc.size Medium
1263 * @tc.type Func
1264 * @tc.level Level0
1265 */
1266 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_1900, TestSize.Level0)
1267 {
1268 OH_CryptoSm2CiphertextSpec *spec = nullptr;
1269 uint8_t c1_x_data[] = {
1270 0x8c, 0x02, 0xe9, 0x71, 0x5e, 0x24, 0x18, 0x1c, 0x04, 0x0b, 0xc9, 0x0e, 0x57, 0x1b, 0x3e, 0xdc,
1271 0xc9, 0x50, 0x17, 0x78, 0x99, 0x23, 0x36, 0x2e, 0x3c, 0xf3, 0xcc, 0xac, 0xd3, 0xa5, 0x17, 0x9b
1272 };
1273 uint8_t c1_y_data[] = {
1274 0x2c, 0x6d, 0x13, 0x4c, 0x96, 0x80, 0x38, 0x19, 0xc4, 0x6c, 0xde, 0x46, 0xe3, 0xd5, 0x57, 0xed,
1275 0x77, 0xf6, 0x73, 0x9b, 0xe1, 0xd2, 0x17, 0xb3, 0x5e, 0xae, 0x82, 0x59, 0xda, 0x6f, 0xc6, 0x7
1276 };
1277 uint8_t c2_data[] = {
1278 0xf5, 0x89, 0xc8, 0xb5, 0xdf, 0xc6, 0x5e, 0x12, 0xc8, 0x55, 0x6a, 0x1c, 0xe4, 0x6f, 0x47, 0x32
1279 };
1280 Crypto_DataBlob c1_x = {.data = c1_x_data, .len = sizeof(c1_x_data)/sizeof(c1_x_data[0])};
1281 Crypto_DataBlob c1_y = {.data = c1_y_data, .len = sizeof(c1_y_data)/sizeof(c1_y_data[0])};
1282 Crypto_DataBlob c2 = {.data = c2_data, .len = sizeof(c2_data)/sizeof(c2_data[0])};
1283 Crypto_DataBlob sm2Ciphertext = {.data = nullptr, .len = 0};
1284
1285 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Create(nullptr, &spec), CRYPTO_SUCCESS);
1286 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_X, &c1_x), CRYPTO_SUCCESS);
1287 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_Y, &c1_y), CRYPTO_SUCCESS);
1288 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C2, &c2), CRYPTO_SUCCESS);
1289 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Encode(spec, &sm2Ciphertext), CRYPTO_PARAMETER_CHECK_FAILED);
1290
1291 OH_CryptoSm2CiphertextSpec_Destroy(spec);
1292 OH_Crypto_FreeDataBlob(&sm2Ciphertext);
1293 }
1294
1295 /**
1296 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_2000
1297 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_2000
1298 * @tc.desc algorithm is Asym Key
1299 * @tc.size Medium
1300 * @tc.type Func
1301 * @tc.level Level0
1302 */
1303 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_2000, TestSize.Level0)
1304 {
1305 OH_CryptoSm2CiphertextSpec *spec = nullptr;
1306 uint8_t data1[] = {
1307 0x30, 0x79, 0x02, 0x20, 0x9b, 0x17, 0xa5, 0xd3, 0xac, 0xcc, 0xf3, 0x3c, 0x2e, 0x36, 0x23,
1308 0x99, 0x78, 0x17, 0x50, 0xc9, 0xdc, 0x3e, 0x1b, 0x57, 0x0e, 0xc9, 0x0b, 0x04, 0x1c, 0x18, 0x24,
1309 0x5e, 0x71, 0xe9, 0x02, 0x8c, 0x02, 0x20, 0x78, 0xc6, 0x6f, 0xda, 0x59, 0x82, 0xae, 0x5e, 0xb3,
1310 0x17, 0xd2, 0xe1, 0x9b, 0x73, 0xf6, 0x77, 0xed, 0x57, 0xd5, 0xe3, 0x46, 0xde, 0x6c, 0xc4, 0x19,
1311 0x38, 0x80, 0x96, 0x4c, 0x13, 0x6d, 0x2c, 0x04, 0x20, 0xf0, 0xb2, 0x80, 0xed, 0x0b, 0xbe, 0xac,
1312 0xac, 0x80, 0x1c, 0x3c, 0xe0, 0xaa, 0x9f, 0x01, 0x47, 0xfc, 0xd7, 0x86, 0x1d, 0x33, 0x21, 0x2b,
1313 0x36, 0xeb, 0x8f, 0x16, 0x36, 0x94, 0x1a, 0x4d, 0xaf, 0x04, 0x10, 0xf5, 0x89, 0xc8, 0xb5, 0xdf,
1314 0xc6, 0x5e, 0x12, 0xc8, 0x55, 0x6a, 0x1c, 0xe4, 0x6f, 0x47, 0x32
1315 };
1316 uint8_t data2[] = {
1317 0x31, 0x79, 0x02, 0x21, 0x00, 0x9b, 0x17, 0xa5, 0xd3, 0xac, 0xcc, 0xf3, 0x3c, 0x2e, 0x36, 0x23,
1318 0x99, 0x78, 0x17, 0x50, 0xc9, 0xdc, 0x3e, 0x1b, 0x57, 0x0e, 0xc9, 0x0b, 0x04, 0x1c, 0x18, 0x24,
1319 0x5e, 0x71, 0xe9, 0x02, 0x8c, 0x02, 0x20, 0x78, 0xc6, 0x6f, 0xda, 0x59, 0x82, 0xae, 0x5e, 0xb3,
1320 0x17, 0xd2, 0xe1, 0x9b, 0x73, 0xf6, 0x77, 0xed, 0x57, 0xd5, 0xe3, 0x46, 0xde, 0x6c, 0xc4, 0x19,
1321 0x38, 0x80, 0x96, 0x4c, 0x13, 0x6d, 0x2c, 0x04, 0x20, 0xf0, 0xb2, 0x80, 0xed, 0x0b, 0xbe, 0xac,
1322 0xac, 0x80, 0x1c, 0x3c, 0xe0, 0xaa, 0x9f, 0x01, 0x47, 0xfc, 0xd7, 0x86, 0x1d, 0x33, 0x21, 0x2b,
1323 0x36, 0xeb, 0x8f, 0x16, 0x36, 0x94, 0x1a, 0x4d, 0xaf, 0x04, 0x10, 0xf5, 0x89, 0xc8, 0xb5, 0xdf,
1324 0xc6, 0x5e, 0x12, 0xc8, 0x55, 0x6a, 0x1c, 0xe4, 0x6f, 0x47, 0x32
1325 };
1326 uint8_t data3[] = {
1327 0x30, 0x80, 0x02, 0x21, 0x00, 0x9b, 0x17, 0xa5, 0xd3, 0xac, 0xcc, 0xf3, 0x3c, 0x2e, 0x36, 0x23,
1328 0x99, 0x78, 0x17, 0x50, 0xc9, 0xdc, 0x3e, 0x1b, 0x57, 0x0e, 0xc9, 0x0b, 0x04, 0x1c, 0x18, 0x24,
1329 0x5e, 0x71, 0xe9, 0x02, 0x8c, 0x02, 0x20, 0x78, 0xc6, 0x6f, 0xda, 0x59, 0x82, 0xae, 0x5e, 0xb3,
1330 0x17, 0xd2, 0xe1, 0x9b, 0x73, 0xf6, 0x77, 0xed, 0x57, 0xd5, 0xe3, 0x46, 0xde, 0x6c, 0xc4, 0x19,
1331 0x38, 0x80, 0x96, 0x4c, 0x13, 0x6d, 0x2c, 0x04, 0x20, 0xf0, 0xb2, 0x80, 0xed, 0x0b, 0xbe, 0xac,
1332 0xac, 0x80, 0x1c, 0x3c, 0xe0, 0xaa, 0x9f, 0x01, 0x47, 0xfc, 0xd7, 0x86, 0x1d, 0x33, 0x21, 0x2b,
1333 0x36, 0xeb, 0x8f, 0x16, 0x36, 0x94, 0x1a, 0x4d, 0xaf, 0x04, 0x10, 0xf5, 0x89, 0xc8, 0xb5, 0xdf,
1334 0xc6, 0x5e, 0x12, 0xc8, 0x55, 0x6a, 0x1c, 0xe4, 0x6f, 0x47, 0x32
1335 };
1336 uint8_t data4[] = {
1337 0x30, 0x79, 0x02, 0x21, 0x00, 0x9b, 0x17, 0xa5, 0xd3, 0xac, 0xcc, 0xf3, 0x3c, 0x2e, 0x36, 0x23,
1338 0x99, 0x78, 0x17, 0x50, 0xc9, 0xdc, 0x3e, 0x1b, 0x57, 0x0e, 0xc9, 0x0b, 0x04, 0x1c, 0x18, 0x24,
1339 0x5e, 0x71, 0xe9, 0x02, 0x8c, 0x02, 0x21, 0x00, 0x78, 0xc6, 0x6f, 0xda, 0x59, 0x82, 0xae, 0x5e, 0xb3,
1340 0x17, 0xd2, 0xe1, 0x9b, 0x73, 0xf6, 0x77, 0xed, 0x57, 0xd5, 0xe3, 0x46, 0xde, 0x6c, 0xc4, 0x19,
1341 0x38, 0x80, 0x96, 0x4c, 0x13, 0x6d, 0x2c, 0x04, 0x20, 0xf0, 0xb2, 0x80, 0xed, 0x0b, 0xbe, 0xac,
1342 0xac, 0x80, 0x1c, 0x3c, 0xe0, 0xaa, 0x9f, 0x01, 0x47, 0xfc, 0xd7, 0x86, 0x1d, 0x33, 0x21, 0x2b,
1343 0x36, 0xeb, 0x8f, 0x16, 0x36, 0x94, 0x1a, 0x4d, 0xaf, 0x04, 0x10, 0xf5, 0x89, 0xc8, 0xb5, 0xdf,
1344 0xc6, 0x5e, 0x12, 0xc8, 0x55, 0x6a, 0x1c, 0xe4, 0x6f, 0x47, 0x32
1345 };
1346 Crypto_DataBlob sm2Ciphertext1 = {.data = data1, .len = sizeof(data1)/sizeof(data1[0])};
1347 Crypto_DataBlob sm2Ciphertext2 = {.data = data2, .len = sizeof(data2)/sizeof(data2[0])};
1348 Crypto_DataBlob sm2Ciphertext3 = {.data = data3, .len = sizeof(data3)/sizeof(data3[0])};
1349 Crypto_DataBlob sm2Ciphertext4 = {.data = data4, .len = sizeof(data4)/sizeof(data4[0])};
1350
1351 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Create(&sm2Ciphertext1, &spec), CRYPTO_OPERTION_ERROR);
1352 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Create(&sm2Ciphertext2, &spec), CRYPTO_OPERTION_ERROR);
1353 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Create(&sm2Ciphertext3, &spec), CRYPTO_OPERTION_ERROR);
1354 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Create(&sm2Ciphertext4, &spec), CRYPTO_OPERTION_ERROR);
1355
1356 OH_CryptoSm2CiphertextSpec_Destroy(spec);
1357 }
1358
1359 /**
1360 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_2100
1361 * @tc.name OHCryptoFrameworkAsymCipherNapiTest.SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_2100
1362 * @tc.desc algorithm is Asym Key
1363 * @tc.size Medium
1364 * @tc.type Func
1365 * @tc.level Level0
1366 */
1367 HWTEST_F(OHCryptoFrameworkAsymCipherNapiTest, SUB_Security_CryptoFramework_NAPI_AsymCiphery_Test_2100, TestSize.Level0)
1368 {
1369 OH_CryptoSm2CiphertextSpec *spec = nullptr;
1370 uint8_t c1_x_data[] = {
1371 0x8c, 0x02, 0xe9, 0x71, 0x5e, 0x24, 0x18, 0x1c, 0x04, 0x0b, 0xc9, 0x0e, 0x57, 0x1b, 0x3e, 0xdc,
1372 0xc9, 0x50, 0x17, 0x78, 0x99, 0x23, 0x36, 0x2e, 0x3c, 0xf3, 0xcc, 0xac, 0xd3, 0xa5, 0x17, 0x9b
1373 };
1374 uint8_t c1_y_data[] = {
1375 0x2c, 0x6d, 0x13, 0x4c, 0x96, 0x80, 0x38, 0x19, 0xc4, 0x6c, 0xde, 0x46, 0xe3, 0xd5, 0x57, 0xed,
1376 0x77, 0xf6, 0x73, 0x9b, 0xe1, 0xd2, 0x17, 0xb3, 0x5e, 0xae, 0x82, 0x59, 0xda, 0x6f, 0xc6, 0x7
1377 };
1378 uint8_t c2_data[] = {
1379 0xf5, 0x89, 0xc8, 0xb5, 0xdf, 0xc6, 0x5e, 0x12, 0xc8, 0x55, 0x6a, 0x1c, 0xe4, 0x6f, 0x47, 0x32
1380 };
1381 uint8_t c3_data[] = {
1382 0xf0, 0xb2, 0x80, 0xed, 0x0b, 0xbe, 0xac, 0xac, 0x80, 0x1c, 0x3c, 0xe0, 0xaa, 0x9f, 0x01, 0x47,
1383 0xfc, 0xd7, 0x86, 0x1d, 0x33, 0x21, 0x2b, 0x36, 0xeb, 0x8f, 0x16, 0x36, 0x94,
1384 };
1385 Crypto_DataBlob c1_x = {.data = c1_x_data, .len = sizeof(c1_x_data)/sizeof(c1_x_data[0])};
1386 Crypto_DataBlob c1_y = {.data = c1_y_data, .len = sizeof(c1_y_data)/sizeof(c1_y_data[0])};
1387 Crypto_DataBlob c2 = {.data = c2_data, .len = sizeof(c2_data)/sizeof(c2_data[0])};
1388 Crypto_DataBlob c3 = {.data = c3_data, .len = sizeof(c3_data)/sizeof(c3_data[0])};
1389 Crypto_DataBlob sm2Ciphertext = {.data = nullptr, .len = 0};
1390
1391 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Create(nullptr, &spec), CRYPTO_SUCCESS);
1392 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_X, &c1_x), CRYPTO_SUCCESS);
1393 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C1_Y, &c1_y), CRYPTO_SUCCESS);
1394 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C2, &c2), CRYPTO_SUCCESS);
1395 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_SetItem(spec, CRYPTO_SM2_CIPHERTEXT_C3, &c3), CRYPTO_SUCCESS);
1396 EXPECT_EQ(OH_CryptoSm2CiphertextSpec_Encode(spec, &sm2Ciphertext), CRYPTO_PARAMETER_CHECK_FAILED);
1397
1398 OH_CryptoSm2CiphertextSpec_Destroy(spec);
1399 OH_Crypto_FreeDataBlob(&sm2Ciphertext);
1400 }
1401
1402 } // namespace Unittest::CryptoFrameworkAsymCipherNapiTest
1403