syn扫描器c语言（syn端口扫描）

本篇文章给大家谈谈syn扫描器c语言，以及syn端口扫描对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、C语言与网络问题 高手进2、什么是端口扫描器?它有什么作用?3、linux 下C语言的syn扫描代码4、怎样用C语言实现网络抓包？5、100分求linux下C语言端口扫描代码

C语言与网络问题 高手进

ping命令是dos命令可以创建一个cmd进程,然后建立两个管道用来得到结果 实现.

下面是一个网络编程的实例, Syn扫描器代码,可以作为参考.

基本可以看为是 ping命令的实现

//getallIP.cpp

#include winsock2.h

#include stdio.h

#pragma comment(lib,”ws2_32.lib”)

int main()

{

////////////////

// 初始化 Windows sockets API.

//

WORD wVersionRequested = MAKEWORD(2, 2);

WSADATA wsaData;

if (WSAStartup(wVersionRequested, wsaData)) {

printf(“WSAStartup failed %s\n”, WSAGetLastError());

return 0;

}

//////////////////

// 获得主机名.

//

char hostname[256];

int res = gethostname(hostname, sizeof(hostname));

if (res != 0) {

printf(“Error: %u\n”, WSAGetLastError());

return 0;

}

printf(“hostname=%s\n”, hostname);

////////////////

// 根据主机名获取主机信息.

//

hostent* pHostent = gethostbyname(hostname);

if (pHostent==NULL) {

printf(“Error: %u\n”, WSAGetLastError());

return 0;

}

//////////////////

// 解析返回的hostent信息.

//

hostent he = *pHostent;

printf(“name=%s\naliases=%s\naddrtype=%d\nlength=%d\n”,

he.h_name, he.h_aliases, he.h_addrtype, he.h_length);

sockaddr_in sa;

//根据 he.h_addr_list[nAdapter]是否为空来获取所有IP地址

for (int nAdapter=0; he.h_addr_list[nAdapter]; nAdapter++) {

memcpy ( sa.sin_addr.s_addr, he.h_addr_list[nAdapter],he.h_length);

// 输出机器的IP地址.

printf(“Address [%d%]: %s\n”,nAdapter, inet_ntoa(sa.sin_addr)); // 显示地址串

}

//////////////////

// 终止 Windows sockets API

//

WSACleanup();

return 0;

}

//mstcpip.h

// Copyright (C) Microsoft Corporation, 1996-1999

#if _MSC_VER 1000

#pragma once

#endif

/* Argument structure for SIO_KEEPALIVE_VALS */

struct tcp_keepalive {

u_long onoff;

u_long keepalivetime;

u_long keepaliveinterval;

};

// New WSAIoctl Options

#define SIO_RCVALL _WSAIOW(IOC_VENDOR,1)

#define SIO_RCVALL_MCAST _WSAIOW(IOC_VENDOR,2)

#define SIO_RCVALL_IGMPMCAST _WSAIOW(IOC_VENDOR,3)

#define SIO_KEEPALIVE_VALS _WSAIOW(IOC_VENDOR,4)

#define SIO_ABSORB_RTRALERT _WSAIOW(IOC_VENDOR,5)

#define SIO_UCAST_IF _WSAIOW(IOC_VENDOR,6)

#define SIO_LIMIT_BROADCASTS _WSAIOW(IOC_VENDOR,7)

#define SIO_INDEX_BIND _WSAIOW(IOC_VENDOR,8)

#define SIO_INDEX_MCASTIF _WSAIOW(IOC_VENDOR,9)

#define SIO_INDEX_ADD_MCAST _WSAIOW(IOC_VENDOR,10)

#define SIO_INDEX_DEL_MCAST _WSAIOW(IOC_VENDOR,11)

//synscan.cpp

#include winsock2.h

#include ws2tcpip.h

#include stdio.h

#include time.h

#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 1)

{

cksum += *buffer++;

size -= sizeof(USHORT);

}

if (size)

{

cksum += *(UCHAR*)buffer;

}

cksum = (cksum 16) + (cksum 0xffff);

cksum += (cksum 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-h_lenver 0xf);

tcphdr = (TCP_HEADER*)(buf + iphdrlen);

//是否来自目标IP

if(iphdr-sourceIP != dest.sin_addr.s_addr) return false;

//序列号是否正确

if((ntohl(tcphdr-th_ack) != (SEQ+1)) (ntohl(tcphdr-th_ack) != SEQ)) return false;

//if(tcphdr-th_flag == 20)return true;

//SYN/ACK – 扫描到一个端口

if(tcphdr -th_flag == 18)

{

printf(“\t%d\t open \n”,ntohs(tcphdr-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 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-h_addr_list[1],hp-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_PORT1 || DEST_PORTEND65535)

{ 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-h_addr_list[1],hp-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-h_addr_list[1],hp-h_length);

dest.sin_family = hp-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=(44 | 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)/44|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_PORTDEST_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;

}

什么是端口扫描器?它有什么作用?

s 扫描器是一款命令行下高速扫描利器，通过最新的瑞星杀毒软件测试

命令: s.exe syn ip1 ip2 端口号 /save

s.exe tcp ip1 ip2 端口号 线程数 /save

s.exe扫描器的使用说明

首先我解释下什么是S扫描器，S扫描器是针对微软ms04045漏洞出的一个扫描，原来作者出这东西

的目的是为了扫描这个漏洞，但现在已经变成我们黑客手中的兵器了，大家也许看过很多如何找肉鸡的

动画或刷QB的动画，那些动画里面很多都是用S扫描器来扫描肉鸡或别人电脑所开放的端口及一些漏洞，

都用这工具的好处是它的扫描速度实在是一个字—强！ 今天我就来教下大家如何使用S扫描器。

简单说明下它的用处：

S扫描器是一个简单的使用两种常用的扫描方式进行端口扫描的端口扫描器程序.

可实现的功能是:

1.两种不同的扫描方式(SYN扫描和一般的connect扫描)

2.可以扫描单个IP或IP段所有端口

3.可以扫描单个IP或IP段单个端口

4.可以扫描单个IP或IP段用户定义的端口

5.可以显示打开端口的banner

6.可将结果写入文件

7.TCP扫描可自定义线程数

用法:scanner TCP/SYN StartIP [EndIP] Ports [Threads] [/Banner] [/Save]

参数说明:

TCP/SYN – TCP方式扫描或SYN方式扫描(SYN扫描需要在win 2k或以上系统才行),SYN扫描对本机无效

StartIP – 起始扫描的IP

EndIP – 结束扫描的IP,可选项,如果这一项没有，就只是对单个IP扫描

Ports – 可以是单个端口，连续的一段端口或非连续的端口

Threads – 使用最大线程数去扫描(SYN扫描不需要加这一项),不能超过1024线程

/Banner – 扫描端口时一并将Banner显示出来,这一选项只对TCP扫描有效

/Save – 将结果写入当前目录的Result.txt文件中去

打开S扫描器，下面我举几个例子演示下S扫描器的主要几个作用。

例子一:

S TCP 218.80.12.1 218.80.12.123 80 512

TCP扫描218.80.12.1到218.80.12.123这IP段中的80端口,最大并发线程是512

例子二：

S TCP 218.80.12.1 218.80.12.123 21,5631 512 /Banner

TCP扫描218.80.12.1到218.80.12.123这IP段中的21和5631端口,最大并发线程是512,并显示Banner

例子三：

S TCP 218.80.12.1 218.80.12.12 1-200 512

TCP扫描218.80.12.1到218.80.12.12这IP段中的1到200端口,最大并发线程是512

例子四：

S TCP 218.80.12.7 1-200 512

TCP扫描218.80.12.7这IP中的1到200端口,最大并发线程是512

例子五：

S SYN 218.80.12.7 1-65535 /Save

SYN扫描218.80.12.7这IP中的1到65535端口,将结果写入Result.txt

扫描结束后Result.txt就存放在你的S扫描器所在的目录里。刚才扫描的东西都在里面。

例子六：

S SYN 218.80.12.1 218.80.12.255 21 /Save

SYN扫描218.80.12.1到218.80.12.255这IP段中的21端口,将结果写入Result.txt

这个我重点说明一下，因为这条命令就是专门用来找肉鸡的，扫描一个IP段有没有开3389的或1433的

我示范下：S SYN 218.80.1.1 218.80.255.255 3389 /Save

注意:

1.SYN扫描是很依赖于扫描者和被扫描者的网速的,如果你是内网的系统，那你不一定可以使用SYN扫描的

，因为你的网关的类型会决定内网系统是否能进行SYN扫描.如果你的配置较低的话，我也不推荐使用

SYN扫描.SYN扫描速度是比TCP扫描的速度快很多的，但在稳定性方面却不是太好，所以自己决定使用

哪种模式进行扫描。

2.SYN扫描不需要线程那个参数，请看上面例子5和6

3.TCP扫描的最大并发线程不能超过1024.

4.使用SYN模式扫描，不能扫描Banner,具体为什么不能，请查看有关SYN的资料

5.内网用户的朋友可以用tcp扫描

关于S.exe 的用法和错误解释

S扫描器扫描命令是:

文件名 参数 起始IP 结束IP 要扫描的端口 保存

s SYN 61.0.0.0 61.255.255.255 1433 save

1433是SQL server 服务器端口

8080是代理服务器端口

linux 下C语言的syn扫描代码

//—————————————————————————

//Filename:ss.c

//Author:yunshu

//Write:2004-04-02

//Thanks Wineggdrop

//Modify:2004-09-08

//—————————————————————————

#include winsock2.h

#include ws2tcpip.h

#include mstcpip.h

#include stdio.h

#pragma comment(lib,”ws2_32.lib”)

////////////////////////////////////////////////////////////////

//全局变量

////////////////////////////////////////////////////////////////

#define srcPort 88

char srcIP[20] = ;//定义源地址

char tgtIP[20] = ;//定义目的地址

int portNow;//定义正在扫描的端口

//标准端口列表

int ports[20] = ;

typedef struct ip_hdr

{

unsigned char h_verlen; //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 tcp_hdr //定义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;

typedef struct tsd_hdr //定义TCP伪首部

{

unsigned long saddr; //源地址

unsigned long daddr; //目的地址

char mbz;

char ptcl; //协议类型

unsigned short tcpl; //TCP长度

}PSD_HEADER;

////////////////////////////////////////////////////////////////

//函数原形

////////////////////////////////////////////////////////////////

int send_packet();//发送数据函数

int recv_packet();//监听数据函数

USHORT checksum( USHORT *, int );//计算检验和函数

void usage( char * );//显示帮助函数

void check_port( char * );//判断端口是否开放函数

////////////////////////////////////////////////////////////////

//main函数

////////////////////////////////////////////////////////////////

int main( int argc , char *argv[] )

{

WSADATA WSAData;

DWORD thread_ID = 1;

char FAR hostname[128] = ;

HANDLE ThreadHandle[20];

struct hostent *phe;

if( argc != 2 )//检查命令行参数是否正确

{

usage( argv[0] );

exit( 0 );

}

if ( WSAStartup(MAKEWORD(2,2) , WSAData) )

{

printf(“WSAStartup Error…\n”);

exit(0);

}

strcpy(tgtIP,argv[1]);//得到目标主机的ip地址

gethostname(hostname,128);//获取本机主机名

phe = gethostbyname(hostname);//获取本机ip地址结构

if(phe == NULL)

{

printf(“Get LocalIP Error…\n”);

}

strcpy(srcIP, inet_ntoa(*((struct in_addr *)phe-h_addr_list[0])));//得到本机ip地址

//调试用，注释掉

//printf(“test\t%s\n”,tgtIP);

//printf(“test\t%s\n”,srcIP);

//开启新线程，接受数据包，分析返回的信息

HANDLE RecvHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)recv_packet,NULL,0,thread_ID);

Sleep(500);//休息一下再启动发送数据包函数

for(int tmp = 0; tmp 20; tmp++)

{

++thread_ID;

//要扫描的端口

portNow = ports[tmp];

//开启新线程，发送数据包

ThreadHandle[tmp] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)send_packet,NULL,0,thread_ID);

//防止生成线程过快，休息

Sleep(100);

}

DWORD WaitThread = WaitForMultipleObjects( 20 , ThreadHandle , TRUE , INFINITE );

if( WaitThread != WAIT_FAILED)

{

for( int n = 0 ; n 20 ; n++ )

{

CloseHandle( ThreadHandle[n] );

}

}

CloseHandle( RecvHandle );

WSACleanup();

return 0;

}

//计算检验和函数，完全抄别人的

USHORT checksum(USHORT *buffer, int size)

{

unsigned long cksum=0;

while(size 1)

{

cksum += *buffer++;

size -= sizeof(USHORT);

}

if(size)

{

cksum += *(UCHAR*)buffer;

}

cksum = (cksum 16) + (cksum 0xffff);

cksum += (cksum 16);

return (USHORT)(~cksum);

}

void usage(char *prog)

{

printf(“===========================================\n”);

printf(“Used To Scan Remote Host’s Ports\n”);

printf(“Usage:%s TargetIP\n”,prog);

printf(“===========================================\n”);

exit(0);

}

//发送数据包的函数

int send_packet()

{

SOCKET sendSocket;

BOOL flag;

int timeout;

SOCKADDR_IN sin;

IP_HEADER ipHeader;

TCP_HEADER tcpHeader;

PSD_HEADER psdHeader;

char szSendBuf[60] = ;

int ret;

unsigned long source_ip;

unsigned long target_ip;

//建立原生数据socket

if((sendSocket = WSASocket(AF_INET, SOCK_RAW, IPPROTO_RAW, NULL, 0, WSA_FLAG_OVERLAPPED)) == INVALID_SOCKET)

{

printf(“Socket Setup Error…\n”);

return 0;

}

//设置自己填充数据包

if(setsockopt(sendSocket, IPPROTO_IP, IP_HDRINCL, (char *)flag, sizeof(flag)) == SOCKET_ERROR)

{

printf(“Setsockopt IP_HDRINCL Error…\n”);

return 0;

}

//设置超时时间

timeout = 1000;

if(setsockopt(sendSocket, SOL_SOCKET, SO_SNDTIMEO, (char *)timeout, sizeof(timeout)) == SOCKET_ERROR)

{

printf(“Setsockopt SO_SNDTIMEO Error…\n”);

return 0;

}

target_ip = inet_addr(tgtIP);

source_ip = inet_addr(srcIP);

sin.sin_family = AF_INET;

sin.sin_port = htons(portNow);

sin.sin_addr.S_un.S_addr = target_ip;

//填充IP首部

ipHeader.h_verlen = (44 | sizeof(ipHeader)/sizeof(unsigned long));

ipHeader.total_len = htons(sizeof(ipHeader)+sizeof(tcpHeader));

ipHeader.ident = 1;

ipHeader.frag_and_flags = 0x40;

ipHeader.ttl = 128;

ipHeader.proto = IPPROTO_TCP;

ipHeader.checksum = 0;

ipHeader.sourceIP = source_ip;//源IP

ipHeader.destIP = target_ip;//目的IP

//填充TCP首部

tcpHeader.th_dport = htons(portNow);//目的端口

tcpHeader.th_sport = htons(srcPort); //源端口

tcpHeader.th_seq = 0x12345678;

tcpHeader.th_ack = 0;

tcpHeader.th_lenres = (sizeof(tcpHeader)/44|0);

tcpHeader.th_flag = 2;//syn标志位。0,2,4,8,16,32-FIN,SYN,RST,PSH,ACK,URG（推测,哈哈）

tcpHeader.th_win = htons(512);

tcpHeader.th_urp = 0;

tcpHeader.th_sum = 0;

//填充tcp伪首部

psdHeader.saddr = ipHeader.sourceIP;

psdHeader.daddr = ipHeader.destIP;

psdHeader.mbz = 0;

psdHeader.ptcl = IPPROTO_TCP;

psdHeader.tcpl = htons(sizeof(tcpHeader));

//计算TCP校验和

memcpy(szSendBuf, psdHeader, sizeof(psdHeader));

memcpy(szSendBuf + sizeof(psdHeader), tcpHeader, sizeof(tcpHeader));

tcpHeader.th_sum = checksum((USHORT *)szSendBuf, sizeof(psdHeader) + sizeof(tcpHeader));

//计算IP检验和

memcpy(szSendBuf, ipHeader, sizeof(ipHeader));

memcpy(szSendBuf + sizeof(ipHeader), tcpHeader, sizeof(tcpHeader));

memset(szSendBuf + sizeof(ipHeader) + sizeof(tcpHeader), 0, 4);

ipHeader.checksum = checksum((USHORT *)szSendBuf, sizeof(ipHeader) + sizeof(tcpHeader));

memcpy(szSendBuf, ipHeader, sizeof(ipHeader));

memcpy(szSendBuf + sizeof(ipHeader), tcpHeader, sizeof(tcpHeader));

//发送数据包

ret = sendto(sendSocket, szSendBuf, sizeof(ipHeader) + sizeof(tcpHeader), 0, (struct sockaddr*)sin, sizeof(sin));

if(ret == SOCKET_ERROR)

{

printf(“Send Packet Error…\n”);

return 0;

}

else return 1;

}

int recv_packet()

{

SOCKADDR_IN sniff;

SOCKET sock;

char recvBuffer[65000] = ;//缓冲区存放捕获的数据

//建立socket监听数据包

sock = socket(AF_INET,SOCK_RAW,IPPROTO_IP);

sniff.sin_family = AF_INET;

sniff.sin_port = htons(0);

sniff.sin_addr.s_addr = inet_addr(srcIP);

//绑定到本地随机端口

bind(sock,(PSOCKADDR)sniff,sizeof(sniff));

//设置SOCK_RAW为SIO_RCVALL，以便接收所有的IP包

//copy来的

DWORD dwBufferLen[10] ;

DWORD dwBufferInLen = 1 ;

DWORD dwBytesReturned = 0 ;

WSAIoctl(sock,SIO_RCVALL,dwBufferInLen,sizeof(dwBufferInLen),dwBufferLen,sizeof(dwBufferLen),dwBytesReturned,NULL,NULL);

while(TRUE)

{

memset(recvBuffer , 0 , sizeof(recvBuffer) );

//开始捕获数据包

int bytesRecived = recv(sock,recvBuffer,sizeof(recvBuffer),0);

if(bytesRecived = 0)

{

break;

}

check_port(recvBuffer);

}

return 1;

}

void check_port(char *buffer)

{

IP_HEADER *ipHeader;//IP_HEADER型指针

TCP_HEADER *tcpHeader;//TCP_HEADER型指针

ipHeader = (IP_HEADER *)buffer;

tcpHeader = (TCP_HEADER *) (buffer+sizeof(IP_HEADER));

if(ipHeader-sourceIP != inet_addr(tgtIP))

{

return;

}

for(int tmp=0;tmp20;tmp++)

{

//SYN+ACK – 2+16=18（也是推测，哈哈）

if(tcpHeader-th_flag == 18 tcpHeader-th_sport == htons(ports[tmp]))

{

printf(“[Found]\t%s\tport\t%d\tOpen\n”,tgtIP,ports[tmp]);

}

}

}

怎样用C语言实现网络抓包？

第一法则：站在巨人肩膀上 不要重复造轮子。

对于这种复杂的过程，第一选择是使用现成的，节约时间，提升效率。

Wireshark（前称Ethereal）是一个网络封包分析软件。网络封包分析软件的功能是撷取网络封包，并尽可能显示出最为详细的网络封包资料。Wireshark使用WinPCAP作为接口，直接与网卡进行数据报文交换。

网络封包分析软件的功能可想像成 “电工技师使用电表来量测电流、电压、电阻” 的工作 – 只是将场景移植到网络上，并将电线替换成网络线。在过去，网络封包分析软件是非常昂贵，或是专门属于营利用的软件。Ethereal的出现改变了这一切。在GNUGPL通用许可证的保障范围底下，使用者可以以免费的代价取得软件与其源代码，并拥有针对其源代码修改及客制化的权利。Ethereal是目前全世界最广泛的网络封包分析软件之一。

第二法则：学习 提升。

如果是单纯的学习知识，可以直接尝试写一些具有部分功能的程序，过程会有点艰难，但非常有意义。学习网络编程，需要了解 开放系统互连参考模型的的七层每一层的意义以及现实当中实现的四层的网络协议。然后就可以知道抓包的包位于模型当中的传输层协议，包括UDP和TCP的协议。进一步要学习每种协议的格式，表头，数据包等等。一句话，冰冻三尺非一日之寒。

Windows下的抓包及简单的编程。

Windows2000在TCP/IP协议组件上做了很多改进，功能也有增强。比如在协议栈上的调整，增大了默认窗口大小，以及高延迟链接新算法。同时在安全性上，可应用IPSec加强安全性，比NT下有不少的改进。

 Microsoft TCP/IP 组件包含“核心协议”、“服务”及两者之间的“接口”。传输驱动程序接口 (TDI) 与网络设备接口规范 (NDIS) 是公用的。 此外，还有许多用户模型应用程序的更高级接口。最常用的接口是 Windows Sockets、远程过程调用 (RPC) 和 NetBIOS。

 Windows Sockets 是一个编程接口，它是在加州大学伯克利分校开发的套接字接口的基础上定义的。它包括了一组扩展件，以充分利用 Microsoft Windows 消息驱动的特点。规范的 1.1 版是在 1993 年 1 月发行的，2.2.0 版在 1996 年 5 月发行。Windows 2000 支持 Winsock 2.2 版。在Winsock2中，支持多个传输协议的原始套接字，重叠I/O模型、服务质量控制等。

这里介绍Windows Sockets的一些关于原始套接字(Raw Socket)的编程。同Winsock1相比，最明显的就是支持了Raw Socket套接字类型，通过原始套接字，我们可以更加自如地控制Windows下的多种协议，而且能够对网络底层的传输机制进行控制。

1、创建一个原始套接字，并设置IP头选项。

SOCKET sock;

sock = socket(AF_INET,SOCK_RAW,IPPROTO_IP);

或者：

s = WSASoccket(AF_INET,SOCK_RAW,IPPROTO_IP,NULL,0,WSA_FLAG_OVERLAPPED);

 这里，我们设置了SOCK_RAW标志，表示我们声明的是一个原始套接字类型。创建原始套接字后，IP头就会包含在接收的数据中，如果我们设定 IP_HDRINCL 选项，那么，就需要自己来构造IP头。注意，如果设置IP_HDRINCL 选项，那么必须具有 administrator权限，要不就必须修改注册表：

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\Afd\Parameter\

修改键：DisableRawSecurity（类型为DWORD），把值修改为 1。如果没有，就添加。

BOOL blnFlag=TRUE;

setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (char *)blnFlag, sizeof(blnFlag);

 对于原始套接字在接收数据报的时候，要注意这么几点：

a、如果接收的数据报中协议类型和定义的原始套接字匹配，那么，接收的所有数据就拷贝到套接字中。

b、如果绑定了本地地址，那么只有接收数据IP头中对应的远端地址匹配，接收的数据就拷贝到套接字中。

c、如果定义的是外部地址，比如使用connect()，那么，只有接收数据IP头中对应的源地址匹配，接收的数据就拷贝到套接字中。

2、构造IP头和TCP头

这里，提供IP头和TCP头的结构：

// Standard TCP flags

#define URG 0x20

#define ACK 0x10

#define PSH 0x08

#define RST 0x04

#define SYN 0x02

#define FIN 0x01

typedef struct _iphdr //定义IP首部

{

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 psd_hdr //定义TCP伪首部

{

unsigned long saddr; //源地址

unsigned long daddr; //目的地址

char mbz;

char ptcl; //协议类型

unsigned short tcpl; //TCP长度

}PSD_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;

TCP伪首部并不是真正存在的，只是用于计算检验和。校验和函数：

USHORT checksum(USHORT *buffer, int size)

{

 unsigned long cksum=0;

 while (size 1)

 {

   cksum += *buffer++;

   size -= sizeof(USHORT);  

 }

 if (size)

 {

   cksum += *(UCHAR*)buffer;  

 }

 cksum = (cksum 16) + (cksum 0xffff);

 cksum += (cksum 16);

 return (USHORT)(~cksum);

}

 当需要自己填充IP头部和TCP头部的时候，就同时需要自己计算他们的检验和。

3、发送原始套接字数据报

 填充这些头部稍微麻烦点，发送就相对简单多了。只需要使用sendto()就OK。

sendto(sock, (char*)tcpHeader, sizeof(tcpHeader), 0, (sockaddr*)addr_in,sizeof(addr_in));

下面是一个示例程序，可以作为SYN扫描的一部分。

#include stdio.h

#include winsock2.h

#include ws2tcpip.h

#define SOURCE_PORT 7234

#define MAX_RECEIVEBYTE 255

typedef struct ip_hdr //定义IP首部

{

unsigned char h_verlen; //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地址

}IPHEADER;

typedef struct tsd_hdr //定义TCP伪首部

{

unsigned long saddr; //源地址

unsigned long daddr; //目的地址

char mbz;

char ptcl; //协议类型

unsigned short tcpl; //TCP长度

}PSDHEADER;

typedef struct tcp_hdr //定义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位紧急数据偏移量

}TCPHEADER;

//CheckSum:计算校验和的子函数

USHORT checksum(USHORT *buffer, int size)

{

unsigned long cksum=0;

while(size 1)

{

cksum+=*buffer++;

size -=sizeof(USHORT);

}

if(size )

{

cksum += *(UCHAR*)buffer;

}

cksum = (cksum 16) + (cksum 0xffff);

cksum += (cksum 16);

return (USHORT)(~cksum);

}

void useage()

{

printf(“******************************************\n”);

printf(“TCPPing\n”);

printf(“\t Written by Refdom\n”);

printf(“\t Email: refdom@263.net\n”);

printf(“Useage: TCPPing.exe Target_ip Target_port \n”);

printf(“*******************************************\n”);

}

int main(int argc, char* argv[])

{

WSADATA WSAData;

SOCKET sock;

SOCKADDR_IN addr_in;

IPHEADER ipHeader;

TCPHEADER tcpHeader;

PSDHEADER psdHeader;

char szSendBuf[60]={0};

BOOL flag;

int rect,nTimeOver;

useage();

if (argc!= 3)

{ return false; }

if (WSAStartup(MAKEWORD(2,2), WSAData)!=0)

{

printf(“WSAStartup Error!\n”);

return false;

}

if ((sock=WSASocket(AF_INET,SOCK_RAW,IPPROTO_RAW,NULL,0,WSA_FLAG_OVERLAPPED))==INVALID_SOCKET)

{

printf(“Socket Setup Error!\n”);

return false;

}

flag=true;

if (setsockopt(sock,IPPROTO_IP, IP_HDRINCL,(char *)flag,sizeof(flag))==SOCKET_ERROR)

{

printf(“setsockopt IP_HDRINCL error!\n”);

return false;

}

nTimeOver=1000;

if (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char*)nTimeOver, sizeof(nTimeOver))==SOCKET_ERROR)

{

printf(“setsockopt SO_SNDTIMEO error!\n”);

return false;

}

addr_in.sin_family=AF_INET;

addr_in.sin_port=htons(atoi(argv[2]));

addr_in.sin_addr.S_un.S_addr=inet_addr(argv[1]);

//

//

//填充IP首部

ipHeader.h_verlen=(44 | sizeof(ipHeader)/sizeof(unsigned long));

// ipHeader.tos=0;

ipHeader.total_len=htons(sizeof(ipHeader)+sizeof(tcpHeader));

ipHeader.ident=1;

ipHeader.frag_and_flags=0;

ipHeader.ttl=128;

ipHeader.proto=IPPROTO_TCP;

ipHeader.checksum=0;

ipHeader.sourceIP=inet_addr(“本地地址”);

ipHeader.destIP=inet_addr(argv[1]);

//填充TCP首部

tcpHeader.th_dport=htons(atoi(argv[2]));

tcpHeader.th_sport=htons(SOURCE_PORT); //源端口号

tcpHeader.th_seq=htonl(0x12345678);

tcpHeader.th_ack=0;

tcpHeader.th_lenres=(sizeof(tcpHeader)/44|0);

tcpHeader.th_flag=2; //修改这里来实现不同的标志位探测，2是SYN，1是FIN，16是ACK探测 等等

tcpHeader.th_win=htons(512);

tcpHeader.th_urp=0;

tcpHeader.th_sum=0;

psdHeader.saddr=ipHeader.sourceIP;

psdHeader.daddr=ipHeader.destIP;

psdHeader.mbz=0;

psdHeader.ptcl=IPPROTO_TCP;

psdHeader.tcpl=htons(sizeof(tcpHeader));

//计算校验和

memcpy(szSendBuf, psdHeader, sizeof(psdHeader));

memcpy(szSendBuf+sizeof(psdHeader), tcpHeader, sizeof(tcpHeader));

tcpHeader.th_sum=checksum((USHORT *)szSendBuf,sizeof(psdHeader)+sizeof(tcpHeader));

memcpy(szSendBuf, ipHeader, sizeof(ipHeader));

memcpy(szSendBuf+sizeof(ipHeader), tcpHeader, sizeof(tcpHeader));

memset(szSendBuf+sizeof(ipHeader)+sizeof(tcpHeader), 0, 4);

ipHeader.checksum=checksum((USHORT *)szSendBuf, sizeof(ipHeader)+sizeof(tcpHeader));

memcpy(szSendBuf, ipHeader, sizeof(ipHeader));

rect=sendto(sock, szSendBuf, sizeof(ipHeader)+sizeof(tcpHeader),

0, (struct sockaddr*)addr_in, sizeof(addr_in));

if (rect==SOCKET_ERROR)

{

printf(“send error!:%d\n”,WSAGetLastError());

return false;

}

else

printf(“send ok!\n”);

closesocket(sock);

WSACleanup();

return 0;

}

4、接收数据

 和发送原始套接字数据相比，接收就比较麻烦了。因为在WIN我们不能用recv()来接收raw socket上的数据，这是因为，所有的IP包都是先递交给系统核心，然后再传输到用户程序，当发送一个raws socket包的时候（比如syn），核心并不知道，也没有这个数据被发送或者连接建立的记录，因此，当远端主机回应的时候，系统核心就把这些包都全部丢掉，从而到不了应用程序上。所以，就不能简单地使用接收函数来接收这些数据报。

 要达到接收数据的目的，就必须采用嗅探，接收所有通过的数据包，然后进行筛选，留下符合我们需要的。可以再定义一个原始套接字，用来完成接收数据的任务，需要设置SIO_RCVALL，表示接收所有的数据。

SOCKET sniffersock;

sniffsock = WSASocket(AF_INET, SOCK_RAW, IPPROTO_IP, NULL, 0, WSA_FLAG_OVERLAPPED);

DWORD lpvBuffer = 1;

DWORD lpcbBytesReturned = 0 ;

WSAIoctl(sniffersock, SIO_RCVALL, lpvBuffer, sizeof(lpvBuffer), NULL, 0, lpcbBytesReturned, NULL, NULL);

 创建一个用于接收数据的原始套接字，我们可以用接收函数来接收数据包了。然后在使用一个过滤函数达到筛选的目的，接收我们需要的数据包。

如果在XP以上的操作系统，微软封杀了Raw Soccket，只能用wincpap之类的开发包了。

100分求linux下C语言端口扫描代码

linux tcp udp 端口扫描源程序

#include sys/socket.h

#include netinet/in.h

#include arpa/inet.h

#include unistd.h

#include errno.h

#include netdb.h

#include stdio.h

#include string.h

#include netinet/ip_icmp.h

#include stdlib.h

#include signal.h

#include libxml/parser.h

#include libxml/tree.h

#define TRUE 1

#define FALSE 0

#define UDP “UDP”

#define TCP “TCP”

#define tcp “tcp”

#define udp “udp”

typedef struct _GsSockStru{

int fd;

int len;

struct sockaddr_in addr;

}GsSockStru;

static int tcptest( char ip[32], char port[20]);

static int udptest( char ip[32], char port[20]);

void sig_alrm( int signo );

static GsSockStru test_sock;

int

main( int argc, char** argv)

{

char string[64];

char port[20];

char pro[20];

char ip[32];

int res;

int i = 0;

int k = 0;

if( argc2 || argc2 )

{

printf(“鍙傛暟涓嶆纭?-1\n”);

return ( -1 );

}

strcpy( string, argv[1]);

while( *string )

{

if( string[i] == ‘:’ )

break;

pro[k] = string[i];

k++;

i++;

}

pro[k] = ‘\0’;

i++;

k = 0;

while( *string )

{

if( string[i] == ‘:’)

break;

ip[k] = string[i];

k++;

i++;

}

ip[k] = ‘\0’;

i++;

k=0;

while( *string )

{

if( string[i] == ‘\0’)

break;

port[k] = string[i];

k++;

i++;

}

port[k] = ‘\0’;

i++;

memset( test_sock, 0, sizeof( test_sock ) );

if ( ( strcmp( TCP, pro) != 0 ) ( strcmp( UDP, pro) != 0 ) ( strcmp( tcp, pro) != 0 ) ( strcmp( udp, pro) != 0 ))

{

printf ( “鍙傛暟涓嶆纭?锛?\n” );

return (-1);

}

if ( strcmp( TCP, pro) == 0 || strcmp( tcp, pro) == 0 )

res = tcptest( ip, port );

if ( strcmp( UDP, pro) == 0 || strcmp( udp, pro) == 0 )

res = udptest( ip, port );printf(“%d\n”,res);

return ( res );

}

int

tcptest( char ip[32], char port[20])

{

int res;

struct timeval tv;

test_sock.fd = socket( AF_INET, SOCK_STREAM, 0 );

if ( test_sock.fd 0 )

{

printf( “create socket failed -3 \n” );

return ( -3 );

}

memset( ( test_sock.addr ), 0, sizeof( test_sock.addr ) );

test_sock.addr.sin_family = AF_INET;

test_sock.addr.sin_port = htons( atoi( port ) );

inet_pton( AF_INET, ip, test_sock.addr.sin_addr );

test_sock.len = sizeof( struct sockaddr );

tv.tv_sec = 10;

tv.tv_usec = 0;

setsockopt( test_sock.fd, SOL_SOCKET, SO_RCVTIMEO,

(const char *)tv, sizeof( tv ) );

res = connect( test_sock.fd,

( struct sockaddr * )( ( test_sock.addr ) ),

test_sock.len );

if ( res 0 )

{

fprintf( stderr, “connect failed 0\n” );

close( test_sock.fd );

return FALSE;

}

close( test_sock.fd );

return TRUE;

}

int udptest( char ip[32], char port[20])

{

struct icmphdr *icmp_header;

struct sockaddr_in target_info;

int target_info_len;

fd_set read_fd;

int scan_port;

char recvbuf[5000];

struct sockaddr_in target_addr;

int icmp_socket;

int udp_socket;

struct timeval tv;

icmp_header = (struct icmphdr *)(recvbuf+sizeof(struct iphdr));

scan_port = atoi( port );

target_addr.sin_family = AF_INET;

inet_pton( AF_INET, ip, target_addr.sin_addr );

target_addr.sin_port = htons(scan_port);

if ((udp_socket=socket(AF_INET,SOCK_DGRAM,0))==-1)

{

printf(“create socket failed -3\n”);

return -3;

}

if ((icmp_socket=socket(AF_INET,SOCK_RAW,IPPROTO_ICMP))==-1)

{

printf(“Create raw socket failed -3\n”);

return -3;

}

sendto(udp_socket,NULL,0,0,(void *)target_addr,sizeof(target_addr));

FD_ZERO(read_fd);

FD_SET(icmp_socket,read_fd);

tv.tv_sec = 1;

tv.tv_usec = 0;

select(FD_SETSIZE,read_fd,NULL,NULL,tv);

for (;;){

if (FD_ISSET(icmp_socket,read_fd))

{

target_info_len = sizeof(target_info);

recvfrom(icmp_socket,recvbuf,5000,0,

(struct sockaddr *)target_info,target_info_len);

if (target_info.sin_addr.s_addr == target_addr.sin_addr.s_addr

icmp_header-type == 3 icmp_header-code=12)

{

printf(“Port %d : Close\n”,scan_port);

return (0);

}

}

return (1) ;

}

}

syn扫描器c语言的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于syn端口扫描、syn扫描器c语言的信息别忘了在本站进行查找喔。