<!--
  Copyright 2018 The ChromiumOS Authors
  Use of this source code is governed by a BSD-style license that can be
  found in the LICENSE file.
-->
<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
  "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
<busconfig>
  <policy user="bootlockboxd">
    <allow own="org.chromium.BootLockbox" />
    <allow receive_sender="org.chromium.BootLockbox" />
    <allow send_destination="org.chromium.BootLockbox" />
  </policy>
  <policy user="root">
    <allow send_destination="org.chromium.BootLockbox"
           send_interface="org.chromium.BootLockboxInterface"
           send_member="ReadBootLockbox"/>
    <allow send_destination="org.chromium.BootLockbox"
           send_interface="org.chromium.BootLockboxInterface"
           send_member="StoreBootLockbox"/>
    <allow send_destination="org.chromium.BootLockbox"
           send_interface="org.chromium.BootLockboxInterface"
           send_member="FinalizeBootLockbox"/>
  </policy>
</busconfig>
