Socks5Client.java

  1. /**
  2.  *
  3.  * Copyright the original author or authors
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smackx.bytestreams.socks5;

  19. import java.io.DataInputStream;
  20. import java.io.DataOutputStream;
  21. import java.io.IOException;
  22. import java.net.InetSocketAddress;
  23. import java.net.Socket;
  24. import java.net.SocketAddress;
  25. import java.nio.charset.StandardCharsets;
  26. import java.util.Arrays;
  27. import java.util.concurrent.Callable;
  28. import java.util.concurrent.ExecutionException;
  29. import java.util.concurrent.FutureTask;
  30. import java.util.concurrent.TimeUnit;
  31. import java.util.concurrent.TimeoutException;
  32. import java.util.logging.Logger;

  34. import org.jivesoftware.smack.SmackException;
  35. import org.jivesoftware.smack.SmackException.NoResponseException;
  36. import org.jivesoftware.smack.SmackException.NotConnectedException;
  37. import org.jivesoftware.smack.SmackException.SmackMessageException;
  38. import org.jivesoftware.smack.XMPPException;
  39. import org.jivesoftware.smack.util.Async;
  40. import org.jivesoftware.smack.util.CloseableUtil;

  42. import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream.StreamHost;

  44. /**
  45.  * The SOCKS5 client class handles establishing a connection to a SOCKS5 proxy. Connecting to a
  46.  * SOCKS5 proxy requires authentication. This implementation only supports the no-authentication
  47.  * authentication method.
  48.  *
  49.  * @author Henning Staib
  50.  */
  51. public class Socks5Client {

  53.     private static final Logger LOGGER = Logger.getLogger(Socks5Client.class.getName());

  55.     /* stream host containing network settings and name of the SOCKS5 proxy */
  56.     protected StreamHost streamHost;

  58.     /* SHA-1 digest identifying the SOCKS5 stream */
  59.     protected String digest;

  61.     /**
  62.      * Constructor for a SOCKS5 client.
  63.      *
  64.      * @param streamHost containing network settings of the SOCKS5 proxy
  65.      * @param digest identifying the SOCKS5 Bytestream
  66.      */
  67.     public Socks5Client(StreamHost streamHost, String digest) {
  68.         this.streamHost = streamHost;
  69.         this.digest = digest;
  70.     }

  72.     /**
  73.      * Returns the initialized socket that can be used to transfer data between peers via the SOCKS5
  74.      * proxy.
  75.      *
  76.      * @param timeout timeout to connect to SOCKS5 proxy in milliseconds
  77.      * @return socket the initialized socket
  78.      * @throws IOException if initializing the socket failed due to a network error
  79.      * @throws TimeoutException if connecting to SOCKS5 proxy timed out
  80.      * @throws InterruptedException if the current thread was interrupted while waiting
  81.      * @throws XMPPException if an XMPP protocol error was received.
  82.      * @throws SmackMessageException if there was an error.
  83.      * @throws NotConnectedException if the XMPP connection is not connected.
  84.      * @throws NoResponseException if there was no response from the remote entity.
  85.      */
  86.     public Socket getSocket(int timeout) throws IOException, InterruptedException,
  87.                     TimeoutException, XMPPException, SmackMessageException, NotConnectedException, NoResponseException {
  88.         // wrap connecting in future for timeout
  89.         FutureTask<Socket> futureTask = new FutureTask<>(new Callable<Socket>() {

  91.             @Override
  92.             public Socket call() throws IOException, SmackMessageException {

  94.                 // initialize socket
  95.                 Socket socket = new Socket();
  96.                 SocketAddress socketAddress = new InetSocketAddress(streamHost.getAddress().asInetAddress(),
  97.                                 streamHost.getPort());
  98.                 socket.connect(socketAddress);

  100.                 // initialize connection to SOCKS5 proxy
  101.                 try {
  102.                     establish(socket);
  103.                 }
  104.                 catch (SmackMessageException e) {
  105.                     if (!socket.isClosed()) {
  106.                         CloseableUtil.maybeClose(socket, LOGGER);
  107.                     }
  108.                     throw e;
  109.                 }

  111.                 return socket;
  112.             }

  114.         });
  115.         Async.go(futureTask, "SOCKS5 client connecting to " + streamHost);

  117.         // get connection to initiator with timeout
  118.         try {
  119.             return futureTask.get(timeout, TimeUnit.MILLISECONDS);
  120.         }
  121.         catch (ExecutionException e) {
  122.             throw new IOException("ExecutionException while SOCKS5 client attempting to connect to " + streamHost, e);
  123.         }

  125.     }

  127.     /**
  128.      * Initializes the connection to the SOCKS5 proxy by negotiating authentication method and
  129.      * requesting a stream for the given digest. Currently only the no-authentication method is
  130.      * supported by the Socks5Client.
  131.      *
  132.      * @param socket connected to a SOCKS5 proxy
  133.      * @throws IOException if an I/O error occurred.
  134.      * @throws SmackMessageException if there was an error.
  135.      */
  136.     protected void establish(Socket socket) throws IOException, SmackMessageException {

  138.         byte[] connectionRequest;
  139.         byte[] connectionResponse;
  140.         /*
  141.          * use DataInputStream/DataOutputStream to assure read and write is completed in a single
  142.          * statement
  143.          */
  144.         DataInputStream in = new DataInputStream(socket.getInputStream());
  145.         DataOutputStream out = new DataOutputStream(socket.getOutputStream());

  147.         // authentication negotiation
  148.         byte[] cmd = new byte[3];

  150.         cmd[0] = (byte) 0x05; // protocol version 5
  151.         cmd[1] = (byte) 0x01; // number of authentication methods supported
  152.         cmd[2] = (byte) 0x00; // authentication method: no-authentication required

  154.         out.write(cmd);
  155.         out.flush();

  157.         byte[] response = new byte[2];
  158.         in.readFully(response);

  160.         // check if server responded with correct version and no-authentication method
  161.         if (response[0] != (byte) 0x05 || response[1] != (byte) 0x00) {
  162.             throw new SmackException.SmackMessageException("Remote SOCKS5 server responded with unexpected version: " + response[0] + ' ' + response[1] + ". Should be 0x05 0x00.");
  163.         }

  165.         // request SOCKS5 connection with given address/digest
  166.         connectionRequest = createSocks5ConnectRequest();
  167.         out.write(connectionRequest);
  168.         out.flush();

  170.         // receive response
  171.         connectionResponse = Socks5Utils.receiveSocks5Message(in);

  173.         // verify response
  174.         connectionRequest[1] = (byte) 0x00; // set expected return status to 0
  175.         if (!Arrays.equals(connectionRequest, connectionResponse)) {
  176.             throw new SmackException.SmackMessageException(
  177.                             "Connection request does not equal connection response. Response: "
  178.                                             + Arrays.toString(connectionResponse) + ". Request: "
  179.                                             + Arrays.toString(connectionRequest));
  180.         }
  181.     }

  183.     /**
  184.      * Returns a SOCKS5 connection request message. It contains the command "connect", the address
  185.      * type "domain" and the digest as address.
  186.      * <p>
  187.      * (see <a href="http://tools.ietf.org/html/rfc1928">RFC1928</a>)
  188.      *
  189.      * @return SOCKS5 connection request message
  190.      */
  191.     private byte[] createSocks5ConnectRequest() {
  192.         byte[] addr = digest.getBytes(StandardCharsets.UTF_8);

  194.         byte[] data = new byte[7 + addr.length];
  195.         data[0] = (byte) 0x05; // version (SOCKS5)
  196.         data[1] = (byte) 0x01; // command (1 - connect)
  197.         data[2] = (byte) 0x00; // reserved byte (always 0)
  198.         data[3] = (byte) 0x03; // address type (3 - domain name)
  199.         data[4] = (byte) addr.length; // address length
  200.         System.arraycopy(addr, 0, data, 5, addr.length); // address
  201.         data[data.length - 2] = (byte) 0; // address port (2 bytes always 0)
  202.         data[data.length - 1] = (byte) 0;

  204.         return data;
  205.     }

  207. }
Created with JaCoCo 0.8.6.202009150832