PortScanner.java

Go to the documentation of this file.

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 *  Encapsulates port scanning application.
 *  
 *  The instance maintains pool of end-points (to be scanned)
 *  starts worker threads that scan end-points from the pool
 *  and displays progress to the user.
 *  
 *  The static main() entry point facility  parses command
 *  line arguments and starts the single instance of the class.
 *  
 *  @author Mikica B Kocic
 */
public class PortScanner extends Thread implements PortConnect.Context
{
    //////////////////////////////////////////////////////////// CONSTANTS ///////////////
    
    /** Connection timeout constant
     */
    private final static int connectionTimeout = 0;
    
    /** Number of maximum allowed worker threads
     */
    private final static int  maxThreadCount = 1000;
    
    /** Maximum allowed number of end-points to scan
     */
    private final static int maxEndpointsToScan = 1024 * 1024;
    
    /** Should application report failed end-points or not.
     *  Disabled by default: Who is interested in failed ports at all?
     */
    private final static boolean reportFailedEndpoints = false;

    //////////////////////////////////////////////////////////// MEMBERS /////////////////
    
    /** Instance of the lookup database for TCP and UDP service names
     */
    private ServiceNames verboseServices;

    /** Output stream where the results are written
     */
    private PrintStream out;

    //////////////////////////////////////////////////////////////////////////////////////
    /*  The pool of end-points (end-point == IP address + TCP port)
     *  from which the 'next end-point to scan' is retrieved.
     */
    
    /** True if pool is depleted
     */
    private boolean endpointDepleted;
    
    /** The current IP address
     */
    private RawIpAddress currentAddr;
    
    /** The current TCP port
     */
    private int currentPort; 
    
    /** The first IP address in the pool
     */
    private RawIpAddress firstAddr;
    
    /** The last IP address in the pool
     */
    private RawIpAddress lastAddr;
    
    /** The first TCP port in the pool
     */
    private int firstPort;
    
    /** The last TCP port in the pool
     */
    private int lastPort;
    
    //////////////////////////////////////////////////////////////////////////////////////
    /*  Statistics
     */
    
    /** Number of active working threads
     */
    private int workerThreadCount = 0; 
    
    /** Number of scanned end-points
     */
    private int scannedEndpointCount = 0; 
    
    /** Number of connected end-points
     */
    private int okEndpointCount  = 0;
    
    /** Number of failed to connect end-points
     */
    private int failedEndpointCount = 0;
    
    //////////////////////////////////////////////////////////// METHODS /////////////////
    
    /**
     *  Creates instance of the PortScanner worker thread.
     *  
     *  @param firstAddr    the first raw IP address in range
     *  @param lastAddr     the last raw IP address in range
     *  @param firstPort    the first port in range
     *  @param lastPort     the last port in range
     *  @param out          output stream for results
     */
    public PortScanner( 
            RawIpAddress firstAddr, RawIpAddress lastAddr, 
            int firstPort, int lastPort,
            PrintStream out )
    {
        this.firstAddr = firstAddr;
        this.lastAddr  = lastAddr;
        this.firstPort = firstPort;
        this.lastPort  = lastPort;
        this.out       = out;

        this.endpointDepleted = false;

        /* Set currentAddr <= copy of the firstAddr
         */
        this.currentAddr = new RawIpAddress( firstAddr );

        /* Set currentPort <= firstPort
         */
        this.currentPort = firstPort;
    }

    /**
     *  Gets next socket address (end-point) from the pool.
     *  
     *  The next end-point is retrieved by first scanning all addresses in range
     *  keeping the TCP port constant. This means that worker threads do not flood 
     *  the specific IP address with different simultaneous connections on different 
     *  TCP ports all at once.
     *  
     *  The next algorithm clarifies previous explanation:
     * 
     *   for( all ports in range ) { 
     *      for ( all addresses in range ) {
     *          end-point := address + port;
     *          perform scan on end-point;
     *      }
     *   }
     *   
     */
    @Override
    public synchronized InetSocketAddress getNextSocketAddress ()
    {
        InetSocketAddress endpoint = null;

        while( ! endpointDepleted && endpoint == null ) 
        {
            /* Create end-point from the current IP address and the current TCP port
             */
            try {
                InetAddress addr = currentAddr.getInetAddress ();
                endpoint = new InetSocketAddress( addr, currentPort );
            } catch( Exception e ) {
                /* this should not happen; however, skip this address */
                e.printStackTrace ();
            }

            /* Advance to the next end-point 
             */
            currentAddr.increase ();

            if ( currentAddr.compare( lastAddr ) > 0 ) 
            {
                currentAddr.set( firstAddr ); // set currentAddr := firstAddr

                if ( ++currentPort > lastPort ) {
                    currentPort = firstPort; // start the loop all over again
                    endpointDepleted = true; // suppress further 'gets'
                }
            }
        }

        return endpoint;
    }

    /**
     *  Reports information about end-point. 
     *  (Call-back from the scanning worker thread.)
     */
    @Override
    public synchronized void onPortConnected( long threadId, InetSocketAddress addr,
            boolean ok, String error, int timeMillis )
    {
        ++scannedEndpointCount;
        
        if ( ok ) {
            ++okEndpointCount;
        } else {
            ++failedEndpointCount;
        }

        if ( ok || ( ! ok && reportFailedEndpoints ) ) 
        {
            String serviceName = verboseServices.lookup( "tcp", addr.getPort () );
    
            if ( serviceName != null ) {
                out.println( now () 
                        + error + ": " + addr.getAddress() + ":" + addr.getPort ()
                        + " (" + serviceName + ")"
                        + ", Thread " + threadId + ", Elapsed " + timeMillis + " ms" );
            } else {
                out.println( now () 
                        + error + ": " + addr.getAddress() + ":" + addr.getPort ()
                        + ", Thread " + threadId + ", Elapsed " + timeMillis + " ms" );
            }

            out.flush ();
        }
    }

    /**
     *  Call-back from the worker thread reporting that it is alive
     */
    @Override
    public synchronized void workerThreadSignIn( long threadId )
    {
        ++workerThreadCount;
    }
    
    /**
     *  Call-back from the worker thread reporting that it is zombie (dead waiting)
     */
    public synchronized void workerThreadSignOut( long threadId )
    {
        --workerThreadCount;
    }
    
    /**
     *  Gets current time stamp (millis resolution)
     *  
     *  @return time in ISO format 
     */
    private static String now ()
    {
        Calendar cal = Calendar.getInstance ();
        SimpleDateFormat sdf = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss.SSS " );
        return sdf.format( cal.getTime() );
    }
    
    /**
     *  Starts working threads and monitors end-point scanning progress.
     */
    @Override
    public void run()
    {
        long startTime = System.nanoTime ();

        out.println( now () + "Started...\n" );

        /* Load service names
         */
        verboseServices = new ServiceNames( "services.txt" );

        /* Calculate how long it will take to perform the scan
         * (if all ports throw timeouts)
         */
        int addrSpanSize = (int)( lastAddr.subtract( firstAddr ) + 1 );
        int portSpanSize = lastPort - firstPort + 1;
        int endpointCount = addrSpanSize * portSpanSize;

        System.out.println( "\nScanning " 
                + addrSpanSize + " hosts * " 
                + portSpanSize + " ports/host = total "
                + endpointCount + " end-points..."
                );
        
        /* Ensure that we do not scan impossible range of end-points
         */
        if ( endpointCount >= maxEndpointsToScan ) {
            String error = "Error: Cowardly refusing to scan more than " 
                + maxEndpointsToScan + " end-points!\n\n"
                + "If you really wanted to scan " + endpointCount + " end-points, "
                + "please start multiple instances of the port scanner "
                + "(either sequantially or in parallel).\n";
            
            out.println( now () + error ); 
            out.println( now () + "Completed." );
            
            System.err.println( "\n" + error ); 
            System.out.println( "Completed." );
            
            out.flush ();
            out.close ();
            
            return;
        }
        
        /* Start port scanner working threads (see PortConnect.run()) in the pool.
         * 
         */
        ExecutorService threadPool = Executors.newFixedThreadPool( maxThreadCount );
        for ( int i = 0; i < maxThreadCount; ++ i )
        {
            threadPool.execute( new PortConnect( this, connectionTimeout ) );
        }
        
        /* Wait all threads to complete. While waiting, display the progress.
         */
        while( true )
        {
            try {
                Thread.sleep( 1000 );
            } catch( InterruptedException e ) {
                break;
            }

            synchronized( this )
            {
                /* Display progress...
                 */
                int elapsed = (int) ( ( System.nanoTime () - startTime ) / 1000000000l );
                
                System.out.print(
                        "\rElapsed " + elapsed + " sec; "
                        + "Scanned " + scannedEndpointCount
                        + " of " + endpointCount
                        + " end-points (" + okEndpointCount
                        + " alive + " + failedEndpointCount
                        + " dead); " + workerThreadCount 
                        + " threads active                 "
                        );
                System.out.flush ();
                
                /* Done if no more working threads.
                 */
                if ( workerThreadCount <= 0) {
                    break;
                }
            }
        }

        /* Be nice and clean-up...
         */
        out.println( "\n" + now() + "Completed." );

        out.flush ();
        out.close ();
        
        threadPool.shutdownNow ();
        
        System.out.println( "\nCompleted." );
    }

    /**
     *  Parses arguments then starts port scanner worker thread.
     *  
     *  @param args
     */
    public static void main( String[] args )
    {
        if ( args.length < 5 ) {
            System.err.println( 
                    "\nUsage: java -jar portScan.jar "
                    + "startAddr stopAddr startPort stopPort resultFile\n"
                    );
            System.exit( 0 );
        }

        String firstHostname = args[0];
        String lastHostname  = args[1];
        
        //////////////////////////////////////////////////////////////////////////////////
        
        /* Get the first raw IP address in range to scan
         */
        RawIpAddress firstAddr = null;
        try {
            firstAddr = new RawIpAddress( firstHostname );
        }  catch( UnknownHostException e ) {
            System.err.println( 
                    "\nError: Failed to parse startAddr " + firstHostname + "\n"
                    + e.toString () );
            System.exit( 0 );
        }

        //////////////////////////////////////////////////////////////////////////////////
        
        /* Get the last raw IP address in range to scan
         */
        RawIpAddress lastAddr = null;
        try {
            lastAddr = new RawIpAddress( lastHostname );
        } catch( UnknownHostException e ) {
            System.err.println( 
                    "\nError: Failed to parse stopAddr " + lastHostname + "\n"
                    + e.toString () );
            System.exit( 0 );
        }

        //////////////////////////////////////////////////////////////////////////////////
        
        /* Ensure not to mix IPv4 and IPv6 addresses
         */
        if ( ! firstAddr.isSameVersion( lastAddr ) ) {
            System.err.println( 
                    "\nError: The first and last IP addresses must be of the same IP version\n"
                    );
            System.exit( 0 );
        }

        //////////////////////////////////////////////////////////////////////////////////
        
        /* Ensure that the first is less then or equal the last IP address
         */
        long spanSize = lastAddr.subtract( firstAddr ) + 1; 
        if ( spanSize <= 0 ) {
            System.out.println( 
                    "\nWarning: The first IP address is greater than the last "
                    + "IP address.\nSwapping IP addresses...\n"
                    );
            RawIpAddress temp = firstAddr; firstAddr = lastAddr; lastAddr = temp;
        }

        //////////////////////////////////////////////////////////////////////////////////
        
        /* Parse the first port in range
         */
        int firstPort = -1;
        try {
            firstPort = Integer.parseInt( args[2] );
        } catch( NumberFormatException e ) {
            /* will fail later */
        }
        if ( firstPort < 0 ) {
            System.err.println( 
                    "\nError: The startPort must be integer between 0 and 65535\n"
                    );
            System.exit( 0 );
        }
        
        //////////////////////////////////////////////////////////////////////////////////
        
        /* Parse the last port in range
         */
        int lastPort  = 80;
        try {
            lastPort = Integer.parseInt( args[3] );
        } catch( NumberFormatException e ) {
            /* will fail later */
        }
        if ( lastPort < 0 ) {
            System.err.println( 
                    "\nError: The stopPort must be integer between 0 and 65535\n"
                    );
            System.exit( 0 );
        }

        //////////////////////////////////////////////////////////////////////////////////
        
        /* Ensure that the first port is less or equal than the last port
         */
        if ( firstPort > lastPort ) {
            System.out.println( 
                    "\nWarning: The first TCP port is greater than the last "
                    + "TCP port.\nSwapping TCP ports...\n"
                    );
            
            int temp = firstPort; firstPort = lastPort; lastPort = temp;
        }
        
        //////////////////////////////////////////////////////////////////////////////////
        
        /* Open the results file
         */
        String result = args[4];

        PrintStream out = null;
        try {
            FileOutputStream file = new FileOutputStream( result );
            out = new PrintStream( file );
        } catch( IOException e ) {
            System.err.println( 
                    "\nError: Failed to open file '" + result + "' for writing\n"
                    + e.toString () );
            System.exit( 0 );
        }

        //////////////////////////////////////////////////////////////////////////////////
        
        /* We have all parameters valid now.
         * Create the instance of the port scanner and start its main thread...
         */
        PortScanner ps = new PortScanner( firstAddr, lastAddr, firstPort, lastPort, out );
        ps.start ();
    }
}

/*! 
 *  \mainpage Port Scanner
 *
 *  \section s_intro Introduction
 *  
 *  The package implements solution to \ref p_task as a part of 
 *  the <a href="http://dsv.su.se/utbildning/distans/ip1" target="_blank"><b>SU/IP1 
 *  course</b></a>.
 *  
 *  \section s_desc Description
 *  
 *  The application scans a range of TCP ports for services on the hosts belonging 
 *  to a specified range  of IP addresses (IPv4 or IPv6).
 *  
 *  The application main entry point PortScanner.main() parses command
 *  line arguments and starts the single instance of the PortScanner class.
 *  
 *  The instance of PortScanner class maintains pool of end-points (= IP
 *  address + TCP port) to be scanned. It also starts worker threads (that should
 *  scan end-points from the pool) and displays progress to the user.
 *  
 *  The PortConnect class encapsulates port scanning worker thread. 
 *  The thread retrieves end-points from the owner's pool and reports (with a call-back) 
 *  what was found on the particular end-point.
 *  
 *  TCP port names are retrieved using instances of the ServiceNames class.
 *  
 *  The RawIpAddress class encapsulates arithmetics for raw IPv4/v6 addresses.
 *  
 *  \section s_usage Usage
 *  \verbatim
    $ java -jar portScan.jar
    
    Usage: java -jar portScan.jar startAddr stopAddr startPort stopPort resultFile \endverbatim
 *  
 *   - \a startAddr - the first IPv4/v6 IP address (or host name) in range
 *   - \a stopAddr  - the last IPv4/v6 IP address (or host name) in range
 *   - \a startPort - the first TCP port in range
 *   - \a stopPort  - the last TCP port in range
 *   - \a resultFile - the filename where results are written
 *  
 *  The application will ensure that \a startAddr is <= \a stopAddr and that
 *  \a startPort <= \a stopPort (i.e. it will swap addresses and/or ports).
 *  
 *  Note, however, that \a startAddr and \a stopAddr must belong the same IP version:
 *  
    \verbatim
    $ java -jar portScan.jar  2001:0db8:0000:0000:0000:0000:1428:0700 192.168.5.10 1 10 r.txt
    
    Error: The first and last IP addresses must be of the same IP version \endverbatim
 *
 *  \section s_jar Executable
 *  
 *  The jar file of the package can be found <a href="../portScan.jar"><b>here</b></a>.
 *  
 *  \section s_src Source Files
 *  
 *   - \ref PortScanner.java
 *   - \ref PortConnect.java
 *   - \ref RawIpAddress.java
 *   - \ref ServiceNames.java
 *
 *  \section s_examples Examples
 *  \verbatim
    
    $ java -jar portScan.jar  10.0.1.255 10.0.1.1  1024 1  results.txt
    
    Warning: The first IP address is greater than the last IP address.
    Swapping IP addresses...
    
    Warning: The first TCP port is greater than the last TCP port.
    Swapping TCP ports...
    
    Scanning 255 hosts * 1024 ports/host = total 261120 end-points...
    ...
    
    $ java -jar portScan.jar  10.0.1.27 10.0.1.27  1  1024 results.txt
    
    Scanning 1 hosts * 1024 ports/host = total 1024 end-points...
    Elapsed 21 sec; Scanned 1024 of 1024 end-points (16 alive + 1008 dead); 0 threads active
    Completed.   \endverbatim
    
 *  \subsection s_results The sample results:
 *  
 *  \verbatim
    2010-11-22 15:13:15.265 Started...
    
    2010-11-22 15:13:15.484 Connected: /10.0.1.27:25 (smtp), Thread 60, Elapsed 6 ms
    2010-11-22 15:13:15.500 Connected: /10.0.1.27:21 (ftp), Thread 44, Elapsed 24 ms
    2010-11-22 15:13:15.531 Connected: /10.0.1.27:110 (pop3), Thread 220, Elapsed 0 ms
    2010-11-22 15:13:15.546 Connected: /10.0.1.27:119 (nntp), Thread 250, Elapsed 1 ms
    2010-11-22 15:13:15.578 Connected: /10.0.1.27:143 (imap), Thread 294, Elapsed 25 ms
    2010-11-22 15:13:15.578 Connected: /10.0.1.27:22 (ssh), Thread 56, Elapsed 105 ms
    2010-11-22 15:13:15.578 Connected: /10.0.1.27:53 (domain), Thread 114, Elapsed 80 ms
    2010-11-22 15:13:15.734 Connected: /10.0.1.27:465 (smtps), Thread 912, Elapsed 5 ms
    2010-11-22 15:13:15.781 Connected: /10.0.1.27:563 (nntps), Thread 1118, Elapsed 1 ms
    2010-11-22 15:13:15.781 Connected: /10.0.1.27:587 (submission), Thread 1168, Elapsed 0 ms
    2010-11-22 15:13:15.921 Connected: /10.0.1.27:80 (http), Thread 170, Elapsed 398 ms
    2010-11-22 15:13:16.062 Connected: /10.0.1.27:995 (pop3s), Thread 1978, Elapsed 1 ms
    2010-11-22 15:13:16.062 Connected: /10.0.1.27:993 (imaps), Thread 1972, Elapsed 5 ms
    2010-11-22 15:13:19.062 Connected: /10.0.1.27:111 (sunrpc), Thread 230, Elapsed 3499 ms
    2010-11-22 15:13:19.109 Connected: /10.0.1.27:139 (netbios-ssn), Thread 278, Elapsed 3532 ms
    2010-11-22 15:13:19.687 Connected: /10.0.1.27:443 (https), Thread 880, Elapsed 3949 ms
    
    2010-11-22 15:13:37.062 Completed.   \endverbatim
 *  
 */
/*! \page p_task IP1-9.5.1 Uppgift
 *  
 *  Skapa ett fristående program som vid kommando-promten startas med 
 *  
 *  \verbatim
    java PortScanner <host-start> <host-stop> <port-start> <port-stop> <result file> \endverbatim
 *    
 *  som scannar av alla (stream sockets) IP-adresser i intervallet 
 *  <code>&lt;host-start&gt;</code> till <code>&lt;host-stop&gt;</code> 
 *  för alla portar i intervallet <code>&lt;port-start&gt;</code> 
 *  till <code>&lt;port-stop&gt;</code> och skriver resultatet till 
 *  filen <code>&lt;result file&gt;</code>.
 *  
 *  Frivillig utvidgning är att till varje port som är en standarport för någon 
 *  tjänst även ta med tjänstens namn i filen <code>&lt;result file&gt;</code>.
 * 
 *  Observera! En del datoransvariga anser att portskanning är dataintrång och anmäler
 *  sådana till den ISP varifrån man kört skanningen.  
 *
 */