1 /*
2 * Copyright (c) 2024 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 <cstdlib>
17 #include <gtest/gtest.h>
18 #include "fs_hvb.h"
19 #include "init_utils.h"
20 #include "securec.h"
21
22 using namespace std;
23 using namespace testing::ext;
24
25 namespace init_ut {
26 class FsHvbUnitTest : public testing::Test {
27 public:
SetUpTestCase(void)28 static void SetUpTestCase(void) {};
TearDownTestCase(void)29 static void TearDownTestCase(void) {};
SetUp(void)30 void SetUp(void) {};
TearDown(void)31 void TearDown(void) {};
32 };
33
CreateTestFile(const char *fileName, const char *data)34 void CreateTestFile(const char *fileName, const char *data)
35 {
36 CheckAndCreateDir(fileName);
37 printf("PrepareParamTestData for %s\n", fileName);
38 FILE *tmpFile = fopen(fileName, "a+");
39 if (tmpFile != nullptr) {
40 fprintf(tmpFile, "%s", data);
41 (void)fflush(tmpFile);
42 fclose(tmpFile);
43 }
44 }
45
HWTEST_F(FsHvbUnitTest, Init_FsHvbInit_001, TestSize.Level0)46 HWTEST_F(FsHvbUnitTest, Init_FsHvbInit_001, TestSize.Level0)
47 {
48 const char *cmdLine;
49 int ret = FsHvbInit();
50 EXPECT_EQ(ret, HVB_ERROR_INVALID_ARGUMENT);
51
52 setenv("VERIFY_VALUE", "PartFail", 1);
53 ret = FsHvbInit();
54 EXPECT_EQ(ret, HVB_ERROR_UNSUPPORTED_VERSION);
55
56 setenv("VERIFY_VALUE", "Succeed", 1);
57 ret = FsHvbInit();
58 EXPECT_EQ(ret, -1);
59
60 cmdLine = "ohos.boot.hvb.hash_algo=test "; // HVB_CMDLINE_HASH_ALG
61 CreateTestFile(BOOT_CMD_LINE, cmdLine);
62 ret = FsHvbInit();
63 EXPECT_EQ(ret, -1);
64
65 cmdLine = "ohos.boot.hvb.digest=1 "; // HVB_CMDLINE_CERT_DIGEST
66 CreateTestFile(BOOT_CMD_LINE, cmdLine);
67 ret = FsHvbInit();
68 EXPECT_EQ(ret, -1);
69 remove(BOOT_CMD_LINE);
70
71 cmdLine = "ohos.boot.hvb.hash_algo=test ";
72 CreateTestFile(BOOT_CMD_LINE, cmdLine);
73 cmdLine = "ohos.boot.hvb.digest=1234 ";
74 CreateTestFile(BOOT_CMD_LINE, cmdLine);
75 ret = FsHvbInit();
76 EXPECT_EQ(ret, -1);
77 remove(BOOT_CMD_LINE);
78
79 setenv("HASH_VALUE", "InitFail", 1);
80 cmdLine = "ohos.boot.hvb.hash_algo=sha256 ";
81 CreateTestFile(BOOT_CMD_LINE, cmdLine);
82 cmdLine = "ohos.boot.hvb.digest=12 ";
83 CreateTestFile(BOOT_CMD_LINE, cmdLine);
84 ret = FsHvbInit();
85 EXPECT_EQ(ret, -1);
86
87 setenv("HASH_VALUE", "UpdateFail", 1);
88 ret = FsHvbInit();
89 EXPECT_EQ(ret, -1);
90
91 setenv("HASH_VALUE", "FinalFail", 1);
92 ret = FsHvbInit();
93 EXPECT_EQ(ret, -1);
94
95 setenv("HASH_VALUE", "AllSucceed", 1);
96 ret = FsHvbInit();
97 EXPECT_EQ(ret, -1);
98
99 remove(BOOT_CMD_LINE);
100 unsetenv("VERIFY_VALUE");
101 unsetenv("HASH_VALUE");
102 }
103
HWTEST_F(FsHvbUnitTest, Init_FsHvbSetupHashtree_001, TestSize.Level0)104 HWTEST_F(FsHvbUnitTest, Init_FsHvbSetupHashtree_001, TestSize.Level0)
105 {
106 FstabItem fsItem;
107
108 int ret = FsHvbSetupHashtree(nullptr);
109 EXPECT_EQ(ret, -1);
110
111 ret = FsHvbSetupHashtree(&fsItem);
112 EXPECT_EQ(ret, -1);
113 }
114
HWTEST_F(FsHvbUnitTest, Init_FsHvbFinal_001, TestSize.Level0)115 HWTEST_F(FsHvbUnitTest, Init_FsHvbFinal_001, TestSize.Level0)
116 {
117 int ret = FsHvbFinal();
118 EXPECT_EQ(ret, 0);
119 }
120
HWTEST_F(FsHvbUnitTest, Init_FsHvbGetValueFromCmdLine_001, TestSize.Level0)121 HWTEST_F(FsHvbUnitTest, Init_FsHvbGetValueFromCmdLine_001, TestSize.Level0)
122 {
123 const char *cmdLine;
124 char hashAlg[32] = { 0 };
125
126 int ret = FsHvbGetValueFromCmdLine(nullptr, sizeof(hashAlg), "ohos.boot.hvb.hash_algo");
127 EXPECT_EQ(ret, -1);
128 ret = FsHvbGetValueFromCmdLine(&hashAlg[0], sizeof(hashAlg), nullptr);
129 EXPECT_EQ(ret, -1);
130
131 cmdLine = "ohos.boot.hvb.hash_algo=sha256 ";
132 CreateTestFile(BOOT_CMD_LINE, cmdLine);
133 ret = FsHvbGetValueFromCmdLine(&hashAlg[0], sizeof(hashAlg), "ohos.boot.hvb.hash_algo");
134 EXPECT_EQ(ret, 0);
135 EXPECT_EQ(strcmp(hashAlg, "sha256"), 0);
136
137 remove(BOOT_CMD_LINE);
138 }
139
HWTEST_F(FsHvbUnitTest, Init_FsHvbConstructVerityTarget_001, TestSize.Level0)140 HWTEST_F(FsHvbUnitTest, Init_FsHvbConstructVerityTarget_001, TestSize.Level0)
141 {
142 DmVerityTarget target;
143 const char *devName = "test";
144 struct hvb_cert cert;
145
146 int ret = FsHvbConstructVerityTarget(nullptr, devName, &cert);
147 EXPECT_EQ(ret, -1);
148 ret = FsHvbConstructVerityTarget(&target, nullptr, &cert);
149 EXPECT_EQ(ret, -1);
150 ret = FsHvbConstructVerityTarget(&target, devName, nullptr);
151 EXPECT_EQ(ret, -1);
152
153 cert.image_len = 512;
154 cert.data_block_size = 0;
155 ret = FsHvbConstructVerityTarget(&target, devName, &cert);
156 EXPECT_EQ(ret, -1);
157 cert.data_block_size = 8;
158 cert.hash_block_size = 0;
159 ret = FsHvbConstructVerityTarget(&target, devName, &cert);
160 EXPECT_EQ(ret, -1);
161
162 cert.hash_block_size = 8;
163 cert.hashtree_offset = 16;
164 cert.hash_algo = 2;
165 ret = FsHvbConstructVerityTarget(&target, devName, &cert);
166 EXPECT_EQ(ret, -1);
167
168 cert.hash_algo = 0;
169 cert.hash_payload.digest = (uint8_t *)"5";
170 cert.digest_size = 1;
171 cert.hash_payload.salt = (uint8_t *)"7";
172 cert.salt_size = 1;
173 cert.fec_size = 1;
174 cert.fec_num_roots = 1;
175 cert.fec_offset = 8;
176 ret = FsHvbConstructVerityTarget(&target, devName, &cert);
177 EXPECT_EQ(ret, 0);
178
179 cert.hash_algo = 1;
180 ret = FsHvbConstructVerityTarget(&target, devName, &cert);
181 EXPECT_EQ(ret, 0);
182 }
183
HWTEST_F(FsHvbUnitTest, Init_FsHvbDestoryVerityTarget_001, TestSize.Level0)184 HWTEST_F(FsHvbUnitTest, Init_FsHvbDestoryVerityTarget_001, TestSize.Level0)
185 {
186 DmVerityTarget target;
187
188 target.paras = (char *)calloc(1, 10);
189 FsHvbDestoryVerityTarget(&target);
190 }
191 }