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 ფაილი Module ფაილი სტრუქტურა Go.mod ფაილი გამოიყენებს კონკრეტული ფორმატში, რომელიც ჩვენ უნდა შეამოწმოთ სწრაფად. მოდულების დეტალები დაიწყება მოდულების Keyword შემდეგ მოდულების გზა. დამოკიდებულებები სიაში მოთხოვნებს დეტალები, რომელიც შეიძლება იყოს ერთი ხაზი ან ჯგუფირებული მრავალ ხაზი ბლოკები. ჩვენ გამოიყენებთ რეგულარული ექსპერიმენტებს მოდულების გზა და ვერსია თითოეული ხაზი, და შეამოწმეთ უარყოფითი დამოკიდებულებები ეძებს // უარყოფითი კომენტარი. ეს მიმოხილვა გთავაზობთ იგივე ინფორმაციას, რომელიც go სია უნდა უზრუნველყოს, მაგრამ გარეშე გამოწვევა გარე პროცესები. მყისიერად, ვიდრე გაქირავება ჩვენ შეგვიძლია შეიტანოთ პირდაპირი ფაილი : 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()
}
 ეს მოთხოვნები შეიცავს ერთი ხაზის მოთხოვნებს და მრავალ ხაზის მოთხოვნებს. მას ატვირთებს მოდულების გზა, ვერსია და აჩვენებს უარყოფითი დამოკიდებულებები. Vulnerability Database კითხვები როგორ მუშაობს Vulnerability Checking მონაცემთა ბაზები შეინახავს პოპულარული უსაფრთხოების პრობლემები პროგრამული პაკეტებში. თითოეული უსაფრთხოების კონფიდენციალურობის მისაღებად იდენტიფიკატები, როგორიცაა CVE ნომერი და მოიცავს დეტალებს შეუზღუდავი ვერსიაზე. პროცესი მუშაობს ამგვარად: ჩვენ გადაცემთ პაკეტების სახელი და ვერსია მონაცემთა ბაზის API- ში, ეს შეამოწმებს, თუ ამ კონკრეტული ვერსიაში არსებობს პოპულარული უსაფრთხოების პრობლემები, და შემდეგ გადაცემა პრობლემების სია. OSV მონაცემთა ბაზა განსაკუთრებით სასარგებლოა, რადგან იგი აერთიანებს vulnerability მონაცემებს მრავალფეროვანი წყაროდან და უზრუნველყოფს ერთგული API. როდესაც ჩვენ კითხვებთ მას, ჩვენ ძირითადად კითხვებთ, "ეს რეპუტაცია ამ პაკეტზე არ აქვს გარკვეული უსაფრთხოების პრობლემები?" მონაცემთა ბაზა აწარმოებს ვერსია შეესაბამება და მოგცემს სტრუქტურული მონაცემები ნებისმიერ შედეგების შესახებ. ჩვენ შეგვიძლია შეამოწმოთ OSV (Open Source Vulnerabilities) მონაცემთა ბაზა ცნობილი პრობლემებისთვის: 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 ფუნქციური სიჩქარე მოდულების სახელი და ვერსია, შემდეგ შეამოწმებს პასუხი ნებისმიერ გამოქვეყნებული Vulnerabilities. ლიცენზია ინფორმაცია Fetching როგორ მუშაობს License Detection Licence compliance check involves identifying what legal terms govern each dependency in your project. ყველაზე open source პროექტები მოიცავს ლიცენზიის ფაილი მათი repositories, და პლატფორმაები, როგორიცაა GitHub შეამოწმოთ ეს ფაილი identify ლიცენზიის ტიპის გამოყენებით SPDX identifier. ჩვენი მიმოხილვა გამოიყენებს GitHub- ის ლიცენზია დეტალაციის API- ს, რომელიც ანალიზიებს რეპუტატორიის შინაარსი და იღებს სტანდარტული ლიცენზია ID-ები. GitHub- ზე მოდულებისთვის, ჩვენ მოპოვებთ მფლობელი და რეპუტატორიის სახელი მოდულების გზადან, შემდეგ კითხვებს GitHub- ის 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- ს სხვა repositories- სთვის. golang.org/x/ Dependency Analysis ერთად Checksum Verification 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)
}
 კონტაქტი 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)
	}
}
 Running ინსტრუმენტი შენახვა კოდი as და აწარმოებს იგი ნებისმიერ 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
 პროგრამული უზრუნველყოფა გთავაზობთ პროგრამული უზრუნველყოფა, რომელიც უზრუნველყოფს თქვენი პროგრამული უზრუნველყოფა. პროგრამული უზრუნველყოფა გთავაზობთ პროგრამული უზრუნველყოფა, რომელიც უზრუნველყოფს პროგრამული უზრუნველყოფის უზრუნველყოფს. ამ განახლება მოიცავს ძირითადი კონცეფციები, მაგრამ ეს არის მხოლოდ დაწყება. რეალური შეუზღუდავიების სინთეზი მოითხოვს ფართო მონაცემთა ბაზებს, მოწინავე ვერსია სფეროში შეესაბამება, ფსიქიკური პოტენციური ფილტრაცია და ძლიერი შეცდომების მართვა. ლიცენზაციის შეესაბამება ინსტრუმენტები მოითხოვს რეგულარული პოლიტიკის საავტომობილო, კომფორტობის მატრიზები და საბაჟო ლიცენზიის იპოვება, ვიდრე GitHub- ის API- ს უზრუნველყოფს. წარმოების გამოყენებისთვის, თქვენ გსურთ მრავალფეროვანი მონაცემთა წყაროები, caching, ფასის შეზღუდავი დახურვა და ბედნიერი კოდი 😉 აქ შეგიძლიათ იპოვოთ წყარო კოდი 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

ეს აუდიო დამზადებულია სიუჟეტის ორიგინალურ ენაზე!

Ძალიან გრძელი; Წაკითხვა

Make resilience your competitive advantage

Go Dependency Scanner- ის შექმნა ნაცვლად

About Author

კომენტარები

დაკიდეთ ტეგები

ეს სტატია იყო წარმოდგენილი

Related Stories

“Dulcedo is a people-first company and all about relationship-building.” says Karim Leduc, CEO

Karak and Space and Time Join Forces to Revolutionize Blockchain Security

Karma: Love on the Blockchain and the Gamification of Helping Others

How to Not Lose 97.8% of Your Newsletter Subscribers

“Dulcedo is a people-first company and all about relationship-building.” says Karim Leduc, CEO

Karak and Space and Time Join Forces to Revolutionize Blockchain Security

Karma: Love on the Blockchain and the Gamification of Helping Others

How to Not Lose 97.8% of Your Newsletter Subscribers

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps