Cycode

ทางการ

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

GitHub

100

ลองใช้ MCP นี้ผู้สนับสนุน

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

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

เอกสาร

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

Cycode Command Line Interface (CLI) เป็นแอปพลิเคชันที่คุณสามารถติดตั้งในเครื่องของคุณเพื่อสแกน repositories เพื่อหาความลับ (secrets), การตั้งค่าโครงสร้างพื้นฐานเป็นโค้ดที่ผิดพลาด (infrastructure as code misconfigurations), ช่องโหว่จากการวิเคราะห์องค์ประกอบซอฟต์แวร์ (software composition analysis vulnerabilities), และปัญหาด้านการทดสอบความปลอดภัยของแอปพลิเคชันแบบสถิต (static application security testing issues)

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

สารบัญ

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

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

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

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

Successfully logged into cycode

ใช้คำสั่ง Configure

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

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

ติดตั้ง Pre-Commit Hook

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

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

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

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

ติดตั้งเฟรมเวิร์ก pre-commit (ต้องติดตั้ง Python 3.9 หรือสูงกว่า):
```
pip3 install pre-commit
```
นำทางไปยังไดเรกทอรีบนสุดของ Git repository ในเครื่องที่คุณต้องการกำหนดค่า
สร้างไฟล์ YAML ใหม่ชื่อ .pre-commit-config.yaml (รวม . ต้นด้วย) ในไดเรกทอรีบนสุดของ repository ที่มีเนื้อหาดังต่อไปนี้:
```
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`	ติดตั้ง completion สำหรับเชลล์ปัจจุบัน
`--show-completion [bash\|zsh\|fish\|powershell\|pwsh]`	แสดง completion สำหรับเชลล์ที่ระบุ เพื่อคัดลอกหรือปรับแต่งการติดตั้ง
`-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 และออกจากระบบ

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

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

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

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

export CYCODE_CLI_ENABLE_TRUSTSTORE=1

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

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

ตัวเลือก 2 — ชี้ CLI ไปยังไฟล์ชุด CA ทำงานได้โดยไม่ต้องเลือกใช้:

ตัวแปรสภาพแวดล้อม	คำอธิบาย
`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

หมายเหตุ:

CYCODE_CLI_ENABLE_TRUSTSTORE ต้องใช้ Python 3.10 หรือใหม่กว่า บน Python 3.9 CLI จะบันทึกคำเตือน และย้อนกลับไปใช้ชุด CA ที่มาพร้อมกับโปรแกรม ใช้ REQUESTS_CA_BUNDLE แทน หรืออัปเกรด Python โปรแกรมแบบสแตนด์อโลนและอิมเมจ Docker มาพร้อมกับ Python ที่รองรับอยู่แล้ว
บน Windows CLI จะย้อนกลับไปใช้ที่เก็บใบรับรองของระบบเสมอเมื่อไม่ได้ตั้งค่า REQUESTS_CA_BUNDLE หรือ CURL_CA_BUNDLE พฤติกรรมนั้นไม่เปลี่ยนแปลง
พร็อกซีเองถูกกำหนดค่าด้วยตัวแปรสภาพแวดล้อมมาตรฐาน HTTP_PROXY, HTTPS_PROXY และ NO_PROXY

คำสั่ง MCP [EXPERIMENT]

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

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

[!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 ด้วยการขนส่ง HTTP ที่สตรีมได้บนโฮสต์และพอร์ตที่กำหนดเอง:

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

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

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

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

[!NOTE] สำหรับสภาพแวดล้อม Cycode ในสหภาพยุโรป ตรวจสอบให้แน่ใจว่าได้ตั้งค่าค่า 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"
    }
  }
}

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

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

หากการสแกนที่ใช้เวลานานถูกตัดสั้นโดยไคลเอนต์ 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

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

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

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

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

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

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

cycode -v mcp

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

CYCODE_CLI_VERBOSE=1 cycode mcp

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

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

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

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

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

คำสั่งแพลตฟอร์ม [BETA]

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

คำสั่ง cycode platform เปิดเผย read APIs ของแพลตฟอร์ม Cycode เป็นคำสั่ง CLI โดยจัดกลุ่ม endpoints ตามทรัพยากร (เช่น projects, violations, workflows) และแปลงพารามิเตอร์ของแต่ละ endpoint เป็นอาร์กิวเมนต์ 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'

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

อ่านอย่างเดียวในตอนนี้ มีเพียง endpoints GET เท่านั้นที่เปิดเผยในเบต้านี้
ขับเคลื่อนด้วยสเปก การเพิ่ม endpoint ใหม่ให้กับ 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 จะถูกส่งไปยัง tenant Cycode ของคุณเพื่อตรวจสอบหาความลับ

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

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

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

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

คำสั่งสแกน

การรันการสแกน

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

คำสั่ง	คำอธิบาย
commit-history	สแกนประวัติ commit หรือทำ diff scanning ระหว่าง commit ที่เฉพาะเจาะจง
path	สแกนไฟล์ใน path ที่ระบุในคำสั่ง
pre-commit	ใช้คำสั่งนี้เพื่อสแกนเนื้อหาที่ยังไม่ได้ commit
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 Report

สำหรับการสแกนทุกครั้งที่ใช้ 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 เท่านั้น

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

ในตัวอย่างก่อนหน้านี้ หากคุณต้องการสแกนเฉพาะสาขาที่ชื่อ 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

ตัวเลือก Lock Restore

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

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

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

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

หากมีไฟล์ล็อกอยู่แล้วพร้อมกับ manifest Cycode จะอ่านโดยตรงโดยไม่รันคำสั่งติดตั้งใดๆ

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

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

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

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

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

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

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

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

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

การสแกน Repository

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

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

cycode scan repository {{path}}

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

cycode scan repository ~/home/git/codebase

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

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

ตัวเลือกสาขา

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

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

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

การสแกนเส้นทาง

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

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

cycode scan path {{path}}

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

cycode scan path ~/home/git/codebase

การสแกนแผน Terraform

Cycode 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

การสแกนประวัติ Commit

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

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

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

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

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

ในการดำเนินการสแกนประวัติ commit ให้ดำเนินการดังต่อไปนี้:

cycode scan commit-history {{path}}

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

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

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

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

ตัวเลือกช่วง Commit (การสแกนแบบ Diff)

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

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

ไวยากรณ์ช่วง Commit

ตัวเลือก --commit-range (-r) รองรับไวยากรณ์การแก้ไข 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

สแกนการเปลี่ยนแปลงใน commit ล่าสุด:

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

สแกนการเปลี่ยนแปลงระหว่าง commit เฉพาะสอง commit:

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

สแกนการเปลี่ยนแปลงในสาขาฟีเจอร์ของคุณเมื่อเทียบกับ main:

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

สแกนการเปลี่ยนแปลงระหว่าง main และสาขาฟีเจอร์:

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

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

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

การสแกนก่อน Commit

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

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

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

การสแกนก่อน Push

การสแกนก่อน push จะระบุปัญหาใด ๆ โดยอัตโนมัติก่อนที่คุณจะ push การเปลี่ยนแปลงไปยัง repository ระยะไกล hook นี้ทำงานบนฝั่งไคลเอ็นต์และสแกนเฉพาะ commit ที่กำลังจะถูก 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.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
```

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

pre-push hook:

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

การตรวจจับสาขาเริ่มต้นอัจฉริยะ

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

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

การตั้งค่าสาขาเริ่มต้นที่กำหนดเอง:

export CYCODE_DEFAULT_BRANCH=origin/develop

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

การข้ามการสแกนก่อน Push

ในการข้ามการสแกนก่อน push สำหรับการดำเนินการ push เฉพาะ ให้ใช้:

SKIP=cycode-pre-push git push

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

git push --no-verify

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

การยกเว้นเส้นทางจากการสแกน

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

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

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

[!WARNING]

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

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

Scanner ที่รองรับ

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 จะส่งคืนรหัสออกของ 1 เมื่อพบปัญหาในผลการสแกน ขึ้นอยู่กับการตั้งค่า CI/CD ของคุณ โดยปกติจะส่งผลให้เกิดความล้มเหลวโดยรวม หากคุณไม่ต้องการให้สิ่งนี้เกิดขึ้น คุณสามารถใช้คุณสมบัติ soft fail ได้

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

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

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

ตัวเลือก	คำอธิบาย
`--by-value TEXT`	ละเว้นค่าเฉพาะขณะสแกนหาความลับ ดู การละเว้นค่าความลับ สำหรับรายละเอียดเพิ่มเติม
`--by-sha TEXT`	ละเว้นค่า SHA512 เฉพาะของสตริงขณะสแกนหาความลับ ดู การละเว้นค่า SHA ของความลับ สำหรับรายละเอียดเพิ่มเติม
`--by-path TEXT`	หลีกเลี่ยงการสแกนพาธเฉพาะ ต้องระบุประเภทการสแกน ดู การละเว้นพาธ สำหรับรายละเอียดเพิ่มเติม
`--by-rule TEXT`	ละเว้นการสแกน ID กฎ secret/IaC/SCA เฉพาะ ดู การละเว้นกฎ Secret หรือ 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 ของความลับของคุณ

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

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

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

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

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 ด้วยค่าพาธของคุณ

การละเว้นกฎ Secret, IaC, SCA หรือ SAST

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

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

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

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 ไฟล์นี้สามารถแชร์ระหว่างนักพัฒนาได้ง่ายหรือแม้แต่คอมมิตไปยัง 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, โดยที่ ~ หมายถึงผู้ใช้s 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

คำสั่งรายงาน

การสร้างรายงาน 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`	ข้ามการกู้คืนไฟล์ล็อกและสแกนเฉพาะ dependencies โดยตรงเท่านั้น ดู ตัวเลือกการกู้คืนล็อก สำหรับรายละเอียด
`--gradle-all-sub-projects`	รันคำสั่ง Gradle restore สำหรับทุก sub-project (ใช้จาก root ของโปรเจกต์ Gradle แบบ multi-project)
`--maven-settings-file`	สำหรับ Maven เท่านั้น อนุญาตให้ใช้ไฟล์ settings.xml ที่กำหนดเองเมื่อสร้าง dependency tree

คำสั่ง Import

การนำเข้า SBOM

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

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

ตัวเลือก	คำอธิบาย	จำเป็น	ค่าเริ่มต้น
`-n, --name TEXT`	ชื่อที่แสดงของ SBOM	ใช่
`-v, --vendor TEXT`	ชื่อของหน่วยงานที่ให้ SBOM	ใช่
`-l, --label TEXT`	แนบ label กับ 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

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

cycode scan path --help

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

cycode ignore --help

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

cycode report --help

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

cycode scan {{option}} --help