የ Go ፕሮጀክቶች መቆጣጠሪያ ላይ, እርስዎ መድሃኒቶች መከታተል, ጥንካሬዎች ለማረጋገጥ, እና የክፍያ ተስማሚነት ለማረጋገጥ አለብዎት. ከባድ መሣሪያዎች ላይ የተመሠረተ helyett, የ 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 ፋይሎች የ Module File Structure አጠቃቀም የ go.mod ፋይሎች የተወሰነ ቅርጸት ይጠቀማሉ. ሞዱል ቅርጸቶች ሞዱል መለያው ጋር ይጀምራል እና ሞዱል ቅርጸት ጋር ይጀምራል. Dependencies are listed in require statements, which can be single-line or grouped in multi-line blocks. የ Parsing Logic ሁለቱም ቅርጾችን በመስመር ላይ በ multi-line require blocks ውስጥ ነጠላዎን መከታተል በመጠቀም ይጠቀማል. የ module path and version from each line can be extracted by regular expressions, and indirect dependencies can be detected by searching for the // indirect comment.This approach gives us the same information that the go list would provide, but without spawning external processes. ከባድ ከባድ ከባድ ወደ እርስዎ የ Parse ቀጥተኛ መልዕክት: 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 ሁለቱም አንድ መስመር መስፈርቶች እና ብዙ መስመር መስፈርቶች ብሎክዎችን ይጠቀማል. ይህ ሞዴል መስፈርቶች, ስሪትዎች ያግኙ, እና በይነገጽ ደህንነት ያውቃል. ጥንካሬ ውሂብ ማረጋገጫ ጥንካሬ ቁጥጥር እንዴት ይሰራል እያንዳንዱ ሶፍትዌር ፓኬቶች ውስጥ የታወቀ ደህንነት ችግሮች ዝርዝሮች ማከማቸዋል. እያንዳንዱ ደህንነት ምልክቶች እንደ CVE ቁጥር ያካትታሉ እና የፈጠራ ስሪቶች ዝርዝር ያካትታሉ. ይህ ሂደት እንደዚህ ይሰራል: የፓኬት ስም እና ስሪት ወደ የ Database API ይሰጣል, እያንዳንዱ ልዩ ስሪት የታወቀ ደህንነት ስሪት ማንኛውም ያካትታሉ, ከዚያም በፈጠራ ስሪት አንድ ዝርዝር ይሰጣል. የ OSV ውሂብ ውሂብ በጣም አስፈላጊ ነው ምክንያቱም ከሁለቱም ውሂብ ከሁለቱም ውሂብ ያካትታል እና አንድ ተስማሚ API ይሰጣል. የ OSV ውሂብ ውሂብ ውሂብ ውሂብ ይሰጣል ጊዜ, በእርግጥ "የዚህ ውሂብ ውሂብ ውሂብ ውሂብ ውሂብ ውሂብ ውሂብ ውሂብ ነው? የ OSV (Open Source Vulnerabilities) databases ላይ የሚታወቀው ችግሮች ለማረጋገጥ ይችላሉ: 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)
	}
}
 የ vulnerability checker ሞዴል ስም እና ስሪት ጋር አንድ JSON payload ይሰጣል, ከዚያም ማንኛውም የተመሠረተ vulnerabilities ላይ መልስ ይታያል. የምስክር ወረቀት ዝርዝር የምስክር ወረቀት ማረጋገጫ እንዴት ነው አብዛኛዎቹ የ Open Source ፕሮጀክቶች በክፍያዎች ውስጥ የክፍያ ፋይሎች ያካትታሉ, እና GitHub እንደ ፕላስቲክዎች SPDX መታወቂያዎችን በመጠቀም የክፍያ አይነት ለመታወቅ እነዚህ ፋይሎች ይታያል. የ GitHub License Detection API ይጠቀማል, ይህም ቅርንጫፍ ይዘትን ይታያል እና መደበኛ ቅርንጫፍ የምስክር ወረቀት ያውቃል. በ GitHub ላይ የተመሠረተ ሞዴሎች ለ, የእኛን አጠቃቀም እና ቅርንጫፍ ስም ከ module path ይቀበላሉ, ከዚያም GitHub's API endpoint ይታያል, ይህም ልዩውን ቅርንጫፍ መረጃ ይሰጣል. ይህ የእኛን መግዛት እና ቅርንጫፍ ማረጋገጫ ፋይሎች ማውረድ እና ማውረድ አይፈልግም. የተለያዩ መስፈርቶች የተለያዩ መስፈርቶች አለው, MIT እንደ አንዳንድ በጣም አስደናቂ ናቸው, እንዲሁም GPL እንደ ሌሎች copyleft መስፈርቶች ናቸው, እነርሱም የእርስዎን ሶፍትዌር እንዴት መተግበሪያ ሊሆን ይችላል. ለ 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/ የ Checksum Verification እና የ Checksum Assessment የሙዚቃ ልኬቶች የሙዚቃ ልኬቶች እና የሙዚቃ ልኬቶች ይጠቀማሉ : 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)
}
 Interface አጠቃቀም ዋናው ተግባር መስመሮች ለስላሳ መተግበሪያዎች ይደውሉ: 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
 ይህ መሣሪያ በፕሮጀክቱ ውስጥ በፕሮጀክቱ ውስጥ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ በፕሮጀክቱ ይህ መተግበሪያ የክፍያ ባህሪያት ያካትታል, ነገር ግን ብቻ መጀመሪያ ደረጃ ነው. እውነተኛ ጥንካሬ ጥንካሬዎች በ GitHub's API አቅርቦት በላይ የግል ፖሊሲ መሣሪያዎች, ተስማሚነት ማተሚያዎች, እና ብጁ ማረጋገጫ ማረጋገጫ ያስፈልጋል. ምርት መጠቀም ለማግኘት, ብዙ ውሂብ ምንጮች, caching, rate limiting, እና ብዙ ተጨማሪ ጥንካሬ ማረጋገጫ መሣሪያዎችን ይፈልጋሉ. ደስተኛ ኮድ ;) እዚህ የ source code ማግኘት ይችላሉ. 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 ከታች መፍጠር

About Author

አስተያየቶች

ተንጠልጣይ መለያዎች

ይህ ጽሑፍ ቀርቧል

Related Stories

AMA with Rana Gujral, CEO of Behavioral Signals and Noonies Nominee, on September 30th, 9 am PST

999 PRISCILLA

Startups Legal Advice discussion with Josh Ephraim, AMA on September 3rd, 9 am PST

Democratizing Tech Skills with Jeremy Morgan of Pluralsight, LIVE AMA on August 17th, 12 pm EST

AMA with Rana Gujral, CEO of Behavioral Signals and Noonies Nominee, on September 30th, 9 am PST

999 PRISCILLA

Startups Legal Advice discussion with Josh Ephraim, AMA on September 3rd, 9 am PST

Democratizing Tech Skills with Jeremy Morgan of Pluralsight, LIVE AMA on August 17th, 12 pm EST

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps