Algoritmo Avançado de Eliminação Segura (ASDA)
A próxima geração de eliminação segura de dados.

Documentação sobre o código-fonte:

A função ASDAErase na classe DataShredder é usada para excluir dados de forma segura de um arquivo. Esse processo envolve quatro etapas, que são realizadas em ordem sequencial.

A primeira etapa é sobrescrever todos os dados do arquivo com um padrão específico. Isso é feito usando a função memset, que define um bloco de memória com um valor específico.

A segunda etapa é criptografar os dados originais do arquivo usando o algoritmo AES de 256 bits (Advanced Encryption Algorithm). Isso é feito utilizando a classe AES, que possui o método StartEncryption que recebe um array de unsigned char como entrada. Os dados a serem criptografados são passados como argumento para esse método.

A terceira etapa envolve a verificação dos dados que foram gravados no arquivo na segunda etapa. Isso é feito lendo os dados de volta do arquivo e comparando-os com os dados originais usando a função memcmp. Se os dados lidos do arquivo não corresponderem aos dados originais, um valor de status 0xC0000719L (STATUS_CONTEXT_MISMATCH) é retornado.

Finalmente, a última etapa é sobrescrever os dados do arquivo com um padrão aleatório. Isso é feito usando a função DoRandomErase, que recebe três argumentos: o tamanho dos dados a serem apagados, um buffer para armazenar os dados e um valor byte representando o número da iteração.

Se todas as quatro etapas forem concluídas com sucesso, a função ASDAErase retorna um valor de status igual a 0. Se qualquer uma das etapas falhar, um código de erro apropriado é retornado.

Código-fonte:

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

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

        // buffer de trabalho
        byte *buf1 = (byte*)malloc(size);

        // ler conteúdo do arquivo
        if(iteration == 0) {
                status=this->m_pLowLevelIO->Read(buf1, size, NULL);
                this->m_pLowLevelIO->SetFilePointer(&nCurrentFilePointer);
        }

        // sobrescrever com 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);      
        }

        // criptografar conteúdo original do arquivo
        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);

                // verificação
                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;
}

Explicação do código-fonte:

Este código-fonte define uma função chamada ASDAErase, que recebe três parâmetros: um inteiro size, um ponteiro buf para um array de bytes, e um inteiro iteration. A função retorna um valor inteiro status.

A função começa declarando e inicializando algumas variáveis. Em seguida, lê o ponteiro atual do arquivo usando a função GetFilePointer de um objeto da classe LowLevelIO. Depois, aloca memória para um buffer de trabalho buf1 e lê o conteúdo do arquivo nesse buffer usando a função Read do mesmo objeto LowLevelIO.

Em seguida, a função apaga os dados no arquivo com o valor 0xFF, escrevendo esse valor no arquivo com a função Write do objeto LowLevelIO, e então criptografa o conteúdo original do arquivo usando o algoritmo AES (Advanced Encryption Standard). Isso é feito gerando uma chave aleatória, configurando os parâmetros de criptografia AES, e então criptografando o conteúdo do arquivo em blocos de 4 bytes usando a função StartEncryption.

A função então grava os dados criptografados de volta no arquivo e, em seguida, sobrescreve o arquivo com um padrão de 0x92, 0x49 e 0x24 repetidos nessa ordem. Depois, verifica se os dados foram gravados corretamente usando a função Read e a função memcmp para comparar os dados no buffer de trabalho buf1 com os dados do padrão em buf.

Se todas essas operações forem bem-sucedidas, a função então chama outra função chamada DoRandomErase para sobrescrever o arquivo com dados aleatórios. Por fim, a função libera a memória alocada para buf1 e retorna o valor de status.