All'ultimo PHDays 9 abbiamo indetto un concorso per hackerare un impianto di pompaggio del gas: concorso . Sul sito c'erano tre stand con diversi parametri di sicurezza (nessuna sicurezza, bassa sicurezza, alta sicurezza), che emulavano lo stesso processo industriale: aria sotto pressione veniva pompata in un pallone (e poi rilasciata).
Nonostante i diversi parametri di sicurezza, la composizione hardware degli stand era la stessa: PLC Siemens Simatic serie S7-300; pulsante di sgonfiaggio di emergenza e dispositivo di misurazione della pressione (collegato agli ingressi digitali (DI) del PLC); valvole funzionanti per il gonfiaggio e lo sgonfiaggio dell'aria (collegate alle uscite digitali del PLC (DO)) - vedere la figura seguente.
Il PLC, a seconda delle letture della pressione e in conformità con il suo programma, ha deciso di sgonfiare o gonfiare il pallone (aprendo e chiudendo le valvole corrispondenti). Tuttavia, tutti gli stand avevano una modalità di controllo manuale, che consentiva di controllare lo stato delle valvole senza alcuna restrizione.
Gli stand differivano nella complessità dell'attivazione di questa modalità: nello stand non protetto era più facile farlo, e nello stand di Alta Sicurezza era corrispondentemente più difficile.
Cinque dei sei problemi sono stati risolti in due giorni; Il primo classificato ha guadagnato 233 punti (ha trascorso una settimana a prepararsi per la competizione). Tre vincitori: I posto - a1exdandy, II - Rubikoid, III - Ze.
Tuttavia, durante i PHDays, nessuno dei partecipanti è riuscito a superare tutti e tre gli stand, quindi abbiamo deciso di organizzare un concorso online e all'inizio di giugno abbiamo pubblicato il compito più difficile. I partecipanti dovevano completare l'attività entro un mese, trovare la bandiera e descrivere la soluzione in dettaglio e in modo interessante.
Sotto il taglio pubblichiamo l'analisi della migliore soluzione al compito tra quelle inviate nel corso del mese, trovata da Alexey Kovrizhnykh (a1exdandy) della società Digital Security, che si è classificato al XNUMX° posto nella competizione durante i PHDays. Di seguito ne riportiamo il testo con i nostri commenti.
Analisi iniziale
Pertanto, l'attività conteneva un archivio con i seguenti file:
- block_upload_traffic.pcapng
- DB100.bin
- suggerimenti.txt
Il filehints.txt contiene le informazioni e i suggerimenti necessari per risolvere l'attività. Ecco i suoi contenuti:
- Petrovich ieri mi ha detto che puoi caricare blocchi da PlcSim in Step7.
- Nello stand è stato utilizzato il PLC Siemens Simatic serie S7-300.
- PlcSim è un emulatore PLC che consente di eseguire ed eseguire il debug di programmi per PLC Siemens S7.
Il file DB100.bin sembra contenere il blocco 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 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......
Come suggerisce il nome, il file block_upload_traffic.pcapng contiene un dump del traffico di caricamento dei blocchi sul PLC.
Vale la pena notare che questo dump del traffico sul sito della competizione durante la conferenza è stato un po’ più difficile da ottenere. Per fare ciò è stato necessario comprendere lo script dal file di progetto per TeslaSCADA2. Da esso è stato possibile capire dove si trovava il dump criptato tramite RC4 e quale chiave occorreva utilizzare per decriptarlo. I dump dei blocchi dati sul posto possono essere ottenuti utilizzando il client del protocollo S7. Per questo ho utilizzato il client demo del pacchetto Snap7.
Estrazione dei blocchi di elaborazione del segnale da un dump del traffico
Osservando il contenuto del dump si capisce che contiene i blocchi di elaborazione dei segnali OB1, FC1, FC2 e FC3:
Questi blocchi devono essere rimossi. Ciò può essere fatto, ad esempio, con il seguente script, avendo precedentemente convertito il traffico dal formato pcapng a 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 = ''Dopo aver esaminato i blocchi risultanti, noterai che iniziano sempre con i byte 70 70 (pp). Ora devi imparare come analizzarli. Il suggerimento di assegnazione suggerisce che è necessario utilizzare PlcSim per questo.
Ottenere istruzioni leggibili dall'uomo dai blocchi
Per prima cosa proviamo a programmare S7-PlcSim caricando al suo interno diversi blocchi con istruzioni ripetitive (= Q 0.0) utilizzando il software Simatic Manager e salvando il PLC ottenuto nell'emulatore nel file example.plc. Osservando il contenuto del file, puoi facilmente determinare l'inizio dei blocchi scaricati dalla firma 70 70, che abbiamo scoperto in precedenza. Prima dei blocchi, a quanto pare, la dimensione del blocco è scritta come valore little-endian di 4 byte.
Dopo aver ricevuto informazioni sulla struttura dei file PLC, è apparso il seguente piano d'azione per la lettura dei programmi PLC S7:
- Utilizzando Simatic Manager, creiamo una struttura a blocchi in S7-PlcSim simile a quella ricevuta dal dump. Le dimensioni dei blocchi devono corrispondere (questo si ottiene riempiendo i blocchi con il numero richiesto di istruzioni) e i loro identificatori (OB1, FC1, FC2, FC3).
- Salvare il PLC in un file.
- Sostituiamo il contenuto dei blocchi nel file risultante con i blocchi del dump del traffico. L'inizio dei blocchi è determinato dalla firma.
- Carichiamo il file risultante in S7-PlcSim e osserviamo il contenuto dei blocchi in Simatic Manager.
I blocchi possono essere sostituiti, ad esempio, con il seguente codice:
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 ha preso una strada forse più difficile, ma comunque corretta. Abbiamo ipotizzato che i partecipanti avrebbero utilizzato il programma NetToPlcSim in modo che PlcSim potesse comunicare sulla rete, caricare blocchi su PlcSim tramite Snap7 e quindi scaricare questi blocchi come progetto da PlcSim utilizzando l'ambiente di sviluppo.
Aprendo il file risultante in S7-PlcSim è possibile leggere i blocchi sovrascritti utilizzando il Simatic Manager. Le principali funzioni di controllo del dispositivo sono registrate nel blocco FC1. Di particolare nota è la variabile #TEMP0, che quando accesa sembra impostare il controllo PLC in modalità manuale in base ai valori di memoria dei bit M2.2 e M2.3. Il valore #TEMP0 è impostato dalla funzione FC3.
Per risolvere il problema, è necessario analizzare la funzione FC3 e capire cosa è necessario fare affinché ne restituisca una logica.
I blocchi di elaborazione del segnale PLC presso lo stand Low Security presso il luogo della gara erano disposti in modo simile, ma per impostare il valore della variabile #TEMP0 era sufficiente scrivere la riga a modo mio ninja nel blocco DB1. Controllare il valore in un blocco era semplice e non richiedeva una conoscenza approfondita del linguaggio di programmazione dei blocchi. Ovviamente, al livello di Alta Sicurezza, ottenere il controllo manuale sarà molto più difficile ed è necessario comprendere le complessità del linguaggio STL (uno dei modi per programmare il PLC S7).
Blocco inverso FC3
Contenuto del blocco FC3 nella rappresentazione AWL:
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_VALIl codice è piuttosto lungo e può sembrare complicato a chi non ha familiarità con STL. Non ha senso analizzare ciascuna istruzione nell'ambito di questo articolo; istruzioni dettagliate e funzionalità del linguaggio STL possono essere trovate nel manuale corrispondente: . Qui presenterò lo stesso codice dopo l'elaborazione, rinominando le etichette e le variabili e aggiungendo commenti che descrivono l'algoritmo operativo e alcuni costrutti del linguaggio STL. Faccio subito notare che il blocco in questione contiene una macchina virtuale che esegue del bytecode situato nel blocco DB100, di cui conosciamo il contenuto. Le istruzioni della macchina virtuale sono costituite da 1 byte di codice operativo e byte di argomenti, un byte per ogni argomento. Tutte le istruzioni considerate hanno due argomenti; ho indicato i loro valori nei commenti come X e Y.
Codice dopo l'elaborazione]
# Инициализация различных переменных
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_VALAvendo un'idea delle istruzioni della macchina virtuale, scriviamo un piccolo disassemblatore per analizzare il bytecode nel blocco 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))
breakDi conseguenza, otteniamo il seguente codice 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)Come puoi vedere, questo programma controlla semplicemente l'uguaglianza di ciascun carattere di DB101 rispetto a un determinato valore. L'ultima riga per superare tutti i controlli è: n0w u 4r3 7h3 m4573r. Se questa linea viene posta nel blocco DB101, allora viene attivato il controllo manuale del PLC e sarà possibile far esplodere o sgonfiare il palloncino.
È tutto! Alexey ha dimostrato un alto livello di conoscenza degno di un ninja industriale :) Abbiamo inviato premi memorabili al vincitore. Molte grazie a tutti i partecipanti!
Fonte: habr.com