Como reforçar serviços do systemd

Reforçar um serviço do systemd é decidir, linha a linha no seu ficheiro de unidade, o que o processo do serviço pode tocar — e um serviço padrão pode tocar quase tudo. Normalmente corre como root, pode escrever em todo o sistema de ficheiros, pode carregar módulos do kernel e pode chamar qualquer chamada de sistema, porque esses são os valores por omissão: um ficheiro de unidade que não define nada não retirou nada. As diretivas de sandbox que o systemd já traz — ProtectSystem, PrivateTmp, NoNewPrivileges e as restantes — permitem retirar esses privilégios a partir de fora, sem mudar uma única linha da aplicação. Este artigo explica o que cada mudança realmente fecha, como ler a pontuação de exposição que mede o resultado e como implementar as mudanças sem quebrar o serviço. Pode auditar o seu próprio ficheiro de unidade no auditor de unidades do systemd, que o pontua, simula os seus temporizadores e produz uma versão reforçada — tudo no seu navegador.

Uma unidade de serviço é uma fronteira de sandbox, não apenas um script de arranque

A maioria das pessoas lê um ficheiro .service como um script de arranque: ExecStart diz o que correr, Restart diz o que fazer quando morre e o resto é modelo. Essa leitura perde o essencial. A secção [Service] é uma lista de permissões, e cada diretiva que não define é uma permissão que concedeu implicitamente. Uma unidade sem diretivas de sandbox executa o seu processo com todo o alcance do utilizador com que corre — normalmente root — sobre o sistema de ficheiros, a rede, os dispositivos, o kernel e todos os outros processos da máquina. Quando um serviço assim é comprometido, o atacante não precisa de escalar privilégios: o serviço já os tem.

A solução é tratar o ficheiro de unidade como a fronteira de segurança que ele é. O systemd pode confinar um processo a um sistema de ficheiros só de leitura, a um /tmp privado que nenhum outro processo consegue ver, a um /dev mínimo, sem novos privilégios, sem módulos do kernel e com uma lista curta de chamadas de sistema — tudo declarado na unidade, tudo imposto pelo kernel, e nada disso exige mudar a aplicação. É isso que torna o reforço de um serviço systemd diferente do reforço da maioria do software: o sandbox vive fora do código, por isso pode adicioná-lo a um daemon que não escreveu e não pode modificar, medir o resultado e revertê-lo apagando um ficheiro. O auditor existe para tornar essa fronteira visível: lê a unidade que realmente tem e enumera o que ela ainda permite.

Como ler a pontuação de exposição: o que significa 9,6 contra 2,0 — e o que não significa

O systemd-analyze security pontua uma unidade numa escala ponderada de exposição de 0,0 a 10,0, em que um número alto significa permissivo e um número baixo significa bem restrito, e rotula-a com uma faixa — OK, MEDIUM, EXPOSED ou UNSAFE na lista curta, com PERFECT, SAFE e DANGEROUS nas pontas da lista completa. Um serviço padrão sem diretivas de sandbox fica normalmente por volta de 9,6 UNSAFE; um serviço reforçado com cuidado fica por volta de 2,0 OK. As linhas por diretiva na saída são a parte útil: cada linha indica uma definição, se está definida e quanto contribui para a exposição, por isso as linhas vermelhas de maior peso são a sua lista de tarefas, por ordem de prioridade.

O que o número não significa importa mais do que o que significa. A página do manual é explícita: a análise cobre apenas as funcionalidades de segurança por serviço que o próprio systemd implementa, e um nível de exposição alto não significa que não haja sandbox eficaz no próprio código do serviço, nem que o serviço seja realmente vulnerável. Um 9,6 diz que o ficheiro de unidade aplica quase nenhum sandbox — não diz nada sobre a autenticação da aplicação, a validação de entradas ou os segredos que ela guarda. Alguns serviços precisam legitimamente de acesso amplo: um runtime de contentores precisa mesmo de chegar a tudo para correr contentores, e nenhuma diretiva pode mudar isso. Por isso leia a pontuação como uma medida de quanto do anfitrião um processo comprometido poderia alcançar, não como um veredicto sobre o serviço, e não persiga o 0,0 — persiga as diretivas que fecham o alcance de que o seu serviço não precisa.

As dez diretivas que fazem a maior parte do trabalho

Dez diretivas fazem a maior parte do trabalho real, e cada uma fecha uma peça específica do anfitrião em vez de todas ao mesmo tempo. ProtectSystem torna o sistema de ficheiros só de leitura — yes cobre /usr e /boot, full acrescenta /etc, strict cobre tudo exceto /dev, /proc e /sys — e ProtectHome esconde /home, /root e /run/user por completo. PrivateTmp dá ao serviço o seu próprio /tmp e /var/tmp que nenhum outro processo consegue ver, acabando com toda uma classe de ataques de ficheiros temporários previsíveis e corridas de links simbólicos. NoNewPrivileges garante que o processo e todos os seus filhos nunca possam obter novos privilégios através de execve, o que neutraliza a maior parte da escalação baseada em setuid numa só linha. CapabilityBoundingSet limita as capacidades de Linux que o processo pode alguma vez deter; deixe-o vazio e o serviço não fica com nenhuma, o que é a maior descida de pontuação de uma só diretiva para muitas unidades.

As outras cinco fecham o kernel e o próprio processo. PrivateDevices substitui /dev por um esqueleto mínimo, por isso um serviço comprometido não consegue mexer em discos brutos ou noutros nós de hardware. ProtectKernelModules proíbe o carregamento de módulos do kernel, e RestrictNamespaces impede o serviço de criar novos namespaces dos tipos que enumerar — uma via de fuga de contentores, fechada na unidade. LockPersonality impede o processo de mudar o seu domínio de execução, o que bloqueia uma classe pequena mas real de ataques baseados em personality. MemoryDenyWriteExecute proíbe memória que seja ao mesmo tempo gravável e executável, o que impede o padrão clássico de escrever shellcode na memória e depois saltar para ele. Juntamente com ProtectSystem=strict, abra os buracos exatos de que o serviço realmente precisa com ReadWritePaths — a lista branca, não um afrouxamento de toda a política — e aplique o filtro de chamadas de sistema SystemCallFilter=@system-service em último lugar, porque é o que mais provavelmente quebra algo subtil.

Temporizadores contra cron: OnCalendar, Persistent e porque vale a pena simular os próximos disparos

Uma linha de cron e um temporizador do systemd executam ambos um trabalho segundo um horário, mas não são o mesmo mecanismo, e as diferenças são onde vivem os erros. Um temporizador é uma unidade .timer que ativa uma unidade .service com o mesmo nome quando expira, e o seu horário é uma expressão OnCalendar — daily, Mon *-*-* 02:00, *-*-01 03:30:00, ou listas, intervalos e passos como Mon..Fri *-*-* 09:00 — com nomes de dias da semana, regras de fim de mês e repetições que uma linha de cron de cinco campos não consegue expressar. A página do manual systemd.timer(5) define a semântica; as consequências práticas são que os disparos de um temporizador ficam registados no journal como os de qualquer outra unidade, que um disparo perdido pode ser recuperado e que o próprio horário pode ser validado antes de alguma vez correr.

Duas funcionalidades fazem com que valha a pena simular os temporizadores antes de os implementar. Persistent=yes significa que, se a máquina estava desligada — ou o temporizador inativo — quando um disparo era devido, o serviço corre uma vez na próxima oportunidade em vez de essa execução nunca acontecer em silêncio, o que é a diferença entre uma cópia de segurança atrasada e uma cópia de segurança que nunca correu. E as expressões OnCalendar têm casos limite que um olhar não deteta: um disparo às 02:30 no dia em que o horário de verão salta as 02:00–03:00, um trabalho mensal no dia 31 num mês de 30 dias, uma regra de dia da semana que cai num feriado. É por isso que vale a pena gerar uma tabela de próximos disparos: corra systemd-analyze calendar com a expressão, ou simule os próximos 100 disparos no auditor, e leia a tabela antes de o horário entrar em vigor — um temporizador que dispara duas vezes, ou nunca, é um erro que quer encontrar num ecrã, não numa cópia de segurança em falta três meses depois.

O fluxo seguro: drop-ins, umas poucas diretivas de cada vez

Nunca edite à mão um ficheiro de unidade empacotado em /usr/lib/systemd/system: a próxima atualização do pacote sobrescreve-o e o seu reforço desaparece em silêncio. A via suportada é um drop-in — corra systemctl edit meuservico.service e as suas mudanças ficam em /etc/systemd/system/meuservico.service.d/override.conf, onde têm precedência sobre o ficheiro distribuído, sobrevivem a atualizações e podem ser removidas apagando um só ficheiro. O auditor pode gerar exatamente esse ficheiro: uma secção [Service] com apenas as diretivas que faltam à sua unidade, por isso a unidade original fica intacta.

Depois aplique umas poucas diretivas de cada vez e volte a medir após cada passo. Corra systemctl daemon-reload, reinicie o serviço, confirme que está realmente a correr com systemctl status, verifique o journal por recusas e volte a pontuá-lo — a pontuação deve descer a cada passo, e um passo que quebre o serviço diz-lhe exatamente que diretiva o fez. O modo de falha é previsível e até útil: o serviço arranca, tenta escrever num caminho que não colocou na lista branca e morre com um erro de sistema de ficheiros só de leitura, e journalctl -u meuservico indica o caminho exato, por isso adiciona-o a ReadWritePaths e continua. É por isso que se reforça aos poucos em vez de colar um bloco gigante e rezar — e é por isso que as ferramentas mais afiadas, o filtro de chamadas de sistema e as restrições de namespaces, vão em último lugar, depois de o serviço ter provado que funciona sob as restrições de sistema de ficheiros e privilégios.

O hábito de auditar primeiro: pontuar antes e depois, guardar a unidade em controlo de versões

Reforçar sem uma referência é adivinhar com passos extra. Antes de mudar o que quer que seja, pontue a unidade tal como está — esse número é a sua linha de partida, e cada mudança posterior é medida contra ele. Depois, após cada lote de diretivas, pontue-a novamente: a pontuação descer de 9,6 para 4,9 e depois para 2,0 é a prova de que o trabalho serviu para alguma coisa, e uma pontuação que não se move após uma mudança é um sinal de que a diretiva não surtiu o efeito esperado. Guarde os números de antes e depois juntamente com a mudança, como guardaria uma referência juntamente com uma melhoria de desempenho.

A segunda metade do hábito é guardar a unidade reforçada onde não se possa perder: o drop-in, e o temporizador se houver, pertencem ao controlo de versões juntamente com a configuração de implementação do serviço, não apenas na máquina. Uma unidade que vive apenas em /etc está a uma falha de disco, uma reconstrução ou um colega bem-intencionado de voltar ao estado original — e uma unidade original numa máquina reconstruída volta a pontuar 9,6 em silêncio. Volte a auditar também segundo um calendário: o systemd ganha novas verificações ao longo do tempo, por isso uma unidade que pontuava 2,0 há dois anos pode pontuar pior hoje sem que uma única linha tenha mudado. O mesmo hábito transfere-se diretamente para o ficheiro de configuração irmão — audite o sshd_config da mesma forma com o auditor de configuração do servidor SSH e o artigo Como reforçar a configuração do servidor SSH — porque a disciplina é a mesma seja qual for o ficheiro: medir primeiro, mudar pouco, medir novamente e guardar o resultado num lugar onde sobreviva à máquina.

Fontes

Perguntas frequentes

Uma pontuação de exposição baixa prova que o meu serviço é seguro?

Não. A pontuação é uma heurística ponderada sobre as diretivas de sandbox que o próprio systemd aplica — mede quanto do anfitrião um processo comprometido poderia alcançar, não se a aplicação é segura. Não sabe nada sobre a autenticação da aplicação, a validação de entradas, erros de lógica, os segredos que ela guarda ou os seus endpoints de rede expostos. Trate uma boa pontuação como uma camada da defesa em profundidade: combine-a com um utilizador dedicado sem root, exposição de rede de mínimo privilégio e a prática normal de segurança de aplicações. Um serviço pode pontuar 1,5 e continuar vulnerável, e um serviço pode pontuar 9,6 e estar bem — o número é uma medida de atenção, não um veredicto.

O reforço vai quebrar o meu serviço?

Pode, e é por isso que se aplicam as diretivas poucas de cada vez e se testa após cada passo. As restrições do sistema de ficheiros são a causa mais comum: ProtectSystem=strict torna todo o sistema de ficheiros só de leitura, por isso um serviço que escreve fora dos seus caminhos da lista branca falha com um erro de só de leitura — verifique o journal, adicione o caminho a ReadWritePaths e tente novamente. O filtro de chamadas de sistema é a ferramenta mais afiada e vai em último lugar: um filtro demasiado restrito pode deixar o serviço arrancar bem e depois falhar horas depois num caminho de código raro, por isso teste sob carga real e mantenha SystemCallErrorNumber=EPERM durante a implementação para que as recusas apareçam como erros normais em vez de uma morte instantânea. Nada disto é irreversível — um drop-in apaga-se, não se desfaz.

Devo substituir o cron por temporizadores do systemd?

Para trabalhos que pertencem a um serviço que o systemd já gere, normalmente sim: os temporizadores dão-lhe registo no journal, dependências com outras unidades, recuperação Persistent de execuções perdidas e um horário que pode validar com systemd-analyze calendar antes de entrar em vigor. O cron continua a ser adequado para trabalhos simples por utilizador e para sistemas sem systemd. Escolha o que escolher, simule primeiro o horário — as expressões OnCalendar têm casos limite de horário de verão, fim de mês e dia da semana que uma linha de cron de cinco campos não tem, e uma tabela de próximos disparos é a forma mais barata de detetar um temporizador que dispara duas vezes, ou nunca, antes de isso importar.