186 lines
9.6 KiB
Bash
Executable File
186 lines
9.6 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# Permissões do armazenamento local (volume montado em /app/.data).
|
|
#
|
|
# Cada caso cria o próprio volume descartável com prefixo único e remove só os
|
|
# volumes que criou. Nunca toca nos volumes do compose
|
|
# (adaptador-planilhas-local-postgres, adaptador-planilhas-local-storage).
|
|
#
|
|
# ADAPTER_IMAGE=adaptador-planilhas:local bash .github/scripts/storage-permissions.sh
|
|
set -euo pipefail
|
|
# Git Bash no Windows converteria /app/... em caminho do Windows.
|
|
export MSYS_NO_PATHCONV=1
|
|
|
|
IMAGE="${ADAPTER_IMAGE:-adaptador-planilhas:local}"
|
|
PREFIX="adaptador-storage-test-$$-$RANDOM"
|
|
CREATED=()
|
|
CONTAINERS=()
|
|
|
|
cleanup() {
|
|
for c in "${CONTAINERS[@]:-}"; do [ -n "$c" ] && docker rm -f "$c" >/dev/null 2>&1 || true; done
|
|
for v in "${CREATED[@]:-}"; do [ -n "$v" ] && docker volume rm "$v" >/dev/null 2>&1 || true; done
|
|
}
|
|
trap cleanup EXIT
|
|
|
|
# Define VOL no shell atual: dentro de $(...) o registro em CREATED se perderia.
|
|
new_volume() {
|
|
VOL="$PREFIX-$1"
|
|
docker volume create "$VOL" >/dev/null
|
|
CREATED+=("$VOL")
|
|
}
|
|
|
|
# Mesmas restrições do serviço storage-init do docker-compose.yml.
|
|
prepare() {
|
|
docker run --rm --network none --user 0:0 \
|
|
--cap-drop ALL --cap-add CHOWN --cap-add FOWNER --cap-add DAC_OVERRIDE \
|
|
--cap-add DAC_READ_SEARCH --cap-add SETUID --cap-add SETGID \
|
|
--security-opt no-new-privileges:true \
|
|
-v "$1:/app/.data" "$IMAGE" prepare-storage "${@:2}"
|
|
}
|
|
|
|
as_app() { local v="$1"; shift; docker run --rm --network none -v "$v:/app/.data" "$IMAGE" exec "$@"; }
|
|
as_root() { local v="$1"; shift; docker run --rm --network none --user 0:0 -v "$v:/app/.data" "$IMAGE" exec "$@"; }
|
|
|
|
# Estado do volume como root: dono, grupo, modo, tamanho e caminho, mais o hash dos arquivos.
|
|
snapshot() {
|
|
as_root "$1" sh -c 'cd /app/.data && find . -printf "%U:%G %m %s %p\n" | sort && find . -type f -exec sha256sum {} + | sort -k2'
|
|
}
|
|
|
|
expect_owner_mode() {
|
|
local v="$1" path="$2" want="$3"
|
|
local got
|
|
got=$(as_root "$v" stat -c '%u:%g %a' "$path")
|
|
[ "$got" = "$want" ] || { echo "ERRO: $path = '$got', esperado '$want'"; exit 1; }
|
|
}
|
|
|
|
fail() { echo "ERRO: $*"; exit 1; }
|
|
|
|
echo "== imagem: $IMAGE =="
|
|
docker image inspect "$IMAGE" >/dev/null
|
|
|
|
echo "== A. volume novo =="
|
|
new_volume a; VA="$VOL"
|
|
# A1: sem storage-init, o volume vazio herda dono e modo da imagem.
|
|
expect_owner_mode "$VA" /app/.data "1001:1001 750"
|
|
expect_owner_mode "$VA" /app/.data/storage "1001:1001 750"
|
|
as_app "$VA" sh -c ': > /app/.data/storage/ok && rm /app/.data/storage/ok' || fail "uid 1001 não escreve no volume novo"
|
|
# A2: com storage-init, o mesmo resultado e a prova de escrita.
|
|
prepare "$VA" | tee /tmp/storage-a.log
|
|
grep -q "STORAGE_WRITABLE" /tmp/storage-a.log || fail "storage-init não confirmou escrita"
|
|
echo "ok: volume novo 1001:1001 750, escrita pelo uid 1001"
|
|
|
|
echo "== B. volume existente, criado antes da correção (raiz root:root 755) =="
|
|
new_volume b; VB="$VOL"
|
|
as_root "$VB" sh -c '
|
|
chown 0:0 /app/.data /app/.data/storage && chmod 755 /app/.data /app/.data/storage
|
|
mkdir -p /app/.data/storage/ws-alpha/modelos
|
|
printf "conteudo do modelo alpha\n" > /app/.data/storage/ws-alpha/modelos/modelo.xlsx
|
|
chown -R 1001:1001 /app/.data/storage/ws-alpha
|
|
printf "arquivo legado de root\n" > /app/.data/storage/legado.bin
|
|
chmod 640 /app/.data/storage/legado.bin'
|
|
# Antes da preparação o uid 1001 não escreve na raiz: é o defeito original.
|
|
if as_app "$VB" sh -c ': > /app/.data/storage/x' 2>/dev/null; then fail "o cenário B deveria começar sem escrita"; fi
|
|
prepare "$VB" 2>&1 | tee /tmp/storage-b.log
|
|
grep -q "STORAGE_WRITABLE" /tmp/storage-b.log || fail "storage-init não confirmou escrita"
|
|
grep -q "AVISO: 1 item" /tmp/storage-b.log || fail "o arquivo de root deveria ser só reportado"
|
|
expect_owner_mode "$VB" /app/.data "1001:1001 750"
|
|
expect_owner_mode "$VB" /app/.data/storage "1001:1001 750"
|
|
# Conteúdo e dono dos arquivos existentes intactos; só os dois diretórios mudaram.
|
|
expect_owner_mode "$VB" /app/.data/storage/legado.bin "0:0 640"
|
|
expect_owner_mode "$VB" /app/.data/storage/ws-alpha/modelos/modelo.xlsx "1001:1001 644"
|
|
test "$(as_root "$VB" cat /app/.data/storage/ws-alpha/modelos/modelo.xlsx)" = "conteudo do modelo alpha" \
|
|
|| fail "conteúdo do modelo alterado"
|
|
test "$(as_root "$VB" cat /app/.data/storage/legado.bin)" = "arquivo legado de root" || fail "conteúdo legado alterado"
|
|
as_app "$VB" sh -c ': > /app/.data/storage/novo && rm /app/.data/storage/novo' || fail "uid 1001 não escreve após preparar"
|
|
echo "ok: volume existente preservado e liberado para o uid 1001"
|
|
|
|
echo "== C. idempotência =="
|
|
s1=$(snapshot "$VB")
|
|
prepare "$VB" > /tmp/storage-c1.log 2>&1
|
|
prepare "$VB" > /tmp/storage-c2.log 2>&1
|
|
s2=$(snapshot "$VB")
|
|
[ "$s1" = "$s2" ] || { diff <(echo "$s1") <(echo "$s2") || true; fail "a preparação repetida alterou o volume"; }
|
|
if grep -q -- "->" /tmp/storage-c2.log; then fail "a segunda execução não deveria alterar dono nem modo"; fi
|
|
echo "ok: duas execuções extras, nenhum byte, dono ou modo alterado"
|
|
|
|
echo "== C2. --fix-existing é limitado ao volume e preserva conteúdo =="
|
|
prepare "$VB" --fix-existing > /tmp/storage-c3.log 2>&1
|
|
expect_owner_mode "$VB" /app/.data/storage/legado.bin "1001:1001 640"
|
|
test "$(as_root "$VB" cat /app/.data/storage/legado.bin)" = "arquivo legado de root" || fail "conteúdo alterado"
|
|
if grep -q "AVISO" /tmp/storage-c3.log; then fail "ainda há item com outro dono"; fi
|
|
echo "ok: dono ajustado só quando pedido, conteúdo intacto"
|
|
|
|
echo "== D. web e worker compartilham o volume =="
|
|
new_volume d; VD="$VOL"
|
|
prepare "$VD" >/dev/null
|
|
# Um contêiner grava como a web grava, outro lê e apaga como o worker faz na limpeza.
|
|
as_app "$VD" sh -c 'mkdir -p /app/.data/storage/ws/jobs && printf saida > /app/.data/storage/ws/jobs/out.csv'
|
|
test "$(as_app "$VD" cat /app/.data/storage/ws/jobs/out.csv)" = "saida" || fail "outro contêiner não lê o arquivo"
|
|
as_app "$VD" rm /app/.data/storage/ws/jobs/out.csv || fail "outro contêiner não apaga o arquivo"
|
|
# O comando web real passa da verificação e responde liveness.
|
|
WEB="$PREFIX-web"
|
|
CONTAINERS+=("$WEB")
|
|
docker run -d --name "$WEB" --network none -e ADAPTER_ENV=development -v "$VD:/app/.data" "$IMAGE" web >/dev/null
|
|
ok=""
|
|
for _ in $(seq 1 30); do
|
|
if docker exec "$WEB" node -e "fetch('http://127.0.0.1:3000/api/health/live').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))" 2>/dev/null; then ok=1; break; fi
|
|
sleep 1
|
|
done
|
|
[ -n "$ok" ] || { docker logs "$WEB"; fail "a web não subiu com o volume preparado"; }
|
|
docker logs "$WEB" 2>&1 | grep -q STORAGE_NOT_WRITABLE && fail "a web reportou storage sem escrita"
|
|
# O comando worker real passa da verificação de storage (falha depois, por falta de banco/Redis, o que não é deste teste).
|
|
WORKER="$PREFIX-worker"
|
|
CONTAINERS+=("$WORKER")
|
|
docker run -d --name "$WORKER" --network none -e ADAPTER_ENV=development -e ADAPTER_JOB_MODE=worker \
|
|
-v "$VD:/app/.data" "$IMAGE" worker >/dev/null
|
|
sleep 6
|
|
wlog=$(docker logs "$WORKER" 2>&1)
|
|
docker rm -f "$WORKER" >/dev/null
|
|
echo "$wlog" | grep -q STORAGE_NOT_WRITABLE && { echo "$wlog"; fail "o worker reportou storage sem escrita"; }
|
|
echo "$wlog" | grep -q '\[worker\]\|DATABASE\|Redis\|ECONNREFUSED\|pglite\|migration' \
|
|
|| { echo "$wlog"; fail "o worker não chegou ao código da aplicação"; }
|
|
echo "ok: escrita, leitura e remoção entre contêineres; web e worker passam da verificação"
|
|
|
|
echo "== E. usuário não privilegiado =="
|
|
test "$(docker exec "$WEB" id -u)" = "1001" || fail "a web não roda como 1001"
|
|
test "$(docker exec "$WEB" sh -c 'grep CapEff /proc/1/status | cut -f2')" = "0000000000000000" || fail "a web tem capacidades"
|
|
test "$(docker run --rm --network none "$IMAGE" exec id -u)" = "1001" || fail "o usuário padrão da imagem não é 1001"
|
|
# prepare-storage recusa rodar sem root, então não serve de atalho para escalar.
|
|
if docker run --rm --network none -v "$VD:/app/.data" "$IMAGE" prepare-storage >/dev/null 2>&1; then
|
|
fail "prepare-storage aceitou rodar como 1001"
|
|
fi
|
|
docker rm -f "$WEB" >/dev/null
|
|
test "$(docker image inspect "$IMAGE" --format "{{.Config.User}}")" = "adaptador" || fail "a imagem não declara USER adaptador"
|
|
echo "ok: web e worker como 1001 sem capacidades; preparação só como root"
|
|
|
|
echo "== F. falha segura com armazenamento sem escrita =="
|
|
new_volume f; VF="$VOL"
|
|
as_root "$VF" sh -c 'chown 0:0 /app/.data /app/.data/storage && chmod 755 /app/.data /app/.data/storage'
|
|
for proc in web worker; do
|
|
set +e
|
|
out=$(docker run --rm --network none -e ADAPTER_ENV=development -v "$VF:/app/.data" "$IMAGE" "$proc" 2>&1)
|
|
code=$?
|
|
set -e
|
|
[ "$code" -ne 0 ] || fail "$proc subiu com storage sem escrita"
|
|
echo "$out" | grep -q STORAGE_NOT_WRITABLE || { echo "$out"; fail "$proc não explicou a falha"; }
|
|
echo " $proc: saiu com código $code e STORAGE_NOT_WRITABLE"
|
|
done
|
|
# Com Supabase configurado o volume local não é usado e a verificação não bloqueia.
|
|
SUPA="$PREFIX-supabase"
|
|
CONTAINERS+=("$SUPA")
|
|
docker run -d --name "$SUPA" --network none -e ADAPTER_ENV=development \
|
|
-e NEXT_PUBLIC_SUPABASE_URL=https://exemplo.invalid -e SUPABASE_SERVICE_ROLE_KEY=x -e SUPABASE_STORAGE_BUCKET=x \
|
|
-v "$VF:/app/.data" "$IMAGE" web >/dev/null
|
|
ok=""
|
|
for _ in $(seq 1 30); do
|
|
if docker exec "$SUPA" node -e "fetch('http://127.0.0.1:3000/api/health/live').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))" 2>/dev/null; then ok=1; break; fi
|
|
sleep 1
|
|
done
|
|
slog=$(docker logs "$SUPA" 2>&1)
|
|
docker rm -f "$SUPA" >/dev/null
|
|
[ -n "$ok" ] || { echo "$slog"; fail "a web não subiu com bucket configurado"; }
|
|
echo "$slog" | grep -q STORAGE_NOT_WRITABLE && { echo "$slog"; fail "a verificação bloqueou com bucket configurado"; }
|
|
echo "ok: falha explícita sem storage; sem bloqueio quando o bucket é o Supabase"
|
|
|
|
echo ""
|
|
echo "PERMISSÕES DO ARMAZENAMENTO: OK (A, B, C, D, E, F)"
|