extensions/common/api/sockets/sockets_manifest_permission_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   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 <set>
   6
   7 #include "base/json/json_reader.h"
   8 #include "base/pickle.h"
   9 #include "base/values.h"
  10 #include "extensions/common/api/sockets/sockets_manifest_permission.h"
  11 #include "extensions/common/manifest_constants.h"
  12 #include "ipc/ipc_message.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 using content::SocketPermissionRequest;
  16
  17 namespace extensions {
  18
  19 namespace {
  20
  21 const char kUdpBindPermission[] =
  22     "{ \"udp\": { \"bind\": [\"127.0.0.1:3007\", \"a.com:80\"] } }";
  23
  24 const char kUdpSendPermission[] =
  25     "{ \"udp\": { \"send\": [\"\", \"a.com:80\"] } }";
  26
  27 const char kTcpConnectPermission[] =
  28     "{ \"tcp\": { \"connect\": [\"127.0.0.1:80\", \"a.com:80\"] } }";
  29
  30 const char kTcpServerListenPermission[] =
  31     "{ \"tcpServer\": { \"listen\": [\"127.0.0.1:80\", \"a.com:80\"] } }";
  32
  33 static void AssertEmptyPermission(const SocketsManifestPermission* permission) {
  34   EXPECT_TRUE(permission);
  35   EXPECT_EQ(std::string(extensions::manifest_keys::kSockets), permission->id());
  36   EXPECT_EQ(permission->id(), permission->name());
  37   EXPECT_FALSE(permission->HasMessages());
  38   EXPECT_EQ(0u, permission->entries().size());
  39 }
  40
  41 static scoped_ptr<base::Value> ParsePermissionJSON(const std::string& json) {
  42   scoped_ptr<base::Value> result(base::JSONReader::Read(json));
  43   EXPECT_TRUE(result) << "Invalid JSON string: " << json;
  44   return result.Pass();
  45 }
  46
  47 static scoped_ptr<SocketsManifestPermission> PermissionFromValue(
  48     const base::Value& value) {
  49   base::string16 error16;
  50   scoped_ptr<SocketsManifestPermission> permission(
  51       SocketsManifestPermission::FromValue(value, &error16));
  52   EXPECT_TRUE(permission) << "Error parsing Value into permission: " << error16;
  53   return permission.Pass();
  54 }
  55
  56 static scoped_ptr<SocketsManifestPermission> PermissionFromJSON(
  57     const std::string& json) {
  58   scoped_ptr<base::Value> value(ParsePermissionJSON(json));
  59   return PermissionFromValue(*value);
  60 }
  61
  62 struct CheckFormatEntry {
  63   CheckFormatEntry(SocketPermissionRequest::OperationType operation_type,
  64                    std::string host_pattern)
  65       : operation_type(operation_type), host_pattern(host_pattern) {}
  66
  67   // operators <, == are needed by container std::set and algorithms
  68   // std::set_includes and std::set_differences.
  69   bool operator<(const CheckFormatEntry& rhs) const {
  70     if (operation_type == rhs.operation_type)
  71       return host_pattern < rhs.host_pattern;
  72
  73     return operation_type < rhs.operation_type;
  74   }
  75
  76   bool operator==(const CheckFormatEntry& rhs) const {
  77     return operation_type == rhs.operation_type &&
  78            host_pattern == rhs.host_pattern;
  79   }
  80
  81   SocketPermissionRequest::OperationType operation_type;
  82   std::string host_pattern;
  83 };
  84
  85 static testing::AssertionResult CheckFormat(
  86     std::multiset<CheckFormatEntry> permissions,
  87     const std::string& json) {
  88   scoped_ptr<SocketsManifestPermission> permission(PermissionFromJSON(json));
  89   if (!permission)
  90     return testing::AssertionFailure() << "Invalid permission " << json;
  91
  92   if (permissions.size() != permission->entries().size()) {
  93     return testing::AssertionFailure()
  94            << "Incorrect # of entries in json: " << json;
  95   }
  96
  97   // Note: We use multiset because SocketsManifestPermission does not have to
  98   // store entries in the order found in the json message.
  99   std::multiset<CheckFormatEntry> parsed_permissions;
 100   for (SocketsManifestPermission::SocketPermissionEntrySet::const_iterator it =
 101            permission->entries().begin();
 102        it != permission->entries().end();
 103        ++it) {
 104     parsed_permissions.insert(
 105         CheckFormatEntry(it->pattern().type, it->GetHostPatternAsString()));
 106   }
 107
 108   if (!std::equal(
 109           permissions.begin(), permissions.end(), parsed_permissions.begin())) {
 110     return testing::AssertionFailure() << "Incorrect socket operations.";
 111   }
 112   return testing::AssertionSuccess();
 113 }
 114
 115 static testing::AssertionResult CheckFormat(const std::string& json) {
 116   return CheckFormat(std::multiset<CheckFormatEntry>(), json);
 117 }
 118
 119 static testing::AssertionResult CheckFormat(const std::string& json,
 120                                             const CheckFormatEntry& op1) {
 121   CheckFormatEntry entries[] = {op1};
 122   return CheckFormat(
 123       std::multiset<CheckFormatEntry>(entries, entries + arraysize(entries)),
 124       json);
 125 }
 126
 127 static testing::AssertionResult CheckFormat(const std::string& json,
 128                                             const CheckFormatEntry& op1,
 129                                             const CheckFormatEntry& op2) {
 130   CheckFormatEntry entries[] = {op1, op2};
 131   return CheckFormat(
 132       std::multiset<CheckFormatEntry>(entries, entries + arraysize(entries)),
 133       json);
 134 }
 135
 136 static testing::AssertionResult CheckFormat(const std::string& json,
 137                                             const CheckFormatEntry& op1,
 138                                             const CheckFormatEntry& op2,
 139                                             const CheckFormatEntry& op3,
 140                                             const CheckFormatEntry& op4,
 141                                             const CheckFormatEntry& op5,
 142                                             const CheckFormatEntry& op6,
 143                                             const CheckFormatEntry& op7,
 144                                             const CheckFormatEntry& op8,
 145                                             const CheckFormatEntry& op9) {
 146   CheckFormatEntry entries[] = {op1, op2, op3, op4, op5, op6, op7, op8, op9};
 147   return CheckFormat(
 148       std::multiset<CheckFormatEntry>(entries, entries + arraysize(entries)),
 149       json);
 150 }
 151
 152 }  // namespace
 153
 154 TEST(SocketsManifestPermissionTest, Empty) {
 155   // Construction
 156   scoped_ptr<SocketsManifestPermission> permission(
 157       new SocketsManifestPermission());
 158   AssertEmptyPermission(permission.get());
 159
 160   // Clone()/Equal()
 161   scoped_ptr<SocketsManifestPermission> clone(
 162       static_cast<SocketsManifestPermission*>(permission->Clone()));
 163   AssertEmptyPermission(clone.get());
 164
 165   EXPECT_TRUE(permission->Equal(clone.get()));
 166
 167   // ToValue()/FromValue()
 168   scoped_ptr<const base::Value> value(permission->ToValue());
 169   EXPECT_TRUE(value.get());
 170
 171   scoped_ptr<SocketsManifestPermission> permission2(
 172       new SocketsManifestPermission());
 173   EXPECT_TRUE(permission2->FromValue(value.get()));
 174   AssertEmptyPermission(permission2.get());
 175
 176   // Union/Diff/Intersection
 177   scoped_ptr<SocketsManifestPermission> diff_perm(
 178       static_cast<SocketsManifestPermission*>(permission->Diff(clone.get())));
 179   AssertEmptyPermission(diff_perm.get());
 180
 181   scoped_ptr<SocketsManifestPermission> union_perm(
 182       static_cast<SocketsManifestPermission*>(permission->Union(clone.get())));
 183   AssertEmptyPermission(union_perm.get());
 184
 185   scoped_ptr<SocketsManifestPermission> intersect_perm(
 186       static_cast<SocketsManifestPermission*>(
 187           permission->Intersect(clone.get())));
 188   AssertEmptyPermission(intersect_perm.get());
 189
 190   // IPC
 191   scoped_ptr<SocketsManifestPermission> ipc_perm(
 192       new SocketsManifestPermission());
 193   scoped_ptr<SocketsManifestPermission> ipc_perm2(
 194       new SocketsManifestPermission());
 195
 196   IPC::Message m;
 197   ipc_perm->Write(&m);
 198   PickleIterator iter(m);
 199   EXPECT_TRUE(ipc_perm2->Read(&m, &iter));
 200   AssertEmptyPermission(ipc_perm2.get());
 201 }
 202
 203 TEST(SocketsManifestPermissionTest, JSONFormats) {
 204   EXPECT_TRUE(CheckFormat(
 205       "{\"udp\":{\"send\":\"\"}}",
 206       CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "*:*")));
 207   EXPECT_TRUE(CheckFormat("{\"udp\":{\"send\":[]}}"));
 208   EXPECT_TRUE(CheckFormat(
 209       "{\"udp\":{\"send\":[\"\"]}}",
 210       CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "*:*")));
 211   EXPECT_TRUE(CheckFormat(
 212       "{\"udp\":{\"send\":[\"a:80\", \"b:10\"]}}",
 213       CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "a:80"),
 214       CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "b:10")));
 215
 216   EXPECT_TRUE(
 217       CheckFormat("{\"udp\":{\"bind\":\"\"}}",
 218                   CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "*:*")));
 219   EXPECT_TRUE(CheckFormat("{\"udp\":{\"bind\":[]}}"));
 220   EXPECT_TRUE(
 221       CheckFormat("{\"udp\":{\"bind\":[\"\"]}}",
 222                   CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "*:*")));
 223   EXPECT_TRUE(
 224       CheckFormat("{\"udp\":{\"bind\":[\"a:80\", \"b:10\"]}}",
 225                   CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "a:80"),
 226                   CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "b:10")));
 227
 228   EXPECT_TRUE(CheckFormat(
 229       "{\"udp\":{\"multicastMembership\":\"\"}}",
 230       CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, "")));
 231   EXPECT_TRUE(CheckFormat("{\"udp\":{\"multicastMembership\":[]}}"));
 232   EXPECT_TRUE(CheckFormat(
 233       "{\"udp\":{\"multicastMembership\":[\"\"]}}",
 234       CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, "")));
 235   EXPECT_TRUE(CheckFormat(
 236       "{\"udp\":{\"multicastMembership\":[\"\", \"\"]}}",
 237       CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, "")));
 238
 239   EXPECT_TRUE(CheckFormat(
 240       "{\"tcp\":{\"connect\":\"\"}}",
 241       CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "*:*")));
 242   EXPECT_TRUE(CheckFormat("{\"tcp\":{\"connect\":[]}}"));
 243   EXPECT_TRUE(CheckFormat(
 244       "{\"tcp\":{\"connect\":[\"\"]}}",
 245       CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "*:*")));
 246   EXPECT_TRUE(CheckFormat(
 247       "{\"tcp\":{\"connect\":[\"a:80\", \"b:10\"]}}",
 248       CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "a:80"),
 249       CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "b:10")));
 250
 251   EXPECT_TRUE(CheckFormat(
 252       "{\"tcpServer\":{\"listen\":\"\"}}",
 253       CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "*:*")));
 254   EXPECT_TRUE(CheckFormat("{\"tcpServer\":{\"listen\":[]}}"));
 255   EXPECT_TRUE(CheckFormat(
 256       "{\"tcpServer\":{\"listen\":[\"\"]}}",
 257       CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "*:*")));
 258   EXPECT_TRUE(CheckFormat(
 259       "{\"tcpServer\":{\"listen\":[\"a:80\", \"b:10\"]}}",
 260       CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "a:80"),
 261       CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "b:10")));
 262
 263   EXPECT_TRUE(CheckFormat(
 264       "{"
 265       "\"udp\":{"
 266       "\"send\":[\"a:80\", \"b:10\"],"
 267       "\"bind\":[\"a:80\", \"b:10\"],"
 268       "\"multicastMembership\":\"\""
 269       "},"
 270       "\"tcp\":{\"connect\":[\"a:80\", \"b:10\"]},"
 271       "\"tcpServer\":{\"listen\":[\"a:80\", \"b:10\"]}"
 272       "}",
 273       CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "a:80"),
 274       CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "b:10"),
 275       CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "a:80"),
 276       CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "b:10"),
 277       CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, ""),
 278       CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "a:80"),
 279       CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "b:10"),
 280       CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "a:80"),
 281       CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "b:10")));
 282 }
 283
 284 TEST(SocketsManifestPermissionTest, FromToValue) {
 285   scoped_ptr<base::Value> udp_send(ParsePermissionJSON(kUdpBindPermission));
 286   scoped_ptr<base::Value> udp_bind(ParsePermissionJSON(kUdpSendPermission));
 287   scoped_ptr<base::Value> tcp_connect(
 288       ParsePermissionJSON(kTcpConnectPermission));
 289   scoped_ptr<base::Value> tcp_server_listen(
 290       ParsePermissionJSON(kTcpServerListenPermission));
 291
 292   // FromValue()
 293   scoped_ptr<SocketsManifestPermission> permission1(
 294       new SocketsManifestPermission());
 295   EXPECT_TRUE(permission1->FromValue(udp_send.get()));
 296   EXPECT_EQ(2u, permission1->entries().size());
 297
 298   scoped_ptr<SocketsManifestPermission> permission2(
 299       new SocketsManifestPermission());
 300   EXPECT_TRUE(permission2->FromValue(udp_bind.get()));
 301   EXPECT_EQ(2u, permission2->entries().size());
 302
 303   scoped_ptr<SocketsManifestPermission> permission3(
 304       new SocketsManifestPermission());
 305   EXPECT_TRUE(permission3->FromValue(tcp_connect.get()));
 306   EXPECT_EQ(2u, permission3->entries().size());
 307
 308   scoped_ptr<SocketsManifestPermission> permission4(
 309       new SocketsManifestPermission());
 310   EXPECT_TRUE(permission4->FromValue(tcp_server_listen.get()));
 311   EXPECT_EQ(2u, permission4->entries().size());
 312
 313   // ToValue()
 314   scoped_ptr<base::Value> value1 = permission1->ToValue();
 315   EXPECT_TRUE(value1);
 316   scoped_ptr<SocketsManifestPermission> permission1_1(
 317       new SocketsManifestPermission());
 318   EXPECT_TRUE(permission1_1->FromValue(value1.get()));
 319   EXPECT_TRUE(permission1->Equal(permission1_1.get()));
 320
 321   scoped_ptr<base::Value> value2 = permission2->ToValue();
 322   EXPECT_TRUE(value2);
 323   scoped_ptr<SocketsManifestPermission> permission2_1(
 324       new SocketsManifestPermission());
 325   EXPECT_TRUE(permission2_1->FromValue(value2.get()));
 326   EXPECT_TRUE(permission2->Equal(permission2_1.get()));
 327
 328   scoped_ptr<base::Value> value3 = permission3->ToValue();
 329   EXPECT_TRUE(value3);
 330   scoped_ptr<SocketsManifestPermission> permission3_1(
 331       new SocketsManifestPermission());
 332   EXPECT_TRUE(permission3_1->FromValue(value3.get()));
 333   EXPECT_TRUE(permission3->Equal(permission3_1.get()));
 334
 335   scoped_ptr<base::Value> value4 = permission4->ToValue();
 336   EXPECT_TRUE(value4);
 337   scoped_ptr<SocketsManifestPermission> permission4_1(
 338       new SocketsManifestPermission());
 339   EXPECT_TRUE(permission4_1->FromValue(value4.get()));
 340   EXPECT_TRUE(permission4->Equal(permission4_1.get()));
 341 }
 342
 343 TEST(SocketsManifestPermissionTest, SetOperations) {
 344   scoped_ptr<SocketsManifestPermission> permission1(
 345       PermissionFromJSON(kUdpBindPermission));
 346   scoped_ptr<SocketsManifestPermission> permission2(
 347       PermissionFromJSON(kUdpSendPermission));
 348   scoped_ptr<SocketsManifestPermission> permission3(
 349       PermissionFromJSON(kTcpConnectPermission));
 350   scoped_ptr<SocketsManifestPermission> permission4(
 351       PermissionFromJSON(kTcpServerListenPermission));
 352
 353   // Union
 354   scoped_ptr<SocketsManifestPermission> union_perm(
 355       static_cast<SocketsManifestPermission*>(
 356           permission1->Union(permission2.get())));
 357   EXPECT_TRUE(union_perm);
 358   EXPECT_EQ(4u, union_perm->entries().size());
 359
 360   EXPECT_TRUE(union_perm->Contains(permission1.get()));
 361   EXPECT_TRUE(union_perm->Contains(permission2.get()));
 362   EXPECT_FALSE(union_perm->Contains(permission3.get()));
 363   EXPECT_FALSE(union_perm->Contains(permission4.get()));
 364
 365   // Diff
 366   scoped_ptr<SocketsManifestPermission> diff_perm1(
 367       static_cast<SocketsManifestPermission*>(
 368           permission1->Diff(permission2.get())));
 369   EXPECT_TRUE(diff_perm1);
 370   EXPECT_EQ(2u, diff_perm1->entries().size());
 371
 372   EXPECT_TRUE(permission1->Equal(diff_perm1.get()));
 373   EXPECT_TRUE(diff_perm1->Equal(permission1.get()));
 374
 375   scoped_ptr<SocketsManifestPermission> diff_perm2(
 376       static_cast<SocketsManifestPermission*>(
 377           permission1->Diff(union_perm.get())));
 378   EXPECT_TRUE(diff_perm2);
 379   AssertEmptyPermission(diff_perm2.get());
 380
 381   // Intersection
 382   scoped_ptr<SocketsManifestPermission> intersect_perm1(
 383       static_cast<SocketsManifestPermission*>(
 384           union_perm->Intersect(permission1.get())));
 385   EXPECT_TRUE(intersect_perm1);
 386   EXPECT_EQ(2u, intersect_perm1->entries().size());
 387
 388   EXPECT_TRUE(permission1->Equal(intersect_perm1.get()));
 389   EXPECT_TRUE(intersect_perm1->Equal(permission1.get()));
 390 }
 391
 392 TEST(SocketsManifestPermissionTest, IPC) {
 393   scoped_ptr<SocketsManifestPermission> permission(
 394       PermissionFromJSON(kUdpBindPermission));
 395
 396   scoped_ptr<SocketsManifestPermission> ipc_perm(
 397       static_cast<SocketsManifestPermission*>(permission->Clone()));
 398   scoped_ptr<SocketsManifestPermission> ipc_perm2(
 399       new SocketsManifestPermission());
 400
 401   IPC::Message m;
 402   ipc_perm->Write(&m);
 403   PickleIterator iter(m);
 404   EXPECT_TRUE(ipc_perm2->Read(&m, &iter));
 405   EXPECT_TRUE(permission->Equal(ipc_perm2.get()));
 406 }
 407
 408 }  // namespace extensions