landlock 0.5 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bfc5c69234e004834818ba52aab192c9219ff0a398d40ada62c4f45be461cdb
-  data.tar.gz: 6ec4b746a959a8f68c5ba11e1c4b7342d0a4facda031a8627f05ae6fedc6c6cf
+  metadata.gz: 212a2155cecade152248158abbbfea18f6592f187f1338a2faf442c5b727a5b4
+  data.tar.gz: 110062bf45e0f020d44112964f2b140c8eac867f8c502171a66c5257c19c2ba6
 SHA512:
-  metadata.gz: efd09558eb3b207ca4be70d4a6509b39338f9cc6374f6422a0fbeee87f2fb8fbb99dd4095044a27f94355062da6016672719a64ab3af78d8d89f622b3b0bb64b
-  data.tar.gz: f7e6d2ebf580fd200fa05217d3266f4a48e93d226757e4a3d9c409d22a844c3f6245fb81956201a4b03c3b8ced3ddd29c169653367efa007a8cd1c71bc833048
+  metadata.gz: 711002205ed3686d42d411d86cda9b18c6f435d467a1732ac5cd97fdb7404549b01a2617232bf7ac480b10f10a07e212331ac57c73f74128ddc5c8bbb17961b2
+  data.tar.gz: 42cf382fe1cd2b29b3f23a5425522eb7a198dd19de3d59fc4ce2be33fb07483ba9ae53b199af6f8f126d960756850552f329b8e3f6dead5e0b08764e5a3d488b

data/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 ## Unreleased
 
+## [0.5.1] - 2026-09-09
+
+### Fixed
+
+- Allow `Landlock.fork(on_unsupported: :run_without_landlock)` to fall back when the support check is blocked or unavailable, including on macOS.
+
 ## [0.5] - 2026-09-01
 
 ### Added

data/README.md

@@ -154,7 +154,7 @@ color = result.stdout if result.success?
 
 The block receives its child-side stdout and stderr streams. Write response data to stdout and diagnostics to stderr, then inspect them through the capture result in the parent. The block's return value is discarded. An exception makes the child exit with status 1 and writes a diagnostic to stderr. `fork` accepts the capture options listed above except `success_status_codes:` and `failure_message:`, which only apply to `capture!`.
 
-By default, `Landlock.fork` requires Linux Landlock support and raises `Landlock::UnsupportedError` before forking when the Landlock ABI is unavailable. A Linux caller that explicitly accepts running without Landlock filesystem, TCP, and scope enforcement can opt in to the fallback:
+By default, `Landlock.fork` requires Linux Landlock support and raises `Landlock::UnsupportedError` before forking when the Landlock ABI is unavailable. A caller that explicitly accepts running without Landlock filesystem, TCP, and scope enforcement can opt in to the fallback:
 
 ```ruby
 result = Landlock.fork(
@@ -165,7 +165,9 @@ result = Landlock.fork(
 ) { |stdout, _stderr| stdout.write(run_plugin) }
 ```
 
-This fallback is used only when the Linux kernel has no Landlock ABI. It skips only Landlock policy enforcement; fork supervision, timeout handling, environment changes, descriptor closing, rlimits, output capture, and seccomp remain active. It is never selected implicitly, and non-Linux systems still raise `Landlock::UnsupportedError`. When fallback is active, the call must include `seccomp_deny_network: true` or at least one `rlimits:` entry because Landlock rules are not effective restrictions in that mode. Timeout, environment handling, descriptor closing, and output limits do not satisfy this requirement. `Landlock.fork` requires an actual restriction. By default, the child closes inherited Ruby `IO` objects other than stdin, stdout, and stderr, then closes every other application descriptor numbered 3 or higher while preserving Ruby VM-reserved descriptors. It enumerates `/proc/self/fd` for this sweep and fails closed with setup status 127 if enumeration is unavailable or fails. Pass `close_others: false` only when the child intentionally needs an inherited descriptor. Child setup failures exit 127.
+This fallback is used when the Landlock ABI is unavailable, including when the capability probe fails or the platform does not support Landlock. Errors applying a policy after Landlock is detected still fail closed. Timeout handling, environment changes, descriptor closing, rlimits, and output capture remain active. Linux also retains parent-death cleanup and any requested seccomp restrictions. Non-Linux systems cannot provide parent-death cleanup and reject `seccomp_deny_network: true`; callers must omit that option and supply at least one `rlimits:` entry.
+
+Fallback is never selected implicitly. When active, the call must include `seccomp_deny_network: true` or at least one `rlimits:` entry because Landlock rules are not effective restrictions in that mode. Timeout, environment handling, descriptor closing, and output limits do not satisfy this requirement. By default, the child closes inherited Ruby `IO` objects other than stdin, stdout, and stderr, then closes every other application descriptor numbered 3 or higher while preserving Ruby VM-reserved descriptors. It enumerates `/proc/self/fd` on Linux and `/dev/fd` elsewhere, including macOS, and fails closed with setup status 127 if enumeration is unavailable or fails. Pass `close_others: false` only when the child intentionally needs an inherited descriptor. Child setup failures exit 127.
 
 The worker is a process-group leader and reserves Linux real-time signal `SIGRTMIN+2` for parent-death handling while the block runs. If the Ruby thread supervising the synchronous `Landlock.fork` call terminates, a native signal handler sends `SIGKILL` to the worker's process group. This terminates the worker and ordinary descendants that remain in that group. It does not cover descendants that create another process group or session, and the group-wide guarantee can be disabled by code that replaces or blocks the reserved signal, clears the parent-death signal, changes credentials in a way that clears it, or replaces the worker with `exec`. After `exec`, the reserved signal still terminates the worker by default, but the reset handler no longer kills its process group. This is process-lifecycle hardening, not a cgroup, PID namespace, or hostile-process containment boundary.
 

data/ext/landlock/landlock.c

@@ -5,10 +5,8 @@
 #include <signal.h>
 #include <string.h>
 
-#ifdef __linux__
 #include <dirent.h>
 #include <stdlib.h>
-#endif
 
 static VALUE mLandlock;
 static VALUE eLandlockError;
@@ -127,13 +125,18 @@ static VALUE rb_ll_close_fd(VALUE self, VALUE fd_value) {
   return Qnil;
 }
 
+#ifdef __linux__
+#define LL_DESCRIPTOR_DIRECTORY "/proc/self/fd"
+#else
+#define LL_DESCRIPTOR_DIRECTORY "/dev/fd"
+#endif
+
 static VALUE rb_ll_close_inherited_fds(VALUE self) {
   /* The forked child keeps running Ruby, so interpreter-reserved descriptors
    * must survive. This rules out close_range across the entire descriptor table. */
-#ifdef __linux__
-  DIR *dir = opendir("/proc/self/fd");
+  DIR *dir = opendir(LL_DESCRIPTOR_DIRECTORY);
   if (!dir) {
-    raise_syscall_error("opendir(/proc/self/fd)");
+    raise_syscall_error("opendir(" LL_DESCRIPTOR_DIRECTORY ")");
   }
 
   int dir_fd = dirfd(dir);
@@ -146,7 +149,7 @@ static VALUE rb_ll_close_inherited_fds(VALUE self) {
         int saved_errno = errno;
         closedir(dir);
         errno = saved_errno;
-        raise_syscall_error("readdir(/proc/self/fd)");
+        raise_syscall_error("readdir(" LL_DESCRIPTOR_DIRECTORY ")");
       }
       break;
     }
@@ -160,14 +163,9 @@ static VALUE rb_ll_close_inherited_fds(VALUE self) {
     }
   }
   if (closedir(dir) != 0) {
-    raise_syscall_error("closedir(/proc/self/fd)");
+    raise_syscall_error("closedir(" LL_DESCRIPTOR_DIRECTORY ")");
   }
   return Qtrue;
-#else
-  errno = ENOSYS;
-  raise_syscall_error("opendir(/proc/self/fd)");
-  return Qnil;
-#endif
 }
 
 static VALUE rb_ll_pidfd_open(VALUE self, VALUE pid_value) {

data/lib/landlock/execution.rb

@@ -86,19 +86,13 @@ module Landlock
         raise ArgumentError, "on_unsupported must be :raise or :run_without_landlock"
       end
 
-      enforce_landlock = Native.abi_version.positive?
-      if !enforce_landlock && (on_unsupported == :raise || !RUBY_PLATFORM.include?("linux"))
-        raise UnsupportedError, "Linux Landlock is unavailable"
-      end
+      enforce_landlock = Landlock.supported?
+      raise UnsupportedError, "Linux Landlock is unavailable" if !enforce_landlock && on_unsupported == :raise
 
       capture_options = prepare_capture_options(**options, require_landlock: enforce_landlock)
       validate_fallback_restriction!(**capture_options) if !enforce_landlock
 
-      Runner::Fork.call_block(
-        **capture_options,
-        enforce_landlock:,
-        &block
-      )
+      Runner::Fork.call_block(**capture_options, enforce_landlock:, &block)
     rescue OutputTooLargeError => error
       result = error.result
       raise CommandError.new(
@@ -205,7 +199,18 @@ module Landlock
       rlimits = Rlimits.normalize(rlimits)
       env = Env.normalize(env)
       policy =
-        prepare_policy(read:, write:, execute:, connect_tcp:, bind_tcp:, paths:, scope:, chdir:, allow_all_known:)
+        prepare_policy(
+          read:,
+          write:,
+          execute:,
+          connect_tcp:,
+          bind_tcp:,
+          paths:,
+          scope:,
+          chdir:,
+          allow_all_known:,
+          abi: require_landlock ? Native.abi_version : 0
+        )
       validate_capture_restriction!(**policy, seccomp_deny_network:, rlimits:)
 
       {
@@ -251,10 +256,21 @@ module Landlock
       raise UnsupportedError, "Linux Landlock is unavailable" unless Native.abi_version.positive?
     end
 
-    def prepare_policy(read:, write:, execute:, connect_tcp:, bind_tcp:, paths:, scope:, chdir:, allow_all_known:)
+    def prepare_policy(
+      read:,
+      write:,
+      execute:,
+      connect_tcp:,
+      bind_tcp:,
+      paths:,
+      scope:,
+      chdir:,
+      allow_all_known:,
+      abi: Native.abi_version
+    )
       connect_tcp = connect_tcp.nil? ? nil : Validation.normalize_ports(connect_tcp, :connect_tcp)
       bind_tcp = bind_tcp.nil? ? nil : Validation.normalize_ports(bind_tcp, :bind_tcp)
-      read, write, execute, paths = validate_policy_paths!(read:, write:, execute:, paths:, chdir:)
+      read, write, execute, paths = validate_policy_paths!(read:, write:, execute:, paths:, chdir:, abi:)
       { read:, write:, execute:, connect_tcp:, bind_tcp:, paths:, scope:, allow_all_known: }
     end
 
@@ -274,6 +290,10 @@ module Landlock
     end
 
     def validate_fallback_restriction!(seccomp_deny_network:, rlimits:, **)
+      if seccomp_deny_network && !RUBY_PLATFORM.include?("linux")
+        raise UnsupportedError, "seccomp_deny_network requires Linux"
+      end
+
       return if seccomp_deny_network || rlimits.any?
 
       raise ArgumentError, "Landlock fallback requires seccomp_deny_network or rlimits"
@@ -298,9 +318,8 @@ module Landlock
       raise ArgumentError, "empty capture policy: provide Landlock rules, seccomp_deny_network, or rlimits"
     end
 
-    def validate_policy_paths!(read:, write:, execute:, paths:, chdir:)
+    def validate_policy_paths!(read:, write:, execute:, paths:, chdir:, abi:)
       base = chdir ? File.expand_path(chdir) : Dir.pwd
-      abi = Native.abi_version
       read = read.nil? ? nil : Validation.validate_existing_paths(read, :read, chdir:)
       write = write.nil? ? nil : Validation.validate_existing_paths(write, :write, chdir:)
       execute = execute.nil? ? nil : Validation.validate_existing_paths(execute, :execute, chdir:)

data/lib/landlock/runner/fork.rb

@@ -139,9 +139,9 @@ module Landlock
             begin
               # Arm group cleanup only after leaving the supervisor's process group.
               ::Process.setpgrp
-              if kill_process_group_on_parent_death
+              if kill_process_group_on_parent_death && RUBY_PLATFORM.include?("linux")
                 Landlock::Native.arm_parent_death_process_group!(parent_pid)
-              else
+              elsif RUBY_PLATFORM.include?("linux")
                 Landlock::Native.set_parent_death_signal!
                 exit! 1 if ::Process.ppid != parent_pid
               end

data/lib/landlock/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Landlock
-  VERSION = "0.5"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: landlock
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: 0.5.1
 platform: ruby
 authors:
 - Sam Saffron