Authenticating to Socks proxy using different accounts in a given JVM

Question

I have a J2EE application that runs some background jobs. Each of these background jobs need to connect to an external FTP server. However, all connections must go through a central SOCKS proxy server. The SOCKS proxy server is set up to require authentication using user names and passwords. Everything works fine if I've to use this SOCKS proxy with "a set" of credentials across all background jobs. However, if I want Job1 to use "user1" for SOCKS login, and Job2 to use "user2" for SOCKS login, I can't seem to find a way to do this. I need this functionality for accounting purposes. Any help on how this can be accomplished is greatly appreciated.
Regards,
Sai Pullabhotla

Answer 1

I tried implementing the ThreadLocal idea and I think the code is working as expected, but my proxy logs are not matching up with what the code says. Below is the code I've including a test class. See below the code for my additional comments.
import java.net.Authenticator;
import java.net.PasswordAuthentication;
* A customer authenticator for authenticating with SOCKS Proxy servers.
public class ProxyAuthenticator extends Authenticator {
      * A thread local for storing the credentials to the SOCKS proxy. The Javadoc
      * for ThreadLocal says they are typically used for static fields, but
      * here I've a singleton instance. Hope this is not an issue.
     private ThreadLocal<PasswordAuthentication> credentials = null;
      * Singleton instance.
     private static ProxyAuthenticator instance = null;
      * Creates a new instance of <code>ProxyAuthenticator</code>. Each thread
      * will have its own copy of credentials, which would be <code>null</code>
      * initially. Each thread must call the <code>setCredentials</code> method
      * to set the proxy credentials if needed.
     private ProxyAuthenticator() {
          credentials = new ThreadLocal<PasswordAuthentication>() {
               @Override
               protected PasswordAuthentication initialValue() {
                    System.out.println("ThreadLocal initialized for "
                         + Thread.currentThread().getName());
                    return null;
               @Override
               public void set(PasswordAuthentication value) {
                    System.out.println(Thread.currentThread().getName() + " SET");
                    super.set(value);
               @Override
               public PasswordAuthentication get() {
                    System.out.println(Thread.currentThread().getName() + " GET");
                    return super.get();
      * Returns the singleton instance of this class.
      * @return the singleton instance of this class.
     public static synchronized ProxyAuthenticator getInstance() {
          if (instance == null) {
               instance = new ProxyAuthenticator();
          return instance;
      * Sets the proxy creditials. This method updates the ThreadLocal variable.
      * @param user
      *            the user name
      * @param password
      *            the password
     public void setCredentials(String user, String password) {
          credentials.set(new PasswordAuthentication(user, password.toCharArray()));
     @Override
     public PasswordAuthentication getPasswordAuthentication() {
          System.out.println("Requesting host: " + this.getRequestingHost());
          System.out.println("Requesting port: " + this.getRequestingPort());
          System.out.println("Requesting protocol: "
               + this.getRequestingProtocol());
          System.out.println("Requesting prompt: " + this.getRequestingPrompt());
          System.out.println("Requesting scheme: " + this.getRequestingScheme());
          System.out.println("Requesting site: " + this.getRequestingSite());
          System.out.println("Requesting URL: " + this.getRequestingURL());
          System.out.println("Requestor type: " + this.getRequestorType());
          System.out.println(Thread.currentThread().getName()
               + " Authenitcator returning credentials "
               + credentials.get().getUserName() + ":"
               + new String(credentials.get().getPassword()));
          return credentials.get();
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Authenticator;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.Socket;
import java.net.Proxy.Type;
* A test class for testing the {@link ProxyAuthenticator}.
public class SocksProxyTest implements Runnable {
      * Socks proxy host, used by the FakeFtpClient
     private static final String SOCKS_PROXY_HOST = "192.168.1.240";
      * Target FTP host to connect to
     private String host = null;
      * Proxy user
     private String proxyUser = null;
      * Proxy password
     private String proxyPassword = null;
      * Creates a new instance of <code>SocksProxyTest</code>
      * @param host
      *            the target FTP host
      * @param proxyUser
      *            proxy user
      * @param proxyPassword
      *            proxy password
     public SocksProxyTest(String host, String proxyUser, String proxyPassword) {
          this.host = host;
          this.proxyUser = proxyUser;
          this.proxyPassword = proxyPassword;
     public void run() {
          // Create the FakeFtpClient
          FakeFtpClient test = new FakeFtpClient(host, 21, proxyUser,
               proxyPassword);
          for (int j = 0; j < 5; j++) {
               try {
                    test.connect();
                    test.disconnect();
                    // Thread.sleep(10000);
               catch (Throwable t) {
                    t.printStackTrace();
      * Test run.
      * @param args
      *            command line arguments
      * @throws IOException
      *             propagated
     public static void main(String[] args) throws IOException {
          // Get the singleton instance of the ProxyAuthenticator.
          ProxyAuthenticator authenticator = ProxyAuthenticator.getInstance();
          // Update the default authenticator to our ProxyAuthenticator
          Authenticator.setDefault(authenticator);
          // Array of FTP hosts we want to connect to
          final String[] ftpHosts = { "192.168.1.53", "192.168.1.54",
                    "192.168.1.55" };
          // Proxy login/user names to connect to each of the above hosts
          final String[] users = { "User-001", "User-002", "User-003" };
          // Proxy passwords for each of the above user names (in this case
          // password == username).
          final String[] passwords = users;
          // For each target FTP host
          for (int i = 0; i < 3; i++) {
               // Create the SocksProxyTest instance with the target host, proxy
               // user and proxy password
               SocksProxyTest spt = new SocksProxyTest(ftpHosts, users[i],
                    passwords[i]);
               // Create a new thread and start it
               Thread t = new Thread(spt);
               t.setName("T" + (i + 1));
               try {
                    t.join();
               catch (InterruptedException e) {
                    e.printStackTrace();
               t.start();
     * A fake FTP client. The connect method connects to the given host, reads
     * the first line the server sends. Does nothing else. The disconnect method
     * closes the socket.
     private static class FakeFtpClient {
          * The FTP host
          private String host = null;
          * The FTP port
          private int port = 0;
          * Proxy login/user name
          private String proxyUser = null;
          * Proxy password
          private String proxyPassword = null;
          * Socket to the target host
          private Socket s = null;
          * Creates a new instance of <code>FakeFtpClient</code>
          * @param host
          * the FTP host
          * @param port
          * the FTP port
          * @param proxyUser
          * Proxy user
          * @param proxyPassword
          * Proxy password
          public FakeFtpClient(String host, int port, String proxyUser,
               String proxyPassword) {
               this.host = host;
               this.port = port;
               this.proxyUser = proxyUser;
               this.proxyPassword = proxyPassword;
          * Connects to the target FTP host through the specified Socks proxy and
          * proxy authentication. Reads the first line of the welcome message.
          * @throws IOException
          * propagated
          public void connect() throws IOException {
               System.out.println(Thread.currentThread().getName()
                    + " Connecting to " + host + " ...");
               // Update the ProxyAuthenticator with the correct credentials for
               // this thread
               ProxyAuthenticator.getInstance().setCredentials(proxyUser,
                    proxyPassword);
               s = new Socket(new Proxy(Type.SOCKS, new InetSocketAddress(
                    SOCKS_PROXY_HOST, 1080)));
               s.setSoTimeout(10000);
               s.connect(new InetSocketAddress(host, port), 10000);
               System.out.println(Thread.currentThread().getName() + " Connected");
               BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(
                    s.getOutputStream()));
               BufferedReader reader = new BufferedReader(new InputStreamReader(
                    s.getInputStream()));
               System.out.println(reader.readLine());
          * Closes the socket.
          public void disconnect() {
               System.out.println(Thread.currentThread().getName()
                    + " Disconnecting...");
               if (s != null) {
                    try {
                         s.close();
                         System.out.println(Thread.currentThread().getName()
                              + " Disconnected");
                    catch (IOException e) {
                         e.printStackTrace();
Looking at the test class, it creates 3 threads T1, T2 and T3. T1 is setup to connect to 192.168.1.53 using a proxy user User-001 and T2 is setup to connect to 192.168.1.54 using proxy user User-002 and T3 connects to 192.168.1.55 using proxy user User-003.
Each thread then loops 5 times to connect to their target servers and disconnect each time. All the debug (System.out) statements indicate that the getPasswordAuthentication is returning the correct credentials for each thread. However, when I look at the logs on the proxy server, the results are different and arbitrary.
Below is the proxy log:
[2011-01-24 11:10:11] 192.168.1.240 User-001 SOCKS5 CONNECT 192.168.1.54:21
[2011-01-24 11:10:11] 192.168.1.240 User-002 SOCKS5 CONNECT 192.168.1.53:21
[2011-01-24 11:10:11] 192.168.1.240 User-002 SOCKS5 CONNECT 192.168.1.55:21
[2011-01-24 11:10:11] 192.168.1.240 User-003 SOCKS5 CONNECT 192.168.1.55:21
[2011-01-24 11:10:11] 192.168.1.240 User-003 SOCKS5 CONNECT 192.168.1.55:21
[2011-01-24 11:10:11] 192.168.1.240 User-003 SOCKS5 CONNECT 192.168.1.55:21
[2011-01-24 11:10:11] 192.168.1.240 User-003 SOCKS5 CONNECT 192.168.1.55:21
[2011-01-24 11:10:11] 192.168.1.240 User-003 SOCKS5 CONNECT 192.168.1.54:21
[2011-01-24 11:10:11] 192.168.1.240 User-002 SOCKS5 CONNECT 192.168.1.53:21
[2011-01-24 11:10:12] 192.168.1.240 User-001 SOCKS5 CONNECT 192.168.1.54:21
[2011-01-24 11:10:12] 192.168.1.240 User-002 SOCKS5 CONNECT 192.168.1.53:21
[2011-01-24 11:10:12] 192.168.1.240 User-001 SOCKS5 CONNECT 192.168.1.54:21
[2011-01-24 11:10:12] 192.168.1.240 User-002 SOCKS5 CONNECT 192.168.1.53:21
[2011-01-24 11:10:12] 192.168.1.240 User-001 SOCKS5 CONNECT 192.168.1.54:21
[2011-01-24 11:10:13] 192.168.1.240 User-002 SOCKS5 CONNECT 192.168.1.53:21
As you can see from the first line in the log, the proxy says User-001 connected to 192.168.1.54, but the code should always connect to 192.168.1.53 with user User-001.
Any idea on what might be going on?