Ora viva!
Já há uns tempos que tinha falado com o Dongs para fazer um KeygenMe para eu tentar keygennar porque nunca o tinha feito. Ele então fez um e eu pus mãos à obra.
[ kgme.tar.bz2 ]
$ ./kgme
Name: falso
Serial: 12345
Bad serial!
Abri então o ficheiro no IDA e andei a procurar por “Bad serial!”, e então que achei. Vai aqui um dump comentado:
0804830C movzx ecx, byte ptr [esi] ; ESI contem o "User"
0804830C ; e ECX contem o primeiro char do "User"
0804830F test ecx, ecx ; Se (ECX != 0x0) ZF=0 ELSE ZF=1
08048311 jz short loc_8048333 ; Se ZF=1 Salta pro drama
08048313 lea edx, [ebp-10Fh] ; EDX fica com "User" sem o primeiro char
08048319 mov ebx, 0DEADh
0804831E db 66h
0804831E nop ; No Operation
08048320
08048320 loc_8048320:
08048320 mov eax, ebx ; EAX passa a tar 0xDEAD tambem
08048322 shl eax, 5 ; Shift Logical Left 5 vezes
08048325 add eax, ecx ; Adiciona o valor do char do "User" (ECX) a EAX
08048327 movzx ecx, byte ptr [edx] ; le o proximo char pra ECX
0804832A add edx, 1 ; Add
0804832D add ebx, eax ; Add
0804832F test ecx, ecx ; Logical Compare
08048331 jnz short loc_8048320 ; Jump if Not Zero (ZF=0)
08048333
08048333 loc_8048333:
08048333 xor edx, edx ; Logical Exclusive OR
08048335 mov eax, offset aBadSerial ; "Bad serial!"
0804833A cmp [ebp-10h], ebx ; Compare Two Operands
0804833D setz dl ; Set Byte if Zero (ZF=1)
08048340 xor eax, offset aGoodSerial ; "Good serial!"
08048345 neg edx ; Two's Complement Negation
08048347 and eax, edx ; Logical AND
08048349 xor eax, offset aBadSerial ; "Bad serial!"
Então o funcionamento da coisa é mais ou menos o seguinte:
/\* inicialização(?) */
\* Le o Name para o registo ESI
\* Mete o primeiro char do Name no registo ECX
\* EDX fica com o Name sem o primeiro char
\* EBX fica com o valor 0xDEAD
/\* ciclo central */
\* Copia o valor de EBX para EAX
\* Faz um shift left 5 vezes a EAX
\* Adiciona o valor do char em ECX a EAX
\* Le o proximo char do Name para ECX
\* Adiciona 1 a EDX
\* Adiciona EAX a EBX
\* Se ECX nao for diferente de 0 salta para o inicio do ciclo
Vou tentar dar um exemplo:
User: Jim
/\* inicialização */
\* ESI = Jim
\* ECX = J (0x4a)
\* EDX = im
\* EBX = 0xdead
( valores dos registos )
-- ECX = J | EDX = im | EBX = 0xdead –
/\* ciclo central */
( Primeiro ciclo - J )
\* EAX = EBX
-- ECX = J | EDX = im | EBX = 0xdead | EAX = 0xdead –
\* shift left 5 vezes a EAX
-- ECX = J | EDX = im | EBX = 0xdead | EAX = 0x1bd5a0 –
\* adiciona o valor do char em ECX (J - 0x4a) a EAX
-- ECX = J | EDX = im | EBX = 0xdead | EAX = 0x1bd5ea –
\* Le o proximo char do Name pra ECX
-- ECX = i | EDX = im | EBX = 0xdead | EAX = 0x1bd5ea –
\* Adiciona 1 a EDX
-- ECX = i | EDX = m | EBX = 0xdead | EAX = 0x1bd5ea –
\* Adiciona EAX a EBX
-- ECX = i | EDX = m | EBX = 0x1cb497 | EAX = 0x1bd5ea –
\* Se ECX é diferente de 0 então do inicio de novo!
( Segundo ciclo - i )
\* EAX = EBX
-- ECX = i | EDX = m | EBX = 0x1cb497 | EAX = 0x1cb497 –
\* shift left 5 vezes a EAX
-- ECX = i | EDX = m | EBX = 0x1cb497 | EAX = 0x39692e0 –
\* adiciona o valor do char em ECX (i - 0x69) a EAX
-- ECX = i | EDX = m | EBX = 0x1cb497 | EAX = 0x3969349 –
\* Le o proximo char do Name pra ECX
-- ECX = m | EDX = m | EBX = 0x1cb497 | EAX = 0x3969349 –
\* Adiciona 1 a EDX (fica limpo)
-- ECX = m | EBX = 0x1cb497 | EAX = 0x3969349 –
\* Adiciona EAX a EBX
-- ECX = m | EBX = 0x3b347e0 | EAX = 0x3969349 –
\* Se ECX é diferente de 0 então do inicio de novo!
( Terceiro ciclo - m )
\* EAX = EBX
-- ECX = m | EBX = 0x3b347e0 | EAX = 0x3b347e0 –
\* shift left 5 vezes a EAX
-- ECX = m | EBX = 0x3b347e0 | EAX = 0x7668fc00 –
\* adiciona o valor do char em ECX (m - 0x6d) a EAX
-- ECX = m | EBX = 0x3b347e0 | EAX = 0x7668fc6d –
\* Le o proximo char do Name pra ECX (fica limpo)
-- EBX = 0x3b347e0 | EAX = 0x7668fc6d –
\* Adiciona 1 a EDX (continua limpo)
-- EBX = 0x3b347e0 | EAX = 0x7668fc6d –
\* Adiciona EAX a EBX
-- EBX = 0x7a1c444d | EAX = 0x7668fc6d –
\* ECX é zero, então temos a serial em EBX
$ kgme
Name: Jim
Serial: 7a1c444d
Good serial!
Fiz uma implementação em C++ do keygen, que a única coisa que usa de c++ é o cout mas mesmo assim, aqui vai:
//============================================================================
// Name : lolkg.cpp
// Author : falso
// Version : 0.1-pre1-beta2-rc4
// Copyright : WTFPL
// Description : Keygen para o kgme do dongs
//============================================================================
#include <iostream>
using namespace std;
int main() {
char name[50];
cout << "| | |\n";
cout << "| ,---.| |__/ ,---.\n";
cout << "| | || | \\ | |\n";
cout << "`---'`---'`---'` ``---|\n";
cout << " `---'\n";
cout << "Name: " << flush;
cin >> name;
int ebx = 0xdead;
int eax = ebx;
int ecx = name[0];
int i = 1;
while (ecx != 0x0) {
eax = ebx;
eax = eax << 5;
eax = eax + ecx;
ecx = name[i];
i++;
ebx = ebx + eax;
}
printf("Serial: %x\n",ebx);
return 0;
}
E já agora, uma em MIPS assembly pro PCSpim:
# this asm can never fail
#
# lolkg
.data
us: .asciiz "User: "
u: .space 50
.text
.globl main
main:
# print user..
li $v0,4
la $a0,us
syscall
# get string
li $v0,8
la $a0,u
syscall
# variavel inicial do algoritmo
li $s0,0xdead # s0 - ebx
move $s1,$s0 # s1 - eax
la $s5,u # tmp
#apanha o primeiro char do Username
lb $s2,0($s5) # s2 - ecx
_while:
move $s1,$s0
sll $s1,$s1,5
add $s1,$s1,$s2
addi $s5,$s5,1
lb $s2,0($s5) # s2 - ecx
addu $s0,$s0,$s1
bne $s2,0xa,_while
# imprime o serial, mas em decimal ;-(
# nao sei como imprimir em hex, pois o serial é em HEX
li $v0,1
move $a0,$s0
syscall
#sai
li $v0,10
syscall
Espero que todo este conhecimento inútil sirva para alguém, nem que seja pra despertar um bichozinho pequenino pro cracking! Fiquem bem, e crackem muito!
