Newsgroup: it.comp.programmare.win32
Titolo: Steganografia : progetto per scuola.

<PREMESSA.>
La steganografia è l'arte di nascondere un messaggio all'interno di un
"altro messaggio" (o contenitore) in modo tale che se venisse intercettato,
o se qualcuno monitorasse lo scambio di informazioni (nel senso più ampio
del termine), tale messaggio passerebbe inosservato.
Esiste una steganografia "linguistica" che usa quindi algoritmi tali da non
nascondere un testo all'interno di un altro testo o anche di "costruire" un
testo di copertura che in realtà (conoscendo l'algoritmo steganografico)
nasconde un altro testo.
Grazie agli strumenti informatici è possibile utilizzare dati non
indispensabili all'interno di file grafici (bit meno significativi) e dei
file audio (con algoritmi in grado di limitare al minimo il decadimento
audio) per memorizzare qualsiasi tipo di file.
Io vorrei creare un semplice tool in grado di memorizzare un qualsiasi file
all'interno di un file EXE (non mi pare che esista e se esiste
pazienza....ehehehe).
Presupposto necessario è evitare che il file steganografato sia possibile
oggetto di scansioni automatiche (tool in grado di controllare
automaticamente una serie di file per verificare la probabilità/certezza che
contengano dati nascosti).
<FINE PREMESSA.>
<IPOTESI>
Alla luce di quanto detto ritengo sia necessario (aiutatemi voi però....
:))) :
1) copiare in un altro file di supporto l'header del file EXE
2) dopo averlo calcolato inserire la nuova dimensione del file
(eseguib+inglobato)
3) inserire come prima istruzione un JMP alla riga successiva del mio file
"inglobato"
   che evidentemente conterrà la prima riga del codice eseguibile.
4) copiare le restanti istruzioni dell'eseguibile.
5) Modificare la tabella dei puntatori dell'eseguibile (? devo?)
6) cancellare il vecchio eseguibile e rinominare il file di appoggio.
<FINE IPOTESI>
<CONSIDERAZIONI>
ritengo che in tal modo si eviti la scansione di semplici tool poichè
sarebbe necessario disassemblare l'exe per risalire al fatto che il JMP in
realtà non è "necessario" al programma, ma deve solo saltare i miei dati.
Probabilmente il sistema è lungi dall'essere sicuro, ma per scuola basta e
avanza!
<FINE CONSIDERAZIONI>
<DO>
Per favore aiutatemi....
<WHILE 1>
grazie per l'aiuto che vorrete darmi.... (e che mi state dando) :)
ps: every language welcome!

 5) Modificare la tabella dei puntatori dell'eseguibile (? devo?)
solo se cambi le dimensioni di un segmento (se il padding non basta)
-- 
  < 
http://www.reactos.com/
 >  Open source clone of Windows NT. Current
      Don't stand, REACT!      version 0.2.1. C, C++ and ASM developers
                               and beta testers are welcome!

 solo se cambi le dimensioni di un segmento (se il padding non basta)
Esiste un altra tecnica che permette di steganografare
dati in qualsiasi programma per processori con *opcode ridondanti*.
Per questioni di semplicita di implementazione parecchi processori
hanno istruzioni che possono essere codificate in 2 o piu modi diversi
occupando lo stesso spazio.
Nel caso delle cpu x86 e' una vera pacchia, ad esempio:
ADD registro1, registro2
puo essere codificata con opcode
0000 000w 11 reg1 reg2
oppure come
0000 001w 11 reg2 reg1
(dove reg1 e reg2 sono i selettori di registro e w e' il selettore
  di formato da byte a word/dword)
Una cosa simile vale per le istruzioni x86
ADC,ADD,AND,CMP,MOV,OR,SBB,SUB e XOR
che operano tra due registri generali (quelli "interi")
con la stessa dimensione (byte, word , dword o qword).
Per steganografare qualcosa dentro un eseguibile basta
quindi prendere l'eseguibile generato dal compilatore
e scandire le sezioni .text che contengono codice.
Ogni volta che si incontra una istruzione "con due formati equivalenti
che occupano lo stesse spazio"
OPCODEX reg1,reg2
si guarda quanto valgono i *selettori* reg1 e reg2
(sono i "codici di registro" dentro l'istruzione, non sono i registri).
Se sono reg1 e reg2 UGUALI (codice reg1 uguale al codice di reg2)
SI VA AVANTI A DECODIFICARE LE ISTRUZIONI SUCCESSIVE.
Se invece i selettori sono diversi,possiamo "ricodificare" l'istruzione
in modo da "nasconderci dentro un bit".
Ora, l'opcode OPCODEX ha un "gemello" OPCODEY che opera con dati scambiati
ed allora in base al valore dei codici reg1 e reg2 possiamo applicare
la codifica seguente.
Se reg1<reg2 "riscriviamo":
    OPCODEX reg1,reg2 se si vuol codificare 0
    oppure
    OPCODEY reg2,reg1 se si vuole codificare 1
Se invece reg1>reg2 "riscriviamo":
    OPCODEY reg2,reg1 se si vuol codificare 0
    oppure
    OPCODEX reg1,reg2 se si vuole codificare 1
[ in altre parole reg1<reg2 steganografa un bit "0"
   mentre reg2>reg1 steganografa un bit "1" ]
Per estrarre le informazioni steganografate basta rileggere
il file "ricodificato" e segnare 0 oppure 1 se nelle istruzioni
"con possibile doppio formato gemello" si trova reg1<reg2 oppure reg1>reg2.
[l'opcode non conta per decidere il valore steganografato, in codifica
  lo abbiamo modificato solo per "inserire" reg1 e reg2 nel giusto ordine].
Con qualche altro trucchetto (pre-comprimere i dati ed aggiungere
una codifica non banale) si ottiene roba difficile da identificare
se non si sa in anticipo cosa cercare e come cercarlo.
Nota che la presenza di entrambi gli opcode "gemelli"
e' "sospetta", visto che di solito gli assemblatori o i compilatori
usano una sola delle due forme, ma crittografando i dati steganografati
anche uno che "sa" che c'e' qualcosa avra' enormi difficolta' a dimostrare
che quell'anomalia corrisponde a dati nascosti, la cosa si puo "coprire"
rilasciando in giro una utility che *migliora* la compressibilita dei
programmi eseguibili eseguendo la ricodifica con opcode "gemelli"
per aumentare la frequenza di sequenze ricorrenti nella sezione .text
(in questo modo si aumentera' la diffusione di .exe "anomali" che
  anche se non contengono dati steganografati aiuteranno a "coprire"
  quelli che lo sono veramente)
[questa cosa si chiama generazione preventiva di falsi bersagli :-) ].
Per realizzare il programma di codifica basta prendere i sorgenti
di un disassemblatore o di un emulatore di processore x86
ed "inserire" il codificatore/decodificatore al posto
della routine di "visualizzazione" (nel caso del disassemblatore)
o di quella di "esecuzione" (nel caso dell'emulatore).
L. Micheletto