इस नोट में, हम सीखेंगे कि एक रन फ़ंक्शन के मशीन कोड को सीधे रनटाइम में कैसे प्राप्त करें, एक डिस्सेम्बलर का उपयोग करके इसे प्रिंट करें, और जिस तरह से हम बिना कॉल किए फ़ंक्शन के पते को प्राप्त करने जैसे कई तरकीबों का पता लगाएंगे।

चेतावनी : यह लघु-लेख आपको उपयोगी कुछ भी नहीं सिखाएगा।

जाओ में समारोह मूल्य

सबसे पहले, यह निर्धारित करें कि एक गो फ़ंक्शन क्या है और हमें फ़ंक्शन मान की अवधारणा की आवश्यकता क्यों है।

यह गो 1.1 फ़ंक्शन कॉल दस्तावेज़ द्वारा सबसे अच्छी तरह से समझाया गया है। दस्तावेज़ नया नहीं है, लेकिन इसमें अधिकांश जानकारी अभी भी प्रासंगिक है।

निम्नतम स्तर पर, यह हमेशा निष्पादन योग्य कोड के लिए एक संकेतक है, लेकिन जब हम अनाम फ़ंक्शन / क्लोजर का उपयोग करते हैं या interface{} रूप में एक फ़ंक्शन पास करते हैं, तो यह सूचक कुछ संरचना के अंदर छिपा होता है।

फ़ंक्शन नाम अपने आप में एक अभिव्यक्ति नहीं है, इसलिए, ऐसा कोड काम नहीं करता है:

 // https://play.golang.org/p/wXeVLU7nLPs package main func add1(x int) int { return 1 } func main() { addr := &add1 println(addr) } 

compile: cannot take the address of add1

लेकिन एक ही समय में, हम एक ही फ़ंक्शन नाम के माध्यम से function value प्राप्त कर सकते हैं:

 // https://play.golang.org/p/oWqv_FQq4hy package main func add1(x int) int { return 1 } func main() { f := add1 // <-------- addr := &f println(addr) } 

यह कोड लॉन्च किया गया है, लेकिन यह स्टैक पर एक स्थानीय वैरिएबल के पते को प्रिंट करेगा, जो कि वास्तव में हम नहीं चाहते थे। लेकिन, जैसा कि ऊपर उल्लेख किया गया है, फ़ंक्शन का पता अभी भी है, आपको बस यह जानने की आवश्यकता है कि इसे कैसे एक्सेस किया जाए।

reflect पैकेज सफलतापूर्वक लागू करने के लिए इस कार्यान्वयन विवरण पर निर्भर करता है। reflect.Value.Call() । वहाँ (प्रतिबिंबित / makefunc.go) आप फ़ंक्शन का पता प्राप्त करने के लिए अगले चरण की जासूसी कर सकते हैं:

 dummy := makeFuncStub code := **(**uintptr)(unsafe.Pointer(&dummy)) 

उपरोक्त कोड एक मूल विचार प्रदर्शित करता है जिसे आप किसी फ़ंक्शन को परिष्कृत कर सकते हैं:

 // funcAddr returns function value fn executable code address. func funcAddr(fn interface{}) uintptr { // emptyInterface is the header for an interface{} value. type emptyInterface struct { typ uintptr value *uintptr } e := (*emptyInterface)(unsafe.Pointer(&fn)) return *e.value } 

add1 फ़ंक्शन add1 को funcAddr(add1) कॉल करके add1 किया जा सकता है।

मशीन फ़ंक्शन कोड का ब्लॉक प्राप्त करना

अब जब हमारे पास फ़ंक्शन के मशीन कोड की शुरुआत का पता है, तो हम फ़ंक्शन के पूरे मशीन कोड को प्राप्त करना चाहते हैं। यहां आपको यह निर्धारित करने में सक्षम होने की आवश्यकता है कि वर्तमान फ़ंक्शन का कोड कहां समाप्त होता है।

यदि x86 आर्किटेक्चर ने निश्चित-लंबाई निर्देश दिए थे, तो यह इतना मुश्किल नहीं होगा और कई उत्तराधिकारी हमारी मदद कर सकते हैं, जिनमें से:

• एक नियम के रूप में, फ़ंक्शन कोड के अंत में INT3 निर्देशों से एक बीट है। यह फ़ंक्शन कोड के अंत के लिए एक अच्छा मार्कर है, लेकिन यह गायब हो सकता है।
• स्टैक के लिए एक गैर-शून्य फ्रेम वाले कार्यों में एक प्रोलॉग होता है जो यह जांचता है कि क्या इस स्टैक को विस्तारित करने की आवश्यकता है। यदि हाँ, तो फ़ंक्शन कोड के तुरंत बाद कोड के लिए एक कूद किया जाता है, और फिर फ़ंक्शन की शुरुआत के लिए एक कूद। जिस कोड में हम रुचि रखते हैं, वह मध्य में होगा।

लेकिन आपको निर्देशों को ईमानदारी से डिकोड करने की आवश्यकता होगी, क्योंकि एक बाइट-दर-पास दूसरे निर्देश के अंदर INT3 बाइट पा सकते हैं। स्किप करने के लिए एक निर्देश की लंबाई की गणना करना भी इतना आसान नहीं है, क्योंकि यह x86, बेबी है ।

runtime पैकेज के संदर्भ में एक फ़ंक्शन का पता कभी-कभी फ़ंक्शन के अंदर कहीं और पते का उपयोग करने की क्षमता पर जोर देने के लिए, PC को कहा जाता है, और न केवल फ़ंक्शन का प्रवेश बिंदु। funcAddr परिणाम का उपयोग funcAddr तर्क के रूप में किया जा सकता है। funcAddr runtime.FuncForPC() फ़ंक्शन को funcAddr प्राप्त करने के लिए। फ़ंक्शन को कॉल किए बिना। असुरक्षित नए साल के परिवर्तनों के माध्यम से, हम runtime._func तक पहुँच सकते हैं। runtime._func , जो जानकारीपूर्ण है, लेकिन बहुत उपयोगी नहीं है: फ़ंक्शन कोड ब्लॉक के आकार के बारे में कोई जानकारी नहीं है।

ऐसा लगता है कि ईएलएफ की मदद के बिना हम सामना नहीं कर सकते।

उन प्लेटफ़ॉर्म के लिए जहां एक्ज़ीक्यूटेबल्स का एक अलग प्रारूप है, अधिकांश लेख प्रासंगिक रहेंगे, लेकिन आपको debug/elf का उपयोग करने की आवश्यकता नहीं होगी, लेकिन debug से एक और पैकेज।

ईएलएफ जो आपके कार्यक्रम में छिपा है

हमें जो जानकारी चाहिए वह पहले से ही ईएलएफ फ़ाइल के मेटाडेटा में निहित है।

os.Args[0] माध्यम से os.Args[0] हम निष्पादन योग्य फ़ाइल को स्वयं एक्सेस कर सकते हैं, और पहले से ही प्रतीक तालिका प्राप्त कर सकते हैं।

 func readELF() (*elf.File, error) { f, err := os.Open(os.Args[0]) if err != nil { return nil, fmt.Errorf("open argv[0]: %w", err) } return elf.NewFile(f) } 

elf.File अंदर एक चरित्र के लिए खोजें

सभी वर्णों को File.Symbols() विधि का उपयोग करके File.Symbols() किया जा सकता है। यह विधि लौटाती है []elf.Symbol , जिसमें Symbol.Size फ़ील्ड शामिल है - यह "फ़ंक्शन आकार" है जिसे हम Symbol.Size । Symbol.Value फ़ील्ड को funcAddr द्वारा funcAddr गए मान से मेल खाना चाहिए।

आप वांछित प्रतीक (पते) ( Symbol.Value ) या नाम ( Symbol.Name ) द्वारा खोज सकते हैं। यदि वर्ण नाम से क्रमबद्ध होते हैं, तो sort.Search() संभव होगा। sort.Search() , लेकिन यह ऐसा नहीं है:

प्रतीकों को उस क्रम में सूचीबद्ध किया जाएगा जो वे फ़ाइल में दिखाई देते हैं।

यदि आपको अक्सर तालिका में वर्ण खोजने की आवश्यकता होती है, तो आपको एक अतिरिक्त सूचकांक बनाना चाहिए, उदाहरण के लिए, map[string]*elf.Symbol या map[uintptr]*elf.Symbol ।

चूंकि हम पहले से ही जानते हैं कि किसी फ़ंक्शन का पता उसके मूल्य से कैसे प्राप्त किया जाए, तो हम उसकी खोज करेंगे:

 func elfLookup(f *elf.File, value uint64) *elf.Symbol { symbols, err := f.Symbols() if err != nil { return nil } for _, sym := range symbols { if sym.Value == value { return &sym } } return nil } 

नोट : काम करने के लिए इस दृष्टिकोण के लिए, हमें एक चरित्र तालिका चाहिए। यदि बाइनरी को ` -ldflags "-s" 'के साथ बनाया गया है, तो elfLookup() हमेशा nil लौटेगा। यदि आप go run माध्यम से प्रोग्राम go run तो आप उसी समस्या का सामना कर सकते हैं। लेख से उदाहरण के लिए, निष्पादन योग्य फ़ाइलों को प्राप्त करने के लिए ' go build ' या ' go install ' करने की सिफारिश की जाती है।

मशीन फ़ंक्शन कोड प्राप्त करना

निष्पादन योग्य कोड के पते की सीमा जानने के बाद, यह केवल सुविधाजनक प्रसंस्करण के लिए []byte के रूप में इसे बाहर निकालना है।

 func funcCode(addr uintptr) ([]byte, error) { elffile, err := readELF() if err != nil { return nil, fmt.Errorf("read elf: %w", err) } sym := elfLookup(elffile, uint64(addr)) if sym == nil { return nil, fmt.Errorf("can't lookup symbol for %x", addr) } code := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{ Data: addr, Len: int(sym.Size), Cap: int(sym.Size), })) return code, nil } 

यह कोड जानबूझकर प्रदर्शन के लिए सरल बनाया गया है। आपको हर बार ELF नहीं पढ़ना चाहिए और इसकी मेज पर एक रेखीय खोज करनी चाहिए।

funcCode() फ़ंक्शन का परिणाम मशीन फ़ंक्शन कोड के बाइट्स के साथ एक टुकड़ा है। उसे funcAddr() कॉल funcAddr() परिणाम funcAddr() करना चाहिए।

 code, err := funcCode(funcAddr(add1)) if err != nil { log.Panicf("can't get function code: %v", err) } fmt.Printf("% x\n", code) // => 48 8b 44 24 08 48 ff c0 48 89 44 24 10 c3 

मशीन कोड जुदा करना

मशीन कोड को पढ़ने के लिए आसान बनाने के लिए, हम एक डिस्सेम्बलर का उपयोग करेंगे।

मैं प्रोजेक्ट्स zydis और Intel XED से सबसे ज्यादा परिचित हूं , इसलिए सबसे पहले मेरी पसंद उन पर पड़ती है।

Go के लिए, आप go-zydis बाइंडिंग ले सकते हैं, जो कि हमारे कार्य के लिए पर्याप्त और आसान है।

आइए हम "मशीन निर्देशों को दरकिनार" के अमूर्त वर्णन करते हैं, जिसकी मदद से अन्य कार्यों को लागू करना संभव है:

 func walkDisasm(code []byte, visit func(*zydis.DecodedInstruction) error) error { dec := zydis.NewDecoder(zydis.MachineMode64, zydis.AddressWidth64) buf := code for len(buf) > 0 { instr, err := dec.Decode(buf) if err != nil { return err } if err := visit(instr); err != nil { return err } buf = buf[int(instr.Length):] } return nil } 

यह फ़ंक्शन इनपुट के रूप में एक मशीन कोड स्लाइस लेता है और प्रत्येक डिकोड किए गए निर्देश के लिए कॉलबैक फ़ंक्शन को कॉल करता है।

इसके आधार पर, हम printDisasm लिख सकते हैं printDisasm हमें printDisasm :

 func printDisasm(code []byte) error { const ZYDIS_RUNTIME_ADDRESS_NONE = math.MaxUint64 formatter, err := zydis.NewFormatter(zydis.FormatterStyleIntel) if err != nil { return err } return walkDisasm(code, func(instr *zydis.DecodedInstruction) error { s, err := formatter.FormatInstruction(instr, ZYDIS_RUNTIME_ADDRESS_NONE) if err != nil { return err } fmt.Println(s) return nil }) } 

यदि हम add1 फ़ंक्शन add1 पर printDisasm चलाते हैं, तो हमें लंबे समय से प्रतीक्षित परिणाम मिलता है:

 mov rax, [rsp+0x08] inc rax mov [rsp+0x10], rax ret 

परिणाम मान्यता

अब हम यह सुनिश्चित करने का प्रयास करेंगे कि पिछले अनुभाग में प्राप्त कोडांतरक कोड सही है।

चूंकि हमारे पास पहले से ही एक संकलित बाइनरी है, आप गो के साथ आपूर्ति की गई objdump उपयोग कर सकते हैं:

 $ go tool objdump -s 'add1' exe TEXT main.add1(SB) example.go example.go:15 0x4bb760 488b442408 MOVQ 0x8(SP), AX example.go:15 0x4bb765 48ffc0 INCQ AX example.go:15 0x4bb768 4889442410 MOVQ AX, 0x10(SP) example.go:15 0x4bb76d c3 RET 

सब कुछ परिवर्तित होता है, केवल वाक्यविन्यास थोड़ा अलग है, जो अपेक्षित है।

विधि के भाव

यदि हमें विधियों के साथ ऐसा करने की आवश्यकता है, तो फ़ंक्शन नाम के बजाय हम विधि अभिव्यक्ति का उपयोग करेंगे।

मान लें कि हमारा add1 वास्तव में एक फ़ंक्शन नहीं है, लेकिन एक add1 टाइप विधि है:

 type adder struct{} func (adder) add1(x int) int { return x + 2 } 

तब फ़ंक्शन का पता प्राप्त करने के लिए कॉल funcAddr(adder.add1) तरह funcAddr(adder.add1) देगा।

निष्कर्ष

मैं दुर्घटना से नहीं इन चीजों के लिए आया था और, शायद, निम्नलिखित लेखों में से एक में मैं आपको बताऊंगा कि इन सभी तंत्रों का उपयोग करने की योजना कैसे बनाई गई थी। इस बीच, मैं इस लेख को इस बात का सतही वर्णन करने का प्रस्ताव करता हूं कि runtime और फंक्शन वैल्यू के माध्यम से हमारे गो फ़ंक्शंस reflect कैसे reflect ।

प्रयुक्त संसाधनों की सूची:

• 1.1 समारोह कॉल जाओ
• गोलंग एक्सेबल्स का विश्लेषण
• "आंतरिक एबीआई" डिज़ाइन पर जाएं