Viimeisenä PHDays 9:nä järjestimme kilpailun kaasunpumppulaitoksen murtamisesta - kilpailu . Paikalla oli kolme osastoa, joilla oli erilaiset turvallisuusparametrit (ei turvallisuutta, matala turvallisuus, korkea turvallisuus), jotka jäljittelivät samaa teollista prosessia: paineilmaa pumpattiin ilmapalloon (ja sitten vapautettiin).
Erilaisista turvallisuusparametreista huolimatta telineiden laitteistokokoonpano oli sama: Siemens Simatic PLC S7-300 -sarja; hätätyhjennyspainike ja paineenmittauslaite (kytketty PLC:n digitaalisiin tuloihin (DI)); venttiilit, jotka toimivat ilman täyttöä ja tyhjentämistä varten (kytkettynä PLC:n (DO) digitaalisiin lähtöihin) - katso alla oleva kuva.
PLC, riippuen painelukemista ja ohjelmansa mukaisesti, teki päätöksen tyhjentää tai täyttää pallo (avasi ja sulki vastaavat venttiilit). Kaikissa telineissä oli kuitenkin manuaalinen ohjaustila, joka mahdollisti venttiilien tilojen ohjaamisen ilman rajoituksia.
Telineet erosivat tämän tilan käyttöönoton monimutkaisuudesta: suojaamattomalla osastolla se oli helpoin tehdä ja High Security -osastolla vastaavasti vaikeampaa.
Viisi kuudesta ongelmasta ratkaistiin kahdessa päivässä; Ykköspelaaja ansaitsi 233 pistettä (hän vietti viikon valmistautuessaan kilpailuun). Kolme voittajaa: I sija - a1exdandy, II - Rubikoid, III - Ze.
PHDaysin aikana kukaan osallistujista ei kuitenkaan pystynyt voittamaan kaikkia kolmea katsomoa, joten päätimme tehdä verkkokilpailun ja julkaisimme vaikeimman tehtävän kesäkuun alussa. Osallistujien oli suoritettava tehtävä kuukauden sisällä, löydettävä lippu ja kuvattava ratkaisu yksityiskohtaisesti ja mielenkiintoisella tavalla.
Leikkauksen alla julkaisemme analyysin kuukauden aikana lähetettyjen parhaasta ratkaisusta tehtävään, sen löysi Alexey Kovrizhnykh (a1exdandy) Digital Security -yhtiöstä, joka sijoittui kilpailussa PHDaysin aikana XNUMX. sijalle. Alla esittelemme sen tekstin kommentteineen.
Alkuperäinen analyysi
Joten tehtävä sisälsi arkiston, jossa oli seuraavat tiedostot:
- block_upload_traffic.pcapng
- DB100.bin
- hints.txt
hints.txt-tiedosto sisältää tarvittavat tiedot ja vihjeet tehtävän ratkaisemiseksi. Tässä sen sisältö:
- Petrovich kertoi minulle eilen, että voit ladata lohkoja PlcSimistä vaiheeseen 7.
- Osastolla oli käytössä Siemens Simatic S7-300 -sarjan PLC.
- PlcSim on PLC-emulaattori, jonka avulla voit suorittaa ja korjata ohjelmia Siemens S7 PLC:ille.
DB100.bin-tiedosto näyttää sisältävän DB100 PLC -tietolohkon: 00000000: 0100 0102 6e02 0401 0206 0100 0101 0102 ....n......... 00000010: 1002 0501 0202 2002 0501 0206 . ......... ................... 0100 0102............00000020. 0102: 7702 0401 0206 0100 0103 0102 0 02 .........&..... 00000030: 0501c0202 1602 0501 0206 0100 0104 0102 00000040 7502 0401 0206 0100 0105 0102 0 .. : 02 0501 00000050 0202 1602a0501 0206 0100 0106 ................ 0102: 3402 4 00000060 0401a 0206 0100 0107 0102 .......... 2602a0501: 0202 00000070b 4 02 0501 0206 0100 0108 ......".....F... 0102b3302: 0401 3 00000080c 0206 0100 0109 ........ ... .... 0102e0: 02 0501 0202 1602 00000090 0501 0206 0100 ........#...... 010f0102: 3702 0401 0206 7 000000 0 ..... ......... .....&. 0100: 010 0102 2202c0501 0202 4602 0501 ....L......
Kuten nimestä voi päätellä, block_upload_traffic.pcapng-tiedosto sisältää lohkolatausliikenteen kaadoksen PLC:hen.
On syytä huomata, että tämä liikennekaatopaikka kilpailupaikalla konferenssin aikana oli hieman vaikeampi saada. Tätä varten oli tarpeen ymmärtää TeslaSCADA2:n projektitiedoston komentosarja. Siitä pystyi ymmärtämään missä RC4:llä salattu kaatopaikka sijaitsi ja millä avaimella sen salauksen purkamiseen tarvittiin. Tietolohkojen kaatopaikat voitiin saada käyttämällä S7-protokollaasiakasta. Tätä varten käytin Snap7-paketin demoasiakasta.
Signaalinkäsittelylohkojen purkaminen liikennevedosta
Katsomalla dumpin sisältöä voit ymmärtää, että se sisältää signaalinkäsittelylohkot OB1, FC1, FC2 ja FC3:
Nämä lohkot on poistettava. Tämä voidaan tehdä esimerkiksi seuraavalla skriptillä, kun liikenne on aiemmin muunnettu pcapng-muodosta pcap:ksi:
#!/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 ('x1ex00', 'x1ex01'): # upload
buf += s7_data[4:]
elif s7_param == 'x1f':
with open(next(names), 'wb') as f:
f.write(buf)
buf = ''Kun olet tutkinut tuloksena olevat lohkot, huomaat, että ne alkavat aina tavuilla 70 70 (pp). Nyt sinun on opittava analysoimaan niitä. Tehtävävihje viittaa siihen, että sinun on käytettävä PlcSimiä tähän.
Ihmisten luettavien ohjeiden saaminen lohkoista
Ensin yritetään ohjelmoida S7-PlcSim lataamalla siihen useita lohkoja toistuvin ohjein (= Q 0.0) Simatic Manager -ohjelmistolla ja tallentamalla emulaattorissa saatu PLC esimerkki.plc-tiedostoon. Katsomalla tiedoston sisältöä voit helposti määrittää ladattujen lohkojen alun aiemmin löytämämme allekirjoituksen 70 70 perusteella. Lohkojen eteen lohkokoko on ilmeisesti kirjoitettu 4-tavuisena little-endian-arvona.
Kun saimme tietoa plc-tiedostojen rakenteesta, seuraava toimintasuunnitelma ilmestyi PLC S7 -ohjelmien lukemiseen:
- Luomme Simatic Managerin avulla S7-PlcSimiin lohkorakenteen, joka on samanlainen kuin se, jonka saimme dumpista. Lohkojen kokojen on vastattava (tämä saavutetaan täyttämällä lohkot tarvittavalla määrällä käskyjä) ja niiden tunnisteita (OB1, FC1, FC2, FC3).
- Tallenna PLC tiedostoon.
- Korvaamme tuloksena olevan tiedoston lohkojen sisällön liikennevedosten lohkoilla. Lohkojen alku määräytyy allekirjoituksen mukaan.
- Lataamme tuloksena olevan tiedoston S7-PlcSimiin ja katsomme lohkojen sisältöä Simatic Managerissa.
Lohkot voidaan korvata esimerkiksi seuraavalla koodilla:
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)Aleksei valitsi ehkä vaikeamman, mutta silti oikean tien. Oletimme, että osallistujat käyttäisivät NetToPlcSim-ohjelmaa, jotta PlcSim voisi kommunikoida verkon yli, ladata lohkoja PlcSimiin Snap7:n kautta ja sitten ladata nämä lohkot projektina PlcSimistä kehitysympäristön avulla.
Avaamalla tuloksena olevan tiedoston S7-PlcSimissä, voit lukea päällekirjoitetut lohkot Simatic Managerilla. Laitteen pääohjaustoiminnot on tallennettu lohkoon FC1. Erityisen huomionarvoista on #TEMP0-muuttuja, joka päälle kytkettynä näyttää asettavan PLC-ohjauksen manuaaliseen tilaan M2.2- ja M2.3-bittisten muistiarvojen perusteella. #TEMP0-arvo asetetaan toiminnolla FC3.
Ongelman ratkaisemiseksi sinun on analysoitava FC3-funktio ja ymmärrettävä, mitä on tehtävä, jotta se palauttaa loogisen.
Kilpailupaikan Low Securityn osastolla PLC-signaalinkäsittelylohkot oli järjestetty samalla tavalla, mutta #TEMP0-muuttujan arvon asettamiseen riitti kirjoittaa rivi my ninja way DB1-lohkoon. Lohkon arvon tarkistaminen oli yksinkertaista eikä vaatinut syvällistä lohkoohjelmointikielen tuntemusta. On selvää, että High Security -tasolla manuaalisen ohjauksen saavuttaminen on paljon vaikeampaa, ja on välttämätöntä ymmärtää STL-kielen monimutkaisuus (yksi tavoista ohjelmoida S7 PLC).
Käänteinen lohko FC3
FC3-lohkon sisältö STL-esityksessä:
L B#16#0
T #TEMP13
T #TEMP15
L P#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
L W#16#0
<>I
JC M00d
L P#DBX 0.0
LAR1
M00d: L B [AR1,P#0.0]
T #TEMP5
L W#16#1
==I
JC M007
L #TEMP5
L W#16#2
==I
JC M008
L #TEMP5
L W#16#3
==I
JC M00f
L #TEMP5
L W#16#4
==I
JC M00e
L #TEMP5
L W#16#5
==I
JC M011
L #TEMP5
L W#16#6
==I
JC M012
JU M010
M007: +AR1 P#1.0
L P#DBX 0.0
LAR2
L B [AR1,P#0.0]
L C#8
*I
+AR2
+AR1 P#1.0
L B [AR1,P#0.0]
JL M003
JU M001
JU M002
JU M004
M003: JU M005
M001: OPN DB 101
L B [AR2,P#0.0]
T #TEMP0
JU M006
M002: OPN DB 101
L B [AR2,P#0.0]
T #TEMP1
JU M006
M004: OPN DB 101
L B [AR2,P#0.0]
T #TEMP2
JU M006
M00f: +AR1 P#1.0
L B [AR1,P#0.0]
L C#8
*I
T #TEMP11
+AR1 P#1.0
L B [AR1,P#0.0]
T #TEMP7
L P#M 100.0
LAR2
L #TEMP7
L C#8
*I
+AR2
TAR2 #TEMP9
TAR1 #TEMP4
OPN DB 101
L P#DBX 0.0
LAR1
L #TEMP11
+AR1
LAR2 #TEMP9
L B [AR2,P#0.0]
T B [AR1,P#0.0]
L #TEMP4
LAR1
JU M006
M008: +AR1 P#1.0
L B [AR1,P#0.0]
T #TEMP3
+AR1 P#1.0
L B [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
L B [AR1,P#0.0]
T #TEMP7
L P#M 100.0
LAR2
L #TEMP7
L C#8
*I
+AR2
TAR2 #TEMP9
+AR1 P#1.0
L B [AR1,P#0.0]
T #TEMP8
L P#M 100.0
LAR2
L #TEMP8
L C#8
*I
+AR2
TAR2 #TEMP10
TAR1 #TEMP4
LAR1 #TEMP9
LAR2 #TEMP10
L B [AR1,P#0.0]
L B [AR2,P#0.0]
AW
INVI
T #TEMP12
L B [AR1,P#0.0]
L B [AR2,P#0.0]
OW
L #TEMP12
AW
T B [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
L B [AR1,P#0.0]
T #TEMP7
L P#M 100.0
LAR2
L #TEMP7
L C#8
*I
+AR2
TAR2 #TEMP9
+AR1 P#1.0
L B [AR1,P#0.0]
T #TEMP8
L P#M 100.0
LAR2
L #TEMP8
L C#8
*I
+AR2
TAR2 #TEMP10
TAR1 #TEMP4
LAR1 #TEMP9
LAR2 #TEMP10
L B [AR1,P#0.0]
L B [AR2,P#0.0]
-I
T B [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
L B [AR1,P#0.0]
T #TEMP7
L P#M 100.0
LAR2
L #TEMP7
L C#8
*I
+AR2
TAR2 #TEMP9
+AR1 P#1.0
L B [AR1,P#0.0]
T #TEMP8
L P#M 100.0
LAR2
L #TEMP8
L C#8
*I
+AR2
TAR2 #TEMP10
TAR1 #TEMP4
LAR1 #TEMP9
LAR2 #TEMP10
L B [AR1,P#0.0]
L B [AR2,P#0.0]
==I
JCN M013
JU M014
M013: L P#DBX 0.0
LAR1
T #TEMP4
L B#16#0
T #TEMP6
JU M006
M014: L #TEMP4
LAR1
L #TEMP13
L L#1
+I
T #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: L P#DBX 0.0
LAR1
L 0
T #TEMP6
TAR1 #TEMP4
M005: TAR1 #TEMP4
CLR
= #TEMP16
L #TEMP13
L L#20
==I
S #TEMP16
L #TEMP15
==I
A #TEMP16
JC M017
L #TEMP13
L L#20
<I
S #TEMP16
L #TEMP15
==I
A #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_VALKoodi on melko pitkä ja saattaa tuntua monimutkaiselta jollekin, joka ei tunne STL:ää. Ei ole mitään järkeä analysoida jokaista ohjetta tämän artikkelin puitteissa; STL-kielen yksityiskohtaiset ohjeet ja ominaisuudet löytyvät vastaavasta käsikirjasta: . Esitän tässä saman koodin käsittelyn jälkeen - nimetän uudelleen tunnisteet ja muuttujat ja lisään kommentteja, jotka kuvaavat toiminta-algoritmia ja joitain STL-kielirakenteita. Huomautan heti, että kyseessä oleva lohko sisältää virtuaalikoneen, joka suorittaa jonkin DB100-lohkossa sijaitsevan tavukoodin, jonka sisällön tiedämme. Virtuaalikoneen käskyt koostuvat yhdestä tavusta käyttökoodia ja tavuista argumentteja, yksi tavu kutakin argumenttia kohden. Kaikilla käsitellyillä ohjeilla on kaksi argumenttia; nimesin niiden arvoiksi kommenteissa X ja Y.
Koodi käsittelyn jälkeen]
# Инициализация различных переменных
L B#16#0
T #CHECK_N # Счетчик успешно пройденных проверок
T #COUNTER_N # Счетчик общего количества проверок
L P#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
L W#16#0
<>I
JC M00d
L P#DBX 0.0
LAR1
# Конструкция switch - case для обработки различных опкодов
M00d: L B [AR1,P#0.0]
T #OPCODE
L W#16#1
==I
JC OPCODE_1
L #OPCODE
L W#16#2
==I
JC OPCODE_2
L #OPCODE
L W#16#3
==I
JC OPCODE_3
L #OPCODE
L W#16#4
==I
JC OPCODE_4
L #OPCODE
L W#16#5
==I
JC OPCODE_5
L #OPCODE
L W#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
L P#DBX 0.0
LAR2
L B [AR1,P#0.0] # Загрузка аргумента X (индекс в DB101)
L C#8
*I
+AR2
+AR1 P#1.0
L B [AR1,P#0.0] # Загрузка аргумента Y (индекс регистра)
JL M003 # Аналог switch - case на основе значения Y
JU M001 # для выбора необходимого регистра для записи.
JU M002 # Подобные конструкции используются и в других
JU M004 # операциях ниже для аналогичных целей
M003: JU LOOPEND
M001: OPN DB 101
L B [AR2,P#0.0]
T #REG0 # Запись значения DB101[X] в REG[0]
JU PRE_LOOPEND
M002: OPN DB 101
L B [AR2,P#0.0]
T #REG1 # Запись значения DB101[X] в REG[1]
JU PRE_LOOPEND
M004: OPN DB 101
L B [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
L B [AR1,P#0.0]
T #TEMP3
+AR1 P#1.0
L B [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
L B [AR1,P#0.0]
T #TEMP7 # первый аргумент - X
L P#M 100.0
LAR2
L #TEMP7
L C#8
*I
+AR2
TAR2 #TEMP9 # REG[X]
+AR1 P#1.0
L B [AR1,P#0.0]
T #TEMP8
L P#M 100.0
LAR2
L #TEMP8
L C#8
*I
+AR2
TAR2 #TEMP10 # REG[Y]
TAR1 #POINTER
LAR1 #TEMP9 # REG[X]
LAR2 #TEMP10 # REG[Y]
L B [AR1,P#0.0]
L B [AR2,P#0.0]
AW
INVI
T #TEMP12 # ~(REG[Y] & REG[X])
L B [AR1,P#0.0]
L B [AR2,P#0.0]
OW
L #TEMP12
AW # (~(REG[Y] & REG[X])) & (REG[Y] | REG[X]) - аналог проверки на равенство
T B [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
L B [AR1,P#0.0]
T #TEMP7
L P#M 100.0
LAR2
L #TEMP7
L C#8
*I
+AR2
TAR2 #TEMP9 # REG[X]
+AR1 P#1.0
L B [AR1,P#0.0]
T #TEMP8
L P#M 100.0
LAR2
L #TEMP8
L C#8
*I
+AR2
TAR2 #TEMP10 # REG[Y]
TAR1 #POINTER
LAR1 #TEMP9
LAR2 #TEMP10
L B [AR1,P#0.0]
L B [AR2,P#0.0]
-I # ACCU1 = ACCU2 - ACCU1, REG[X] - REG[Y]
T B [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
L B [AR1,P#0.0]
T #TEMP7 # REG[X]
L P#M 100.0
LAR2
L #TEMP7
L C#8
*I
+AR2
TAR2 #TEMP9 # REG[X]
+AR1 P#1.0
L B [AR1,P#0.0]
T #TEMP8
L P#M 100.0
LAR2
L #TEMP8
L C#8
*I
+AR2
TAR2 #TEMP10 # REG[Y]
TAR1 #POINTER
LAR1 #TEMP9 # REG[Y]
LAR2 #TEMP10 # REG[X]
L B [AR1,P#0.0]
L B [AR2,P#0.0]
==I
JCN M013
JU M014
M013: L P#DBX 0.0
LAR1
T #POINTER
L B#16#0
T #TEMP6
JU PRE_LOOPEND
M014: L #POINTER
LAR1
# Инкремент значения #CHECK_N
L #CHECK_N
L L#1
+I
T #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: L P#DBX 0.0
LAR1
L 0
T #TEMP6
TAR1 #POINTER
LOOPEND: TAR1 #POINTER
CLR
= #TEMP16
L #CHECK_N
L L#20
==I
S #TEMP16
L #COUNTER_N
==I
A #TEMP16
# Все проверки пройдены, если #CHECK_N == #COUNTER_N == 20
JC GOOD
L #CHECK_N
L L#20
<I
S #TEMP16
L #COUNTER_N
==I
A #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_VALKun olet saanut käsityksen virtuaalikoneen ohjeista, kirjoitetaan pieni disassembler, joka jäsentää DB100-lohkon tavukoodin:
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))
breakTuloksena saamme seuraavan virtuaalikoneen koodin:
Virtuaalikonekoodi
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)Kuten näet, tämä ohjelma yksinkertaisesti tarkistaa jokaisen DB101-merkin tasa-arvon tiettyyn arvoon. Viimeinen rivi kaikkien tarkastusten läpäisemiseksi on: n0w u 4r3 7h3 m4573r. Jos tämä viiva sijoitetaan lohkoon DB101, manuaalinen PLC-ohjaus aktivoituu ja ilmapallo voidaan räjäyttää tai tyhjentää.
Siinä kaikki! Alexey osoitti teollisen ninjan arvoista osaamista :) Lähetimme voittajalle ikimuistoisia palkintoja. Suuri kiitos kaikille osallistujille!
Lähde: will.com
