golang

Создал хранилище данных в одном зашифрованном файле

  • воскресенье, 28 июня 2026 г. в 00:00:15
https://habr.com/ru/articles/1052650/

В прошлой статье я рассказывал про свой пет-проект qrrot. Тогда это была in memory база данных на Go с TCP-интерфейсом и встроенным ИИ-ассистентом. Идея казалась забавной, но на практике оказалась бесполезной вещью, поэтому я просто продолжил ее ковырять и пробовать сделать из нее что-то интересное и быстрое. В процессе ковыряния в своем проекте я полностью перевернул его суть и идею, и вышло это.

Архитектурный сдвиг: уходим от In-Memory

Главная болячка прошлой версии - все данные лежали в ОЗУ. Если у вас гигабайты файлов, память закончится раньше, чем вы успеете сказать OOM. Сейчас подход изменился:

Данные строго на диске

Сами файлы (payload) лежат в одном-единственном бинарном файле базы с расширением qrr.

Индекс в памяти

В ОЗУ хранится только легкая карта map[string]entry.Entry. В ней лежат метаданные: смещение файла на диске (offset), его размер (size), MIME-тип, IV (вектор инициализации) и хэш авторизации.

type Entry struct {
	Offset   uint64
	Size     uint64
	MimeType string
	IV       []byte
	AuthHash []byte
}

Чтение на лету

Когда клиент запрашивает файл, сервер находит метаданные в индексе, открывает файл базы данных, делает io.NewSectionReader по нужному смещению и стримит клиенту дешифрованные чанки. Сами данные в память целиком не грузятся.

func (s *Store) GetReader(key string, token string) (io.ReadCloser, string, uint64, error) {
	s.mu.RLock()
	defer s.mu.RUnlock()

	ent, ok := s.data[key]
	if !ok {
		return nil, "", 0, errors.New("value not found")
	}

	expectedHash := sha256.Sum256(append([]byte(token), ent.IV...))
	if !bytes.Equal(ent.AuthHash, expectedHash[:]) {
		return nil, "", 0, errors.New("invalid token")
	}

	r := io.NewSectionReader(s.dbFile, int64(ent.Offset), int64(ent.Size))

	keyHash := sha256.Sum256([]byte(token))
	block, err := aes.NewCipher(keyHash[:])
	if err != nil {
		return nil, "", 0, err
	}
	cipherStream := cipher.NewCTR(block, ent.IV)

	streamReader := &cipher.StreamReader{S: cipherStream, R: r}

	return readCloser{streamReader}, ent.MimeType, ent.Size, nil
}

Формат файла

Файл с данными - это обычный append-only файл со следующей структурой:

┌────────────────────────────────────────┐
│          QRRT magic (4 bytes)          │ -> маркер формата файла
├────────────────────────────────────────┤
│            version (1 byte)            │ -> версия формата
├────────────────────────────────────────┤
│               records*                 │ -> массив записей
└────────────────────────────────────────┘

Каждая запись в хвосте имеет такую структуру:

┌────────────────────────────────────────┐
│            mimeLen (1 byte)            │ -> длина строки mime-типа
├────────────────────────────────────────┤
│         mime (variable length)         │ -> сам mime-тип
├────────────────────────────────────────┤
│            keyLen (1 byte)             │ -> длина ключа записи
├────────────────────────────────────────┤
│         key (variable length)          │ -> ключ
├────────────────────────────────────────┤
│             IV (16 bytes)              │ -> вектор инициализации для aes
├────────────────────────────────────────┤
│          authHash (32 bytes)           │ -> тег для проверки целостности
├────────────────────────────────────────┤
│             size (8 bytes)             │ -> размер зашифрованных данных
├────────────────────────────────────────┤
│    encrypted data (variable length)    │ -> сырые зашифрованные данные
└────────────────────────────────────────┘

Криптография на коленке

Вся прелесть новой архитектуры - это криптографическая изоляция без создания базы пользователей или ролей. Схема работы:

Шифрование

Данные шифруются алгоритмом AES-256-CTR. Ключ шифрования — это SHA-256(token), где токен присылает сам клиент при каждом запросе.

Вектор инициализации (IV)

На каждую запись генерируется 16 случайных байт (IV). Это защищает от атак на основе анализа частоты повторения блоков, даже если вы заливаете одинаковые файлы.

Авторизация без пароля

Сервер не знает вашего токена и нигде его не хранит. Вместо этого при записи он вычисляет хэш по такой формуле:

authHash=SHA-256(token∥IV)

Этот хэш пишется в заголовок записи на диск.

Проверка

Когда клиент просит файл по ключу и присылает токен, сервер берет с диска IV этой записи, считает хэш от присланного токена + IV и сравнивает его со сохраненным authHash. Если они совпали, инициализируется шифр с SHA-256(token) и дешифрует поток на лету, если не совпали - возвращается ошибка о невалидном токене.

iv := make([]byte, 16)
if _, err := rand.Read(iv); err != nil {
	return nil, err
}

keyHash := sha256.Sum256([]byte(token))
block, err := aes.NewCipher(keyHash[:])
if err != nil {
	return nil, err
}
cipherStream := cipher.NewCTR(block, iv)

h := sha256.Sum256(append([]byte(token), iv...))
authHash := h[:]

Транзакции и защита от сбоев питания

Поскольку запись идет в один файл, внезапное отключение света посреди транзакции может убить базу. Чтобы этого избежать, запись происходит в два этапа:

Запись во временный файл

Данные от клиента принимаются по gRPC чанками по 32 КБ. Они шифруются на лету и сразу пишутся во временный файл в той же директории, ОЗУ при этом не нагружается.

func (w *dbWriter) Write(p []byte) (n int, err error) {
	var buf []byte
	var poolBuf *[]byte
	if len(p) <= 64*1024 {
		poolBuf = bufferPool.Get().(*[]byte)
		buf = (*poolBuf)[:len(p)]
		defer bufferPool.Put(poolBuf)
	} else {
		buf = make([]byte, len(p))
	}

	w.cipherStream.XORKeyStream(buf, p)
	n, err = w.tempFile.Write(buf)
	w.written += int64(n)
	return n, err
}

Атомарная запись

Если запись во временный файл прошла успешно, сервер блокирует запись в основную БД, прыгает в конец файла базы данных, записывает туда заголовок записи, копирует шифрованное тело из временного файла и выполняет синхронизацию. Только после этого обновляется индекс в оперативке, а временный файл удаляется.

Все в Docker!

Теперь проект можно развернуть у себя на сервере используя всего одну команду:

docker compose up -d --build

И qrrot будет слушать соединения на порту 69045

Не все так радужно

Проект стал намного чище, но архитектурных компромиссов тут хватает:

Нет удаления данных

В коде в принципе отсутствует метод удаления записей. Это append-only лог, в котором можно только добавлять новые записи. Если вы перезапишете ключ, старая запись физически останется лежать в файле базы данных, просто мапа в памяти переключится на новое смещение. Файл базы данных будет раздуваться вечно, пока не кончится диск.

Индекс полностью в памяти

Вся карта ключей и метаданных держится в ОЗУ. Если заливать туда миллионы мелких файлов, память улетит очень быстро.

Живой пример - пишем gRPC клиент для трансляции видео с камеры

Шаг 1. Инициализация камеры

Здесь мы просто открываем видеоустройство и настраиваем захват в формате MJPEG (который на выходе дает сразу готовые JPEG-кадры, избавляя нас от необходимости кодировать картинку вручную):

cam, err := webcam.Open("/dev/video0")
if err != nil {
	log.Fatalf("Не удалось открыть камеру: %v", err)
}
defer cam.Close()

format := webcam.PixelFormat(0x47504a4d) 
_, _, _, err = cam.SetImageFormat(format, 640, 480)

_ = cam.StartStreaming()
defer cam.StopStreaming()

Шаг 2. Захват кадра в буфер

Ждем, пока сенсор камеры отдаст готовый кадр, и забираем его сырые байты прямо из буфера:

err = cam.WaitForFrame(5)
if err != nil {
	log.Fatalf("Таймаут ожидания кадра: %v", err)
}

frameBytes, err := cam.ReadFrame()
if err != nil || len(frameBytes) == 0 {
	log.Fatalf("Ошибка чтения кадра")
}

Шаг 3. Стриминг в gRPC-канал qrrot

Самый интересный этап. Мы открываем двусторонний стрим Put, сначала отправляем метаданные (чтобы сервер понимал, под каким именем и с каким MIME-типом сохранить файл), а затем нарезаем кадр на чанки и льем их в поток, чтобы не забивать ОЗУ:

stream, err := client.Put(ctx)

err = stream.Send(&qrrotv1.PutRequest{
	Data: &qrrotv1.PutRequest_Metadata{
		Metadata: &qrrotv1.Metadata{
			Key:      "snapshot.jpg",
			MimeType: "image/jpeg",
		},
	},
	Token: "какойта токен",
})

const chunkSize = 32 * 1024
reader := bytes.NewReader(frameBytes)
buf := make([]byte, chunkSize)

for {
	n, err := reader.Read(buf)
	if err == io.EOF {
		break
	}
	_ = stream.Send(&qrrotv1.PutRequest{
		Data: &qrrotv1.PutRequest_Chunk{
			Chunk: buf[:n],
		},
		Token: "какойта токен",
	})
}

resp, err := stream.CloseAndRecv()
if err != nil || resp.GetStatus() != "OK" {
	log.Fatalf("Ошибка сохранения кадра на сервере")
}

Заключение

Получился очень интересный проект, благодаря которому я немного продвинулся в системщине и научился работать с сырыми данными, а также прокачался в криптографии. Если вас заинтересовал проект, и вы хотите поучаствовать в его развитии, держите ссылки:

Сайт: https://piterov.xyz/qrrot

GitHub: https://github.com/piterovxyz/qrrot