Newsgroup: it.comp.retrocomputing
Titolo: "raw-disk" mini HOWTO

/tmp/rootsda.txt &
tail -f /tmp/rootsda.txt
(attenzione la prima riga, non sbagliare nulla! - e cambia /dev/sda nel
device del tuo disco se non e` /dev/sda).
Ci mettera` un bel po', probabilmente, e ti dara` dei
warnings che non riesce a leggere la partition table. Non fa niente.
Dovresti vedere almeno una riga del tipo
[numero di byte offset]:root:[password crittata]:[altre cose]
dove [password crittata] e` una stringa ascii di 13 caratteri.
ora prendi la tua password crittata dall'/etc/passwd o /etc/shadow
del tuo linux, sempre di 13 caratteri, e trasformala in esadecimale.
A questo proposito, ti puo` venire utile il seguente programmino:
----------------------------------
/*********************
** Name: asc2hex.c
** Author: Leo Liberti
** Purpose: Convert ascii to hex (where the f**k is the standard
**              unix utility to do this??)
** Compile with: cc -o asc2hex asc2hex.c
*********************/
#include <stdio.h>
#include <string.h>
int main(int argc, char** argv) {
        int i, l;
        if (argc < 2) {
                printf("asc2hex: error: need a string to convert\n");
                return 1;
        }
        l = strlen(argv[1]);
        for(i = 0; i < l; i++)
                printf("%x ", argv[1][i]);
        printf("\n");
        return 0;
}
----------------------------------
Esempio:
zeus:~ # asc2hex "Ojb6rJ6z68JT;"
4f 6a 62 36 72 4a 36 7a 36 38 4a 54 3b
Qui ho preso una stringa inventata, "Ojb6rJ6z68JT;", tu ci metti la
stringa
che data in output dal seguente comando:
cat /etc/passwd | grep root: | cut -f 2 -d :
oppure
cat /etc/shadow | grep root: | cut -f 2 -d :
se hai installato le shadow passwords.
Adesso lancia lde (linux disk editor) in questo modo
lde /dev/sda
(ovviamente /dev/sda puo` cambiare, come detto sopra). Premi la freccia
in
giu` finche' il blocco 00000 non diventa 00001 (sulla riga in alto, un
po' a
destra). Vedi a che byte esattamente questo succede: nel mio caso un
blocco
per lde erano 1024 bytes, mentre il blocco sul disco era di 512 bytes.
Tieni
conto che gli offset sulla sinistra sono esadecimali, quindi se l'ultimo
byte a essere "blocco 0" e` 0x3FF e il primo a essere "blocco 1" e`
0x400
vuol dire che il blocco e` di 1024 bytes.  Ad ogni modo, supponiamo che
lde
usi i blocchi da 1024 bytes. Esci da lde premendo "q".
Ora calcola a quale blocco devi andare a cambiare la password con lde.
Prima di tutto compila il seguente programmino:
--------------------------------------------
/*********************
** Name: dec2hex.c
** Author: Leo Liberti
** Purpose: Convert decimal to hex (where the f**k is the standard
**              unix utility to do this??)
** Compile with cc -o dec2hex dec2hex.c
*********************/
#include <stdio.h>
int main(int argc, char** argv) {
        unsigned long int a;
        if (argc < 2) {
                printf("dec2hex: error: need an integer to convert\n");
                return 1;
        }
        sscanf(argv[1], "%ld", &a);
        printf("%x\n", a);
        return 0;
}
-------------------------------------------
e mettilo in un path, poi torniamo al file /tmp/rootsda.txt che hai
creato
prima: questo file contiene tutti i byte offset, dall'inizio del disco,
che
contengono la stringa "root:" ma non la stringa "root:x:" (quindi anche
se
sul disco dell'Apollo ci sono le shadow passwords tu le ignori). Per
renderlo un po' piu` leggibile fai:
BLOCKSIZE=1024 ; \
for i in `cat /tmp/rootsda.txt` ; do \
        echo -n `dec2hex $i` ; \
        echo -n " " ; \
        echo $i/$BLOCKSIZE | bc ; \
done | cat -b > /tmp/tochange.txt
Ora il file /tmp/tochange.txt dovrebbe essere una cosa tipo
     1  58603 353
     2  802c2 512
     3  80419 513
     4  80429 513
     5  8043c 513
     6  8044c 513
     7  8045c 513
     8  8046d 513
     ....
cioe`: il primo cambio deve essere effettuato al byte offset
(esadecimale)
0x58603, che si trova al blocco (di misura 1024 bytes) 353, eccetera.
Ora lancia
lde /dev/sda
e premi "#", poi inserisci il numero di blocco del primo cambio
specificato
in /tmp/tochange.txt (nell'esempio sopra, 353). Ora con le frecce vai
all'offset corrispondente (nell'esempio sopra, 58603), e trovi "root:".
Devi
vedere cosa viene dopo. Se i tredici caratteri che seguono sono
"evidentemente" una password criptata (e qui bisogna andare a intuito,
ma ti
assicuro non e` difficile), allora sostituisci questi tredici bytes con
i
tredici bytes ottenuti facendo "asc2hex" sulla tua password crittata
presa
dalla tua macchina linux (di nuovo, puoi ottenerla con
asc2hex `cat /etc/passwd | grep root: | cut -f 2 -d :`
o
asc2hex `cat /etc/shadow | grep root: | cut -f 2 -d :`
se hai le shadow passwords).
Per sostituire questi bytes, prima fai "F", poi "W" (set status flag
write
to ON), poi "Q", poi "e" per fare edit. Ora puoi editare i bytes. Quando
hai
finito questo blocco, fai C-w (Control + w) per scriverlo al disco, e
passa
al cambio successivo.
Se invece i tredici caratteri che seguono "root:" non sono una password
crittata, passa subito al cambio successivo.
NOTA: purtroppo "grep -a" si perde qualche carattere, quindi i
byte-offset
del file tochange.txt potrebbero essere minori dell'effettivo
byte-offset. Se non trovi "root:" al byte offset indicato nel
tochange.txt
prova ad andare un po' avanti. Se l'offset e` molto alto l'errore si
accumula e potresti dover andare avanti un bel po'. Puoi provare, per
evitare questo inconveniente, a togliere "-a" dal grep iniziale; ma
certe
distribuzioni di grep si limitano a dire "Binary file matches" su file
non
di testo, senza riportare l'effettivo valore del byte offset. Sulla
debian
questo non succede, quindi con debian puoi fare "grep -b [eccetera]" e
gli
offset dovrebbero risultare giusti. Con la SuSE invece l'inconveniente
c'e`.
Leo Liberti (
llib...@hotmail.com
)

 4. ripetere dal punto 2. fino alla fine del disco.
non c'e' bisogno di fare cio'
basta cambiare la stringa, ad esempio  
"root:HK1esvTX./l2M:0:1::/:";
in 
"root::0:1:Rooooooooooot:/:";
aumentando il campo "commento" :)
a tal proposito per un problema simile avuto con un disco scsi di un
sistema NCR tower650 il nostro caro amico Martin ha scritto questo
programmino che cambia la pw sulla immagine del disco precedentemente
creata con "dd" sotto linux ... cosi' :
dd if=/dev/scdx of=immagine.iso
dove scdx e' il device scsi del disco in questione
ecco il programmino :
/* Azzera la password di root sul disco del NCR
 *
 * Martin, FreakNet, Catania, febbraio 2000
 */
#include <stdio.h>
/* Per open() */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
static char NCR_DEVICE[] = "/dev/sdc";
/* offset della POSIZIONE in cui si trova la stringa root da cambiare
   ... posizione che va cercata sulla immagine
*/
#define NCR_OFFSET 66041856L
static char old[] = "root:HK1esvTX./l2M:0:1::/:"; /* stringa da cambiare */
static char new[] = "root::0:1:Rooooooooooot:/:";
#define LEN 26
static char buf[LEN];
static void
byteswap(char *s, int n)
{
	register int i;
	register char tmp;
	register char *cp;
/* questo ciclo for fa' lo swap dei bytes poiche' il disco NCR
   era registrato con i byte tra loro scambiati. si puo' ovviare
   a questo facendo l'immagine con dd usando l'opzione "swab" 
   e ricordandosi poi di ributtarla su' colla stessa opzione :)
   asbesto 23-6-00
*/
	for (i=0, cp=s; i<n; i+=2, cp+=2) {
		tmp = cp[0];
		cp[0] = cp[1];
		cp[1] = tmp;
	}
}
main()
{
	int fd;
	byteswap(old, LEN);
	byteswap(new, LEN);
	fd = open(NCR_DEVICE, O_RDWR);
	if (fd < 0) {
		perror(NCR_DEVICE);
		exit(1);
	}
	if (lseek(fd, NCR_OFFSET, 0) != NCR_OFFSET) {
		perror("lseek(1)");
		exit(0);
	}
	if (read(fd, buf, LEN) != LEN) {
		perror("read");
		exit(1);
	}
	if (memcmp(buf, old, LEN) != 0) {
		fputs("memcmp\n", stderr);
		fflush(stderr);
		write(1, "[", 1);
		write(1, old, LEN);
		write(1, "]\n[", 3);
		write(1, buf, LEN);
		write(1, "]\n", 2);
		exit(1);
	}
	if (lseek(fd, NCR_OFFSET, 0) != NCR_OFFSET) {
		perror("lseek(2)");
		exit(0);
	}
	if (write(fd, new, LEN) != LEN) {
		perror("write");
		exit(1);
	}
	if (close(fd) != 0) {
		perror("close");
		exit(1);
	}
	exit(0);
}
ps si declinano responsabilita' sul corretto funzionamento di
tutto questo :)
-- 
MI DISGUSTA chi manda messaggi MIME, HTML o con attach. ICQ 36294456, PGP
asb...@kyuzz.org
, mex No (C) for non commercial use, 
www.kyuzz.org/asbesto

creata con "dd" sotto linux ... cosi' :
Non e' che il vostro amico Martin avrebbe qualcosa del genere per
winnt 3.5??
tanx
Ciao
Maurizio
~-_Non ho un museo, solo una sala giochi..._-~
Most wanted:
- "The Goonies" - Konami - msx1
- "Metal Gear Solid" - Konami - msx2
- Nec PC-Engine

 "root::0:1:Rooooooooooot:/:";
Non penso che una delle due strategia sia
piu` semplice dell'altra. Si tratta comunque
di sostituire una stringa con un'altra.
Comunque grazie del programmino, molto
interessante.
Leo

 winnt 3.5??
Scusa, non c'e` il supporto sperimentale per NTFS in read/write su
linux? So per certo che c'e` il supporto read-only.
Perche' non monti il disco su un'altra macchina NT? Cosi`
sicuramente c'hai read-write. Poi sta a te cercare la stringa da
cambiare, non so nulla di come NT3.5 immagazzina la password
di root.
Leo

di root.
A questa non ci avevo pensato! Si, si, mi sa che lo monto sul server
in ufficio quello che ha nt4... se mi beccano mi uccidono!
Ciao
Maurizio
~-_Non ho un museo, solo una sala giochi..._-~
http://utenti.tripod.it/altermxm/
Most wanted:
- "The Goonies" - Konami - msx1
- "Metal Gear Solid" - Konami - msx2
- Nec PC-Engine
- Panasonic MSX TurboR

 in ufficio quello che ha nt4... se mi beccano mi uccidono!
Beh, ti uccidono in ogni caso, o tua mamma o i tuoi datori
di lavoro. Che hai da perdere? ;-)
Leo