1 /*
2  * Copyright (C) 2021-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 "key_agree_sdk_test.h"
17 
18 #include <gtest/gtest.h>
19 #include "key_agree_sdk.h"
20 #include "hc_types.h"
21 #include "device_auth.h"
22 
23 using namespace std;
24 using namespace testing::ext;
25 
26 static const int32_t g_sessionIdClient = 1001;
27 static const int32_t g_sessionIdServer = 1002;
28 static const int32_t g_messageLength = 2048;
29 static const int32_t g_sharedSecretLength = 7;
30 static const int32_t g_deviceIdLength = 17;
31 static const int32_t g_sessionKeyLength = 64;
32 
33 static KeyAgreeSession *g_session;
34 static KeyAgreeSession *g_session_s;
35 static KeyAgreeBlob g_sharedSecret = { NULL, 0 };
36 static KeyAgreeBlob g_deviceId = { NULL, 0 };
37 static KeyAgreeBlob g_deviceId_s = { NULL, 0 };
38 static KeyAgreeBlob g_messageToTransmit1 = { NULL, 0 };
39 static KeyAgreeBlob g_messageToTransmit2 = { NULL, 0 };
40 static KeyAgreeBlob g_messageToTransmit3 = { NULL, 0 };
41 static KeyAgreeBlob g_messageToTransmit4 = { NULL, 0 };
42 static KeyAgreeBlob g_messageToTransmit5 = { NULL, 0 };
43 static KeyAgreeBlob g_sessionKey_s = { NULL, 0 };
44 static KeyAgreeBlob g_sessionKey = { NULL, 0 };
45 
46 class KeyAgreeInitSessionTest : public testing::Test {
47 public:
48     static void SetUpTestCase();
49     static void TearDownTestCase();
50     void SetUp();
51     void TearDown();
52 };
53 
SetUpTestCase()54 void KeyAgreeInitSessionTest::SetUpTestCase()
55 {
56     g_session = (KeyAgreeSession *)HcMalloc(sizeof(KeyAgreeSession), 0);
57     g_session_s = (KeyAgreeSession *)HcMalloc(sizeof(KeyAgreeSession), 0);
58 }
TearDownTestCase()59 void KeyAgreeInitSessionTest::TearDownTestCase()
60 {
61     HcFree(g_session);
62     HcFree(g_session_s);
63 }
SetUp()64 void KeyAgreeInitSessionTest::SetUp() {}
TearDown()65 void KeyAgreeInitSessionTest::TearDown()
66 {
67     KeyAgreeFreeSession(g_session);
68     KeyAgreeFreeSession(g_session_s);
69 }
70 
71 HWTEST_F(KeyAgreeInitSessionTest, KeyAgreeInitSessionTest001, TestSize.Level0)
72 {
73     g_session->sessionId = g_sessionIdClient;
74     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_ANY,
75         KEYAGREE_TYPE_CLIENT);
76     EXPECT_EQ(res, KEYAGREE_SUCCESS);
77 }
78 
79 HWTEST_F(KeyAgreeInitSessionTest, KeyAgreeInitSessionTest002, TestSize.Level0)
80 {
81     g_session_s->sessionId = g_sessionIdServer;
82     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session_s, KEYAGREE_PROTOCOL_ANY,
83         KEYAGREE_TYPE_SERVER);
84     EXPECT_EQ(res, KEYAGREE_SUCCESS);
85 }
86 
87 HWTEST_F(KeyAgreeInitSessionTest, KeyAgreeInitSessionTest003, TestSize.Level0)
88 {
89     g_session->sessionId = g_sessionIdClient;
90     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_DL_SPEKE_256,
91         KEYAGREE_TYPE_CLIENT);
92     EXPECT_EQ(res, KEYAGREE_SUCCESS);
93 }
94 
95 HWTEST_F(KeyAgreeInitSessionTest, KeyAgreeInitSessionTest004, TestSize.Level0)
96 {
97     g_session->sessionId = g_sessionIdClient;
98     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_DL_SPEKE_384,
99         KEYAGREE_TYPE_CLIENT);
100     EXPECT_EQ(res, KEYAGREE_SUCCESS);
101 }
102 
103 HWTEST_F(KeyAgreeInitSessionTest, KeyAgreeInitSessionTest005, TestSize.Level0)
104 {
105     g_session->sessionId = g_sessionIdClient;
106     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_EC_SPEKE_P256,
107         KEYAGREE_TYPE_CLIENT);
108     EXPECT_EQ(res, KEYAGREE_SUCCESS);
109 }
110 
111 HWTEST_F(KeyAgreeInitSessionTest, KeyAgreeInitSessionTest006, TestSize.Level0)
112 {
113     g_session->sessionId = g_sessionIdClient;
114     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_EC_SPEKE_X25519,
115         KEYAGREE_TYPE_CLIENT);
116     EXPECT_EQ(res, KEYAGREE_SUCCESS);
117 }
118 
119 HWTEST_F(KeyAgreeInitSessionTest, KeyAgreeInitSessionTest007, TestSize.Level0)
120 {
121     g_session->sessionId = g_sessionIdClient;
122     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, NULL, KEYAGREE_PROTOCOL_EC_SPEKE_X25519,
123         KEYAGREE_TYPE_CLIENT);
124     EXPECT_NE(res, KEYAGREE_SUCCESS);
125 }
126 
127 class KeyAgreeStartSessionTest : public testing::Test {
128 public:
129     static void SetUpTestCase();
130     static void TearDownTestCase();
131     void SetUp();
132     void TearDown();
133 };
134 
SetUpTestCase()135 void KeyAgreeStartSessionTest::SetUpTestCase()
136 {
137     g_session = (KeyAgreeSession *)HcMalloc(sizeof(KeyAgreeSession), 0);
138     g_session_s = (KeyAgreeSession *)HcMalloc(sizeof(KeyAgreeSession), 0);
139 
140     g_sharedSecret.length = g_sharedSecretLength;
141     g_sharedSecret.data = (uint8_t *)HcMalloc(g_sharedSecret.length, 0);
142     (void)memcpy_s(g_sharedSecret.data, g_sharedSecret.length, (uint8_t *)"123456", g_sharedSecretLength);
143 
144     g_deviceId.length = g_deviceIdLength;
145     g_deviceId.data = (uint8_t *)HcMalloc(g_deviceId.length, 0);
146     (void)memcpy_s(g_deviceId.data, g_deviceId.length, (uint8_t *)"clientclientabcd", g_deviceIdLength);
147 
148     g_deviceId_s.length = g_deviceIdLength;
149     g_deviceId_s.data = (uint8_t *)HcMalloc(g_deviceId_s.length, 0);
150     (void)memcpy_s(g_deviceId_s.data, g_deviceId_s.length, (uint8_t *)"serverserverabcd", g_deviceIdLength);
151 }
152 
TearDownTestCase()153 void KeyAgreeStartSessionTest::TearDownTestCase()
154 {
155     HcFree(g_session);
156     HcFree(g_session_s);
157     HcFree(g_sharedSecret.data);
158     HcFree(g_deviceId.data);
159     HcFree(g_deviceId_s.data);
160 }
SetUp()161 void KeyAgreeStartSessionTest::SetUp() {}
TearDown()162 void KeyAgreeStartSessionTest::TearDown()
163 {
164     KeyAgreeFreeSession(g_session);
165     KeyAgreeFreeSession(g_session_s);
166 }
167 
168 HWTEST_F(KeyAgreeStartSessionTest, KeyAgreeStartSessionTest001, TestSize.Level0)
169 {
170     g_session->sessionId = g_sessionIdClient;
171     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_ANY,
172         KEYAGREE_TYPE_CLIENT);
173     EXPECT_EQ(res, KEYAGREE_SUCCESS);
174 
175     res = KeyAgreeStartSession(g_session, &g_sharedSecret, &g_deviceId, NULL);
176     EXPECT_EQ(res, KEYAGREE_SUCCESS);
177 }
178 
179 HWTEST_F(KeyAgreeStartSessionTest, KeyAgreeStartSessionTest002, TestSize.Level0)
180 {
181     g_session->sessionId = g_sessionIdClient;
182     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_ANY,
183         KEYAGREE_TYPE_CLIENT);
184     EXPECT_EQ(res, KEYAGREE_SUCCESS);
185 
186     res = KeyAgreeStartSession(g_session, &g_sharedSecret, NULL, NULL);
187     EXPECT_NE(res, KEYAGREE_SUCCESS);
188 }
189 
190 HWTEST_F(KeyAgreeStartSessionTest, KeyAgreeStartSessionTest003, TestSize.Level0)
191 {
192     g_session->sessionId = g_sessionIdClient;
193     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_ANY,
194         KEYAGREE_TYPE_CLIENT);
195     EXPECT_EQ(res, KEYAGREE_SUCCESS);
196 
197     res = KeyAgreeStartSession(g_session, NULL, &g_deviceId, NULL);
198     EXPECT_NE(res, KEYAGREE_SUCCESS);
199 }
200 
201 HWTEST_F(KeyAgreeStartSessionTest, KeyAgreeStartSessionTest004, TestSize.Level0)
202 {
203     g_session->sessionId = g_sessionIdClient;
204     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_ANY,
205         KEYAGREE_TYPE_CLIENT);
206     EXPECT_EQ(res, KEYAGREE_SUCCESS);
207 
208     res = KeyAgreeStartSession(NULL, &g_sharedSecret, &g_deviceId, NULL);
209     EXPECT_NE(res, KEYAGREE_SUCCESS);
210 }
211 
212 class KeyAgreeGenerateNextMessageTest : public testing::Test {
213 public:
214     static void SetUpTestCase();
215     static void TearDownTestCase();
216     void SetUp();
217     void TearDown();
218 };
219 
SetUpTestCase()220 void KeyAgreeGenerateNextMessageTest::SetUpTestCase()
221 {
222     g_session = (KeyAgreeSession *)HcMalloc(sizeof(KeyAgreeSession), 0);
223     g_session_s = (KeyAgreeSession *)HcMalloc(sizeof(KeyAgreeSession), 0);
224 
225     g_sharedSecret.length = g_sharedSecretLength;
226     g_sharedSecret.data = (uint8_t *)HcMalloc(g_sharedSecret.length, g_sharedSecretLength);
227     (void)memcpy_s(g_sharedSecret.data, g_sharedSecret.length, (uint8_t *)"123456", g_sharedSecretLength);
228 
229     g_deviceId.length = g_deviceIdLength;
230     g_deviceId.data = (uint8_t *)HcMalloc(g_deviceId.length, 0);
231     (void)memcpy_s(g_deviceId.data, g_deviceId.length, (uint8_t *)"clientclientabcd", g_deviceIdLength);
232 
233     g_deviceId_s.length = g_deviceIdLength;
234     g_deviceId_s.data = (uint8_t *)HcMalloc(g_deviceId_s.length, 0);
235     (void)memcpy_s(g_deviceId_s.data, g_deviceId_s.length, (uint8_t *)"serverserverabcd", g_deviceIdLength);
236 }
TearDownTestCase()237 void KeyAgreeGenerateNextMessageTest::TearDownTestCase()
238 {
239     HcFree(g_session);
240     HcFree(g_session_s);
241     HcFree(g_sharedSecret.data);
242     HcFree(g_deviceId.data);
243     HcFree(g_deviceId_s.data);
244 }
SetUp()245 void KeyAgreeGenerateNextMessageTest::SetUp()
246 {
247     g_messageToTransmit1.length = g_messageLength;
248     g_messageToTransmit1.data = (uint8_t *)HcMalloc(g_messageToTransmit1.length, 0);
249 
250     g_messageToTransmit2.length = g_messageLength;
251     g_messageToTransmit2.data = (uint8_t *)HcMalloc(g_messageToTransmit2.length, 0);
252 
253     g_messageToTransmit3.length = g_messageLength;
254     g_messageToTransmit3.data = (uint8_t *)HcMalloc(g_messageToTransmit3.length, 0);
255 
256     g_messageToTransmit4.length = g_messageLength;
257     g_messageToTransmit4.data = (uint8_t *)HcMalloc(g_messageToTransmit4.length, 0);
258 
259     g_messageToTransmit5.length = g_messageLength;
260     g_messageToTransmit5.data = (uint8_t *)HcMalloc(g_messageToTransmit5.length, 0);
261 
262     g_sessionKey_s.length = g_sessionKeyLength;
263     g_sessionKey_s.data = (uint8_t *)HcMalloc(g_sessionKey_s.length, 0);
264 
265     g_sessionKey.length = g_sessionKeyLength;
266     g_sessionKey.data = (uint8_t *)HcMalloc(g_sessionKey.length, 0);
267 }
TearDown()268 void KeyAgreeGenerateNextMessageTest::TearDown()
269 {
270     HcFree(g_messageToTransmit1.data);
271     HcFree(g_messageToTransmit2.data);
272     HcFree(g_messageToTransmit3.data);
273     HcFree(g_messageToTransmit4.data);
274     HcFree(g_messageToTransmit5.data);
275     HcFree(g_sessionKey_s.data);
276     HcFree(g_sessionKey.data);
277     KeyAgreeFreeSession(g_session);
278     KeyAgreeFreeSession(g_session_s);
279 }
280 
281 HWTEST_F(KeyAgreeGenerateNextMessageTest, KeyAgreeGenerateNextMessageTest001, TestSize.Level0)
282 {
283     g_session->sessionId = g_sessionIdClient;
284     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_ANY,
285         KEYAGREE_TYPE_CLIENT);
286     EXPECT_EQ(res, KEYAGREE_SUCCESS);
287 
288     g_session_s->sessionId = g_sessionIdServer;
289     res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session_s, KEYAGREE_PROTOCOL_ANY, KEYAGREE_TYPE_SERVER);
290     EXPECT_EQ(res, KEYAGREE_SUCCESS);
291 
292     res = KeyAgreeStartSession(g_session, &g_sharedSecret, &g_deviceId, NULL);
293     EXPECT_EQ(res, KEYAGREE_SUCCESS);
294 
295     res = KeyAgreeStartSession(g_session_s, &g_sharedSecret, &g_deviceId_s, NULL);
296     EXPECT_EQ(res, KEYAGREE_SUCCESS);
297 
298     res = KeyAgreeGenerateNextMessage(g_session, NULL, &g_messageToTransmit1);
299     EXPECT_EQ(res, KEYAGREE_SUCCESS);
300 
301     res = KeyAgreeIsFinish(g_session);
302     EXPECT_NE(res, KEYAGREE_SUCCESS);
303 
304     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit1, &g_messageToTransmit2);
305     EXPECT_EQ(res, KEYAGREE_SUCCESS);
306 
307     res = KeyAgreeIsFinish(g_session_s);
308     EXPECT_NE(res, KEYAGREE_SUCCESS);
309 
310     res = KeyAgreeGenerateNextMessage(g_session, &g_messageToTransmit2, &g_messageToTransmit3);
311     EXPECT_EQ(res, KEYAGREE_SUCCESS);
312 
313     res = KeyAgreeIsFinish(g_session);
314     EXPECT_NE(res, KEYAGREE_SUCCESS);
315 
316     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit3, &g_messageToTransmit4);
317     EXPECT_EQ(res, KEYAGREE_SUCCESS);
318 
319     res = KeyAgreeIsFinish(g_session_s);
320     EXPECT_EQ(res, KEYAGREE_SUCCESS);
321 
322     res = KeyAgreeGetResult(g_session_s, &g_sessionKey_s);
323     EXPECT_EQ(res, KEYAGREE_SUCCESS);
324 
325     res = KeyAgreeGenerateNextMessage(g_session, &g_messageToTransmit4, &g_messageToTransmit5);
326     EXPECT_EQ(res, KEYAGREE_SUCCESS);
327 
328     res = KeyAgreeIsFinish(g_session);
329     EXPECT_EQ(res, KEYAGREE_SUCCESS);
330 
331     res = KeyAgreeGetResult(g_session, &g_sessionKey);
332     EXPECT_EQ(res, KEYAGREE_SUCCESS);
333 
334     EXPECT_EQ(*(g_sessionKey.data), *(g_sessionKey_s.data));
335 }
336 
337 HWTEST_F(KeyAgreeGenerateNextMessageTest, KeyAgreeGenerateNextMessageTest002, TestSize.Level0)
338 {
339     g_session->sessionId = g_sessionIdClient;
340     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_DL_SPEKE_256,
341         KEYAGREE_TYPE_CLIENT);
342     EXPECT_EQ(res, KEYAGREE_SUCCESS);
343 
344     g_session_s->sessionId = g_sessionIdServer;
345     res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session_s, KEYAGREE_PROTOCOL_DL_SPEKE_256, KEYAGREE_TYPE_SERVER);
346     EXPECT_EQ(res, KEYAGREE_SUCCESS);
347 
348     res = KeyAgreeStartSession(g_session, &g_sharedSecret, &g_deviceId, NULL);
349     EXPECT_EQ(res, KEYAGREE_SUCCESS);
350 
351     res = KeyAgreeStartSession(g_session_s, &g_sharedSecret, &g_deviceId_s, NULL);
352     EXPECT_EQ(res, KEYAGREE_SUCCESS);
353 
354     res = KeyAgreeGenerateNextMessage(g_session, NULL, &g_messageToTransmit1);
355     EXPECT_EQ(res, KEYAGREE_SUCCESS);
356 
357     res = KeyAgreeIsFinish(g_session);
358     EXPECT_NE(res, KEYAGREE_SUCCESS);
359 
360     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit1, &g_messageToTransmit2);
361     EXPECT_EQ(res, KEYAGREE_SUCCESS);
362 
363     res = KeyAgreeIsFinish(g_session_s);
364     EXPECT_NE(res, KEYAGREE_SUCCESS);
365 
366     res = KeyAgreeGenerateNextMessage(g_session, &g_messageToTransmit2, &g_messageToTransmit3);
367     EXPECT_EQ(res, KEYAGREE_SUCCESS);
368 
369     res = KeyAgreeIsFinish(g_session);
370     EXPECT_EQ(res, KEYAGREE_SUCCESS);
371 
372     res = KeyAgreeGetResult(g_session, &g_sessionKey);
373     EXPECT_EQ(res, KEYAGREE_SUCCESS);
374 
375     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit3, &g_messageToTransmit4);
376     EXPECT_EQ(res, KEYAGREE_SUCCESS);
377 
378     res = KeyAgreeIsFinish(g_session_s);
379     EXPECT_EQ(res, KEYAGREE_SUCCESS);
380 
381     res = KeyAgreeGetResult(g_session_s, &g_sessionKey_s);
382     EXPECT_EQ(res, KEYAGREE_SUCCESS);
383 
384     EXPECT_EQ(*(g_sessionKey.data), *(g_sessionKey_s.data));
385 }
386 
387 HWTEST_F(KeyAgreeGenerateNextMessageTest, KeyAgreeGenerateNextMessageTest003, TestSize.Level0)
388 {
389     g_session->sessionId = g_sessionIdClient;
390     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_DL_SPEKE_384,
391         KEYAGREE_TYPE_CLIENT);
392     EXPECT_EQ(res, KEYAGREE_SUCCESS);
393 
394     g_session_s->sessionId = g_sessionIdServer;
395     res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session_s, KEYAGREE_PROTOCOL_DL_SPEKE_384, KEYAGREE_TYPE_SERVER);
396     EXPECT_EQ(res, KEYAGREE_SUCCESS);
397 
398     res = KeyAgreeStartSession(g_session, &g_sharedSecret, &g_deviceId, NULL);
399     EXPECT_EQ(res, KEYAGREE_SUCCESS);
400 
401     res = KeyAgreeStartSession(g_session_s, &g_sharedSecret, &g_deviceId_s, NULL);
402     EXPECT_EQ(res, KEYAGREE_SUCCESS);
403 
404     res = KeyAgreeGenerateNextMessage(g_session, NULL, &g_messageToTransmit1);
405     EXPECT_EQ(res, KEYAGREE_SUCCESS);
406 
407     res = KeyAgreeIsFinish(g_session);
408     EXPECT_NE(res, KEYAGREE_SUCCESS);
409 
410     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit1, &g_messageToTransmit2);
411     EXPECT_EQ(res, KEYAGREE_SUCCESS);
412 
413     res = KeyAgreeIsFinish(g_session_s);
414     EXPECT_NE(res, KEYAGREE_SUCCESS);
415 
416     res = KeyAgreeGenerateNextMessage(g_session, &g_messageToTransmit2, &g_messageToTransmit3);
417     EXPECT_EQ(res, KEYAGREE_SUCCESS);
418 
419     res = KeyAgreeIsFinish(g_session);
420     EXPECT_EQ(res, KEYAGREE_SUCCESS);
421 
422     res = KeyAgreeGetResult(g_session, &g_sessionKey);
423     EXPECT_EQ(res, KEYAGREE_SUCCESS);
424 
425     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit3, &g_messageToTransmit4);
426     EXPECT_EQ(res, KEYAGREE_SUCCESS);
427 
428     res = KeyAgreeIsFinish(g_session_s);
429     EXPECT_EQ(res, KEYAGREE_SUCCESS);
430 
431     res = KeyAgreeGetResult(g_session_s, &g_sessionKey_s);
432     EXPECT_EQ(res, KEYAGREE_SUCCESS);
433 
434     EXPECT_EQ(*(g_sessionKey.data), *(g_sessionKey_s.data));
435 }
436 
437 HWTEST_F(KeyAgreeGenerateNextMessageTest, KeyAgreeGenerateNextMessageTest004, TestSize.Level0)
438 {
439     g_session->sessionId = g_sessionIdClient;
440     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_EC_SPEKE_P256,
441         KEYAGREE_TYPE_CLIENT);
442     EXPECT_EQ(res, KEYAGREE_SUCCESS);
443 
444     g_session_s->sessionId = g_sessionIdServer;
445     res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session_s, KEYAGREE_PROTOCOL_EC_SPEKE_P256, KEYAGREE_TYPE_SERVER);
446     EXPECT_EQ(res, KEYAGREE_SUCCESS);
447 
448     res = KeyAgreeStartSession(g_session, &g_sharedSecret, &g_deviceId, NULL);
449     EXPECT_EQ(res, KEYAGREE_SUCCESS);
450 
451     res = KeyAgreeStartSession(g_session_s, &g_sharedSecret, &g_deviceId_s, NULL);
452     EXPECT_EQ(res, KEYAGREE_SUCCESS);
453 
454     res = KeyAgreeGenerateNextMessage(g_session, NULL, &g_messageToTransmit1);
455     EXPECT_EQ(res, KEYAGREE_SUCCESS);
456 
457     res = KeyAgreeIsFinish(g_session);
458     EXPECT_NE(res, KEYAGREE_SUCCESS);
459 
460     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit1, &g_messageToTransmit2);
461     EXPECT_EQ(res, KEYAGREE_SUCCESS);
462 
463     res = KeyAgreeIsFinish(g_session_s);
464     EXPECT_NE(res, KEYAGREE_SUCCESS);
465 
466     res = KeyAgreeGenerateNextMessage(g_session, &g_messageToTransmit2, &g_messageToTransmit3);
467     EXPECT_EQ(res, KEYAGREE_SUCCESS);
468 
469     res = KeyAgreeIsFinish(g_session);
470     EXPECT_EQ(res, KEYAGREE_SUCCESS);
471 
472     res = KeyAgreeGetResult(g_session, &g_sessionKey);
473     EXPECT_EQ(res, KEYAGREE_SUCCESS);
474 
475     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit3, &g_messageToTransmit4);
476     EXPECT_EQ(res, KEYAGREE_SUCCESS);
477 
478     res = KeyAgreeIsFinish(g_session_s);
479     EXPECT_EQ(res, KEYAGREE_SUCCESS);
480 
481     res = KeyAgreeGetResult(g_session_s, &g_sessionKey_s);
482     EXPECT_EQ(res, KEYAGREE_SUCCESS);
483 
484     EXPECT_EQ(*(g_sessionKey.data), *(g_sessionKey_s.data));
485 }
486 
487 HWTEST_F(KeyAgreeGenerateNextMessageTest, KeyAgreeGenerateNextMessageTest005, TestSize.Level0)
488 {
489     g_session->sessionId = g_sessionIdClient;
490     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_EC_SPEKE_X25519,
491         KEYAGREE_TYPE_CLIENT);
492     EXPECT_EQ(res, KEYAGREE_SUCCESS);
493 
494     g_session_s->sessionId = g_sessionIdServer;
495     res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session_s, KEYAGREE_PROTOCOL_EC_SPEKE_X25519,
496         KEYAGREE_TYPE_SERVER);
497     EXPECT_EQ(res, KEYAGREE_SUCCESS);
498 
499     res = KeyAgreeStartSession(g_session, &g_sharedSecret, &g_deviceId, NULL);
500     EXPECT_EQ(res, KEYAGREE_SUCCESS);
501 
502     res = KeyAgreeStartSession(g_session_s, &g_sharedSecret, &g_deviceId_s, NULL);
503     EXPECT_EQ(res, KEYAGREE_SUCCESS);
504 
505     res = KeyAgreeGenerateNextMessage(g_session, NULL, &g_messageToTransmit1);
506     EXPECT_EQ(res, KEYAGREE_SUCCESS);
507 
508     res = KeyAgreeIsFinish(g_session);
509     EXPECT_NE(res, KEYAGREE_SUCCESS);
510 
511     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit1, &g_messageToTransmit2);
512     EXPECT_EQ(res, KEYAGREE_SUCCESS);
513 
514     res = KeyAgreeIsFinish(g_session_s);
515     EXPECT_NE(res, KEYAGREE_SUCCESS);
516 
517     res = KeyAgreeGenerateNextMessage(g_session, &g_messageToTransmit2, &g_messageToTransmit3);
518     EXPECT_EQ(res, KEYAGREE_SUCCESS);
519 
520     res = KeyAgreeIsFinish(g_session);
521     EXPECT_EQ(res, KEYAGREE_SUCCESS);
522 
523     res = KeyAgreeGetResult(g_session, &g_sessionKey);
524     EXPECT_EQ(res, KEYAGREE_SUCCESS);
525 
526     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit3, &g_messageToTransmit4);
527     EXPECT_EQ(res, KEYAGREE_SUCCESS);
528 
529     res = KeyAgreeIsFinish(g_session_s);
530     EXPECT_EQ(res, KEYAGREE_SUCCESS);
531 
532     res = KeyAgreeGetResult(g_session_s, &g_sessionKey_s);
533     EXPECT_EQ(res, KEYAGREE_SUCCESS);
534 
535     EXPECT_EQ(*(g_sessionKey.data), *(g_sessionKey_s.data));
536 }
537 
538 HWTEST_F(KeyAgreeGenerateNextMessageTest, KeyAgreeGenerateNextMessageTest006, TestSize.Level0)
539 {
540     g_session->sessionId = g_sessionIdClient;
541     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_EC_SPEKE_X25519,
542         KEYAGREE_TYPE_CLIENT);
543     EXPECT_EQ(res, KEYAGREE_SUCCESS);
544 
545     g_session_s->sessionId = g_sessionIdServer;
546     res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session_s, KEYAGREE_PROTOCOL_EC_SPEKE_P256, KEYAGREE_TYPE_SERVER);
547     EXPECT_EQ(res, KEYAGREE_SUCCESS);
548 
549     res = KeyAgreeStartSession(g_session, &g_sharedSecret, &g_deviceId, NULL);
550     EXPECT_EQ(res, KEYAGREE_SUCCESS);
551 
552     res = KeyAgreeStartSession(g_session_s, &g_sharedSecret, &g_deviceId_s, NULL);
553     EXPECT_EQ(res, KEYAGREE_SUCCESS);
554 
555     res = KeyAgreeGenerateNextMessage(g_session, NULL, &g_messageToTransmit1);
556     EXPECT_EQ(res, KEYAGREE_SUCCESS);
557 
558     res = KeyAgreeIsFinish(g_session);
559     EXPECT_NE(res, KEYAGREE_SUCCESS);
560 
561     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit1, &g_messageToTransmit2);
562     EXPECT_NE(res, KEYAGREE_SUCCESS);
563 
564     res = KeyAgreeIsFinish(g_session_s);
565     EXPECT_NE(res, KEYAGREE_SUCCESS);
566 
567     res = KeyAgreeGenerateNextMessage(g_session, &g_messageToTransmit2, &g_messageToTransmit3);
568     EXPECT_NE(res, KEYAGREE_SUCCESS);
569 
570     res = KeyAgreeIsFinish(g_session);
571     EXPECT_NE(res, KEYAGREE_SUCCESS);
572 }
573 
574 class KeyAgreeIsFinishTest : public testing::Test {
575 public:
576     static void SetUpTestCase();
577     static void TearDownTestCase();
578     void SetUp();
579     void TearDown();
580 };
581 
SetUpTestCase()582 void KeyAgreeIsFinishTest::SetUpTestCase()
583 {
584     g_session = (KeyAgreeSession *)HcMalloc(sizeof(KeyAgreeSession), 0);
585     g_session_s = (KeyAgreeSession *)HcMalloc(sizeof(KeyAgreeSession), 0);
586 }
TearDownTestCase()587 void KeyAgreeIsFinishTest::TearDownTestCase()
588 {
589     HcFree(g_session);
590     HcFree(g_session_s);
591 }
SetUp()592 void KeyAgreeIsFinishTest::SetUp() {}
TearDown()593 void KeyAgreeIsFinishTest::TearDown()
594 {
595     KeyAgreeFreeSession(g_session);
596     KeyAgreeFreeSession(g_session_s);
597 }
598 
599 HWTEST_F(KeyAgreeIsFinishTest, KeyAgreeIsFinishTest001, TestSize.Level0)
600 {
601     g_session->sessionId = g_sessionIdClient;
602     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_ANY,
603         KEYAGREE_TYPE_CLIENT);
604     EXPECT_EQ(res, KEYAGREE_SUCCESS);
605 
606     res = KeyAgreeIsFinish(g_session);
607     EXPECT_NE(res, KEYAGREE_SUCCESS);
608 }
609 
610 HWTEST_F(KeyAgreeIsFinishTest, KeyAgreeIsFinishTest002, TestSize.Level0)
611 {
612     g_session->sessionId = g_sessionIdClient;
613     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_ANY,
614         KEYAGREE_TYPE_CLIENT);
615     EXPECT_EQ(res, KEYAGREE_SUCCESS);
616 
617     res = KeyAgreeIsFinish(NULL);
618     EXPECT_NE(res, KEYAGREE_SUCCESS);
619 }
620 
621 class KeyAgreeGetResultTest : public testing::Test {
622 public:
623     static void SetUpTestCase();
624     static void TearDownTestCase();
625     void SetUp();
626     void TearDown();
627 };
628 
SetUpTestCase()629 void KeyAgreeGetResultTest::SetUpTestCase()
630 {
631     g_session = (KeyAgreeSession *)HcMalloc(sizeof(KeyAgreeSession), 0);
632     g_session_s = (KeyAgreeSession *)HcMalloc(sizeof(KeyAgreeSession), 0);
633 
634     g_sessionKey_s.length = g_sessionKeyLength;
635     g_sessionKey_s.data = (uint8_t *)HcMalloc(g_sessionKey_s.length, 0);
636 
637     g_sessionKey.length = g_sessionKeyLength;
638     g_sessionKey.data = (uint8_t *)HcMalloc(g_sessionKey.length, 0);
639 }
TearDownTestCase()640 void KeyAgreeGetResultTest::TearDownTestCase()
641 {
642     HcFree(g_session);
643     HcFree(g_session_s);
644     HcFree(g_sessionKey_s.data);
645     HcFree(g_sessionKey.data);
646 }
SetUp()647 void KeyAgreeGetResultTest::SetUp() {}
TearDown()648 void KeyAgreeGetResultTest::TearDown()
649 {
650     KeyAgreeFreeSession(g_session);
651     KeyAgreeFreeSession(g_session_s);
652 }
653 
654 HWTEST_F(KeyAgreeGetResultTest, KeyAgreeGetResultTest001, TestSize.Level0)
655 {
656     g_session->sessionId = g_sessionIdClient;
657     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_ANY,
658         KEYAGREE_TYPE_CLIENT);
659     EXPECT_EQ(res, KEYAGREE_SUCCESS);
660 
661     res = KeyAgreeGetResult(g_session, NULL);
662     EXPECT_NE(res, KEYAGREE_SUCCESS);
663 }
664 
665 HWTEST_F(KeyAgreeGetResultTest, KeyAgreeGetResultTest002, TestSize.Level0)
666 {
667     g_session->sessionId = g_sessionIdClient;
668     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_ANY,
669         KEYAGREE_TYPE_CLIENT);
670     EXPECT_EQ(res, KEYAGREE_SUCCESS);
671 
672     res = KeyAgreeGetResult(g_session, &g_sessionKey);
673     EXPECT_NE(res, KEYAGREE_SUCCESS);
674 }
675 
676 class KeyAgreeFreeSessionTest : public testing::Test {
677 public:
678     static void SetUpTestCase();
679     static void TearDownTestCase();
680     void SetUp();
681     void TearDown();
682 };
683 
SetUpTestCase()684 void KeyAgreeFreeSessionTest::SetUpTestCase()
685 {
686     g_session = (KeyAgreeSession *)HcMalloc(sizeof(KeyAgreeSession), 0);
687     g_session_s = (KeyAgreeSession *)HcMalloc(sizeof(KeyAgreeSession), 0);
688 
689     g_sharedSecret.length = g_sharedSecretLength;
690     g_sharedSecret.data = (uint8_t *)HcMalloc(g_sharedSecret.length, 0);
691     (void)memcpy_s(g_sharedSecret.data, g_sharedSecret.length, (uint8_t *)"123456", g_sharedSecretLength);
692 
693     g_deviceId.length = g_deviceIdLength;
694     g_deviceId.data = (uint8_t *)HcMalloc(g_deviceId.length, 0);
695     (void)memcpy_s(g_deviceId.data, g_deviceId.length, (uint8_t *)"clientclientabcd", g_deviceIdLength);
696 
697     g_deviceId_s.length = g_deviceIdLength;
698     g_deviceId_s.data = (uint8_t *)HcMalloc(g_deviceId_s.length, 0);
699     (void)memcpy_s(g_deviceId_s.data, g_deviceId_s.length, (uint8_t *)"serverserverabcd", g_deviceIdLength);
700 
701     g_messageToTransmit1.length = g_messageLength;
702     g_messageToTransmit1.data = (uint8_t *)HcMalloc(g_messageToTransmit1.length, 0);
703 
704     g_messageToTransmit2.length = g_messageLength;
705     g_messageToTransmit2.data = (uint8_t *)HcMalloc(g_messageToTransmit2.length, 0);
706 
707     g_messageToTransmit3.length = g_messageLength;
708     g_messageToTransmit3.data = (uint8_t *)HcMalloc(g_messageToTransmit3.length, 0);
709 
710     g_messageToTransmit4.length = g_messageLength;
711     g_messageToTransmit4.data = (uint8_t *)HcMalloc(g_messageToTransmit4.length, 0);
712 
713     g_messageToTransmit5.length = g_messageLength;
714     g_messageToTransmit5.data = (uint8_t *)HcMalloc(g_messageToTransmit5.length, 0);
715 
716     g_sessionKey_s.length = g_sessionKeyLength;
717     g_sessionKey_s.data = (uint8_t *)HcMalloc(g_sessionKey_s.length, 0);
718 
719     g_sessionKey.length = g_sessionKeyLength;
720     g_sessionKey.data = (uint8_t *)HcMalloc(g_sessionKey.length, 0);
721 }
TearDownTestCase()722 void KeyAgreeFreeSessionTest::TearDownTestCase()
723 {
724     HcFree(g_session);
725     HcFree(g_session_s);
726     HcFree(g_sharedSecret.data);
727     HcFree(g_deviceId.data);
728     HcFree(g_deviceId_s.data);
729     HcFree(g_messageToTransmit1.data);
730     HcFree(g_messageToTransmit2.data);
731     HcFree(g_messageToTransmit3.data);
732     HcFree(g_messageToTransmit4.data);
733     HcFree(g_messageToTransmit5.data);
734     HcFree(g_sessionKey_s.data);
735     HcFree(g_sessionKey.data);
736 }
SetUp()737 void KeyAgreeFreeSessionTest::SetUp() {}
TearDown()738 void KeyAgreeFreeSessionTest::TearDown()
739 {
740     KeyAgreeFreeSession(g_session);
741     KeyAgreeFreeSession(g_session_s);
742 }
743 
744 HWTEST_F(KeyAgreeFreeSessionTest, KeyAgreeFreeSessionTest001, TestSize.Level0)
745 {
746     g_session->sessionId = g_sessionIdClient;
747     KeyAgreeResult res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session, KEYAGREE_PROTOCOL_ANY,
748         KEYAGREE_TYPE_CLIENT);
749     EXPECT_EQ(res, KEYAGREE_SUCCESS);
750 
751     g_session_s->sessionId = g_sessionIdServer;
752     res = KeyAgreeInitSession(DEFAULT_OS_ACCOUNT, g_session_s, KEYAGREE_PROTOCOL_ANY, KEYAGREE_TYPE_SERVER);
753     EXPECT_EQ(res, KEYAGREE_SUCCESS);
754 
755     res = KeyAgreeStartSession(g_session, &g_sharedSecret, &g_deviceId, NULL);
756     EXPECT_EQ(res, KEYAGREE_SUCCESS);
757 
758     res = KeyAgreeStartSession(g_session_s, &g_sharedSecret, &g_deviceId_s, NULL);
759     EXPECT_EQ(res, KEYAGREE_SUCCESS);
760 
761     res = KeyAgreeGenerateNextMessage(g_session, NULL, &g_messageToTransmit1);
762     EXPECT_EQ(res, KEYAGREE_SUCCESS);
763 
764     res = KeyAgreeIsFinish(g_session);
765     EXPECT_NE(res, KEYAGREE_SUCCESS);
766 
767     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit1, &g_messageToTransmit2);
768     EXPECT_EQ(res, KEYAGREE_SUCCESS);
769 
770     res = KeyAgreeIsFinish(g_session_s);
771     EXPECT_NE(res, KEYAGREE_SUCCESS);
772 
773     res = KeyAgreeGenerateNextMessage(g_session, &g_messageToTransmit2, &g_messageToTransmit3);
774     EXPECT_EQ(res, KEYAGREE_SUCCESS);
775 
776     res = KeyAgreeIsFinish(g_session);
777     EXPECT_NE(res, KEYAGREE_SUCCESS);
778 
779     res = KeyAgreeGenerateNextMessage(g_session_s, &g_messageToTransmit3, &g_messageToTransmit4);
780     EXPECT_EQ(res, KEYAGREE_SUCCESS);
781 
782     res = KeyAgreeIsFinish(g_session_s);
783     EXPECT_EQ(res, KEYAGREE_SUCCESS);
784 
785     res = KeyAgreeGetResult(g_session_s, &g_sessionKey_s);
786     EXPECT_EQ(res, KEYAGREE_SUCCESS);
787 
788     res = KeyAgreeGenerateNextMessage(g_session, &g_messageToTransmit4, &g_messageToTransmit5);
789     EXPECT_EQ(res, KEYAGREE_SUCCESS);
790 
791     res = KeyAgreeIsFinish(g_session);
792     EXPECT_EQ(res, KEYAGREE_SUCCESS);
793 
794     res = KeyAgreeGetResult(g_session, &g_sessionKey);
795     EXPECT_EQ(res, KEYAGREE_SUCCESS);
796 
797     EXPECT_EQ(*(g_sessionKey.data), *(g_sessionKey_s.data));
798 
799     KeyAgreeFreeSession(g_session);
800     KeyAgreeFreeSession(g_session_s);
801 
802     res = KeyAgreeGetResult(g_session, &g_sessionKey);
803     EXPECT_NE(res, KEYAGREE_SUCCESS);
804 
805     res = KeyAgreeGetResult(g_session_s, &g_sessionKey_s);
806     EXPECT_NE(res, KEYAGREE_SUCCESS);
807 }