Продвинутый алгоритм безопасного уничтожения данных (ASDA)
Следующее поколение безопасного стирания данных.

Документация по исходному коду:

Функция ASDAErase в классе DataShredder используется для безопасного удаления данных из файла. Этот процесс включает четыре последовательных шага.

Первый шаг — перезапись всех данных в файле определённым шаблоном. Это делается с помощью функции memset, которая устанавливает блок памяти в определённое значение.

Второй шаг — шифрование оригинальных данных в файле с использованием 256-битного AES (Advanced Encryption Algorithm). Это осуществляется с помощью класса AES, у которого есть метод StartEncryption, принимающий массив типа unsigned char в качестве входных данных. Данные для шифрования передаются в этот метод как аргумент.

Третий шаг включает проверку данных, записанных на втором этапе. Это делается путем считывания данных из файла и сравнения их с оригиналом с помощью функции memcmp. Если считанные данные не совпадают с оригинальными, возвращается код состояния 0xC0000719L (STATUS_CONTEXT_MISMATCH).

Наконец, последний шаг — перезапись данных в файле случайным шаблоном. Это делается с помощью функции DoRandomErase, которая принимает три аргумента: размер данных для удаления, буфер для хранения данных и байт, представляющий номер итерации.

Если все четыре шага завершаются успешно, функция ASDAErase возвращает код состояния 0. Если какой-либо шаг завершается неудачно, возвращается соответствующий код ошибки.

Исходный код:

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;
}

Объяснение исходного кода:

Этот исходный код определяет функцию ASDAErase, которая принимает три параметра: целочисленный размер, указатель buf на массив байтов и целое значение итерации. Функция возвращает значение статуса типа long.

Функция начинается с объявления и инициализации некоторых переменных. Затем она считывает текущий указатель файла с помощью функции GetFilePointer объекта класса LowLevelIO. Затем она выделяет память для рабочего буфера buf1 и считывает содержимое файла в этот буфер с помощью функции Read того же объекта LowLevelIO.

Затем функция затирает данные в файле значением 0xFF, записывая это значение в файл с помощью функции Write объекта LowLevelIO, а затем шифрует оригинальное содержимое файла с помощью алгоритма AES (Advanced Encryption Standard). Она генерирует случайный ключ, настраивает параметры шифрования AES и шифрует содержимое файла блоками по 4 байта с использованием функции StartEncryption.

Затем функция записывает зашифрованные данные обратно в файл, после чего перезаписывает файл шаблоном из значений 0x92, 0x49 и 0x24 в повторяющемся порядке. Далее она проверяет корректность записи данных с помощью функций Read и memcmp, сравнивая данные в рабочем буфере buf1 с шаблоном данных в buf.

Если все эти операции выполнены успешно, функция вызывает другую функцию под названием DoRandomErase для перезаписи файла случайными данными. В завершение функция освобождает память, выделенную для buf1, и возвращает значение статуса.