Tijdens de laatste PHDays 9 hielden we een wedstrijd om een benzinepompinstallatie te hacken - een wedstrijd . Er waren drie stands op het terrein met verschillende beveiligingsparameters (geen beveiliging, lage beveiliging, hoge beveiliging), die hetzelfde industriële proces nabootsten: lucht onder druk werd in een ballon gepompt (en vervolgens losgelaten).
Ondanks de verschillende veiligheidsparameters was de hardwaresamenstelling van de stands hetzelfde: Siemens Simatic PLC S7-300-serie; noodleegknop en drukmeetapparaat (aangesloten op digitale PLC-ingangen (DI)); kleppen die werken voor het opblazen en laten leeglopen van lucht (aangesloten op de digitale uitgangen van de PLC (DO)) - zie onderstaande afbeelding.
De PLC nam, afhankelijk van de drukmetingen en in overeenstemming met zijn programma, een beslissing om de bal leeg te laten lopen of op te blazen (de bijbehorende kleppen opende en sloot). Alle stands hadden echter een handmatige bedieningsmodus, waardoor het mogelijk was om de standen van de kleppen zonder enige beperking te regelen.
De stands verschilden in de complexiteit van het inschakelen van deze modus: op de onbeschermde stand was dit het gemakkelijkst, en op de High Security-stand was het navenant moeilijker.
Vijf van de zes problemen waren in twee dagen opgelost; De deelnemer op de eerste plaats verdiende 233 punten (hij was een week bezig met de voorbereiding op de competitie). Drie winnaars: ik plaats - a1exdandy, II - Rubikoid, III - Ze.
Tijdens PHDays kon geen van de deelnemers echter alle drie de stands overwinnen, dus besloten we een online competitie te maken en begin juni de moeilijkste taak te publiceren. Deelnemers moesten de taak binnen een maand voltooien, de vlag vinden en de oplossing gedetailleerd en op een interessante manier beschrijven.
Onder de snede publiceren we een analyse van de beste oplossing voor de taak van degenen die in de loop van de maand zijn verzonden. Deze werd gevonden door Alexey Kovrizhnykh (a1exdandy) van het Digital Security-bedrijf, die tijdens PHDays de eerste plaats behaalde in de competitie. Hieronder presenteren wij de tekst met ons commentaar.
Initiële analyse
De taak bevatte dus een archief met de volgende bestanden:
- block_upload_traffic.pcapng
- DB100.bin
- hints.txt
Het bestand hints.txt bevat de benodigde informatie en hints om de taak op te lossen. Hier is de inhoud:
- Petrovich vertelde me gisteren dat je blokken van PlcSim in Step7 kunt laden.
- Op de stand werd gebruik gemaakt van de Siemens Simatic S7-300 serie PLC.
- PlcSim is een PLC-emulator waarmee u programma's voor Siemens S7 PLC's kunt uitvoeren en fouten kunt opsporen.
Het DB100.bin-bestand lijkt het DB100 PLC-datablok te bevatten: 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 02a00000030 ..w... 0501: 0202 1602 0501 0206 0100 0104 0102 00000040 ................ 7502: 0401 0206 0100 0105 0102 0 02a0501 00000050 u.............. 0202: 1602 0501 0206 0100 0106 0102 3402 4..............00000060. 0401: 0206 0100 0107 0102 2602 0501 0202 00000070 ......... & ..... 4: 02C0501 0206 0100 0108 0102 3302 0401 3 L ......... 00000080. .. 0206 : 0100 0109 0102 0 02a0501 0202 1602 00000090 ................ 0501: 0206 0100 010 0102a 3702 0401 0206 7 .........000000. .... 0a0100: 010 0102b 2202 0501 0202 4602 0501 000000 .......F... 0b0206: 0100 010 0102c 3302 0401 0206 0100 3 ........000000. .... .. 0c010: 0102d 0 02a0501 0202 1602 0501 0206 000000 ................ 0d0100: 010 0102e 6 02d0401 0206 0100 010 000000f ......m. .... .... 0e0102: 1102 0501 0202 2302 0501 0206 0100 000000 ........#...... 0f0110: 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 02c0501 0206 0100 XNUMX ....L......
Zoals de naam al doet vermoeden, bevat het block_upload_traffic.pcapng-bestand een dump van blokuploadverkeer naar de PLC.
Het is vermeldenswaard dat deze verkeersdump op het wedstrijdterrein tijdens de conferentie iets moeilijker te verkrijgen was. Om dit te doen was het nodig om het script uit het projectbestand voor TeslaSCADA2 te begrijpen. Hieruit was het mogelijk om te begrijpen waar de met RC4 gecodeerde dump zich bevond en welke sleutel moest worden gebruikt om deze te decoderen. Dumps van datablokken op locatie kunnen worden verkregen met behulp van de S7-protocolclient. Hiervoor heb ik de democlient uit het Snap7-pakket gebruikt.
Signaalverwerkingsblokken extraheren uit een verkeersdump
Als je naar de inhoud van de dump kijkt, kun je begrijpen dat deze signaalverwerkingsblokken OB1, FC1, FC2 en FC3 bevat:
Deze blokken moeten worden verwijderd. Dit kan bijvoorbeeld worden gedaan met het volgende script, nadat u eerder het verkeer van het pcapng-formaat naar pcap hebt geconverteerd:
#!/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 = ''Als je de resulterende blokken hebt onderzocht, zul je merken dat ze altijd beginnen met bytes 70 70 (pp). Nu moet je leren hoe je ze kunt analyseren. De opdrachthint suggereert dat u hiervoor PlcSim moet gebruiken.
Voor mensen leesbare instructies uit blokken halen
Laten we eerst proberen S7-PlcSim te programmeren door er verschillende blokken met herhalende instructies (= Q 0.0) in te laden met behulp van de Simatic Manager-software, en de in de emulator verkregen PLC op te slaan in het bestand example.plc. Door naar de inhoud van het bestand te kijken, kun je eenvoudig het begin van de gedownloade blokken bepalen aan de hand van de handtekening 70 70, die we eerder ontdekten. Vóór de blokken wordt de blokgrootte blijkbaar geschreven als een kleine endian-waarde van 4 bytes.
Nadat we informatie hadden ontvangen over de structuur van plc-bestanden, verscheen het volgende actieplan voor het inlezen van PLC S7-programma's:
- Met Simatic Manager creëren we in S7-PlcSim een blokstructuur die lijkt op de blokstructuur die we van de dump hebben ontvangen. De blokgroottes moeten overeenkomen (dit wordt bereikt door de blokken te vullen met het vereiste aantal instructies) en hun identificatiegegevens (OB1, FC1, FC2, FC3).
- Sla de PLC op in een bestand.
- We vervangen de inhoud van de blokken in het resulterende bestand door de blokken uit de verkeersdump. Het begin van de blokken wordt bepaald door de handtekening.
- We laden het resulterende bestand in S7-PlcSim en bekijken de inhoud van de blokken in Simatic Manager.
Blokken kunnen bijvoorbeeld worden vervangen door de volgende code:
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 nam een misschien moeilijker, maar nog steeds correct pad. We gingen ervan uit dat deelnemers het NetToPlcSim-programma zouden gebruiken, zodat PlcSim over het netwerk kon communiceren, blokken naar PlcSim kon uploaden via Snap7 en deze blokken vervolgens als een project van PlcSim kon downloaden met behulp van de ontwikkelomgeving.
Door het resulterende bestand in S7-PlcSim te openen, kunt u de overschreven blokken lezen met behulp van de Simatic Manager. De belangrijkste apparaatbesturingsfuncties zijn vastgelegd in blok FC1. Van bijzonder belang is de #TEMP0-variabele, die, wanneer ingeschakeld, de PLC-besturing in de handmatige modus lijkt te zetten op basis van de M2.2- en M2.3-bitgeheugenwaarden. De #TEMP0-waarde wordt ingesteld door functie FC3.
Om het probleem op te lossen, moet u de FC3-functie analyseren en begrijpen wat er moet gebeuren zodat deze een logische retourneert.
De PLC-signaalverwerkingsblokken op de Low Security-stand op het wedstrijdterrein waren op een vergelijkbare manier gerangschikt, maar om de waarde van de #TEMP0-variabele in te stellen, was het voldoende om de regel op mijn ninja-manier in het DB1-blok te schrijven. Het controleren van de waarde in een blok was eenvoudig en vereiste geen diepgaande kennis van de blokprogrammeertaal. Het is duidelijk dat op het High Security-niveau het bereiken van handmatige bediening veel moeilijker zal zijn en het is noodzakelijk om de fijne kneepjes van de STL-taal te begrijpen (een van de manieren om de S7 PLC te programmeren).
Omkeerblok FC3
Inhoud van het FC3-blok in STL-weergave:
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_VALDe code is behoorlijk lang en kan ingewikkeld lijken voor iemand die niet bekend is met STL. Het heeft geen zin om elke instructie in het kader van dit artikel te analyseren; gedetailleerde instructies en mogelijkheden van de STL-taal zijn te vinden in de bijbehorende handleiding: . Hier zal ik dezelfde code presenteren na verwerking - waarbij ik de labels en variabelen hernoem en commentaar toevoeg dat het werkingsalgoritme en enkele STL-taalconstructies beschrijft. Laat me meteen opmerken dat het blok in kwestie een virtuele machine bevat die een bytecode uitvoert die zich in het DB100-blok bevindt, waarvan we de inhoud kennen. Instructies voor virtuele machines bestaan uit 1 byte aan bedieningscode en bytes aan argumenten, één byte voor elk argument. Alle beschouwde instructies hebben twee argumenten; ik heb hun waarden in de opmerkingen aangeduid als X en Y.
Codeer na verwerking]
# Инициализация различных переменных
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_VALNu we een idee hebben van de instructies voor de virtuele machine, gaan we een kleine disassembler schrijven om de bytecode in het DB100-blok te ontleden:
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))
breakAls resultaat krijgen we de volgende virtuele machinecode:
Virtuele machinecode
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)Zoals u kunt zien, controleert dit programma eenvoudig elk teken uit DB101 op gelijkheid met een bepaalde waarde. De laatste regel voor het slagen voor alle controles is: n0w u 4r3 7h3 m4573r. Als deze lijn in blok DB101 wordt geplaatst, wordt de handmatige PLC-besturing geactiveerd en is het mogelijk de ballon te laten exploderen of leeg te laten lopen.
Dat is alles! Alexey toonde een hoog kennisniveau dat een industriële ninja waardig is :) We hebben gedenkwaardige prijzen naar de winnaar gestuurd. Hartelijk dank aan alle deelnemers!
Bron: www.habr.com