GHIDRA, Playstation 1 निष्पादनयोग्य, FLIRT हस्ताक्षर और PsyQ

सभी को नमस्कार

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

संक्षेप में - हाइड्रा को चलाना डरावना नहीं है। और लॉन्च के बाद हमें जो भी मिलेगा, वह आपके सभी डर को बुकमार्क-और-बैकस्टेड सर्वव्यापी एनएसए से रोक देगा।

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

मैंने Delphi पर एक दोस्त के साथ TIM प्रारूप के साथ काम करने के लिए एक शांत उपयोगिता लिखकर शुरू किया (यह प्लेस्टेशन वर्ल्ड से BMP जैसा कुछ है): टिम 2 व्यू । एक समय में, सफलता का आनंद लिया (और शायद अब आनंद मिलता है)। तब मैं गहराई में जाना चाहता था।

और फिर समस्याएं शुरू हुईं। मैं तब MIPS परिचित नहीं था। पढ़ाई में लग गए। मैं या तो IDA Pro परिचित नहीं था (मैं Playstation तुलना में बाद में Sega Mega Drive पर गेम को रिवर्स करने के लिए आया था)। लेकिन, इंटरनेट के लिए धन्यवाद, मुझे पता चला कि IDA Pro PS1 डाउनलोड और विश्लेषण का समर्थन करता है: PS-X EXE निष्पादन योग्य फाइलें । मैंने एक अजीब नाम और एक्सटेंशन के साथ एक गेम फ़ाइल (ऐसा लगता है कि वे Lemmings थे) को अपलोड करने की कोशिश की, जैसे कि Ida में SLUS_123.45 , मुझे कोडांतरक कोड की लाइनों का एक गुच्छा मिला (सौभाग्य से, मुझे पहले से ही पता था कि यह क्या था, विंडोज एक्स-ड्राइवरों के तहत धन्यवाद। x86), और समझना शुरू किया।

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

मैं जिन भी कठिनाइयों से गुज़रा, उसके बाद मैंने खेल संसाधनों के कई पैकर्स / अनपैकर्स लिखने में कामयाबी हासिल की। लेकिन मैंने कभी भी कोड का अध्ययन नहीं किया है। क्यों? ठीक है, सब कुछ सामान्य है: बहुत सारे कोड थे, BIOS तक पहुंच और फ़ंक्शन जो कि वास्तव में समझना असंभव था (वे पुस्तकालय थे, और फिर मेरे पास एसडीके के लिए कर्लिंग नहीं है), एक ही समय में तीन रजिस्टरों के साथ काम करने के निर्देश, एक डिकम्पॉइलर की कमी।

और इसलिए, कई सालों के बाद, GHIDRA सामने आता GHIDRA । डिकम्पॉइलर द्वारा समर्थित प्लेटफार्मों के बीच MIPS । हे आनंद! चलो कुछ जल्द ही विघटित करने की कोशिश करते हैं! लेकिन ... मैं एक बम्मर की प्रतीक्षा कर रहा था। PS-X EXE हाइड्रा द्वारा समर्थित नहीं PS-X EXE । कोई बात नहीं, अपना लिखो!

वास्तव में कोड

पर्याप्त गीतात्मक विषयांतर, चलो कोड लिखते हैं। Ghidra लिए अपने स्वयं के डाउनलोडर्स कैसे बनाएं, मुझे पहले से ही पता था कि मैंने पहले क्या लिखा था । इसलिए, यह केवल पहले कर्लिंग लोहे के मेमोरी मैप को खोजने के लिए बनी हुई है, रजिस्टरों के पते और, आप बायनेरिज़ को इकट्ठा और लोड कर सकते हैं। जल्दी से नहीं कहा।

कोड तैयार था, रजिस्टरों और क्षेत्रों को जोड़ा गया था और मान्यता दी गई थी, लेकिन अभी भी उन जगहों पर एक बड़ा खाली स्थान था जहां पुस्तकालय कार्यों और BIOS कार्यों को बुलाया जाता था। और, दुर्भाग्य से, हाइड्रा के पास FLIRT समर्थन नहीं था। यदि नहीं, तो जोड़ते हैं।

FLIRT हस्ताक्षरों का प्रारूप pat.txt फ़ाइल में जाना और वर्णित है, जिसे Ida SDK में पाया जा सकता है। इडा के पास विशेष रूप से Playstation लाइब्रेरी फ़ाइलों से ये हस्ताक्षर बनाने के लिए एक उपयोगिता है, और इसे कहा जाता है: ppsx । मैंने PsyQ Playstation Development Kit नामक PsyQ Playstation Development Kit लिए SDK डाउनलोड किया, वहां पर काम की फाइलें मिलीं और उनमें से कम से कम कुछ हस्ताक्षर बनाने की कोशिश की - सफलतापूर्वक। यह एक छोटा पाठ करता है जिसमें प्रत्येक पंक्ति का एक विशिष्ट प्रारूप होता है। यह कोड लिखना शेष है जो इन पंक्तियों को पार्स करेगा, और उन्हें कोड पर लागू करेगा।

PatParser

चूंकि प्रत्येक पंक्ति में एक विशिष्ट प्रारूप होता है, इसलिए एक नियमित अभिव्यक्ति लिखना तर्कसंगत होगा। यह इस तरह निकला:

 private static final Pattern linePat = Pattern.compile("^((?:[0-9A-F\\.]{2})+) ([0-9A-F]{2}) ([0-9A-F]{4}) ([0-9A-F]{4}) ((?:[:\\^][0-9A-F]{4}@? [\\.\\w]+ )+)((?:[0-9A-F\\.]{2})+)?$"); 

ठीक है, तो ऑफसेट, प्रकार और फ़ंक्शन नाम के लिए अलग से मॉड्यूल की सूची में, हम एक अलग regexp लिखते हैं:

 private static final Pattern modulePat = Pattern.compile("([:\\^][0-9A-F]{4}@?) ([\\.\\w]+) "); 

अब प्रत्येक हस्ताक्षर के घटकों को अलग-अलग करते हैं:

1. सबसे पहले बाइट्स ( 0-9A-F ) का हेक्स अनुक्रम आता है, जहाँ उनमें से कुछ भी हो सकते हैं (डॉट कैरेक्टर "।")। इसलिए, हम एक ऐसा वर्ग बनाते हैं जो इस तरह के अनुक्रम को संग्रहीत करेगा। मैंने इसे MaskedBytes कहा:

 package pat; public class MaskedBytes { private final byte[] bytes, masks; public final byte[] getBytes() { return bytes; } public final byte[] getMasks() { return masks; } public final int getLength() { return bytes.length; } public MaskedBytes(byte[] bytes, byte[] masks) { this.bytes = bytes; this.masks = masks; } public static MaskedBytes extend(MaskedBytes src, MaskedBytes add) { return extend(src, add.getBytes(), add.getMasks()); } public static MaskedBytes extend(MaskedBytes src, byte[] addBytes, byte[] addMasks) { int length = src.getBytes().length; byte[] tmpBytes = new byte[length + addBytes.length]; byte[] tmpMasks = new byte[length + addMasks.length]; System.arraycopy(src.getBytes(), 0, tmpBytes, 0, length); System.arraycopy(addBytes, 0, tmpBytes, length, addBytes.length); System.arraycopy(src.getMasks(), 0, tmpMasks, 0, length); System.arraycopy(addMasks, 0, tmpMasks, length, addMasks.length); return new MaskedBytes(tmpBytes, tmpMasks); } } 

1. उस खंड की लंबाई जहां से CRC16 की गणना की जाती है।
2. CRC16 , जो अपने स्वयं के बहुपद ( 0x8408 ) का उपयोग करता है:

 public static boolean checkCrc16(byte[] bytes, short resCrc) { if ( bytes.length == 0 ) return true; int crc = 0xFFFF; for (int i = 0; i < bytes.length; ++i) { int a = bytes[i]; for (int x = 0; x < 8; ++x) { if (((crc ^ a) & 1) != 0) { crc = (crc >> 1) ^ 0x8408; } else { crc >>= 1; } a >>= 1; } } crc = ~crc; int x = crc; crc = (crc << 8) | ((x >> 8) & 0xFF); crc &= 0xFFFF; return (short)crc == resCrc; } 

1. बाइट्स में "मॉड्यूल" की कुल लंबाई।
2. वैश्विक नामों की सूची (हमें क्या चाहिए)
3. अन्य नामों के लिंक की सूची (भी आवश्यक)।
4. टेल बाइट्स।

मॉड्यूल में प्रत्येक नाम में एक विशिष्ट प्रकार है और शुरुआत के सापेक्ष ऑफसेट है। एक प्रकार का संकेत वर्णों के आधार पर दिया जा सकता है ::, ^, @, प्रकार पर निर्भर करता है:

• " : NAME ": वैश्विक नाम। यह ऐसे नामों के लिए था कि मैंने सब कुछ शुरू किया;
• " : NAME @ ": स्थानीय नाम / लेबल। यह संकेत नहीं हो सकता है, लेकिन इसे रहने दो;
• " ^ NAME ": नाम का लिंक।

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

परिणामस्वरूप, हम तीन प्रकार के नामों के लिए enum बनाते हैं:

 package pat; public enum ModuleType { GLOBAL_NAME, LOCAL_NAME, REF_NAME; public boolean isGlobal() { return this == GLOBAL_NAME; } public boolean isLocal() { return this == LOCAL_NAME; } public boolean isReference() { return this == REF_NAME; } @Override public String toString() { if (isGlobal()) { return "Global"; } else if (isLocal()) { return "Local"; } else { return "Reference"; } } } 

आइए एक कोड लिखें जो पाठ हेक्साडेसिमल अनुक्रम और डॉट्स को MaskedBytes टाइप करने के लिए MaskedBytes :

 private MaskedBytes hexStringToMaskedBytesArray(String s) { MaskedBytes res = null; if (s != null) { int len = s.length(); byte[] bytes = new byte[len / 2]; byte[] masks = new byte[len / 2]; for (int i = 0; i < len; i += 2) { char c1 = s.charAt(i); char c2 = s.charAt(i + 1); masks[i / 2] = (byte) ( (((c1 == '.') ? 0x0 : 0xF) << 4) | (((c2 == '.') ? 0x0 : 0xF) << 0) ); bytes[i / 2] = (byte) ( (((c1 == '.') ? 0x0 : Character.digit(c1, 16)) << 4) | (((c2 == '.') ? 0x0 : Character.digit(c2, 16)) << 0) ); } res = new MaskedBytes(bytes, masks); } return res; } 

आप पहले से ही एक वर्ग के बारे में सोच सकते हैं जो प्रत्येक व्यक्तिगत फ़ंक्शन के बारे में जानकारी संग्रहीत करेगा: फ़ंक्शन का नाम, मॉड्यूल में ऑफसेट और प्रकार:

 package pat; public class ModuleData { private final long offset; private final String name; private final ModuleType type; public ModuleData(long offset, String name, ModuleType type) { this.offset = offset; this.name = name; this.type = type; } public final long getOffset() { return offset; } public final String getName() { return name; } public final ModuleType getType() { return type; } } 

और, अंत में: एक वर्ग जो सब कुछ संग्रहीत करेगा जो pat फ़ाइल की प्रत्येक पंक्ति पर इंगित किया गया है, वह है: बाइट्स, सीआरसी, ऑफसेट के साथ नामों की एक सूची:

 package pat; import java.util.Arrays; import java.util.List; public class SignatureData { private final MaskedBytes templateBytes, tailBytes; private MaskedBytes fullBytes; private final int crc16Length; private final short crc16; private final int moduleLength; private final List<ModuleData> modules; public SignatureData(MaskedBytes templateBytes, int crc16Length, short crc16, int moduleLength, List<ModuleData> modules, MaskedBytes tailBytes) { this.templateBytes = this.fullBytes = templateBytes; this.crc16Length = crc16Length; this.crc16 = crc16; this.moduleLength = moduleLength; this.modules = modules; this.tailBytes = tailBytes; if (this.tailBytes != null) { int addLength = moduleLength - templateBytes.getLength() - tailBytes.getLength(); byte[] addBytes = new byte[addLength]; byte[] addMasks = new byte[addLength]; Arrays.fill(addBytes, (byte)0x00); Arrays.fill(addMasks, (byte)0x00); this.fullBytes = MaskedBytes.extend(this.templateBytes, addBytes, addMasks); this.fullBytes = MaskedBytes.extend(this.fullBytes, tailBytes); } } public MaskedBytes getTemplateBytes() { return templateBytes; } public MaskedBytes getTailBytes() { return tailBytes; } public MaskedBytes getFullBytes() { return fullBytes; } public int getCrc16Length() { return crc16Length; } public short getCrc16() { return crc16; } public int getModuleLength() { return moduleLength; } public List<ModuleData> getModules() { return modules; } } 

अब मुख्य बात: हम इन सभी वर्गों को बनाने के लिए कोड लिखते हैं:

 private List<ModuleData> parseModuleData(String s) { List<ModuleData> res = new ArrayList<ModuleData>(); if (s != null) { Matcher m = modulePat.matcher(s); while (m.find()) { String __offset = m.group(1); ModuleType type = __offset.startsWith(":") ? ModuleType.GLOBAL_NAME : ModuleType.REF_NAME; type = (type == ModuleType.GLOBAL_NAME && __offset.endsWith("@")) ? ModuleType.LOCAL_NAME : type; String _offset = __offset.replaceAll("[:^@]", ""); long offset = Integer.parseInt(_offset, 16); String name = m.group(2); res.add(new ModuleData(offset, name, type)); } } return res; } 

 private void parse(List<String> lines) { modulesCount = 0L; signatures = new ArrayList<SignatureData>(); int linesCount = lines.size(); monitor.initialize(linesCount); monitor.setMessage("Reading signatures..."); for (int i = 0; i < linesCount; ++i) { String line = lines.get(i); Matcher m = linePat.matcher(line); if (m.matches()) { MaskedBytes pp = hexStringToMaskedBytesArray(m.group(1)); int ll = Integer.parseInt(m.group(2), 16); short ssss = (short)Integer.parseInt(m.group(3), 16); int llll = Integer.parseInt(m.group(4), 16); List<ModuleData> modules = parseModuleData(m.group(5)); MaskedBytes tail = null; if (m.group(6) != null) { tail = hexStringToMaskedBytesArray(m.group(6)); } signatures.add(new SignatureData(pp, ll, ssss, llll, modules, tail)); modulesCount += modules.size(); } monitor.incrementProgress(1); } } 

फ़ंक्शन बनाने के लिए कोड जहां हस्ताक्षर में से एक को मान्यता दी गई थी:

 private static void disasmInstruction(Program program, Address address) { DisassembleCommand cmd = new DisassembleCommand(address, null, true); cmd.applyTo(program, TaskMonitor.DUMMY); } public static void setFunction(Program program, FlatProgramAPI fpa, Address address, String name, boolean isFunction, boolean isEntryPoint, MessageLog log) { try { if (fpa.getInstructionAt(address) == null) disasmInstruction(program, address); if (isFunction) { fpa.createFunction(address, name); } if (isEntryPoint) { fpa.addEntryPoint(address); } if (isFunction && program.getSymbolTable().hasSymbol(address)) { return; } program.getSymbolTable().createLabel(address, name, SourceType.IMPORTED); } catch (InvalidInputException e) { log.appendException(e); } } 

सबसे कठिन जगह, जैसा कि पहले उल्लेख किया गया है, किसी अन्य नाम / चर के लिंक की गिनती कर रहा है (शायद कोड में सुधार करने की आवश्यकता है):

 public static void setInstrRefName(Program program, FlatProgramAPI fpa, PseudoDisassembler ps, Address address, String name, MessageLog log) { ReferenceManager refsMgr = program.getReferenceManager(); Reference[] refs = refsMgr.getReferencesFrom(address); if (refs.length == 0) { disasmInstruction(program, address); refs = refsMgr.getReferencesFrom(address); if (refs.length == 0) { refs = refsMgr.getReferencesFrom(address.add(4)); if (refs.length == 0) { refs = refsMgr.getFlowReferencesFrom(address.add(4)); Instruction instr = program.getListing().getInstructionAt(address.add(4)); if (instr == null) { disasmInstruction(program, address.add(4)); instr = program.getListing().getInstructionAt(address.add(4)); if (instr == null) { return; } } FlowType flowType = instr.getFlowType(); if (refs.length == 0 && !(flowType.isJump() || flowType.isCall() || flowType.isTerminal())) { return; } refs = refsMgr.getReferencesFrom(address.add(8)); if (refs.length == 0) { return; } } } } try { program.getSymbolTable().createLabel(refs[0].getToAddress(), name, SourceType.IMPORTED); } catch (InvalidInputException e) { log.appendException(e); } } 

और, अंतिम स्पर्श - हस्ताक्षर लागू करें:

 public void applySignatures(ByteProvider provider, Program program, Address imageBase, Address startAddr, Address endAddr, MessageLog log) throws IOException { BinaryReader reader = new BinaryReader(provider, false); PseudoDisassembler ps = new PseudoDisassembler(program); FlatProgramAPI fpa = new FlatProgramAPI(program); monitor.initialize(getAllModulesCount()); monitor.setMessage("Applying signatures..."); for (SignatureData sig : signatures) { MaskedBytes fullBytes = sig.getFullBytes(); MaskedBytes tmpl = sig.getTemplateBytes(); Address addr = program.getMemory().findBytes(startAddr, endAddr, fullBytes.getBytes(), fullBytes.getMasks(), true, TaskMonitor.DUMMY); if (addr == null) { monitor.incrementProgress(sig.getModules().size()); continue; } addr = addr.subtract(imageBase.getOffset()); byte[] nextBytes = reader.readByteArray(addr.getOffset() + tmpl.getLength(), sig.getCrc16Length()); if (!PatParser.checkCrc16(nextBytes, sig.getCrc16())) { monitor.incrementProgress(sig.getModules().size()); continue; } addr = addr.add(imageBase.getOffset()); List<ModuleData> modules = sig.getModules(); for (ModuleData data : modules) { Address _addr = addr.add(data.getOffset()); if (data.getType().isGlobal()) { setFunction(program, fpa, _addr, data.getName(), data.getType().isGlobal(), false, log); } monitor.setMessage(String.format("%s function %s at 0x%08X", data.getType(), data.getName(), _addr.getOffset())); monitor.incrementProgress(1); } for (ModuleData data : modules) { Address _addr = addr.add(data.getOffset()); if (data.getType().isReference()) { setInstrRefName(program, fpa, ps, _addr, data.getName(), log); } monitor.setMessage(String.format("%s function %s at 0x%08X", data.getType(), data.getName(), _addr.getOffset())); monitor.incrementProgress(1); } } } 

यहां आप एक दिलचस्प फ़ंक्शन के बारे में बात कर सकते हैं: findBytes() । इसके साथ, आप बाइट्स के विशिष्ट दृश्यों की खोज कर सकते हैं, प्रत्येक बाइट के लिए निर्दिष्ट बिट मास्क के साथ। विधि को इस तरह कहा जाता है:

 Address addr = program.getMemory().findBytes(startAddr, endAddr, bytes, masks, forward, TaskMonitor.DUMMY); 

नतीजतन, जिस पते से बाइट्स शुरू होती हैं, वह वापस आ जाता है, या null ।

एक विश्लेषक लिख रहा है

चलो इसे खूबसूरती से करते हैं, और यदि हम नहीं चाहते हैं, तो हम हस्ताक्षर का उपयोग नहीं करते हैं, लेकिन उपयोगकर्ता को यह चरण चुनने दें। ऐसा करने के लिए, आपको अपना स्वयं का कोड विश्लेषक लिखना होगा (आप इस सूची में लोगों को देख सकते हैं - यह सब वे हैं, हाँ):

इसलिए, इस सूची में शामिल होने के लिए, आपको AbstractAnalyzer वर्ग से वारिस करना होगा और कुछ विधियों को ओवरराइड करना होगा:

1. डिजाइनर। इसे आधार वर्ग के निर्माता को नाम, विश्लेषक के विवरण और इसके प्रकार (बाद में उस पर अधिक) के साथ कॉल करना होगा। यह मुझे कुछ इस तरह दिखता है:

 public PsxAnalyzer() { super("PSYQ Signatures", "PSX signatures applier", AnalyzerType.INSTRUCTION_ANALYZER); } 

1. getDefaultEnablement() । यह निर्धारित करता है कि क्या हमारा विश्लेषक हमेशा उपलब्ध है, या केवल अगर कुछ शर्तों को पूरा किया जाता है (उदाहरण के लिए, यदि हमारे लोडर का उपयोग किया जाता है)।
2. canAnalyze() । क्या एक डाउनलोड करने योग्य बाइनरी फ़ाइल पर इस विश्लेषक का उपयोग करना संभव है?
   पैराग्राफ 2 और 3, सिद्धांत रूप में, एक एकल फ़ंक्शन द्वारा सत्यापित किए जा सकते हैं:

 public static boolean isPsxLoader(Program program) { return program.getExecutableFormat().equalsIgnoreCase(PsxLoader.PSX_LOADER); } 

जहाँ PsxLoader.PSX_LOADER बूटलोडर का नाम संग्रहीत करता है, और इसमें पहले परिभाषित किया गया है।

कुल, हमारे पास है:

 @Override public boolean getDefaultEnablement(Program program) { return isPsxLoader(program); } @Override public boolean canAnalyze(Program program) { return isPsxLoader(program); } 

1. registerOptions() । इस पद्धति को फिर से परिभाषित करने के लिए यह बिल्कुल भी आवश्यक नहीं है, लेकिन अगर हमें उपयोगकर्ता से कुछ पूछने की आवश्यकता है, उदाहरण के लिए, विश्लेषण से पहले पैट फ़ाइल का पथ, तो इस विधि में ऐसा करना सबसे अच्छा है। हमें मिलता है:

 private static final String OPTION_NAME = "PSYQ PAT-File Path"; private File file = null; @Override public void registerOptions(Options options, Program program) { try { file = Application.getModuleDataFile("psyq4_7.pat").getFile(false); } catch (FileNotFoundException e) { } options.registerOption(OPTION_NAME, OptionType.FILE_TYPE, file, null, "PAT-File (FLAIR) created from PSYQ library files"); } 

यहाँ यह स्पष्ट करना आवश्यक है। स्थैतिक विधि getModuleDataFile() Application वर्ग data निर्देशिका में फ़ाइल के लिए पूर्ण पथ देता है, जो हमारे मॉड्यूल के पेड़ में है, और हम बाद में संदर्भित करने के लिए किसी भी आवश्यक फ़ाइलों को संग्रहीत कर सकते हैं।

खैर, OPTION_NAME registerOption() विधि OPTION_NAME में निर्दिष्ट नाम के साथ एक विकल्प को registerOption() OPTION_NAME , प्रकार File (यानी, उपयोगकर्ता एक नियमित संवाद बॉक्स के माध्यम से फ़ाइल का चयन करने में सक्षम होगा), डिफ़ॉल्ट मूल्य और विवरण।

अगला। क्योंकि हमारे पास पंजीकृत विकल्प को बाद में संदर्भित करने का एक सामान्य अवसर नहीं है, हमें optionsChanged() को फिर से परिभाषित करने की आवश्यकता होगी: optionsChanged()

 @Override public void optionsChanged(Options options, Program program) { super.optionsChanged(options, program); file = options.getFile(OPTION_NAME, file); } 

यहां हम नए मूल्य के अनुसार वैश्विक चर का अद्यतन करते हैं।

added() विधि। अब मुख्य बात: विश्लेषक शुरू होने पर विधि जिसे कहा जाएगा। इसमें हम विश्लेषण के लिए उपलब्ध पतों की एक सूची प्राप्त करेंगे, लेकिन हमें केवल उन लोगों की आवश्यकता है जिनमें कोड शामिल हैं। इसलिए, आपको फ़िल्टर करने की आवश्यकता है। अंतिम कोड:

 @Override public boolean added(Program program, AddressSetView set, TaskMonitor monitor, MessageLog log) throws CancelledException { if (file == null) { return true; } Memory memory = program.getMemory(); AddressRangeIterator it = memory.getLoadedAndInitializedAddressSet().getAddressRanges(); while (!monitor.isCancelled() && it.hasNext()) { AddressRange range = it.next(); try { MemoryBlock block = program.getMemory().getBlock(range.getMinAddress()); if (block.isInitialized() && block.isExecute() && block.isLoaded()) { PatParser pat = new PatParser(file, monitor); RandomAccessByteProvider provider = new RandomAccessByteProvider(new File(program.getExecutablePath())); pat.applySignatures(provider, program, block.getStart(), block.getStart(), block.getEnd(), log); } } catch (IOException e) { log.appendException(e); return false; } } return true; } 

यहां हम उन पतों की सूची से गुजरते हैं जो निष्पादन योग्य हैं, और वहां हस्ताक्षर लागू करने का प्रयास करते हैं।

निष्कर्ष और अंत

सब कुछ पसंद है। वास्तव में, यहां कुछ भी जटिल नहीं है। उदाहरण हैं, समुदाय जीवंत है, आप सुरक्षित रूप से पूछ सकते हैं कि कोड लिखते समय क्या स्पष्ट नहीं है। निचला रेखा: Playstation 1 निष्पादन योग्य फ़ाइलों के लिए एक कार्यशील बूटलोडर और विश्लेषक।

सभी स्रोत कोड यहां उपलब्ध हैं: ghidra_psx_ldr
यहाँ विज्ञप्ति: विज्ञप्ति