Docker: Łatanie luk w obrazach za pomocą Trivy i Copa

Obrazy kontenerów Docker często zawierają luki w zabezpieczeniach dziedziczone z pakietów systemu operacyjnego, na którym są oparte. Zamiast tworzyć obrazy od podstaw, można użyć Trivy do skanowania pod kątem podatności i Copa do ich bezpośredniego łatania. Ten poradnik pokazuje, jak zidentyfikować i naprawić luki w kontenerach na systemach Ubuntu, Debian, RHEL, CentOS i Fedora, korzystając z tych dwóch potężnych narzędzi open-source.

W tym samouczku nauczysz się:

Jak zainstalować skaner podatności Trivy na Ubuntu/Debian
Jak zainstalować narzędzie do patchowania kontenera Copa
Jak skanować obrazy Dockera pod kątem podatności systemu operacyjnego
Jak automatycznie łatać podatności kontenerów
Jak sprawdzić, czy załatane obrazy są wolne od podatności

Podsumowanie artykułu: Skanuj obrazy Dockera pod kątem podatności za pomocą Trivy i automatycznie je poprawiaj używając Copa.

Krok	Polecenie/Akcja
1. Skanuj obraz	`sudo trivy image --vuln-type os --ignore-unfixed IMAGE_NAME`
2. Eksportuj raport JSON	`trivy image --vuln-type os --ignore-unfixed -f json -o report.json IMAGE_NAME`
3. Uruchom BuildKit	`sudo docker run --detach --rm --privileged -p 127.0.0.1:8888:8888/tcp --name buildkitd --entrypoint buildkitd moby/buildkit:v0.11.4 --addr tcp://0.0.0.0:8888`
4. Obraz łatki	`sudo copa patch -i IMAGE_NAME -r report.json -t patched -a tcp://0.0.0.0:8888`

Krok 1: Zainstaluj skaner podatności Trivy

Trivy to otwartoźródłowy skaner podatności opracowany przez Aqua Security. Wykrywa podatności w pakietach systemu operacyjnego, zależnościach aplikacji i obrazach kontenerów.

Ubuntu/Debian

Zainstaluj zależności: Najpierw zainstaluj pakiety wget i gnupg, które są wymagane do dodania repozytorium:
```
$ sudo apt-get install wget gnupg -y
```

Dodaj klucz GPG Trivy: Pobierz i dodaj klucz podpisujący repozytorium Trivy:

$ wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | gpg --dearmor | sudo tee /usr/share/keyrings/trivy.gpg > /dev/null

Dodaj repozytorium Trivy: Dodaj oficjalne repozytorium Trivy do swojej listy źródeł:

$ echo "deb [signed-by=/usr/share/keyrings/trivy.gpg] https://aquasecurity.github.io/trivy-repo/deb generic main" | sudo tee -a /etc/apt/sources.list.d/trivy.list

Zainstaluj Trivy: Zaktualizuj listę pakietów i zainstaluj Trivy:
```
$ sudo apt-get update
$ sudo apt-get install trivy -y
```

RHEL/CentOS/Fedora

Dodaj repozytorium Trivy: Utwórz plik repozytorium Trivy:

# sudo tee /etc/yum.repos.d/trivy.repo << 'EOF'
[trivy]
name=Trivy repository
baseurl=https://aquasecurity.github.io/trivy-repo/rpm/releases/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://aquasecurity.github.io/trivy-repo/rpm/public.key
EOF

Zainstaluj Trivy: Użyj dnf lub yum, aby zainstalować:
```
# sudo dnf install trivy -y
```

Zweryfikuj instalację, sprawdzając wersję:

$ trivy --version

Krok 2: Zainstaluj narzędzie Copa Patching

Copa (Copacetic) to projekt typu sandbox w CNFC, który bezpośrednio aktualizuje obrazy kontenerów bez konieczności pełnego przebudowywania. Wykorzystuje raporty o podatnościach z narzędzi skanujących, takich jak Trivy, do stosowania aktualizacji bezpieczeństwa. Copa jest dystrybuowana jako pojedynczy plik binarny, który działa na wszystkich dystrybucjach Linuksa.

Pobierz plik binarny Copa: Pobierz gotowy plik binarny ze strony oficjalnych wydań Copa na GitHub:

$ wget https://github.com/project-copacetic/copacetic/releases/download/v0.9.0/copa_0.9.0_linux_amd64.tar.gz

Rozpakuj archiwum: Rozpakuj pobrany plik tar:
```
$ tar -xzf copa_0.9.0_linux_amd64.tar.gz
```
Zainstaluj Copa: Przenieś plik binarny do ścieżki systemowej:
```
$ sudo mv copa /usr/local/bin/
```
Sprawdź instalację: Potwierdź, że Copa jest poprawnie zainstalowane:
```
$ copa --version
```

Krok 3: Skanuj obraz kontenera pod kątem podatności

Przed zastosowaniem łatki musisz zidentyfikować luki w obrazie kontenera. Poniższe kroki wykorzystują linuxconfig/instantprivacy jako przykład – zamień go na nazwę swojego obrazu.

Pobierz obraz kontenera: Pobierz obraz, który chcesz przeskanować:
```
$ sudo docker pull linuxconfig/instantprivacy
```
Skanuj pod kątem luk: Uruchom Trivy, aby przeskanować system operacyjny pod kątem luk. Flaga --ignore-unfixed wyklucza luki, dla których nie ma dostępnych poprawek:
```
$ sudo trivy image --vuln-type os --ignore-unfixed linuxconfig/instantprivacy
```

Eksportuj raport JSON: Copa wymaga wyników skanowania w formacie JSON:

$ trivy image --vuln-type os --ignore-unfixed -f json -o instantprivacy.json linuxconfig/instantprivacy

Krok 4: Załatka obrazu kontenera za pomocą Copa

Copa używa BuildKit do stosowania poprawek w obrazach kontenerów.

Uruchom kontener BuildKit: Uruchom BuildKit jako kontener z uprawnieniami uprzywilejowanymi:

$ sudo docker run --detach --rm --privileged \
  -p 127.0.0.1:8888:8888/tcp \
  --name buildkitd \
  --entrypoint buildkitd \
  moby/buildkit:v0.11.4 \
  --addr tcp://0.0.0.0:8888

Sprawdź, czy BuildKit działa: Potwierdź, że kontener uruchomił się pomyślnie:
```
$ sudo docker ps
```
Zaktualizuj obraz kontenera: Użyj Copa, aby zastosować poprawki bezpieczeństwa. Flaga -t określa tag dla zaktualizowanego obrazu:
```
$ sudo copa patch \
  -i docker.io/linuxconfig/instantprivacy \
  -r instantprivacy.json \
  -t patched \
  -a tcp://0.0.0.0:8888
```
Copa pobiera aktualizacje zabezpieczeń i tworzy nową warstwę obrazu z zastosowanymi poprawkami. Obraz z poprawkami będzie oznaczony jako linuxconfig/instantprivacy:patched.

Krok 5: Zweryfikuj załatany obraz

Zeskanuj załatany obraz: Potwierdź, że wszystkie luki zostały usunięte:

$ sudo trivy image --vuln-type os --ignore-unfixed linuxconfig/instantprivacy:patched

Przetestuj poprawiony obraz: Sprawdź, czy poprawiony obraz działa poprawnie:

$ sudo docker run --name=instantprivacy -d -p 8118:8118 linuxconfig/instantprivacy:patched
$ export http_proxy="http://localhost:8118"
$ curl api.ipify.org
45.84.107.174

Sprzątanie: Zatrzymaj kontener BuildKit po zakończeniu:
```
$ sudo docker stop buildkitd
```

Wniosek

Pomyślnie przeskanowałeś obraz kontenera Docker pod kątem luk w zabezpieczeniach za pomocą Trivy i automatycznie je załatałeś przy użyciu Copa. To podejście jest szybsze niż ponowne budowanie obrazów od podstaw i dodaje tylko jedną warstwę łaty, zachowując oryginalną strukturę obrazu. W środowiskach produkcyjnych zintegruj te narzędzia z pipeline CI/CD, aby automatycznie skanować i łatać obrazy kontenerów przed wdrożeniem. Więcej informacji znajdziesz w oficjalnej dokumentacji Trivy oraz na stronie projektu Copa.

Najczęściej zadawane pytania

Jakie typy luk może załatać Copa? Copa łata tylko luki w pakietach na poziomie systemu operacyjnego (takich jak pakiety Debian, Ubuntu, Alpine czy RHEL). Nie może łatać zależności na poziomie aplikacji, takich jak pakiety npm, moduły Python pip czy moduły Go. W takich przypadkach trzeba przebudować aplikację z aktualnymi zależnościami.
Dlaczego potrzebuję BuildKit, aby uruchomić Copa? Copa wykorzystuje możliwości porównywania i scalania BuildKit, aby utworzyć nową warstwę obrazu zawierającą tylko zmienione pliki. BuildKit działa jako uprzywilejowany kontener, który obsługuje niskopoziomową manipulację obrazami. Bez BuildKit, Copa nie może zastosować poprawek w systemie plików kontenera.
Czy mogę aktualizować obrazy z prywatnych rejestrów? Tak, Copa obsługuje prywatne rejestry. Musisz się uwierzytelnić za pomocą docker login przed uruchomieniem polecenia aktualizacji. Copa używa twoich danych logowania Docker do pobrania obrazu bazowego i, jeśli to konieczne, wysłania zaktualizowanego wyniku.
Co się stanie, jeśli Copa nie będzie mogła załatać wszystkich luk? Niektóre luki mogą jeszcze nie mieć dostępnych poprawek. Flaga --ignore-unfixed w Trivy wyklucza je z raportu. Copa załata wszystko, co ma dostępną poprawkę. Uruchom ponownie Trivy bez --ignore-unfixed, aby zobaczyć wszystkie luki, w tym te oczekujące na poprawki.
Jak zaktualizować Copę do najnowszej wersji? Pobierz najnowsze wydanie ze strony wydań Copa na GitHub i zamień plik binarny w /usr/local/bin/. Sprawdź bieżącą wersję za pomocą copa --version.