Made port scanner multi threaded

Author: stealthcopter

app/src/main/java/com/stealthcotper/networktools/MainActivity.java

@@ -44,7 +44,7 @@ protected void onCreate(Bundle savedInstanceState) {
 
         InetAddress ipAddress = IPTools.getLocalIPv4Address();
         if (ipAddress != null){
-            editIpAddress.setText(ipAddress.toString());
+            editIpAddress.setText(ipAddress.getHostAddress());
         }
 
         findViewById(R.id.pingButton).setOnClickListener(new View.OnClickListener() {
@@ -198,8 +198,10 @@ private void doPortScan() throws Exception {
         appendResultsText("PortScanning IP: " + ipAddress);
         ArrayList<Integer> openPorts = PortScan.onAddress(ipAddress).setPort(21).doScan();
 
+        final long startTimeMillis = System.currentTimeMillis();
+
         // Perform an asynchronous port scan
-        PortScan.onAddress(ipAddress).setTimeOutMillis(1000).setPortsAll().doScan(new PortScan.PortListener() {
+        PortScan.onAddress(ipAddress).setTimeOutMillis(1000).setPortsAll().setNoThreads(50).doScan(new PortScan.PortListener() {
             @Override
             public void onResult(int portNo, boolean open) {
                 if (open) appendResultsText("Open: " + portNo);
@@ -208,6 +210,7 @@ public void onResult(int portNo, boolean open) {
             @Override
             public void onFinished(ArrayList<Integer> openPorts) {
                 appendResultsText("Open Ports: " + openPorts.size());
+                appendResultsText("Time Taken: " + ((System.currentTimeMillis() - startTimeMillis)/1000.0f));
             }
         });
 

library/src/main/java/com/stealthcopter/networktools/PortScan.java

@@ -1,18 +1,33 @@
 package com.stealthcopter.networktools;
 
 import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
 
 import com.stealthcopter.networktools.portscanning.PortScanTCP;
 
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Created by mat on 14/12/15.
  */
 public class PortScan {
 
+    private int noThreads = 50;
+    private InetAddress address;
+    private int timeOutMillis = 1000;
+    private boolean cancelled = false;
+    private ArrayList<Integer> ports = new ArrayList<>();
+    private ArrayList<Integer> openPortsFound = new ArrayList<>();
+
+    @Nullable
+    private PortListener portListener;
+
     // This class is not to be instantiated
     private PortScan() {
     }
@@ -22,11 +37,6 @@ public interface PortListener{
         void onFinished(ArrayList<Integer> openPorts);
     }
 
-    private InetAddress address;
-    private int timeOutMillis = 1000;
-    private boolean cancelled = false;
-    private ArrayList<Integer> ports = new ArrayList<>();
-
     /**
      * Set the address to ping
      * @param address - Address to be pinged
@@ -54,8 +64,18 @@ public static PortScan onAddress(@NonNull InetAddress ia) {
     }
 
     /**
-     * Set the timeout
+     * Sets the timeout for each port scanned
+     *
+     * If you raise the timeout you may want to consider increasing the thread count {@link #setNoThreads(int)} to compensate.
+     * We can afford to have quite a high thread count as most of the time the thread is just sitting
+     * idle and waiting for the socket to timeout.
+     *
      * @param timeOutMillis - the timeout for each ping in milliseconds
+     * Recommendations:
+     *      Local host: 20 - 500 ms - can be very fast as request doesn't need to go over network
+     *      Local network 500 - 2500 ms
+     *      Remote Scan 2500+ ms
+     *
      * @return this object to allow chaining
      */
     public PortScan setTimeOutMillis(int timeOutMillis){
@@ -172,6 +192,20 @@ private void setAddress(InetAddress address) {
         this.address = address;
     }
 
+
+     /**
+      *
+      * @param noThreads set the number of threads to work with, note we default to a large number
+      *                  as these requests are network heavy not cpu heavy.
+      * @return self
+      * @throws IllegalAccessException - if no threads is less than 1
+      */
+    public PortScan setNoThreads(int noThreads) throws IllegalAccessException {
+        if (noThreads < 1) throw new IllegalArgumentException("Cannot have less than 1 thread");
+        this.noThreads = noThreads;
+        return this;
+    }
+
     /**
      * Cancel a running ping
      */
@@ -180,23 +214,34 @@ public void cancel() {
     }
 
     /**
-     * Perform a synchrnous port scan and return a list of open ports
+     * Perform a synchronous port scan and return a list of open ports
      * @return - ping result
      */
     public ArrayList<Integer> doScan(){
 
         cancelled = false;
+        openPortsFound.clear();
 
-        ArrayList<Integer> openPorts = new ArrayList<>();
+        ExecutorService executor = Executors.newFixedThreadPool(noThreads);
 
         for (int portNo : ports) {
-            if (PortScanTCP.scanAddress(address, portNo, timeOutMillis)){
-                openPorts.add(portNo);
-            }
-            if (cancelled) break;
+            Runnable worker = new PortScanRunnable(address, portNo, timeOutMillis);
+            executor.execute(worker);
+        }
+
+        // This will make the executor accept no new threads
+        // and finish all existing threads in the queue
+        executor.shutdown();
+        // Wait until all threads are finish
+        try {
+            executor.awaitTermination(1, TimeUnit.HOURS);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
         }
 
-        return openPorts;
+        Collections.sort(openPortsFound);
+
+        return openPortsFound;
     }
 
     /**
@@ -206,23 +251,34 @@ public ArrayList<Integer> doScan(){
      */
     public PortScan doScan(final PortListener portListener){
 
+        this.portListener = portListener;
+        openPortsFound.clear();
+        cancelled = false;
+
         new Thread(new Runnable() {
             @Override
             public void run() {
-                cancelled = false;
 
-                ArrayList<Integer> openPorts = new ArrayList<>();
+                ExecutorService executor = Executors.newFixedThreadPool(noThreads);
+
                 for (int portNo : ports) {
-                    boolean open = PortScanTCP.scanAddress(address, portNo, 1000);
-                    if (portListener!=null){
-                        portListener.onResult(portNo, open);
-                        if (open) openPorts.add(portNo);
-                    }
-                    if (cancelled) break;
+                    Runnable worker = new PortScanRunnable(address, portNo, timeOutMillis);
+                    executor.execute(worker);
+                }
+
+                // This will make the executor accept no new threads
+                // and finish all existing threads in the queue
+                executor.shutdown();
+                // Wait until all threads are finish
+                try {
+                    executor.awaitTermination(1, TimeUnit.HOURS);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
                 }
 
                 if (portListener!=null){
-                    portListener.onFinished(openPorts);
+                    Collections.sort(openPortsFound);
+                    portListener.onFinished(openPortsFound);
                 }
 
             }
@@ -231,5 +287,32 @@ public void run() {
         return this;
     }
 
+    private synchronized void portScanned(int port, boolean open){
+        if (open){
+            openPortsFound.add(port);
+        }
+        if (portListener != null) {
+            portListener.onResult(port, open);
+        }
+    }
+
+    private class PortScanRunnable implements Runnable {
+        private final InetAddress address;
+        private final int portNo;
+        private final int timeOutMillis;
+
+        PortScanRunnable(InetAddress address, int portNo, int timeOutMillis) {
+            this.address = address;
+            this.portNo = portNo;
+            this.timeOutMillis = timeOutMillis;
+        }
+
+        @Override
+        public void run() {
+            if (cancelled) return;
+            portScanned(portNo, PortScanTCP.scanAddress(address, portNo, timeOutMillis));
+        }
+    }
+
 
 }

scripts/decrypt-secrets.sh

@@ -3,11 +3,11 @@
 # Following this guide to encrypt / decrypt files
 # https://github.com/circleci/encrypted-files
 
-# Encrypted using openssl 1.1.0g
+# Encrypted using openssl 1.1.0g /usr/local/bin/openssl 
 
 # Encrypt
 #openssl aes-256-cbc -e -in key.p12 -out .circleci/key.p12.enc -k $ANDROID_NETWORK_TOOLS_DECRYPTKEY1
 
 # Decrypt
 openssl aes-256-cbc -d -in .circleci/key.p12.enc -out key.p12 -k $ANDROID_NETWORK_TOOLS_DECRYPTKEY1
-openssl aes-256-cbc -d -in .circleci/keystore.enc -out keystore -k $ANDROID_NETWORK_TOOLS_DECRYPTKEY2
+openssl aes-256-cbc -d -in .circleci/keystore.enc -out keystore -k $ANDROID_NETWORK_TOOLS_DECRYPTKEY2