Haai Habr!
In die moderne werklikheid, as gevolg van die groeiende rol van houers in ontwikkelingsprosesse, is die kwessie van die versekering van die sekuriteit van verskeie stadiums en entiteite wat met houers geassosieer word, nie die minste belangrike kwessie nie. Om handkontroles uit te voer is tydrowend, so dit sal 'n goeie idee wees om ten minste die aanvanklike stappe te neem om hierdie proses te outomatiseer.
In hierdie artikel sal ek klaargemaakte skrifte deel vir die implementering van verskeie Docker-sekuriteitshulpmiddels en instruksies oor hoe om 'n klein demonstrasiestand te ontplooi om hierdie proses te toets. U kan die materiaal gebruik om te eksperimenteer met hoe om die proses te organiseer om die sekuriteit van Dockerfile-beelde en -instruksies te toets. Dit is duidelik dat almal se ontwikkeling en implementering infrastruktuur verskil, so hieronder sal ek verskeie moontlike opsies verskaf.
Sekuriteitskontrole-nutsprogramme
Daar is 'n groot aantal verskillende hulptoepassings en -skrifte wat kontrole uitvoer op verskeie aspekte van die Docker-infrastruktuur. Sommige van hulle is reeds in die vorige artikel beskryf (), en in hierdie materiaal wil ek op drie daarvan fokus, wat die grootste deel van die sekuriteitsvereistes vir Docker-beelde dek wat tydens die ontwikkelingsproses gebou is. Daarbenewens sal ek ook 'n voorbeeld wys van hoe hierdie drie nutsprogramme in een pyplyn gekoppel kan word om sekuriteitskontroles uit te voer.
Hadolint
'N Redelik eenvoudige konsole-hulpmiddel wat as 'n eerste benadering help om die korrektheid en veiligheid van Dockerfile-instruksies te evalueer (byvoorbeeld deur slegs gemagtigde beeldregisters te gebruik of sudo te gebruik).
Dockle
'n Konsolehulpmiddel wat met 'n prent werk (of met 'n gestoorde teer-argief van 'n prent), wat die korrektheid en sekuriteit van 'n spesifieke prent as sodanig nagaan, die lae en konfigurasie daarvan ontleed - watter gebruikers geskep word, watter instruksies gebruik word, watter volumes gemonteer word, die teenwoordigheid van 'n leë wagwoord, ens. d. Tot dusver is die aantal tjeks nie baie groot nie en is gebaseer op verskeie van ons eie tjeks en aanbevelings vir Docker.
Trivy
Hierdie program is daarop gemik om twee tipes kwesbaarhede te vind - probleme met OS-bou (ondersteun deur Alpine, RedHat (EL), CentOS, Debian GNU, Ubuntu) en probleme met afhanklikhede (Gemfile.lock, Pipfile.lock, composer.lock, pakket -lock.json, garing.slot, vrag.slot). Trivy kan beide 'n prent in die bewaarplek en 'n plaaslike prent skandeer, en kan ook skandeer gebaseer op die oorgeplaaste .tar-lêer met die Docker-prent.
Opsies vir die implementering van nutsprogramme
Om die beskryfde toepassings in 'n geïsoleerde omgewing te probeer, sal ek instruksies verskaf vir die installering van al die nutsprogramme in 'n ietwat vereenvoudigde proses.
Die hoofgedagte is om te demonstreer hoe u outomatiese inhoudverifikasie van Dockerfiles en Docker-beelde wat tydens ontwikkeling geskep word, kan implementeer.
Die tjek self bestaan uit die volgende stappe:
- Kontroleer die korrektheid en veiligheid van Dockerfile-instruksies met behulp van 'n linter-nutsding Hadolint
- Kontroleer die korrektheid en veiligheid van die finale en intermediêre beelde met behulp van 'n nut Dockle
- Kontroleer vir die teenwoordigheid van publiek bekende kwesbaarhede (CVE) in die basisbeeld en 'n aantal afhanklikhede - met behulp van die nut Trivy
Later in die artikel sal ek drie opsies gee om hierdie stappe te implementeer:
Die eerste is deur die CI/CD-pyplyn op te stel deur GitLab as 'n voorbeeld te gebruik (met 'n beskrywing van die proses om 'n toetsinstansie te verhoog).
Die tweede gebruik 'n dopskrif.
Die derde een behels die bou van 'n Docker-beeld om Docker-beelde te skandeer.
Jy kan die opsie kies wat jou die beste pas, dit na jou infrastruktuur oordra en dit by jou behoeftes aanpas.
Alle nodige lêers en bykomende instruksies is ook in die bewaarplek geleë:
Integrasie in GitLab CI/CD
In die eerste opsie sal ons kyk hoe u sekuriteitskontroles kan implementeer deur die GitLab-bewaarstelsel as voorbeeld te gebruik. Hier sal ons deur die stappe gaan en uitvind hoe om 'n toetsomgewing met GitLab van nuuts af te installeer, 'n skanderingsproses te skep en nutsprogramme te begin om die toets Dockerfile en 'n ewekansige prent na te gaan - die JuiceShop-toepassing.
GitLab installeer
1. Installeer Docker:
sudo apt-get update && sudo apt-get install docker.io2. Voeg die huidige gebruiker by die docker-groep sodat jy met docker kan werk sonder om sudo te gebruik:
sudo addgroup <username> docker3. Vind jou IP:
ip addr4. Installeer en begin GitLab in die houer, en vervang die IP-adres in die gasheernaam met jou eie:
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:latestOns wag totdat GitLab al die nodige installasieprosedures voltooi (jy kan die proses monitor deur die loglêer-uitvoer: docker logs -f gitlab).
5. Maak jou plaaslike IP in die blaaier oop en sien 'n bladsy wat jou vra om die wagwoord vir die wortelgebruiker te verander:
Stel 'n nuwe wagwoord in en gaan na GitLab.
6. Skep 'n nuwe projek, byvoorbeeld cicd-toets en inisialiseer dit met die beginlêer LEESMY.md:
7. Nou moet ons GitLab Runner installeer: 'n agent wat al die nodige bewerkings op versoek sal uitvoer.
Laai die nuutste weergawe af (in hierdie geval vir Linux 64-bis):
sudo curl -L --output /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-linux-amd648. Maak dit uitvoerbaar:
sudo chmod +x /usr/local/bin/gitlab-runner9. Voeg 'n OS-gebruiker vir Runner by en begin die diens:
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 startDit behoort so iets te lyk:
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. Nou registreer ons die Runner sodat dit met ons GitLab-instansie kan kommunikeer.
Om dit te doen, maak die Instellings-CI/CD-bladsy oop (http://OUR_IP_ADDRESS/root/cicd-test/-/settings/ci_cd) en op die Runners-oortjie vind die URL en Registrasieteken:
11. Registreer Runner deur die URL en Registrasietoken te vervang:
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 gevolg hiervan kry ons 'n gereedgemaakte werkende GitLab, waarin ons instruksies moet byvoeg om ons nutsprogramme te begin. In hierdie demonstrasie het ons nie die stappe om die toepassing te bou en dit te hou nie, maar in 'n werklike omgewing sal dit die skanderingstappe voorafgaan en beelde en 'n Docker-lêer vir ontleding genereer.
pyplyn konfigurasie
1. Voeg lêers by die bewaarplek mydockerfile.df (dit is 'n toets Docker-lêer wat ons sal nagaan) en die GitLab CI/CD-proseskonfigurasielêer .gitlab-cicd.yml, wat instruksies vir skandeerders lys (let op die kolletjie in die lêernaam).
Die YAML-konfigurasielêer bevat instruksies om drie nutsprogramme (Hadolint, Dockle en Trivy) uit te voer wat die geselekteerde Dockerfile en die beeld gespesifiseer in die DOCKERFILE-veranderlike sal ontleed. Alle nodige lêers kan uit die bewaarplek geneem word:
Uittreksel uit mydockerfile.df (hierdie is 'n abstrakte lêer met 'n stel arbitrêre instruksies slegs om die werking van die nut te demonstreer). Direkte skakel na die lêer:
Inhoud van mydockerfile.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 rootDie konfigurasie YAML lyk so (die lêer self kan gevind word via die direkte skakel hier: ):
Inhoud van .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.htmlIndien nodig, kan jy ook gestoorde beelde in die vorm van 'n .tar-argief skandeer (jy sal egter die invoerparameters vir die nutsprogramme in die YAML-lêer moet verander)
NB: Trivy vereis geïnstalleer rpm и git. Andersins sal dit foute genereer wanneer RedHat-gebaseerde beelde geskandeer word en opdaterings aan die kwesbaarheidsdatabasis ontvang word.
2. Nadat lêers by die bewaarplek gevoeg is, volgens die instruksies in ons konfigurasielêer, sal GitLab outomaties die bou- en skanderingsproses begin. Op die CI/CD → Pyplyne-oortjie kan jy die vordering van instruksies sien.
Gevolglik het ons vier take. Drie van hulle handel direk oor skandering, en die laaste een (Rapport) versamel 'n eenvoudige verslag van verspreide lêers met skanderingsresultate.
Trivy hou by verstek op om te loop as KRITIESE kwesbaarhede in die beeld of afhanklikhede bespeur word. Terselfdertyd gee Hadolint altyd 'n sukseskode terug omdat dit altyd kommentaar lewer, wat veroorsaak dat die bouwerk stop.
Afhangende van u spesifieke vereistes, kan u 'n uitgangkode opstel sodat wanneer hierdie nutsprogramme probleme van 'n sekere kritieke belang opspoor, dit ook die bouproses stop. In ons geval sal die bou slegs stop as Trivy 'n kwesbaarheid opspoor met die kritiekheid wat ons in die SHOWSTOPPER-veranderlike in gespesifiseer het .gitlab-ci.yml.
Die resultaat van elke hulpprogram kan in die logboek van elke skanderingtaak gesien word, direk in die json-lêers in die artefakte-afdeling, of in 'n eenvoudige HTML-verslag (meer daaroor hieronder):
3. Om nutsverslae in 'n effens meer mens-leesbare vorm aan te bied, word 'n klein Python-skrif gebruik om drie JSON-lêers in een HTML-lêer met 'n tabel van defekte om te skakel.
Hierdie skrif word geloods deur 'n aparte Verslagtaak, en sy finale artefak is 'n HTML-lêer met 'n verslag. Die skrifbron is ook in die bewaarplek en kan aangepas word om by jou behoeftes, kleure, ens.
Skulpskrif
Die tweede opsie is geskik vir gevalle waar u Docker-beelde buite die CI/CD-stelsel moet nagaan of u al die instruksies in 'n vorm moet hê wat direk op die gasheer uitgevoer kan word. Hierdie opsie word gedek deur 'n klaargemaakte dopskrif wat op 'n skoon virtuele (of selfs regte) masjien uitgevoer kan word. Die skrip voer dieselfde instruksies uit as die gitlab-runner hierbo beskryf.
Vir die skrip om suksesvol te loop, moet Docker op die stelsel geïnstalleer word en die huidige gebruiker moet in die docker-groep wees.
Die skrif self kan hier gevind word:
Aan die begin van die lêer spesifiseer veranderlikes watter prent geskandeer moet word en watter kritieke defekte sal veroorsaak dat die Trivy-nutsprogram met die gespesifiseerde foutkode verlaat.
Tydens skripuitvoering sal alle nutsprogramme na die gids afgelaai word docker_tools, die resultate van hul werk is in die gids docker_tools/json, en die HTML met die verslag sal in die lêer wees resultate.html.
Voorbeeld skripuitvoer
~/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-beeld met alle nutsprogramme
As 'n derde alternatief het ek twee eenvoudige Dockerfiles saamgestel om 'n beeld met sekuriteitshulpmiddels te skep. Een Dockerfile sal help om 'n stel te bou vir die skandering van 'n prent vanaf 'n bewaarplek, die tweede (Dockerfile_tar) sal help om 'n stel te bou vir die skandering van 'n teerlêer met 'n prent.
1. Neem die ooreenstemmende Docker-lêer en skrifte uit die bewaarplek .
2. Ons begin dit vir montering:
docker build -t dscan:image -f docker_security.df .
3. Nadat die samestelling voltooi is, skep ons 'n houer uit die prent. Terselfdertyd gee ons die DOCKERIMAGE omgewingsveranderlike deur met die naam van die prent waarin ons belangstel en monteer die Dockerfile wat ons van ons masjien wil analiseer na die lêer /Dockerfile (let daarop dat die absolute pad na hierdie lêer vereis word):
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.htmlBevindinge
Ons het net na een basiese stel nutsprogramme gekyk vir die skandering van Docker-artefakte, wat, na my mening, baie effektief 'n ordentlike deel van die beeldsekuriteitsvereistes dek. Daar is ook 'n groot aantal betaalde en gratis nutsmiddels wat dieselfde kontroles kan uitvoer, pragtige verslae kan teken of suiwer in konsole-modus kan werk, houerbestuurstelsels kan dek, ens. 'n Oorsig van hierdie nutsgoed en hoe om dit te integreer kan 'n bietjie later verskyn .
Die goeie ding van die stel gereedskap wat in die artikel beskryf word, is dat hulle almal op oopbronkode gebou is en jy kan daarmee en ander soortgelyke instrumente eksperimenteer om te vind wat by jou vereistes en infrastruktuurkenmerke pas. Natuurlik moet alle kwesbaarhede wat gevind word, bestudeer word vir toepaslikheid in spesifieke toestande, maar dit is 'n onderwerp vir 'n toekomstige groot artikel.
Ek hoop dat hierdie gids, skrifte en nutsprogramme jou sal help en 'n beginpunt sal word vir die skep van 'n veiliger infrastruktuur op die gebied van containerisering.
Bron: will.com