Dateizeiger erhalten



  • Hallo,

    gibt es in C++ eine Moeglichkeit die Anfangsadresse einer Datei zu erhalten.
    Ich moechte meinen eigenen Datei Shredder bauen und jedes Bit der Datei bis zum Ende mit einer "1" ueberschreiben. Ich dachte dabei an diesen Code hier.

    ofstream myfile;
      myfile.open ("example.txt");
    

    Aber ich glaube so bekomm ich nicht die Startadresse der Datei oder..



  • Ich hab jetzt mal noch den Code hier gefunden. Ein Pointer vom Typ FILE. Wenn ich den dereferenzier muesste ich doch die Adresse ueberschreibne koennen. Hm

    FILE * pFile;
      long size;
    
      pFile = fopen ("C:/Users/bert1/Desktop/example.txt","rb");
      if (pFile==NULL) perror ("Error opening file");
      else
      {
    
    	printf("Address of File: %d",pFile);
    
    	for(int i =0;i<25;i++)
    	{
    		*pFile = 0;
    	}
    
        fseek (pFile, 0, SEEK_END);   // non-portable
        size=ftell (pFile);
        fclose (pFile);
        printf ("\nSize of myfile.txt: %ld bytes.\n",size);
      }
      return 0;
    


  • Was denn bitte für einen Zeiger? Daten schreibt man mit ostream::write() bzw fwrite().



  • Ein Dateizeiger ist ein Hillfskonstrukt, mi dem du bestimmen kannst, an welcher Position in der Datei die nächste Operation stattfinden soll.

    FILE ist eine Datenstruktur (Erbe von C), in dem das System Informationen über die geöffnete Datei ablegt.
    Da kann auch der Dateizeiger enthalten sein.

    Dein pFile ist ein Zeiger auf so eine Struktur, die von fopen erzeugt wurde.
    Das pFile ist nicht der Dateizeiger und Manipulationen daran sollte man unterlassen (z.b. dereferenzieren)

    "rb" ist für deine Zwecke auch der falsche Modus bei fopen .
    Damit sich an der Datei etwas ändertm musst du schon Schreiboperationen daran vornehmen.



  • So hab mir jetzt mal so einen File Shredder gebastelt. Was haltet ihr davon. Ich versteh gar nicht was diese Algorithmen bringen sollen. Reicht es nicht wenn man jedes Byte einfach mit einem beliebigen Wert ueberschreibt. Und das meinetwegen halt oefter. Was mich bzgl. C++ gewundert hat, wenn ich calculateFileSize hinter main schreibe dann findet er die Funktion nicht.

    #include <iostream>
    #include <fstream>
    
    using namespace std;
    
    int calculateFileSize(char* path)
    {
      long begin, end;
      ifstream myfile (path);
      begin = myfile.tellg();
      myfile.seekg (0, ios::end);
      end = myfile.tellg();
      myfile.close();
    
      int size = end - begin;
      return size;
    }
    
    //main function
    int main()
    
      char* path = "YOUR PATH";
    
      const int size  = calculateFileSize(path);
    
      std::ofstream outfile (path,std::ofstream::binary);
    
      // allocate memory for file content
      char* buffer = new char[size];
      char overwriteValue=1;
    
      //overwrite bytes of file
      for(int k = 0;k<8;k++)
      {
    	 overwriteValue=overwriteValue<<1;
       //or: overwriteValue=rand()%256;
    	 for(int i=0;i<size;i++)
    	 {
    		 buffer[i]=0;
    	 }
    
    	 // write to outfile
    	 outfile.write (buffer,size);
    	 //rewind file pointers
    	 outfile.seekp(0,ios::beg);
      }
      // release dynamically-allocated memory
      delete[] buffer;
    
      outfile.close();
      return 0;
    }
    


  • computernerds schrieb:

    So hab mir jetzt mal so einen File Shredder gebastelt. Was haltet ihr davon. Ich versteh gar nicht was diese Algorithmen bringen sollen. Reicht es nicht wenn man jedes Byte einfach mit einem beliebigen Wert ueberschreibt. Und das meinetwegen halt oefter. Was mich bzgl. C++ gewundert hat, wenn ich calculateFileSize hinter main schreibe dann findet er die Funktion nicht.

    #include <iostream>
    #include <fstream>
    
    using namespace std;
    
    int calculateFileSize(char* path)
    {
      long begin, end;
      ifstream myfile (path);
      begin = myfile.tellg();
      myfile.seekg (0, ios::end);
      end = myfile.tellg();
      myfile.close();
    
      int size = end - begin;
      return size;
    }
    
    //main function
    int main()
    
      char* path = "YOUR PATH";
    
      const int size  = calculateFileSize(path);
    
      std::ofstream outfile (path,std::ofstream::binary);
    
      // allocate memory for file content
      char* buffer = new char[size];
      char overwriteValue=1;
    
      //overwrite bytes of file
      for(int k = 0;k<8;k++)
      {
    	  overwriteValue=overwriteValue<<1;
    	  for(int i=0;i<size;i++)
    	  {
    		  buffer[i]=0;
    	  }
    
    	  // write to outfile
    	  outfile.write (buffer,size);
    	  //rewind file pointers
    	  outfile.seekp(0,ios::beg);
      }
      // release dynamically-allocated memory
      delete[] buffer;
    
      outfile.close();
      return 0;
    }
    

    Sieht nett aus. Ob Du damit aber den Speicher der Datei auf Deiner Festplatte überschreibst, ist aber nicht gewährleistet. Die Highlevelroutinen zum Dateizugriff geben Dir hier überhaupt keine Gewährleistung, in welchen Sektoren Deine Daten geschrieben werden. Da mußt Du schon das Dateisystem selber auslesen und verändern.

    VG



  • ja stimmt schon. So nee Datei kann ja uberall verstreut sein. Wenn die jetzt 10 Millionen Byte gross ist und ich uberschreib von der Startadresse einfach mal die naechsten 10 Millionen Bytes kann der Schuss nach hinten losgehen.
    Aber die Startadresse der Datei sollte schon die wirkliche physikalische Adresse sein, behaupt ich jetzt mal.



  • computernerds schrieb:

    ja stimmt schon. So nee Datei kann ja uberall verstreut sein. Wenn die jetzt 10 Millionen Byte gross ist und ich uberschreib von der Startadresse einfach mal die naechsten 10 Millionen Bytes kann der Schuss nach hinten losgehen.
    Aber die Startadresse der Datei sollte schon die wirkliche physikalische Adresse sein, behaupt ich jetzt mal.

    Die bekommst Du aber nicht mit den Highlevelfunktionen.

    VG
    Edit: Die physikalische Adresse einer Datei sind die Sektornummern eines Speicherblocks Deiner Festplatte.



  • Eine Datei hat keine Startadresse.
    Wenn du mittels memory mapped file-Zugriff lesend/schreibend auf eine Datei zugreifst, dann wird die Datei in den Hauptspeicher gespiegelt (und man könnte dann evtl. von einer Startadresse reden).
    Je nach Festplattentyp (Harddisk, SSD) muß dann aber ein Überschreiben einer Datei nicht unbedingt auch den selben physikalischen Sektor auf der Festplatte benutzen (es wird einfach der Eintrag im internen Directory geändert).



  • Das ist defintiv die Datei auf der Festplatte. Du oeffnest die Datei auf der Festplatte und schreibst auch dort deine Bytes rein.



  • Wenn du eine bestehende Datei zum Schreiben öffnest, wird der bisherige Speicherplatz zur weiteren Benutzung freigegeben.
    Schreiboperationen auf die neue Datei müssen nicht den alten Platz benutzen.

    computernerds schrieb:

    Was mich bzgl. C++ gewundert hat, wenn ich calculateFileSize hinter main schreibe dann findet er die Funktion nicht.

    Der Compiler geht einmal durch die Datei.
    Dinge, die er nicht kennt, werden als Fehler gemeldet.
    Der Compiler hat beim Aufruf der Funktion noch keine Information über diesen Bezeichner und weiß nicht, was er damit machen soll.
    Das kann man aber mit einer Deklaration umgehen.

    Grundlagen.



  • DirkB schrieb:

    Der Compiler hat beim Aufruf der Funktion noch keine Information über diesen Bezeichner und weiß nicht, was er damit machen soll.
    Das kann man aber mit einer Deklaration umgehen.

    ah ok. In Java ist das egal. Der Compiler geht 2mal ueber die Datei.

    Dass wenn man z.B. an eine Datei am Ende was anhaengen moechte dieser Speicherplatz freigegeben wird und die komplette Datei woanders hinkopiert wird, das wusste ich nicht.



  • Wenn du low level Zugriff haben willst, hängt das von deinem System ab.

    Hier mal ein paar Links zum weiteren Studium:

    https://msdn.microsoft.com/en-us/library/aa363858(VS.85).aspx
    https://www.pjrc.com/tech/8051/ide/fat32.html
    http://www.cplusplus.com/forum/windows/18019/

    Aber Achtung, mit low lewel basteleien kannst du dir dein System zerschießen, dafür übernehme ich keine Verantwortung, wünsche dir aber viel Erfolg und viel Spaß.



  • computernerds schrieb:

    ah ok. In Java ist das egal. Der Compiler geht 2mal ueber die Datei.

    C++ ist nicht Java.

    computernerds schrieb:

    Dass wenn man z.B. an eine Datei am Ende was anhaengen moechte dieser Speicherplatz freigegeben wird und die komplette Datei woanders hinkopiert wird, das wusste ich nicht.

    Das stimmt ja auch nicht und das habe ich auch garnicht behauptet.

    DirkB schrieb:

    Wenn du eine bestehende Datei zum Schreiben öffnest,

    Schreiben (write) ist etwas anderes als Anhägen (append) und auch als Lesen (read).
    Es gibt Kombinationen aus den Modi, aber auch da muss man aufpassen und wissen, was dabei passiert.



  • Mal nee amateur Frage. Woher kennt das Betriebssystem eigentlich den Prozessor Befehl um etwas auf die Festplatte zu schreiben. Wenn man ein Betriebssystem installiert,
    dann weiss dieses nicht auf welchem Prozessor es laufen wird. Oder hat das Betriebssystem als Standard den Befehlssatz von Intel und AMD dabei ?



  • computernerds schrieb:

    Mal nee amateur Frage. Woher kennt das Betriebssystem eigentlich den Prozessor Befehl um etwas auf die Festplatte zu schreiben. Wenn man ein Betriebssystem installiert,
    dann weiss dieses nicht auf welchem Prozessor es laufen wird. Oder hat das Betriebssystem als Standard den Befehlssatz von Intel und AMD dabei ?

    Das BIOS benutzt Standardkommandos, die mit jeder Hardware funktionieren sollte. In. der Regel, stammt das Bios eh vom Mainboardhersteller oder wurde zumindest von diesem getestet.

    Das OS lädt dann den optimalen Treiber beim Booten.

    VG



  • Wenn ich einen Intel i7 Prozessor habe, dann laedt das Betriebssystem den Befehlssatz dafuer beim Booten. So versteh ich das jetzt mal...



  • computernerds schrieb:

    Wenn ich einen Intel i7 Prozessor habe, dann laedt das Betriebssystem den Befehlssatz dafuer beim Booten. So versteh ich das jetzt mal...

    So ungefähr. Wobei eher der Chipsatz und die Schnittstelle die erforderlichen Kommandos bestimmen. Die CPU hat hier eher weniger Einfluß.

    VG



  • computernerds schrieb:

    Mal nee amateur Frage. Woher kennt das Betriebssystem eigentlich den Prozessor Befehl um etwas auf die Festplatte zu schreiben. Wenn man ein Betriebssystem installiert,
    dann weiss dieses nicht auf welchem Prozessor es laufen wird. Oder hat das Betriebssystem als Standard den Befehlssatz von Intel und AMD dabei ?

    Nun, Intel und AMD haben durchaus gemeinsame Befehle, sonst wären sie nicht kompatibel.

    Wikipedia: Real Mode schrieb:

    Jeder x86-kompatible Prozessor startet nach dem Reset im Real Mode.

    Ob der I7 noch dazu gehört, weiß ich aber nicht.

    Es gibt dann noch die Spezialbefehle, die einige Berechnungen schneller machen und (noch) nicht kompatibel sind.
    Aber dafür hat das Betriebssystem meist keine Verwendung.
    Und wenn doch, dann gibt es eine spezielle DLL für den Prozessor.


Log in to reply