Skip to content

About

No description, website, or topics provided.

Resources

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

27 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 

Repository files navigation

direct_chat

Мессенджер с сквозным шифрованием (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 с откатом транзакции.

Сервер

REST API

Метод Путь Назначение Авторизация
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.

WebSocket (Socket.IO)

Клиент → сервер:

Событие Поля Действие
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

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() выполняет шаги в строгом порядке, и это не произвольное решение:

  1. login_offline() — расшифровка приватного ключа из локальной БД. Если пароль неверен, сеть не затрагивается вообще: попытка логина на чужом устройстве не оставляет следа на сервере.
  2. POST /api/login — получение токена.
  3. _load_all_group_keys() — загрузка и расшифровка ключей всех чатов из /api/get_chats.
  4. 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 для паролей и вывода ключей)

About

No description, website, or topics provided.

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages