📈 👨‍👩‍👦 🔙 इतना डरावना नहीं, XTS-AES 🔶 🔮 ℹ️

अभिवादन,% उपयोगकर्ता नाम%!

आज का लेख ड्रॉपबॉक्स में फ़ाइलों को एन्क्रिप्ट करने के लिए कार्यक्रम के एक नि: शुल्क एनालॉग लिखने के विचारों से प्रेरित है, अर्थात्, फ़ाइलों के सेक्टर-बाय-सेक्टर के एन्क्रिप्शन मोड का एक पहलू (किसी भी स्थान पर / से पढ़ने / लिखने की क्षमता के लिए)
हम सभी लोकप्रिय डिस्क एनक्रिप्टर्स (ट्रू क्रिप्टाइक, डिस्क क्रिप्टो) में उपयोग किए जाने वाले एक्सटीएस-एईएस एन्क्रिप्शन मोड के बारे में बात करेंगे।
यह IEEE P1619 ™ / D16 (ब्लॉक-ओरिएंटेड स्टोरेज डिवाइस पर डेटा के क्रिप्टोग्राफ़िक संरक्षण के लिए मानक) में वर्णित है और डेटा सेक्टर-बाय-सेक्टर को संग्रहीत करने का सबसे सुरक्षित तरीका माना जाता है।

सबसे पहले, हम काम के लिए इनपुट डेटा निर्धारित करेंगे:

256/512 कुंजी बिट्स (शायद SHA-256/512 (नमक + पासवर्ड) या केडीएफ जैसा कुछ)
सेक्टर का पता (संख्या)
128 बिट्स की डेटा लंबाई कई के Sobsno ब्लॉक (ब्लॉक आकार एईएस)

सरलीकृत, एल्गोरिथ्म इस प्रकार है:

दो में एक कुंजी का टूटना। पहला भाग डेटा एन्क्रिप्शन कुंजी ( k1 ), दूसरा - ट्विन वैल्यू ( k2 ) उत्पन्न करने की कुंजी बन जाता है।
इस प्रकार, यदि हम 512-बिट कुंजी का उपयोग करते हैं, तो हमने इसे 2x256 पर देखा और इसका उपयोग एईएस -256 में किया
हम सेक्टर नंबर को बाइट सरणी में बदलते हैं और इसे k2 कुंजी के साथ एन्क्रिप्ट करते हैं। यह हमारा ट्विस्ट वैल्यू है
हम आकार और प्रत्येक ब्लॉक के लिए 16 बाइट्स के ब्लॉक में डेटा ऐरे से गुजरते हैं:
1. इसे ट्विक मान के साथ रखें
2. हम इसे कुंजी k1 के साथ एन्क्रिप्ट / डिक्रिप्ट करते हैं
3. फिर से Xorim पहले से ही (दौड़) एक एन्क्रिप्टेड डेटा ब्लॉक जिसमें ट्विक वैल्यू है । हम इसे सहेजते हैं, यह उस सेक्टर का एन्क्रिप्टेड ब्लॉक होगा जिसकी हमें जरूरत है (for / ras)
4. बहुपद α = x ¹²⁸ + x ⁷ + x ² + x + 1 द्वारा ट्विक मान को गुणा करें

यहाँ (मेरे लिए, विशेष रूप से) बहुउद्देश्यीय बहुपद है। एल्गोरिदम में, यह अंतिम चरण में 1 बिट + xor द्वारा पूरे सरणी की एक पारी है।

निजी कास्ट int GF_128_FDBK = 0x87 ;
निजी कॉन्स्टेंस int AES_BLK_BYTES = 16 ;
...
// α से T (कमजोर मान) को गुणा करें
सिन = 0 ; // कैरी बिट
के लिए ( j = 0 ; j < AES_BLK_BYTES ; j ++ )
{
Cout = ( T [ j ] >> 7 ) & 1 ;
T [ j ] = ( बाइट ) ( ( ( T [ j ] << 1 ) + Cin ) & 0xFF ) ;
सिन = cout ;
}
अगर ( Cout ! = 0 )
{
टी [ 0 ] ^ = GF_128_FDBK ;
}

सिद्धांत रूप में, कोई अपराध नहीं। ऐसा इसलिए किया जाता है ताकि सेक्टर के भीतर प्रत्येक डेटा ब्लॉक के लिए ट्वीक वैल्यू अलग-अलग हो।
गणितीय रूप से समझ रखने वाले दर्शकों के लिए प्रश्न : इसे GF (2) modulo x ¹²⁸ + x ⁷ + x ² + x + 1 में बहुपद द्वारा गुणा क्यों चुना गया? मेरा (गैर) ज्ञान केवल यह मानने के लिए पर्याप्त है कि चक्रीय समूह यहां शामिल हैं, और यह सब चक्रीय बदलाव का एक प्रकार का एनालॉग है।

C # कार्य कोड जो मानक परीक्षण भी पास करता है:

कक्षा XTS
{
निजी कास्ट int GF_128_FDBK = 0x87 ;
निजी कॉन्स्टेंस int AES_BLK_BYTES = 16 ;
सार्वजनिक स्थैतिक बाइट [ ] एन्क्रिप्टसेक्टर ( बाइट [ ] इनडाटा, बाइट [ ] dataEnc एन्क्रिप्शनKey, बाइट [ ] tweakEnc एन्क्रिप्शनKey, UInt64 सेक्टरनंबर, बूल एनक्रिप्ट )
{
बाइट [ ] आउटडेटा = नया बाइट [ इनडाटा। लंबाई ] ; // एक परिणाम होगा। InData का आकार 32 का गुणक होना चाहिए!
यूंट आई, जे ; // स्थानीय काउंटर
var T = नई बाइट [ AES_BLK_BYTES ] ; // tweak मूल्य
var x = नया बाइट [ AES_BLK_BYTES ] ; / (एन्क्रिप्टेड डेटा ब्लॉक के पीछे / रास) के लिए बफर
// सेक्टर नंबर को बाइट सरणी में बदलें
सरणी। कॉपी ( BitConverter। GetBytes ( सेक्टरनंबर ) , टी, 8 ) ;
// T में एन्क्रिप्शन के बाद, हमारे पास ट्विन वैल्यू है। सच्चा मतलब एन्क्रिप्ट है
processAES ( tweakEncryptionKey, T, true ) ;
// प्रक्रिया AES_BLK_BYTES एक बार में बाइट करती है
के लिए ( i = 0 ; i < inData। लंबाई ; i + = AES_BLK_BYTES )
{
// Xorim डेटा के एक टुकड़े के साथ ट्विक मूल्य
के लिए ( j = 0 ; j < AES_BLK_BYTES ; j ++ )
{
x [ j ] = ( बाइट ) ( inData [ i + j ] ^ T [ j ] ) ;
}
// ब्लॉक को एन्क्रिप्ट / डिक्रिप्ट करें
processAES ( dataEnc एन्क्रिप्शनKey, x, एन्क्रिप्ट ) ;
// संसाधित डेटा ब्लॉक के साथ ज़ोरिम ट्विक मूल्य
के लिए ( j = 0 ; j < AES_BLK_BYTES ; j ++ )
{
outData [ i + j ] = ( बाइट ) ( x [ j ] ^ T [ j ] ) ;
}
// α से गुणा मूल्य
j = AES_BLK_BYTES ;
int t = T [ AES_BLK_BYTES - 1 ] ;
जबकि ( - j ! = 0 )
T [ j ] = ( बाइट ) ( ( T [ j ] << 1 ) | ( ( T [ j - 1 ] & xx80 ) = = 0 ; 1 : 0 ) ) ;
टी [ 0 ] = ( बाइट ) ( ( टी [ 0 ] << 1 ) ^ ( ( टी एंड 0x80 ) ! = 0 ; 0x87 : 0x00 ) ) ;
}
वापसी से बाहर ;
}
निजी स्थिर शून्य प्रक्रियाऐसे ( बाइट [ ] के, बाइट [ ] टी, बूल एन्क्रिप्शन )
{
/ * एन्सफैस्टगाइन बौंसीकस्टल से लिया गया। आप मानक के साथ बदल सकते हैं
* कार्यान्वयन, या यहां तक कि एक अलग एल्गोरिथ्म का उपयोग करें, बस विचार करें
* एन्क्रिप्शन ब्लॉक आकार।
* /
var इंजन = नया AesFastEngine ( ) ;
इंजन। Init ( एन्क्रिप्ट, नया KeyParameter ( k ) ) ;
इंजन। प्रोसेसब्लॉक ( टी, 0 , टी, 0 ) ;
}
}

______________________
एईएस का उपयोग करना, जैसा कि आप देख सकते हैं, आवश्यक नहीं है। सच है, मानक में इसके बारे में कुछ नहीं कहा गया है।

होमवर्क 32 से अधिक नहीं के आकार के लिए सेक्टर प्रोसेसिंग को लागू करना होगा।
और मैं ड्रॉपबॉक्स के लिए एन्क्रिप्शन लिखना जारी रखूंगा)

इतना डरावना नहीं, XTS-AES

अभिवादन,% उपयोगकर्ता नाम%!

More articles: