端口多线程扫描

检测端口是否打开有几种方式，比如

TCP connect扫描：（优点：不需要权限、可以同时扫描多个端口。缺点：容易被察觉）。

SYN扫描：（半开放扫描，利用TCP三次握手，发送SYN标志，端口开放，则会返回正常的SYN+ACK标志的TCP报文，否则反馈RST标志报文）。

ACK扫描（构造含有ACK标志的TCP报文到主机，不能确定端口关闭或者开放，因为主机收到ACK报文，不管端口是否开放，都会返回RST标志报文，但是可以用来检测防火墙配置，看防火墙是否过滤了这个端口）。

FIN扫描等（构造含有FIN标志的TCP报文到主机，返回RST标志报文，则端口关闭，无反应，则表示端口打开）。

以下用connect方式检测，速度快。

// MultiThreadScan.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <WinSock2.h>
#include <windows.h>
#include <filesystem>

#pragma comment(lib,"ws2_32.lib");//system32/ws2_32.dll

#define OK 0
#define ERR -1

#define SCAN_IP "192.168.1.109"
#define SCAN_START_PORT 80
#define SCAN_END_PORT 91
#define THREAD_MAX 10

#define  IPADDR_LEN 16

unsigned short g_ausThreadState[THREAD_MAX] = { 0 };

typedef struct tagScanInfo
{
    char szIpAddr[IPADDR_LEN];
    unsigned short usPort;
    unsigned short usThreadIdx;
}SCAN_INFO_S;

#define TEST_PTR 0//不建议用指针，因为传入参数可能会因为线程启动问题导致错误
//线程函数,共同使用变量导致的冲突
DWORD WINAPI ScanPort(LPVOID lpParam)
{
    SOCKET iFd;
    SOCKADDR_IN stTarget = { 0 };
    int iConnRet;
    SCAN_INFO_S stScan = { 0 };
    SCAN_INFO_S *pstScan;

    if (TEST_PTR)
    {
        pstScan = (SCAN_INFO_S *)lpParam;//这也是一种强制转换方法，结果和下面mencpy()结果一样，

        printf("\n[Thread:%d] Scan:%s:%u", pstScan->usThreadIdx, pstScan->szIpAddr, pstScan->usPort);

        stTarget.sin_family = AF_INET;
        stTarget.sin_addr.s_addr = inet_addr(pstScan->szIpAddr);
        stTarget.sin_port = htons(pstScan->usPort);//h:host to n:net s:short

        //TCP连接申请套接字，发送时候，向socket里面写数据，接收时取数据
        iFd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (iFd < 0)
        {
            return OK;
        }

        //发起连接，通过ifd进行通许
        iConnRet = connect(iFd, (SOCKADDR*)&stTarget, sizeof(SOCKADDR));
        if (iConnRet == OK)
        {
            printf("\n[Thread:%d] %s:PORT:%u is open", pstScan->usThreadIdx, pstScan->szIpAddr, pstScan->usPort);
        }
        else
        {
            printf("\n[Thread:%d] %s:PORT:%u is close", pstScan->usThreadIdx, pstScan->szIpAddr, pstScan->usPort);
        }
    }
    else
    {
        memcpy(&stScan, lpParam, sizeof(SCAN_INFO_S));//相当于把参数做了一次强制转换,注意和strcpy区别
        printf("\n[Thread:%d] Scan:%s:%u", stScan.usThreadIdx, stScan.szIpAddr, stScan.usPort);

        stTarget.sin_family = AF_INET;
        stTarget.sin_addr.s_addr = inet_addr(stScan.szIpAddr);
        stTarget.sin_port = htons(stScan.usPort);//h:host to n:net s:short

        //TCP连接申请套接字，发送时候，向socket里面写数据，接收时取数据
        iFd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (iFd < 0)
        {
            return OK;
        }

        //发起连接，通过ifd进行通许
        iConnRet = connect(iFd, (SOCKADDR*)&stTarget, sizeof(SOCKADDR));
        if (iConnRet == OK)
        {
            printf("\n[Thread:%d] %s:PORT:%u is open", stScan.usThreadIdx, stScan.szIpAddr, stScan.usPort);
        }
        else
        {
            printf("\n[Thread:%d] %s:PORT:%u is close", stScan.usThreadIdx, stScan.szIpAddr, stScan.usPort);
        }
    }
    
    closesocket(iFd);
    g_ausThreadState[stScan.usThreadIdx] = 0;//标记线程结束
    return OK;
}

//单线程扫描
//int ScanPort1(char szIpAddr[], unsigned short usPort)
//{
//    SOCKET iFd;
//    SOCKADDR_IN stTarget = { 0 };
//    int iConnRet;
//
//    stTarget.sin_family = AF_INET;
//    stTarget.sin_addr.s_addr = inet_addr(szIpAddr);
//    stTarget.sin_port = htons(usPort);//h:host to n:net s:short
//
//    //TCP连接申请套接字，发送时候，向socket里面写数据，接收时取数据
//    iFd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
//    if (iFd < 0)
//    {
//        return OK;
//    }
//
//    //发起连接，通过ifd进行通许
//    iConnRet = connect(iFd, (SOCKADDR*)&stTarget, sizeof(SOCKADDR));
//    if (iConnRet==OK)
//    {
//        printf("\n%s:PORT:%u is open",szIpAddr,usPort);
//    }
//    else
//    {
//        printf("\n%s:PORT:%u is close", szIpAddr, usPort);
//    }
//
//    closesocket(iFd);
//    return OK;
//}

int StartScan()
{
    WSADATA stWsa;
    HANDLE hThread[THREAD_MAX] = { 0 };
    unsigned short usPort = SCAN_START_PORT;
    SCAN_INFO_S stScan = { 0 };

    memcpy(stScan.szIpAddr, SCAN_IP, IPADDR_LEN);

    if (WSAStartup(0x0202, &stWsa) != OK)
    {
        return ERR;
    }

    //循环扫描某个ip的某个端口
    while (usPort <= SCAN_END_PORT)
    {
        for (int i = 0; i < THREAD_MAX; ++i)
        {
            if (0 == g_ausThreadState[i])
            {
                if (hThread[i] != 0)
                {
                    CloseHandle(hThread[i]);
                }
                stScan.usPort = usPort;
                stScan.usThreadIdx = i;
                g_ausThreadState[i] = 1;
                hThread[i] = CreateThread(NULL, 0, ScanPort, &stScan, 0, NULL);
                usPort++;
                if (usPort>=SCAN_END_PORT)
                {
                    break;
                }
                Sleep(100);//不sleep也会导致结构体资源冲突
            }
        }
        //ScanPort1(SCAN_IP, usPort);
    }

    WSACleanup();
    return OK;
}

int _tmain(int argc, _TCHAR* argv[])
{
    StartScan();
    system("pause");
    return 0;
}