Security overview
This page explains how Utly Remote checks who’s who, controls what each person can do, and limits what we, as the people running the service, can see or do. It takes about ten minutes to read. Our threat model covers the same ground in full technical detail.
The main idea
Our server helps two computers find each other and passes the technical details they need to connect. We designed Utly Remote so that it stays safe even if that server is hacked, gives out false information, delays or swaps messages, or has its database stolen. Everything important is checked by the two computers themselves, so you don’t have to rely on us being trustworthy.
Each computer has its own key
When Utly Remote first runs, it creates an Ed25519 key pair. The private key is stored on the computer, protected by the Windows account. Our server links the public key to the computer’s nine-digit ID, and that link never changes. To register, the program signs a random challenge from the server with its private key. This means nobody can take over an ID just by claiming it, and an old registration can’t be replayed.
Sessions are encrypted with keys our server never has
A session is a WebRTC connection between the two computers. The picture and sound use DTLS-SRTP, and keyboard and mouse input, the clipboard, files, chat and other messages go over an encrypted DTLS data channel. The two computers create the encryption keys between themselves. Our server only passes along the information they need to start the connection.
Each computer signs the fingerprint of its connection certificate with its private key, and sends that signature with its connection details. The other computer checks the signature against the public key that came with the request, and against its own record for that ID. If our server swapped the connection details, the signature wouldn’t match and the connection would fail.
Voice and video calls use their own WebRTC connection between the two programs, encrypted in the same way. The details needed to set up a call travel inside the session’s encrypted connection.
The first connection: saved keys and four words
The first time you accept a connection from an ID, your computer saves its public key. If the same ID later shows up with a different key, the viewer’s side refuses it, and the host sees a warning on the request window. You can remove a saved key in Settings if you need to.
A saved key can’t help the very first time two computers connect. For that, both screens show four words that are worked out from both connections’ fingerprints. If someone were intercepting the connection from the middle, the words on the two screens would be different. Compare the words before you accept, and don’t continue if they don’t match.
Consent and permissions
A session only starts after the host clicks Accept, or after the viewer proves they know the unattended password. Keyboard and mouse, clipboard, sound and files are separate permissions. The host chooses them on the request window and can change them during the session. The host’s own program enforces them: with keyboard and mouse turned off, it ignores the input that arrives, and with files turned off, it doesn’t answer file requests. None of this relies on the viewer’s program behaving.
Unattended access: the password is never sent
The unattended password uses a protocol called OPAQUE. The host keeps a record from which the password can’t be worked out, and the viewer proves it knows the password without sending it. Our server passes along three messages that reveal nothing about the password. The exchange is also tied to both computers’ connection fingerprints, so it can’t be reused for a different connection. A wrong password is detected on the viewer’s side first. Five wrong attempts from one ID lock that ID out for thirty minutes, and twenty wrong attempts from any mix of IDs stop the host from accepting the password at all for thirty minutes.
Before the first password can be set, the program shows a warning about phone scams. If someone says they were told to install the program, they’re shown a ten-minute pause and our safety page instead of the password box.
The background service
When the background service is installed, the part that shares the screen runs as a Windows service. It starts a helper in the user’s session, which is what lets it show the sign-in screen, handle administrator prompts and send Ctrl+Alt+Del. The program you see talks to that helper through a named pipe that only the system, administrators and signed-in users can open. Before trusting the pipe, the program checks that it really belongs to the system or to itself. The computer’s identity, saved keys and unattended access record are stored with the service in ProgramData, protected for that computer and readable only by the system and administrators.
The session log
Each session start and end, permission change, declined request, failed sign-in, lockout, key change and file transfer is added to a log on the host. Each entry includes a hash of the entry before it, and the program checks the whole chain every time the log is opened, marking the first entry that doesn’t match. This catches anyone who edits or deletes an entry, unless they also rewrite every entry after it. An administrator could do that, but an administrator could also replace the program itself.
Accounts
Accounts are optional, and a computer that never signs in isn’t affected by them. Account passwords use the same OPAQUE protocol, with our server as the other side, so the server never sees the password. When someone tries to sign in with an email that doesn’t exist, the server answers with a fake record, so the exchange doesn’t reveal which emails have accounts. Signing up sets up an authenticator app before anything is stored, and gives you eight single-use recovery codes. A new device signs in with the password and then needs one more thing: approval from a device that’s already signed in, a code from the authenticator app (each code works once), or a recovery code. Each device holds a random token, stored in scrambled form on the server and protected on the device. Any signed-in device can sign out any other, and it’s cut off straight away.
You can use the same account in a browser at utly.dev/account. The browser runs the same password protocol, so your password never leaves the browser either. A browser counts as a device, needs the same second step, and keeps its token in a cookie that only that page can read.
The address book
With an account, the names you give computers are shared between your devices. They’re encrypted with a key made from your password, which your program works out and our server never learns. Each entry is encrypted with XChaCha20-Poly1305 and stored under a label made from the ID with a secret key, so our server can’t read an entry or tell which ID it belongs to. Only the names are shared.
Updates
The program downloads updates over HTTPS and checks each one’s signature against a key built into the program before running anything. We keep the private signing key ourselves, not on the web server, so even if the web server were hacked, the most an attacker could do is stop updates from arriving. If a new version doesn’t start properly, the program goes back to the previous one.
Abuse reports
Anyone can report an ID from inside the program. Each report is linked to a registered ID and an internet address, and a person reads it. A blocked ID can’t register and can’t connect to or accept connections from anyone. Our terms explain the policy.
Reporting a security problem
Please write to mail@lohit.me, and don’t post it anywhere public until it’s fixed. We’ll reply within three days, tell you what we think within seven, and fix anything serious within thirty days or explain our plan. We’ll credit you, unless you’d rather we didn’t.
What we can’t protect against
Someone using your computer while it’s unlocked can act as you, because the keys are tied to your Windows account, not to you as a person. Encryption can’t stop someone who persuades a host to click Accept, which is why the request window shows who’s asking and why both screens show four words. As the people running the service, we can see who connects to whom and when, and we could refuse to connect you. The threat model covers everything else, including what each type of attacker could do.