java调用Naabu进行端口扫描、Nucei进行漏洞扫描

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;

public class test {

    public static void main(String[] args) {
        // 设置exe文件的路径
        String exePath = "D:\\IDEA\\untitled1\\src\\naabu.exe";
        // 设置命令及其参数
        ProcessBuilder processBuilder = new ProcessBuilder(exePath, "-host", "127.0.0.1");

        try {
            // 启动子进程
            Process process = processBuilder.start();

            // 获取子进程的输出流（标准输入）
            OutputStream stdin = process.getOutputStream();
            // 写入一个换行符，相当于按下回车
            stdin.write("\n".getBytes(StandardCharsets.UTF_8));
            stdin.flush();
            stdin.close(); // 关闭标准输入，表示不再输入

            // 获取子进程的标准输出和错误输出
            String stdout = readStream(process.getInputStream());
            String stderr = readStream(process.getErrorStream());

            // 等待子进程执行完毕
            int exitCode = process.waitFor();

            // 打印输出结果
            if (!stdout.isEmpty()) {
                System.out.println("输出结果:\n" + stdout);
            }

            // 打印错误信息
            if (!stderr.isEmpty()) {
                System.out.println("错误信息:\n" + stderr);
            }

            // 可选：打印子进程的退出码
            System.out.println("子进程退出码: " + exitCode);

        } catch (IOException e) {
            System.err.println("执行命令时发生IO错误: " + e.getMessage());
            e.printStackTrace();
        } catch (InterruptedException e) {
            System.err.println("子进程被中断: " + e.getMessage());
            e.printStackTrace();
            Thread.currentThread().interrupt(); // 重设中断状态
        }
    }

    /**
     * 读取输入流并返回其内容作为字符串。
     *
     * @param inputStream 要读取的输入流
     * @return 输入流的内容
     * @throws IOException 如果发生IO错误
     */
    private static String readStream(InputStream inputStream) throws IOException {
        StringBuilder result = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
            String line;
            while ((line = reader.readLine()) != null) {
                result.append(line).append(System.lineSeparator());
            }
        }
        return result.toString().trim();
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;

public class test2 {

    /**
     * 异步读取流并通过回调处理每一行
     *
     * @param stream    输入流（标准输出或标准错误）
     * @param callback 处理每一行的回调函数
     */
    public static void readStream(InputStream stream, Consumer<String> callback) {
        new Thread(() -> {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    callback.accept(line);
                }
            } catch (IOException e) {
                System.err.println("读取流时发生错误: " + e.getMessage());
            }
        }).start();
    }

    /**
     * 运行 nuclei.exe 并处理其输出
     */
    public static void runNuclei() {
        // 配置 nuclei.exe 的路径和工作目录
        String nucleiPath = "D:\\IDEA\\untitled1\\src\\nuclei.exe";
        String[] command = {nucleiPath, "-target", "netegn.com"};
        String workingDir = "D:\\IDEA\\untitled1\\src";

        // 使用 ProcessBuilder 设置进程信息
        ProcessBuilder processBuilder = new ProcessBuilder(command);
        processBuilder.directory(new java.io.File(workingDir));

        // 将子进程的标准输入重定向为关闭，以防止子进程等待输入
        processBuilder.redirectInput(ProcessBuilder.Redirect.PIPE); // 使用 PIPE 以便关闭输出流

        Process process;
        try {
            // 启动子进程
            process = processBuilder.start();
            // 立即关闭子进程的标准输入
            process.getOutputStream().close();
        } catch (IOException e) {
            System.err.println("无法启动进程: " + e.getMessage());
            return;
        }

        // 创建并启动线程读取标准输出
        readStream(process.getInputStream(), System.out::println);

        // 创建并启动线程读取标准错误
        readStream(process.getErrorStream(), line -> System.err.println(line));

        try {
            // 设置超时时间为120秒（根据需要调整）
            boolean finished = process.waitFor(300, TimeUnit.SECONDS);
            if (!finished) {
                // 超时，强制终止子进程
                process.destroyForcibly();
                System.err.println("命令执行超时，已终止子进程。");
            }
        } catch (InterruptedException e) {
            // 等待进程时发生中断，强制终止子进程
            process.destroyForcibly();
            System.err.println("等待进程时发生错误: " + e.getMessage());
            Thread.currentThread().interrupt(); // 重新设置中断状态
        }

        // 获取并打印进程的退出码
        try {
            int exitCode = process.exitValue();
            System.out.println("命令执行完毕，退出码 " + exitCode);
        } catch (IllegalThreadStateException e) {
            System.err.println("进程尚未终止。");
        }
    }

    public static void main(String[] args) {
        runNuclei();
    }
}

原文地址：https://blog.csdn.net/weixin_35770067/article/details/145264653

免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！