"Leeren" Speicher auf der Festplatte überschreiben

“Leeren” Speicher auf der Festplatte überschreiben

Hallo Java-community,

Ich möchte ein Programm schreiben, das den “leeren” speicher der festplatte komplett überschreibt.
Oft ist es doch so, dass das Betriebsystem in den Bitfolgen der Speicheradressen nur ein Bitflag setzt um zu symbolisieren, dass diese bitfolge “leer” ist. Allerdings bleiben die eigentlichen daten nach wie vor unverändert. Oder verstehe ich etwas falsch?
Ist es also möglich mit java diese speicherzellen ausfindig zu machen und alle bits einer folge bis auf das flag bit z.b. auf 1 zu setzten?
Wenn ja welche methoden benötige ich?

Danke für jede Antwort.

Moin,

wie wäre es denn einfach mit ** Defragmentieren** :confused:

Gruß
Klaus

Hallo Gast0815,

mit Java wirst du da nicht weit kommen, den wo und wie eine Datei abgespeichert wird ist Sache des Betriebsystems und der Hardware.
Mit den Standardmethoden von Java wirst du da meines Wissens nicht viel machen können, bzw. dir nie 100% sicher sein, daß auch alles überschrieben wurde.

Ich gehe mal davon aus, daß du die Dateien (Bombenbauanleitungen, KiPos, Kategorie-2-Bilder und Hetzschriften) so löschen möchtest, daß man diese nicht mehr rekonstruieren kann. (Ständiges Festplattenschreddern und Computer-verschwinden-lassen kann mit der Zeit ziemlich teuer werden.)

Mit einer einfachen standard Defragmentierung wirst du auch nicht das gewünschte Ziel erreichen.
Es gibt da diverse Lösch-Programme, die sowas erledigen. (Schlagwort: data eraser)

MfG
hansmueller

Einfach mit dev/null > /dev/sdX

Mit reinem Java keine Chance

Hallo Klaus und danke für deine schnelle Antwort.
Durch das defragmentieren werden soweit ich weiß dateifragmente auf der festplatte so verschoben, dass mögliche zugriffszeiten verkürzt werden. Dabei bleiben die dateien und damit die bits in ihrer form erhalten. Außerdem handelt es sich dabei um speicherzellen, die vom system als beschrieben erkannt werden. Ich möchte allerdings die Speicherzellen überschreiben die aufgrund des flagbits als gelöscht angesehen werden.

Das machst du besser in C. Wenn es um Windows geht, so öffnest du die Festplatte:

char *drive = „\\.\PhysicalDrive0“; //Device

HANDLE hDisk = CreateFile(drive , GENERIC_READ, FILE_SHARE_VALID_FLAGS, 0,
OPEN_EXISTING, 0, 0);

Dazu einfach mal die Doku für CreateFile durchlesen

Das geht natürlich nur under unixoiden Systemen. Und korrekt ist das auch nicht. Die Quelle ist entweder /dev/zero oder /dev/urandom. Zusätzlich ist der Befehl dd nötig. Mit diesen Suchbegriffen googeln oder die manpage von dd lesen

Alles klar, hab mir fast gedacht, dass ich auf C ausweichen muss.

Vielen dank für eure Antworten!

Moin,

oder um es mal etwas platter auszudrücken:

für Hardware- osder OS-nahe Programmierung ist eine plattform-**unabhängige ** Sprache wie Java immer denkbar ungeeignet!

Gruß
Klaus

Klar kannst du es auch in Java machen nur die OS kritischen Sachen musst du in C implementieren und dann mit JNI aufrufen. Ob das Sinn macht - eher nicht.

erzeuge eine Datei, fülle diese mit 0x00 (oder anderem Wert) bis die Festplatte voll ist und lösche sie anschließend wieder. Festplatte leer

Ich weiß nicht, ob man in diese richtung helfen soll, weil hansmueller hat doch schon alles geschrieben.

        File f = new File("C:\\Users\\Blub\\Desktop\\schonBestehendeDatei.txt");
        int l = (int) f.length();
        for (int i = 0; i < 10; i++) {
            FileOutputStream fos = new FileOutputStream(f);
            for (int j = 0; j < l; j++) {
                int b = 1;
                for (int k = 0; k < 8; k++) {
                    b = b << 1 | i % 2;
                }
                //System.out.println((byte) b);
                fos.write((byte) b);
            }
            fos.flush();
            fos.close();
        }
        return;```


erstelle aus .... ....
[spoiler]

12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345
12345


(7 Zeichen in einer Zeile [Wind])

ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ

[/spoiler]

Wenn ich ihn richtig verstanden haben, will er die ganze Platte voll müllen und da man mit Java glaube ich nicht an das File System direkt kommt, wird das nicht funktionieren.

Edit: Man könnte versuchen ob so etwas funktioniert:

File f = new File("C/:"); //Pfad zum Laufwerk 
f.getFreeSpace(); 

Zumindest sieht f.getFreeSpace(); vielversprechend aus.

Zusammen mit Cyborg Methode. Ob es 10 mal bedarf und immer mit dem selben Wert aus BitOperationen generiert wage ich zu bezweifeln.

Einfach in die Mikrowelle packen xD

Also ich bin ja immer dagegen etwas zu programmieren was es schon gibt: http://www.pcmag.com/slideshow_viewer/0,3253,l=255105&a=255105&po=8,00.asp

bye
TT

[QUOTE=timbeau]Einfach mit dev/null > /dev/sdX

Mit reinem Java keine Chance[/QUOTE]

Ehr /dev/random oder /dev/zero … aus /dev/null wird nichts raus kommen :wink:

Große Datei anlegen alleine reicht auch nicht. Man müsste z.B. noch zusätzlich schauen welche Dateien keine ganzen Blöcke verwenden und deren ungenutzten Speicher auch überschreiben. Und das vorgehen macht dann richtig Spaß wenns ne SSD oder SD-Karte ist. → Besser gleich nur die Dateien sicher löschen deren Inhalt man wirklich vernichtet wissen will. Spart Zeit und schont die Hardware.

Also es ist wie beschrieben Sache der JRE/JVM, Betriebssytem und Hardware wie zB Festplatte.

Ich bin mir nichtmal sicher, ob obiger Code nicht einfach woanders eine neue Datei hinschreibt oder auch nur einmal -1 (int) geschrieben wird.

1111 1111 bekäme man auch einfacher durch i%2 == 0? (byte) 0 : (byte) -1
hin. Oder 0xFF oder -0b111_1111 (-127…).

Edit: (byte) ((i%2)-1)

Edit 2: (byte) (-(i%2))

*** Edit ***

Edit: @Mods: Darf ich eine wahrscheinlich funktionierende, auf FileOutputStream (nicht FileChannel) basierende Lösung posten, die wahrscheinlich alle Dateien eines Verzeichnis’ mehrmals überschreibt (und umbenennt), sd sie anschließend in der Papierkorb verschoben werden können, oder ist das nicht erlaubt?

*** Edit ***

so sähe das aus, falls falsch ,bitte löschen:
[spoiler]``` public static void rewriteFolder(File folder) throws IOException, InterruptedException {
if (!folder.isDirectory() || !folder.canWrite()) {
throw new IllegalArgumentException("Not a folder: " + folder);
}
File[] files = folder.listFiles();
Arrays.sort(files, new Comparator() {
@Override
public int compare(File o1, File o2) {
return -Long.valueOf(o1.lastModified()).compareTo(o2.lastModified());/zuerst neue Dateien/
}
});
for (File file : files) {
if (!file.isFile() || !file.canWrite()) {
continue;
}
if (JOptionPane.showConfirmDialog(null, "Soll

" + file + "

ÜBerschrieben werden?", “ÜBerschreiben”, JOptionPane.OK_CANCEL_OPTION) == JOptionPane.OK_OPTION) {
System.out.println(“ok”);
int l = (int) file.length();
for (int i = 0; i < 10; i++) {
int b = -(i % 2);
System.out.println("b = " + b + " , (byte) b = " + (byte) b);
FileOutputStream fos = new FileOutputStream(file);
for (int j = 0; j < l; j++) {
fos.write(b);
}
fos.flush();
fos.close();
Thread.sleep(250L);
}
file.renameTo(new File(file.getParent() + File.separatorChar + System.currentTimeMillis() + “.txt”));
}
}
}```

run:
ok
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
ok
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
ok
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
ok
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
ok
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
ok
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
ok
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
b = 0 , (byte) b = 0
b = -1 , (byte) b = -1
BUILD SUCCESSFUL (total tim

[/spoiler]

Wieso auch nicht? Istbdoch legaler (badumm… tss) java code :smiley:

unter Linux einfach shred zum sicheren Löschen verwenden. Ansonsten hilft auch eine Vollverschlüsselung, da mit dem übrgigebliebenen Verschlüsselungsbrei auch niemand was anfangen kann. Hat man keine Verschlüsselung und nicht sicher gelöscht, ist der einfachste Weg, die Daten was man braucht auf eine neue und verschlüsselte Platte zu packen und die alte in die Mikrowelle und unter die Bohrmaschine ^^

[QUOTE=HoaX]Ehr /dev/random oder /dev/zero … aus /dev/null wird nichts raus kommen :wink:
[/QUOTE]

Jaaa, ich weiß. :slight_smile:

Diese ganzen Byte-Geschichten sind völlig sinnlos. @CyborgBeta z.B. Diese arbeiten nur auf Partitionsgrenzen, die GPT z.B. wirst du damit nicht wegbekommen.

Ich halte shred für ziemlich übertrieben, dd sollte reichen. Die Speicherbereiche sind heutzutage so dicht, dass die Leseköpfe da alles erwischen, was früher anders war. Da musste man alles mehrfach überschrieben, weil die Spuren eventuell nicht sauber beschrieben wurden.