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_aes_cipher_test_common.h"
17
18 #include <gtest/gtest.h>
19
HksAesCipherTestEncrypt(const struct HksBlob * keyAlias,const struct HksParamSet * encryptParamSet,const struct HksBlob * inData,struct HksBlob * cipherText)20 int32_t Unittest::AesCipher::HksAesCipherTestEncrypt(const struct HksBlob *keyAlias,
21 const struct HksParamSet *encryptParamSet, const struct HksBlob *inData, struct HksBlob *cipherText)
22 {
23 uint8_t handleE[sizeof(uint64_t)] = {0};
24 struct HksBlob handleEncrypt = { sizeof(uint64_t), handleE };
25 int32_t ret = HksInit(keyAlias, encryptParamSet, &handleEncrypt);
26 EXPECT_EQ(ret, HKS_SUCCESS) << "Init failed.";
27 if (ret != HKS_SUCCESS) {
28 return ret;
29 }
30
31 ret = TestUpdateLoopFinish(&handleEncrypt, encryptParamSet, inData, cipherText);
32 EXPECT_EQ(ret, HKS_SUCCESS) << "TestUpdateLoopFinish failed.";
33 if (ret != HKS_SUCCESS) {
34 return ret;
35 }
36 EXPECT_NE(HksMemCmp(inData->data, cipherText->data, inData->size), HKS_SUCCESS) << "cipherText equals inData";
37
38 uint8_t tmpOut[Unittest::AesCipher::AES_COMMON_SIZE] = {0};
39 struct HksBlob outData = { Unittest::AesCipher::AES_COMMON_SIZE, tmpOut };
40 ret = HksEncrypt(keyAlias, encryptParamSet, inData, &outData);
41 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEncrypt failed.";
42 if (ret != HKS_SUCCESS) {
43 return ret;
44 }
45 EXPECT_EQ(HksMemCmp(outData.data, cipherText->data, outData.size), HKS_SUCCESS) << "cipherText not equals outData";
46
47 return HKS_SUCCESS;
48 }
49
HksAesCipherTestDecrypt(const struct HksBlob * keyAlias,const struct HksParamSet * decryptParamSet,const struct HksBlob * cipherText,struct HksBlob * plainText,const struct HksBlob * inData)50 int32_t Unittest::AesCipher::HksAesCipherTestDecrypt(const struct HksBlob *keyAlias,
51 const struct HksParamSet *decryptParamSet, const struct HksBlob *cipherText, struct HksBlob *plainText,
52 const struct HksBlob *inData)
53 {
54 uint8_t handleD[sizeof(uint64_t)] = {0};
55 struct HksBlob handleDecrypt = { sizeof(uint64_t), handleD };
56 int32_t ret = HksInit(keyAlias, decryptParamSet, &handleDecrypt);
57 EXPECT_EQ(ret, HKS_SUCCESS) << "Init failed.";
58 if (ret != HKS_SUCCESS) {
59 return ret;
60 }
61
62 ret = TestUpdateLoopFinish(&handleDecrypt, decryptParamSet, cipherText, plainText);
63 EXPECT_EQ(ret, HKS_SUCCESS) << "TestUpdateLoopFinish failed.";
64 if (ret != HKS_SUCCESS) {
65 return ret;
66 }
67 EXPECT_EQ(HksMemCmp(inData->data, plainText->data, inData->size), HKS_SUCCESS) << "plainText not equals inData";
68
69 uint8_t tmpOut[Unittest::AesCipher::AES_COMMON_SIZE] = {0};
70 struct HksBlob outData = { Unittest::AesCipher::AES_COMMON_SIZE, tmpOut };
71 ret = HksDecrypt(keyAlias, decryptParamSet, cipherText, &outData);
72 EXPECT_EQ(ret, HKS_SUCCESS) << "HksDecrypt failed.";
73 if (ret != HKS_SUCCESS) {
74 return ret;
75 }
76 EXPECT_EQ(HksMemCmp(outData.data, plainText->data, outData.size), HKS_SUCCESS) << "plainText not equals outData";
77
78 return HKS_SUCCESS;
79 }
80
HksAesCipherTestCaseOther(const struct HksBlob * keyAlias,struct HksParamSet * genParamSet,struct HksParamSet * encryptParamSet,struct HksParamSet * decryptParamSet)81 int32_t Unittest::AesCipher::HksAesCipherTestCaseOther(const struct HksBlob *keyAlias, struct HksParamSet *genParamSet,
82 struct HksParamSet *encryptParamSet, struct HksParamSet *decryptParamSet)
83 {
84 char tmpInData[] = "AES_ECB_INDATA_1";
85 struct HksBlob inData = {
86 Unittest::AesCipher::g_inData.length(),
87 (uint8_t *)Unittest::AesCipher::g_inData.c_str()
88 };
89
90 struct HksParam *modeParam = nullptr;
91 HksGetParam(genParamSet, HKS_TAG_BLOCK_MODE, &modeParam);
92 if (modeParam->uint32Param == HKS_MODE_ECB) {
93 inData.size = strlen(tmpInData);
94 inData.data = (uint8_t *)tmpInData;
95 }
96
97 /* 1. Generate Key */
98 int32_t ret = HksGenerateKey(keyAlias, genParamSet, nullptr);
99 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey failed.";
100 if (ret != HKS_SUCCESS) {
101 return ret;
102 }
103
104 /* 2. Encrypt */
105 uint8_t cipher[Unittest::AesCipher::AES_COMMON_SIZE] = {0};
106 struct HksBlob cipherText = { Unittest::AesCipher::AES_COMMON_SIZE, cipher };
107 ret = HksAesCipherTestEncrypt(keyAlias, encryptParamSet, &inData, &cipherText);
108 EXPECT_EQ(ret, HKS_SUCCESS) << "HksAesCipherTestEncrypt failed.";
109
110 /* 3. Decrypt Three Stage */
111 uint8_t plain[Unittest::AesCipher::AES_COMMON_SIZE] = {0};
112 struct HksBlob plainText = { Unittest::AesCipher::AES_COMMON_SIZE, plain };
113 ret = HksAesCipherTestDecrypt(keyAlias, decryptParamSet, &cipherText, &plainText, &inData);
114 EXPECT_EQ(ret, HKS_SUCCESS) << "HksAesCipherTestDecrypt failed.";
115
116 /* 3. Delete Key */
117 EXPECT_EQ(HksDeleteKey(keyAlias, genParamSet), HKS_SUCCESS) << "DeleteKey failed.";
118 return ret;
119 }
120
121 #if defined(_USE_OPENSSL_) && defined(_USE_MBEDTLS_)
HksAESCipherTestCaseCcm(const struct HksBlob * keyAlias,struct HksParamSet * genParamSet,struct HksParamSet * encryptParamSet,struct HksParamSet * decryptParamSet)122 int32_t Unittest::AesCipher::HksAESCipherTestCaseCcm(const struct HksBlob *keyAlias, struct HksParamSet *genParamSet,
123 struct HksParamSet *encryptParamSet, struct HksParamSet *decryptParamSet)
124 {
125 struct HksBlob inData = {
126 Unittest::AesCipher::g_inData.length(),
127 (uint8_t *)Unittest::AesCipher::g_inData.c_str()
128 };
129
130 /* 1. Generate Key */
131 int32_t ret = HksGenerateKey(keyAlias, genParamSet, nullptr);
132 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey failed.";
133 if (ret != HKS_SUCCESS) {
134 return ret;
135 }
136
137 /* 2. Encrypt Three Stage */
138 uint8_t cipher[Unittest::AesCipher::AES_COMMON_SIZE] = {0};
139 struct HksBlob cipherText = { Unittest::AesCipher::AES_COMMON_SIZE, cipher };
140 ret = HksAesCipherTestEncrypt(keyAlias, encryptParamSet, &inData, &cipherText);
141 EXPECT_EQ(ret, HKS_SUCCESS) << "HksAesCipherTestEncrypt failed.";
142 cipherText.size -= Unittest::AesCipher::AEAD_SIZE;
143
144 /* 3. Decrypt Three Stage */
145 uint8_t plain[Unittest::AesCipher::AES_COMMON_SIZE] = {0};
146 struct HksBlob plainText = { Unittest::AesCipher::AES_COMMON_SIZE, plain };
147 ret = HksAesCipherTestDecrypt(keyAlias, decryptParamSet, &cipherText, &plainText, &inData);
148 EXPECT_EQ(ret, HKS_SUCCESS) << "HksAesCipherTestDecrypt failed.";
149
150 /* 3. Delete Key */
151 EXPECT_EQ(HksDeleteKey(keyAlias, genParamSet), HKS_SUCCESS) << "DeleteKey failed.";
152 return ret;
153 }
154 #endif
155
HksAesCipherTestCaseGcm(const struct HksBlob * keyAlias,struct HksParamSet * genParamSet,struct HksParamSet * encryptParamSet,struct HksParamSet * decryptParamSet,struct HksParamSet * decrypt1ParamSet)156 int32_t Unittest::AesCipher::HksAesCipherTestCaseGcm(const struct HksBlob *keyAlias, struct HksParamSet *genParamSet,
157 struct HksParamSet *encryptParamSet, struct HksParamSet *decryptParamSet, struct HksParamSet *decrypt1ParamSet)
158 {
159 struct HksBlob inData = {
160 Unittest::AesCipher::g_inData.length(),
161 (uint8_t *)Unittest::AesCipher::g_inData.c_str()
162 };
163
164 /* 1. Generate Key */
165 int32_t ret = HksGenerateKey(keyAlias, genParamSet, nullptr);
166 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey failed.";
167 if (ret != HKS_SUCCESS) {
168 return ret;
169 }
170
171 /* 2. Encrypt Three Stage */
172 uint8_t cipher[Unittest::AesCipher::AES_COMMON_SIZE] = {0};
173 struct HksBlob cipherText = { Unittest::AesCipher::AES_COMMON_SIZE, cipher };
174 ret = HksAesCipherTestEncrypt(keyAlias, encryptParamSet, &inData, &cipherText);
175 EXPECT_EQ(ret, HKS_SUCCESS) << "HksAesCipherTestEncrypt failed.";
176
177 uint8_t plain1[Unittest::AesCipher::AES_COMMON_SIZE] = {0};
178 struct HksBlob plainText1 = { Unittest::AesCipher::AES_COMMON_SIZE, plain1 };
179 ret = HksDecrypt(keyAlias, decrypt1ParamSet, &cipherText, &plainText1);
180 EXPECT_EQ(ret, HKS_SUCCESS) << "HksDecrypt failed.";
181
182 cipherText.size -= Unittest::AesCipher::AEAD_SIZE;
183
184 uint32_t i = 0;
185 for (i = 0; i < decryptParamSet->paramsCnt; i++) {
186 if (decryptParamSet->params[i].tag == HKS_TAG_AE_TAG) {
187 uint8_t *tempPtr = cipherText.data;
188 (void)memcpy_s(decryptParamSet->params[i].blob.data, Unittest::AesCipher::AEAD_SIZE,
189 tempPtr + cipherText.size, Unittest::AesCipher::AEAD_SIZE);
190 break;
191 }
192 }
193
194 /* 3. Decrypt Three Stage */
195 // Init
196 uint8_t handleD[sizeof(uint64_t)] = {0};
197 struct HksBlob handleDecrypt = { sizeof(uint64_t), handleD };
198 ret = HksInit(keyAlias, decryptParamSet, &handleDecrypt);
199 EXPECT_EQ(ret, HKS_SUCCESS) << "Init failed.";
200
201 // Update & Finish
202 uint8_t plain[Unittest::AesCipher::AES_COMMON_SIZE] = {0};
203 struct HksBlob plainText = { Unittest::AesCipher::AES_COMMON_SIZE, plain };
204 ret = TestUpdateLoopFinish(&handleDecrypt, decryptParamSet, &cipherText, &plainText);
205 EXPECT_EQ(ret, HKS_SUCCESS) << "TestUpdateLoopFinish failed.";
206 EXPECT_EQ(HksMemCmp(inData.data, plainText.data, inData.size), HKS_SUCCESS) << "plainText not equals inData";
207 EXPECT_EQ(HksMemCmp(plainText1.data, plainText.data, plainText1.size), HKS_SUCCESS) << "plainText != plainText1";
208
209 /* 3. Delete Key */
210 EXPECT_EQ(HksDeleteKey(keyAlias, genParamSet), HKS_SUCCESS) << "DeleteKey failed.";
211 return ret;
212 }