हैकक्वेस्ट 2019 में माइकोसॉफ्ट लूनीक्स को तोड़ना

नमस्कार, हेब्र!

ZeroNight 2019 सम्मेलन से पहले हैकक्वेस्ट में, एक मनोरंजक कार्य था। मैंने समय पर निर्णय पारित नहीं किया, लेकिन मुझे रोमांच का हिस्सा मिला। मुझे लगता है कि आपको यह जानने में दिलचस्पी होगी कि आयोजकों और r0.Crew टीम ने प्रतिभागियों के लिए क्या तैयार किया है।

कार्य: गुप्त माइक्रोसॉफ़्ट 1998 ऑपरेटिंग सिस्टम के लिए एक सक्रियण कोड प्राप्त करें।

इस लेख में मैं आपको बताऊंगा कि यह कैसे करना है।

सामग्री

0. कार्य
1. उपकरण
2. छवि का निरीक्षण करें
3. चरित्र उपकरणों और कर्नेल
4. Search register_chrdev
4.1। एक ताजा न्यूनतम लिनक्स छवि तैयार करना
4.2। कुछ और तैयारी
4.3। LUNix पर KASLR को अक्षम करें
4.4। हम खोज करते हैं और एक हस्ताक्षर पाते हैं
5. / देव / सक्रिय और लिखने के कार्य से fops के लिए खोजें
6. हम पढ़ाई लिखाई करते हैं
6.1। हैश फंक्शन
6.2। मुख्य पीढ़ी एल्गोरिथम
6.3। keygen

कार्य

QEMU में लॉन्च की गई छवि के लिए मेल और सक्रियण कुंजी की आवश्यकता होती है। हम पहले से ही मेल जानते हैं, चलो बाकी की तलाश करें!

1. उपकरण

• GDB
• QEMU
• binwalk
• आईडीए

~/.gdbinit आपको एक उपयोगी फ़ंक्शन लिखने की आवश्यकता है:

 define xxd dump binary memory dump.bin $arg0 $arg0+$arg1 shell xxd dump.bin end 

2. छवि का निरीक्षण करें

पहले नाम बदलें jD74nd8_task2.iso से lunix.iso।

बिनवॉक का उपयोग करते हुए, हम देखते हैं कि ऑफसेट 0x413000 पर एक स्क्रिप्ट है। यह स्क्रिप्ट मेल और कुंजी की जाँच करती है:


हम सीधे छवि में हेक्स संपादक के साथ चेक को तोड़ते हैं और स्क्रिप्ट को हमारे आदेशों को निष्पादित करते हैं। अब यह कैसा दिखता है:


ध्यान दें कि आपको activated रेखा को activated करने के लिए ट्रिम करना था ताकि छवि का आकार समान रहे। सौभाग्य से, कोई हैश चेक नहीं है। छवि को lunix_broken_activation.iso कहा जाता है।

इसे QEMU के माध्यम से चलाएं:

 sudo qemu-system-x86_64 lunix_broken_activation.iso -enable-kvm 

चलो अंदर खोदें:


तो हमारे पास है:

1. वितरण - न्यूनतम लिनक्स 5.0.11।
2. चरित्र उपकरण /dev/activate मेल की जांच करने में लगे हुए हैं, कुंजी, जिसका अर्थ है कि सत्यापन तर्क को कर्नेल के आंत्र में कहीं और देखने की आवश्यकता है।
3. मेल, कुंजी email|key में प्रेषित की जाती है। email|key प्रारूप।

Target_broken_activation.iso छवि की अब आवश्यकता नहीं होगी।

3. चरित्र उपकरणों और कर्नेल

उपकरण जैसे /dev/mem , /dev/vcs , /dev/activate , आदि। register_chrdev फ़ंक्शन का उपयोग करके register_chrdev करें:

 int register_chrdev (unsigned int major, const char * name, const struct fops); 

name का नाम है, और fops संरचना में ड्राइवर फ़ंक्शन के लिए संकेत हैं:

 struct file_operations { struct module *owner; loff_t (*llseek) (struct file *, loff_t, int); ssize_t (*read) (struct file *, char *, size_t, loff_t *); ssize_t (*write) (struct file *, const char *, size_t, loff_t *); int (*readdir) (struct file *, void *, filldir_t); unsigned int (*poll) (struct file *, struct poll_table_struct *); int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); int (*mmap) (struct file *, struct vm_area_struct *); int (*open) (struct inode *, struct file *); int (*flush) (struct file *); int (*release) (struct inode *, struct file *); int (*fsync) (struct file *, struct dentry *, int datasync); int (*fasync) (int, struct file *, int); int (*lock) (struct file *, int, struct file_lock *); ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *); ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *); }; 

हम केवल इस समारोह में रुचि रखते हैं:

 ssize_t (*write) (struct file *, const char *, size_t, loff_t *); 

यहां, दूसरा तर्क बफर है जिसका डेटा स्थानांतरित किया गया है, अगला बफर का आकार है।

4. Search register_chrdev

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

और हस्ताक्षर न्यूनतम डिबगिंग जानकारी के साथ न्यूनतम लिनक्स छवि में है। सामान्य तौर पर, आपको अपना न्यूनतम निर्माण करने की आवश्यकता होती है।

अर्थात्, योजना इस प्रकार है:

  Minimal Linux ->   register_chrdev ->  ->   register_chrdev  Lunix 

4.1। एक ताजा न्यूनतम लिनक्स छवि तैयार करना

1. आवश्यक उपकरण स्थापित करें:
   

    sudo apt install wget make gawk gcc bc bison flex xorriso libelf-dev libssl-dev 

2. डाउनलोडिंग स्क्रिप्ट:
   
   

    git clone https://github.com/ivandavidov/minimal cd minimal/src 

3. सही 02_build_kernel.sh :
   इसे हटा दें
   
   

    # Disable debug symbols in kernel => smaller kernel binary. sed -i "s/^CONFIG_DEBUG_KERNEL.*/\\# CONFIG_DEBUG_KERNEL is not set/" .config 

   
   इसे जोड़ें
   
   

    echo "CONFIG_GDB_SCRIPTS=y" >> .config 

   
   
4. संकलन
   
   

    ./build_minimal_linux_live.sh 

छवि न्यूनतम / src / minimal_linux_live.iso है।

4.2। कुछ और तैयारी

न्यूनतम / src / iso फ़ोल्डर के लिए minimal_linux_live.iso को अनज़िप करें।

न्यूनतम / src / iso / बूट फ़ाइल rootfs.xz कर्नेल rootfs.xz कर्नेल kernel.xz और rootfs.xz FS rootfs.xz । उन्हें kernel.minimal.xz , rootfs.minimal.xz नाम दें।

इसके अलावा, आपको छवि से कोर खींचने की आवश्यकता है। इसके साथ निकालने में मदद करेगा vmlinux स्क्रिप्ट:

 extract-vmlinux kernel.minimal.xz > vmlinux.minimal 

अब न्यूनतम / src / iso / बूट फोल्डर में हमारे पास यह सेट है: kernel.minimal.xz , rootfs.minimal.xz , vmlinux.minimal ।

लेकिन lunix.iso से हमें केवल कर्नेल की आवश्यकता है। इसलिए, हम सभी समान संचालन करते हैं, हम vmlinux.lunix kernel.xz कहते हैं, vmlinux.lunix बारे में भूल जाते हैं। kernel.xz , rootfs.xz , अब मैं आपको बताऊंगा कि क्यों।

4.3। LUNix पर KASLR को अक्षम करें

मैं QEMU में नए इकट्ठे मिनिमल लिनक्स के मामले में KASLR को निष्क्रिय करने में कामयाब रहा।
लेकिन यह लुनिक्स के साथ काम नहीं करता था। इसलिए, आपको छवि को स्वयं संपादित करना होगा।

ऐसा करने के लिए, इसे हेक्स संपादक में खोलें, लाइन "APPEND vga=normal" और इसे "APPEND nokaslr\x20\x20\x20" बदलें।

और छवि को lunix_nokaslr.iso कहा जाता है।

4.4। हम खोज करते हैं और एक हस्ताक्षर पाते हैं

हम एक टर्मिनल में ताजा मिनिमल लिनक्स लॉन्च करते हैं:

 sudo qemu-system-x86_64 -kernel kernel.minimal.xz -initrd rootfs.minimal.xz -append nokaslr -s 

अन्य डिबगर में:

 sudo gdb vmlinux.minimal (gdb) target remote localhost:1234 

अब कार्यों की सूची में register_chrdev :


जाहिर है, हमारा विकल्प __register_chrdev ।
हमें भ्रम नहीं है कि हमने register_chrdev की खोज की, लेकिन __register_chrdev पाया

जुदा:


क्या हस्ताक्षर लेना है? मैंने कई विकल्पों की कोशिश की और निम्नलिखित टुकड़े पर बसे:

  0xffffffff811c9785 <+101>: shl $0x14,%esi 0xffffffff811c9788 <+104>: or %r12d,%esi 

तथ्य यह है कि 0xc1, 0xe6, 0x14, 0x44, 0x09, 0xe6 में केवल एक फ़ंक्शन होता है जिसमें 0xc1, 0xe6, 0x14, 0x44, 0x09, 0xe6 ।

अब मैं दिखाऊंगा, लेकिन पहले हमें यह पता लगाना होगा कि इसे किस खंड में देखना है।


__register_chrdev फ़ंक्शन __register_chrdev पता 0xffffffff811c9720 , यह __register_chrdev खंड है। वहां हम देखेंगे।

संदर्भ न्यूनतम लिनक्स से डिस्कनेक्ट करें। अब lunix से कनेक्ट करें।

एक टर्मिनल में:

 sudo qemu-system-x86_64 lunix_nokaslr.iso -s -enable-kvm 

दूसरे में:

 sudo gdb vmlinux.lunix (gdb) target remote localhost:1234 

हम .text खंड की सीमाओं को देखते हैं:


सीमाएँ 0xffffffff81000000 - 0xffffffff81600b91 , 0xc1, 0xe6, 0x14, 0x44, 0x09, 0xe6 :


हम पता 0xffffffff810dc643 पर टुकड़ा 0xffffffff810dc643 । लेकिन यह फ़ंक्शन का केवल एक हिस्सा है, आइए देखें कि ऊपर क्या है:


और यहाँ फ़ंक्शन की शुरुआत 0xffffffff810dc5d0 (क्योंकि retq पड़ोसी फ़ंक्शन से बाहर निकलना है)।

5. खोज देव / से / सक्रिय

Register_chrdev फ़ंक्शन का प्रोटोटाइप यह है:

 int register_chrdev (unsigned int major, const char * name, const struct fops); 

हमें एक संरचना की जरूरत है।

डिबगर और QEMU को पुनरारंभ करना। हमने 0xffffffff810dc5d0 पर 0xffffffff810dc5d0 ब्रेक 0xffffffff810dc5d0 । यह कई बार काम करेगा। ये डिवाइस mem, vcs, cpu/msr, cpu/cpuid , और उनके तुरंत बाद activate हैं।


नाम के सूचक को rcx में संग्रहीत किया जाता है। और fops करने के लिए सूचक r8 :



तो, write समारोह का पता 0xffffffff811f068f ।

6. हम पढ़ाई लिखाई करते हैं

समारोह में कई दिलचस्प ब्लॉक शामिल हैं। यह हर ब्रेकप्वाइंट का सही वर्णन करने के लायक नहीं है, यह एक सामान्य दिनचर्या है। इसके अलावा, गणना के ब्लॉक नग्न आंखों को दिखाई देते हैं।

6.1। हैश फंक्शन

vmlinux.lunix आईडीए खोलें, कर्नेल vmlinux.lunix लोड करें और देखें कि लेखन फ़ंक्शन के अंदर क्या है।

ध्यान देने योग्य पहली बात यह चक्र है:


कुछ sub_FFFFFFFF811F0413 फ़ंक्शन को sub_FFFFFFFF811F0413 , जो इस तरह से शुरू होता है:


और पते पर 0xffffffff81829ce0 , sha256 के लिए एक तालिका का पता लगाया गया है:


यही है, sub_FFFFFFFF811F0413 = sub_FFFFFFFF811F0413 256। बाइट्स जिसका हैश प्राप्त किया जाना चाहिए $sp+0x50+var49 माध्यम से प्रेषित किया जाता है, और परिणाम $sp+0x50+var48 में संग्रहीत किया जाता है। वैसे, var49=-0x49 , var48=-0x48 , इसलिए $sp+0x50+var49 = $sp+0x7 , $sp+0x50+var48 = $sp+0x8 ।

इसे देखें।

हम qemu, gdb को शुरू करते हैं, 0xffffffff811f0748 call sub_FFFFFFFF811F0413 पर सेट 0xffffffff811f0748 call sub_FFFFFFFF811F0413 और निर्देश पर 0xffffffff811f0748 call sub_FFFFFFFF811F0413 0xffffffff811f074d xor ecx, ecx , जो फंक्शन के तुरंत बाद है। मेल test@mail.ru , पासवर्ड 1234-5678-0912-3456 test@mail.ru ।

मेल का बाइट फ़ंक्शन पर जाता है, और इसका परिणाम यह है:

 >>> import hashlib >>> hashlib.sha256(b"t").digest().hex() 'e3b98a4da31a127d4bde6e43033f66ba274cab0eb7eb1c70ec41402bf6273dd8' >>> 

यही है, हाँ, यह वास्तव में sha256 है, केवल यह मेल के सभी बाइट्स के लिए हैश की गणना करता है, और केवल मेल के लिए एक हैश नहीं।

फिर बाइट द्वारा हैश का सारांश दिया जाता है। लेकिन यदि योग 0xEC से अधिक है, तो 0xEC द्वारा विभाजन का शेष भाग 0xEC :

 import hashlib def get_email_hash(email): h = [0]*32 for sym in email: sha256 = hashlib.sha256(sym.encode()).digest() for i in range(32): s = h[i] + sha256[i] if s <= 0xEC: h[i] = s else: h[i] = s % 0xEC return h 

राशि 0xffffffff81c82f80 पर सहेजी जाती है। देखते हैं कि test@mail.ru से हैश क्या test@mail.ru ।

हमने ffffffff811f0786 dec r13d पर ब्रेक ffffffff811f0786 dec r13d (यह लूप से बाहर निकलना है):


और साथ तुलना करें:

 >>> get_email_hash('test@mail.ru') 2b902daf5cc483159b0a2f7ed6b593d1d56216a61eab53c8e4b9b9341fb14880 

लेकिन हैश खुद कुंजी के लिए स्पष्ट रूप से थोड़ा लंबा है।

6.2। मुख्य पीढ़ी एल्गोरिदम

इस कोड के लिए कुंजी जिम्मेदार है:


यहाँ प्रत्येक बाइट की अंतिम गणना है:

 0xFFFFFFFF811F0943 imul eax, r12d 0xFFFFFFFF811F0947 cdq 0xFFFFFFFF811F0948 idiv r10d 

r12d और r12d हैश बाइट्स में, उन्हें गुणा किया जाता है, और फिर 9 से विभाजित करने का शेष लिया जाता है।

क्योंकि


और बाइट्स को अप्रत्याशित क्रम में लिया जाता है। मैं इसे keygen में इंगित करूंगा।

6.3। keygen

 def keygen(email): email_hash = get_email_hash(email) pairs = [(0x00, 0x1c), (0x1f, 0x03), (0x01, 0x1d), (0x1e, 0x02), (0x04, 0x18), (0x1b, 0x07), (0x05, 0x19), (0x1a, 0x06), (0x08, 0x14), (0x17, 0x0b), (0x09, 0x15), (0x16, 0x0a), (0x0c, 0x10), (0x13, 0x0f), (0x0d, 0x11), (0x12, 0x0e)] key = [] for pair in pairs: i = pair[0] j = pair[1] key.append((email_hash[i] * email_hash[j])%9) return [''.join(map(str, key[i:i+4])) for i in range(0, 16, 4)] 

तो, चलो कुछ कुंजी उत्पन्न करते हैं:

 >>> import lunix >>> lunix.keygen("m.gayanov@gmail.com") ['0456', '3530', '0401', '2703'] 

और अब आप आराम कर सकते हैं और खेल 2048 खेल सकते हैं :) आपका ध्यान के लिए धन्यवाद! यहाँ कोड