Security

We carry your work and secrets. We can't read them.

Updated October 22, 2026

syncport moves uncommitted code, .env files and agent conversations between your devices and, if you choose, your team. Everything is encrypted on the sending device for the devices you confirmed, and signed by the sender. Our relay stores and forwards the sealed packages. This page shows what it holds, how a device earns your trust, and what we can't protect.

What our server stores

This is a handoff as our database stores it.

{
  "id": "5f0c2d1e-9a8b-4c7d-8e6f-0a1b2c3d4e5f",
  "kind": "workspace",
  "project_id": "r1_3f9a2c71d04be8a95c6e1f2a7b3d9c40",
  "project_name": null,
  "source_device_id": "8c41a9d2-7b3e-4f1a-9c0d-2e3f4a5b6c7d",
  "recipients": ["a72e5b10-3c4d-4e5f-8a9b-0c1d2e3f4a5b"],
  "agents": ["claude"],
  "size_bytes": 1843204,
  "sha256": "4be1…",
  "sealed": "YWdlLWVuY3J5cHRpb24ub3JnL3Yx…",
  "created_at": "2026-10-25T03:12:09Z",
  "expires_at": "2026-11-08T03:12:09Z"
}

It never receives:

source code, diffs or Git objects
.env and other secrets
agent conversations and the working state
project names, branch names, commit hashes and local paths
session titles

Projects are told apart by a routing ID made from a secret only your devices hold. Even for a public repository, the ID doesn't say which one it is.

How a device joins

Sign in with Google on the new device's approval page. This lets the device talk to our relay.
Confirm it from a device you already own. Run syncport devices confirm and type the last four characters of the fingerprint the new device shows. Your device signs the new one into your device list.

Our server can't add a device on its own. Without a signature from one of your devices, a device receives nothing. Your device list is a signed chain: each device remembers the latest entry it has seen and refuses a list that was shortened or rewritten. A new device also compares the whole list once with a device you trust, using syncport devices verify, so it can't be handed a made-up one.

Check it any time: syncport devices shows which device confirmed each one.

How a teammate joins

A team has its own signed list. A person joins only when an owner's device signs them in, after the owner compares their account fingerprint on a call or in person. Teammates see each other's tracks, the paths and line ranges they change, and team decisions. They never see your .env, your conversations or the commands your agents may run, unless you hand one over file by file.

How a handoff is sealed

Encrypted with age, with one recipient per confirmed device.
Signed with the sending device's Ed25519 key.
Verified before anything is written: the signature first, then hashes, project identity and paths.
Secrets such as .env travel in the sealed package under their own path and are never written into a Git object.
Device keys stay in a file only your user can read, the same way on every OS. syncport checks its permissions every time it starts.
Check commands allowed on one device are confirmed again on each of your other devices before they can run there.

Threat model

If this happens	An attacker gets	They don't get
Our database leaks	Sealed packages, device names, agent names, sizes and times	Contents, project names, commit hashes, paths
Our server is taken over	The ability to delay or drop packages, and the metadata above	A way to add a device or a teammate, or to roll back a signed list unnoticed
Your Google account is taken over	A web approval for their own device	Anything sent to that device, until one of your devices confirms it. A reset waits 24 hours and your devices are told
You lose a device	What that device already received, its key, and packages still waiting for it	Anything sent after you remove it from another device
Malware runs as you on a device	Whatever your agent can read on that device, including the device key file	A quiet way to add a device or to make your other devices run new commands. New devices are announced on your other devices, and new check commands are confirmed on each one
A teammate leaves	What they already received	Tracks, decisions and secret updates after removal

What we can't protect

A device that is already compromised. Malware running as you can read what your agent can read.
Key files. On every OS, device keys are a file only your user can read, so software running as you can read it too.
Files after they arrive. On the receiving device, .env is a normal file again, because your project needs it.
Copies people already received. Removing a device or a teammate stops future deliveries, not past ones. Rotate credentials you shared.
Metadata. Our relay sees device names, agent names, package sizes and times.
Losing every device. Old packages can't be recovered. That is what end-to-end encryption means.

Cryptography and code

age (filippo.io/age) with X25519 for encryption.
Ed25519 from the Go standard library for signatures.
SHA-256 for package hashes and the signed lists; HMAC-SHA256 for routing IDs.
Standalone binaries with published SHA-256 checksums. The installers verify them.
The client source isn't public. This page describes the protocol, so you can see what each part does and what our server holds. The security model in the docs has more detail.

Report a vulnerability

Email peerproblem@gmail.com. We read every report and reply as soon as we can. Please test only against your own account and devices. Machine-readable contact: /.well-known/security.txt.