linkward 0.1.0__py3-none-any.whl

linkward/__init__.py

@@ -0,0 +1,27 @@
+"""Read local files without following symlinks in any path component.
+
+``safe_open`` returns bytes after checking policy on the opened descriptor.
+``open_nofollow`` returns a caller-owned descriptor with only the path guarantee.
+Metadata checks provide best-effort change detection, not a content snapshot or
+proof of authenticity. Linux and macOS; standard library only.
+"""
+
+from .core import (
+    FileChangedDuringRead,
+    FilePolicyError,
+    SafeOpenError,
+    SymlinkRejected,
+    open_nofollow,
+    safe_open,
+)
+
+__all__ = [
+    "FileChangedDuringRead",
+    "FilePolicyError",
+    "SafeOpenError",
+    "SymlinkRejected",
+    "open_nofollow",
+    "safe_open",
+]
+
+__version__ = "0.1.0"

linkward/core.py

@@ -0,0 +1,353 @@
+"""Symlink-rejecting reads with policy checks on the opened file descriptor.
+
+Directory descriptors anchor each step of path traversal. ``O_NOFOLLOW`` rejects
+links rather than checking a path and later trusting it to stay unchanged.
+Metadata comparisons detect some concurrent writes; they do not provide a snapshot.
+"""
+
+from __future__ import annotations
+
+import errno
+import os
+import stat as stat_module
+from typing import NoReturn
+
+__all__ = [
+    "FileChangedDuringRead",
+    "FilePolicyError",
+    "SafeOpenError",
+    "SymlinkRejected",
+    "open_nofollow",
+    "safe_open",
+]
+
+
+class SafeOpenError(Exception):
+    """Base class for every linkward failure."""
+
+
+class SymlinkRejected(SafeOpenError):
+    """A symlink was encountered in a path component, or the target itself is one."""
+
+
+class FileChangedDuringRead(SafeOpenError):
+    """The observed metadata or read length indicates a concurrent change."""
+
+
+class FilePolicyError(SafeOpenError):
+    """The opened file did not satisfy a required mode / owner / size / type policy."""
+
+
+# O_NOFOLLOW: if the final component is a symlink, fail instead of following it.
+# O_DIRECTORY: assert the component we just opened is a directory (used while descending).
+# O_CLOEXEC: never leak these fds across an exec.
+# O_NONBLOCK avoids a FIFO open waiting for a writer. It is not an I/O timeout:
+# regular files and some devices/filesystems can still block.
+_REQUIRED_FLAGS = ("O_NOFOLLOW", "O_DIRECTORY", "O_CLOEXEC", "O_NONBLOCK")
+
+# Read in bounded chunks so a hostile/huge file can't force an unbounded allocation.
+_CHUNK = 65536
+
+
+def _require_absolute(path: str | os.PathLike[str]) -> tuple[str, list[str]]:
+    """Convert a PathLike once, then validate its text without resolving links."""
+    try:
+        path = os.fspath(path)
+    except TypeError as exc:
+        raise SafeOpenError(
+            "path must be a string or a PathLike returning a string"
+        ) from exc
+    if not isinstance(path, str) or not path or "\x00" in path:
+        raise SafeOpenError("path must be non-empty text without NUL characters")
+    try:
+        os.fsencode(path)
+    except UnicodeEncodeError as exc:
+        raise SafeOpenError("path cannot be encoded for this filesystem") from exc
+    if not path.startswith("/"):
+        raise SafeOpenError("path must be absolute (start with '/')")
+    parts = [component for component in path.split("/") if component]
+    if any(component in (".", "..") for component in parts):
+        raise SafeOpenError("path must not contain '.' or '..' components")
+    if not parts:
+        raise SafeOpenError("path must reference a file, not the filesystem root")
+    if path.endswith("/"):
+        raise SafeOpenError("path must not end with '/'")
+    return path, parts
+
+
+def open_nofollow(path: str | os.PathLike[str]) -> int:
+    """Open ``path`` for reading with no symlink permitted in any component.
+
+    Returns a non-inheritable, non-blocking descriptor. The caller owns it and
+    must ``os.close`` it. No file type, owner, mode, size, or content checks are
+    performed. During a path race, a rejected link may be reported as the broader
+    :class:`SafeOpenError` if its type can no longer be determined.
+
+    This is the low-level primitive; most callers want :func:`safe_open`.
+    """
+    path, parts = _require_absolute(path)
+    return _open_components(path, parts)
+
+
+def _open_components(path: str, parts: list[str]) -> int:
+    if os.name != "posix" or any(not hasattr(os, flag) for flag in _REQUIRED_FLAGS):
+        raise SafeOpenError(
+            "this platform lacks the required POSIX no-follow open flags"
+        )
+    dir_flags = os.O_RDONLY | os.O_NOFOLLOW | os.O_DIRECTORY | os.O_CLOEXEC
+    leaf_flags = os.O_RDONLY | os.O_NOFOLLOW | os.O_CLOEXEC | os.O_NONBLOCK
+    *dirs, leaf = parts
+
+    try:
+        parent_fd = os.open("/", dir_flags)
+    except OSError as exc:
+        raise SafeOpenError(f"cannot open filesystem root for {path!r}: {exc}") from exc
+    leaf_fd = None
+    try:
+        for component in dirs:
+            try:
+                next_fd = os.open(component, dir_flags, dir_fd=parent_fd)
+            except OSError as exc:
+                _reclassify_component(exc, component, parent_fd, path, is_leaf=False)
+            else:
+                previous_fd = parent_fd
+                parent_fd = next_fd
+                _close_fd(previous_fd)
+
+        try:
+            leaf_fd = os.open(leaf, leaf_flags, dir_fd=parent_fd)
+        except OSError as exc:
+            _reclassify_component(exc, leaf, parent_fd, path, is_leaf=True)
+    except NotImplementedError as exc:
+        raise SafeOpenError(
+            "this platform lacks descriptor-relative open support"
+        ) from exc
+    finally:
+        try:
+            _close_fd(parent_fd)
+        except BaseException:
+            # Do not lose an opened leaf if closing its parent prevents return.
+            if leaf_fd is not None:
+                _close_fd(leaf_fd)
+            raise
+    return leaf_fd
+
+
+def _close_fd(fd: int) -> None:
+    try:
+        os.close(fd)
+    except OSError as exc:
+        # Never retry close: the OS may already have released/reused this number.
+        raise SafeOpenError(f"cannot close file descriptor {fd}: {exc}") from exc
+
+
+def safe_open(
+    path: str | os.PathLike[str],
+    *,
+    max_bytes: int = 1024 * 1024,
+    require_mode: int | None = None,
+    require_owner: int | None = None,
+    require_regular_file: bool = True,
+    require_single_hardlink: bool = False,
+) -> bytes:
+    """Read bytes without following links, checking policy on the opened file.
+
+    Two ``fstat`` observations check device/inode, size, mtime, and ctime, and the
+    read length must agree with the initial size. Matching metadata does not prove
+    unchanged contents: concurrent writes (including mmap writes) can escape these
+    checks. This is not an atomic snapshot or a directory confinement primitive.
+
+    Parameters
+    ----------
+    path:
+        Absolute text path or PathLike[str]. No ``.``/``..`` components, trailing
+        slash, or symlinks. The text returned by ``os.fspath`` is validated.
+    max_bytes:
+        Non-negative integer limit on returned bytes. Reads at most one extra
+        byte to detect growth. Buffer assembly can use more than this much memory.
+    require_mode:
+        If set, the file's permission bits (``st_mode & 0o777``) must equal this,
+        e.g. ``0o600`` for a credentials file. Otherwise :class:`FilePolicyError`.
+    require_owner:
+        If set, the file's ``st_uid`` must equal this (typically ``os.geteuid()``).
+    require_regular_file:
+        If True (default), reject anything that is not a regular file
+        (fifos, devices, directories, sockets).
+    require_single_hardlink:
+        If True, require ``st_nlink == 1`` at the initial policy check. This is
+        not proof that no other process can write the file.
+
+    Returns
+    -------
+    bytes
+        The file's contents.
+    """
+    _validate_policy(
+        max_bytes,
+        require_mode,
+        require_owner,
+        require_regular_file,
+        require_single_hardlink,
+    )
+    path, parts = _require_absolute(path)
+
+    fd = _open_components(path, parts)
+    try:
+        before = os.fstat(fd)
+
+        _enforce_policy(
+            before,
+            path=path,
+            max_bytes=max_bytes,
+            require_mode=require_mode,
+            require_owner=require_owner,
+            require_regular_file=require_regular_file,
+            require_single_hardlink=require_single_hardlink,
+        )
+
+        data = _read_all(fd, max_bytes=max_bytes, path=path)
+
+        after = os.fstat(fd)
+        _assert_unchanged(before, after, path=path, read_len=len(data))
+        return data
+    except OSError as exc:
+        raise SafeOpenError(f"cannot read or inspect {path!r}: {exc}") from exc
+    finally:
+        _close_fd(fd)
+
+
+def _validate_policy(
+    max_bytes: int,
+    require_mode: int | None,
+    require_owner: int | None,
+    require_regular_file: bool,
+    require_single_hardlink: bool,
+) -> None:
+    for name, value in (
+        ("max_bytes", max_bytes),
+        ("require_mode", require_mode),
+        ("require_owner", require_owner),
+    ):
+        if value is None and name != "max_bytes":
+            continue
+        if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+            raise SafeOpenError(f"{name} must be a non-negative integer")
+    if require_mode is not None and require_mode > 0o777:
+        raise SafeOpenError("require_mode must be between 0 and 0o777")
+    for name, value in (
+        ("require_regular_file", require_regular_file),
+        ("require_single_hardlink", require_single_hardlink),
+    ):
+        if not isinstance(value, bool):
+            raise SafeOpenError(f"{name} must be a bool")
+
+
+def _enforce_policy(
+    st: os.stat_result,
+    *,
+    path: str,
+    max_bytes: int,
+    require_mode: int | None,
+    require_owner: int | None,
+    require_regular_file: bool,
+    require_single_hardlink: bool,
+) -> None:
+    if require_regular_file and not stat_module.S_ISREG(st.st_mode):
+        raise FilePolicyError(f"{path!r} is not a regular file")
+    if require_mode is not None and (st.st_mode & 0o777) != require_mode:
+        raise FilePolicyError(
+            f"{path!r} has mode {st.st_mode & 0o777:#o}, required {require_mode:#o}"
+        )
+    if require_owner is not None and st.st_uid != require_owner:
+        raise FilePolicyError(
+            f"{path!r} is owned by uid {st.st_uid}, required uid {require_owner}"
+        )
+    if require_single_hardlink and st.st_nlink != 1:
+        raise FilePolicyError(
+            f"{path!r} has {st.st_nlink} hardlinks, required exactly 1"
+        )
+    if st.st_size > max_bytes:
+        raise FilePolicyError(
+            f"{path!r} is {st.st_size} bytes, exceeds max_bytes={max_bytes}"
+        )
+
+
+def _read_all(fd: int, *, max_bytes: int, path: str) -> bytes:
+    """Read up to max_bytes+1 so we can detect a file that grew past the limit."""
+    chunks: list[bytes] = []
+    total = 0
+    while total <= max_bytes:
+        chunk = os.read(fd, min(_CHUNK, max_bytes - total + 1))
+        if not chunk:
+            break
+        chunks.append(chunk)
+        total += len(chunk)
+        if total > max_bytes:
+            raise FilePolicyError(
+                f"{path!r} grew past max_bytes={max_bytes} during read"
+            )
+    return b"".join(chunks)
+
+
+def _assert_unchanged(
+    before: os.stat_result,
+    after: os.stat_result,
+    *,
+    path: str,
+    read_len: int,
+) -> None:
+    """Reject if the fd's underlying file changed identity, size, or timestamps.
+
+    This compares observations, not path names or content versions. Once opened,
+    a descriptor stays attached to its inode even if the path is replaced.
+    """
+    if (before.st_dev, before.st_ino) != (after.st_dev, after.st_ino):
+        raise FileChangedDuringRead(f"{path!r} changed identity (inode) during read")
+    if before.st_size != after.st_size:
+        raise FileChangedDuringRead(
+            f"{path!r} changed size during read ({before.st_size} -> {after.st_size})"
+        )
+    if (
+        before.st_mtime_ns != after.st_mtime_ns
+        or before.st_ctime_ns != after.st_ctime_ns
+    ):
+        raise FileChangedDuringRead(f"{path!r} was modified during read")
+    if read_len != before.st_size:
+        raise FileChangedDuringRead(
+            f"{path!r}: read {read_len} bytes but stat reported {before.st_size}"
+        )
+
+
+def _reclassify_component(
+    exc: OSError,
+    component: str,
+    parent_fd: int,
+    path: str,
+    *,
+    is_leaf: bool,
+) -> NoReturn:
+    """Translate a failed no-follow open into the right exception.
+
+    ELOOP identifies a rejected link directly. With O_DIRECTORY some systems use
+    ENOTDIR instead; lstat is a best-effort diagnostic for those cases. The entry
+    can change between open and lstat, affecting only the exception subtype. No
+    failed open is retried, so classification cannot cause a link to be followed.
+    """
+    where = "target file" if is_leaf else "path component"
+    if exc.errno == errno.ELOOP:
+        raise SymlinkRejected(
+            f"{where} {component!r} in {path!r} is a symlink"
+        ) from exc
+    try:
+        st = os.lstat(component, dir_fd=parent_fd)
+        is_symlink = stat_module.S_ISLNK(st.st_mode)
+    except (OSError, NotImplementedError):
+        is_symlink = False
+
+    if is_symlink:
+        raise SymlinkRejected(
+            f"{where} {component!r} in {path!r} is a symlink"
+        ) from exc
+    raise SafeOpenError(
+        f"cannot open {where} {component!r} in {path!r}: {exc}"
+    ) from exc

linkward-0.1.0.dist-info/METADATA

@@ -0,0 +1,254 @@
+Metadata-Version: 2.3
+Name: linkward
+Version: 0.1.0
+Summary: Read local files without following symlinks, with owner, mode, and size checks.
+Project-URL: Homepage, https://github.com/alohaaaaaaaaaaaaaa/safeopen
+Project-URL: Issues, https://github.com/alohaaaaaaaaaaaaaa/safeopen/issues
+Project-URL: Source, https://github.com/alohaaaaaaaaaaaaaa/safeopen
+Author: Elton Pang
+License: MIT License
+        
+        Copyright (c) 2026 Elton Pang
+        
+        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.
+Keywords: file,o_nofollow,race-condition,security,symlink,toctou
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Filesystems
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# linkward
+
+**Read a local file while rejecting symbolic links in every path component, with optional owner, permission, and size checks.**
+
+Pure Python, zero runtime dependencies. Linux and macOS, Python 3.9+.
+
+Use it when a Python service or CLI reads a credential or configuration file and
+must reject symlink redirection. `linkward` opens each directory relative to the
+previous directory's descriptor with `O_NOFOLLOW`, then opens and reads the final
+file through the same descriptor used for policy checks.
+
+| Read method | Rejects a symlink at the final file | Rejects symlinks in parent directories |
+| --- | --- | --- |
+| `open(path, "rb")` | No | No |
+| `os.open(path, os.O_RDONLY \| os.O_NOFOLLOW)` | Yes | No |
+| `safe_open(path)` | Yes | Yes |
+
+This prevents symlink traversal during this open operation. It does **not** make
+an attacker-writable regular file trustworthy or provide a snapshot of its contents.
+
+## Install
+
+This project has not been published to PyPI. Install from the repository:
+
+```bash
+python -m pip install 'git+https://github.com/alohaaaaaaaaaaaaaa/linkward.git'
+```
+
+For a reproducible deployment, pin a reviewed commit after the `.git` URL with
+`@<commit>`.
+
+## Read a credential
+
+```python
+import os
+from pathlib import Path
+
+from linkward import SafeOpenError, safe_open
+
+# A configured absolute path with no symlinks in any component.
+credential_path = Path("/srv/myapp/token")
+
+try:
+    token = safe_open(
+        credential_path,
+        require_owner=os.geteuid(),
+        require_mode=0o600,
+        max_bytes=64 * 1024,
+    )
+except SafeOpenError:
+    # Abort startup rather than using a credential that failed these checks.
+    raise
+```
+
+Owner and permission checks are **off by default**; enable them for your trust
+policy. The example requires the effective user's ownership and exactly `0600`
+ordinary permission bits. A matching owner and mode do not establish content
+authenticity, and ACLs or other writers may still permit changes.
+
+Paths must be absolute `str` or `os.PathLike[str]` values. Relative paths, `.` or
+`..` components, NUL characters, the filesystem root, and trailing slashes are
+rejected. Validation applies to the text returned by `os.fspath()`; a `Path`
+object may already have removed `.` components or trailing slashes. Bytes paths
+are unsupported.
+
+Parent directories are opened read-only, so the caller needs directory read and
+search permissions as well as permission to read the file.
+
+On macOS, `/tmp`, `/var`, and `/etc` commonly contain or are symlinks. Configure a
+trusted canonical path such as `/private/etc/myapp/token` if appropriate for your
+system. Do not call `resolve()` or `realpath()` on an untrusted path just to make it
+pass: those operations follow links, and a later open can encounter a changed path.
+
+## Run the attack demonstration
+
+After installation, from a repository checkout:
+
+```bash
+python examples/symlink_attack.py
+```
+
+The demonstration compares ordinary `open()`, final-component-only `O_NOFOLLOW`,
+and `safe_open()`. It also performs a controlled swap between a separate path
+check and open. The timing is deliberate: this illustrates the failure mode and
+the protection, rather than measuring a probabilistic race's success rate.
+
+## API
+
+```python
+safe_open(
+    path,
+    *,
+    max_bytes=1024 * 1024,
+    require_mode=None,
+    require_owner=None,
+    require_regular_file=True,
+    require_single_hardlink=False,
+) -> bytes
+
+open_nofollow(path) -> int
+```
+
+| `safe_open` option | Behavior |
+| --- | --- |
+| `max_bytes` | Nonnegative integer; reject an oversized file. Returned bytes never exceed this limit. |
+| `require_mode` | Optional integer from `0` to `0o777`; require an exact match with `st_mode & 0o777`. Special mode bits and ACLs are not checked by this option. |
+| `require_owner` | Optional nonnegative user ID to match against `st_uid`, commonly `os.geteuid()`. |
+| `require_regular_file` | Default `True`; reject directories, FIFOs, devices, sockets, and other nonregular files. |
+| `require_single_hardlink` | Default `False`; if enabled, require `st_nlink == 1` at the initial inspection. This is a link-count check, not a guarantee of exclusive access. |
+
+Integer options reject booleans; the two boolean options require actual `bool`
+values. Policy checks use the initial descriptor metadata, followed by the
+before/after change check. Setting `require_regular_file=False` does not turn this
+into a general stream reader: size and read-length consistency checks still apply,
+so pseudo-files that report a size of zero can be rejected despite having content.
+
+Size detection may read one byte beyond `max_bytes` before rejecting a growing
+file. Chunk storage and combining the result also require memory beyond the
+returned bytes; `max_bytes` is not a strict process-memory limit.
+
+`open_nofollow()` only provides the path traversal guarantee. It does not enforce
+file type, owner, permissions, size, link count, or content stability. Its descriptor
+is opened read-only and nonblocking and is not inherited across `exec`; the caller
+must close it:
+
+```python
+import os
+from linkward import open_nofollow
+
+fd = open_nofollow("/srv/myapp/token")
+try:
+    metadata = os.fstat(fd)
+    # Apply your own policy and read from this descriptor.
+finally:
+    os.close(fd)
+```
+
+All library failures derive from `SafeOpenError`:
+
+| Exception | Meaning |
+| --- | --- |
+| `SymlinkRejected` | A symbolic link was identified in a rejected path component. |
+| `FilePolicyError` | The opened file did not meet the requested type, owner, mode, size, or link-count policy. |
+| `FileChangedDuringRead` | Descriptor metadata or the amount read indicated a change during the read. |
+| `SafeOpenError` | Invalid input, unsupported platform, or another filesystem failure. |
+
+Filesystem `OSError`s are wrapped with the original exception in `__cause__` for
+diagnostics. A concurrent path change can affect the exception classification;
+the operation still rejects a component it cannot open safely.
+
+## Security boundaries
+
+- **Concurrent content writes:** the before/after `fstat` comparison is a
+  best-effort change detector. Writes through `mmap`, filesystem timestamp
+  behavior, or other concurrent writes can leave indistinguishable metadata.
+  A successful read can contain a mixture of bytes from different moments.
+  There is no snapshot or authenticity guarantee. Use an appropriate publication
+  or integrity scheme when those guarantees are required.
+- **Renames and directory replacement:** once opened, a descriptor stays attached
+  to the selected object. Renaming a path does not make the reader follow the new
+  name and does not necessarily cause an error. Already-opened directories can
+  also be moved; traversal is not confinement within a pathname boundary.
+- **Other redirection and writers:** malicious regular files, hard links, bind
+  mounts, mount changes, privileged attackers, and other processes with write
+  access are outside the symlink guarantee. Protect files and their directories
+  according to your threat model. This library is not a sandbox or `chroot`.
+- **Platform and I/O:** Windows is unsupported. Filesystem behavior still matters;
+  nonblocking open avoids the usual FIFO-open wait but does not guarantee a time
+  limit on file operations or safe reads from arbitrary devices. Keep the default
+  regular-file requirement unless you explicitly handle other file types.
+
+See [SECURITY.md](SECURITY.md) for reporting vulnerabilities.
+
+## Related work
+
+Safe path handling predates this project. Other approaches include
+[`pathrs`](https://pypi.org/project/pathrs/) and
+[`google/linkward`](https://github.com/google/linkward); their APIs, dependencies,
+and confinement semantics differ. This project's focus is a small Python API for
+rejecting every symlink component and checking the descriptor being read.
+
+The `filelock` advisories
+[CVE-2025-68146](https://github.com/tox-dev/filelock/security/advisories/GHSA-w853-jp5j-5j7f)
+and [CVE-2026-22701](https://github.com/tox-dev/filelock/security/advisories/GHSA-qmgc-5h2g-mvrw)
+illustrate related symlink risks in lock-file creation and locking. `linkward` is
+read-only; it does not implement those locking operations or replace their fixes.
+
+## Development
+
+```bash
+git clone https://github.com/alohaaaaaaaaaaaaaa/linkward.git
+cd linkward
+python -m pip install --upgrade pip
+python -m pip install -e '.[test]'
+python -m pytest
+```
+
+The tests cover accepted reads as well as rejected paths and policies, controlled
+concurrent changes, and descriptor cleanup.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

linkward-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+linkward/__init__.py,sha256=6ZuYL6jA1ebsiKdgX7zJR-63mJOuzp9SGxx4ps8TsJY,693
+linkward/core.py,sha256=hVyMUc5QO9va1YpWDb6qg0L4_LfHiMo09wLrSvJ_OOo,12668
+linkward/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+linkward-0.1.0.dist-info/METADATA,sha256=HwMcNytxuDny07-canh76FefUdckd15ZIBq_4aeMblA,11146
+linkward-0.1.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+linkward-0.1.0.dist-info/licenses/LICENSE,sha256=msluwQln86rse-NmyqkWZvY08nZWXrY4rJBwlMasRv4,1067
+linkward-0.1.0.dist-info/RECORD,,

linkward-0.1.0.dist-info/WHEEL

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

linkward-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Elton Pang
+
+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.