services/api/test/unit/permission_test.rb

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: AGPL-3.0
   4
   5 require 'test_helper'
   6
   7 class PermissionTest < ActiveSupport::TestCase
   8   include CurrentApiClient
   9
  10   test "Grant permissions on an object I own" do
  11     set_user_from_auth :active_trustedclient
  12
  13     ob = Specimen.create
  14     assert ob.save
  15
  16     # Ensure I have permission to manage this group even when its owner changes
  17     perm_link = Link.create(tail_uuid: users(:active).uuid,
  18                             head_uuid: ob.uuid,
  19                             link_class: 'permission',
  20                             name: 'can_manage')
  21     assert perm_link.save, "should give myself permission on my own object"
  22   end
  23
  24   test "Delete permission links when deleting an object" do
  25     set_user_from_auth :active_trustedclient
  26
  27     ob = Specimen.create!
  28     Link.create!(tail_uuid: users(:active).uuid,
  29                  head_uuid: ob.uuid,
  30                  link_class: 'permission',
  31                  name: 'can_manage')
  32     ob_uuid = ob.uuid
  33     assert ob.destroy, "Could not destroy object with 1 permission link"
  34     assert_empty(Link.where(head_uuid: ob_uuid),
  35                  "Permission link was not deleted when object was deleted")
  36   end
  37
  38   test "permission links owned by root" do
  39     set_user_from_auth :active_trustedclient
  40     ob = Specimen.create!
  41     perm_link = Link.create!(tail_uuid: users(:active).uuid,
  42                              head_uuid: ob.uuid,
  43                              link_class: 'permission',
  44                              name: 'can_read')
  45     assert_equal system_user_uuid, perm_link.owner_uuid
  46   end
  47
  48   test "readable_by" do
  49     set_user_from_auth :active_trustedclient
  50
  51     ob = Specimen.create!
  52     Link.create!(tail_uuid: users(:active).uuid,
  53                  head_uuid: ob.uuid,
  54                  link_class: 'permission',
  55                  name: 'can_read')
  56     assert Specimen.readable_by(users(:active)).where(uuid: ob.uuid).any?, "user does not have read permission"
  57   end
  58
  59   test "writable_by" do
  60     set_user_from_auth :active_trustedclient
  61
  62     ob = Specimen.create!
  63     Link.create!(tail_uuid: users(:active).uuid,
  64                  head_uuid: ob.uuid,
  65                  link_class: 'permission',
  66                  name: 'can_write')
  67     assert ob.writable_by.include?(users(:active).uuid), "user does not have write permission"
  68   end
  69
  70   test "writable_by reports requesting user's own uuid for a writable project" do
  71     invited_to_write = users(:project_viewer)
  72     group = groups(:asubproject)
  73
  74     # project_view can read, but cannot see write or see writers list
  75     set_user_from_auth :project_viewer
  76     assert_equal([group.owner_uuid],
  77                  group.writable_by,
  78                  "writers list should just have owner_uuid")
  79
  80     # allow project_viewer to write for the remainder of the test
  81     set_user_from_auth :admin
  82     Link.create!(tail_uuid: invited_to_write.uuid,
  83                  head_uuid: group.uuid,
  84                  link_class: 'permission',
  85                  name: 'can_write')
  86     group.permissions.reload
  87
  88     # project_viewer should see self in writers list (but not all writers)
  89     set_user_from_auth :project_viewer
  90     assert_not_nil(group.writable_by,
  91                     "can write but cannot see writers list")
  92     assert_includes(group.writable_by, invited_to_write.uuid,
  93                     "self missing from writers list")
  94     assert_includes(group.writable_by, group.owner_uuid,
  95                     "project owner missing from writers list")
  96     refute_includes(group.writable_by, users(:active).uuid,
  97                     "saw :active user in writers list")
  98
  99     # active user should see full writers list
 100     set_user_from_auth :active
 101     assert_includes(group.writable_by, invited_to_write.uuid,
 102                     "permission just added, but missing from writers list")
 103
 104     # allow project_viewer to manage for the remainder of the test
 105     set_user_from_auth :admin
 106     Link.create!(tail_uuid: invited_to_write.uuid,
 107                  head_uuid: group.uuid,
 108                  link_class: 'permission',
 109                  name: 'can_manage')
 110     # invite another writer we can test for
 111     Link.create!(tail_uuid: users(:spectator).uuid,
 112                  head_uuid: group.uuid,
 113                  link_class: 'permission',
 114                  name: 'can_write')
 115     group.permissions.reload
 116
 117     set_user_from_auth :project_viewer
 118     assert_not_nil(group.writable_by,
 119                     "can manage but cannot see writers list")
 120     assert_includes(group.writable_by, users(:spectator).uuid,
 121                     ":spectator missing from writers list")
 122   end
 123
 124   test "user owns group, group can_manage object's group, user can add permissions" do
 125     set_user_from_auth :admin
 126
 127     owner_grp = Group.create!(owner_uuid: users(:active).uuid)
 128
 129     sp_grp = Group.create!
 130     sp = Specimen.create!(owner_uuid: sp_grp.uuid)
 131
 132     Link.create!(link_class: 'permission',
 133                  name: 'can_manage',
 134                  tail_uuid: owner_grp.uuid,
 135                  head_uuid: sp_grp.uuid)
 136
 137     # active user owns owner_grp, which has can_manage permission on sp_grp
 138     # user should be able to add permissions on sp.
 139     set_user_from_auth :active_trustedclient
 140     test_perm = Link.create(tail_uuid: users(:active).uuid,
 141                             head_uuid: sp.uuid,
 142                             link_class: 'permission',
 143                             name: 'can_write')
 144     assert test_perm.save, "could not save new permission on target object"
 145     assert test_perm.destroy, "could not delete new permission on target object"
 146   end
 147
 148   # bug #3091
 149   skip "can_manage permission on a non-group object" do
 150     set_user_from_auth :admin
 151
 152     ob = Specimen.create!
 153     # grant can_manage permission to active
 154     perm_link = Link.create!(tail_uuid: users(:active).uuid,
 155                              head_uuid: ob.uuid,
 156                              link_class: 'permission',
 157                              name: 'can_manage')
 158     # ob is owned by :admin, the link is owned by root
 159     assert_equal users(:admin).uuid, ob.owner_uuid
 160     assert_equal system_user_uuid, perm_link.owner_uuid
 161
 162     # user "active" can modify the permission link
 163     set_user_from_auth :active_trustedclient
 164     perm_link.properties["foo"] = 'bar'
 165     assert perm_link.save, "could not save modified link"
 166
 167     assert_equal 'bar', perm_link.properties['foo'], "link properties do not include foo = bar"
 168   end
 169
 170   test "user without can_manage permission may not modify permission link" do
 171     set_user_from_auth :admin
 172
 173     ob = Specimen.create!
 174     # grant can_manage permission to active
 175     perm_link = Link.create!(tail_uuid: users(:active).uuid,
 176                              head_uuid: ob.uuid,
 177                              link_class: 'permission',
 178                              name: 'can_read')
 179     # ob is owned by :admin, the link is owned by root
 180     assert_equal ob.owner_uuid, users(:admin).uuid
 181     assert_equal perm_link.owner_uuid, system_user_uuid
 182
 183     # user "active" may not modify the permission link
 184     set_user_from_auth :active_trustedclient
 185     perm_link.name = 'can_manage'
 186     assert_raises ArvadosModel::PermissionDeniedError do
 187       perm_link.save
 188     end
 189   end
 190
 191   test "manager user gets permission to minions' articles via can_manage link" do
 192     manager = create :active_user, first_name: "Manage", last_name: "Er"
 193     minion = create :active_user, first_name: "Min", last_name: "Ion"
 194     minions_specimen = act_as_user minion do
 195       Specimen.create!
 196     end
 197     # Manager creates a group. (Make sure it doesn't magically give
 198     # anyone any additional permissions.)
 199     g = nil
 200     act_as_user manager do
 201       g = create :group, name: "NoBigSecret Lab"
 202       assert_empty(User.readable_by(manager).where(uuid: minion.uuid),
 203                    "saw a user I shouldn't see")
 204       assert_raises(ArvadosModel::PermissionDeniedError,
 205                     ActiveRecord::RecordInvalid,
 206                     "gave can_read permission to a user I shouldn't see") do
 207         create(:permission_link,
 208                name: 'can_read', tail_uuid: minion.uuid, head_uuid: g.uuid)
 209       end
 210       %w(can_manage can_write can_read).each do |perm_type|
 211         assert_raises(ArvadosModel::PermissionDeniedError,
 212                       ActiveRecord::RecordInvalid,
 213                       "escalated privileges") do
 214           create(:permission_link,
 215                  name: perm_type, tail_uuid: g.uuid, head_uuid: minion.uuid)
 216         end
 217       end
 218       assert_empty(User.readable_by(manager).where(uuid: minion.uuid),
 219                    "manager saw minion too soon")
 220       assert_empty(User.readable_by(minion).where(uuid: manager.uuid),
 221                    "minion saw manager too soon")
 222       assert_empty(Group.readable_by(minion).where(uuid: g.uuid),
 223                    "minion saw manager's new NoBigSecret Lab group too soon")
 224
 225       # Manager declares everybody on the system should be able to see
 226       # the NoBigSecret Lab group.
 227       create(:permission_link,
 228              name: 'can_read',
 229              tail_uuid: 'zzzzz-j7d0g-fffffffffffffff',
 230              head_uuid: g.uuid)
 231       # ...but nobody has joined the group yet. Manager still can't see
 232       # minion.
 233       assert_empty(User.readable_by(manager).where(uuid: minion.uuid),
 234                    "manager saw minion too soon")
 235     end
 236
 237     act_as_user minion do
 238       # Minion can see the group.
 239       assert_not_empty(Group.readable_by(minion).where(uuid: g.uuid),
 240                        "minion could not see the NoBigSecret Lab group")
 241       # Minion joins the group.
 242       create(:permission_link,
 243              name: 'can_read',
 244              tail_uuid: g.uuid,
 245              head_uuid: minion.uuid)
 246     end
 247
 248     act_as_user manager do
 249       # Now, manager can see minion.
 250       assert_not_empty(User.readable_by(manager).where(uuid: minion.uuid),
 251                        "manager could not see minion")
 252       # But cannot obtain further privileges this way.
 253       assert_raises(ArvadosModel::PermissionDeniedError,
 254                     "escalated privileges") do
 255         create(:permission_link,
 256                name: 'can_manage', tail_uuid: manager.uuid, head_uuid: minion.uuid)
 257       end
 258       assert_empty(Specimen
 259                      .readable_by(manager)
 260                      .where(uuid: minions_specimen.uuid),
 261                    "manager saw the minion's private stuff")
 262       assert_raises(ArvadosModel::PermissionDeniedError,
 263                    "manager could update minion's private stuff") do
 264         minions_specimen.update_attributes(properties: {'x' => 'y'})
 265       end
 266     end
 267
 268     act_as_system_user do
 269       # Root can give Manager more privileges over Minion.
 270       create(:permission_link,
 271              name: 'can_manage', tail_uuid: g.uuid, head_uuid: minion.uuid)
 272     end
 273
 274     act_as_user manager do
 275       # Now, manager can read and write Minion's stuff.
 276       assert_not_empty(Specimen
 277                          .readable_by(manager)
 278                          .where(uuid: minions_specimen.uuid),
 279                        "manager could not find minion's specimen by uuid")
 280       assert_equal(true,
 281                    minions_specimen.update_attributes(properties: {'x' => 'y'}),
 282                    "manager could not update minion's specimen object")
 283     end
 284   end
 285
 286   test "users with bidirectional read permission in group can see each other, but cannot see each other's private articles" do
 287     a = create :active_user, first_name: "A"
 288     b = create :active_user, first_name: "B"
 289     other = create :active_user, first_name: "OTHER"
 290     act_as_system_user do
 291       g = create :group
 292       [a,b].each do |u|
 293         create(:permission_link,
 294                name: 'can_read', tail_uuid: u.uuid, head_uuid: g.uuid)
 295         create(:permission_link,
 296                name: 'can_read', head_uuid: u.uuid, tail_uuid: g.uuid)
 297       end
 298     end
 299     a_specimen = act_as_user a do
 300       Specimen.create!
 301     end
 302     assert_not_empty(Specimen.readable_by(a).where(uuid: a_specimen.uuid),
 303                      "A cannot read own Specimen, following test probably useless.")
 304     assert_empty(Specimen.readable_by(b).where(uuid: a_specimen.uuid),
 305                  "B can read A's Specimen")
 306     [a,b].each do |u|
 307       assert_empty(User.readable_by(u).where(uuid: other.uuid),
 308                    "#{u.first_name} can see OTHER in the user list")
 309       assert_empty(User.readable_by(other).where(uuid: u.uuid),
 310                    "OTHER can see #{u.first_name} in the user list")
 311       act_as_user u do
 312         assert_raises ArvadosModel::PermissionDeniedError, "wrote without perm" do
 313           other.update_attributes!(prefs: {'pwned' => true})
 314         end
 315         assert_equal(true, u.update_attributes!(prefs: {'thisisme' => true}),
 316                      "#{u.first_name} can't update its own prefs")
 317       end
 318       act_as_user other do
 319         assert_raises(ArvadosModel::PermissionDeniedError,
 320                         "OTHER wrote #{u.first_name} without perm") do
 321           u.update_attributes!(prefs: {'pwned' => true})
 322         end
 323         assert_equal(true, other.update_attributes!(prefs: {'thisisme' => true}),
 324                      "OTHER can't update its own prefs")
 325       end
 326     end
 327   end
 328
 329   test "cannot create with owner = unwritable user" do
 330     set_user_from_auth :rominiadmin
 331     assert_raises ArvadosModel::PermissionDeniedError, "created with owner = unwritable user" do
 332       Specimen.create!(owner_uuid: users(:active).uuid)
 333     end
 334   end
 335
 336   test "cannot change owner to unwritable user" do
 337     set_user_from_auth :rominiadmin
 338     ob = Specimen.create!
 339     assert_raises ArvadosModel::PermissionDeniedError, "changed owner to unwritable user" do
 340       ob.update_attributes!(owner_uuid: users(:active).uuid)
 341     end
 342   end
 343
 344   test "cannot create with owner = unwritable group" do
 345     set_user_from_auth :rominiadmin
 346     assert_raises ArvadosModel::PermissionDeniedError, "created with owner = unwritable group" do
 347       Specimen.create!(owner_uuid: groups(:aproject).uuid)
 348     end
 349   end
 350
 351   test "cannot change owner to unwritable group" do
 352     set_user_from_auth :rominiadmin
 353     ob = Specimen.create!
 354     assert_raises ArvadosModel::PermissionDeniedError, "changed owner to unwritable group" do
 355       ob.update_attributes!(owner_uuid: groups(:aproject).uuid)
 356     end
 357   end
 358
 359   def container_logs(container, user)
 360     Log.readable_by(users(user)).
 361       where(object_uuid: containers(container).uuid, event_type: "test")
 362   end
 363
 364   test "container logs created by dispatch are visible to container requestor" do
 365     set_user_from_auth :dispatch1
 366     Log.create!(object_uuid: containers(:running).uuid,
 367                 event_type: "test")
 368
 369     assert_not_empty container_logs(:running, :admin)
 370     assert_not_empty container_logs(:running, :active)
 371     assert_empty container_logs(:running, :spectator)
 372   end
 373
 374   test "container logs created by dispatch are public if container request is public" do
 375     set_user_from_auth :dispatch1
 376     Log.create!(object_uuid: containers(:running_older).uuid,
 377                 event_type: "test")
 378
 379     assert_not_empty container_logs(:running_older, :anonymous)
 380   end
 381 end