Newsgroup: it.comp.programmare
Titolo: Modificare un .exe in tempo reale

E' possibile che, quando un utente clicca su un link che punta ad un
eseguibile quest'ultimo venga modificato dinamicamente?
Spiego meglio da cosa deriva il mio dubbio. Qualcuno di voi si sarà
sicuramente imbattuto in quei siti che promuovono casinò virtuali. In
sostanza i webmaster che aderiscono al programma di promozione  dovrebbero
guadagnare una percentuale sulle perdite dei giocatori procacciati
attraverso il loro sito web. Grosso modo la cosa funziona così: il webmaster
aderisce al servizio e gli viene assegnato un codice identificativo. Il
webmaster colloca nel proprio sito un banner pubblicitario che punta, con il
proprio codice, alla home page del casino. Ogni utente che cliccando arriva
sul casino è invitato a scaricare il software necessario per giocare. Ogni
utente che scarica il software è automaticamente "assegnato" a quel
webmaster che lo ha "presentato" e, di conseguenza, il webmaster dovrebbe
guadagnare sulle sue perdite.
Mi chiedo: visto che l'utente, una volta scaricato l'eseguibile, si
interfaccerà al casinò solo attraverso il software che ha scaricato, il
codice che lo assegna a quel particolare webmaster deve essere contenuto
all'interno dell'eseguibile stesso.
In sostanza l'utente cliccherà su un link del tipo
http://www.nomecasino.com/~codicewebmaster/casino.exe
Casino.exe è un software che installerà il casinò sul proprio computer e
permetterà all'utente di giocare senza che quest'ultimo si ricolleghi al
sito dal quale lo ha scaricato. Per poter risalire al webmaster che ha
presentato quell'utente, l'unica soluzione possibile è che l'eseguibile in
questione si crei dinamicamente a seconda del codice che gli viene passato
nel link.
Mi chiedevo appunto se fosse tecnicamente possibile modificare un file
binario in tempi rapidissimi in modo da creare di volta in volta un
eseguibile contenente al suo interno quel particolare codice necessario per
poter risalire al webmaster.
Grazie

Sicuramente direi che è possibile, nel limite in cui è possibile editare un
file: normalmente il programma che apre il file non sa che significato abbia
il contenuto.
Questa tecnica è usata da alcune protezioni contro la copia del software,
allo scopo di scrivere un algoritmo non visibile dal disassemblatore e non
modificabile con un editore esadecimale; la stessa tecnica, giustamente, è
usata dai crak (i programmi che tolgono la protezione).
A quanto ne so (ma ti avviso che so molto poco e cerco di contribuire con
impegno ma con poche conoscenze) un file non può modificare se stesso:
bisogna farlo fare da un altro programma. Però l'eseguibile potrebbe salvare
sul disco un programma che lo modifica, lanciarlo e terminare se stesso. Il
programma che modifica l'eseguibile, una volta terminato il suo lavoro,
lancerà nuovamente quest'ultimo, che provvederà subito a cancellare dal
disco il programma non più utile.
Ciao.
PS: dimenticavo...
La faccenda del casinò potrebbe essere gestita con altre tecniche, tipo un
database sul server che rende disponibile il file eseguibile, oppure un
cookie, oppure ancora il collegamento potrebbe portare ad un programma che
in realtà esegue altre operazioni prima di rendere disponibile il file da
scaricare. Sono solo idee, vedi tu se ti sembrano praticabili.
Una cosa è certa: per scaricare ed installare un programma, oltretutto un
programma che deve essere eseguito quando sei collegato alla rete, ci vuole
molta fiducia molta. Io lo ho fatto solo con Napster, ma non sono stato nè
il primo nè il secondo.
Ciao di nuovo.

eseguibile quest'ultimo venga modificato dinamicamente?
Sicuro. Il modo piu' semplice e' attaccare al file .EXE, scritto con
il linguaggio che piu' ti aggrada, "tot" bytes di fuffa. Gli headers
del file .EXE faranno si' che quei "tot" bytes siano ignorati. Pero'
il programma potra' fare:
	fp = fopen(argv[0], "r");
	fseek(fp, -TOT, SEEK_END);
	fread(buffer, TOT, 1, fp);
	fclose(fp);
e avere in un buffer il proprio codice personale.
In PHP, per esempio, potresti fare:
	$len = filesize("install.exe") + strlen($WEBMASTERCODE);
	Header("Content-Type: application/exe");
	Header("Content-Length: $len");
	fpassthru("install.exe");
	print($WEBMASTERCODE);
Leonardo SE&O
-- 
".signature": bad command or file name

 del file .EXE faranno si' che quei "tot" bytes siano ignorati.
Si puo' fare sul serio? Dimmi se ho capito: io prendo il mio eseguibile, ci
attacco tot byte e posso usarli liberamente come se costituissero un file
temporaneo, sempre che abbia i permessi di scrittura?
Mah... devo assolutamente provare!
-- 
 Ciao, Bianco.
 Reply to luca.bianco (at) 
tiscalinet.it

temporaneo, sempre che abbia i permessi di scrittura?
In LETTURA. Puoi anche salvare nell'eseguibile una stringa del tipo:
	INGIRUMIMUSNOCTEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX(END)
e poi fare qualcosa del tipo:
	string = strrev("ETCONSUMIMURIGNI");
	fp = fopen(argv[0], "r");
	pos = file_search(fp, string);
	pos += strlen(string);
	fread(buffer, sizeof(buffer), 1, fp);
	fclose(fp);
...per inviarlo via Web, si puo' usare un PHP che include DUE files
(la prima meta' dell'eseguibile, fino ad INGIRUMIMUSNOCTE compreso,
e la seconda, da (END) in poi), e in mezzo stampa 20 caratteri, che
sono la "stringa segreta".
Dato che NON si sta scrivendo su un file, il sistema e' economico e
puo' funzionare qualsiasi sia il numero di client connessi.
Leonardo


 In LETTURA. 
[esempio]
Scusa, non sono stato chiaro io: pensavo ad un ambito diverso, una
qualsiasi applicazione, niente a che vedere con il Web. Nel particolare, un
programmino scritto in C (linguaggio che uso di solito) che usa la parte
finale dell'eseguibile (i byte attaccati) come se fossero un buffer per
lettura/scrittura.


lettura/scrittura.
In lettura/scrittura, non so se si possa fare. I files .EXE Windows li
apre in write lock mode - non so perche'. Prova. Se non ti da' errore,
allora puoi farlo senza problemi :-)


lettura/scrittura.
Solo in lettura, come ha detto Leonardo; per aggirare il problema, puoi
allocare della memoria con VirtualAlloc() con permessi di
lettura/scrittura/esecuzione, copiarci dentro i byte attaccati in fondo
al tuo eseguibile, e lavorare su quel buffer.
-- 
Saluti,
    Mardy

 al tuo eseguibile, e lavorare su quel buffer.
Si', e' una soluzione, ma la cosa che mi "intrippava" era avere un buffer
attaccato all'eseguibile (l'equivalente di un array statico)... non
chiedermi perche', pero' mi piace ;-)


chiedermi perche', pero' mi piace ;-)
Può essere una cosa utile, soprattutto se vuoi rendere difficile il
debugging (o il cracking) del tuo programma. :-)
-- 
Saluti,
    Mardy