Når du administrerer Go-projekter, skal du spore afhængigheder, kontrollere sårbarheder og sikre licensoverensstemmelse.I stedet for at stole på eksterne værktøjer, lad os opbygge vores egen afhængighedsanalysator ved hjælp af Go's standardbibliotek. Den centrale struktur Vi vil arbejde med Go-moduler, så vi har brug for strukturer til at repræsentere dem: 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
}
 Vores værktøj vil håndtere tre operationer: liste af afhængigheder, sårbarhedsskanning og licenskontrol. Parsing go.mod filer Forståelse af modulfilstruktur Filen go.mod bruger et specifikt format, som vi skal analysere korrekt. Modulerklæringer begynder med modulens nøgleord efterfulgt af modulens vej. Afhængigheder er opført i kræveudtalelser, som kan være enkeltlinje eller grupperet i multi-linje blokke. Vi bruger regelmæssige udtryk til at udtrække modulvejen og versionen fra hver linje, og detektere indirekte afhængigheder ved at lede efter den // indirekte kommentar. I stedet for at skyde ud Vi kan parse den Fil direkte til: 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()
}
 Analysatoren håndterer både single-line requires og multi-line requires blokke. Den udvinder modulveje, versioner og identificerer indirekte afhængigheder. Sårbarhedsdatabase forespørgsler Hvordan sårbarhedskontrol virker Sårbarhedsdatabaser opbevarer optegnelser over kendte sikkerhedsproblemer i softwarepakker. Hver sårbarhed får tildelt identifikatorer som CVE-numre og indeholder oplysninger om berørte versioner. Processen fungerer således: Vi sender pakkenavnet og versionen til database-API'en, den kontrollerer, om den specifikke version har kendte sårbarheder, og returnerer derefter en liste over problemer, hvis den findes. OSV-databasen er især nyttig, fordi den aggregerer sårbarhedsdata fra flere kilder og giver en enhedlig API. Når vi forespørger den, spørger vi i det væsentlige "har denne nøjagtige version af denne pakke nogen rapporterede sikkerhedsproblemer?" Vi kan tjekke OSV-databasen (Open Source Vulnerabilities) for kendte problemer: 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)
	}
}
 Sårbarhedskontrollen sender en JSON-nyhedsbelastning med modulnavnet og versionen, og analyserer derefter svaret for eventuelle rapporterede sårbarheder. Tilladelse til at hente oplysninger Hvordan Licens Detection virker De fleste open source-projekter indeholder licensfiler i deres repositories, og platforme som GitHub analyserer disse filer for at identificere licenstypen ved hjælp af SPDX-identifikatorer. Vores tilgang udnytter GitHub's licensdetektion API, som analyserer repositoryindhold og returnerer standardiserede licens-id'er. For moduler hostet på GitHub, udtrækker vi ejeren og repositorynavnet fra modulbanen, og derefter forespørger GitHub's API-endpoint, der specifikt giver licensoplysninger. Dette giver os maskinlæsbare licensdata uden at skulle downloade og analysere licensfiler selv. Forskellige licenser har forskellige krav, nogle som MIT er meget tilladende, mens andre som GPL har copyleft krav, der kan påvirke, hvordan du kan distribuere din software. For GitHub-hostede moduler kan vi få licensdata fra deres 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)
	}
}
 Tilsynsmyndigheden anerkender, at Pakkerne bruger BSD-3-Clause, og derefter forespørger GitHub's API for andre repositories. golang.org/x/ Afhængighedsanalyse med checksum-verifikation Afhængighedsanalysatoren lister moduler og kontrollerer deres integritet ved hjælp af : 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)
}
 Kommandør Interface Hovedfunktionen ruter kommandoer til de relevante håndtere: 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)
	}
}
 Løb med værktøjet Gem koden som og køre det i ethvert Go-projekt: 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
 Udgangen viser afhængighedsoplysninger, sårbarhedsrapporter og licensdistribution på tværs af projektets afhængigheder. Værktøjet demonstrerer, hvordan afhængighedsanalyse fungerer bag kulisserne, analyserer modulfiler, forespørger offentlige API'er og krydsrefererer datakilder. Denne implementering dækker de grundlæggende begreber, men er kun et udgangspunkt. Real sårbarhed scanning kræver omfattende databaser, sofistikeret version række matching, falsk positiv filtrering, og robust fejlhåndtering. Licensoverensstemmelse værktøjer har brug for juridiske politik motorer, kompatibilitet matricer, og brugerdefineret licens detektion ud over, hvad GitHubs API giver. Glædelig kodning ;) Du kan finde kildekoden her 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

Denne lyd er produceret på historiens originalsprog!

Byg en Go Dependency Scanner fra bunden

About Author

KOMMENTARER

HÆNG TAGS

DENNE ARTIKEL BLEV PRÆsenterET I

Related Stories

Meet Bybit: HackerNoon Company of the Week

Meet Google Cloud: HackerNoon Company of the Week

Meet KuCoin Community Chain: HackerNoon Company of the Week

Meet Octopus Network: HackerNoon Company of the Week

Meet Bybit: HackerNoon Company of the Week

Meet Google Cloud: HackerNoon Company of the Week

Meet KuCoin Community Chain: HackerNoon Company of the Week

Meet Octopus Network: HackerNoon Company of the Week

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps