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.
|| 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.
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.
e, compute
raw dh = X25519(e.private, recipient.public); reject
all-zero DH.dh,
salt=e.public || recipient.public (64 bytes),
info=A("allwedo-sealed-v1"), output length=44.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.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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
.awdbak.enc): PBKDF2-HMAC-SHA256,
200000 iterations, 16-byte fresh random salt, output 32. Password bytes
are the exact UTF-8 string: trim is used only to reject all-whitespace
passwords, not to change a nonempty password.
Wire=A("AWDE") || 01 || salt[16] || nonce[12] || ct || tag.
Minimum size=49. No multi-byte little-endian integer exists in the
header..awdbak.k.enc): direct random 32-byte
stored key, no KDF/salt.
Wire=A("AWDK") || 01 || nonce[12] || ct || tag. Minimum
size=33. This is a separate container, not another AWDE version.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().
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):
deriveOwnRegistryKey(mainDbKey) =
M(mainDbKey,U("allwedo/own_registry/sqlcipher/v1")).deriveOwnPersonStoreKey(rootSecret) =
M(rootSecret,U("allwedo/own_person/sqlcipher/v1")). The
root is an independent random 32-byte own-person store root, not the
main database key. Both feed the same SQLCipher opener; own-person
schema version is 2, distinct from cipher compatibility 4. Their feature
flags default off.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):
hex(HH(U("allwedo-identity-v1:" + p))).HH(A("allwedo-recovery-identity-v1") || LP(U(p))).HH(A("allwedo-recovery-root-v1") || LP(U(spaceId)) || LP(U(p))).Release: phrase recovery and identity functions are wired. Public fingerprint bytes must not be reused as a private signing or encryption seed.
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.
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.
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.
Additional signature formats and authentication contexts:
PeerIdentity is a separate persisted Ed25519 identity;
it signs U("allwedo-peer-sign-v1:" + data) and uses
standard base64 public keys and signatures. Device-key rotation signs
U("rotate|" + deviceId + "|" + newPubkeyB64 + "|" + signedAtMs)
with the old identity.allwedo-lan-roster-v1, version 1, explicit binary lengths
and fixed-size fingerprints. Checkpoint signatures
domain=allwedo-membership-checkpoint-v1 and row
attestations domain=allwedo-row-attestation-v1. These are
membership-dependent paths, not substitutes for live role checks.U(J(["allwedo-file-provenance-v1",spaceId,id,memberId, deviceId,checkpointHash,aadVersion,originalName??"",mimeType?? "application/octet-stream",fileType??"document",sizeBytes,sha256,blobKeyCt, blobRef]));
version 1 proof has aadVersion 1 or 2. It requires verified membership
placement. FILE_PROVENANCE_ENFORCE defaults false, without
a hard release-mode guard.signature and
cosignatures; cosigning includes the issuer
signature and excludes cosignatures. Binary
fields are lowercase hex in the canonical JSON, including
signatures.U(tokenId)||1f||U(requestId)||1f||U(issuerMemberId)||1f|| issuerNonce[32]||1f||receiverNonce[32],
where 1f is one separator byte. Own-link SAS input is
H(U("aw-own-link-sas-v1")||00||qrSecret||C(transcript)).
These feed §11 SAS. Own-link QR/signed domains are
aw-own-link-qr-v1 and aw-own-link-v1; alias
membership binding domain=aw-membership-binding-v1. These
own-link paths have feature flags default off.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.
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.
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"
}
}
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.