Cycode

ทางการ

เพิ่มความปลอดภัยในวงจรการพัฒนาซอฟต์แวร์ของคุณด้วยการสแกน SAST, SCA, Secrets และ IaC ผ่าน Cycode

คุณทำอะไรได้บ้างด้วย Cycode MCP?

สแกนเส้นทาง repository เพื่อหาความลับที่ถูกฝังไว้ — ขอให้ผู้ช่วยรัน cycode_secret_scan บนไดเรกทอรีในเครื่องเพื่อตรวจจับข้อมูลรับรองที่ถูกเปิดเผย
ตรวจสอบ dependencies เพื่อหาช่องโหว่ที่รู้จัก — เรียกใช้ cycode_sca_scan กับเส้นทางโปรเจกต์เพื่อระบุแพ็กเกจโอเพนซอร์สที่มีช่องโหว่หรือไม่เป็นไปตามข้อกำหนด
ตรวจสอบไฟล์ Infrastructure as Code เพื่อหาการตั้งค่าที่ผิดพลาด — ใช้ cycode_iac_scan บนไดเรกทอรี Terraform หรือ CloudFormation เพื่อเผยให้เห็นการตั้งค่าที่มีความเสี่ยง
ตรวจสอบซอร์สโค้ดเพื่อหาข้อบกพร่องด้านความปลอดภัย — รัน cycode_sast_scan บนโค้ดเบสเพื่อค้นหาจุดอ่อนระดับโค้ดและปัญหาด้านคุณภาพ
ยืนยันสถานะการตรวจสอบสิทธิ์และเวอร์ชันของ CLI — เรียกใช้ cycode_status เพื่อยืนยันการเชื่อมต่อกับ Cycode และเวอร์ชันที่ใช้งานอยู่

เอกสาร

คู่มือผู้ใช้ Cycode CLI

Cycode Command Line Interface (CLI) เป็นแอปพลิเคชันที่คุณสามารถติดตั้งในเครื่องของคุณเพื่อสแกนที่เก็บโค้ดของคุณสำหรับซีเคร็ต, การกำหนดค่าที่ผิดพลาดของ Infrastructure as Code, ช่องโหว่ในการวิเคราะห์องค์ประกอบซอฟต์แวร์ และปัญหาการทดสอบความปลอดภัยของแอปพลิเคชันแบบสแตติก

คู่มือนี้จะแนะนำคุณเกี่ยวกับการติดตั้งและการใช้งาน

สารบัญ

ข้อกำหนดเบื้องต้น
การติดตั้ง
1. ติดตั้ง Cycode CLI
2. ติดตั้ง Pre-Commit Hook
คำสั่ง Cycode CLI
คำสั่ง MCP
คำสั่ง Platform
AI Guardrails
1. ข้อมูลที่ AI Guardrails เก็บรวบรวม
คำสั่ง Scan
คำสั่ง Report
1. การสร้างรายงาน SBOM
คำสั่ง Import
บันทึกการสแกน
วิธีใช้ไวยากรณ์

ข้อกำหนดเบื้องต้น

แอปพลิเคชัน Cycode CLI ต้องการ Python เวอร์ชัน 3.9 หรือใหม่กว่า คำสั่ง MCP ใช้ได้เฉพาะกับ Python 3.10 ขึ้นไป หากคุณใช้ Python เวอร์ชันก่อนหน้า คำสั่งนี้จะไม่สามารถใช้ได้
ใช้ คำสั่ง cycode auth เพื่อตรวจสอบสิทธิ์กับ Cycode ด้วย CLI
- หรือคุณสามารถรับ Cycode Client ID และ Client Secret Key ได้โดยทำตามขั้นตอนที่ระบุในหน้า Service Account Token และ Personal Access Token ซึ่งมีรายละเอียดเกี่ยวกับการรับค่าเหล่านี้

การติดตั้ง

ขั้นตอนการติดตั้งต่อไปนี้ใช้ได้กับทั้งระบบปฏิบัติการ Windows และ UNIX / Linux

[!NOTE] ขั้นตอนต่อไปนี้สมมติว่าใช้ python3 และ pip3 สำหรับคำสั่งที่เกี่ยวข้องกับ Python อย่างไรก็ตาม บางระบบอาจใช้คำสั่ง python และ pip แทน ขึ้นอยู่กับการกำหนดค่าสภาพแวดล้อม Python ของคุณ

ติดตั้ง Cycode CLI

ในการติดตั้งแอปพลิเคชัน Cycode CLI บนเครื่องของคุณ ให้ทำตามขั้นตอนต่อไปนี้:

เปิดแอปพลิเคชัน command line หรือ terminal ของคุณ
รันคำสั่งใดคำสั่งหนึ่งต่อไปนี้:
- เพื่อติดตั้งจาก PyPI:
```
pip3 install cycode
```
- เพื่อติดตั้งจาก Homebrew:
```
brew install cycode
```
- เพื่อติดตั้งจาก GitHub Releases ไปที่และดาวน์โหลดไฟล์ปฏิบัติการสำหรับระบบปฏิบัติการและสถาปัตยกรรมของคุณ จากนั้นรันคำสั่งต่อไปนี้:
```
cd /path/to/downloaded/cycode-cli
chmod +x cycode
./cycode
```
สุดท้ายตรวจสอบสิทธิ์ CLI มีสามวิธีในการตั้งค่า Cycode client ID และข้อมูลประจำตัว (client secret หรือ OIDC ID token):
- cycode auth (แนะนำ)
- cycode configure
- เพิ่มลงใน ตัวแปรสภาพแวดล้อม ของคุณ

การใช้คำสั่ง Auth

[!NOTE] นี่คือวิธีที่ แนะนำ สำหรับการตั้งค่าเครื่องของคุณเพื่อตรวจสอบสิทธิ์กับ Cycode CLI

พิมพ์คำสั่งต่อไปนี้ลงในหน้าต่าง terminal/command line ของคุณ:

cycode auth
หน้าต่างเบราว์เซอร์จะปรากฏขึ้น ขอให้คุณเข้าสู่ระบบ Cycode (ดังที่แสดงด้านล่าง):
ป้อนข้อมูลประจำตัวการเข้าสู่ระบบของคุณในหน้านี้และเข้าสู่ระบบ
ในที่สุดคุณจะถูกนำไปยังหน้าด้านล่าง ซึ่งคุณจะถูกขอให้เลือกกลุ่มธุรกิจที่คุณต้องการอนุญาต Cycode (ถ้ามี):

[!NOTE] นี่จะเป็นวิธีเริ่มต้นสำหรับการตรวจสอบสิทธิ์กับ Cycode CLI
คลิกปุ่ม Allow เพื่ออนุญาต Cycode CLI ในกลุ่มธุรกิจที่เลือก
เมื่อเสร็จสิ้น คุณจะเห็นหน้าจอต่อไปนี้หากเลือกสำเร็จ:
ในหน้าจอ terminal/command line คุณจะเห็นข้อความต่อไปนี้เมื่อออกจากหน้าต่างเบราว์เซอร์:

Successfully logged into cycode

การใช้คำสั่ง Configure

[!NOTE] หากคุณตั้งค่า Cycode Client ID และ Client Secret ผ่านตัวแปรสภาพแวดล้อม Linux หรือ Windows แล้ว ข้อมูลประจำตัวเหล่านั้นจะมีความสำคัญเหนือกว่าวิธีนี้

พิมพ์คำสั่งต่อไปนี้ลงในหน้าต่าง terminal/command line ของคุณ:
```
cycode configure
```
ป้อนค่า Cycode API URL ของคุณ (คุณสามารถเว้นว่างไว้เพื่อใช้ค่าเริ่มต้น)

Cycode API URL [https://api.cycode.com]: https://api.onpremise.com
ป้อนค่า Cycode APP URL ของคุณ (คุณสามารถเว้นว่างไว้เพื่อใช้ค่าเริ่มต้น)

Cycode APP URL [https://app.cycode.com]: https://app.onpremise.com
ป้อนค่า Cycode Client ID ของคุณ

Cycode Client ID []: 7fe5346b-xxxx-xxxx-xxxx-55157625c72d
ป้อนค่า Cycode Client Secret ของคุณ (ข้ามหากคุณวางแผนที่จะใช้ OIDC ID token)

Cycode Client Secret []: c1e24929-xxxx-xxxx-xxxx-8b08c1839a2e
ป้อนค่า Cycode OIDC ID Token ของคุณ (ไม่บังคับ)

Cycode ID Token []: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...
หากป้อนค่าสำเร็จ คุณจะเห็นข้อความต่อไปนี้:

Successfully configured CLI credentials!

หรือ/และ

Successfully configured Cycode URLs!

หากคุณเข้าไปในโฟลเดอร์ .cycode ภายใต้โฟลเดอร์ผู้ใช้ของคุณ คุณจะพบว่าข้อมูลประจำตัวเหล่านี้ถูกสร้างและวางไว้ในไฟล์ credentials.yaml ในโฟลเดอร์นั้น URL ถูกวางไว้ในไฟล์ config.yaml ในโฟลเดอร์นั้น

เพิ่มลงในตัวแปรสภาพแวดล้อม

บน Unix/Linux:

export CYCODE_CLIENT_ID={your Cycode ID}

และ

export CYCODE_CLIENT_SECRET={your Cycode Secret Key}

หากองค์กรของคุณใช้การตรวจสอบสิทธิ์ OIDC คุณสามารถให้ ID token แทน (หรือเพิ่มเติม):

export CYCODE_ID_TOKEN={your Cycode OIDC ID token}

บน Windows

จาก Control Panel ไปที่เมนู System:
ถัดไป คลิก Advanced system settings:
ในหน้าต่าง System Properties ที่เปิดขึ้น ให้คลิกปุ่ม Environment Variables:
สร้างตัวแปร CYCODE_CLIENT_ID และ CYCODE_CLIENT_SECRET ด้วยค่าที่ตรงกับ ID และ Secret Key ของคุณตามลำดับ หากคุณตรวจสอบสิทธิ์ผ่าน OIDC ให้เพิ่ม CYCODE_ID_TOKEN ด้วยค่า OIDC ID token ของคุณเช่นกัน:
แทรก cycode.exe ลงในพาธเพื่อทำการติดตั้งให้เสร็จสมบูรณ์

ติดตั้ง Pre-Commit Hook

pre-commit และ pre-push hooks ของ Cycode สามารถตั้งค่าภายในที่เก็บโค้ดในเครื่องของคุณ เพื่อให้แอปพลิเคชัน Cycode CLI ระบุปัญหาใดๆ กับโค้ดของคุณโดยอัตโนมัติก่อนที่คุณจะ commit หรือ push ไปยัง codebase ของคุณ

[!NOTE] pre-commit และ pre-push hooks ไม่สามารถใช้ได้กับการสแกน IaC

ทำตามขั้นตอนต่อไปนี้เพื่อติดตั้ง pre-commit hook:

การติดตั้ง Pre-Commit Hook

ติดตั้ง pre-commit framework (ต้องติดตั้ง Python 3.9 หรือสูงกว่า):
```
pip3 install pre-commit
```
ไปที่ไดเรกทอรีบนสุดของที่เก็บ Git ในเครื่องที่คุณต้องการกำหนดค่า
สร้างไฟล์ YAML ใหม่ชื่อ .pre-commit-config.yaml (รวม . ตอนต้น) ในไดเรกทอรีบนสุดของที่เก็บที่มีเนื้อหาดังต่อไปนี้:
```
repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.5.0
    hooks:
      - id: cycode
        stages: [pre-commit]
```
แก้ไขไฟล์ที่สร้างขึ้นสำหรับความต้องการเฉพาะของคุณ ใช้ hook ID cycode เพื่อเปิดใช้งานการสแกนหา Secrets ใช้ hook ID cycode-sca เพื่อเปิดใช้งานการสแกน SCA ใช้ hook ID cycode-sast เพื่อเปิดใช้งานการสแกน SAST หากคุณต้องการเปิดใช้งานประเภทการสแกนทั้งหมด ให้ใช้การกำหนดค่านี้:
```
repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.5.0
    hooks:
      - id: cycode
        stages: [pre-commit]
      - id: cycode-sca
        stages: [pre-commit]
      - id: cycode-sast
        stages: [pre-commit]
```
ติดตั้ง hook ของ Cycode:
```
pre-commit install
```
การติดตั้ง hook ที่สำเร็จจะแสดงข้อความ: Pre-commit installed at .git/hooks/pre-commit
อัปเดต pre-commit hook ให้เป็นปัจจุบันเสมอ:
```
pre-commit autoupdate
```
มันจะอัปเดต rev ใน .pre-commit-config.yaml เป็นเวอร์ชันล่าสุดของ Cycode CLI โดยอัตโนมัติ

[!NOTE] ทริกเกอร์เกิดขึ้นกับคำสั่ง git commit Hook จะทริกเกอร์เฉพาะไฟล์ที่ staged สำหรับ commit

การติดตั้ง Pre-Push Hook

ในการติดตั้ง pre-push hook เพิ่มเติมหรือแทน pre-commit hook:

เพิ่ม pre-push hooks ลงในไฟล์ .pre-commit-config.yaml ของคุณ:

repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.5.0
    hooks:
      - id: cycode-pre-push
        stages: [pre-push]

ติดตั้ง pre-push hook:

pre-commit install --hook-type pre-push

สำหรับทั้ง pre-commit และ pre-push hooks ให้ใช้:
```
pre-commit install
pre-commit install --hook-type pre-push
```

[!NOTE] Pre-push hooks ทริกเกอร์กับคำสั่ง git push และสแกนเฉพาะ commits ที่กำลังจะถูก push

คำสั่ง Cycode CLI

ต่อไปนี้คือตัวเลือกและคำสั่งที่ใช้ได้กับแอปพลิเคชัน Cycode CLI:

ตัวเลือก	คำอธิบาย
`-v`, `--verbose`	แสดงบันทึกโดยละเอียด
`--no-progress-meter`	ไม่แสดงแถบความคืบหน้า
`--no-update-notifier`	ไม่ตรวจสอบการอัปเดต CLI
`-o`, `--output [rich\|text\|json\|table]`	ระบุประเภทผลลัพธ์ ค่าเริ่มต้นคือ `rich`
`--client-id TEXT`	ระบุ Cycode client ID สำหรับการรันการสแกนเฉพาะครั้งนี้
`--client-secret TEXT`	ระบุ Cycode client secret สำหรับการรันการสแกนเฉพาะครั้งนี้
`--id-token TEXT`	ระบุ Cycode OIDC ID token สำหรับการรันการสแกนเฉพาะครั้งนี้
`--install-completion`	ติดตั้งการเติมคำสั่งอัตโนมัติสำหรับ shell ปัจจุบัน
`--show-completion [bash\|zsh\|fish\|powershell\|pwsh]`	แสดงการเติมคำสั่งอัตโนมัติสำหรับ shell ที่ระบุ เพื่อคัดลอกหรือปรับแต่งการติดตั้ง
`-h`, `--help`	แสดงตัวเลือกสำหรับคำสั่งที่กำหนด
คำสั่ง	คำอธิบาย
-------------------------------------------	----------------------------------------------------------------------------------------------------------------------------------------------
auth	ตรวจสอบสิทธิ์เครื่องของคุณเพื่อเชื่อมโยง CLI กับบัญชี Cycode ของคุณ
configure	คำสั่งเริ่มต้นเพื่อกำหนดค่าการตรวจสอบสิทธิ์ไคลเอนต์ CLI ของคุณ
ignore	ละเว้นค่า พาธ หรือรหัสกฎที่ระบุ
mcp	เริ่มเซิร์ฟเวอร์ Model Context Protocol (MCP) เพื่อเปิดใช้งานการผสานรวม AI กับความสามารถในการสแกนของ Cycode
scan	สแกนเนื้อหาเพื่อหาการละเมิด Secrets/IaC/SCA/SAST คุณจะต้องระบุประเภทการสแกนที่จะดำเนินการ: commit-history/path/repository/etc.
report	สร้างรายงาน คุณจะต้องระบุประเภทรายงานที่จะดำเนินการ เช่น SBOM
status	แสดงสถานะ CLI และออก

คำสั่ง MCP [การทดลอง]

[!WARNING] คำสั่ง MCP พร้อมใช้งานสำหรับ Python 3.10 ขึ้นไปเท่านั้น หากคุณใช้ Python เวอร์ชันก่อนหน้า คำสั่งนี้จะไม่พร้อมใช้งาน

คำสั่ง Model Context Protocol (MCP) ช่วยให้คุณสามารถเริ่มเซิร์ฟเวอร์ MCP ที่เปิดเผยความสามารถในการสแกนของ Cycode แก่ระบบ AI และแอปพลิเคชัน ซึ่งช่วยให้โมเดล AI สามารถโต้ตอบกับเครื่องมือ Cycode CLI ผ่านโปรโตคอลมาตรฐานได้

[!TIP] เพื่อประสบการณ์ที่ดีที่สุด ให้ติดตั้ง Cycode CLI แบบ global บนระบบของคุณโดยใช้ pip install cycode หรือ brew install cycode จากนั้นตรวจสอบสิทธิ์เพียงครั้งเดียวด้วย cycode auth หลังจากการติดตั้งแบบ global และการตรวจสอบสิทธิ์ คุณจะไม่จำเป็นต้องกำหนดค่าตัวแปรสภาพแวดล้อม CYCODE_CLIENT_ID และ CYCODE_CLIENT_SECRET ในไฟล์การกำหนดค่า MCP ของคุณ

การเริ่มเซิร์ฟเวอร์ MCP

ในการเริ่มเซิร์ฟเวอร์ MCP ให้ใช้คำสั่งต่อไปนี้:

cycode mcp

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

ตัวเลือกที่พร้อมใช้งาน

ตัวเลือก	คำอธิบาย
`-t, --transport`	ประเภทการขนส่งสำหรับเซิร์ฟเวอร์ MCP: `stdio`, `sse`, หรือ `streamable-http` (ค่าเริ่มต้น: `stdio`)
`-H, --host`	ที่อยู่โฮสต์ที่จะผูกเซิร์ฟเวอร์ (ใช้สำหรับการขนส่งที่ไม่ใช่ stdio เท่านั้น) (ค่าเริ่มต้น: `127.0.0.1`)
`-p, --port`	หมายเลขพอร์ตที่จะผูกเซิร์ฟเวอร์ (ใช้สำหรับการขนส่งที่ไม่ใช่ stdio เท่านั้น) (ค่าเริ่มต้น: `8000`)
`--help`	แสดงข้อความช่วยเหลือและตัวเลือกที่พร้อมใช้งาน

เครื่องมือ MCP

เซิร์ฟเวอร์ MCP มีเครื่องมือต่อไปนี้ที่ระบบ AI สามารถใช้ได้:

ชื่อเครื่องมือ	คำอธิบาย
`cycode_secret_scan`	สแกนหาซีเคร็ตที่ฝัง hardcode
`cycode_sca_scan`	สแกนเพื่อการวิเคราะห์องค์ประกอบซอฟต์แวร์ (SCA) - ช่องโหว่และปัญหาใบอนุญาต
`cycode_iac_scan`	สแกนหาการกำหนดค่าที่ผิดพลาดของ Infrastructure as Code (IaC)
`cycode_sast_scan`	สแกนเพื่อการทดสอบความปลอดภัยของแอปพลิเคชันแบบสแตติก (SAST) - ข้อบกพร่องด้านคุณภาพโค้ดและความปลอดภัย
`cycode_status`	รับข้อมูลเวอร์ชัน Cycode CLI สถานะการตรวจสอบสิทธิ์ และการกำหนดค่า

เครื่องมือสแกนแต่ละตัวยอมรับโหมดอินพุตสองโหมดที่ไม่สามารถใช้ร่วมกันได้:

paths (แนะนำ) — พาธไฟล์หรือไดเรกทอรีอย่างน้อยหนึ่งรายการที่มีอยู่บนดิสก์ ไดเรกทอรีจะถูกสแกนแบบเรียกซ้ำ เอ็นจิน Cycode จัดการการค้นพบและการกรองไฟล์ เช่นเดียวกับที่ cycode scan -t <type> path ./src ทำจาก CLI
files (ทางเลือกสำรอง) — พจนานุกรมที่แมปพาธไฟล์กับเนื้อหาทั้งหมดเป็นสตริง ใช้สิ่งนี้เฉพาะเมื่อไฟล์ไม่พร้อมใช้งานบนดิสก์ (เช่น การแก้ไขในหน่วยความจำที่ยังไม่ได้บันทึก)

[!TIP] ใช้ paths ทุกครั้งที่ทำได้ การส่งไฟล์ขนาดใหญ่ (เช่น package-lock.json) เป็นเนื้อหาแบบอินไลน์อาจเกินขีดจำกัดของโทเค็นและทำให้ไคลเอนต์ AI ทำงานช้าลง ด้วย paths เอ็นจิน Cycode จะอ่านไฟล์โดยตรงจากดิสก์

เครื่องมือสแกนทั้งหมดส่งคืนออบเจกต์ JSON ที่มีฟิลด์ "summary" พร้อมจำนวนการละเมิดที่มนุษย์อ่านได้ (เช่น "Cycode found 3 violations: 1 CRITICAL, 2 HIGH.") นอกเหนือจากอาร์เรย์ "detections" แบบเต็ม

ตัวอย่างการใช้งาน

ตัวอย่างคำสั่งพื้นฐาน

เริ่มเซิร์ฟเวอร์ MCP ด้วยการตั้งค่าเริ่มต้น (การขนส่ง stdio):

cycode mcp

เริ่มเซิร์ฟเวอร์ MCP ด้วยการขนส่ง stdio อย่างชัดเจน:

cycode mcp -t stdio

เริ่มเซิร์ฟเวอร์ MCP ด้วยการขนส่ง Server-Sent Events (SSE):

cycode mcp -t sse -p 8080

เริ่มเซิร์ฟเวอร์ MCP ด้วยการขนส่ง HTTP แบบสตรีมได้บนโฮสต์และพอร์ตที่กำหนดเอง:

cycode mcp -t streamable-http -H 0.0.0.0 -p 9000

เรียนรู้เพิ่มเติมเกี่ยวกับประเภทการขนส่ง MCP ได้ใน MCP Protocol Specification – Transports

ตัวอย่างการกำหนดค่า

การใช้ MCP กับ Cursor/VS Code/Claude Desktop/ฯลฯ (mcp.json)

[!NOTE] สำหรับสภาพแวดล้อม Cycode ใน EU ตรวจสอบให้แน่ใจว่าได้ตั้งค่า CYCODE_API_URL และ CYCODE_APP_URL ที่เหมาะสมในตัวแปรสภาพแวดล้อม (เช่น https://api.eu.cycode.com และ https://app.eu.cycode.com)

ทำตาม คู่มือนี้ เพื่อกำหนดค่าเซิร์ฟเวอร์ MCP ใน VS Code/GitHub Copilot ของคุณ โปรดทราบว่าใน settings.json มีออบเจกต์ mcp ที่มีออบเจกต์ย่อย servers ซ้อนอยู่ แทนที่จะเป็นออบเจกต์ mcpServers แบบสแตนด์อโลน

สำหรับ การขนส่ง stdio (การดำเนินการโดยตรง):

{
  "mcpServers": {
    "cycode": {
      "command": "cycode",
      "args": ["mcp"],
      "env": {
        "CYCODE_CLIENT_ID": "your-cycode-id",
        "CYCODE_CLIENT_SECRET": "your-cycode-secret-key",
        "CYCODE_API_URL": "https://api.cycode.com",
        "CYCODE_APP_URL": "https://app.cycode.com"
      }
    }
  }
}

สำหรับ การขนส่ง stdio ด้วยการติดตั้ง pipx:

{
  "mcpServers": {
    "cycode": {
      "command": "pipx",
      "args": ["run", "cycode", "mcp"],
      "env": {
        "CYCODE_CLIENT_ID": "your-cycode-id",
        "CYCODE_CLIENT_SECRET": "your-cycode-secret-key",
        "CYCODE_API_URL": "https://api.cycode.com",
        "CYCODE_APP_URL": "https://app.cycode.com"
      }
    }
  }
}

สำหรับ การขนส่ง stdio ด้วยการติดตั้ง uvx:

{
  "mcpServers": {
    "cycode": {
      "command": "uvx",
      "args": ["cycode", "mcp"],
      "env": {
        "CYCODE_CLIENT_ID": "your-cycode-id",
        "CYCODE_CLIENT_SECRET": "your-cycode-secret-key",
        "CYCODE_API_URL": "https://api.cycode.com",
        "CYCODE_APP_URL": "https://app.cycode.com"
      }
    }
  }
}

สำหรับ การขนส่ง SSE (Server-Sent Events):

{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.1:8000/sse"
    }
  }
}

สำหรับ การขนส่ง SSE บนพอร์ตที่กำหนดเอง:

{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.1:8080/sse"
    }
  }
}

สำหรับ การขนส่ง HTTP แบบสตรีมได้:

{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.1:8000/mcp"
    }
  }
}

การรันเซิร์ฟเวอร์ MCP ในพื้นหลัง

สำหรับ การขนส่ง SSE (เริ่มเซิร์ฟเวอร์ก่อน จากนั้นกำหนดค่าไคลเอนต์):

# Start the MCP server in the background
cycode mcp -t sse -p 8000 &

# Configure in mcp.json
{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.1:8000/sse"
    }
  }
}

สำหรับ การขนส่ง HTTP แบบสตรีมได้:

# Start the MCP server in the background
cycode mcp -t streamable-http -H 127.0.0.2 -p 9000 &

# Configure in mcp.json
{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.2:9000/mcp"
    }
  }
}

การกำหนดค่าขั้นสูง

ใบรับรองที่กำหนดเองและการหมดเวลา (สภาพแวดล้อมพร็อกซี)

หากองค์กรของคุณใช้พร็อกซีขององค์กรหรือชุด CA ที่กำหนดเองสำหรับการตรวจสอบ HTTPS คุณต้องแจ้งให้ Cycode CLI (และสแต็ก TLS ของ Python ที่เกี่ยวข้อง) ทราบว่าจะค้นหาชุดใบรับรองที่เชื่อถือได้ได้จากที่ใด คุณยังสามารถเพิ่มการหมดเวลาการเรียกเครื่องมือ MCP หากการสแกนถูกตัดให้สั้นลง

ตัวแปรสภาพแวดล้อม	คำอธิบาย
`REQUESTS_CA_BUNDLE`	พาธไปยังไฟล์ชุด CA ที่กำหนดเอง (`.pem` หรือ `.crt`) ใช้โดยไลบรารี `requests` สำหรับการเรียก HTTPS ทั้งหมดที่ทำโดย Cycode CLI
`SSL_CERT_FILE`	พาธไปยังไฟล์ชุด CA ที่กำหนดเอง ใช้โดยโมดูล `ssl` ระดับต่ำของ Python ตั้งค่านี้ควบคู่ไปกับ `REQUESTS_CA_BUNDLE` เพื่อความครอบคลุมเต็มรูปแบบ
`MCP_TOOL_TIMEOUT`	การหมดเวลา (เป็นวินาที) ที่ไคลเอนต์ MCP เช่น Claude และ GitHub Copilot รอให้การเรียกเครื่องมือเสร็จสมบูรณ์ เพิ่มค่านี้หากการสแกนที่ใช้เวลานานถูกตัดออกก่อนที่จะเสร็จสิ้น

[!TIP] ตั้งค่าทั้ง REQUESTS_CA_BUNDLE และ SSL_CERT_FILE เป็นพาธชุด CA เดียวกัน REQUESTS_CA_BUNDLE ครอบคลุมเลเยอร์ HTTP; SSL_CERT_FILE ครอบคลุมเลเยอร์ TLS ระดับล่าง การใช้เพียงตัวใดตัวหนึ่งอาจยังทำให้เกิดข้อผิดพลาดเกี่ยวกับใบรับรองในบางสภาพแวดล้อม

ตัวอย่างการกำหนดค่า mcp.json ด้วยใบรับรองที่กำหนดเองและการหมดเวลาที่นานขึ้น:

{
  "mcpServers": {
    "cycode": {
      "command": "cycode",
      "args": ["mcp"],
      "env": {
        "REQUESTS_CA_BUNDLE": "/path/to/your/corporate-ca-bundle.pem",
        "SSL_CERT_FILE": "/path/to/your/corporate-ca-bundle.pem",
        "MCP_TOOL_TIMEOUT": "1800"
      }
    }
  }
}

[!NOTE] เซิร์ฟเวอร์ MCP ต้องการการตรวจสอบสิทธิ์ Cycode CLI ที่เหมาะสมจึงจะทำงานได้ ตรวจสอบให้แน่ใจว่าคุณได้ตรวจสอบสิทธิ์โดยใช้ cycode auth หรือกำหนดค่าข้อมูลประจำตัวของคุณก่อนเริ่มเซิร์ฟเวอร์ MCP

การอนุญาตเครื่องมือล่วงหน้าสำหรับ Subagents (Claude Code)

เมื่อ Claude Code มอบหมายงานให้กับ subagents พื้นหลัง (เช่น เพื่อรันการสแกนแบบขนาน) subagents เหล่านั้นจะไม่สามารถแสดงข้อความแจ้งขออนุญาตแบบโต้ตอบได้ หากเครื่องมือ Cycode ไม่ได้รับการอนุมัติล่วงหน้า การสแกนจะล้มเหลวอย่างเงียบๆ ในบริบทของ subagent

ในการอนุญาตเครื่องมือ Cycode MCP ล่วงหน้าเพื่อให้ทำงานได้ในทุกบริบทรวมถึง subagents ให้เพิ่มเครื่องมือเหล่านั้นลงในรายการ allowedTools ในการตั้งค่า Claude Code ของคุณ (~/.claude/settings.json):

{
  "allowedTools": [
    "mcp__cycode__cycode_secret_scan",
    "mcp__cycode__cycode_sca_scan",
    "mcp__cycode__cycode_iac_scan",
    "mcp__cycode__cycode_sast_scan",
    "mcp__cycode__cycode_status"
  ]
}

เมื่อเพิ่มแล้ว Claude Code จะไม่แจ้งขออนุมัติเมื่อมีการเรียกเครื่องมือเหล่านี้ และเครื่องมือเหล่านี้จะทำงานได้อย่างถูกต้องภายใน subagents

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

หากคุณพบปัญหาเกี่ยวกับเซิร์ฟเวอร์ MCP คุณสามารถเปิดใช้งานการบันทึกดีบักเพื่อรับข้อมูลรายละเอียดเพิ่มเติมเกี่ยวกับสิ่งที่เกิดขึ้น มีสองวิธีในการเปิดใช้งานการบันทึกดีบัก:

การใช้แฟล็ก -v หรือ --verbose:

cycode -v mcp

การใช้ตัวแปรสภาพแวดล้อม CYCODE_CLI_VERBOSE:

CYCODE_CLI_VERBOSE=1 cycode mcp

บันทึกดีบักจะแสดงข้อมูลรายละเอียดเกี่ยวกับ:

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

ข้อมูลนี้มีประโยชน์เมื่อ:

วินิจฉัยปัญหาการเชื่อมต่อ
ทำความเข้าใจว่าเหตุใดเครื่องมือบางอย่างจึงไม่ทำงาน
ระบุปัญหาการตรวจสอบสิทธิ์
ดีบักปัญหาเฉพาะการขนส่ง

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

คำสั่ง Platform [BETA]

[!WARNING] คำสั่ง platform อยู่ในสถานะ เบต้า คำสั่ง อาร์กิวเมนต์ และรูปแบบเอาต์พุตถูกสร้างขึ้นแบบไดนามิกจากข้อกำหนด API ของ Cycode และอาจเปลี่ยนแปลงระหว่างรุ่นโดยไม่ต้องแจ้งให้ทราบ อย่าพึ่งพาคำสั่งเหล่านี้ในระบบอัตโนมัติสำหรับการใช้งานจริง

คำสั่ง cycode platform เปิดเผย API การอ่านของแพลตฟอร์ม Cycode เป็นคำสั่ง CLI โดยจะจัดกลุ่มเอนด์พอยต์ตามทรัพยากร (เช่น projects, violations, workflows) และเปลี่ยนพารามิเตอร์ของแต่ละเอนด์พอยต์ให้เป็นอาร์กิวเมนต์ CLI และแฟล็ก --option ที่มีชนิดข้อมูล

cycode platform projects list --page-size 50
cycode platform violations count
cycode platform workflows view <workflow-id>

ข้อกำหนด OpenAPI ถูกดึงมาจาก Cycode API เมื่อใช้งานครั้งแรกและถูกแคชไว้ที่ ~/.cycode/openapi-spec.json เป็นเวลา 24 ชั่วโมง คำสั่งที่ไม่เกี่ยวข้อง (cycode scan, cycode status, ฯลฯ) จะไม่ทริกเกอร์การดึงข้อมูล

[!NOTE] คุณต้องได้รับการตรวจสอบสิทธิ์ (cycode auth หรือตัวแปรสภาพแวดล้อม CYCODE_CLIENT_ID / CYCODE_CLIENT_SECRET) เพื่อให้ cycode platform ค้นพบและรันคำสั่ง คำสั่ง Cycode CLI อื่นๆ ทำงานได้โดยไม่ต้องตรวจสอบสิทธิ์

การค้นหาคำสั่ง

เนื่องจากคำสั่งถูกสร้างขึ้นจากข้อกำหนด แหล่งที่มาของความจริงสำหรับสิ่งที่มีอยู่คือ --help:

cycode platform --help                  # list all resource groups
cycode platform projects --help         # list actions on a resource
cycode platform projects list --help    # list options/arguments for an action

ตัวอย่าง Platform

# List projects with pagination
cycode platform projects list --page-size 25

# View a single project by ID
cycode platform projects view <project-id>

# Count violations across the tenant
cycode platform violations count

# Filter using query parameters (see `--help` for what each endpoint supports)
cycode platform violations list --severity CRITICAL

เอาต์พุตทั้งหมดเป็น JSON ตามค่าเริ่มต้น — ส่งผ่าน jq เพื่อการกรองเฉพาะกิจ:

cycode platform projects list --page-size 100 | jq '.items[].name'

หมายเหตุและข้อจำกัดของ Platform

อ่านได้อย่างเดียวในปัจจุบัน เฉพาะเอนด์พอยต์ GET เท่านั้นที่ถูกเปิดเผยในรุ่นเบต้านี้
ขับเคลื่อนด้วยข้อกำหนด การเพิ่มเอนด์พอยต์ใหม่ลงใน API จะปรากฏขึ้นโดยอัตโนมัติในครั้งถัดไปที่แคชถูกรีเฟรช
ไม่มีข้อกำหนดที่รวมมา การเรียกใช้ cycode platform ครั้งแรกหลังการติดตั้ง (หรือหลังจากแคช 24 ชั่วโมงหมดอายุ) จะทำการดึงข้อมูลผ่านเครือข่าย สำหรับการเชื่อมต่อที่ช้า การเรียกครั้งแรกนี้อาจใช้เวลาสองสามวินาที การเรียกครั้งต่อๆ ไปจะเกือบจะทันทีจนกว่าแคชจะหมดอายุ
แทนที่ TTL ของแคช ด้วย CYCODE_SPEC_CACHE_TTL=<seconds>

AI Guardrails [BETA]

AI Guardrails ติดตั้ง hooks เข้าไปใน AI coding agents ที่รองรับ (Claude Code, Cursor, Copilot, Codex) เพื่อให้ prompts, ไฟล์ที่ agent อ่าน, และอาร์กิวเมนต์ของ MCP tool ถูกสแกนหาความลับก่อนที่จะส่งไปยังโมเดล

ข้อมูลที่ AI Guardrails เก็บรวบรวม

การสแกนเกิดขึ้นฝั่งเซิร์ฟเวอร์ ดังนั้นเนื้อหาที่ถูกสแกนจะออกจากเครื่อง: ข้อความ prompt, เนื้อหาของ ไฟล์ที่ agent อ่าน, และอาร์กิวเมนต์ของ MCP tool จะถูกส่งไปยัง Cycode tenant ของคุณเพื่อตรวจสอบหาความลับ

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

ตัวระบุอุปกรณ์ — ชื่อโฮสต์ของเครื่องและหมายเลขซีเรียลฮาร์ดแวร์
ตัวระบุผู้ใช้ — ที่อยู่อีเมลของผู้ใช้ที่ลงชื่อเข้าใช้ AI coding agent และชื่อผู้ใช้ ระบบปฏิบัติการภายในเครื่อง
รายละเอียดสภาพแวดล้อม — ระบบปฏิบัติการและเวอร์ชัน, AI agent, เวอร์ชันและโมเดลที่ใช้งาน, เนื้อหาของไฟล์การกำหนดค่า MCP ของ agent และปลั๊กอินที่เปิดใช้งาน

หมายเลขซีเรียลฮาร์ดแวร์ถูกแคชไว้ในไฟล์ชั่วคราวภายในเครื่อง ซึ่งอ่านได้เฉพาะผู้ใช้ที่รัน คำสั่งนั้น เพื่อให้การเรียกใช้ hook ซ้ำๆ ไม่ต้องสอบถามฮาร์ดแวร์อีก

หากการเก็บรวบรวมข้อมูลนี้ไม่เป็นที่ยอมรับในสภาพแวดล้อมของคุณ อย่าติดตั้ง guardrails hooks (cycode ai-guardrails uninstall จะลบ hooks ที่ติดตั้งไว้แล้วออก)

คำสั่ง Scan

การรัน Scan

แอปพลิเคชัน Cycode CLI มีการสแกนหลายประเภทเพื่อให้คุณสามารถเลือกตัวเลือกที่เหมาะสมกับกรณีของคุณมากที่สุด ต่อไปนี้คือตัวเลือกและคำสั่งที่มีให้ใช้งานในปัจจุบัน:

ตัวเลือก	คำอธิบาย
`-t, --scan-type [secret\|iac\|sca\|sast]`	ระบุการสแกนที่คุณต้องการดำเนินการ (`secret`/`iac`/`sca`/`sast`) ค่าเริ่มต้นคือ `secret`
`--show-secret BOOLEAN`	แสดงความลับในรูปแบบข้อความธรรมดา ดูรายละเอียดเพิ่มเติมในส่วน แสดง/ซ่อนความลับ
`--soft-fail BOOLEAN`	รันการสแกนโดยไม่ทำให้ล้มเหลว จะส่งคืนรหัสสถานะที่ไม่ใช่ข้อผิดพลาดเสมอ ดูรายละเอียดเพิ่มเติมในส่วน Soft Fail
`--severity-threshold [INFO\|LOW\|MEDIUM\|HIGH\|CRITICAL]`	แสดงเฉพาะการละเมิดที่มีระดับตามที่ระบุหรือสูงกว่า
`--sca-scan`	ระบุการสแกน SCA ที่คุณต้องการดำเนินการ (`package-vulnerabilities`/`license-compliance`) ค่าเริ่มต้นคือทั้งสองอย่าง
`--monitor`	เมื่อระบุ ผลการสแกนจะถูกบันทึกใน Cycode
`--cycode-report`	แสดงลิงก์ไปยังรายงานการสแกนในแพลตฟอร์ม Cycode ในผลลัพธ์ของคอนโซล
`--no-restore`	เมื่อระบุ Cycode จะไม่รันคำสั่ง restore การดำเนินการนี้จะสแกนเฉพาะ direct dependencies เท่านั้น!
`--stop-on-error`	ยกเลิกการสแกนหากเกิดความล้มเหลวในการรวบรวมไฟล์หรือการ restore dependency ใดๆ แทนที่จะข้ามไฟล์ที่ล้มเหลวและดำเนินการต่อ
`--gradle-all-sub-projects`	รันคำสั่ง gradle restore สำหรับโปรเจกต์ย่อยทั้งหมด ควรรันจาก
`--maven-settings-file`	สำหรับ Maven เท่านั้น อนุญาตให้ใช้ไฟล์ settings.xml แบบกำหนดเองเมื่อสแกนหา dependencies
`--help`	แสดงตัวเลือกสำหรับคำสั่งที่กำหนด

คำสั่ง	คำอธิบาย
commit-history	สแกนประวัติ commit หรือทำการสแกน diff ระหว่าง commit ที่ระบุ
path	สแกนไฟล์ในพาธที่ระบุในคำสั่ง
pre-commit	ใช้คำสั่งนี้เพื่อสแกนเนื้อหาที่ยังไม่ได้ commit
repository	สแกน git repository รวมถึงประวัติของมัน

ตัวเลือก

ตัวเลือก Severity

เพื่อจำกัดผลลัพธ์ของการสแกนให้อยู่ในเกณฑ์ความรุนแรงที่ระบุ สามารถเพิ่มอาร์กิวเมนต์ --severity-threshold ลงในคำสั่ง scan ได้

ตัวอย่างเช่น คำสั่งต่อไปนี้จะสแกน repository เพื่อหาการละเมิดนโยบายที่มีความรุนแรงระดับ Medium หรือสูงกว่า:

cycode scan --severity-threshold MEDIUM repository ~/home/git/codebase

ตัวเลือก Monitor

[!NOTE] ตัวเลือกนี้ใช้ได้เฉพาะกับการสแกน SCA เท่านั้น

เพื่อส่งผลการสแกนที่เชื่อมโยงกับ นโยบาย SCA ที่พบในการสแกนประเภท SCA ไปยัง Cycode ให้เพิ่มอาร์กิวเมนต์ --monitor ลงในคำสั่ง scan

ตัวอย่างเช่น คำสั่งต่อไปนี้จะสแกน repository เพื่อหาการละเมิดนโยบาย SCA และส่งไปยังแพลตฟอร์ม Cycode:

cycode scan -t sca --monitor repository ~/home/git/codebase

ตัวเลือก Cycode Report

สำหรับทุกการสแกนที่ดำเนินการโดยใช้ Cycode CLI รายงานจะถูกสร้างขึ้นโดยอัตโนมัติและผลลัพธ์จะถูกส่งไปยัง Cycode ผลลัพธ์เหล่านี้เชื่อมโยงกับนโยบายที่เกี่ยวข้อง (เช่น นโยบาย SCA สำหรับการสแกน Repository) ภายในแพลตฟอร์ม Cycode

เพื่อให้ URL โดยตรงไปยังรายงาน Cycode นี้ถูกพิมพ์ในผลลัพธ์ CLI ของคุณหลังจากการสแกนเสร็จสิ้น ให้เพิ่มอาร์กิวเมนต์ --cycode-report ลงในคำสั่ง scan ของคุณ

cycode scan --cycode-report repository ~/home/git/codebase

ผลการสแกนทั้งหมดจาก CLI จะปรากฏในส่วน CLI Logs ของ Cycode หากคุณรวมแฟล็ก --cycode-report ไว้ในคำสั่งของคุณ ลิงก์โดยตรงไปยังรายงานที่ระบุจะแสดงในเทอร์มินัลของคุณหลังจากผลการสแกน

[!WARNING] คุณต้องมีบทบาท owner หรือ admin ใน Cycode เพื่อดูหน้านี้

cli-report

หน้ารายงานจะมีลักษณะคล้ายดังนี้:

ตัวเลือก Package Vulnerabilities

[!NOTE] ตัวเลือกนี้ใช้ได้เฉพาะกับการสแกน SCA เท่านั้น

เพื่อสแกนช่องโหว่ของแพ็คเกจเฉพาะของ local repository ของคุณ ให้เพิ่มอาร์กิวเมนต์ --sca-scan package-vulnerabilities ต่อจากตัวเลือก -t sca หรือ --scan-type sca

ในตัวอย่างก่อนหน้านี้ หากคุณต้องการรันเฉพาะการสแกน SCA สำหรับช่องโหว่ของแพ็คเกจ คุณสามารถดำเนินการดังต่อไปนี้:

cycode scan -t sca --sca-scan package-vulnerabilities repository ~/home/git/codebase

ตัวเลือก License Compliance

[!NOTE] ตัวเลือกนี้ใช้ได้เฉพาะกับการสแกน SCA เท่านั้น

เพื่อสแกน branch เฉพาะของ local repository ของคุณ ให้เพิ่มอาร์กิวเมนต์ --sca-scan license-compliance ตามด้วยชื่อของ branch ที่คุณต้องการสแกน

ในตัวอย่างก่อนหน้านี้ หากคุณต้องการสแกนเฉพาะ branch ที่ชื่อ dev คุณสามารถดำเนินการดังต่อไปนี้:

cycode scan -t sca --sca-scan license-compliance repository ~/home/git/codebase -b dev

ตัวเลือก Lock Restore

[!NOTE] ตัวเลือกนี้ใช้ได้เฉพาะกับการสแกน SCA เท่านั้น

เมื่อรันการสแกน SCA, Cycode CLI จะพยายาม restore (สร้าง) dependency lockfile สำหรับแต่ละ manifest file ที่รองรับที่พบโดยอัตโนมัติ การดำเนินการนี้ช่วยให้สามารถสแกน transitive dependencies ได้ ไม่ใช่แค่ที่ระบุไว้โดยตรงใน manifest หากต้องการข้ามขั้นตอนนี้และสแกนเฉพาะ direct dependencies ให้ใช้แฟล็ก --no-restore

ระบบนิเวศต่อไปนี้รองรับการ restore lockfile อัตโนมัติ:

ระบบนิเวศ	ไฟล์ Manifest	Lockfile ที่สร้าง	เครื่องมือที่เรียกใช้ (เมื่อไม่มี lockfile)
npm	`package.json`	`package-lock.json`	`npm install --package-lock-only --ignore-scripts --no-audit`
Yarn	`package.json`	`yarn.lock`	`yarn install --ignore-scripts`
pnpm	`package.json`	`pnpm-lock.yaml`	`pnpm install --ignore-scripts`
Deno	`deno.json` / `deno.jsonc`	`deno.lock`	(อ่านเฉพาะ lockfile ที่มีอยู่)
Go	`go.mod`	`go.mod.graph`	`go list -m -json all` + `go mod graph`
Maven	`pom.xml`	`bcde.mvndeps`	`mvn dependency:tree`
Gradle	`build.gradle` / `build.gradle.kts`	`gradle-dependencies-generated.txt`	`gradle dependencies -q --console plain`
SBT	`build.sbt`	`build.sbt.lock`	`sbt dependencyLockWrite`
NuGet	`*.csproj`	`packages.lock.json`	`dotnet restore --use-lock-file`
Ruby	`Gemfile`	`Gemfile.lock`	`bundle --quiet`
Poetry	`pyproject.toml`	`poetry.lock`	`poetry lock`
pip	`pyproject.toml` / `requirements.txt`	`pylock.toml`	`pip lock .` / `pip lock -r requirements.txt -o pylock.toml`
Pipenv	`Pipfile`	`Pipfile.lock`	`pipenv lock`
PHP Composer	`composer.json`	`composer.lock`	`composer update --no-cache --no-install --no-scripts --ignore-platform-reqs`

หากมี lockfile อยู่แล้วข้างๆ manifest, Cycode จะอ่านโดยตรงโดยไม่ต้องรันคำสั่ง install ใดๆ

ข้อกำหนดเบื้องต้นของ SBT: ต้องติดตั้งปลั๊กอิน sbt-dependency-lock เพิ่มบรรทัดต่อไปนี้ลงใน project/plugins.sbt:

addSbtPlugin("software.purpledragon" % "sbt-dependency-lock" % "1.5.1")

ตัวเลือก Stop on Error

ตามค่าเริ่มต้น Cycode จะสแกนต่อไปแม้ว่าจะไม่สามารถอ่านไฟล์ได้ (เช่น เนื่องจากข้อผิดพลาดด้านสิทธิ์) หรือไม่สามารถสร้าง dependency lockfile ระหว่างการสแกน SCA ได้ รายการที่ล้มเหลวจะถูกข้ามไปพร้อมคำเตือน และการสแกนจะดำเนินการต่อกับไฟล์ที่เหลือ

ใช้ --stop-on-error เพื่อเปลี่ยนพฤติกรรมนี้: การสแกนจะยุติทันทีเมื่อเกิดความล้มเหลวครั้งแรกและรายงานข้อผิดพลาด

cycode scan -t sca --stop-on-error path ~/home/git/codebase

สิ่งนี้มีประโยชน์ใน CI pipelines ที่ความล้มเหลวแบบเงียบจะทำให้ได้ผลการสแกนที่ไม่สมบูรณ์ เมื่อ --stop-on-error ถูกทริกเกอร์ คุณสามารถแก้ไขปัญหาพื้นฐานหรือสำหรับความล้มเหลวในการ restore ของ SCA โดยเฉพาะ ให้เพิ่ม --no-restore เพื่อข้ามการสร้าง lockfile และสแกนเฉพาะ direct dependencies

เมื่อใช้ --stop-on-error, CLI จะแยกความแตกต่างระหว่างข้อผิดพลาดในการสแกนและการละเมิดนโยบายผ่าน exit codes:

Exit code	ความหมาย
`0`	การสแกนเสร็จสมบูรณ์โดยไม่มีการละเมิด
`1`	การสแกนเสร็จสมบูรณ์และพบการละเมิด
`2`	การสแกนถูกยกเลิกเนื่องจากข้อผิดพลาด (เฉพาะเมื่อตั้งค่า `--stop-on-error`)

การสแกน Repository

การสแกน repository จะตรวจสอบ local repository ทั้งหมดเพื่อหาความลับที่เปิดเผยหรือการกำหนดค่าที่ไม่ปลอดภัย การสแกนประเภทที่ครอบคลุมมากขึ้นนี้จะดูทุกอย่าง: สถานะปัจจุบันของ repository และประวัติ commit ของคุณ มันจะมองหาไม่เพียงแต่ความลับที่กำลังเปิดเผยอยู่ใน repository แต่รวมถึงความลับที่ถูกลบไปก่อนหน้านี้ด้วย

เพื่อดำเนินการสแกน repository แบบเต็ม ให้ดำเนินการดังต่อไปนี้:

cycode scan repository {{path}}

ตัวอย่างเช่น หากคุณต้องการสแกน repository ที่เก็บไว้ใน ~/home/git/codebase คุณสามารถดำเนินการดังต่อไปนี้:

cycode scan repository ~/home/git/codebase

ตัวเลือกต่อไปนี้พร้อมใช้งานสำหรับคำสั่งนี้:

ตัวเลือก	คำอธิบาย
`-b, --branch TEXT`	Branch ที่จะสแกน หากไม่ได้ตั้งค่าจะสแกน branch เริ่มต้น

ตัวเลือก Branch

เพื่อสแกน branch เฉพาะของ local repository ของคุณ ให้เพิ่มอาร์กิวเมนต์ -b (หรือ --branch) ตามด้วยชื่อของ branch ที่คุณต้องการสแกน

จากตัวอย่างก่อนหน้านี้ หากคุณต้องการสแกนเฉพาะ branch ที่ชื่อ dev คุณสามารถดำเนินการดังต่อไปนี้:

cycode scan repository ~/home/git/codebase -b dev

การสแกน Path

การสแกน path จะตรวจสอบไดเรกทอรีภายในเครื่องที่ระบุและเนื้อหาทั้งหมดภายในนั้น แทนที่จะมุ่งเน้นเฉพาะ GIT repository

เพื่อดำเนินการสแกนไดเรกทอรี ให้ดำเนินการดังต่อไปนี้:

cycode scan path {{path}}

ตัวอย่างเช่น พิจารณาสถานการณ์ที่คุณต้องการสแกนไดเรกทอรีที่อยู่ที่ ~/home/git/codebase คุณสามารถดำเนินการดังต่อไปนี้:

cycode scan path ~/home/git/codebase

การสแกน Terraform PlanCycode CLI รองรับการสแกนแผน Terraform (รองรับ Terraform 0.12 ขึ้นไป)

ไฟล์แผน Terraform ต้องอยู่ในรูปแบบ JSON (มีนามสกุล .json)

หากคุณมีเพียงไฟล์คอนฟิก คุณสามารถสร้างแผนได้โดยทำตามขั้นตอนต่อไปนี้:

เริ่มต้นไดเรกทอรีทำงานที่มีไฟล์คอนฟิก Terraform:

terraform init
สร้างแผนการดำเนินการ Terraform และบันทึกผลลัพธ์ไบนารี:

terraform plan -out={tfplan_output}
แปลงไฟล์ผลลัพธ์ไบนารีเป็น JSON ที่อ่านได้:

terraform show -json {tfplan_output} > {tfplan}.json
สแกน {tfplan}.json ของคุณด้วย Cycode CLI:

cycode scan -t iac path ~/PATH/TO/YOUR/{tfplan}.json

การสแกนประวัติคอมมิต

[!NOTE] การสแกนประวัติคอมมิตไม่พร้อมใช้งานสำหรับการสแกน IaC

คำสั่งสแกนประวัติคอมมิตมีความสามารถหลักสองประการ:

การสแกนประวัติทั้งหมด: วิเคราะห์คอมมิตทั้งหมดในประวัติของรีพอสิทอรี
การสแกนความแตกต่าง: สแกนเฉพาะการเปลี่ยนแปลงระหว่างคอมมิตที่ระบุ

การสแกนซีเคร็ตสามารถวิเคราะห์คอมมิตทั้งหมดในประวัติของรีพอสิทอรีได้ เนื่องจากซีเคร็ตที่ถูกนำเข้ามาและถูกลบออกในภายหลังอาจยังคงรั่วไหลหรือถูกเปิดเผยได้ สำหรับการสแกน SCA และ SAST คำสั่งประวัติคอมมิตจะเน้นการสแกนความแตกต่าง/การเปลี่ยนแปลงระหว่างคอมมิต ทำให้เหมาะสำหรับการรีวิว Pull Request และการสแกนแบบเพิ่มส่วน

การสแกนประวัติคอมมิตจะตรวจสอบประวัติคอมมิตของ Git repository ของคุณ และสามารถใช้ได้ทั้งสำหรับการวิเคราะห์ประวัติแบบครอบคลุมและการสแกนความแตกต่างแบบเจาะจงของการเปลี่ยนแปลงที่ระบุ

เพื่อดำเนินการสแกนประวัติคอมมิต ให้ดำเนินการดังนี้:

cycode scan commit-history {{path}}

ตัวอย่างเช่น พิจารณาสถานการณ์ที่คุณต้องการสแกนประวัติคอมมิตสำหรับรีพอสิทอรีที่เก็บอยู่ใน ~/home/git/codebase คุณสามารถดำเนินการดังนี้:

cycode scan commit-history ~/home/git/codebase

ตัวเลือกต่อไปนี้พร้อมใช้งานสำหรับคำสั่งนี้:

ตัวเลือก	คำอธิบาย
`-r, --commit-range TEXT`	สแกนช่วงคอมมิตใน Git repository นี้ โดยค่าเริ่มต้น cycode จะสแกนประวัติคอมมิตทั้งหมด (ตัวอย่าง: HEAD~1)

ตัวเลือกช่วงคอมมิต (การสแกนความแตกต่าง)

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

การตรวจสอบ Pull Request: สแกนเฉพาะการเปลี่ยนแปลงที่นำเข้ามาใน PR
การสแกน CI/CD แบบเพิ่มส่วน: เน้นการเปลี่ยนแปลงล่าสุดแทนที่จะเป็นโค้ดเบสทั้งหมด
การรีวิว Feature Branch: เปรียบเทียบการเปลี่ยนแปลงกับ branch main/master
การเพิ่มประสิทธิภาพ: การสแกนที่เร็วขึ้นโดยการจำกัดขอบเขตเฉพาะการเปลี่ยนแปลงที่เกี่ยวข้อง

ไวยากรณ์ช่วงคอมมิต

ตัวเลือก --commit-range (-r) รองรับไวยากรณ์ Git revision มาตรฐาน:

ไวยากรณ์	คำอธิบาย	ตัวอย่าง
`commit1..commit2`	การเปลี่ยนแปลงจาก commit1 ถึง commit2	`abc123..def456`
`commit1...commit2`	การเปลี่ยนแปลงใน commit2 ที่ไม่อยู่ใน commit1	`main...feature-branch`
`commit`	การเปลี่ยนแปลงจาก commit ถึง HEAD	`HEAD~1`
`branch1..branch2`	การเปลี่ยนแปลงจาก branch1 ถึง branch2	`main..feature-branch`

ตัวอย่างการสแกนความแตกต่าง

สแกนการเปลี่ยนแปลงในคอมมิตล่าสุด:

cycode scan commit-history -r HEAD~1 ~/home/git/codebase

สแกนการเปลี่ยนแปลงระหว่างสองคอมมิตที่ระบุ:

cycode scan commit-history -r abc123..def456 ~/home/git/codebase

สแกนการเปลี่ยนแปลงใน Feature Branch ของคุณเปรียบเทียบกับ main:

cycode scan commit-history -r main..HEAD ~/home/git/codebase

สแกนการเปลี่ยนแปลงระหว่าง main และ Feature Branch:

cycode scan commit-history -r main..feature-branch ~/home/git/codebase

สแกนการเปลี่ยนแปลงทั้งหมดใน 3 คอมมิตล่าสุด:

cycode scan commit-history -r HEAD~3..HEAD ~/home/git/codebase

[!TIP] สำหรับ CI/CD pipelines คุณสามารถใช้ environment variables เช่น ${{ github.event.pull_request.base.sha }}..${{ github.sha }} (GitHub Actions) หรือ $CI_MERGE_REQUEST_TARGET_BRANCH_SHA..$CI_COMMIT_SHA (GitLab CI) เพื่อสแกนเฉพาะการเปลี่ยนแปลงของ PR/MR

การสแกนก่อนคอมมิต

การสแกนก่อนคอมมิตจะระบุปัญหาใด ๆ โดยอัตโนมัติก่อนที่คุณจะคอมมิตการเปลี่ยนแปลงไปยังรีพอสิทอรีของคุณ คุณไม่จำเป็นต้องดำเนินการสแกนนี้ด้วยตนเอง กำหนดค่า pre-commit hook ตามรายละเอียดในส่วนการติดตั้งของคู่มือนี้

หลังจากติดตั้ง pre-commit hook แล้ว คุณอาจต้องการข้ามการสแกนในบางคอมมิตเป็นครั้งคราว โดยเพิ่มสิ่งต่อไปนี้ลงในคำสั่ง git ของคุณเพื่อข้ามการสแกนสำหรับคอมมิตเดียว:

SKIP=cycode git commit -m <your commit message>`

การสแกนก่อนพุช

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

[!NOTE] Pre-push hook ไม่พร้อมใช้งานสำหรับการสแกน IaC

pre-push hook ทำงานร่วมกับ pre-commit framework และสามารถกำหนดค่าให้ทำงานก่อนการดำเนินการ git push ใด ๆ

การติดตั้ง Pre-Push Hook

เพื่อตั้งค่า pre-push hook โดยใช้ pre-commit framework:

ติดตั้ง pre-commit framework (หากยังไม่ได้ติดตั้ง):
```
pip3 install pre-commit
```

สร้างหรืออัปเดตไฟล์ .pre-commit-config.yaml ของคุณเพื่อรวม pre-push hooks:

repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.5.0
    hooks:
      - id: cycode-pre-push
        stages: [pre-push]

สำหรับการสแกนหลายประเภท ใช้การกำหนดค่านี้:

repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.5.0
    hooks:
      - id: cycode-pre-push          # Secrets scan
        stages: [pre-push]
      - id: cycode-sca-pre-push      # SCA scan
        stages: [pre-push]
      - id: cycode-sast-pre-push     # SAST scan
        stages: [pre-push]

ติดตั้ง pre-push hook:
```
pre-commit install --hook-type pre-push
```
การติดตั้งที่สำเร็จจะแสดงข้อความ: Pre-push installed at .git/hooks/pre-push
อัปเดต pre-push hook ให้ทันสมัยอยู่เสมอ:
```
pre-commit autoupdate
```

วิธีการทำงานของการสแกนก่อนพุช

pre-push hook:

รับข้อมูลเกี่ยวกับคอมมิตที่กำลังถูกพุช
คำนวณช่วงคอมมิตที่เหมาะสมในการสแกน
สำหรับ branch ใหม่: สแกนคอมมิตทั้งหมดจาก merge base กับ default branch
สำหรับ branch ที่มีอยู่: สแกนเฉพาะคอมมิตใหม่ตั้งแต่การพุชครั้งล่าสุด
ดำเนินการสแกนแบบครอบคลุมเช่นเดียวกับโหมดการสแกนอื่น ๆ ของ Cycode

การตรวจจับ Default Branch อัจฉริยะ

pre-push hook ตรวจจับ default branch สำหรับการคำนวณ merge base อย่างชาญฉลาดโดยใช้ลำดับความสำคัญนี้:

Environment Variable: CYCODE_DEFAULT_BRANCH - อนุญาตให้กำหนดค่าเองได้
Git Remote HEAD: ใช้ git symbolic-ref refs/remotes/origin/HEAD เพื่อตรวจจับ default branch จริงของ remote
Git Remote Info: ถอยกลับไปใช้ git remote show origin หาก symbolic-ref ล้มเหลว
Hardcoded Fallbacks: ใช้ชื่อ default branch ทั่วไป (origin/main, origin/master, main, master)

การตั้งค่า Default Branch เอง:

export CYCODE_DEFAULT_BRANCH=origin/develop

การตรวจจับอัจฉริยะนี้ช่วยให้มั่นใจว่า pre-push hook ทำงานได้อย่างถูกต้องไม่ว่ารีพอสิทอรีของคุณจะใช้ main, master, develop หรือชื่อ default branch อื่น ๆ

การข้ามการสแกนก่อนพุช

เพื่อข้ามการสแกนก่อนพุชสำหรับการดำเนินการพุชที่ระบุ ใช้:

SKIP=cycode-pre-push git push

หรือเพื่อข้าม pre-push hooks ทั้งหมด:

git push --no-verify

[!TIP] pre-push hook จะถูกทริกเกอร์เมื่อมีคำสั่ง git push และสแกนเฉพาะคอมมิตที่กำลังจะถูกพุช ทำให้มีประสิทธิภาพมากกว่าการสแกนรีพอสิทอรีทั้งหมด

ยกเว้นพาธจากการสแกน

คุณสามารถใช้ไฟล์ .cycodeignore เพื่อบอก Cycode CLI ว่าไฟล์และไดเรกทอรีใดที่จะยกเว้นจากการสแกน มันทำงานเหมือนกับไฟล์ .gitignore ซึ่งช่วยให้คุณโฟกัสการสแกนไปที่โค้ดที่เกี่ยวข้องและป้องกันไม่ให้บางพาธทริกเกอร์การละเมิดในเครื่อง

วิธีการทำงาน

สร้างไฟล์ชื่อ .cycodeignore ในโฟลเดอร์ทำงานของคุณ
ระบุไฟล์และไดเรกทอรีที่คุณต้องการยกเว้น โดยใช้รูปแบบเดียวกับ .gitignore
วางไฟล์นี้ในไดเรกทอรีที่คุณวางแผนจะรันคำสั่ง cycode scan

[!WARNING]

ไฟล์ที่ไม่ถูกต้อง: หากไฟล์ .cycodeignore มีข้อผิดพลาดทางไวยากรณ์ การสแกน CLI จะล้มเหลวและส่งกลับข้อผิดพลาด

การละเว้นพาธ vs. การละเมิด: ไฟล์นี้ใช้สำหรับการยกเว้นพาธ ซึ่งแตกต่างจากความสามารถของ CLI ในการละเว้นการละเมิดที่ระบุ (ตัวอย่างเช่น โดยใช้แฟล็ก --ignore-violation)

สแกนเนอร์ที่รองรับ

SAST
IaC (เร็ว ๆ นี้)
SCA (เร็ว ๆ นี้)

ผลการสแกน

การสแกนแต่ละครั้งจะเสร็จสิ้นพร้อมข้อความระบุว่าพบปัญหาใด ๆ หรือไม่

หากไม่พบปัญหา การสแกนจะสิ้นสุดด้วยข้อความสำเร็จต่อไปนี้:

Good job! No issues were found!!! 👏👏👏

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

แสดง/ซ่อนซีเคร็ต

ใน ตัวอย่างด้านล่าง พบซีเคร็ตในไฟล์ secret_test ซึ่งอยู่ในโฟลเดอร์ย่อย cli ส่วนที่สองของข้อความแสดงบรรทัดเฉพาะที่ซีเคร็ตปรากฏ ซึ่งในกรณีนี้คือค่าที่กำหนดให้กับ googleApiKey

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

เพื่อปิดใช้งานการปิดบังซีเคร็ต ให้เพิ่มอาร์กิวเมนต์ --show-secret ในการสแกนประเภทใด ๆ

ในตัวอย่างต่อไปนี้ การสแกนพาธถูกดำเนินการกับไดเรกทอรีย่อย cli โดยเปิดใช้งานตัวเลือกเพื่อแสดงซีเคร็ตใด ๆ ที่พบแบบเต็ม:

cycode scan --show-secret path ./cli

ผลลัพธ์จะไม่ถูกปิดบัง

Soft Fail

ในการทำงานปกติ CLI จะส่งกลับ exit code 1 เมื่อพบปัญหาในผลการสแกน ขึ้นอยู่กับการตั้งค่า CI/CD ของคุณ ซึ่งมักจะส่งผลให้เกิดความล้มเหลวโดยรวม หากคุณไม่ต้องการให้สิ่งนี้เกิดขึ้น คุณสามารถใช้คุณสมบัติ soft fail ได้

โดยการเพิ่มตัวเลือก --soft-fail ในการสแกนประเภทใด ๆ exit code จะถูกบังคับให้เป็น 0 ไม่ว่าจะพบผลลัพธ์ใด ๆ หรือไม่

ตัวอย่างผลการสแกน

ตัวอย่างผลลัพธ์ซีเคร็ต

╭─────────────────────────────────────────────────────────────── Hardcoded generic-password is used ───────────────────────────────────────────────────────────────╮
│                                                                                                                                               Violation 12 of 12 │
│ ╭─ 🔍 Details ───────────────────────────────────────╮ ╭─ 💻 Code Snippet ─────────────────────────────────────────────────────────────────────────────────────╮ │
│ │  Severity    🟠 MEDIUM                             │ │   34 };                                                                                               │ │
│ │  In file     /Users/cycodemacuser/NodeGoat/test/s  │ │   35                                                                                                  │ │
│ │              ecurity/profile-test.js               │ │   36 var sutUserName = "user1";                                                                       │ │
│ │  Secret SHA  b4ea3116d868b7c982ee6812cce61727856b  │ │ ❱ 37 var sutUserPassword = "Us*****23";                                                               │ │
│ │              802b3063cd5aebe7d796988552e0          │ │   38                                                                                                  │ │
│ │  Rule ID     68b6a876-4890-4e62-9531-0e687223579f  │ │   39 chrome.setDefaultService(service);                                                               │ │
│ ╰────────────────────────────────────────────────────╯ │   40                                                                                                  │ │
│                                                        ╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│ ╭─ 📝 Summary ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │
│ │ A generic secret or password is an authentication token used to access a computer or application and is assigned to a password variable.                     │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

ตัวอย่างผลลัพธ์ IaC

╭──────────── Enable Content Encoding through the attribute 'MinimumCompressionSize'. This value should be greater than -1 and smaller than 10485760. ─────────────╮
│                                                                                                                                              Violation 45 of 110 │
│ ╭─ 🔍 Details ───────────────────────────────────────╮ ╭─ 💻 Code Snippet ─────────────────────────────────────────────────────────────────────────────────────╮ │
│ │  Severity      🟠 MEDIUM                           │ │   20 BinaryMediaTypes:                                                                                │ │
│ │  In file       ...ads-copy/iac/cft/api-gateway/ap  │ │   21   - !Ref binaryMediaType1                                                                        │ │
│ │                i-gateway-rest-api/deploy.yml       │ │   22   - !Ref binaryMediaType2                                                                        │ │
│ │  IaC Provider  CloudFormation                      │ │ ❱ 23 MinimumCompressionSize: -1                                                                       │ │
│ │  Rule ID       33c4b90c-3270-4337-a075-d3109c141b  │ │   24 EndpointConfiguration:                                                                           │ │
│ │                53                                  │ │   25   Types:                                                                                         │ │
│ ╰────────────────────────────────────────────────────╯ │   26     - EDGE                                                                                       │ │
│                                                        ╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│ ╭─ 📝 Summary ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │
│ │ This policy validates the proper configuration of content encoding in AWS API Gateway. Specifically, the policy checks for the attribute                     │ │
│ │ 'minimum_compression_size' in API Gateway REST APIs. Correct configuration of this attribute is important for enabling content encoding of API responses for │ │
│ │ improved API performance and reduced payload sizes.                                                                                                          │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

ตัวอย่างผลลัพธ์ SCA

╭─────────────────────────────────────────────────────── [CVE-2019-10795] Prototype Pollution in undefsafe ────────────────────────────────────────────────────────╮
│                                                                                                                                             Violation 172 of 195 │
│ ╭─ 🔍 Details ───────────────────────────────────────╮ ╭─ 💻 Code Snippet ─────────────────────────────────────────────────────────────────────────────────────╮ │
│ │  Severity               🟠 MEDIUM                  │ │   26758   "integrity": "sha1-5z3T17DXxe2G+6xrCufYxqadUPo=",                                           │ │
│ │  In file                /Users/cycodemacuser/Node  │ │   26759   "dev": true                                                                                 │ │
│ │                         Goat/package-lock.json     │ │   26760 },                                                                                            │ │
│ │  CVEs                   CVE-2019-10795             │ │ ❱ 26761 "undefsafe": {                                                                                │ │
│ │  Package                undefsafe                  │ │   26762   "version": "2.0.2",                                                                         │ │
│ │  Version                2.0.2                      │ │   26763   "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.2.tgz",                   │ │
│ │  First patched version  Not fixed                  │ │   26764   "integrity": "sha1-Il9rngM3Zj4Njnz9aG/Cg2zKznY=",                                           │ │
│ │  Dependency path        nodemon 1.19.1 ->          │ ╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│ │                         undefsafe 2.0.2            │                                                                                                           │
│ │  Rule ID                9c6a8911-e071-4616-86db-4  │                                                                                                           │
│ │                         943f2e1df81                │                                                                                                           │
│ ╰────────────────────────────────────────────────────╯                                                                                                           │
│ ╭─ 📝 Summary ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │
│ │ undefsafe before 2.0.3 is vulnerable to Prototype Pollution. The 'a' function could be tricked into adding or modifying properties of Object.prototype using │ │
│ │ a __proto__ payload.                                                                                                                                         │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

ตัวอย่างผลลัพธ์ SAST

╭───────────────────────────────────────────── [CWE-208: Observable Timing Discrepancy] Observable Timing Discrepancy ─────────────────────────────────────────────╮
│                                                                                                                                               Violation 24 of 49 │
│ ╭─ 🔍 Details ───────────────────────────────────────╮ ╭─ 💻 Code Snippet ─────────────────────────────────────────────────────────────────────────────────────╮ │
│ │  Severity       🟠 MEDIUM                          │ │   173         " including numbers, lowercase and uppercase letters.";                                 │ │
│ │  In file        /Users/cycodemacuser/NodeGoat/app  │ │   174     return false;                                                                               │ │
│ │                 /routes/session.js                 │ │   175 }                                                                                               │ │
│ │  CWE            CWE-208                            │ │ ❱ 176 if (password !== verify) {                                                                      │ │
│ │  Subcategory    Security                           │ │   177     errors.verifyError = "Password must match";                                                 │ │
│ │  Language       js                                 │ │   178     return false;                                                                               │ │
│ │  Security Tool  Bearer (Powered by Cycode)         │ │   179 }                                                                                               │ │
│ │  Rule ID        19fbca07-a8e7-4fa6-92ac-a36d15509  │ ╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│ │                 fa9                                │                                                                                                           │
│ ╰────────────────────────────────────────────────────╯                                                                                                           │
│ ╭─ 📝 Summary ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │
│ │ Observable Timing Discrepancy occurs when the time it takes for certain operations to complete can be measured and observed by attackers. This vulnerability │ │
│ │ is particularly concerning when operations involve sensitive information, such as password checks or secret comparisons. If attackers can analyze how long   │ │
│ │ these operations take, they might be able to deduce confidential details, putting your data at risk.                                                         │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

แนวทางการแก้ไขเฉพาะของบริษัท

หากบริษัทของคุณได้ตั้งค่าแนวทางการแก้ไขเฉพาะในนโยบายที่เกี่ยวข้องผ่านพอร์ทัล Cycode คุณจะเห็นฟิลด์ "Company Guidelines" ที่มีแนวทางการแก้ไขที่คุณเพิ่มไว้ โปรดทราบว่าหากคุณไม่ได้เพิ่มแนวทางของบริษัทใด ๆ ฟิลด์นี้จะไม่ปรากฏในเครื่องมือ CLI

การละเว้นผลการสแกน

สามารถเพิ่มกฎการละเว้นเพื่อละเว้นค่าซีเคร็ตที่ระบุ ค่า SHA512 ที่ระบุ พาธที่ระบุ และ Cycode secret และ IaC rule ID ที่ระบุ ซึ่งจะทำให้การสแกนไม่แจ้งเตือนค่าเหล่านี้ กฎการละเว้นถูกเขียนและบันทึกในเครื่องในไฟล์ ./.cycode/config.yaml

[!WARNING] การเพิ่มค่าที่จะละเว้นควรทำด้วยการพิจารณาอย่างรอบคอบถึงค่า พาธ และนโยบาย เพื่อให้แน่ใจว่าการสแกนจะตรวจจับผลบวกจริงได้

ต่อไปนี้คือตัวเลือกที่พร้อมใช้งานสำหรับคำสั่ง cycode ignore:

ตัวเลือก	คำอธิบาย
`--by-value TEXT`	ละเว้นค่าเฉพาะขณะสแกนหาซีเคร็ต ดูรายละเอียดเพิ่มเติมที่ การละเว้นค่าซีเคร็ต
`--by-sha TEXT`	ละเว้นการแสดงผล SHA512 เฉพาะของสตริงขณะสแกนหาซีเคร็ต ดูรายละเอียดเพิ่มเติมที่ การละเว้นค่า SHA ของซีเคร็ต
`--by-path TEXT`	หลีกเลี่ยงการสแกนพาธที่ระบุ จำเป็นต้องระบุประเภทการสแกน ดูรายละเอียดเพิ่มเติมที่ การละเว้นพาธ
`--by-rule TEXT`	ละเว้นการสแกนรหัสกฎซีเคร็ต/รหัสกฎ IaC/รหัสกฎ SCA ที่ระบุ ดูรายละเอียดเพิ่มเติมที่ การละเว้นกฎซีเคร็ตหรือ Iac
`--by-package TEXT`	ละเว้นการสแกนเวอร์ชันแพ็คเกจที่ระบุขณะรันการสแกน SCA รูปแบบที่คาดหวัง - `name@version` ดูรายละเอียดเพิ่มเติมที่ การละเว้นแพ็คเกจ
`--by-cve TEXT`	ละเว้นการสแกน CVE ที่ระบุขณะรันการสแกน SCA รูปแบบที่คาดหวัง: CVE-YYYY-NNN
`-t, --scan-type [secret\|iac\|sca\|sast]`	ระบุการสแกนที่คุณต้องการดำเนินการ (`secret`/`iac`/`sca`/`sast`) ค่าเริ่มต้นคือ `secret`
`-g, --global`	เพิ่มกฎการละเว้นและอัปเดตในไฟล์คอนฟิก `.cycode` ส่วนกลาง

การละเว้นค่าซีเคร็ต

หากต้องการละเว้นค่าซีเคร็ตที่ระบุ คุณจะต้องใช้แฟล็ก --by-value การดำเนินการนี้จะละเว้นค่าซีเคร็ตที่กำหนดจากการสแกนในอนาคตทั้งหมด ใช้คำสั่งต่อไปนี้เพื่อเพิ่มค่าซีเคร็ตที่จะละเว้น:

cycode ignore --by-value {{secret-value}}

ในตัวอย่างที่ด้านบนของส่วนนี้ คำสั่งเพื่อละเว้นค่าซีเคร็ตที่ระบุมีดังนี้:

cycode ignore --by-value h3110w0r1d!@#$350

ในตัวอย่างข้างต้น ให้แทนที่ค่า h3110w0r1d!@#$350 ด้วยค่าซีเคร็ตที่ไม่ได้มาสก์ของคุณ ดูตัวเลือกการสแกนของ Cycode สำหรับรายละเอียดเกี่ยวกับวิธีดูค่าซีเคร็ตในผลลัพธ์การสแกน

การละเว้นค่า SHA ของซีเคร็ต

หากต้องการละเว้นค่า SHA ของซีเคร็ตที่ระบุ คุณจะต้องใช้แฟล็ก --by-sha การดำเนินการนี้จะละเว้นค่า SHA ของซีเคร็ตที่กำหนดจากการสแกนในอนาคตทั้งหมด ใช้คำสั่งต่อไปนี้เพื่อเพิ่มค่า SHA ของซีเคร็ตที่จะละเว้น:

cycode ignore --by-sha {{secret-sha-value}}

ในตัวอย่างที่ด้านบนของส่วนนี้ คำสั่งเพื่อละเว้นค่า SHA ของซีเคร็ตที่ระบุมีดังนี้:

cycode ignore --by-sha a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0

ในตัวอย่างข้างต้น ให้แทนที่ค่า a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0 ด้วยค่า SHA ของซีเคร็ตของคุณ

การละเว้นพาธ

หากต้องการละเว้นพาธที่ระบุสำหรับการสแกนซีเคร็ต, IaC หรือ SCA คุณจะต้องใช้แฟล็ก --by-path ร่วมกับแฟล็ก -t, --scan-type (คุณต้องระบุประเภทการสแกน) การดำเนินการนี้จะละเว้นพาธที่กำหนดจากการสแกนในอนาคตทั้งหมดสำหรับประเภทการสแกนที่กำหนด ใช้คำสั่งต่อไปนี้เพื่อเพิ่มพาธที่จะละเว้น:

cycode ignore -t {{scan-type}} --by-path {{path}}

ในตัวอย่างที่ด้านบนของส่วนนี้ คำสั่งเพื่อละเว้นพาธที่ระบุสำหรับซีเคร็ตมีดังนี้:

cycode ignore -t secret --by-path ~/home/my-repo/config

ในตัวอย่างข้างต้น ให้แทนที่ค่า ~/home/my-repo/config ด้วยค่าพาธของคุณ

ในตัวอย่างที่ด้านบนของส่วนนี้ คำสั่งเพื่อละเว้นพาธที่ระบุจากการสแกน IaC มีดังนี้:

cycode ignore -t iac --by-path ~/home/my-repo/config

ในตัวอย่างข้างต้น ให้แทนที่ค่า ~/home/my-repo/config ด้วยค่าพาธของคุณ

ในตัวอย่างที่ด้านบนของส่วนนี้ คำสั่งเพื่อละเว้นพาธที่ระบุจากการสแกน SCA มีดังนี้:

cycode ignore -t sca --by-path ~/home/my-repo/config

ในตัวอย่างข้างต้น ให้แทนที่ค่า ~/home/my-repo/config ด้วยค่าพาธของคุณ

การละเว้นกฎซีเคร็ต, IaC, SCA หรือ SAST

หากต้องการละเว้นกฎซีเคร็ต, IaC, SCA หรือ SAST ที่ระบุ คุณจะต้องใช้แฟล็ก --by-rule ร่วมกับแฟล็ก -t, --scan-type (คุณต้องระบุประเภทการสแกน) การดำเนินการนี้จะละเว้นค่ารหัสกฎที่กำหนดจากการสแกนในอนาคตทั้งหมด ใช้คำสั่งต่อไปนี้เพื่อเพิ่มค่ารหัสกฎที่จะละเว้น:

cycode ignore -t {{scan-type}} --by-rule {{rule-ID}}

ในตัวอย่างที่ด้านบนของส่วนนี้ คำสั่งเพื่อละเว้นรหัสกฎซีเคร็ตที่ระบุมีดังนี้:

cycode ignore -t secret --by-rule ce3a4de0-9dfc-448b-a004-c538cf8b4710

ในตัวอย่างข้างต้น ให้แทนที่ค่า ce3a4de0-9dfc-448b-a004-c538cf8b4710 ด้วยรหัสกฎที่คุณต้องการละเว้น

ในตัวอย่างที่ด้านบนของส่วนนี้ คำสั่งเพื่อละเว้นรหัสกฎ IaC ที่ระบุมีดังนี้:

cycode ignore -t iac --by-rule bdaa88e2-5e7c-46ff-ac2a-29721418c59c

ในตัวอย่างข้างต้น ให้แทนที่ค่า bdaa88e2-5e7c-46ff-ac2a-29721418c59c ด้วยรหัสกฎที่คุณต้องการละเว้น

ในตัวอย่างที่ด้านบนของส่วนนี้ คำสั่งเพื่อละเว้นรหัสกฎ SCA ที่ระบุมีดังนี้:

cycode ignore -t sca --by-rule dc21bc6b-9f4f-46fb-9f92-e4327ea03f6b

ในตัวอย่างข้างต้น ให้แทนที่ค่า dc21bc6b-9f4f-46fb-9f92-e4327ea03f6b ด้วยรหัสกฎที่คุณต้องการละเว้น

การละเว้นแพ็คเกจ

[!NOTE] ตัวเลือกนี้ใช้ได้เฉพาะกับการสแกน SCA เท่านั้น

หากต้องการละเว้นแพ็คเกจที่ระบุในการสแกน SCA คุณจะต้องใช้แฟล็ก --by-package ร่วมกับแฟล็ก -t, --scan-type (คุณต้องระบุประเภทการสแกน sca) การดำเนินการนี้จะละเว้นแพ็คเกจที่กำหนด โดยใช้การจัดรูปแบบ {{package_name}}@{{package_version}} จากการสแกนในอนาคตทั้งหมด ใช้คำสั่งต่อไปนี้เพื่อเพิ่มแพ็คเกจและเวอร์ชันที่จะละเว้น:

cycode ignore --scan-type sca --by-package {{package_name}}@{{package_version}}

หรือ

cycode ignore -t sca --by-package {{package_name}}@{{package_version}}

ในตัวอย่างด้านล่าง คำสั่งเพื่อละเว้นแพ็คเกจ SCA ที่ระบุมีดังนี้:

cycode ignore --scan-type sca --by-package pyyaml@5.3.1

ในตัวอย่างข้างต้น ให้แทนที่ pyyaml ด้วยชื่อแพ็คเกจ และ 5.3.1 ด้วยเวอร์ชันแพ็คเกจที่คุณต้องการละเว้น

การละเว้นผ่านไฟล์คอนฟิก

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

พาธของไฟล์คอนฟิก

ตามค่าเริ่มต้น คำสั่ง cycode ignore ทั้งหมดจะบันทึกกฎการละเว้นไปยังไดเรกทอรีปัจจุบันที่รัน CLI

ตัวอย่าง: การรันคำสั่ง CLI ละเว้นจาก /Users/name/projects/backend จะสร้าง config.yaml ใน /Users/name/projects/backend/.cycode

➜  backend  pwd
/Users/name/projects/backend
➜  backend  cycode ignore --by-value test-value
➜  backend  tree -a
.
└── .cycode
    └── config.yaml

2 directories, 1 file

ตัวเลือกที่สองคือการบันทึกกฎการละเว้นไปยังไฟล์คอนฟิกส่วนกลาง พาธของคอนฟิกส่วนกลางคือ ~/.cycode/config.yaml โดยที่ ~ หมายถึง users home directory, for example, /Users/name` บน macOS

การบันทึกไปยังพื้นที่ส่วนกลางสามารถทำได้ด้วยแฟล็ก -g ของคำสั่ง cycode ignore ตัวอย่างเช่น: cycode ignore -g --by-value test-value

ไดเรกทอรีการทำงานที่เหมาะสม

เป็นสิ่งสำคัญอย่างยิ่งที่จะต้องวางโฟลเดอร์ .cycode และรัน CLI จากตำแหน่งเดียวกัน คุณควรตรวจสอบอีกครั้งเมื่อทำงานกับสภาพแวดล้อมที่แตกต่างกัน เช่น CI/CD (GitHub Actions, Jenkins เป็นต้น)

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

โครงสร้างกฎการละเว้นในคอนฟิก

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

โครงสร้าง YAML แบบนามธรรม:

exclusions:
  {scanTypeName}:
    {ignoringType}:
    - someIgnoringValue1
    - someIgnoringValue2

ค่าที่เป็นไปได้ของ scanTypeName: iac, sca, sast, secret

ค่าที่เป็นไปได้ของ ignoringType: paths, values, rules, packages, shas, cves

[!WARNING] ค่าสำหรับ "ละเว้นตามค่า" จะไม่ถูกจัดเก็บเป็นข้อความธรรมดา! CLI จะจัดเก็บแฮช sha256 ของค่าแทน คุณควรใส่แฮชของสตริงเมื่อแก้ไขไฟล์คอนฟิกด้วยตนเอง

ตัวอย่างของ config.yaml จริง:

exclusions:
  iac:
    rules:
    - bdaa88e2-5e7c-46ff-ac2a-29721418c59c
  sca:
    packages:
    - pyyaml@5.3.1
  secret:
    paths:
    - /Users/name/projects/build
    rules:
    - ce3a4de0-9dfc-448b-a004-c538cf8b4710
    shas:
    - a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0
    values:
    - a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3
    - 60303ae22b998861bce3b28f33eec1be758a213c86c93c076dbe9f558c11c752

คำสั่ง Report

การสร้างรายงาน SBOM

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

ตัวเลือกต่อไปนี้พร้อมใช้งานสำหรับคำสั่งนี้:

ตัวเลือก	คำอธิบาย	จำเป็น	ค่าเริ่มต้น
`-f, --format [spdx-2.2\|spdx-2.3\|cyclonedx-1.4]`	รูปแบบ SBOM	ใช่
`-o, --output-format [JSON]`	ระบุรูปแบบไฟล์เอาต์พุต	ไม่	json
`--output-file PATH`	ไฟล์เอาต์พุต	ไม่	ชื่อไฟล์ที่สร้างขึ้นอัตโนมัติบันทึกไปยังไดเรกทอรีปัจจุบัน
`--include-vulnerabilities`	รวมช่องโหว่	ไม่	False
`--include-dev-dependencies`	รวมดีเพนเดนซีสำหรับการพัฒนา	ไม่	False

คำสั่งต่อไปนี้พร้อมใช้งานสำหรับคำสั่งนี้:

คำสั่ง	คำอธิบาย
`path`	สร้างรายงาน SBOM สำหรับพาธที่ระบุในคำสั่ง
`repository-url`	สร้างรายงาน SBOM สำหรับ URI ของที่เก็บที่ระบุในคำสั่ง

ที่เก็บ

เพื่อสร้างรายงาน SBOM สำหรับ URI ของที่เก็บ:
cycode report sbom --format <sbom format> --include-vulnerabilities --include-dev-dependencies --output-file </path/to/file> repository_url <repository url>

ตัวอย่างเช่น:
cycode report sbom --format spdx-2.3 --include-vulnerabilities --include-dev-dependencies repository_url https://github.com/cycodehq/cycode-cli.git

โปรเจกต์ภายใน

เพื่อสร้างรายงาน SBOM สำหรับพาธ:
cycode report sbom --format <sbom format> --include-vulnerabilities --include-dev-dependencies --output-file </path/to/file> path </path/to/project>

ตัวอย่างเช่น:
cycode report sbom --format spdx-2.3 --include-vulnerabilities --include-dev-dependencies path /path/to/local/project

คำสั่งย่อย path รองรับตัวเลือกเพิ่มเติมต่อไปนี้:

ตัวเลือก	คำอธิบาย
`--no-restore`	ข้ามการกู้คืนไฟล์ล็อกและสแกนเฉพาะดีเพนเดนซีโดยตรง ดูรายละเอียดที่ ตัวเลือกการกู้คืนล็อก
`--gradle-all-sub-projects`	รันคำสั่งกู้คืน Gradle สำหรับโปรเจกต์ย่อยทั้งหมด (ใช้จากรูทของบิลด์ Gradle หลายโปรเจกต์)
`--maven-settings-file`	สำหรับ Maven เท่านั้น อนุญาตให้ใช้ไฟล์ settings.xml แบบกำหนดเองเมื่อสร้างแผนภูมิดีเพนเดนซี

คำสั่ง Import

การนำเข้า SBOM

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

ตัวเลือกต่อไปนี้พร้อมใช้งานสำหรับคำสั่งนี้:

ตัวเลือก	คำอธิบาย	จำเป็น	ค่าเริ่มต้น
`-n, --name TEXT`	ชื่อที่แสดงของ SBOM	ใช่
`-v, --vendor TEXT`	ชื่อของเอนทิตีที่ให้ SBOM	ใช่
`-l, --label TEXT`	แนบป้ายกำกับไปยัง SBOM	ไม่
`-o, --owner TEXT`	ที่อยู่อีเมลของผู้ใช้ Cycode ที่ทำหน้าที่เป็นผู้ติดต่อสำหรับ SBOM นี้	ไม่
`-b, --business-impact [High \| Medium \| Low]`	ผลกระทบทางธุรกิจ	ไม่	ปานกลาง

ตัวอย่างเช่น:
cycode import sbom --name example-sbom --vendor cycode -label tag1 -label tag2 --owner example@cycode.com /path/to/local/project

บันทึกการสแกน

การสแกน CLI ทั้งหมดจะถูกบันทึกใน Cycode สามารถดูบันทึกได้ภายใต้ การตั้งค่า > บันทึก CLI

วิธีใช้ไวยากรณ์

คุณสามารถเพิ่มอาร์กิวเมนต์ --help ไปยังคำสั่งใดๆ ได้ตลอดเวลาเพื่อดูข้อความช่วยเหลือที่จะแสดงตัวเลือกที่มีอยู่และไวยากรณ์ของตัวเลือกเหล่านั้น

หากต้องการดูความช่วยเหลือทั่วไป เพียงป้อนคำสั่ง:

cycode --help

หากต้องการดูตัวเลือกการสแกน ให้ป้อน:

cycode scan --help

หากต้องการดูตัวเลือกที่มีสำหรับประเภทการสแกนเฉพาะ ให้ป้อน:

cycode scan {{option}} --help

ตัวอย่างเช่น หากต้องการดูตัวเลือกที่มีสำหรับการสแกนเส้นทาง คุณจะต้องป้อน:

cycode scan path --help

หากต้องการดูตัวเลือกที่มีสำหรับฟังก์ชันละเว้นการสแกน ให้ใช้คำสั่งนี้:

cycode ignore --help

หากต้องการดูตัวเลือกที่มีสำหรับรายงาน ให้ใช้คำสั่งนี้:

cycode report --help

หากต้องการดูตัวเลือกที่มีสำหรับประเภทรายงานเฉพาะ ให้ป้อน:

cycode scan {{option}} --help