As of November 2026: CardinalHost (currently pre-launch and documented at cardinalhost.org) develops native clients for macOS (Swift/SwiftUI) and Linux (GTK 4/libadwaita) alongside shared protocol specifications (cardinal-contracts 1.0.0). Six canonical JSON contracts, 278 conformance vectors across 13 sections and 53 documented source mutations surface divergences reproducibly (currently 245 passing checks, 33 open failures and 11 documented discrepancies), paired with AES-256-GCM configuration encryption and LAN-tested ChaCha20-Poly1305 sync channels.
Why Cross-OS Native Systems Tools Must Guard Against Protocol Drift
Many cross-platform infrastructure tools bundle a full browser runtime such as Electron so they only have to maintain one user interface. Across the Cardinal family—alongside CardinalMail and CardinalOS—we deliberately avoid embedding a browser engine: without claiming comparative RAM or latency benchmarks against third-party runtimes, building native clients lets each platform integrate directly with its operating system’s UI toolkit and credential APIs.
Maintaining two native implementations in different languages, however, introduces a classic systems risk: subtle wire-protocol drift. When a Swift client on macOS exchanges frames, geometry updates, consent tokens or encrypted sync payloads with a Python and GTK 4 client on Linux, even a minor discrepancy in integer framing, HiDPI coordinate scaling, AEAD nonce layout or token expiry handling can trigger silent bugs or security weaknesses. Prose wiki specifications inevitably lag behind code changes. In our engineering work on CardinalHost within our projects research section, protocol specifications are therefore machine-readable, manifest-sealed and executed incrementally against real modules—with explicit tracking of unfinished adapters and open discrepancies.
Two Native Clients Built Around Platform Security Primitives
Before two endpoints exchange packets, each client uses the native security mechanisms of its host operating system directly rather than inventing custom credential stores:
- macOS Client (Swift & SwiftUI): Built natively on Apple’s
CryptoKitand macOS Keychain, combining remote desktop control with SFTP, SMB, NFS and WebDAV filesystem mounts, two-leg server-to-server transfers viarsyncthrough an isolated temporary local buffer, and a multi-host 2 / 4 / 8 live console closed in code and automated tests (with field validation in progress). - Linux Client (GTK 4 & libadwaita): Designed natively for modern GNOME desktops, storing credentials in GNOME Keyring via
libsecretand mounting remote filesystems viaGVfsandsshfs. Hardened local store, indexer and trash routines anchor file operations on open directory file descriptors (dir_fd) withO_NOFOLLOWto defend those paths against symlink TOCTOU substitution. - Signed Update Verification and Redacted Opt-In Telemetry: On Linux, the update checker reads the outer JSON wrapper (capped at 256 KiB) to extract the raw signed payload string and validates its Ed25519 signature before parsing the inner release JSON or trusting version strings and package URLs. Optional crash reporting is strictly opt-in, redacts local file paths and usernames prior to serialisation, and is tested against a local mock receiver.
Descriptor-Anchored Local Paths and Transparent Server-to-Server Staging
Two file-handling paths show how CardinalHost pairs local OS primitives with explicit transparency about current trade-offs. When local management routines on Linux operate inside directories where entries could be swapped for symbolic links, purely string-based checks leave a classic time-of-check-to-time-of-use (TOCTOU) window between path validation and file opening.
In the hardened local modules of the Linux client (store.py, indicizzatore.py, cestino.py), file operations are anchored on open directory file descriptors (dir_fd) with O_NOFOLLOW so the kernel aborts if the target entry is a symlink. On macOS, server-to-server transfer (enqueueServerToServer / runServerToServer) automates copying between two remote hosts across two sequential resumable rsync legs: it sanitises the remote filename to a single component (componenteFileContenuto against ../ traversal), downloads into an isolated temporary folder under temporaryDirectory (ServerMountApp-xfer-<UUID>), uploads to the destination host and performs best-effort cleanup. Exactly as stated in the macOS UI footer, items pass through the Mac as a temporary staging buffer—we claim neither diskless in-memory streaming nor unmeasured speed gains.
Why Cryptographic Signature Ordering Matters in Software Updates and Telemetry
Update pipelines and crash reporters fail when inner metadata is trusted before authentication. In aggiornamenti.py, the Linux client extracts only the raw contenuto string and signature from the size-capped outer JSON wrapper, verifies the Ed25519 signature over the exact UTF-8 bytes against the pinned public key, and parses the inner JSON—expiry timestamp, platform entry and version string—strictly after signature verification succeeds. Likewise, rather than assuming regular-expression redaction works by inspection, our test suite sends synthetic crash traces containing canary usernames and home paths into a local mock telemetry receiver that fails the test run if an unredacted token survives serialisation.
cardinal-contracts 1.0.0: Six Declarative Specifications and Explicit Parity Accounting
Cross-platform wire discipline is anchored in cardinal-contracts (version 1.0.0) in the Cardinal infrastructure repository. Rather than duplicating protocol rules in Swift and Python comments, six canonical declarative JSON specifications (packaged inside 36 SHA-256-sealed files) define reference wire semantics:
| Contract Specification | Governed Wire Domain | Targeted Drift Risks & Scope |
|---|---|---|
control-input |
Keycode mapping, modifier state bitmasks, pointer motion and scroll axes | Key/pointer parsing across AST-isolated Linux input receivers (Python client emission still separate) |
capture-geometry |
Monitor bounds, HiDPI scale factors, crop regions and pointer coordinate projection | Coordinate rounding and boundary limits across HiDPI and multi-monitor layouts |
consent-r7 |
Consent token lifecycle, validity windows, renewal rules and immediate revocation | Wire responses of isolated R7 emitters (grant reads and RDP teardown simulated in the runner) |
session-handshake |
Protocol version negotiation, capability bitfields and deterministic view-only fallback | Stream-opening bounds and SSH line-parser grammar |
h264-sei |
Binary layout of embedded H.264 user_data_unregistered SEI signalling payloads |
Annex-B splitting and SEI framing (including 19 shared smoke vectors compiled against Swift H264Stream) |
sync-crypto |
Key derivation parameters, nonce construction, version headers and AEAD tag checks | KDF parameters, nonce layout and ciphertext rejection in the Python client module |
Before running conformance suites, package_integrity.py validates a SHA-256 manifest covering all 36 package files so corrupted checkouts or unsealed edits fail immediately. The Python harness defines 278 conformance vectors across 13 sections alongside a catalogue of 53 documented source mutations designed to perturb bounds and validation branches in temporary copies.
Equally important is the explicit coverage and parity ledger recorded in coverage.json and discrepancies.json: the package openly declares complete_parity = false and tracks 11 open discrepancies (D01–D11, covering relative motion mr, coordinate rounding, scroll conversion, screen indices >= 64, unknown audio SEI states and SSH stream quoting) slated for reconciliation. While python-client (crypto and H.264/SEI), AST-extracted Linux agent pure functions and input receivers, and a standalone macOS H264Stream smoke test are executable today, Python client input/handshake emission is marked not-implemented and full Swift XCTest integration is marked prepared-not-integrated. Running the full 13-section harness against the current infrastructure checkout executes all 278 vectors and reports 245 passing checks and 33 failures (24 NameError and 9 ValueError across the AGENTE sections and D11): these show that the AST isolation of the evolved agent requires updating, without by themselves proving a change in the wire protocol.
Encrypted Synchronisation: What Stands Today and What Remains Under Construction
Engineers moving between desktop workstations and laptops need reliable state synchronisation without surrendering server inventories to third-party cloud databases. CardinalHost separates this problem into two distinct cryptographic layers:
- Client-Side Configuration Synchronisation (
SMv1Envelope): Host profiles and connection settings are encrypted locally before leaving the client. After explicitly checking theSMv1version prefix, CardinalHost derives symmetric keys from the user secret via PBKDF2-HMAC-SHA256 with 600,000 iterations and per-envelope salt, protecting payloads with authenticated AES-256-GCM encryption. Plaintext host lists or passphrases never leave the endpoint, and ciphertext tampering fails GCM tag verification. - Direct Peer-to-Peer Folder Sync Channel: For direct device-to-device file synchronisation without intermediary cloud storage, CardinalHost reached its encrypted channel milestone (Sync 1.0) on 1 September 2026: a mutual-authentication handshake paired with a ChaCha20-Poly1305 encrypted data channel, tested and verified across a live Mac↔Linux LAN.
Explicit Maturity Boundary: Proving a mutually authenticated ChaCha20-Poly1305 channel across macOS and Linux on a real LAN establishes the cryptographic transport foundation—not finished continuous folder sync. Continuous filesystem watching, conflict resolution under concurrent edits and multi-session bidirectional convergence remain under active construction, and we intentionally make no claim of parity with mature sync engines such as Syncthing.
What Our August 2026 Adversarial Audit Found and Fixed (~238 Defects)
Applied systems research also means reviewing one’s own code systematically for weaknesses before entrusting live infrastructure to it. The engineering timeline on cardinalhost.org records an internal adversarial audit in August 2026 reporting around 238 confirmed defects closed in code—explicitly stated as internal evidence for the reviewed scope rather than independent product certification.
Across the security and protocol modules documented in this series—including dir_fd/O_NOFOLLOW on local Linux paths, Ed25519 signature verification before JSON parsing in aggiornamenti.py, the AI tool gate (GateAIAgente and StrumentiAIAgente) and senzaACapo in the diagnostic preview, the _percorso_avvio_vietato write guard and PonteAI—targeted regression tests keep those boundaries from regressing during later refactors, whereas the limita output truncator does not yet have a dedicated unit test in ServerMountAppTests. We bring the exact same contract-driven verification mindset to client software platforms—illustrated in our Engineering Note on automated translation and structural verification gates in Django and across our custom Python and Django systems engineering practice.
Conclusion: Verifiable Engineering Instead of Marketing Superlatives
Across all three research and architecture articles, CardinalHost follows one guiding principle: grounding technical statements in named repository modules, documented checks and candid disclosure of unfinished components and open discrepancies—spanning Wayland capture over PipeWire, deterministic command gating, and cross-OS protocol contracts. Follow ongoing pre-launch engineering updates directly at cardinalhost.org and in our CardinalHost research overview on the projects page.
Frequently Asked Questions (FAQ)
Because avoiding an embedded browser runtime lets CardinalHost integrate directly with each operating system’s native UI and security primitives: Swift and SwiftUI with CryptoKit and macOS Keychain on Apple systems, and GTK 4 and libadwaita with GNOME Keyring (libsecret), GVfs/sshfs and dir_fd/O_NOFOLLOW-hardened local file paths on Linux.
Through cardinal-contracts 1.0.0: six declarative JSON specifications (inside 36 SHA-256-manifest-verified files), 278 conformance vectors across 13 sections and 53 documented source mutations test wire formats against real modules. Scope limits are explicit: complete_parity is false, full Swift XCTest integration is prepared-not-integrated, 11 open discrepancies are tracked for reconciliation, and the current run reports 245 passing checks with 33 open failures.
Connection configurations use the versioned SMv1 envelope encrypted client-side before transmission. Keys are derived with PBKDF2-HMAC-SHA256 using 600,000 iterations and random salt, and payloads are encrypted and authenticated with AES-256-GCM.
No. While the mutually authenticated ChaCha20-Poly1305 encrypted sync channel was verified on a real Mac-to-Linux LAN on 1 September 2026, continuous background watching and bidirectional conflict convergence are still under active construction.