Nos últimos PHDays 9 fixemos un concurso para piratear unha planta de bombeo de gas - concurso . No lugar había tres postos con diferentes parámetros de seguridade (Sen seguridade, Baixa seguridade, Alta seguridade), emulando o mesmo proceso industrial: bombeábase aire a presión nun globo (e despois soltábase).
A pesar dos diferentes parámetros de seguridade, a composición do hardware dos soportes foi a mesma: serie Siemens Simatic PLC S7-300; botón de desinflado de emerxencia e dispositivo de medición de presión (conectado a entradas dixitais (DI) do PLC); válvulas que funcionan para inflar e desinflar o aire (conectadas ás saídas dixitais do PLC (DO)) - consulte a seguinte figura.
O PLC, en función das lecturas de presión e de acordo co seu programa, tomou a decisión de desinflar ou inflar a bola (abriu e pechou as válvulas correspondentes). Non obstante, todos os soportes tiñan un modo de control manual, o que permitía controlar o estado das válvulas sen ningunha restrición.
Os stands diferían na complexidade de habilitar este modo: no stand desprotexido era máis fácil facelo e no stand de Alta Seguridade resultou máis difícil.
Cinco dos seis problemas resolvéronse en dous días; O primeiro clasificado obtivo 233 puntos (pasou unha semana preparándose para a competición). Tres gañadores: I lugar - a1exdandy, II - Rubikoid, III - Ze.
Non obstante, durante os PHDays ningún dos participantes foi quen de superar os tres stands, polo que decidimos facer un concurso en liña e publicamos a tarefa máis difícil a principios de xuño. Os participantes tiveron que completar a tarefa nun mes, buscar a bandeira e describir a solución con detalle e dun xeito interesante.
Debaixo do corte publicamos unha análise da mellor solución para a tarefa dos enviados ao longo do mes, atopouno Alexey Kovrizhnykh (a1exdandy) da empresa de Seguridade Dixital, que obtivo o XNUMXº lugar na competición durante PHDays. A continuación presentamos o seu texto cos nosos comentarios.
Análise inicial
Entón, a tarefa contiña un arquivo cos seguintes ficheiros:
- block_upload_traffic.pcapng
- DB100.bin
- suxestións.txt
O ficheiro hints.txt contén a información e as suxestións necesarias para resolver a tarefa. Velaquí o seu contido:
- Petrovich díxome onte que podes cargar bloques de PlcSim no Step7.
- No stand utilizouse o PLC da serie Siemens Simatic S7-300.
- PlcSim é un emulador de PLC que che permite executar e depurar programas para PLC Siemens S7.
Parece que o ficheiro DB100.bin contén o bloque de datos do PLC DB100: 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: 0100C0107 0102 2602 0501 0202 00000070 4 02 L ......... 0501. .. 0206 : 0100 0108 0102 3302 0401a3 00000080 0206 0100 ................ 0109: 0102 0 02 0501a 0202 1602 00000090 0501 .........0206 0100a010: 0102 3702b 0401 0206 7 000000 0 0100 ......".....F... 010b0102: 2202 0501 0202c 4602 0501 000000 ..0 0206 ..0100 .. 010c0102: 3302d 0401 0206a0100 3 000000 0 010 0102 ................ 0d02: 0501 0202e 1602 0501d0206 000000 0 ..0100 010..0102 .... 6e02: 0401 0206 0100 010 000000 0 0102 1102 ........#...... 0501f0202: 2302 0501 0206 0100 000000 0 0110 . ..... 0102: 3502 0401 0206 0100 0111 0102 5 00000100 ......%......... 1202: 0501 0202 2502 0501 0206 0100 ..0112 ..... .....&. 00000110: 0102 3302 0401c0206 0100 0113 0102 ....L......
Como o nome indica, o ficheiro block_upload_traffic.pcapng contén un vertedoiro de tráfico de carga de bloques ao PLC.
Cabe destacar que este vertedoiro de tráfico no lugar da competición durante a conferencia foi un pouco máis difícil de conseguir. Para iso, foi necesario comprender o script do ficheiro do proxecto para TeslaSCADA2. A partir del púidose comprender onde se atopaba o vertedoiro cifrado mediante RC4 e que chave había que empregar para descifralo. Os volcados de bloques de datos no sitio pódense obter mediante o cliente do protocolo S7. Para iso usei o cliente de demostración do paquete Snap7.
Extraer bloques de procesamento de sinal dun vertedoiro de tráfico
Mirando o contido do vertedoiro, pode entender que contén os bloques de procesamento de sinal OB1, FC1, FC2 e FC3:
Estes bloques deben ser eliminados. Isto pódese facer, por exemplo, co seguinte script, despois de converter previamente o tráfico do 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 = ''Despois de examinar os bloques resultantes, notarás que sempre comezan cos bytes 70 70 (pp). Agora tes que aprender a analizalos. A suxestión da asignación suxire que cómpre usar PlcSim para iso.
Obtención de instrucións lexibles por humanos de bloques
En primeiro lugar, imos tentar programar S7-PlcSim cargando nel mediante o software Simatic Manager varios bloques con instrucións repetidas (= Q 0.0) e gardando o PLC obtido no emulador no ficheiro example.plc. Ao mirar o contido do ficheiro, pode determinar facilmente o inicio dos bloques descargados pola sinatura 70 70, que descubrimos anteriormente. Antes dos bloques, ao parecer, o tamaño do bloque escríbese como un valor little-endian de 4 bytes.
Despois de recibir información sobre a estrutura dos ficheiros plc, apareceu o seguinte plan de acción para ler os programas PLC S7:
- Usando Simatic Manager, creamos unha estrutura de bloques en S7-PlcSim similar á que recibimos do vertedoiro. Os tamaños dos bloques deben coincidir (isto conséguese enchendo os bloques co número necesario de instrucións) e os seus identificadores (OB1, FC1, FC2, FC3).
- Garda o PLC nun ficheiro.
- Substituímos o contido dos bloques do ficheiro resultante polos bloques do vertedoiro de tráfico. O inicio dos bloques está determinado pola sinatura.
- Cargamos o ficheiro resultante en S7-PlcSim e miramos o contido dos bloques en Simatic Manager.
Os bloques pódense substituír, por exemplo, co seguinte código:
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 tomou un camiño quizais máis difícil, pero aínda así correcto. Supuxemos que os participantes usarían o programa NetToPlcSim para que PlcSim puidese comunicarse a través da rede, cargar bloques a PlcSim a través de Snap7 e, a continuación, descargar estes bloques como proxecto desde PlcSim usando o entorno de desenvolvemento.
Ao abrir o ficheiro resultante en S7-PlcSim, pode ler os bloques sobrescritos usando o Simatic Manager. As principais funcións de control do dispositivo están rexistradas no bloque FC1. Destaca especialmente a variable #TEMP0, que cando está activada parece configurar o control do PLC en modo manual en función dos valores de memoria de bits M2.2 e M2.3. O valor #TEMP0 establécese pola función FC3.
Para resolver o problema, cómpre analizar a función FC3 e comprender o que hai que facer para que devolva unha lóxica.
Os bloques de procesamento de sinal do PLC no stand de Low Security no lugar da competición dispuxéronse dun xeito similar, pero para establecer o valor da variable #TEMP0, bastou con escribir a liña do meu camiño ninja no bloque DB1. Comprobar o valor nun bloque foi sinxelo e non requiriu un coñecemento profundo da linguaxe de programación de bloques. Obviamente, a nivel de Alta Seguridade, conseguir o control manual será moito máis difícil e é necesario comprender as complejidades da linguaxe STL (unha das formas de programar o PLC S7).
Bloque inverso FC3
Contido do bloque FC3 en representación 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_VALO código é bastante longo e pode parecer complicado para alguén que non estea familiarizado co STL. Non ten sentido analizar cada instrución no marco deste artigo; as instrucións e as capacidades detalladas da linguaxe STL pódense atopar no manual correspondente: . Aquí presentarei o mesmo código despois do procesamento: renomeando as etiquetas e variables e engadindo comentarios que describan o algoritmo de operación e algunhas construcións da linguaxe STL. Permítanme observar inmediatamente que o bloque en cuestión contén unha máquina virtual que executa algún bytecode situado no bloque DB100, cuxo contido coñecemos. As instrucións da máquina virtual consisten en 1 byte de código operativo e bytes de argumentos, un byte por cada argumento. Todas as instrucións consideradas teñen dous argumentos; designei os seus valores nos comentarios como X e Y.
Código despois do procesamento]
# Инициализация различных переменных
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_VALTendo unha idea das instrucións da máquina virtual, escribamos un pequeno desensamblador para analizar o bytecode no bloque 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))
breakComo resultado, obtemos o seguinte código de máquina virtual:
Código de máquina virtual
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)Como podes ver, este programa simplemente verifica cada carácter de DB101 para a igualdade dun determinado valor. A liña final para pasar todas as comprobacións é: n0w u 4r3 7h3 m4573r. Se esta liña se coloca no bloque DB101, activarase o control manual do PLC e será posible explotar ou desinflar o globo.
Iso é todo! Alexey demostrou un alto nivel de coñecementos digno dun ninja industrial :) Enviamos premios memorables ao gañador. Moitas grazas a todos os participantes!
Fonte: www.habr.com