GHIDRA का आधुनिकीकरण। रम सेगा मेगा ड्राइव के लिए लोडर

अभिवादन, साथियों। मैंने अभी तक खुले-स्रोत-स्रोत GHIDRA बारे में नहीं सुना है, शायद केवल एक बहरा / अंधा / गूंगा / कोई इंटरनेट रिवर्स इंजीनियर नहीं है। बॉक्स के बाहर इसकी क्षमताएं अद्भुत हैं: सभी समर्थित प्रोसेसर के लिए डीकॉम्पोलर, नए आर्किटेक्चर का सरल जोड़ (आईआर में सक्षम रूपांतरण के कारण तत्काल सक्रिय विघटन के साथ), लिपियों का एक गुच्छा जो जीवन को सरल बनाता है, Undo / Redo करने की संभावना / और यह प्रदान की गई सभी सुविधाओं का केवल एक बहुत छोटा हिस्सा है। यह कहने के लिए कि मैं प्रभावित था, लगभग कुछ भी नहीं कहना है।

इसलिए, इस लेख में मैं आपको बताना चाहूंगा कि मैंने GHIDRA लिए अपना पहला मॉड्यूल कैसे लिखा - Sega Mega Drive / Genesis लिए गेम के लिए एक रम लोडर। इसे लिखने के लिए मुझे ज़रूरत थी ... बस कुछ घंटे! चलो चलते हैं।

हम विकास का माहौल तैयार करते हैं

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

प्लगइन को स्थापित करने के लिए, Java लिए Eclipse डाउनलोड करें, Help क्लिक करें -> Install New Software... , फिर Add बटन पर क्लिक करें, और Archive... बटन का उपयोग करके प्लगइन के साथ संग्रह चयन संवाद खोलें। GhidraDev साथ संग्रह $(GHIDRA)/Extensions/Eclipse/GhidraDev । इसे चुनें, Add बटन पर क्लिक करें।

दिखाई देने वाली सूची में, Ghidra पर एक daw Ghidra , Next > पर क्लिक करें Next > , समझौतों से सहमत हों, Install Anyway क्लिक Install Anyway (क्योंकि प्लगइन का हस्ताक्षर नहीं है), और Eclipse पुनः आरंभ करें।

कुल मिलाकर, एक नया GhidraDev आइटम आपकी परियोजनाओं के सुविधाजनक निर्माण और वितरण के लिए IDE GhidraDev में दिखाई देगा (बेशक, आप नए Eclipse परियोजनाओं के लिए सामान्य विज़ार्ड के माध्यम से भी बना सकते हैं)। इसके अलावा, हमारे पास विकसित प्लग-इन या स्क्रिप्ट को डीबग करने का अवसर है।

तो, आइए Eclipse में एक नई परियोजना बनाएं।

लोडर प्रोजेक्ट बनाएं

GhidraDev -> New -> Ghidra Module Project...

हम परियोजना के नाम को इंगित करते हैं (हम इस बात का ध्यान रखते हैं कि Loader प्रकार के शब्दों को फ़ाइल नामों से चिपकाया जाएगा, और क्रम में sega_loaderLoader.java जैसी कुछ भी प्राप्त नहीं करने के लिए, हम उन्हें तदनुसार नाम देते हैं)।

Next > क्लिक करें। यहां हम उन श्रेणियों के सामने डौस रखते हैं जिनकी हमें आवश्यकता होती है। मेरे मामले में, यह केवल एक Loader । Next > क्लिक करें।

यहां हम साथ निर्देशिका के लिए पथ को इंगित करते हैं। Next > क्लिक करें।

GHIDRA पाइथन ( GHIDRA माध्यम से) में स्क्रिप्ट लिखने की अनुमति देता है। मैं Java में लिखूंगा, इसलिए मैं एक दाव नहीं लगाता हूं। मैं Finish दबाता हूं।

एक कोड लिखना

खाली प्रोजेक्ट ट्री प्रभावशाली लगता है:

java कोड वाली सभी फाइलें /src/main/java शाखा में हैं:

getName ()

आरंभ करने के लिए, चलिए बूटलोडर के लिए एक नाम चुनें। getName() विधि इसे लौटाती है:

 @Override public String getName() { return "Sega Mega Drive / Genesis Loader"; } 

findSupportedLoadSpecs ()

findSupportedLoadSpecs() विधि तय करती है (बाइनरी फ़ाइल में निहित डेटा के आधार पर) जो प्रोसेसर मॉड्यूल का उपयोग findSupportedLoadSpecs() लिए किया जाना चाहिए (साथ ही IDA )। GHIDRA शब्दावली में GHIDRA इसे Compiler Language कहा जाता है। इसमें शामिल हैं: प्रोसेसर, एंडियननेस, बिटनेस और कंपाइलर (यदि ज्ञात हो)।

यह विधि समर्थित आर्किटेक्चर और भाषाओं की सूची लौटाती है। यदि डेटा गलत प्रारूप में है, तो हम बस एक खाली सूची लौटाते हैं।

तो, Sega Mega Drive के मामले में, शब्द " SEGA " सबसे अधिक बार हेडर के ऑफसेट 0x100 पर मौजूद होता है (यह एक शर्त नहीं है, लेकिन 99% मामलों में पूरा होता है)। आपको यह जांचने की आवश्यकता है कि क्या यह लाइन आयातित फ़ाइल में है। ऐसा करने के लिए, ByteProvider provider को findSupportedLoadSpecs() ByteProvider provider , जिसके साथ हम फ़ाइल के साथ काम करेंगे।

किसी फ़ाइल से डेटा पढ़ने की सुविधा के लिए हम एक BinaryReader ऑब्जेक्ट बनाते हैं:

 BinaryReader reader = new BinaryReader(provider, false); 

इस मामले में false तर्क Big Endian का उपयोग पढ़ते समय इंगित करता है। अब रेखा पढ़ते हैं। ऐसा करने के लिए, reader ऑब्जेक्ट की readAsciiString(offset, size) विधि का उपयोग करें:

 reader.readAsciiString(0x100, 4).equals(new String("SEGA")) 

यदि equals() true , तो हम Segov रम के साथ काम कर रहे हैं, और सूची में List<LoadSpec> loadSpecs = new ArrayList<>(); मोटोरोला m68k जोड़ना संभव होगा। ऐसा करने के लिए, प्रकार की एक नई ऑब्जेक्ट बनाएं LoadSpec , जिसका निर्माता लोडर ऑब्जेक्ट (इस मामले में, this ) को स्वीकार करता है, एक ImageBase जिसमें ROM लोड किया जाएगा, प्रकार का एक ऑब्जेक्ट LanguageCompilerSpecPair और एक झंडा - क्या यह LoadSpec सूची में दूसरों के बीच LoadSpec किया गया है (हां, सूची में हां) एक से अधिक LoadSpec हो सकते हैं)।

LanguageCompilerSpecPair लिए निर्माता प्रारूप निम्नानुसार है:

1. पहला तर्क languageID , " ProcessorName: Endianness: बिट्स: ExactCpu " रूप की एक स्ट्रिंग। मेरे मामले में, यह " 68000: BE: 32: MC68020 " लाइन होना चाहिए (दुर्भाग्य से, वास्तव में MC68000 डिलीवरी में शामिल नहीं है, लेकिन यह ऐसी समस्या नहीं है)। ExactCpu default हो सकता default
2. दूसरा तर्क, compilerSpecID , जिसे आपको यहां निर्दिष्ट करने की आवश्यकता है, को खोजने के लिए निर्देशिका में प्रोसेसर विवरण ( $(GHIDRA)/Ghidra/Processors/68000/data/languages ) के साथ 68000.opinion फ़ाइल में 68000.opinion । हम देखते हैं कि केवल default यहाँ इंगित किया गया है। दरअसल, हम इसका संकेत देते हैं

परिणामस्वरूप, हमारे पास निम्नलिखित कोड हैं (जैसा कि आप देख सकते हैं, अब तक कुछ भी जटिल नहीं है):

 @Override public Collection<LoadSpec> findSupportedLoadSpecs(ByteProvider provider) throws IOException { List<LoadSpec> loadSpecs = new ArrayList<>(); BinaryReader reader = new BinaryReader(provider, false); if (reader.readAsciiString(0x100, 4).equals(new String("SEGA"))) { loadSpecs.add(new LoadSpec(this, 0, new LanguageCompilerSpecPair("68000:BE:32:MC68020", "default"), true)); } return loadSpecs; } 

लोड ()

इस पद्धति में, हम सेगमेंट बनाएंगे, इनपुट डेटा प्रोसेस करेंगे, कोड और पहले से ज्ञात लेबल बनाएंगे। ऐसा करने के लिए, निम्नलिखित वस्तुओं को प्रवेश द्वार पर हमारी मदद के लिए प्रस्तुत किया जाता है:

1. ByteProvider provider : हम पहले से ही उसे जानते हैं। बाइनरी फ़ाइल डेटा के साथ काम करना
2. LoadSpec loadSpec : आर्किटेक्चर का विनिर्देश LoadSpec loadSpec के आयात चरण के दौरान findSupportedLoadSpecs गया है findSupportedLoadSpecs विधि का उपयोग किया गया findSupportedLoadSpecs । यह आवश्यक है यदि, उदाहरण के लिए, हम एक मॉड्यूल में कई डेटा प्रारूपों के साथ काम करने में सक्षम हैं। आराम से
3. List<Option> options : List<Option> options सूची (कस्टम सहित)। मैंने अभी तक उनके साथ काम करना नहीं सीखा है
4. Program program : मुख्य वस्तु जो सभी आवश्यक कार्यक्षमता तक पहुंच प्रदान करती है: लिस्टिंग, पता स्थान, खंड, लेबल, सरणियां बनाना, आदि।
5. MemoryConflictHandler handler और TaskMonitor monitor : हमें शायद ही कभी उनके साथ सीधे काम करना पड़ता है (आमतौर पर, इन वस्तुओं को तैयार तरीकों से गुजरना)
6. MessageLog log : लकड़हारा

तो, शुरुआत के लिए, आइए कुछ ऑब्जेक्ट बनाएं जो GHIDRA संस्थाओं और मौजूदा डेटा के साथ हमारे काम को सरल GHIDRA । निश्चित रूप से, हमें निश्चित रूप से BinaryReader आवश्यकता BinaryReader :

 BinaryReader reader = new BinaryReader(provider, false); 

अगला। यह हमारे लिए बहुत उपयोगी होगा और FlatProgramAPI वर्ग के लगभग पूरे ऑब्जेक्ट को सरल करेगा (आप बाद में देखेंगे कि आप इसके साथ क्या कर सकते हैं):

 FlatProgramAPI fpa = new FlatProgramAPI(program, monitor); 

रम हेडिंग

शुरू करने के लिए, हम यह निर्धारित करेंगे कि एक सामान्य सेगा रम की हेडिंग क्या है। पहले 0x100 बाइट्स में वैक्टरों के लिए 64 DivideByZero पॉइंटर्स की एक तालिका होती है, उदाहरण के लिए: Reset , Trap , DivideByZero , VBLANK और अन्य।

इसके बाद रोमा, क्षेत्रों, ROM और RAM ब्लॉकों की शुरुआत और अंत के पते के साथ संरचना आती है, चेकबॉक्स (क्षेत्र डेवलपर्स के अनुरोध पर चेक किया जाता है, न कि उपसर्ग) और अन्य जानकारी।

आइए इन संरचनाओं के साथ काम करने के लिए java कक्षाएं बनाएं, साथ ही उन डेटा प्रकारों को लागू करने के लिए जिन्हें संरचनाओं की सूची में जोड़ा जाएगा।

VectorsTable

हम एक नया वर्ग VectorsTable , और, ध्यान देते हैं, हम संकेत देते हैं कि यह StructConverter इंटरफेस को लागू करता है। इस वर्ग में हम वैक्टर के पते (भविष्य में उपयोग के लिए) और उनके नाम संग्रहीत करेंगे।

हम वेक्टर नामों और उनकी संख्या की एक सूची घोषित करते हैं:

 private static final int VECTORS_SIZE = 0x100; private static final int VECTORS_COUNT = VECTORS_SIZE / 4; private static final String[] VECTOR_NAMES = { "SSP", "Reset", "BusErr", "AdrErr", "InvOpCode", "DivBy0", "Check", "TrapV", "GPF", "Trace", "Reserv0", "Reserv1", "Reserv2", "Reserv3", "Reserv4", "BadInt", "Reserv10", "Reserv11", "Reserv12", "Reserv13", "Reserv14", "Reserv15", "Reserv16", "Reserv17", "BadIRQ", "IRQ1", "EXT", "IRQ3", "HBLANK", "IRQ5", "VBLANK", "IRQ7", "Trap0", "Trap1", "Trap2", "Trap3", "Trap4", "Trap5", "Trap6", "Trap7", "Trap8", "Trap9", "Trap10", "Trap11", "Trap12", "Trap13","Trap14", "Trap15", "Reserv30", "Reserv31", "Reserv32", "Reserv33", "Reserv34", "Reserv35", "Reserv36", "Reserv37", "Reserv38", "Reserv39", "Reserv3A", "Reserv3B", "Reserv3C", "Reserv3D", "Reserv3E", "Reserv3F" }; 

हम पते और वेक्टर नाम के भंडारण के लिए एक अलग वर्ग बनाते हैं:

 package sega; import ghidra.program.model.address.Address; public class VectorFunc { private Address address; private String name; public VectorFunc(Address address, String name) { this.address = address; this.name = name; } public Address getAddress() { return address; } public String getName() { return name; } } 

वैक्टर की सूची vectors सरणी में संग्रहीत की जाएगी:

 private VectorFunc[] vectors; 

निर्माता के लिए VectorsTable होगा:

1. FlatProgramAPI fpa हाइड्रा के Address डेटा प्रकार के लिए long पते को बदलने के लिए FlatProgramAPI fpa (वास्तव में, यह डेटा प्रकार पते के सरल संख्यात्मक मान को किसी अन्य चिप से FlatProgramAPI fpa पूरक करता है - पता स्थान)
2. BinaryReader reader - रीडिंग यार्ड

toAddr() ऑब्जेक्ट में एक toAddr() विधि है, और reader ने setPointerIndex() और readNextUnsignedInt() । सिद्धांत रूप में, अधिक कुछ भी आवश्यक नहीं है। हमें कोड मिलता है:

 public VectorsTable(FlatProgramAPI fpa, BinaryReader reader) throws IOException { if (reader.length() < VECTORS_COUNT) { return; } reader.setPointerIndex(0); vectors = new VectorFunc[VECTORS_COUNT]; for (int i = 0; i < VECTORS_COUNT; ++i) { vectors[i] = new VectorFunc(fpa.toAddr(reader.readNextUnsignedInt()), VECTOR_NAMES[i]); } } 

toDataType() विधि, जिसे हमें संरचना को लागू करने के लिए ओवरराइड करने की आवश्यकता है, को एक Structure ऑब्जेक्ट वापस करना चाहिए जिसमें संरचना फ़ील्ड के नाम, उनके आकार, और प्रत्येक फ़ील्ड पर टिप्पणियों को घोषित किया जाना चाहिए (आप null उपयोग कर सकते हैं):

 @Override public DataType toDataType() { Structure s = new StructureDataType("VectorsTable", 0); for (int i = 0; i < VECTORS_COUNT; ++i) { s.add(POINTER, 4, VECTOR_NAMES[i], null); } return s; } 

ठीक है, चलो प्रत्येक वैक्टर, या पूरी सूची (बॉयलरप्लेट कोड का एक गुच्छा) प्राप्त करने के तरीकों को लागू करते हैं:

  public VectorFunc[] getVectors() { return vectors; } public VectorFunc getSSP() { if (vectors.length < 1) { return null; } return vectors[0]; } public VectorFunc getReset() { if (vectors.length < 2) { return null; } return vectors[1]; } public VectorFunc getBusErr() { if (vectors.length < 3) { return null; } return vectors[2]; } public VectorFunc getAdrErr() { if (vectors.length < 4) { return null; } return vectors[3]; } public VectorFunc getInvOpCode() { if (vectors.length < 5) { return null; } return vectors[4]; } public VectorFunc getDivBy0() { if (vectors.length < 6) { return null; } return vectors[5]; } public VectorFunc getCheck() { if (vectors.length < 7) { return null; } return vectors[6]; } public VectorFunc getTrapV() { if (vectors.length < 8) { return null; } return vectors[7]; } public VectorFunc getGPF() { if (vectors.length < 9) { return null; } return vectors[8]; } public VectorFunc getTrace() { if (vectors.length < 10) { return null; } return vectors[9]; } public VectorFunc getReserv0() { if (vectors.length < 11) { return null; } return vectors[10]; } public VectorFunc getReserv1() { if (vectors.length < 12) { return null; } return vectors[11]; } public VectorFunc getReserv2() { if (vectors.length < 13) { return null; } return vectors[12]; } public VectorFunc getReserv3() { if (vectors.length < 14) { return null; } return vectors[13]; } public VectorFunc getReserv4() { if (vectors.length < 15) { return null; } return vectors[14]; } public VectorFunc getBadInt() { if (vectors.length < 16) { return null; } return vectors[15]; } public VectorFunc getReserv10() { if (vectors.length < 17) { return null; } return vectors[16]; } public VectorFunc getReserv11() { if (vectors.length < 18) { return null; } return vectors[17]; } public VectorFunc getReserv12() { if (vectors.length < 19) { return null; } return vectors[18]; } public VectorFunc getReserv13() { if (vectors.length < 20) { return null; } return vectors[19]; } public VectorFunc getReserv14() { if (vectors.length < 21) { return null; } return vectors[20]; } public VectorFunc getReserv15() { if (vectors.length < 22) { return null; } return vectors[21]; } public VectorFunc getReserv16() { if (vectors.length < 23) { return null; } return vectors[22]; } public VectorFunc getReserv17() { if (vectors.length < 24) { return null; } return vectors[23]; } public VectorFunc getBadIRQ() { if (vectors.length < 25) { return null; } return vectors[24]; } public VectorFunc getIRQ1() { if (vectors.length < 26) { return null; } return vectors[25]; } public VectorFunc getEXT() { if (vectors.length < 27) { return null; } return vectors[26]; } public VectorFunc getIRQ3() { if (vectors.length < 28) { return null; } return vectors[27]; } public VectorFunc getHBLANK() { if (vectors.length < 29) { return null; } return vectors[28]; } public VectorFunc getIRQ5() { if (vectors.length < 30) { return null; } return vectors[29]; } public VectorFunc getVBLANK() { if (vectors.length < 31) { return null; } return vectors[30]; } public VectorFunc getIRQ7() { if (vectors.length < 32) { return null; } return vectors[31]; } public VectorFunc getTrap0() { if (vectors.length < 33) { return null; } return vectors[32]; } public VectorFunc getTrap1() { if (vectors.length < 34) { return null; } return vectors[33]; } public VectorFunc getTrap2() { if (vectors.length < 35) { return null; } return vectors[34]; } public VectorFunc getTrap3() { if (vectors.length < 36) { return null; } return vectors[35]; } public VectorFunc getTrap4() { if (vectors.length < 37) { return null; } return vectors[36]; } public VectorFunc getTrap5() { if (vectors.length < 38) { return null; } return vectors[37]; } public VectorFunc getTrap6() { if (vectors.length < 39) { return null; } return vectors[38]; } public VectorFunc getTrap7() { if (vectors.length < 40) { return null; } return vectors[39]; } public VectorFunc getTrap8() { if (vectors.length < 41) { return null; } return vectors[40]; } public VectorFunc getTrap9() { if (vectors.length < 42) { return null; } return vectors[41]; } public VectorFunc getTrap10() { if (vectors.length < 43) { return null; } return vectors[42]; } public VectorFunc getTrap11() { if (vectors.length < 44) { return null; } return vectors[43]; } public VectorFunc getTrap12() { if (vectors.length < 45) { return null; } return vectors[44]; } public VectorFunc getTrap13() { if (vectors.length < 46) { return null; } return vectors[45]; } public VectorFunc getTrap14() { if (vectors.length < 47) { return null; } return vectors[46]; } public VectorFunc getTrap15() { if (vectors.length < 48) { return null; } return vectors[47]; } public VectorFunc getReserv30() { if (vectors.length < 49) { return null; } return vectors[48]; } public VectorFunc getReserv31() { if (vectors.length < 50) { return null; } return vectors[49]; } public VectorFunc getReserv32() { if (vectors.length < 51) { return null; } return vectors[50]; } public VectorFunc getReserv33() { if (vectors.length < 52) { return null; } return vectors[51]; } public VectorFunc getReserv34() { if (vectors.length < 53) { return null; } return vectors[52]; } public VectorFunc getReserv35() { if (vectors.length < 54) { return null; } return vectors[53]; } public VectorFunc getReserv36() { if (vectors.length < 55) { return null; } return vectors[54]; } public VectorFunc getReserv37() { if (vectors.length < 56) { return null; } return vectors[55]; } public VectorFunc getReserv38() { if (vectors.length < 57) { return null; } return vectors[56]; } public VectorFunc getReserv39() { if (vectors.length < 58) { return null; } return vectors[57]; } public VectorFunc getReserv3A() { if (vectors.length < 59) { return null; } return vectors[58]; } public VectorFunc getReserv3B() { if (vectors.length < 60) { return null; } return vectors[59]; } public VectorFunc getReserv3C() { if (vectors.length < 61) { return null; } return vectors[60]; } public VectorFunc getReserv3D() { if (vectors.length < 62) { return null; } return vectors[61]; } public VectorFunc getReserv3E() { if (vectors.length < 63) { return null; } return vectors[62]; } public VectorFunc getReserv3F() { if (vectors.length < 64) { return null; } return vectors[63]; } 

GameHeader

हम ऐसा ही करेंगे और एक GameHeader क्लास GameHeader जो कि StructConverter इंटरफ़ेस को लागू करता है।

हम फ़ील्ड सेट करते हैं, इनपुट डेटा की पर्याप्त लंबाई की जाँच करते हैं, हमारे लिए दो नए तरीकों का उपयोग करते हैं readNextByteArray() , readNextUnsignedShort() reader ऑब्जेक्ट का डेटा पढ़ने के लिए, और एक संरचना बनाएँ। परिणामी कोड इस प्रकार है:

 package sega; import java.io.IOException; import ghidra.app.util.bin.BinaryReader; import ghidra.app.util.bin.StructConverter; import ghidra.program.flatapi.FlatProgramAPI; import ghidra.program.model.address.Address; import ghidra.program.model.data.DataType; import ghidra.program.model.data.Structure; import ghidra.program.model.data.StructureDataType; public class GameHeader implements StructConverter { private byte[] consoleName = null; private byte[] releaseDate = null; private byte[] domesticName = null; private byte[] internationalName = null; private byte[] version = null; private short checksum = 0; private byte[] ioSupport = null; private Address romStart = null, romEnd = null; private Address ramStart = null, ramEnd = null; private byte[] sramCode = null; private byte unused = 0; private Address sramStart = null, sramEnd = null; private byte[] notes = null; FlatProgramAPI fpa; public GameHeader(FlatProgramAPI fpa, BinaryReader reader) throws IOException { this.fpa = fpa; if (reader.length() < 0x200) { return; } reader.setPointerIndex(0x100); consoleName = reader.readNextByteArray(0x10); releaseDate = reader.readNextByteArray(0x10); domesticName = reader.readNextByteArray(0x30); internationalName = reader.readNextByteArray(0x30); version = reader.readNextByteArray(0x0E); checksum = (short) reader.readNextUnsignedShort(); ioSupport = reader.readNextByteArray(0x10); romStart = fpa.toAddr(reader.readNextUnsignedInt()); romEnd = fpa.toAddr(reader.readNextUnsignedInt()); ramStart = fpa.toAddr(reader.readNextUnsignedInt()); ramEnd = fpa.toAddr(reader.readNextUnsignedInt()); sramCode = reader.readNextByteArray(0x03); unused = reader.readNextByte(); sramStart = fpa.toAddr(reader.readNextUnsignedInt()); sramEnd = fpa.toAddr(reader.readNextUnsignedInt()); notes = reader.readNextByteArray(0x44); } @Override public DataType toDataType() { Structure s = new StructureDataType("GameHeader", 0); s.add(STRING, 0x10, "ConsoleName", null); s.add(STRING, 0x10, "ReleaseDate", null); s.add(STRING, 0x30, "DomesticName", null); s.add(STRING, 0x30, "InternationalName", null); s.add(STRING, 0x0E, "Version", null); s.add(WORD, 0x02, "Checksum", null); s.add(STRING, 0x10, "IoSupport", null); s.add(POINTER, 0x04, "RomStart", null); s.add(POINTER, 0x04, "RomEnd", null); s.add(POINTER, 0x04, "RamStart", null); s.add(POINTER, 0x04, "RamEnd", null); s.add(STRING, 0x03, "SramCode", null); s.add(BYTE, 0x01, "Unused", null); s.add(POINTER, 0x04, "SramStart", null); s.add(POINTER, 0x04, "SramEnd", null); s.add(STRING, 0x44, "Notes", null); return s; } public byte[] getConsoleName() { return consoleName; } public byte[] getReleaseDate() { return releaseDate; } public byte[] getDomesticName() { return domesticName; } public byte[] getInternationalName() { return internationalName; } public byte[] getVersion() { return version; } public short getChecksum() { return checksum; } public byte[] getIoSupport() { return ioSupport; } public Address getRomStart() { return romStart; } public Address getRomEnd() { return romEnd; } public Address getRamStart() { return ramStart; } public Address getRamEnd() { return ramEnd; } public byte[] getSramCode() { return sramCode; } public byte getUnused() { return unused; } public Address getSramStart() { return sramStart; } public Address getSramEnd() { return sramEnd; } public boolean hasSRAM() { if (sramCode == null) { return false; } return sramCode[0] == 'R' && sramCode[1] == 'A' && sramCode[2] == 0xF8; } public byte[] getNotes() { return notes; } } 

हेडर के लिए ऑब्जेक्ट बनाएँ:

 vectors = new VectorsTable(fpa, reader); header = new GameHeader(fpa, reader); 

खंडों

सेगा के पास स्मृति क्षेत्रों का एक प्रसिद्ध मानचित्र है, जिसे मैं, शायद, यहां तालिका के रूप में नहीं दूंगा, लेकिन मैं केवल वह कोड दूंगा जो कि सेगमेंट बनाने के लिए उपयोग किया जाता है।

तो, FlatProgramAPI वर्ग के ऑब्जेक्ट में एक createMemoryBlock() विधि है, जिसके साथ मेमोरी क्षेत्र बनाना सुविधाजनक है। इनपुट पर, यह निम्नलिखित तर्क लेता है:

1. name : क्षेत्र का नाम
2. address : क्षेत्र का पता शुरू करें
3. stream : टाइप InputStream का एक ऑब्जेक्ट, जो मेमोरी के क्षेत्र में डेटा के लिए आधार होगा। यदि आप null निर्दिष्ट करते हैं, तो एक असिंचित क्षेत्र बनाया जाएगा (उदाहरण के लिए, 68K RAM या Z80 RAM हमें बस उसी की आवश्यकता होगी
4. size : निर्मित क्षेत्र का आकार
5. isOverlay : true या false स्वीकार करता true , और इंगित करता है कि मेमोरी क्षेत्र ओवरले है। मुझे पता नहीं है कि निष्पादन योग्य फ़ाइलों को छोड़कर इसकी आवश्यकता कहां है

आउटपुट पर, createMemoryBlock() एक MemoryBlock प्रकार का ऑब्जेक्ट MemoryBlock , जिसमें आप वैकल्पिक रूप से एक्सेस राइट्स फ्लैग ( Read , Write , createMemoryBlock() सेट कर सकते हैं।

परिणामस्वरूप, हमें निम्नलिखित फ़ॉर्म का एक फ़ंक्शन मिलता है:

 private void createSegment(FlatProgramAPI fpa, InputStream stream, String name, Address address, long size, boolean read, boolean write, boolean execute) { MemoryBlock block = null; try { block = fpa.createMemoryBlock(name, address, stream, size, false); block.setRead(read); block.setWrite(read); block.setExecute(execute); } catch (Exception e) { Msg.error(this, String.format("Error creating %s segment", name)); } } 

यहाँ हमने अतिरिक्त रूप से एक त्रुटि संदेश प्रदर्शित करने के लिए Msg वर्ग की स्थैतिक error विधि को कहा है।

गेम रम वाले सेगमेंट में अधिकतम आकार 0x3FFFFF (बाकी सब कुछ पहले से ही अन्य क्षेत्रों से संबंधित होगा)। आइए इसे बनाएं:

 InputStream romStream = provider.getInputStream(0); createSegment(fpa, romStream, "ROM", fpa.toAddr(0x000000), Math.min(romStream.available(), 0x3FFFFF), true, false, true); 

InputStream , 0.

, ( SegaCD Sega32X ). OptionDialog . , showYesNoDialogWithNoAsDefaultButton() YES NO - NO .

:

 if (OptionDialog.YES_OPTION == OptionDialog.showYesNoDialogWithNoAsDefaultButton(null, "Question", "Create Sega CD segment?")) { if (romStream.available() > 0x3FFFFF) { InputStream epaStream = provider.getInputStream(0x400000); createSegment(fpa, epaStream, "EPA", fpa.toAddr(0x400000), 0x400000, true, true, false); } else { createSegment(fpa, null, "EPA", fpa.toAddr(0x400000), 0x400000, true, true, false); } } if (OptionDialog.YES_OPTION == OptionDialog.showYesNoDialogWithNoAsDefaultButton(null, "Question", "Create Sega 32X segment?")) { createSegment(fpa, null, "32X", fpa.toAddr(0x800000), 0x200000, true, true, false); } 

:

 createSegment(fpa, null, "Z80", fpa.toAddr(0xA00000), 0x10000, true, true, false); createSegment(fpa, null, "SYS1", fpa.toAddr(0xA10000), 16 * 2, true, true, false); createSegment(fpa, null, "SYS2", fpa.toAddr(0xA11000), 2, true, true, false); createSegment(fpa, null, "Z802", fpa.toAddr(0xA11100), 2, true, true, false); createSegment(fpa, null, "Z803", fpa.toAddr(0xA11200), 2, true, true, false); createSegment(fpa, null, "FDC", fpa.toAddr(0xA12000), 0x100, true, true, false); createSegment(fpa, null, "TIME", fpa.toAddr(0xA13000), 0x100, true, true, false); createSegment(fpa, null, "TMSS", fpa.toAddr(0xA14000), 4, true, true, false); createSegment(fpa, null, "VDP", fpa.toAddr(0xC00000), 2 * 9, true, true, false); createSegment(fpa, null, "RAM", fpa.toAddr(0xFF0000), 0x10000, true, true, true); if (header.hasSRAM()) { Address sramStart = header.getSramStart(); Address sramEnd = header.getSramEnd(); if (sramStart.getOffset() >= 0x200000 && sramEnd.getOffset() <= 0x20FFFF && sramStart.getOffset() < sramEnd.getOffset()) { createSegment(fpa, null, "SRAM", sramStart, sramEnd.getOffset() - sramStart.getOffset() + 1, true, true, false); } } 

,

CreateArrayCmd . , :

1. address : ,
2. numElements :
3. dataType :
4. elementSize :

applyTo(program) , .

, , BYTE , WORD , DWORD . , FlatProgramAPI createByte() , createWord() , createDword() ..

, , (, VDP ). , :

1. Program getSymbolTable() , , ..
2. createLabel() , , . , , SourceType.IMPORTED

, :

 private void createNamedByteArray(FlatProgramAPI fpa, Program program, Address address, String name, int numElements) { if (numElements > 1) { CreateArrayCmd arrayCmd = new CreateArrayCmd(address, numElements, ByteDataType.dataType, ByteDataType.dataType.getLength()); arrayCmd.applyTo(program); } else { try { fpa.createByte(address); } catch (Exception e) { Msg.error(this, "Cannot create byte. " + e.getMessage()); } } try { program.getSymbolTable().createLabel(address, name, SourceType.IMPORTED); } catch (InvalidInputException e) { Msg.error(this, String.format("%s : Error creating array %s", getName(), name)); } } private void createNamedWordArray(FlatProgramAPI fpa, Program program, Address address, String name, int numElements) { if (numElements > 1) { CreateArrayCmd arrayCmd = new CreateArrayCmd(address, numElements, WordDataType.dataType, WordDataType.dataType.getLength()); arrayCmd.applyTo(program); } else { try { fpa.createWord(address); } catch (Exception e) { Msg.error(this, "Cannot create word. " + e.getMessage()); } } try { program.getSymbolTable().createLabel(address, name, SourceType.IMPORTED); } catch (InvalidInputException e) { Msg.error(this, String.format("%s : Error creating array %s", getName(), name)); } } private void createNamedDwordArray(FlatProgramAPI fpa, Program program, Address address, String name, int numElements) { if (numElements > 1) { CreateArrayCmd arrayCmd = new CreateArrayCmd(address, numElements, DWordDataType.dataType, DWordDataType.dataType.getLength()); arrayCmd.applyTo(program); } else { try { fpa.createDWord(address); } catch (Exception e) { Msg.error(this, "Cannot create dword. " + e.getMessage()); } } try { program.getSymbolTable().createLabel(address, name, SourceType.IMPORTED); } catch (InvalidInputException e) { Msg.error(this, String.format("%s : Error creating array %s", getName(), name)); } } 

 createNamedDwordArray(fpa, program, fpa.toAddr(0xA04000), "Z80_YM2612", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA10000), "IO_PCBVER", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA10002), "IO_CT1_DATA", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA10004), "IO_CT2_DATA", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA10006), "IO_EXT_DATA", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA10008), "IO_CT1_CTRL", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA1000A), "IO_CT2_CTRL", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA1000C), "IO_EXT_CTRL", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA1000E), "IO_CT1_RX", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA10010), "IO_CT1_TX", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA10012), "IO_CT1_SMODE", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA10014), "IO_CT2_RX", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA10016), "IO_CT2_TX", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA10018), "IO_CT2_SMODE", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA1001A), "IO_EXT_RX", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA1001C), "IO_EXT_TX", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA1001E), "IO_EXT_SMODE", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA11000), "IO_RAMMODE", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA11100), "IO_Z80BUS", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xA11200), "IO_Z80RES", 1); createNamedByteArray(fpa, program, fpa.toAddr(0xA12000), "IO_FDC", 0x100); createNamedByteArray(fpa, program, fpa.toAddr(0xA13000), "IO_TIME", 0x100); createNamedDwordArray(fpa, program, fpa.toAddr(0xA14000), "IO_TMSS", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xC00000), "VDP_DATA", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xC00002), "VDP__DATA", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xC00004), "VDP_CTRL", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xC00006), "VDP__CTRL", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xC00008), "VDP_CNTR", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xC0000A), "VDP__CNTR", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xC0000C), "VDP___CNTR", 1); createNamedWordArray(fpa, program, fpa.toAddr(0xC0000E), "VDP____CNTR", 1); createNamedByteArray(fpa, program, fpa.toAddr(0xC00011), "VDP_PSG", 1); 

createData() DataUtilities . :

1. program : Program
2. address : ,
3. dataType :
4. dataLength : . -1
5. stackPointers : true , - . false
6. clearDataMode : , (, )

: .. (, ), . FlatProgramAPI createFunction() , .

:

 private void markVectorsTable(Program program, FlatProgramAPI fpa) { try { DataUtilities.createData(program, fpa.toAddr(0), vectors.toDataType(), -1, false, ClearDataMode.CLEAR_ALL_UNDEFINED_CONFLICT_DATA); for (VectorFunc func : vectors.getVectors()) { fpa.createFunction(func.getAddress(), func.getName()); } } catch (CodeUnitInsertionException e) { Msg.error(this, "Vectors mark conflict at 0x000000"); } } private void markHeader(Program program, FlatProgramAPI fpa) { try { DataUtilities.createData(program, fpa.toAddr(0x100), header.toDataType(), -1, false, ClearDataMode.CLEAR_ALL_UNDEFINED_CONFLICT_DATA); } catch (CodeUnitInsertionException e) { Msg.error(this, "Vectors mark conflict at 0x000100"); } } 

load()

load() setMessage() TaskMonitor , .

 monitor.setMessage(String.format("%s : Start loading", getName())); 

, :

 @Override protected void load(ByteProvider provider, LoadSpec loadSpec, List<Option> options, Program program, MemoryConflictHandler handler, TaskMonitor monitor, MessageLog log) throws CancelledException, IOException { monitor.setMessage(String.format("%s : Start loading", getName())); BinaryReader reader = new BinaryReader(provider, false); FlatProgramAPI fpa = new FlatProgramAPI(program, monitor); vectors = new VectorsTable(fpa, reader); header = new GameHeader(fpa, reader); createSegments(fpa, provider, program, monitor); markVectorsTable(program, fpa); markHeader(program, fpa); monitor.setMessage(String.format("%s : Loading done", getName())); } 

getDefaultOptions validateOptions

,

Run -> Debug As -> 1 Ghidra . .

GHIDRA

, - . Eclipse extension.properties , :

 description=Loader for Sega Mega Drive / Genesis ROMs author=Dr. MefistO createdOn=20.03.2019 

GhidraDev -> Export -> Ghidra Module Extension... :

dist zip- (- ghidra_9.0_PUBLIC_20190320_Sega.zip ) GHIDRA .

. , File -> Install Extensions... , , . ...

github- , .

: IDA GHIDRA . .