1. Usando Grub (Grand Unified Bootloader) - Il metodo più comune
Questo metodo prevede l'interruzione del processo di avvio e l'avvio in una modalità utente singolo in cui è possibile reimpostare la password.
Passaggi:
1. Riavvia il sistema: Riavvia la macchina Linux.
2. Interrompi il processo di avvio: Mentre il sistema si avvia, guarda il menu Grub. In genere vedrai un elenco di sistemi operativi. Potrebbe essere necessario premere un tasto (come `Esc`,` Shift`, `E` o` Enter `) o tenerlo giù per visualizzare il menu. La chiave varia a seconda del sistema e della configurazione GRUB. Se non vedi il menu Grub, potrebbe essere nascosto. Tenere premuto "Shift` durante l'avvio lo rivela spesso.
3. Modifica la voce Grub: Una volta visualizzato il menu Grub, utilizzare i tasti freccia per evidenziare la voce che si desidera avviare (di solito l'opzione Linux predefinita). Premere `E` per modificare la voce selezionata. Ciò aprirà un editor di testo all'interno dell'ambiente Grub.
4. Trova la linea del kernel: Cerca una linea che inizia con `Linux` o` Linux16`. Questa riga contiene parametri passati al kernel durante l'avvio.
5. APPEND `init =/bin/bash` o` rd.break appling =0` (o `systemd.unit =emergency.target`) sulla linea del kernel:
* `init =/bin/bash`: Questo è il metodo più vecchio e più comune. Dice al kernel di avviare `/bin/bash` come processo iniziale anziché il normale sistema INIT (come SystemD o Sysvinit). Questo ti dà effettivamente una shell di radice. Dopo aver finito di modificare la password, dovrai rimontare il filesystem root come lettura-scrittura prima di poter modificare la password.
* `Rd.Break Eppling =0` (CentOS/RHEL/Fedora con Selinux): Questo è generalmente il metodo * preferito * per i sistemi basati su Red Hat (CentOS, RHEL, Fedora) che hanno abilitato Selinux. `Rd.Break` dice agli INITRAMF di interrompere il processo di avvio prima di passare al file di file root reale, dandoti l'opportunità di apportare modifiche. `Eppling =0` mette Selinux in modalità permissiva, impedendo a Selinux di interferire con il reimpostazione della password.
* `SystemD.Unit =Emergency.Target` (SystemD Systems): Ciò causerà l'avvio del sistema in modalità di emergenza
Esempio (usando `init =/bin/bash`):
`` `
Linux /boot/vmlinuz-5.15.0-72-root generico =/dev/mapper/vgubuntu-root ro silenzioso splash $ vt_handoff
`` `
Modificalo a:
`` `
Linux /boot/vmlinuz-5.15.0-72-root generico =/dev/mapper/vgubuntu-root ro silenzioso splash $ vt_handoff init =/bin/bash
`` `
Esempio (usando `rd.break impling =0`):
`` `
Linux /boot/vmlinuz-5.15.0-72-root generico =/dev/mapper/vgubuntu-root ro silenzioso splash $ vt_handoff
`` `
Modificalo a:
`` `
Linux /boot/vmlinuz-5.15.0-72-GENERICO ROOT =/DEV/MAPPER/VGUBUNTU-ROOT RO QUIT FLUSP $ VT_HANDOFF RD.BREAK EFFUCCING =
`` `
Posizionare l'opzione all'estremità * della linea dopo qualsiasi altra opzione esistente, separata da uno spazio.
6. Avvia la voce modificata: Premere `ctrl+x` o` f10` per avviarsi con la voce Grub modificata.
7. Rimuovere il filesystem root (se si utilizza `init =/bin/bash`):
* Con `init =/bin/bash`, il filesystem di root è montato di sola lettura. È necessario rimonderlo come lettura-scrittura prima di poter modificare la password. Esegui il seguente comando:
`` `Bash
Mount -o Remount, RW /
`` `
8. Modifica la password di root: Usa il comando `passwd`:
`` `Bash
passwd
`` `
Immettere la nuova password quando richiesto. Ti verrà chiesto di inserirlo di nuovo per conferma.
9. Se si utilizza `rd.break imponcing =0` (centOS/RHEL/FEDORA con Selinux):
* Il file system potrebbe non essere nella directory principale. Avrai prima bisogno di Chroot alla radice.
`` `Bash
Chroot /Sysroot
`` `
* Ora, cambia la password di root:
`` `Bash
passwd
`` `
10. REIBLABILE SELinux (se si utilizza `Rd.Break Epplcing =0`):
* Dopo aver modificato la password, è necessario rielaborare il filesystem.
`` `Bash
Touch /.AutoRelabel
Uscita
Uscita
`` `
Il sistema riavvie ed eseguirà il processo di rilascio. Questo può richiedere del tempo. Non interrompere il processo.
11. Riavvia: Digita `Exec /Sbin /init` (o` riavvia -f` se il primo comando non funziona, ma questo è meno pulito e può potenzialmente portare a incoerenze del filesystem). Se si utilizza `init =/bin/bash`, la digitazione` exit` potrebbe funzionare in alcuni casi, ma `Exec/sbin/init` è generalmente più affidabile.
Considerazioni importanti per il metodo Grub:
* Protezione password Grub: Se il bootloader GRUB è protetto da password, questo metodo non funzionerà direttamente. Dovrai prima conoscere la password di Grub.
* Crittografia (Luks): Se il tuo filesystem root è crittografato (ad esempio, utilizzando Luks), dovrai sbloccare la partizione crittografata * prima di * puoi accedervi e modificare la password. Ciò comporta generalmente l'ingresso della passphrase di decrittografia allo stivale. I passaggi sopra si applicano quindi dopo aver sbloccato il volume crittografato.
* Selinux (centos/Rhel/Fedora): Sui sistemi con Selinux abilitato, è * cruciale * riempire il filesystem dopo aver modificato la password, come mostrato nelle istruzioni `Rd.Break`. Se non lo fai, potresti riscontrare gravi problemi, inclusa l'incapacità di accedere anche con la password corretta.
2. Utilizzando un CD/USB in diretta
Questo metodo prevede l'avvio da un ambiente LIVE Linux (ad esempio, Ubuntu Live CD, Fedora Live USB) e il montaggio della partizione di root per modificare la password.
Passaggi:
1. Avvio da Media live: Avvia il tuo computer da un CD Linux Live o da unità USB.
2. Identifica la partizione di root: Apri un terminale nell'ambiente live. Utilizzare il comando `lsblk` o` fdisk -l` per identificare la partizione corretta che contiene il filesystem root dell'installazione di Linux (`/`). Cerca la partizione che ha il punto di montaggio `Root` assegnato.
3. Montare la partizione radicale: Crea un punto di montaggio (una directory) e montare la partizione radicale lì. Sostituire `/dev/sdax` con il dispositivo effettivo e la partizione identificata nel passaggio precedente.
`` `Bash
sudo mkdir /mnt /myroot
sudo mount /dev /sdax /mnt /myroot
`` `
Se hai una partizione `/boot 'separata, potresti anche dover montare:
`` `Bash
sudo monte/dev/sday/mnt/myroot/boot # sostituire/dev/sday con la partizione di avvio
`` `
4. Montare i filesystem speciali: Montare i filesistemi `proc`,` sys` e `dev` dall'ambiente live nella directory radicale montata. Ciò è necessario per "Chroot` funzionare correttamente.
`` `Bash
sudo monte -o bind /proc /mnt /myroot /proc
sudo monte -o bind /sys /mnt /myroot /sys
sudo monte -o bind /dev /mnt /myroot /dev
sudo monte -o bind/dev/pts/mnt/myroot/dev/pts
`` `
5. Chroot nel filesystem root: Utilizzare il comando `chroot` per modificare la directory principale nella partizione montata. Questo rende la partizione montata la "radice" per i comandi successivi.
`` `Bash
sudo chroot /mnt /myroot
`` `
6. Modifica la password di root: Usa il comando `passwd`:
`` `Bash
passwd
`` `
Immettere la nuova password quando richiesto.
7. ESCI CHROOT E SNOUNT:
`` `Bash
Esci # Esci dall'ambiente Chroot
sudo umount/mnt/myroot/dev/pts
sudo umount/mnt/myroot/dev
sudo umount/mnt/myroot/sys
sudo umount/mnt/myroot/proc
sudo umount /mnt /myroot /boot # se hai montato /avvio
sudo umount /mnt /myroot
`` `
8. Riavvia: Riavvia il computer e avvia dal normale disco rigido.
Considerazioni importanti per il metodo CD/USB in diretta:
* Crittografia (Luks): Se il tuo filesystem root è crittografato, dovrai sbloccarlo dall'ambiente live * prima di * puoi montare. Utilizzare `CryptSetUp Luksopen/Dev/Sdax MyRoot` (sostituire`/dev/sdax` con la partizione crittografata) e immettere la passphrase. Quindi montare `/dev/mapper/myroot` invece di`/dev/sdax`.
* LVM (Gestione del volume logico): Se il tuo filesystem root si trova su un volume logico LVM, potrebbe essere necessario attivare prima il gruppo di volume:`sudo vgchange -ay`. Quindi, identifica il volume logico e montalo.
* Avvio sicuro: Se l'avvio sicuro è abilitato nelle impostazioni UEFI, potrebbe essere necessario disabilitarlo o configurarlo per consentire l'avvio da supporti esterni.
3. Utilizzando il parametro `singolo` kernel (meno comune, potrebbe non funzionare su tutti i sistemi)
Questo metodo è simile al metodo Grub ma utilizza un parametro del kernel diverso. Potrebbe non essere affidabile come il metodo `init =/bin/bash` sui sistemi moderni.
Passaggi:
1. Riavvia e interrompere il processo di avvio: Come nel metodo Grub (passaggi 1 e 2).
2. Modifica la voce Grub: Come nel metodo Grub (passaggi 3 e 4).
3. Append `single` o` 1` alla linea del kernel: Aggiungi `singolo` o` 1` alla fine della linea `Linux` o` Linux16`.
4. Avvia la voce modificata: Premere `ctrl+x` o` f10` per l'avvio.
5. Modifica la password di root: Il sistema dovrebbe avviarsi in modalità utente singolo, dando una shell di radice. Usa il comando `passwd`:
`` `Bash
passwd
`` `
6. Riavvia: Tipo `riavvio '.
Perché questi metodi funzionano (spiegazione):
* Grub e Modalità utente singolo: Grub è il bootloader che carica il kernel Linux. Interrompendo il processo di avvio e modificando i parametri del kernel, possiamo istruire il kernel ad avviare in una modalità speciale (modalità utente singolo) in cui abbiamo accesso diretto all'account root * senza * richiedere una password. Questo perché la modalità utente singolo è progettata per la manutenzione e il recupero del sistema. Il parametro `init =/bin/bash` sovrascrive il processo di inizializzazione standard, dando direttamente una shell di root.
* CD/USB Live e Chroot: Un CD/USB live fornisce un ambiente Linux separato e funzionante. Montando la partizione di root del sistema installato e utilizzando `chroot`, sei essenzialmente" commuta "il filesystem di root alla directory radice del sistema installato. Ciò ti consente di eseguire comandi (come `passwd`) come se avessi effettuato l'accesso al sistema installato, anche se in realtà li stai eseguendo dall'ambiente live.
Considerazioni sulla sicurezza:
* Accesso fisico: Questi metodi richiedono accesso fisico alla macchina. Se qualcuno ha accesso fisico, può potenzialmente compromettere il sistema, indipendentemente dalla password.
* Grub Password: Prendi in considerazione l'impostazione di una password per Grub per evitare la modifica non autorizzata delle opzioni di avvio.
* Crittografia: La crittografia del filesystem root (ad esempio, con Luks) aggiunge un forte livello di sicurezza, poiché un utente malintenzionato avrebbe bisogno della passphrase di decrittografia per accedere ai dati, anche con accesso fisico.
* Avvio sicuro: L'avvio sicuro aiuta a impedire la corsa di bootloader non autorizzati, fornendo un altro livello di sicurezza.
Scegliere il metodo giusto:
* Grub: Il metodo Grub è generalmente il più semplice e veloce se si dispone di accesso diretto al sistema e si può interrompere il processo di avvio. Tuttavia, è vulnerabile se Grub è protetto da password o se il filesystem è crittografato senza conoscere la passphrase. È anche il metodo che è più probabile che sia influenzato da Selinux.
* CD/USB live: Il metodo CD/USB live è più versatile e può essere utilizzato anche se GRUB è protetto da password. Richiede un po 'più di configurazione ma fornisce un ambiente più controllato. È particolarmente utile se è necessario sbloccare prima un filesystem crittografato.
Note importanti:
* Backup: Prima di tentare uno di questi metodi, è * altamente raccomandato * di avere un recente backup dei tuoi dati importanti. Mentre queste procedure sono generalmente sicure, c'è sempre il rischio di perdita di dati se qualcosa va storto.
* Care e accuratezza: Controllare due comandi e nomi delle partizioni prima di eseguirli. Gli errori tipografici possono portare a gravi problemi.
* Selinux: Sii particolarmente attento con i sistemi abilitati per Selinux (CentOS, RHEL, Fedora). Segui precisamente i passaggi di rilascio.
* Modalità di ripristino: Alcune distribuzioni Linux forniscono un'opzione "Modalità di ripristino" nel menu Grub. Questa modalità spesso si avvia in una shell di root, semplificando il processo di reimpostazione della password. Tuttavia, potrebbe ancora richiedere il rimorchio del filesystem come lettura-scrittura.
* Cloud Istances: Sulle macchine virtuali cloud (ad es. AWS EC2, VM azure, motore di calcolo di Google Cloud), le procedure di recupero delle password possono variare. I fornitori di cloud in genere offrono meccanismi per ripristinare la password di root tramite le loro console Web o API. Consultare la documentazione per il tuo provider cloud specifico.
Comprendendo questi metodi e le loro considerazioni, è possibile recuperare con sicurezza una password di root persa sul sistema Linux. Ricorda di dare la priorità alla sicurezza e di eseguire sempre il backup dei dati.
Domanda © www.354353.com