перемножение байт из массива и сложение. Что это за алгоритм?

Подскажите что за алгоритм шифрования?

Код (Text):

1. int __usercall sub_4012E0<eax>(int _Data<eax>, int _key<ecx>, int Buf)
2. {
3.   int Key; // ecx@1
4.   int Data; // edx@2
5.   unsigned __int8 sum; // al@2
6.   signed int Count; // esi@2
7.   int result; // eax@4
8.   int DataBlock; // [sp+Ch] [bp-Ch]@1
9.   signed int Status; // [sp+10h] [bp-8h]@1
10.  
11.   Status = 0;
12.   DataBlock = _Data + 1;
13.   Key = _key + 1;
14.   do
15.   {
16.     Data = DataBlock;
17.     sum = 0;
18.     Count = 13;
19.     do
20.     {
21.       sum += *(_BYTE *)(Data + 2) * *(_BYTE *)(Key + 2)
22.            + *(_BYTE *)(Data + 1) * *(_BYTE *)(Key + 1)
23.            + *(_BYTE *)Data * *(_BYTE *)Key
24.            + *(_BYTE *)(Data - 1) * *(_BYTE *)(Key - 1);
25.       Key += 4;
26.       Data += 4;
27.       --Count;
28.     }
29.     while ( Count );
30.     result = sum;
31.     *(_BYTE *)(Status++ + Buf) = result;
32.   }
33.   while ( Status < 52 );
34.   return result;
35. }

где _Data - [мои данные]FGHIJKLMN и т. д алфавит.
_Key массив байт
Buf - буфер куда помещаются расшифрованные данные

Или подскажите как зашифровать данные что бы их можно было подать на вход этой функции

 

Если я правильно отреверсил алгоритм, то key - это матрица байтов 52х52 и шифрование сводится к умножению вектора data на нее. Для декодирования нужно ее обратить. Тонкость в том что все вычисления по модулю 256, а там не все числа обратимы. Возможно _BYTE это что-то другое, тогда все проще.

 

помоему вы абсолютно правы сейчас буду пробовать считать.

 

Люди, что ж вы декомпилятор совсем не используете?
1. Поставь курсор на Data
2. Нажми Y
3. Введи unsigned char *
4. Повтори для переменных Key, Buf, и т.п.

 

Aids
Выложите бинарь если не жалко, можно ЛС.

 

Тестовое задание eset:
http://www.joineset.com/researcher.html

http://www.joineset.com/w4-download/eset_reversing_challenge_1.exe
решив первое задание получите вторую ссылку.
http://www.3537.sk/download/r3v3r51ngch4113ng313v312ab36db1ff0ada88d/eset_reversing_challenge_2.exe

 

Если я правильно понял, и по известным Buf и Key нужно закодировать Data, то

а) выберите в каждом из 52-символьных блоков Key один байт, который является обратимым по модулю 256 (пусть "j"),
б) вычислите для соответствующей ему позиции в Data соответствующее значение (Data[j]*Key[j]=Buf),
в) все остальные 51 значение в этом блоке Data установите в 0.

И так повторите для каждого столбца.

 

Lukovchanin

может чего не понимаю. Но Data это вектор размером в 52 байта, Key это 52x52 байт.
Data могут быть только символы алфавита и цифры.
Весь алгоритм шифрования M=(D*K1+K2)*K3=> решить его можно D=(M*K3^-1-K2)*K1^-1
где известны M(51x1), K1(52x52), K2(52), K3(52x52)
Сейчас я пытаюсь обратить матрицу K3, по формуле
K3^-1=1/det(K3)*C^t
где С^t транспонированная союзная
det(K3) по рекурсивной формуле пытаюсь посчитать http://ru.wikipedia.org/wiki/Определитель
но пока я не могу даже посчитать определитеь матрицы 52x52
Мой код

Код (Text):

1. int main(int n,char **arg){
2.     FILE *f=fopen("D:\\Temp\\1\\noname","rb");//noname_2_table1","rb");
3.     long len=filelength(fileno(f));
4.     char *mat=new char[len];
5.     fread(mat,1,len,f);
6.     fclose(f);
7.     long a=Det(len,mat);
8.     delete []mat;
9.     return 0;
10. }
11.  
12. long Det(int n,char *matrix){
13.     if (n==1)return matrix[0];
14.     long res=0;
15.     long sum=0;
16.     n=sqrt((float)n);
17.     for (int i=0;i<n;i++){
18.         long len=n-1;
19.         char *m=new char[len*len];
20.         int jj=0;
21.         for (int j=0;j<(n*n);j++){
22.             if (((i%n)!=(j%n))&&(j>n-1)){
23.                 m[jj++]=matrix[j]; //строю минорную матрицу вычёркивая строку и столбец
24.             }
25.         }
26.         sum=sum+pow((float)-1,i)*((matrix[i%n]*Det(len*len,m))&0xFF);
27.         sum=sum&0xFF;
28.         delete []m;
29.     }
30.     return sum;
31. }

Проверял код подсчётом матрицы 9x9 и 3x3 считает правильно. А вот 52x52 не выдаёт результат всё выполняет расчёты, алгоритм медленный.

 

пробовал считать через excel там определитель считается быстро, но он не подходит так как надо использовать основание 0xff может я что то накосячил в алгоритме.

 

Aids
Во-первых, основание равно 256.
А ты учел, что не все числа обратимы? Тебе просто повезло наверно с матрицами 9x9 и 3х3
Нужен алгоритм усложненный с перестановками столбцов или строк и выбирать обратимый элемент.

 

Тоже но не декомпилированное

Код (Text):

1. .text:004012E0 MulMatr         proc near               ; CODE XREF: ThreadSerial2+88p
2. .text:004012E0                                         ; ThreadSerial2+A4p
3. .text:004012E0
4. .text:004012E0 data            = dword ptr -0Ch
5. .text:004012E0 count           = dword ptr -8
6. .text:004012E0 sum             = dword ptr -4
7. .text:004012E0 buf             = dword ptr  8
8. .text:004012E0
9. .text:004012E0                 push    ebp
10. .text:004012E1                 mov     ebp, esp
11. .text:004012E3                 sub     esp, 0Ch
12. .text:004012E6                 push    ebx
13. .text:004012E7                 inc     eax             ; data 52x1
14. .text:004012E8                 push    esi
15. .text:004012E9                 mov     [ebp+count], 0
16. .text:004012F0                 mov     [ebp+data], eax
17. .text:004012F3                 inc     ecx             ; Table1 52x52
18. .text:004012F4                 push    edi
19. .text:004012F5
20. .text:004012F5 next2:                                  ; CODE XREF: MulMatr+A8j
21. .text:004012F5                 mov     edx, [ebp+data]
22. .text:004012F8                 xor     eax, eax
23. .text:004012FA                 lea     esi, [eax+0Dh]  ; 13
24. .text:004012FD                 lea     ecx, [ecx+0]
25. .text:00401300
26. .text:00401300 next1:                                  ; CODE XREF: MulMatr+91j
27. .text:00401300                 movzx   ebx, byte ptr [edx-1]
28. .text:00401304                 movzx   edi, byte ptr [ecx-1]
29. .text:00401308                 imul    edi, ebx
30. .text:0040130B                 movzx   ebx, byte ptr [edx]
31. .text:0040130E                 and     edi, 0FFh
32. .text:00401314                 add     eax, edi
33. .text:00401316                 movzx   edi, byte ptr [ecx]
34. .text:00401319                 imul    edi, ebx
35. .text:0040131C                 movzx   ebx, byte ptr [edx+1]
36. .text:00401320                 and     eax, 0FFh
37. .text:00401325                 and     edi, 0FFh
38. .text:0040132B                 mov     [ebp+sum], eax
39. .text:0040132E                 add     eax, edi
40. .text:00401330                 movzx   edi, byte ptr [ecx+1]
41. .text:00401334                 imul    edi, ebx
42. .text:00401337                 movzx   ebx, byte ptr [edx+2]
43. .text:0040133B                 and     eax, 0FFh
44. .text:00401340                 and     edi, 0FFh
45. .text:00401346                 mov     [ebp+sum], eax
46. .text:00401349                 add     eax, edi
47. .text:0040134B                 movzx   edi, byte ptr [ecx+2]
48. .text:0040134F                 imul    edi, ebx
49. .text:00401352                 and     eax, 0FFh
50. .text:00401357                 mov     [ebp+sum], eax
51. .text:0040135A                 and     edi, 0FFh
52. .text:00401360                 add     eax, edi
53. .text:00401362                 and     eax, 0FFh
54. .text:00401367                 add     ecx, 4
55. .text:0040136A                 add     edx, 4
56. .text:0040136D                 dec     esi
57. .text:0040136E                 mov     [ebp+sum], eax
58. .text:00401371                 jnz     short next1
59. .text:00401373                 mov     edx, [ebp+count]
60. .text:00401376                 mov     esi, [ebp+buf]
61. .text:00401379                 and     eax, 0FFh
62. .text:0040137E                 mov     [edx+esi], al
63. .text:00401381                 inc     edx
64. .text:00401382                 mov     [ebp+count], edx
65. .text:00401385                 cmp     edx, 34h
66. .text:00401388                 jl      next2
67. .text:0040138E                 pop     edi
68. .text:0040138F                 pop     esi
69. .text:00401390                 pop     ebx
70. .text:00401391                 mov     esp, ebp
71. .text:00401393                 pop     ebp
72. .text:00401394                 retn
73. .text:00401394 MulMatr         endp

ещё попробовал загнать матрицы в Excel и посчитать обратную и все последующие вычисления. В результате нашёл входной вектор D=(M*K3^-1-K2)*K1^-1, но вот проблема я не учёл основания 256

 

Aids
По модулю 256 обратимы все нечетные числа, т.ч. алгоритм просто построить. Теперь или жди готовой проги от Ezrah или сам трудись.

 

valterg

Вы имеете ввиду метод Гаусса — Жордана, для расчёта обратной матрицы?

 

К сожалению у меня ничего не выйдет, у меня Windows 7 x64, программа на ней не запускается, виртуалки нет, в общем бида.

 

Ezrah
я тоже под x64, с виртуалки тестирую. Этот крякми палит веруалку ещё, пришлось пропатчить немного.

код который считаеть обратную матрицу, но я не знаю как запилить его под основание 256. Может кто чего подскажет

Код (Text):

1. void obrmatrix(int n,float** m){
2.     float **b;
3.     b=new float*[n];
4.  
5.     for (int i=0;i<n;i++) {
6.         b[i]=new float[n];
7.         memset(b[i],0,n*sizeof(float));
8.     }
9.     for (int k=0; k<n;k++){
10.        for (int i=0;i<n;i++){
11.            for (int j=0;j<n;j++){
12.                    if ((i==k) && (j==k))
13.                       b[i][j] = 1/m[i][j];
14.                    if ((i==k) && (j!=k))
15.                       b[i][j] = -m[i][j]/m[k][k];
16.                    if ((i!=k) && (j==k))
17.                       b[i][j] = m[i][k]/m[k][k];
18.                    if ((i!=k) && (j!=k))
19.                       b[i][j] = m[i][j] - m[k][j] * m[i][k]/m[k][k];
20.            }
21.        }
22.        for (int i= 0; i<n;i++)
23.            for (int j= 0;j<n;j++) m[i][j]= b[i][ j];
24.     }
25.     for (int i=0;i<n;i++) delete []b[i];
26.     delete []b;
27. }

 

Ezrah

кстати он работает под x64 если пропатчить, 0x11a1560 на безусловный переход и 0x11a1f25 занопить in, и ещё он палит ольку по названию окна

пропатченый крякми работает под x64
http://file.qip.ru/file/3lsSDR20/patch.html

 

Не понял из первого поста, что дано, а что нужно вычислить. После Вашего разъяснения стало ясно.
Можно увидеть в аттаче саму матрицу ?

 

Lukovchanin

key(52x52)
http://file.qip.ru/file/DcPvz8Wd/noname_2_table2.html
buf(1x52)
http://file.qip.ru/file/KnfkBhE0/key_chack.html

 

Это шифр Хилла

 

Дайте кто нибудь ссылку как рассчитать обратную матрицу хоть по какому нибудь основанию.

или подскажите как они получили обратную матрицу да ещё такую красивую?
http://ru.wikipedia.org/wiki/Шифр_Хилла