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
16 #include "UTTest_crypto_mgr.h"
17 #include "dm_anonymous.h"
18 #include "dm_constants.h"
19 #include "json_object.h"
20
21 namespace OHOS {
22 namespace DistributedHardware {
SetUp()23 void CryptoMgrTest::SetUp()
24 {}
25
TearDown()26 void CryptoMgrTest::TearDown()
27 {}
28
SetUpTestCase()29 void CryptoMgrTest::SetUpTestCase()
30 {}
31
TearDownTestCase()32 void CryptoMgrTest::TearDownTestCase()
33 {}
34
35 HWTEST_F(CryptoMgrTest, EncryptAndDecryptMessage_001, testing::ext::TestSize.Level0)
36 {
37 auto cryptoMgr = std::make_shared<CryptoMgr>();
38 uint8_t sessionKey[SESSION_KEY_LENGTH] = "sessionKey_fm88";
39 auto ret = cryptoMgr->SaveSessionKey(sessionKey, SESSION_KEY_LENGTH);
40 ASSERT_EQ(ret, DM_OK);
41
42 JsonObject jsonObj;
43 jsonObj[TAG_DEVICE_ID] = "51352xxxx";
44 jsonObj[TAG_CRYPTO_SUPPORT] = true;
45 std::string message = SafetyDump(jsonObj);
46 std::string encryptData;
47 std::string decryptData;
48 ret = cryptoMgr->EncryptMessage(message, encryptData);
49 ASSERT_EQ(ret, DM_OK);
50 cryptoMgr->DecryptMessage(encryptData, decryptData);
51 EXPECT_STREQ(decryptData.c_str(), message.c_str());
52 }
53
54 HWTEST_F(CryptoMgrTest, EncryptAndDecryptMessage_002, testing::ext::TestSize.Level0)
55 {
56 auto cryptoMgr = std::make_shared<CryptoMgr>();
57 uint8_t sessionKey[SESSION_KEY_LENGTH] = "sessionKey_fm88";
58 auto ret = cryptoMgr->SaveSessionKey(sessionKey, SESSION_KEY_LENGTH);
59 ASSERT_EQ(ret, DM_OK);
60
61 JsonObject jsonObj;
62 jsonObj[TAG_DEVICE_ID] = "51352xxxx";
63 jsonObj[TAG_CRYPTO_SUPPORT] = true;
64 std::string message = SafetyDump(jsonObj);
65 std::string encryptData1;
66 std::string encryptData2;
67 std::string decryptData;
68 ret = cryptoMgr->EncryptMessage(message, encryptData1);
69 ASSERT_EQ(ret, DM_OK);
70 ret = cryptoMgr->EncryptMessage(message, encryptData2);
71 ASSERT_EQ(ret, DM_OK);
72 cryptoMgr->DecryptMessage(encryptData1, decryptData);
73 EXPECT_STREQ(decryptData.c_str(), message.c_str());
74 cryptoMgr->DecryptMessage(encryptData2, decryptData);
75 EXPECT_STREQ(decryptData.c_str(), message.c_str());
76 }
77
78 HWTEST_F(CryptoMgrTest, EncryptAndDecryptMessage_003, testing::ext::TestSize.Level2)
79 {
80 auto cryptoMgr = std::make_shared<CryptoMgr>();
81 uint8_t sessionKey[SESSION_KEY_LENGTH] = "sessionKey_fm88";
82 auto ret = cryptoMgr->SaveSessionKey(sessionKey, SESSION_KEY_LENGTH);
83 ASSERT_EQ(ret, DM_OK);
84
85 std::string emptyMessage;
86 std::string encryptData;
87 std::string decryptData;
88 ret = cryptoMgr->EncryptMessage(emptyMessage, encryptData);
89 EXPECT_NE(ret, DM_OK);
90 cryptoMgr->DecryptMessage(encryptData, decryptData);
91 EXPECT_NE(ret, DM_OK);
92 }
93
94 HWTEST_F(CryptoMgrTest, EncryptAndDecryptMessage_004, testing::ext::TestSize.Level2)
95 {
96 auto cryptoMgr = std::make_shared<CryptoMgr>();
97 const size_t sessionKeyLen = 15;
98 uint8_t sessionKey[sessionKeyLen] = {'\0'};
99 auto ret = cryptoMgr->SaveSessionKey(sessionKey, sessionKeyLen);
100 ASSERT_EQ(ret, DM_OK);
101
102 std::string emptyMessage;
103 std::string encryptData;
104 std::string decryptData;
105 ret = cryptoMgr->EncryptMessage(emptyMessage, encryptData);
106 EXPECT_NE(ret, DM_OK);
107 cryptoMgr->DecryptMessage(encryptData, decryptData);
108 EXPECT_NE(ret, DM_OK);
109 }
110
111 HWTEST_F(CryptoMgrTest, EncryptAndDecryptMessage_005, testing::ext::TestSize.Level2)
112 {
113 auto cryptoMgr = std::make_shared<CryptoMgr>();
114
115 JsonObject jsonObj;
116 jsonObj[TAG_DEVICE_ID] = "51352xxxx";
117 jsonObj[TAG_CRYPTO_SUPPORT] = true;
118 std::string message = SafetyDump(jsonObj);
119 std::string encryptData;
120 std::string decryptData;
121 auto ret = cryptoMgr->EncryptMessage(message, encryptData);
122 EXPECT_NE(ret, DM_OK);
123 cryptoMgr->DecryptMessage(encryptData, decryptData);
124 EXPECT_NE(ret, DM_OK);
125 }
126 } // namespace DistributedHardware
127 } // namespace OHOS
128