VpnService protect() അല്ലെങ്കിൽ ആപ്പ് ഒഴിവാക്കൽ: റൂട്ടിംഗ് ശരിയാക്കുന്നത് ഏതാണ്

ടണലിന്റെ സ്വന്തം പാക്കറ്റുകൾ ടണലിന് പുറത്ത് നിർത്താൻ രണ്ട് വഴികളുണ്ട്: ട്രാൻസ്പോർട്ട് സോക്കറ്റ് സംരക്ഷിക്കുക, അല്ലെങ്കിൽ മുഴുവൻ ആപ്പും VPN-ൽ നിന്ന് പുറത്തെടുക്കുക. അവ വ്യത്യസ്ത പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നു, എളുപ്പത്തിൽ ബന്ധിപ്പിക്കാം എന്നതിനാൽ വിശാലമായത് തിരഞ്ഞെടുക്കുന്നതാണ് ആപ്പുകൾ ശ്രദ്ധിക്കാതെ തന്നെ ലോക്കൽ നെറ്റ്വർക്ക് ആക്സസും വിഭജിത DNS-ഉം നഷ്ടപ്പെടുന്ന വഴി. ടണലിന് പുറത്ത് നിൽക്കേണ്ടതിൽ നിന്ന് തുടങ്ങി, അത് നേടുന്ന ഏറ്റവും ചെറിയ പരിധി തിരഞ്ഞെടുക്കുക.

protect() ടണലിൽ നിന്ന് എന്ത് നീക്കുന്നു

VpnService.protect() ഓരോ സോക്കറ്റിനുമുള്ള വിളിയാണ്. ടണൽ കൊണ്ടുപോകുന്ന സോക്കറ്റോ ഡിസ്ക്രിപ്റ്ററോ നിങ്ങൾ അതിന് നൽകുന്നു, Android ആ സോക്കറ്റ് അടയാളപ്പെടുത്തുന്നു, അതുവഴി അതിന്റെ ട്രാഫിക് VPN ഇന്റർഫേസിന് പകരം താഴെയുള്ള നെറ്റ്വർക്ക് ഉപയോഗിക്കും. ആപ്പ് അയക്കുന്ന ബാക്കിയെല്ലാം സാധാരണ VPN റൂട്ട് പിന്തുടരുന്നു.

ആ ഇടുങ്ങിയ പരിധിയാണ് കാര്യം. സംരക്ഷിത സോക്കറ്റ് നിങ്ങളുടെ HTTP ക്ലയന്റ് പേരുകൾ എങ്ങനെ പരിഹരിക്കുന്നു, നിങ്ങളുടെ അനലിറ്റിക്സ് വിളികൾ ഏത് ഇന്റർഫേസ് ഉപയോഗിക്കുന്നു, അല്ലെങ്കിൽ പിന്നീട് തുറക്കുന്ന രണ്ടാം കണക്ഷന് എന്ത് സംഭവിക്കുന്നു എന്നതൊന്നും മാറ്റുന്നില്ല.

പരിധി തീരുമാനിക്കുന്ന മൂന്ന് വ്യവസ്ഥകൾ

ആദ്യ വ്യവസ്ഥ, ടണലിന്റെ ട്രാൻസ്പോർട്ട് മാത്രം പുറത്തുപോകണോ എന്നതാണ്. ആപ്പിന്റെ ബാക്കി ട്രാഫിക് ഇനിയും VPN വഴി പോകേണ്ടതുണ്ടെങ്കിൽ, സോക്കറ്റ് സംരക്ഷണമാണ് ശരിയായ പരിധി. രണ്ടാം വ്യവസ്ഥ, സോക്കറ്റ് സൃഷ്ടിക്കുന്നത് നിങ്ങൾ നിയന്ത്രിക്കുന്നുണ്ടോ എന്നതാണ്. ഉള്ളിൽ ആഴത്തിൽ സ്വന്തം സോക്കറ്റ് തുറക്കുന്ന ലൈബ്രറി, ഒരു ഹുക്ക് നൽകുകയോ തയ്യാറായ സോക്കറ്റ് സ്വീകരിക്കുകയോ ചെയ്യുന്നില്ലെങ്കിൽ protect() വിളിക്കാൻ നിങ്ങൾക്ക് ഇടം നൽകുന്നില്ല. മൂന്നാം വ്യവസ്ഥ, ആപ്പ് ലോക്കൽ നെറ്റ്വർക്കിലേക്കോ captive portal-ലേക്കോ നേരിട്ട് എത്തണമോ എന്നതാണ്, ഇത് ടണൽ ജീവനോടെ നിർത്തുന്നതിൽ നിന്ന് വ്യത്യസ്തമായ ആവശ്യകതയാണ്.

ആപ്പിനെaddDisallowedApplication() കൊണ്ട് ഒഴിവാക്കുന്നത് പരുക്കൻ ഉപകരണമാണ്. ആപ്പ് ഉണ്ടാക്കുന്ന ഓരോ കണക്ഷനും അത് VPN-ൽ നിന്ന് നീക്കുന്നു, നിങ്ങൾ പരിശോധിക്കാൻ ആഗ്രഹിച്ചവ ഉൾപ്പെടെ, ചില ഉപകരണങ്ങളിൽ ലോക്കൽ കണ്ടെത്തലിന്റെ സ്വഭാവവും മാറ്റുന്നു.

മൂന്നാം ഓപ്ഷൻ, ട്രാൻസ്പോർട്ടിനെ തിരഞ്ഞെടുത്ത നെറ്റ്വർക്കിലേക്ക് ബന്ധിക്കുകയാണ്:bindProcessToNetwork() അല്ലെങ്കിൽ സോക്കറ്റ് തലത്തിലുള്ള നെറ്റ്വർക്ക് ഹാൻഡിൽ ഉപയോഗിച്ച്. ഉപകരണത്തിൽ ഒരേ സമയം Wi-Fi-ഉം മൊബൈലും ഉണ്ടാകുമ്പോൾ, ടണൽ ഒരു നിർദ്ദിഷ്ട അപ്‌ലിങ്കിലൂടെ പോകണമെന്ന് ആഗ്രഹിക്കുമ്പോൾ ഇത് ഉപകാരപ്രദമാണ്.

ട്രാൻസ്പോർട്ട് നിർമ്മിക്കുന്ന സമയത്ത് തന്നെ അത് വിളിക്കുക

വിളിക്കുക protect() ട്രാൻസ്പോർട്ട് ഉണ്ടാക്കുന്ന അതേ ബ്ലോക്കിൽ,connect() അല്ലെങ്കിൽ send() മുമ്പ്. വിളി false തിരികെ നൽകിയാൽ, സോക്കറ്റ് അടച്ച് സെറ്റപ്പ് പരാജയപ്പെടുത്തുക; തുടർന്നാൽ പാക്കറ്റുകൾ നിങ്ങളുടെ സ്വന്തം ഇന്റർഫേസിലേക്ക് വീണ്ടും കടക്കാവുന്ന ട്രാൻസ്പോർട്ട് നിങ്ങളുടെ കൈവശം അവശേഷിക്കും.

രൂപം ഒരിടത്ത് സൂക്ഷിക്കാൻ മാത്രം ചെറുതാണ്:

DatagramSocket transport = new DatagramSocket();
if (!protect(transport)) {
    transport.close();
    throw new IOException("transport not protected");
}
transport.connect(serverAddress);

ഇവിടെ മൂന്ന് വിശദാംശങ്ങൾ കടിക്കുന്നു. ആദ്യം,ബൂളിയൻ മാത്രമാണ് നിങ്ങൾക്ക് ലഭിക്കുന്ന സൂചന, അതിനാൽ പിൻവലിച്ച സമ്മതവും നിരസിച്ച വിളിയും തമ്മിൽ വേർതിരിക്കാൻ മതിയായ സന്ദർഭത്തോടെ പരാജയം രേഖപ്പെടുത്തുക. രണ്ടാമത്,protect() സോക്കറ്റിനെ ഉൾക്കൊള്ളുന്നു, ഡിസ്ക്രിപ്റ്റർ നമ്പറിനെയല്ല: സോക്കറ്റ് അടച്ച് പിന്നീട് അതേ പൂർണ്ണസംഖ്യ മറ്റൊരു സോക്കറ്റിന് ഉപയോഗിച്ചാൽ, പുതിയ സോക്കറ്റ് സംരക്ഷിതമല്ല. മൂന്നാമത്, നേറ്റീവ് ലൈബ്രറി ട്രാൻസ്പോർട്ട് തുറക്കുമ്പോൾ, നേറ്റീവ് കോഡ് ബന്ധിപ്പിക്കുന്നതിന് മുമ്പ് ഡിസ്ക്രിപ്റ്റർ സംരക്ഷിക്കുക, അല്ലെങ്കിൽ റൂട്ട് ഇതിനകം തിരഞ്ഞെടുത്തിരിക്കാം.VpnService റഫറൻസ് നിങ്ങളുടെ ലക്ഷ്യ API നില യഥാർത്ഥത്തിൽ ഏത് ഓവർലോഡുകൾ നൽകുന്നു എന്ന് ഉറപ്പാക്കാനുള്ള സ്ഥലമാണ്.

സുഖകരമായ വഴി മാത്രമല്ല, തടയപ്പെട്ട വഴിയും പരീക്ഷിക്കുക

ടണൽ ഉയർത്തിയ അവസ്ഥയിൽ പരിശോധിക്കുക, കാരണം ആ അവസ്ഥയിൽ മാത്രമേ രണ്ട് വഴികൾക്കും വ്യത്യാസപ്പെടാൻ കഴിയൂ. സംരക്ഷിത ട്രാൻസ്പോർട്ടിലൂടെ ഒരു അഭ്യർത്ഥനയും,protect() ഒരിക്കലും വിളിച്ചിട്ടില്ലാത്ത കോഡ് വഴിയിൽ നിന്ന് മറ്റൊന്നും അയച്ച്, ദൂരെയുള്ള അറ്റം എന്ത് കാണുന്നു എന്ന് താരതമ്യം ചെയ്യുക: സംരക്ഷിത കണക്ഷൻ താഴെയുള്ള നെറ്റ്വർക്കിനെ ഉറവിടമായി കൊണ്ട് എത്തണം, സംരക്ഷണമില്ലാത്തത് ടണലിന്റെ സ്വന്തം വിലാസം കാണിച്ച് ടണലിന്റെ ബൈറ്റ് കൗണ്ടറുകൾ ചലിപ്പിക്കുന്നു. ഉപകരണത്തിൽ ss അല്ലെങ്കിൽ netstat റേഡിയോയിൽ നിന്ന് എന്തെങ്കിലും പുറത്തുപോകുന്നതിന് മുമ്പ് അതേ വിഭജനം കാണിക്കുന്നു.

പിൻവലിക്കൽ വെവ്വേറെ പരീക്ഷിക്കുക, കാരണം സമ്മതത്തിന്റെ മാറ്റം നിങ്ങളുടെ സോക്കറ്റ് കോഡ് തൊടാതെ ഇന്റർഫേസ് തകർക്കുന്നു. VPN സമ്മതം പിൻവലിക്കുകയോ സേവനം നിർത്തുകയോ ചെയ്ത്, ട്രാൻസ്പോർട്ട് വീണ്ടും നിർമ്മിച്ച്,protect() ഇപ്പോഴും true തിരികെ നൽകുന്നുവെന്നും സമ്മതം വീണ്ടും നൽകുമ്പോൾ ട്രാൻസ്പോർട്ട് വീണ്ടും ബന്ധിപ്പിക്കുന്നുവെന്നും ഉറപ്പാക്കുക.

സംരക്ഷിത അഭ്യർത്ഥന എങ്ങനെയും ടണൽ പിന്തുടരുന്നുവെങ്കിൽ, സോക്കറ്റ് ഇതിനകം റൂട്ട് ചെയ്തതിന് ശേഷമാണ് സംരക്ഷണ വിളി നടക്കുന്നത്. അത് നേരത്തേക്ക് നീക്കി വീണ്ടും പരീക്ഷിക്കുക.

തീരുമാനം ട്രാൻസ്പോർട്ട് സെറ്റപ്പിന് അരികിൽ എഴുതി സൂക്ഷിക്കുക: ഏത് സോക്കറ്റുകളാണ് സംരക്ഷിതം, ഏത് ആപ്പ് ട്രാഫിക് ഒഴിവാക്കിയിരിക്കുന്നു, സംരക്ഷണം പരാജയപ്പെടുമ്പോൾ ആപ്പ് എന്ത് ചെയ്യുന്നു. ആ വരിയാണ് ഒരു പരീക്ഷണം പരാജയപ്പെട്ടതിനാൽ ഒഴിവാക്കലിനെ മുഴുവൻ ആപ്പിലേക്ക് വ്യാപിപ്പിക്കുന്നതിൽ നിന്ന് പിന്നീടുള്ള പുനഃസംരചനയെ തടയുന്നത്. അടുത്ത വ്യക്തിക്ക് മാനിഫെസ്റ്റ് വിപരീത എഞ്ചിനീയറിംഗ് ചെയ്യാതെ ഉദ്ദേശ്യം പരിശോധിക്കാനുള്ള വഴിയും അത് നൽകുന്നു.