seccomp-notify 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4348459a8a4722dfdc17dcf0acf21b0e7802f6b9b5fe80e1821d9cb1964d7802
+  data.tar.gz: 3d8776d6b56396439b30b17897eb862dde5fbe8c591ce3e58d62a1c928c90e72
+SHA512:
+  metadata.gz: b3c6841b95077468dea06d50250d91f660386cf21e33240bcf270b07b7f7efabe6e890a0ee1e6ca22d6492d9cb6837b1cd25954c4eb93d195c77a4ce025221ac
+  data.tar.gz: 63d5fdf903dc3541c9ded5eb90deb66de7ea4171304b375f6228aae690462816cd5880eef05de9d27df95bb843fb84c573e89b6ffc718cee50c2e693827ff731

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to seccomp-notify are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and versions follow [Semantic Versioning](https://semver.org/).
+
+## v0.1.0 - 2026-08-22
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# seccomp-notify
+
+Pure Ruby plumbing for Linux [`SECCOMP_RET_USER_NOTIF`](https://www.kernel.org/doc/html/latest/userspace-api/seccomp_filter.html). It builds cBPF filters, transfers listener file descriptors, supervises notifications, reads target memory, and injects file descriptors without a native extension.
+
+> [!WARNING]
+> This gem is a mechanism, not a security policy or a complete sandbox. Never inspect a pointer argument and then use `continue!` as a security decision: another target thread can change that memory between inspection and syscall execution (TOCTOU). Reject the syscall or emulate it instead.
+
+Seccomp cannot intercept vDSO calls, I/O submitted through an existing `io_uring`, operations on already-open file descriptors, or indirect shared-memory effects. `io_uring_setup` is denied by default. If the supervisor dies, blocked notification syscalls return `ENOSYS`.
+
+`fcntl` and `sendmsg` must remain allowed because Ruby uses them to wrap and transfer the listener fd; policies that try to notify or deny them are rejected.
+
+## Requirements
+
+- Linux on x86_64 or aarch64
+- Ruby 3.1 or newer
+- Linux 5.0 or newer; ADDFD needs 5.9 or newer
+- `CONFIG_SECCOMP_FILTER=y`
+
+Container runtimes may block `seccomp(2)` with their own profile. For Docker development, use an isolated test container with:
+
+```sh
+docker run --rm --security-opt seccomp=unconfined -v "$PWD:/app" -w /app ruby:3.4 bundle exec rake
+```
+
+## Installation
+
+```ruby
+gem "seccomp-notify"
+```
+
+## Usage
+
+The recommended shape keeps the unfiltered supervisor in the parent and installs the filter in a child:
+
+```ruby
+require "seccomp/notify"
+
+open_syscalls = RUBY_PLATFORM.include?("x86_64") ? %i[open openat] : %i[openat]
+policy = Seccomp::Notify::Policy.new do
+  notify(*open_syscalls, :connect)
+end
+
+supervisor = Seccomp::Notify.spawn(policy) do
+  exec("bundle", "install")
+end
+
+open_handler = proc do |request|
+  path_argument = request.syscall == :open ? 0 : 1
+  path = request.read_string(request.args[path_argument])
+  if path == "/etc/shadow"
+    request.error!(Errno::EACCES)
+  else
+    request.continue!(unsafe: true)
+  end
+end
+open_syscalls.each { |syscall| supervisor.on(syscall, &open_handler) }
+
+supervisor.on(:connect) { |request| request.error!(Errno::ENETUNREACH) }
+status = supervisor.run
+```
+
+`request.pid` is an alias for `request.tid`: the kernel reports the thread ID that issued the syscall, not the process ID.
+
+`supervise_self(policy, supervisor: :fork)` accepts a block that configures the child supervisor. The safer `:spawn` form starts a clean Ruby VM and therefore supports only the default pass-through handler. Both forms detach the supervisor child, so broad `Process.wait` calls in the target can still observe related lifecycle effects.
+
+## Responses and features
+
+- `allow!(value = 0)` emulates a successful return value without executing the syscall.
+- `error!(Errno::EPERM)` returns an errno.
+- `continue!` executes the original syscall when supported.
+- `add_fd!(io)` injects a file descriptor when supported.
+- `kill!` terminates the issuing task.
+
+Use `Seccomp::Notify.features` to inspect runtime support. Set `SECCOMP_NOTIFY_DISABLE_FEATURES=addfd,continue` to force feature fallbacks in tests.
+
+Targets started by this gem can call `Seccomp::Notify.supervisor_alive?` to poll the health pipe. If the target `exec`s, the pipe fd is inherited and published as `SECCOMP_NOTIFY_HEALTH_FD`.
+
+## Development
+
+Run `bundle exec rake`. Linux runs include real seccomp integration tests; other systems run only portable filter and layout tests. `spike/notify_min.c` is the reference C round trip, and `tools/gen_syscall_table.rb` regenerates architecture tables from Linux kernel headers.
+
+Releases before 1.0 may change the API. The project is available under the MIT License.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/examples/deny_network.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "seccomp/notify"
+
+abort "usage: #{$PROGRAM_NAME} COMMAND [ARG...]" if ARGV.empty?
+
+policy = Seccomp::Notify::Policy.new { notify :connect, :sendto }
+supervisor = Seccomp::Notify.spawn(policy) { exec(*ARGV) }
+supervisor.on(:connect) { |request| request.error!(Errno::ENETUNREACH) }
+supervisor.on(:sendto) { |request| request.error!(Errno::ENETUNREACH) }
+exit(supervisor.run.exitstatus)

data/examples/emulate_open.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "seccomp/notify"
+
+abort "usage: #{$PROGRAM_NAME} REPLACEMENT COMMAND [ARG...]" if ARGV.length < 2
+replacement = File.expand_path(ARGV.shift)
+open_syscalls = RUBY_PLATFORM.include?("x86_64") ? %i[open openat] : %i[openat]
+policy = Seccomp::Notify::Policy.new { notify(*open_syscalls) }
+supervisor = Seccomp::Notify.spawn(policy) { exec(*ARGV) }
+handler = proc do |request|
+  path_argument = request.syscall == :open ? 0 : 1
+  if request.read_string(request.args[path_argument]) == "/dev/urandom"
+    File.open(replacement) { |file| request.add_fd!(file) }
+  else
+    request.continue!(unsafe: true)
+  end
+end
+open_syscalls.each { |syscall| supervisor.on(syscall, &handler) }
+exit(supervisor.run.exitstatus)

data/examples/strace_lite.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "seccomp/notify"
+
+abort "usage: #{$PROGRAM_NAME} COMMAND [ARG...]" if ARGV.empty?
+
+open_syscalls = RUBY_PLATFORM.include?("x86_64") ? %i[open openat] : %i[openat]
+policy = Seccomp::Notify::Policy.new { notify(*open_syscalls, :connect, :execve) }
+supervisor = Seccomp::Notify.spawn(policy) { exec(*ARGV) }
+supervisor.on_unknown do |request|
+  warn "#{request.tid} #{request.syscall}(#{request.args.map { |arg| "0x#{arg.to_s(16)}" }.join(", ")})"
+  request.continue!
+end
+exit(supervisor.run.exitstatus)

data/exe/seccomp-notify-supervisor

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "socket"
+require "seccomp/notify"
+
+socket = UNIXSocket.for_fd(Integer(ARGV.fetch(0)))
+target_pid = Integer(ARGV.fetch(1))
+options = Marshal.load([ARGV.fetch(2)].pack("H*")) # rubocop:disable Security/MarshalLoad
+health_writer = IO.for_fd(Integer(ARGV.fetch(3)))
+listener = Seccomp::Notify::FdPassing.recv_fd(socket)
+socket.close
+supervisor = Seccomp::Notify::Supervisor.new(listener, target_pid:, target_child: false, health_writer:, **options)
+supervisor.on_unknown { |request| request.continue! }
+supervisor.run

data/lib/seccomp/notify/bpf/builder.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Seccomp
+  module Notify
+    module BPF
+      class Builder
+        LINEAR_LIMIT = 64
+        AUDIT_ARCHES = {x86_64: Constants::AUDIT_ARCH_X86_64, aarch64: Constants::AUDIT_ARCH_AARCH64}.freeze
+
+        def initialize(policy, arch: Libc.architecture)
+          raise NotSupportedError, "unsupported architecture: #{arch}" unless AUDIT_ARCHES.key?(arch)
+
+          @policy = policy
+          @arch = arch
+        end
+
+        def build
+          decisions = @policy.decisions(@arch)
+          body = decisions.length <= LINEAR_LIMIT ? linear(decisions) : tree(decisions.sort)
+          Program.new(prologue + body)
+        end
+
+        private
+
+        def prologue
+          [
+            ins(Constants::BPF_LD_W_ABS, 0, 0, Constants::OFF_ARCH),
+            ins(Constants::BPF_JMP_JEQ_K, 1, 0, AUDIT_ARCHES.fetch(@arch)),
+            ins(Constants::BPF_RET_K, 0, 0, Constants::SECCOMP_RET_KILL_PROCESS),
+            ins(Constants::BPF_LD_W_ABS, 0, 0, Constants::OFF_NR)
+          ]
+        end
+
+        def linear(decisions)
+          decisions.flat_map do |number, action|
+            [ins(Constants::BPF_JMP_JEQ_K, 0, 1, number), ins(Constants::BPF_RET_K, 0, 0, action)]
+          end << ins(Constants::BPF_RET_K, 0, 0, @policy.default_action)
+        end
+
+        def tree(decisions)
+          return [ins(Constants::BPF_RET_K, 0, 0, @policy.default_action)] if decisions.empty?
+          return linear(decisions) if decisions.length <= 4
+
+          middle = decisions.length / 2
+          left = tree(decisions[...middle])
+          right = tree(decisions[middle..])
+          pivot = decisions[middle][0]
+          [
+            ins(Constants::BPF_JMP_JGE_K, 0, 1, pivot),
+            ins(Constants::BPF_JMP_JA, 0, 0, 1),
+            ins(Constants::BPF_JMP_JA, 0, 0, right.length)
+          ] + right + left
+        end
+
+        def ins(code, jt, jf, k)
+          Instruction.new(code:, jt:, jf:, k:)
+        end
+      end
+    end
+  end
+end

data/lib/seccomp/notify/bpf/instruction.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Seccomp
+  module Notify
+    module BPF
+      Instruction = Struct.new(:code, :jt, :jf, :k, keyword_init: true) do
+        def to_binary
+          [code, jt, jf, k].pack(Structs::INSTRUCTION_FORMAT)
+        end
+      end
+    end
+  end
+end

data/lib/seccomp/notify/bpf/program.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "fiddle"
+
+module Seccomp
+  module Notify
+    module BPF
+      class Program
+        attr_reader :instructions
+
+        def initialize(instructions)
+          @instructions = instructions.freeze
+          raise FilterTooLargeError, "BPF program exceeds #{Constants::BPF_MAXINSNS} instructions" if instructions.length > Constants::BPF_MAXINSNS
+
+          @binary = instructions.map(&:to_binary).join
+          @pointer = Fiddle::Pointer[@binary]
+          @sock_fprog = [instructions.length, @pointer.to_i].pack(Structs::PROGRAM_FORMAT)
+        end
+
+        def to_binary
+          @binary
+        end
+
+        def to_sock_fprog
+          @sock_fprog
+        end
+      end
+    end
+  end
+end

data/lib/seccomp/notify/constants.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Seccomp
+  module Notify
+    module Constants
+      SECCOMP_SET_MODE_STRICT = 0
+      SECCOMP_SET_MODE_FILTER = 1
+      SECCOMP_GET_ACTION_AVAIL = 2
+      SECCOMP_GET_NOTIF_SIZES = 3
+
+      SECCOMP_FILTER_FLAG_TSYNC = 1 << 0
+      SECCOMP_FILTER_FLAG_LOG = 1 << 1
+      SECCOMP_FILTER_FLAG_SPEC_ALLOW = 1 << 2
+      SECCOMP_FILTER_FLAG_NEW_LISTENER = 1 << 3
+      SECCOMP_FILTER_FLAG_TSYNC_ESRCH = 1 << 4
+      SECCOMP_FILTER_FLAG_WAIT_KILLABLE_RECV = 1 << 5
+
+      SECCOMP_RET_KILL_PROCESS = 0x8000_0000
+      SECCOMP_RET_KILL_THREAD = 0x0000_0000
+      SECCOMP_RET_TRAP = 0x0003_0000
+      SECCOMP_RET_ERRNO = 0x0005_0000
+      SECCOMP_RET_USER_NOTIF = 0x7fc0_0000
+      SECCOMP_RET_TRACE = 0x7ff0_0000
+      SECCOMP_RET_LOG = 0x7ffc_0000
+      SECCOMP_RET_ALLOW = 0x7fff_0000
+
+      SECCOMP_USER_NOTIF_FLAG_CONTINUE = 1 << 0
+      SECCOMP_ADDFD_FLAG_SETFD = 1 << 0
+      SECCOMP_ADDFD_FLAG_SEND = 1 << 1
+      O_CLOEXEC = 0x80000
+
+      AUDIT_ARCH_X86_64 = 0xc000_003e
+      AUDIT_ARCH_AARCH64 = 0xc000_00b7
+      AUDIT_ARCH_I386 = 0x4000_0003
+      SYS_SECCOMP = {x86_64: 317, aarch64: 277}.freeze
+
+      PR_SET_NO_NEW_PRIVS = 38
+      BPF_LD_W_ABS = 0x20
+      BPF_JMP_JA = 0x05
+      BPF_JMP_JEQ_K = 0x15
+      BPF_JMP_JGE_K = 0x35
+      BPF_RET_K = 0x06
+      BPF_MAXINSNS = 4096
+      MAX_ERRNO = 4095
+      OFF_NR = 0
+      OFF_ARCH = 4
+      OFF_IP = 8
+      OFF_ARGS = 16
+
+      module_function
+
+      def errno_number(value)
+        number = value.is_a?(Module) ? value.const_get(:Errno, false) : value
+        return number if number.is_a?(Integer) && (1..MAX_ERRNO).cover?(number)
+
+        raise ArgumentError, "errno must be between 1 and #{MAX_ERRNO}"
+      rescue NameError
+        raise ArgumentError, "errno must be between 1 and #{MAX_ERRNO}"
+      end
+    end
+  end
+end

data/lib/seccomp/notify/errors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Seccomp
+  module Notify
+    class Error < StandardError; end
+    class NotSupportedError < Error; end
+    class InvalidPolicyError < Error; end
+    class FilterTooLargeError < Error; end
+    class AlreadyRespondedError < Error; end
+    class StaleNotificationError < Error; end
+    class MemoryReadError < Error; end
+  end
+end

data/lib/seccomp/notify/fd_passing.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "socket"
+require "timeout"
+
+module Seccomp
+  module Notify
+    module FdPassing
+      module_function
+
+      def send_fd(socket, io)
+        socket.sendmsg("\0", 0, nil, Socket::AncillaryData.unix_rights(io))
+      end
+
+      def recv_fd(socket, timeout: 10)
+        raise Timeout::Error, "timed out waiting for listener fd" unless IO.select([socket], nil, nil, timeout)
+
+        _message, _address, _flags, control = socket.recvmsg(1, 0, 64, scm_rights: true)
+        raise EOFError, "message did not contain a file descriptor" unless control
+
+        io = control.unix_rights.first
+        raise EOFError, "message did not contain a file descriptor" unless io
+
+        io
+      end
+    end
+  end
+end

data/lib/seccomp/notify/features.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module Seccomp
+  module Notify
+    module Features
+      module_function
+
+      def detect
+        disabled = ENV.fetch("SECCOMP_NOTIFY_DISABLE_FEATURES", "").split(",").map(&:strip)
+        result = {user_notif: supported?, continue: false, addfd: false, addfd_send: false, wait_killable_recv: false}
+        return result.freeze unless result[:user_notif]
+
+        result[:continue] = probe_response(Constants::SECCOMP_USER_NOTIF_FLAG_CONTINUE)
+        result[:addfd] = probe_addfd(0)
+        result[:addfd_send] = probe_addfd(Constants::SECCOMP_ADDFD_FLAG_SEND)
+        result[:wait_killable_recv] = probe_install(Constants::SECCOMP_FILTER_FLAG_WAIT_KILLABLE_RECV)
+        disabled.each { |name| result[name.to_sym] = false if result.key?(name.to_sym) }
+        result[:addfd_send] = false unless result[:addfd]
+        result.freeze
+      end
+
+      def supported?
+        Libc.notif_sizes
+        true
+      rescue SystemCallError, NotSupportedError
+        false
+      end
+
+      def probe_response(flags)
+        probe do |listener, request|
+          response = [request.unpack1("Q<"), 0, 0, flags].pack(Structs::RESPONSE_FORMAT)
+          Ioctl.call(listener, Ioctl::NOTIF_SEND, response)
+        end
+      end
+
+      def probe_addfd(flags)
+        File.open("/dev/null") do |source|
+          probe do |listener, request|
+            id = request.unpack1("Q<")
+            injected = Ioctl.call(listener, Ioctl::NOTIF_ADDFD, [id, flags, source.fileno, 0, 0].pack(Structs::ADDFD_FORMAT))
+            Ioctl.call(listener, Ioctl::NOTIF_SEND, [id, injected, 0, 0].pack(Structs::RESPONSE_FORMAT)) if flags.zero?
+          end
+        end
+      end
+
+      def probe_install(flags)
+        parent, child = UNIXSocket.pair
+        pid = fork do
+          parent.close
+          listener = Filter.install!(BPF::Builder.new(Policy.new { notify :getpid }).build, flags:)
+          FdPassing.send_fd(child, listener)
+          exit! 0
+        rescue SystemCallError
+          exit! 1
+        end
+        child.close
+        listener = FdPassing.recv_fd(parent, timeout: 2)
+        listener.close
+        status = wait_for_probe(pid)
+        status.success?
+      rescue EOFError, Timeout::Error
+        terminate_probe(pid)
+        false
+      ensure
+        parent&.close unless parent&.closed?
+      end
+
+      def probe
+        parent, child = UNIXSocket.pair
+        pid = fork do
+          parent.close
+          listener = Filter.install!(BPF::Builder.new(Policy.new { notify :getpid }).build)
+          FdPassing.send_fd(child, listener)
+          Libc::SYSCALL.call(Syscalls.number(:getpid), 0, 0, 0)
+          exit! 0
+        rescue StandardError
+          exit! 1
+        end
+        child.close
+        listener = FdPassing.recv_fd(parent, timeout: 2)
+        request = "\0" * Structs::NOTIF_SIZE
+        Ioctl.call(listener, Ioctl::NOTIF_RECV, request)
+        yield listener, request
+        status = wait_for_probe(pid)
+        status.success?
+      rescue SystemCallError, EOFError, Timeout::Error
+        terminate_probe(pid)
+        false
+      ensure
+        listener&.close unless listener&.closed?
+        parent&.close unless parent&.closed?
+      end
+
+      def wait_for_probe(pid)
+        Timeout.timeout(2) { Process.waitpid2(pid).last }
+      end
+
+      def terminate_probe(pid)
+        Process.kill("KILL", pid) rescue nil
+        Process.waitpid(pid) rescue nil
+      end
+    end
+  end
+end

data/lib/seccomp/notify/filter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Seccomp
+  module Notify
+    module Filter
+      module_function
+
+      def install!(program, flags: 0)
+        unless Libc.prctl(Constants::PR_SET_NO_NEW_PRIVS, 1).zero?
+          raise SystemCallError.new("prctl(PR_SET_NO_NEW_PRIVS)", Fiddle.last_error)
+        end
+
+        filter_flags = flags | Constants::SECCOMP_FILTER_FLAG_NEW_LISTENER
+        fd = Libc.seccomp(Constants::SECCOMP_SET_MODE_FILTER, filter_flags, program.to_sock_fprog)
+        raise SystemCallError.new("seccomp(SET_MODE_FILTER)", Fiddle.last_error) if fd.negative?
+
+        IO.for_fd(fd, "r")
+      end
+    end
+  end
+end

data/lib/seccomp/notify/ioctl.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "fiddle"
+
+module Seccomp
+  module Notify
+    module Ioctl
+      NONE = 0
+      WRITE = 1
+      READ = 2
+      MAGIC = "!".ord
+
+      module_function
+
+      def ioc(dir, type, nr, size)
+        (dir << 30) | (size << 16) | (type << 8) | nr
+      end
+
+      NOTIF_RECV = ioc(READ | WRITE, MAGIC, 0, 80)
+      NOTIF_SEND = ioc(READ | WRITE, MAGIC, 1, 24)
+      NOTIF_ID_VALID = ioc(WRITE, MAGIC, 2, 8)
+      NOTIF_ID_VALID_OLD = ioc(READ, MAGIC, 2, 8)
+      NOTIF_ADDFD = ioc(WRITE, MAGIC, 3, 24)
+      NOTIF_SET_FLAGS = ioc(WRITE, MAGIC, 4, 8)
+
+      def call(io, request, buffer)
+        result = Libc.ioctl(io.fileno, request, buffer)
+        return result unless result.negative?
+
+        raise SystemCallError.new("ioctl(0x#{request.to_s(16)})", Fiddle.last_error)
+      end
+    end
+  end
+end

data/lib/seccomp/notify/libc.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "fiddle"
+
+module Seccomp
+  module Notify
+    module Libc
+      HANDLE = Fiddle.dlopen(nil)
+      SYSCALL = Fiddle::Function.new(
+        HANDLE["syscall"],
+        [Fiddle::TYPE_LONG] * 4,
+        Fiddle::TYPE_LONG,
+        need_gvl: true
+      )
+      PRCTL = Fiddle::Function.new(
+        HANDLE["prctl"],
+        [Fiddle::TYPE_INT] * 5,
+        Fiddle::TYPE_INT
+      )
+      IOCTL = Fiddle::Function.new(
+        HANDLE["ioctl"],
+        [Fiddle::TYPE_INT, Fiddle::TYPE_LONG, Fiddle::TYPE_VOIDP],
+        Fiddle::TYPE_INT,
+        need_gvl: true
+      )
+      POLL = Fiddle::Function.new(
+        HANDLE["poll"],
+        [Fiddle::TYPE_VOIDP, Fiddle::TYPE_LONG, Fiddle::TYPE_INT],
+        Fiddle::TYPE_INT
+      )
+
+      module_function
+
+      def architecture
+        @architecture ||= case RUBY_PLATFORM
+        when /x86_64/
+          :x86_64
+        when /aarch64|arm64/
+          :aarch64
+        else
+          raise NotSupportedError, "unsupported architecture: #{RUBY_PLATFORM}"
+        end
+      end
+
+      def prctl(option, arg2 = 0, arg3 = 0, arg4 = 0, arg5 = 0)
+        PRCTL.call(option, arg2, arg3, arg4, arg5)
+      end
+
+      def seccomp(operation, flags, buffer = 0)
+        pointer = buffer.is_a?(String) ? Fiddle::Pointer[buffer] : buffer
+        SYSCALL.call(Constants::SYS_SECCOMP.fetch(architecture), operation, flags, pointer.to_i)
+      end
+
+      def ioctl(fd, request, buffer)
+        IOCTL.call(fd, request, Fiddle::Pointer[buffer])
+      end
+
+      def poll_hup?(fd)
+        buffer = [fd, 1, 0].pack("l<s<s<")
+        result = POLL.call(Fiddle::Pointer[buffer], 1, 0)
+        raise SystemCallError.new("poll", Fiddle.last_error) if result.negative?
+
+        (buffer.unpack1("@6S<") & 0x10).positive?
+      end
+
+      def notif_sizes
+        buffer = "\0" * 6
+        result = seccomp(Constants::SECCOMP_GET_NOTIF_SIZES, 0, buffer)
+        raise SystemCallError.new("seccomp(GET_NOTIF_SIZES)", Fiddle.last_error) if result.negative?
+
+        notif, resp, data = buffer.unpack("S<S<S<")
+        {notif: notif, resp: resp, data: data}.freeze
+      end
+    end
+  end
+end