ჰეი ჰაბრ!

დღევანდელ რეალობაში, განვითარების პროცესებში კონტეინერიზაციის როლის გაზრდის გამო, კონტეინერებთან დაკავშირებული სხვადასხვა ეტაპისა და სუბიექტების უსაფრთხოების უზრუნველყოფის საკითხი ბოლო ადგილზე არ დგას. შემოწმებების ხელით შესრულება შრომატევადი ამოცანაა, ამიტომ კარგი იქნება ამ პროცესის ავტომატიზაციისკენ მინიმუმ საწყისი ნაბიჯების გადადგმა.

ამ სტატიაში მე გაგიზიარებთ მზა სკრიპტებს Docker უსაფრთხოების რამდენიმე პროგრამის განსახორციელებლად და ინსტრუქციებს, თუ როგორ უნდა დააყენოთ პატარა დემო სტენდი ამ პროცესის შესამოწმებლად. თქვენ შეგიძლიათ გამოიყენოთ მასალები ექსპერიმენტებისთვის, თუ როგორ უნდა მოაწყოთ Dockerfile სურათებისა და ინსტრუქციების უსაფრთხოების ტესტირების პროცესი. გასაგებია, რომ განვითარებისა და განხორციელების ინფრასტრუქტურა ყველასთვის განსხვავებულია, ამიტომ ქვემოთ რამდენიმე შესაძლო ვარიანტს მოგცემთ.

უსაფრთხოების შემოწმების საშუალებები

არსებობს დიდი რაოდენობით სხვადასხვა დამხმარე აპლიკაციები და სკრიპტები, რომლებიც ამოწმებენ Docker ინფრასტრუქტურის სხვადასხვა ასპექტს. ზოგიერთი მათგანი უკვე აღწერილია წინა სტატიაში (https://habr.com/ru/company/swordfish_security/blog/518758/#docker-security), და ამ სტატიაში მინდა გავამახვილო ყურადღება სამ მათგანზე, რომლებიც მოიცავს Docker სურათების უსაფრთხოების მოთხოვნების დიდ ნაწილს, რომლებიც აგებულია განვითარების პროცესში. გარდა ამისა, მე ასევე გაჩვენებთ მაგალითს, თუ როგორ შეიძლება ეს სამი კომუნალური პროგრამა გაერთიანდეს ერთ მილსადენში უსაფრთხოების შემოწმების შესასრულებლად.

ჰადოლინი
https://github.com/hadolint/hadolint

საკმაოდ მარტივი კონსოლის პროგრამა, რომელიც ეხმარება, როგორც პირველი მიახლოებით, შეაფასოს Dockerfile ინსტრუქციების სისწორე და უსაფრთხოება (მაგალითად, მხოლოდ ავტორიზებული გამოსახულების რეესტრის გამოყენებით ან სუდოს გამოყენებით).

დოქლი
https://github.com/goodwithtech/dockle

კონსოლის პროგრამა, რომელიც მუშაობს სურათზე (ან შენახულ გამოსახულების ტარბოლზე), რომელიც ამოწმებს კონკრეტული სურათის სისწორეს და უსაფრთხოებას, როგორც ასეთი, მისი ფენების და კონფიგურაციის ანალიზით - რა მომხმარებლები არიან შექმნილი, რა ინსტრუქციები გამოიყენება, რა ტომი არის დამონტაჟებული. , ცარიელი პაროლის არსებობა და ა.შ. დ. ჯერჯერობით შემოწმებების რაოდენობა არც თუ ისე დიდია და ეფუძნება რამდენიმე ჩვენს საკუთარ შემოწმებას და რეკომენდაციას დსს (ინტერნეტ უსაფრთხოების ცენტრი) ბენჩმარკი დოკერისთვის.


წვრილმანი
https://github.com/aquasecurity/trivy

ეს პროგრამა მიზნად ისახავს ორი ტიპის დაუცველობის პოვნას - OS-ის აგების პრობლემები (Alpine, RedHat (EL), CentOS, Debian GNU, Ubuntu არის მხარდაჭერილი) და დამოკიდებულების პრობლემები (Gemfile.lock, Pipfile.lock, composer.lock, პაკეტის დაბლოკვა). .json , ნართი.საკეტი, Cargo.lock). Trivy-ს შეუძლია სკანირება მოახდინოს როგორც საცავში, ასევე ლოკალურ სურათზე, ასევე სკანირება გადაცემული .tar ფაილის საფუძველზე Docker-ის გამოსახულებაზე.

Utilities განხორციელების პარამეტრები

იმისათვის, რომ სცადოთ აღწერილი აპლიკაციები იზოლირებულ გარემოში, მე მივცემ ინსტრუქციებს ყველა კომუნალური პროგრამის დაყენების შესახებ გარკვეულწილად გამარტივებულ პროცესში.

მთავარი იდეა არის იმის დემონსტრირება, თუ როგორ შეგიძლიათ განახორციელოთ Dockerfiles და Docker სურათების ავტომატური შინაარსის გადამოწმება, რომლებიც შექმნილია განვითარების დროს.

თავად შემოწმება შედგება შემდეგი ნაბიჯებისგან:

1. Dockerfile-ის ინსტრუქციების სისწორისა და უსაფრთხოების შემოწმება ლინტერის საშუალებით ჰადოლინი
2. საბოლოო და შუალედური სურათების სისწორისა და უსაფრთხოების შემოწმება უტილიტის გამოყენებით დოქლი
3. საბაზისო სურათში საჯაროდ ცნობილი დაუცველობის (CVE) არსებობის შემოწმება და რიგი დამოკიდებულების არსებობა - უტილიტის გამოყენებით წვრილმანი

მოგვიანებით სტატიაში მე მივცემ სამ ვარიანტს ამ ნაბიჯების განსახორციელებლად:
პირველი არის CI/CD მილსადენის კონფიგურაცია GitLab-ის მაგალითის გამოყენებით (სატესტო ინსტანციის ამაღლების პროცესის აღწერით).
მეორე არის shell სკრიპტის გამოყენება.
მესამე არის Docker გამოსახულების აგება Docker სურათების სკანირებისთვის.
თქვენ შეგიძლიათ აირჩიოთ თქვენთვის ყველაზე შესაფერისი ვარიანტი, გადაიტანოთ იგი თქვენს ინფრასტრუქტურაში და მოერგოთ თქვენს საჭიროებებს.

ყველა საჭირო ფაილი და დამატებითი ინსტრუქციები ასევე განთავსებულია საცავში: https://github.com/Swordfish-Security/docker_cicd

ინტეგრაცია GitLab CI/CD-ში

პირველ ვარიანტში ჩვენ შევხედავთ, თუ როგორ შეგიძლიათ განახორციელოთ უსაფრთხოების შემოწმებები GitLab საცავის სისტემის, როგორც მაგალითის გამოყენებით. აქ ჩვენ გავივლით ნაბიჯებს და გავარკვევთ, თუ როგორ უნდა დააინსტალიროთ სატესტო გარემო GitLab-ით ნულიდან, შევქმნათ სკანირების პროცესი და გავუშვით უტილიტები ტესტის Dockerfile-ისა და შემთხვევითი სურათის შესამოწმებლად - JuiceShop აპლიკაცია.

GitLab-ის ინსტალაცია
1. დააინსტალირეთ Docker:

sudo apt-get update && sudo apt-get install docker.io

2. დაამატეთ ამჟამინდელი მომხმარებელი დოკერის ჯგუფში, რათა შეძლოთ დოკერთან მუშაობა სუდოს გამოყენების გარეშე:

sudo addgroup <username> docker

3. იპოვეთ თქვენი IP:

ip addr

4. დააინსტალირეთ და გაუშვით GitLab კონტეინერში, ჩაანაცვლეთ IP მისამართი ჰოსტის სახელში თქვენით:

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:latest

ჩვენ ველოდებით GitLab-ს დაასრულებს ინსტალაციის ყველა საჭირო პროცედურას (შეგიძლიათ თვალი ადევნოთ პროცესს log ფაილის გამოსვლიდან: docker logs -f gitlab).

5. გახსენით თქვენი ადგილობრივი IP ბრაუზერში და ნახეთ გვერდი, რომელიც გთავაზობთ პაროლის შეცვლას root მომხმარებლისთვის:

დააყენეთ ახალი პაროლი და გადადით GitLab-ში.

6. შექმენით ახალი პროექტი, მაგალითად, cicd-test და დააინსტალირეთ მისი საწყისი ფაილი README.md:

7. ახლა ჩვენ უნდა დავაინსტალიროთ GitLab Runner: აგენტი, რომელიც მოთხოვნის შემთხვევაში განახორციელებს ყველა საჭირო ოპერაციას.
ჩამოტვირთეთ უახლესი ვერსია (ამ შემთხვევაში, Linux 64-ბიტისთვის):

sudo curl -L --output /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-linux-amd64

8. გახადეთ ის შესრულებადი:

sudo chmod +x /usr/local/bin/gitlab-runner

9. დაამატეთ OS მომხმარებელი Runner-ისთვის და დაიწყეთ სერვისი:

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 start

ეს უნდა გამოიყურებოდეს დაახლოებით ასე:

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. ახლა ჩვენ ვარეგისტრირებთ Runner-ს, რათა მან შეძლოს ურთიერთქმედება ჩვენს GitLab მაგალითთან.
ამისათვის გახსენით Settings-CI/CD გვერდი (http://OUR_ IP_ADDRESS/root/cicd-test/-/settings/ci_cd) და Runners ჩანართზე იპოვეთ URL და რეგისტრაციის ნიშანი:

11. დაარეგისტრირეთ Runner URL-ისა და რეგისტრაციის ნიშნის ჩანაცვლებით:

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"

შედეგად, ჩვენ ვიღებთ მზა სამუშაო GitLab-ს, რომელშიც უნდა დავამატოთ ინსტრუქციები ჩვენი უტილიტების დასაწყებად. ამ დემო ვერსიაში ჩვენ არ გვაქვს ნაბიჯები აპლიკაციის შესაქმნელად და კონტეინერიზაციისთვის, მაგრამ რეალურ გარემოში ეს წინ უსწრებს სკანირების ნაბიჯებს და წარმოქმნის სურათებს და Dockerfile-ს ანალიზისთვის.

მილსადენის კონფიგურაცია

1. დაამატეთ ფაილები საცავში mydockerfile.df (ეს არის სატესტო Dockerfile, რომელსაც ჩვენ შევამოწმებთ) და GitLab CI/CD პროცესის კონფიგურაციის ფაილი .gitlab-cicd.yml, რომელშიც ჩამოთვლილია ინსტრუქციები სკანერებისთვის (აღნიშნეთ წერტილი ფაილის სახელში).

.yaml კონფიგურაციის ფაილი შეიცავს ინსტრუქციებს სამი კომუნალური პროგრამის (Hadolint, Dockle და Trivy) გაშვებისთვის, რომლებიც აანალიზებენ არჩეულ Dockerfile-ს და DOCKERFILE ცვლადში მითითებულ სურათს. ყველა საჭირო ფაილის აღება შესაძლებელია საცავიდან: https://github.com/Swordfish-Security/docker_cicd/

ამონარიდი mydockerfile.df (ეს არის აბსტრაქტული ფაილი თვითნებური ინსტრუქციების ნაკრებით მხოლოდ იმის საჩვენებლად, თუ როგორ მუშაობს პროგრამა). ფაილის პირდაპირი ბმული: mydockerfile.df

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 root

YAML კონფიგურაცია ასე გამოიყურება (ფაილი თავად შეგიძლიათ იხილოთ პირდაპირი ბმულის საშუალებით აქ: .gitlab-ci.yml):

.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.html

საჭიროების შემთხვევაში, შენახული სურათების სკანირებაც შეგიძლიათ .tar არქივის სახით (თუმცა, თქვენ უნდა შეცვალოთ YAML ფაილში კომუნალური პროგრამების შეყვანის პარამეტრები)

შენიშვნა: Trivy საჭიროებს ინსტალაციას rpm и ტურიზმი. წინააღმდეგ შემთხვევაში, ის წარმოქმნის შეცდომებს RedHat-ზე დაფუძნებული სურათების სკანირებისა და დაუცველობის მონაცემთა ბაზის განახლებების მიღებისას.

2. საცავში ფაილების დამატების შემდეგ, ჩვენი კონფიგურაციის ფაილში მოცემული ინსტრუქციის მიხედვით, GitLab ავტომატურად დაიწყებს აშენებისა და სკანირების პროცესს. CI/CD → Pipelines ჩანართზე შეგიძლიათ იხილოთ ინსტრუქციების პროგრესი.

შედეგად, ჩვენ გვაქვს ოთხი დავალება. სამი მათგანი უშუალოდ ეხება სკანირებას, ხოლო ბოლო (მოხსენება) აგროვებს მარტივ ანგარიშს გაფანტული ფაილებიდან სკანირების შედეგებით.

ნაგულისხმევად, Trivy აჩერებს მის შესრულებას, თუ გამოსახულებაში ან დამოკიდებულებებში აღმოჩენილია კრიტიკული დაუცველობა. ამავდროულად, Hadolint ყოველთვის აბრუნებს Success-ს შესრულების კოდში, რადგან მის შესრულებას ყოველთვის აქვს შენიშვნები, რაც იწვევს build-ის შეჩერებას.

თქვენი სპეციფიკური მოთხოვნებიდან გამომდინარე, შეგიძლიათ დააკონფიგურიროთ გასასვლელი კოდი ისე, რომ ამ კომუნალურმა მომსახურებებმა ასევე შეაჩერონ მშენებლობის პროცესი გარკვეული კრიტიკულობის პრობლემების გამოვლენისას. ჩვენს შემთხვევაში, build შეჩერდება მხოლოდ იმ შემთხვევაში, თუ Trivy აღმოაჩენს დაუცველობას იმ სიმძიმით, რომელიც მითითებულია SHOWSTOPPER ცვლადში. .gitlab-ci.yml.


თითოეული პროგრამის მუშაობის შედეგი შეიძლება იხილოთ თითოეული სკანირების ამოცანის ჟურნალში, უშუალოდ json ფაილებში არტეფაქტების განყოფილებაში, ან მარტივ HTML ანგარიშში (დაწვრილებით ამის შესახებ ქვემოთ):


3. უტილიტას ანგარიშების ოდნავ უფრო ადვილად წასაკითხად წარმოდგენისთვის, პატარა Python სკრიპტი გამოიყენება სამი JSON ფაილის გადასაყვანად ერთ HTML ფაილად დეფექტების ცხრილით.
ეს სკრიპტი გაშვებულია ცალკე ანგარიშის ამოცანებით და მისი საბოლოო არტეფაქტი არის HTML ფაილი მოხსენებით. სკრიპტის წყარო ასევე არის საცავში და შეიძლება მოერგოს თქვენს საჭიროებებს, ფერებს და ა.შ.

Shell სკრიპტი

მეორე ვარიანტი შესაფერისია იმ შემთხვევებისთვის, როდესაც საჭიროა Docker-ის სურათების შემოწმება CI/CD სისტემის გარეთ, ან უნდა გქონდეთ ყველა ინსტრუქცია იმ ფორმით, რომელიც შეიძლება შესრულდეს პირდაპირ ჰოსტზე. ეს ვარიანტი დაფარულია მზა shell სკრიპტით, რომელიც შეიძლება გაშვებული იყოს სუფთა ვირტუალურ (ან თუნდაც რეალურ) მანქანაზე. სკრიპტი ასრულებს იგივე ინსტრუქციებს, როგორც ზემოთ აღწერილი gitlab-runner.

იმისათვის, რომ სკრიპტმა წარმატებით იმუშაოს, Docker უნდა იყოს დაინსტალირებული სისტემაში და მიმდინარე მომხმარებელი უნდა იყოს დოკერ ჯგუფში.

თავად სკრიპტი შეგიძლიათ იხილოთ აქ: docker_sec_check.sh

ფაილის დასაწყისში, ცვლადები განსაზღვრავენ, რომელი სურათის დასკანირებაა საჭირო და რომელი კრიტიკული დეფექტები გამოიწვევს Trivy უტილიტას გასვლას მითითებული შეცდომის კოდით.

სკრიპტის შესრულების დროს, ყველა კომუნალური პროგრამა ჩამოიტვირთება დირექტორიაში docker_tools, მათი მუშაობის შედეგები დირექტორიაშია docker_tools/json, და HTML ანგარიშით იქნება ფაილში results.html.

სკრიპტის გამომავალი მაგალითი

~/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.html

დოკერის სურათი ყველა კომუნალური საშუალებით

როგორც მესამე ალტერნატივა, მე შევადგინე ორი მარტივი Dockerfiles გამოსახულების შესაქმნელად უსაფრთხოების კომუნალური საშუალებებით. ერთი Dockerfile დაეხმარება შექმნას ნაკრები სურათის საცავიდან სკანირებისთვის, მეორე (Dockerfile_tar) ააშენებს კომპლექტს tar ფაილის გამოსახულების სკანირებისთვის.

1. აიღეთ შესაბამისი Docker ფაილი და სკრიპტები საცავიდან https://github.com/Swordfish-Security/docker_cicd/tree/master/Dockerfile.
2. გაუშვით შეკრებისთვის:

docker build -t dscan:image -f docker_security.df .

3. შეკრების დასრულების შემდეგ ჩვენ ვქმნით კონტეინერს გამოსახულებისგან. ამავდროულად, ჩვენ გადავცემთ DOCKERIMAGE გარემოს ცვლადს იმ სურათის სახელთან, რომელიც ჩვენ გვაინტერესებს და ვამონტაჟებთ Dockerfile-ს, რომელიც გვინდა გავაანალიზოთ ჩვენი მანქანიდან ფაილში. /დოკერფაილი (გაითვალისწინეთ, რომ ამ ფაილის აბსოლუტური გზაა საჭირო):

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.html

დასკვნები

ჩვენ განვიხილეთ Docker artifact-ის სკანირების საშუალებების მხოლოდ ერთი ძირითადი ნაკრები, რომელიც, ვფიქრობ, საკმაოდ ეფექტურად ფარავს გამოსახულების უსაფრთხოების მოთხოვნების კარგ ნაწილს. არსებობს მრავალი სხვა ფასიანი და უფასო ხელსაწყოები, რომლებსაც შეუძლიათ შეასრულონ იგივე შემოწმება, შექმნან ლამაზი ანგარიშები ან იმუშაონ მხოლოდ კონსოლის რეჟიმში, დაფარონ კონტეინერის მართვის სისტემები და ა.შ.

სტატიაში აღწერილი ხელსაწყოების ნაკრების დადებითი მხარე არის ის, რომ ისინი ყველა აგებულია ღია წყაროზე და შეგიძლიათ ექსპერიმენტი გააკეთოთ მათთან და სხვა მსგავსი ინსტრუმენტებით, რათა იპოვოთ ზუსტად რა შეესაბამება თქვენს მოთხოვნებს და ინფრასტრუქტურის მახასიათებლებს. რა თქმა უნდა, ყველა დაუცველობა, რომელიც აღმოჩენილია, უნდა იქნას შესწავლილი კონკრეტულ პირობებში გამოსაყენებლად, მაგრამ ეს არის მომავალი დიდი სტატიის თემა.

იმედი მაქვს, რომ ეს ინსტრუქციები, სკრიპტები და უტილიტები დაგეხმარებათ და გახდება საწყისი წერტილი კონტეინერიზაციის სფეროში უფრო უსაფრთხო ინფრასტრუქტურის შესაქმნელად.

წყარო: www.habr.com