Siemens SGold: взлом через Java

Предисловие


В данной статье раскрывается метод получения доступа к адресному пространству процессора любого телефона Siemens платформы SGold через единственную среду, в которой можно запустить хоть какой-то код, то есть через Java-машину.
Предлагаемый способ был придуман товарищем Chaos (Дмитрием Захаровым), человеком без которого, как говорится, не было возможности модифицировать и отлаживать прошивку на телефонах Siemens c BB-процессором
семейств SGoldLite и SGold-2. А я лишь его расширил и систематизировал.

Что это в перспективе даёт?


Это всё делает возможной модификацию прошивки прямо с телефона без компьютера и Data-кабеля, которого в наше время не найти, да и может иметь место недостаток финансов. Для простого пользователя это расширение аппаратных (разгон процессора, увеличение производительности, разблокировка SDRAM и прочее) и программных
(такое как легендарный исполнитель формата ELF, увеличение хипа Java и т.п.) возможностей, а для программиста — попрактиковаться в написании ARM программ, работать напрямую с «железом», процессором (который стоит в IPhone 2, между прочим), для этого имеются все условия. И естественно, это для интересующихся и любопытных, у которых может и завалялся такой аппарат. Заинтриговало?
Так дайте ему вторую жизнь!

Исходный код


Всю работу с адресным пространством я оформил в отдельный класс ASpace. Далее буду пояснять некоторые его детали.

Инициализация


Ну и перейдём наконец к методу.
Как вы догадались, сие действие происходит через Java-код, ну и, конечно же, ARM-ассемблер. В Java-машине Siemens есть встроенные классы по работе с zip-архивами. Тут-то и прокололись «хвалённые фашистские», ой, то есть немецкие инженеры, недоглядели дырку. Это применимо ко всем существующим прошивкам (а новых, к сожалению или к радости, ждать не приходится).
Собственно по заголовку, давайте рассмотрим код:

 //Мнимый буфер для чтения 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; }
   }


Опишу как выглядит карта адресного пространства Siemens:
0x00000000-0x00003FFF — Внутренняя SRAM #1 (внутри микроконтроллера)
0x00080000-0x00097FFF — Внутренняя SRAM #2 (внутри микроконтроллера)
0x00400000-0x0040FFFF — Внутренний BootROM (внутри микроконтроллера)
0xA0000000-0xA7FFFFFF — Внешняя Flash (бывает 32 МБ, 64 МБ, 96 МБ, 128 МБ)
0xA8000000-0xA9FFFFFF — Внешняя SDRAM (бывает 8 МБ, 16 МБ, 32 МБ)
0xB0000000-0xB7FFFFFF — Зеркало Flash с доступом на запись
0xF0000000-0xFFFFFFFF — Порты ввода/вывода, регистры встроенных устройств в мк

Суть в том, что считывая методом read 0x7FFFFFFF байт за пределами массива aspace_ziparray, мы попадаем в область массива mainarray, тем самым Java увеличивает его длину до 2 Гб (0x7FFFFFFF). Так как всё в пределах правил, то исключения о выходе из-за границ массива не выскакивает. И содержимое этого массива есть адресное пространство,
начиная с физического адреса этого массива в SDRAM.

Естественно, это где-то в Java-хипе.
На x65-ых моделях это в районе 0xA8000000-0xA8300000.
На x75-ых моделях это в районе 0xA8500000-0xA8700000.

Так как массив int, то одна ячейка это 4 байта, т.е. перемещая индекс на 1, мы двигаемся по 4 байта. Наш массив хоть и int, но больше 2 Гб он не видит, поэтому в нашем распоряжении половина SDRAM, зеркало Flash, I/O порты и вся внутрянняя память.
Остальное, так сказать, «за кадром». Далее надо сместить индекс, чтобы он оказался в области зеркала Flash, и вести его к началу, по пути проверяя сигнатуру aspace_sgold_flash_signature, которая свидетельствует, что мы в начале Flash. Как нашли её, прыгаем на начальный адрес, записывая индекс массива mainarray, соответствующий адресу 0x00, в переменную mainarray_startindex.
Всё, инициализация пройдена.

Чтение и запись


С помощью массива mainarray, перемещая его индекс относительно mainarray_startindex, мы можем как считать, так и записать в SRAM/SDRAM/порты ввода-вывода.
Этим занимаются методы:

//Чтение слова в 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);


Исполнение ARM-кода


Действительно, всё это хорошо, ну а как же исполнять ARM-код?
Есть метод установки исполнителя машинного кода процессора.
В 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
  }; 


Меняя тело программы, мы можем задавать параметры, следить, чтобы при одной команде код вызывался только один раз. После установки, можно запускать ARM-процедуры, задавать до 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-код:


 /* Методы для включения /выключения 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);



Заключение


Выше я упомянул о перспективе. Готовая реализация одной из её идей уже существует,
и, разумеется, является примером работы с этим классом.
Вы можете найти исходники и готовый мидлет здесь:

Siemens SGold Service Tool.
Поделиться публикацией

Комментарии 9

    +1
    Осталось найти старый сименс.
      +2
      Даааа, сколько же было интересных раскопок в прошивках сименсов :) Мне вот не ранее как вчера написал очередной товарищ с просьбой прислать Qtopia для SX1 )))
        +5
        Siemens CX65, я тебя любил, извини что раздавил задницей и проц отпаялся…
        Тебя можно было патчить так, как не снилось меню настроек в андроиде…
        *плакаю*
          0
          Интересный метод, может сработать и на других моделях телефонов и от других компаний.
            0
            А в случае ошибки его тяжело будет «воскресить»?
              0
              Ну если про мидлет, то чтобы просто посмотреть как работают эльфы, достаточно запустить временный эльфпак через мидлет, это абсолютно безопасное действие, даже те необходимые патчи ставятся виртуально. Нужна только эта библиотека ф-ий. Также можно виртуально поставить и некоторые другие патчи. А если всё-таки решили патчить реально, то слейте через мидлет образ флеш (бекап, фуллфлеш) и считайте ключи, запишите их сохраните их. Если что-то пойдёт не так и телефон не включится, то нужен кабель (dca510,500) и сохранённые бекап и ключи вам пригодятся. Всё легко восстановить, если даже забыли считать ключи и слить бекап, то и в этом случае оживить тоже можно, но там надо повозится немного.
              +2
              *сдул пыль со своего пропатечнного сх75 с эльфами*
                0
                А куда делся s-c.org? Только старый добрый .ru висит…
                  0
                  Как это часто бывает, владельцы потеряли интерес и профукали домен.
                  На .ru, справедливости ради, ситуация отличается только тем, что не профукали домен, но форум мёртв.

                Только полноправные пользователи могут оставлять комментарии. Войдите, пожалуйста.

                Самое читаемое