Cryptography

How AllWeDo encrypts and authenticates data · AllWeDo 3.1.206 · Published: October 20, 2026

This is a public, implementation-specific description of the AllWeDo client and shared Dart packages as released in AllWeDo 3.1.206. It describes bytes and build gates, not a certification, security proof, or export-classification determination. Published on 20 October 2026. All keys, seeds, phrases and plaintext in the vectors below are deliberately public test material and MUST NOT be used for real data.

1. Conventions and primitive references

|| concatenates octets; U(s) is UTF-8 without a BOM or implicit NUL; A(s) is ASCII. Labels are case sensitive. LP(x) is the four-byte unsigned big-endian octet length of x, followed by x. Integers in label interpolation use decimal with no padding. Hex is lowercase unless a decoder explicitly accepts both cases. H(x) is SHA-256; HH(x) is SHA-256 of the raw 32-byte SHA-256 digest, not of its hex text. M(k,x) is HMAC-SHA256 with key k and message x. Sizes are octets. A KDF's salt is not an AEAD nonce.

The constructions use the following primitives. Each section below names its combination; these references do not standardize AllWeDo's combinations.

Primitive Reference
X25519, 32-byte seed/public/shared secret RFC 7748
HKDF Extract then Expand with HMAC-SHA256 RFC 5869
HMAC RFC 2104
SHA-256 and SHA-512 FIPS 180-4
ChaCha20-Poly1305, key 32, nonce 12, tag 16 RFC 8439
XChaCha20-Poly1305, key 32, nonce 24, tag 16 XChaCha draft-03, an expired Internet-Draft, not an RFC
AES-256 and GCM (tag 128 bits here) FIPS 197, SP 800-38D
AES-CBC SP 800-38A
PBKDF2 RFC 8018, SP 800-132
Ed25519 (no prehash/context mode) RFC 8032
Argon2id version 0x13 RFC 9106
Base64, base64url and base32 alphabets RFC 4648
X.509, RSA and TLS RFC 5280, RFC 8017, RFC 8446, RFC 5246

J(x) means compact Dart jsonEncode, preserving object insertion order; it is not a canonical JSON standard. Arrays preserve element order. Strings are double-quoted. Both J and C escape quote as \", backslash as \\, and U+0008, U+0009, U+000A, U+000C, U+000D as \b, \t, \n, \f, \r. Other U+0000..U+001F controls use lowercase \u00xx. Neither escapes /, U+2028, U+2029 or other Unicode scalars; no Unicode normalization occurs. J escapes lone UTF-16 surrogates as lowercase \udxxx; C refuses them. U(J(x)) and C(x) are UTF-8 bytes without a BOM.

C(x) is AllWeDo's own canonical JSON, not RFC 8785: no whitespace, object keys sorted lexicographically by their unescaped UTF-8 bytes (a shorter prefix sorts first), and arrays in input order. Booleans use true/false; null at the root or in an array uses null. Numbers must have a plain decimal integer spelling matching -?(0|[1-9][0-9]*) and magnitude <= 9007199254740991 (2^53-1). The encoder checks the runtime number's decimal spelling: on the Dart VM even 1.0 is refused; JavaScript may already have erased that distinction.

Canonical encoding refuses null object values (rather than omitting them), non-string or duplicate object keys, noninteger number spellings (including fractions, NaN and infinities), integers outside that bound, lone surrogates in keys or values, cyclic maps/lists, depth greater than 200, and every other type (including sets, dates and arbitrary objects). Root depth is zero; each object value or array element increments depth by one. A shared acyclic subtree is allowed. Strings, booleans, bounded integers, null, arrays and string-keyed objects are the only supported values, subject to these refusals.

“Release” below is source reachability and compile-time defaults, not a claim that an APK/IPA was disassembled. A disabled flag does not prove physical absence from all binary sections.

2. Space-secret wrapping and authenticated wraps

Source: packages/allwedo_e2e/lib/src/e2e_crypto.dart, SpaceSecret and SpaceKeyWrapAuth; the app re-exports the shared implementation. Purpose: deliver a random 32-byte space secret to an X25519 device identity.

  1. Generate a fresh ephemeral X25519 key pair e, compute raw dh = X25519(e.private, recipient.public); reject all-zero DH.
  2. HKDF-SHA256: IKM=dh, salt=e.public || recipient.public (64 bytes), info=A("allwedo-sealed-v1"), output length=44.
  3. Key=output[0:32], nonce=output[32:44]. ChaCha20-Poly1305 encrypts the space secret with empty AAD. It is not XChaCha and uses no BLAKE hash.
  4. Wire=e.public[32] || ciphertext[32] || tag[16], exactly 80 bytes. There is no version byte or transmitted nonce inside this blob.

The anonymous box does not authenticate its sender. The v2 detached Ed25519 signature covers exactly:

A("allwedo-space-key-wrap-v2") || LP(U(spaceId)) || u64be(keyEpoch)
|| recipientX25519Pub[32] || LP(wrappedKey)

The ASCII label is 25 bytes. keyEpoch >= 1. The generic signing builder requires a nonempty wrap; the sealed-box opener requires exactly 80 bytes. The outer exchange carries sigV=2, signer public key (32 bytes) and signature (64 bytes); binary JSON fields use base64. The recipient verifies before adopting the secret and enforces its space authority pin. The strict verifier rejects noncanonical/off-curve/small-order keys and out-of-range scalars as implemented in ed25519_strict.dart; registry validators additionally enforce prime-subgroup identity rules. Release: wrap distribution is wired, independent of the chat encryption gate.

3. Space AEAD, chat text and file chunk KDF

SpaceSecret.encrypt/decrypt uses a raw 32-byte space key directly, with no KDF. XChaCha20-Poly1305 uses a fresh random 24-byte nonce by default; the API also permits an explicit 24-byte nonce. AAD is exactly the caller's octets. Wire v1=01 || nonce[24] || ciphertext[N] || tag[16] (N+41 bytes). An empty plaintext is valid (minimum 41). Version 00 and all unknown versions are rejected by the actual decoder, despite outdated source comments.

Chat in lib/data/sync_exporter.dart / sync_importer.dart encrypts UTF-8 message text, AAD=U(channelId + "|" + messageId), and carries padded standard base64 of the complete envelope as text_ct; routing metadata remains outside. The vector's channel ID is deliberately space-test. Release: chat export defaults to !kReleaseMode && E2E_GATE_ON (flag default false), so production release export is disabled. The decoder and shared primitive still exist.

fileKeyFor(chunkSha256) is a separate HKDF-SHA256 helper: IKM=space key, salt=raw 32-byte chunk hash, info=A("allwedo-file-chunk-v1"), L=32. It does not describe the random file-key relay scheme below and has no app caller at this source revision. No push-preview KDF is implemented in this helper.

4. Sync export authentication

Source: lib/data/sync_engine.dart, also shared daemon changeset helpers. Purpose: authenticate compact JSON changesets, not encrypt their contents.

exportKey = M(U(realSecret), U("allwedo-export-v4:" + spaceId))
signature = hex(M(exportKey, U(J(changesetWithoutSignature))))

The stored space-secret string is normally 64 hex characters, but this KDF uses its UTF-8 text, not decoded key bytes. This is a fixed-label HMAC KDF, not HKDF. signature is 64 lowercase hex characters in the top-level JSON object. Version defaults to changeset v3; the version function argument does not select another KDF. Map order matters: remove only signature, then re-encode. No nonce, salt, AAD or tag truncation. Missing secret refuses signing; the normal export path fails closed. Release: active, including plaintext chat changesets. Backup imports and ordinary server-origin ingress paths explicitly use skipHmac:true (the relay may reserialize changesets). Thus this MAC is produced on export but is not a mandatory check on every receive transport; server provenance/admission is a separate boundary.

5. File relay encryption and file-move proofs

Source: lib/data/file_blob_crypto.dart. Purpose: encrypt immutable relay bodies reproducibly. Each file gets a random 32-byte key fk. Its key wrap is the §3 envelope of fk under the space key with random nonce and AAD=U(J(["allwedo-file-key-v1",spaceId,fileId])). The 73-byte wrap is padded standard base64 (100 characters).

Blob AAD is U(J([label,spaceId,fileId,originalName,mimeType,sizeBytes,sha256, memberId?])), in that exact order. label="allwedo-file-blob-v1" when memberId is null (omitted); otherwise label=allwedo-file-blob-v2 and memberId is the final array element, including an empty string if supplied. sha256 here is the caller's text field, not decoded bytes.

nonceKey = M(fk, U("allwedo-file-nonce-key-v1"))
nonce = M(nonceKey, U("allwedo-file-nonce-v1") || H(aad) || H(plaintext))[0:24]
body = 01 || nonce || XChaCha20-Poly1305(fk, nonce, plaintext, aad).ct || tag
blobRef = hex(H(body))

This two-HMAC composition is not HKDF. Relay identity names the encrypted body; repeated identical inputs reproduce the name. Release: enabled = !kReleaseMode && FILE_E2E_BLOB_V1 (default false), so disabled in release.

lib/data/file_reparent_proof.dart independently authenticates a move while the source secret is still held. Key=M(U(secret),U("allwedo-file-reparent-key-v1:" + from)); MAC=hex(M(key,U(J(["allwedo-file-reparent-v2",from,to,fileId, publisherId,authorId,sha256,sizeBytes,epoch,sourceUpdatedAt])))). Output object has authorMemberId, epoch (UUID-shaped), sourceUpdatedAt, mac. No encryption, nonce or salt. Release: called by file staging/import/purge; it is independent of the file encryption flag.

6. Agent bridge cursors

Source: lib/agent/agent_bridge.dart. A per-install random 32-byte key is stored as standard base64 at agent_bridge_cursor_key_v1. Plaintext=u64be(rowId) (8 bytes); nonce=M(key,plaintext)[0:12]. AES-256-GCM uses the same key, that nonce, AAD=01, tag=16. Token=base64urlNoPad(01 || nonce[12] || ct[8] || tag[16]), 37 decoded bytes. The receiver authenticates, checks nonnegative signed-64-bit row range and recomputes the deterministic nonce. Old decimal and 43-character HMAC tokens restart from position zero. No KDF or salt. Release: maybeStart refuses kReleaseMode; enabling AGENT_BRIDGE cannot bypass that guard. The app entry point references it; source alone does not establish whether every cursor helper is tree-shaken from a particular release artifact.

7. Personal keys and person content

These features have independent OWN_* flags, default false. They are not unconditionally excluded by kReleaseMode: a release built with the required flags can enable them. Do not describe default-disabled code as absent.

7.1 Recovery envelope

Source: lib/security/person/recovery_envelope.dart. For a normalized checked phrase p and nonempty person ID, recipient X25519 seed is HH(U("aw-own-recovery-envelope-key-v1") || LP(U(personId)) || U(p)). Generate a fresh ephemeral X25519 pair, reject zero DH; AES key= H(U("aw-own-recovery-envelope-dh-key-v1") || dh) (32). This is SHA-256 concatenation, not HKDF; there is no salt/info parameter. Random nonce=12; AES-256-GCM AAD=U("aw-own-recovery-envelope-v1:" + personId + ":" + version). Wire=base64urlNoPad(ephPub[32] || nonce[12] || tag[16] || ct[N]). No binary version byte; version is an external epoch bound by AAD. Seal requires version>=1 and plaintext 1..6000 bytes; opener decoded length 61..6144 and canonical unpadded base64url. Release: person-key flows, default disabled.

7.2 Device epoch catalog envelope

Source: device_epoch_envelope.dart. Fresh ephemeral X25519 to canonical recipient device key, zero DH refused. AES key= H(U("aw-own-device-epoch-key-v1") || dh). Nonce=random 12; AAD=U("aw-own-device-epoch-v1:" + personId + ":" + version + ":" + deviceId). Same ephPub || nonce || tag || ct ordering and canonical unpadded base64url as §7.1; plaintext nonempty; no HKDF, salt or internal version byte. Release: person epoch key distribution, default disabled.

Source: own_link_provisioning.dart. Fresh ephemeral X25519; zero DH refused. AES key=H(U("aw-own-link-provision-key-v1") || dh), random nonce=12, AES-256-GCM tag=16. AAD=C(context) where context has exactly: protocolVersion:1, domain:"aw-own-link-provision-v1", personId, sessionId, acceptedEventId, recipientDevice, recipientEd25519Key, recipientX25519Key, scope:"person-content". Identity fields come from the validated QR and accepted transcript; recipient key text is hex. The output is these nine fields plus ephemeralPubkeyB64, boxNonceB64, ciphertextB64, macB64 (canonical padded standard base64). Plaintext 1..4096; canonical full envelope at most 8192 bytes. acceptedEventId must equal the protocol's add-event digest. Release: OWN_LINK flow, default off.

7.4 Own-device possession challenge

Source: device_proof_crypto.dart. Client opens the server's challenge using its 32-byte X25519 seed; canonical registry identities and nonzero DH required. AES key=H(U("aw-own-proof-box-v1") || dh); nonce=12, AES-GCM tag=16. AAD=C(transcript). The transcript contains protocolVersion:1, domain:"aw-device-proof-v1", and the following fields: personId, sessionId, spaceId, memberId, membershipGeneration, deviceId, ed25519Key, x25519Key, challengeNonce, challengeDigest, genesisHash, provisioningDigest, scope. membershipGeneration is a positive bounded integer; the five ID fields match [A-Za-z0-9._:-]{1,128}, excluding . and ... Key/digest values are 32-byte lowercase hex; challengeNonce is nonzero 32-byte lowercase hex. scope is person-content or space-continuity. The validated transcript is canonicalized as a whole; any additional accepted fields are also covered by C, rather than silently dropped. If present, extensions must be an object. The fixture in §14 has exactly these fields. The challenge carries canonical padded standard-base64 ephemeralPubkeyB64 (32), boxNonceB64 (12), ciphertextB64 (32), macB64 (16). Decrypted answer is 32 bytes and hex(H(answer)) must equal transcript challengeDigest. No HKDF/salt. Release: own-registry proof flow, default disabled. The client contains the opener; the fixed interoperability vector includes the sender fixture.

7.5 Person content

Source: person_content_crypto.dart, person_wire.dart. A resolver supplies a 32-byte pck or dk epoch key. XChaCha20-Poly1305 uses random nonce=24, tag=16. AAD=C({domain:"allwedo/person/content-aad/v1",personId,continuityId, keyDomain,contentEpoch,authorDevice,registryHead,opId}). The v1 person envelope contains those seven header fields, protocolVersion:1, domain:"aw-person-envelope-v1", nonce (48 lowercase hex characters), ciphertext=base64urlNoPad(ct||tag), ciphertextHash=hex(H(ct||tag)). The ciphertext hash excludes the nonce and header; the AEAD authenticates the header. No per-message KDF. An inner PersonContentRecord is C({version:1,spaceId,logicalId,payloadB64:base64urlNoPad(payload)}). Release: person store/sync/key flags default false.

8. Backup containers

Source: lib/services/backup_encryption_service.dart. Both formats use AES-256-GCM, 12-byte fresh random nonce, 16-byte tag and empty AAD. Magic/version header bytes are parsed, not included in AAD.

Release: both service functions are compiled from normal app paths; actual use depends on manual export choice and platform auto-backup availability. The vector test injects an explicit byte stream through the existing test RNG argument; production defaults to Random.secure().

9. Database encryption and auxiliary database keys

Source: lib/data/database_crypto.dart, pubspec.yaml sqlite3 hooks. Purpose: database encryption at rest. The app generates/stores 32 random bytes, passes 64 lowercase hex characters using PRAGMA cipher = 'sqlcipher', PRAGMA key = "x'...rawKeyHex...'", then PRAGMA cipher_compatibility = 4, in that order. Raw-key mode bypasses the password-to-encryption-key PBKDF2; it does not mean that the native format has no salt or authentication-key derivation. The app does not implement page encryption or override its IV, page salt, AAD, padding or HMAC input. The native dependency is sqlite3 3.1.5 selecting sqlite3mc, not an app-level AES envelope and not the obsolete no-op sqlcipher_flutter_libs plugin. The configured native scheme's page format is owned by its SQLCipher codec documentation.

The host test calls the actual DatabaseCrypto.applyKey on a fresh file using that bundled native library, then records its effective parameters. It reports cipher=sqlcipher, legacy=0, legacy_page_size=4096, page_size=4096, kdf_iter=256000, fast_kdf_iter=2, hmac_use=1, hmac_pgno=1 (little endian), hmac_salt_mask=58 (0x3a), kdf_algorithm=2 and hmac_algorithm=2 (SHA-512), plaintext_header_size=0. Thus the application's cipher_compatibility=4 request must not be read as proof of sqlite3mc legacy=4; the observed setting is legacy=0. The native SQLCipher cipher uses AES-256-CBC with a 16-byte per-page random IV and a 64-byte SHA-512 HMAC, 80 reserved bytes per page. The format's random salt is 16 bytes; the native HMAC subkey uses two PBKDF2 rounds and the salt XOR mask 0x3a. No GCM AAD or AllWeDo message version exists in these pages. Native layout details and legacy-mode differences are the vendor codec's contract; source comments claiming unconditional Zetetic SQLCipher-4 interchangeability are not adopted by this specification.

The main database encryption path is active in release; plain-SQLite tests can accept unknown pragmas as no-ops. applyKey with empty input skips keying. Availability is checked using PRAGMA cipher with a legacy cipher_version fallback; a successful unknown pragma alone is not evidence of encryption.

Auxiliary keys are fixed-label HMAC-SHA256, L=32 (no nonce/salt/HKDF):

10. PIN hashing and recovery phrases

lib/utils/pin_utils.dart: Argon2id 0x13, memory=2^15 KiB (32 MiB), time=4, parallelism=1, output=32, salt=hex-decoded 16 random bytes. Input is U(pin + ":" + pepper); the device pepper is stored separately. Stored form is argon2id$v=1$m=15,t=4,p=1$ followed by 64 lowercase hash hex characters. Here v=1 is the app's format label (not Argon2 version 1) and m=15 is an exponent (not 15 MiB/KiB). The salt is stored separately. Verification uses the current configured parameters; this string is not the standard PHC form. Legacy hashPin computes hex(H(U(salt + ":" + pin))); live PIN verification refuses legacy hashes. Release: Argon2id active.

packages/allwedo_core/lib/src/membership/seed_phrase.dart: current wordlist version=3, ordered 2048-word BIP39 English vocabulary. This is not BIP39 seed derivation: pick 11 independent random indices, then compute h=H(U("allwedo-v2-checksum:" + first11.join(" "))); 12th index=(u32be(h[0:4]) & 0x7fffffff) % 2048. Entropy is 121 bits before the checksum, not 128 or 132. The vocabulary is BIP-0039 English. Its SHA-256 is 2f5eed53a4727b4bf8880d8f3f199efc90e58503646d9ff8eff3a2ed3b24dbda for the ordered 2048 lowercase words, one per LF-terminated line including the final LF, with no BOM (UTF-8/ASCII). Normalize by trim().toLowerCase().split(RegExp(r"\s+")).join(" "). The historical function suffix “V2” is independent of wordlist version 3.

Derivations from normalized phrase p (raw double SHA-256, no salt/stretching):

Release: phrase recovery and identity functions are wired. Public fingerprint bytes must not be reused as a private signing or encryption seed.

11. SAS and call verification

sas_kdf.dart: HKDF-SHA256, IKM=nonempty caller input, salt=empty, info=U("AllWeDo-SAS-v1"), L=6. Take the first five output bytes, encode most-significant-bit first with RFC 4648 uppercase base32, no padding; format eight letters/digits as XXXX-XXXX. The sixth byte is discarded. No nonce/AAD/encryption. Callers bind session context in their input as described in §13.1. Release: pairing/cosign code exists; own-link SAS is under its default-disabled feature flag.

call_verify_emoji.dart: order the two nonempty DTLS fingerprint byte strings lexicographically by raw octets; sharedCallSecret=H(first||second). HKDF-SHA256 IKM=that digest, salt=empty, info=U("AllWeDo-CallVerify-v1"), L=4. Each output byte directly indexes the application's fixed ordered 256-entry emoji alphabet. This section describes the derivation; it does not enumerate that display alphabet or specify emoji interoperability. The helper accepts arbitrary nonempty input. SDP/provider preparation follows. call_verify_sdp.dart parses the first usable a=fingerprint: colon-hex line without enforcing the named hash algorithm or a 32-byte length. When either fingerprint is unavailable, it instead feeds UTF-8 ufrag + ":" + pwd from each SDP through the same sort/hash/KDF and returns source=iceCredentials, isAttested=false. These public SDP values are not secret-to-call key material. No encryption or transmitted tag. Release: call_provider.dart invokes this derivation.

12. LAN TLS, authentication and other keyed transcripts

lan_cert_manager.dart, lan_tls.dart: per-device RSA-2048 keypair and self-signed X.509 certificate, generated through basic_utils, default validity 365 days, renewal window 30 days. Subject CN=allwedo-lan-<epochMs>, O=AllWeDo, OU=LAN Sync; CSR/certificate signing use basic_utils 5.7.0's SHA-256/RSA defaults (RSASSA-PKCS1-v1_5); public exponent 65537, certificate serial defaults to 1. No SAN argument is supplied. The certificate pin is hex(H(certDER)), not a public-key-only hash. Local PEM key/cert are reused; client/server contexts have withTrustedRoots:false. Pinned fingerprint match and end validity are checked; initial pinning occurs in a pairing ceremony. TLS records, cipher-suite negotiation and ephemeral session keys are handled by Dart's platform TLS stack, with no application KDF/AAD or pinned suite in these files. No deterministic TLS handshake vector is claimed. Release: LAN TLS is wired.

LAN space key=M(U(realSecret),U("allwedo-lan-auth-v2:" + spaceId)). Handshake auth key=M(A("allwedo/lan-auth/v2"),spaceKey) — the label is the HMAC key, not its message. Auth version=2. Transcript:

A("allwedo/lan-auth/v2") || u32be(2)
|| LP(U(role)) || LP(U(spaceId)) || LP(U(lowercase(serverCertFingerprint)))
|| LP(U(serverDeviceId)) || LP(U(clientDeviceId))
|| LP(U(serverNonce)) || LP(U(clientNonce))

Role is client or server; nonces are 32 random bytes encoded as 64 hex characters. Mixed-case nonce spellings are preserved; the fingerprint is lowercased. Proof=hex(M(authKey,transcript)). This binds the server certificate and claimed identities, not a TLS exporter/session identifier. Legacy helper signaling proof=hex(M(spaceKey,U(peerId + ":" + timestamp))). LAN frame signing key=M(U(secret),U("allwedo-lan-sign-v1:" + spaceId)); MAC=hex(M(signingKey,U(payload))) over exact serialized frame payload. Release: LAN v2 authentication and frame MACs are wired.

TransportAuthGuard is an additional helper with no production constructor caller at this revision. Key=M(U(secret),U("allwedo-transport-auth-v1:"+spaceId)). MAC=hex(M(key,U(nonce + "|" + ts + "|" + J(payload)))). Envelope=J({v:1,nonce,ts,mac,payload}). Despite its old comment, the nonce is not random: first 32 hex characters of H(key[0:8] || U(microseconds + "|" + seenNonces.length + "|" + key.length + "|" + payloadCounter)); counter increments after generation. Its replay window is ±5 minutes, bounded 4096 nonce cache plus eviction timestamp floor. No encryption/AAD. Release: unused helper; do not infer protection for stub transports from its presence.

Other active HMAC compositions (full 32-byte output as lowercase hex):

Purpose/source Key bytes Message bytes / format
Space-scoped device ID, device_id_resolver.dart U(baseDeviceId) U("aw-device-v1:"+spaceId)
HTTP /auth and device registration, api_client.dart U(deviceToken) or build sync secret for registration/legacy path U(spaceId+":"+deviceId+":"+epochMilliseconds); signature in JSON
Entitlement verification, entitlement_signature.dart U(signKey) U([spaceId,status,UTC(expiresAt),UTC(graceStartedAt),UTC(signedAt)].join("|")); null timestamp=""; UTC uses Dart toIso8601String()

These have no nonce-derived encryption, HKDF, salt or AAD. Timestamp fields are text within the MAC message. Entitlement verification additionally refuses signedAt more than 60 seconds in the future.

13. Catch-up proofs and signatures

Shared core catch_up_proof.dart: raw 32-byte space secret (not UTF-8 hex), HKDF-SHA256 salt=empty, info=A("allwedo-catchup-proof-v1"), L=32. Key fingerprint=hex(H(A("allwedo-space-key-fp-v1")||secret)[0:16]). MAC=hex(M(proofKey,A("AWD-CU1")||typedEncoding)). No encryption/nonce/AAD. Protocol version=1.

Typed encoding is u32be(fieldCount)||LP(field1)||.... Strings are UTF-8, integers nonnegative decimal ASCII (<=2^53-1), booleans ASCII 1/0. Hex IDs are lowercase text, not decoded bytes. Lists are bytewise sorted, duplicates refused, and encoded as a nested field sequence. Request order: v,space,id,at,fresh,kf; slice order: v,space,walk,for,i,last,skipped,rows,rowsDigest,src,kf. Space comes from authenticated context and does not travel in the proof object; MAC is a separate JSON field excluded from the encoding. IDs/kf are 32 hex, rowsDigest/mac 64 hex; device IDs preserve case and use 1..128 ASCII [A-Za-z0-9._:-]. This is a summary of catch-up authentication. Release: catch-up protocol is wired in sync, separate from the chat AEAD flag.

Ed25519 is used for device identity, /auth binding, key publication, signed wraps, membership checkpoints, row attestations, recovery and capability tokens. Seeds/public keys are 32 bytes, signatures 64; these are detached Ed25519, not Ed25519ph. /auth binding message is U(spaceId+"|"+deviceId+"|"+signedAtMs), and key publication proof is U("allwedo-ed25519-publish-v1|"+spaceId+"|"+deviceId+"|"+pubkeyB64). Capability tokens use libsodium detached Ed25519 over their own canonical payload. PersonWire signatures use validated C(document) with the explicit protocolVersion:1 and per-type domain. Registry events, admission bindings, receipts and key commits use distinct domain-bound builders. This document summarizes those signature formats; it does not specify every signing builder. These signatures are not interchangeable. There is no encryption nonce, AEAD AAD, salt or info for raw Ed25519 signing. Release: existing device identity/wrap paths are wired; new own-person paths default off. The unconnected member-removal-v1 helper in the shared E2E file is included as a dormant construction, not asserted as active authorization.

13.1 Additional signed formats and task AEAD

Additional signature formats and authentication contexts:

packages/allwedo_tasks/lib/src/task_v2_envelope.dart encrypts task event bodies with the raw space epoch key using the §3 XChaCha envelope. AAD=U(J(["allwedo-task-row-v2",2,kind,id,revision,spaceId,writerMemberId, keyEpoch])), plaintext=U(J(body)). Outer JSON has exactly v:2,kind,id,revision,spaceId,writerMemberId,keyEpoch,ct; ct is padded standard base64 of 01||nonce24||ct||tag16. The body repeats the seven identity/header fields, checked on seal/open. Kinds are todo, assignee, report, review, file; keyEpoch>=1; encrypted bytes length 41..262144. Nonce defaults random and the existing API also accepts an explicit 24-byte nonce. TaskV2Flags default false for receive/projection/create/completionReceipts/files/departedReview/repeat; there is no hard release-mode exclusion. No additional KDF or salt.

13.2 Native restore-key wrapping and platform storage

android/app/src/main/kotlin/app/allwedo/RestoreKeyDurability.kt, called by MainActivity's restore storage methods, wraps a 32-byte staged database key under an AndroidKeyStore AES key with alias allwedo_restore_key_durability_v1. It requests AES/GCM/NoPadding and randomized encryption, with no explicit AES key size in this source. The provider creates the IV; persist requires 12 bytes. AAD is exact UTF-8 storage name, matching ^db_passphrase_restore_[0-9a-f]{32}$. The no-backup file is 01||iv12||ct32||tag16 (61 bytes); open requests a 128-bit tag. There is no application KDF/salt. Native API requires Android M or later; this path is wired in Android release. Keystore keys are non-exportable through this API; this does not establish hardware backing. Randomized Keystore generation is not a deterministic host Dart vector.

The normal SecureStore is a platform/plugin service, not another AllWeDo AEAD wire format. Android requests resetOnError:false and migrateOnAlgorithmChange:false; ordinary pinned-plugin defaults request RSA OAEP with SHA-256/MGF1 and AES-GCM, while BYOK entries explicitly request RSA ECB PKCS1 padding with AES-GCM. Existing saved cipher selection is retained by the project's plugin compatibility patch; these are configuration requests, not a claim that every saved entry uses the newest default. iOS uses the Keychain API. No platform private key or storage-encryption master key is included in this specification. Personal-AI's database uses its independent random 32-byte secure-store key, then the same database cipher configuration as §9 (not the main database's key).

Server connections use platform TLS; call media uses WebRTC DTLS-SRTP, implemented by the platform and WebRTC libraries.

14. Executable public vectors

The JSON below contains synthetic fixtures exercised by the production specification test. The public-edition test independently reconstructs every encryption vector from this page's stated inputs and primitive parameters, without application encryption codecs. Deterministic fixtures use ascending byte arrays, fixed nonces or the explicit ByteStream test RNG (nextInt returns successive 0..255 modulo the requested bound). No production randomness is changed. Where an API hardcodes Random.secure, a fixed sender fixture is checked by the production opener; the neighboring tests exercise randomized production sealing too. Native database pages and TLS handshakes are not portable deterministic byte fixtures; their configuration and behavior have separate tests.

All omitted cross-vector inputs are fixed here; no source file is needed to reproduce an encryption vector. seq(n,start) means the n bytes start,start+1,...,start+n-1 modulo 256. Hex fields decode to bytes; base64 fields decode with their named alphabet, adding padding only for a base64url decoder that requires it. All identifiers are literal, case-sensitive text. Unless overridden in the table below, encryption plaintext is inputs.plaintextHex. The task plaintext is U(taskV2.plaintextJson); the device-proof plaintext is base64Decode(fixture.challengeResponseB64).

Vector Key, nonce, identity and other inputs
sealedWrap (§2) Space secret to wrap is inputs.keyHex; recipient seed is inputs.recipientSeedHex; ephemeral seed is sealedWrap.ephemeralSeedHex. Empty AAD; derived nonce.
chat (§3) Key=inputs.keyHex, nonce=inputs.nonce24Hex; channelId=inputs.spaceId, messageId=inputs.messageId.
fileChunkKeyHex (§3) Key=inputs.keyHex; chunk hash bytes=seq(32,64) (hex 404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f), an arbitrary synthetic hash input.
fileV1, fileV2 (§5) Space key=inputs.keyHex; file key=fileKeyHex; key-wrap nonce=seq(24,24); spaceId=inputs.spaceId, fileId=file-test, originalName=test.txt, mimeType=text/plain, sizeBytes=23, sha256=hex(H(plaintext)); memberId omitted for V1, member-test for V2. Blob nonce is derived.
backup (§8) AWDE password=backup.passphrase, salt=seq(16,0), nonce=seq(12,16); AWDK key=inputs.keyHex, nonce=seq(12,0). Empty AAD.
bridgeCursor (§6) Key=inputs.keyHex, rowId=207; plaintext=u64be(207); deterministic nonce and AAD=01.
recoveryEnvelope (§7.1) Phrase=phrase.normalized, personId=person-test, version=7; seeds are the named vector fields; nonce=seq(12,0).
deviceEpochEnvelope (§7.2) personId=person-test, version=7, deviceId=device-test; seeds are the named fields; nonce=seq(12,0).
deviceProof (§7.4) The fixture contains all seed, nonce and plaintext inputs; recipient seed=x25519SeedB64, ephemeral seed=ephemeralSeedB64, nonce=boxNonceB64, AAD=C(fixture.transcript).
taskV2 (§13.1) Key=inputs.keyHex, nonce=inputs.nonce24Hex; AAD fields come from taskV2.envelope in the order specified in §13.1.
personContent (§7.5) Key=inputs.keyHex, nonce=inputs.nonce24Hex; the seven identity/header fields come from personContent.envelope, with AAD domain from §7.5. Inner record uses spaceId=inputs.spaceId, logicalId=logical-test, payload=inputs.plaintextHex; it is a separate encoding example, not this vector's encrypted plaintext.
ownLink (§7.3) Seeds are ownLink.ephemeralSeedHex and ownLink.recipientSeedHex; nonce=seq(12,0); the nine AAD context fields are in ownLink.envelope. acceptedEventId and recipient identities are supplied fixture inputs for this encryption example.

The other groups illustrate hashes, key derivation, authentication, signatures or observed configuration; they are not additional encryption envelopes. wrapSignatureV2, signedTranscripts and capability use inputs.keyHex as their synthetic Ed25519 seed. Signature examples with a messageHex or unsignedHex field supply their serialized message directly.

For the sealed-wrap fixture, the pinned Dart backend fills the ephemeral 32-byte seed from eight big-endian 32-bit RNG words. ByteStream supplies words 0 through 7, so this seed is not the ascending byte array 0 through 31. The tests derive the public key from the documented seed, check it against the actual production wrap prefix, and independently reproduce all 80 wrap bytes using the documented seeds, X25519, HKDF and AEAD parameters.

{
  "inputs": {
    "keyHex": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
    "recipientSeedHex": "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
    "nonce24Hex": "000102030405060708090a0b0c0d0e0f1011121314151617",
    "plaintextHex": "416c6c5765446f207465737420766563746f7220323037",
    "spaceId": "space-test",
    "messageId": "message-test"
  },
  "sealedWrap": {
    "ephemeralSeedHex": "0000000000000001000000020000000300000004000000050000000600000007",
    "ephemeralPubHex": "5b54e8de57dd331f5b9568c717d72ebd0e93a1bdd9803e99acaa44195a301026",
    "recipientPubHex": "358072d6365880d1aeea329adf9121383851ed21a28e3b75e965d0d2cd166254",
    "wrapHex": "5b54e8de57dd331f5b9568c717d72ebd0e93a1bdd9803e99acaa44195a301026b40f1fcdc1c6fe8b6e1ad89419656fdb063412e86d9ae309c320cb7978741e1557d7cb4ac724feea05611e545559fe9b"
  },
  "chat": {
    "aadHex": "73706163652d746573747c6d6573736167652d74657374",
    "envelopeHex": "01000102030405060708090a0b0c0d0e0f1011121314151617dfae6328f596e28e472155baeb24cd8b3f285a85cfe62a0cff886ec926e016b6a9c2193e34fdf6"
  },
  "fileChunkKeyHex": "f2f31df43f5e288b1b2b573700218db1a83ba6aec0bb01bfcf4d7860b7327396",
  "fileV1": {
    "fileKeyHex": "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f",
    "blobAadHex": "5b22616c6c7765646f2d66696c652d626c6f622d7631222c2273706163652d74657374222c2266696c652d74657374222c22746573742e747874222c22746578742f706c61696e222c32332c2239623462373636626138626464663234656533666239376432656265343539666162303433666234333430306365306331333033663661326437626532353034225d",
    "keyAadHex": "5b22616c6c7765646f2d66696c652d6b65792d7631222c2273706163652d74657374222c2266696c652d74657374225d",
    "wrappedKeyB64": "ARgZGhscHR4fICEiIyQlJicoKSorLC0uLxBLOZ8pPYEBmbXOxkzpRruWp5Jk9J5SJXS648TGzvWrnjBo8aMwT4EVhiw9T+LFEg==",
    "nonceHex": "8349f951cadb9b470f7f9a0314b25452e4bb95b88f5dc75c",
    "envelopeHex": "018349f951cadb9b470f7f9a0314b25452e4bb95b88f5dc75c0d2f113ddc7680f7e018d0d08059c3564cfda1194c079cabe456bcf0fc7cbc3af4b0a08c836d8a",
    "blobRef": "befbb21862d00033d0f341c13cfa63d434dc93a4ad060cb5d608248700fed0f2"
  },
  "fileV2": {
    "fileKeyHex": "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f",
    "blobAadHex": "5b22616c6c7765646f2d66696c652d626c6f622d7632222c2273706163652d74657374222c2266696c652d74657374222c22746573742e747874222c22746578742f706c61696e222c32332c2239623462373636626138626464663234656533666239376432656265343539666162303433666234333430306365306331333033663661326437626532353034222c226d656d6265722d74657374225d",
    "keyAadHex": "5b22616c6c7765646f2d66696c652d6b65792d7631222c2273706163652d74657374222c2266696c652d74657374225d",
    "wrappedKeyB64": "ARgZGhscHR4fICEiIyQlJicoKSorLC0uLxBLOZ8pPYEBmbXOxkzpRruWp5Jk9J5SJXS648TGzvWrnjBo8aMwT4EVhiw9T+LFEg==",
    "nonceHex": "5c192a179fa4c5de58cec1374a5f8bea7d724550f08cf761",
    "envelopeHex": "015c192a179fa4c5de58cec1374a5f8bea7d724550f08cf761a7608154ee11b09bdaab88f89a3056ca3074b84ec1934aeec5f7e751c5cead2f0b7d343c39e5ce",
    "blobRef": "ead41928b85ba0cc654a2f5175be08e9f6610d6d56151bd4eec4d800628ca15b"
  },
  "wrapSignatureV2": {
    "messageHex": "616c6c7765646f2d73706163652d6b65792d777261702d76320000000a73706163652d746573740000000000000007358072d6365880d1aeea329adf9121383851ed21a28e3b75e965d0d2cd166254000000505b54e8de57dd331f5b9568c717d72ebd0e93a1bdd9803e99acaa44195a301026b40f1fcdc1c6fe8b6e1ad89419656fdb063412e86d9ae309c320cb7978741e1557d7cb4ac724feea05611e545559fe9b",
    "publicKeyHex": "03a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b8",
    "signatureHex": "19f75c6ae7b17707f4259405b432384a16f4271f44026837ff7694f4d5cca1a396210c7d4fb7a8ead008b3d722d89380753d202d8de9816dd7f771656d567a0b"
  },
  "backup": {
    "passphrase": "public-test-passphrase",
    "pbkdf2KeyHex": "a3d7df0c5667e3c5268ad03122c11465620fb6ecd9bd78936a2c87faaf2f5ac9",
    "awdeHex": "4157444501000102030405060708090a0b0c0d0e0f101112131415161718191a1b81217848b684141f3f01edbb37dae758396a24c87646f98372e851c5110b751edb40ca2f163039",
    "awdkHex": "4157444b01000102030405060708090a0b066eba4ca0a1ad3bf924e4ff919f1d0ef7b9f514c24b68d443c6da968b7ef6a4d664ce94949a12"
  },
  "pin": {
    "pin": "1234",
    "saltHex": "000102030405060708090a0b0c0d0e0f",
    "pepper": "public-test-pepper",
    "encoded": "argon2id$v=1$m=15,t=4,p=1$d407e8cc0bfeb63f8d6c5db554aab952237bdd0473f453499907101a0a03217e"
  },
  "sas": "AMEA-O7VI",
  "callVerify": {
    "sharedSecretHex": "fdeab9acf3710362bd2658cdc9a29e8f9c757fcf9811603a8c447cd1d9151108",
    "emojis": [
      "🍝",
      "🐹",
      "🦁",
      "💀"
    ]
  },
  "phrase": {
    "normalized": "abandon ability able about above absent absorb abstract absurd abuse access acid",
    "identityHex": "bdf6d647326f804bd855ee1d73d3bd476ec66ed76ac355922ebf6c7c4e4cf28a",
    "recoveryIdentitySeedHex": "c2c7ae7b8ac44d3aeda4a733fc7452e47e4a3fa678ac2e1d29c6b6f0f4cf3f81",
    "recoveryRootSeedHex": "0f29bec8149df490b58a8954e873b4a239e5eb8b8566f196d7dcf2e07d388cc4"
  },
  "databaseSubkeys": {
    "registryHex": "c4e6bfcf13f7319597a4cd68e098b366f8946e4f3a090c697bf583c6ca6decd6",
    "personHex": "11a49bb41830bd770980bf50c91a2752dd67f52d253bfa78adf278c9fc4339b8"
  },
  "deviceId": "5d6149c120a00f582ceb4655cbbdb363cfb61726b87f1d617226501101cee098",
  "entitlement": "4a2b3710fe4aa28bae595b6f23798940da54a3a659a14957ed83f2fbc763a15a",
  "fileReparent": {
    "authorMemberId": "author-test",
    "epoch": "00000000-0000-4000-8000-000000000001",
    "sourceUpdatedAt": "2026-01-01T00:00:00.000Z",
    "mac": "ba94d14be50c962ed022f8f2490adf6fe41b151728d4db479c583b16c70ebbfc"
  },
  "lan": {
    "spaceKeyHex": "aca0e15ba5ee3b48eba94e05960d8239f78aaae6031493c160a98641d2798ddd",
    "authKeyHex": "4f807f52d52fd3e723f5be28fc616736fad5952527b7a318f3739fd969458cf9",
    "transcriptHex": "616c6c7765646f2f6c616e2d617574682f76320000000200000006636c69656e740000000a73706163652d7465737400000040616261626162616261626162616261626162616261626162616261626162616261626162616261626162616261626162616261626162616261626162616261620000000b7365727665722d746573740000000b636c69656e742d7465737400000040303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130313031303130310000004030323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032303230323032",
    "proof": "ef366509bbd50f7bc909b47256887709d428f7dfaf6012d43f69a601eea12f1a"
  },
  "transportGuard": {
    "keyHex": "9446b1f675d17d05ed389eeda8e562f59ea2b7594084707cdbbbafac69a7788b",
    "envelope": "{\"v\":1,\"nonce\":\"bcdd3f34aebec72bd22020aaf6ec366e\",\"ts\":1767225600000,\"mac\":\"bf5725417aae3a2e3496100cacdd0928c78dddfa0053881d41af81fb95a13f8c\",\"payload\":{\"test\":207}}"
  },
  "sync": {
    "secretText": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
    "payloadJson": "{\"version\":3,\"nodeId\":\"test-node\"}",
    "derivedKeyHex": "c37b8980f31f9eb93189fc5d5a3b245550eea82d3c8ca4e19ca1953e184b04d9",
    "signature": "571fb697ebfc54ef8cae466905e9d898172f5e3e7f23309f690db15519ffda1b"
  },
  "bridgeCursor": "AX57r57Uw6IeE8w_116eMyv4B6cGU5UzGViFCcYEzIFpvSftiQ",
  "recoveryEnvelope": {
    "ephemeralSeedHex": "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f",
    "recipientSeedHex": "401eb54185bd6b3822ec7371f6690f25b50fb2c91c284f456e2e55f20560e738",
    "dhHex": "4af6215c4d737b4c8e3ba23ab7dbcb291a184ddce4b9619d37ca4bfa540a7c56",
    "aesKeyHex": "c37c3ddbb42c1274c106f7058eb9a8a83016031636b8fc2a5d0256402b59d346",
    "aadHex": "61772d6f776e2d7265636f766572792d656e76656c6f70652d76313a706572736f6e2d746573743a37",
    "envelopeB64url": "Z13VdO13iTELPS52gfN5C0ZsdzsVIf7PNld5WDcepS8AAQIDBAUGBwgJCgtiiZR9FSbto2Hm8P-8BWuifRAzzWMOFc2orFMx-EJbqsKWlDhw_hE"
  },
  "deviceEpochEnvelope": {
    "ephemeralSeedHex": "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f",
    "recipientSeedHex": "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
    "dhHex": "7c79d7b5f31b9aac367477f5f7c7a68b5c44cac28ed5c902a59ec48c02956a6a",
    "aesKeyHex": "4706c9a37404fbe2c6f59920e7f2f25768dc9ab10fc9299ffca1a76473b7b34f",
    "aadHex": "61772d6f776e2d6465766963652d65706f63682d76313a706572736f6e2d746573743a373a6465766963652d74657374",
    "envelopeB64url": "Z13VdO13iTELPS52gfN5C0ZsdzsVIf7PNld5WDcepS8AAQIDBAUGBwgJCgsOW4mxIUIqTMzbjxid7xR8QXwk4v0ShLpvsfiQnYiljwfFhX61MSQ"
  },
  "deviceProof": {
    "fixture": {
      "boxNonceB64": "BgYGBgYGBgYGBgYG",
      "challengeResponseB64": "BQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQU=",
      "ciphertextB64": "RGNF2vL4cGsVOWi48IVV76TOiYj3Z7wlSJYLRm8dlpI=",
      "ed25519SeedB64": "AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=",
      "ephemeralPubkeyB64": "Xf7dO2vUf2+ijuFdlp1bsOpTd01Ii9r53xxuASSz7yI=",
      "ephemeralSeedB64": "AwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM=",
      "format": "aw-own-device-proof-v1",
      "id": "proof_record_1",
      "macB64": "MV0KcvPkS7i2wGARVKO2jw==",
      "publishPopB64": "gSsnv3LiI57+BX6oCL0xkSCCLn495CbT9+hwBgBmOAQYU7Z6nljSPt48l9YRYwy00OuBDU207s4zuGtjUja2DA==",
      "signatureB64": "3kjy1BAZeYGBKxji5AJ82ZIh+Ds0MfGbl27ufHlWSdVXwTIxS/UVaUiBWuM2vDr0sR1XJY9RLyzuInZAJwqiDQ==",
      "transcript": {
        "challengeDigest": "f849d67325facf04177bc663b2dc544051831c589ef581d412f2eba44834e77c",
        "challengeNonce": "0404040404040404040404040404040404040404040404040404040404040404",
        "deviceId": "device_B",
        "domain": "aw-device-proof-v1",
        "ed25519Key": "8a88e3dd7409f195fd52db2d3cba5d72ca6709bf1d94121bf3748801b40f6f5c",
        "genesisHash": "1111111111111111111111111111111111111111111111111111111111111111",
        "memberId": "member_A",
        "membershipGeneration": 4,
        "personId": "person_A",
        "protocolVersion": 1,
        "provisioningDigest": "6666666666666666666666666666666666666666666666666666666666666666",
        "scope": "person-content",
        "sessionId": "session_1",
        "spaceId": "space_A",
        "x25519Key": "ce8d3ad1ccb633ec7b70c17814a5c76ecd029685050d344745ba05870e587d59"
      },
      "transcriptSha256": "000ce19dc94f4c3ba9fb9b21dc1c3956a93aa51c0cde6a711cb0eadcd4a2f7d1",
      "x25519SeedB64": "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI="
    },
    "openedB64": "BQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQU="
  },
  "taskV2": {
    "plaintextJson": "{\"v\":2,\"kind\":\"todo\",\"id\":\"task-test\",\"revision\":\"revision-test\",\"spaceId\":\"space-test\",\"writerMemberId\":\"member-test\",\"keyEpoch\":7,\"title\":\"Public test task\"}",
    "aadHex": "5b22616c6c7765646f2d7461736b2d726f772d7632222c322c22746f646f222c227461736b2d74657374222c227265766973696f6e2d74657374222c2273706163652d74657374222c226d656d6265722d74657374222c375d",
    "envelope": {
      "v": 2,
      "kind": "todo",
      "id": "task-test",
      "revision": "revision-test",
      "spaceId": "space-test",
      "writerMemberId": "member-test",
      "keyEpoch": 7,
      "ct": "AQABAgMEBQYHCAkKCwwNDg8QERITFBUWF+XgeV2q4KGMWC1IquloipwkI0eH0fR0j10gHcJc3p50KmPFkGNLKxaw48cqpk49QEuYkDwxHYhwaPW+SeqUMNaeAozDafoBzEh9HOMoFWjBPC1o/8BxH7V0508exXQBAQtpFyllWRTp3y9Qsl5jOC4dS6qIknlXRqIUJ2oX5rqBMJ9VYenDIq7u/RVpJOGI4ZotCqB+8Vx1hsZsCeLFsrlqlAk8Rgi2ivELjtJ/HYg="
    }
  },
  "catchUp": {
    "fingerprint": "54b196badef353c3bea32b0a3b6c0cfb",
    "request": {
      "v": 1,
      "id": "01010101010101010101010101010101",
      "at": "2026-01-01T00:00:00.000Z",
      "fresh": [
        "device-a",
        "device-b"
      ],
      "kf": "54b196badef353c3bea32b0a3b6c0cfb",
      "mac": "52a1c647df9ba848565ebcd030d2c0b3eff3e0cb66ec69dcb4e0ea5745b19c27"
    },
    "slice": {
      "v": 1,
      "walk": "02020202020202020202020202020202",
      "for": [
        "01010101010101010101010101010101"
      ],
      "i": 0,
      "last": true,
      "skipped": 0,
      "rows": 0,
      "rowsDigest": "0000000000000000000000000000000000000000000000000000000000000000",
      "src": "device-a",
      "kf": "54b196badef353c3bea32b0a3b6c0cfb",
      "mac": "754edaf596dbefe1116381a72cec60d974cc894d07607b2b970036908276691b"
    }
  },
  "personContent": {
    "aadHex": "7b22617574686f72446576696365223a226465766963652d74657374222c22636f6e74656e7445706f6368223a372c22636f6e74696e756974794964223a22636f6e74696e756974792d74657374222c22646f6d61696e223a22616c6c7765646f2f706572736f6e2f636f6e74656e742d6161642f7631222c226b6579446f6d61696e223a2270636b222c226f704964223a226f702d74657374222c22706572736f6e4964223a22706572736f6e2d74657374222c22726567697374727948656164223a2230303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030227d",
    "envelope": {
      "protocolVersion": 1,
      "domain": "aw-person-envelope-v1",
      "personId": "person-test",
      "continuityId": "continuity-test",
      "keyDomain": "pck",
      "contentEpoch": 7,
      "authorDevice": "device-test",
      "registryHead": "0000000000000000000000000000000000000000000000000000000000000000",
      "opId": "op-test",
      "nonce": "000102030405060708090a0b0c0d0e0f1011121314151617",
      "ciphertext": "365jKPWW4o5HIVW66yTNiz8oWoXP5io90D8peGrHzvDef1KTGl3_",
      "ciphertextHash": "132004b3fb1d71e3a91c027216b92320212ebda853a8bc31c5d0a6acf68c1e23"
    },
    "innerRecordHex": "7b226c6f676963616c4964223a226c6f676963616c2d74657374222c227061796c6f6164423634223a225157787356325645627942305a584e3049485a6c59335276636941794d4463222c2273706163654964223a2273706163652d74657374222c2276657273696f6e223a317d"
  },
  "ownLink": {
    "qr": {
      "protocolVersion": 1,
      "domain": "aw-own-link-qr-v1",
      "sessionId": "11111111111111111111111111111111",
      "personId": "person-test",
      "genesisHash": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
      "spaceId": "space-test",
      "memberId": "member-test",
      "membershipGeneration": 1,
      "authorDevice": "author-test",
      "authorEd25519Key": "8a88e3dd7409f195fd52db2d3cba5d72ca6709bf1d94121bf3748801b40f6f5c",
      "authorX25519Key": "73b2d8b76aa9b53660032bc8f5d8bee3a3ae4e3b3a7fd49ade81f7347a34aa68",
      "registryHeadSeq": 1,
      "registryHeadHash": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
      "scope": "person-content",
      "issuedAt": 1000,
      "expiresAt": 1600,
      "qrSecretB64": "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8="
    },
    "transcript": {
      "protocolVersion": 1,
      "domain": "aw-own-link-v1",
      "invitationDigest": "5ec7395121c0ee59490ca2b6b8228c83a51f19ae37dfecd87f88711cfae9003e",
      "sessionId": "11111111111111111111111111111111",
      "personId": "person-test",
      "genesisHash": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
      "spaceId": "space-test",
      "memberId": "member-test",
      "membershipGeneration": 1,
      "authorDevice": "author-test",
      "authorEd25519Key": "8a88e3dd7409f195fd52db2d3cba5d72ca6709bf1d94121bf3748801b40f6f5c",
      "authorX25519Key": "73b2d8b76aa9b53660032bc8f5d8bee3a3ae4e3b3a7fd49ade81f7347a34aa68",
      "subjectDevice": "subject-test",
      "subjectEd25519Key": "8139770ea87d175f56a35466c34c7ecccb8d8a91b4ee37a25df60f5b8fc9b394",
      "subjectX25519Key": "97c3b10b4d6c133a78ea5dcc1cf6421d3f81ae37b1f628ce14ca6fce7730f333",
      "registryHeadSeq": 1,
      "registryHeadHash": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
      "scope": "person-content",
      "expiresAt": 1600
    },
    "acceptedEventId": "8ac7b7ce2adb4dd97dadf855be9d90fcaf7fe1a921efed500a20f8991a9bd4d1",
    "ephemeralSeedHex": "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f",
    "recipientSeedHex": "0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c",
    "aesKeyHex": "9f4cbf808efaad743c1e74dfbca78c5d06425b6e10524d9f42fc5abef2f15677",
    "aadHex": "7b2261636365707465644576656e744964223a2238616337623763653261646234646439376461646638353562653964393066636166376665316139323165666564353030613230663839393161396264346431222c22646f6d61696e223a2261772d6f776e2d6c696e6b2d70726f766973696f6e2d7631222c22706572736f6e4964223a22706572736f6e2d74657374222c2270726f746f636f6c56657273696f6e223a312c22726563697069656e74446576696365223a227375626a6563742d74657374222c22726563697069656e74456432353531394b6579223a2238313339373730656138376431373566353661333534363663333463376563636362386438613931623465653337613235646636306635623866633962333934222c22726563697069656e745832353531394b6579223a2239376333623130623464366331333361373865613564636331636636343231643366383161653337623166363238636531346361366663653737333066333333222c2273636f7065223a22706572736f6e2d636f6e74656e74222c2273657373696f6e4964223a223131313131313131313131313131313131313131313131313131313131313131227d",
    "envelope": {
      "protocolVersion": 1,
      "domain": "aw-own-link-provision-v1",
      "personId": "person-test",
      "sessionId": "11111111111111111111111111111111",
      "acceptedEventId": "8ac7b7ce2adb4dd97dadf855be9d90fcaf7fe1a921efed500a20f8991a9bd4d1",
      "recipientDevice": "subject-test",
      "recipientEd25519Key": "8139770ea87d175f56a35466c34c7ecccb8d8a91b4ee37a25df60f5b8fc9b394",
      "recipientX25519Key": "97c3b10b4d6c133a78ea5dcc1cf6421d3f81ae37b1f628ce14ca6fce7730f333",
      "scope": "person-content",
      "ephemeralPubkeyB64": "Z13VdO13iTELPS52gfN5C0ZsdzsVIf7PNld5WDcepS8=",
      "boxNonceB64": "AAECAwQFBgcICQoL",
      "ciphertextB64": "mZ7oIBcbaXvb7gNsoa9Lm+h1kU7m/Dk=",
      "macB64": "Pqnr3mdxxSodsVb+7JL4cQ=="
    }
  },
  "nativeDatabaseParameters": {
    "cipher": [
      [
        "sqlcipher"
      ]
    ],
    "legacy": [
      [
        "0"
      ]
    ],
    "legacy_page_size": [
      [
        "4096"
      ]
    ],
    "kdf_iter": [
      [
        "256000"
      ]
    ],
    "fast_kdf_iter": [
      [
        "2"
      ]
    ],
    "hmac_use": [
      [
        "1"
      ]
    ],
    "hmac_pgno": [
      [
        "1"
      ]
    ],
    "hmac_salt_mask": [
      [
        "58"
      ]
    ],
    "kdf_algorithm": [
      [
        "2"
      ]
    ],
    "hmac_algorithm": [
      [
        "2"
      ]
    ],
    "plaintext_header_size": [
      [
        "0"
      ]
    ],
    "page_size": [
      [
        4096
      ]
    ]
  },
  "signedTranscripts": {
    "memberRemoval": {
      "messageHex": "00000019616c6c7765646f2d6d656d6265722d72656d6f76616c2d76310000000a73706163652d746573740000000c7375626a6563742d746573740000000b617574686f722d746573740000000b6465766963652d7465737400000010313030303a303a6e6f64652d7465737400000000",
      "signatureHex": "0144f9c7cd9f399bdbb4a7837e38fa64cc22694f414acff72d31509a413d3320ef3817fec32cb8ae7d3f2e1ff3200586d9f849ad15c5eb53b4ef8aeb65a98700"
    },
    "lanRoster": {
      "messageHex": "616c6c7765646f2d6c616e2d726f737465722d7631000000010000000a73706163652d7465737400000000000000010000019b76daa8000000019b7c010400000000010000000b6465766963652d746573740000000b6d656d6265722d746573740000004061626162616261626162616261626162616261626162616261626162616261626162616261626162616261626162616261626162616261626162616261626162",
      "signatureHex": "4d1494f4363735b3116c54ee8edf4c84503a3b279b53c2aa60906175029e54aa1e31a43f63cacb4fedaf7594d7b00205b635a92533a771412dd35606186ab40c"
    },
    "rowAttestation": {
      "messageHex": "616c6c7765646f2d726f772d6174746573746174696f6e2d7631000000040000000100000005746f646f7300000008726f772d746573740000000a73706163652d7465737400000004313030300000000b6465766963652d746573740000000b6d656d6265722d7465737400000004000000010000001c7b227469746c65223a225075626c69632074657374207461736b227d",
      "signatureHex": "49bc065178601a94f651f1652ec1b3af0e49965c4c26499dcc6c511f30096f873d4304144f60ea2c24e7a3fa3eeab3fbe4ef6a248895084b2f308b15a860e800"
    },
    "recoveryTranscript": {
      "messageHex": "616c6c7765646f2d7265636f766572792d7472616e7363726970742d7631000000126964656e746974792d6368616c6c656e6765000000147075626c69632d746573742d6964656e74697479000000157075626c69632d746573742d6368616c6c656e6765",
      "signatureHex": "8d28293d8111efec7be10c57d2f434a85797ef3ec20d0b00a72b87082b20590fe3f6a378b04322d3ca4c4cc99898ed4d0890c2995ac9a6a5947c7ecf93e7cd0b"
    },
    "fileProvenance": {
      "messageHex": "5b22616c6c7765646f2d66696c652d70726f76656e616e63652d7631222c2273706163652d74657374222c2266696c652d74657374222c226d656d6265722d74657374222c226465766963652d74657374222c227075626c69632d746573742d636865636b706f696e74222c322c22222c226170706c69636174696f6e2f6f637465742d73747265616d222c22646f63756d656e74222c32332c2239623462373636626138626464663234656533666239376432656265343539666162303433666234333430306365306331333033663661326437626532353034222c227075626c69632d746573742d6b65792d656e76656c6f7065222c2230303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030225d",
      "signatureHex": "d190722add509a811ba6bbd2dea0eabb8cb144cadc6d4fcaf6d941bb9ac8f42c33cb1f365d3797e275e680b72a151fcbcfa92dde1708d6e94a224021988a4e03"
    }
  },
  "capability": {
    "unsignedHex": "7b226465766963655f6964223a226465766963652d74657374222c22657870697265735f61745f6d73223a323030302c22686c63223a22313030303a303a6e6f64652d74657374222c226973737565645f61745f6d73223a313030302c226973737565725f6d656d6265725f6964223a22617574686f722d74657374222c226973737565725f7075626b6579223a2230336131303762666633636531306265316437306464313865373462633039393637653464363330396261353064356631646463383636343132353533316238222c226e6f6e6365223a223031303130313031303130313031303130313031303130313031303130313031222c227065726d697373696f6e73223a5b2272656164225d2c22726f6c65223a224d656d626572222c2273636f7065223a2273706163652d74657374222c2273706163655f65706f6368223a372c227375626a6563745f6d656d6265725f6964223a226d656d6265722d74657374222c2274746c5f636c617373223a2273686f7274227d",
    "forCosigHex": "7b226465766963655f6964223a226465766963652d74657374222c22657870697265735f61745f6d73223a323030302c22686c63223a22313030303a303a6e6f64652d74657374222c226973737565645f61745f6d73223a313030302c226973737565725f6d656d6265725f6964223a22617574686f722d74657374222c226973737565725f7075626b6579223a2230336131303762666633636531306265316437306464313865373462633039393637653464363330396261353064356631646463383636343132353533316238222c226e6f6e6365223a223031303130313031303130313031303130313031303130313031303130313031222c227065726d697373696f6e73223a5b2272656164225d2c22726f6c65223a224d656d626572222c2273636f7065223a2273706163652d74657374222c227369676e6174757265223a226531633930626137303937386265626365653162343837356433343664623662626431396130306534656333643837643331336266633263333365633536363037613535653032393733376531613632336534373831323334646437613733633863363234643464626364303533626230653738623266653938356336363061222c2273706163655f65706f6368223a372c227375626a6563745f6d656d6265725f6964223a226d656d6265722d74657374222c2274746c5f636c617373223a2273686f7274227d",
    "signatureHex": "e1c90ba70978bebcee1b4875d346db6bbd19a00e4ec3d87d313bfc2c33ec56607a55e029737e1a623e4781234dd7a73c8c624d4dbcd053bb0e78b2fe985c660a"
  }
}

Status of this document

This page describes the cryptographic constructions in AllWeDo 3.1.206. It is not a security audit, certification or export-classification determination. For corrections or questions, contact allwedo-support@allmobile.app.