Advanced Secure Deletion Algorithm (ASDA)
Die nächste Generation sicherer Datenlöschung.

Dokumentation zum Quellcode:

Die Funktion ASDAErase in der Klasse DataShredder wird verwendet, um Daten sicher aus einer Datei zu löschen. Dieser Prozess umfasst vier Schritte, die nacheinander ausgeführt werden.

Der erste Schritt besteht darin, alle Daten in der Datei mit einem bestimmten Muster zu überschreiben. Dies geschieht mit der Funktion memset, die einen Speicherblock auf einen bestimmten Wert setzt.

Im zweiten Schritt werden die Originaldaten in der Datei mit dem 256-Bit-AES-Algorithmus (Advanced Encryption Standard) verschlüsselt. Dies geschieht mit der Klasse AES, die eine Methode StartEncryption besitzt, welche ein Array von unsigned char als Eingabe erwartet. Die zu verschlüsselnden Daten werden dieser Methode als Argument übergeben.

Der dritte Schritt besteht darin, die im zweiten Schritt geschriebenen Daten zu verifizieren. Dazu werden die Daten aus der Datei gelesen und mit den Originaldaten mithilfe der Funktion memcmp verglichen. Wenn die gelesenen Daten nicht mit den Originaldaten übereinstimmen, wird der Statuswert 0xC0000719L (STATUS_CONTEXT_MISMATCH) zurückgegeben.

Im letzten Schritt werden die Daten in der Datei mit einem zufälligen Muster überschrieben. Dies geschieht mit der Funktion DoRandomErase, die drei Argumente erwartet: die Größe der zu löschenden Daten, einen Puffer zum Speichern der Daten und einen Byte-Wert, der die Iteration darstellt.

Wenn alle vier Schritte erfolgreich abgeschlossen werden, gibt die Funktion ASDAErase den Statuswert 0 zurück. Falls ein Schritt fehlschlägt, wird ein entsprechender Fehlercode zurückgegeben.

Quellcode:

long DataShredder::ASDAErase(DWORD size, byte *buf, byte iteration)
{
    long status=0;

        LARGE_INTEGER nCurrentFilePointer = {0};
        this->m_pLowLevelIO->GetFilePointer(&nCurrentFilePointer);

        // working buffer
        byte *buf1 = (byte*)malloc(size);

        // read file content
        if(iteration == 0) {
                status=this->m_pLowLevelIO->Read(buf1, size, NULL);
                this->m_pLowLevelIO->SetFilePointer(&nCurrentFilePointer);
        }

        // wipe with 0xFF
        if(status == 0)
        {
                memset(buf, 0xFF, size);

                status=this->m_pLowLevelIO->Write(buf, size, NULL);
                if(!m_noBuffering)
                        this->m_pLowLevelIO->Flush();
                this->m_pLowLevelIO->SetFilePointer(&nCurrentFilePointer);      
        }

        // encrypt original file content
        if(status == 0)
        {
                ULONG K[8];

                ULONG seed;
                seed=GetTickCount();
                K[0]=LowLevel::IO::Random(&seed);
                K[1]=LowLevel::IO::Random(&seed);
                K[2]=LowLevel::IO::Random(&seed);
                K[3]=LowLevel::IO::Random(&seed);
                K[4]=LowLevel::IO::Random(&seed);
                K[5]=LowLevel::IO::Random(&seed);
                K[6]=LowLevel::IO::Random(&seed);
                K[7]=LowLevel::IO::Random(&seed);

                AES aes;
                aes.SetParameters(256);
                aes.StartEncryption((const unsigned char *)K);
                
                for(ULONG i=0; (i*4)m_pLowLevelIO->Write(buf, size, NULL);

                if(!m_noBuffering)
                        this->m_pLowLevelIO->Flush();
                this->m_pLowLevelIO->SetFilePointer(&nCurrentFilePointer);      
        }

        if(status == 0)
        {
                byte bData[] = {
                        0x92,//10010010,
                        0x49,//01001001,
                        0x24 //00100100
                };
                for(DWORD i = 0; i < size; i++)
                {
                        buf[i] = bData[i%3];
                }

                status=this->m_pLowLevelIO->Write(buf, size, NULL);
                if(!m_noBuffering)
                        this->m_pLowLevelIO->Flush();
                this->m_pLowLevelIO->SetFilePointer(&nCurrentFilePointer);

                // verify
                if(0==this->m_pLowLevelIO->Read(buf1, size, NULL))
                {
                        this->m_pLowLevelIO->SetFilePointer(&nCurrentFilePointer);      

                        if(memcmp(buf1, buf, size))
                        {
                                status=0xC0000719L;//STATUS_CONTEXT_MISMATCH;
                        }
                }
                else
                {
                        status=0xC0000719L;//STATUS_CONTEXT_MISMATCH;
                }
                
        }

        if(status == 0)
        {
                status = this->DoRandomErase(size, buf, 0);
        }

        free(buf1);

    return status;
}

Erklärung des Quellcodes:

Dieser Quellcode definiert eine Funktion namens ASDAErase, die drei Parameter übernimmt: eine Ganzzahl size, einen Zeiger buf auf ein Byte-Array und eine Ganzzahl iteration. Die Funktion gibt einen Ganzzahlwert status zurück.

Die Funktion beginnt mit der Deklaration und Initialisierung einiger Variablen. Anschließend liest sie den aktuellen Dateizeiger mit der Funktion GetFilePointer eines Objekts der Klasse LowLevelIO aus. Dann wird Speicher für einen Arbeits-Puffer buf1 reserviert und der Dateiinhalt mit der Funktion Read gelesen.

Die Funktion überschreibt dann die Daten in der Datei mit dem Wert 0xFF, indem sie diesen mit der Funktion Write in die Datei schreibt. Danach verschlüsselt sie den ursprünglichen Dateiinhalt mit dem AES-Algorithmus. Dazu wird ein zufälliger Schlüssel generiert, die AES-Parameter gesetzt und der Inhalt blockweise mit der Methode StartEncryption verschlüsselt.

Anschließend wird der verschlüsselte Inhalt zurück in die Datei geschrieben und die Datei mit einem sich wiederholenden Muster aus 0x92, 0x49 und 0x24 überschrieben. Danach wird überprüft, ob die Daten korrekt geschrieben wurden, indem sie erneut mit der Funktion Read gelesen und mithilfe von memcmp mit dem Muster verglichen werden.

Wenn all diese Operationen erfolgreich sind, wird abschließend die Funktion DoRandomErase aufgerufen, um die Datei mit zufälligen Daten zu überschreiben. Schließlich wird der reservierte Speicher für buf1 freigegeben und der Statuswert zurückgegeben.