🥇Industrial Ninja의 발자취를 따라: Positive Hack Days 9에서 PLC가 해킹된 방법

지난 PHDays 9에서 가스 펌프장 해킹 대회를 열었습니다. 산업닌자. 현장에는 동일한 산업 프로세스를 모방하는 다양한 보안 매개변수(보안 없음, 낮은 보안, 높은 보안)를 갖춘 XNUMX개의 스탠드가 있었습니다. 즉, 압력을 받는 공기를 풍선에 펌핑한 다음 방출했습니다.

다양한 안전 매개변수에도 불구하고 스탠드의 하드웨어 구성은 동일했습니다. Siemens Simatic PLC S7-300 시리즈; 비상 수축 버튼 및 압력 측정 장치(PLC 디지털 입력(DI)에 연결됨) 공기 팽창 및 수축을 위해 작동하는 밸브(PLC(DO)의 디지털 출력에 연결됨) - 아래 그림을 참조하세요.

PLC는 압력 판독값과 해당 프로그램에 따라 볼의 수축 또는 팽창을 결정했습니다(해당 밸브를 열고 닫음). 하지만 모든 스탠드에는 수동 제어 모드가 있어서 아무런 제약 없이 밸브의 상태를 제어할 수 있었다.

스탠드는 이 모드를 활성화하는 복잡성이 달랐습니다. 보호되지 않은 스탠드에서는 이 작업이 가장 쉬웠고, 높은 보안 스탠드에서는 이에 따라 더 어려웠습니다.

233개 문제 중 1개 문제가 이틀 만에 해결되었습니다. XNUMX위 참가자는 XNUMX점을 획득했다. (그는 대회 준비에 일주일을 보냈다.) 세 명의 우승자: I 위치 - aXNUMXexdandy, II - Rubikoid, III - Ze.

그러나 PHDays 동안 참가자 중 세 가지 스탠드를 모두 통과하지 못한 참가자가 있어 온라인 대회를 열기로 결정하고 XNUMX월 초에 가장 어려운 과제를 발표했습니다. 참가자들은 한 달 안에 과제를 완수하고, 깃발을 찾고, 해결책을 자세하고 흥미롭게 설명해야 했습니다.

컷 아래에는 한 달 동안 전송된 작업에 대한 최상의 솔루션에 대한 분석이 게시되어 있으며, 이는 PHDays 동안 경쟁에서 1위를 차지한 Digital Security 회사의 Alexey Kovrizhnykh(aXNUMXexdandy)가 발견한 것입니다. 아래에는 의견과 함께 해당 텍스트를 제시합니다.

초기 분석

따라서 작업에는 다음 파일이 포함된 아카이브가 포함되었습니다.

block_upload_traffic.pcapng
DB100.bin
힌트.txt

힌트.txt 파일에는 작업을 해결하는 데 필요한 정보와 힌트가 포함되어 있습니다. 그 내용은 다음과 같습니다.

Petrovich는 어제 나에게 PlcSim의 블록을 Step7로 로드할 수 있다고 말했습니다.

부스에는 Siemens Simatic S7-300 시리즈 PLC가 사용되었습니다.

PlcSim은 Siemens S7 PLC용 프로그램을 실행하고 디버깅할 수 있는 PLC 에뮬레이터입니다.

DB100.bin 파일에는 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 유............... 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......

이름에서 알 수 있듯이 block_upload_traffic.pcapng 파일에는 PLC에 대한 블록 업로드 트래픽 덤프가 포함되어 있습니다.

컨퍼런스 기간 동안 대회 현장에서 발생한 트래픽 덤프를 확보하기가 조금 더 어려웠다는 점은 주목할 가치가 있습니다. 이를 위해서는 TeslaSCADA2용 프로젝트 파일의 스크립트를 이해해야 했습니다. 이를 통해 RC4를 사용하여 암호화된 덤프의 위치와 이를 해독하는 데 어떤 키를 사용해야 하는지 이해할 수 있었습니다. S7 프로토콜 클라이언트를 사용하여 사이트의 데이터 블록 덤프를 얻을 수 있습니다. 이를 위해 Snap7 패키지의 데모 클라이언트를 사용했습니다.

트래픽 덤프에서 신호 처리 블록 추출

덤프 내용을 보면 신호 처리 블록 OB1, FC1, FC2 및 FC3이 포함되어 있음을 알 수 있습니다.

이러한 블록을 제거해야 합니다. 예를 들어 이전에 트래픽을 pcapng 형식에서 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 = ''

결과 블록을 조사한 결과, 항상 바이트 70 70(pp)으로 시작한다는 것을 알 수 있습니다. 이제 이를 분석하는 방법을 배워야 합니다. 할당 힌트에서는 이를 위해 PlcSim을 사용해야 한다고 제안합니다.

블록에서 사람이 읽을 수 있는 명령어 얻기

먼저 Simatic Manager 소프트웨어를 사용하여 반복 명령(= Q 7)이 포함된 여러 블록을 로드하고 에뮬레이터에서 얻은 PLC를 example.plc 파일에 저장하여 S0.0-PlcSim을 프로그래밍해 보겠습니다. 파일의 내용을 보면 앞서 발견한 서명 70 70으로 다운로드된 블록의 시작을 쉽게 확인할 수 있습니다. 블록 앞에는 분명히 블록 크기가 4바이트 리틀 엔디안 값으로 기록되어 있습니다.

plc 파일의 구조에 대한 정보를 받은 후 PLC S7 프로그램을 읽기 위한 다음 작업 계획이 나타났습니다.

Simatic Manager를 사용하여 덤프에서 받은 것과 유사한 블록 구조를 S7-PlcSim에 생성합니다. 블록 크기(필요한 명령어 수로 블록을 채워서 달성됨)와 해당 식별자(OB1, FC1, FC2, FC3)가 일치해야 합니다.
PLC를 파일로 저장합니다.
결과 파일의 블록 내용을 트래픽 덤프의 블록으로 바꿉니다. 블록의 시작은 서명에 의해 결정됩니다.
결과 파일을 S7-PlcSim에 로드하고 Simatic Manager에서 블록의 내용을 살펴봅니다.

예를 들어 블록은 다음 코드로 대체될 수 있습니다.

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는 아마도 더 어렵지만 여전히 올바른 길을 택했습니다. 우리는 참가자들이 NetToPlcSim 프로그램을 사용하여 PlcSim이 네트워크를 통해 통신하고 Snap7을 통해 PlcSim에 블록을 업로드한 다음 개발 환경을 사용하여 PlcSim에서 해당 블록을 프로젝트로 다운로드할 수 있다고 가정했습니다.

S7-PlcSim에서 결과 파일을 열면 Simatic Manager를 사용하여 덮어쓴 블록을 읽을 수 있습니다. 주요 장치 제어 기능은 블록 FC1에 기록됩니다. 특히 주목할 점은 #TEMP0 변수입니다. 이 변수는 켜질 때 M2.2 및 M2.3 비트 메모리 값을 기반으로 PLC 제어를 수동 모드로 설정하는 것으로 나타납니다. #TEMP0 값은 FC3 기능에 의해 설정됩니다.

문제를 해결하려면 FC3 함수를 분석하고 논리적 함수를 반환하기 위해 수행해야 할 작업을 이해해야 합니다.

대회장 Low Security 스탠드의 PLC 신호 처리 블록도 비슷한 방식으로 배치했지만, #TEMP0 변수의 값을 설정하려면 DB1 블록에 my ninja way라는 라인을 써넣으면 충분했습니다. 블록의 값을 확인하는 것은 간단했으며 블록 프로그래밍 언어에 대한 깊은 지식이 필요하지 않았습니다. 분명히 높은 보안 수준에서는 수동 제어를 달성하는 것이 훨씬 더 어려울 것이며 STL 언어(S7 PLC를 프로그래밍하는 방법 중 하나)의 복잡성을 이해하는 것이 필요합니다.

역방향 블록 FC3

STL 표현의 FC3 블록 내용:

      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

코드가 상당히 길고 STL에 익숙하지 않은 사람에게는 복잡해 보일 수 있습니다. 이 기사의 프레임워크 내에서 각 명령을 분석하는 것은 의미가 없습니다. STL 언어의 자세한 지침과 기능은 해당 매뉴얼에서 찾을 수 있습니다. S7-300 및 S7-400 프로그래밍을 위한 명령문 목록(STL). 여기서는 처리 후 동일한 코드를 제시하겠습니다. 즉, 레이블과 변수의 이름을 바꾸고 작업 알고리즘과 일부 STL 언어 구성을 설명하는 주석을 추가합니다. 문제의 블록에는 우리가 알고 있는 내용인 DB100 블록에 있는 일부 바이트코드를 실행하는 가상 머신이 포함되어 있다는 점을 즉시 알아두겠습니다. 가상 머신 명령어는 1바이트의 운영 코드와 인수 바이트(각 인수당 XNUMX바이트)로 구성됩니다. 고려된 모든 지침에는 두 개의 인수가 있으며 주석에서 해당 값을 X와 Y로 지정했습니다.

처리 후 코드]

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

가상 머신 명령어에 대한 아이디어를 얻었으니 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))
        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)

보시다시피, 이 프로그램은 단순히 DB101의 각 문자가 특정 값과 같은지 확인합니다. 모든 검사를 통과하기 위한 마지막 줄은 n0w u 4r3 7h3 m4573r입니다. 이 라인이 블록 DB101에 배치되면 수동 PLC 제어가 활성화되고 풍선을 분해하거나 수축시킬 수 있습니다. 

그게 다야! Alexey는 산업 닌자에 걸맞은 높은 수준의 지식을 보여주었습니다 :) 우승자에게는 기억에 남는 상품을 보냈습니다. 모든 참가자들에게 깊은 감사를 드립니다!

출처 : habr.com

Industrial Ninja의 발자취를 따라: Positive Hack Days 9에서 PLC가 해킹된 방법

초기 분석

트래픽 덤프에서 신호 처리 블록 추출

블록에서 사람이 읽을 수 있는 명령어 얻기

역방향 블록 FC3

코멘트를 추가 답장을 취소