begin process at 2008 08 21 14:56:37
1 229 428 membres
248 nouveaux aujourd'hui
14 263 membres club

Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum.
Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

AVOIR LA SOURCE ASM DE VOTRE PROJET VB


Information sur la source

Catégorie :Trucs & Astuces Niveau : Initié Date de création : 05/07/2004 Date de mise à jour : 05/07/2004 08:01:35 Vu / téléchargé: 4 996 / 304

Note :
10 / 10 - par 1 personne
10,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10

Commentaire sur cette source (25)
Ajouter un commentaire et/ou une note

Description

Ceci permet de créer des fichiers contenant la source ASM de votre programme lors de la compilation. Pour ce faire :
1- dans votre dossier de vb, renommer c2.exe par c2_.exe
2- copier l'éxécutable c2.exe (qui est dans le dossier de ma source) dans le dossier de vb.
3- cour désinstaller, supprimer mon éxécutable (le c2.exe (CELUI EN VB!)) et  renommer le c2_.exe (c2.exe original) en en c2.exe
4- créer un fichier appellé c2.cfg dans le dossier de VB
5- dans ce fichier, vous mettez les paramètres que vous voulez envoyer à c2. VOUS AVEZ LE CONTRÔLE DE C2! Pour générer la source ASM, voici le fichier de configuration :

##début du fichier (ne pas inscrire :-)
-Fa"$filename$_VB.asm"
##fin du fichier (ne pas inscrire :-)
C'est simple non? paramètre, CRLF, paramètre CRLF...
Voici la liste des variables :
$filename$              > Nom du fichier qui se fait compiler
$filepath$                > Dossier du fichier qui se fait compiler
$vbpath$                 > Dossier de VB (celui dans lequel est l'EXE de mon prog)

CES VARIABLES SONT CASE SENSITIVE!!!

Je ne sais pas quels paramètres sont pris en charge par c2. Par contre, j'ai mit le fichier cl.txt qui contient les paramètres de cl.exe , le compilateur c++ (il y en a sûrement en commun)

Source

  • 'Voici un exemple de la conversion :
  • 'Projet VB : Une feuille (form1) avec un bouton (command1) :
  • Option Explicit
  • Private Sub Command1_Click()
  • Dim strMess As String
  • strMess = InputBox("Quel est le mot de passe?")
  • If StrComp(strMess, "allo", vbTextCompare) <> 0 Then
  • MsgBox "MAUVAIS MOT DE PASSE!", vbCritical + vbOKOnly
  • Else
  • MsgBox "Mot de passe accepté!", vbInformation + vbOKOnly
  • End If
  • End Sub
  • 'Maintenant, le résultat en ASM (ESSAYEZ DE TROUVENT COMMENT LE CRACKER):
  • TITLE E:\Programmes\Microsoft Visual Studio\VB98\test asm\Form1.frm
  • .386P
  • include listing.inc
  • if @Version gt 510
  • .model FLAT
  • else
  • _TEXT SEGMENT PARA USE32 PUBLIC 'CODE'
  • _TEXT ENDS
  • _DATA SEGMENT DWORD USE32 PUBLIC 'DATA'
  • _DATA ENDS
  • CONST SEGMENT DWORD USE32 PUBLIC 'CONST'
  • CONST ENDS
  • _BSS SEGMENT DWORD USE32 PUBLIC 'BSS'
  • _BSS ENDS
  • _TLS SEGMENT DWORD USE32 PUBLIC 'TLS'
  • _TLS ENDS
  • text$1 SEGMENT PARA USE32 PUBLIC ''
  • text$1 ENDS
  • ; COMDAT ?Command1_Click@Form1@@AAGXXZ
  • text$1 SEGMENT PARA USE32 PUBLIC ''
  • text$1 ENDS
  • FLAT GROUP _DATA, CONST, _BSS
  • ASSUME CS: FLAT, DS: FLAT, SS: FLAT
  • endif
  • PUBLIC ?Command1_Click@Form1@@AAGXXZ ; Form1::Command1_Click
  • EXTRN __imp_@__vbaStrMove:NEAR
  • EXTRN __imp____vba@00617CA8:NEAR
  • EXTRN __imp_@__vbaVarDup:NEAR
  • EXTRN ___vba@0060DC2C:BYTE
  • EXTRN __imp____vbaFreeVarList:NEAR
  • EXTRN __imp____vbaStrComp:NEAR
  • EXTRN ___vba@0060DC68:BYTE
  • EXTRN __imp____vba@00618D04:NEAR
  • EXTRN ___vba@00618C40:BYTE
  • EXTRN ___vba@00618C74:BYTE
  • EXTRN __imp_@__vbaFreeStr:NEAR
  • EXTRN ___vbaExceptHandler:NEAR
  • EXTRN __except_list:DWORD
  • ; COMDAT CONST
  • ; File E:\Programmes\Microsoft Visual Studio\VB98\test asm\Form1.frm
  • CONST SEGMENT
  • $S40 DB 07H, 00H
  • DB 08H, 00H
  • DD FLAT:$L39
  • DD FLAT:$L37
  • DD FLAT:$L38
  • CONST ENDS
  • ; COMDAT ?Command1_Click@Form1@@AAGXXZ
  • text$1 SEGMENT
  • _Me$ = 8
  • _strMess$ = -24
  • _unnamed_var1$ = -40
  • _unnamed_var1$ = -56
  • _unnamed_var1$ = -72
  • _unnamed_var1$ = -88
  • _unnamed_var1$ = -104
  • _unnamed_var1$ = -120
  • _unnamed_var1$ = -136
  • _unnamed_var1$ = -152
  • __$SEHRec$ = -20
  • ?Command1_Click@Form1@@AAGXXZ PROC NEAR ; Form1::Command1_Click, COMDAT
  • ; File E:\Programmes\Microsoft Visual Studio\VB98\test asm\Form1.frm
  • ; Line 28
  • push ebp
  • mov ebp, esp
  • sub esp, 12 ; 0000000cH
  • push OFFSET FLAT:___vbaExceptHandler
  • mov eax, DWORD PTR fs:__except_list
  • push eax
  • mov DWORD PTR fs:__except_list, esp
  • sub esp, 236 ; 000000ecH
  • push ebx
  • push esi
  • push edi
  • mov DWORD PTR __$SEHRec$[ebp+8], esp
  • mov DWORD PTR __$SEHRec$[ebp+12], OFFSET FLAT:$S40
  • mov eax, DWORD PTR _Me$[ebp]
  • mov ecx, eax
  • and ecx, 1
  • mov DWORD PTR __$SEHRec$[ebp+16], ecx
  • and al, -2 ; fffffffeH
  • push eax
  • mov DWORD PTR _Me$[ebp], eax
  • mov edx, DWORD PTR [eax]
  • call DWORD PTR [edx+4]
  • xor ebx, ebx
  • ; Line 30
  • mov edi, -2147352572 ; 80020004H
  • mov esi, 10 ; 0000000aH
  • mov DWORD PTR _unnamed_var1$[ebp], ebx
  • mov DWORD PTR _unnamed_var1$[ebp], ebx
  • mov DWORD PTR _unnamed_var1$[ebp], ebx
  • mov DWORD PTR _unnamed_var1$[ebp], ebx
  • mov DWORD PTR _unnamed_var1$[ebp], ebx
  • mov DWORD PTR _unnamed_var1$[ebp], ebx
  • mov DWORD PTR _unnamed_var1$[ebp], ebx
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • mov DWORD PTR _strMess$[ebp], ebx
  • mov DWORD PTR _unnamed_var1$[ebp], ebx
  • mov DWORD PTR _unnamed_var1$[ebp+8], edi
  • mov DWORD PTR _unnamed_var1$[ebp], esi
  • mov DWORD PTR _unnamed_var1$[ebp+8], edi
  • mov DWORD PTR _unnamed_var1$[ebp], esi
  • mov DWORD PTR _unnamed_var1$[ebp+8], edi
  • mov DWORD PTR _unnamed_var1$[ebp], esi
  • mov DWORD PTR _unnamed_var1$[ebp+8], edi
  • mov DWORD PTR _unnamed_var1$[ebp], esi
  • mov DWORD PTR _unnamed_var1$[ebp+8], edi
  • mov DWORD PTR _unnamed_var1$[ebp], esi
  • mov DWORD PTR _unnamed_var1$[ebp+8], edi
  • mov DWORD PTR _unnamed_var1$[ebp], esi
  • mov DWORD PTR _unnamed_var1$[ebp+8], OFFSET FLAT:___vba@0060DC2C
  • mov DWORD PTR _unnamed_var1$[ebp], 8
  • call DWORD PTR __imp_@__vbaVarDup
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • push eax
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • push ecx
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • push edx
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • push eax
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • push ecx
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • push edx
  • push eax
  • call DWORD PTR __imp____vba@00617CA8
  • mov edx, eax
  • lea ecx, DWORD PTR _strMess$[ebp]
  • call DWORD PTR __imp_@__vbaStrMove
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • push ecx
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • push edx
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • push eax
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • push ecx
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • push edx
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • push eax
  • push ecx
  • push 7
  • call DWORD PTR __imp____vbaFreeVarList
  • ; Line 31
  • mov edx, DWORD PTR _strMess$[ebp]
  • add esp, 32 ; 00000020H
  • push edx
  • push OFFSET FLAT:___vba@0060DC68
  • push 1
  • call DWORD PTR __imp____vbaStrComp
  • test ax, ax
  • ; Line 32
  • mov DWORD PTR _unnamed_var1$[ebp+8], edi
  • mov DWORD PTR _unnamed_var1$[ebp], esi
  • mov DWORD PTR _unnamed_var1$[ebp+8], edi
  • mov DWORD PTR _unnamed_var1$[ebp], esi
  • mov DWORD PTR _unnamed_var1$[ebp+8], edi
  • mov DWORD PTR _unnamed_var1$[ebp], esi
  • je SHORT $L46
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • mov DWORD PTR _unnamed_var1$[ebp+8], OFFSET FLAT:___vba@00618C40
  • mov DWORD PTR _unnamed_var1$[ebp], 8
  • call DWORD PTR __imp_@__vbaVarDup
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • push eax
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • push ecx
  • push edx
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • push 16 ; 00000010H
  • push eax
  • call DWORD PTR __imp____vba@00618D04
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • push ecx
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • push edx
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • push eax
  • push ecx
  • ; Line 33
  • jmp SHORT $L74
  • $L46:
  • ; Line 34
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • mov DWORD PTR _unnamed_var1$[ebp+8], OFFSET FLAT:___vba@00618C74
  • mov DWORD PTR _unnamed_var1$[ebp], 8
  • call DWORD PTR __imp_@__vbaVarDup
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • push edx
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • push eax
  • push ecx
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • push 64 ; 00000040H
  • push edx
  • call DWORD PTR __imp____vba@00618D04
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • push eax
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • push ecx
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • push edx
  • push eax
  • $L74:
  • push 4
  • call DWORD PTR __imp____vbaFreeVarList
  • add esp, 20 ; 00000014H
  • ; Line 36
  • mov DWORD PTR __$SEHRec$[ebp+16], ebx
  • $L39:
  • push $L70
  • jmp SHORT $L65
  • $L38:
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • push ecx
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • push edx
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • push eax
  • lea edx, DWORD PTR _unnamed_var1$[ebp]
  • push ecx
  • lea eax, DWORD PTR _unnamed_var1$[ebp]
  • push edx
  • lea ecx, DWORD PTR _unnamed_var1$[ebp]
  • push eax
  • push ecx
  • push 7
  • call DWORD PTR __imp____vbaFreeVarList
  • add esp, 32 ; 00000020H
  • ret 0
  • $L65:
  • $L37:
  • lea ecx, DWORD PTR _strMess$[ebp]
  • call DWORD PTR __imp_@__vbaFreeStr
  • $L68:
  • ret 0
  • $L70:
  • mov eax, DWORD PTR _Me$[ebp]
  • push eax
  • mov edx, DWORD PTR [eax]
  • call DWORD PTR [edx+8]
  • mov eax, DWORD PTR __$SEHRec$[ebp+16]
  • mov ecx, DWORD PTR __$SEHRec$[ebp]
  • pop edi
  • pop esi
  • mov DWORD PTR fs:__except_list, ecx
  • pop ebx
  • mov esp, ebp
  • pop ebp
  • ret 4
  • ?Command1_Click@Form1@@AAGXXZ ENDP ; Form1::Command1_Click
  • text$1 ENDS
  • END
'Voici un exemple de la conversion :
'Projet VB : Une feuille (form1) avec un bouton (command1) :

Option Explicit

Private Sub Command1_Click()
Dim strMess As String
strMess = InputBox("Quel est le mot de passe?")
If StrComp(strMess, "allo", vbTextCompare) <> 0 Then
MsgBox "MAUVAIS MOT DE PASSE!", vbCritical + vbOKOnly
Else
MsgBox "Mot de passe accepté!", vbInformation + vbOKOnly
End If
End Sub

'Maintenant, le résultat en ASM (ESSAYEZ DE TROUVENT COMMENT LE CRACKER):
	TITLE	E:\Programmes\Microsoft Visual Studio\VB98\test asm\Form1.frm
	.386P
include listing.inc
if @Version gt 510
.model FLAT
else
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
_DATA	SEGMENT DWORD USE32 PUBLIC 'DATA'
_DATA	ENDS
CONST	SEGMENT DWORD USE32 PUBLIC 'CONST'
CONST	ENDS
_BSS	SEGMENT DWORD USE32 PUBLIC 'BSS'
_BSS	ENDS
_TLS	SEGMENT DWORD USE32 PUBLIC 'TLS'
_TLS	ENDS
text$1	SEGMENT PARA USE32 PUBLIC ''
text$1	ENDS
;	COMDAT ?Command1_Click@Form1@@AAGXXZ
text$1	SEGMENT PARA USE32 PUBLIC ''
text$1	ENDS
FLAT	GROUP _DATA, CONST, _BSS
	ASSUME	CS: FLAT, DS: FLAT, SS: FLAT
endif
PUBLIC	?Command1_Click@Form1@@AAGXXZ			; Form1::Command1_Click
EXTRN	__imp_@__vbaStrMove:NEAR
EXTRN	__imp____vba@00617CA8:NEAR
EXTRN	__imp_@__vbaVarDup:NEAR
EXTRN	___vba@0060DC2C:BYTE
EXTRN	__imp____vbaFreeVarList:NEAR
EXTRN	__imp____vbaStrComp:NEAR
EXTRN	___vba@0060DC68:BYTE
EXTRN	__imp____vba@00618D04:NEAR
EXTRN	___vba@00618C40:BYTE
EXTRN	___vba@00618C74:BYTE
EXTRN	__imp_@__vbaFreeStr:NEAR
EXTRN	___vbaExceptHandler:NEAR
EXTRN	__except_list:DWORD
;	COMDAT CONST
; File E:\Programmes\Microsoft Visual Studio\VB98\test asm\Form1.frm
CONST	SEGMENT
$S40	DB	07H, 00H
	DB	08H, 00H
	DD	FLAT:$L39
	DD	FLAT:$L37
	DD	FLAT:$L38
CONST	ENDS
;	COMDAT ?Command1_Click@Form1@@AAGXXZ
text$1	SEGMENT
_Me$ = 8
_strMess$ = -24
_unnamed_var1$ = -40
_unnamed_var1$ = -56
_unnamed_var1$ = -72
_unnamed_var1$ = -88
_unnamed_var1$ = -104
_unnamed_var1$ = -120
_unnamed_var1$ = -136
_unnamed_var1$ = -152
__$SEHRec$ = -20
?Command1_Click@Form1@@AAGXXZ PROC NEAR			; Form1::Command1_Click, COMDAT
; File E:\Programmes\Microsoft Visual Studio\VB98\test asm\Form1.frm
; Line 28
	push	ebp
	mov	ebp, esp
	sub	esp, 12					; 0000000cH
	push	OFFSET FLAT:___vbaExceptHandler
	mov	eax, DWORD PTR fs:__except_list
	push	eax
	mov	DWORD PTR fs:__except_list, esp
	sub	esp, 236				; 000000ecH
	push	ebx
	push	esi
	push	edi
	mov	DWORD PTR __$SEHRec$[ebp+8], esp
	mov	DWORD PTR __$SEHRec$[ebp+12], OFFSET FLAT:$S40
	mov	eax, DWORD PTR _Me$[ebp]
	mov	ecx, eax
	and	ecx, 1
	mov	DWORD PTR __$SEHRec$[ebp+16], ecx
	and	al, -2					; fffffffeH
	push	eax
	mov	DWORD PTR _Me$[ebp], eax
	mov	edx, DWORD PTR [eax]
	call	DWORD PTR [edx+4]
	xor	ebx, ebx
; Line 30
	mov	edi, -2147352572			; 80020004H
	mov	esi, 10					; 0000000aH
	mov	DWORD PTR _unnamed_var1$[ebp], ebx
	mov	DWORD PTR _unnamed_var1$[ebp], ebx
	mov	DWORD PTR _unnamed_var1$[ebp], ebx
	mov	DWORD PTR _unnamed_var1$[ebp], ebx
	mov	DWORD PTR _unnamed_var1$[ebp], ebx
	mov	DWORD PTR _unnamed_var1$[ebp], ebx
	mov	DWORD PTR _unnamed_var1$[ebp], ebx
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	mov	DWORD PTR _strMess$[ebp], ebx
	mov	DWORD PTR _unnamed_var1$[ebp], ebx
	mov	DWORD PTR _unnamed_var1$[ebp+8], edi
	mov	DWORD PTR _unnamed_var1$[ebp], esi
	mov	DWORD PTR _unnamed_var1$[ebp+8], edi
	mov	DWORD PTR _unnamed_var1$[ebp], esi
	mov	DWORD PTR _unnamed_var1$[ebp+8], edi
	mov	DWORD PTR _unnamed_var1$[ebp], esi
	mov	DWORD PTR _unnamed_var1$[ebp+8], edi
	mov	DWORD PTR _unnamed_var1$[ebp], esi
	mov	DWORD PTR _unnamed_var1$[ebp+8], edi
	mov	DWORD PTR _unnamed_var1$[ebp], esi
	mov	DWORD PTR _unnamed_var1$[ebp+8], edi
	mov	DWORD PTR _unnamed_var1$[ebp], esi
	mov	DWORD PTR _unnamed_var1$[ebp+8], OFFSET FLAT:___vba@0060DC2C
	mov	DWORD PTR _unnamed_var1$[ebp], 8
	call	DWORD PTR __imp_@__vbaVarDup
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	push	eax
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	push	ecx
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	push	edx
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	push	eax
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	push	ecx
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	push	edx
	push	eax
	call	DWORD PTR __imp____vba@00617CA8
	mov	edx, eax
	lea	ecx, DWORD PTR _strMess$[ebp]
	call	DWORD PTR __imp_@__vbaStrMove
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	push	ecx
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	push	edx
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	push	eax
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	push	ecx
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	push	edx
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	push	eax
	push	ecx
	push	7
	call	DWORD PTR __imp____vbaFreeVarList
; Line 31
	mov	edx, DWORD PTR _strMess$[ebp]
	add	esp, 32					; 00000020H
	push	edx
	push	OFFSET FLAT:___vba@0060DC68
	push	1
	call	DWORD PTR __imp____vbaStrComp
	test	ax, ax
; Line 32
	mov	DWORD PTR _unnamed_var1$[ebp+8], edi
	mov	DWORD PTR _unnamed_var1$[ebp], esi
	mov	DWORD PTR _unnamed_var1$[ebp+8], edi
	mov	DWORD PTR _unnamed_var1$[ebp], esi
	mov	DWORD PTR _unnamed_var1$[ebp+8], edi
	mov	DWORD PTR _unnamed_var1$[ebp], esi
	je	SHORT $L46
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	mov	DWORD PTR _unnamed_var1$[ebp+8], OFFSET FLAT:___vba@00618C40
	mov	DWORD PTR _unnamed_var1$[ebp], 8
	call	DWORD PTR __imp_@__vbaVarDup
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	push	eax
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	push	ecx
	push	edx
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	push	16					; 00000010H
	push	eax
	call	DWORD PTR __imp____vba@00618D04
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	push	ecx
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	push	edx
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	push	eax
	push	ecx
; Line 33
	jmp	SHORT $L74
$L46:
; Line 34
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	mov	DWORD PTR _unnamed_var1$[ebp+8], OFFSET FLAT:___vba@00618C74
	mov	DWORD PTR _unnamed_var1$[ebp], 8
	call	DWORD PTR __imp_@__vbaVarDup
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	push	edx
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	push	eax
	push	ecx
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	push	64					; 00000040H
	push	edx
	call	DWORD PTR __imp____vba@00618D04
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	push	eax
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	push	ecx
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	push	edx
	push	eax
$L74:
	push	4
	call	DWORD PTR __imp____vbaFreeVarList
	add	esp, 20					; 00000014H
; Line 36
	mov	DWORD PTR __$SEHRec$[ebp+16], ebx
$L39:
	push	$L70
	jmp	SHORT $L65
$L38:
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	push	ecx
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	push	edx
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	push	eax
	lea	edx, DWORD PTR _unnamed_var1$[ebp]
	push	ecx
	lea	eax, DWORD PTR _unnamed_var1$[ebp]
	push	edx
	lea	ecx, DWORD PTR _unnamed_var1$[ebp]
	push	eax
	push	ecx
	push	7
	call	DWORD PTR __imp____vbaFreeVarList
	add	esp, 32					; 00000020H
	ret	0
$L65:
$L37:
	lea	ecx, DWORD PTR _strMess$[ebp]
	call	DWORD PTR __imp_@__vbaFreeStr
$L68:
	ret	0
$L70:
	mov	eax, DWORD PTR _Me$[ebp]
	push	eax
	mov	edx, DWORD PTR [eax]
	call	DWORD PTR [edx+8]
	mov	eax, DWORD PTR __$SEHRec$[ebp+16]
	mov	ecx, DWORD PTR __$SEHRec$[ebp]
	pop	edi
	pop	esi
	mov	DWORD PTR fs:__except_list, ecx
	pop	ebx
	mov	esp, ebp
	pop	ebp
	ret	4
?Command1_Click@Form1@@AAGXXZ ENDP			; Form1::Command1_Click
text$1	ENDS
END

Conclusion

Je ne mit connais pas en ASM mais je sais qu'il est valide car toute les procédures y sont. Ceci va sûrement interressé plusieurs...
Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip

  • signaler à un administrateur
    Commentaire de DeadlyPredator le 05/07/2004 07:53:23

    C'est terrible, 10 lignes de code VB pour 266 en ASM.

  • signaler à un administrateur
    Commentaire de DeadlyPredator le 05/07/2004 07:57:33

    Les fichiers ASM seront créé dans le dossier du form, du module,... donc il est préférable que vous ayez déjà enregistrer votre projet. N'OUBLIEZ SURTOUT PAS DE CRÉER LE FICHIER C2.CFG (DANS LE DOSSIER DE VB) ET D'Y AJOUTER :
    -Fa"$filename$_VB.asm"

  • signaler à un administrateur
    Commentaire de DeadlyPredator le 05/07/2004 08:05:02

    Il faudrait faire corriger le bug quand on oubli puis qu'on appui sur refresh dans le browser car ça double le comentaire. Puis il se pourrais que j'ai envoyer un source très similaire mais c'est qu'il y a eu un bug lors de l'envoie pi ça a tout fourré donc j'ai dû renvoyer une nouvelle source.

  • signaler à un administrateur
    Commentaire de BruNews le 05/07/2004 13:05:45 administrateur CS

    Salut,

    quel interet ??? a part mettre en evidence pourquoi vb est si lent (String etant le pire de tout) et qu'il fait bien de disparaitre, je ne vois pas a quoi cela peut servir.

    Bonne continuation.

  • signaler à un administrateur
    Commentaire de davidauche le 05/07/2004 18:23:45

    salut, c'est b1 comme idée et le code en général, il existe des programmes qui font ça appartir d'une exe (son généralement utiliser pour des buts de crackage), Alors BruNews, ça sert à pleine des choses vraiment : apprendre les trucs de sécurite de VB en ASM, Apprendre l'assembleurs et les boucles et les conditions en ASM appartir des simples exemples en vb,,,, de plus je crois que tu connais bien que l'ASM fait tout et on peut faire tout avec code ASM ;), alors avant de dire ..... pensez un peu, meme si t'as des problèmes avec VB ou tu n'aime pas ;).
    Amicalement cher BruNews.
    Bonne continuation.

  • signaler à un administrateur
    Commentaire de DeadlyPredator le 05/07/2004 18:25:29

    Tant qu'on va continuer de croire en vb, il va continuer d'exister!

  • signaler à un administrateur
    Commentaire de DeadlyPredator le 05/07/2004 18:27:39

    Et n'oubliez pas que dans le fichier de config (c2.cfg), vous pouvez ajouter d'autre paramètres. Il faut juste trouver lesquels en testant ceux du fichier cl.txt.

  • signaler à un administrateur
    Commentaire de crenaud76 le 05/07/2004 18:43:29

    Même si je suis un fan du VB6, je suis d'accord avec Brunews !! Ce source ne fait que mettre en évidence les défauts de VB6 !! Un code tout simple en VB génère ENORMEMENT de code-machine ! Et pas des plus optimisé en plus à mon avis. !!!
    Je developpe en VB depuis des années (plus de 10 ans) et j'adore ce langage, qui m'a bcp appris et avec lequel j'ai fait (et je continue encore) à faire des choses très balaise !! Mais Brunews à raison ! VB, au moins dans sa version 6 n'a plus aucun avenir ! Il continuera sans doute encore à exister car il y a plein de gens qui développe avec aujourd'hui et donc la masse de connaissance est importante et les programmeur sont souvent des gens rétissent à l'évolution (sans doute parceque cela les oblige à se remettre en cause et à reconnaitre qu'ils doivent presque tout réapprendre pour un autre langage). Mais les fait sont la : Dans le monde professionnel, il est de plus en plus inutile de connaitre le VB6. Il faut aujourd'hui se tourner vers les technologie web (java, php, etc ...) et/ou .NET : VB.NET (et la, la connaissance de VB6 est une grande aide), C#, etc ...

    Je voudrais pas jouer au vieux con, mais, il y a un peu plus de 15 on programmais en Turbo Pascal ou en C et on disait que c'était les langages universels, que rien ni personne ne pourrait les déboulonner !! Qui programme encore en Turbo Pascal ou en C ?? Bien peu de gens en vérité (je fait abstraction des gens qui comme moi, code encore en Turbo Pascal, juste pour le plaisir !) Je veux dire dans le monde professionnel ????

  • signaler à un administrateur
    Commentaire de DeadlyPredator le 05/07/2004 19:05:11

    Ouais. C'est vrai que le VB6 est lent et va s'éteindre MAIS une nouvelle version sortira : VB.net. Dès que je vais avoir .Net et que je vais m'y être abitué, je vais mettre de côté le 6. VB.Net est nettement plus rapide.

  • signaler à un administrateur
    Commentaire de BruNews le 06/07/2004 11:18:41 administrateur CS

    davidauche &gt; apprendre l'ASM c'est bien et je serais mal place pour dire le contraire mais surement pas a partir d'un listing issu de VB, c'est vraiment trop mauvais, prends plutot exemple sur un listing issu d'une compile C sur VS 2003 qui lui produit un ASM tres convenable.

    Pour ce qui est de l'avenir de VB, qu'on aime ou pas n'entre pour rien dans l'affaire. Comme l'explique crenaud76, c'est quasi deja fini, faites un semblant de recherche d'emploi et vous en serez convaincu.

    crenaud76 &gt; le C/C++ est toujours tres employe dans le monde pro, partout ou il faut des performances, le langage bas niveau reste indispensable comme dans les jeux, le graphisme et tous les domaines ou le quasi 'temps reel' est requis, la medecine par exemple (mon boulot).

    Bossez bien.

  • signaler à un administrateur
    Commentaire de EBArtSoft le 06/07/2004 12:06:21 administrateur CS

    Pour rentrer dans cet interresant debat je voudrait
    dire que les listings asm de vb explique seulement
    comment faire des appels vers la machine virtuelle
    elle ne donne aucun vrai code assembleur. Vous ne
    trouverez rien d'autre que des push et call la preuve
    en est dans l'exemple que tu nous a fournis alors
    je vous souhaite juste de bien vous amuser quand
    meme car si ça peut pousser certain vers l'assembleur
    ce sera deja un debut d'interet...

    ah et puis desolé mais vb.net c'est pas plus rapide ! lol
    @+

  • signaler à un administrateur
    Commentaire de davidauche le 06/07/2004 15:08:23

    Re, ni vb6, ni vb.net, ni c++ ou c++.net (le C c'est déjà dépasser par c++ ;) )  seront le futur de la programmation, il faut être franche et accepter la réalité, que Csharp sera le vrai futur, c'est un extrait 2 plusieurs langages (vb, c++, Java,...), donc à longtemps on sera obliger de programmer avec net, MS (que j'aime pas) va nous obliger  même si on n'aime pas ça :(. La seule langage qui reste en concurrence avec Csharp et MS c'est Java. bn courage a tt ;)

  • signaler à un administrateur
    Commentaire de BruNews le 06/07/2004 17:45:34 administrateur CS

    C# fait partie des interpretes, rien a voir avec un langage natif comme C ou c++ donc aucun risque qu'il remplace quoi que ce soit un jour.

    Le C est depasse, non la faut etre serieux et se documenter un peu avant de sortir de telles inepties. Le C++ ne s'utilise que dans un prog en mode 'user', la ou l'alloc memoire se fait sur le tas du prog alors qu'on peut TOUT ecrire en C jusqu'au kernel mode.

  • signaler à un administrateur
    Commentaire de Horfee le 06/07/2004 19:49:23

    slt
    je suis vraiment pas d'accord avec certain : C est le meilleur langage : regardez linux, les systemes UNIX en general et vous verez que le C est derriere!!!
    certe le C++ est plus puissant que C mais ce dernier est plus rapide donc chacun a ses propres atouts et en aucun cas il faut les mettre en concurrence!el C et C++ sont tt 2 les plus utilisés !!!
    par contre pour ce qui est de vb6, ca fait deja longtemps que c mort : je programme depuis plus d'un an en VB.NET...mais tt c "langages" n'ont pour moi aucun avenir(trop lent : c fait pour bricoler, pas pour programmer) et pour repondre a bruNews des magasines ont demontré que VB6 etait malheureusement le 4eme langage le plus demandé en ce moment sur le marché du travail(avant il y a C/C++,java et un autre je c plus).
    Quant à l'assembleur, c'est vrai que c bien, mais ce langage là aussi est mort : on ne peut ecrire que des petites routines avec donc ca sert plus a rien : ce n'est plus que pour la frime ou le cracking...donc je trouve donc cette source sans grand interet!!!
    dsl deadly predator mais bon...je dis ce que je pense au moins.
    ++

  • signaler à un administrateur
    Commentaire de BruNews le 06/07/2004 21:05:54 administrateur CS

    C'est idem pour Windows, entierement ecrit en C, a part le boot en asm bien entendu.

  • signaler à un administrateur
    Commentaire de Leonello le 06/07/2004 22:52:12

    Le bon language de programmation, c'est celui que l'on maîtrise le mieux.

    Leo

  • signaler à un administrateur
    Commentaire de DeadlyPredator le 07/07/2004 04:58:33

    Bon, je vous r'appelle que MA SOURCE FAIT PAS JUSTE CRÉER UN FICHIER PSEUDO-ASM! Elle permet aussi de d'ajouter d'autres options à la compilation. Et aussi çca va décourager des gens de faire ce genre de source : Exe inviolable.

  • signaler à un administrateur
    Commentaire de Bombela le 07/07/2004 12:32:01

    LOL

    Quel débat !

    Je pense que l'asm, lui, reste incontournable.
    Sans ça, je sais pas comment on peut faire un BootSector...

    Ensuite, le C peut être comparé à de l'asm de haut niveau.
    Il est très puissant, et les compilateurs (j'utilise GCC sous Windows) optimize de façons faramineuse le code ! J'ai fais des désassemblages de mes sources, et c'est mieux optimisé qu'un Humain ne peut le faire ! Le bémol, c'est que les compilo C n'utilise pas toutes les instructions des processeurs actuel, mais bon, vu que l'on peut faire de l'asm Inline...

    Ensuite, le C++, j'avoue ne pas en avoir encore fait. Mais ce que je sais, c'est que c'est le language C orienté objet. Il est evidement fait pour les programmes utilisateurs, car il utilise des fonctions standard.

    Ensuite, le VB, c'est "simple", mais alors, vraiment lent ! Mais lent !
    J'ai fais des testes de boucle entre DElphi et VB, et j'ai jusqu'a 10 secondes d'écart !
    De plus, les programme VB exige des DLL pour fonctionner, et ne fais que des programme Windows. Contrairement à DElphi, qui possède Kilix, pour Linux.

    Le .NET, C# ? Oulala ! Encore MIcro$oft qui veux ralentire les PC !
    Ce sont des language précompilé ! Vive la lenteur !
    Et puis, on devient tributaire d'une sociétée, qui est Micro$oft...

    Enfin voilà... Les bon language de haut niveaux évolue toujours...

    Turbo Pascal &gt; Delphi:Kilix
    C &gt; C++

    Les autre évolue vers la démendance d'un société, et je ne pense pas que se soit bon !

    J'ai dis. ;0)

  • signaler à un administrateur
    Commentaire de CCJ le 23/08/2004 16:51:19

    (encore a la bourre!)
    si vb existe c'est parcequ'il est basic et plus facile et rapide a apprendre sinon il existerai pô!
    na!

  • signaler à un administrateur
    Commentaire de ennixo le 25/08/2004 16:45:37

    AH mais non !!!!

    VB c'est très rapide et je peux le prouver !!!

    si vous trouvez VB lent c'est que votre code n'est pas optimisé, que vous utilisez des variants, et que vous testez en mode debug (pas compilé).

    là évidement c'est lent !

    mais du code compilé est bien assez rapide pour concurrencer C++ (si si) !!!

    alors évidement en c++ ça ira peut etre un poil + vite qu'en VB dans la globalité du programme mais il ne faut pas oublier que VB c'est certes assez simple mais ça n'empeche pas que c'est puissant.

    sinon à ce moment là on a qu'à programmer en assembleur et optimiser à fond mais là s'il faut faire un truc un peu compliqué en VB ça devient carrément infernal en asm...

    mais en tt cas, je l'ai déjà dit et je le redis VB c super rapide !!!

    Sinon ce programme est interessant mais il pourrait être encore plus interessant de substituer les appels à la dll par des api windows (et ainsi avoir enfin des programmes standalone).

    moi je dis : TODO !

  • signaler à un administrateur
    Commentaire de iloveprog le 07/02/2007 11:31:25

    mec, il faut que tu arretes de fumer ! Un prog en C/C++ un poil plus rapide que VB ?!
    Pour l'exemple, mon petit prog de compression de fichiers en VB etait en moyenne 26 fois plus lent que le meme codé en C/C++.
    Faut arreter cte polemique comparative entre les langages , oui VB c'est bien, ca permet de faire enormement de choses, oublie pas que c'est un langage tres haut-niveau (eloignee du materiel ; asm -> bas niveau).

    C'est comme si tu disais qu'un prog bien optimisé en C (moyen niveau)  sera juste un peu plus lent que le meme codé en assembleur.

    >>DeadlyPredator : joli travail ! Ta source est propre et puissante ...

  • signaler à un administrateur
    Commentaire de Proger le 11/12/2007 14:44:49

    J'aime bien la polémique :)
    VB6 est aussi rapide que n'importe quel langage lorsqu'on fait des algorithmes _pur_ et qu'on ne code pas avec ses gros sabots.
    La gestion des tableaux et des type utilisateurs et un chouia plus lent qu'en c++ a cause des contrôles anti "seg fault"... et le fait qu'on ne puisse pas utiliser de pointeurs.
    Les opérations en virgules flottantes sont aussi un chouia plus lente, dans certains cas, à cause -aussi- de vérifications anti-dépassements.
    Par contre il perd en vitesse si on travaille avec les gestions de Variant ou String (concaténation, mid() left() format(), etc...) là ou tous les autres langages ont des routines plus finaudes.
    Enfin, l'utilisation d'objets et d'API est un gouffre à performances... à n'utiliser qu'en dernier recours (donc en E/S, et surtout pas dans un algo!).

    Et bien evidemment, si vous compilez pas vos programmes VB6, toutes comparaisons avec des autres langages du même niveau est une hérésie... comparez-le plutôt au javascript dans ce cas!

    Au final, VB6 est définitivement dépassé en perf parce qu'il ne bénéficie pas d'un compilateur costaud (son compilo date de 1998, et donc il était adatpé au CPU de l'époque, tandis qu'en .net, vc etc... ils sont plus récent, tirent parti du pipelining, des grosses caches, branchement prédictifs si on place les instructions dans un certain ordre...)

  • signaler à un administrateur
    Commentaire de Renfield le 11/12/2007 15:47:17 administrateur CS

    d'accord avec toi l'ami, a quand un nouveau compilo VB6 qui supporte le multithread, optimise ce qui es pondu (multi core, pipelines, buffers plus grand, x64)... et qui sort du natif :p

    ca rallongerait la vie de VB6 :p

  • signaler à un administrateur
    Commentaire de BruNews le 11/12/2007 16:15:35 administrateur CS

    Quel discours de sourds...
    Un compilateur costaud, mais pour quoi faire ? il y a très peu de compilé dans du VB, comme dit plus haut par EB, ce ne sont quasi que des call vers la VM, il n'y a pratiquement rien à optimiser.
    Pour optimiser il faut avoir le code dans le listing.
    Ce n'est pas avec du script genre: "maprogbar.value = n" qu'un autre compilo changerait quoi que ce soit, il faut par force appeler le binaire contenant le vrai code et c'est dans la VM que ça se situe.

  • signaler à un administrateur
    Commentaire de Proger le 11/12/2007 18:44:59

    Pour résumé la pensée :
    i = i + 1, c'est aussi rapide dans n'importe quel langage. Le défaut du VB6 compilé c'est qu'il fait inc eax là ou les compilo modernes font add eax,1

    Faut pas tirer sur l'ambulance! en vb6, on est pas obligé de faire text1.text = text1.text + label1.caption, il y en a qui connaissent le coup du i = i + 1 (et qui compile en natif et pas p-code)

    A ceux qui ont un code vb 10 à 30 fois plus lent qu'un code en C, remettez-vous en question avant d'accuser votre IDE favori ! des dizaines de tutoriaux sur VBFrance exposent comment éviter les pièges à lenteur.

Ajouter un commentaire

Pub



Appels d'offres

CalendriCode

Août 2008
LMMJVSD
    123
45678910
11121314151617
18192021222324
25262728293031

Boutique

Boutique de goodies CodeS-SourceS