Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

feat(whatsapp-store): store whatsmeow state encrypted in Postgres (#8537)

Wolf Mermelsteincaea779c7076
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.json
index f99573d18f..b1ce4ad643 100644
--- a/.github/workspace-dep-closures.json
+++ b/.github/workspace-dep-closures.json
@@ -14000,6 +14000,12 @@
"crates/whatsapp_linked",
"crates/workspace-hack"
],
+ "whatsapp_store_pg": [
+ "crates/whatsapp_store_pg",
+ "crates/whatsmeow",
+ "crates/whatsmeow_proto",
+ "crates/workspace-hack"
+ ],
"whatsmeow": [
"crates/whatsmeow",
"crates/whatsmeow_proto",
diff --git a/.sqlx/query-030bd856f8ae96822a5151b09ad880fd2711bfe6b51d315b82d536188070c4fc.json b/.sqlx/query-030bd856f8ae96822a5151b09ad880fd2711bfe6b51d315b82d536188070c4fc.json
new file mode 100644
index 0000000000..02de138a05
--- /dev/null
+++ b/.sqlx/query-030bd856f8ae96822a5151b09ad880fd2711bfe6b51d315b82d536188070c4fc.json
@@ -0,0 +1,18 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO whatsapp_privacy_token (account_id, user_jid, token_timestamp, nonce, value)\n SELECT $1, entry.user_jid, entry.token_timestamp, entry.nonce, entry.value\n FROM UNNEST($2::text[], $3::timestamptz[], $4::bytea[], $5::bytea[])\n AS entry(user_jid, token_timestamp, nonce, value)\n ON CONFLICT (account_id, user_jid) DO UPDATE SET\n token_timestamp = EXCLUDED.token_timestamp,\n nonce = EXCLUDED.nonce,\n value = EXCLUDED.value\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "TextArray",
+ "TimestamptzArray",
+ "ByteaArray",
+ "ByteaArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "030bd856f8ae96822a5151b09ad880fd2711bfe6b51d315b82d536188070c4fc"
+}
diff --git a/.sqlx/query-0387cb4c338223f63292ca716f7d3a9d6f64e8a5e648a7695d57d16e6f6c3ddc.json b/.sqlx/query-0387cb4c338223f63292ca716f7d3a9d6f64e8a5e648a7695d57d16e6f6c3ddc.json
new file mode 100644
index 0000000000..2a74f31e22
--- /dev/null
+++ b/.sqlx/query-0387cb4c338223f63292ca716f7d3a9d6f64e8a5e648a7695d57d16e6f6c3ddc.json
@@ -0,0 +1,18 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO whatsapp_store_value (account_id, store, key, nonce, value)\n SELECT $1, $2, entry.key, entry.nonce, entry.value\n FROM UNNEST($3::text[], $4::bytea[], $5::bytea[]) AS entry(key, nonce, value)\n ON CONFLICT (account_id, store, key) DO UPDATE SET\n nonce = EXCLUDED.nonce,\n value = EXCLUDED.value,\n updated_at = now()\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "TextArray",
+ "ByteaArray",
+ "ByteaArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "0387cb4c338223f63292ca716f7d3a9d6f64e8a5e648a7695d57d16e6f6c3ddc"
+}
diff --git a/.sqlx/query-06df6697a45bd245c73d6da7f510b4ba280cc5c4dbb73145ea20c760bd908d44.json b/.sqlx/query-06df6697a45bd245c73d6da7f510b4ba280cc5c4dbb73145ea20c760bd908d44.json
new file mode 100644
index 0000000000..1a25dafabc
--- /dev/null
+++ b/.sqlx/query-06df6697a45bd245c73d6da7f510b4ba280cc5c4dbb73145ea20c760bd908d44.json
@@ -0,0 +1,14 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM whatsapp_device\n WHERE account_id = $1\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "06df6697a45bd245c73d6da7f510b4ba280cc5c4dbb73145ea20c760bd908d44"
+}
diff --git a/.sqlx/query-072e2177f55dcbd6777d0ecb0be2ebcd2197cd118be9736c5d191d03f0791bae.json b/.sqlx/query-072e2177f55dcbd6777d0ecb0be2ebcd2197cd118be9736c5d191d03f0791bae.json
new file mode 100644
index 0000000000..ec0a60be94
--- /dev/null
+++ b/.sqlx/query-072e2177f55dcbd6777d0ecb0be2ebcd2197cd118be9736c5d191d03f0791bae.json
@@ -0,0 +1,28 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT user_id, lease_epoch\n FROM whatsapp_linked_account\n WHERE id = $1\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "user_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "lease_epoch",
+ "type_info": "Int8"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ false,
+ false
+ ]
+ },
+ "hash": "072e2177f55dcbd6777d0ecb0be2ebcd2197cd118be9736c5d191d03f0791bae"
+}
diff --git a/.sqlx/query-17949476e90b6053b41fc8c5ba60ccf5731c8e7d94998fa291bb803a19e45a0d.json b/.sqlx/query-17949476e90b6053b41fc8c5ba60ccf5731c8e7d94998fa291bb803a19e45a0d.json
new file mode 100644
index 0000000000..07e84dfcdc
--- /dev/null
+++ b/.sqlx/query-17949476e90b6053b41fc8c5ba60ccf5731c8e7d94998fa291bb803a19e45a0d.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM whatsapp_outgoing_event\n WHERE account_id = $1 AND created_at < $2\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Timestamptz"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "17949476e90b6053b41fc8c5ba60ccf5731c8e7d94998fa291bb803a19e45a0d"
+}
diff --git a/.sqlx/query-1ce1b770a5834653d4ebe823e80376eb7be0fafea29cabcc7ebff858658dc605.json b/.sqlx/query-1ce1b770a5834653d4ebe823e80376eb7be0fafea29cabcc7ebff858658dc605.json
new file mode 100644
index 0000000000..c46b37d8d4
--- /dev/null
+++ b/.sqlx/query-1ce1b770a5834653d4ebe823e80376eb7be0fafea29cabcc7ebff858658dc605.json
@@ -0,0 +1,18 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO whatsapp_pre_key (account_id, key_id, uploaded, nonce, value)\n SELECT $1, entry.key_id, $2, entry.nonce, entry.value\n FROM UNNEST($3::bigint[], $4::bytea[], $5::bytea[]) AS entry(key_id, nonce, value)\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Bool",
+ "Int8Array",
+ "ByteaArray",
+ "ByteaArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "1ce1b770a5834653d4ebe823e80376eb7be0fafea29cabcc7ebff858658dc605"
+}
diff --git a/.sqlx/query-2939bea5a0d20c91c73f6f3514f3dd8b3cc7b2bd8c496ac5df4d5f8d18e1d4a2.json b/.sqlx/query-2939bea5a0d20c91c73f6f3514f3dd8b3cc7b2bd8c496ac5df4d5f8d18e1d4a2.json
new file mode 100644
index 0000000000..c4b9c96c49
--- /dev/null
+++ b/.sqlx/query-2939bea5a0d20c91c73f6f3514f3dd8b3cc7b2bd8c496ac5df4d5f8d18e1d4a2.json
@@ -0,0 +1,18 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO whatsapp_store_value (account_id, store, key, nonce, value)\n SELECT $1, $2, entry.key, entry.nonce, entry.value\n FROM UNNEST($3::text[], $4::bytea[], $5::bytea[]) AS entry(key, nonce, value)\n ON CONFLICT (account_id, store, key) DO NOTHING\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "TextArray",
+ "ByteaArray",
+ "ByteaArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "2939bea5a0d20c91c73f6f3514f3dd8b3cc7b2bd8c496ac5df4d5f8d18e1d4a2"
+}
diff --git a/.sqlx/query-2d07890bf15dbab0a3c15e6fe1a3028734d830295ec28a9c7d8af470ff02429e.json b/.sqlx/query-2d07890bf15dbab0a3c15e6fe1a3028734d830295ec28a9c7d8af470ff02429e.json
new file mode 100644
index 0000000000..e9ea4a2b2e
--- /dev/null
+++ b/.sqlx/query-2d07890bf15dbab0a3c15e6fe1a3028734d830295ec28a9c7d8af470ff02429e.json
@@ -0,0 +1,19 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO whatsapp_app_state_mutation_mac (\n account_id, name, index_mac, version, nonce, value\n )\n SELECT $1, $2, entry.index_mac, $3, entry.nonce, entry.value\n FROM UNNEST($4::bytea[], $5::bytea[], $6::bytea[]) AS entry(index_mac, nonce, value)\n ON CONFLICT (account_id, name, index_mac, version) DO UPDATE SET\n nonce = EXCLUDED.nonce,\n value = EXCLUDED.value\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "Int8",
+ "ByteaArray",
+ "ByteaArray",
+ "ByteaArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "2d07890bf15dbab0a3c15e6fe1a3028734d830295ec28a9c7d8af470ff02429e"
+}
diff --git a/.sqlx/query-3005b416c2a9034a14fd4a3dd473f369a1aa25a74072ab3e9df9eca7fbf86310.json b/.sqlx/query-3005b416c2a9034a14fd4a3dd473f369a1aa25a74072ab3e9df9eca7fbf86310.json
new file mode 100644
index 0000000000..8ff75f0cdd
--- /dev/null
+++ b/.sqlx/query-3005b416c2a9034a14fd4a3dd473f369a1aa25a74072ab3e9df9eca7fbf86310.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT account_id\n FROM whatsapp_device\n WHERE account_id = $1\n FOR NO KEY UPDATE\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "account_id",
+ "type_info": "Uuid"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ false
+ ]
+ },
+ "hash": "3005b416c2a9034a14fd4a3dd473f369a1aa25a74072ab3e9df9eca7fbf86310"
+}
diff --git a/.sqlx/query-3665ba05801dda1cf017023d6e6f89eb2f93b09087aef6e243c54ed1b79ddad9.json b/.sqlx/query-3665ba05801dda1cf017023d6e6f89eb2f93b09087aef6e243c54ed1b79ddad9.json
new file mode 100644
index 0000000000..2241e3ba6e
--- /dev/null
+++ b/.sqlx/query-3665ba05801dda1cf017023d6e6f89eb2f93b09087aef6e243c54ed1b79ddad9.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT lease_epoch\n FROM whatsapp_linked_account\n WHERE id = $1\n FOR SHARE\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "lease_epoch",
+ "type_info": "Int8"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ false
+ ]
+ },
+ "hash": "3665ba05801dda1cf017023d6e6f89eb2f93b09087aef6e243c54ed1b79ddad9"
+}
diff --git a/.sqlx/query-4679c75486b6688406986e1329cf7bad3144b1132e03f72da6877ed1fb76e6d5.json b/.sqlx/query-4679c75486b6688406986e1329cf7bad3144b1132e03f72da6877ed1fb76e6d5.json
new file mode 100644
index 0000000000..85d5d9d4af
--- /dev/null
+++ b/.sqlx/query-4679c75486b6688406986e1329cf7bad3144b1132e03f72da6877ed1fb76e6d5.json
@@ -0,0 +1,18 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO whatsapp_event_buffer (account_id, ciphertext_hash, server_time, nonce, value)\n VALUES ($1, $2, $3, $4, $5)\n ON CONFLICT (account_id, ciphertext_hash) DO UPDATE SET\n server_time = EXCLUDED.server_time,\n inserted_at = now(),\n nonce = EXCLUDED.nonce,\n value = EXCLUDED.value\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Bytea",
+ "Timestamptz",
+ "Bytea",
+ "Bytea"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "4679c75486b6688406986e1329cf7bad3144b1132e03f72da6877ed1fb76e6d5"
+}
diff --git a/.sqlx/query-4c55be08c54d40219fd8b0ea217e22251951d222996556950b097783cf490754.json b/.sqlx/query-4c55be08c54d40219fd8b0ea217e22251951d222996556950b097783cf490754.json
new file mode 100644
index 0000000000..a9fb004b07
--- /dev/null
+++ b/.sqlx/query-4c55be08c54d40219fd8b0ea217e22251951d222996556950b097783cf490754.json
@@ -0,0 +1,36 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT key, nonce, value\n FROM whatsapp_store_value\n WHERE account_id = $1 AND store = $2 AND key LIKE $3\n ORDER BY key\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "key",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "nonce",
+ "type_info": "Bytea"
+ },
+ {
+ "ordinal": 2,
+ "name": "value",
+ "type_info": "Bytea"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false
+ ]
+ },
+ "hash": "4c55be08c54d40219fd8b0ea217e22251951d222996556950b097783cf490754"
+}
diff --git a/.sqlx/query-577de129ec419b785c3901ba6e64e695bbcb9229d3cdb0987a9669f1d19ac7f3.json b/.sqlx/query-577de129ec419b785c3901ba6e64e695bbcb9229d3cdb0987a9669f1d19ac7f3.json
new file mode 100644
index 0000000000..66c3bb0aa1
--- /dev/null
+++ b/.sqlx/query-577de129ec419b785c3901ba6e64e695bbcb9229d3cdb0987a9669f1d19ac7f3.json
@@ -0,0 +1,24 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT EXISTS (\n SELECT 1\n FROM whatsapp_store_value\n WHERE account_id = $1 AND store = $2 AND key = $3\n ) AS \"exists!\"\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "exists!",
+ "type_info": "Bool"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": [
+ null
+ ]
+ },
+ "hash": "577de129ec419b785c3901ba6e64e695bbcb9229d3cdb0987a9669f1d19ac7f3"
+}
diff --git a/.sqlx/query-5bea223c321de8a7af2a0aed6151e1428cd7ea6b86742cbd1ef4a32d92b96e7f.json b/.sqlx/query-5bea223c321de8a7af2a0aed6151e1428cd7ea6b86742cbd1ef4a32d92b96e7f.json
new file mode 100644
index 0000000000..ccb25a77a6
--- /dev/null
+++ b/.sqlx/query-5bea223c321de8a7af2a0aed6151e1428cd7ea6b86742cbd1ef4a32d92b96e7f.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM whatsapp_privacy_token\n WHERE account_id = $1 AND token_timestamp < $2\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Timestamptz"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "5bea223c321de8a7af2a0aed6151e1428cd7ea6b86742cbd1ef4a32d92b96e7f"
+}
diff --git a/.sqlx/query-5f16a3e103c92ccfede1be826ebcb7fdef517a70dd5cb3d956b446b544321cb0.json b/.sqlx/query-5f16a3e103c92ccfede1be826ebcb7fdef517a70dd5cb3d956b446b544321cb0.json
new file mode 100644
index 0000000000..daa4d5a29f
--- /dev/null
+++ b/.sqlx/query-5f16a3e103c92ccfede1be826ebcb7fdef517a70dd5cb3d956b446b544321cb0.json
@@ -0,0 +1,36 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT chat_jid, nonce, value\n FROM whatsapp_outgoing_event\n WHERE account_id = $1 AND chat_jid = ANY($2) AND message_id = $3\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "chat_jid",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "nonce",
+ "type_info": "Bytea"
+ },
+ {
+ "ordinal": 2,
+ "name": "value",
+ "type_info": "Bytea"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "TextArray",
+ "Text"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false
+ ]
+ },
+ "hash": "5f16a3e103c92ccfede1be826ebcb7fdef517a70dd5cb3d956b446b544321cb0"
+}
diff --git a/.sqlx/query-6b3229250262e62c59363059d69cb17d3614e0e0a878295a87158d13cce36996.json b/.sqlx/query-6b3229250262e62c59363059d69cb17d3614e0e0a878295a87158d13cce36996.json
new file mode 100644
index 0000000000..e40a1a9e62
--- /dev/null
+++ b/.sqlx/query-6b3229250262e62c59363059d69cb17d3614e0e0a878295a87158d13cce36996.json
@@ -0,0 +1,41 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT user_jid, token_timestamp, nonce, value\n FROM whatsapp_privacy_token\n WHERE account_id = $1 AND user_jid = ANY($2)\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "user_jid",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "token_timestamp",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 2,
+ "name": "nonce",
+ "type_info": "Bytea"
+ },
+ {
+ "ordinal": 3,
+ "name": "value",
+ "type_info": "Bytea"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "TextArray"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false,
+ false
+ ]
+ },
+ "hash": "6b3229250262e62c59363059d69cb17d3614e0e0a878295a87158d13cce36996"
+}
diff --git a/.sqlx/query-6b56595e15afc9414013ba0261e1d1833abbd317b0dd167fc77ab4b437d8e289.json b/.sqlx/query-6b56595e15afc9414013ba0261e1d1833abbd317b0dd167fc77ab4b437d8e289.json
new file mode 100644
index 0000000000..c41c94bd38
--- /dev/null
+++ b/.sqlx/query-6b56595e15afc9414013ba0261e1d1833abbd317b0dd167fc77ab4b437d8e289.json
@@ -0,0 +1,34 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT data_key_ciphertext, kms_key_id, encryption_version\n FROM whatsapp_device\n WHERE account_id = $1\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "data_key_ciphertext",
+ "type_info": "Bytea"
+ },
+ {
+ "ordinal": 1,
+ "name": "kms_key_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 2,
+ "name": "encryption_version",
+ "type_info": "Int2"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false
+ ]
+ },
+ "hash": "6b56595e15afc9414013ba0261e1d1833abbd317b0dd167fc77ab4b437d8e289"
+}
diff --git a/.sqlx/query-6fdcb808278c91fbd0c23432cd7e0be6ea5121e095284c21cbab19b1b37b2f5a.json b/.sqlx/query-6fdcb808278c91fbd0c23432cd7e0be6ea5121e095284c21cbab19b1b37b2f5a.json
new file mode 100644
index 0000000000..4238a92bfc
--- /dev/null
+++ b/.sqlx/query-6fdcb808278c91fbd0c23432cd7e0be6ea5121e095284c21cbab19b1b37b2f5a.json
@@ -0,0 +1,41 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT user_jid, token_timestamp, nonce, value\n FROM whatsapp_privacy_token\n WHERE account_id = $1 AND user_jid = ANY($2)\n ORDER BY token_timestamp DESC\n LIMIT 1\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "user_jid",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "token_timestamp",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 2,
+ "name": "nonce",
+ "type_info": "Bytea"
+ },
+ {
+ "ordinal": 3,
+ "name": "value",
+ "type_info": "Bytea"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "TextArray"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false,
+ false
+ ]
+ },
+ "hash": "6fdcb808278c91fbd0c23432cd7e0be6ea5121e095284c21cbab19b1b37b2f5a"
+}
diff --git a/.sqlx/query-8eaf12a19b9c9b292b8533288354307ac0877548a768cc05a20ff44a031fb429.json b/.sqlx/query-8eaf12a19b9c9b292b8533288354307ac0877548a768cc05a20ff44a031fb429.json
new file mode 100644
index 0000000000..974dd651a7
--- /dev/null
+++ b/.sqlx/query-8eaf12a19b9c9b292b8533288354307ac0877548a768cc05a20ff44a031fb429.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM whatsapp_event_buffer\n WHERE account_id = $1 AND inserted_at < $2\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Timestamptz"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "8eaf12a19b9c9b292b8533288354307ac0877548a768cc05a20ff44a031fb429"
+}
diff --git a/.sqlx/query-8ef89b280bdf1778c23df6e530825b241c3c2029c35150f7f7848a3019e29d2e.json b/.sqlx/query-8ef89b280bdf1778c23df6e530825b241c3c2029c35150f7f7848a3019e29d2e.json
new file mode 100644
index 0000000000..c927f5bbc2
--- /dev/null
+++ b/.sqlx/query-8ef89b280bdf1778c23df6e530825b241c3c2029c35150f7f7848a3019e29d2e.json
@@ -0,0 +1,16 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM whatsapp_store_value\n WHERE account_id = $1 AND store = $2 AND key = ANY($3)\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "8ef89b280bdf1778c23df6e530825b241c3c2029c35150f7f7848a3019e29d2e"
+}
diff --git a/.sqlx/query-90de5f57e7abcb810b0503c4e58facf8a97e72f6745a7f89cfcbf00e931ead7c.json b/.sqlx/query-90de5f57e7abcb810b0503c4e58facf8a97e72f6745a7f89cfcbf00e931ead7c.json
new file mode 100644
index 0000000000..c9ba026402
--- /dev/null
+++ b/.sqlx/query-90de5f57e7abcb810b0503c4e58facf8a97e72f6745a7f89cfcbf00e931ead7c.json
@@ -0,0 +1,16 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM whatsapp_app_state_mutation_mac\n WHERE account_id = $1 AND name = $2 AND index_mac = ANY($3)\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "ByteaArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "90de5f57e7abcb810b0503c4e58facf8a97e72f6745a7f89cfcbf00e931ead7c"
+}
diff --git a/.sqlx/query-92a3f1f677ee5f0879147b31a962dcab39e3d7104c887f15c89ea6cc88a5ec33.json b/.sqlx/query-92a3f1f677ee5f0879147b31a962dcab39e3d7104c887f15c89ea6cc88a5ec33.json
new file mode 100644
index 0000000000..bb43b00e9d
--- /dev/null
+++ b/.sqlx/query-92a3f1f677ee5f0879147b31a962dcab39e3d7104c887f15c89ea6cc88a5ec33.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM whatsapp_pre_key\n WHERE account_id = $1 AND key_id = $2\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Int8"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "92a3f1f677ee5f0879147b31a962dcab39e3d7104c887f15c89ea6cc88a5ec33"
+}
diff --git a/.sqlx/query-a2d207fe6f036cbc70182c69ebf775a497a3de61fb7f46af66652753aee8a56d.json b/.sqlx/query-a2d207fe6f036cbc70182c69ebf775a497a3de61fb7f46af66652753aee8a56d.json
new file mode 100644
index 0000000000..5838a89c25
--- /dev/null
+++ b/.sqlx/query-a2d207fe6f036cbc70182c69ebf775a497a3de61fb7f46af66652753aee8a56d.json
@@ -0,0 +1,41 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT server_time, inserted_at, nonce, value\n FROM whatsapp_event_buffer\n WHERE account_id = $1 AND ciphertext_hash = $2\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "server_time",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 1,
+ "name": "inserted_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 2,
+ "name": "nonce",
+ "type_info": "Bytea"
+ },
+ {
+ "ordinal": 3,
+ "name": "value",
+ "type_info": "Bytea"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Bytea"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ true,
+ true
+ ]
+ },
+ "hash": "a2d207fe6f036cbc70182c69ebf775a497a3de61fb7f46af66652753aee8a56d"
+}
diff --git a/.sqlx/query-a34087e4ca88dca708c0f79b67a92b06149ef60db06db23522af1be020313efd.json b/.sqlx/query-a34087e4ca88dca708c0f79b67a92b06149ef60db06db23522af1be020313efd.json
new file mode 100644
index 0000000000..46c540a2dc
--- /dev/null
+++ b/.sqlx/query-a34087e4ca88dca708c0f79b67a92b06149ef60db06db23522af1be020313efd.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n UPDATE whatsapp_pre_key\n SET uploaded = true\n WHERE account_id = $1 AND key_id <= $2 AND NOT uploaded\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Int8"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "a34087e4ca88dca708c0f79b67a92b06149ef60db06db23522af1be020313efd"
+}
diff --git a/.sqlx/query-a3d6c425cbc9d0ce175b50d3418694b0e85f3522b35db9861c4e6dc2b92c66cb.json b/.sqlx/query-a3d6c425cbc9d0ce175b50d3418694b0e85f3522b35db9861c4e6dc2b92c66cb.json
new file mode 100644
index 0000000000..ad2c2fc45e
--- /dev/null
+++ b/.sqlx/query-a3d6c425cbc9d0ce175b50d3418694b0e85f3522b35db9861c4e6dc2b92c66cb.json
@@ -0,0 +1,36 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT key, nonce, value\n FROM whatsapp_store_value\n WHERE account_id = $1 AND store = $2 AND key = ANY($3)\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "key",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "nonce",
+ "type_info": "Bytea"
+ },
+ {
+ "ordinal": 2,
+ "name": "value",
+ "type_info": "Bytea"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "TextArray"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false
+ ]
+ },
+ "hash": "a3d6c425cbc9d0ce175b50d3418694b0e85f3522b35db9861c4e6dc2b92c66cb"
+}
diff --git a/.sqlx/query-a48da657cf79e1737fc6c7412ed7be65718c281c817a548d5e5623bbd2712e70.json b/.sqlx/query-a48da657cf79e1737fc6c7412ed7be65718c281c817a548d5e5623bbd2712e70.json
new file mode 100644
index 0000000000..f5367395bd
--- /dev/null
+++ b/.sqlx/query-a48da657cf79e1737fc6c7412ed7be65718c281c817a548d5e5623bbd2712e70.json
@@ -0,0 +1,35 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT key_id, nonce, value\n FROM whatsapp_pre_key\n WHERE account_id = $1 AND NOT uploaded\n ORDER BY key_id\n LIMIT $2\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "key_id",
+ "type_info": "Int8"
+ },
+ {
+ "ordinal": 1,
+ "name": "nonce",
+ "type_info": "Bytea"
+ },
+ {
+ "ordinal": 2,
+ "name": "value",
+ "type_info": "Bytea"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Int8"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false
+ ]
+ },
+ "hash": "a48da657cf79e1737fc6c7412ed7be65718c281c817a548d5e5623bbd2712e70"
+}
diff --git a/.sqlx/query-a724bbd607353cbccdbf15aa197ba77b3012907540e25a8b714fb85e6039b1a2.json b/.sqlx/query-a724bbd607353cbccdbf15aa197ba77b3012907540e25a8b714fb85e6039b1a2.json
new file mode 100644
index 0000000000..526d6592e4
--- /dev/null
+++ b/.sqlx/query-a724bbd607353cbccdbf15aa197ba77b3012907540e25a8b714fb85e6039b1a2.json
@@ -0,0 +1,35 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT key_id, nonce, value\n FROM whatsapp_pre_key\n WHERE account_id = $1 AND key_id = $2\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "key_id",
+ "type_info": "Int8"
+ },
+ {
+ "ordinal": 1,
+ "name": "nonce",
+ "type_info": "Bytea"
+ },
+ {
+ "ordinal": 2,
+ "name": "value",
+ "type_info": "Bytea"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Int8"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false
+ ]
+ },
+ "hash": "a724bbd607353cbccdbf15aa197ba77b3012907540e25a8b714fb85e6039b1a2"
+}
diff --git a/.sqlx/query-a8ccae7c5f1b09755b74c6e8bdf097c074f86a123c4672a0fd8a6c2f2d4d3315.json b/.sqlx/query-a8ccae7c5f1b09755b74c6e8bdf097c074f86a123c4672a0fd8a6c2f2d4d3315.json
new file mode 100644
index 0000000000..76bd62ff80
--- /dev/null
+++ b/.sqlx/query-a8ccae7c5f1b09755b74c6e8bdf097c074f86a123c4672a0fd8a6c2f2d4d3315.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT COUNT(*) AS \"count!\"\n FROM whatsapp_pre_key\n WHERE account_id = $1 AND uploaded\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "count!",
+ "type_info": "Int8"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ null
+ ]
+ },
+ "hash": "a8ccae7c5f1b09755b74c6e8bdf097c074f86a123c4672a0fd8a6c2f2d4d3315"
+}
diff --git a/.sqlx/query-b12b97a2e971d70339e318c9dc690923766b32552ff6f4ed3a298eb843706ae3.json b/.sqlx/query-b12b97a2e971d70339e318c9dc690923766b32552ff6f4ed3a298eb843706ae3.json
new file mode 100644
index 0000000000..4324a6bec3
--- /dev/null
+++ b/.sqlx/query-b12b97a2e971d70339e318c9dc690923766b32552ff6f4ed3a298eb843706ae3.json
@@ -0,0 +1,16 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM whatsapp_store_value\n WHERE account_id = $1 AND store = $2 AND key LIKE $3\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "b12b97a2e971d70339e318c9dc690923766b32552ff6f4ed3a298eb843706ae3"
+}
diff --git a/.sqlx/query-c0d3a430b9508b91d4313d85d5e50e02c89048231acb431fecd09ebc69c97c45.json b/.sqlx/query-c0d3a430b9508b91d4313d85d5e50e02c89048231acb431fecd09ebc69c97c45.json
new file mode 100644
index 0000000000..f76ee8bac1
--- /dev/null
+++ b/.sqlx/query-c0d3a430b9508b91d4313d85d5e50e02c89048231acb431fecd09ebc69c97c45.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n UPDATE whatsapp_event_buffer\n SET nonce = NULL, value = NULL\n WHERE account_id = $1 AND ciphertext_hash = $2\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Bytea"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "c0d3a430b9508b91d4313d85d5e50e02c89048231acb431fecd09ebc69c97c45"
+}
diff --git a/.sqlx/query-cafd81c309588887ceaa8d648ab252578b5611ca2cd3ee2b7b84c09622ae7a57.json b/.sqlx/query-cafd81c309588887ceaa8d648ab252578b5611ca2cd3ee2b7b84c09622ae7a57.json
new file mode 100644
index 0000000000..9c39df8efb
--- /dev/null
+++ b/.sqlx/query-cafd81c309588887ceaa8d648ab252578b5611ca2cd3ee2b7b84c09622ae7a57.json
@@ -0,0 +1,36 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT version, nonce, value\n FROM whatsapp_app_state_mutation_mac\n WHERE account_id = $1 AND name = $2 AND index_mac = $3\n ORDER BY version DESC\n LIMIT 1\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "version",
+ "type_info": "Int8"
+ },
+ {
+ "ordinal": 1,
+ "name": "nonce",
+ "type_info": "Bytea"
+ },
+ {
+ "ordinal": 2,
+ "name": "value",
+ "type_info": "Bytea"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "Bytea"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false
+ ]
+ },
+ "hash": "cafd81c309588887ceaa8d648ab252578b5611ca2cd3ee2b7b84c09622ae7a57"
+}
diff --git a/.sqlx/query-d9cf564a13b36c2ab1bf73b950a35fc051ba997d902cedbffa0f707565a87834.json b/.sqlx/query-d9cf564a13b36c2ab1bf73b950a35fc051ba997d902cedbffa0f707565a87834.json
new file mode 100644
index 0000000000..bf9fddd029
--- /dev/null
+++ b/.sqlx/query-d9cf564a13b36c2ab1bf73b950a35fc051ba997d902cedbffa0f707565a87834.json
@@ -0,0 +1,18 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO whatsapp_outgoing_event (account_id, chat_jid, message_id, nonce, value)\n VALUES ($1, $2, $3, $4, $5)\n ON CONFLICT (account_id, chat_jid, message_id) DO UPDATE SET\n created_at = now(),\n nonce = EXCLUDED.nonce,\n value = EXCLUDED.value\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "Text",
+ "Bytea",
+ "Bytea"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "d9cf564a13b36c2ab1bf73b950a35fc051ba997d902cedbffa0f707565a87834"
+}
diff --git a/.sqlx/query-e4afd2f840b2c2728cf4e5f8bb919a1f3dc83ab532fc78fbb3de520bf1e3d0a8.json b/.sqlx/query-e4afd2f840b2c2728cf4e5f8bb919a1f3dc83ab532fc78fbb3de520bf1e3d0a8.json
new file mode 100644
index 0000000000..b1ef17ec2e
--- /dev/null
+++ b/.sqlx/query-e4afd2f840b2c2728cf4e5f8bb919a1f3dc83ab532fc78fbb3de520bf1e3d0a8.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT MAX(key_id)\n FROM whatsapp_pre_key\n WHERE account_id = $1\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "max",
+ "type_info": "Int8"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ null
+ ]
+ },
+ "hash": "e4afd2f840b2c2728cf4e5f8bb919a1f3dc83ab532fc78fbb3de520bf1e3d0a8"
+}
diff --git a/.sqlx/query-eaaf5cc4dce0a3e49d0b87133ecb1537770f983ba7bdbbad5733973bda1129b4.json b/.sqlx/query-eaaf5cc4dce0a3e49d0b87133ecb1537770f983ba7bdbbad5733973bda1129b4.json
new file mode 100644
index 0000000000..ca4fd81f3e
--- /dev/null
+++ b/.sqlx/query-eaaf5cc4dce0a3e49d0b87133ecb1537770f983ba7bdbbad5733973bda1129b4.json
@@ -0,0 +1,30 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT nonce, value\n FROM whatsapp_store_value\n WHERE account_id = $1 AND store = $2 AND key = $3\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "nonce",
+ "type_info": "Bytea"
+ },
+ {
+ "ordinal": 1,
+ "name": "value",
+ "type_info": "Bytea"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": [
+ false,
+ false
+ ]
+ },
+ "hash": "eaaf5cc4dce0a3e49d0b87133ecb1537770f983ba7bdbbad5733973bda1129b4"
+}
diff --git a/.sqlx/query-f0c532d8e744b58ba33b2b61bbada52a02bb874d5a20301ba7a2d78842d4ef2b.json b/.sqlx/query-f0c532d8e744b58ba33b2b61bbada52a02bb874d5a20301ba7a2d78842d4ef2b.json
new file mode 100644
index 0000000000..43022c9034
--- /dev/null
+++ b/.sqlx/query-f0c532d8e744b58ba33b2b61bbada52a02bb874d5a20301ba7a2d78842d4ef2b.json
@@ -0,0 +1,25 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO whatsapp_device (\n account_id,\n data_key_ciphertext,\n kms_key_id,\n encryption_version\n )\n VALUES ($1, $2, $3, $4)\n ON CONFLICT (account_id) DO NOTHING\n RETURNING account_id\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "account_id",
+ "type_info": "Uuid"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Bytea",
+ "Text",
+ "Int2"
+ ]
+ },
+ "nullable": [
+ false
+ ]
+ },
+ "hash": "f0c532d8e744b58ba33b2b61bbada52a02bb874d5a20301ba7a2d78842d4ef2b"
+}
diff --git a/Cargo.lock b/Cargo.lock
index b78c01e7a0..b1bcff0bd7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -21629,6 +21629,33 @@ dependencies = [
"workspace-hack",
]
+[[package]]
+name = "whatsapp_store_pg"
+version = "0.1.0"
+dependencies = [
+ "aes-gcm 0.10.3",
+ "async-trait",
+ "aws-sdk-kms",
+ "chrono",
+ "futures",
+ "hex",
+ "macro_db_migrator",
+ "postcard",
+ "prost 0.14.3",
+ "rand 0.9.4",
+ "rootcause",
+ "serde",
+ "sqlx",
+ "strum 0.27.2",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "uuid",
+ "whatsmeow",
+ "workspace-hack",
+ "zeroize",
+]
+
[[package]]
name = "whatsmeow"
version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index ee98994e45..a789190ebd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -132,6 +132,7 @@ members = [
"crates/webhook_signature",
"crates/whatsapp_fake_server",
"crates/whatsapp_linked",
+ "crates/whatsapp_store_pg",
"crates/whatsmeow",
"crates/whatsmeow_proto",
"crates/whatsmeow_signal",
diff --git a/crates/macro_db_client/migrations/20261027062649_whatsapp_store.sql b/crates/macro_db_client/migrations/20261027062649_whatsapp_store.sql
new file mode 100644
index 0000000000..88c744042e
--- /dev/null
+++ b/crates/macro_db_client/migrations/20261027062649_whatsapp_store.sql
@@ -0,0 +1,92 @@
+-- The whatsmeow device store of a linked WhatsApp account (crates/whatsapp_store_pg).
+--
+-- Every value column holds AES-256-GCM ciphertext under the account's data key,
+-- which is itself only stored wrapped by KMS (whatsapp_device). Lookup keys
+-- (Signal addresses, JIDs, prekey ids, MACs) stay plaintext so they can be
+-- indexed. Everything cascades from the account, so deleting the account or
+-- the device row removes every key and session.
+SET LOCAL lock_timeout = '5s';
+
+CREATE TABLE whatsapp_device (
+ account_id uuid PRIMARY KEY REFERENCES whatsapp_linked_account (id) ON DELETE CASCADE,
+ -- The account's data key, wrapped by KMS under the account's encryption context.
+ data_key_ciphertext bytea NOT NULL,
+ kms_key_id text NOT NULL,
+ encryption_version smallint NOT NULL,
+ created_at timestamptz NOT NULL DEFAULT now()
+);
+
+-- Values with point and prefix lookups only. `key` is byte-ordered (C
+-- collation) so `LIKE 'prefix%'` deletes use the primary key.
+CREATE TABLE whatsapp_store_value (
+ account_id uuid NOT NULL REFERENCES whatsapp_device (account_id) ON DELETE CASCADE,
+ store text NOT NULL,
+ key text COLLATE "C" NOT NULL,
+ nonce bytea NOT NULL CHECK (length(nonce) = 12),
+ value bytea NOT NULL,
+ updated_at timestamptz NOT NULL DEFAULT now(),
+ PRIMARY KEY (account_id, store, key)
+);
+
+-- One-time prekeys: numbered, listed in order, counted by upload state.
+CREATE TABLE whatsapp_pre_key (
+ account_id uuid NOT NULL REFERENCES whatsapp_device (account_id) ON DELETE CASCADE,
+ key_id bigint NOT NULL CHECK (key_id BETWEEN 0 AND 4294967295),
+ uploaded boolean NOT NULL DEFAULT false,
+ nonce bytea NOT NULL CHECK (length(nonce) = 12),
+ -- The encrypted private key.
+ value bytea NOT NULL,
+ PRIMARY KEY (account_id, key_id)
+);
+
+-- App state mutation MACs: the newest version per index MAC, and batch deletes
+-- by index MAC. The index MAC is keyed by an app state key, so it reveals
+-- nothing without one; the value MAC is encrypted.
+CREATE TABLE whatsapp_app_state_mutation_mac (
+ account_id uuid NOT NULL REFERENCES whatsapp_device (account_id) ON DELETE CASCADE,
+ name text NOT NULL,
+ index_mac bytea NOT NULL,
+ version bigint NOT NULL,
+ nonce bytea NOT NULL CHECK (length(nonce) = 12),
+ value bytea NOT NULL,
+ PRIMARY KEY (account_id, name, index_mac, version)
+);
+
+-- Privacy tokens, deleted by age.
+CREATE TABLE whatsapp_privacy_token (
+ account_id uuid NOT NULL REFERENCES whatsapp_device (account_id) ON DELETE CASCADE,
+ user_jid text NOT NULL,
+ token_timestamp timestamptz NOT NULL,
+ nonce bytea NOT NULL CHECK (length(nonce) = 12),
+ value bytea NOT NULL,
+ PRIMARY KEY (account_id, user_jid)
+);
+
+-- Decrypted incoming events, kept so a redelivery isn't decrypted twice and
+-- deleted after 14 days. The plaintext is cleared (nonce and value null) once
+-- the event is handled.
+CREATE TABLE whatsapp_event_buffer (
+ account_id uuid NOT NULL REFERENCES whatsapp_device (account_id) ON DELETE CASCADE,
+ ciphertext_hash bytea NOT NULL CHECK (length(ciphertext_hash) = 32),
+ server_time timestamptz NOT NULL,
+ inserted_at timestamptz NOT NULL DEFAULT now(),
+ nonce bytea CHECK (length(nonce) = 12),
+ value bytea,
+ PRIMARY KEY (account_id, ciphertext_hash),
+ CHECK ((nonce IS NULL) = (value IS NULL))
+);
+
+CREATE INDEX whatsapp_event_buffer_inserted_at_idx ON whatsapp_event_buffer (account_id, inserted_at);
+
+-- Sent messages kept for answering retry receipts, deleted after 7 days.
+CREATE TABLE whatsapp_outgoing_event (
+ account_id uuid NOT NULL REFERENCES whatsapp_device (account_id) ON DELETE CASCADE,
+ chat_jid text NOT NULL,
+ message_id text NOT NULL,
+ created_at timestamptz NOT NULL DEFAULT now(),
+ nonce bytea NOT NULL CHECK (length(nonce) = 12),
+ value bytea NOT NULL,
+ PRIMARY KEY (account_id, chat_jid, message_id)
+);
+
+CREATE INDEX whatsapp_outgoing_event_created_at_idx ON whatsapp_outgoing_event (account_id, created_at);
diff --git a/crates/whatsapp_store_pg/AGENTS.md b/crates/whatsapp_store_pg/AGENTS.md
new file mode 100644
index 0000000000..9acb2f0a94
--- /dev/null
+++ b/crates/whatsapp_store_pg/AGENTS.md
@@ -0,0 +1,68 @@
+# whatsapp_store_pg
+
+## What it is
+
+Part of WhatsApp linked devices: the Postgres implementation of every
+`whatsmeow::store` trait for one linked account, with per-account envelope
+encryption (KMS-wrapped data key, AES-256-GCM per value) and lease fencing.
+The threat model is the crate doc comment in `src/lib.rs`.
+
+## Start here
+
+- `src/store.rs`: `PgWhatsAppStore::open`, fencing (`check_lease`) and the
+ row helpers every store is built from.
+- `src/cipher.rs`: the data key and value sealing (associated data =
+ account | store | key).
+- `src/kms.rs`: the KMS seam, the AWS impl, and the encryption context.
+
+## Scope
+
+- Owns: the `whatsapp_device`, `whatsapp_store_value`, `whatsapp_pre_key`,
+ `whatsapp_app_state_mutation_mac`, `whatsapp_privacy_token`,
+ `whatsapp_event_buffer` and `whatsapp_outgoing_event` tables
+ (`crates/macro_db_client/migrations/20261027062649_whatsapp_store.sql`).
+- Not here: the account, pairing and lease rows → linked-domain migration
+ `20261026000000_whatsapp_linked.sql`; taking leases and running clients →
+ `services/whatsapp_session_service`.
+
+## Boundaries
+
+- Depends on: `whatsmeow` (store traits), AWS KMS.
+- Used by: the WhatsApp session service.
+
+## Recipes
+
+- Support a new whatsmeow store trait: a `StoreName` variant in
+ `src/cipher.rs`, the impl in `src/store/<area>.rs`, tests in
+ `src/store/<area>/test.rs`. Point and prefix lookups use
+ `whatsapp_store_value`; a store that needs ordering, ranges or deletes by
+ age gets its own table.
+
+## Checks
+
+- `cargo test -p whatsapp_store_pg` with `SQLX_OFFLINE` unset and
+ `DATABASE_URL` on a database with the MacroDB migrations applied.
+- `cargo clippy -p whatsapp_store_pg --all-targets --features fake-kms`
+
+## Gotchas
+
+- Every write goes through `begin_write` (fencing) and a value's key parts
+ must match between `seal` and `open`, or it stops decrypting. Never move or
+ rename a stored key without re-encrypting (see `move_signal_user`).
+- Read-modify-write operations take `lock_device` (`FOR NO KEY UPDATE` on the
+ device row); plain writes don't.
+- `PgWhatsAppStore::seal(purpose, plaintext)` / `unseal(purpose, sealed)`
+ encrypt blobs kept outside the store (e.g. media download locators) under
+ the account's data key: `0x01 | nonce | ciphertext`, associated data
+ `account | "sealed" | purpose`, so they never open as a store value or
+ for another purpose or account.
+- whatsmeow errors come back as `StoreError::Internal`; use `is_fenced` to
+ detect a lost lease.
+- `fake-kms` exposes `FakeWhatsAppKms` for other crates' tests; never enable
+ it in a binary.
+- Deleting the device row deletes the keys; it does not unlink the device at
+ WhatsApp.
+
+## Related
+
+- Rules: `.agents/rules/rust/security.md` (CS-72), `.agents/rules/rust/db.md`
diff --git a/crates/whatsapp_store_pg/CLAUDE.md b/crates/whatsapp_store_pg/CLAUDE.md
new file mode 120000
index 0000000000..47dc3e3d86
--- /dev/null
+++ b/crates/whatsapp_store_pg/CLAUDE.md
@@ -0,0 +1 @@
+AGENTS.md
\ No newline at end of file
diff --git a/crates/whatsapp_store_pg/Cargo.toml b/crates/whatsapp_store_pg/Cargo.toml
new file mode 100644
index 0000000000..9fa5db3369
--- /dev/null
+++ b/crates/whatsapp_store_pg/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+edition = "2024"
+name = "whatsapp_store_pg"
+publish = false
+version = "0.1.0"
+description = "Postgres implementation of the whatsmeow device stores, with per-account envelope encryption."
+
+[features]
+# The in-memory KMS stand-in, for tests of crates that open a store.
+fake-kms = []
+
+[dependencies]
+aes-gcm = { workspace = true }
+async-trait = { workspace = true }
+aws-sdk-kms = { workspace = true }
+chrono = { workspace = true }
+hex = { workspace = true }
+postcard = { workspace = true }
+prost = { workspace = true }
+rand = { workspace = true }
+rootcause = { workspace = true }
+serde = { workspace = true }
+sqlx = { workspace = true }
+strum = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true, features = ["sync"] }
+tracing = { workspace = true }
+uuid = { workspace = true }
+whatsmeow = { path = "../whatsmeow" }
+workspace-hack = { version = "0.1", path = "../workspace-hack" }
+zeroize = { workspace = true }
+
+[dev-dependencies]
+futures = { workspace = true }
+macro_db_migrator = { path = "../macro_db_migrator" }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
diff --git a/crates/whatsapp_store_pg/src/cipher.rs b/crates/whatsapp_store_pg/src/cipher.rs
new file mode 100644
index 0000000000..d44eb432ac
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/cipher.rs
@@ -0,0 +1,170 @@
+//! Encrypting stored values under an account's data key.
+//!
+//! AES-256-GCM with a random 96-bit nonce per write, so the same data key can
+//! seal any number of values: at 2^32 writes per account the collision
+//! probability of random nonces is still below 2^-32. Each value is bound by
+//! its associated data to the account, the store and the key it was written
+//! under, so a ciphertext copied to another row, store or account fails to
+//! decrypt instead of being read as that row's value.
+
+#[cfg(test)]
+mod test;
+
+use aes_gcm::aead::{Aead, Payload};
+use aes_gcm::{Aes256Gcm, KeyInit, Nonce};
+use uuid::Uuid;
+use zeroize::Zeroizing;
+
+use crate::error::WhatsAppStoreError;
+
+/// The scheme this crate writes, stored on the device row so a second scheme
+/// can be added without a migration.
+pub const ENCRYPTION_VERSION: i16 = 1;
+
+const NONCE_LENGTH: usize = 12;
+const DATA_KEY_LENGTH: usize = 32;
+
+/// An account's data key in plaintext.
+///
+/// Lives only in memory, from the KMS `Decrypt` (or `GenerateDataKey`) when a
+/// replica takes the account's lease until the store is dropped. Zeroizes on
+/// drop, redacts its `Debug`, and has no serialization.
+pub(crate) struct WhatsAppDataKey(Zeroizing<[u8; DATA_KEY_LENGTH]>);
+
+impl WhatsAppDataKey {
+ /// Accepts exactly 32 bytes of key material.
+ pub(crate) fn from_plaintext(plaintext: &[u8]) -> Result<Self, WhatsAppStoreError> {
+ let key: [u8; DATA_KEY_LENGTH] = plaintext
+ .try_into()
+ .map_err(|_| WhatsAppStoreError::Malformed)?;
+ Ok(Self(Zeroizing::new(key)))
+ }
+}
+
+impl std::fmt::Debug for WhatsAppDataKey {
+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ formatter.write_str("WhatsAppDataKey(redacted)")
+ }
+}
+
+/// Which store a value belongs to: the `store` column of
+/// `whatsapp_store_value`, and part of every value's associated data.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, strum::IntoStaticStr)]
+#[strum(serialize_all = "snake_case")]
+pub(crate) enum StoreName {
+ Device,
+ Identity,
+ Session,
+ SenderKey,
+ AppStateSyncKey,
+ AppStateVersion,
+ Contact,
+ ChatSettings,
+ MessageSecret,
+ NctSalt,
+ LidByPn,
+ PnByLid,
+ PreKey,
+ AppStateMutationMac,
+ PrivacyToken,
+ BufferedEvent,
+ OutgoingEvent,
+ /// Not a store: blobs sealed for callers by [`crate::PgWhatsAppStore::seal`],
+ /// whose "key" is their purpose.
+ Sealed,
+}
+
+impl StoreName {
+ pub(crate) fn as_str(self) -> &'static str {
+ self.into()
+ }
+}
+
+/// A sealed value, ready for its `nonce` and `value` columns.
+pub(crate) struct Sealed {
+ pub(crate) nonce: Vec<u8>,
+ pub(crate) value: Vec<u8>,
+}
+
+/// Seals and opens the values of one account.
+pub(crate) struct ValueCipher {
+ account_id: Uuid,
+ // `aes-gcm` is built with `zeroize`, so the key schedule is wiped on drop.
+ aead: Aes256Gcm,
+}
+
+impl ValueCipher {
+ pub(crate) fn new(account_id: Uuid, data_key: &WhatsAppDataKey) -> Self {
+ Self {
+ account_id,
+ aead: Aes256Gcm::new(data_key.0.as_ref().into()),
+ }
+ }
+
+ /// Encrypts a value stored under `key` in `store`. A composite key passes
+ /// one part per component.
+ pub(crate) fn seal(
+ &self,
+ store: StoreName,
+ key: &[&[u8]],
+ plaintext: &[u8],
+ ) -> Result<Sealed, WhatsAppStoreError> {
+ let nonce: [u8; NONCE_LENGTH] = rand::random();
+ let associated_data = self.associated_data(store, key);
+ let value = self
+ .aead
+ .encrypt(
+ &Nonce::from(nonce),
+ Payload {
+ msg: plaintext,
+ aad: &associated_data,
+ },
+ )
+ .map_err(|_| WhatsAppStoreError::Encrypt)?;
+ Ok(Sealed {
+ nonce: nonce.to_vec(),
+ value,
+ })
+ }
+
+ /// Decrypts a value read from under `key` in `store`. Fails if the
+ /// ciphertext was written for any other account, store or key.
+ pub(crate) fn open(
+ &self,
+ store: StoreName,
+ key: &[&[u8]],
+ nonce: &[u8],
+ value: &[u8],
+ ) -> Result<Vec<u8>, WhatsAppStoreError> {
+ let nonce: [u8; NONCE_LENGTH] =
+ nonce.try_into().map_err(|_| WhatsAppStoreError::Decrypt)?;
+ let associated_data = self.associated_data(store, key);
+ self.aead
+ .decrypt(
+ &Nonce::from(nonce),
+ Payload {
+ msg: value,
+ aad: &associated_data,
+ },
+ )
+ .map_err(|_| WhatsAppStoreError::Decrypt)
+ }
+
+ /// `account_id | store | key…`: the account's 16 bytes, then each other
+ /// part prefixed by its length as a big-endian u32, so no two different
+ /// (store, key) pairs encode to the same bytes.
+ fn associated_data(&self, store: StoreName, key: &[&[u8]]) -> Vec<u8> {
+ let store = store.as_str().as_bytes();
+ let mut associated_data = Vec::with_capacity(
+ 16 + 4 + store.len() + key.iter().map(|part| 4 + part.len()).sum::<usize>(),
+ );
+ associated_data.extend_from_slice(self.account_id.as_bytes());
+ for part in std::iter::once(store).chain(key.iter().copied()) {
+ // Parts are keys and names, far below 4 GiB.
+ let length = u32::try_from(part.len()).unwrap_or(u32::MAX);
+ associated_data.extend_from_slice(&length.to_be_bytes());
+ associated_data.extend_from_slice(part);
+ }
+ associated_data
+ }
+}
diff --git a/crates/whatsapp_store_pg/src/cipher/test.rs b/crates/whatsapp_store_pg/src/cipher/test.rs
new file mode 100644
index 0000000000..9f2b6e2209
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/cipher/test.rs
@@ -0,0 +1,132 @@
+use uuid::Uuid;
+
+use super::*;
+
+const ACCOUNT: Uuid = Uuid::from_u128(1);
+const OTHER_ACCOUNT: Uuid = Uuid::from_u128(2);
+
+fn cipher(account_id: Uuid) -> ValueCipher {
+ ValueCipher::new(
+ account_id,
+ &WhatsAppDataKey::from_plaintext(&[42; 32]).unwrap(),
+ )
+}
+
+#[test]
+fn a_sealed_value_opens_only_under_its_account_store_and_key() {
+ let sealed = cipher(ACCOUNT)
+ .seal(StoreName::Session, &[b"111:0"], b"session")
+ .unwrap();
+
+ assert_eq!(
+ cipher(ACCOUNT)
+ .open(
+ StoreName::Session,
+ &[b"111:0"],
+ &sealed.nonce,
+ &sealed.value
+ )
+ .unwrap(),
+ b"session"
+ );
+ for (account, store, key) in [
+ (OTHER_ACCOUNT, StoreName::Session, b"111:0".as_slice()),
+ (ACCOUNT, StoreName::Identity, b"111:0".as_slice()),
+ (ACCOUNT, StoreName::Session, b"111:1".as_slice()),
+ ] {
+ assert!(matches!(
+ cipher(account).open(store, &[key], &sealed.nonce, &sealed.value),
+ Err(WhatsAppStoreError::Decrypt)
+ ));
+ }
+}
+
+#[test]
+fn key_parts_are_length_prefixed_so_splits_differ() {
+ let sealed = cipher(ACCOUNT)
+ .seal(StoreName::MessageSecret, &[b"ab", b"c"], b"secret")
+ .unwrap();
+ assert!(
+ cipher(ACCOUNT)
+ .open(
+ StoreName::MessageSecret,
+ &[b"a", b"bc"],
+ &sealed.nonce,
+ &sealed.value
+ )
+ .is_err()
+ );
+ assert!(
+ cipher(ACCOUNT)
+ .open(
+ StoreName::MessageSecret,
+ &[b"abc"],
+ &sealed.nonce,
+ &sealed.value
+ )
+ .is_err()
+ );
+}
+
+#[test]
+fn another_data_key_or_a_tampered_value_does_not_open() {
+ let sealed = cipher(ACCOUNT)
+ .seal(StoreName::Session, &[b"111:0"], b"session")
+ .unwrap();
+ let other_key = ValueCipher::new(
+ ACCOUNT,
+ &WhatsAppDataKey::from_plaintext(&[43; 32]).unwrap(),
+ );
+ assert!(
+ other_key
+ .open(
+ StoreName::Session,
+ &[b"111:0"],
+ &sealed.nonce,
+ &sealed.value
+ )
+ .is_err()
+ );
+
+ let mut tampered = sealed.value.clone();
+ tampered[0] ^= 1;
+ assert!(
+ cipher(ACCOUNT)
+ .open(StoreName::Session, &[b"111:0"], &sealed.nonce, &tampered)
+ .is_err()
+ );
+ assert!(
+ cipher(ACCOUNT)
+ .open(
+ StoreName::Session,
+ &[b"111:0"],
+ &sealed.nonce[..11],
+ &sealed.value
+ )
+ .is_err()
+ );
+}
+
+#[test]
+fn every_seal_uses_a_fresh_nonce() {
+ let cipher = cipher(ACCOUNT);
+ let first = cipher
+ .seal(StoreName::Session, &[b"111:0"], b"same")
+ .unwrap();
+ let second = cipher
+ .seal(StoreName::Session, &[b"111:0"], b"same")
+ .unwrap();
+ assert_eq!(first.nonce.len(), 12);
+ assert_ne!(first.nonce, second.nonce);
+ assert_ne!(first.value, second.value);
+}
+
+#[test]
+fn the_data_key_is_32_bytes_and_never_printed() {
+ assert!(matches!(
+ WhatsAppDataKey::from_plaintext(&[1; 31]),
+ Err(WhatsAppStoreError::Malformed)
+ ));
+ let key = WhatsAppDataKey::from_plaintext(&[0xab; 32]).unwrap();
+ assert_eq!(format!("{key:?}"), "WhatsAppDataKey(redacted)");
+}
diff --git a/crates/whatsapp_store_pg/src/error.rs b/crates/whatsapp_store_pg/src/error.rs
new file mode 100644
index 0000000000..6ba8f96a87
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/error.rs
@@ -0,0 +1,68 @@
+//! Store failures, and how they reach whatsmeow.
+
+use whatsmeow::store::StoreError;
+
+use crate::kms::WhatsAppKmsError;
+
+/// Why a store operation failed.
+///
+/// Carries no stored values or keys: these errors end up in logs.
+#[derive(Debug, thiserror::Error)]
+pub enum WhatsAppStoreError {
+ /// The account's lease epoch is no longer the one this store was opened
+ /// with: another replica took the account over, so this one must stop.
+ /// Nothing was written.
+ #[error("whatsapp account lease was taken over; this store is fenced out")]
+ Fenced,
+ /// The linked account does not exist (or was deleted).
+ #[error("whatsapp linked account not found")]
+ AccountNotFound,
+ /// The device was deleted (logged out) after this store was opened.
+ #[error("whatsapp device was deleted")]
+ DeviceDeleted,
+ /// Wrapping or unwrapping the data key failed, including because the
+ /// encryption context did not match.
+ #[error(transparent)]
+ Kms(#[from] WhatsAppKmsError),
+ /// The device row was written by a scheme this build does not know.
+ #[error("whatsapp store uses unsupported encryption version {0}")]
+ UnsupportedVersion(i16),
+ /// A stored value did not decrypt: it was tampered with, or moved from
+ /// another row, store or account.
+ #[error("a stored whatsapp value failed to decrypt")]
+ Decrypt,
+ /// A value could not be encrypted.
+ #[error("a whatsapp value failed to encrypt")]
+ Encrypt,
+ /// A stored value decrypted but is not what its store holds.
+ #[error("a stored whatsapp value is malformed")]
+ Malformed,
+ /// The call was invalid.
+ #[error("{0}")]
+ InvalidArgument(String),
+ /// Postgres failed.
+ #[error("whatsapp store database error: {0}")]
+ Database(#[from] sqlx::Error),
+}
+
+impl From<WhatsAppStoreError> for StoreError {
+ fn from(error: WhatsAppStoreError) -> Self {
+ match error {
+ WhatsAppStoreError::InvalidArgument(message) => StoreError::InvalidArgument(message),
+ WhatsAppStoreError::DeviceDeleted => StoreError::DeviceDeleted,
+ error => StoreError::Internal(rootcause::Report::new(error).into_dynamic()),
+ }
+ }
+}
+
+/// Whether a whatsmeow store failure is this store being fenced out, after
+/// which the caller must stop using the account instead of retrying.
+pub fn is_fenced(error: &StoreError) -> bool {
+ match error {
+ StoreError::Internal(report) => matches!(
+ report.downcast_current_context::<WhatsAppStoreError>(),
+ Some(WhatsAppStoreError::Fenced)
+ ),
+ _ => false,
+ }
+}
diff --git a/crates/whatsapp_store_pg/src/kms.rs b/crates/whatsapp_store_pg/src/kms.rs
new file mode 100644
index 0000000000..660874b0df
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/kms.rs
@@ -0,0 +1,165 @@
+//! Wrapping an account's data key with AWS KMS.
+//!
+//! Envelope encryption, as `microsoft_oauth_grant_db_utils` does, not the
+//! direct KMS calls of `cursor_api_key`: a device store is thousands of small
+//! values written on every message, far too many for a KMS call each. KMS is
+//! called once per account to generate the data key (`GenerateDataKey`) and
+//! once each time a replica takes the account's lease (`Decrypt`); everything
+//! else is local AES-GCM under that key (see [`crate::cipher`]).
+//!
+//! The wrapped key is bound by its encryption context to one user and one
+//! account, and KMS enforces it: a `whatsapp_device` row copied to another
+//! account does not unwrap.
+
+#[cfg(any(test, feature = "fake-kms"))]
+mod fake;
+#[cfg(test)]
+mod test;
+
+use std::collections::HashMap;
+
+use aws_sdk_kms::primitives::Blob;
+use aws_sdk_kms::types::DataKeySpec;
+use uuid::Uuid;
+use zeroize::Zeroizing;
+
+#[cfg(any(test, feature = "fake-kms"))]
+pub use fake::FakeWhatsAppKms;
+
+use crate::cipher::ENCRYPTION_VERSION;
+
+/// Names the purpose in the encryption context, so a data key from another
+/// feature cannot be unwrapped as a WhatsApp one even under the same KMS key.
+const ENCRYPTION_PURPOSE: &str = "whatsapp-session";
+
+/// A freshly generated data key.
+pub struct GeneratedDataKey {
+ /// The plaintext key. Only for sealing values in memory.
+ pub plaintext: Zeroizing<Vec<u8>>,
+ /// The key wrapped by KMS, to store.
+ pub ciphertext: Vec<u8>,
+ /// The KMS key that wrapped it.
+ pub kms_key_id: String,
+}
+
+impl std::fmt::Debug for GeneratedDataKey {
+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ formatter
+ .debug_struct("GeneratedDataKey")
+ .field("kms_key_id", &self.kms_key_id)
+ .finish_non_exhaustive()
+ }
+}
+
+/// A KMS operation failed.
+///
+/// Deliberately opaque: the AWS error can tell "wrong encryption context"
+/// from "no permission", and a caller that can tell them apart can probe. The
+/// detail belongs in CloudTrail.
+#[derive(Debug, thiserror::Error)]
+#[error("whatsapp data key kms operation failed")]
+pub struct WhatsAppKmsError;
+
+/// The KMS operations the store needs, as a seam tests can stand in for.
+pub trait WhatsAppKms: Send + Sync {
+ /// Generates a 256-bit data key wrapped under the configured KMS key and
+ /// `encryption_context`.
+ fn generate_data_key(
+ &self,
+ encryption_context: HashMap<String, String>,
+ ) -> impl Future<Output = Result<GeneratedDataKey, WhatsAppKmsError>> + Send;
+
+ /// Unwraps a data key, which KMS refuses unless `encryption_context`
+ /// matches the one it was generated with. `kms_key_id` is the key the row
+ /// recorded; the AWS adapter ignores it and only ever uses its configured
+ /// key, so changing that key means relinking the accounts.
+ fn decrypt(
+ &self,
+ kms_key_id: &str,
+ ciphertext: &[u8],
+ encryption_context: HashMap<String, String>,
+ ) -> impl Future<Output = Result<Zeroizing<Vec<u8>>, WhatsAppKmsError>> + Send;
+}
+
+/// The encryption context of an account's data key.
+///
+/// The one place it is built, so it cannot be built two slightly different
+/// ways: a context that differs at all is a key nothing can unwrap again.
+pub(crate) fn encryption_context(user_id: &str, account_id: Uuid) -> HashMap<String, String> {
+ HashMap::from([
+ ("macro:purpose".to_owned(), ENCRYPTION_PURPOSE.to_owned()),
+ ("macro:user-id".to_owned(), user_id.to_owned()),
+ ("macro:account-id".to_owned(), account_id.to_string()),
+ (
+ "macro:encryption-version".to_owned(),
+ ENCRYPTION_VERSION.to_string(),
+ ),
+ ])
+}
+
+/// [`WhatsAppKms`] over a real AWS KMS client.
+///
+/// The key must be separate from the Cursor and Microsoft ones: whatever can
+/// unwrap WhatsApp data keys can read every linked account's sessions.
+#[derive(Clone)]
+pub struct AwsWhatsAppKms {
+ client: aws_sdk_kms::Client,
+ kms_key_id: String,
+}
+
+impl AwsWhatsAppKms {
+ /// Generates data keys under `kms_key_id`, and unwraps them.
+ pub fn new(client: aws_sdk_kms::Client, kms_key_id: String) -> Self {
+ Self { client, kms_key_id }
+ }
+}
+
+impl WhatsAppKms for AwsWhatsAppKms {
+ #[tracing::instrument(skip_all, err)]
+ async fn generate_data_key(
+ &self,
+ encryption_context: HashMap<String, String>,
+ ) -> Result<GeneratedDataKey, WhatsAppKmsError> {
+ let response = self
+ .client
+ .generate_data_key()
+ .key_id(&self.kms_key_id)
+ .key_spec(DataKeySpec::Aes256)
+ .set_encryption_context(Some(encryption_context))
+ .send()
+ .await
+ .map_err(|_| WhatsAppKmsError)?;
+ let plaintext = response.plaintext.ok_or(WhatsAppKmsError)?;
+ let ciphertext = response.ciphertext_blob.ok_or(WhatsAppKmsError)?;
+ Ok(GeneratedDataKey {
+ plaintext: Zeroizing::new(plaintext.into_inner()),
+ ciphertext: ciphertext.into_inner(),
+ // The response names the fully qualified ARN even when the
+ // configured id is an alias, which is what the row records.
+ kms_key_id: response.key_id.ok_or(WhatsAppKmsError)?,
+ })
+ }
+
+ #[tracing::instrument(skip_all, err)]
+ async fn decrypt(
+ &self,
+ _kms_key_id: &str,
+ ciphertext: &[u8],
+ encryption_context: HashMap<String, String>,
+ ) -> Result<Zeroizing<Vec<u8>>, WhatsAppKmsError> {
+ let response = self
+ .client
+ .decrypt()
+ // Always the configured key, never the id stored with the row: a
+ // blob wrapped under any other key is refused, even if this role
+ // could use that key.
+ .key_id(&self.kms_key_id)
+ .ciphertext_blob(Blob::new(ciphertext))
+ .set_encryption_context(Some(encryption_context))
+ .send()
+ .await
+ .map_err(|_| WhatsAppKmsError)?;
+ let plaintext = response.plaintext.ok_or(WhatsAppKmsError)?;
+ Ok(Zeroizing::new(plaintext.into_inner()))
+ }
+}
diff --git a/crates/whatsapp_store_pg/src/kms/fake.rs b/crates/whatsapp_store_pg/src/kms/fake.rs
new file mode 100644
index 0000000000..d10fe1121b
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/kms/fake.rs
@@ -0,0 +1,110 @@
+//! An in-memory stand-in for KMS, for tests.
+
+use std::collections::{BTreeMap, HashMap};
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use aes_gcm::aead::{Aead, Payload};
+use aes_gcm::{Aes256Gcm, KeyInit, Nonce};
+use zeroize::Zeroizing;
+
+use super::{GeneratedDataKey, WhatsAppKms, WhatsAppKmsError};
+
+const NONCE_LENGTH: usize = 12;
+
+/// Wraps data keys under a random in-memory key with the encryption context
+/// as associated data, so like KMS it refuses to unwrap under any other
+/// context or key id. Counts calls, so tests can check how often a store
+/// talks to KMS.
+pub struct FakeWhatsAppKms {
+ kms_key_id: String,
+ wrapping_key: Aes256Gcm,
+ generate_calls: AtomicUsize,
+ decrypt_calls: AtomicUsize,
+}
+
+impl FakeWhatsAppKms {
+ /// A fake whose wrapped keys name `kms_key_id`.
+ pub fn new(kms_key_id: &str) -> Self {
+ let wrapping_key: [u8; 32] = rand::random();
+ Self {
+ kms_key_id: kms_key_id.to_owned(),
+ wrapping_key: Aes256Gcm::new(&wrapping_key.into()),
+ generate_calls: AtomicUsize::new(0),
+ decrypt_calls: AtomicUsize::new(0),
+ }
+ }
+
+ /// How many data keys were generated.
+ pub fn generate_calls(&self) -> usize {
+ self.generate_calls.load(Ordering::SeqCst)
+ }
+
+ /// How many data keys were unwrapped (successfully or not).
+ pub fn decrypt_calls(&self) -> usize {
+ self.decrypt_calls.load(Ordering::SeqCst)
+ }
+
+ fn associated_data(encryption_context: HashMap<String, String>) -> Vec<u8> {
+ let sorted: BTreeMap<String, String> = encryption_context.into_iter().collect();
+ let mut associated_data = Vec::new();
+ for (key, value) in sorted {
+ for part in [key, value] {
+ associated_data.extend_from_slice(&(part.len() as u64).to_be_bytes());
+ associated_data.extend_from_slice(part.as_bytes());
+ }
+ }
+ associated_data
+ }
+}
+
+impl WhatsAppKms for FakeWhatsAppKms {
+ async fn generate_data_key(
+ &self,
+ encryption_context: HashMap<String, String>,
+ ) -> Result<GeneratedDataKey, WhatsAppKmsError> {
+ self.generate_calls.fetch_add(1, Ordering::SeqCst);
+ let plaintext: [u8; 32] = rand::random();
+ let nonce: [u8; NONCE_LENGTH] = rand::random();
+ let wrapped = self
+ .wrapping_key
+ .encrypt(
+ &Nonce::from(nonce),
+ Payload {
+ msg: &plaintext,
+ aad: &Self::associated_data(encryption_context),
+ },
+ )
+ .map_err(|_| WhatsAppKmsError)?;
+ Ok(GeneratedDataKey {
+ plaintext: Zeroizing::new(plaintext.to_vec()),
+ ciphertext: [nonce.as_slice(), &wrapped].concat(),
+ kms_key_id: self.kms_key_id.clone(),
+ })
+ }
+
+ async fn decrypt(
+ &self,
+ kms_key_id: &str,
+ ciphertext: &[u8],
+ encryption_context: HashMap<String, String>,
+ ) -> Result<Zeroizing<Vec<u8>>, WhatsAppKmsError> {
+ self.decrypt_calls.fetch_add(1, Ordering::SeqCst);
+ if kms_key_id != self.kms_key_id {
+ return Err(WhatsAppKmsError);
+ }
+ let (nonce, wrapped) = ciphertext
+ .split_first_chunk::<NONCE_LENGTH>()
+ .ok_or(WhatsAppKmsError)?;
+ let plaintext = self
+ .wrapping_key
+ .decrypt(
+ &Nonce::from(*nonce),
+ Payload {
+ msg: wrapped,
+ aad: &Self::associated_data(encryption_context),
+ },
+ )
+ .map_err(|_| WhatsAppKmsError)?;
+ Ok(Zeroizing::new(plaintext))
+ }
+}
diff --git a/crates/whatsapp_store_pg/src/kms/test.rs b/crates/whatsapp_store_pg/src/kms/test.rs
new file mode 100644
index 0000000000..584d2d1e38
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/kms/test.rs
@@ -0,0 +1,71 @@
+use uuid::Uuid;
+
+use super::*;
+
+const ACCOUNT: Uuid = Uuid::from_u128(1);
+
+#[test]
+fn the_encryption_context_names_the_purpose_user_account_and_version() {
+ assert_eq!(
+ encryption_context("macro|alice", ACCOUNT),
+ HashMap::from([
+ ("macro:purpose".to_owned(), "whatsapp-session".to_owned()),
+ ("macro:user-id".to_owned(), "macro|alice".to_owned()),
+ (
+ "macro:account-id".to_owned(),
+ "00000000-0000-0000-0000-000000000001".to_owned()
+ ),
+ ("macro:encryption-version".to_owned(), "1".to_owned()),
+ ])
+ );
+}
+
+#[tokio::test]
+async fn the_fake_unwraps_only_under_the_same_context_and_key() {
+ let kms = FakeWhatsAppKms::new("key-1");
+ let context = encryption_context("macro|alice", ACCOUNT);
+ let generated = kms.generate_data_key(context.clone()).await.unwrap();
+ assert_eq!(generated.plaintext.len(), 32);
+ assert_eq!(generated.kms_key_id, "key-1");
+
+ let unwrapped = kms
+ .decrypt("key-1", &generated.ciphertext, context.clone())
+ .await
+ .unwrap();
+ assert_eq!(*unwrapped, *generated.plaintext);
+
+ for wrong_context in [
+ encryption_context("macro|bob", ACCOUNT),
+ encryption_context("macro|alice", Uuid::from_u128(2)),
+ ] {
+ assert!(
+ kms.decrypt("key-1", &generated.ciphertext, wrong_context)
+ .await
+ .is_err()
+ );
+ }
+ assert!(
+ kms.decrypt("key-2", &generated.ciphertext, context.clone())
+ .await
+ .is_err()
+ );
+ assert!(
+ FakeWhatsAppKms::new("key-1")
+ .decrypt("key-1", &generated.ciphertext, context)
+ .await
+ .is_err()
+ );
+ assert_eq!((kms.generate_calls(), kms.decrypt_calls()), (1, 4));
+}
+
+#[test]
+fn a_generated_key_never_prints_its_plaintext() {
+ let generated = GeneratedDataKey {
+ plaintext: Zeroizing::new(vec![0xab; 32]),
+ ciphertext: vec![1, 2, 3],
+ kms_key_id: "key-1".to_owned(),
+ };
+ let printed = format!("{generated:?}");
+ assert!(!printed.contains("171"), "{printed}");
+ assert!(printed.contains("key-1"));
+}
diff --git a/crates/whatsapp_store_pg/src/lib.rs b/crates/whatsapp_store_pg/src/lib.rs
new file mode 100644
index 0000000000..db4ae36b63
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/lib.rs
@@ -0,0 +1,55 @@
+#![deny(missing_docs)]
+//! The whatsmeow device store of a linked WhatsApp account, in Postgres.
+//!
+//! [`PgWhatsAppStore`] implements every store trait of `whatsmeow::store` for
+//! one account: Signal identities, sessions, prekeys and sender keys, app
+//! state keys and versions, contacts, chat settings, message secrets, privacy
+//! tokens, event buffers and LID mappings, plus the device's own keys
+//! ([`whatsmeow::store::DeviceContainer`]). [`PgWhatsAppStore::load_device`]
+//! hands out a [`whatsmeow::store::Device`] backed by it.
+//!
+//! # Threat model
+//!
+//! The store holds the keys of a person's WhatsApp account. With the noise
+//! and identity keys and the sessions, anyone can impersonate the linked
+//! device: read the person's new messages and send as them, until they unlink
+//! it. So every value is encrypted at rest:
+//!
+//! - **Per-account data key** ([`cipher`]): AES-256-GCM, a fresh random nonce
+//! per write, and associated data binding each ciphertext to its account,
+//! store and key. A value copied to another row, store or account fails to
+//! decrypt.
+//! - **Wrapped by KMS** ([`kms`]): the data key is generated by KMS once per
+//! account and stored only wrapped, under an encryption context naming the
+//! user and the account. A replica unwraps it once when it takes the
+//! account's lease and holds it in memory (zeroized on drop, never logged or
+//! serialized) until the store is dropped. A database dump alone decrypts
+//! nothing; every unwrap is an IAM-gated, CloudTrail-recorded KMS call.
+//! - **Plaintext lookup keys**: Signal addresses, JIDs (which contain phone
+//! numbers), message IDs, prekey IDs, app state index MACs and timestamps
+//! stay plaintext so they can be indexed. Values (keys, sessions, sender
+//! keys, app state keys, versions and value MACs, names, settings, secrets,
+//! tokens, event plaintexts, and which LID belongs to which phone number)
+//! are all sealed.
+//!
+//! What this does not protect against: a process holding the lease has the
+//! plaintext data key, and whatsmeow's [`whatsmeow::store::Device`] holds the
+//! device's private keys in memory for the whole connection.
+//!
+//! # Fencing
+//!
+//! A store is opened for the lease epoch its caller holds. Every write checks
+//! `whatsapp_linked_account.lease_epoch` in the same transaction and fails
+//! with [`WhatsAppStoreError::Fenced`] (see [`is_fenced`] for whatsmeow's
+//! errors) once another replica has taken the account over.
+//!
+//! Deleting the account or its device row deletes the keys; it does not
+//! unlink the device at WhatsApp. A "disconnect" surface must log out first.
+
+pub mod cipher;
+mod error;
+pub mod kms;
+mod store;
+
+pub use error::{WhatsAppStoreError, is_fenced};
+pub use store::PgWhatsAppStore;
diff --git a/crates/whatsapp_store_pg/src/store.rs b/crates/whatsapp_store_pg/src/store.rs
new file mode 100644
index 0000000000..8a7694c850
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store.rs
@@ -0,0 +1,555 @@
+//! The device store of one linked account, and the row helpers every
+//! whatsmeow store trait is built from.
+
+mod app_state;
+mod contacts;
+mod device;
+mod events;
+mod lid;
+mod signal;
+#[cfg(test)]
+mod test;
+
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::sync::Mutex;
+
+use sqlx::{PgConnection, PgExecutor, PgPool, Postgres, Transaction};
+use uuid::Uuid;
+use zeroize::Zeroizing;
+
+use crate::cipher::{ENCRYPTION_VERSION, StoreName, ValueCipher, WhatsAppDataKey};
+use crate::error::WhatsAppStoreError;
+use crate::kms::{WhatsAppKms, encryption_context};
+
+/// Every whatsmeow store of one linked account, in Postgres.
+///
+/// Holds the account's data key in memory (see [`crate::cipher`]) and the
+/// lease epoch the caller held when it opened the store. Every write runs in
+/// a transaction that first checks the account still has that epoch, and
+/// holds a share lock on the account row until it commits, so once a
+/// takeover has bumped the epoch no write from the previous holder can land.
+pub struct PgWhatsAppStore {
+ pool: PgPool,
+ account_id: Uuid,
+ lease_epoch: i64,
+ cipher: ValueCipher,
+ /// Phone number Signal users already moved to their LID, as whatsmeow
+ /// remembers them, so a migration runs once per user per process.
+ migrated_pn_sessions: Mutex<HashSet<String>>,
+}
+
+impl std::fmt::Debug for PgWhatsAppStore {
+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ formatter
+ .debug_struct("PgWhatsAppStore")
+ .field("account_id", &self.account_id)
+ .field("lease_epoch", &self.lease_epoch)
+ .finish_non_exhaustive()
+ }
+}
+
+impl PgWhatsAppStore {
+ /// Opens the store of `account_id` for the holder of `lease_epoch`.
+ ///
+ /// The first open of an account generates its data key (one KMS
+ /// `GenerateDataKey`) and stores it wrapped; every later open unwraps it
+ /// (one KMS `Decrypt`). The plaintext key then stays in memory only.
+ ///
+ /// # Errors
+ /// [`WhatsAppStoreError::Fenced`] when the account's epoch is not
+ /// `lease_epoch`, [`WhatsAppStoreError::Kms`] when KMS refuses, and
+ /// database errors.
+ #[tracing::instrument(
+ name = "whatsapp_store.open",
+ skip(pool, kms),
+ fields(account_id = %account_id, lease_epoch, created),
+ err
+ )]
+ pub async fn open(
+ pool: PgPool,
+ account_id: Uuid,
+ lease_epoch: i64,
+ kms: &impl WhatsAppKms,
+ ) -> Result<Self, WhatsAppStoreError> {
+ let account = sqlx::query!(
+ r#"
+ SELECT user_id, lease_epoch
+ FROM whatsapp_linked_account
+ WHERE id = $1
+ "#,
+ account_id,
+ )
+ .fetch_optional(&pool)
+ .await?
+ .ok_or(WhatsAppStoreError::AccountNotFound)?;
+ if account.lease_epoch != lease_epoch {
+ return Err(WhatsAppStoreError::Fenced);
+ }
+ let context = encryption_context(&account.user_id, account_id);
+
+ let data_key = match read_wrapped_data_key(&pool, account_id).await? {
+ Some(wrapped) => wrapped.unwrap(kms, context).await?,
+ None => {
+ let generated = kms.generate_data_key(context.clone()).await?;
+ let mut transaction = pool.begin().await?;
+ check_lease(&mut transaction, account_id, lease_epoch).await?;
+ let inserted = sqlx::query_scalar!(
+ r#"
+ INSERT INTO whatsapp_device (
+ account_id,
+ data_key_ciphertext,
+ kms_key_id,
+ encryption_version
+ )
+ VALUES ($1, $2, $3, $4)
+ ON CONFLICT (account_id) DO NOTHING
+ RETURNING account_id
+ "#,
+ account_id,
+ generated.ciphertext,
+ generated.kms_key_id,
+ ENCRYPTION_VERSION,
+ )
+ .fetch_optional(&mut *transaction)
+ .await?;
+ transaction.commit().await?;
+ tracing::Span::current().record("created", inserted.is_some());
+ match inserted {
+ Some(_) => WhatsAppDataKey::from_plaintext(&generated.plaintext)?,
+ // Another open created the device first: use its key.
+ None => {
+ read_wrapped_data_key(&pool, account_id)
+ .await?
+ .ok_or(WhatsAppStoreError::DeviceDeleted)?
+ .unwrap(kms, context)
+ .await?
+ }
+ }
+ }
+ };
+
+ Ok(Self {
+ pool,
+ account_id,
+ lease_epoch,
+ cipher: ValueCipher::new(account_id, &data_key),
+ migrated_pn_sessions: Mutex::new(HashSet::new()),
+ })
+ }
+
+ /// The account this store belongs to.
+ pub fn account_id(&self) -> Uuid {
+ self.account_id
+ }
+
+ /// The lease epoch every write is checked against.
+ pub fn lease_epoch(&self) -> i64 {
+ self.lease_epoch
+ }
+
+ /// Encrypts a blob the caller keeps elsewhere (e.g. a media download
+ /// locator) under the account's data key, bound to the account and
+ /// `purpose`: it only unseals with [`PgWhatsAppStore::unseal`] for the same
+ /// account and purpose. The output is `SEALED_FORMAT | nonce | ciphertext`.
+ ///
+ /// # Errors
+ /// [`WhatsAppStoreError::Encrypt`] if encryption fails.
+ pub fn seal(&self, purpose: &str, plaintext: &[u8]) -> Result<Vec<u8>, WhatsAppStoreError> {
+ let sealed = self
+ .cipher
+ .seal(StoreName::Sealed, &[purpose.as_bytes()], plaintext)?;
+ Ok([&[SEALED_FORMAT], sealed.nonce.as_slice(), &sealed.value].concat())
+ }
+
+ /// Decrypts a blob from [`PgWhatsAppStore::seal`].
+ ///
+ /// # Errors
+ /// [`WhatsAppStoreError::Decrypt`] if it was sealed for another account or
+ /// purpose, was tampered with, or is not in a known format.
+ pub fn unseal(
+ &self,
+ purpose: &str,
+ sealed: &[u8],
+ ) -> Result<Zeroizing<Vec<u8>>, WhatsAppStoreError> {
+ let Some((&SEALED_FORMAT, rest)) = sealed.split_first() else {
+ return Err(WhatsAppStoreError::Decrypt);
+ };
+ let (nonce, value) = rest
+ .split_at_checked(SEALED_NONCE_LENGTH)
+ .ok_or(WhatsAppStoreError::Decrypt)?;
+ Ok(Zeroizing::new(self.cipher.open(
+ StoreName::Sealed,
+ &[purpose.as_bytes()],
+ nonce,
+ value,
+ )?))
+ }
+
+ /// Begins a write transaction, failing with
+ /// [`WhatsAppStoreError::Fenced`] unless this store still holds the lease.
+ async fn begin_write(&self) -> Result<Transaction<'static, Postgres>, WhatsAppStoreError> {
+ let mut transaction = self.pool.begin().await?;
+ check_lease(&mut transaction, self.account_id, self.lease_epoch).await?;
+ Ok(transaction)
+ }
+
+ /// Serializes read-modify-write operations of this account until the
+ /// transaction ends. `NO KEY UPDATE`, so plain writes (whose foreign keys
+ /// take `KEY SHARE` locks on the device row) are not blocked.
+ async fn lock_device(&self, connection: &mut PgConnection) -> Result<(), WhatsAppStoreError> {
+ sqlx::query_scalar!(
+ r#"
+ SELECT account_id
+ FROM whatsapp_device
+ WHERE account_id = $1
+ FOR NO KEY UPDATE
+ "#,
+ self.account_id,
+ )
+ .fetch_optional(connection)
+ .await?
+ .ok_or(WhatsAppStoreError::DeviceDeleted)?;
+ Ok(())
+ }
+
+ async fn get_value(
+ &self,
+ executor: impl PgExecutor<'_>,
+ store: StoreName,
+ key: &str,
+ ) -> Result<Option<Vec<u8>>, WhatsAppStoreError> {
+ let row = sqlx::query!(
+ r#"
+ SELECT nonce, value
+ FROM whatsapp_store_value
+ WHERE account_id = $1 AND store = $2 AND key = $3
+ "#,
+ self.account_id,
+ store.as_str(),
+ key,
+ )
+ .fetch_optional(executor)
+ .await?;
+ row.map(|row| {
+ self.cipher
+ .open(store, &[key.as_bytes()], &row.nonce, &row.value)
+ })
+ .transpose()
+ }
+
+ /// The values of the keys that have one.
+ async fn get_values(
+ &self,
+ executor: impl PgExecutor<'_>,
+ store: StoreName,
+ keys: &[String],
+ ) -> Result<HashMap<String, Vec<u8>>, WhatsAppStoreError> {
+ if keys.is_empty() {
+ return Ok(HashMap::new());
+ }
+ let rows = sqlx::query!(
+ r#"
+ SELECT key, nonce, value
+ FROM whatsapp_store_value
+ WHERE account_id = $1 AND store = $2 AND key = ANY($3)
+ "#,
+ self.account_id,
+ store.as_str(),
+ keys,
+ )
+ .fetch_all(executor)
+ .await?;
+ rows.into_iter()
+ .map(|row| {
+ let value =
+ self.cipher
+ .open(store, &[row.key.as_bytes()], &row.nonce, &row.value)?;
+ Ok((row.key, value))
+ })
+ .collect()
+ }
+
+ /// Every value whose key starts with `prefix`, in key order.
+ async fn list_values(
+ &self,
+ executor: impl PgExecutor<'_>,
+ store: StoreName,
+ prefix: &str,
+ ) -> Result<Vec<(String, Vec<u8>)>, WhatsAppStoreError> {
+ let rows = sqlx::query!(
+ r#"
+ SELECT key, nonce, value
+ FROM whatsapp_store_value
+ WHERE account_id = $1 AND store = $2 AND key LIKE $3
+ ORDER BY key
+ "#,
+ self.account_id,
+ store.as_str(),
+ like_prefix(prefix),
+ )
+ .fetch_all(executor)
+ .await?;
+ rows.into_iter()
+ .map(|row| {
+ let value =
+ self.cipher
+ .open(store, &[row.key.as_bytes()], &row.nonce, &row.value)?;
+ Ok((row.key, value))
+ })
+ .collect()
+ }
+
+ /// Writes many values in one statement, replacing existing ones.
+ async fn put_values(
+ &self,
+ connection: &mut PgConnection,
+ store: StoreName,
+ entries: BTreeMap<String, Vec<u8>>,
+ ) -> Result<(), WhatsAppStoreError> {
+ let (keys, nonces, values) = self.seal_values(store, entries)?;
+ if keys.is_empty() {
+ return Ok(());
+ }
+ sqlx::query!(
+ r#"
+ INSERT INTO whatsapp_store_value (account_id, store, key, nonce, value)
+ SELECT $1, $2, entry.key, entry.nonce, entry.value
+ FROM UNNEST($3::text[], $4::bytea[], $5::bytea[]) AS entry(key, nonce, value)
+ ON CONFLICT (account_id, store, key) DO UPDATE SET
+ nonce = EXCLUDED.nonce,
+ value = EXCLUDED.value,
+ updated_at = now()
+ "#,
+ self.account_id,
+ store.as_str(),
+ &keys,
+ &nonces,
+ &values,
+ )
+ .execute(connection)
+ .await?;
+ Ok(())
+ }
+
+ /// Writes many values in one statement, keeping existing ones.
+ async fn insert_values_if_absent(
+ &self,
+ connection: &mut PgConnection,
+ store: StoreName,
+ entries: BTreeMap<String, Vec<u8>>,
+ ) -> Result<(), WhatsAppStoreError> {
+ let (keys, nonces, values) = self.seal_values(store, entries)?;
+ if keys.is_empty() {
+ return Ok(());
+ }
+ sqlx::query!(
+ r#"
+ INSERT INTO whatsapp_store_value (account_id, store, key, nonce, value)
+ SELECT $1, $2, entry.key, entry.nonce, entry.value
+ FROM UNNEST($3::text[], $4::bytea[], $5::bytea[]) AS entry(key, nonce, value)
+ ON CONFLICT (account_id, store, key) DO NOTHING
+ "#,
+ self.account_id,
+ store.as_str(),
+ &keys,
+ &nonces,
+ &values,
+ )
+ .execute(connection)
+ .await?;
+ Ok(())
+ }
+
+ /// Seals entries into the three arrays of an `UNNEST` insert. A map, so a
+ /// batch never names one key twice (which `ON CONFLICT` rejects), and in
+ /// key order, so concurrent batches lock rows in the same order.
+ #[expect(
+ clippy::type_complexity,
+ reason = "the three UNNEST columns, used right away by both callers"
+ )]
+ fn seal_values(
+ &self,
+ store: StoreName,
+ entries: BTreeMap<String, Vec<u8>>,
+ ) -> Result<(Vec<String>, Vec<Vec<u8>>, Vec<Vec<u8>>), WhatsAppStoreError> {
+ let mut keys = Vec::with_capacity(entries.len());
+ let mut nonces = Vec::with_capacity(entries.len());
+ let mut values = Vec::with_capacity(entries.len());
+ for (key, plaintext) in entries {
+ let sealed = self.cipher.seal(store, &[key.as_bytes()], &plaintext)?;
+ keys.push(key);
+ nonces.push(sealed.nonce);
+ values.push(sealed.value);
+ }
+ Ok((keys, nonces, values))
+ }
+
+ async fn delete_values(
+ &self,
+ connection: &mut PgConnection,
+ store: StoreName,
+ keys: &[String],
+ ) -> Result<(), WhatsAppStoreError> {
+ if keys.is_empty() {
+ return Ok(());
+ }
+ sqlx::query!(
+ r#"
+ DELETE FROM whatsapp_store_value
+ WHERE account_id = $1 AND store = $2 AND key = ANY($3)
+ "#,
+ self.account_id,
+ store.as_str(),
+ keys,
+ )
+ .execute(connection)
+ .await?;
+ Ok(())
+ }
+
+ async fn delete_prefix(
+ &self,
+ connection: &mut PgConnection,
+ store: StoreName,
+ prefix: &str,
+ ) -> Result<(), WhatsAppStoreError> {
+ sqlx::query!(
+ r#"
+ DELETE FROM whatsapp_store_value
+ WHERE account_id = $1 AND store = $2 AND key LIKE $3
+ "#,
+ self.account_id,
+ store.as_str(),
+ like_prefix(prefix),
+ )
+ .execute(connection)
+ .await?;
+ Ok(())
+ }
+
+ /// Writes one value in its own fenced transaction.
+ async fn put_one(
+ &self,
+ store: StoreName,
+ key: String,
+ plaintext: Vec<u8>,
+ ) -> Result<(), WhatsAppStoreError> {
+ let mut transaction = self.begin_write().await?;
+ self.put_values(&mut transaction, store, BTreeMap::from([(key, plaintext)]))
+ .await?;
+ transaction.commit().await?;
+ Ok(())
+ }
+
+ /// Deletes one value in its own fenced transaction.
+ async fn delete_one(&self, store: StoreName, key: String) -> Result<(), WhatsAppStoreError> {
+ let mut transaction = self.begin_write().await?;
+ self.delete_values(&mut transaction, store, &[key]).await?;
+ transaction.commit().await?;
+ Ok(())
+ }
+}
+
+/// Fails with [`WhatsAppStoreError::Fenced`] unless the account still has
+/// `lease_epoch`, and share-locks the account row until the transaction ends
+/// so a takeover's epoch bump waits for this write.
+async fn check_lease(
+ connection: &mut PgConnection,
+ account_id: Uuid,
+ lease_epoch: i64,
+) -> Result<(), WhatsAppStoreError> {
+ let current = sqlx::query_scalar!(
+ r#"
+ SELECT lease_epoch
+ FROM whatsapp_linked_account
+ WHERE id = $1
+ FOR SHARE
+ "#,
+ account_id,
+ )
+ .fetch_optional(connection)
+ .await?;
+ if current == Some(lease_epoch) {
+ Ok(())
+ } else {
+ Err(WhatsAppStoreError::Fenced)
+ }
+}
+
+/// The device row's wrapped data key.
+struct WrappedDataKey {
+ data_key_ciphertext: Vec<u8>,
+ kms_key_id: String,
+ encryption_version: i16,
+}
+
+impl WrappedDataKey {
+ async fn unwrap(
+ self,
+ kms: &impl WhatsAppKms,
+ context: HashMap<String, String>,
+ ) -> Result<WhatsAppDataKey, WhatsAppStoreError> {
+ // Checked before the KMS call: a version this build cannot read is our
+ // bug to report, not a request worth a KMS call.
+ if self.encryption_version != ENCRYPTION_VERSION {
+ return Err(WhatsAppStoreError::UnsupportedVersion(
+ self.encryption_version,
+ ));
+ }
+ let plaintext = kms
+ .decrypt(&self.kms_key_id, &self.data_key_ciphertext, context)
+ .await?;
+ WhatsAppDataKey::from_plaintext(&plaintext)
+ }
+}
+
+async fn read_wrapped_data_key(
+ pool: &PgPool,
+ account_id: Uuid,
+) -> Result<Option<WrappedDataKey>, WhatsAppStoreError> {
+ Ok(sqlx::query_as!(
+ WrappedDataKey,
+ r#"
+ SELECT data_key_ciphertext, kms_key_id, encryption_version
+ FROM whatsapp_device
+ WHERE account_id = $1
+ "#,
+ account_id,
+ )
+ .fetch_optional(pool)
+ .await?)
+}
+
+/// A `LIKE` pattern matching keys that start with `prefix`. Signal users of
+/// LIDs contain `_`, a `LIKE` wildcard, so the prefix is escaped.
+fn like_prefix(prefix: &str) -> String {
+ let mut pattern = String::with_capacity(prefix.len() + 1);
+ for character in prefix.chars() {
+ if matches!(character, '\\' | '%' | '_') {
+ pattern.push('\\');
+ }
+ pattern.push(character);
+ }
+ pattern.push('%');
+ pattern
+}
+
+/// Joins the parts of a composite key. The separator appears in no JID,
+/// Signal address or message ID; a part containing it is rejected so two
+/// different keys can never join to the same string.
+fn composite_key(parts: &[&str]) -> Result<String, WhatsAppStoreError> {
+ // The part itself stays out of the error: it may be a phone number.
+ if parts.iter().any(|part| part.contains(KEY_SEPARATOR)) {
+ return Err(WhatsAppStoreError::InvalidArgument(format!(
+ "a store key part contains {KEY_SEPARATOR:?}"
+ )));
+ }
+ Ok(parts.join(KEY_SEPARATOR))
+}
+
+const KEY_SEPARATOR: &str = "|";
+
+/// The first byte of a [`PgWhatsAppStore::seal`] output, so another format can
+/// be added later.
+const SEALED_FORMAT: u8 = 1;
+const SEALED_NONCE_LENGTH: usize = 12;
diff --git a/crates/whatsapp_store_pg/src/store/app_state.rs b/crates/whatsapp_store_pg/src/store/app_state.rs
new file mode 100644
index 0000000000..fc5123bd76
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/app_state.rs
@@ -0,0 +1,297 @@
+//! App state sync keys, collection versions and mutation MACs.
+
+#[cfg(test)]
+mod test;
+
+use std::collections::BTreeMap;
+
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use whatsmeow::store::{
+ AppStateMutationMac, AppStateStore, AppStateSyncKey, AppStateSyncKeyStore, StoreError,
+};
+
+use super::PgWhatsAppStore;
+use crate::cipher::StoreName;
+use crate::error::WhatsAppStoreError;
+
+const HASH_LENGTH: usize = 128;
+
+/// An app state sync key as sealed in its value.
+#[derive(Serialize, Deserialize)]
+struct SyncKeyRecord {
+ data: Vec<u8>,
+ fingerprint: Vec<u8>,
+ timestamp: i64,
+}
+
+impl From<SyncKeyRecord> for AppStateSyncKey {
+ fn from(record: SyncKeyRecord) -> Self {
+ AppStateSyncKey {
+ data: record.data,
+ fingerprint: record.fingerprint,
+ timestamp: record.timestamp,
+ }
+ }
+}
+
+fn decode_sync_key(plaintext: &[u8]) -> Result<SyncKeyRecord, WhatsAppStoreError> {
+ postcard::from_bytes(plaintext).map_err(|_| WhatsAppStoreError::Malformed)
+}
+
+impl PgWhatsAppStore {
+ /// Every sync key with its ID, newest first.
+ async fn all_sync_keys(&self) -> Result<Vec<(Vec<u8>, SyncKeyRecord)>, WhatsAppStoreError> {
+ let mut keys = self
+ .list_values(&self.pool, StoreName::AppStateSyncKey, "")
+ .await?
+ .into_iter()
+ .map(|(id, plaintext)| {
+ let id = hex::decode(id).map_err(|_| WhatsAppStoreError::Malformed)?;
+ Ok((id, decode_sync_key(&plaintext)?))
+ })
+ .collect::<Result<Vec<_>, WhatsAppStoreError>>()?;
+ keys.sort_by_key(|(_, key)| std::cmp::Reverse(key.timestamp));
+ Ok(keys)
+ }
+}
+
+/// An account has a handful of sync keys, so "newest" is computed over all
+/// of them after decrypting rather than from a plaintext timestamp column.
+#[async_trait]
+impl AppStateSyncKeyStore for PgWhatsAppStore {
+ async fn put_app_state_sync_key(
+ &self,
+ id: &[u8],
+ key: AppStateSyncKey,
+ ) -> Result<(), StoreError> {
+ let id = hex::encode(id);
+ let mut transaction = self.begin_write().await?;
+ self.lock_device(&mut transaction).await?;
+ let existing = self
+ .get_value(&mut *transaction, StoreName::AppStateSyncKey, &id)
+ .await?
+ .map(|plaintext| decode_sync_key(&plaintext))
+ .transpose()?;
+ // As whatsmeow: a key is only replaced by a newer one.
+ if existing.is_some_and(|existing| key.timestamp <= existing.timestamp) {
+ return Ok(());
+ }
+ let record = SyncKeyRecord {
+ data: key.data,
+ fingerprint: key.fingerprint,
+ timestamp: key.timestamp,
+ };
+ let plaintext =
+ postcard::to_allocvec(&record).map_err(|_| WhatsAppStoreError::Malformed)?;
+ self.put_values(
+ &mut transaction,
+ StoreName::AppStateSyncKey,
+ BTreeMap::from([(id, plaintext)]),
+ )
+ .await?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn get_app_state_sync_key(
+ &self,
+ id: &[u8],
+ ) -> Result<Option<AppStateSyncKey>, StoreError> {
+ Ok(self
+ .get_value(&self.pool, StoreName::AppStateSyncKey, &hex::encode(id))
+ .await?
+ .map(|plaintext| decode_sync_key(&plaintext).map(AppStateSyncKey::from))
+ .transpose()?)
+ }
+
+ async fn get_latest_app_state_sync_key_id(&self) -> Result<Option<Vec<u8>>, StoreError> {
+ Ok(self
+ .all_sync_keys()
+ .await?
+ .into_iter()
+ .next()
+ .map(|(id, _)| id))
+ }
+
+ async fn get_all_app_state_sync_keys(&self) -> Result<Vec<AppStateSyncKey>, StoreError> {
+ Ok(self
+ .all_sync_keys()
+ .await?
+ .into_iter()
+ .map(|(_, key)| key.into())
+ .collect())
+ }
+}
+
+/// The version and LT hash of a collection, sealed as the version (8 bytes,
+/// big endian) followed by the 128-byte hash.
+fn encode_version(version: u64, hash: &[u8; HASH_LENGTH]) -> Vec<u8> {
+ [version.to_be_bytes().as_slice(), hash].concat()
+}
+
+fn decode_version(plaintext: &[u8]) -> Result<(u64, [u8; HASH_LENGTH]), WhatsAppStoreError> {
+ let (version, hash) = plaintext
+ .split_first_chunk::<8>()
+ .ok_or(WhatsAppStoreError::Malformed)?;
+ let hash: [u8; HASH_LENGTH] = hash.try_into().map_err(|_| WhatsAppStoreError::Malformed)?;
+ Ok((u64::from_be_bytes(*version), hash))
+}
+
+#[async_trait]
+impl AppStateStore for PgWhatsAppStore {
+ async fn put_app_state_version(
+ &self,
+ name: &str,
+ version: u64,
+ hash: [u8; 128],
+ ) -> Result<(), StoreError> {
+ Ok(self
+ .put_one(
+ StoreName::AppStateVersion,
+ name.to_owned(),
+ encode_version(version, &hash),
+ )
+ .await?)
+ }
+
+ async fn get_app_state_version(&self, name: &str) -> Result<(u64, [u8; 128]), StoreError> {
+ let Some(plaintext) = self
+ .get_value(&self.pool, StoreName::AppStateVersion, name)
+ .await?
+ else {
+ // Version 0 and an empty hash: the initial state.
+ return Ok((0, [0; HASH_LENGTH]));
+ };
+ Ok(decode_version(&plaintext)?)
+ }
+
+ async fn delete_app_state_version(&self, name: &str) -> Result<(), StoreError> {
+ Ok(self
+ .delete_one(StoreName::AppStateVersion, name.to_owned())
+ .await?)
+ }
+
+ async fn put_app_state_mutation_macs(
+ &self,
+ name: &str,
+ version: u64,
+ mutations: &[AppStateMutationMac],
+ ) -> Result<(), StoreError> {
+ if mutations.is_empty() {
+ return Ok(());
+ }
+ let stored_version = i64::try_from(version).map_err(|_| {
+ WhatsAppStoreError::InvalidArgument("app state version out of range".to_owned())
+ })?;
+ // One row per index MAC: a batch naming one twice keeps the last, as
+ // the later mutation wins.
+ let by_index: BTreeMap<&[u8], &[u8]> = mutations
+ .iter()
+ .map(|mutation| (mutation.index_mac.as_slice(), mutation.value_mac.as_slice()))
+ .collect();
+ let mut index_macs = Vec::with_capacity(by_index.len());
+ let mut nonces = Vec::with_capacity(by_index.len());
+ let mut values = Vec::with_capacity(by_index.len());
+ for (index_mac, value_mac) in by_index {
+ let sealed = self.cipher.seal(
+ StoreName::AppStateMutationMac,
+ &[name.as_bytes(), index_mac, &version.to_be_bytes()],
+ value_mac,
+ )?;
+ index_macs.push(index_mac.to_vec());
+ nonces.push(sealed.nonce);
+ values.push(sealed.value);
+ }
+ let mut transaction = self.begin_write().await?;
+ sqlx::query!(
+ r#"
+ INSERT INTO whatsapp_app_state_mutation_mac (
+ account_id, name, index_mac, version, nonce, value
+ )
+ SELECT $1, $2, entry.index_mac, $3, entry.nonce, entry.value
+ FROM UNNEST($4::bytea[], $5::bytea[], $6::bytea[]) AS entry(index_mac, nonce, value)
+ ON CONFLICT (account_id, name, index_mac, version) DO UPDATE SET
+ nonce = EXCLUDED.nonce,
+ value = EXCLUDED.value
+ "#,
+ self.account_id,
+ name,
+ stored_version,
+ &index_macs,
+ &nonces,
+ &values,
+ )
+ .execute(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn delete_app_state_mutation_macs(
+ &self,
+ name: &str,
+ index_macs: &[Vec<u8>],
+ ) -> Result<(), StoreError> {
+ if index_macs.is_empty() {
+ return Ok(());
+ }
+ let mut transaction = self.begin_write().await?;
+ sqlx::query!(
+ r#"
+ DELETE FROM whatsapp_app_state_mutation_mac
+ WHERE account_id = $1 AND name = $2 AND index_mac = ANY($3)
+ "#,
+ self.account_id,
+ name,
+ index_macs,
+ )
+ .execute(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn get_app_state_mutation_mac(
+ &self,
+ name: &str,
+ index_mac: &[u8],
+ ) -> Result<Option<Vec<u8>>, StoreError> {
+ let row = sqlx::query!(
+ r#"
+ SELECT version, nonce, value
+ FROM whatsapp_app_state_mutation_mac
+ WHERE account_id = $1 AND name = $2 AND index_mac = $3
+ ORDER BY version DESC
+ LIMIT 1
+ "#,
+ self.account_id,
+ name,
+ index_mac,
+ )
+ .fetch_optional(&self.pool)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ let Some(row) = row else {
+ return Ok(None);
+ };
+ let version = u64::try_from(row.version).map_err(|_| WhatsAppStoreError::Malformed)?;
+ Ok(Some(self.cipher.open(
+ StoreName::AppStateMutationMac,
+ &[name.as_bytes(), index_mac, &version.to_be_bytes()],
+ &row.nonce,
+ &row.value,
+ )?))
+ }
+}
diff --git a/crates/whatsapp_store_pg/src/store/app_state/test.rs b/crates/whatsapp_store_pg/src/store/app_state/test.rs
new file mode 100644
index 0000000000..ab451c10d2
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/app_state/test.rs
@@ -0,0 +1,192 @@
+use macro_db_migrator::MACRO_DB_MIGRATIONS;
+use sqlx::{Pool, Postgres};
+use whatsmeow::store::{AppStateMutationMac, AppStateStore, AppStateSyncKey, AppStateSyncKeyStore};
+
+use crate::store::test::open_new_store;
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn sync_keys_are_only_replaced_by_newer_ones(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ assert_eq!(
+ store.get_latest_app_state_sync_key_id().await.unwrap(),
+ None
+ );
+ assert_eq!(store.get_all_app_state_sync_keys().await.unwrap(), vec![]);
+
+ let older = AppStateSyncKey {
+ data: vec![1; 32],
+ fingerprint: vec![1, 2, 3],
+ timestamp: 1_000,
+ };
+ let newer = AppStateSyncKey {
+ data: vec![2; 32],
+ fingerprint: vec![4, 5, 6],
+ timestamp: 2_000,
+ };
+ store
+ .put_app_state_sync_key(&[0xaa, 0x01], older.clone())
+ .await
+ .unwrap();
+ store
+ .put_app_state_sync_key(&[0xbb, 0x02], newer.clone())
+ .await
+ .unwrap();
+ assert_eq!(
+ store.get_app_state_sync_key(&[0xaa, 0x01]).await.unwrap(),
+ Some(older.clone())
+ );
+ assert_eq!(store.get_app_state_sync_key(&[0xcc]).await.unwrap(), None);
+ assert_eq!(
+ store.get_latest_app_state_sync_key_id().await.unwrap(),
+ Some(vec![0xbb, 0x02])
+ );
+ assert_eq!(
+ store.get_all_app_state_sync_keys().await.unwrap(),
+ vec![newer.clone(), older.clone()]
+ );
+
+ // A key with an older or equal timestamp doesn't replace the stored one.
+ let stale = AppStateSyncKey {
+ data: vec![9; 32],
+ fingerprint: vec![9],
+ timestamp: 2_000,
+ };
+ store
+ .put_app_state_sync_key(&[0xbb, 0x02], stale)
+ .await
+ .unwrap();
+ assert_eq!(
+ store.get_app_state_sync_key(&[0xbb, 0x02]).await.unwrap(),
+ Some(newer)
+ );
+ let fresh = AppStateSyncKey {
+ data: vec![3; 32],
+ fingerprint: vec![7],
+ timestamp: 3_000,
+ };
+ store
+ .put_app_state_sync_key(&[0xaa, 0x01], fresh.clone())
+ .await
+ .unwrap();
+ assert_eq!(
+ store.get_app_state_sync_key(&[0xaa, 0x01]).await.unwrap(),
+ Some(fresh)
+ );
+ assert_eq!(
+ store.get_latest_app_state_sync_key_id().await.unwrap(),
+ Some(vec![0xaa, 0x01])
+ );
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn app_state_versions_start_at_zero(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ assert_eq!(
+ store.get_app_state_version("regular").await.unwrap(),
+ (0, [0; 128])
+ );
+
+ let mut hash = [0; 128];
+ hash[0] = 1;
+ hash[127] = 255;
+ store
+ .put_app_state_version("regular", 42, hash)
+ .await
+ .unwrap();
+ store
+ .put_app_state_version("critical_block", 7, [3; 128])
+ .await
+ .unwrap();
+ assert_eq!(
+ store.get_app_state_version("regular").await.unwrap(),
+ (42, hash)
+ );
+
+ store.delete_app_state_version("regular").await.unwrap();
+ assert_eq!(
+ store.get_app_state_version("regular").await.unwrap(),
+ (0, [0; 128])
+ );
+ assert_eq!(
+ store.get_app_state_version("critical_block").await.unwrap(),
+ (7, [3; 128])
+ );
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn the_newest_mutation_mac_wins_and_deletes_go_by_index(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let mutations: Vec<AppStateMutationMac> = (0..1000u16)
+ .map(|index| AppStateMutationMac {
+ index_mac: index.to_be_bytes().to_vec(),
+ value_mac: vec![1, index as u8],
+ })
+ .collect();
+ store
+ .put_app_state_mutation_macs("regular", 1, &mutations)
+ .await
+ .unwrap();
+ store
+ .put_app_state_mutation_macs(
+ "regular",
+ 2,
+ &[AppStateMutationMac {
+ index_mac: vec![0, 5],
+ value_mac: vec![2, 5],
+ }],
+ )
+ .await
+ .unwrap();
+ store
+ .put_app_state_mutation_macs("regular", 3, &[])
+ .await
+ .unwrap();
+
+ assert_eq!(
+ store
+ .get_app_state_mutation_mac("regular", &[0, 5])
+ .await
+ .unwrap(),
+ Some(vec![2, 5])
+ );
+ assert_eq!(
+ store
+ .get_app_state_mutation_mac("regular", &[3, 231])
+ .await
+ .unwrap(),
+ Some(vec![1, 231])
+ );
+ assert_eq!(
+ store
+ .get_app_state_mutation_mac("critical_block", &[0, 5])
+ .await
+ .unwrap(),
+ None
+ );
+
+ store
+ .delete_app_state_mutation_macs("regular", &[vec![0, 5], vec![0, 6]])
+ .await
+ .unwrap();
+ assert_eq!(
+ store
+ .get_app_state_mutation_mac("regular", &[0, 5])
+ .await
+ .unwrap(),
+ None
+ );
+ assert_eq!(
+ store
+ .get_app_state_mutation_mac("regular", &[0, 6])
+ .await
+ .unwrap(),
+ None
+ );
+ assert_eq!(
+ store
+ .get_app_state_mutation_mac("regular", &[0, 7])
+ .await
+ .unwrap(),
+ Some(vec![1, 7])
+ );
+}
diff --git a/crates/whatsapp_store_pg/src/store/contacts.rs b/crates/whatsapp_store_pg/src/store/contacts.rs
new file mode 100644
index 0000000000..0b04ed6d3e
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/contacts.rs
@@ -0,0 +1,329 @@
+//! Contact names and local chat settings. Each contact or chat is one sealed
+//! record, so whatsmeow's per-column updates become read-modify-writes under
+//! the device lock.
+
+#[cfg(test)]
+mod test;
+
+use std::collections::{BTreeMap, HashMap};
+
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use whatsmeow::store::{
+ ChatSettingsStore, ContactEntry, ContactStore, RedactedPhoneEntry, StoreError,
+};
+use whatsmeow::types::{ContactInfo, Jid, LocalChatSettings, MessageId};
+
+use super::PgWhatsAppStore;
+use crate::cipher::StoreName;
+use crate::error::WhatsAppStoreError;
+
+/// A contact as sealed in its value.
+#[derive(Default, Serialize, Deserialize)]
+struct ContactRecord {
+ first_name: String,
+ full_name: String,
+ push_name: String,
+ business_name: String,
+ redacted_phone: String,
+}
+
+impl From<ContactRecord> for ContactInfo {
+ fn from(record: ContactRecord) -> Self {
+ ContactInfo {
+ first_name: record.first_name,
+ full_name: record.full_name,
+ push_name: record.push_name,
+ business_name: record.business_name,
+ redacted_phone: record.redacted_phone,
+ }
+ }
+}
+
+/// A chat's settings as sealed in its value.
+#[derive(Default, Serialize, Deserialize)]
+struct ChatSettingsRecord {
+ muted_until: Option<DateTime<Utc>>,
+ pinned: bool,
+ archived: bool,
+ wasa_root_secret_id: Option<MessageId>,
+}
+
+fn encode<Record: Serialize>(record: &Record) -> Result<Vec<u8>, WhatsAppStoreError> {
+ postcard::to_allocvec(record).map_err(|_| WhatsAppStoreError::Malformed)
+}
+
+fn decode<Record: for<'de> Deserialize<'de>>(
+ plaintext: &[u8],
+) -> Result<Record, WhatsAppStoreError> {
+ postcard::from_bytes(plaintext).map_err(|_| WhatsAppStoreError::Malformed)
+}
+
+impl PgWhatsAppStore {
+ /// Updates the records of `keys` in one transaction: reads them under the
+ /// device lock (a missing one starts from its default), applies `update`
+ /// to each, and writes back those it reports changed. Returns what
+ /// `update` returned per key.
+ async fn update_records<Record, Outcome>(
+ &self,
+ store: StoreName,
+ keys: Vec<String>,
+ mut update: impl FnMut(&str, &mut Record) -> (bool, Outcome) + Send,
+ ) -> Result<HashMap<String, Outcome>, WhatsAppStoreError>
+ where
+ Record: Default + Serialize + for<'de> Deserialize<'de>,
+ {
+ let mut transaction = self.begin_write().await?;
+ self.lock_device(&mut transaction).await?;
+ let mut existing = self.get_values(&mut *transaction, store, &keys).await?;
+ let mut changed = BTreeMap::new();
+ let mut outcomes = HashMap::with_capacity(keys.len());
+ for key in keys {
+ let mut record = existing
+ .remove(&key)
+ .map(|plaintext| decode::<Record>(&plaintext))
+ .transpose()?
+ .unwrap_or_default();
+ let (was_changed, outcome) = update(&key, &mut record);
+ if was_changed {
+ changed.insert(key.clone(), encode(&record)?);
+ }
+ outcomes.insert(key, outcome);
+ }
+ self.put_values(&mut transaction, store, changed).await?;
+ transaction.commit().await?;
+ Ok(outcomes)
+ }
+
+ async fn update_record<Record, Outcome>(
+ &self,
+ store: StoreName,
+ key: String,
+ mut update: impl FnMut(&mut Record) -> (bool, Outcome) + Send,
+ ) -> Result<Outcome, WhatsAppStoreError>
+ where
+ Record: Default + Serialize + for<'de> Deserialize<'de>,
+ {
+ self.update_records(store, vec![key], |_, record| update(record))
+ .await?
+ .into_values()
+ .next()
+ .ok_or(WhatsAppStoreError::Malformed)
+ }
+}
+
+/// Replaces a name, reporting whether it changed and what it was, as
+/// whatsmeow's `PutPushName` does.
+fn replace_name(name: &mut String, new_name: &str) -> (bool, (bool, String)) {
+ if name == new_name {
+ return (false, (false, String::new()));
+ }
+ let previous = std::mem::replace(name, new_name.to_owned());
+ (true, (true, previous))
+}
+
+#[async_trait]
+impl ContactStore for PgWhatsAppStore {
+ async fn put_push_name(
+ &self,
+ user: &Jid,
+ push_name: &str,
+ ) -> Result<(bool, String), StoreError> {
+ Ok(self
+ .update_record(
+ StoreName::Contact,
+ user.to_string(),
+ |record: &mut ContactRecord| replace_name(&mut record.push_name, push_name),
+ )
+ .await?)
+ }
+
+ async fn put_business_name(
+ &self,
+ user: &Jid,
+ business_name: &str,
+ ) -> Result<(bool, String), StoreError> {
+ Ok(self
+ .update_record(
+ StoreName::Contact,
+ user.to_string(),
+ |record: &mut ContactRecord| replace_name(&mut record.business_name, business_name),
+ )
+ .await?)
+ }
+
+ async fn put_contact_name(
+ &self,
+ user: &Jid,
+ full_name: &str,
+ first_name: &str,
+ ) -> Result<(), StoreError> {
+ self.update_record(
+ StoreName::Contact,
+ user.to_string(),
+ |record: &mut ContactRecord| {
+ let changed = record.full_name != full_name || record.first_name != first_name;
+ full_name.clone_into(&mut record.full_name);
+ first_name.clone_into(&mut record.first_name);
+ (changed, ())
+ },
+ )
+ .await?;
+ Ok(())
+ }
+
+ async fn put_all_contact_names(&self, contacts: &[ContactEntry]) -> Result<(), StoreError> {
+ // A contact listed twice keeps its last names, as whatsmeow dedupes.
+ let names: HashMap<String, &ContactEntry> = contacts
+ .iter()
+ .map(|entry| (entry.jid.to_string(), entry))
+ .collect();
+ let keys = names.keys().cloned().collect();
+ self.update_records(
+ StoreName::Contact,
+ keys,
+ |key, record: &mut ContactRecord| {
+ let Some(entry) = names.get(key) else {
+ return (false, ());
+ };
+ let changed =
+ record.full_name != entry.full_name || record.first_name != entry.first_name;
+ record.full_name.clone_from(&entry.full_name);
+ record.first_name.clone_from(&entry.first_name);
+ (changed, ())
+ },
+ )
+ .await?;
+ Ok(())
+ }
+
+ async fn put_many_redacted_phones(
+ &self,
+ entries: &[RedactedPhoneEntry],
+ ) -> Result<(), StoreError> {
+ let phones: HashMap<String, &str> = entries
+ .iter()
+ .map(|entry| (entry.jid.to_string(), entry.redacted_phone.as_str()))
+ .collect();
+ let keys = phones.keys().cloned().collect();
+ self.update_records(
+ StoreName::Contact,
+ keys,
+ |key, record: &mut ContactRecord| {
+ let Some(phone) = phones.get(key) else {
+ return (false, ());
+ };
+ let changed = record.redacted_phone != *phone;
+ (*phone).clone_into(&mut record.redacted_phone);
+ (changed, ())
+ },
+ )
+ .await?;
+ Ok(())
+ }
+
+ async fn get_contact(&self, user: &Jid) -> Result<Option<ContactInfo>, StoreError> {
+ Ok(self
+ .get_value(&self.pool, StoreName::Contact, &user.to_string())
+ .await?
+ .map(|plaintext| decode::<ContactRecord>(&plaintext).map(ContactInfo::from))
+ .transpose()?)
+ }
+
+ async fn get_all_contacts(&self) -> Result<HashMap<Jid, ContactInfo>, StoreError> {
+ Ok(self
+ .list_values(&self.pool, StoreName::Contact, "")
+ .await?
+ .into_iter()
+ .map(|(jid, plaintext)| {
+ let jid: Jid = jid.parse().map_err(|_| WhatsAppStoreError::Malformed)?;
+ Ok((jid, decode::<ContactRecord>(&plaintext)?.into()))
+ })
+ .collect::<Result<_, WhatsAppStoreError>>()?)
+ }
+}
+
+#[async_trait]
+impl ChatSettingsStore for PgWhatsAppStore {
+ async fn put_muted_until(
+ &self,
+ chat: &Jid,
+ muted_until: Option<DateTime<Utc>>,
+ ) -> Result<(), StoreError> {
+ self.update_record(
+ StoreName::ChatSettings,
+ chat.to_string(),
+ |record: &mut ChatSettingsRecord| {
+ record.muted_until = muted_until;
+ (true, ())
+ },
+ )
+ .await?;
+ Ok(())
+ }
+
+ async fn put_pinned(&self, chat: &Jid, pinned: bool) -> Result<(), StoreError> {
+ self.update_record(
+ StoreName::ChatSettings,
+ chat.to_string(),
+ |record: &mut ChatSettingsRecord| {
+ record.pinned = pinned;
+ (true, ())
+ },
+ )
+ .await?;
+ Ok(())
+ }
+
+ async fn put_archived(&self, chat: &Jid, archived: bool) -> Result<(), StoreError> {
+ self.update_record(
+ StoreName::ChatSettings,
+ chat.to_string(),
+ |record: &mut ChatSettingsRecord| {
+ record.archived = archived;
+ (true, ())
+ },
+ )
+ .await?;
+ Ok(())
+ }
+
+ async fn put_wasa_root_secret_id(&self, chat: &Jid, id: &MessageId) -> Result<(), StoreError> {
+ self.update_record(
+ StoreName::ChatSettings,
+ chat.to_string(),
+ |record: &mut ChatSettingsRecord| {
+ record.wasa_root_secret_id = Some(id.clone());
+ (true, ())
+ },
+ )
+ .await?;
+ Ok(())
+ }
+
+ async fn get_wasa_root_secret_id(&self, chat: &Jid) -> Result<Option<MessageId>, StoreError> {
+ Ok(self
+ .get_value(&self.pool, StoreName::ChatSettings, &chat.to_string())
+ .await?
+ .map(|plaintext| decode::<ChatSettingsRecord>(&plaintext))
+ .transpose()?
+ .and_then(|record| record.wasa_root_secret_id))
+ }
+
+ /// Like whatsmeow, a chat has settings once any of them (including its
+ /// WASA root secret ID) was stored.
+ async fn get_chat_settings(&self, chat: &Jid) -> Result<Option<LocalChatSettings>, StoreError> {
+ Ok(self
+ .get_value(&self.pool, StoreName::ChatSettings, &chat.to_string())
+ .await?
+ .map(|plaintext| {
+ decode::<ChatSettingsRecord>(&plaintext).map(|record| LocalChatSettings {
+ muted_until: record.muted_until,
+ pinned: record.pinned,
+ archived: record.archived,
+ })
+ })
+ .transpose()?)
+ }
+}
diff --git a/crates/whatsapp_store_pg/src/store/contacts/test.rs b/crates/whatsapp_store_pg/src/store/contacts/test.rs
new file mode 100644
index 0000000000..788cac08fc
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/contacts/test.rs
@@ -0,0 +1,192 @@
+use std::collections::HashMap;
+
+use chrono::{TimeZone, Utc};
+use macro_db_migrator::MACRO_DB_MIGRATIONS;
+use sqlx::{Pool, Postgres};
+use whatsmeow::store::{
+ ChatSettingsStore, ContactEntry, ContactStore, MUTED_FOREVER, RedactedPhoneEntry,
+};
+use whatsmeow::types::{
+ ContactInfo, DEFAULT_USER_SERVER, GROUP_SERVER, HIDDEN_USER_SERVER, LocalChatSettings, new_jid,
+};
+
+use crate::store::test::open_new_store;
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn names_report_whether_they_changed(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let alice = new_jid("111", DEFAULT_USER_SERVER);
+ assert_eq!(store.get_contact(&alice).await.unwrap(), None);
+
+ assert_eq!(
+ store.put_push_name(&alice, "Alice").await.unwrap(),
+ (true, String::new())
+ );
+ assert_eq!(
+ store.put_push_name(&alice, "Alice").await.unwrap(),
+ (false, String::new())
+ );
+ assert_eq!(
+ store.put_push_name(&alice, "Al").await.unwrap(),
+ (true, "Alice".to_owned())
+ );
+ assert_eq!(
+ store.put_business_name(&alice, "Alice Inc").await.unwrap(),
+ (true, String::new())
+ );
+ store
+ .put_contact_name(&alice, "Alice Smith", "Alice")
+ .await
+ .unwrap();
+
+ assert_eq!(
+ store.get_contact(&alice).await.unwrap(),
+ Some(ContactInfo {
+ first_name: "Alice".to_owned(),
+ full_name: "Alice Smith".to_owned(),
+ push_name: "Al".to_owned(),
+ business_name: "Alice Inc".to_owned(),
+ redacted_phone: String::new(),
+ })
+ );
+
+ // An unchanged empty name for an unknown contact stores nothing.
+ let unknown = new_jid("999", DEFAULT_USER_SERVER);
+ assert_eq!(
+ store.put_push_name(&unknown, "").await.unwrap(),
+ (false, String::new())
+ );
+ assert_eq!(store.get_contact(&unknown).await.unwrap(), None);
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn batches_merge_into_existing_contacts(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let alice = new_jid("111", DEFAULT_USER_SERVER);
+ let bob = new_jid("222", DEFAULT_USER_SERVER);
+ let lid_user = new_jid("98765", HIDDEN_USER_SERVER);
+ store.put_push_name(&alice, "Al").await.unwrap();
+
+ store
+ .put_all_contact_names(&[
+ ContactEntry {
+ jid: alice.clone(),
+ first_name: "Wrong".to_owned(),
+ full_name: "Wrong".to_owned(),
+ },
+ ContactEntry {
+ jid: bob.clone(),
+ first_name: "Bob".to_owned(),
+ full_name: "Bob Jones".to_owned(),
+ },
+ // Listed twice: the last entry wins.
+ ContactEntry {
+ jid: alice.clone(),
+ first_name: "Alice".to_owned(),
+ full_name: "Alice Smith".to_owned(),
+ },
+ ])
+ .await
+ .unwrap();
+ store
+ .put_many_redacted_phones(&[RedactedPhoneEntry {
+ jid: lid_user.clone(),
+ redacted_phone: "+1∙∙∙∙∙∙∙∙80".to_owned(),
+ }])
+ .await
+ .unwrap();
+ store.put_all_contact_names(&[]).await.unwrap();
+
+ assert_eq!(
+ store.get_all_contacts().await.unwrap(),
+ HashMap::from([
+ (
+ alice,
+ ContactInfo {
+ first_name: "Alice".to_owned(),
+ full_name: "Alice Smith".to_owned(),
+ push_name: "Al".to_owned(),
+ ..ContactInfo::default()
+ }
+ ),
+ (
+ bob,
+ ContactInfo {
+ first_name: "Bob".to_owned(),
+ full_name: "Bob Jones".to_owned(),
+ ..ContactInfo::default()
+ }
+ ),
+ (
+ lid_user,
+ ContactInfo {
+ redacted_phone: "+1∙∙∙∙∙∙∙∙80".to_owned(),
+ ..ContactInfo::default()
+ }
+ ),
+ ])
+ );
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn chat_settings_are_kept_per_chat(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let group = new_jid("123-456", GROUP_SERVER);
+ let direct = new_jid("111", DEFAULT_USER_SERVER);
+ assert_eq!(store.get_chat_settings(&group).await.unwrap(), None);
+
+ let muted_until = Utc.with_ymd_and_hms(2030, 1, 2, 3, 4, 5).unwrap();
+ store
+ .put_muted_until(&group, Some(muted_until))
+ .await
+ .unwrap();
+ store.put_pinned(&group, true).await.unwrap();
+ store.put_archived(&direct, true).await.unwrap();
+ store
+ .put_muted_until(&direct, Some(*MUTED_FOREVER))
+ .await
+ .unwrap();
+
+ assert_eq!(
+ store.get_chat_settings(&group).await.unwrap(),
+ Some(LocalChatSettings {
+ muted_until: Some(muted_until),
+ pinned: true,
+ archived: false,
+ })
+ );
+ assert_eq!(
+ store.get_chat_settings(&direct).await.unwrap(),
+ Some(LocalChatSettings {
+ muted_until: Some(*MUTED_FOREVER),
+ pinned: false,
+ archived: true,
+ })
+ );
+
+ store.put_muted_until(&group, None).await.unwrap();
+ assert_eq!(
+ store.get_chat_settings(&group).await.unwrap(),
+ Some(LocalChatSettings {
+ muted_until: None,
+ pinned: true,
+ archived: false,
+ })
+ );
+
+ // Storing only the WASA root secret ID creates the chat's settings.
+ let other = new_jid("789-012", GROUP_SERVER);
+ assert_eq!(store.get_wasa_root_secret_id(&other).await.unwrap(), None);
+ store
+ .put_wasa_root_secret_id(&other, &"3EB0ABCDEF".to_owned())
+ .await
+ .unwrap();
+ assert_eq!(
+ store.get_wasa_root_secret_id(&other).await.unwrap(),
+ Some("3EB0ABCDEF".to_owned())
+ );
+ assert_eq!(
+ store.get_chat_settings(&other).await.unwrap(),
+ Some(LocalChatSettings::default())
+ );
+}
diff --git a/crates/whatsapp_store_pg/src/store/device.rs b/crates/whatsapp_store_pg/src/store/device.rs
new file mode 100644
index 0000000000..ece2f800cf
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/device.rs
@@ -0,0 +1,255 @@
+//! The device's own data (its keys, JIDs and names), and building a whatsmeow
+//! [`Device`] backed by this store.
+
+#[cfg(test)]
+mod test;
+
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use prost::Message;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+use whatsmeow::proto::wa_adv::AdvSignedDeviceIdentity;
+use whatsmeow::signal::CurveSignatures;
+use whatsmeow::store::{Device, DeviceContainer, StoreError};
+use whatsmeow::types::Jid;
+use whatsmeow::util::keys::{PreKey, new_key_pair, new_key_pair_from_private_key};
+
+use super::PgWhatsAppStore;
+use crate::cipher::StoreName;
+use crate::error::WhatsAppStoreError;
+
+/// The device record is one value per account.
+const DEVICE_KEY: &str = "";
+
+/// The ID of the signed prekey of a new device, as whatsmeow numbers it.
+const SIGNED_PRE_KEY_ID: u32 = 1;
+
+/// A device as sealed in its value. Public keys are derived from the private
+/// ones on load, as whatsmeow's `sqlstore` does.
+#[derive(Serialize, Deserialize)]
+struct DeviceRecord {
+ noise_private_key: [u8; 32],
+ identity_private_key: [u8; 32],
+ signed_pre_key_private_key: [u8; 32],
+ signed_pre_key_id: u32,
+ signed_pre_key_signature: Option<Vec<u8>>,
+ registration_id: u32,
+ adv_secret_key: Vec<u8>,
+ jid: String,
+ lid: String,
+ /// The protobuf `AdvSignedDeviceIdentity`, when known.
+ account: Option<Vec<u8>>,
+ platform: String,
+ business_name: String,
+ push_name: String,
+ lid_migration_timestamp: i64,
+ companion_meta_nonce: String,
+ facebook_uuid: Option<Uuid>,
+}
+
+impl PgWhatsAppStore {
+ /// The account's device with every store backed by this one: the saved
+ /// device, or a new unpaired one (not saved until whatsmeow pairs and
+ /// calls [`Device::save`]), as whatsmeow's `Container` hands out.
+ ///
+ /// # Errors
+ /// If the stored device fails to decrypt or decode, or the database fails.
+ #[tracing::instrument(
+ name = "whatsapp_store.load_device",
+ skip_all,
+ fields(account_id = %self.account_id, initialized),
+ err
+ )]
+ pub async fn load_device(
+ self: &Arc<Self>,
+ signatures: &impl CurveSignatures,
+ ) -> Result<Device, WhatsAppStoreError> {
+ let stored = self
+ .get_value(&self.pool, StoreName::Device, DEVICE_KEY)
+ .await?;
+ tracing::Span::current().record("initialized", stored.is_some());
+ let Some(plaintext) = stored else {
+ let identity_key = new_key_pair();
+ let signed_pre_key = identity_key.create_signed_pre_key(signatures, SIGNED_PRE_KEY_ID);
+ return Ok(self.device(DeviceParts {
+ noise_key: new_key_pair(),
+ identity_key,
+ signed_pre_key,
+ registration_id: rand::random(),
+ adv_secret_key: rand::random::<[u8; 32]>().to_vec(),
+ id: None,
+ lid: Jid::default(),
+ account: None,
+ platform: String::new(),
+ business_name: String::new(),
+ push_name: String::new(),
+ lid_migration_timestamp: 0,
+ companion_meta_nonce: String::new(),
+ facebook_uuid: None,
+ initialized: false,
+ }));
+ };
+ let record: DeviceRecord =
+ postcard::from_bytes(&plaintext).map_err(|_| WhatsAppStoreError::Malformed)?;
+ let signature = record
+ .signed_pre_key_signature
+ .map(|signature| <[u8; 64]>::try_from(signature.as_slice()))
+ .transpose()
+ .map_err(|_| WhatsAppStoreError::Malformed)?;
+ let parse_jid = |jid: &str| -> Result<Jid, WhatsAppStoreError> {
+ jid.parse().map_err(|_| WhatsAppStoreError::Malformed)
+ };
+ Ok(self.device(DeviceParts {
+ noise_key: new_key_pair_from_private_key(record.noise_private_key),
+ identity_key: new_key_pair_from_private_key(record.identity_private_key),
+ signed_pre_key: PreKey {
+ key_pair: new_key_pair_from_private_key(record.signed_pre_key_private_key),
+ key_id: record.signed_pre_key_id,
+ signature,
+ },
+ registration_id: record.registration_id,
+ adv_secret_key: record.adv_secret_key,
+ id: Some(parse_jid(&record.jid)?),
+ lid: parse_jid(&record.lid)?,
+ account: record
+ .account
+ .map(|account| AdvSignedDeviceIdentity::decode(account.as_slice()))
+ .transpose()
+ .map_err(|_| WhatsAppStoreError::Malformed)?,
+ platform: record.platform,
+ business_name: record.business_name,
+ push_name: record.push_name,
+ lid_migration_timestamp: record.lid_migration_timestamp,
+ companion_meta_nonce: record.companion_meta_nonce,
+ facebook_uuid: record.facebook_uuid,
+ initialized: true,
+ }))
+ }
+
+ fn device(self: &Arc<Self>, parts: DeviceParts) -> Device {
+ Device {
+ noise_key: parts.noise_key,
+ identity_key: parts.identity_key,
+ signed_pre_key: parts.signed_pre_key,
+ registration_id: parts.registration_id,
+ adv_secret_key: parts.adv_secret_key,
+ id: parts.id,
+ lid: parts.lid,
+ account: parts.account,
+ platform: parts.platform,
+ business_name: parts.business_name,
+ push_name: parts.push_name,
+ lid_migration_timestamp: parts.lid_migration_timestamp,
+ companion_meta_nonce: parts.companion_meta_nonce,
+ facebook_uuid: parts.facebook_uuid,
+ initialized: parts.initialized,
+ deleted: false,
+ identities: self.clone(),
+ sessions: self.clone(),
+ pre_keys: self.clone(),
+ sender_keys: self.clone(),
+ app_state_keys: self.clone(),
+ app_state: self.clone(),
+ contacts: self.clone(),
+ chat_settings: self.clone(),
+ msg_secrets: self.clone(),
+ privacy_tokens: self.clone(),
+ nct_salt: self.clone(),
+ event_buffer: self.clone(),
+ lids: self.clone(),
+ container: self.clone(),
+ }
+ }
+}
+
+/// The data fields of a [`Device`], without its store handles.
+struct DeviceParts {
+ noise_key: whatsmeow::util::keys::KeyPair,
+ identity_key: whatsmeow::util::keys::KeyPair,
+ signed_pre_key: PreKey,
+ registration_id: u32,
+ adv_secret_key: Vec<u8>,
+ id: Option<Jid>,
+ lid: Jid,
+ account: Option<AdvSignedDeviceIdentity>,
+ platform: String,
+ business_name: String,
+ push_name: String,
+ lid_migration_timestamp: i64,
+ companion_meta_nonce: String,
+ facebook_uuid: Option<Uuid>,
+ initialized: bool,
+}
+
+#[async_trait]
+impl DeviceContainer for PgWhatsAppStore {
+ #[tracing::instrument(
+ name = "whatsapp_store.put_device",
+ skip_all,
+ fields(account_id = %self.account_id),
+ err
+ )]
+ async fn put_device(&self, store: &Device) -> Result<(), StoreError> {
+ let Some(jid) = &store.id else {
+ return Err(StoreError::InvalidArgument(
+ "device JID must be known before accessing database".to_owned(),
+ ));
+ };
+ let record = DeviceRecord {
+ noise_private_key: store.noise_key.private,
+ identity_private_key: store.identity_key.private,
+ signed_pre_key_private_key: store.signed_pre_key.key_pair.private,
+ signed_pre_key_id: store.signed_pre_key.key_id,
+ signed_pre_key_signature: store
+ .signed_pre_key
+ .signature
+ .map(|signature| signature.to_vec()),
+ registration_id: store.registration_id,
+ adv_secret_key: store.adv_secret_key.clone(),
+ jid: jid.to_string(),
+ lid: store.lid.to_string(),
+ account: store.account.as_ref().map(Message::encode_to_vec),
+ platform: store.platform.clone(),
+ business_name: store.business_name.clone(),
+ push_name: store.push_name.clone(),
+ lid_migration_timestamp: store.lid_migration_timestamp,
+ companion_meta_nonce: store.companion_meta_nonce.clone(),
+ facebook_uuid: store.facebook_uuid,
+ };
+ let plaintext =
+ postcard::to_allocvec(&record).map_err(|_| WhatsAppStoreError::Malformed)?;
+ Ok(self
+ .put_one(StoreName::Device, DEVICE_KEY.to_owned(), plaintext)
+ .await?)
+ }
+
+ /// Deletes the device row, which cascades to every key, session and value
+ /// of the account. This store is unusable afterwards; opening the account
+ /// again generates a new data key.
+ #[tracing::instrument(
+ name = "whatsapp_store.delete_device",
+ skip_all,
+ fields(account_id = %self.account_id),
+ err
+ )]
+ async fn delete_device(&self, _store: &Device) -> Result<(), StoreError> {
+ let mut transaction = self.begin_write().await?;
+ sqlx::query!(
+ r#"
+ DELETE FROM whatsapp_device
+ WHERE account_id = $1
+ "#,
+ self.account_id,
+ )
+ .execute(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+}
diff --git a/crates/whatsapp_store_pg/src/store/device/test.rs b/crates/whatsapp_store_pg/src/store/device/test.rs
new file mode 100644
index 0000000000..827f527575
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/device/test.rs
@@ -0,0 +1,94 @@
+use macro_db_migrator::MACRO_DB_MIGRATIONS;
+use sqlx::{Pool, Postgres};
+use uuid::Uuid;
+use whatsmeow::proto::wa_adv::AdvSignedDeviceIdentity;
+use whatsmeow::store::{SessionStore, StoreError};
+use whatsmeow::types::{HIDDEN_USER_SERVER, new_ad_jid, new_jid};
+
+use crate::store::test::{FixedSignatures, open_new_store};
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn a_new_device_is_unpaired_and_needs_a_jid_to_save(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let device = store.load_device(&FixedSignatures).await.unwrap();
+ assert!(!device.initialized);
+ assert_eq!(device.id, None);
+ assert_eq!(device.signed_pre_key.key_id, 1);
+ assert_eq!(device.signed_pre_key.signature, Some([7; 64]));
+
+ let error = device.save().await.unwrap_err();
+ assert!(matches!(error, StoreError::InvalidArgument(_)), "{error:?}");
+ // Still unpaired: a new device (new keys) each time until one is saved.
+ let again = store.load_device(&FixedSignatures).await.unwrap();
+ assert!(!again.initialized);
+ assert_ne!(again.noise_key, device.noise_key);
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn a_saved_device_loads_back(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let mut device = store.load_device(&FixedSignatures).await.unwrap();
+ device.id = Some(new_ad_jid("15551234567", 0, 12));
+ device.lid = new_jid("98765", HIDDEN_USER_SERVER);
+ device.account = Some(AdvSignedDeviceIdentity {
+ details: Some(vec![1, 2, 3]),
+ account_signature_key: Some(vec![4; 32]),
+ account_signature: Some(vec![5; 64]),
+ device_signature: Some(vec![6; 64]),
+ });
+ device.platform = "android".to_owned();
+ device.business_name = "Shop".to_owned();
+ device.push_name = "Alice".to_owned();
+ device.lid_migration_timestamp = 1_700_000_000;
+ device.companion_meta_nonce = "nonce".to_owned();
+ device.facebook_uuid = Some(Uuid::now_v7());
+ device.save().await.unwrap();
+
+ let loaded = store.load_device(&FixedSignatures).await.unwrap();
+ assert!(loaded.initialized);
+ assert_eq!(loaded.noise_key, device.noise_key);
+ assert_eq!(loaded.identity_key, device.identity_key);
+ assert_eq!(loaded.signed_pre_key, device.signed_pre_key);
+ assert_eq!(loaded.registration_id, device.registration_id);
+ assert_eq!(loaded.adv_secret_key, device.adv_secret_key);
+ assert_eq!(loaded.id, device.id);
+ assert_eq!(loaded.lid, device.lid);
+ assert_eq!(loaded.account, device.account);
+ assert_eq!(loaded.platform, "android");
+ assert_eq!(loaded.business_name, "Shop");
+ assert_eq!(loaded.push_name, "Alice");
+ assert_eq!(loaded.lid_migration_timestamp, 1_700_000_000);
+ assert_eq!(loaded.companion_meta_nonce, "nonce");
+ assert_eq!(loaded.facebook_uuid, device.facebook_uuid);
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn deleting_the_device_deletes_every_key(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let mut device = store.load_device(&FixedSignatures).await.unwrap();
+ device.id = Some(new_ad_jid("15551234567", 0, 12));
+ device.save().await.unwrap();
+ device
+ .sessions
+ .put_session("111:0", b"session".to_vec())
+ .await
+ .unwrap();
+
+ device.delete().await.unwrap();
+ assert!(device.deleted);
+ let remaining = sqlx::query_scalar!(
+ r#"
+ SELECT
+ (SELECT COUNT(*) FROM whatsapp_device WHERE account_id = $1)
+ + (SELECT COUNT(*) FROM whatsapp_store_value WHERE account_id = $1)
+ AS "count!"
+ "#,
+ store.account_id(),
+ )
+ .fetch_one(&pool)
+ .await
+ .unwrap();
+ assert_eq!(remaining, 0);
+ // The store itself is useless now; its writes fail.
+ assert!(store.put_session("111:0", b"late".to_vec()).await.is_err());
+}
diff --git a/crates/whatsapp_store_pg/src/store/events.rs b/crates/whatsapp_store_pg/src/store/events.rs
new file mode 100644
index 0000000000..01664cd0b4
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/events.rs
@@ -0,0 +1,552 @@
+//! Message secrets, privacy tokens, the NCT salt, and the buffers of incoming
+//! and outgoing events.
+
+#[cfg(test)]
+mod test;
+
+use std::collections::{BTreeMap, HashMap};
+
+use async_trait::async_trait;
+use chrono::{DateTime, TimeDelta, Utc};
+use serde::{Deserialize, Serialize};
+use whatsmeow::store::{
+ BufferedEvent, DecryptionTransaction, EventBuffer, MessageSecretInsert, MsgSecretStore,
+ NctSaltStore, PrivacyToken, PrivacyTokenStore, StoreError,
+};
+use whatsmeow::types::{Jid, MessageId};
+
+use super::{PgWhatsAppStore, composite_key};
+use crate::cipher::StoreName;
+use crate::error::WhatsAppStoreError;
+
+/// The NCT salt is one value per account.
+const NCT_SALT_KEY: &str = "";
+
+/// WhatsApp servers buffer events for 14 days, so older hashes can't recur.
+const BUFFERED_EVENT_RETENTION: TimeDelta = TimeDelta::days(14);
+
+/// How long sent messages are kept for answering retry receipts.
+const OUTGOING_EVENT_RETENTION: TimeDelta = TimeDelta::days(7);
+
+fn message_secret_key(chat: &Jid, sender: &Jid, id: &str) -> Result<String, WhatsAppStoreError> {
+ composite_key(&[&chat.to_string(), &sender.to_string(), id])
+}
+
+#[async_trait]
+impl MsgSecretStore for PgWhatsAppStore {
+ async fn put_message_secrets(&self, inserts: &[MessageSecretInsert]) -> Result<(), StoreError> {
+ let mut secrets = BTreeMap::new();
+ for insert in inserts {
+ // Skipped as whatsmeow skips them.
+ if insert.chat.is_empty()
+ || insert.sender.is_empty()
+ || insert.id.is_empty()
+ || insert.secret.is_empty()
+ {
+ continue;
+ }
+ let key = message_secret_key(
+ &insert.chat.to_non_ad(),
+ &insert.sender.to_non_ad(),
+ &insert.id,
+ )?;
+ // The first secret of a message wins, as with `ON CONFLICT DO NOTHING`.
+ secrets.entry(key).or_insert_with(|| insert.secret.clone());
+ }
+ if secrets.is_empty() {
+ return Ok(());
+ }
+ let mut transaction = self.begin_write().await?;
+ self.insert_values_if_absent(&mut transaction, StoreName::MessageSecret, secrets)
+ .await?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn put_message_secret(
+ &self,
+ chat: &Jid,
+ sender: &Jid,
+ id: &MessageId,
+ secret: Vec<u8>,
+ ) -> Result<(), StoreError> {
+ let key = message_secret_key(&chat.to_non_ad(), &sender.to_non_ad(), id)?;
+ let mut transaction = self.begin_write().await?;
+ self.insert_values_if_absent(
+ &mut transaction,
+ StoreName::MessageSecret,
+ BTreeMap::from([(key, secret)]),
+ )
+ .await?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ /// Like whatsmeow, also finds a secret stored under the other identity
+ /// (LID or phone number) of the chat or the sender.
+ async fn get_message_secret(
+ &self,
+ chat: &Jid,
+ sender: &Jid,
+ id: &MessageId,
+ ) -> Result<Option<(Vec<u8>, Jid)>, StoreError> {
+ let chat = chat.to_non_ad();
+ let sender = sender.to_non_ad();
+ let chats = self.with_alternate(chat).await?;
+ let senders = self.with_alternate(sender).await?;
+ let mut candidates = Vec::with_capacity(chats.len() * senders.len());
+ for chat in &chats {
+ for sender in &senders {
+ candidates.push((message_secret_key(chat, sender, id)?, sender.clone()));
+ }
+ }
+ let keys: Vec<String> = candidates.iter().map(|(key, _)| key.clone()).collect();
+ let mut found = self
+ .get_values(&self.pool, StoreName::MessageSecret, &keys)
+ .await?;
+ Ok(candidates
+ .into_iter()
+ .find_map(|(key, sender)| Some((found.remove(&key)?, sender))))
+ }
+}
+
+/// A privacy token as sealed in its value; the timestamp is the row's
+/// plaintext `token_timestamp`, which expiry deletes by.
+#[derive(Serialize, Deserialize)]
+struct PrivacyTokenRecord {
+ token: Vec<u8>,
+ sender_timestamp: Option<DateTime<Utc>>,
+}
+
+impl PgWhatsAppStore {
+ fn open_privacy_token(
+ &self,
+ user_jid: &str,
+ nonce: &[u8],
+ value: &[u8],
+ ) -> Result<PrivacyTokenRecord, WhatsAppStoreError> {
+ let plaintext = self.cipher.open(
+ StoreName::PrivacyToken,
+ &[user_jid.as_bytes()],
+ nonce,
+ value,
+ )?;
+ postcard::from_bytes(&plaintext).map_err(|_| WhatsAppStoreError::Malformed)
+ }
+}
+
+#[async_trait]
+impl PrivacyTokenStore for PgWhatsAppStore {
+ /// As whatsmeow: an older token never replaces a newer one, and a token
+ /// without a sender timestamp keeps the stored one.
+ async fn put_privacy_tokens(&self, tokens: &[PrivacyToken]) -> Result<(), StoreError> {
+ let mut newest: BTreeMap<String, &PrivacyToken> = BTreeMap::new();
+ for token in tokens {
+ let user = token.user.to_non_ad().to_string();
+ match newest.get(&user) {
+ Some(kept) if kept.timestamp > token.timestamp => {}
+ _ => {
+ newest.insert(user, token);
+ }
+ }
+ }
+ if newest.is_empty() {
+ return Ok(());
+ }
+ let mut transaction = self.begin_write().await?;
+ self.lock_device(&mut transaction).await?;
+ let users: Vec<String> = newest.keys().cloned().collect();
+ let existing = sqlx::query!(
+ r#"
+ SELECT user_jid, token_timestamp, nonce, value
+ FROM whatsapp_privacy_token
+ WHERE account_id = $1 AND user_jid = ANY($2)
+ "#,
+ self.account_id,
+ &users,
+ )
+ .fetch_all(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ let existing: HashMap<String, (DateTime<Utc>, Option<DateTime<Utc>>)> = existing
+ .into_iter()
+ .map(|row| {
+ let record = self.open_privacy_token(&row.user_jid, &row.nonce, &row.value)?;
+ Ok((row.user_jid, (row.token_timestamp, record.sender_timestamp)))
+ })
+ .collect::<Result<_, WhatsAppStoreError>>()?;
+
+ let mut user_jids = Vec::with_capacity(newest.len());
+ let mut timestamps = Vec::with_capacity(newest.len());
+ let mut nonces = Vec::with_capacity(newest.len());
+ let mut values = Vec::with_capacity(newest.len());
+ for (user, token) in newest {
+ let sender_timestamp = match existing.get(&user) {
+ Some((stored, _)) if token.timestamp < *stored => continue,
+ Some((_, stored_sender)) => token.sender_timestamp.or(*stored_sender),
+ None => token.sender_timestamp,
+ };
+ let plaintext = postcard::to_allocvec(&PrivacyTokenRecord {
+ token: token.token.clone(),
+ sender_timestamp,
+ })
+ .map_err(|_| WhatsAppStoreError::Malformed)?;
+ let sealed =
+ self.cipher
+ .seal(StoreName::PrivacyToken, &[user.as_bytes()], &plaintext)?;
+ user_jids.push(user);
+ timestamps.push(token.timestamp);
+ nonces.push(sealed.nonce);
+ values.push(sealed.value);
+ }
+ sqlx::query!(
+ r#"
+ INSERT INTO whatsapp_privacy_token (account_id, user_jid, token_timestamp, nonce, value)
+ SELECT $1, entry.user_jid, entry.token_timestamp, entry.nonce, entry.value
+ FROM UNNEST($2::text[], $3::timestamptz[], $4::bytea[], $5::bytea[])
+ AS entry(user_jid, token_timestamp, nonce, value)
+ ON CONFLICT (account_id, user_jid) DO UPDATE SET
+ token_timestamp = EXCLUDED.token_timestamp,
+ nonce = EXCLUDED.nonce,
+ value = EXCLUDED.value
+ "#,
+ self.account_id,
+ &user_jids,
+ &timestamps,
+ &nonces,
+ &values,
+ )
+ .execute(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ /// Like whatsmeow, also finds a token stored under the user's other
+ /// identity (LID or phone number), preferring the newest.
+ async fn get_privacy_token(&self, user: &Jid) -> Result<Option<PrivacyToken>, StoreError> {
+ let user = user.to_non_ad();
+ let candidates: Vec<String> = self
+ .with_alternate(user.clone())
+ .await?
+ .iter()
+ .map(Jid::to_string)
+ .collect();
+ let row = sqlx::query!(
+ r#"
+ SELECT user_jid, token_timestamp, nonce, value
+ FROM whatsapp_privacy_token
+ WHERE account_id = $1 AND user_jid = ANY($2)
+ ORDER BY token_timestamp DESC
+ LIMIT 1
+ "#,
+ self.account_id,
+ &candidates,
+ )
+ .fetch_optional(&self.pool)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ let Some(row) = row else {
+ return Ok(None);
+ };
+ let record = self.open_privacy_token(&row.user_jid, &row.nonce, &row.value)?;
+ Ok(Some(PrivacyToken {
+ user,
+ token: record.token,
+ timestamp: row.token_timestamp,
+ sender_timestamp: record.sender_timestamp,
+ }))
+ }
+
+ async fn delete_expired_privacy_tokens(
+ &self,
+ cutoff: DateTime<Utc>,
+ ) -> Result<u64, StoreError> {
+ let mut transaction = self.begin_write().await?;
+ let deleted = sqlx::query!(
+ r#"
+ DELETE FROM whatsapp_privacy_token
+ WHERE account_id = $1 AND token_timestamp < $2
+ "#,
+ self.account_id,
+ cutoff,
+ )
+ .execute(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?
+ .rows_affected();
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(deleted)
+ }
+}
+
+#[async_trait]
+impl NctSaltStore for PgWhatsAppStore {
+ async fn put_nct_salt(&self, salt: Vec<u8>) -> Result<(), StoreError> {
+ Ok(self
+ .put_one(StoreName::NctSalt, NCT_SALT_KEY.to_owned(), salt)
+ .await?)
+ }
+
+ async fn get_nct_salt(&self) -> Result<Option<Vec<u8>>, StoreError> {
+ Ok(self
+ .get_value(&self.pool, StoreName::NctSalt, NCT_SALT_KEY)
+ .await?)
+ }
+
+ async fn delete_nct_salt(&self) -> Result<(), StoreError> {
+ Ok(self
+ .delete_one(StoreName::NctSalt, NCT_SALT_KEY.to_owned())
+ .await?)
+ }
+}
+
+/// A sent event as sealed in its value.
+#[derive(Serialize, Deserialize)]
+struct OutgoingEventRecord {
+ format: String,
+ plaintext: Vec<u8>,
+}
+
+#[async_trait]
+impl EventBuffer for PgWhatsAppStore {
+ async fn get_buffered_event(
+ &self,
+ ciphertext_hash: [u8; 32],
+ ) -> Result<Option<BufferedEvent>, StoreError> {
+ let row = sqlx::query!(
+ r#"
+ SELECT server_time, inserted_at, nonce, value
+ FROM whatsapp_event_buffer
+ WHERE account_id = $1 AND ciphertext_hash = $2
+ "#,
+ self.account_id,
+ ciphertext_hash.as_slice(),
+ )
+ .fetch_optional(&self.pool)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ let Some(row) = row else {
+ return Ok(None);
+ };
+ let plaintext = match (row.nonce, row.value) {
+ (Some(nonce), Some(value)) => self.cipher.open(
+ StoreName::BufferedEvent,
+ &[&ciphertext_hash],
+ &nonce,
+ &value,
+ )?,
+ // Cleared once handled.
+ _ => Vec::new(),
+ };
+ Ok(Some(BufferedEvent {
+ plaintext,
+ insert_time: row.inserted_at,
+ server_time: row.server_time,
+ }))
+ }
+
+ async fn put_buffered_event(
+ &self,
+ ciphertext_hash: [u8; 32],
+ plaintext: Vec<u8>,
+ server_timestamp: DateTime<Utc>,
+ ) -> Result<(), StoreError> {
+ let sealed = self
+ .cipher
+ .seal(StoreName::BufferedEvent, &[&ciphertext_hash], &plaintext)?;
+ let mut transaction = self.begin_write().await?;
+ sqlx::query!(
+ r#"
+ INSERT INTO whatsapp_event_buffer (account_id, ciphertext_hash, server_time, nonce, value)
+ VALUES ($1, $2, $3, $4, $5)
+ ON CONFLICT (account_id, ciphertext_hash) DO UPDATE SET
+ server_time = EXCLUDED.server_time,
+ inserted_at = now(),
+ nonce = EXCLUDED.nonce,
+ value = EXCLUDED.value
+ "#,
+ self.account_id,
+ ciphertext_hash.as_slice(),
+ server_timestamp,
+ sealed.nonce,
+ sealed.value,
+ )
+ .execute(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ /// whatsmeow runs the body in a database transaction that its store
+ /// calls join through the context; the port has no context to carry one,
+ /// so the body's calls run in their own transactions.
+ async fn do_decryption_txn(&self, body: DecryptionTransaction<'_>) -> Result<(), StoreError> {
+ body.await
+ }
+
+ async fn clear_buffered_event_plaintext(
+ &self,
+ ciphertext_hash: [u8; 32],
+ ) -> Result<(), StoreError> {
+ let mut transaction = self.begin_write().await?;
+ sqlx::query!(
+ r#"
+ UPDATE whatsapp_event_buffer
+ SET nonce = NULL, value = NULL
+ WHERE account_id = $1 AND ciphertext_hash = $2
+ "#,
+ self.account_id,
+ ciphertext_hash.as_slice(),
+ )
+ .execute(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn delete_old_buffered_hashes(&self) -> Result<(), StoreError> {
+ let mut transaction = self.begin_write().await?;
+ sqlx::query!(
+ r#"
+ DELETE FROM whatsapp_event_buffer
+ WHERE account_id = $1 AND inserted_at < $2
+ "#,
+ self.account_id,
+ Utc::now() - BUFFERED_EVENT_RETENTION,
+ )
+ .execute(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn get_outgoing_event(
+ &self,
+ chat_jid: &Jid,
+ alt_chat_jid: &Jid,
+ id: &MessageId,
+ ) -> Result<Option<(String, Vec<u8>)>, StoreError> {
+ let chat_jid = chat_jid.to_string();
+ let candidates = [chat_jid.clone(), alt_chat_jid.to_string()];
+ let rows = sqlx::query!(
+ r#"
+ SELECT chat_jid, nonce, value
+ FROM whatsapp_outgoing_event
+ WHERE account_id = $1 AND chat_jid = ANY($2) AND message_id = $3
+ "#,
+ self.account_id,
+ &candidates,
+ id,
+ )
+ .fetch_all(&self.pool)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ // Prefer the event stored under the chat JID itself.
+ let Some(row) = rows
+ .iter()
+ .find(|row| row.chat_jid == chat_jid)
+ .or_else(|| rows.first())
+ else {
+ return Ok(None);
+ };
+ let plaintext = self.cipher.open(
+ StoreName::OutgoingEvent,
+ &[row.chat_jid.as_bytes(), id.as_bytes()],
+ &row.nonce,
+ &row.value,
+ )?;
+ let record: OutgoingEventRecord =
+ postcard::from_bytes(&plaintext).map_err(|_| WhatsAppStoreError::Malformed)?;
+ Ok(Some((record.format, record.plaintext)))
+ }
+
+ async fn add_outgoing_event(
+ &self,
+ chat_jid: &Jid,
+ id: &MessageId,
+ format: &str,
+ plaintext: Vec<u8>,
+ ) -> Result<(), StoreError> {
+ let chat_jid = chat_jid.to_string();
+ let record = postcard::to_allocvec(&OutgoingEventRecord {
+ format: format.to_owned(),
+ plaintext,
+ })
+ .map_err(|_| WhatsAppStoreError::Malformed)?;
+ let sealed = self.cipher.seal(
+ StoreName::OutgoingEvent,
+ &[chat_jid.as_bytes(), id.as_bytes()],
+ &record,
+ )?;
+ let mut transaction = self.begin_write().await?;
+ sqlx::query!(
+ r#"
+ INSERT INTO whatsapp_outgoing_event (account_id, chat_jid, message_id, nonce, value)
+ VALUES ($1, $2, $3, $4, $5)
+ ON CONFLICT (account_id, chat_jid, message_id) DO UPDATE SET
+ created_at = now(),
+ nonce = EXCLUDED.nonce,
+ value = EXCLUDED.value
+ "#,
+ self.account_id,
+ chat_jid,
+ id,
+ sealed.nonce,
+ sealed.value,
+ )
+ .execute(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn delete_old_outgoing_events(&self) -> Result<(), StoreError> {
+ let mut transaction = self.begin_write().await?;
+ sqlx::query!(
+ r#"
+ DELETE FROM whatsapp_outgoing_event
+ WHERE account_id = $1 AND created_at < $2
+ "#,
+ self.account_id,
+ Utc::now() - OUTGOING_EVENT_RETENTION,
+ )
+ .execute(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+}
diff --git a/crates/whatsapp_store_pg/src/store/events/test.rs b/crates/whatsapp_store_pg/src/store/events/test.rs
new file mode 100644
index 0000000000..931fd490c3
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/events/test.rs
@@ -0,0 +1,285 @@
+use chrono::{TimeZone, Utc};
+use macro_db_migrator::MACRO_DB_MIGRATIONS;
+use sqlx::{Pool, Postgres};
+use whatsmeow::store::{
+ EventBuffer, LidStore, MessageSecretInsert, MsgSecretStore, NctSaltStore, PrivacyToken,
+ PrivacyTokenStore,
+};
+use whatsmeow::types::{
+ DEFAULT_USER_SERVER, GROUP_SERVER, HIDDEN_USER_SERVER, new_ad_jid, new_jid,
+};
+
+use crate::store::test::open_new_store;
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn message_secrets_keep_the_first_and_are_found_by_either_identity(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let group = new_jid("123-456", GROUP_SERVER);
+ let sender_pn = new_jid("111", DEFAULT_USER_SERVER);
+ let sender_lid = new_jid("98765", HIDDEN_USER_SERVER);
+ let sender_device = new_ad_jid("111", 0, 3);
+
+ store
+ .put_message_secrets(&[
+ MessageSecretInsert {
+ chat: group.clone(),
+ sender: sender_device.clone(),
+ id: "A1".to_owned(),
+ secret: vec![1],
+ },
+ MessageSecretInsert {
+ chat: group.clone(),
+ sender: sender_pn.clone(),
+ id: "A1".to_owned(),
+ secret: vec![2],
+ },
+ // Skipped: no secret.
+ MessageSecretInsert {
+ chat: group.clone(),
+ sender: sender_pn.clone(),
+ id: "A2".to_owned(),
+ secret: vec![],
+ },
+ ])
+ .await
+ .unwrap();
+ store
+ .put_message_secret(&group, &sender_pn, &"A1".to_owned(), vec![3])
+ .await
+ .unwrap();
+
+ assert_eq!(
+ store
+ .get_message_secret(&group, &sender_device, &"A1".to_owned())
+ .await
+ .unwrap(),
+ Some((vec![1], sender_pn.clone()))
+ );
+ assert_eq!(
+ store
+ .get_message_secret(&group, &sender_pn, &"A2".to_owned())
+ .await
+ .unwrap(),
+ None
+ );
+ // Not found by the LID until the mapping is known.
+ assert_eq!(
+ store
+ .get_message_secret(&group, &sender_lid, &"A1".to_owned())
+ .await
+ .unwrap(),
+ None
+ );
+ store
+ .put_lid_mapping(&sender_lid, &sender_pn)
+ .await
+ .unwrap();
+ assert_eq!(
+ store
+ .get_message_secret(&group, &sender_lid, &"A1".to_owned())
+ .await
+ .unwrap(),
+ Some((vec![1], sender_pn))
+ );
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn privacy_tokens_only_move_forward_in_time(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let alice = new_jid("111", DEFAULT_USER_SERVER);
+ let alice_lid = new_jid("98765", HIDDEN_USER_SERVER);
+ let bob = new_jid("222", DEFAULT_USER_SERVER);
+ let at = |seconds: i64| Utc.timestamp_opt(1_700_000_000 + seconds, 0).unwrap();
+ assert_eq!(store.get_privacy_token(&alice).await.unwrap(), None);
+
+ store
+ .put_privacy_tokens(&[
+ PrivacyToken {
+ user: new_ad_jid("111", 0, 2),
+ token: vec![1],
+ timestamp: at(10),
+ sender_timestamp: Some(at(5)),
+ },
+ PrivacyToken {
+ user: bob.clone(),
+ token: vec![2],
+ timestamp: at(10),
+ sender_timestamp: None,
+ },
+ ])
+ .await
+ .unwrap();
+ // Older: ignored.
+ store
+ .put_privacy_tokens(&[PrivacyToken {
+ user: alice.clone(),
+ token: vec![9],
+ timestamp: at(1),
+ sender_timestamp: None,
+ }])
+ .await
+ .unwrap();
+ assert_eq!(
+ store.get_privacy_token(&alice).await.unwrap(),
+ Some(PrivacyToken {
+ user: alice.clone(),
+ token: vec![1],
+ timestamp: at(10),
+ sender_timestamp: Some(at(5)),
+ })
+ );
+ // Newer without a sender timestamp: keeps the stored sender timestamp.
+ store
+ .put_privacy_tokens(&[PrivacyToken {
+ user: alice.clone(),
+ token: vec![3],
+ timestamp: at(20),
+ sender_timestamp: None,
+ }])
+ .await
+ .unwrap();
+ let expected = PrivacyToken {
+ user: alice.clone(),
+ token: vec![3],
+ timestamp: at(20),
+ sender_timestamp: Some(at(5)),
+ };
+ assert_eq!(
+ store.get_privacy_token(&alice).await.unwrap(),
+ Some(expected.clone())
+ );
+
+ // Found by the LID once mapped, reported under the asked-for user.
+ store.put_lid_mapping(&alice_lid, &alice).await.unwrap();
+ assert_eq!(
+ store.get_privacy_token(&alice_lid).await.unwrap(),
+ Some(PrivacyToken {
+ user: alice_lid,
+ ..expected
+ })
+ );
+
+ assert_eq!(
+ store.delete_expired_privacy_tokens(at(15)).await.unwrap(),
+ 1
+ );
+ assert_eq!(store.get_privacy_token(&bob).await.unwrap(), None);
+ assert!(store.get_privacy_token(&alice).await.unwrap().is_some());
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn the_nct_salt_round_trips(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ assert_eq!(store.get_nct_salt().await.unwrap(), None);
+ store.put_nct_salt(vec![1, 2, 3]).await.unwrap();
+ store.put_nct_salt(vec![4, 5]).await.unwrap();
+ assert_eq!(store.get_nct_salt().await.unwrap(), Some(vec![4, 5]));
+ store.delete_nct_salt().await.unwrap();
+ assert_eq!(store.get_nct_salt().await.unwrap(), None);
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn buffered_events_are_cleared_and_expire(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let server_time = Utc.timestamp_opt(1_700_000_000, 0).unwrap();
+ assert_eq!(store.get_buffered_event([1; 32]).await.unwrap(), None);
+
+ store
+ .put_buffered_event([1; 32], b"decrypted".to_vec(), server_time)
+ .await
+ .unwrap();
+ store
+ .put_buffered_event([2; 32], b"other".to_vec(), server_time)
+ .await
+ .unwrap();
+ let buffered = store.get_buffered_event([1; 32]).await.unwrap().unwrap();
+ assert_eq!(buffered.plaintext, b"decrypted".to_vec());
+ assert_eq!(buffered.server_time, server_time);
+
+ store.clear_buffered_event_plaintext([1; 32]).await.unwrap();
+ let cleared = store.get_buffered_event([1; 32]).await.unwrap().unwrap();
+ assert_eq!(cleared.plaintext, Vec::<u8>::new());
+ assert_eq!(cleared.insert_time, buffered.insert_time);
+
+ let ran = std::sync::atomic::AtomicBool::new(false);
+ store
+ .do_decryption_txn(Box::pin(async {
+ ran.store(true, std::sync::atomic::Ordering::SeqCst);
+ Ok(())
+ }))
+ .await
+ .unwrap();
+ assert!(ran.into_inner());
+
+ sqlx::query!(
+ r#"
+ UPDATE whatsapp_event_buffer
+ SET inserted_at = now() - interval '15 days'
+ WHERE account_id = $1 AND ciphertext_hash = $2
+ "#,
+ store.account_id(),
+ [2u8; 32].as_slice(),
+ )
+ .execute(&pool)
+ .await
+ .unwrap();
+ store.delete_old_buffered_hashes().await.unwrap();
+ assert_eq!(store.get_buffered_event([2; 32]).await.unwrap(), None);
+ assert!(store.get_buffered_event([1; 32]).await.unwrap().is_some());
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn outgoing_events_are_found_by_either_chat_and_expire(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let chat = new_jid("111", DEFAULT_USER_SERVER);
+ let alt_chat = new_jid("98765", HIDDEN_USER_SERVER);
+ let other = new_jid("222", DEFAULT_USER_SERVER);
+ let id = "3EB0AA".to_owned();
+
+ store
+ .add_outgoing_event(&alt_chat, &id, "e2e", b"sent".to_vec())
+ .await
+ .unwrap();
+ assert_eq!(
+ store
+ .get_outgoing_event(&chat, &alt_chat, &id)
+ .await
+ .unwrap(),
+ Some(("e2e".to_owned(), b"sent".to_vec()))
+ );
+ store
+ .add_outgoing_event(&chat, &id, "fb", b"sent to pn".to_vec())
+ .await
+ .unwrap();
+ assert_eq!(
+ store
+ .get_outgoing_event(&chat, &alt_chat, &id)
+ .await
+ .unwrap(),
+ Some(("fb".to_owned(), b"sent to pn".to_vec()))
+ );
+ assert_eq!(
+ store.get_outgoing_event(&other, &other, &id).await.unwrap(),
+ None
+ );
+
+ sqlx::query!(
+ r#"
+ UPDATE whatsapp_outgoing_event
+ SET created_at = now() - interval '8 days'
+ WHERE account_id = $1 AND chat_jid = '[email protected]'
+ "#,
+ store.account_id(),
+ )
+ .execute(&pool)
+ .await
+ .unwrap();
+ store.delete_old_outgoing_events().await.unwrap();
+ assert_eq!(
+ store
+ .get_outgoing_event(&chat, &alt_chat, &id)
+ .await
+ .unwrap(),
+ Some(("e2e".to_owned(), b"sent".to_vec()))
+ );
+}
diff --git a/crates/whatsapp_store_pg/src/store/lid.rs b/crates/whatsapp_store_pg/src/store/lid.rs
new file mode 100644
index 0000000000..88755b43ac
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/lid.rs
@@ -0,0 +1,225 @@
+//! LID ↔ phone number mappings.
+//!
+//! whatsmeow keeps one mapping table shared by every device; here each
+//! account has its own, since accounts belong to different people. Which LID
+//! belongs to which phone number is personal data (it de-pseudonymizes a
+//! LID), so each direction is a sealed value: `lid_by_pn` keyed by the phone
+//! number user, `pn_by_lid` keyed by the LID user. The users themselves are
+//! plaintext keys, as JIDs are everywhere else in the store.
+
+#[cfg(test)]
+mod test;
+
+use std::collections::{BTreeMap, HashMap};
+
+use async_trait::async_trait;
+use sqlx::PgConnection;
+use whatsmeow::store::{LidMapping, LidStore, StoreError};
+use whatsmeow::types::{DEFAULT_USER_SERVER, HIDDEN_USER_SERVER, Jid};
+
+use super::PgWhatsAppStore;
+use crate::cipher::StoreName;
+use crate::error::WhatsAppStoreError;
+
+fn user_jid(user: Vec<u8>, device: u16, server: &str) -> Result<Jid, WhatsAppStoreError> {
+ Ok(Jid {
+ user: String::from_utf8(user).map_err(|_| WhatsAppStoreError::Malformed)?,
+ device,
+ server: server.to_owned(),
+ ..Jid::default()
+ })
+}
+
+fn is_valid_mapping(lid: &Jid, pn: &Jid) -> bool {
+ lid.server == HIDDEN_USER_SERVER && pn.server == DEFAULT_USER_SERVER
+}
+
+impl PgWhatsAppStore {
+ /// The JID followed by its other identity (LID or phone number) when one
+ /// is known, for lookups that accept either.
+ pub(super) async fn with_alternate(&self, jid: Jid) -> Result<Vec<Jid>, WhatsAppStoreError> {
+ let alternate = match jid.server.as_str() {
+ DEFAULT_USER_SERVER => {
+ self.lookup(&jid, StoreName::LidByPn, HIDDEN_USER_SERVER)
+ .await?
+ }
+ HIDDEN_USER_SERVER => {
+ self.lookup(&jid, StoreName::PnByLid, DEFAULT_USER_SERVER)
+ .await?
+ }
+ _ => None,
+ };
+ Ok(std::iter::once(jid).chain(alternate).collect())
+ }
+
+ async fn lookup(
+ &self,
+ source: &Jid,
+ store: StoreName,
+ target_server: &str,
+ ) -> Result<Option<Jid>, WhatsAppStoreError> {
+ self.get_value(&self.pool, store, &source.user)
+ .await?
+ .map(|user| user_jid(user, source.device, target_server))
+ .transpose()
+ }
+
+ /// Applies mappings in order, each replacing any older mapping of either
+ /// side, as whatsmeow's `PutLIDMapping` does. Reads both directions of
+ /// every user in one query each, then writes and deletes in one each.
+ async fn put_mappings(
+ &self,
+ connection: &mut PgConnection,
+ mappings: &[&LidMapping],
+ ) -> Result<(), WhatsAppStoreError> {
+ let pns: Vec<String> = mappings
+ .iter()
+ .map(|mapping| mapping.pn.user.clone())
+ .collect();
+ let lids: Vec<String> = mappings
+ .iter()
+ .map(|mapping| mapping.lid.user.clone())
+ .collect();
+ // `None` marks a mapping deleted in this batch.
+ let mut lid_by_pn: HashMap<String, Option<String>> = HashMap::new();
+ let mut pn_by_lid: HashMap<String, Option<String>> = HashMap::new();
+ for (pn, lid) in self
+ .get_values(&mut *connection, StoreName::LidByPn, &pns)
+ .await?
+ {
+ lid_by_pn.insert(
+ pn,
+ Some(String::from_utf8(lid).map_err(|_| WhatsAppStoreError::Malformed)?),
+ );
+ }
+ for (lid, pn) in self
+ .get_values(&mut *connection, StoreName::PnByLid, &lids)
+ .await?
+ {
+ pn_by_lid.insert(
+ lid,
+ Some(String::from_utf8(pn).map_err(|_| WhatsAppStoreError::Malformed)?),
+ );
+ }
+
+ for mapping in mappings {
+ let (lid, pn) = (&mapping.lid.user, &mapping.pn.user);
+ let old_lid = lid_by_pn.insert(pn.clone(), Some(lid.clone())).flatten();
+ let old_pn = pn_by_lid.insert(lid.clone(), Some(pn.clone())).flatten();
+ if let Some(old_lid) = old_lid
+ && old_lid != *lid
+ {
+ pn_by_lid.insert(old_lid, None);
+ }
+ if let Some(old_pn) = old_pn
+ && old_pn != *pn
+ {
+ lid_by_pn.insert(old_pn, None);
+ }
+ }
+
+ for (store, entries) in [
+ (StoreName::LidByPn, lid_by_pn),
+ (StoreName::PnByLid, pn_by_lid),
+ ] {
+ let mut puts = BTreeMap::new();
+ let mut deletes = Vec::new();
+ for (key, value) in entries {
+ match value {
+ Some(value) => {
+ puts.insert(key, value.into_bytes());
+ }
+ None => deletes.push(key),
+ }
+ }
+ self.delete_values(connection, store, &deletes).await?;
+ self.put_values(connection, store, puts).await?;
+ }
+ Ok(())
+ }
+}
+
+#[async_trait]
+impl LidStore for PgWhatsAppStore {
+ async fn put_many_lid_mappings(&self, mappings: &[LidMapping]) -> Result<(), StoreError> {
+ // Invalid entries are skipped, as whatsmeow skips them.
+ let valid: Vec<&LidMapping> = mappings
+ .iter()
+ .filter(|mapping| is_valid_mapping(&mapping.lid, &mapping.pn))
+ .collect();
+ if valid.is_empty() {
+ return Ok(());
+ }
+ let mut transaction = self.begin_write().await?;
+ self.lock_device(&mut transaction).await?;
+ self.put_mappings(&mut transaction, &valid).await?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn put_lid_mapping(&self, lid: &Jid, jid: &Jid) -> Result<(), StoreError> {
+ if !is_valid_mapping(lid, jid) {
+ return Err(StoreError::InvalidArgument(
+ "invalid PutLIDMapping call: expected a LID and a phone number JID".to_owned(),
+ ));
+ }
+ let mapping = LidMapping {
+ lid: lid.clone(),
+ pn: jid.clone(),
+ };
+ let mut transaction = self.begin_write().await?;
+ self.lock_device(&mut transaction).await?;
+ self.put_mappings(&mut transaction, &[&mapping]).await?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn get_pn_for_lid(&self, lid: &Jid) -> Result<Option<Jid>, StoreError> {
+ if lid.server != HIDDEN_USER_SERVER {
+ return Err(StoreError::InvalidArgument(
+ "invalid GetPNForLID call with non-LID JID".to_owned(),
+ ));
+ }
+ Ok(self
+ .lookup(lid, StoreName::PnByLid, DEFAULT_USER_SERVER)
+ .await?)
+ }
+
+ async fn get_lid_for_pn(&self, pn: &Jid) -> Result<Option<Jid>, StoreError> {
+ if pn.server != DEFAULT_USER_SERVER {
+ return Err(StoreError::InvalidArgument(
+ "invalid GetLIDForPN call with non-PN JID".to_owned(),
+ ));
+ }
+ Ok(self
+ .lookup(pn, StoreName::LidByPn, HIDDEN_USER_SERVER)
+ .await?)
+ }
+
+ async fn get_many_lids_for_pns(&self, pns: &[Jid]) -> Result<HashMap<Jid, Jid>, StoreError> {
+ let pns: Vec<&Jid> = pns
+ .iter()
+ .filter(|pn| pn.server == DEFAULT_USER_SERVER)
+ .collect();
+ let users: Vec<String> = pns.iter().map(|pn| pn.user.clone()).collect();
+ let lids = self
+ .get_values(&self.pool, StoreName::LidByPn, &users)
+ .await?;
+ Ok(pns
+ .into_iter()
+ .filter_map(|pn| {
+ let lid = lids.get(&pn.user)?;
+ Some(
+ user_jid(lid.clone(), pn.device, HIDDEN_USER_SERVER)
+ .map(|lid| (pn.clone(), lid)),
+ )
+ })
+ .collect::<Result<_, WhatsAppStoreError>>()?)
+ }
+}
diff --git a/crates/whatsapp_store_pg/src/store/lid/test.rs b/crates/whatsapp_store_pg/src/store/lid/test.rs
new file mode 100644
index 0000000000..d7e16b967b
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/lid/test.rs
@@ -0,0 +1,130 @@
+use std::collections::HashMap;
+
+use macro_db_migrator::MACRO_DB_MIGRATIONS;
+use sqlx::{Pool, Postgres};
+use whatsmeow::store::{LidMapping, LidStore, StoreError};
+use whatsmeow::types::{
+ DEFAULT_USER_SERVER, GROUP_SERVER, HIDDEN_USER_SERVER, new_ad_jid, new_jid,
+};
+
+use crate::store::test::open_new_store;
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn mappings_resolve_both_ways_keeping_the_device(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let pn = new_jid("111", DEFAULT_USER_SERVER);
+ let lid = new_jid("98765", HIDDEN_USER_SERVER);
+ assert_eq!(store.get_lid_for_pn(&pn).await.unwrap(), None);
+
+ store.put_lid_mapping(&lid, &pn).await.unwrap();
+ assert_eq!(store.get_lid_for_pn(&pn).await.unwrap(), Some(lid.clone()));
+ assert_eq!(store.get_pn_for_lid(&lid).await.unwrap(), Some(pn.clone()));
+
+ let pn_device = new_ad_jid("111", 0, 4);
+ let mut lid_device = lid.clone();
+ lid_device.device = 4;
+ assert_eq!(
+ store.get_lid_for_pn(&pn_device).await.unwrap(),
+ Some(lid_device.clone())
+ );
+ assert_eq!(
+ store.get_pn_for_lid(&lid_device).await.unwrap(),
+ Some(pn_device)
+ );
+
+ assert!(matches!(
+ store.get_lid_for_pn(&lid).await.unwrap_err(),
+ StoreError::InvalidArgument(_)
+ ));
+ assert!(matches!(
+ store.get_pn_for_lid(&pn).await.unwrap_err(),
+ StoreError::InvalidArgument(_)
+ ));
+ assert!(matches!(
+ store.put_lid_mapping(&pn, &lid).await.unwrap_err(),
+ StoreError::InvalidArgument(_)
+ ));
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn a_new_mapping_replaces_older_ones_of_either_side(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let pn = new_jid("111", DEFAULT_USER_SERVER);
+ let other_pn = new_jid("222", DEFAULT_USER_SERVER);
+ let lid = new_jid("98765", HIDDEN_USER_SERVER);
+ let new_lid = new_jid("55555", HIDDEN_USER_SERVER);
+
+ store.put_lid_mapping(&lid, &pn).await.unwrap();
+ // The phone number got a new LID: the old LID maps to nothing.
+ store.put_lid_mapping(&new_lid, &pn).await.unwrap();
+ assert_eq!(
+ store.get_lid_for_pn(&pn).await.unwrap(),
+ Some(new_lid.clone())
+ );
+ assert_eq!(store.get_pn_for_lid(&lid).await.unwrap(), None);
+ // The LID moved to another phone number: the old number maps to nothing.
+ store.put_lid_mapping(&new_lid, &other_pn).await.unwrap();
+ assert_eq!(
+ store.get_pn_for_lid(&new_lid).await.unwrap(),
+ Some(other_pn.clone())
+ );
+ assert_eq!(store.get_lid_for_pn(&pn).await.unwrap(), None);
+ assert_eq!(
+ store.get_lid_for_pn(&other_pn).await.unwrap(),
+ Some(new_lid)
+ );
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn batches_skip_invalid_mappings_and_apply_in_order(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let pns: Vec<_> = (0..300)
+ .map(|index| new_jid(&format!("1555{index:04}"), DEFAULT_USER_SERVER))
+ .collect();
+ let lids: Vec<_> = (0..300)
+ .map(|index| new_jid(&format!("9000{index:04}"), HIDDEN_USER_SERVER))
+ .collect();
+ let mut mappings: Vec<LidMapping> = pns
+ .iter()
+ .zip(&lids)
+ .map(|(pn, lid)| LidMapping {
+ lid: lid.clone(),
+ pn: pn.clone(),
+ })
+ .collect();
+ mappings.push(LidMapping {
+ lid: new_jid("123-456", GROUP_SERVER),
+ pn: pns[0].clone(),
+ });
+ // A later mapping in the same batch moves the first phone number.
+ let moved_lid = new_jid("77777", HIDDEN_USER_SERVER);
+ mappings.push(LidMapping {
+ lid: moved_lid.clone(),
+ pn: pns[0].clone(),
+ });
+ store.put_many_lid_mappings(&mappings).await.unwrap();
+ store.put_many_lid_mappings(&[]).await.unwrap();
+
+ assert_eq!(
+ store.get_lid_for_pn(&pns[0]).await.unwrap(),
+ Some(moved_lid)
+ );
+ assert_eq!(store.get_pn_for_lid(&lids[0]).await.unwrap(), None);
+ assert_eq!(
+ store.get_pn_for_lid(&lids[299]).await.unwrap(),
+ Some(pns[299].clone())
+ );
+
+ let unknown = new_jid("1999", DEFAULT_USER_SERVER);
+ let device = new_ad_jid("15550007", 0, 2);
+ let mut device_lid = lids[7].clone();
+ device_lid.device = 2;
+ let many = store
+ .get_many_lids_for_pns(&[pns[1].clone(), unknown, device.clone(), lids[2].clone()])
+ .await
+ .unwrap();
+ assert_eq!(
+ many,
+ HashMap::from([(pns[1].clone(), lids[1].clone()), (device, device_lid)])
+ );
+}
diff --git a/crates/whatsapp_store_pg/src/store/signal.rs b/crates/whatsapp_store_pg/src/store/signal.rs
new file mode 100644
index 0000000000..f2dcba8c4d
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/signal.rs
@@ -0,0 +1,456 @@
+//! Identities, sessions, prekeys and sender keys: what libsignal reads and
+//! writes, following whatsmeow's `store/sqlstore`.
+
+#[cfg(test)]
+mod test;
+
+use std::collections::{BTreeMap, HashMap};
+
+use async_trait::async_trait;
+use whatsmeow::store::{IdentityStore, PreKeyStore, SenderKeyStore, SessionStore, StoreError};
+use whatsmeow::types::Jid;
+use whatsmeow::util::keys::{PreKey, new_key_pair_from_private_key, new_pre_key};
+
+use super::{PgWhatsAppStore, composite_key};
+use crate::cipher::StoreName;
+use crate::error::WhatsAppStoreError;
+
+/// The prefix of every Signal address of a user: `user:device`.
+fn address_prefix(user: &str) -> String {
+ format!("{user}:")
+}
+
+#[async_trait]
+impl IdentityStore for PgWhatsAppStore {
+ async fn put_identity(&self, address: &str, key: [u8; 32]) -> Result<(), StoreError> {
+ Ok(self
+ .put_one(StoreName::Identity, address.to_owned(), key.to_vec())
+ .await?)
+ }
+
+ async fn delete_all_identities(&self, phone: &str) -> Result<(), StoreError> {
+ let mut transaction = self.begin_write().await?;
+ self.delete_prefix(
+ &mut transaction,
+ StoreName::Identity,
+ &address_prefix(phone),
+ )
+ .await?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn delete_identity(&self, address: &str) -> Result<(), StoreError> {
+ Ok(self
+ .delete_one(StoreName::Identity, address.to_owned())
+ .await?)
+ }
+
+ async fn is_trusted_identity(&self, address: &str, key: [u8; 32]) -> Result<bool, StoreError> {
+ let Some(existing) = self
+ .get_value(&self.pool, StoreName::Identity, address)
+ .await?
+ else {
+ // Trust if not known; it is saved automatically later.
+ return Ok(true);
+ };
+ let existing: [u8; 32] = existing
+ .try_into()
+ .map_err(|_| WhatsAppStoreError::Malformed)?;
+ Ok(existing == key)
+ }
+}
+
+#[async_trait]
+impl SessionStore for PgWhatsAppStore {
+ async fn get_session(&self, address: &str) -> Result<Option<Vec<u8>>, StoreError> {
+ Ok(self
+ .get_value(&self.pool, StoreName::Session, address)
+ .await?)
+ }
+
+ async fn has_session(&self, address: &str) -> Result<bool, StoreError> {
+ let exists = sqlx::query_scalar!(
+ r#"
+ SELECT EXISTS (
+ SELECT 1
+ FROM whatsapp_store_value
+ WHERE account_id = $1 AND store = $2 AND key = $3
+ ) AS "exists!"
+ "#,
+ self.account_id,
+ StoreName::Session.as_str(),
+ address,
+ )
+ .fetch_one(&self.pool)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(exists)
+ }
+
+ async fn get_many_sessions(
+ &self,
+ addresses: &[String],
+ ) -> Result<HashMap<String, Option<Vec<u8>>>, StoreError> {
+ let mut found = self
+ .get_values(&self.pool, StoreName::Session, addresses)
+ .await?;
+ Ok(addresses
+ .iter()
+ .map(|address| (address.clone(), found.remove(address)))
+ .collect())
+ }
+
+ async fn put_session(&self, address: &str, session: Vec<u8>) -> Result<(), StoreError> {
+ Ok(self
+ .put_one(StoreName::Session, address.to_owned(), session)
+ .await?)
+ }
+
+ async fn put_many_sessions(
+ &self,
+ sessions: HashMap<String, Vec<u8>>,
+ ) -> Result<(), StoreError> {
+ let mut transaction = self.begin_write().await?;
+ self.put_values(
+ &mut transaction,
+ StoreName::Session,
+ sessions.into_iter().collect(),
+ )
+ .await?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn delete_all_sessions(&self, phone: &str) -> Result<(), StoreError> {
+ let mut transaction = self.begin_write().await?;
+ self.delete_prefix(&mut transaction, StoreName::Session, &address_prefix(phone))
+ .await?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn delete_session(&self, address: &str) -> Result<(), StoreError> {
+ Ok(self
+ .delete_one(StoreName::Session, address.to_owned())
+ .await?)
+ }
+
+ #[tracing::instrument(
+ name = "whatsapp_store.migrate_pn_to_lid",
+ skip_all,
+ fields(account_id = %self.account_id),
+ err
+ )]
+ async fn migrate_pn_to_lid(&self, pn: &Jid, lid: &Jid) -> Result<(), StoreError> {
+ let pn_user = pn.signal_address_user();
+ if !self.migrated_users().insert(pn_user.clone()) {
+ return Ok(());
+ }
+ let migrated = self
+ .move_signal_user(
+ &address_prefix(&pn_user),
+ &address_prefix(&lid.signal_address_user()),
+ )
+ .await;
+ if migrated.is_err() {
+ // Not migrated after all: let the next call try again.
+ self.migrated_users().remove(&pn_user);
+ }
+ Ok(migrated?)
+ }
+}
+
+impl PgWhatsAppStore {
+ fn migrated_users(&self) -> std::sync::MutexGuard<'_, std::collections::HashSet<String>> {
+ // Every use is one set operation, so a panic can't leave it half-written.
+ self.migrated_pn_sessions
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ }
+
+ /// Moves the sessions, identities and sender keys of one Signal user to
+ /// another, re-encrypting each under its new key, replacing what the new
+ /// user already has. Sender keys are keyed sender first, so the same
+ /// prefix finds them.
+ async fn move_signal_user(&self, from: &str, to: &str) -> Result<(), WhatsAppStoreError> {
+ let mut transaction = self.begin_write().await?;
+ for store in [
+ StoreName::Session,
+ StoreName::Identity,
+ StoreName::SenderKey,
+ ] {
+ let moved: BTreeMap<String, Vec<u8>> = self
+ .list_values(&mut *transaction, store, from)
+ .await?
+ .into_iter()
+ .filter_map(|(key, value)| {
+ let rest = key.strip_prefix(from)?;
+ Some((format!("{to}{rest}"), value))
+ })
+ .collect();
+ if moved.is_empty() {
+ continue;
+ }
+ tracing::debug!(
+ store = store.as_str(),
+ count = moved.len(),
+ "moving signal user"
+ );
+ self.put_values(&mut transaction, store, moved).await?;
+ self.delete_prefix(&mut transaction, store, from).await?;
+ }
+ transaction.commit().await?;
+ Ok(())
+ }
+
+ /// The next prekey ID: one past the highest ever stored, as whatsmeow
+ /// numbers them (from 1).
+ async fn next_pre_key_id(
+ &self,
+ connection: &mut sqlx::PgConnection,
+ ) -> Result<u32, WhatsAppStoreError> {
+ let last = sqlx::query_scalar!(
+ r#"
+ SELECT MAX(key_id)
+ FROM whatsapp_pre_key
+ WHERE account_id = $1
+ "#,
+ self.account_id,
+ )
+ .fetch_one(connection)
+ .await?
+ .unwrap_or(0);
+ u32::try_from(last + 1)
+ .map_err(|_| WhatsAppStoreError::InvalidArgument("prekey IDs exhausted".to_owned()))
+ }
+
+ /// Stores new prekeys in one statement.
+ async fn insert_pre_keys(
+ &self,
+ connection: &mut sqlx::PgConnection,
+ keys: &[PreKey],
+ uploaded: bool,
+ ) -> Result<(), WhatsAppStoreError> {
+ let mut key_ids = Vec::with_capacity(keys.len());
+ let mut nonces = Vec::with_capacity(keys.len());
+ let mut values = Vec::with_capacity(keys.len());
+ for key in keys {
+ let sealed = self.cipher.seal(
+ StoreName::PreKey,
+ &[&key.key_id.to_be_bytes()],
+ &key.key_pair.private,
+ )?;
+ key_ids.push(i64::from(key.key_id));
+ nonces.push(sealed.nonce);
+ values.push(sealed.value);
+ }
+ sqlx::query!(
+ r#"
+ INSERT INTO whatsapp_pre_key (account_id, key_id, uploaded, nonce, value)
+ SELECT $1, entry.key_id, $2, entry.nonce, entry.value
+ FROM UNNEST($3::bigint[], $4::bytea[], $5::bytea[]) AS entry(key_id, nonce, value)
+ "#,
+ self.account_id,
+ uploaded,
+ &key_ids,
+ &nonces,
+ &values,
+ )
+ .execute(connection)
+ .await?;
+ Ok(())
+ }
+
+ fn open_pre_key(
+ &self,
+ key_id: i64,
+ nonce: &[u8],
+ value: &[u8],
+ ) -> Result<PreKey, WhatsAppStoreError> {
+ let key_id = u32::try_from(key_id).map_err(|_| WhatsAppStoreError::Malformed)?;
+ let private: [u8; 32] = self
+ .cipher
+ .open(StoreName::PreKey, &[&key_id.to_be_bytes()], nonce, value)?
+ .try_into()
+ .map_err(|_| WhatsAppStoreError::Malformed)?;
+ Ok(PreKey {
+ key_pair: new_key_pair_from_private_key(private),
+ key_id,
+ signature: None,
+ })
+ }
+}
+
+#[async_trait]
+impl PreKeyStore for PgWhatsAppStore {
+ #[tracing::instrument(
+ name = "whatsapp_store.get_or_gen_pre_keys",
+ skip(self),
+ fields(account_id = %self.account_id, generated),
+ err
+ )]
+ async fn get_or_gen_pre_keys(&self, count: u32) -> Result<Vec<PreKey>, StoreError> {
+ let mut transaction = self.begin_write().await?;
+ // Serializes prekey numbering, as whatsmeow's prekey lock does.
+ self.lock_device(&mut transaction).await?;
+ let rows = sqlx::query!(
+ r#"
+ SELECT key_id, nonce, value
+ FROM whatsapp_pre_key
+ WHERE account_id = $1 AND NOT uploaded
+ ORDER BY key_id
+ LIMIT $2
+ "#,
+ self.account_id,
+ i64::from(count),
+ )
+ .fetch_all(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ let mut keys = rows
+ .iter()
+ .map(|row| self.open_pre_key(row.key_id, &row.nonce, &row.value))
+ .collect::<Result<Vec<_>, _>>()?;
+ let missing = count.saturating_sub(u32::try_from(keys.len()).unwrap_or(u32::MAX));
+ tracing::Span::current().record("generated", missing);
+ if missing > 0 {
+ let first_id = self.next_pre_key_id(&mut transaction).await?;
+ let new_keys = (0..missing)
+ .map(|offset| {
+ first_id
+ .checked_add(offset)
+ .map(new_pre_key)
+ .ok_or_else(|| {
+ WhatsAppStoreError::InvalidArgument("prekey IDs exhausted".to_owned())
+ })
+ })
+ .collect::<Result<Vec<_>, _>>()?;
+ self.insert_pre_keys(&mut transaction, &new_keys, false)
+ .await?;
+ keys.extend(new_keys);
+ }
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(keys)
+ }
+
+ async fn gen_one_pre_key(&self) -> Result<PreKey, StoreError> {
+ let mut transaction = self.begin_write().await?;
+ self.lock_device(&mut transaction).await?;
+ let key = new_pre_key(self.next_pre_key_id(&mut transaction).await?);
+ self.insert_pre_keys(&mut transaction, std::slice::from_ref(&key), true)
+ .await?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(key)
+ }
+
+ async fn get_pre_key(&self, id: u32) -> Result<Option<PreKey>, StoreError> {
+ let row = sqlx::query!(
+ r#"
+ SELECT key_id, nonce, value
+ FROM whatsapp_pre_key
+ WHERE account_id = $1 AND key_id = $2
+ "#,
+ self.account_id,
+ i64::from(id),
+ )
+ .fetch_optional(&self.pool)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(row
+ .map(|row| self.open_pre_key(row.key_id, &row.nonce, &row.value))
+ .transpose()?)
+ }
+
+ async fn remove_pre_key(&self, id: u32) -> Result<(), StoreError> {
+ let mut transaction = self.begin_write().await?;
+ sqlx::query!(
+ r#"
+ DELETE FROM whatsapp_pre_key
+ WHERE account_id = $1 AND key_id = $2
+ "#,
+ self.account_id,
+ i64::from(id),
+ )
+ .execute(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn mark_pre_keys_as_uploaded(&self, up_to_id: u32) -> Result<(), StoreError> {
+ let mut transaction = self.begin_write().await?;
+ sqlx::query!(
+ r#"
+ UPDATE whatsapp_pre_key
+ SET uploaded = true
+ WHERE account_id = $1 AND key_id <= $2 AND NOT uploaded
+ "#,
+ self.account_id,
+ i64::from(up_to_id),
+ )
+ .execute(&mut *transaction)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ transaction
+ .commit()
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(())
+ }
+
+ async fn uploaded_pre_key_count(&self) -> Result<usize, StoreError> {
+ let count = sqlx::query_scalar!(
+ r#"
+ SELECT COUNT(*) AS "count!"
+ FROM whatsapp_pre_key
+ WHERE account_id = $1 AND uploaded
+ "#,
+ self.account_id,
+ )
+ .fetch_one(&self.pool)
+ .await
+ .map_err(WhatsAppStoreError::from)?;
+ Ok(usize::try_from(count).map_err(|_| WhatsAppStoreError::Malformed)?)
+ }
+}
+
+#[async_trait]
+impl SenderKeyStore for PgWhatsAppStore {
+ async fn put_sender_key(
+ &self,
+ group: &str,
+ user: &str,
+ session: Vec<u8>,
+ ) -> Result<(), StoreError> {
+ // Sender first, so a user's sender keys share a key prefix.
+ let key = composite_key(&[user, group])?;
+ Ok(self.put_one(StoreName::SenderKey, key, session).await?)
+ }
+
+ async fn get_sender_key(&self, group: &str, user: &str) -> Result<Option<Vec<u8>>, StoreError> {
+ let key = composite_key(&[user, group])?;
+ Ok(self
+ .get_value(&self.pool, StoreName::SenderKey, &key)
+ .await?)
+ }
+}
diff --git a/crates/whatsapp_store_pg/src/store/signal/test.rs b/crates/whatsapp_store_pg/src/store/signal/test.rs
new file mode 100644
index 0000000000..bee366bb06
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/signal/test.rs
@@ -0,0 +1,258 @@
+use std::collections::HashMap;
+
+use macro_db_migrator::MACRO_DB_MIGRATIONS;
+use sqlx::{Pool, Postgres};
+use whatsmeow::store::{IdentityStore, PreKeyStore, SenderKeyStore, SessionStore, StoreError};
+use whatsmeow::types::{DEFAULT_USER_SERVER, HIDDEN_USER_SERVER, new_jid};
+use whatsmeow::util::keys::new_key_pair_from_private_key;
+
+use crate::store::test::open_new_store;
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn identities_are_trusted_on_first_use_and_deleted_by_user(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ assert!(store.is_trusted_identity("111:0", [1; 32]).await.unwrap());
+ store.put_identity("111:0", [1; 32]).await.unwrap();
+ assert!(store.is_trusted_identity("111:0", [1; 32]).await.unwrap());
+ assert!(!store.is_trusted_identity("111:0", [2; 32]).await.unwrap());
+
+ store.put_identity("111:3", [3; 32]).await.unwrap();
+ store.put_identity("1112:0", [4; 32]).await.unwrap();
+ // `_` is a LIKE wildcard: "111_1:0" must not match the prefix "1111:".
+ store.put_identity("111_1:0", [5; 32]).await.unwrap();
+ store.put_identity("1111:0", [6; 32]).await.unwrap();
+ store.delete_all_identities("111").await.unwrap();
+ store.delete_all_identities("111_1").await.unwrap();
+ assert!(store.is_trusted_identity("111:0", [9; 32]).await.unwrap());
+ assert!(store.is_trusted_identity("111:3", [9; 32]).await.unwrap());
+ assert!(store.is_trusted_identity("111_1:0", [9; 32]).await.unwrap());
+ assert!(!store.is_trusted_identity("1112:0", [9; 32]).await.unwrap());
+ assert!(!store.is_trusted_identity("1111:0", [9; 32]).await.unwrap());
+
+ store.delete_identity("1112:0").await.unwrap();
+ assert!(store.is_trusted_identity("1112:0", [9; 32]).await.unwrap());
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn sessions_round_trip_singly_and_in_batches(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ assert_eq!(store.get_session("111:0").await.unwrap(), None);
+ assert!(!store.has_session("111:0").await.unwrap());
+
+ store.put_session("111:0", b"one".to_vec()).await.unwrap();
+ assert!(store.has_session("111:0").await.unwrap());
+ store
+ .put_session("111:0", b"one again".to_vec())
+ .await
+ .unwrap();
+ assert_eq!(
+ store.get_session("111:0").await.unwrap(),
+ Some(b"one again".to_vec())
+ );
+
+ store
+ .put_many_sessions(HashMap::from([
+ ("111:1".to_owned(), b"two".to_vec()),
+ ("222:0".to_owned(), b"three".to_vec()),
+ ]))
+ .await
+ .unwrap();
+ let many = store
+ .get_many_sessions(&["111:0".to_owned(), "111:1".to_owned(), "333:0".to_owned()])
+ .await
+ .unwrap();
+ assert_eq!(
+ many,
+ HashMap::from([
+ ("111:0".to_owned(), Some(b"one again".to_vec())),
+ ("111:1".to_owned(), Some(b"two".to_vec())),
+ ("333:0".to_owned(), None),
+ ])
+ );
+ assert_eq!(store.get_many_sessions(&[]).await.unwrap(), HashMap::new());
+
+ store.delete_all_sessions("111").await.unwrap();
+ assert_eq!(store.get_session("111:0").await.unwrap(), None);
+ assert_eq!(store.get_session("111:1").await.unwrap(), None);
+ assert_eq!(
+ store.get_session("222:0").await.unwrap(),
+ Some(b"three".to_vec())
+ );
+ store.delete_session("222:0").await.unwrap();
+ assert!(!store.has_session("222:0").await.unwrap());
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn migrate_pn_to_lid_moves_sessions_identities_and_sender_keys(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let pn = new_jid("1234567890", DEFAULT_USER_SERVER);
+ let lid = new_jid("98765432101234", HIDDEN_USER_SERVER);
+ store
+ .put_session("1234567890:0", b"main".to_vec())
+ .await
+ .unwrap();
+ store
+ .put_session("1234567890:5", b"companion".to_vec())
+ .await
+ .unwrap();
+ store
+ .put_session("98765432101234_1:0", b"stale lid".to_vec())
+ .await
+ .unwrap();
+ store.put_identity("1234567890:0", [1; 32]).await.unwrap();
+ store
+ .put_sender_key("[email protected]", "1234567890:0", b"sender".to_vec())
+ .await
+ .unwrap();
+ store
+ .put_session("12345678901:0", b"someone else".to_vec())
+ .await
+ .unwrap();
+
+ store.migrate_pn_to_lid(&pn, &lid).await.unwrap();
+
+ assert_eq!(store.get_session("1234567890:0").await.unwrap(), None);
+ assert_eq!(store.get_session("1234567890:5").await.unwrap(), None);
+ assert_eq!(
+ store.get_session("98765432101234_1:0").await.unwrap(),
+ Some(b"main".to_vec())
+ );
+ assert_eq!(
+ store.get_session("98765432101234_1:5").await.unwrap(),
+ Some(b"companion".to_vec())
+ );
+ assert!(
+ store
+ .is_trusted_identity("1234567890:0", [9; 32])
+ .await
+ .unwrap()
+ );
+ assert!(
+ !store
+ .is_trusted_identity("98765432101234_1:0", [9; 32])
+ .await
+ .unwrap()
+ );
+ assert_eq!(
+ store
+ .get_sender_key("[email protected]", "98765432101234_1:0")
+ .await
+ .unwrap(),
+ Some(b"sender".to_vec())
+ );
+ assert_eq!(
+ store
+ .get_sender_key("[email protected]", "1234567890:0")
+ .await
+ .unwrap(),
+ None
+ );
+ assert_eq!(
+ store.get_session("12345678901:0").await.unwrap(),
+ Some(b"someone else".to_vec())
+ );
+
+ // Migrated once per process: a session stored under the phone number
+ // afterwards stays where it is.
+ store
+ .put_session("1234567890:0", b"new".to_vec())
+ .await
+ .unwrap();
+ store.migrate_pn_to_lid(&pn, &lid).await.unwrap();
+ assert_eq!(
+ store.get_session("1234567890:0").await.unwrap(),
+ Some(b"new".to_vec())
+ );
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn pre_keys_are_numbered_from_one_and_marked_uploaded(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let first_batch = store.get_or_gen_pre_keys(3).await.unwrap();
+ assert_eq!(
+ first_batch.iter().map(|key| key.key_id).collect::<Vec<_>>(),
+ vec![1, 2, 3]
+ );
+ for key in &first_batch {
+ assert_eq!(
+ key.key_pair,
+ new_key_pair_from_private_key(key.key_pair.private)
+ );
+ assert_eq!(key.signature, None);
+ }
+ // Not uploaded yet, so the same keys come back.
+ let again = store.get_or_gen_pre_keys(2).await.unwrap();
+ assert_eq!(again, first_batch[..2]);
+
+ store.mark_pre_keys_as_uploaded(2).await.unwrap();
+ assert_eq!(store.uploaded_pre_key_count().await.unwrap(), 2);
+ let next_batch = store.get_or_gen_pre_keys(2).await.unwrap();
+ assert_eq!(
+ next_batch.iter().map(|key| key.key_id).collect::<Vec<_>>(),
+ vec![3, 4]
+ );
+ assert_eq!(next_batch[0], first_batch[2]);
+ assert_eq!(store.gen_one_pre_key().await.unwrap().key_id, 5);
+ assert_eq!(store.uploaded_pre_key_count().await.unwrap(), 3);
+
+ store.remove_pre_key(1).await.unwrap();
+ assert_eq!(store.get_pre_key(1).await.unwrap(), None);
+ assert_eq!(
+ store.get_pre_key(2).await.unwrap(),
+ Some(first_batch[1].clone())
+ );
+ // IDs keep counting up after removals.
+ store.remove_pre_key(5).await.unwrap();
+ assert_eq!(store.gen_one_pre_key().await.unwrap().key_id, 5);
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn a_large_pre_key_batch_is_generated_and_uploaded_at_once(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let keys = store.get_or_gen_pre_keys(5000).await.unwrap();
+ assert_eq!(
+ keys.iter().map(|key| key.key_id).collect::<Vec<_>>(),
+ (1..=5000).collect::<Vec<_>>()
+ );
+ assert_eq!(store.get_or_gen_pre_keys(5000).await.unwrap(), keys);
+
+ store.mark_pre_keys_as_uploaded(5000).await.unwrap();
+ assert_eq!(store.uploaded_pre_key_count().await.unwrap(), 5000);
+ assert_eq!(
+ store.get_pre_key(4321).await.unwrap(),
+ Some(keys[4320].clone())
+ );
+ assert_eq!(store.get_or_gen_pre_keys(1).await.unwrap()[0].key_id, 5001);
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn sender_keys_are_per_group_and_sender(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ store
+ .put_sender_key("[email protected]", "111:0", b"first".to_vec())
+ .await
+ .unwrap();
+ store
+ .put_sender_key("[email protected]", "111:0", b"second".to_vec())
+ .await
+ .unwrap();
+ store
+ .put_sender_key("[email protected]", "111:0", b"first again".to_vec())
+ .await
+ .unwrap();
+ assert_eq!(
+ store.get_sender_key("[email protected]", "111:0").await.unwrap(),
+ Some(b"first again".to_vec())
+ );
+ assert_eq!(
+ store.get_sender_key("[email protected]", "111:0").await.unwrap(),
+ Some(b"second".to_vec())
+ );
+ assert_eq!(store.get_sender_key("[email protected]", "222:0").await.unwrap(), None);
+
+ let error = store
+ .put_sender_key("[email protected]", "111|0", b"ambiguous".to_vec())
+ .await
+ .unwrap_err();
+ assert!(matches!(error, StoreError::InvalidArgument(_)), "{error:?}");
+}
diff --git a/crates/whatsapp_store_pg/src/store/test.rs b/crates/whatsapp_store_pg/src/store/test.rs
new file mode 100644
index 0000000000..27fa59e217
--- /dev/null
+++ b/crates/whatsapp_store_pg/src/store/test.rs
@@ -0,0 +1,628 @@
+//! Opening, encryption at rest, fencing and concurrency, against a real
+//! Postgres. The fixtures here are shared with the per-store tests.
+
+use std::sync::Arc;
+
+use macro_db_migrator::MACRO_DB_MIGRATIONS;
+use sqlx::{Pool, Postgres};
+use uuid::Uuid;
+use whatsmeow::signal::CurveSignatures;
+use whatsmeow::store::{IdentityStore, PreKeyStore, SessionStore};
+
+use super::PgWhatsAppStore;
+use crate::error::{WhatsAppStoreError, is_fenced};
+use crate::kms::FakeWhatsAppKms;
+
+pub(crate) const KMS_KEY_ID: &str = "arn:aws:kms:us-east-1:123456789012:key/whatsapp-test";
+
+/// Signatures are only used to sign a new device's prekey here.
+pub(crate) struct FixedSignatures;
+
+impl CurveSignatures for FixedSignatures {
+ fn calculate_signature(&self, _private_key: &[u8; 32], _message: &[u8]) -> [u8; 64] {
+ [7; 64]
+ }
+
+ fn verify_signature(
+ &self,
+ _public_key: &[u8; 32],
+ _message: &[u8],
+ _signature: &[u8; 64],
+ ) -> bool {
+ true
+ }
+}
+
+/// A Macro user: a `macro_user` identity and the `"User"` profile the
+/// account references.
+pub(crate) async fn insert_user(pool: &Pool<Postgres>, user_id: &str) {
+ let email = format!("{user_id}@example.com");
+ sqlx::query!(
+ r#"
+ WITH new_macro_user AS (
+ INSERT INTO macro_user (id, username, email, stripe_customer_id)
+ VALUES (gen_random_uuid(), $2, $2, $3)
+ RETURNING id
+ )
+ INSERT INTO "User" ("id", "email", "macro_user_id")
+ SELECT $1, $2, new_macro_user.id FROM new_macro_user
+ "#,
+ user_id,
+ email,
+ format!("stripe_{user_id}"),
+ )
+ .execute(pool)
+ .await
+ .expect("the user is new");
+}
+
+/// A Macro user and a linked account of theirs, at lease epoch 0.
+pub(crate) async fn insert_account(pool: &Pool<Postgres>, user_id: &str) -> Uuid {
+ insert_user(pool, user_id).await;
+ let account_id = Uuid::now_v7();
+ sqlx::query!(
+ r#"
+ INSERT INTO whatsapp_linked_account (id, user_id, state)
+ VALUES ($1, $2, 'pairing')
+ "#,
+ account_id,
+ user_id,
+ )
+ .execute(pool)
+ .await
+ .expect("the account is new");
+ account_id
+}
+
+/// A store of a new account, at lease epoch 0.
+pub(crate) async fn open_new_store(pool: &Pool<Postgres>) -> Arc<PgWhatsAppStore> {
+ let account_id = insert_account(pool, "macro|whatsapp-store-owner").await;
+ let kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+ Arc::new(
+ PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms)
+ .await
+ .expect("the account is new"),
+ )
+}
+
+async fn set_lease_epoch(pool: &Pool<Postgres>, account_id: Uuid, lease_epoch: i64) {
+ sqlx::query!(
+ "UPDATE whatsapp_linked_account SET lease_epoch = $2 WHERE id = $1",
+ account_id,
+ lease_epoch,
+ )
+ .execute(pool)
+ .await
+ .expect("the account exists");
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn the_data_key_is_generated_once_and_unwrapped_on_every_later_open(pool: Pool<Postgres>) {
+ let account_id = insert_account(&pool, "macro|data-key").await;
+ let kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+
+ let first = PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms)
+ .await
+ .unwrap();
+ first
+ .put_session("111:0", b"session".to_vec())
+ .await
+ .unwrap();
+ assert_eq!((kms.generate_calls(), kms.decrypt_calls()), (1, 0));
+
+ let second = PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms)
+ .await
+ .unwrap();
+ assert_eq!((kms.generate_calls(), kms.decrypt_calls()), (1, 1));
+ assert_eq!(
+ second.get_session("111:0").await.unwrap(),
+ Some(b"session".to_vec())
+ );
+ // Reads and writes never call KMS again.
+ second
+ .put_session("222:0", b"other".to_vec())
+ .await
+ .unwrap();
+ assert_eq!((kms.generate_calls(), kms.decrypt_calls()), (1, 1));
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn concurrent_first_opens_agree_on_one_data_key(pool: Pool<Postgres>) {
+ let account_id = insert_account(&pool, "macro|first-opens").await;
+ let kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+
+ let (first, second) = tokio::join!(
+ PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms),
+ PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms),
+ );
+ let (first, second) = (first.unwrap(), second.unwrap());
+
+ first
+ .put_session("111:0", b"from first".to_vec())
+ .await
+ .unwrap();
+ second
+ .put_session("222:0", b"from second".to_vec())
+ .await
+ .unwrap();
+ assert_eq!(
+ second.get_session("111:0").await.unwrap(),
+ Some(b"from first".to_vec())
+ );
+ assert_eq!(
+ first.get_session("222:0").await.unwrap(),
+ Some(b"from second".to_vec())
+ );
+ let devices = sqlx::query_scalar!(
+ r#"SELECT COUNT(*) AS "count!" FROM whatsapp_device WHERE account_id = $1"#,
+ account_id,
+ )
+ .fetch_one(&pool)
+ .await
+ .unwrap();
+ assert_eq!(devices, 1);
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn values_are_stored_as_ciphertext(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ let session = b"a very recognizable session record".to_vec();
+ store.put_session("111:0", session.clone()).await.unwrap();
+
+ let stored = sqlx::query!(
+ r#"
+ SELECT nonce, value
+ FROM whatsapp_store_value
+ WHERE account_id = $1 AND store = 'session' AND key = '111:0'
+ "#,
+ store.account_id(),
+ )
+ .fetch_one(&pool)
+ .await
+ .unwrap();
+ assert_eq!(stored.nonce.len(), 12);
+ // Ciphertext plus the 16-byte tag.
+ assert_eq!(stored.value.len(), session.len() + 16);
+ assert!(
+ !stored
+ .value
+ .windows(8)
+ .any(|window| session.windows(8).any(|plain| plain == window)),
+ "no run of the plaintext appears in the stored value"
+ );
+
+ // A fresh nonce per write: writing the same value again changes both.
+ store.put_session("111:0", session.clone()).await.unwrap();
+ let rewritten = sqlx::query!(
+ r#"
+ SELECT nonce, value
+ FROM whatsapp_store_value
+ WHERE account_id = $1 AND store = 'session' AND key = '111:0'
+ "#,
+ store.account_id(),
+ )
+ .fetch_one(&pool)
+ .await
+ .unwrap();
+ assert_ne!(rewritten.nonce, stored.nonce);
+ assert_ne!(rewritten.value, stored.value);
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn a_value_moved_to_another_key_does_not_decrypt(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ store.put_session("111:0", b"alice".to_vec()).await.unwrap();
+ store.put_session("222:0", b"bob".to_vec()).await.unwrap();
+
+ sqlx::query!(
+ r#"
+ UPDATE whatsapp_store_value AS target
+ SET nonce = source.nonce, value = source.value
+ FROM whatsapp_store_value AS source
+ WHERE target.account_id = $1 AND target.store = 'session' AND target.key = '222:0'
+ AND source.account_id = $1 AND source.store = 'session' AND source.key = '111:0'
+ "#,
+ store.account_id(),
+ )
+ .execute(&pool)
+ .await
+ .unwrap();
+
+ let error = store.get_session("222:0").await.unwrap_err();
+ let whatsmeow::store::StoreError::Internal(report) = &error else {
+ panic!("unexpected error: {error:?}");
+ };
+ assert!(
+ matches!(
+ report.downcast_current_context::<WhatsAppStoreError>(),
+ Some(WhatsAppStoreError::Decrypt)
+ ),
+ "unexpected error: {error:?}"
+ );
+ assert_eq!(
+ store.get_session("111:0").await.unwrap(),
+ Some(b"alice".to_vec())
+ );
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn a_value_moved_to_another_store_does_not_decrypt(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ store.put_identity("111:0", [9; 32]).await.unwrap();
+
+ sqlx::query!(
+ r#"
+ INSERT INTO whatsapp_store_value (account_id, store, key, nonce, value)
+ SELECT account_id, 'session', key, nonce, value
+ FROM whatsapp_store_value
+ WHERE account_id = $1 AND store = 'identity' AND key = '111:0'
+ "#,
+ store.account_id(),
+ )
+ .execute(&pool)
+ .await
+ .unwrap();
+
+ assert!(store.get_session("111:0").await.is_err());
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn a_value_moved_to_another_account_does_not_decrypt(pool: Pool<Postgres>) {
+ let kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+ let alice_account = insert_account(&pool, "macro|alice").await;
+ let bob_account = insert_account(&pool, "macro|bob").await;
+ let alice = PgWhatsAppStore::open(pool.clone(), alice_account, 0, &kms)
+ .await
+ .unwrap();
+ let bob = PgWhatsAppStore::open(pool.clone(), bob_account, 0, &kms)
+ .await
+ .unwrap();
+ alice
+ .put_session("111:0", b"alice's".to_vec())
+ .await
+ .unwrap();
+
+ sqlx::query!(
+ r#"
+ INSERT INTO whatsapp_store_value (account_id, store, key, nonce, value)
+ SELECT $2, store, key, nonce, value
+ FROM whatsapp_store_value
+ WHERE account_id = $1 AND store = 'session' AND key = '111:0'
+ "#,
+ alice_account,
+ bob_account,
+ )
+ .execute(&pool)
+ .await
+ .unwrap();
+
+ assert!(bob.get_session("111:0").await.is_err());
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn a_data_key_moved_to_another_account_does_not_unwrap(pool: Pool<Postgres>) {
+ let kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+ let alice_account = insert_account(&pool, "macro|alice").await;
+ let bob_account = insert_account(&pool, "macro|bob").await;
+ PgWhatsAppStore::open(pool.clone(), alice_account, 0, &kms)
+ .await
+ .unwrap();
+ PgWhatsAppStore::open(pool.clone(), bob_account, 0, &kms)
+ .await
+ .unwrap();
+
+ sqlx::query!(
+ r#"
+ UPDATE whatsapp_device AS bob
+ SET data_key_ciphertext = alice.data_key_ciphertext
+ FROM whatsapp_device AS alice
+ WHERE bob.account_id = $2 AND alice.account_id = $1
+ "#,
+ alice_account,
+ bob_account,
+ )
+ .execute(&pool)
+ .await
+ .unwrap();
+
+ let error = PgWhatsAppStore::open(pool.clone(), bob_account, 0, &kms)
+ .await
+ .unwrap_err();
+ assert!(matches!(error, WhatsAppStoreError::Kms(_)), "{error:?}");
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn a_data_key_does_not_unwrap_for_another_owner_or_kms_key(pool: Pool<Postgres>) {
+ let kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+ let account_id = insert_account(&pool, "macro|owner").await;
+ PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms)
+ .await
+ .unwrap();
+
+ // Another KMS key (or another key altogether) refuses the wrapped key.
+ let other_kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+ let error = PgWhatsAppStore::open(pool.clone(), account_id, 0, &other_kms)
+ .await
+ .unwrap_err();
+ assert!(matches!(error, WhatsAppStoreError::Kms(_)), "{error:?}");
+
+ // The account handed to another user: the context no longer matches.
+ insert_user(&pool, "macro|new-owner").await;
+ sqlx::query!(
+ "UPDATE whatsapp_linked_account SET user_id = 'macro|new-owner' WHERE id = $1",
+ account_id,
+ )
+ .execute(&pool)
+ .await
+ .unwrap();
+ let error = PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms)
+ .await
+ .unwrap_err();
+ assert!(matches!(error, WhatsAppStoreError::Kms(_)), "{error:?}");
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn an_unknown_encryption_version_is_refused_before_calling_kms(pool: Pool<Postgres>) {
+ let kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+ let account_id = insert_account(&pool, "macro|version").await;
+ PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms)
+ .await
+ .unwrap();
+ sqlx::query!(
+ "UPDATE whatsapp_device SET encryption_version = 2 WHERE account_id = $1",
+ account_id,
+ )
+ .execute(&pool)
+ .await
+ .unwrap();
+
+ let error = PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms)
+ .await
+ .unwrap_err();
+ assert!(
+ matches!(error, WhatsAppStoreError::UnsupportedVersion(2)),
+ "{error:?}"
+ );
+ assert_eq!(kms.decrypt_calls(), 0);
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn opening_a_missing_account_fails(pool: Pool<Postgres>) {
+ let kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+ let error = PgWhatsAppStore::open(pool.clone(), Uuid::now_v7(), 0, &kms)
+ .await
+ .unwrap_err();
+ assert!(
+ matches!(error, WhatsAppStoreError::AccountNotFound),
+ "{error:?}"
+ );
+ assert_eq!(kms.generate_calls(), 0);
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn a_takeover_fences_out_the_previous_holder(pool: Pool<Postgres>) {
+ let kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+ let account_id = insert_account(&pool, "macro|fencing").await;
+ let previous = PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms)
+ .await
+ .unwrap();
+ previous
+ .put_session("111:0", b"before".to_vec())
+ .await
+ .unwrap();
+
+ set_lease_epoch(&pool, account_id, 1).await;
+
+ let error = previous
+ .put_session("111:0", b"stale".to_vec())
+ .await
+ .unwrap_err();
+ assert!(is_fenced(&error), "{error:?}");
+ let error = previous.get_or_gen_pre_keys(5).await.unwrap_err();
+ assert!(is_fenced(&error), "{error:?}");
+ assert_eq!(
+ sqlx::query_scalar!(
+ r#"SELECT COUNT(*) AS "count!" FROM whatsapp_pre_key WHERE account_id = $1"#,
+ account_id,
+ )
+ .fetch_one(&pool)
+ .await
+ .unwrap(),
+ 0
+ );
+
+ let error = PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms)
+ .await
+ .unwrap_err();
+ assert!(matches!(error, WhatsAppStoreError::Fenced), "{error:?}");
+
+ let next = PgWhatsAppStore::open(pool.clone(), account_id, 1, &kms)
+ .await
+ .unwrap();
+ assert_eq!(
+ next.get_session("111:0").await.unwrap(),
+ Some(b"before".to_vec())
+ );
+ next.put_session("111:0", b"after".to_vec()).await.unwrap();
+ assert_eq!(
+ previous.get_session("111:0").await.unwrap(),
+ Some(b"after".to_vec()),
+ "reads are not fenced"
+ );
+}
+
+/// The epoch bump of a takeover waits for an in-flight write of the previous
+/// holder, so the write either lands before the takeover or not at all.
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn a_takeover_waits_for_an_in_flight_write(pool: Pool<Postgres>) {
+ let kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+ let account_id = insert_account(&pool, "macro|in-flight").await;
+ let previous = PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms)
+ .await
+ .unwrap();
+
+ let mut in_flight = previous.begin_write().await.unwrap();
+ // While the write is open, the takeover's epoch bump cannot take the row.
+ let mut takeover = pool.acquire().await.unwrap();
+ sqlx::query!("SET lock_timeout = '200ms'")
+ .execute(&mut *takeover)
+ .await
+ .unwrap();
+ let blocked = sqlx::query!(
+ "UPDATE whatsapp_linked_account SET lease_epoch = 1 WHERE id = $1",
+ account_id,
+ )
+ .execute(&mut *takeover)
+ .await
+ .unwrap_err();
+ assert!(
+ blocked.to_string().contains("lock timeout"),
+ "the bump waited on the write: {blocked}"
+ );
+ previous
+ .put_values(
+ &mut in_flight,
+ crate::cipher::StoreName::Session,
+ std::collections::BTreeMap::from([("111:0".to_owned(), b"landed".to_vec())]),
+ )
+ .await
+ .unwrap();
+ in_flight.commit().await.unwrap();
+ sqlx::query!(
+ "UPDATE whatsapp_linked_account SET lease_epoch = 1 WHERE id = $1",
+ account_id,
+ )
+ .execute(&mut *takeover)
+ .await
+ .unwrap();
+
+ assert_eq!(
+ previous.get_session("111:0").await.unwrap(),
+ Some(b"landed".to_vec())
+ );
+ assert!(is_fenced(
+ &previous
+ .put_session("111:0", b"late".to_vec())
+ .await
+ .unwrap_err()
+ ));
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn concurrent_writers_do_not_lose_writes_or_reuse_prekey_ids(pool: Pool<Postgres>) {
+ let kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+ let account_id = insert_account(&pool, "macro|concurrent").await;
+ let first = Arc::new(
+ PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms)
+ .await
+ .unwrap(),
+ );
+ let second = Arc::new(
+ PgWhatsAppStore::open(pool.clone(), account_id, 0, &kms)
+ .await
+ .unwrap(),
+ );
+
+ let sessions = (0..40u8).map(|index| {
+ let store = if index % 2 == 0 {
+ first.clone()
+ } else {
+ second.clone()
+ };
+ async move { store.put_session(&format!("{index}:0"), vec![index]).await }
+ });
+ futures::future::try_join_all(sessions).await.unwrap();
+
+ let upload_rounds = |store: &Arc<PgWhatsAppStore>| {
+ let store = store.clone();
+ async move {
+ for _ in 0..5 {
+ let keys = store.get_or_gen_pre_keys(10).await?;
+ let last = keys.last().map_or(0, |key| key.key_id);
+ store.mark_pre_keys_as_uploaded(last).await?;
+ }
+ Ok::<_, whatsmeow::store::StoreError>(())
+ }
+ };
+ let (first_rounds, second_rounds) = tokio::join!(upload_rounds(&first), upload_rounds(&second));
+ first_rounds.unwrap();
+ second_rounds.unwrap();
+
+ let all: Vec<String> = (0..40).map(|index| format!("{index}:0")).collect();
+ let stored = first.get_many_sessions(&all).await.unwrap();
+ for index in 0..40u8 {
+ assert_eq!(stored[&format!("{index}:0")], Some(vec![index]));
+ }
+ // Numbering was serialized: IDs are 1..=n with no gap or duplicate.
+ let ids = sqlx::query_scalar!(
+ "SELECT key_id FROM whatsapp_pre_key WHERE account_id = $1 ORDER BY key_id",
+ account_id,
+ )
+ .fetch_all(&pool)
+ .await
+ .unwrap();
+ assert!(ids.len() >= 50, "every round had keys to upload");
+ assert_eq!(ids, (1..=ids.len() as i64).collect::<Vec<_>>());
+ assert_eq!(first.uploaded_pre_key_count().await.unwrap(), ids.len());
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn sealed_blobs_open_only_for_their_account_and_purpose(pool: Pool<Postgres>) {
+ let kms = FakeWhatsAppKms::new(KMS_KEY_ID);
+ let alice_account = insert_account(&pool, "macro|alice").await;
+ let bob_account = insert_account(&pool, "macro|bob").await;
+ let alice = PgWhatsAppStore::open(pool.clone(), alice_account, 0, &kms)
+ .await
+ .unwrap();
+ let bob = PgWhatsAppStore::open(pool.clone(), bob_account, 0, &kms)
+ .await
+ .unwrap();
+
+ let sealed = alice.seal("media-locator", b"https://mmg/locator").unwrap();
+ assert_eq!(sealed[0], 1);
+ assert_eq!(sealed.len(), 1 + 12 + 19 + 16);
+ assert_eq!(
+ *alice.unseal("media-locator", &sealed).unwrap(),
+ b"https://mmg/locator".to_vec()
+ );
+ assert_ne!(
+ alice.seal("media-locator", b"https://mmg/locator").unwrap(),
+ sealed
+ );
+
+ assert!(matches!(
+ alice.unseal("other-purpose", &sealed),
+ Err(WhatsAppStoreError::Decrypt)
+ ));
+ assert!(matches!(
+ bob.unseal("media-locator", &sealed),
+ Err(WhatsAppStoreError::Decrypt)
+ ));
+ for tampered_at in [0, 5, sealed.len() - 1] {
+ let mut tampered = sealed.clone();
+ tampered[tampered_at] ^= 1;
+ assert!(alice.unseal("media-locator", &tampered).is_err());
+ }
+ assert!(alice.unseal("media-locator", &sealed[..10]).is_err());
+ assert!(alice.unseal("media-locator", &[]).is_err());
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn a_sealed_blob_is_not_a_store_value(pool: Pool<Postgres>) {
+ let store = open_new_store(&pool).await;
+ // A blob sealed for purpose "111:0" can't be planted as the session "111:0".
+ let sealed = store.seal("111:0", b"planted").unwrap();
+ sqlx::query!(
+ r#"
+ INSERT INTO whatsapp_store_value (account_id, store, key, nonce, value)
+ VALUES ($1, 'session', '111:0', $2, $3)
+ "#,
+ store.account_id(),
+ &sealed[1..13],
+ &sealed[13..],
+ )
+ .execute(&pool)
+ .await
+ .unwrap();
+ assert!(store.get_session("111:0").await.is_err());
+}