DEV Community

Cover image for Kengele: an alarm for when an activist goes missing, that nobody can switch off
Stanley Chege Thuita
Stanley Chege Thuita

Posted on Edited on AI-assisted

Kengele: an alarm for when an activist goes missing, that nobody can switch off

The short version, for everyone: When an activist disappears, how fast the public finds out often decides how fast they are released. Kengele (Swahili for "bell") is a free, open-source alarm: if an activist stops checking in, the people they trust are told within minutes, and nobody can switch the alarm off, not the captors and not a government that shuts down the internet. This post explains the whole system: who it protects against, how the pieces fit, and the design decisions behind it, with code you can run.

When an activist disappears, the first hours matter.

In Kenya, the national human rights commission counted more than 80 abductions and enforced disappearances after the 2024 protests. In January 2025, several abducted young men were released within hours of public outcry. Kenyan activist Boniface Mwangi and Ugandan activist Agather Atuhaire were freed after their detention in Tanzania became public.

Speed of public pressure is what gets people out. Today the alarm depends on someone noticing and phoning around, over networks that can be watched or switched off. Uganda and Tanzania both shut down the internet around their elections.

So I'm building Kengele, an open-source alarm for when an activist goes missing. Ukinyamaza, kengele inalia: if you go quiet, the bell rings.

GitHub logo altradits / kengele

An alarm for when an activist goes missing. No servers, works through shutdowns. Swahili first.

Kengele

When an activist goes silent, the right people know within minutes, and nobody can switch the alarm off.

Ukinyamaza, kengele inalia. ("If you go quiet, the bell rings.")

Warning

Status: design stage. Not for real use. There is no working app yet. Do not rely on Kengele to protect anyone until an independent security review is complete and published here. People's lives may depend on this tool, so we will not cut corners to ship it sooner.

Why

When an activist disappears, how fast the public finds out often decides how quickly they are freed.

Not for real use yet. Kengele is in the design and early build stage. Nobody should rely on it until an independent security review is published. Code links below are pinned to commit e10d277.

This is the overview post of a series. The deep dives go into the code of each part:

Contents

  1. How it works, in six steps
  2. The threat model came first
  3. Architecture: where each piece runs
  4. The escalation ladder
  5. Seven design decisions, and what we rejected
  6. A tour of the code
  7. Run the watcher yourself
  8. How the code is kept honest
  9. What it cannot do
  10. Prior art and what we learned
  11. Where it is and how to help

How it works, in six steps

  1. Watch windows. Before a protest, a court visit or a risky trip, the activist sets check-ins, for example every 90 minutes from 2pm to 8pm. Outside a window, Kengele is off.
  2. The alarm lives on the guardians' phones. Each check-in is a signed, encrypted message to 3 to 5 guardians (family, a lawyer, an organisation). If one doesn't arrive, every guardian's app raises the alarm on its own. Seizing the activist's phone stops nothing.
  3. Duress PIN. If someone forces the activist to check in, the duress PIN shows a normal screen and quietly raises the top-level alarm.
  4. Guardians confirm first. Nothing goes public until 2 of 3 guardians confirm. The alert text is locked under a key split among the guardians (Shamir secret sharing), so one guardian, even a coerced one, cannot publish early.
  5. Public alert and legal packet. Once confirmed, the activist's pre-written alert is published on Nostr, and the lawyer gets a ready habeas corpus packet with timestamps anchored to Bitcoin.
  6. A captor can't call it off. After an alarm starts, the activist's own all-clear ends nothing. Only guardians, after a voice or video check, can stand it down.

The rest of this post is about why each of those steps looks the way it does.

The threat model came first

Most apps write a threat model after the code, if at all. Kengele's threat model was written and published before any alarm code, and every security-sensitive pull request has to cite the section it relies on. A flaw here can cost a life, so the code answers to the document, not the other way round.

It names nine adversaries:

# Adversary What they can do What they want
A1 State security agents with telco access Call records, cell location, SMS content, order shutdowns, pressure app stores Find and seize the activist; map their network
A2 Captors who seize the phone Switch it off, search it, copy storage, run forensic tools Silence the alarm; learn the guardians and the plan
A3 Coercion of the activist Threats or torture to force a check-in, an unlock or a PIN Keep the alarm quiet; find guardians
A4 A compromised or pressured guardian One guardian's keys and device Suppress an alarm, fake one, forge an all-clear
A5 Logging Nostr relays and network observers Store every event, log IPs and timing, drop events Build metadata maps; silence alarms
A6 Network shutdowns and SMS interception Internet and/or SMS off, regionally or nationally Make every activist silent at once
A7 Insider at a partner organisation Access to an organisation's watcher Leak who is protected; suppress alarms
A8 Impersonators and defamation campaigns Create Nostr keys, post publicly Post fake alarms or fake "found safe" updates
A9 App store and supply-chain attackers Push a malicious build or dependency Run code on every activist's phone

And it is explicit about its assumptions. If any of these is false, the analysis changes:

  1. The activist's phone is not already infected with spyware at setup.
  2. At least 2 of the 3 to 5 guardians are honest and reachable when it matters.
  3. Keys are exchanged in person or over a channel already trusted (for example Signal with verified safety numbers).
  4. Standard cryptography holds: secp256k1 Schnorr signatures, NIP-44 (ChaCha20 + HMAC-SHA256), SHA-256.
  5. The adversary can control the phone network inside the country, but not every Nostr relay worldwide at once.
  6. Phone clocks are roughly right. Signed times are claims until anchored with OpenTimestamps.

Assumption 5 is the one the whole architecture rests on, so the next section starts there.

Architecture: where each piece runs

+-----------------------------------+
| ACTIVIST'S PHONE                  |
|  watch plan (encrypted)           |
|  check-in, duress PIN, panic      |
|  "going dark" button              |
+-----------------------------------+
    |               |              |
    | Nostr         | SMS          | Bluetooth
    | gift wraps    | (opt-in,     | carry-and-forward
    | (NIP-59)      |  2 segments) | (v0.2), any phone
    v               |              |
+---------------+   |              |
| PUBLIC RELAYS |   |              |
| chosen by the |   |              |
| group, several|   |              |
| countries     |   |              |
+---------------+   |              |
    |               |              |
    v               v              v
+-----------------------------------+
| EACH GUARDIAN'S DEVICE (3 to 5)   |
|  deadline engine, per route       |
|  2-of-3 confirmation tally        |
|  OpenTimestamps proofs            |
|  habeas corpus packet             |
+-----------------------------------+
    |
    | k guardians confirm
    v
 public alert on Nostr  +  packet to the lawyer
Enter fullscreen mode Exit fullscreen mode

The important property is what is missing from the diagram: there is no Kengele server. Altradits runs nothing in the alarm path. The deadline runs on the guardians' devices, and messages travel over public relays the activist and guardians choose together, plus SMS and (in v0.2) a Bluetooth mesh.

That gives three properties at once:

  • Nothing to seize or switch off. A court order, a raid or an unpaid hosting bill cannot stop every guardian's phone and every relay in several countries.
  • The alarm survives the activist's phone. Taking or smashing the phone is exactly the event the guardians are waiting for.
  • No central database of who is protected. There is no list to subpoena.

The escalation ladder

An alarm does not go straight to the public. It climbs:

Level Trigger Who is told Code
0. Reminder Check-in is close to due The activist internal/schedule
1. Private A missed deadline, a panic, or a duress check-in Every guardian, privately internal/schedule
2. Public k guardians (default 2 of 3) confirm the same alarm Everyone: the pre-written alert is published, signed by a key the activist announced in advance internal/confirm
3. Legal Public alarm The lawyer, with signed events and Bitcoin timestamps internal/ots, internal/packet

The ladder is the answer to two opposite failures. Amnesty's Panic Button was retired partly because it alerted contacts by accident, and false alarms destroy trust. But an alarm that waits too long is useless. So the private level is fast and noisy (every guardian, every missed deadline), and the public level is slow and deliberate (k humans must agree, and the cryptography enforces it).

Seven design decisions, and what we rejected

1. The deadline runs on the guardians' devices, not the activist's phone and not a cloud.
Rejected: a timer on the activist's phone (captors switch it off) and a company cloud like consumer check-in apps use (a government can subpoena or block it). Running the deadline where the activist is not is right; running it in one company's cloud is wrong for activists.

2. Public Nostr relays, not our own server or a messenger.
Rejected: our own server (one point of failure, one subpoena), and building on a single messenger's infrastructure (one company's terms, one phone number per user). Nostr gives signed events, NIP-44 encryption and NIP-59 gift wraps that hide the sender and time from relays, over relays anyone can run. The wire format post goes through it byte by byte.

3. One fixed-size message for everything.
Every event (check-in, duress, panic, confirmation, all-clear, going dark) is exactly 228 bytes, so a panic looks like a check-in to every carrier, and it fits in two SMS. Rejected: variable-length messages, because size is metadata.

4. A clock that pauses per route during shutdowns.
Rejected: ignoring shutdowns (hundreds of false public alarms on election day) and pausing on one global "online" flag (wrong when SMS works but data doesn't). The deadline engine post has a runnable shutdown scenario.

5. "2 of 3" enforced by cryptography.
The pre-written alert and the key that signs it are encrypted under a random key that is split with Shamir's secret sharing. One guardian's share cannot even decrypt it. Rejected: a counter in the app (if confirmations >= 2), which one compromised phone could patch out.

6. No location trail, ever.
The alert carries only the place the activist typed at their last check-in. The code refuses alert text that looks like GPS coordinates or a map link. Rejected: live location sharing, which would help abductors and expose everyone the activist met.

7. No custody of anything.
No accounts, no phone numbers stored (guardians are public keys), no money held. The legal fund is a Bitcoin wallet the activist alone, or 2 of 3 guardians, can spend, using existing wallets like Liana or Sparrow. Kengele only generates the descriptor.

A tour of the code

The core is Go. Counts are lines at commit e10d277, source and tests:

Package What it does Source Tests
internal/message The 228-byte signed, encrypted event; SMS text form; going-dark body 546 765
internal/schedule Deadline engine: watch windows, per-route pauses, mass silence, going dark 999 1,118
internal/transport Nostr gift wraps, relay client, outbox; bitchat carry 1,379 928
internal/confirm Shamir-sealed alert kits, 2-of-3 tally, all-clear rules, public notes 1,035 726
internal/ots OpenTimestamps: salted commitments, offline queue, .ots wire format 1,538 885
internal/packet Habeas corpus packet 276 175
internal/fund Legal-fund descriptor (activist, or 2 of 3 guardians) 773 631
internal/meshcarry, internal/meshexit Bluetooth carry-and-forward and radio exits (v0.2 work) 2,208 2,941
cmd/ kengele-watcher, kengele-packet, kengele-fund, kengele-talk, mesh tools 1,388 1,175

Across the board there are more lines of tests than of code in the packages that decide when someone is in danger. The Android apps (activist and guardian, Kotlin) live in android/ and share test vectors with the Go message format, so the two implementations cannot quietly disagree.

The flow of one check-in through the code:

  1. The activist app builds a message.Event{Kind: KindCheckIn, CreatedAt: now, Seq: n, Body: "Milimani law courts"}.
  2. message.SealAll signs it once (BIP-340, domain-tagged) and encrypts it once per guardian (NIP-44 v2). Every result is 228 bytes.
  3. nostr.Wrap puts each one in a rumor, a seal and a gift wrap signed by a one-time key, and the transport publishes it to every relay.
  4. On a guardian's device, the transport unwraps it, message.Open verifies the signature and the strict layout, and the watcher calls schedule.Engine.Observe(now, transport.Nostr, event).
  5. The engine moves that activist's deadline forward from the signed time and returns notices for the app to show.

If step 4 never happens, Engine.Tick eventually returns a missed notice, and the confirmation flow in internal/confirm begins.

Run the watcher yourself

The Go watcher is what an organisation can run as a backup guardian. It reads an encrypted watch plan and follows each activist. Without relays it runs as a local demo (not for real use), which is enough to see the engine work.

git clone https://github.com/altradits/kengele
cd kengele
go build -o kengele-watcher ./cmd/kengele-watcher
Enter fullscreen mode Exit fullscreen mode

Write a plan with two made-up activists: Amina uses Nostr and SMS, Baraka uses Nostr only. Short intervals so you can watch it happen (start a few seconds from now, in UTC):

{"version": 1, "activists": [
 {"label": "Amina", "pubkey": "0101010101010101010101010101010101010101010101010101010101010101",
  "start": "2026-11-19T18:52:05Z", "end": "2026-11-19T19:02:00Z",
  "interval": "20s", "grace": "10s", "reminder": "5s", "transports": ["nostr", "sms"]},
 {"label": "Baraka", "pubkey": "0202020202020202020202020202020202020202020202020202020202020202",
  "start": "2026-11-19T18:52:05Z", "end": "2026-11-19T19:02:00Z",
  "interval": "20s", "grace": "10s", "reminder": "5s"}
]}
Enter fullscreen mode Exit fullscreen mode

The plan says where people will be and when, so the watcher only ever reads it encrypted. Seal it, delete the plain copy, and run with Nostr pretending to be down:

export KENGELE_PASSPHRASE='a long passphrase'
./kengele-watcher seal-plan -in plan.json -out plan.kgp && rm plan.json
./kengele-watcher run -plan plan.kgp -tick 1s -down nostr
Enter fullscreen mode Exit fullscreen mode

Our run (Go 1.26.5, macOS):

kengele-watcher 0.0.0-dev: watching 2, no transport yet (not for real use) / inafuatilia 2, bado hakuna transport (si kwa matumizi halisi)
2026-11-19T18:52:05Z started      Amina deadline 2026-11-19T18:52:35Z
2026-11-19T18:52:05Z started      Baraka deadline 2026-11-19T18:52:35Z
2026-11-19T18:52:05Z paused       Baraka deadline 2026-11-19T18:52:35Z (window opened while all of this activist's transports are down)
2026-11-19T18:52:20Z reminder     Amina deadline 2026-11-19T18:52:35Z
2026-11-19T18:52:35Z missed       Amina deadline 2026-11-19T18:52:35Z (no check-in by 2026-11-19T18:52:35Z)
Enter fullscreen mode Exit fullscreen mode

That is the shutdown rule in five lines. With Nostr down, Baraka pauses the moment his window opens, because Nostr is his only route; silence from him means nothing yet. Amina does not pause, because she still has SMS. When she misses her deadline, it is a real missed check-in, and it is raised. Every message is bilingual, Swahili and English, because the people who will run this first speak both.

For live use, add -relays wss://…,wss://… -key-file guardian.key and optionally -alert-hook ./hook.sh, which runs once per alarming notice (to ring a phone, send an email to a duty officer, and so on).

How the code is kept honest

A tool like this is only as trustworthy as its process, so the process is part of the design:

  • Every pull request runs gofmt, go vet, go build and go test -race ./.... The race detector matters: the transport and the confirmation tally are concurrent, and alarm logic with a data race is a bug that only shows up on the worst day.
  • Golden test vectors. The message format has a fixed vector with made-up keys, checked byte for byte, and the NIP-44 library is checked against the specification's own vector, so a dependency upgrade cannot silently change the wire format.
  • Reproducible Android builds. A workflow rebuilds the APK and checks the checksum, so anyone can confirm the app they install was built from this source (threat A9).
  • One-line commit messages and cited threat-model sections keep the history reviewable by people who are not Go developers.
  • No real people in the repo. Test data uses made-up keys and names, and the docs say so.

What it cannot do

The threat model lists these plainly, so nobody relies on Kengele for more than it gives:

  1. It does not prevent an abduction. It shortens the time between a disappearance and public pressure.
  2. If the phone is taken instantly, SMS is down and no other Kengele phone is nearby, nothing gets out until the network returns. Kengele then makes sure the alarm fires in the first minute the network is back, with proof of timing.
  3. During a shutdown, silence means nothing. Guardians cannot tell an abduction from a dead network, so the alarm waits for the network. That can mean hours or days.
  4. A phone already infected with spyware defeats it.
  5. Coercion can reveal guardians, and a captor who knows about the duress PIN may defeat it.
  6. A majority of compromised guardians can block confirmation or forge an all-clear. Choose guardians who don't live, work or get arrested together.
  7. SMS exposes who texted whom to the phone company. It is off by default for that reason.
  8. Regular check-ins form a visible rhythm, even when encrypted.

Prior art and what we learned

Círculo Panic Button Consumer check-in apps Kengele
Central server Yes Central team Company cloud None (public Nostr relays)
Alarm survives a seized phone Not stated No Yes Yes (guardians' devices)
Works during shutdowns No SMS only No Paused clock, SMS, mesh, carry-forward
False-alarm control Not stated Weak Reminder Reminder, private first, 2-of-3 confirm
Duress PIN Not stated No No Yes
Court-ready timestamps No No No OpenTimestamps on Bitcoin
Swahili No Not known Not known First

The closest tool, Círculo by Guardian Project and ARTICLE 19, says on its site that its service shut down on 15 November 2026. It needed the internet and its own servers. Amnesty's Panic Button was retired after false alarms. Kengele is designed around both lessons: no servers, and nothing goes public without human confirmation. More in docs/prior-art.md.

Where it is and how to help

Built so far: the threat model, the message format, the deadline engine with shutdown mode and going dark, the Nostr transport, the SMS spec, 2-of-3 confirmation with the coerced all-clear rule, OpenTimestamps anchoring, the habeas corpus packet, the legal-fund descriptor on signet, and early Bluetooth mesh work. 79 commits, every one through race-tested CI.

Next: the Android apps end to end, drills with real guardians, Bluetooth mesh through bitchat, and an independent security review before anyone relies on it.

We are open to collaboration, guidance and any form of participation:

  • Digital-security reviewers: the threat model has a reviewer checklist. Critique it before any code reaches a real person.
  • Go developers: the deep-dive posts above are a good way in.
  • Android and Kotlin developers: the activist and guardian apps.
  • Nostr developers: review the gift-wrap and relay code.
  • Swahili translators and people who work with activists: tell us what we are missing.

Start with the Start here issue and CONTRIBUTING.md. Report security issues privately as described in SECURITY.md.

Code: github.com/altradits/kengele (MIT). Not sponsored.

Ukinyamaza, kengele inalia. If you go quiet, the bell rings.

Top comments (0)