🔨 🔉 🌵 हैकर बैटल: पार्सिंग PHDays CTF और CTF क्वालिस जॉब्स 📻 ✌🏿 🏂🏽

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

आज के विषय में, हम कुछ दिलचस्प कार्यों का विश्लेषण प्रस्तुत करेंगे, जिनका सामना पिछली प्रतियोगिताओं के प्रतिभागियों ने किया था।

इतिहास और भूगोल

इस साल PHDays CTF चौथी बार आयोजित किया जाएगा। यह प्रतियोगिता 2011 में पॉजिटिव हैक डेज़ फोरम के दौरान पहली बार आयोजित की गई थी, फिर पीपीपी टीम के सदस्य विजेता बने, रूसी टीम लेट मोर ने अगले साल जीत हासिल की और नीदरलैंड्स से आइंडबाजेन PHDays III में चैंपियन बने। हर साल, संयुक्त राज्य अमेरिका से जापान तक PHDays CTF - में दुनिया भर की टीमें हिस्सा लेती हैं।

इस वर्ष, क्वालीफाइंग प्रतियोगिताओं में भाग लेने के लिए 600 से अधिक टीमों ने पंजीकरण किया है।

Quests और वातावरण

स्थापित परंपरा के अनुसार, खेल कार्यों और बुनियादी ढांचे को प्रतियोगिता की किंवदंती के अनुसार तैयार किया जाता है - एक विशेष कहानी जो PHDays CTF कार्यों के एक सरल सेट को एक रोमांचक प्रतियोगिता में बदल देती है जिसका एक लक्ष्य होता है। उदाहरण के लिए, पिछले साल, प्रतिभागियों ने डी 'एरोरिम की काल्पनिक दुनिया को मौत से बचा लिया। आगामी प्रतियोगिताएं इस कहानी को जारी रखेंगी।

प्रतियोगिता के कार्य आमतौर पर वास्तविक प्रोटोटाइप पर आधारित होते हैं: सीटीएफ कार्यों और सेवाओं में कमजोरियों को वास्तविक जीवन में विभिन्न प्रणालियों में पाया जा सकता है। PHDays CTF प्रतियोगिताएं मूल खेल यांत्रिकी के लिए भी दिलचस्प हैं, जो गेम खेलने के लिए अलग-अलग और विभिन्न रणनीतियों को लागू करना संभव बनाती हैं ( PHDays वेबसाइट पर अधिक)।

आमतौर पर, आयोजक उन टीमों के लिए असामान्य कार्य तैयार करते हैं जो सीधे हैकिंग से संबंधित नहीं हैं। उदाहरण के लिए, PHDays 2012 के दौरान, एक विशेष कचरा कंटेनर में बोनस झंडे ढूंढकर अतिरिक्त अंक अर्जित किए जा सकते हैं, और PHDays III के दौरान टीमों को " हैकर भूलभुलैया " को पार करना पड़ा - लेजर क्षेत्र, ट्रैकिंग सेंसर, गुप्त दरवाजे, एक कमरे के साथ बाधा कोर्स। कीड़े और अन्य दिलचस्प परीक्षण।

लेकिन मुख्य बिंदु, ज़ाहिर है, सूचना सुरक्षा की विभिन्न समस्याओं को हल करने के दौरान पूरी तरह से अर्जित किए जाते हैं। आइए उनमें से कुछ को देखें।

पदच्छेद

प्रतियोगिता का योग्यता चरण (PHDays CTF Quals) कार्य-आधारित CTF के प्रकार को संदर्भित करता है, अर्थात, टीमों को कार्यों को हल करना चाहिए और उनके लिए अंक प्राप्त करना चाहिए। कार्य निम्न श्रेणियों में से एक में गिर सकते हैं:

फोरेंसिक - कंप्यूटर फोरेंसिक परीक्षा,
रिवर्स (रिवर्स इंजीनियरिंग) - बाइनरी कोड विश्लेषण,
Pwn - कमजोरियों का शोषण,
व्यवस्थापक - प्रशासन कौशल,
नेटवर्क - नेटवर्क के बुनियादी ढांचे और प्रोटोकॉल का ज्ञान,
क्रिप्टो - क्रिप्टोग्राफी,
स्टेग्नो - स्टेग्नोग्राफ़ी,
पीपीसी (पेशेवर प्रोग्रामिंग और कोडिंग) - ओलंपियाड प्रोग्रामिंग,
वेब - खोज और वेब भेद्यताओं का उपयोग,
विविध - विविध।

चलो अंतिम श्रेणी से शुरू करते हैं।

अवहेलना करता है

एमपी 3 फ़ाइल में छिपे संदेश को डिक्रिप्ट करने के लिए आवश्यक कार्यों में से एक के भाग के रूप में PHDays IV CTF Qual में प्रतिभागी।

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

हमारे मामले में, सब कुछ कुछ अलग है। यदि आप पाठ संपादक में प्रस्तावित फ़ाइल खोलते हैं, तो यह इस तरह दिखता है:

फ़ाइल की शुरुआत में आईडी 3 प्रारूप में मेटाडेटा हैं। पहले TRCK (ट्रैक नंबर) टैग आता है, और फिर पाठ के कुछ टुकड़े:

RGB7 5.183, NULL RGB6 0.42,159 RGB5 194,244,68 RGB4 47,77,6 RGB3 44,73,141 RGB2 140,207,72 RGB1 120,156,203

यह जानकारी सात रिकॉर्ड (RGB7 से RGB1 तक) में विभाजित की जा सकती है:

RGB7 5.183, NULL

RGB6 0.42.159

RGB5 194,244.68

RGB4 47.77.6

RGB3 44.73.141

RGB2 140,207.72

RGB1 120,156,203

RGB पहचानकर्ताओं में से प्रत्येक के बाद तीन मान हैं। ये आमतौर पर संख्याएँ होती हैं, लेकिन एक मामले में NULL। यह मानना आसान है कि यह अभिलेखों की एक सरणी है, जिनमें से प्रत्येक में तीन एकल-बाइट मान शामिल हैं। आप वर्णों को दशमलव कोडों को क्रमित, संयोजित, रूपांतरित कर सकते हैं और उन्हें हेक्साडेसिमल में मुद्रित कर सकते हैं, उदाहरण के लिए, इस कार्यक्रम का उपयोग करते हुए:

>>> a = [120,156,203, 140,207,72, 44,73,141, 47,77,6, 194,244,68, 0,42,159, 5,183]

>>> print "".join(map(chr, a)).encode("hex")

नतीजतन, हम प्राप्त करते हैं:

789ccb8ccf482c498d2f4d06c2f444002a9f05b7

हेक्साडेसिमल अनुक्रम कोड 0x78 0x9C के साथ बाइट्स से शुरू होता है, और यह हमें बताता है कि zlib डेटा कम्प्रेशन एल्गोरिथ्म का उपयोग किया जाता है। यदि आप डिफ़ॉल्ट मापदंडों के साथ संपीड़न मोड में zlib का उपयोग करते हैं, तो आउटपुट अनुक्रम इन बाइट्स के साथ शुरू होगा।

पायथन में ज़लीब लाइब्रेरी के डेकोम्प्रेस फ़ंक्शन के लिए एक कॉल के साथ, आप पैक्ड संदेश को अनपैक कर सकते हैं:

 >>> import zlib >>> print zlib.decompress("".join(map(chr, a)))

और फिर पाठ प्रदर्शित किया जाएगा:

i_hate_ucucuga

यह वह ध्वज था जिसे प्रतियोगिता के आयोजकों को भेजा जाना था।

अमान्य क्रिप्टोग्राफी

यह असाइनमेंट क्रिप्टो श्रेणी का है। किंवदंती के अनुसार, एक संचार सत्र को बाधित किया गया था, और टीमों को प्रेषित संदेशों को डिक्रिप्ट करने की आवश्यकता है।

सबसे पहले, चाबियों का आदान-प्रदान करने और फिर एन्क्रिप्टेड डेटा संचारित करने की प्रक्रिया स्पष्ट रूप से दिखाई देती है। यह समझना आवश्यक है कि इस तरह के संचार को किस क्रिप्टोग्राफिक आधार पर बनाया जा सकता है।

कार्य को मंगल कहा जाता है, हम मान सकते हैं कि इसका मतलब संशोधित आरएसए है।

प्रत्येक कुंजी में दो भाग होते हैं, और दोनों मामलों में दूसरा भाग 0x010001 == 65537 है - आरएसए (ई) का अक्सर इस्तेमाल किया जाने वाला सार्वजनिक प्रतिपादक। तो, संचार सत्र में, पहले सार्वजनिक कुंजी (एन ₁ / ई ₁ , एन ₂ / ई ₂ ) का आदान-प्रदान होता है, और फिर उन पर एन्क्रिप्टेड संदेशों का आदान-प्रदान होता है (सी 1, सी 2)।

यदि यह वास्तव में RSA के समान कुछ है, तो ci = pow (m _i , e _i , n _i )। यह एम ₁ और एम ₂ खोजने के लिए आवश्यक है।

pow - मॉड्यूलर घातांक का कार्य, pow (वैल, ऍक्स्प, मापुलस) == वैल ^{ऍक्स्प} % मापांक।

RSA एल्गोरिथम के अनुसार:

m _i = pow (c _i , d _i , n _i ),
d _i * e _i mod 1 mod φ (n _i ),
n _मैं कई अपराधों का उत्पाद है,
the (n) यूलर फंक्शन है, प्राकृतिक संख्याओं की संख्या प्रति n और n से कम है।

टास्क एन ₁ और एन ₂ में 1535 बिट्स की लंबाई होती है, यानी उन्हें फैक्टराइज्ड (साधारण कारकों में विघटित) नहीं किया जा सकता है।

हम पायथन में विस्तारित यूक्लिडियन एल्गोरिथ्म के कार्यान्वयन का उपयोग करेंगे:

 def egcd(a, b): # Extended Greatest Common Divisor if a == 0: return (b, 0, 1) else: g, y, x = egcd (b % a, a) return (g, x - (b // a) * y, y)

संख्या ₁ और n ₂ के GCD (सबसे बड़े सामान्य कारक) का पता लगाएं:

 gcd = egcd(n1,n2)[0]

जीसीडी (एन ₁ , एन ₂ ) की लंबाई 1024 बिट्स है। नंबर ₁ और n _{2 के} अन्य विभाजक प्राप्त करें:

 p1 = n1 / gcd p2 = n2 / gcd

पी ₁ और पी ₂ 512-बिट प्राइम्स हैं, जीसीडी 1024 बिट्स (सबसे अधिक 512 * 512) की एक संयुक्त संख्या है, और यह भी फैक्टराइज़ करने के लिए बहुत बड़ी है ...

मामले पर विचार करें जब वांछित संदेश मी _i को संख्याओं द्वारा दर्शाया जा सकता है जो पी _i से अधिक नहीं है।

चलो n _i = p _i * q * r, फिर 0 <m _i <p _{i के लिए} निम्नलिखित अभिव्यक्ति मान्य होगी:

pow (m _i , e _i , n _i )% p _i == pow (m _i , e _i , p _i )

फिर डिक्रिप्शन डी के लिए घातांक d ' _मैं निम्नलिखित अभिव्यक्ति को संतुष्ट करना चाहिए:

e _i * d ' _i mod 1 mod * (p _i )

डी 'का मूल्य _मुझे बीजीय पूरक की गणना करके मिल सकता है:

d ' _i = invmod (e _i , p (p _i ))

प्राइम पी के लिए,

) (p _i ) == p _i-1 ,

इसलिए:

d ' _i = invmod (e _i , p _i-1 )

पायथन में निम्नलिखित फ़ंक्शन द्वारा बीजीय पूरक की गणना लागू की जाती है:

 def invmod(a, m): # Modular inversion g, x, y = egcd (a, m) if g == 1: return x % m raise Exception("modular inverse does not exist")

आपको एक फ़ंक्शन की भी आवश्यकता होगी जो एक संख्या को एक पंक्ति में बदल देता है और अंतिम वर्ण '\ 0' से केवल पंक्ति के अंत तक पाठ छोड़ता है:

 def showX(v): print ("%0256X" % v).decode("hex").split('\0')[-1]

डि की गणना करें, डिक्रिप्शन करें:

 d1 = invmod(e, p1-1) d2 = invmod(e, p2-1) showX(pow(c1, d1, p1)) showX(pow(c2, d2, p2))

और हमें इसका परिणाम मिलता है:

अनुरोध: GET_FLAG (हस्ताक्षर: 5e2d5e0323591b1c)।

परिणाम: its_n0t_ab0ut_p4dd1ng

झंडा स्ट्रिंग " its_n0t_ab0ut_p4dd1ng

" है।

Ccc क्रिप्टोग्राफिक असाइनमेंट

दिया गया: source.tar.gz आर्काइव जिसमें ecc.py और task.py फाइलें हैं, जिसमें एक प्रमुख सत्यापन योजना है , जिसे दीर्घवृत्तीय क्रिप्टोग्राफी का उपयोग करके लागू किया गया है। यह ज्ञात है कि पते को 195.133.87.171 से 5555 के पोर्ट पर जोड़कर, आप कुछ सर्वर के साथ एक कनेक्शन स्थापित कर सकते हैं:

nc 195.133.87.171 5555

password: secch4l*

चूंकि स्रोत दिए गए हैं, यह उनके विश्लेषण से शुरू होने लायक है। आप इन्हें चला भी सकते हैं।

चूंकि मेरे पास लिबनाम मॉड्यूल नहीं था, इसलिए मुझे इसे स्वयं लिखना था। यह इसे लागू करने के लिए पर्याप्त है, पहले से उल्लिखित मॉड्यूलर उलटा का कार्य और इसके द्वारा उपयोग किए गए विस्तारित यूक्लिडियन एल्गोरिथ्म:

 def egcd(a, b): # Extended Greatest Common Divisor if a == 0: return (b, 0, 1) else: g, y, x = egcd (b % a, a) return (g, x - (b // a) * y, y) def invmod(a, m): # Modular inversion g, x, y = egcd (a % m, m) if g != 1: raise Exception("modular inverse does not exist") else: return x % m

तो, task.py

से main

कार्य:

 def main(): print "Auth:“ auth = raw_input() if hashlib.sha1(auth).hexdigest() != "375d5c01ca1b8c3863024d10aac7713472eb5033": # secch4l* print "nope“ return prefix = os.urandom(8) print "Proof of work, please“ print "Prefix is (hexed) ", prefix.encode("hex") test = raw_input().decode("hex") if not test.startswith(prefix) or len(test) > 16: print "nope“ return h = hashlib.sha1(test).hexdigest() if not h.startswith("000000"): print "nope“ return goflag()

एक पंक्ति पढ़ी जाती है, SHA-1 जिसमें से निर्दिष्ट मान ("secch4l *") के बराबर होना चाहिए।

फिर एक यादृच्छिक 8-बाइट उपसर्ग क्लाइंट को भेजा जाता है। बाइट्स को हेक्स स्ट्रिंग के रूप में एन्कोड किया जाता है। जवाब में, ग्राहक को 16 बाइट्स की तुलना में एक स्ट्रिंग भेजनी चाहिए, ताकि यह निर्दिष्ट उपसर्ग के साथ शुरू हो, और इस स्ट्रिंग से SHA-1 मान के पहले 3 बाइट्स शून्य होना चाहिए। यदि सभी चरण सफल हैं, तो गोफलाग () फ़ंक्शन कहा जाता है।

निम्नलिखित कोड टुकड़ा सर्वर से जुड़ता है, पासवर्ड भेजता है, उपसर्ग प्राप्त करता है, गणना करता है और प्रतिक्रिया भेजता है:

 def readLn(sock): a = [] while True: c = sock.recv(1) if '\n' == c: return "".join(a) a.append(c) HOST = "195.133.87.171" PORT = 5555 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((HOST, PORT)) print readLn(sock) # Auth: sock.send("secch4l*\n") print readLn(sock) # Proof of work, please s = readLn(sock) print s # Prefix is (hexed) 0b3997e62b9ffbf4 prefix = s.split()[-1].decode("hex") for i in xrange(0x7FFFFFFF): s = "%s%X" % (prefix, i) if hashlib.sha1(s).digest()[:3] == '\0\0\0': break sock.send(s + '\n')

क्लाइंट कोड पर इस कोड को निष्पादित करने के बाद, सर्वर goflag () फ़ंक्शन करता है, जो निम्न पाठ प्रदर्शित करता है:

चुनाव आयोग के अध्यक्ष

R = 572115218124168948525078362547166172445820217705568707355669424304224832114

साझा SECRET = R ^ पासवर्ड

संलग्न संदेश: 7a93846a011e0d0382e94f32d705239e6298169dcec20da5d6

क्या कार्यक्षेत्र से task.py

फ़ंक्शन में होता है:

 def goflag(): print "EC PASSWORD CHECK" r = random.randint(31337, 1 << 250) R = p256.power(G, r) print "R =", R print "SHARED SECRET = R ^ PASSWORD" S = p256.power(R, PASSWORD) key = p256.derive(S) cipher = encrypt(FLAG, key) print "ENCRYPTED MESSAGE:", cipher.encode("hex")

अण्डाकार वक्रों पर असममित क्रिप्टोग्राफी का उपयोग किया जाता है। NIST द्वारा अनुशंसित P-256 वक्र चयनित है। वक्र बिंदुओं पर संचालन के कार्यान्वयन में स्पष्ट कमजोरियां नहीं होती हैं।

हम R के मूल्य को जानते हैं, लेकिन PASSWORD (जो पासवर्ड से सर्वर द्वारा पढ़ा जाता है) के मान को जाने बिना, हम एस की गणना नहीं कर सकते। एस जानने को हमें आसानी से कुंजी की गणना करने की अनुमति देगा। तो शायद एन्क्रिप्शन एक त्रुटि के साथ लागू किया जाता है?

task.py

से encrypt

फ़ंक्शन:

 def encrypt(msg, key): iv = os.urandom(8) stream = hashlib.sha256(iv + key).digest() stream = hashlib.sha256(stream + iv + key).digest() cipher = iv + xor(msg, stream) return cipher

कोड से पता चलता है कि एन्क्रिप्टेड संदेश यादृच्छिक 8-बाइट आरंभीकरण वेक्टर iv से पहले है, और एन्क्रिप्शन XOR ध्वज के रूप में दो SHA-256 गणनाओं के आउटपुट के रूप में उत्पन्न गामा के साथ किया जाता है। कुंजी का अर्थ जाने बिना, गामा प्राप्त करना अवास्तविक है। लेकिन कार्यक्रम में कुंजी कैसे प्राप्त की जाती है?

टास्कटाइम से व्युत्पन्न फ़ंक्शन:

 def derive(self, p): return hashlib.sha256(str((p[0] << 10) / p[1])).digest()

यह पता चला है कि बिंदु एस (दो निर्देशांक - x और y) के मूल्य का उपयोग इनपुट SHA-256 के रूप में किया जाता है। वास्तव में, str (int (x * 1024 / y)) हैश इनपुट को आपूर्ति की जाती है। चूंकि x और y में घनिष्ठ मान हैं (ये बड़े पूर्णांक हैं), अंकगणितीय संचालन का परिणाम 1024 के करीब होना चाहिए (हालांकि यह कई बार इससे अधिक हो सकता है)।

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

 import hashlib, ecc enc = "7a93846a011e0d0382e94f32d705239e6298169dcec20da5d6".decode("hex") iv = enc[:8] def decrypt(key): stream = hashlib.sha256(iv + key).digest() stream = hashlib.sha256(stream + iv + key).digest() return ecc.xor(enc[8:], stream) for i in xrange(0x7FFFFFFF): s = decrypt(hashlib.sha256(str(i)).digest()) for c in bytearray(s): if c < 32 or c >= 128: break else: print s # ecc_is_too_s3cure break

इस प्रकार, ध्वज "ecc_is_too_s3cure" पंक्ति है।

रिवर्स इंजीनियरिंग। Shadelt900

रिवर्स इंजीनियरिंग एक और लोकप्रिय नौकरी श्रेणी है। CTF के अलावा, बेस्ट रिवर्सल प्रतियोगिता PHDays प्रतियोगिता कार्यक्रम में शामिल है।

Shadelt900 असाइनमेंट, पिछले तीन की तरह, PHDays IV CTF Quals प्रोग्राम का हिस्सा था, जिसे जनवरी 2014 में आयोजित किया गया था। टीमों को 'derrorim_enc.bmp' नामक छवि को डिक्रिप्ट करना था। यह ज्ञात था कि इसे एन्क्रिप्ट करने के लिए उपयोग किए जाने वाले टूल को Shadelt9000.exe कहा जाता था, लेकिन डिक्रिप्टर नहीं मिल सका। यहाँ छवि है:

Shadelt9000.exe फ़ाइल पर एक नज़दीकी नज़र यह स्पष्ट करती है कि एप्लिकेशन OpenGL का उपयोग करता है। एक कॉपीराइट 1.2.8 कॉपीराइट 1995-2013 मार्क एडलर को भी फुलाया जाता है, यह दर्शाता है कि कार्यक्रम लोकप्रिय ज़ालिब संपीड़न पुस्तकालय का उपयोग करता है।

यदि आप असंतुष्ट व्यक्ति में देखते हैं जहाँ से zlib फ़ंक्शंस के लिए कॉल आते हैं, तो आप जल्दी से इस तरह के कोड पा सकते हैं:

0x47F660 और 0x47F7B8 पते पर zlib द्वारा पैक किए गए डेटा ऐरे हैं। उन्हें अनपैक करें:

 from zlib import decompress as unZ base = 0x47C000 - 0x7AE00 # data section base ab=open("ShadeIt9000.exe", "rb").read() open("1.txt", "w").write(unZ(ab[0x47F660-base:],-15)) open("2.txt", "w").write(unZ(ab[0x47F7B8-base:],-15))

अनपैक करने के बाद, 1.txt फ़ाइल में एक पिक्सेल shader होता है:

 #version 330 uniform sampler2D u_texture; uniform sampler2D u_gamma; varying vec4 texCoord0; varying vec3 v_param; uint func(vec3 co){ return uint(fract(sin(dot(co ,vec3(17.1684, 94.3498, 124.9547))) * 68431.4621) * 255.); } uvec3 rol(uvec3 value, int shift) { return (value << shift) | (value >> (8 - shift)); } const uvec3 m = uvec3(0xff); void main() { uvec3 t = uvec3(texture2D(u_texture, vec2(texCoord0)).rgb * 0xff) & m; uvec3 g = uvec3(texture2D(u_gamma, vec2(texCoord0)).rgb * 0xff) & m; int s = int(mod(func(v_param), 8)); t = rol(t, s); vec3 c = vec3((t ^ g) & m) / 0xff; gl_FragColor = vec4(c, 1.); }

2. पाठ फ़ाइल में एक शीर्ष shader होता है:

 attribute vec3 a_param; varying vec4 texCoord0; varying vec3 v_param; void main(void) { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; texCoord0 = gl_MultiTexCoord0; v_param = a_param; }

पिक्सेल शेडर के बारे में मुख्य जानकारी लाल रंग में दी गई है:

चर टी संसाधित बनावट (इनपुट फ़ाइल) का वर्तमान तत्व निकला,

और चर जी में, वर्तमान गामा तत्व (एक छद्म यादृच्छिक तरीके से उत्पन्न)।

वेरिएबल एस में, हम देखते हैं कि एस के चक्रीय बदलाव के लिए बाद में कुछ मूल्य का उपयोग किया गया है।

आउटपुट मान वास्तव में के रूप में गणना की जाती है

(rol(t,s) ^ g)

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

गामा कैसे उत्पन्न होता है:

 unsigned char *pbGamma = malloc(cbGamma); srand(time(0)); for (i = 0; i < cbGamma; i++) { pbGamma[i] = rand(); }

यह देखा जा सकता है कि यह वर्तमान समय पर निर्भर करता है।

मूल संग्रह से आप यह पता लगा सकते हैं कि फ़ाइल derrorim_enc.bmp 01/21/2014 को 18:37:52 पर बनाई गई थी।

हमें मान मिलता है कि उस समय () फ़ंक्शन वापस आ जाएगा:

 >>> import time >>> print hex(int(time.mktime((2014,1,21, 18,37,52, 0,0,0))))

0x52de8640

अब फाइल ShadeIt9000.exe को ShadeIt9000_f.exe पर कॉपी करें और इसे ठीक करें।

ऑफसेट 00015557 बाइट्स की जरूरत है

E8 A5 31 01 00

के साथ बदलें

B8 40 86 DE 52

यह जगह के बराबर है

mov eax,52de8640h

पर call _time

mov eax,52de8640h

।

इस प्रकार, हमें ShadeIt9000_f का संस्करण मिला, जो हमेशा उसी सरगम के साथ एन्क्रिप्ट होगा, जब यह हमारे लिए ब्याज की फ़ाइल एन्क्रिप्ट किया गया था।

अब आपको उन मूल्यों को तैयार करने की आवश्यकता है जो छवि को डिक्रिप्ट करने में मदद करेंगे:

 import os bmp=open("derrorim_enc.bmp", "rb").read() hdr = bmp[:0x36] abData = bytearray(bmp[0x36:]) cbBody = len(bmp) - len(hdr) open("00.bmp", "wb").write(hdr + '\0'*cbBody) open("XX.bmp", "wb").write(hdr + '\2'*cbBody) os.system("ShadeIt9000_f.exe 00.bmp") os.system("ShadeIt9000_f.exe XX.bmp")

00_enc.bmp फ़ाइल में जीरो बाइट से मिलकर चित्र को एन्क्रिप्ट करने का परिणाम होगा। यह अपने शुद्धतम रूप में गामा होगा।

XX_enc.bmp फ़ाइल में चित्र को एन्क्रिप्ट करने का परिणाम होगा, जिसमें 2 के मूल्य के साथ बाइट्स शामिल हैं। यह हमें यह पता लगाने में मदद करेगा कि प्रत्येक बाइट को चक्रीय रूप से स्थानांतरित कर दिया गया था।

अंत में, Shadelt9000 को डिक्रिप्ट करके:

 def rol(v,i): return (((v<<i) & 0xFF) | ((v>>(8-i)) & 0xFF)) def ror(v,i): return (((v>>i) & 0xFF) | ((v<<(8-i)) & 0xFF)) dRot = {rol(1,i):i for i in xrange(8)} bmp=open("derrorim_enc.bmp", "rb").read() hdr = bmp[:0x36] abData = bytearray(bmp[0x36:]) abGamma = bytearray(open("00_enc.bmp", "rb").read()[0x36:]) abRot = bytearray(open("XX_enc.bmp", "rb").read()[0x36:]) for i,b in enumerate(abGamma): abRot[i] = dRot[abRot[i] ^ b] for i,b in enumerate(abGamma): abData[i] = ror(abData[i] ^ b, abRot[i]) open("derrorim.bmp", "wb").write(hdr + str(abData))

हमें मिलता है:

कार्य को हल करने का सबसे प्रभावी नहीं बल्कि सही तरीका ऊपर वर्णित किया गया था। एक छोटा रास्ता है।

तुरंत 0x47F848 और 0x47F9A0 पते पर शीर्ष की छाया के पीछे उलटा रूपांतरण करने के लिए पिक्सेल और वर्टेक्स shader के पैक किए हुए zlib कोड निहित है। शायद वह गलती से कार्य डिजाइनर द्वारा भूल गया था। या शायद जानबूझकर छोड़ दिया।

एन्क्रिप्शन और डिक्रिप्शन के लिए शीर्ष shader कोड समान हैं, इसलिए यह उन्हें छूने के लिए कोई मतलब नहीं है। और क्या होता है यदि आप पिक्सेल शेडर की जगह लेते हैं?

ShadeIt9000_f.exe को ShadeIt9000_d.exe पर कॉपी करें और इसे ठीक करें:

00015775: 60 F6 ==> 48 F8

फिर ShadeIt9000_d.exe derrorim_enc.bmp चलाएं। और हमें डिक्रिप्ट की गई फ़ाइल derrorim_enc_enc.bmp का आउटपुट मिलता है, जो (छोटी कलाकृतियों के अपवाद के साथ) उसी के साथ मेल खाता है जिसे हमने पायथन स्क्रिप्ट के साथ डिक्रिप्ट किया था।

आज के लिए बस इतना ही! आपका ध्यान देने के लिए आप सभी का धन्यवाद, हम टिप्पणियों में प्रश्नों का उत्तर देने में प्रसन्न होंगे।

हम आपको याद दिलाते हैं कि PHDays IV CTF का फाइनल पॉजिटिव हैक डेज़ फोरम के दौरान 21 और 22 मई को होगा। न केवल सीधे साइट पर, बल्कि मोबाइल एप्लिकेशन का उपयोग करके प्रतियोगिता की प्रगति की निगरानी करना संभव होगा। खबर का पालन करें!

यह भी पढ़ें:

हम आपको याद दिलाते हैं कि PHDays IV पर ऑनलाइन प्रतियोगिता हैशनर और " प्रतिस्पर्धी खुफिया " में भागीदारी के लिए पंजीकरण शुरू हो चुका है!

PS सभी PHDays CTF और CTF Quals असाइनमेंट का एक संग्रह PHDays वेबसाइट पर पाया जा सकता है। इसलिए, यदि आपके पास खुद को परखने की इच्छा है - आगे बढ़ो!

पीपीएस विषय में प्रस्तुत कार्यों का विस्तृत विश्लेषण दिमित्री स्किलारोव द्वारा आयोजित एक विशेष वेबिनार में हुआ। वेबिनार प्रविष्टि यहाँ उपलब्ध है: http://my.webinar.ru/record/290241/ ।

हैकर बैटल: पार्सिंग PHDays CTF और CTF क्वालिस जॉब्स