जावा फ़ाइल ओवरराइटिंग

प्रोजेक्ट विकसित करते समय, इसके निष्पादन के दौरान एप्लिकेशन द्वारा बनाई गई फ़ाइलों को हटाना आवश्यक हो गया। लेकिन यह आवश्यक था कि सत्र के अंत में, पीसी के काम पर फ़ाइलों को हटाया नहीं गया था, लेकिन उपयोगकर्ता के अनुरोध पर।

और ऐसा लगता है कि कोई समस्या नहीं है। जावा मानक लाइब्रेरी में फ़ाइल हटाने के लिए java.io.File क्लास में एक डिलीट () विधि है।

File file = new File("path/to/file"); if (file.delete()) { System.out.println(file.getName() + " deleted"); } else { System.out.println(file.getName() + " not deleted"); } 

Java.io.File क्लास में डिलीट () विधि हुड के तहत एक फाइल को हटाने के लिए एक देशी फ़ंक्शन के आधार पर कॉल करता है, जो ओएस पर निर्भर करता है। और आधुनिक ऑपरेटिंग सिस्टम फ़ाइल को हटाते समय फ़ाइल को तुरंत नहीं हटाते हैं, लेकिन केवल फ़ाइल नाम को हटाते हैं। फ़ाइल की सामग्री बनी हुई है, और पहले से हटाई गई फ़ाइल द्वारा कब्जा की गई मेमोरी भविष्य में पुन: उपयोग की जा सकती है। लेकिन सभी समान, कुछ समय के लिए ऐसा लगता है कि पहले से ही हटाई गई फ़ाइल उपलब्ध है।

और यदि आप इंटरनेट पर देखते हैं, तो हटाए गए फ़ाइलों को पुनर्प्राप्त करने के लिए कई कार्यक्रम हैं, उदाहरण के लिए Recuva ।

लेकिन मैं चाहता हूं कि भविष्य में उन्हें पुनर्स्थापित करने की संभावना के बिना फाइलें हटा दी जाएं। इंटरनेट की खोज शुरू करना, यह बिना किसी पुनर्स्थापना (ओवरराइटिंग) के फ़ाइल को हटाने के लिए निकलता है, यह बहुत तुच्छ कार्य नहीं है। और इस तरह के कार्य को लागू करते समय, किसी विशेष ओएस में फाइलों के साथ काम करने की सुविधाओं को ध्यान में रखना आवश्यक है। और इस मामले में, आपको या तो मैन्युअल रूप से लिखित देशी एपीआई या किसी प्रकार के मूल पुस्तकालय का उपयोग करने की आवश्यकता है।

चूंकि एप्लिकेशन को उबंटू में विकसित किया गया था, यह ओएस कमांड-लाइन उपयोगिताओं के रूप में कई तैयार समाधान प्रदान करता है। उदाहरण के लिए, सिक्योर-डिलीट यूटिलिटी, जो आपको अलग-अलग तरीकों का उपयोग करके बिना रिकवरी के फाइल को डिलीट करने की अनुमति देती है।

 $ srm -vz private/* 

अनुप्रयोगों को यह जांचना चाहिए कि उपयोगिता स्थापित है या नहीं और एक त्रुटि प्रदर्शित करें यदि वह नहीं मिलती है। लेकिन दूसरे ओएस के लिए एप्लिकेशन का उपयोग करने के मामले में, आपको एक समान उपयोगिता का उपयोग करने की आवश्यकता है।

जो बहुत सुविधाजनक नहीं है और मैं इन समस्याओं से दूर जाना चाहता हूं। यदि आप सिक्योर-डिलीट यूटिलिटी के सोर्स कोड को देखते हैं, तो यह आपको अलग-अलग ऑपरेटिंग सिस्टम के तहत काम करने की अनुमति देता है। यह C99 में लिखा गया है और विभिन्न प्रीप्रोसेसिंग जादू और एक प्लेटफ़ॉर्म-विशिष्ट API का उपयोग करता है। त्रुटि के मामले में ऐसे मूल कोड को डीबग करना बहुत मुश्किल है और यह कार्य है।

यदि आप समझते हैं कि सिक्योर-डिलीट उपयोगिता कैसे काम करती है, तो निम्नलिखित चरणों को अलग किया जा सकता है।

• पहले, यह जाँचता है कि क्या फ़ाइल मौजूद है और अधिकार सही हैं।
• निर्दिष्ट एल्गोरिथ्म के आधार पर, फ़ाइल की सामग्री को ओवरराइट करता है।
• फ़ाइल का आकार शून्य बाइट्स तक कम कर देता है।
• फ़ाइल को वर्णों का एक यादृच्छिक अनुक्रम नाम देता है।
• फ़ाइल को हटाता है।

सुरक्षित-डिलीट विभिन्न एल्गोरिदम को किसी फ़ाइल की सामग्री को अधिलेखित करने की अनुमति देता है:

• सरल एल्गोरिथ्म - 1 पास 0x00 बाइट्स के साथ ओवरराइट करता है।
• डीओई एल्गोरिथ्म - 3 के साथ ओवरराइट करता है यादृच्छिक, यादृच्छिक, "डू"।
• RCMP एल्गोरिथ्म - 3 पास 0x00, 0xFF, "RCMP" के साथ।
• OPENBSD एल्गोरिथ्म - 3 पास 0xFF, 0x00, 0xFF बाइट्स के साथ ओवरराइट करता है।
• डीओडी एल्गोरिथ्म - 7 पास ओवरराइट करता है।
• गुटमैन एल्गोरिथ्म - 35 पास ओवरराइट करता है।

मैं चाहता हूं कि कोड प्लेटफ़ॉर्म-स्वतंत्र हो और विभिन्न ऑपरेटिंग सिस्टम के तहत काम करे। यदि आप आधुनिक C ++ को देखते हैं, तो फ़ाइलों को अधिलेखित करने के लिए सुरक्षित-डिलीट करने वाले सभी चरण किए जा सकते हैं।

यह जाँचने के लिए कि क्या कोई फ़ाइल मौजूद है और क्या इसके सही अधिकार हैं, आप std :: filesystem का उपयोग कर सकते हैं, जिसे C ++ 17 में जोड़ा गया था।

मानक के पिछले संस्करणों के लिए, बढ़ावा :: फाइलसिस्टम का उपयोग किया जा सकता है।

 namespace fs = std::filesystem; if (!fs::exists(file)) { env->ThrowNew(exception_class, "File doesn't exist"); } if (!fs::is_regular_file(file)) { env->ThrowNew(exception_class, "Path doesn't regular file or symlink"); } if (!eraser.check_permision(file, fs::status(file).permissions())) { env->ThrowNew(exception_class, "File hasn't enough permision (maybe not user)"); } bool kl::erase_content::check_permision(const fs::path& entry, fs::perms permision) { try { fs::permissions(entry, fs::perms::owner_read | fs::perms::owner_write, fs::perm_options::add); return true; } catch (fs::filesystem_error& e) { return false; } } 

फ़ाइल की सामग्री को अधिलेखित करने के लिए, चुने हुए एल्गोरिथ्म के आधार पर, आप कार्यान्वयन को सुरक्षित-डिलीट के रूप में छोड़ सकते हैं।

 bool kl::erase_content::overwrite() { switch (entry.get_mode()) { case kl::overwrite_mode::SIMPLE_MODE: if (!overwrite_byte(1, 0x00)) { return false; } break; case kl::overwrite_mode::DOE_MODE: if (!overwrite_random(1)) { return false; } if (!overwrite_random(2)) { return false; } if (!overwrite_bytes(3, "DoE")) { return false; } break; case kl::overwrite_mode::OPENBSD_MODE: /* override OPENBSD_MODE method */ break; case kl::overwrite_mode::RCMP_MODE: /* override RCMP_MODE method */ break; case kl::overwrite_mode::DOD_MODE: /* override DOD_MODE method */ break; case kl::overwrite_mode::GUTMAN_MODE: /* override GUTMAN_MODE method */ break; default: std::cerr << "overwrite mode doesn't choose" << std::endl; } return true; } 

एल्गोरिथ्म के आधार पर, एक निश्चित आकार के एक बफ़र को एक निश्चित डेटा सेट से भरा जाता है, और इस बफ़र को एक फ़ाइल में तब तक लिखता है जब तक कि यह अंत तक नहीं पहुंच जाता।

 bool kl::erase_content::overwrite_byte(const int pass, const uint8_t byte) { const auto& [file_name, file_size, buffer_size, mode] = entry; this->buffer = std::make_unique<uint8_t[]>(buffer_size); std::memset(buffer.get(), byte, buffer_size); this->file = kl::fs_util::make_open_file(file_name, "r+b"); if (!overwrite_data(pass)) { return false; } return true; } bool kl::erase_content::overwrite_data(const int pass) { const auto& [file_name, file_size, buffer_size, mode] = entry; const size_t count = file_size / buffer_size; const size_t tail = file_size % buffer_size; size_t writted = 0; if (fseek(file.get(), 0, SEEK_SET) != 0) { std::cerr << "couldn't seek in file" << std::endl; return false; } writted = write_buffer(count, tail); if (writted != file_size) { std::cerr << "couldn't write buffer in file" << std::endl; return false; } fflush(file.get()); if (fseek(file.get(), 0, SEEK_SET) != 0) { std::cerr << "couldn't seek in file" << std::endl; return false; } file.reset(); return true; } 

फिर इसके लिए std :: filesystem :: resize_file () फ़ंक्शन का उपयोग करके फ़ाइल का आकार शून्य बाइट्स तक कम करें।

 try { fs::resize_file(file, 0); } catch (fs::filesystem_error& e) { env->ThrowNew(exception_class, "truncate file fail"); } 

अगला चरण है कि फ़ाइल का नाम बदलकर वर्णों का एक यादृच्छिक क्रम रखें, इसके लिए std :: random () और std :: filesystem :: file :: प्रतिस्थापित_filename () का उपयोग करें।

 std::string parent_path = file.parent_path(); std::string file_name = file.filename(); fs::path copy_file = file; file_name = random_text(file_name.size()); copy_file.replace_filename(fs::path(file_name)); try { fs::rename(file, copy_file); } catch (fs::filesystem_error& e) { env->ThrowNew(exception_class, "can't rename file"); } return true; 

और अंतिम चरण में, आपको बस इसके लिए std :: filesystem :: remove () का उपयोग करके फ़ाइल को हटाने की आवश्यकता है।

 try { fs::remove(copy_file); } catch (fs::filesystem_error& e) { env->ThrowNew(exception_class, "can't remove file"); } 

खैर, जावा में उपयोग के लिए आपको देशी तरीकों की घोषणा करने की आवश्यकता है।

 public class EraseFS { static { System.loadLibrary("jefl"); } public static native boolean eraseFile(String path) throws EraseException; public static native boolean eraseFile(String path, OverwrideMode mode) throws EraseException; public static native boolean eraseFiles(String... paths) throws EraseException; public static native boolean eraseFiles(OverwrideMode mode, String... paths) throws EraseException; public static native boolean eraseDirectory(String path, boolean recursived) throws EraseException; public static native boolean eraseDirectory(String path, OverwrideMode mode, boolean recursived) throws EraseException; } 

मूल कार्यान्वयन केवल मानक C ++ लाइब्रेरी का उपयोग करता है, जो अन्य प्लेटफार्मों पर पोर्ट करना आसान बनाता है। और सबसे महत्वपूर्ण बात, कोई प्रीप्रोसेसर मैक्रो जादू नहीं है, जो त्रुटियों के मामले में डीबग करना इतना आसान नहीं है।

मानक सी ++ 17 पहले से ही सभी लोकप्रिय संकलक द्वारा समर्थित है: एमवीएससी, क्लैंग, जीसीसी।
पूर्ण स्रोत कोड को github: कोड पर देखा जा सकता है।