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

परिचय

Habré पर पहले से ही द्विआधारी स्वरूपों के रिवर्स इंजीनियरिंग के बारे में और .class फ़ाइल के बायोटेक संरचना के अध्ययन के बारे में कई लेख थे:
स्थिरांक का पूल
जावा बाइटकोड फंडामेंटल ,
जावा बाइटकोड "हैलो वर्ल्ड" ,
JVM आदि के लिए बायटेकोड से नमस्ते विश्व
शोधकर्ता के पास एक अज्ञात बाइनरी प्रोटोकॉल से निपटने या बाइनरी संरचना को खोदने का कार्य है जिसके लिए एक विनिर्देश है।

बाइनरी फॉरमेट में मेरी रुचि तब भी पैदा हुई जब मैं एक छात्र था और लिनक्स फाइल सिस्टम ड्राइवर के विकास पर एक टर्म पेपर लिखा था। कुछ साल बाद मैंने फॉरेंसिक विशेषज्ञों के लिए लिनक्स की मूल बातें पर व्याख्यान दिया - पुराने दिनों में लिनक्स एक नवीनता और एक युवा विशेषज्ञ था, जो विश्वविद्यालय के बाद वयस्क विशेषज्ञों को बहुत सी नई चीजें बता सकता था। मुझे बता रहे हैं कि dd का उपयोग करके डिस्क से डंप कैसे हटाया जाए, और अध्ययन के लिए छवि को किसी अन्य कंप्यूटर से कनेक्ट करने के बाद, मैंने महसूस किया कि डिस्क छवि में बहुत सारी रोचक जानकारी है। यदि आप फ़ाइल सिस्टम प्रारूप के लिए विनिर्देशन जानते हैं और उपयुक्त उपकरण थे, तो यह जानकारी बिना इमेज (हुह, माउंट-लूप ...) को बढ़ाए बिना भी निकाली जा सकती है। दुर्भाग्य से, मेरे पास ऐसे उपकरण नहीं थे।

कुछ वर्षों के बाद, मुझे जावा लाइब्रेरी को विघटित करने की आवश्यकता थी। उन दिनों कोई जेडी जीयूआई नहीं था, साथ ही एक वैचारिक डिकंपाइलर भी था, लेकिन जेएडी था। मेरी लाइब्रेरी के लिए, JAD ने त्रुटि संदेशों के साथ जावा ऑपकोड का मिश्रण तैयार किया। इसके अलावा, JAD ने एनोटेशन का समर्थन नहीं किया, और जावा 6 में, जो तब दिखाई दिया, उन्हें पूर्ण करने के लिए उपयोग किया गया था। जावा वर्चुअल मशीन विनिर्देशन के साथ सशस्त्र, मैंने शुरू किया ...

विचार

मुझे बाइनरी संरचनाओं और एक सार्वभौमिक लोडर का वर्णन करने के लिए एक सार्वभौमिक तंत्र की आवश्यकता थी। लोडर, विवरण का उपयोग करते हुए, बाइनरी डेटा को मेमोरी में पढ़ेगा। आपको आमतौर पर संख्याओं, तारों, डेटा सरणियों और यौगिक संरचनाओं से निपटना पड़ता है। संख्याओं के साथ सब कुछ सरल है - उनकी एक निश्चित लंबाई है - 1, 2, 4 या 8 बाइट्स और भाषा में उपलब्ध डेटा प्रकारों के लिए तुरंत मैप किया जा सकता है। उदाहरण के लिए: बाइट, शॉर्ट, इंट, जावा के लिए लंबा। एक बाइट से अधिक संख्यात्मक प्रकारों के लिए, एक बाइट ऑर्डर मार्कर (तथाकथित बिगइंडियन / लिटिलएंडिआंग प्रतिनिधित्व) प्रदान किया जाना चाहिए।

स्ट्रिंग्स के साथ यह अधिक कठिन है - वे विभिन्न एन्कोडिंग (एएससीआईआई, यूनिकोडे) में हो सकते हैं, एक निश्चित या परिवर्तनीय लंबाई है। एक निश्चित लंबाई वाली स्ट्रिंग को बाइट्स की एक सरणी के रूप में माना जा सकता है। चर-लंबाई के तार के लिए, आप दो रिकॉर्डिंग विकल्पों का उपयोग कर सकते हैं - स्ट्रिंग की शुरुआत में स्ट्रिंग की लंबाई (पास्कल या लंबाई-उपसर्गों के तार) का संकेत दें या स्ट्रिंग के अंत में इंगित करने के लिए स्ट्रिंग के अंत में एक विशेष चरित्र डालें। शून्य के मूल्य के साथ एक बाइट (तथाकथित शून्य-समाप्त स्प्रिंग्स) इस तरह के संकेत के रूप में उपयोग किया जाता है। दोनों विकल्पों के फायदे और नुकसान हैं, जिनमें से एक चर्चा इस लेख के दायरे से परे है। यदि आकार शुरुआत में निर्दिष्ट किया जाता है, तो प्रारूप विकसित करते समय, आपको अधिकतम स्ट्रिंग लंबाई निर्धारित करने की आवश्यकता होती है: हमें लंबाई मार्कर को आवंटित करने के लिए कितने बाइट्स की आवश्यकता है: यह निर्भर करता है: 2 ⁸ - 1 एक बाइट के लिए, 2 ¹⁶ - 1 दो बाइट्स के लिए।

हम समग्र डेटा संरचनाओं को अलग-अलग वर्गों में भेद करेंगे, संख्या और तारों के अपघटन को जारी रखेंगे।

.Class फ़ाइल की संरचना

हमें किसी तरह जावा .class फ़ाइल की संरचना का वर्णन करने की आवश्यकता है। नतीजतन, मैं जावा कक्षाओं का एक सेट करना चाहूंगा, जहां प्रत्येक वर्ग में केवल फ़ील्ड्स होते हैं जो अध्ययन किए जा रहे डेटा संरचना के अनुरूप होते हैं और, संभवतः, स्टर्लिंग () पद्धति को कॉल करते समय मानव-पठनीय रूप में ऑब्जेक्ट को प्रदर्शित करने के लिए सहायक तरीके। स्पष्ट रूप से, मैं किसी फ़ाइल को पढ़ने या लिखने के लिए जिम्मेदार तर्क के अंदर नहीं होना चाहूंगा।

हम जावा वर्चुअल मशीन के विनिर्देश लेते हैं,
जेवीएम विनिर्देश, जावा एसई 12 संस्करण ।
हमें अनुभाग 4 "क्लास फाइल फॉर्मेट" में रुचि होगी।

यह निर्धारित करने के लिए कि किस क्षेत्र को लोड करने के लिए, हम एनोटेशन @FieldOrder (इंडेक्स = ...) का परिचय देते हैं। हमें बूटलोडर के लिए फ़ील्ड के क्रम को स्पष्ट रूप से इंगित करने की आवश्यकता है, क्योंकि विनिर्देश हमें उस आदेश पर गारंटी नहीं देते हैं जिसमें वे एक बाइनरी फ़ाइल में सहेजे जाएंगे।

जावा .class फ़ाइल मैजिक नंबर के 4 बाइट्स, जावा के मामूली संस्करण के दो बाइट्स और प्रमुख संस्करण के दो बाइट्स से शुरू होती है। हम int वैरिएबल में मैजिक नंबर और शॉर्ट में माइनर और मेजर वर्जन नंबर पैक करते हैं:

@FieldOrder(index = 1) private int magic; @FieldOrder(index = 2) private short minorVersion; @FieldOrder(index = 3) private short majorVersion; 

.Class फ़ाइल में आगे स्थिर पूल (दो-बाइट चर) और स्थिर पूल का आकार है। हम सरणियों और सूची संरचनाओं के आकार की घोषणा करने के लिए @ContainerSize एनोटेशन का परिचय देते हैं। आकार तय किया जा सकता है (हम इसे मूल्य विशेषता के माध्यम से सेट करेंगे) या एक चर लंबाई है, जो पहले पढ़े गए चर द्वारा निर्धारित किया गया है। इस मामले में, हम "फ़ील्डनाम" विशेषता का उपयोग करेंगे, जो इंगित करता है कि हम किस चर से कंटेनर का आकार पढ़ेंगे। विनिर्देश के अनुसार (धारा 4.1,
"द क्लासफाइल स्ट्रक्चर"), स्थिर पूल का वास्तविक आकार मूल्य से 1 से भिन्न होता है
जो निरंतर_पुल_काउंट को लिखा जाता है:

 u2 constant_pool_count; cp_info constant_pool[constant_pool_count-1]; 

इस तरह के सुधारों के लिए, हम @ContainerSize एनोटेशन में एक अतिरिक्त सुधारक विशेषता पेश करते हैं।
अब हम निरंतर पूल का विवरण जोड़ सकते हैं:

  @FieldOrder(index = 4) private short constantPoolCount; @FieldOrder(index = 5) @ContainerSize(fieldName = "constantPoolCount", corrector = -1) private List<ConstantPoolItem> constantPoolList = new ArrayList<>(); 

  @FieldOrder(index= 1) private int containerSize; @FieldOrder(index = 2) @ContainerSize(filed="actualContainerSize") private List<ContainerItem> containerItems; public int getActualContainerSize(){ return containerSize * 2 + 3; } 

लगातार पूल

स्थिरांक के पूल में प्रत्येक तत्व या तो int, long, float, double, String, या जावा वर्ग के घटकों में से एक का विवरण-वर्ग फ़ील्ड्स (फ़ील्ड्स), विधियाँ, विधि हस्ताक्षर इत्यादि के संगत कंटेंट का विवरण है। यहाँ "स्थिर" शब्द का अर्थ है कोड में प्रयुक्त एक अनाम मान:

 if (intValue > 100500) 

CONSTANT_Integer के उदाहरण के रूप में निरंतर पूल में 100500 का मान दर्शाया जाएगा। जावा 12 के लिए जेवीएम विनिर्देश 17 प्रकारों को परिभाषित करता है जो एक निरंतर पूल में हो सकते हैं।

हमारे कार्यान्वयन में, हम एक क्लास कॉन्स्टेंटपुलिमम बनाएंगे जिसमें एक सिंगल-बाइट फ़ील्ड टैग होगा, जो यह निर्धारित करता है कि हम इस समय किस संरचना को पढ़ रहे हैं। उपरोक्त तालिका में प्रत्येक तत्व के लिए, एक जावा वर्ग, कॉन्स्टेंटपूल इटेम का वंशज बनाएं। एक सार्वभौमिक बाइनरी फ़ाइल लोडर यह निर्धारित करने में सक्षम होना चाहिए कि पहले से पढ़े गए टैग के आधार पर किस वर्ग का उपयोग किया जाना चाहिए।
(सामान्य तौर पर, एक टैग किसी भी प्रकार का एक चर हो सकता है)। इस उद्देश्य के लिए, हैस इनहाइटर इंटरफ़ेस को परिभाषित करें और कॉन्स्टेंटपूल इटेम वर्ग में इस इंटरफ़ेस को लागू करें:

 public interface HasInheritor<T> { public Class<? extends T> getInheritor() throws InheritorNotFoundException; public Collection<Class<? extends T>> getInheritors(); } 

 public class ConstantPoolItem implements HasInheritor<ConstantPoolItem> { private final static Map<Byte, Class<? extends ConstantPoolItem>> m = new HashMap<>(); static { m.put((byte) 7, ClassInfo.class); m.put((byte) 9, FieldRefInfo.class); m.put((byte) 10, MethodRefInfo.class); m.put((byte) 11, InterfaceMethodRefInfo.class); m.put((byte) 8, StringInfo.class); m.put((byte) 3, IntegerInfo.class); m.put((byte) 4, FloatInfo.class); m.put((byte) 5, LongInfo.class); m.put((byte) 6, DoubleInfo.class); m.put((byte) 12, NameAndTypeInfo.class); m.put((byte) 1, Utf8Info.class); m.put((byte) 15, MethodHandleInfo.class); m.put((byte) 16, MethodTypeInfo.class); m.put((byte) 17, DynamicInfo.class); m.put((byte) 18, InvokeDynamicInfo.class); m.put((byte) 19, ModuleInfo.class); m.put((byte) 20, PackageInfo.class); } @FieldOrder(index = 1) private byte tag; @Override public Class<? extends ConstantPoolItem> getInheritor() throws InheritorNotFoundException { Class<? extends ConstantPoolItem> clazz = m.get(tag); if (clazz == null) { throw new InheritorNotFoundException(this.getClass().getName(), String.valueOf(tag)); } return clazz; } @Override public Collection<Class<? extends ConstantPoolItem>> getInheritors() { return m.values(); } } 

सार्वभौमिक लोडर आवश्यक वर्ग को तुरंत रोक देगा और पढ़ना जारी रखेगा। एकमात्र शर्त: उत्तराधिकारी वर्गों में अनुक्रमित माता-पिता वर्ग के साथ अंत-टू-एंड नंबरिंग होना चाहिए। इसका मतलब यह है कि सभी कॉन्स्टेंटपूल इटेम, फील्डऑर्डर-व्युत्पन्न वर्गों में, एनोटेशन में एक से अधिक सूचकांक होना चाहिए, क्योंकि मूल कक्षा में हम पहले से ही "1" नंबर के साथ टैग फ़ील्ड पढ़ते हैं।

.Class फ़ाइल की संरचना (जारी)

.Class फ़ाइल में निरंतर पूल के तत्वों की सूची के बाद एक दो-बाइट पहचानकर्ता है जो इस वर्ग के विवरण को परिभाषित करता है - चाहे वह वर्ग एक एनोटेशन हो, एक इंटरफ़ेस, एक सार वर्ग, क्या इसमें अंतिम ध्वज है, आदि। इसके बाद एक दो-बाइट पहचानकर्ता (निरंतर पूल में एक तत्व का संदर्भ) होता है जो इस वर्ग को परिभाषित करता है। यह पहचानकर्ता ClassInfo प्रकार के एक तत्व को इंगित करता है। किसी दिए गए वर्ग के लिए सुपरक्लास को एक समान तरीके से परिभाषित किया जाता है (वर्ग परिभाषा में "विस्तार" शब्द के बाद क्या संकेत दिया गया है)। जिन वर्गों के पास स्पष्ट रूप से सुपरक्लास नहीं हैं, उनके लिए इस क्षेत्र में ऑब्जेक्ट क्लास का संदर्भ है।

जावा में, किसी भी वर्ग में केवल एक सुपरक्लास हो सकता है, लेकिन संख्या
इस श्रेणी को लागू करने के लिए कई इंटरफेस हो सकते हैं:

  @FieldOrder(index = 9) private short interfacesCount; @FieldOrder(index = 10) @ContainerSize(fieldName = "interfacesCount") private List<Short> interfaceIndexList; 

InterfaceIndexList में प्रत्येक तत्व निरंतर पूल में एक तत्व के लिए एक लिंक का प्रतिनिधित्व करता है (जैसा कि निर्दिष्ट किया गया है
सूचकांक में ClassInfo प्रकार के साथ एक तत्व होना चाहिए)।
वर्ग चर (गुण, क्षेत्र) और विधियों को संबंधित सूचियों द्वारा दर्शाया जाता है:

  @FieldOrder(index = 11) private short fieldsCount; @FieldOrder(index = 12) @ContainerSize(fieldName = "fieldsCount") private List<Field> fieldList; @FieldOrder(index = 13) private short methodsCount; @FieldOrder(index = 14) @ContainerSize(fieldName = "methodsCount") private List<Method> methodList; 

जावा .class फ़ाइल के विवरण में अंतिम तत्व वर्ग विशेषताओं की सूची है। वर्ग, नेस्टेड कक्षाओं आदि से संबंधित स्रोत फ़ाइल का वर्णन करने वाले गुण यहां सूचीबद्ध किए जा सकते हैं।

जावा बायटेकोड बड़े-एंडियन प्रतिनिधित्व में संख्यात्मक डेटा के साथ काम करता है, हम इस प्रतिनिधित्व का डिफ़ॉल्ट रूप से उपयोग करेंगे। छोटे-एंडियन संख्या वाले द्विआधारी प्रारूपों के लिए, हम लिटिलएंडियन एनोटेशन का उपयोग करेंगे। उन स्ट्रिंग्स के लिए जिनकी पूर्वनिर्धारित लंबाई नहीं है, लेकिन
टर्मिनल चरित्र से पहले पढ़े जाते हैं (जैसे सी-जैसे शून्य-समाप्त स्ट्रिंग्स) हम उपयोग करेंगे
@StringTerminator एनोटेशन:

  @FieldOrder(index = 2) @StringTerminator(0) private String nullTerminatedString; 

कभी-कभी अंतर्निहित कक्षाओं में आपको उच्च स्तर से जानकारी अग्रेषित करने की आवश्यकता होती है। MethodList में विधि ऑब्जेक्ट में उस वर्ग के नाम के बारे में जानकारी नहीं है जिसमें वह स्थित है, इसके अलावा, विधि ऑब्जेक्ट में उसका नाम और मापदंडों की सूची शामिल नहीं है। यह सब जानकारी निरंतर पूल में तत्वों पर सूचकांक के रूप में प्रस्तुत की जाती है। यह एक वर्चुअल मशीन के लिए पर्याप्त है, लेकिन हम इनस्ट्रिंग () विधियों को लागू करना चाहते हैं ताकि वे मानव-अनुकूल रूप में विधि के बारे में जानकारी प्रदर्शित करें, न कि निरंतर पूल में तत्वों पर अनुक्रमित के रूप में। ऐसा करने के लिए, विधि वर्ग को कॉन्स्टैंटपूलिस्ट के संदर्भ में और इस क्लैसिंडेक्स के मान के साथ एक चर पर जाना चाहिए। घोंसले के शिकार के अंतर्निहित स्तरों से लिंक पारित करने में सक्षम होने के लिए, हम इंजेक्शन एनोटेशन का उपयोग करेंगे:

  @FieldOrder(index = 14) @ContainerSize(fieldName = "methodsCount") @Inject(fieldName = "constantPoolList") @Inject(fieldName = "thisClassIndex") private List<Method> methodList; 

वर्तमान वर्ग (ClassFile) में निरंतरपूलिस्ट और इसक्लासइंडेक्स वैरिएबल के लिए गेट्टर विधियां कहा जाएगा, और प्राप्त वर्ग (इस मामले में विधि) में, सेटर विधियों को बुलाया जाएगा (यदि वे मौजूद हैं)।

यूनिवर्सल बूटलोडर

तो, हमारे पास एक हस इनहेरीटर इंटरफेस और पांच एनोटेशन @FieldOrder, @ContainerSize, LittleEndian , Inject और @StringTerminator हैं, जो हमें एब्सट्रैक्शन के उच्च स्तर पर बाइनरी संरचनाओं का वर्णन करने की अनुमति देते हैं। एक औपचारिक विवरण होने पर, हम इसे सार्वभौमिक लोडर को पास कर सकते हैं, जो वर्णित संरचना को तुरंत कर सकता है, बाइनरी फ़ाइल को पार्स कर सकता है और इसे मेमोरी में पढ़ सकता है।

परिणामस्वरूप, हमें इस कोड का उपयोग करने में सक्षम होना चाहिए:

  ClassFile classFile; try (InputStream is = new FileInputStream(inputFileName)) { Loader loader = new InputStreamLoader(is); classFile = (ClassFile) loader.load(); } 

दुर्भाग्य से, जावा प्लेटफ़ॉर्म डेवलपर्स पूल में आठ-बाइट मूल्यों के लिए थोड़ा बहुत परिष्कृत हैं।
स्थिरांक दो कोशिकाओं के लिए प्रदान किए जाते हैं, पहली कोशिका में एक मान होना चाहिए, और दूसरा रहता है
खाली करें। यह लंबे और दोहरे स्थिरांक पर लागू होता है।

इन विशिष्ट मामलों को संभालने के लिए, हम @EntrySize एनोटेशन जोड़ेंगे, जिसका हम उपयोग करेंगे,
आठ बाइट स्थिरांक टैग करने के लिए:

 @EntrySize(value = 2, index = 1) public class EightByteNumberInfo extends ConstantPoolItem { @FieldOrder(index = 2) private int highBytes; @FieldOrder(index = 3) private int lowBytes; } 

मूल्य विशेषता उन कोशिकाओं की संख्या को इंगित करती है जो तत्व कब्जा करेंगे, सूचकांक - तत्व का सूचकांक,
जिसमें मान होता है। LongInfo और DoubleInfo वर्ग EightByteNumberInfo वर्ग का विस्तार करेंगे।
यूनिवर्सल बूटलोडर को @EntrySize एनोटेशन का समर्थन करने वाले कार्यात्मक के साथ विस्तारित करने की आवश्यकता होगी।

  public ClassFileLoader(String fileName) { try { File f = new File(fileName); FileInputStream fis = new FileInputStream(f); loader = new EntrySizeSupportLoader(fis); } catch (FileNotFoundException e) { throw new RuntimeException(e); } } 

ClassFileLoader के साथ कक्षा को लोड करने के बाद, आप डिबगर को रोक सकते हैं और IDE में चर निरीक्षक में लोड किए गए वर्ग की जांच कर सकते हैं।

वर्ग फ़ाइल इस तरह दिखाई देगी:

और लगातार पूल इस तरह है:

निष्कर्ष

जो कोई भी अंत तक पढ़ सकता है, वह अपने हाथों से जावा बाइटकोड को चुन सकता है। गितुब में जाने के लिए स्वतंत्र महसूस करें और जावा कक्षाओं के एक सेट के रूप में जावा वर्ग फ़ाइल का विवरण डाउनलोड करें: https://github.com/esavin/annotate4j-classfile । यूनिवर्सल लोडर और एनोटेशन यहाँ हैं: https://github.com/esavin/annotate4j-core

संकलित वर्ग फ़ाइल डाउनलोड करने के लिए, annotate4j.classfile.loader.ClassFileLoader लोडर का उपयोग करें।

अधिकांश कोड जावा 6 के लिए लिखे गए थे, मैंने केवल निरंतर पूल को आधुनिक संस्करणों के लिए अनुकूलित किया। मेरे पास जावा ओपकोड के लिए जावा लोडर को पूरी तरह से लागू करने की ताकत और इच्छा नहीं थी, इसलिए इस हिस्से में केवल छोटे विकास हैं।

इस लाइब्रेरी (मुख्य भाग) का उपयोग करके मैं होल्टर मॉनिटरिंग डेटा (दैनिक हृदय गतिविधि का ईसीजी अध्ययन) के साथ बाइनरी फ़ाइल को वापस करने में कामयाब रहा। दूसरी ओर, मैं डेल्फी में लिखे गए एक लेखा प्रणाली के बाइनरी प्रोटोकॉल को डिक्रिप्ट नहीं कर सका। मुझे समझ नहीं आया कि तारीखें कैसे प्रसारित होती हैं, और कभी-कभी ऐसी स्थिति उत्पन्न होती है जब वास्तविक डेटा पिछले मूल्यों पर निर्मित संरचना के अनुरूप नहीं होता है।

मैंने ELF प्रारूप (यूनिक्स / लिनक्स पर रन करने योग्य प्रारूप) के लिए जावा वर्ग फ़ाइल के समान एक मॉडल बनाने की कोशिश की, लेकिन मैं विनिर्देश को पूरी तरह से समझ नहीं सका - यह मेरे लिए बहुत अस्पष्ट हो गया। एक ही भाग्य जेपीईजी और बीएमपी प्रारूपों को परिभाषित करता है - हर समय जब मैं विनिर्देश को समझने में कुछ कठिनाइयों के साथ आया था।