Black Hat Go

# Strukturalashgan ma'lumotlar ## Bu darsda nima o'rganamiz? Pentest paytida API'lardan JSON javob keladi, config fayllar YAML yoki TOML da yoziladi, skaner natijalarini faylga saqlaymiz. Bu darsda Go struct'larni JSON'ga va JSONni struct'larga aylantirishni, struct tag'lardan foydalanishni va streaming (katta ma'lumot uchun) ko'ramiz. ## JSON — asosiy format **JSON marshaling** — Go struct'ni JSON'ga aylantirish: ```go package main import ( "encoding/json" "fmt" ) type ScanResult struct { IP string Port int IsOpen bool Service string } func main() { result := ScanResult{ IP: "192.168.1.1", Port: 80, IsOpen: true, Service: "HTTP", } // struct → JSON bytes data, err := json.Marshal(result) if err != nil { fmt.Println("Xato:", err) return } fmt.Println(string(data)) // {"IP":"192.168.1.1","Port":80,"IsOpen":true,"Service":"HTTP"} } ``` Odam o'qiy oladigan formatda (debug uchun): ```go data, err := json.MarshalIndent(result, "", " ") // { // "IP": "192.168.1.1", // "Port": 80, // "IsOpen": true, // "Service": "HTTP" // } ``` **JSON unmarshaling** — JSON'dan struct yaratish: ```go jsonStr := `{"IP":"10.0.0.1","Port":443,"IsOpen":true,"Service":"HTTPS"}` var result ScanResult err := json.Unmarshal([]byte(jsonStr), &result) if err != nil { fmt.Println("Parse xatosi:", err) return } fmt.Println(result.IP, result.Port) // 10.0.0.1 443 ``` > [!WARNING] > `json.Unmarshal(data, result)` emas — `&result` (pointer). Unmarshal struct'ni o'zgartirishi kerak, shuning uchun pointer beriladi. ## Struct tag'lar Default holatda JSON kalit nomi Go field nomiga teng (`IP`, `Port`). Agar JSON'da boshqacha nom kerak bo'lsa — tag yoziladi: ```go type ScanResult struct { IP string `json:"ip"` Port int `json:"port"` IsOpen bool `json:"is_open"` // snake_case Service string `json:"service,omitempty"` // bo'sh bo'lsa chiqmaydi Internal string `json:"-"` // JSON'ga hech qachon chiqmaydi } ``` `omitempty` — field zero value bo'lsa (`""`, `0`, `false`, `nil`) JSON'da ko'rinmaydi. Bunda ehtiyot bo'ling: `Count: 0` ham chiqmaydi, agar `omitempty` bo'lsa. Bundan saqlanish uchun pointer ishlatiladi: ```go type Stats struct { Count *int `json:"count,omitempty"` // nil bo'lsa chiqmaydi, 0 bo'lsa chiqadi } ``` Tag variantlari: | Tag | Nima qiladi | |---|---| | `json:"name"` | JSON da "name" kalit ishlatiladi | | `json:"name,omitempty"` | Bo'sh bo'lsa chiqmaydi | | `json:"-"` | Hech qachon JSON'ga chiqmaydi | | `json:",string"` | Raqamni string sifatida serialize qiladi | ## Encoder va Decoder — streaming `json.Marshal/Unmarshal` butun ma'lumotni xotirada saqlaydi. Katta fayl yoki HTTP stream uchun `Encoder/Decoder` xotirani tejaydi: ```go // Faylga yozish — streaming func saveResults(results []ScanResult, filename string) error { f, err := os.Create(filename) if err != nil { return fmt.Errorf("fayl yaratib bo'lmadi: %w", err) } defer f.Close() encoder := json.NewEncoder(f) encoder.SetIndent("", " ") return encoder.Encode(results) // to'g'ridan-to'g'ri faylga yozadi } // Fayldan o'qish — streaming func loadResults(filename string) ([]ScanResult, error) { f, err := os.Open(filename) if err != nil { return nil, fmt.Errorf("fayl ochib bo'lmadi: %w", err) } defer f.Close() var results []ScanResult decoder := json.NewDecoder(f) if err := decoder.Decode(&results); err != nil { return nil, fmt.Errorf("JSON parse xatosi: %w", err) } return results, nil } ``` HTTP API bilan: ```go // API'dan JSON qabul qilish func fetchTargets(url string) ([]string, error) { resp, err := http.Get(url) if err != nil { return nil, err } defer resp.Body.Close() var targets []string if err := json.NewDecoder(resp.Body).Decode(&targets); err != nil { return nil, fmt.Errorf("JSON decode: %w", err) } return targets, nil } // HTTP handler'da JSON javob qaytarish func scanHandler(w http.ResponseWriter, r *http.Request) { results := []ScanResult{...} w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(results) } ``` ## Custom marshaling Ba'zan standart JSON formati yetarli emas — masalan, `time.Time` ni o'z formatimizda saqlash: ```go // Timestamp — time.Time'ning o'rami, custom JSON format bilan type Timestamp time.Time func (t Timestamp) MarshalJSON() ([]byte, error) { stamp := time.Time(t).Format("2006-01-02 15:04:05") return []byte(`"` + stamp + `"`), nil } func (t *Timestamp) UnmarshalJSON(data []byte) error { // tırnoqlarni olib tashlash s := string(data[1 : len(data)-1]) parsed, err := time.Parse("2006-01-02 15:04:05", s) if err != nil { return err } *t = Timestamp(parsed) return nil } type Event struct { Name string `json:"name"` CreatedAt Timestamp `json:"created_at"` } ``` Endi `json.Marshal(event)` chaqirilganda `Timestamp.MarshalJSON` avtomatik ishga tushadi. ## XML XML eski tizimlar, SOAP API'lar va ba'zi konfiguratsiya fayllarida ishlatiladi: ```go import "encoding/xml" type Book struct { XMLName xml.Name `xml:"book"` // root element nomi Title string `xml:"title"` // element Author string `xml:"author"` Year int `xml:"year,attr"` // atribut } book := Book{Title: "Black Hat Go", Author: "Tom Steele", Year: 2020} data, _ := xml.MarshalIndent(book, "", " ") fmt.Println(xml.Header + string(data)) // // // Black Hat Go // Tom Steele // ``` ## YAML va TOML — konfiguratsiya fayllar YAML — odam o'qiy oladigan format, Kubernetes va Docker Compose ishlatadi: ```go // go get gopkg.in/yaml.v3 import "gopkg.in/yaml.v3" type Config struct { Server struct { Host string `yaml:"host"` Port int `yaml:"port"` } `yaml:"server"` Timeout int `yaml:"timeout"` } yamlData := ` server: host: localhost port: 8080 timeout: 30 ` var cfg Config yaml.Unmarshal([]byte(yamlData), &cfg) fmt.Printf("Server: %s:%d\n", cfg.Server.Host, cfg.Server.Port) ``` TOML — Rust va Go ekosistemida keng tarqalgan: ```go // go get github.com/BurntSushi/toml import "github.com/BurntSushi/toml" tomlData := ` [server] host = "localhost" port = 8080 ` toml.Decode(tomlData, &cfg) ``` ## Binary encoding — Go'dan Go'ga `encoding/gob` — faqat Go'da ishlaydi, lekin JSON'dan ~3 marta tezroq va kichikroq: ```go import ( "bytes" "encoding/gob" ) type Payload struct { Command string Args []string } // Encode var buf bytes.Buffer gob.NewEncoder(&buf).Encode(Payload{Command: "scan", Args: []string{"192.168.1.1"}}) // Decode var p Payload gob.NewDecoder(&buf).Decode(&p) ``` C2 (Command & Control) server'da target bilan Go'da ikki tomonlama muloqot uchun foydali. ## Amaliy misol: scanner konfiguratsiya menedjer ```go package main import ( "encoding/json" "fmt" "net" "os" ) type PortRange struct { Start int `json:"start"` End int `json:"end"` } type Target struct { IP string `json:"ip"` PortRanges []PortRange `json:"port_ranges"` } type ScanConfig struct { Targets []Target `json:"targets"` Timeout int `json:"timeout"` // soniya Workers int `json:"workers"` OutputFile string `json:"output_file,omitempty"` } // validateConfig — konfiguratsiyani tekshiradi func validateConfig(cfg *ScanConfig) error { if len(cfg.Targets) == 0 { return fmt.Errorf("kamida bitta target kerak") } for i, t := range cfg.Targets { if net.ParseIP(t.IP) == nil { return fmt.Errorf("target %d: noto'g'ri IP: %s", i, t.IP) } for j, pr := range t.PortRanges { if pr.Start < 1 || pr.Start > 65535 { return fmt.Errorf("target %d, oraliq %d: noto'g'ri start port: %d", i, j, pr.Start) } if pr.End < pr.Start || pr.End > 65535 { return fmt.Errorf("target %d, oraliq %d: noto'g'ri end port: %d", i, j, pr.End) } } } if cfg.Timeout <= 0 { return fmt.Errorf("timeout musbat son bo'lishi kerak") } if cfg.Workers <= 0 { return fmt.Errorf("workers musbat son bo'lishi kerak") } return nil } // saveConfig — konfiguratsiyani faylga saqlaydi func saveConfig(cfg *ScanConfig, filename string) error { if err := validateConfig(cfg); err != nil { return fmt.Errorf("validatsiya: %w", err) } f, err := os.Create(filename) if err != nil { return fmt.Errorf("fayl yaratib bo'lmadi: %w", err) } defer f.Close() enc := json.NewEncoder(f) enc.SetIndent("", " ") return enc.Encode(cfg) } // loadConfig — fayldan konfiguratsiyani o'qiydi func loadConfig(filename string) (*ScanConfig, error) { f, err := os.Open(filename) if err != nil { return nil, fmt.Errorf("config ochib bo'lmadi: %w", err) } defer f.Close() var cfg ScanConfig if err := json.NewDecoder(f).Decode(&cfg); err != nil { return nil, fmt.Errorf("JSON parse: %w", err) } if err := validateConfig(&cfg); err != nil { return nil, fmt.Errorf("validatsiya: %w", err) } return &cfg, nil } func main() { cfg := &ScanConfig{ Targets: []Target{ { IP: "192.168.1.1", PortRanges: []PortRange{ {Start: 1, End: 1024}, {Start: 8000, End: 9000}, }, }, }, Timeout: 5, Workers: 100, OutputFile: "natijalar.json", } if err := saveConfig(cfg, "config.json"); err != nil { fmt.Println("Saqlashda xato:", err) return } fmt.Println("Konfiguratsiya saqlandi: config.json") loaded, err := loadConfig("config.json") if err != nil { fmt.Println("O'qishda xato:", err) return } fmt.Printf("Yuklandi: %d target\n", len(loaded.Targets)) for _, t := range loaded.Targets { fmt.Printf(" %s — %d port oraliq\n", t.IP, len(t.PortRanges)) } } ``` Saqlangan `config.json` fayl: ```json { "targets": [ { "ip": "192.168.1.1", "port_ranges": [ {"start": 1, "end": 1024}, {"start": 8000, "end": 9000} ] } ], "timeout": 5, "workers": 100, "output_file": "natijalar.json" } ``` ## Eng yaxshi amaliyotlar ```go // Har doim struct tag yozing — field nomi o'zgarganda JSON kabi emas type User struct { ID int `json:"id"` Name string `json:"name"` } // Xatoni ignore qilmang data, err := json.Marshal(obj) if err != nil { return fmt.Errorf("JSON encoding: %w", err) } // Katta ma'lumot uchun Encoder/Decoder (ioutil.ReadAll + Marshal emas) json.NewDecoder(resp.Body).Decode(&result) ``` ## Qisqacha — eslab qoling 1. `json.Marshal` — struct → JSON. `json.Unmarshal` — JSON → struct (pointer bilan). 2. **Struct tag** `json:"name,omitempty"` — JSON kalit nomini va ixtiyoriy maydonni boshqarish. 3. `json:"-"` — password va ichki ma'lumotlarni JSON'dan yashirish. 4. **Encoder/Decoder** — katta fayl va HTTP stream uchun, xotirani tejaydi. 5. **Custom MarshalJSON/UnmarshalJSON** — standart format yetmasa. 6. **YAML/TOML** — konfiguratsiya fayllar uchun, tashqi kutubxona kerak. ## Modul 2 yakunlandi Go asoslarini to'liq o'rganib chiqdingiz: muhit sozlash, ma'lumot turlari, boshqaruv strukturalari, goroutine va channel'lar, xato boshqarish, va ma'lumot serializatsiyasi. Keyingi modulda real hujum vositalarini quramiz: TCP skaner, HTTP klient, DNS razvedka. Hozirgi bilimlaringiz bu vositalarning asosi.

Strukturalashgan Ma'lumotlar: Go'da Data Serialization Superpower'i