Мессенджер с сквозным шифрованием (E2E) и серверным хранением сообщений в зашифрованном виде. Сервер отвечает за аутентификацию, маршрутизацию и статус присутствия, но не имеет доступа к содержимому сообщений и к ключам шифрования.
Ключевая идея: приватный ключ пользователя никогда не покидает устройство. При регистрации клиент генерирует пару Curve25519 и отправляет серверу только публичный ключ; приватный ключ сохраняется локально, зашифрованный паролем пользователя. Для группового чата создаётся один случайный симметричный ключ, который шифруется публичным ключом каждого участника отдельно. Сервер хранит только уже зашифрованные блобы и не может их прочитать.
direct-chat/
├── server/
│ ├── server.py REST API, Socket.IO-события, аутентификация, SQLite
│ ├── models.py схема БД: User, SessionModel, Chat, ChatMembership,
│ │ Message, MessageRead
│ ├── requirements.txt
│ └── db.sqlite игнорируется git
└── client/
├── client.py криптография, REST-обёртки, обработчики Socket.IO
├── models.py локальный кэш: Account, User, Chat, ChatKey,
│ Message, MessageRead, ChatMembership
├── requirements.txt
└── db.sqlite игнорируется git
┌──────────────────────────┐
пароль ────────►│ клиент: Argon2id ─► SecretBox
│ расшифровать свой X25519 │◄── локальная БД (accounts)
└──────────┬───────────────┘
│ приватный ключ (никогда не уходит с устройства)
┌────────────────────────────┼─────────────────────────────┐
│ ▼ │
│ ┌───────────────────────────────┐ │
│ создание │ group_key = os.urandom(32) │ │
│ чата: │ для каждого участника: │ │
│ │ Box(my_private, their_pub) │ │
│ │ → encrypted_group_key │ │
│ └───────┬───────────────┬────────┘ │
│ │ │ │
└────────────────────┼───────────────┼──────────────────────┘
▼ ▼
┌──────────────────────────────────────────┐
│ POST /api/create_chat (ключи + участники)│
│ сервер: сохраняет блобы, не имеет ключей │
└──────────────────────────────────────────┘
│
сообщение: ▼
plaintext ─► SecretBox(group_key) ─► base64 ─► WebSocket send_message
│
┌──────────────────────────────────────────────┐
│ сервер: пишет bytes в БД, рассылает as-is │
└──────────────────────────────────────────────┘
│
▼
клиент участника: SecretBox(group_key) ─► plaintext
Всё построено на primitives из PyNaCl (libsodium) и argon2-cffi.
Ключи пользователя. Пара Curve25519 генерируется на клиенте при регистрации (PrivateKey.generate()). Сервер получает публичный ключ (32 байта, base64) и проверяет длину; приватный ключ на сервер не отправляется и не хранится.
Шифрование приватного ключа на устройстве. Пароль не хранится нигде. Из него выводится 32-байтный ключ:
hash_secret_raw(
secret=password.encode(),
salt=salt, # os.urandom(16) при регистрации
time_cost=3,
memory_cost=64 * 1024, # 64 МиБ
parallelism=1,
hash_len=32,
type=Type.ID, # Argon2id
)Этим ключом приватный ключ шифруется SecretBox (XSalsa20-Poly1305) и кладётся в локальную таблицу accounts рядом с солью. Расшифровка происходит только в момент логина и только на устройстве.
Групповые чаты. На чат генерируется один случайный 32-байтный симметричный ключ (os.urandom(32)). Для каждого участника он шифруется отдельно через Box(my_private, their_public) — Curve25519 + XSalsa20-Poly1305. Получается N разных блобов одного и того же ключа, и расшифровать конкретный может только владелец соответствующего приватного ключа.
Сообщения. Тело шифруется симметричным ключом чата через SecretBox, результат кодируется в base64 и уходит по сети в таком виде. Сервер сохраняет content: bytes в БД без попыток интерпретации и возвращает клиенту ровно те же байты, что получил. Пароль и приватный ключ для этого не нужны — у сервера их просто нет.
| Механизм | Реализация |
|---|---|
| Хранение пароля | Argon2id через argon2.PasswordHasher, только хеш |
| Актуализация параметров | ph.check_needs_rehash() — перехеширование при устаревших параметрах Argon2 |
| Токен сессии | secrets.token_hex(32), 256 бит энтропии |
| Хранение токена | только SHA-256 дайджест в sessions.hashed_token, сырой токен в БД отсутствует |
| Срок жизни | 12 часов, скользящее окно — продлевается при каждом успешном обращении |
| Передача токена | заголовок Authorization: Bearer <token>, не query-параметр |
| WebSocket | токен в поле auth при установлении соединения, проверяется в обработчике connect |
Истекшая сессия удаляется при попытке обращения. Токен утерянного устройства можно отозвать удалением строки из sessions.
Защита от перечисления пользователей. При логине ответ для несуществующего аккаунта и для неверного пароля совпадает дословно («Неверные учётные данные»), чтобы по времени ответа или по тексту ошибки нельзя было определить, зарегистрирован ли username.
Валидация регистрации. Имя пользователя проверяется регулярным выражением ^[a-zA-Z0-9_.]{3,32}$; публичный ключ декодируется из base64 и должен быть ровно 32 байта. Конфликт уникальности перехватывается через IntegrityError с откатом транзакции.
| Метод | Путь | Назначение | Авторизация |
|---|---|---|---|
| GET | /api |
проверка доступности | нет |
| POST | /api/register |
регистрация: username, password, public_key | нет |
| POST | /api/login |
вход, возвращает токен | нет |
| GET | /api/get_user?username= |
публичные данные пользователя + статус онлайн | токен |
| POST | /api/create_chat |
создание чата с зашифрованными ключами участников | токен |
| GET | /api/get_chats |
список чатов, участники, ключ, счётчик непрочитанных | токен |
| GET | /api/get_messages?chat_name= |
непрочитанные сообщения (попутно ставит отметки о прочтении) | токен |
Единый формат ответа — {"status": "ok", ...} или {"status": "error", "error": "..."}. Отсутствие авторизации возвращает HTTP 401, недостаточные права — 403, ненайденный объект — 404.
Клиент → сервер:
| Событие | Поля | Действие |
|---|---|---|
send_message |
chat_name, content (base64) |
сохраняет сообщение, рассылает new_message всей комнате |
typing |
chat_name, is_typing |
пересылает индикатор набора остальным |
mark_read |
chat_name, message_ids[] |
сохраняет отметки, рассылает read_receipt, чистит прочитанное |
Сервер → клиент:
| Событие | Когда |
|---|---|
new_message |
новое сообщение в чате (включая отправителя — это подтверждение доставки и синхронизация нескольких устройств) |
read_receipt |
участник прочитал сообщения |
typing |
индикатор набора текста |
user_online / user_offline |
изменение присутствия |
chat_created |
текущего пользователя добавили в чат, приходит вместе с его зашифрованным ключом |
error |
ошибка обработки события |
Состояние соединений держится в двух индексах в памяти процесса:
connected_users: dict[str, int] # sid -> user_id
user_sids: dict[int, set[str]] # user_id -> {sid, ...}Второй индекс позволяет считать пользователя онлайн при активном соединении с любого числа устройств и корректно порождать событие user_offline только когда закрыто последнее соединение. Онлайн-статус в ответах REST вычисляется по наличию sid, поэтому в БД он не хранится и не расходится с реальностью; last_online обновляется как метка времени.
При подключении клиент автоматически вступает в комнату каждого своего чата (join_room), поэтому групповая рассылка работает без отдельной подписки. События, адресованные лично отправителю, исключают его соединения через skip_sid.
Сообщения удаляются с сервера, как только их прочитали все участники чата (cleanup_messages сравнивает число отметок MessageRead с числом memberships). Непрочитанная переписка остаётся доступной офлайн-клиентам, прочитанная не копится бесконечно. Функция работает в рамках одного чата, а не по всей таблице.
Счётчик непрочитанных в /api/get_chats считается через ~Message.reads.any(...) — анти-джойн, а не подсчёт в Python.
SQLite по умолчанию игнорирует внешние ключи, поэтому на уровне движка включён хук, включающий их при каждом соединении:
@event.listens_for(engine, "connect")
def enable_foreign_keys(dbapi_connection, _):
dbapi_connection.cursor().execute("PRAGMA foreign_keys=ON")Без этого объявленные в моделях ondelete="CASCADE" не срабатывают и удаление пользователя оставило бы осиротевшие записи. Идентификаторы сообщений извлекаются через session.flush() до commit(), чтобы в рассылку ушло уже настоящее id.
users ──< sessions (токен, user_id CASCADE, expires_at)
──< chat_memberships >── chats ──< messages ──< message_reads
(message_id CASCADE)
──< messages (author)
chat_memberships хранит encrypted_group_key — ключ чата, зашифрованный под конкретного участника. Уникальный составной ключ (user_id, chat_id) исключает повторное вступление. Тот же блоб приходит клиенту и в get_chats, и в событии chat_created, поэтому участнику не нужно отдельно запрашивать ключ.
login() выполняет шаги в строгом порядке, и это не произвольное решение:
login_offline()— расшифровка приватного ключа из локальной БД. Если пароль неверен, сеть не затрагивается вообще: попытка логина на чужом устройстве не оставляет следа на сервере.POST /api/login— получение токена._load_all_group_keys()— загрузка и расшифровка ключей всех чатов из/api/get_chats.connect_socket()— подключение WebSocket.
Ключи чатов расшифровываются до установки соединения намеренно: иначе первое же входящее сообщение пришло бы в обработчик, где get_group_key() ещё нечего вернуть. Ошибка расшифровки отдельного чата не прерывает вход — она логируется как предупреждение, остальные чаты работают.
_group_keys: dict[str, bytes] # chat_name -> групповой ключКэш живёт в памяти и заполняется при логине, при создании собственного чата и при получении chat_created. Приватные ключи и ключи чатов не записываются в локальную БД открытым текстом.
Клиент дублирует данные, чтобы читать их без сетевых запросов:
| Таблица | Назначение |
|---|---|
accounts |
encrypted_private_key + salt — существует только для собственных аккаунтов на этом устройстве |
users |
кэш публичных данных: свой и контактов; у контакта account = None |
chats |
name (идентификатор для API) и display_name (для показа) |
messages |
сообщения в зашифрованном виде, encrypted_content |
message_reads |
локальные отметки о прочтении |
chat_keys |
схема заведена под хранение ключей чата на диске |
chat_members |
локальный состав участников |
Публичные ключи контактов подтягиваются через save_user() и кэшируются, поэтому создание чата с известным контактом не требует сети.
Сообщения, пришедшие по WebSocket, пишутся в локальную БД с проверкой на дубликат по id — при переподключении или повторной доставке запись не удваивается.
Все входящие события после расшифровки и сохранения передаются в переопределяемые функции-обработчики:
| Функция | Событие |
|---|---|
on_message_received(chat_name, sender, plaintext, created_at) |
новое расшифрованное сообщение |
on_read_receipt_received(chat_name, reader, message_ids) |
квитанция о прочтении |
on_typing_received(chat_name, username, is_typing) |
индикатор набора |
on_presence_changed(chat_name, username, online, last_online) |
присутствие участника |
По умолчанию они печатают состояние в консоль. Интеграция с UI сводится к переопределению этих четырёх функций — сетевой и криптографический слои при этом не затрагиваются.
Требуется Python 3.11+ и libpcap-подобные зависимости не нужны. Разделы client/ и server/ держат независимые виртуальные окружения и отдельные requirements.txt (пиннинг всех транзитивных зависимостей).
Сервер:
cd server
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python server.py # http://127.0.0.1:5000, схема создаётся автоматическиКлиент:
cd client
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python client.py # создаёт локальную схему БДАдрес сервера задан константой HOST = "http://127.0.0.1:5000" в начале client/client.py. Сервер слушает только loopback — выставление в сеть требует отдельной настройки (gunicorn уже зафиксирован в зависимостях).
Сценарий проверки: зарегистрировать двух пользователей в отдельных каталогах/окружениях, создать чат одним из них, подключить второго и убедиться, что сообщения расшифровываются у обоих, а содержимое в server/db.sqlite нечитаемо без ключа.
| Решение | Причина |
|---|---|
| E2E на клиенте, а не TLS на транспорте | TLS защищает канал до сервера; здесь сервер принципиально не может прочитать содержимое, даже при полном контроле над машиной |
| Приватный ключ генерируется на клиенте | Иначе он неизбежно проходит через сервер |
| Argon2id для пароля и для ключа шифрования | Одна функция вывода ключа для обоих случаев; memory_cost создаёт реальную нагрузку на перебор |
| Хранение только SHA-256 дайджеста токена | Утечка таблицы сессий не даёт готовых токенов для использования |
| Токен в заголовке, не в URL | URL попадает в логи сервера и в историю браузера |
| Скользящий срок сессии 12 часов | Активный пользователь не разлогинивается, бездействующий теряет доступ автоматически |
| Одинаковый ответ при неверном логине | Исключает перечисление зарегистрированных username |
| Один симметричный ключ на чат | Расшифровка не требует приватного ключа отправителя и переносится на все устройства участника |
| Отдельный блоб ключа на каждого участника | Участник не может получить ключ, предназначенный другому, даже при доступе к БД |
Сервер хранит content: bytes и возвращает как есть |
Отсутствие операций над данными на сервере — условие, при котором E2E имеет смысл |
| Удаление прочитанного сообщения | Хранилище не растёт бесконечно; непрочитанное остаётся для офлайн-клиентов |
| Рассылка отправителю тоже | Подтверждение доставки и синхронизация нескольких устройств одного пользователя |
skip_sid на адресных событиях |
Не нужно отфильтровывать собственные сообщения на клиенте |
Расшифровка ключей до connect() |
Исключает гонку на первом входящем сообщении |
| Локальная расшифровка ключа до запроса токена | Неверный пароль не оставляет запросов на сервере |
| Онлайн из памяти, а не из БД | Второй индекс sid отражает текущие соединения; БД для этого не годится |
| Два индекса соединений | Поддержка нескольких устройств без потери событий при отключении одного |
PRAGMA foreign_keys=ON на каждое соединение |
Без него SQLite игнорирует CASCADE, объявленный в моделях |
flush() до commit() |
Получить id сообщения для рассылки, не разрывая транзакцию |
IntegrityError вместо предварительной проверки |
Решение о конфликте отдано БД, нет гонки между проверкой и записью |
Работает и покрыто кодом: регистрация с генерацией пары ключей, вход с двумя этапами проверки, выдача и скользящее продление токена, создание группового чата с индивидуальным шифрованием ключа каждому участнику, отправка и получение сообщений в реальном времени, отметки о прочтении с рассылкой квитанций, счётчики непрочитанных, присутствие с учётом нескольких устройств, удаление прочитанных сообщений, локальный кэш и расшифровка ключей при входе.
Ограничения, которые видно из кода:
- Расшифровка ключа чата, созданного другим участником, не работает.
_load_group_key_from_membership()расшифровывает ключ черезBox(my_private, my_public), что корректно только когда чат создал сам пользователь: сервер не возвращает публичный ключ создателя, а сохранять его нужно рядом с чатом. Это отмечено в коде как временное решение. Полноценное решение — хранитьcreator_public_keyв таблицеChatлибо отдавать его в/api/get_chatsи/api/create_chat. - Таблица
chat_keysв клиентской схеме заведена, но ключи чатов держатся только в памяти; постоянного хранения нет. - Событие
chat_createdприходит только участникам, находящимся онлайн в момент создания чата. Офлайн-участник получит чат при следующем/api/get_chats, но не уведомление. client.py— библиотечный модуль без интерфейса и без интерактивного режима:main()только создаёт схему БД, вывод идёт черезprintв обработчиках по умолчанию. Подключение к десктопному или терминальному UI — предполагаемый следующий шаг.- Состояние соединений хранится в памяти процесса, поэтому масштабирование на несколько воркеров потребует внешнего адаптера для presence и комнат Socket.IO (например, Redis) — сейчас сервер рассчитан на один процесс.
- Транспорт — открытый WebSocket Socket.IO. Прикладной протокол шифрует тело сообщения, но метаданные (имена чатов,
chat_name, время, состав участников, ip-адреса) остаются открытыми.
Python 3.11+ · Flask, Flask-SocketIO, eventlet, gunicorn (сервер) · python-socketio, requests (клиент) · SQLAlchemy 2.0 (typed Mapped/mapped_column) + SQLite · PyNaCl / libsodium (Curve25519, XSalsa20-Poly1305) · argon2-cffi (Argon2id для паролей и вывода ключей)