Dev.to Security πŸ” Cybersecurity πŸ‘ 0 πŸ“– 20 min read

A dead man's switch that survives an internet shutdown: inside Kengele's deadline engine in Go

The short version, for everyone: Kengele is a free, open-source alarm for activists. If an activist stops checking in, their trusted contacts are alerted. The hard part is that governments switch the internet off at exac

A dead man's switch that survives an internet shutdown: inside Kengele's deadline engine in Go

The short version, for everyone: Kengele is a free, open-source alarm for activists. If an activist stops checking in, their trusted contacts are alerted. The hard part is that governments switch the internet off at exactly the moments abductions happen, and during a shutdown everyone goes quiet. This post walks through the Go code that tells "the activist went silent" apart from "the network went silent", with a scenario you can run on your own machine.

Kengele (Swahili for "bell") is an alarm for activists in East Africa. Ukinyamaza, kengele inalia: "if you go quiet, the bell rings." An activist sets a watch window before a protest, a court date or a border crossing ("2pm to 10pm, check in every 90 minutes"). Their check-ins go to three to five guardians. If a check-in does not arrive, each guardian's device raises the alarm on its own. There is no Kengele server to seize or switch off.

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.

Contents

  1. Why ten lines is not enough
  2. A passive engine with no goroutines
  3. The watch window and seven states
  4. Pausing per route, not per network
  5. The return window
  6. Run it yourself: an election-day shutdown
  7. Mass silence, stuck probes and going dark
  8. Late messages, replays and testing
  9. What is still open

At its core that is a dead man's switch, and a dead man's switch sounds like ten lines of code:

if time.Since(lastCheckIn) > interval+grace {
    raiseAlarm()
}

This post is about why the real one is 775 lines, and why every one of those lines exists because of a specific way people get hurt.

Kengele is still in design and not for real use until an independent security review is published. Everything below is code you can read and run today, at commit e10d277.

Why ten lines is not enough

The naive version fails in four ways that matter in Kenya, Uganda and Tanzania.

1. Shutdowns make everyone silent at once. Uganda ordered the internet off on 13 January 2026, effective 6pm, two days before its election. Tanzania did the same in October 2025. With the naive code, every activist under watch misses their deadline in the same minute and every guardian gets an alarm. Hundreds of false public alarms would destroy trust in the tool on its first real day.

2. But silence during a shutdown can also be real. Abductions happen during shutdowns. If we simply ignore missed check-ins while the network is down, the alarm is useless exactly when it is needed. The alarm must fire the minute the network comes back if the activist still has not checked in, not days later when someone finally notices.

3. Shutdowns are partial. In Tanzania in 2025, mobile data went dark but SMS mostly kept working. An activist who has the encrypted SMS fallback turned on can still check in. Their clock should keep running. An activist who only uses the internet path should pause. One global "online" flag gets both wrong.

4. Messages arrive late, and the late arrival is not the activist's fault. A check-in can be carried phone to phone over Bluetooth and delivered hours later. It still carries the activist's signed original time. The deadline engine must judge a check-in by when it was signed, not when it arrived, and still tell guardians it was late so they verify.

On top of that, an attacker with the activist's phone will try to abuse every one of these exceptions to keep the alarm quiet. Every pause has to be bounded.

The design rule: a passive engine with no goroutines

The first decision shapes everything else. The engine in internal/schedule owns no clock, no timers and no goroutines. The caller feeds it three things:

Input Method Meaning
Time passing Tick(now) "It is now now. What changed?"
Connectivity SetTransport(now, kind, up) "Nostr (or SMS) just went up or down for this guardian"
Messages Observe(now, via, event) "This verified event arrived over this route"

Every call returns a slice of Notice values (started, reminder, missed, alarm, paused, resumed, and so on). The caller decides what to do with them: show a notification, start the guardian confirmation flow, write a log.

// The engine is passive and has no goroutines: the caller feeds it the
// time (Tick), connectivity changes (SetTransport, SetOnline) and opened
// messages (Observe), and acts on the Notices it returns. That keeps it
// deterministic under a fake clock.

Why this matters:

  • Determinism. Given the same sequence of calls, you always get the same notices. There is no race between a timer firing and a message arriving, because there are no timers.
  • Testability. A test can walk through a whole election day in microseconds by calling Tick with made-up times. The test suite does exactly that: dozens of scenarios run in well under a second.
  • Portability. The engine has no opinion about how time is delivered. The Go watcher an organisation can host (cmd/kengele-watcher) drives it from a ticker; the Android guardian app, still being built, can drive the same rules from its own scheduler.

There is even a test that guards the rule itself, so nobody can quietly add a background goroutine later:

TestNoGoroutines (click to expand)
func TestNoGoroutines(t *testing.T) {
    before := runtime.NumGoroutine()
    e := New(Config{}, t0)
    for i := 0; i < 50; i++ {
        _ = e.Watch(key(i), window())
    }
    for m := 0; m < 600; m += 5 {
        e.Tick(at(m))
        if m == 200 {
            e.SetOnline(at(m), false)
        }
        if m == 260 {
            e.SetOnline(at(m), true)
        }
    }
    if after := runtime.NumGoroutine(); after > before {
        t.Errorf("goroutines: %d before, %d after", before, after)
    }
}

One more small rule: time never runs backwards inside the engine. If a caller passes a now earlier than the last one (a phone clock correction, for example), Tick keeps the later time.

if now.Before(e.now) {
    now = e.now // time never runs backwards inside the engine
}

The watch window

A watch is a Window:

type Window struct {
    Start, End time.Time
    Interval   time.Duration // check in every Interval
    Grace      time.Duration // late after due + Grace
    Reminder   time.Duration // remind this long before due
}

Validate refuses windows that cannot work: no start or end, end before start, a non-positive interval, negative grace, or a reminder that is not shorter than the interval.

The deadline after any accepted check-in is computed by one small function:

func (e *Engine) setDeadline(t *tracker, from time.Time) {
    due := from.Add(t.w.Interval)
    if due.After(t.w.End) {
        due = t.w.End
    }
    t.missAt = due.Add(t.w.Grace)
    t.reminded = false
    t.returnGranted = false
}

Three details are worth noticing:

  • from is the signed time of the check-in, not the arrival time. A check-in signed at 15:20 and delivered at 15:50 still sets the next deadline from 15:20.
  • The last deadline is clamped to the end of the window, so the activist does not have to check in after the protest is over just because the arithmetic said so.
  • returnGranted resets on every accepted check-in. Hold that thought; it is the defence against a flapping network.

Seven states

Each watched activist has a tracker with one of seven states:

State Meaning
inactive The window has not started
waiting The next check-in is not yet due
reminder The check-in is close to due or inside its grace period
missed A deadline passed while the network was up. Level 1: guardians are told privately
alarm A duress check-in or panic arrived. Top level
paused Every route this activist uses is down (or a mass-silence hold is in force)
cleared The window ended with a final check-in, or the guardians stood down

Two transitions are deliberately missing.

A check-in cannot cancel an alarm. Once a duress check-in or panic has arrived, a normal check-in is ignored:

case t.state == StateInactive, t.state == StateAlarm, t.state == StateCleared:
    return nil // a check-in cannot cancel an alarm; only all clear can

If captors hold the activist, they can make the activist check in. That must not undo the alarm the activist raised a minute earlier.

The activist's own all-clear cannot end a Level 1 alarm. This was the subject of my previous post:

Captors can force the PIN. They still can't switch the alarm off.
altradits profile
Stanley Chege Thuita
Stanley Chege Thuita
Stanley Chege Thuita
Follow
Nov 18

Before Level 1, an all-clear from the activist ends the watch like a final check-in. From Level 1 up, it is recorded and shown to guardians ("the activist says they are safe") but ends nothing. Only k guardians, after a voice or video call, can stand the alarm down through StandDown.

Pausing per route, not per network

The engine tracks connectivity per transport. Today there are two, defined in internal/transport/kind.go:

const (
    Unknown Kind = iota // proves nothing about any route
    Nostr               // gift-wrapped events through public relays
    SMS                 // the encrypted two-part SMS fallback
    Mesh                // reserved for the Bluetooth mesh (v0.2)
)

Each activist's plan lists the routes they use. The default is Nostr only; SMS is opt-in because SMS exposes metadata (who texted whom) to the phone company. The engine's rule is:

An activist's clock pauses only when every route they use is down, and resumes when one of them comes back.

// reachable reports whether at least one of t's transports is up.
func (e *Engine) reachable(t *tracker) bool {
    for _, k := range t.via {
        if e.up[k] {
            return true
        }
    }
    return false
}

When a route goes down, SetTransport first settles anything already due (so an alarm that was due a second before the outage still fires), then pauses every activist who is now unreachable:

if !up {
    out = e.Tick(now) // settle anything already due before pausing
    e.up[k] = false
    for _, a := range e.order {
        t := e.acts[a]
        if t.offline || e.reachable(t) {
            continue
        }
        t.offline, t.offlineAt, t.stillAt = true, e.now, e.now
        ...
        if t.state == StateWaiting || t.state == StateReminder {
            t.resume, t.state = t.state, StatePaused
            out = append(out, Notice{Kind: NoticePaused, ...})
        }
    }
    return out
}

Note what is not paused: an activist already in missed or alarm. A shutdown never downgrades an alarm.

The return window: firing the minute the network is back

When a route returns, each activist who was paused resumes. Two cases:

  1. The deadline fell inside the outage. The activist could not have checked in. They get a return window (2 hours by default) from the moment the network came back.
  2. The deadline is still in the future. It moves forward by the length of the outage, so the activist gets exactly the time they lost.
if !t.missAt.After(now) && !t.returnGranted {
    t.missAt = now.Add(e.cfg.ReturnWindow)
    t.returnGranted = true
} else {
    t.missAt = t.missAt.Add(outage)
}

The returnGranted flag is the important part. Without it, an attacker (or just a bad connection) could flap the network up and down, and every "up" would grant another two hours. One check-in cycle gets the return window at most once. The test for it reads like a story:

{
    name: "flapping network cannot stretch one deadline again and again",
    steps: []step{
        tick(0), offline(60), online(120), // deadline +105 in outage -> +240, return window used
        offline(130), online(135),          // 5 min outage -> +245
        offline(200), online(260),          // +245 passed in outage, but window already used -> +305
        tick(304), tick(305),
    },
    want: []want{{0, StateMissed, 305}},
},

The third outage does not grant a fresh two hours. It only adds back the 60 minutes that were actually lost. At +305 minutes the alarm fires.

Run it yourself: an election-day shutdown

Here is a scenario with two activists. Amina has the SMS fallback turned on. Baraka uses Nostr only. The window runs 14:00 to 22:00 with a check-in every 90 minutes, 15 minutes of grace and a 10-minute reminder. At 15:40 the internet is switched off. SMS keeps working. At 19:00 the internet comes back.

Save this as internal/schedule/blog_example_test.go in a clone of the repo:

package schedule

import (
    "fmt"
    "time"

    "github.com/altradits/kengele/internal/message"
    "github.com/altradits/kengele/internal/transport"
)

func Example_shutdown() {
    start := time.Date(2026, 1, 15, 14, 0, 0, 0, time.UTC)
    m := func(min int) time.Time { return start.Add(time.Duration(min) * time.Minute) }
    amina, baraka := [32]byte{1}, [32]byte{2}
    names := map[[32]byte]string{amina: "Amina", baraka: "Baraka"}
    show := func(ns []Notice) {
        for _, n := range ns {
            fmt.Printf("%s  %-6s %-9s next deadline %s\n", n.At.Format("15:04"), names[n.Activist], n.Kind, n.Deadline.Format("15:04"))
        }
    }
    checkIn := func(who [32]byte, min int, seq uint32) message.Event {
        return message.Event{Kind: message.KindCheckIn, CreatedAt: m(min), Seq: seq, Signer: who}
    }

    w := Window{Start: start, End: m(480), Interval: 90 * time.Minute, Grace: 15 * time.Minute, Reminder: 10 * time.Minute}
    e := New(Config{}, start)
    _ = e.Watch(amina, w, transport.Nostr, transport.SMS) // SMS fallback on
    _ = e.Watch(baraka, w)                                // Nostr only

    for min := 0; min <= 420; min++ { // tick once a minute (kengele-watcher defaults to every 30s)
        switch min {
        case 80:
            show(e.Observe(m(min), transport.Nostr, checkIn(amina, min, 1)))
        case 100:
            show(e.SetTransport(m(min), transport.Nostr, false)) // internet switched off
        case 170:
            show(e.Observe(m(min), transport.SMS, checkIn(amina, min, 2))) // Amina checks in by SMS
        case 300:
            show(e.SetTransport(m(min), transport.Nostr, true)) // internet back
        default:
            show(e.Tick(m(min)))
        }
    }
    // Output:
    // 14:00  Amina  started   next deadline 15:45
    // 14:00  Baraka started   next deadline 15:45
    // 15:20  Amina  reminder  next deadline 15:45
    // 15:20  Baraka reminder  next deadline 15:45
    // 15:40  Baraka paused    next deadline 15:45
    // 16:40  Amina  reminder  next deadline 17:05
    // 18:10  Amina  reminder  next deadline 18:35
    // 18:35  Amina  missed    next deadline 18:35
    // 19:00  Baraka resumed   next deadline 21:00
    // 20:35  Baraka reminder  next deadline 21:00
    // 21:00  Baraka missed    next deadline 21:00
}

Then:

git clone https://github.com/altradits/kengele
cd kengele
# save the file above as internal/schedule/blog_example_test.go
go test -race -run Example_shutdown -v ./internal/schedule

Our run (Go 1.26.5, macOS arm64):

=== RUN   Example_shutdown
--- PASS: Example_shutdown (0.00s)
PASS
ok      github.com/altradits/kengele/internal/schedule  1.555s

Read the output line by line, because every line is a design decision:

  • 15:20. Both get a reminder (due 15:30, reminder 10 minutes before). Amina checks in over Nostr in the same minute, so her next deadline moves to 15:20 + 90 + 15 = 17:05. Baraka does not check in.
  • 15:40. The internet goes off. Baraka pauses, because Nostr is his only route. His 15:45 deadline is frozen. Amina does not pause, because SMS still works for her. Her clock keeps running.
  • 16:40 and 16:50. Amina gets her reminder and checks in by SMS at 16:50. That check-in proves only that SMS works; it says nothing about Nostr. Her next deadline becomes 18:35.
  • 18:35. Amina missed. The internet is still off, but she had a working route and did not use it. That is a real missed check-in, and it is raised as one. This is the behaviour the single "online" flag would get wrong: it would have paused her too.
  • 19:00. The internet is back. Baraka's 15:45 deadline fell inside the outage, so he gets the return window: 21:00.
  • 21:00. Baraka missed. He had two full hours of working internet and did not check in. The alarm fires at a predictable, explainable time, not days later.

Mass silence: when the probe has not noticed the shutdown yet

SetTransport depends on something telling the engine that a route is down. In the watcher, that signal comes from the Nostr transport's relay reachability (a Connectivity callback reporting how many relays answered). But a shutdown can be partial in ways a probe cannot see: the guardian's relays are fine, but the activists' phones are in a region where data is off. Or the guardian is abroad, and only the country is dark.

From the guardian's side, that looks like several activists all missing at the same moment while nobody has heard from anyone. That pattern has two explanations, and both are serious: a regional shutdown, or a mass arrest.

The engine does not pretend to know which. When at least MassSilence activists (3 by default) miss within MassSpan (15 minutes) and nothing has arrived on any of their routes in that span, it holds them for at most the return window and tells the guardian to check by hand now:

if len(recent) >= e.cfg.MassSilence {
    for _, t := range recent {
        t.massHold, t.returnGranted = true, true
        t.resume, t.state = t.state, StatePaused
        t.missAt = now.Add(e.cfg.ReturnWindow)
        out = append(out, Notice{Kind: NoticeMassSilence, ...
            Reason: fmt.Sprintf("%d activists silent at once: possible shutdown or mass arrest, check by hand now", len(recent))})
    }
    ...
}

Three things keep this from becoming a way to suppress alarms:

  1. It is bounded. The hold lasts at most ReturnWindow. When it runs out and the activist is still silent, they go to missed with the reason "still silent after the mass-silence hold ended".
  2. It uses up the return window. A held activist cannot get a second free delay from a later outage in the same cycle.
  3. Evidence ends it early, but only on the right route. If anyone gets through on a route, that route clearly works, so the hold ends at once for every activist who uses that route:
for _, k := range e.order {
    h := e.acts[k]
    if h.massHold && k != ev.Signer && transport.IsSupported(via) && h.uses(via) {
        h.massHold = false
        h.state = StateMissed
        out = append(out, Notice{Kind: NoticeMissed, ...
            Reason: "others are getting through on " + via.String() + ", this activist is still silent"})
    }
}

The h.uses(via) check is the subtle part. An SMS check-in from Amina proves that SMS works. It proves nothing about Nostr, so it must not end the hold for Nostr-only Baraka. There is a test for exactly that: "an SMS check-in during a Nostr outage does not lift the hold for Nostr-only activists". And a message tagged transport.Unknown proves nothing about any network at all, though it still counts as a check-in.

A stuck "down" signal must not silence the alarm forever

Here is a failure mode that took a while to see. An offline pause never ends on its own: it waits for SetTransport(..., true). If the probe has a bug, or an attacker can make the guardian's device believe Nostr is down (block the relays at the guardian's network, for example), the clock stays frozen forever and silence means nothing forever.

So while an activist stays offline-paused, the engine re-alerts every 24 hours (StillPausedEvery), in Swahili and English:

out = append(out, Notice{Kind: NoticeStillPaused, ...
    Reason: fmt.Sprintf("bado imesimama / still paused: clock paused since %s, deadline %s",
        t.offlineAt.UTC().Format(time.RFC3339), t.missAt.UTC().Format(time.RFC3339))})

It does not raise the alarm (that would be a false alarm during a genuine week-long shutdown), but it makes sure a human looks. Mass-silence and going-dark holds are excluded because they already end on their own.

Going dark: a pre-announced shutdown

Shutdowns often come with a few hours' warning. So the activist has a "Going dark" button. It sends a signed, encrypted going-dark event (kind 7) to every guardian before the network goes down. Its body carries the current plan, how long the activist expects to be dark, the return window they want afterwards, and a SHA-256 commitment to the pre-written alert.

The engine pauses only that activist, even while the transports are up:

func (e *Engine) goingDark(t *tracker, ev message.Event) []Notice {
    g, err := message.ParseGoingDark(ev)
    if err != nil {
        return nil
    }
    until := e.now.Add(g.Dark)
    t.dark, t.darkSince, t.darkUntil, t.darkReturn = true, e.now, until, g.ReturnWindow
    t.massHold = false
    if t.state == StateWaiting || t.state == StateReminder {
        t.resume, t.state = t.state, StatePaused
    }
    return []Notice{{Kind: NoticeGoingDark, ...
        Reason: fmt.Sprintf("anaenda gizani / going dark: the activist expects a shutdown, clock paused until %s", ...)}}
}

The rules around it are where the security lives:

  • At most 7 days. message.MaxGoingDark caps the dark window. One message must never silence an activist for longer than a week. A longer shutdown needs a fresh going-dark, which needs the activist to be alive, free and holding their key.
  • It never downgrades. A going-dark does nothing to an activist already in missed, alarm or cleared. Captors who force the button after the alarm has fired gain nothing.
  • It is dropped if unreadable. A going-dark with a body that does not parse is ignored, and replays of an old sequence number are dropped before they reach this function.
  • A real check-in ends it early. An accepted check-in proves the activist is reachable, so the hold ends.
  • Duress and panic still fire. A panic during a going-dark hold raises the top-level alarm immediately.

When the hold ends, the same return-window rule applies as for an outage: a deadline that passed inside the hold gets the activist's requested return window once per cycle; any other deadline moves forward by the length of the hold.

The honest residual risk: captors who force the activist to press "Going dark" before any alarm has fired can buy a bounded pause of a running clock. Bounded is the point. It is at most 7 days, it shows up on every guardian's screen, and guardians who were told about a shutdown that never came can act on that.

Late messages and the signed time

Store-and-forward is a core feature: a panic can hop from phone to phone over Bluetooth and reach a network hours later. Every event carries the activist's signed CreatedAt, and the engine judges check-ins by it:

case at.Before(t.w.Start), !at.After(t.last):
    return nil // stale: signed before the window or before the last check-in

When a check-in arrives after the deadline already fired, the engine accepts it, resets the deadline, and raises recovered with one of two reasons:

reason := "late check-in: verify by voice before standing down"
if prev == StateMissed && !at.After(prevMiss) {
    reason = "check-in was signed in time but delivered late"
}

Guardians see the difference between "they checked in late" and "they checked in on time, but the message was delayed". Both still say: verify by voice. A recovered check-in never silently erases the fact that the alarm fired.

And one edge case that is easy to miss: a very old check-in can leave the next deadline already in the past. The engine catches that and raises missed immediately with "the latest check-in was too old to cover now".

Replays

A check-in captured off the wire could be re-sent later to make a missing activist look alive. Each tracker keeps the set of sequence numbers it has seen, and Observe drops any repeat before doing anything else:

if _, dup := t.seen[ev.Seq]; dup {
    return out
}
t.seen[ev.Seq] = struct{}{}

Combined with the rule that a check-in must be signed after the last accepted one, a replay can never move a deadline.

Testing it: a table of election days

The test file is 955 lines of table-driven scenarios. Each case is a list of steps (tick, offline, online, ev, down, up, gdark) at minute offsets from 10:00 on 15 January 2026, plus the notices and final states expected:

{
    name:    "deadline inside the outage gets the return window",
    steps:   []step{tick(0), offline(60), tick(200), online(120 + 0)},
    notices: []string{"started/0", "paused/0", "resumed/0"},
    want:    []want{{0, StateWaiting, 320}}, // engine time is already +200 when it comes back
},

Reading the case names is the best summary of the engine's promises:

  • "duress check-in raises the alarm and a later check-in cannot cancel it"
  • "duress during a shutdown still raises the alarm"
  • "short outage before the deadline moves it by the outage"
  • "flapping network cannot stretch one deadline again and again"
  • "check-in signed in time but delivered late (store and forward)"
  • "Nostr down, SMS up: the SMS activist's clock runs, the Nostr-only one pauses"
  • "the Nostr-only holds still end on time after an SMS check-in"

Run the whole suite with the race detector:

go test -race -count=1 -v -run 'TestSchedule|TestMixedTransports|TestStillPaused$|TestNoGoroutines|TestGoingDark' ./internal/schedule

Our run:

--- PASS: TestSchedule (0.00s)
--- PASS: TestGoingDark (0.00s)
--- PASS: TestMixedTransports (0.00s)
--- PASS: TestStillPaused (0.00s)
--- PASS: TestNoGoroutines (0.00s)
ok      github.com/altradits/kengele/internal/schedule  1.572s

A whole year of simulated shutdowns, in under two seconds, because the engine never waits for a real clock.

What I would do differently, and what is still open

  • The engine trusts the caller's connectivity signal. The still-paused re-alert limits the damage of a lying probe, but a guardian whose own network is controlled by an attacker is still in a weak position. That is one reason guardians should not all live in the same city, and why an organisation abroad can run the Go watcher as a backup.
  • Seen sequence numbers live in memory. Across a restart, replay protection falls back to the "signed after the last check-in" rule, which still blocks replays from moving a deadline, but persistence belongs in the watcher.
  • Timing metadata. A check-in every 90 minutes is a visible rhythm on a relay or a phone network, even when the content is encrypted. Cover traffic or random delays are an open question in the threat model.
  • The defaults (2-hour return window, 3 activists for mass silence, 24-hour re-alert) are educated guesses. They need to be tested in drills with real guardians before anyone relies on them. The plan for those drills is in docs/drills.md.

What it still cannot do

If the phone is taken instantly, SMS is down and no other Kengele phone is nearby, nothing gets out until the network returns. The engine's promise is narrower and more honest: the alarm fires in the first minutes the network is back, with the activist's signed timestamps intact, instead of days later when someone finally notices. Kengele does not prevent abductions. It shortens the time between a disappearance and public pressure.

How to help

Kengele is free, MIT-licensed and not for real use yet. We are open to collaboration, guidance and any form of participation:

  • Go developers: review internal/schedule. Try to find a sequence of calls that keeps a silent activist quiet for longer than the rules above allow. That is a bug, and we want it.
  • Android and Kotlin developers: the guardian app needs to apply these same rules on the phone.
  • Digital-security reviewers: the threat model needs critique before any code reaches a real person.
  • Swahili translators and people who work with activists: tell us what we are missing.

Start with CONTRIBUTING.md. Report security issues privately as described in SECURITY.md.

Not sponsored. Every life is worth watching over. Look out for each other.

πŸ“° Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes β€” full credit and traffic to the original publisher.