Cycode

ทางการ

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

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

สแกนหาความลับ — ขอให้ผู้ช่วยสแกนไฟล์หรือไดเรกทอรีเพื่อค้นหาความลับที่ฝังไว้ในโค้ดโดยใช้ cycode_secret_scan
สแกนหาปัญหา SCA — ขอให้สแกน Software Composition Analysis เพื่อค้นหาช่องโหว่และปัญหาด้านใบอนุญาตผ่าน cycode_sca_scan
สแกนหาการกำหนดค่า IaC ที่ไม่ถูกต้อง — ให้ผู้ช่วยตรวจสอบโครงสร้างพื้นฐานในรูปแบบโค้ดเพื่อค้นหาการกำหนดค่าที่ไม่ถูกต้องด้วย cycode_iac_scan
สแกนหาปัญหา SAST — เรียกใช้การสแกน Static Application Security Testing เพื่อค้นหาปัญหาด้านคุณภาพโค้ดและข้อบกพร่องด้านความปลอดภัยโดยใช้ cycode_sast_scan
ตรวจสอบสถานะ CLI — ขอเวอร์ชัน Cycode CLI สถานะการยืนยันตัวตน และรายละเอียดการกำหนดค่าผ่าน cycode_status

เอกสาร

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

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

คู่มือนี้จะแนะนำทั้งการติดตั้งและการใช้งาน

สารบัญ

ข้อกำหนดเบื้องต้น
การติดตั้ง
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.10 ขึ้นไป
ใช้คำสั่ง 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 ในเครื่องของคุณ:

เปิดแอปพลิเคชันบรรทัดคำสั่งหรือเทอร์มินัล
เรียกใช้คำสั่งใดคำสั่งหนึ่งต่อไปนี้:
- หากต้องการติดตั้งจาก 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

พิมพ์คำสั่งต่อไปนี้ในหน้าต่างเทอร์มินัล/บรรทัดคำสั่ง:

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

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

Successfully logged into cycode

ใช้คำสั่ง Configure

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

พิมพ์คำสั่งต่อไปนี้ในหน้าต่างเทอร์มินัล/บรรทัดคำสั่ง:
```
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 ลงใน path เพื่อให้การติดตั้งเสร็จสมบูรณ์

ติดตั้ง Pre-Commit Hook

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

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

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

ติดตั้ง Pre-Commit Hook

ติดตั้งเฟรมเวิร์ก pre-commit (ต้องติดตั้ง Python 3.10 ขึ้นไป):
```
pip3 install pre-commit
```
ไปยังไดเรกทอรีระดับบนสุดของที่เก็บ Git ในเครื่องที่คุณต้องการกำหนดค่า
สร้างไฟล์ YAML ใหม่ชื่อ .pre-commit-config.yaml (รวม . ที่อยู่ต้นไฟล์) ในไดเรกทอรีระดับบนสุดของที่เก็บ โดยให้มีเนื้อหาต่อไปนี้:
```
repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.25.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.25.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] Hook จะทำงานเมื่อใช้คำสั่ง git commit Hook จะทำงานเฉพาะกับไฟล์ที่จัดเตรียมไว้สำหรับ commit เท่านั้น

ติดตั้ง Pre-Push Hook

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

เพิ่ม pre-push hook ลงในไฟล์ .pre-commit-config.yaml:

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

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

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

หากใช้ทั้ง pre-commit และ pre-push hook ให้ใช้:
```
pre-commit install
pre-commit install --hook-type pre-push
```

[!NOTE] Pre-push hook จะทำงานเมื่อใช้คำสั่ง git push และสแกนเฉพาะ commit ที่กำลังจะ 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	ละเว้นค่า เส้นทาง หรือ ID กฎที่ระบุ
mcp	เริ่มเซิร์ฟเวอร์ Model Context Protocol (MCP) เพื่อเปิดใช้การผสานรวม AI กับความสามารถในการสแกนของ Cycode
scan	สแกนเนื้อหาเพื่อหาการละเมิด Secrets/IaC/SCA/SAST คุณ`จะต้องระบุประเภทการสแกนที่ต้องการดำเนินการ เช่น commit-history/path/repository เป็นต้น
report	สร้างรายงาน คุณจะต้องระบุประเภทของรายงานที่ต้องการสร้าง เช่น SBOM
status	แสดงสถานะ CLI แล้วออก

ใบรับรองและพร็อกซี

โดยค่าเริ่มต้น Cycode CLI จะตรวจสอบการเชื่อมต่อ HTTPS โดยใช้ชุด CA ที่มาพร้อมกับ CLI

หากองค์กรของคุณใช้พร็อกซีที่ตรวจสอบการรับส่งข้อมูล HTTPS หรือใช้การติดตั้งภายในองค์กรที่มี CA ของตนเอง คุณมีสองตัวเลือก

ตัวเลือก 1 — ใช้ใบรับรองที่ติดตั้งไว้ในเครื่องอยู่แล้ว หาก CA ของคุณอยู่ในที่เก็บใบรับรองของเครื่อง (ซึ่งมักเป็นกรณีของอุปกรณ์ที่มีการจัดการ) ให้เลือกเปิดใช้:

export CYCODE_CLI_ENABLE_TRUSTSTORE=1

จากนั้น CLI จะตรวจสอบกับที่เก็บใบรับรอง Windows, Keychain ของ macOS หรือไดเรกทอรี CA ของระบบบน Linux โดยไม่จำเป็นต้องกำหนดค่าเส้นทางใบรับรอง

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

ตัวเลือก 2 — ระบุไฟล์ชุด CA ให้ CLI ใช้งานได้โดยไม่ต้องเลือกเปิดใช้:

ตัวแปรสภาพแวดล้อม	คำอธิบาย
`REQUESTS_CA_BUNDLE`	เส้นทางไปยังไฟล์ชุด CA (`.pem` หรือ `.crt`) ที่ต้องการเชื่อถือ
`CURL_CA_BUNDLE`	ชื่อแทนของ `REQUESTS_CA_BUNDLE` ซึ่งจะใช้เมื่อไม่ได้กำหนดตัวแปรหลัง

ใช้สองตัวเลือกร่วมกันได้: เมื่อใช้ CYCODE_CLI_ENABLE_TRUSTSTORE=1 ใบรับรองจาก REQUESTS_CA_BUNDLE จะได้รับความเชื่อถือ เพิ่มเติมจาก ที่เก็บใบรับรองของเครื่อง ไม่ใช่ใช้แทนที่

[!TIP] เรียกใช้คำสั่งใดก็ได้พร้อม -v เพื่อดูแหล่งที่มาของการเชื่อถือที่กำลังใช้งาน เช่น cycode -v status

หมายเหตุ:

บน Windows CLI จะใช้ที่เก็บใบรับรองของระบบเป็นทางเลือกสำรองเสมอ เมื่อไม่ได้กำหนดทั้ง REQUESTS_CA_BUNDLE และ CURL_CA_BUNDLE พฤติกรรมนี้ยังคงเหมือนเดิม
กำหนดค่าพร็อกซีด้วยตัวแปรสภาพแวดล้อมมาตรฐาน HTTP_PROXY, HTTPS_PROXY และ NO_PROXY

คำสั่ง MCP [EXPERIMENT]

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

[!TIP] เพื่อประสบการณ์ใช้งานที่ดีที่สุด ให้ติดตั้ง Cycode CLI แบบส่วนกลางในระบบของคุณโดยใช้ pip install cycode หรือ brew install cycode จากนั้นยืนยันตัวตนเพียงครั้งเดียวด้วย cycode auth หลังจากติดตั้งและยืนยันตัวตนแบบส่วนกลางแล้ว คุณไม่จำเป็นต้องกำหนดค่าตัวแปรสภาพแวดล้อม 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`	สแกนหาข้อมูลลับที่ฝังไว้ในโค้ด
`cycode_sca_scan`	สแกนหา Software Composition Analysis (SCA) — ช่องโหว่และปัญหาเกี่ยวกับใบอนุญาต
`cycode_iac_scan`	สแกนหาการกำหนดค่าผิดพลาดของ Infrastructure as Code (IaC)
`cycode_sast_scan`	สแกนหา Static Application Security Testing (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 ด้วยการขนส่ง streamable HTTP โดยกำหนดโฮสต์และพอร์ตเอง:

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

ดูข้อมูลเพิ่มเติมเกี่ยวกับประเภทการขนส่ง MCP ได้ที่ ข้อกำหนดโปรโตคอล MCP – การขนส่ง

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

การใช้ 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"
    }
  }
}

สำหรับ การขนส่ง streamable 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"
    }
  }
}

สำหรับ การขนส่ง streamable 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"
    }
  }
}

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

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

หากไคลเอ็นต์ MCP ของคุณยุติการสแกนที่ใช้เวลานานก่อนเสร็จสิ้น ให้เพิ่มเวลาหมดเวลาของการเรียกใช้เครื่องมือ

ตัวแปรสภาพแวดล้อม คำอธิบาย

MCP_TOOL_TIMEOUT เวลาหมดเวลา (เป็นวินาที) ที่ไคลเอ็นต์ MCP เช่น Claude และ GitHub Copilot รอให้การเรียกใช้เครื่องมือเสร็จสิ้น เพิ่มค่านี้หากการสแกนที่ใช้เวลานานถูกยุติก่อนเสร็จสิ้น

ตัวแปรสภาพแวดล้อม	คำอธิบาย
`MCP_TOOL_TIMEOUT`	เวลาหมดเวลา (เป็นวินาที) ที่ไคลเอ็นต์ MCP เช่น Claude และ GitHub Copilot รอให้การเรียกใช้เครื่องมือเสร็จสิ้น เพิ่มค่านี้หากการสแกนที่ใช้เวลานานถูกยุติก่อนเสร็จสิ้น

เมื่ออยู่หลังพร็อกซีขององค์กร ให้กำหนดตัวแปรใบรับรองในบล็อก env ของเซิร์ฟเวอร์ MCP ดูตัวเลือกได้ที่ ใบรับรองและพร็อกซี: ใช้ CYCODE_CLI_ENABLE_TRUSTSTORE=1 เพื่อใช้ใบรับรองที่มีอยู่ในเครื่อง หรือ ใช้ REQUESTS_CA_BUNDLE เพื่อระบุไฟล์ชุด CA

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

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

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

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

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

หากต้องการอนุญาตเครื่องมือ MCP ของ Cycode ล่วงหน้าเพื่อให้ทำงานได้ในทุกบริบท รวมถึง subagent ให้เพิ่มเครื่องมือเหล่านั้นลงในรายการ 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 จะไม่ขออนุมัติเมื่อมีการเรียกใช้เครื่องมือเหล่านี้ และเครื่องมือจะทำงานได้อย่างถูกต้องภายใน subagent

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

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

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

cycode -v mcp

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

CYCODE_CLI_VERBOSE=1 cycode mcp

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

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

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

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

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

คำสั่ง Platform [BETA]

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

คำสั่ง 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

ตัวอย่างแพลตฟอร์ม

# 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'

หมายเหตุและข้อจำกัดของแพลตฟอร์ม

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

AI Guardrails [BETA]

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

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

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

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

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

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

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

คำสั่ง 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`/`unmaintained-packages`/`malicious-packages`) ค่าเริ่มต้นคือทั้งหมด
`--monitor`	เมื่อระบุไว้ ระบบจะบันทึกผลการสแกนใน Cycode
`--cycode-report`	แสดงลิงก์ไปยังรายงานการสแกนบนแพลตฟอร์ม Cycode ในเอาต์พุตของคอนโซล
`--no-restore`	เมื่อระบุไว้ Cycode จะไม่เรียกใช้คำสั่ง restore การดำเนินการนี้จะสแกนเฉพาะ dependency โดยตรงเท่านั้น!
`--stop-on-error`	ยกเลิกการสแกนหากเกิดข้อผิดพลาดในการรวบรวมไฟล์หรือกู้คืน dependency แทนที่จะข้ามไฟล์ที่ล้มเหลวแล้วดำเนินการต่อ
`--gradle-all-sub-projects`	เรียกใช้คำสั่ง gradle restore สำหรับทุกโปรเจกต์ย่อย ควรเรียกใช้จาก
`--maven-settings-file`	สำหรับ Maven เท่านั้น อนุญาตให้ใช้ไฟล์ settings.xml ที่กำหนดเองเมื่อสแกนหา dependency
`--help`	แสดงตัวเลือกสำหรับคำสั่งที่ระบุ

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

ตัวเลือก

ตัวเลือกระดับความรุนแรง

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

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

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

ตัวเลือก Monitor

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

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

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

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

ตัวเลือกรายงาน Cycode

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

หากต้องการให้พิมพ์ URL โดยตรงของรายงาน Cycode ในเอาต์พุต CLI หลังการสแกนเสร็จสิ้น ให้เพิ่มอาร์กิวเมนต์ --cycode-report ลงในคำสั่งสแกน

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

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

[!WARNING] คุณต้องมีบทบาท owner หรือ admin ใน Cycode จึงจะดูหน้านี้ได้

cli-report

หน้ารายงานจะมีลักษณะดังตัวอย่างด้านล่าง:

ตัวเลือกช่องโหว่ของแพ็กเกจ

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

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

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

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

ตัวเลือกการปฏิบัติตามข้อกำหนดด้านไลเซนส์

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

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

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

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

ตัวเลือกแพ็กเกจที่ไม่มีการบำรุงรักษา

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

หากต้องการสแกนเฉพาะแพ็กเกจที่ไม่มีการบำรุงรักษา (แพ็กเกจที่มีการตรวจสอบ OpenSSF Scorecard Maintained ในระดับต่ำ ซึ่งหมายถึงแทบไม่มีหรือไม่มีการ commit และกิจกรรมเกี่ยวกับ issue เมื่อไม่นานมานี้) ให้เพิ่มอาร์กิวเมนต์ --sca-scan unmaintained-packages ต่อท้ายตัวเลือก -t sca หรือ --scan-type sca

[!NOTE] นโยบายขององค์กรเป็นตัวกำหนดว่าจะรายงานแพ็กเกจที่ไม่มีการบำรุงรักษาหรือไม่ ตัวเลือกนี้จำกัดขอบเขตสิ่งที่การสแกนรายงาน แต่ไม่สามารถเปิดใช้นโยบายที่ปิดอยู่สำหรับ tenant ของคุณได้

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

cycode scan -t sca --sca-scan unmaintained-packages repository ~/home/git/codebase

ตัวเลือกแพ็กเกจที่เป็นอันตราย

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

หากต้องการสแกนเฉพาะแพ็กเกจที่เป็นอันตราย (dependency ที่ประกาศเตือนด้านความปลอดภัยระบุว่าเป็นมัลแวร์ ไม่ใช่เพียงมีช่องโหว่) ให้เพิ่มอาร์กิวเมนต์ --sca-scan malicious-packages ต่อท้ายตัวเลือก -t sca หรือ --scan-type sca

การละเมิดที่เกี่ยวข้องกับแพ็กเกจที่เป็นอันตรายจะถูกรายงานเป็น Critical เสมอ และไม่มีคะแนน CVSS หรือเวอร์ชันที่แก้ไขได้ วิธีแก้ไขเพียงอย่างเดียวคือการนำ dependency ออก

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

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

cycode scan -t sca --sca-scan malicious-packages repository ~/home/git/codebase

ตัวเลือกการกู้คืน Lock

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

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

ระบบนิเวศต่อไปนี้รองรับการกู้คืนไฟล์ lock โดยอัตโนมัติ:

ระบบนิเวศ	ไฟล์ Manifest	ไฟล์ Lock ที่สร้างขึ้น	เครื่องมือที่เรียกใช้ (เมื่อไม่มีไฟล์ Lock)
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`	(อ่านเฉพาะไฟล์ Lock ที่มีอยู่)
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`

หากมีไฟล์ Lock อยู่แล้วในตำแหน่งเดียวกับ manifest Cycode จะอ่านไฟล์นั้นโดยตรงโดยไม่เรียกใช้คำสั่งติดตั้ง ข้อกำหนดเบื้องต้นของ SBT: ต้องติดตั้งปลั๊กอิน sbt-dependency-lock เพิ่มบรรทัดต่อไปนี้ใน project/plugins.sbt:

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

ตัวเลือกหยุดเมื่อเกิดข้อผิดพลาด

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

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

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

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

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

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

การสแกน Repository

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

หากต้องการสแกน repository ทั้งหมด ให้เรียกใช้คำสั่งต่อไปนี้:

cycode scan repository {{path}}

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

cycode scan repository ~/home/git/codebase

ตัวเลือกต่อไปนี้ใช้กับคำสั่งนี้ได้:

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

ตัวเลือก Branch

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

จากตัวอย่างก่อนหน้า หากต้องการสแกนเฉพาะ branch ชื่อ dev ให้เรียกใช้คำสั่งต่อไปนี้:

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

การสแกน Path

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

หากต้องการสแกนไดเรกทอรี ให้เรียกใช้คำสั่งต่อไปนี้:

cycode scan path {{path}}

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

cycode scan path ~/home/git/codebase

การสแกน Terraform Plan

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

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

หากคุณมีเพียงไฟล์การกำหนดค่า คุณสามารถสร้าง plan ได้ดังนี้:

เริ่มต้นไดเรกทอรีทำงานที่มีไฟล์การกำหนดค่า 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

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

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

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

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

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

cycode scan commit-history {{path}}

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

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

ตัวเลือกต่อไปนี้ใช้กับคำสั่งนี้ได้:

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

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

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

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

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

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

ไวยากรณ์	คำอธิบาย	ตัวอย่าง
`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`

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

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

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 คุณสามารถใช้ตัวแปรสภาพแวดล้อม เช่น ${{ 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

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

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

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

ตัวเลือกต่อไปนี้ใช้กับคำสั่งนี้ได้:

ตัวเลือก	คำอธิบาย
`-b, --base-ref TEXT`	Git ref (คอมมิต, branch หรือ tag) ที่ใช้เปรียบเทียบ diff; ค่าเริ่มต้นคือ `HEAD` ซึ่งตรงกับลักษณะการทำงานของ pre-commit hook
`--include-unstaged`	สแกนการเปลี่ยนแปลงของไฟล์ที่ติดตามซึ่งยังไม่ได้ stage ด้วย ไม่ใช่เฉพาะสิ่งที่ stage ไว้; ปิดใช้งานโดยค่าเริ่มต้น
`--path PATH`	path ที่ไม่บังคับสำหรับจำกัดขอบเขตการสแกน diff; ระบุซ้ำได้; ค่าเริ่มต้นคือไดเรกทอรีทำงานทั้งหมด

การสแกน Local Diff (การผสานรวม IDE)

--base-ref และ --include-unstaged เปลี่ยน pre-commit ให้เป็น การสแกน local diff แบบใช้งานทั่วไป: เปรียบเทียบคอมมิตใดก็ได้ (ค่าเริ่มต้นคือ HEAD) กับไดเรกทอรีทำงานปัจจุบันของคุณ รวมถึงการแก้ไขที่ยังไม่ได้ stage ด้วย ฟังก์ชันนี้มีไว้สำหรับปลั๊กอิน IDE และเครื่องมืออื่น ๆ ที่ต้องการให้ผลตอบกลับอย่างต่อเนื่องและทันทีขณะทำงาน แทนที่จะใช้ขั้นตอนการทำงานของ git hook เมื่อใช้ร่วมกับ --include-unstaged แล้ว --path จะช่วยให้ IDE จำกัดการสแกนไว้เฉพาะไฟล์ที่เปิดอยู่ในตัวแก้ไขได้

[!NOTE] การสแกน local diff (ผ่านแฟล็กเหล่านี้) ไม่พร้อมใช้งานสำหรับการสแกน IaC

สแกนทุกสิ่งที่มีการเปลี่ยนแปลงในขณะนี้ (ทั้งที่ stage และยังไม่ stage) โดยเทียบกับคอมมิตล่าสุด:

cycode scan pre-commit --include-unstaged

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

cycode scan pre-commit --include-unstaged --base-ref main

สแกนเฉพาะไฟล์ที่ระบุ (เช่น ไฟล์ที่เปิดอยู่ใน IDE):

cycode scan pre-commit --include-unstaged --path src/app.py

การสแกน Pre-Push

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

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

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

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

หากต้องการตั้งค่า pre-push hook โดยใช้เฟรมเวิร์ก pre-commit:

ติดตั้งเฟรมเวิร์ก pre-commit (หากยังไม่ได้ติดตั้ง):
```
pip3 install pre-commit
```

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

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

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

repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.25.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 จะสแกนทุกคอมมิตที่กำลัง push ทีละคอมมิต ดังนั้นความลับที่เพิ่มเข้ามาในคอมมิตหนึ่งและถูกลบออกในคอมมิตถัดไปก็ยังตรวจพบได้ เมื่อติดตั้งผ่านเฟรมเวิร์ก pre-commit ช่วงที่ push จะถูกกำหนดโดยเฟรมเวิร์ก: สำหรับ branch ที่มีอยู่ จะใช้คอมมิตใหม่ตั้งแต่ branch ระยะไกล และสำหรับ branch ใหม่ จะใช้คอมมิตที่ยังไม่มีในระยะไกล (คอมมิตทั้งหมดเมื่อ push ไปยัง remote ที่ว่างเปล่า) เมื่อเรียกใช้จาก .git/hooks/pre-push ที่เขียนขึ้นเอง ช่วงจะอ่านจากอินพุต hook ของ git และสำหรับ branch ใหม่จะสแกนตั้งแต่ merge base กับ branch เริ่มต้น (ดูด้านล่าง)

การ push ที่ไม่มีสิ่งให้สแกน เช่น tag การลบ branch และการ push ที่เป็นปัจจุบันอยู่แล้ว จะผ่านไปโดยไม่สแกน หาก hook ระบุสิ่งที่กำลัง push ไม่ได้ จะล้มเหลวและบล็อกการ push แทนที่จะผ่านไปโดยไม่แจ้งให้ทราบ

pre-push hooks ของ Cycode กำหนดค่า always_run: true และ pass_filenames: false เนื่องจากการสแกนครอบคลุมคอมมิตที่กำลัง push ไม่ใช่รายการไฟล์ หากไม่มี always_run เฟรมเวิร์ก pre-commit จะข้าม hook เมื่อคอมมิตที่กำลัง push ไม่มีไฟล์ที่เปลี่ยนแปลงรวมกัน เช่น มีการเพิ่มความลับในคอมมิตหนึ่งและลบออกในคอมมิตถัดไป หากไม่มี pass_filenames: false เฟรมเวิร์กจะส่งชื่อไฟล์ที่เปลี่ยนแปลงซึ่งการสแกนไม่ได้ใช้ และเมื่อ push จำนวนมาก เฟรมเวิร์กจะแบ่งไฟล์เป็นชุด ๆ แล้วเรียกใช้การสแกนทั้งหมดหนึ่งครั้งต่อชุด หากคุณกำหนด hook เอง (เช่น เป็น hook แบบ repo: local) ให้ตั้งค่าทั้งสองตัวเลือก

การตรวจหา Branch เริ่มต้นอย่างชาญฉลาด

เมื่อเรียกใช้จาก hook ที่เขียนขึ้นเอง การสแกน pre-push จะตรวจหา branch เริ่มต้นสำหรับคำนวณ merge base ตามลำดับความสำคัญต่อไปนี้:

ตัวแปรสภาพแวดล้อม: CYCODE_DEFAULT_BRANCH - อนุญาตให้กำหนดค่าแทนด้วยตนเอง
Git Remote HEAD: ใช้ git symbolic-ref refs/remotes/origin/HEAD เพื่อตรวจหา branch เริ่มต้นจริงของ remote
ข้อมูล Git Remote: ใช้ git remote show origin เป็นทางเลือกสำรองหาก symbolic-ref ล้มเหลว
ค่า fallback ที่กำหนดไว้ตายตัว: ใช้ชื่อ branch เริ่มต้นที่พบบ่อย (origin/main, origin/master, main, master)

การกำหนด Branch เริ่มต้นแบบกำหนดเอง:

export CYCODE_DEFAULT_BRANCH=origin/develop

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

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

หากต้องการข้ามการสแกนก่อนพุชสำหรับการพุชครั้งใดครั้งหนึ่ง ให้ใช้:

SKIP=cycode-pre-push git push

หรือหากต้องการข้าม pre-push hook ทั้งหมด:

git push --no-verify

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

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

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

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

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

[!WARNING]

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

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

เครื่องมือสแกนที่รองรับ

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

ผลการสแกน

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

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

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

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

แสดง/ซ่อนข้อมูลลับ

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

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

หากต้องการปิดการปกปิดข้อมูลลับ ให้เพิ่มอาร์กิวเมนต์ --show-secret ในการสแกนทุกประเภท

ในตัวอย่างต่อไปนี้ มีการเรียกใช้ Path Scan กับไดเรกทอรีย่อย cli โดยเปิดตัวเลือกให้แสดงข้อมูลลับที่พบทั้งหมด:

cycode scan --show-secret path ./cli

ผลลัพธ์ที่ได้จะไม่ถูกปกปิด

Soft Fail

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

เมื่อเพิ่มตัวเลือก --soft-fail ในการสแกนทุกประเภท รหัสออกจะถูกกำหนดเป็น 0 ไม่ว่าจะพบผลลัพธ์ใดหรือไม่ก็ตาม

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

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

╭─────────────────────────────────────────────────────────────── 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 พาธ และ ID กฎของข้อมูลลับและ IaC ของ Cycode ที่ระบุได้ กฎเหล่านี้จะทำให้การสแกนไม่แจ้งเตือนค่าดังกล่าว กฎการละเว้นจะถูกเขียนและบันทึกไว้ในไฟล์ ./.cycode/config.yaml ในเครื่อง

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

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

ตัวเลือก	คำอธิบาย
`--by-value TEXT`	ละเว้นค่าที่ระบุเมื่อสแกนหาข้อมูลลับ ดูรายละเอียดเพิ่มเติมที่ การละเว้นค่าข้อมูลลับ
`--by-sha TEXT`	ละเว้นค่า SHA512 ที่แทนสตริงที่ระบุเมื่อสแกนหาข้อมูลลับ ดูรายละเอียดเพิ่มเติมที่ การละเว้นค่า SHA ของข้อมูลลับ
`--by-path TEXT`	หลีกเลี่ยงการสแกนพาธที่ระบุ ต้องระบุประเภทการสแกน ดูรายละเอียดเพิ่มเติมที่ การละเว้นพาธ
`--by-rule TEXT`	ละเว้นการสแกน ID กฎข้อมูลลับ/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 (ต้องระบุประเภทการสแกน) ซึ่งจะละเว้นค่า ID กฎดังกล่าวจากการสแกนทั้งหมดในอนาคต ใช้คำสั่งต่อไปนี้เพื่อเพิ่มค่า ID กฎที่ต้องการละเว้น:

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

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

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

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

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

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

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

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

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

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

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

[!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 คุณสามารถแชร์ไฟล์นี้ระหว่างนักพัฒนา หรือแม้แต่ commit ไฟล์ไปยัง 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 เป็นต้น)

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

กฎการละเว้นโครงสร้างใน config

สิ่งสำคัญคือต้องเข้าใจว่า 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 ของรีโพซิทอรี

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

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

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

Command	Description
`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 รองรับตัวเลือกเพิ่มเติมต่อไปนี้:

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

คำสั่ง Import

การนำเข้า SBOM

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

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

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

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

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

การสแกนทั้งหมดของ CLI จะถูกบันทึกใน Cycode คุณสามารถดูบันทึกได้ที่ Settings > CLI Logs

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

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

หากต้องการดูวิธีใช้ทั่วไป ให้ป้อนคำสั่ง:

cycode --help

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

cycode scan --help

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

cycode scan {{option}} --help

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

cycode scan path --help

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

cycode ignore --help

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

cycode report --help

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

cycode scan {{option}} --help