Home | History | Annotate | Download | only in permissions 
      1 // Copyright 2013 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 "base/pickle.h"
      6 #include "base/values.h"
      7 #include "chrome/common/extensions/extension_messages.h"
      8 #include "extensions/common/permissions/api_permission_set.h"
      9 #include "extensions/common/permissions/permissions_info.h"
     10 #include "ipc/ipc_message.h"
     11 #include "testing/gtest/include/gtest/gtest.h"
     12 
     13 namespace extensions {
     14 
     15 TEST(APIPermissionSetTest, General) {
     16   APIPermissionSet apis;
     17   apis.insert(APIPermission::kTab);
     18   apis.insert(APIPermission::kBackground);
     19   apis.insert(APIPermission::kProxy);
     20   apis.insert(APIPermission::kClipboardWrite);
     21   apis.insert(APIPermission::kPlugin);
     22 
     23   EXPECT_EQ(apis.find(APIPermission::kProxy)->id(), APIPermission::kProxy);
     24   EXPECT_TRUE(apis.find(APIPermission::kSocket) == apis.end());
     25 
     26   EXPECT_EQ(apis.size(), 5u);
     27 
     28   EXPECT_EQ(apis.erase(APIPermission::kTab), 1u);
     29   EXPECT_EQ(apis.size(), 4u);
     30 
     31   EXPECT_EQ(apis.erase(APIPermission::kTab), 0u);
     32   EXPECT_EQ(apis.size(), 4u);
     33 }
     34 
     35 TEST(APIPermissionSetTest, CreateUnion) {
     36   APIPermission* permission = NULL;
     37 
     38   APIPermissionSet apis1;
     39   APIPermissionSet apis2;
     40   APIPermissionSet expected_apis;
     41   APIPermissionSet result;
     42 
     43   const APIPermissionInfo* permission_info =
     44     PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
     45   permission = permission_info->CreateAPIPermission();
     46   {
     47     scoped_ptr<base::ListValue> value(new base::ListValue());
     48     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
     49     value->Append(new base::StringValue("udp-bind::8080"));
     50     value->Append(new base::StringValue("udp-send-to::8888"));
     51     if (!permission->FromValue(value.get())) {
     52       NOTREACHED();
     53     }
     54   }
     55 
     56   // Union with an empty set.
     57   apis1.insert(APIPermission::kTab);
     58   apis1.insert(APIPermission::kBackground);
     59   apis1.insert(permission->Clone());
     60   expected_apis.insert(APIPermission::kTab);
     61   expected_apis.insert(APIPermission::kBackground);
     62   expected_apis.insert(permission);
     63 
     64   APIPermissionSet::Union(apis1, apis2, &result);
     65 
     66   EXPECT_TRUE(apis1.Contains(apis2));
     67   EXPECT_TRUE(apis1.Contains(result));
     68   EXPECT_FALSE(apis2.Contains(apis1));
     69   EXPECT_FALSE(apis2.Contains(result));
     70   EXPECT_TRUE(result.Contains(apis1));
     71   EXPECT_TRUE(result.Contains(apis2));
     72 
     73   EXPECT_EQ(expected_apis, result);
     74 
     75   // Now use a real second set.
     76   apis2.insert(APIPermission::kTab);
     77   apis2.insert(APIPermission::kProxy);
     78   apis2.insert(APIPermission::kClipboardWrite);
     79   apis2.insert(APIPermission::kPlugin);
     80 
     81   permission = permission_info->CreateAPIPermission();
     82   {
     83     scoped_ptr<base::ListValue> value(new base::ListValue());
     84     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
     85     value->Append(new base::StringValue("udp-send-to::8899"));
     86     if (!permission->FromValue(value.get())) {
     87       NOTREACHED();
     88     }
     89   }
     90   apis2.insert(permission);
     91 
     92   expected_apis.insert(APIPermission::kTab);
     93   expected_apis.insert(APIPermission::kProxy);
     94   expected_apis.insert(APIPermission::kClipboardWrite);
     95   expected_apis.insert(APIPermission::kPlugin);
     96 
     97   permission = permission_info->CreateAPIPermission();
     98   {
     99     scoped_ptr<base::ListValue> value(new base::ListValue());
    100     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
    101     value->Append(new base::StringValue("udp-bind::8080"));
    102     value->Append(new base::StringValue("udp-send-to::8888"));
    103     value->Append(new base::StringValue("udp-send-to::8899"));
    104     if (!permission->FromValue(value.get())) {
    105       NOTREACHED();
    106     }
    107   }
    108   // Insert a new socket permission which will replace the old one.
    109   expected_apis.insert(permission);
    110 
    111   APIPermissionSet::Union(apis1, apis2, &result);
    112 
    113   EXPECT_FALSE(apis1.Contains(apis2));
    114   EXPECT_FALSE(apis1.Contains(result));
    115   EXPECT_FALSE(apis2.Contains(apis1));
    116   EXPECT_FALSE(apis2.Contains(result));
    117   EXPECT_TRUE(result.Contains(apis1));
    118   EXPECT_TRUE(result.Contains(apis2));
    119 
    120   EXPECT_EQ(expected_apis, result);
    121 }
    122 
    123 TEST(APIPermissionSetTest, CreateIntersection) {
    124   APIPermission* permission = NULL;
    125 
    126   APIPermissionSet apis1;
    127   APIPermissionSet apis2;
    128   APIPermissionSet expected_apis;
    129   APIPermissionSet result;
    130 
    131   const APIPermissionInfo* permission_info =
    132     PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
    133 
    134   // Intersection with an empty set.
    135   apis1.insert(APIPermission::kTab);
    136   apis1.insert(APIPermission::kBackground);
    137   permission = permission_info->CreateAPIPermission();
    138   {
    139     scoped_ptr<base::ListValue> value(new base::ListValue());
    140     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
    141     value->Append(new base::StringValue("udp-bind::8080"));
    142     value->Append(new base::StringValue("udp-send-to::8888"));
    143     if (!permission->FromValue(value.get())) {
    144       NOTREACHED();
    145     }
    146   }
    147   apis1.insert(permission);
    148 
    149   APIPermissionSet::Intersection(apis1, apis2, &result);
    150   EXPECT_TRUE(apis1.Contains(result));
    151   EXPECT_TRUE(apis2.Contains(result));
    152   EXPECT_TRUE(apis1.Contains(apis2));
    153   EXPECT_FALSE(apis2.Contains(apis1));
    154   EXPECT_FALSE(result.Contains(apis1));
    155   EXPECT_TRUE(result.Contains(apis2));
    156 
    157   EXPECT_TRUE(result.empty());
    158   EXPECT_EQ(expected_apis, result);
    159 
    160   // Now use a real second set.
    161   apis2.insert(APIPermission::kTab);
    162   apis2.insert(APIPermission::kProxy);
    163   apis2.insert(APIPermission::kClipboardWrite);
    164   apis2.insert(APIPermission::kPlugin);
    165   permission = permission_info->CreateAPIPermission();
    166   {
    167     scoped_ptr<base::ListValue> value(new base::ListValue());
    168     value->Append(new base::StringValue("udp-bind::8080"));
    169     value->Append(new base::StringValue("udp-send-to::8888"));
    170     value->Append(new base::StringValue("udp-send-to::8899"));
    171     if (!permission->FromValue(value.get())) {
    172       NOTREACHED();
    173     }
    174   }
    175   apis2.insert(permission);
    176 
    177   expected_apis.insert(APIPermission::kTab);
    178   permission = permission_info->CreateAPIPermission();
    179   {
    180     scoped_ptr<base::ListValue> value(new base::ListValue());
    181     value->Append(new base::StringValue("udp-bind::8080"));
    182     value->Append(new base::StringValue("udp-send-to::8888"));
    183     if (!permission->FromValue(value.get())) {
    184       NOTREACHED();
    185     }
    186   }
    187   expected_apis.insert(permission);
    188 
    189   APIPermissionSet::Intersection(apis1, apis2, &result);
    190 
    191   EXPECT_TRUE(apis1.Contains(result));
    192   EXPECT_TRUE(apis2.Contains(result));
    193   EXPECT_FALSE(apis1.Contains(apis2));
    194   EXPECT_FALSE(apis2.Contains(apis1));
    195   EXPECT_FALSE(result.Contains(apis1));
    196   EXPECT_FALSE(result.Contains(apis2));
    197 
    198   EXPECT_EQ(expected_apis, result);
    199 }
    200 
    201 TEST(APIPermissionSetTest, CreateDifference) {
    202   APIPermission* permission = NULL;
    203 
    204   APIPermissionSet apis1;
    205   APIPermissionSet apis2;
    206   APIPermissionSet expected_apis;
    207   APIPermissionSet result;
    208 
    209   const APIPermissionInfo* permission_info =
    210     PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
    211 
    212   // Difference with an empty set.
    213   apis1.insert(APIPermission::kTab);
    214   apis1.insert(APIPermission::kBackground);
    215   permission = permission_info->CreateAPIPermission();
    216   {
    217     scoped_ptr<base::ListValue> value(new base::ListValue());
    218     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
    219     value->Append(new base::StringValue("udp-bind::8080"));
    220     value->Append(new base::StringValue("udp-send-to::8888"));
    221     if (!permission->FromValue(value.get())) {
    222       NOTREACHED();
    223     }
    224   }
    225   apis1.insert(permission);
    226 
    227   APIPermissionSet::Difference(apis1, apis2, &result);
    228 
    229   EXPECT_EQ(apis1, result);
    230 
    231   // Now use a real second set.
    232   apis2.insert(APIPermission::kTab);
    233   apis2.insert(APIPermission::kProxy);
    234   apis2.insert(APIPermission::kClipboardWrite);
    235   apis2.insert(APIPermission::kPlugin);
    236   permission = permission_info->CreateAPIPermission();
    237   {
    238     scoped_ptr<base::ListValue> value(new base::ListValue());
    239     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
    240     value->Append(new base::StringValue("udp-send-to::8899"));
    241     if (!permission->FromValue(value.get())) {
    242       NOTREACHED();
    243     }
    244   }
    245   apis2.insert(permission);
    246 
    247   expected_apis.insert(APIPermission::kBackground);
    248   permission = permission_info->CreateAPIPermission();
    249   {
    250     scoped_ptr<base::ListValue> value(new base::ListValue());
    251     value->Append(new base::StringValue("udp-bind::8080"));
    252     value->Append(new base::StringValue("udp-send-to::8888"));
    253     if (!permission->FromValue(value.get())) {
    254       NOTREACHED();
    255     }
    256   }
    257   expected_apis.insert(permission);
    258 
    259   APIPermissionSet::Difference(apis1, apis2, &result);
    260 
    261   EXPECT_TRUE(apis1.Contains(result));
    262   EXPECT_FALSE(apis2.Contains(result));
    263 
    264   EXPECT_EQ(expected_apis, result);
    265 
    266   // |result| = |apis1| - |apis2| --> |result| intersect |apis2| == empty_set
    267   APIPermissionSet result2;
    268   APIPermissionSet::Intersection(result, apis2, &result2);
    269   EXPECT_TRUE(result2.empty());
    270 }
    271 
    272 TEST(APIPermissionSetTest, IPC) {
    273   APIPermission* permission = NULL;
    274 
    275   APIPermissionSet apis;
    276   APIPermissionSet expected_apis;
    277 
    278   const APIPermissionInfo* permission_info =
    279     PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
    280 
    281   apis.insert(APIPermission::kTab);
    282   apis.insert(APIPermission::kBackground);
    283   permission = permission_info->CreateAPIPermission();
    284   {
    285     scoped_ptr<base::ListValue> value(new base::ListValue());
    286     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
    287     value->Append(new base::StringValue("udp-bind::8080"));
    288     value->Append(new base::StringValue("udp-send-to::8888"));
    289     if (!permission->FromValue(value.get())) {
    290       NOTREACHED();
    291     }
    292   }
    293   apis.insert(permission);
    294 
    295   EXPECT_NE(apis, expected_apis);
    296 
    297   IPC::Message m;
    298   WriteParam(&m, apis);
    299   PickleIterator iter(m);
    300   CHECK(ReadParam(&m, &iter, &expected_apis));
    301   EXPECT_EQ(apis, expected_apis);
    302 }
    303 
    304 TEST(APIPermissionSetTest, ImplicitPermissions) {
    305   APIPermissionSet apis;
    306   apis.insert(APIPermission::kFileSystemWrite);
    307   apis.AddImpliedPermissions();
    308 
    309   EXPECT_EQ(apis.find(APIPermission::kFileSystemWrite)->id(),
    310             APIPermission::kFileSystemWrite);
    311   EXPECT_EQ(apis.size(), 1u);
    312 
    313   apis.erase(APIPermission::kFileSystemWrite);
    314   apis.insert(APIPermission::kFileSystemDirectory);
    315   apis.AddImpliedPermissions();
    316 
    317   EXPECT_EQ(apis.find(APIPermission::kFileSystemDirectory)->id(),
    318             APIPermission::kFileSystemDirectory);
    319   EXPECT_EQ(apis.size(), 1u);
    320 
    321   apis.insert(APIPermission::kFileSystemWrite);
    322   apis.AddImpliedPermissions();
    323 
    324   EXPECT_EQ(apis.find(APIPermission::kFileSystemWrite)->id(),
    325             APIPermission::kFileSystemWrite);
    326   EXPECT_EQ(apis.find(APIPermission::kFileSystemDirectory)->id(),
    327             APIPermission::kFileSystemDirectory);
    328   EXPECT_EQ(apis.find(APIPermission::kFileSystemWriteDirectory)->id(),
    329             APIPermission::kFileSystemWriteDirectory);
    330   EXPECT_EQ(apis.size(), 3u);
    331 }
    332 
    333 }  // namespace extensions
    334