Lors du dernier PHDays 9, nous avons organisé un concours pour pirater une usine de pompage de gaz - concours . Il y avait trois stands sur le site avec des paramètres de sécurité différents (Pas de sécurité, Faible sécurité, Haute sécurité), imitant le même processus industriel : de l'air sous pression était pompé dans un ballon (puis relâché).
Malgré les différents paramètres de sécurité, la composition matérielle des stands était la même : Siemens Simatic PLC série S7-300 ; bouton de dégonflage d'urgence et dispositif de mesure de pression (connectés aux entrées numériques (DI) du PLC) ; vannes fonctionnant au gonflage et au dégonflage de l'air (connectées aux sorties numériques de l'automate (DO)) - voir la figure ci-dessous.
Le PLC, en fonction des relevés de pression et conformément à son programme, a pris la décision de dégonfler ou de gonfler le ballon (ouvert et fermé les vannes correspondantes). Cependant, tous les stands disposaient d'un mode de contrôle manuel, qui permettait de contrôler les états des vannes sans aucune restriction.
Les stands différaient par la complexité de l'activation de ce mode : dans le stand non protégé, c'était le plus simple à réaliser, et dans le stand de Haute Sécurité, c'était en conséquence plus difficile.
Cinq des six problèmes ont été résolus en deux jours ; Le premier participant a obtenu 233 points (il a passé une semaine à préparer le concours). Trois gagnants : I place - a1exdandy, II - Rubikoid, III - Ze.
Cependant, lors des PHDays, aucun des participants n'a pu surmonter les trois stands, nous avons donc décidé de lancer un concours en ligne et publié la tâche la plus difficile début juin. Les participants devaient terminer la tâche en un mois, trouver le drapeau et décrire la solution en détail et de manière intéressante.
Sous la coupe, nous publions une analyse de la meilleure solution à la tâche parmi celles envoyées au cours du mois, elle a été trouvée par Alexey Kovrizhnykh (a1exdandy) de la société Digital Security, qui a remporté la XNUMXère place du concours lors des PHDays. Nous présentons ci-dessous son texte avec nos commentaires.
Analyse initiale
Ainsi, la tâche contenait une archive avec les fichiers suivants :
- block_upload_traffic.pcapng
- DB100.bin
- conseils.txt
Le fichier astuces.txt contient les informations et astuces nécessaires pour résoudre la tâche. Voici son contenu :
- Petrovich m'a dit hier que vous pouvez charger des blocs de PlcSim dans Step7.
- L'automate Siemens Simatic série S7-300 a été utilisé sur le stand.
- PlcSim est un émulateur d'automate qui vous permet d'exécuter et de déboguer des programmes pour les automates Siemens S7.
Le fichier DB100.bin semble contenir le bloc de données de l'automate DB100 : 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 02 0501a0202 1602 00000090 0501 ............ 0206 : 0100 010 0102 3702a 0401 0206 7 000000 .........0. .... 0100a010 : 0102 2202b 0501 0202 4602 0501 000000 0 ......".....F... 0206b0100 : 010 0102 3302c 0401 0206 0100 3 000000 ........0. ...... 010c0102 : 0d 02 0501a0202 1602 0501 0206 000000 0 ................ 0100d010 : 0102 6e 02 0401d0206 0100 010 000000 0f ......m. ........ 0102e1102 : 0501 0202 2302 0501 0206 0100 000000 0 ........#...... 0110f0102 : 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 02 0501c0206 0100 XNUMX XNUMX ....L......
Comme son nom l'indique, le fichier block_upload_traffic.pcapng contient un vidage du trafic de téléchargement de blocs vers l'automate.
Il est à noter que cette baisse de trafic sur le site de compétition lors de la conférence a été un peu plus difficile à obtenir. Pour ce faire, il était nécessaire de comprendre le script du fichier de projet pour TeslaSCADA2. À partir de là, il était possible de comprendre où se trouvait le dump chiffré à l'aide de RC4 et quelle clé devait être utilisée pour le déchiffrer. Des dumps de blocs de données sur site ont pu être obtenus à l'aide du client de protocole S7. Pour cela, j'ai utilisé le client de démonstration du package Snap7.
Extraire des blocs de traitement du signal d'un vidage de trafic
En regardant le contenu du dump, vous comprendrez qu'il contient les blocs de traitement du signal OB1, FC1, FC2 et FC3 :
Ces blocs doivent être supprimés. Cela peut être fait, par exemple, avec le script suivant, après avoir préalablement converti le trafic du format pcapng vers 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 = ''Après avoir examiné les blocs résultants, vous remarquerez qu'ils commencent toujours par les octets 70 70 (pp). Vous devez maintenant apprendre à les analyser. L'indice d'affectation suggère que vous devez utiliser PlcSim pour cela.
Obtenir des instructions lisibles par l'homme à partir de blocs
Essayons d'abord de programmer S7-PlcSim en y chargeant plusieurs blocs avec des instructions répétitives (= Q 0.0) à l'aide du logiciel Simatic Manager et en enregistrant l'automate obtenu dans l'émulateur dans le fichier exemple.plc. En regardant le contenu du fichier, vous pouvez facilement déterminer le début des blocs téléchargés par la signature 70 70, que nous avons découverte plus tôt. Apparemment, avant les blocs, la taille du bloc est écrite sous la forme d'une valeur petit-boutiste de 4 octets.
Après avoir reçu des informations sur la structure des fichiers API, le plan d'action suivant est apparu pour la lecture des programmes PLC S7 :
- À l'aide de Simatic Manager, nous créons une structure de blocs dans S7-PlcSim similaire à celle que nous avons reçue du dump. Les tailles de blocs doivent correspondre (ceci est obtenu en remplissant les blocs avec le nombre d'instructions requis) et leurs identifiants (OB1, FC1, FC2, FC3).
- Enregistrez l'automate dans un fichier.
- Nous remplaçons le contenu des blocs du fichier résultant par les blocs du vidage du trafic. Le début des blocs est déterminé par la signature.
- Nous chargeons le fichier résultant dans S7-PlcSim et examinons le contenu des blocs dans Simatic Manager.
Les blocs peuvent être remplacés, par exemple, par le code suivant :
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 a emprunté un chemin peut-être plus difficile, mais toujours correct. Nous avons supposé que les participants utiliseraient le programme NetToPlcSim pour que PlcSim puisse communiquer sur le réseau, télécharger des blocs vers PlcSim via Snap7, puis télécharger ces blocs en tant que projet depuis PlcSim en utilisant l'environnement de développement.
En ouvrant le fichier résultant dans S7-PlcSim, vous pouvez lire les blocs écrasés à l'aide du Simatic Manager. Les principales fonctions de contrôle des appareils sont enregistrées dans le bloc FC1. Il convient de noter en particulier la variable #TEMP0 qui, lorsqu'elle est activée, semble définir le contrôle de l'API en mode manuel en fonction des valeurs de mémoire des bits M2.2 et M2.3. La valeur #TEMP0 est définie par la fonction FC3.
Pour résoudre le problème, vous devez analyser la fonction FC3 et comprendre ce qui doit être fait pour qu'elle renvoie une fonction logique.
Les blocs de traitement du signal CPL du stand Basse Sécurité du site de compétition étaient disposés de la même manière, mais pour définir la valeur de la variable #TEMP0, il suffisait d'écrire la ligne à ma manière de ninja dans le bloc DB1. Vérifier la valeur dans un bloc était simple et ne nécessitait pas de connaissances approfondies du langage de programmation par blocs. Evidemment, au niveau Haute Sécurité, réaliser un contrôle manuel sera beaucoup plus difficile et il est nécessaire de comprendre les subtilités du langage STL (l'un des moyens de programmer l'automate S7).
Bloc inverse FC3
Contenu du bloc FC3 en représentation 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_VALLe code est assez long et peut paraître compliqué à quelqu'un qui n'est pas familier avec STL. Cela ne sert à rien d'analyser chaque instruction dans le cadre de cet article, des instructions détaillées et des capacités du langage STL peuvent être trouvées dans le manuel correspondant : . Ici, je présenterai le même code après traitement - en renommant les étiquettes et les variables et en ajoutant des commentaires décrivant l'algorithme de fonctionnement et certaines constructions du langage STL. Permettez-moi de noter immédiatement que le bloc en question contient une machine virtuelle qui exécute un bytecode situé dans le bloc DB100, dont nous connaissons le contenu. Les instructions de la machine virtuelle se composent de 1 octet de code d'exploitation et d'octets d'arguments, un octet pour chaque argument. Toutes les instructions considérées ont deux arguments ; j'ai désigné leurs valeurs dans les commentaires comme X et Y.
Code après traitement]
# Инициализация различных переменных
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_VALAprès avoir eu une idée des instructions de la machine virtuelle, écrivons un petit désassembleur pour analyser le bytecode dans le bloc 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))
breakEn conséquence, nous obtenons le code de machine virtuelle suivant :
Code de la machine virtuelle
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)Comme vous pouvez le voir, ce programme vérifie simplement l'égalité de chaque caractère du DB101 avec une certaine valeur. La dernière ligne pour réussir tous les contrôles est : n0w u 4r3 7h3 m4573r. Si cette ligne est placée dans le bloc DB101, alors le contrôle manuel PLC est activé et il sera possible de faire exploser ou dégonfler le ballon.
C'est tout! Alexey a démontré un haut niveau de connaissances digne d'un ninja industriel :) Nous avons envoyé des prix mémorables au gagnant. Un grand merci à tous les participants !
Source: habr.com