15 Criptografia

Visão geral

O Zabbix suporta comunicações criptografadas entre os componentes do Zabbix usando o protocolo Transport Layer Security (TLS) v.1.2 e 1.3 (dependendo da biblioteca de criptografia). A criptografia baseada em certificado e baseada em chave pré-compartilhada é suportada.

A criptografia pode ser configurada para conexões:

  • Entre o Zabbix server, Zabbix proxy, Zabbix agent, Zabbix web service, utilitários zabbix_sender e zabbix_get
  • Para o banco de dados Zabbix a partir do Zabbix frontend e server/proxy
  • Entre o Zabbix frontend e o Zabbix server

A criptografia é opcional e configurável para componentes individuais:

  • Alguns proxies e agents podem ser configurados para usar criptografia baseada em certificado com o server, enquanto outros podem usar criptografia baseada em chave pré-compartilhada, e ainda outros continuam com comunicações não criptografadas (como antes).
  • O server (proxy) pode usar diferentes configurações de criptografia para diferentes hosts.

Os programas daemon do Zabbix usam uma porta de escuta para conexões recebidas criptografadas e não criptografadas. Adicionar uma criptografia não requer a abertura de novas portas em firewalls.

Limitações

  • As chaves privadas são armazenadas em texto simples em arquivos legíveis pelos componentes do Zabbix durante a inicialização.
  • As chaves pré-compartilhadas são inseridas no frontend do Zabbix e armazenadas no banco de dados do Zabbix em texto simples.
  • A criptografia interna não protege as comunicações entre o servidor web que executa o frontend do Zabbix e o navegador web do usuário.
  • Atualmente, cada conexão criptografada é aberta com um handshake TLS completo, sem cache de sessão e tickets implementados.
  • Adicionar criptografia aumenta o tempo para verificações de item e ações, dependendo da latência da rede:
    • Por exemplo, se o atraso do pacote for de 100ms, abrir uma conexão TCP e enviar uma solicitação não criptografada leva cerca de 200ms. Com criptografia, cerca de 1000 ms são adicionados para estabelecer a conexão TLS.
    • Os timeouts podem precisar ser aumentados, caso contrário, alguns itens e ações que executam scripts remotos em agents podem funcionar com conexões não criptografadas, mas falhar com timeout quando criptografadas.
  • A criptografia não é suportada pela descoberta de rede. As verificações do agent Zabbix realizadas pela descoberta de rede serão não criptografadas e, se o agent Zabbix estiver configurado para rejeitar conexões não criptografadas, essas verificações não terão sucesso.

Compilando o Zabbix com suporte a criptografia

Para oferecer suporte à criptografia, o Zabbix deve ser compilado e vinculado com uma das bibliotecas criptográficas suportadas:

  • GnuTLS - a partir da versão 3.1.18
  • OpenSSL - versões 1.0.1, 1.0.2, 1.1.0, 1.1.1, 3.0.x
  • LibreSSL - testado com as versões 2.7.4, 2.8.2:
    • LibreSSL 2.6.x não é suportado
    • LibreSSL é suportado como uma substituição compatível do OpenSSL; as novas funções de API específicas do LibreSSL tls_*() não são usadas. Componentes do Zabbix compilados com LibreSSL não poderão usar PSK; somente certificados podem ser usados.

Você pode encontrar mais informações sobre a configuração de SSL para o frontend do Zabbix consultando estas boas práticas.

A biblioteca é selecionada especificando a respectiva opção no script "configure":

  • --with-gnutls[=DIR]
  • --with-openssl[=DIR] (também usado para LibreSSL)

Por exemplo, para configurar os fontes do server e do agent com OpenSSL, você pode usar algo como:

./configure --enable-server --enable-agent --with-mysql --enable-ipv6 --with-net-snmp --with-libcurl --with-libxml2 --with-openssl

Diferentes componentes do Zabbix podem ser compilados com diferentes bibliotecas criptográficas (por exemplo, um server com OpenSSL e um agent com GnuTLS).

Se você planeja usar chaves pré-compartilhadas (PSK), considere usar bibliotecas GnuTLS ou OpenSSL 1.1.0 (ou mais recentes) nos componentes do Zabbix que utilizam PSKs. As bibliotecas GnuTLS e OpenSSL 1.1.0 suportam conjuntos de cifras PSK com Perfect Forward Secrecy. Versões mais antigas da biblioteca OpenSSL (1.0.1, 1.0.2c) também suportam PSKs, mas os conjuntos de cifras PSK disponíveis não fornecem Perfect Forward Secrecy.

Gerenciamento da criptografia de conexões

As conexões no Zabbix podem usar:

Há dois parâmetros importantes usados para especificar a criptografia entre os componentes do Zabbix:

  • TLSConnect - especifica qual criptografia usar para conexões de saída (sem criptografia, PSK ou certificado)
  • TLSAccept - especifica quais tipos de conexões são permitidos para conexões de entrada (sem criptografia, PSK ou certificado). Um ou mais valores podem ser especificados.

TLSConnect é usado nos arquivos de configuração do Zabbix proxy (no modo ativo, especifica apenas conexões com o server) e do Zabbix agent (para verificações ativas). No frontend do Zabbix, o equivalente de TLSConnect é o campo Connections to host em Data collection > Hosts > <some host> > guia Encryption e o campo Connections to proxy em Administration > Proxies> <some proxy> > guia Encryption. Se o tipo de criptografia configurado para a conexão falhar, nenhum outro tipo de criptografia será tentado.

TLSAccept é usado nos arquivos de configuração do Zabbix proxy (no modo passivo, especifica apenas conexões do server) e do Zabbix agent (para verificações passivas). No frontend do Zabbix, o equivalente de TLSAccept é o campo Connections from host em Data collection > Hosts > <some host> > guia Encryption e o campo Connections from proxy em Administration > Proxies > <some proxy> > guia Encryption.

Normalmente, você configura apenas um tipo de criptografia para conexões de entrada. Mas talvez você queira alternar o tipo de criptografia, por exemplo, de sem criptografia para baseada em certificado, com o mínimo de tempo de indisponibilidade e possibilidade de rollback. Para isso:

  • Defina TLSAccept=unencrypted,cert no arquivo de configuração do agent e reinicie o Zabbix agent
  • Teste a conexão com zabbix_get para o agent usando certificado. Se funcionar, você pode reconfigurar a criptografia para esse agent no frontend do Zabbix, na guia Data collection > Hosts > <some host> > Encryption, definindo Connections to host como "Certificate".
  • Quando o cache de configuração do server for atualizado (e a configuração do proxy for atualizada, se o host for monitorado por proxy), as conexões com esse agent serão criptografadas
  • Se tudo funcionar como esperado, você pode definir TLSAccept=cert no arquivo de configuração do agent e reiniciar o Zabbix agent. Agora o agent aceitará apenas conexões criptografadas baseadas em certificado. Conexões sem criptografia e baseadas em PSK serão rejeitadas.

De forma semelhante, isso funciona no server e no proxy. Se, no frontend do Zabbix, na configuração do host, Connections from host estiver definido como "Certificate", então apenas conexões criptografadas baseadas em certificado serão aceitas do agent (verificações ativas) e do zabbix_sender (itens trapper).

Muito provavelmente, você configurará as conexões de entrada e de saída para usar o mesmo tipo de criptografia ou nenhuma criptografia. Mas, tecnicamente, é possível configurá-las de forma assimétrica, por exemplo, criptografia baseada em certificado para conexões de entrada e baseada em PSK para conexões de saída.

A configuração de criptografia de cada host é exibida no frontend do Zabbix, em Data collection > Hosts, na coluna Agent encryption. Por exemplo:

Example Connections to host Allowed connections from host Rejected connections from host
none\_none.png Sem criptografia Sem criptografia Criptografadas, criptografadas baseadas em certificado e PSK
cert\_cert.png Criptografadas, baseadas em certificado Criptografadas, baseadas em certificado Sem criptografia e criptografadas baseadas em PSK
psk\_psk.png Criptografadas, baseadas em PSK Criptografadas, baseadas em PSK Sem criptografia e criptografadas baseadas em certificado
psk\_none\_psk.png Criptografadas, baseadas em PSK Sem criptografia e criptografadas baseadas em PSK Criptografadas, baseadas em certificado
cert\_all.png Criptografadas, baseadas em certificado Sem criptografia, PSK ou criptografadas baseadas em certificado -

As conexões são sem criptografia por padrão. A criptografia deve ser configurada individualmente para cada host e proxy.

zabbix_get e zabbix_sender com criptografia

Consulte as páginas de manual do zabbix_get e zabbix_sender para usá-los com criptografia.

Suítes de cifras

Por padrão, as suítes de cifras são configuradas internamente durante a inicialização do Zabbix.

Também há suporte para suítes de cifras configuradas pelo usuário para GnuTLS e OpenSSL. Os usuários podem configurar as suítes de cifras de acordo com suas políticas de segurança. O uso desse recurso é opcional (as suítes de cifras padrão integradas continuam funcionando).

Para bibliotecas criptográficas compiladas com configurações padrão, as regras integradas do Zabbix normalmente resultam nas seguintes suítes de cifras (em ordem da maior para a menor prioridade):

Biblioteca Suítes de cifras de certificado Suítes de cifras PSK
GnuTLS 3.1.18 TLS_ECDHE_RSA_AES_128_GCM_SHA256
TLS_ECDHE_RSA_AES_128_CBC_SHA256
TLS_ECDHE_RSA_AES_128_CBC_SHA1
TLS_RSA_AES_128_GCM_SHA256
TLS_RSA_AES_128_CBC_SHA256
TLS_RSA_AES_128_CBC_SHA1		 TLS_ECDHE_PSK_AES_128_CBC_SHA256
TLS_ECDHE_PSK_AES_128_CBC_SHA1
TLS_PSK_AES_128_GCM_SHA256
TLS_PSK_AES_128_CBC_SHA256
TLS_PSK_AES_128_CBC_SHA1
OpenSSL 1.0.2c ECDHE-RSA-AES128-GCM-SHA256
ECDHE-RSA-AES128-SHA256
ECDHE-RSA-AES128-SHA
AES128-GCM-SHA256
AES128-SHA256
AES128-SHA		 PSK-AES128-CBC-SHA
OpenSSL 1.1.0 ECDHE-RSA-AES128-GCM-SHA256
ECDHE-RSA-AES128-SHA256
ECDHE-RSA-AES128-SHA
AES128-GCM-SHA256
AES128-CCM8
AES128-CCM
AES128-SHA256
AES128-SHA
 ECDHE-PSK-AES128-CBC-SHA256
ECDHE-PSK-AES128-CBC-SHA
PSK-AES128-GCM-SHA256
PSK-AES128-CCM8
PSK-AES128-CCM
PSK-AES128-CBC-SHA256
PSK-AES128-CBC-SHA
OpenSSL 1.1.1d TLS_AES_256_GCM_SHA384
TLS_CHACHA20_POLY1305_SHA256
TLS_AES_128_GCM_SHA256
ECDHE-RSA-AES128-GCM-SHA256
ECDHE-RSA-AES128-SHA256
ECDHE-RSA-AES128-SHA
AES128-GCM-SHA256
AES128-CCM8
AES128-CCM
AES128-SHA256
AES128-SHA		 TLS_CHACHA20_POLY1305_SHA256
TLS_AES_128_GCM_SHA256
ECDHE-PSK-AES128-CBC-SHA256
ECDHE-PSK-AES128-CBC-SHA
PSK-AES128-GCM-SHA256
PSK-AES128-CCM8
PSK-AES128-CCM
PSK-AES128-CBC-SHA256
PSK-AES128-CBC-SHA

Ciphersuites configuradas pelo usuário

Os critérios internos de seleção de ciphersuites podem ser substituídos por ciphersuites configuradas pelo usuário.

Ciphersuites configuradas pelo usuário são um recurso destinado a usuários avançados que compreendem ciphersuites TLS, sua segurança e as consequências de erros, e que estejam confortáveis com a solução de problemas de TLS.

Os critérios internos de seleção de ciphersuites podem ser substituídos usando os seguintes parâmetros:

Escopo de substituição Parâmetro Valor Descrição
Seleção de ciphersuite para certificados TLSCipherCert13 Cipher strings válidas do OpenSSL 1.1.1 para o protocolo TLS 1.3 (seus valores são passados para a função OpenSSL SSL_CTX_set_ciphersuites()). Critérios de seleção de ciphersuite baseados em certificado para TLS 1.3

Apenas OpenSSL 1.1.1 ou mais recente.
TLSCipherCert Cipher strings válidas do OpenSSL para TLS 1.2 ou priority strings válidas do GnuTLS. Seus valores são passados para as funções SSL_CTX_set_cipher_list() ou gnutls_priority_init(), respectivamente. Critérios de seleção de ciphersuite baseados em certificado para TLS 1.2/1.3 (GnuTLS), TLS 1.2 (OpenSSL)
Seleção de ciphersuite para PSK TLSCipherPSK13 Cipher strings válidas do OpenSSL 1.1.1 para o protocolo TLS 1.3 (seus valores são passados para a função OpenSSL SSL_CTX_set_ciphersuites()). Critérios de seleção de ciphersuite baseados em PSK para TLS 1.3

Apenas OpenSSL 1.1.1 ou mais recente.
TLSCipherPSK Cipher strings válidas do OpenSSL para TLS 1.2 ou priority strings válidas do GnuTLS. Seus valores são passados para as funções SSL_CTX_set_cipher_list() ou gnutls_priority_init(), respectivamente. Critérios de seleção de ciphersuite baseados em PSK para TLS 1.2/1.3 (GnuTLS), TLS 1.2 (OpenSSL)
Lista combinada de ciphersuites para certificado e PSK TLSCipherAll13 Cipher strings válidas do OpenSSL 1.1.1 para o protocolo TLS 1.3 (seus valores são passados para a função OpenSSL SSL_CTX_set_ciphersuites()). Critérios de seleção de ciphersuite para TLS 1.3

Apenas OpenSSL 1.1.1 ou mais recente.
TLSCipherAll Cipher strings válidas do OpenSSL para TLS 1.2 ou priority strings válidas do GnuTLS. Seus valores são passados para as funções SSL_CTX_set_cipher_list() ou gnutls_priority_init(), respectivamente. Critérios de seleção de ciphersuite para TLS 1.2/1.3 (GnuTLS), TLS 1.2 (OpenSSL)

Para substituir a seleção de ciphersuite nas utilitários zabbix_get e zabbix_sender - use os parâmetros de linha de comando:

  • --tls-cipher13
  • --tls-cipher

Os novos parâmetros são opcionais. Se um parâmetro não for especificado, o valor padrão interno será usado. Se um parâmetro for definido, ele não pode estar vazio.

Se a configuração de um valor TLSCipher* na biblioteca de criptografia falhar, o server, proxy ou agent não será iniciado e um erro será registrado.

É importante entender quando cada parâmetro é aplicável.

Conexões de saída

O caso mais simples são as conexões de saída:

  • Para conexões de saída com certificado - use TLSCipherCert13 ou TLSCipherCert
  • Para conexões de saída com PSK - use TLSCipherPSK13 ou TLSCipherPSK
  • No caso das utilitários zabbix_get e zabbix_sender, os parâmetros de linha de comando --tls-cipher13 ou --tls-cipher podem ser usados (a criptografia é especificada de forma inequívoca com o parâmetro --tls-connect)
Conexões de entrada

É um pouco mais complicado com conexões de entrada porque as regras são específicas para componentes e configuração.

Para o Zabbix agent:

Configuração de conexão do agent Configuração de cifras
TLSConnect=cert TLSCipherCert, TLSCipherCert13
TLSConnect=psk TLSCipherPSK, TLSCipherPSK13
TLSAccept=cert TLSCipherCert, TLSCipherCert13
TLSAccept=psk TLSCipherPSK, TLSCipherPSK13
TLSAccept=cert,psk TLSCipherAll, TLSCipherAll13

Para o Zabbix server e proxy:

Configuração de conexão Configuração de cifras
Conexões de saída usando PSK TLSCipherPSK, TLSCipherPSK13
Conexões de entrada usando certificados TLSCipherAll, TLSCipherAll13
Conexões de entrada usando PSK se o server não tiver certificado TLSCipherPSK, TLSCipherPSK13
Conexões de entrada usando PSK se o server tiver certificado TLSCipherAll, TLSCipherAll13

É possível observar um padrão nas duas tabelas acima:

  • TLSCipherAll e TLSCipherAll13 podem ser especificados somente se uma lista combinada de conjuntos de cifras baseados em certificado e PSK for usada. Há dois casos em que isso ocorre: server (proxy) com um certificado configurado (os conjuntos de cifras PSK são sempre configurados no server, proxy se a biblioteca criptográfica oferecer suporte a PSK), agent configurado para aceitar conexões de entrada baseadas tanto em certificado quanto em PSK
  • em outros casos, TLSCipherCert* e/ou TLSCipherPSK* são suficientes

As tabelas a seguir mostram os valores padrão internos de TLSCipher*. Eles podem ser um bom ponto de partida para seus próprios valores personalizados.

Parameter GnuTLS 3.6.12
TLSCipherCert NONE:+VERS-TLS1.2:+ECDHE-RSA:+RSA:+AES-128-GCM:+AES-128-CBC:+AEAD:+SHA256:+SHA1:+CURVE-ALL:+COMP-NULL:+SIGN-ALL:+CTYPE-X.509
TLSCipherPSK NONE:+VERS-TLS1.2:+ECDHE-PSK:+PSK:+AES-128-GCM:+AES-128-CBC:+AEAD:+SHA256:+SHA1:+CURVE-ALL:+COMP-NULL:+SIGN-ALL
TLSCipherAll NONE:+VERS-TLS1.2:+ECDHE-RSA:+RSA:+ECDHE-PSK:+PSK:+AES-128-GCM:+AES-128-CBC:+AEAD:+SHA256:+SHA1:+CURVE-ALL:+COMP-NULL:+SIGN-ALL:+CTYPE-X.509
Parameter OpenSSL 1.1.1d 1
TLSCipherCert13
TLSCipherCert EECDH+aRSA+AES128:RSA+aRSA+AES128
TLSCipherPSK13 TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
TLSCipherPSK kECDHEPSK+AES128:kPSK+AES128
TLSCipherAll13
TLSCipherAll EECDH+aRSA+AES128:RSA+aRSA+AES128:kECDHEPSK+AES128:kPSK+AES128

1 Os valores padrão são diferentes para versões mais antigas do OpenSSL (1.0.1, 1.0.2, 1.1.0), para o LibreSSL e se o OpenSSL for compilado sem suporte a PSK.

Exemplos de conjuntos de cifras configurados pelo usuário

Veja abaixo os seguintes exemplos de conjuntos de cifras configurados pelo usuário:

Testando strings de cifra e permitindo apenas ciphersuites PFS

Para ver quais ciphersuites foram selecionadas, você precisa definir DebugLevel=4 no arquivo de configuração ou usar a opção -vv para zabbix_sender.

Pode ser necessário fazer alguns testes com os parâmetros TLSCipher* antes de obter as ciphersuites desejadas. É inconveniente reiniciar o Zabbix server, proxy ou agent várias vezes apenas para ajustar os parâmetros TLSCipher*. Opções mais práticas são usar zabbix_sender ou o comando openssl. Vamos mostrar ambos.

1. Usando zabbix_sender.

Vamos criar um arquivo de configuração de teste, por exemplo, /home/zabbix/test.conf, com a sintaxe de um arquivo zabbix_agentd.conf:

  Hostname=nonexisting
  ServerActive=nonexisting

  TLSConnect=cert
  TLSCAFile=/home/zabbix/ca.crt
  TLSCertFile=/home/zabbix/agent.crt
  TLSKeyFile=/home/zabbix/agent.key
  TLSPSKIdentity=nonexisting
  TLSPSKFile=/home/zabbix/agent.psk

Você precisa de certificados válidos de CA e do agent, além de PSK para este exemplo. Ajuste os caminhos e nomes dos arquivos de certificado e PSK para o seu ambiente.

Se você não estiver usando certificados, apenas PSK, pode criar um arquivo de teste mais simples:

  Hostname=nonexisting
  ServerActive=nonexisting

  TLSConnect=psk
  TLSPSKIdentity=nonexisting
  TLSPSKFile=/home/zabbix/agentd.psk

As ciphersuites selecionadas podem ser vistas executando zabbix_sender (exemplo compilado com OpenSSL 1.1.d):

  $ zabbix_sender -vv -c /home/zabbix/test.conf -k nonexisting_item -o 1 2>&1 | grep ciphersuites
  zabbix_sender [41271]: DEBUG: zbx_tls_init_child() certificate ciphersuites: TLS_AES_256_GCM_SHA384 TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-RSA-AES128-GCM-SHA256 ECDHE-RSA-AES128-SHA256 ECDHE-RSA-AES128-SHA AES128-GCM-SHA256 AES128-CCM8 AES128-CCM AES128-SHA256 AES128-SHA
  zabbix_sender [41271]: DEBUG: zbx_tls_init_child() PSK ciphersuites: TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-PSK-AES128-CBC-SHA256 ECDHE-PSK-AES128-CBC-SHA PSK-AES128-GCM-SHA256 PSK-AES128-CCM8 PSK-AES128-CCM PSK-AES128-CBC-SHA256 PSK-AES128-CBC-SHA
  zabbix_sender [41271]: DEBUG: zbx_tls_init_child() certificate and PSK ciphersuites: TLS_AES_256_GCM_SHA384 TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-RSA-AES128-GCM-SHA256 ECDHE-RSA-AES128-SHA256 ECDHE-RSA-AES128-SHA AES128-GCM-SHA256 AES128-CCM8 AES128-CCM AES128-SHA256 AES128-SHA ECDHE-PSK-AES128-CBC-SHA256 ECDHE-PSK-AES128-CBC-SHA PSK-AES128-GCM-SHA256 PSK-AES128-CCM8 PSK-AES128-CCM PSK-AES128-CBC-SHA256 PSK-AES128-CBC-SHA

Aqui você vê as ciphersuites selecionadas por padrão. Esses valores padrão são escolhidos para garantir interoperabilidade com agents do Zabbix executando em sistemas com versões mais antigas do OpenSSL (a partir de 1.0.1).

Em sistemas mais novos, você pode optar por reforçar a segurança permitindo apenas algumas ciphersuites, por exemplo, apenas ciphersuites com PFS (Perfect Forward Secrecy). Vamos tentar permitir apenas ciphersuites com PFS usando os parâmetros TLSCipher*.

O resultado não será interoperável com sistemas que usam OpenSSL 1.0.1 e 1.0.2, se PSK for usado. A criptografia baseada em certificado deve funcionar.

Adicione duas linhas ao arquivo de configuração test.conf:

  TLSCipherCert=EECDH+aRSA+AES128
  TLSCipherPSK=kECDHEPSK+AES128

e teste novamente:

  $ zabbix_sender -vv -c /home/zabbix/test.conf -k nonexisting_item -o 1 2>&1 | grep ciphersuites            
  zabbix_sender [42892]: DEBUG: zbx_tls_init_child() certificate ciphersuites: TLS_AES_256_GCM_SHA384 TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-RSA-AES128-GCM-SHA256 ECDHE-RSA-AES128-SHA256 ECDHE-RSA-AES128-SHA        
  zabbix_sender [42892]: DEBUG: zbx_tls_init_child() PSK ciphersuites: TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-PSK-AES128-CBC-SHA256 ECDHE-PSK-AES128-CBC-SHA        
  zabbix_sender [42892]: DEBUG: zbx_tls_init_child() certificate and PSK ciphersuites: TLS_AES_256_GCM_SHA384 TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-RSA-AES128-GCM-SHA256 ECDHE-RSA-AES128-SHA256 ECDHE-RSA-AES128-SHA AES128-GCM-SHA256 AES128-CCM8 AES128-CCM AES128-SHA256 AES128-SHA ECDHE-PSK-AES128-CBC-SHA256 ECDHE-PSK-AES128-CBC-SHA PSK-AES128-GCM-SHA256 PSK-AES128-CCM8 PSK-AES128-CCM PSK-AES128-CBC-SHA256 PSK-AES128-CBC-SHA

As listas "certificate ciphersuites" e "PSK ciphersuites" mudaram

  • elas estão mais curtas do que antes, contendo apenas ciphersuites TLS 1.3 e ciphersuites TLS 1.2 ECDHE-* como esperado.

2. TLSCipherAll e TLSCipherAll13 não podem ser testados com zabbix_sender; eles não afetam o valor "certificate and PSK ciphersuites" mostrado no exemplo acima. Para ajustar TLSCipherAll e TLSCipherAll13, você precisa fazer testes com o agent, proxy ou server.

Portanto, para permitir apenas ciphersuites PFS, talvez seja necessário adicionar até três parâmetros

  TLSCipherCert=EECDH+aRSA+AES128
  TLSCipherPSK=kECDHEPSK+AES128
  TLSCipherAll=EECDH+aRSA+AES128:kECDHEPSK+AES128

ao zabbix_agentd.conf, zabbix_proxy.conf e zabbix_server_conf se cada um deles tiver um certificado configurado e o agent também tiver PSK.

Se o seu ambiente Zabbix usar apenas criptografia baseada em PSK e nenhum certificado, então apenas um:

  TLSCipherPSK=kECDHEPSK+AES128

Agora que você entende como isso funciona, pode testar a seleção de ciphersuites até mesmo fora do Zabbix, com o comando openssl. Vamos testar os três valores de parâmetro TLSCipher*:

  $ openssl ciphers EECDH+aRSA+AES128 | sed 's/:/ /g'
  TLS_AES_256_GCM_SHA384 TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-RSA-AES128-GCM-SHA256 ECDHE-RSA-AES128-SHA256 ECDHE-RSA-AES128-SHA
  $ openssl ciphers kECDHEPSK+AES128 | sed 's/:/ /g'
  TLS_AES_256_GCM_SHA384 TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-PSK-AES128-CBC-SHA256 ECDHE-PSK-AES128-CBC-SHA
  $ openssl ciphers EECDH+aRSA+AES128:kECDHEPSK+AES128 | sed 's/:/ /g'
  TLS_AES_256_GCM_SHA384 TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-RSA-AES128-GCM-SHA256 ECDHE-RSA-AES128-SHA256 ECDHE-RSA-AES128-SHA ECDHE-PSK-AES128-CBC-SHA256 ECDHE-PSK-AES128-CBC-SHA

Você pode preferir openssl ciphers com a opção -V para uma saída mais detalhada:

  $ openssl ciphers -V EECDH+aRSA+AES128:kECDHEPSK+AES128
            0x13,0x02 - TLS_AES_256_GCM_SHA384  TLSv1.3 Kx=any      Au=any  Enc=AESGCM(256) Mac=AEAD
            0x13,0x03 - TLS_CHACHA20_POLY1305_SHA256 TLSv1.3 Kx=any      Au=any  Enc=CHACHA20/POLY1305(256) Mac=AEAD
            0x13,0x01 - TLS_AES_128_GCM_SHA256  TLSv1.3 Kx=any      Au=any  Enc=AESGCM(128) Mac=AEAD
            0xC0,0x2F - ECDHE-RSA-AES128-GCM-SHA256 TLSv1.2 Kx=ECDH     Au=RSA  Enc=AESGCM(128) Mac=AEAD
            0xC0,0x27 - ECDHE-RSA-AES128-SHA256 TLSv1.2 Kx=ECDH     Au=RSA  Enc=AES(128)  Mac=SHA256
            0xC0,0x13 - ECDHE-RSA-AES128-SHA    TLSv1 Kx=ECDH     Au=RSA  Enc=AES(128)  Mac=SHA1
            0xC0,0x37 - ECDHE-PSK-AES128-CBC-SHA256 TLSv1 Kx=ECDHEPSK Au=PSK  Enc=AES(128)  Mac=SHA256
            0xC0,0x35 - ECDHE-PSK-AES128-CBC-SHA TLSv1 Kx=ECDHEPSK Au=PSK  Enc=AES(128)  Mac=SHA1

Da mesma forma, você pode testar as strings de prioridade do GnuTLS:

  $ gnutls-cli -l --priority=NONE:+VERS-TLS1.2:+ECDHE-RSA:+AES-128-GCM:+AES-128-CBC:+AEAD:+SHA256:+CURVE-ALL:+COMP-NULL:+SIGN-ALL:+CTYPE-X.509
  Cipher suites for NONE:+VERS-TLS1.2:+ECDHE-RSA:+AES-128-GCM:+AES-128-CBC:+AEAD:+SHA256:+CURVE-ALL:+COMP-NULL:+SIGN-ALL:+CTYPE-X.509
  TLS_ECDHE_RSA_AES_128_GCM_SHA256                        0xc0, 0x2f      TLS1.2
  TLS_ECDHE_RSA_AES_128_CBC_SHA256                        0xc0, 0x27      TLS1.2

  Protocols: VERS-TLS1.2
  Ciphers: AES-128-GCM, AES-128-CBC
  MACs: AEAD, SHA256
  Key Exchange Algorithms: ECDHE-RSA
  Groups: GROUP-SECP256R1, GROUP-SECP384R1, GROUP-SECP521R1, GROUP-X25519, GROUP-X448, GROUP-FFDHE2048, GROUP-FFDHE3072, GROUP-FFDHE4096, GROUP-FFDHE6144, GROUP-FFDHE8192
  PK-signatures: SIGN-RSA-SHA256, SIGN-RSA-PSS-SHA256, SIGN-RSA-PSS-RSAE-SHA256, SIGN-ECDSA-SHA256, SIGN-ECDSA-SECP256R1-SHA256, SIGN-EdDSA-Ed25519, SIGN-RSA-SHA384, SIGN-RSA-PSS-SHA384, SIGN-RSA-PSS-RSAE-SHA384, SIGN-ECDSA-SHA384, SIGN-ECDSA-SECP384R1-SHA384, SIGN-EdDSA-Ed448, SIGN-RSA-SHA512, SIGN-RSA-PSS-SHA512, SIGN-RSA-PSS-RSAE-SHA512, SIGN-ECDSA-SHA512, SIGN-ECDSA-SECP521R1-SHA512, SIGN-RSA-SHA1, SIGN-ECDSA-SHA1
Mudando de AES128 para AES256

O Zabbix usa AES128 como padrão interno para dados. Vamos supor que você esteja usando certificados e queira mudar para AES256, no OpenSSL 1.1.1.

Isso pode ser feito adicionando os respectivos parâmetros em zabbix_server.conf:

  TLSCAFile=/home/zabbix/ca.crt
  TLSCertFile=/home/zabbix/server.crt
  TLSKeyFile=/home/zabbix/server.key
  TLSCipherCert13=TLS_AES_256_GCM_SHA384
  TLSCipherCert=EECDH+aRSA+AES256:-SHA1:-SHA384
  TLSCipherPSK13=TLS_CHACHA20_POLY1305_SHA256
  TLSCipherPSK=kECDHEPSK+AES256:-SHA1
  TLSCipherAll13=TLS_AES_256_GCM_SHA384
  TLSCipherAll=EECDH+aRSA+AES256:-SHA1:-SHA384

Embora apenas os ciphersuites relacionados a certificados sejam usados, os parâmetros TLSCipherPSK* também são definidos para evitar seus valores padrão, que incluem cifras menos seguras para maior interoperabilidade. Os ciphersuites PSK não podem ser completamente desabilitados no server/proxy.

E em zabbix_agentd.conf:

  TLSConnect=cert
  TLSAccept=cert
  TLSCAFile=/home/zabbix/ca.crt
  TLSCertFile=/home/zabbix/agent.crt
  TLSKeyFile=/home/zabbix/agent.key
  TLSCipherCert13=TLS_AES_256_GCM_SHA384
  TLSCipherCert=EECDH+aRSA+AES256:-SHA1:-SHA384