Při správě projektů Go je třeba sledovat závislosti, zkontrolovat zranitelnosti a zajistit dodržování licencí. Místo spoléhání se na externí nástroje vytvořme vlastní analyzátor závislosti pomocí standardní knihovny Go. Základní struktura Budeme pracovat s moduly Go, takže potřebujeme struktury, které je reprezentují: 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
}
 Náš nástroj zvládne tři operace: seznam závislostí, skenování zranitelností a kontrolu licencí. Parsing go.mod soubory Pochopení modulové struktury souborů Soubor go.mod používá specifický formát, který potřebujeme správně analyzovat. Modulové prohlášení začínají klíčovým slovem modulu následovaným modulovou cestou. Závislosti jsou uvedeny v požadovaných prohlášeních, které mohou být jednorázové nebo seskupeny do bloků s více řádky. Používáme pravidelné výrazy k extrahování modulové cesty a verze z každého řádku a k detekci nepřímých závislostí hledáním nepřímého komentáře. Namísto střelby na Můžeme se podívat na Přímý soubor přímo: 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()
}
 Analyzátor zpracovává bloky požadavků na jeden řádek a bloky požadavků na více řádků. Extrahuje modulové cesty, verze a identifikuje nepřímé závislosti. Požadavky na databázi zranitelností Jak funguje kontrola zranitelnosti Databáze zranitelností uchovávají záznamy o známých bezpečnostních problémech v softwarových balíčcích. Každé zranitelnosti je přiřazeno identifikátory, jako jsou čísla CVE, a obsahuje podrobnosti o ovlivněných verzích. Proces funguje takto: odesíláme název balíčku a verzi databázi API, zkontroluje, zda má daná konkrétní verze známé zranitelnosti, a v případě nalezení vrátí seznam problémů. Databáze OSV je obzvláště užitečná, protože shromažďuje údaje o zranitelnostech z více zdrojů a poskytuje jednotný rozhraní API.Když ji dotazujeme, v podstatě se ptáme: „Má tato přesná verze tohoto balíčku nějaké hlášené bezpečnostní problémy?“ Databáze provádí shodu verzí a vrací strukturované údaje o všech zjištěních. Můžeme zkontrolovat databázi OSV (Open Source Vulnerabilities) pro známé problémy: 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)
	}
}
 Kontrola zranitelnosti odesílá úložiště JSON s názvem a verzí modulu a následně analyzuje odpověď na případné hlášené zranitelnosti. Licenční informace Fetching Jak funguje detekce licencí Většina projektů s otevřeným zdrojovým kódem obsahuje licenční soubory ve svých úložištích a platformy jako GitHub tyto soubory analyzují, aby identifikovaly typ licence pomocí identifikátorů SPDX. Náš přístup využívá rozhraní API pro detekci licencí GitHub, které analyzuje obsah úložiště a vrací standardizované identifikátory licencí. U modulů hostovaných na GitHub extrahujeme vlastníka a název úložiště z cesty modulu a poté vyhledáváme koncový bod API GitHub, který konkrétně poskytuje informace o licencích. Různé licence mají různé požadavky, některé, jako je MIT, jsou velmi přípustné, zatímco jiné, jako je GPL, mají požadavky na copyleft, které mohou ovlivnit způsob, jakým můžete distribuovat software. U modulů hostovaných GitHub můžeme získat licence z jejich 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)
	}
}
 Kontrolní úřad uznává, že Pakety používají BSD-3-Clause, poté vyhledávají API GitHub pro jiné úložiště. golang.org/x/ Analýza závislosti s ověřením kontrolní částky Analyzátor závislostí seznamuje moduly a ověřuje jejich integritu pomocí : 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)
}
 Příkazový rozhraní Hlavní funkce směruje příkazy na příslušné manipulátory: 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)
	}
}
 Spuštění nástroje Uložit kód jako a spustit ji v jakémkoli Go projektu: 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
 Výstup zobrazuje informace o závislosti, zprávy o zranitelnosti a distribuci licencí mezi závislostmi vašeho projektu. Nástroj demonstruje, jak analýza závislosti funguje za scénami, analyzuje soubory modulů, dotazuje veřejné rozhraní API a křížově odkazuje na zdroje dat. Tato implementace pokrývá základní pojmy, ale je to jen výchozí bod. Skenování skutečných zranitelností vyžaduje komplexní databáze, sofistikované shodování rozsahů verzí, falešné pozitivní filtrování a robustní řešení chyb. Nástroje pro dodržování licencí potřebují právní nástroje, matice kompatibility a detekci vlastních licencí nad rámec toho, co nabízí rozhraní API GitHub. Šťastný kousek ;) Zdrojový kód naleznete zde 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

Tento zvuk je produkován v původním jazyce příběhu!

Vytvoření Go Dependency Scanner od nuly

About Author

KOMENTÁŘE

ZAVĚŠIT ZNAČKY

TENTO ČLÁNEK BYL PŘEDSTAVEN V

Related Stories

Coinshift Launches csUSDL, Announces Strategic Partnerships

Coinshift Launches csUSDL, Announces Strategic Partnerships

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps