Auf den vergangenen PHDays 9 haben wir einen Wettbewerb zum Hacken einer Gasumwälzungsanlage veranstaltet — einen Contest . Es gab drei Stände mit unterschiedlichen Sicherheitsparametern (Keine Sicherheit, Niedrige Sicherheit, Hohe Sicherheit), die denselben industriellen Prozess simulierten: In einen Luftballon wurde Luft unter Druck hineingepumpt (und dann wieder abgelassen).
Trotz der unterschiedlichen Sicherheitsparameter war die Hardware der Stände identisch: Siemens Simatic S7-300 PLC; Notfallablass-Taste und Druckmessgerät (angeschlossen an digitale Eingänge der PLC (DI)); Ventile, die das Pumpen und Ablassen von Luft steuerten (angeschlossen an digitale Ausgänge der PLC (DO)) — siehe Abbildung unten.
Die PLC traf je nach Druckanzeige und gemäß ihrem Programm die Entscheidung zum Ablassen oder Aufpumpen des Ballons (öffnete und schloss die entsprechenden Ventile). Auf allen Ständen war jedoch ein manueller Steuerungsmodus vorgesehen, der die Möglichkeit gab, die Zustände der Ventile ohne Einschränkungen zu steuern.
Die Stände wiesen Unterschiede in der Aktivierung dieses Modus auf: Auf dem ungeschützten Stand war es am einfachsten, während es auf dem High-Security-Stand entsprechend schwieriger war.
Innerhalb von zwei Tagen wurden fünf von sechs Aufgaben gelöst; der Teilnehmer, der den ersten Platz belegte, erzielte 233 Punkte (er hatte eine Woche für die Vorbereitung auf den Wettbewerb aufgewendet). Die drei Preisträger: I. Platz — a1exdandy, II. — Rubikoid, III. — Ze.
Allerdings konnte während der PHDays niemand von den Teilnehmern alle drei Stände bewältigen, weshalb wir uns entschieden, einen Online-Wettbewerb zu veranstalten und zu Beginn des Juni die schwierigste Aufgabe zu veröffentlichen. Die Teilnehmer hatten einen Monat Zeit, um die Aufgabe zu erfüllen, das Flag zu finden und die Lösung detailliert und interessant zu erläutern.
Unterhalb des Beitrags veröffentlichen wir die Analyse der besten Lösung der über den Monat eingereichten Aufgaben, die von Alexey Kovrizhnykh (a1exdandy) von Digital Security gefunden wurde, der den I. Platz im Wettbewerb während der PHDays belegte. Im Folgenden geben wir seinen Text mit unseren Kommentaren wieder.
Erste Analyse
Also, in der Aufgabe gab es ein Archiv mit Dateien:
- block_upload_traffic.pcapng
- DB100.bin
- hints.txt
Die Datei hints.txt enthält notwendige Informationen und Hinweise zur Lösung der Aufgabe. Hier ist der Inhalt:
- Petrovich hat mir gestern erzählt, dass man aus PlcSim Blöcke in Step7 laden kann.
- Am Stand wurde eine Siemens Simatic S7-300 SPS verwendet.
- PlcSim ist ein Emulator für SPS, mit dem Programme für die Siemens S7 SPS ausgeführt und debuggt werden können.
Die Datei DB100.bin scheint einen Datenblock DB100 der SPS zu enthalten: 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 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 L...........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 ......".....F... 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.......
Nach dem Dateinamen zu urteilen, enthält die Datei block_upload_traffic.pcapng einen Dump des Upload-Traffics auf die SPS.
Es ist erwähnenswert, dass es etwas schwieriger war, diesen Datenverkehrsdump während der Konferenz auf der Wettbewerbsplattform zu erhalten. Dazu musste man sich im Skript der Projektdatei für TeslaSCADA2 zurechtfinden. Daraus konnte man entnehmen, wo sich der mit RC4 verschlüsselte Dump befindet und welchen Schlüssel man für die Entschlüsselung verwenden muss. Die Dumps der Datenblöcke auf der Plattform konnten mit einem S7-Protokoll-Client abgerufen werden. Ich habe dafür den Democlient aus dem Snap7-Paket verwendet.
Extraktion von Signalverarbeitungsblöcken aus dem Datenverkehrsdump
Ein Blick auf den Dump zeigt, dass darin die Signalverarbeitungsblöcke OB1, FC1, FC2 und FC3 übertragen werden:
Diese Blöcke müssen extrahiert werden. Dies kann beispielsweise mit folgendem Skript erfolgen, nachdem der Datenverkehr von pcapng in pcap konvertiert wurde:
#!/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 = ''Wenn man die erhaltenen Blöcke untersucht, fällt auf, dass sie immer mit den Bytes 70 70 (pp) beginnen. Jetzt muss man lernen, sie zu analysieren. Der Hinweis zur Aufgabe lässt darauf schließen, dass man hierfür PlcSim verwenden sollte.
Erhalten von menschenlesbaren Anweisungen aus den Blöcken
Zunächst versuchen wir, S7-PlcSim zu programmieren, indem wir einige Blöcke mit wiederholenden Anweisungen (= Q 0.0) mit der Software Simatic Manager laden und das resultierende PLC im Emulator in eine Datei example.plc speichern. Durch einen Blick auf den Inhalt der Datei können wir den Anfang der geladenen Blöcke leicht an der Signatur 70 70 erkennen, die wir zuvor gefunden haben. Vor den Blöcken scheint die Größenangabe des Blocks in Form eines 4-Byte-Little-Endian-Werts gespeichert zu sein.
Nachdem wir Informationen über die Struktur von PLC-Dateien erhalten haben, ergibt sich der folgende Plan für das Lesen von PLC-Programmen für S7:
- Mit Simatic Manager erstellen wir in S7-PlcSim eine Blockstruktur, die derjenigen aus dem Dump entspricht. Die Blockgrößen müssen übereinstimmen (dies wird durch die Auffüllung der Blöcke mit der erforderlichen Anzahl an Anweisungen erreicht) sowie deren Identifikatoren (OB1, FC1, FC2, FC3).
- Wir speichern das PLC in eine Datei.
- Wir ersetzen den Inhalt der Blöcke in der erhaltenen Datei durch die Blöcke aus dem Verkehrsdump. Den Anfang der Blöcke bestimmen wir anhand der Signatur.
- Die erhaltene Datei laden wir in S7-PlcSim und betrachten den Inhalt der Blöcke im Simatic Manager.
Die Ersetzung der Blöcke kann beispielsweise mit folgendem Code durchgeführt werden:
mit open('original.plc', 'rb') as f:
plc = f.read()
blocks = []
for fname in ['OB1.bin', 'FC1.bin', 'FC2.bin', 'FC3.bin']:
mit 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)
mit open('target.plc', 'wb') as f:
f.write(plc)Alexej hat sich für einen möglicherweise komplizierteren, aber dennoch richtigen Weg entschieden. Wir gingen davon aus, dass die Teilnehmer das Programm NetToPlcSim verwenden würden, um mit PlcSim über das Netzwerk zu kommunizieren, die Blöcke über Snap7 in PlcSim hochladen und dann diese Blöcke als Projekt aus PlcSim mit der Entwicklungsumgebung herunterladen.
Wenn man die erhaltene Datei in S7-PlcSim öffnet, können die überschriebenen Blöcke mit dem Simatic Manager gelesen werden. Die wichtigsten Geräteverwaltungsfunktionen sind im Block FC1 gespeichert. Besonders auffällig ist die Variable #TEMP0, deren Aktivierung anscheinend die Steuerung des SPS in den manuellen Modus basierend auf den Werten des Bit-Speichers M2.2 und M2.3 überträgt. Der Wert von #TEMP0 wird durch die Funktion FC3 gesetzt.
Um die Aufgabe zu lösen, muss die Funktion FC3 analysiert werden, um zu verstehen, was getan werden muss, damit sie eine logische Eins zurückgibt.
Die Signalverarbeitungsblöcke des PLC im Low Security-Bereich der Wettbewerbsstation wurden auf die gleiche Weise eingerichtet. Um den Wert der Variablen #TEMP0 festzulegen, genügte es, die Zeile my ninja way im Block DB1 zu schreiben. Die Prüfung des Wertes im Block war klar strukturiert und erforderte keine tiefen Kenntnisse der Blockprogrammierung. Offensichtlich wird es auf der High Security-Ebene deutlich schwieriger sein, manuelle Steuerungen zu erreichen, und man muss sich mit den Feinheiten der STL-Sprache (eine der Programmiermethoden für PLC S7) auseinandersetzen.
Rückwärtsblock FC3
Inhalt des Blocks FC3 in STL-Darstellung:
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_VALDer Code ist recht umfangreich und könnte für jemanden, der mit STL nicht vertraut ist, kompliziert erscheinen. Es macht keinen Sinn, jede Anweisung in diesem Artikel zu analysieren; detaillierte Informationen zu den Anweisungen und Möglichkeiten der STL-Sprache finden Sie im entsprechenden Handbuch: . Hier präsentiere ich denselben Code nach der Aufbereitung – Umbenennung von Etiketten und Variablen sowie Hinzufügen von Kommentaren, die den Arbeitsablauf und einige Konstruktionen der STL-Sprache beschreiben. Ich möchte betonen, dass im betrachteten Block eine virtuelle Maschine implementiert ist, die einen bestimmten Bytecode ausführt, der im Block DB100 gespeichert ist, dessen Inhalt uns bekannt ist. Die Anweisungen der virtuellen Maschine bestehen aus 1 Byte Opcode und Bytes für die Argumente, jeweils ein Byte für jedes Argument. Alle besprochenen Anweisungen haben zwei Argumente, deren Werte in den Kommentaren als X und Y gekennzeichnet sind.
Code nach der Aufbereitung]
# Инициализация различных переменных
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_VALNachdem wir ein Verständnis für die Anweisungen der virtuellen Maschine erhalten haben, werden wir einen kleinen Disassembler schreiben, um den Bytecode im Block DB100 zu analysieren:
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{})
'.format(
m[pc + 1], m[pc + 2]))
pc += 3
else:
print('unk opcode {}'.format(op))
breakDas Ergebnis wird der folgende Code der virtuellen Maschine sein:
Code der virtuellen Maschine
R1 = DB101[0]
R2 = 6e (n)
R0 = 0; R1 = (R1 == R2)
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[1]
R2 = 10 (?)
R0 = 0; R1 = R1 - R2
R2 = 20 (?)
R0 = 0; R1 = R1 - R2
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[2]
R2 = 77 (w)
R0 = 0; R1 = (R1 == R2)
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[3]
R2 = 0a (?)
R0 = 0; R1 = R1 - R2
R2 = 16 (?)
R0 = 0; R1 = R1 - R2
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[4]
R2 = 75 (u)
R0 = 0; R1 = (R1 == R2)
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[5]
R2 = 0a (?)
R0 = 0; R1 = R1 - R2
R2 = 16 (?)
R0 = 0; R1 = R1 - R2
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[6]
R2 = 34 (4)
R0 = 0; R1 = (R1 == R2)
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[7]
R2 = 26 (?)
R0 = 0; R1 = R1 - R2
R2 = 4c (L)
R0 = 0; R1 = R1 - R2
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[8]
R2 = 33 (3)
R0 = 0; R1 = (R1 == R2)
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[9]
R2 = 0a (?)
R0 = 0; R1 = R1 - R2
R2 = 16 (?)
R0 = 0; R1 = R1 - R2
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[10]
R2 = 37 (7)
R0 = 0; R1 = (R1 == R2)
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[11]
R2 = 22 (?)
R0 = 0; R1 = R1 - R2
R2 = 46 (F)
R0 = 0; R1 = R1 - R2
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[12]
R2 = 33 (3)
R0 = 0; R1 = (R1 == R2)
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[13]
R2 = 0a (?)
R0 = 0; R1 = R1 - R2
R2 = 16 (?)
R0 = 0; R1 = R1 - R2
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[14]
R2 = 6d (m)
R0 = 0; R1 = (R1 == R2)
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[15]
R2 = 11 (?)
R0 = 0; R1 = R1 - R2
R2 = 23 (?)
R0 = 0; R1 = R1 - R2
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[16]
R2 = 35 (5)
R0 = 0; R1 = (R1 == R2)
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[17]
R2 = 12 (?)
R0 = 0; R1 = R1 - R2
R2 = 25 (?)
R0 = 0; R1 = R1 - R2
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[18]
R2 = 33 (3)
R0 = 0; R1 = (R1 == R2)
ÜBERPRÜFEN (R1 == R0)
R1 = DB101[19]
R2 = 26 (?)
R0 = 0; R1 = R1 - R2
R2 = 4c (L)
R0 = 0; R1 = R1 - R2
ÜBERPRÜFEN (R1 == R0)Wie zu sehen ist, überprüft dieses Programm einfach jedes Zeichen aus DB101 auf eine bestimmte Übereinstimmung. Die endgültige Zeichenkette, um alle Prüfungen zu bestehen: n0w u 4r3 7h3 m4573r. Wenn diese Zeichenkette in den DB101-Bereich eingegeben wird, aktiviert sich die manuelle Steuerung des PLC und man kann den Luftballon sprengen oder entleeren.
Das ist alles! Alexej hat ein beeindruckendes Wissen gezeigt, das einem industriellen Ninja würdig ist 🙂 Dem Gewinner haben wir Andenken geschickt. Vielen Dank an alle Teilnehmer!
Quelle: habr.com
