ໃນ footsteps ຂອງ Ninja ອຸດສາຫະກໍາ: ວິທີການ PLC ໄດ້ຖືກ hacked ໃນ Positive Hack Days 9

ໃນ PHDays ສຸດທ້າຍ 9 ພວກເຮົາໄດ້ຈັດການແຂ່ງຂັນເພື່ອ hack ໂຮງງານຜະລິດອາຍແກັສ - ການແຂ່ງຂັນ Ninja ອຸດສາຫະກໍາ. ມີສາມຢືນຢູ່ໃນເວັບໄຊທີ່ມີຕົວກໍານົດຄວາມປອດໄພທີ່ແຕກຕ່າງກັນ (ບໍ່ມີຄວາມປອດໄພ, ຄວາມປອດໄພຕ່ໍາ, ຄວາມປອດໄພສູງ), emulating ຂະບວນການອຸດສາຫະກໍາດຽວກັນ: ອາກາດພາຍໃຕ້ຄວາມກົດດັນໄດ້ຖືກ pumped ເຂົ້າໄປໃນປູມເປົ້າ (ແລະຫຼັງຈາກນັ້ນປ່ອຍອອກມາ).

ເຖິງວ່າຈະມີຕົວກໍານົດຄວາມປອດໄພທີ່ແຕກຕ່າງກັນ, ອົງປະກອບຮາດແວຂອງຂາຕັ້ງແມ່ນຄືກັນ: Siemens Simatic PLC S7-300 ຊຸດ; ປຸ່ມ deflation ສຸກເສີນແລະອຸປະກອນວັດແທກຄວາມກົດດັນ (ເຊື່ອມຕໍ່ກັບ PLC ວັດສະດຸປ້ອນດິຈິຕອນ (DI)); valves ປະຕິບັດງານສໍາລັບອັດຕາເງິນເຟີ້ແລະ deflation ຂອງອາກາດ (ເຊື່ອມຕໍ່ກັບຜົນຜະລິດດິຈິຕອນຂອງ PLC (DO)) - ເບິ່ງຮູບຂ້າງລຸ່ມນີ້.

PLC, ອີງຕາມການອ່ານຄວາມກົດດັນແລະສອດຄ່ອງກັບໂຄງການຂອງຕົນ, ໄດ້ຕັດສິນໃຈທີ່ຈະ deflate ຫຼື inflate ບານ (ເປີດແລະປິດປ່ຽງທີ່ສອດຄ້ອງກັນ). ຢ່າງໃດກໍຕາມ, ຂາຕັ້ງທັງຫມົດມີຮູບແບບການຄວບຄຸມຄູ່ມື, ເຊິ່ງເຮັດໃຫ້ມັນເປັນໄປໄດ້ທີ່ຈະຄວບຄຸມສະຖານະຂອງປ່ຽງໂດຍບໍ່ມີຂໍ້ຈໍາກັດໃດໆ.

ຂາຕັ້ງມີຄວາມແຕກຕ່າງໃນຄວາມສັບສົນຂອງການເປີດໃຊ້ຮູບແບບນີ້: ຢູ່ທີ່ຈຸດຢືນທີ່ບໍ່ມີການປ້ອງກັນມັນງ່າຍທີ່ສຸດທີ່ຈະເຮັດແນວນີ້, ແລະຢູ່ທີ່ຈຸດຢືນຄວາມປອດໄພສູງມັນກໍ່ມີຄວາມຫຍຸ້ງຍາກຫຼາຍ.

ຫ້າ​ໃນ​ຫົກ​ບັນຫາ​ໄດ້​ຮັບ​ການ​ແກ້​ໄຂ​ໃນ​ສອງ​ມື້; ຜູ້ເຂົ້າຮ່ວມສະຖານທີ່ທໍາອິດໄດ້ຮັບ 233 ຄະແນນ (ລາວໃຊ້ເວລາຫນຶ່ງອາທິດໃນການກະກຽມສໍາລັບການແຂ່ງຂັນ). ສາມຜູ້ຊະນະ: I place - a1exdandy, II - Rubikoid, III - Ze.

ຢ່າງໃດກໍ່ຕາມ, ໃນລະຫວ່າງ PHDays, ບໍ່ມີຜູ້ເຂົ້າຮ່ວມສາມາດເອົາຊະນະທັງສາມຈຸດຢືນ, ດັ່ງນັ້ນພວກເຮົາໄດ້ຕັດສິນໃຈເຮັດການແຂ່ງຂັນອອນໄລນ໌ແລະເຜີຍແຜ່ວຽກງານທີ່ຍາກທີ່ສຸດໃນຕົ້ນເດືອນມິຖຸນາ. ຜູ້ເຂົ້າຮ່ວມຕ້ອງໄດ້ເຮັດສໍາເລັດວຽກງານພາຍໃນຫນຶ່ງເດືອນ, ຊອກຫາທຸງ, ແລະອະທິບາຍການແກ້ໄຂຢ່າງລະອຽດແລະຫນ້າສົນໃຈ.

ຂ້າງລຸ່ມນີ້ການຕັດພວກເຮົາເຜີຍແຜ່ການວິເຄາະຂອງການແກ້ໄຂທີ່ດີທີ່ສຸດສໍາລັບວຽກງານຈາກຜູ້ທີ່ສົ່ງມາໃນເດືອນ, ມັນໄດ້ຖືກພົບເຫັນໂດຍ Alexey Kovrizhnykh (a1exdandy) ຈາກບໍລິສັດ Digital Security, ຜູ້ທີ່ໄດ້ອັນດັບທີ XNUMX ໃນການແຂ່ງຂັນໃນລະຫວ່າງ PHDays. ຂ້າງລຸ່ມນີ້ພວກເຮົານໍາສະເຫນີຂໍ້ຄວາມຂອງມັນດ້ວຍຄໍາເຫັນຂອງພວກເຮົາ.

ການວິເຄາະເບື້ອງຕົ້ນ

ດັ່ງນັ້ນ, ວຽກງານມີບ່ອນເກັບມ້ຽນທີ່ມີໄຟລ໌ຕໍ່ໄປນີ້:

• block_upload_traffic.pcapng
• DB100.bin
• hints.txt

ໄຟລ໌ hints.txt ມີຂໍ້ມູນທີ່ຈໍາເປັນ ແລະຄໍາແນະນໍາເພື່ອແກ້ໄຂວຽກງານ. ນີ້ແມ່ນເນື້ອໃນຂອງມັນ:

1. Petrovich ບອກຂ້ອຍໃນມື້ວານນີ້ວ່າທ່ານສາມາດໂຫລດບລັອກຈາກ PlcSim ເຂົ້າໄປໃນຂັ້ນຕອນທີ 7.
2. Siemens Simatic S7-300 series PLC ໄດ້ຖືກນໍາໃຊ້ຢູ່ບ່ອນຕັ້ງ.
3. PlcSim ເປັນ emulator PLC ທີ່ອະນຸຍາດໃຫ້ທ່ານສາມາດດໍາເນີນການແລະ debug ໂຄງການສໍາລັບ Siemens S7 PLCs.

ໄຟລ໌ 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 0401a0206 ..w............. 0100: 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 0100 0107 0102 2602 0501 0202 00000070 4 02 0501 : 0206 0100 0108 0102 3302a0401 3 00000080 0206 ................ 0100 : 0109 0102 0 02a 0501 0202 1602 00000090 ..... . .. 0501c0206:0100d 010 0102a3702 0401 0206 7 000000 0 ................ 0100d010: 0102 2202e 0501 0202d4602 0501 000000 ...... .... 0e0206: 0100 010 0102 3302 0401 0206 0100 3 ........#...... 000000f0: 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 0202c2302 0501 0206 0100 ....L......

ດັ່ງທີ່ຊື່ແນະນໍາ, ໄຟລ໌ block_upload_traffic.pcapng ມີການຖິ້ມຂີ້ເຫຍື້ອຂອງການຈະລາຈອນການອັບໂຫລດບລັອກໄປຫາ PLC.

ມັນເປັນມູນຄ່າທີ່ສັງເກດວ່າການຖິ້ມຂີ້ເຫຍື້ອນີ້ຢູ່ໃນສະຖານທີ່ແຂ່ງຂັນໃນລະຫວ່າງກອງປະຊຸມແມ່ນມີຄວາມຫຍຸ້ງຍາກຫຼາຍທີ່ຈະໄດ້ມາ. ເພື່ອເຮັດສິ່ງນີ້, ມັນຈໍາເປັນຕ້ອງເຂົ້າໃຈ script ຈາກໄຟລ໌ໂຄງການສໍາລັບ TeslaSCADA2. ຈາກມັນສາມາດເຂົ້າໃຈໄດ້ວ່າບ່ອນຖິ້ມຂີ້ເຫຍື້ອທີ່ເຂົ້າລະຫັດໂດຍໃຊ້ RC4 ຕັ້ງຢູ່ແລະຕ້ອງການໃຊ້ລະຫັດໃດເພື່ອຖອດລະຫັດມັນ. ການຖິ້ມບລັອກຂໍ້ມູນຢູ່ໃນເວັບໄຊສາມາດໄດ້ຮັບໂດຍໃຊ້ S7 protocol client. ສໍາລັບການນີ້ຂ້າພະເຈົ້າໄດ້ນໍາໃຊ້ລູກຄ້າຕົວຢ່າງຈາກຊຸດ Snap7.

ສະກັດຕັນການປະມວນຜົນສັນຍານຈາກ dump ການຈະລາຈອນ

ຊອກຫາຢູ່ໃນເນື້ອໃນຂອງ dump, ທ່ານສາມາດເຂົ້າໃຈໄດ້ວ່າມັນປະກອບດ້ວຍຕັນປະມວນຜົນສັນຍານ 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 = ''

ໂດຍໄດ້ກວດເບິ່ງຕັນຜົນໄດ້ຮັບ, ທ່ານຈະສັງເກດເຫັນວ່າພວກມັນເລີ່ມຕົ້ນດ້ວຍ bytes 70 70 (pp). ໃນປັດຈຸບັນທ່ານຈໍາເປັນຕ້ອງຮຽນຮູ້ວິທີການວິເຄາະພວກມັນ. ຄໍາແນະນໍາການມອບຫມາຍແນະນໍາວ່າທ່ານຈໍາເປັນຕ້ອງໃຊ້ PlcSim ສໍາລັບການນີ້.

ໄດ້ຮັບຄໍາແນະນໍາທີ່ມະນຸດສາມາດອ່ານໄດ້ຈາກບລັອກ

ທໍາອິດ, ໃຫ້ພະຍາຍາມຂຽນໂປລແກລມ S7-PlcSim ໂດຍການໂຫລດຫຼາຍໆບລັອກດ້ວຍຄໍາແນະນໍາຊ້ໍາ (= Q 0.0) ເຂົ້າໄປໃນມັນໂດຍໃຊ້ຊອບແວ Simatic Manager, ແລະບັນທຶກ PLC ທີ່ໄດ້ຮັບໃນ emulator ເຂົ້າໄປໃນໄຟລ໌ example.plc. ໂດຍການເບິ່ງເນື້ອໃນຂອງໄຟລ໌, ທ່ານສາມາດກໍານົດການເລີ່ມຕົ້ນຂອງບລັອກທີ່ດາວໂຫລດໄດ້ງ່າຍໂດຍລາຍເຊັນ 70 70, ທີ່ພວກເຮົາຄົ້ນພົບກ່ອນຫນ້ານີ້. ກ່ອນທ່ອນໄມ້, ປາກົດຂື້ນ, ຂະຫນາດຂອງບລັອກແມ່ນຂຽນເປັນຄ່າ 4-byte ນ້ອຍ-endian.

ຫຼັງຈາກທີ່ພວກເຮົາໄດ້ຮັບຂໍ້ມູນກ່ຽວກັບໂຄງສ້າງຂອງໄຟລ໌ plc, ແຜນປະຕິບັດງານດັ່ງຕໍ່ໄປນີ້ປາກົດຂຶ້ນສໍາລັບການອ່ານໂຄງການ PLC S7:

1. ການນໍາໃຊ້ Simatic Manager, ພວກເຮົາສ້າງໂຄງສ້າງບລັອກໃນ S7-PlcSim ຄ້າຍຄືກັນກັບຫນຶ່ງທີ່ພວກເຮົາໄດ້ຮັບຈາກການຖິ້ມຂີ້ເຫຍື້ອ. ຂະຫນາດຂອງຕັນຕ້ອງກົງກັນ (ອັນນີ້ແມ່ນບັນລຸໄດ້ໂດຍການຕື່ມຂໍ້ມູນໃສ່ຕັນດ້ວຍຈໍານວນຄໍາແນະນໍາທີ່ຕ້ອງການ) ແລະຕົວລະບຸຂອງມັນ (OB1, FC1, FC2, FC3).
2. ບັນທຶກ PLC ໃສ່ໄຟລ໌.
3. ພວກເຮົາທົດແທນເນື້ອໃນຂອງຕັນໃນໄຟລ໌ຜົນໄດ້ຮັບກັບຕັນຈາກ dump ການຈະລາຈອນ. ການເລີ່ມຕົ້ນຂອງທ່ອນໄມ້ແມ່ນຖືກກໍານົດໂດຍລາຍເຊັນ.
4. ພວກເຮົາໂຫລດໄຟລ໌ຜົນໄດ້ຮັບເຂົ້າໄປໃນ S7-PlcSim ແລະເບິ່ງເນື້ອໃນຂອງຕັນໃນ Simmatic Manager.

Blocks ສາມາດຖືກແທນທີ່, ສໍາລັບຕົວຢ່າງ, ດ້ວຍລະຫັດຕໍ່ໄປນີ້:

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 ສາມາດສື່ສານຜ່ານເຄືອຂ່າຍ, ອັບໂຫລດບລັອກໄປຍັງ PlcSim ຜ່ານ Snap7, ແລະຫຼັງຈາກນັ້ນດາວໂຫລດຕັນເຫຼົ່ານີ້ເປັນໂຄງການຈາກ PlcSim ໂດຍໃຊ້ສະພາບແວດລ້ອມການພັດທະນາ.

ໂດຍການເປີດໄຟລ໌ຜົນໄດ້ຮັບໃນ S7-PlcSim, ທ່ານສາມາດອ່ານບລັອກທີ່ຖືກຂຽນທັບໂດຍໃຊ້ Simatic Manager. ຫນ້າທີ່ຄວບຄຸມອຸປະກອນຕົ້ນຕໍແມ່ນບັນທຶກໄວ້ໃນບລັອກ FC1. ຫມາຍເຫດໂດຍສະເພາະແມ່ນຕົວແປ #TEMP0, ເຊິ່ງເມື່ອເປີດມັນເບິ່ງຄືວ່າຈະຕັ້ງຄ່າການຄວບຄຸມ PLC ເປັນໂຫມດຄູ່ມືໂດຍອີງໃສ່ຄ່າຄວາມຈໍາບິດ M2.2 ແລະ M2.3. ຄ່າ #TEMP0 ຖືກກໍານົດໂດຍຟັງຊັນ FC3.

ເພື່ອແກ້ໄຂບັນຫາ, ທ່ານຈໍາເປັນຕ້ອງວິເຄາະຟັງຊັນ FC3 ແລະເຂົ້າໃຈສິ່ງທີ່ຕ້ອງເຮັດເພື່ອໃຫ້ມັນກັບຄືນມາຢ່າງມີເຫດຜົນ.

ຕັນການປຸງແຕ່ງສັນຍານ PLC ຢູ່ທີ່ຈຸດຢືນຄວາມປອດໄພຕ່ໍາໃນສະຖານທີ່ແຂ່ງຂັນໄດ້ຖືກຈັດລຽງໃນລັກສະນະທີ່ຄ້າຍຄືກັນ, ແຕ່ເພື່ອກໍານົດຄ່າຂອງຕົວແປ #TEMP0, ມັນພຽງພໍທີ່ຈະຂຽນເສັ້ນວິທີການ ninja ຂອງຂ້ອຍເຂົ້າໄປໃນ DB1 block. ການກວດສອບມູນຄ່າໃນບລັອກແມ່ນກົງໄປກົງມາແລະບໍ່ຮຽກຮ້ອງໃຫ້ມີຄວາມຮູ້ເລິກເຊິ່ງກ່ຽວກັບພາສາການຂຽນໂປຼແກຼມບລັອກ. ແນ່ນອນ, ໃນລະດັບຄວາມປອດໄພສູງ, ການບັນລຸການຄວບຄຸມຄູ່ມືຈະມີຄວາມຫຍຸ້ງຍາກຫຼາຍແລະມັນຈໍາເປັນຕ້ອງເຂົ້າໃຈຄວາມຊັບຊ້ອນຂອງພາສາ STL (ຫນຶ່ງໃນວິທີການດໍາເນີນໂຄງການ S7 PLC).

Reverse block FC3

ເນື້ອໃນຂອງຕັນ FC3 ໃນການເປັນຕົວແທນຂອງ 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_VAL

ລະຫັດແມ່ນຂ້ອນຂ້າງຍາວ ແລະອາດເບິ່ງຄືວ່າສັບສົນກັບຄົນທີ່ບໍ່ຄຸ້ນເຄີຍກັບ STL. ບໍ່ມີຈຸດໃດໃນການວິເຄາະແຕ່ລະຄໍາແນະນໍາໃນກອບຂອງບົດຄວາມນີ້, ຄໍາແນະນໍາລາຍລະອຽດແລະຄວາມສາມາດຂອງພາສາ STL ສາມາດພົບໄດ້ໃນຄູ່ມືທີ່ສອດຄ້ອງກັນ: ລາຍການຖະແຫຼງການ (STL) ສໍາລັບການດໍາເນີນໂຄງການ S7-300 ແລະ S7-400. ໃນທີ່ນີ້ຂ້າພະເຈົ້າຈະນໍາສະເຫນີລະຫັດດຽວກັນຫຼັງຈາກການປຸງແຕ່ງ - ການປ່ຽນຊື່ປ້າຍຊື່ແລະຕົວແປແລະເພີ່ມຄໍາຄິດຄໍາເຫັນທີ່ອະທິບາຍວິທີການປະຕິບັດງານແລະບາງໂຄງສ້າງຂອງພາສາ STL. ໃຫ້ຂ້າພະເຈົ້າສັງເກດເຫັນທັນທີວ່າຕັນໃນຄໍາຖາມປະກອບດ້ວຍເຄື່ອງ virtual ທີ່ປະຕິບັດບາງ bytecode ທີ່ຕັ້ງຢູ່ໃນຕັນ DB100, ເນື້ອໃນທີ່ພວກເຮົາຮູ້. ຄໍາແນະນໍາຂອງເຄື່ອງ virtual ປະກອບດ້ວຍ 1 byte ຂອງລະຫັດປະຕິບັດການແລະ bytes ຂອງ arguments, ຫນຶ່ງ byte ສໍາລັບແຕ່ລະ argument. ຄໍາແນະນໍາທີ່ພິຈາລະນາທັງຫມົດມີສອງການໂຕ້ຖຽງ;

ລະຫັດຫຼັງຈາກການປະມວນຜົນ]

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

ມີຄວາມຄິດກ່ຽວກັບຄໍາແນະນໍາຂອງ virtual machine, ໃຫ້ຂຽນ disassembler ຂະຫນາດນ້ອຍເພື່ອວິເຄາະ bytecode ໃນ DB100 block:

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

ດັ່ງນັ້ນ, ພວກເຮົາໄດ້ຮັບລະຫັດ virtual machine ຕໍ່ໄປນີ້:

ລະຫັດເຄື່ອງ 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)

ດັ່ງທີ່ເຈົ້າສາມາດເຫັນໄດ້, ໂຄງການນີ້ພຽງແຕ່ກວດເບິ່ງແຕ່ລະຕົວອັກສອນຈາກ DB101 ສໍາລັບຄວາມສະເຫມີພາບກັບຄ່າທີ່ແນ່ນອນ. ເສັ້ນສຸດທ້າຍສໍາລັບການຜ່ານການກວດສອບທັງຫມົດແມ່ນ: n0w u 4r3 7h3 m4573r. ຖ້າເສັ້ນນີ້ຖືກຈັດໃສ່ໃນບລັອກ DB101, ຫຼັງຈາກນັ້ນ, ການຄວບຄຸມ PLC ຄູ່ມືຈະຖືກເປີດໃຊ້ແລະມັນຈະເປັນໄປໄດ້ທີ່ຈະລະເບີດຫຼື deflate ປູມເປົ້າ.


ຫມົດ​ເທົ່າ​ນີ້! Alexey ສະແດງໃຫ້ເຫັນຄວາມຮູ້ໃນລະດັບສູງທີ່ສົມຄວນກັບ ninja ອຸດສາຫະກໍາ :) ພວກເຮົາໄດ້ສົ່ງລາງວັນທີ່ຫນ້າຈົດຈໍາໃຫ້ກັບຜູ້ຊະນະ. ຂອບໃຈຫຼາຍໆກັບຜູ້ເຂົ້າຮ່ວມທັງຫມົດ!

ແຫຼ່ງຂໍ້ມູນ: www.habr.com