🙆🏿 ♉️ 🙇🏾 इंडस्ट्रियल निंजा के मद्देनजर: पॉजीटिव हैक डेज़ 9 में पीएलसी को कैसे हैक किया गया 😕 👩🏿‍✈️ ☝🏼

PHDays 9 में, हमने औद्योगिक पम्पिंग प्रतियोगिता - एक गैस पम्पिंग प्लांट को हैक करने की प्रतियोगिता आयोजित की। साइट पर तीन सुरक्षा मानकों (नो सिक्योरिटी, लो सिक्योरिटी, हाई सिक्योरिटी) के साथ एक ही औद्योगिक प्रक्रिया का अनुकरण करते हुए तीन स्टैंड थे: दबाव में हवा को गुब्बारे (और फिर नीचे उतारा गया) में पंप किया गया था।

विभिन्न सुरक्षा मापदंडों के बावजूद, स्टैंड का हार्डवेयर समान था: सीमेंस सिमैटिक S7-300 पीएलसी; आपातकालीन ब्लो-ऑफ बटन और दबाव मापने वाला उपकरण (पीएलसी डिजिटल इनपुट (डीआई) से जुड़ा); पंप और रक्तस्राव के लिए वाल्व (पीएलसी (डीओ) के डिजिटल आउटपुट से जुड़ा) - नीचे दिए गए आंकड़े को देखें।

पीएलसी, दबाव रीडिंग के आधार पर और इसके कार्यक्रम के अनुसार, गेंद को उड़ाने या उड़ाने के बारे में निर्णय किया (संबंधित वाल्वों को खोला और बंद किया गया)। हालांकि, सभी स्टैंडों पर एक मैनुअल कंट्रोल मोड प्रदान किया गया था, जिसने बिना किसी प्रतिबंध के वाल्व राज्यों को नियंत्रित करना संभव बना दिया।

इस मोड को सक्षम करने की जटिलता से स्टैंड को प्रतिष्ठित किया गया था: असुरक्षित स्टैंड पर यह करना सबसे आसान था, लेकिन उच्च सुरक्षा स्टैंड पर, तदनुसार, यह अधिक कठिन था।

दो दिनों में, छह में से पांच समस्याएं हल हो गईं; पहले स्थान पर विजेता ने 233 अंक अर्जित किए (उसने प्रतियोगिता के लिए एक सप्ताह की तैयारी की)। तीन विजेता: I जगह - a1exdandy, II - रूबिकॉइड, III - ज़ी।

हालांकि, PHDays के दौरान, कोई भी प्रतिभागी सभी तीन स्टैंडों को पार नहीं कर पाया, इसलिए हमने एक ऑनलाइन प्रतियोगिता करने का फैसला किया और जून की शुरुआत में सबसे मुश्किल काम प्रकाशित किया। प्रतिभागियों को एक महीने में कार्य पूरा करना था, झंडा ढूंढना था, समाधान का विस्तार से और दिलचस्प तरीके से वर्णन करना था।

कटौती के तहत, हम महीने में भेजे गए असाइनमेंट के लिए सबसे अच्छा समाधान का विश्लेषण प्रकाशित करते हैं, यह डिजिटल सिक्योरिटी कंपनी के एलेक्सी कोवरीजनीख (a1exdandy) ने पाया था, जिन्होंने PHDays के दौरान प्रतियोगिता में प्रथम स्थान प्राप्त किया था। नीचे हम अपनी टिप्पणी के साथ इसका पाठ प्रदान करते हैं।

प्रारंभिक विश्लेषण

इसलिए, कार्य में फ़ाइलों के साथ एक संग्रह था:

block_upload_traffic.pcapng
DB100.bin
hints.txt

Hints.txt फ़ाइल में कार्य को हल करने के लिए आवश्यक जानकारी और युक्तियां हैं। यहाँ इसकी सामग्री हैं:

पेट्रोविच ने मुझे कल बताया था कि प्लेसीम से आप स्टेप 7 में ब्लॉक डाउनलोड कर सकते हैं।
स्टैंड पर, सीमेंस सिमैटिक एस 7-300 श्रृंखला पीएलसी का उपयोग किया गया था।
प्लेसीम एक पीएलसी एमुलेटर है जो आपको सीमेंस एस 7 पीएलसी के लिए प्रोग्राम चलाने और डीबग करने की अनुमति देता है।

 DB100.bin फ़ाइल, जाहिरा तौर पर, एक DB100 PLC डेटा ब्लॉक सम्‍मिलित है: 00000000: 0100 0102 6e02 0401 0206 0100 0101 0102 .... n ........... 00000010: 1002 0501 0202 2002 0501 00 0100 0100 0102 ...... ......... 00000020: 0102 7702 0401 0206 0100 0103 0102 0a02 ..w ............. 00000030: 0501 0202 1602 0501 0206 0100 0104 0102 ................ 00000040: 7502 0401 0206 0100 0105 0102 0a02 0501 u ............... 00000050: 0202 1602 0501 0206 0100 0106 0102 3402 .............. 4।  00000060: 0401 0206 0100 0107 0102 2602 0501 0202 .......... & ..... 00000070: 4c02 0501 0206 0100 0108 0102 3302 0401 एल ........... 3। .. 00000080: 0206 0100 0109 0102 0a02 0501 0202 1602 ................ 00000090: 0501 0206 0100 010a 0102 3702 0401 0206 .......... 7। .... 000000a0: 0100 010b 0102 2202 0501 0202 4602 0501 ...... "..... एफ ... 000000b0: 0206 0100 010c 0102 3302 0401 0206 0100 ........ 3। ...... 000000c0: 010d 0102 0a02 0501 0202 1602 0501 0206 ................ 000000d0: 0100 010e 0102 6d02 0401 0206 0100 010f ...... m। ........ 000000e0: 0102 1102 0501 0202 2302 0501 0206 0100 ........ # ....... 000000f0: 0110 0102 3502 0401 0206 0100 0111 0102 .... 5। .......... 00000100: 1202 0501 0202 2502 0501 0206 0100 0112 ......% ......... 00000110: 0102 3302 0401 0206 0100 0113 0102 2602 ..3। .......... &। 00000120: 0501 0202 4c02 0501 0206 0100 .... L ......।

नाम से देखते हुए, block_upload_traffic.pcapng फ़ाइल में PLC लोड करने वाले ट्रैफ़िक का एक डंप होता है।

यह ध्यान देने योग्य है कि सम्मेलन के दौरान प्रतियोगिता स्थल पर यातायात का यह डंप थोड़ा और मुश्किल था। ऐसा करने के लिए, TeslaSCADA2 के लिए प्रोजेक्ट फ़ाइल से स्क्रिप्ट को समझना आवश्यक था। इससे यह समझना संभव था कि RC4 के साथ एन्क्रिप्ट किया गया डंप कहां स्थित है और इसे डिक्रिप्ट करने के लिए किस कुंजी का उपयोग किया जाना चाहिए। साइट पर डेटा ब्लॉक के डंप S7 प्रोटोकॉल क्लाइंट का उपयोग करके प्राप्त किया जा सकता है। मैंने इसके लिए Snap7 पैकेज से डेमो क्लाइंट का उपयोग किया।

ट्रैफिक डंप से सिग्नल प्रोसेसिंग इकाइयां निकालना

डंप की सामग्री को देखते हुए, आप समझ सकते हैं कि सिग्नल प्रोसेसिंग ब्लॉक ओबी 1, एफसी 1, एफसी 2 और एफसी 3 में प्रेषित हैं:

इन ब्लॉकों को निकालना आवश्यक है। यह उदाहरण के लिए, निम्न स्क्रिप्ट के साथ, pcapng प्रारूप से pcap में ट्रैफ़िक परिवर्तित करने के बाद किया जा सकता है:

#!/usr/bin/env python2 import struct from scapy.all import * packets = rdpcap('block_upload_traffic.pcap') s7_hdr_struct = '>BBHHHHBB' s7_hdr_sz = struct.calcsize(s7_hdr_struct) tpkt_cotp_sz = 7 names = iter(['OB1.bin', 'FC1.bin', 'FC2.bin', 'FC3.bin']) buf = '' for packet in packets: if packet.getlayer(IP).src == '10.0.102.11': tpkt_cotp_s7 = str(packet.getlayer(TCP).payload) if len(tpkt_cotp_s7) < tpkt_cotp_sz + s7_hdr_sz: continue s7 = tpkt_cotp_s7[tpkt_cotp_sz:] s7_hdr = s7[:s7_hdr_sz] param_sz = struct.unpack(s7_hdr_struct, s7_hdr)[4] s7_param = s7[12:12+param_sz] s7_data = s7[12+param_sz:] if s7_param in ('\x1e\x00', '\x1e\x01'): # upload buf += s7_data[4:] elif s7_param == '\x1f': with open(next(names), 'wb') as f: f.write(buf) buf = ''

प्राप्त ब्लॉकों का अध्ययन करने के बाद, आप देख सकते हैं कि वे हमेशा बाइट्स 70 70 (पीपी) के साथ शुरू होते हैं। अब आपको यह जानने की जरूरत है कि उनका विश्लेषण कैसे किया जाए। कार्य के लिए एक संकेत बताता है कि आपको इसके लिए प्लेसीम का उपयोग करने की आवश्यकता है।

ब्लॉकों से मानव-पठनीय निर्देश प्राप्त करना

सबसे पहले, चलो S7-PlcSim को दोहराते हुए निर्देश (= Q 0.0) के साथ कई ब्लॉकों को लोड करके इसे Simatic Manager सॉफ्टवेयर का उपयोग करते हैं, और परिणामस्वरूप पीएलसी एमुलेटर को save करते हैं। example.plc फ़ाइल। फ़ाइल की सामग्री को देखकर, आप आसानी से हस्ताक्षर 70 70 द्वारा लोड किए गए ब्लॉकों की शुरुआत निर्धारित कर सकते हैं, जिसे हमने पहले खोजा था। ब्लॉक से पहले, जाहिरा तौर पर, ब्लॉक आकार को 4-बाइट लिटिल-एंडियन मान के रूप में लिखा जाता है।

पीएलसी फाइलों की संरचना के बारे में जानकारी प्राप्त करने के बाद, पीएलसी एस 7 कार्यक्रमों को पढ़ने के लिए निम्नलिखित कार्य योजना दिखाई दी:

सिमैटिक मैनेजर का उपयोग करके, हम S7-PlcSim में ब्लॉक संरचना बनाते हैं जो हमें डंप से मिली थी। ब्लॉक आकार को मेल खाना चाहिए (निर्देशों की सही संख्या के साथ ब्लॉकों को भरकर प्राप्त किया गया) और उनके पहचानकर्ता (OB1, FC1, FC2, FC3)।
पीएलसी को एक फ़ाइल में सहेजें।
हम प्राप्त फ़ाइल में ब्लॉक की सामग्री को ट्रैफिक डंप से ब्लॉक के साथ बदलते हैं। ब्लॉकों की शुरुआत हस्ताक्षर द्वारा निर्धारित की जाती है।
परिणामी फ़ाइल S7-PlcSim पर अपलोड की गई है और हम Simatic Manager में ब्लॉक की सामग्री को देखते हैं।

ब्लॉक को प्रतिस्थापित किया जा सकता है, उदाहरण के लिए, निम्न कोड के साथ:

 with open('original.plc', 'rb') as f: plc = f.read() blocks = [] for fname in ['OB1.bin', 'FC1.bin', 'FC2.bin', 'FC3.bin']: with open(fname, 'rb') as f: blocks.append(f.read()) i = plc.find(b'pp') for block in blocks: plc = plc[:i] + block + plc[i+len(block):] i = plc.find(b'pp', i + 1) with open('target.plc', 'wb') as f: f.write(plc)

अलेक्सेसी संभवतः अधिक जटिल हो गया, लेकिन अभी भी सही तरीका है। हमने यह मान लिया था कि प्रतिभागी NetToPlcSim प्रोग्राम का उपयोग करेंगे, ताकि PlcSim नेटवर्क पर संचार कर सके, Snap7 के माध्यम से PlcSim में ब्लॉक लोड कर सके और फिर विकास पर्यावरण का उपयोग करके PlcSim से एक प्रोजेक्ट के रूप में इन ब्लॉकों को डाउनलोड कर सके।

S7-PlcSim में परिणामी फ़ाइल को खोलकर, आप सिमैटिक मैनेजर का उपयोग करके ओवरराइट किए गए ब्लॉकों को पढ़ सकते हैं। मुख्य डिवाइस प्रबंधन फ़ंक्शन ब्लॉक FC1 में दर्ज किए गए हैं। चर # TEMP0 विशेष ध्यान आकर्षित करता है, जब इसे चालू किया जाता है, तो ऐसा लगता है कि पीएलसी नियंत्रण को बिट मेमोरी M2.2 और M2.3 के मूल्यों के आधार पर मैनुअल मोड में स्विच किया जाता है। # TEMP0 FC3 द्वारा निर्धारित है।

समस्या को हल करने के लिए, एफसी 3 फ़ंक्शन का विश्लेषण करना और यह समझना आवश्यक है कि क्या किया जाना चाहिए ताकि यह एक तार्किक इकाई लौटाए।

प्रतियोगिता स्थल पर लो सिक्योरिटी स्टैंड पर पीएलसी सिग्नल प्रोसेसिंग ब्लॉक को उसी तरह व्यवस्थित किया गया था, लेकिन # TEMP0 वैरिएबल के मान को सेट करने के लिए, लाइन को मेरे निंजा तरीके को DB1 ब्लॉक में लिखना पर्याप्त था। ब्लॉक में मूल्य की जाँच स्पष्ट रूप से व्यवस्थित की गई थी और इसे ब्लॉक प्रोग्रामिंग भाषा के गहन ज्ञान की आवश्यकता नहीं थी। जाहिर है, उच्च सुरक्षा स्तर पर मैन्युअल नियंत्रण हासिल करना बहुत कठिन होगा और एसटीएल भाषा (एस 7 पीएलसी प्रोग्रामिंग के तरीकों में से एक) की पेचीदगियों को समझना आवश्यक है।

ब्लॉक ब्लॉक FC3

STL प्रतिनिधित्व में FC3 ब्लॉक की सामग्री:

  LB#16#0 T #TEMP13 T #TEMP15 LP#DBX 0.0 T #TEMP4 CLR = #TEMP14 M015: L #TEMP4 LAR1 OPN DB 100 L DBLG TAR1 <=D JC M016 L DW#16#0 T #TEMP0 L #TEMP6 LW#16#0 <>I JC M00d LP#DBX 0.0 LAR1 M00d: LB [AR1,P#0.0] T #TEMP5 LW#16#1 ==I JC M007 L #TEMP5 LW#16#2 ==I JC M008 L #TEMP5 LW#16#3 ==I JC M00f L #TEMP5 LW#16#4 ==I JC M00e L #TEMP5 LW#16#5 ==I JC M011 L #TEMP5 LW#16#6 ==I JC M012 JU M010 M007: +AR1 P#1.0 LP#DBX 0.0 LAR2 LB [AR1,P#0.0] LC#8 *I +AR2 +AR1 P#1.0 LB [AR1,P#0.0] JL M003 JU M001 JU M002 JU M004 M003: JU M005 M001: OPN DB 101 LB [AR2,P#0.0] T #TEMP0 JU M006 M002: OPN DB 101 LB [AR2,P#0.0] T #TEMP1 JU M006 M004: OPN DB 101 LB [AR2,P#0.0] T #TEMP2 JU M006 M00f: +AR1 P#1.0 LB [AR1,P#0.0] LC#8 *IT #TEMP11 +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP7 LP#M 100.0 LAR2 L #TEMP7 LC#8 *I +AR2 TAR2 #TEMP9 TAR1 #TEMP4 OPN DB 101 LP#DBX 0.0 LAR1 L #TEMP11 +AR1 LAR2 #TEMP9 LB [AR2,P#0.0] TB [AR1,P#0.0] L #TEMP4 LAR1 JU M006 M008: +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP3 +AR1 P#1.0 LB [AR1,P#0.0] JL M009 JU M00b JU M00a JU M00c M009: JU M005 M00b: L #TEMP3 T #TEMP0 JU M006 M00a: L #TEMP3 T #TEMP1 JU M006 M00c: L #TEMP3 T #TEMP2 JU M006 M00e: +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP7 LP#M 100.0 LAR2 L #TEMP7 LC#8 *I +AR2 TAR2 #TEMP9 +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP8 LP#M 100.0 LAR2 L #TEMP8 LC#8 *I +AR2 TAR2 #TEMP10 TAR1 #TEMP4 LAR1 #TEMP9 LAR2 #TEMP10 LB [AR1,P#0.0] LB [AR2,P#0.0] AW INVI T #TEMP12 LB [AR1,P#0.0] LB [AR2,P#0.0] OW L #TEMP12 AW TB [AR1,P#0.0] L DW#16#0 T #TEMP0 L MB 101 T #TEMP1 L MB 102 T #TEMP2 L #TEMP4 LAR1 JU M006 M011: +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP7 LP#M 100.0 LAR2 L #TEMP7 LC#8 *I +AR2 TAR2 #TEMP9 +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP8 LP#M 100.0 LAR2 L #TEMP8 LC#8 *I +AR2 TAR2 #TEMP10 TAR1 #TEMP4 LAR1 #TEMP9 LAR2 #TEMP10 LB [AR1,P#0.0] LB [AR2,P#0.0] -ITB [AR1,P#0.0] L DW#16#0 T #TEMP0 L MB 101 T #TEMP1 L MB 102 T #TEMP2 L #TEMP4 LAR1 JU M006 M012: L #TEMP15 INC 1 T #TEMP15 +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP7 LP#M 100.0 LAR2 L #TEMP7 LC#8 *I +AR2 TAR2 #TEMP9 +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP8 LP#M 100.0 LAR2 L #TEMP8 LC#8 *I +AR2 TAR2 #TEMP10 TAR1 #TEMP4 LAR1 #TEMP9 LAR2 #TEMP10 LB [AR1,P#0.0] LB [AR2,P#0.0] ==I JCN M013 JU M014 M013: LP#DBX 0.0 LAR1 T #TEMP4 LB#16#0 T #TEMP6 JU M006 M014: L #TEMP4 LAR1 L #TEMP13 LL#1 +IT #TEMP13 JU M006 M006: L #TEMP0 T MB 100 L #TEMP1 T MB 101 L #TEMP2 T MB 102 +AR1 P#1.0 L #TEMP6 + 1 T #TEMP6 JU M005 M010: LP#DBX 0.0 LAR1 L 0 T #TEMP6 TAR1 #TEMP4 M005: TAR1 #TEMP4 CLR = #TEMP16 L #TEMP13 LL#20 ==IS #TEMP16 L #TEMP15 ==IA #TEMP16 JC M017 L #TEMP13 LL#20 <IS #TEMP16 L #TEMP15 ==IA #TEMP16 JC M018 JU M019 M017: SET = #TEMP14 JU M016 M018: CLR = #TEMP14 JU M016 M019: CLR O #TEMP14 = #RET_VAL JU M015 M016: CLR O #TEMP14 = #RET_VAL

कोड काफी बड़ा है और एसटीएल से अपरिचित व्यक्ति के लिए, यह जटिल लग सकता है। इस लेख के ढांचे के भीतर प्रत्येक निर्देश को अलग करने का कोई मतलब नहीं है, विस्तृत निर्देश और एसटीएल भाषा सुविधाओं के लिए, एस 7-300 और एस 7-400 प्रोग्रामिंग के लिए संबंधित मैनुअल: स्टेटमेंट लिस्ट (एसटीएल) देखें । यहां मैं प्रोसेसिंग के बाद एक ही कोड दूंगा - लेबल और वेरिएबल्स का नाम बदलने और काम के एल्गोरिथ्म और एसटीएल भाषा के कुछ निर्माणों का वर्णन करने वाली टिप्पणियों को जोड़ना। मैं तुरंत ध्यान देता हूं कि विचाराधीन ब्लॉक में एक वर्चुअल मशीन लागू की गई है जो DB100 ब्लॉक में स्थित कुछ बाइटकोड को निष्पादित करती है, जिसकी सामग्री हम जानते हैं। वर्चुअल मशीन निर्देश ऑपरेटिंग कोड के 1 बाइट और तर्कों के बाइट्स हैं, प्रत्येक तर्क के लिए एक बाइट। समीक्षा किए गए सभी निर्देशों के दो तर्क हैं, मैंने टिप्पणियों में उनके मूल्यों को एक्स और वाई के रूप में नामित किया है।

पोस्ट प्रोसेसिंग कोड

]

 #    LB#16#0 T #CHECK_N #     T #COUNTER_N #     LP#DBX 0.0 T #POINTER #     CLR = #PRE_RET_VAL #     - LOOP: L #POINTER LAR1 OPN DB 100 L DBLG TAR1 <=D #       JC FINISH L DW#16#0 T #REG0 L #TEMP6 LW#16#0 <>I JC M00d LP#DBX 0.0 LAR1 #  switch - case     M00d: LB [AR1,P#0.0] T #OPCODE LW#16#1 ==I JC OPCODE_1 L #OPCODE LW#16#2 ==I JC OPCODE_2 L #OPCODE LW#16#3 ==I JC OPCODE_3 L #OPCODE LW#16#4 ==I JC OPCODE_4 L #OPCODE LW#16#5 ==I JC OPCODE_5 L #OPCODE LW#16#6 ==I JC OPCODE_6 JU OPCODE_OTHER #   01:    DB101[X]   Y # OP01(X, Y): REG[Y] = DB101[X] OPCODE_1: +AR1 P#1.0 LP#DBX 0.0 LAR2 LB [AR1,P#0.0] #   X (  DB101) LC#8 *I +AR2 +AR1 P#1.0 LB [AR1,P#0.0] #   Y ( ) JL M003 #  switch - case    Y JU M001 #      . JU M002 #       JU M004 #      M003: JU LOOPEND M001: OPN DB 101 LB [AR2,P#0.0] T #REG0 #   DB101[X]  REG[0] JU PRE_LOOPEND M002: OPN DB 101 LB [AR2,P#0.0] T #REG1 #   DB101[X]  REG[1] JU PRE_LOOPEND M004: OPN DB 101 LB [AR2,P#0.0] T #REG2 #   DB101[X]  REG[2] JU PRE_LOOPEND #   02:   X   Y # OP02(X, Y): REG[Y] = X OPCODE_2: +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP3 +AR1 P#1.0 LB [AR1,P#0.0] JL M009 JU M00b JU M00a JU M00c M009: JU LOOPEND M00b: L #TEMP3 T #REG0 JU PRE_LOOPEND M00a: L #TEMP3 T #REG1 JU PRE_LOOPEND M00c: L #TEMP3 T #REG2 JU PRE_LOOPEND #  03    ,    ... #   04:   X  Y # OP04(X, Y): REG[0] = 0; REG[X] = (REG[X] == REG[Y]) OPCODE_4: +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP7 #   - X LP#M 100.0 LAR2 L #TEMP7 LC#8 *I +AR2 TAR2 #TEMP9 # REG[X] +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP8 LP#M 100.0 LAR2 L #TEMP8 LC#8 *I +AR2 TAR2 #TEMP10 # REG[Y] TAR1 #POINTER LAR1 #TEMP9 # REG[X] LAR2 #TEMP10 # REG[Y] LB [AR1,P#0.0] LB [AR2,P#0.0] AW INVI T #TEMP12 # ~(REG[Y] & REG[X]) LB [AR1,P#0.0] LB [AR2,P#0.0] OW L #TEMP12 AW # (~(REG[Y] & REG[X])) & (REG[Y] | REG[X]) -     TB [AR1,P#0.0] L DW#16#0 T #REG0 L MB 101 T #REG1 L MB 102 T #REG2 L #POINTER LAR1 JU PRE_LOOPEND #   05:   Y  X # OP05(X, Y): REG[0] = 0; REG[X] = REG[X] - REG[Y] OPCODE_5: +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP7 LP#M 100.0 LAR2 L #TEMP7 LC#8 *I +AR2 TAR2 #TEMP9 # REG[X] +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP8 LP#M 100.0 LAR2 L #TEMP8 LC#8 *I +AR2 TAR2 #TEMP10 # REG[Y] TAR1 #POINTER LAR1 #TEMP9 LAR2 #TEMP10 LB [AR1,P#0.0] LB [AR2,P#0.0] -I # ACCU1 = ACCU2 - ACCU1, REG[X] - REG[Y] TB [AR1,P#0.0] L DW#16#0 T #REG0 L MB 101 T #REG1 L MB 102 T #REG2 L #POINTER LAR1 JU PRE_LOOPEND #   06:  #CHECK_N    X  Y # OP06(X, Y): #CHECK_N += (1 if REG[X] == REG[Y] else 0) OPCODE_6: L #COUNTER_N INC 1 T #COUNTER_N +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP7 # REG[X] LP#M 100.0 LAR2 L #TEMP7 LC#8 *I +AR2 TAR2 #TEMP9 # REG[X] +AR1 P#1.0 LB [AR1,P#0.0] T #TEMP8 LP#M 100.0 LAR2 L #TEMP8 LC#8 *I +AR2 TAR2 #TEMP10 # REG[Y] TAR1 #POINTER LAR1 #TEMP9 # REG[Y] LAR2 #TEMP10 # REG[X] LB [AR1,P#0.0] LB [AR2,P#0.0] ==I JCN M013 JU M014 M013: LP#DBX 0.0 LAR1 T #POINTER LB#16#0 T #TEMP6 JU PRE_LOOPEND M014: L #POINTER LAR1 #   #CHECK_N L #CHECK_N LL#1 +IT #CHECK_N JU PRE_LOOPEND PRE_LOOPEND: L #REG0 T MB 100 L #REG1 T MB 101 L #REG2 T MB 102 +AR1 P#1.0 L #TEMP6 + 1 T #TEMP6 JU LOOPEND OPCODE_OTHER: LP#DBX 0.0 LAR1 L 0 T #TEMP6 TAR1 #POINTER LOOPEND: TAR1 #POINTER CLR = #TEMP16 L #CHECK_N LL#20 ==IS #TEMP16 L #COUNTER_N ==IA #TEMP16 #   ,  #CHECK_N == #COUNTER_N == 20 JC GOOD L #CHECK_N LL#20 <IS #TEMP16 L #COUNTER_N ==IA #TEMP16 JC FAIL JU M019 GOOD: SET = #PRE_RET_VAL JU FINISH FAIL: CLR = #PRE_RET_VAL JU FINISH M019: CLR O #PRE_RET_VAL = #RET_VAL JU LOOP FINISH: CLR O #PRE_RET_VAL = #RET_VAL

वर्चुअल मशीन निर्देशों का विचार प्राप्त करने के बाद, हम DB100 ब्लॉक में बायोटेक को पार्स करने के लिए एक छोटा सा डिस्सेम्बलर लिखेंगे:

 import string alph = string.ascii_letters + string.digits with open('DB100.bin', 'rb') as f: m = f.read() pc = 0 while pc < len(m): op = m[pc] if op == 1: print('R{} = DB101[{}]'.format(m[pc + 2], m[pc + 1])) pc += 3 elif op == 2: c = chr(m[pc + 1]) c = c if c in alph else '?' print('R{} = {:02x} ({})'.format(m[pc + 2], m[pc + 1], c)) pc += 3 elif op == 4: print('R0 = 0; R{} = (R{} == R{})'.format( m[pc + 1], m[pc + 1], m[pc + 2])) pc += 3 elif op == 5: print('R0 = 0; R{} = R{} - R{}'.format( m[pc + 1], m[pc + 1], m[pc + 2])) pc += 3 elif op == 6: print('CHECK (R{} == R{})\n'.format( m[pc + 1], m[pc + 2])) pc += 3 else: print('unk opcode {}'.format(op)) break

परिणामस्वरूप, हमें निम्न वर्चुअल मशीन कोड मिलता है:

वर्चुअल मशीन कोड

 R1 = DB101[0] R2 = 6e (n) R0 = 0; R1 = (R1 == R2) CHECK (R1 == R0) R1 = DB101[1] R2 = 10 (?) R0 = 0; R1 = R1 - R2 R2 = 20 (?) R0 = 0; R1 = R1 - R2 CHECK (R1 == R0) R1 = DB101[2] R2 = 77 (w) R0 = 0; R1 = (R1 == R2) CHECK (R1 == R0) R1 = DB101[3] R2 = 0a (?) R0 = 0; R1 = R1 - R2 R2 = 16 (?) R0 = 0; R1 = R1 - R2 CHECK (R1 == R0) R1 = DB101[4] R2 = 75 (u) R0 = 0; R1 = (R1 == R2) CHECK (R1 == R0) R1 = DB101[5] R2 = 0a (?) R0 = 0; R1 = R1 - R2 R2 = 16 (?) R0 = 0; R1 = R1 - R2 CHECK (R1 == R0) R1 = DB101[6] R2 = 34 (4) R0 = 0; R1 = (R1 == R2) CHECK (R1 == R0) R1 = DB101[7] R2 = 26 (?) R0 = 0; R1 = R1 - R2 R2 = 4c (L) R0 = 0; R1 = R1 - R2 CHECK (R1 == R0) R1 = DB101[8] R2 = 33 (3) R0 = 0; R1 = (R1 == R2) CHECK (R1 == R0) R1 = DB101[9] R2 = 0a (?) R0 = 0; R1 = R1 - R2 R2 = 16 (?) R0 = 0; R1 = R1 - R2 CHECK (R1 == R0) R1 = DB101[10] R2 = 37 (7) R0 = 0; R1 = (R1 == R2) CHECK (R1 == R0) R1 = DB101[11] R2 = 22 (?) R0 = 0; R1 = R1 - R2 R2 = 46 (F) R0 = 0; R1 = R1 - R2 CHECK (R1 == R0) R1 = DB101[12] R2 = 33 (3) R0 = 0; R1 = (R1 == R2) CHECK (R1 == R0) R1 = DB101[13] R2 = 0a (?) R0 = 0; R1 = R1 - R2 R2 = 16 (?) R0 = 0; R1 = R1 - R2 CHECK (R1 == R0) R1 = DB101[14] R2 = 6d (m) R0 = 0; R1 = (R1 == R2) CHECK (R1 == R0) R1 = DB101[15] R2 = 11 (?) R0 = 0; R1 = R1 - R2 R2 = 23 (?) R0 = 0; R1 = R1 - R2 CHECK (R1 == R0) R1 = DB101[16] R2 = 35 (5) R0 = 0; R1 = (R1 == R2) CHECK (R1 == R0) R1 = DB101[17] R2 = 12 (?) R0 = 0; R1 = R1 - R2 R2 = 25 (?) R0 = 0; R1 = R1 - R2 CHECK (R1 == R0) R1 = DB101[18] R2 = 33 (3) R0 = 0; R1 = (R1 == R2) CHECK (R1 == R0) R1 = DB101[19] R2 = 26 (?) R0 = 0; R1 = R1 - R2 R2 = 4c (L) R0 = 0; R1 = R1 - R2 CHECK (R1 == R0)

जैसा कि आप देख सकते हैं, यह कार्यक्रम एक निश्चित मूल्य के लिए समानता के लिए DB101 से प्रत्येक प्रतीक की जांच करता है। सभी चेक पास करने के लिए अंतिम पंक्ति: n0w u 4r3 7h3 m4573r। यदि यह रेखा DB101 ब्लॉक में रखी गई है, तो PLC का मैन्युअल नियंत्रण सक्रिय हो गया है और गुब्बारे को उड़ाना या अपस्फीति करना संभव होगा।

वह सब है! एलेक्सी ने औद्योगिक निंजा के योग्य उच्च स्तर के ज्ञान का प्रदर्शन किया :) हमने विजेता को यादगार पुरस्कार भेजे। सभी प्रतिभागियों को बहुत धन्यवाद!

इंडस्ट्रियल निंजा के मद्देनजर: पॉजीटिव हैक डेज़ 9 में पीएलसी को कैसे हैक किया गया

प्रारंभिक विश्लेषण

ट्रैफिक डंप से सिग्नल प्रोसेसिंग इकाइयां निकालना

ब्लॉकों से मानव-पठनीय निर्देश प्राप्त करना

ब्लॉक ब्लॉक FC3

More articles: