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
}
 当社のツールは、依存性のリスト化、脆弱性スキャン、ライセンスチェックの3つの操作を処理します。 go.mod ファイル モジュールファイル構造の理解 go.mod ファイルは、正しく解析する必要がある特定の形式を使用します. モジュール宣言は、モジュールキーワードから始まり、モジュールパスに続きます. Dependencies are listed in require statements, which can be single-line or grouped in multi-line blocks. パッシングロジックは、我々が多線要求ブロック内にいるかどうかを追跡することによって、両方のフォーマットを処理します.We use regular expressions to extract the module path and version from each line, and detect indirect dependencies by looking for the // indirect comment. This approach gives us the same information that go list would provide, but without spawning external processes. このアプローチは、go listが提供する同じ情報を提供します。 発砲するよりは、 , we can parse the 直接ファイル: 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()
}
 パッサーは、単行リクエストと複数のリクエストブロックの両方を処理します. It extracts module paths, versions, and identifies indirect dependencies. 脆弱性データベースクエリ 脆弱性をチェックする方法 脆弱性データベースは、ソフトウェア パッケージ内の既知のセキュリティ問題の記録を保持します。各脆弱性は、CVE 番号などの識別子を割り当てられ、影響を受けたバージョンの詳細を含みます。このプロセスは、パッケージ名とバージョンをデータベース API に送信し、特定のバージョンに既知の脆弱性があるかどうかを確認し、発見した場合に問題のリストを返します。 OSV データベースは、複数のソースから脆弱性データを集計し、統一された API を提供するため、特に役に立ちます。当社は、このパッケージの正確なバージョンに報告されたセキュリティ上の問題があるか?」と尋ねると、データベースはバージョン一致を実行し、あらゆる発見に関する構造化されたデータを返します。 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 識別子を使用してライセンスの種類を識別するために、これらのファイルを解析します。 私たちのアプローチは、リポジトリのコンテンツを分析し、標準化されたライセンス識別子を返すGitHubのライセンス検出APIを活用します。GitHubにホストされているモジュールの場合、モジュールパスから所有者とリポジトリ名を抽出し、GitHubのAPIエンドポイントをクエリし、ライセンス情報を提供します。 さまざまなライセンスには異なる要件があり、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 を使用し、その後他のリポジトリの GitHub の API をクエリします。 golang.org/x/ チェックサム検証による依存分析 dependency analyzer は、モジュールをリストし、その統合性を確認します。 : 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)
	}
}
 ツールを走る コードを Save as どんなプロジェクトでも実行する: 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
 出力は、依存性情報、脆弱性レポート、およびプロジェクトの依存性におけるライセンス配布を表示します.The tool demonstrates how dependence analysis works behind the scenes, parsing module files, querying public APIs, and cross-referencing data sources. この実装は、基本的なコンセプトをカバーしますが、それは始まりのポイントにすぎません。実際の脆弱性スキャンには、包括的なデータベース、高度なバージョン範囲の一致、偽ポジティブのフィルタリング、そして強力なエラー処理が必要です。ライセンスコンプライアンスツールには、法的ポリシーエンジン、互換性マトリックス、およびGitHubのAPIが提供するもの以外のカスタマイズされたライセンス検出が必要です。 ハッピーコード ;) ここでソースコードを見つけることができます。 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

このオーディオは、ストーリーの元の言語で制作されています。

「Go Dependency Scanner from Scratch」

About Author

コメント

ラベル

この記事は

Related Stories

フォーラムからフィードへ: ソーシャルメディアアルゴリズムがデジタルインタラクションを形作る仕組み

AI/ML データレイクのリファレンスアーキテクチャを構築するためのアーキテクトガイド

目に見えない層: ユーザーインタビューがかけがえのない資産である理由

HackerNoon ライティングコンテストで優勝したいですか? #crypto-api コンテスト優勝者のおすすめはこちら

フォーラムからフィードへ: ソーシャルメディアアルゴリズムがデジタルインタラクションを形作る仕組み

AI/ML データレイクのリファレンスアーキテクチャを構築するためのアーキテクトガイド

目に見えない層: ユーザーインタビューがかけがえのない資産である理由

HackerNoon ライティングコンテストで優勝したいですか? #crypto-api コンテスト優勝者のおすすめはこちら

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps