Version 1.1 · July 2026. A plain-English account of how Continuo protects your keystrokes, mouse, clipboard, and files. Claims about pairing, identity pinning, and secure connection admission can be checked against the ContinuoSecurityTransport package.
1. Why this document exists
Continuo types on your Macs and moves your cursor. Something with that much reach has to be built so you can check it directly. This paper sets out what Continuo does with your input and your data, what it defends against, and where it stops.
Continuo is commercial proprietary software. It consumes pairing, identity-pinning, and secure connection-admission code in the product. A buildable package containing that code is prepared for publication, together with a staged and tested generic session-crypto implementation. That generic session crypto is not yet the shipped input-encryption implementation. The complete application, motion engine, and Pro capabilities remain closed.
In one sentence: keyboard, mouse, clipboard, and file content move between your own Macs over mutually-authenticated TLS 1.3 on your local network; Continuo sends no telemetry and no input content to an Internet service; every failure path gives control back rather than guessing.
2. Threat model
What Continuo protects against:
- A passive attacker sniffing your Wi-Fi (reading keystrokes/passwords in transit between paired Macs).
- An active man-in-the-middle trying to impersonate one of your Macs during or after pairing.
- A rogue device on your LAN attempting to connect to, or inject input into, your Macs.
- Malicious or malformed file/clipboard payloads sent over the bulk channel.
What is explicitly out of scope:
- A Mac that is already fully compromised at the OS level (Continuo trusts the endpoints it runs on).
- Physical access to an unlocked Mac.
- Traffic patterns on a hostile network. Continuo hides what you send between peers, but not the fact that two Macs are talking.
- Remote control over the internet. Continuo’s peer path is local-network only.
3. Pairing
Devices pair using a commit-reveal Short Authentication String (SAS). Both Macs derive a short human-readable code (a set of words) from a commitment exchanged before any secret is revealed, so a man-in-the-middle cannot substitute its own key without changing the words the user sees. You confirm the words match on both screens; if they don’t, pairing fails closed.
After the first successful pairing each Mac pins the other’s identity. From then on a device presenting a different one is refused, even if it sits on the same network under the right name. Paired Macs live in a list you control: remove one and it cannot connect again.
The pairing, SAS verification, trust storage, identity-pinning, and secure connection-admission logic are the parts of ContinuoSecurityTransport consumed by the product.
4. Transport
Every session begins on one reliable channel secured with mutually-authenticated TLS 1.3, using pinned P-256 identities and forward secrecy. This pinned mutual TLS 1.3 transport is shipped in Continuo. Mutual means both ends prove who they are. Pinned means each end accepts only the exact identity it paired with, rather than any certificate some authority is willing to vouch for. Forward secrecy means a key stolen tomorrow still cannot decrypt traffic captured today.
Input then rides two paths, and both are encrypted:
- Keystrokes, buttons and scroll boundaries are authoritative on that TLS 1.3 channel. A redundant copy of the same frame also goes out as a datagram, so latency becomes whichever arrives first. The datagram is sealed with ChaChaPoly under a separate key set, derived from the same session handshake with a distinct HKDF label, so the two carriers never share key material.
- Pointer motion is a datagram path only. It never enters the reliable channel, because a lost motion frame must be discarded rather than retransmitted behind newer ones. Each frame is sealed with ChaChaPoly under its own per-session, per-direction key.
Both datagram key sets are negotiated inside the pinned TLS 1.3 session, from an ephemeral X25519 secret, so they inherit its forward secrecy and its pinned identities. There is no path on which input leaves your Mac unencrypted.
There is no setting that turns encryption off. Some tools in this category ship one, or shipped plaintext in the past. Continuo has never had one. Anything that can type on your Mac should not have a switch that quietly stops protecting you.
Exactly one Mac holds the input at any moment, and the one you are physically typing on always wins. That stops two machines fighting over the cursor, and it closes off a whole family of injection races. If anything goes wrong or the link drops, Continuo releases control immediately rather than holding on to it.
The package’s generic SessionCrypto target covers key agreement, session-key derivation, authenticated session encryption, and bounded security framing. It remains staged and tested, and is not the shipped input-encryption implementation.
5. The bulk channel
Rich clipboard (images, files) and drag-across-edge file transfer ride a dedicated bulk channel that is isolated from the input path, so a large transfer can never stall or interfere with keystroke/mouse latency. The receiving side treats every incoming payload as untrusted and applies a fail-closed receive gate:
- Confined to one place. Writes are sanitised and kept inside a designated folder. Attempts to escape it are refused.
- Quarantined. Received files land in quarantine. Nothing is placed silently anywhere sensitive.
- Size-capped. Oversized payloads are refused instead of being allowed to exhaust the machine.
- Checked on arrival. Contents are SHA-256 verified, and anything that does not match is discarded.
The bulk parser and receive-gate implementation are proprietary and not part of the security package prepared for publication.
6. What Continuo keeps
- No telemetry. The app does not send analytics or usage data to Continuo.
- No cloud relay for your input. Keyboard, mouse, clipboard, and transferred-file content are not sent to an Internet service. They stay on the authenticated local peer connection between your Macs.
- No account, no sign-in. Identity is a local cryptographic keypair, not a login.
- Keystrokes never touch disk as part of normal operation.
- Redacted logs: diagnostic logs never contain keycodes or keystroke content.
Continuo may contact Internet services for updates, licensing, downloads, and payments. Those connections are documented in the Network manifest. None of them carry keyboard, mouse, clipboard, or file content.
7. Platform hardening
- Hardened Runtime. Code-injection and library-hijack protections are on.
- Signed with an Apple Developer ID and notarized for macOS, so Gatekeeper can verify the binary has not been tampered with since signing. Apple notarization checks submitted software for malicious components and signing issues; it is not a privacy, encryption, or source-code audit.
- Only scoped permissions. Accessibility and Input Monitoring let Continuo capture and inject input, while Local Network enables peer discovery and connections. An optional Location permission reads the current Wi-Fi network name for local labels and mismatch warnings; skipping it does not affect input sharing.
8. What is prepared for publication and what stays proprietary
Product-consumed code prepared for publication (ContinuoSecurityTransport):
- cryptographic identity;
- pairing and SAS verification;
- trust storage and identity pinning;
- secure connection admission;
- relevant pairing, trust, and admission tests.
Staged and tested:
- generic
SessionCryptokey agreement and session-key derivation; - generic authenticated session encryption;
- bounded generic security framing;
- relevant session-crypto tests and fuzz targets.
This generic session-crypto implementation is not yet the shipped input-encryption implementation.
Proprietary:
- full application and UI;
- motion and native trackpad engine;
- event encoding and performance optimisations;
- clipboard/file feature implementations;
- licensing and Pro feature gates;
- all Pro features and product orchestration.
Continuo is commercial proprietary software. The package planned for publication distinguishes code the product consumes for pairing, identity pinning, and secure connection admission from generic session crypto that remains staged.
9. Verifiability
ContinuoSecurityTransport is prepared for publication. When the package is public, you will be able to inspect, compile, test, and fuzz the buildable package without requesting access. Until then, the private mirror is preparation for publication and is not public evidence yet.
Release-to-source mapping is planned. When it ships, each signed release will record the security-source commit identifier, and Continuo will publish a comparison procedure here. Once that mapping ships, the source will substantiate the consumed pairing, trust, and admission boundary, not provide byte-for-byte proof of the binary or of the shipped input-encryption path.
Exact cryptographic primitives and parameters for the transport are documented in the package prepared for publication. This paper is an overview in plain English rather than a formal specification.