🤟 🥟 ☁️ Boost.Asio का उपयोग करते हुए अतुल्यकालिक पिंग 🕺🏽 🆑 😫

कमजोरियों के लिए एक नोड को स्कैन करने के चरणों में से एक इसकी नेटवर्क उपलब्धता को निर्धारित करना है। जैसा कि आप जानते हैं, यह पिंग कमांड के माध्यम से कई तरीकों से किया जा सकता है।

बड़ी संख्या में कार्यस्थानों वाले संगठन में सुरक्षा विश्लेषण परियोजनाओं में से एक के लिए, हमें अपना "पिंजर" विकसित करने की आवश्यकता है।

तकनीकी विशिष्टताओं की आवश्यकताएं इस प्रकार थीं:

एक साथ प्रतिक्रिया करने वाले नोड्स की संख्या बड़ी (कई सबनेट) होनी चाहिए।
बंदरगाहों की संख्या उपयोगकर्ता द्वारा निर्धारित की जाती है (65535 हो सकती है)।
प्रोसेसर के सभी समय पर पिंगर को "खाना" नहीं चाहिए।
अदरक में तेज गति होनी चाहिए।

पिंग विधि उपयोगकर्ता द्वारा निर्धारित की जाती है, विभिन्न विधियाँ उपलब्ध हैं (ICMP पिंग, TCP पोर्ट पिंग और रिज़ॉल्व नाम)। स्वाभाविक रूप से, पहला विचार तैयार किए गए समाधान का उपयोग करना था, उदाहरण के लिए, नैंप, लेकिन यह नोड्स (पोर्ट) की ऐसी सीमाओं पर भारी और अनुत्पादक है।

ToR के अनुरूप होने के परिणाम के लिए, किए गए सभी ऑपरेशनों को अतुल्यकालिक होना चाहिए और थ्रेड्स के एकल पूल का उपयोग करना चाहिए।

बाद की परिस्थिति ने हमें Boost.Asio लाइब्रेरी को एक विकास उपकरण के रूप में चुनने के लिए प्रेरित किया, क्योंकि इसमें सभी आवश्यक अतुल्यकालिक प्राइमेटिव शामिल हैं।

अदरक का क्रियान्वयन

पिंजर के काम में, निम्नलिखित पदानुक्रम कार्यान्वित किया जाता है:
पिंग वर्ग पिंग का संचालन करता है, एक नाम प्राप्त करता है, कार्यों को पूरा करने के बाद, एक कॉलबैक शुरू किया जाता है, जिसके परिणामस्वरूप परिणाम प्रसारित होता है। पिंजर क्लास पिंग ऑपरेशन बनाता है, आरंभ करता है, नए अनुरोधों को कतारबद्ध करता है, थ्रेड्स की संख्या को नियंत्रित करता है और एक साथ खुले सॉकेट की संख्या को निर्धारित करता है, स्थानीय बंदरगाहों की उपलब्धता को निर्धारित करता है।

इस तथ्य को ध्यान में रखना आवश्यक है कि प्रतीक्षा कुर्सियां, और इसलिए एक साथ पिंगेबल पोर्ट्स, कई हजार तक पहुंच सकते हैं, जबकि दुर्गम नोड्स (पोर्ट्स) पिंग किए जाने पर प्रोसेसर लोड न्यूनतम हो सकता है।

दूसरी ओर, यदि उपलब्ध नोड्स (पोर्ट) को पिंग किया जाता है, तो कई सौ सक्रिय सॉकेट्स प्रोसेसर लोड को काफी बढ़ा देते हैं। यह पता चला है कि सक्रिय सॉकेट्स की संख्या पर प्रोसेसर लोड की निर्भरता नॉनलाइनर है।

सीपीयू संसाधनों और पिंग समय के बीच संतुलन बनाने के लिए, प्रोसेसर लोडिंग का उपयोग किया जाता है, जिसके आधार पर सक्रिय सॉकेट की संख्या नियंत्रित होती है।

पोर्ट उपलब्धता

पिंग मशीन पर, बंदरगाहों को एक फ़ायरवॉल द्वारा अवरुद्ध किया जा सकता है, इसलिए हमारे पिंजर में स्थानीय बंदरगाहों की उपलब्धता को निर्धारित करने के लिए एक तंत्र को लागू करना आवश्यक था। पोर्ट की उपलब्धता का निर्धारण करने के लिए, हम एक अमान्य पते से कनेक्ट करने का प्रयास कर रहे हैं: यदि यह सफल होता है, तो पोर्ट को फ़ायरवॉल द्वारा अनुकरण किया जाता है।

typename PortState::Enum GetPortState(const Ports::value_type port) { boost::recursive_mutex::scoped_lock lock(m_PortsMutex); PortState::Enum& state = m_EnabledPorts[port]; if (state == PortState::Unknown) { state = PortState::Pending; const std::size_t service = GetNextService(); const SocketPtr socket(new TCPSocket(GetService(service))); const TimerPtr timer(new Timer(GetService(service))); socket->async_connect( Tcp::endpoint(Address(INVALID_IP), port), boost::bind( &PingerImpl::GetPortStateCallback, this, ba::placeholders::error, port, socket, timer ) ); timer->expires_from_now(boost::posix_time::seconds(1)); timer->async_wait(boost::bind(&PingerImpl::CancelConnect, this, socket)); } return state; } void GetPortStateCallback(const boost::system::error_code& e, const Ports::value_type port, const SocketPtr, const TimerPtr) { boost::recursive_mutex::scoped_lock lock(m_PortsMutex); m_EnabledPorts[port] = e ? PortState::Enabled : PortState::Disabled; } void CancelConnect(const SocketPtr socket) { boost::system::error_code e; socket->close(e); }

पिंग प्रक्रिया में, आपको अक्सर होस्ट का नेटवर्क नाम प्राप्त करना पड़ता है, लेकिन दुर्भाग्य से, getnameinfo का अतुल्यकालिक संस्करण इस तरह से गायब है।

Boost.Asio में, अतुल्यकालिक नाम अधिग्रहण एक पृष्ठभूमि थ्रेड में होता है जो बढ़ावा देने के लिए बाध्य है :: asio :: io_service ऑब्जेक्ट । इस प्रकार, नाम प्राप्त करने के लिए पृष्ठभूमि संचालन की संख्या को बढ़ावा देने की संख्या के बराबर है :: asio_io_service ऑब्जेक्ट । सामान्य रूप से नाम और पिंग प्राप्त करने की गति बढ़ाने के लिए, हम बढ़ावा देते हैं :: asio :: io_service पूल में थ्रेड्स की संख्या के अनुसार ऑब्जेक्ट्स , और प्रत्येक पिंग ऑपरेशन को अपनी वस्तु द्वारा संसाधित किया जाता है।

पिंग ऑपरेशन कार्यान्वयन

ICMP पिंग

सब कुछ काफी सरल है: कच्चे सॉकेट का उपयोग किया जाता है। Boost.org से उदाहरणों के कार्यान्वयन के आधार पर। कोड काफी सरल है और किसी विशेष स्पष्टीकरण की आवश्यकता नहीं है।

टीसीपी पिंग

यह श्रेणी में प्रत्येक पोर्ट के लिए एक दूरस्थ होस्ट के साथ एक टीसीपी कनेक्शन स्थापित करने का एक प्रयास है। यदि दूरस्थ होस्ट के कम से कम एक पोर्ट से कनेक्ट करने का प्रयास सफल है, तो होस्ट को उपलब्ध माना जाता है। यदि किसी पोर्ट के साथ कनेक्शन स्थापित करना संभव नहीं था, तो एसिंक्रोनस संचालन की संख्या शून्य के बराबर हो जाती है और पिंग ऑब्जेक्ट नष्ट हो जाता है। इस मामले में, पिंग डिस्ट्रक्टर में पिंग परिणाम को ध्यान में रखते हुए कॉलबैक किया जाता है।

पिंग ऑपरेशन ऑब्जेक्ट तब तक मौजूद रहता है जब तक कि कम से कम एक अतुल्यकालिक ऑपरेशन किया जाता है, क्योंकि उनमें से प्रत्येक के लिए share_from_this () पॉइंटर को पास किया जाता है।

टीसीपी पिंग प्रक्रिया शुरू करने वाला कोड:

 virtual void StartTCPPing(std::size_t timeout) override { boost::mutex::scoped_lock lock(m_DataMutex); if (PingerLogic::IsCompleted() || m_Ports2Ping.empty()) return; Ports::const_iterator it = m_Ports2Ping.begin(); const Ports::const_iterator itEnd = m_Ports2Ping.end(); for (; it != itEnd; ) { const PortState::Enum state = m_Owner.GetPortState(*it); //      —  if (state == PortState::Disabled) { it = m_Ports2Ping.erase(it); continue; } else if (state == PortState::Pending) //  ,      { ++it; continue; } if (m_Owner.CanAddSocket()) // ,        { PingPort(*it); it = m_Ports2Ping.erase(it); if (m_Ports2Ping.empty()) break; } else { break; } } if (!m_Ports2Ping.empty()) { //   ,     m_RestartPingTimer.expires_from_now(boost::posix_time::milliseconds(DELAY_IF_MAX_SOCKETS_REACHED)); m_RestartPingTimer.async_wait(boost::bind( &Ping::StartTCPPing, shared_from_this(), timeout )); } //           m_StartTime = boost::posix_time::microsec_clock().local_time(); m_PingTimer.expires_from_now(boost::posix_time::seconds(timeout)); m_PingTimer.async_wait(boost::bind(&Ping::OnTimeout, shared_from_this(), ba::placeholders::error, timeout)); }

एक अतुल्यकालिक कनेक्शन शुरू करने वाला कोड:

 void PingPort(const Ports::value_type port) { const Tcp::endpoint ep(m_Address, port); const SocketPtr socket(new TCPSocket(m_Owner.GetService(m_ServiceIndex))); m_Sockets.push_back(socket); m_Owner.OnSocketCreated(); //     socket->async_connect(ep, boost::bind( &Ping::TCPConnectCallback, shared_from_this(), boost::asio::placeholders::error, socket )); }

कॉलबैक:

 void TCPConnectCallback(const boost::system::error_code& e, const SocketPtr socket) { m_Owner.OnSocketClosed(); //     if (!e) TCPPingSucceeded(socket); else TCPPingFailed(socket); }

प्रासंगिक हैंडलर:

 void TCPPingSucceeded(const SocketPtr socket) { const boost::posix_time::time_duration td(boost::posix_time::microsec_clock::local_time() - m_StartTime); boost::system::error_code error; socket->shutdown(TCPSocket::shutdown_both, error); // pinged successfully, close all opened sockets boost::mutex::scoped_lock lock(m_DataMutex); CloseSockets(); PingerLogic::OnTcpSucceeded(static_cast<std::size_t>(td.total_milliseconds())); } void TCPPingFailed(const SocketPtr socket) { // ping on this port fails, close this socket boost::system::error_code error; socket->close(error); boost::mutex::scoped_lock lock(m_DataMutex); const std::vector<SocketPtr>::const_iterator it = std::remove( m_Sockets.begin(), m_Sockets.end(), socket ); m_Sockets.erase(it, m_Sockets.end()); if (m_Sockets.empty()) m_PingTimer.cancel(); // all ports failed, cancel timer }

नाम हल करना

बूस्ट रिज़ॉल्वर, पास किए गए तर्क के प्रकार पर निर्भर करता है, फ़ंक्शंस प्राप्त करता है getaddrinfo या getnameinfo (क्रमशः पहला और दूसरा कोड उदाहरण, नीचे)।

 virtual void StartResolveIpByName(const std::string& name) override { const typename Resolver::query query(Tcp::v4(), name, ""); m_Resolver.async_resolve(query, boost::bind( &Ping::ResolveIpCallback, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::iterator )); } virtual void StartResolveNameByIp(unsigned long ip) override { const Tcp::endpoint ep(Address(ip), 0); m_Resolver.async_resolve(ep, boost::bind( &Ping::ResolveFQDNCallback, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::iterator )); }

पहला कोड उदाहरण आईपी एड्रेस प्राप्त करने के लिए उपयोग किया जाता है; इसी कोड का उपयोग NetBIOS नाम को सत्यापित करने के लिए किया जाता है। दूसरे उदाहरण से कोड का उपयोग नोड के FQDN को प्राप्त करने के लिए किया जाता है यदि इसका आईपी पहले से ही ज्ञात है।

अदरक का तर्क

दरअसल, यह एक अलग अमूर्तन में बनाया गया है। और हमारे पास इसके कई कारण हैं।

अदरक तर्क से सॉकेट संचालन को अलग करना आवश्यक है।
भविष्य में पिंजर के काम के दौरान कई रणनीतियों का उपयोग करने की संभावना पर विचार करना आवश्यक है।
यूनिट के साथ कवर करने के लिए शर्तों का कार्यान्वयन एक अलग इकाई के रूप में अदरक के संचालन के पूरे तर्क का परीक्षण करता है।

वह वर्ग जो पिंग ऑपरेशन को कार्यान्वित करता है, उस वर्ग से विरासत में मिला है जो तर्क को लागू करता है:

 class Ping : public boost::enable_shared_from_this<Ping>, public PingerLogic

उसी समय, पिंग वर्ग में संबंधित आभासी तरीकों को फिर से परिभाषित किया जाता है:

 //! Init ports virtual void InitPorts(const std::string& ports) = 0; //! Resolve ip virtual bool ResolveIP(const std::string& name) = 0; //! Start resolve callback virtual void StartResolveNameByIp(unsigned long ip) = 0; //! Start resolve callback virtual void StartResolveIpByName(const std::string& name) = 0; //! Start TCP ping callback virtual void StartTCPPing(std::size_t timeout) = 0; //! Start ICMP ping virtual void StartICMPPing(std::size_t timeout) = 0; //! Start get NetBios name virtual void StartGetNetBiosName(const std::string& name) = 0; //! Cancel all pending operations virtual void Cancel() = 0;

हम PingerLogic वर्ग के कार्यान्वयन का विस्तार से वर्णन नहीं करेंगे, हम केवल कोड उदाहरण देंगे जो खुद के लिए बोलते हैं।

 //! On ping start void OnStart() { InitPorts(m_Request.m_Ports); const bool ipResolved = ResolveIP(m_Request.m_HostName); if (!ipResolved) StartResolveIpByName(m_Request.m_HostName); } //! On ip resolved void OnIpResolved(const unsigned long ip) { boost::recursive_mutex::scoped_lock lock(m_Mutex); m_Result.m_ResolvedIP = ip; if (m_Request.m_Flags & SCANMGR_PING_RESOLVE_HOSTNAME) { m_HasPendingResolve = true; StartResolveNameByIp(ip); } if (m_Request.m_Flags & SCANMGR_PING_ICMP) { // if tcp ping needed it will be invoked after icmp completes StartICMPPing(m_Request.m_TimeoutSec); return; } if (m_Request.m_Flags & SCANMGR_PING_TCP) { // in case of tcp ping only StartTCPPing(m_Request.m_TimeoutSec); } }

आज के लिए बस इतना ही। आपका ध्यान के लिए धन्यवाद! अगले लेख में हम नेटवर्क पिंग प्रक्रिया के कवरेज और हमारे पिंज यूनिट परीक्षण के तर्क के बारे में बात करेंगे। देखते रहो।

सर्गेई कर्णखोव, वरिष्ठ प्रोग्रामर, पॉजिटिव टेक्नोलॉजीज ( सीएलआरएन ) द्वारा पोस्ट किया गया।

Boost.Asio का उपयोग करते हुए अतुल्यकालिक पिंग