1 /*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <stdio.h>
18
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21
22 #include <android-base/file.h>
23 #include <android-base/logging.h>
24 #include <android-base/properties.h>
25 #include <bootloader_message/bootloader_message.h>
26 #include <string_view>
27
28 namespace {
29 using ::testing::StartsWith;
30
mtectrl(std::string_view arg)31 int mtectrl(std::string_view arg) {
32 std::string cmd = "mtectrl -t /data/local/tmp/misc_memtag ";
33 cmd += arg;
34 return system(cmd.c_str());
35 }
36
RunMteCtrl()37 int RunMteCtrl() {
38 CHECK(android::base::GetIntProperty("arm64.memtag.test_bootctl_loaded", 0) == 1);
39 std::string arg = android::base::GetProperty("arm64.memtag.test_bootctl", "none");
40 arg += " ";
41 arg += android::base::GetProperty("arm64.memtag.test_bootctl_override", "default");
42 return mtectrl(arg);
43 }
44
Boot(misc_memtag_message m)45 void Boot(misc_memtag_message m) {
46 std::string m_str(reinterpret_cast<char*>(&m), sizeof(m));
47 android::base::WriteStringToFile(m_str, "/data/local/tmp/misc_memtag");
48 mtectrl("-s arm64.memtag.test_bootctl -f arm64.memtag.test_bootctl_loaded");
49 // arm64.memtag.test_bootctl got updated, so we trigger ourselves.
50 RunMteCtrl();
51 }
52
Reboot()53 void Reboot() {
54 android::base::SetProperty("arm64.memtag.test_bootctl", "INVALID");
55 android::base::SetProperty("arm64.memtag.test_bootctl_loaded", "0");
56 std::string m_str;
57 ASSERT_TRUE(android::base::ReadFileToString("/data/local/tmp/misc_memtag", &m_str));
58 misc_memtag_message m;
59 ASSERT_EQ(m_str.size(), sizeof(m));
60 memcpy(&m, m_str.c_str(), sizeof(m));
61 m.memtag_mode &= ~MISC_MEMTAG_MODE_MEMTAG_ONCE;
62 Boot(m);
63 }
64
SetMemtagProp(const std::string & s)65 void SetMemtagProp(const std::string& s) {
66 android::base::SetProperty("arm64.memtag.test_bootctl", s);
67 RunMteCtrl();
68 }
69
SetOverrideProp(const std::string & s)70 void SetOverrideProp(const std::string& s) {
71 android::base::SetProperty("arm64.memtag.test_bootctl_override", s);
72 RunMteCtrl();
73 }
74
GetMisc()75 std::string GetMisc() {
76 std::string data;
77 CHECK(android::base::ReadFileToString("/data/local/tmp/misc_memtag", &data, false));
78 return data;
79 }
80
TestProperty()81 std::string TestProperty() {
82 return android::base::GetProperty("arm64.memtag.test_bootctl", "");
83 }
TestFlag()84 std::string TestFlag() {
85 return android::base::GetProperty("arm64.memtag.test_bootctl_loaded", "");
86 }
87 } // namespace
88
89 class MteCtrlTest : public ::testing::Test {
SetUp()90 void SetUp() override {
91 // Empty fake misc partition.
92 int fd = creat("/data/local/tmp/misc_memtag", 0600);
93 CHECK(fd != -1);
94 CHECK(ftruncate(fd, sizeof(misc_memtag_message)) != -1);
95 close(fd);
96 android::base::SetProperty("arm64.memtag.test_bootctl", "INVALID");
97 android::base::SetProperty("arm64.memtag.test_bootctl_override", "");
98 android::base::SetProperty("arm64.memtag.test_bootctl_loaded", "0");
99 }
TearDown()100 void TearDown() override {
101 CHECK(unlink("/data/local/tmp/misc_memtag") == 0);
102 }
103 };
104
TEST_F(MteCtrlTest,invalid)105 TEST_F(MteCtrlTest, invalid) {
106 EXPECT_NE(mtectrl("memtag-invalid"), 0);
107 EXPECT_NE(mtectrl("memtag override-invalid"), 0);
108 }
109
TEST_F(MteCtrlTest,set_once)110 TEST_F(MteCtrlTest, set_once) {
111 Boot({});
112 SetMemtagProp("memtag-once");
113 EXPECT_THAT(GetMisc(), StartsWith("\x01\x5a\xfe\xfe\x5a\x02"));
114 }
115
TEST_F(MteCtrlTest,set_once_kernel)116 TEST_F(MteCtrlTest, set_once_kernel) {
117 Boot({});
118 SetMemtagProp("memtag-once,memtag-kernel");
119 EXPECT_THAT(GetMisc(), StartsWith("\x01\x5a\xfe\xfe\x5a\x06"));
120 }
121
TEST_F(MteCtrlTest,read_memtag)122 TEST_F(MteCtrlTest, read_memtag) {
123 Boot({});
124 SetMemtagProp("memtag");
125 Reboot();
126 EXPECT_EQ(TestProperty(), "memtag");
127 EXPECT_EQ(TestFlag(), "1");
128 }
129
TEST_F(MteCtrlTest,read_invalid_memtag_message)130 TEST_F(MteCtrlTest, read_invalid_memtag_message) {
131 misc_memtag_message m = {.version = 1, .magic = 0xffff, .memtag_mode = MISC_MEMTAG_MODE_MEMTAG};
132 Boot(m);
133 EXPECT_EQ(TestProperty(), "none");
134 EXPECT_EQ(TestFlag(), "1");
135 }
136
TEST_F(MteCtrlTest,read_invalid_memtag_mode)137 TEST_F(MteCtrlTest, read_invalid_memtag_mode) {
138 misc_memtag_message m = {.version = MISC_MEMTAG_MESSAGE_VERSION,
139 .magic = MISC_MEMTAG_MAGIC_HEADER,
140 .memtag_mode = MISC_MEMTAG_MODE_MEMTAG | 1u << 31};
141 Boot(m);
142 EXPECT_EQ(TestProperty(), "memtag");
143 EXPECT_EQ(TestFlag(), "1");
144 }
145
TEST_F(MteCtrlTest,set_read_force_off)146 TEST_F(MteCtrlTest, set_read_force_off) {
147 Boot({});
148 SetMemtagProp("memtag,memtag-once");
149 SetOverrideProp("force_off");
150 Reboot();
151 EXPECT_EQ(TestProperty(), "memtag-off,forced");
152 SetOverrideProp("default");
153 Reboot();
154 EXPECT_EQ(TestProperty(), "none");
155 }
156
TEST_F(MteCtrlTest,set_read_force_off_none)157 TEST_F(MteCtrlTest, set_read_force_off_none) {
158 Boot({});
159 SetMemtagProp("none");
160 SetOverrideProp("force_off");
161 Reboot();
162 EXPECT_EQ(TestProperty(), "memtag-off,forced");
163 SetOverrideProp("default");
164 Reboot();
165 EXPECT_EQ(TestProperty(), "none");
166 }
167
TEST_F(MteCtrlTest,set_read_force_off_and_on)168 TEST_F(MteCtrlTest, set_read_force_off_and_on) {
169 Boot({});
170 SetMemtagProp("memtag,memtag-once");
171 SetOverrideProp("force_off");
172 Reboot();
173 EXPECT_EQ(TestProperty(), "memtag-off,forced");
174 SetOverrideProp("default");
175 Reboot();
176 EXPECT_EQ(TestProperty(), "none");
177 SetOverrideProp("force_on");
178 Reboot();
179 EXPECT_EQ(TestProperty(), "memtag,forced");
180 }
181
TEST_F(MteCtrlTest,set_read_force_off_already)182 TEST_F(MteCtrlTest, set_read_force_off_already) {
183 Boot({});
184 SetMemtagProp("memtag-off,memtag-once");
185 SetOverrideProp("force_off");
186 Reboot();
187 EXPECT_EQ(TestProperty(), "memtag-off");
188 SetOverrideProp("default");
189 Reboot();
190 EXPECT_EQ(TestProperty(), "memtag-off");
191 }
192
TEST_F(MteCtrlTest,set_read_force_off_and_on_already)193 TEST_F(MteCtrlTest, set_read_force_off_and_on_already) {
194 Boot({});
195 SetMemtagProp("memtag-off,memtag-once");
196 SetOverrideProp("force_off");
197 Reboot();
198 EXPECT_EQ(TestProperty(), "memtag-off");
199 SetOverrideProp("default");
200 Reboot();
201 EXPECT_EQ(TestProperty(), "memtag-off");
202 SetOverrideProp("force_on");
203 Reboot();
204 EXPECT_EQ(TestProperty(), "memtag,forced");
205 }
206
TEST_F(MteCtrlTest,set_read_force_on)207 TEST_F(MteCtrlTest, set_read_force_on) {
208 Boot({});
209 SetMemtagProp("memtag-once");
210 SetOverrideProp("force_on");
211 Reboot();
212 EXPECT_EQ(TestProperty(), "memtag,forced");
213 SetOverrideProp("default");
214 Reboot();
215 EXPECT_EQ(TestProperty(), "none");
216 }
217
TEST_F(MteCtrlTest,set_read_force_on_none)218 TEST_F(MteCtrlTest, set_read_force_on_none) {
219 Boot({});
220 SetMemtagProp("none");
221 SetOverrideProp("force_on");
222 Reboot();
223 EXPECT_EQ(TestProperty(), "memtag,forced");
224 SetOverrideProp("default");
225 Reboot();
226 EXPECT_EQ(TestProperty(), "none");
227 }
228
TEST_F(MteCtrlTest,set_read_force_on_and_off)229 TEST_F(MteCtrlTest, set_read_force_on_and_off) {
230 Boot({});
231 SetMemtagProp("memtag-once");
232 SetOverrideProp("force_on");
233 Reboot();
234 EXPECT_EQ(TestProperty(), "memtag,forced");
235 SetOverrideProp("default");
236 Reboot();
237 EXPECT_EQ(TestProperty(), "none");
238 SetOverrideProp("force_off");
239 Reboot();
240 EXPECT_EQ(TestProperty(), "memtag-off,forced");
241 }
242
TEST_F(MteCtrlTest,set_read_force_on_already)243 TEST_F(MteCtrlTest, set_read_force_on_already) {
244 Boot({});
245 SetMemtagProp("memtag,memtag-once");
246 SetOverrideProp("force_on");
247 Reboot();
248 EXPECT_EQ(TestProperty(), "memtag");
249 SetOverrideProp("default");
250 Reboot();
251 EXPECT_EQ(TestProperty(), "memtag");
252 }
253
TEST_F(MteCtrlTest,set_read_force_on_and_off_already)254 TEST_F(MteCtrlTest, set_read_force_on_and_off_already) {
255 Boot({});
256 SetMemtagProp("memtag,memtag-once");
257 SetOverrideProp("force_on");
258 Reboot();
259 EXPECT_EQ(TestProperty(), "memtag");
260 SetOverrideProp("default");
261 Reboot();
262 EXPECT_EQ(TestProperty(), "memtag");
263 SetOverrideProp("force_off");
264 Reboot();
265 EXPECT_EQ(TestProperty(), "memtag-off,forced");
266 }
267
TEST_F(MteCtrlTest,override)268 TEST_F(MteCtrlTest, override) {
269 Boot({});
270 SetMemtagProp(("memtag"));
271 SetMemtagProp(("memtag-once"));
272 EXPECT_THAT(GetMisc(), StartsWith("\x01\x5a\xfe\xfe\x5a\x02"));
273 }
274
TEST_F(MteCtrlTest,read_empty)275 TEST_F(MteCtrlTest, read_empty) {
276 Boot({});
277 EXPECT_EQ(TestProperty(), "none");
278 EXPECT_EQ(TestFlag(), "1");
279 }
280
TEST_F(MteCtrlTest,force_off_invalid_mode)281 TEST_F(MteCtrlTest, force_off_invalid_mode) {
282 Boot({});
283 SetMemtagProp("memtag-invalid");
284 SetOverrideProp("force_off");
285 EXPECT_THAT(GetMisc(), StartsWith("\x01\x5a\xfe\xfe\x5a\x30"));
286 Reboot();
287 EXPECT_EQ(TestProperty(), "memtag-off,forced");
288 SetOverrideProp("default");
289 Reboot();
290 EXPECT_EQ(TestProperty(), "none");
291 }
292
TEST_F(MteCtrlTest,force_on_invalid_mode)293 TEST_F(MteCtrlTest, force_on_invalid_mode) {
294 Boot({});
295 SetMemtagProp("memtag-invalid");
296 SetOverrideProp("force_on");
297 EXPECT_THAT(GetMisc(), StartsWith("\x01\x5a\xfe\xfe\x5a\x21"));
298 Reboot();
299 EXPECT_EQ(TestProperty(), "memtag,forced");
300 SetOverrideProp("default");
301 Reboot();
302 EXPECT_EQ(TestProperty(), "none");
303 }
304
TEST_F(MteCtrlTest,mode_invalid_override)305 TEST_F(MteCtrlTest, mode_invalid_override) {
306 Boot({});
307 SetMemtagProp("memtag");
308 SetOverrideProp("force_invalid");
309 EXPECT_THAT(GetMisc(), StartsWith("\x01\x5a\xfe\xfe\x5a\x01"));
310 Reboot();
311 EXPECT_EQ(TestProperty(), "memtag");
312 SetOverrideProp("default");
313 Reboot();
314 EXPECT_EQ(TestProperty(), "memtag");
315 }
316