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

Главная болячка прошлой версии - все данные лежали в ОЗУ. Если у вас гигабайты файлов, память закончится раньше, чем вы успеете сказать 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), где токен присылает сам клиент при каждом запросе.

На каждую запись генерируется 16 случайных байт (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 compose up -d --build

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

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

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

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

Здесь мы просто открываем видеоустройство и настраиваем захват в формате 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()

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

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

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

Самый интересный этап. Мы открываем двусторонний стрим 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