SOCKS വഴി Java TLS-നായി ലക്ഷ്യസ്ഥാനത്തിന്റെ ഐഡന്റിറ്റി ഉപയോഗിക്കുക

ആദ്യം SOCKS വഴി ബന്ധിപ്പിക്കുക, തുടർന്ന് വെബ്സൈറ്റിന്റെ ഹോസ്റ്റ്നെയിമും വ്യക്തമായ HTTPS എൻഡ്പോയിന്റ് പരിശോധനകളും ഉള്ള ഒരു SSLSocket പാളിയായി ചേർക്കുക.

SOCKS എൻഡ്പോയിന്റ് നിങ്ങളെ വെബ്സൈറ്റിലേക്ക് എത്തിക്കുന്നു. ആ കണക്ഷനുള്ളിലെ TLS പിയർ വെബ്സൈറ്റ് തന്നെയാണ്, അതിനാൽ ലക്ഷ്യസ്ഥാനത്തിന്റെ ഹോസ്റ്റ്നെയിം പാളിച്ചേർത്ത സോക്കറ്റ് ഫാക്ടറിക്ക് നൽകുക:

String destination = "example.com";
int destinationPort = 443;
Proxy proxy = new Proxy(
    Proxy.Type.SOCKS,
    new InetSocketAddress("127.0.0.1", 1080)
);

try (Socket transport = new Socket(proxy)) {
    transport.connect(
        InetSocketAddress.createUnresolved(destination, destinationPort),
        5000
    );
    SSLSocketFactory factory =
        (SSLSocketFactory) SSLSocketFactory.getDefault();
    try (SSLSocket tls = (SSLSocket) factory.createSocket(
            transport, destination, destinationPort, true)) {
        SSLParameters parameters = tls.getSSLParameters();
        parameters.setEndpointIdentificationAlgorithm("HTTPS");
        tls.setSSLParameters(parameters);
        tls.setSoTimeout(15000);
        tls.startHandshake();
        // Send the application's HTTPS request through tls.
    }
}

ഈ ഭാഗം സാധാരണ Java നെറ്റ്വർക്കിംഗ്, TLS ഇംപോർട്ടുകൾ, നിലവിലുള്ള ഡിഫോൾട്ട് വിശ്വാസ കോൺഫിഗറേഷൻ, പ്രോക്സി ക്രെഡൻഷ്യലുകൾ ആവശ്യമില്ലാത്ത SOCKS കണക്ഷൻ എന്നിവ അനുമാനിക്കുന്നു. ഇത് ഹാൻഡ്ഷേക്ക് നടത്തുന്നു; ആപ്ലിക്കേഷൻ ഇപ്പോഴും സെർവർ പ്രതീക്ഷിക്കുന്ന ഫോർമാറ്റിൽ ഒരു HTTP അഭ്യർത്ഥന അയയ്ക്കണം. അനുവദനീയമായ പൊതു റൂട്ടുകളിലെ പൊതു HTTPS ലക്ഷ്യങ്ങൾക്ക് SOCKS പ്രോക്സി പട്ടിക സാധ്യതയുള്ള എൻഡ്പോയിന്റുകൾ നൽകുന്നു; സെർവറിന്റെ പതിപ്പും ഹോസ്റ്റ്നെയിം പിന്തുണയും ഈ Java സോക്കറ്റ് പാതയുമായി പൊരുത്തപ്പെടുത്തുക.

ഉദാഹരണത്തിലെ രണ്ട് ഐഡന്റിറ്റികൾ വായിക്കുക

127.0.0.1:1080 പ്രോക്സി എൻഡ്പോയിന്റാണ്, ഈ Java പ്രോസസ്സിൽ നിന്ന് എത്താവുന്നത്. destination, destinationPort എന്നിവ വെബ്സൈറ്റ് തിരിച്ചറിയുന്നു. createUnresolved ക്ലൈന്റിൽ മുൻകൂട്ടി പരിഹരിക്കുന്നതിനുപകരം ആ ഹോസ്റ്റ്നെയിം SOCKS പാതയ്ക്കായി നിലനിർത്തുന്നു.

പാളിച്ചേർത്ത createSocket ലക്ഷ്യസ്ഥാനത്തിന്റെ ഐഡന്റിറ്റി സ്വീകരിക്കുന്നു. setEndpointIdentificationAlgorithm("HTTPS") അതിന്റെ ഹോസ്റ്റ്നെയിം പരിശോധനകൾ വ്യക്തമായി അഭ്യർത്ഥിക്കുന്നു. അസംസ്കൃത SSLSocket-ന്റെ സർട്ടിഫിക്കറ്റ്-ചെയിൻ വിശ്വാസം ഹോസ്റ്റ്നെയിം പരിശോധന പ്രവർത്തനക്ഷമമാണെന്ന് സ്വയം തെളിയിക്കുന്നില്ല. പൊരുത്തക്കേട് അടിച്ചമർത്താൻ പ്രോക്സിയുടെ പേരോ loopback-ഓ മാറ്റിസ്ഥാപിക്കുന്നത് തെറ്റായ എൻഡ്പോയിന്റ് പ്രാമാണീകരിച്ചേക്കാം.

വിശ്വാസവും വൃത്തിയാക്കലും അവയുടെ ഘട്ടങ്ങളിൽ നിലനിർത്തുക

ഡിഫോൾട്ട് ഫാക്ടറി JVM-ന്റെ കോൺഫിഗർ ചെയ്ത വിശ്വാസ ക്രമീകരണം ഉപയോഗിക്കുന്നു. സ്വകാര്യ ആവശ്യകതകളുള്ള ഒരു ആപ്ലിക്കേഷന് പകരം അതിന്റെ ശരിയായി ആരംഭിച്ച SSLContext ഫാക്ടറി ഉപയോഗിക്കാം. ആ തിരഞ്ഞെടുപ്പ് SOCKS പാതയിൽ നിന്ന് വേറിട്ടതാണ്; എല്ലാ സർട്ടിഫിക്കറ്റും സ്വീകരിക്കുന്ന ഒരു ട്രസ്റ്റ് മാനേജർ തെറ്റായ പിയർ പേര് പരിഹരിക്കുന്നില്ല.

SOCKS നിരസിക്കൽ TLS-ന് മുമ്പ് സംഭവിക്കുന്നു; വിശ്വസിക്കാനാകാത്ത സർട്ടിഫിക്കറ്റോ തെറ്റായ ഹോസ്റ്റ്നെയിമോ TLS സമയത്ത് പരാജയപ്പെടുന്നു; അതിനുശേഷം ഒരു HTTP പിശക് വന്നേക്കാം. പ്രോക്സിയിലേക്കുള്ള ലോഗിൻ ടണൽ അഭ്യർത്ഥന അധികാരപ്പെടുത്തുന്നു, അതിനുള്ളിലെ വെബ്സൈറ്റ് പ്രാമാണീകരിക്കുന്നില്ല.

സ്വയമേവയുള്ള അടയ്ക്കൽ പ്രവർത്തനക്ഷമമാക്കി പാളിച്ചേർത്ത സോക്കറ്റ് അടയ്ക്കുന്നത് അതിന്റെ ഗതാഗതം അടയ്ക്കുന്നു. സാധാരണ പൂർത്തീകരണത്തിന് മുമ്പ് റാപ്പിംഗോ ഹാൻഡ്ഷേക്കോ പരാജയപ്പെട്ടാൽ പുറം വിഭവ പരിധിയും ആ ഗതാഗതം അടയ്ക്കുന്നു.

അനുബന്ധ ലേഖനങ്ങൾ