ब्राउज़र में AES-256-GCM से फ़ाइलें एन्क्रिप्ट करें

ब्राउज़र में AES-256-GCM से किसी फ़ाइल को एन्क्रिप्ट करना का अर्थ है — क्लाउड ड्राइव, ईमेल अटैचमेंट या USB स्टिक, कहीं भी जाने से पहले — अपनी ही मशीन पर, अपने चुने हुए पासवर्ड से निकाली गई कुंजी से फ़ाइल को सिफरटेक्स्ट में बदलना। एन्क्रिप्शन पेज के अंदर WebCrypto से चलता है, और फ़ाइल व पासवर्ड कभी ब्राउज़र नहीं छोड़ते। यह मायने रखता है क्योंकि फ़ाइल किसी ऐसे संदेश जैसी नहीं है जिसे दोबारा टाइप किया जा सके: वह स्वयं रहस्य है। कोई चैट AES-GCM का वर्णन कर सकती है, पर आपकी असली फ़ाइल को एन्क्रिप्ट नहीं कर सकती — और फ़ाइल को चैट में चिपकाना या "ऑनलाइन एन्क्रिप्ट" का दावा करने वाली किसी भी साइट पर अपलोड करना, सादा पाठ पहले किसी अजनबी को सौंपना है। आप फ़ाइल एन्क्रिप्टर में फ़ाइलों को एन्क्रिप्ट और डिक्रिप्ट कर सकते हैं — पूरी तरह अपने ब्राउज़र में, बिना आकार सीमा के।

आपकी फ़ाइल ही रहस्य है — उसे कभी चैट में न चिपकाएँ, किसी भी साइट पर अपलोड न करें

लोग पासवर्ड के प्रति सावधान रहते हैं और फ़ाइलों के प्रति लापरवाह, जबकि फ़ाइलें ज़्यादा बुरा रिसाव हैं। पासवर्ड बदला जा सकता है; फ़ाइल एक बार पढ़ी जाए तो उसे "अनपढ़ा" नहीं किया जा सकता। एक टैक्स रिटर्न, अनुबंध का मसौदा, पहचान पत्र का स्कैन, पारिवारिक तस्वीरों का फ़ोल्डर — हर एक में ऐसी जानकारी होती है जो वर्षों तक संवेदनशील रहती है, और एक बार जब उसकी प्रति आपकी मशीन से बाहर निकल जाए तो आप उसे वापस नहीं बुला सकते। यह इस लेख का पहला नियम है: कभी किसी फ़ाइल को चैट में न चिपकाएँ, और उसे कभी ऐसी किसी साइट पर अपलोड न करें जिसका भरोसे का एकमात्र प्रमाण "ऑनलाइन एन्क्रिप्ट" वाक्य हो। जो सेवा आपकी फ़ाइल को आपके लिए एन्क्रिप्ट करती है, उसने परिभाषा से ही सादा पाठ देख लिया है। अगर वह हैक हो जाए, बिक जाए, या बस अपलोड लॉग कर रही हो, तो उसके बाद लगाया गया एन्क्रिप्शन सिर्फ़ सजावट है।

ब्राउज़र-स्थानीय एन्क्रिप्शन इस क्रम को उलट देता है। फ़ाइल पेज द्वारा पढ़ी जाती है, आपकी मशीन पर टुकड़ा-दर-टुकड़ा एन्क्रिप्ट होती है, और बाहर सिर्फ़ सिफरटेक्स्ट जाता है — आपके डाउनलोड फ़ोल्डर में, और वहाँ से जहाँ आप उसे रखना तय करें। साइट को कभी फ़ाइल, पासवर्ड या कुंजी नहीं मिलती, क्योंकि उन्हें पाने वाला कोई सर्वर पक्ष है ही नहीं: यह टूल एक स्थिर पेज है। यही तर्क बताता है कि यह टूल चैटबॉट का जवाब बनने के बजाय क्यों मौजूद है। चैटबॉट AES-GCM को पूरी तरह समझा सकता है और फिर भी आपकी असली फ़ाइल को एन्क्रिप्ट नहीं कर सकता, और जिस पल आप फ़ाइल चिपकाते हैं ताकि वह ऐसा करे, आप सादा पाठ उसी पक्ष को सौंप चुके होते हैं जिससे आप उसे बचाना चाहते थे। अगर किसी कार्यप्रवाह को फ़ाइल की ही ज़रूरत है, तो काम वहीं होना चाहिए जहाँ फ़ाइल पहले से है — आपकी मशीन पर।

AES-256-GCM सरल भाषा में: एक कुंजी, हर टुकड़े पर एक नई जाँच

AES-256-GCM एक ही एल्गोरिदम में दो गारंटियाँ समेटता है, और फ़ाइलों के लिए दोनों मायने रखती हैं। "AES-256" वाला हिस्सा सिफर है: 256-बिट कुंजी डेटा के हर ब्लॉक को इतनी गहराई से उलझा देती है कि जिस कुंजी का कोई अंदाज़ा नहीं लगा सकता, उसके साथ सिफरटेक्स्ट सादा पाठ के बारे में कुछ भी नहीं बताता। "GCM" वाला हिस्सा प्रमाणीकरण है: फ़ाइल के हर टुकड़े के लिए एल्गोरिदम 16-बाइट का टैग गिनता है — उस टुकड़े, उसकी स्थिति और कुंजी की उँगलियों के निशान। डिक्रिप्शन टैग को फिर से गिनकर मिलाता है; अगर एक भी बाइट बदल जाए — ट्रांज़िट में एक बिट पलट जाए, पासवर्ड गलत हो, किसी टुकड़े को दूसरी फ़ाइल के टुकड़े से बदल दिया जाए — तो टैग मेल नहीं खाता और डिक्रिप्शन चुपचाप दूषित डेटा सौंपने के बजाय मना कर देता है।

यह दूसरी गारंटी ही वजह है कि GCM फ़ाइलों के लिए पुराने CBC मोड से बेहतर है, और अंतर समझने लायक है। CBC हर ब्लॉक को पिछले ब्लॉक से जोड़कर एन्क्रिप्ट करता है, पर उसके पास यह जानने का कोई अंतर्निहित तरीका नहीं है कि सिफरटेक्स्ट से छेड़छाड़ हुई है या नहीं: CBC फ़ाइल में बिट पलट सकने वाला हमलावर डिक्रिप्ट किए गए आउटपुट को अनुमानित तरीकों से बदल सकता है, और CBC के विरुद्ध क्लासिक पैडिंग-ओरेकल हमले ठीक इसी कमज़ोरी का फायदा उठाते हैं। CBC के साथ छेड़छाड़ पकड़ने के लिए अलग HMAC चाहिए, और उस रचना को सही करना ही वह जगह है जहाँ कार्यान्वयन गड़बड़ाते हैं। GCM जाँच को अंदर ही बना देता है — हर टुकड़ा अपना टैग लेकर चलता है, जो उसके सादा पाठ पर भरोसा करने से पहले जाँचा जाता है — इसलिए जोड़ने का कोई दूसरा तंत्र नहीं है, हमला करने का कोई पैडिंग नहीं है। एक कुंजी, एक एल्गोरिदम, गोपनीयता और प्रमाणीकरण एक साथ।

पासवर्ड या कुंजी-युग्म? साझा पासवर्ड कब सही उपकरण है

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

पासवर्ड तब जीतता है जब कुंजी-युग्म की सेटअप लागत ही वह वजह हो कि एन्क्रिप्शन होता ही नहीं — जो ज़्यादातर लोगों और ज़्यादातर फ़ाइलों के लिए आम मामला है। अपने भविष्य के स्वयं के लिए कोई फ़ाइल, किसी ऐसी ड्राइव पर बैकअप जिस पर आप पूरी तरह भरोसा नहीं करते, किसी सहकर्मी के लिए दस्तावेज़ जिसे आप पासवर्ड आमने-सामने दे सकते हैं: इनके लिए कोई कुंजी बुनियादी ढाँचा नहीं चाहिए, सिर्फ़ एक मज़बूत पासवर्ड और ऐसा प्रारूप चाहिए जिसे प्राप्तकर्ता खोल सके। इनके लिए फ़ाइल एन्क्रिप्टर इस्तेमाल करें। जब प्राप्तकर्ता अजनबी हो, जब फ़ाइल आपसे जोड़ी जा सकनी चाहिए, या जब आपको कई लोगों के लिए बिना उनके बीच एक रहस्य बाँटे एन्क्रिप्ट करना हो, तो इसके बजाय PGP सूट इस्तेमाल करें — वही साइट, वही "सब कुछ ब्राउज़र में" नियम, और संदेशों व पहचान के लिए सही उपकरण। जब कुंजी-युग्म वाले उपकरण की ज़रूरत थी तब पासवर्ड वाला उपकरण चुनना एक असली गलती है; पर कुंजी-युग्म वाला उपकरण चुनकर फिर सेटअप से हारकर कभी कुछ भी एन्क्रिप्ट न करना, ज़्यादा आम गलती है।

दूसरे टूल फ़ाइलों को 10 MB तक क्यों सीमित करते हैं — और स्ट्रीमिंग वह सीमा कैसे हटा देता है

अगर आपने कभी ऑनलाइन फ़ाइल एन्क्रिप्ट करने की कोशिश की है, तो आप उस सीमा से मिले होंगे: 10 MB, कभी-कभी उससे भी कम, और उससे बड़ी कोई भी चीज़ ठुकरा दी जाती है। यह सीमा कंजूसी नहीं है। ज़्यादातर टूल पूरी फ़ाइल को मेमोरी में पढ़ते हैं, उसे एक बार में एन्क्रिप्ट करते हैं, पूरा सिफरटेक्स्ट मेमोरी में रखते हैं, और फिर उसे डाउनलोड के रूप में पेश करते हैं — एक बड़ी फ़ाइल की चार प्रतियाँ एक साथ RAM में, साथ ही ब्राउज़र की अपनी सीमा कि मेमोरी में एक blob कितना बड़ा हो सकता है। 2 GB का वीडियो इस तरह एन्क्रिप्ट करने के लिए गीगाबाइट मेमोरी चाहिए, और साधारण मशीन पर यह सीधे विफल हो जाता है। इसलिए टूल इनपुट को उस आकार तक सीमित करता है जिसे वह झेल सके, और बड़ी फ़ाइलें बिना एन्क्रिप्ट के रह जाती हैं।

इसका हल है पूरी फ़ाइल को एक साथ पकड़े रहना बंद करना। एन्क्रिप्टर फ़ाइल को 1 MiB के टुकड़ों में पढ़ता है, एक टुकड़ा एन्क्रिप्ट करता है, उसका सिफरटेक्स्ट लिखता है, और अगला टुकड़ा पढ़ने से पहले उसे भूल जाता है — फ़ाइल कितनी भी बड़ी हो, मेमोरी का शिखर एक मेगाबाइट के पास ही रहता है। Chromium और Edge में आउटपुट फ़ाइल सिस्टम एक्सेस API से जाता है, इसलिए हर एन्क्रिप्ट किया गया टुकड़ा बनते ही डिस्क पर लिख दिया जाता है: सच्ची स्ट्रीमिंग, पाइपलाइन में कहीं भी पूरी फ़ाइल की बफ़रिंग नहीं। Firefox और Safari में यह API अभी नहीं है, इसलिए वहाँ टुकड़े अंत में एक डाउनलोड में इकट्ठा किए जाते हैं — पेज यह साफ़-साफ़ कहता है, और उन ब्राउज़रों पर बहुत बड़ी फ़ाइलों के लिए ईमानदार सलाह है कि इस काम के लिए Chromium ब्राउज़र इस्तेमाल करें। 1 MiB का टुकड़ा आकार फ़ाइल प्रारूप द्वारा तय है, कोई सेटिंग नहीं: डिक्रिप्टर यही उम्मीद करता है, और इसे तय रखना ही वह बात है जिससे इस टूल से बनी हर फ़ाइल प्रारूप के किसी भी अन्य कार्यान्वयन द्वारा पढ़ी जा सके।

प्रारूप, दस्तावेज़ीकृत: आपकी फ़ाइल इस साइट से बँधी नहीं है

एन्क्रिप्ट की गई फ़ाइल जिसे उसे बनाने वाली वेबसाइट के बिना खोला न जा सके, वह बैकअप नहीं, बंधक है। इसलिए कंटेनर प्रारूप टूल पेज पर पूरी तरह दस्तावेज़ीकृत है, और यह खंड उसका संक्षिप्त रूप है। .sysxenc फ़ाइल आठ मैजिक बाइट SYSXENC1 से शुरू होती है, फिर दो बाइट की हेडर लंबाई, फिर JSON हेडर: प्रारूप संस्करण, KDF नाम और पुनरावृत्ति संख्या, एक यादृच्छिक 16-बाइट सॉल्ट, 1 MiB का टुकड़ा आकार, मूल फ़ाइल नाम, सादा पाठ का आकार, सादा पाठ का SHA-256, और टाइमस्टैंप। बॉडी टुकड़ों का क्रम है, हर टुकड़े में चार-बाइट सिफरटेक्स्ट लंबाई, एक नया यादृच्छिक 12-बाइट IV, और 16-बाइट GCM टैग वाला सिफरटेक्स्ट होता है। कुंजी आपके पासवर्ड से PBKDF2-SHA-256 द्वारा 600,000 पुनरावृत्तियों के साथ निकाली जाती है — वह संख्या जिसकी OWASP सिफारिश करता है — और हर टुकड़ा अतिरिक्त डेटा से प्रमाणित होता है जो उसे इस फ़ाइल और उसकी स्थिति से बाँधता है: सटीक हेडर बाइट्स और टुकड़ा सूचकांक, इसलिए क्रम बदला गया या दूसरी फ़ाइल से जोड़ा गया टुकड़ा अपनी टैग जाँच में विफल रहता है।

यह सब लिखने का मतलब है कि कोई भी रीडर लागू कर सकता है, और नीचे दिया गया Python डिक्रिप्टर इसका प्रमाण है। वह सिर्फ़ मानक लाइब्रेरी और cryptography पैकेज का उपयोग करता है, हेडर पढ़ता है, कुंजी फिर से निकालता है, टुकड़ा-दर-टुकड़ा डिक्रिप्ट करके हर टैग जाँचता है, और अंत में सादा पाठ का SHA-256 जाँचता है — ठीक वही जो ब्राउज़र टूल करता है। उसे इस प्रारूप में बनी फ़ाइलों पर चलाया गया, जिसमें कई मेगाबाइट की फ़ाइल, खाली फ़ाइल, गलत पासवर्ड और छेड़छाड़ की गई फ़ाइल शामिल थीं, और हर मामले में उसका व्यवहार सही रहा। एक ईमानदार सीमा: OpenSSL कमांड लाइन इस खंडित प्रारूप को सीधे डिक्रिप्ट नहीं कर सकती, क्योंकि उसके पास प्रति-टुकड़ा IV, अतिरिक्त प्रमाणित डेटा और टैग व्यक्त करने का कोई तरीका नहीं है। यह प्रारूप के डिज़ाइन की विशेषता है, कोई रहस्य नहीं, और यह लेख इसके विपरीत दिखावा नहीं करेगा — नीचे दिया गया स्क्रिप्ट, या कोई भी AES-GCM कार्यान्वयन, इस्तेमाल करें।

विफलता मोड: एन्क्रिप्शन आपको किन चीज़ों से नहीं बचा सकता

पहला विफलता मोड वह है जिसके बारे में टूल सबसे ज़ोर से चेतावनी देता है, क्योंकि उसका कोई उपाय नहीं है: पासवर्ड खोया तो फ़ाइल गई। कोई रिकवरी नहीं, कोई "पासवर्ड भूल गए" लिंक नहीं, कहीं रखा कोई मास्टर कुंजी नहीं — कुंजी सिर्फ़ आपके पासवर्ड से निकाली जाती है, और उसके बिना सिफरटेक्स्ट यादृच्छिक बाइट्स से अलग नहीं किया जा सकता। मूल फ़ाइल हटाने से पहले पासवर्ड को किसी सुरक्षित जगह, फ़ाइल से अलग, लिख लें। दूसरा विफलता मोड कमज़ोर पासवर्ड है। 600,000 पुनरावृत्तियों वाला PBKDF2 अनुमान लगाने को धीमा करता है, पर "password123" को मज़बूत नहीं बना सकता: फ़ाइल पाने वाला हमलावर ऑफ़लाइन अनुमान लगा सकता है, जितनी तेज़ी से उसका हार्डवेयर इजाज़त दे, और उसे रोकने वाला कोई सर्वर नहीं है। ऐसा लंबा पासफ़्रेज़ इस्तेमाल करें जिसे आप याद रख सकें, छोटा पासवर्ड नहीं जिसे आप जल्दी टाइप कर सकें।

तीसरा और चौथा विफलता मोड उन चीज़ों के बारे में हैं जिन्हें एन्क्रिप्शन कवर नहीं करता। हेडर में मूल फ़ाइल नाम, फ़ाइल आकार और निर्माण समय सादे रूप में रखे जाते हैं — सामग्री गुप्त है, मेटाडेटा नहीं। अगर फ़ाइल नाम ही संवेदनशील है, तो एन्क्रिप्ट करने से पहले फ़ाइल का नाम बदल लें, और पहले दस्तावेज़ क्लीनर से गुज़ारने पर विचार करें, क्योंकि दस्तावेज़ों के अंदर भी अपना मेटाडेटा होता है: लेखक के नाम, संपादन इतिहास, एम्बेडेड थंबनेल। और किसी समझौता किए गए डिवाइस पर कोई एन्क्रिप्शन मदद नहीं करता। अगर जिस मशीन पर आप एन्क्रिप्ट कर रहे हैं, उस पर पहले से मैलवेयर चल रहा है, तो वह एन्क्रिप्शन से पहले फ़ाइल पढ़ सकता है और टाइप करते समय पासवर्ड पढ़ सकता है। एन्क्रिप्शन ट्रांज़िट में और विश्राम में फ़ाइल की रक्षा करता है; वह किसी ऐसी मशीन पर फ़ाइल की रक्षा नहीं करता जो पहले ही किसी और के कब्ज़े में है। यह एन्क्रिप्शन छोड़ने का कारण नहीं है — यह ठीक-ठीक जानने का कारण है कि वह आपको क्या देता है।

Python से .sysxenc फ़ाइल डिक्रिप्ट करें

#!/usr/bin/env python3
"""Decrypt a SYSXENC v1 file produced by the SysOSX file encryptor.

Format (SYSXENC v1), as documented at
https://www.sysosx.com/tools/file-encryptor/ :
  header: 8-byte magic b"SYSXENC1", u16BE header length, header JSON bytes
          {"v": 1, "kdf": "PBKDF2-SHA256", "iter": 600000,
           "salt": <base64, 16 bytes>, "chunkSize": 1048576,
           "name": <original filename>, "size": <plaintext bytes>,
           "sha256": <hex of plaintext>, "created": <ISO timestamp>}
  body:   chunks, each u32BE ciphertext length (ciphertext INCLUDING the
          16-byte GCM tag) + 12-byte random IV + ciphertext+tag.
          The last chunk may be shorter; an empty file has zero chunks.
  AAD per chunk: the exact header JSON bytes + u32LE chunk index.
  KDF: PBKDF2-HMAC-SHA-256, 600,000 iterations, 256-bit key.

Requires the `cryptography` package:  pip install cryptography

Note: OpenSSL's command-line tool cannot decrypt this chunked format
directly — it has no way to express per-chunk IVs, AAD, and tags — so
use this script (or any AES-GCM implementation) instead.

Usage:
  python3 sysxenc_decrypt.py encrypted.sysxenc decrypted.bin
  python3 sysxenc_decrypt.py encrypted.sysxenc decrypted.bin --password hunter2
  (without --password, the password is read securely from the terminal)
"""

import argparse
import base64
import getpass
import hashlib
import json
import struct
import sys

MAGIC = b"SYSXENC1"
HEADER_LEN_FMT = ">H"   # u16 big-endian
CHUNK_LEN_FMT = ">I"    # u32 big-endian
CHUNK_INDEX_FMT = "<I"  # u32 little-endian
IV_LEN = 12
TAG_LEN = 16
KEY_LEN = 32


def _read_exact(f, n, what):
    data = f.read(n)
    if len(data) != n:
        raise ValueError(f"truncated file: could not read {what}")
    return data


def decrypt_file(in_path, out_path, password):
    with open(in_path, "rb") as f:
        magic = _read_exact(f, 8, "magic")
        if magic != MAGIC:
            raise ValueError(
                f"bad magic {magic!r}: not a SYSXENC v1 file")
        (header_len,) = struct.unpack(
            HEADER_LEN_FMT, _read_exact(f, 2, "header length"))
        header_bytes = _read_exact(f, header_len, "header JSON")
        header = json.loads(header_bytes.decode("utf-8"))
        if header.get("v") != 1:
            raise ValueError(
                f"unsupported format version: {header.get('v')!r}")
        if header.get("kdf") != "PBKDF2-SHA256":
            raise ValueError(
                f"unsupported KDF: {header.get('kdf')!r}")
        iterations = int(header["iter"])
        salt = base64.b64decode(header["salt"])
        chunk_size = int(header["chunkSize"])
        expected_size = int(header["size"])
        expected_sha256 = header["sha256"]

        key = hashlib.pbkdf2_hmac(
            "sha256", password.encode("utf-8"), salt, iterations, KEY_LEN)

        # Imported here so a bad file fails fast with a format error,
        # not an ImportError.
        from cryptography.hazmat.primitives.ciphers.aead import AESGCM

        aesgcm = AESGCM(key)
        hasher = hashlib.sha256()
        written = 0
        index = 0
        with open(out_path, "wb") as out:
            while True:
                len_bytes = f.read(4)
                if len(len_bytes) == 0:
                    break  # end of body
                if len(len_bytes) != 4:
                    raise ValueError(
                        f"truncated file: chunk {index} length field")
                (ct_len,) = struct.unpack(CHUNK_LEN_FMT, len_bytes)
                iv = _read_exact(f, IV_LEN, f"chunk {index} IV")
                ct_and_tag = _read_exact(
                    f, ct_len, f"chunk {index} ciphertext")
                aad = header_bytes + struct.pack(CHUNK_INDEX_FMT, index)
                try:
                    plain = aesgcm.decrypt(iv, ct_and_tag, aad)
                except Exception as exc:
                    raise ValueError(
                        f"chunk {index} failed authentication: "
                        "wrong password or tampered file") from exc
                out.write(plain)
                hasher.update(plain)
                written += len(plain)
                index += 1

        if written != expected_size:
            raise ValueError(
                f"size mismatch: header says {expected_size} bytes, "
                f"decrypted {written}")
        if hasher.hexdigest() != expected_sha256:
            raise ValueError(
                "SHA-256 mismatch: decrypted content does not match "
                "the header digest (file tampered or corrupt)")
        return header


def main(argv=None):
    parser = argparse.ArgumentParser(
        description="Decrypt a SYSXENC v1 (.sysxenc) file.")
    parser.add_argument("input", help="encrypted .sysxenc file")
    parser.add_argument("output", help="where to write the plaintext")
    parser.add_argument("--password",
                        help="password (if omitted, prompted securely)")
    args = parser.parse_args(argv)
    password = args.password
    if password is None:
        password = getpass.getpass("Password: ")
    try:
        header = decrypt_file(args.input, args.output, password)
    except (ValueError, OSError, KeyError) as exc:
        print(f"error: {exc}", file=sys.stderr)
        return 1
    print(f"decrypted {header.get('name', args.input)} "
          f"({header['size']} bytes, {header['sha256'][:12]}..., "
          f"SHA-256 verified)")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

स्रोत

अक्सर पूछे जाने वाले प्रश्न

क्या मेरी फ़ाइल या मेरा पासवर्ड कभी ब्राउज़र छोड़ता है?

नहीं। एन्क्रिप्शन पेज में WebCrypto API से चलता है, फ़ाइल आपकी मशीन पर 1 MiB के टुकड़ों में पढ़ी जाती है, और पासवर्ड सिर्फ़ स्थानीय रूप से कुंजी निकालने के लिए इस्तेमाल होता है। कोई अपलोड चरण नहीं, कोई सर्वर पक्ष नहीं, कोई खाता नहीं — यह टूल एक स्थिर पेज है। ब्राउज़र छोड़ने वाली इकलौती चीज़ सिफरटेक्स्ट है, जब आप उसे डाउनलोड करते हैं। अगर आप पुष्टि करना चाहें, तो एन्क्रिप्ट करते समय अपने ब्राउज़र का नेटवर्क टैब खोलें: आपको फ़ाइल ले जाने वाला कोई अनुरोध नहीं दिखेगा।

अगर मैं पासवर्ड भूल जाऊँ तो क्या होगा?

फ़ाइल वापस नहीं मिल सकती। कुंजी सिर्फ़ आपके पासवर्ड से PBKDF2 द्वारा निकाली जाती है — पासवर्ड की कोई प्रति नहीं, कोई रिकवरी कुंजी नहीं, और साइट के पास उसे रीसेट करने का कोई तरीका नहीं है, क्योंकि वह उसे कभी देखती ही नहीं। गलत पासवर्ड से दूषित फ़ाइल नहीं बनती: डिक्रिप्शन अपनी प्रमाणीकरण जाँच में विफल रहता है और आपको बता देता है, बिना कोई आउटपुट लिखे। मूल फ़ाइल हटाने से पहले पासवर्ड को किसी सुरक्षित जगह, एन्क्रिप्ट की गई फ़ाइल से अलग, रख लें।

क्या मैं इस वेबसाइट के बिना .sysxenc फ़ाइल डिक्रिप्ट कर सकता हूँ?

हाँ। SYSXENC v1 प्रारूप टूल पेज पर पूरी तरह दस्तावेज़ीकृत है — हेडर लेआउट, टुकड़ा लेआउट, AAD नियम और KDF पैरामीटर — और इस लेख का Python डिक्रिप्टर उसे मानक लाइब्रेरी और cryptography पैकेज से लागू करता है। उसे टूल से बनी फ़ाइलों पर सत्यापित किया गया है। इकलौती चीज़ जिसका आप इस्तेमाल नहीं कर सकते वह OpenSSL कमांड लाइन है: उसके पास प्रति-टुकड़ा IV, AAD और टैग व्यक्त करने का कोई तरीका नहीं है, इसलिए वह इस खंडित प्रारूप को सीधे डिक्रिप्ट नहीं कर सकती।