在最後的 PHDays 9 上，我們舉辦了一場破解天然氣泵站的競賽 - 競賽 。 現場有三個具有不同安全參數的展位（無安全性、低安全性、高安全性），模擬相同的工業流程：加壓空氣被泵入氣球（然後釋放）。
儘管安全參數不同，但展位的硬體組成是相同的：西門子Simatic PLC S7-300系列； 緊急放氣按鈕和壓力測量裝置（連接到PLC數位輸入（DI））； 用於充氣和放氣的閥門（連接到 PLC (DO) 的數位輸出） - 請參閱下圖。
PLC根據壓力讀數並按照其程序做出對球進行放氣或充氣的決定（打開和關閉相應的閥門）。 不過，所有月台都有手動控制模式，可以不受任何限制地控制閥門的狀態。
各個展位啟用此模式的複雜性有所不同：在無保護的展位上最容易做到這一點，而在高安全性展位上則相應地更困難。
兩天內解決了六個問題中的五個； 第一名的選手獲得了233分（他花了一週的時間準備比賽）。 三位得獎者：第一名 - a1exdandy，第二名 - Rubikoid，第三名 - Ze。
然而，在 PHDays 期間，沒有一個參賽者能夠克服所有三個看台，因此我們決定進行線上比賽，並在 XNUMX 月初公佈了最困難的任務。 參與者必須在一個月內完成任務，找到旗幟，並以有趣的方式詳細描述解決方案。
在剪輯下方，我們發布了對本月發送的任務最佳解決方案的分析，該分析是由數位安全公司的 Alexey Kovrizhnykh (a1exdandy) 發現的，他在 PHDays 比賽中獲得了第一名。 下面我們將介紹其文本和我們的評論。
初步分析
因此，該任務包含包含以下文件的存檔：
- block_upload_traffic.pcapng
- DB100.bin
- 提示.txt
hins.txt 檔案包含解決任務所需的資訊和提示。 以下是其內容：
- Petrovich 昨天告訴我，您可以將 PlcSim 中的區塊載入到 Step7 中。
- 展台採用了西門子Simatic S7-300系列PLC。
- PlcSim 是一個 PLC 仿真器，可讓您運行和偵錯西門子 S7 PLC 的程式。
DB100.bin 檔案似乎包含 DB100 PLC 資料區塊： 00000000: 0100 0102 6e02 0401 0206 0100 0101 0102 ....n......... 00000010: 1002 0501 0202 2002第0501章.. ........... 0206：0100 0102 00000020 0102 7702 0401 0206 0100a0103 ............ 0102：0 02 00000030 0501 0202 1602 0501 0206 0100. ................ 0104: 0102 00000040 7502 0401 0206 0100 0105a0102 0 ....................... 02: 0501 00000050 0202 1602 0501 0206 0100 0106......0102. 3402: 4 00000060 0401 0206 0100 0107 0102 2602 ....... 0501: 0202c00000070 4 02 0501: 0206c0100 0108 0102 3302 0401 3. 00000080 0206 0100 0109 0102a0 02 0501 0202 ........ 1602: 00000090 0501 0206 0100a 010 0102 3702 0401 ........0206. .... 7a000000: 0 0100b 010 0102... .F... 2202b0501: 0202 4602 0501c 000000 0 0206 0100 010 ........0102. .... .. 3302c0401: 0206d 0100 3a000000 0 010 0102 0 02 ........ 0501d0202 : 1602 0501e 0206 000000d0 0100 010 0102 6f ......m. .... .... 02e0401: 0206 0100 010 000000 0 0102 1102 0501 0202 2302 0501 0206 0100f000000: 0 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 ..... .....&. 4: 02 0501 ..... .....&. 0206: 0100 XNUMX XNUMXcXNUMX XNUMX.
顧名思義，block_upload_traffic.pcapng 檔案包含到 PLC 的區塊上傳流量的轉儲。
值得注意的是，這次大會期間比賽現場的流量轉儲有點難取得。 為此，有必要了解 TeslaSCADA2 專案文件中的腳本。 從中可以了解使用 RC4 加密的轉儲位於何處以及需要使用什麼金鑰來解密它。 現場資料塊的轉儲可以使用S7協定客戶端取得。 為此，我使用了 Snap7 套件中的演示客戶端。
從流量轉儲中提取訊號處理區塊
查看轉儲的內容，可以了解它包含訊號處理區塊OB1、FC1、FC2和FC3：
這些塊必須被移除。 例如，可以使用以下腳本來完成此操作，之前已將流量從 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 ('x1ex00', 'x1ex01'): # upload
buf += s7_data[4:]
elif s7_param == 'x1f':
with open(next(names), 'wb') as f:
f.write(buf)
buf = ''檢查生成的區塊後，您會注意到它們始終以位元組 70 70 (pp) 開頭。 現在您需要學習如何分析它們。 指派提示表示您需要為此使用 PlcSim。
從區塊中取得人類可讀的指令
首先，我們嘗試使用 Simatic Manager 軟體將多個具有重複指令 (= Q 7) 的區塊載入到 S0.0-PlcSim 中，並將模擬器中獲得的 PLC 儲存到 example.plc 檔案中。 透過查看文件的內容，您可以透過我們先前發現的簽名 70 70 輕鬆確定下載區塊的開頭。 顯然，在區塊之前，區塊大小被寫為 4 位元組小端值。
當我們收到有關plc檔案結構的資訊後，出現了以下讀取PLC S7程式的行動計畫：
- 使用 Simatic Manager，我們在 S7-PlcSim 中建立一個類似於我們從轉儲中收到的區塊結構。 區塊大小必須匹配（這是透過用所需數量的指令填充區塊來實現的）及其識別碼（OB1、FC1、FC2、FC3）。
- 將 PLC 儲存到文件中。
- 我們將結果檔案中的區塊內容替換為流量轉儲中的區塊。 區塊的開始由簽名決定。
- 我們將產生的檔案載入到 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 中開啟產生的文件，您可以使用 Simatic Manager 讀取所覆蓋的區塊。 主要設備控制功能記錄在區塊FC1中。 特別值得注意的是#TEMP0 變量，當開啟該變量時，它會根據 M2.2 和 M2.3 位元記憶體值將 PLC 控制設定為手動模式。 #TEMP0 值由功能 FC3 設定。
要解決該問題，您需要分析 FC3 函數並了解需要做什麼才能傳回邏輯值。
比賽現場低安全看台的 PLC 訊號處理區塊以類似的方式排列，但要設定 #TEMP0 變數的值，只需將我的忍者方式寫入 DB1 區塊即可。 檢查區塊中的值非常簡單，不需要深入了解區塊程式語言。 顯然，在高安全級別，實現手動控制會困難得多，有必要了解STL語言（S7 PLC程式設計方式之一）的複雜性。
反向區塊 FC3
STL 表示形式的 FC3 區塊的內容：
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_VAL該程式碼相當冗長，對於不熟悉 STL 的人來說可能看起來很複雜。 在本文的框架內分析每條指令是沒有意義的；STL語言的詳細指令和功能可以在相應的手冊中找到： 。 在這裡，我將展示處理後的相同程式碼 - 重命名標籤和變數並添加描述操作演算法和一些 STL 語言結構的註解。 讓我立即註意到，所討論的區塊包含一個虛擬機，該虛擬機執行位於 DB100 區塊中的一些字節碼，我們知道其內容。 虛擬機器指令由 1 個位元組的操作代碼和位元組的參數組成，每個參數一個位元組。 所有考慮的指令都有兩個參數；我在註解中將它們的值指定為 X 和 Y。
處理後的程式碼]
# Инициализация различных переменных
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_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 控制，並且可以使氣球爆炸或放氣。
就這樣！ Alexey 展現了工業忍者應有的高水平知識:) 我們為獲勝者頒發了令人難忘的獎品。 非常感謝所有參與者！
來源： www.habr.com