Bandit Security Linting: การระบุและการลดช่องโหว่ด้านความปลอดภัยของ Python

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

Bandit คืออะไร

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

Bandit ทำงานโดยการแยกวิเคราะห์โค้ด Python และสร้าง Abstract Syntax Tree (AST) จากนั้นจะใช้ชุดการทดสอบตามรูปแบบช่องโหว่ที่ทราบกับ AST เมื่อพบปัญหาด้านความปลอดภัยที่อาจเกิดขึ้น Bandit จะรายงานด้วยระดับความรุนแรง ระดับความมั่นใจ และคำอธิบายโดยละเอียดของปัญหา

ทำไมต้องใช้ Bandit

การรวม Bandit เข้ากับขั้นตอนการทำงานของการพัฒนาของคุณมีข้อดีที่สำคัญหลายประการ:

• การตรวจจับช่องโหว่ตั้งแต่เนิ่นๆ: Bandit ช่วยให้คุณระบุช่องโหว่ด้านความปลอดภัยได้ตั้งแต่เนิ่นๆ ในกระบวนการพัฒนา ลดต้นทุนและความพยายามที่ต้องใช้ในการแก้ไขในภายหลัง
• ปรับปรุงคุณภาพของโค้ด: โดยการบังคับใช้แนวทางปฏิบัติในการเขียนโค้ดที่ปลอดภัย Bandit มีส่วนช่วยในการปรับปรุงคุณภาพและการบำรุงรักษาโค้ดโดยรวม
• การตรวจสอบความปลอดภัยอัตโนมัติ: Bandit ทำให้กระบวนการตรวจสอบความปลอดภัยเป็นไปโดยอัตโนมัติ ทำให้ง่ายต่อการตรวจสอบให้แน่ใจว่าโค้ดของคุณเป็นไปตามแนวทางปฏิบัติที่ดีที่สุดด้านความปลอดภัย
• ครอบคลุม OWASP Top 10: Bandit มีการทดสอบที่แก้ไขช่องโหว่หลายรายการที่ระบุไว้ใน OWASP Top 10 ซึ่งช่วยให้คุณป้องกันความเสี่ยงด้านความปลอดภัยของเว็บแอปพลิเคชันทั่วไป
• กฎที่ปรับแต่งได้: คุณสามารถปรับแต่งกฎของ Bandit ให้เหมาะกับข้อกำหนดด้านความปลอดภัยและมาตรฐานการเขียนโค้ดเฉพาะของคุณได้
• การรวมเข้ากับ CI/CD Pipelines: Bandit สามารถรวมเข้ากับ Continuous Integration/Continuous Deployment (CI/CD) pipelines ของคุณได้อย่างง่ายดาย ทำให้มั่นใจได้ว่าการตรวจสอบความปลอดภัยจะดำเนินการโดยอัตโนมัติในการเปลี่ยนแปลงโค้ดทุกครั้ง

เริ่มต้นใช้งาน Bandit

ต่อไปนี้คือคำแนะนำทีละขั้นตอนเพื่อเริ่มต้นใช้งาน Bandit:

1. การติดตั้ง

คุณสามารถติดตั้ง Bandit โดยใช้ pip ซึ่งเป็นตัวติดตั้งแพ็คเกจ Python:

            pip install bandit
            

              
                Copy
              
            
          

2. การรัน Bandit

ในการรัน Bandit บนโค้ด Python ของคุณ ให้ใช้คำสั่งต่อไปนี้:

            bandit -r <directory>
            

              
                Copy
              
            
          

แทนที่ <directory> ด้วยไดเร็กทอรีที่มีโค้ด Python ของคุณ แฟล็ก -r บอก Bandit ให้สแกนไฟล์ Python ทั้งหมดในไดเร็กทอรีที่ระบุแบบเรียกซ้ำ

คุณยังสามารถระบุไฟล์แต่ละไฟล์ได้:

            bandit <file1.py> <file2.py>
            

              
                Copy
              
            
          

3. การตีความผลลัพธ์

Bandit จะส่งออกรายงานที่แสดงรายละเอียดช่องโหว่ด้านความปลอดภัยที่อาจเกิดขึ้นที่พบในโค้ดของคุณ แต่ละช่องโหว่จะถูกกำหนดระดับความรุนแรง (เช่น สูง ปานกลาง ต่ำ) และระดับความมั่นใจ (เช่น สูง ปานกลาง ต่ำ) รายงานยังรวมถึงคำอธิบายโดยละเอียดของช่องโหว่และบรรทัดของโค้ดที่พบ

ตัวอย่างเอาต์พุต Bandit:

            ./example.py:10:0:B603  [blacklist] Use of subprocess.Popen with shell=True is known to be vulnerable to shell injection
	Severity: High   Confidence: High
	Location: ./example.py:10
--------------------------------------------------

            

              
                Copy
              
            
          

เอาต์พุตนี้บ่งชี้ว่า Bandit พบช่องโหว่ที่มีความรุนแรงสูงในไฟล์ example.py ในบรรทัดที่ 10 ช่องโหว่เกี่ยวข้องกับการใช้ subprocess.Popen กับ shell=True ซึ่งทราบกันดีว่ามีความเสี่ยงต่อการโจมตี shell injection

ช่องโหว่ด้านความปลอดภัยทั่วไปที่ตรวจพบโดย Bandit

Bandit สามารถตรวจจับช่องโหว่ด้านความปลอดภัยทั่วไปได้หลากหลายในโค้ด Python นี่คือตัวอย่างบางส่วน:

• Shell Injection (B602, B603): การใช้ subprocess.Popen หรือ os.system กับอินพุตที่ไม่น่าเชื่อถืออาจนำไปสู่การโจมตี shell injection
• SQL Injection (B608): การสร้างคิวรี SQL โดยใช้การต่อสตริงกับข้อมูลที่ผู้ใช้ป้อนอาจทำให้แอปพลิเคชันของคุณเสี่ยงต่อการโจมตี SQL injection
• รหัสผ่านที่ Hardcoded (B105): การจัดเก็บรหัสผ่านโดยตรงในโค้ดของคุณเป็นความเสี่ยงด้านความปลอดภัยที่สำคัญ
• Weak Cryptography (B303, B304, B322): การใช้อัลกอริธึมการเข้ารหัสที่อ่อนแอหรือล้าสมัยอาจกระทบต่อความลับและความสมบูรณ์ของข้อมูลของคุณ
• Insecure Deserialization (B301, B401): การดีซีเรียลไลซ์ข้อมูลจากแหล่งที่ไม่น่าเชื่อถืออาจนำไปสู่การดำเนินการโค้ดโดยพลการ
• XML External Entity (XXE) Injection (B405): การแยกวิเคราะห์เอกสาร XML จากแหล่งที่ไม่น่าเชื่อถือโดยไม่มีการฆ่าเชื้ออย่างเหมาะสมอาจทำให้แอปพลิเคชันของคุณเสี่ยงต่อการโจมตี XXE injection
• Format String Vulnerabilities (B323): การใช้ข้อมูลที่ผู้ใช้ป้อนใน format strings โดยไม่มีการฆ่าเชื้ออย่างเหมาะสมอาจนำไปสู่ format string vulnerabilities
• การใช้ `eval()` หรือ `exec()` (B301): ฟังก์ชันเหล่านี้ดำเนินการโค้ดโดยพลการ และการใช้ฟังก์ชันเหล่านี้กับอินพุตที่ไม่น่าเชื่อถือเป็นอันตรายอย่างยิ่ง
• Insecure Temporary File Usage (B308): การสร้างไฟล์ชั่วคราวในตำแหน่งที่คาดเดาได้อาจทำให้ผู้โจมตีเขียนทับหรืออ่านข้อมูลที่ละเอียดอ่อนได้
• Missing or Incorrect Error Handling (B110): การไม่จัดการกับข้อยกเว้นอย่างเหมาะสมอาจเปิดเผยข้อมูลที่ละเอียดอ่อนหรือนำไปสู่การโจมตี denial-of-service

ตัวอย่าง: การระบุและการแก้ไขช่องโหว่ Shell Injection

มาดูตัวอย่างง่ายๆ ว่า Bandit สามารถช่วยคุณระบุและแก้ไขช่องโหว่ shell injection ได้อย่างไร

พิจารณาโค้ด Python ต่อไปนี้:

            import subprocess
import os

def execute_command(command):
    subprocess.Popen(command, shell=True)

if __name__ == "__main__":
    user_input = input("Enter a command to execute: ")
    execute_command(user_input)

            

              
                Copy
              
            
          

โค้ดนี้รับอินพุตของผู้ใช้และดำเนินการเป็นคำสั่ง shell โดยใช้ subprocess.Popen กับ shell=True นี่คือตัวอย่างคลาสสิกของช่องโหว่ shell injection

การรัน Bandit บนโค้ดนี้จะสร้างเอาต์พุตต่อไปนี้:

            ./example.py:4:0:B603  [blacklist] Use of subprocess.Popen with shell=True is known to be vulnerable to shell injection
	Severity: High   Confidence: High
	Location: ./example.py:4
--------------------------------------------------

            

              
                Copy
              
            
          

Bandit ระบุอย่างถูกต้องว่าการใช้ subprocess.Popen กับ shell=True เป็นช่องโหว่ที่มีความรุนแรงสูง

ในการแก้ไขช่องโหว่นี้ คุณควรหลีกเลี่ยงการใช้ shell=True และส่งคำสั่งและอาร์กิวเมนต์เป็นรายการไปยัง subprocess.Popen แทน คุณควรฆ่าเชื้ออินพุตของผู้ใช้เพื่อป้องกันไม่ให้มีการฉีดคำสั่งที่เป็นอันตราย

นี่คือโค้ดเวอร์ชันที่แก้ไขแล้ว:

            import subprocess
import shlex

def execute_command(command):
    # Sanitize the input using shlex.split to prevent shell injection
    command_list = shlex.split(command)
    subprocess.Popen(command_list)

if __name__ == "__main__":
    user_input = input("Enter a command to execute: ")
    execute_command(user_input)

            

              
                Copy
              
            
          

โดยการใช้ shlex.split เพื่อฆ่าเชื้ออินพุตของผู้ใช้และส่งคำสั่งเป็นรายการไปยัง subprocess.Popen คุณสามารถลดความเสี่ยงของการโจมตี shell injection ได้

การรัน Bandit บนโค้ดที่แก้ไขแล้วจะไม่รายงานช่องโหว่ shell injection อีกต่อไป

การกำหนดค่า Bandit

Bandit สามารถกำหนดค่าได้โดยใช้ไฟล์กำหนดค่า (bandit.yaml หรือ .bandit) เพื่อปรับแต่งลักษณะการทำงาน คุณสามารถใช้ไฟล์กำหนดค่าเพื่อ:

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

นี่คือตัวอย่างไฟล์กำหนดค่า bandit.yaml:

            exclude:
  - 'tests/'
  - 'docs/'

skips:
  - 'B101'

confidence_level:
  MEDIUM:
    - 'B603'

severity_level:
  LOW:
    - 'B105'

            

              
                Copy
              
            
          

ไฟล์กำหนดค่านี้ยกเว้นไดเร็กทอรี tests/ และ docs/ จากการสแกน ข้ามการทดสอบ B101 (ซึ่งตรวจสอบการใช้คำสั่ง assert) ปรับระดับความมั่นใจของการทดสอบ B603 เป็น MEDIUM และปรับระดับความรุนแรงของการทดสอบ B105 เป็น LOW

การรวม Bandit เข้ากับ CI/CD Pipeline ของคุณ

การรวม Bandit เข้ากับ CI/CD pipeline ของคุณเป็นขั้นตอนสำคัญในการรับรองความปลอดภัยของโค้ด Python ของคุณ โดยการรัน Bandit โดยอัตโนมัติในการเปลี่ยนแปลงโค้ดทุกครั้ง คุณสามารถตรวจจับช่องโหว่ด้านความปลอดภัยได้ตั้งแต่เนิ่นๆ และป้องกันไม่ให้ช่องโหว่เหล่านั้นเข้าถึงการผลิต

นี่คือตัวอย่างวิธีการรวม Bandit เข้ากับ GitLab CI/CD pipeline:

            stages:
  - test

bandit:
  image: python:3.9
  stage: test
  before_script:
    - pip install bandit
  script:
    - bandit -r .
  artifacts:
    reports:
      bandit: bandit.report

            

              
                Copy
              
            
          

การกำหนดค่านี้กำหนดงาน bandit ที่รัน Bandit บนไดเร็กทอรีปัจจุบัน งานนี้ใช้ Python 3.9 Docker image และติดตั้ง Bandit โดยใช้ pip คำสั่ง bandit -r . รัน Bandit แบบเรียกซ้ำบนไฟล์ Python ทั้งหมดในไดเร็กทอรีปัจจุบัน ส่วน artifacts ระบุว่ารายงาน Bandit ควรบันทึกเป็น artifact ซึ่งสามารถดาวน์โหลดและตรวจสอบได้

สามารถสร้างการกำหนดค่าที่คล้ายกันสำหรับแพลตฟอร์ม CI/CD อื่นๆ เช่น Jenkins, CircleCI และ GitHub Actions

เหนือกว่า Bandit: กลยุทธ์ด้านความปลอดภัยที่ครอบคลุม

แม้ว่า Bandit จะเป็นเครื่องมือที่มีค่าสำหรับการระบุช่องโหว่ด้านความปลอดภัยที่อาจเกิดขึ้น แต่สิ่งสำคัญคือต้องจำไว้ว่า Bandit เป็นเพียงส่วนหนึ่งของกลยุทธ์ด้านความปลอดภัยที่ครอบคลุม แนวทางปฏิบัติที่สำคัญอื่นๆ ด้านความปลอดภัย ได้แก่:

• แนวทางปฏิบัติในการเขียนโค้ดที่ปลอดภัย: ปฏิบัติตามหลักเกณฑ์และแนวทางปฏิบัติที่ดีที่สุดในการเขียนโค้ดที่ปลอดภัยเพื่อลดความเสี่ยงในการนำช่องโหว่มาใช้ในโค้ดของคุณ
• การตรวจสอบความปลอดภัยเป็นประจำ: ดำเนินการตรวจสอบความปลอดภัยเป็นประจำเพื่อระบุและแก้ไขจุดอ่อนด้านความปลอดภัยที่อาจเกิดขึ้นในแอปพลิเคชันของคุณ
• การทดสอบการเจาะระบบ: ดำเนินการทดสอบการเจาะระบบเพื่อจำลองการโจมตีในโลกแห่งความเป็นจริงและระบุช่องโหว่ที่อาจตรวจไม่พบโดยเครื่องมือ static analysis เช่น Bandit
• การจัดการช่องโหว่: ดำเนินการโปรแกรมการจัดการช่องโหว่เพื่อติดตามและแก้ไขช่องโหว่ในซอฟต์แวร์และโครงสร้างพื้นฐานของคุณ
• การจัดการ Dependency: อัปเดต dependencies ของคุณให้ทันสมัยอยู่เสมอเพื่อแพตช์ช่องโหว่ที่ทราบในไลบรารีของบุคคลที่สาม เครื่องมือเช่น `pip-audit` และ `safety` สามารถช่วยในเรื่องนี้ได้
• การตรวจสอบความถูกต้องและการฆ่าเชื้ออินพุต: ตรวจสอบความถูกต้องและฆ่าเชื้ออินพุตของผู้ใช้เสมอเพื่อป้องกันการโจมตีแบบ injection และช่องโหว่ที่เกี่ยวข้องกับอินพุตอื่นๆ
• การรับรองความถูกต้องและการให้สิทธิ์: ดำเนินการกลไกการรับรองความถูกต้องและการให้สิทธิ์ที่แข็งแกร่งเพื่อปกป้องข้อมูลและทรัพยากรที่ละเอียดอ่อน
• การฝึกอบรมการรับรู้ด้านความปลอดภัย: จัดให้มีการฝึกอบรมการรับรู้ด้านความปลอดภัยแก่ผู้พัฒนาและพนักงานอื่นๆ เพื่อให้ความรู้เกี่ยวกับภัยคุกคามด้านความปลอดภัยทั่วไปและแนวทางปฏิบัติที่ดีที่สุด

สรุป

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

แหล่งข้อมูล

• Bandit Documentation
• OWASP (Open Web Application Security Project)
• Bandit on PyPI