components/nacl/loader/nonsfi/nonsfi_sandbox_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 // Sanitizers internally use some syscalls which non-SFI NaCl disallows.
   6 #if !defined(ADDRESS_SANITIZER) && !defined(THREAD_SANITIZER) && \
   7     !defined(MEMORY_SANITIZER) && !defined(LEAK_SANITIZER)
   8
   9 #include "components/nacl/loader/nonsfi/nonsfi_sandbox.h"
  10
  11 #include <errno.h>
  12 #include <fcntl.h>
  13 #include <linux/futex.h>
  14 #include <pthread.h>
  15 #include <sched.h>
  16 #include <signal.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <sys/mman.h>
  20 #include <sys/prctl.h>
  21 #include <sys/ptrace.h>
  22 #include <sys/socket.h>
  23 #include <sys/syscall.h>
  24 #include <sys/types.h>
  25 #include <sys/wait.h>
  26 #include <time.h>
  27 #include <unistd.h>
  28
  29 #include "base/bind.h"
  30 #include "base/callback.h"
  31 #include "base/compiler_specific.h"
  32 #include "base/files/scoped_file.h"
  33 #include "base/logging.h"
  34 #include "base/posix/eintr_wrapper.h"
  35 #include "base/sys_info.h"
  36 #include "base/threading/thread.h"
  37 #include "base/time/time.h"
  38 #include "sandbox/linux/seccomp-bpf-helpers/sigsys_handlers.h"
  39 #include "sandbox/linux/seccomp-bpf/bpf_tests.h"
  40 #include "sandbox/linux/seccomp-bpf/sandbox_bpf.h"
  41 #include "sandbox/linux/seccomp-bpf/syscall.h"
  42 #include "sandbox/linux/system_headers/linux_syscalls.h"
  43 #include "third_party/lss/linux_syscall_support.h"  // for MAKE_PROCESS_CPUCLOCK
  44
  45 namespace {
  46
  47 void DoPipe(base::ScopedFD* fds) {
  48   int tmp_fds[2];
  49   BPF_ASSERT_EQ(0, pipe(tmp_fds));
  50   fds[0].reset(tmp_fds[0]);
  51   fds[1].reset(tmp_fds[1]);
  52 }
  53
  54 void DoSocketpair(base::ScopedFD* fds) {
  55   int tmp_fds[2];
  56   BPF_ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, tmp_fds));
  57   fds[0].reset(tmp_fds[0]);
  58   fds[1].reset(tmp_fds[1]);
  59 }
  60
  61 TEST(NaClNonSfiSandboxTest, BPFIsSupported) {
  62   bool seccomp_bpf_supported = sandbox::SandboxBPF::SupportsSeccompSandbox(
  63       sandbox::SandboxBPF::SeccompLevel::SINGLE_THREADED);
  64
  65   if (!seccomp_bpf_supported) {
  66     LOG(ERROR) << "Seccomp BPF is not supported, these tests "
  67                << "will pass without running";
  68   }
  69 }
  70
  71 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
  72                  invalid_sysno,
  73                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
  74                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
  75   syscall(999);
  76 }
  77
  78 const int kExpectedValue = 123;
  79
  80 void* SetValueInThread(void* test_val_ptr) {
  81   *reinterpret_cast<int*>(test_val_ptr) = kExpectedValue;
  82   return NULL;
  83 }
  84
  85 // To make this test pass, we need to allow sched_getaffinity and
  86 // mmap. We just disable this test not to complicate the sandbox.
  87 BPF_TEST_C(NaClNonSfiSandboxTest,
  88            clone_by_pthread_create,
  89            nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
  90   // clone call for thread creation is allowed.
  91   pthread_t th;
  92   int test_val = 42;
  93   BPF_ASSERT_EQ(0, pthread_create(&th, NULL, &SetValueInThread, &test_val));
  94   BPF_ASSERT_EQ(0, pthread_join(th, NULL));
  95   BPF_ASSERT_EQ(kExpectedValue, test_val);
  96 }
  97
  98 int DoFork() {
  99   // Call clone() to do a fork().
 100   const int pid = syscall(__NR_clone, SIGCHLD, NULL);
 101   if (pid == 0)
 102     _exit(0);
 103   return pid;
 104 }
 105
 106 // The sanity check for DoFork without the sandbox.
 107 TEST(NaClNonSfiSandboxTest, DoFork) {
 108   const int pid = DoFork();
 109   ASSERT_LT(0, pid);
 110   int status;
 111   ASSERT_EQ(pid, HANDLE_EINTR(waitpid(pid, &status, 0)));
 112   ASSERT_TRUE(WIFEXITED(status));
 113   ASSERT_EQ(0, WEXITSTATUS(status));
 114 }
 115
 116 // Then, try this in the sandbox.
 117 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 118                  clone_for_fork,
 119                  DEATH_MESSAGE(sandbox::GetCloneErrorMessageContentForTests()),
 120                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 121   DoFork();
 122 }
 123
 124 BPF_TEST_C(NaClNonSfiSandboxTest,
 125            prctl_SET_NAME,
 126            nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 127   errno = 0;
 128   BPF_ASSERT_EQ(-1, syscall(__NR_prctl, PR_SET_NAME, "foo"));
 129   BPF_ASSERT_EQ(EPERM, errno);
 130 }
 131
 132 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 133                  prctl_SET_DUMPABLE,
 134                  DEATH_MESSAGE(sandbox::GetPrctlErrorMessageContentForTests()),
 135                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 136   syscall(__NR_prctl, PR_SET_DUMPABLE, 1UL);
 137 }
 138
 139 BPF_TEST_C(NaClNonSfiSandboxTest,
 140            socketcall_allowed,
 141            nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 142   base::ScopedFD fds[2];
 143   struct msghdr msg = {};
 144   struct iovec iov;
 145   std::string payload("foo");
 146   iov.iov_base = &payload[0];
 147   iov.iov_len = payload.size();
 148   msg.msg_iov = &iov;
 149   msg.msg_iovlen = 1;
 150   DoSocketpair(fds);
 151   BPF_ASSERT_EQ(static_cast<int>(payload.size()),
 152                 HANDLE_EINTR(sendmsg(fds[1].get(), &msg, 0)));
 153   BPF_ASSERT_EQ(static_cast<int>(payload.size()),
 154                 HANDLE_EINTR(recvmsg(fds[0].get(), &msg, 0)));
 155   BPF_ASSERT_EQ(0, shutdown(fds[0].get(), SHUT_RDWR));
 156 }
 157
 158 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 159                  accept,
 160                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 161                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 162   accept(0, NULL, NULL);
 163 }
 164
 165 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 166                  bind,
 167                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 168                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 169   bind(0, NULL, 0);
 170 }
 171
 172 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 173                  connect,
 174                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 175                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 176   connect(0, NULL, 0);
 177 }
 178
 179 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 180                  getpeername,
 181                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 182                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 183   getpeername(0, NULL, NULL);
 184 }
 185
 186 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 187                  getsockname,
 188                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 189                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 190   struct sockaddr addr;
 191   socklen_t addrlen = 0;
 192   getsockname(0, &addr, &addrlen);
 193 }
 194
 195 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 196                  getsockopt,
 197                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 198                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 199   getsockopt(0, 0, 0, NULL, NULL);
 200 }
 201
 202 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 203                  listen,
 204                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 205                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 206   listen(0, 0);
 207 }
 208
 209 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 210                  recv,
 211                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 212                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 213   recv(0, NULL, 0, 0);
 214 }
 215
 216 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 217                  recvfrom,
 218                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 219                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 220   recvfrom(0, NULL, 0, 0, NULL, NULL);
 221 }
 222
 223 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 224                  send,
 225                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 226                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 227   send(0, NULL, 0, 0);
 228 }
 229
 230 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 231                  sendto,
 232                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 233                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 234   sendto(0, NULL, 0, 0, NULL, 0);
 235 }
 236
 237 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 238                  setsockopt,
 239                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 240                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 241   setsockopt(0, 0, 0, NULL, 0);
 242 }
 243
 244 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 245                  socket,
 246                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 247                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 248   socket(0, 0, 0);
 249 }
 250
 251 #if defined(__x86_64__) || defined(__arm__)
 252 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 253                  socketpair,
 254                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 255                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 256   int fds[2];
 257   socketpair(AF_INET, SOCK_STREAM, 0, fds);
 258 }
 259 #endif
 260
 261 BPF_TEST_C(NaClNonSfiSandboxTest,
 262            fcntl_SETFD_allowed,
 263            nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 264   base::ScopedFD fds[2];
 265   DoSocketpair(fds);
 266   BPF_ASSERT_EQ(0, fcntl(fds[0].get(), F_SETFD, FD_CLOEXEC));
 267 }
 268
 269 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 270                  fcntl_SETFD,
 271                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 272                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 273   base::ScopedFD fds[2];
 274   DoSocketpair(fds);
 275   fcntl(fds[0].get(), F_SETFD, 99);
 276 }
 277
 278 BPF_TEST_C(NaClNonSfiSandboxTest,
 279            fcntl_GETFL_SETFL_allowed,
 280            nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 281   base::ScopedFD fds[2];
 282   DoPipe(fds);
 283   const int fd = fds[0].get();
 284   BPF_ASSERT_EQ(0, fcntl(fd, F_GETFL));
 285   BPF_ASSERT_EQ(0, fcntl(fd, F_SETFL, O_RDWR | O_NONBLOCK));
 286   BPF_ASSERT_EQ(O_NONBLOCK, fcntl(fd, F_GETFL));
 287 }
 288
 289 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 290                  fcntl_GETFL_SETFL,
 291                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 292                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 293   base::ScopedFD fds[2];
 294   DoSocketpair(fds);
 295   fcntl(fds[0].get(), F_SETFL, O_APPEND);
 296 }
 297
 298 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 299                  fcntl_DUPFD,
 300                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 301                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 302   fcntl(0, F_DUPFD);
 303 }
 304
 305 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 306                  fcntl_DUPFD_CLOEXEC,
 307                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 308                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 309   fcntl(0, F_DUPFD_CLOEXEC);
 310 }
 311
 312 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 313                  FutexWithRequeuePriorityInheritence,
 314                  DEATH_MESSAGE(sandbox::GetFutexErrorMessageContentForTests()),
 315                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 316   syscall(__NR_futex, NULL, FUTEX_CMP_REQUEUE_PI, 0, NULL, NULL, 0);
 317   _exit(1);
 318 }
 319
 320 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 321                  FutexWithRequeuePriorityInheritencePrivate,
 322                  DEATH_MESSAGE(sandbox::GetFutexErrorMessageContentForTests()),
 323                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 324   syscall(__NR_futex, NULL, FUTEX_CMP_REQUEUE_PI_PRIVATE, 0, NULL, NULL, 0);
 325   _exit(1);
 326 }
 327
 328 BPF_TEST_C(NaClNonSfiSandboxTest,
 329            StartingAndJoiningThreadWorks,
 330            nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 331   base::Thread thread("sandbox_tests");
 332   BPF_ASSERT(thread.Start());
 333   // |thread|'s destructor will join the thread.
 334 }
 335
 336 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 337                  FutexWithUnlockPIPrivate,
 338                  DEATH_MESSAGE(sandbox::GetFutexErrorMessageContentForTests()),
 339                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 340   syscall(__NR_futex, NULL, FUTEX_UNLOCK_PI_PRIVATE, 0, NULL, NULL, 0);
 341   _exit(1);
 342 }
 343
 344 void* DoAllowedAnonymousMmap() {
 345   return mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE,
 346               MAP_ANONYMOUS | MAP_SHARED, -1, 0);
 347 }
 348
 349 BPF_TEST_C(NaClNonSfiSandboxTest,
 350            mmap_allowed,
 351            nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 352   void* ptr = DoAllowedAnonymousMmap();
 353   BPF_ASSERT_NE(MAP_FAILED, ptr);
 354   BPF_ASSERT_EQ(0, munmap(ptr, getpagesize()));
 355 }
 356
 357 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 358                  mmap_unallowed_flag,
 359                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 360                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 361   mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE,
 362        MAP_ANONYMOUS | MAP_POPULATE, -1, 0);
 363 }
 364
 365 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 366                  mmap_unallowed_prot,
 367                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 368                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 369   mmap(NULL, getpagesize(), PROT_READ | PROT_GROWSDOWN,
 370        MAP_ANONYMOUS, -1, 0);
 371 }
 372
 373 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 374                  mmap_exec,
 375                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 376                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 377   mmap(NULL, getpagesize(), PROT_EXEC, MAP_ANONYMOUS, -1, 0);
 378 }
 379
 380 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 381                  mmap_read_exec,
 382                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 383                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 384   mmap(NULL, getpagesize(), PROT_READ | PROT_EXEC, MAP_ANONYMOUS, -1, 0);
 385 }
 386
 387 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 388                  mmap_write_exec,
 389                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 390                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 391   mmap(NULL, getpagesize(), PROT_WRITE | PROT_EXEC, MAP_ANONYMOUS, -1, 0);
 392 }
 393
 394 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 395                  mmap_read_write_exec,
 396                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 397                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 398   mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE | PROT_EXEC,
 399        MAP_ANONYMOUS, -1, 0);
 400 }
 401
 402 BPF_TEST_C(NaClNonSfiSandboxTest,
 403            mprotect_allowed,
 404            nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 405   void* ptr = DoAllowedAnonymousMmap();
 406   BPF_ASSERT_NE(MAP_FAILED, ptr);
 407   BPF_ASSERT_EQ(0, mprotect(ptr, getpagesize(), PROT_READ));
 408   BPF_ASSERT_EQ(0, munmap(ptr, getpagesize()));
 409 }
 410
 411 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 412                  mprotect_unallowed_prot,
 413                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 414                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 415   // We have tested DoAllowedAnonymousMmap is allowed in
 416   // mmap_allowed, so we can make sure the following mprotect call
 417   // kills the process.
 418   void* ptr = DoAllowedAnonymousMmap();
 419   BPF_ASSERT_NE(MAP_FAILED, ptr);
 420   mprotect(ptr, getpagesize(), PROT_READ | PROT_GROWSDOWN);
 421 }
 422
 423 BPF_TEST_C(NaClNonSfiSandboxTest,
 424            brk,
 425            nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 426   char* next_brk = static_cast<char*>(sbrk(0)) + getpagesize();
 427   // The kernel interface must return zero for brk.
 428   BPF_ASSERT_EQ(0, syscall(__NR_brk, next_brk));
 429   // The libc wrapper translates it to ENOMEM.
 430   errno = 0;
 431   BPF_ASSERT_EQ(-1, brk(next_brk));
 432   BPF_ASSERT_EQ(ENOMEM, errno);
 433 }
 434
 435 // clockid restrictions are mostly tested in sandbox/ with the
 436 // RestrictClockID() unittests. Some basic tests are duplicated here as
 437 // a precaution.
 438
 439 void CheckClock(clockid_t clockid) {
 440   struct timespec ts;
 441   ts.tv_sec = ts.tv_nsec = -1;
 442   BPF_ASSERT_EQ(0, clock_gettime(clockid, &ts));
 443   BPF_ASSERT_LE(0, ts.tv_sec);
 444   BPF_ASSERT_LE(0, ts.tv_nsec);
 445 }
 446
 447 BPF_TEST_C(NaClNonSfiSandboxTest,
 448            clock_gettime_allowed,
 449            nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 450   CheckClock(CLOCK_MONOTONIC);
 451   CheckClock(CLOCK_PROCESS_CPUTIME_ID);
 452   CheckClock(CLOCK_REALTIME);
 453   CheckClock(CLOCK_THREAD_CPUTIME_ID);
 454 }
 455
 456 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 457                  clock_gettime_crash_monotonic_raw,
 458                  DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 459                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 460   struct timespec ts;
 461   clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
 462 }
 463
 464 BPF_DEATH_TEST_C(NaClNonSfiSandboxTest,
 465                  invalid_syscall_crash,
 466                  DEATH_SEGV_MESSAGE(sandbox::GetErrorMessageContentForTests()),
 467                  nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {
 468   sandbox::Syscall::InvalidCall();
 469 }
 470
 471 // The following test cases check if syscalls return EPERM regardless
 472 // of arguments.
 473 #define RESTRICT_SYSCALL_EPERM_TEST(name)                      \
 474   BPF_TEST_C(NaClNonSfiSandboxTest,                            \
 475              name##_EPERM,                                     \
 476              nacl::nonsfi::NaClNonSfiBPFSandboxPolicy) {       \
 477     errno = 0;                                                 \
 478     BPF_ASSERT_EQ(-1, syscall(__NR_##name, 0, 0, 0, 0, 0, 0)); \
 479     BPF_ASSERT_EQ(EPERM, errno);                               \
 480   }
 481
 482 RESTRICT_SYSCALL_EPERM_TEST(epoll_create);
 483 #if defined(__i386__) || defined(__arm__)
 484 RESTRICT_SYSCALL_EPERM_TEST(getegid32);
 485 RESTRICT_SYSCALL_EPERM_TEST(geteuid32);
 486 RESTRICT_SYSCALL_EPERM_TEST(getgid32);
 487 RESTRICT_SYSCALL_EPERM_TEST(getuid32);
 488 #endif
 489 RESTRICT_SYSCALL_EPERM_TEST(getegid);
 490 RESTRICT_SYSCALL_EPERM_TEST(geteuid);
 491 RESTRICT_SYSCALL_EPERM_TEST(getgid);
 492 RESTRICT_SYSCALL_EPERM_TEST(getuid);
 493 RESTRICT_SYSCALL_EPERM_TEST(madvise);
 494 RESTRICT_SYSCALL_EPERM_TEST(open);
 495 RESTRICT_SYSCALL_EPERM_TEST(openat);
 496 RESTRICT_SYSCALL_EPERM_TEST(ptrace);
 497 RESTRICT_SYSCALL_EPERM_TEST(set_robust_list);
 498 #if defined(__i386__) || defined(__x86_64__)
 499 RESTRICT_SYSCALL_EPERM_TEST(time);
 500 #endif
 501
 502 }  // namespace
 503
 504 #endif  // !ADDRESS_SANITIZER && !THREAD_SANITIZER &&
 505         // !MEMORY_SANITIZER && !LEAK_SANITIZER