E se avessi accidentalmente eseguito il comando "chmod -R" sulle directory di sistema (/, / etc, ...)

Ho corso per caso

sudo chmod 755 -R /

invece di

sudo chmod 755 -R ./

L'ho fermato dopo pochi secondi, ma ora ci sono alcuni problemi come

sudo: must be setuid root

Come posso ripristinare le autorizzazioni?

In breve: non è possibile reinstallare il sistema.

Voglio dire, le autorizzazioni Posix sono utilizzate e invocate pesantemente; c'è una moltitudine di posti nel filesystem in cui permessi errati rompono il sistema operativo (flag SUID) o, peggio ancora, lo rendono esposto in termini di sicurezza ( /etc/ssh/ssh_host_rsa_key) mentre sembra funzionare correttamente.

Quindi, un tale recupero è difficile da fare correttamente. Manca una cosa e tu la rovini. Hai già rovinato il tuo sudo chmodcomando (se è la tua amica piuttosto che te, potrebbe anche imparare qualche lezione su Linux) - e questo è un comando molto semplice. Un corretto recupero richiederebbe molti più comandi e molta più vigilanza. Anche se usi la sceneggiatura di qualcuno.

Quindi fidati di me, basta reinstallare. È una scommessa sicura e garantita per tenerti fuori dai guai.

Infine, alcuni suggerimenti rilevanti qui.

Primo: la reinstallazione sarà meno dolorosa se la/home prossima volta configurerai il tuo su una partizione separata . In realtà, saranno un gioco da ragazzi.

Secondo: prendi in considerazione la pazza scienza di Linux in una macchina virtuale come VirtualBox e fai le tue istantanee.

Terzo: chmod -R .funziona. Un punto da solo .è un nome di directory valido. Non è necessario aggiungere quella barra. Avresti potuto evitare il rischio catastrofico di saltare il punto completamente;
semplice chmod: missing operand after ‘755’VS un sistema in rovina.

Ho scritto e ho usato per diversi anni un paio di script di Ruby per rsyncpermessi e proprietà. Script get-filesystem-aclraccoglie tutte le informazioni attraversando ricorsivamente tutti i file e inserendole tutte nel file .acl. Lo script .acl-restoreleggerà .acle applicherà tutti gli chown"e chmod".

È possibile eseguire get-filesystem-aclun'installazione Ubuntu simile e quindi copiare il .aclfile nella casella danneggiata da chmod, inserire .acle .acl-restorein /, ed eseguire .acl-restore.

Dovrai avere root, quindi aggiusta il tuo sudocome suggeriva Marco Ceppi.

Posso generare e darti il .aclfile per il mio Ubuntu.

get-filesystem-acl

#!/usr/bin/ruby

RM   = "/bin/rm"
SORT = "/usr/bin/sort"
TMP  = "/tmp/get_acl_#{Time.now.to_i}_#{rand * 899 + 100}"

require 'find'

IGNORE = [".git"]

def numeric2human(m)
  return sprintf("%c%c%c%c%c%c%c%c%c",
            (m & 0400 == 0 ? ?- : ?r),
            (m & 0200 == 0 ? ?- : ?w),
            (m & 0100 == 0 ? (m & 04000 == 0 ? ?- : ?S) :
                             (m & 04000 == 0 ? ?x : ?s)),
            (m & 0040 == 0 ? ?- : ?r),
            (m & 0020 == 0 ? ?- : ?w),
            (m & 0010 == 0 ? (m & 02000 == 0 ? ?- : ?S) :
                             (m & 02000 == 0 ? ?x : ?s)),
            (m & 0004 == 0 ? ?- : ?r),
            (m & 0002 == 0 ? ?- : ?w),
            (m & 0001 == 0 ? (m & 01000 == 0 ? ?- : ?T) :
                             (m & 01000 == 0 ? ?x : ?t)))
end


File.open(TMP, "w") do |acl_file|

  # TODO: Instead of the current dir, find the .git dir, which could be
  #       the same or outside of the current dir
  Find.find(".") do |path|

    next if IGNORE.collect {|ig| !!(path[2..-1] =~ /\A#{ig}/)}.include? true
    next if File.symlink?(path)

    stat = File.lstat(path)
    group_id = stat.gid
    rules    = "#{type}#{numeric2human(stat.mode)}" 

    acl_file.puts "#{path} #{rules} #{owner_id} #{group_id}"
  end
end

`#{SORT} #{TMP} > .acl`
`#{RM}   #{TMP}`

.acl-restore

#!/usr/bin/ruby

# This script will only work with .acl_ids

# Restore from...
FROM  = ".acl"

MKDIR = "/bin/mkdir"
CHMOD = "/bin/chmod"
CHOWN = "/bin/chown"
known_content_missing = false


def numeric2human(m)
  return sprintf("%c%c%c%c%c%c%c%c%c",
            (m & 0400 == 0 ? ?- : ?r),
            (m & 0200 == 0 ? ?- : ?w),
            (m & 0100 == 0 ? (m & 04000 == 0 ? ?- : ?S) :
                             (m & 04000 == 0 ? ?x : ?s)),
            (m & 0040 == 0 ? ?- : ?r),
            (m & 0020 == 0 ? ?- : ?w),
            (m & 0010 == 0 ? (m & 02000 == 0 ? ?- : ?S) :
                             (m & 02000 == 0 ? ?x : ?s)),
            (m & 0004 == 0 ? ?- : ?r),
            (m & 0002 == 0 ? ?- : ?w),
            (m & 0001 == 0 ? (m & 01000 == 0 ? ?- : ?T) :
                             (m & 01000 == 0 ? ?x : ?t)))
end

def human2chmod(mode)
  raise unless mode =~ /([r-][w-][xtsTS-])([r-][w-][xtsTS-])([r-][w-][xtsTS-])/
  triple = [$1, $2, $3]
  u,g,o = triple.collect do |i|
    i.sub('s', 'sx').sub('t', 'tx').downcase.gsub('-', '')
  end

  return "u=#{u},g=#{g},o=#{o}" 
end



File.open(FROM).each do |acl|
  raise unless acl =~ /\A(([^ ]*? )+)([^ ]+) ([^ ]+) ([^ ]+)\Z/
  path, rules, owner_id, group_id = $1, $3, $4, $5
  path = path.strip
  owner_id = owner_id.to_i
  group_id = group_id.to_i

  if !File.exists?(path) and !File.symlink?(path)
    if rules =~ /\Ad/
      STDERR.puts "Restoring a missing directory: #{path}"
      STDERR.puts "Probably it was an empty directory. Git goes not track them."
      `#{MKDIR} -p '#{path}'` # Creating the any parents
    else
      known_content_missing = true
      STDERR.puts "ERROR: ACL is listed but the file is missing: #{path}"
      next
    end
  end

  s = File.lstat(path)
  t = s.ftype[0..0].sub('f', '-') # Single character for the file type
                                  # But a "-" istead of "f"

  # Actual, but not neccesarely Desired 
  actual_rules    = "#{t}#{numeric2human(s.mode)}"
  actual_owner_id = s.uid 
  actual_group_id = s.gid 

  unless [actual_rules, actual_owner_id, actual_group_id] ==
    [rules, owner_id, group_id]

    chmod_argument = human2chmod(rules)

    # Debug
    #p chmod_argument
    #p s.mode

    ## Verbose
    puts path
    puts "Wrong: #{[actual_rules, actual_owner_id, actual_group_id].inspect}"
    puts "Fixed: #{[rules, owner_id, group_id].inspect}"
    `#{CHMOD} #{chmod_argument} '#{path}'`

    #puts
  end

end

if known_content_missing
  STDERR.puts "-" * 80 
  STDERR.puts "Some files that are listed in #{FROM.inspect} are missing in " +
              "the current directory."
  STDERR.puts
  STDERR.puts "Is #{FROM.inspect} outdated?"
  STDERR.puts "(Try retrograding the current directory to an earlier version)"
  STDERR.puts
  STDERR.puts "Or is the current directory incomplete?"
  STDERR.puts "(Try to recover the current directory)"
  STDERR.puts "-" * 80 
end

A lungo: puoi. Dovrai montare il file system da un Live CD e iniziare a ripristinare le autorizzazioni nei punti appropriati. Come minimo per riavere sudo ti consigliamo di eseguire sudo chmod u+s /usr/bin/sudomentre sei nella sessione LiveCD - questo risolverà il setuid root necessario.

Tuttavia, sarebbe probabilmente più semplice reinstallare semplicemente il sistema.

Vorrei provare a reinstallare tutti i pacchetti con apt-get install --reinstall, possibilmente utilizzando l'output di dpkg --get-selections | grep installper ottenere un elenco di essi.

Va bene, non l'ho provato (quindi usalo a tuo rischio e pericolo), ma potrebbe comunque funzionare. Lo testerò in una macchina virtuale quando avrò la possibilità di:

Innanzitutto, in un sistema ancora funzionante, ho fatto quanto segue per ottenere tutte le autorizzazioni per i file in un elenco, saltando la /home/directory:

sudo find / -not -path /home -printf "%m:%p\0" > /tmp/fileper.log

Questo stamperà le autorizzazioni e il nome del file per ciascun file o directory sul sistema, seguito da un \0carattere (questo è necessario in seguito per gestire nomi di file strani come quelli che contengono newline).

Quindi, su un sistema in cui le autorizzazioni dei file sono state compromesse:

while IFS=: read -r -d '' perm file; do  
    chmod "$perm" "$file"
done < /tmp/fileper.log 

Questo leggerà ogni riga di fileper.log, salvando le autorizzazioni come $perme il nome del file come $filee quindi imposterà le autorizzazioni del file (o della directory) su qualsiasi cosa sia elencata nellafileper.log

Alcune cose da notare qui:

• Durante l'output nel file:, /tmp/fileper.logpotresti elencare le impostazioni personalizzate, proc, ecc.
• potresti non essere in grado di avviare o eseguire comandi,

Quello che suggerirei è di avviare un LiveCD con la versione di Linux che hai sul tuo disco, eseguire il comando, modificare il percorso in cui hai montato il disco locale ed eseguire il secondo comando!

Ho provato che quando avviato da un CD / USB Ubuntu, posso scegliere di non formattare il disco, il che significa che sostituirà tutto nella /directory, MA salterà la /home/directory. Ciò significa che i tuoi utenti avranno ancora intatta la configurazione di app / DATI (musica, video, documenti). E sostituendo i file di sistema, chmodviene impostato il numero corretto.

(So ​​che non dovrei commentare in una risposta, ma non abbastanza reputazione per commentare.)

La risposta di blade19899 ha funzionato per me, tranne per i collegamenti simbolici. Ad esempio, ha applicato 755 a / bin / bash, ma poi ha applicato 777 al symlink / bin / rbash, in effetti 777-ing / bin / bash.

Dato che avevo già il file fileper.log, ho appena modificato il comando destination-end:

while IFS=: read -r -d '' perm file; do  
    if [[ ! -L "$file" ]]; then    
        chmod "$perm" "$file"
    fi
done < /tmp/fileper.log 

Puoi provare a ripristinare le autorizzazioni con apt-get.

Se non è possibile eseguire questi comandi con sudo, potrebbe essere necessario avviare la modalità di ripristino ed eseguirli come root.

Per l'avvio in modalità di ripristino, consultare https://wiki.ubuntu.com/RecoveryMode .

Da http://hyperlogos.org/page/Restoring-Permissions-Debian-System

Nota: questo è stato originariamente pubblicato sui forum di Ubuntu ma non riesco a trovare il post originale.

Prova, in ordine,

sudo apt-get --reinstall install `dpkg --get-selections | grep install | grep -v deinstall | cut -f1`

Se fallisce:

sudo apt-get --reinstall install `dpkg --get-selections | grep install | grep -v deinstall | cut -f1 | egrep -v '(package1|package2)'`

E infine, come ultima risorsa,

sudo dpkg --get-selections | grep install | grep -v deinstall | cut -f1 | xargs apt-get --reinstall -y --force-yes install

Usando apt-get

Ecco lo snip pertinente, EDITED FOR CORRECTNESS e riformattato:

sudo apt-get --reinstall install `dpkg --get-selections | grep install | grep -v deinstall | cut -f1`

Supponiamo che tu riceva messaggi su alcuni pacchetti che non possono essere reinstallati e il comando ha esito negativo. Ecco un modo per risolverlo saltando i pacchetti in questione:

sudo apt-get --reinstall install `dpkg --get-selections | grep install | grep -v deinstall | cut -f1 | egrep -v '(package1|package2)'`

E infine, se in qualche modo dovessi aver installato così tante cose che il comando sopra non riesce a dire che l'elenco degli argomenti è troppo lungo, ecco la correzione, che verrà eseguita apt-get molte più volte di quanto potresti desiderare:

sudo dpkg --get-selections | grep install | grep -v deinstall | cut -f1 | xargs apt-get --reinstall -y --force-yes install

Nota le opzioni -ye --force-yes, che non ti apt-getchiederanno più e più volte. Queste sono sempre opzioni divertenti, se sei sicuro di sapere cosa stai facendo.

Ho avuto lo stesso problema, posso risolverlo. Nel mio caso Ubuntu 19.10

Apri il tuo terminale e digita sotto il semplice codice

sudo -i

aprire un altro terminale e controllare sotto il comando.

sudo apt update