landlockpy 0.1.0__py3-none-any.whl

landlockpy/__init__.py

@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: 0BSD
+"""Python bindings for the Landlock Linux security module.
+
+Landlock lets unprivileged processes sandbox themselves with filesystem,
+network and IPC restrictions enforced by the kernel. Rulesets are scoped to
+what the running kernel supports, so applications get best-effort protection
+across kernel versions.
+
+Kernel reference: https://docs.kernel.org/userspace-api/landlock.html
+Project site: https://landlock.io/
+"""
+
+import errno
+
+from . import _syscall
+from .errors import LandlockError, UnsupportedError
+from .flags import (
+    AccessFS,
+    AccessNet,
+    RestrictFlag,
+    Scope,
+    fs_for_abi,
+    net_for_abi,
+    restrict_for_abi,
+    scope_for_abi,
+)
+from .ruleset import Ruleset
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AccessFS",
+    "AccessNet",
+    "LandlockError",
+    "RestrictFlag",
+    "Ruleset",
+    "Scope",
+    "UnsupportedError",
+    "__version__",
+    "abi_version",
+    "errata",
+    "fs_for_abi",
+    "net_for_abi",
+    "restrict_for_abi",
+    "scope_for_abi",
+    "supported",
+]
+
+
+def abi_version() -> int:
+    """Return the Landlock ABI version of the running kernel, or 0.
+
+    A return value of 0 means the kernel is too old (ENOSYS) or Landlock is
+    disabled at boot time (EOPNOTSUPP).
+    """
+    try:
+        return _syscall.abi_version()
+    except LandlockError as exc:
+        if exc.errno in (errno.ENOSYS, errno.EOPNOTSUPP):
+            return 0
+        raise
+
+
+def errata() -> int:
+    """Return the errata bitmask for the current ABI version, or 0.
+
+    Bit N set means erratum N is fixed in the running kernel. Older kernels
+    without the errata mechanism report 0. Most applications should not
+    check errata; best-effort enforcement is the safer default.
+    """
+    try:
+        return _syscall.errata()
+    except LandlockError as exc:
+        if exc.errno in (errno.ENOSYS, errno.EOPNOTSUPP, errno.EINVAL):
+            return 0
+        raise
+
+
+def supported() -> bool:
+    """Return whether the running kernel supports Landlock."""
+    return abi_version() >= 1

landlockpy/_syscall.py

@@ -0,0 +1,124 @@
+# SPDX-License-Identifier: 0BSD
+"""Raw ctypes bindings for the Landlock syscalls and prctl.
+
+The Landlock syscall numbers 444-446 are shared by every architecture that
+implements them. All calls go through libc's syscall(2) wrapper, so no libffi
+or compiler is needed.
+"""
+
+import ctypes
+import ctypes.util
+import errno
+import os
+import sys
+
+from .errors import LandlockError, UnsupportedError
+
+SYS_CREATE_RULESET = 444
+SYS_ADD_RULE = 445
+SYS_RESTRICT_SELF = 446
+
+PR_SET_NO_NEW_PRIVS = 38
+
+CREATE_RULESET_VERSION = 1 << 0
+CREATE_RULESET_ERRATA = 1 << 1
+
+ADD_RULE_QUIET = 1 << 0
+
+RULE_PATH_BENEATH = 1
+RULE_NET_PORT = 2
+
+
+class RulesetAttr(ctypes.Structure):
+    """struct landlock_ruleset_attr. The quiet fields need ABI 10."""
+
+    _fields_ = [
+        ("handled_access_fs", ctypes.c_uint64),
+        ("handled_access_net", ctypes.c_uint64),
+        ("scoped", ctypes.c_uint64),
+        ("quiet_access_fs", ctypes.c_uint64),
+        ("quiet_access_net", ctypes.c_uint64),
+        ("quiet_scoped", ctypes.c_uint64),
+    ]
+
+
+class PathBeneathAttr(ctypes.Structure):
+    """struct landlock_path_beneath_attr. Packed, no trailing padding."""
+
+    _pack_ = 1
+    _fields_ = [
+        ("allowed_access", ctypes.c_uint64),
+        ("parent_fd", ctypes.c_int32),
+    ]
+
+
+class NetPortAttr(ctypes.Structure):
+    """struct landlock_net_port_attr."""
+
+    _fields_ = [
+        ("allowed_access", ctypes.c_uint64),
+        ("port", ctypes.c_uint64),
+    ]
+
+
+_libc: ctypes.CDLL | None = None
+
+
+def _get_libc() -> ctypes.CDLL:
+    global _libc
+    if _libc is None:
+        if sys.platform != "linux":
+            raise UnsupportedError("Landlock is only available on Linux")
+        name = ctypes.util.find_library("c")
+        _libc = ctypes.CDLL(name or None, use_errno=True)
+        _libc.syscall.restype = ctypes.c_long
+        _libc.prctl.restype = ctypes.c_int
+    return _libc
+
+
+def _call(nr: int, *args: object) -> int:
+    ret = int(_get_libc().syscall(nr, *args))
+    if ret != -1:
+        return ret
+    err = ctypes.get_errno()
+    if err in (errno.ENOSYS, errno.EOPNOTSUPP):
+        raise UnsupportedError(err, os.strerror(err))
+    raise LandlockError(err, os.strerror(err))
+
+
+def abi_version() -> int:
+    """Return the highest Landlock ABI version supported by the kernel."""
+    return _call(SYS_CREATE_RULESET, None, 0, CREATE_RULESET_VERSION)
+
+
+def errata() -> int:
+    """Return the errata bitmask for the current ABI version."""
+    return _call(SYS_CREATE_RULESET, None, 0, CREATE_RULESET_ERRATA)
+
+
+def create_ruleset(attr: RulesetAttr) -> int:
+    """Create a ruleset and return its file descriptor."""
+    return _call(SYS_CREATE_RULESET, ctypes.byref(attr), ctypes.sizeof(attr), 0)
+
+
+def add_path_beneath(ruleset_fd: int, attr: PathBeneathAttr, flags: int = 0) -> None:
+    """Add a LANDLOCK_RULE_PATH_BENEATH rule to a ruleset."""
+    _call(SYS_ADD_RULE, ruleset_fd, RULE_PATH_BENEATH, ctypes.byref(attr), flags)
+
+
+def add_net_port(ruleset_fd: int, attr: NetPortAttr, flags: int = 0) -> None:
+    """Add a LANDLOCK_RULE_NET_PORT rule to a ruleset."""
+    _call(SYS_ADD_RULE, ruleset_fd, RULE_NET_PORT, ctypes.byref(attr), flags)
+
+
+def set_no_new_privs() -> None:
+    """Set the no_new_privs attribute on the calling thread via prctl."""
+    ret = _get_libc().prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)
+    if ret == -1:
+        err = ctypes.get_errno()
+        raise LandlockError(err, os.strerror(err))
+
+
+def restrict_self(ruleset_fd: int, flags: int = 0) -> None:
+    """Enforce a ruleset on the calling thread and its future children."""
+    _call(SYS_RESTRICT_SELF, ruleset_fd, flags)

landlockpy/errors.py

@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: 0BSD
+"""Exception types raised by landlockpy."""
+
+
+class LandlockError(OSError):
+    """A Landlock syscall failed."""
+
+
+class UnsupportedError(LandlockError):
+    """The running kernel does not support Landlock or the requested feature."""

landlockpy/flags.py

@@ -0,0 +1,168 @@
+# SPDX-License-Identifier: 0BSD
+"""Access rights, scope flags and restrict flags for Landlock rulesets.
+
+Flag values mirror the constants in linux/landlock.h. Each flag records the
+oldest Landlock ABI version that supports it; use the for_abi helpers to
+compute the subset usable on a given kernel.
+
+Kernel reference: https://docs.kernel.org/userspace-api/landlock.html
+"""
+
+from enum import IntFlag
+from typing import TypeVar
+
+__all__ = [
+    "LATEST_ABI",
+    "AccessFS",
+    "AccessNet",
+    "RestrictFlag",
+    "Scope",
+    "fs_for_abi",
+    "net_for_abi",
+    "restrict_for_abi",
+    "scope_for_abi",
+]
+
+LATEST_ABI = 11
+"""Newest Landlock ABI version known to this library."""
+
+
+class AccessFS(IntFlag):
+    """Filesystem access rights, mirroring LANDLOCK_ACCESS_FS_*.
+
+    Used in the handled_access_fs field of a ruleset and in the
+    allowed_access field of path rules. See "Filesystem flags" in the
+    kernel documentation.
+    """
+
+    NONE = 0
+    EXECUTE = 1 << 0
+    WRITE_FILE = 1 << 1
+    READ_FILE = 1 << 2
+    READ_DIR = 1 << 3
+    REMOVE_DIR = 1 << 4
+    REMOVE_FILE = 1 << 5
+    MAKE_CHAR = 1 << 6
+    MAKE_DIR = 1 << 7
+    MAKE_REG = 1 << 8
+    MAKE_SOCK = 1 << 9
+    MAKE_FIFO = 1 << 10
+    MAKE_BLOCK = 1 << 11
+    MAKE_SYM = 1 << 12
+    REFER = 1 << 13
+    TRUNCATE = 1 << 14
+    IOCTL_DEV = 1 << 15
+    RESOLVE_UNIX = 1 << 16
+
+
+class AccessNet(IntFlag):
+    """Network access rights, mirroring LANDLOCK_ACCESS_NET_*.
+
+    Used in the handled_access_net field of a ruleset and in the
+    allowed_access field of port rules. See "Network flags" in the
+    kernel documentation.
+    """
+
+    NONE = 0
+    BIND_TCP = 1 << 0
+    CONNECT_TCP = 1 << 1
+    BIND_UDP = 1 << 2
+    CONNECT_SEND_UDP = 1 << 3
+
+
+class Scope(IntFlag):
+    """Scope flags, mirroring LANDLOCK_SCOPE_*.
+
+    Set on a ruleset to isolate the domain from resources outside it,
+    such as abstract UNIX sockets or signals. See "Scope flags" in the
+    kernel documentation.
+    """
+
+    NONE = 0
+    ABSTRACT_UNIX_SOCKET = 1 << 0
+    SIGNAL = 1 << 1
+
+
+class RestrictFlag(IntFlag):
+    """Flags accepted by landlock_restrict_self, mirroring
+    LANDLOCK_RESTRICT_SELF_*. See "Enforcing a ruleset" in the kernel
+    documentation.
+    """
+
+    NONE = 0
+    LOG_SAME_EXEC_OFF = 1 << 0
+    LOG_NEW_EXEC_ON = 1 << 1
+    LOG_SUBDOMAINS_OFF = 1 << 2
+    TSYNC = 1 << 3
+    NO_NEW_PRIVS = 1 << 4
+
+
+_F = TypeVar("_F", bound=IntFlag)
+
+_FS_MIN_ABI: dict[AccessFS, int] = {
+    AccessFS.EXECUTE: 1,
+    AccessFS.WRITE_FILE: 1,
+    AccessFS.READ_FILE: 1,
+    AccessFS.READ_DIR: 1,
+    AccessFS.REMOVE_DIR: 1,
+    AccessFS.REMOVE_FILE: 1,
+    AccessFS.MAKE_CHAR: 1,
+    AccessFS.MAKE_DIR: 1,
+    AccessFS.MAKE_REG: 1,
+    AccessFS.MAKE_SOCK: 1,
+    AccessFS.MAKE_FIFO: 1,
+    AccessFS.MAKE_BLOCK: 1,
+    AccessFS.MAKE_SYM: 1,
+    AccessFS.REFER: 2,
+    AccessFS.TRUNCATE: 3,
+    AccessFS.IOCTL_DEV: 5,
+    AccessFS.RESOLVE_UNIX: 9,
+}
+
+_NET_MIN_ABI: dict[AccessNet, int] = {
+    AccessNet.BIND_TCP: 4,
+    AccessNet.CONNECT_TCP: 4,
+    AccessNet.BIND_UDP: 10,
+    AccessNet.CONNECT_SEND_UDP: 10,
+}
+
+_SCOPE_MIN_ABI: dict[Scope, int] = {
+    Scope.ABSTRACT_UNIX_SOCKET: 6,
+    Scope.SIGNAL: 6,
+}
+
+_RESTRICT_MIN_ABI: dict[RestrictFlag, int] = {
+    RestrictFlag.LOG_SAME_EXEC_OFF: 7,
+    RestrictFlag.LOG_NEW_EXEC_ON: 7,
+    RestrictFlag.LOG_SUBDOMAINS_OFF: 7,
+    RestrictFlag.TSYNC: 8,
+    RestrictFlag.NO_NEW_PRIVS: 11,
+}
+
+
+def _for_abi(table: dict[_F, int], flag_type: type[_F], abi: int) -> _F:
+    mask = flag_type(0)
+    for flag, min_abi in table.items():
+        if abi >= min_abi:
+            mask |= flag
+    return mask
+
+
+def fs_for_abi(abi: int) -> AccessFS:
+    """Return the filesystem rights supported by the given ABI version."""
+    return _for_abi(_FS_MIN_ABI, AccessFS, abi)
+
+
+def net_for_abi(abi: int) -> AccessNet:
+    """Return the network rights supported by the given ABI version."""
+    return _for_abi(_NET_MIN_ABI, AccessNet, abi)
+
+
+def scope_for_abi(abi: int) -> Scope:
+    """Return the scope flags supported by the given ABI version."""
+    return _for_abi(_SCOPE_MIN_ABI, Scope, abi)
+
+
+def restrict_for_abi(abi: int) -> RestrictFlag:
+    """Return the restrict flags supported by the given ABI version."""
+    return _for_abi(_RESTRICT_MIN_ABI, RestrictFlag, abi)

landlockpy/ruleset.py

@@ -0,0 +1,265 @@
+# SPDX-License-Identifier: 0BSD
+"""Ruleset construction and enforcement for Landlock."""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import types
+
+from . import _syscall
+from .errors import UnsupportedError
+from .flags import (
+    LATEST_ABI,
+    AccessFS,
+    AccessNet,
+    RestrictFlag,
+    Scope,
+    fs_for_abi,
+    net_for_abi,
+    restrict_for_abi,
+    scope_for_abi,
+)
+
+__all__ = ["Ruleset"]
+
+
+class Ruleset:
+    """A Landlock ruleset under construction.
+
+    A ruleset declares which access rights it handles. Handled rights are
+    denied by default once the ruleset is enforced; allow_path() and
+    allow_port() then grant back specific rights for specific objects:
+
+        with Ruleset() as ruleset:
+            ruleset.allow_path("/usr", AccessFS.READ_FILE | AccessFS.READ_DIR)
+            ruleset.allow_port(443, AccessNet.CONNECT_TCP)
+            ruleset.restrict()
+
+    Rights the running kernel does not support are dropped in best-effort
+    mode (the default), or rejected with UnsupportedError when best_effort
+    is False.
+
+    The ruleset owns a kernel file descriptor. Use it as a context manager
+    or call close() to release it.
+
+    Kernel reference: https://docs.kernel.org/userspace-api/landlock.html
+    """
+
+    def __init__(
+        self,
+        *,
+        handled_fs: AccessFS | None = None,
+        handled_net: AccessNet | None = None,
+        scoped: Scope = Scope.NONE,
+        quiet_fs: AccessFS = AccessFS.NONE,
+        quiet_net: AccessNet = AccessNet.NONE,
+        quiet_scoped: Scope = Scope.NONE,
+        best_effort: bool = True,
+    ) -> None:
+        self._abi = _syscall.abi_version()
+
+        req_fs = fs_for_abi(LATEST_ABI) if handled_fs is None else AccessFS(handled_fs)
+        req_net = (
+            net_for_abi(LATEST_ABI) if handled_net is None else AccessNet(handled_net)
+        )
+        req_scoped = Scope(scoped)
+
+        if best_effort:
+            self._handled_fs = req_fs & fs_for_abi(self._abi)
+            self._handled_net = req_net & net_for_abi(self._abi)
+            self._scoped = req_scoped & scope_for_abi(self._abi)
+        else:
+            self._reject_unsupported(req_fs, fs_for_abi(self._abi), "filesystem")
+            self._reject_unsupported(req_net, net_for_abi(self._abi), "network")
+            self._reject_unsupported(req_scoped, scope_for_abi(self._abi), "scope")
+            self._handled_fs = req_fs
+            self._handled_net = req_net
+            self._scoped = req_scoped
+
+        quiet_fs, quiet_net, quiet_scoped = (
+            AccessFS(quiet_fs),
+            AccessNet(quiet_net),
+            Scope(quiet_scoped),
+        )
+        if self._abi < 10 and (quiet_fs or quiet_net or quiet_scoped):
+            if not best_effort:
+                raise UnsupportedError("quiet rules require ABI 10")
+            quiet_fs, quiet_net, quiet_scoped = (
+                AccessFS.NONE,
+                AccessNet.NONE,
+                Scope.NONE,
+            )
+        if quiet_fs & ~self._handled_fs:
+            raise ValueError("quiet_fs must be a subset of handled_fs")
+        if quiet_net & ~self._handled_net:
+            raise ValueError("quiet_net must be a subset of handled_net")
+        if quiet_scoped & ~self._scoped:
+            raise ValueError("quiet_scoped must be a subset of scoped")
+
+        attr = _syscall.RulesetAttr(
+            handled_access_fs=int(self._handled_fs),
+            handled_access_net=int(self._handled_net),
+            scoped=int(self._scoped),
+            quiet_access_fs=int(quiet_fs),
+            quiet_access_net=int(quiet_net),
+            quiet_scoped=int(quiet_scoped),
+        )
+        self._fd = _syscall.create_ruleset(attr)
+        os.set_inheritable(self._fd, False)
+        self._closed = False
+        self._enforced = False
+
+    @staticmethod
+    def _reject_unsupported(requested: int, supported: int, kind: str) -> None:
+        missing = requested & ~supported
+        if missing:
+            raise UnsupportedError(
+                f"kernel does not support requested {kind} rights: {missing:#x}"
+            )
+
+    @property
+    def abi_version(self) -> int:
+        """Landlock ABI version of the running kernel."""
+        return self._abi
+
+    @property
+    def handled_fs(self) -> AccessFS:
+        """Filesystem rights this ruleset denies by default."""
+        return self._handled_fs
+
+    @property
+    def handled_net(self) -> AccessNet:
+        """Network rights this ruleset denies by default."""
+        return self._handled_net
+
+    @property
+    def scoped(self) -> Scope:
+        """Scope isolation flags applied to the domain."""
+        return self._scoped
+
+    @property
+    def enforced(self) -> bool:
+        """Whether restrict() has been called successfully."""
+        return self._enforced
+
+    @property
+    def closed(self) -> bool:
+        """Whether the ruleset file descriptor has been closed."""
+        return self._closed
+
+    def fileno(self) -> int:
+        """Return the underlying ruleset file descriptor."""
+        return self._fd
+
+    def _check_mutable(self) -> None:
+        if self._closed:
+            raise RuntimeError("ruleset is closed")
+        if self._enforced:
+            raise RuntimeError("ruleset is already enforced")
+
+    def allow_path(
+        self, path: str | os.PathLike[str], access: AccessFS, *, quiet: bool = False
+    ) -> AccessFS:
+        """Grant filesystem access rights on a file hierarchy.
+
+        The path can point to a file or a directory; a directory rule covers
+        its whole hierarchy. Access is masked against the handled filesystem
+        rights. Returns the rights actually granted, which is empty if none
+        of the requested rights are handled and no rule was added.
+
+        quiet marks the rule with LANDLOCK_ADD_RULE_QUIET, suppressing audit
+        logs for accesses the ruleset declared quiet (requires ABI 10).
+        See "Extending a ruleset" in the kernel documentation.
+        """
+        self._check_mutable()
+        granted = AccessFS(access) & self._handled_fs
+        if not granted:
+            return AccessFS.NONE
+        parent_fd = os.open(path, os.O_PATH | os.O_CLOEXEC)
+        try:
+            attr = _syscall.PathBeneathAttr(
+                allowed_access=int(granted), parent_fd=parent_fd
+            )
+            flags = _syscall.ADD_RULE_QUIET if quiet else 0
+            _syscall.add_path_beneath(self._fd, attr, flags)
+        finally:
+            os.close(parent_fd)
+        return granted
+
+    def allow_port(
+        self, port: int, access: AccessNet, *, quiet: bool = False
+    ) -> AccessNet:
+        """Grant network access rights on a TCP or UDP port.
+
+        Port 0 covers the ephemeral port range used by auto-bound sockets.
+        Access is masked against the handled network rights. Returns the
+        rights actually granted, which is empty if none of the requested
+        rights are handled and no rule was added.
+
+        A LandlockError with errno EAFNOSUPPORT means the kernel lacks
+        TCP/IP support; the operation is impossible anyway and the error
+        can safely be ignored. See "Extending a ruleset" in the kernel
+        documentation.
+        """
+        self._check_mutable()
+        if not 0 <= port <= 65535:
+            raise ValueError(f"port out of range: {port}")
+        granted = AccessNet(access) & self._handled_net
+        if not granted:
+            return AccessNet.NONE
+        attr = _syscall.NetPortAttr(allowed_access=int(granted), port=port)
+        flags = _syscall.ADD_RULE_QUIET if quiet else 0
+        _syscall.add_net_port(self._fd, attr, flags)
+        return granted
+
+    def restrict(
+        self, flags: RestrictFlag = RestrictFlag.NONE, *, no_new_privs: bool = True
+    ) -> None:
+        """Enforce the ruleset on the calling thread and its future children.
+
+        Flags unsupported by the running kernel are dropped. With
+        no_new_privs, the thread is also prevented from gaining privileges
+        through suid or file-capability binaries. On ABI 11 and newer this
+        is set atomically with enforcement; on older kernels a
+        prctl(PR_SET_NO_NEW_PRIVS) call is made first.
+
+        Enforcement is irreversible and per-thread. Without the TSYNC flag
+        (ABI 8), only the calling thread and its future children are
+        restricted; sibling threads keep their own policy. See "Enforcing
+        a ruleset" in the kernel documentation.
+        """
+        if self._closed:
+            raise RuntimeError("ruleset is closed")
+        if self._enforced:
+            raise RuntimeError("ruleset is already enforced")
+        effective = RestrictFlag(flags) & restrict_for_abi(self._abi)
+        if no_new_privs:
+            if self._abi >= 11:
+                effective |= RestrictFlag.NO_NEW_PRIVS
+            else:
+                _syscall.set_no_new_privs()
+        _syscall.restrict_self(self._fd, int(effective))
+        self._enforced = True
+
+    def close(self) -> None:
+        """Close the ruleset file descriptor. Safe to call twice."""
+        if not self._closed:
+            os.close(self._fd)
+            self._closed = True
+
+    def __enter__(self) -> Ruleset:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: types.TracebackType | None,
+    ) -> None:
+        self.close()
+
+    def __del__(self) -> None:
+        # __del__ must never raise
+        with contextlib.suppress(Exception):
+            self.close()

landlockpy-0.1.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.5
+Name: landlockpy
+Version: 0.1.0
+Summary: Python bindings for the Landlock Linux security module
+Project-URL: Homepage, https://quad4.io
+Project-URL: Repository, https://github.com/Quad4-Software/landlockpy
+Project-URL: Documentation, https://docs.kernel.org/userspace-api/landlock.html
+Author: Quad4
+License-Expression: 0BSD
+License-File: LICENSE
+Keywords: landlock,linux,lsm,sandbox,security
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Operating System Kernels :: Linux
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# landlockpy
+
+[![CI](https://github.com/Quad4-Software/landlockpy/actions/workflows/ci.yml/badge.svg)](https://github.com/Quad4-Software/landlockpy/actions/workflows/ci.yml)
+[![CodeQL](https://github.com/Quad4-Software/landlockpy/actions/workflows/codeql.yml/badge.svg)](https://github.com/Quad4-Software/landlockpy/actions/workflows/codeql.yml)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/Quad4-Software/landlockpy/badge)](https://securityscorecards.dev/viewer/?uri=github.com/Quad4-Software/landlockpy)
+[![License: 0BSD](https://img.shields.io/badge/license-0BSD-blue)](LICENSE)
+
+Dependency-free Python bindings for the Landlock Linux security module.
+Landlock lets unprivileged processes sandbox themselves with filesystem,
+network and IPC restrictions enforced by the kernel. Supports ABI versions
+1 through 11 with best-effort degradation on older kernels.
+
+Requires Python 3.10+ and Linux 5.13+ with Landlock enabled in the LSM list.
+
+## Install
+
+    pip install landlockpy
+
+## Usage
+
+```python
+from landlockpy import AccessFS, AccessNet, Ruleset
+
+with Ruleset() as ruleset:
+    ruleset.allow_path(
+        "/usr", AccessFS.READ_FILE | AccessFS.READ_DIR | AccessFS.EXECUTE
+    )
+    ruleset.allow_port(443, AccessNet.CONNECT_TCP)
+    ruleset.restrict()
+
+# everything not granted above is now denied for this thread and its children
+```
+
+`landlockpy.supported()` reports whether the running kernel has Landlock,
+and `landlockpy.abi_version()` returns its ABI version.
+
+## Documentation
+
+- API: docstrings in `src/landlockpy/`, mostly `ruleset.py`
+- Landlock API reference: https://docs.kernel.org/userspace-api/landlock.html
+- Project site: https://landlock.io/
+
+License: 0BSD.

landlockpy-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+landlockpy/__init__.py,sha256=WyQ9tjIUkPVnn6E5OJmUB8mHHJmu4rvmY2x9WxUAWYY,2049
+landlockpy/_syscall.py,sha256=AK4LeBMF543qaMwNoDSb__VjswUFJfbFCo1SD29lykU,3600
+landlockpy/errors.py,sha256=a9zosmfdz8G7nYyfUFt_fsjI7YfW5nS5GDE8gGctNPc,267
+landlockpy/flags.py,sha256=j_g1Y-HbFlyMiNwVV_sDlSACNq-ep9_aC1u0fTfO2Vs,4267
+landlockpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+landlockpy/ruleset.py,sha256=1bEm_1oWRLbjP83teE-ZxFb3puDQmm4E1nxQSRVoiPw,9514
+landlockpy-0.1.0.dist-info/METADATA,sha256=MLg59Kbd4f0fBJOU1_GCb4nY6ZErIO0Ckg9yufkdDts,2552
+landlockpy-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+landlockpy-0.1.0.dist-info/licenses/LICENSE,sha256=3Hnwsz5EXuTC9iTlGjzA171dKQtIVsgjFoF5DEMRl48,633
+landlockpy-0.1.0.dist-info/RECORD,,

landlockpy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

landlockpy-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,12 @@
+Copyright (c) 2026 Quad4
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.