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 फ़ाइल एक विशिष्ट प्रारूप का उपयोग करता है जिसे हमें सही ढंग से विश्लेषण करने की आवश्यकता है. मॉड्यूल घोषणाएं मॉड्यूल कुंजी शब्द के साथ शुरू होती हैं, जिसके बाद मॉड्यूल पथ होता है. Dependencies are listed in require statements, which can be single-line or grouped in multi-line blocks. हम नियमित अभिव्यक्तियों का उपयोग मॉड्यूल पथ और प्रत्येक पंक्ति से संस्करण निकालने के लिए, और अप्रत्यक्ष निर्भरताओं को पता लगाने के लिए // अप्रत्यक्ष टिप्पणी की तलाश करके. यह दृष्टिकोण हमें वही जानकारी देता है जो 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 कैसे काम करता है कमजोरता डेटाबेस सॉफ्टवेयर पैकेज में ज्ञात सुरक्षा मुद्दों के रिकॉर्ड बनाए रखते हैं। प्रत्येक कमजोरता को सीवीई नंबरों जैसे पहचानकर्ता दिए जाते हैं और प्रभावित संस्करणों के बारे में विवरण शामिल हैं। प्रक्रिया इस तरह काम करती है: हम पैकेज का नाम और संस्करण डेटाबेस एपीआई को भेजते हैं, यह जांचता है कि उस विशिष्ट संस्करण में कोई ज्ञात कमजोरता है, फिर एक समस्याओं की सूची वापस करती है यदि पाई जाती है। OSV डेटाबेस विशेष रूप से उपयोगी है क्योंकि यह कई स्रोतों से कमजोरता डेटा को एकत्र करता है और एक एकीकृत एपीआई प्रदान करता है. जब हम इसे पूछते हैं, तो हम मूल रूप से पूछते हैं "क्या इस पैकेज के इस सटीक संस्करण में कोई सुरक्षा समस्याएं हैं? हम ज्ञात मुद्दों के लिए 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)
	}
}
 कमजोरियों की जांच मॉड्यूल का नाम और संस्करण के साथ एक JSON प्लैटलोड भेजती है, फिर किसी भी रिपोर्ट किए गए कमजोरियों के लिए प्रतिक्रिया का विश्लेषण करती है। लाइसेंस के बारे में जानकारी लाइसेंस डिटेक्शन कैसे काम करता है लाइसेंस अनुपालन की जाँच में यह पहचानना शामिल है कि आपके परियोजना में प्रत्येक निर्भरता को किस कानूनी शर्तों से नियंत्रित किया जाता है. अधिकांश ओपन सोर्स परियोजनाओं में अपने रिपोरिटोरियल में लाइसेंस फ़ाइल शामिल हैं, और जीटहब जैसे प्लेटफॉर्म एसपीडीएक्स पहचानकर्ताओं का उपयोग करके लाइसेंस प्रकार की पहचान करने के लिए इन फ़ाइलों का विश्लेषण करते हैं. हमारा दृष्टिकोण GitHub की लाइसेंस पता लगाने एपीआई का लाभ उठाता है, जो रेपोरेटरी सामग्री का विश्लेषण करता है और मानकीकृत लाइसेंस पहचानकर्ताओं को वापस देता है. GitHub पर होस्ट किए गए मॉड्यूल के लिए, हम मॉड्यूल पथ से मालिक और रेपोरेटरी नाम निकालते हैं, फिर GitHub के API एंडपॉइंटपॉइंट को पूछते हैं जो विशिष्ट रूप से लाइसेंस जानकारी प्रदान करता है. यह हमें लाइसेंस फ़ाइलों को खुद डाउनलोड और विश्लेषण करने की आवश्यकता के बिना मशीन से पढ़ाई योग्य लाइसेंस डेटा देता है. विभिन्न लाइसेंस में अलग-अलग आवश्यकताएं हैं, कुछ जैसे कि MIT बहुत अनुमतिदार हैं, जबकि अन्य जैसे कि जीपीएल में कॉपीलेफ्ट आवश्यकताएं हैं जो आपके सॉफ्टवेयर को वितरित करने के तरीके को प्रभावित कर सकती हैं. इन अंतरों को समझना कानूनी अनुपालन के लिए महत्वपूर्ण है. GitHub द्वारा होस्ट किए गए मॉड्यूल के लिए, हम उनके एपीआई से लाइसेंस डेटा प्राप्त कर सकते हैं: 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 के एपीआई का पूछताछ करते हैं। golang.org/x/ Checksum Verification के साथ Dependency Analysis निर्भरता विश्लेषक मॉड्यूल सूचीबद्ध करता है और उनके अखंडता की पुष्टि करता है : 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 और इसे किसी भी 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 का एपीआई प्रदान करता है। कॉफी के फायदे ;) आप यहां स्रोत कोड पा सकते हैं 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

अपने वर्कफ़्लो को 10 गुना बेहतर कैसे बनाएं: 17 ज़रूरी ऐप्स

फ्लोकी का वल्लाह भारत के श्रीलंका दौरे के लिए सहयोगी प्रायोजक के रूप में शामिल हुआ

फ़ोरम से फ़ीड तक: सोशल मीडिया एल्गोरिदम डिजिटल इंटरैक्शन को कैसे आकार देते हैं

10 Reasons Why Publishing on HackerNoon Will Skyrocket Your Reach and Impact

अपने वर्कफ़्लो को 10 गुना बेहतर कैसे बनाएं: 17 ज़रूरी ऐप्स

फ्लोकी का वल्लाह भारत के श्रीलंका दौरे के लिए सहयोगी प्रायोजक के रूप में शामिल हुआ

फ़ोरम से फ़ीड तक: सोशल मीडिया एल्गोरिदम डिजिटल इंटरैक्शन को कैसे आकार देते हैं

10 Reasons Why Publishing on HackerNoon Will Skyrocket Your Reach and Impact

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps