Сейчас на форуме: asfa (+6 невидимых)

 eXeL@B —› Вопросы новичков —› Кейген для телепорт и тому подобных...
Посл.ответ Сообщение

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

 Создано: 03 июня 2010 17:23
· Личное сообщение · #1

В топике "программы с простой защитой часть 1" была дана ссылка на teleport, как на программу с простой защитой и несложным генератором ключа. Вот мне интересно узнать как для неё вычислить алгоритм генерирования ключа.
По-моему в деле участвует вот этот код, только не смекну что к чему.
Code:
  1. 004350E0  /$ 8B4C24 04      MOV     ECX, DWORD PTR SS:[ESP+4]
  2. 004350E4  |. F7C1 03000000  TEST    ECX, 3
  3. 004350EA  |. 74 14          JE      SHORT pro.00435100
  4. 004350EC  |> 8A01           /MOV     AL, BYTE PTR DS:[ECX]
  5. 004350EE  |. 41             |INC     ECX
  6. 004350EF  |. 84C0           |TEST    AL, AL
  7. 004350F1  |. 74 40          |JE      SHORT pro.00435133
  8. 004350F3  |. F7C1 03000000  |TEST    ECX, 3
  9. 004350F9  |.^75 F1          \JNZ     SHORT pro.004350EC
  10. 004350FB  |. 05 00000000    ADD     EAX, 0
  11. 00435100  |> 8B01           /MOV     EAX, DWORD PTR DS:[ECX]
  12. 00435102  |. BA FFFEFE7E    |MOV     EDX, 7EFEFEFF
  13. 00435107  |. 03D0           |ADD     EDX, EAX
  14. 00435109  |. 83F0 FF        |XOR     EAX, FFFFFFFF
  15. 0043510C  |. 33C2           |XOR     EAX, EDX
  16. 0043510E  |. 83C1 04        |ADD     ECX, 4
  17. 00435111  |. A9 00010181    |TEST    EAX, 81010100
  18. 00435116  |.^74 E8          |JE      SHORT pro.00435100
  19. 00435118  |. 8B41 FC        |MOV     EAX, DWORD PTR DS:[ECX-4]
  20. 0043511B  |. 84C0           |TEST    AL, AL
  21. 0043511D  |. 74 32          |JE      SHORT pro.00435151
  22. 0043511F  |. 84E4           |TEST    AH, AH
  23. 00435121  |. 74 24          |JE      SHORT pro.00435147
  24. 00435123  |. A9 0000FF00    |TEST    EAX, 0FF0000
  25. 00435128  |. 74 13          |JE      SHORT pro.0043513D
  26. 0043512A  |. A9 000000FF    |TEST    EAX, FF000000
  27. 0043512F  |. 74 02          |JE      SHORT pro.00435133
  28. 00435131  |.^EB CD          \JMP     SHORT pro.00435100
  29. 00435133  |> 8D41 FF        LEA     EAX, DWORD PTR DS:[ECX-1]
  30. 00435136  |. 8B4C24 04      MOV     ECX, DWORD PTR SS:[ESP+4]
  31. 0043513A  |. 2BC1           SUB     EAX, ECX
  32. 0043513C  |. C3             RETN
  33. 0043513D  |> 8D41 FE        LEA     EAX, DWORD PTR DS:[ECX-2]
  34. 00435140  |. 8B4C24 04      MOV     ECX, DWORD PTR SS:[ESP+4]
  35. 00435144  |. 2BC1           SUB     EAX, ECX
  36. 00435146  |. C3             RETN
  37. 00435147  |> 8D41 FD        LEA     EAX, DWORD PTR DS:[ECX-3]
  38. 0043514A  |. 8B4C24 04      MOV     ECX, DWORD PTR SS:[ESP+4]
  39. 0043514E  |. 2BC1           SUB     EAX, ECX
  40. 00435150  |. C3             RETN
  41. 00435151  |> 8D41 FC        LEA     EAX, DWORD PTR DS:[ECX-4]
  42. 00435154  |. 8B4C24 04      MOV     ECX, DWORD PTR SS:[ESP+4]
  43. 00435158  |. 2BC1           SUB     EAX, ECX
  44. 0043515A  \. C3             RETN

Кто-нобудь может подсказать как вычисляются подобные алгоритмы генерации ключа?




Ранг: 756.3 (! !), 113thx
Активность: 0.61↘0.05
Статус: Участник
Student

 Создано: 03 июня 2010 17:41
· Личное сообщение · #2

Смотря о чём речь... Есть несколько вариантов Teleport и много версий для каждого
для версии Teleport Pro 1.62 а код видимо оттуда, это абсолютно не тот код
смотри проверку:
Code:
  1. 0042EEBA   .  E8 AE090000   CALL pro.0042F86D
  2. 0042EEBF   .  3BF0          CMP ESI,EAX
  3. 0042EEC1   .  59            POP ECX
  4. 0042EEC2   .  75 0F         JNZ SHORT pro.0042EED3

и в частности процедуру генерации по адресу 0042F86D

-----
z+Dw7uLu5+jqLCDq7vLu8PvpIPHs7uMh


Ранг: 533.6 (!), 232thx
Активность: 0.45↘0
Статус: Uploader
retired

 Создано: 03 июня 2010 17:51
· Личное сообщение · #3

ekkl это вообще ф-ия strlen
Code:
  1. strlen  proc \
  2.         buf:ptr byte
  3.  
  4.         OPTION PROLOGUE:NONE, EPILOGUE:NONE
  5.  
  6.         .FPO    ( 0, 1, 0, 0, 0, 0 )
  7.  
  8. string  equ     [esp + 4]
  9.  
  10.         mov     ecx,string              ; ecx -> string
  11.         test    ecx,3                   ; test if string is aligned on 32 bits
  12.         je      short main_loop
  13.  
  14. str_misaligned:
  15.         ; simple byte loop until string is aligned
  16.         mov     al,byte ptr [ecx]
  17.         add     ecx,1
  18.         test    al,al
  19.         je      short byte_3
  20.         test    ecx,3
  21.         jne     short str_misaligned
  22.  
  23.         add     eax,dword ptr 0         ; 5 byte nop to align label below
  24.  
  25.         align   16                      ; should be redundant
  26.  
  27. main_loop:
  28.         mov     eax,dword ptr [ecx]     ; read 4 bytes
  29.         mov     edx,7efefeffh
  30.         add     edx,eax
  31.         xor     eax,-1
  32.         xor     eax,edx
  33.         add     ecx,4
  34.         test    eax,81010100h
  35.         je      short main_loop
  36.         ; found zero byte in the loop
  37.         mov     eax,[ecx - 4]
  38.         test    al,al                   ; is it byte 0
  39.         je      short byte_0
  40.         test    ah,ah                   ; is it byte 1
  41.         je      short byte_1
  42.         test    eax,00ff0000h           ; is it byte 2
  43.         je      short byte_2
  44.         test    eax,0ff000000h          ; is it byte 3
  45.         je      short byte_3
  46.         jmp     short main_loop         ; taken if bits 24-30 are clear and bit
  47.                                         ; 31 is set
  48.  
  49. byte_3:
  50.         lea     eax,[ecx - 1]
  51.         mov     ecx,string
  52.         sub     eax,ecx
  53.         ret
  54. byte_2:
  55.         lea     eax,[ecx - 2]
  56.         mov     ecx,string
  57.         sub     eax,ecx
  58.         ret
  59. byte_1:
  60.         lea     eax,[ecx - 3]
  61.         mov     ecx,string
  62.         sub     eax,ecx
  63.         ret
  64. byte_0:
  65.         lea     eax,[ecx - 4]
  66.         mov     ecx,string
  67.         sub     eax,ecx
  68.         ret
  69.  
  70. strlen  endp


-----
Лучше быть одиноким, но свободным © $me

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

 Создано: 03 июня 2010 19:36
· Личное сообщение · #4

>> ekkl это вообще ф-ия strlen
Да?
Не подумал бы. Но в eax она возвращает длину строки. Почему-то вызывается раз пять.....
Что-то не совсем понятен алгоритм её работы. и что значит
Code:
  1.  mov     edx,7efefeffh

Isaev, код тот
Code:
  1. 0042F86D  /$ 57             PUSH    EDI
  2. 0042F86E  |. 8B7C24 08      MOV     EDI, DWORD PTR SS:[ESP+8]
  3. 0042F872  |. 85FF           TEST    EDI, EDI
  4. 0042F874  |. 74 09          JE      SHORT pro.0042F87F
  5. 0042F876  |. 57             PUSH    EDI
  6. 0042F877  |. E8 64580000    CALL    pro.004350E0

Процедура генерации вызывает приведенные мною выше участок кода.
Ну да ладно, если это strlen




Ранг: 533.6 (!), 232thx
Активность: 0.45↘0
Статус: Uploader
retired

 Создано: 03 июня 2010 19:45
· Личное сообщение · #5

ekkl пишет:
Что-то не совсем понятен алгоритм её работы.
ну с этим до разработчиков МС

-----
Лучше быть одиноким, но свободным © $me


Ранг: 673.3 (! !), 400thx
Активность: 0.4↘0.31
Статус: Участник
CyberMonk

 Создано: 03 июня 2010 20:08
· Личное сообщение · #6

ekkl

Code:
  1. int strlen(char const* s)
  2. {
  3.     /* Search index.
  4.     * The input pointer is still needed for length calculation.
  5.     */
  6.     char const* p = s;
  7.  
  8.     /* Bit patterns (32 bit system), temporary.
  9.     * The three used 32 bit patterns are 0x7efefeff (7efefeff,
  10.     * 7efefeffh, m), 0x81010101 (81010101, 81010101h, -m) and 0x81010100
  11.     * (81010100, 81010100h, ~m).
  12.     * On 64 bit systems, the pattern would be 0x7efefefefefefeff (its
  13.     * complement 0x8101010101010101).
  14.     */
  15.     int m = 0x7efefeff, n = ~m, i;
  16.  
  17.     /* Advance the search index until it is aligned to the data size
  18.     * used in the following search loop; do a conventional search on
  19.     * that unaligned part at the same time, since the string may be
  20.     * short (shorter than sizeof(int)-1).
  21.     * This loop is not entered in the more optimal case of an input
  22.     * string being aligned (compilers may chose to e.g. align string
  23.     * literals, dynamically allocated buffers are aligned, etc).
  24.     * Alignment of the subsequent multi-byte data accesses is an
  25.     * optimization, since misaligned data accesses include a performance
  26.     * penalty and possibly use more than one cache line, or are even
  27.     * disallowed and generate a bus error, e.g. in RISC architectures.
  28.     * This step will take less than sizeof(int) loop iterations.
  29.     * The &(sizeof(int)-1) operation is an optimized %sizeof(int)
  30.     * (assuming sizeof(int) is a power-of-two), since bit operations are
  31.     * more performant than arithmetic operations (in this case, with an
  32.     * operand that is known at compile time, the compiler/optimizer
  33.     * might generate the same code for the %-operation).
  34.     * The !=0 part is left away here (and also at other places) in the
  35.     * conditional expression , which might be a reflection of the fact
  36.     * that the compiler may directly use the zero-conditional produced
  37.     * by the &-operation.
  38.     */
  39.     for (; (int)p & (sizeof(int) - 1); p++) {
  40.  
  41.         /* Check for end-of-string too (relevant with small, unaligned
  42.         * strings, see earlier comment too).
  43.         */
  44.         if (!*p) {
  45.             return p - s;
  46.         }
  47.     }
  48.  
  49.     /* Aligned multi-byte data search loop, in pieces of sizeof(int)
  50.     * (by C language definition, int is the most natural data size for
  51.     * CPUs to operate on; maybe not with 64 bit systems in LP64 mode
  52.     * [only longs and pointers native; int remains 32 bit, for software
  53.     * compatibility and/or resource saving], in which long may be the
  54.     * natural data size).
  55.     * One multi-byte data-access is done per iteration instead of
  56.     * sizeof(int) single-byte data-accesses (a single multi-byte
  57.     * data-access may even be faster than one single-byte data-access).
  58.     * Each iteration uses one subtraction/addition/comparison instead
  59.     * of sizeof(int).
  60.     */
  61.     for (;;) {
  62.  
  63.         /* Next sizeof(int) aligned string bytes.
  64.         * We may read up to sizeof(int)-1 bytes beyond the string
  65.         * (excluding its terminating nul byte), which is not a problem
  66.         * with memory (page) maps, since the (mapped) pages are aligned
  67.         * to a multiple of sizeof(int) and so an aligned int can't cross
  68.         * two pages.
  69.         * However, memory boundary check tools may trigger warnings
  70.         * (such as uninitialized memory read, etc).
  71.         */
  72.         i = *(int const*)p;
  73.  
  74.         /* Check if this chunk is a candidate for having embedded nul
  75.         * bytes.
  76.         * This algorithm assumes two's complement integer
  77.         * representation.
  78.         * i+0x7efefeff is the same as i-0x81010101.
  79.         * Subtracting 1 from each (possible nul) byte will flip its
  80.         * least significant bit, and possibly some more, depending on
  81.         * the input (all bits up to the least significant set bit).
  82.         * If the byte was zero (all bits cleared, a nul byte), all bits
  83.         * are flipped and a carry bit is generated into the next
  84.         * significant byte, which flips the next byte's least
  85.         * significant bit a second time.
  86.         * Since we cannot (and don't want) to check the
  87.         * int-carry-out-bit (the most significant byte's carry) in C,
  88.         * the most significant byte's most significant bit is used to do
  89.         * that check, which leads to false candidates if only that bit
  90.         * was set in the most significant byte (i.e. the most
  91.         * significant byte was a \x80 byte).
  92.         * These false candidates weaken the search algorithm's
  93.         * performance a bit.
  94.         * Comparing the subtraction-flip result with the logic-flip
  95.         * result (^~i), while only considering the sizeof(int) bits of
  96.         * interest (&0x81010100), will reveal if carries have occurred
  97.         * (double-bit-flip vs. single-bit-flip).
  98.         */
  99.         if (!(((i + m) ^ ~i) & n)) {
  100.  
  101.             /* This chunk is not a candidate, which means it does not
  102.             * include nul bytes.
  103.             * Advance sizeof(int) bytes.
  104.             */
  105.             p += sizeof(int);
  106.  
  107.         } else {
  108.  
  109.             /* This chunk is a candidate, which means it may include nul
  110.             * bytes or, at the most significant byte, a \x80.
  111.             * Searches on strings containing lots of such bytes will be
  112.             * less-than-optimized.
  113.             * Conventionally search for a nul (and its position) in
  114.             * sizeof(int) bytes and continue chunked search if none is
  115.             * found (with a false candidate, see comments above), in
  116.             * which case the search index is advanced too by sizeof(int)
  117.             * bytes.
  118.             */
  119.             for (i = sizeof(int); i; p++, i--) {
  120.                 if (!*p) {
  121.                     return p - s;
  122.                 }
  123.             }
  124.         }
  125.     }
  126. }


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

-----
RE In Progress [!] Coding Hazard [!] Stay Clear of this Cube


Ранг: 164.6 (ветеран), 65thx
Активность: 0.12↘0
Статус: Участник
Волшебник

 Создано: 03 июня 2010 21:05
· Личное сообщение · #7

Чего? Хоть сам понял что сказал? Учить, учить и ещё раз учить мат.часть.

-----
Следуй за белым кроликом


Ранг: 355.4 (мудрец), 55thx
Активность: 0.32↘0
Статус: Uploader
5KRT

 Создано: 03 июня 2010 22:35 · Поправил: Coderess
· Личное сообщение · #8

Мда, телепорт этож первый мой кейген
Пользуйся идой в ней есть куча сигнатур для разных компилеров.

-----
Gutta cavat lapidem. Feci, quod potui. Faciant meliora potentes

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

 Создано: 03 июня 2010 23:34 · Поправил: ekkl
· Личное сообщение · #9

А без ИДЫ никак?
И как сигнатура может помочь в вычислении кейгена?
---
Кстати, удалось вычислить, что сначала выполняются какие-то операции с ведённым серийником, получается 32 разрядное число.
Потом имя пользователя (без последних 4 букв) побуквенно ксориться с 5DFEE4A4. Затем сравниваются числа полученные в первом и втором случае..




Ранг: 756.3 (! !), 113thx
Активность: 0.61↘0.05
Статус: Участник
Student

 Создано: 03 июня 2010 23:54
· Личное сообщение · #10

ekkl пишет:
А без ИДЫ никак?
я вообще не знаю как ей пользоваться, т.ч. очень даже как

начало я тебе дал, процедура там простенькая совсем, т.ч. не спеши и всё разберёшь

-----
z+Dw7uLu5+jqLCDq7vLu8PvpIPHs7uMh


Ранг: 355.4 (мудрец), 55thx
Активность: 0.32↘0
Статус: Uploader
5KRT

 Создано: 04 июня 2010 00:12 · Поправил: Coderess
· Личное сообщение · #11

Да конечно можно и без иды, просто некоторые функции можно посмотреть в иде и вернутся обратно в ольку, ты на правильном пути, попроходи 0x0042EEBA пару раз, не забывай коментировать -- очень помогает.

-----
Gutta cavat lapidem. Feci, quod potui. Faciant meliora potentes
 eXeL@B —› Вопросы новичков —› Кейген для телепорт и тому подобных...
:: Ваш ответ
Жирный  Курсив  Подчеркнутый  Перечеркнутый  {mpf5}  Код  Вставить ссылку 
:s1: :s2: :s3: :s4: :s5: :s6: :s7: :s8: :s9: :s10: :s11: :s12: :s13: :s14: :s15: :s16:


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