mxc 0.2.0-x86_64-linux → 0.3.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86bb54e129b48e32e469fa771293b5d887064fad5a98c1ed7d47e98c823288e2
-  data.tar.gz: 22054e5c8fe708cf11fcacfba0e1612a296716f7f7f7f8428d2786ba93ca9e18
+  metadata.gz: e1fede2f737ced692fc0707a6aa148cb471456c51975a69b01453946be3cf86f
+  data.tar.gz: c71d74ea18026d8e8e7b4aa543c6fc54a87838986c244bf23576c4ecbe618140
 SHA512:
-  metadata.gz: 4db21a001399af4632811e84238a37b32d9d21b10fead1d87e62599385a5aa2fa661690fd182a35d9a0c6453981e4ad39970ca0262dccb2144a3b435b1f73e34
-  data.tar.gz: eef8f390ec961e9940660c10f2020820a7e341c8e53e584385b80571f8876d8291f6c94796ccb5da110705d1d33af045ac73f6e70b649a3e2119af48539fa61f
+  metadata.gz: c224454b5f04ddd562bf747cba8690b8337ec9a7b38300a52e38948eb087101cae22c5638330f955c2b26e6f06a33549406fe9691c8f47efb6aa148181bd472f
+  data.tar.gz: 51a0d65079bd000c4f8bd1eb255b6e98f73ffde581d9913273a6bf34a4ea067ac14d26a6e178933aebe0e5255cf73f720ad47ddde26a2fb0241f37bdafc87ce5

data/NOTICE

@@ -6,8 +6,8 @@ endorsed by Microsoft.
 
 The native extension compiles and links the mxc-sdk crate
 (https://github.com/microsoft/mxc, https://crates.io/crates/mxc-sdk), from
-a fork at https://github.com/crmne/microsoft-mxc that adds resource limits,
-which is distributed under the MIT License:
+a fork at https://github.com/crmne/microsoft-mxc that adds resource limits
+and a Landlock backend, which is distributed under the MIT License:
 
 MIT License
 

data/README.md

@@ -22,7 +22,7 @@ result.stdout
 result.success?
 ```
 
-It is an unofficial Ruby binding to [Microsoft's MXC](https://github.com/microsoft/mxc), the MIT-licensed sandbox library. Not affiliated with or endorsed by Microsoft. Resource limits come from [a fork of MXC](https://github.com/crmne/microsoft-mxc) until they are [part of MXC itself](https://github.com/microsoft/mxc/issues/1498).
+It is an unofficial Ruby binding to [Microsoft's MXC](https://github.com/microsoft/mxc), the MIT-licensed sandbox library. Not affiliated with or endorsed by Microsoft. Resource limits and the Landlock backend come from [a fork of MXC](https://github.com/crmne/microsoft-mxc) until they are part of MXC itself ([resource limits](https://github.com/microsoft/mxc/issues/1498), [Landlock](https://github.com/microsoft/mxc/issues/1494)).
 
 ## Installation
 
@@ -36,6 +36,8 @@ Precompiled gems cover Linux (x86_64 and ARM64, glibc and musl), macOS (Intel an
 sudo apt-get install bubblewrap
 ```
 
+Where Bubblewrap cannot create its namespaces, as in a default Docker container or on Ubuntu with AppArmor's restriction, sandboxes run on Landlock instead (Linux 6.2 or newer), without network access.
+
 Commands that use the network also need `slirp4netns`, `iptables`, util-linux, and `/dev/net/tun`. macOS and Windows need nothing extra.
 
 ## Usage
@@ -117,15 +119,16 @@ MXC.backends                   # => [#<MXC::Backend name=:bubblewrap ...>]
 
 ## Platforms
 
-| Platform | Backend | 0.2.0 |
+| Platform | Backend | 0.3.0 |
 | --- | --- | --- |
 | Linux | Bubblewrap | Supported and tested, without process limits |
+| Linux 6.2 and later | Landlock, where Bubblewrap cannot run or when asked for | Supported and tested, without network access or process limits |
 | macOS | Seatbelt | Supported and tested, without memory or process limits |
 | Windows 11 24H2 and later | ProcessContainer | Supported and tested, without host allow-lists |
 
 On Windows, a single String runs through `cmd.exe` instead of `sh`. See [Running Commands](https://crmne.github.io/mxc/running-commands/#windows) and [Policies](https://crmne.github.io/mxc/policies/#windows) for what else differs.
 
-Docker blocks the namespaces Bubblewrap needs by default. [Running in Docker](https://crmne.github.io/mxc/running-in-docker/) shows the smallest set of changes that makes it work, with a seccomp profile and a Kamal configuration for a job role.
+Docker blocks the namespaces Bubblewrap needs by default, so a default container runs sandboxes on Landlock. [Running in Docker](https://crmne.github.io/mxc/running-in-docker/) shows what that gives up, and the smallest set of changes that makes Bubblewrap work, with a seccomp profile and a Kamal configuration for a job role.
 
 ## Documentation
 

data/lib/mxc/availability.rb

@@ -16,9 +16,13 @@ module MXC
     # Returns a suggestion for making the host supported, or nil.
     attr_reader :remediation
 
+    # Returns the backend sandboxes run on, such as <tt>:bubblewrap</tt>, or <tt>:landlock</tt>
+    # when <tt>:auto</tt> falls back to it. Returns nil when no sandbox can start.
+    attr_reader :runs_on
+
     def self.probe(backend) # :nodoc:
       result = Sandbox.new(backend:, timeout: 10).run('exit 0')
-      return new(backend:, supported: true) if result.success?
+      return new(backend:, supported: true, runs_on: result.backend) if result.success?
 
       outcome = result.timed_out? ? 'timed out' : "exited with #{result.exit_code}"
       new(backend:, supported: false, reason: "A sandboxed `exit 0` #{outcome}: #{result.stderr.strip}")
@@ -26,8 +30,9 @@ module MXC
       new(backend:, supported: false, reason: e.message, remediation: e.remediation)
     end
 
-    def initialize(backend:, supported:, reason: nil, remediation: nil) # :nodoc:
+    def initialize(backend:, supported:, reason: nil, remediation: nil, runs_on: nil) # :nodoc:
       @backend = backend
+      @runs_on = runs_on
       @supported = supported
       @reason = reason
       @remediation = remediation
@@ -39,7 +44,8 @@ module MXC
     end
 
     def inspect # :nodoc:
-      "#<MXC::Availability backend=#{backend.inspect} supported=#{supported?} reason=#{reason.inspect}>"
+      "#<MXC::Availability backend=#{backend.inspect} supported=#{supported?} runs_on=#{runs_on.inspect} " \
+        "reason=#{reason.inspect}>"
     end
   end
 end

data/lib/mxc/configuration.rb

@@ -15,7 +15,8 @@ module MXC
       @timeout = nil
     end
 
-    # Sets the default backend: <tt>:auto</tt>, <tt>:bubblewrap</tt>, or <tt>:seatbelt</tt>.
+    # Sets the default backend: <tt>:auto</tt>, <tt>:bubblewrap</tt>, <tt>:landlock</tt>,
+    # <tt>:seatbelt</tt>, or <tt>:process_container</tt>.
     def backend=(name)
       @backend = Sandbox.backend_name(name)
     end

data/lib/mxc/native.rb

@@ -13,6 +13,9 @@ module MXC
     MISSING_BUBBLEWRAP = /bwrap\) is not installed/
     INSTALL_BUBBLEWRAP = 'Install Bubblewrap 0.5.0 or newer (Debian/Ubuntu: apt-get install bubblewrap; ' \
                          'Fedora: dnf install bubblewrap; Arch: pacman -S bubblewrap)'
+    LANDLOCK_REFUSAL = /\ALandlock: /
+    LANDLOCK_POLICY = 'Change the policy as the message says, or run on Bubblewrap: a sandbox with backend :auto ' \
+                      'runs on Landlock only where Bubblewrap cannot create its namespaces'
 
     def self.backend_attributes
       backends.map { |attributes| attributes.merge(name: BACKEND_NAMES.fetch(attributes[:name], attributes[:name])) }
@@ -21,8 +24,12 @@ module MXC
     def self.error(message, code: nil, remediation: nil, **)
       if message.match?(MISSING_BUBBLEWRAP)
         UnsupportedError.new(message, code: :backend_unavailable, remediation: remediation || INSTALL_BUBBLEWRAP, **)
+      elsif message.match?(LANDLOCK_REFUSAL)
+        UnsupportedError.new(message, code:, remediation: remediation || LANDLOCK_POLICY, **)
+      elsif UNSUPPORTED_CODES.include?(code)
+        UnsupportedError.new(message, code:, remediation: remediation || StartupFailure.hint(message), **)
       else
-        (UNSUPPORTED_CODES.include?(code) ? UnsupportedError : Error).new(message, code:, remediation:, **)
+        Error.new(message, code:, remediation:, **)
       end
     end
   end

data/lib/mxc/preflight.rb

@@ -16,16 +16,27 @@ module MXC
                    'Linux and Windows support it'
     PROCESS_LIMIT = 'Leave processes out of the limits. Only Windows can count the processes of one sandbox; ' \
                     'in a container, limit them with docker run --pids-limit'
+    LANDLOCK_NETWORK = 'Use network: false, or the :bubblewrap backend on a host that allows unprivileged user ' \
+                       'namespaces. Landlock cannot tell one address from another, so it could only allow the ' \
+                       "whole host network, the host's loopback and inbound connections included"
 
     module_function
 
-    def check!(network:, denied: [], resources: nil)
-      error = problem(network:, denied:, resources:)
+    def check!(network:, denied: [], resources: nil, backend: :auto)
+      error = problem(network:, denied:, resources:, backend:)
       raise error if error
     end
 
-    def problem(network:, denied: [], resources: nil, path: ENV.fetch('PATH', ''), tun: TUN)
-      resource_problem(resources) || host_problem(network, denied, path, tun)
+    def problem(network:, denied: [], resources: nil, backend: :auto, path: ENV.fetch('PATH', ''), tun: TUN)
+      resource_problem(resources) || landlock_problem(network, backend) || host_problem(network, denied, path, tun)
+    end
+
+    def landlock_problem(network, backend)
+      return unless network && backend == :landlock
+
+      kind = network.is_a?(Hash) ? 'Host allow-lists are' : 'Network access is'
+      UnsupportedError.new("#{kind} not supported on Landlock", code: :backend_unavailable,
+                                                                remediation: LANDLOCK_NETWORK)
     end
 
     def resource_problem(resources)

data/lib/mxc/sandbox.rb

@@ -28,7 +28,8 @@ module MXC
   #
   #   SkillSandbox.new.run("python3 app/skills/build.py")
   class Sandbox
-    BACKENDS = %i[auto bubblewrap seatbelt process_container].freeze # :nodoc:
+    BACKENDS = %i[auto bubblewrap landlock seatbelt process_container].freeze # :nodoc:
+    LANDLOCK_FALLBACK = /runs on Landlock instead/ # :nodoc:
     OPTIONS = %i[readable writable denied network env directory timeout backend limits priority].freeze # :nodoc:
     HOST_RESOLVER_SOCKETS = %w[/run/systemd/resolve].freeze # :nodoc:
     WINDOWS_ENV = %w[SYSTEMROOT WINDIR SYSTEMDRIVE COMSPEC PATHEXT PATH LOCALAPPDATA TEMP TMP
@@ -218,8 +219,12 @@ module MXC
     end
 
     # Sets the backend: <tt>:auto</tt> (Bubblewrap on Linux, Seatbelt on macOS,
-    # ProcessContainer on Windows), <tt>:bubblewrap</tt>, <tt>:seatbelt</tt>, or
-    # <tt>:process_container</tt>.
+    # ProcessContainer on Windows), <tt>:bubblewrap</tt>, <tt>:landlock</tt>, <tt>:seatbelt</tt>,
+    # or <tt>:process_container</tt>.
+    #
+    # On Linux, <tt>:auto</tt> runs on Landlock when Bubblewrap cannot create its namespaces,
+    # and says so in Result#warnings. <tt>:bubblewrap</tt> never does. <tt>:landlock</tt>
+    # needs Linux 6.2 or newer and runs without network access.
     def with_backend(name)
       @settings[:backend] = name && self.class.backend_name(name)
       self
@@ -279,7 +284,7 @@ module MXC
       return stream(*command, &) if block_given?
 
       outcome = StartupFailure.check!(Native.run(command_line(command), request))
-      Result.new(**outcome, backend: resolved_backend)
+      Result.new(**outcome, backend: resolved_backend(outcome[:warnings]))
     end
 
     # Starts +command+ and returns its Process without waiting for it. Takes the command
@@ -287,7 +292,8 @@ module MXC
     #
     #   sandbox.spawn("python3", "-i", "-q")
     def spawn(*command)
-      Process.new(Native.spawn(command_line(command), request), backend: resolved_backend)
+      native = Native.spawn(command_line(command), request)
+      Process.new(native, backend: resolved_backend(native.warnings))
     end
 
     # Returns true when this host can run this sandbox, including its network policy.
@@ -298,8 +304,10 @@ module MXC
     # Returns the Availability of this sandbox on this host, with the reason and
     # remediation when it cannot run.
     def availability
-      problem = Preflight.problem(network:, denied:, resources:)
-      return MXC.availability(backend:) unless problem
+      problem = Preflight.problem(network:, denied:, resources:, backend:)
+      host = MXC.availability(backend:) unless problem
+      problem ||= Preflight.problem(network:, backend: :landlock) if host&.runs_on == :landlock
+      return host unless problem
 
       Availability.new(backend:, supported: false, reason: problem.message, remediation: problem.remediation)
     end
@@ -404,15 +412,16 @@ module MXC
       arguments.map { |argument| WindowsArguments.quote(argument) }.join(' ')
     end
 
-    def resolved_backend
+    def resolved_backend(warnings)
       return backend unless backend == :auto
       return :process_container if Preflight.windows?
+      return :seatbelt unless Preflight.linux?
 
-      Preflight.linux? ? :bubblewrap : :seatbelt
+      warnings.any?(LANDLOCK_FALLBACK) ? :landlock : :bubblewrap
     end
 
     def request
-      Preflight.check!(network:, denied:, resources:)
+      Preflight.check!(network:, denied:, resources:, backend:)
       {
         readonly: expand(readable),
         readwrite: expand(writable),

data/lib/mxc/startup_failure.rb

@@ -7,7 +7,8 @@ module MXC
                               /setting up uid map/i, /unshare.*Operation not permitted/i)
     PROC = /Can't mount proc|mount proc on/i
     HOST_PROBLEMS = {
-      NAMESPACES => 'Unprivileged user namespaces are blocked. On a host, enable kernel.unprivileged_userns_clone=1 ' \
+      NAMESPACES => 'Unprivileged user namespaces are blocked. Use backend :auto or :landlock to run on Landlock ' \
+                    'instead, or allow them for Bubblewrap: on a host, enable kernel.unprivileged_userns_clone=1 ' \
                     'and, on Ubuntu 23.10 and later, allow bwrap in AppArmor ' \
                     '(kernel.apparmor_restrict_unprivileged_userns). ' \
                     "In Docker, run with a seccomp profile that allows namespaces: #{DOCKER_GUIDE}",
@@ -15,23 +16,27 @@ module MXC
               "In Docker, see #{DOCKER_GUIDE}"
     }.freeze
     CHDIR = /Can't chdir/i
+    BWRAP_LINE = /^bwrap: .*$/
 
     module_function
 
     def detect(outcome)
-      return unless outcome[:exit_code] == 1 && outcome[:stdout].to_s.empty?
+      failure = outcome[:failure] or return
+      reason = outcome[:stderr].to_s.scan(BWRAP_LINE).last
+      return Error.new(failure, code: :backend_error) unless reason
 
-      stderr = outcome[:stderr].to_s
-      return unless stderr.match?(/\Abwrap: [^\n]*\n?\z/)
-
-      message = "Bubblewrap could not start the sandbox: #{stderr.strip}"
-      _, hint = HOST_PROBLEMS.find { |pattern, _| stderr.match?(pattern) }
+      message = "Bubblewrap could not start the sandbox: #{reason}"
+      hint = hint(reason)
       return UnsupportedError.new(message, code: :backend_unavailable, remediation: hint, operation: 'bwrap') if hint
 
-      remediation = 'Make the directory readable or writable in the sandbox' if stderr.match?(CHDIR)
+      remediation = 'Make the directory readable or writable in the sandbox' if reason.match?(CHDIR)
       Error.new(message, code: :backend_error, remediation:, operation: 'bwrap')
     end
 
+    def hint(message)
+      HOST_PROBLEMS.find { |pattern, _| message.match?(pattern) }&.last
+    end
+
     def check!(outcome)
       error = detect(outcome)
       raise error if error

data/lib/mxc/version.rb

@@ -2,5 +2,5 @@
 
 module MXC
   # The gem version.
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/mxc.rb

@@ -87,7 +87,8 @@ module MXC
       Native.backend_attributes.map { |attributes| Backend.new(**attributes) }
     end
 
-    # Returns true when this host supports +capability+ with the configured backend.
+    # Returns true when this host supports +capability+ with the configured backend. Where
+    # sandboxes run on Landlock, there is no <tt>:network</tt> or <tt>:network_policy</tt>.
     #
     # +capability+ is <tt>:network</tt> for unrestricted network access,
     # <tt>:network_policy</tt> for host allow-lists, <tt>:cpu_time_limit</tt>,
@@ -100,8 +101,8 @@ module MXC
       return false unless supported?
 
       case capability
-      when :network then Preflight.problem(network: true).nil?
-      when :network_policy then Preflight.problem(network: { allow: [] }).nil? && proxy_enforcement?
+      when :network then Preflight.problem(network: true, backend: runs_on).nil?
+      when :network_policy then Preflight.problem(network: { allow: [] }, backend: runs_on).nil? && proxy_enforcement?
       when *RESOURCE_CAPABILITIES.keys then Preflight.resource_problem(RESOURCE_CAPABILITIES[capability]).nil?
       else configured_backends.any? { |backend| backend.supports?(capability) }
       end
@@ -109,6 +110,10 @@ module MXC
 
     private
 
+    def runs_on
+      availability.runs_on
+    end
+
     def proxy_enforcement?
       !Preflight.linux? || configured_backends.any? { |backend| backend.supports?(:proxy_enforcement) }
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mxc
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: x86_64-linux
 authors:
 - Carmine Paolino
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-10-14 00:00:00.000000000 Z
+date: 2026-10-17 00:00:00.000000000 Z
 dependencies: []
 description: An unofficial Ruby binding to Microsoft's MXC. Run commands in Bubblewrap,
   Seatbelt or Windows ProcessContainer sandboxes with filesystem, network, environment