Newsgroup: it.comp.lang.delphi
Titolo: Eseguire un file residente solo in memoria

Mi chiedono di includere un eseguibile in un altro. Fin qua tutto semplice, 
lo includo in un file di risorse e lo leggo con TResourceStream.
Si vorrebbe però che l'eseguibile "incluso" venga eseguito direttamente 
dalla memoria e non venga salvato su disco. Quindi non posso passare il 
ResourceStream su un TFileStream col metodo CopyFrom. Mi rimane 
TMemoryStream ma poi non saprei come eseguire il file.
Mi rimane un memory mapped file (CreateFileMapping, attributo SEC_NOCACHE), 
ma poi come eseguirlo?
-- 
Mauro Falzari
"Chi sarà ricorso a un veleno per pensare,
ben presto non potrà più pensare senza veleno".
  (Charles Baudelaire, in "Le poëme du haschish", Parigi 1980)

 dalla memoria e non venga salvato su disco.
Siamo sicuri che una simile pratica venga tollerata dal generico 
antivirus? :-|
-- 
MARCO BREVEGLIERI
  (
http://www.marco.breveglieri.name
)
     Non hai la possibilità di scaricare Turbo Delphi Explorer?
     Te lo spedisco io!! [
http://www.marco.breveglieri.name/?p=48
]

 antivirus? :-|
mah, credo che debba essere fatto girare su macchine con Win95 o giù di lì,  
e solo in ambito industriale, credo. Quindi niente antivirus. Sto tizio 
vorrebbe usare il meccanismo dell'EXE incluso in un altro EXE a mo' di 
protezione anticrack.
In effetti ho cercato a destra e a manca su google ma c'è un po' pochino. 
Pare che non sia possibile. (sul fantomatico Win32Loader.exe poi, citato in 
un articolo, non ho trovato quasi nulla).
Qualcuno suggeriva un RAMDisk, ma per fare quello bisognerebbe riavviare 
tutto, e invece qui serve una soluzione "al volo".
Altra domanda: se lo copio su disco e lo lancio, posso cancellare l'EXE 
mentre sta girando? In linea generale non credo si possa...
Quindi dovrei lanciare l'EXE, aspettare che termini e poi cancellarlo, 
magari in modo "sicuro" dal disco.
Che ne dite?
-- 
Mauro Falzari
"Eteroschedasticità condizionale".
  (
http://tinyurl.com/a5k5w
)

Utilizzare un RAM drive è troppo macchinoso ? Il programma viene
installato n-volte su PC altrui ?
Ciao
--- posted by geoForum on 
http://www.delphiedintorni.it

scusa non avevo aggiornato il post, ritiro quanto detto...


Non potresti zippare il file con una password e aprirlo con la password
scritta nel programma di lancio ? Ho visto in giro alcuni componenti a
riguardo..


Naturalmente il file zippato chiamalo TExecV.dll o qualcosa del genere e
non .zip :-D




Non è possibile, per le mie conoscenze di win32.
Per una questione di contesto.
Se tu carichi nella memoria di un processo dei dati, questi dati
appartengono al quel processo e non possono essere "toccati" da altri.
Se mandi in esecuzione un altro file viene istanziato un nuovo spazio
memoria di cui il processo appena avviato è proprietario. 
Per quel che vuoi far tu uno spazio memoria(ricordiamoci che si lavora con
indirizzamenti virtuali e non fisici) deve essere usato da 2 processi e
questo fa impazzire le MMU, processore, S.O.
I sistemi *nix hanno il comando fork che crea un processo figlio copiando
tutta la memoria del padre nello spazio creato per il figlio. Esiste
qualcosa anche per win? (sono rimasto abbastanza indietro su win32).
Usando il fork hai due processi, nel primo il "lanciante" nel secondo
entrambi.
Non puoi nemmeno aprire un file e poi cancellarlo, l'S.O. non carica tutto
in memoria, ma a blocchi, a seconda di cosa/come/quando gli serve. Se lo
togli dal disco....
Ci risiamo....nei sistemi *nix si può cancellare un file in uso, l'S.O. non
rimuove il riferimento(inode) sul disco fino a quando non viene chiuso, ma
non è accessibile ad altri processi(a patto di non andare a puntare l'inode
specifico...ma come fai a conoscerlo?) E' una pratica abbastanza diffusa
come passaggio dati tra processo padre/figlio, si apre il file, si passa
all'altro e poi si cancella mentre l'altro l'ha in uso; il file esiste solo
per chi lo tiene aperto.(sto andanto OT....)
Bye,
Raktzo

"Mauro Falzari" <mauro_...@despammed.com.invalid> ha scritto nel 
messaggio:
La butto la.
Includi anzichč l'eseguibile un iso (intesa come file immagine) leggibile da 
una qualsiasi periferica virtuale come i CD-ROM virtuali (il che dovrebbe 
anche aumentare la tolleranza da parte degli AV meno rigidi). Installi la 
periferica virtuale CD-ROM (che non richiede il reboot della macchina se il 
driver č installato: vedi Nero Image Drive & co. che le aggiungono/rimuovono 
on-the-fly) e carichi su di essa la iso. Automagicamente puoi eseguire il 
tuo file ...
-- 
- Carlo - 

Volevo soltanto ricordare, non credo sia questo caso, che Borland non
permette l'utilizzo di Delphi per fini ritenuti "non etici".. Quindi prima
di mettere in gioco la propria licenza ci penserei un attimo....
Buona Giornata
Matteo


 Non č possibile, per le mie conoscenze di win32.
Si', si puo' fare. I programmi di compressione
come UPX, per esempio, lo fanno.
Un esempio in C lo si trova qui:
http://snipurl.com/131xi
Questa invece e' una discussione riguardo Delphi:
http://snipurl.com/131xs
e googlando un po' secondo me si trova anche altro.
Ciao
-- 
ACSH
[TurboDelphi]
Chi fa da se', fatica il doppio 

 prima di mettere in gioco la propria licenza ci penserei un attimo....
non è un virus nè un malware, quello che mi propongo di scrivere!
D'altronde, sperimentare non è neppure un peccato.
-- 
Mauro Falzari
"Le gambe delle donne sono l'unico compasso che misura il 
mondo".
  (François Truffault)

 secondo entrambi.
in effetti, guglando, avevo trovato discussioni a riguardo, ma solo per 
ambienti *nix


L'operazione fatta in quei casi è diversa.
Diversa in quanto l'esecuzione del codice avviene all'interno del processo
che ha "generato" il codice.
Per quello che dici ci sono anche questi
http://groups.google.it/group/borland.public.delphi.language.basm/browse_thread/thread/a6c98087019fd4b3/b7412ef9c0d3253f%23b7412ef9c0d3253f
http://www.experts-exchange.com/Programming/Programming_Languages/Delphi/Q_20974729.html
http://www.joachim-bauch.de/tutorials/load_dll_memory.html/en
Bye,
Raktzo

che ha "generato" il codice.
Che vuoi dire ?

raktzo ha scritto:



Non mi sembra facesse troppo lo schizzinoso riguardo al metodo di
esecuzione, ma ora tra le mie e le tue info probabilmente qualcosa
riuscira' a tirare fuori.
Una curiosità: questi metodi valgono per tutte le versioni di Win32?
Io non ne sono sicuro, ma purtroppo non ho molto tempo per informarmi.
Se tu sai qualcosa senza che tu debba perderci troppo tempo, mi piacerebbe
conoscere la risposta.
Ciao
ACSH
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 riguardo..
sě ma bisognerebbe comunque salvare il file unzippato da qualche parte e 
poi, alla fine cancellarlo. 
1- Il programma CONTENITORE scompatta il programma PILLOLA (su disco).
2- Il programma CONTENITORE lancia il programma PILLOLA e attende che
   termini
3- Il programma CONTENITORE cancella il programma PILLOLA
I punti 1 e 2 sono semplici, ma mettiamo che tra il punto 2 e 3 manchi la 
corrente... Il programma PILLOLA resterebbe su disco, no?
-- 
Mauro Falzari
"Se non conosci la storia, sei un perfetto ignorante".
  (Edward Johnston, 1990)

Grazie a tutti per gli interessanti contributi. Ho guardato i link e alcune 
parti mi sono sembrate davvero esoteriche, allo stato delle mie attuali 
conoscenze...
In sostanza, una DLL si riesce a caricare direttamente dalla memoria perchè 
è rilocabile, ma un EXE no.
Tra i link che mi sono stati consigliati c'è anche un porting in delphi del 
caricamento della DLL 
 
http://www.dsplayer.de/open_source_projects/BTMemoryModule.zip
A questo link che mi è stato consigliato invece
http://groups.google.it/group/borland.public.delphi.language.basm/browse_th
read/thread/a6c98087019fd4b3/b7412ef9c0d3253f%23b7412ef9c0d3253f
si vede come caricare dinamicamente istruzioni macchina. Certo, può andar 
bene per programmi relativamente piccoli, ma come caricare tutto il codice 
di un EXE di un paio di MB?
Vedrò quello che riesco a cavarne fuori.
Devo vedere anche se è possibile che 'sta benedetta applicazione del mio 
amico non sia un file dati di qualche programma (come può essere un file 
DOC per WINWORD) e se il programma non esponga per caso un server COM (nel 
qual caso aprirei -se possibile- un'istanza invisibile del COM-server e gli 
passerei il file...)
Casualmente mi sono anche imbattuto in questo, anche se non riesco ancora a 
farlo funzionare:
 
http://www.swissdelphicenter.ch/torry/showcode.php?id=2427
-- 
Mauro Falzari
"Quando tutto è silenzio le cose cominciano a parlare,
pietre, animali e piante diventano fratelli e sorelle
e comunicano ciò che è nascosto".
  (Ernst Jünger)

 iso. Automagicamente puoi eseguire il tuo file ...
quindi questa ISO non dovrebbe essere visibile da nessuna parte, con mezzi 
"normali" (explorer), giusto? (con un RAM drive invece si vedrebbe il file, 
durante l'esecuzione)


Chiedo scusa se non ho capito bene... 
Pensavo di mettere il file zippato con una password e quindi criptato
(inoltre nascosto con estensione dll).. IN ogni caso non sarebbe leggibile
il contenuto, e aprirlo dall'applicazione che ha la password con un
componente destinato a tale scopo. Ne ho visti di bellini a riguardo in giro..
Il file potrebbe essere anche messo in un archivio .exe autoestraente,
sempre con password.
Magari mi sfugge qualcosa 
Ciao


 durante l'esecuzione)
La ISO a rigor di logica è visibile. Però puoi nascondere il drive. Ci son 
diversi applicativi che per scopi più o meno nobili lo fanno.
Dai un' occhio qui, forse ti sarà utile:
http://www.jsifaq.com/SF/Tips/Tip.aspx?id=3636
-- 
- Carlo - 

Chiedo scusa se non ho capito bene... 
Pensavo di mettere il file zippato con una password e quindi criptato
(inoltre nascosto con estensione dll).. IN ogni caso non sarebbe leggibile
il contenuto, e aprirlo dall'applicazione che ha la password con un
componente destinato a tale scopo. Ne ho visti di bellini a riguardo in giro..
Il file potrebbe essere anche messo in un archivio .exe autoestraente,
sempre con password.
Magari mi sfugge qualcosa 
Ciao
--- posted by geoForum on 
http://www.delphiedintorni.it

 son diversi applicativi che per scopi più o meno nobili lo fanno.
oh my god...il tutto era nato a mo' di protezione anticrack...un EXE 
criptato e compresso dentro un altro EXE...però in effetti è lo stesso modo 
con cui si può scrivere un malware.
Rileggendo i post precedenti mi pare che la soluzione della DLL sia forse 
quella più praticabile.
Comunque ci proverò...
-- 
Mauro Falzari
"L'oppio assomiglia alla religione 
come un illusionista assomiglia a Gesù Cristo".
  (Jean Cocteau, in "Lettres a Jacques Maritain", Parigi 1926)

 la corrente... Il programma PILLOLA resterebbe su disco, no?
mi è venuta in mente una variante ai punti 2 e 3...niente di che...
2- Il programma CONTENITORE lancia il programma PILLOLA e poi termina
3- Il programma PILLOLA si autocancella al termine dell'esecuzione (la 
   soluzione KILLME.BAT, tanto per intenderci)


 (inoltre nascosto con estensione dll).. 
sì ma la compressione/criptatura del file incluso non sono un problema...il 
problema è essere sicuri che venga cancellato dopo che è stato decompresso


 Una curiosità: questi metodi valgono per tutte le versioni di Win32?
Non penso, da una lettura veloce di alcuni codici si fa uso specifico di
funzioni riservate al mondo NT(NT, w2k, wxp, etc)
Bye,
Raktzo

Ci daresti un feedback della tua esperienza...
son curioso :-)
Bye,
Raktzo

Ok, non ci eravamo capiti....
Credo che il file possa essere letto direttamente senza essere decompresso..
Quindi rimarrebbe evenutualmente criptato sul HD. comunque cancellato se
si vuole, ma col solo rischio di lasciare un file criptato inutilizzabile...
Ciao Matt


 decompresso.. 
i casi sono due: o viene messo in una cartella temporanea nascosta (come fa 
WinZIP o WinRAR) o viene passato (se si tratta di componenti Delphi) come 
TStream.
In questo secondo caso, non posso avviare un file che esiste solo come 
Stream...
-- 
Mauro Falzari
"Chi sarà ricorso a un veleno per pensare,
ben presto non potrà più pensare senza veleno".
  (Charles Baudelaire, in "Le poëme du haschish", Parigi 1890)

 son curioso :-)
più che altro, se hai pazienza :-) visto che non è un'applicazione 
"critica" ed è poco più che un passatempo per me...


Non so, pensavo di utlizzare TMemoryStream come dicevi all'inizio con un
componente di compressione criptata come 
Easy Compression Library
http://www.componentace.com
che vi accede in lettura e scrittura, se ho visto bene.
Non conosco bene l'argomento. Scusa se ti ho fatto perdere tempo.
Ciao


Se non hai tempo di guardare il sito che ti ho detto sopra ti invio una
porzione delle istruzioni.
Se ho capito bene dovrebbe scompattare e leggere in memoria
Easy Compression Library provides a memory stream interface with
TECLMemoryStream class that can be easily used to compress and decompress
a file to a memory.
 
Compressing a file to memory.
To compress a file to memory you need to perform the following 2 steps:
   1. Create an instance of TECLMemoryStream that will contain a
compressed file with blank Password and with CompressionLevel parameter
not equal to eclNone value, i.e. with one of the compression modes.
   2. Call LoadFromFile method of TECLMemoryStream to load and compress
source file.
      Then you could directly access compressed data using
CompressedDataStream property of TECLMemoryStream.
 
      Example:
      var
      CompFS: TECLMemoryStream;
      begin
      CompFS := TECLMemoryStream.Create('', ppmMax);
      CompFS.LoadFromFile('c:\test.txt');
      { load compressed data }
      CompFS.CompressedDataStream.LoadFromFile('c:\test.ecl');
      { copy compressed data to a blob stream }
      BlobStream.CopyFrom(CompFS.CompressedDataStream,
CompFS.CompressedDataStream.Size);
      CompFS.Free;
      end;
 
      Decompressing a file to memory.
      To decompress a file to memory you need to perform the following 3
steps:
         1. Create an instance of TECLMemoryStream for the compressed
source file without parameters in constructor.
         2. Call LoadFromFile method of CompressedDataStream property of
TECLMemoryStream to load compressed file.
         3. Set the value of CompressionLevel property of TECLMemoryStream
to eclNone to decompress the data in memory.
 
            Note:
            The step 3 is not required to access decompressed data in
memory. For ECL streams, you almost always deal with the transparently
decompressed data when you use methods and properties of the ECL streams.
 
            Example:
            var
            CompFS: TECLMemoryStream;
            begin
            CompFS := TECLMemoryStream.Create;
            CompFS.CompressedDataStream.LoadFromFile('c:\test.ecl');
            CompFS.CompressionLevel := eclNone;
            ShowMessage('The size of decompressed data is:
'+IntToStr(CompFS.Size));
            CompFS.Free;
            end;


 '+IntToStr(CompFS.Size));
ok...se mi dici come eseguire CompFS senza salvarlo su disco abbiamo 
risolto il problema :-)


 son curioso :-)
appena ho un attimo di tempo devo approfondire questa dichiarazione:
"Under Win32, unless you are running from a removable drive, you cannot 
delete a running executable."
  (
http://delphi.about.com/cs/adptips1999/a/bltip0799_3.htm
)
Poi mi son posto anche il problema se si potesse lanciare un eseguibile 
avente estensione diversa da EXE e mi sono imbattuto in questa discussione 
datata 1999
http://groups.google.it/group/it.comp.delphi/browse_thread/thread/822479ca4
a791e0/36fa343075271f4b?lnk=st&q=lanciare+file+estensione+non+exe+delphi&rn
um=3&hl=it
-- 
Mauro Falzari
"L'oppio assomiglia alla religione 
come un illusionista assomiglia a Gesů Cristo".


   (
http://delphi.about.com/cs/adptips1999/a/bltip0799_3.htm
)
è falsa. 
Non si riesce a cancellare un file EXE che si trova su una chiavetta USB, 
mentre sta girando.
-- 
Mauro Falzari
"Military justice is to justice 
what military music is to music".
  (Groucho Marx)

Volevo soltanto chiedere ma il programma .exe da lamciare lo crei in
delphi e hai le sorgenti ? In tal caso c'è un metodo m.semplice
(probabilmente non è così)...
Ciao


Cioč il programma .exe arriva da un altro linguaggio tipo VBasic e ci sono
a disposizione le sorgenti... ?


 (probabilmente non è così)...
eh no, magari! Abbiamo l'EXE ma non i sorgenti (ce ne fosse una cosa, di 
facile...)
-- 
Mauro Falzari
"Io passo in mezzo agli uomini,
come in mezzo a frammenti dell'avvenire:
di quell'avvenire che io contemplo".
  (Friedrich Wilhelm Nietzsche, 1844-1900)

Mi č venuto in mente questo metodo.... Davvero l'ultima idea visto il
fallimento delle precedenti !
Si potrebbe criptare il file ma non con zip ma con un cripter
Il cricter deve perň poter permettere di eseguire il file da riga di comando.
Cercando in rete mi sono imbattuto in:
http://axcrypt.axantum.com/
AXCRypt ha il privilegio di poter eseguire i file da riga di comando con
l'opzione nomefile -o.
pippo -o
Quindi userei ShellExecute di Delphi che puň lanciare delle righe di
comando come se venissero lanciate da prompt.
Rimane da capire se il programma crypt scelto non scrive prima sul HD e se
č necessario installarlo e come sul pc di destinazione.
In caso contrario ne esistono altri in rete ?


 
http://axcrypt.axantum.com/
Matteo, mi hai dato un'ottima idea!
AxCrypt lo conosco già da un po' e lo utilizzo correntemente su vari pc, ma 
non mi era venuto in mente che si potesse usare da riga di comando (in 
effetti mi ero scaricato di recente i sorgenti per capire come fa a 
lanciare i file decriptati, se li salvasse su disco, ecc. - ma non ho 
approfondito, anche perchè sono scritti in C++)
Grazie ancora!!
-- 
Mauro Falzari
"Detelematizzatevi!"
  (
http://tinyurl.com/85qyw
)

Volevo soltanto chiedere una cosa.... Per vedere se la mia idea è possibile!
Si possono inviare da Delphi dei comandi come se venissero inviati da
tastiera ?
Nell'esempio supponiamo che il programma da lanciare nascosto giri sotto DOS.
Lancerei un .bat, attraverso ShellExecute di Delphi con dentro 
DEBUG MYFILE.DLL
dove MYFILE.DLL è il programma nascosto.
A questo punto andreai a scrivere un byte modificato e poi a lanciare il
programma stesso con l'istruzione del DEBUG che è g
Quindi se il programma non è di dimensioni eccessive e forse deve per
forza girare sotto DOS verrebbe caricato, riparato e lanciato
Matt


 sono a disposizione le sorgenti... ?
no, non ci sono i sorgenti a disposizione. Questo mio amico ha modificato 
bit per bit alcune parti di programmi per automazione industriale, in 
origine forse creati con C++ o con Delphi, adattandoli alle proprie 
esigenze.
-- 
Mauro Falzari
"Chi domanda comanda".
  (anonimo)

 Lancerei un .bat, attraverso ShellExecute di Delphi con dentro 
ti ringrazio per la profusione d'impegno ma penso che sia sufficiente 
AxCrypt con la linea di comando.
Ci lavorerň su nel tempo libero, č un passatempo! Grazie comunque per il 
tuo suggerimento che č stato determinante.



Ciao a tutti, premetto che non conosco per niente delphi ma la
discussione si riallaccia ad una problematica che avevo già sollevato
tempo fa :
http://groups.google.it/group/it.comp.programmare.win32/browse_thread/thread/42f733e689b417d7/b2033d6d65b10abb?lnk=st&q=win32+alcibiade&rnum=3&hl=it#b2033d6d65b10abb
Spero possa tornarvi utile, ciao

 &hl=it#b2033d6d65b10abb 
sì ma non mi pare che ti abbiano consigliato soluzioni praticabili, oltre a 
dirti di studiarti il formato PE :)
-- 
Mauro Falzari
Da una firma:
  "QûAñÐø LuÑgØ îL §ËñTiêRø ÐeLLå SûÃ ËsîStêNzÅ
  Lâ VøŠtRâ AñiMä ñØn vêÐrÅ Più dUê PãiÅ Ð'iMpRÕntË,
  nØñ GîÕitË pÊn§ãnDø K'iÕ ÅßßIâ §mêSsØ Ði T¤rMêÑtärVî,
  ßêN§ì VøLtãtÊvi ÅD ØSsËrvÅRê Lã v¤§tRâ ŠäLMã
  Kê hÅ §mêSsø ËtêrÑáMêNtË Ði LåsCîÃrË ImpR¤Ñtê. . . †"

 dirti di studiarti il formato PE :)
Solo quella di creare il file al volo e cancellarlo, il resto mi è
sembrato di capire che è mostruosamente difficile .....se trovate un
modo + efficiente fatemi un fischio che sono interessato (anche se non
conosco delphi ;))


che è facile da realizzare poichè includi il file criptato in un altro 
eseguibile e da lì lo scompatti su disco (il file è cmq sempre criptato), 
poi lo lanci da riga di comando, passandogli ovviamente la 
passphrase (
http://axcrypt.sourceforge.net/cmdline.htm
), e a sua volta 
AxCrypt decripterà il file "in maniera sicura", lo caricherà in memoria 
(come accidenti faccia è scritto nei sorgenti in C++, visto che è un open 
source) e lo eseguirà, senza lasciare traccia sul disco (almeno ne sono 
ragionevolmente certo).


PAZZESCO, arrivato a un soffio dalla soluzione però il debug non accetta
il tasto EWNTER !!! (Tolta la possibilità apposta sulla API da zio Bill ?)
Procedure TForm1.Delay (Msecs : Integer);
Var
   FirstTickCount : LongInt;
Begin
     FirstTickCount := GetTickCount;
     Repeat
           Application.ProcessMessages; Sleep(1);
     Until ((GetTickCount - FirstTickCount) >= LongInt (Msecs));
End;
procedure TForm1.Button1Click(Sender: TObject);
var x : integer;
begin
// MyProg.exe è il nome del programma che vogliamo nascondere
// C:\ è la posizione dove si trova
// Per non far vedere il cmd di dos mettere SW_HIDE al posto di SW_NORMAL
winexec('debug C:\myprog.exe',SW_SHOWNORMAL);
// qui metti un Delay o non funziona
Delay (300);
(* QUI METTIAMO TUTTE LE ISTRUZIONI PER CORREGGERE IL PROGRAMMA,
   TIPICAMENTE ABBIAMO TOLTO DALL'ASSEMBLER UN JMP
   E LO RIMETTIAMO CON L'ISTRUZIONE E *)
// Metti tra apici lettere maisucole o non fuziona  ???
keybd_event(Ord('G'), MapVirtualKey(Ord('G'), 0), 0, 0);
keybd_event(Ord('G'), MapVirtualKey(Ord('G'), 0), KEYEVENTF_KEYUP, 0);
Delay (100);
keybd_event(vk_RETURN, 1, 0, 0);
keybd_event(vk_RETURN, 1, KEYEVENTF_KEYUP, 0);
end;


 winexec('debug C:\myprog.exe',SW_SHOWNORMAL);
...ma scusa, devi ancora salvarlo su disco! :-D


...ma scusa, devi ancora salvarlo su disco! :-D
Non è necessario salvarlo su disco perchè il DEBUG carica in memoria e
lancia direttamente con l'istruzione G.
Il file su disco ha un JMP sbagliato, si carica, si mette a posto il JMP e
di lancia con G.
Non so,magari un abbaglio, è una cosa che interessa anche a me, farò delle
prove...


 keybd_event(vk_RETURN, 1, KEYEVENTF_KEYUP, 0);
perchè non un SendMessage + WM_KEYDOWN? Ma bisognerebbe conoscere l'handle 
della finestra, mi diresti tu. Allora in 10 min ho voluto provare anche 
io...ma non mi riesce di avere l'handle della finestra di CMD.EXE.
Forse tu puoi avere maggior fortuna. Ho modificato la ExecuteAndWait in 
modo da avere l'handle della main window dell'applicazione lanciata (ogni 
app dovrebbe avere una main window, anche se nascosta), però continua a 
restituirmi una finestra con nome "Tree1", sempre con lo stesso handle e 
che non sembra avere child windows (pensavo che tra le child avrei trovato 
la finestra dei comandi, in modo da poter usare SendMessage/PostMessage):
program Project1;
uses
  ShellAPI,
  Dialogs,
  SysUtils,
  Windows,
  Messages;
function ExecuteAndWait(const FileName: string;
  const Parameters: string = ''; Wait: Boolean = False): THandle;
var
	SEI: TShellExecuteInfo;
begin
// Inizializzo la struttura con i parametri.
	FillChar(SEI, SizeOf(SEI), #0);
	SEI.cbSize := SizeOf(SEI);
	if Wait then
// Questo flag è necessario perché il campo
// hProcess venga restituito in output.
		SEI.fMask := SEE_MASK_NOCLOSEPROCESS;
	SEI.lpFile := PChar(FileName);
  SEI.lpParameters:= PChar(Parameters);
// Per mostrare l'applicazione lanciata.
	SEI.nShow := SW_NORMAL;
	if ShellExecuteEx(@SEI) then
    begin
      Result := SEI.hInstApp;
      if Wait then
  // Aspetto che il processo termini.
        WaitForSingleObject(SEI.hProcess, INFINITE);
  // Rilascio il process handle.
      CloseHandle(SEI.hProcess);
    end
  else
    Result := 0;
end;
function GetWindowCaption(Handle: THandle): string;
var
  Buffer: array [0..255] of Char;
begin
  GetWindowText(Handle, Buffer, SizeOf(Buffer));
  Result := Buffer;
end;
function Callback(HWindow: HWND; lParam: LPARAM): BOOL; stdcall;
begin
  ShowMessage(GetWindowCaption(HWindow));
  Result := True       // = continua
end;
var
  h: THandle;
begin
  h := ExecuteAndWait('cmd.exe', '', false);
  if h > 0 then
  begin
    EnumChildWindows(h, @Callback, 0);
    ShowMessageFmt('Caption: "%s"; Handle: %u', [GetWindowCaption(h), h]);
  end
end.
-- 
Mauro Falzari
"Creative minds have always been known
to survive any kind of bad training".
  (Anna Freud)

La strada più giusta è quella dell'handle, ho provato ma anche a me niente...
CON L'INVIO DEL ENTER IN QUESTO MODO (keybd_event(VkKeyScan(#13), 28, 0,
0);) FUNZIONA... Devo trovare i : forse per correggere il JMP... !
Vedi qui sotto procedure corrette...
Procedure TForm1.INVIOIstruzione(TestoISTR:String);
var x : integer;
begin
// Qui manda : deve usare lo shift --- Ovvio vedi tastiera
if TestoISTR=':' then begin
keybd_event(Vk_Shift, 1, 0, 0);
keybd_event(VkKeyScan(':'), 1, 0, 0);
keybd_event(VkKeyScan(':'), 1, KEYEVENTF_KEYUP, 0);
keybd_event(Vk_Shift, 1, KEYEVENTF_KEYUP, 0);
end;
// Questa funziona con ENTER per il DEBUG con 28 ????
if TestoISTR='$' then begin
keybd_event(VkKeyScan(#13), 28, 0, 0);
keybd_event(VkKeyScan(#13), 28, KEYEVENTF_KEYup, 0);
exit;
end;
for x:=1 to length(TestoISTR) do
begin
keybd_event(VkKeyScan(TestoISTR[X]),
MapVirtualKey(VkKeyScan(TestoISTR[X]), 0), 0, 0);
keybd_event(VkKeyScan(TestoISTR[X]),
MapVirtualKey(VkKeyScan(TestoISTR[X]), 0), KEYEVENTF_KEYUP, 0);
end;
end;
procedure TForm1.Button1Click(Sender: TObject);
var x : integer; V2: string; V,sc: CHAR;
begin
//winexec('debug C:\myprog.exe',SW_SHOWNORMAL);
ExecuteAndWait('cmd.exe', '', false);
// qui metti un Delay o non funziona
//Delay (300);
INVIOISTRUZIONE('debug C');
INVIOISTRUZIONE(':');
INVIOISTRUZIONE('\MyProg.exe');
INVIOISTRUZIONE(#13);
INVIOISTRUZIONE('g');
(* QUI METTIAMO TUTTE LE ISTRUZIONI PER CORREGGERE IL PROGRAMMA,
   TIPICAMENTE ABBIAMO TOLTO DALL'ASSEMBLER UN JMP
   E LO RIMETTIAMO CON L'ISTRUZIONE E non mi ricorso se servono :
   Se servono allora bisogna trovare l'equivalente come ENTER ??? *)
INVIOISTRUZIONE('$');


Aggiungo a quanto detto sopra (invio del RETURN al Debug) che è possibile
anche lanciare eseguibili che usano dei parametri:
L'istruzione da mettere nel DEBUG è
n parametro1 parametro2 parametro3 etc.
Credo che si possa anche usare l'estensione .bat anzichè .exe per dare
ancora meno nell'occhio... oppure .com (Tanto il DEBUG la flagga sempre
come file eseguibile - qua bisogna fare delle prove per sicurezza).
L'eseguibile deve però poter essere lanciato da DOS... 
Se si riescono a trovare i ":" allora possiamo fare davvero tutto come
forzare dei JMP di protezione....
Ciao
