ความสับสนในการพึ่งพา - การตรึงเวอร์ชัน

การขาดการกำหนดเวอร์ชันที่แน่นอนและความสับสนในเรื่องการพึ่งพา

ในการพัฒนาซอฟต์แวร์ เราต้องพึ่งพาทั้งส่วนประกอบหรืออาร์ติแฟกต์ของตนเองและจากภายนอก การจัดการการพึ่งพาที่ยืดหยุ่นจึงเป็นสิ่งสำคัญสำหรับซอฟต์แวร์สมัยใหม่ ตัวจัดการแพ็กเกจเช่น NPM, Maven, จุดเล็ก ๆ or นูเก็ท เครื่องมือเหล่านี้มักใช้เพื่อระบุความสัมพันธ์ของซอฟต์แวร์ โดยได้รับการออกแบบโดยคำนึงถึงความสะดวกสบายและใช้งานง่ายเป็นหลัก ไม่ใช่เพื่อความปลอดภัย

 

ปัญหา

ปัญหาคือ ความยืดหยุ่นและความง่ายในการใช้งานสำหรับนักพัฒนาซอฟต์แวร์ดึงดูดผู้ไม่หวังดี ซึ่งมองว่าการพึ่งพาซอฟต์แวร์เป็นสิ่งที่ดึงดูดใจธุรกิจของพวกเขาอย่างไม่อาจต้านทานได้ ผลที่ตามมาคือ ผู้ไม่หวังดีได้ใช้ทุกช่องทางการโจมตีที่เป็นไปได้ดังที่แสดงไว้ในที่นี้ ที่มา: “Backstabber's Knife Collection: A Review of Open Source Software Supply Chain Attacks”

ในบทความนี้ เราจะเน้นไปที่การใช้การประกาศเวอร์ชันแบบเปิด ซึ่งหมายความว่าเวอร์ชันที่ดาวน์โหลดมานั้นไม่ได้ตายตัว แต่ต้องอยู่ในช่วงที่กำหนดไว้ ในระหว่างการสร้างโปรแกรม ระบบจะเลือกเวอร์ชันที่มีอยู่สูงสุดที่เข้ากันได้กับช่วงเวอร์ชันที่ระบุไว้ แล้วดาวน์โหลด/ติดตั้งโดยตัวจัดการแพ็กเกจ

เรามาลองยกตัวอย่างการประกาศแบบเปิดในส่วนการประกาศการพึ่งพาสำหรับตัวจัดการแพ็กเกจต่างๆ กัน:

      • เอ็นพีเอ็ม: package.json

    {

     

       ...

       “การพึ่งพา”: {
          ...
          “ยอมรับ”: “>=1.3.8”
          “lodash”: “~4.16.0”
          ...
       },
       ...
    }

    จะติดตั้งเวอร์ชันที่ใหญ่ที่สุดที่มีอยู่ซึ่งไม่ต่ำกว่า 1.3.8 สำหรับแพ็คเกจ accepts รวมถึงการอัปเดต 'แพทช์' ที่ใหญ่ที่สุดสำหรับ lodash ในช่วง 4.16.x ด้วย

        • มาเวน: pom.xml

      ...

      ...

           คอมมอนส์-ไอโอ
           คอมมอนส์-ไอโอ
           ปล่อย

      ...

      ...

      เวอร์ชันล่าสุดที่มีให้ใช้งานสำหรับ commons-io (ไฟล์ jar) จะถูกเพิ่มเป็นส่วนประกอบที่จำเป็น

          • ปี๊บ: setup.py

        ...
        ติดตั้ง(
            ...
            install_requires=['peppercorn', 'launchpadlib'],
            ...
        )
        ...

        โครงการเวอร์ชันเปิดดังกล่าวมีทั้งข้อดีและข้อเสีย ข้อดีคือเวอร์ชันใหม่ ๆ จะได้รับการพัฒนาต่อไป มักจะ ประกอบด้วยการปรับปรุงด้านฟังก์ชันการทำงานและคุณภาพ การแก้ไขข้อบกพร่อง และแพตช์ความปลอดภัย ซึ่งจะได้รับการอัปเกรดโดยอัตโนมัติ โปรดทราบว่าสำหรับโครงการจริงส่วนใหญ่ การแก้ไขจะไม่ถูกย้อนกลับไปยังเวอร์ชันย่อยก่อนหน้า ยกเว้นอาจเป็นช่องโหว่ด้านความปลอดภัยที่ร้ายแรง เวอร์ชันแบบเปิดยังเหมาะสำหรับการใช้งานในไลบรารี เพื่อลดจำนวนเวอร์ชันที่ต้องติดตั้งเมื่อแก้ไขการพึ่งพาของส่วนประกอบทั้งหมดแล้ว

        แต่การกำหนดช่วงเวอร์ชันแบบเปิดก็มีข้อเสียอยู่ คุณไม่รู้แน่ชัดว่าเวอร์ชันใดจะถูกติดตั้งในระหว่างการสร้าง และการสร้างนั้นไม่สามารถทำซ้ำได้ นอกจากนี้ยังมีข้อเสียอีกด้วย มืด ควรเลือกใช้เวอร์ชันแบบเปิด หากผู้ไม่ประสงค์ดีสามารถเผยแพร่ส่วนประกอบที่เป็นอันตรายในที่เก็บสาธารณะด้วยเวอร์ชันสูงที่เข้ากันได้กับช่วงเวอร์ชันแบบเปิดของคุณ การสร้างเวอร์ชันถัดไปของคุณจะรวมส่วนประกอบที่เป็นอันตรายนั้นไว้ด้วย และอาจถึงขั้นเรียกใช้มัลแวร์ในสคริปต์การติดตั้งที่อาจถูกเรียกใช้โดยอัตโนมัติ การปกปิดเพย์โหลดการโจมตีจึงเป็นศิลปะอย่างหนึ่ง

        ซึ่งเป็นที่รู้จักกันในนาม ขาดการตรึงเวอร์ชัน ปัญหา.

        ผู้ไม่ประสงค์ดีมักพยายามสร้างเวอร์ชันที่เป็นอันตรายของแพ็กเกจโอเพนซอร์สยอดนิยม พวกเขาอาจเข้าถึงคีย์สำหรับที่เก็บแพ็กเกจผ่านการรั่วไหลของข้อมูลลับ โดยมักใช้เทคนิคทางสังคม หรือซ่อนการพึ่งพาที่เป็นอันตรายซ้อนอยู่ภายในสิ่งที่ดูเหมือนจะมีประโยชน์ pull requestแม้แต่ผู้เขียนบางคนเองก็อาจตัดสินใจว่าโลกนี้ไม่ยุติธรรม และหันมาตำหนิลูกค้าของตนด้วยถ้อยคำที่รุนแรง ประท้วง ในบรรจุภัณฑ์ของตัวเอง!

        ลองนึกภาพว่าคุณทำงานให้กับองค์กรที่ใช้ทั้งส่วนประกอบภายในและส่วนประกอบโอเพนซอร์ส
        หากผู้ไม่ประสงค์ดีรู้ชื่อของส่วนประกอบภายในเหล่านั้น เขา/เธอสามารถเผยแพร่ส่วนประกอบที่มีชื่อเดียวกันลงในที่เก็บสาธารณะได้ ตัวจัดการแพ็กเกจจำนวนมากจะดาวน์โหลดส่วนประกอบสาธารณะก่อน และหากเลือกเวอร์ชันอย่างถูกต้องและเวอร์ชันใน dependency ที่ประกาศไว้เป็นแบบโอเพนซอร์ส ปัญหาแบบนี้เรียกว่า "ปัญหา" ความสับสนในการพึ่งพา.

        ลองมาดูตัวอย่างกัน สมมติว่าในโปรเจ็กต์ NPM ของเรามีการพึ่งพาคอมโพเนนต์ส่วนตัวอยู่:

            • เอ็นพีเอ็ม: package.json

          {
            ชื่อ: "my-project"

           

            ...
            “การพึ่งพา”: {

              ...
              “my-private-dep”: “>=1.0.0”,

              ...

             }

             ...

          }

           

          ผู้โจมตีอาจสร้างเวอร์ชันหลักที่สูงของ my-private-dep (เช่น 99.0.0) และเผยแพร่ในที่เก็บแพ็กเกจ npm สาธารณะ โดยใช้บัญชีปลอมของตนเอง (ผู้โจมตีไม่จำเป็นต้องเกี่ยวข้องกับองค์กรของฉันเลย) ตัวจัดการแพ็กเกจ NPM จะติดตั้งส่วนประกอบที่เป็นอันตราย ซึ่งมักจะส่งผลร้ายแรง

          การแก้ไขปัญหา

          เพื่อหลีกเลี่ยงปัญหาเหล่านี้ในกระบวนการสร้างซอฟต์แวร์ของเรา เราควรปฏิบัติตามหลักเกณฑ์ที่เข้มงวดเกี่ยวกับการประกาศเวอร์ชันของส่วนประกอบ ซึ่งขึ้นอยู่กับเทคโนโลยีที่ใช้ สิ่งสำคัญคือ เวอร์ชันเฉพาะของแพ็กเกจ เมื่อเผยแพร่ในที่เก็บแล้ว จะต้องไม่สามารถเปลี่ยนแปลงได้ (เพื่อหลีกเลี่ยงการทำให้ส่วนประกอบที่เกี่ยวข้องเสียหาย ไม่ใช่แค่เหตุผลด้านความปลอดภัยเท่านั้น)

          แนวคิดหลักคือการตรึง (ต้นสน) เวอร์ชันต่างๆ โดยตรวจสอบเสมอว่าเวอร์ชันที่แก้ไขแล้วของส่วนประกอบ (รวมถึงการพึ่งพาแบบส่งต่อทั้งหมด) ปราศจากมัลแวร์ และสิ่งนี้เป็นไปได้ด้วย ล็อคไฟล์ ซึ่งโปรแกรมจัดการแพ็กเกจหลายตัวมีให้ใช้งาน มาดูกันว่าการกำหนดเวอร์ชันทำงานอย่างไรในโปรแกรมจัดการแพ็กเกจต่างๆ มีความสมดุลที่ละเอียดอ่อนระหว่าง การอัปเดตเวอร์ชันบ่อยครั้ง เพื่อแก้ไขช่องโหว่ที่ทราบแล้วและ การตรึงเวอร์ชัน เพื่อหลีกเลี่ยงการสร้างที่ไม่แน่นอนและการโจมตีห่วงโซ่อุปทานที่อาจเกิดขึ้น

              • NPM:
                ตัวจัดการแพ็กเกจ npm หรือ yarn ใช้ไฟล์ lockfile ที่แตกต่างกัน (npm-shrinkwrap.json / package-lock.json หรือ yarn.lock ตามลำดับ) ซึ่งระบุเวอร์ชันคงที่สำหรับ dependency ทั้งหมด ทั้งทางตรงและทางอ้อม ไฟล์ lockfile ควรอยู่ภายใต้การควบคุมเวอร์ชัน มิฉะนั้นนักพัฒนาคนอื่นๆ หรือ build node อาจได้เวอร์ชันที่แตกต่างกัน หลีกเลี่ยงการใช้ npm install เว้นแต่ว่าในระหว่างการพัฒนาคุณจำเป็นต้องอัปเดต dependency (เช่น เพื่อติดตั้งการแก้ไขด้านความปลอดภัย) โดยทั่วไปแล้ว ให้ใช้ npm ci (Clean Install) ที่มีความแน่นอนมากกว่า เพื่อให้ตัวจัดการแพ็กเกจใช้ไฟล์ lockfile หรือจะหยุดทำงานพร้อมข้อผิดพลาดหากไม่มีไฟล์ lockfile หรือไฟล์นั้นไม่ตรงกับ package.json หากมีการตรวจสอบเวอร์ชันที่ระบุไว้เพื่อหามัลแวร์ ไฟล์ lockfile จะช่วยให้มั่นใจได้ว่าจะไม่มีสิ่งผิดปกติเกิดขึ้นในระหว่างการสร้าง

                สำหรับส่วนประกอบภายใน แนะนำให้สร้าง ขอบเขต NPM จัดการโดยองค์กร (เช่น @myorg) และใช้ขอบเขตนั้นใน dependency (เช่น @myorg/my-private-dep) ซึ่งอาจมีเพียงการมองเห็นแบบส่วนตัวเท่านั้น ซึ่งทำให้เกิดปัญหาดังกล่าว ความสับสนในการพึ่งพา การโจมตีดังกล่าวเกิดขึ้นได้ เนื่องจากมีเพียงสมาชิกขององค์กรที่มีสิทธิ์เขียนเท่านั้นที่สามารถเผยแพร่แพ็กเกจภายใต้ขอบเขตดังกล่าวได้

              • Maven:
                Maven / Gradle ไม่มีไฟล์ล็อก (แต่ดูเพิ่มเติมได้ที่...) บทความ StackOverflow นี้).

                Maven/Gradle ไม่ค่อยใช้ช่วงเวอร์ชันเท่ากับระบบนิเวศอื่นๆ จึงควรหลีกเลี่ยงการใช้งานช่วงเวอร์ชัน ช่วงเวอร์ชัน และเวอร์ชันเมตา LATEST หรือ RELEASE ควรตรวจสอบเวอร์ชันทางอ้อมด้วยเช่นกัน ปลั๊กอิน Maven เวอร์ชัน เป็นเครื่องมือที่ดีสำหรับการควบคุมเวอร์ชัน

                โปรดทราบว่า Maven มีแนวคิดเรื่องขอบเขตขององค์กร (ส่วน groupId ของการพึ่งพา) มาโดยตลอด และดูเหมือนว่าความสับสนในการพึ่งพาจะไม่เป็นปัญหาเลยสำหรับระบบนิเวศนั้น

              • จุดเล็ก ๆ:
                ใน Python มีเครื่องมือต่างๆ สำหรับจัดการกับไฟล์ล็อก:

                - ท่อซึ่งจะสร้างไฟล์ล็อก Pipfile.lock ขึ้นมา
                - บทกวีซึ่งสร้างไฟล์ poetry.lock ขึ้นมา
                - การแช่แข็งเมล็ดพืชคำสั่งนี้จะสร้างไฟล์ requirements.txt ซึ่งทำหน้าที่เป็นไฟล์ล็อก ตรวจสอบว่าการพึ่งพา (dependencies) ทั้งหมดใช้เวอร์ชันคงที่หรือไม่โดยใช้ตัวดำเนินการ == จากนั้นใช้คำสั่ง pip install -r requirements.txt เพื่อใช้การพึ่งพาเวอร์ชันคงที่เหล่านั้น

            โปรดจำไว้ว่าไฟล์ล็อกที่กล่าวถึงข้างต้นควรอยู่ภายใต้การควบคุมเวอร์ชัน และคำสั่งสร้างที่เลือกใช้ควรใช้ไฟล์ล็อกนั้นด้วย

            แหล่งเก็บแพ็กเกจทั่วไปที่ใช้ร่วมกับ pip (PyPI) ไม่มีขอบเขตการตั้งชื่อ และมีความเสี่ยงต่อการโจมตีที่ทำให้เกิดความสับสนในการพึ่งพาแพ็กเกจ หลีกเลี่ยงความสับสนเรื่องการพึ่งพาในระบบนิเวศของ Python ไม่ใช่เรื่องง่าย และผู้เขียนบางคนแนะนำให้ใช้ที่เก็บภายในเพื่อทำหน้าที่เป็นตัวกลางสำหรับไลบรารีสาธารณะที่ดึงมาจาก PyPI แต่ให้ดึงไลบรารีส่วนตัวจากที่เก็บภายในก่อน (-index-url ควรชี้ไปยังที่เก็บภายใน ไม่ใช่ PyPI และควรลบ –extra-index-url ออก)

            การโจมตีที่แท้จริงบางอย่าง

            การโจมตี Getcookies: ผู้ใช้ชื่อ dustin87 ได้เพิ่มการพึ่งพาทางอ้อมเข้าไปในแพ็กเกจ mailparser ยอดนิยมของ npm โดยเพิ่มแพ็กเกจที่เป็นอันตรายที่มีช่องโหว่ RCE (gCOMMANDhDATAi) เข้าไปด้วย

            JSON.stringify(req.headers).replace(/g([a-f0-9]{4})h((?:[a-f0-9]{2})+)i/gi, (o, p, v) => {})

            ถึงแม้จะล้าสมัยไปแล้ว (ไม่มีผู้ตรวจสอบ!) แต่ mailparser ก็ยังคงมียอดดาวน์โหลดประมาณ 64,000 ครั้งต่อสัปดาห์ นี่เป็นกรณีของการโจมตีที่เกือบจะสำเร็จ เพราะการโจมตีแบบ RCE นั้นไม่ได้เกิดขึ้นจริงcisเอ็ด

            NPM เผยแพร่แล้ว โพสต์นี้ พร้อมรายละเอียดเกี่ยวกับการโจมตี getcookies

            ความสับสนในการพึ่งพา:

            ในปี 2021 อเล็กซ์ บีร์ซาน ค้นพบปัญหาความสับสนเรื่องความสัมพันธ์ทางสายเลือด และได้เผยแพร่บทความชื่อ “วิธีที่ผมแฮ็กเข้าไปในระบบของ Apple, Microsoft และบริษัทอื่นๆ อีกหลายสิบแห่ง"

            โปรดจำไว้ว่าสำหรับ npm นั้น ขอบเขตขององค์กร เช่น @myorg ควรสงวนไว้ และแพ็กเกจภายในควรได้รับการแก้ไขให้ใช้ขอบเขตดังกล่าว

            เมื่อใช้ pip ซึ่งเป็นแหล่งรวมแพ็กเกจสาธารณะทั่วไปอย่าง PyPI นั้น ไม่มีขอบเขต/เนมสเปซ แต่ละแพ็กเกจส่วนตัวอาจมีชื่อแพ็กเกจสาธารณะที่เหมือนกับชื่อแพ็กเกจภายใน แต่เป็นแพ็กเกจว่างเปล่า และอาจสร้างข้อผิดพลาดเมื่อใช้งาน เพื่อให้สามารถระบุได้หากมีการดึงข้อมูลโดยไม่ได้ตั้งใจ

            โหนด-ไอพีซี:

            เมื่อสงครามรัสเซีย-ยูเครนเริ่มต้นขึ้น เจ้าของแพ็กเกจได้แทรกโค้ดที่เป็นอันตรายเพื่อลบไฟล์แบบสุ่ม เมื่อติดตั้งบนโฮสต์ในรัสเซียและเบลารุส ไฟล์ ssl-geospec.js ทำหน้าที่แยกแยะตามภูมิศาสตร์ดังนี้:

            ที่น่าสนใจคือ แพ็กเกจอื่นๆ ก็ใช้เวอร์ชันแบบเปิดสำหรับ dependency node-ipc เช่น เฟรมเวิร์ก Vue.js ที่ได้รับความนิยม และผู้ดูแลเฟรมเวิร์กนั้นก็ได้รับ... อุทธรณ์ด่วน เพื่อกำหนดเวอร์ชันที่ปลอดภัยสำหรับการพึ่งพา node-ipc

            แจกันดอกไม้โรแมนติกนี้ โพสต์นี้มีรายละเอียดเพิ่มเติม เกี่ยวกับการก่อวินาศกรรมครั้งนี้ ซึ่งก้าวไปอีกขั้นจากเหตุการณ์อื่นๆ โปรเทสต์แวร์ ปัญหา

             

            สรุปข้อสังเกต

            เวอร์ชันแบบเปิดควร ไม่เคย มีการใช้ในโครงการซอฟต์แวร์แบบรวมศูนย์ ซึ่งทำให้การสร้างซอฟต์แวร์ไม่สามารถทำซ้ำได้ และผู้โจมตีอาจใช้ช่องโหว่นี้เพื่อแทรกมัลแวร์ผ่านการโจมตีโครงสร้างการพึ่งพา เช่น ความสับสนในการพึ่งพาที่กล่าวมาข้างต้น

            การตั้งค่าที่ไม่ถูกต้อง เช่น เวอร์ชันแบบเปิด, การขาดการกำหนดเวอร์ชันที่แน่นอน หรือส่วนประกอบภายในที่ไม่มีขอบเขต ควรหลีกเลี่ยงปัญหาเหล่านี้ สิ่งแรกที่ต้องทำคือตรวจจับปัญหาดังกล่าว อาจถึงขั้นระงับการสร้างเมื่อพบปัญหา และกำหนดมาตรฐานขั้นตอนการดำเนินการ

            ตรวจจับข้อบกพร่องและการตั้งค่าที่ไม่ถูกต้องในส่วนประกอบต่างๆ โดยอัตโนมัติ และรายงานส่วนประกอบที่น่าสงสัยซึ่งอาจเสี่ยงต่อการโจมตีห่วงโซ่อุปทานบางประเภท เช่น ความสับสนในการพึ่งพาการนำเสนอโซลูชันที่มาพร้อมเครื่องมือแก้ไขปัญหาที่ใช้งานได้จริง เป็นหนึ่งในเป้าหมายหลักของโครงการนี้ แพลตฟอร์ม Xygeni.

            อ่านต่อ
            Ohm M., Plate H., Sykosch A., Meier M.: “Backstabber's Knife Collection: A Review of Open Source Software Supply Chain Attacks”. DIMVA 2020. Lecture Notes in Computer Science, vol 12223. Springer – 2020 (แหล่งที่มาของภาพแผนผังการโจมตีแบบพึ่งพา)
            @adam-npm: “ตรวจพบโมดูลที่เป็นอันตราย: getcookies“บล็อก npm (เก็บถาวร) – 2 พฤษภาคม 2018”
            อเล็กซ์ บีร์ซาน: “วิธีที่ผมแฮ็กเข้าไปในระบบของ Apple, Microsoft และบริษัทอื่นๆ อีกหลายสิบแห่ง“Medium – 9 กุมภาพันธ์ 2021”
            แอ็กซ์ ชาร์มา: “การก่อวินาศกรรมครั้งใหญ่: แพ็กเกจ npm ชื่อดังลบไฟล์เพื่อประท้วงสงครามในยูเครน“BleepingComputer – 17 มีนาคม 2022”

            sca-tools-software-composition-analysis-tools
            จัดลำดับความสำคัญ แก้ไข และรักษาความปลอดภัยความเสี่ยงด้านซอฟต์แวร์ของคุณ
            สมัครบัญชีฟรีได้เลย
            ไม่ต้องใช้บัตรเครดิต

            รักษาความปลอดภัยในการพัฒนาและส่งมอบซอฟต์แวร์ของคุณ

            ด้วยชุดผลิตภัณฑ์ Xygeni