baseline_policy_android_unittest.cc 4.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138
  1. // Copyright 2018 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. #include "sandbox/linux/seccomp-bpf-helpers/baseline_policy_android.h"
  5. #include <fcntl.h>
  6. #include <linux/android/binder.h>
  7. #include <linux/ashmem.h>
  8. #include <linux/nbd.h>
  9. #include <linux/userfaultfd.h>
  10. #include <sched.h>
  11. #include <sys/ioctl.h>
  12. #include <sys/resource.h>
  13. #include <sys/stat.h>
  14. #include <sys/types.h>
  15. #include "base/files/scoped_file.h"
  16. #include "base/posix/eintr_wrapper.h"
  17. #include "sandbox/linux/seccomp-bpf-helpers/sigsys_handlers.h"
  18. #include "sandbox/linux/seccomp-bpf/bpf_tests.h"
  19. namespace sandbox {
  20. namespace {
  21. BPF_TEST_C(BaselinePolicyAndroid, Getrusage, BaselinePolicyAndroid) {
  22. struct rusage usage{};
  23. errno = 0;
  24. BPF_ASSERT_EQ(0, getrusage(RUSAGE_SELF, &usage));
  25. errno = 0;
  26. BPF_ASSERT_EQ(0, getrusage(RUSAGE_THREAD, &usage));
  27. }
  28. BPF_TEST_C(BaselinePolicyAndroid, CanOpenProcCpuinfo, BaselinePolicyAndroid) {
  29. // This is required for |android_getCpuFeatures()|, which is used to enable
  30. // various fast paths in the renderer (for instance, in zlib).
  31. //
  32. // __NR_open is blocked in 64 bit mode, but as long as libc's open() redirects
  33. // open() to openat(), then this should work. Make sure this stays true.
  34. BPF_ASSERT_NE(-1, open("/proc/cpuinfo", O_RDONLY));
  35. }
  36. BPF_TEST_C(BaselinePolicyAndroid, Membarrier, BaselinePolicyAndroid) {
  37. // Should not crash.
  38. syscall(__NR_membarrier, 32 /* cmd */, 0 /* flags */);
  39. }
  40. BPF_TEST_C(BaselinePolicyAndroid,
  41. SchedGetAffinity_Blocked,
  42. BaselinePolicyAndroid) {
  43. cpu_set_t set{};
  44. errno = 0;
  45. BPF_ASSERT_EQ(-1, sched_getaffinity(0, sizeof(set), &set));
  46. BPF_ASSERT_EQ(EPERM, errno);
  47. }
  48. BPF_TEST_C(BaselinePolicyAndroid,
  49. SchedSetAffinity_Blocked,
  50. BaselinePolicyAndroid) {
  51. cpu_set_t set{};
  52. errno = 0;
  53. BPF_ASSERT_EQ(-1, sched_setaffinity(0, sizeof(set), &set));
  54. BPF_ASSERT_EQ(EPERM, errno);
  55. }
  56. BPF_TEST_C(BaselinePolicyAndroid, Ioctl_Allowed, BaselinePolicyAndroid) {
  57. base::ScopedFD fd(HANDLE_EINTR(open("/dev/null", O_RDWR)));
  58. BPF_ASSERT(fd.is_valid());
  59. errno = 0;
  60. BPF_ASSERT_EQ(-1, ioctl(fd.get(), ASHMEM_SET_PROT_MASK));
  61. BPF_ASSERT_EQ(ENOTTY, errno);
  62. errno = 0;
  63. BPF_ASSERT_EQ(-1, ioctl(fd.get(), BINDER_WRITE_READ));
  64. BPF_ASSERT_EQ(ENOTTY, errno);
  65. // 32- and 64-bit constant values for BINDER_WRITE_READ.
  66. errno = 0;
  67. BPF_ASSERT_EQ(-1, ioctl(fd.get(), 0xc0186201));
  68. BPF_ASSERT_EQ(ENOTTY, errno);
  69. errno = 0;
  70. BPF_ASSERT_EQ(-1, ioctl(fd.get(), 0xc0306201));
  71. BPF_ASSERT_EQ(ENOTTY, errno);
  72. errno = 0;
  73. BPF_ASSERT_EQ(-1, ioctl(fd.get(), TCGETS));
  74. BPF_ASSERT_EQ(ENOTTY, errno);
  75. }
  76. BPF_TEST_C(BaselinePolicyAndroid, Ioctl_Blocked, BaselinePolicyAndroid) {
  77. base::ScopedFD fd(HANDLE_EINTR(open("/dev/null", O_RDWR)));
  78. BPF_ASSERT(fd.is_valid());
  79. errno = 0;
  80. BPF_ASSERT_EQ(-1, ioctl(fd.get(), NBD_CLEAR_SOCK));
  81. BPF_ASSERT_EQ(EINVAL, errno);
  82. }
  83. BPF_DEATH_TEST_C(BaselinePolicyAndroid,
  84. UserfaultfdIoctl_BlockedDefault,
  85. DEATH_SEGV_MESSAGE(GetIoctlErrorMessageContentForTests()),
  86. BaselinePolicyAndroid) {
  87. base::ScopedFD fd(HANDLE_EINTR(open("/dev/null", O_RDWR)));
  88. BPF_ASSERT(fd.is_valid());
  89. ioctl(fd.get(), UFFDIO_WAKE);
  90. }
  91. class AllowUserfaultfdBaselinePolicyAndroid : public BaselinePolicyAndroid {
  92. public:
  93. AllowUserfaultfdBaselinePolicyAndroid()
  94. : BaselinePolicyAndroid(
  95. RuntimeOptions{.allow_userfaultfd_ioctls = true}) {}
  96. };
  97. BPF_TEST_C(BaselinePolicyAndroid,
  98. UserfaultfdIoctl_Allowed,
  99. AllowUserfaultfdBaselinePolicyAndroid) {
  100. base::ScopedFD fd(HANDLE_EINTR(open("/dev/null", O_RDWR)));
  101. BPF_ASSERT(fd.is_valid());
  102. errno = 0;
  103. BPF_ASSERT_EQ(-1, ioctl(fd.get(), UFFDIO_WAKE));
  104. BPF_ASSERT_EQ(ENOTTY, errno);
  105. }
  106. BPF_DEATH_TEST_C(BaselinePolicyAndroid,
  107. UserfaultfdIoctl_BlockedSubset,
  108. DEATH_SEGV_MESSAGE(GetIoctlErrorMessageContentForTests()),
  109. BaselinePolicyAndroid) {
  110. base::ScopedFD fd(HANDLE_EINTR(open("/dev/null", O_RDWR)));
  111. BPF_ASSERT(fd.is_valid());
  112. ioctl(fd.get(), UFFDIO_API);
  113. }
  114. } // namespace
  115. } // namespace sandbox