नया!
Advanced Secure Deletion Algorithm (ASDA)
सुरक्षित डेटा मिटाने की अगली पीढ़ी।
ASDA अत्यंत प्रभावी, सत्यापित डेटा मिटाने को न्यूनतम संसाधन खपत के साथ सक्षम बनाता है। चार पास दक्षता और पारदर्शिता के लिए डिज़ाइन किए गए हैं: रीड‑आफ्टर‑राइट सत्यापन और विलोपन लॉग हर कदम का दस्तावेजीकरण करते हैं। AES‑256 और क्रिप्टोग्राफिक रूप से मजबूत यादृच्छिक संख्याएं फोरेंसिक पुनर्निर्माण को काफी कठिन बनाती हैं। यह कार्यान्वयन मौजूदा प्रक्रियाओं में सहजता से एकीकृत होता है।
ASDA NIST SP 800‑88 Rev. 1 (क्लियर / पर्ज / डेस्ट्रॉय) की आवश्यकताओं से भी अधिक है। माध्यम (HDD/SSD/फ्लैश) के आधार पर, अतिरिक्त पर्ज तंत्र उपयुक्त हो सकते हैं—जैसे ब्लॉक इरेज़ या क्रिप्टोग्राफिक इरेज़।
चार पास का अवलोकन
डेटा क्षेत्र को पूरी तरह से 0xFF से ओवरराइट किया जाता है—मूल सामग्री पुनर्प्राप्त नहीं की जा सकती।
मूल बफ़र सामग्री को AES‑256 के साथ एन्क्रिप्ट किया जाता है और वापस लिखा जाता है—फोरेंसिक पुनर्निर्माण के खिलाफ एक क्रिप्टोग्राफिक बाधा बनाते हुए। (कुंजी केवल अस्थायी रूप से RAM में रहती हैं और बाद में सुरक्षित रूप से मिटा दी जाती हैं।)
एक परिभाषित बिट पैटर्न (जैसे, 10010010 01001001 00100100) लिखा जाता है, इसके बाद रीड‑आफ्टर‑राइट सत्यापन होता है। विचलन को फिर से ओवरराइट किया जाता है और इरेज़र रिपोर्ट में दर्ज किया जाता है।
अंत में, ASDA क्षेत्र को क्रिप्टोग्राफिक रूप से मजबूत यादृच्छिक संख्याओं (NIST SP 800‑90A के अनुसार CSPRNG) से ओवरराइट करता है।
स्रोत कोड के बारे में दस्तावेज़:
DataShredder क्लास में ASDAErase फ़ंक्शन का उपयोग फ़ाइल से डेटा को सुरक्षित रूप से हटाने के लिए किया जाता है। यह प्रक्रिया चार चरणों में पूरी होती है, जो क्रमिक रूप से किए जाते हैं।
पहला चरण फ़ाइल में सभी डेटा को एक विशिष्ट पैटर्न से ओवरराइट करना है। यह memset फ़ंक्शन का उपयोग करके किया जाता है, जो मेमोरी के एक ब्लॉक को एक विशिष्ट मान पर सेट करता है।
दूसरा चरण फ़ाइल में मूल डेटा को 256-बिट AES (एडवांस्ड एन्क्रिप्शन एल्गोरिदम) का उपयोग करके एन्क्रिप्ट करना है। यह 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);
// कार्यशील बफ़र
byte *buf1 = (byte*)malloc(size);
// फ़ाइल सामग्री पढ़ें
if(iteration == 0) {
status=this->m_pLowLevelIO->Read(buf1, size, NULL);
this->m_pLowLevelIO->SetFilePointer(&nCurrentFilePointer);
}
// 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);
}
// मूल फ़ाइल सामग्री को एन्क्रिप्ट करें
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);
// सत्यापित करें
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 नामक एक फ़ंक्शन को परिभाषित करता है, जो तीन पैरामीटर लेता है: एक पूर्णांक size, एक बाइट एरे के लिए पॉइंटर buf, और एक पूर्णांक iteration। यह फ़ंक्शन एक पूर्णांक मान status लौटाता है।
फ़ंक्शन कुछ वेरिएबल घोषित और प्रारंभ करता है। फिर यह LowLevelIO क्लास के एक ऑब्जेक्ट की GetFilePointer फ़ंक्शन का उपयोग करके वर्तमान फ़ाइल पॉइंटर पढ़ता है। इसके बाद यह कार्यशील बफ़र buf1 के लिए मेमोरी आवंटित करता है और उसी LowLevelIO ऑब्जेक्ट की Read फ़ंक्शन का उपयोग करके फ़ाइल सामग्री इस बफ़र में पढ़ता है।
फिर फ़ंक्शन फ़ाइल में डेटा को 0xFF मान से मिटाता है, इसे Write फ़ंक्शन के माध्यम से फ़ाइल में लिखता है, और फिर AES (एडवांस्ड एन्क्रिप्शन स्टैंडर्ड) एल्गोरिदम का उपयोग करके मूल फ़ाइल सामग्री को एन्क्रिप्ट करता है। यह एक यादृच्छिक कुंजी उत्पन्न करके और AES एन्क्रिप्शन पैरामीटर सेट करके करता है, और फिर StartEncryption फ़ंक्शन का उपयोग करके 4 बाइट के ब्लॉकों में फ़ाइल सामग्री को एन्क्रिप्ट करता है।
फ़ंक्शन फिर एन्क्रिप्टेड डेटा को फ़ाइल में वापस लिखता है, और फिर 0x92, 0x49, और 0x24 के पैटर्न से फ़ाइल को ओवरराइट करता है। इसके बाद यह Read फ़ंक्शन और memcmp फ़ंक्शन का उपयोग करके कार्यशील बफ़र buf1 में डेटा की तुलना पैटर्न डेटा buf से करता है ताकि पुष्टि हो सके कि डेटा सही लिखा गया है।
यदि ये सभी ऑपरेशन सफल होते हैं, तो फ़ंक्शन DoRandomErase नामक एक अन्य फ़ंक्शन को कॉल करता है जो फ़ाइल को यादृच्छिक डेटा से ओवरराइट करता है। अंत में, फ़ंक्शन buf1 के लिए आवंटित मेमोरी मुक्त करता है और status मान लौटाता है।