Secure, Concurrent Web Access Using Java and Tor

A Comprehensive Guide for developing a Secure, Concurrent Web Access Using Java and Tor:

Overview

This guide details how to set up a Java environment to access websites using Tor for anonymity, implement multi-threading with 100 threads, introduce random delays, and save HTTP responses to a file. We will use the Tor Java Library (Orchid) and Apache HttpClient.

Prerequisites

1. Java Development Kit (JDK)

2. Integrated Development Environment (IDE)

3. Tor Browser

4. Maven (Optional for dependency management)

Step 1: Install Required Software

1. Install Java Development Kit (JDK)

• Download and install the JDK from the Oracle website.

• Set up the JAVA_HOME environment variable and add the JDK bin directory to your system's PATH.

2. Install an Integrated Development Environment (IDE)

• Choose an IDE like IntelliJ IDEA, Eclipse, or Visual Studio Code.

• Download and install your preferred IDE.

Step 2: Set Up Your Java Project

1. Create a New Java Project in Your IDE:

   • Open your IDE and create a new Java project.

2. Add Dependencies:

   • If you are using Maven, add the following dependencies to your pom.xml file:

     <dependencies>
         <dependency>
             <groupId>org.apache.httpcomponents</groupId>
             <artifactId>httpclient</artifactId>
             <version>4.5.13</version>
         </dependency>
         <dependency>
             <groupId>com.subgraph.orchid</groupId>
             <artifactId>orchid</artifactId>
             <version>1.0.0</version>
         </dependency>
     </dependencies>

   • If you are not using Maven, download the JAR files for Apache HttpClient and the Tor Java Library (Orchid) and add them to your project’s build path.

Step 3: Implement Tor Integration and Multi-threading

1. Implement Multi-threading with Delay and File Writing:

   • Use ExecutorService to manage a pool of threads.

   • Add a random delay between starting new threads.

   • Save each HTTP response to a file.

import com.subgraph.orchid.TorClient;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.DefaultProxyRoutePlanner;
import org.apache.http.util.EntityUtils;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class MultiThreadedTorProxy {
    private static final String TARGET_URL = "http://example.com";
    private static final int NUM_THREADS = 100;

    public static void main(String[] args) {
        // Initialize Tor
        TorClient torClient = new TorClient();
        torClient.start();
        torClient.enableSocksListener();

        // Ensure Tor is fully started
        while (!torClient.isReady()) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        // Tor SOCKS proxy details
        String torProxyHost = "127.0.0.1";
        int torProxyPort = torClient.getSocksPort();

        // Set up ExecutorService for multithreading
        ExecutorService executor = Executors.newFixedThreadPool(NUM_THREADS);
        HttpHost proxy = new HttpHost(torProxyHost, torProxyPort, "socks");
        DefaultProxyRoutePlanner routePlanner = new DefaultProxyRoutePlanner(proxy);
        Random random = new Random();

        for (int i = 0; i < NUM_THREADS; i++) {
            // Introduce a random delay between 5 to 15 seconds
            try {
                int delay = 5000 + random.nextInt(10000);
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }

            // Submit tasks to the executor
            executor.submit(() -> {
                try (CloseableHttpClient httpClient = HttpClients.custom()
                        .setRoutePlanner(routePlanner)
                        .build()) {
                        
                    // Create a Get request
                    // String getRequestPayload = "?userId=aaa"
                    // HttpGet request = new HttpGet(TARGET_URL+getRequestPayload );
                       
                    // Create POST request
                    HttpPost postRequest = new HttpPost(TARGET_URL);
                    
                    // Set POST request data
                    String json = "{\"loginid\":\"yourLoginId\", \"password\":\"yourPassword\", \"queryId\":\"yourQueryId\"}";
                    StringEntity entity = new StringEntity(json);
                    postRequest.setEntity(entity);
                    postRequest.setHeader("Content-type", "application/json");

                    // Execute the POST request
                    HttpResponse response = httpClient.execute(postRequest);
                    HttpEntity responseEntity = response.getEntity();

                    if (responseEntity != null) {
                        String content = EntityUtils.toString(responseEntity);
                        saveResponseToFile(content);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }

        // Shutdown the executor
        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // Stop Tor client
        torClient.stop();
    }

    private static void saveResponseToFile(String content) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("responses.txt", true))) {
            writer.write(content);
            writer.newLine();
            writer.newLine(); // Separate each response with a new line
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Step 4: Compile and Run the Application

1. Compile Your Java Project:

   • Ensure that all dependencies are properly included and compile your project.

2. Package the Application:

   • Package your application into a JAR file if necessary.

3. Run the Application:

   • Execute the compiled Java application. It will start the Tor client and make concurrent HTTP requests through the Tor network.

   java -cp path/to/your/project.jar MultiThreadedTorProxy

Summary

• Java Development Kit (JDK): Download and install from the Oracle website.

• Integrated Development Environment (IDE): Install IntelliJ IDEA, Eclipse, or VS Code.

• Tor Browser: Download and install from the Tor Project website.

• Dependencies: Add Apache HttpClient and Tor Java Library (Orchid) to your project.

• Multi-threading: Use ExecutorService to manage 100 threads with random delays and save HTTP responses to a file.