Möödunud PHDays 9 korraldasime gaasipumbatehase häkkimise võistluse – võistluse . Kohapeal oli kolm erinevate turvaparameetritega stendi (ei turvalisus, madal turvalisus, kõrge turvalisus), mis jäljendasid sama tööstuslikku protsessi: rõhu all olev õhk pumbati õhupalli (ja seejärel vabastati).
Vaatamata erinevatele ohutusparameetritele oli stendide riistvaraline koostis sama: Siemens Simatic PLC S7-300 seeria; hädaolukorra tühjendamise nupp ja rõhu mõõtmise seade (ühendatud PLC digitaalsisenditega (DI)); ventiilid, mis töötavad õhu täitmiseks ja tühjendamiseks (ühendatud PLC (DO) digitaalväljunditega) - vt allolevat joonist.
PLC tegi olenevalt rõhunäitudest ja vastavalt oma programmile otsuse palli tühjendamiseks või täispuhumiseks (avanud ja sulgenud vastavad klapid). Kõigil stendidel oli aga käsitsijuhtimise režiim, mis võimaldas klappide olekuid piiranguteta juhtida.
Stendid erinesid selle režiimi lubamise keerukusest: kaitsmata stendil oli seda kõige lihtsam teha ja High Security stendil vastavalt keerulisem.
Kuuest probleemist viis lahendati kahe päevaga; Esikohal osaleja kogus 233 punkti (võistluseks valmistudes kulutas ta nädala). Kolm võitjat: I koht - a1exdandy, II - Rubikoid, III - Ze.
PHDpäevade ajal ei suutnud aga ükski osaleja kõigist kolmest tribüünist jagu saada, mistõttu otsustasime teha veebipõhise võistluse ja avaldasime juuni alguses kõige keerulisema ülesande. Osalejad pidid kuu aja jooksul ülesande täitma, lipukese leidma ning lahendust üksikasjalikult ja huvitavalt kirjeldama.
Lõike all avaldame analüüsi kuu jooksul saadetutest ülesande parima lahenduse kohta, selle leidis Alexey Kovrizhnykh (a1exdandy) ettevõttest Digital Security, kes saavutas PHDaysi võistlusel XNUMX. koha. Allpool esitame selle teksti koos oma kommentaaridega.
Esialgne analüüs
Niisiis sisaldas ülesanne arhiivi järgmiste failidega:
- block_upload_traffic.pcapng
- DB100.bin
- hints.txt
Fail hints.txt sisaldab ülesande lahendamiseks vajalikku infot ja näpunäiteid. Siin on selle sisu:
- Petrovitš ütles mulle eile, et saate PlcSimist plokke Step7 laadida.
- Stendil oli kasutusel Siemens Simatic S7-300 seeria PLC.
- PlcSim on PLC-emulaator, mis võimaldab teil Siemens S7 PLC-de jaoks programme käivitada ja siluda.
Fail DB100.bin näib sisaldavat DB100 PLC andmeplokki: 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 0501 .......&..... 0202: 1602c0501 0206 0100 0104 0102 00000040 7502 0401 0206 0100 0105 0102 0 02 .. : 0501 00000050 0202 1602 0501a0206 0100 0106 0102 ................ 3402: 4 00000060 0401 0206a 0100 0107 0102 2602 .......... 0501a0202: 00000070 4b 02 0501 0206 0100 0108 0102 ......".....F... 3302b0401: 3 00000080 0206c 0100 0109 0102 ........0. ... .... 02e0501: 0202 1602 00000090 0501 0206 0100 010 0102 ........#...... 3702f0401: 0206 7 000000 0 0100 010 ..... ......... .....&. 0102: 2202 0501 0202c4602 0501 000000 0 ....L......
Nagu nimigi ütleb, sisaldab fail block_upload_traffic.pcapng plokkide üleslaadimise liiklust PLC-sse.
Väärib märkimist, et konverentsi ajal võistluspaigas oli seda liikluspuhangut veidi keerulisem hankida. Selleks oli vaja mõista TeslaSCADA2 projektifaili skripti. Sellest oli võimalik aru saada, kus RC4 abil krüpteeritud dump asus ja millist võtit oli vaja selle dekrüpteerimiseks kasutada. Kohapealsete andmeplokkide väljavõtteid saab hankida S7 protokollikliendi abil. Selleks kasutasin Snap7 paketist pärit demoklienti.
Signaalitöötlusplokkide eraldamine liiklusmähist
Vaadates prügikasti sisu, saate aru, et see sisaldab signaalitöötlusplokke OB1, FC1, FC2 ja FC3:
Need plokid tuleb eemaldada. Seda saab teha näiteks järgmise skriptiga, olles eelnevalt teisendanud liikluse pcapng-vormingust pcap-i:
#!/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 = ''Olles uurinud saadud plokke, märkate, et need algavad alati baitidega 70 70 (pp). Nüüd peate õppima, kuidas neid analüüsida. Määramise vihje viitab sellele, et selleks tuleb kasutada PlcSimi.
Inimloetavate juhiste saamine plokkidest
Kõigepealt proovime programmeerida S7-PlcSimi, laadides sellesse Simatic Manager tarkvara abil mitu korduvate juhistega plokki (= Q 0.0) ja salvestades emulaatoris saadud PLC faili example.plc. Faili sisu vaadates saate hõlpsasti määrata allalaaditud plokkide alguse signatuuriga 70 70, mille me varem avastasime. Enne plokke on ilmselt ploki suurus kirjutatud 4-baidise little-endiani väärtusena.
Pärast plc-failide struktuuri kohta teabe saamist ilmus PLC S7 programmide lugemiseks järgmine tegevuskava:
- Simatic Manageri abil loome S7-PlcSimis plokistruktuuri, mis sarnaneb prügikastist saadud struktuuriga. Plokkide suurused peavad ühtima (see saavutatakse, täites plokid vajaliku arvu käskudega) ja nende identifikaatorid (OB1, FC1, FC2, FC3).
- Salvestage PLC faili.
- Saadud failis asendame plokkide sisu liiklusmässist pärinevate plokkidega. Plokkide algus määratakse allkirjaga.
- Laadime saadud faili S7-PlcSimi ja vaatame Simatic Manageris plokkide sisu.
Plokid saab asendada näiteks järgmise koodiga:
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 valis võib-olla raskema, kuid siiski õige tee. Eeldasime, et osalejad kasutavad programmi NetToPlcSim, et PlcSim saaks üle võrgu suhelda, Snap7 kaudu PlcSimi plokid üles laadida ja seejärel arenduskeskkonda kasutades PlcSimist projektina need plokid alla laadida.
Avades saadud faili S7-PlcSimis, saate Simatic Manageri abil lugeda üle kirjutatud plokke. Peamised seadme juhtimisfunktsioonid on salvestatud plokis FC1. Erilist tähelepanu väärib muutuja #TEMP0, mis sisselülitamisel seab PLC-juhtimise M2.2- ja M2.3-bitise mälu väärtuste põhjal käsitsi režiimi. #TEMP0 väärtus määratakse funktsiooniga FC3.
Probleemi lahendamiseks peate analüüsima funktsiooni FC3 ja mõistma, mida tuleb teha, et see tagastaks loogilise funktsiooni.
Sarnaselt olid paigutatud ka võistluspaiga Low Security stendi PLC signaalitöötlusplokid, kuid #TEMP0 muutuja väärtuse määramiseks piisas sellest, kui kirjutasin DB1 plokki rida my ninja way. Plokis oleva väärtuse kontrollimine oli lihtne ega nõudnud ploki programmeerimiskeele sügavaid teadmisi. Ilmselgelt on kõrge turvalisuse tasemel käsitsi juhtimise saavutamine palju keerulisem ja on vaja mõista STL-keele (üks S7 PLC programmeerimise viise) keerukust.
Tagurpidi plokk FC3
FC3 ploki sisu STL-esituses:
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_VALKood on üsna pikk ja võib tunduda keeruline kellelegi, kes STL-i ei tunne. Selle artikli raames pole mõtet iga juhiseid analüüsida, STL-keele üksikasjalikud juhised ja võimalused leiate vastavast juhendist: . Siin esitan sama koodi pärast töötlemist - siltide ja muutujate ümbernimetamist ning tegevusalgoritmi ja mõningaid STL keele konstruktsioone kirjeldavate kommentaaride lisamist. Märgin kohe ära, et kõnealune plokk sisaldab virtuaalmasinat, mis täidab mingit DB100 plokis asuvat baitkoodi, mille sisu on meile teada. Virtuaalmasina käsud koosnevad 1 baidist tegevuskoodist ja argumentide baitidest, üks bait iga argumendi kohta. Kõigil vaadeldavatel juhistel on kaks argumenti; märkisin nende väärtusteks kommentaarides X ja Y.
Kood pärast töötlemist]
# Инициализация различных переменных
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_VALOlles saanud aimu virtuaalmasina juhistest, kirjutame väikese disassembleri, et sõeluda DB100 plokis baitkood:
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))
breakSelle tulemusena saame järgmise virtuaalmasina koodi:
Virtuaalse masina kood
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)Nagu näete, kontrollib see programm lihtsalt iga DB101 märgi võrdsust teatud väärtusega. Kõigi kontrollide läbimise viimane rida on: n0w u 4r3 7h3 m4573r. Kui see rida asetatakse plokki DB101, siis aktiveeritakse käsitsi PLC juhtimine ja on võimalik õhupalli plahvatada või tühjendada.
See on kõik! Alexey demonstreeris kõrget tööstusninja väärilist teadmiste taset :) Võitjale saatsime meeldejäävad auhinnad. Suur tänu kõigile osalejatele!
Allikas: www.habr.com