🥇Стопама Индустриал Ниња: како је ПЛЦ хакован на Поситиве Хацк Даис 9

На последњем ПХДаис 9 одржали смо такмичење за хаковање постројења за пумпање гаса - такмичење Индустриал Ниња. На локацији су била три штанда са различитим безбедносним параметрима (Без безбедности, Ниска безбедност, Висока безбедност), који су опонашали исти индустријски процес: ваздух под притиском је упумпаван у балон (а затим пуштен).

Упркос различитим безбедносним параметрима, хардверски састав трибина је био исти: Сиеменс Симатиц ПЛЦ серија С7-300; дугме за испухивање у нужди и уређај за мерење притиска (повезан са дигиталним улазима ПЛЦ-а (ДИ)); вентили који раде за надувавање и испухивање ваздуха (повезани на дигиталне излазе ПЛЦ-а (ДО)) - видети слику испод.

ПЛЦ је, у зависности од очитавања притиска иу складу са својим програмом, донео одлуку да издува или надува лопту (отворио и затворио одговарајуће вентиле). Међутим, сви штандови су имали ручни режим управљања, што је омогућило контролу стања вентила без икаквих ограничења.

Трибине су се разликовале по сложености омогућавања овог режима: на незаштићеном штанду то је било најлакше урадити, а на штанду високе безбедности је сходно томе било теже.

Пет од шест проблема решено је за два дана; Првопласирани је освојио 233 бода (недељу дана се припремао за такмичење). Три победника: И место - а1екданди, ИИ - Рубикоид, ИИИ - Зе.

Међутим, током ПХДаис-а нико од учесника није успео да савлада све три трибине, па смо одлучили да направимо онлајн такмичење и почетком јуна објавили најтежи задатак. Учесници су морали да ураде задатак у року од месец дана, пронађу заставу и детаљно и на занимљив начин опишу решење.

Испод реза објављујемо анализу најбољег решења задатка од оних послатих током месеца, пронашао га је Алексеј Коврижних (а1екданди) из компаније Дигитал Сецурити, који је заузео XNUMX. место на такмичењу током ПХДаис-а. У наставку доносимо њен текст са нашим коментарима.

Иницијална анализа

Дакле, задатак је садржао архиву са следећим фајловима:

блоцк_уплоад_траффиц.пцапнг
ДБ100.бин
хинтс.ткт

Датотека хинтс.ткт садржи потребне информације и савете за решавање задатка. Ево његовог садржаја:

Петровић ми је јуче рекао да можете учитати блокове са ПлцСим-а у Степ7.

На штанду је коришћен Сиеменс Симатиц С7-300 серија ПЛЦ.

ПлцСим је ПЛЦ емулатор који вам омогућава покретање и отклањање грешака у програмима за Сиеменс С7 ПЛЦ-ове.

Чини се да датотека ДБ100.бин садржи ДБ100 ПЛЦ блок података: 00000000: 0100 0102 6е02 0401 0206 0100 0101 0102 ....н......... 00000010: 1002 0501 0202 2002 0501 0206 0100 . ..... ......... 0102: 00000020 0102 7702 0401 0206 0100 0103 0102а0 ..в............. 02: 00000030 0501 0202 1602 0501 0206 0100 ................ 0104: 0102 00000040 7502 0401 0206 0100 0105а0102 0 у............. 02: 0501 00000050 0202 1602 0501 0206 0100 0106............0102. 3402: 4 00000060 0401 0206 0100 0107 0102 2602 ......... & ..... 0501: 0202Ц00000070 4 02 0501 0206 0100 0108 0102 Л ......... 3302. .. 0401 : 3 00000080 0206 0100 0109а0102 0 02 0501 ................ 0202: 1602 00000090 0501 0206а 0100 010 0102 3702 .......... 0401а0206: 7 000000б 0 0100 010 0102 2202 0501 ......".....Ф... 0202б4602: 0501 000000 0ц 0206 0100 010 ...... .. 0102ц3302: 0401д 0206 0100а3 000000 0 010 0102 0 ................ 02д0501: 0202 1602е 0501 0206д000000 0 0100 ...010 .... .... 0102е6: 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: 1202 0501 0202 2502 0501 0206 .....0100 ..... 0112 ... .....&... 00000110: 0102 3302 0401ц0206 0100 0113 0102 ....Л......

Као што име сугерише, датотека блоцк_уплоад_траффиц.пцапнг садржи испис саобраћаја за отпремање блокова у ПЛЦ.

Вреди напоменути да је ову депонију саобраћаја на месту такмичења током конференције било мало теже добити. Да бисте то урадили, било је потребно разумети скрипту из пројектне датотеке за ТеслаСЦАДА2. Из њега је било могуће разумети где се налази депонија шифрована помоћу РЦ4 и који кључ треба да се користи за дешифровање. Думпови блокова података на локацији могу се добити коришћењем клијента С7 протокола. За ово сам користио демо клијент из Снап7 пакета.

Екстраховање блокова за обраду сигнала из саобраћајне депоније

Гледајући садржај дампа, можете схватити да садржи блокове за обраду сигнала ОБ1, ФЦ1, ФЦ2 и ФЦ3:

Ови блокови морају бити уклоњени. Ово се може урадити, на пример, помоћу следеће скрипте, након што је претходно конвертовао саобраћај из пцапнг формата у пцап:

#!/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 = ''

Након што сте испитали резултујуће блокове, приметићете да они увек почињу са бајтовима 70 70 (пп). Сада морате научити како их анализирати. Наговештај за додељивање сугерише да за ово треба да користите ПлцСим.

Добијање инструкција читљивих људи из блокова

Прво, покушајмо да програмирамо С7-ПлцСим тако што ћемо у њега учитати неколико блокова са понављајућим упутствима (= К 0.0) помоћу софтвера Симатиц Манагер и сачувати ПЛЦ добијен у емулатору у датотеку екампле.плц. Гледајући садржај датотеке, лако можете одредити почетак преузетих блокова по потпису 70 70, који смо раније открили. Пре блокова, очигледно, величина блока је записана као 4-бајтна вредност малог ендијана.

Након што смо добили информације о структури плц фајлова, појавио се следећи акциони план за читање ПЛЦ С7 програма:

Користећи Симатиц Манагер, креирамо структуру блокова у С7-ПлцСим-у сличну оној коју смо добили из думп-а. Величине блокова морају да се подударају (ово се постиже попуњавањем блокова потребним бројем инструкција) и њиховим идентификаторима (ОБ1, ФЦ1, ФЦ2, ФЦ3).
Сачувајте ПЛЦ у датотеку.
Садржај блокова у резултујућој датотеци замењујемо блоковима из депоније саобраћаја. Почетак блокова је одређен потписом.
Добијени фајл учитавамо у С7-ПлцСим и гледамо садржај блокова у Симатиц Манагер-у.

Блокови се могу заменити, на пример, следећим кодом:

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)

Алексеј је кренуо можда тежим, али ипак исправним путем. Претпоставили смо да ће учесници користити НетТоПлцСим програм како би ПлцСим могао да комуницира преко мреже, учитава блокове у ПлцСим преко Снап7, а затим преузима ове блокове као пројекат са ПлцСим-а користећи развојно окружење.

Отварањем резултујуће датотеке у С7-ПлцСим-у, можете прочитати преписане блокове користећи Симатиц Манагер. Главне функције управљања уређајем су снимљене у блоку ФЦ1. Од посебне пажње је променљива #ТЕМП0, која када је укључена чини се да поставља ПЛЦ контролу на ручни режим на основу вредности М2.2 и М2.3 бита меморије. Вредност #ТЕМП0 је постављена функцијом ФЦ3.

Да бисте решили проблем, потребно је да анализирате функцију ФЦ3 и разумете шта треба да се уради да би вратила логичну.

Блокови за обраду ПЛЦ сигнала на штанду Лов Сецурити на месту такмичења били су распоређени на сличан начин, али да би се подесила вредност променљиве #ТЕМП0, било је довољно уписати линију ми ниња ваи у ДБ1 блок. Провера вредности у блоку била је једноставна и није захтевала дубоко познавање језика програмирања блока. Очигледно, на нивоу високе безбедности, постизање ручне контроле ће бити много теже и неопходно је разумети замршености СТЛ језика (један од начина програмирања С7 ПЛЦ-а).

Реверзни блок ФЦ3

Садржај ФЦ3 блока у СТЛ представљању:

      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_VAL

Код је прилично дугачак и некоме ко није упознат са СТЛ-ом може изгледати компликовано. Нема смисла анализирати сваку инструкцију у оквиру овог чланка; детаљна упутства и могућности СТЛ језика могу се наћи у одговарајућем приручнику: Листа изјава (СТЛ) за С7-300 и С7-400 програмирање. Овде ћу представити исти код након обраде - преименовања ознака и променљивих и додавања коментара који описују алгоритам операције и неке СТЛ језичке конструкције. Одмах да приметим да дотични блок садржи виртуелну машину која извршава неки бајт код који се налази у блоку ДБ100, чији садржај знамо. Инструкције виртуелне машине се састоје од 1 бајта оперативног кода и бајтова аргумената, по један бајт за сваки аргумент. Сва разматрана упутства имају два аргумента; њихове вредности сам означио у коментарима као Кс и И.

Шифра након обраде]

# Инициализация различных переменных
      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_VAL

Пошто сте добили идеју о упутствима виртуелне машине, хајде да напишемо мали дисамблер за рашчлањивање бајткода у ДБ100 блоку:

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))
        break

Као резултат, добијамо следећи код виртуелне машине:

Код виртуелне машине

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)

Као што видите, овај програм једноставно проверава сваки карактер из ДБ101 да ли је једнак одређеној вредности. Коначна линија за пролазак свих провера је: н0в у 4р3 7х3 м4573р. Ако се ова линија постави у блок ДБ101, тада се активира ручна ПЛЦ контрола и биће могуће експлодирати или испухати балон. 

То је све! Алексеј је показао висок ниво знања достојан индустријског нинџе :) Победнику смо послали незаборавне награде. Велико хвала свим учесницима!

Извор: ввв.хабр.цом

Стопама индустријског нинџе: како је ПЛЦ хакован на Поситиве Хацк Даис 9

Иницијална анализа

Екстраховање блокова за обраду сигнала из саобраћајне депоније

Добијање инструкција читљивих људи из блокова

Реверзни блок ФЦ3

Додај коментар Одустани од одговора