Ir para conteúdo

Keygen Feito em python


Aof

Posts Recomendados

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.

k2.thumb.png.04271166c0cf01e84887c666c0cf8da4.png

Editado por Aof
  • Curtir 3
Link para o comentário
Compartilhar em outros sites

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

Editado por Aof
  • Curtir 2
Link para o comentário
Compartilhar em outros sites

  • 7 meses depois...
  • 3 semanas depois...
  • 2 semanas depois...
  • 3 anos depois...
  • Apoiador Byte

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]

facil.thumb.png.1a06a8613be396bfa884e07f6bd7b222.png

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:

facil0.thumb.png.d3701b2d9a87335e17eca8019b25ee2d.png

facil1.thumb.png.6d8db58d0130dc226882b45e178fa3a0.png

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

facil2.thumb.png.f9ac90eb9dda8eb3cfe623476f88eb7b.png

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

facil3.thumb.png.4a51535971e564fffdc1359f68b1e13d.png

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.

facil4.thumb.png.bcf0d65af34028530a1d39684d4d0a8b.png

 

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.

facil5.thumb.png.0d2948a7237dabc23b9880d42a80f955.png

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.

facil6.thumb.png.175c438d60c63a5bc44c5282c6773ac7.png

facil7.thumb.png.4eb93115ce0965cdaeb650ea5bfb91fd.png

facil8.thumb.png.af8be609b7b7c8d710b91ddedb298e2d.png

facil9.thumb.png.e2db79496eed491a2e64b6ea5c8c8a43.png

[]'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

 

  • Curtir 2
Link para o comentário
Compartilhar em outros sites

Participe da conversa

Você pode postar agora e se cadastrar mais tarde. Se você tem uma conta, faça o login para postar com sua conta.

Visitante
Responder

×   Você colou conteúdo com formatação.   Remover formatação

  Apenas 75 emojis são permitidos.

×   Seu link foi automaticamente incorporado.   Mostrar como link

×   Seu conteúdo anterior foi restaurado.   Limpar o editor

×   Não é possível colar imagens diretamente. Carregar ou inserir imagens do URL.

  • Quem Está Navegando   0 membros estão online

    • Nenhum usuário registrado visualizando esta página.
×
×
  • Criar Novo...