Zabbix obsługuje szyfrowaną komunikację między komponentami Zabbix z użyciem protokołu Transport Layer Security (TLS) w wersji 1.2 i 1.3 (w zależności od biblioteki kryptograficznej). Obsługiwane jest szyfrowanie oparte na certyfikatach oraz na kluczach współdzielonych.

Szyfrowanie można skonfigurować dla połączeń:

Między Zabbix server, Zabbix proxy, Zabbix agent, usługą Zabbix web service oraz narzędziami zabbix_sender i zabbix_get
Z bazą danych Zabbix z poziomu Zabbix frontend oraz server/proxy
Między Zabbix frontend a Zabbix server

Szyfrowanie jest opcjonalne i można je skonfigurować dla poszczególnych komponentów:

Niektóre proxy i agenty mogą być skonfigurowane do używania szyfrowania opartego na certyfikatach w komunikacji z serwerem, podczas gdy inne mogą używać szyfrowania opartego na kluczach współdzielonych, a jeszcze inne mogą nadal korzystać z nieszyfrowanej komunikacji (jak dotychczas).
Serwer (proxy) może używać różnych konfiguracji szyfrowania dla różnych hostów.

Programy daemon Zabbix używają jednego portu nasłuchującego zarówno dla szyfrowanych, jak i nieszyfrowanych połączeń przychodzących. Dodanie szyfrowania nie wymaga otwierania nowych portów w zaporach sieciowych.

Ograniczenia

Klucze prywatne są przechowywane w postaci zwykłego tekstu w plikach dostępnych do odczytu przez komponenty Zabbix podczas uruchamiania.
Klucze współdzielone są wprowadzane w Zabbix frontend i przechowywane w bazie danych Zabbix w postaci zwykłego tekstu.
Wbudowane szyfrowanie nie chroni komunikacji między serwerem WWW uruchamiającym Zabbix frontend a przeglądarką internetową użytkownika.
Obecnie każde szyfrowane połączenie jest otwierane z pełnym uzgadnianiem TLS; nie są zaimplementowane buforowanie sesji ani bilety.
Dodanie szyfrowania wydłuża czas sprawdzania pozycji i wykonywania akcji, w zależności od opóźnień sieciowych:
- Na przykład, jeśli opóźnienie pakietów wynosi 100 ms, to otwarcie połączenia TCP i wysłanie niezaszyfrowanego żądania zajmuje około 200 ms. Przy szyfrowaniu dochodzi około 1000 ms na ustanowienie połączenia TLS.
- Może być konieczne zwiększenie limitów czasu; w przeciwnym razie niektóre pozycje i akcje uruchamiające zdalne skrypty na agentach mogą działać przy połączeniach nieszyfrowanych, ale kończyć się błędem przekroczenia limitu czasu przy połączeniach szyfrowanych.
Szyfrowanie nie jest obsługiwane przez wykrywanie sieci. Kontrole Zabbix agent wykonywane przez wykrywanie sieci będą nieszyfrowane, a jeśli Zabbix agent jest skonfigurowany tak, aby odrzucać nieszyfrowane połączenia, takie kontrole nie zakończą się powodzeniem.

Kompilowanie Zabbix z obsługą szyfrowania

Aby obsługiwać szyfrowanie, Zabbix musi zostać skompilowany i połączony z jedną z obsługiwanych bibliotek kryptograficznych:

GnuTLS - od wersji 3.1.18
OpenSSL - wersje 1.0.1, 1.0.2, 1.1.0, 1.1.1, 3.0.x
LibreSSL - testowano z wersjami 2.7.4, 2.8.2:
- LibreSSL 2.6.x nie jest obsługiwany
- LibreSSL jest obsługiwany jako kompatybilny zamiennik OpenSSL; nowe funkcje API tls_*() specyficzne dla LibreSSL nie są używane. Komponenty Zabbix skompilowane z LibreSSL nie będą mogły używać PSK, będzie można używać wyłącznie certyfikatów.

Więcej informacji o konfiguracji SSL dla frontend Zabbix można znaleźć w tych najlepszych praktykach.

Bibliotekę wybiera się przez podanie odpowiedniej opcji do skryptu „configure”:

--with-gnutls[=DIR]
--with-openssl[=DIR] (używane również dla LibreSSL)

Na przykład, aby skonfigurować źródła dla serwer i agent z użyciem OpenSSL, można użyć polecenia podobnego do poniższego:

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

Różne komponenty Zabbix mogą być kompilowane z różnymi bibliotekami kryptograficznymi (np. serwer z OpenSSL, agent z GnuTLS).

Jeśli planujesz używać kluczy współdzielonych (PSK), rozważ użycie bibliotek GnuTLS lub OpenSSL 1.1.0 (albo nowszych) w komponentach Zabbix korzystających z PSK. Biblioteki GnuTLS i OpenSSL 1.1.0 obsługują pakiety szyfrów PSK z Perfect Forward Secrecy. Starsze wersje biblioteki OpenSSL (1.0.1, 1.0.2c) również obsługują PSK, ale dostępne pakiety szyfrów PSK nie zapewniają Perfect Forward Secrecy.

Zarządzanie szyfrowaniem połączeń

Połączenia w Zabbix mogą używać:

braku szyfrowania (domyślnie)
szyfrowania opartego na certyfikatach RSA
szyfrowania opartego na PSK

Istnieją dwa ważne parametry używane do określania szyfrowania między komponentami Zabbix:

TLSConnect - określa, jakiego szyfrowania używać dla połączeń wychodzących (bez szyfrowania, PSK lub certyfikat)
TLSAccept - określa, jakie typy połączeń są dozwolone dla połączeń przychodzących (bez szyfrowania, PSK lub certyfikat). Można podać jedną lub więcej wartości.

TLSConnect jest używany w plikach konfiguracyjnych Zabbix proxy (w trybie aktywnym określa tylko połączenia do serwer) oraz Zabbix agent (dla aktywnych kontroli). W Zabbix frontend odpowiednikiem TLSConnect jest pole Connections to host na karcie Data collection → Hosts → <some host> → Encryption oraz pole Connections to proxy na karcie Administration → Proxies → <some proxy> → Encryption. Jeśli skonfigurowany typ szyfrowania dla połączenia zawiedzie, żadne inne typy szyfrowania nie będą próbowane.

TLSAccept jest używany w plikach konfiguracyjnych Zabbix proxy (w trybie pasywnym określa tylko połączenia z serwer) oraz Zabbix agent (dla pasywnych kontroli). W Zabbix frontend odpowiednikiem TLSAccept jest pole Connections from host na karcie Data collection → Hosts → <some host> → Encryption oraz pole Connections from proxy na karcie Administration → Proxies → <some proxy> → Encryption.

Zwykle konfiguruje się tylko jeden typ szyfrowania dla połączeń przychodzących. Możesz jednak chcieć zmienić typ szyfrowania, np. z braku szyfrowania na szyfrowanie oparte na certyfikatach, przy minimalnym czasie niedostępności i z możliwością wycofania zmian. Aby to osiągnąć:

Ustaw TLSAccept=unencrypted,cert w pliku konfiguracyjnym agent i uruchom ponownie Zabbix agent
Przetestuj połączenie z agent za pomocą zabbix_get, używając certyfikatu. Jeśli działa, możesz ponownie skonfigurować szyfrowanie dla tego agent w Zabbix frontend na karcie Data collection → Hosts → <some host> → Encryption, ustawiając Connections to host na "Certificate".
Gdy pamięć podręczna konfiguracji serwer zostanie zaktualizowana (a konfiguracja proxy również zostanie zaktualizowana, jeśli host jest monitorowany przez proxy), połączenia z tym agent będą szyfrowane
Jeśli wszystko działa zgodnie z oczekiwaniami, możesz ustawić TLSAccept=cert w pliku konfiguracyjnym agent i uruchomić ponownie Zabbix agent. Teraz agent będzie akceptował tylko szyfrowane połączenia oparte na certyfikatach. Połączenia bez szyfrowania oraz oparte na PSK będą odrzucane.

W podobny sposób działa to na serwer i proxy. Jeśli w Zabbix frontend w konfiguracji host pole Connections from host jest ustawione na "Certificate", to od agent (aktywne kontrole) i zabbix_sender (trapper pozycja) będą akceptowane tylko szyfrowane połączenia oparte na certyfikatach.

Najprawdopodobniej skonfigurujesz połączenia przychodzące i wychodzące tak, aby używały tego samego typu szyfrowania albo w ogóle bez szyfrowania. Technicznie jednak możliwa jest konfiguracja asymetryczna, np. szyfrowanie oparte na certyfikatach dla połączeń przychodzących i oparte na PSK dla połączeń wychodzących.

Konfiguracja szyfrowania dla każdego host jest wyświetlana w Zabbix frontend, w Data collection → Hosts w kolumnie Agent encryption. Na przykład:

Przykład	Connections to host	Allowed connections from host	Rejected connections from host
$none\_none.png$	Bez szyfrowania	Bez szyfrowania	Szyfrowane, oparte na certyfikatach i oparte na PSK
$cert\_cert.png$	Szyfrowane, oparte na certyfikatach	Szyfrowane, oparte na certyfikatach	Bez szyfrowania i szyfrowane oparte na PSK
$psk\_psk.png$	Szyfrowane, oparte na PSK	Szyfrowane, oparte na PSK	Bez szyfrowania i szyfrowane oparte na certyfikatach
$psk\_none\_psk.png$	Szyfrowane, oparte na PSK	Bez szyfrowania i szyfrowane oparte na PSK	Szyfrowane oparte na certyfikatach
$cert\_all.png$	Szyfrowane, oparte na certyfikatach	Bez szyfrowania, szyfrowane oparte na PSK lub oparte na certyfikatach	-

Połączenia domyślnie nie są szyfrowane. Szyfrowanie musi być skonfigurowane indywidualnie dla każdego host i proxy.

zabbix_get i zabbix_sender z szyfrowaniem

Informacje o używaniu zabbix_get i zabbix_sender z szyfrowaniem można znaleźć w ich stronach podręcznika man.

Pakiety szyfrów

Pakiety szyfrów są domyślnie konfigurowane wewnętrznie podczas uruchamiania Zabbix.

Obsługiwane są również pakiety szyfrów konfigurowane przez użytkownika dla GnuTLS i OpenSSL. Użytkownicy mogą skonfigurować pakiety szyfrów zgodnie ze swoimi politykami bezpieczeństwa. Korzystanie z tej funkcji jest opcjonalne (wbudowane domyślne pakiety szyfrów nadal działają).

W przypadku bibliotek kryptograficznych skompilowanych z ustawieniami domyślnymi wbudowane reguły Zabbix zwykle skutkują następującymi pakietami szyfrów (w kolejności od wyższego do niższego priorytetu):

Biblioteka	Pakiety szyfrów certyfikatów	Pakiety szyfrów 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

Pakiety szyfrów skonfigurowane przez użytkownika

Wbudowane kryteria wyboru pakietów szyfrów mogą zostać nadpisane przez pakiety szyfrów skonfigurowane przez użytkownika.

Pakiety szyfrów skonfigurowane przez użytkownika to funkcja przeznaczona dla zaawansowanych użytkowników, którzy rozumieją pakiety szyfrów TLS, ich bezpieczeństwo oraz konsekwencje błędów, a także dobrze radzą sobie z rozwiązywaniem problemów z TLS.

Wbudowane kryteria wyboru pakietów szyfrów można nadpisać za pomocą następujących parametrów:

Zakres nadpisania	Parametr	Wartość	Opis
Wybór pakietów szyfrów dla certyfikatów	TLSCipherCert13	Prawidłowe cipher strings OpenSSL 1.1.1 dla protokołu TLS 1.3 (ich wartości są przekazywane do funkcji OpenSSL `SSL_CTX_set_ciphersuites()`).	Kryteria wyboru pakietów szyfrów opartych na certyfikatach dla TLS 1.3 Tylko OpenSSL 1.1.1 lub nowszy.
Wybór pakietów szyfrów dla certyfikatów	TLSCipherCert	Prawidłowe cipher strings OpenSSL dla TLS 1.2 lub prawidłowe priority strings GnuTLS. Ich wartości są przekazywane odpowiednio do funkcji `SSL_CTX_set_cipher_list()` lub `gnutls_priority_init()`.	Kryteria wyboru pakietów szyfrów opartych na certyfikatach dla TLS 1.2/1.3 (GnuTLS), TLS 1.2 (OpenSSL)
Wybór pakietów szyfrów dla PSK	TLSCipherPSK13	Prawidłowe cipher strings OpenSSL 1.1.1 dla protokołu TLS 1.3 (ich wartości są przekazywane do funkcji OpenSSL `SSL_CTX_set_ciphersuites()`).	Kryteria wyboru pakietów szyfrów opartych na PSK dla TLS 1.3 Tylko OpenSSL 1.1.1 lub nowszy.
Wybór pakietów szyfrów dla PSK	TLSCipherPSK	Prawidłowe cipher strings OpenSSL dla TLS 1.2 lub prawidłowe priority strings GnuTLS. Ich wartości są przekazywane odpowiednio do funkcji `SSL_CTX_set_cipher_list()` lub `gnutls_priority_init()`.	Kryteria wyboru pakietów szyfrów opartych na PSK dla TLS 1.2/1.3 (GnuTLS), TLS 1.2 (OpenSSL)
Połączona lista pakietów szyfrów dla certyfikatu i PSK	TLSCipherAll13	Prawidłowe cipher strings OpenSSL 1.1.1 dla protokołu TLS 1.3 (ich wartości są przekazywane do funkcji OpenSSL `SSL_CTX_set_ciphersuites()`).	Kryteria wyboru pakietów szyfrów dla TLS 1.3 Tylko OpenSSL 1.1.1 lub nowszy.
Połączona lista pakietów szyfrów dla certyfikatu i PSK	TLSCipherAll	Prawidłowe cipher strings OpenSSL dla TLS 1.2 lub prawidłowe priority strings GnuTLS. Ich wartości są przekazywane odpowiednio do funkcji `SSL_CTX_set_cipher_list()` lub `gnutls_priority_init()`.	Kryteria wyboru pakietów szyfrów dla TLS 1.2/1.3 (GnuTLS), TLS 1.2 (OpenSSL)

Aby nadpisać wybór pakietów szyfrów w narzędziach zabbix_get i zabbix_sender, użyj parametrów wiersza poleceń:

--tls-cipher13
--tls-cipher

Nowe parametry są opcjonalne. Jeśli parametr nie zostanie określony, zostanie użyta wewnętrzna wartość domyślna. Jeśli parametr jest zdefiniowany, nie może być pusty.

Jeśli ustawienie wartości TLSCipher* w bibliotece kryptograficznej zakończy się niepowodzeniem, serwer, proxy lub agent nie uruchomi się, a błąd zostanie zapisany w logu.

Ważne jest, aby rozumieć, kiedy każdy parametr ma zastosowanie.

Połączenia wychodzące

Najprostszy przypadek to połączenia wychodzące:

Dla połączeń wychodzących z certyfikatem użyj TLSCipherCert13 lub TLSCipherCert
Dla połączeń wychodzących z PSK użyj TLSCipherPSK13 lub TLSCipherPSK
W przypadku narzędzi zabbix_get i zabbix_sender można użyć parametrów wiersza poleceń --tls-cipher13 lub --tls-cipher (szyfrowanie jest jednoznacznie określone parametrem --tls-connect)

Połączenia przychodzące

W przypadku połączeń przychodzących jest to nieco bardziej skomplikowane, ponieważ reguły są specyficzne dla komponentów i konfiguracji.

Dla Zabbix agent:

Konfiguracja połączenia agenta	Konfiguracja szyfrów
TLSConnect=cert	TLSCipherCert, TLSCipherCert13
TLSConnect=psk	TLSCipherPSK, TLSCipherPSK13
TLSAccept=cert	TLSCipherCert, TLSCipherCert13
TLSAccept=psk	TLSCipherPSK, TLSCipherPSK13
TLSAccept=cert,psk	TLSCipherAll, TLSCipherAll13

Dla Zabbix serwer i proxy:

Konfiguracja połączenia	Konfiguracja szyfrów
Połączenia wychodzące używające PSK	TLSCipherPSK, TLSCipherPSK13
Połączenia przychodzące używające certyfikatów	TLSCipherAll, TLSCipherAll13
Połączenia przychodzące używające PSK, jeśli serwer nie ma certyfikatu	TLSCipherPSK, TLSCipherPSK13
Połączenia przychodzące używające PSK, jeśli serwer ma certyfikat	TLSCipherAll, TLSCipherAll13

W dwóch powyższych tabelach można zauważyć pewną prawidłowość:

TLSCipherAll i TLSCipherAll13 mogą być określone tylko wtedy, gdy używana jest połączona lista pakietów szyfrujących opartych na certyfikatach i PSK. Występuje to w dwóch przypadkach: serwer (proxy) ze skonfigurowanym certyfikatem (pakiety szyfrujące PSK są zawsze konfigurowane na serwerze, proxy, jeśli biblioteka kryptograficzna obsługuje PSK), agent skonfigurowany do akceptowania zarówno przychodzących połączeń opartych na certyfikatach, jak i na PSK
w pozostałych przypadkach wystarczające są TLSCipherCert* i/lub TLSCipherPSK*

Poniższe tabele pokazują wbudowane wartości domyślne TLSCipher*. Mogą one być dobrym punktem wyjścia do zdefiniowania własnych wartości niestandardowych.

Parametr	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

Parametr	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

¹ Wartości domyślne są inne dla starszych wersji OpenSSL (1.0.1, 1.0.2, 1.1.0), dla LibreSSL oraz jeśli OpenSSL został skompilowany bez obsługi PSK.

Przykłady pakietów szyfrujących skonfigurowanych przez użytkownika

Poniżej przedstawiono przykłady pakietów szyfrujących skonfigurowanych przez użytkownika:

Testowanie ciągów szyfrów i zezwalanie tylko na pakiety szyfrujące z PFS
Przełączanie z AES128 na AES256

Testowanie ciągów szyfrów i zezwalanie tylko na pakiety szyfrów PFS

Aby zobaczyć, które pakiety szyfrów zostały wybrane, należy ustawić DebugLevel=4 w pliku konfiguracyjnym lub użyć opcji -vv dla zabbix_sender.

Przed uzyskaniem żądanych pakietów szyfrów może być konieczne poeksperymentowanie z parametrami TLSCipher*. Wielokrotne restartowanie serwera Zabbix, proxy lub agent tylko po to, aby dostosować parametry TLSCipher*, jest niewygodne. Wygodniejszymi opcjami są użycie zabbix_sender lub polecenia openssl. Pokażmy oba sposoby.

1. Użycie zabbix_sender.

Utwórzmy testowy plik konfiguracyjny, na przykład /home/zabbix/test.conf, ze składnią pliku 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

Do tego przykładu potrzebne są prawidłowe certyfikaty CA i agent oraz PSK. Dostosuj ścieżki i nazwy plików certyfikatów oraz PSK do swojego środowiska.

Jeśli nie używasz certyfikatów, a tylko PSK, możesz utworzyć prostszy plik testowy:

  Hostname=nonexisting
  ServerActive=nonexisting

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

Wybrane pakiety szyfrów można zobaczyć, uruchamiając zabbix_sender (przykład skompilowany z 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

Tutaj widać pakiety szyfrów wybrane domyślnie. Te wartości domyślne zostały dobrane tak, aby zapewnić interoperacyjność z agentami Zabbix działającymi w systemach ze starszymi wersjami OpenSSL (od 1.0.1).

W nowszych systemach można zwiększyć bezpieczeństwo, zezwalając tylko na kilka pakietów szyfrów, np. tylko na pakiety szyfrów z PFS (Perfect Forward Secrecy). Spróbujmy zezwolić tylko na pakiety szyfrów z PFS przy użyciu parametrów TLSCipher*.

Wynik nie będzie interoperacyjny z systemami używającymi OpenSSL 1.0.1 i 1.0.2, jeśli używany jest PSK. Szyfrowanie oparte na certyfikatach powinno działać.

Dodaj dwie linie do pliku konfiguracyjnego test.conf:

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

i przetestuj ponownie:

  $ 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

Listy „certificate ciphersuites” i „PSK ciphersuites” uległy zmianie — są krótsze niż wcześniej i zawierają tylko pakiety szyfrów TLS 1.3 oraz pakiety szyfrów TLS 1.2 ECDHE-*, zgodnie z oczekiwaniami.

2. TLSCipherAll i TLSCipherAll13 nie mogą być testowane za pomocą zabbix_sender; nie wpływają one na wartość „certificate and PSK ciphersuites” pokazaną w powyższym przykładzie. Aby dostroić TLSCipherAll i TLSCipherAll13, trzeba eksperymentować z agent, proxy lub serwer.

Aby więc zezwolić tylko na pakiety szyfrów PFS, może być konieczne dodanie maksymalnie trzech parametrów

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

do zabbix_agentd.conf, zabbix_proxy.conf i zabbix_server_conf, jeśli każdy z nich ma skonfigurowany certyfikat, a agent ma również PSK.

Jeśli środowisko Zabbix używa wyłącznie szyfrowania opartego na PSK i nie używa certyfikatów, wystarczy tylko jeden parametr:

  TLSCipherPSK=kECDHEPSK+AES128

Teraz, gdy już rozumiesz, jak to działa, możesz testować wybór pakietów szyfrów nawet poza Zabbix, za pomocą polecenia openssl. Przetestujmy wszystkie trzy wartości parametrów 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

Możesz preferować openssl ciphers z opcją -V, aby uzyskać bardziej szczegółowe dane wyjściowe:

  $ 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

Podobnie można testować ciągi priorytetów dla 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

Przełączanie z AES128 na AES256

Zabbix używa AES128 jako wbudowanego domyślnego szyfrowania danych. Załóżmy, że używasz certyfikatów i chcesz przełączyć się na AES256 w OpenSSL 1.1.1.

Można to osiągnąć, dodając odpowiednie parametry w 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

Chociaż używane będą tylko pakiety szyfrów związane z certyfikatami, parametry TLSCipherPSK* również są zdefiniowane, aby uniknąć ich wartości domyślnych, które obejmują mniej bezpieczne szyfry dla szerszej interoperacyjności. Pakietów szyfrów PSK nie można całkowicie wyłączyć na serwer/proxy.

A w 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 Korzystanie z certyfikatów

Docs

15 Szyfrowanie

Przegląd