Keygen Feito em python

Aof · June 12, 2018

k.png.ae1e9d5bad5a0b0ceefc7f3cdb3e79e2.png

Este e um keygen simples feito em python, ele e voltado a resolver um algoritmo de um crack-me que encontrei na net, e como agente não ver por ai como é feito um keygen fiz o meu próprio em um script bem simples mas que funciona. lembrando que isso deve ser usado para fiz educacionais.

##############################
# Autor: Aof #
# date: 09/06/2018 #
# name: KEyGen User and Pass #
##############################

string = input('user: ') #entrada do usuario
const = 51651293 #serial inicial. obs uma constante
print('Pass for user: '+string)

#loop que faz o Bitwise
for i in string:
x=ord(i) #pega o valor ascii do 'i' e move para o x
#print(x)
const += x #soma o const com o valor de x

print(const) #mostra o serial final

Explicação: O keygen primeiro pega o tamanho do texto digitado, depois ele faz um loop, nesse loop ele pega o valor da letra na tabela ASCII e com esse valor o algoritmo somado com a constante 51651293. Com isso sabemos que conforme a loop for rodando a constante vai sendo incrementada e na final da o resultado esperado, nosso serial.

Edited June 13, 2018 by Aof

Aof · June 12, 2018

0043B1B7 CALL teste.0041AED4 ; PEGOU O USER DIGITADO
0043B1BC CMP DWORD PTR SS:[EBP-8],0
0043B1C0 JE teste.0043B289
0043B1C6 MOV EDI,31422DD ; NOSSA CONSTANTE EM HEX, VALOR EM DECIMAL = 51651293
0043B1CB LEA EDX,DWORD PTR SS:[EBP-8] ; EAX RECEBE A STRING USER
0043B1CE MOV EAX,DWORD PTR SS:[EBP-4]
0043B1D1 MOV EAX,DWORD PTR DS:[EAX+280]
0043B1D7 CALL teste.0041AED4 ; PEGOU O LEN DE USER
0043B1DC MOV EAX,DWORD PTR SS:[EBP-8]
0043B1DF CALL teste.00403934
0043B1E4 MOV EBX,EAX
0043B1E6 TEST EBX,EBX
0043B1E8 LE SHORT teste.0043B20E
0043B1EA MOV ESI,1
0043B1EF LEA EDX,DWORD PTR SS:[EBP-8]
0043B1F2 MOV EAX,DWORD PTR SS:[EBP-4]
0043B1F5 MOV EAX,DWORD PTR DS:[EAX+280]
0043B1FB CALL teste.0041AED4 ; PEGOU O USER DIGITADO
0043B200 MOV EAX,DWORD PTR SS:[EBP-8]
0043B203 MOVZX EAX,BYTE PTR DS:[EAX+ESI-1] ; pega o primeiro byte e
0043B208 ADD EDI,EAX ; o valor 031422DD (DEC = 51651293) e inc com valor ascii do byte
0043B20A INC ESI
0043B20B DEC EBX
0043B20C JNZ SHORT teste.0043B1EF

Edited June 12, 2018 by Aof

Will · January 27, 2019

Olá, amigo!

Poderia disponibilizar o download desse "The +0 Selftest for Crackers"?

Edno Garcia · February 16, 2019

Em 27/01/2019 em 18:32, Will disse:

Olá, amigo!

Poderia disponibilizar o download desse "The +0 Selftest for Crackers"?

Fiz uma traduçao desse programinha. Assim que possível, posto pra vc baixar, amigo.

Edno Garcia · March 2, 2019

Aqui, meu amigo.

The+0 Selftest for Crackers.exe

Will · March 7, 2019

Em 02/03/2019 em 15:46, Edno Garcia disse:

Aqui, meu amigo.

The+0 Selftest for Crackers.exe

Obrigado!

paulosgf · July 1, 2022

Galera, segue minha resolução do desafio nível "Fácil"

Primeiramente, verificamos no DiE que se trata de um crackme em Delphi que esconde a WinAPI debaixo de várias camadas de sua biblioteca própria, a Visual Component Library (VCL) usada em formulários e que só então chama as funções Windows em nível mais baixo. Então temos de usar um decodificador dos componentes do formulário Delphi, como o Interactive Delphi Reconstructor (IDR). [1]

Abrir o programa no IDR -> File -> Load File -> Autodetect Version
Localizar a main() do Delphi, classe TMain:
IDR -> Forms (F5) -> Text -> TMAIN {main} -> (duplo clique)
Localizar o objeto TButton e seu evento OnClick relacionado conforme imagem:

Há também o Delphi Decompiler (DeDe), que pode ser mais prático para alguns do que o IDR. [2]

Configurar o IDA Free com a assinatura FLIRT da VCL, pois facilita muito a identificação dos componentes. Certifique-se de que a assinatura FLIRT mssdk32 seja adicionada também. Vide em [3].

O Delphi usa a convenção de chamada fastcall, porém é diferente da chamada fastcall do Windows. Os parâmetros são passados nesta ordem: EAX, EDX, ECX, os outros na pilha. Para classes, o ponteiro this é passado em EAX. Quando um construtor é chamado, a estrutura da classe é passada em EAX e o ponteiro this é também retornado em EAX.
Configurar o IDA:
Options -> Compiler ->
Compiler = Delphi
Calling convention = Fastcall

O Delphi usa strings no estilo Pascal. O comprimento da string é especificado no início da string. As strings armazenadas no arquivo binário estão no formato estilo C, primeiro precisam ser convertidas chamando o método LStrAsg().
Novamente configurar o IDA em: Options -> String Literals -> Manage Defaults -> Default String Literal Type = Delphi

Agora buscar o evento Button4Click que aparece como TMain_Button4Click, visto que é derivado da TMain. Ele começa no offset 0x0043B374. Recebe a entrada no campo TMain.Edit4:TEdit através da função @TControl@GetText. Em seguida calcula o tamanho da entrada com a função @@LStrLen.

O Algoritmo é meio confuso, conforme se vê na seção codificação, então simulei ele em um script python para facilitar o entendimento...

#!/usr/bin/env python3

txt = input("no que estou pensando... ") # Entrada
laco = 16   # 16 passadas
acumul = 0  # Variável temporaria que acumula codificação de cada char da entrada
cod = 0     # Saída codificada

while (laco > 0):
    print("LACO: " + str(laco)) # Informa nova passada
    tam = len(txt)              # Tamanho da entrada
    contador = 1                # Conta cada char da entrada
    for n in range(0,tam):      # Laço percorrendo toda a entrada
        ch = ord(txt[n])
        print(chr(ch) + ": " +  hex(ch))    # Char e seu valor ASCII
        resto = contador + acumul           
        ch = ch + resto
        acumul = ch
        print("acumulador: " + hex(acumul)) # Char codificado nesta volta
        cod += cod
        cod = cod ^ acumul
        ch = acumul
        resto = ch % contador   
        resto += 1
        print("resto: " + hex(resto))       # Resto da divisão entre char e contador
        ch = int(ch / contador)
        print("quociente: " + hex(ch))      # Quociente da divisão
        cod += int(resto)                   # Valor codificado da entrada nesta volta
        print("codificacao: " + "0x{}".format(hex(cod)[len(hex(cod))-8:len(hex(cod))]))
        contador += 1
        print("contador: " + hex(contador)) # Incrementa contador de char
        tam -= 1
        print("tamanho: " + hex(tam))       # Decrementa tamanho da entrada
        print("\n")

    laco -= 1                   # Decrementa uma volta no laço

... porém como é um algoritmo de Hash, não é reversível (one-way-hash). Sem as variáveis resto da divisão e, principalmente o tamanho da entrada original, não há como recuperá-la. Talvez se analisando o incremento a cada passada do hash dentro do espaço de endereçamento do algoritmo seja possível deduzir o tamanho, mas ai foge do escopo "Fácil", proposto pelo desafio.

A codificação é feita em cada char num laço repetido 16 vezes. Em seguida vem a 1ª validação comparando com o valor 0x3810.

No x64dbg, iniciar com um breakpoint no endereço de inicio da rotina de codificação, em 0x0043B3C3. Dar F9.
Após o algoritmo de codificação, há 4 testes nos endereços 0x0043B3FA, 0x0043B402, 0x0043B428, 0x0043B452. Definir um breakpoint em cada um e remover o do inicio do algoritmo de codificação. Dar novamente F9, parando no 1º teste. Executar a instrução de comparação com F8 e, em seguida na instrução de salto, habilidar a Zero Flag (ZF=1) com duplo-clique. Repetir os mesmos passos para os demais testes até chegar ao final, onde qualquer senha é aceita.