Этап 6: закалка — лимиты ADR-021, аудит модели угроз, сверка документов

Лимиты: все четыре правила ADR-021 — регистрация 5/час на IP, вход 10/10 мин
на IP и ник, сообщения 30/мин, прочие изменяющие 60/мин; 429 с Retry-After;
X-Real-IP читается только с loopback, иначе адрес соединения — иначе заголовок
отменял бы лимит на IP; карты вёдер ограничены поколениями.

Аудит нашёл то, что пропустили пять раундов ревью:
ADR-056: nginx вёл access_log с IP и полными путями вопреки обещанию deploy.md.
Ники и социальный граф ложились в /var/log/nginx рядом с чистым журналом bare.
ADR-058: «выйти на других устройствах» не обрывал уже открытый SSE — отозванная
сессия продолжала получать сообщения.
ADR-059: промежуточный ключ комнаты был невосстановим. Участник, пропустивший
офлайн два rekey подряд, навсегда не расшифровал бы сообщения среднего ключа —
вопреки обещанию storage.md о повторной попытке после получения keyId.
ADR-063: ACK уходил по одному на конверт, а не пачкой. Получатель в оживлённой
комнате выедал общее ведро подтверждениями и упирался в 429 на всех изменяющих
запросах, включая выход из комнаты: 116 отказов за прогон стало нулём.
ADR-055, 057, 060, 061, 062: ключи вёдер и границы, +dirty у bare version,
403 unknown_device не хоронит сообщение, усечение имени в подсказке ввода,
kdf как оракул после повышения цели KDF.

Модель угроз пополнена тем, что действительно видит оператор: push-подписки
лежат в базе открытым текстом, и вместе с VAPID-ключом с той же машины это
произвольное уведомление на экране блокировки.

README приведён к v1.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015DbCjVfTFq4ZFG8juD45YJ

internal/store/rooms.go

@@ -49,16 +49,18 @@ type WrappedKey struct {
 	CT string
 }
 
-// Room — комната и её состав. Key — текущий ключ того, кто спрашивает;
-// nil означает, что ключа у него нет. NeedsRekey — состав уменьшился,
-// а нового ключа ещё не было (ADR-041).
+// Room — комната и её состав. Keys — завёрнутые ключи того, кто
+// спрашивает, от старого к новому: сервер держит два последних keyId
+// (ADR-018) и отдаёт участнику все, иначе пропущенный в офлайне ключ
+// не добыть ничем (ADR-059). Пусто — ключей у него нет. NeedsRekey —
+// состав уменьшился, а нового ключа ещё не было (ADR-041).
 type Room struct {
 	ID         string
 	Name       string
 	Owner      string
 	Members    []string // по joined_at
 	CreatedAt  int64
-	Key        *RoomKey
+	Keys       []RoomKey
 	NeedsRekey bool
 }
 
@@ -71,15 +73,17 @@ type Recipient struct {
 }
 
 // RoomChange — итог изменения комнаты: кому уходит room, а кому room_left.
-// Room.Key всегда nil — ключ у каждого получателя свой, он в Recipient.
+// Room.Keys всегда пусты — ключ у каждого получателя свой, он в Recipient.
 type RoomChange struct {
 	Room    Room
 	Members []Recipient // итоговый состав
 	Left    []Recipient // выбывшие
 }
 
-// Rooms — комнаты, где пользователь участник, каждая с его текущим
-// ключом (docs/protocol.md, «Комнаты»).
+// Rooms — комнаты, где пользователь участник, каждая со всеми его
+// завёрнутыми ключами: сервер держит два последних keyId, и участник,
+// пропустивший rekey в офлайне, добирает пропущенный отсюда
+// (ADR-059, docs/protocol.md, «Комнаты»).
 func (s *Store) Rooms(ctx context.Context, nick string) ([]Room, error) {
 	rows, err := s.db.QueryContext(ctx, `
 		SELECT r.id, r.name, r.owner, r.created_at, r.needs_rekey
@@ -130,22 +134,25 @@ func (s *Store) Rooms(ctx context.Context, nick string) ([]Room, error) {
 		return nil, fmt.Errorf("store: состав комнат: %w", err)
 	}
 
-	keys, err := s.db.QueryContext(ctx, currentKeysQuery+` AND nick = ?`, nick)
+	// Порядок — от старого ключа к новому, тот же, что у обрезки
+	// и у «текущего» (ADR-042): последний в списке и есть текущий.
+	keys, err := s.db.QueryContext(ctx, `
+		SELECT room_id, key_id, sender, iv, ct FROM room_keys
+		WHERE nick = ? AND room_id IN (SELECT room_id FROM room_members WHERE nick = ?)
+		ORDER BY room_id, created_at, key_id`, nick, nick)
 	if err != nil {
 		return nil, fmt.Errorf("store: ключи комнат: %w", err)
 	}
 	defer keys.Close()
 
 	for keys.Next() {
-		// Второй столбец — ник владельца ключа, здесь он всегда nick.
-		var room, member string
+		var room string
 		var k RoomKey
-		if err := keys.Scan(&room, &member, &k.KeyID, &k.From, &k.IV, &k.CT); err != nil {
+		if err := keys.Scan(&room, &k.KeyID, &k.From, &k.IV, &k.CT); err != nil {
 			return nil, fmt.Errorf("store: ключи комнат: %w", err)
 		}
 		if i, ok := at[room]; ok {
-			key := k
-			out[i].Key = &key
+			out[i].Keys = append(out[i].Keys, k)
 		}
 	}
 	if err := keys.Err(); err != nil {

internal/store/rooms_test.go

@@ -88,7 +88,7 @@ func TestCreateRoomTakenID(t *testing.T) {
 		t.Fatalf("Rooms: %v", err)
 	}
 	if len(rooms) != 1 || rooms[0].Name != "общая" || rooms[0].Owner != "marta" ||
-		rooms[0].Key == nil || rooms[0].Key.KeyID != "k1" {
+		current(rooms[0]) == nil || current(rooms[0]).KeyID != "k1" {
 		t.Errorf("комната после отказа: %+v", rooms)
 	}
 	if got, err := s.Rooms(ctx, "petya"); err != nil || len(got) != 0 {
@@ -96,6 +96,15 @@ func TestCreateRoomTakenID(t *testing.T) {
 	}
 }
 
+// current — текущий ключ участника: последний в Keys, они идут от старого
+// к новому (ADR-059).
+func current(r Room) *RoomKey {
+	if len(r.Keys) == 0 {
+		return nil
+	}
+	return &r.Keys[len(r.Keys)-1]
+}
+
 // У комнаты живут два последних keyId; обрезка при rekey и фоновая чистка
 // держат одни и те же ключи и не трогают текущий ключ участника (ADR-018).
 func TestRoomKeysTrimmedToTwo(t *testing.T) {
@@ -120,13 +129,31 @@ func TestRoomKeysTrimmedToTwo(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Rooms %s: %v", nick, err)
 		}
-		if len(rooms) != 1 || rooms[0].Key == nil {
+		if len(rooms) != 1 || current(rooms[0]) == nil {
 			t.Fatalf("комнаты %s: %+v", nick, rooms)
 		}
-		if rooms[0].Key.KeyID != "k3" || rooms[0].Key.CT != "ct-"+nick {
-			t.Errorf("ключ %s: %+v", nick, rooms[0].Key)
+		if current(rooms[0]).KeyID != "k3" || current(rooms[0]).CT != "ct-"+nick {
+			t.Errorf("ключ %s: %+v", nick, current(rooms[0]))
 		}
 	}
+	// Участнику отдаются оба удерживаемых ключа, от старого к новому:
+	// без прежнего он не прочитает сообщение, отправленное до последнего
+	// rekey, пока его не было (ADR-059).
+	rooms, err := s.Rooms(ctx, "petya")
+	if err != nil {
+		t.Fatalf("Rooms petya: %v", err)
+	}
+	if len(rooms) != 1 || len(rooms[0].Keys) != 2 {
+		t.Fatalf("ключи petya: %+v", rooms)
+	}
+	if rooms[0].Keys[0].KeyID != "k2" || rooms[0].Keys[1].KeyID != "k3" {
+		t.Errorf("порядок ключей: получено %v, ожидалось [k2 k3]",
+			[]string{rooms[0].Keys[0].KeyID, rooms[0].Keys[1].KeyID})
+	}
+	// Ключей чужой комнаты в ответе нет.
+	if got, err := s.Rooms(ctx, "marta"); err != nil || len(got) != 1 || len(got[0].Keys) != 2 {
+		t.Errorf("ключи marta: %+v, %v", got, err)
+	}
 }
 
 // Два rekey в одну миллисекунду: текущим остаётся последний розданный ключ,
@@ -147,11 +174,11 @@ func TestRoomKeysWithinOneMillisecond(t *testing.T) {
 	}
 	for _, nick := range []string{"marta", "petya"} {
 		rooms, err := s.Rooms(ctx, nick)
-		if err != nil || len(rooms) != 1 || rooms[0].Key == nil {
+		if err != nil || len(rooms) != 1 || current(rooms[0]) == nil {
 			t.Fatalf("комнаты %s: %+v, %v", nick, rooms, err)
 		}
-		if rooms[0].Key.KeyID != "aaa" {
-			t.Errorf("текущий ключ %s: получено %q, ожидалось \"aaa\"", nick, rooms[0].Key.KeyID)
+		if current(rooms[0]).KeyID != "aaa" {
+			t.Errorf("текущий ключ %s: получено %q, ожидалось \"aaa\"", nick, current(rooms[0]).KeyID)
 		}
 	}
 	// Свежим ключом можно писать: он остался ключом комнаты.

internal/store/store_test.go

@@ -105,11 +105,23 @@ func TestUsersAndSessions(t *testing.T) {
 		t.Errorf("истёкшая сессия: получено %v, ожидалось ErrNotFound", err)
 	}
 
-	// Смена пароля с logoutOthers: остаётся только текущая сессия.
+	// Смена пароля с logoutOthers: остаётся только текущая сессия, а
+	// устройства завершённых сессий отдаются обработчику — он закроет
+	// их потоки событий (ADR-058).
+	if _, err := s.RegisterDevice(ctx, "device-live", "marta", live, now); err != nil {
+		t.Fatalf("RegisterDevice: %v", err)
+	}
+	if _, err := s.RegisterDevice(ctx, "device-other", "marta", other, now); err != nil {
+		t.Fatalf("RegisterDevice: %v", err)
+	}
 	cred := Credential{Hash: []byte("new"), Salt: []byte("salt2"), Params: "argon2id,m=19456,t=2,p=1"}
-	if err := s.SetPassword(ctx, "marta", cred, `{"v":1,"new":true}`, true, live); err != nil {
+	revoked, err := s.SetPassword(ctx, "marta", cred, `{"v":1,"new":true}`, true, live)
+	if err != nil {
 		t.Fatalf("SetPassword: %v", err)
 	}
+	if len(revoked) != 1 || revoked[0] != "device-other" {
+		t.Errorf("устройства завершённых сессий: получено %v, ожидалось [device-other]", revoked)
+	}
 	if _, err := s.Session(ctx, other, now); !errors.Is(err, ErrNotFound) {
 		t.Errorf("чужая сессия после logoutOthers: получено %v, ожидалось ErrNotFound", err)
 	}

internal/store/users.go

@@ -80,28 +80,65 @@ func (s *Store) SetAuth(ctx context.Context, nick string, cred Credential) error
 // разъехавшиеся хеш и блоб означали бы аккаунт, в который нельзя войти
 // или ключ которого не расшифровать. При logoutOthers в той же транзакции
 // удаляются все сессии пользователя, кроме keep — текущей.
-func (s *Store) SetPassword(ctx context.Context, nick string, cred Credential, blob string, logoutOthers bool, keep []byte) error {
+//
+// Первое значение — устройства, к которым были привязаны удалённые сессии:
+// их потоки событий закрывает обработчик. Поток проверяет сессию только
+// при подключении, поэтому отозванная иначе продолжала бы получать
+// конверты до обрыва соединения (ADR-058).
+func (s *Store) SetPassword(ctx context.Context, nick string, cred Credential, blob string, logoutOthers bool, keep []byte) ([]string, error) {
 	tx, err := s.db.BeginTx(ctx, nil)
 	if err != nil {
-		return fmt.Errorf("store: смена пароля: %w", err)
+		return nil, fmt.Errorf("store: смена пароля: %w", err)
 	}
 	defer tx.Rollback()
 
 	if _, err := tx.ExecContext(ctx, `
 		UPDATE users SET auth_hash = ?, auth_salt = ?, auth_params = ?, key_blob = ? WHERE nick = ?`,
 		cred.Hash, cred.Salt, cred.Params, blob, nick); err != nil {
-		return fmt.Errorf("store: смена пароля: %w", err)
+		return nil, fmt.Errorf("store: смена пароля: %w", err)
 	}
+	var revoked []string
 	if logoutOthers {
+		revoked, err = revokedDevices(ctx, tx, nick, keep)
+		if err != nil {
+			return nil, err
+		}
 		if _, err := tx.ExecContext(ctx, `
 			DELETE FROM sessions WHERE nick = ? AND token_hash <> ?`, nick, keep); err != nil {
-			return fmt.Errorf("store: смена пароля: %w", err)
+			return nil, fmt.Errorf("store: смена пароля: %w", err)
 		}
 	}
 	if err := tx.Commit(); err != nil {
-		return fmt.Errorf("store: смена пароля: %w", err)
+		return nil, fmt.Errorf("store: смена пароля: %w", err)
 	}
-	return nil
+	return revoked, nil
+}
+
+// revokedDevices — устройства завершаемых сессий, кроме устройства текущей:
+// её оставляют, и закрывать её поток незачем.
+func revokedDevices(ctx context.Context, tx *sql.Tx, nick string, keep []byte) ([]string, error) {
+	rows, err := tx.QueryContext(ctx, `
+		SELECT DISTINCT device_id FROM sessions
+		WHERE nick = ? AND token_hash <> ? AND device_id IS NOT NULL
+		  AND device_id NOT IN (SELECT device_id FROM sessions WHERE token_hash = ? AND device_id IS NOT NULL)
+		ORDER BY device_id`, nick, keep, keep)
+	if err != nil {
+		return nil, fmt.Errorf("store: устройства завершённых сессий: %w", err)
+	}
+	defer rows.Close()
+
+	var out []string
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			return nil, fmt.Errorf("store: устройства завершённых сессий: %w", err)
+		}
+		out = append(out, id)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("store: устройства завершённых сессий: %w", err)
+	}
+	return out, nil
 }
 
 // DeleteUser удаляет пользователя; устройства, сессии, контакты, членство,