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 OkHttpClient.

Disclaimer

The source code provided here is for educational purposes only. While the Java source code compiles without errors, it is not configured to execute directly. You are encouraged to modify and adapt the code to suit your needs. Please note that any modifications or executions of the code are done at your own risk. The authors and distributors of this code are not responsible for any consequences resulting from its use.

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.

   • Example pom.xml

3KB

pom.xml

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.

package com.example;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.Socket;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import com.subgraph.orchid.TorClient;

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class MultiThreadedTorProxy {
    private static final String TARGET_URL = "http://127.0.0.1:8080";
    private static final int NUM_THREADS = 1;

    public static void main(String[] args) {
        // Initialize Tor
        TorClient torClient = new TorClient();
        System.out.println("Starting Tor client...");
        String torProxyHost = "127.0.0.1";
        int torProxyPort = 9050;

        try {
            torClient.start();
            torClient.enableSocksListener(torProxyPort); // Default SOCKS port
        } catch (Exception e) {
            e.printStackTrace();
        }

        // Ensure Tor is fully started
        while (!isSocksPortOpen(torProxyHost, torProxyPort)) {
            try {
                System.out.println("Waiting for Tor to start...");
                Thread.sleep(1000); // Check every 1 second
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        System.out.println("Tor proxy is running on port 9050");

        // Set up ExecutorService for multithreading
        ExecutorService executor = Executors.newFixedThreadPool(NUM_THREADS);
        Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress(torProxyHost, torProxyPort));
        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);
                System.out.println("Thread " + i + " sleeping for " + delay + " ms");
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }

            // Submit tasks to the executor
            executor.submit(() -> {
                OkHttpClient client = new OkHttpClient.Builder()
                        .proxy(proxy)
                        .build();

                Request request = new Request.Builder()
                        .url(TARGET_URL)
                        .get()
                        // .post(RequestBody.create(
                        // MediaType.parse("application/json"),
                        // "{\"loginid\":\"yourLoginId\", \"password\":\"yourPassword\",
                        // \"queryId\":\"yourQueryId\"}"))
                        .build();
                System.out.println(request);
                try (Response response = client.newCall(request).execute()) {
                    if (response.body() != null) {
                        System.out.println(response.headers());
                        String content = response.body().string();
                        saveResponseToFile(content);
                    } else {
                        System.out.println("fail empty respond");
                    }
                } catch (IOException 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();
        }
    }

    private static boolean isSocksPortOpen(String host, int port) {
        try (Socket socket = new Socket(host, port)) {
            return true;
        } catch (IOException e) {
            return false;
        }
    }
}

```

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.

mvn clean package

3KB

demo-1.0-SNAPSHOT.jar

1. 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 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.