1. Principles
Voke stores sleep, heart, activity and workout data from Apple Health and Google Health, works out scores and summaries, and lets you share chosen parts with people you invite. Health data stays sensitive for a lifetime, so Voke is built around these principles:
- Nothing readable at rest. Everything Voke stores about your health (the database, backups, logs, job queues and push payloads) is either ciphertext under keys only your devices hold, one of the records listed in section 6, or metadata listed in section 14.
- A key only you hold. Your iPhone makes your account’s root key and keeps it in iCloud Keychain, with a recovery key only you hold. Voke’s server never has it.
- Readable on the server only in memory, only with your phone’s permission. Voke’s server works out scores, views and AI answers. It can do that only while a request carries keys your phone signed for it, or, for an AI app you connected, a token only that app holds. It drops the keys when the request ends and writes nothing readable. Google Health pages are the one exception: the server reads each page in memory between fetching it and sealing it (section 13).
- Your phone is your identity. There are no passwords. Each iPhone holds keys in its Secure Enclave that can’t leave it, and risky actions need a fresh signature from that phone.
- Nothing is shared until you choose. People you invite get keys for only the categories and levels you set.
- AI is off until you turn it on, and AI requests ask providers to keep no copy and not train on your data.
- Your data stays in Canada. Its off-site backups are in Canada too.
- Prepared for quantum computers. Anything sealed to a person uses X-Wing (ML-KEM-768 with X25519), every signature that protects stored or shared data is hybrid with ML-DSA-65, connections and backups use hybrid post-quantum key exchange, and every symmetric key is 256-bit.
2. Protections at a glance
- Health data at restHow it’s protected: AES-256-GCM under content keys only your devices and your leases hold; stored items have opaque ids
- Scores, views and exportsHow it’s protected: Worked out by Voke’s server in memory, under a short-lived lease your phone signs (section 7)
- Your root keyHow it’s protected: Made on your iPhone, synced by iCloud Keychain, never sent to Voke; a recovery key only you hold
- Sign-inHow it’s protected: Sign in with Apple, a Secure Enclave P-256 key and a Secure Enclave ML-DSA-65 key; no passwords
- ConnectionsHow it’s protected: TLS 1.2 and 1.3 with hybrid post-quantum key exchange (X25519MLKEM768)
- Off-site backupsHow it’s protected: Ciphertext under your keys, sealed again with age to a hybrid post-quantum recipient
- Logs and job queuesHow it’s protected: A fixed list of IDs, codes, counts and durations; no health values
- NotificationsHow it’s protected: No health values; circle notifications show only generic text
- SharingHow it’s protected: Share keys wrapped to each member’s post-quantum public key
- AIHow it’s protected: Off until you turn it on; each request opens data in memory under a lease; chats and summaries are stored sealed
- Connected AI appsHow it’s protected: The key that opens your data lives inside the app’s own OAuth tokens, never on Voke’s server
- Data locationHow it’s protected: Canada, with backups in Canada
3. Architecture
Voke has four parts that matter for security:
- The iPhone app. It holds your keys, reads Apple Health on the phone, and signs each upload and each lease with the phone’s device keys. It shows your data, your circles and Ask Voke.
- Voke’s server. It runs as containers on AWS Fargate in Montréal, behind a load balancer that accepts only HTTPS. It stores ciphertext, verifies signatures, routes data between people, sends notifications, fetches Google Health data and runs the AI features. It reads health data only in memory, under keys a request brings (section 7).
- The database. A PostgreSQL database on Amazon RDS holds the ciphertext, wrapped keys and account records. It sits in private subnets with no route to the internet and accepts connections only from Voke’s server, over TLS. A separate Amazon DynamoDB table holds each account’s server data key, wrapped by AWS Key Management Service (KMS), which the server uses for the few records it must be able to open itself (section 6).
- Outside services. Apple handles Sign in with Apple and delivers notifications. Google sends Google Health data. AI requests go through Vercel’s AI Gateway. The full list, with what each one handles and where, is on the service providers page.
The voke.co website is separate. It’s hosted on Cloudflare and never handles health data. The web pages at app.voke.co are there for invites and for connecting AI apps; there’s no sign-in on the web.
4. Where your data lives
Your data is stored in Canada:
- CanadaServer, database, KMS keys and key table: Montréal (AWS ca-central-1)Off-site backups: Calgary (AWS ca-west-1)
- Server keys stay in Canada. The KMS keys never leave KMS, and the key table and backups are in the same region too.
- Directory entries hold keyed hashes and a region code. A directory table in Montréal (AWS ca-central-1) holds, for each account, a keyed hash (HMAC-SHA-256) of your Apple sign-in identifier and a region code. Voke’s server checks it each time a device signs in, so an account exists in only one region. For subscriptions it also holds a keyed hash of your account identifier and, if you subscribe, a keyed hash of your subscription’s original transaction identifier, each with a region code, so Apple’s subscription updates reach your region. It holds nothing else. The account entries are removed when you delete your account; the transaction entry stays, so a late update from Apple can still reach the consent record.
Some data leaves Canada to make features work: Google sends Google Health data from its own servers, Apple handles sign-in and notifications, and AI features, if you turn them on, are processed in the United States, or in Europe for accounts in Europe (section 11). Your root key lives in iCloud Keychain, which Apple syncs end to end between your devices.
5. Identity and devices
Sign in with Apple, and no passwords
Sign in with Apple is the only way to create or open an account. Voke has no passwords, so there are none to steal or reuse.
When you sign in, the app first creates a device key (below). Voke’s server checks the identity token Apple returns, and requires that token to carry a value derived from a one-time challenge and the new device’s public key. This ties Apple’s confirmation of who you are to that specific key on that specific phone. The server also exchanges Apple’s one-time code with Apple and checks that both refer to the same Apple account. If the key is already enrolled to that same account, as after an interrupted sign-in, it signs that account back in; a key enrolled to any other account, or revoked, is refused.
Voke stores your name, the email address Apple gives it (often a private relay address) and Apple’s identifier for your account. Apple’s access and refresh tokens are stored encrypted with a server-wide 256-bit key (XChaCha20-Poly1305). Apple’s identity token isn’t kept after sign-in.
Device keys
Each iPhone holds two keys in its Secure Enclave, the chip that holds keys the operating system itself can’t read out:
- A P-256 key, made at sign-in. It signs every Apple Health upload, each new session and risky actions.
- An ML-DSA-65 key, a post-quantum signature key, enrolled with a proof signed by both keys. Together with the P-256 key it signs every lease (section 7). There is no software fallback: a phone without it can’t read or write your data.
The private keys never leave the phone and aren’t included in device backups. Voke’s server keeps only the public keys. The keys can be used once the phone has been unlocked after a restart, without Face ID each time, because Apple Health uploads run in the background and have to be signed. So they are as safe as the phone’s own lock.
The P-256 key signs:
- Every Apple Health upload. The server checks the signature and a hash of the upload before accepting it. Uploads must be signed within the last 14 days, and a repeated upload is recognised and ignored.
- Each new session. See below.
- Risky actions. Deleting your account, signing out your other devices, revoking another device, deleting a circle, removing a member, approving, changing or disconnecting an AI app, and turning AI features off each need a fresh signature over a one-time challenge. The challenge is tied to that device, that action and its target, lasts 5 minutes and can be used once. A stolen session token alone can’t do any of these things.
Sessions
Sessions last 15 minutes and are never extended. To keep you signed in, the app asks for a new challenge, signs it with the device key and receives a fresh session shortly before the old one expires. The session token is held in the app’s memory, not written to storage. Every request is refused if the device key behind its session has been revoked.
Signing out revokes that device’s key and deletes its sessions. “Sign out other devices” does the same for every other device at once. A session token opens no data on its own: reading health data also needs a lease signed by the phone’s two Secure Enclave keys.
6. End-to-end encryption and your keys
The key hierarchy
Account root key 256-bit, made on your first iPhone,
│ synced by iCloud Keychain, never sent to Voke
├─ HKDF → account key pair X-Wing (ML-KEM-768 + X25519); public half published, signed
├─ HKDF → signing keys Ed25519 + ML-DSA-65, used together
├─ HKDF → wrapping key AES-256-GCM; wraps content keys
├─ HKDF → locator root → one HMAC key per category and month: opaque ids
├─ HKDF → state key sealed indexes, record locators, sync state
└─ content keys random 256-bit, one per category and account epoch,
│ stored on the server only wrapped
├─ HKDF → per-item keys AES-256-GCM
└─ HKDF → inbox key pair X-Wing; the server seals new data to its public halfAll derivations use HKDF-SHA-256 with a fixed label per purpose, so a key for one purpose can’t open data meant for another.
- The root key is 32 random bytes made on your first iPhone and stored in iCloud Keychain, which syncs it end to end between your Apple devices whether or not you use Advanced Data Protection. The app also keeps a copy that never leaves that phone, so signing out of iCloud doesn’t lock you out of a phone you’re holding. Native code holds the key; it never reaches the app’s JavaScript.
- Your account public key is an X-Wing key pair derived from the root key. Its public half, with your Ed25519 and ML-DSA-65 public keys, is published as a key bundle signed with both signature keys. The server refuses a different bundle for your account unless it is signed by the current one.
- Content keys are random, one per category (sleep, heart, vitals, activity, workouts, body, nutrition, heart rhythm events, mind, cycle, readiness, journal, and AI history) and account epoch. Each is stored on the server wrapped under your wrapping key. A wrapped key carries no category in the clear; your phone checks each unwrapped key against an identifier derived from your root key, so a swapped row fails.
- One account epoch. Sharing and AI apps reach your data through their own keys (sections 10 and 12), which are rotated or destroyed when access ends.
- Opaque ids. Each stored item’s id is an HMAC of its kind, stream and day under a locator key for that category and month. The server never sees which metric or day an item holds.
- Sealed items. Each item is compressed, then sealed with AES-256-GCM under a key derived from its content key and its id, with a fresh 96-bit nonce. The associated data binds the item to your account, its id, its revision and its category, so an item copied to another account, id or category fails to open. Indexes, record locators and sync state are sealed the same way under your state key.
- Inbox keys. Each content key derives an X-Wing inbox key pair. Your phone publishes the public half, signed with your account signature keys, and the server verifies it before using it. When data reaches the server while no key of yours is present (a Google Health page, a journal entry or body fact written by an AI app, an Ask Voke chat or a morning summary), the server seals it to that public key. Only someone holding the content key, meaning your phones or a lease or AI app you granted that category, can open it. Pending items are merged into your stored data under a lease from your phone and then deleted.
Recovery and new devices
- Every Apple device you own gets the root key through iCloud Keychain, including a new iPhone restored from iCloud.
- A recovery key is shown once at setup: 256 bits plus a 16-bit checksum, written as 56 characters in 14 groups of four. Voke stores only your root key wrapped under it (AES-256-GCM under a key derived with HKDF), and accepts a new wrap only with your account signatures. The checksum catches typing mistakes before anything is sent. The app has no copy button; generating a new recovery key from the account screen replaces the old one, which stops working.
- Linking a new device that doesn’t have the key: the new iPhone shows a QR code (or a code you type) that carries a SHA-256 commitment to its own one-time X-Wing public key and a secret the server never sees. You scan it in the Voke app on a phone you already have. That phone checks the commitment before it asks for Face ID, then seals the root key to the new device’s key, bound to the secret. The server relays the sealed payload once and deletes it on first read, or after 10 minutes. A server that swaps in its own key fails the commitment, and a payload the server makes itself fails to open. Linking can’t be started from a web link.
- If you lose every device, your iCloud Keychain and your recovery key, your data can’t be recovered by anyone, including Voke.
What the server can open itself
A few records are encrypted under keys the server holds, because the server must use them with no phone involved. They are protected against a copied database or backup:
- Your Google Health refresh token, sealed with AES-256-GCM under a per-account 256-bit data key held under KMS, so the server can fetch Google data while your phone is asleep (section 13).
- Changes an AI asks you to approve, such as more access, sealed under the same per-account data key until you decide, and deleted 7 days after.
- Apple’s access and refresh tokens, sealed with XChaCha20-Poly1305 under a server-wide key.
The per-account KMS key is created by KMS, stored only wrapped in a key table kept apart from the database, unwrapped only for a request that names your account and its purpose, and destroyed when you delete your account.
Accounts made before end-to-end encryption
An account made with a version of the Voke app from before end-to-end encryption stays as it was and isn’t moved to it. Its health data, body facts, journal, chats and summaries are sealed under that account’s server-held data key, which the server can open. Everything else in this paper describes end-to-end encrypted accounts.
What the database holds in plain form
To run the service, the database also holds metadata protected only by the database’s own storage encryption and access controls. Section 14 lists it in full. The database’s storage, the key table, the backups and the container registry are encrypted at rest by AWS with 256-bit keys.
7. How the server computes: leases
Voke’s server, not the phone, works out scores, baselines, views, exports and AI answers, using the same code for every account. To do that it needs readable data, so your phone lends it keys for one request at a time. That loan is a lease.
What a lease is
- Signed by your phone. A lease lists exactly which keys it carries and for which categories, months and purpose, and is signed by both of the phone’s Secure Enclave keys: P-256 and ML-DSA-65. The server refuses it unless both signatures verify against keys enrolled for that device and account.
- Short-lived and used once. A lease lasts at most 120 seconds: 60 seconds for views, scoring and summaries, 120 for uploads and Ask Voke. The server rejects a lease issued more than 5 seconds in the future, checks its expiry, and records its id in a replay table that holds only the id and the expiry, so it can’t be used twice.
- Only in a request body. A lease travels only in the JSON body of a request over TLS, never in a header, a URL or a query, because headers and URLs are what proxies and logs record. No job, cache, log or error message ever carries one.
- Kept in memory only. On the server the keys are imported as non-extractable keys, reachable only inside that request, and dropped when it ends. Any read outside the lease is refused, never answered with partial or empty data.
What runs under a lease
- Upload from Apple HealthWhat the server reads in memory: The upload itself, which your phone sends over TLS with the keys for the categories and months it touches. The server normalises it and seals it with your keys; nothing readable is stored.
- ScoringWhat the server reads in memory: Every category for the days being scored plus up to 180 days before them, so baselines and scores match. Results are sealed under your readiness key.
- Viewing your dataWhat the server reads in memory: The categories and dates the screen needs.
- ExportWhat the server reads in memory: Your data for the export; the file is built in memory and never stored.
- Ask VokeWhat the server reads in memory: Every category over your full history, because the phone signs before the model picks what to read (section 11).
- Morning summaryWhat the server reads in memory: The categories and days the summary needs.
- Merging pending itemsWhat the server reads in memory: The pending items and the stored items they change.
During each of these requests, Voke’s server reads only the data the lease covers, in memory, and drops the keys when the request ends. Stored data stays unreadable without a lease.
Workout routes are the exception the other way: they never leave the phone. The app reads the route from Apple Health on the iPhone and draws the map there. To name the place, one point of the route goes to Apple’s geocoder, not to Voke.
8. Encryption in transit and post-quantum readiness
Connections
- Phone and web to Voke. Voke’s API accepts only HTTPS with TLS 1.2 or 1.3. Plain HTTP is redirected, and the API sends HTTP Strict Transport Security for a year. The API’s addresses point straight at Voke’s load balancer on AWS; no content delivery network decrypts the traffic on the way.
- Inside AWS. The database refuses connections that don’t use TLS. Voke’s storage buckets refuse requests that don’t use TLS.
- The website. voke.co is served over HTTPS only, with HTTP Strict Transport Security covering its subdomains.
- Google notifications. When Google tells Voke new data is ready, Voke checks Google’s signature on the message before acting on it.
What is post-quantum
A large enough quantum computer would break the public-key methods most of the internet uses, such as the elliptic-curve exchange X25519. Data copied today could be decrypted once one exists, so everything that keeps data confidential is hybrid: an attacker must break both a post-quantum and a classical algorithm.
- Everything sealed to a person: your account key, inbox keys, share keys, AI app keys, device linking, chat history and summaries use HPKE (RFC 9180) with X-Wing, which combines NIST’s ML-KEM-768 (FIPS 203) with X25519.
- Your connections to Voke: the API, sign-in, AI-connection and app addresses use X25519MLKEM768, a hybrid key exchange. The app always uses it, and so do current Chrome, Firefox, Safari and Edge.
- voke.co, served by Cloudflare, uses the same hybrid key exchange.
- The server’s own connections to its database, to AWS services and to Google, Apple sign-in and Vercel’s AI Gateway use the same hybrid key exchange.
- Off-site backups are sealed with age’s hybrid recipient, ML-KEM-768 with X25519 (section 9).
- Stored data is sealed with 256-bit symmetric keys. Known quantum attacks on symmetric encryption at most halve its effective strength, which leaves 256-bit keys with a wide margin. The recovery key and the invite secret are 256-bit for the same reason.
- Signatures: key bundles, recovery wraps, inbox keys, share keys and invite snapshots carry a composite Ed25519 and ML-DSA-65 signature that is valid only when both halves verify. Leases and device enrolment carry both a P-256 and an ML-DSA-65 signature from the Secure Enclave.
9. Backups
- Database backups. Amazon RDS keeps automatic backups that allow the database to be restored to any point in the last 35 days. They’re encrypted at rest with AWS KMS like the database.
- Off-site copies. Every night, a backup job dumps the database and encrypts the dump with age to a hybrid post-quantum public key (ML-KEM-768 with X25519) before it leaves the job. The backup job holds only the public half, so it can create backups but not read them. The private key is kept in a password manager, not on any server. The encrypted dumps are stored in a separate bucket in Calgary, which has its own KMS key, blocks all public access and deletes each copy after 30 days.
- What a backup holds. Your health data is ciphertext under your keys inside every layer above, so a backup holds nothing readable without your root key, your recovery key or a key you granted. It also holds the metadata in section 14.
10. Sharing and circles
Sharing in Voke happens through circles: groups of people you invite.
- Nothing is shared by default. When you create or join a circle, every category starts off.
- You set a level per category: none, score only, daily summary or full detail. A per-person setting can override the circle-wide one. If you share with someone in more than one circle, they get the highest level you gave them.
- Some data is never shared: body measurements, heart rhythm events, your Feed, your chats and your morning summaries.
Keys for each person
- Share keys. Your phone makes a random 256-bit share key for each category, level and epoch of your data. Levels nest: someone who sees full detail also gets the summary and score keys. Your phone works out what each level shows, seals it under that level’s share key, and uploads only ciphertext.
- Wrapped to each member. Your phone wraps each share key with X-Wing HPKE to the account public key of every member allowed to see that level, after checking the member’s signed key bundle, and signs each wrap with your account signature keys. The server checks the signature and the member’s level before it stores a wrap, so it can’t add a key you didn’t grant, and it never holds a share key itself.
- Reading. When a member opens your data, their phone sends a lease with the share keys they hold; the server opens your sealed views in memory for that request. Nobody without a key you wrapped to them can open them, whatever the server does.
- A circle key. Each circle has its own 256-bit key, held by its members, for things that belong to the circle rather than one person, such as its name.
- Reactions and challenges are sealed under share keys, so only people who can see the data they refer to can read them.
- Sharing with someone who’s offline. Your published X-Wing account key works like the signed last-resort prekey in Signal’s PQXDH protocol: anyone can wrap a key to it without you being online.
Invites
- Links carry a secret. An invite link carries a 256-bit secret after the
#, which browsers never send to a server. The invite page on app.voke.co hands it to the app without sending it anywhere. - An inviter snapshot. When you invite someone with a link, your phone seals a snapshot for them under a key derived from that secret: the circle key, the members, and your own share keys at the level you chose. It signs the snapshot with your account signature keys. The server holds only ciphertext it can’t open, for at most the invite’s 7 days.
- Binding the joiner’s keys. After accepting, the joiner’s app sends an authentication code (HMAC-SHA-256 under a key derived from the secret) over a digest of its signed key bundle, and only then can it take the snapshot, once. The joiner’s phone verifies your signature before decrypting. Your phone checks the code with the secret it still holds, and members’ phones wrap keys to the joiner only after that check passes, so a server can’t substitute its own key.
- Typed codes have no secret and no snapshot; keys reach the joiner from members’ phones.
- Invite links and codes work once and last 7 days. Voke stores only a keyed hash of each one.
Removing someone
When a member leaves or is removed, or you lower their level, their access ends both ways at once and the invites they sent are cancelled. In the same step the server deletes every key wrap they lost, including those for their AI apps; access they still have through another circle is kept. Each affected person’s phone then moves their share keys to a new epoch wrapped only to the people still entitled, so new data is sealed under keys they never receive. The circle key moves to a new epoch, with the circle’s name sealed again under it, when the phone of the circle’s first admin next runs Voke. Until then, the person who left can still read the circle’s name. Only a circle’s admins can remove members or delete the circle, and both need a device signature.
Circle alerts
Voke doesn’t send circle alerts, such as a missed night of sleep, for end-to-end encrypted accounts. Who has opted in to which alerts is stored sealed to the subject’s and recipient’s keys. Other circle notifications carry only “New activity in your circle”, with opaque ids, for Apple’s push service to deliver.
The access log
Each read of your data by another person or an AI is recorded. What was read (categories, level, dates) is sealed to your AI history key, so you and your AI can read it. Who read it, through which connection and when stays visible to the server.
11. AI features and what providers see
Off until you turn it on
Ask Voke and the morning summary stay off until you turn on “Use AI features” and agree to send your data to AI providers. Voke records that agreement with its version, and checks it before every AI request. Turning AI off (which needs a device signature) deletes your chats and summaries, disconnects your AI apps and keeps your data out of other people’s AI.
How Ask Voke reads your data
For each Ask Voke turn, your phone signs a lease that carries the keys for every category over your full history, plus your AI history key, because it signs before the model chooses what to look up. The lease lasts at most 120 seconds. The server opens only what the model’s tools read, in memory, and drops the keys when the answer is done. The tools still limit how much each call returns. Each turn and its title are sealed with X-Wing HPKE to your AI history inbox key before they’re stored, so Voke’s server can write your chats but not read them back without a lease from your phone.
The morning summary is asked for by your phone, under a lease for the days it needs. The summary is sealed to the same key, and your phone posts its own “Your morning brief is ready” notification.
The path a request takes
AI requests go from Voke’s server to Vercel’s AI Gateway, which passes them to a model host. For accounts in Canada and the United States the model is DeepSeek V4.1 Flash, served in the United States. For accounts in Europe it’s Claude Haiku 5.5, served in the European Union.
Every request is sent with three settings:
- Zero data retention: the provider should delete the request after answering.
- No training: the provider may not train on it.
- Region pinning: the request must be served in the region above. Voke checks where each answer was served and throws it away if it came from elsewhere.
The gateway enforces these settings and routes only to hosts that accept them, and a request fails rather than going anywhere that won’t accept them. What a provider does with a request is governed by these terms.
What the model sees
- Ask Voke: your question, the earlier messages in that chat, your name as it appears in Voke, and the health data the model looks up to answer. That data includes actual values, such as last night’s sleep stages or your resting heart rate. If you ask about someone in a circle, it includes their name and Voke’s internal ID for them, but not their email address.
- Morning summary: only a few sentences Voke has already worked out from your data, with no raw readings and no identifiers.
Other people’s data
Ask Voke can read what you can read: the data people share with you, at the levels they share it, where they have AI features on too. Your phone passes the share keys it holds to your Ask Voke leases. The morning summary and AI apps you connect read only your own data. If people narrow what you can see or turn their AI features off, chat turns that used their data are deleted.
The topic check
Before Ask Voke answers, a small model checks the question is about health, sleep or fitness, so Ask Voke stays on health topics. It’s run by TypeSafe AI through Vercel, with zero data retention and no training. It sees only the text of your own last 6 messages: no answers and no stored health data, though your messages may themselves mention your health.
What Voke keeps
Chats are stored sealed to your AI history key and deleted after 30 days. Morning summaries are stored sealed and kept until you turn AI off or delete your account. Voke’s logs record timings and counts for AI requests, not the text of questions or answers.
12. AI app connections (MCP)
You can connect your own AI app, such as Claude or ChatGPT, to Voke over the Model Context Protocol (MCP). This works separately from Voke’s own AI features.
Approval and access
- Standard OAuth. Connections use OAuth 2.1 with PKCE (S256 only). AI apps register themselves automatically, so there’s no shared secret to leak.
- Approved on your phone. The AI app’s sign-in page offers to open the Voke app, or shows a QR code and a short code. In the Voke app you see what the AI app asked for and choose, per category, Off, Read or Read and change. Approving needs a device signature, and the request expires after 10 minutes. Anything an AI app asks for that needs your own hand, such as more access, appears on your phone as a request to approve.
- Tokens bound to Voke. Tokens are issued only for Voke’s MCP address, and the MCP server refuses tokens issued for anything else. Access tokens last 1 hour. Refresh tokens rotate on each use, and reusing an old one more than 30 seconds later revokes the whole connection’s tokens. A connection lasts at most 90 days before you approve it again.
- Every call is checked against the levels you chose, and is logged like any other read. An AI app reads only your own data.
The key lives in the AI app’s tokens
The AI app calls Voke at any time, often while your phone is asleep, so it needs a key of its own. Voke never keeps one that opens your data:
- When the AI app exchanges its approval code for tokens, the server makes an X-Wing key pair for that connection in memory. Each access and refresh token is 32 random bytes. The server wraps the key pair’s private seed with AES-256-GCM under a key derived from each token, stores only those wraps, the public key and SHA-256 digests of the tokens, and discards the seed and the tokens.
- Your phone seals the keys for the categories you granted (and your circle keys, if you granted circles) to the connection’s public key, signs the bundle with your account signature keys, and uploads it. It does this when you approve, and again whenever you open Voke or it wakes in the background.
- On each call, the token the AI app presents unwraps the seed in memory, which opens the bundle; the server reads what that call needs, answers, and drops everything. Until the bundle arrives, a call for data answers that the data exists and you need to open Voke, never that there’s none.
- On refresh, the old token unwraps the seed and the server re-wraps it under the new tokens and deletes the old wraps.
- Writes from an AI app, such as a journal entry, are sealed to that category’s inbox key and merged into your data later.
So at rest Voke holds only what it can’t open without a token the AI app holds. The key is never in the MCP address: an address is copied into OAuth’s resource parameter, browser history and server logs, and would turn public setup links into secrets. The MCP host answers only its exact address, with no query string, and returns the same empty error for anything else.
Disconnecting an app, turning AI off or deleting your account deletes the connection’s tokens, wraps and key bundles at once.
Once data reaches your AI app, it’s handled under your account with that company and its privacy terms, not Voke’s. Voke tells you this before you connect.
13. Google Health
Voke’s server fetches Google Health data for you, so it arrives while your phone is asleep.
- Sealed on arrival. Each page Google returns is readable only in the server’s memory while it’s normalised, then sealed per category to your inbox keys. Your phones, Ask Voke and your AI apps can read it at once; the server can’t read it again.
- No data in queues or cursors. Fetch jobs and backfill progress hold only Google data type names, time windows and page tokens, never data points. Fetch jobs are sealed under a key the server holds; backfill progress is stored readable until your first import finishes or you remove Voke’s access. Google’s change notices are kept as a connection id and an hour window, for at most an hour. Finished fetch jobs are deleted after 10 minutes and failed ones after an hour.
- Fetching while your phone is asleep. The server uses your Google refresh token, stored under a key the server holds (section 6). The page token, data type and time window of a fetch exist for minutes.
14. What Voke’s servers handle
Your health data is end-to-end encrypted. To route data and run the service, Voke’s servers handle only the account and service metadata below, and open health data only in memory, for the request it was lent to.
Stored in plain form
- your account ID, your name and email from Sign in with Apple, and when the account was created;
- your region, the keyed hash in the region directory, and your device public keys, push tokens and the IP address and user agent of recent sessions;
- when your devices sync, and the ids, sizes, epochs and revisions of the items they write;
- which sources you’ve linked, and that Google has new data for you, by hour;
- who is in which circle, each person’s level for each category, invites, and which categories, levels, epochs and months each stored key or pending item belongs to;
- who read your data, through which connection and when (what they read is sealed);
- the digest of each circle alert sent, and who it went to;
- your agreements to terms and your AI consent, your AI connections, when they’re used and how many calls they make;
- which change an AI asked you to approve and its status (the request itself is sealed under the server’s key for your account, section 6);
- for each Ask Voke chat, which people it mentioned, so it can be deleted if they stop sharing;
- the queue of background jobs, which refers to accounts by ID and records failures as codes from a fixed list.
Readable in memory, never stored
- data a lease opens, while that request runs (section 7);
- Google Health pages, between fetch and seal;
- Ask Voke questions, answers and the data the model reads, which also go to the model provider;
- what an AI app you connected reads or writes during a call;
- your reactions in a circle, which travel to the server over TLS and are sealed there.
Held so the server can use them
Your Google refresh token and Apple’s tokens (section 6).
15. What happens if…
Someone copies Voke’s database or a backup. They get ciphertext and the metadata in section 14. Your content keys are wrapped under your root key, which Voke never has. They could open the records in section 6 only by also getting the KMS keys, which never leave KMS.
Someone gets full control of Voke’s servers. They can’t open stored health data with any key Voke holds. Key use under KMS is recorded in CloudTrail.
Someone records your connection today and builds a quantum computer later. The key exchange is hybrid post-quantum, and anything stored is sealed with X-Wing or 256-bit keys.
Your iPhone is lost or stolen. Its keys are protected by the phone’s lock and can’t be copied off it. From another device, revoke it; its sessions end at once, and any session expires within 15 minutes anyway.
A session token leaks. It expires within 15 minutes, opens no data without a lease signed by the phone, and can’t delete your account, change your devices, remove circle members or approve AI apps.
An AI app’s token leaks. It reaches only what you granted that app, and an access token works for at most an hour. Reusing an old refresh token revokes the whole connection, and you can disconnect the app from Voke at any time.
You remove someone from a circle. Their access ends immediately in both directions, their key wraps are deleted, and your phone moves to new keys they never get.
You lose every device and your recovery key, and iCloud Keychain. Your data can’t be recovered by anyone.
You delete your account. Your data, keys and key wraps are deleted (section 16).
16. Deletion
You can delete your account in the app; it needs a device signature. Here’s what happens:
- Access ends at once. Your devices are revoked, sessions and notification tokens are deleted, you’re removed from every circle (a circle you run passes to its longest-standing member, or is deleted if no one is left), and your AI consent and AI app connections, with their key wraps, are removed.
- Provider tokens are revoked. Voke asks Google and Apple to revoke the tokens it held for you.
- Your data and keys are deleted from the database: ciphertext, wrapped keys, your key bundle, your recovery wrap, pending items, and Google’s notifications about your account.
- The server’s key for your account is destroyed. The wrapped KMS data key is replaced with a marker saying it was destroyed, and Voke refuses to ever create a new key for that account.
- The directory entry and the account record are deleted.
- Voke checks nothing is left. A final step fails, and the job retries, if any record tied to your account remains.
- Your phone forgets your keys. Once the server confirms the deletion, the app deletes your root key from the phone and from iCloud Keychain.
The job retries until every step succeeds. Records of security events, such as when a device signed in or was revoked and that the account was deleted, are kept.
Backups. Database backups keep your ciphertext and the metadata in section 14 for up to 35 days, and the encrypted off-site copies for up to 30 days, and then they’re gone. Until then the ciphertext can be opened only with your root key or your recovery key, which Voke never has. If you kept a copy of your recovery key, destroy it too.
17. Operations
Access and its controls
Voke is operated by its founder, Rida F’kih, who holds administrative access to Voke’s AWS infrastructure. That access doesn’t open stored health data: the keys for it aren’t on Voke’s servers. The controls:
- The server’s own permissions are narrow. The role the server runs under can unwrap a KMS key only when the request names an account and the right purpose, and the database user it connects as can read and write data but not change the database’s structure.
- No long-lived cloud keys. Voke’s deploy pipeline has no stored AWS credentials. GitHub Actions gets short-lived credentials through OpenID Connect, and only for Voke’s repository. Roles that change production can be used only from the main branch’s production environment. The role that previews infrastructure changes on pull requests can’t read secrets or data.
- Key use is recorded. Every KMS unwrap is tagged with the account’s ID. A dedicated AWS CloudTrail trail records every key use, along with other AWS account activity, in a separate encrypted bucket kept for a year.
Logging
Voke’s server writes structured logs. Every field has to come from a fixed list of IDs, codes, counts and durations: the logger drops anything else, and a test fails the build if code tries to log a field outside the list, an error’s text, a request body or a payload. Errors are logged by their type and a short code, never their message. Any long base64 string is dropped, and lease and key fields can never be logged. Request logs record the route, status and timing, without your IP address or account ID. Logs are kept for 30 days.
The database’s slow-query log records how long a query took but not the values in it.
Testing that nothing readable is stored
A plaintext scanner plants known values in a test account and searches every column of every table, the job queue, logs, push payloads and a restored backup for them, in plain, hex, base64 and compressed forms. It first proves it can find planted values, so a blind scan fails. A second check fails if any row for an end-to-end encrypted account is sealed under a key the server holds, other than the records listed in section 6. These run on test stacks, not on production data.
Deploy pipeline
- Every push is scanned with gitleaks for secrets across the full history, and type checks, tests and infrastructure checks run on the parts that changed.
- Production deploys run automatically only after those checks pass on the main branch. New versions roll out alongside the old one and roll back automatically if they fail health checks.
- Voke’s AWS infrastructure is defined in code and applied by the pipeline.
- GitHub Actions are pinned to exact commits, workflow tokens are read-only by default, pull requests from forks never run workflows, and Dependabot raises security alerts and fixes for dependencies.
- Container images are stored in a private registry with immutable tags and scanned when they’re pushed.
- Changes can also be pushed to the main branch by Worm, Voke’s AI engineering agent. They go through the same checks and deploy pipeline as any other change.
Secrets
Application secrets are stored encrypted in AWS Systems Manager Parameter Store and handed to the server when it starts. They’re written outside the infrastructure code, so they don’t appear in it or in its state. The database’s administrator password is generated and held by AWS. The production server refuses to start with the test or local key implementations used in development.
18. Reporting and incident response
Reporting a vulnerability. Email security@voke.co with what you found and how to reproduce it. We’ll reply within 3 business days. Please don’t access other people’s data or disrupt the service while testing. Voke publishes a security.txt file with the same contact.
Monitoring. Alarms on server errors, failed health checks, unexpected server restarts, failed scheduled tasks and database health go straight to the operator.
If there’s a breach. If a breach of security safeguards creates a real risk of significant harm to you, we’ll tell you directly and report it to the Privacy Commissioner of Canada, Alberta’s Information and Privacy Commissioner and any other regulator the law requires, such as the US Federal Trade Commission or a data protection authority in the EU or EEA. We keep a record of every breach for at least 24 months. The privacy policy has the details.
Appendix A: cryptographic primitives
- Sealing to a person (account, inbox, share, AI app, linking)Primitive: HPKE (RFC 9180), X-Wing (ML-KEM-768 + X25519), HKDF-SHA-256, AES-256-GCM
- Stored data and key wrappingPrimitive: AES-256-GCM, 96-bit random nonce, 128-bit tag, address bound as associated data
- Key derivationPrimitive: HKDF-SHA-256, one label per purpose
- Opaque ids, invite hashes, join binding, webhook checksPrimitive: HMAC-SHA-256
- Account signaturesPrimitive: Composite Ed25519 + ML-DSA-65, both must verify
- Device keys, leases and request signaturesPrimitive: ECDSA P-256 with SHA-256 and ML-DSA-65, in the Secure Enclave
- Recovery keyPrimitive: 256 bits, 56 characters with a 16-bit checksum
- Records the server opens (section 6)Primitive: AES-256-GCM under a KMS-generated 256-bit data key; Apple tokens XChaCha20-Poly1305
- Google notification signaturesPrimitive: ECDSA P-256 with SHA-256 (Google Tink)
- TLS key exchangePrimitive: X25519MLKEM768 (ML-KEM-768 + X25519)
- Off-site backupsPrimitive: age 1.3, ML-KEM-768 + X25519 recipient (HPKE), ChaCha20-Poly1305 payload
Appendix B: internal decision records
Voke records its design decisions as numbered architecture decision records (ADRs) in its code repository. These are the ones behind each section.
- Architecture: ADR 0011, 0198, 0273
- Where your data lives: ADR 0198, 0202 to 0208
- Identity and devices: ADR 0008, 0020, 0021, 0080, 0081, 0259, 0327
- End-to-end encryption and keys: ADR 0215, 0216, 0253, 0258 to 0262, 0310, 0314
- Leases: ADR 0263 to 0266, 0313, 0315, 0316, 0322
- Encryption in transit and post-quantum readiness: ADR 0087, 0158, 0198, 0251, 0253, 0259
- Backups: ADR 0006, 0061, 0198, 0252
- Sharing and circles: ADR 0026, 0083, 0145, 0188, 0219, 0361 to 0364, 0377, 0407
- AI features: ADR 0112, 0146, 0160, 0164, 0178, 0210, 0220, 0357, 0360
- AI app connections: ADR 0098, 0099, 0109, 0164, 0254, 0279, 0280, 0359
- Google Health: ADR 0218, 0365, 0385
- What Voke’s servers handle: ADR 0215, 0221, 0268, 0366, 0368
- Operations: ADR 0011, 0200, 0212, 0221, 0268
- Deletion: ADR 0006, 0071, 0084, 0085, 0091, 0265, 0310