हे हबर!

आधुनिक वास्तविकता में, विकास प्रक्रियाओं में कंटेनरीकरण की बढ़ती भूमिका के कारण, कंटेनरों से जुड़े विभिन्न चरणों और संस्थाओं की सुरक्षा सुनिश्चित करने का मुद्दा कम महत्वपूर्ण मुद्दा नहीं है। मैन्युअल जांच करने में समय लगता है, इसलिए इस प्रक्रिया को स्वचालित करने की दिशा में कम से कम प्रारंभिक कदम उठाना एक अच्छा विचार होगा।

इस लेख में, मैं इस प्रक्रिया का परीक्षण करने के लिए एक छोटे डेमो स्टैंड को तैनात करने के तरीके पर कई डॉकर सुरक्षा उपयोगिताओं और निर्देशों को लागू करने के लिए तैयार स्क्रिप्ट साझा करूंगा। आप Dockerfile छवियों और निर्देशों की सुरक्षा के परीक्षण की प्रक्रिया को व्यवस्थित करने के तरीके का प्रयोग करने के लिए सामग्रियों का उपयोग कर सकते हैं। यह स्पष्ट है कि हर किसी का विकास और कार्यान्वयन बुनियादी ढांचा अलग है, इसलिए नीचे मैं कई संभावित विकल्प प्रदान करूंगा।

सुरक्षा जाँच उपयोगिताएँ

बड़ी संख्या में विभिन्न सहायक एप्लिकेशन और स्क्रिप्ट हैं जो डॉकर बुनियादी ढांचे के विभिन्न पहलुओं की जांच करते हैं। उनमें से कुछ का वर्णन पिछले लेख में पहले ही किया जा चुका है (https://habr.com/ru/company/swordfish_security/blog/518758/#docker-security), और इस सामग्री में मैं उनमें से तीन पर ध्यान केंद्रित करना चाहूंगा, जो विकास प्रक्रिया के दौरान निर्मित डॉकर छवियों के लिए अधिकांश सुरक्षा आवश्यकताओं को कवर करते हैं। इसके अलावा, मैं एक उदाहरण भी दिखाऊंगा कि सुरक्षा जांच करने के लिए इन तीन उपयोगिताओं को एक पाइपलाइन में कैसे जोड़ा जा सकता है।

Hadolint
https://github.com/hadolint/hadolint

एक काफी सरल कंसोल उपयोगिता जो पहले सन्निकटन के रूप में, डॉकरफ़ाइल निर्देशों की शुद्धता और सुरक्षा का मूल्यांकन करने में मदद करती है (उदाहरण के लिए, केवल अधिकृत छवि रजिस्ट्रियों का उपयोग करना या सूडो का उपयोग करना)।

डॉकल
https://github.com/goodwithtech/dockle

एक कंसोल उपयोगिता जो एक छवि (या किसी छवि के सहेजे गए टार संग्रह के साथ) के साथ काम करती है, जो किसी विशेष छवि की शुद्धता और सुरक्षा की जांच करती है, इसकी परतों और कॉन्फ़िगरेशन का विश्लेषण करती है - कौन से उपयोगकर्ता बनाए जाते हैं, कौन से निर्देश उपयोग किए जाते हैं, कौन से वॉल्यूम माउंट किए गए हैं, एक खाली पासवर्ड की उपस्थिति, आदि। डी. अब तक चेक की संख्या बहुत बड़ी नहीं है और यह हमारे स्वयं के कई चेक और सिफारिशों पर आधारित है सीआईएस (इंटरनेट सुरक्षा केंद्र) बेंचमार्क डॉकर के लिए.

तुच्छ
https://github.com/aquasecurity/trivy

इस उपयोगिता का उद्देश्य दो प्रकार की कमजोरियों को ढूंढना है - ओएस बिल्ड के साथ समस्याएं (अल्पाइन, रेडहैट (ईएल), सेंटओएस, डेबियन जीएनयू, उबंटू द्वारा समर्थित) और निर्भरता के साथ समस्याएं (जेमफाइल.लॉक, पिपफाइल.लॉक, कंपोजर.लॉक, पैकेज) -लॉक.जेसन, यार्न.लॉक, कार्गो.लॉक)। ट्रिवी रिपॉजिटरी में एक छवि और एक स्थानीय छवि दोनों को स्कैन कर सकता है, और डॉकर छवि के साथ स्थानांतरित .tar फ़ाइल के आधार पर भी स्कैन कर सकता है।

उपयोगिताओं को लागू करने के विकल्प

वर्णित अनुप्रयोगों को एक अलग वातावरण में आज़माने के लिए, मैं कुछ हद तक सरलीकृत प्रक्रिया में सभी उपयोगिताओं को स्थापित करने के लिए निर्देश प्रदान करूंगा।

मुख्य विचार यह प्रदर्शित करना है कि आप विकास के दौरान बनाई गई Dockerfiles और Docker छवियों के स्वचालित सामग्री सत्यापन को कैसे कार्यान्वित कर सकते हैं।

चेक में स्वयं निम्नलिखित चरण होते हैं:

लिंटर उपयोगिता का उपयोग करके डॉकरफ़ाइल निर्देशों की शुद्धता और सुरक्षा की जाँच करना Hadolint
एक उपयोगिता का उपयोग करके अंतिम और मध्यवर्ती छवियों की शुद्धता और सुरक्षा की जाँच करना डॉकल
उपयोगिता का उपयोग करके आधार छवि और कई निर्भरताओं में सार्वजनिक रूप से ज्ञात कमजोरियों (सीवीई) की उपस्थिति की जाँच करना तुच्छ

लेख में बाद में मैं इन चरणों को लागू करने के लिए तीन विकल्प दूंगा:
पहला उदाहरण के रूप में GitLab का उपयोग करके CI/CD पाइपलाइन को कॉन्फ़िगर करना है (परीक्षण उदाहरण बढ़ाने की प्रक्रिया के विवरण के साथ)।
दूसरा शेल स्क्रिप्ट का उपयोग कर रहा है।
तीसरे में डॉकर छवियों को स्कैन करने के लिए एक डॉकर छवि बनाना शामिल है।
आप वह विकल्प चुन सकते हैं जो आपके लिए सबसे उपयुक्त हो, इसे अपने बुनियादी ढांचे में स्थानांतरित करें और इसे अपनी आवश्यकताओं के अनुसार अनुकूलित करें।

सभी आवश्यक फ़ाइलें और अतिरिक्त निर्देश भी रिपॉजिटरी में स्थित हैं: https://github.com/Swordfish-Security/docker_cicd

GitLab CI/CD में एकीकरण

पहले विकल्प में, हम देखेंगे कि आप उदाहरण के तौर पर GitLab रिपॉजिटरी सिस्टम का उपयोग करके सुरक्षा जांच कैसे लागू कर सकते हैं। यहां हम चरणों से गुजरेंगे और यह पता लगाएंगे कि शुरुआत से GitLab के साथ एक परीक्षण वातावरण कैसे स्थापित किया जाए, एक स्कैनिंग प्रक्रिया बनाई जाए और परीक्षण Dockerfile और एक यादृच्छिक छवि - JuiceShop एप्लिकेशन की जांच के लिए उपयोगिताओं को लॉन्च किया जाए।

गिटलैब स्थापित करना
1. डॉकर स्थापित करें:

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

2. वर्तमान उपयोगकर्ता को docker समूह में जोड़ें ताकि आप sudo का उपयोग किए बिना docker के साथ काम कर सकें:

sudo addgroup <username> docker

3. अपना आईपी ढूंढें:

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 सभी आवश्यक इंस्टॉलेशन प्रक्रियाओं को पूरा नहीं कर लेता (आप लॉग फ़ाइल आउटपुट के माध्यम से प्रक्रिया की निगरानी कर सकते हैं: docker logs -f gitlab)।

5. ब्राउज़र में अपना स्थानीय आईपी खोलें और एक पेज देखें जो आपसे रूट उपयोगकर्ता के लिए पासवर्ड बदलने के लिए कह रहा है:

नया पासवर्ड सेट करें और GitLab पर जाएं।

6. एक नया प्रोजेक्ट बनाएं, उदाहरण के लिए सीआईसीडी-टेस्ट और इसे स्टार्ट फ़ाइल के साथ आरंभ करें 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. रनर के लिए एक ओएस उपयोगकर्ता जोड़ें और सेवा शुरू करें:

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. अब हम रनर को पंजीकृत करते हैं ताकि यह हमारे GitLab इंस्टेंस के साथ इंटरैक्ट कर सके।
ऐसा करने के लिए, सेटिंग्स-सीआई/सीडी पेज (http://OUR_IP_ADDRESS/root/cicd-test/-/settings/ci_cd) खोलें और रनर टैब पर यूआरएल और पंजीकरण टोकन ढूंढें:

11. यूआरएल और पंजीकरण टोकन को प्रतिस्थापित करके रनर रजिस्टर करें:

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 मिलता है, जिसमें हमें अपनी उपयोगिताओं को शुरू करने के लिए निर्देश जोड़ने की आवश्यकता होती है। इस डेमो में हमारे पास एप्लिकेशन बनाने और उसे कंटेनरीकृत करने के चरण नहीं हैं, लेकिन वास्तविक वातावरण में ये स्कैनिंग चरणों से पहले होंगे और विश्लेषण के लिए छवियां और डॉकरफाइल उत्पन्न करेंगे।

पाइपलाइन विन्यास

1. रिपॉजिटरी में फ़ाइलें जोड़ें mydockerfile.df (यह एक परीक्षण डॉकरफाइल है जिसे हम जांचेंगे) और 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 फ़ाइल में उपयोगिताओं के लिए इनपुट पैरामीटर बदलने की आवश्यकता होगी)

ध्यान दें: ट्रिवी को स्थापित करने की आवश्यकता है rpm и Git. अन्यथा, यह RedHat-आधारित छवियों को स्कैन करते समय और भेद्यता डेटाबेस में अपडेट प्राप्त करते समय त्रुटियां उत्पन्न करेगा।

2. रिपॉजिटरी में फ़ाइलें जोड़ने के बाद, हमारी कॉन्फ़िगरेशन फ़ाइल के निर्देशों के अनुसार, GitLab स्वचालित रूप से निर्माण और स्कैन प्रक्रिया शुरू कर देगा। सीआई/सीडी → पाइपलाइन टैब पर आप निर्देशों की प्रगति देख सकते हैं।

परिणामस्वरूप, हमारे पास चार कार्य हैं। उनमें से तीन सीधे स्कैनिंग से संबंधित हैं, और अंतिम (रिपोर्ट) स्कैनिंग परिणामों के साथ बिखरी हुई फ़ाइलों से एक सरल रिपोर्ट एकत्र करता है।

डिफ़ॉल्ट रूप से, यदि छवि या निर्भरता में गंभीर कमजोरियाँ पाई जाती हैं तो ट्रिवी चलना बंद कर देता है। साथ ही, Hadolint हमेशा एक सक्सेस कोड लौटाता है क्योंकि इसके परिणामस्वरूप हमेशा टिप्पणियाँ आती हैं, जिसके कारण निर्माण रुक जाता है।

आपकी विशिष्ट आवश्यकताओं के आधार पर, आप एक निकास कोड कॉन्फ़िगर कर सकते हैं ताकि जब ये उपयोगिताएँ एक निश्चित गंभीरता की समस्याओं का पता लगाएँ, तो वे निर्माण प्रक्रिया को भी रोक दें। हमारे मामले में, निर्माण केवल तभी रुकेगा जब ट्रिवी उस गंभीरता के साथ एक भेद्यता का पता लगाता है जिसे हमने SHOWSTOPPER वैरिएबल में निर्दिष्ट किया है .gitlab-ci.yml.

प्रत्येक उपयोगिता का परिणाम प्रत्येक स्कैनिंग कार्य के लॉग में, सीधे कलाकृतियों अनुभाग में json फ़ाइलों में, या एक साधारण HTML रिपोर्ट में देखा जा सकता है (उस पर अधिक जानकारी नीचे दी गई है):

3. उपयोगिता रिपोर्ट को थोड़ा अधिक मानव-पठनीय रूप में प्रस्तुत करने के लिए, तीन JSON फ़ाइलों को दोषों की तालिका के साथ एक HTML फ़ाइल में परिवर्तित करने के लिए एक छोटी पायथन स्क्रिप्ट का उपयोग किया जाता है।
यह स्क्रिप्ट एक अलग रिपोर्ट कार्य द्वारा लॉन्च की गई है, और इसका अंतिम आर्टिफैक्ट एक रिपोर्ट के साथ एक HTML फ़ाइल है। स्क्रिप्ट स्रोत भी रिपॉजिटरी में है और इसे आपकी आवश्यकताओं, रंगों आदि के अनुरूप अनुकूलित किया जा सकता है।

शैल स्क्रिप्ट

दूसरा विकल्प उन मामलों के लिए उपयुक्त है जब आपको सीआई/सीडी सिस्टम के बाहर डॉकर छवियों की जांच करने की आवश्यकता होती है या आपको सभी निर्देशों को एक ऐसे फॉर्म में रखने की आवश्यकता होती है जिसे सीधे होस्ट पर निष्पादित किया जा सके। यह विकल्प एक तैयार शेल स्क्रिप्ट द्वारा कवर किया गया है जिसे एक साफ़ वर्चुअल (या यहां तक कि वास्तविक) मशीन पर चलाया जा सकता है। स्क्रिप्ट ऊपर वर्णित गिटलैब-रनर के समान निर्देशों को निष्पादित करती है।

स्क्रिप्ट को सफलतापूर्वक चलाने के लिए, डॉकर को सिस्टम पर स्थापित किया जाना चाहिए और वर्तमान उपयोगकर्ता को डॉकर समूह में होना चाहिए।

स्क्रिप्ट स्वयं यहां पाई जा सकती है: docker_sec_check.sh

फ़ाइल की शुरुआत में, वेरिएबल निर्दिष्ट करते हैं कि किस छवि को स्कैन करने की आवश्यकता है और कौन से महत्वपूर्ण दोष ट्रिवी उपयोगिता को निर्दिष्ट त्रुटि कोड के साथ बाहर निकलने का कारण बनेंगे।

स्क्रिप्ट निष्पादन के दौरान, सभी उपयोगिताओं को निर्देशिका में डाउनलोड किया जाएगा docker_tools, उनके कार्य के परिणाम निर्देशिका में हैं docker_tools/json, और रिपोर्ट वाला HTML फ़ाइल में होगा परिणाम.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

सभी उपयोगिताओं के साथ डॉकर छवि

तीसरे विकल्प के रूप में, मैंने सुरक्षा उपयोगिताओं के साथ एक छवि बनाने के लिए दो सरल डॉकरफ़ाइलें संकलित कीं। एक Dockerfile एक रिपॉजिटरी से एक छवि को स्कैन करने के लिए एक सेट बनाने में मदद करेगा, दूसरा (Dockerfile_tar) एक छवि के साथ एक टार फ़ाइल को स्कैन करने के लिए एक सेट बनाने में मदद करेगा।

1. रिपॉजिटरी से संबंधित डॉकर फ़ाइल और स्क्रिप्ट लें 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

निष्कर्ष

हमने डॉकर कलाकृतियों को स्कैन करने के लिए उपयोगिताओं के केवल एक बुनियादी सेट को देखा, जो, मेरी राय में, छवि सुरक्षा आवश्यकताओं के एक अच्छे हिस्से को बहुत प्रभावी ढंग से कवर करता है। बड़ी संख्या में सशुल्क और मुफ्त उपकरण भी हैं जो समान जांच कर सकते हैं, सुंदर रिपोर्ट तैयार कर सकते हैं या पूरी तरह से कंसोल मोड में काम कर सकते हैं, कंटेनर प्रबंधन सिस्टम आदि को कवर कर सकते हैं। इन उपकरणों का अवलोकन और उन्हें कैसे एकीकृत किया जाए, यह थोड़ी देर बाद दिखाई दे सकता है .

इस आलेख में वर्णित उपकरणों के सेट के बारे में अच्छी बात यह है कि वे सभी खुले स्रोत हैं और आप उनके और अन्य समान उपकरणों के साथ प्रयोग करके यह पता लगा सकते हैं कि आपकी आवश्यकताओं और बुनियादी ढांचे के लिए क्या उपयुक्त है। बेशक, पाई गई सभी कमजोरियों का विशिष्ट परिस्थितियों में प्रयोज्यता के लिए अध्ययन किया जाना चाहिए, लेकिन यह भविष्य के बड़े लेख का विषय है।

मुझे उम्मीद है कि यह गाइड, स्क्रिप्ट और उपयोगिताएँ आपकी मदद करेंगी और कंटेनरीकरण के क्षेत्र में अधिक सुरक्षित बुनियादी ढाँचा बनाने के लिए एक शुरुआती बिंदु बन जाएंगी।

स्रोत: www.habr.com

डॉकर सुरक्षा की जाँच के लिए उपयोगिताओं को लागू करने के तरीके और उदाहरण