Como converte Assemby Language para Codigo Visual Basic , isso é possível?

Assuntos Gerais
#1

Algo como usar e converter esse codigo para Visual Basic

Private Sub Command2_Click() '4C47B0 loc_004C47B0: push ebp loc_004C47B1: mov ebp, esp loc_004C47B3: sub esp, 00000018h loc_004C47B6: push 00402826h ; loc_004C47BB: mov eax, fs:[00h] loc_004C47C1: push eax loc_004C47C2: mov fs:[00000000h], esp loc_004C47C9: mov eax, 00000030h loc_004C47CE: call 00402820h ; loc_004C47D3: push ebx loc_004C47D4: push esi loc_004C47D5: push edi loc_004C47D6: mov var_18, esp loc_004C47D9: mov var_14, 00402710h loc_004C47E0: mov eax, arg_8 loc_004C47E3: and eax, 00000001h loc_004C47E6: mov var_10, eax loc_004C47E9: mov ecx, arg_8 loc_004C47EC: and ecx, FFFFFFFEh loc_004C47EF: mov arg_8, ecx loc_004C47F2: mov var_C, 00000000h loc_004C47F9: mov edx, arg_8 loc_004C47FC: mov eax, [edx] loc_004C47FE: mov ecx, arg_8 loc_004C4801: push ecx loc_004C4802: call [eax+04h] loc_004C4805: mov var_4, 00000001h loc_004C480C: mov var_4, 00000002h loc_004C4813: push FFFFFFFFh loc_004C4815: call On Error ... loc_004C481B: mov var_4, 00000003h loc_004C4822: cmp [004C6010h], 00000000h loc_004C4829: jnz 4C4844h loc_004C482B: push 004C6010h loc_004C4830: push 0040A830h loc_004C4835: call [00401114h] ; loc_004C483B: mov var_44, 004C6010h loc_004C4842: jmp 4C484Bh loc_004C4844: mov var_44, 004C6010h loc_004C484B: mov edx, var_44 loc_004C484E: mov eax, [edx] loc_004C4850: mov var_28, eax loc_004C4853: push 00411534h ; "NO" loc_004C4858: mov ecx, var_28 loc_004C485B: mov edx, [ecx] loc_004C485D: mov eax, var_28 loc_004C4860: push eax loc_004C4861: call [edx+000001C4h] loc_004C4867: fclex loc_004C4869: mov var_2C, eax loc_004C486C: cmp var_2C, 00000000h loc_004C4870: jnl 4C488Fh loc_004C4872: push 000001C4h loc_004C4877: push 00410E44h loc_004C487C: mov ecx, var_28 loc_004C487F: push ecx loc_004C4880: mov edx, var_2C loc_004C4883: push edx loc_004C4884: call [00401054h] ; loc_004C488A: mov var_48, eax loc_004C488D: jmp 4C4896h loc_004C488F: mov var_48, 00000000h loc_004C4896: mov var_4, 00000004h loc_004C489D: cmp [004C6D20h], 00000000h loc_004C48A4: jnz 4C48BFh loc_004C48A6: push 004C6D20h loc_004C48AB: push 00412010h loc_004C48B0: call [00401114h] ; loc_004C48B6: mov var_4C, 004C6D20h loc_004C48BD: jmp 4C48C6h loc_004C48BF: mov var_4C, 004C6D20h loc_004C48C6: mov eax, var_4C loc_004C48C9: mov ecx, [eax] loc_004C48CB: mov var_28, ecx loc_004C48CE: mov edx, arg_8 loc_004C48D1: push edx loc_004C48D2: lea eax, var_24 loc_004C48D5: push eax loc_004C48D6: call [00401080h] ; loc_004C48DC: push eax loc_004C48DD: mov ecx, var_28 loc_004C48E0: mov edx, [ecx] loc_004C48E2: mov eax, var_28 loc_004C48E5: push eax loc_004C48E6: call [edx+10h] loc_004C48E9: fclex loc_004C48EB: mov var_2C, eax loc_004C48EE: cmp var_2C, 00000000h loc_004C48F2: jnl 4C490Eh loc_004C48F4: push 00000010h loc_004C48F6: push 00412000h loc_004C48FB: mov ecx, var_28 loc_004C48FE: push ecx loc_004C48FF: mov edx, var_2C loc_004C4902: push edx loc_004C4903: call [00401054h] ; loc_004C4909: mov var_50, eax loc_004C490C: jmp 4C4915h loc_004C490E: mov var_50, 00000000h loc_004C4915: lea ecx, var_24 loc_004C4918: call [00401194h] ; loc_004C491E: mov var_10, 00000000h loc_004C4925: push 004C4937h loc_004C492A: jmp 4C4936h loc_004C492C: lea ecx, var_24 loc_004C492F: call [00401194h] ; loc_004C4935: ret loc_004C4936: ret loc_004C4937: mov eax, arg_8 loc_004C493A: mov ecx, [eax] loc_004C493C: mov edx, arg_8 loc_004C493F: push edx loc_004C4940: call [ecx+08h] loc_004C4943: mov eax, var_10 loc_004C4946: mov ecx, var_20 loc_004C4949: mov fs:[00000000h], ecx loc_004C4950: pop edi loc_004C4951: pop esi loc_004C4952: pop ebx loc_004C4953: mov esp, ebp loc_004C4955: pop ebp loc_004C4956: retn 0004h End Sub

#2

Não.

#3

:shock: - Uma pena !

#4

Acho que em assembler fica mais legível :roll: brincadeira!

#5

Duran is back !?!?!?!?

Noooooooooooooooooooooooo

http://www.nooooooooooooooo.com/

#6

Não é possível, mas você pode recuperar assinaturas de métodos no caso, se o assembly foi gerado por um compilador c ou c++(ex uma dll).
DumpBin faz isso.

http://support.microsoft.com/kb/177429

Programas gerados por compiladores de código nativo não precisam ser obfuscados pela mesma razão.

#7

Parem a votação: Ganhou o prêmio de tópico mas sem noção do ano !

Como pode levar a sério alguém que propõe tamanho disparate ?! Não dá né…

#8

[quote=boone]Parem a votação: Ganhou o prêmio de tópico mas sem noção do ano !

Como pode levar a sério alguém que propõe tamanho disparate ?! Não dá né…[/quote]

rsrsrs

#9

:shock: - Uma pena ![/quote]

Não dá porque o assembler é dependente de plataforma. Cada processador possui suas próprias instruções gravadas na memória de programa.

#10

pq diabos vc quer fazer o contrario do que o compilador já faz?

#11

:arrow: Is there a way to convert the Assembly code to VB Code

It would be very cryptic, difficult to follow, and a waste of VB power. You CAN directly convert a single ASM instruction into an equivalent VB statement. You can not convert a series of ASM instructions into 1+ VB statements any more than you can convert VB into C, PERL, or COBOL (does anyone still use this?!) Each language uses different METHODS or STYLES to perform a TASK. ASM is the most ‘flexible’ language because it allows manipulation of the computer at the silicon level. All higher level languages manipulate Items, even to Ideas.

The statement ‘A=B+C’ seems simple, but what goes on behind the scenes includees *) determining if EACH variable EXISTS, *)adjusting any size differences, *)converting numeric format differences into one that can be calculated by all variables, *)evaluating what the formula says to do, *)determining the order of operands, *)carrying out the formua, *)converting the result to the form of the destination variable, *)error checking and reporting. Converting ALL that into VB code would render the meaning of ‘A=B+C’ incomprehensible!

You’re probably looking for a de-compiler (converting object code into source code). A disassembler converts Machine code into object code, or at least into human readable form. The result would be probably just as incomprehensible because it can’t reveal the Intent or Style of the programmer. Why did they write it THAT way?

Try looking at a dump from DEBUG.COM (if you can find a copy, AND your OS will allow it to run.) You’re brain will bleed before the hour is up!

#12

O problema do Duran provavelmente é o seguinte: ele tem um programa VB 6.0 (a última versão do VB que gerava código nativo, para Windows 32 bits) e por algum motivo obscuro ele não tem os fontes.

Às vezes é possível descompilar o código gerado pelo VB 6.0 porque ele é muito “ingênuo” em termos de compilação Assembly, e acho que há algumas ferramentas que fazem isso. (Acho que só ferramentas pagas, nem sei se o desenvolvedor ou a software house original vendem ainda esses produtos)

O VB 3.0 (que é uma coisa para Windows 3.X) gerava só pseudo-código, portanto é relativamente fácil descompilar programas escritos em VB 3.0. Mas o VB 6.0 é outra coisa.

#13

:shock: - Uma pena ![/quote]

Não dá porque o assembler é dependente de plataforma. Cada processador possui suas próprias instruções gravadas na memória de programa.[/quote]
Isso era algo que não previa, bom pelo menos a engenharia reversa é possivel quando se trata da linguagem Java para seus fontes .class para o codigo Java, descompilação é um limite particular, no caso do assembler isso foi um golpe sobre como isso se aplica fisicamente para a implementação ao codigo em vias do processador.

Valeuuu !!!

#14

:shock: - Uma pena ![/quote]

Não dá porque o assembler é dependente de plataforma. Cada processador possui suas próprias instruções gravadas na memória de programa.[/quote]
Isso era algo que não previa, bom pelo menos a engenharia reversa é possivel quando se trata da linguagem Java para seus fontes .class para o codigo Java, descompilação é um limite particular, no caso do assembler isso foi um golpe sobre como isso se aplica fisicamente para a implementação ao codigo em vias do processador.

Valeuuu !!!

[/quote]

Ahhhhh tá…

#15

só dando risada mesmo…

feriadão chegando néh…

[size=18]Fora que já tem outro MARCIO DURAN[/size]

#16

Duran,disso que tu fuma tem mais?

#17

fuma eu nem sei mas nem maconha acho que é!!! kkkkk

esse é famoso Marcio Duran JR

o rei dos (OFF-TOPIC)

#18

[quote=entanglement]O problema do Duran provavelmente é o seguinte: ele tem um programa VB 6.0 (a última versão do VB que gerava código nativo, para Windows 32 bits) e por algum motivo obscuro ele não tem os fontes.

Às vezes é possível descompilar o código gerado pelo VB 6.0 porque ele é muito “ingênuo” em termos de compilação Assembly, e acho que há algumas ferramentas que fazem isso. (Acho que só ferramentas pagas, nem sei se o desenvolvedor ou a software house original vendem ainda esses produtos)

O VB 3.0 (que é uma coisa para Windows 3.X) gerava só pseudo-código, portanto é relativamente fácil descompilar programas escritos em VB 3.0. Mas o VB 6.0 é outra coisa.
[/quote]

Não existe ferramenta para decompilar assembly, porque ela não guarda nenhuma informação semântica de uma linguagem. Ela é apenas uma linguagem de montagem. Você passa valores para um mnemônico referente a um registrador.

Existe um depurador chamado softice que consegue depurar dentro do kernel do windows, e ali você consegue ler assembly. Mas o entendimento vai da capacidade do profissional, e é assim que o wine é desenvolvido.
Isso que eu chamo de programação orientada a cabelos do peito.

#19


Syser Kernel Debugger 1.99.1900.1214

Syser Debugger - kernel-level debugger with a graphical window interface of the Chinese developer. Allows you to debug applications, and drivers. Combines the functions of IDA Pro, SoftIce and OllyDbg. Debugger - this thing needed to create programs. However, many of those who write computer programs and using the debugger, do not know what principles and mechanisms of its work. This program has the opportunity to highlight the listing dizasseblera, dynamic loading and unloading, with the support of the keyboard and mouse support for Unicode and more.

Main features:
highlighting the listing dizasseblera
dynamic loading and unloading
Support work with the keyboard and mouse
Support of all debugger commands Softice
Support for Unicode, a multilingual interface
Support for plug-ins
Support for multiprocessor systems with Intel Hyper-Threaded Processors
support script
Support to the clipboard, lets you copy data from a Level 3 to Level Ring Ring 0
work together with the correct Softice
Automatic loading drivers for debug
add comments to debug
Bookmarks
Support for cross-reference and data reference
multiple
and much more

#20

a idéia é essa aí. Normalmente o pessoal que quebra licença de softwares usa também. Ficar lendo assembly de x86 é uma tarefa complicada, pra mim não dá não.