[comment]: # translation:outdated

[comment]: # ({822969ff-822969ff})
# 17. Criptografia

[comment]: # ({/822969ff-822969ff})

[comment]: # ({0b118c23-0b118c23})
#### Visão geral

Zabbix suporta comunicações criptografadas entre componentes Zabbix usando
Protocolo Transport Layer Security (TLS) v.1.2 e 1.3 (dependendo do
biblioteca de criptografia). Criptografia baseada em certificado e baseada em chave pré-compartilhada
é suportado.

A criptografia pode ser configurada para conexões:

- Entre servidor Zabbix, proxy Zabbix, agente Zabbix, zabbix\_sender
    e utilitários zabbix\_get
- Para o banco de dados Zabbix [do frontend Zabbix e
    servidor/proxy](/manual/appendix/install/db_encrypt)

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

- Alguns proxies e agentes podem ser configurados para usar certificados
    criptografia com o servidor, enquanto outros podem usar
    criptografia baseada em chave, e ainda outros continuam com não criptografado
    comunicações (como antes)
- Servidor (proxy) pode usar diferentes configurações de criptografia para
    diferentes anfitriões

Os programas daemon Zabbix usam uma porta de escuta para
conexões de entrada não criptografadas. Adicionar uma criptografia não requer
abrindo novas portas em firewalls.

[comment]: # ({/0b118c23-0b118c23})

[comment]: # ({bdc6b202-bdc6b202})
#### Limitações

- As chaves privadas são armazenadas em texto simples em arquivos legíveis pelo Zabbix
    componentes durante a inicialização
- Chaves pré-compartilhadas são inseridas no frontend do Zabbix e armazenadas no Zabbix
    banco de dados em texto simples
- A criptografia integrada não protege as comunicações:
    - Entre o servidor web rodando o frontend Zabbix e a web do usuário
        navegador
    - Entre o frontend Zabbix e o servidor Zabbix
- Atualmente, cada conexão criptografada é aberta com um handshake TLS completo,
    nenhum cache de sessão e tickets são implementados
- A adição de criptografia aumenta o tempo para verificações e ações de itens,
    dependendo da latência da rede:
    - Por exemplo, se o atraso do pacote for de 100ms, abrir um TCP
        conexão e envio de solicitação não criptografada leva cerca de 200ms.
        Com criptografia são adicionados cerca de 1000 ms para estabelecer o TLS
        conexão;
    - Os tempos limite podem precisar ser aumentados, caso contrário, alguns itens e
        ações que executam scripts remotos em agentes podem funcionar com
        conexões não criptografadas, mas falham com o tempo limite com criptografado.
- A criptografia não é suportada por [network
    descoberta](/manual/discovery/network_discovery). Verificações do agente Zabbix
    realizada pela descoberta de rede não será criptografada e se o Zabbix
    agente está configurado para rejeitar conexões não criptografadas, tais verificações
    não terá sucesso.

[comment]: # ({/bdc6b202-bdc6b202})

[comment]: # ({ba7ecc58-ba7ecc58})
#### Compilando Zabbix com suporte a criptografia

Para suportar a criptografia, o Zabbix deve ser compilado e vinculado a um dos
bibliotecas de criptografia suportadas:

- GnuTLS - da versão 3.1.18
- OpenSSL - versões 1.0.1, 1.0.2, 1.1.0, 1.1.1
- LibreSSL - testado com as versões 2.7.4, 2.8.2:
    - LibreSSL 2.6.x não é suportado
    - O 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 Zabbix compilados com LibreSSL não poderão usar
        PSK, somente certificados podem ser usados.

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

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

Por exemplo, para configurar as origens para servidor e agente 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 Zabbix podem ser compilados com diferentes criptomoedas
bibliotecas (por exemplo, um servidor com *OpenSSL*, um agente com *GnuTLS*).

::: não importante
 Se você planeja usar chaves pré-compartilhadas (PSK),
considere usar bibliotecas *GnuTLS* ou *OpenSSL 1.1.0* (ou mais recente) em
Componentes Zabbix usando PSKs. Bibliotecas *GnuTLS* e *OpenSSL 1.1.0*
suporta conjuntos de cifras PSK com [Perfect Forward
Sigilo](https://en.wikipedia.org/wiki/Forward_secrecy#Perfect_forward_secrecy_.28PFS.29).
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
Segredo.
:::

[comment]: # ({/ba7ecc58-ba7ecc58})

[comment]: # ({2d0e2b80-2d0e2b80})
#### Gerenciamento de criptografia de conexão

Conexões no Zabbix podem usar:

- sem criptografia (padrão)
- [baseado em certificado RSA
    criptografia](/manual/encryption/using_certificates)
- [criptografia baseada em PSK](/manual/encryption/using_pre_shared_keys)

Existem dois parâmetros importantes usados ​​para especificar a criptografia entre
Componentes do Zabbix:

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

`TLSConnect` é usado nos arquivos de configuração do proxy Zabbix (no
modo ativo, especifica apenas conexões com o servidor) e agente Zabbix (para
verificações ativas). No frontend do Zabbix, o equivalente do TLSConnect é o
*Conexões ao host* campo em *Configuração → Hosts → <alguns
host> → guia Criptografia* e o campo *Conexões ao proxy* em
*Administração → Proxies → <algum proxy> → guia Criptografia*. Se o
tipo de criptografia configurado para falha de conexão, nenhuma outra criptografia
tipos serão tentados.

`TLSAccept` é usado nos arquivos de configuração do proxy Zabbix (no
modo passivo, especifica apenas conexões do servidor) e agente Zabbix
(para verificações passivas). No frontend do Zabbix, o equivalente do TLSAccept é o
*Conexões do host* campo em *Configuração → Hosts → <alguns
host> → aba Criptografia* e o campo *Conexões do proxy* em
*Administração → Proxies → <algum proxy> → guia Criptografia*.

Normalmente você configura apenas um tipo de criptografia para
criptografias. Mas você pode querer mudar o tipo de criptografia, por exemplo a partir de
descriptografado para baseado em certificado com tempo de inatividade e reversão mínimos
possibilidade. Para alcançar isto:

- Defina `TLSAccept=unencrypted,cert` no arquivo de configuração do agente e
    reinicie o agente Zabbix
- Teste a conexão com o zabbix\_get para o agente usando o certificado. Se
    funciona, você pode reconfigurar a criptografia para esse agente no Zabbix
    frontend na *Configuração → Hosts → <algum host> →
    Aba Criptografia* definindo *Conexões ao host* para "Certificado".
- Quando o cache de configuração do servidor é atualizado (e proxy
    configuração é atualizada se o host for monitorado por proxy) então
    as conexões com esse agente serão criptografadas
- Se tudo funcionar como esperado, você pode definir `TLSAccept=cert` no
    arquivo de configuração do agente e reinicie o agente Zabbix. Agora o agente
    aceitará apenas conexões baseadas em certificados criptografados.
    Conexões não criptografadas e baseadas em PSK serão rejeitadas.

De maneira semelhante, funciona no servidor e no proxy. Se no Zabbix frontend em
configuração do host *Conexões do host* é definido como "Certificado" e
somente conexões criptografadas baseadas em certificado serão aceitas do
agent (verificações ativas) e zabbix\_sender (itens do 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 configurá-lo assimetricamente, por ex. baseado em certificado
criptografia para conexões de entrada e baseadas em PSK para conexões de saída.

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

|Exemplo|Conexões ao host|Conexões permitidas do host|Conexões rejeitadas do host|
|-------|-------------------|--------------------- --------|------------------------------|
|![none\_none.png](../../assets/en/manual/encryption/none_none.png)|Unencrypted|Unencrypted|Criptografado, certificado e criptografado com base em PSK|
|![cert\_cert.png](../../assets/en/manual/encryption/cert_cert.png)|Criptografado, baseado em certificado|Criptado, baseado em certificado|Não criptografado e criptografado com base em PSK|
|![psk\_psk.png](../../assets/en/manual/encryption/psk_psk.png)|Criptografado, baseado em PSK|Criptado, baseado em PSK|Não criptografado e criptografado com base em certificado|
|![psk\_none\_psk.png](../../assets/en/manual/encryption/psk_none_psk.png)|Criptografado, baseado em PSK|Criptografia não criptografada e baseada em PSK|Criptografia baseada em certificado|
|![cert\_all.png](../../assets/en/manual/encryption/cert_all.png)|Criptografado, baseado em certificado|Não criptografado, PSK ou criptografado baseado em certificado|\-|

::: não importante
As conexões não são criptografadas por padrão. Criptografia
deve ser configurado para cada host e proxy individualmente.
:::

[comment]: # ({/2d0e2b80-2d0e2b80})

[comment]: # ({ad15e6ff-ad15e6ff})
#### zabbix\_get e zabbix\_sender com criptografia

Veja [zabbix\_get](/manpages/zabbix_get) e
[zabbix\_sender](/manpages/zabbix_sender) manpages para usá-los com
criptografia.

[comment]: # ({/ad15e6ff-ad15e6ff})

[comment]: # ({be2996e2-be2996e2})
#### Ciphersuites

Ciphersuites por padrão são configurados internamente durante a inicialização do Zabbix
e, antes do Zabbix 4.0.19, 4.4.7, não são configuráveis ​​pelo usuário.

Desde o Zabbix 4.0.19, 4.4.7 também os ciphersuites configurados pelo usuário são
suportado para GnuTLS e OpenSSL. Os usuários podem
[configure](#user-configured_ciphersuites) ciphersuites de acordo com
suas políticas de segurança. O uso deste recurso é opcional (integrado
ciphersuites padrão ainda funcionam).

Para bibliotecas de criptografia compiladas com configurações padrão Zabbix built-in
regras normalmente resultam nos seguintes conjuntos de cifras (em ordem de
prioridade mais alta para mais baixa):

|Biblioteca|Certificate ciphersuites|PSK ciphersuites|
|-------|------------------------|---------------- |
|*GnuTLS 3.1.18*|TLS\_ECDHE\_RSA\_AES\_128\_GCM\_SHA256<br>TLS\_ECDHE\_RSA\_AES\_128\_CBC\_SHA256<br>TLS\_ECDHE\_RSA\_AES\_128\ _CBC\_SHA1<br>TLS\_RSA\_AES\_128\_GCM\_SHA256<br>TLS\_RSA\_AES\_128\_CBC\_SHA256<br>TLS\_RSA\_AES\_128\_CBC\_SHA1|TLS\_ECDHE\ _PSK\_AES\_128\_CBC\_SHA256<br>TLS\_ECDHE\_PSK\_AES\_128\_CBC\_SHA1<br>TLS\_PSK\_AES\_128\_GCM\_SHA256<br>TLS\_PSK\_AES\_128\ _CBC\_SHA256<br>TLS\_PSK\_AES\_128\_CBC\_SHA1|
|*OpenSSL 1.0.2c*|ECDHE-RSA-AES128-GCM-SHA256<br>ECDHE-RSA-AES128-SHA256<br>ECDHE-RSA-AES128-SHA<br>AES128-GCM-SHA256<br>AES128- SHA256<br>AES128-SHA|PSK-AES128-CBC-SHA|
|*OpenSSL 1.1.0*|ECDHE-RSA-AES128-GCM-SHA256<br>ECDHE-RSA-AES128-SHA256<br>ECDHE-RSA-AES128-SHA<br>AES128-GCM-SHA256<br>AES128- CCM8<br>AES128-CCM<br>AES128-SHA256<br>AES128-SHA<br>|ECDHE-PSK-AES128-CBC-SHA256<br>ECDHE-PSK-AES128-CBC-SHA<br>PSK-AES128 -GCM-SHA256<br>PSK-AES128-CCM8<br>PSK-AES128-CCM<br>PSK-AES128-CBC-SHA256<br>PSK-AES128-CBC-SHA|
|*OpenSSL 1.1.1d*|TLS\_AES\_256\_GCM\_SHA384<br>TLS\_CHACHA20\_POLY1305\_SHA256<br>TLS\_AES\_128\_GCM\_SHA256<br>ECDHE-RSA-AES128-GCM- SHA256<br>ECDHE-RSA-AES128-SHA256<br>ECDHE-RSA-AES128-SHA<br>AES128-GCM-SHA256<br>AES128-CCM8<br>AES128-CCM<br>AES128-SHA256<br> AES128-SHA|TLS\_CHACHA20\_POLY1305\_SHA256<br>TLS\_AES\_128\_GCM\_SHA256<br>ECDHE-PSK-AES128-CBC-SHA256<br>ECDHE-PSK-AES128-CBC-SHA<br> PSK-AES128-GCM-SHA256<br>PSK-AES128-CCM8<br>PSK-AES128-CCM<br>PSK-AES128-CBC-SHA256<br>PSK-AES128-CBC-SHA|

[comment]: # ({/be2996e2-be2996e2})

[comment]: # ({b5e04652-b5e04652})
#### Ciphersuites configurados pelo usuário

Os critérios de seleção do conjunto de cifras integrados podem ser substituídos por
ciphersuites configurados pelo usuário.

::: não importante
Ciphersuites configurados pelo usuário é um recurso destinado
para usuários avançados que entendem conjuntos de criptografia TLS, sua segurança e
consequências de erros e que se sentem à vontade com o TLS
solução de problemas.
:::

Os critérios de seleção do ciphersuite integrados podem ser substituídos usando o
seguintes parâmetros:

|Substituir escopo|Parâmetro|Valor|Descrição|
|--------------|---------|-----|-----------|
|Seleção de Ciphersuite para certificados|TLSCipherCert13|Válido OpenSSL 1.1.1 [cipher strings](https://www.openssl.org/docs/man1.1.1/man1/ciphers.html) para protocolo TLS 1.3 (seus valores são passados ​​para a função OpenSSL SSL\_CTX\_set\_ciphersuites()).|Critérios de seleção de conjuntos de códigos baseados em certificados para TLS 1.3<br><br>Somente OpenSSL 1.1.1 ou mais recente.|
|^|TLSCipherCert|OpenSSL válido [strings de criptografia](https://www.openssl.org/docs/man1.1.1/man1/ciphers.html) para TLS 1.2 ou GnuTLS válido [strings de prioridade](https://gnutls .org/manual/html_node/Priority-Strings.html). 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 conjuntos de códigos baseados em certificados para TLS 1.2/1.3 (GnuTLS), TLS 1.2 (OpenSSL) |
|Seleção de Ciphersuite para PSK|TLSCipherPSK13|Válido OpenSSL 1.1.1 [cipher strings](https://www.openssl.org/docs/man1.1.1/man1/ciphers.html) para protocolo TLS 1.3 (seus valores são passados ​​para a função OpenSSL SSL\_CTX\_set\_ciphersuites()).|Critérios de seleção de conjuntos de códigos baseados em PSK para TLS 1.3<br><br>Somente OpenSSL 1.1.1 ou mais recente.|
|^|TLSCipherPSK|OpenSSL válido [strings de criptografia](https://www.openssl.org/docs/man1.1.1/man1/ciphers.html) para TLS 1.2 ou GnuTLS válido [strings de prioridade](https://gnutls .org/manual/html_node/Priority-Strings.html). 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 ciphersuite para certificado e PSK|TLSCipherAll13|Valid OpenSSL 1.1.1 [cipher strings](https://www.openssl.org/docs/man1.1.1/man1/ciphers.html) para 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<br><br>Somente OpenSSL 1.1.1 ou mais recente.|
|^|TLSCipherAll|OpenSSL válido [strings de criptografia](https://www.openssl.org/docs/man1.1.1/man1/ciphers.html) para TLS 1.2 ou GnuTLS válido [strings de prioridade](https://gnutls .org/manual/html_node/Priority-Strings.html). Seus valores são passados ​​para as funções SSL\_CTX\_set\_cipher\_list() ou gnutls\_priority\_init(), respectivamente.|Critérios de seleção do Ciphersuite para TLS 1.2/1.3 (GnuTLS), TLS 1.2 (OpenSSL)|

Para substituir a seleção do ciphersuite em
[zabbix\_get](/manpages/zabbix_get) e
[zabbix\_sender](/manpages/zabbix_sender) utilitários - use o
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 é usado. Se um parâmetro é definido, ele não pode ser
vazio.

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

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

[comment]: # ({/b5e04652-b5e04652})

[comment]: # ({a74c28c7-a74c28c7})
##### 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 e
     TLS CipherPSK
- No caso dos utilitários zabbix\_get e zabbix\_sender a linha de comando
     parâmetros `--tls-cipher13` e `--tls-cipher` podem ser usados
     (a criptografia é especificada sem ambiguidade com um `--tls-connect`
     parâmetro)

[comment]: # ({/a74c28c7-a74c28c7})

[comment]: # ({3edf3b2b-3edf3b2b})
##### 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 e
     TLS CipherPSK
- No caso dos utilitários zabbix\_get e zabbix\_sender a linha de comando
     parâmetros `--tls-cipher13` e `--tls-cipher` podem ser usados
     (a criptografia é especificada sem ambiguidade com um `--tls-connect`
     parâmetro)

[comment]: # ({/3edf3b2b-3edf3b2b})

[comment]: # ({bfb4ef88-bfb4ef88})
##### Testando strings de cifras e permitindo apenas conjuntos de cifras PFS

Para ver quais ciphersuites foram selecionados, você precisa definir
'DebugLevel=4' no arquivo de configuração, ou use a opção `-vv` para
zabbix\_sender.

Algumas experiências com os parâmetros `TLSCipher*` podem ser necessárias
antes de obter os conjuntos de cifras desejados. É inconveniente reiniciar
Servidor, proxy ou agente Zabbix várias vezes apenas para ajustar `TLSCipher*`
parâmetros. Opções mais convenientes estão usando zabbix\_sender ou o
comando `openssl`. Vamos mostrar os dois.

**1.** Usando zabbix\_sender.

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

      Nome do host=não existente
      ServerActive=inexistente
      
      TLSConnect=cert
      TLSCAFile=/home/zabbix/ca.crt
      TLSCertFile=/home/zabbix/agent.crt
      TLSKeyFile=/home/zabbix/agent.key
      TLSPSKIdentity=inexistente
      TLSPSKFile=/home/zabbix/agent.psk

Você precisa de certificados válidos de CA e agente e PSK para este exemplo.
Ajuste os caminhos e nomes de certificados e arquivos PSK para seu ambiente.

Se você não estiver usando certificados, mas apenas PSK, você pode simplificar
arquivo de teste:

      Nome do host=não existente
      ServerActive=inexistente
      
      TLSConnect=psk
      TLSPSKIdentity=inexistente
      TLSPSKFile=/home/zabbix/agentd.psk

Os ciphersuites selecionados podem ser vistos executando zabbix\_sender (exemplo
compilado com OpenSSL 1.1.d):

      $ zabbix_sender -vv -c /home/zabbix/test.conf -k item_não-existente -o 1 2>&1 | grep ciphersuites
      zabbix_sender [41271]: depuração: zbx_tls_init_child () ciphersuites de certificados: TLS_AES_256_GCM_SHA384 TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-RSA-AES128-MCG-SHA256 ECDHE-RSA-AES de 128 SHA256 ECDHE-RSA-AES128-SHA AES128-MCG-SHA256 AES128-CCM8 AES128-CCM AES128-SHA256 AES128-SHA
      zabbix_sender [41271]: depuração: zbx_tls_init_child () PSK ciphersuites: TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-PSK-AES de 128 CBC-SHA256 ECDHE-PSK-AES de 128 CBC-SHA PSK-AES128-MCG-SHA256 PSK-AES de 128 CCM8 PSK-AES de 128 CCM PSK-AES128-CBC-SHA256 PSK-AES128-CBC-SHA
      zabbix_sender [41271]: depuração: zbx_tls_init_child () certificado e PSK ciphersuites: TLS_AES_256_GCM_SHA384 TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-RSA-AES128-MCG-SHA256 ECDHE-RSA-AES de 128 SHA256 ECDHE-RSA-AES128-SHA AES128-MCG-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ê os conjuntos de cifras selecionados por padrão. Esses valores padrão
são escolhidos para garantir a interoperabilidade com os agentes Zabbix rodando em
sistemas com versões mais antigas do OpenSSL (de 1.0.1).

Com sistemas mais novos, você pode optar por aumentar a segurança permitindo apenas um
alguns conjuntos de cifras, e. apenas ciphersuites com PFS (Perfect Forward
Segredo). Vamos tentar permitir apenas ciphersuites com PFS usando
Parâmetros `TLSCipher*`.

::: não importante
O resultado não será interoperável com sistemas
usando OpenSSL 1.0.1 e 1.0.2, se PSK for usado. Baseado em certificado
criptografia deve funcionar.
:::

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

      TLSCipherCert=EECDH+aRSA+AES128
      TLS CipherPSK=kECDHEPSK+AES128

e teste novamente:

      $ zabbix_sender -vv -c /home/zabbix/test.conf -k item_não-existente -o 1 2>&1 | grep ciphersuites
      zabbix_sender [42892]: DEBUG: zbx_tls_init_child() certificados ciphersuites: TLS_AES_256_GCM_SHA384 TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-RSA-AES128-GCM-SHA256 ECDHE-RSA-AES1128-SHA256 ECDHE-RSA-AES1128-SHA256
      zabbix_sender [42892]: DEBUG: zbx_tls_init_child() Ciphersuites PSK: TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-PSK-AES128-CBC-SHA256 ECDHE-PSK-AES128-CBC-SHA
      zabbix_sender [42892]: depuração: zbx_tls_init_child () certificado e PSK ciphersuites: TLS_AES_256_GCM_SHA384 TLS_CHACHA20_POLY1305_SHA256 TLS_AES_128_GCM_SHA256 ECDHE-RSA-AES128-MCG-SHA256 ECDHE-RSA-AES de 128 SHA256 ECDHE-RSA-AES128-SHA AES128-MCG-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" foram alteradas
- eles são mais curtos do que antes, contendo apenas conjuntos de cifras TLS 1.3 e
TLS 1.2 ECDHE-\* ciphersuites conforme esperado.

**2.** TLSCipherAll e TLSCipherAll13 não podem ser testados com
zabbix\_sender; eles não afetam "certificados e conjuntos de cifras PSK"
valor mostrado no exemplo acima. Para ajustar TLScipherAll e
TLSCipherAll13 você precisa experimentar com o agente, proxy ou servidor.

Portanto, para permitir apenas conjuntos de cifras PFS, você pode precisar adicionar até três
parâmetros

      TLSCipherCert=EECDH+aRSA+AES128
      TLS CipherPSK=kECDHEPSK+AES128
      TLSCipherAll=EECDH+aRSA+AES128:kECDHEPSK+AES128

para zabbix\_agentd.conf, zabbix\_proxy.c

[comment]: # ({/bfb4ef88-bfb4ef88})

[comment]: # ({a549cda7-a549cda7})
##### Mudando de AES128 para AES256

O Zabbix usa o AES128 como padrão interno para dados. Vamos supor que você
está usando certificados e deseja 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
      TLSipherPSK13=TLS_CHACHA20_POLY1305_SHA256
      TLSCipherPSK=kECDHEPSK+AES256:-SHA1
      TLSipherAll13=TLS_AES_256_GCM_SHA384
      TLSCipherAll=EECDH+aRSA+AES256:-SHA1:-SHA384

::: não importante
Embora apenas conjuntos de criptografia relacionados a certificados
será usado, os parâmetros `TLSCipherPSK*` também são definidos para evitar
seus valores padrão que incluem cifras menos seguras para
interoperabilidade. Ciphersuites PSK não podem ser completamente desabilitados em
servidor/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

[comment]: # ({/a549cda7-a549cda7})