सीमेंस SGold: जावा के माध्यम से हैकिंग

प्रस्तावना

यह लेख किसी भी सीमेंस SGold प्लेटफ़ॉर्म फोन के प्रोसेसर के एड्रेस स्पेस तक पहुंच प्राप्त करने के लिए एक एकल वातावरण के माध्यम से एक विधि का खुलासा करता है जिसमें आप कम से कम कुछ कोड चला सकते हैं, जो कि जावा मशीन के माध्यम से होता है।
प्रस्तावित विधि का आविष्कार कॉमरेड कैओस (दिमित्री ज़खारोव) ने किया था, एक व्यक्ति जिसके बिना वे कहते हैं, बीबी प्रोसेसर के साथ सीमेंस फोन पर फर्मवेयर को संशोधित और डीबग करना संभव नहीं था।
SGoldLite और SGold-2 परिवार। और मैंने इसे विस्तारित और व्यवस्थित किया।

लंबे समय में यह क्या देता है?

यह सब कंप्यूटर और डेटा केबल के बिना फोन से सीधे फर्मवेयर को संशोधित करना संभव बनाता है, जो हमारे समय में नहीं मिल सकता है, और वित्त की कमी हो सकती है। एक साधारण उपयोगकर्ता के लिए, यह हार्डवेयर का विस्तार है (प्रोसेसर को ओवरक्लॉक करना, उत्पादकता बढ़ाना, एसडीआरएएम को अनलॉक करना, आदि) और सॉफ्टवेयर
(जैसे कि ELF प्रारूप के प्रसिद्ध निष्पादक, जावा हीप को बढ़ाना, आदि) और प्रोग्रामर के लिए - एआरएम प्रोग्राम लिखने का अभ्यास करने के लिए, हार्डवेयर के साथ सीधे काम करना, प्रोसेसर (जो कि IPhone 2 में स्थापित किया गया है, वैसे, इसके लिए) सभी शर्तें हैं। और निश्चित रूप से, यह उन लोगों के लिए है जो रुचि रखते हैं और उत्सुक हैं, जिनके पास ऐसा उपकरण हो सकता है। Intrigued?
तो उसे दूसरा जीवन दो!

स्रोत कोड

मैंने एक अलग ASpace क्लास में एड्रेस स्पेस के साथ सारा काम डिजाइन किया। आगे मैं इसके कुछ विवरण समझाऊंगा।

प्रारंभ

खैर, आखिरकार, विधि पर चलते हैं।
जैसा कि आप अनुमान लगा सकते हैं, यह क्रिया जावा कोड के माध्यम से होती है, और निश्चित रूप से, एआरएम कोडांतरक। सीमेंस जावा मशीन में जिप अभिलेखागार के साथ काम करने के लिए अंतर्निहित कक्षाएं हैं। यह तब था कि "vaunted फासीवादी" छेदा, ओह, अर्थात, जर्मन इंजीनियरों ने छेद को अनदेखा कर दिया। यह सभी मौजूदा फ़र्मवारों पर लागू होता है (और नए लोग, दुर्भाग्य से या खुशी के लिए, इंतजार नहीं करना पड़ता है)।
वास्तव में शीर्षक के लिए, आइए कोड देखें:

//    ZIP  public byte[] aspace_ziparray = {0,0,0,0}; //,   2,  public int[] mainarray = {0}; //   public static final int ASPACE_RET_SUCCESS = 1; public static final int ASPACE_RET_UNKNOWNERROR = 0; public static final int ASPACE_RET_NOZIPFILE = -1; public static final int ASPACE_RET_NOZIPENTRY = -2; public static final int ASPACE_RET_SIGNOFIND = -3; //     0xA8000000 (SDRAM)  0xB0000000 (Flash) private static final int ASPACE_OFFSET_SDRAM_TO_FLASH = 0x8000000; //    0x00000000 (  ) public static int mainarray_startindex = 0; /*     Flash */ //   ()   0xA0000030 private static final int[] aspace_sgold_flash_signature = { 0xA0000000, //0xA0000000 0x5FFFFFFF, //0x5FFFFFFF 0xA0000074, //0xA0000074 0x544B4A43 //CJKT Marker }; /*   ( ) */ public int ASpace_Init(String any_zipfile, String any_zipentryname) { try { //  ,       ZipFile zf = new ZipFile(any_zipfile); if (zf != null) { // ZipEntry      ZipEntry ze = zf.getEntry(any_zipentryname); if (ze != null) { //  InputStream zis = zf.getInputStream(ze); //   ,      , //     2 zis.read(aspace_ziparray, 4, 0x7FFFFFFF); // zip -  zf.close(); //    Flash //       //     0x0 int i = ASPACE_OFFSET_SDRAM_TO_FLASH/4; for (; i > 0; i--) { int j = 0; for (int k = 0; k < 4; k++) { if (mainarray[i + k] != aspace_sgold_flash_signature[k]) { j = 1; break; } } if (j == 0) { //    Flash mainarray_startindex = i - (aspace_sgold_flash_signature_offset/4); // ,    , .. 0x00 mainarray_startindex += ( 0x50000000/4 ); break; } } //,   if (i != 0) return ASPACE_RET_SUCCESS; //  else return ASPACE_RET_SIGNOFIND; //     } else return ASPACE_RET_NOZIPENTRY; //    } else return ASPACE_RET_NOZIPFILE; //  } catch (Exception e) { return ASPACE_RET_UNKNOWNERROR; } } 

मैं बताऊंगा कि सीमेंस एड्रेस स्पेस मैप कैसा दिखता है:
0x00000000-0x00003FFF - आंतरिक SRAM # 1 (माइक्रोकंट्रोलर के अंदर)
0x00080000-0x00097FFF - आंतरिक SRAM # 2 (माइक्रोकंट्रोलर के अंदर)
0x00400000-0x0040FFFF - आंतरिक बूटमॉम (माइक्रोकंट्रोलर के अंदर)
0xA0000000-0xA7FFFFFF - बाहरी फ्लैश (कभी-कभी 32 एमबी, 64 एमबी, 96 एमबी, 128 एमबी)
0xA8000000-0xA9FFFFFF - बाहरी एसडीआरएएम (8 एमबी, 16 एमबी, 32 एमबी होता है)
0xB0000000-0xB7FFFFFF - लिखने के एक्सेस के साथ फ्लैश मिरर
0xF0000000-0xFFFFFFFF - I / O पोर्ट, माइक्रोन में एम्बेडेड उपकरणों के रजिस्टर

लब्बोलुआब यह है कि Aspace_ziparray सरणी के बाहर 0x7FFFFFFFF विधि बाइट्स पढ़ने से, हम मेनरे सरणी क्षेत्र में आते हैं, जिससे जावा इसकी लंबाई 2 जीबी (0x7FFFFFFF) तक बढ़ जाती है। चूंकि सब कुछ नियमों के भीतर है, इसलिए सरणी छोड़ने के बारे में अपवाद पॉप नहीं होता है। और इस सरणी की सामग्री पता स्थान है,
एसडीआरएएम में इस सरणी के भौतिक पते के साथ शुरू करना।

स्वाभाविक रूप से, यह जावा हिप में कहीं है।
X65 वें मॉडल पर, यह 0xA8000000-0xA8300000 क्षेत्र में है।
X75 वें मॉडल पर, यह 0xA8500000-0xA8700000 क्षेत्र में है।

चूंकि सरणी अंतर है, तो एक सेल 4 बाइट्स है, अर्थात्। इंडेक्स को 1 से आगे बढ़ाते हुए, हम 4 बाइट ले जाते हैं। हालांकि हमारी सरणी अंतरंग है, यह 2 जीबी से अधिक नहीं दिखता है, इसलिए हमारे पास हमारे निपटान में एसडीआरएएम, फ्लैश मिरर, आई / ओ पोर्ट और सभी आंतरिक मेमोरी के आधे हिस्से हैं।
बाकी, तो बोलने के लिए, "पर्दे के पीछे" है। अगला, आपको इंडेक्स को शिफ्ट करने की आवश्यकता है ताकि यह फ्लैश मिरर के क्षेत्र में हो, और इसे शुरुआत में ले जाएं, रास्ते में Aspace_sgold_flash_signature हस्ताक्षर की जांच करना, जो इंगित करता है कि हम फ्लैश की शुरुआत में हैं। जैसा कि हमने पाया, हम शुरुआती पते पर कूदते हैं, पता 0x00 से संबंधित मुख्य सरणी के सूचकांक को चर mainarray_startindex पर लिखते हैं।
सब कुछ, आरंभीकरण पूरा हो गया है।

पढ़ो और लिखो

मेनरे सरणी का उपयोग करते हुए, इसके सूचकांक को mainarray_startindex के सापेक्ष स्थानांतरित करते हुए, हम SRAM / SDRAM / I / O पोर्ट को पढ़ और लिख सकते हैं।
इस तरीके में शामिल हैं:

 //   32    public int ASpace_readword(int address); //   16    public int ASpace_readhwrd(int address); //    public int ASpace_readbyte(int address); //   32    public int ASpace_writeword(int address, int value); //   16    public int ASpace_writehwrd(int address, int value); //    public int ASpace_writebyte(int address, int value); 

एआरएम कोड निष्पादन

वास्तव में, यह सब अच्छा है, लेकिन एआरएम कोड निष्पादित करने के बारे में क्या?
प्रोसेसर के मशीन कोड के निष्पादक को स्थापित करने के लिए एक विधि है।
फ़ोन का SRAM / SDRAM विभिन्न बिंदुओं से भरा है (जो नहीं जानते हैं, C / C ++ ट्यूटोरियल्स को पढ़ें) जिन्हें समय-समय पर कॉल किया जाता है, और यदि आप अपना कोड किसी खाली जगह पर अपलोड करते हैं (और उनमें से भी बहुत सारे हैं और पॉइंटर को अपने स्थान से बदलें,) तब फर्मवेयर खुद इसे कॉल करेगा। लेकिन आपको सब कुछ सही ढंग से करने की आवश्यकता है ताकि सिस्टम गिर न जाए। उदाहरण के लिए, हमारी विधि के लिए ARM कोड निष्पादक इस तरह दिखता है:

  /* ARM Caller -  ARM - */ //    public final int aspace_sgold_armcaller_newpointer = 0x803F8; //    ARM Caller'a public final int aspace_sgold_armcaller_bodyaddress = 0x8E010; //       public final int aspace_sgold_workcode_bodyaddress = 0x8E100; //    private static final int ASPACE_ARMCALLER_STATE = 16; private static final int ASPACE_ARMCALLER_OLDPROC = 17; private static final int ASPACE_ARMCALLER_RUNPROC = 18; private static final int ASPACE_ARMCALLER_PARAM0 = 19; private static final int ASPACE_ARMCALLER_PARAM1 = 20; private static final int ASPACE_ARMCALLER_PARAM2 = 21; private static final int ASPACE_ARMCALLER_PARAM3 = 22; private static final int ASPACE_ARMCALLER_RETURN = 23; //  private static int aspace_armcaller_repaddress = 0; //   ARM Caller'a private static int aspace_armcaller_bodyaddress = 0; //     ARM  private static int[] aspace_armcaller = { 0xE92D401F, // ; STMFD SP!, {R0-R4,LR} 0xE59F0038, // ; LDR R0, =old_proc 0xE12FFF30, // ; BLX R0 0xE59F002C, // ; LDR R0, =state 0xE3500000, // ; CMP R0, #0 0x08BD801F, // ; LDMEQFD SP!, {R0-R4,PC} 0xE59F002C, // ; LDR R0, =param0 0xE59F102C, // ; LDR R1, =param1 0xE59F202C, // ; LDR R2, =param2 0xE59F302C, // ; LDR R3, =param3 0xE59F4018, // ; LDR R4, =run_proc 0xE12FFF34, // ; BLX R4 0xE58F0024, // ; STR R0, [PC,#0x24] ; ret 0xE3A00000, // ; MOV R0, #0 0xE58F0000, // ; STR R0, [PC,#0x00] ; state 0xE8BD801F, // ; LDMFD SP!, {R0-R4,PC} 0x00000000, // ; state 0x00000000, // ; old_proc 0x00000000, // ; run_proc 0x00000000, // ; param0 0x00000000, // ; param1 0x00000000, // ; param2 0x00000000, // ; param3 0x00000000 // ; ret }; 

कार्यक्रम के शरीर को बदलते हुए, हम पैरामीटर सेट कर सकते हैं, सुनिश्चित करें कि एक कमांड के साथ कोड केवल एक बार कहा जाता है। स्थापना के बाद, आप एआरएम-प्रक्रियाएं चला सकते हैं, 4 पैरामीटर सेट कर सकते हैं और रिटर्न मान प्राप्त कर सकते हैं।
हमारे कलाकार की सेवा करने की विधियाँ:

  /*   / ARM Caller'a (   ) */ // ARM Caller'a public int ASpace_InstallArmCaller(int replace_address, int body_address); // ARM Caller'a public int ASpace_DeInstallArmCaller(); /*     */ public int ASpace_RunArmCode(int address, int arg0, int arg1, int arg2, int arg3); 

अतिरिक्त तरीके

खैर, जो ऊपर दिया गया है वह मूल, नींव है। लेकिन कक्षा में अन्य विधियां हैं।
उनके आधार पर उन्हें इकट्ठा किया जाता है। कुछ एआरएम कोड का उपयोग करते हैं:

 /*    / ARM  Data Abort */ public void ASpace_DisableDataAbort(); public void ASpace_EnableDataAbort(); /*    SDRAM  0xB8000000 (  ARM Caller) */ public void ASpace_SDRAMRemap(); /*          */ public int ASpace_SearchFunction(int search_address, int search_size, int[] pattern, int offset); /*          */ public int ASpace_SearchFunctionByWords(int search_address, int search_size, int[] pattern, int offset); 

निष्कर्ष

ऊपर, मैंने परिप्रेक्ष्य का उल्लेख किया। उनके विचारों में से एक पहले से तैयार कार्यान्वयन मौजूद है,
और, ज़ाहिर है, इस वर्ग के साथ काम करने का एक उदाहरण है।
आप स्रोत और तैयार मिलेट यहां पा सकते हैं:

सीमेंस SGold सेवा उपकरण ।