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 suportar criptografia, o Zabbix deve ser compilado e vinculado com uma das bibliotecas de criptografia 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 um substituto 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, apenas certificados podem ser usados.

Você pode saber mais sobre como configurar SSL para o frontend do Zabbix consultando estas melhores práticas.

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

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

Por exemplo, para configurar os fontes para server e 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 de criptografia (por exemplo, um server com OpenSSL, um agent com GnuTLS).

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

Gerenciamento de criptografia de conexão

As conexões no Zabbix podem usar:

Existem 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 proxy Zabbix (em modo ativo, especifica apenas conexões para o server) e do agent Zabbix (para checagens ativas). No frontend do Zabbix, o equivalente ao TLSConnect é o campo Conexões para o host em Coleta de dados → Hosts → <algum host> → aba Criptografia e o campo Conexões para o proxy em Administração → Proxies → <algum proxy> → aba Criptografia. 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 proxy Zabbix (em modo passivo, especifica apenas conexões do server) e do agent Zabbix (para checagens passivas). No frontend do Zabbix, o equivalente ao TLSAccept é o campo Conexões do host em Coleta de dados → Hosts → <algum host> → aba Criptografia e o campo Conexões do proxy em Administração → Proxies → <algum proxy> → aba Criptografia.

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

Defina TLSAccept=unencrypted,cert no arquivo de configuração do agent e reinicie o agent Zabbix
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 aba Coleta de dados → Hosts → <algum host> → Criptografia definindo Conexões para o host como "Certificado".
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 para 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 agent Zabbix. Agora o agent aceitará apenas conexões criptografadas baseadas em certificado. Conexões sem criptografia e baseadas em PSK serão rejeitadas.

Da mesma forma, funciona no server e no proxy. Se no frontend do Zabbix, na configuração do host, Conexões do host estiver definido como "Certificado", então apenas conexões criptografadas baseadas em certificado serão aceitas do agent (checagens ativas) e do zabbix_sender (itens trapper).

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

A configuração de criptografia para cada host é exibida no frontend do Zabbix, em Coleta de dados → Hosts na coluna Criptografia do agent. Por exemplo:

Exemplo	Conexões para o host	Conexões permitidas do host	Conexões rejeitadas do host
$none\_none.png$	Sem criptografia	Sem criptografia	Criptografadas, baseadas em certificado e baseadas em PSK
$cert\_cert.png$	Criptografada, baseada em certificado	Criptografada, baseada em certificado	Sem criptografia e criptografada baseada em PSK
$psk\_psk.png$	Criptografada, baseada em PSK	Criptografada, baseada em PSK	Sem criptografia e criptografada baseada em certificado
$psk\_none\_psk.png$	Criptografada, baseada em PSK	Sem criptografia e criptografada baseada em PSK	Criptografada baseada em certificado
$cert\_all.png$	Criptografada, baseada em certificado	Sem criptografia, baseada em PSK ou baseada em certificado	-

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

zabbix_get e zabbix_sender com criptografia

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

Ciphersuites

As ciphersuites por padrão são configuradas internamente durante a inicialização do Zabbix.

Também são suportadas ciphersuites configuradas pelo usuário para GnuTLS e OpenSSL. Os usuários podem configurar ciphersuites de acordo com suas políticas de segurança. O uso deste recurso é opcional (as ciphersuites padrão ainda funcionam).

Para bibliotecas de criptografia compiladas com as configurações padrão, as regras internas do Zabbix normalmente resultam nas seguintes ciphersuites (em ordem da maior para a menor prioridade):

Biblioteca	Ciphersuites de certificado	Ciphersuites 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.
Seleção de ciphersuite para certificados	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.
Seleção de ciphersuite para PSK	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.
Lista combinada de ciphersuites para certificado e PSK	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 agent do Zabbix:

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

Para o server e proxy do Zabbix:

Configuração de conexão	Configuração de cifra
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

Algum padrão pode ser visto nas duas tabelas acima:

TLSCipherAll e TLSCipherAll13 só podem ser especificados se uma lista combinada de ciphersuites baseadas em certificado e PSK for usada. Existem dois casos em que isso ocorre: server (proxy) com um certificado configurado (ciphersuites PSK são sempre configuradas no server, proxy se a biblioteca de criptografia suportar PSK), agent configurado para aceitar conexões de entrada baseadas em certificado e PSK
nos outros casos, TLSCipherCert* e/ou TLSCipherPSK* são suficientes

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

Parâmetro	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

Parâmetro	OpenSSL 1.1.1d ¹
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

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

Exemplos de ciphersuites configuradas pelo usuário

Veja abaixo os seguintes exemplos de ciphersuites configuradas pelo usuário:

Testando strings de cifra e permitindo apenas ciphersuites PFS
Trocando de AES128 para AES256

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 o zabbix_sender.

Pode ser necessário experimentar 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 convenientes são usar o zabbix_sender ou o comando openssl. Vamos mostrar ambos.

1. Usando o 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 CA e agent válidos e 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, mas 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 o 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 a interoperabilidade com agents Zabbix executando em sistemas com versões mais antigas do OpenSSL (a partir de 1.0.1).

Com sistemas mais recentes, 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 usando 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 experimentar com o agent, proxy ou server.

Portanto, para permitir apenas ciphersuites PFS, pode ser 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 não certificados, então apenas um:

  TLSCipherPSK=kECDHEPSK+AES128

Agora que você entende como funciona, pode testar a seleção de ciphersuite mesmo fora do Zabbix, com o comando openssl. Vamos testar todos 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 para 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

What’s next?

1 Usando certificados

Docs

15 Criptografia

Visão geral