Durante il recente PHDays 9 abbiamo organizzato una competizione di hacking di un impianto di pompaggio del gas — concours . Sono stati allestiti tre stand con vari livelli di sicurezza (No Security, Low Security, High Security), emulando lo stesso processo industriale: un pallone viene riempito (e poi sgonfiato) con aria compressa.
Nonostante i diversi livelli di sicurezza, la composizione hardware degli stand era la stessa: PLC Siemens Simatic della serie S7-300; pulsante di sgonfiaggio d'emergenza e strumento di misurazione della pressione (collegati agli ingressi digitali del PLC (DI)); valvole, che funzionano per l'immissione e lo sgonfiamento dell'aria (collegate alle uscite digitali del PLC (DO)) — vedi figura sotto.
Il PLC, in base alle letture della pressione e secondo il suo programma, decideva se sgonfiare o gonfiare il palloncino (aprendo e chiudendo le valvole corrispondenti). Tuttavia, in tutti gli stand era prevista una modalità di controllo manuale, che consentiva di gestire lo stato delle valvole senza alcuna restrizione.
Gli stand differivano per la complessità dell'attivazione di questa modalità: sullo stand non protetto era più semplice farlo, mentre sullo stand High Security, di conseguenza, era più difficile.
In due giorni sono state risolte cinque delle sei sfide; il partecipante che si è piazzato al primo posto ha guadagnato 233 punti (ha impiegato una settimana per prepararsi al concorso). I tre migliori: 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 la sfida più difficile. I partecipanti avevano un mese per completare il compito, trovare la bandiera e descrivere in dettaglio e in modo interessante la soluzione.
Di seguito pubblichiamo un'analisi della migliore soluzione ricevuta durante il mese, trovata da Alexey Kovrizhnykh (a1exdandy) della società Digital Security, che ha occupato il primo posto nel concorso durante i PHDays. Qui sotto riportiamo il suo testo con i nostri commenti.
Analisi iniziale
Quindi, nel compito c'era un archivio con i file:
- block_upload_traffic.pcapng
- DB100.bin
- hints.txt
Il file hints.txt contiene le informazioni e i suggerimenti necessari per risolvere il compito. Ecco il suo contenuto:
- Pietro mi ha raccontato ieri che da PlcSim è possibile caricare i blocchi in Step7.
- Nel banco di prova è stato utilizzato un PLC Siemens Simatic della serie S7-300.
- PlcSim è un emulatore PLC che consente di eseguire e debugare programmi per PLC Siemens S7.
Il file DB100.bin, a quanto pare, contiene un blocco 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 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.......
A giudicare dal nome, il file block_upload_traffic.pcapng contiene un dump del traffico di caricamento dei blocchi sul PLC.
Vale la pena notare che ottenere questo dump di traffico nel luogo della competizione durante la conferenza è stato un po' più complicato. È stato necessario capire lo script nel file del progetto per TeslaSCADA2. Da esso si poteva comprendere dove si trovava il dump cifrato con RC4 e quale chiave utilizzare per la sua decrittazione. I dump dei blocchi di dati sul posto potevano essere ottenuti utilizzando il client del protocollo S7. Io ho usato il democlient incluso nel pacchetto Snap7.
Estrazione dei blocchi di elaborazione del segnale dal dump di traffico
Esaminando il contenuto del dump, si può comprendere che in esso vengono trasmessi i blocchi di elaborazione del segnale OB1, FC1, FC2 e FC3:
È necessario estrarre questi blocchi. Questo può essere fatto, ad esempio, con il seguente script, convertendo preliminarmente il traffico da 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 = ''Esaminando i blocchi ottenuti, si può notare che iniziano sempre con i byte 70 70 (pp). Ora bisogna imparare ad analizzarli. L'indizio per il compito suggerisce che è necessario utilizzare PlcSim.
Ottenere istruzioni leggibili da blocchi
Innanzitutto, proviamo a programmare S7-PlcSim caricando alcuni blocchi con istruzioni ripetute (= Q 0.0) utilizzando il software Simatic Manager e salveremo il risultato ottenuto nell'emulatore PLC in un file example.plc. Guardando il contenuto del file, è facile identificare l'inizio dei blocchi caricati tramite la firma 70 70, che abbiamo scoperto in precedenza. Prima dei blocchi, apparentemente è registrata la dimensione del blocco come un valore little-endian a 4 byte.
Dopo aver ottenuto informazioni sulla struttura dei file plc, è emerso il seguente piano d'azione per la lettura dei programmi PLC S7:
- Utilizzando Simatic Manager, creiamo in S7-PlcSim una struttura di blocchi simile a quella che abbiamo ottenuto dall' dump. Devono corrispondere le dimensioni dei blocchi (ottenuta tramite il riempimento dei blocchi con il numero necessario di istruzioni) e i loro identificatori (OB1, FC1, FC2, FC3).
- Salviamo il PLC in un file.
- Sostituiamo il contenuto dei blocchi nel file ottenuto con i blocchi dall' dump del traffico. L'inizio dei blocchi viene determinato dalla firma.
- Carichiamo il file ottenuto in S7-PlcSim e guardiamo il contenuto dei blocchi in Simatic Manager.
La sostituzione dei blocchi può essere effettuata, 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)Aleksej ha scelto un percorso forse più complesso, ma comunque corretto. Supponevamo che i partecipanti utilizzassero il programma NetToPlcSim per comunicare tramite rete con PlcSim, caricassero i blocchi in PlcSim tramite Snap7 e poi scaricassero questi blocchi come progetto da PlcSim tramite l'ambiente di sviluppo.
Aprendo il file ottenuto in S7-PlcSim, è possibile leggere i blocchi sovrascritti tramite Simatic Manager. Le funzioni principali di controllo dei dispositivi sono registrate nel blocco FC1. Attira particolare attenzione la variabile #TEMP0, che, a quanto pare, abilita il controllo del PLC in modalità manuale in base ai valori della memoria bit M2.2 e M2.3. Il valore di #TEMP0 viene impostato dalla funzione FC3.
Per risolvere il compito è necessario analizzare la funzione FC3 e capire cosa deve essere fatto affinché restituisca uno uno logico.
I blocchi di elaborazione dei segnali PLC nello stand Low Security sul sito del concorso erano disposti in modo simile, ma per impostare il valore della variabile #TEMP0 era sufficiente scrivere la stringa my ninja way nel blocco DB1. Il controllo del valore nel blocco era impostato in modo chiaro e non richiedeva approfondite conoscenze del linguaggio di programmazione dei blocchi. È evidente che a livello High Security ottenere un controllo manuale sarà significativamente più complesso e sarà necessario approfondire le sottigliezze del linguaggio STL (uno dei modi di programmare i PLC S7).
Inversione del blocco FC3
Contenuto del blocco FC3 nella rappresentazione 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_VALIl codice è piuttosto voluminoso e può sembrare complicato a chi non è familiare con il STL. Non ha senso analizzare ogni istruzione all'interno di questo articolo; è possibile approfondire le istruzioni e le possibilità del linguaggio STL nel manuale corrispondente: . Qui riporterò lo stesso codice dopo l'elaborazione: rinominando etichette e variabili e aggiungendo commenti che descrivono l'algoritmo e alcune costruzioni del linguaggio STL. Preciso fin da subito che nel blocco considerato è stata implementata una macchina virtuale che esegue un certo bytecode, contenuto nel blocco DB100, il cui contenuto ci è noto. Le istruzioni della macchina virtuale consistono in 1 byte di codice operativo e byte di argomenti, uno per ogni argomento. Tutte le istruzioni considerate hanno due argomenti; i loro valori nei commenti sono indicati 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 acquisito una comprensione delle istruzioni della macchina virtuale, scriviamo un semplice 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, otterremo il seguente codice della macchina virtuale:
Codice della macchina virtuale
R1 = DB101[0]
R2 = 6e (n)
R0 = 0; R1 = (R1 == R2)
CONTROLLO (R1 == R0)
R1 = DB101[1]
R2 = 10 (?)
R0 = 0; R1 = R1 - R2
R2 = 20 (?)
R0 = 0; R1 = R1 - R2
CONTROLLO (R1 == R0)
R1 = DB101[2]
R2 = 77 (w)
R0 = 0; R1 = (R1 == R2)
CONTROLLO (R1 == R0)
R1 = DB101[3]
R2 = 0a (?)
R0 = 0; R1 = R1 - R2
R2 = 16 (?)
R0 = 0; R1 = R1 - R2
CONTROLLO (R1 == R0)
R1 = DB101[4]
R2 = 75 (u)
R0 = 0; R1 = (R1 == R2)
CONTROLLO (R1 == R0)
R1 = DB101[5]
R2 = 0a (?)
R0 = 0; R1 = R1 - R2
R2 = 16 (?)
R0 = 0; R1 = R1 - R2
CONTROLLO (R1 == R0)
R1 = DB101[6]
R2 = 34 (4)
R0 = 0; R1 = (R1 == R2)
CONTROLLO (R1 == R0)
R1 = DB101[7]
R2 = 26 (?)
R0 = 0; R1 = R1 - R2
R2 = 4c (L)
R0 = 0; R1 = R1 - R2
CONTROLLO (R1 == R0)
R1 = DB101[8]
R2 = 33 (3)
R0 = 0; R1 = (R1 == R2)
CONTROLLO (R1 == R0)
R1 = DB101[9]
R2 = 0a (?)
R0 = 0; R1 = R1 - R2
R2 = 16 (?)
R0 = 0; R1 = R1 - R2
CONTROLLO (R1 == R0)
R1 = DB101[10]
R2 = 37 (7)
R0 = 0; R1 = (R1 == R2)
CONTROLLO (R1 == R0)
R1 = DB101[11]
R2 = 22 (?)
R0 = 0; R1 = R1 - R2
R2 = 46 (F)
R0 = 0; R1 = R1 - R2
CONTROLLO (R1 == R0)
R1 = DB101[12]
R2 = 33 (3)
R0 = 0; R1 = (R1 == R2)
CONTROLLO (R1 == R0)
R1 = DB101[13]
R2 = 0a (?)
R0 = 0; R1 = R1 - R2
R2 = 16 (?)
R0 = 0; R1 = R1 - R2
CONTROLLO (R1 == R0)
R1 = DB101[14]
R2 = 6d (m)
R0 = 0; R1 = (R1 == R2)
CONTROLLO (R1 == R0)
R1 = DB101[15]
R2 = 11 (?)
R0 = 0; R1 = R1 - R2
R2 = 23 (?)
R0 = 0; R1 = R1 - R2
CONTROLLO (R1 == R0)
R1 = DB101[16]
R2 = 35 (5)
R0 = 0; R1 = (R1 == R2)
CONTROLLO (R1 == R0)
R1 = DB101[17]
R2 = 12 (?)
R0 = 0; R1 = R1 - R2
R2 = 25 (?)
R0 = 0; R1 = R1 - R2
CONTROLLO (R1 == R0)
R1 = DB101[18]
R2 = 33 (3)
R0 = 0; R1 = (R1 == R2)
CONTROLLO (R1 == R0)
R1 = DB101[19]
R2 = 26 (?)
R0 = 0; R1 = R1 - R2
R2 = 4c (L)
R0 = 0; R1 = R1 - R2
CONTROLLO (R1 == R0)Come si può notare, questo programma verifica semplicemente ogni carattere di DB101 per verificarne l'uguaglianza con un determinato valore. La stringa finale per superare tutti i controlli è: n0w u 4r3 7h3 m4573r. Se si posiziona questa stringa nel blocco DB101, si attiverà il controllo manuale del PLC e sarà possibile far esplodere o sgonfiare un palloncino.
Ecco fatto! Aleksej ha dimostrato un alto livello di conoscenze, degno di un ninja industriale 🙂 Abbiamo inviato premi commemorativi al vincitore. Un grande grazie a tutti i partecipanti!
Fonte: habr.com
