Code Quality & Security with SonarQube

สามารถดู video ของหัวข้อนี้ก่อนได้ ดู video

Code Quality คืออะไร

Code Quality คือการประเมินคุณภาพของ code ของภาษาโปรแกรม computer โดยพิจารณาจากหลายปัจจัยเพื่อให้แน่ใจว่า code นั้นมีคุณภาพดีรหรือไม่ ซึ่งการรักษาคุณภาพ code ที่ดีมีจุดประสงค์ตั้งแต่

1. ความเข้าใจง่าย: code ที่มีคุณภาพดีจะมีความเข้าใจง่าย ทำให้ทีม developer สามารถทำงานร่วมกันได้อย่างมีประสิทธิภาพ สามารถทำความเข้าใจและปรับปรุง code ได้ง่ายในอนาคต
2. การบำรุงรักษาง่าย (Maintainability): code ที่มีโครงสร้างดีและมีการจัดการที่ดีจะช่วยให้การบำรุงรักษาและการแก้ไขบัคต่างๆ เป็นไปได้ง่ายและรวดเร็ว
3. ความถูกต้อง (Correctness): code ต้องทำงานได้ถูกต้องตามที่ออกแบบไว้
4. ประสิทธิภาพ (Efficiency): code ควรจะทำงานได้เร็วและใช้ทรัพยากรของระบบอย่างมีประสิทธิภาพ
5. การทำตามมาตรฐาน (Standards Compliance): code ควรปฏิบัติตามมาตรฐานการเขียน code ที่ยอมรับกันภายใน source code ชุดนั้น

ดังนั้น เพื่อให้ทุก source code มีนิยาม “quality” ที่เหมือนกัน เราจึงต้องมีการกำหนดสิ่งที่เรียกว่า “หลักการของการควบคุมของ code quality ขึ้นมา” โดยปกติก็จะมีหลากหลายไอเดียที่ทำกันตั้งแต่

• Documentation: เขียนเอกสารประกอบ code เช่น คำอธิบาย function, การใช้งาน, และตัวอย่างการใช้งาน เพื่อให้คนอื่นสามารถเข้าใจและใช้ code ได้ง่าย
• Coding Standards and Guidelines: กำหนดมาตรฐานการเขียน code ให้ทุกคนมีลายมือและวิธีเขียนที่เหมือนๆกัน เช่น การตั้งชื่อตัวแปร, การจัดรูปแบบ code และการใช้งาน function เพื่อให้ code นั้นสอดคล้องกันและมีความเข้าใจที่เหมือนๆกัน (ปกติ ก็จะใช้ตัวช่วยเพิ่มเติมเช่น ESLint หรือ Prettier เพื่อให้การกำกับเกิดขึ้นบน Editor ของ developer ขณะทำงาน)
• เพิ่ม Automated Testing: ตั้งแต่
  • Unit Tests: ทดสอบ function หรือ module แต่ละส่วนเพื่อให้แน่ใจว่าทำงานถูกต้อง
  • Integration Tests: ทดสอบการทำงานร่วมกันของหลายๆ ส่วน
  • End-to-End Tests: ทดสอบระบบทั้งหมดเพื่อให้แน่ใจว่าทำงานตามที่คาดหวัง

รวมถึง วิธีการอีกวิธีที่เป็นที่นิยม นั่นคือการทำ “Code Review” ที่ให้ให้เพื่อนร่วมทีม (หรือ เราจะเรียกว่า ผู้ที่รู้ว่า code นี้มันควรจะเป็นยังไง) ตรวจสอบ code เพื่อหาข้อผิดพลาดและแนะนำวิธีการปรับปรุง ทีนี้เราจะลองมาเจาะลึกวิธีนี้กัน

Code Review

https://www.sonarsource.com/solutions/code-review/

Code Review คือกระบวนการตรวจสอบ code โดยเพื่อนร่วมทีม หรือผู้ที่มีความรู้ในด้านการพัฒนาโปรแกรม เพื่อหาข้อผิดพลาด ปรับปรุงคุณภาพ และเพิ่มความปลอดภัยให้กับ code ก่อนที่จะนำไปใช้งานจริง

โดยปกติ concept ของการทำ code review ก็จะมี process กันประมาณนี้

1. Pull Request: developer ส่งคำขอให้เพื่อนร่วมทีมตรวจสอบ code ที่พัฒนาเสร็จแล้ว ก่อนที่จะนำ code นั้นเข้ามารวมกับ code หลัก
2. Peer Review: ให้เพื่อนร่วมทีมอ่านและตรวจสอบ code โดยอาจทำในลักษณะคู่ (Pair Programming) หรือ meeting และ รีวิวกับทีมไปพร้อมๆกกัน
3. Checklist: ใช้รายการตรวจสอบ (Checklist) เพื่อให้แน่ใจว่าการตรวจสอบครอบคลุมทุกประเด็นสำคัญ เช่น ความถูกต้อง, ความปลอดภัย, ประสิทธิภาพ, การทำตามมาตรฐาน
4. Commenting: ผู้ตรวจสอบแสดงความคิดเห็นเกี่ยวกับ code ในจุดที่ต้องการการปรับปรุงหรือชี้แนะวิธีการแก้ไข
5. Feedback Loop: developer ตอบกลับความคิดเห็นและแก้ไข code ตามคำแนะนำจากผู้ตรวจสอบ

ซึ่งเป้าหมาย ก็เพื่อทำให้ code นั้นยังคงเป็นไปตาม standard ของ code quality ตามที่ทีมกำหนดกันมา เพื่อให้ทีมสามารถทำงานกันต่อได้อย่างราบรื่นยิ่งขึ้น

ทีนี้ ในหลายๆที่ เชื่อว่ายังคงใช้วิธีการ review code ด้วยวิธีแบบ manual นั่นคือกระบวนการตรวจสอบและประเมิน code โดยใช้การตรวจสอบของ “มนุษย์” เป็นหลัก มันเลยมักจะตามมากับปัญหาจุกจิกหลายอย่างตั้งแต่

• ใช้เวลาและทรัพยากรมากเกิน: ซึ่งอาจทำให้เกิดการเบียดเบียนเวลาที่ควรใช้ในการพัฒนา code (ดังมุกที่เราชอบเล่นกันเวลา review code ว่า “LGTM” แล้วก็ผ่านไป)
• ความลำเอียงและข้อผิดพลาดของมนุษย์ (Human Error): ผู้ตรวจสอบอาจมีความลำเอียงหรือพลาดข้อผิดพลาดบางประการ เนื่องจากข้อจำกัดในการมองเห็นและความเข้าใจใน code (เช่น developer คนนี้อาจจะเป็น Senior ก็จริงแต่พอพึ่งเข้ามาดู source code อาจจะตัดสินใจใช้ idea ของตัวเอง แทนที่จะ follow ตาม guideline ก่อนหน้า) รวมถึง ความสม่ำเสมอในการตรวจสอบอาจแตกต่างกันไปขึ้นอยู่กับผู้ตรวจสอบแต่ละคน (developer บางคน อาจจะไม่ได้ตาม guideline เป๊ะๆ)
• การตรวจสอบที่ไม่ครอบคลุม: การตรวจสอบด้วยมนุษย์อาจไม่ครอบคลุมทุกกรณีหรือส่วนของ code ทำให้มีโอกาสที่ข้อผิดพลาดบางประการจะหลุดรอดไปได้
• แรงกดดันในการตรวจสอบ (Review Pressure): ผู้ตรวจสอบอาจรู้สึกกดดันในการต้องตรวจสอบ code ภายในเวลาที่กำหนด ซึ่งอาจทำให้การตรวจสอบขาดความละเอียด (ความเหนื่อยล้าของผู้ตรวจสอบก็มีผลนะ)
• รวมถึง การทำงานซ้ำซ้อน ที่บางครั้งการตรวจสอบด้วยมนุษย์อาจเกิดการทำงานซ้ำซ้อนกับการตรวจสอบโดยเครื่องมืออัตโนมัติ ซึ่งอาจทำให้เสียเวลาโดยไม่จำเป็น (เช่น ไปตรวจสอบ code จุดที่ ESLint มันตรวจสอบไปแล้ว)

การแก้ปัญหามันก็มีหลายหลาย Idea ตั้งแต่มีการ Training ให้รู้จัก Source code มากขึ้น, สร้าง Guidelines and Checklists เพื่อให้ปฏิบัติตามกันอย่างถูกต้อง, กระจายการ Review code ให้ทุกคนได้รับเท่าๆกัน

แต่วิธีแก้ปัญหาที่ dev team มักนิยมทำกันก็คือ ถ้าอย่างนั้นเราก็หาสักเครื่องมือหนึ่ง ที่เป็น Automation tools มาช่วย Review code ก่อน

SonarQube

SonarQube เป็นเครื่องมือสำหรับการวิเคราะห์ code ที่ช่วยในการตรวจสอบคุณภาพของ code โปรแกรม โดยสามารถตรวจสอบและประเมินคุณภาพ code ได้หลายด้าน เช่น ความถูกต้อง (Correctness), ความปลอดภัย (Security), ประสิทธิภาพ (Performance), ความสามารถในการบำรุงรักษา (Maintainability), และการปฏิบัติตามมาตรฐาน (Compliance) เป็นต้น

คุณสมบัติหลักของ SonarQube

1. การวิเคราะห์ code แบบ Static Analysis (SAST): SonarQube จะตรวจสอบ code โดยไม่ต้องรันโปรแกรม ทำให้สามารถตรวจสอบ code ได้ทันทีที่มีการเขียนหรือเปลี่ยนแปลง
2. การตรวจจับ Bugs และ Vulnerabilities: สามารถตรวจสอบและรายงานข้อผิดพลาดและช่องโหว่ต่างๆ ใน code
3. การวัดค่า Technical Debt: ประเมินปริมาณงานที่จำเป็นต้องทำเพื่อปรับปรุง code ให้มีคุณภาพดีขึ้น
4. การสนับสนุนหลายภาษาโปรแกรม: รองรับการตรวจสอบ code ในหลายภาษาโปรแกรม เช่น Java, C#, JavaScript, Python, PHP, และอื่นๆ
5. การรวมเข้ากับเครื่องมือ CI/CD: สามารถรวมเข้ากับเครื่องมือ Continuous Integration และ Continuous Deployment เช่น Jenkins, GitLab CI, Azure DevOps เป็นต้น

Step การลง SonarQube

เราต้องลง Software SonarQube ซึ่งปกติจะมี 2 วิธีคือ ลงที่เครื่องๆนั้นเลย (เช่น Windows, Linux) กับ ลงด้วยวิธีการ Docker

ซึ่งในหัวข้อนี้เราจะลงผ่าน Docker เพื่อให้สามารถนำไปประยุกต์ใช้ได้

https://docs.sonarsource.com/sonarqube/latest/setup-and-upgrade/install-the-server/installing-sonarqube-from-docker/

หรือสามารถใช้ docker-compose ตามด้านล่างนี้ได้

version: '3.7'
services:
  sonarqube:
    image: sonarqube:community  # Use the Community Edition image
    ports:
      - 9000:9000
    volumes:
      - sonarqube_data:/opt/sonarqube/data
    environment:
      - SONAR_JDBC_URL=jdbc:postgresql://postgresql:5432/sonarqube  # Connect to PostgreSQL container
      - SONAR_JDBC_USERNAME=sonarqube
      - SONAR_JDBC_PASSWORD=sonarqube
    networks:
      - sonarqube-network

  postgresql:  # PostgreSQL database service
    image: postgres
    environment:
      - POSTGRES_USER=sonarqube
      - POSTGRES_PASSWORD=sonarqube
    volumes:
      - postgresql_data:/var/lib/postgresql/data
    networks:
      - sonarqube-network

volumes:
  sonarqube_data:
  postgresql_data:

# add network name sonarqube-network
networks:
  sonarqube-network:
    external: true

โดยที่ SonarQube ใช้ PostgreSQL เป็นฐานข้อมูลหลักในการจัดเก็บข้อมูล แต่ยังสามารถใช้ฐานข้อมูลอื่นได้ตามความต้องการและการตั้งค่าของผู้ใช้ ซึ่งฐานข้อมูลที่ SonarQube รองรับมีดังนี้

1. PostgreSQL (แนะนำให้ใช้)
2. MySQL
3. Oracle
4. Microsoft SQL Server

สำหรับการใช้งานจริง PostgreSQL เป็นตัวเลือกที่แนะนำมากที่สุดเนื่องจากประสิทธิภาพและการสนับสนุนที่ดีจาก community ของ SonarQube เองด้วย

รู้จักกับ SonarQube Scanner

ทีนี้ ตอนนี้เรามี SonarQube และ แล้ว “เราจะส่ง code เข้า SonarQube ได้อย่างไร ?”

การส่ง code เข้าไปวิเคราะห์ใน SonarQube สามารถทำได้หลายวิธี ขึ้นอยู่กับการตั้งค่าและ framework / tools ที่เราใช้ แต่วิธีการที่สามารถใช้ร่วมกันได้ทั้งหมด (ไม่ว่า project เราจะเป็นภาษาอะไรก็ตาม) นั่นคือ SonarQube Scanner

https://docs.sonarsource.com/sonarqube/latest/analyzing-source-code/scanners/sonarscanner/

SonarQube Scanner เป็นเครื่องมือที่ใช้ในการวิเคราะห์ code โปรแกรมของคุณและส่งผลการวิเคราะห์ไปยัง SonarQube Server โดย SonarQube Scanner จะทำงานผ่านการเรียกใช้คำสั่งจากบรรทัดคำสั่ง (Command Line Interface) และสามารถใช้งานได้กับหลายภาษาโปรแกรม เช่น Java, JavaScript, Python, C#, PHP, และอื่นๆ

Ref: https://www.researchgate.net/figure/is-a-representation-of-the-different-components-of-SQ-and-how-they-interact-one-with-the_fig1_326655148

คุณสมบัติหลักของ SonarQube Scanner

1. การวิเคราะห์ code แบบ Static Analysis: ตรวจสอบและวิเคราะห์ code โดยไม่ต้องรันโปรแกรม
2. ความสามารถในการรวมเข้ากับ CI/CD Pipeline: สามารถใช้ร่วมกับเครื่องมือ CI/CD ต่างๆ เช่น Jenkins, GitLab CI, GitHub Actions
3. รองรับหลายแพลตฟอร์ม: สามารถทำงานได้บน Windows, macOS และ Linux
4. การเชื่อมต่อกับ SonarQube Server: ส่งผลการวิเคราะห์ไปยัง SonarQube Server เพื่อเก็บและแสดงผล

Step โดยประมาณของการใช้ Sonar Scanner คือ

1. ติดตั้ง SonarQube Scanner ซึ่งเหมือนกับ SonarQube server เลย สามารถทำได้ทั้ง ลงที่เครื่อง หรือใช้งานผ่าน Docker
2. สร้างไฟล์ sonar-project.properties เพื่อ config Sonar Scanner ในแต่ละ project (เป็นการระบุทั้งตำแหน่งของ SonarQube Server และ credential เพื่อให้ส่งข้อมูลไปถูก project ยิ่งขึ้น)

ตัวอย่าง

sonar.projectKey=my_project_key
sonar.projectName=My Project
sonar.projectVersion=1.0
sonar.sources=src
sonar.host.url=http://localhost:9000
sonar.login=my_sonar_token

3. run คำสั่ง SonarQube Scanner ผ่าน command line sonar-scanner

มาลองเล่น SonarQube ทั้งหมดกัน

ตัวอย่างที่เราหยิบมา เราจะหยิบ project Node.js (Express.js) ที่ทำ service Backend API ขึ้นมา โดยใน Node.js นี้จะมีการต่อเข้าไปยัง MongoDB เพื่อสำหรับการเก็บและดึงข้อมูลมาใช้

สิ่งที่เราได้เพิ่ม เราจะทำตาม step ของ SonarQube Scanner เลยคือ

1. ติดตั้ง SonarQube Scanner = ในทีนี้เราจะใช้ผ่าน Docker เช่นเดียวกัน

https://hub.docker.com/r/sonarsource/sonar-scanner-cli

โดยเราจะทำการเพิ่มผ่าน docker-compose ไว้

version: '3.7'
services:
  sonar-scanner:
    container_name: sonar-scanner
    platform: linux/amd64
    image: sonarsource/sonar-scanner-cli
    volumes:
      - .:/usr/src  # Mount the current directory as the project directory
    working_dir: /usr/src
    command: sonar-scanner
    networks:
      - sonarqube-network

# add network name sonarqube-network
networks:
  sonarqube-network:
    external: true

โดยหลักการของ SonarQube Scanner (สำหรับ Docker) คือ

1. เราจะนำไฟล์ source code map เข้ากับตำแหน่ง เพื่อนำ source code ทั้งหมดเข้า container docker ที่มีการ run ขึ้นมา

   /usr/src

2. ตอน docker run เสร็จ ให้ start ด้วยคำสั่ง sonar-scanner เพื่อทำการ scan

3. หลังจาก scan เสร็จ container ก็จะ kill ตัวเองทิ้ง เนื่องจากไม่มี process อะไร run ค้างไว้

ดังนั้น เพื่อให้ง่ายตอนการใช้งานร่วมกับ project ของ node.js เราจะทำการเพิ่มการ run ลงใน package.json โดยให้ docker-compose ของ SonarQube Scanner อยู่ตำแหน่ง docker-compose-scan.yml

{
  "name": "sonar-test-express-app",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "start": "node app.js",
    "scan": "docker-compose -f docker-compose-scan.yml up -d"
  },
  /* ... */
}

และเราก็จะสามารถ run ได้จากคำสั่งนี้โดยตรง

npm run scan

ok step ที่ 1 เรียบร้อย

2. step ต่อมาเราต้องเพิ่ม config sonar-project.properties สำหรับ ให้ต่อเข้ามายัง SonarQube ได้ โดยต้องเพิ่มค่าเข้าไปดังนี้

sonar.projectKey=test-express
sonar.sources=.
sonar.host.url=http://0.0.0.0:9000

# สำหรับชาว Mac เนื่องจากภายใน network docker ไม่สามารถ map กลับมายัง sonarqube ภายนอกได้ จำเป็นต้องใช้ map host ภายใน docker ตามด้านล่างนี้แทน
# sonar.host.url=http://host.docker.internal:9000

sonar.token=<sonar token>

และขั้นตอนสุดท้าย ดำเนินการ run ด้วย คำสั่ง

npm run scan

และลองดู log จาก docker ดูก็จะเจอว่า มันพยายาม run scan เพื่อส่งเข้าไปไปใน SonarQube Server

เมื่อเรากลับมาดูที่หน้า SonarQube Server ก็จะเจอผลลัพธ์ออกมาได้

ซึ่งตัว SonarQube ที่เราลองเล่นกันนั้น จะเป็นตัวของ Community Version (version free ที่ทุกคนสามารถใช้งานได้) SonarQube จะทำการ Static Application Security Testing (SAST) Analysis (เป็นการวิเคราะห์ code แบบ Static โดยไม่ต้องรัน code) ซึ่งจะช่วยตรวจจับปัญหาต่าง ๆ ใน code ได้ตั้งแต่

• Code Quality and Code Security: ตรวจจับปัญหาคุณภาพของ code และความปลอดภัยของ code
• Bugs Detection: ตรวจจับและรายงาน Bugใน code
• Code Smells Detection: ตรวจจับและรายงานปัญหาใน code ที่อาจจะไม่ใช่บั๊กแต่ทำให้ code อ่านยากหรือบำรุงรักษายาก
• Security Vulnerabilities: ตรวจจับช่องโหว่ด้านความปลอดภัยใน code
• Security Hotspots: แจ้งเตือน code ที่อาจจะมีความเสี่ยงด้านความปลอดภัย
• Maintainability Issues: วิเคราะห์และรายงานปัญหาด้านการบำรุงรักษาของ code
• Duplicated Code Detection: ตรวจจับ code ที่ซ้ำกันในโปรเจ็กต์
• Code Complexity Metrics: วิเคราะห์และรายงานความซับซ้อนของ code

โดยตัว SonarQube จะทำเป็น Dashboard รายงานออกมา (ตามภาพด้านบน) รวมถึง feature Quality Gates ที่สามารถกำหนดเกณฑ์การผ่านของคุณภาพ code ไว้ได้

รวมถึง SonarQube นั้นได้เตรียม Rule (กฎที่กำหนดขึ้นเพื่อใช้ในการวิเคราะห์ code กฎเหล่านี้จะเป็นการกำหนดเงื่อนไขในการตรวจจับปัญหาต่าง ๆ ใน code โดยแต่ละ rule จะมีการอธิบายว่าตรวจจับปัญหาอะไร ทำไมถึงสำคัญ และวิธีการแก้ไขอย่างไร) ที่สามารถเปิด / ปิด การใช้งานได้ ขึ้นอยู่กับว่าทีม Strict กับกฎแต่ละตัวมากน้อยแค่ไหน

• ซึ่งสิ่งนี้แหละ จะเป็นสิ่งที่ทำให้ developer ทุกคนมีกฎการทำงานที่เหมือนๆกัน การ Review code ก็จะได้ผลลัพธ์ที่ Consistency ออกมาได้

การส่ง Code Coverage

นอกเหนือจากการตรวจจับ issue แล้ว SonarQube ยังได้รวม feature ของการวิเคราะห์ Code Coverage ไว้ในตัวด้วยเช่นกัน

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

โดย SonarQube สามารถทำงานร่วมกับข้อมูล Code Coverage ที่ได้รับจากเครื่องมือทดสอบต่าง ๆ เช่น JaCoCo สำหรับ Java, Istanbul สำหรับ JavaScript (รวมถึง C8 ใน javascript ที่เรากำลังจะใช้ด้วย) และอื่น ๆ เพื่อรวมข้อมูลเหล่านี้เข้าไปในรายงานการวิเคราะห์ code โดยทั้งหมดจะแสดงผลผ่าน dashboard ออกมาได้

สิ่งที่เราต้องเพิ่มมาใน code คือ

1. เราต้องเพิ่ม unit test + coverage test tool เข้ามา โดยสำหรับ เคสในหัวข้อนี้ ที่เราใช้ node.js เราจะใช้ library mocha เป็น unit test และ c8 (ตัวที่พัฒนามาจาก Istanbul ที่รองรับกับ ES6 Module) เป็น coverage test tool

โดยเราทำการเพิ่มคำสั่งมาใน package.json ตามนี้

{
  "name": "sonar-test-express-app",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "start": "node app.js",
    "test": "mocha --exit",
    "coverage": "c8 --reporter=lcov npm run test",
    "scan": "docker-compose -f docker-compose-scan.yml up -d"
  },
  /* ... */
}

โดยผลของ code coverage นั้นจะต้องออกมา ณ ตำแหน่งใดตำแหน่งหนึ่งใน code (ซึ่ง format แนะนำสำหรับ SonarQube คือใช้ lcov)

หลังจากนั้น เพื่อให้ SonarQube รู้จักกับ Code Coverage จะต้องเพิ่ม config เข้าไปใน sonar-project.properties เพื่อให้รู้จักกับ path ของ code coverage

sonar.projectKey=test-express
sonar.sources=.
sonar.host.url=http://0.0.0.0:9000
sonar.token=<sonar token>

# เพิ่มตำแหน่งนี้เข้ามา
sonar.tests=test/
sonar.test.inclusions=**/*.test.js,**/*.spec.js
sonar.javascript.lcov.reportPaths=coverage/lcov.info
sonar.exclusions=coverage/**

แล้วหลังจากนั้นทำการ run npm run scan ซ้ำอีกทีหนึ่ง เราก็จะได้ผลลัพธ์ code coverage โผล่ที่ Dashboard SonarQube ได้

ซึ่งมันก็จะเห็นหมดว่า Code coverage แต่ละ file cover ไปแล้ว กี่ % บ้าง

SonarLint

ทีนี้ หลายคนก็อาจจะสงสัยว่า แล้วถ้าอย่างนี้ หากเราอยากรู้ผลลัพธ์จาก Sonar เราจำเป็นต้องส่งไปยัง SonarQube Server ทุกครั้งไหม ? = คำตอบคือ “ไม่จำเป็น” เราสามารถทราบผลลัพธ์บางส่วนของ SAST ได้ก่อนผ่าน SonarLint

https://marketplace.visualstudio.com/items?itemName=SonarSource.sonarlint-vscode

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

• ตรวจสอบ code ขณะพัฒนา: SonarLint สามารถติดตั้งเป็น plugin ใน IDE ต่าง ๆ เช่น IntelliJ IDEA, Visual Studio, Eclipse และ VS Code เมื่อใช้งาน SonarLint มันจะทำการตรวจสอบ code ทันทีที่คุณเขียน และจะแสดงผลลัพธ์การตรวจสอบภายใน IDE ที่คุณใช้อยู่
• แนะนำการแก้ไข: เมื่อ SonarLint ตรวจพบปัญหาหรือข้อผิดพลาด มันจะแสดงรายละเอียดและแนะนำวิธีการแก้ไข ซึ่งจะช่วยลดเวลาในการตรวจสอบและปรับปรุงคุณภาพ code ได้
• ทำงานร่วมกับ SonarQube/SonarCloud: หากเราใช้ SonarQube หรือ SonarCloud ในการตรวจสอบ code ใน project เราสามารถเชื่อมต่อ SonarLint กับเซิร์ฟเวอร์ SonarQube หรือ SonarCloud เพื่อให้การตรวจสอบ code ใน local สอดคล้องกับกฎการตรวจสอบของ project ที่ setup ใน SonarQube Server ได้

วิธีการติดตั้งคือ

1. ลง Plugin SonarLint ตาม Editor ที่ใช้งานอยู่ (โดยปกติ ลง Plugin แค่นี้ก็สามารถใช้งานได้แล้ว แต่ SonarLint นั้นสามารถเชื่อมเข้ากับ SonarQube Server เพื่อนำข้อมูลอื่นๆบน SonarQube Server มาใช้ได้)
2. ทำการ setup SonarLint เข้ากับ server ที่ทำการ run SonarQube อยู่
3. เมื่อ connect เรียบร้อย ให้เราลองกลับมาที่ Source code อีกที จะเจอว่ามีคำแนะนำจาก SonarLint เพิ่มมาได้

เมื่อลงทุกอย่าง ถูกต้อง เราก็จะเจอ SonarLint แสดงผลลัพธ์ออกมา

เพิ่มเติม Developer และ Enterprise version

Developer Version

• สามารถทำ Branch Analysis จาก Branch อื่นได้ (สามารถทำขณะ Pull Request ได้ จากแต่เดิมที่ทำได้แค่ main branch ใน community version)
• เพิ่มเติมเรื่อง Trait Analysis และ Deeper SAST

อย่างที่เราทราบกันว่า SonarQube ได้ทำ SAST กับ source code ไว้ แต่จุดที่แข็งแกร่งอีกอย่างของ SonarQube คือ SonarQube มี “Deeper SAST” เพิ่มเติมเข้ามา

Deeper SAST เป็น feature ใหม่ใน SonarQube ที่ช่วยเพิ่มประสิทธิภาพในการวิเคราะห์ความปลอดภัยของ code โดยเฉพาะในการค้นหาช่องโหว่ที่ซ่อนอยู่ใน code ซึ่งฟีเจอร์นี้จะทำการวิเคราะห์อย่างลึกซึ้งมากขึ้น โดยใช้เทคนิคการวิเคราะห์ที่เรียกว่า taint analysis ซึ่งช่วยให้สามารถตรวจจับช่องโหว่ที่อาจเกิดจากการจัดการข้อมูลที่ไม่ปลอดภัยได้อย่างมีประสิทธิภาพมากขึ้น

ความแตกต่างระหว่าง Deeper SAST และ SAST

• SAST (Static Application Security Testing): เป็นการวิเคราะห์ code ในระดับพื้นฐาน โดยมุ่งเน้นการค้นหาช่องโหว่ที่ชัดเจน เช่น การใช้ function ที่ไม่ปลอดภัย หรือการจัดการข้อมูลที่ไม่ถูกต้อง
• Deeper SAST: มุ่งเน้นการวิเคราะห์ที่ลึกซึ้งมากขึ้น โดยสามารถตรวจจับช่องโหว่ที่ซ่อนอยู่ใน code ได้ เช่น การวิเคราะห์การไหลของข้อมูล (data flow) และการตรวจสอบการใช้ library ที่มีช่องโหว่ รวมถึงการตรวจสอบการพึ่งพา (transitive dependencies) ซึ่งช่วยให้การวิเคราะห์มีความครอบคลุมมากขึ้น

ทีนี้ เรามาพูดถึง Taint Analysis กันบ้าง Taint Analysis เป็นเทคนิคที่ใช้ในการวิเคราะห์ความปลอดภัยของ code โดยเฉพาะในการตรวจจับช่องโหว่ที่เกี่ยวข้องกับ “การจัดการข้อมูลที่ไม่ปลอดภัย” เทคนิคนี้มักใช้ในกระบวนการ Static Application Security Testing (SAST) และมีจุดมุ่งหมายเพื่อระบุว่าข้อมูลที่ไม่ปลอดภัย (tainted data) ได้ถูกนำไปใช้ใน code อย่างไร และมีโอกาสที่จะทำให้เกิดช่องโหว่หรือไม่

ซึ่ง Taint Analysis นั้น ไม่สามารถใช้งานได้ใน SonarQube Community Edition ได้ feature นี้เป็นส่วนหนึ่งของ Developer Edition และ version ที่สูงกว่านี้ (เช่น Enterprise และ Data Center Editions)

ยกตัวอย่างเช่น code นี้

router.post('/user/find-name', async (req, res) => {
  try {
    const userInput = req.body.input // Tainted data from user input
    const users = await User.find({ name: userInput }) // Using User Schema to query users by name
    res.send(users)
  } catch (err) {
    res.status(500).json({ message: err.message })
  }
})

หากเป็น community version จะไม่สามารถตรวจเจอได้ แต่หากใช้ Developer version จะสามารถตรวจเจอช่องโหว่นี้จาก feature ของ Trait Analysis ได้

Reference

• Deeper SAST https://www.sonarsource.com/blog/deeper-sast-uncovers-hidden-security-vulnerabilities/
• Taint Analysis https://monsterconnect.co.th/taint-analysis/

Enterprise Version

มี feature ที่ on top developer มา แต่จะมีจุดเด่นเพิ่มเข้ามา 2 feature ใหญ่ๆ

1. Portfolio

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

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

ยกตัวอย่างตาม video นี้

https://www.youtube.com/watch?v=M86f__ZYIKQ

2. Security Report

Security Reports ใน SonarQube Enterprise ถูกออกแบบมาเพื่อให้ข้อมูลเชิงลึกที่ครอบคลุมเกี่ยวกับช่องโหว่ด้านความปลอดภัยและจุดเสี่ยงภายใน codebase ของคุณ ฟีเจอร์นี้ช่วยให้ผู้ใช้สามารถ “สร้างรายงาน” รายละเอียดที่จัดประเภทช่องโหว่ภายใต้หมวดหมู่ต่าง ๆ ช่วยให้ทีมเข้าใจและจัดการกับปัญหาด้านความปลอดภัยได้อย่างมีประสิทธิภาพ รายงานสามารถสร้างได้ทั้งในระดับ project และ portfolio ให้ภาพรวมในระดับสูงและข้อมูลเชิงลึกในโครงการเฉพาะ

โดย feature ใหญ่ๆของ security report นั้นประกอบด้วย

• การจัดประเภทช่องโหว่: รายงานจะแยกประเภทช่องโหว่และจุดเสี่ยงด้านความปลอดภัย ทำให้ง่ายต่อการจัดลำดับความสำคัญของการแก้ไขปัญหา
• ระดับ Project และ Portfolio: ผู้ใช้สามารถดูรายงานความปลอดภัยสำหรับโครงการแต่ละโครงการหรือรวบรวมข้อมูลจากหลายโครงการ ซึ่งมีประโยชน์อย่างยิ่งสำหรับองค์กรขนาดใหญ่
• การผสานรวมกับ SAST: ฟีเจอร์ Security Reports ถูกรวมเข้ากับความสามารถของ Static Application Security Testing (SAST) ช่วยให้การวิเคราะห์ช่องโหว่ใน code มีความลึกซึ้งยิ่งขึ้น

และนี่คือตัวอย่าง Security Report ของ SonarQube สามารถ Download จากหน้า SonarQube server ได้เลย

ตัวอย่าง pdf โดยประมาณ

Reference

https://docs.sonarsource.com/sonarqube/latest/user-guide/security-reports/

สรุปเนื้อหา

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

อย่างไรก็ตาม SonarQube ควรถูกมองว่าเป็นเครื่องมือ “เสริม” สำหรับการดูแลคุณภาพ code ไม่ใช่เครื่องมือชี้วัดประสิทธิภาพของ application ถึงแม้ว่า code ที่ clean จะช่วยลดปัญหาต่าง ๆ ในการพัฒนา software ได้ แต่ก็ไม่ได้หมายความว่าจะสามารถแก้ไขทุกปัญหาได้ การมี code ที่ดีช่วยเพิ่มคุณภาพของงานและลดปัญหาที่อาจเกิดขึ้น เช่น การตรวจจับข้อผิดพลาด ช่องโหว่ด้านความปลอดภัย และลดความเสี่ยงจากการใช้ code ที่ไม่ปลอดภัย ดังนั้น การใช้ SonarQube จึงเป็นเพียงส่วนหนึ่งในการทำให้ software มีคุณภาพที่ดีขึ้น แต่ยังคงต้องอาศัยการพัฒนาและตรวจสอบในด้านอื่น ๆ ด้วยเช่นกัน

หวังว่าทุกคนจะได้รับความรู้ทั้ง SonarQube และ Code Quality นำไปประยุกต์ใช้ต่อกันนะครับ 😁