Форум программистов, компьютерный форум CyberForum.ru

Алгоритм шифрования из exe файла - C++

Восстановить пароль Регистрация
 
GregoryRUS
0 / 0 / 0
Регистрация: 30.08.2013
Сообщений: 3
30.08.2013, 18:50     Алгоритм шифрования из exe файла #1
Hola amigos!
На C++ к слову я мало что понимаю и столкнулся с некой необходимостью получить алгоритм шифрования обычного CD-ключа из exe-файла.

Пишу на C# простой установщик игры со всеми патчами и дополнениями, но помимо ключей реестра необходимо еще и позволить пользователю вводить свой CD-ключ, а записывается он в реестр пройдя некий алгоритм шифрования (банальный hex-bin не подойдет).

На одном из форумов нашел реализацию, но вытянуть алгоритм не могу в виду недостатка знаний по C++.
Если кто сможет помочь - буду очень признателен, тем более что сам алгоритм должен быть достаточно простым:

Декомпиленый вариант с помощью Hex-ray:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
/* This file has been generated by the Hex-Rays decompiler.
   Copyright (c) 2009 Hex-Rays <info@hex-rays.com>
 
   Detected compiler: Visual C++
*/
 
#include <windows.h>
#include <defs.h>
 
 
//-------------------------------------------------------------------------
// Data declarations
 
// extern void *commode; weak
// extern void *_initenv; weak
// extern int fmode;
extern _UNKNOWN unk_4020D8; // weak
extern _UNKNOWN unk_4020E0; // weak
extern _UNKNOWN unk_4020E4; // weak
extern _UNKNOWN unk_4020F0; // weak
extern struct _EXCEPTION_POINTERS ExceptionInfo; // idb
extern char aSoftwareBohemi[46]; // weak
extern char Str; // idb
extern char aIswow64process[15]; // weak
extern const WCHAR ModuleName[]; // idb
extern char ProcName[]; // idb
extern char Format[]; // idb
extern char a32bitMode_[]; // idb
extern const WCHAR ValueName[]; // idb
extern char aYourArma2OaHex[]; // idb
extern char a02x[]; // idb
extern char aYourArma2OaCdK[]; // idb
extern char aArma2OaRegistr[37]; // weak
extern char aArma2OaKeyNotF[]; // idb
extern char aEnterNewKeyWit[]; // idb
extern char aS[]; // idb
extern char aNewArma2OaHexK[]; // idb
extern char aRegistryKeySuc[40]; // weak
extern char aErrorWritingRe[66]; // weak
extern char aErrorOpeningRe[]; // idb
extern char Command[]; // idb
extern _UNKNOWN unk_402478; // weak
extern _UNKNOWN unk_402480; // weak
extern _UNKNOWN unk_402488; // weak
extern _UNKNOWN unk_4024C8; // weak
extern int dword_403000; // weak
extern int dword_403004; // weak
extern int dword_403010; // weak
extern int dword_403014; // weak
extern LPCSTR lpSubKey; // idb
extern int dword_403020; // weak
extern int dword_403024; // weak
extern int dword_403028; // weak
extern int dword_40302C; // weak
extern int dword_403030; // weak
extern int dword_403034; // weak
extern int dword_403038; // weak
extern int dword_40303C; // weak
extern int dword_403040; // weak
extern int dword_403044; // weak
extern int dword_40304C; // weak
extern int dword_403090; // weak
extern int dword_403098; // weak
extern __int16 word_403124; // weak
extern __int16 word_403128; // weak
extern __int16 word_40312C; // weak
extern __int16 word_403130; // weak
extern int dword_403134; // weak
extern int dword_403138; // weak
extern int dword_40313C; // weak
extern int dword_403140; // weak
extern int dword_403144; // weak
extern int dword_403148; // weak
extern int dword_40314C; // weak
extern int dword_403150; // weak
extern __int16 word_403154; // weak
extern int dword_403158; // weak
extern int dword_40315C; // weak
extern __int16 word_403160; // weak
extern int dword_403364; // weak
extern int dword_403368; // weak
extern int dword_40336C; // weak
extern int dword_403370; // weak
extern int (__stdcall *dword_403374)(_DWORD, _DWORD); // weak
extern char byte_40337C[24]; // idb
extern BYTE Data; // idb
extern _UNKNOWN unk_403398; // weak
extern int dword_4033A4; // weak
extern volatile LONG Destination; // idb
extern PVOID dword_4033AC; // idb
extern PVOID Ptr; // idb
extern int dword_4033B4; // weak
extern int (__thiscall *dword_4033B8)(_DWORD, _DWORD, _DWORD, _DWORD); // weak
 
//-------------------------------------------------------------------------
// Function declarations
 
int __cdecl sub_401000();
// BOOL __usercall sub_4012F3<eax>(char _CF<cf>, char _ZF<zf>, char _SF<sf>, char _OF<of>, int a5<eax>, int a6<edx>, int a7<ecx>, int a8<ebx>, int a9<edi>, int a10<esi>, char a11);
int __cdecl sub_401302();
// int __usercall sub_401486<eax>(int a1<ebp>);
// void __usercall sub_40149A(int a1<ebp>);
// int loc_4014B6(); weak
int __cdecl sub_4014D6();
// int __usercall start<eax>(int a1<ebp>);
// BOOL __usercall sub_40159A<eax>(char _CF<cf>, char _ZF<zf>, char _SF<sf>, char _OF<of>, int a5<eax>, int a6<edx>, int a7<ecx>, int a8<ebx>, int a9<edi>, int a10<esi>, char a11);
int __stdcall TopLevelExceptionFilter(int a1);
int __cdecl sub_4016E2();
// int __cdecl amsg_exit(_DWORD); weak
_onexit_t __cdecl sub_4016F6(_onexit_t Ptr);
int __cdecl sub_40178E();
int __cdecl sub_401797(_onexit_t Ptr); // idb
int (*__cdecl sub_4017AE())(void);
int (*__cdecl sub_4017D4())(void);
// int __cdecl XcptFilter(_DWORD, _DWORD); weak
bool __cdecl sub_401800(int a1);
int __cdecl sub_401840(int a1, unsigned int a2);
// unsigned int __usercall sub_401890<eax>(int a1<eax>, int a2);
// int __cdecl initterm(_DWORD, _DWORD); weak
// int __cdecl initterm_e(_DWORD, _DWORD); weak
// _DWORD __cdecl _SEH_prolog4(_DWORD, _DWORD); weak
// int __stdcall _SEH_epilog4(_DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD); weak
int __cdecl sub_4019B9(int a1, int a2, int a3, int a4);
errno_t __cdecl sub_4019DE();
int __cdecl sub_401A06();
int __cdecl sub_401A09();
// int __cdecl crt_debugger_hook(_DWORD); weak
// void __cdecl terminate(); idb
// int __cdecl unlock(_DWORD); weak
// int __cdecl _dllonexit(_DWORD, _DWORD, _DWORD); weak
// int __cdecl lock(_DWORD); weak
// int __cdecl except_handler4_common(_DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD); weak
// int __stdcall invoke_watson(_DWORD, _DWORD, _DWORD, _DWORD, _DWORD); weak
// errno_t __cdecl controlfp_s(unsigned int *CurrentState, unsigned int NewValue, unsigned int Mask);
// int __usercall sub_401AE0<eax>(__int64 a1<edx:eax>, unsigned __int8 a2<cl>);
// LSTATUS __stdcall RegOpenKeyExA(HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult);
// LSTATUS __stdcall RegSetValueExW(HKEY hKey, LPCWSTR lpValueName, DWORD Reserved, DWORD dwType, const BYTE *lpData, DWORD cbData);
// LSTATUS __stdcall RegCloseKey(HKEY hKey);
// LSTATUS __stdcall RegQueryValueExW(HKEY hKey, LPCWSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);
// HANDLE __stdcall GetCurrentProcess();
// HMODULE __stdcall GetModuleHandleW(LPCWSTR lpModuleName);
// FARPROC __stdcall GetProcAddress(HMODULE hModule, LPCSTR lpProcName);
// DWORD __stdcall GetCurrentProcessId();
// DWORD __stdcall GetCurrentThreadId();
// DWORD __stdcall GetTickCount();
// BOOL __stdcall QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount);
// PVOID __stdcall DecodePointer(PVOID Ptr);
// BOOL __stdcall IsDebuggerPresent();
// LPTOP_LEVEL_EXCEPTION_FILTER __stdcall SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter);
// LONG __stdcall UnhandledExceptionFilter(struct _EXCEPTION_POINTERS *ExceptionInfo);
// BOOL __stdcall TerminateProcess(HANDLE hProcess, UINT uExitCode);
// PVOID __stdcall EncodePointer(PVOID Ptr);
// BOOL __stdcall HeapSetInformation(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength);
// LONG __stdcall InterlockedCompareExchange(volatile LONG *Destination, LONG Exchange, LONG Comperand);
// void __stdcall Sleep(DWORD dwMilliseconds);
// LONG __stdcall InterlockedExchange(volatile LONG *Target, LONG Value);
// void __stdcall GetSystemTimeAsFileTime(LPFILETIME lpSystemTimeAsFileTime);
// int __cdecl configthreadlocale(_DWORD); weak
// int __cdecl _setusermatherr(_DWORD); weak
// int __cdecl _set_app_type(_DWORD); weak
// _onexit_t __cdecl onexit(_onexit_t Func);
// void __cdecl exit(int Code);
// void __cdecl exit(int Code);
// void __cdecl cexit();
// int __cdecl _getmainargs(_DWORD, _DWORD, _DWORD, _DWORD, _DWORD); weak
// int __cdecl system(const char *Command);
// int __cdecl toupper(int C);
// int __cdecl isalnum(int C);
// int scanf(const char *Format, ...);
// int printf(const char *Format, ...);
// char *__cdecl strchr(const char *Str, int Val);
 
 
//----- (00401000) --------------------------------------------------------
int __cdecl sub_401000()
{
  int v0; // ebx@1
  HMODULE v1; // eax@1
  HANDLE v2; // eax@2
  int v3; // edi@6
  int v4; // ecx@11
  unsigned int v5; // ebx@11
  int v6; // edi@11
  __int64 v7; // qt0@12
  int v8; // eax@13
  char v9; // cl@14
  unsigned __int64 v10; // qt0@14
  int v11; // ebx@21
  BYTE v12; // al@22
  int v13; // edi@23
  char v14; // al@24
  char *v15; // eax@28
  int v16; // edx@29
  int v17; // eax@31
  signed int v18; // ecx@31
  unsigned int v19; // edx@32
  unsigned __int64 v20; // qt0@32
  DWORD v21; // edi@34
  const char *v23; // [sp+0h] [bp-23Ch]@17
  const char *v24; // [sp+0h] [bp-23Ch]@38
  BYTE *v25; // [sp+10h] [bp-22Ch]@1
  BYTE *v26; // [sp+14h] [bp-228h]@10
  int v27; // [sp+18h] [bp-224h]@1
  HKEY hKey; // [sp+1Ch] [bp-220h]@6
  BYTE *v29; // [sp+20h] [bp-21Ch]@21
  unsigned int v30; // [sp+28h] [bp-214h]@21
  DWORD cbData; // [sp+30h] [bp-20Ch]@1
  BYTE Data[516]; // [sp+34h] [bp-208h]@7
  unsigned int v33; // [sp+238h] [bp-4h]@1
 
  v33 = (unsigned int)&v25 ^ dword_403000;
  cbData = 512;
  ((void (__cdecl *)(_DWORD))printf)(" \n\n ARMA2 OA CD-KEY changer 1.0 by inf1kek,");
  v0 = 0;
  v27 = 0;
  v1 = GetModuleHandleW(L"kernel32");
  dword_403374 = (int (__stdcall *)(_DWORD, _DWORD))GetProcAddress(v1, "IsWow64Process");
  if ( dword_403374 )
  {
    v2 = GetCurrentProcess();
    dword_403374(v2, &v27);
  }
  if ( v27 )
  {
    printf(" 64bit mode.\n\n");
  }
  else
  {
    printf(" 32bit mode.\n\n");
    lpSubKey = "SOFTWARE\\Bohemia Interactive Studio\\ArmA 2 OA";
  }
  v3 = (int)byte_40337C;
  if ( RegOpenKeyExA(HKEY_LOCAL_MACHINE, lpSubKey, 0, 1u, &hKey) )
  {
    v23 = " ARMA2:OA Key not found...";
  }
  else
  {
    if ( !RegQueryValueExW(hKey, L"KEY", 0, 0, Data, &cbData) )
    {
      RegCloseKey(hKey);
      printf(" Your ARMA2:OA hex-key: ");
      do
        printf("%02X ", Data[v0++]);
      while ( v0 != 15 );
      v25 = (BYTE *)byte_40337C;
      v26 = Data;
      do
      {
        v6 = 0;
        v5 = 0;
        v4 = 0;
        do
        {
          HIDWORD(v7) = v5;
          LODWORD(v7) = v6;
          v5 = (unsigned __int64)(v7 << 8) >> 32;
          v6 = v26[v4++] | (v6 << 8);
        }
        while ( v4 != 5 );
        v8 = 0;
        do
        {
          v9 = v6;
          LODWORD(v10) = v6;
          HIDWORD(v10) = v5;
          v6 = v10 >> 5;
          v5 >>= 5;
          v25[v8++] = *(&Str + (v9 & 0x1F));
        }
        while ( v8 != 8 );
        v25 += 8;
        v26 += 5;
      }
      while ( v25 != &::Data );
      printf("\n\n Your ARMA2:OA CD-KEY: ");
      v3 = (int)byte_40337C;
      printf(byte_40337C);
      goto LABEL_20;
    }
    v23 = " ARMA2:OA Registry path not found...";
  }
  printf(v23);
LABEL_20:
  printf("\n\n Enter new key without '-' : ");
  scanf("%s", v3);
  v27 = (int)&unk_403398;
  v26 = (BYTE *)v3;
LABEL_21:
  v11 = 0;
  v30 = 0;
  v25 = 0;
  v29 = v26;
  while ( 1 )
  {
    v12 = *v29;
    if ( !*v29 )
      return 0;
    v13 = (char)v12;
    if ( isalnum((char)v12) )
    {
      v14 = toupper(v13);
      if ( v14 == 79 )
      {
        v14 = 48;
      }
      else
      {
        if ( v14 == 73 )
          v14 = 49;
      }
      v15 = strchr(&Str, v14);
      if ( !v15 )
        return 0;
      v11 |= sub_401AE0((signed int)(v15 - &Str), (unsigned __int8)v25);
      v30 |= v16;
    }
    v25 += 5;
    ++v29;
    if ( v25 == (BYTE *)40 )
    {
      v17 = v27;
      v18 = 5;
      do
      {
        v19 = v30;
        *(_BYTE *)v17 = v11;
        LODWORD(v20) = v11;
        HIDWORD(v20) = v19;
        v11 = v20 >> 8;
        --v17;
        --v18;
        v30 = v19 >> 8;
      }
      while ( v18 );
      v26 += 8;
      v27 += 5;
      if ( v26 == &::Data )
      {
        printf("\n New ARMA2:OA hex-key: ");
        v21 = 0;
        do
          printf("%02X ", *(&::Data + v21++));
        while ( v21 != 15 );
        if ( RegOpenKeyExA(HKEY_LOCAL_MACHINE, lpSubKey, 0, 2u, &hKey) )
        {
          v24 = "\n\n Error opening registry path, run program as an Administrator!\n\n";
        }
        else
        {
          if ( RegSetValueExW(hKey, L"KEY", 0, 3u, &::Data, v21) )
            v24 = "\n\n Error writing registry key, run program as an Administrator!\n\n";
          else
            v24 = "\n\n Registry key successfully updated!\n\n";
        }
        printf(v24);
        RegCloseKey(hKey);
        system("pause");
        return 0;
      }
      goto LABEL_21;
    }
  }
}
// 403000: using guessed type int dword_403000;
// 403374: using guessed type int (__stdcall *dword_403374)(_DWORD, _DWORD);
// 401000: using guessed type BYTE Data[516];
 
//----- (004012F3) --------------------------------------------------------
BOOL __usercall sub_4012F3<eax>(char _CF<cf>, char _ZF<zf>, char _SF<sf>, char _OF<of>, int a5<eax>, int a6<edx>, int a7<ecx>, int a8<ebx>, int a9<edi>, int a10<esi>, char a11)
{
  if ( a7 == dword_403000 )
    __asm { rep retn }
  return sub_40159A(
           a7 < (unsigned int)dword_403000,
           a7 == dword_403000,
           a7 - dword_403000 < 0,
           __SETO__(a7, dword_403000),
           a5,
           a6,
           a7,
           a8,
           a9,
           a10,
           a11);
}
// 403000: using guessed type int dword_403000;
 
//----- (00401302) --------------------------------------------------------
int __cdecl sub_401302()
{
  int result; // eax@1
 
  sub_401797((_onexit_t)sub_4017D4);
  dword_403034 = dword_403368;
  result = _getmainargs(&dword_403020, &dword_403028, &dword_403024, dword_403364, &dword_403034);
  dword_403030 = result;
  if ( result < 0 )
    result = amsg_exit(8);
  return result;
}
// 4016F0: using guessed type int __cdecl amsg_exit(_DWORD);
// 4020B0: using guessed type int __cdecl _getmainargs(_DWORD, _DWORD, _DWORD, _DWORD, _DWORD);
// 403020: using guessed type int dword_403020;
// 403024: using guessed type int dword_403024;
// 403028: using guessed type int dword_403028;
// 403030: using guessed type int dword_403030;
// 403034: using guessed type int dword_403034;
// 403364: using guessed type int dword_403364;
// 403368: using guessed type int dword_403368;
 
//----- (00401486) --------------------------------------------------------
int __usercall sub_401486<eax>(int a1<ebp>)
{
  int v1; // eax@1
  int v3; // ecx@1
 
  v1 = *(_DWORD *)(a1 - 20);
  v3 = **(_DWORD **)v1;
  *(_DWORD *)(a1 - 32) = v3;
  return XcptFilter(v3, v1);
}
// 4017FA: using guessed type int __cdecl XcptFilter(_DWORD, _DWORD);
 
//----- (0040149A) --------------------------------------------------------
void __usercall sub_40149A(int a1<ebp>)
{
  int v1; // eax@1
 
  v1 = *(_DWORD *)(a1 - 32);
  dword_403038 = *(_DWORD *)(a1 - 32);
  JUMPOUT(dword_40302C, 0, *(unsigned int *)loc_4014B6);
  exit(v1);
}
// 4014B6: using guessed type int loc_4014B6();
// 40302C: using guessed type int dword_40302C;
// 403038: using guessed type int dword_403038;
 
//----- (004014D6) --------------------------------------------------------
int __cdecl sub_4014D6()
{
  bool v0; // eax@2
 
  if ( v400000 != 23117
    || *(_DWORD *)(v40003c + 4194304) != 17744
    || *(_WORD *)(v40003c + 4194328) != 267
    || *(_DWORD *)(v40003c + 4194420) <= 0xEu )
    v0 = 0;
  else
    v0 = *(_DWORD *)(v40003c + 4194536) != 0;
  dword_40302C = v0;
  _set_app_type(1);
  dword_4033AC = EncodePointer((PVOID)0xFFFFFFFF);
  Ptr = dword_4033AC;
  fmode = dword_403370;
  commode = (void *)dword_40336C;
  sub_4017AE();
  sub_401A06();
  if ( !dword_403014 )
    _setusermatherr(sub_401A06);
  sub_4019DE();
  if ( dword_403010 == -1 )
    configthreadlocale(-1);
  return 0;
}
// 402060: using guessed type int __cdecl configthreadlocale(_DWORD);
// 402064: using guessed type int __cdecl _setusermatherr(_DWORD);
// 402068: using guessed type void *commode;
// 402070: using guessed type int __cdecl _set_app_type(_DWORD);
// 403010: using guessed type int dword_403010;
// 403014: using guessed type int dword_403014;
// 40302C: using guessed type int dword_40302C;
// 40336C: using guessed type int dword_40336C;
// 403370: using guessed type int dword_403370;
 
//----- (0040159A) --------------------------------------------------------
BOOL __usercall sub_40159A<eax>(char _CF<cf>, char _ZF<zf>, char _SF<sf>, char _OF<of>, int a5<eax>, int a6<edx>, int a7<ecx>, int a8<ebx>, int a9<edi>, int a10<esi>, char a11)
{
  int v11; // ST04_4@1
  int v12; // ST330_4@1
  HANDLE v14; // eax@3
  int v15; // [sp+32Ch] [bp+4h]@1
 
  dword_403148 = a5;
  dword_403144 = a7;
  dword_403140 = a6;
  dword_40313C = a8;
  dword_403138 = a10;
  dword_403134 = a9;
  word_403160 = __SS__;
  word_403154 = __CS__;
  word_403130 = __DS__;
  word_40312C = __ES__;
  word_403128 = __FS__;
  word_403124 = __GS__;
  __asm { pushf }
  dword_403158 = v11;
  dword_40314C = v12;
  dword_403150 = v15;
  dword_40315C = (int)&a11;
  dword_403098 = 65537;
  dword_40304C = dword_403150;
  dword_403040 = -1073740791;
  dword_403044 = 1;
  dword_403090 = IsDebuggerPresent();
  crt_debugger_hook(1);
  SetUnhandledExceptionFilter(0);
  UnhandledExceptionFilter(&ExceptionInfo);
  if ( !dword_403090 )
    crt_debugger_hook(1);
  v14 = GetCurrentProcess();
  return TerminateProcess(v14, 0xC0000409u);
}
// 401AA4: using guessed type int __cdecl crt_debugger_hook(_DWORD);
// 403040: using guessed type int dword_403040;
// 403044: using guessed type int dword_403044;
// 40304C: using guessed type int dword_40304C;
// 403090: using guessed type int dword_403090;
// 403098: using guessed type int dword_403098;
// 403124: using guessed type __int16 word_403124;
// 403128: using guessed type __int16 word_403128;
// 40312C: using guessed type __int16 word_40312C;
// 403130: using guessed type __int16 word_403130;
// 403134: using guessed type int dword_403134;
// 403138: using guessed type int dword_403138;
// 40313C: using guessed type int dword_40313C;
// 403140: using guessed type int dword_403140;
// 403144: using guessed type int dword_403144;
// 403148: using guessed type int dword_403148;
// 40314C: using guessed type int dword_40314C;
// 403150: using guessed type int dword_403150;
// 403154: using guessed type __int16 word_403154;
// 403158: using guessed type int dword_403158;
// 40315C: using guessed type int dword_40315C;
// 403160: using guessed type __int16 word_403160;
 
//----- (004016A0) --------------------------------------------------------
int __stdcall TopLevelExceptionFilter(int a1)
{
  _DWORD *v1; // eax@1
  int v2; // eax@3
 
  v1 = *(_DWORD **)a1;
  if ( **(_DWORD **)a1 == -529697949 )
  {
    if ( v1[4] == 3 )
    {
      v2 = v1[5];
      if ( v2 == 429065504 || v2 == 429065505 || v2 == 429065506 || v2 == 26820608 )
        terminate();
    }
  }
  return 0;
}
 
//----- (004016E2) --------------------------------------------------------
int __cdecl sub_4016E2()
{
  SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)TopLevelExceptionFilter);
  return 0;
}
 
//----- (004016F6) --------------------------------------------------------
_onexit_t __cdecl sub_4016F6(_onexit_t Ptr)
{
  _onexit_t result; // eax@2
  PVOID v2; // eax@3
  int v3; // ST1C_4@3
  PVOID v4; // [sp+14h] [bp-20h]@3
  PVOID v5; // [sp+18h] [bp-1Ch]@3
  CPPEH_RECORD ms_exc; // [sp+1Ch] [bp-18h]@3
 
  if ( (int)DecodePointer(::Ptr) == -1 )
  {
    result = onexit(Ptr);
  }
  else
  {
    lock(8);
    ms_exc.disabled = 0;
    v5 = DecodePointer(::Ptr);
    v4 = DecodePointer(dword_4033AC);
    v2 = EncodePointer(Ptr);
    v3 = _dllonexit(v2, &v5, &v4);
    ::Ptr = EncodePointer(v5);
    dword_4033AC = EncodePointer(v4);
    ms_exc.disabled = -2;
    sub_40178E();
    result = (_onexit_t)v3;
  }
  return result;
}
// 401AB6: using guessed type int __cdecl _dllonexit(_DWORD, _DWORD, _DWORD);
// 401ABC: using guessed type int __cdecl lock(_DWORD);
 
//----- (0040178E) --------------------------------------------------------
int __cdecl sub_40178E()
{
  return unlock(8);
}
// 401AB0: using guessed type int __cdecl unlock(_DWORD);
 
//----- (00401797) --------------------------------------------------------
int __cdecl sub_401797(_onexit_t Ptr)
{
  return (sub_4016F6(Ptr) != 0) - 1;
}
 
//----- (004017AE) --------------------------------------------------------
int (*__cdecl sub_4017AE())(void)
{
  int (*result)(void); // eax@1
  unsigned int v1; // edi@1
 
  result = (int (*)(void))&unk_402478;
  v1 = (unsigned int)&unk_402478;
  if ( &unk_402478 < &unk_402478 )
  {
    do
    {
      result = *(int (**)(void))v1;
      if ( *(_DWORD *)v1 )
        result = (int (*)(void))result();
      v1 += 4;
    }
    while ( v1 < (unsigned int)&unk_402478 );
  }
  return result;
}
 
//----- (004017D4) --------------------------------------------------------
int (*__cdecl sub_4017D4())(void)
{
  int (*result)(void); // eax@1
  unsigned int v1; // edi@1
 
  result = (int (*)(void))&unk_402480;
  v1 = (unsigned int)&unk_402480;
  if ( &unk_402480 < &unk_402480 )
  {
    do
    {
      result = *(int (**)(void))v1;
      if ( *(_DWORD *)v1 )
        result = (int (*)(void))result();
      v1 += 4;
    }
    while ( v1 < (unsigned int)&unk_402480 );
  }
  return result;
}
 
//----- (00401800) --------------------------------------------------------
bool __cdecl sub_401800(int a1)
{
  bool result; // eax@2
  int v2; // eax@3
 
  if ( *(_WORD *)a1 != 23117 || (v2 = a1 + *(_DWORD *)(a1 + 60), *(_DWORD *)v2 != 17744) )
    result = 0;
  else
    result = *(_WORD *)(v2 + 24) == 267;
  return result;
}
 
//----- (00401840) --------------------------------------------------------
int __cdecl sub_401840(int a1, unsigned int a2)
{
  int result; // eax@1
  unsigned int v3; // edx@1
  unsigned int v4; // esi@1
  int v5; // ecx@1
  unsigned int v6; // ecx@2
 
  v5 = a1 + *(_DWORD *)(a1 + 60);
  v4 = *(_WORD *)(v5 + 6);
  v3 = 0;
  result = *(_WORD *)(v5 + 20) + v5 + 24;
  if ( *(_WORD *)(v5 + 6) )
  {
    while ( 1 )
    {
      v6 = *(_DWORD *)(result + 12);
      if ( a2 >= v6 )
      {
        if ( a2 < v6 + *(_DWORD *)(result + 8) )
          break;
      }
      ++v3;
      result += 40;
      if ( v3 >= v4 )
        goto LABEL_5;
    }
  }
  else
  {
LABEL_5:
    result = 0;
  }
  return result;
}
 
//----- (00401890) --------------------------------------------------------
unsigned int __usercall sub_401890<eax>(int a1<eax>, int a2)
{
  int v2; // eax@2
  unsigned int result; // eax@3
  unsigned int v4; // [sp-10h] [bp-28h]@1
  unsigned int *v5; // [sp+0h] [bp-18h]@1
  int v6; // [sp+8h] [bp-10h]@1
  int (__cdecl *v7)(int, int, int, int); // [sp+Ch] [bp-Ch]@1
  unsigned int v8; // [sp+10h] [bp-8h]@1
  int v9; // [sp+14h] [bp-4h]@1
  int v10; // [sp+18h] [bp+0h]@1
 
  v7 = sub_4019B9;
  v6 = a1;
  v8 = dword_403000 ^ (unsigned int)&unk_4024C8;
  v4 = (unsigned int)&v10 ^ dword_403000;
  v5 = &v4;
  v9 = 0;
  if ( sub_401800(4194304) && (v2 = sub_401840(4194304, a2 - 4194304)) != 0 )
  {
    result = ~(unsigned __int8)(*(_DWORD *)(v2 + 36) >> 31) & 1;
    v9 = -2;
  }
  else
  {
    result = 0;
  }
  return result;
}
// 403000: using guessed type int dword_403000;
 
//----- (004019B9) --------------------------------------------------------
int __cdecl sub_4019B9(int a1, int a2, int a3, int a4)
{
  return except_handler4_common(&dword_403000, sub_4012F3, a1, a2, a3, a4);
}
// 401AC2: using guessed type int __cdecl except_handler4_common(_DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD);
// 403000: using guessed type int dword_403000;
 
//----- (004019DE) --------------------------------------------------------
errno_t __cdecl sub_4019DE()
{
  errno_t result; // eax@1
 
  result = controlfp_s(0, 0x10000u, 0x30000u);
  if ( result )
    result = invoke_watson(0, 0, 0, 0, 0);
  return result;
}
// 401AC8: using guessed type int __stdcall invoke_watson(_DWORD, _DWORD, _DWORD, _DWORD, _DWORD);
 
//----- (00401A06) --------------------------------------------------------
int __cdecl sub_401A06()
{
  return 0;
}
 
//----- (00401A09) --------------------------------------------------------
int __cdecl sub_401A09()
{
  int result; // eax@3
  DWORD v1; // esi@4
  DWORD v2; // esi@4
  DWORD v3; // esi@4
  DWORD v4; // esi@4
  LARGE_INTEGER PerformanceCount; // [sp+8h] [bp-10h]@4
  struct _FILETIME SystemTimeAsFileTime; // [sp+10h] [bp-8h]@1
 
  SystemTimeAsFileTime.dwLowDateTime = 0;
  SystemTimeAsFileTime.dwHighDateTime = 0;
  if ( dword_403000 != -1153374642 && dword_403000 & 0xFFFF0000 )
  {
    result = ~dword_403000;
    dword_403004 = ~dword_403000;
  }
  else
  {
    GetSystemTimeAsFileTime(&SystemTimeAsFileTime);
    v2 = GetCurrentProcessId() ^ SystemTimeAsFileTime.dwLowDateTime ^ SystemTimeAsFileTime.dwHighDateTime;
    v3 = GetCurrentThreadId() ^ v2;
    v4 = GetTickCount() ^ v3;
    QueryPerformanceCounter(&PerformanceCount);
    result = PerformanceCount.LowPart ^ PerformanceCount.HighPart;
    v1 = PerformanceCount.LowPart ^ PerformanceCount.HighPart ^ v4;
    if ( v1 == -1153374642 )
    {
      v1 = -1153374641;
    }
    else
    {
      if ( !(v1 & 0xFFFF0000) )
      {
        result = (v1 | 0x4711) << 16;
        v1 |= result;
      }
    }
    dword_403000 = v1;
    dword_403004 = ~v1;
  }
  return result;
}
// 403000: using guessed type int dword_403000;
// 403004: using guessed type int dword_403004;
 
//----- (00401AE0) --------------------------------------------------------
int __usercall sub_401AE0<eax>(__int64 a1<edx:eax>, unsigned __int8 a2<cl>)
{
  __int64 v2; // qax@3
 
  if ( a2 >= 0x40u )
  {
    LODWORD(v2) = 0;
  }
  else
  {
    if ( a2 >= 0x20u )
      LODWORD(v2) = 0;
    else
      v2 = a1 << (a2 & 0x1F);
  }
  return v2;
}
 
// ALL OK, 22 function(s) have been successfully decompiled
Оригинальный exe:
https://scrobly.com/c3wCYllkZx2CRY5owVaQ
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
30.08.2013, 18:50     Алгоритм шифрования из exe файла
Посмотрите здесь:

Алгоритм шифрования Рабина C++
C++ Алгоритм шифрования по ГОСТу
C++ Алгоритм шифрования DES
Алгоритм шифрования XTEA C++
C++ Алгоритм шифрования Anubis
алгоритм шифрования MISTY1 C++
Алгоритм шифрования RSA C++
C++ Написать AES, шифрования любого файла .exe.

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Герц
523 / 340 / 4
Регистрация: 05.11.2010
Сообщений: 1,077
Записей в блоге: 1
30.08.2013, 18:54     Алгоритм шифрования из exe файла #2
Там одни побитовые операции, разбирайся сидя с ручкой и блокнотом. Делать такую работу за тебя никто не станет.
GregoryRUS
0 / 0 / 0
Регистрация: 30.08.2013
Сообщений: 3
30.08.2013, 19:49  [ТС]     Алгоритм шифрования из exe файла #3
Спасибо. Разобрался )
Yandex
Объявления
30.08.2013, 19:49     Алгоритм шифрования из exe файла
Ответ Создать тему
Опции темы

Текущее время: 14:56. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru