Come posso trovare solo i file eseguibili sotto una certa directory in Linux?

La verifica della presenza di file eseguibili può essere effettuata con -perm (non consigliato) o -executable (consigliato, in quanto tiene conto dell'ACL). Per utilizzare l'opzione -executable:

find <dir> -executable

se si vogliono trovare solo file eseguibili e directory non ricercabili, combinarli con -type f:

find <dir> -executable -type f

Utilizzare l'opzione di ricerca -perm. Questa troverà i file nella directory corrente che sono eseguibili dal loro proprietario, dai membri del gruppo o da altri:

find . -perm /u=x,g=x,o=x

Modifica:

Ho appena trovato un'altra opzione che è presente almeno in GNU find 4.4.0:

find . -executable
``` &001 


Questo dovrebbe funzionare ancora meglio perché anche le ACL sono considerate.

So che la domanda menziona specificamente Linux, ma dato che è il primo risultato su Google, volevo solo aggiungere la risposta che stavo cercando (per esempio se siete - come me al momento - costretti dal vostro datore di lavoro ad usare un sistema non GNU/Linux).

Testato su macOS 10.12.5

find . -perm +111 -type f

Io ho un altro approccio, nel caso in cui quello che si vuole veramente è solo fare qualcosa con i file eseguibili - e non necessariamente per forzare la ricerca a filtrare se stessa:

for i in `find -type f`; do [-x $i] && echo "$i is executable"; done

preferisco questo perché non si basa su -executable che è specifico per la piattaforma; e non si basa su -perm che è un po’ arcano, un po’ specifico per la piattaforma, e come scritto sopra richiede che il file sia eseguibile per tutti (non solo per voi).

Il -type f è importante perché nelle directory *nix le directory devono essere eseguibili per essere attraversabili, e più la query è nel comando find, più efficiente sarà la memoria del vostro comando.

Comunque, solo offrendo un altro approccio, dal momento che *nix è la terra di un miliardo di approcci.

Un file marcato come eseguibile non deve necessariamente essere un file o un oggetto eseguibile o caricabile.

Ecco cosa uso:

find ./ -type f -name "*" -not -name "*.o" -exec sh -c '
    case "$(head -n 1 "$1")" in
      ?ELF*) exit 0;;
      MZ*) exit 0;;
      #!*/ocamlrun*)exit0;;
    esac
exit 1
' sh {} \; -print

Come fan di un unico liner…

find /usr/bin -executable -type f -print0 | xargs file | grep ASCII
``` ```
echo -n "+ Identifying script files owned by root that execute and have an eval in them..."
find / -not \( -path /proc -prune \) -type f -executable -user root -exec grep -l eval {} \; -exec file {} \; | grep ASCII| cut -d ':' -f1 > $outputDir"/root_owned_scripts_with_eval.out" 2>/dev/null &

Usando ‘xargs’ per prendere l'output dal comando di ricerca (usando print0 per garantire che i nomi dei file con spazi siano gestiti correttamente). Ora abbiamo una lista di file eseguibili e li forniamo, uno per uno, come parametro per il comando ‘file’. Poi grep per il termine ASCII per ignorare i binari. Si prega di sostituire -executable in find command con lo stile che preferite (vedi risposte precedenti) o che funziona sul vostro ‘NIX OS

Ho richiesto quanto sopra per trovare i file con eval in script di proprietà di root, così ho creato quanto segue per aiutare a trovare i punti deboli dell'escalation privata dove l'utente root esegue script con parametri non sicuri…

&001

Ho creato una funzione in ~/.bashrc stasera per trovare file eseguibili non nel percorso di sistema e non nelle directory:

# Quickly locate executables not in the path
xlocate () {
    locate -0r "$1" | xargs -0 -I{} bash -c '[[-x "$1"]] && [[! -d "$1"]] \
        && echo "executable: $1"' _ {}
} # xlocate ()
``` ```
$ time xlocate llocate
executable: /bin/ntfsfallocate
executable: /home/rick/restore/mnt/e/bin/llocate
executable: /mnt/clone/bin/ntfsfallocate
executable: /mnt/clone/home/rick/restore/mnt/e/bin/llocate
executable: /mnt/clone/usr/bin/fallocate
executable: /mnt/e/bin/llocate
executable: /mnt/old/bin/ntfsfallocate
executable: /mnt/old/usr/bin/fallocate
executable: /usr/bin/fallocate

real 0m0.504s
user 0m0.487s
sys 0m0.018s

Il vantaggio è che cercherà tre distribuzioni Linux e un'installazione Windows in meno di un secondo dove il comando find richiede 15 minuti.

Per esempio:

$ time xlocate /mnt/e/usr/local/bin/ | wc -l
65

real 0m0.741s
user 0m0.705s
sys 0m0.032s
``` &001 

o per un'intera directory e tutti i suoi sub: 


&001