脚本如何检测端口是否开放

本文目录导读：

1. Python 脚本（推荐）
2. 批量端口扫描脚本
3. Bash Shell 脚本
4. 使用 nmap 工具
5. Go 语言脚本
6. 注意事项
7. 选择建议

检测端口是否开放有多种方法,以下是几种常见脚本实现方案：

Python 脚本（推荐）

#!/usr/bin/env python3
import socket
import sys
def check_port(host, port, timeout=2):
    """检测端口是否开放"""
    try:
        # 创建socket对象
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(timeout)
        # 尝试连接
        result = sock.connect_ex((host, port))
        sock.close()
        if result == 0:
            return True
        else:
            return False
    except Exception as e:
        print(f"错误: {e}")
        return False
if __name__ == "__main__":
    if len(sys.argv) != 3:
        print(f"用法: {sys.argv[0]} <主机> <端口>")
        sys.exit(1)
    host = sys.argv[1]
    port = int(sys.argv[2])
    if check_port(host, port):
        print(f"端口 {port} 在 {host} 上是开放的")
    else:
        print(f"端口 {port} 在 {host} 上未开放")

批量端口扫描脚本

#!/usr/bin/env python3
import socket
import concurrent.futures
import sys
def scan_port(host, port):
    """扫描单个端口"""
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(1)
        result = sock.connect_ex((host, port))
        sock.close()
        if result == 0:
            return port
        return None
    except:
        return None
def scan_ports(host, start_port, end_port, max_workers=50):
    """扫描端口范围"""
    open_ports = []
    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = []
        for port in range(start_port, end_port + 1):
            futures.append(executor.submit(scan_port, host, port))
        for future in concurrent.futures.as_completed(futures):
            result = future.result()
            if result:
                open_ports.append(result)
    return sorted(open_ports)
if __name__ == "__main__":
    # 示例：扫描常见端口
    host = "127.0.0.1"
    open_ports = scan_ports(host, 1, 1000)
    print(f"主机 {host} 开放端口:")
    for port in open_ports:
        print(f"  {port}")

Bash Shell 脚本

#!/bin/bash
# 检测单个端口
check_port() {
    local host=$1
    local port=$2
    local timeout=$3
    # 使用 /dev/tcp 特殊文件 (Bash 内置)
    if timeout $timeout bash -c "echo >/dev/tcp/$host/$port" 2>/dev/null; then
        return 0
    else
        return 1
    fi
}
# 使用 netcat
check_port_nc() {
    local host=$1
    local port=$2
    if nc -zv $host $port 2>&1 | grep -q "succeeded"; then
        return 0
    else
        return 1
    fi
}
# 主函数
host="127.0.0.1"
port=80
if check_port $host $port 2; then
    echo "端口 $port 在 $host 上开放"
else
    echo "端口 $port 在 $host 上未开放"
fi

使用 nmap 工具

#!/bin/bash
# 需要先安装 nmap
# apt-get install nmap  # Ubuntu/Debian
# yum install nmap     # CentOS/RHEL
nmap -p 22,80,443 192.168.1.1  # 检测特定端口
nmap -p 1-1000 192.168.1.1     # 检测端口范围
nmap -p 80 --open 192.168.1.1  # 只显示开放端口

Go 语言脚本

package main
import (
    "fmt"
    "net"
    "os"
    "strconv"
    "time"
)
func checkPort(host string, port int) bool {
    address := net.JoinHostPort(host, strconv.Itoa(port))
    conn, err := net.DialTimeout("tcp", address, 2*time.Second)
    if err != nil {
        return false
    }
    conn.Close()
    return true
}
func main() {
    if len(os.Args) != 3 {
        fmt.Printf("Usage: %s <host> <port>\n", os.Args[0])
        os.Exit(1)
    }
    host := os.Args[1]
    port, err := strconv.Atoi(os.Args[2])
    if err != nil {
        fmt.Println("Invalid port number")
        os.Exit(1)
    }
    if checkPort(host, port) {
        fmt.Printf("Port %d on %s is open\n", port, host)
    } else {
        fmt.Printf("Port %d on %s is closed\n", port, host)
    }
}

注意事项

1. 网络权限：某些环境可能限制端口扫描
2. 防火墙影响：防火墙可能阻止连接或返回误导信息
3. 超时设置：根据网络状况调整超时时间
4. 并发控制：批量扫描时注意不要过度占用资源
5. 法律合规：只扫描自己有权限的主机

选择建议

• 简单检测：使用 Python 或 Bash 脚本
• 批量扫描：使用 Python 多线程或 nmap
• 性能要求高：使用 Go 或 C 语言
• 集成到系统：使用 Python 脚本更方便

根据具体需求选择合适的方案即可。