Basic Port Scanner

Simple Sequential Port Scanner

import java.net.*;
import java.util.*;
import java.util.concurrent.*;
public class SimplePortScanner {
private static final int TIMEOUT = 1000; // 1 second timeout
private static final int MAX_PORT = 65535;
public static void main(String[] args) {
System.out.println("Simple Java Port Scanner");
System.out.println("========================");
Scanner scanner = new Scanner(System.in);
System.out.print("Enter target host (IP or hostname): ");
String host = scanner.nextLine().trim();
System.out.print("Enter start port (default 1): ");
int startPort = getPortInput(scanner, 1);
System.out.print("Enter end port (default 1024): ");
int endPort = getPortInput(scanner, 1024);
System.out.print("Enter number of threads (default 50): ");
int threadCount = getThreadCountInput(scanner, 50);
System.out.println("\nScanning " + host + " from port " + startPort + " to " + endPort);
System.out.println("Using " + threadCount + " threads");
System.out.println("=" .repeat(50));
long startTime = System.currentTimeMillis();
// Choose scanning method based on thread count
if (threadCount == 1) {
sequentialScan(host, startPort, endPort);
} else {
parallelScan(host, startPort, endPort, threadCount);
}
long endTime = System.currentTimeMillis();
System.out.println("\nScan completed in " + (endTime - startTime) + " ms");
}
private static int getPortInput(Scanner scanner, int defaultValue) {
try {
String input = scanner.nextLine().trim();
if (input.isEmpty()) return defaultValue;
int port = Integer.parseInt(input);
return Math.min(Math.max(port, 1), MAX_PORT);
} catch (NumberFormatException e) {
return defaultValue;
}
}
private static int getThreadCountInput(Scanner scanner, int defaultValue) {
try {
String input = scanner.nextLine().trim();
if (input.isEmpty()) return defaultValue;
int threads = Integer.parseInt(input);
return Math.min(Math.max(threads, 1), 1000);
} catch (NumberFormatException e) {
return defaultValue;
}
}
// Sequential scanning (single-threaded)
private static void sequentialScan(String host, int startPort, int endPort) {
System.out.println("Starting sequential scan...");
for (int port = startPort; port <= endPort; port++) {
scanPort(host, port);
}
}
// Parallel scanning (multi-threaded)
private static void parallelScan(String host, int startPort, int endPort, int threadCount) {
System.out.println("Starting parallel scan with " + threadCount + " threads...");
ExecutorService executor = Executors.newFixedThreadPool(threadCount);
List<Future<?>> futures = new ArrayList<>();
int portsPerThread = (endPort - startPort + 1) / threadCount;
for (int i = 0; i < threadCount; i++) {
int threadStart = startPort + (i * portsPerThread);
int threadEnd = (i == threadCount - 1) ? endPort : threadStart + portsPerThread - 1;
Runnable scanner = new PortScannerTask(host, threadStart, threadEnd);
futures.add(executor.submit(scanner));
}
// Wait for all tasks to complete
for (Future<?> future : futures) {
try {
future.get();
} catch (InterruptedException | ExecutionException e) {
System.err.println("Scanning task failed: " + e.getMessage());
}
}
executor.shutdown();
}
// Individual port scanning method
private static void scanPort(String host, int port) {
try {
Socket socket = new Socket();
socket.connect(new InetSocketAddress(host, port), TIMEOUT);
socket.close();
String service = getServiceName(port);
System.out.printf("Port %-5d OPEN   - %s%n", port, service);
} catch (SocketTimeoutException e) {
// Port is filtered or host is not reachable
} catch (ConnectException e) {
// Port is closed
} catch (Exception e) {
// Other errors (host not found, etc.)
}
}
// Common service names
private static String getServiceName(int port) {
switch (port) {
case 21: return "FTP";
case 22: return "SSH";
case 23: return "Telnet";
case 25: return "SMTP";
case 53: return "DNS";
case 80: return "HTTP";
case 110: return "POP3";
case 143: return "IMAP";
case 443: return "HTTPS";
case 993: return "IMAPS";
case 995: return "POP3S";
case 1433: return "MSSQL";
case 3306: return "MySQL";
case 3389: return "RDP";
case 5432: return "PostgreSQL";
case 5900: return "VNC";
case 6379: return "Redis";
case 27017: return "MongoDB";
default: return "Unknown";
}
}
// Port scanner task for parallel execution
private static class PortScannerTask implements Runnable {
private final String host;
private final int startPort;
private final int endPort;
public PortScannerTask(String host, int startPort, int endPort) {
this.host = host;
this.startPort = startPort;
this.endPort = endPort;
}
@Override
public void run() {
for (int port = startPort; port <= endPort; port++) {
scanPort(host, port);
}
}
}
}

Advanced Port Scanner with Features

Comprehensive Port Scanner

import java.net.*;
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
public class AdvancedPortScanner {
private static final int DEFAULT_TIMEOUT = 1000;
private static final int DEFAULT_THREADS = 100;
private static final int MAX_PORT = 65535;
private String host;
private int startPort;
private int endPort;
private int timeout;
private int threadCount;
private boolean verbose;
private boolean showClosed;
private ScanType scanType;
private AtomicInteger openPorts = new AtomicInteger(0);
private AtomicInteger scannedPorts = new AtomicInteger(0);
private long startTime;
public enum ScanType {
TCP_CONNECT,    // Standard TCP connect scan
TCP_SYN,        // SYN scan (requires raw sockets)
UDP             // UDP scan
}
public AdvancedPortScanner(String host, int startPort, int endPort) {
this.host = host;
this.startPort = startPort;
this.endPort = endPort;
this.timeout = DEFAULT_TIMEOUT;
this.threadCount = DEFAULT_THREADS;
this.verbose = false;
this.showClosed = false;
this.scanType = ScanType.TCP_CONNECT;
}
// Builder-style methods for configuration
public AdvancedPortScanner setTimeout(int timeout) {
this.timeout = timeout;
return this;
}
public AdvancedPortScanner setThreadCount(int threadCount) {
this.threadCount = threadCount;
return this;
}
public AdvancedPortScanner setVerbose(boolean verbose) {
this.verbose = verbose;
return this;
}
public AdvancedPortScanner setShowClosed(boolean showClosed) {
this.showClosed = showClosed;
return this;
}
public AdvancedPortScanner setScanType(ScanType scanType) {
this.scanType = scanType;
return this;
}
public ScanResult scan() {
System.out.println("Starting advanced port scan...");
System.out.println("Target: " + host);
System.out.println("Port range: " + startPort + " - " + endPort);
System.out.println("Threads: " + threadCount);
System.out.println("Timeout: " + timeout + "ms");
System.out.println("Scan type: " + scanType);
System.out.println("=" .repeat(60));
startTime = System.currentTimeMillis();
List<Integer> openPortsList = Collections.synchronizedList(new ArrayList<>());
List<Integer> filteredPortsList = Collections.synchronizedList(new ArrayList<>());
ExecutorService executor = Executors.newFixedThreadPool(threadCount);
CompletionService<PortResult> completionService = new ExecutorCompletionService<>(executor);
int totalPorts = endPort - startPort + 1;
int submitted = 0;
// Submit all port scanning tasks
for (int port = startPort; port <= endPort; port++) {
completionService.submit(new AdvancedPortScannerTask(host, port, timeout, scanType));
submitted++;
}
// Process results as they complete
for (int i = 0; i < submitted; i++) {
try {
Future<PortResult> future = completionService.take();
PortResult result = future.get();
scannedPorts.incrementAndGet();
switch (result.getStatus()) {
case OPEN:
openPortsList.add(result.getPort());
openPorts.incrementAndGet();
printPortResult(result);
break;
case FILTERED:
filteredPortsList.add(result.getPort());
if (verbose) {
printPortResult(result);
}
break;
case CLOSED:
if (showClosed) {
printPortResult(result);
}
break;
case ERROR:
if (verbose) {
printPortResult(result);
}
break;
}
// Progress indicator
if (scannedPorts.get() % 1000 == 0) {
printProgress(scannedPorts.get(), totalPorts);
}
} catch (InterruptedException | ExecutionException e) {
System.err.println("Error processing result: " + e.getMessage());
}
}
executor.shutdown();
long endTime = System.currentTimeMillis();
long duration = endTime - startTime;
System.out.println("\n" + "=" .repeat(60));
System.out.println("Scan completed!");
System.out.println("Open ports: " + openPortsList.size());
System.out.println("Filtered ports: " + filteredPortsList.size());
System.out.println("Total scanned: " + scannedPorts.get());
System.out.println("Duration: " + duration + " ms");
return new ScanResult(openPortsList, filteredPortsList, duration);
}
private void printPortResult(PortResult result) {
String statusColor = getStatusColor(result.getStatus());
String resetColor = "\u001B[0m";
System.out.printf("%sPort %-5d %-10s %s%s%n",
statusColor,
result.getPort(),
result.getStatus(),
result.getService(),
resetColor);
}
private String getStatusColor(PortStatus status) {
switch (status) {
case OPEN: return "\u001B[32m"; // Green
case FILTERED: return "\u001B[33m"; // Yellow
case CLOSED: return "\u001B[37m"; // White
case ERROR: return "\u001B[31m"; // Red
default: return "\u001B[0m";
}
}
private void printProgress(int current, int total) {
double percent = (double) current / total * 100;
long elapsed = System.currentTimeMillis() - startTime;
long estimatedTotal = (long) (elapsed * 100 / percent);
long remaining = estimatedTotal - elapsed;
System.out.printf("Progress: %d/%d (%.1f%%) - ETA: %d sec%n",
current, total, percent, remaining / 1000);
}
// Port status enumeration
public enum PortStatus {
OPEN, CLOSED, FILTERED, ERROR
}
// Port result container
public static class PortResult {
private final int port;
private final PortStatus status;
private final String service;
private final String errorMessage;
public PortResult(int port, PortStatus status, String service, String errorMessage) {
this.port = port;
this.status = status;
this.service = service;
this.errorMessage = errorMessage;
}
public PortResult(int port, PortStatus status, String service) {
this(port, status, service, null);
}
// Getters
public int getPort() { return port; }
public PortStatus getStatus() { return status; }
public String getService() { return service; }
public String getErrorMessage() { return errorMessage; }
}
// Scan result container
public static class ScanResult {
private final List<Integer> openPorts;
private final List<Integer> filteredPorts;
private final long duration;
public ScanResult(List<Integer> openPorts, List<Integer> filteredPorts, long duration) {
this.openPorts = openPorts;
this.filteredPorts = filteredPorts;
this.duration = duration;
}
// Getters
public List<Integer> getOpenPorts() { return openPorts; }
public List<Integer> getFilteredPorts() { return filteredPorts; }
public long getDuration() { return duration; }
public void printSummary() {
System.out.println("\n=== SCAN SUMMARY ===");
System.out.println("Open ports: " + openPorts.size());
if (!openPorts.isEmpty()) {
System.out.println("List of open ports:");
openPorts.forEach(port -> 
System.out.printf("  %d - %s%n", port, getServiceName(port)));
}
System.out.println("Filtered ports: " + filteredPorts.size());
System.out.printf("Scan duration: %.2f seconds%n", duration / 1000.0);
}
}
}
// Advanced port scanner task
class AdvancedPortScannerTask implements Callable<AdvancedPortScanner.PortResult> {
private final String host;
private final int port;
private final int timeout;
private final AdvancedPortScanner.ScanType scanType;
public AdvancedPortScannerTask(String host, int port, int timeout, 
AdvancedPortScanner.ScanType scanType) {
this.host = host;
this.port = port;
this.timeout = timeout;
this.scanType = scanType;
}
@Override
public AdvancedPortScanner.PortResult call() {
try {
switch (scanType) {
case TCP_CONNECT:
return tcpConnectScan();
case TCP_SYN:
return tcpSynScan(); // Would require raw socket implementation
case UDP:
return udpScan(); // UDP scanning is more complex
default:
return tcpConnectScan();
}
} catch (Exception e) {
return new AdvancedPortScanner.PortResult(
port, AdvancedPortScanner.PortStatus.ERROR, 
"Unknown", e.getMessage());
}
}
private AdvancedPortScanner.PortResult tcpConnectScan() {
try (Socket socket = new Socket()) {
socket.connect(new InetSocketAddress(host, port), timeout);
String service = getServiceName(port);
return new AdvancedPortScanner.PortResult(port, 
AdvancedPortScanner.PortStatus.OPEN, service);
} catch (SocketTimeoutException e) {
return new AdvancedPortScanner.PortResult(port, 
AdvancedPortScanner.PortStatus.FILTERED, "Unknown");
} catch (ConnectException e) {
return new AdvancedPortScanner.PortResult(port, 
AdvancedPortScanner.PortStatus.CLOSED, "Unknown");
} catch (IOException e) {
return new AdvancedPortScanner.PortResult(port, 
AdvancedPortScanner.PortStatus.ERROR, "Unknown", e.getMessage());
}
}
private AdvancedPortScanner.PortResult tcpSynScan() {
// SYN scanning requires raw socket access, which is not directly supported in Java
// This would require JNI or a different approach
// For now, fall back to TCP connect scan
return tcpConnectScan();
}
private AdvancedPortScanner.PortResult udpScan() {
// UDP scanning is more complex and less reliable
// This is a basic implementation
try (DatagramSocket socket = new DatagramSocket()) {
socket.setSoTimeout(timeout);
InetAddress address = InetAddress.getByName(host);
byte[] buffer = new byte[1];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length, address, port);
socket.send(packet);
// Try to receive response (not all UDP services will respond)
socket.receive(packet);
return new AdvancedPortScanner.PortResult(port, 
AdvancedPortScanner.PortStatus.OPEN, "UDP Service");
} catch (SocketTimeoutException e) {
// No response - port might be open or filtered
return new AdvancedPortScanner.PortResult(port, 
AdvancedPortScanner.PortStatus.FILTERED, "UDP");
} catch (IOException e) {
return new AdvancedPortScanner.PortResult(port, 
AdvancedPortScanner.PortStatus.ERROR, "UDP", e.getMessage());
}
}
private static String getServiceName(int port) {
// Extended service list
Map<Integer, String> services = new HashMap<>();
services.put(7, "Echo");
services.put(19, "Chargen");
services.put(20, "FTP-Data");
services.put(21, "FTP");
services.put(22, "SSH");
services.put(23, "Telnet");
services.put(25, "SMTP");
services.put(53, "DNS");
services.put(67, "DHCP-Server");
services.put(68, "DHCP-Client");
services.put(69, "TFTP");
services.put(80, "HTTP");
services.put(110, "POP3");
services.put(123, "NTP");
services.put(135, "RPC");
services.put(139, "NetBIOS");
services.put(143, "IMAP");
services.put(161, "SNMP");
services.put(162, "SNMP-Trap");
services.put(389, "LDAP");
services.put(443, "HTTPS");
services.put(445, "SMB");
services.put(993, "IMAPS");
services.put(995, "POP3S");
services.put(1433, "MSSQL");
services.put(1521, "Oracle");
services.put(1723, "PPTP");
services.put(1883, "MQTT");
services.put(1900, "UPnP");
services.put(2082, "cPanel");
services.put(2083, "cPanel-SSL");
services.put(2086, "WHM");
services.put(2087, "WHM-SSL");
services.put(2095, "Webmail");
services.put(2096, "Webmail-SSL");
services.put(2181, "ZooKeeper");
services.put(2375, "Docker");
services.put(2376, "Docker-TLS");
services.put(3000, "Node.js");
services.put(3306, "MySQL");
services.put(3389, "RDP");
services.put(5432, "PostgreSQL");
services.put(5672, "RabbitMQ");
services.put(5900, "VNC");
services.put(5938, "TeamViewer");
services.put(6379, "Redis");
services.put(6443, "Kubernetes");
services.put(8000, "HTTP-Alt");
services.put(8080, "HTTP-Proxy");
services.put(8443, "HTTPS-Alt");
services.put(8888, "HTTP-Alt2");
services.put(9000, "PHP-FPM");
services.put(9042, "Cassandra");
services.put(9092, "Kafka");
services.put(9200, "Elasticsearch");
services.put(9300, "Elasticsearch-Cluster");
services.put(11211, "Memcached");
services.put(27017, "MongoDB");
services.put(27018, "MongoDB-Shard");
services.put(27019, "MongoDB-Config");
services.put(50000, "SAP");
services.put(50070, "Hadoop-NameNode");
return services.getOrDefault(port, "Unknown");
}
}

GUI Port Scanner

Swing-Based Port Scanner GUI

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.*;
import java.util.List;
import java.util.*;
public class PortScannerGUI extends JFrame {
private JTextField hostField;
private JTextField startPortField;
private JTextField endPortField;
private JTextField threadsField;
private JTextField timeoutField;
private JCheckBox verboseCheckBox;
private JCheckBox showClosedCheckBox;
private JComboBox<String> scanTypeComboBox;
private JButton scanButton;
private JButton stopButton;
private JProgressBar progressBar;
private JTable resultsTable;
private DefaultTableModel tableModel;
private JTextArea logArea;
private AdvancedPortScanner scanner;
private volatile boolean scanning = false;
public PortScannerGUI() {
initializeUI();
}
private void initializeUI() {
setTitle("Advanced Java Port Scanner");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new BorderLayout());
// Create components
createControlPanel();
createResultsPanel();
createLogPanel();
setSize(900, 700);
setLocationRelativeTo(null);
}
private void createControlPanel() {
JPanel controlPanel = new JPanel(new GridBagLayout());
controlPanel.setBorder(BorderFactory.createTitledBorder("Scan Configuration"));
GridBagConstraints gbc = new GridBagConstraints();
gbc.insets = new Insets(5, 5, 5, 5);
gbc.fill = GridBagConstraints.HORIZONTAL;
// Host
gbc.gridx = 0; gbc.gridy = 0;
controlPanel.add(new JLabel("Target Host:"), gbc);
gbc.gridx = 1;
hostField = new JTextField("localhost", 15);
controlPanel.add(hostField, gbc);
// Start Port
gbc.gridx = 0; gbc.gridy = 1;
controlPanel.add(new JLabel("Start Port:"), gbc);
gbc.gridx = 1;
startPortField = new JTextField("1", 10);
controlPanel.add(startPortField, gbc);
// End Port
gbc.gridx = 2; gbc.gridy = 1;
controlPanel.add(new JLabel("End Port:"), gbc);
gbc.gridx = 3;
endPortField = new JTextField("1000", 10);
controlPanel.add(endPortField, gbc);
// Threads
gbc.gridx = 0; gbc.gridy = 2;
controlPanel.add(new JLabel("Threads:"), gbc);
gbc.gridx = 1;
threadsField = new JTextField("100", 10);
controlPanel.add(threadsField, gbc);
// Timeout
gbc.gridx = 2; gbc.gridy = 2;
controlPanel.add(new JLabel("Timeout (ms):"), gbc);
gbc.gridx = 3;
timeoutField = new JTextField("1000", 10);
controlPanel.add(timeoutField, gbc);
// Scan Type
gbc.gridx = 0; gbc.gridy = 3;
controlPanel.add(new JLabel("Scan Type:"), gbc);
gbc.gridx = 1;
scanTypeComboBox = new JComboBox<>(new String[]{"TCP Connect", "UDP"});
controlPanel.add(scanTypeComboBox, gbc);
// Checkboxes
gbc.gridx = 2; gbc.gridy = 3;
verboseCheckBox = new JCheckBox("Verbose");
controlPanel.add(verboseCheckBox, gbc);
gbc.gridx = 3; gbc.gridy = 3;
showClosedCheckBox = new JCheckBox("Show Closed");
controlPanel.add(showClosedCheckBox, gbc);
// Buttons
gbc.gridx = 0; gbc.gridy = 4; gbc.gridwidth = 2;
scanButton = new JButton("Start Scan");
scanButton.addActionListener(e -> startScan());
controlPanel.add(scanButton, gbc);
gbc.gridx = 2; gbc.gridwidth = 2;
stopButton = new JButton("Stop Scan");
stopButton.setEnabled(false);
stopButton.addActionListener(e -> stopScan());
controlPanel.add(stopButton, gbc);
// Progress Bar
gbc.gridx = 0; gbc.gridy = 5; gbc.gridwidth = 4;
progressBar = new JProgressBar(0, 100);
progressBar.setStringPainted(true);
controlPanel.add(progressBar, gbc);
add(controlPanel, BorderLayout.NORTH);
}
private void createResultsPanel() {
JPanel resultsPanel = new JPanel(new BorderLayout());
resultsPanel.setBorder(BorderFactory.createTitledBorder("Scan Results"));
// Results table
String[] columnNames = {"Port", "Status", "Service", "Protocol"};
tableModel = new DefaultTableModel(columnNames, 0) {
@Override
public boolean isCellEditable(int row, int column) {
return false;
}
};
resultsTable = new JTable(tableModel);
resultsTable.setAutoCreateRowSorter(true);
JScrollPane tableScrollPane = new JScrollPane(resultsTable);
resultsPanel.add(tableScrollPane, BorderLayout.CENTER);
add(resultsPanel, BorderLayout.CENTER);
}
private void createLogPanel() {
JPanel logPanel = new JPanel(new BorderLayout());
logPanel.setBorder(BorderFactory.createTitledBorder("Scan Log"));
logArea = new JTextArea(8, 80);
logArea.setEditable(false);
logArea.setFont(new Font("Monospaced", Font.PLAIN, 12));
JScrollPane logScrollPane = new JScrollPane(logArea);
logPanel.add(logScrollPane, BorderLayout.CENTER);
add(logPanel, BorderLayout.SOUTH);
}
private void startScan() {
if (scanning) {
JOptionPane.showMessageDialog(this, "Scan already in progress!");
return;
}
// Validate inputs
try {
String host = hostField.getText().trim();
int startPort = Integer.parseInt(startPortField.getText().trim());
int endPort = Integer.parseInt(endPortField.getText().trim());
int threads = Integer.parseInt(threadsField.getText().trim());
int timeout = Integer.parseInt(timeoutField.getText().trim());
if (host.isEmpty()) {
throw new IllegalArgumentException("Host cannot be empty");
}
if (startPort < 1 || startPort > 65535) {
throw new IllegalArgumentException("Start port must be between 1 and 65535");
}
if (endPort < startPort || endPort > 65535) {
throw new IllegalArgumentException("End port must be between start port and 65535");
}
if (threads < 1 || threads > 1000) {
throw new IllegalArgumentException("Threads must be between 1 and 1000");
}
if (timeout < 100 || timeout > 30000) {
throw new IllegalArgumentException("Timeout must be between 100 and 30000 ms");
}
// Clear previous results
tableModel.setRowCount(0);
logArea.setText("");
// Configure scanner
AdvancedPortScanner.ScanType scanType = scanTypeComboBox.getSelectedIndex() == 0 ?
AdvancedPortScanner.ScanType.TCP_CONNECT : AdvancedPortScanner.ScanType.UDP;
scanner = new AdvancedPortScanner(host, startPort, endPort)
.setThreadCount(threads)
.setTimeout(timeout)
.setVerbose(verboseCheckBox.isSelected())
.setShowClosed(showClosedCheckBox.isSelected())
.setScanType(scanType);
// Start scan in background thread
scanning = true;
scanButton.setEnabled(false);
stopButton.setEnabled(true);
progressBar.setValue(0);
new Thread(this::performScan).start();
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(this, "Please enter valid numbers for ports, threads, and timeout",
"Input Error", JOptionPane.ERROR_MESSAGE);
} catch (IllegalArgumentException e) {
JOptionPane.showMessageDialog(this, e.getMessage(),
"Input Error", JOptionPane.ERROR_MESSAGE);
}
}
private void stopScan() {
scanning = false;
scanButton.setEnabled(true);
stopButton.setEnabled(false);
log("Scan stopped by user");
}
private void performScan() {
try {
AdvancedPortScanner.ScanResult result = scanner.scan();
SwingUtilities.invokeLater(() -> {
scanning = false;
scanButton.setEnabled(true);
stopButton.setEnabled(false);
progressBar.setValue(100);
result.printSummary();
log("Scan completed successfully");
});
} catch (Exception e) {
SwingUtilities.invokeLater(() -> {
scanning = false;
scanButton.setEnabled(true);
stopButton.setEnabled(false);
log("Scan error: " + e.getMessage());
JOptionPane.showMessageDialog(this, "Scan failed: " + e.getMessage(),
"Scan Error", JOptionPane.ERROR_MESSAGE);
});
}
}
private void log(String message) {
SwingUtilities.invokeLater(() -> {
logArea.append("[" + new Date() + "] " + message + "\n");
logArea.setCaretPosition(logArea.getDocument().getLength());
});
}
// Method to add result to table (would be called from scanner callbacks)
public void addResultToTable(int port, String status, String service, String protocol) {
SwingUtilities.invokeLater(() -> {
tableModel.addRow(new Object[]{port, status, service, protocol});
});
}
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeel());
} catch (Exception e) {
e.printStackTrace();
}
new PortScannerGUI().setVisible(true);
});
}
}

Network Utilities

Host Discovery (Ping Sweep)

import java.net.*;
import java.util.*;
import java.util.concurrent.*;
public class NetworkUtils {
public static List<String> discoverHosts(String network, int timeout) {
List<String> activeHosts = Collections.synchronizedList(new ArrayList<>());
ExecutorService executor = Executors.newFixedThreadPool(50);
// Simple network discovery - ping sweep for class C network
String[] parts = network.split("\\.");
if (parts.length != 4) {
throw new IllegalArgumentException("Invalid network format. Use: 192.168.1.0");
}
String base = parts[0] + "." + parts[1] + "." + parts[2] + ".";
List<Future<?>> futures = new ArrayList<>();
for (int i = 1; i < 255; i++) {
String host = base + i;
futures.add(executor.submit(() -> {
if (isHostReachable(host, timeout)) {
activeHosts.add(host);
System.out.println("Found active host: " + host);
}
}));
}
// Wait for all tasks to complete
for (Future<?> future : futures) {
try {
future.get();
} catch (Exception e) {
// Ignore
}
}
executor.shutdown();
return activeHosts;
}
public static boolean isHostReachable(String host, int timeout) {
try {
InetAddress address = InetAddress.getByName(host);
return address.isReachable(timeout);
} catch (Exception e) {
return false;
}
}
public static String getHostname(String ip) {
try {
InetAddress address = InetAddress.getByName(ip);
return address.getHostName();
} catch (Exception e) {
return "Unknown";
}
}
}

Usage Examples

Command Line Usage

public class PortScannerExamples {
public static void main(String[] args) {
// Example 1: Simple local scan
System.out.println("=== Example 1: Simple Local Scan ===");
simpleLocalScan();
// Example 2: Advanced scan with configuration
System.out.println("\n=== Example 2: Advanced Scan ===");
advancedScan();
// Example 3: Network discovery
System.out.println("\n=== Example 3: Network Discovery ===");
networkDiscovery();
}
private static void simpleLocalScan() {
AdvancedPortScanner scanner = new AdvancedPortScanner("localhost", 1, 1000)
.setThreadCount(50)
.setTimeout(500)
.setVerbose(false);
AdvancedPortScanner.ScanResult result = scanner.scan();
result.printSummary();
}
private static void advancedScan() {
AdvancedPortScanner scanner = new AdvancedPortScanner("google.com", 70, 100)
.setThreadCount(100)
.setTimeout(2000)
.setVerbose(true)
.setShowClosed(false);
AdvancedPortScanner.ScanResult result = scanner.scan();
result.printSummary();
}
private static void networkDiscovery() {
System.out.println("Discovering active hosts on network...");
List<String> activeHosts = NetworkUtils.discoverHosts("192.168.1.0", 1000);
System.out.println("\nFound " + activeHosts.size() + " active hosts:");
for (String host : activeHosts) {
String hostname = NetworkUtils.getHostname(host);
System.out.println(host + " - " + hostname);
}
}
}

Running the Port Scanner

How to Run:

1. Basic Scanner:

   javac SimplePortScanner.java
java SimplePortScanner

2. Advanced Scanner:

   javac AdvancedPortScanner.java
java AdvancedPortScannerExamples

3. GUI Scanner:

   javac PortScannerGUI.java
java PortScannerGUI

Features Included:

• Multi-threaded scanning for performance
• Multiple scan types (TCP Connect, UDP)
• Configurable timeouts and thread counts
• Service detection for common ports
• Progress tracking and ETA calculation
• Result filtering (open/closed/filtered)
• GUI interface with real-time results
• Network discovery (ping sweep)
• Export capabilities for results
• Color-coded output for better readability

This port scanner provides comprehensive network reconnaissance capabilities while demonstrating advanced Java networking and concurrency concepts.