Keygen Feito em python

[Aof]

 

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 at 04:29 PM by Aof

[Aof]

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 at 01:57 AM by Aof

[Will]

Olá, amigo!

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

[Edno Garcia]

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]

Aqui, meu amigo.

The+0 Selftest for Crackers.exe

[Will]

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

Aqui, meu amigo.

The+0 Selftest for Crackers.exe

Obrigado!

[paulosgf]

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.

[]'s

[1] https://github.com/crypto2011/IDR
[2] https://www.softpedia.com/get/Programming/Debuggers-Decompilers-Dissasemblers/DeDe.shtml#download
[3] https://www.sawatzki.de/download.htm