网络扫描程序设计

最新推荐文章于 2024-09-02 20:55:08 发布
最新推荐文章于 2024-09-02 20:55:08 发布
阅读量1k 收藏 18
点赞数 1
分类专栏： 互联网程序设计 文章标签： 网络 java idea 信息与通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51293984/article/details/127635188
版权

一、简介

目标主机扫描是网络功防的基础和前提，扫描探测一台目标主机包括：确定该目标主机是否活动、目标主机的操作系统、正在使用哪些端口、对外提供了哪些服务、相关服务的软件版本等等，对这些内容的探测就是为了“对症下药”，为攻防提供参考信息。对主机的探测工具非常多，比如大名鼎鼎的nmap、netcat、superscan，以及国内的x-scanner等等。

二、主机扫描（远程主机探测）

1、通过指定的IP地址范围，发现该范围钟活跃的主机，如192.168.233.0-192.168.233.255

请添加图片描述
扫描192.168.233.0~192.168.233.255，收到消息192.168.233.175的端口6060开放

更好的思路是将ip地址转换为整数形式，ip地址范围的遍历就转为在两个数字之间for循环，循环体钟将每一个数字换回ip地址进行处理即可，关键就在于实现ip与数字之间的互相转换：
请添加图片描述
最终结果=以上四行或运算

但是！在java钟，二进制最高位1是符号位使用，表示负数，所以我们需要用long类型来存储ip转换的数字，避免出现负数的情况。

ip和长整型互相转化：
public  long ipToLong(String ip) {
  String[] ipArray = ip.split("\\.");
  long num = 0;
  for (int i=0; i<ipArray.length; i++) {
    long valueOfSection = Long.parseLong(ipArray[i]);
    num = (valueOfSection << 8 * (3 - i)) | num;
  }
  return num;
}

/**
 * 长整型转ip  
 */
public  String longToIp(long i) {
//右移，并将高位置0
  return ((i >> 24 ) & 0xFF) + "." +
      ((i >> 16 ) & 0xFF) + "." +
      ((i >>  8 ) & 0xFF) + "." +
      ( i        & 0xFF);
}

三、端口扫描

在目标主机IP文本框中填入活跃主机的ip，再点击扫描。

多线程扫描：即便使用快速扫描的方式，如果扫描的端口范围较大，还是耗时较久。可以结合快速扫描，开启多线程加快速度：每一个线程负责扫描一段范围，分而治之加快速度。
请添加图片描述

四、完整代码

IpUtils.java
package chapter09;
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//


public class IpUtils {
    public IpUtils() {
    }

    public static int ipToInt(String ip) {
        String[] ipArray = ip.split("\\.");
        int num = 0;

        for(int i = 0; i < ipArray.length; ++i) {
            int valueOfSection = Integer.parseInt(ipArray[i]);
            num |= valueOfSection << 8 * (3 - i);
        }

        return num;
    }

    public static String intToIp(int ip) {
        StringBuffer sb = new StringBuffer("");
        sb.append(String.valueOf(ip >>> 24));
        sb.append(".");
        sb.append(String.valueOf((ip & 16777215) >>> 16));
        sb.append(".");
        sb.append(String.valueOf((ip & '\uffff') >>> 8));
        sb.append(".");
        sb.append(String.valueOf(ip & 255));
        return sb.toString();
    }

    public static long ipToLong(String strIp) {
        String[] s = strIp.split("\\.");
        long ip = (Long.parseLong(s[0]) << 24) + (Long.parseLong(s[1]) << 16) + (Long.parseLong(s[2]) << 8) + Long.parseLong(s[3]);
        return ip;
    }

    public static String longToIp(long longIp) {
        StringBuffer sb = new StringBuffer("");
        sb.append(String.valueOf(longIp >> 24)).append(".").append(String.valueOf((longIp & 16777215L) >> 16)).append(".").append(String.valueOf((longIp & 65535L) >> 8)).append(".").append(String.valueOf(longIp & 255L));
        return sb.toString();
    }

    public static void main(String[] args) {
        int intIP;
        System.out.println(intIP = ipToInt("192.168.0.1"));
        System.out.println(ipToInt("192.168.0.254"));
        System.out.println(intToIp(intIP));
        System.out.println(ipToLong("192.168.0.127"));
    }
}
HostScannerFX.java
package chapter09;
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.concurrent.atomic.AtomicInteger;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class HostScannerFX extends Application {
    private TextArea taDisplay = new TextArea();
    private TextField tfStartIp = new TextField("192.168.0.1");
    private TextField tfEndIp = new TextField("192.168.0.158");
    private TextField tfCmd = new TextField();
    private Button btnScan = new Button("主机扫描");
    private Button btnExecute = new Button("执行命令");
    private Button btnStop = new Button("停止");
    private Button btnExit = new Button("退出");
    private ThreadGroup threadGroup = new ThreadGroup("scanThread");
    static AtomicInteger hostCount = new AtomicInteger(0);
    private long startIp;
    private long endIp;

    public HostScannerFX() {
    }

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

    public void start(Stage primaryStage) throws Exception {
        BorderPane mainPane = new BorderPane();
        VBox display = new VBox();
        display.setSpacing(10.0D);
        display.setPadding(new Insets(10.0D, 20.0D, 10.0D, 20.0D));
        this.taDisplay.setWrapText(true);
        this.taDisplay.setEditable(false);
        display.getChildren().addAll(new Node[]{new Label("扫描结果:"), this.taDisplay});
        VBox.setVgrow(this.taDisplay, Priority.ALWAYS);
        mainPane.setCenter(display);
        this.btnScan.setOnAction((event) -> {
            this.startIp = IpUtils.ipToLong(this.tfStartIp.getText());
            this.endIp = IpUtils.ipToLong(this.tfEndIp.getText());
            int thread = 4;
            hostCount.set(0);

            for(int i = 0; i < thread; ++i) {
                HostScannerFX.ScanHandler scanHandler = new HostScannerFX.ScanHandler(i, thread);
                (new Thread(this.threadGroup, scanHandler, "MultiThread" + i)).start();
            }

        });
        this.btnExecute.setOnAction((event) -> {
            Thread scanThread = new Thread(this.threadGroup, () -> {
                try {
                    String cmd = this.tfCmd.getText();
                    Process process = Runtime.getRuntime().exec(cmd);
                    InputStream in = process.getInputStream();
                    BufferedReader br = new BufferedReader(new InputStreamReader(in, "gbk"));

                    String msg;
                    while((msg = br.readLine()) != null) {
                        String finalMsg = msg;
                        Platform.runLater(() -> {
                            this.taDisplay.appendText(finalMsg + "\n");
                        });
                    }
                } catch (IOException var7) {
                    System.err.println(var7.getMessage());
                }

            }, "scanThread");
            scanThread.start();
        });
        this.btnStop.setOnAction((event) -> {
            this.threadGroup.interrupt();
        });
        this.btnExit.setOnAction((event) -> {
            this.threadGroup.interrupt();
            System.exit(0);
        });
        HBox controls = new HBox();
        controls.setSpacing(10.0D);
        controls.setPadding(new Insets(10.0D, 20.0D, 10.0D, 20.0D));
        controls.setAlignment(Pos.CENTER);
        controls.getChildren().addAll(new Node[]{new Label("起始地址："), this.tfStartIp, new Label("结束地址："), this.tfEndIp, this.btnScan});
        HBox cmd = new HBox();
        cmd.setSpacing(10.0D);
        cmd.setPadding(new Insets(10.0D, 20.0D, 10.0D, 20.0D));
        cmd.setAlignment(Pos.CENTER);
        cmd.getChildren().addAll(new Node[]{new Label("输入命令格式："), this.tfCmd, this.btnExecute, this.btnStop, this.btnExit});
        VBox vCmd = new VBox();
        vCmd.setAlignment(Pos.CENTER);
        vCmd.setPrefWidth(500.0D);
        vCmd.getChildren().addAll(new Node[]{controls, cmd});
        mainPane.setBottom(vCmd);
        Scene scene = new Scene(mainPane, 700.0D, 400.0D);
        primaryStage.setOnCloseRequest((event) -> {
            this.threadGroup.interrupt();
            System.exit(0);
        });
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public boolean isReachable(String host) throws IOException {
        int timeOut = 100;
        InetAddress address = InetAddress.getByName(host);
        return address.isReachable(timeOut);
    }

    class ScanHandler implements Runnable {
        private int totalThreadNum;
        private int threadNo;

        public ScanHandler(int threadNo) {
            this.totalThreadNum = 10;
            this.threadNo = threadNo;
        }

        public ScanHandler(int threadNo, int totalThreadNum) {
            this.totalThreadNum = totalThreadNum;
            this.threadNo = threadNo;
        }

        public void run() {
            for(long host = HostScannerFX.this.startIp + (long)this.threadNo; host <= HostScannerFX.this.endIp; host += (long)this.totalThreadNum) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("interrupted!");
                    break;
                }

                try {
                    boolean res = HostScannerFX.this.isReachable(IpUtils.longToIp(host));
                    if (res) {
                        long finalHost = host;
                        Platform.runLater(() -> {
                            HostScannerFX.this.taDisplay.appendText(IpUtils.longToIp(finalHost) + " is reachable.\n");

                            try {
                                Socket socket = new Socket();
                                socket.connect(new InetSocketAddress(String.valueOf(finalHost), 6060), 200);
                                socket.close();
                                String msg = IpUtils.longToIp(finalHost) + "的端口6060开放了\n";
                                Platform.runLater(() -> {
                                    HostScannerFX.this.taDisplay.appendText(msg);
                                });
                            } catch (IOException var5) {
                                var5.printStackTrace();
                            }

                        });
                    }
                } catch (IOException var6) {
                    var6.printStackTrace();
                }

                HostScannerFX.hostCount.incrementAndGet();
            }

            if ((long)HostScannerFX.hostCount.get() == HostScannerFX.this.endIp - HostScannerFX.this.startIp + 1L) {
                HostScannerFX.hostCount.incrementAndGet();
                Platform.runLater(() -> {
                    HostScannerFX.this.taDisplay.appendText("扫描完毕");
                });
            }

        }
    }
}
PortScannerFx.java
package chapter09;
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.concurrent.atomic.AtomicInteger;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.ProgressBar;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class PortScannerFx extends Application {
    private TextArea taDisplay = new TextArea();
    private TextField tfTargetIp = new TextField("192.168.0.1");
    private TextField tfStartPort = new TextField("1");
    private TextField tfEndPort = new TextField("443");
    private Button btnScan = new Button("扫描");
    private Button btnQuickScan = new Button("快速扫描");
    private Button btnMultiThreadScan = new Button("多线程扫描");
    private Button btnStop = new Button("停止");
    private Button btnClear = new Button("清空");
    private Button btnExit = new Button("退出");
    private ProgressBar progressBar = new ProgressBar(0.0D);
    private Label progressLabel = new Label("0%");
    private String ip;
    private int startPort;
    private int endPort;
    private ThreadGroup threadGroup = new ThreadGroup("scanThread");
    static AtomicInteger portCount = new AtomicInteger(0);

    public PortScannerFx() {
    }

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

    public void start(Stage primaryStage) throws Exception {
        BorderPane mainPane = new BorderPane();
        VBox display = new VBox();
        display.setSpacing(10.0D);
        display.setPadding(new Insets(10.0D, 20.0D, 10.0D, 20.0D));
        this.taDisplay.setWrapText(true);
        this.taDisplay.setEditable(false);
        this.taDisplay.setPrefHeight(250.0D);
        this.progressBar.setPrefWidth(600.0D);
        HBox progressBox = new HBox();
        progressBox.setAlignment(Pos.CENTER);
        progressBox.setSpacing(10.0D);
        progressBox.getChildren().addAll(new Node[]{this.progressLabel, this.progressBar});
        display.getChildren().addAll(new Node[]{new Label("端口扫描结果:"), this.taDisplay, progressBox});
        VBox.setVgrow(this.taDisplay, Priority.ALWAYS);
        mainPane.setTop(display);
        HBox params = new HBox();
        params.setSpacing(10.0D);
        params.setPadding(new Insets(10.0D, 20.0D, 10.0D, 20.0D));
        params.setAlignment(Pos.CENTER);
        this.tfStartPort.setPrefWidth(40.0D);
        this.tfEndPort.setPrefWidth(40.0D);
        params.getChildren().addAll(new Node[]{new Label("目标主机IP："), this.tfTargetIp, new Label("起始端口号："), this.tfStartPort, new Label("结束端口号："), this.tfEndPort});
        mainPane.setCenter(params);
        this.btnStop.setDisable(true);
        this.btnScan.setOnAction((event) -> {
            this.ip = this.tfTargetIp.getText();
            this.startPort = Integer.parseInt(this.tfStartPort.getText());
            this.endPort = Integer.parseInt(this.tfEndPort.getText());
            this.progressBar.setProgress(0.0D);
            this.progressLabel.setText("0%");
            int totalPorts = this.endPort - this.startPort + 1;
            Thread scanThread = new Thread(this.threadGroup, () -> {
                System.out.println("Scan start!");

                for(int i = this.startPort; i <= this.endPort; ++i) {
                    if (Thread.currentThread().isInterrupted()) {
                        System.out.println("interrupted!");
                        break;
                    }

                    System.out.println("Scanning port " + i);

                    String msg;
                    try {
                        Socket socket = new Socket(this.ip, i);
                        socket.close();
                        msg = "端口 " + i + " is open\n";
                    } catch (IOException var6) {
                        msg = "端口 " + i + " is not open\n";
                    }

                    this.taDisplay.appendText(msg);
                    double progress = (double)(i - this.startPort) / (double)totalPorts;
                    Platform.runLater(() -> {
                        this.progressBar.setProgress(progress);
                        this.progressLabel.setText((int)(progress * 100.0D) + "%");
                    });
                }

            }, "scanThread");
            this.btnStop.setDisable(false);
            this.btnScan.setDisable(true);
            this.btnQuickScan.setDisable(true);
            this.btnMultiThreadScan.setDisable(true);
            scanThread.start();
        });
        this.btnQuickScan.setOnAction((event) -> {
            this.ip = this.tfTargetIp.getText();
            this.startPort = Integer.parseInt(this.tfStartPort.getText());
            this.endPort = Integer.parseInt(this.tfEndPort.getText());
            this.progressBar.setProgress(0.0D);
            this.progressLabel.setText("0%");
            int totalPorts = this.endPort - this.startPort + 1;
            Thread scanThread = new Thread(this.threadGroup, () -> {
                System.out.println("Scan start!");

                for(int i = this.startPort; i <= this.endPort; ++i) {
                    if (Thread.currentThread().isInterrupted()) {
                        System.out.println("interrupted!");
                        break;
                    }

                    System.out.println("Scanning port " + i);

                    String msg;
                    try {
                        Socket socket = new Socket();
                        socket.connect(new InetSocketAddress(this.ip, i), 200);
                        socket.close();
                        msg = "端口 " + i + " is open\n";
                    } catch (IOException var6) {
                        msg = "端口 " + i + " is not open\n";
                    }

                    this.taDisplay.appendText(msg);
                    double progress = (double)(i - this.startPort) / (double)totalPorts;
                    Platform.runLater(() -> {
                        this.progressBar.setProgress(progress);
                        this.progressLabel.setText((int)(progress * 100.0D) + "%");
                    });
                }

            }, "quickScanThread");
            this.btnStop.setDisable(false);
            this.btnScan.setDisable(true);
            this.btnQuickScan.setDisable(true);
            this.btnMultiThreadScan.setDisable(true);
            scanThread.start();
        });
        this.btnMultiThreadScan.setOnAction((event) -> {
            this.ip = this.tfTargetIp.getText();
            this.startPort = Integer.parseInt(this.tfStartPort.getText());
            this.endPort = Integer.parseInt(this.tfEndPort.getText());
            this.btnStop.setDisable(false);
            this.btnScan.setDisable(true);
            this.btnQuickScan.setDisable(true);
            this.btnMultiThreadScan.setDisable(true);
            int thread = 4;
            portCount.set(0);

            for(int i = 0; i < thread; ++i) {
                PortScannerFx.ScanHandler scanHandler = new PortScannerFx.ScanHandler(i, thread);
                (new Thread(this.threadGroup, scanHandler, "MultiThread" + i)).start();
            }

        });
        this.btnStop.setOnAction((event) -> {
            this.btnStop.setDisable(true);
            this.btnScan.setDisable(false);
            this.btnQuickScan.setDisable(false);
            this.btnMultiThreadScan.setDisable(false);

            try {
                this.threadGroup.list();
                this.threadGroup.interrupt();
            } catch (Exception var3) {
            }

        });
        this.btnExit.setOnAction((event) -> {
            try {
                this.threadGroup.interrupt();
            } catch (Exception var3) {
            }

            System.exit(0);
        });
        this.btnClear.setOnAction((event) -> {
            this.taDisplay.clear();
            this.progressBar.setProgress(0.0D);
            this.progressLabel.setText("0%");
        });
        HBox buttons = new HBox();
        buttons.setAlignment(Pos.CENTER);
        buttons.setSpacing(10.0D);
        buttons.setPadding(new Insets(10.0D, 20.0D, 10.0D, 20.0D));
        buttons.getChildren().addAll(new Node[]{this.btnScan, this.btnQuickScan, this.btnMultiThreadScan, this.btnStop, this.btnClear, this.btnExit});
        mainPane.setBottom(buttons);
        Scene scene = new Scene(mainPane, 700.0D, 400.0D);
        primaryStage.setOnCloseRequest((event) -> {
            try {
                this.threadGroup.interrupt();
            } catch (Exception var3) {
            }

            System.exit(0);
        });
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    class ScanHandler implements Runnable {
        private int totalThreadNum;
        private int threadNo;

        public ScanHandler(int threadNo) {
            this.totalThreadNum = 10;
            this.threadNo = threadNo;
        }

        public ScanHandler(int threadNo, int totalThreadNum) {
            this.totalThreadNum = totalThreadNum;
            this.threadNo = threadNo;
        }

        public void run() {
            System.out.println("thread created");

            for(int port = PortScannerFx.this.startPort + this.threadNo; port <= PortScannerFx.this.endPort; port += this.totalThreadNum) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("interrupted!");
                    break;
                }

                double progress = (double)PortScannerFx.portCount.get() / (double)(PortScannerFx.this.endPort - PortScannerFx.this.startPort + 1);
                Platform.runLater(() -> {
                    PortScannerFx.this.progressBar.setProgress(progress);
                    PortScannerFx.this.progressLabel.setText((int)(progress * 100.0D) + "%");
                });

                try {
                    Socket socket = new Socket();
                    socket.connect(new InetSocketAddress(PortScannerFx.this.ip, port), 200);
                    socket.close();
                    String msg = "端口 " + port + " is open\n";
                    Platform.runLater(() -> {
                        PortScannerFx.this.taDisplay.appendText(msg);
                    });
                } catch (IOException var6) {
                }

                PortScannerFx.portCount.incrementAndGet();
            }

            if (PortScannerFx.portCount.get() == PortScannerFx.this.endPort - PortScannerFx.this.startPort + 1) {
                PortScannerFx.portCount.incrementAndGet();
                Platform.runLater(() -> {
                    PortScannerFx.this.taDisplay.appendText("\n----------------多线程扫描结束--------------------\n");
                    PortScannerFx.this.btnStop.setDisable(true);
                    PortScannerFx.this.btnScan.setDisable(false);
                    PortScannerFx.this.btnQuickScan.setDisable(false);
                    PortScannerFx.this.btnMultiThreadScan.setDisable(false);
                });
            }

        }
    }
}
一个很菜的小猪
关注
专栏目录
scanner程序 网络扫描
06-13
一、用C语言编写一个在linux下扫描局域网内主机的程序。要求可以显示局域网内的主机名列表，IP地址列表，并可以显示哪些主机开放了哪些端口。 二.实验环境 Linux，C语言
网络扫描仪：Python中的网络扫描仪程序
02-18
3. 异步编程：Python的`asyncio`库支持异步I/O，使网络扫描程序能够同时处理多个连接，提高效率。 二、网络扫描原理 网络扫描通常包括以下步骤： 1. IP地址范围确定：首先，我们需要指定扫描的目标IP地址范围，...
基于C++MFC的网络安全扫描器的设计与实现
毕业作品网站
09-30 4569
InsertItem 函数去创建这些选项卡控件，使管理员能够更加方便的切换各个功能模块，然后就可以对每一个功能模块进行编辑，而对不同的功能选项卡管理员要进行操作的监听，一旦有相关事件的发生，管理员能够及时作出反馈并给出正确的操作，从而大大降低了用户的使用难度，方便用户进行可视化的合理的扫描操作。就目前主流的网络扫描器，大多数采用的是命令行界面，用户使用的门槛相对较高，可视化的图形界面旨在提供给用户一个友好的使用环境，这种用户-界面的体系结构深受广大喜爱。6.1.3NetBIOS 扫描功能模块测试 46。
如何使用Windows自带的软件进行扫描
最新发布
rtkj1122的博客
09-02 1007
速印机（理想、理光、基士得耶、荣大等）、复印机（夏普、东芝、理光、佳能、震旦等全系列）、打印机、扫描仪、传真机、多媒体教学一体机、交互式电子白板、报警器材、监控、国产化设备、竞业达监考设备及其它监考设备、听力考试设备、特种安防设备维护及维修。1、在电脑屏幕上，依次点击“开始”---“所有程序”---“Windows传真和扫描”；1、点击电脑左下角的“开始”图标，在“所有程序”中打开“画图”。2、在“新扫描”窗口中，根据需要点击“预览”或者“扫描”按钮；1、点击“开始”菜单，点击“控制面板”；
主机系统扫描程序设计
Beeters的博客
11-18 858
主机端口扫描
python 计算机网络课程设计（网络主机扫描程序）
qq_56992543的博客
12-28 3060
我们的运行环境是pycharm 目录 背景 随着网络技术的发展，越来越多的计算机接入互联网上，网络安全逐渐成 为一个潜在的巨大问题，如何保障自身的网络安全，其中一个主要的方法就是 自查自纠，而在这个过程中，对自己的网络活动主机扫描成为一种较为快捷， 直观，简单的方法。本次课程设计就是对网络主机扫描技术的研究以及实现， 其中技术包括 ARP，ICMP，TCP，UDP 网络协议的网络活动主机扫描。 利用 ARP 协议获取活动主机的 mac 地址，当获取的不为”00-00-00-00
网络扫描器的设计与实现
10-04
网络扫描器的设计与实现 运行环境 操作系统：Windows XP及以上。 开发工具：Microsoft Visual C++6.0，Notepad++。 开发语言：C/C++， MFC。 主要功能模块测试 主机扫描功能模块测试 在主机扫描功能模块中，管理员输入起始 IP 为 192.168.0.100，结束 IP 为 192.168.0.103，在这个 IP 段的范围内进行测试，结果显示有两台主机处在存活状态，分别是 192.168.0.100 和 192.168.0.102，其扫描结果如图所示： HostScan 端口扫描功能模块测试 在端口扫描功能模块中，管理员输入起始 IP 为 192.168.0.100，结束 IP 为 192.168.0.102，在这个 IP 段的范围内进行测试，端口范围设置为 1~1024，结果显示，主机 192.168.0.100 开放了 80 端口，192.168.0.102 开放了 135、139 和 445 端口，其扫描结果如图所示： PortScan NetBIOS 扫描功能模块测试 在网上基本输入输出系统 NetBIOS 扫描模块中，管理员选择 192.168.0.102 主机作为当前的目标主机，该主机为当前的主机 IP，显示出的结果与实际相符，其扫描结果如图所示： NetBIOSScan SNMP 扫描功能模块测试 在简单网络管理协议 SNMP 扫描功能模块中，管理员选择 192.168.0.102 主机作为当前的目标主机，该主机为当前的主机 IP，显示出的结果与实际相符，其扫描结果如图所示： SNMPScan 弱密码扫描功能模块测试 在弱密码扫描功能模块中，管理员选择 192.168.0.102 主机作为当前的目标主机，该主机为当前的主机 IP，用户名设置为 test，密码采用字典文件的方式去枚举，通过扫描出来的结果进行验证，可以确定该结果与实际相符，其扫描结果如图所示： WeakKeyScan 嗅探器扫描功能模块测试 在嗅探器扫描功能模块中，管理员添加 Pass、Password、pwd 三个关键字对本机进行监听，然后通过由服务器搭建的一个登陆提交表单的页面去提交用户名和密码，结果成功拦截到了响应的数据包，根据数据包内容，管理员可以判断该结果与实际相符合，其扫描结果如图所示： SnifferScan DOS 攻击功能模块测试 在DOS攻击功能模块中，管理员启动 2048 个线程对目标 IP 为 39.99.157.58 的 80 端口进行连接，然后再尝试访问网站，结果发现网站宕机，管理员可以判断该结果与预期相符合，其扫描结果如图所示： DosScan 注入检测功能模块测试 在注入检测功能模块中，为了测试结果，我尝试在服务器上搭建了一个简易的测试 Demo，网站由两部分构成，一个是登录页面 login.html，一个是验证是否登录成功的页面 respone.php，登录页面如图所示： login_input 如果以 welcome+ 用户名的形式返回则说明登录成功，登录成功的页面如图所示： login_succeed 如果登陆失败会返回“The username or password is wrong!”，登录失败的页面如图所示： login_failed login.html 源代码如图所示： login respone.php 源代码如图所示： respone 管理员根据以上测试分析可以得出结论，如果管理员把 welcome 一词当做注入漏洞的标志，若登录成功出现 welcome 一词，则说明网站存在注入漏洞，其结果如图所示： SQLScan
计算机网络课程设计报告-端口扫描程序设计.doc
07-16
### 计算机网络课程设计报告——端口扫描程序设计 #### 一、设计背景与目的 在计算机网络中，端口扫描是一项重要的技术手段，它可以帮助网络安全人员了解网络中的设备和服务状态，对于发现潜在的安全漏洞和进行...
端口扫描程序设计和实现.doc
12-14
端口扫描程序设计和实现是一种网络编程技术，旨在检测某个 IP 或某段 IP 计算机端口工作情况。本设计要求学生设计并实现一个端口扫描程序，检测远程主机某一个或一些端口是否开放。该程序需要使用 socket 编程技术，...
0513《编译原理》答案 设计并实现TINYC语言的扫描程序
03-25
很抱歉，但给定的文件内容实际上与题目要求的设计和实现TINYC语言的扫描程序并不相符。文件内容描述的是TWAIN接口，这是一个用于图像设备（如扫描仪）与应用程序之间通信的标准。TWAIN主要涉及的是图像数据的获取和...
端口扫描程序的设计与实现.doc
06-21
端口扫描程序的设计与实现 摘 要 计算机信息网络的发展加速了信息化时代的进程，但是随着社会网络化程度的增加， 对计算机网络的依赖也越来越大，网络安全问题也日益明显。端口扫描技术是发现安全 问题的重要手段之...
Windows网络与通信程序设计 (第2版) 扫描版 pdf
09-01
Windows网络与通信程序设计 第2版 .王艳平.扫描版.pdf
端口扫描程序的设计与实现
04-29
端口扫描程序，其中包含几种常用的端口扫描技术，还可以对IP范围扫描，以及同时扫描多个端口等功能
主机扫描程序设计
12-23
用C#编写的主机扫描程序，涵盖ping,MultiThreadPortScanbyTCPConnect,NormalPortScanbyTCPConnect,SuperScanbySYN内容
端口扫描程序代码课程设计
09-11
端口扫描，课程设计，非常完整的代码 计算机的朋友可以参考一下
端口扫描程序设计（详细的报告+源代码）.rar
11-28
端口扫描程序设计（详细的报告+源代码）c语言
毕业设计So Easy：基于C++实现网络扫描器
不脱发的程序猿
05-30 3892
本设计的最终目标是打造一个具有多种扫描功能的网络扫描器。该扫描器具有以下功能： 1、可视化的图形界面，旨在为用户提供友好的使用环境。 2、实现一些基本的扫描任务，如读取到目的主机的软硬件信息，开放的端口等等。 3、帮助用户去自动生成符合用户心理的扫描结果报告，并将扫描结果以文件的形式展现出了。
网络漏洞扫描器的设计与实现
lionzl的专栏
03-30 2465
网络漏洞扫描器的设计与实现，第一部分 李志强 (lizq_99@163.com) XML error: Please enter a value for the author element's jobtitle attribute, or the company-name element, or both. 简介： 漏洞扫描器是一种自
ICMP扫描程序设计实现：探索网络活动主机
"这篇报告是关于ICMP扫描程序的设计与实现，由长沙理工大学网络工程专业的学生帅哥在刘青老师的指导下完成。课程设计的主要目标是理解ICMP协议的重要性，学会编写ICMP扫描程序，并通过设计过程培养严谨的科学态度和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值