cryptnode 0.1.1__1-py3-none-win_amd64.whl

cryptnode/ubuntu.py

@@ -0,0 +1,144 @@
+"""One systemd instance per portal on Ubuntu; no root-resident Host."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+import pwd
+import subprocess
+import sys
+import tempfile
+import time
+from typing import Dict
+
+from .models import NodeError, Profile
+from .paths import profile_dir
+
+
+UNIT_DIR = Path("/etc/systemd/system")
+
+
+def _unit_name(profile: Profile) -> str:
+    return "cryptnode@%d.service" % profile.portal_id
+
+
+def _quote(value: str) -> str:
+    if any(character in value for character in "\r\n\x00"):
+        raise NodeError("unit_path", "systemd path contains a control character")
+    return '"%s"' % value.replace("\\", "\\\\").replace('"', '\\"').replace("%", "%%").replace("$", "$$")
+
+
+def _working_directory(value: str) -> str:
+    if not value.startswith("/") or any(character in value for character in "\r\n\x00"):
+        raise NodeError("unit_path", "systemd working directory must be an absolute path")
+    return value.replace("\\", "\\\\").replace("%", "%%")
+
+
+def _run(*args: str, allow_failure: bool = False) -> str:
+    result = subprocess.run(["systemctl", *args], capture_output=True, text=True,
+                            timeout=30, check=False)
+    if result.returncode != 0 and not allow_failure:
+        raise NodeError("systemd_failed", "systemd operation failed: %s" % args[0])
+    return result.stdout
+
+
+def status(profile: Profile) -> Dict[str, str]:
+    output = _run("show", _unit_name(profile),
+                  "--property=LoadState,ActiveState,SubState,UnitFileState,MainPID", allow_failure=True)
+    row = dict(line.split("=", 1) for line in output.splitlines() if "=" in line)
+    if row.get("LoadState") != "loaded":
+        return {"exists": "false", "active": "false", "enabled": "false", "pid": "0"}
+    return {"exists": "true", "active": str(row.get("ActiveState") == "active").lower(),
+            "enabled": str(row.get("UnitFileState") == "enabled").lower(),
+            "pid": row.get("MainPID", "0"), "substate": row.get("SubState", "")}
+
+
+def reset_failed(profile: Profile) -> None:
+    """Let one explicit CLI start recover without changing automatic retry limits."""
+    _run("reset-failed", _unit_name(profile))
+
+
+def _runtime_user() -> str:
+    name = os.environ.get("SUDO_USER")
+    if not name or name == "root":
+        raise NodeError("runtime_user", "sudo must preserve the trusted deployment administrator")
+    account = pwd.getpwnam(name)
+    if account.pw_uid == 0 or not name.replace("-", "").replace("_", "").isalnum():
+        raise NodeError("runtime_user", "invalid runtime administrator")
+    return name
+
+
+def _unit_text(root: Path, profile: Profile) -> bytes:
+    user = _runtime_user()
+    directory = profile_dir(root, profile.portal_id)
+    python = str(Path(sys.executable).absolute())
+    command = "%s -m cryptnode.host --portal-id %d --install-dir %s" % (
+        _quote(python), profile.portal_id, _quote(str(root)))
+    lines = [
+        "[Unit]", "Description=CryptNode portal %d" % profile.portal_id,
+        "Wants=network-online.target", "After=network-online.target",
+        "StartLimitIntervalSec=600", "StartLimitBurst=3", "",
+        "[Service]", "Type=simple", "User=%s" % user,
+        "WorkingDirectory=%s" % _working_directory(str(directory)), "UMask=0077",
+        "ExecStartPre=%s --validate" % command, "ExecStart=%s" % command,
+        "Restart=on-failure", "RestartSec=30s", "KillMode=control-group", "TimeoutStopSec=20s",
+        "NoNewPrivileges=true", "ProtectSystem=strict", "ReadWritePaths=%s" % _quote(str(directory)),
+        "", "[Install]", "WantedBy=multi-user.target", "",
+    ]
+    return "\n".join(lines).encode("utf-8")
+
+
+def install(root: Path, profile: Profile) -> None:
+    path = UNIT_DIR / _unit_name(profile)
+    if path.is_symlink():
+        raise NodeError("systemd_unit", "systemd unit path is a symbolic link")
+    descriptor, temporary = tempfile.mkstemp(prefix=".cryptnode-", dir=str(UNIT_DIR))
+    try:
+        with os.fdopen(descriptor, "wb") as stream:
+            stream.write(_unit_text(root, profile))
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.chmod(temporary, 0o644)
+        os.replace(temporary, path)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+    _run("daemon-reload")
+    _run("enable", _unit_name(profile))
+    if status(profile)["enabled"] != "true":
+        raise NodeError("systemd_readback", "systemd did not enable the portal instance")
+
+
+def perform(root: Path, profile: Profile, action: str) -> Dict[str, str]:
+    if action not in ("start", "stop", "restart", "enable", "disable"):
+        raise ValueError("invalid systemd action")
+    before = status(profile)
+    if before["exists"] != "true":
+        raise NodeError("unit_missing", "CryptNode systemd instance is missing")
+    directory = profile_dir(root, profile.portal_id)
+    if action in ("start", "restart"):
+        (directory / "stop-request").unlink(missing_ok=True)
+    _run(action, _unit_name(profile))
+    expected = "enabled" if action in ("enable", "disable") else "active"
+    wanted = "false" if action in ("stop", "disable") else "true"
+    for _ in range(40):
+        result = status(profile)
+        if result[expected] == wanted:
+            return result
+        time.sleep(0.25)
+    raise NodeError("systemd_readback", "systemd state did not reach the requested value")
+
+
+def remove(root: Path, profile: Profile) -> None:
+    name = _unit_name(profile)
+    if status(profile)["exists"] == "true":
+        perform(root, profile, "stop")
+        perform(root, profile, "disable")
+    path = UNIT_DIR / name
+    if path.is_symlink():
+        raise NodeError("systemd_unit", "systemd unit path is a symbolic link")
+    path.unlink(missing_ok=True)
+    _run("daemon-reload")
+    if status(profile)["exists"] != "false":
+        raise NodeError("systemd_readback", "systemd instance remains registered")

cryptnode/windows.py

@@ -0,0 +1,313 @@
+"""Protected, single-instance Task Scheduler registration for one portal."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import time
+from typing import Dict, Optional, Sequence
+from xml.etree import ElementTree
+from xml.sax.saxutils import escape
+
+from .models import NodeError, Profile
+from .paths import profile_dir, read_profile
+from .security import atomic_write
+
+
+_NS = "http://schemas.microsoft.com/windows/2004/02/mit/task"
+_LOCAL_RESTART_DELAYS = (30.0, 60.0, 120.0)
+
+
+def _name(profile: Profile) -> str:
+    return "\\CryptNode\\portal-%d" % profile.portal_id
+
+
+def _run(*arguments: str, allow_failure: bool = False) -> subprocess.CompletedProcess:
+    result = subprocess.run(["schtasks.exe", *arguments], capture_output=True, text=True,
+                            timeout=30, check=False, creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0))
+    if result.returncode != 0 and not allow_failure:
+        raise NodeError("task_failed", "Task Scheduler operation failed")
+    return result
+
+
+def _task_xml(root: Path, profile: Profile) -> bytes:
+    python = Path(sys.executable).absolute()
+    arguments = subprocess.list2cmdline(["-m", "cryptnode.windows", "--portal-id",
+                                         str(profile.portal_id), "--install-dir", str(root)])
+    command = escape(str(python))
+    args = escape(arguments)
+    description = escape("CryptNode portal %d (%s)" % (profile.portal_id, profile.portal_name))
+    document = '''<Task version="1.4" xmlns="%s">
+  <RegistrationInfo><Description>%s</Description></RegistrationInfo>
+  <Triggers><BootTrigger><Enabled>true</Enabled><Delay>PT45S</Delay></BootTrigger></Triggers>
+  <Principals><Principal id="CryptNode"><UserId>S-1-5-18</UserId>
+    <RunLevel>HighestAvailable</RunLevel>
+  </Principal></Principals>
+  <Settings><MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate><StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings><StopOnIdleEnd>false</StopOnIdleEnd><RestartOnIdle>false</RestartOnIdle></IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand><RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure><Interval>PT2M</Interval><Count>3</Count></RestartOnFailure>
+    <Enabled>true</Enabled>
+  </Settings>
+  <Actions Context="CryptNode"><Exec><Command>%s</Command><Arguments>%s</Arguments></Exec></Actions>
+</Task>
+''' % (_NS, description, command, args)
+    return document.encode("utf-8")
+
+
+def _query_xml(profile: Profile) -> str:
+    result = _run("/query", "/tn", _name(profile), "/xml", allow_failure=True)
+    if result.returncode != 0:
+        return ""
+    return result.stdout
+
+
+def _verify_definition(root: Path, profile: Profile) -> bool:
+    raw = _query_xml(profile)
+    if not raw:
+        return False
+    try:
+        tree = ElementTree.fromstring(raw)
+        ns = {"t": _NS}
+        get = lambda path: tree.findtext(path, namespaces=ns)
+        wanted = ElementTree.fromstring(_task_xml(root, profile))
+        wanted_get = lambda path: wanted.findtext(path, namespaces=ns)
+        fields = ("t:RegistrationInfo/t:Description", "t:Principals/t:Principal/t:UserId",
+                  "t:Principals/t:Principal/t:LogonType", "t:Principals/t:Principal/t:RunLevel",
+                  "t:Triggers/t:BootTrigger/t:Enabled", "t:Triggers/t:BootTrigger/t:Delay",
+                  "t:Settings/t:MultipleInstancesPolicy",
+                  "t:Settings/t:DisallowStartIfOnBatteries",
+                  "t:Settings/t:StopIfGoingOnBatteries", "t:Settings/t:AllowHardTerminate",
+                  "t:Settings/t:StartWhenAvailable", "t:Settings/t:RunOnlyIfNetworkAvailable",
+                  "t:Settings/t:IdleSettings/t:StopOnIdleEnd",
+                  "t:Settings/t:IdleSettings/t:RestartOnIdle",
+                  "t:Settings/t:AllowStartOnDemand", "t:Settings/t:RunOnlyIfIdle",
+                  "t:Settings/t:ExecutionTimeLimit", "t:Settings/t:Enabled",
+                  "t:Settings/t:RestartOnFailure/t:Interval",
+                  "t:Settings/t:RestartOnFailure/t:Count",
+                  "t:Actions/t:Exec/t:Command", "t:Actions/t:Exec/t:Arguments")
+        omitted_defaults = {
+            "t:Triggers/t:BootTrigger/t:Enabled": "true",
+            "t:Settings/t:AllowHardTerminate": "true",
+            "t:Settings/t:RunOnlyIfNetworkAvailable": "false",
+            "t:Settings/t:IdleSettings/t:RestartOnIdle": "false",
+            "t:Settings/t:AllowStartOnDemand": "true",
+            "t:Settings/t:RunOnlyIfIdle": "false",
+            "t:Settings/t:Enabled": "true",
+        }
+        for field in fields:
+            actual = get(field)
+            if actual is None:
+                actual = omitted_defaults.get(field)
+            if actual != wanted_get(field):
+                return False
+        return True
+    except ElementTree.ParseError:
+        return False
+
+
+def _query_state(profile: Profile) -> Dict[str, str]:
+    name = "portal-%d" % profile.portal_id
+    script = r'''$ErrorActionPreference = 'Stop'
+try {
+  $service = New-Object -ComObject Schedule.Service
+  $service.Connect()
+  $task = $service.GetFolder('\CryptNode').GetTask('%s')
+  [pscustomobject]@{query='ok'; state=[int]$task.State; enabled=[bool]$task.Enabled} |
+    ConvertTo-Json -Compress
+} catch {
+  $exception = $_.Exception
+  while ($null -ne $exception.InnerException) { $exception = $exception.InnerException }
+  [long]$hresult = $exception.HResult
+  if ($hresult -lt 0) { $hresult += 4294967296 }
+  $query = switch ($hresult) {
+    2147942402 { 'missing'; break }
+    2147942403 { 'missing'; break }
+    2147942405 { 'access_limited'; break }
+    default { 'unknown' }
+  }
+  [pscustomobject]@{query=$query; hresult=$hresult} | ConvertTo-Json -Compress
+}''' % name
+    result = subprocess.run(["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", script],
+                            capture_output=True, text=True, timeout=30, check=False, creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0))
+    if result.returncode != 0:
+        raise NodeError("task_readback", "Task Scheduler state could not be read")
+    try:
+        value = json.loads(result.stdout)
+        query = value["query"]
+        if query == "missing":
+            return {"exists": "false", "active": "false", "enabled": "false"}
+        if query == "access_limited":
+            return {"exists": "access_limited", "active": "access_limited",
+                    "enabled": "access_limited", "state": "AccessLimited"}
+        if query == "unknown":
+            return {"exists": "unknown", "active": "unknown",
+                    "enabled": "unknown", "state": "Unknown"}
+        states = ("Unknown", "Disabled", "Queued", "Ready", "Running")
+        state = value["state"]
+        enabled = value["enabled"]
+        if (query != "ok" or type(state) is not int or not 0 <= state < len(states)
+                or type(enabled) is not bool):
+            raise ValueError("task state")
+        return {"exists": "true", "active": str(state == 4).lower(),
+                "enabled": str(enabled).lower(), "state": states[state]}
+    except (KeyError, TypeError, ValueError):
+        raise NodeError("task_readback", "Task Scheduler returned invalid state") from None
+
+
+def _start_host(root: Path, profile: Profile) -> subprocess.Popen:
+    command = [sys.executable, "-m", "cryptnode.host", "--portal-id",
+               str(profile.portal_id), "--install-dir", str(root)]
+    flags = (getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
+             | getattr(subprocess, "CREATE_NO_WINDOW", 0))
+    try:
+        process = subprocess.Popen(command, stdin=subprocess.DEVNULL,
+                                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                                   creationflags=flags, close_fds=True)
+        try:
+            from .processes import _assign_kill_on_close
+            _assign_kill_on_close(process)
+        except NodeError:
+            process.kill()
+            process.wait(timeout=3)
+            raise
+        return process
+    except OSError as exc:
+        raise NodeError("host_start", "CryptNode Host process could not be started") from exc
+
+
+def _record_controller(directory: Path, profile: Profile, state: str,
+                       error: str, attempt: int, restart_limit: int,
+                       restart_delay_seconds: Optional[float]) -> None:
+    payload = {"portal_id": profile.portal_id, "node_id": profile.node_id,
+               "state": state, "error": error, "log_warning": False,
+               "portal_configured": None, "portal_enabled": None,
+               "control_pid": None, "data_pid": None, "core_pid": None,
+               "restart_attempt": attempt, "restart_limit": restart_limit,
+               "restart_delay_seconds": restart_delay_seconds,
+               "checked_at": int(time.time())}
+    try:
+        atomic_write(directory / "runtime.json",
+                     (json.dumps(payload, sort_keys=True, separators=(",", ":")) + "\n").encode("utf-8"),
+                     public_read=True, parent_public_read=True)
+    except (OSError, NodeError):
+        pass
+
+
+def _run_controller(root: Path, profile: Profile, *,
+                    restart_delays: Sequence[float] = _LOCAL_RESTART_DELAYS) -> int:
+    directory = profile_dir(root, profile.portal_id)
+    stop_request = directory / "stop-request"
+    failures = 0
+    while not stop_request.exists():
+        try:
+            result = _start_host(root, profile).wait()
+        except NodeError:
+            result = 78
+        if result == 0 or stop_request.exists():
+            return 0
+        failures += 1
+        if failures > len(restart_delays):
+            _record_controller(directory, profile, "failed",
+                               "host restart limit exhausted after exit %d" % result,
+                               failures, len(restart_delays), None)
+            return 78
+        delay = float(restart_delays[failures - 1])
+        _record_controller(directory, profile, "recovering",
+                           "Host exited with %d" % result, failures,
+                           len(restart_delays), delay)
+        deadline = time.monotonic() + delay
+        while not stop_request.exists() and time.monotonic() < deadline:
+            time.sleep(min(0.25, max(0.0, deadline - time.monotonic())))
+    return 0
+
+
+def status(profile: Profile) -> Dict[str, str]:
+    return _query_state(profile)
+
+
+def install(root: Path, profile: Profile) -> None:
+    directory = profile_dir(root, profile.portal_id)
+    with tempfile.NamedTemporaryFile(prefix=".cryptnode-task-", suffix=".xml", dir=str(directory),
+                                     delete=False) as stream:
+        path = Path(stream.name)
+        stream.write(_task_xml(root, profile))
+    try:
+        _run("/create", "/tn", _name(profile), "/xml", str(path), "/f")
+    finally:
+        path.unlink(missing_ok=True)
+    if not _verify_definition(root, profile):
+        raise NodeError("task_readback", "Task Scheduler definition differs from CryptNode policy")
+
+
+def perform(root: Path, profile: Profile, action: str) -> Dict[str, str]:
+    if action not in ("start", "stop", "restart", "enable", "disable"):
+        raise ValueError("invalid task action")
+    current = status(profile)
+    if current["exists"] == "false":
+        raise NodeError("task_missing", "CryptNode scheduled task is missing")
+    if current["exists"] != "true":
+        raise NodeError("task_readback", "CryptNode scheduled task state is unavailable")
+    directory = profile_dir(root, profile.portal_id)
+    if action in ("stop", "restart"):
+        atomic_write(directory / "stop-request", b"stop\n", parent_public_read=True)
+        for _ in range(60):
+            if status(profile)["active"] == "false":
+                break
+            time.sleep(0.25)
+        if status(profile)["active"] == "true":
+            _run("/end", "/tn", _name(profile))
+    if action in ("start", "restart"):
+        (directory / "stop-request").unlink(missing_ok=True)
+        _run("/run", "/tn", _name(profile))
+    if action in ("enable", "disable"):
+        _run("/change", "/tn", _name(profile), "/%s" % action)
+    expected = "enabled" if action in ("enable", "disable") else "active"
+    wanted = "false" if action in ("stop", "disable") else "true"
+    for _ in range(80):
+        result = status(profile)
+        if result[expected] == wanted:
+            if action == "stop":
+                (directory / "stop-request").unlink(missing_ok=True)
+            return result
+        time.sleep(0.25)
+    raise NodeError("task_readback", "scheduled task did not reach the requested state")
+
+
+def remove(root: Path, profile: Profile) -> None:
+    current = status(profile)
+    if current["exists"] == "false":
+        return
+    if current["exists"] != "true":
+        raise NodeError("task_readback", "CryptNode scheduled task state is unavailable")
+    perform(root, profile, "stop")
+    _run("/delete", "/tn", _name(profile), "/f")
+    if status(profile)["exists"] != "false":
+        raise NodeError("task_readback", "scheduled task remains registered")
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(prog="crnode-windows-controller")
+    parser.add_argument("--portal-id", type=int, required=True)
+    parser.add_argument("--install-dir", type=Path, required=True)
+    args = parser.parse_args(argv)
+    try:
+        directory = profile_dir(args.install_dir, args.portal_id)
+        profile = read_profile(directory)
+        return _run_controller(args.install_dir, profile)
+    except (OSError, NodeError, ValueError) as exc:
+        print("crnode-windows-controller: %s" % exc, file=sys.stderr)
+        return 78
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cryptnode-0.1.1.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.3
+Name: cryptnode
+Version: 0.1.1
+Summary: Managed multi-portal CryptNode client
+Requires-Python: >=3.8
+Requires-Dist: cryptography==43.0.3
+Requires-Dist: tomli==2.2.1; python_version < '3.11'
+License-File: THIRD-PARTY.md
+Description-Content-Type: text/markdown
+
+# CryptNode 0.1.1
+
+Managed multi-portal client for CryptPortal, with private FRP and stunnel executables.
+
+## Supported platforms
+
+* Windows x86-64 with a trusted machine-level Python 3.8 or newer.
+* Linux x86-64 with glibc 2.31 or newer and systemd; use a trusted virtual environment owned by the deployment user.
+* Other architectures and macOS are not supported by these wheels.
+
+## Install
+
+Linux, inside the intended virtual environment:
+
+```sh
+python -m pip install cryptnode==0.1.1
+python -m cryptnode --version
+```
+
+Windows, from an administrator terminal using the intended machine-level Python:
+
+```powershell
+python -s -m pip install --no-user cryptnode==0.1.1
+python -s -m pip check
+python -s -c "import cryptnode.host"
+python -m cryptnode --version
+```
+
+Windows SYSTEM scheduled tasks must be able to read and execute that Python installation, CryptNode and its complete dependency set. User AppData installations are unsuitable. Using `-s` prevents pip from treating dependencies installed only in the interactive user's site-packages as satisfied. The Python environment and package files must not be writable by untrusted users. A successful import is a prerequisite, not an end-to-end scheduled-task test.
+
+Dependencies: cryptography==43.0.3; Python versions below 3.11 also require tomli==2.2.1. pip installs their declared dependencies automatically.
+
+## Deploy and connect
+
+```text
+crnode deploy <absolute-runtime-directory>
+crnode load <two-digit-node-id> <client-key-bundle.zip>
+crnode list
+crnode status <portal-name-or-id> --json
+```
+
+On Windows, `load` and commands that modify SYSTEM tasks require an administrator terminal. Linux commands request sudo as needed while retaining the selected virtual environment. Obtain a matching client bundle from your CryptPortal administrator; credentials and server configuration are not included in this distribution. Protect client bundles and private keys.
+
+## Changes and validation limits
+
+0.1.1 adds Linux sudo/virtual-environment usability improvements, prompt idempotent start for already-running instances, concise Ctrl+C handling and a five-column Chinese list display. Initial load and runtime public TLS connections use private stunnel with CA/hostname checks, mutual TLS and per-handshake server-leaf certificate pin verification.
+
+The accepted candidate reports 107 passed/11 skipped on Windows, 99 passed/19 skipped on Linux, 20 private mTLS tests and 32 handshake combinations across Ubuntu 20.04/22.04/24.04/26.04. These results do not imply all deployment scenarios passed. A Windows deployment failed when SYSTEM could not import a user-installed package, and subsequently when a globally installed package still depended on user-only cryptography. Successful retesting of that machine remains unconfirmed. Host stderr retention and clearer startup diagnostics remain improvement items.
+
+This release packaging preserves every accepted CryptNode Python file and executable byte. It adds distribution materials and documentation; no runtime fix is claimed by the repackaging.
+
+## Third-party source and licenses
+
+Each slim wheel contains the runtime binaries and licensing notices. The same PyPI release provides complete corresponding stunnel and OpenSSL source, the exact patch and build scripts in `cryptnode-0.1.1.tar.gz`. Full licenses and notices are under `cryptnode-0.1.1.dist-info/licenses/`.
+
+Apply the supplied patch to the supplied stunnel source using the supplied platform build script. The patch changes Profile working-directory handling on Windows and adds per-handshake leaf-certificate pin checks; these modifications are identified in the patch and build matrix. The same archive contains all corresponding OpenSSL source statically linked into the private TLS executable. Neither archive contains deployment credentials.
+
+FRP is Apache-2.0; stunnel is GPL-2.0-or-later with its upstream OpenSSL linking exception; OpenSSL is Apache-2.0. These notices describe the respective third-party components, not a new license grant for unrelated CryptNode code. Windows compiler-runtime copyright notices and exceptions are included separately.

cryptnode-0.1.1.dist-info/RECORD

@@ -0,0 +1,35 @@
+cryptnode-0.1.1.dist-info/METADATA,sha256=vg2HgotLk4qi0fzxGQqQYGYjdlT9pU7rjk761y2AcY0,4422
+cryptnode-0.1.1.dist-info/WHEEL,sha256=oagoGCm1jfYdYiHmRrWRiR009qvdh5sIXM17bPumCjo,104
+cryptnode-0.1.1.dist-info/entry_points.txt,sha256=lIKyPHyI-OUmZPp3BCXgHjjMYp0B8WUdjR0xHW3HXao,80
+cryptnode-0.1.1.dist-info/licenses/BUILD-MATRIX.toml,sha256=0PhdrJU1fvi_-ZEKKH6ZZ8e2STXoLKV7nr57NOSHWnk,1589
+cryptnode-0.1.1.dist-info/licenses/FRP-LICENSE,sha256=xllut76FgcGL5zbIRvuRc7aezPbvlMUTWJPsVr2Sugg,11358
+cryptnode-0.1.1.dist-info/licenses/GCC-RUNTIME-COPYRIGHT,sha256=pIH3cvelMzXxOzLGxU6xyFd86XcE7dN1erftQoeo6Wo,75729
+cryptnode-0.1.1.dist-info/licenses/OPENSSL-LICENSE,sha256=fVRQyy0UJlG4r6MVtfI478gF2tgn2RujZ9hRa8nUnno,10175
+cryptnode-0.1.1.dist-info/licenses/SOURCE-AVAILABILITY.md,sha256=AZsN3VnKytEANRdORiE5mlnRxm5ZaU-yC86RSAHDKj4,409
+cryptnode-0.1.1.dist-info/licenses/STUNNEL-GPL-2.0.md,sha256=YvFx1Ni2cm32Hximu8CnD3nEvCE02DfTXIH8Yomi2E0,17941
+cryptnode-0.1.1.dist-info/licenses/STUNNEL-LICENSE,sha256=cW8YsQ6sPxh16iIFQY3RsAhL0hC9F9YV32sYDPxNZbY,1768
+cryptnode-0.1.1.dist-info/licenses/STUNNEL-PATCH,sha256=gcmW66rfV5gH3ZndSenfWDOLcnCp_CBLD5jQH4kBG8o,1546
+cryptnode-0.1.1.dist-info/licenses/THIRD-PARTY.md,sha256=Gyw4jeSuMXnqECgCvPxbXHO2dAT-y56d9OzYuzuwD-4,1896
+cryptnode/__init__.py,sha256=6DSmb43Crde3wR83wVsWr5SLZ0Kp7yCW94hL-8yDuv0,69
+cryptnode/__main__.py,sha256=dvqRbpPgrhpsG7UdzAvPKJwBTp92CkcWX4qEQBzPQdc,49
+cryptnode/bundles.py,sha256=lmuUbW89Q6xRk90wm7AipUataaWC9psfYDeW4-QC9K0,4932
+cryptnode/certificates.py,sha256=xvhB93dr5obxJbBx0q2nh5GrtoGUCdRusHnuKshfGmo,5206
+cryptnode/cli.py,sha256=NMAM0BdbXxOH3xj__dqUKre4prXcG8y4p92iXmt2ROk,18364
+cryptnode/config.py,sha256=1lBRlLs3jcnryfYmMvCvJaFn8GEA-T8e6xfAQa1wxGg,3445
+cryptnode/control.py,sha256=g6vRkkZN2aXAxkTozOIULTLq7sDnS6cDD65b6rXmibA,2590
+cryptnode/diagnostics.py,sha256=3zu0SXYDRN0z8QanA2OyqKo3pj3HzuKRxqpPPN3eVsM,2414
+cryptnode/frp.py,sha256=DHHzEzSfYJ1Nvy0uil4QT8JiriCaFV355SAIv8MwWc4,614
+cryptnode/host.py,sha256=oApmxq4p_sD1e_LTiS4BiTs7AsAKRHLX3TraK-n1COM,8684
+cryptnode/lifecycle.py,sha256=xDMSrVZNlBNW_iuEGL8oM5qkDKS1N9YjwPgstNu2KFQ,13608
+cryptnode/logs.py,sha256=XmI-vQaMWRFzmLbhMDDu0sm7SOS0xNR4KAuTlFx_pQc,1476
+cryptnode/models.py,sha256=mynX4Cji0cpoKbAehvUHt_PBUk0nl7yVV8pgUhTroBk,1039
+cryptnode/paths.py,sha256=-gbWRKhT-V8tlxUsL2TyAF8YLwo4mvl5bng4F12MjhU,5603
+cryptnode/processes.py,sha256=ZD_7xea8XUqdXgriKGBY6Dhxr2_9T7kTepT-_e7SZfw,7825
+cryptnode/resources/__init__.py,sha256=LT1ggKn2owUOABFwH9LDCj0x8MDJ7MMCjechP89lSJs,80
+cryptnode/resources/windows/crnode-core.exe,sha256=ycWfm7mVYUBbgdaPaIOErsSTad8QSJBEMVKSsOqslXo,16708608
+cryptnode/resources/windows/crnode-tls.exe,sha256=bqRqNB6R8SbLbc-qm8UkLgcSVTuJr4jDJ1bSf3a9tSQ,4894888
+cryptnode/security.py,sha256=kCB1NmpTdK8YyHCtDVpvl1BzlR7Itw7C-Heg2FJTWCk,5487
+cryptnode/tls.py,sha256=XOKZXLJr8zLmQCfB4mKSKhe-4Wj-vRkBYQ6NlwtEC3M,2260
+cryptnode/ubuntu.py,sha256=JUaseLP_7VjAtoUESAvKkNKGFI2V8QUawDMxSIMjYW4,5941
+cryptnode/windows.py,sha256=E9AzL_kkR8PmqLU44HBXk7W6_N-80SfPsG-WgnG0SPU,14391
+cryptnode-0.1.1.dist-info/RECORD,,

cryptnode-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: cryptnode-builder
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+Build: 1

cryptnode-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+crnode = cryptnode.cli:main
+crnode-host = cryptnode.host:main

cryptnode-0.1.1.dist-info/licenses/BUILD-MATRIX.toml

@@ -0,0 +1,29 @@
+schema = "cryptnode.build-matrix/v1"
+version = "0.1.1"
+source_date_epoch = 1789732800
+frp_version = "0.71.0"
+stunnel_version = "5.80"
+openssl_version = "3.5.8"
+frp_linux_archive_sha256 = "84f27e39f11169f7adcef8e8b70c9329de17747b1f14dad9fb95eef5682ea716"
+frp_windows_archive_sha256 = "9e5062e3e5cf07e67144a3a4acf175ef6a2486f3605dd6cf288bae34ab39819f"
+stunnel_source_sha256 = "6d0841d48de07cbbaf4a055919065bf7bb5ebc63cc15c97a2c76caa2bf285513"
+openssl_source_sha256 = "a8f84a39918ec6415ce765d9b429d313ba97b8143169c172e734b9514464f5b2"
+stunnel_windows_ssl_c_upstream_sha256 = "9fa3c5fd18a4f27714ba04efdf8cf3fb6f7e0612b572caeb4b17421dfe597b4d"
+stunnel_windows_ssl_c_patched_sha256 = "b43a41da5f2b8c4db4ff10d75a8fc8e75f636327dd0358891f3a4f88abde2c90"
+
+stunnel_windows_verify_c_upstream_sha256 = "e30f7209730733d04d00d2c033f17637153e632578d99225c5ee103782f0c811"
+stunnel_windows_verify_c_patched_sha256 = "affeee67a08f9e76d29d7adaf6520da1fc7bb1a81240ee468f316fec6da74978"
+
+[linux]
+build_candidate = true
+wheel_tag = "py3-none-manylinux_2_31_x86_64"
+build_baseline = "Ubuntu 20.04 / glibc 2.31"
+openssl = "3.5.8 private static link; no provider module"
+stunnel_binary_sha256 = "d6ea6f98996ffcebdaddeb245becf275b3dc5d86889706f112d91742c103f7fa"
+
+[windows]
+wheel_tag = "py3-none-win_amd64"
+kernel_source = "official stunnel 5.80 source with guarded Windows cwd and per-handshake DER leaf SHA256 pin patch"
+openssl = "3.5.8 private static link; no provider module"
+runtime_dlls = []
+stunnel_binary_sha256 = "6ea46a341e91f126cb6dcfaa9bc5242e0712553b89af88c32756d27f76bdb524"