Skip to content

How it works

Revoked is client and server infrastructure for exchanging data. Whoever holds data shares it, and whoever needs data requests it. Either way, the data stays with its owner, and everyone else gets access they can lose.

The big picture

Every person uses the app, and every app talks to a server of their choosing. Services and tools talk to that same server. Servers talk to each other, so people on different servers can answer each other.

flowchart LR
    subgraph P[On your device]
        A[Revoked app<br/>keeps your private keys]
    end
    subgraph H[Your server, on your domain]
        S[API]
        V[(Vault, shares,<br/>requests, identities)]
        S --- V
    end
    subgraph O[Everyone else]
        L[Whoever has a link]
        Y[Your service or tool]
        R[Other Revoked servers]
    end
    D[DNS record<br/>_revoked.your-domain]
    A <--> S
    L --> S
    Y <--> S
    R <--> S
    D -. names the server's key .-> S
Part What it does
App Your window on all of it. Your identity's private key is made here and never leaves the device.
Server Keeps your vault, and checks the rules every time someone opens a link. One Go binary with a built-in database.
DNS record Names your server's key, which is what ties it to your domain.
API Everything the app does, this API does. There are no private endpoints.

Why it's access, not copies

A copy leaves your hands the moment you send it. A link goes back to the vault every time, so each change and each revocation takes effect on the next read.

flowchart LR
    subgraph C[With a copy]
        direction TB
        O1[Your data] -- sent --> X1[Their copy]
        O1 -- sent --> X2[Another copy]
        X1 -. can't be changed or taken back .-> Z1[Out of your hands]
    end
    subgraph K[With a link]
        direction TB
        O2[(Your vault)]
        L1[Their link] -- reads today's value --> O2
        L2[Another link] -- reads today's value --> O2
    end

Five ways to use it

Each one is the same idea with a different starting point.

Who starts it What the other side ends up with Try it
Share Whoever has the data A link to records Lab
Collect Whoever needs the data A link to their answer, or the typed answer Lab
Sign in A service An ID made for it, and any entries you agreed to share Lab
Prove A service, or whoever asks Only the details you ticked, and proof they're real Lab
Connect A tool The status and views of links it proposed Lab

Share

sequenceDiagram
    participant R as Whoever has the link
    participant S as Your server
    R->>S: Open the link
    S->>S: Active? Password? Views left? Verified viewer?
    alt A rule says no
        S-->>R: Refused, with the reason
    else All rules pass
        S-->>R: Today's values from your vault
    end

Collect

sequenceDiagram
    participant A as You
    participant S as Server
    participant R as The person answering
    A->>S: Create a request
    A->>R: Send the link
    R->>S: Check who is asking
    R->>S: Answer from their vault
    S-->>A: Callback, if you set one
    A->>S: Read the answers
    S-->>A: Today's values

An answer is kept in the workspace of whoever gave it, so they can change it or take it back. When people are on different servers, the answer stays at home, and the other server fetches it each time it's needed.

Sign in

sequenceDiagram
    participant Y as Your server
    participant P as Your page
    participant A as Revoked app
    participant S as Revoked server
    P->>Y: 1. Start
    Y-->>P: Link and check code
    P->>A: 2. QR code or link
    A->>S: 3. Approve, signed
    A->>Y: 4. Code to your callback
    Y->>S: 5. Redeem the code
    S-->>Y: ID token
    Y-->>P: 6. The session starts

Revoked keeps no session of its own. Every sign-in is approved in the app, and the service keeps its own session after that.

Prove

Every check starts from DNS. That's what stops anyone from claiming to be someone they aren't.

flowchart TB
    D[DNS names the server's key] --> S[The server shows that same key]
    S --> I[That key signed the sender's identity]
    I --> T[The server hasn't revoked the identity]
    T --> OK[DNS verified]
    D -- no record --> NV[Not verified: you decide]
    S -- doesn't match --> SP[Spoofed: blocked]
    I -- doesn't match --> SP
    T -- revoked --> RV[Revoked: blocked]
sequenceDiagram
    participant C as Who confirms it
    participant Y as Your app
    participant S as The service
    participant V as A Revoked server
    C->>Y: Offer
    Y->>C: Accept, signed with your key
    C-->>Y: The attestation
    S->>Y: Ask, with a fresh nonce
    Y-->>S: Proof with only the ticked details
    S->>V: Check the proof
    V-->>S: verified, and the ticked details

Connect

sequenceDiagram
    participant T as The tool
    participant A as Your app
    participant S as Your server
    T->>A: Propose a link, and ask to connect
    A->>S: Create the share and the connection
    A-->>T: One-time code
    T->>S: Code and verifier
    S-->>T: Connection token
    T->>S: What became of my links?
    S-->>T: Status and views, never the values

What the server can and can't see

Server sees it? Why
Your vault records Yes It reads them to answer a link. Run your own server, so it's yours.
An end-to-end encrypted record No Encrypted on your device. Its value on the server is always empty.
Your identity's private key No Made on your device, and it never leaves.
Your passkey No Your device keeps it. The server only sees the public half.
Who opened a link How often It counts views. The owner sees the count.

Go deeper