При управлінні проектами 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 Розуміння структури файлів модулів Файл 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. Коли ми запитуємо її, ми, по суті, запитуємо: "Чи має ця точна версія цього пакета які-небудь повідомлення про проблеми з безпекою?" Ми можемо перевірити базу даних Open Source Vulnerabilities (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, мають вимоги до копілейфта, які можуть вплинути на те, як ви можете розповсюджувати своє програмне забезпечення. Для модулів, розміщених на 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/ Аналіз залежності з перевіркою суми Аналізатор залежності перелічує модулі та перевіряє їх цілісність за допомогою : 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)
}
 Командний інтерфейс Основні маршрути функції вказують на відповідних операторів: 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)
	}
}
 Завантажити інструмент Зберегти код як Використовуйте його в будь-якому проекті: 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.

Створення Go Dependency Scanner from Scratch

About Author

КОМЕНТАРІ

ПОВІСИТИ БИРКИ

ЦЯ СТАТТЯ БУЛА ПРЕДСТАВЛЕНА В

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps