Patch di un binario con dd

Ho letto questa citazione (sotto) più volte, di recente qui , e sono continuamente perplesso su come ddpuò essere usato per correggere qualsiasi cosa per non parlare di un compilatore:

Il sistema Unix che ho usato a scuola, 30 anni fa, era molto limitato nella RAM e nello spazio su disco. Soprattutto, il /usr/tmpfile system era molto piccolo, il che causava problemi quando qualcuno cercava di compilare un programma di grandi dimensioni. Ovviamente, gli studenti non dovevano scrivere "grandi programmi" comunque; i programmi di grandi dimensioni erano in genere codici sorgente copiati da "da qualche parte". Molti di noi copiato /usr/bin/cca /home/<myname>/cc, e utilizzato ddper patchare il binario da utilizzare /tmpal posto di/usr/tmp , che era più grande. Naturalmente, questo ha solo aggravato il problema: lo spazio su disco occupato da queste copie contava in quei giorni, e ora si /tmpriempiva regolarmente, impedendo ad altri utenti di modificare anche i propri file. Dopo aver scoperto cosa è successo, gli amministratori di sistema hanno fatto unchmod go-r /bin/* /usr/bin/* che "risolto" il problema e cancellato tutte le nostre copie del compilatore C.

(Enfasi mia)

La ddpagina man non dice nulla sul patching e non credo che potrebbe essere riutilizzato per farlo comunque.

I binari potrebbero davvero essere patchati dd? C'è qualche significato storico in questo?

Proviamolo. Ecco un banale programma C:

#include <stdio.h>
int main(int argc, char **argv) {
    puts("/usr/tmp");
}

Lo costruiremo in test:

$ cc -o test test.c

Se lo eseguiamo, stampa "/ usr / tmp".

Scopriamo dove " /usr/tmp" è nel binario:

$ strings -t d test | grep /usr/tmp
1460 /usr/tmp

-t d stampa l'offset in decimale nel file di ogni stringa trovata.

Ora facciamo un file temporaneo con solo " /tmp\0" al suo interno:

$ printf "/tmp\x00" > tmp

Quindi ora abbiamo il binario, sappiamo dove si trova la stringa che vogliamo cambiare e abbiamo un file con la stringa di sostituzione al suo interno.

Ora possiamo usare dd:

$ dd if=tmp of=test obs=1 seek=1460 conv=notrunc

Questo legge i dati dal tmp(nostro " /tmp\0" file), scrivendoli nel nostro binario, usando una dimensione del blocco di output di 1 byte, saltando all'offset che abbiamo trovato prima prima che scriva qualcosa e non troncando esplicitamente il file quando è fatto.

Possiamo eseguire l'eseguibile con patch:

$ ./test
/tmp

La stringa letterale che il programma stampa è stata modificata, quindi ora contiene " /tmp\0tmp\0", ma le funzioni di stringa si interrompono non appena vedono il primo byte null. Questo patching consente solo di rendere la stringa più corta o della stessa lunghezza e non più lunga, ma è adeguata per questi scopi.

Quindi non solo possiamo correggere le cose usando dd, ma l'abbiamo appena fatto.

Dipende da cosa intendi per "patch the binary".

Cambio binari a ddvolte. Ovviamente non esiste una tale funzionalità dd, ma può aprire file e leggere e scrivere cose con offset specifici, quindi se sai cosa scrivere dove, voilà c'è la tua patch.

Ad esempio avevo questo binario che conteneva alcuni dati PNG. Usa binwalkper trovare l'offset, ddper estrarlo (di solito binwalk estrae anche le cose ma la mia copia era difettosa), modificalo con gimp, assicurati che il file modificato abbia le stesse dimensioni o più piccolo di quello originale (cambiare offset non è qualcosa che puoi fare facilmente ), quindi utilizzare ddper rimettere in posizione l'immagine modificata.

$ binwalk thebinary
[…]
4194643    0x400153     PNG image, 800 x 160, 8-bit/color RGB, non-interlaced
[…]
$ dd if=nickel bs=1 skip=4194641 count=2 conv=swab | od -i
21869 # file size in this case - depends on the binary format
$ dd if=thebinary bs=1 skip=4194643 count=21869 of=theimage.png
$ gimp theimage.png
$ pngcrush myimage.png myimage.crush.png
# make sure myimage.crush.png is smaller than the original
$ dd if=myimage.crush.png of=thebinary bs=1 seek=4194643 conv=notrunc

A volte desidero anche sostituire le stringhe nei file binari (come percorso o nomi delle variabili). Anche se questo potrebbe essere fatto anche usando dd, è più semplice farlo usando sed. Devi solo assicurarti che la stringa che sostituisci abbia la stessa lunghezza della stringa originale in modo da non finire per cambiare gli offset.

sed -e s@/the/old/save/path@/the/new/save/path@ -i thebinary

o per prendere l'esempio di @ MichaelHomer con un 0 byte aggiunto in:

sed -e 's@/usr/tmp@/tmp\x00tmp@' -i test

Ovviamente devi verificare se effettivamente funziona dopo.