Al administrar proyectos de Go, necesita rastrear dependencias, verificar vulnerabilidades y garantizar el cumplimiento de la licencia. En lugar de depender de herramientas externas, construya nuestro propio analizador de dependencias utilizando la biblioteca estándar de Go. La estructura central Trabajaremos con módulos Go, por lo que necesitamos estructuras para representarlos: 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
}
 Nuestra herramienta manejará tres operaciones: la lista de dependencias, la verificación de vulnerabilidades y la verificación de licencias. Descargar archivos go.mod Comprensión de la estructura de archivos de módulos El archivo go.mod utiliza un formato específico que necesitamos analizar correctamente. Las declaraciones de módulos comienzan con la palabra clave del módulo seguida del camino del módulo. Las dependencias se listan en las declaraciones de requerimiento, que pueden ser de una sola línea o agrupadas en bloques de varias líneas. La lógica de análisis maneja ambos formatos rastreando si estamos dentro de un bloque de requerimientos de múltiples líneas. usamos expresiones regulares para extraer el camino del módulo y la versión de cada línea, y detectar dependencias indirectas buscando el // comentario indirecto. En lugar de disparar a Podemos paralizar el Archivo en directo: 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()
}
 El analizador maneja los bloques de requerimientos de una sola línea y los bloques de requerimientos de varias líneas.Extrae los caminos de módulos, las versiones e identifica las dependencias indirectas. Bases de datos de vulnerabilidades Cómo funciona el control de vulnerabilidad Las bases de datos de vulnerabilidades mantienen registros de problemas de seguridad conocidos en paquetes de software. Cada vulnerabilidad recibe identificadores asignados como números CVE e incluye detalles sobre las versiones afectadas. El proceso funciona de esta manera: enviamos el nombre del paquete y la versión a la API de la base de datos, que comprueba si esa versión específica tiene vulnerabilidades conocidas, y luego devuelve una lista de problemas si se encuentran. La base de datos de OSV es especialmente útil porque agrega datos de vulnerabilidades de múltiples fuentes y proporciona una API unificada. Cuando la consultamos, básicamente preguntamos "¿Esta versión exacta de este paquete tiene problemas de seguridad reportados?" Podemos comprobar la base de datos de vulnerabilidades de código abierto (OSV) para problemas conocidos: 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)
	}
}
 El verificador de vulnerabilidades envía una carga útil de JSON con el nombre y la versión del módulo, y luego analiza la respuesta para cualquier vulnerabilidad reportada. Obtención de información de licencia Cómo funciona la detección de licencias La mayoría de los proyectos de código abierto incluyen archivos de licencia en sus repositorios, y plataformas como GitHub analizan estos archivos para identificar el tipo de licencia utilizando identificadores SPDX. Nuestro enfoque aprovecha la API de detección de licencias de GitHub, que analiza el contenido del repositorio y devuelve identificadores de licencia estandarizados. Para módulos alojados en GitHub, extraemos el nombre del propietario y del repositorio del camino del módulo, luego consultamos el punto final de la API de GitHub que proporciona específicamente información de licencia. Esto nos da datos de licencia legibles por máquina sin tener que descargar y analizar los archivos de licencia nosotros mismos. Diferentes licencias tienen requisitos diferentes, algunos como MIT son muy permisivos, mientras que otros como GPL tienen requisitos de copyleft que pueden afectar a cómo puede distribuir su software. Para los módulos alojados en GitHub, podemos obtener datos de licencia de su 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)
	}
}
 El controlador de licencias reconoce que Los paquetes utilizan BSD-3-Clause, luego consultan la API de GitHub para otros repositorios. golang.org/x/ Análisis de dependencia con verificación de checksum El analizador de dependencia enumera los módulos y verifica su integridad utilizando : 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)
}
 Interfaz de comandos La ruta de la función principal manda a los manipuladores apropiados: 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)
	}
}
 Correr la herramienta Guardar el código como y ejecutarlo en cualquier proyecto 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
 La salida muestra información sobre dependencias, informes de vulnerabilidades y distribución de licencias en todas las dependencias de su proyecto.La herramienta demuestra cómo funciona el análisis de dependencias detrás de las escenas, analizando archivos de módulos, consultando APIs públicas y referenciando fuentes de datos. Esta implementación cubre los conceptos básicos, pero es sólo un punto de partida. El escaneo de vulnerabilidades reales requiere bases de datos completas, ajuste de rango de versiones sofisticado, filtración de falsos positivos y manejo de errores robusto. Las herramientas de cumplimiento de licencias necesitan motores de políticas legales, matrices de compatibilidad y detección de licencias personalizadas más allá de lo que ofrece la API de GitHub. Para el uso de la producción, usted desearía múltiples fuentes de datos, caché, limitación de tasa y una lógica de validación mucho más completa. Un buen codigo ;) Puedes encontrar el código fuente aquí 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

Este audio es producido en el idioma original de la historia!

Construir un escáner de dependencia de Go desde cero

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

Cómo mejorar su flujo de trabajo 10 veces: 17 aplicaciones esenciales

¿Quieres ganar un concurso de redacción de HackerNoon? Esto es lo que recomiendan los ganadores del concurso #crypto-api

Aumente su productividad con estas 18 herramientas para desarrolladores 🚀🔥

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

Cómo mejorar su flujo de trabajo 10 veces: 17 aplicaciones esenciales

¿Quieres ganar un concurso de redacción de HackerNoon? Esto es lo que recomiendan los ganadores del concurso #crypto-api

Aumente su productividad con estas 18 herramientas para desarrolladores 🚀🔥

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps