Algoritmo Avanzado de Eliminación Segura de Datos (ASDA)
La Próxima Generación de Borrado Seguro de Datos

Documentación sobre el código fuente:

La función ASDAErase en la clase DataShredder se utiliza para eliminar de forma segura los datos de un archivo. Este proceso consta de cuatro pasos, que se ejecutan en orden secuencial.

El primer paso consiste en sobrescribir todos los datos del archivo con un patrón específico. Esto se realiza utilizando la función memset, que establece un bloque de memoria con un valor determinado.

El segundo paso es cifrar los datos originales del archivo utilizando el algoritmo AES de 256 bits (Advanced Encryption Algorithm). Esto se realiza con la clase AES, que tiene un método StartEncryption que toma una matriz de unsigned char como entrada. Los datos que se van a cifrar se pasan como argumento a este método.

El tercer paso consiste en verificar los datos que fueron escritos en el segundo paso. Esto se hace leyendo nuevamente los datos del archivo y comparándolos con los originales mediante la función memcmp. Si los datos leídos no coinciden con los originales, se devuelve el valor de estado 0xC0000719L (STATUS_CONTEXT_MISMATCH).

Finalmente, el último paso es sobrescribir los datos del archivo con un patrón aleatorio. Esto se realiza mediante la función DoRandomErase, que toma tres argumentos: el tamaño de los datos a eliminar, un búfer para contener los datos, y un valor byte que representa el número de iteración.

Si los cuatro pasos se completan correctamente, la función ASDAErase devuelve un valor de estado de 0. Si alguno de los pasos falla, se devuelve un código de error correspondiente.

Código fuente:

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

Explicación del código fuente:

Este código fuente define una función llamada ASDAErase, que toma tres parámetros: un entero size, un puntero buf a un arreglo de bytes, y un entero iteration. La función devuelve un valor entero status.

La función comienza declarando e inicializando algunas variables. Luego lee el puntero actual del archivo usando la función GetFilePointer de un objeto de la clase LowLevelIO. Después, asigna memoria para un búfer de trabajo buf1 y lee el contenido del archivo en este búfer utilizando la función Read del mismo objeto LowLevelIO.

Luego, la función sobrescribe los datos del archivo con el valor 0xFF escribiéndolo en el archivo usando la función Write del objeto LowLevelIO, y después cifra el contenido original del archivo utilizando el algoritmo AES (Advanced Encryption Standard). Para ello, genera una clave aleatoria y configura los parámetros de cifrado AES, y luego cifra el contenido del archivo en bloques de 4 bytes usando la función StartEncryption.

La función escribe los datos cifrados de nuevo en el archivo, y luego sobrescribe el archivo con un patrón de 0x92, 0x49 y 0x24, repitiéndose en ese orden. Luego verifica que los datos se hayan escrito correctamente usando la función Read y comparándolos con memcmp entre el búfer buf1 y los datos en buf.

Si todas estas operaciones son exitosas, la función llama a otra función llamada DoRandomErase para sobrescribir el archivo con datos aleatorios. Finalmente, libera la memoria asignada a buf1 y devuelve el valor de status.