---
title: "ＶＣ＋＋实现SYN扫描"
author: "winzenghua"
date: "2009-03-29T18:33:00Z"
tags: []
slug: "syn"
draft: false
lastmod: "2009-03-29T18:33:00Z"
id: 948143
url: "https://java4gis.iteye.com/blog/948143"
---

#include &lt;winsock2.h&gt;  
#include &lt;ws2tcpip.h&gt;  
#include &lt;stdio.h&gt;

#include &lt;time.h&gt;  
#include "mstcpip.h"  
#pragma comment(lib,"ws2\_32.lib")  
#define SEQ 0x28376839

SOCKET sockRaw = INVALID\_SOCKET,  
sockListen = INVALID\_SOCKET;  
struct sockaddr\_in dest;

BOOL ScanOK=FALSE;  
char \*DEST\_HOST;  
int DEST\_PORT;  
int DEST\_PORTEND;  
int play=0;  
clock\_t start,end;//程序运行的起始和结束时间  
float costtime;//程序耗时

typedef struct \_iphdr  
{  
unsigned char h\_lenver; //4位首部长度+4位IP版本号  
unsigned char tos; //8位服务类型TOS  
unsigned short total\_len; //16位总长度（字节）  
unsigned short ident; //16位标识  
unsigned short frag\_and\_flags; //3位标志位  
unsigned char ttl; //8位生存时间 TTL  
unsigned char proto; //8位协议 (TCP, UDP 或其他)  
unsigned short checksum; //16位IP首部校验和  
unsigned int sourceIP; //32位源IP地址  
unsigned int destIP; //32位目的IP地址  
}IP\_HEADER;

typedef struct \_tcphdr //定义TCP首部  
{  
USHORT th\_sport; //16位源端口  
USHORT th\_dport; //16位目的端口  
unsigned int th\_seq; //32位序列号  
unsigned int th\_ack; //32位确认号  
unsigned char th\_lenres; //4位首部长度/6位保留字  
unsigned char th\_flag; //6位标志位  
USHORT th\_win; //16位窗口大小  
USHORT th\_sum; //16位校验和  
USHORT th\_urp; //16位紧急数据偏移量  
}TCP\_HEADER;

struct //定义TCP伪首部  
{  
unsigned long saddr; //源地址  
unsigned long daddr; //目的地址  
char mbz;  
char ptcl; //协议类型  
unsigned short tcpl; //TCP长度  
}psd\_header;

//SOCK错误处理程序  
void CheckSockError(int iErrorCode, char \*pErrorMsg)  
{  
if(iErrorCode==SOCKET\_ERROR)  
{  
printf("%s Error:%d\\n", pErrorMsg, GetLastError());  
closesocket(sockRaw);  
ExitProcess(-1);  
}

}

//计算检验和  
USHORT checksum(USHORT \*buffer, int size)  
{  
unsigned long cksum=0;  
while (size &gt; 1)  
{  
cksum += \*buffer++;  
size -= sizeof(USHORT);  
}  
if (size)  
{  
cksum += \*(UCHAR\*)buffer;  
}  
cksum = (cksum &gt;&gt; 16) + (cksum & 0xffff);  
cksum += (cksum &gt;&gt;16);  
return (USHORT)(~cksum);  
}

//IP解包程序  
bool DecodeIPHeader(char \*buf, int bytes)  
{  
IP\_HEADER \*iphdr;  
TCP\_HEADER \*tcphdr;  
unsigned short iphdrlen;  
iphdr = (IP\_HEADER \*)buf;  
iphdrlen = sizeof(unsigned long) * (iphdr-&gt;h\_lenver & 0xf);  
tcphdr = (TCP\_HEADER\*)(buf + iphdrlen);  
//是否来自目标IP  
if(iphdr-&gt;sourceIP != dest.sin\_addr.s\_addr) return false;

//序列号是否正确  
if((ntohl(tcphdr-&gt;th\_ack) != (SEQ+1)) && (ntohl(tcphdr-&gt;th\_ack) != SEQ)) return false;  
//if(tcphdr-&gt;th\_flag == 20)return true;  
//SYN/ACK - 扫描到一个端口  
if(tcphdr -&gt;th\_flag == 18)  
{  
printf("\\t%d\\t open \\n",ntohs(tcphdr-&gt;th\_sport));  
return true;  
}

return true;  
}

void usage(void)  
{  
printf("\\t===================SYN portscaner======================\\n");  
printf("\\t============gxisone@hotmail.com 2004/7/6===========\\n");  
printf("\\tusage: synscan DomainName\[IP] StartPort-EndPort\\n");  
printf("\\tExample: synscan [www.163.com](http://www.163.com) 1-139\\n");  
printf("\\tExample: synscan 192.168.1.1 8000-9000\\n");  
}

DWORD WINAPI RecvThread(LPVOID para)//接收数据线程函数  
{  
int iErrorCode;  
struct hostent \*hp;  
char RecvBuf\[65535]={0};  
sockListen = socket(AF\_INET , SOCK\_RAW , IPPROTO\_IP);  
CheckSockError(sockListen, "socket");

//设置IP头操作选项  
BOOL bOpt = true;  
iErrorCode = setsockopt(sockRaw,IPPROTO\_IP,IP\_HDRINCL,(char \*)&bOpt,sizeof(bOpt));  
CheckSockError(iErrorCode, "setsockopt()");

//获得本地IP  
SOCKADDR\_IN sa;  
unsigned char LocalName\[256];

iErrorCode = gethostname((char\*)LocalName,sizeof(LocalName)-1);  
CheckSockError(iErrorCode, "gethostname()");  
if((hp = gethostbyname((char\*)LocalName)) == NULL)  
{  
CheckSockError(SOCKET\_ERROR, "gethostbyname()");  
}  
memcpy(&sa.sin\_addr.S\_un.S\_addr,hp-&gt;h\_addr\_list\[1],hp-&gt;h\_length);  
sa.sin\_family = AF\_INET;  
sa.sin\_port = htons(7000);  
iErrorCode = bind(sockListen, (PSOCKADDR)&sa, sizeof(sa));  
CheckSockError(iErrorCode, "bind");

//设置SOCK\_RAW为SIO\_RCVALL，以便接收所有的IP包  
DWORD dwBufferLen\[10] ;  
DWORD dwBufferInLen = 1 ;  
DWORD dwBytesReturned = 0 ;  
iErrorCode=WSAIoctl(sockListen, SIO\_RCVALL,&dwBufferInLen, sizeof(dwBufferInLen),&dwBufferLen, sizeof(dwBufferLen),&dwBytesReturned , NULL , NULL );  
CheckSockError(iErrorCode, "Ioctl");  
memset(RecvBuf, 0, sizeof(RecvBuf));  
//接收数据  
for(;;)  
{

iErrorCode = recv(sockListen, RecvBuf, sizeof(RecvBuf), 0);  
//CheckSockError(iErrorCode, "recv");  
DecodeIPHeader(RecvBuf,iErrorCode) ;  
}  
if(ScanOK)  
{  
closesocket(sockListen);  
return 0;  
}  
}

void playx(void) // 定义状态提示函数  
{  
// 进度条  
char \*plays\[12]=  
{  
" | ",  
" / ",  
" - ",  
" \\\\ ",  
" | ",  
" / ",  
" - ",  
" \\\\ ",  
" | ",  
" / ",  
" - ",  
" \\\\ ",  
};  
printf(" =%s=\\r", plays\[play]);  
play=(play==11)?0:play+1;  
Sleep(2);  
}

//主函数  
int main(int argc,char \*\*argv)  
{  
char \*p;  
if(argc!=3)  
{  
usage();  
return 0;  
}

p=argv\[2];//处理端口参数  
if(strstr(argv\[2],"-"))  
{ DEST\_PORT=atoi(argv\[2]);  
for(;\*p;)  
if(\*(p++)=='-')break;  
DEST\_PORTEND=atoi(p);

if(DEST\_PORT&lt;1 || DEST\_PORTEND&gt;65535)  
{ printf("Port Error!\\n");  
return 0;  
}

}

DEST\_HOST=argv\[1];

usage();

int iErrorCode;  
int datasize;  
struct hostent \*hp;  
IP\_HEADER ip\_header;  
TCP\_HEADER tcp\_header;  
char SendBuf\[128]={0};

//初始化SOCKET  
WSADATA wsaData;  
iErrorCode = WSAStartup(MAKEWORD(2,2),&wsaData);  
CheckSockError(iErrorCode, "WSAStartup()");  
sockRaw = socket(AF\_INET , SOCK\_RAW , IPPROTO\_IP);  
CheckSockError(sockRaw, "socket()");  
sockListen = socket(AF\_INET , SOCK\_RAW , IPPROTO\_IP);  
CheckSockError(sockListen, "socket");

//设置IP头操作选项  
BOOL bOpt = true;  
iErrorCode = setsockopt(sockRaw,IPPROTO\_IP,IP\_HDRINCL,(char \*)&bOpt,sizeof(bOpt));  
CheckSockError(iErrorCode, "setsockopt()");

//获得本地IP  
SOCKADDR\_IN sa;  
unsigned char LocalName\[256];

iErrorCode = gethostname((char\*)LocalName,sizeof(LocalName)-1);  
CheckSockError(iErrorCode, "gethostname()");  
if((hp = gethostbyname((char\*)LocalName)) == NULL)  
{  
CheckSockError(SOCKET\_ERROR, "gethostbyname()");  
}

memcpy(&sa.sin\_addr.S\_un.S\_addr,hp-&gt;h\_addr\_list\[1],hp-&gt;h\_length);  
sa.sin\_family = AF\_INET;  
sa.sin\_port = htons(7000);  
iErrorCode = bind(sockListen, (PSOCKADDR)&sa, sizeof(sa));  
CheckSockError(iErrorCode, "bind");

//获得目标主机IP  
memset(&dest,0,sizeof(dest));  
dest.sin\_family = AF\_INET;  
dest.sin\_port = htons(DEST\_PORT);  
if((dest.sin\_addr.s\_addr = inet\_addr(DEST\_HOST)) == INADDR\_NONE)  
{  
if((hp = gethostbyname(DEST\_HOST)) != NULL)  
{  
memcpy(&(dest.sin\_addr),hp-&gt;h\_addr\_list\[1],hp-&gt;h\_length);  
dest.sin\_family = hp-&gt;h\_addrtype;  
printf("dest.sin\_addr = %s\\n",inet\_ntoa(dest.sin\_addr));  
}  
else  
{  
CheckSockError(SOCKET\_ERROR, "gethostbyname()");  
}  
}

//开启监听线程  
HANDLE Thread=CreateThread(NULL,0,RecvThread,0,0,0);

//填充IP首部  
ip\_header.h\_lenver=(4&lt;&lt;4 | sizeof(ip\_header)/sizeof(unsigned long));  
//高四位IP版本号，低四位首部长度  
ip\_header.total\_len=htons(sizeof(IP\_HEADER)+sizeof(TCP\_HEADER)); //16位总长度（字节）  
ip\_header.ident=1; //16位标识  
ip\_header.frag\_and\_flags=0; //3位标志位  
ip\_header.ttl=128; //8位生存时间TTL  
ip\_header.proto=IPPROTO\_TCP; //8位协议(TCP,UDP…)  
ip\_header.checksum=0; //16位IP首部校验和  
ip\_header.sourceIP=sa.sin\_addr.s\_addr; //32位源IP地址  
ip\_header.destIP=dest.sin\_addr.s\_addr; //32位目的IP地址

//填充TCP首部  
tcp\_header.th\_sport=htons(7000); //源端口号  
tcp\_header.th\_lenres=(sizeof(TCP\_HEADER)/4&lt;&lt;4|0); //TCP长度和保留位  
tcp\_header.th\_win=htons(16384);

//填充TCP伪首部（用于计算校验和，并不真正发送）  
psd\_header.saddr=ip\_header.sourceIP;  
psd\_header.daddr=ip\_header.destIP;  
psd\_header.mbz=0;  
psd\_header.ptcl=IPPROTO\_TCP;  
psd\_header.tcpl=htons(sizeof(tcp\_header));

Sleep(500);  
printf("\\n");  
printf("Scaning %s\\n",DEST\_HOST);  
start=clock();//开始计时

for(;DEST\_PORT&lt;DEST\_PORTEND;DEST\_PORT++)  
{

playx();  
tcp\_header.th\_dport=htons(DEST\_PORT); //目的端口号  
tcp\_header.th\_ack=0; //ACK序列号置为0  
tcp\_header.th\_flag=2; //SYN 标志  
tcp\_header.th\_seq=htonl(SEQ); //SYN序列号  
tcp\_header.th\_urp=0; //偏移  
tcp\_header.th\_sum=0; //校验和  
//计算TCP校验和，计算校验和时需要包括TCP pseudo header  
memcpy(SendBuf,&psd\_header,sizeof(psd\_header));  
memcpy(SendBuf+sizeof(psd\_header),&tcp\_header,sizeof(tcp\_header));  
tcp\_header.th\_sum=checksum((USHORT \*)SendBuf,sizeof(psd\_header)+sizeof(tcp\_header));

//计算IP校验和  
memcpy(SendBuf,&ip\_header,sizeof(ip\_header));  
memcpy(SendBuf+sizeof(ip\_header),&tcp\_header,sizeof(tcp\_header));  
memset(SendBuf+sizeof(ip\_header)+sizeof(tcp\_header),0,4);  
datasize=sizeof(ip\_header)+sizeof(tcp\_header);  
ip\_header.checksum=checksum((USHORT \*)SendBuf,datasize);

//填充发送缓冲区  
memcpy(SendBuf,&ip\_header,sizeof(ip\_header));

//发送TCP报文  
iErrorCode=sendto(sockRaw,SendBuf,datasize,0,(struct sockaddr\*) &dest,  
sizeof(dest));  
CheckSockError(iErrorCode, "sendto()");  
}  
end=clock();//计时结束  
ScanOK=TRUE;  
printf("Closeing Thread.....\\n");  
WaitForSingleObject(Thread,5000);  
CloseHandle(Thread);

costtime= (float)(end - start) / CLOCKS\_PER\_SEC; //转换时间格式  
printf("Cost time:%f Sec",costtime);//显示耗时

//退出前清理  
if(sockRaw != INVALID\_SOCKET) closesocket(sockRaw);  
WSACleanup();  
return 0;  
}