WIP Switch back to TCP when RDMA send fails (does not work)

Close TCP connections for RDMA clients
Also check for "Received garbage" during test
2026-05-01 22:26:41 +00:00 · 2026-05-01 22:13:29 +00:00 · 2026-05-01 16:01:28 +03:00 · 2026-05-01 15:57:15 +03:00 · 2026-05-01 15:57:15 +03:00 · 2026-04-29 02:42:23 +03:00
143 changed files with 18209 additions and 1186 deletions
@@ -234,6 +234,60 @@ jobs:
          echo ""
        done

+  test_etcd_fail_https:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 10
+      run: ETCD_SCHEME=https /root/vitastor/tests/test_etcd_fail.sh
+    - name: Print logs
+      if: always() && steps.test.outcome == 'failure'
+      run: |
+        for i in /root/vitastor/testdata/*.log /root/vitastor/testdata/*.txt; do
+          echo "-------- $i --------"
+          cat $i
+          echo ""
+        done
+
+  test_etcd_fail_https_antietcd:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 10
+      run: ETCD_SCHEME=https ANTIETCD=1 /root/vitastor/tests/test_etcd_fail.sh
+    - name: Print logs
+      if: always() && steps.test.outcome == 'failure'
+      run: |
+        for i in /root/vitastor/testdata/*.log /root/vitastor/testdata/*.txt; do
+          echo "-------- $i --------"
+          cat $i
+          echo ""
+        done
+
+  test_snapshot_https:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 3
+      run: ETCD_SCHEME=https /root/vitastor/tests/test_snapshot.sh
+    - name: Print logs
+      if: always() && steps.test.outcome == 'failure'
+      run: |
+        for i in /root/vitastor/testdata/*.log /root/vitastor/testdata/*.txt; do
+          echo "-------- $i --------"
+          cat $i
+          echo ""
+        done
+
  test_interrupted_rebalance:
    runs-on: ubuntu-latest
    needs: build
@@ -648,6 +702,24 @@ jobs:
          echo ""
        done

+  test_snapshot_chain_encrypted:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 3
+      run: ENCRYPTED=1 /root/vitastor/tests/test_snapshot_chain.sh
+    - name: Print logs
+      if: always() && steps.test.outcome == 'failure'
+      run: |
+        for i in /root/vitastor/testdata/*.log /root/vitastor/testdata/*.txt; do
+          echo "-------- $i --------"
+          cat $i
+          echo ""
+        done
+
  test_old_snapshot_chain:
    runs-on: ubuntu-latest
    needs: build
@@ -1206,6 +1278,24 @@ jobs:
          echo ""
        done

+  test_heal_ec_rdma:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 10
+      run: TEST_NAME=ec_rdma RDMA=1 SCHEME=ec /root/vitastor/tests/test_heal.sh
+    - name: Print logs
+      if: always() && steps.test.outcome == 'failure'
+      run: |
+        for i in /root/vitastor/testdata/*.log /root/vitastor/testdata/*.txt; do
+          echo "-------- $i --------"
+          cat $i
+          echo ""
+        done
+
  test_checksum:
    runs-on: ubuntu-latest
    needs: build
@@ -1224,6 +1314,24 @@ jobs:
          echo ""
        done

+  test_checksum_xxhash:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 3
+      run: TEST_NAME=xxhash OSD_ARGS="--data_csum_type xxh3_32" /root/vitastor/tests/test_checksum.sh
+    - name: Print logs
+      if: always() && steps.test.outcome == 'failure'
+      run: |
+        for i in /root/vitastor/testdata/*.log /root/vitastor/testdata/*.txt; do
+          echo "-------- $i --------"
+          cat $i
+          echo ""
+        done
+
  test_old_checksum:
    runs-on: ubuntu-latest
    needs: build
@@ -2052,3 +2160,39 @@ jobs:
          echo ""
        done

+  test_write_encrypted:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 3
+      run: /root/vitastor/tests/test_write_encrypted.sh
+    - name: Print logs
+      if: always() && steps.test.outcome == 'failure'
+      run: |
+        for i in /root/vitastor/testdata/*.log /root/vitastor/testdata/*.txt; do
+          echo "-------- $i --------"
+          cat $i
+          echo ""
+        done
+
+  test_write_encrypted_ec:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 3
+      run: SCHEME=ec /root/vitastor/tests/test_write_encrypted.sh
+    - name: Print logs
+      if: always() && steps.test.outcome == 'failure'
+      run: |
+        for i in /root/vitastor/testdata/*.log /root/vitastor/testdata/*.txt; do
+          echo "-------- $i --------"
+          cat $i
+          echo ""
+        done
+
@@ -38,6 +38,14 @@ for my $line (<>)
            {
                $test_name .= '_antietcd';
            }
+            elsif ($1 eq 'ETCD_SCHEME' && $2 eq 'https')
+            {
+                $test_name .= '_https';
+            }
+            elsif ($1 eq 'ENCRYPTED')
+            {
+                $test_name .= '_encrypted';
+            }
            elsif ($1 eq 'OLD')
            {
                $test_name =~ s/^test_/test_old_/s;
@@ -3,3 +3,4 @@
 package-lock.json
 fio
 qemu
+node_modules
@@ -62,6 +62,7 @@ Vitastor поддерживает QEMU-драйвер, протоколы UBLK,
    - [Дисковые параметры OSD](docs/config/layout-osd.ru.md)
    - [Прочие параметры OSD](docs/config/osd.ru.md)
    - [Параметры мониторов](docs/config/monitor.ru.md)
+    - [Безопасность](docs/config/security.ru.md)
  - [Настройки пулов](docs/config/pool.ru.md)
  - [Метаданные образов в etcd](docs/config/inode.ru.md)
 - Использование
@@ -62,6 +62,7 @@ Read more details in the documentation. You can start from here: [Quick Start](d
    - [OSD Disk Layout](docs/config/layout-osd.en.md)
    - [OSD Runtime Parameters](docs/config/osd.en.md)
    - [Monitor](docs/config/monitor.en.md)
+    - [Security](docs/config/security.en.md)
  - [Pool configuration](docs/config/pool.en.md)
  - [Image metadata in etcd](docs/config/inode.en.md)
 - Usage
@@ -3,7 +3,7 @@ Section: admin
 Priority: optional
 Maintainer: Vitaliy Filippov <vitalif@yourcmc.ru>
 Build-Depends: debhelper, g++ (>= 8), libstdc++6 (>= 8),
-  linux-libc-dev, libgoogle-perftools-dev, libjerasure-dev, libgf-complete-dev,
+  linux-libc-dev, libgoogle-perftools-dev, libjerasure-dev, libgf-complete-dev, libc-ares-dev,
  libibverbs-dev, librdmacm-dev, libisal-dev, cmake, pkg-config, libnl-3-dev, libnl-genl-3-dev,
  node-bindings <!nocheck>, node-gyp, node-nan
 Standards-Version: 4.5.0
@@ -12,20 +12,18 @@ ARG REL=
 WORKDIR /root

 RUN set -e -x; \
-    if [ "$REL" = "buster" ]; then \
-        perl -i -pe 's/deb.debian.org/archive.debian.org/' /etc/apt/sources.list; \
-        apt-get update; \
-        apt-get -y install wget; \
-        wget https://vitastor.io/debian/pubkey.gpg -O /etc/apt/trusted.gpg.d/vitastor.gpg; \
-        echo "deb https://vitastor.io/debian $REL main" >> /etc/apt/sources.list; \
-    fi; \
+    perl -i -pe 's/deb.debian.org/archive.debian.org/' /etc/apt/sources.list; \
+    apt-get update; \
+    apt-get -y install wget; \
+    wget https://vitastor.io/debian/pubkey.gpg -O /etc/apt/trusted.gpg.d/vitastor.gpg; \
+    echo "deb https://vitastor.io/debian $REL main" >> /etc/apt/sources.list; \
    grep '^deb ' /etc/apt/sources.list | perl -pe 's/^deb/deb-src/' >> /etc/apt/sources.list; \
    perl -i -pe 's/Types: deb$/Types: deb deb-src/' /etc/apt/sources.list.d/*.sources || true; \
    echo 'APT::Install-Recommends false;' >> /etc/apt/apt.conf; \
    echo 'APT::Install-Suggests false;' >> /etc/apt/apt.conf

 RUN apt-get update && \
-    apt-get -y install fio libgoogle-perftools-dev devscripts libjerasure-dev cmake \
+    apt-get -y install fio libgoogle-perftools-dev devscripts libjerasure-dev cmake libc-ares-dev libisal-crypto-dev \
        libibverbs-dev librdmacm-dev libisal-dev libnl-3-dev libnl-genl-3-dev curl nodejs npm node-nan node-bindings && \
    apt-get -y build-dep fio && \
    apt-get --download-only source fio
@@ -38,3 +38,4 @@ In the future, additional configuration methods may be added:
 - [OSD Disk Layout](config/layout-osd.en.md)
 - [OSD Runtime Parameters](config/osd.en.md)
 - [Monitor](config/monitor.en.md)
+- [Security Parameters](config/security.en.md)
@@ -41,3 +41,4 @@
 - [Дисковые параметры OSD](config/layout-osd.ru.md)
 - [Прочие параметры OSD](config/osd.ru.md)
 - [Параметры мониторов](config/monitor.ru.md)
+- [Параметры безопасности](config/security.ru.md)
@@ -198,8 +198,14 @@ put a modified value into etcd key /vitastor/config/global.
 - Type: string
 - Default: none

-Data checksum type to use. May be "crc32c" or "none". Set to "crc32c" to
-enable data checksums.
+Data and metadata checksum type to use. May be "crc32c", "xxh3_32" or "none".
+Select crc32c or xxh3_32 and set csum_block_size to enable data checksums.
+
+Both crc32c and xxh3_32 are almost equally fast, xxh3_32 is safer. xxh3_32 is
+the xxhash3 algorithm truncated from 64 to 32 bits (which is still a good hash).
+
+Note that enabled data checksums either increase memory usage or reduce
+performance. Check details in [csum_block_size](#csum_block_size) description.

 ## csum_block_size

@@ -209,8 +209,12 @@ journal_block_size и meta_block_size. Однако на данный момен
 - Тип: строка
 - Значение по умолчанию: none

-Тип используемых OSD контрольных сумм данных. Может быть "crc32c" или "none".
-Установите в "crc32c", чтобы включить расчёт и проверку контрольных сумм данных.
+Тип используемых OSD контрольных сумм данных и метаданных. Может быть "crc32c",
+"xxh3_32" или "none". Выберите crc32c или xxh3_32 и установите csum_block_size,
+чтобы включить контрольные суммы данных.
+
+И crc32c, и xxh3_32 примерно одинаково быстры, xxh3_32 надёжней. xxh3_32 - это
+алгоритм xxhash3, обрезанный с 64 до 32 бит (это всё равно хороший хеш).

 Следует понимать, что контрольные суммы в зависимости от размера блока их
 расчёта либо увеличивают потребление памяти, либо снижают производительность.
@@ -0,0 +1,150 @@
+[Documentation](../../README.md#documentation) → [Configuration](../config.en.md) → Security Parameters
+
+-----
+
+[Читать на русском](security.ru.md)
+
+# Security Parameters
+
+These parameters affect your Vitastor installation security and apply to OSDs, monitors and clients.
+
+Most of them can be set in /etc/vitastor/vitastor.conf and in etcd, but don't support online modification.
+
+- [etcd_client_cert](#etcd_client_cert)
+- [etcd_client_key](#etcd_client_key)
+- [etcd_ca](#etcd_ca)
+- [osd_etcd_client_cert](#osd_etcd_client_cert)
+- [osd_etcd_client_key](#osd_etcd_client_key)
+- [mon_etcd_client_cert](#mon_etcd_client_cert)
+- [mon_etcd_client_key](#mon_etcd_client_key)
+- [vault_url](#vault_url)
+- [vault_secret_api_path](#vault_secret_api_path)
+- [vault_client_cert](#vault_client_cert)
+- [vault_client_key](#vault_client_key)
+- [vault_ca](#vault_ca)
+- [vault_timeout_ms](#vault_timeout_ms)
+- [vault_error_timeout_sec](#vault_error_timeout_sec)
+- [vault_refresh_leeway_sec](#vault_refresh_leeway_sec)
+- [max_cipher_pool_size](#max_cipher_pool_size)
+
+## etcd_client_cert
+
+- Type: string
+
+Client TLS certificate to use for Vitastor client (not OSD and not monitor)
+etcd https connections. May be path to a file or just a PEM string with certificate.
+In the latter case, string must begin with "-----BEGIN CERTIFICATE-----".
+
+## etcd_client_key
+
+- Type: string
+
+Private key for etcd_client_cert (also a file or a PEM string).
+
+## etcd_ca
+
+- Type: string
+
+Trusted TLS CA to verify etcd server certificate. May be path to a file,
+directory or just a PEM string with certificate.
+
+## osd_etcd_client_cert
+
+- Type: string
+
+Same as [etcd_client_cert](#etcd_client_cert), but only for OSDs.
+OSDs, clients and monitors should have different permissions, so they should
+use different certificates.
+
+## osd_etcd_client_key
+
+- Type: string
+
+Same as [etcd_client_key](#etcd_client_key), but only for OSDs.
+
+## mon_etcd_client_cert
+
+- Type: string
+
+Same as [etcd_client_cert](#etcd_client_cert), but only for Vitastor monitors.
+
+## mon_etcd_client_key
+
+- Type: string
+
+Same as [etcd_client_key](#etcd_client_key), but only for Vitastor monitors.
+
+## vault_url
+
+- Type: string
+
+Vault base URL.
+
+Vitastor clients support AES-256-XTS image data encryption with different per-image keys.
+Encryption is performed by the client, OSDs don't have access to decrypted data.
+
+Encryption keys may be stored in etcd or, for the increased security level, in an external
+[HashiCorp Vault](https://developer.hashicorp.com/vault/) or [OpenBao](https://openbao.org/)
+instance.
+
+Vitastor clients use [v1 k/v secrets engine](https://openbao.org/api-docs/secret/kv/kv-v1/)
+and [TLS authentication engine](https://openbao.org/api-docs/auth/cert/) in Vault.
+
+In that case, only key IDs are stored in etcd.
+
+## vault_secret_api_path
+
+- Type: string
+- Default: /v1/secret/
+
+Vault v1 secret API mount path to use.
+
+## vault_client_cert
+
+- Type: string
+
+Client TLS certificate to use for Vault connections. Just like [etcd_client_cert](#etcd_client_cert),
+may be path to a file or just a certificate in PEM string.
+
+## vault_client_key
+
+- Type: string
+
+Private key for vault_client_cert (also a file or a PEM string).
+
+## vault_ca
+
+- Type: string
+
+Trusted TLS CA to verify Vault server certificate. May be path to a file,
+directory or just a PEM string with certificate.
+
+## vault_timeout_ms
+
+- Type: integer
+- Default: 5000
+
+Timeout for Vault requests in milliseconds.
+
+## vault_error_timeout_sec
+
+- Type: integer
+- Default: 60
+
+Time (in seconds) to wait before retrying after receiving an error from Vault.
+
+## vault_refresh_leeway_sec
+
+- Type: integer
+- Default: 60
+
+Extra time (in seconds) before real Vault token lease_timeout to refresh it, just
+in case of system clock drift.
+
+## max_cipher_pool_size
+
+- Type: integer
+- Default: 256
+
+Maximum number of OpenSSL cipher contexts cached in OSD memory, counted separately
+for each cipher and for encryption/decryption. Probably doesn't require modification.
@@ -0,0 +1,154 @@
+[Документация](../../README-ru.md#документация) → [Конфигурация](../config.ru.md) → Параметры безопасности
+
+-----
+
+[Read in English](security.en.md)
+
+# Параметры безопасности
+
+Данные параметры затрагивают безопасность инсталляций Vitastor и используются
+OSD, мониторами и клиентами.
+
+Большая их часть может задаваться в /etc/vitastor/vitastor.conf и в etcd, но не
+поддерживает онлайн-изменение.
+
+- [etcd_client_cert](#etcd_client_cert)
+- [etcd_client_key](#etcd_client_key)
+- [etcd_ca](#etcd_ca)
+- [osd_etcd_client_cert](#osd_etcd_client_cert)
+- [osd_etcd_client_key](#osd_etcd_client_key)
+- [mon_etcd_client_cert](#mon_etcd_client_cert)
+- [mon_etcd_client_key](#mon_etcd_client_key)
+- [vault_url](#vault_url)
+- [vault_secret_api_path](#vault_secret_api_path)
+- [vault_client_cert](#vault_client_cert)
+- [vault_client_key](#vault_client_key)
+- [vault_ca](#vault_ca)
+- [vault_timeout_ms](#vault_timeout_ms)
+- [vault_error_timeout_sec](#vault_error_timeout_sec)
+- [vault_refresh_leeway_sec](#vault_refresh_leeway_sec)
+- [max_cipher_pool_size](#max_cipher_pool_size)
+
+## etcd_client_cert
+
+- Тип: строка
+
+Клиентский TLS сертификат для https-подключений к etcd для клиентов Vitastor
+(не OSD и не мониторов). Может быть путём к файлу или просто строкой с
+сертификатом в формате PEM. В последнем случае строка должна начинаться с
+"-----BEGIN CERTIFICATE-----".
+
+## etcd_client_key
+
+- Тип: строка
+
+Закрытый ключ для сертификата etcd_client_cert (также путь к файлу или PEM строка).
+
+## etcd_ca
+
+- Тип: строка
+
+Доверенный корневой TLS-сертификат для проверки сертификата сервера etcd.
+Может быть путём к файлу, директории или просто строкой с сертификатом в
+формате PEM.
+
+## osd_etcd_client_cert
+
+- Тип: строка
+
+Аналогично [etcd_client_cert](#etcd_client_cert), но только для OSD.
+OSD, клиенты и мониторы должны иметь разные привилегии, поэтому они должны
+использовать разные сертификаты.
+
+## osd_etcd_client_key
+
+- Тип: строка
+
+Аналогично [etcd_client_key](#etcd_client_key), но только для OSD.
+
+## mon_etcd_client_cert
+
+- Тип: строка
+
+Аналогично [etcd_client_cert](#etcd_client_cert), но только для мониторов Vitastor.
+
+## mon_etcd_client_key
+
+- Тип: строка
+
+Аналогично [etcd_client_key](#etcd_client_key), но только для мониторов Vitastor.
+
+## vault_url
+
+- Тип: строка
+
+Базовый адрес Vault.
+
+Клиенты Vitastor поддерживают AES-256-XTS шифрование данных образов с отдельными ключами на
+каждый образ. Данные шифруются клиентами, OSD не имеют доступа к незашифрованным данным.
+
+Ключи шифрования могут храниться в etcd или, для повышенного уровня безопасности, во внешнем
+[HashiCorp Vault](https://developer.hashicorp.com/vault/) или [OpenBao](https://openbao.org/).
+
+Клиенты Vitastor используют [движок секретов v1](https://openbao.org/api-docs/secret/kv/kv-v1/)
+и [TLS-аутентификацию](https://openbao.org/api-docs/auth/cert/) в Vault.
+
+В этом случае, только ID ключей хранятся в etcd.
+
+## vault_secret_api_path
+
+- Тип: строка
+- Значение по умолчанию: /v1/secret/
+
+Путь к API секретов v1 для использования клиентами.
+
+## vault_client_cert
+
+- Тип: строка
+
+Клиентский TLS сертификат для подключений к Vault. Как и [etcd_client_cert](#etcd_client_cert),
+может быть путём к файлу или просто PEM-строкой с сертификатом.
+
+## vault_client_key
+
+- Тип: строка
+
+Закрытый ключ для сертификата vault_client_cert (также путь к файлу или PEM строка).
+
+## vault_ca
+
+- Тип: строка
+
+Доверенный корневой TLS-сертификат для проверки сертификата сервера Vault.
+Может быть путём к файлу, директории или просто строкой с сертификатом в
+формате PEM.
+
+## vault_timeout_ms
+
+- Тип: целое число
+- Значение по умолчанию: 5000
+
+Максимально время выполнения Vault-запросов в миллисекундах.
+
+## vault_error_timeout_sec
+
+- Тип: целое число
+- Значение по умолчанию: 60
+
+Время (в секундах) для ожидания перед повторной попыткой при получении ошибки от Vault.
+
+## vault_refresh_leeway_sec
+
+- Тип: целое число
+- Значение по умолчанию: 60
+
+Зазор времени (в секундах), чтобы обновлять токены Vault чуть раньше их реального
+lease_timeout, на случай "ухода" системных часов.
+
+## max_cipher_pool_size
+
+- Тип: целое число
+- Значение по умолчанию: 256
+
+Максимальное количество кэшируемых в памяти OSD контекстов шифра OpenSSL, учитываемое
+отдельно для каждого шифра и для шифрования и расшифровки. Вряд ли требует изменения.
@@ -44,6 +44,8 @@

 {{../../config/monitor.en.md|indent=2}}

+{{../../config/security.en.md|indent=2}}
+
 {{../../config/pool.en.md|indent=2}}

 {{../../config/inode.en.md|indent=2}}
@@ -44,6 +44,8 @@

 {{../../config/monitor.ru.md|indent=2}}

+{{../../config/security.ru.md|indent=2}}
+
 {{../../config/pool.ru.md|indent=2}}

 {{../../config/inode.ru.md|indent=2}}
@@ -233,11 +233,21 @@
  type: string
  default: none
  info: |
-    Data checksum type to use. May be "crc32c" or "none". Set to "crc32c" to
-    enable data checksums.
+    Data and metadata checksum type to use. May be "crc32c", "xxh3_32" or "none".
+    Select crc32c or xxh3_32 and set csum_block_size to enable data checksums.
+
+    Both crc32c and xxh3_32 are almost equally fast, xxh3_32 is safer. xxh3_32 is
+    the xxhash3 algorithm truncated from 64 to 32 bits (which is still a good hash).
+
+    Note that enabled data checksums either increase memory usage or reduce
+    performance. Check details in [csum_block_size](#csum_block_size) description.
  info_ru: |
-    Тип используемых OSD контрольных сумм данных. Может быть "crc32c" или "none".
-    Установите в "crc32c", чтобы включить расчёт и проверку контрольных сумм данных.
+    Тип используемых OSD контрольных сумм данных и метаданных. Может быть "crc32c",
+    "xxh3_32" или "none". Выберите crc32c или xxh3_32 и установите csum_block_size,
+    чтобы включить контрольные суммы данных.
+
+    И crc32c, и xxh3_32 примерно одинаково быстры, xxh3_32 надёжней. xxh3_32 - это
+    алгоритм xxhash3, обрезанный с 64 до 32 бит (это всё равно хороший хеш).

    Следует понимать, что контрольные суммы в зависимости от размера блока их
    расчёта либо увеличивают потребление памяти, либо снижают производительность.
@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "yaml": "^2.8.2"
+  }
+}
@@ -0,0 +1,5 @@
+# Security Parameters
+
+These parameters affect your Vitastor installation security and apply to OSDs, monitors and clients.
+
+Most of them can be set in /etc/vitastor/vitastor.conf and in etcd, but don't support online modification.
@@ -0,0 +1,7 @@
+# Параметры безопасности
+
+Данные параметры затрагивают безопасность инсталляций Vitastor и используются
+OSD, мониторами и клиентами.
+
+Большая их часть может задаваться в /etc/vitastor/vitastor.conf и в etcd, но не
+поддерживает онлайн-изменение.
@@ -0,0 +1,131 @@
+- name: etcd_client_cert
+  type: string
+  info: |
+    Client TLS certificate to use for Vitastor client (not OSD and not monitor)
+    etcd https connections. May be path to a file or just a PEM string with certificate.
+    In the latter case, string must begin with "-----BEGIN CERTIFICATE-----".
+  info_ru: |
+    Клиентский TLS сертификат для https-подключений к etcd для клиентов Vitastor
+    (не OSD и не мониторов). Может быть путём к файлу или просто строкой с
+    сертификатом в формате PEM. В последнем случае строка должна начинаться с
+    "-----BEGIN CERTIFICATE-----".
+- name: etcd_client_key
+  type: string
+  info: Private key for etcd_client_cert (also a file or a PEM string).
+  info_ru: Закрытый ключ для сертификата etcd_client_cert (также путь к файлу или PEM строка).
+- name: etcd_ca
+  type: string
+  info: |
+    Trusted TLS CA to verify etcd server certificate. May be path to a file,
+    directory or just a PEM string with certificate.
+  info_ru: |
+    Доверенный корневой TLS-сертификат для проверки сертификата сервера etcd.
+    Может быть путём к файлу, директории или просто строкой с сертификатом в
+    формате PEM.
+- name: osd_etcd_client_cert
+  type: string
+  info: |
+    Same as [etcd_client_cert](#etcd_client_cert), but only for OSDs.
+    OSDs, clients and monitors should have different permissions, so they should
+    use different certificates.
+  info_ru: |
+    Аналогично [etcd_client_cert](#etcd_client_cert), но только для OSD.
+    OSD, клиенты и мониторы должны иметь разные привилегии, поэтому они должны
+    использовать разные сертификаты.
+- name: osd_etcd_client_key
+  type: string
+  info: Same as [etcd_client_key](#etcd_client_key), but only for OSDs.
+  info_ru: Аналогично [etcd_client_key](#etcd_client_key), но только для OSD.
+- name: mon_etcd_client_cert
+  type: string
+  info: Same as [etcd_client_cert](#etcd_client_cert), but only for Vitastor monitors.
+  info_ru: Аналогично [etcd_client_cert](#etcd_client_cert), но только для мониторов Vitastor.
+- name: mon_etcd_client_key
+  type: string
+  info: Same as [etcd_client_key](#etcd_client_key), but only for Vitastor monitors.
+  info_ru: Аналогично [etcd_client_key](#etcd_client_key), но только для мониторов Vitastor.
+- name: vault_url
+  type: string
+  info: |
+    Vault base URL.
+
+    Vitastor clients support AES-256-XTS image data encryption with different per-image keys.
+    Encryption is performed by the client, OSDs don't have access to decrypted data.
+
+    Encryption keys may be stored in etcd or, for the increased security level, in an external
+    [HashiCorp Vault](https://developer.hashicorp.com/vault/) or [OpenBao](https://openbao.org/)
+    instance.
+
+    Vitastor clients use [v1 k/v secrets engine](https://openbao.org/api-docs/secret/kv/kv-v1/)
+    and [TLS authentication engine](https://openbao.org/api-docs/auth/cert/) in Vault.
+
+    In that case, only key IDs are stored in etcd.
+  info_ru: |
+    Базовый адрес Vault.
+
+    Клиенты Vitastor поддерживают AES-256-XTS шифрование данных образов с отдельными ключами на
+    каждый образ. Данные шифруются клиентами, OSD не имеют доступа к незашифрованным данным.
+
+    Ключи шифрования могут храниться в etcd или, для повышенного уровня безопасности, во внешнем
+    [HashiCorp Vault](https://developer.hashicorp.com/vault/) или [OpenBao](https://openbao.org/).
+
+    Клиенты Vitastor используют [движок секретов v1](https://openbao.org/api-docs/secret/kv/kv-v1/)
+    и [TLS-аутентификацию](https://openbao.org/api-docs/auth/cert/) в Vault.
+
+    В этом случае, только ID ключей хранятся в etcd.
+- name: vault_secret_api_path
+  type: string
+  default: /v1/secret/
+  info: Vault v1 secret API mount path to use.
+  info_ru: Путь к API секретов v1 для использования клиентами.
+- name: vault_client_cert
+  type: string
+  info: |
+    Client TLS certificate to use for Vault connections. Just like [etcd_client_cert](#etcd_client_cert),
+    may be path to a file or just a certificate in PEM string.
+  info_ru: |
+    Клиентский TLS сертификат для подключений к Vault. Как и [etcd_client_cert](#etcd_client_cert),
+    может быть путём к файлу или просто PEM-строкой с сертификатом.
+- name: vault_client_key
+  type: string
+  info: Private key for vault_client_cert (also a file or a PEM string).
+  info_ru: Закрытый ключ для сертификата vault_client_cert (также путь к файлу или PEM строка).
+- name: vault_ca
+  type: string
+  info: |
+    Trusted TLS CA to verify Vault server certificate. May be path to a file,
+    directory or just a PEM string with certificate.
+  info_ru: |
+    Доверенный корневой TLS-сертификат для проверки сертификата сервера Vault.
+    Может быть путём к файлу, директории или просто строкой с сертификатом в
+    формате PEM.
+- name: vault_timeout_ms
+  type: int
+  default: 5000
+  info: Timeout for Vault requests in milliseconds.
+  info_ru: Максимально время выполнения Vault-запросов в миллисекундах.
+- name: vault_error_timeout_sec
+  type: int
+  default: 60
+  info: |
+    Time (in seconds) to wait before retrying after receiving an error from Vault.
+  info_ru: |
+    Время (в секундах) для ожидания перед повторной попыткой при получении ошибки от Vault.
+- name: vault_refresh_leeway_sec
+  type: int
+  default: 60
+  info: |
+    Extra time (in seconds) before real Vault token lease_timeout to refresh it, just
+    in case of system clock drift.
+  info_ru: |
+    Зазор времени (в секундах), чтобы обновлять токены Vault чуть раньше их реального
+    lease_timeout, на случай "ухода" системных часов.
+- name: max_cipher_pool_size
+  type: int
+  default: 256
+  info: |
+    Maximum number of OpenSSL cipher contexts cached in OSD memory, counted separately
+    for each cipher and for encryption/decryption. Probably doesn't require modification.
+  info_ru: |
+    Максимальное количество кэшируемых в памяти OSD контекстов шифра OpenSSL, учитываемое
+    отдельно для каждого шифра и для шифрования и расшифровки. Вряд ли требует изменения.
@@ -15,8 +15,8 @@
 - gcc and g++ 8 or newer, clang 10 or newer, or other compiler with C++11 plus
  designated initializers support from C++20
 - CMake
- jerasure headers and libraries
- ISA-L, libibverbs and librdmacm headers and libraries (optional)
+- jerasure, c-ares headers and libraries
+- ISA-L, libibverbs, librdmacm, libnl3 headers and libraries (optional)
 - tcmalloc (google-perftools-dev)

 ## Basic instructions
@@ -15,8 +15,8 @@
 - gcc и g++ >= 8, либо clang >= 10, либо другой компилятор с поддержкой C++11 плюс
  назначенных инициализаторов (designated initializers) из C++20
 - CMake
- Заголовки и библиотеки jerasure
- Опционально - заголовки и библиотеки ISA-L, libibverbs, librdmacm
+- Заголовки и библиотеки jerasure, c-ares
+- Опционально - заголовки и библиотеки ISA-L, libibverbs, librdmacm, libnl3
 - tcmalloc (google-perftools-dev)

 ## Базовая инструкция
@@ -41,6 +41,8 @@
 - [Built-in Prometheus metric exporter](../config/monitor.en.md#enable_prometheus)
 - [NFS RDMA support](../usage/nfs.en.md#rdma) (probably also usable for GPUDirect)
 - [S3](../installation/s3.en.md)
+- [TLS support for etcd connections](../config/security.en.md)
+- [AES-256-XTS image encryption](../usage/cli.en.md#create) and [Vault support](../config/security.en.md#vault_url) for key storage

 ## Plugins and tools

@@ -43,6 +43,8 @@
 - [Встроенный Prometheus-экспортер метрик](../config/monitor.ru.md#enable_prometheus)
 - [Поддержка NFS RDMA](../usage/nfs.ru.md#rdma) (вероятно, также подходящая для GPUDirect)
 - [S3](../installation/s3.ru.md)
+- [Поддержка TLS-соединений с etcd](../config/security.ru.md)
+- [AES-256-XTS шифрование данных](../usage/cli.ru.md#create) и [поддержка Vault](../config/security.ru.md#vault_url) для хранения ключей

 ## Драйверы и инструменты

@@ -125,18 +125,31 @@ bench-kaveri         kaveri    10 G  10 G    0 B/s  0     0      0 us  0 B/s  0

 ## create

-`vitastor-cli create -s|--size <size> [-p|--pool <id|name>] [--parent <parent_name>[@<snapshot>]] <name>`
+`vitastor-cli create -s|--size SIZE [OPTIONS] <name>`

-Create an image. You may use K/M/G/T suffixes for `<size>`. If `--parent` is specified,
-a copy-on-write image clone is created. Parent must be a snapshot (readonly image).
-Pool must be specified if there is more than one pool.
+Create an image. Options:
+
+* `-s|--size SIZE` - New image size in bytes or with a K/M/G/T unit suffix.
+* `-p|--pool POOL` - Specify pool for the new image (may be omitted if there is only 1 pool).
+* `--parent PARENT` - Create a copy-on-write image clone based on PARENT (or PARENT@SNAPSHOT).
+  If parent is not a snapshot, it must be a read-only image.
+* `--enc-key random` - Generate a new random AES-256-XTS encryption key for the new image.
+* `--enc-key HEX` - Set a specified AES-256-XTS key (64 bytes in hex) for the new image.
+* `--enc-key vault:ID` - Use an encryption key from an external Vault secret with specified ID.

 ```
-vitastor-cli create --snapshot <snapshot> [-p|--pool <id|name>] <image>
-vitastor-cli snap-create [-p|--pool <id|name>] <image>@<snapshot>
+vitastor-cli create --snapshot <snapshot> [OPTIONS] <image>
+vitastor-cli snap-create [OPTIONS] <image>@<snapshot>
 ```

-Create a snapshot of image `<name>` (either form can be used). May be used live if only a single writer is active.
+Create a snapshot of image `<image>`. May be used live if only a single writer is active.
+
+Options:
+
+* `-p|--pool POOL` - Move image to pool POOL, leaving the snapshot in the old pool.
+* `--enc-key random` - Change image encryption key to a new random AES-256-XTS key.
+* `--enc-key KEY` - Change image encryption key to a specified key, Vault key or to an empty key.
+  By default, the image retains its old encryption key when taking a snapshot.

 See also about [how to export snapshots](qemu.en.md#exporting-snapshots).

@@ -151,6 +164,7 @@ You should resize file system in the image, if present, before shrinking it.
 * `--deleted 1|0` - Set/clear 'deleted image' flag (set automatically during unfinished deletes).
 * `-f|--force` - Proceed with shrinking or setting readwrite flag even if the image has children.
 * `--down-ok` - Proceed with shrinking even if some data will be left on unavailable OSDs.
+* `--enc-key HEX` - Change image encryption key (allowed only with `--force`).

 ## dd

@@ -127,19 +127,32 @@ bench-kaveri         kaveri    10 G  10 G    0 B/s  0     0      0 us  0 B/s  0

 ## create

-`vitastor-cli create -s|--size <size> [-p|--pool <id|name>] [--parent <parent_name>[@<snapshot>]] <name>`
+`vitastor-cli create -s|--size SIZE [ОПЦИИ] <name>`

-Создать образ. Для размера `<size>` можно использовать суффиксы K/M/G/T (килобайт-мегабайт-гигабайт-терабайт).
-Если указана опция `--parent`, создаётся клон образа. Родитель `<parent_name>[@<snapshot>]` должен быть
-снимком (или просто немодифицируемым образом). Пул обязательно указывать, если в кластере больше одного пула.
+Создать образ. Опции:
+
+* `-s|--size SIZE` - Размер нового образа в байтах или с суффиксом K/M/G/T (кило/мега/гига/терабайт).
+* `-p|--pool POOL` - Создать образ в заданном пуле (можно не указывать, если пул всего один).
+* `--parent PARENT` - Создать легковесный клон на основе образа `PARENT` или снимка `PARENT@SNAP`.
+  Если `PARENT` - не снимок, он должен быть помечен как образ только для чтения.
+* `--enc-key random` - Сгенерировать случайный ключ шифрования AES-256-XTS для нового образа.
+* `--enc-key HEX` - Установить заданный ключ AES-256-XTS (64 байта в hex) для нового образа.
+* `--enc-key vault:ID` - Использовать ключ из внешнего секрета с заданным ID из Vault.

 ```
-vitastor-cli create --snapshot <snapshot> [-p|--pool <id|name>] <image>
-vitastor-cli snap-create [-p|--pool <id|name>] <image>@<snapshot>
+vitastor-cli create --snapshot <snapshot> [ОПЦИИ] <image>
+vitastor-cli snap-create [ОПЦИИ] <image>@<snapshot>
 ```

-Создать снимок образа `<name>` (можно использовать любую форму команды). Снимок можно создавать без остановки
-клиентов, если пишущий клиент максимум 1.
+Создать снимок образа `<image>` (можно использовать любую форму команды).
+Снимок можно создавать без остановки клиентов, если пишущих клиентов не больше одного.
+
+Опции:
+
+* `-p|--pool POOL` - Переместить образ в пул POOL, оставив снимок в старом пуле.
+* `--enc-key random` - Изменить ключ шифрования образа на новый случайный ключ AES-256-XTS.
+* `--enc-key KEY` - Изменить ключ шифрования образа на заданный ключ, ключ из Vault или пустой ключ.
+  По умолчанию шифрованные образы сохраняют старый ключ при снятии снимка.

 Смотрите также информацию о том, [как экспортировать снимки](qemu.ru.md#экспорт-снимков).

@@ -156,6 +169,7 @@ vitastor-cli snap-create [-p|--pool <id|name>] <image>@<snapshot>
 * `--deleted 1|0` - Установить/снять флаг "образ удалён" (устанавливается при незавершённом удалении).
 * `-f|--force` - Разрешить уменьшение или перевод в чтение-запись образа, у которого есть клоны.
 * `--down-ok` - Разрешить уменьшение, даже если часть данных останется неудалённой на недоступных OSD.
+* `--enc-key HEX` - Изменить ключ шифрования образа (разрешено только с `--force`).

 ## dd

@@ -18,7 +18,7 @@ class AntiEtcdAdapter
                cluster = cluster ? (''+(cluster||'')).split(/,+/) : [];
            cluster = Object.keys(cluster.reduce((a, url) =>
            {
-                a[url.toLowerCase().replace(/^(https?:\/\/)/, '').replace(/\/.*$/, '')] = true;
+                a[url.toLowerCase().replace(/^(https?:\/\/)?(.*?)(\/.*)?$/, (m, m1, m2) => (m1||'http://')+m2)] = true;
                return a;
            }, {}));
            const cfg_port = config.antietcd_port;
@@ -26,7 +26,8 @@ class AntiEtcdAdapter
            is_local['0.0.0.0'] = true;
            is_local['::'] = true;
            is_local[''] = true;
-            const selected = cluster.map(s => s.split(':', 2)).filter(ip => is_local[ip[0]] && (!cfg_port || ip[1] == cfg_port));
+            // split :, 3 -> <schema>:<//ip>:<port>
+            const selected = cluster.map(s => s.split(':', 3)).filter(ip => is_local[ip[1].substr(2)] && (!cfg_port || ip[2] == cfg_port));
            if (selected.length > 1)
            {
                console.error('More than 1 etcd_address matches local IPs, please specify port');
@@ -35,16 +36,30 @@ class AntiEtcdAdapter
            else if (selected.length == 1)
            {
                const antietcd_config = {
-                    ip: selected[0][0],
-                    port: selected[0][1],
-                    data: config.antietcd_data_file || ((config.antietcd_data_dir || '/var/lib/vitastor') + '/mon_'+selected[0][1]+'.json.gz'),
+                    ip: selected[0][1].substr(2),
+                    port: selected[0][2],
+                    cert: config.antietcd_cert,
+                    key: config.antietcd_key,
+                    ca: config.etcd_ca,
+                    data: config.antietcd_data_file || ((config.antietcd_data_dir || '/var/lib/vitastor') + '/mon_'+selected[0][2]+'.json.gz'),
                    persist_filter: vitastor_persist_filter({ vitastor_prefix: config.etcd_prefix || '/vitastor' }),
-                    node_id: selected[0][0]+':'+selected[0][1], // node_id = ip:port
-                    cluster: (cluster.length == 1 ? null : cluster.reduce((a, c) => { a[c] = "http://"+c; return a; }, {})),
+                    node_id: selected[0][1].substr(2)+':'+selected[0][2], // node_id = ip:port
+                    cluster: (cluster.length == 1 ? null : cluster.reduce((a, c) => { a[c.replace(/^(https?:\/\/)/, '')] = c; return a; }, {})),
                    cluster_key: (config.etcd_prefix || '/vitastor'),
                    stale_read: 1,
                    log_level: 1,
                };
+                if (config.use_auth)
+                {
+                    antietcd_config.client_cert_auth = true;
+                    antietcd_config.auth_filter = require('./vitastor_auth_filter.js');
+                    antietcd_config.peer_ca = config.antietcd_server_ca;
+                    if (!config.antietcd_server_ca || config.antietcd_server_ca == config.etcd_ca)
+                    {
+                        console.error('Secure setup requires separate antietcd_server_ca (for signing antietcd server certificates) and etcd_ca (for signing client certificates)');
+                        process.exit(1);
+                    }
+                }
                for (const key in config)
                {
                    if (key.substr(0, 9) === 'antietcd_')
@@ -169,7 +184,7 @@ class AntiEtcdAdapter
                    await new Promise(ok => setTimeout(ok, timeout-(Date.now()-prev)));
                }
                prev = Date.now();
-                const res = await this.antietcd.api(path.replace(/^\/+/, '').replace(/\/+$/, '').replace(/\/+/g, '_'), body);
+                const res = await this.antietcd.api(path.replace(/^\/+/, '').replace(/\/+$/, '').replace(/\/+/g, '_'), body, { username: 'root' });
                if (res.error)
                {
                    console.error('Failed to query antietcd '+path+' (retry '+retry+'/'+retries+'): '+res.error);
@@ -1,7 +1,9 @@
 // Copyright (c) Vitaliy Filippov, 2019+
 // License: VNPL-1.1 (see README.md for details)

+const fs = require('fs');
 const http = require('http');
+const https = require('https');
 const WebSocket = require('ws');
 const { b64, local_ips } = require('./utils.js');

@@ -15,11 +17,30 @@ class EtcdAdapter
        this.ws = null;
        this.ws_alive = false;
        this.ws_keepalive_timer = null;
+        this.opts = {};
    }

    parse_config(config)
    {
        this.parse_etcd_addresses(config.etcd_address||config.etcd_url);
+        if (config.mon_etcd_client_cert || config.etcd_client_cert)
+        {
+            this.opts.cert = config.mon_etcd_client_cert || config.etcd_client_cert;
+            if (this.opts.cert.substr(0, 5) != '-----')
+                this.opts.cert = fs.readFileSync(this.opts.cert, { encoding: 'utf-8' });
+        }
+        if (config.mon_etcd_client_key || config.etcd_client_key)
+        {
+            this.opts.key = config.mon_etcd_client_key || config.etcd_client_key;
+            if (this.opts.key.substr(0, 5) != '-----')
+                this.opts.key = fs.readFileSync(this.opts.key, { encoding: 'utf-8' });
+        }
+        if (config.etcd_ca)
+        {
+            this.opts.ca = config.etcd_ca;
+            if (this.opts.ca.substr(0, 5) != '-----')
+                this.opts.ca = fs.readFileSync(this.opts.ca, { encoding: 'utf-8' });
+        }
    }

    parse_etcd_addresses(addrs)
@@ -39,7 +60,7 @@ class EtcdAdapter
        for (let url of addrs)
        {
            let scheme = 'http';
-            url = url.trim().replace(/^(https?):\/\//, (m, m1) => { scheme = m1; return ''; });
+            url = url.trim().replace(/^(https?):\/\//i, (m, m1) => { scheme = m1.toLowerCase(); return ''; });
            const slash = url.indexOf('/');
            const colon = url.indexOf(':');
            const is_local = is_local_ip[colon >= 0 ? url.substr(0, colon) : (slash >= 0 ? url.substr(0, slash) : url)];
@@ -130,7 +151,7 @@ class EtcdAdapter
                    }
                    ok(false);
                }, this.mon.config.etcd_mon_timeout);
-                this.ws = new WebSocket(base+'/watch');
+                this.ws = new WebSocket(base+'/watch', this.opts);
                this.ws_used_url = cur_addr;
                const fail = () =>
                {
@@ -272,7 +293,7 @@ class EtcdAdapter
            {
                throw new Error(MON_STOPPED);
            }
-            const res = await POST(base+path, body, timeout);
+            const res = await POST(base+path, body, timeout, this.opts);
            if (this.mon.stopped)
            {
                throw new Error(MON_STOPPED);
@@ -298,7 +319,7 @@ class EtcdAdapter
    }
 }

-function POST(url, body, timeout)
+function POST(url, body, timeout, opts)
 {
    return new Promise(ok =>
    {
@@ -310,10 +331,10 @@ function POST(url, body, timeout)
            req = null;
            ok({ error: 'timeout' });
        }, timeout) : null;
-        let req = http.request(url, { method: 'POST', headers: {
+        let req = (url.substr(0, 5) == 'https' ? https : http).request(url, { method: 'POST', headers: {
            'Content-Type': 'application/json',
            'Content-Length': body_text.length,
-        } }, (res) =>
+        }, ...(opts||{}) }, (res) =>
        {
            if (!req)
            {
@@ -16,6 +16,7 @@ const etcd_allow = new RegExp('^'+[
    'config/pools',
    'config/osd/[1-9]\\d*',
    'config/pgs', // old name
+    'config/user/.*',
    'pg/config',
    'config/inode/[1-9]\\d*/[1-9]\\d*',
    'osd/state/[1-9]\\d*',
@@ -45,7 +46,14 @@ const etcd_tree = {
            config_path: "/etc/vitastor/vitastor.conf",
            etcd_prefix: "/vitastor",
            // etcd connection - configurable online
-            etcd_address: "10.0.115.10:2379/v3",
+            etcd_address: "http://10.0.115.10:2379/v3",
+            etcd_client_cert: "",
+            etcd_client_key: "",
+            osd_etcd_client_cert: "",
+            osd_etcd_client_key: "",
+            mon_etcd_client_cert: "",
+            mon_etcd_client_key: "",
+            etcd_ca: "",
            // mon
            etcd_mon_ttl: 5, // min: 1
            etcd_mon_timeout: 1000, // ms. min: 0
@@ -201,6 +209,8 @@ const etcd_tree = {
                primary_affinity_tags?: 'nvme' | [ 'nvme', ... ],
                // scrub interval
                scrub_interval?: '30d',
+                // users allowed to create images in this pool
+                creator_group?: '',
            },
            ...
        }, */
@@ -217,10 +227,21 @@ const etcd_tree = {
                    parent_id?: <inode_t>,
                    readonly?: boolean,
                    deleted?: boolean,
+                    enc_key?: string,
+                    owner?: string,
+                    owner_group?: string,
+                    reader_group?: string,
                }
            }
        }, */
        inode: {},
+        /* user: {
+            <username>: {
+                type: 'osd'|'mon'|'admin'|'client',
+                groups: string[],
+            },
+        }, */
+        user: {},
    },
    osd: {
        state: {
@@ -0,0 +1,471 @@
+// AntiEtcd authentication filter for Vitastor
+// (c) Vitaliy Filippov, 2026
+// License: Mozilla Public License 2.0 or Vitastor Network Public License 1.1
+
+// Permissions are based on:
+// 1. Users.
+//    Stored in /vitastor/config/user/<username>.
+//    Has 2 properties:
+//    - type, one of: osd, mon, admin, client.
+//      osd, mon types should be used by OSDs/monitors.
+//      admin should be used for administrative access from vitastor-cli.
+//      client should be used for regular clients.
+//    - groups, a list of group names the user is included in.
+// 2. Images.
+//    Stored in /vitastor/config/inode/<pool>/<inode>. Has the following properties:
+//    - owner (user name)
+//    - owner_group (group name)
+//    - reader_group
+
+const static_perms = {
+    invalid: {
+        keys: {},
+        prefixes: {},
+    },
+    osd: {
+        keys: { '/pg/config': false },
+        prefixes: { '/osd/': true, '/pg/state/': true, '/pg/history/': true, '/pgstats/': true },
+    },
+    mon: {
+        keys: { '/pg/config': true, '/stats': true, '/history/last_clean_pgs': true },
+        prefixes: {
+            '/config/': false, '/osd/': false, '/mon/': true, '/pg/history/': true,
+            '/pgstats/': false, '/inode/stats/': true, '/pool/stats/': true,
+        },
+    },
+    admin: {
+        keys: { '/stats': false },
+        prefixes: {
+            '/config/': true, '/osd/': true, '/index/': true, '/pg/history/': true,
+            '/mon/': false, '/pg/': false, '/pgstats/': false, '/inode/stats/': false, '/pool/stats/': false,
+        },
+    },
+    client: {
+        keys: { '/config/global': false, '/config/node_placement': false, '/config/pools': false, '/pg/config': false },
+        prefixes: { '/osd/stats/': false, '/pg/state/': false, '/index/maxid/': false },
+    },
+};
+
+const api_perms = {
+    osd: { lease_grant: true, lease_revoke: true, lease_keepalive: true },
+    mon: { lease_grant: true, lease_revoke: true, lease_keepalive: true },
+    admin: { maintenance_status: true },
+    client: {},
+};
+
+class VitastorAuthFilter
+{
+    constructor(antietcd)
+    {
+        this.cfg = antietcd.cfg;
+        this.antietcd = antietcd;
+        this.prefix = this.cfg.vitastor_prefix || '/vitastor';
+        this.prefix_parts = this.prefix.split('/');
+    }
+
+    _get(path, decode)
+    {
+        let cur = this.antietcd.etctree.state;
+        path = path instanceof Array ? path : path.split('/');
+        for (const p of path)
+        {
+            if (!cur.children)
+            {
+                return null;
+            }
+            cur = cur.children[p];
+            if (!cur)
+            {
+                return null;
+            }
+        }
+        if (decode)
+        {
+            return this._decode(path, cur.value);
+        }
+        return cur;
+    }
+
+    _decode(path, cur)
+    {
+        if (!cur)
+        {
+            return null;
+        }
+        if (cur)
+        {
+            try
+            {
+                cur = JSON.parse(cur);
+            }
+            catch (e)
+            {
+                console.warn('Invalid JSON in '+(path instanceof Array ? path.join('/') : path)+': '+e);
+            }
+        }
+        return cur;
+    }
+
+    // userInfo: { name: string, type: string, perms: static_perms[type], groups: { [string]: true } }
+    _check_compare(check, userInfo, checked)
+    {
+        let key = String(check.key);
+        if (key.substr(0, this.prefix.length) !== this.prefix)
+        {
+            return false;
+        }
+        key = key.substr(this.prefix.length);
+        if (key in userInfo.perms.keys)
+        {
+            return true;
+        }
+        for (const pfx in userInfo.perms.prefixes)
+        {
+            if (key.substr(0, pfx.length) == pfx)
+            {
+                return true;
+            }
+        }
+        if (userInfo.type == 'client')
+        {
+            // Image permissions
+            if (key.substr(0, 14) == '/config/inode/')
+            {
+                // Allowed to check that a key does not exist
+                if (check.target == 'VERSION' && check.version == 0)
+                {
+                    checked['M'+key] = true;
+                    return true;
+                }
+                else if (check.target == 'MOD')
+                {
+                    const data = this._get(check.key);
+                    if (!data || data.mod_revision != check.mod_revision)
+                    {
+                        // Break check to trigger CAS failure
+                        check.mod_revision = '18446744073709551615'; // UINT64_MAX
+                        return true;
+                    }
+                    const inode = this._decode(check.key, data.value);
+                    if (inode && (inode.owner_group && userInfo.groups[inode.owner_group] ||
+                        inode.owner === userInfo.name))
+                    {
+                        checked['M'+key] = true;
+                        return true;
+                    }
+                }
+                return false;
+            }
+            if (key.substr(0, 13) == '/index/image/')
+            {
+                // Allowed to check that a key does not exist
+                if (check.target == 'VERSION' && check.version == 0)
+                {
+                    checked['M'+key] = true;
+                    return true;
+                }
+                else if (check.target == 'MOD')
+                {
+                    let data = this._get(check.key);
+                    if (!data || data.mod_revision != check.mod_revision)
+                    {
+                        // Break check to trigger CAS failure
+                        check.mod_revision = '18446744073709551615'; // UINT64_MAX
+                        return true;
+                    }
+                    data = this._decode(check.key, data.value);
+                    if (data)
+                    {
+                        const inode = this._get([ ...this.prefix_parts, 'config', 'inode', data.pool_id, data.id ], true);
+                        if (inode && (inode.owner_group && userInfo.groups[inode.owner_group] ||
+                            inode.owner === userInfo.name))
+                        {
+                            checked['M'+key] = true;
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+            if (key.substr(0, 13) == '/index/maxid/')
+            {
+                const pool_id = key.substr(13);
+                const pool_cfg = this._get([ ...this.prefix_parts, 'config', 'pools' ], true);
+                if (!pool_cfg || !pool_cfg[pool_id] || !pool_cfg[pool_id].creator_group || !userInfo.groups[pool_cfg[pool_id].creator_group])
+                {
+                    return false;
+                }
+                if (check.target == 'VERSION' && check.version == 0)
+                {
+                    checked['I'+parseInt(key.substr(13))+'_0'] = true;
+                    return true;
+                }
+                else if (check.target == 'MOD')
+                {
+                    const data = this._get(check.key);
+                    if (!data || data.mod_revision != check.mod_revision)
+                    {
+                        // Break check to trigger CAS failure
+                        check.mod_revision = '18446744073709551615'; // UINT64_MAX
+                        return true;
+                    }
+                    checked['I'+parseInt(key.substr(13))+'_'+data.value] = true;
+                    return true;
+                }
+                return false;
+            }
+        }
+        return false;
+    }
+
+    _check_read(kv, userInfo)
+    {
+        let key = String(kv.key);
+        if (key.substr(0, this.prefix.length) !== this.prefix)
+        {
+            return false;
+        }
+        key = key.substr(this.prefix.length);
+        if (key in userInfo.perms.keys)
+        {
+            return true;
+        }
+        for (const pfx in userInfo.perms.prefixes)
+        {
+            if (key.substr(0, pfx.length) == pfx)
+            {
+                return true;
+            }
+        }
+        if (userInfo.type == 'client')
+        {
+            // Image permissions
+            if (key.substr(0, 14) == '/config/inode/')
+            {
+                const inode = this._decode(kv.key, kv.value);
+                if (inode && (inode.reader_group && userInfo.groups[inode.reader_group] ||
+                    inode.owner_group && userInfo.groups[inode.owner_group] ||
+                    inode.owner === userInfo.name))
+                {
+                    return true;
+                }
+                return false;
+            }
+            if (key.substr(0, 13) == '/index/image/')
+            {
+                const data = this._decode(kv.key, kv.value);
+                const inode = this._get([ ...this.prefix_parts, 'config', 'inode', data.pool_id, data.id ], true);
+                if (inode && (inode.reader_group && userInfo.groups[inode.reader_group] ||
+                    inode.owner_group && userInfo.groups[inode.owner_group] ||
+                    inode.owner === userInfo.name))
+                {
+                    return true;
+                }
+                return false;
+            }
+        }
+        return false;
+    }
+
+    _check_write(put, userInfo, checked)
+    {
+        let key = String(put.key);
+        if (key.substr(0, this.prefix.length) !== this.prefix)
+        {
+            return false;
+        }
+        key = key.substr(this.prefix.length);
+        if (userInfo.perms.keys[key])
+        {
+            return true;
+        }
+        for (const pfx in userInfo.perms.prefixes)
+        {
+            if (userInfo.perms.prefixes[pfx] && key.substr(0, pfx.length) == pfx)
+            {
+                return true;
+            }
+        }
+        if (checked && userInfo.type == 'client')
+        {
+            if (key.substr(0, 13) == '/index/maxid/' &&
+                checked['I'+parseInt(key.substr(13))+'_'+(put.value-1)])
+            {
+                // Allowed to increment maxid
+                return true;
+            }
+            if (checked['M'+key])
+            {
+                // Allowed to modify known images with CAS checks
+                return true;
+            }
+        }
+        return false;
+    }
+
+    _check_req(req, userInfo, checked)
+    {
+        let r;
+        if ((r = (req.request_range || req.requestRange)))
+        {
+            // All range queries are allowed, but responses are filtered - it's simpler
+        }
+        else if ((r = (req.request_put || req.requestPut)))
+        {
+            if (!this._check_write(r, userInfo, checked))
+                return false;
+        }
+        else if ((r = (req.request_delete_range || req.requestDeleteRange)))
+        {
+            if (!r.range_end || r.range_end === r.key)
+            {
+                if (!this._check_write({ key: r.key }, userInfo))
+                    return false;
+            }
+            else
+            {
+                // All keys in range must satisfy prefix
+                r.range_end = String(r.range_end);
+                if (r.key.length != r.range_end.length ||
+                    r.key[r.key.length-1] != '/' ||
+                    r.range_end[r.range_end.length-1] != '0')
+                {
+                    return false;
+                }
+                let key = r.key.substr(this.prefix.length);
+                let found = false;
+                for (const pfx in userInfo.perms.prefixes)
+                {
+                    if (userInfo.perms.prefixes[pfx] && key.substr(0, pfx.length) == pfx)
+                    {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found)
+                    return false;
+            }
+        }
+        return true;
+    }
+
+    _get_user(username)
+    {
+        if (!username)
+        {
+            return null;
+        }
+        let userInfo = this._get([ ...this.prefix_parts, 'config', 'user', username ], true);
+        if (!userInfo)
+        {
+            userInfo = { type: 'client' };
+        }
+        userInfo.perms = static_perms[userInfo.type] || static_perms['invalid'];
+        userInfo.name = username;
+        if (userInfo.groups instanceof Array)
+        {
+            userInfo.groups = userInfo.groups.reduce((a, c) => { a[c] = true; return a; }, {});
+        }
+        else
+        {
+            userInfo.groups = {};
+        }
+        return userInfo;
+    }
+
+    filter_api(username, api/*, data*/)
+    {
+        if (username === 'root')
+        {
+            return true;
+        }
+        const userInfo = this._get([ ...this.prefix_parts, 'config', 'user', username ], true);
+        return userInfo && api_perms[userInfo.type] && api_perms[userInfo.type][api];
+    }
+
+    filter_txn(username, txn)
+    {
+        if (username === 'root')
+        {
+            return true;
+        }
+        const userInfo = this._get_user(username);
+        if (!userInfo)
+        {
+            return null;
+        }
+        const checked = {};
+        if (txn.compare)
+        {
+            for (const check of txn.compare)
+            {
+                if (!this._check_compare(check, userInfo, checked))
+                    return null;
+            }
+        }
+        // Special transactions:
+        // 1. create image: create config/inode and index/image, increment index/maxid/<pool> (with CAS)
+        // 2. create snapshot: same as create image but also rename previous to @snap
+        if (txn.success)
+        {
+            for (const req of txn.success)
+            {
+                if (!this._check_req(req, userInfo, checked))
+                    return null;
+            }
+        }
+        if (txn.failure)
+        {
+            for (const req of txn.failure)
+            {
+                if (!this._check_req(req, userInfo, null))
+                    return null;
+            }
+        }
+        return txn;
+    }
+
+    filter_txn_response(username, txn, res)
+    {
+        if (!res.responses || username === 'root')
+        {
+            return;
+        }
+        const userInfo = this._get_user(username);
+        if (!userInfo)
+        {
+            for (const resp of res.responses)
+            {
+                if (resp.response_range && resp.response_range.kvs)
+                {
+                    resp.response_range.kvs = [];
+                }
+            }
+            return;
+        }
+        for (const resp of res.responses)
+        {
+            if (resp.response_range && resp.response_range.kvs)
+            {
+                resp.response_range.kvs = resp.response_range.kvs.filter(kv => this._check_read(kv, userInfo));
+            }
+        }
+    }
+
+    filter_watch_message(username, msg)
+    {
+        if (!msg.result || !msg.result.events || username === 'root')
+        {
+            return;
+        }
+        const userInfo = this._get_user(username);
+        if (!userInfo)
+        {
+            msg.result.events = [];
+            return;
+        }
+        msg.result.events = msg.result.events.filter(ev => this._check_read(ev.kv, userInfo));
+    }
+}
+
+module.exports = VitastorAuthFilter;
@@ -11,7 +11,7 @@ WORKDIR /root
 RUN sed -i 's/enabled=0/enabled=1/' /etc/yum.repos.d/*.repo
 RUN dnf -y install epel-release dnf-plugins-core
 RUN dnf -y install https://vitastor.io/rpms/centos/10/vitastor-release-1.0-1.el10.noarch.rpm
-RUN dnf -y install gcc-c++ gperftools-devel fio nodejs rpm-build jerasure-devel isa-l-devel gf-complete-devel rdma-core-devel cmake libnl3-devel
+RUN dnf -y install gcc-c++ gperftools-devel fio nodejs rpm-build jerasure-devel isa-l-devel gf-complete-devel rdma-core-devel cmake libnl3-devel c-ares-devel
 RUN dnf download --source fio
 RUN rpm --nomd5 -i fio*.src.rpm
 RUN cd ~/rpmbuild/SPECS && dnf builddep -y --spec fio.spec
@@ -16,6 +16,7 @@ BuildRequires:  gf-complete-devel
 BuildRequires:  rdma-core-devel
 BuildRequires:  cmake
 BuildRequires:  libnl3-devel
+BuildRequires:  c-ares-devel
 Requires:       vitastor-osd = %{version}-%{release}
 Requires:       vitastor-mon = %{version}-%{release}
 Requires:       vitastor-client = %{version}-%{release}
@@ -15,7 +15,7 @@ RUN yum -y --enablerepo=extras install centos-release-scl epel-release yum-utils
 RUN perl -i -pe 's!mirrorlist=!#mirrorlist=!s; s!#\s*baseurl=http://mirror.centos.org!baseurl=http://vault.centos.org!' /etc/yum.repos.d/CentOS-SCLo-scl*.repo
 RUN yum -y install https://vitastor.io/rpms/centos/7/vitastor-release-1.0-1.el7.noarch.rpm
 RUN yum -y install devtoolset-9-gcc-c++ devtoolset-9-libatomic-devel gcc make cmake gperftools-devel \
-    fio rh-nodejs12 jerasure-devel libisa-l-devel gf-complete-devel rdma-core-devel libnl3-devel
+    fio rh-nodejs12 jerasure-devel libisa-l-devel gf-complete-devel rdma-core-devel libnl3-devel c-ares-devel
 RUN yumdownloader --disablerepo=centos-sclo-rh --source fio
 RUN rpm --nomd5 -i fio*.src.rpm
 RUN rm -f /etc/yum.repos.d/CentOS-Media.repo
@@ -17,6 +17,7 @@ BuildRequires:  gf-complete-devel
 BuildRequires:  rdma-core-devel
 BuildRequires:  cmake3
 BuildRequires:  libnl3-devel
+BuildRequires:  c-ares-devel
 Requires:       vitastor-osd = %{version}-%{release}
 Requires:       vitastor-mon = %{version}-%{release}
 Requires:       vitastor-client = %{version}-%{release}
@@ -13,7 +13,7 @@ RUN dnf -y install centos-release-advanced-virtualization epel-release dnf-plugi
 RUN sed -i 's/^mirrorlist=/#mirrorlist=/; s!#baseurl=.*!baseurl=http://vault.centos.org/centos/8.4.2105/virt/$basearch/$avdir/!; s!^baseurl=.*Source/.*!baseurl=http://vault.centos.org/centos/8.4.2105/virt/Source/advanced-virtualization/!' /etc/yum.repos.d/CentOS-Advanced-Virtualization.repo
 RUN yum -y install https://vitastor.io/rpms/centos/8/vitastor-release-1.0-1.el8.noarch.rpm
 RUN dnf -y install gcc-toolset-9 gcc-toolset-9-gcc-c++ gperftools-devel \
-    fio nodejs rpm-build jerasure-devel libisa-l-devel gf-complete-devel libibverbs-devel libarchive cmake libnl3-devel
+    fio nodejs rpm-build jerasure-devel libisa-l-devel gf-complete-devel libibverbs-devel libarchive cmake libnl3-devel c-ares-devel
 RUN dnf download --source fio
 RUN rpm --nomd5 -i fio*.src.rpm
 RUN cd ~/rpmbuild/SPECS && dnf builddep -y --enablerepo=powertools --spec fio.spec
@@ -16,6 +16,7 @@ BuildRequires:  gf-complete-devel
 BuildRequires:  rdma-core-devel
 BuildRequires:  cmake
 BuildRequires:  libnl3-devel
+BuildRequires:  c-ares-devel
 Requires:       vitastor-osd = %{version}-%{release}
 Requires:       vitastor-mon = %{version}-%{release}
 Requires:       vitastor-client = %{version}-%{release}
@@ -10,7 +10,7 @@ WORKDIR /root
 RUN sed -i 's/enabled=0/enabled=1/' /etc/yum.repos.d/*.repo
 RUN dnf -y install epel-release dnf-plugins-core
 RUN dnf -y install https://vitastor.io/rpms/centos/9/vitastor-release-1.0-1.el9.noarch.rpm
-RUN dnf -y install gcc-c++ gperftools-devel fio nodejs rpm-build jerasure-devel libisa-l-devel gf-complete-devel rdma-core-devel libarchive cmake libnl3-devel
+RUN dnf -y install gcc-c++ gperftools-devel fio nodejs rpm-build jerasure-devel libisa-l-devel gf-complete-devel rdma-core-devel libarchive cmake libnl3-devel c-ares-devel
 RUN dnf download --source fio
 RUN rpm --nomd5 -i fio*.src.rpm
 RUN cd ~/rpmbuild/SPECS && dnf builddep -y --spec fio.spec
@@ -16,6 +16,7 @@ BuildRequires:  gf-complete-devel
 BuildRequires:  rdma-core-devel
 BuildRequires:  cmake
 BuildRequires:  libnl3-devel
+BuildRequires:  c-ares-devel
 Requires:       vitastor-osd = %{version}-%{release}
 Requires:       vitastor-mon = %{version}-%{release}
 Requires:       vitastor-client = %{version}-%{release}
@@ -69,11 +69,21 @@ pkg_check_modules(ISAL libisal)
 if (ISAL_LIBRARIES)
 	add_definitions(-DWITH_ISAL)
 endif (ISAL_LIBRARIES)
+pkg_check_modules(ISAL_CRYPTO libisal_crypto)
+if (ISAL_CRYPTO_LIBRARIES)
+	add_definitions(-DWITH_ISAL_CRYPTO)
+endif (ISAL_CRYPTO_LIBRARIES)
 pkg_check_modules(RDMACM librdmacm)
 if (RDMACM_LIBRARIES)
 	add_definitions(-DWITH_RDMACM)
 endif (RDMACM_LIBRARIES)

+find_package(OpenSSL REQUIRED)
+add_definitions(-DWITH_OPENSSL)
+
+pkg_check_modules(CARES REQUIRED libcares)
+include_directories(${CARES_INCLUDE_DIRS})
+
 if (${WITH_SYSTEM_LIBURING})
 	pkg_check_modules(LIBURING REQUIRED liburing>=2.10)
 	include_directories(${LIBURING_INCLUDE_DIRS})
@@ -83,13 +83,17 @@ void blockstore_disk_t::parse_config(std::map<std::string, std::string> & config
    {
        data_csum_type = BLOCKSTORE_CSUM_CRC32C;
    }
+    else if (config["data_csum_type"] == "xxh3_32")
+    {
+        data_csum_type = BLOCKSTORE_CSUM_XXH3_32;
+    }
    else if (config["data_csum_type"] == "" || config["data_csum_type"] == "none")
    {
        data_csum_type = BLOCKSTORE_CSUM_NONE;
    }
    else
    {
-        throw std::runtime_error("data_csum_type="+config["data_csum_type"]+" is unsupported, only \"crc32c\" and \"none\" are supported");
+        throw std::runtime_error("data_csum_type="+config["data_csum_type"]+" is unsupported, only \"crc32c\", \"xxh3_32\" and \"none\" are supported");
    }
    csum_block_size = parse_size(config["csum_block_size"]);
    discard_on_start = config.find("discard_on_start") != config.end() &&
@@ -16,6 +16,7 @@
 #define BLOCKSTORE_CSUM_NONE 0
 // Lower byte of checksum type is its length
 #define BLOCKSTORE_CSUM_CRC32C 0x104
+#define BLOCKSTORE_CSUM_XXH3_32 0x204

 #define MOCK_DATA_FD 1000
 #define MOCK_META_FD 1001
@@ -12,6 +12,7 @@
 #include "blockstore_heap.h"
 #include "../util/allocator.h"
 #include "../util/crc32c.h"
+#include "../util/xxh_x86dispatch.h"
 #include "../util/malloc_or_die.h"

 #define BS_HEAP_FREE_MVCC 1
@@ -64,19 +65,19 @@ uint32_t blockstore_heap_t::get_simple_entry_size()
 uint32_t blockstore_heap_t::get_big_entry_size()
 {
    return sizeof(heap_big_write_t) + dsk->clean_entry_bitmap_size*2 +
-        (!dsk->data_csum_type ? 0 : dsk->data_block_size/dsk->csum_block_size * (dsk->data_csum_type & 0xFF));
+        (!dsk->csum_block_size ? 0 : dsk->data_block_size/dsk->csum_block_size * (dsk->data_csum_type & 0xFF));
 }

 uint32_t blockstore_heap_t::get_big_intent_entry_size()
 {
    return sizeof(heap_big_intent_t) + dsk->clean_entry_bitmap_size*2 +
-        (!dsk->data_csum_type ? 4 : dsk->data_block_size/dsk->csum_block_size * (dsk->data_csum_type & 0xFF));
+        (!dsk->csum_block_size ? 4 : dsk->data_block_size/dsk->csum_block_size * (dsk->data_csum_type & 0xFF));
 }

 uint32_t blockstore_heap_t::get_small_entry_size(uint32_t offset, uint32_t len)
 {
    return sizeof(heap_small_write_t) + dsk->clean_entry_bitmap_size +
-        (!dsk->data_csum_type ? 4 : (dsk->data_csum_type & 0xFF) *
+        (!dsk->csum_block_size ? 4 : (dsk->data_csum_type & 0xFF) *
            ((offset+len+dsk->csum_block_size-1)/dsk->csum_block_size - offset/dsk->csum_block_size));
 }

@@ -91,7 +92,7 @@ uint32_t blockstore_heap_t::get_csum_size(heap_entry_t *wr)

 uint32_t blockstore_heap_t::get_csum_size(uint32_t entry_type, uint32_t offset, uint32_t len)
 {
-    if (!dsk->data_csum_type)
+    if (!dsk->csum_block_size)
    {
        return 0;
    }
@@ -214,15 +215,24 @@ void heap_entry_t::set_big_location(blockstore_heap_t *heap, uint64_t location)
    big().block_num = location / heap->dsk->data_block_size;
 }

-uint32_t heap_entry_t::calc_crc32c()
+uint32_t heap_entry_t::calc_checksum(blockstore_disk_t *dsk)
 {
-    auto old_crc32c = crc32c;
-    crc32c = 0;
-    uint32_t res = ::crc32c(0, (uint8_t*)this, size);
-    crc32c = old_crc32c;
+    auto old_checksum = checksum;
+    checksum = 0;
+    uint32_t res = 0;
+    if (dsk->data_csum_type == BLOCKSTORE_CSUM_XXH3_32)
+        res = (uint32_t)XXH3_64bits(this, size);
+    else
+        res = ::crc32c(0, (uint8_t*)this, size);
+    checksum = old_checksum;
    return res;
 }

+uint32_t heap_entry_t::calc_checksum(blockstore_heap_t *heap)
+{
+    return calc_checksum(heap->dsk);
+}
+
 uint64_t blockstore_heap_t::get_pg_id(inode_t inode, uint64_t stripe)
 {
    uint64_t pg_num = 0;
@@ -380,12 +390,12 @@ corrupted_object:
                goto corrupted_object;
            }
            // Verify crc
-            uint32_t expected_crc32c = wr->calc_crc32c();
-            if (wr->crc32c != expected_crc32c)
+            uint32_t expected_checksum = wr->calc_checksum(this);
+            if (wr->checksum != expected_checksum)
            {
-                fprintf(stderr, "Error: entry %jx:%jx v%ju l%ju in metadata block %u at %u is corrupt (crc32c mismatch: expected %08x, got %08x). ",
+                fprintf(stderr, "Error: entry %jx:%jx v%ju l%ju in metadata block %u at %u is corrupt (checksum mismatch: expected %08x, got %08x). ",
                    wr->inode, wr->stripe, wr->version, wr->lsn,
-                    block_num, block_offset, expected_crc32c, wr->crc32c);
+                    block_num, block_offset, expected_checksum, wr->checksum);
                goto corrupted_object;
            }
            // Verify offset & len
@@ -934,7 +944,11 @@ bool blockstore_heap_t::calc_checksums(heap_entry_t *wr, uint8_t *data, bool set
            len = wr->big_intent().len;
        else
            assert(0);
-        uint32_t real_csum = crc32c(0, data, len);
+        uint32_t real_csum = 0;
+        if (dsk->data_csum_type == BLOCKSTORE_CSUM_XXH3_32)
+            real_csum = (uint32_t)XXH3_64bits(data, len);
+        else
+            real_csum = crc32c(0, data, len);
        if (set)
        {
            *wr_csum = real_csum;
@@ -984,11 +998,26 @@ static uint32_t crc32c_iter(uint32_t prev_crc, const std::function<uint8_t*(uint
    return prev_crc;
 }

+static void xxh3_iter(XXH3_state_t* xxh3_state, const std::function<uint8_t*(uint32_t start, uint32_t & len)> & next, uint32_t pos, uint32_t size)
+{
+    uint32_t cur_len = 0;
+    while (size > 0)
+    {
+        uint8_t *data = next(pos, cur_len);
+        assert(data);
+        cur_len = (cur_len < size ? cur_len : size);
+        XXH3_64bits_update(xxh3_state, data, cur_len);
+        pos += cur_len;
+        size -= cur_len;
+    }
+}
+
 bool blockstore_heap_t::calc_block_checksums(uint32_t *block_csums, uint8_t *bitmap,
    uint32_t start, uint32_t end, std::function<uint8_t*(uint32_t start, uint32_t & len)> next,
    bool set, std::function<void(uint32_t, uint32_t, uint32_t)> bad_block_cb)
 {
    bool res = true;
+    XXH3_state_t* xxh3_state = NULL;
    uint32_t pos = start;
    uint32_t block_end = (start/dsk->csum_block_size + 1)*dsk->csum_block_size;
    uint32_t block_crc = 0;
@@ -1005,42 +1034,89 @@ bool blockstore_heap_t::calc_block_checksums(uint32_t *block_csums, uint8_t *bit
                    pos += dsk->bitmap_granularity;
                // zero padding at the beginning or at the end of the block is not counted
                if (pos > prev && prev > 0 && pos < block_end)
-                    block_crc = crc32c_pad(block_crc, NULL, 0, pos-prev, 0);
+                {
+                    if (dsk->data_csum_type == BLOCKSTORE_CSUM_XXH3_32)
+                    {
+                        if (!xxh3_state)
+                        {
+                            xxh3_state = XXH3_createState();
+                            XXH3_64bits_reset(xxh3_state);
+                        }
+                        uint32_t zeropad = pos-prev;
+                        while (zeropad > 0)
+                        {
+                            uint32_t zerolen = zeropad > 4096 ? 4096 : zeropad;
+                            XXH3_64bits_update(xxh3_state, zero_page, zerolen);
+                            zeropad -= zerolen;
+                        }
+                    }
+                    else
+                        block_crc = crc32c_pad(block_crc, NULL, 0, pos-prev, 0);
+                }
                prev = pos;
                while (pos < end && pos < block_end && (bitmap[pos/dsk->bitmap_granularity/8] & (1 << ((pos/dsk->bitmap_granularity) % 8))))
                    pos += dsk->bitmap_granularity;
                if (pos > prev)
                {
                    isset = true;
-                    block_crc = crc32c_iter(block_crc, next, prev, pos-prev);
+                    if (dsk->data_csum_type == BLOCKSTORE_CSUM_XXH3_32)
+                    {
+                        if (!xxh3_state)
+                        {
+                            xxh3_state = XXH3_createState();
+                            XXH3_64bits_reset(xxh3_state);
+                        }
+                        xxh3_iter(xxh3_state, next, prev, pos-prev);
+                    }
+                    else
+                        block_crc = crc32c_iter(block_crc, next, prev, pos-prev);
                }
                prev = pos;
            }
        }
        else
        {
-            block_crc = crc32c_iter(block_crc, next, pos, (end > block_end ? block_end : end)-pos);
+            if (dsk->data_csum_type == BLOCKSTORE_CSUM_XXH3_32)
+            {
+                if (!xxh3_state)
+                {
+                    xxh3_state = XXH3_createState();
+                    XXH3_64bits_reset(xxh3_state);
+                }
+                xxh3_iter(xxh3_state, next, pos, (end > block_end ? block_end : end)-pos);
+            }
+            else
+                block_crc = crc32c_iter(block_crc, next, pos, (end > block_end ? block_end : end)-pos);
            pos = (end > block_end ? block_end : end);
            isset = true;
        }
+        if (dsk->data_csum_type == BLOCKSTORE_CSUM_XXH3_32 && xxh3_state)
+        {
+            block_crc = (uint32_t)XXH3_64bits_digest(xxh3_state);
+            XXH3_64bits_reset(xxh3_state);
+        }
        if (set)
        {
            *block_csums = block_crc;
        }
        else if (isset && block_crc != *block_csums)
        {
+            res = false;
            if (bad_block_cb)
-            {
                bad_block_cb(blk_start, *block_csums, block_crc);
-                res = false;
-            }
            else
-                return false;
+                break;
        }
        block_end += dsk->csum_block_size;
        block_crc = 0;
        block_csums++;
    }
+    if (dsk->data_csum_type == BLOCKSTORE_CSUM_XXH3_32 && xxh3_state)
+    {
+        block_crc = (uint32_t)XXH3_64bits_digest(xxh3_state);
+        XXH3_freeState(xxh3_state);
+        xxh3_state = NULL;
+    }
    return res;
 }

@@ -1399,7 +1475,7 @@ int blockstore_heap_t::add_entry(uint32_t wr_size, uint32_t *modified_block,
    insert_list_item(li);
    li->block_num = block_num;
    new_wr->size = wr_size;
-    new_wr->crc32c = new_wr->calc_crc32c();
+    new_wr->checksum = new_wr->calc_checksum(this);
    return 0;
 }

@@ -1459,7 +1535,7 @@ int blockstore_heap_t::add_big_write(object_id oid, heap_entry_t *old_head, bool
            memset(wr->get_ext_bitmap(this), 0, dsk->clean_entry_bitmap_size);
        memset(wr->get_int_bitmap(this), 0, dsk->clean_entry_bitmap_size);
        bitmap_set(wr->get_int_bitmap(this), offset, len, dsk->bitmap_granularity);
-        if (dsk->data_csum_type)
+        if (dsk->csum_block_size)
        {
            memset(wr->get_checksums(this), 0, get_csum_size(wr));
            calc_checksums(wr, (uint8_t*)data, true, offset, len);
@@ -1488,7 +1564,7 @@ int blockstore_heap_t::add_redirect_intent(object_id oid, heap_entry_t **obj_ptr
            memset(wr->get_ext_bitmap(this), 0, dsk->clean_entry_bitmap_size);
        memset(wr->get_int_bitmap(this), 0, dsk->clean_entry_bitmap_size);
        bitmap_set(wr->get_int_bitmap(this), offset, len, dsk->bitmap_granularity);
-        if (dsk->data_csum_type)
+        if (dsk->csum_block_size)
            memset(wr->get_checksums(this), 0, get_csum_size(wr));
        calc_checksums(wr, (uint8_t*)data, true);
        *obj_ptr = wr;
@@ -1526,7 +1602,7 @@ int blockstore_heap_t::add_big_intent(object_id oid, heap_entry_t **obj_ptr, uin
            memcpy(wr->get_ext_bitmap(this), obj->get_ext_bitmap(this), dsk->clean_entry_bitmap_size);
        memcpy(wr->get_int_bitmap(this), obj->get_int_bitmap(this), dsk->clean_entry_bitmap_size);
        bitmap_set(wr->get_int_bitmap(this), offset, len, dsk->bitmap_granularity);
-        if (dsk->data_csum_type)
+        if (dsk->csum_block_size)
        {
            if (checksums)
                memcpy(wr->get_checksums(this), checksums, get_csum_size(wr));
@@ -1573,7 +1649,7 @@ int blockstore_heap_t::add_compact(heap_entry_t *obj, uint64_t compact_version,
        new_wr->set_big_location(this, compact_location);
        memcpy(new_wr->get_int_bitmap(this), new_int_bitmap, dsk->clean_entry_bitmap_size);
        memcpy(new_wr->get_ext_bitmap(this), new_ext_bitmap, dsk->clean_entry_bitmap_size);
-        if (dsk->data_csum_type && new_csums)
+        if (dsk->csum_block_size && new_csums)
            memcpy(new_wr->get_checksums(this), new_csums, dsk->data_block_size/dsk->csum_block_size*(dsk->data_csum_type & 0xFF));
    });
 }
@@ -43,7 +43,7 @@ struct __attribute__((__packed__)) heap_entry_t
 {
    uint16_t size;
    uint16_t entry_type;
-    uint32_t crc32c;
+    uint32_t checksum;
    uint64_t lsn;
    uint64_t inode;
    uint64_t stripe;
@@ -69,7 +69,8 @@ struct __attribute__((__packed__)) heap_entry_t
    uint32_t *get_checksum(blockstore_heap_t *heap);
    uint64_t big_location(blockstore_heap_t *heap);
    void set_big_location(blockstore_heap_t *heap, uint64_t location);
-    uint32_t calc_crc32c();
+    uint32_t calc_checksum(blockstore_heap_t *heap);
+    uint32_t calc_checksum(blockstore_disk_t *dsk);
 };

 struct __attribute__((__packed__)) heap_small_write_t
@@ -80,7 +81,7 @@ struct __attribute__((__packed__)) heap_small_write_t
    uint32_t offset;
    uint32_t len;

-    // Also includes 1 bitmap and 1 crc32c after the bitmap if checksums are disabled
+    // Also includes 1 bitmap and 1 checksum after the bitmap if block checksums are disabled
 };

 struct __attribute__((__packed__)) heap_big_write_t
@@ -98,7 +99,7 @@ struct __attribute__((__packed__)) heap_big_intent_t
    uint32_t offset;
    uint32_t len;

-    // Also includes 2 bitmaps and 1 crc32c if checksums are disabled
+    // Also includes 2 bitmaps and 1 checksums if block checksums are disabled
 };

 struct __attribute__((__packed__)) heap_list_item_t
@@ -12,11 +12,11 @@ if (RDMACM_LIBRARIES)
 	set(MSGR_RDMACM "msgr_rdmacm.cpp")
 endif (RDMACM_LIBRARIES)
 add_library(vitastor_common STATIC
-	../util/epoll_manager.cpp etcd_state_client.cpp messenger.cpp ../util/addr_util.cpp
-	msgr_stop.cpp msgr_op.cpp msgr_send.cpp msgr_receive.cpp ../util/ringloop.cpp ../../json11/json11.cpp
+	../util/epoll_manager.cpp etcd_state_client.cpp messenger.cpp ../util/addr_util.cpp ../util/xxh_x86dispatch.c ../util/openssl_util.cpp
+	msgr_encrypt.cpp msgr_handshake.cpp msgr_stop.cpp msgr_op.cpp msgr_send.cpp msgr_receive.cpp ../util/ringloop.cpp ../../json11/json11.cpp
 	http_client.cpp osd_ops.cpp pg_states.cpp ../util/timerfd_manager.cpp ../util/str_util.cpp ../util/json_util.cpp ${MSGR_RDMA} ${MSGR_RDMACM}
 )
-target_link_libraries(vitastor_common pthread)
+target_link_libraries(vitastor_common pthread ${OPENSSL_LIBRARIES} ${CARES_LIBRARIES} ${ISAL_CRYPTO_LIBRARIES})
 target_compile_options(vitastor_common PUBLIC -fPIC)

 # libvitastor_client.so
@@ -24,6 +24,7 @@ add_library(vitastor_client SHARED
 	cluster_client.cpp
 	cluster_client_list.cpp
 	cluster_client_wb.cpp
+	cluster_client_icache.cpp
 	vitastor_c.cpp
 )
 set_target_properties(vitastor_client PROPERTIES PUBLIC_HEADER "client/vitastor_c.h")
@@ -33,6 +34,8 @@ target_link_libraries(vitastor_client
 	${LIBURING_LIBRARIES}
 	${IBVERBS_LIBRARIES}
 	${RDMACM_LIBRARIES}
+	${OPENSSL_LIBRARIES}
+	${ISAL_CRYPTO_LIBRARIES}
 )
 set_target_properties(vitastor_client PROPERTIES VERSION ${VITASTOR_VERSION} SOVERSION 0)
 configure_file(vitastor.pc.in vitastor.pc @ONLY)
@@ -98,9 +101,10 @@ endif (${WITH_QEMU})
 add_executable(test_cluster_client
 	EXCLUDE_FROM_ALL
 	../test/test_cluster_client.cpp
-	pg_states.cpp osd_ops.cpp cluster_client.cpp cluster_client_list.cpp cluster_client_wb.cpp msgr_op.cpp ../test/mock/messenger.cpp msgr_stop.cpp
-	etcd_state_client.cpp ../util/timerfd_manager.cpp ../util/addr_util.cpp ../util/str_util.cpp ../util/json_util.cpp ../../json11/json11.cpp
+	pg_states.cpp osd_ops.cpp cluster_client.cpp cluster_client_list.cpp cluster_client_wb.cpp cluster_client_icache.cpp msgr_op.cpp ../test/mock/messenger.cpp msgr_stop.cpp msgr_encrypt.cpp
+	etcd_state_client.cpp ../util/timerfd_manager.cpp ../util/addr_util.cpp ../util/str_util.cpp ../util/json_util.cpp ../util/xxh_x86dispatch.c ../util/openssl_util.cpp ../../json11/json11.cpp
 )
+target_link_libraries(test_cluster_client ${OPENSSL_LIBRARIES} ${ISAL_CRYPTO_LIBRARIES})
 target_compile_definitions(test_cluster_client PUBLIC -D__MOCK__)
 target_include_directories(test_cluster_client BEFORE PUBLIC ${CMAKE_SOURCE_DIR}/src/test/mock)
 add_dependencies(build_tests test_cluster_client)
@@ -51,7 +51,7 @@ cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd
        msgr.stop_client(op->client_id);
        delete op;
    };
-    msgr.parse_config(config);
+    msgr.parse_config(config, true);

    st_cli.tfd = tfd;
    st_cli.on_load_config_hook = [this](json11::Json::object & cfg) { on_load_config_hook(cfg); };
@@ -62,6 +62,7 @@ cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd
    st_cli.on_change_node_placement_hook = [this]() { on_change_node_placement_hook(); };
    st_cli.on_load_pgs_hook = [this](bool success) { on_load_pgs_hook(success); };
    st_cli.on_reload_hook = [this]() { st_cli.load_global_config(); };
+    st_cli.on_inode_change_hook = [this](uint64_t inode, bool removed) { on_change_inode_hook(inode, removed); };

    st_cli.parse_config(config);
    st_cli.infinite_start = false;
@@ -70,13 +71,11 @@ cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd
        st_cli.infinite_start = config["client_infinite_start"].bool_value();
    }
    st_cli.load_global_config();
-
-    scrap_buffer_size = SCRAP_BUFFER_SIZE;
-    scrap_buffer = malloc_or_die(scrap_buffer_size);
 }

 cluster_client_t::~cluster_client_t()
 {
+    vault_destroy();
    if (retry_timeout_id >= 0)
    {
        tfd->clear_timer(retry_timeout_id);
@@ -94,7 +93,6 @@ cluster_client_t::~cluster_client_t()
    {
        ringloop->unregister_consumer(&consumer);
    }
-    free(scrap_buffer);
    delete wb;
    wb = NULL;
 }
@@ -481,7 +479,9 @@ void cluster_client_t::on_load_config_hook(json11::Json::object & etcd_global_co
        self_tree_metrics.clear();
        client_hostname = new_hostname;
    }
-    msgr.parse_config(config);
+    // vault
+    vault_parse_config();
+    msgr.parse_config(config, false);
    st_cli.parse_config(config);
    st_cli.load_pgs();
 }
@@ -607,6 +607,9 @@ void cluster_client_t::on_change_pool_config_hook()
            pg_counts[pool_item.first] = pool_item.second.real_pg_count;
        }
    }
+    inode_cache.clear();
+    inode_cache_children.clear();
+    vault_keys.clear();
    continue_ops();
 }

@@ -673,6 +676,10 @@ bool cluster_client_t::flush()
 {
    if (!ringloop)
    {
+        if (vault_loading)
+        {
+            return false;
+        }
        if (wb->writeback_queue.size())
        {
            wb->start_writebacks(this, 0);
@@ -695,7 +702,7 @@ bool cluster_client_t::flush()
        sync_done = true;
    };
    execute(sync);
-    while (!sync_done)
+    while (!sync_done || vault_loading)
    {
        ringloop->loop();
        if (!sync_done)
@@ -958,10 +965,40 @@ bool cluster_client_t::check_rw(cluster_op_t *op)
    {
        op->flags |= OP_IMMEDIATE_COMMIT;
    }
+    bool searched = false;
+    std::shared_ptr<inode_cache_t> icache;
+    if (op->opcode == OSD_OP_READ || op->opcode == OSD_OP_WRITE)
+    {
+        if (!searched)
+        {
+            icache = inode_cache_get(op->inode);
+            searched = true;
+        }
+        if (icache && icache->has_parent_loop && op->opcode == OSD_OP_READ)
+        {
+            op->retval = -EINVAL;
+            auto cb = std::move(op->callback);
+            cb(op);
+            return false;
+        }
+        if (icache && icache->op_enc)
+        {
+            // Use shared_ptr aliasing to attach op_enc to the inode cache entry
+            op->enc = std::shared_ptr<osd_op_enc_t>(icache, icache->op_enc);
+        }
+        else
+            op->enc.reset();
+    }
+    else
+        op->enc.reset();
    if ((op->opcode == OSD_OP_WRITE || op->opcode == OSD_OP_DELETE) && !(op->flags & OSD_OP_IGNORE_READONLY))
    {
-        auto ino_it = st_cli.inode_config.find(op->inode);
-        if (ino_it != st_cli.inode_config.end() && ino_it->second.readonly)
+        if (!searched)
+        {
+            icache = inode_cache_get(op->inode);
+            searched = true;
+        }
+        if (icache && icache->readonly)
        {
            op->retval = -EROFS;
            auto cb = std::move(op->callback);
@@ -972,33 +1009,39 @@ bool cluster_client_t::check_rw(cluster_op_t *op)
    op->deoptimise_snapshot = false;
    if (enable_writeback && (op->opcode == OSD_OP_READ || op->opcode == OSD_OP_READ_BITMAP || op->opcode == OSD_OP_READ_CHAIN_BITMAP))
    {
-        auto ino_it = st_cli.inode_config.find(op->inode);
-        if (ino_it != st_cli.inode_config.end())
+        if (!searched)
        {
-            int chain_size = 0;
-            while (ino_it != st_cli.inode_config.end() && ino_it->second.parent_id)
+            icache = inode_cache_get(op->inode);
+            searched = true;
+        }
+        if (icache)
+        {
+            for (auto & parent: icache->chain)
            {
-                // Check for loops - FIXME check it in etcd_state_client
-                if (ino_it->second.parent_id == op->inode ||
-                    chain_size > st_cli.inode_config.size())
-                {
-                    op->retval = -EINVAL;
-                    auto cb = std::move(op->callback);
-                    cb(op);
-                    return false;
-                }
-                if (INODE_POOL(ino_it->second.parent_id) == INODE_POOL(ino_it->first) &&
-                    wb->has_inode(ino_it->second.parent_id))
+                if (INODE_POOL(parent) == INODE_POOL(op->inode) && wb->has_inode(parent))
                {
                    // Deoptimise reads - we have dirty data for one of the parent layer(s).
                    op->deoptimise_snapshot = true;
                    break;
                }
-                chain_size++;
-                ino_it = st_cli.inode_config.find(ino_it->second.parent_id);
            }
        }
    }
+    if (icache && icache->err_code)
+    {
+        if (icache->err_code == EPERM)
+        {
+            op->retval = -EPERM;
+            auto cb = std::move(op->callback);
+            cb(op);
+            return false;
+        }
+        else if (icache->err_code == EAGAIN)
+        {
+            key_wait_ops.push_back(op);
+            return false;
+        }
+    }
    return true;
 }

@@ -1121,31 +1164,33 @@ resume_2:
        // because if some operations were invalid for the new PG count we'd get errors
        if (op->opcode == OSD_OP_READ || op->opcode == OSD_OP_READ_CHAIN_BITMAP)
        {
-            // Check parent inode
-            auto ino_it = st_cli.inode_config.find(op->cur_inode);
-            // Skip parents from the same pool
-            int skipped = 0;
-            while (!op->deoptimise_snapshot &&
-                ino_it != st_cli.inode_config.end() && ino_it->second.parent_id &&
-                INODE_POOL(ino_it->second.parent_id) == INODE_POOL(op->cur_inode))
+            uint64_t next_inode = 0;
+            auto icache = inode_cache_get(op->cur_inode);
+            if (icache)
            {
-                // Check for loops - FIXME check it in etcd_state_client
-                if (ino_it->second.parent_id == op->inode ||
-                    skipped > st_cli.inode_config.size())
+                if (icache->has_parent_loop)
                {
                    op->retval = -EINVAL;
                    erase_op(op);
                    return 1;
                }
-                skipped++;
-                ino_it = st_cli.inode_config.find(ino_it->second.parent_id);
+                if (op->deoptimise_snapshot)
+                {
+                    if (icache->chain.size() > 1)
+                        next_inode = icache->chain[1];
+                }
+                else
+                {
+                    if (icache->other_pool_parent_id)
+                        next_inode = icache->other_pool_parent_id;
+                }
            }
-            if (ino_it != st_cli.inode_config.end() &&
-                ino_it->second.parent_id &&
-                ino_it->second.parent_id != op->inode)
+            if (next_inode)
            {
                // Continue reading from the parent inode
-                op->cur_inode = ino_it->second.parent_id;
+                icache = inode_cache_get(next_inode);
+                op->cur_inode = next_inode;
+                op->enc = (icache && icache->op_enc ? std::shared_ptr<osd_op_enc_t>(icache, icache->op_enc) : nullptr);
                op->parts.clear();
                op->done_count = 0;
                goto resume_0;
@@ -1196,7 +1241,7 @@ resume_2:
    return 0;
 }

-static void add_iov(int size, bool skip, cluster_op_t *op, int &iov_idx, size_t &iov_pos, osd_op_buf_list_t &iov, void *scrap, int scrap_len)
+static void add_iov(int size, int skip, cluster_op_t *op, int &iov_idx, size_t &iov_pos, osd_op_buf_list_t &iov)
 {
    int left = size;
    while (left > 0 && iov_idx < op->iov.count)
@@ -1204,7 +1249,7 @@ static void add_iov(int size, bool skip, cluster_op_t *op, int &iov_idx, size_t
        int cur_left = op->iov.buf[iov_idx].iov_len - iov_pos;
        if (cur_left < left)
        {
-            if (!skip)
+            if (skip == 0)
            {
                iov.push_back((uint8_t*)op->iov.buf[iov_idx].iov_base + iov_pos, cur_left);
            }
@@ -1214,7 +1259,7 @@ static void add_iov(int size, bool skip, cluster_op_t *op, int &iov_idx, size_t
        }
        else
        {
-            if (!skip)
+            if (skip == 0)
            {
                iov.push_back((uint8_t*)op->iov.buf[iov_idx].iov_base + iov_pos, left);
            }
@@ -1223,16 +1268,10 @@ static void add_iov(int size, bool skip, cluster_op_t *op, int &iov_idx, size_t
        }
    }
    assert(left == 0);
-    if (skip && scrap_len > 0)
+    if (skip == 1)
    {
-        // All skipped ranges are read into the same useless buffer
-        left = size;
-        while (left > 0)
-        {
-            int cur_left = scrap_len < left ? scrap_len : left;
-            iov.push_back(scrap, cur_left);
-            left -= cur_left;
-        }
+        // data read into a NULL buffer will be discarded by messenger
+        iov.push_back(NULL, size);
    }
 }

@@ -1252,7 +1291,11 @@ void cluster_client_t::slice_rw(cluster_op_t *op)
        // Allocate memory for the bitmap
        unsigned object_bitmap_size = ((op->len / pool_cfg.bitmap_granularity + 7) / 8);
        object_bitmap_size = (object_bitmap_size < 8 ? 8 : object_bitmap_size);
-        unsigned bitmap_mem = object_bitmap_size + (pool_cfg.data_block_size / pool_cfg.bitmap_granularity / 8 * pg_data_size) * op->parts.size();
+        unsigned bitmap_mem = object_bitmap_size +
+            op->parts.size() * pg_data_size *
+            (pool_cfg.data_block_size / pool_cfg.bitmap_granularity / 8
+            // read chain_info - max 4 bytes per block
+            + (op->enc ? osd_op_rw_t::chain_info_bytes(op->enc->chain_size)*op->len/pool_cfg.bitmap_granularity : 0));
        if (!op->bitmap_buf || op->bitmap_buf_size < bitmap_mem)
        {
            op->bitmap_buf = realloc_or_die(op->bitmap_buf, bitmap_mem);
@@ -1294,10 +1337,10 @@ void cluster_client_t::slice_rw(cluster_op_t *op)
                        {
                            begin = cur;
                            // Just advance iov_idx & iov_pos
-                            add_iov(cur-prev, true, op, iov_idx, iov_pos, op->parts[i].iov, NULL, 0);
+                            add_iov(cur-prev, 2, op, iov_idx, iov_pos, op->parts[i].iov);
                        }
                        else
-                            add_iov(cur-prev, skip_prev, op, iov_idx, iov_pos, op->parts[i].iov, scrap_buffer, scrap_buffer_size);
+                            add_iov(cur-prev, skip_prev ? 1 : 0, op, iov_idx, iov_pos, op->parts[i].iov);
                    }
                    skip_prev = skip;
                    prev = cur;
@@ -1308,11 +1351,11 @@ void cluster_client_t::slice_rw(cluster_op_t *op)
            if (skip_prev)
            {
                // Just advance iov_idx & iov_pos
-                add_iov(end-prev, true, op, iov_idx, iov_pos, op->parts[i].iov, NULL, 0);
+                add_iov(end-prev, 2, op, iov_idx, iov_pos, op->parts[i].iov);
                end = prev;
            }
            else
-                add_iov(cur-prev, skip_prev, op, iov_idx, iov_pos, op->parts[i].iov, scrap_buffer, scrap_buffer_size);
+                add_iov(cur-prev, skip_prev ? 1 : 0, op, iov_idx, iov_pos, op->parts[i].iov);
            if (end == begin)
            {
                op->done_count++;
@@ -1321,7 +1364,7 @@ void cluster_client_t::slice_rw(cluster_op_t *op)
        }
        else if (op->opcode != OSD_OP_READ_BITMAP && op->opcode != OSD_OP_READ_CHAIN_BITMAP && op->opcode != OSD_OP_DELETE)
        {
-            add_iov(end-begin, false, op, iov_idx, iov_pos, op->parts[i].iov, NULL, 0);
+            add_iov(end-begin, 0, op, iov_idx, iov_pos, op->parts[i].iov);
        }
        op->parts[i].parent = op;
        op->parts[i].offset = begin;
@@ -1407,9 +1450,12 @@ int cluster_client_t::try_send(cluster_op_t *op, int i, std::function<void(osd_o
            osd_client_t *cl = peer_it->second;
            part->flags |= PART_SENT|PART_VALID;
            op->inflight_count++;
-            uint64_t pg_bitmap_size = (pool_cfg.data_block_size / pool_cfg.bitmap_granularity / 8) * (
-                pool_cfg.scheme == POOL_SCHEME_REPLICATED ? 1 : pool_cfg.pg_size-pool_cfg.parity_chunks
-            );
+            uint32_t pg_data_size = (pool_cfg.scheme == POOL_SCHEME_REPLICATED ? 1 : pool_cfg.pg_size-pool_cfg.parity_chunks);
+            uint64_t pg_bitmap_size = pg_data_size * (pool_cfg.data_block_size / pool_cfg.bitmap_granularity / 8
+                // read chain_info - max 4 bytes per block
+                + (op->opcode == OSD_OP_READ && op->enc
+                    ? osd_op_rw_t::chain_info_bytes(op->enc->chain_size)*pool_cfg.data_block_size/pool_cfg.bitmap_granularity
+                    : 0));
            uint64_t meta_rev = 0;
            if (op->opcode != OSD_OP_READ_BITMAP && op->opcode != OSD_OP_DELETE && !op->deoptimise_snapshot)
            {
@@ -1428,6 +1474,7 @@ int cluster_client_t::try_send(cluster_op_t *op, int i, std::function<void(osd_o
                    .inode = op->cur_inode,
                    .offset = part->offset,
                    .len = part->len,
+                    .flags = op->opcode == OSD_OP_READ && op->enc && !op->deoptimise_snapshot ? OSD_OP_RETURN_CHAIN : 0,
                    .meta_revision = meta_rev,
                    .version = op->opcode == OSD_OP_WRITE || op->opcode == OSD_OP_DELETE ? op->version : 0,
                } },
@@ -1435,6 +1482,7 @@ int cluster_client_t::try_send(cluster_op_t *op, int i, std::function<void(osd_o
                    ? (uint8_t*)op->part_bitmaps + pg_bitmap_size*i : NULL),
                .bitmap_len = (unsigned)(op->opcode == OSD_OP_READ || op->opcode == OSD_OP_READ_BITMAP || op->opcode == OSD_OP_READ_CHAIN_BITMAP
                    ? pg_bitmap_size : 0),
+                .enc = op->enc,
                .callback = cb ? cb : [this, part](osd_op_t *op_part)
                {
                    handle_op_part(part);
@@ -1552,6 +1600,9 @@ static inline void mem_or(void *res, const void *r2, unsigned int len)
    }
 }

+// Error priority: others > EPERM > EIO > ENOSPC > ETIMEDOUT > EPIPE
+#define ERR_PRIO(e) (((e) == -EPERM ? 5 : ((e) == -EIO ? 4 : ((e) == -ENOSPC ? 3 : ((e) == -ETIMEDOUT ? 2 : ((e) == -EPIPE ? 1 : (!(e) ? 0 : 10)))))))
+
 void cluster_client_t::handle_op_part(cluster_op_part_t *part)
 {
    cluster_op_t *op = part->parent;
@@ -1560,15 +1611,10 @@ void cluster_client_t::handle_op_part(cluster_op_part_t *part)
    {
        // Operation failed, retry
        part->flags |= PART_ERROR;
-        if (!op->retval || op->retval == -EPIPE ||
-            part->op.reply.hdr.retval == -ENOSPC && op->retval == -ETIMEDOUT ||
-            part->op.reply.hdr.retval == -EIO)
-        {
-            // Error priority: EIO > ENOSPC > ETIMEDOUT > EPIPE
+        if (ERR_PRIO(part->op.reply.hdr.retval) > ERR_PRIO(op->retval))
            op->retval = part->op.reply.hdr.retval;
-        }
        uint64_t stop_client_id = 0;
-        if (op->retval != -EINTR && op->retval != -EIO && op->retval != -ENOSPC)
+        if (op->retval != -EINTR && op->retval != -EIO && op->retval != -ENOSPC && op->retval != -EPERM)
        {
            stop_client_id = part->op.client_id;
            if (op->retval != -EPIPE || log_level > 0)
@@ -5,6 +5,7 @@

 #include "messenger.h"
 #include "etcd_state_client.h"
+#include "../util/robin_hood.h"

 #define DEFAULT_CLIENT_MAX_DIRTY_BYTES 32*1024*1024
 #define DEFAULT_CLIENT_MAX_DIRTY_OPS 1024
@@ -71,6 +72,7 @@ protected:
    cluster_op_t *prev = NULL, *next = NULL;
    int prev_wait = 0;
    uint64_t flush_id = 0;
+    std::shared_ptr<osd_op_enc_t> enc;
    friend class cluster_client_t;
    friend class writeback_cache_t;
 };
@@ -80,6 +82,25 @@ struct inode_list_osd_t;
 struct inode_list_pg_t;
 class writeback_cache_t;

+struct inode_cache_t
+{
+    std::vector<inode_t> chain; // only parents from the same pool
+    uint8_t *key_data = NULL;
+    osd_op_enc_t *op_enc = NULL;
+    bool readonly = false;
+    bool has_parent_loop = false;
+    inode_t other_pool_parent_id = 0;
+    int err_code = 0;
+
+    ~inode_cache_t();
+};
+
+struct vault_load_key_t
+{
+    int key_state = 0;
+    std::string key;
+};
+
 // FIXME: Split into public and private interfaces
 class __attribute__((visibility("default"))) cluster_client_t
 {
@@ -89,8 +110,8 @@ public:
    timerfd_manager_t *tfd = NULL;
    ring_loop_t *ringloop = NULL;

-    std::map<pool_id_t, uint64_t> pg_counts;
-    std::map<pool_pg_num_t, osd_num_t> pg_primary;
+    // config:
+
    // client_max_dirty_* is actually "max unsynced", for the case when immediate_commit is off
    uint64_t client_max_dirty_bytes = 0;
    uint64_t client_max_dirty_ops = 0;
@@ -102,12 +123,23 @@ public:
    uint64_t client_max_writeback_iodepth = 0;
    std::string conf_hostname;

+    std::string vault_url;
+    std::string vault_client_cert;
+    std::string vault_client_key;
+    std::string vault_ca;
+    std::string vault_secret_api_path;
+    uint64_t vault_timeout_ms = 0;
+    uint64_t vault_error_timeout_sec = 0;
+    uint64_t vault_refresh_leeway_sec = 0;
+
    int log_level = 0;
    int client_retry_interval = 50; // ms
    int client_eio_retry_interval = 1000; // ms
    bool client_retry_enospc = true;
    int client_wait_up_timeout = 16; // sec (for listings)

+    // state:
+
    std::string client_hostname;
    std::map<std::string, int> self_tree_metrics;
    std::map<osd_num_t, int> osd_tree_metrics;
@@ -115,15 +147,28 @@ public:
    int retry_timeout_id = -1;
    int retry_timeout_duration = 0;
    std::vector<cluster_op_t*> offline_ops;
+    std::vector<cluster_op_t*> key_wait_ops;
    cluster_op_t *op_queue_head = NULL, *op_queue_tail = NULL;
    writeback_cache_t *wb = NULL;
    std::set<osd_num_t> dirty_osds;
    uint64_t dirty_bytes = 0, dirty_ops = 0;

-    void *scrap_buffer = NULL;
-    unsigned scrap_buffer_size = 0;
+    // inodes require some extra state for read/write, it's stored here.
+    // moreover, robin_hood access is slightly faster than std::map :)
+    robin_hood::unordered_flat_map<inode_t, std::shared_ptr<inode_cache_t>> inode_cache;
+    std::set<std::pair<inode_t, inode_t>> inode_cache_children;
+
+    http_context_t *vault_http_ctx = NULL;
+    http_co_t *vault_http_cli = NULL;
+    bool vault_loading = false;
+    std::string vault_token;
+    bool vault_auth_error = false;
+    timespec vault_token_expire = {};
+    std::vector<std::string> vault_key_load_queue;
+    std::map<std::string, vault_load_key_t> vault_keys;

    bool pgs_loaded = false;
+    std::map<pool_id_t, uint64_t> pg_counts;
    ring_consumer_t consumer;
    std::vector<std::function<void(void)>> on_ready_hooks;
    int list_retry_timeout_id = -1;
@@ -163,6 +208,13 @@ protected:
 #endif
    void continue_ops(int time_passed = 0);

+    std::shared_ptr<inode_cache_t> inode_cache_get(inode_t ino);
+    void vault_parse_config();
+    bool vault_check_token();
+    void vault_load_keys();
+    void vault_destroy();
+    void vault_parse_secret(const std::string & key_id, const std::string & err, json11::Json data);
+
 protected:
    bool affects_osd(uint64_t inode, uint64_t offset, uint64_t len, osd_num_t osd);
    bool affects_pg(uint64_t inode, uint64_t offset, uint64_t len, pool_id_t pool_id, pg_num_t pg_num);
@@ -173,6 +225,7 @@ protected:
    void on_change_pg_state_hook(pool_id_t pool_id, pg_num_t pg_num, osd_num_t prev_primary);
    void on_change_osd_state_hook(uint64_t peer_osd);
    void on_change_node_placement_hook();
+    void on_change_inode_hook(uint64_t inode, bool removed);

    void execute_internal(cluster_op_t *op);
    void execute_cas(cluster_op_t *op);
@@ -189,6 +242,7 @@ protected:
    void erase_op(cluster_op_t *op);
    void calc_wait(cluster_op_t *op);
    void inc_wait(uint64_t opcode, uint64_t flags, cluster_op_t *next, int inc);
+
    void continue_lists();
    bool continue_listing(inode_list_t *lst);
    bool restart_listing(inode_list_t* lst);
@@ -0,0 +1,367 @@
+// Copyright (c) Vitaliy Filippov, 2019+
+// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
+
+#include <stdexcept>
+#include <assert.h>
+#include "cluster_client_impl.h"
+#include "http_client.h"
+#include "str_util.h"
+
+#define VAULT_KEY_NOT_LOADED 0
+#define VAULT_KEY_LOADING 1
+#define VAULT_KEY_LOADED 2
+#define VAULT_KEY_ERROR 3
+
+inode_cache_t::~inode_cache_t()
+{
+    if (key_data)
+    {
+        free(key_data);
+        key_data = NULL;
+        op_enc = NULL;
+    }
+}
+
+void cluster_client_t::vault_destroy()
+{
+    if (vault_http_ctx)
+    {
+#ifndef __MOCK__
+        http_destroy(vault_http_cli);
+        http_context_destroy(vault_http_ctx);
+        vault_http_cli = NULL;
+        vault_http_ctx = NULL;
+#endif
+    }
+}
+
+void cluster_client_t::vault_parse_config()
+{
+    vault_url = config["vault_url"].string_value();
+    vault_client_cert = config["vault_client_cert"].string_value();
+    vault_client_key = config["vault_client_key"].string_value();
+    vault_ca = config["vault_ca"].string_value();
+    vault_secret_api_path = "/v1/secret/";
+    if (config["vault_secret_api_path"].is_string())
+        vault_secret_api_path = config["vault_secret_api_path"].string_value();
+    vault_timeout_ms = config["vault_timeout_ms"].uint64_value();
+    if (!vault_timeout_ms)
+        vault_timeout_ms = 5000;
+    vault_error_timeout_sec = config["vault_error_timeout_sec"].uint64_value();
+    if (!vault_error_timeout_sec)
+        vault_error_timeout_sec = 60;
+    vault_refresh_leeway_sec = config["vault_refresh_leeway_sec"].uint64_value();
+    if (!vault_refresh_leeway_sec)
+        vault_refresh_leeway_sec = 60;
+}
+
+// FIXME: Rework client API by adding open/close and cache inode information in the "FD" (maybe)
+void cluster_client_t::on_change_inode_hook(uint64_t inode, bool removed)
+{
+    std::vector<inode_t> children = { inode };
+    for (size_t i = 0; i < children.size(); i++)
+    {
+        auto it = inode_cache_children.lower_bound(std::make_pair(children[i], (inode_t)0));
+        while (it != inode_cache_children.end() && it->first == children[i])
+        {
+            children.push_back(it->second);
+            it++;
+        }
+    }
+    for (auto & inode: children)
+    {
+        auto it = inode_cache.find(inode);
+        if (it != inode_cache.end())
+        {
+            auto icache = it->second;
+            for (auto & parent: icache->chain)
+            {
+                inode_cache_children.erase(std::make_pair(parent, inode));
+            }
+            inode_cache.erase(it);
+        }
+    }
+}
+
+std::shared_ptr<inode_cache_t> cluster_client_t::inode_cache_get(inode_t ino)
+{
+    auto icache_it = inode_cache.find(ino);
+    if (icache_it != inode_cache.end())
+    {
+        return icache_it->second;
+    }
+    // Fill inode cache
+    auto ino_it = st_cli.inode_config.find(ino);
+    if (ino_it == st_cli.inode_config.end())
+    {
+        inode_cache[ino] = NULL;
+        return NULL;
+    }
+    auto pool_it = st_cli.pool_config.find(INODE_POOL(ino));
+    if (pool_it == st_cli.pool_config.end())
+    {
+        inode_cache[ino] = NULL;
+        return NULL;
+    }
+    auto & inode_cfg = ino_it->second;
+    auto & pool_cfg = pool_it->second;
+    std::shared_ptr<inode_cache_t> icache = std::make_shared<inode_cache_t>();
+    icache->readonly = inode_cfg.readonly;
+    icache->chain.push_back(ino);
+    std::vector<inode_config_t*> chain_cfg;
+    // FIXME: Allow unencrypted read & write when all chain is encrypted with the same key
+    int enc_key_count = !inode_cfg.enc_key.empty() ? 1 : 0;
+    if (inode_cfg.parent_id)
+    {
+        // Check for loops and cache the chain
+        robin_hood::unordered_flat_set<inode_t> seen;
+        seen.insert(ino);
+        uint64_t parent_id = inode_cfg.parent_id;
+        while (parent_id)
+        {
+            if (seen.find(parent_id) != seen.end())
+            {
+                icache->has_parent_loop = true;
+                break;
+            }
+            seen.insert(parent_id);
+            ino_it = st_cli.inode_config.find(parent_id);
+            if (INODE_POOL(parent_id) == INODE_POOL(ino))
+            {
+                icache->chain.push_back(parent_id);
+                if (ino_it == st_cli.inode_config.end())
+                    chain_cfg.push_back(NULL);
+                else
+                {
+                    chain_cfg.push_back(&ino_it->second);
+                    if (!ino_it->second.enc_key.empty())
+                        enc_key_count++;
+                }
+            }
+            else if (!icache->other_pool_parent_id)
+                icache->other_pool_parent_id = parent_id;
+            if (ino_it == st_cli.inode_config.end())
+                break;
+            parent_id = ino_it->second.parent_id;
+        }
+    }
+    // Check external keys and wait for loading, if required
+    if (enc_key_count)
+    {
+        for (size_t i = 0; i <= chain_cfg.size(); i++)
+        {
+            inode_config_t *cfg = !i ? &inode_cfg : chain_cfg[i-1];
+            if (cfg && cfg->enc_key.substr(0, strlen(VAULT_KEY_PREFIX)) == VAULT_KEY_PREFIX)
+            {
+                auto & ik = vault_keys[inode_cfg.enc_key];
+                if (ik.key_state == VAULT_KEY_ERROR || vault_url.empty())
+                {
+                    icache->err_code = EPERM;
+                    enc_key_count = 0;
+                }
+                else if (ik.key_state == VAULT_KEY_NOT_LOADED)
+                {
+                    ik.key_state = VAULT_KEY_LOADING;
+                    vault_key_load_queue.push_back(inode_cfg.enc_key);
+                    vault_load_keys();
+                    icache->err_code = EAGAIN;
+                    enc_key_count = 0;
+                }
+                else if (ik.key_state == VAULT_KEY_LOADING)
+                {
+                    icache->err_code = EAGAIN;
+                    enc_key_count = 0;
+                }
+                else
+                {
+                    assert(ik.key_state == VAULT_KEY_LOADED);
+                }
+            }
+        }
+    }
+    // Generate encryption key chain, if applicable
+    if (enc_key_count)
+    {
+        uint8_t *key_data = (uint8_t*)malloc_or_die(
+            AES_256_XTS_KEY_SIZE * enc_key_count +
+            sizeof(uint8_t*) * icache->chain.size() +
+            sizeof(osd_op_enc_t)
+        );
+        uint8_t **keys = (uint8_t**)(key_data + AES_256_XTS_KEY_SIZE * enc_key_count);
+        osd_op_enc_t *enc = (osd_op_enc_t*)((uint8_t*)keys + sizeof(uint8_t*)*icache->chain.size());
+        size_t key_pos = 0;
+        for (size_t i = 0; i <= chain_cfg.size(); i++)
+        {
+            inode_config_t *cfg = !i ? &inode_cfg : chain_cfg[i-1];
+            if (cfg && !cfg->enc_key.empty())
+            {
+                const auto & key = cfg->enc_key.substr(0, strlen(VAULT_KEY_PREFIX)) == VAULT_KEY_PREFIX
+                    ? vault_keys.at(cfg->enc_key).key
+                    : cfg->enc_key;
+                assert(key_pos < AES_256_XTS_KEY_SIZE * enc_key_count);
+                assert(key.size() == 2*AES_256_XTS_KEY_SIZE);
+                keys[i] = key_data + key_pos;
+                fromhexstr(key, AES_256_XTS_KEY_SIZE, key_data + key_pos);
+                key_pos += AES_256_XTS_KEY_SIZE;
+            }
+            else
+                keys[i] = NULL;
+        }
+        enc->key_chain = keys;
+        enc->chain_size = icache->chain.size();
+        enc->read_chain_bitmap_pos = pool_cfg.data_block_size/pool_cfg.bitmap_granularity/8;
+        enc->bitmap_granularity = pool_cfg.bitmap_granularity;
+        icache->key_data = key_data;
+        icache->op_enc = enc;
+    }
+    inode_cache[ino] = icache;
+    for (auto & parent: icache->chain)
+    {
+        if (parent != ino)
+            inode_cache_children.insert(std::make_pair(parent, ino));
+    }
+    return icache;
+}
+
+#ifndef __MOCK__
+bool cluster_client_t::vault_check_token()
+{
+    timespec now;
+    clock_gettime(CLOCK_REALTIME, &now);
+    if (!vault_token_expire.tv_sec || vault_token_expire.tv_sec < now.tv_sec)
+    {
+        vault_loading = true;
+        http_json_post(
+            vault_http_cli, vault_url+"/v1/auth/cert/login", json11::Json::object{}, "",
+            (http_options_t){ .timeout = (int)vault_timeout_ms, .keepalive = true },
+            [this](http_message_t *response)
+            {
+                clock_gettime(CLOCK_REALTIME, &vault_token_expire);
+                vault_loading = false;
+                std::string err;
+                json11::Json data;
+                response->parse_json_response(err, data);
+                if (err != "")
+                {
+                    vault_token_expire.tv_sec += vault_error_timeout_sec;
+                    fprintf(stderr, "Vault request failed: %s\n", err.c_str());
+                }
+                else
+                {
+                    uint64_t ttl = data["auth"]["lease_duration"].uint64_value();
+                    vault_token = data["auth"]["client_token"].string_value();
+                    if (vault_token.empty() || !ttl)
+                    {
+                        vault_token_expire.tv_sec += vault_error_timeout_sec;
+                        fprintf(stderr, "No token or lease_duration in Vault response: %s\n", data.dump().c_str());
+                    }
+                    else
+                    {
+                        if (ttl < vault_refresh_leeway_sec)
+                            vault_token_expire.tv_sec += ttl/2;
+                        else
+                            vault_token_expire.tv_sec += ttl - vault_refresh_leeway_sec;
+                    }
+                }
+                vault_load_keys();
+            }
+        );
+        return false;
+    }
+    if (vault_token.empty())
+    {
+        // Auth error happened, mark all loads as failed
+        for (auto & key_id: vault_key_load_queue)
+        {
+            auto & k = vault_keys[key_id];
+            k.key_state = VAULT_KEY_ERROR;
+        }
+        vault_key_load_queue.clear();
+        auto ops = std::move(key_wait_ops);
+        for (cluster_op_t *op: ops)
+            inode_cache.erase(op->inode);
+        for (cluster_op_t *op: ops)
+            execute_internal(op);
+        return false;
+    }
+    return true;
+}
+#endif
+
+void cluster_client_t::vault_load_keys()
+{
+    if (vault_loading || !vault_key_load_queue.size())
+    {
+        return;
+    }
+#ifdef __MOCK__
+    vault_loading = true;
+#else
+    if (!vault_http_ctx)
+    {
+        std::string error;
+        vault_http_ctx = http_context_init(tfd, vault_client_cert, vault_client_key, vault_ca, true, error);
+        if (!vault_http_ctx)
+        {
+            fprintf(stderr, "Failed to initialize HTTP context for Vault: %s\n", error.c_str());
+            exit(1);
+        }
+        vault_http_cli = http_init(vault_http_ctx);
+    }
+    if (!vault_check_token())
+    {
+        return;
+    }
+    std::string key_id = vault_key_load_queue[0];
+    vault_key_load_queue.erase(vault_key_load_queue.begin());
+    vault_loading = true;
+    http_get(
+        vault_http_cli, vault_url+vault_secret_api_path+key_id.substr(strlen(VAULT_KEY_PREFIX)), "X-Vault-Token: "+vault_token+"\r\n",
+        (http_options_t){ .timeout = (int)vault_timeout_ms, .keepalive = true },
+        [this, key_id](http_message_t *response)
+        {
+            vault_loading = false;
+            std::string err;
+            json11::Json data;
+            response->parse_json_response(err, data);
+            vault_parse_secret(key_id, err, data);
+        }
+    );
+#endif
+}
+
+void cluster_client_t::vault_parse_secret(const std::string & key_id, const std::string & err, json11::Json data)
+{
+    vault_loading = false;
+    auto & k = vault_keys[key_id];
+    if (err != "")
+    {
+        k.key_state = VAULT_KEY_ERROR;
+        fprintf(stderr, "Vault %s%s%s request failed: %s\n", vault_url.c_str(),
+            vault_secret_api_path.c_str(), key_id.c_str()+strlen(VAULT_KEY_PREFIX), err.c_str());
+    }
+    else
+    {
+        auto hexkey = data["data"]["key"].string_value();
+        if (hexkey.empty() || !ishexstr(hexkey) || hexkey.size() != 2*AES_256_XTS_KEY_SIZE)
+        {
+            k.key_state = VAULT_KEY_ERROR;
+            fprintf(stderr, "Vault /v1/secret/%s request failed: 'key' is empty or has invalid format\n", key_id.c_str());
+        }
+        else
+        {
+            k.key_state = VAULT_KEY_LOADED;
+            k.key = hexkey;
+        }
+    }
+    if (vault_key_load_queue.empty())
+    {
+        auto ops = std::move(key_wait_ops);
+        for (cluster_op_t *op: ops)
+            inode_cache.erase(op->inode);
+        for (cluster_op_t *op: ops)
+            execute_internal(op);
+    }
+    else
+        vault_load_keys();
+}
@@ -5,7 +5,6 @@

 #include "cluster_client.h"

-#define SCRAP_BUFFER_SIZE 4*1024*1024
 #define PART_SENT 1
 #define PART_DONE 2
 #define PART_ERROR 4
@@ -1,7 +1,10 @@
 // Copyright (c) Vitaliy Filippov, 2019+
 // License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)

+#include <assert.h>
+#include "malloc_or_die.h"
 #include "osd_ops.h"
+#include "msgr_op.h"
 #include "pg_states.h"
 #include "etcd_state_client.h"
 #ifndef __MOCK__
@@ -9,6 +12,7 @@
 #include "http_client.h"
 #endif
 #include "str_util.h"
+#include "json_util.h"

 etcd_state_client_t::~etcd_state_client_t()
 {
@@ -22,14 +26,19 @@ etcd_state_client_t::~etcd_state_client_t()
    stop_ws_keepalive();
    if (etcd_watch_ws)
    {
-        http_close(etcd_watch_ws);
+        http_destroy(etcd_watch_ws);
        etcd_watch_ws = NULL;
    }
    if (keepalive_client)
    {
-        http_close(keepalive_client);
+        http_destroy(keepalive_client);
        keepalive_client = NULL;
    }
+    if (http_ctx)
+    {
+        http_context_destroy(http_ctx);
+        http_ctx = NULL;
+    }
 #endif
    if (load_pgs_timer_id >= 0)
    {
@@ -72,55 +81,91 @@ std::vector<std::string> etcd_state_client_t::get_addresses()
    return addrs;
 }

-void etcd_state_client_t::etcd_call_oneshot(std::string etcd_address, std::string api, json11::Json payload,
+std::shared_ptr<user_info_t> etcd_state_client_t::get_user(const std::string & username)
+{
+    auto user_it = user_info.find(username);
+    if (user_it != user_info.end())
+    {
+        return user_it->second;
+    }
+    auto inf = std::make_shared<user_info_t>();
+    inf->name = username;
+    return inf;
+}
+
+bool etcd_state_client_t::check_image_perm(const std::shared_ptr<user_info_t> & user_info, inode_t inode_num, bool write)
+{
+    if (user_info->type == user_type_t::ADMIN)
+    {
+        return true;
+    }
+    auto cache_it = user_info->perm_cache.find(inode_num);
+    if (cache_it != user_info->perm_cache.end() &&
+        cache_it->second.mod_revision == user_perm_cache_revision)
+    {
+        return write ? (cache_it->second.perm == user_perm_t::OWNER) : (cache_it->second.perm != user_perm_t::DENY);
+    }
+    auto inode_it = inode_config.find(inode_num);
+    if (inode_it == inode_config.end())
+    {
+        return false;
+    }
+    // FIXME Implement cache reset after reworking etcd interaction to not keep everything in memory
+    auto & perm_item = user_info->perm_cache[inode_num];
+    perm_item.mod_revision = user_perm_cache_revision;
+    perm_item.perm = (user_info->name == inode_it->second.owner || inode_it->second.owner_group != "" &&
+        user_info->groups.find(inode_it->second.owner_group) != user_info->groups.end()
+        ? user_perm_t::OWNER : (inode_it->second.reader_group != "" &&
+            user_info->groups.find(inode_it->second.reader_group) != user_info->groups.end()
+            ? user_perm_t::READER : user_perm_t::DENY));
+    return write ? (perm_item.perm == user_perm_t::OWNER) : (perm_item.perm != user_perm_t::DENY);
+}
+
+http_context_t *etcd_state_client_t::get_http_ctx()
+{
+    if (!http_ctx)
+    {
+        std::string error;
+        http_ctx = http_context_init(tfd, etcd_client_cert, etcd_client_key, etcd_ca, true, error);
+        if (!http_ctx)
+        {
+            fprintf(stderr, "Failed to initialize HTTP context: %s\n", error.c_str());
+            exit(1);
+        }
+    }
+    return http_ctx;
+}
+
+void etcd_state_client_t::etcd_call_oneshot(const std::string & etcd_url, const std::string & api, json11::Json payload,
    int timeout, std::function<void(std::string, json11::Json)> callback)
 {
-    std::string etcd_api_path;
-    int pos = etcd_address.find('/');
-    if (pos >= 0)
-    {
-        etcd_api_path = etcd_address.substr(pos);
-        etcd_address = etcd_address.substr(0, pos);
-    }
-    std::string req = payload.dump();
-    req = "POST "+etcd_api_path+api+" HTTP/1.1\r\n"
-        "Host: "+etcd_address+"\r\n"
-        "Content-Type: application/json\r\n"
-        "Content-Length: "+std::to_string(req.size())+"\r\n"
-        "Connection: close\r\n"
-        "\r\n"+req;
-    auto http_cli = http_init(tfd);
-    auto cb = [http_cli, callback](const http_response_t *response)
+    auto http_cli = http_init(get_http_ctx());
+    http_json_post(http_cli, etcd_url+api, payload, "", { .timeout = timeout }, [http_cli, callback](http_message_t *response)
    {
        std::string err;
        json11::Json data;
        response->parse_json_response(err, data);
        callback(err, data);
-        http_close(http_cli);
-    };
-    http_request(http_cli, etcd_address, req, { .timeout = timeout }, cb);
+        http_destroy(http_cli);
+    });
 }

-void etcd_state_client_t::etcd_call(std::string api, json11::Json payload, int timeout,
+void etcd_state_client_t::etcd_call(const std::string & api, json11::Json payload, int timeout,
    int retries, int interval, std::function<void(std::string, json11::Json)> callback)
 {
-    if (!etcd_addresses.size() && !etcd_local.size())
+    pick_next_etcd([=]()
    {
-        fprintf(stderr, "etcd_address is missing in Vitastor configuration\n");
-        exit(1);
-    }
-    pick_next_etcd();
-    std::string etcd_address = selected_etcd_address;
-    std::string etcd_api_path;
-    int pos = etcd_address.find('/');
-    if (pos >= 0)
-    {
-        etcd_api_path = etcd_address.substr(pos);
-        etcd_address = etcd_address.substr(0, pos);
-    }
+        etcd_call_selected(api, payload, timeout, retries, interval, callback);
+    });
+}
+
+void etcd_state_client_t::etcd_call_selected(const std::string & api, json11::Json payload, int timeout,
+    int retries, int interval, std::function<void(std::string, json11::Json)> callback)
+{
+    const auto & url = selected_etcd_url;
    std::string req = payload.dump();
-    req = "POST "+etcd_api_path+api+" HTTP/1.1\r\n"
-        "Host: "+etcd_address+"\r\n"
+    req = "POST "+url.path+api+" HTTP/1.1\r\n"
+        "Host: "+url.hostname+"\r\n"
        "Content-Type: application/json\r\n"
        "Content-Length: "+std::to_string(req.size())+"\r\n"
        "Connection: keep-alive\r\n"
@@ -128,15 +173,15 @@ void etcd_state_client_t::etcd_call(std::string api, json11::Json payload, int t
        "\r\n"+req;
    retries--;
    auto cb = [this, api, payload, timeout, retries, interval, callback,
-        cur_addr = selected_etcd_address](const http_response_t *response)
+        cur_addr = url.addr](http_message_t *response)
    {
        std::string err;
        json11::Json data;
        response->parse_json_response(err, data);
        if (err != "")
        {
-            if (cur_addr == selected_etcd_address)
-                selected_etcd_address = "";
+            if (cur_addr == selected_etcd_url.addr)
+                selected_etcd_url = (http_url_t){};
            if (retries > 0)
            {
                if (this->log_level > 0)
@@ -164,54 +209,58 @@ void etcd_state_client_t::etcd_call(std::string api, json11::Json payload, int t
            callback(err, data);
    };
    if (!keepalive_client)
-    {
-        keepalive_client = http_init(tfd);
-    }
-    http_request(keepalive_client, etcd_address, req, { .timeout = timeout, .keepalive = true }, cb);
+        keepalive_client = http_init(get_http_ctx());
+    http_request(keepalive_client, url.addr, req, { .timeout = timeout, .keepalive = true, .ssl = url.ssl }, cb);
 }

-void etcd_state_client_t::add_etcd_url(std::string addr)
+
+void etcd_state_client_t::add_etcd_url(std::string etcd_address)
 {
-    if (addr.length() > 0)
+    if (etcd_address.size() > 0)
    {
-        if (strtolower(addr.substr(0, 7)) == "http://")
-            addr = addr.substr(7);
-        else if (strtolower(addr.substr(0, 8)) == "https://")
-        {
-            fprintf(stderr, "HTTPS is unsupported for etcd. Either use plain HTTP or setup a local proxy for etcd interaction\n");
-            exit(1);
-        }
        if (!local_ips.size())
-            local_ips = getifaddr_list(std::vector<addr_mask_t>(), true);
-        std::string check_addr;
-        int pos = addr.find('/');
-        int pos2 = addr.find(':');
-        if (pos2 >= 0)
-            check_addr = addr.substr(0, pos2);
-        else if (pos >= 0)
-            check_addr = addr.substr(0, pos);
-        else
-            check_addr = addr;
-        if (pos == std::string::npos)
-            addr += "/v3";
-        bool local = false;
-        int i;
-        for (i = 0; i < local_ips.size(); i++)
        {
-            if (local_ips[i] == check_addr)
-            {
-                local = true;
-                break;
-            }
+            // Fill local_ips
+            for (auto & ip: getifaddr_list(std::vector<addr_mask_t>(), true))
+                local_ips.insert(ip);
        }
-        auto & to = local ? this->etcd_local : this->etcd_addresses;
+        std::string etcd_api_path;
+        bool ssl = false;
+        if (etcd_address.substr(0, 8) == "https://")
+        {
+            ssl = true;
+            etcd_address = etcd_address.substr(8);
+        }
+        else if (etcd_address.substr(0, 7) == "http://")
+            etcd_address = etcd_address.substr(7);
+        auto pos = etcd_address.find('/');
+        if (pos != std::string::npos)
+        {
+            etcd_api_path = etcd_address.substr(pos);
+            etcd_address = etcd_address.substr(0, pos);
+        }
+        else
+            etcd_api_path = "/v3";
+        pos = etcd_address.find(':');
+        auto check_addr = (pos != std::string::npos ? etcd_address.substr(0, pos) : etcd_address);
+        bool is_local = local_ips.find(check_addr) != local_ips.end();
+        auto & to = (is_local ? etcd_local : etcd_addresses);
+        check_addr = (ssl ? "https://" : "http://") + etcd_address + etcd_api_path;
+        size_t i;
        for (i = 0; i < to.size(); i++)
        {
-            if (to[i] == addr)
+            if (to[i] == check_addr)
                break;
        }
        if (i >= to.size())
-            to.push_back(addr);
+        {
+            to.push_back(check_addr);
+            // Check if it's a domain name
+            sockaddr_storage ss;
+            bool is_name = !is_local && !string_to_addr(etcd_address, true, 0, &ss);
+            auto & to_addr = (is_local ? etcd_local_addr_urls : (is_name ? etcd_name_urls : etcd_nonlocal_addr_urls));
+            to_addr.push_back((http_url_t){ .ssl = ssl, .addr = etcd_address, .hostname = etcd_address, .path = etcd_api_path });
+        }
    }
 }

@@ -219,6 +268,9 @@ void etcd_state_client_t::parse_config(const json11::Json & config)
 {
    this->etcd_local.clear();
    this->etcd_addresses.clear();
+    this->etcd_local_addr_urls.clear();
+    this->etcd_nonlocal_addr_urls.clear();
+    this->etcd_name_urls.clear();
    if (config["etcd_address"].is_string())
    {
        std::string ea = config["etcd_address"].string_value();
@@ -239,6 +291,22 @@ void etcd_state_client_t::parse_config(const json11::Json & config)
            add_etcd_url(ea.string_value());
        }
    }
+    if (this->osd_num)
+    {
+        this->etcd_client_cert = config["osd_cert"].string_value();
+        this->etcd_client_key = config["osd_pkey"].string_value();
+    }
+    else
+    {
+        this->etcd_client_cert = config["cert"].string_value();
+        this->etcd_client_key = config["pkey"].string_value();
+    }
+    if (this->etcd_client_cert == "")
+    {
+        this->etcd_client_cert = config["etcd_client_cert"].string_value();
+        this->etcd_client_key = config["etcd_client_key"].string_value();
+    }
+    this->etcd_ca = config["etcd_ca"].string_value();
    this->etcd_prefix = config["etcd_prefix"].string_value();
    if (this->etcd_prefix == "")
    {
@@ -291,66 +359,130 @@ void etcd_state_client_t::parse_config(const json11::Json & config)
    }
 }

-void etcd_state_client_t::pick_next_etcd()
-{
-    if (selected_etcd_address != "")
-        return;
-    if (addresses_to_try.size() == 0)
-    {
-        // Prefer local etcd, if any
-        for (int i = 0; i < etcd_local.size(); i++)
-            addresses_to_try.push_back(etcd_local[i]);
-        std::vector<int> ns;
-        for (int i = 0; i < etcd_addresses.size(); i++)
-            ns.push_back(i);
-        if (!rand_initialized)
-        {
-            timespec tv;
-            clock_gettime(CLOCK_REALTIME, &tv);
-            srand48(tv.tv_sec*1000000000 + tv.tv_nsec);
-            rand_initialized = true;
-        }
-        while (ns.size())
-        {
-            int i = lrand48() % ns.size();
-            addresses_to_try.push_back(etcd_addresses[ns[i]]);
-            ns.erase(ns.begin()+i, ns.begin()+i+1);
-        }
-    }
-    selected_etcd_address = addresses_to_try[0];
-    addresses_to_try.erase(addresses_to_try.begin(), addresses_to_try.begin()+1);
-}
-
-void etcd_state_client_t::start_etcd_watcher()
+void etcd_state_client_t::pick_next_etcd(std::function<void()> cb)
 {
    if (!etcd_addresses.size() && !etcd_local.size())
    {
        fprintf(stderr, "etcd_address is missing in Vitastor configuration\n");
        exit(1);
    }
-    pick_next_etcd();
-    std::string etcd_address = selected_etcd_address;
-    std::string etcd_api_path;
-    int pos = etcd_address.find('/');
-    if (pos >= 0)
+    if (selected_etcd_url.addr != "")
    {
-        etcd_api_path = etcd_address.substr(pos);
-        etcd_address = etcd_address.substr(0, pos);
+        cb();
+        return;
    }
+    if (etcd_urls_to_try.size() != 0)
+    {
+        selected_etcd_url = std::move(etcd_urls_to_try[0]);
+        etcd_urls_to_try.erase(etcd_urls_to_try.begin());
+        cb();
+        return;
+    }
+    on_resolve_queue.push_back(std::move(cb));
+    if (on_resolve_queue.size() > 1)
+    {
+        // Already resolving
+        return;
+    }
+    assert(!resolve_count);
+    local_to_try = 0;
+    for (auto & url: etcd_local_addr_urls)
+    {
+        // Prefer local IPs, if any
+        etcd_urls_to_try.push_back(url);
+        local_to_try++;
+    }
+    for (auto & url: etcd_nonlocal_addr_urls)
+    {
+        etcd_urls_to_try.push_back(url);
+    }
+    resolve_count++;
+    for (auto & url: etcd_name_urls)
+    {
+        resolve_count++;
+        http_resolve(get_http_ctx(), url.ssl, url.addr, [this, url](const std::string & error, const std::vector<std::string>& addresses)
+        {
+            if (error != "")
+                fprintf(stderr, "Error resolving %s: %s\n", url.addr.c_str(), error.c_str());
+            for (auto & addr: addresses)
+            {
+                auto url_copy = url;
+                url_copy.addr = addr;
+                if (local_ips.find(addr) != local_ips.end())
+                {
+                    etcd_urls_to_try.insert(etcd_urls_to_try.begin(), std::move(url_copy));
+                    local_to_try++;
+                }
+                else
+                    etcd_urls_to_try.push_back(std::move(url_copy));
+            }
+            resolve_count--;
+            if (!resolve_count)
+                pick_next_etcd_on_resolve();
+        });
+    }
+    resolve_count--;
+    if (!resolve_count)
+    {
+        pick_next_etcd_on_resolve();
+    }
+}
+
+void etcd_state_client_t::pick_next_etcd_on_resolve()
+{
+    if (!etcd_urls_to_try.size())
+    {
+        fprintf(stderr, "None of etcd_address could be resolved\n");
+        exit(1);
+    }
+    if (!rand_initialized)
+    {
+        timespec tv;
+        clock_gettime(CLOCK_REALTIME, &tv);
+        srand48(tv.tv_sec*1000000000 + tv.tv_nsec);
+        rand_initialized = true;
+    }
+    // Shuffle addresses
+    for (size_t i = etcd_urls_to_try.size()-1; i > local_to_try; i--)
+    {
+        size_t j = local_to_try + lrand48() % (i - local_to_try);
+        if (j != i)
+            std::swap(etcd_urls_to_try[i], etcd_urls_to_try[j]);
+    }
+    selected_etcd_url = std::move(etcd_urls_to_try[0]);
+    etcd_urls_to_try.erase(etcd_urls_to_try.begin());
+    auto cbs = std::move(on_resolve_queue);
+    for (auto cb: cbs)
+    {
+        cb();
+    }
+}
+
+void etcd_state_client_t::start_etcd_watcher()
+{
+    pick_next_etcd([this]()
+    {
+        start_etcd_watcher_selected();
+    });
+}
+
+void etcd_state_client_t::start_etcd_watcher_selected()
+{
+    const auto & url = selected_etcd_url;
    etcd_watches_initialised = 0;
    ws_alive = 1;
-    if (etcd_watch_ws)
-    {
-        http_close(etcd_watch_ws);
-        etcd_watch_ws = NULL;
-    }
    if (this->log_level > 1)
    {
-        fprintf(stderr, "Trying to connect to etcd websocket at %s, watch from revision %ju/%ju/%ju\n", etcd_address.c_str(),
+        fprintf(stderr, "Trying to connect to etcd websocket at %s%s%s (hostname %s), watch from revision %ju/%ju/%ju\n",
+            url.ssl ? "https://" : "http://", url.addr.c_str(), url.path.c_str(), url.hostname.c_str(),
            etcd_watch_revision_config, etcd_watch_revision_osd, etcd_watch_revision_pg);
    }
-    etcd_watch_ws = open_websocket(tfd, etcd_address, etcd_api_path+"/watch", etcd_slow_timeout,
-        [this, cur_addr = selected_etcd_address](const http_response_t *msg)
+    if (!etcd_watch_ws)
+        etcd_watch_ws = http_init(get_http_ctx());
+    else
+        http_close(etcd_watch_ws);
+    open_websocket(etcd_watch_ws, url.addr, url.hostname, url.path+"/watch", { .timeout = etcd_slow_timeout, .ssl = url.ssl },
+        [this, cur_addr = url.addr](http_message_t *msg)
    {
        if (msg->body.length())
        {
@@ -393,7 +525,6 @@ void etcd_state_client_t::start_etcd_watcher()
                                fprintf(stderr, "Revisions before %ju were compacted by etcd, reloading state\n",
                                    data["result"]["compact_revision"].uint64_value());
                                http_close(etcd_watch_ws);
-                                etcd_watch_ws = NULL;
                                etcd_watch_revision_config = etcd_watch_revision_osd = etcd_watch_revision_pg = 0;
                                on_reload_hook();
                            }
@@ -438,7 +569,7 @@ void etcd_state_client_t::start_etcd_watcher()
                        etcd_watch_revision_pg = watch_rev;
                    else if (watch_id == ETCD_OSD_STATE_WATCH_ID)
                        etcd_watch_revision_osd = watch_rev;
-                    addresses_to_try.clear();
+                    etcd_urls_to_try.clear();
                }
                // First gather all changes into a hash to remove multiple overwrites
                std::map<std::string, etcd_kv_t> changes;
@@ -468,13 +599,8 @@ void etcd_state_client_t::start_etcd_watcher()
        if (msg->eof)
        {
            fprintf(stderr, "Disconnected from etcd %s\n", cur_addr.c_str());
-            if (cur_addr == selected_etcd_address)
-                selected_etcd_address = "";
-            if (etcd_watch_ws)
-            {
-                http_close(etcd_watch_ws);
-                etcd_watch_ws = NULL;
-            }
+            if (cur_addr == selected_etcd_url.addr)
+                selected_etcd_url = (http_url_t){};
            if (etcd_watches_initialised == 0)
            {
                // Connection not established, retry in <etcd_quick_timeout>
@@ -549,12 +675,7 @@ void etcd_state_client_t::start_ws_keepalive()
            {
                if (this->log_level > 0)
                {
-                    fprintf(stderr, "Websocket ping failed, disconnecting from etcd %s\n", selected_etcd_address.c_str());
-                }
-                if (etcd_watch_ws)
-                {
-                    http_close(etcd_watch_ws);
-                    etcd_watch_ws = NULL;
+                    fprintf(stderr, "Websocket ping failed, disconnecting from etcd %s\n", selected_etcd_url.addr.c_str());
                }
                start_etcd_watcher();
            }
@@ -942,6 +1063,8 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
                pc.used_for_app = "fs:"+pc.used_for_app;
            else
                pc.used_for_app = pool_item.second["used_for_app"].as_string();
+            // Create group permission
+            pc.creator_group = pool_item.second["creator_group"].string_value();
            // Local Read Configuration
            std::string local_reads = pool_item.second["local_reads"].string_value();
            if (local_reads == "nearest")
@@ -1261,37 +1384,15 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
                {
                    on_inode_change_hook(inode_num, true);
                }
+                if (this->inode_config.find(inode_num) != this->inode_config.end())
+                {
+                    user_perm_cache_revision = kv.mod_revision;
+                }
                this->inode_config.erase(inode_num);
            }
            else
            {
-                inode_t parent_inode_num = value["parent_id"].uint64_value();
-                if (parent_inode_num && !(parent_inode_num >> (64-POOL_ID_BITS)))
-                {
-                    uint64_t parent_pool_id = value["parent_pool"].uint64_value();
-                    if (!parent_pool_id)
-                        parent_inode_num |= pool_id << (64-POOL_ID_BITS);
-                    else if (parent_pool_id >= POOL_ID_MAX)
-                    {
-                        fprintf(
-                            stderr, "Inode %ju/%ju parent_pool value is invalid, ignoring parent setting\n",
-                            inode_num >> (64-POOL_ID_BITS), inode_num & (((uint64_t)1 << (64-POOL_ID_BITS)) - 1)
-                        );
-                        parent_inode_num = 0;
-                    }
-                    else
-                        parent_inode_num |= parent_pool_id << (64-POOL_ID_BITS);
-                }
-                insert_inode_config((inode_config_t){
-                    .num = inode_num,
-                    .name = value["name"].string_value(),
-                    .size = value["size"].uint64_value(),
-                    .parent_id = parent_inode_num,
-                    .readonly = value["readonly"].bool_value(),
-                    .deleted = value["deleted"].bool_value(),
-                    .meta = value["meta"],
-                    .mod_revision = kv.mod_revision,
-                });
+                insert_inode_config(deserialize_inode_cfg(inode_num, kv.value, kv.mod_revision));
            }
        }
    }
@@ -1302,6 +1403,40 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
        if (on_change_node_placement_hook)
            on_change_node_placement_hook();
    }
+    else if (key.substr(0, etcd_prefix.length()+13) == etcd_prefix+"/config/user/")
+    {
+        // <etcd_prefix>/config/user/<username>
+        auto name = key.substr(etcd_prefix.length()+13);
+        auto & inf = user_info[name];
+        if (!value.is_object())
+        {
+            if (inf)
+            {
+                inf->type = user_type_t::CLIENT;
+                inf->groups.clear();
+                inf->perm_cache.clear();
+            }
+            user_info.erase(name);
+        }
+        else
+        {
+            if (!inf)
+            {
+                inf = std::make_shared<user_info_t>();
+                inf->name = name;
+            }
+            inf->type = value["type"] == "admin" ? user_type_t::ADMIN :
+                (value["type"] == "mon" ? user_type_t::MON :
+                (value["type"] == "osd" ? user_type_t::OSD : user_type_t::CLIENT));
+            inf->groups.clear();
+            for (auto & group: value["groups"].array_items())
+            {
+                if (group.string_value() != "")
+                    inf->groups.insert(group.string_value());
+            }
+            inf->perm_cache.clear();
+        }
+    }
 }

 uint32_t etcd_state_client_t::parse_immediate_commit(const std::string & immediate_commit_str, uint32_t default_value)
@@ -1324,7 +1459,12 @@ uint32_t etcd_state_client_t::parse_scheme(const std::string & scheme)

 void etcd_state_client_t::insert_inode_config(const inode_config_t & cfg)
 {
-    this->inode_config[cfg.num] = cfg;
+    auto & cfg_ref = this->inode_config[cfg.num];
+    if (cfg_ref.mod_revision != cfg.mod_revision)
+    {
+        user_perm_cache_revision = cfg.mod_revision;
+    }
+    cfg_ref = cfg;
    if (cfg.name != "")
    {
        this->inode_by_name[cfg.name] = cfg.num;
@@ -1380,6 +1520,10 @@ json11::Json::object etcd_state_client_t::serialize_inode_cfg(inode_config_t *cf
            new_cfg["parent_pool"] = (uint64_t)INODE_POOL(cfg->parent_id);
        new_cfg["parent_id"] = (uint64_t)INODE_NO_POOL(cfg->parent_id);
    }
+    if (!cfg->enc_key.empty())
+    {
+        new_cfg["enc_key"] = cfg->enc_key;
+    }
    if (cfg->readonly)
    {
        new_cfg["readonly"] = true;
@@ -1388,6 +1532,18 @@ json11::Json::object etcd_state_client_t::serialize_inode_cfg(inode_config_t *cf
    {
        new_cfg["deleted"] = true;
    }
+    if (!cfg->owner.empty())
+    {
+        new_cfg["owner"] = cfg->owner;
+    }
+    if (!cfg->owner_group.empty())
+    {
+        new_cfg["owner_group"] = cfg->owner_group;
+    }
+    if (!cfg->reader_group.empty())
+    {
+        new_cfg["reader_group"] = cfg->reader_group;
+    }
    if (cfg->meta.is_object())
    {
        new_cfg["meta"] = cfg->meta;
@@ -1395,6 +1551,53 @@ json11::Json::object etcd_state_client_t::serialize_inode_cfg(inode_config_t *cf
    return new_cfg;
 }

+inode_config_t etcd_state_client_t::deserialize_inode_cfg(uint64_t inode_num, json11::Json value, uint64_t mod_revision)
+{
+    inode_t parent_inode_num = value["parent_id"].uint64_value();
+    if (parent_inode_num && !INODE_POOL(parent_inode_num))
+    {
+        uint64_t parent_pool_id = value["parent_pool"].uint64_value();
+        if (!parent_pool_id)
+            parent_inode_num = INODE_WITH_POOL(INODE_POOL(inode_num), parent_inode_num);
+        else if (parent_pool_id >= POOL_ID_MAX)
+        {
+            fprintf(
+                stderr, "Inode %u/%ju parent_pool value is invalid, ignoring parent setting\n",
+                INODE_POOL(inode_num), INODE_NO_POOL(inode_num)
+            );
+            parent_inode_num = 0;
+        }
+        else
+            parent_inode_num |= parent_pool_id << (64-POOL_ID_BITS);
+    }
+    std::string enc_key;
+    if (!value["enc_key"].is_null())
+    {
+        enc_key = value["enc_key"].string_value();
+        if (enc_key.substr(0, strlen(VAULT_KEY_PREFIX)) != VAULT_KEY_PREFIX &&
+            (enc_key.size() != 2*AES_256_XTS_KEY_SIZE || !ishexstr(enc_key)))
+        {
+            enc_key = "";
+            fprintf(stderr, "Inode %u/%ju has invalid enc_key, should be %u bit hex string or Vault key reference\n",
+                INODE_POOL(inode_num), INODE_NO_POOL(inode_num), AES_256_XTS_KEY_SIZE);
+        }
+    }
+    return (inode_config_t){
+        .num = inode_num,
+        .name = value["name"].string_value(),
+        .size = value["size"].uint64_value(),
+        .parent_id = parent_inode_num,
+        .readonly = value["readonly"].bool_value(),
+        .deleted = value["deleted"].bool_value(),
+        .enc_key = std::move(enc_key),
+        .owner = value["owner"].string_value(),
+        .owner_group = value["owner_group"].string_value(),
+        .reader_group = value["reader_group"].string_value(),
+        .meta = value["meta"],
+        .mod_revision = mod_revision,
+    };
+}
+
 int etcd_state_client_t::address_count()
 {
    return etcd_addresses.size() + etcd_local.size();
@@ -4,10 +4,12 @@
 #pragma once

 #include <set>
+#include <memory>

 #include "json11/json11.hpp"
 #include "object_id.h"
 #include "timerfd_manager.h"
+#include "../util/robin_hood.h"

 #define ETCD_CONFIG_WATCH_ID 1
 #define ETCD_OSD_STATE_WATCH_ID 2
@@ -19,6 +21,8 @@
 #define MAX_DATA_BLOCK_SIZE 128*1024*1024
 #define DEFAULT_BITMAP_GRANULARITY 4096

+#define VAULT_KEY_PREFIX "vault:"
+
 #ifndef IMMEDIATE_NONE
 #define IMMEDIATE_NONE 0
 #define IMMEDIATE_SMALL 1
@@ -66,6 +70,7 @@ struct pool_config_t
    std::map<pg_num_t, pg_config_t> pg_config;
    uint64_t scrub_interval = 0;
    std::string used_for_app;
+    std::string creator_group;
    int backfillfull = 0;
    int local_reads = 0;

@@ -83,6 +88,9 @@ struct inode_config_t
    inode_t parent_id = 0;
    bool readonly = false;
    bool deleted = false;
+    std::string enc_key;
+    // Permissions
+    std::string owner, owner_group, reader_group;
    // Arbitrary metadata
    json11::Json meta;
    // Change revision of the metadata in etcd
@@ -95,23 +103,67 @@ struct inode_watch_t
    inode_config_t cfg = {};
 };

+struct http_url_t
+{
+    bool ssl;
+    std::string addr;
+    std::string hostname;
+    std::string path;
+};
+
+enum class user_type_t
+{
+    CLIENT = 0,
+    ADMIN = 1,
+    MON = 2,
+    OSD = 3,
+};
+
+struct user_perm_t
+{
+    enum class perm_type_t: uint8_t;
+    constexpr static perm_type_t DENY = (perm_type_t)0;
+    constexpr static perm_type_t READER = (perm_type_t)1;
+    constexpr static perm_type_t OWNER = (perm_type_t)2;
+    uint64_t mod_revision = 0;
+    perm_type_t perm = DENY;
+};
+
+struct user_info_t
+{
+    std::string name;
+    user_type_t type;
+    robin_hood::unordered_flat_set<std::string> groups;
+    robin_hood::unordered_flat_map<inode_t, user_perm_t> perm_cache;
+};
+
 struct http_co_t;
+struct http_context_t;

 struct __attribute__((visibility("default"))) etcd_state_client_t
 {
 protected:
-    std::vector<std::string> local_ips;
-    std::vector<std::string> etcd_addresses;
+    std::set<std::string> local_ips;
    std::vector<std::string> etcd_local;
-    std::string selected_etcd_address;
-    std::vector<std::string> addresses_to_try;
+    std::vector<std::string> etcd_addresses;
+    std::vector<http_url_t> etcd_local_addr_urls;
+    std::vector<http_url_t> etcd_nonlocal_addr_urls;
+    std::vector<http_url_t> etcd_name_urls;
+    size_t local_to_try = 0;
+    std::vector<http_url_t> etcd_urls_to_try;
+    http_url_t selected_etcd_url;
+    size_t resolve_count = 0;
    std::vector<inode_watch_t*> watches;
+    std::vector<std::function<void()>> on_resolve_queue;
    bool new_pg_config = false;
    int ws_keepalive_timer = -1;
    int ws_alive = 0;
    bool rand_initialized = false;
    void add_etcd_url(std::string);
-    void pick_next_etcd();
+    void pick_next_etcd(std::function<void()> cb);
+    void pick_next_etcd_on_resolve();
+    void etcd_call_selected(const std::string & api, json11::Json payload, int timeout, int retries, int interval, std::function<void(std::string, json11::Json)> callback);
+    void start_etcd_watcher_selected();
 public:
    int etcd_keepalive_timeout = 30;
    int etcd_ws_keepalive_interval = 5;
@@ -124,10 +176,15 @@ public:
    uint32_t global_bitmap_granularity = DEFAULT_BITMAP_GRANULARITY;
    uint32_t global_immediate_commit = IMMEDIATE_NONE;

+    uint64_t osd_num = 0;
    std::string etcd_prefix;
+    std::string etcd_client_cert;
+    std::string etcd_client_key;
+    std::string etcd_ca;
    int log_level = 0;
    timerfd_manager_t *tfd = NULL;

+    http_context_t *http_ctx = NULL;
    http_co_t *etcd_watch_ws = NULL, *keepalive_client = NULL;
    int etcd_watches_initialised = 0;
    uint64_t etcd_watch_revision_config = 0;
@@ -140,6 +197,8 @@ public:
    std::set<osd_num_t> seen_peers;
    std::map<inode_t, inode_config_t> inode_config;
    std::map<std::string, inode_t> inode_by_name;
+    robin_hood::unordered_flat_map<std::string, std::shared_ptr<user_info_t>> user_info;
+    uint64_t user_perm_cache_revision = 0;
    json11::Json node_placement;

    std::function<void(std::map<std::string, etcd_kv_t> &)> on_change_hook;
@@ -158,10 +217,14 @@ public:
    std::function<void(http_co_t *)> on_start_watcher_hook;

    json11::Json::object serialize_inode_cfg(inode_config_t *cfg);
+    inode_config_t deserialize_inode_cfg(uint64_t inode_num, json11::Json value, uint64_t mod_revision);
    etcd_kv_t parse_etcd_kv(const json11::Json & kv_json);
    std::vector<std::string> get_addresses();
-    void etcd_call_oneshot(std::string etcd_address, std::string api, json11::Json payload, int timeout, std::function<void(std::string, json11::Json)> callback);
-    void etcd_call(std::string api, json11::Json payload, int timeout, int retries, int interval, std::function<void(std::string, json11::Json)> callback);
+    std::shared_ptr<user_info_t> get_user(const std::string & username);
+    bool check_image_perm(const std::shared_ptr<user_info_t> & user_info, inode_t inode_num, bool write);
+    http_context_t *get_http_ctx();
+    void etcd_call_oneshot(const std::string & etcd_address, const std::string & api, json11::Json payload, int timeout, std::function<void(std::string, json11::Json)> callback);
+    void etcd_call(const std::string & api, json11::Json payload, int timeout, int retries, int interval, std::function<void(std::string, json11::Json)> callback);
    void etcd_txn(json11::Json txn, int timeout, int retries, int interval, std::function<void(std::string, json11::Json)> callback);
    void etcd_txn_slow(json11::Json txn, std::function<void(std::string, json11::Json)> callback);
    void start_etcd_watcher();
@@ -17,14 +17,19 @@

 class timerfd_manager_t;

+#pragma GCC visibility push(default)
+
 struct http_options_t
 {
    int timeout;
    bool want_streaming;
    bool keepalive;
+    bool ssl;
 };

-struct http_response_t
+struct http_context_t;
+
+struct http_message_t
 {
    std::string error;

@@ -41,10 +46,26 @@ struct http_response_t
 // Opened websocket or keepalive HTTP connection
 struct http_co_t;

-http_co_t* http_init(timerfd_manager_t *tfd);
-http_co_t* open_websocket(timerfd_manager_t *tfd, const std::string & host, const std::string & path,
-    int timeout, std::function<void(const http_response_t *msg)> on_message);
+http_context_t* http_context_init(timerfd_manager_t *tfd, const std::string & ssl_cert, const std::string & ssl_key,
+    const std::string & ssl_ca, bool verify_peer, std::string & error);
+std::string http_context_get_ssl_cn(http_context_t *ctx);
+void http_resolve(http_context_t *ctx, bool ssl, std::string host,
+    std::function<void(const std::string & error, const std::vector<std::string> & addrs)> cb);
+void http_context_destroy(http_context_t *ctx);
+http_co_t* http_init(http_context_t *ctx = NULL);
+void open_websocket(http_co_t *handler, const std::string & addr, const std::string & hostname, const std::string & path,
+    const http_options_t & options, std::function<void(http_message_t *msg)> on_message);
 void http_request(http_co_t *handler, const std::string & host, const std::string & request,
-    const http_options_t & options, std::function<void(const http_response_t *response)> response_callback);
+    const http_options_t & options, std::function<void(http_message_t *response)> response_callback);
+void http_get(http_co_t *handler, const std::string & url, const std::string & headers,
+    const http_options_t & options, std::function<void(http_message_t *response)> response_callback);
+void http_json_post(http_co_t *handler, const std::string & url, json11::Json body, const std::string & headers,
+    const http_options_t & options, std::function<void(http_message_t *response)> response_callback);
 void http_post_message(http_co_t *handler, uint8_t type, const std::string & msg);
+void http_serve(http_co_t *handler, int peer_fd, const http_options_t & options,
+    std::function<void(http_message_t *msg)> request_callback);
+void http_reply(http_co_t *handler, const std::string & reply);
 void http_close(http_co_t *co);
+void http_destroy(http_co_t *co);
+
+#pragma GCC visibility pop
@@ -10,6 +10,7 @@
 #include <stdexcept>

 #include "addr_util.h"
+#include "str_util.h"
 #include "messenger.h"
 #ifdef WITH_RDMA
 #include "msgr_rdma.h"
@@ -117,6 +118,7 @@ void msgr_iothread_t::run()

 void osd_messenger_t::init()
 {
+    init_tls();
 #ifdef WITH_RDMACM
    if (use_rdmacm)
    {
@@ -189,9 +191,12 @@ void osd_messenger_t::init()
        {
            auto cl = cl_it->second;
            cl_it++;
-            if (!cl->osd_num && !cl->in_osd_num || cl->peer_state != PEER_CONNECTED && cl->peer_state != PEER_RDMA)
+            if (!cl->osd_num && !cl->in_osd_num ||
+                cl->peer_state != PEER_CONNECTED &&
+                cl->peer_state != PEER_RDMA_CONNECTING_OUT &&
+                cl->peer_state != PEER_RDMA)
            {
-                // Do not run keepalive on regular clients
+                // Do not run keepalive on regular and unconnected clients
                continue;
            }
            if (cl->ping_time_remaining > 0)
@@ -199,10 +204,21 @@ void osd_messenger_t::init()
                cl->ping_time_remaining--;
                if (!cl->ping_time_remaining)
                {
-                    // Ping timed out, stop the client
-                    fprintf(stderr, "Ping timed out for OSD %ju (client %ju), disconnecting peer\n",
-                        cl->in_osd_num ? cl->in_osd_num : cl->osd_num, cl->client_id);
-                    clients_to_stop.push_back(cl->client_id);
+                    // Ping timed out
+                    if (cl->peer_state == PEER_RDMA_CONNECTING_OUT && cl->peer_fd >= 0)
+                    {
+                        fprintf(stderr, "Ping timed out for OSD %ju over RDMA (client %ju), switching back to TCP\n",
+                            cl->in_osd_num ? cl->in_osd_num : cl->osd_num, cl->client_id);
+                        delete cl->rdma_conn;
+                        cl->rdma_conn = NULL;
+                        cl->peer_state = PEER_CONNECTED;
+                    }
+                    else
+                    {
+                        fprintf(stderr, "Ping timed out for OSD %ju (client %ju), disconnecting peer\n",
+                            cl->in_osd_num ? cl->in_osd_num : cl->osd_num, cl->client_id);
+                        clients_to_stop.push_back(cl->client_id);
+                    }
                }
            }
            else if (cl->idle_time_remaining > 0)
@@ -220,7 +236,7 @@ void osd_messenger_t::init()
                            .opcode = OSD_OP_PING,
                        },
                    };
-                    op->callback = [this, cl](osd_op_t *op)
+                    op->callback = [this](osd_op_t *op)
                    {
                        auto cl_it = clients.find(op->client_id);
                        if (cl_it == clients.end())
@@ -229,14 +245,25 @@ void osd_messenger_t::init()
                            delete op;
                            return;
                        }
-                        uint64_t fail_client_id = (op->reply.hdr.retval != 0 ? op->client_id : 0);
-                        auto fail_osd_num = cl->in_osd_num ? cl->in_osd_num : cl->osd_num;
+                        auto cl = cl_it->second;
+                        bool failed = (op->reply.hdr.retval != 0);
                        cl->ping_time_remaining = 0;
                        delete op;
-                        if (fail_client_id)
+                        if (failed)
                        {
-                            fprintf(stderr, "Ping failed for OSD %ju (client %ju), disconnecting peer\n", fail_osd_num, fail_client_id);
-                            stop_client(fail_client_id);
+                            auto fail_osd_num = cl->in_osd_num ? cl->in_osd_num : cl->osd_num;
+                            if (cl->peer_state == PEER_RDMA_CONNECTING_OUT && cl->peer_fd >= 0)
+                            {
+                                fprintf(stderr, "Ping failed for OSD %ju over RDMA (client %ju), switching back to TCP\n", fail_osd_num, cl->client_id);
+                                delete cl->rdma_conn;
+                                cl->rdma_conn = NULL;
+                                cl->peer_state = PEER_CONNECTED;
+                            }
+                            else
+                            {
+                                fprintf(stderr, "Ping failed for OSD %ju (client %ju), disconnecting peer\n", fail_osd_num, cl->client_id);
+                                stop_client(cl->client_id);
+                            }
                        }
                    };
                    cl->ping_time_remaining = osd_ping_timeout;
@@ -295,10 +322,52 @@ osd_messenger_t::~osd_messenger_t()
        rdmacm_evch = NULL;
    }
 #endif
+    for (auto encrypt_ctx: encrypt_xts_pool)
+    {
+        destroy_aes_xts_encrypt(encrypt_ctx);
+    }
+    for (auto decrypt_ctx: decrypt_xts_pool)
+    {
+        destroy_aes_xts_decrypt(decrypt_ctx);
+    }
+    destroy_tls();
 }

-void osd_messenger_t::parse_config(const json11::Json & config)
+void osd_messenger_t::parse_config(const json11::Json & config, bool init)
 {
+    this->max_cipher_pool_size = config["max_cipher_pool_size"].uint64_value();
+    if (!this->max_cipher_pool_size)
+        this->max_cipher_pool_size = 256;
+    if (config["proto_checksums"].is_null())
+        this->use_proto_checksums = MSGR_CSUM_PAYLOAD;
+    else if (config["proto_checksums"].is_bool())
+        this->use_proto_checksums = config["proto_checksums"].bool_value() ? MSGR_CSUM_FULL : 0;
+    else if (config["proto_checksums"].string_value() != "")
+        this->use_proto_checksums = config["proto_checksums"].string_value() == "full" ? MSGR_CSUM_FULL : MSGR_CSUM_PAYLOAD;
+    else
+        this->use_proto_checksums = 0;
+    this->receive_buffer_size = (uint32_t)config["tcp_header_buffer_size"].uint64_value();
+    if (!this->receive_buffer_size || this->receive_buffer_size > 1024*1024*1024)
+        this->receive_buffer_size = 65536;
+    this->min_zerocopy_send_size = config["min_zerocopy_send_size"].is_null()
+        ? DEFAULT_MIN_ZEROCOPY_SEND_SIZE
+        : (int)config["min_zerocopy_send_size"].int64_value();
+    this->peer_connect_interval = config["peer_connect_interval"].uint64_value();
+    if (!this->peer_connect_interval)
+        this->peer_connect_interval = 5;
+    this->peer_connect_timeout = config["peer_connect_timeout"].uint64_value();
+    if (!this->peer_connect_timeout)
+        this->peer_connect_timeout = 5;
+    this->osd_idle_timeout = config["osd_idle_timeout"].uint64_value();
+    if (!this->osd_idle_timeout)
+        this->osd_idle_timeout = 5;
+    this->osd_ping_timeout = config["osd_ping_timeout"].uint64_value();
+    if (!this->osd_ping_timeout)
+        this->osd_ping_timeout = 5;
+    this->log_level = config["log_level"].uint64_value();
+    // All other parameters are only set on init
+    if (!init)
+        return;
 #ifdef WITH_RDMA
    if (!config["use_rdma"].is_null())
    {
@@ -329,31 +398,25 @@ void osd_messenger_t::parse_config(const json11::Json & config)
    if (!this->rdma_max_msg || this->rdma_max_msg > 128*1024*1024)
        this->rdma_max_msg = 129*1024;
 #endif
+    if (!osd_num)
+    {
+        tls_cert = config["cert"].string_value();
+        tls_key = config["pkey"].string_value();
+        osd_tls_ca = config["osd_ca"].string_value();
+    }
+    else
+    {
+        tls_cert = config["osd_cert"].string_value();
+        tls_key = config["osd_pkey"].string_value();
+        osd_tls_ca = config["osd_ca"].string_value();
+        client_tls_ca = config["client_ca"].string_value();
+    }
    if (!osd_num)
        this->iothread_count = (uint32_t)config["client_iothread_count"].uint64_value();
    else
        this->iothread_count = (uint32_t)config["osd_iothread_count"].uint64_value();
-    this->receive_buffer_size = (uint32_t)config["tcp_header_buffer_size"].uint64_value();
-    if (!this->receive_buffer_size || this->receive_buffer_size > 1024*1024*1024)
-        this->receive_buffer_size = 65536;
    this->use_sync_send_recv = config["use_sync_send_recv"].bool_value() ||
-        config["use_sync_send_recv"].uint64_value();
-    this->min_zerocopy_send_size = config["min_zerocopy_send_size"].is_null()
-        ? DEFAULT_MIN_ZEROCOPY_SEND_SIZE
-        : (int)config["min_zerocopy_send_size"].int64_value();
-    this->peer_connect_interval = config["peer_connect_interval"].uint64_value();
-    if (!this->peer_connect_interval)
-        this->peer_connect_interval = 5;
-    this->peer_connect_timeout = config["peer_connect_timeout"].uint64_value();
-    if (!this->peer_connect_timeout)
-        this->peer_connect_timeout = 5;
-    this->osd_idle_timeout = config["osd_idle_timeout"].uint64_value();
-    if (!this->osd_idle_timeout)
-        this->osd_idle_timeout = 5;
-    this->osd_ping_timeout = config["osd_ping_timeout"].uint64_value();
-    if (!this->osd_ping_timeout)
-        this->osd_ping_timeout = 5;
-    this->log_level = config["log_level"].uint64_value();
+        config["use_sync_send_recv"].uint64_value() || !ringloop;
    // OSD public & cluster networks
    this->osd_networks.clear();
    if (config["osd_network"].is_string())
@@ -510,7 +573,7 @@ void osd_messenger_t::try_connect_peer_tcp(osd_num_t peer_osd, const char *peer_
    cl->peer_state = PEER_CONNECTING;
    cl->connect_timeout_id = -1;
    cl->osd_num = peer_osd;
-    cl->in_buf = malloc_or_die(receive_buffer_size);
+    cl->in_buf = (uint8_t*)malloc_or_die(receive_buffer_size);
    clients[client_id] = cl;
    clients_by_fd[peer_fd] = cl;
    tfd->set_fd_handler(peer_fd, true, [this](int peer_fd, int epoll_events)
@@ -559,6 +622,7 @@ void osd_messenger_t::handle_connect_epoll(int peer_fd)
        handle_peer_epoll(peer_fd, epoll_events);
    });
    // Check OSD number
+    init_tls_client(cl);
    check_peer_config(cl);
 }

@@ -569,6 +633,17 @@ void osd_messenger_t::handle_peer_epoll(int peer_fd, int epoll_events)
    if (epoll_events & EPOLLRDHUP)
    {
        // Stop client
+        if (cl->rdma_close_tcp && (cl->peer_state == PEER_RDMA ||
+            cl->peer_state == PEER_RDMA_CONNECTING_IN ||
+            cl->peer_state == PEER_RDMA_CONNECTING_OUT))
+        {
+            // It's allowed to stop the TCP socket during RDMA transition
+            tfd->set_fd_handler(cl->peer_fd, false, NULL);
+            clients_by_fd.erase(cl->peer_fd);
+            close(cl->peer_fd);
+            cl->peer_fd = -1;
+            return;
+        }
        if (log_level > 0)
        {
            fprintf(stderr, "[OSD %ju] client %ju disconnected\n", this->osd_num, cl->client_id);
@@ -648,7 +723,15 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
        // Inform that we're OSD <osd_num>
        payload["osd_num"] = osd_num;
    }
-    payload["features"] = json11::Json::object{ { "check_sequencing", true } };
+    auto features = json11::Json::object{
+        { "check_sequencing", true },
+        { "rdma_close_tcp", true },
+    };
+    if (use_proto_checksums)
+    {
+        features["proto_checksums"] = use_proto_checksums;
+    }
+    payload["features"] = features;
 #ifdef WITH_RDMA
    if (!use_rdmacm && rdma_contexts.size())
    {
@@ -688,6 +771,11 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
            err = true;
            fprintf(stderr, "Failed to get config from OSD %ju (retval=%jd), disconnecting peer\n", cl->osd_num, op->reply.hdr.retval);
        }
+        else if (cl->gcm_enabled && !cl->hs_result.peer_is_osd)
+        {
+            err = true;
+            fprintf(stderr, "Client %ju is not authenticated as an OSD, disconnecting peer\n", cl->client_id);
+        }
        else
        {
            config = json11::Json::parse(std::string((char*)op->buf), json_err);
@@ -723,7 +811,19 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
            delete op;
            return;
        }
+        if (use_proto_checksums)
+        {
+            auto peer_csums = config["features"]["proto_checksums"].uint64_value();
+            if (peer_csums == MSGR_CSUM_FULL && use_proto_checksums == MSGR_CSUM_FULL)
+                cl->proto_csum_status = MSGR_CSUM_FULL;
+            else if (peer_csums && use_proto_checksums)
+                cl->proto_csum_status = MSGR_CSUM_PAYLOAD;
+        }
 #ifdef WITH_RDMA
+        if (config["features"]["rdma_close_tcp"].bool_value())
+        {
+            cl->rdma_close_tcp = true;
+        }
        if (!use_rdmacm && cl->rdma_conn && config["rdma_address"].is_string())
        {
            msgr_rdma_address_t addr;
@@ -748,9 +848,14 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
                {
                    fprintf(stderr, "Connected to OSD %ju using RDMA\n", cl->osd_num);
                }
-                cl->peer_state = PEER_RDMA;
+                cl->peer_state = (cl->rdma_close_tcp ? PEER_RDMA_CONNECTING_OUT : PEER_RDMA);
                // Add the initial receive request
                init_recv_rdma(cl);
+                // Check the connection by using a ping
+                cl->ping_time_remaining = osd_ping_timeout;
+                cl->idle_time_remaining = 0;
+                delete op;
+                return;
            }
        }
 #endif
@@ -786,7 +891,8 @@ void osd_messenger_t::accept_connections(int listen_fd)
        cl->peer_port = ntohs(((sockaddr_in*)&addr)->sin_port);
        cl->peer_fd = peer_fd;
        cl->peer_state = PEER_CONNECTED;
-        cl->in_buf = malloc_or_die(receive_buffer_size);
+        cl->in_buf = (uint8_t*)malloc_or_die(receive_buffer_size);
+        init_tls_client(cl);
        // Add FD to epoll
        tfd->set_fd_handler(peer_fd, false, [this](int peer_fd, int epoll_events)
        {
@@ -829,6 +935,11 @@ bool osd_messenger_t::is_use_rdmacm()
 }
 #endif

+bool osd_messenger_t::is_encryption_enabled()
+{
+    return tls_cert != "" || tls_key != "" || osd_tls_ca != "";
+}
+
 json11::Json::object osd_messenger_t::read_config(const json11::Json & config)
 {
    json11::Json::object file_config;
@@ -12,12 +12,20 @@
 #include <deque>
 #include <vector>

+#include <openssl/types.h>
+
+#ifdef WITH_ISAL_CRYPTO
+#include <isa-l_crypto/aes_gcm.h>
+#endif
+
+#include "../util/xxh_x86dispatch.h"
 #include "../util/robin_hood.h"
 #include "malloc_or_die.h"
 #include "json11/json11.hpp"
 #include "msgr_op.h"
 #include "timerfd_manager.h"
 #include "addr_util.h"
+#include "msgr_handshake.h"
 #include <ringloop.h>

 #define CL_READ_HDR 1
@@ -27,16 +35,23 @@

 #define PEER_CONNECTING 1
 #define PEER_CONNECTED 2
-#define PEER_RDMA_CONNECTING 3
-#define PEER_RDMA 4
-#define PEER_STOPPED 5
+#define PEER_RDMA_CONNECTING_IN 3
+#define PEER_RDMA_CONNECTING_OUT 4
+#define PEER_RDMA 5
+#define PEER_STOPPED 6
+
+#define MSGR_CSUM_PAYLOAD 1
+#define MSGR_CSUM_FULL 2
+#define MSGR_CSUM_NEG 4

 #define VITASTOR_CONFIG_PATH "/etc/vitastor/vitastor.conf"

 #define DEFAULT_MIN_ZEROCOPY_SEND_SIZE 32*1024

-#define MSGR_SENDP_HDR 1
-#define MSGR_SENDP_FREE 2
+#define AES_256_GCM_KEY_SIZE 32
+#define AES_256_GCM_IV_SIZE 12
+
+#define MAX_SIMPLE_PAYLOAD_SIZE 1048576

 struct msgr_sendp_t
 {
@@ -49,6 +64,13 @@ struct msgr_rdma_connection_t;
 struct msgr_rdma_context_t;
 #endif

+struct op_aes_xts_encrypt_t;
+struct op_aes_xts_decrypt_t;
+void destroy_aes_xts_encrypt(op_aes_xts_encrypt_t *encrypt_ctx);
+void destroy_aes_xts_decrypt(op_aes_xts_decrypt_t *decrypt_ctx);
+
+struct user_info_t;
+
 struct osd_client_t
 {
    uint64_t client_id = 0;
@@ -65,23 +87,53 @@ struct osd_client_t
    osd_num_t in_osd_num = 0;
    bool is_incoming = false;

-    void *in_buf = NULL;
+    uint8_t *in_buf = NULL;

 #ifdef WITH_RDMA
    msgr_rdma_connection_t *rdma_conn = NULL;
 #endif

+    uint8_t *ssl_out_buf = NULL;
+    size_t ssl_out_buf_size = 0, ssl_out_buf_cap = 0;
+
+    bool gcm_enabled = false;
+    msgr_handshake_i *hs = NULL;
+    msgr_handshake_result_t hs_result;
+    std::shared_ptr<user_info_t> user_info;
+    std::vector<uint8_t> my_key, peer_key;
+    uint64_t my_iv_ctr = 0, peer_iv_ctr = 0;
+#ifdef WITH_ISAL_CRYPTO
+    isal_gcm_key_data my_key_isal, peer_key_isal;
+    isal_gcm_context_data *enc_ctx = NULL;
+    isal_gcm_context_data *dec_ctx = NULL;
+#else
+    EVP_CIPHER_CTX *enc_ctx = NULL;
+    EVP_CIPHER_CTX *dec_ctx = NULL;
+#endif
+    uint8_t enc_tag[16];
+    size_t enc_tag_size = 0;
+    uint8_t dec_tag[16];
+    size_t dec_tag_size = 0;
+
    // Read state
+    bool io_error = false;
    int read_ready = 0;
    osd_op_t *read_op = NULL;
+    size_t read_op_size = 0;
+    size_t read_op_pos = 0;
    iovec read_iov = { 0 };
    msghdr read_msg = { 0 };
-    int read_remaining = 0;
-    int read_state = 0;
-    osd_op_buf_list_t recv_list;
+    std::vector<iovec> recv_list;
+    std::vector<int> recv_flags;
    uint64_t read_op_id = 1;
    bool check_sequencing = false;
+    bool rdma_close_tcp = false;
    bool enable_pg_locks = false;
+    op_aes_xts_decrypt_t *xts_dec_ctx = NULL;
+    size_t read_op_inline_decrypt_pos = 0;
+    size_t read_op_inline_decrypt_in = 0;
+    int proto_csum_status = 0;
+    XXH3_state_t* read_csum_state = NULL;

    // Incoming operations
    std::vector<osd_op_t*> received_ops;
@@ -94,11 +146,17 @@ struct osd_client_t
    std::set<pool_pg_num_t> dirty_pgs;

    // Write state
+    std::deque<osd_op_t *> write_ops;
+    osd_op_t *write_op = NULL;
+    size_t write_op_pos = 0;
    msghdr write_msg = { 0 };
    int write_state = 0;
-    std::vector<iovec> send_list, next_send_list;
-    std::vector<msgr_sendp_t> outbox, next_outbox;
+    std::vector<iovec> send_list;
+    size_t send_list_size = 0;
+    std::deque<osd_op_t*> send_free_ops;
    std::vector<osd_op_t*> zc_free_list;
+    op_aes_xts_encrypt_t *xts_enc_ctx = NULL;
+    XXH3_state_t* write_csum_state = NULL;

    ~osd_client_t();
    void cancel_ops();
@@ -176,9 +234,19 @@ struct osd_messenger_t;
 struct rdmacm_connecting_t;
 #endif

+class msgr_op_reader_t;
+class msgr_op_writer_t;
+
 struct __attribute__((visibility("default"))) osd_messenger_t
 {
 protected:
+    friend class copy_op_reader_t;
+    friend class gcm_op_reader_t;
+    friend class get_op_reader_t;
+    friend class copy_op_writer_t;
+    friend class gcm_op_writer_t;
+    friend class get_op_writer_t;
+
    int keepalive_timer_id = -1;

    uint32_t receive_buffer_size = 0;
@@ -190,6 +258,12 @@ protected:
    bool use_sync_send_recv = false;
    int min_zerocopy_send_size = DEFAULT_MIN_ZEROCOPY_SEND_SIZE;
    int iothread_count = 0;
+    int max_cipher_pool_size = 256;
+
+    std::string tls_cert;
+    std::string tls_key;
+    std::string osd_tls_ca;
+    std::string client_tls_ca;

 #ifdef WITH_RDMA
    bool use_rdma = true;
@@ -207,19 +281,42 @@ protected:
    robin_hood::unordered_flat_map<rdma_cm_id*, rdmacm_connecting_t*> rdmacm_connecting;
 #endif

+    bool gcm_enabled = false;
+    msgr_handshake_ctx_i *hs_ctx = NULL;
+
+    void init_tls();
+    void destroy_tls();
+    void init_tls_client(osd_client_t *cl);
+    bool do_tls_handshake(osd_client_t *cl, bool from_recv = false);
+    bool derive_aes_keys(osd_client_t *cl, bool update_my, bool update_peer);
+
    std::vector<msgr_iothread_t*> iothreads;
    std::vector<uint64_t> read_ready_clients;
    std::vector<uint64_t> write_ready_clients;
    // We don't use ringloop->set_immediate here because we may have no ringloop in client :)
    std::deque<osd_op_t*> set_immediate_ops;

+    std::vector<op_aes_xts_encrypt_t*> encrypt_xts_pool;
+    std::vector<op_aes_xts_decrypt_t*> decrypt_xts_pool;
+
+#ifdef WITH_ISAL_CRYPTO
+    std::vector<isal_gcm_context_data*> encrypt_gcm_pool;
+    std::vector<isal_gcm_context_data*> decrypt_gcm_pool;
+#else
+    std::vector<EVP_CIPHER_CTX*> encrypt_gcm_pool;
+    std::vector<EVP_CIPHER_CTX*> decrypt_gcm_pool;
+#endif
+
 public:
    timerfd_manager_t *tfd = NULL;
    ring_loop_t *ringloop = NULL;
    bool has_sendmsg_zc = false;
-    // osd_num_t is only for logging and asserts
    uint64_t next_client_id = 1;
-    osd_num_t osd_num;
+    // osd_num = 0 for client messenger, osd_num > 0 for OSD messenger
+    osd_num_t osd_num = 0;
+    uint32_t clean_entry_bitmap_size = 0;
+    uint32_t bs_block_size = 0;
+    uint32_t max_write_request_size = 0;
    robin_hood::unordered_flat_map<uint64_t, osd_client_t*> clients;
    robin_hood::unordered_flat_map<uint64_t, osd_client_t*> osd_peers;
    robin_hood::unordered_flat_map<int, osd_client_t*> clients_by_fd;
@@ -230,11 +327,12 @@ public:
    std::vector<addr_mask_t> osd_cluster_network_masks;
    std::vector<std::string> all_osd_networks;
    std::vector<addr_mask_t> all_osd_network_masks;
+    int use_proto_checksums = 0;
    // op statistics
    osd_op_stats_t stats, recovery_stats;

    void init();
-    void parse_config(const json11::Json & config);
+    void parse_config(const json11::Json & config, bool init);
    void connect_peer(uint64_t osd_num, json11::Json peer_state);
    void stop_client(uint64_t client_id, bool force_delete = false);
    void destroy_client(osd_client_t *cl);
@@ -243,6 +341,7 @@ public:
    std::function<void(osd_num_t)> repeer_pgs;
    std::function<void(osd_num_t)> break_pg_locks;
    std::function<bool(osd_client_t*, json11::Json)> check_config_hook;
+    std::function<void(osd_client_t*)> handshake_hook;
    void read_requests();
    void send_replies();
    void accept_connections(int listen_fd);
@@ -263,6 +362,7 @@ public:
    rdma_cm_id *rdmacm_listen(const std::string & bind_address, int rdmacm_port, int *bound_port, int log_level);
    void rdmacm_destroy_listener(rdma_cm_id *listener);
 #endif
+    bool is_encryption_enabled();

    void inc_op_stats(osd_op_stats_t & stats, uint64_t opcode, timespec & tv_begin, timespec & tv_end, uint64_t len);
    void measure_exec(osd_op_t *cur_op);
@@ -279,15 +379,30 @@ protected:

    bool try_send(osd_client_t *cl);
    void handle_send(int result, bool prev, bool more, osd_client_t *cl);
+    bool op_write_to(osd_client_t *cl, msgr_op_writer_t & wr);
+    void next_write_op(osd_client_t *cl);
+    bool op_write_buf(osd_client_t *cl, uint8_t *src, size_t src_len, uint8_t *dst, size_t dst_len, bool skip_csum, size_t & from, size_t & done);
+    bool op_copy_data_to(osd_client_t *cl, uint8_t *dst, size_t dst_len, size_t & from, size_t & done);
+    size_t copy_ops_to(osd_client_t *cl, uint8_t *dst, size_t dst_len);
+    template<typename T> size_t copy_ops_to_with(osd_client_t *cl, uint8_t *dst, size_t dst_len);

-    bool handle_read(int result, osd_client_t *cl);
-    bool handle_read_buffer(osd_client_t *cl, void *curbuf, int remain);
-    bool handle_finished_read(osd_client_t *cl);
-    void handle_op_hdr(osd_client_t *cl);
-    bool handle_reply_hdr(osd_client_t *cl);
-    void handle_reply_ready(osd_op_t *op);
+    void handle_read(int result, osd_client_t *cl);
+    bool handle_read_buffer(osd_client_t *cl, uint8_t *curbuf, size_t bufsize);
+    template<typename T> bool handle_buffer_with(osd_client_t *cl, uint8_t *curbuf, size_t bufsize);
+    bool handle_hdr(osd_client_t *cl);
+    bool allocate_op_buffers(osd_client_t *cl);
+    bool allocate_reply_buffers(osd_client_t *cl, osd_op_t *op);
+    bool op_read_from(osd_client_t *cl, msgr_op_reader_t & rdr);
+    bool handle_finished_op(osd_client_t *cl);
    void handle_immediate_ops();

+    void op_encrypted_copy_buf(osd_client_t *cl, uint8_t *enc_buf, size_t enc_len, uint8_t *plain, size_t plain_len, size_t & done_plain, size_t & done_enc);
+    void op_encrypt_free(osd_client_t* cl);
+    void op_decrypted_copy_buf(osd_client_t *cl, uint8_t *enc_buf, size_t enc_len, uint8_t *plain, size_t plain_len, size_t & done_plain, size_t & done_enc);
+    void op_decrypt_start(osd_client_t* cl);
+    void op_decrypt_inline(osd_client_t* cl);
+    void op_decrypt_free(osd_client_t* cl);
+
 #ifdef WITH_RDMA
    void try_send_rdma(osd_client_t *cl);
    bool init_recv_rdma(osd_client_t *cl);
@@ -0,0 +1,601 @@
+// Copyright (c) Vitaliy Filippov, 2026+
+// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
+
+#include <assert.h>
+
+#ifdef WITH_ISAL_CRYPTO
+#include <isa-l_crypto/isal_crypto_api.h>
+#endif
+
+#include "str_util.h"
+#include "etcd_state_client.h"
+#include "messenger.h"
+#include "msgr_encrypt.h"
+#include "http_client.h"
+#include "openssl_util.h"
+
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+
+op_aes_xts_encrypt_t::op_aes_xts_encrypt_t()
+{
+#ifndef WITH_ISAL_CRYPTO
+    if (!(ctx = EVP_CIPHER_CTX_new()))
+    {
+        ERR_print_errors_fp(stderr);
+        abort();
+    }
+    EVP_CIPHER_CTX_set_padding(ctx, 0);
+    if (EVP_EncryptInit_ex(ctx, EVP_aes_256_xts(), NULL, NULL, NULL) != 1)
+    {
+        ERR_print_errors_fp(stderr);
+        abort();
+    }
+#endif
+}
+
+op_aes_xts_encrypt_t::~op_aes_xts_encrypt_t()
+{
+    assert(!encrypted);
+#ifndef WITH_ISAL_CRYPTO
+    EVP_CIPHER_CTX_free(ctx);
+#endif
+    if (tmp)
+        free(tmp);
+}
+
+void op_aes_xts_encrypt_t::start(uint8_t *key, uint64_t start_offset, size_t block_size)
+{
+    assert(!encrypted);
+    this->start_offset = start_offset;
+    this->key = key;
+    this->block_size = block_size;
+    this->offset = 0;
+    this->encrypted = false;
+    this->tmp_pos = 0;
+    if (tmp && tmp_size != block_size)
+    {
+        free(tmp);
+        tmp = NULL;
+        tmp_size = 0;
+    }
+#ifndef WITH_ISAL_CRYPTO
+    if (EVP_EncryptInit_ex(ctx, NULL, NULL, key, NULL) != 1)
+    {
+        ERR_print_errors_fp(stderr);
+        abort();
+    }
+#endif
+}
+
+void op_aes_xts_encrypt_t::encrypt_block(uint8_t *in, uint8_t *out)
+{
+    uint8_t iv[16] = { 0 };
+    *((uint64_t*)iv) = start_offset + offset - offset%block_size;
+#ifdef WITH_ISAL_CRYPTO
+    int r = isal_aes_xts_enc_256(key+32, key, iv, block_size, in, out);
+    assert(r == 0 || r == ISAL_CRYPTO_ERR_XTS_SAME_KEYS);
+#else
+    if (EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv) != 1)
+    {
+        ERR_print_errors_fp(stderr);
+        abort();
+    }
+    int actual_out = 0;
+    if (EVP_EncryptUpdate(ctx, out, &actual_out, in, block_size) != 1)
+    {
+        ERR_print_errors_fp(stderr);
+        abort();
+    }
+    assert(actual_out == block_size);
+#endif
+}
+
+void op_aes_xts_encrypt_t::update(uint8_t *in, size_t max_in, uint8_t *out, size_t max_out, size_t & done_in, size_t & done_out)
+{
+    // Fucking AES-XTS implementations (all of them) don't have streaming support,
+    // crafting IV to resume encryption is slow, so we have to accumulate a full block
+    // and encrypt it at once :-(
+    // And then we have to support consuming it in parts because it's simpler for the
+    // higher layers.
+    if (encrypted)
+    {
+        // Copy accumulated and encrypted output
+        assert(tmp);
+        if (max_out > block_size - tmp_pos)
+            max_out = block_size - tmp_pos;
+        memcpy(out, tmp + tmp_pos, max_out);
+        done_out += max_out;
+        tmp_pos += max_out;
+        if (tmp_pos >= block_size)
+        {
+            encrypted = false;
+            done_in += 1;
+        }
+    }
+    else if (max_in < block_size - offset%block_size)
+    {
+        // Just accumulate input
+        if (!tmp)
+        {
+            tmp = (uint8_t*)malloc_or_die(block_size);
+            tmp_size = block_size;
+        }
+        memcpy(tmp + offset%block_size, in, max_in);
+        done_in += max_in;
+        offset += max_in;
+    }
+    else if (max_out < block_size)
+    {
+        // Accumulate and encrypt input in <tmp>, then copy part of it to <out>
+        if (!tmp)
+        {
+            tmp = (uint8_t*)malloc_or_die(block_size);
+            tmp_size = block_size;
+        }
+        max_in = block_size - offset%block_size;
+        memcpy(tmp + offset%block_size, in, max_in);
+        encrypt_block(tmp, tmp);
+        encrypted = true;
+        memcpy(out, tmp, max_out);
+        tmp_pos = max_out;
+        done_in += max_in-1;
+        offset += max_in;
+        done_out += max_out;
+    }
+    else if (!(offset%block_size))
+    {
+        // Full block - simplest case
+        encrypt_block(in, out);
+        done_in += block_size;
+        offset += block_size;
+        done_out += block_size;
+    }
+    else
+    {
+        // Accumulate input and encrypt directly to <output>
+        assert(tmp);
+        max_in = block_size - offset%block_size;
+        memcpy(tmp + offset%block_size, in, max_in);
+        encrypt_block(tmp, out);
+        done_in += max_in;
+        offset += max_in;
+        done_out += block_size;
+    }
+}
+
+void destroy_aes_xts_encrypt(op_aes_xts_encrypt_t *encrypt_ctx)
+{
+    delete encrypt_ctx;
+}
+
+op_aes_xts_decrypt_t::op_aes_xts_decrypt_t()
+{
+#ifndef WITH_ISAL_CRYPTO
+    if (!(ctx = EVP_CIPHER_CTX_new()))
+    {
+        ERR_print_errors_fp(stderr);
+        abort();
+    }
+    EVP_CIPHER_CTX_set_padding(ctx, 0);
+    if (EVP_DecryptInit_ex(ctx, EVP_aes_256_xts(), NULL, NULL, NULL) != 1)
+    {
+        ERR_print_errors_fp(stderr);
+        abort();
+    }
+#endif
+}
+
+op_aes_xts_decrypt_t::~op_aes_xts_decrypt_t()
+{
+    assert(!decrypted);
+#ifndef WITH_ISAL_CRYPTO
+    EVP_CIPHER_CTX_free(ctx);
+#endif
+    if (tmp)
+        free(tmp);
+}
+
+void op_aes_xts_decrypt_t::start(uint8_t **key_chain, size_t chain_size, void *key_indexes, uint64_t start_offset, size_t block_size)
+{
+    assert(!decrypted);
+    this->start_offset = start_offset;
+    this->key_chain = key_chain;
+    this->chain_size = chain_size;
+    this->key_indexes = key_indexes;
+    this->key_index_bytes = osd_op_rw_t::chain_info_bytes(chain_size);
+    assert(chain_size <= 1 || key_indexes != NULL);
+    this->block_size = block_size;
+    this->offset = 0;
+    this->tmp_pos = 0;
+    if (tmp && tmp_size != block_size)
+    {
+        free(tmp);
+        tmp = NULL;
+        tmp_size = 0;
+    }
+#ifndef WITH_ISAL_CRYPTO
+    if (chain_size == 1 && key_chain[0] && EVP_DecryptInit_ex(ctx, NULL, NULL, key_chain[0], NULL) != 1)
+    {
+        ERR_print_errors_fp(stderr);
+        abort();
+    }
+#endif
+}
+
+void op_aes_xts_decrypt_t::decrypt_block(uint8_t *in, uint8_t *out)
+{
+    uint8_t *key = NULL;
+    if (chain_size > 1)
+    {
+        uint32_t key_index = key_index_bytes == 1
+            ? ((uint8_t*)key_indexes)[offset/block_size]
+            : (key_index_bytes == 2
+                ? ((uint16_t*)key_indexes)[offset/block_size]
+                : (key_index_bytes == 4
+                    ? ((uint32_t*)key_indexes)[offset/block_size]
+                    : UINT32_MAX));
+        assert(key_index < chain_size);
+        key = key_chain[key_index];
+    }
+    else
+    {
+        key = key_chain[0];
+    }
+    if (!key)
+    {
+        if (in != out)
+            memcpy(out, in, block_size);
+        return;
+    }
+    uint8_t iv[16] = { 0 };
+    *((uint64_t*)iv) = start_offset + offset - offset%block_size;
+#ifdef WITH_ISAL_CRYPTO
+    int r = isal_aes_xts_dec_256(key+32, key, iv, block_size, in, out);
+    assert(r == 0 || r == ISAL_CRYPTO_ERR_XTS_SAME_KEYS);
+#else
+    if (EVP_DecryptInit_ex(ctx, NULL, NULL, chain_size == 1 ? NULL : key, iv) != 1)
+    {
+        ERR_print_errors_fp(stderr);
+        abort();
+    }
+    int actual_out = 0;
+    if (EVP_DecryptUpdate(ctx, out, &actual_out, in, block_size) != 1)
+    {
+        ERR_print_errors_fp(stderr);
+        abort();
+    }
+    assert(actual_out == block_size);
+#endif
+}
+
+// out may be NULL, in this case all input is still decrypted to calculate checksums,
+// but part of it is skipped and not copied to out
+void op_aes_xts_decrypt_t::update(uint8_t *in, size_t max_in, uint8_t *out, size_t max_out, size_t & done_in, size_t & done_out)
+{
+    // Fucking AES-XTS implementations (all of them) don't have streaming support,
+    // crafting IV to resume decryption is slow, so we have to accumulate a full block
+    // and decrypt it at once :-(
+    // And then we have to support consuming it in parts because clients sometimes need
+    // fragmented output.
+    if (decrypted)
+    {
+        // Copy accumulated and decrypted output
+        assert(tmp);
+        if (max_out > block_size - tmp_pos)
+            max_out = block_size - tmp_pos;
+        if (out)
+            memcpy(out, tmp + tmp_pos, max_out);
+        done_out += max_out;
+        tmp_pos += max_out;
+        if (tmp_pos >= block_size)
+        {
+            decrypted = false;
+            done_in += 1;
+        }
+    }
+    else if (max_in < block_size - offset%block_size)
+    {
+        // Just accumulate input
+        if (!tmp)
+        {
+            tmp = (uint8_t*)malloc_or_die(block_size);
+            tmp_size = block_size;
+        }
+        memcpy(tmp + offset%block_size, in, max_in);
+        done_in += max_in;
+        offset += max_in;
+    }
+    else if (max_out < block_size || !out)
+    {
+        // Accumulate and decrypt input in <tmp>, then copy part of it to <out>
+        if (!tmp)
+        {
+            tmp = (uint8_t*)malloc_or_die(block_size);
+            tmp_size = block_size;
+        }
+        max_in = block_size - offset%block_size;
+        memcpy(tmp + offset%block_size, in, max_in);
+        decrypt_block(tmp, tmp);
+        decrypted = true;
+        if (out)
+            memcpy(out, tmp, max_out);
+        tmp_pos = max_out;
+        done_in += max_in-1;
+        offset += max_in;
+        done_out += max_out;
+    }
+    else if (!(offset%block_size))
+    {
+        // Full block - simplest case
+        if (out)
+            decrypt_block(in, out);
+        done_in += block_size;
+        offset += block_size;
+        done_out += block_size;
+    }
+    else
+    {
+        // Accumulate input and decrypt directly to <output>
+        assert(tmp);
+        max_in = block_size - offset%block_size;
+        memcpy(tmp + offset%block_size, in, max_in);
+        assert(out);
+        decrypt_block(tmp, out);
+        done_in += max_in;
+        offset += max_in;
+        done_out += block_size;
+    }
+}
+
+void destroy_aes_xts_decrypt(op_aes_xts_decrypt_t *decrypt_ctx)
+{
+    delete decrypt_ctx;
+}
+
+void osd_messenger_t::op_encrypted_copy_buf(osd_client_t *cl, uint8_t *enc_buf, size_t enc_len, uint8_t *plain, size_t plain_len, size_t & done_plain, size_t & done_enc)
+{
+    if (!cl->xts_enc_ctx)
+    {
+        if (encrypt_xts_pool.size())
+        {
+            cl->xts_enc_ctx = encrypt_xts_pool.back();
+            encrypt_xts_pool.pop_back();
+        }
+        else
+            cl->xts_enc_ctx = new op_aes_xts_encrypt_t();
+        assert(cl->write_op->enc->key_chain[0]);
+        cl->xts_enc_ctx->start(cl->write_op->enc->key_chain[0], cl->write_op->req.rw.offset, cl->write_op->enc->bitmap_granularity);
+    }
+    while (done_plain < plain_len && done_enc < enc_len)
+    {
+        size_t done_in = 0;
+        size_t done_out = 0;
+        cl->xts_enc_ctx->update(plain+done_plain, plain_len-done_plain, enc_buf+done_enc, enc_len-done_enc, done_in, done_out);
+        if (cl->write_csum_state && done_out > 0)
+            XXH3_64bits_update(cl->write_csum_state, enc_buf+done_enc, done_out);
+        done_enc += done_out;
+        cl->write_op_pos += done_in;
+        done_plain += done_in;
+    }
+}
+
+void osd_messenger_t::op_decrypted_copy_buf(osd_client_t *cl, uint8_t *enc_buf, size_t enc_len, uint8_t *plain, size_t plain_len, size_t & done_plain, size_t & done_enc)
+{
+    op_decrypt_start(cl);
+    while (done_plain < plain_len && done_enc < enc_len)
+    {
+        size_t done_in = 0;
+        size_t done_out = 0;
+        // plain == NULL means skip output
+        cl->xts_dec_ctx->update(enc_buf+done_enc, enc_len-done_enc, plain ? plain+done_plain : NULL, plain_len-done_plain, done_in, done_out);
+        if (cl->read_csum_state && done_in > 0)
+            XXH3_64bits_update(cl->read_csum_state, enc_buf+done_enc, done_in);
+        done_enc += done_in;
+        cl->read_op_pos += done_out;
+        cl->read_op_inline_decrypt_in += done_in;
+        done_plain += done_out;
+    }
+}
+
+void osd_messenger_t::op_decrypt_start(osd_client_t* cl)
+{
+    if (!cl->xts_dec_ctx)
+    {
+        if (decrypt_xts_pool.size())
+        {
+            cl->xts_dec_ctx = decrypt_xts_pool.back();
+            decrypt_xts_pool.pop_back();
+        }
+        else
+            cl->xts_dec_ctx = new op_aes_xts_decrypt_t();
+        auto & enc = cl->read_op->enc;
+        assert(cl->read_op->req.hdr.opcode == OSD_OP_READ);
+        cl->xts_dec_ctx->start(enc->key_chain, enc->chain_size,
+            (cl->read_op->req.rw.flags & OSD_OP_RETURN_CHAIN) ? (uint8_t*)cl->read_op->bitmap + enc->read_chain_bitmap_pos : 0,
+            cl->read_op->req.rw.offset, enc->bitmap_granularity);
+    }
+}
+
+void osd_messenger_t::op_decrypt_inline(osd_client_t* cl)
+{
+    op_decrypt_start(cl);
+    osd_op_t *op = cl->read_op;
+    size_t from_in = cl->read_op_inline_decrypt_in;
+    int i = 0;
+    while (i < op->iov.count && from_in >= op->iov.buf[i].iov_len)
+    {
+        from_in -= op->iov.buf[i].iov_len;
+        i++;
+    }
+    size_t from_out = cl->read_op_inline_decrypt_pos - OSD_PACKET_SIZE - op->reply.rw.bitmap_len;
+    int j = 0;
+    while (j < op->iov.count && from_out >= op->iov.buf[j].iov_len)
+    {
+        from_out -= op->iov.buf[j].iov_len;
+        j++;
+    }
+    while (i < op->iov.count && j < op->iov.count)
+    {
+        uint8_t *in = (uint8_t*)op->iov.buf[i].iov_base + from_in;
+        size_t in_len = op->iov.buf[i].iov_len - from_in;
+        uint8_t *out = (uint8_t*)op->iov.buf[j].iov_base + from_out;
+        size_t out_len = op->iov.buf[j].iov_len - from_out;
+        size_t done_in = 0;
+        size_t done_out = 0;
+        cl->xts_dec_ctx->update(in, in_len, out, out_len, done_in, done_out);
+        if (done_in >= in_len)
+        {
+            i++;
+            from_in = 0;
+        }
+        else
+            from_in += done_in;
+        if (done_out >= out_len)
+        {
+            j++;
+            from_out = 0;
+        }
+        else
+            from_out += done_out;
+    }
+    assert(j >= op->iov.count);
+}
+
+void osd_messenger_t::op_decrypt_free(osd_client_t* cl)
+{
+    if (cl->xts_dec_ctx)
+    {
+        if (decrypt_xts_pool.size() > max_cipher_pool_size)
+            delete cl->xts_dec_ctx;
+        else
+            decrypt_xts_pool.push_back(cl->xts_dec_ctx);
+        cl->xts_dec_ctx = NULL;
+    }
+}
+
+void osd_messenger_t::op_encrypt_free(osd_client_t* cl)
+{
+    if (cl->xts_enc_ctx)
+    {
+        if (encrypt_xts_pool.size() > max_cipher_pool_size)
+            delete cl->xts_enc_ctx;
+        else
+            encrypt_xts_pool.push_back(cl->xts_enc_ctx);
+        cl->xts_enc_ctx = NULL;
+    }
+}
+
+bool osd_messenger_t::derive_aes_keys(osd_client_t *cl, bool update_my, bool update_peer)
+{
+    if (!cl->hs_result.shared_secret.size())
+    {
+        cl->hs_result = cl->hs->get_result();
+        if (handshake_hook)
+        {
+            handshake_hook(cl);
+        }
+    }
+    std::vector<uint8_t> old_my = cl->my_key, old_peer = cl->peer_key;
+    // Both keys include AES key and iv + xxhash3 secret
+    const auto len = AES_256_GCM_KEY_SIZE + AES_256_GCM_IV_SIZE + XXH_SECRET_DEFAULT_SIZE;
+    cl->my_key.resize(len);
+    cl->peer_key.resize(len);
+    bool ok = true;
+    if (update_my || !old_my.size())
+    {
+        ok = ok && hs_ctx->derive_kdf(cl->hs_result.shared_secret.data(), cl->hs_result.shared_secret.size(),
+            old_my.size() ? old_my.data() : NULL, old_my.size(),
+            cl->is_incoming ? "server key" : "client key", cl->my_key.data(), len);
+#ifdef WITH_ISAL_CRYPTO
+        if (ok)
+            isal_aes_gcm_pre_256(cl->my_key.data(), &cl->my_key_isal);
+#endif
+        cl->my_iv_ctr = 0;
+    }
+    if (update_peer || !old_peer.size())
+    {
+        ok = ok && hs_ctx->derive_kdf(cl->hs_result.shared_secret.data(), cl->hs_result.shared_secret.size(),
+            old_peer.size() ? old_peer.data() : NULL, old_peer.size(),
+            !cl->is_incoming ? "server key" : "client key", cl->peer_key.data(), len);
+#ifdef WITH_ISAL_CRYPTO
+        if (ok)
+            isal_aes_gcm_pre_256(cl->peer_key.data(), &cl->peer_key_isal);
+#endif
+        cl->peer_iv_ctr = 0;
+    }
+    return ok;
+}
+
+void osd_messenger_t::init_tls()
+{
+    if (!tls_cert.empty() || !tls_key.empty() || !osd_tls_ca.empty() || !client_tls_ca.empty())
+    {
+        if (tls_cert.empty() || tls_key.empty() || osd_tls_ca.empty() || osd_num && client_tls_ca.empty())
+        {
+            if (osd_num)
+                fprintf(stderr, "Vitastor transport encryption requires osd_cert, osd_pkey, osd_ca, client_ca options for OSDs\n");
+            else
+                fprintf(stderr, "Vitastor transport encryption requires cert, pkey and osd_ca options\n");
+            exit(1);
+        }
+        else
+        {
+#ifndef __MOCK__
+            gcm_enabled = true;
+            hs_ctx = msgr_handshake_ctx_i::create_ctx();
+            if (!hs_ctx->init(tls_cert, tls_key, osd_tls_ca, client_tls_ca))
+            {
+                fprintf(stderr, "Error: %s\n", hs_ctx->get_error().c_str());
+                exit(1);
+            }
+#endif
+        }
+    }
+}
+
+void osd_messenger_t::init_tls_client(osd_client_t *cl)
+{
+    if (gcm_enabled)
+    {
+        cl->gcm_enabled = true;
+        cl->hs = hs_ctx->create();
+        cl->hs->init(cl->is_incoming);
+        if (cl->hs->get_out().size())
+        {
+            if (cl->write_state == 0)
+            {
+                cl->write_state = CL_WRITE_READY;
+                write_ready_clients.push_back(cl->client_id);
+            }
+        }
+    }
+}
+
+void osd_messenger_t::destroy_tls()
+{
+#ifdef WITH_ISAL_CRYPTO
+    for (isal_gcm_context_data *ctx: encrypt_gcm_pool)
+    {
+        free(ctx);
+    }
+    for (isal_gcm_context_data *ctx: decrypt_gcm_pool)
+    {
+        free(ctx);
+    }
+#else
+    for (EVP_CIPHER_CTX *ctx: encrypt_gcm_pool)
+    {
+        EVP_CIPHER_CTX_free(ctx);
+    }
+    for (EVP_CIPHER_CTX *ctx: decrypt_gcm_pool)
+    {
+        EVP_CIPHER_CTX_free(ctx);
+    }
+#endif
+    if (hs_ctx)
+    {
+        delete hs_ctx;
+        hs_ctx = NULL;
+    }
+}
@@ -0,0 +1,68 @@
+// Copyright (c) Vitaliy Filippov, 2026+
+// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
+
+#include <stdint.h>
+
+#ifdef WITH_ISAL_CRYPTO
+#include <isa-l_crypto/aes_xts.h>
+#endif
+
+#include "../util/xxh_x86dispatch.h"
+#include <openssl/conf.h>
+#include <openssl/evp.h>
+#include <openssl/err.h>
+
+class op_aes_xts_encrypt_t
+{
+#ifndef WITH_ISAL_CRYPTO
+    EVP_CIPHER_CTX *ctx = NULL;
+#endif
+    uint64_t start_offset = 0;
+    uint8_t *key = NULL;
+    size_t offset = 0;
+    size_t block_size = 0;
+    uint8_t *tmp = NULL;
+    size_t tmp_size = 0;
+    size_t tmp_pos = 0;
+    bool encrypted = false;
+
+    void encrypt_block(uint8_t *in, uint8_t *out);
+
+public:
+    op_aes_xts_encrypt_t();
+    ~op_aes_xts_encrypt_t();
+
+    void start(uint8_t *key, uint64_t start_offset, size_t block_size);
+    void update(uint8_t *in, size_t max_in, uint8_t *out, size_t max_out, size_t & done_in, size_t & done_out);
+};
+
+void destroy_aes_xts_encrypt(op_aes_xts_encrypt_t *encrypt_ctx);
+
+class op_aes_xts_decrypt_t
+{
+#ifndef WITH_ISAL_CRYPTO
+    EVP_CIPHER_CTX *ctx = NULL;
+#endif
+    uint64_t start_offset = 0;
+    uint8_t **key_chain = NULL;
+    size_t chain_size = 0;
+    void *key_indexes = NULL;
+    int key_index_bytes = 0;
+    size_t offset = 0;
+    size_t block_size = 0;
+    uint8_t *tmp = NULL;
+    size_t tmp_size = 0;
+    size_t tmp_pos = 0;
+    bool decrypted = false;
+
+    void decrypt_block(uint8_t *in, uint8_t *out);
+
+public:
+    op_aes_xts_decrypt_t();
+    ~op_aes_xts_decrypt_t();
+
+    void start(uint8_t **key_chain, size_t chain_size, void *key_indexes, uint64_t start_offset, size_t block_size);
+    void update(uint8_t *in, size_t max_in, uint8_t *out, size_t max_out, size_t & done_in, size_t & done_out);
+};
+
+void destroy_aes_xts_decrypt(op_aes_xts_decrypt_t *decrypt_ctx);
@@ -0,0 +1,765 @@
+// Copyright (c) Vitaliy Filippov, 2026+
+// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
+
+#include <stdint.h>
+#include <assert.h>
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <openssl/conf.h>
+#include <openssl/evp.h>
+#include <openssl/obj_mac.h>
+#include <openssl/ec.h>
+#include <openssl/kdf.h>
+#include <openssl/bio.h>
+#include <openssl/pem.h>
+#include <openssl/err.h>
+
+#include "msgr_handshake.h"
+#include "openssl_util.h"
+#include "str_util.h"
+
+#define AES_256_GCM_KEY_SIZE 32
+#define AES_256_GCM_IV_SIZE 12
+
+// TLS 1.3-like handshake
+
+// 1. Client->server: EC public key
+// 2. Server->client: EC public key, encrypted certificate and digital signature of the handshake
+// 3. Client->server: encrypted certificate and digital signature of the handshake
+
+// "vitaECDH" interleaved
+#define MSGR_HS_MAGIC 0x4861447443694576l
+#define MSGR_HS_MAX_LEN 131072
+
+#define MSGR_HS_SERVER_INIT 0
+#define MSGR_HS_CLIENT_INIT 1
+#define MSGR_HS_SERVER_REPLY 2
+#define MSGR_HS_CLIENT_REPLY 3
+#define MSGR_HS_DONE 100
+#define MSGR_HS_ERROR 101
+
+struct __attribute__((__packed__)) msgr_handshake_hdr_t
+{
+    uint32_t msg_len;
+    uint64_t magic;
+    uint32_t type;
+};
+
+class msgr_handshake_ctx_t: public msgr_handshake_ctx_i
+{
+    friend class msgr_handshake_t;
+
+    EVP_PKEY_CTX *pctx = NULL;
+    EVP_PKEY *params = NULL;
+    X509_STORE *ca = NULL;
+    X509 *osd_ca = NULL;
+    X509 *client_ca = NULL;
+    std::string my_cert_pem;
+    X509 *my_cert = NULL;
+    EVP_PKEY *my_pubkey = NULL;
+    const EVP_MD *md = NULL;
+    EVP_PKEY *my_privkey = NULL;
+    EVP_KDF_CTX* kdf_ctx = NULL;
+    std::string error;
+
+    bool on_error(const std::string & prefix);
+
+public:
+    ~msgr_handshake_ctx_t();
+    msgr_handshake_i* create() override;
+    bool init(const std::string & pem_cert, const std::string & pem_key,
+        const std::string & pem_osd_ca, const std::string & pem_client_ca) override;
+    std::string get_error() override;
+    bool derive_kdf(const uint8_t* insecret, size_t insecret_len,
+        const uint8_t* salt, size_t salt_len, const char *label, uint8_t *outsecret, size_t outsize) override;
+};
+
+class msgr_handshake_t: public msgr_handshake_i
+{
+    msgr_handshake_ctx_t *ctx = NULL;
+    bool is_server = false;
+
+    std::vector<uint8_t> full_handshake;
+    std::vector<uint8_t> in_buf;
+    std::vector<uint8_t> out_buf;
+    std::string error;
+
+    int state = 0;
+
+    EVP_PKEY *ec_key = NULL;
+    X509 *peer_cert = NULL;
+    bool peer_is_osd = false;
+    std::vector<uint8_t> shared_secret;
+    std::vector<uint8_t> hs_key, peer_hs_key;
+
+    msgr_handshake_hdr_t *cur_hdr = NULL;
+    uint8_t *cur_buf = NULL;
+    size_t cur_left = 0;
+
+    bool on_error(const std::string & prefix);
+    bool derive_shared_secret(EVP_PKEY *peer_ec_key);
+    bool derive_hs_keys(const uint8_t *encoded_peer_key, size_t encoded_key_len);
+    bool sign(std::vector<uint8_t> & out);
+    bool verify(const uint8_t *signature, size_t signature_len);
+    bool encrypt(const uint8_t* src, size_t len, uint8_t* dest);
+    bool decrypt(const uint8_t* src, size_t & len, uint8_t* dest);
+    bool make_client_init();
+    bool make_server_reply();
+    bool make_client_reply();
+    bool verify_peer(const uint8_t *peer_cert_pem, size_t peer_cert_len);
+    ssize_t start_msg(uint8_t* src, size_t len, uint32_t expected_type);
+    bool read_with_len(const uint8_t* & dst, uint32_t & dst_len);
+    bool handle_client_init();
+    bool handle_server_reply();
+    bool handle_client_reply();
+    bool handle_peer_cert(const uint8_t *key, uint32_t key_len);
+    void complete();
+
+public:
+    // Workflow: create -> init -> handle -> get_result/get_error -> destruct
+    msgr_handshake_t(msgr_handshake_ctx_t *ctx): ctx(ctx) {}
+    ~msgr_handshake_t();
+    bool init(bool server_mode) override;
+    ssize_t handle(uint8_t* in_buf, size_t in_size) override;
+    bool done() override;
+    std::vector<uint8_t>& get_out() override;
+    msgr_handshake_result_t get_result() override;
+    std::string get_error() override;
+};
+
+msgr_handshake_ctx_i* msgr_handshake_ctx_i::create_ctx()
+{
+    return new msgr_handshake_ctx_t();
+}
+
+msgr_handshake_i* msgr_handshake_ctx_t::create()
+{
+    return new msgr_handshake_t(this);
+}
+
+bool msgr_handshake_ctx_t::init(const std::string & pem_cert, const std::string & pem_key,
+    const std::string & pem_osd_ca, const std::string & pem_client_ca)
+{
+    if (pem_cert.substr(0, 5) == "-----")
+        my_cert_pem = pem_cert;
+    else
+    {
+        my_cert_pem = read_file(pem_cert);
+        if (my_cert_pem.empty())
+        {
+            error = "Failed to load certificate file";
+            return false;
+        }
+    }
+    {
+        BIO *bio = BIO_new_mem_buf(my_cert_pem.data(), my_cert_pem.size());
+        if (!bio)
+            return on_error("BIO_new_mem_buf: ");
+        my_cert = PEM_read_bio_X509(bio, NULL, 0, NULL);
+        BIO_free(bio);
+        if (!my_cert)
+            return on_error("Failed to load certificate: ");
+    }
+    if (!(my_pubkey = X509_get0_pubkey(my_cert)))
+        return on_error("X509_get0_pubkey: ");
+    if (!(md = EVP_get_digestbynid(NID_sha384)))
+        return on_error("EVP_get_digestbynid SHA384: ");
+    if (!(my_privkey = openssl_load_key(pem_key)))
+        return on_error("Failed to load private key: ");
+    if (!(ca = X509_STORE_new()))
+        return on_error("X509_STORE_CTX_new: ");
+    if (!(osd_ca = openssl_load_cert(pem_osd_ca)))
+        return on_error("Failed to load OSD CA certificate: ");
+    if (X509_STORE_add_cert(ca, osd_ca) <= 0)
+        return on_error("X509_STORE_add_cert OSD CA: ");
+    if (!pem_client_ca.empty() && !(client_ca = openssl_load_cert(pem_client_ca)))
+        return on_error("Failed to load client CA certificate: ");
+    if (client_ca && X509_STORE_add_cert(ca, client_ca) <= 0)
+        return on_error("X509_STORE_add_cert client CA: ");
+    if (!(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL)))
+        return on_error("EVP_PKEY_CTX_new_id: ");
+    if (EVP_PKEY_paramgen_init(pctx) <= 0)
+        return on_error("EVP_PKEY_paramgen_init: ");
+    if (EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, /*NID_X9_62_prime256v1*/NID_secp384r1) <= 0)
+        return on_error("EVP_PKEY_CTX_set_ec_paramgen_curve_nid: ");
+    if (EVP_PKEY_paramgen(pctx, &params) <= 0)
+        return on_error("EVP_PKEY_paramgen: ");
+    EVP_KDF *kdf = EVP_KDF_fetch(NULL, "hkdf", NULL);
+    if (!kdf)
+        return on_error("EVP_KDF_fetch: ");
+    kdf_ctx = EVP_KDF_CTX_new(kdf);
+    EVP_KDF_free(kdf);
+    return true;
+}
+
+std::string msgr_handshake_ctx_t::get_error()
+{
+    return error;
+}
+
+msgr_handshake_ctx_t::~msgr_handshake_ctx_t()
+{
+    if (pctx)
+        EVP_PKEY_CTX_free(pctx);
+    if (params)
+        EVP_PKEY_free(params);
+    if (ca)
+        X509_STORE_free(ca);
+    if (osd_ca)
+        X509_free(osd_ca);
+    if (client_ca)
+        X509_free(client_ca);
+    my_pubkey = NULL;
+    if (my_cert)
+        X509_free(my_cert);
+    if (my_privkey)
+        EVP_PKEY_free(my_privkey);
+    if (kdf_ctx)
+        EVP_KDF_CTX_free(kdf_ctx);
+}
+
+bool msgr_handshake_ctx_t::on_error(const std::string & prefix)
+{
+    error = prefix+ERR_error_string(ERR_get_error(), NULL);
+    return false;
+}
+
+bool msgr_handshake_ctx_t::derive_kdf(const uint8_t* insecret, size_t insecret_len,
+    const uint8_t* salt, size_t salt_len, const char *label, uint8_t *outsecret, size_t outsize)
+{
+    OSSL_PARAM params[5];
+    int n = 0;
+    params[n++] = OSSL_PARAM_construct_utf8_string("digest", (char*)"sha384", (size_t)7);
+    params[n++] = OSSL_PARAM_construct_octet_string("key", (void*)insecret, insecret_len);
+    params[n++] = OSSL_PARAM_construct_octet_string("info", (void*)label, strlen(label)+1);
+    params[n++] = OSSL_PARAM_construct_octet_string("salt", (salt ? (void*)salt : (void*)""), salt_len);
+    params[n++] = OSSL_PARAM_construct_end();
+    assert(n <= sizeof(params)/sizeof(OSSL_PARAM));
+    if (EVP_KDF_CTX_set_params(kdf_ctx, params) <= 0)
+        return false;
+    if (EVP_KDF_derive(kdf_ctx, outsecret, outsize, NULL) <= 0)
+        return false;
+    return true;
+}
+
+msgr_handshake_t::~msgr_handshake_t()
+{
+    if (peer_cert)
+        X509_free(peer_cert);
+    if (ec_key)
+        EVP_PKEY_free(ec_key);
+}
+
+bool msgr_handshake_t::on_error(const std::string & prefix)
+{
+    error = prefix+ERR_error_string(ERR_get_error(), NULL);
+    state = MSGR_HS_ERROR;
+    return false;
+}
+
+bool msgr_handshake_t::init(bool server_mode)
+{
+    this->ctx = ctx;
+    std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)> kctx(EVP_PKEY_CTX_new(ctx->params, NULL), EVP_PKEY_CTX_free);
+    if (!kctx)
+        return on_error("EVP_PKEY_CTX_new with EC params: ");
+    if (EVP_PKEY_keygen_init(kctx.get()) <= 0)
+        return on_error("EVP_PKEY_keygen_init: ");
+    if (EVP_PKEY_keygen(kctx.get(), &ec_key) <= 0)
+        return on_error("EVP_PKEY_keygen: ");
+    if (!server_mode)
+    {
+        // Send initial message - only the EC public key
+        if (!make_client_init())
+            return false;
+    }
+    this->is_server = server_mode;
+    this->state = server_mode ? MSGR_HS_SERVER_INIT : MSGR_HS_CLIENT_INIT;
+    return true;
+}
+
+static void copy_to(std::vector<uint8_t> & buf, const void* src, uint32_t len)
+{
+    size_t old_size = buf.size();
+    buf.resize(buf.size() + len);
+    memcpy(buf.data() + old_size, src, len);
+}
+
+static void copy_to_with_len(std::vector<uint8_t> & buf, const void* src, uint32_t len)
+{
+    copy_to(buf, &len, sizeof(len));
+    copy_to(buf, src, len);
+}
+
+bool msgr_handshake_t::derive_shared_secret(EVP_PKEY *peer_ec_key)
+{
+    EVP_PKEY_CTX *dh_ctx = NULL;
+    if (!(dh_ctx = EVP_PKEY_CTX_new(ec_key, NULL)))
+        return on_error("EVP_PKEY_CTX_new for ECDH: ");
+    if (!EVP_PKEY_derive_init(dh_ctx))
+    {
+        EVP_PKEY_CTX_free(dh_ctx);
+        return on_error("EVP_PKEY_derive_init: ");
+    }
+    if (!EVP_PKEY_derive_set_peer(dh_ctx, peer_ec_key))
+    {
+        EVP_PKEY_CTX_free(dh_ctx);
+        return on_error("EVP_PKEY_derive_set_peer: ");
+    }
+    size_t len = 0;
+    if (!EVP_PKEY_derive(dh_ctx, NULL, &len))
+    {
+        EVP_PKEY_CTX_free(dh_ctx);
+        return on_error("EVP_PKEY_derive get length: ");
+    }
+    shared_secret.resize(len);
+    assert(len == 48);
+    if (!EVP_PKEY_derive(dh_ctx, shared_secret.data(), &len))
+    {
+        EVP_PKEY_CTX_free(dh_ctx);
+        return on_error("EVP_PKEY_derive: ");
+    }
+    assert(len == shared_secret.size());
+    shared_secret.resize(len);
+    EVP_PKEY_CTX_free(dh_ctx);
+    return true;
+}
+
+bool msgr_handshake_t::derive_hs_keys(const uint8_t *encoded_peer_key, size_t encoded_key_len)
+{
+    std::unique_ptr<EVP_PKEY, decltype(&EVP_PKEY_free)> peer_ec_key(EVP_PKEY_new(), EVP_PKEY_free);
+    if (!peer_ec_key)
+        return on_error("EVP_PKEY_new: ");
+    if (EVP_PKEY_copy_parameters(peer_ec_key.get(), ec_key) <= 0)
+        return on_error("EVP_PKEY_copy_parameters: ");
+    if (EVP_PKEY_set1_encoded_public_key(peer_ec_key.get(), encoded_peer_key, encoded_key_len) <= 0)
+        return on_error("Invalid handshake peer key: ");
+    if (!derive_shared_secret(peer_ec_key.get()))
+        return false;
+    hs_key.resize(AES_256_GCM_KEY_SIZE + AES_256_GCM_IV_SIZE);
+    peer_hs_key.resize(AES_256_GCM_KEY_SIZE + AES_256_GCM_IV_SIZE);
+    if (!ctx->derive_kdf(shared_secret.data(), shared_secret.size(),
+        NULL, 0, (state == MSGR_HS_SERVER_INIT ? "server hs key" : "client hs key"),
+        hs_key.data(), hs_key.size()))
+        return on_error("derive_kdf: ");
+    if (!ctx->derive_kdf(shared_secret.data(), shared_secret.size(),
+        NULL, 0, (state != MSGR_HS_SERVER_INIT ? "server hs key" : "client hs key"),
+        peer_hs_key.data(), peer_hs_key.size()))
+        return on_error("derive_kdf: ");
+    return true;
+}
+
+bool msgr_handshake_t::sign(std::vector<uint8_t> & out)
+{
+    std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)> md_ctx(EVP_MD_CTX_new(), EVP_MD_CTX_free);
+    if (!md_ctx)
+        return on_error("EVP_MD_CTX_create: ");
+    if (EVP_DigestSignInit(md_ctx.get(), NULL, ctx->md, NULL, ctx->my_privkey) <= 0)
+        return on_error("EVP_DigestSignInit: ");
+    if (EVP_DigestSignUpdate(md_ctx.get(), full_handshake.data(), full_handshake.size()) <= 0)
+        return on_error("EVP_DigestSignUpdate: ");
+    size_t siglen = 0;
+    if (EVP_DigestSignFinal(md_ctx.get(), NULL, &siglen) <= 0)
+        return on_error("EVP_DigestSignFinal get length: ");
+    size_t oldsize = out.size();
+    out.resize(oldsize + siglen);
+    if (EVP_DigestSignFinal(md_ctx.get(), out.data() + oldsize, &siglen) <= 0)
+        return on_error("EVP_DigestSignFinal: ");
+    out.resize(oldsize + siglen);
+    return true;
+}
+
+bool msgr_handshake_t::verify(const uint8_t *signature, size_t signature_len)
+{
+    std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)> md_ctx(EVP_MD_CTX_new(), EVP_MD_CTX_free);
+    if (!md_ctx)
+        return on_error("EVP_MD_CTX_create: ");
+    if (EVP_DigestVerifyInit(md_ctx.get(), NULL, ctx->md, NULL, X509_get0_pubkey(peer_cert)) <= 0)
+        return on_error("EVP_DigestVerifyInit: ");
+    if (EVP_DigestVerifyUpdate(md_ctx.get(), full_handshake.data(), full_handshake.size()) <= 0)
+        return on_error("EVP_DigestVerifyUpdate: ");
+    if (EVP_DigestVerifyFinal(md_ctx.get(), signature, signature_len) <= 0)
+        return false;
+    return true;
+}
+
+bool msgr_handshake_t::encrypt(const uint8_t* src, size_t len, uint8_t* dest)
+{
+    std::unique_ptr<EVP_CIPHER_CTX, decltype(&EVP_CIPHER_CTX_free)> enc_ctx(EVP_CIPHER_CTX_new(), EVP_CIPHER_CTX_free);
+    if (!ctx)
+        return on_error("EVP_CIPHER_CTX_new: ");
+    if (EVP_EncryptInit_ex(enc_ctx.get(), EVP_aes_256_gcm(), NULL, hs_key.data(), hs_key.data() + AES_256_GCM_KEY_SIZE) <= 0)
+        return on_error("EVP_EncryptInit AES-256-GCM: ");
+    int actual_out;
+    if (EVP_EncryptUpdate(enc_ctx.get(), dest, &actual_out, src, len) <= 0)
+        return on_error("EVP_EncryptUpdate: ");
+    assert(actual_out == len);
+    if (EVP_EncryptFinal_ex(enc_ctx.get(), NULL, &actual_out) <= 0)
+        return on_error("EVP_EncryptFinal: ");
+    if (EVP_CIPHER_CTX_ctrl(enc_ctx.get(), EVP_CTRL_GCM_GET_TAG, 16, dest+len) <= 0)
+        return on_error("EVP_CTRL_GCM_GET_TAG: ");
+    (*(uint64_t*)(hs_key.data() + AES_256_GCM_KEY_SIZE))++; // change IV
+    return true;
+}
+
+bool msgr_handshake_t::decrypt(const uint8_t *src, size_t & len, uint8_t* dest)
+{
+    if (len <= 16) // only tag?!
+    {
+        len = 0;
+        error = "Handshake decryption failed";
+        state = MSGR_HS_ERROR;
+        return false;
+    }
+    std::unique_ptr<EVP_CIPHER_CTX, decltype(&EVP_CIPHER_CTX_free)> dec_ctx(EVP_CIPHER_CTX_new(), EVP_CIPHER_CTX_free);
+    if (!ctx)
+        return on_error("EVP_CIPHER_CTX_new: ");
+    if (EVP_DecryptInit_ex(dec_ctx.get(), EVP_aes_256_gcm(), NULL, peer_hs_key.data(), peer_hs_key.data() + AES_256_GCM_KEY_SIZE) <= 0)
+        return on_error("EVP_DecryptInit AES-256-GCM: ");
+    int actual_out;
+    len -= 16;
+    if (EVP_DecryptUpdate(dec_ctx.get(), dest, &actual_out, src, len) <= 0)
+        return on_error("EVP_DecryptUpdate: ");
+    assert(actual_out == len);
+    if (EVP_CIPHER_CTX_ctrl(dec_ctx.get(), EVP_CTRL_GCM_SET_TAG, 16, (void*)(src+len)) <= 0)
+        return on_error("EVP_CTRL_GCM_SET_TAG: ");
+    if (EVP_DecryptFinal_ex(dec_ctx.get(), NULL, &actual_out) <= 0)
+    {
+        error = "Handshake decryption failed";
+        state = MSGR_HS_ERROR;
+        return false;
+    }
+    (*(uint64_t*)(peer_hs_key.data() + AES_256_GCM_KEY_SIZE))++; // change IV
+    return true;
+}
+
+bool msgr_handshake_t::make_client_init()
+{
+    uint8_t *key = NULL;
+    size_t key_len = EVP_PKEY_get1_encoded_public_key(ec_key, &key);
+    if (!key_len)
+        return on_error("EVP_PKEY_get1_encoded_public_key: ");
+    const size_t old_len = out_buf.size();
+    out_buf.resize(out_buf.size() + key_len + sizeof(msgr_handshake_hdr_t));
+    uint8_t *buf = out_buf.data() + old_len;
+    msgr_handshake_hdr_t *hdr = (msgr_handshake_hdr_t *)buf;
+    hdr->msg_len = key_len + sizeof(msgr_handshake_hdr_t);
+    hdr->magic = MSGR_HS_MAGIC;
+    hdr->type = MSGR_HS_CLIENT_INIT;
+    memcpy(buf + sizeof(msgr_handshake_hdr_t), key, key_len);
+    copy_to(full_handshake, &hdr->type, sizeof(hdr->type));
+    copy_to_with_len(full_handshake, key, key_len);
+    OPENSSL_free(key);
+    return true;
+}
+
+bool msgr_handshake_t::make_server_reply()
+{
+    uint8_t *key = NULL;
+    size_t key_len = EVP_PKEY_get1_encoded_public_key(ec_key, &key);
+    if (!key_len)
+        return on_error("EVP_PKEY_get1_encoded_public_key: ");
+    // Append type, key and raw certificate to signed data and sign it
+    msgr_handshake_hdr_t hdr = { .magic = MSGR_HS_MAGIC, .type = MSGR_HS_SERVER_REPLY };
+    copy_to(full_handshake, &hdr.type, sizeof(hdr.type));
+    copy_to_with_len(full_handshake, key, key_len);
+    copy_to_with_len(full_handshake, ctx->my_cert_pem.data(), ctx->my_cert_pem.size());
+    std::vector<uint8_t> signature;
+    if (!sign(signature))
+    {
+        OPENSSL_free(key);
+        return false;
+    }
+    // Encrypt certificate and signature
+    std::vector<uint8_t> encrypt_data;
+    copy_to_with_len(encrypt_data, ctx->my_cert_pem.data(), ctx->my_cert_pem.size());
+    copy_to_with_len(encrypt_data, signature.data(), signature.size());
+    encrypt_data.resize(encrypt_data.size()+16);
+    if (!encrypt(encrypt_data.data(), encrypt_data.size()-16, encrypt_data.data()))
+    {
+        OPENSSL_free(key);
+        return false;
+    }
+    // Construct message
+    hdr.msg_len = sizeof(msgr_handshake_hdr_t) + 4 + key_len + encrypt_data.size();
+    copy_to(out_buf, &hdr, sizeof(hdr));
+    copy_to_with_len(out_buf, key, key_len);
+    copy_to(out_buf, encrypt_data.data(), encrypt_data.size());
+    OPENSSL_free(key);
+    return true;
+}
+
+bool msgr_handshake_t::make_client_reply()
+{
+    // Append type and raw certificate to signed data and sign it
+    msgr_handshake_hdr_t hdr = { .magic = MSGR_HS_MAGIC, .type = MSGR_HS_CLIENT_REPLY };
+    copy_to(full_handshake, &hdr.type, sizeof(hdr.type));
+    copy_to_with_len(full_handshake, ctx->my_cert_pem.data(), ctx->my_cert_pem.size());
+    std::vector<uint8_t> signature;
+    if (!sign(signature))
+        return false;
+    // Encrypt certificate and signature
+    std::vector<uint8_t> encrypt_data;
+    copy_to_with_len(encrypt_data, ctx->my_cert_pem.data(), ctx->my_cert_pem.size());
+    copy_to_with_len(encrypt_data, signature.data(), signature.size());
+    encrypt_data.resize(encrypt_data.size()+16);
+    if (!encrypt(encrypt_data.data(), encrypt_data.size()-16, encrypt_data.data()))
+        return false;
+    // Construct message
+    hdr.msg_len = sizeof(msgr_handshake_hdr_t) + encrypt_data.size();
+    copy_to(out_buf, &hdr, sizeof(hdr));
+    copy_to(out_buf, encrypt_data.data(), encrypt_data.size());
+    return true;
+}
+
+bool msgr_handshake_t::verify_peer(const uint8_t *peer_cert_pem, size_t peer_cert_len)
+{
+    BIO *bio = BIO_new_mem_buf(peer_cert_pem, peer_cert_len);
+    if (!bio)
+        return on_error("BIO_new_mem_buf: ");
+    peer_cert = PEM_read_bio_X509(bio, NULL, 0, NULL);
+    BIO_free(bio);
+    if (!peer_cert)
+    {
+        error = "Invalid peer certificate";
+        state = MSGR_HS_ERROR;
+        return false;
+    }
+    std::unique_ptr<X509_STORE_CTX, decltype(&X509_STORE_CTX_free)> ca_ctx(X509_STORE_CTX_new(), X509_STORE_CTX_free);
+    if (!ca_ctx)
+        return on_error("X509_STORE_CTX_new: ");
+    if (X509_STORE_CTX_init(ca_ctx.get(), ctx->ca, peer_cert, NULL) <= 0)
+        return on_error("X509_STORE_CTX_init: ");
+    // Maybe use X509_VERIFY_PARAM_set_auth_level(X509_STORE_CTX_get0_param(ca_ctx.get()), 2) ?
+    X509_STORE_CTX_set_default(ca_ctx.get(), is_server ? "ssl_client" : "ssl_server");
+    if (X509_verify_cert(ca_ctx.get()) <= 0)
+    {
+        error = "Peer certificate verification failed: ";
+        error += X509_verify_cert_error_string(X509_STORE_CTX_get_error(ca_ctx.get()));
+        state = MSGR_HS_ERROR;
+        return false;
+    }
+    peer_is_osd = (X509_verify(peer_cert, X509_get0_pubkey(ctx->osd_ca)) > 0);
+    if (!is_server && !peer_is_osd)
+    {
+        error = "Peer is not an OSD";
+        state = MSGR_HS_ERROR;
+        return false;
+    }
+    return true;
+}
+
+ssize_t msgr_handshake_t::start_msg(uint8_t* src, size_t len, uint32_t expected_type)
+{
+    size_t orig_len = len;
+    size_t to_buffer = (len < sizeof(msgr_handshake_hdr_t)-in_buf.size()
+        ? len : sizeof(msgr_handshake_hdr_t)-in_buf.size());
+    in_buf.insert(in_buf.end(), src, src+to_buffer);
+    len -= to_buffer;
+    src += to_buffer;
+    if (in_buf.size() < sizeof(msgr_handshake_hdr_t))
+        return 0;
+    cur_hdr = (msgr_handshake_hdr_t *)in_buf.data();
+    if (cur_hdr->magic != MSGR_HS_MAGIC ||
+        cur_hdr->type != expected_type ||
+        cur_hdr->msg_len <= sizeof(msgr_handshake_hdr_t) ||
+        cur_hdr->msg_len >= MSGR_HS_MAX_LEN)
+    {
+        error = "Invalid handshake packet magic, type or size";
+        state = MSGR_HS_ERROR;
+        return -1;
+    }
+    to_buffer = (len < cur_hdr->msg_len-in_buf.size()
+        ? len : cur_hdr->msg_len-in_buf.size());
+    in_buf.insert(in_buf.end(), src, src+to_buffer);
+    cur_hdr = (msgr_handshake_hdr_t *)in_buf.data();
+    len -= to_buffer;
+    src += to_buffer;
+    if (in_buf.size() < cur_hdr->msg_len)
+        return 0;
+    cur_left = cur_hdr->msg_len - sizeof(msgr_handshake_hdr_t);
+    cur_buf = in_buf.data() + sizeof(msgr_handshake_hdr_t);
+    return orig_len - len;
+}
+
+bool msgr_handshake_t::read_with_len(const uint8_t* & dst, uint32_t & dst_len)
+{
+    if (cur_left < 4)
+    {
+        error = "Handshake packet too short";
+        state = MSGR_HS_ERROR;
+        return false;
+    }
+    dst_len = *(uint32_t*)cur_buf;
+    cur_buf += 4;
+    cur_left -= 4;
+    if (cur_left < dst_len)
+    {
+        error = "Handshake packet too short";
+        state = MSGR_HS_ERROR;
+        return false;
+    }
+    dst = cur_buf;
+    cur_buf += dst_len;
+    cur_left -= dst_len;
+    return true;
+}
+
+bool msgr_handshake_t::handle_client_init()
+{
+    // Derive shared secret and handshake keys
+    if (!derive_hs_keys(cur_buf, cur_left))
+        return false;
+    // Add type and key to full_handshake
+    copy_to(full_handshake, &cur_hdr->type, sizeof(cur_hdr->type));
+    copy_to_with_len(full_handshake, cur_buf, cur_left);
+    in_buf.clear();
+    return true;
+}
+
+// Decrypt and check peer certificate
+bool msgr_handshake_t::handle_peer_cert(const uint8_t *key, uint32_t key_len)
+{
+    if (!decrypt(cur_buf, cur_left, cur_buf))
+        return false;
+    const uint8_t *peer_cert_pem = NULL;
+    uint32_t peer_cert_len = 0;
+    if (!read_with_len(peer_cert_pem, peer_cert_len))
+        return false;
+    // Parse and verify certificate
+    if (!verify_peer(peer_cert_pem, peer_cert_len))
+        return false;
+    // Verify signature
+    copy_to(full_handshake, &cur_hdr->type, sizeof(cur_hdr->type));
+    if (key)
+        copy_to_with_len(full_handshake, key, key_len);
+    copy_to_with_len(full_handshake, peer_cert_pem, peer_cert_len);
+    const uint8_t *signature = NULL;
+    uint32_t signature_len = 0;
+    if (!read_with_len(signature, signature_len))
+        return false;
+    if (!verify(signature, signature_len))
+        return false;
+    return true;
+}
+
+bool msgr_handshake_t::handle_server_reply()
+{
+    // Derive shared secret and handshake keys
+    const uint8_t *key = NULL;
+    uint32_t key_len = 0;
+    if (!read_with_len(key, key_len))
+        return false;
+    if (!derive_hs_keys(key, key_len))
+        return false;
+    // Decrypt and check peer certificate
+    if (!handle_peer_cert(key, key_len))
+        return false;
+    in_buf.clear();
+    return true;
+}
+
+bool msgr_handshake_t::handle_client_reply()
+{
+    // Decrypt and check peer certificate
+    if (!handle_peer_cert(NULL, 0))
+        return false;
+    in_buf.clear();
+    return true;
+}
+
+void msgr_handshake_t::complete()
+{
+    state = MSGR_HS_DONE;
+    hs_key.clear();
+    peer_hs_key.clear();
+    full_handshake.clear();
+}
+
+ssize_t msgr_handshake_t::handle(uint8_t* in_buf, size_t in_size)
+{
+    if (state == MSGR_HS_SERVER_INIT)
+    {
+        ssize_t r = start_msg(in_buf, in_size, MSGR_HS_CLIENT_INIT);
+        if (r < 0)
+            return r;
+        if (r == 0)
+            return in_size;
+        if (!handle_client_init())
+            return -1;
+        // Send encrypted & signed response
+        if (!make_server_reply())
+            return -1;
+        state = MSGR_HS_SERVER_REPLY;
+        return r;
+    }
+    else if (state == MSGR_HS_CLIENT_INIT)
+    {
+        ssize_t r = start_msg(in_buf, in_size, MSGR_HS_SERVER_REPLY);
+        if (r < 0)
+            return r;
+        if (r == 0)
+            return in_size;
+        if (!handle_server_reply())
+            return -1;
+        // Verification passed, send certificate to the server
+        if (!make_client_reply())
+            return -1;
+        // Finished!
+        complete();
+        return r;
+    }
+    else if (state == MSGR_HS_SERVER_REPLY)
+    {
+        ssize_t r = start_msg(in_buf, in_size, MSGR_HS_CLIENT_REPLY);
+        if (r < 0)
+            return r;
+        if (r == 0)
+            return in_size;
+        if (!handle_client_reply())
+            return -1;
+        // Verification passed
+        // Finished!
+        complete();
+        return r;
+    }
+    else if (state == MSGR_HS_DONE)
+    {
+        return 0;
+    }
+    else if (state != MSGR_HS_ERROR)
+    {
+        error = "Unexpected handshake state: "+std::to_string(state);
+    }
+    return -1;
+}
+
+bool msgr_handshake_t::done()
+{
+    return (state == MSGR_HS_DONE);
+}
+
+std::vector<uint8_t>& msgr_handshake_t::get_out()
+{
+    return out_buf;
+}
+
+msgr_handshake_result_t msgr_handshake_t::get_result()
+{
+    if (state != MSGR_HS_DONE)
+        return msgr_handshake_result_t{};
+    X509_up_ref(peer_cert);
+    return msgr_handshake_result_t{
+        .peer_cert = peer_cert,
+        .peer_is_osd = peer_is_osd,
+        .shared_secret = shared_secret,
+    };
+}
+
+std::string msgr_handshake_t::get_error()
+{
+    return error;
+}
@@ -0,0 +1,54 @@
+// Copyright (c) Vitaliy Filippov, 2026+
+// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
+
+#pragma once
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+#include <openssl/types.h>
+
+#define AES_256_GCM_KEY_SIZE 32
+#define AES_256_GCM_IV_SIZE 12
+#define AES_256_GCM_MAX_IV_CTR ((uint64_t)1 << 32)
+
+// TLS 1.3-like handshake
+
+// 1. Client->server: EC public key
+// 2. Server->client: EC public key, encrypted certificate and digital signature of the handshake
+// 3. Client->server: encrypted certificate and digital signature of the handshake
+
+struct msgr_handshake_result_t
+{
+    X509 *peer_cert = NULL;
+    bool peer_is_osd = false;
+    std::vector<uint8_t> shared_secret;
+};
+
+class msgr_handshake_i
+{
+public:
+    // Workflow: create -> init -> handle_msg -> get_result/get_error -> destruct
+    virtual ~msgr_handshake_i() = default;
+    virtual bool init(bool server_mode) = 0;
+    virtual ssize_t handle(uint8_t* in_buf, size_t in_size) = 0;
+    virtual bool done() = 0;
+    virtual std::vector<uint8_t> & get_out() = 0;
+    virtual msgr_handshake_result_t get_result() = 0;
+    virtual std::string get_error() = 0;
+};
+
+class msgr_handshake_ctx_i
+{
+public:
+    static msgr_handshake_ctx_i* create_ctx();
+    virtual ~msgr_handshake_ctx_i() = default;
+    virtual msgr_handshake_i* create() = 0;
+    virtual bool init(const std::string & pem_cert, const std::string & pem_key,
+        const std::string & pem_osd_ca, const std::string & pem_client_ca) = 0;
+    virtual std::string get_error() = 0;
+    virtual bool derive_kdf(const uint8_t* insecret, size_t insecret_len,
+        const uint8_t* salt, size_t salt_len, const char *label, uint8_t *outsecret, size_t outsize) = 0;
+};
@@ -23,6 +23,10 @@ osd_op_t::~osd_op_t()
        // So we don't reuse it, but free it every time
        free(buf);
    }
+    if (enc_buf)
+    {
+        free(enc_buf);
+    }
 }

 bool osd_op_t::is_recovery_related()
@@ -3,6 +3,8 @@

 #pragma once

+#include <memory>
+
 #include <sys/uio.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -16,6 +18,8 @@

 #define OSD_OP_INLINE_BUF_COUNT 16

+#define AES_256_XTS_KEY_SIZE 64
+
 // Kind of a vector with small-list-optimisation
 struct osd_op_buf_list_t
 {
@@ -152,6 +156,19 @@ struct blockstore_op_t;

 struct osd_primary_op_data_t;

+struct osd_op_enc_t
+{
+    // Keys may contain more information in the future, like encryption algorithm and key ID
+    // In this case, key_chain will become inode_key_t* with inode_key_t also being a structure
+    // Currently all keys are required to be 512 bit (64 byte) long, for AES-256-XTS
+    // Raw pointers are convenient for messenger code; external users may use shared_ptr aliasing
+    // to implement complex freeing of osd_op_enc_t along with their external inode cache info
+    uint8_t** key_chain = NULL;
+    size_t chain_size = 0;
+    uint32_t read_chain_bitmap_pos = 0;
+    uint32_t bitmap_granularity = 0;
+};
+
 struct __attribute__((visibility("default"))) osd_op_t
 {
    timespec tv_begin = { 0 }, tv_end = { 0 };
@@ -164,9 +181,12 @@ struct __attribute__((visibility("default"))) osd_op_t
    // bitmap, bitmap_len, bmp_data are only meaningful for reads
    void *bitmap = NULL;
    unsigned bitmap_len = 0;
-    unsigned bmp_data = 0;
-    void *bitmap_buf = NULL;
+    size_t bmp_data = 0;
+    uint8_t *bitmap_buf = NULL;
    void *rmw_buf = NULL;
+    std::shared_ptr<osd_op_enc_t> enc;
+    uint8_t *enc_buf = NULL;
+    uint64_t csum = 0; // network layer checksum
    osd_primary_op_data_t* op_data = NULL;
    std::function<void(osd_op_t*)> callback;

@@ -176,4 +196,5 @@ struct __attribute__((visibility("default"))) osd_op_t
    void cancel();

    bool is_recovery_related();
+    uint64_t calc_data_checksum();
 };
@@ -541,7 +541,7 @@ bool osd_messenger_t::connect_rdma(uint64_t client_id, std::string rdma_address,
            {
                // Remember connection, but switch to RDMA only after sending the configuration response
                cl->rdma_conn = rdma_conn;
-                cl->peer_state = PEER_RDMA_CONNECTING;
+                cl->peer_state = PEER_RDMA_CONNECTING_IN;
                return true;
            }
        }
@@ -568,28 +568,6 @@ static void try_send_rdma_wr(osd_client_t *cl, ibv_sge *sge, int op_sge)
    cl->rdma_conn->cur_send++;
 }

-static int try_send_rdma_copy(osd_client_t *cl, uint8_t *dst, int dst_len)
-{
-    auto rc = cl->rdma_conn;
-    int total_dst_len = dst_len;
-    while (dst_len > 0 && rc->send_pos < cl->send_list.size())
-    {
-        iovec & iov = cl->send_list[rc->send_pos];
-        uint32_t len = (uint32_t)(iov.iov_len-rc->send_buf_pos < dst_len
-            ? iov.iov_len-rc->send_buf_pos : dst_len);
-        memcpy(dst, (uint8_t*)iov.iov_base+rc->send_buf_pos, len);
-        dst += len;
-        dst_len -= len;
-        rc->send_buf_pos += len;
-        if (rc->send_buf_pos >= iov.iov_len)
-        {
-            rc->send_pos++;
-            rc->send_buf_pos = 0;
-        }
-    }
-    return total_dst_len-dst_len;
-}
-
 void osd_messenger_t::try_send_rdma(osd_client_t *cl)
 {
    auto rc = cl->rdma_conn;
@@ -615,7 +593,12 @@ void osd_messenger_t::try_send_rdma(osd_client_t *cl)
        dst_len = (rc->send_out_pos < rc->send_out_size ? rc->send_out_size-rc->send_out_pos : rc->send_done_pos-rc->send_out_pos);
        if (dst_len > rc->max_msg)
            dst_len = rc->max_msg;
-        copied = try_send_rdma_copy(cl, dst, dst_len);
+        copied = copy_ops_to(cl, dst, dst_len);
+        if (cl->io_error)
+        {
+            stop_client(cl->client_id);
+            return;
+        }
        if (copied > 0)
        {
            rc->send_out_pos += copied;
@@ -631,6 +614,7 @@ void osd_messenger_t::try_send_rdma(osd_client_t *cl)
            };
            try_send_rdma_wr(cl, &sge, 1);
            rc->send_sizes.push_back(copied);
+            cl->send_free_ops.push_back(NULL); // end marker
        }
    }
 }
@@ -659,6 +643,7 @@ static void try_recv_rdma_wr(osd_client_t *cl, void *buf)

 bool osd_messenger_t::init_recv_rdma(osd_client_t *cl)
 {
+    return true;
    auto rc = cl->rdma_conn;
    assert(!rc->recv_buf.buf);
    rc->recv_buf.buf = (uint8_t*)malloc_or_die(rc->max_msg * rc->max_recv);
@@ -714,9 +699,14 @@ void osd_messenger_t::handle_rdma_events(msgr_rdma_context_t *rdma_context)
                continue;
            }
            auto rc = cl->rdma_conn;
+            if (!rc)
+            {
+                // Connection destroyed (fallback to TCP)
+                continue;
+            }
            if (wc[i].status != IBV_WC_SUCCESS)
            {
-                fprintf(stderr, "RDMA work request failed for client %ju", client_id);
+                fprintf(stderr, "RDMA work request (%s) failed for client %ju", is_send ? "send" : "recv", client_id);
                if (cl->osd_num)
                {
                    fprintf(stderr, " (OSD %ju)", cl->osd_num);
@@ -727,9 +717,28 @@ void osd_messenger_t::handle_rdma_events(msgr_rdma_context_t *rdma_context)
            }
            if (!is_send)
            {
-                // Reset OSD ping state - client is obviously alive
-                cl->ping_time_remaining = 0;
-                cl->idle_time_remaining = osd_idle_timeout;
+                if (cl->peer_state == PEER_RDMA_CONNECTING_OUT)
+                {
+                    // First message received over RDMA - TCP socket can be closed now
+                    if (log_level > 0)
+                    {
+                        fprintf(stderr, "Successfully connected with client %ju using RDMA\n", cl->client_id);
+                    }
+                    cl->peer_state = PEER_RDMA;
+                    if (cl->peer_fd >= 0 && cl->rdma_close_tcp)
+                    {
+                        // TCP socket is not needed anymore
+                        tfd->set_fd_handler(cl->peer_fd, false, NULL);
+                        clients_by_fd.erase(cl->peer_fd);
+                        close(cl->peer_fd);
+                        cl->peer_fd = -1;
+                    }
+                    if (cl->osd_num)
+                    {
+                        osd_peers[cl->osd_num] = cl;
+                        on_connect_peer(cl->osd_num, 0, cl->client_id);
+                    }
+                }
                rc->cur_recv--;
                if (!handle_read_buffer(cl, rc->recv_buffers[rc->next_recv_buf], wc[i].byte_len))
                {
@@ -741,54 +750,27 @@ void osd_messenger_t::handle_rdma_events(msgr_rdma_context_t *rdma_context)
            else
            {
                rc->cur_send--;
-                uint64_t sent_size = rc->send_sizes.at(0);
-                rc->send_sizes.erase(rc->send_sizes.begin(), rc->send_sizes.begin()+1);
+                // byte_len is not filled for send operations
+                uint64_t sent_size = rc->send_sizes.front();
+                rc->send_sizes.pop_front();
                rc->send_done_pos += sent_size;
                rc->send_out_full = false;
                if (rc->send_done_pos == rc->send_out_size)
                    rc->send_done_pos = 0;
                assert(rc->send_done_pos < rc->send_out_size);
-                int send_pos = 0, send_buf_pos = 0;
-                while (sent_size > 0)
+                while (cl->send_free_ops.front())
                {
-                    if (sent_size >= cl->send_list.at(send_pos).iov_len)
-                    {
-                        sent_size -= cl->send_list[send_pos].iov_len;
-                        send_pos++;
-                    }
-                    else
-                    {
-                        send_buf_pos = sent_size;
-                        sent_size = 0;
-                    }
+                    delete cl->send_free_ops.front();
+                    cl->send_free_ops.pop_front();
                }
-                assert(rc->send_pos >= send_pos);
-                if (rc->send_pos == send_pos)
+                cl->send_free_ops.pop_front();
+                if ((cl->proto_csum_status & MSGR_CSUM_NEG) && !cl->write_op && !cl->write_ops.size())
                {
-                    rc->send_buf_pos -= send_buf_pos;
-                }
-                rc->send_pos -= send_pos;
-                for (int i = 0; i < send_pos; i++)
-                {
-                    if (cl->outbox[i].flags & MSGR_SENDP_FREE)
-                    {
-                        // Reply fully sent
-                        delete cl->outbox[i].op;
-                    }
-                }
-                if (send_pos > 0)
-                {
-                    cl->send_list.erase(cl->send_list.begin(), cl->send_list.begin()+send_pos);
-                    cl->outbox.erase(cl->outbox.begin(), cl->outbox.begin()+send_pos);
-                }
-                if (send_buf_pos > 0)
-                {
-                    cl->send_list[0].iov_base = (uint8_t*)cl->send_list[0].iov_base + send_buf_pos;
-                    cl->send_list[0].iov_len -= send_buf_pos;
+                    // Checksums negotiated, enable
+                    cl->proto_csum_status = cl->proto_csum_status & (~MSGR_CSUM_NEG);
                }
                try_send_rdma(cl);
            }
        }
    } while (event_count > 0);
-    handle_immediate_ops();
 }
@@ -8,8 +8,11 @@
 #include <infiniband/verbs.h>
 #include <string>
 #include <vector>
+#include <deque>
 #include "addr_util.h"

+struct osd_op_t;
+
 struct msgr_rdma_address_t
 {
    ibv_gid gid;
@@ -72,11 +75,11 @@ struct msgr_rdma_connection_t
    int cur_send = 0, cur_recv = 0;
    int send_pos = 0, send_buf_pos = 0;
    int next_recv_buf = 0;
-    std::vector<void*> recv_buffers;
+    std::vector<uint8_t*> recv_buffers;
    msgr_rdma_buf_t recv_buf;
-    std::vector<uint64_t> send_sizes;
+    std::deque<uint64_t> send_sizes;
    msgr_rdma_buf_t send_out;
-    int send_out_pos = 0, send_done_pos = 0, send_out_size = 0;
+    size_t send_out_pos = 0, send_done_pos = 0, send_out_size = 0;
    bool send_out_full = false;

    ~msgr_rdma_connection_t();
@@ -19,6 +19,7 @@ struct rdmacm_connecting_t
    int tcp_port = 0;
    int timeout_ms = 0;
    int timeout_id = -1;
+    bool is_incoming = false;
    msgr_rdma_context_t *rdma_context = NULL;
 };

@@ -292,6 +293,7 @@ void osd_messenger_t::rdmacm_accept(rdma_cm_event *ev)
    conn->client_id = next_client_id++;
    conn->parsed_addr = *(sockaddr_storage*)rdma_get_peer_addr(ev->id);
    conn->rdma_context = rdma_context;
+    conn->is_incoming = true;
    rdmacm_set_conn_timeout(conn);
    rdmacm_connecting[ev->id] = conn;
    fprintf(stderr, "[OSD %ju] new client %ju: connection from %s via RDMA-CM\n", this->osd_num, conn->client_id,
@@ -492,11 +494,13 @@ void osd_messenger_t::rdmacm_established(rdma_cm_event *ev)
    cl->peer_addr = conn->parsed_addr;
    cl->peer_port = conn->rdmacm_port;
    cl->client_id = conn->client_id;
+    cl->is_incoming = conn->is_incoming;
    cl->peer_state = PEER_RDMA;
    cl->connect_timeout_id = -1;
    cl->osd_num = peer_osd;
-    cl->in_buf = malloc_or_die(receive_buffer_size);
+    cl->in_buf = (uint8_t*)malloc_or_die(receive_buffer_size);
    cl->rdma_conn = rc;
+    init_tls_client(cl);
    clients[conn->client_id] = cl;
    if (conn->timeout_id >= 0)
    {
@@ -7,6 +7,451 @@

 #include "messenger.h"

+#include <openssl/evp.h>
+#include <openssl/err.h>
+
+#define WR_GCM     1
+#define WR_XTS     2
+#define WR_NO_CSUM 4
+
+class msgr_op_writer_t
+{
+public:
+    virtual bool write(uint8_t *src, size_t src_len, int flags = 0) = 0;
+    virtual bool finish() = 0;
+};
+
+class copy_op_writer_t: public msgr_op_writer_t
+{
+protected:
+    osd_messenger_t* msgr;
+    osd_client_t* cl;
+    size_t from;
+
+    uint8_t *curbuf;
+    size_t bufsize;
+    size_t done;
+
+public:
+    copy_op_writer_t(osd_messenger_t* msgr, osd_client_t* cl, uint8_t *curbuf, size_t bufsize):
+        msgr(msgr), cl(cl), from(cl->write_op_pos), curbuf(curbuf), bufsize(bufsize), done(0)
+    {}
+
+    void reset()
+    {
+        from = cl->write_op_pos;
+    }
+
+    bool write(uint8_t *src, size_t src_len, int flags = 0) override
+    {
+        if (from >= src_len)
+        {
+            from -= src_len;
+            return true;
+        }
+        if (flags & WR_XTS)
+        {
+            msgr->op_encrypted_copy_buf(cl, curbuf, bufsize, src, src_len, from, done);
+        }
+        else
+        {
+            size_t n = src_len-from;
+            if (n > bufsize-done)
+                n = bufsize-done;
+            if (cl->write_csum_state && !(flags & WR_NO_CSUM))
+                XXH3_64bits_update(cl->write_csum_state, src+from, n);
+            memcpy(curbuf+done, src+from, n);
+            done += n;
+            cl->write_op_pos += n;
+            from += n;
+        }
+        if (from < src_len)
+            return false;
+        from = 0;
+        return true;
+    }
+
+    bool finish() override
+    {
+        return true;
+    }
+
+    size_t get_done()
+    {
+        return done;
+    }
+};
+
+class gcm_op_writer_t: public msgr_op_writer_t
+{
+    osd_messenger_t* msgr;
+    osd_client_t* cl;
+    size_t from;
+
+    uint8_t *curbuf;
+    size_t bufsize;
+    size_t done;
+
+public:
+    gcm_op_writer_t(osd_messenger_t* msgr, osd_client_t* cl, uint8_t *curbuf, size_t bufsize):
+        msgr(msgr), cl(cl), from(cl->write_op_pos), curbuf(curbuf), bufsize(bufsize), done(0)
+    {
+    }
+
+    void reset()
+    {
+        from = cl->write_op_pos;
+        init_ctx(msgr, cl);
+    }
+
+    static void init_ctx(osd_messenger_t* msgr, osd_client_t *cl)
+    {
+        if (!cl->enc_ctx)
+        {
+            if (msgr->encrypt_gcm_pool.size())
+            {
+                cl->enc_ctx = msgr->encrypt_gcm_pool.back();
+                msgr->encrypt_gcm_pool.pop_back();
+            }
+            else
+            {
+#ifdef WITH_ISAL_CRYPTO
+                cl->enc_ctx = (isal_gcm_context_data*)malloc_or_die(sizeof(isal_gcm_context_data));
+#else
+                cl->enc_ctx = EVP_CIPHER_CTX_new();
+                assert(cl->enc_ctx);
+                int r = EVP_EncryptInit_ex(cl->enc_ctx, EVP_aes_256_gcm(), NULL, NULL, NULL);
+                if (r != 1)
+                {
+                    fprintf(stderr, "EncryptInit error: ");
+                    ERR_print_errors_fp(stderr);
+                    abort();
+                }
+#endif
+            }
+        }
+        if (cl->my_iv_ctr >= AES_256_GCM_MAX_IV_CTR)
+        {
+            // Rotate key every 2^32 messages
+            bool ok = msgr->derive_aes_keys(cl, true, false);
+            assert(ok);
+        }
+#ifdef WITH_ISAL_CRYPTO
+        int r = isal_aes_gcm_init_256(&cl->my_key_isal, cl->enc_ctx, cl->my_key.data() + AES_256_GCM_KEY_SIZE, NULL, 0);
+        if (r != 0)
+        {
+            fprintf(stderr, "isal_aes_gcm_init_256 error %d\n", r);
+            abort();
+        }
+#else
+        int r = EVP_EncryptInit_ex(cl->enc_ctx, NULL, NULL, (uint8_t*)cl->my_key.data(), cl->my_key.data() + AES_256_GCM_KEY_SIZE);
+        if (r != 1)
+        {
+            fprintf(stderr, "EncryptInit error: ");
+            ERR_print_errors_fp(stderr);
+            abort();
+        }
+#endif
+        // Increase IV
+        cl->my_iv_ctr++;
+        (*(uint64_t*)(cl->my_key.data() + AES_256_GCM_KEY_SIZE))++;
+    }
+
+    static void free_ctx(osd_messenger_t* msgr, osd_client_t *cl)
+    {
+        if (msgr->encrypt_gcm_pool.size() < msgr->max_cipher_pool_size)
+            msgr->encrypt_gcm_pool.push_back(cl->enc_ctx);
+        else
+        {
+#ifdef WITH_ISAL_CRYPTO
+            free(cl->enc_ctx);
+#else
+            EVP_CIPHER_CTX_free(cl->enc_ctx);
+#endif
+        }
+        cl->enc_ctx = NULL;
+    }
+
+    bool write(uint8_t *src, size_t src_len, int flags) override
+    {
+        if (from >= src_len)
+        {
+            from -= src_len;
+            return true;
+        }
+        if (!(flags & WR_GCM))
+        {
+            if (flags & WR_XTS)
+            {
+                msgr->op_encrypted_copy_buf(cl, curbuf, bufsize, src, src_len, from, done);
+            }
+            else
+            {
+                size_t n = src_len-from;
+                if (n > bufsize-done)
+                    n = bufsize-done;
+                if (!n)
+                    return false;
+                if (cl->write_csum_state && !(flags & WR_NO_CSUM))
+                    XXH3_64bits_update(cl->write_csum_state, src+from, n);
+                memcpy(curbuf+done, src+from, n);
+                done += n;
+                cl->write_op_pos += n;
+                from += n;
+            }
+        }
+        else
+        {
+            size_t n = src_len-from;
+            if (n > bufsize-done)
+                n = bufsize-done;
+            if (!n)
+                return false;
+#ifdef WITH_ISAL_CRYPTO
+            int r = isal_aes_gcm_enc_256_update(&cl->my_key_isal, cl->enc_ctx, curbuf+done, src+from, n);
+            assert(!r);
+#else
+            int actual_out;
+            if (EVP_EncryptUpdate(cl->enc_ctx, curbuf+done, &actual_out, src+from, n) != 1)
+            {
+                fprintf(stderr, "EncryptUpdate error: ");
+                ERR_print_errors_fp(stderr);
+                abort();
+            }
+            assert(actual_out == n);
+#endif
+            if (cl->write_csum_state && !(flags & WR_NO_CSUM))
+                XXH3_64bits_update(cl->write_csum_state, src+from, n);
+            done += n;
+            cl->write_op_pos += n;
+            from += n;
+        }
+        if (from < src_len)
+            return false;
+        from = 0;
+        return true;
+    }
+
+    static void write_tag_to(osd_messenger_t *msgr, osd_client_t *cl, uint8_t *dst)
+    {
+#ifdef WITH_ISAL_CRYPTO
+        int r = isal_aes_gcm_enc_256_finalize(&cl->my_key_isal, cl->enc_ctx, dst, 16);
+        assert(!r);
+#else
+        int actual_out = 0;
+        int r = EVP_EncryptFinal_ex(cl->enc_ctx, NULL, &actual_out);
+        if (r != 1)
+        {
+            fprintf(stderr, "EncryptFinal error: ");
+            ERR_print_errors_fp(stderr);
+            abort();
+        }
+        assert(actual_out == 0);
+        r = EVP_CIPHER_CTX_ctrl(cl->enc_ctx, EVP_CTRL_GCM_GET_TAG, 16, dst);
+        assert(r == 1);
+#endif
+    }
+
+    bool finish() override
+    {
+        // Tag is 16 bytes
+        if (done >= bufsize)
+            return false;
+        if (bufsize-done < 16 || cl->enc_tag_size)
+        {
+            // No space for the full tag, but msgr_rdma expects us to always fill the whole buffer
+            if (!cl->enc_tag_size)
+            {
+                write_tag_to(msgr, cl, cl->enc_tag);
+                cl->enc_tag_size = 16;
+            }
+            size_t n = bufsize-done;
+            if (n > cl->enc_tag_size)
+                n = cl->enc_tag_size;
+            memcpy(curbuf+done, cl->enc_tag+16-cl->enc_tag_size, n);
+            done += n;
+            cl->enc_tag_size -= n;
+            if (cl->enc_tag_size > 0)
+                return false;
+        }
+        else
+        {
+            // The whole tag fits at once
+            write_tag_to(msgr, cl, curbuf+done);
+            done += 16;
+        }
+        free_ctx(msgr, cl);
+        return true;
+    }
+
+    size_t get_done()
+    {
+        return done;
+    }
+};
+
+class get_op_writer_t: public msgr_op_writer_t
+{
+    osd_messenger_t* msgr;
+    osd_client_t* cl;
+    size_t from;
+    size_t done;
+    size_t enc_size;
+    size_t done_enc;
+
+public:
+    get_op_writer_t(osd_messenger_t* msgr, osd_client_t* cl, uint8_t*, size_t):
+        msgr(msgr), cl(cl), from(cl->write_op_pos), done(0), enc_size(0), done_enc(0)
+    {
+    }
+
+    static void ssl_extend_buf(osd_client_t *cl, size_t more = 0)
+    {
+        size_t min_cap = cl->ssl_out_buf_size*2;
+        if (min_cap < cl->ssl_out_buf_size+more)
+            min_cap = cl->ssl_out_buf_size+more;
+        if (min_cap < 16384)
+            min_cap = 16384;
+        if (cl->ssl_out_buf_cap < min_cap)
+        {
+            uintptr_t old_buf = (uintptr_t)cl->ssl_out_buf;
+            uintptr_t old_end = old_buf + cl->ssl_out_buf_cap;
+            cl->ssl_out_buf = (uint8_t*)realloc_or_die(cl->ssl_out_buf, min_cap);
+            cl->ssl_out_buf_cap = min_cap;
+            for (auto & iov: cl->send_list)
+            {
+                if ((uintptr_t)iov.iov_base >= old_buf && (uintptr_t)iov.iov_base < old_end)
+                    iov.iov_base = cl->ssl_out_buf + ((uintptr_t)iov.iov_base - old_buf);
+            }
+        }
+    }
+
+    static void send_out_buf(osd_client_t *cl, size_t n)
+    {
+        if (cl->send_list.size() > 0)
+        {
+            iovec& last = cl->send_list.back();
+            if (last.iov_base+last.iov_len == cl->ssl_out_buf+cl->ssl_out_buf_size)
+            {
+                last.iov_len += n;
+                cl->ssl_out_buf_size += n;
+                return;
+            }
+        }
+        cl->send_list.push_back((iovec){ .iov_base = cl->ssl_out_buf+cl->ssl_out_buf_size, .iov_len = n });
+        cl->ssl_out_buf_size += n;
+    }
+
+    void reset()
+    {
+        from = cl->write_op_pos;
+        enc_size = 0;
+        done_enc = 0;
+        if (cl->gcm_enabled)
+        {
+            gcm_op_writer_t::init_ctx(msgr, cl);
+        }
+    }
+
+    bool write(uint8_t *src, size_t src_len, int flags) override
+    {
+        if (from >= src_len)
+        {
+            // Skip
+            from -= src_len;
+            return true;
+        }
+        if (cl->send_list.size() >= IOV_MAX)
+        {
+            return false;
+        }
+        if (flags & WR_GCM)
+        {
+            if (cl->gcm_enabled)
+            {
+                // Encrypt data to client's temporary output buffer (all at once)
+                size_t n = src_len-from;
+                ssl_extend_buf(cl, n);
+#ifdef WITH_ISAL_CRYPTO
+                int r = isal_aes_gcm_enc_256_update(&cl->my_key_isal, cl->enc_ctx, cl->ssl_out_buf+cl->ssl_out_buf_size, src+from, n);
+                assert(!r);
+#else
+                int actual_out;
+                if (EVP_EncryptUpdate(cl->enc_ctx, cl->ssl_out_buf+cl->ssl_out_buf_size, &actual_out, src+from, n) != 1)
+                {
+                    fprintf(stderr, "EncryptUpdate error: ");
+                    ERR_print_errors_fp(stderr);
+                    abort();
+                }
+                assert(actual_out == n);
+#endif
+                if (cl->write_csum_state && !(flags & WR_NO_CSUM))
+                    XXH3_64bits_update(cl->write_csum_state, src+from, n);
+                send_out_buf(cl, n);
+                done += n;
+                cl->write_op_pos += n;
+                from += n;
+                if (from < src_len)
+                    return false;
+                from = 0;
+                return true;
+            }
+        }
+        if (flags & WR_XTS)
+        {
+            if (!cl->write_op->enc_buf)
+            {
+                if (cl->send_list.size() >= IOV_MAX-1)
+                {
+                    // Make sure that 1 encrypted buffer and 1 checksum fits
+                    return false;
+                }
+                // No way except than to allocate a temporary buffer and encrypt data to it
+                assert(cl->write_op->req.hdr.opcode == OSD_OP_WRITE);
+                enc_size = cl->write_op->req.rw.len - from + (from % 16);
+                assert(enc_size > 0);
+                cl->write_op->enc_buf = (uint8_t*)malloc_or_die(enc_size);
+                cl->send_list.push_back((iovec){ .iov_base = cl->write_op->enc_buf, .iov_len = enc_size });
+                done += enc_size;
+            }
+            assert(enc_size > 0);
+            msgr->op_encrypted_copy_buf(cl, cl->write_op->enc_buf, enc_size, src, src_len, from, done_enc);
+            assert(from == src_len);
+        }
+        else
+        {
+            if (cl->write_csum_state && !(flags & WR_NO_CSUM))
+                XXH3_64bits_update(cl->write_csum_state, src+from, src_len-from);
+            cl->send_list.push_back((iovec){ src+from, src_len-from });
+            done += src_len-from;
+            cl->write_op_pos += src_len-from;
+        }
+        from = 0;
+        return true;
+    }
+
+    bool finish() override
+    {
+        if (cl->enc_ctx)
+        {
+            if (cl->send_list.size() >= IOV_MAX)
+                return false;
+            // Tag is 16 bytes
+            ssl_extend_buf(cl, 16);
+            gcm_op_writer_t::write_tag_to(msgr, cl, cl->ssl_out_buf+cl->ssl_out_buf_size);
+            send_out_buf(cl, 16);
+            done += 16;
+            gcm_op_writer_t::free_ctx(msgr, cl);
+        }
+        return true;
+    }
+
+    size_t get_done()
+    {
+        return done;
+    }
+};
+
 void osd_messenger_t::outbox_push(osd_op_t *cur_op)
 {
    assert(cur_op->client_id);
@@ -21,6 +466,7 @@ void osd_messenger_t::outbox_push(osd_op_t *cur_op)
    {
        clock_gettime(CLOCK_REALTIME, &cur_op->tv_begin);
        cur_op->req.hdr.id = ++cl->send_op_id;
+        cl->sent_ops[cur_op->req.hdr.id] = cur_op;
    }
    else
    {
@@ -37,79 +483,11 @@ void osd_messenger_t::outbox_push(osd_op_t *cur_op)
        }
        // Can't be not found because client IDs are unique
        assert(found);
-    }
-    auto & to_send_list = cl->write_msg.msg_iovlen ? cl->next_send_list : cl->send_list;
-    auto & to_outbox = cl->write_msg.msg_iovlen ? cl->next_outbox : cl->outbox;
-    if (cur_op->op_type == OSD_OP_IN)
-    {
        measure_exec(cur_op);
-        to_send_list.push_back((iovec){ .iov_base = cur_op->reply.buf, .iov_len = OSD_PACKET_SIZE });
-    }
-    else
-    {
-        to_send_list.push_back((iovec){ .iov_base = cur_op->req.buf, .iov_len = OSD_PACKET_SIZE });
-        cl->sent_ops[cur_op->req.hdr.id] = cur_op;
-    }
-    to_outbox.push_back((msgr_sendp_t){ .op = cur_op, .flags = MSGR_SENDP_HDR });
-    // Bitmap
-    if (cur_op->op_type == OSD_OP_IN &&
-        cur_op->req.hdr.opcode == OSD_OP_SEC_READ &&
-        cur_op->reply.sec_rw.attr_len > 0)
-    {
-        to_send_list.push_back((iovec){
-            .iov_base = cur_op->bitmap,
-            .iov_len = cur_op->reply.sec_rw.attr_len,
-        });
-        to_outbox.push_back((msgr_sendp_t){ .op = cur_op, .flags = 0 });
-    }
-    else if (cur_op->op_type == OSD_OP_OUT &&
-        (cur_op->req.hdr.opcode == OSD_OP_SEC_WRITE || cur_op->req.hdr.opcode == OSD_OP_SEC_WRITE_STABLE) &&
-        cur_op->req.sec_rw.attr_len > 0)
-    {
-        to_send_list.push_back((iovec){
-            .iov_base = cur_op->bitmap,
-            .iov_len = cur_op->req.sec_rw.attr_len,
-        });
-        to_outbox.push_back((msgr_sendp_t){ .op = cur_op, .flags = 0 });
-    }
-    // Operation data
-    if ((cur_op->op_type == OSD_OP_IN
-        ? (cur_op->req.hdr.opcode == OSD_OP_READ ||
-        cur_op->req.hdr.opcode == OSD_OP_SEC_READ ||
-        cur_op->req.hdr.opcode == OSD_OP_SEC_LIST ||
-        cur_op->req.hdr.opcode == OSD_OP_SHOW_CONFIG ||
-        cur_op->req.hdr.opcode == OSD_OP_DESCRIBE)
-        : (cur_op->req.hdr.opcode == OSD_OP_WRITE ||
-        cur_op->req.hdr.opcode == OSD_OP_SEC_WRITE ||
-        cur_op->req.hdr.opcode == OSD_OP_SEC_WRITE_STABLE ||
-        cur_op->req.hdr.opcode == OSD_OP_SEC_STABILIZE ||
-        cur_op->req.hdr.opcode == OSD_OP_SEC_ROLLBACK ||
-        cur_op->req.hdr.opcode == OSD_OP_SHOW_CONFIG)) && cur_op->iov.count > 0)
-    {
-        for (int i = 0; i < cur_op->iov.count; i++)
-        {
-            if (cur_op->iov.buf[i].iov_len > 0)
-            {
-                assert(cur_op->iov.buf[i].iov_base);
-                to_send_list.push_back(cur_op->iov.buf[i]);
-                to_outbox.push_back((msgr_sendp_t){ .op = cur_op, .flags = 0 });
-            }
-        }
-    }
-    if (cur_op->req.hdr.opcode == OSD_OP_SEC_READ_BMP)
-    {
-        if (cur_op->op_type == OSD_OP_IN && cur_op->reply.hdr.retval > 0)
-            to_send_list.push_back((iovec){ .iov_base = cur_op->buf, .iov_len = (size_t)cur_op->reply.hdr.retval });
-        else if (cur_op->op_type == OSD_OP_OUT && cur_op->req.sec_read_bmp.len > 0)
-            to_send_list.push_back((iovec){ .iov_base = cur_op->buf, .iov_len = (size_t)cur_op->req.sec_read_bmp.len });
-        to_outbox.push_back((msgr_sendp_t){ .op = cur_op, .flags = 0 });
-    }
-    if (cur_op->op_type == OSD_OP_IN)
-    {
-        to_outbox[to_outbox.size()-1].flags |= MSGR_SENDP_FREE;
    }
+    cl->write_ops.push_back(cur_op);
 #ifdef WITH_RDMA
-    if (cl->peer_state == PEER_RDMA)
+    if (cl->peer_state == PEER_RDMA || cl->peer_state == PEER_RDMA_CONNECTING_OUT)
    {
        try_send_rdma(cl);
        return;
@@ -118,17 +496,17 @@ void osd_messenger_t::outbox_push(osd_op_t *cur_op)
    if (!ringloop)
    {
        // FIXME: It's worse because it doesn't allow batching
-        while (cl->outbox.size())
+        while (cl->write_op || cl->write_ops.size())
        {
            try_send(cl);
        }
    }
    else
    {
-        if ((cl->write_msg.msg_iovlen > 0 || !try_send(cl)) && (cl->write_state == 0))
+        if (!try_send(cl) && cl->write_state == 0)
        {
            cl->write_state = CL_WRITE_READY;
-            write_ready_clients.push_back(cur_op->client_id);
+            write_ready_clients.push_back(cl->client_id);
        }
        ringloop->wakeup();
    }
@@ -185,12 +563,48 @@ void osd_messenger_t::measure_exec(osd_op_t *cur_op)

 bool osd_messenger_t::try_send(osd_client_t *cl)
 {
-    if (!cl->send_list.size() || cl->write_msg.msg_iovlen > 0 || cl->peer_state == PEER_STOPPED || cl->peer_fd < 0)
+    if (cl->peer_state == PEER_STOPPED || cl->peer_fd < 0)
    {
        return true;
    }
+    if (cl->write_msg.msg_iovlen > 0 || !ringloop->space_left() && !use_sync_send_recv)
+    {
+        return false;
+    }
    assert(cl->peer_state != PEER_RDMA);
-    if (ringloop && !use_sync_send_recv)
+    if (cl->hs)
+    {
+        // Send handshake message
+        if (cl->hs->get_out().size())
+        {
+            get_op_writer_t::ssl_extend_buf(cl, cl->hs->get_out().size());
+            memcpy(cl->ssl_out_buf+cl->ssl_out_buf_size, cl->hs->get_out().data(), cl->hs->get_out().size());
+            get_op_writer_t::send_out_buf(cl, cl->hs->get_out().size());
+            cl->hs->get_out().clear();
+        }
+        if (!cl->hs->get_out().size() && cl->hs->done())
+        {
+            delete cl->hs;
+            cl->hs = NULL;
+            goto copy_ops;
+        }
+    }
+    else
+    {
+copy_ops:
+        copy_ops_to_with<get_op_writer_t>(cl, NULL, 0);
+    }
+    if (cl->io_error)
+    {
+        stop_client(cl->client_id);
+        return true;
+    }
+    if (!cl->send_list.size())
+    {
+        cl->write_state = 0;
+        return true;
+    }
+    if (!use_sync_send_recv)
    {
        auto iothread = iothreads.size() ? iothreads[cl->peer_fd % iothreads.size()] : NULL;
        io_uring_sqe sqe_local;
@@ -201,21 +615,22 @@ bool osd_messenger_t::try_send(osd_client_t *cl)
            sqe_local = { .user_data = (uint64_t)&data_local };
            data_local = {};
        }
-        if (!sqe)
-            return false;
+        assert(sqe);
+        cl->send_list_size = 0;
+        for (auto & iov: cl->send_list)
+        {
+            cl->send_list_size += iov.iov_len;
+        }
        cl->write_msg.msg_iov = cl->send_list.data();
        cl->write_msg.msg_iovlen = cl->send_list.size() < IOV_MAX ? cl->send_list.size() : IOV_MAX;
        cl->refs++;
        ring_data_t* data = ((ring_data_t*)sqe->user_data);
        data->callback = [this, cl](ring_data_t *data) { handle_send(data->res, data->prev, data->more, cl); };
        bool use_zc = has_sendmsg_zc && min_zerocopy_send_size >= 0;
-        if (use_zc && min_zerocopy_send_size > 0)
+        if (use_zc && min_zerocopy_send_size > 0 &&
+            cl->send_list_size/cl->write_msg.msg_iovlen < min_zerocopy_send_size)
        {
-            size_t avg_size = 0;
-            for (size_t i = 0; i < cl->write_msg.msg_iovlen; i++)
-                avg_size += cl->write_msg.msg_iov[i].iov_len;
-            if (avg_size/cl->write_msg.msg_iovlen < min_zerocopy_send_size)
-                use_zc = false;
+            use_zc = false;
        }
        if (use_zc)
        {
@@ -246,6 +661,75 @@ bool osd_messenger_t::try_send(osd_client_t *cl)
    return true;
 }

+size_t osd_messenger_t::copy_ops_to(osd_client_t *cl, uint8_t *dst, size_t dst_len)
+{
+    if (cl->gcm_enabled)
+    {
+        if (cl->hs)
+        {
+            // Send handshake message
+            size_t n = 0;
+            if (cl->hs->get_out().size())
+            {
+                n = cl->hs->get_out().size() < dst_len ? cl->hs->get_out().size() : dst_len;
+                memcpy(dst, cl->hs->get_out().data(), n);
+                cl->hs->get_out().erase(cl->hs->get_out().begin(), cl->hs->get_out().begin() + n);
+            }
+            if (!cl->hs->get_out().size() && cl->hs->done())
+            {
+                delete cl->hs;
+                cl->hs = NULL;
+                n += copy_ops_to_with<gcm_op_writer_t>(cl, dst+n, dst_len-n);
+            }
+            return n;
+        }
+        return copy_ops_to_with<gcm_op_writer_t>(cl, dst, dst_len);
+    }
+    return copy_ops_to_with<copy_op_writer_t>(cl, dst, dst_len);
+}
+
+template<typename T>
+size_t osd_messenger_t::copy_ops_to_with(osd_client_t *cl, uint8_t *dst, size_t dst_len)
+{
+    T wr(this, cl, dst, dst_len);
+    while (cl->write_op || cl->write_ops.size())
+    {
+        if (!cl->write_op)
+        {
+            wr.reset();
+            next_write_op(cl);
+        }
+        osd_op_t *op = cl->write_op;
+        if (!op_write_to(cl, wr))
+        {
+            if (cl->io_error)
+                return 0;
+            break;
+        }
+        if (!cl->write_op && op->op_type == OSD_OP_IN)
+        {
+            // this is a reply, free the op after sending it
+            cl->send_free_ops.push_back(op);
+        }
+    }
+    return wr.get_done();
+}
+
+void osd_messenger_t::next_write_op(osd_client_t *cl)
+{
+    cl->write_op = cl->write_ops.front();
+    cl->write_ops.pop_front();
+    if (cl->proto_csum_status == MSGR_CSUM_FULL || cl->proto_csum_status == MSGR_CSUM_PAYLOAD)
+    {
+        if (!cl->write_csum_state)
+            cl->write_csum_state = XXH3_createState();
+        if (cl->my_key.size() == AES_256_GCM_KEY_SIZE + AES_256_GCM_IV_SIZE + XXH_SECRET_DEFAULT_SIZE)
+            XXH3_64bits_reset_withSecret(cl->write_csum_state, cl->my_key.data() + AES_256_GCM_KEY_SIZE + AES_256_GCM_IV_SIZE, XXH_SECRET_DEFAULT_SIZE);
+        else
+            XXH3_64bits_reset(cl->write_csum_state);
+    }
+}
+
 void osd_messenger_t::send_replies()
 {
    for (int i = 0; i < write_ready_clients.size(); i++)
@@ -266,6 +750,7 @@ void osd_messenger_t::handle_send(int result, bool prev, bool more, osd_client_t
    if (!prev)
    {
        cl->write_msg.msg_iovlen = 0;
+        cl->send_list.clear();
    }
    if (!more)
    {
@@ -293,69 +778,68 @@ void osd_messenger_t::handle_send(int result, bool prev, bool more, osd_client_t
            // Second notification - only free a batch of postponed ops
            int i = 0;
            for (; i < cl->zc_free_list.size() && cl->zc_free_list[i]; i++)
-                delete cl->zc_free_list[i];
+            {
+                if (!((size_t)cl->zc_free_list[i] & 7))
+                    delete cl->zc_free_list[i];
+                else
+                    free((void*)((size_t)cl->zc_free_list[i] & ~(size_t)7));
+            }
            if (i > 0)
                cl->zc_free_list.erase(cl->zc_free_list.begin(), cl->zc_free_list.begin()+i+1);
            return;
        }
-        int done = 0;
-        while (result > 0 && done < cl->send_list.size())
+        if (cl->send_list_size > result)
        {
-            iovec & iov = cl->send_list[done];
-            if (iov.iov_len <= result)
+            fprintf(stderr, "Client %ju socket write error: expected to send "
+                "%zu bytes with MSG_WAITALL but sent %u. Disconnecting client\n", cl->client_id, cl->send_list_size, result);
+            stop_client(cl->client_id);
+            return;
+        }
+        for (auto op: cl->send_free_ops)
+        {
+            if (more)
            {
-                if (cl->outbox[done].flags & MSGR_SENDP_FREE)
-                {
-                    // Reply fully sent
-                    if (more)
-                        cl->zc_free_list.push_back(cl->outbox[done].op);
-                    else
-                        delete cl->outbox[done].op;
-                }
-                result -= iov.iov_len;
-                done++;
+                assert(!((size_t)op & 7));
+                cl->zc_free_list.push_back(op);
            }
            else
-            {
-                iov.iov_len -= result;
-                iov.iov_base = (uint8_t*)iov.iov_base + result;
-                break;
-            }
+                delete op;
        }
        if (more)
        {
-            int expected = cl->send_list.size() < IOV_MAX ? cl->send_list.size() : IOV_MAX;
-            if (done != expected)
+            if (cl->ssl_out_buf_size)
            {
-                fprintf(stderr, "Client %ju socket write error: expected to send "
-                    "%d iovecs with MSG_WAITALL but sent %d. Disconnecting client\n", cl->client_id, expected, done);
-                stop_client(cl->client_id);
-                return;
+                cl->zc_free_list.push_back((osd_op_t*)((size_t)cl->ssl_out_buf | 1));
+                cl->ssl_out_buf = NULL;
+                cl->ssl_out_buf_cap = 0;
            }
            cl->zc_free_list.push_back(NULL); // end marker
        }
-        if (done > 0)
+        cl->ssl_out_buf_size = 0;
+        cl->send_free_ops.clear();
+        cl->write_state = 0;
+        if (cl->write_op || cl->write_ops.size())
+            cl->write_state = CL_WRITE_READY;
+        if ((cl->proto_csum_status & MSGR_CSUM_NEG) && !cl->write_op && !cl->write_ops.size())
        {
-            cl->send_list.erase(cl->send_list.begin(), cl->send_list.begin()+done);
-            cl->outbox.erase(cl->outbox.begin(), cl->outbox.begin()+done);
+            // Checksums negotiated, enable
+            cl->proto_csum_status = cl->proto_csum_status & (~MSGR_CSUM_NEG);
        }
-        if (cl->next_send_list.size())
-        {
-            cl->send_list.insert(cl->send_list.end(), cl->next_send_list.begin(), cl->next_send_list.end());
-            cl->outbox.insert(cl->outbox.end(), cl->next_outbox.begin(), cl->next_outbox.end());
-            cl->next_send_list.clear();
-            cl->next_outbox.clear();
-        }
-        cl->write_state = cl->outbox.size() > 0 ? CL_WRITE_READY : 0;
 #ifdef WITH_RDMA
-        if (cl->rdma_conn && !cl->outbox.size() && cl->peer_state == PEER_RDMA_CONNECTING)
+        if (cl->rdma_conn && cl->peer_state == PEER_RDMA_CONNECTING_IN && !cl->write_op && !cl->write_ops.size())
        {
-            // FIXME: Ignore pings during RDMA state transition
-            if (log_level > 0)
+            if (cl->rdma_close_tcp)
            {
-                fprintf(stderr, "Successfully connected with client %ju using RDMA\n", cl->client_id);
+                cl->peer_state = PEER_RDMA_CONNECTING_OUT;
+            }
+            else
+            {
+                if (log_level > 0)
+                {
+                    fprintf(stderr, "Successfully connected with client %ju using RDMA\n", cl->client_id);
+                }
+                cl->peer_state = PEER_RDMA;
            }
-            cl->peer_state = PEER_RDMA;
            // Add the initial receive request
            init_recv_rdma(cl);
        }
@@ -366,3 +850,100 @@ void osd_messenger_t::handle_send(int result, bool prev, bool more, osd_client_t
        write_ready_clients.push_back(cl->client_id);
    }
 }
+
+static inline bool op_has_data_for_ssl(osd_op_t *op)
+{
+    return (op->op_type == OSD_OP_IN
+        ? (op->req.hdr.opcode == OSD_OP_SEC_LIST ||
+        op->req.hdr.opcode == OSD_OP_SHOW_CONFIG ||
+        op->req.hdr.opcode == OSD_OP_DESCRIBE)
+        : (op->req.hdr.opcode == OSD_OP_SEC_STABILIZE ||
+        op->req.hdr.opcode == OSD_OP_SEC_ROLLBACK ||
+        op->req.hdr.opcode == OSD_OP_SHOW_CONFIG)) && op->iov.count > 0;
+}
+
+static inline bool op_has_data_for_nonssl(osd_op_t *op)
+{
+    return (op->op_type == OSD_OP_IN
+        ? (op->req.hdr.opcode == OSD_OP_READ ||
+        op->req.hdr.opcode == OSD_OP_SEC_READ)
+        : (op->req.hdr.opcode == OSD_OP_WRITE ||
+        op->req.hdr.opcode == OSD_OP_SEC_WRITE ||
+        op->req.hdr.opcode == OSD_OP_SEC_WRITE_STABLE)) && op->iov.count > 0;
+}
+
+bool osd_messenger_t::op_write_to(osd_client_t *cl, msgr_op_writer_t & wr)
+{
+    osd_op_t *op = cl->write_op;
+    // Header
+    if (!wr.write((op->op_type == OSD_OP_IN ? op->reply.buf : op->req.buf), OSD_PACKET_SIZE,
+        WR_GCM | (cl->proto_csum_status == MSGR_CSUM_PAYLOAD ? WR_NO_CSUM : 0)))
+    {
+        return false;
+    }
+    // Bitmap
+    if (op->op_type == OSD_OP_IN)
+    {
+        if (op->req.hdr.opcode == OSD_OP_SEC_READ && op->reply.sec_rw.attr_len > 0)
+        {
+            if (!wr.write((uint8_t*)op->bitmap, op->reply.sec_rw.attr_len, WR_GCM))
+                return false;
+        }
+        else if (op->req.hdr.opcode == OSD_OP_SEC_READ_BMP && op->reply.hdr.retval > 0)
+        {
+            if (!wr.write((uint8_t*)op->buf, (size_t)op->reply.hdr.retval, WR_GCM))
+                return false;
+        }
+        else if (op->req.hdr.opcode == OSD_OP_READ && op->reply.rw.bitmap_len > 0)
+        {
+            if (!wr.write((uint8_t*)op->bitmap, op->reply.rw.bitmap_len, WR_GCM))
+                return false;
+        }
+    }
+    else if (op->op_type == OSD_OP_OUT)
+    {
+        if ((op->req.hdr.opcode == OSD_OP_SEC_WRITE || op->req.hdr.opcode == OSD_OP_SEC_WRITE_STABLE) &&
+            op->req.sec_rw.attr_len > 0)
+        {
+            if (!wr.write((uint8_t*)op->bitmap, op->req.sec_rw.attr_len, WR_GCM))
+                return false;
+        }
+        else if (op->req.hdr.opcode == OSD_OP_SEC_READ_BMP && op->req.sec_read_bmp.len > 0)
+        {
+            if (!wr.write((uint8_t*)op->buf, (size_t)op->req.sec_read_bmp.len, WR_GCM))
+                return false;
+        }
+    }
+    // Operation data
+    if (op_has_data_for_ssl(op))
+    {
+        for (int i = 0; i < cl->write_op->iov.count; i++)
+        {
+            auto & iov = cl->write_op->iov.buf[i];
+            if (!wr.write((uint8_t*)iov.iov_base, iov.iov_len, WR_GCM))
+                return false;
+        }
+    }
+    else if (op_has_data_for_nonssl(op))
+    {
+        for (int i = 0; i < cl->write_op->iov.count; i++)
+        {
+            auto & iov = cl->write_op->iov.buf[i];
+            if (!wr.write((uint8_t*)iov.iov_base, iov.iov_len, (op->enc ? WR_XTS : 0)))
+                return false;
+        }
+    }
+    if (cl->proto_csum_status == MSGR_CSUM_FULL ||
+        cl->proto_csum_status == MSGR_CSUM_PAYLOAD && cl->write_op_pos > OSD_PACKET_SIZE)
+    {
+        cl->write_op->csum = XXH3_64bits_digest(cl->write_csum_state);
+        if (!wr.write((uint8_t*)&cl->write_op->csum, 8, WR_GCM|WR_NO_CSUM))
+            return false;
+    }
+    if (!wr.finish())
+        return false;
+    op_encrypt_free(cl);
+    cl->write_op = NULL;
+    cl->write_op_pos = 0;
+    return true;
+}
@@ -5,9 +5,12 @@
 #include <assert.h>

 #include "messenger.h"
+#include "../util/xxh_x86dispatch.h"
 #ifdef WITH_RDMA
 #include "msgr_rdma.h"
 #endif
+#include <openssl/evp.h>
+#include <openssl/pem.h>

 void osd_client_t::cancel_ops()
 {
@@ -79,6 +82,22 @@ void osd_messenger_t::stop_client(uint64_t client_id, bool force_delete)
            fprintf(stderr, "[OSD %ju] Stopping client %ju (regular client)\n", osd_num, client_id);
        }
    }
+    if (cl->xts_enc_ctx)
+    {
+        if (encrypt_xts_pool.size() > max_cipher_pool_size)
+            destroy_aes_xts_encrypt(cl->xts_enc_ctx);
+        else
+            encrypt_xts_pool.push_back(cl->xts_enc_ctx);
+        cl->xts_enc_ctx = NULL;
+    }
+    if (cl->xts_dec_ctx)
+    {
+        if (decrypt_xts_pool.size() > max_cipher_pool_size)
+            destroy_aes_xts_decrypt(cl->xts_dec_ctx);
+        else
+            decrypt_xts_pool.push_back(cl->xts_dec_ctx);
+        cl->xts_dec_ctx = NULL;
+    }
    // First set state to STOPPED so another stop_client() call doesn't try to free it again
    cl->refs++;
    int prev_state = cl->peer_state;
@@ -189,13 +208,23 @@ osd_client_t::~osd_client_t()
    }
    // Cancel outbound ops
    cancel_ops();
-    for (osd_op_t *op: zc_free_list)
+    for (osd_op_t *op: send_free_ops)
    {
        if (op)
        {
            delete op;
        }
    }
+    for (osd_op_t *op: zc_free_list)
+    {
+        if (op)
+        {
+            if (!((size_t)op & 7))
+                delete op;
+            else
+                free((void*)((size_t)op & ~(size_t)7));
+        }
+    }
 #ifndef __MOCK__
 #ifdef WITH_RDMA
    if (rdma_conn)
@@ -205,4 +234,47 @@ osd_client_t::~osd_client_t()
    }
 #endif
 #endif
+    if (read_csum_state)
+    {
+        XXH3_freeState(read_csum_state);
+        read_csum_state = NULL;
+    }
+    if (write_csum_state)
+    {
+        XXH3_freeState(write_csum_state);
+        write_csum_state = NULL;
+    }
+    if (enc_ctx)
+    {
+#ifdef WITH_ISAL_CRYPTO
+        free(enc_ctx);
+#else
+        EVP_CIPHER_CTX_free(enc_ctx);
+#endif
+        enc_ctx = NULL;
+    }
+    if (dec_ctx)
+    {
+#ifdef WITH_ISAL_CRYPTO
+        free(dec_ctx);
+#else
+        EVP_CIPHER_CTX_free(dec_ctx);
+#endif
+        dec_ctx = NULL;
+    }
+    if (ssl_out_buf)
+    {
+        free(ssl_out_buf);
+        ssl_out_buf = NULL;
+    }
+    if (hs)
+    {
+        delete hs;
+        hs = NULL;
+    }
+    if (hs_result.peer_cert)
+    {
+        X509_free(hs_result.peer_cert);
+        hs_result.peer_cert = NULL;
+    }
 }
@@ -37,6 +37,7 @@

 #define OSD_OP_RECOVERY_RELATED     (uint32_t)1
 #define OSD_OP_IGNORE_PG_LOCK       (uint32_t)2
+#define OSD_OP_RETURN_CHAIN         (uint32_t)4

 // Memory alignment for direct I/O (usually 512 bytes)
 #ifndef DIRECT_IO_ALIGNMENT
@@ -228,13 +229,27 @@ struct __attribute__((__packed__)) osd_op_rw_t
    uint64_t offset;
    // length. 0 means to read all bitmaps of the specified range, but no data.
    uint32_t len;
-    // flags (for future)
+    // flags
+    // OSD_OP_RETURN_CHAIN for chained reads: return parent number in chain for each block
+    // read_chain size comes after bitmap, takes 0 bytes / 1 byte / 2 byte / 4 byte per each block,
+    // depending on the number of parent inodes (0 parents = 0 bytes, up to 255 parents = 1 byte, etc)
    uint32_t flags;
-    // inode metadata revision
+    // inode metadata revision for chained reads
    uint64_t meta_revision;
    // object version for atomic "CAS" (compare-and-set) writes
    // writes and deletes fail with -EINTR if object version differs from (version-1)
    uint64_t version;
+
+    static inline size_t chain_info_bytes(size_t chain_size)
+    {
+        if (chain_size <= 1)
+            return 0;
+        if (chain_size <= 256)
+            return 1;
+        if (chain_size <= 65536)
+            return 2;
+        return 4;
+    }
 };

 struct __attribute__((__packed__)) osd_reply_rw_t
@@ -2,11 +2,19 @@ cmake_minimum_required(VERSION 2.8...3.30)

 project(vitastor)

+set(OPENAPI_JSON_H "${CMAKE_CURRENT_BINARY_DIR}/openapi.json.h")
+add_custom_command(
+	OUTPUT ${OPENAPI_JSON_H}
+	COMMAND ${CMAKE_COMMAND} -E echo const char* openapi_description = R\\\"json\\\( > ${OPENAPI_JSON_H}
+	COMMAND ${CMAKE_COMMAND} -E cat ${CMAKE_CURRENT_SOURCE_DIR}/openapi.json >> ${OPENAPI_JSON_H}
+	COMMAND ${CMAKE_COMMAND} -E echo "\\)json\\\"\\;" >> ${OPENAPI_JSON_H}
+	DEPENDS openapi.json
+)
+
 # libvitastor_cli.a
 add_library(vitastor_cli STATIC
 	cli_common.cpp
 	cli_alloc_osd.cpp
-	cli_status.cpp
 	cli_describe.cpp
 	cli_fix.cpp
 	cli_ls.cpp
@@ -14,6 +22,7 @@ add_library(vitastor_cli STATIC
 	cli_dd.cpp
 	cli_modify.cpp
 	cli_modify_osd.cpp
+	cli_modify_user.cpp
 	cli_osd_tree.cpp
 	cli_pg_ls.cpp
 	cli_flatten.cpp
@@ -27,8 +36,13 @@ add_library(vitastor_cli STATIC
 	cli_pool_ls.cpp
 	cli_pool_modify.cpp
 	cli_pool_rm.cpp
+	cli_serve.cpp
+	cli_status.cpp
+	cli_user_ls.cpp
+	${OPENAPI_JSON_H}
 )
 target_compile_options(vitastor_cli PUBLIC -fPIC)
+target_include_directories(vitastor_cli PRIVATE ${CMAKE_CURRENT_BINARY_DIR})

 # vitastor-cli
 add_executable(vitastor-cli
@@ -37,24 +37,42 @@ static const char* help_text =
    "  --sort FIELD    Sort by specified field (name, size, used_size, <read|write|delete>_<iops|bps|lat|queue>)\n"
    "  -r|--reverse    Sort in descending order\n"
    "  -n|--count N    Only list first N items\n"
+    "  --ids ID1,ID2   Only list images with specified full IDs\n"
    "  --tree          Show image snapshot/clone tree\n"
    "\n"
-    "vitastor-cli create -s|--size <size> [-p|--pool <id|name>] [--parent <parent_name>[@<snapshot>]] <name>\n"
-    "  Create an image. You may use K/M/G/T suffixes for <size>. If --parent is specified,\n"
-    "  a copy-on-write image clone is created. Parent must be a snapshot (readonly image).\n"
-    "  Pool must be specified if there is more than one pool.\n"
+    "vitastor-cli create -s|--size SIZE [OPTIONS] <name>\n"
+    "  Create an image. Options:\n"
+    "  -s|--size SIZE      New image size in bytes or with a K/M/G/T unit suffix.\n"
+    "  -p|--pool POOL      Specify pool for the new image (may be omitted if there is only 1 pool).\n"
+    "  --parent PARENT     Create a copy-on-write image clone based on PARENT (or PARENT@SNAPSHOT).\n"
+    "                      If parent is not a snapshot, it must be a read-only image.\n"
+    "  --enc-key random    Generate a new random AES-256-XTS encryption key for the new image.\n"
+    "  --enc-key HEX       Set a specified AES-256-XTS key (64 bytes in hex) for the new image.\n"
+    "  --enc-key vault:ID  Use an encryption key from an external Vault secret with specified ID.\n"
+    "  --owner username    Set owner (default is the current user from TLS certificate).\n"
+    "  --owner_group name  Set owner group name.\n"
+    "  --reader_group rdr  Set reader group name.\n"
    "\n"
-    "vitastor-cli create --snapshot <snapshot> [-p|--pool <id|name>] <image>\n"
-    "vitastor-cli snap-create [-p|--pool <id|name>] <image>@<snapshot>\n"
-    "  Create a snapshot of image <name>. May be used live if only a single writer is active.\n"
+    "vitastor-cli create --snapshot <snapshot> [OPTIONS] <image>\n"
+    "vitastor-cli snap-create [OPTIONS] <image>@<snapshot>\n"
+    "  Create a snapshot of image <image>. May be used live if only a single writer is active.\n"
+    "  Options:\n"
+    "  -p|--pool POOL    Move image to pool POOL, leaving the snapshot in the old pool.\n"
+    "  --enc-key random  Change image encryption key to a new random AES-256-XTS key.\n"
+    "  --enc-key KEY     Change image encryption key to a specified key, Vault key or to an empty key.\n"
+    "                    By default, the image retains its old key when taking a snapshot.\n"
    "\n"
    "vitastor-cli modify <name> [--rename <new-name>] [--resize <size>] [--readonly | --readwrite] [-f|--force] [--down-ok]\n"
    "  Rename, resize image or change its readonly status. Images with children can't be made read-write.\n"
    "  If the new size is smaller than the old size, extra data will be purged.\n"
    "  You should resize file system in the image, if present, before shrinking it.\n"
-    "  --deleted 1|0  Set/clear 'deleted image' flag (set automatically during unfinished deletes).\n"
-    "  -f|--force     Proceed with shrinking or setting readwrite flag even if the image has children.\n"
-    "  --down-ok      Proceed with shrinking even if some data will be left on unavailable OSDs.\n"
+    "  --deleted 1|0       Set/clear 'deleted image' flag (set automatically during unfinished deletes).\n"
+    "  -f|--force          Proceed with shrinking or setting readwrite flag even if the image has children.\n"
+    "  --down-ok           Proceed with shrinking even if some data will be left on unavailable OSDs.\n"
+    "  --enc-key HEX       Change image encryption key (allowed only with --force).\n"
+    "  --owner username    Change image owner.\n"
+    "  --owner_group name  Change image owner group name.\n"
+    "  --reader_group rdr  Change image reader group name.\n"
    "\n"
    "vitastor-cli dd [iimg=<image> | if=<file>] [oimg=<image> | of=<file>] [bs=1M]\n"
    "    [count=N] [seek/oseek=N] [skip/iseek=M] [iodepth=N] [status=progress]\n"
@@ -193,6 +211,7 @@ static const char* help_text =
    "    --used_for_app s3:<name>      Mark pool as used for S3 location with name <name>\n"
    "    --pg_stripe_size <number>     Increase object grouping stripe\n"
    "    --max_osd_combinations 10000  Maximum number of random combinations for LP solver input\n"
+    "    --creator_group <group>       User group allowed to create images in this pool.\n"
    "    --wait                        Wait for the new pool to come online\n"
    "    -f|--force                    Do not check that cluster has enough OSDs to create the pool\n"
    "  Examples:\n"
@@ -204,7 +223,7 @@ static const char* help_text =
    "    [-s|--pg_size <number>] [--pg_minsize <number>] [-n|--pg_count <count>]\n"
    "    [--failure_domain <level>] [--root_node <node>] [--osd_tags <tags>] [--used_for_app <type>:<name>]\n"
    "    [--max_osd_combinations <number>] [--primary_affinity_tags <tags>] [--scrub_interval <time>]\n"
-    "    [--level_placement <rules>] [--raw_placement <rules>]\n"
+    "    [--level_placement <rules>] [--raw_placement <rules>] [--creator_group <group>]\n"
    "  Non-modifiable parameters (changing them WILL lead to data loss):\n"
    "    [--block_size <size>] [--bitmap_granularity <size>]\n"
    "    [--immediate_commit <all|small|none>] [--pg_stripe_size <size>]\n"
@@ -217,7 +236,7 @@ static const char* help_text =
    "vitastor-cli rm-pool|pool-rm [--force] <id|name>\n"
    "  Remove a pool. Refuses to remove pools with images without --force.\n"
    "\n"
-    "vitastor-cli ls-pools|pool-ls|ls-pool|pools [-l] [--detail] [--sort FIELD] [-r] [-n N] [--stats] [<glob> ...]\n"
+    "vitastor-cli ls-pools|pool-ls|ls-pool|pools [-l] [--detail] [--sort FIELD] [-r] [-n N] [<glob> ...]\n"
    "  List pools (only matching <glob> patterns if passed).\n"
    "  -l|--long       Also report I/O statistics\n"
    "  --detail        Use list format (not table), show all details\n"
@@ -225,6 +244,25 @@ static const char* help_text =
    "  -r|--reverse    Sort in descending order\n"
    "  -n|--count N    Only list first N items\n"
    "\n"
+    "vitastor-cli ls-users|user-ls|ls-user|list-users [<name> ...]\n"
+    "  List users (only with specified names if passed).\n"
+    "\n"
+    "vitastor-cli modify-user --type <type> --groups group1,group2,... <username>\n"
+    "  Create or update user permissions. User names match CN of their certificates.\n"
+    "  --type TYPE      Set user type: client, admin, mon or osd. Default is client.\n"
+    "  --groups GROUPS  Set user's groups.\n"
+    "\n"
+    "vitastor-cli rm-user|remove-user|delete-user <username>\n"
+    "  Remove a user.\n"
+    "\n"
+    "vitastor-cli serve\n"
+    "  Start HTTP server able to handle CLI commands over a REST API. Options:\n"
+    "  --bind_address ADDR  Specify server IP address or addresses, separated by space. Default is 127.0.0.1.\n"
+    "  --port 8080          Specify server port.\n"
+    "  --server_cert FILE   Path to server TLS certificate file (PEM format).\n"
+    "  --server_key FILE    Path to server TLS private key file.\n"
+    "  --client_ca FILE     Path to file with TLS CA certificates used to validate client connections.\n"
+    "\n"
    "Use vitastor-cli --help <command> for command details or vitastor-cli --help --all for all details.\n"
    "\n"
    "GLOBAL OPTIONS:\n"
@@ -319,27 +357,24 @@ static json11::Json::object parse_args(int narg, const char *args[])
    return cfg;
 }

-static int run(cli_tool_t *p, json11::Json::object cfg)
+std::function<bool(cli_result_t &)> cli_tool_t::start(json11::Json::object cfg, cli_result_t & result)
 {
-    cli_result_t result = {};
-    p->is_command_line = true;
-    p->parse_config(cfg);
    json11::Json::array cmd = cfg["command"].array_items();
    cfg.erase("command");
    std::function<bool(cli_result_t &)> action_cb;
    if (!cmd.size())
    {
-        result = { .err = EINVAL, .text = "command is missing" };
+        result = { .err = EOPNOTSUPP, .text = "command is missing" };
    }
    else if (cmd[0] == "status")
    {
        // Show cluster status
-        action_cb = p->start_status(cfg);
+        action_cb = start_status(cfg);
    }
    else if (cmd[0] == "df")
    {
        // Show pool space stats
-        action_cb = p->start_pool_ls(cfg);
+        action_cb = start_pool_ls(cfg);
    }
    else if (cmd[0] == "ls")
    {
@@ -349,7 +384,7 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
            cmd.erase(cmd.begin(), cmd.begin()+1);
            cfg["names"] = cmd;
        }
-        action_cb = p->start_ls(cfg);
+        action_cb = start_ls(cfg);
    }
    else if (cmd[0] == "snap-create")
    {
@@ -364,7 +399,7 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
        {
            cfg["image"] = name.substr(0, pos);
            cfg["snapshot"] = name.substr(pos + 1);
-            action_cb = p->start_create(cfg);
+            action_cb = start_create(cfg);
        }
    }
    else if (cmd[0] == "create")
@@ -374,7 +409,7 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
        {
            cfg["image"] = cmd[1];
        }
-        action_cb = p->start_create(cfg);
+        action_cb = start_create(cfg);
    }
    else if (cmd[0] == "modify")
    {
@@ -383,12 +418,12 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
        {
            cfg["image"] = cmd[1];
        }
-        action_cb = p->start_modify(cfg);
+        action_cb = start_modify(cfg);
    }
    else if (cmd[0] == "rm-data")
    {
        // Delete inode data
-        action_cb = p->start_rm_data(cfg);
+        action_cb = start_rm_data(cfg);
    }
    else if (cmd[0] == "rm-osd")
    {
@@ -398,7 +433,7 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
            cmd.erase(cmd.begin(), cmd.begin()+1);
            cfg["osd_id"] = cmd;
        }
-        action_cb = p->start_rm_osd(cfg);
+        action_cb = start_rm_osd(cfg);
    }
    else if (cmd[0] == "merge-data")
    {
@@ -409,7 +444,7 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
            if (cmd.size() > 2)
                cfg["to"] = cmd[2];
        }
-        action_cb = p->start_merge(cfg);
+        action_cb = start_merge(cfg);
    }
    else if (cmd[0] == "flatten")
    {
@@ -418,7 +453,7 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
        {
            cfg["image"] = cmd[1];
        }
-        action_cb = p->start_flatten(cfg);
+        action_cb = start_flatten(cfg);
    }
    else if (cmd[0] == "dd")
    {
@@ -432,16 +467,31 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
                cfg[arg.substr(0, p)] = arg.substr(p+1);
            }
        }
-        action_cb = p->start_dd(cfg);
+        action_cb = start_dd(cfg);
    }
    else if (cmd[0] == "rm")
    {
        // Remove multiple snapshots and rebase their children
-        if (cfg["exact"].bool_value() || cfg["matching"].bool_value())
+        if (cfg["names"].is_array())
+        {
+            cfg["globs"] = cfg["names"];
+            cfg.erase("names");
+            cfg["exact"] = true;
+            cfg["matching"] = false;
+            action_cb = start_rm_wildcard(cfg);
+        }
+        else if (cfg["matching"].is_array())
+        {
+            cfg["globs"] = cfg["matching"];
+            cfg["exact"] = false;
+            cfg["matching"] = true;
+            action_cb = start_rm_wildcard(cfg);
+        }
+        else if (cfg["exact"].bool_value() || cfg["matching"].bool_value())
        {
            cmd.erase(cmd.begin(), cmd.begin()+1);
            cfg["globs"] = cmd;
-            action_cb = p->start_rm_wildcard(cfg);
+            action_cb = start_rm_wildcard(cfg);
        }
        else
        {
@@ -451,41 +501,41 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
                if (cmd.size() > 2)
                    cfg["to"] = cmd[2];
            }
-            action_cb = p->start_rm(cfg);
+            action_cb = start_rm(cfg);
        }
    }
    else if (cmd[0] == "describe")
    {
        // Describe unclean objects
-        action_cb = p->start_describe(cfg);
+        action_cb = start_describe(cfg);
    }
    else if (cmd[0] == "fix")
    {
        // Fix inconsistent objects (by deleting some copies)
-        action_cb = p->start_fix(cfg);
+        action_cb = start_fix(cfg);
    }
    else if (cmd[0] == "alloc-osd")
    {
        // Allocate a new OSD number
-        action_cb = p->start_alloc_osd(cfg);
+        action_cb = start_alloc_osd(cfg);
    }
    else if (cmd[0] == "osd-tree")
    {
        // Print OSD tree
-        action_cb = p->start_osd_tree(cfg);
+        cfg["as_tree"] = true;
+        action_cb = start_osd_tree(cfg);
    }
    else if (cmd[0] == "osds" || cmd[0] == "ls-osds" || cmd[0] == "ls-osd" || cmd[0] == "osd-ls")
    {
        // Print OSD list
-        cfg["flat"] = true;
-        action_cb = p->start_osd_tree(cfg);
+        action_cb = start_osd_tree(cfg);
    }
    else if (cmd[0] == "modify-osd")
    {
        // Modify OSD configuration
        if (cmd.size() > 1)
            cfg["osd_num"] = cmd[1];
-        action_cb = p->start_modify_osd(cfg);
+        action_cb = start_modify_osd(cfg);
    }
    else if (cmd[0] == "pg-list" || cmd[0] == "pg-ls" || cmd[0] == "list-pg" || cmd[0] == "ls-pg" || cmd[0] == "ls-pgs" || cmd[0] == "pgs")
    {
@@ -495,7 +545,7 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
            cmd.erase(cmd.begin(), cmd.begin()+1);
            cfg["pg_state"] = cmd;
        }
-        action_cb = p->start_pg_list(cfg);
+        action_cb = start_pg_list(cfg);
    }
    else if (cmd[0] == "create-pool" || cmd[0] == "pool-create")
    {
@@ -504,16 +554,16 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
        {
            cfg["name"] = cmd[1];
        }
-        action_cb = p->start_pool_create(cfg);
+        action_cb = start_pool_create(cfg);
    }
    else if (cmd[0] == "modify-pool" || cmd[0] == "pool-modify")
    {
        // Modify existing pool
        if (cmd.size() > 1)
        {
-            cfg["old_name"] = cmd[1];
+            cfg["pool"] = cmd[1];
        }
-        action_cb = p->start_pool_modify(cfg);
+        action_cb = start_pool_modify(cfg);
    }
    else if (cmd[0] == "rm-pool" || cmd[0] == "pool-rm")
    {
@@ -522,7 +572,7 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
        {
            cfg["pool"] = cmd[1];
        }
-        action_cb = p->start_pool_rm(cfg);
+        action_cb = start_pool_rm(cfg);
    }
    else if (cmd[0] == "ls-pool" || cmd[0] == "pool-ls" || cmd[0] == "ls-pools" || cmd[0] == "pools")
    {
@@ -533,12 +583,55 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
            cmd.erase(cmd.begin(), cmd.begin()+1);
            cfg["names"] = cmd;
        }
-        action_cb = p->start_pool_ls(cfg);
+        action_cb = start_pool_ls(cfg);
+    }
+    else if (cmd[0] == "user-ls" || cmd[0] == "ls-user" || cmd[0] == "ls-users" || cmd[0] == "list-users")
+    {
+        // List users
+        if (cmd.size() > 1)
+        {
+            cmd.erase(cmd.begin(), cmd.begin()+1);
+            cfg["names"] = cmd;
+        }
+        action_cb = start_user_ls(cfg);
+    }
+    else if (cmd[0] == "modify-user" || cmd[0] == "user-modify")
+    {
+        // Create/update user
+        if (cmd.size() > 1)
+        {
+            cfg["name"] = cmd[1];
+        }
+        action_cb = start_modify_user(cfg);
+    }
+    else if (cmd[0] == "rm-user" || cmd[0] == "remove-user" || cmd[0] == "delete-user")
+    {
+        // Remove user
+        if (cmd.size() > 1)
+        {
+            cfg["name"] = cmd[1];
+        }
+        cfg["remove"] = true;
+        action_cb = start_modify_user(cfg);
+    }
+    else if (cmd[0] == "serve")
+    {
+        // Start HTTP server
+        action_cb = start_serve(cfg);
    }
    else
    {
-        result = { .err = EINVAL, .text = "unknown command: "+cmd[0].string_value() };
+        result = { .err = EOPNOTSUPP, .text = "unknown command: "+cmd[0].string_value() };
    }
+    return action_cb;
+}
+
+static int run(cli_tool_t *p, json11::Json::object cfg)
+{
+    cli_result_t result = {};
+    p->is_command_line = true;
+    p->parse_config(cfg);
+    auto action_cb = p->start(cfg, result);
    if (action_cb != NULL)
    {
        // Create client
@@ -550,6 +643,7 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
        {
            result = r;
            action_cb = NULL;
+            p->ringloop->submit();
        });
        // Loop until it completes
        while (action_cb != NULL)
@@ -9,6 +9,7 @@
 #include "object_id.h"
 #include "ringloop.h"
 #include <functional>
+#include <set>

 struct rm_inode_t;
 struct snap_merger_t;
@@ -26,6 +27,8 @@ struct cli_result_t
    json11::Json data;
 };

+struct user_info_t;
+
 class cli_tool_t
 {
 public:
@@ -37,6 +40,8 @@ public:
    bool is_command_line = false;
    bool color = false;

+    std::shared_ptr<user_info_t> user; // for http mode
+
    ring_loop_t *ringloop = NULL;
    epoll_manager_t *epmgr = NULL;
    cluster_client_t *cli = NULL;
@@ -46,18 +51,24 @@ public:
    json11::Json etcd_result;

    void parse_config(json11::Json::object & cfg);
+    void parse_api_opts(json11::Json::object & cfg);
    json11::Json parse_tags(std::string tags);

+    json11::Json::object format_image(const inode_config_t & cfg);
    void change_parent(inode_t cur, inode_t new_parent, cli_result_t *result);
    inode_config_t* get_inode_cfg(const std::string & name);

+    bool check_image_perm(const inode_config_t & cfg, bool write);
+
    friend struct rm_inode_t;
    friend struct snap_merger_t;
    friend struct snap_flattener_t;
    friend struct snap_remover_t;

+    std::function<bool(cli_result_t &)> start(json11::Json::object cfg, cli_result_t & result);
    std::function<bool(cli_result_t &)> start_alloc_osd(json11::Json);
    std::function<bool(cli_result_t &)> start_create(json11::Json);
+    std::function<bool(cli_result_t &)> start_dd(json11::Json);
    std::function<bool(cli_result_t &)> start_describe(json11::Json);
    std::function<bool(cli_result_t &)> start_fix(json11::Json);
    std::function<bool(cli_result_t &)> start_flatten(json11::Json);
@@ -65,6 +76,7 @@ public:
    std::function<bool(cli_result_t &)> start_merge(json11::Json);
    std::function<bool(cli_result_t &)> start_modify(json11::Json);
    std::function<bool(cli_result_t &)> start_modify_osd(json11::Json);
+    std::function<bool(cli_result_t &)> start_modify_user(json11::Json);
    std::function<bool(cli_result_t &)> start_osd_tree(json11::Json);
    std::function<bool(cli_result_t &)> start_pg_list(json11::Json);
    std::function<bool(cli_result_t &)> start_pool_create(json11::Json);
@@ -75,8 +87,9 @@ public:
    std::function<bool(cli_result_t &)> start_rm_data(json11::Json);
    std::function<bool(cli_result_t &)> start_rm_osd(json11::Json);
    std::function<bool(cli_result_t &)> start_rm_wildcard(json11::Json);
+    std::function<bool(cli_result_t &)> start_serve(json11::Json);
    std::function<bool(cli_result_t &)> start_status(json11::Json);
-    std::function<bool(cli_result_t &)> start_dd(json11::Json);
+    std::function<bool(cli_result_t &)> start_user_ls(json11::Json);

    // Should be called like loop_and_wait(start_status(), <completion callback>)
    void loop_and_wait(std::function<bool(cli_result_t &)> loop_cb, std::function<void(const cli_result_t &)> complete_cb);
@@ -6,6 +6,62 @@
 #include "cluster_client.h"
 #include "cli.h"

+bool cli_tool_t::check_image_perm(const inode_config_t & cfg, bool write)
+{
+    return !user ||
+        user->type == user_type_t::ADMIN ||
+        user->name == cfg.owner ||
+        cfg.owner_group != "" && user->groups.find(cfg.owner_group) != user->groups.end() ||
+        !write && cfg.reader_group != "" && user->groups.find(cfg.reader_group) != user->groups.end();
+}
+
+json11::Json::object cli_tool_t::format_image(const inode_config_t & cfg)
+{
+    auto pool_it = cli->st_cli.pool_config.find(INODE_POOL(cfg.num));
+    bool good_pool = pool_it != cli->st_cli.pool_config.end();
+    auto img = json11::Json::object {
+        { "name", cfg.name },
+        { "size", cfg.size },
+        { "inode_id", cfg.num },
+        { "inode_num", INODE_NO_POOL(cfg.num) },
+        { "pool_id", (uint64_t)INODE_POOL(cfg.num) },
+        { "pool_name", good_pool ? pool_it->second.name : "? (ID:"+std::to_string(INODE_POOL(cfg.num))+")" },
+        { "readonly", cfg.readonly },
+        { "deleted", cfg.deleted },
+    };
+    if (cfg.owner != "")
+    {
+        img["owner"] = cfg.owner;
+    }
+    if (cfg.owner_group != "")
+    {
+        img["owner_group"] = cfg.owner_group;
+    }
+    if (cfg.reader_group != "")
+    {
+        img["reader_group"] = cfg.reader_group;
+    }
+    if (!cfg.enc_key.empty())
+    {
+        img["encrypted"] = true;
+        // Only show Vault key IDs
+        if (cfg.enc_key.substr(0, strlen(VAULT_KEY_PREFIX)) == VAULT_KEY_PREFIX)
+            img["enc_key_id"] = cfg.enc_key;
+    }
+    if (cfg.parent_id)
+    {
+        auto parent_it = cli->st_cli.inode_config.find(cfg.parent_id);
+        if (parent_it != cli->st_cli.inode_config.end())
+        {
+            img["parent_name"] = parent_it->second.name;
+        }
+        img["parent_inode_id"] = cfg.parent_id;
+        img["parent_inode_num"] = INODE_NO_POOL(cfg.parent_id);
+        img["parent_pool_id"] = (uint64_t)INODE_POOL(cfg.parent_id);
+    }
+    return img;
+}
+
 void cli_tool_t::change_parent(inode_t cur, inode_t new_parent, cli_result_t *result)
 {
    auto cur_cfg_it = cli->st_cli.inode_config.find(cur);
@@ -101,6 +157,16 @@ inode_config_t* cli_tool_t::get_inode_cfg(const std::string & name)
    return NULL;
 }

+void cli_tool_t::parse_api_opts(json11::Json::object & cfg)
+{
+    iodepth = cfg["iodepth"].uint64_value();
+    if (!iodepth)
+        iodepth = 32;
+    parallel_osds = cfg["parallel_osds"].uint64_value();
+    if (!parallel_osds)
+        parallel_osds = 4;
+}
+
 void cli_tool_t::parse_config(json11::Json::object & cfg)
 {
    for (auto kv_it = cfg.begin(); kv_it != cfg.end();)
@@ -121,15 +187,10 @@ void cli_tool_t::parse_config(json11::Json::object & cfg)
    else
        color = isatty(1);
    json_output = cfg["json"].bool_value();
-    iodepth = cfg["iodepth"].uint64_value();
-    if (!iodepth)
-        iodepth = 32;
-    parallel_osds = cfg["parallel_osds"].uint64_value();
-    if (!parallel_osds)
-        parallel_osds = 4;
    log_level = cfg["log_level"].int64_value();
    progress = cfg["progress"].uint64_value() ? true : false;
    list_first = cfg["wait_list"].uint64_value() ? true : false;
+    parse_api_opts(cfg);
 }

 struct cli_result_looper_t
@@ -153,7 +214,6 @@ void cli_tool_t::loop_and_wait(std::function<bool(cli_result_t &)> loop_cb, std:
            ringloop->unregister_consumer(&looper->consumer);
            looper->loop_cb = NULL;
            looper->complete_cb(looper->result);
-            ringloop->submit();
            delete looper;
            return;
        }
@@ -1,8 +1,11 @@
 // Copyright (c) Vitaliy Filippov, 2019+
 // License: VNPL-1.1 (see README.md for details)

+#include <openssl/rand.h>
+
 #include <ctype.h>
 #include "cli.h"
+#include "http_client.h"
 #include "cluster_client.h"
 #include "str_util.h"

@@ -29,11 +32,15 @@ struct image_creator_t
    uint64_t size = 0;
    bool force = false;
    bool force_size = false;
+    std::string enc_key;
+    bool set_key = false;
+    std::string new_owner, new_owner_group, new_reader_group;

    pool_id_t old_pool_id = 0;
    inode_t new_parent_id = 0;
    inode_t new_id = 0, old_id = 0;
-    uint64_t max_id_mod_rev = 0, cfg_mod_rev = 0, idx_mod_rev = 0;
+    uint64_t max_id_mod_rev = 0, idx_mod_rev = 0;
+    inode_config_t cur_cfg;
    inode_config_t new_cfg;

    int state = 0;
@@ -64,7 +71,8 @@ struct image_creator_t
        }
        if (new_pool_id)
        {
-            if (pools.find(new_pool_id) == pools.end())
+            auto pool_it = pools.find(new_pool_id);
+            if (pool_it == pools.end())
            {
                result = (cli_result_t){ .err = ENOENT, .text = "Pool "+std::to_string(new_pool_id)+" does not exist" };
                state = 100;
@@ -111,6 +119,23 @@ struct image_creator_t
            create_snapshot();
    }

+    bool check_pool_permission()
+    {
+        if (!parent->user || parent->user->type == user_type_t::ADMIN)
+        {
+            return true;
+        }
+        auto pool_it = parent->cli->st_cli.pool_config.find(new_pool_id);
+        if (pool_it == parent->cli->st_cli.pool_config.end() ||
+            (pool_it->second.creator_group == "" || parent->user->groups.find(pool_it->second.creator_group) == parent->user->groups.end()))
+        {
+            result = (cli_result_t){ .err = EACCES, .text = "Pool image create permission denied" };
+            state = 100;
+            return false;
+        }
+        return true;
+    }
+
    void create_image()
    {
        if (state == 2)
@@ -150,6 +175,10 @@ struct image_creator_t
            state = 100;
            return;
        }
+        if (!check_pool_permission())
+        {
+            return;
+        }
        if (!size && !force_size)
        {
            result = (cli_result_t){ .err = EINVAL, .text = "Image size is missing" };
@@ -194,15 +223,11 @@ resume_3:
        // Save into inode_config for library users to be able to take it from there immediately
        new_cfg.mod_revision = parent->etcd_result["header"]["revision"].uint64_value();
        parent->cli->st_cli.insert_inode_config(new_cfg);
+        auto img = parent->format_image(new_cfg);
        result = (cli_result_t){
            .err = 0,
            .text = "Image "+image_name+" created",
-            .data = json11::Json::object {
-                { "name", image_name },
-                { "pool", new_pool_name },
-                { "parent", new_parent },
-                { "size", size },
-            }
+            .data = img,
        };
        state = 100;
    }
@@ -233,7 +258,7 @@ resume_3:
        }
        do
        {
-            // In addition to next_id, get: size, old_id, old_pool_id, new_parent, cfg_mod_rev, idx_mod_rev
+            // In addition to next_id, get: cur_cfg, old_id, old_pool_id, size, idx_mod_rev
 resume_2:
 resume_3:
            get_image_details();
@@ -245,11 +270,22 @@ resume_3:
                state = 100;
                return;
            }
+            if (!parent->check_image_perm(cur_cfg, true))
+            {
+                result = (cli_result_t){ .err = EACCES, .text = "Image permission denied" };
+                state = 100;
+                return;
+            }
            if (!new_pool_id)
            {
                // Create snapshot in the same pool by default
                new_pool_id = old_pool_id;
            }
+            // Verify pool permissions if the pool is different from the original
+            if (new_pool_id != old_pool_id && !check_pool_permission())
+            {
+                return;
+            }
            attempt_create();
            state = 4;
 resume_4:
@@ -272,13 +308,23 @@ resume_4:
        // Save into inode_config for library users to be able to take it from there immediately
        new_cfg.mod_revision = parent->etcd_result["header"]["revision"].uint64_value();
        parent->cli->st_cli.insert_inode_config(new_cfg);
+        {
+            auto new_pool_it = parent->cli->st_cli.pool_config.find(new_pool_id);
+            new_pool_name = new_pool_it != parent->cli->st_cli.pool_config.end() ? new_pool_it->second.name : "";
+        }
        result = (cli_result_t){
            .err = 0,
            .text = "Snapshot "+image_name+"@"+new_snap+" created",
            .data = json11::Json::object {
-                { "name", image_name+"@"+new_snap },
-                { "pool", (uint64_t)new_pool_id },
-                { "parent", new_parent },
+                { "inode_id", INODE_WITH_POOL(new_pool_id, new_id) },
+                { "inode_num", new_id },
+                { "name", image_name },
+                { "pool_id", (uint64_t)new_pool_id },
+                { "pool_name", new_pool_name },
+                { "parent_name", image_name+"@"+new_snap },
+                { "parent_inode_id", INODE_WITH_POOL(old_pool_id, old_id) },
+                { "parent_inode_num", old_id },
+                { "parent_pool_id", (uint64_t)old_pool_id },
                { "size", size },
            }
        };
@@ -323,17 +369,6 @@ resume_4:
            goto resume_2;
        else if (state == 3)
            goto resume_3;
-        if (!new_pool_id)
-        {
-            for (auto & ic: parent->cli->st_cli.inode_config)
-            {
-                if (ic.second.name == image_name)
-                {
-                    new_pool_id = INODE_POOL(ic.first);
-                    break;
-                }
-            }
-        }
        parent->etcd_txn(json11::Json::object { { "success", json11::Json::array {
            get_next_id(),
            json11::Json::object {
@@ -357,7 +392,7 @@ resume_2:
        extract_next_id(parent->etcd_result["responses"][0]);
        old_id = 0;
        old_pool_id = 0;
-        cfg_mod_rev = idx_mod_rev = 0;
+        idx_mod_rev = 0;
        if (parent->etcd_result["responses"][1]["response_range"]["kvs"].array_items().size() == 0)
        {
            for (auto & ic: parent->cli->st_cli.inode_config)
@@ -366,9 +401,8 @@ resume_2:
                {
                    old_id = INODE_NO_POOL(ic.first);
                    old_pool_id = INODE_POOL(ic.first);
+                    cur_cfg = ic.second;
                    size = ic.second.size;
-                    new_parent_id = ic.second.parent_id;
-                    cfg_mod_rev = ic.second.mod_revision;
                    break;
                }
            }
@@ -412,16 +446,14 @@ resume_3:
            }
            {
                auto kv = parent->cli->st_cli.parse_etcd_kv(parent->etcd_result["responses"][0]["response_range"]["kvs"][0]);
-                size = kv.value["size"].uint64_value();
-                new_parent_id = kv.value["parent_id"].uint64_value();
-                uint64_t parent_pool_id = kv.value["parent_pool"].uint64_value();
-                if (new_parent_id)
-                {
-                    new_parent_id = INODE_WITH_POOL(parent_pool_id ? parent_pool_id : old_pool_id, new_parent_id);
-                }
-                cfg_mod_rev = kv.mod_revision;
+                cur_cfg = parent->cli->st_cli.deserialize_inode_cfg(INODE_WITH_POOL(old_pool_id, old_id), kv.value, kv.mod_revision);
+                size = cur_cfg.size;
            }
        }
+        if (!new_pool_id)
+        {
+            new_pool_id = old_pool_id;
+        }
    }

    void attempt_create()
@@ -434,6 +466,27 @@ resume_3:
            .readonly = false,
            .meta = new_meta,
        };
+        if (set_key)
+        {
+            new_cfg.enc_key = enc_key;
+        }
+        else if (new_snap != "")
+        {
+            new_cfg.enc_key = cur_cfg.enc_key;
+        }
+        new_cfg.owner = http_context_get_ssl_cn(parent->cli->st_cli.get_http_ctx());
+        if (!new_owner.empty())
+        {
+            new_cfg.owner = new_owner;
+        }
+        if (!new_owner_group.empty())
+        {
+            new_cfg.owner_group = new_owner_group;
+        }
+        if (!new_reader_group.empty())
+        {
+            new_cfg.reader_group = new_reader_group;
+        }
        json11::Json::array checks = json11::Json::array {
            json11::Json::object {
                { "target", "VERSION" },
@@ -500,16 +553,12 @@ resume_3:
        };
        if (new_snap != "")
        {
-            inode_config_t snap_cfg = {
-                .num = INODE_WITH_POOL(old_pool_id, old_id),
-                .name = image_name+"@"+new_snap,
-                .size = size,
-                .parent_id = new_parent_id,
-                .readonly = true,
-            };
+            inode_config_t snap_cfg = cur_cfg;
+            snap_cfg.name = image_name+"@"+new_snap;
+            snap_cfg.readonly = true;
            checks.push_back(json11::Json::object {
                { "target", "MOD" },
-                { "mod_revision", cfg_mod_rev },
+                { "mod_revision", cur_cfg.mod_revision },
                { "key", base64_encode(
                    parent->cli->st_cli.etcd_prefix+"/config/inode/"+
                    std::to_string(old_pool_id)+"/"+std::to_string(old_id)
@@ -554,8 +603,16 @@ std::function<bool(cli_result_t &)> cli_tool_t::start_create(json11::Json cfg)
    auto image_creator = new image_creator_t();
    image_creator->parent = this;
    image_creator->image_name = cfg["image"].string_value();
-    image_creator->new_pool_id = cfg["pool"].uint64_value();
-    image_creator->new_pool_name = cfg["pool"].string_value();
+    if (!cfg["pool"].is_null())
+    {
+        image_creator->new_pool_id = cfg["pool"].uint64_value();
+        image_creator->new_pool_name = cfg["pool"].string_value();
+    }
+    else
+    {
+        image_creator->new_pool_id = cfg["pool_id"].uint64_value();
+        image_creator->new_pool_name = cfg["pool_name"].string_value();
+    }
    image_creator->force = cfg["force"].bool_value();
    image_creator->force_size = cfg["force_size"].bool_value();
    if (cfg["image_meta"].is_object())
@@ -566,6 +623,33 @@ std::function<bool(cli_result_t &)> cli_tool_t::start_create(json11::Json cfg)
    {
        image_creator->new_snap = cfg["snapshot"].string_value();
    }
+    if (!cfg["enc_key"].is_null())
+    {
+        image_creator->set_key = true;
+        if (image_creator->enc_key == "random")
+        {
+            uint8_t newkey[64];
+            RAND_bytes(newkey, 64);
+            image_creator->enc_key = tohexstr(newkey, 64);
+        }
+        else
+        {
+            image_creator->enc_key = cfg["enc_key"].string_value();
+            if (image_creator->enc_key != "" &&
+                image_creator->enc_key.substr(0, strlen(VAULT_KEY_PREFIX)) != VAULT_KEY_PREFIX &&
+                (!ishexstr(image_creator->enc_key) || image_creator->enc_key.size() != 128))
+            {
+                return [](cli_result_t & result)
+                {
+                    result = (cli_result_t){ .err = EINVAL, .text = "Encryption key is not a 512-bit hex string, not \"\" and not \"random\"" };
+                    return true;
+                };
+            }
+        }
+    }
+    image_creator->new_owner = cfg["owner"].string_value();
+    image_creator->new_owner_group = cfg["owner_group"].string_value();
+    image_creator->new_reader_group = cfg["reader_group"].string_value();
    image_creator->new_parent = cfg["parent"].string_value();
    if (!cfg["size"].is_null())
    {
@@ -864,7 +864,7 @@ resume_2:
        // Copy data
        if (iinfo.in_seekable && iseek >= iinfo.in_size)
        {
-            result = (cli_result_t){ .err = -EINVAL, .text = "Input seek position is beyond end of input" };
+            result = (cli_result_t){ .err = EINVAL, .text = "Input seek position is beyond end of input" };
            goto close_end;
        }
        if (!iinfo.iwatch && !iinfo.in_seekable && iseek)
@@ -57,12 +57,24 @@ struct cli_describe_t

    void parse_options(json11::Json cfg)
    {
-        only_pool = cfg["pool"].uint64_value();
-        if (!only_pool && cfg["pool"].is_string())
+        uint64_t pool_id;
+        std::string pool_name;
+        if (!cfg["pool"].is_null())
+        {
+            pool_id = cfg["pool"].uint64_value();
+            pool_name = pool_id ? "" : cfg["pool"].string_value();
+        }
+        else
+        {
+            pool_id = cfg["pool_id"].uint64_value();
+            pool_name = pool_id ? "" : cfg["pool_name"].string_value();
+        }
+        only_pool = pool_id;
+        if (!only_pool && pool_name != "")
        {
            for (auto & pp: parent->cli->st_cli.pool_config)
            {
-                if (pp.second.name == cfg["pool"].string_value())
+                if (pp.second.name == pool_name)
                {
                    only_pool = pp.first;
                    break;
@@ -106,6 +118,22 @@ struct cli_describe_t
            if (cfg["object_state"].string_value().find("misplaced") != std::string::npos)
                object_state |= OBJ_MISPLACED;
        }
+        else if (!object_state && cfg["object_state"].is_array())
+        {
+            for (auto & st: cfg["object_state"].array_items())
+            {
+                if (st == "inconsistent")
+                    object_state |= OBJ_INCONSISTENT;
+                else if (st == "corrupted")
+                    object_state |= OBJ_CORRUPTED;
+                else if (st == "incomplete")
+                    object_state |= OBJ_INCOMPLETE;
+                else if (st == "degraded")
+                    object_state |= OBJ_DEGRADED;
+                else if (st == "misplaced")
+                    object_state |= OBJ_MISPLACED;
+            }
+        }
    }

    void loop()
@@ -35,6 +35,12 @@ struct snap_flattener_t
            state = 100;
            return;
        }
+        if (!parent->check_image_perm(*target_cfg, true))
+        {
+            result = (cli_result_t){ .err = EACCES, .text = "Image permission denied" };
+            state = 100;
+            return;
+        }
        target_id = target_cfg->num;
        std::vector<inode_t> chain_list;
        inode_config_t *cur = target_cfg;
@@ -17,6 +17,7 @@ struct image_lister_t
    std::string list_pool_name;
    std::string sort_field;
    std::set<std::string> only_names;
+    std::vector<uint64_t> only_ids;
    bool reverse = false;
    bool exact = false;
    bool tree = false;
@@ -52,35 +53,19 @@ struct image_lister_t
                return;
            }
        }
-        for (auto & ic: parent->cli->st_cli.inode_config)
+        auto begin_it = list_pool_id
+            ? parent->cli->st_cli.inode_config.lower_bound(INODE_WITH_POOL(list_pool_id, 0))
+            : parent->cli->st_cli.inode_config.begin();
+        auto end_it = list_pool_id
+            ? parent->cli->st_cli.inode_config.lower_bound(INODE_WITH_POOL(list_pool_id+1, 0))
+            : parent->cli->st_cli.inode_config.end();
+        for (auto it = begin_it; it != end_it; it++)
        {
-            if (list_pool_id && INODE_POOL(ic.second.num) != list_pool_id)
+            if (!parent->check_image_perm(it->second, false))
            {
                continue;
            }
-            auto pool_it = parent->cli->st_cli.pool_config.find(INODE_POOL(ic.second.num));
-            bool good_pool = pool_it != parent->cli->st_cli.pool_config.end();
-            auto item = json11::Json::object {
-                { "name", ic.second.name },
-                { "size", ic.second.size },
-                { "used_size", 0 },
-                { "readonly", ic.second.readonly },
-                { "pool_id", (uint64_t)INODE_POOL(ic.second.num) },
-                { "pool_name", good_pool ? pool_it->second.name : "? (ID:"+std::to_string(INODE_POOL(ic.second.num))+")" },
-                { "inode_num", INODE_NO_POOL(ic.second.num) },
-                { "inode_id", ic.second.num },
-                { "deleted", ic.second.deleted },
-            };
-            if (ic.second.parent_id)
-            {
-                auto p_it = parent->cli->st_cli.inode_config.find(ic.second.parent_id);
-                item["parent_name"] = p_it != parent->cli->st_cli.inode_config.end()
-                    ? p_it->second.name : "";
-                item["parent_pool_id"] = (uint64_t)INODE_POOL(ic.second.parent_id);
-                item["parent_inode_num"] = INODE_NO_POOL(ic.second.parent_id);
-                item["parent_inode_id"] = ic.second.parent_id;
-            }
-            stats[ic.second.num] = item;
+            stats[it->second.num] = parent->format_image(it->second);
        }
    }

@@ -127,6 +112,7 @@ resume_1:
            state = 100;
            return;
        }
+        // FIXME: Do not always read everything
        space_info = parent->etcd_result;
        std::map<pool_id_t, uint64_t> pool_pg_real_size;
        for (auto & kv_item: space_info["responses"][0]["response_range"]["kvs"].array_items())
@@ -160,6 +146,11 @@ resume_1:
            }
            inode_t inode_num = INODE_WITH_POOL(pool_id, only_inode_num);
            uint64_t used_size = kv.value["raw_used"].uint64_value();
+            auto stat_it = stats.find(inode_num);
+            if (parent->user && parent->user->type != user_type_t::ADMIN && stat_it == stats.end())
+            {
+                continue;
+            }
            // save stats
            auto pool_it = parent->cli->st_cli.pool_config.find(pool_id);
            if (pool_it != parent->cli->st_cli.pool_config.end())
@@ -168,7 +159,6 @@ resume_1:
                used_size = used_size / (pool_pg_real_size[pool_id] ? pool_pg_real_size[pool_id] : 1)
                    * (pool_cfg.scheme == POOL_SCHEME_REPLICATED ? 1 : pool_cfg.pg_size-pool_cfg.parity_chunks);
            }
-            auto stat_it = stats.find(inode_num);
            if (stat_it == stats.end())
            {
                stats[inode_num] = json11::Json::object {
@@ -202,20 +192,33 @@ resume_1:
    json11::Json::array to_list()
    {
        json11::Json::array list;
-        for (auto & kv: stats)
+        if (only_ids.size())
        {
-            if (!only_names.size())
+            for (auto & id: only_ids)
            {
-                list.push_back(kv.second);
-            }
-            else
-            {
-                for (auto & glob: only_names)
+                if (stats.find(id) != stats.end())
                {
-                    if (exact ? (kv.second["name"].string_value() == glob) : stupid_glob(kv.second["name"].string_value(), glob))
+                    list.push_back(stats[id]);
+                }
+            }
+        }
+        else
+        {
+            for (auto & kv: stats)
+            {
+                if (!only_names.size())
+                {
+                    list.push_back(kv.second);
+                }
+                else
+                {
+                    for (auto & glob: only_names)
                    {
-                        list.push_back(kv.second);
-                        break;
+                        if (exact ? (kv.second["name"].string_value() == glob) : stupid_glob(kv.second["name"].string_value(), glob))
+                        {
+                            list.push_back(kv.second);
+                            break;
+                        }
                    }
                }
            }
@@ -371,7 +374,7 @@ resume_1:
            }
        }
        cols.push_back(json11::Json::object{
-            { "key", "ro" },
+            { "key", "flags" },
            { "title", "FLAGS" },
            { "right", true },
        });
@@ -399,8 +402,14 @@ resume_1:
                kv.second["delete_q"] = format_q(kv.second["delete_queue"].number_value());
            }
            kv.second["size_fmt"] = format_size(kv.second["size"].uint64_value());
-            kv.second["ro"] = kv.second["deleted"].bool_value() ? "DEL" :
-                (kv.second["readonly"].bool_value() ? "RO" : "-");
+            std::string flags;
+            if (kv.second["deleted"].bool_value())
+                flags += "DEL";
+            if (kv.second["readonly"].bool_value())
+                flags += (flags.empty() ? "RO" : ",RO");
+            if (kv.second["encrypted"].bool_value())
+                flags += (flags.empty() ? "ENC" : ",ENC");
+            kv.second["flags"] = flags;
        }
        result.text = print_table(tree ? to_tree(to_list()) : to_list(), cols, parent->color);
        state = 100;
@@ -570,17 +579,30 @@ std::function<bool(cli_result_t &)> cli_tool_t::start_ls(json11::Json cfg)
    lister->parent = this;
    lister->exact = cfg["exact"].bool_value();
    lister->tree = cfg["tree"].bool_value();
-    lister->list_pool_id = cfg["pool"].uint64_value();
-    lister->list_pool_name = lister->list_pool_id ? "" : cfg["pool"].as_string();
+    if (!cfg["pool"].is_null())
+    {
+        lister->list_pool_id = cfg["pool"].uint64_value();
+        lister->list_pool_name = lister->list_pool_id ? "" : cfg["pool"].as_string();
+    }
+    else
+    {
+        lister->list_pool_id = cfg["pool_id"].uint64_value();
+        lister->list_pool_name = lister->list_pool_id ? "" : cfg["pool_name"].string_value();
+    }
    lister->show_stats = cfg["long"].bool_value();
    lister->show_delete = cfg["del"].bool_value();
    lister->sort_field = cfg["sort"].string_value() != "" ? cfg["sort"].string_value() : "name";
    lister->reverse = cfg["reverse"].bool_value();
    lister->max_count = cfg["count"].uint64_value();
+    if (cfg["names"].is_string())
+        lister->only_names.insert(cfg["names"].string_value());
    for (auto & item: cfg["names"].array_items())
-    {
        lister->only_names.insert(item.string_value());
-    }
+    if (cfg["ids"].is_string())
+        for (auto & item: explode(",", cfg["ids"].string_value(), true))
+            lister->only_ids.push_back(stoull_full(item));
+    for (auto & item: cfg["ids"].array_items())
+        lister->only_ids.push_back(item.uint64_value());
    return [lister](cli_result_t & result)
    {
        lister->loop();
@@ -374,7 +374,7 @@ struct snap_merger_t
        result = (cli_result_t){ .text = "Done, layers from "+from_name+" to "+to_name+" merged into "+target_name, .data = json11::Json::object {
            { "from", from_name },
            { "to", to_name },
-            { "into", target_name },
+            { "target", target_name },
        }};
        state = 100;
    resume_100:
@@ -17,6 +17,9 @@ struct image_changer_t
    bool force_size = false, inc_size = false;
    bool set_readonly = false, set_readwrite = false, force = false;
    bool set_deleted = false, new_deleted = false;
+    bool set_key = false;
+    std::string enc_key;
+    json11::Json new_owner, new_owner_group, new_reader_group;
    bool down_ok = false;
    // interval between fsyncs
    int fsync_interval = 128;
@@ -74,6 +77,12 @@ struct image_changer_t
            state = 100;
            return;
        }
+        if (!parent->check_image_perm(cfg, true))
+        {
+            result = (cli_result_t){ .err = EACCES, .text = "Image permission denied" };
+            state = 100;
+            return;
+        }
        for (auto & ic: parent->cli->st_cli.inode_config)
        {
            if (ic.second.parent_id == inode_num)
@@ -88,10 +97,7 @@ struct image_changer_t
            (!new_size && !force_size || cfg.size == new_size || cfg.size >= new_size && inc_size) &&
            (new_name == "" || new_name == image_name))
        {
-            result = (cli_result_t){ .err = 0, .text = "No change", .data = json11::Json::object {
-                { "error_code", 0 },
-                { "error_text", "No change" },
-            }};
+            result = (cli_result_t){ .err = 0, .text = "No change", .data = parent->format_image(cfg) };
            state = 100;
            return;
        }
@@ -152,6 +158,36 @@ resume_1:
        {
            cfg.name = new_name;
        }
+        if (new_owner.is_string())
+        {
+            cfg.owner = new_owner.string_value();
+        }
+        if (new_owner_group.is_string())
+        {
+            cfg.owner_group = new_owner_group.string_value();
+        }
+        if (new_reader_group.is_string())
+        {
+            cfg.reader_group = new_reader_group.string_value();
+        }
+        if (set_key)
+        {
+            if (!force)
+            {
+                result = (cli_result_t){ .err = EINVAL, .text = "Changing image encryption key is only allowed with --force" };
+                state = 100;
+                return;
+            }
+            if (enc_key != "" &&
+                enc_key.substr(0, strlen(VAULT_KEY_PREFIX)) != VAULT_KEY_PREFIX &&
+                (!ishexstr(enc_key) || enc_key.size() != 128))
+            {
+                result = (cli_result_t){ .err = EINVAL, .text = "Encryption key is not a 512-bit hex string and not \"\"" };
+                state = 100;
+                return;
+            }
+            cfg.enc_key = enc_key;
+        }
        {
            std::string cur_cfg_key = base64_encode(parent->cli->st_cli.etcd_prefix+
                "/config/inode/"+std::to_string(INODE_POOL(inode_num))+
@@ -235,12 +271,7 @@ resume_2:
        result = (cli_result_t){
            .err = 0,
            .text = "Image "+image_name+" modified",
-            .data = json11::Json::object {
-                { "name", image_name },
-                { "inode", INODE_NO_POOL(inode_num) },
-                { "pool", (uint64_t)INODE_POOL(inode_num) },
-                { "size", new_size },
-            }
+            .data = parent->format_image(cfg)
        };
        state = 100;
    }
@@ -261,9 +292,14 @@ std::function<bool(cli_result_t &)> cli_tool_t::start_modify(json11::Json cfg)
    changer->set_deleted = !cfg["deleted"].is_null();
    changer->new_deleted = json_is_true(cfg["deleted"]);
    changer->fsync_interval = cfg["fsync_interval"].uint64_value();
+    changer->enc_key = cfg["enc_key"].string_value();
+    changer->set_key = cfg["enc_key"].is_string();
    if (!changer->fsync_interval)
        changer->fsync_interval = 128;
    changer->down_ok = cfg["down_ok"].bool_value();
+    changer->new_owner = cfg["owner"];
+    changer->new_owner_group = cfg["owner_group"];
+    changer->new_reader_group = cfg["reader_group"];
    // FIXME Check that the image doesn't have children when shrinking
    return [changer](cli_result_t & result)
    {
@@ -0,0 +1,161 @@
+// Copyright (c) Vitaliy Filippov, 2019+
+// License: VNPL-1.1 (see README.md for details)
+
+#include "cli.h"
+#include "cluster_client.h"
+#include "str_util.h"
+
+// Create/update/delete a user
+struct cli_modify_user_t
+{
+    cli_tool_t *parent;
+
+    std::string user_name;
+    std::string user_type;
+    json11::Json groups;
+    bool del = false;
+
+    int state = 0;
+    cli_result_t result;
+    etcd_kv_t kv;
+    json11::Json::object new_cfg;
+
+    bool is_done()
+    {
+        return state == 100;
+    }
+
+    void loop()
+    {
+        if (state == 1)
+            goto resume_1;
+        else if (state == 2)
+            goto resume_2;
+        if (user_type != "client" && user_type != "admin" && user_type != "mon" && user_type != "osd")
+        {
+            result = (cli_result_t){ .err = EINVAL, .text = "Unknown user type: "+user_type };
+            state = 100;
+            return;
+        }
+        if (groups.is_string())
+        {
+            groups = groups == "" ? std::vector<std::string>() : explode(",", groups.string_value(), true);
+        }
+        else if (groups.is_array())
+        {
+            for (auto & gr: groups.array_items())
+            {
+                if (!gr.is_string())
+                {
+                    result = (cli_result_t){ .err = EINVAL, .text = "Group names must be strings" };
+                    state = 100;
+                    return;
+                }
+            }
+        }
+        else if (!groups.is_null())
+        {
+            result = (cli_result_t){ .err = EINVAL, .text = "Group names must be strings" };
+            state = 100;
+            return;
+        }
+        if (user_name == "")
+        {
+            result = (cli_result_t){ .err = EINVAL, .text = "User name must not be empty" };
+            state = 100;
+            return;
+        }
+        parent->etcd_txn(json11::Json::object {
+            { "success", json11::Json::array { json11::Json::object {
+                { "request_range", json11::Json::object {
+                    { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/user/"+user_name) },
+                } },
+            } } }
+        });
+        state = 1;
+resume_1:
+        if (parent->waiting > 0)
+            return;
+        if (parent->etcd_err.err)
+        {
+            result = parent->etcd_err;
+            state = 100;
+            return;
+        }
+        kv = parent->cli->st_cli.parse_etcd_kv(parent->etcd_result["responses"][0]["response_range"]["kvs"][0]);
+        while (true)
+        {
+            new_cfg = kv.value.object_items();
+            if (!kv.mod_revision && del)
+            {
+                result = (cli_result_t){ .err = ENOENT, .text = "User "+user_name+" does not exist" };
+                state = 100;
+                break;
+            }
+            if (!groups.is_null())
+                new_cfg["groups"] = groups;
+            if (user_type != "")
+                new_cfg["type"] = user_type;
+            if (!new_cfg["type"].is_string())
+                new_cfg["type"] = "client";
+            parent->etcd_txn(json11::Json::object {
+                { "compare", json11::Json::array { json11::Json::object {
+                    { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/user/"+user_name) },
+                    { "target", kv.mod_revision ? "MOD" : "VERSION" },
+                    { kv.mod_revision ? "mod_revision" : "version", kv.mod_revision },
+                } } },
+                { "success", json11::Json::array {
+                    del ? json11::Json::object { { "request_delete_range", json11::Json::object {
+                        { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/user/"+user_name) },
+                    } } } : json11::Json::object { { "request_put", json11::Json::object {
+                        { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/user/"+user_name) },
+                        { "value", base64_encode(json11::Json(new_cfg).dump()) }
+                    } } },
+                } },
+                { "failure", json11::Json::array { json11::Json::object {
+                    { "request_range", json11::Json::object {
+                        { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/user/"+user_name) },
+                    } },
+                } } },
+            });
+            state = 2;
+resume_2:
+            if (parent->waiting > 0)
+                return;
+            if (parent->etcd_err.err)
+            {
+                result = parent->etcd_err;
+                state = 100;
+                return;
+            }
+            if (parent->etcd_result["succeeded"].bool_value())
+                break;
+            kv = parent->cli->st_cli.parse_etcd_kv(parent->etcd_result["responses"][0]["response_range"]["kvs"][0]);
+        }
+        state = 100;
+        result.text = del ? "User "+user_name+" removed" : "User "+user_name+" modified";
+        new_cfg["name"] = user_name;
+        result.data = del ? json11::Json::object{ { "ok", true } } : new_cfg;
+    }
+};
+
+std::function<bool(cli_result_t &)> cli_tool_t::start_modify_user(json11::Json cfg)
+{
+    auto creator = new cli_modify_user_t();
+    creator->parent = this;
+    creator->user_name = cfg["name"].string_value();
+    creator->user_type = cfg["type"].string_value();
+    creator->groups = cfg["groups"];
+    creator->del = cfg["remove"].bool_value();
+    return [creator](cli_result_t & result)
+    {
+        creator->loop();
+        if (creator->is_done())
+        {
+            result = creator->result;
+            delete creator;
+            return true;
+        }
+        return false;
+    };
+}
@@ -41,7 +41,7 @@ struct osd_tree_printer_t
 {
    cli_tool_t *parent;
    json11::Json cfg;
-    bool flat = false;
+    bool as_tree = false;
    bool show_stats = false;

    int state = 0;
@@ -209,11 +209,14 @@ resume_1:
            for (int i = 1; i < node_seq.size(); i++)
            {
                auto & node = placement_tree->nodes.at(node_seq[i]);
-                fmt_items.push_back(json11::Json::object{
-                    { "type", node.level },
-                    { "name", node.name },
-                    { "parent", node.parent },
-                });
+                if (as_tree)
+                {
+                    fmt_items.push_back(json11::Json::object{
+                        { "type", node.level },
+                        { "name", node.name },
+                        { "parent", node.parent },
+                    });
+                }
                for (uint64_t osd_num: node.child_osds)
                {
                    auto & osd = placement_tree->osds.at(osd_num);
@@ -221,17 +224,22 @@ resume_1:
                        { "type", "osd" },
                        { "name", osd.num },
                        { "parent", node.name },
-                        { "up", osd.up ? "up" : "down" },
+                        { "up", osd.up },
                        { "size", osd.size },
                        { "free", osd.free },
                        { "reweight", osd.reweight },
                        { "noout", osd.noout },
                        { "tags", osd.tags },
-                        { "block", (uint64_t)osd.block_size },
-                        { "bitmap", (uint64_t)osd.bitmap_granularity },
-                        { "commit", osd.immediate_commit == IMMEDIATE_NONE ? "none" : (osd.immediate_commit == IMMEDIATE_ALL ? "all" : "small") },
-                        { "op_stats", osd_stats[osd_num]["op_stats"] },
+                        { "data_block_size", (uint64_t)osd.block_size },
+                        { "bitmap_granularity", (uint64_t)osd.bitmap_granularity },
+                        { "immediate_commit", osd.immediate_commit == IMMEDIATE_NONE ? "none" : (osd.immediate_commit == IMMEDIATE_ALL ? "all" : "small") },
                    };
+                    if (show_stats)
+                    {
+                        json_osd["op_stats"] = osd_stats[osd_num]["op_stats"];
+                        json_osd["subop_stats"] = osd_stats[osd_num]["subop_stats"];
+                        json_osd["recovery_stats"] = osd_stats[osd_num]["recovery_stats"];
+                    }
                    if (osd_stats[osd_num]["slow_ops_primary"].uint64_value() > 0)
                    {
                        json_osd["slow_ops_primary"] = osd_stats[osd_num]["slow_ops_primary"];
@@ -249,7 +257,7 @@ resume_1:
        for (int i = 1; i < node_seq.size(); i++)
        {
            auto & node = placement_tree->nodes.at(node_seq[i]);
-            if (!flat)
+            if (as_tree)
            {
                fmt_items.push_back(json11::Json::object{
                    { "type", str_repeat("  ", indents[i]) + node.level },
@@ -257,7 +265,7 @@ resume_1:
                });
            }
            std::string parent = node.name;
-            if (flat)
+            if (!as_tree)
            {
                auto cur = &placement_tree->nodes.at(node.name);
                while (cur->parent != "" && cur->parent != node.name)
@@ -270,7 +278,7 @@ resume_1:
            {
                auto & osd = placement_tree->osds.at(osd_num);
                auto fmt = json11::Json::object{
-                    { "type", (flat ? "osd" : str_repeat("  ", indents[i]+1) + "osd") },
+                    { "type", (!as_tree ? "osd" : str_repeat("  ", indents[i]+1) + "osd") },
                    { "name", osd.num },
                    { "parent", parent },
                    { "up", osd.up ? "up" : "down" },
@@ -300,7 +308,7 @@ resume_1:
            }
        }
        json11::Json::array cols;
-        if (!flat)
+        if (as_tree)
        {
            cols.push_back(json11::Json::object{
                { "key", "type" },
@@ -309,9 +317,9 @@ resume_1:
        }
        cols.push_back(json11::Json::object{
            { "key", "name" },
-            { "title", flat ? "OSD" : "NAME" },
+            { "title", !as_tree ? "OSD" : "NAME" },
        });
-        if (flat)
+        if (!as_tree)
        {
            cols.push_back(json11::Json::object{
                { "key", "parent" },
@@ -414,7 +422,7 @@ std::function<bool(cli_result_t &)> cli_tool_t::start_osd_tree(json11::Json cfg)
    auto osd_tree_printer = new osd_tree_printer_t();
    osd_tree_printer->parent = this;
    osd_tree_printer->cfg = cfg;
-    osd_tree_printer->flat = cfg["flat"].bool_value();
+    osd_tree_printer->as_tree = cfg["as_tree"].bool_value();
    osd_tree_printer->show_stats = cfg["long"].bool_value();
    return [osd_tree_printer](cli_result_t & result)
    {
@@ -282,10 +282,16 @@ std::function<bool(cli_result_t &)> cli_tool_t::start_pg_list(json11::Json cfg)
 {
    auto pg_lister = new pg_lister_t();
    pg_lister->parent = this;
-    if (cfg["pool"].uint64_value())
+    if (!cfg["pool"].is_null())
+    {
        pg_lister->pool_id = cfg["pool"].uint64_value();
+        pg_lister->pool_name = pg_lister->pool_id ? "" : cfg["pool"].string_value();
+    }
    else
-        pg_lister->pool_name = cfg["pool"].string_value();
+    {
+        pg_lister->pool_id = cfg["pool_id"].uint64_value();
+        pg_lister->pool_name = pg_lister->pool_id ? "" : cfg["pool_name"].string_value();
+    }
    for (auto & st: cfg["pg_state"].array_items())
        pg_lister->pg_state.push_back(st.string_value());
    if (cfg["pg_state"].is_string())
@@ -91,7 +91,7 @@ std::string validate_pool_config(json11::Json::object & new_cfg, json11::Json ol
        }
        else if (key == "name" || key == "scheme" || key == "immediate_commit" ||
            key == "failure_domain" || key == "root_node" || key == "scrub_interval" || key == "used_for_app" ||
-            key == "used_for_fs" || key == "raw_placement" || key == "local_reads")
+            key == "used_for_fs" || key == "raw_placement" || key == "local_reads" || key == "creator_group")
        {
            if (!value.is_string())
            {
@@ -213,7 +213,7 @@ resume_3:
                    if (failure_domain != "osd")
                        pool_err += "\n- different parent '"+failure_domain+"' nodes";
                    result = (cli_result_t){
-                        .err = EINVAL,
+                        .err = EBUSY,
                        .text = pool_err,
                    };
                    state = 100;
@@ -206,7 +206,7 @@ resume_1:
                { "space_efficiency", pool_stats[pool_cfg.id]["space_efficiency"].number_value() },
                { "pg_real_size", pool_stats[pool_cfg.id]["pg_real_size"].uint64_value() },
                { "osd_count", (uint64_t)pg_per_osd.size() },
-                { "backfillfull", pool_cfg.backfillfull },
+                { "backfillfull", !!pool_cfg.backfillfull },
            };
        }
        // Include full pool config
@@ -546,6 +546,10 @@ resume_3:
                { "write_fmt", "Write" },
                { "delete_fmt", "Delete" },
            };
+            if (sort_field == "osd_tags" || sort_field == "primary_affinity_tags")
+            {
+                sort_field += "_fmt";
+            }
            auto list = to_list();
            size_t title_len = 0;
            for (auto & item: list)
@@ -666,15 +670,12 @@ std::function<bool(cli_result_t &)> cli_tool_t::start_pool_ls(json11::Json cfg)
    lister->show_stats = cfg["long"].bool_value();
    lister->detailed = cfg["detail"].bool_value();
    lister->sort_field = cfg["sort"].string_value();
-    if ((lister->sort_field == "osd_tags") ||
-        (lister->sort_field == "primary_affinity_tags" ))
-        lister->sort_field = lister->sort_field + "_fmt";
    lister->reverse = cfg["reverse"].bool_value();
    lister->max_count = cfg["count"].uint64_value();
+    if (cfg["names"].is_string())
+        lister->only_names.insert(cfg["names"].string_value());
    for (auto & item: cfg["names"].array_items())
-    {
        lister->only_names.insert(item.string_value());
-    }
    return [lister](cli_result_t & result)
    {
        lister->loop();
@@ -39,16 +39,21 @@ struct pool_changer_t
            goto resume_1;
        else if (state == 2)
            goto resume_2;
-        pool_id = stoull_full(cfg["old_name"].string_value());
-        if (!pool_id)
+        if (!cfg["pool"].is_null())
        {
-            pool_name = cfg["old_name"].string_value();
-            if (pool_name == "")
-            {
-                result = (cli_result_t){ .err = ENOENT, .text = "Pool ID or name is required to modify it" };
-                state = 100;
-                return;
-            }
+            pool_id = cfg["pool"].uint64_value();
+            pool_name = pool_id ? "" : cfg["pool"].string_value();
+        }
+        else
+        {
+            pool_id = cfg["id"].uint64_value();
+            pool_name = pool_id ? "" : cfg["old_name"].string_value();
+        }
+        if (!pool_id && pool_name == "")
+        {
+            result = (cli_result_t){ .err = ENOENT, .text = "Pool ID or name is required to modify it" };
+            state = 100;
+            return;
        }
 resume_0:
        // Get pools from etcd
@@ -179,7 +184,7 @@ resume_2:
        result = (cli_result_t){
            .err = 0,
            .text = "Pool "+pool_name+" updated",
-            .data = new_pools,
+            .data = new_pools[std::to_string(pool_id)],
        };
        state = 100;
    }
@@ -196,7 +196,9 @@ resume_3:
        result = (cli_result_t){
            .err = 0,
            .text = "Pool "+pool_name+" deleted",
-            .data = new_pools
+            .data = json11::Json::object{
+                {"ok", true},
+            },
        };
        state = 100;
    }
@@ -207,8 +209,16 @@ std::function<bool(cli_result_t &)> cli_tool_t::start_pool_rm(json11::Json cfg)
    auto pool_remover = new pool_remover_t();
    pool_remover->parent = this;

-    pool_remover->pool_id = cfg["pool"].uint64_value();
-    pool_remover->pool_name = pool_remover->pool_id ? "" : cfg["pool"].as_string();
+    if (!cfg["pool"].is_null())
+    {
+        pool_remover->pool_id = cfg["pool"].uint64_value();
+        pool_remover->pool_name = pool_remover->pool_id ? "" : cfg["pool"].as_string();
+    }
+    else
+    {
+        pool_remover->pool_id = cfg["pool_id"].uint64_value();
+        pool_remover->pool_name = pool_remover->pool_id ? "" : cfg["pool_name"].as_string();
+    }

    pool_remover->force = !cfg["force"].is_null();

@@ -269,10 +269,17 @@ resume_100:
            {
                char buf[1024];
                snprintf(buf, 1024, "Parent inode of layer %s (id 0x%jx) not found", cur->name.c_str(), cur->parent_id);
+                result = (cli_result_t){ .err = ENOENT, .text = buf };
                state = 100;
                return;
            }
            cur = &it->second;
+            if (!parent->check_image_perm(*cur, true))
+            {
+                result = (cli_result_t){ .err = EACCES, .text = "Image permission denied" };
+                state = 100;
+                return;
+            }
            chain_list.push_back(cur->num);
        }
        if (cur->num != from_cfg->num)
@@ -297,6 +304,12 @@ resume_100:
            auto it = sources.find(ic.second.parent_id);
            if (it != sources.end() && sources.find(ic.second.num) == sources.end())
            {
+                if (!parent->check_image_perm(ic.second, true))
+                {
+                    result = (cli_result_t){ .err = EACCES, .text = "Image permission denied" };
+                    state = 100;
+                    return;
+                }
                merge_children.push_back(ic.second.num);
                if (ic.second.readonly || writers_stopped)
                {
@@ -451,6 +464,7 @@ resume_100:
        inode_config_t new_cfg = *child_cfg;
        new_cfg.deleted = false;
        new_cfg.num = target_cfg->num;
+        new_cfg.enc_key = target_cfg->enc_key;
        new_cfg.parent_id = new_parent;
        json11::Json::array cmp = json11::Json::array {
            json11::Json::object {
@@ -264,7 +264,7 @@ struct rm_inode_t
            {
                // Error
                result = (cli_result_t){
-                    .err = EIO,
+                    .err = EBUSY,
                    .text = "Failed: some blocks were not removed",
                    .data = data,
                };
@@ -181,6 +181,7 @@ struct rm_osd_t
            if (dry_run || is_dataloss && !force_dataloss || is_warning && !force_warning)
            {
                result.err = is_dataloss && !force_dataloss || is_warning && !force_warning ? EBUSY : 0;
+                result.data = json11::Json::object{ { "pool_effects", pool_effects } };
                state = 100;
                return;
            }
@@ -332,6 +333,9 @@ struct rm_osd_t
        ids = (osd_ids.size() > 1 ? "OSDs " : "OSD ")+ids+(osd_ids.size() > 1 ? " are" : " is")+" removed from etcd";
        state = 100;
        result.text = (result.text != "" ? ids+"\n"+result.text : ids);
+        result.data = json11::Json::object {
+            {"deleted_osds", osd_ids},
+        };
        result.err = 0;
    }

@@ -195,6 +195,8 @@ std::function<bool(cli_result_t &)> cli_tool_t::start_rm_wildcard(json11::Json c
    auto wildcard_remover = new wildcard_remover_t();
    wildcard_remover->parent = this;
    wildcard_remover->cfg = cfg;
+    if (cfg["globs"].is_string())
+        wildcard_remover->globs.push_back(cfg["globs"].string_value());
    for (auto & glob: cfg["globs"].array_items())
        wildcard_remover->globs.push_back(glob.string_value());
    wildcard_remover->exact = cfg["exact"].bool_value();
@@ -0,0 +1,499 @@
+// Copyright (c) Vitaliy Filippov, 2019+
+// License: VNPL-1.1 (see README.md for details)
+
+#include <signal.h>
+#include <sys/socket.h>
+#include <netinet/tcp.h>
+#include <stdexcept>
+#include "cli.h"
+#include "cluster_client.h"
+#include "epoll_manager.h"
+#include "http_client.h"
+#include "str_util.h"
+#include "json_util.h"
+#include "addr_util.h"
+#include "openapi.json.h"
+
+struct cli_serve_conn_t
+{
+    int peer_fd = 0;
+    std::string peer_addr;
+    http_co_t *co = NULL;
+    cli_tool_t *p = NULL;
+    cli_result_t result;
+    bool keepalive = false;
+    bool closed = false;
+    timespec request_time;
+    std::string request_method;
+    std::string request_path;
+    std::string request_body;
+    std::string response_type;
+    std::function<bool(cli_result_t &)> action_cb;
+};
+
+struct cli_serve_path_t
+{
+    std::string cmd;
+    bool allow_get;
+    bool allow_client;
+};
+
+// Serve vitastor-cli commands over HTTP in JSON format
+struct cli_serve_t
+{
+    std::map<std::string, cli_serve_path_t> cmd_paths = {
+        {"data/delete",   {"rm-data",     false, false}},
+        {"data/describe", {"describe",    true,  false}},
+        {"data/fix",      {"fix",         false, false}},
+        {"data/merge",    {"merge-data",  false, false}},
+        {"image/create",  {"create",      false, true}},
+        {"image/delete",  {"rm",          false, true}},
+        {"image/flatten", {"flatten",     false, true}},
+        {"image/list",    {"ls",          true,  true}},
+        {"image/modify",  {"modify",      false, true}},
+        {"osd/alloc",     {"alloc-osd",   false, false}},
+        {"osd/delete",    {"rm-osd",      false, false}},
+        {"osd/list",      {"ls-osd",      true,  false}},
+        {"osd/modify",    {"modify-osd",  false, false}},
+        {"pg/list",       {"ls-pgs",      true,  false}},
+        {"pool/create",   {"create-pool", false, false}},
+        {"pool/delete",   {"rm-pool",     false, false}},
+        {"pool/list",     {"pools",       true,  false}},
+        {"pool/modify",   {"modify-pool", false, false}},
+        {"user/delete",   {"remove-user", false, false}},
+        {"user/list",     {"ls-user",     false, false}},
+        {"user/modify",   {"modify-user", false, false}},
+        {"status",        {"status",      true,  false}},
+    };
+
+    cli_tool_t *parent = NULL;
+    json11::Json options;
+    cli_result_t result;
+
+    bool log_body = false;
+    bool stop = false;
+    std::vector<std::string> bind_addresses;
+    int port = 0;
+    int listen_backlog = 0;
+    bool ssl = false;
+    bool use_auth = false;
+    std::vector<int> listen_fds;
+    http_context_t *http_ctx = NULL;
+    std::set<cli_serve_conn_t*> connections;
+
+    int state = 0;
+
+    bool is_done()
+    {
+        return state == 100;
+    }
+
+    void loop()
+    {
+        if (state == 1)
+            goto resume_1;
+        else if (state == 2)
+            goto resume_2;
+        else if (state == 100)
+            return;
+        if (options["bind_address"].is_string())
+            bind_addresses = explode(" ", options["bind_address"].string_value(), true);
+        else
+            bind_addresses.push_back("127.0.0.1");
+        port = options["port"].uint64_value();
+        if (!port)
+            port = 8080;
+        else if (port < 0 || port > 65535)
+        {
+            result = (cli_result_t){ .err = EINVAL, .text = "HTTP port can't be larger than 65536" };
+            state = 100;
+            return;
+        }
+        listen_backlog = options["listen_backlog"].uint64_value();
+        if (!listen_backlog)
+            listen_backlog = 128;
+        {
+            std::string tls_cert = (parent->cli->config.find("server_cert") != parent->cli->config.end()
+                ? parent->cli->config["server_cert"].string_value() : "");
+            std::string tls_key = (parent->cli->config.find("server_key") != parent->cli->config.end()
+                ? parent->cli->config["server_key"].string_value() : "");
+            std::string tls_ca = (parent->cli->config.find("client_ca") != parent->cli->config.end()
+                ? parent->cli->config["client_ca"].string_value() : "");
+            if (tls_cert != "" || tls_key != "" || tls_ca != "")
+            {
+                ssl = true;
+                if (tls_cert == "" || tls_key == "")
+                {
+                    result = (cli_result_t){ .err = EINVAL, .text = "server_cert and server_key are required to serve HTTPS" };
+                    state = 100;
+                    return;
+                }
+                // use_auth is enabled by default when client_ca is set
+                use_auth = (parent->cli->config["use_auth"].is_null()
+                    ? (tls_ca != "")
+                    : json_is_true(parent->cli->config["use_auth"]));
+                std::string error;
+                http_ctx = http_context_init(parent->epmgr->tfd, tls_cert, tls_key, tls_ca, tls_ca != "", error);
+                if (error != "")
+                {
+                    result = (cli_result_t){ .err = EINVAL, .text = error };
+                    state = 100;
+                    return;
+                }
+            }
+        }
+        for (auto & bind_address: bind_addresses)
+        {
+            int listen_fd = create_and_bind_socket(bind_address, port, listen_backlog, NULL);
+            fcntl(listen_fd, F_SETFL, fcntl(listen_fd, F_GETFL, 0) | O_NONBLOCK);
+            parent->epmgr->set_fd_handler(listen_fd, false, [this](int fd, int events)
+            {
+                accept_connections(fd);
+            });
+            listen_fds.push_back(listen_fd);
+        }
+    resume_1:
+        if (!stop)
+        {
+            state = 1;
+            return;
+        }
+        for (auto conn: connections)
+        {
+            http_close(conn->co);
+        }
+    resume_2:
+        // Wait for all connections to finish
+        if (connections.size() > 0)
+        {
+            state = 2;
+            return;
+        }
+        if (http_ctx)
+        {
+            http_context_destroy(http_ctx);
+            http_ctx = NULL;
+        }
+        state = 100;
+    }
+
+    void accept_connections(int listen_fd)
+    {
+        sockaddr_storage addr;
+        socklen_t peer_addr_size = sizeof(addr);
+        int peer_fd;
+        while ((peer_fd = accept(listen_fd, (sockaddr*)&addr, &peer_addr_size)) >= 0)
+        {
+            auto peer_addr_str = addr_to_string(addr);
+            assert(peer_fd != 0);
+            timespec ts;
+            clock_gettime(CLOCK_REALTIME, &ts);
+            printf("[%s.%03ju] New connection %d from %s\n", format_datetime(ts.tv_sec).c_str(), (uint64_t)ts.tv_nsec/1000000,
+                peer_fd, peer_addr_str.c_str());
+            fcntl(peer_fd, F_SETFL, fcntl(peer_fd, F_GETFL, 0) | O_NONBLOCK);
+            int one = 1;
+            setsockopt(peer_fd, SOL_TCP, TCP_NODELAY, &one, sizeof(one));
+            cli_serve_conn_t *conn = new cli_serve_conn_t;
+            conn->peer_fd = peer_fd;
+            conn->peer_addr = peer_addr_str;
+            conn->co = http_init(http_ctx);
+            http_serve(conn->co, peer_fd, (http_options_t){ .ssl = ssl }, [this, conn](http_message_t *msg)
+            {
+                process_request(conn, msg);
+            });
+            connections.insert(conn);
+            // Try to accept next connection
+            peer_addr_size = sizeof(addr);
+        }
+        if (peer_fd == -1 && errno != EAGAIN)
+        {
+            throw std::runtime_error(std::string("accept: ") + strerror(errno));
+        }
+    }
+
+    int map_to_http(int err, std::string *text)
+    {
+        int code = 0;
+        if (err == EINVAL)
+        {
+            code = 400;
+            if (text)
+                *text = "Bad Request";
+        }
+        else if (err == EACCES)
+        {
+            code = 403;
+            if (text)
+                *text = "Forbidden";
+        }
+        else if (err == EOPNOTSUPP)
+        {
+            code = 404;
+            if (text)
+                *text = "Not Found";
+        }
+        else if (err == ENOSYS)
+        {
+            code = 405;
+            if (text)
+                *text = "Method Not Allowed";
+        }
+        else if (err == EAGAIN)
+        {
+            code = 409;
+            if (text)
+                *text = "Update Conflict";
+        }
+        else if (err == ENOTEMPTY || err == EEXIST || err == ENOENT || err == EBUSY)
+        {
+            code = 412;
+            if (text)
+                *text = "Precondition Failed";
+        }
+        else /*if (err == EIO || err == EBADF)*/
+        {
+            code = 500;
+            if (text)
+                *text = "Internal Server Error";
+        }
+        return code;
+    }
+
+    std::string cli_http_response(cli_serve_conn_t *conn)
+    {
+        timespec now;
+        clock_gettime(CLOCK_REALTIME, &now);
+        int code = 200;
+        std::string response;
+        if (conn->result.err)
+        {
+            std::string status_line;
+            code = map_to_http(conn->result.err, &status_line);
+            response = "HTTP/1.1 "+std::to_string(code)+" "+status_line+"\r\n";
+        }
+        else
+        {
+            response = "HTTP/1.1 200 OK\r\n";
+        }
+        response += (conn->keepalive
+            ? "Connection: keep-alive\r\n"
+            : "Connection: close\r\n");
+        std::string body;
+        if (!conn->result.data.is_null())
+        {
+            response += "Content-Type: application/json\r\n";
+            body = conn->result.data.dump();
+        }
+        else
+        {
+            if (!conn->response_type.empty())
+                response += "Content-Type: "+conn->response_type+"\r\n";
+            else
+                response += "Content-Type: text/plain; charset=utf-8\r\n";
+            body = conn->result.text;
+        }
+        response += "Content-Length: "+std::to_string(body.size())+"\r\n\r\n";
+        response += body;
+        if (conn->request_method.find("\n") != std::string::npos)
+            conn->request_method = str_replace(conn->request_method, "\n", "%0a");
+        if (conn->request_method.find(" ") != std::string::npos)
+            conn->request_method = str_replace(conn->request_method, " ", "%20");
+        if (conn->request_path.find("\n") != std::string::npos)
+            conn->request_path = str_replace(conn->request_path, "\n", "%0a");
+        if (conn->request_path.find(" ") != std::string::npos)
+            conn->request_path = str_replace(conn->request_path, " ", "%20");
+        uint64_t response_time = (now.tv_sec-conn->request_time.tv_sec)*1000 + (now.tv_nsec-conn->request_time.tv_nsec)/1000000;
+        printf("[%s.%03ju] %s %s %s %d %.03f sec\n",
+            format_datetime(now.tv_sec).c_str(), (uint64_t)now.tv_nsec/1000000,
+            conn->peer_addr.c_str(), conn->request_method.c_str(), conn->request_path.c_str(), code,
+            response_time/1000.0);
+        if (log_body)
+        {
+            if (conn->request_body.find("\n") != std::string::npos)
+                conn->request_body = str_replace(conn->request_body, "\n", " ");
+            if (conn->request_body.size())
+                printf("  %s\n", conn->request_body.c_str());
+            printf("  %s\n", body.c_str());
+        }
+        return response;
+    }
+
+    void process_request(cli_serve_conn_t *conn, http_message_t *msg)
+    {
+        timespec ts;
+        clock_gettime(CLOCK_REALTIME, &ts);
+        if (!msg->error.empty())
+        {
+            // connection is closed
+            fprintf(stderr, "[%s.%03ju] Connection %d closed: %s\n", format_datetime(ts.tv_sec).c_str(),
+                (uint64_t)ts.tv_nsec/1000000, conn->peer_fd, msg->error.c_str());
+            if (conn->p)
+                conn->closed = true;
+            else
+            {
+                connections.erase(conn);
+                http_destroy(conn->co);
+                delete conn;
+            }
+            return;
+        }
+        conn->keepalive = msg->headers.find("connection") != msg->headers.end() &&
+            msg->headers.at("connection") == "keep-alive";
+        conn->p = new cli_tool_t;
+        conn->p->iodepth = parent->iodepth;
+        conn->p->parallel_osds = parent->parallel_osds;
+        conn->p->json_output = true;
+        conn->p->ringloop = parent->ringloop;
+        conn->p->epmgr = parent->epmgr;
+        conn->p->cli = parent->cli;
+        conn->p->is_command_line = false;
+        // Parse request
+        auto req_line = explode(" ", msg->status_line, true);
+        if (req_line.size() < 2)
+        {
+            if (req_line[0] == "")
+                req_line[0] = "-";
+            req_line.push_back("-");
+        }
+        conn->request_time = ts;
+        conn->request_method = std::move(req_line[0]);
+        conn->request_path = std::move(req_line[1]);
+        conn->request_body = std::move(msg->body);
+        conn->response_type = "";
+        if (use_auth)
+        {
+            conn->p->user = parent->cli->st_cli.get_user(msg->headers["_tls_common_name"]);
+        }
+        auto ctype = msg->headers["content-type"];
+        if (conn->request_method != "GET" && conn->request_method != "POST")
+        {
+            conn->result = { .err = ENOSYS, .text = "Unsupported request method "+conn->request_method };
+        }
+        else if (ctype != (conn->request_method == "GET" ? "" : "application/json"))
+        {
+            conn->result = { .err = EINVAL, .text = "Unsupported Content-Type: "+ctype+" for "+conn->request_method+" requests" };
+        }
+        else
+        {
+            auto uri = explode("?", conn->request_path, true);
+            uri[0] = trim(uri[0], "/");
+            auto cmd_it = cmd_paths.find(uri[0]);
+            if (uri[0] == "")
+            {
+                std::string text = "Supported APIs:\n\n- GET /openapi\n";
+                for (auto & pp: cmd_paths)
+                {
+                    text += (pp.second.allow_get ? "- GET" : "- POST") + (" /" + pp.first) + "\n";
+                }
+                conn->result = { .text = text };
+            }
+            else if (uri[0] == "openapi")
+            {
+                conn->response_type = "application/json";
+                conn->result = { .text = openapi_description };
+                if (use_auth)
+                {
+                    // Filter available paths by privileges
+                    if (conn->p->user->type == user_type_t::CLIENT)
+                    {
+                        std::string error;
+                        auto openapi = json11::Json::parse(openapi_description, error).object_items();
+                        json11::Json::object paths;
+                        for (auto & kv: openapi["paths"].object_items())
+                        {
+                            auto cmd_it = cmd_paths.find(kv.first.substr(1));
+                            if (cmd_it != cmd_paths.end() && cmd_it->second.allow_client)
+                            {
+                                paths[kv.first] = kv.second;
+                            }
+                        }
+                        openapi["paths"] = paths;
+                        conn->response_type = "application/json";
+                        conn->result = { .text = json11::Json(openapi).dump() };
+                    }
+                    else if (conn->p->user->type != user_type_t::ADMIN)
+                    {
+                        conn->response_type = "";
+                        conn->result = { .err = EACCES, .text = "Access denied" };
+                    }
+                }
+            }
+            else if (cmd_it == cmd_paths.end())
+            {
+                conn->result = { .err = EOPNOTSUPP, .text = "unknown command: "+uri[0] };
+            }
+            else if (conn->request_method == "GET" && !cmd_it->second.allow_get)
+            {
+                conn->result = { .err = ENOSYS, .text = "method /"+uri[0]+" only allows POST requests" };
+            }
+            else if (use_auth && conn->p->user->type == user_type_t::CLIENT && !cmd_it->second.allow_client)
+            {
+                conn->result = { .err = EACCES, .text = "Access denied" };
+            }
+            else
+            {
+                std::string error;
+                json11::Json::object cfg;
+                if (conn->request_method == "POST")
+                {
+                    cfg = json11::Json::parse(conn->request_body, error).object_items();
+                }
+                else
+                {
+                    // Parse URI
+                    cfg = parse_uri_params(uri[1]);
+                }
+                if (error != "")
+                {
+                    conn->result = { .err = EINVAL, .text = "Invalid JSON in body: "+error };
+                }
+                else
+                {
+                    cfg["command"] = json11::Json::array{cmd_it->second.cmd};
+                    conn->p->parse_api_opts(cfg);
+                    conn->action_cb = conn->p->start(cfg, conn->result);
+                }
+            }
+        }
+        if (!conn->action_cb)
+        {
+            http_reply(conn->co, cli_http_response(conn));
+            delete conn->p;
+            conn->p = NULL;
+            return;
+        }
+        conn->p->loop_and_wait(conn->action_cb, [this, conn](const cli_result_t & r)
+        {
+            conn->result = r;
+            conn->action_cb = NULL;
+            delete conn->p;
+            conn->p = NULL;
+            if (!conn->closed)
+                http_reply(conn->co, cli_http_response(conn));
+            else
+            {
+                connections.erase(conn);
+                http_destroy(conn->co);
+                delete conn;
+            }
+        });
+    }
+};
+
+std::function<bool(cli_result_t &)> cli_tool_t::start_serve(json11::Json cfg)
+{
+    auto server = new cli_serve_t();
+    server->parent = this;
+    server->options = cfg;
+    return [server](cli_result_t & result)
+    {
+        server->loop();
+        if (server->is_done())
+        {
+            result = server->result;
+            delete server;
+            return true;
+        }
+        return false;
+    };
+}
@@ -18,6 +18,7 @@ struct status_printer_t
 {
    cli_tool_t *parent;

+    cli_result_t result;
    int state = 0;
    json11::Json::array mon_members;
    json11::Json agg_stats;
@@ -89,7 +90,7 @@ resume_2:
            return;
        if (parent->etcd_err.err)
        {
-            fprintf(stderr, "%s\n", parent->etcd_err.text.c_str());
+            result = parent->etcd_err;
            state = 100;
            return;
        }
@@ -107,7 +108,8 @@ resume_2:
            if (etcd_states[i]["error"].is_null())
            {
                etcd_alive++;
-                etcd_db_size = etcd_states[i]["dbSize"].uint64_value();
+                uint64_t db_size = etcd_states[i]["dbSize"].uint64_value();
+                etcd_db_size = db_size > etcd_db_size ? db_size : etcd_db_size;
            }
        }
        int mon_count = 0;
@@ -265,7 +267,7 @@ resume_2:
                    obj_n = agg_stats["object_counts"][str].uint64_value() * parent->cli->st_cli.global_block_size;
                json_status[str+"_data"] = obj_n;
            }
-            printf("%s\n", json11::Json(json_status).dump().c_str());
+            result.data = json11::Json(json_status);
            state = 100;
            return;
        }
@@ -406,7 +408,7 @@ std::function<bool(cli_result_t &)> cli_tool_t::start_status(json11::Json cfg)
        printer->loop();
        if (printer->is_done())
        {
-            result = { .err = 0 };
+            result = printer->result;
            delete printer;
            return true;
        }
@@ -0,0 +1,128 @@
+// Copyright (c) Vitaliy Filippov, 2019+
+// License: VNPL-1.1 (see README.md for details)
+
+#include <algorithm>
+#include "cli.h"
+#include "cluster_client.h"
+#include "str_util.h"
+#include "json_util.h"
+
+// List users
+struct user_lister_t
+{
+    cli_tool_t *parent;
+    std::vector<std::string> only_names;
+
+    int state = 0;
+    cli_result_t result;
+    json11::Json::array users;
+
+    bool is_done()
+    {
+        return state == 100;
+    }
+
+    void loop()
+    {
+        if (state == 1)
+            goto resume_1;
+        if (state == 100)
+            return;
+        {
+            json11::Json::array select;
+            if (!only_names.size())
+            {
+                select.push_back(json11::Json::object {
+                    { "request_range", json11::Json::object {
+                        { "key", base64_encode(
+                            parent->cli->st_cli.etcd_prefix+"/config/user/"
+                        ) },
+                        { "range_end", base64_encode(
+                            parent->cli->st_cli.etcd_prefix+"/config/user0"
+                        ) },
+                    } },
+                });
+            }
+            else
+            {
+                for (auto & name: only_names)
+                {
+                    select.push_back(json11::Json::object {
+                        { "request_range", json11::Json::object {
+                            { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/user/"+name) },
+                        } }
+                    });
+                }
+            }
+            parent->etcd_txn(json11::Json::object {
+                { "success", select },
+            });
+        }
+        state = 1;
+resume_1:
+        if (parent->waiting > 0)
+            return;
+        if (parent->etcd_err.err)
+        {
+            result = parent->etcd_err;
+            state = 100;
+            return;
+        }
+        for (auto & response: parent->etcd_result["responses"].array_items())
+        {
+            for (auto & kv_item: response["response_range"]["kvs"].array_items())
+            {
+                auto kv = parent->cli->st_cli.parse_etcd_kv(kv_item);
+                auto user = kv.value.object_items();
+                user["name"] = kv.key.substr(parent->cli->st_cli.etcd_prefix.size()+13);
+                if (!parent->json_output)
+                    user["groups_fmt"] = implode(",", user["groups"].array_items());
+                users.push_back(std::move(user));
+            }
+        }
+        if (parent->json_output)
+        {
+            // JSON output
+            result.data = users;
+            state = 100;
+            return;
+        }
+        // Table output: name, type, groups
+        json11::Json::array cols;
+        cols.push_back(json11::Json::object{
+            { "key", "name" },
+            { "title", "NAME" },
+        });
+        cols.push_back(json11::Json::object{
+            { "key", "type" },
+            { "title", "TYPE" },
+        });
+        cols.push_back(json11::Json::object{
+            { "key", "groups_fmt" },
+            { "title", "GROUPS" },
+        });
+        result.text = print_table(users, cols, parent->color);
+        state = 100;
+    }
+};
+
+std::function<bool(cli_result_t &)> cli_tool_t::start_user_ls(json11::Json cfg)
+{
+    auto lister = new user_lister_t();
+    lister->parent = this;
+    if (cfg["names"].is_string())
+        lister->only_names.push_back(cfg["names"].string_value());
+    for (auto & item: cfg["names"].array_items())
+        lister->only_names.push_back(item.string_value());
+    return [lister](cli_result_t & result)
+    {
+        lister->loop();
+        if (lister->is_done())
+        {
+            result = lister->result;
+            delete lister;
+            return true;
+        }
+        return false;
+    };
+}
@@ -7,7 +7,7 @@ add_executable(vitastor-disk
 	disk_tool.cpp disk_simple_offsets.cpp
 	disk_tool_discard.cpp disk_tool_journal.cpp disk_tool_meta.cpp disk_tool_prepare.cpp disk_tool_resize.cpp
 	disk_tool_resize_auto.cpp disk_tool_udev.cpp disk_tool_utils.cpp disk_tool_upgrade.cpp
-	../util/crc32c.c ../util/str_util.cpp ../util/json_util.cpp ../../json11/json11.cpp ../util/rw_blocking.cpp ../util/allocator.cpp ../util/ringloop.cpp
+	../util/crc32c.c ../util/xxh_x86dispatch.c ../util/str_util.cpp ../util/json_util.cpp ../../json11/json11.cpp ../util/rw_blocking.cpp ../util/allocator.cpp ../util/ringloop.cpp
 	../blockstore/blockstore_disk.cpp ../blockstore/blockstore_heap.cpp ../blockstore/multilist.cpp
 )
 target_link_libraries(vitastor-disk
@@ -136,8 +136,8 @@ struct disk_tool_t
    void choose_journal_block(uint32_t je_size);
    int resize_rebuild_journal();
    int resize_write_new_journal();
-    void remap_big_write(heap_entry_t *wr);
-    void remap_small_write(heap_entry_t *wr);
+    void remap_big_write(blockstore_heap_t *heap, heap_entry_t *wr);
+    void remap_small_write(blockstore_heap_t *heap, heap_entry_t *wr);
    void fill_old_clean_entry(blockstore_heap_t *heap, heap_entry_t *big_wr);
    void fill_old_journal_entry(blockstore_heap_t *heap, heap_entry_t *wr);
    int resize_rebuild_meta();
@@ -175,7 +175,6 @@ struct disk_tool_t
 void disk_tool_simple_offsets(json11::Json cfg, bool json_output);

 uint64_t sscanf_json(const char *fmt, const json11::Json & str);
-void fromhexstr(const std::string & from, int bytes, uint8_t *to);
 int disable_cache(const std::string & dev);
 uint64_t get_atomic_write_size(const std::string & dev);
 uint64_t get_device_size(const std::string & dev, bool should_exist = false);
@@ -4,6 +4,7 @@
 #include <unistd.h>

 #include "disk_tool.h"
+#include "str_util.h"
 #include "malloc_or_die.h"

 int disk_tool_t::dump_journal()
@@ -4,6 +4,7 @@
 #include "disk_tool.h"
 #include "rw_blocking.h"
 #include "json_util.h"
+#include "str_util.h"
 #include "malloc_or_die.h"

 int disk_tool_t::process_meta(std::function<void(blockstore_meta_header_v3_t *)> hdr_fn,
@@ -751,7 +752,7 @@ close_err0:
                {
                    *wr->get_checksum(&heap) = sscanf_json("%jx", write_entry["data_crc32c"]);
                }
-                wr->crc32c = wr->calc_crc32c();
+                wr->checksum = wr->calc_checksum(&heap);
                assert((uint8_t*)wr + wr->size == new_meta_buf + meta_offset + used_space);
            }
        }
@@ -794,7 +795,7 @@ close_err:
            fromhexstr(meta_entry["ext_bitmap"].string_value(), new_clean_entry_bitmap_size, wr->get_ext_bitmap(&heap));
            if (new_meta_hdr->data_csum_type != 0)
                fromhexstr(meta_entry["data_csum"].string_value(), new_data_csum_size, wr->get_checksums(&heap));
-            wr->crc32c = wr->calc_crc32c();
+            wr->checksum = wr->calc_checksum(&heap);
            assert((uint8_t*)wr + wr->size == new_meta_buf + meta_offset + used_space);
            auto j_it = journal_by_object.find(oid);
            if (j_it != journal_by_object.end())
@@ -860,7 +861,7 @@ close_err:
                        assert(0);
                    }
                    wr->size = wr->get_size(&heap);
-                    wr->crc32c = wr->calc_crc32c();
+                    wr->checksum = wr->calc_checksum(&heap);
                    assert((uint8_t*)wr + wr->size == new_meta_buf + meta_offset + used_space);
                }
            }
@@ -531,7 +531,7 @@ int disk_tool_t::resize_write_new_journal()
    return 0;
 }

-void disk_tool_t::remap_big_write(heap_entry_t *wr)
+void disk_tool_t::remap_big_write(blockstore_heap_t *heap, heap_entry_t *wr)
 {
    uint64_t block_num = wr->big().block_num;
    auto remap_it = data_remap.find(block_num);
@@ -544,10 +544,10 @@ void disk_tool_t::remap_big_write(heap_entry_t *wr)
    }
    block_num += data_idx_diff;
    wr->big().block_num = block_num;
-    wr->crc32c = wr->calc_crc32c();
+    wr->checksum = wr->calc_checksum(heap);
 }

-void disk_tool_t::remap_small_write(heap_entry_t *wr)
+void disk_tool_t::remap_small_write(blockstore_heap_t *heap, heap_entry_t *wr)
 {
    if (new_meta_format == BLOCKSTORE_META_FORMAT_HEAP && wr->small().len > 0)
    {
@@ -559,7 +559,7 @@ void disk_tool_t::remap_small_write(heap_entry_t *wr)
        memcpy(new_journal_ptr, buffer_area+wr->small().location, wr->small().len);
        wr->small().location = new_journal_ptr-new_journal_buf;
        new_journal_ptr += wr->small().len;
-        wr->crc32c = wr->calc_crc32c();
+        wr->checksum = wr->calc_checksum(heap);
    }
 }

@@ -673,11 +673,11 @@ int disk_tool_t::resize_rebuild_meta()
            {
                if (wr->type() == BS_HEAP_BIG_WRITE || wr->type() == BS_HEAP_BIG_INTENT)
                {
-                    remap_big_write(wr);
+                    remap_big_write(heap, wr);
                }
                else if (wr->type() == BS_HEAP_SMALL_WRITE)
                {
-                    remap_small_write(wr);
+                    remap_small_write(heap, wr);
                }
                else if (wr->type() != BS_HEAP_DELETE && new_meta_format != BLOCKSTORE_META_FORMAT_HEAP)
                {
@@ -786,7 +786,7 @@ int disk_tool_t::resize_rebuild_meta()
                    memcpy(((uint8_t*)wr) + sizeof(heap_big_write_t) + new_clean_entry_bitmap_size, bitmap+new_clean_entry_bitmap_size, new_clean_entry_bitmap_size);
                    memcpy(((uint8_t*)wr) + sizeof(heap_big_write_t) + 2*new_clean_entry_bitmap_size, bitmap+2*new_clean_entry_bitmap_size, new_data_csum_size);
                }
-                wr->crc32c = wr->calc_crc32c();
+                wr->checksum = wr->calc_checksum(&dsk);
                new_meta_pos += wr->size;
            }
            else
@@ -22,28 +22,6 @@ uint64_t sscanf_json(const char *fmt, const json11::Json & str)
    return value;
 }

-static int fromhex(char c)
-{
-    if (c >= '0' && c <= '9')
-        return (c-'0');
-    else if (c >= 'a' && c <= 'f')
-        return (c-'a'+10);
-    else if (c >= 'A' && c <= 'F')
-        return (c-'A'+10);
-    return -1;
-}
-
-void fromhexstr(const std::string & from, int bytes, uint8_t *to)
-{
-    for (int i = 0; i < from.size() && i < bytes; i++)
-    {
-        int x = fromhex(from[2*i]), y = fromhex(from[2*i+1]);
-        if (x < 0 || y < 0)
-            break;
-        to[i] = x*16 + y;
-    }
-}
-
 // returns 1 = check error, 0 = write through, -1 = write back
 // (similar to 1 = warning, -1 = error, 0 = success in disable_cache)
 static int check_queue_cache(std::string dev, std::string parent_dev)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Vitaliy Filippov	32721046b8	WIP Switch back to TCP when RDMA send fails (does not work)	2026-05-01 22:26:41 +00:00
Vitaliy Filippov	f8de201625	Close TCP connections for RDMA clients	2026-05-01 22:13:29 +00:00
Vitaliy Filippov	e7f30c4939	Also check for "Received garbage" during test	2026-05-01 16:01:28 +03:00
Vitaliy Filippov	8e441f4173	Add a CI test with RDMA	2026-05-01 15:57:15 +03:00
Vitaliy Filippov	80a05c052a	Add request size validation to prevent OOMDoS	2026-05-01 15:57:15 +03:00
Vitaliy Filippov	a972c13571	Implement OSD-side authorization for operations	2026-04-29 02:42:23 +03:00
Vitaliy Filippov	9372df4beb	Remove tls_ from option names	2026-04-27 15:41:00 +03:00
Vitaliy Filippov	24c27386b6	Remove TLS support (superseded by direct GCM)	2026-04-27 15:41:00 +03:00
Vitaliy Filippov	394de5e9aa	Implement TLS 1.3-like handshake manually	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	be61e76df0	Extract openssl-related code, wire ssl implementation back	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	5cad126987	Coalesce entries in send_out_buf	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	afa50a05b8	Support isa-l_crypto for AES-XTS too	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	9ff833178e	Fix xts+rdma encrypt errors	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	b152baa733	Fix "use-after-realloc" warning	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	8dbbf4097a	Support isa-l_crypto for AES-GCM	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	17cb875e10	Remove WITH_OPENSSL from all files except http_client, always require OpenSSL	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	03e15338e5	Use pools for GCM contexts	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	dccc549e33	Try to run tests with AES-GCM	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	440a8bc33a	Implement direct AES-256-GCM with a static key for benchmark	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	78a21542da	Make sure to send all TLS data before continuing	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	75ba9509ad	Parse standard TLS record headers	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	8b58fe9808	Omit msgr_tls_record_hdr_t for non-tls data	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	331f345a78	Allow 2 and 4 byte per block chain_info (allow more than 255 snapshots with encryption)	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	d0a4ac914b	Implement OSD TLS support	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	e42b812323	Allow to skip checksums for headers	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	ac5c753735	Implement protocol-level checksums (xxhash3)	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	f9eb497105	Include xxhash3 x86dispatch	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	3489c99640	Do not use scrap_buffer in the client (it would block protocol checksum support)	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	a21dcd4480	Support TLS CN authentication and per-image permissions in vitastor-cli serve	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	340849248b	Add VitastorAuthFilter	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	ee462c4375	Implement vitastor-cli ls-user, modify-user, remove-user commands	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	0053a0d825	Add image owner/owner_group/reader_group support (for antietcd VitastorAuthFilter)	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	cdeecead8d	Add security parameter documentation	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	c0e34b19c9	Support inline (string PEM) certificates and pkeys	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	e8abe99205	Show encryption keys (only IDs) in the listing	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	8225b37f53	Support storing image encryption keys in Vault	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	62b29b03c5	Prefer local etcd addresses and correctly cycle over them even when they need resolving Seems slightly overcomplicated...	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	ae2f570b58	Support DNS resolving via libc-ares	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	d7f854ab3e	Batch handle_immediate_ops more	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	29640d1aac	Add vitastor-cli create & modify --enc-key parameter	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	66a016f8a1	Support reading from snapshots encrypted with different keys	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	34d01f44db	Support decryption with multiple keys	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	3956982112	Allow to return chain_info in response to reads	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	713b17e574	Add basic AES-XTS client-side encryption support	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	4efa48c9ca	Rework msgr send/receive to allow encryption support	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	26d5e1ed00	Move fromhexstr() to str_util	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	9ba3444cfa	Add openapi description	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	96c0001127	Slightly fix API return and input types	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	56a14cc0bd	Implement vitastor-cli serve command to serve simple HTTP API	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	6ca1b9eca9	Implement HTTP server support O_o	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	876dbd730a	Rename http_response_t to http_message_t	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	4398ee0377	Extract common HTTP context	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	2c673a90bd	Support xxhash 32-bit checksums (data_csum_type=xxh3_32)	2026-04-27 15:24:44 +03:00
Vitaliy Filippov	a8371498e1	Detect block checksums using csum_block_size, not data_csum_type	2026-04-27 15:24:43 +03:00
Vitaliy Filippov	2a093cbfb5	Add client certificate support	2026-04-27 15:24:43 +03:00
Vitaliy Filippov	094a181491	Do not re-initialize TLS context every connection	2026-04-27 15:24:43 +03:00
Vitaliy Filippov	fe30783135	Add https support to antietcd	2026-04-27 15:24:43 +03:00
Vitaliy Filippov	e9a6c58418	Implement etcd SSL support via OpenSSL Maybe I should remove all of this and use libwebsockets :)	2026-04-27 15:24:43 +03:00