בעת ניהול פרויקטים של Go, עליך לעקוב אחר התמכרות, לבדוק פגיעות ולהבטיח תאימות רישיון.במקום להסתמך על כלים חיצוניים, בואו נבנה את אנליסט ההתמכרות שלנו באמצעות הספרייה הסטנדרטית של Go. מבנה הליבה אנו עובדים עם מודולים של Go, ולכן אנו זקוקים למבנים כדי לייצג אותם: package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"regexp"
	"sort"
	"strings"
	"time"
)

type Module struct {
	Path     string
	Version  string
	Indirect bool
}

type GoMod struct {
	Module   Module
	Requires []Module
}
 הכלי שלנו יטפל בשלוש פעולות: רשימת תלויות, סריקת פגיעות ובדיקת רישיונות. עקבו אחרי go.mod files הבנה של מבנה קובץ מודול הקובץ go.mod משתמש בפורמט מסוים שאנחנו צריכים לחקור כראוי. הצהרות מודול מתחילות עם מילת המפתח של המודול ולאחר מכן את נתיב המודול. אנו משתמשים בביטויים קבועים כדי לחלץ את נתיב המודול וגרסה מכל שורה, ולזהות תלויות עקיפות על ידי חיפוש הערה עקיפה // גישה זו נותנת לנו את אותה מידע שהרשימה הולכת תספק, אבל בלי להביא לתהליכים חיצוניים. במקום לירות על אנחנו יכולים לחלק את קובץ ישיר : go list go.mod func parseGoMod() (*GoMod, error) {
	file, err := os.Open("go.mod")
	if err != nil {
		return nil, fmt.Errorf("go.mod not found: %v", err)
	}
	defer file.Close()

	goMod := &GoMod{
		Requires: []Module{},
	}

	scanner := bufio.NewScanner(file)
	inRequire := false
	requireRegex := regexp.MustCompile(`^\s*([^\s]+)\s+([^\s]+)(?:\s+//\s*indirect)?`)
	moduleRegex := regexp.MustCompile(`^module\s+(.+)`)

	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())

		if strings.HasPrefix(line, "module ") {
			if matches := moduleRegex.FindStringSubmatch(line); len(matches) > 1 {
				goMod.Module = Module{Path: matches[1]}
			}
		}

		if strings.HasPrefix(line, "require (") {
			inRequire = true
			continue
		}

		if inRequire && line == ")" {
			inRequire = false
			continue
		}

		if inRequire || strings.HasPrefix(line, "require ") {
			cleanLine := strings.TrimPrefix(line, "require ")
			if matches := requireRegex.FindStringSubmatch(cleanLine); len(matches) >= 3 {
				module := Module{
					Path:     matches[1],
					Version:  matches[2],
					Indirect: strings.Contains(line, "indirect"),
				}
				goMod.Requires = append(goMod.Requires, module)
			}
		}
	}

	return goMod, scanner.Err()
}
 המפרט מתמודד עם בלוקים של דרישות קו יחיד ודרישות קו רב.הוא מוציא דרכים מודול, גירסאות ומזהה תלויות עקיפות. בקשות מסד הנתונים של פגיעות כיצד פועלת בדיקת פגיעות מסדי הנתונים של פגיעות שומרים על רשומות של בעיות אבטחה ידועות בחבילות תוכנה. לכל פגיעה מוקצים מזהים כגון מספרים CVE וכוללים פרטים על גירסאות מושפעות.התהליך פועל כך: אנו שולחים את שם החבילה ואת גירסה ל-API של מסד הנתונים, הוא בודק אם הגירסה הספציפית מכילה פגיעות ידועות ולאחר מכן מחזיר רשימה של בעיות אם נמצאו. מסד הנתונים של OSV הוא שימושי במיוחד משום שהוא אוסף נתוני פגיעות ממקורות מרובים ומספק API מאוחדת.כאשר אנו שואלים אותו, אנחנו בעצם שואלים "האם לגרסה המדויקת של חבילה זו יש בעיות אבטחה מדווחות?" אנו יכולים לבדוק את מסד הנתונים של OSV (הקוד פתוח) עבור בעיות ידועות: func checkOSVDatabase(modulePath, version string) []string {
	url := "https://api.osv.dev/v1/query"

	payload := map[string]interface{}{
		"package": map[string]string{
			"name":      modulePath,
			"ecosystem": "Go",
		},
		"version": version,
	}

	jsonData, err := json.Marshal(payload)
	if err != nil {
		return []string{}
	}

	client := &http.Client{Timeout: 10 * time.Second}
	resp, err := client.Post(url, "application/json", strings.NewReader(string(jsonData)))
	if err != nil {
		return []string{}
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return []string{}
	}

	var result struct {
		Vulns []struct {
			ID      string `json:"id"`
			Summary string `json:"summary"`
		} `json:"vulns"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return []string{}
	}

	var vulnerabilities []string
	for _, vuln := range result.Vulns {
		vulnStr := fmt.Sprintf("%s: %s", vuln.ID, vuln.Summary)
		vulnerabilities = append(vulnerabilities, vulnStr)
	}

	return vulnerabilities
}

func checkVulnerabilities() {
	goMod, err := parseGoMod()
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	vulnerableModules := 0

	for i, mod := range goMod.Requires {
		fmt.Printf("\rScanning %d/%d: %s", i+1, len(goMod.Requires), mod.Path)
		vulns := checkOSVDatabase(mod.Path, mod.Version)
		if len(vulns) > 0 {
			vulnerableModules++
			fmt.Printf("\n🚨 %s@%s:\n", mod.Path, mod.Version)
			for _, vuln := range vulns {
				fmt.Printf("  - %s\n", vuln)
			}
		}
	}

	if vulnerableModules == 0 {
		fmt.Println("\n✅ No known vulnerabilities found")
	} else {
		fmt.Printf("\n⚠️ Found %d vulnerable modules\n", vulnerableModules)
	}
}
 בדיקת הפגיעות שולחת משקל JSON עם שם המודול וגרסה, ולאחר מכן בודקת את התשובה לכל פגיעות שדווחו. איסוף מידע רישיון כיצד עובד רישיון זיהוי רוב פרויקטים קוד פתוחים כוללים קבצי רישיון במחסנים שלהם, ופלטפורמות כמו GitHub לנתח קבצים אלה כדי לזהות את סוג הרישיון באמצעות מזהים SPDX. הגישה שלנו מנצלת את API זיהוי הרישיונות של GitHub, אשר מנתח את התוכן של המאגר ומחזיר מזהה רישיון סטנדרטי. עבור מודולים מאוחסנים ב- GitHub, אנו מספקים את שם הבעלים ואת שם המאגר מן מסלול המודול, ולאחר מכן מבקשים את נקודת הסוף של API של GitHub המספקת מידע רישיון ספציפי. רישיונות שונים יש דרישות שונות, חלק כמו MIT הם מאוד מותר, בעוד אחרים כמו GPL יש דרישות copyleft אשר עשויים להשפיע על איך אתה יכול להפיץ את התוכנה שלך. עבור מודולים המארחים ב-GitHub, אנו יכולים לקבל נתוני רישיון מ-API שלהם: func fetchGitHubLicense(owner, repo string) string {
	url := fmt.Sprintf("https://api.github.com/repos/%s/%s/license", owner, repo)

	client := &http.Client{Timeout: 10 * time.Second}
	resp, err := client.Get(url)
	if err != nil {
		return "Unknown"
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return "Unknown"
	}

	var result struct {
		License struct {
			SPDXID string `json:"spdx_id"`
		} `json:"license"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return "Unknown"
	}

	if result.License.SPDXID != "" && result.License.SPDXID != "NOASSERTION" {
		return result.License.SPDXID
	}

	return "Unknown"
}

func fetchLicenseFromRepo(modulePath string) string {
	if strings.HasPrefix(modulePath, "golang.org/x/") {
		return "BSD-3-Clause"
	}

	if !strings.HasPrefix(modulePath, "github.com/") {
		return "Unknown"
	}

	parts := strings.Split(modulePath, "/")
	if len(parts) < 3 {
		return "Unknown"
	}

	return fetchGitHubLicense(parts[1], parts[2])
}

func checkLicenses() {
	goMod, err := parseGoMod()
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	licenseCount := make(map[string]int)

	for i, mod := range goMod.Requires {
		fmt.Printf("\rProcessing %d/%d...", i+1, len(goMod.Requires))
		license := fetchLicenseFromRepo(mod.Path)
		licenseCount[license]++
		fmt.Printf("\r  %s: %s\n", mod.Path, license)
	}

	fmt.Println("\nLicense Distribution:")
	for license, count := range licenseCount {
		percentage := float64(count) / float64(len(goMod.Requires)) * 100
		fmt.Printf("  %s: %d modules (%.1f%%)\n", license, count, percentage)
	}
}
 מנהל הרישיון מכיר בכך החבילות משתמשות ב- BSD-3-Clause, ולאחר מכן מבקשות את API של GitHub עבור מחירי אחסון אחרים. golang.org/x/ ניתוח תלות עם Verification Checksum אנליסט ההתמכרות מפרט מודולים ומבטיח את שלמותם באמצעות : go.sum func parseGoSum() map[string]string {
	checksums := make(map[string]string)

	file, err := os.Open("go.sum")
	if err != nil {
		return checksums
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		parts := strings.Fields(scanner.Text())
		if len(parts) >= 3 {
			module := parts[0] + "@" + parts[1]
			checksums[module] = parts[2]
		}
	}

	return checksums
}

func analyzeDependencies() {
	goMod, err := parseGoMod()
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	checksums := parseGoSum()

	fmt.Printf("Module: %s\n", goMod.Module.Path)
	fmt.Printf("Found %d dependencies:\n\n", len(goMod.Requires))

	direct, indirect := 0, 0

	sort.Slice(goMod.Requires, func(i, j int) bool {
		return goMod.Requires[i].Path < goMod.Requires[j].Path
	})

	for _, mod := range goMod.Requires {
		status := "direct"
		if mod.Indirect {
			status = "indirect"
			indirect++
		} else {
			direct++
		}

		checksumKey := mod.Path + "@" + mod.Version
		hasChecksum := "❌"
		if _, exists := checksums[checksumKey]; exists {
			hasChecksum = "✅"
		}

		fmt.Printf("  %s %s@%s (%s)\n", hasChecksum, mod.Path, mod.Version, status)
	}

	fmt.Printf("\nSummary: %d direct, %d indirect dependencies\n", direct, indirect)
}
 אינטראקציה Command המסלולים העיקריים של הפונקציה פקודות למנהלים המתאימים: func main() {
	if len(os.Args) < 2 {
		fmt.Println("Usage: go run main.go <command>")
		fmt.Println("Commands:")
		fmt.Println("  deps      List all dependencies")
		fmt.Println("  vulns     Check for vulnerabilities")
		fmt.Println("  licenses  Check license compliance")
		os.Exit(1)
	}

	switch os.Args[1] {
	case "deps":
		analyzeDependencies()
	case "vulns":
		checkVulnerabilities()
	case "licenses":
		checkLicenses()
	default:
		fmt.Println("Unknown command")
		os.Exit(1)
	}
}
 לרוץ את הכלים שמור את הקוד כמו ולעשות את זה בכל פרויקט Go: main.go # List dependencies with checksum verification
go run main.go deps
 # Scan for vulnerabilities
go run main.go vulns
 # Analyze licenses
go run main.go licenses
 היציאה מציגה מידע על תלויות, דיווחים על פגיעות והפצה של רישיונות בין תלויות הפרויקט שלך.הכלי מראה כיצד ניתוח תלויות פועל מאחורי הקלעים, בדיקת קבצי מודול, שאלת API ציבוריים והפניה בין מקורות נתונים. יישום זה מכסה את המושגים הבסיסיים, אך הוא רק נקודת התחלה. סריקת פגיעות אמיתית דורשת מסדי נתונים מקיפים, תואמות טווח גירסאות מתוחכמות, מסנן חיובי שווא וניהול שגיאות חזק. כלים להגבלת רישיונות זקוקים למנועי מדיניות משפטית, למטריסי תאימות, לזיהוי רישיונות מותאמים אישית מעבר למה ש-API של GitHub מספק. קודי מזל 😉 ניתן למצוא את קוד המקור כאן https://github.com/rezmoss/go-dependency-scanner

This story contains new, firsthand information uncovered by the writer.

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

Read My Stories

האודיו הזה מופק בשפת המקור של הסיפור!

בניית סורק תלות Go from scratch

About Author

הערות

תלו תגים

מאמר זה הוצג ב

Related Stories

The TechBeat: Investigating Internet Freedom: Unseen Aspects of Our Online Existence (1/20/2024)

10 Reasons Why Publishing on HackerNoon Will Skyrocket Your Reach and Impact

The TechBeat: To Focus or Not Focus: How to Find the Right Product-Market Fit (3/8/2024)

The TechBeat: Python's Testing Playbook: Building Bulletproof Code (1/16/2024)

The TechBeat: Investigating Internet Freedom: Unseen Aspects of Our Online Existence (1/20/2024)

10 Reasons Why Publishing on HackerNoon Will Skyrocket Your Reach and Impact

The TechBeat: To Focus or Not Focus: How to Find the Right Product-Market Fit (3/8/2024)

The TechBeat: Python's Testing Playbook: Building Bulletproof Code (1/16/2024)

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps