path: root/src/main/java/com/it_jaros/jscanner/Scanner.java

package com.it_jaros.jscanner;

import java.io.IOException;
import java.io.InputStream;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.LockSupport;

public class Scanner implements AutoCloseable {

    private static final int READ_BUFFER_SIZE = 1024;

    private volatile boolean cancelled = false;

    private final Semaphore socketLimit;
    private final boolean bannerRecognition;
    private final boolean disableOnlineCheck;
    private final int maxHostsLimit;
    private final int maxWorkersPerHost;
    private final int timeoutInMillis;
    private final long delayInNanos;
    private final Phaser runningScans = new Phaser(0);

    public Scanner(
            int socketLimit,
            int timeoutInMillis,
            int delayInMillis,
            int maxWorkersPerHost,
            int maxHostsLimit,
            boolean disableOnlineCheck,
            boolean bannerRecognition
    ) {
        this.delayInNanos = TimeUnit.MILLISECONDS.toNanos(Math.max(0, delayInMillis));
        this.bannerRecognition = bannerRecognition;
        this.disableOnlineCheck = disableOnlineCheck;
        this.maxHostsLimit = maxHostsLimit;
        this.maxWorkersPerHost = maxWorkersPerHost;
        this.socketLimit = new Semaphore(socketLimit);
        this.timeoutInMillis = timeoutInMillis;
    }

    public Scanner(ScanOptions options) {
        this(options.openSocketLimit(), options.timeoutInMillis(), options.delayInMillis(), options.maxWorkersPerHost(), options.maxHostsLimit(), options.disableHostCheck(), options.bannerRecognition());
    }


    public List<ScanResult> runScan(Scan scan) {
        if (scan == null) {
            throw new IllegalArgumentException("Scan argument cannot be null");
        }

        scan.start();
        runningScans.register();
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            CompletionService<ScanResult> completionService = new ExecutorCompletionService<>(executor);
            Queue<String> hostsInQueue = new ArrayDeque<>(scan.getHosts());

            int hostsToProcess = hostsInQueue.size();
            int activeHostWorkers = 0;
            while ((hostsToProcess > 0 && !cancelled) || activeHostWorkers > 0) {
                // process queue
                while (
                        !hostsInQueue.isEmpty() // continue as long as we have hosts to process
                                && activeHostWorkers < maxHostsLimit // limit is not reached
                                && !cancelled // and scanner not closed
                ) {
                    activeHostWorkers++;
                    final String host = hostsInQueue.poll();
                    completionService.submit(() -> scanHostPorts(host, scan.getPorts(), scan));
                }

                try {
                    Future<ScanResult> finishedHost = completionService.poll(10, TimeUnit.MILLISECONDS);
                    if (finishedHost == null) {
                        continue;
                    }
                    activeHostWorkers--;
                    hostsToProcess--;
                    scan.addScanResult(finishedHost.get());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } catch (ExecutionException e) {
                    System.out.printf("%s -> %s%n", e.getClass().getSimpleName(), e.getMessage());
                }
            }
        } finally {
            runningScans.arriveAndDeregister();
        }

        scan.stop();
        return scan.getResults();
    }

    private ScanResult scanHostPorts(String host, String ports, Scan scan) {
        PortRange portRange = new PortRange(ports);
        BitSet openPorts = new BitSet(PortRange.MAX_PORT);
        BitSet filteredPorts = new BitSet(PortRange.MAX_PORT);
        HashMap<Integer, ServiceType> serviceTypes = new HashMap<>();

        // Give progressbar the current progress object which is then updated in the sub virtual threads
        Progress progress = new Progress(host, portRange.getTotal(), new AtomicInteger(), new AtomicInteger(), new AtomicInteger());
        scan.addHostProgress(progress);

        if (!disableOnlineCheck && !checkHostOnline(host)) {
            // Visually show that this host is basically done
            progress.done().set(progress.total());
            return new ScanResult(host, openPorts, filteredPorts, serviceTypes);
        }

        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            CompletionService<PortResult> completionService = new ExecutorCompletionService<>(executor);
            List<Throwable> errors = new ArrayList<>();
            AtomicLong portSlotFactory = new AtomicLong(System.nanoTime());
            int activePerHostWorkers = 0;
            int portsToProcess = portRange.getTotal();
            while ((portsToProcess > 0 && !cancelled) || activePerHostWorkers > 0) {
                while (
                        portRange.hasNext() // continue as long as we have ports
                                && activePerHostWorkers < maxWorkersPerHost // and we have not reached our limit 
                                && !cancelled // and the scanner is not about to close
                ) {
                    activePerHostWorkers++;
                    final int currentPort = portRange.next();
                    completionService.submit(() -> {
                        waitForSlot(portSlotFactory);
                        return checkPort(host, currentPort, scan);
                    });
                }

                try {
                    Future<PortResult> portResultFuture = completionService.poll(10, TimeUnit.MILLISECONDS);
                    if (portResultFuture == null) {
                        continue;
                    }

                    PortResult portResult = portResultFuture.get();

                    activePerHostWorkers--;
                    portsToProcess--;
                    progress.done().incrementAndGet();
                    switch (portResult.getState()) {
                        case OPEN -> {
                            // bitset is not thread-safe, so it is set
                            // outside the other virtual threads that update progress
                            openPorts.set(portResult.getPort());
                            progress.open().incrementAndGet();
                            serviceTypes.put(portResult.getPort(), ServiceDetector.detect(portResult.getBanner()));
                        }
                        case FILTERED -> {
                            filteredPorts.set(portResult.getPort());
                            progress.filtered().incrementAndGet();
                        }
                    }
                } catch (InterruptedException ignored) {
                    Thread.currentThread().interrupt();
                } catch (ExecutionException e) {
                    errors.add(e);
                }
            }

            if (!errors.isEmpty()) {
                System.out.printf("Errors happened during scan of host %s%nErrors:%s -> %s", host, errors.size(), errors);
            }
        }

        return new ScanResult(host, openPorts, filteredPorts, serviceTypes);
    }

    private boolean checkHostOnline(String host) {
        try {
            return InetAddress.getByName(host).isReachable(timeoutInMillis);
        } catch (IOException e) {
            // something went wrong
        }

        return false;
    }

    private void waitForSlot(AtomicLong scanSlotFactory) {
        if (delayInNanos > 0) {
            long slot = scanSlotFactory.getAndAdd(delayInNanos);
            long wait = slot - System.nanoTime();
            if (wait > 0)
                LockSupport.parkNanos(wait);
        }
    }

    private PortResult checkPort(String host, int port, Scan scan) {
        PortResult result = new PortResult();
        result.setPort(port);
        result.setState(PortState.UNKNOWN);

        // don't allow more sockets then specified
        socketLimit.acquireUninterruptibly();
        // count how many ports are concurrently checked
        scan.incSocketCounter();
        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress(host, port), timeoutInMillis);

            if (bannerRecognition) {
                result.setBanner(getBanner(socket));
            }
            result.setState(PortState.OPEN);
        } catch (SocketTimeoutException ignored) {
            result.setState(PortState.FILTERED);
        } catch (ConnectException ignored) {
            result.setState(PortState.CLOSED);
        } catch (IOException ignored) {
            // NoRouteToHostException: this can be safely ignored because the port is closed if a host is unreachable
            // Will happen a lot when scanning for open ports, so not needed
        } finally {
            scan.decSocketCounter();
            socketLimit.release();
        }

        return result;
    }

    private String getBanner(Socket socket) {
        byte[] buffer = new byte[READ_BUFFER_SIZE];
        try (InputStream input = socket.getInputStream()) {
            socket.setSoTimeout(timeoutInMillis);
            int bytesRead = input.read(buffer);
            if (bytesRead <= 0) {
                return null;
            }
            return new String(buffer, 0, bytesRead, StandardCharsets.UTF_8).trim();
        } catch (IOException e) {
            // we ignore this failure
        }
        return null;
    }

    public void cancel() {
        cancelled = true;
    }

    @Override
    public void close() throws Exception {
        cancel();
        awaitTermination(Duration.ofMillis(10000));
    }

    public void awaitTermination(Duration duration) throws InterruptedException, TimeoutException {
        runningScans.awaitAdvanceInterruptibly(
                runningScans.getPhase(),
                duration.toMillis(),
                TimeUnit.MILLISECONDS);
    }
}