टाइम आउट होने वाला कनेक्शन आपको लगभग कुछ नहीं बताता। हो सकता है दूसरी तरफ़ कुछ सुन ही न रहा हो, हो सकता है तीन हॉप दूर कोई फ़ायरवॉल चुपचाप आपका SYN गिरा रहा हो और एक लॉग लाइन तक न बना रहा हो, या हो सकता है रूट ही मौजूद न हो। आप जहाँ बैठे हैं, वहाँ से ये सब एक जैसे दिखते हैं। आप इंतज़ार करते हैं। कुछ नहीं होता।

तो टिकट लिखा जाता है “पोर्ट 445 कहीं ब्लॉक है”, और यही “कहीं” उसे उछालता रहता है। आपका प्रोवाइडर अपना एज जाँचता है, साफ़ पाता है, और वापस भेज देता है। आप अपने होस्ट का फ़ायरवॉल जाँचते हैं, साफ़ पाते हैं, और वापस भेज देते हैं। एक हफ़्ता निकल जाता है। कुछ ठीक नहीं होता।

नुक़सान करने वाला शब्द “कहीं” है। उसका वहाँ होना ज़रूरी नहीं। आपके और मंज़िल के बीच हर राउटर पर यह बताने की ज़िम्मेदारी है कि गड़बड़ वही है, और यह ज़िम्मेदारी 1995 से स्टैंडर्ड में लिखी हुई है। बस सही तरीक़े से पूछना आना चाहिए।

यह सब लिखकर समझाने की ज़रूरत क्यों है

क्योंकि इस इंडस्ट्री में बहुत सारे लोग बुनियादी काम नहीं कर पाते, और इसकी क़ीमत उनके एम्प्लॉयर हर हफ़्ते असली पैसे में चुकाते हैं।

मेरा मतलब जूनियर से नहीं है। मेरा मतलब उन लोगों से है जिनके पीछे सालों का अनुभव है, दीवार पर सर्टिफ़िकेशन टँगे हैं और जॉब टाइटल में सीनियर लिखा है, और जिनका टाइम आउट हुए पोर्ट का डायग्नोसिस “ब्लॉक है” पर रुक जाता है और आगे नहीं जाता। वे ping चलाते हैं। वह फ़ेल होता है, या चल जाता है, और दोनों ही सूरत में उन्होंने उस पोर्ट के बारे में कुछ नहीं सीखा जिसके बारे में पूछा गया था। फिर टिकट प्रोवाइडर के पास जाता है, प्रोवाइडर उसे लौटा देता है, और किसी की दो हफ़्ते की तनख़्वाह एक ऐसे थ्रेड में चली जाती है जो एक कमांड हो सकता था।

इसमें कुछ भी मुश्किल नहीं है। ड्रॉप और रिजेक्ट में फ़र्क़ करना, जवाब पर TTL पढ़ना, यह जानना कि traceroute में एक स्टार अपने आप में कुछ नहीं बताता: यह एक दोपहर में सीखा जाता है और पूरे करियर काम आता है। लोग इसे इसलिए नहीं जानते क्योंकि वे मंदबुद्धि हैं, ऐसा नहीं है। वजह यह है कि कोई इसे सिखाता ही नहीं। वेंडर ट्रेनिंग आपको वेंडर का कंसोल सिखाती है। सर्टिफ़िकेशन आपको परीक्षा सिखाते हैं। नीचे की बुनियाद को पहले दिन से मान लिया जाता है और असल में कभी पढ़ाया नहीं जाता, तो लोग बिना कभी दिखाए गए सीनियर रोल तक पहुँच जाते हैं, और तब तक पूछने में शर्म आती है।

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

और यह भी कि मैंने यह मेहनत क्यों की: इसे लिखते हुए मैंने इसे अपनी लाइन पर चलाया और तीन ऐसी ख़राबियाँ मिलीं जिनका मुझे पता नहीं था। ग्यारह हॉप दूर एक SMB ड्रॉप। एक हॉप दूर नक़ली SMTP रीसेट। एक फ़ायरवॉल नियम जो IPv4 पर है और IPv6 पर नहीं। एक दोपहर, बिना root के, एक ऐसी लाइन पर जिसकी देखभाल मैं ख़ुद करता हूँ और जिस पर ध्यान देता हूँ। ज़रा सोचिए कि उन नेटवर्क पर क्या-क्या बिना देखे पड़ा है जिन्हें चलाने के लिए किसी को पैसे मिलते हैं।

Fisher-Price OS (Windows) इसमें क्यों नहीं है

इसके यहाँ न होने के दो कारण हैं। एक तकनीकी है और एक नहीं, और मैं यह दिखावा करने के बजाय कि सब इंजीनियरिंग है, आपको दोनों बताना पसंद करूँगा।

तकनीकी कारण यह है कि वह यह कर ही नहीं सकता। tracert ICMP echo request भेजता है और कुछ नहीं। Microsoft का अपना रेफ़रेंस इसे बताता है “sending Internet Control Message Protocol (ICMP) echo Request or ICMPv6 messages to the destination with incrementally increasing time to live (TTL) field values”, और इसके सिंटैक्स में कहीं भी पोर्ट का पैरामीटर नहीं है। pathping वही टूल है जिस पर आँकड़े जोड़ दिए गए हैं। Test-NetConnection आपको बता देगा कि कोई TCP पोर्ट खुला है या बंद, और इस बारे में बिल्कुल कुछ नहीं कि जवाब कितनी दूर से आया। इनमें से कोई भी उस पोर्ट को किसी चुनी हुई दूरी पर प्रोब नहीं कर सकता जिसकी आपको सच में परवाह है, और इस पोस्ट का पूरा तरीक़ा यही है।

स्क्रिप्ट लिखकर भी आप इससे बच नहीं सकते। .NET में सॉकेट पर TTL सेट करना काफ़ी आसान है, लेकिन ICMP एरर को वापस पढ़ना मुश्किल वाला हिस्सा है, और उस ट्रिक का कोई बराबर नहीं है जिस पर यह पोस्ट टिकी है: ऐसा कोई तरीक़ा नहीं कि कर्नेल वही एरर उसी आम सॉकेट पर बताए जिसने उसे पैदा किया। बचता है raw सॉकेट, और Microsoft का अपना डॉक्यूमेंटेशन कहता है “only members of the Administrators group can create sockets of type SOCK_RAW”। तो बिना विशेषाधिकार वाला रास्ता मौजूद ही नहीं है, और विशेषाधिकार वाले को लोकल एडमिन टोकन चाहिए। शुरू करने से पहले ही आप थर्ड-पार्टी डाउनलोड में पहुँच चुके हैं।

दूसरा कारण यह है कि मुझे परवाह नहीं है, और मैं इसे सजाने के बजाय सीधे कहना पसंद करूँगा। यह नाम भी कोई सस्ता तंज़ नहीं है, यह एक वर्णन है। यह वह OS है जो आपको तब थमाया जाता है जब आपके पास कभी कोई दूसरा नहीं रहा, यह मशीन को आपसे छिपाता है और यह एक डिज़ाइन का लक्ष्य है, कोई दुर्घटना नहीं, और जिस पल आप नेटवर्क से कोई सटीक सवाल पूछना चाहते हैं, पता चलता है कि वह टूल कभी बना ही नहीं, क्योंकि जिन लोगों के लिए इसे बनाया गया है उनसे कभी पूछने की उम्मीद ही नहीं की गई। तीस साल बाद भी tracert किसी पैकेट को किसी पोर्ट पर निशाना नहीं बना सकता।

यह असली IT लोगों के लिए एक ढंग का ऑपरेटिंग सिस्टम नहीं है, और अगर आपने कभी सिर्फ़ यही इस्तेमाल किया है तो आप यह काम उस स्तर पर नहीं कर रहे जिसके लिए यह पोस्ट लिखी गई है। मुझे पता है कि यह बुरा लगता है। मैं पसंद किए जाने के लिए नहीं लिख रहा, मैं वह लिख रहा हूँ जो मैं मापता हूँ, उन लोगों के लिए जो चीज़ें मापते हैं, और मुझे ख़ास परवाह नहीं कि जिसने कभी सिर्फ़ यही चलाया है वह चाहता है कि मैं इसे किसी और तरह कहूँ।

तर्क टूलों की सूची है, राय नहीं। नीचे टेबल का हर Unix आपको हॉप लिमिट सेट करने और प्रोटोकॉल चुनने देगा, उनमें से चार एक ही कमांड से, और Linux पूरा माप sudo के बिना भी कर लेगा। ऐसा इसलिए नहीं कि उन्हें इस्तेमाल करना ज़्यादा मुश्किल है। ऐसा इसलिए है कि उन्हें ऐसे लोगों ने बनाया जिन्हें उम्मीद थी कि कीबोर्ड पर बैठा इंसान चीज़ें जानना चाहेगा। जिस ऑपरेटिंग सिस्टम का डायग्नोस्टिक ping पर ख़त्म हो जाता है, उसने साफ़ बता दिया है कि वह इस्तेमाल करने वाले के बारे में क्या सोचता है, और तीस साल तक लोगों का इसे मान लेना ही वह वजह है कि हम एक ऐसी इंडस्ट्री पर पहुँचे हैं जो एक गिरा हुआ पैकेट नहीं ढूँढ सकती।

तो मैं इसे नहीं चलाता, सालों से गंभीर काम के लिए नहीं चलाया, और एक असली कमी के बारे में निष्पक्ष दिखने के लिए मैं इसका अलग सेक्शन नहीं लिखने वाला। जिस पर भी मैं बनाता हूँ और जहाँ से भी मापने लायक़ कुछ है, वह Unix है, और यह पोस्ट वहीं रहती है।

अगर ख़राब बॉक्स संयोग से Fisher-Price OS (Windows) चला रहा है, तो इससे तरीक़े में कुछ नहीं बदलता। किसी और चीज़ पर शेल लीजिए, कोई Linux VM, कोई Mac, उसी स्विच पर कोई Raspberry Pi, और हॉप लिमिट को उसकी तरफ़ बढ़ाइए। माप को ज़रा भी परवाह नहीं कि दूसरी तरफ़ क्या चल रहा है। उसे सिर्फ़ इसकी परवाह है कि बीच में क्या है।

TTL एक हॉप बजट है, और हर राउटर आपको रसीद देने का कर्ज़दार है

IPv4 हेडर में 8-बिट का Time to Live फ़ील्ड होता है। यह नाम एक बचा हुआ अवशेष है: इसे सेकंड में तय किया गया था, और दशकों से कोई इसे सेकंड नहीं मानता। RFC 1812 ने 1995 में यह बहस ख़त्म कर दी और हॉप-काउंट वाले अर्थ को अनिवार्य बना दिया:

Each router (or other module) that handles a packet MUST decrement the TTL by at least one, even if the elapsed time was much less than a second. Since this is very often the case, the TTL is effectively a hop count limit on how far a datagram can propagate through the Internet.

फिर वह हिस्सा जो यहाँ मायने रखता है, उसी सेक्शन से:

If the TTL is reduced to zero (or less), the packet MUST be discarded, and if the destination is not a multicast address the router MUST send an ICMP Time Exceeded message, Code 0 (TTL Exceeded in Transit) message to the source.

यह MUST है। कोई शिष्टाचार नहीं, कोई सुझाव नहीं। 1981 में RFC 792 ने सिर्फ़ इतना कहा था कि गेटवे “may also notify the source host”; तेरह साल बाद यह शर्त सख़्त की गई, और RFC 1812 साफ़ शब्दों में बताता है क्यों:

ICMP Time Exceeded messages are required because the traceroute diagnostic tool depends on them.

IPv6 ने यह दिखावा छोड़ दिया और फ़ील्ड का नाम बदल दिया। RFC 8200 इसे Hop Limit कहता है, “8-bit unsigned integer. Decremented by 1 by each node that forwards the packet”, और ख़त्म होने का मैसेज ICMPv6 टाइप 3, कोड 0 बन गया, “hop limit exceeded in transit”।

इसे नियम की बजाय एक औज़ार की तरह पढ़िए तो यह कुछ काम की बात कहता है। रास्ते का हर राउटर एक बीकन है जिसे आप दूरी से पुकार सकते हैं। हॉप लिमिट 4 रखिए और चौथा राउटर अपनी पहचान बता देगा। आपको टोपोलॉजी जानने की ज़रूरत नहीं, किसी चीज़ तक एक्सेस की ज़रूरत नहीं, और ऑपरेटर के सहयोग की ज़रूरत नहीं। आपको हर हॉप पर एक पैकेट चाहिए।

Traceroute 1980 के दशक के आख़िर से ठीक यही करता आया है। जो चीज़ उसका ठीक से न कर पाना है, वही असल में आपकी परवाह की चीज़ है, क्योंकि डिफ़ॉल्ट रूप से वह 33434 रेंज के ऊपर के UDP पोर्ट प्रोब करता है, जिसे न कोई फ़िल्टर करता है और न कोई सर्व करता है, तो वह आपको एक ऐसे रास्ते के बारे में बताता है जिसे कोई असली चीज़ कभी इस्तेमाल नहीं करती। किसी ऐसे होस्ट तक साफ़ traceroute, जिस तक आप TCP/445 पर नहीं पहुँच सकते, सिर्फ़ यह साबित करता है कि UDP/33434 वहाँ पहुँचता है। सवाल यह कभी था ही नहीं।

तो उस पोर्ट को प्रोब कीजिए जिसकी आपको परवाह है।

जो वापस आया उसे पढ़िए, न कि यह कि कुछ वापस आया या नहीं

हॉप गिनने से पहले देखिए कि जब आप सामान्य हॉप लिमिट के साथ दूसरी तरफ़ पहुँचते हैं तो वह क्या करता है। पाँच अलग-अलग जवाब होते हैं और लोग अक्सर उन्हें एक में मिला देते हैं।

क्या वापस आता हैइसका मतलबकिसने भेजा
SYN-ACK, कनेक्शन खुल जाता हैपोर्ट खुला हैहोस्ट, या उसकी तरफ़ से जवाब देने वाला कोई
TCP RSTसक्रिय रूप से मना कियावह होस्ट जिस पर कुछ नहीं सुन रहा, या रिजेक्ट के लिए कॉन्फ़िगर किया गया कोई डिवाइस
ICMP 3/13, communication administratively prohibitedकोई डिवाइस पॉलिसी के आधार पर मना कर रहा है और बता भी रहा हैवही डिवाइस: उसका सोर्स एड्रेस ही आपका जवाब है
ICMP 3/1, 3/2, 3/3host, protocol या port unreachableआख़िरी राउटर, या होस्ट
कुछ भी नहींकोई चुपचाप ड्रॉप कर रहा हैपता नहीं, तो जाकर मापिए

तीसरी पंक्ति वह है जिसके लिए अपनी आदतें बदलना फ़ायदेमंद है। जब कोई फ़ायरवॉल ड्रॉप के बजाय रिजेक्ट के लिए कॉन्फ़िगर होता है, तो वह ICMP के सोर्स फ़ील्ड में अपना एड्रेस डालता है और दोषी आपको मुफ़्त में थमा देता है। Linux पर nft ... reject with icmpx admin-prohibited यही बनाता है, और iptables -j REJECT --reject-with icmp-admin-prohibited हमेशा से यही बनाता आया है। ज़्यादातर टूल इसे फेंक देते हैं और “filtered” छाप देते हैं। nmap --reason इसे दिखाएगा। नीचे वाली स्क्रिप्ट भी।

पंक्ति दो और पाँच दिलचस्प विफलताएँ हैं। चुपचाप ड्रॉप करना आपको कुछ न बताने का एक पॉलिसी फ़ैसला है, और चूँकि लगभग हर कमर्शियल फ़ायरवॉल पर यही डिफ़ॉल्ट है, इसलिए असल में आपका सामना इसी से होगा। ख़ामोशी की उम्मीद रखिए।

पंक्ति दो पर भी शक होना चाहिए। रीसेट इस बात का सबूत नहीं कि उसे होस्ट ने भेजा, और मैं एक असली उदाहरण के साथ इस पर लौटूँगा, क्योंकि यह लिखते हुए मुझे अपनी ही लाइन पर ऐसा एक मिला।

जिस पोर्ट की परवाह है उसे दो बार चलकर देखिए

तरीक़ा है दो रन और एक diff। बस इतना ही।

  1. हॉप लिमिट को 1 से 20 तक बढ़ाइए, ठीक उसी प्रोटोकॉल और पोर्ट से जो फ़ेल हो रहा है, और लिखिए कि हर हॉप पर कौन सा राउटर जवाब देता है।
  2. यही काम किसी ऐसी चीज़ से कीजिए जो चलती है, बेहतर हो कि वही होस्ट और एक ऐसा पोर्ट जो खुलता है।
  3. जिस हॉप पर पहले रन में जवाब रुक जाते हैं, और दूसरे रन में चलते रहते हैं, वही डिवाइस आपको ड्रॉप कर रहा है। दूसरा रन आपको उसका एड्रेस देता है।

जवाब बदलने के बजाय रुकते क्यों हैं: राउटर पैकेट के साथ कुछ और करने से पहले अपनी इनबाउंड एक्सेस लिस्ट लगाता है, तो अगर पॉलिसी ड्रॉप कहती है तो फ़ॉरवर्डिंग पाथ के हॉप लिमिट देखने से पहले ही पैकेट ग़ायब हो जाता है, कोई Time Exceeded नहीं बनता, और डिवाइस अपने किए पर कभी अपना नाम नहीं लिखता। इसलिए ख़ामोशी गड़बड़ वाले हॉप पर शुरू होती है, उसके बाद नहीं।

इस चलने के लिए मैंने एक छोटा टूल लिखा, क्योंकि कोई भी नेटिव टूल इसे हर प्लेटफ़ॉर्म पर नहीं करता। यह एक आम सॉकेट पर IP_TTL (या IPV6_UNICAST_HOPS) सेट करता है, कनेक्ट करता है, और ICMP एरर वापस पढ़ता है। Linux पर IP_RECVERR वह एरर उसी सॉकेट पर बताता है जिसने उसे पैदा किया, जिसका मतलब है पूरी चीज़ बिना विशेषाधिकार के चलती है: न root, न raw सॉकेट, न capabilities। macOS, BSD और Solaris पर कर्नेल आपको ICMP इस तरह नहीं देता, तो यह raw सॉकेट पर वापस जाता है और इसे root चाहिए।

hopfind.py: TTL वॉकर hopfind.py · 11 kB

यह सिर्फ़ स्टैंडर्ड लाइब्रेरी की 279 लाइनें हैं, और कुछ नहीं, और अगर आप डाउनलोड करने के बजाय पढ़ना चाहें तो पूरी इस पोस्ट के आख़िर में छपी है।

python3 hopfind.py example.net 445      # the port under suspicion
python3 hopfind.py example.net 443      # the reference run
python3 hopfind.py example.net 53 --proto udp
python3 hopfind.py 2001:db8::1 443 -6

दोनों रन के लिए एक ही प्रोटोकॉल इस्तेमाल कीजिए। TCP ट्रेल की तुलना ICMP ट्रेल से करना दो रास्तों की तुलना करना है, क्योंकि लोड बैलेंसिंग five-tuple पर हैश करती है और ICMP में हैश करने के लिए पोर्ट होते ही नहीं। वही होस्ट, वही प्रोटोकॉल, अलग पोर्ट: यही ईमानदार तुलना है।

नीचे सब कुछ 28 अगस्त 2026 को मेरी अपनी लाइन का असली आउटपुट है, Fedora पर बिना विशेषाधिकार वाले यूज़र के रूप में चलाया गया। इसमें हर एड्रेस को डॉक्यूमेंटेशन रेंज में बदल दिया गया है: IPv4 के लिए RFC 5737, IPv6 के लिए RFC 3849, और एक इंटरफ़ेस आइडेंटिफ़ायर भी बदला गया है। तो 198.51.100.x मेरा अपना राउटर और मेरा ISP है, 203.0.113.x ट्रांज़िट और पीयरिंग है, 192.0.2.x दूर वाला नेटवर्क है, और 2001:db8::/32 पूरा IPv6 रास्ता है। ढाँचा हर जगह वैसा ही रखा गया है: वही प्रीफ़िक्स सीमाएँ, होस्ट-पार्ट का वही आकार, अलग-अलग नेटवर्क की वही गिनती। हॉप नंबर, टाइमिंग, ICMP टाइप और कौन सा हॉप चुप हुआ, ये सब बिल्कुल वैसे ही हैं जैसे मापे गए।

एक होस्ट, तीन पोर्ट, तीन अलग ख़राबियाँ

पूरे समय वही मंज़िल: पब्लिक इंटरनेट पर एक होस्ट, चौदह हॉप दूर, जिस पर 443 खुला है। पहले रेफ़रेंस रन।

$ python3 hopfind.py 192.0.2.4 443 --max 15
walking to 192.0.2.4  TCP/443  hop limit 1-15
  1  198.51.100.254                              0.3 ms  ICMP 11/0 time exceeded in-transit
  2  198.51.100.133                             28.8 ms  ICMP 11/0 time exceeded in-transit
  3  *
  4  198.51.100.153                              6.3 ms  ICMP 11/0 time exceeded in-transit
  5  *
  6  203.0.113.240                              16.5 ms  ICMP 11/0 time exceeded in-transit
  7  203.0.113.188                              16.5 ms  ICMP 11/0 time exceeded in-transit
  8  203.0.113.185                              16.5 ms  ICMP 11/0 time exceeded in-transit
  9  203.0.113.15                               15.6 ms  ICMP 11/0 time exceeded in-transit
 10  203.0.113.125                              16.1 ms  ICMP 11/0 time exceeded in-transit
 11  192.0.2.31                                 26.6 ms  ICMP 11/0 time exceeded in-transit
 12  *
 13  *
 14  192.0.2.4                                  19.5 ms  connected

Verdict: TCP/443 is open. It answered at hop 14.

हॉप 3, 5, 12 और 13 पर ध्यान दीजिए। एक ऐसे रास्ते पर जो साफ़ तौर पर चलता है, चार राउटर कुछ नहीं बोले, क्योंकि बहुत सी किट अपने लिए ICMP न बनाने के लिए कॉन्फ़िगर होती है, या उसे सख़्ती से रेट-लिमिट करती है। स्टार फ़ायरवॉल का सबूत नहीं है। और कुछ न भी याद रहे तो यह याद रखिए। संकेत कभी भी एक रन में स्टार का होना नहीं है; संकेत वह जगह है जहाँ दो रन असहमत होने लगते हैं।

अब उसी होस्ट पर 445, जो यहाँ से टाइम आउट होता है।

$ python3 hopfind.py 192.0.2.4 445 --max 15
walking to 192.0.2.4  TCP/445  hop limit 1-15
  1  198.51.100.254                              0.3 ms  ICMP 11/0 time exceeded in-transit
  2  198.51.100.133                              8.0 ms  ICMP 11/0 time exceeded in-transit
  3  *
  4  198.51.100.153                              6.4 ms  ICMP 11/0 time exceeded in-transit
  5  203.0.113.76                                5.6 ms  ICMP 11/0 time exceeded in-transit
  6  203.0.113.240                              15.9 ms  ICMP 11/0 time exceeded in-transit
  7  203.0.113.188                              15.8 ms  ICMP 11/0 time exceeded in-transit
  8  203.0.113.185                              16.6 ms  ICMP 11/0 time exceeded in-transit
  9  203.0.113.15                               15.9 ms  ICMP 11/0 time exceeded in-transit
 10  203.0.113.125                              15.0 ms  ICMP 11/0 time exceeded in-transit
 11  *
 12  *
 13  *
 14  *
 15  *

Verdict: answers stop after hop 10 (203.0.113.125).
         Whatever swallows TCP/445 is hop 11.
         Walk a port that works and read off the address at hop 11.

हॉप 11 ने 443 वाले रन को 26.6 ms में जवाब दिया और 445 वाले रन को बिल्कुल कुछ नहीं कहा। वही बॉक्स, वही रास्ता, उसके आगे वही दस राउटर। जो रन चलता है उससे मिलाइए और हॉप 11 का एक नाम है: 192.0.2.31। यही डिवाइस SMB ड्रॉप कर रहा है, मंज़िल से तीन हॉप पहले और मेरे प्रोवाइडर के एज से आठ हॉप आगे। न मेरा, न मेरे ISP का।

हॉप 5 स्टार वाली बात को दूसरी तरफ़ से साबित करता है। 443 वाले रन पर वह स्टार था और 445 वाले रन पर उसने जवाब दिया: ख़राबी से बिल्कुल उल्टा। यह ICMP रेट लिमिटिंग हो सकती है, या यह भी कि दोनों रन किसी लोड बैलेंसर से अलग-अलग रास्तों से गए। मुझे नहीं पता कौन सा, और आपको भी नहीं पता चलेगा। किसी पर भी भरोसा करने से पहले दोनों रन दोहराइए।

एक ही होस्ट तक हॉप लिमिट के दो वॉक, और वह हॉप जहाँ वे असहमत होने लगते हैंएक ही होस्ट तक दो वॉक, और वह हॉप जहाँ वे असहमत होने लगते हैंहर हॉप लिमिट पर एक प्रोब। रंगा हुआ ख़ाना मतलब उस राउटर ने ICMP Time Exceeded लौटाया और अपना नाम बताया।राउटर ने जवाब दियाकुछ नहीं लौटायहाँ से आगे चुप1234567891011121314प्रोब पर सेट हॉप लिमिटTCP/443रेफ़रेंस, खुलता है••*•*••••••**✓खुलता हैTCP/445जाँच में, टाइम आउट••*•••••••****हॉप 11 ने एक वॉक को जवाब दिया, दूसरे को नहींहॉप 3, 5, 12 और 13 एक साफ़ चलते रास्ते पर कुछ नहीं बोले, तो अकेला स्टार कुछ नहीं बताता।हॉप 11 ने रेफ़रेंस वॉक को 26.6 ms में जवाब दिया और टेस्ट वॉक को कभी नहीं।यही सीमा है, और रेफ़रेंस वॉक इसे एक एड्रेस देता है: 192.0.2.31।
वही दो रन, आमने-सामने। सिर्फ़ हॉप 11 वाला ख़ाना मायने रखता है, और उसके बारे में मायने रखने वाली बात असहमति है: उसने एक रन को जवाब दिया और दूसरे को नहीं।

फिर पोर्ट 25। इसने मुझे रोक दिया।

$ python3 hopfind.py 192.0.2.4 25 --max 15
walking to 192.0.2.4  TCP/25  hop limit 1-15
  1  192.0.2.4                                   0.4 ms  TCP reset

Verdict: a reset came back to a probe with a hop limit of 1.
         Nothing more than one hop away can have sent it, so check the reply
         TTL before you believe the host did.

हॉप लिमिट 1 का मतलब है कि पैकेट मेरे अपने राउटर पर मर गया। वह एक हॉप गया। वह चौदह नहीं जा सकता था। फिर भी 0.4 ms में एक TCP रीसेट वापस आया जिस पर मंज़िल का एड्रेस था, और मेरे कर्नेल ने आज्ञाकारी ढंग से connection refused बता दिया। हॉप लिमिट सेट किए बिना मैं इसे “दूसरी तरफ़ कोई मेल सर्वर नहीं है” पढ़ता और टिकट बंद कर देता।

एक हॉप दूर कोई चीज़ आउटबाउंड SMTP के लिए रीसेट नक़ली बना रही है और उन पर मंज़िल का एड्रेस लगा रही है। आउटबाउंड 25 को ब्लॉक करना किसी कंज़्यूमर राउटर या ISP के लिए बिल्कुल आम बात है, और इसे ड्रॉप के बजाय रीसेट से करना शायद ज़्यादा शालीन तरीक़ा है, लेकिन रीसेट पर किसी और का एड्रेस है और मुझे पता ही नहीं था कि मेरा राउटर ऐसा करता है। इसे हॉप लिमिट ने पकड़ा, और जवाब में और कुछ भी इसे नहीं पकड़ता।

एक का फ़र्क़: पाइपलाइन में एक्सेस लिस्ट कहाँ बैठती है

ऊपर का फ़ैसला कहता है कि ड्रॉप करने वाला हॉप 11 है क्योंकि जवाब हॉप 10 के बाद रुक गए। इस हिसाब से सावधान रहिए, क्योंकि यह इस पर निर्भर है कि गड़बड़ वाला डिवाइस दो काम किस क्रम में करता है।

ज़्यादातर किट पहले इनबाउंड पॉलिसी लगाती है और हॉप लिमिट की जाँच बाद में। Deny लगता है, पैकेट फेंक दिया जाता है, और कोई Time Exceeded कभी नहीं बनता, तो डिवाइस कभी दिखता नहीं और ख़ामोशी उसके अपने हॉप नंबर पर शुरू होती है। ऊपर यही मामला है। यही आम मामला भी है।

कुछ प्लेटफ़ॉर्म पॉलिसी जाँचने से पहले फ़ास्ट पाथ में हॉप लिमिट का ख़त्म होना संभालते हैं। वहाँ डिवाइस अपने लिए भेजे गए प्रोब का जवाब देता है और सिर्फ़ अपने आगे जाने वाले प्रोब ड्रॉप करता है, तो वह सामान्य रूप से दिखता है और ख़ामोशी एक हॉप बाद शुरू होती है।

गड़बड़ वाला हॉप आमतौर पर क्यों नहीं दिखता: पॉलिसी हॉप लिमिट की जाँच से पहले जाँची जाती हैआपको ड्रॉप करने वाले हॉप के अंदर, दो जाँचों का क्रम तय करता है कि आप क्या देखेंगेआपका प्रोब बजट में एक हॉप बाक़ी रहते पहुँचता है, और deny वाले नियम से मेल खाता है।पहले पॉलिसी: लगभग सभी फ़ायरवॉल, और इस पोस्ट में मापा गया हर मामलाहॉप N पर राउटरप्रोब आयाइनबाउंड पॉलिसीहॉप लिमिट जाँचफ़ॉरवर्डहॉप लिमिट देखे जाने से पहले ही फेंका गयाकोई ICMP नहीं बनता, तो यह राउटर ड्रॉप पर कभी अपना नाम नहीं लिखता।आपका वॉक हॉप N पर चुप हो जाता है।पहले expiry: कुछ प्लेटफ़ॉर्म इसे फ़ास्ट पाथ में संभालते हैंहॉप N पर राउटरप्रोब आयाहॉप लिमिट जाँचइनबाउंड पॉलिसीफ़ॉरवर्डख़त्म हुआ, तो ICMP 11/0 इस राउटर के एड्रेस के साथ लौटता हैयह अपने लिए जवाब देता है और सिर्फ़ आगे जाने वाले प्रोब निगलता है।आपका वॉक हॉप N+1 से चुप हो जाता है।
ड्रॉप करने वाला हॉप आमतौर पर अदृश्य क्यों रहता है। लगभग सभी फ़ायरवॉल पर deny पहले जाँचा जाता है, तो फ़ॉरवर्डिंग पाथ के यह देखने से पहले कि हॉप लिमिट ख़त्म हो गई, प्रोब जा चुका होता है और कोई ICMP कभी नहीं बनता। जो किट फ़ास्ट पाथ में ख़त्म होना संभालती है, वहाँ वही डिवाइस अपने लिए भेजे प्रोब का जवाब देता है और सिर्फ़ आगे भेजे गए प्रोब निगलता है।

तो “जवाब हॉप N के बाद रुकते हैं” का ईमानदार अर्थ है: ड्रॉप करने वाला हॉप N+1 है अगर उसने बजट ख़त्म होने पर ध्यान देने से पहले आपका प्रोब फेंक दिया, या ख़ुद हॉप N है अगर उसने अपने लिए भेजे प्रोब का जवाब दिया और आगे भेजा गया सब कुछ निगल लिया। दो पड़ोसी डिवाइस, और जो रन चलता है वह दोनों के नाम बताता है। एड्रेस बताइए, हॉप काउंट नहीं: आपका टिकट पढ़ने वाले के लिए हॉप काउंट का कोई मतलब नहीं, क्योंकि वह कहीं और से गिन रहा है।

जवाब का TTL बताता है कि असल में किसने जवाब दिया

ऊपर का SMTP रीसेट बाहर जाते हॉप लिमिट से पकड़ा गया। वापस आने वाले हर जवाब में एक दूसरी, स्वतंत्र जाँच भी मौजूद है, और इसकी कोई क़ीमत नहीं।

शुरुआती TTL मान स्टैंडर्ड नहीं हैं, लेकिन व्यवहार में तीन होते हैं:

शुरुआतआमतौर पर भेजने वाला
64Linux, macOS, BSD, illumos, ज़्यादातर होस्ट
255Cisco IOS, Junos, Solaris, ज़्यादातर नेटवर्क किट का अपना ट्रैफ़िक
128Fisher-Price OS (Windows), जो किसी एक से आए जवाब को पढ़ने के लिए आपको अब भी जानना होगा

मिले हुए TTL को अगले ऊपरी मान से घटाइए और आपको हॉप काउंट वापस मिल जाता है। TTL 50 के साथ आया जवाब 64 से शुरू हुआ और 14 हॉप चला। TTL 250 वाला 255 से शुरू हुआ और 5 हॉप चला। ping इसे बिना पूछे छाप देता है:

ping -c1 192.0.2.4          # ttl=50 → 14 hops away
tcpdump -n -v 'icmp'        # -v prints the ttl of every packet it shows

इससे दो बातें निकलती हैं। दोनों मुफ़्त।

जिस जवाब का उल्टा हॉप काउंट होस्ट के बाक़ी जवाबों से मेल नहीं खाता, उसे होस्ट ने नहीं भेजा। अगर किसी सर्वर से echo reply 14 हॉप दूर से आता है और पोर्ट 25 पर RST 1 हॉप दूर से, तो RST किसी middlebox ने लिखा है। ऊपर वाले सेक्शन वाली ही ट्रिक, दूसरे सिरे से, और यह तब भी काम करती है जब आप आउटबाउंड TTL सेट नहीं कर सकते।

जो जवाब 255 से शुरू हुआ वह नेटवर्क किट से आया, सर्वर से नहीं। तब काम का है जब आप यह समझने की कोशिश कर रहे हों कि आपको मना करने वाली चीज़ होस्ट है या उसके आगे का राउटर।

ICMP के बजाय TCP पर यह फ़ील्ड देखने के लिए आपको कैप्चर चाहिए, और फ़िल्टर याद रखने लायक़ है:

# every hop-limit expiry coming back to you, IPv4 and IPv6
tcpdump -n -v 'icmp[icmptype] == 11 or icmp6[icmp6type] == 3'

# who is resetting you, and from how far
tcpdump -n -v 'tcp[tcpflags] & tcp-rst != 0'

tcpdump इस ख़त्म होने को ICMP time exceeded in-transit छापता है: वही वाक्यांश जो स्टैंडर्ड इस्तेमाल करते हैं, और वही घटना जो उन प्लेटफ़ॉर्म पर “TTL expired in transit” दिखती है जो इसे ऐसे लिखते हैं।

नेटिव टूलों से यही ट्रिक, पाँच Unix पर

अगर आप स्क्रिप्ट नहीं चलाना चाहते, तो नेटिव टूल इसका ज़्यादातर हिस्सा कर देंगे। बस वे आपकी उम्मीद से ज़्यादा आपस में असहमत हैं। ख़ासकर -P के तीन अलग मतलब हैं, इस पर निर्भर करते हुए कि आपके हाथ में किसका traceroute है, और उनमें से एक चुपचाप आपका टेस्ट बर्बाद कर देगा।

Linux (traceroute 2.1.x)macOS / FreeBSDOpenBSDNetBSDSolaris 11
TCP प्रोब-T-P tcpकाम का नहींनहींनहीं
ICMP प्रोब-I-I-I-I-I
तय पोर्ट पर UDP-U -p N-e -p Nनहींनहींनहीं
डेस्टिनेशन पोर्ट-p N (TCP के लिए स्थिर)-p N (-e के बिना बढ़ता है)-p N (बढ़ता है)-p N (बढ़ता है)-p N (बढ़ता है)
-P का मतलबइस्तेमाल नहींप्रोब प्रोटोकॉलसंख्या वाला प्रोटोकॉल, “will not work reliably for most protocols”DF सेट करना और पाथ MTU प्रोब करनाप्रोब के बीच ठहराव, सेकंड में
विशेषाधिकार चाहिएहाँ, -T और -I के लिएहाँहाँहाँहाँ

इनमें से हर एक को raw सॉकेट चाहिए, तो हर एक को विशेषाधिकार चाहिए, हालाँकि macOS और BSD आमतौर पर traceroute को setuid root के साथ भेजते हैं, तो शायद आपको आगे sudo न लिखना पड़े। Linux ऐसा नहीं करता, और Fedora भी नहीं, और ऊपर वाली स्क्रिप्ट के होने की आधी वजह यही है।

उस टेबल में तीन जाल हैं, और मैंने तीनों को एक दोपहर बर्बाद करते देखा है।

BSD और macOS पर, -p एक बेस पोर्ट है जो हर प्रोब के साथ बढ़ता है। तो traceroute -P tcp -p 445 host पहले 445 टेस्ट करता है, फिर 446, फिर 447, और हॉप 10 तक आप एक ऐसे पोर्ट के बारे में पूछ रहे हैं जिसका किसी ने नाम भी नहीं सुना। आपको साथ में -e भी चाहिए, जिसे man पेज firewall evasion mode कहता है और जिसका असल मतलब बस “पोर्ट को स्थिर रखो” है:

sudo traceroute -P tcp -e -p 445 example.net     # macOS, FreeBSD

Linux पर, डिफ़ॉल्ट UDP तरीक़े के लिए सादा -p भी यही करता है और स्थिर UDP पोर्ट के लिए आपको -U -p चाहिए। TCP के लिए -T -p पहले से स्थिर है: man पेज साफ़ कहता है कि “for TCP and others specifies just the (constant) destination port to connect”।

sudo traceroute -T -p 445 example.net            # Linux
sudo traceroute -U -p 53  example.net            # Linux, UDP/53 specifically

Solaris और NetBSD पर पोर्ट को पिन करने का कोई तरीक़ा ही नहीं है, और Solaris पर -P सेकंड में ठहराव है, तो Linux से कॉपी की गई कमांड लाइन बिना एरर के चलेगी और ऐसा कुछ नहीं मापेगी जो आपने पूछा था। Solaris में TCP प्रोब मोड भी नहीं है। यही वह मामला है जहाँ आपको स्क्रिप्ट चाहिए।

Redox अलग है और एक वाक्य के लायक़ है क्योंकि मुझे यह सवाल आने की उम्मीद है। उसका पूरा नेटवर्क टूलकिट netutils है: dns, ifconfig, nc, ping, telnetd, wget। न traceroute, न tcpdump, कैप्चर करने के लिए कुछ भी नहीं। अगर Redox बॉक्स समस्या का एक सिरा है, तो दूसरे सिरे से मापिए और वॉक को उसकी तरफ़ मोड़िए।

mtr का भी ज़िक्र बनता है, क्योंकि यह दोहराने और औसत निकालने वाला वह हिस्सा करता है जो ऊपर की टेबल आपसे हाथ से करवाती हैं:

sudo mtr -T -P 445 --report --report-cycles 20 example.net

इसे फ़ेल होने वाले पोर्ट पर चलाइए और फिर एक चलने वाले पर, आमने-सामने। वही तरीक़ा, सुंदर आउटपुट।

अगर कोई ICMP ब्लॉक करता है तो इसमें से कुछ नहीं चलता

इस पोस्ट का हर माप मुझ तक वापस आने वाले ICMP एरर से बना है। उन्हें ब्लॉक कीजिए और पूरा डायग्नोस्टिक अँधेरे में चला जाता है, और साथ में बहुत कुछ और भी।

ICMP को पूरी तरह ब्लॉक करना कुछ जगहों पर अब भी एक सुरक्षा रुख़ माना जाता है। 1990 के दशक के बाद से इसका बचाव नहीं किया जा सकता। जिन हमलों को रोकने की कल्पना की जाती है वे ping of death और smurf थे, दोनों स्टैक में ठीक किए गए थे, बॉर्डर पर नहीं, और दोनों उससे पहले ठीक हो गए थे जब यह सलाह दोहराने वाले कुछ इंजीनियर पैदा भी नहीं हुए थे। आज पूरी तरह ब्लॉक करने से जो रुकता है वह डायग्नोसिस है। और कुछ नहीं।

RFC 1812 इस बात पर व्याख्या की कोई गुंजाइश नहीं छोड़ता: Time Exceeded एक MUST है, और स्टैंडर्ड कहता है कि इसकी वजह यह है कि traceroute इस पर निर्भर है। इसे ड्रॉप कीजिए और आपने वह टूल तोड़ दिया जिसे इंटरनेट का अपना राउटर रिक्वायरमेंट डॉक्यूमेंट इस मैसेज के होने का कारण बताता है।

Path MTU discovery महँगा वाला है। इसे सेंडर तक ICMP 3/4, fragmentation needed, वापस आना चाहिए। उसे फ़िल्टर कीजिए और आपको वह ख़राबी मिलती है जिसके पीछे हर नेटवर्क इंजीनियर कम से कम एक बार भागा है, जिसमें हैंडशेक पूरा होता है और छोटे ट्रांसफ़र चलते हैं और पूरे साइज़ का पैकेट ले जाने वाली हर चीज़ हमेशा के लिए अटक जाती है। SSH कनेक्ट होता है और scp रुक जाता है। पेज लोड होता है और इमेज कभी नहीं आती। लॉग में कुछ नहीं। grep करने को कुछ नहीं।

IPv6 पर यह पसंद का मामला नहीं रहता। RFC 4890 §4.3.1 उन मैसेज की सूची देता है जिन्हें फ़ायरवॉल को ड्रॉप नहीं करना चाहिए:

  • Destination Unreachable (Type 1) - All codes
  • Packet Too Big (Type 2)
  • Time Exceeded (Type 3) - Code 0 only
  • Parameter Problem (Type 4) - Codes 1 and 2 only

और Packet Too Big पर वह नतीजे के बारे में साफ़ बोलता है: “Effectively, parts of the Internet will become inaccessible.” IPv6 राउटर फ़्रैगमेंट नहीं करते। अगर Packet Too Big सेंडर तक नहीं पहुँच सकता, तो उबरने का कोई रास्ता नहीं।

नियंत्रण रेट लिमिट है, ड्रॉप नहीं। इनबाउंड टाइप 3 और टाइप 11 की इजाज़त दीजिए, उन्हें गिनिए, क़रीब सौ प्रति सेकंड पर सीमा लगाइए, सीमा से ऊपर जो जाए उसे लॉग कीजिए, और आपने डायग्नोस्टिक बचा लिए, path MTU discovery चालू रखा, और वह सारी सुरक्षा भी रख ली जो पूरी तरह ब्लॉक करने वाला नियम देने की कल्पना करता था। आप किसी चीज़ को कितना स्वीकार करते हैं इसे सीमित करना एक नियंत्रण है। उसे पूरा ठुकराना और उसे हार्डनिंग कहना बस मापे जाने से इनकार करना है।

MSP चलाने वाले किसी के लिए भी: अगर आपके ग्राहक की लाइन ICMP एरर ड्रॉप करती है, तो आपने उनसे, और ख़ुद से भी, यह साबित करने की क्षमता छीन ली है कि ख़राबी किस नेटवर्क में है। अगली बार जब कोई ख़राबी दो प्रोवाइडर के बीच बैठी होगी और दोनों कहेंगे कि उनकी तरफ़ साफ़ है, तो वही इस पॉलिसी का बिल है।

Echo को छोड़कर। उसे ड्रॉप कीजिए।

ऊपर सब कुछ ICMP एरर के बारे में है। Echo एक अलग जानवर है, और यह प्रोटोकॉल का वह एक हिस्सा है जिसे मैं बॉर्डर पर वायर से हटा दूँगा।

देखिए स्टैंडर्ड इससे क्या माँगता है। IPv4 में, RFC 792 echo request के बारे में कहता है कि “the data received in the echo message must be returned in the echo reply message”। IPv6 और भी साफ़ है: RFC 4443 फ़ील्ड को “zero or more octets of arbitrary data” के रूप में परिभाषित करता है और फिर माँगता है कि उसे “MUST be returned entirely and unmodified in the ICMPv6 Echo Reply message”।

इसे ऑपरेटर की बजाय हमलावर की तरह पढ़िए। स्टैंडर्ड धरती के हर होस्ट को बाध्य करता है कि वह आपके चुने हुए बाइट्स का एक ब्लॉक स्वीकार करे और सीधे आपको वापस थमा दे। यह कोई साइड इफ़ेक्ट नहीं है। यह एक अनिवार्य, दोतरफ़ा, मनचाहे पेलोड वाला चैनल है, एक ऐसे प्रोटोकॉल पर जिसे ज़्यादातर फ़ायरवॉल बिना जाँचे जाने देते हैं और ज़्यादातर लॉगिंग कंटेंट की बजाय पैकेट गिनती के रूप में दर्ज करती है।

लोग तीस साल से इस पर टनल बना रहे हैं। Loki ने 1996 में Phrack 49 में यह किया। Ptunnel ping के अंदर पूरा TCP सेशन ले जाएगा और दो दशक से बस एक पैकेज की दूरी पर है। अगर आपकी egress पॉलिसी है “सब ब्लॉक करो, ICMP की इजाज़त दो क्योंकि नेटवर्क टीम को चाहिए”, तो आपके पास egress पॉलिसी नहीं है। आपके पास कुछ अतिरिक्त क़दमों वाला एक VPN है, और ट्रैफ़िक ऐसे निकलता है जैसे कोई जाँच रहा हो कि इंटरनेट चालू है या नहीं।

RFC 4890 मुझसे असहमत है, और सिर्फ़ अपने काम का आधा हिस्सा उद्धृत करने के बजाय इसे साफ़ कहना ठीक है। §4.3.1 Echo Request और Echo Response को एरर के साथ उसी must-not-drop सूची में रखता है। फिर वह जो कारण देता है उसे पढ़िए:

For Teredo tunneling [RFC4380] to IPv6 nodes on the site to be possible, it is essential that the connectivity checking messages are allowed through the firewall.

echo को खुला रखने का बताया गया कारण यह है कि किसी को इससे आपके फ़ायरवॉल के आर-पार एक टनल बनानी है। यही मेरा तर्क है, उल्टा पक्ष रखने वालों के हाथों लिखा हुआ।

तो पॉलिसी संकरी है, पूरी तरह नहीं:

# transit rules. permit the errors, drop the ping
ip protocol icmp icmp type { destination-unreachable, time-exceeded, parameter-problem } \
    limit rate 100/second accept
ip protocol icmp icmp type { echo-request, echo-reply } drop

ip6 nexthdr ipv6-icmp icmpv6 type { destination-unreachable, packet-too-big, \
    time-exceeded, parameter-problem } limit rate 100/second accept
ip6 nexthdr ipv6-icmp icmpv6 type { echo-request, echo-reply } drop

IPv6 पर, इस पैटर्न को neighbour discovery रखे बिना किसी link-local या होस्ट चेन पर मत ले जाइए। टाइप 133 से 137, nd-router-solicit से nd-redirect तक, वह तरीक़ा हैं जिससे IPv6 वह काम करता है जो IPv4 में ARP करता है। उन्हें ड्रॉप कीजिए और सेगमेंट कुछ ही मिनटों में काम करना बंद कर देगा, और यह फ़ायरवॉल की ख़राबी जैसा नहीं दिखेगा। Echo को बॉर्डर पर फ़िल्टर कीजिए, होस्ट और उसके अपने राउटर के बीच के वायर पर नहीं।

इसकी आपको क्या क़ीमत चुकानी पड़ती है? सीमा के पार ping, और कुछ नहीं। इस पोस्ट में सब कुछ काम करता रहता है, क्योंकि यहाँ का एक भी माप echo request नहीं भेजता। hopfind.py TCP और UDP पर चलता है और वापस आने वाले एरर पढ़ता है; traceroute -T और -U भी यही करते हैं। Path MTU discovery को Packet Too Big चाहिए, जो एक एरर है। उल्टे TTL वाली ट्रिक किसी भी जवाब पर काम करती है, और एक TCP हैंडशेक आपको एक दे देगा। आप सिर्फ़ डिब्बे का सबसे कम जानकारी देने वाला टूल खोते हैं, और यह पूरी पोस्ट इसी बारे में एक तर्क है कि ping पर रुक जाना ही असल समस्या है।

मेरी अपनी लाइन पहले से ठीक यही करती है, हालाँकि मुझे शक है कि यह जानबूझकर था। मेरे डिफ़ॉल्ट गेटवे पर ping को 100% loss मिलता है, और उसी गेटवे से ICMP Time Exceeded 0.3 ms में वापस आता है, जैसा इस पोस्ट का हर ट्रेस दिखाता है। Echo बंद, एरर खुले। जिसने भी वह फ़र्मवेयर भेजा उसने सही जवाब दिया, और मुझे इसका पता सिर्फ़ ढूँढने जाने पर चला।

वही नियम, सिर्फ़ एक बार लिखा हुआ

यह रही वह ख़राबी जो मुझे अपने ही घर में मिलने की उम्मीद नहीं थी। एक पब्लिक DNS रिज़ॉल्वर, दोनों फ़ैमिली पर TCP/443 पर चलकर देखा गया, कुछ ही मिनटों के अंतर पर।

$ python3 hopfind.py 192.0.2.53 443 --max 10
walking to 192.0.2.53  TCP/443  hop limit 1-10
  1  *
  2  *
  3  *
  4  *
  5  *
  6  *
  7  *
  8  *
  9  *
 10  *

Verdict: nothing answered at all, not even the first hop.

बिल्कुल कुछ नहीं। एक भी हॉप नहीं। मेरे अपने राउटर ने वह expiry भी नहीं बताया जो उसने ज़रूर बनाया होगा, वही expiry जो उसने इस पोस्ट के हर दूसरे वॉक के लिए 0.3 ms में बताया, तो ड्रॉप हॉप 1 पर होता है, हॉप लिमिट की जाँच चलने से पहले, और हॉप 1 मेरा है।

रास्ता ठीक है, जिसे वही मंज़िल UDP पर साबित करती है:

$ python3 hopfind.py 192.0.2.53 53 --proto udp --max 10
  1  198.51.100.254                              0.3 ms  ICMP 11/0 time exceeded in-transit
  2  198.51.100.133                              5.4 ms  ICMP 11/0 time exceeded in-transit
  3  *
  4  198.51.100.167                             14.5 ms  ICMP 11/0 time exceeded in-transit
  5  203.0.113.50                                6.3 ms  ICMP 11/0 time exceeded in-transit
  6  203.0.113.174                               5.7 ms  ICMP 11/0 time exceeded in-transit
  7  203.0.113.201                               6.4 ms  ICMP 11/0 time exceeded in-transit
  8  *

उसी एड्रेस तक सात हॉप के साफ़ जवाब। तो यह न रूटिंग है और न मंज़िल: मेरी लाइन पर कोई चीज़ उस होस्ट तक TCP को ड्रॉप करती है और UDP को जाने देती है।

फिर वही रिज़ॉल्वर, वही पोर्ट, IPv6 पर:

$ python3 hopfind.py 2001:db8:53::53 443 -6 --max 10
walking to 2001:db8:53::53  TCP/443  hop limit 1-10
  1  2001:db8:1:ee:beef:abcd:fec0:2a30           0.5 ms  ICMP 3/0 hop limit exceeded in-transit
  2  2001:db8:1::15c                            24.6 ms  ICMP 3/0 hop limit exceeded in-transit
  3  *
  4  2001:db8:2:200::50                          5.5 ms  ICMP 3/0 hop limit exceeded in-transit
  5  2001:db8:2:2::4                             5.7 ms  ICMP 3/0 hop limit exceeded in-transit
  6  2001:db8:2:991::                           16.6 ms  ICMP 3/0 hop limit exceeded in-transit
  7  2001:db8:53::53                             5.7 ms  connected

Verdict: TCP/443 is open. It answered at hop 7.

सीधा पार। सात हॉप, कोई ड्रामा नहीं। वही सर्विस, वही पोर्ट, वही इरादा, और नियम सिर्फ़ एक एड्रेस फ़ैमिली पर मौजूद है।

जिसने भी वह नियम लिखा, उसने उसे IPv4 के लिए लिखा और उसका जोड़ीदार कभी नहीं लिखा। मुझे नहीं पता इसका मक़सद क्या था, मेरा अंदाज़ा है कि DNS को लोकल रखने से जुड़ा कुछ, लेकिन जो भी था, वह जब से इस लाइन पर IPv6 है तब से आधे ट्रैफ़िक पर ही हासिल हो रहा है। अगर यह किसी वजह से था, तो काम नहीं करता। अगर नहीं था, तो इसे वहाँ नहीं होना चाहिए।

यह dual-stack समस्या का रोज़मर्रा वाला रूप है, और यह इस बहस से कहीं ज़्यादा आम है कि IPv6 लगाना भी चाहिए या नहीं। दो नियम-पुस्तिकाएँ। एक की देखरेख होती है।

पूरी स्क्रिप्ट

कोई डिपेंडेंसी नहीं, कोई इंस्टॉल नहीं, स्टैंडर्ड लाइब्रेरी के सिवा कुछ नहीं। Python 3.6 या उसके बाद का, और Linux पर कोई विशेषाधिकार नहीं।

पोर्टेबिलिटी की पूरी कहानी ये दो क्लास हैं। ErrorQueue Linux वाला रास्ता है: सॉकेट पर IP_RECVERR चालू कीजिए, और प्रोब फ़ेल होने के बाद MSG_ERRQUEUE पढ़िए और राउटर का एड्रेस उस sock_extended_err स्ट्रक्चर से निकालिए जिसके साथ कर्नेल उसे जोड़ता है। RawIcmp बाक़ी हर जगह के लिए है: एक raw ICMP सॉकेट खोलिए, जो आए उसे पढ़िए, पैकेट से सोर्स एड्रेस लीजिए। पहले को कुछ नहीं चाहिए, दूसरे को root चाहिए, और बाक़ी प्रोग्राम को परवाह नहीं कि उसे कौन सा मिला।

एक बारीकी बताने लायक़ है क्योंकि यही सही जवाब और विश्वसनीय-से-लगने वाले जवाब का फ़र्क़ है। probe() में एरर क्यू को SO_ERROR देखने से पहले ख़ाली किया जाता है। ICMP एरर TCP सॉकेट तक एक सादे errno के रूप में पहुँचता है, ICMP 3/3 port unreachable ECONNREFUSED बनकर आता है, बिल्कुल एक असली रीसेट की तरह, तो पहले SO_ERROR जाँचने से इस पोस्ट में ऊपर वाला नक़ली SMTP रीसेट दूसरी तरफ़ से आया एक ईमानदार इनकार बताया जाता। पहले क्यू पढ़िए और ee_origin आपको बताता है कि किसी राउटर ने बात की।

#!/usr/bin/env python3
"""hopfind - work out how many hops away the thing blocking your port is.

Walks the IPv4 TTL, or the IPv6 hop limit, up from 1 and records which router
answers at each step - using the protocol and port you actually care about
instead of traceroute's default UDP high ports.

Run it twice. Once against something that works, once against the port that
does not. The hop where the answers stop is the device dropping you, and the
run that works gives you its address.

    python3 hopfind.py example.net 445            # the port under suspicion
    python3 hopfind.py example.net 443            # the reference run
    python3 hopfind.py example.net 53 --proto udp
    python3 hopfind.py 2001:db8::1 443 -6

On Linux this needs no privileges at all: IP_RECVERR and IPV6_RECVERR hand the
ICMP errors back on the ordinary socket that caused them. On macOS, the BSDs
and Solaris the errors have to be read off a raw ICMP socket, which means root.

Written for https://blogs.damiendye.uk/networking/how-far-away-is-the-firewall/
Public domain. Do what you like with it.
"""

import argparse
import errno
import os
import select
import socket
import struct
import sys
import time

# Linux socket options. Absent from the socket module on some builds, so they
# are spelled out rather than looked up.
IP_RECVERR = 11
IPV6_RECVERR = 25

# ee_origin values from linux/errqueue.h. Anything else means the errno came
# from the local stack rather than from a router.
SO_EE_ORIGIN_ICMP = 2
SO_EE_ORIGIN_ICMP6 = 3

ICMP_V4 = {
    (11, 0): "time exceeded in-transit",
    (11, 1): "fragment reassembly time exceeded",
    (3, 0): "net unreachable",
    (3, 1): "host unreachable",
    (3, 2): "protocol unreachable",
    (3, 3): "port unreachable",
    (3, 4): "fragmentation needed",
    (3, 9): "net administratively prohibited",
    (3, 10): "host administratively prohibited",
    (3, 13): "communication administratively prohibited",
    (5, 0): "redirect",
}

ICMP_V6 = {
    (3, 0): "hop limit exceeded in-transit",
    (3, 1): "fragment reassembly time exceeded",
    (1, 0): "no route to destination",
    (1, 1): "communication administratively prohibited",
    (1, 3): "address unreachable",
    (1, 4): "port unreachable",
    (2, 0): "packet too big",
}


def describe(family, icmp_type, icmp_code):
    table = ICMP_V4 if family == socket.AF_INET else ICMP_V6
    return table.get((icmp_type, icmp_code), "unrecognised")


def is_expiry(family, icmp_type):
    """Was this the router saying 'your hop budget ran out here'?"""
    return icmp_type == (11 if family == socket.AF_INET else 3)


class ErrorQueue:
    """Linux. The kernel reports the ICMP error on the socket that provoked it."""

    def arm(self, sock, family):
        if family == socket.AF_INET:
            sock.setsockopt(socket.IPPROTO_IP, IP_RECVERR, 1)
        else:
            sock.setsockopt(socket.IPPROTO_IPV6, IPV6_RECVERR, 1)

    def extra_readers(self):
        return []

    def collect(self, sock, family):
        try:
            _, ancillary, _, _ = sock.recvmsg(0, 1024, socket.MSG_ERRQUEUE)
        except OSError:
            return None
        wanted = (socket.IPPROTO_IP, IP_RECVERR) if family == socket.AF_INET \
            else (socket.IPPROTO_IPV6, IPV6_RECVERR)
        for level, kind, data in ancillary:
            if (level, kind) != wanted or len(data) < 16:
                continue
            # struct sock_extended_err, then the sockaddr of the router that
            # sent the error - SO_EE_OFFENDER in the kernel headers.
            _, origin, icmp_type, icmp_code = struct.unpack_from("=IBBB", data, 0)
            if origin not in (SO_EE_ORIGIN_ICMP, SO_EE_ORIGIN_ICMP6):
                return None
            addr = None
            if len(data) >= 24:
                offender_family, = struct.unpack_from("=H", data, 16)
                if offender_family == socket.AF_INET:
                    addr = socket.inet_ntoa(data[20:24])
                elif offender_family == socket.AF_INET6 and len(data) >= 40:
                    addr = socket.inet_ntop(socket.AF_INET6, data[24:40])
            return addr, icmp_type, icmp_code
        return None


class RawIcmp:
    """macOS, the BSDs, illumos, Solaris. Read the ICMP off a raw socket, as root."""

    def __init__(self, family):
        proto = socket.IPPROTO_ICMP if family == socket.AF_INET else socket.IPPROTO_ICMPV6
        self.sock = socket.socket(family, socket.SOCK_RAW, proto)
        self.sock.setblocking(False)

    def arm(self, sock, family):
        pass

    def extra_readers(self):
        return [self.sock]

    def collect(self, sock, family):
        try:
            packet, peer = self.sock.recvfrom(1500)
        except OSError:
            return None
        if family == socket.AF_INET:
            # BSD raw sockets hand back the IP header too.
            header_len = (packet[0] & 0x0F) * 4
            packet = packet[header_len:]
        if len(packet) < 2:
            return None
        return peer[0], packet[0], packet[1]


def probe(dest, port, proto, family, hop_limit, timeout, listener):
    """One probe at one hop limit. Returns (icmp, socket_state, note)."""
    kind = socket.SOCK_STREAM if proto == "tcp" else socket.SOCK_DGRAM
    sock = socket.socket(family, kind)
    if family == socket.AF_INET:
        sock.setsockopt(socket.IPPROTO_IP, socket.IP_TTL, hop_limit)
    else:
        sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_UNICAST_HOPS, hop_limit)
    listener.arm(sock, family)
    sock.setblocking(False)

    try:
        if kind == socket.SOCK_DGRAM:
            sock.connect((dest, port))
            sock.send(b"\x00" * 32)
        else:
            try:
                sock.connect((dest, port))
            except BlockingIOError:
                pass
    except OSError as exc:
        sock.close()
        return None, None, "local error: %s" % exc.strerror

    readers = [sock] + listener.extra_readers()
    writers = [] if kind == socket.SOCK_DGRAM else [sock]
    deadline = time.time() + timeout
    icmp = state = None

    while time.time() < deadline:
        ready_r, ready_w, ready_x = select.select(
            readers, writers, [sock], max(0.01, deadline - time.time()))
        if not (ready_r or ready_w or ready_x):
            continue
        # Drain the error queue first, always. An ICMP error reaches a TCP
        # socket as a plain errno, so SO_ERROR on its own cannot tell you
        # whether a router spoke or the far end did.
        icmp = listener.collect(sock, family)
        if icmp:
            break
        if ready_w:
            err = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
            if err == 0:
                state = "connected"
            elif err == errno.ECONNREFUSED:
                state = "TCP reset"
            else:
                state = os.strerror(err)
            break

    sock.close()
    if icmp or state:
        return icmp, state, None
    return None, None, "no reply"


def walk(dest, port, proto, family, first, last, timeout, listener):
    print("walking to %s  %s/%d  hop limit %d-%d" % (dest, proto.upper(), port, first, last))
    answered = []
    for hop in range(first, last + 1):
        started = time.time()
        icmp, state, _ = probe(dest, port, proto, family, hop, timeout, listener)
        rtt = (time.time() - started) * 1000
        if icmp:
            addr, icmp_type, icmp_code = icmp
            print(" %2d  %-39s %7.1f ms  ICMP %d/%d %s"
                  % (hop, addr or "?", rtt, icmp_type, icmp_code,
                     describe(family, icmp_type, icmp_code)))
            if is_expiry(family, icmp_type):
                answered.append((hop, addr))
            else:
                return answered, hop, "icmp-reject", addr
        elif state:
            print(" %2d  %-39s %7.1f ms  %s" % (hop, dest, rtt, state))
            return answered, hop, state, dest
        else:
            print(" %2d  *" % hop)
    return answered, None, "silent", None


def main():
    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    parser.add_argument("host")
    parser.add_argument("port", nargs="?", type=int, default=443)
    parser.add_argument("--proto", choices=("tcp", "udp"), default="tcp")
    parser.add_argument("--first", type=int, default=1, help="hop limit to start at")
    parser.add_argument("--max", type=int, default=20, help="hop limit to stop at")
    parser.add_argument("--wait", type=float, default=2.0, help="seconds to wait per hop")
    parser.add_argument("-6", dest="v6", action="store_true", help="force IPv6")
    parser.add_argument("-4", dest="v4", action="store_true", help="force IPv4")
    args = parser.parse_args()

    family = socket.AF_INET6 if args.v6 else socket.AF_INET
    kind = socket.SOCK_STREAM if args.proto == "tcp" else socket.SOCK_DGRAM
    dest = socket.getaddrinfo(args.host, args.port, family, kind)[0][4][0]

    if sys.platform.startswith("linux"):
        listener = ErrorQueue()
    else:
        try:
            listener = RawIcmp(family)
        except PermissionError:
            sys.exit("%s cannot report ICMP errors on a normal socket, so this "
                     "needs a raw one. Run it as root." % sys.platform)

    answered, stop, why, who = walk(dest, args.port, args.proto, family,
                                    args.first, args.max, args.wait, listener)
    what = "%s/%d" % (args.proto.upper(), args.port)
    print()

    if why == "connected":
        print("Verdict: %s is open. It answered at hop %d." % (what, stop))
    elif why == "icmp-reject":
        print("Verdict: %s at hop %d is refusing %s on policy, and is honest "
              "enough to say so." % (who, stop, what))
    elif why == "TCP reset":
        print("Verdict: a reset came back to a probe with a hop limit of %d." % stop)
        print("         Nothing more than %s away can have sent it, so check the reply"
              % ("one hop" if stop == 1 else "%d hops" % stop))
        print("         TTL before you believe the host did.")
    elif answered:
        last_hop, last_addr = answered[-1]
        print("Verdict: answers stop after hop %d (%s)." % (last_hop, last_addr))
        print("         Whatever swallows %s is hop %d." % (what, last_hop + 1))
        print("         Walk a port that works and read off the address at hop %d."
              % (last_hop + 1))
    else:
        print("Verdict: nothing answered at all, not even the first hop. Either the")
        print("         first hop is the one dropping you, or the ICMP errors are being")
        print("         filtered on the way back. Walk a port that works to tell those")
        print("         two apart.")


if __name__ == "__main__":
    main()

यह आपको क्या नहीं बता सकता

तरीक़ा सस्ता है और ज़्यादातर चीज़ों के बारे में ईमानदार है, लेकिन यह टोपोलॉजी स्कैनर नहीं है। टिकट में साफ़ बताइए कि आपने असल में क्या मापा।

अलग five-tuple अलग रास्ते ले सकते हैं। ECMP सोर्स और डेस्टिनेशन पोर्ट को अगले हॉप के चुनाव में हैश करता है, तो दो अलग पोर्ट पर दो रन के एक ही राउटर से गुज़रने की कोई गारंटी नहीं है, और यही उन दो बातों में से एक है जो समझा सकती है कि ऊपर हॉप 5 ने एक रन को जवाब क्यों दिया और दूसरे पर चुप क्यों रहा। दोनों रन दोहराइए। जो सीमा खिसकती है वह साबित नहीं है।

MPLS हॉप छिपाता है। एक label-switched कोर एक हॉप जैसा दिख सकता है, या बिल्कुल नहीं। किसी और के बैकबोन के आर-पार कोई भी गिनती एक निचली सीमा है।

ICMP बनाना लगभग हर जगह रेट लिमिटेड है। राउटर के जवाब देने से तेज़ प्रोब कीजिए और आप अपने ही स्टार बना लेते हैं। hopfind.py हर हॉप पर एक प्रोब भेजता है और इंतज़ार करता है; यह जानबूझकर है।

वापसी का रास्ता बाहर जाने वाले रास्ते जैसा होना ज़रूरी नहीं। बाहर का हॉप काउंट वापसी का हॉप काउंट नहीं है, और उल्टे TTL वाला हिसाब सिर्फ़ वापसी वाला हिस्सा मापता है।

Anycast का मतलब है कि हॉप N पर होस्ट दो बार एक ही बॉक्स न हो। ख़ासकर पब्लिक रिज़ॉल्वर और CDN।

पूरा हुआ हैंडशेक इसका मतलब नहीं कि सेशन बचा रहेगा। एक stateful फ़ायरवॉल SYN को जाने दे सकता है और जाँच के बाद आगे का ड्रॉप कर सकता है। अगर कनेक्शन खुलता है और फिर मर जाता है, तो यह ग़लत औज़ार है: जाकर कैप्चर कीजिए।

आपने पहला ड्रॉप करने वाला डिवाइस ढूँढा है, वह नहीं जिसे कोई मानेगा। CGN या कैरियर नेटवर्क में हॉप N+1 का एड्रेस एक ही एड्रेस के पीछे कई बॉक्स में से एक हो सकता है। फिर भी उसी का हवाला देना सही है, क्योंकि यह रास्ते के बारे में एक तथ्य है।

यह असल में किस काम का है

उछाल-कूद ख़त्म करना। इस पूरी मेहनत का यही हासिल है।

“पोर्ट 445 कहीं ब्लॉक है” टिकट वापस करने का न्योता है। यह नहीं है:

192.0.2.4 तक TCP/445 हॉप 11 पर, एड्रेस 192.0.2.31 पर, चुपचाप ड्रॉप होता है। उसी रास्ते पर हॉप 11 TCP/443 को 26 ms में ICMP Time Exceeded से जवाब देता है और 445 पर बिल्कुल कुछ नहीं, तो यह ड्रॉप उस डिवाइस पर एक पॉलिसी फ़ैसला है, रूटिंग की ख़राबी नहीं। उसके आगे के दस हॉप साफ़ हैं। बीस मिनट में चार बार दोहराया गया, बिना विशेषाधिकार वाले शेल से, स्क्रिप्ट संलग्न है।

इसे कोई वापस नहीं करता। यह एक डिवाइस का नाम बताता है, बताता है कि उसने क्या किया, बताता है कि उसने क्या नहीं किया, और काम करके दिखाता है। वे इसे बदलें या नहीं, यह अब भी उनका फ़ैसला है। लेकिन हफ़्ते भर की पिंग-पोंग ख़त्म, और इसमें चार कमांड लगीं।

इसमें सब कुछ एक 8-बिट फ़ील्ड से निकला जिसे 1981 में टाइमर के रूप में तय किया गया था, जिसे कभी एक बार भी टाइमर की तरह इस्तेमाल नहीं किया गया, और जो चुपचाप “कहीं” को एक एड्रेस में बदल देता है।

पढ़ना सीखने लायक़ है।