Hoi Habr!
Yn 'e moderne realiteit, fanwegen de groeiende rol fan kontenerisaasje yn ûntwikkelingsprosessen, is it probleem fan it garandearjen fan' e feiligens fan ferskate stadia en entiteiten ferbûn mei konteners net it minste wichtige probleem. It útfieren fan hânmjittige kontrôles is tiidslinend, dus it soe in goed idee wêze om op syn minst de earste stappen te nimmen foar it automatisearjen fan dit proses.
Yn dit artikel sil ik klearmakke skripts diele foar it ymplementearjen fan ferskate Docker-befeiligingsprogramma's en ynstruksjes oer hoe't jo in lytse demo-stand kinne ynsette om dit proses te testen. Jo kinne de materialen brûke om te eksperimintearjen mei hoe't jo it proses kinne organisearje foar it testen fan de feiligens fan Dockerfile-ôfbyldings en ynstruksjes. It is dúdlik dat de ynfrastruktuer foar ûntwikkeling en ymplemintaasje fan elkenien oars is, dus hjirûnder sil ik ferskate mooglike opsjes leverje.
Utilities foar feiligenskontrôle
D'r binne in grut oantal ferskillende helpapplikaasjes en skripts dy't kontrôles útfiere op ferskate aspekten fan 'e Docker-ynfrastruktuer. Guon fan harren binne al beskreaun yn it foarige artikel (), en yn dit materiaal soe ik graach rjochtsje wolle op trije fan har, dy't it grutste part fan 'e feiligenseasken foar Docker-ôfbyldings dekke tidens it ûntwikkelingsproses. Derneist sil ik ek in foarbyld sjen litte hoe't dizze trije nutsbedriuwen kinne wurde ferbûn yn ien pipeline om feiligenskontrôles út te fieren.
Hadolint
In frij ienfâldich konsole-hulpprogramma dat helpt, as in earste benadering, de korrektheid en feiligens fan Dockerfile-ynstruksjes te evaluearjen (bygelyks allinich autorisearre ôfbyldingsregistraasjes brûke of sudo brûke).
Dockle
In konsole-hulpprogramma dat wurket mei in ôfbylding (of mei in bewarre tar-argyf fan in ôfbylding), dat de krektens en feiligens fan in bepaalde ôfbylding as sadanich kontrolearret, syn lagen en konfiguraasje analysearret - hokker brûkers binne makke, hokker ynstruksjes wurde brûkt, hokker folumes wurde monteard, de oanwêzigens fan in leech wachtwurd, ensfh d. Oant no ta is it oantal kontrôles net heul grut en is basearre op ferskate fan ús eigen kontrôles en oanbefellings foar Docker.
Trivy
Dit hulpprogramma is rjochte op it finen fan twa soarten kwetsberens - problemen mei OS-builds (stipe troch Alpine, RedHat (EL), CentOS, Debian GNU, Ubuntu) en problemen mei ôfhinklikens (Gemfile.lock, Pipfile.lock, composer.lock, pakket -lock.json , yarn.lock, cargo.lock). Trivy kin sawol in ôfbylding yn 'e repository as in lokale ôfbylding scannen, en kin ek scannen op basis fan it oerdroegen .tar-bestân mei de Docker-ôfbylding.
Opsjes foar it útfieren fan nutsbedriuwen
Om de beskreaune applikaasjes te besykjen yn in isolearre omjouwing, sil ik ynstruksjes leverje foar it ynstallearjen fan alle nutsfoarsjenningen yn in wat ferienfâldige proses.
It haadidee is om te demonstrearjen hoe't jo automatyske ynhâldferifikaasje kinne ymplementearje fan Dockerfiles en Docker-ôfbyldings dy't wurde makke tidens ûntwikkeling.
De kontrôle sels bestiet út de folgjende stappen:
- Kontrolearje de krektens en feiligens fan Dockerfile-ynstruksjes mei in linter-hulpprogramma Hadolint
- Kontrolearje de krektens en feiligens fan 'e lêste en tuskenlizzende ôfbyldings mei help fan in hulpprogramma Dockle
- Kontrolearje op de oanwêzigens fan iepenbier bekende kwetsberheden (CVE) yn 'e basisôfbylding en in oantal ôfhinklikens - mei help fan it nut Trivy
Letter yn it artikel sil ik trije opsjes jaan foar it útfieren fan dizze stappen:
De earste is troch it konfigurearjen fan de CI / CD-pipeline mei GitLab as foarbyld (mei in beskriuwing fan it proses fan it ferheegjen fan in testeksimplaar).
De twadde brûkt in shell-skript.
De tredde omfettet it bouwen fan in Docker-ôfbylding om Docker-ôfbyldings te scannen.
Jo kinne de opsje kieze dy't it bêste by jo past, it oermeitsje nei jo ynfrastruktuer en oanpasse oan jo behoeften.
Alle nedige bestannen en oanfoljende ynstruksjes binne ek te finen yn it repository:
Yntegraasje yn GitLab CI / CD
Yn 'e earste opsje sille wy sjen hoe't jo feiligenskontrôles kinne ymplementearje mei it GitLab-repositorysysteem as foarbyld. Hjir sille wy troch de stappen gean en útfine hoe't jo in testomjouwing mei GitLab fanôf it begjin kinne ynstallearje, in skennenproses meitsje en nutsfoarsjenningen starte foar it kontrolearjen fan de test Dockerfile en in willekeurige ôfbylding - de JuiceShop-applikaasje.
GitLab ynstallearje
1. Ynstallearje Docker:
sudo apt-get update && sudo apt-get install docker.io2. Foegje de aktuele brûker ta oan de docker-groep sadat jo mei docker kinne wurkje sûnder sudo te brûken:
sudo addgroup <username> docker3. Fyn jo IP:
ip addr4. Ynstallearje en starte GitLab yn 'e kontener, it ferfangen fan it IP-adres yn' e hostnamme mei jo eigen:
docker run --detach
--hostname 192.168.1.112
--publish 443:443 --publish 80:80
--name gitlab
--restart always
--volume /srv/gitlab/config:/etc/gitlab
--volume /srv/gitlab/logs:/var/log/gitlab
--volume /srv/gitlab/data:/var/opt/gitlab
gitlab/gitlab-ce:latestWy wachtsje oant GitLab alle nedige ynstallaasjeprosedueres foltôget (jo kinne it proses kontrolearje fia de logbestânútfier: docker logs -f gitlab).
5. Iepenje jo lokale IP yn 'e browser en sjoch in side dy't jo freget om it wachtwurd foar de root-brûker te feroarjen:
Stel in nij wachtwurd yn en gean nei GitLab.
6. Meitsje in nij projekt, bygelyks cicd-test en inisjalisearje it mei de start triem Readme.md:
7. No moatte wy GitLab Runner ynstallearje: in agint dy't op oanfraach alle nedige operaasjes útfiere sil.
Download de lêste ferzje (yn dit gefal, foar Linux 64-bit):
sudo curl -L --output /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-linux-amd648. Meitsje it útfierber:
sudo chmod +x /usr/local/bin/gitlab-runner9. Foegje in OS-brûker ta foar Runner en start de tsjinst:
sudo useradd --comment 'GitLab Runner' --create-home gitlab-runner --shell /bin/bash
sudo gitlab-runner install --user=gitlab-runner --working-directory=/home/gitlab-runner
sudo gitlab-runner startIt moat der sa útsjen:
local@osboxes:~$ sudo gitlab-runner install --user=gitlab-runner --working-directory=/home/gitlab-runner
Runtime platform arch=amd64 os=linux pid=8438 revision=0e5417a3 version=12.0.1
local@osboxes:~$ sudo gitlab-runner start
Runtime platform arch=amd64 os=linux pid=8518 revision=0e5417a3 version=12.0.1
10. No registrearje wy de Runner sadat it kin ynteraksje mei ús GitLab-eksimplaar.
Om dit te dwaan, iepenje de ynstellings-CI/CD-side (http://OUR_IP_ADDRESS/root/cicd-test/-/settings/ci_cd) en op it ljepblêd Runners fine jo de URL en registraasjetoken:
11. Registrearje Runner troch de URL en registraasjetoken te ferfangen:
sudo gitlab-runner register
--non-interactive
--url "http://<URL>/"
--registration-token "<Registration Token>"
--executor "docker"
--docker-privileged
--docker-image alpine:latest
--description "docker-runner"
--tag-list "docker,privileged"
--run-untagged="true"
--locked="false"
--access-level="not_protected"As gefolch krije wy in klearebare wurkjende GitLab, wêryn wy ynstruksjes moatte tafoegje om ús nutsbedriuwen te begjinnen. Yn dizze demo hawwe wy net de stappen om de applikaasje te bouwen en te kontenerearjen, mar yn in echte omjouwing soene dizze de scanstappen foarôfgeane en ôfbyldings generearje en in Dockerfile foar analyse.
pipeline konfiguraasje
1. Foegje bestannen ta oan it repository mydockerfile.df (dit is in test Dockerfile dat wy sille kontrolearje) en it GitLab CI / CD proses konfiguraasjetriem .gitlab-cicd.yml, dy't ynstruksjes foar scanners listet (note de stip yn 'e triemnamme).
It YAML-konfiguraasjetriem befettet ynstruksjes foar it útfieren fan trije nutsbedriuwen (Hadolint, Dockle, en Trivy) dy't de selektearre Dockerfile analysearje en de ôfbylding spesifisearre yn 'e DOCKERFILE-fariabele. Alle nedige bestannen kinne wurde nommen út it repository:
Úttreksel út mydockerfile.df (dit is in abstrakt bestân mei in set willekeurige ynstruksjes allinich om de wurking fan it nut te demonstrearjen). Direkte keppeling nei it bestân:
Ynhâld fan mydockerple.df
FROM amd64/node:10.16.0-alpine@sha256:f59303fb3248e5d992586c76cc83e1d3700f641cbcd7c0067bc7ad5bb2e5b489 AS tsbuild
COPY package.json .
COPY yarn.lock .
RUN yarn install
COPY lib lib
COPY tsconfig.json tsconfig.json
COPY tsconfig.app.json tsconfig.app.json
RUN yarn build
FROM amd64/ubuntu:18.04@sha256:eb70667a801686f914408558660da753cde27192cd036148e58258819b927395
LABEL maintainer="Rhys Arkins <[email protected]>"
LABEL name="renovate"
...
COPY php.ini /usr/local/etc/php/php.ini
RUN cp -a /tmp/piik/* /var/www/html/
RUN rm -rf /tmp/piwik
RUN chown -R www-data /var/www/html
ADD piwik-cli-setup /piwik-cli-setup
ADD reset.php /var/www/html/
## ENTRYPOINT ##
ADD entrypoint.sh /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]
USER rootDe konfiguraasje YAML sjocht der sa út (it bestân sels kin fûn wurde fia de direkte keppeling hjir: ):
Ynhâld fan .gitlab-ci.yml
variables:
DOCKER_HOST: "tcp://docker:2375/"
DOCKERFILE: "mydockerfile.df" # name of the Dockerfile to analyse
DOCKERIMAGE: "bkimminich/juice-shop" # name of the Docker image to analyse
# DOCKERIMAGE: "knqyf263/cve-2018-11235" # test Docker image with several CRITICAL CVE
SHOWSTOPPER_PRIORITY: "CRITICAL" # what level of criticality will fail Trivy job
TRIVYCACHE: "$CI_PROJECT_DIR/.cache" # where to cache Trivy database of vulnerabilities for faster reuse
ARTIFACT_FOLDER: "$CI_PROJECT_DIR"
services:
- docker:dind # to be able to build docker images inside the Runner
stages:
- scan
- report
- publish
HadoLint:
# Basic lint analysis of Dockerfile instructions
stage: scan
image: docker:git
after_script:
- cat $ARTIFACT_FOLDER/hadolint_results.json
script:
- export VERSION=$(wget -q -O - https://api.github.com/repos/hadolint/hadolint/releases/latest | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/1/')
- wget https://github.com/hadolint/hadolint/releases/download/v${VERSION}/hadolint-Linux-x86_64 && chmod +x hadolint-Linux-x86_64
# NB: hadolint will always exit with 0 exit code
- ./hadolint-Linux-x86_64 -f json $DOCKERFILE > $ARTIFACT_FOLDER/hadolint_results.json || exit 0
artifacts:
when: always # return artifacts even after job failure
paths:
- $ARTIFACT_FOLDER/hadolint_results.json
Dockle:
# Analysing best practices about docker image (users permissions, instructions followed when image was built, etc.)
stage: scan
image: docker:git
after_script:
- cat $ARTIFACT_FOLDER/dockle_results.json
script:
- export VERSION=$(wget -q -O - https://api.github.com/repos/goodwithtech/dockle/releases/latest | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/1/')
- wget https://github.com/goodwithtech/dockle/releases/download/v${VERSION}/dockle_${VERSION}_Linux-64bit.tar.gz && tar zxf dockle_${VERSION}_Linux-64bit.tar.gz
- ./dockle --exit-code 1 -f json --output $ARTIFACT_FOLDER/dockle_results.json $DOCKERIMAGE
artifacts:
when: always # return artifacts even after job failure
paths:
- $ARTIFACT_FOLDER/dockle_results.json
Trivy:
# Analysing docker image and package dependencies against several CVE bases
stage: scan
image: docker:git
script:
# getting the latest Trivy
- apk add rpm
- export VERSION=$(wget -q -O - https://api.github.com/repos/knqyf263/trivy/releases/latest | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/1/')
- wget https://github.com/knqyf263/trivy/releases/download/v${VERSION}/trivy_${VERSION}_Linux-64bit.tar.gz && tar zxf trivy_${VERSION}_Linux-64bit.tar.gz
# displaying all vulnerabilities w/o failing the build
- ./trivy -d --cache-dir $TRIVYCACHE -f json -o $ARTIFACT_FOLDER/trivy_results.json --exit-code 0 $DOCKERIMAGE
# write vulnerabilities info to stdout in human readable format (reading pure json is not fun, eh?). You can remove this if you don't need this.
- ./trivy -d --cache-dir $TRIVYCACHE --exit-code 0 $DOCKERIMAGE
# failing the build if the SHOWSTOPPER priority is found
- ./trivy -d --cache-dir $TRIVYCACHE --exit-code 1 --severity $SHOWSTOPPER_PRIORITY --quiet $DOCKERIMAGE
artifacts:
when: always # return artifacts even after job failure
paths:
- $ARTIFACT_FOLDER/trivy_results.json
cache:
paths:
- .cache
Report:
# combining tools outputs into one HTML
stage: report
when: always
image: python:3.5
script:
- mkdir json
- cp $ARTIFACT_FOLDER/*.json ./json/
- pip install json2html
- wget https://raw.githubusercontent.com/shad0wrunner/docker_cicd/master/convert_json_results.py
- python ./convert_json_results.py
artifacts:
paths:
- results.htmlAs it nedich is, kinne jo ek bewarre ôfbyldings scannen yn 'e foarm fan in .tar-argyf (jo moatte lykwols de ynfierparameters feroarje foar de nutsbedriuwen yn it YAML-bestân)
NB: Trivy fereasket ynstallearre rpm и gean. Oars sil it flaters generearje by it scannen fan RedHat-basearre ôfbyldings en it ûntfangen fan updates foar de kwetsberensdatabase.
2. Nei it tafoegjen fan triemmen oan it repository, neffens de ynstruksjes yn ús konfiguraasjetriem, sil GitLab automatysk it bou- en scanproses begjinne. Op it tabblêd CI/CD → Pipelines kinne jo de fuortgong fan ynstruksjes sjen.
As gefolch hawwe wy fjouwer taken. Trije fan harren dogge direkt mei skennen, en de lêste (Rapport) sammelet in ienfâldich rapport fan ferspraat triemmen mei skennen resultaten.
Standert stopet Trivy mei rinnen as KRITISCHE kwetsberens wurde ûntdutsen yn 'e ôfbylding of ôfhinklikens. Tagelyk jout Hadolint altyd in Success-koade werom, om't it altyd resultearret yn opmerkings, wêrtroch't de bou stopet.
Ofhinklik fan jo spesifike easken kinne jo in útgongskoade konfigurearje, sadat as dizze nutsbedriuwen problemen fan in bepaalde kritykens detectearje, se ek it bouproses stopje. Yn ús gefal sil de build allinich stopje as Trivy in kwetsberens detektearret mei de kritykens dy't wy spesifisearre hawwe yn 'e SHOWSTOPPER-fariabele yn .gitlab-ci.yml.
It resultaat fan elk hulpprogramma kin wurde besjoen yn it logboek fan elke skennentaak, direkt yn 'e json-bestannen yn 'e artefaktseksje, of yn in ienfâldich HTML-rapport (mear oer dat hjirûnder):
3. Om gebrûksrapporten yn in wat mear minsklik lêsbere foarm te presintearjen, wurdt in lyts Python-skript brûkt om trije JSON-bestannen te konvertearjen yn ien HTML-bestân mei in tabel fan defekten.
Dit skript wurdt lansearre troch in aparte Rapport taak, en syn lêste artefakt is in HTML triem mei in rapport. De skriptboarne is ek yn 'e repository en kin oanpast wurde oan jo behoeften, kleuren, ensfh.
Shell skript
De twadde opsje is geskikt foar gefallen as jo Docker-ôfbyldings moatte kontrolearje bûten it CI / CD-systeem of jo moatte alle ynstruksjes hawwe yn in formulier dat direkt op 'e host kin wurde útfierd. Dizze opsje wurdt dekt troch in klear makke shell-skript dat kin wurde útfierd op in skjinne firtuele (of sels echte) masine. It skript fiert deselde ynstruksjes út as de hjirboppe beskreaune gitlab-runner.
Foar it skript om suksesfol te rinnen, moat Docker ynstalleare wurde op it systeem en de hjoeddeistige brûker moat yn 'e docker-groep wêze.
It skript sels is hjir te finen:
Oan it begjin fan it bestân spesifisearje fariabelen hokker ôfbylding moat wurde skansearre en hokker kritike defekten sille feroarsaakje dat it Trivy-hulpprogramma útgiet mei de opjûne flaterkoade.
Tidens it útfieren fan skript sille alle nutsbedriuwen wurde ynladen nei de map docker_tools, de resultaten fan har wurk binne yn 'e map docker_tools/json, en de HTML mei it rapport sil yn it bestân wêze results.html.
Foarbyld skriptútfier
~/docker_cicd$ ./docker_sec_check.sh
[+] Setting environment variables
[+] Installing required packages
[+] Preparing necessary directories
[+] Fetching sample Dockerfile
2020-10-20 10:40:00 (45.3 MB/s) - ‘Dockerfile’ saved [8071/8071]
[+] Pulling image to scan
latest: Pulling from bkimminich/juice-shop
[+] Running Hadolint
...
Dockerfile:205 DL3015 Avoid additional packages by specifying `--no-install-recommends`
Dockerfile:248 DL3002 Last USER should not be root
...
[+] Running Dockle
...
WARN - DKL-DI-0006: Avoid latest tag
* Avoid 'latest' tag
INFO - CIS-DI-0005: Enable Content trust for Docker
* export DOCKER_CONTENT_TRUST=1 before docker pull/build
...
[+] Running Trivy
juice-shop/frontend/package-lock.json
=====================================
Total: 3 (UNKNOWN: 0, LOW: 1, MEDIUM: 0, HIGH: 2, CRITICAL: 0)
+---------------------+------------------+----------+---------+-------------------------+
| LIBRARY | VULNERABILITY ID | SEVERITY | VERSION | TITLE |
+---------------------+------------------+----------+---------+-------------------------+
| object-path | CVE-2020-15256 | HIGH | 0.11.4 | Prototype pollution in |
| | | | | object-path |
+---------------------+------------------+ +---------+-------------------------+
| tree-kill | CVE-2019-15599 | | 1.2.2 | Code Injection |
+---------------------+------------------+----------+---------+-------------------------+
| webpack-subresource | CVE-2020-15262 | LOW | 1.4.1 | Unprotected dynamically |
| | | | | loaded chunks |
+---------------------+------------------+----------+---------+-------------------------+
juice-shop/package-lock.json
============================
Total: 20 (UNKNOWN: 0, LOW: 1, MEDIUM: 6, HIGH: 8, CRITICAL: 5)
...
juice-shop/package-lock.json
============================
Total: 5 (CRITICAL: 5)
...
[+] Removing left-overs
[+] Making the output look pretty
[+] Converting JSON results
[+] Writing results HTML
[+] Clean exit ============================================================
[+] Everything is done. Find the resulting HTML report in results.htmlDocker-ôfbylding mei alle nutsfoarsjenningen
As tredde alternatyf haw ik twa ienfâldige Dockerfiles gearstald om in ôfbylding te meitsjen mei befeiligingsprogramma's. Ien Dockerfile sil helpe om in set te bouwen foar it scannen fan in ôfbylding fan in repository, de twadde (Dockerfile_tar) sil helpe om in set te bouwen foar it scannen fan in tar-bestân mei in ôfbylding.
1. Nim it oerienkommende Docker-bestân en skripts út it repository .
2. Wy lansearje it foar montage:
docker build -t dscan:image -f docker_security.df .
3. Nei't de gearkomste foltôge is, meitsje wy in kontener fan 'e ôfbylding. Tagelyk passe wy de DOCKERIMAGE omjouwingsfariabele troch mei de namme fan 'e ôfbylding wêryn wy ynteressearre binne en montearje it Dockerfile dat wy wolle analysearje fan ús masine nei it bestân /Dockerfile (notysje dat it absolute paad nei dit bestân fereaske is):
docker run --rm -v $(pwd)/results:/results -v $(pwd)/docker_security.df:/Dockerfile -e DOCKERIMAGE="bkimminich/juice-shop" dscan:image
[+] Setting environment variables
[+] Running Hadolint
/Dockerfile:3 DL3006 Always tag the version of an image explicitly
[+] Running Dockle
WARN - DKL-DI-0006: Avoid latest tag
* Avoid 'latest' tag
INFO - CIS-DI-0005: Enable Content trust for Docker
* export DOCKER_CONTENT_TRUST=1 before docker pull/build
INFO - CIS-DI-0006: Add HEALTHCHECK instruction to the container image
* not found HEALTHCHECK statement
INFO - DKL-LI-0003: Only put necessary files
* unnecessary file : juice-shop/node_modules/sqlite3/Dockerfile
* unnecessary file : juice-shop/node_modules/sqlite3/tools/docker/architecture/linux-arm64/Dockerfile
* unnecessary file : juice-shop/node_modules/sqlite3/tools/docker/architecture/linux-arm/Dockerfile
[+] Running Trivy
...
juice-shop/package-lock.json
============================
Total: 20 (UNKNOWN: 0, LOW: 1, MEDIUM: 6, HIGH: 8, CRITICAL: 5)
...
[+] Making the output look pretty
[+] Starting the main module ============================================================
[+] Converting JSON results
[+] Writing results HTML
[+] Clean exit ============================================================
[+] Everything is done. Find the resulting HTML report in results.htmlResultaten
Wy seagen mar ien basisset fan nutsfoarsjenningen foar it scannen fan Docker-artefakten, dy't, nei myn miening, heul effektyf in fatsoenlik diel fan 'e easken foar ôfbyldingsfeiligens dekt. D'r binne ek in grut oantal betelle en fergese ark dy't deselde kontrôles útfiere kinne, prachtige rapporten tekenje of gewoan yn konsolemodus wurkje, kontenerbehearsystemen dekke, ensfh. In oersjoch fan dizze ark en hoe't se se yntegrearje kinne ferskine wat letter .
It goede ding oer de set ark beskreaun yn dit artikel is dat se allegear iepen boarne binne en jo kinne eksperimintearje mei har en oare ferlykbere ark om te finen wat by jo behoeften en ynfrastruktuer past. Fansels moatte alle kwetsberens dy't fûn wurde studearre wurde foar tapasberens yn spesifike omstannichheden, mar dit is in ûnderwerp foar in takomstich grut artikel.
Ik hoopje dat dizze hantlieding, skripts en nutsbedriuwen jo sille helpe en in útgongspunt wurde foar it meitsjen fan in feiliger ynfrastruktuer op it mêd fan containerisaasje.
Boarne: www.habr.com