Сейчас на форуме: _MBK_, Adler, asfa, bartolomeo (+9 невидимых)

 eXeL@B —› Вопросы новичков —› Исследования дешифровщика
Посл.ответ Сообщение

Ранг: 11.2 (новичок), 9thx
Активность: 0.030
Статус: Участник

Создано: 14 сентября 2012 20:34 · Поправил: Flasher-11
· Личное сообщение · #1

Приветствую всех.
Исследую шифровщик/дешифровщик - пакер/анпакер. Первый раз занимаюсь такими вещами. Уже на финальном этапе, осталось расшифровать корневую ФС. Тут я уже в очередной раз застрял.
--> Анпакер <--
Отрывок из алгоритма расшифровки
Code:
  1. 00401318   PUSH EBP
  2. 00401319   MOV EBP,ESP
  3. 0040131B   PUSH EDI
  4. 0040131C   PUSH ESI
  5. 0040131D   PUSH EBX
  6. 0040131E   SUB ESP,10
  7. 00401321   MOV EAX,DWORD PTR SS:[EBP+8]
  8. 00401324   MOV EBX,DWORD PTR DS:[EAX]
  9. 00401326   XOR EBX,DWORD PTR DS:[402030] - а откуда там этот массив взялся, никак не пойму
  10. 0040132C   MOV EDI,DWORD PTR DS:[EAX+4]
  11. 0040132F   XOR EDI,DWORD PTR DS:[402034]
  12. 00401335   MOV EAX,EDI
  13. 00401337   SHR EAX,18
  14. 0040133A   MOV EDX,EDI


Проблема в том, что я никак не могу найти где генерируется этот массив, где в последующем он используется для расшифровки.
Думаю, что он уже предусмотрен в тулзе.



Ранг: 617.3 (!), 677thx
Активность: 0.540
Статус: Участник

Создано: 14 сентября 2012 20:52
· Личное сообщение · #2

Flasher-11 пишет:
Думаю, что он уже предусмотрен в тулзе.

угу, массив статичен. Не знаю чем, но чем-то алгоритм напомнил twofish



Ранг: 11.2 (новичок), 9thx
Активность: 0.030
Статус: Участник

Создано: 14 сентября 2012 20:57
· Личное сообщение · #3

Vovan666, спасибо за ответ. Хотел лишний раз убедиться, но уже со слов знающих людей




Ранг: 1053.6 (!!!!), 1078thx
Активность: 1.060.81
Статус: Участник

Создано: 14 сентября 2012 21:06 · Поправил: reversecode
· Личное сообщение · #4

Vovan666 пишет:
угу, массив статичен. Не знаю чем, но чем-то алгоритм напомнил twofish

угу, а тот массив это ключ статический

ИДА все кристально показывает, зачем олькой извращатся?



Ранг: 11.2 (новичок), 9thx
Активность: 0.030
Статус: Участник

Создано: 14 сентября 2012 21:10 · Поправил: Flasher-11
· Личное сообщение · #5

Ненавижу китайцев, нет бы шифровать, как шифровали всю прошивку.Еще и с ФС возиться

Не дружу я с IDA



Ранг: 11.2 (новичок), 9thx
Активность: 0.030
Статус: Участник

Создано: 18 сентября 2012 23:51
· Личное сообщение · #6

Восстановил код, дизассемблер + декомпилятор. Код конечно ужасен, не приводил его в нормальный вид.
По сути он работает достаточно быстро, но сделал я так чтоб он считывал статический ключ из файла и по смещениям находил нужные ему dword'ы. Но тут оказалось, что я немного лох, а может и полный и так делать не стоило, т.к из-за каждого поиска нужно смещения расшифровка данных сводится почти к 20-30 кб/c.
Может кто помочь советом, как лучше сделать поиск смещений по ключу? Или как лучше организовать все это?

Code:
  1.             FileStream WriteFile = new FileStream(Dir + "RFSFAT16ROOTFS_000000000.12", FileMode.OpenOrCreate, FileAccess.Write);
  2.             BinaryWriter BinWrite = new BinaryWriter(WriteFile);
  3.             FileStream KeyOpen = new FileStream("ROOTFS_KEY", FileMode.Open, FileAccess.Read);
  4.             BinaryReader BinKeyOpen = new BinaryReader(KeyOpen);
  5.             for (int i = 0; i < 1067; i++)
  6.             {
  7.                 Keybuffer[i] = BinKeyOpen.ReadUInt32();
  8.             }
  9.             FileStream RootFSOpen = new FileStream(Dir +"RFSFAT16ROOTFS_000000000", FileMode.Open, FileAccess.Read);
  10.             BinaryReader BinRootFSOpen = new BinaryReader(RootFSOpen);
  11.             for (int count = 0; count < RootFSOpen.Length; count++)
  12.             {
  13.                 for (int i = 0; i < 4; i++)
  14.                 {
  15.                     FSbuffer[i] = BinRootFSOpen.ReadUInt32();
  16.                 }
  17.                 EBX = FSbuffer[0] ^ Keybuffer[4];
  18.                 EDI = FSbuffer[1] ^ Keybuffer[5];
  19.                 EAX = EDI >> 24;
  20.                 EDX = EDI & 0x0FF;
  21.                 KeyOpen.Seek(EAX * 4 + Offset_1, SeekOrigin.Begin);
  22.                 Temp_1 = BinKeyOpen.ReadUInt32();
  23.                 KeyOpen.Seek(EDX * 4 + Offset_2, SeekOrigin.Begin);
  24.                 Temp_2 = BinKeyOpen.ReadUInt32();
  25.                 EAX = Temp_1 ^ Temp_2;
  26.                 KeyOpen.Seek(((EDI & 0x0FF0000) >> 16) * 4 + Offset_3, SeekOrigin.Begin);
  27.                 Temp_1 = BinKeyOpen.ReadUInt32();
  28.                 EAX = EAX ^ Temp_1;
  29.                 KeyOpen.Seek(((EDI >> 8) & 0x0FF) * 4 + Offset_4, SeekOrigin.Begin);
  30.                 Temp_2 = BinKeyOpen.ReadUInt32();
  31.                 EAX = EAX ^ Temp_2;
  32.                 EDX = EBX & 0x0FF;
  33.                 ESI = EBX >> 24;
  34.                 KeyOpen.Seek(EDX * 4 + Offset_1, SeekOrigin.Begin);
  35.                 Temp_1 = BinKeyOpen.ReadUInt32();
  36.                 KeyOpen.Seek(ESI * 4 + Offset_3, SeekOrigin.Begin);
  37.                 Temp_2 = BinKeyOpen.ReadUInt32();
  38.                 EDX = Temp_1 ^ Temp_2;
  39.                 KeyOpen.Seek(((EBX & 0x0FF0000) >> 16) * 4 + Offset_4, SeekOrigin.Begin);
  40.                 Temp_1 = BinKeyOpen.ReadUInt32();
  41.                 EDX = EDX ^ Temp_1;
  42.                 KeyOpen.Seek(((EBX >> 8) & 0x0FF) * 4 + Offset_2, SeekOrigin.Begin);
  43.                 Temp_2 = BinKeyOpen.ReadUInt32();
  44.                 EDX = EDX ^ Temp_2;
  45.                 Q[0] = Keybuffer[38] + EDX + EAX;
  46.                 ESI = FSbuffer[2] ^ Keybuffer[6];
  47.                 Q[1] = ROR(ESI, 31);
  48.                 Ac = (FSbuffer[3] ^ Keybuffer[7]) ^ (EDX + Keybuffer[39] + EAX * 2);
  49.                 Q[2] = EDI;
  50.                 Q[3] = EBX;
  51.                 ECX = ROL(Ac, 31);
  52.                 Q[0] = Q[1] ^ Q[0];
  53.                 EBX = Q[0];
  54.                 Q[1] = 0;
  55.                 while (true)
  56.                 {
  57.                     EAX = ECX >> 24;
  58.                     EDX = ECX & 0x0FF;
  59.                     KeyOpen.Seek(EAX * 4 + Offset_1, SeekOrigin.Begin);
  60.                     Temp_1 = BinKeyOpen.ReadUInt32();
  61.                     KeyOpen.Seek(EDX * 4 + Offset_2, SeekOrigin.Begin);
  62.                     Temp_2 = BinKeyOpen.ReadUInt32();
  63.                     EAX = Temp_1 ^ Temp_2;
  64.                     KeyOpen.Seek(((ECX & 0x0FF0000) >> 16) * 4 + Offset_3, SeekOrigin.Begin);
  65.                     Temp_1 = BinKeyOpen.ReadUInt32();
  66.                     EAX = EAX ^ Temp_1;
  67.                     KeyOpen.Seek(((ECX >> 8) & 0x0FF) * 4 + Offset_4, SeekOrigin.Begin);
  68.                     Temp_2 = BinKeyOpen.ReadUInt32();
  69.                     EAX = EAX ^ Temp_2;
  70.                     EDX = EBX & 0x0FF;
  71.                     ESI = EBX >> 24;
  72.                     KeyOpen.Seek(EDX * 4 + Offset_1, SeekOrigin.Begin);
  73.                     Temp_1 = BinKeyOpen.ReadUInt32();
  74.                     KeyOpen.Seek(ESI * 4 + Offset_3, SeekOrigin.Begin);
  75.                     Temp_2 = BinKeyOpen.ReadUInt32();
  76.                     EDX = Temp_1 ^ Temp_2;
  77.                     KeyOpen.Seek(((EBX & 0x0FF0000) >> 16) * 4 + Offset_4, SeekOrigin.Begin);
  78.                     Temp_1 = BinKeyOpen.ReadUInt32();
  79.                     EDX = EDX ^ Temp_1;
  80.                     KeyOpen.Seek(((EBX >> 8) & 0x0FF) * 4 + Offset_2, SeekOrigin.Begin);
  81.                     Temp_2 = BinKeyOpen.ReadUInt32();
  82.                     EDX = EDX ^ Temp_2;
  83.                     ESI = EAX + EDX;
  84.                     ESI = ESI + Keybuffer[r];
  85.                     r = r - 2;
  86.                     EDI = Q[3];
  87.                     ESI = ESI ^ ROR(EDI, 31);
  88.                     EDI = Q[1];
  89.                     EAX = (EDX + Keybuffer[t] + EAX * 2) ^ Q[2];
  90.                     t = t - 2;
  91.                     EAX = ROR(EAX, 1);
  92.                     EDI = EDI - 8;
  93.                     q = q + 8;
  94.                     Q[1] = EDI;
  95.                     Q[3] = EBX;
  96.                     Q[2] = ECX;
  97.                     if (== 112)
  98.                     {
  99.                         r = 36;
  100.                         t = 37;
  101.                         q = 0;
  102.                         EDI = 0;
  103.                         break;
  104.                     }
  105.                     ECX = EAX;
  106.                     EBX = ESI;
  107.                     EAX = ECX;
  108.                 }
  109.                 Q[0] = EBX;
  110.                 EBX = ESI;
  111.                 EDX = EAX >> 24;
  112.                 EDI = EAX & 0XFF;
  113.                 KeyOpen.Seek(EDX * 4 + Offset_1, SeekOrigin.Begin);
  114.                 Temp_1 = BinKeyOpen.ReadUInt32();
  115.                 KeyOpen.Seek(EDI * 4 + Offset_2, SeekOrigin.Begin);
  116.                 Temp_2 = BinKeyOpen.ReadUInt32();
  117.                 EDX = Temp_1 ^ Temp_2;
  118.                 KeyOpen.Seek(((EAX & 0x0FF0000) >> 16) * 4 + Offset_3, SeekOrigin.Begin);
  119.                 Temp_1 = BinKeyOpen.ReadUInt32();
  120.                 EDX = EDX ^ Temp_1;
  121.                 KeyOpen.Seek(((EAX >> 8) & 0x0FF) * 4 + Offset_4, SeekOrigin.Begin);
  122.                 Temp_2 = BinKeyOpen.ReadUInt32();
  123.                 EDX = EDX ^ Temp_2;
  124.                 EDI = EBX & 0xFF;
  125.                 ESI = ESI >> 24;
  126.                 KeyOpen.Seek(EDI * 4 + Offset_1, SeekOrigin.Begin);
  127.                 Temp_1 = BinKeyOpen.ReadUInt32();
  128.                 EDI = Temp_1;
  129.                 KeyOpen.Seek(ESI * 4 + Offset_3, SeekOrigin.Begin);
  130.                 Temp_1 = BinKeyOpen.ReadUInt32();
  131.                 Q[3] = EDI ^ Temp_1;
  132.                 KeyOpen.Seek(((EBX & 0x0FF0000) >> 16) * 4 + Offset_4, SeekOrigin.Begin);
  133.                 Temp_2 = BinKeyOpen.ReadUInt32();
  134.                 Q[3] = Q[3] ^ Temp_2;
  135.                 KeyOpen.Seek(((EBX >> 8) & 0x0FF) * 4 + Offset_2, SeekOrigin.Begin);
  136.                 Temp_1 = BinKeyOpen.ReadUInt32();
  137.                 Q[3] = Q[3] ^ Temp_1;
  138.                 EDI = Q[3] + Keybuffer[9];
  139.                 EDI = (EDI + EDX * 2) ^ ECX;
  140.                 EDI = ROR(EDI, 1);
  141.                 EBX = EBX ^ Keybuffer[0];
  142.                 P[0] = EBX;
  143.                 EAX = EAX ^ Keybuffer[1];
  144.                 P[1] = EAX;
  145.                 ESI = Q[0];
  146.                 ESI = ROR(ESI, 31);
  147.                 ESI = ESI ^ Keybuffer[2];
  148.                 P[2] = ESI ^ (EDX + Q[3] + Keybuffer[8]);
  149.                 P[3] = EDI ^ Keybuffer[3];
  150.                 BinWrite.Write(P[0]);
  151.                 BinWrite.Write(P[1]);
  152.                 BinWrite.Write(P[2]);
  153.                 BinWrite.Write(P[3]);
  154.             }




Ранг: 65.3 (постоянный), 10thx
Активность: 0.020
Статус: Участник

Создано: 19 сентября 2012 01:24
· Личное сообщение · #7

Весь код не читал, но .Seek & .Read будет выполняться долго. Он же уже в память прочитан, почему бы там не искать?
//Пардон, если глупость, спать надо.



Ранг: 11.2 (новичок), 9thx
Активность: 0.030
Статус: Участник

Создано: 19 сентября 2012 06:59
· Личное сообщение · #8

Я его считывал в uint массив, но если с ним работать, то вся логика рушиться напрочь. Считывал его, потому что удобнее использовать какие-то статичные значения, чем опять использовать Seek




Ранг: 1053.6 (!!!!), 1078thx
Активность: 1.060.81
Статус: Участник

Создано: 19 сентября 2012 08:58
· Личное сообщение · #9

алгоритм twofish есть в исходниках,
зачем вы там что то восстанавливали.. непонятно



Ранг: 11.2 (новичок), 9thx
Активность: 0.030
Статус: Участник

Создано: 19 сентября 2012 20:48
· Личное сообщение · #10

Но так там же ключ явно не 256-битный. Или я что-то не до конца понимаю



Ранг: 617.3 (!), 677thx
Активность: 0.540
Статус: Участник

Создано: 20 сентября 2012 00:29
· Личное сообщение · #11

А почему ключ должен быть 256 бит? 256 это его максимально возможная длина, если ключ 402030+402034, то длина получается 64 бита



Ранг: 11.2 (новичок), 9thx
Активность: 0.030
Статус: Участник

Создано: 20 сентября 2012 20:42
· Личное сообщение · #12

Vovan666, это понятно. Я просто не понимаю, допустим, если ключ 402030+402034, то длина получается 64 бита, как Вы говорили, то зачем остальной массив?



Ранг: 617.3 (!), 677thx
Активность: 0.540
Статус: Участник

Создано: 20 сентября 2012 21:14 · Поправил: Vovan666
· Личное сообщение · #13

посмотри исходники алгоритма и поймешь, там не один массив а их штук 7-8; mds,q0,q1 и тд.



Ранг: 11.2 (новичок), 9thx
Активность: 0.030
Статус: Участник

Создано: 22 сентября 2012 15:33
· Личное сообщение · #14

В исходниках только 4 статических массива. MDS,Q0,Q1,RS, даже если брать их, то статический ключ будет больше всех вместе взятых статических массивов. MDS массив вроде такой {4020C0,4024C0,402СС0,4028С0} если конечно я не ошибаюсь.



Ранг: 0.2 (гость)
Активность: 0=0
Статус: Участник

Создано: 24 сентября 2012 04:07
· Личное сообщение · #15

глупый вопрос, но знать, чтобы открыть этот .bin файл?



Ранг: 310.8 (мудрец), 29thx
Активность: 0.430
Статус: Участник

Создано: 27 сентября 2012 16:53
· Личное сообщение · #16

ask there http://exelab.ru/f/action=vtopic&forum=10 by english или создайте новую тему здесь же, но пишите понятнее.


 eXeL@B —› Вопросы новичков —› Исследования дешифровщика
:: Ваш ответ
Жирный  Курсив  Подчеркнутый  Перечеркнутый  {mpf5}  Код  Вставить ссылку 
:s1: :s2: :s3: :s4: :s5: :s6: :s7: :s8: :s9: :s10: :s11: :s12: :s13: :s14: :s15: :s16:


Максимальный размер аттача: 500KB.
Ваш логин: german1505 » Выход » ЛС
   Для печати Для печати