Në ditët e fundit të PHD 9 ne mbajtëm një konkurs për të hakuar një impiant pompimi gazi - konkurs . Kishte tre stenda në vend me parametra të ndryshëm sigurie (Pa siguri, Siguri e ulët, Siguri e lartë), duke imituar të njëjtin proces industrial: ajri nën presion derdhej në një tullumbace (dhe më pas lëshohej).
Pavarësisht parametrave të ndryshëm të sigurisë, përbërja harduerike e stendave ishte e njëjtë: seria Siemens Simatic PLC S7-300; butoni i deflacionit emergjent dhe pajisja matëse e presionit (e lidhur me hyrjet dixhitale PLC (DI)); valvulat që funksionojnë për fryrjen dhe deflacionin e ajrit (të lidhura me daljet dixhitale të PLC (DO)) - shihni figurën më poshtë.
PLC, në varësi të leximeve të presionit dhe në përputhje me programin e tij, mori një vendim për të shfryrë ose fryrë topin (hapi dhe mbylli valvulat përkatëse). Sidoqoftë, të gjitha stendat kishin një modalitet kontrolli manual, i cili bëri të mundur kontrollin e gjendjeve të valvulave pa asnjë kufizim.
Stendat ndryshonin në kompleksitetin e aktivizimit të kësaj mënyre: në stendën e pambrojtur ishte më e lehtë për ta bërë këtë, dhe në stendën e Sigurisë së Lartë ishte përkatësisht më e vështirë.
Pesë nga gjashtë problemet u zgjidhën në dy ditë; Pjesëmarrësi i vendit të parë fitoi 233 pikë (ai kaloi një javë duke u përgatitur për konkursin). Tre fitues: Vendi I - a1exdandy, II - Rubikoid, III - Ze.
Megjithatë, gjatë ditëve të doktoraturës, asnjë nga pjesëmarrësit nuk mundi t'i kapërcejë të tria stendat, kështu që vendosëm të bënim një konkurs online dhe publikuam detyrën më të vështirë në fillim të qershorit. Pjesëmarrësit duhej të përfundonin detyrën brenda një muaji, të gjenin flamurin dhe të përshkruanin zgjidhjen në detaje dhe në një mënyrë interesante.
Poshtë prerjes ne publikojmë një analizë të zgjidhjes më të mirë të detyrës nga ato të dërguara gjatë muajit, ajo u gjet nga Alexey Kovrizhnykh (a1exdandy) nga kompania e Sigurisë Dixhitale, e cila zuri vendin e parë në konkurs gjatë PHDays. Më poshtë po paraqesim tekstin e saj me komentet tona.
Analiza fillestare
Pra, detyra përmbante një arkiv me skedarët e mëposhtëm:
- block_upload_traffic.pcapng
- DB100.bin
- sugjerime.txt
Skedari hints.txt përmban informacionin dhe sugjerimet e nevojshme për të zgjidhur detyrën. Ja përmbajtja e tij:
- Petrovich më tha dje se mund të ngarkosh blloqe nga PlcSim në Step7.
- Në stendë u përdor PLC i serisë Siemens Simatic S7-300.
- PlcSim është një emulator PLC që ju lejon të ekzekutoni dhe korrigjoni programet për PLC-të e Siemens S7.
Skedari DB100.bin duket se përmban bllokun e të dhënave DB100 PLC: 00000000: 0100 0102 6e02 0401 0206 0100 0101 0102 ....n......... 00000010: 1002 0501 0202 . ..... ......... 2002: 0501 0206 0100 0102 00000020 0102 7702 0401a0206 ..w............. 0100: 0103 0102 0 02 00000030 ................ 0501: 0202 1602 0501 0206 0100 0104 0102a00000040 7502 u................. 0401: 0206 0100 0105 0102 0 02 0501 00000050..........0202. 1602: 0501 0206 0100 0106 0102 3402 4 00000060 .........&..... 0401: 0206c0100 0107 0102 2602 0501 0202 . : 00000070 4 02 0501 0206a0100 0108 0102 3302 ................ 0401: 3 00000080 0206 0100a 0109 0102 0 02 .........0501. 0202a1602: 00000090 0501b 0206 0100 010 0102 3702 0401 ......".....F... 0206b7: 000000 0 0100c 010 0102 2202 ....... .. 0501c0202: 4602d 0501 000000a0 0206 0100 010 0102 3302 ................ 0401d0206: 0100 3e 000000 0d010 0102 0 ....... .... 02e0501: 0202 1602 0501 0206 000000 0 0100 010 ........#...... 0102f6: 02 0401 0206 0100 010 000000 .....0 . ..... 0102: 1102 0501 0202 2302 0501 0206 0100 000000 ......%......... 0: 0110 0102 3502 0401 0206 0100 0111 . .....&. 0102: 5 00000100 1202c0501 0202 2502 0501 ....L......
Siç sugjeron emri, skedari block_upload_traffic.pcapng përmban një grumbull të trafikut të ngarkimit të bllokut në PLC.
Vlen të përmendet se kjo deponi e trafikut në vendin e konkursit gjatë konferencës ishte pak më e vështirë për t'u marrë. Për ta bërë këtë, ishte e nevojshme të kuptoni skriptin nga skedari i projektit për TeslaSCADA2. Prej tij ishte e mundur të kuptohej se ku ndodhej deponia e koduar duke përdorur RC4 dhe çfarë çelësi duhej të përdorej për ta deshifruar atë. Deponimet e blloqeve të të dhënave në vend mund të merren duke përdorur klientin e protokollit S7. Për këtë kam përdorur klientin demo nga paketa Snap7.
Nxjerrja e blloqeve të përpunimit të sinjalit nga një deponi trafiku
Duke parë përmbajtjen e hale, mund të kuptoni se ai përmban blloqe të përpunimit të sinjalit OB1, FC1, FC2 dhe FC3:
Këto blloqe duhet të hiqen. Kjo mund të bëhet, për shembull, me skriptin e mëposhtëm, pasi keni konvertuar më parë trafikun nga formati pcapng në 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 ('x1ex00', 'x1ex01'): # upload
buf += s7_data[4:]
elif s7_param == 'x1f':
with open(next(names), 'wb') as f:
f.write(buf)
buf = ''Pasi të keni ekzaminuar blloqet që rezultojnë, do të vini re se ato gjithmonë fillojnë me bajt 70 70 (pp). Tani ju duhet të mësoni se si t'i analizoni ato. Sugjerimi i detyrës sugjeron që ju duhet të përdorni PlcSim për këtë.
Marrja e udhëzimeve të lexueshme nga njeriu nga blloqet
Së pari, le të përpiqemi të programojmë S7-PlcSim duke ngarkuar disa blloqe me udhëzime të përsëritura (= Q 0.0) në të duke përdorur softuerin Simatic Manager dhe duke ruajtur PLC-në e marrë në emulator në skedarin example.plc. Duke parë përmbajtjen e skedarit, mund të përcaktoni lehtësisht fillimin e blloqeve të shkarkuar me nënshkrimin 70 70, të cilin e zbuluam më herët. Përpara blloqeve, me sa duket, madhësia e bllokut është shkruar si një vlerë 4-bajtë pak endian.
Pasi morëm informacion në lidhje me strukturën e skedarëve plc, u shfaq plani i mëposhtëm i veprimit për leximin e programeve PLC S7:
- Duke përdorur Simatic Manager, ne krijojmë një strukturë blloku në S7-PlcSim të ngjashme me atë që morëm nga hale. Madhësitë e blloqeve duhet të përputhen (kjo arrihet duke plotësuar blloqet me numrin e kërkuar të udhëzimeve) dhe identifikuesit e tyre (OB1, FC1, FC2, FC3).
- Ruani PLC-në në një skedar.
- Ne zëvendësojmë përmbajtjen e blloqeve në skedarin që rezulton me blloqet nga deponia e trafikut. Fillimi i blloqeve përcaktohet nga nënshkrimi.
- Ne ngarkojmë skedarin që rezulton në S7-PlcSim dhe shikojmë përmbajtjen e blloqeve në Simatic Manager.
Blloqet mund të zëvendësohen, për shembull, me kodin e mëposhtëm:
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)Alexey mori një rrugë ndoshta më të vështirë, por ende të saktë. Ne supozuam se pjesëmarrësit do të përdornin programin NetToPlcSim në mënyrë që PlcSim të mund të komunikonte përmes rrjetit, të ngarkonte blloqe në PlcSim nëpërmjet Snap7 dhe më pas t'i shkarkonin këto blloqe si projekt nga PlcSim duke përdorur mjedisin e zhvillimit.
Duke hapur skedarin që rezulton në S7-PlcSim, mund të lexoni blloqet e mbishkruara duke përdorur Simatic Manager. Funksionet kryesore të kontrollit të pajisjes regjistrohen në bllokun FC1. Vëmendje e veçantë është ndryshorja #TEMP0, e cila kur aktivizohet duket se e vendos kontrollin PLC në modalitetin manual bazuar në vlerat e memories bit M2.2 dhe M2.3. Vlera #TEMP0 vendoset nga funksioni FC3.
Për të zgjidhur problemin, duhet të analizoni funksionin FC3 dhe të kuptoni se çfarë duhet bërë në mënyrë që të kthejë një funksion logjik.
Blloqet e përpunimit të sinjalit PLC në stendën e sigurisë së ulët në vendin e konkurrencës u rregulluan në mënyrë të ngjashme, por për të vendosur vlerën e ndryshores #TEMP0, mjaftoi të shkruani rreshtin my ninja way në bllokun DB1. Kontrollimi i vlerës në një bllok ishte i drejtpërdrejtë dhe nuk kërkonte njohuri të thella të gjuhës programuese të bllokut. Natyrisht, në nivelin e Sigurisë së Lartë, arritja e kontrollit manual do të jetë shumë më e vështirë dhe është e nevojshme të kuptohen ndërlikimet e gjuhës STL (një nga mënyrat për të programuar S7 PLC).
Blloku i kundërt FC3
Përmbajtja e bllokut FC3 në përfaqësimin STL:
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_VALKodi është mjaft i gjatë dhe mund të duket i ndërlikuar për dikë që nuk e njeh STL. Nuk ka kuptim të analizojmë çdo udhëzim brenda kornizës së këtij neni; udhëzimet dhe aftësitë e hollësishme të gjuhës STL mund të gjenden në manualin përkatës: . Këtu do të paraqes të njëjtin kod pas përpunimit - duke riemërtuar etiketat dhe variablat dhe duke shtuar komente që përshkruajnë algoritmin e funksionimit dhe disa konstruksione të gjuhës STL. Më lejoni të vërej menjëherë se blloku në fjalë përmban një makinë virtuale që ekzekuton disa bajtkod të vendosur në bllokun DB100, përmbajtjen e të cilit ne e dimë. Udhëzimet e makinës virtuale përbëhen nga 1 bajt kodi operativ dhe bajtë argumentesh, një bajt për çdo argument. Të gjitha udhëzimet e konsideruara kanë dy argumente; unë i caktova vlerat e tyre në komente si X dhe Y.
Kodi pas përpunimit]
# Инициализация различных переменных
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_VALDuke pasur një ide për udhëzimet e makinës virtuale, le të shkruajmë një çmontues të vogël për të analizuar bajtkodin në bllokun 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))
breakSi rezultat, marrim kodin e mëposhtëm të makinës virtuale:
Kodi i makinës virtuale
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)Siç mund ta shihni, ky program thjesht kontrollon çdo karakter nga DB101 për barazi me një vlerë të caktuar. Linja përfundimtare për kalimin e të gjitha kontrolleve është: n0w u 4r3 7h3 m4573r. Nëse kjo linjë vendoset në bllokun DB101, atëherë aktivizohet kontrolli manual i PLC dhe do të jetë e mundur të shpërthejë ose të shfryhet baloni.
Kjo eshte e gjitha! Alexey demonstroi një nivel të lartë njohurish të denjë për një ninja industriale :) Ne i dërguam çmime të paharrueshme fituesit. Shumë faleminderit për të gjithë pjesëmarrësit!
Burimi: www.habr.com