À l'ultimi PHDays 9 avemu tenutu un cuncorsu per pirate una pianta di pompa di gasu - cumpetizione . Ci era trè stand in u situ cù diversi paràmetri di sicurità (No Security, Low Security, High Security), emulendu u stessu prucessu industriale: l'aria sottu pressione hè stata pompata in un pallone (è dopu liberatu).
Malgradu i diversi paràmetri di sicurità, a cumpusizioni hardware di i stands era a stessa: a serie Siemens Simatic PLC S7-300; Pulsante di sgonfiamentu d'urgenza è dispusitivu di misurazione di pressione (cunnessu à l'input digitale PLC (DI)); valvole chì operanu per l'inflazione è a deflazione di l'aria (cunnessu à l'output digitale di u PLC (DO)) - vede a figura sottu.
U PLC, secondu a lettura di pressione è in cunfurmità cù u so prugramma, hà pigliatu a decisione di deflate o inflate a bola (apertu è chjusu e valvule currispundenti). In ogni casu, tutti i stands avianu un modu di cuntrollu manuale, chì hà permessu di cuntrullà i stati di e valvule senza restrizioni.
I stands differenu in a cumplessità di attivà stu modu: in u stand senza prutezzione era più faciule per fà questu, è in u stand High Security era più difficiule.
Cinque di i sei prublemi sò stati risolti in dui ghjorni; U primu participante hà guadagnatu punti 233 (hà passatu una settimana per preparà a cumpetizione). Trè vincitori: I postu - a1exdandy, II - Rubikoid, III - Ze.
In ogni casu, durante i PHDays, nimu di i participanti hà sappiutu superà tutti i trè stands, cusì avemu decisu di fà un cuncorsu in linea è publicatu u compitu più difficiule à principiu di ghjugnu. I participanti anu da compie u compitu in un mesi, truvà a bandiera, è discrìviri a suluzione in dettu è in una manera interessante.
Sottu u tagliu publichemu un analisi di a megliu suluzione à u compitu da quelli mandati annantu à u mese, hè stata trovata da Alexey Kovrizhnykh (a1exdandy) da a cumpagnia di Sicurezza Digitale, chì hà pigliatu u XNUMXu postu in a cumpetizione durante PHDays. Sottu avemu prisentatu u so testu cù i nostri cumenti.
Analisi iniziale
Dunque, u compitu cuntene un archiviu cù i seguenti schedari:
- block_upload_traffic.pcapng
- DB100.bin
- suggerimenti.txt
U schedariu hints.txt cuntene l'infurmazioni necessarii è cunsiglii per risolve u compitu. Eccu u so cuntenutu:
- Petrovich m'hà dettu ieri chì pudete carricà blocchi da PlcSim in Step7.
- U PLC di a serie Siemens Simatic S7-300 hè stata utilizata à u stand.
- PlcSim hè un emulatore PLC chì permette di eseguisce è debug prugrammi per i PLC Siemens S7.
U schedariu DB100.bin pare cuntene u bloccu di dati 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 0206a0100 ..w............. 0103: 0102 0 02 00000030 0501 ................ 0202: 1602 0501 0206 0100 0104 0102 00000040a7502 0401 u............... 0206: 0100 0105 0102 0 02 0501 00000050 0202............1602. 0501: 0206 0100 0106 0102 3402 4 ....... ... 00000060 0401 0206 0100 0107 0102 l .... .. 2602 : 0501 0202 00000070 4 02a0501 0206 0100 0108 ................ 0102: 3302 0401 3 00000080a 0206 0100 0109 0102 .........0 02a0501: 0202 1602b 00000090 0501 0206 0100 010 0102 ......".....F... 3702b0401: 0206 7 000000c 0 0100 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......
Cum'è u nome suggerisce, u schedariu block_upload_traffic.pcapng cuntene un dump of block upload traffic à u PLC.
Hè vale a nutà chì questu dump di trafficu in u situ di cuncorsu durante a cunferenza era un pocu più difficiuli di ottene. Per fà questu, era necessariu capisce u script da u schedariu di prughjettu per TeslaSCADA2. Da ellu era pussibule di capiscenu induve u dump encrypted using RC4 era situatu è chì chjave deve esse usata per decifrallu. Dumps di blocchi di dati in u situ puderanu esse ottenuti cù u cliente di protocolu S7. Per questu aghju utilizatu u cliente demo da u pacchettu Snap7.
Estrazione di blocchi di trasfurmazioni di signali da un dump di trafficu
Fighjendu u cuntenutu di u dump, pudete capisce chì cuntene blocchi di trasfurmazioni di signali OB1, FC1, FC2 è FC3:
Questi blocchi deve esse eliminati. Questu pò esse fattu, per esempiu, cù u seguente script, avè cunvertitu prima u trafficu da u formatu 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 = ''Dopu avè esaminatu i blocchi resultanti, vi vede chì sempre cumincianu cù bytes 70 70 (pp). Avà vi tocca à amparà à analizà elli. U suggerimentu di assignazione suggerisce chì avete bisognu di utilizà PlcSim per questu.
Ottene istruzioni leggibili da i blocchi
Prima, pruvemu di prugrammà S7-PlcSim carghjendu parechji blocchi cù struzzioni ripetuti (= Q 0.0) in questu cù u software Simatic Manager, è salvendu u PLC ottenutu in l'emulatore in u schedariu example.plc. Fighjendu u cuntenutu di u schedariu, pudete facilmente determinà u principiu di i blocchi scaricati da a firma 70 70, chì avemu scupertu prima. Prima di i blocchi, apparentemente, a dimensione di u bloccu hè scrittu cum'è un valore little-endian di 4 byte.
Dopu avè ricivutu infurmazioni nantu à a struttura di i fugliali plc, u seguente pianu d'azzione apparsu per leghje i prugrammi PLC S7:
- Utilizendu Simatic Manager, creamu una struttura di bloccu in S7-PlcSim simile à quellu chì avemu ricevutu da u dump. E dimensioni di i blocchi anu da cuncordà (questu hè ottinutu cumpiendu i blocchi cù u numeru necessariu d'istruzzioni) è i so identificatori (OB1, FC1, FC2, FC3).
- Salvà u PLC in un schedariu.
- Sustituemu u cuntenutu di i blocchi in u schedariu resultanti cù i blocchi da u dump di trafficu. U principiu di i blocchi hè determinatu da a firma.
- Carchemu u schedariu resultanti in S7-PlcSim è fighjemu u cuntenutu di i blocchi in Simatic Manager.
I blocchi ponu esse rimpiazzati, per esempiu, cù u codice seguente:
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 hà pigliatu una strada forse più difficiule, ma ancu curretta. Assumimu chì i participanti anu utilizatu u prugramma NetToPlcSim in modu chì PlcSim puderia cumunicà nantu à a reta, caricate blocchi à PlcSim via Snap7, è dopu scaricate questi blocchi cum'è un prughjettu da PlcSim utilizendu l'ambiente di sviluppu.
Aprendu u schedariu risultatu in S7-PlcSim, pudete leghje i blocchi sovrascritti cù u Simatic Manager. E funzioni principali di cuntrollu di u dispositivu sò registrate in u blocu FC1. Da nota particulari hè a variabile #TEMP0, chì quandu hè attivata pare chì mette u cuntrollu PLC in modu manuale basatu annantu à i valori di memoria di bit M2.2 è M2.3. U valore #TEMP0 hè stabilitu da a funzione FC3.
Per risolve u prublema, avete bisognu di analizà a funzione FC3 è capisce ciò chì deve esse fattu per chì torna una logica.
I blocchi di trasfurmazioni di signali PLC in u stand Low Security in u situ di a cuncurrenza sò stati disposti in una manera simili, ma per stabilisce u valore di a variabile #TEMP0, era abbastanza per scrive a linea u mo modu ninja in u bloccu DB1. A verificazione di u valore in un bloccu era simplice è ùn hà micca bisognu di cunniscenza profonda di a lingua di prugrammazione di bloccu. Ovviamente, à u livellu di l'Alta Sicurezza, ottene u cuntrollu manuali serà assai più difficiuli è hè necessariu di capiscenu l'intricacies di a lingua STL (una di e manere di prugrammà u PLC S7).
Bloccu inversu FC3
Cuntenutu di u bloccu FC3 in a rapprisintazioni 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_VALU codice hè abbastanza longu è pò parè complicatu à qualchissia chì ùn cunnosci micca STL. Ùn ci hè nunda in l'analisi di ogni struzzione in u quadru di stu articulu struzzioni detallati è capacità di a lingua STL ponu esse truvati in u manuale currispundente: . Quì vi prisintà u listessu codice dopu a trasfurmazioni - rinominà e etichette è variàbili è aghjunghje cumenti chì descrizanu l'algoritmu di l'operazione è certi custruzzioni di lingua STL. Lasciami immediatamente nutà chì u bloccu in quistione cuntene una macchina virtuale chì eseguisce qualchì bytecode situatu in u bloccu DB100, u cuntenutu di quale sapemu. Istruzzioni di a macchina virtuale sò custituiti da 1 byte di codice operativu è byte di argumenti, un byte per ogni argumentu. Tutte l'istruzzioni cunsiderate anu dui argumenti chì aghju designatu i so valori in i cumenti cum'è X è Y.
Codice dopu a trasfurmazioni]
# Инициализация различных переменных
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_VALDopu avè avutu una idea di l'istruzzioni di a macchina virtuale, scrivemu un picculu disassembler per analizà u bytecode in u bloccu 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))
breakIn u risultatu, avemu u seguente codice di macchina virtuale:
codice macchina 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)Comu pudete vede, stu prugramma cuntrolla solu ogni caratteru da DB101 per l'ugualità à un certu valore. A linea finale per passà tutti i cuntrolli hè: n0w u 4r3 7h3 m4573r. Se sta linea hè piazzata in u bloccu DB101, allora u cuntrollu PLC manuale hè attivatu è serà pussibule esplusione o deflate u globu.
Eccu tuttu! Alexey hà dimustratu un altu livellu di cunniscenza degna di un ninja industriale :) Avemu mandatu premi memorabili à u vincitore. Grazie mille à tutti i participanti !
Source: www.habr.com
