När du hanterar Go-projekt måste du spåra beroenden, kontrollera sårbarheter och säkerställa licensöverensstämmelse. Istället för att förlita dig på externa verktyg, låt oss bygga vår egen beroendeanalysator med Go:s standardbibliotek. Kärnstrukturen Vi kommer att arbeta med Go-moduler, så vi behöver strukturer för att representera 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
}
 Vårt verktyg kommer att hantera tre operationer: listning av beroenden, sårbarhetsskanning och licenskontroll. Hämta go.mod filer Förstå modulens filstruktur Go.mod-filen använder ett specifikt format som vi behöver analysera korrekt. Moduldeklarationer börjar med modulnyckelordet följt av modulvägen. Vi använder regelbundna uttryck för att extrahera modulvägen och versionen från varje rad, och upptäcka indirekta beroenden genom att leta efter den // indirekta kommentaren. Istället för att skjuta ut Vi kan parsera den Fil direkt från: 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()
}
 Parser hanterar både enkellinje kräver och multi-line kräver block. Det extraherar modulvägar, versioner och identifierar indirekta beroenden. Sårbarhetsdatabasfrågor Hur sårbarhetskontroll fungerar Sårbarhetsdatabaser upprätthåller register över kända säkerhetsproblem i programvarupaket. Varje sårbarhet tilldelas identifierare som CVE-nummer och innehåller detaljer om de versioner som påverkas. Processen fungerar så här: vi skickar paketnamnet och versionen till databasens API, det kontrollerar om den specifika versionen har kända sårbarheter och returnerar sedan en lista över problem om de hittas. OSV-databasen är särskilt användbar eftersom den aggregerar sårbarhetsdata från flera källor och ger en enhetlig API. När vi frågar den frågar vi i huvudsak "har den här exakta versionen av detta paket några rapporterade säkerhetsproblem?" Vi kan kontrollera OSV (Open Source Vulnerabilities) databasen för kända problem: 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årbarhetskontrollen skickar en JSON-laddning med modulnamnet och versionen och analyserar sedan svaret för eventuella rapporterade sårbarheter. Licensinformation fångad Hur licensdetektering fungerar De flesta öppen källkodsprojekt innehåller licensfiler i sina lagringsplatser, och plattformar som GitHub analyserar dessa filer för att identifiera licenstypen med hjälp av SPDX-identifierare. Vårt tillvägagångssätt utnyttjar GitHubs licensdetektering API, som analyserar repositoryinnehållet och returnerar standardiserade licensidentifierare. För moduler som är värd på GitHub extraherar vi ägaren och repositorynamnet från modulvägen, sedan frågar GitHubs API-ändpunkt som specifikt ger licensinformation. Detta ger oss maskinläsbara licensdata utan att behöva ladda ner och analysera licensfiler själva. Olika licenser har olika krav, vissa som MIT är mycket tillåtande, medan andra som GPL har copyleft-krav som kan påverka hur du kan distribuera din programvara. För GitHub-hostade moduler kan vi få licensdata från deras 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)
	}
}
 Tillståndsgivaren erkänner att Paketen använder BSD-3-Clause och sedan frågar GitHubs API för andra repositories. golang.org/x/ Beroendeanalys med checksumverifiering Beroendeanalysatorn listar moduler och kontrollerar deras integritet med hjälp av : 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)
}
 Kommandotjänst Interface Huvudfunktionen vägar kommandon till lämpliga handlare: 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)
	}
}
 Kör verktyget Spara koden som och kör det i något 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
 Utgången visar beroendeinformation, sårbarhetsrapporter och licensdistribution över projektets beroenden. Verktyget visar hur beroendeanalys fungerar bakom kulisserna, analyserar modulfiler, frågar offentliga API:er och korsrefererar datakällor. Denna implementering täcker de grundläggande begreppen men är bara en utgångspunkt. Real sårbarhetssökning kräver omfattande databaser, sofistikerad versionskala matchning, falsk positiv filtrering och robust felhantering. licensöverensstämmelse verktyg behöver juridiska policymotorer, kompatibilitetsmatriser och anpassad licensdetektering utöver vad GitHubs API erbjuder. För produktionsanvändning vill du ha flera datakällor, caching, hastighetsbegränsning och mycket mer grundlig validering logik. Lycklig kodning ;) Du hittar källkoden här 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

Det här ljudet är producerat på berättelsens originalspråk!

Bygg en Go Dependency Scanner från grunden

About Author

KOMMENTARER

HÄNG TAGGAR

DENNA ARTIKEL PRESENTERAS I

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps