1 // Copyright 2012 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "ipc/ipc_message_utils.h"
6
7 #include <stddef.h>
8 #include <stdint.h>
9 #include <memory>
10
11 #include "base/files/file_path.h"
12 #include "base/json/json_reader.h"
13 #include "base/memory/ptr_util.h"
14 #include "base/test/test_shared_memory_util.h"
15 #include "base/unguessable_token.h"
16 #include "build/build_config.h"
17 #include "ipc/ipc_channel_handle.h"
18 #include "ipc/ipc_message.h"
19 #include "testing/gtest/include/gtest/gtest.h"
20
21 #if BUILDFLAG(IS_WIN)
22 #include <windows.h>
23 #endif
24
25 namespace IPC {
26 namespace {
27
28 // Tests nesting of messages as parameters to other messages.
TEST(IPCMessageUtilsTest,NestedMessages)29 TEST(IPCMessageUtilsTest, NestedMessages) {
30 int32_t nested_routing = 12;
31 uint32_t nested_type = 78;
32 int nested_content = 456789;
33 Message::PriorityValue nested_priority = Message::PRIORITY_HIGH;
34 Message nested_msg(nested_routing, nested_type, nested_priority);
35 nested_msg.set_sync();
36 ParamTraits<int>::Write(&nested_msg, nested_content);
37
38 // Outer message contains the nested one as its parameter.
39 int32_t outer_routing = 91;
40 uint32_t outer_type = 88;
41 Message::PriorityValue outer_priority = Message::PRIORITY_NORMAL;
42 Message outer_msg(outer_routing, outer_type, outer_priority);
43 ParamTraits<Message>::Write(&outer_msg, nested_msg);
44
45 // Read back the nested message.
46 base::PickleIterator iter(outer_msg);
47 IPC::Message result_msg;
48 ASSERT_TRUE(ParamTraits<Message>::Read(&outer_msg, &iter, &result_msg));
49
50 // Verify nested message headers.
51 EXPECT_EQ(nested_msg.routing_id(), result_msg.routing_id());
52 EXPECT_EQ(nested_msg.type(), result_msg.type());
53 EXPECT_EQ(nested_msg.priority(), result_msg.priority());
54 EXPECT_EQ(nested_msg.flags(), result_msg.flags());
55
56 // Verify nested message content
57 base::PickleIterator nested_iter(nested_msg);
58 int result_content = 0;
59 ASSERT_TRUE(ParamTraits<int>::Read(&nested_msg, &nested_iter,
60 &result_content));
61 EXPECT_EQ(nested_content, result_content);
62
63 // Try reading past the ends for both messages and make sure it fails.
64 IPC::Message dummy;
65 ASSERT_FALSE(ParamTraits<Message>::Read(&outer_msg, &iter, &dummy));
66 ASSERT_FALSE(ParamTraits<int>::Read(&nested_msg, &nested_iter,
67 &result_content));
68 }
69
70 // Tests that detection of various bad parameters is working correctly.
TEST(IPCMessageUtilsTest,ParameterValidation)71 TEST(IPCMessageUtilsTest, ParameterValidation) {
72 base::FilePath::StringType ok_string(FILE_PATH_LITERAL("hello"), 5);
73 base::FilePath::StringType bad_string(FILE_PATH_LITERAL("hel\0o"), 5);
74
75 // Change this if ParamTraits<FilePath>::Write() changes.
76 IPC::Message message;
77 ParamTraits<base::FilePath::StringType>::Write(&message, ok_string);
78 ParamTraits<base::FilePath::StringType>::Write(&message, bad_string);
79
80 base::PickleIterator iter(message);
81 base::FilePath ok_path;
82 base::FilePath bad_path;
83 ASSERT_TRUE(ParamTraits<base::FilePath>::Read(&message, &iter, &ok_path));
84 ASSERT_FALSE(ParamTraits<base::FilePath>::Read(&message, &iter, &bad_path));
85 }
86
TEST(IPCMessageUtilsTest,InlinedVector)87 TEST(IPCMessageUtilsTest, InlinedVector) {
88 static constexpr size_t stack_capacity = 5;
89 absl::InlinedVector<double, stack_capacity> inlined_vector;
90 for (size_t i = 0; i < 2 * stack_capacity; i++) {
91 inlined_vector.push_back(i * 2.0);
92 }
93
94 IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
95 IPC::WriteParam(&msg, inlined_vector);
96
97 absl::InlinedVector<double, stack_capacity> output;
98 base::PickleIterator iter(msg);
99 EXPECT_TRUE(IPC::ReadParam(&msg, &iter, &output));
100 ASSERT_EQ(inlined_vector.size(), output.size());
101 for (size_t i = 0; i < 2 * stack_capacity; i++) {
102 EXPECT_EQ(inlined_vector[i], output[i]);
103 }
104 }
105
TEST(IPCMessageUtilsTest,MojoChannelHandle)106 TEST(IPCMessageUtilsTest, MojoChannelHandle) {
107 mojo::MessagePipe message_pipe;
108 IPC::ChannelHandle channel_handle(message_pipe.handle0.release());
109
110 IPC::Message message;
111 IPC::WriteParam(&message, channel_handle);
112
113 base::PickleIterator iter(message);
114 IPC::ChannelHandle result_handle;
115 EXPECT_TRUE(IPC::ReadParam(&message, &iter, &result_handle));
116 EXPECT_EQ(channel_handle.mojo_handle, result_handle.mojo_handle);
117 }
118
TEST(IPCMessageUtilsTest,OptionalUnset)119 TEST(IPCMessageUtilsTest, OptionalUnset) {
120 std::optional<int> opt;
121 base::Pickle pickle;
122 IPC::WriteParam(&pickle, opt);
123
124 std::string log;
125 IPC::LogParam(opt, &log);
126 EXPECT_EQ("(unset)", log);
127
128 std::optional<int> unserialized_opt;
129 base::PickleIterator iter(pickle);
130 EXPECT_TRUE(IPC::ReadParam(&pickle, &iter, &unserialized_opt));
131 EXPECT_FALSE(unserialized_opt);
132 }
133
TEST(IPCMessageUtilsTest,OptionalSet)134 TEST(IPCMessageUtilsTest, OptionalSet) {
135 std::optional<int> opt(10);
136 base::Pickle pickle;
137 IPC::WriteParam(&pickle, opt);
138
139 std::string log;
140 IPC::LogParam(opt, &log);
141 EXPECT_EQ("10", log);
142
143 std::optional<int> unserialized_opt;
144 base::PickleIterator iter(pickle);
145 EXPECT_TRUE(IPC::ReadParam(&pickle, &iter, &unserialized_opt));
146 EXPECT_TRUE(unserialized_opt);
147 EXPECT_EQ(opt.value(), unserialized_opt.value());
148 }
149
150 template <typename SharedMemoryRegionType>
151 class SharedMemoryRegionTypedTest : public ::testing::Test {};
152
153 typedef ::testing::Types<base::WritableSharedMemoryRegion,
154 base::UnsafeSharedMemoryRegion,
155 base::ReadOnlySharedMemoryRegion>
156 AllSharedMemoryRegionTypes;
157 TYPED_TEST_SUITE(SharedMemoryRegionTypedTest, AllSharedMemoryRegionTypes);
158
TYPED_TEST(SharedMemoryRegionTypedTest,WriteAndRead)159 TYPED_TEST(SharedMemoryRegionTypedTest, WriteAndRead) {
160 const size_t size = 2314;
161 auto [pre_pickle, pre_mapping] = base::CreateMappedRegion<TypeParam>(size);
162 const size_t pre_size = pre_pickle.GetSize();
163
164 const std::string content = "Hello, world!";
165 memcpy(pre_mapping.memory(), content.data(), content.size());
166
167 IPC::Message message;
168 IPC::WriteParam(&message, pre_pickle);
169 EXPECT_FALSE(pre_pickle.IsValid());
170
171 TypeParam post_pickle;
172 base::PickleIterator iter(message);
173 EXPECT_TRUE(IPC::ReadParam(&message, &iter, &post_pickle));
174 EXPECT_EQ(pre_size, post_pickle.GetSize());
175 typename TypeParam::MappingType post_mapping = post_pickle.Map();
176 EXPECT_EQ(pre_mapping.guid(), post_mapping.guid());
177 EXPECT_EQ(0, memcmp(pre_mapping.memory(), post_mapping.memory(),
178 post_pickle.GetSize()));
179 }
180
TYPED_TEST(SharedMemoryRegionTypedTest,InvalidRegion)181 TYPED_TEST(SharedMemoryRegionTypedTest, InvalidRegion) {
182 TypeParam pre_pickle;
183 EXPECT_FALSE(pre_pickle.IsValid());
184
185 IPC::Message message;
186 IPC::WriteParam(&message, pre_pickle);
187
188 TypeParam post_pickle;
189 base::PickleIterator iter(message);
190 EXPECT_TRUE(IPC::ReadParam(&message, &iter, &post_pickle));
191 EXPECT_FALSE(post_pickle.IsValid());
192 }
193
TEST(IPCMessageUtilsTest,UnguessableTokenTest)194 TEST(IPCMessageUtilsTest, UnguessableTokenTest) {
195 base::UnguessableToken token = base::UnguessableToken::Create();
196 base::Pickle pickle;
197 IPC::WriteParam(&pickle, token);
198
199 std::string log;
200 IPC::LogParam(token, &log);
201 EXPECT_EQ(token.ToString(), log);
202
203 base::UnguessableToken deserialized_token;
204 base::PickleIterator iter(pickle);
205 EXPECT_TRUE(IPC::ReadParam(&pickle, &iter, &deserialized_token));
206 EXPECT_EQ(token, deserialized_token);
207 }
208
TEST(IPCMessageUtilsTest,FlatMap)209 TEST(IPCMessageUtilsTest, FlatMap) {
210 base::flat_map<std::string, int> input;
211 input["foo"] = 42;
212 input["bar"] = 96;
213
214 base::Pickle pickle;
215 IPC::WriteParam(&pickle, input);
216
217 base::PickleIterator iter(pickle);
218 base::flat_map<std::string, int> output;
219 EXPECT_TRUE(IPC::ReadParam(&pickle, &iter, &output));
220
221 EXPECT_EQ(input, output);
222 }
223
TEST(IPCMessageUtilsTest,StrongAlias)224 TEST(IPCMessageUtilsTest, StrongAlias) {
225 using TestType = base::StrongAlias<class Tag, int>;
226 TestType input(42);
227
228 base::Pickle pickle;
229 IPC::WriteParam(&pickle, input);
230
231 base::PickleIterator iter(pickle);
232 TestType output;
233 EXPECT_TRUE(IPC::ReadParam(&pickle, &iter, &output));
234
235 EXPECT_EQ(input, output);
236 }
237
TEST(IPCMessageUtilsTest,DictValueConversion)238 TEST(IPCMessageUtilsTest, DictValueConversion) {
239 base::Value::Dict dict_value;
240 dict_value.Set("path1", 42);
241 dict_value.Set("path2", 84);
242 base::Value::List subvalue;
243 subvalue.Append(1234);
244 subvalue.Append(5678);
245 dict_value.Set("path3", std::move(subvalue));
246
247 IPC::Message message;
248 ParamTraits<base::Value::Dict>::Write(&message, dict_value);
249
250 base::PickleIterator iter(message);
251 base::Value::Dict read_value;
252 ASSERT_TRUE(
253 ParamTraits<base::Value::Dict>::Read(&message, &iter, &read_value));
254 EXPECT_EQ(dict_value, read_value);
255 }
256
TEST(IPCMessageUtilsTest,ListValueConversion)257 TEST(IPCMessageUtilsTest, ListValueConversion) {
258 base::Value::List list_value;
259 list_value.Append(42);
260 list_value.Append(84);
261
262 IPC::Message message;
263 ParamTraits<base::Value::List>::Write(&message, list_value);
264
265 base::PickleIterator iter(message);
266 base::Value::List read_value;
267 ASSERT_TRUE(
268 ParamTraits<base::Value::List>::Read(&message, &iter, &read_value));
269 EXPECT_EQ(list_value, read_value);
270 }
271
272 #if BUILDFLAG(IS_WIN)
TEST(IPCMessageUtilsTest,ScopedHandle)273 TEST(IPCMessageUtilsTest, ScopedHandle) {
274 HANDLE raw_dupe_handle;
275 ASSERT_TRUE(::DuplicateHandle(::GetCurrentProcess(), ::GetCurrentProcess(),
276 ::GetCurrentProcess(), &raw_dupe_handle, 0,
277 FALSE, DUPLICATE_SAME_ACCESS));
278 base::win::ScopedHandle dupe_handle(raw_dupe_handle);
279
280 Message message(0, 0, Message::PRIORITY_LOW);
281 WriteParam(&message, dupe_handle);
282
283 base::PickleIterator iter(message);
284 base::win::ScopedHandle read_handle;
285 EXPECT_TRUE(ReadParam(&message, &iter, &read_handle));
286 EXPECT_TRUE(read_handle.IsValid());
287 }
288 #endif // BUILDFLAG(IS_WIN)
289
290 } // namespace
291 } // namespace IPC
292