You don't have to trust us. That's the whole point.

A normal camera records everything. This one is built to refuse.

At the center of SecuraCV is the witness kernel — the software you install at home, and the gatekeeper every detection passes through before anything is stored or sent. It isn't a camera app that tries to be private; the invasive features are left out, not switched off.

Privacy by absence, not by setting

Three intentional constraints

The one sentence that leaves is signed. Try to fake it.

When a Canary lets a claim out, it stamps it with a digital signature. Below is a real one, made in your browser this second with the same method (Ed25519) the device uses. Watch it verify, then rewrite the record and watch the stamp catch you.

// build the same message the device signs, then sign + verify it
function canonical(c, hash) {
  return "securacv-canary-sig|v1|presence|" + id +
         "|occupants=" + c.occupants +
         "|range_m=" + c.range_m + "|" + hash;
}
sig = await crypto.subtle.sign("Ed25519", privKey, msg);
ok  = await crypto.subtle.verify("Ed25519", pubKey, sig, msg);

// firmware/projects/canary-display/src/trust.cpp
// rebuild the locked canonical, then verify the stamp
snprintf(canonical, sizeof(canonical),
         "%s|v%d|chain|%s|%lu|%s",
         SIG_PREFIX, SCHEMA_V, device_id, length, latest_hash_hex);

const bool ok = Ed25519::verify(sig, pubkey,
                    (const uint8_t*)canonical, n);

Same handshake, both sides. The browser and the chip build the byte-for-byte identical message (securacv-canary-sig|v1|…) before they sign or check it — so anyone can re-check a real Canary's claim without us.

Every record remembers the one before it. Break one, break the rest.

One signed claim is good; a history you can't secretly edit is better. The kernel writes each event into a hash chain: every new record carries a fingerprint of the one before it. Change any past record, even by one character, and every record after it stops adding up. Try it.

/// Hashes a log entry with the previous chain hash.
pub fn hash_entry(prev_hash: &[u8; 32], payload: &[u8]) -> [u8; 32] {
    let mut hasher = Sha256::new();
    hasher.update(prev_hash);  // ← the fold: last hash…
    hasher.update(payload);    // …mixed with this record
    hasher.finalize().into()
}

let prev_hash  = store.last_event_hash_or_checkpoint_head()?;
let entry_hash = hash_entry(&prev_hash, payload_json.as_bytes());
let signature  = sign_entry(keys, &entry_hash, DOMAIN_SEALED_LOG_ENTRY)?;
// the new record is now both chained AND signed — three lines.

That's the whole trick. Each hash folds in the one before it, so the newest fingerprint vouches for the entire history. The demo runs the same SHA-256(previous + record) the kernel does.

We emulate a lot. Here's exactly what's real.

The Test bench, the Lab and the Scenes run in a browser — and the cryptography in them is completely real. The radar, the chip's secret key and the sealed storage can't exist in a web page, so those are simulated; the signature checks in them are not.

The emulator's own README says it plainly: it “talks to the firmware only through the same boundaries silicon would.” Where your browser can do the real math, it does — so a “verified ✓” in a demo is a real signature check, not decoration.

Three ways to check, from “click a button” to “audit the source.”

Trust should be optional. Pick how deep you want to dig.