माइक्रोसॉफ्ट विंडोज पासवर्ड भंडारण और एन्क्रिप्शन

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

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

वि ब्लॉक

डिफ़ॉल्ट रूप से विस्टा से पहले विंडोज दो अलग-अलग हैश में पासवर्ड संग्रहीत करता है - एलएम और एनटी। सीटी और ऊपर में, एलएम हैश संग्रहीत नहीं है। पहले, आइए देखें कि इन हैश को कहां देखना है, और फिर हम यह पता लगाएंगे कि वे क्या हैं।

उपयोगकर्ता पासवर्ड, साथ ही कई अन्य उपयोगी जानकारी, रजिस्ट्री में HKLM \ SAM \ SAM \ Domains \ Account \ users \ [RID] \ V पर संग्रहीत हैं
वी-ब्लॉक के रूप में जाना जाता है। एसएएम अनुभाग संगत फ़ाइल c: \ Windows \ System32 \ config \ SAM में स्थित है । RID - एक विशिष्ट उपयोगकर्ता पहचानकर्ता, आप इसे देख सकते हैं, उदाहरण के लिए, HKLM \ SAM \ SAM \ Domains \ Account \ Users \ name \ <उपयोगकर्ता नाम> शाखा (डिफ़ॉल्ट पैरामीटर, फ़ील्ड पैरामीटर प्रकार है) को देखकर। उदाहरण के लिए, "व्यवस्थापक" खाते की RID हमेशा 500 (0x1F4) होती है, और "अतिथि" उपयोगकर्ता 501 (0x1f5) है। डिफ़ॉल्ट रूप से एसएएम अनुभाग तक पहुंच केवल सिस्टम उपयोगकर्ता के लिए संभव है, लेकिन अगर आप वास्तव में इसे देखना चाहते हैं, तो सिस्टम के साथ regedit चलाएं:

PsExec.exe -s -i -d regedit.

एक सुविधाजनक रूप में वी-ब्लॉक का निरीक्षण करने के लिए, आप उदाहरण के लिए, इसे एक पाठ फ़ाइल (रीडगिट में फ़ाइल-निर्यात) में निर्यात कर सकते हैं।
हम यहां देखेंगे

0x0 से 0xCC तक सभी डेटा के पते हैं जो वी-ब्लॉक में हैं, उनके आकार और डेटा के बारे में कुछ अतिरिक्त जानकारी। वास्तविक पता प्राप्त करने के लिए आपको उस पते की आवश्यकता है जिसे हम 0xCC जोड़ते हैं। पते और आकार BIG ENDIAN सिद्धांत के अनुसार संग्रहीत किए जाते हैं, यानी आपको बाइट्स को पलटना होगा। 4 बाइट्स प्रत्येक पैरामीटर के लिए आवंटित किए जाते हैं, लेकिन वास्तव में सभी पैरामीटर एक या दो बाइट्स में फिट होते हैं। यहां देखें:

उपयोगकर्ता नाम - 0x
उपयोगकर्ता नाम की लंबाई - 0x10
एलएम हैश का पता - 0x9s
एलएम हैश लंबाई - 0xa0
NT हैश पता - 0xa8
NT हैश की लंबाई - 0xac

इस स्थिति में, उपयोगकर्ता नाम 0xd4 + 0xcc पर पाया जाएगा और इसकी लंबाई 0xc बाइट होगी।
NT हैश ऑफसेट 0x12c + 0xcc और इसके आकार (हमेशा समान) = 0x14 पर स्थित होगा।

पासवर्ड के भंडारण के बारे में एक और विस्तार यह है कि 4 बाइट्स हमेशा NT और LM हैश दोनों में जोड़े जाते हैं, जिसका उद्देश्य मेरे लिए एक रहस्य है। इसके अलावा, पासवर्ड निष्क्रिय होने पर भी 4 बाइट्स मौजूद रहेंगे। इस मामले में, यह स्पष्ट है कि एलएम हैश = 4 की लंबाई, और यदि आप इसके पते को देखते हैं, तो आप इन 4 बाइट्स को इस तथ्य के बावजूद देख सकते हैं कि एलएम हैश नहीं है।
इसलिए, हैश ऑफ़सेट की खोज करते समय, हम पते में 4 बाइट्स को सुरक्षित रूप से जोड़ते हैं, और जब आकार को ध्यान में रखते हैं, तो हम इसे घटाते हैं। यदि कोड को पढ़ने के लिए यह अधिक सुविधाजनक है, तो पता खोज कुछ इस तरह दिखाई देगी, उलटा, अतिरिक्त चार बाइट्स को ध्यान में रखते हुए और स्टार्टिंग ऑफसेट को जोड़ने के लिए 0xcc (C # कोड)

int lmhashOffset = userVblock[0x9c] + userVblock[0x9d] * 0x100 + 4 + 0xcc;
int nthashOffset = userVblock[0xa8] + userVblock[0xa9] * 0x100 + 4 + 0xcc;
int lmhashSize = userVblock[0xa0] + userVblock[0xa1] * 0x100 - 4;
int nthashSize = userVblock[0xac] + userVblock[0xad] * 0x100 - 4;
int usernameOffset = userVblock[0xc] + userVblock[0xd] * 0x100 + 0xcc;
int usernameLen = userVblock[0x10] + userVblock[0x1a] * 0x100;
userVblock - मान बाइट के एक सरणी के रूप में HKLM \ SAM \ SAM \ Domains \ Account \ users \\ V।
आप यहां वी-ब्लॉक के बारे में अधिक पढ़ सकते हैं।

एल्गोरिदम

अब हम एन्क्रिप्शन एल्गोरिदम को समझेंगे।
NT हैश पीढ़ी :
1. उपयोगकर्ता का पासवर्ड एक यूनिकोड स्ट्रिंग में बदल जाता है।
2. इस स्ट्रिंग के आधार पर एक MD4 हैश उत्पन्न होता है।
3. परिणामस्वरूप हैश को डीईएस एल्गोरिथ्म के साथ एन्क्रिप्ट किया गया है, कुंजी उपयोगकर्ता के आरआईडी के आधार पर संकलित है।
LM हैश जेनरेशन :
1. उपयोगकर्ता पासवर्ड ऊपरी मामले में बदल जाता है और 14 बाइट्स की लंबाई के लिए शून्य के साथ गद्देदार होता है।
2. परिणामस्वरूप स्ट्रिंग को 7 बाइट्स के दो हिस्सों में विभाजित किया गया है और उनमें से प्रत्येक को डेस एल्गोरिथ्म के साथ व्यक्तिगत रूप से एन्क्रिप्ट किया गया है। नतीजतन, हमें लंबाई में 16 बाइट्स का एक हैश (लंबाई में 8 बाइट्स के दो स्वतंत्र हिस्सों से मिलकर) मिलता है।
3. परिणामस्वरूप हैश को डीईएस एल्गोरिथ्म के साथ एन्क्रिप्ट किया गया है, कुंजी उपयोगकर्ता के आरआईडी के आधार पर संकलित है।

4. विंडोज़ 2000 और उच्चतर में, दोनों प्राप्त हैश को अतिरिक्त रूप से RC4 एल्गोरिदम के साथ एन्क्रिप्ट किया गया है, जिसे "सिस्टम कुंजी" या सिस्की यूटिलिटी द्वारा उत्पन्न बूटकी के रूप में जाना जाता है, और इसे एक मुश्किल तरीके से एन्क्रिप्ट किया गया है।

मूल पासवर्ड और प्रत्येक चरण को व्यक्तिगत रूप से प्राप्त करने के लिए चरणों के सामान्य अनुक्रम पर विचार करें
1. बूटकी प्राप्त करें, इसके आधार पर आरसी 4 के लिए कुंजी उत्पन्न करें, आरसी 4 का उपयोग करके हैश को डिक्रिप्ट करें
2. हम उपयोगकर्ताओं के डेस से RID'ov के लिए चाबियाँ प्राप्त करते हैं, हम डेसोम हैश को डिक्रिप्ट करते हैं
3. परिणामी हैश पर ब्रूट बल द्वारा हमला किया जाता है।

Bootkey

सिस्टम कुंजी (बूटकी) को 4 भागों में विभाजित किया गया है और निम्नलिखित रजिस्ट्री कुंजियों में निहित है:

HKLM \ System \ CurrentControlSet \ Control \ Lsa \ JD
HKLM \ System \ CurrentControlSet \ Control \ Lsa \ Skew1
HKLM \ System \ CurrentControlSet \ Control \ Lsa \ GBG
HKLM \ System \ CurrentControlSet \ Control \ Lsa \ Data

सिस्टम अनुभाग फ़ाइल c: \ Windows \ System32 \ config \ system में स्थित है

यह ध्यान दिया जाना चाहिए कि CurrentControlSet अनुभाग कंट्रोलसेट अनुभागों में से एक का लिंक है और सिस्टम बूट होने पर बनाया जाता है। इसका मतलब यह है कि यह सिस्टम फ़ाइल में नहीं पाया जा सकता है यदि सिस्टम निष्क्रिय है। यदि आप किसी फ़ाइल में कुंजी की खोज करने का निर्णय लेते हैं, तो आपको HKLM \ SYSTEM \ Select \ default में डिफ़ॉल्ट ContolSet मान का पता लगाना होगा।
उदाहरण के लिए, यदि HKLM \ System \ Select \ default = 1 - HKLM \ System \ CurrentControlSet \ के बजाय हम HKLM \ System \ controlset001 में देखें

प्रत्येक रजिस्ट्री कुंजी में एक छिपी विशेषता होती है, जिसे "क्लास" के रूप में जाना जाता है। Regedit ने इसे आसानी से नहीं दिखाया, लेकिन आप इसे देख सकते हैं, उदाहरण के लिए, यदि आप इन रजिस्ट्री कुंजियों को पाठ फ़ाइलों में निर्यात करते हैं। Winapi में यह विशेषता प्राप्त करने के लिए एक RegQueryInfoKey फ़ंक्शन है।
टुकड़े हेक्साडेसिमल संख्याओं के एक स्ट्रिंग प्रतिनिधित्व में संग्रहीत किए जाते हैं, BIG ENDIAN सिद्धांत के अनुसार इसके अलावा (यानी, एक स्ट्रिंग पीछे की ओर नहीं, बल्कि एक संख्या)।
उदाहरण के लिए, हमें ये रिकॉर्ड मिले:

Key Name: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\JD
Class Name: 46003cdb = {0xdb,0x3c,0x00,0x46}
Key Name: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\Skew1
Class Name: e0387d24 = {0x24,0x7d,0x38,0xe0}
Key Name: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\GBG
Class Name: 4d183449 = {0x49,0x34,0x18,0x4d}
Key Name: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\Data
Class Name: 0419ed03 = {0x03,0xed,0x19,0x04}

चार भागों से एकत्र की गई कुंजी बाइट्स की एक सरणी होगी:

scrambled_key = {0xdb,0x3c,0x00,0x46,0x24,0x7d,0x38,0xe0,0x49,0x34,0x18,0x4d,0x03,0xed,0x19,0x04};

अगला, इस सरणी के तत्वों को कुछ निरंतर सरणी p के आधार पर पुन: व्यवस्थित किया जाता है

int[] p = { 0xb, 0x6, 0x7, 0x1, 0x8, 0xa, 0xe, 0x0, 0x3, 0x5, 0x2, 0xf, 0xd, 0x9, 0xc, 0x4 };
इस सरणी में तत्व क्रमपरिवर्तन के लिए पदों को परिभाषित करते हैं, अर्थात

key[i] = scrambled_key[p[i]];

हमारे उदाहरण में, हमें एक सरणी मिलती है:

key[] = {0x4d,0x38,0xe0,0x3c,0x49,0x18,0x19,0xdb,0x46,0x7d,0x00,0x04,0xed,0x34,0x03,0x24 };

यह सरणी तथाकथित बूटकी है । केवल यह पासवर्ड का एन्क्रिप्शन नहीं लेगा, लेकिन बूटकी पर आधारित एक निश्चित हैश, एफ-ब्लॉक के टुकड़े और कुछ स्थिरांक। इसे हशेड बूटीक कहते हैं।

हशेड बूटी

Hashed bootkey पाने के लिए हमें 2 स्ट्रिंग स्थिरांक (ASCII) की आवश्यकता है:

string aqwerty = "!@#$%^&*()qwertyUIOPAzxcvbnmQQQQQQQQQQQQ)(*@&%\0";
string anum = "0123456789012345678901234567890123456789\0";
आपको उपयोगकर्ता के F- ब्लॉक (HKLM \ SAM \ SAM \ Domains \ Account \ users \\ F) की आवश्यकता होगी, अर्थात् इसके 16 बाइट्स: F [0x70: 0x80]

एक बड़े सरणी में विभाजित इन मूल्यों के आधार पर, हम एक MD5 हैश बनाते हैं, जो RC4 एन्क्रिप्शन की कुंजी होगी

rc4_key = MD5(F[0x70:0x80] + aqwerty + bootkey + anum).

हैशेड बूटकी प्राप्त करने के लिए अंतिम चरण rc4 एन्क्रिप्शन है (या डिक्रिप्शन - rc4 में यह एक और एक ही कार्य है) F-block fragment F की कुंजी प्राप्त करता है [0x80: 0xA0] ;

hashedBootkey = RC4(rc4_key,F[0x80:0xA0])

हमारे हाथों में हश्र बूटीक, यह सीखना है कि इसे सही तरीके से कैसे संभालना है।

पासवर्ड को हॉन्टेड बूटकी से डिक्रिप्ट करें

LM और NT पासवर्ड के लिए हमें 2 और स्ट्रिंग स्थिरांक चाहिए -

string almpassword = "LMPASSWORD";
string antpassword = "NTPASSWORD";

4 बाइट्स (शून्य के साथ गद्देदार) के रूप में उपयोगकर्ता की आरआईडी और हशेड बूटकी की पहली छमाही ( हैशडबूटी [0x0: 0x10] );
यह सब एक बाइट सरणी में सरेस से जोड़ा हुआ है और नियमों के अनुसार MD5 माना जाता है:
rc4_key_lm = MD5(hbootkey[0x0:0x10] +RID + almpassword);
rc4_key_nt = MD5(hbootkey[0x0:0x10] +RID + antpassword);

प्राप्त md5 हैश rc4 की कुंजी है, जिसने उपयोगकर्ता के V- ब्लॉक में LM और NT हैश को एन्क्रिप्ट किया है

userLMpass = RC4(rc4_key_lm,userSyskeyLMpass);
userNTpass = RC4(rc4_key_lm,userSyskeyNTpass);

इस स्तर पर, हमें उपयोगकर्ता के पासवर्ड उस रूप में प्राप्त हुए, जिसमें वे syskey एन्क्रिप्शन के बिना संग्रहीत होंगे, हम कह सकते हैं कि सबसे कठिन पीछे है। अगले चरण पर जाएं।

डेस

उपयोगकर्ता के आरआईडी के चार बाइट्स के आधार पर, कुछ क्रमपरिवर्तन और बिटवाइज़ संचालन का उपयोग करते हुए, हम 2 डेस कुंजी बनाते हैं। यहाँ ऐसे कार्य हैं जो आपत्ति (C #) करते हैं:
private byte[] str_to_key(byte[] str) {
byte[] key = new byte[8];
key[0] = (byte)(str[0] >> 1);
key[1] = (byte)(((str[0] & 0x01) << 6) | (str[1] >> 2));
key[2] = (byte)(((str[1] & 0x03) << 5) | (str[2] >> 3));
key[3] = (byte)(((str[2] & 0x07) << 4) | (str[3] >> 4));
key[4] = (byte)(((str[3] & 0x0F) << 3) | (str[4] >> 5));
key[5] = (byte)(((str[4] & 0x1F) << 2) | (str[5] >> 6));
key[6] = (byte)(((str[5] & 0x3F) << 1) | (str[6] >> 7));
key[7] = (byte)(str[6] & 0x7F);
for (int i = 0; i < 8; i++) {
key[i] = (byte)(key[i] << 1);
}
des_set_odd_parity(ref key);
return key;
}

private byte[] sid_to_key1(byte[] rid) {
byte[] s = new byte[7];
s[0] = (byte)(rid[0] & 0xFF);
s[1] = (byte)(rid[1] & 0xFF);
s[2] = (byte)(rid[2] & 0xFF);
s[3] = (byte)(rid[3] & 0xFF);
s[4] = s[0];
s[5] = s[1];
s[6] = s[2];

return str_to_key(s);
}

private byte[] sid_to_key2(byte[] rid) {
byte[] s = new byte[7];
s[0] = (byte)((rid[3]) & 0xFF);
s[1] = (byte)(rid[0] & 0xFF);
s[2] = (byte)((rid[1]) & 0xFF);
s[3] = (byte)((rid[2]) & 0xFF);
s[4] = s[0];
s[5] = s[1];
s[6] = s[2];

return str_to_key(s);
}

खैर, des_set_odd_parity (रेफ कुंजी) फ़ंक्शन को छोड़कर टिप्पणी करने के लिए कुछ भी नहीं है - यह ओपनस् लाइब्रेरी के कार्यों में से एक है, जिसका कार्य कुछ "विषम बिट्स" को जोड़ना है, इसका उपयोग हमलों के प्रतिरोध को बढ़ाने के लिए किया जाता है।

इसके बाद, हम NT (या LM) हैश को 8 बाइट्स के 2 भागों में विभाजित करते हैं और इसे DES के साथ डिक्रिप्ट करते हैं। एक आधा को sid_to_key1 फ़ंक्शन द्वारा उत्पन्न कुंजी के साथ एन्क्रिप्ट किया जाता है, दूसरा sid_to_key2 है।
obfskey_l = userNTpass[0x0:0x7]
obfskey_r = userNTpass[0x8:0xF]
byte[] deskey1 = sid_to_key1(RID);
byte[] deskey2 = sid_to_key2(RID);
byte[] md4hash_l = DES(obfskey_l, deskey1);
byte[] md4hash_r = DES(obfskey_r, deskey2);

दो हिस्सों को चमकाने के बाद, हम LM के मामले में NT, या LanMan (DES) के मामले में md4 हैश प्राप्त करते हैं। परिणामी हैश पूरी तरह से जानवर बल के हमले के लिए तैयार है।
वैसे, खाली पासवर्ड से md4 हैश 31d6cfe0d16ae931b73c59d7e0c089c0 है

अध्ययन स्रोत कोड ophcrack-3.3.1 के आधार पर आयोजित किया गया था, साथ ही साथ लेख लाल बटन पुश करें: SysKey और SAM