OpenWrt పాలసీ రూటింగ్: స్థానిక DNSని పట్టుకునే గొలుసు

LANలోని క్లయింట్లు టన్నెల్ ద్వారా పరిష్కరిస్తారు, రౌటర్ స్వంత శోధనలు నిశ్శబ్దంగా అలా చేయవు. ప్యాకేజీ అప్డేట్లు, సమయ సమకాలీకరణ మరియు డైనమిక్ DNS అన్నీ సాధారణ అప్లింక్ ద్వారా బయటకు వెళ్తాయి, అయితే ప్రతి ఫార్వర్డ్ చేసిన క్వెరీ VPN తీసుకుంటుంది, మరియు ఇంటర్ఫేస్లో రెండు వేరే మార్గాలు ఉన్నాయని ఏదీ సూచించదు. వివరణ పాలసీలో బగ్ కాదు, ఏ హుక్ ప్యాకెట్ను చూస్తుంది అనే ప్రశ్న. రెండు ప్రవాహాలు, ఒక రిజాల్వర్ చిరునామా, వాటిలో ఒకటి మాత్రమే రౌటర్ను దాటుతుంది. వాటిని వేరు చేయడమే మొత్తం సరిదిద్దడం.

రెండు ప్రవాహాలు, ఒక రిజాల్వర్ చిరునామా

మొదటి ప్రవాహం ప్రజలు ఊహించేది. క్లయింట్ రౌటర్ రిజాల్వర్ను అడుగుతుంది, రిజాల్వర్ పైకి ఫార్వర్డ్ చేస్తుంది, ఆ ఫార్వర్డ్ చేసిన ప్యాకెట్ బయటకు వెళ్లేటప్పుడు రౌటర్ గుండా వెళ్తుంది. ఆ ప్యాకెట్ ఫార్వర్డ్ ట్రాఫిక్ను గమనించే ఏదైనా చూడగలదు.

రెండో ప్రవాహం ఎప్పుడూ ఎక్కడి నుండి రాదు. రౌటర్ దాన్ని సృష్టిస్తుంది, కాబట్టి లోపలికి వచ్చే ప్యాకెట్ లేదా సరిపోల్చాల్సిన ఫార్వర్డింగ్ దశ లేదు.

రెండూ ఒకే రిజాల్వర్ చిరునామాను లక్ష్యంగా చేసుకోవచ్చు, అందుకే తేడాను గమనించకపోవడం సులభం. అదే గమ్యం, వేరే మూలం, వేరే గొలుసు. మూలాన్ని చూసిన వెంటనే మిగిలిన నిర్ధారణ అనుసరిస్తుంది.

ఫార్వర్డ్ చేసిన మరియు స్థానికంగా సృష్టించిన ప్యాకెట్లు వేరే విధంగా ప్రవేశిస్తాయి

ఫార్వర్డ్ ట్రాఫిక్ మరొక ఇంటర్ఫేస్ నుండి వచ్చినప్పుడు మూల్యాంకనం చేయబడుతుంది. పాలసీ రూటింగ్ ప్యాకేజీలు దాన్ని prerouting గొలుసుగా బయటపెడతాయి, అక్కడ ఉంచిన నియమం రౌటర్ దాటే ప్రతి ప్యాకెట్ను చూస్తుంది. అందుకే క్లయింట్ లుకప్లు పాలసీ వివరించినట్లే ప్రవర్తిస్తాయి, అందుకే రౌటర్ దాన్ని పట్టించుకోదు. నియమం తప్పు కాదు, రౌటర్ ఎప్పుడూ చేరని హుక్కు జోడించబడింది. దాన్ని కదిలిస్తే, అదే సరిపోలిక పని చేయడం ప్రారంభిస్తుంది.

స్థానికంగా సృష్టించిన ట్రాఫిక్ను రౌటర్లోని ప్రక్రియ సృష్టిస్తుంది మరియు బదులుగా ఔట్పుట్ మార్గంలోకి ప్రవేశిస్తుంది. రౌటర్ స్వంత నిర్ణయం దాన్ని రూట్ చేస్తుంది, పాలసీ ఆ గొలుసును కవర్ చేస్తే మాత్రమే అది పాలసీని కలుస్తుంది. సరిపోల్చడానికి లోపలికి వచ్చే ఇంటర్ఫేస్ లేదా గమనించడానికి ఫార్వర్డింగ్ నిర్ణయం లేదు.

ఇది ప్యాకెట్లు ఎక్కడ పుడతాయనే లక్షణం, ఏదో నిర్దిష్ట ప్యాకేజీ లక్షణం కాదు. ఒక గొలుసు కోసం రాసిన నియమానికి మరొకదాని గురించి అభిప్రాయం ఉండదు. ఏ నియమ ట్యూనింగ్ దాన్ని మార్చదు.

ఔట్పుట్ గొలుసును ఎంచుకోండి, తర్వాత సరిపోలికను సన్నగా చేయండి

సరిదిద్దడం అంటే అదే ఉద్దేశాన్ని ఔట్పుట్ గొలుసుకు కూడా జోడించడం, లేదా రౌటర్ స్వంత క్వెరీలే ముఖ్యమైతే నియమాన్ని అక్కడికి తరలించడం. పాలసీ రూటింగ్ ప్యాకేజీపై నిర్మించిన OpenWrt సెటప్లో దీని అర్థం నియమం గొలుసు సెట్టింగ్లో prerouting బదులు output ఎంచుకోవడం. రెండు జనాభాకు కవరేజ్ అవసరమైతే రెండు నియమాలను ఉంచండి.

తర్వాత నియమం ఏదానికి సరిపోతుందో సన్నగా చేయండి. రిజాల్వర్ నిజంగా ఉపయోగించే పోర్ట్లోని గమ్య రిజాల్వర్ చిరునామాలు, రౌటర్ సృష్టించే అన్నింటిని టన్నెల్కు పంపడం కంటే చాలా చిన్న నిర్ణయం.

రెండు గొలుసులను కవర్ చేసే ఒకటి రాయడానికి ప్రయత్నించడం బదులు రెండు నియమాలను స్పష్టంగా ఉంచండి. వేర్వేరు నియమాలు చదవడానికి సులభం, డీబగ్ చేస్తున్నప్పుడు క్లయింట్ ట్రాఫిక్కు భంగం కలిగించకుండా రౌటర్ మార్గాన్ని నిలిపివేయడానికి అనుమతిస్తాయి. కౌంటర్లను ఒక్కొక్కటిగా అర్థవంతంగా చేస్తాయి.

టన్నెల్ స్వంత రవాణాను నియమం వెలుపల ఉంచండి

టన్నెల్ బాహ్య కనెక్షన్ను కూడా రౌటర్ సృష్టిస్తుంది. స్థానికంగా సృష్టించిన మొత్తం ట్రాఫిక్ను టన్నెల్కు పంపే నియమం టన్నెల్ను దాని ద్వారానే రూట్ చేస్తుంది, అది అసలు పైకి రాదు.

నిర్వహణ ప్రాప్యత రెండో బాధితుడు. రౌటర్ నుండి పుట్టిన పరిపాలనా సెషన్లు, లేదా వాటికి సమాధానాలు, చాలా వెడల్పైన స్థానిక నియమం ద్వారా టన్నెల్లోకి లాగబడి LAN నుండి చేరుకోలేనివి కావచ్చు.

టన్నెల్ ముగింపు బిందువును సరిపోలిక నుండి మినహాయించి, నియమాన్ని రిజాల్వర్ చిరునామాలకు పరిమితం చేయండి. అది DNS అవసరానికి సరిపోతుంది మరియు దాని గురించి ఆలోచించడానికి తగినంత చిన్నది.

ఒకటి కాదు, రెండు జనాభాను పరీక్షించండి

రౌటర్ తన స్వంత క్వెరీ చేస్తున్నట్లు గమనించి, ఏ ఇంటర్ఫేస్ దాన్ని మోసిందో గుర్తించండి. LAN హోస్ట్ నుండి లుకప్ను పునరావృతం చేసి, అది తీసుకున్న మార్గాన్ని గుర్తించండి. పాలసీ నియమాలపై కౌంటర్లు ఊహించకుండా రెండు సమాధానాలను కనిపించేలా చేస్తాయి.

ఫలితాలను రెండు వేర్వేరు కనుగొనడాలుగా పరిగణించండి. టన్నెల్ ద్వారా పరిష్కరించే క్లయింట్ రౌటర్ గురించి ఏమీ చెప్పదు, సరిగ్గా పరిష్కరించే రౌటర్ మరొక శ్రోతపై ఉన్న క్లయింట్ గురించి ఏమీ చెప్పదు. వాటిని మార్పు రికార్డులో వేర్వేరు పంక్తులుగా రాయండి.

పోర్టును కూడా తనిఖీ చేయండి: గమ్య పోర్ట్ 53కి సరిపోలే నియమం 853లో DNS over TLS లేదా HTTPS ముగింపు బిందువు ద్వారా చేరే రిజాల్వర్ను మిస్ అవుతుంది. కాన్ఫిగర్ చేసిన upstream నిజంగా ఉపయోగించే రవాణాకు సరిపోల్చండి, లీక్ సరైన కారణంతో మూసుకుపోతుంది.