Algorithme avancé d’effacement sécurisé (ASDA)
La nouvelle génération d’effacement sécurisé des données.

Documentation sur le code source :

La fonction ASDAErase dans la classe DataShredder est utilisée pour supprimer les données d’un fichier de manière sécurisée. Ce processus comprend quatre étapes, exécutées dans un ordre séquentiel.

La première étape consiste à écraser toutes les données du fichier avec un motif spécifique. Cela se fait à l’aide de la fonction memset, qui remplit un bloc mémoire avec une valeur donnée.

La deuxième étape est de chiffrer les données originales du fichier en utilisant l’algorithme AES 256 bits (Advanced Encryption Standard). Cela est réalisé avec la classe AES, qui possède une méthode StartEncryption prenant en entrée un tableau de unsigned char. Les données à chiffrer sont passées à cette méthode en argument.

La troisième étape consiste à vérifier les données écrites dans le fichier lors de la deuxième étape. Cela se fait en relisant les données du fichier et en les comparant aux données originales via la fonction memcmp. Si les données lues ne correspondent pas aux données originales, une valeur de statut 0xC0000719L (STATUS_CONTEXT_MISMATCH) est retournée.

Enfin, la dernière étape consiste à écraser les données dans le fichier avec un motif aléatoire. Cela se fait à l’aide de la fonction DoRandomErase, qui prend trois arguments : la taille des données à effacer, un buffer pour contenir les données, et une valeur de type byte représentant le numéro d’itération.

Si les quatre étapes sont terminées avec succès, la fonction ASDAErase retourne une valeur de statut de 0. Si une étape échoue, un code d’erreur approprié est retourné.

Code source :

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

Explication du code source :

Ce code source définit une fonction appelée ASDAErase, qui prend trois paramètres : un entier size, un pointeur buf vers un tableau d’octets, et un entier iteration. La fonction retourne un entier status.

La fonction commence par déclarer et initialiser plusieurs variables. Elle lit ensuite le pointeur de fichier courant en utilisant la fonction GetFilePointer d’un objet de la classe LowLevelIO. Puis elle alloue de la mémoire pour un buffer de travail buf1 et lit le contenu du fichier dans ce buffer via la fonction Read du même objet LowLevelIO.

La fonction efface ensuite les données dans le fichier avec la valeur 0xFF en écrivant cette valeur dans le fichier via la fonction Write de l’objet LowLevelIO, puis elle chiffre le contenu original du fichier en utilisant l’algorithme AES (Advanced Encryption Standard). Elle génère pour cela une clé aléatoire, configure les paramètres du chiffrement AES, puis chiffre le contenu du fichier par blocs de 4 octets à l’aide de la fonction StartEncryption.

La fonction réécrit ensuite les données chiffrées dans le fichier, puis écrase le fichier avec un motif répétitif de 0x92, 0x49 et 0x24 dans cet ordre. Elle vérifie ensuite que les données ont été correctement écrites à l’aide de la fonction Read et de memcmp, qui compare les données dans le buffer de travail buf1 avec celles du motif dans buf.

Si toutes ces opérations réussissent, la fonction appelle alors une autre fonction appelée DoRandomErase pour écraser le fichier avec des données aléatoires. Enfin, la fonction libère la mémoire allouée à buf1 et retourne la valeur de statut.