Trova file leggibili dall'uomo

Sto cercando di trovare un modo efficace per superare il livello 5 della sfida del bandito OverTheWire .

Comunque, ho un sacco di file e ce n'è solo uno che rispetta i seguenti criteri:

• Leggibile dagli umani
• 1033 byte di dimensione
• Non eseguibile

In questo momento, sto usando il findcomando e sono in grado di trovare i file corrispondenti agli ultimi 2 criteri:

find . -size 1033c ! -executable

Tuttavia, non so come escludere file non leggibili dall'uomo. Le soluzioni che ho trovato per quella sfida usano il -readableparametro test, ma non credo che funzioni. -readableesamina solo le autorizzazioni dei file e non il suo contenuto, mentre la descrizione della sfida richiede un file ASCII o qualcosa del genere.

Sì, è possibile utilizzare findper cercare file non eseguibili della giusta dimensione e quindi utilizzare fileper verificare la presenza di ASCII. Qualcosa di simile a:

find . -type f -size 1033c ! -executable -exec file {} + | grep ASCII

La domanda, tuttavia, non è così semplice come sembra. "Lettura umana" è un termine orribilmente vago. Presumibilmente, intendi il testo. OK, ma che tipo di testo? Solo carattere latino ASCII? Unicode completo? Ad esempio, considera questi tre file:

$ cat file1
abcde
$ cat file2
αβγδε
$ cat file3
abcde
αβγδε
$ cat file4
#!/bin/sh
echo foo

Questi sono tutti testi e leggibili dall'uomo. Ora, vediamo cosa fileli rende:

$ file *
file1: ASCII text
file2: UTF-8 Unicode text
file3: UTF-8 Unicode text
file4: POSIX shell script, ASCII text executable

Quindi, il findcomando sopra troverà solo file1(per il bene di questo esempio, immaginiamo che quei file contengano 1033 caratteri). È possibile espandere il findper cercare la stringa text:

find . -type f -size 1033c ! -executable -exec file {} + | grep -w text

Con -w, grepverranno stampate solo le linee in cui textsi trova una parola autonoma. Questo dovrebbe essere abbastanza vicino a quello che si vuole, ma non posso garantire che non v'è alcun altro tipo di file la cui descrizione potrebbe anche includere la stringa text.

Mentre -execè principalmente usato per fare qualcosa con i file che sono stati trovati, può anche fungere da test. Pertanto, possiamo aggiungerlo ai tuoi altri criteri:

find . \
  -size 1033c \
  -not -executable \
  -exec sh -c 'file {} | grep "text$"' \;

Ricorda, greprestituisce un valore diverso da zero quando il modello non è stato trovato e sh -c "COMMAND"restituisce il risultato della valutazione (purché sia ​​valido). Quindi questo stamperà solo file dove file <filename>sputa qualcosa che termina text, ad esempio "Testo Unicode UTF-8" o "Testo ASCII", ma non "Testo ASCII esteso non ISO, con sequenze di escape".

In una sola riga, finisce anche più breve di andare oltre xargs:

find . -size 1033c -not -executable -exec sh -c 'file {} | grep "text$"' \;

Tieni presente che puoi sostituirlo sh -c 'file {} | grep "text$"'con qualsiasi comando personalizzato. Se vuoi verificare qualcosa di molto complesso, potrebbe essere una buona idea fornire uno script di shell e usarlo invece:

find . -size 1033c -not -executable -exec is_human_readable.sh {} \;

che, a lungo termine, è più facile da mantenere rispetto alla cronologia della shell:

#!/bin/sh
file "$@" | grep "text$" > /dev/null

find . -size 1033c ! -executable -exec file {} +

Hai solo bisogno di usare:

find inhere -size 1033c

Ti darà l'unico file che contiene la password.

Basta eseguire quanto segue sul contenuto della directory:

$ file -- *
-file00: data
-file01: data
-file02: data
-file03: data
-file04: data
-file05: data
-file06: data
-file07: ASCII text
-file08: data
-file09: data
$ cat -- \-file07
<output>

find . -size 1033c ! -executable|xargs file|grep "ASCII text" |awk -F: '{print $1}'

Prova questi comandi combinati. funziona sulla mia stazione.

Puoi provare questo

find . -size 1033c ! -executable -exec file {} +

La tua sfida non lo consente grep. il file delle password verrà riportato come "testo ASCII, con righe molto lunghe"

Per filtrare i nomi dei file leggibili dall'uomo, è possibile utilizzare il nome della classe di caratteri[:print:] ( stampabile ) . Ulteriori informazioni su tali classi sono disponibili nel manuale di .grep

find . -type f -size 1033c -name "[[:print:]]*" ! -executable

Ripensandoci, il requisito "leggibile dall'uomo" potrebbe riferirsi al contenuto del file, anziché al suo nome. In altre parole, dovresti cercare file di testo . È un po 'più complicato. Come suggerito da @D_Bye in un commento, è necessario utilizzare il filecomando per determinare il tipo di contenuto del file. Ma non sarebbe una buona idea correre filedietro una pipe, perché complicherebbe il compito di visualizzare il nome del file. Ecco cosa suggerisco:

find . -type f -size 1033c ! -executable -exec sh -c 'file -b $0 | grep -q text' {} \; -print

Ecco in breve come filefunziona -part:

• Il -execpredicato viene eseguito sh -c 'file -b $0 | grep -q text' FILENAMEper ciascuno di essi FILENAMEche soddisfa tutte le condizioni precedenti (tipo, dimensione, non eseguibile).
• Per ciascuno di questi file, un guscio ( sh) gestisce questo breve scritto : file -b $0 | grep -q text, sostituendo $0con il nome del file.
• Il fileprogramma determina il tipo di contenuto di ciascun file e genera queste informazioni. L' -bopzione impedisce di stampare il nome di ciascun file testato.
• grepfiltra l'output proveniente dal fileprogramma, cercando le righe contenenti "testo" . (Guarda tu stesso come fileappare un tipico output del comando.)
• Ma grepnon genera il testo filtrato, perché ha l' -qopzione (silenziosa) fornita. Quello che fa, è semplicemente cambiare il suo stato di uscita in uno 0(che rappresenta "vero" - il testo filtrato è stato trovato) o 1 (che significa "errore" - il testo "testo" non è apparso nell'output da file).
• Il vero / falso stato di uscita proveniente dal greppassa ulteriormente sha finde agisce come il risultato finale dell'intero " -exec sh -c 'file $0 | grep -q text' {} \;" test.
• Nel caso in cui il test sopra riportato fosse vero , il -printcomando viene eseguito (cioè viene stampato il nome del file testato).

bandit4@bandit:~$ ls
inhere

bandit4@bandit:~$ file inhere/*


inhere/-file00: data
inhere/-file01: data
inhere/-file02: data
inhere/-file03: data
inhere/-file04: data
inhere/-file05: data
inhere/-file06: data
inhere/-file07: ASCII text
inhere/-file08: data
inhere/-file09: data

bandit4@bandit:~$ pwd 

/home/bandit4

bandit4@bandit:~$ cat /home/bandit4/inhere/-file07

koReBOKuIDDepwhWk7jZC0RTdopnAYKh
bandit4@bandit:~$ 

find  -type f ! -executable -size 1033c

ti procurerà il file dell'esercizio

find . -type f -size 1033c ! -executable | xargs file | grep text

Fan di una fodera

Penso che il modo più descrittivo sia il modo più lungo di trovare la password per questo livello di bandito menzionato dalla maggior parte sopra usando find e grep.

find . -type f -size 1033c ! -executable -exec file {} + | grep ASCII

Ma, dopo aver usato di più il comando 'file', mi sono reso conto che è abbastanza facile individuare file leggibili dall'uomo (ovvero ASCII in questo livello) in questo modo controllando interi tipi di file di directory. La directory inhere contiene i file con il nome '-filexx' o controlla rapidamente l'intera directory inhere confile ./*

Ecco il mio approccio.

bandit4@bandit:~/inhere$ file ./*
./-file00: data
./-file01: data
./-file02: data
./-file03: data
./-file04: data
./-file05: data
./-file06: data
./-file07: ASCII text
./-file08: data
./-file09: data

bandit4@bandit:~/inhere$ cat ./-file07
koReBOKuIDDepwhWk7jZC0RTdopnAYKh

du --human-readable | find -not -executable -size 1033c

otterrà il tuo risultato