Newsgroup: it.comp.lang.visual-basic
Titolo: VB6 reverse engineering ...

Uso una piccola applicazione in VB6 non più supportata dall'autore,
distribuita in un unico file .exe .
Mi servirebbero assai un paio di piccole modifiche, che potrei farmi
tranquillamente da solo.
Question:
esiste un decompilatore che renda codice sorgente, forms e quant'altro
necessario a ricompilare il tutto.... o sto vaneggiando ?
Thx in advance,
p.

Pietro Gambadilegno ha scritto:

In parte: la pazienza e la competenza che ti servirebbero ti 
permetterebbero di riscrivertela da capo...
-- 
Emanuele Torrenti
Registered Linux User #409659
http://torrenti.altervista.org


Se la applicazione è compilata in P-Code grazie a VBRefactor potrai avere 
del codice ingestibile, inguardabile e forse non funzionante, ma comunque 
codice vb6.
Se la applicazione è compilata in codice nativo l' unica possibilità è 
essere bravissimi in asm e modificare il tutto da SoftICE o altro 
debugger/disassembler.
Ma a quel punto significa che sei tanto bravo che scriveresti quell' 
applicazione in poche ore in VB...
Bye,
-- 
Carmine ( 
pikachu...@gmail.com
 (Togli la scritta NOSPAM) )
Webmaster di The Total Site 4 : 
http://www.thetotalsite.it
My Blog: 
http://blog.thetotalsite.it
MariokartDS Codice Amico: 532639027909 - CarmineC in MarioKartDS
Se un circuito funziona al primo tentativo è perchè il problema è molto
più nascosto e subdolo di quanto tu possa pensare...
E apparirà nel momento in cui farà il massimo danno 

permetterebbero di riscrivertela da capo...
Ok, 
la pazienza ce l'ho, la competenza si può accrescere.
Se il sorgente in uscita (!?) consentisse di capire come accede ai suoi
dati, mi sarebbe sufficiente per mettere insieme un'applicazioncina
"esterna" adatta allo scopo.
Allora, esistono 'sti decompilatori x VB6?
p.

 Allora, esistono 'sti decompilatori x VB6?
Leggi la mia risposta.
Pazienza significa mesi di lavoro.
Competenza significa averne TANTA davvero.


Competenza significa averne TANTA davvero.
Il (maledetto) programma è certamente compilato in codice nativo...
Pazienza, mi rassegnerò a fare a mano le cose che volevo automatizzare.
Grazie a tutti.
p.

 automatizzare.
Ma comunque, spiegaci che tipo di programma è e cosa vuoi aggiorgerci...
Forse c'è un altro programma opensource adatto alla scopo.


Forse c'è un altro programma opensource adatto alla scopo.
Ci provo.
Esso gestisce ed archivia i risultati di prove di laboratorio su una
serie di prodotti, e le caratteristiche nominali dei medesimi.
La parte che mi interessa modificare preleva alcuni campi da un archivio
in formato... non identificabile, e li manda ad un file .doc per
produrre un certificato di conformità. 
Il file .doc contiene delle variabili nella forma $$CODICE$$,
$$DIMENSIONI$$, ecc. che vengono sostituite dai dati inviati
dall'applicazione. 
Il mio scopo è aggiungere altre informazioni sul certificato, inviando
dei campi che esistono nell'archivio, ma che il programma attualmente
ignora.
p.

 ignora.
I campi che sono ignorati dal programma attuale sono comunque visibili a 
monitor? E se si', in che modo? (text box, list box ,griglia ecc.ecc.)
Umbe 

Pietro Gambadilegno ha scritto:

SE il programma NON si interfaccia direttamente alle macchine per
l'acquisizione dei risultati (input a manina dei risultati)
Prendi Access ed in un pomeriggio sforni tutto quello che vuoi
in 3 gg con VB
Se deve interfacciarsi alle macchine:
a) sai il protocollo di comunicazione....spippoli un po...in genere
sono via seriale.....
ed in una settimana tiri fuori un nuovo gestionale (se deve solo
stampare il certificato e poco altro)
b) Non sai il protocollo...la casa produttrice non te lo dice...perchè
casomai vendono loro un gestionale adatto...ed allora è dura!...devi
monitorare le comunicazioni e vedere se ci capisci qualcosa...in genere
cmq vada...sparano fuori file di testo..
cmq vada

 monitor? E se si', in che modo? (text box, list box ,griglia ecc.ecc.)
le visualizzazioni sono tutte in griglie, credo non µ$oft , ... ma l'insieme 
dei dati è sparpagliato in varie schermate.
p.

 ha scritto nel messaggio 
news:YIi6g.108137$PR2.1...@twister2.libero.it...

Le griglie contengono solo ed esclusivamente i dati che ti interessano 
oppure anche dati che non vorresti inserire nei rapporti(o che già sono 
stati inseriti)?
Inoltre....come si passa da una schermata all'altra? con bottoni? con menu'?
Umbe 

 menu'?
con pulsanti
cmq. pensavo che, accedendo al codice (speranza ormai tramontata), avrei 
potuto capire come accedere ai dati salvati e riscrivere solo la  parte di 
invio delle informazioni al file word.
p.

 invio delle informazioni al file word.
L'altra possibilità, ed era la ragione di tutte le mie domande, era quella 
di intecettare con un altro programma i vari handle dei vari controlli 
disseminati sulle form e creare quindi creare il rapporto nuovo.
Il tutto rigorosamente intercettando i vari messaggi di sistema (via Api). 
Si poteva fare con i vari FindWindowEx, sendMessage e postMessage 
ecc.ecc.ma
 
con la griglia strutturata in quel modo la vedo grigia......a meno che 
qualcuno non abbia idee diverse...
Umbe 

 ha scritto nel messaggio news:iu2i52pkeqbf6kuq1...@4ax.com...

la seconda che hai detto

 meno che qualcuno non abbia idee diverse...
ci avevo pensato pure io, ma mi è parso che i controlli griglia siano 
inaccessibili all'API...
grazie comunque,
p.
p.s.
... ho già iniziato a reinserire i dati mancanti a mano...

 ma comunque codice vb6.
VBRefactor???
Mi spieghi meglio cos'è?
-- 
Gianluca Cannalire
Microsoft MVP/MCP - Visual Basic
http://www.visual-basic.it
http://community.visual-basic.it/gianluca
 

 Mi spieghi meglio cos'è?
?
Tempo fa proprio su questo ng non ricordo chi aveva fatto il nome di questo 
programmino.
Forse il nome non è proprio esatto... ma mi sembra che sia così.
Il programma ovviamente non era della microsoft, ma di un azienda esterna.
Perchè cmq? C'è qualcosa di strano?


 esterna. Perchè cmq? C'è qualcosa di strano?
Forse il nome l'ho fatto proprio io (anzi, sicuramente).
Ma non ha nulla, nulla, ma proprio nulla-nulla a che vedere, con il 
discorso decompilazione.
Ciao


 discorso decompilazione.
???
Ma... come?
Serve appunto a risalire al source code...
Ho provato la versione demo, e faceva decompilare solo la Sub Main...


 Ho provato la versione demo, e faceva decompilare solo la Sub Main...
mah...
Io non ne ho mai visto uno...


Io non ne ho mai visto uno...
C'è questo:
http://www.vb-decompiler.org/index.php?p=Products
La versione PRO, per carpire qualche "segreto" da riutilizzare, penso
vada bene.
Chissà se il codice (modificato e) ricompilato poi funziona, almeno nei
casi più semplici...
p.

"Pietro Gambadilegno" ha scritto nel messaggio

Ti dirò. ho provato la versione lite, con un prog in VB5, estremamente
semplice (è solo un test, praticamente non fa niente).
Ha ricreato l'interfaccia, più o meno, e ti dirò che non mi aspettavo
neanche quello :-).
Ma ovviamente le routine, il codice insomma, non viene decompilato,
solo disassemblato, che è una cosa ben diversa.
Per esempio, una delle routine originali è questa:
***************
Private Sub Command1_Click()
  Dim A As Integer
  Dim B As Integer
  Dim C As Integer
  Dim D As Integer
  For D = 0 To 4
    For C = 0 To 4
      For B = 0 To 4
        For A = 0 To 4
          Debug.Print 8 * A & ", " & 8 * B & ", " & 8 * C & ", " & 8 * D
        Next
      Next
    Next
  Next
***************
Il risultato del disassembler è stato questo (posto solo l'inizio, eh):
***************
Private Function Command1__405FF0
00405FF0:    push ebp
00405FF1:    mov ebp, esp
00405FF3:    sub esp, 0000000Ch
00405FF6:    push 004011B6h ; MSVBVM50.DLL.__vbaExceptHandler
00405FFB:    mov eax, fs:[00h]
00406001:    push eax
00406002:    mov fs:[00000000h], esp
00406009:    sub esp, 00000060h
0040600C:    mov eax, [ebp+08h]
0040600F:    push ebx
00406010:    mov ecx, eax
00406012:    push esi
00406013:    and al, FEh
00406015:    push edi
00406016:    mov var_0C, esp
00406019:    and ecx, 00000001h
0040601C:    mov edx, [eax]
0040601E:    mov var_08, 00401110h
00406025:    push eax
***************
Col compilato in native mode, che ovviamente è il default, e quindi
quello che tutti usano, non si tira fuori di più. Ricompilando in p-code,
dalla stessa sub si ottiene questo:
***************
Private Function Command1__40575C
  'Data Table: 4044FC
  loc_405704: LitI2_Byte 0
  loc_405706: FLdRfVar var_8C
  loc_405709: LitI2_Byte 4
  loc_40570B: ForI2
  loc_405711: LitI2_Byte 0
  loc_405713: FLdRfVar var_8A
  loc_405716: LitI2_Byte 4
  loc_405718: ForI2
  loc_40571E: LitI2_Byte 0
  loc_405720: FLdRfVar var_88
  loc_405723: LitI2_Byte 4
  loc_405725: ForI2
  loc_40572B: LitI2_Byte 0
  loc_40572D: FLdRfVar var_86
  loc_405730: LitI2_Byte 4
  loc_405732: ForI2
  loc_405738: FLdRfVar var_86
  loc_40573B: NextI2 var_9C, loc_405738
  loc_405740: FLdRfVar var_88
  loc_405743: NextI2 var_98, loc_40572B
  loc_405748: FLdRfVar var_8A
  loc_40574B: NextI2 var_94, loc_40571E
  loc_405750: FLdRfVar var_8C
  loc_405753: NextI2 var_90, loc_405711
  loc_405758: ExitProcHresult
  loc_405759: LargeBos loc_405759 'Ignore this
  loc_40575B: LargeBos loc_4057DF 'Ignore this
End Function
***************
Converrai che non è proprio codice ricompilabile, modificabile
e/o riutilizzabile. Credo di aver capito che nella versione Pro
questo tipo di codice venga ritradotto in VB, per quanto con delle
limitazioni... ma la realtà è che io non conosco nessun buon motivo
per compilare in p-code e nessun programmatore che lo faccia.
E, come dice anche l'help: "If a program was compiled in the native
code, restoration of  the initial code from machine instructions is out of
questions."
Chiaro, no ?
Bye, G. 

Chiaro, no ?
Chiarissimo.
Devo dire che, come utente di sw migliorabile, la cosa mi dispiace...
... ma come programmatore, anche se ormai solo "della domenica", mi
dispiace un po' meno.
Ciao,
p.