Binary Request: wipe

SlrG

Neuer User
Mitglied seit
4 Jun 2006
Beiträge
5
Punkte für Reaktionen
0
Punkte
1
Hallo!

Könnte mir jemand mit Linux System und laufendem Compiler bitte "wipe" für die Fritz!Box Fon 7170 kompilieren? Wäre echt klasse. Ich will nicht immer zur Box laufen, die Platte abziehen und oben am Rechner wieder einstecken, um sicher löschen zu können.

Vielleicht ist das ja auch für jemand anderen interessant.

Danke!

Michael
 
Das man damit nicht auf einfache Weise ein ganzes Verzeichnis halbweg sicher und effizient mit mehreren Durchläufen löschen kann.

Kann natürlich sein, dass ich als absoluter Linux Neuling einfach nicht die richtigen Parameter kenne. Aber einfaches Googeln hat mir bisher nur solche Skripte gebracht, die eine einzelne Datei mit dd löschen. Für ein Verzeichnis habe ich noch nichts gefunden.

Vielleicht kennst Du ja ein besseres Skript bzw. kannst mir die richtigen Parameter nennen.

In dem bisher besten Skript, was ich gefunden habe, steht jedenfalls ein Verweis auf wipe und der Hinweis, dass dieses seine Aufgabe wohl besser erledigt. (Das Skript mit dem Hinweis steht am unteren Ende folgender Seite.)
http://www.museum.state.il.us/ismdepts/library/linuxguides/abs-guide/extmisc.html

Jedenfalls hatte mich dieser Hinweis dann bewogen mir eine fertige Mipsel-Binary aus dem Netz zu besorgen, die aber natürlich nicht funktioniert hat. :(

Deshalb hab ich jetzt einfach mal gefragt, ob es mir nicht jemand compilieren kann.
 
Du kannst etwas in der Art versuchen, am Besten wenn sich keine wichtigen Dateien auf der Platte befinden.
find sucht alle Einträge innerhalb des Verzeichnisses, -type f grenzt das Ergebnis auf reguläre Dateien ein.
Code:
DIR="$1"
if ! test -d "$DIR"; then
    echo "$DIR not found"
    exit 1
fi
for i in $(find "$DIR" -type f); do
    erase "$i"
done
Alternative:
Code:
# Dateien normal löschen
# rm ...
dd if=/dev/zero of=Tmp-File bs=1024k
rm Tmp-File
Damit wird der gesamte nicht belegte Platz überschrieben. Je nach Plattengröße kann dies dauern.

Insbesondere darf man nicht vergessen, daß die FBF eine USB 1.1 Anschluß hat, man kann also nur mit ca 1 MB/s rechnen.
 
@RalfFriedl: Danke für Deine aktive Hilfe. :)

Der von Dir vorgeschlagene Weg ist sicher gangbar, aber wie Du selbst schreibst, kann es je nach Plattengröße ewig dauern, bis der Vorgang abgeschlossen ist.

@All:
Deshalb suche ich immer noch nach einer Möglichkeit einzelne Verzeichnisse mit Unterverzeichnissen und enthaltenen Dateien selektiv auszuradieren. Ein kompiliertes wipe wäre da die einfachste Lösung. Findet sich nicht doch noch jemand, der es schnell mal zu kompilieren versucht? Vielleicht läuft es ja glatt durch?! Der Sourcecode liegt hier: http://sourceforge.net/project/showfiles.php?group_id=804&package_id=798

Alternativ kann mir vielleicht auch jemand sagen, welche Threads, FAQs o. ä. ich durcharbeiten muss, um zu verstehen, wie man ein auf der 7170 lauffähiges Binary erzeugt. :confused:

Ansonsten bin ich aber auch bereit Ralfs Ansatz mit dd weiter zu verfolgen. Ich habe deshalb mal das Skript, welches ich oben schon angesprochen hatte so modifiziert, dass es auch tatsächlich auf der 7170 läuft. Leider löscht es bisher nur einzelne Dateien. Ich werde es die Tage aber noch so modifizieren, dass es sich rekursiv durch einen angegebenen Pfad hangelt.

Das Skript heisst bei mir "ddw" und liegt im Pfad. Man startet es mit

ddw dateiname x​

wobei x eine optionale Zahl ist, die für die Anzahl der gewünschten Schreibdurchgänge steht. Lässt man sie weg, werden 7 Durchgänge pro Datei geschrieben. Aber das kann man im Code natürlich anpassen wie man will.

Achtung!: Es kommt keine Abfrage, ob man die angegebene Datei auch wirklich löschen will. Wenn sie existiert wird ohne weitere Rückfrage gelöscht!

Code:
#!/bin/sh
#  This script overwrites a target file alternately
#+ with random bytes, then zeros before finally deleting it.
#  After that, even examining the raw disk sectors
#+ will make it hard to reveal the original file data.

BLOCKSIZE=1      #  I/O with /dev/urandom requires unit block size,
                 #+ otherwise you get weird results.
E_BADARGS=70
E_NOT_FOUND=71

if [ -z "$1" ]   # No filename specified.
then
  echo "Usage: `basename $0` filename"
  exit $E_BADARGS
fi

file=$1

if [ ! -e "$file" ]
then
  echo "File \"$file\" not found."
  exit $E_NOT_FOUND
fi  

if [ -z "$2" ]   # No number of passes given use
then
  PASSES=7       # default number of file-shredding passes.
else
  PASSES=$(echo $2 | sed -e 's/[^0-9]//g' )
fi


# As there's no /dev/zero, create one in /var/tmp.
if [ ! -e "/var/tmp/zero" ]
then
  mknod /var/tmp/zero   c   1 5
fi

flength=$(ls -l "$file" | tr -s ' ' '\n' | sed -n 5p)  # Field 5 is file length.

# Wipe File
pass_count=1
rpass_count=$PASSES
echo -n "$PASSES-Pass Wipe of File \"$file\": "

while [ "$pass_count" -le "$PASSES" ]
do
  if [ $pass_count -gt 1 -a $pass_count -le $PASSES ]
  then
    echo -n \>
  fi
  echo -n $rpass_count
  busybox dd if=/dev/urandom of=$file bs=$BLOCKSIZE count=$flength 2> /dev/null
               # Fill with random bytes.
  busybox dd if=/var/tmp/zero of=$file bs=$BLOCKSIZE count=$flength  2> /dev/null
               # Fill with zeros.
  let "pass_count += 1"
  let "rpass_count -= 1"
done  

# Scramble Filename
stime=$(date +"%T" | sed -e 's/[^0-9]//g' )
let new_fn=$flength*$stime
mv $file $new_fn
file=$new_fn

rm -f $file    # Finally, delete scrambled and wiped file.
echo " Done!";

exit 0
 
So... Ich hab die Sache mit dem DD mal weiter verfolgt. Es war nicht ganz einfach, aber folgendes Skript sollte in der Lage sein, ein komplettes Verzeichnis mit Unterverzeichnissen und Dateien zu schreddern. Ohne sed wäre es unmöglich gewesen. Aber der ist zum Glück ja auf der Box.

Die Benutzung des Skriptes ist auf eigene Gefahr, ich übernehme keinerlei Haftung. Ich habe zwar recht umfangreich getestet, aber mit einzelnen Datei- bzw. Verzeichnisnamen kann es vielleicht immer noch zu unerwünschten Effekten kommen.

Je nach Größe der Verzeichnisse/Dateien und gewählter Durchlaufszahl dauert das schreddern ewig. :( Aber das hatte Ralf ja schon vermutet. Ein compiliertes wipe schafft das sicher auch nicht besser, aber vielleicht ist es doch noch eine Nummer zuverlässiger, als mein handgestrickter Algorithmus. Falls also doch noch jemand einen Compiler mit Langeweile hat, ich bin immer noch interessiert. :)

Okay. Genug gelabert. Hier ist das Skript:
Code:
#!/bin/sh
#  This script overwrites a target file/directory alternately
#+ with random bytes, then zeros before finally deleting it.
#  After that, even examining the raw disk sectors
#+ will make it hard to reveal the original file data.

STARTPATH=$(pwd)
E_BADARGS=70     # Wrong Arguments
E_NOT_FOUND=71   # File not found

if [ -z "${1}" ]   # No filename/path specified.
then
  echo "Usage: `basename $0` path/filename"
  exit $E_BADARGS
fi

file="${1}"

if [ ! -e "${file}" ]
then
  echo "File \"${file}\" not found."
  exit $E_NOT_FOUND
fi

if [ -n "$2" ]   # Number of passes specified.
then 
  PASSES=$(echo $2 | sed -e 's/[^0-9]//g')
fi
if [ "$PASSES" -eq "" ]
then
  PASSES=1       # Set default number of file-shredding passes.
fi  

# If there's no /dev/zero, create one in /var/tmp.
if [ ! -e "/var/tmp/zero" ]
then
  mknod /var/tmp/zero   c   1 5
fi

# Wipe File
wipe_file () {
  # restore filename
  fn=$(echo "${1}" | sed -e s/":"/" "/g)
  BLOCKSIZE=1      #  I/O with /dev/urandom requires unit block size,
                   #+ otherwise you get weird results.

  dirname=$(echo "${fn}" | sed 's,[^/]*$,,')    	# extract the dirname from a path
  filename=$(echo "${fn}" | sed 's,.*/,,')		    # extract the filename from a path

  cd "${dirname}"
  flength=$(ls -l "${filename}" | tr -s ' ' '\n' | sed -n 5p)  # Field 5 is file length.

  pass_count=1
  rpass_count=$2
  echo -n "$2-Pass Wipe of File \"${filename}\": "

  while [ "$pass_count" -le "$2" ]
  do
    if [ $pass_count -gt 1 -a $pass_count -le $2 ]
    then
      echo -n \>
    fi
    echo -n $rpass_count
    busybox dd if=/dev/urandom of="${filename}" bs=$BLOCKSIZE count=$flength 2> /dev/null
                 # Fill with random bytes.
    busybox dd if=/var/tmp/zero of="${filename}" bs=$BLOCKSIZE count=$flength  2> /dev/null
                 # Fill with zeros.
    let "pass_count += 1"
    let "rpass_count -= 1"
  done  
  # Scramble Filename with pseudo random string
  fnlength=$(echo ${#filename})
  new_fn=$(echo $(busybox dd if=/dev/urandom count=500 bs=1 2>/dev/null | sed -e s/[^0-9A-Za-z]//g) | sed -e s/[^0-9A-Za-z]//g | sed -e "s/.*\(.\{$fnlength\}\)/\1/")
  mv "${filename}" $new_fn

  rm -f $new_fn    # Finally, delete scrambled and wiped file.
  cd "${STARTPATH}"
  echo " Done!";
}

if [ -d "${file}" ]
then
  echo Wiping, scrambling and removing files:
  # wipe files in whole directory including subdirs
  # find files and mask spaces
  for ff in `find "${file}" -type f | sed -e s/" "/":"/g 2>/dev/null`
  do
    wipe_file $ff $PASSES "${STARTPATH}"
  done
  echo  
  echo Scrambling and removing directories:
  i=0
  #find files, mask spaces and reverse find output
  for ff in `find "${file}" -type d | sed -e s/" "/":"/g | sed '1!G;h;$!d' 2>/dev/null`
  do
    # restore filename
    fn=$(echo "${ff}" | sed -e s/":"/" "/g)
    echo -n "${fn}"
    let "i=i+1"
    dirname=$(echo "${fn}" | sed 's,[^/]*$,,')    	# extract the dirname from a path
    filename=$(echo "${fn}" | sed 's,.*/,,')		    # extract the filename from a path
    if [ ! "${dirname}" == "" ]
    then
      cd "${dirname}"
    fi
    # Scramble Dirname with pseudo random string
    fnlength=$(echo ${#filename})
    new_fn=$(echo $(busybox dd if=/dev/urandom count=500 bs=1 2>/dev/null | sed -e s/[^0-9A-Za-z]//g) | sed -e s/[^0-9A-Za-z]//g | sed -e "s/.*\(.\{$fnlength\}\)/\1/")
    mv "${filename}" $new_fn
    rm -r $new_fn
    cd "${STARTPATH}"
    echo " "\> Done.
  done  
else
  # wipe single file
  wipe_file "${file}" $PASSES "${STARTPATH}"
fi

exit 0

Und nochmal: Es erfolgt keine Abfrage, ob man wirklich löschen will!
 
Kostenlos!

Zurzeit aktive Besucher

Statistik des Forums

Themen
248,475
Beiträge
2,292,295
Mitglieder
377,928
Neuestes Mitglied
mp24