Módulo 6: Deploy Seguro, Chave com Comando Travado, Blue-Green e Aprovação | Curso de Segurança para Sites

Módulo 6 · Curso de Segurança para Sites e Servidores

Deploy seguro

O deploy automático é a única porta que se abre sozinha. Este módulo parte de uma pergunta concreta, feita durante a auditoria: "e se eu contratar um programador mal-intencionado e aprovar o código dele sem perceber?". A resposta é inverter quem manda no servidor, para que o pior merge possível só consiga trocar a imagem do site.

GitHub Actions comando travado blue-green CODEOWNERS

Aula 20

O risco do pipeline: quem faz merge vira root

Um deploy automático típico faz assim: a cada push na branch principal, o GitHub Actions entra no servidor por SSH como root, baixa o repositório e roda um script dele, como bin/deploy.sh, junto com os arquivos de compose também vindos do repositório. Funciona, e é exatamente o que a auditoria encontrou. O problema é que o servidor obedece a qualquer coisa que esteja escrita no repositório.

Pense em quem consegue alterar esse script. Um colaborador com acesso de escrita. Uma conta do GitHub invadida. Uma ação de terceiros usada no workflow que foi comprometida, um tipo de ataque à cadeia de suprimentos que já atingiu milhares de projetos. Em todos os casos, a linha maliciosa passa pela revisão disfarçada no meio de uma mudança grande, e no próximo deploy ela roda como root, num servidor que hospeda outros projetos. Pelo STRIDE do módulo 1, é uma elevação de privilégio de manual: permissão de escrita no repositório vira controle total do servidor.

A correção não é confiar mais nas pessoas, é tirar do repositório o poder de dizer o que roda no servidor. O repositório continua definindo o que vai dentro da imagem do site. O servidor passa a definir, sozinho, como essa imagem é colocada no ar.

O que um merge malicioso consegue fazer

Alcance do dano, de 0 (nenhum) a 5 (total), antes e depois das mudanças deste módulo.

Avaliação qualitativa do curso, a partir da auditoria descrita no módulo 1. O código do site continua exposto: revisão de código segue necessária.

Fontes desta aula: GitHub: security hardening for Actions · SLSA

Aula 21

Chave de deploy com comando travado

O OpenSSH permite amarrar uma chave a um único comando. Na linha da chave no authorized_keys, a opção command= define o que roda, ignorando o que o cliente pediu, e restrict desliga terminal, encaminhamento de portas, de agente e de X11:

# /root/.ssh/authorized_keys: uma chave só para o deploy
command="/usr/local/sbin/site-deploy",restrict ssh-ed25519 AAAA... deploy-do-site

O pedido original do cliente chega ao script na variável SSH_ORIGINAL_COMMAND, e é aí que entra a segunda trava: o script mora no servidor, pertence ao root e aceita uma única frase, o ambiente e o código do commit, validados por expressão regular. Qualquer outra coisa é recusada e registrada.

#!/bin/bash
# /usr/local/sbin/site-deploy (dono root, modo 700). Mora no servidor, não vem do repositório.
set -euo pipefail

pedido="${SSH_ORIGINAL_COMMAND:-}"
if [[ ! "$pedido" =~ ^(producao|teste)\ ([0-9a-f]{40})$ ]]; then
    logger -t site-deploy "pedido recusado de ${SSH_CONNECTION%% *}"
    echo "só aceito 'producao <sha>' ou 'teste <sha>'" >&2
    exit 1
fi
ambiente="${BASH_REMATCH[1]}"
export IMAGE_TAG="${BASH_REMATCH[2]}"

# Um deploy por vez em cada ambiente.
exec 9>"/run/lock/site-deploy-$ambiente.lock"
flock -w 1500 9 || { echo "outro deploy ainda está rodando" >&2; exit 1; }

# Token temporário do workflow pela entrada padrão: serve só para baixar a imagem.
IFS= read -r -t 20 token || true
[ -n "${token:-}" ] && printf '%s' "$token" | docker login ghcr.io -u ci --password-stdin >/dev/null
unset token

cd /srv/site-$ambiente
sh bin/deploy.sh      # o deploy.sh e o compose usados são os que JÁ ESTÃO no servidor

Repare no que o workflow do GitHub passa a enviar: só a frase producao 3f2a... e, pela entrada padrão, o token temporário do registro de imagens, que expira com o job. Nenhum script trafega. Com isso, a chave de deploy, se vazar, permite apenas disparar a publicação de uma imagem que já existe no registro, e o aviso de login do módulo 5 registra cada uso.

O custo: mudanças na infraestrutura (o compose, o deploy.sh, o próprio script) deixam de ir sozinhas no merge. As cópias no repositório viram referência, e alguém com acesso ao servidor as copia à mão depois de revisar. Para a maioria dos sites, essas mudanças são raras, e o controle extra vale o passo manual.

Fontes desta aula: sshd(8): AUTHORIZED_KEYS FILE FORMAT · SSH Academy: authorized_keys

Aula 22

Imagem pronta, blue-green e rollback

A outra metade da inversão é: o servidor não compila nada. A imagem do site é construída no pipeline, publicada num registro (no curso, o GitHub Container Registry) com a etiqueta do commit, e o servidor só baixa a imagem daquele commit. Compilar no servidor significaria executar lá ferramentas e scripts do repositório, o que é exatamente o que queremos evitar.

O caminho do merge até o ar

GITHUB SERVIDOR Merge main protegida Build imagem do commit Registro ghcr.io, tag = sha Aprovação no celular só então o segredo de deploy é liberado Chave travada recebe "producao <sha>" Script do servidor valida e baixa a imagem blue (no ar) green (nova)
Ilustração do curso. Nada do repositório é executado no servidor: só a imagem do commit, isolada no contêiner.

No servidor, o deploy.sh faz a troca blue-green: existem duas "cores" do site, e só uma recebe tráfego. O script lê qual cor está no ar, sobe a outra com a imagem nova, espera o healthcheck (uma página que testa o banco) passar e roda a rotina de preparação do WordPress. Se qualquer passo falhar, a cor nova é removida e a antiga continua no ar, sem o visitante perceber. Se tudo der certo, a cor antiga sinaliza ao proxy reverso que deve sair do balanceamento e é desligada.

Como cada imagem tem a etiqueta do commit, o rollback é rodar o mesmo script com o commit anterior: IMAGE_TAG=<sha anterior> sh bin/deploy.sh. Sem recompilar, sem restaurar arquivos. É o mesmo argumento do módulo 1, agora a favor da disponibilidade: um site que se reconstrói a partir de artefatos imutáveis se recupera rápido de qualquer coisa, inclusive de uma invasão.

Fontes desta aula: Martin Fowler: BlueGreenDeployment · Humble e Farley, Continuous Delivery (2010)

Aula 23

Aprovação humana: ambientes, CODEOWNERS e branch protegida

As travas técnicas limitam o estrago. A última camada decide se o deploy acontece. No GitHub, ela tem três peças, todas configuradas em Settings:

  1. Ambiente com revisor obrigatório. O job de deploy declara environment: production, e em Settings → Environments → production você liga Required reviewers. O job para e espera; a notificação chega no aplicativo GitHub Mobile, e um toque em Approve libera. Os segredos do ambiente, como a chave de deploy, só são entregues ao job depois da aprovação. Em repositório privado, esse recurso exige um plano pago do GitHub.
  2. Branch principal protegida. Ninguém faz push direto na main; tudo entra por pull request.
  3. CODEOWNERS nos caminhos sensíveis. Com Require review from Code Owners ligado, mudanças nesses arquivos só entram com a aprovação do dono.
# .github/CODEOWNERS: caminhos que levam ao servidor só entram com a sua aprovação
/.github/            @dono-do-projeto
/bin/                @dono-do-projeto
/docker/             @dono-do-projeto
/servidor/           @dono-do-projeto
/Dockerfile          @dono-do-projeto
/docker-compose*.yml @dono-do-projeto
# .github/workflows/deploy.yml (trecho)
deploy:
  needs: build
  runs-on: ubuntu-latest
  environment: production          # espera a aprovação
  steps:
    - name: Publicar o commit
      run: |
        echo "${{ secrets.GITHUB_TOKEN }}" | ssh -i chave_deploy deploy@servidor "producao ${{ github.sha }}"

Por último, o colaborador entra como colaborador, sem acesso a Settings nem aos segredos. Somando tudo: para chegar ao servidor, um código malicioso precisaria passar pela revisão de um Code Owner, pela aprovação do deploy, e mesmo assim só conseguiria trocar a imagem do site, que roda isolada e sob a vigilância do verificador de integridade.

Fontes desta aula: GitHub: environments · GitHub: code owners · GitHub: protected branches

Erros comuns

  • Enviar o script de deploy pelo SSH. Se o workflow manda o script, quem altera o workflow decide o que roda no servidor.
  • Usar a chave pessoal como chave de deploy. Uma chave sem restrição num segredo do GitHub é uma porta de root.
  • Compilar no servidor. Build no servidor executa código do repositório fora do contêiner.
  • Etiqueta "latest" no deploy. Sem a etiqueta do commit, não há rollback confiável nem rastreabilidade.
  • Aprovação sem as travas. Aprovar pelo celular sem chave travada ainda permite que um deploy aprovado sem querer rode qualquer coisa.

Aplicação prática

  1. Leia o seu workflow de deploy e responda: o que um merge malicioso conseguiria rodar no servidor?
  2. Gere uma chave só para o deploy, amarre-a com command= e restrict a um script do servidor que valide o commit.
  3. Mude o workflow para mandar só o ambiente e o commit, e confira com um deploy no ambiente de teste.
  4. Crie o CODEOWNERS, proteja a main e ligue o revisor obrigatório no ambiente de produção.

Siglas usadas neste módulo

CI/CD:
Continuous Integration / Continuous Delivery, integração e entrega contínuas.
PR:
Pull Request, pedido de integração de mudanças no repositório.
SHA:
Secure Hash Algorithm, função de resumo que identifica cada commit do git (40 caracteres em hexadecimal).
SSH:
Secure Shell, protocolo de acesso remoto seguro a servidores.
SLSA:
Supply-chain Levels for Software Artifacts, framework de segurança da cadeia de suprimentos de software.
YAML:
YAML Ain't Markup Language, formato dos arquivos de workflow do GitHub Actions.

Perguntas frequentes

Por que um pipeline de deploy comum é um risco para o servidor?
Porque, na configuração mais comum, a automação entra no servidor como root e executa um script que veio do próprio repositório. Quem conseguir colocar uma linha nesse script e passar pelo merge, seja um colaborador mal-intencionado, uma conta invadida ou uma dependência comprometida, executa qualquer comando como root no próximo deploy. Num servidor compartilhado, isso alcança todos os outros projetos da máquina.
O que é uma chave SSH com comando travado?
É uma chave cuja linha no authorized_keys começa com command="/caminho/do/script",restrict. Com isso, qualquer conexão feita com essa chave executa só aquele script, não importa o comando que o cliente pediu; o pedido original chega ao script na variável SSH_ORIGINAL_COMMAND, onde pode ser validado. A opção restrict desliga terminal, encaminhamento de portas e de agente. Se a chave vazar, o atacante só consegue chamar o script, e o script só aceita o que você definiu.
Por que o servidor deve baixar uma imagem pronta em vez de compilar o código?
Porque compilar no servidor significa executar no servidor ferramentas e scripts vindos do repositório, como Dockerfile, instaladores e hooks de build. Com a imagem construída no pipeline e publicada num registro, o servidor só baixa a imagem daquele commit e a roda isolada no contêiner. Um merge malicioso consegue, no máximo, trocar a imagem do site, que roda sem acesso ao servidor nem aos outros projetos.
A aprovação de deploy pelo celular adianta se eu aprovar sem olhar?
Adianta, porque ela não é a única barreira. Com a chave de comando travado e o script do servidor, até um deploy aprovado sem revisão só consegue trocar a imagem do site. A aprovação acrescenta outra garantia: os segredos do ambiente de produção, como a chave de deploy, só são entregues ao job depois do toque de alguém autorizado. Sem aprovação, nem a automação nem quem a alterou chegam ao servidor.
O que o CODEOWNERS protege que a revisão comum não protege?
O CODEOWNERS associa caminhos do repositório a responsáveis. Com a proteção de branch exigindo revisão de Code Owners, nenhuma mudança em arquivos sensíveis, como workflows, scripts de deploy, Dockerfile e configuração de contêineres, entra na branch principal sem a aprovação dessa pessoa. Um colaborador consegue aprovar o código do tema de outro colaborador, mas não consegue aprovar sozinho uma mudança no caminho que leva ao servidor.