block.c

一个阻断tcp连接的程序。可以实时的抓包并且经过分析后阻断已建立的tcp联接。

#include "Block.h"
#include "capture.h"


PPPoE_Packet poe_packet; 
struct ip ip_packet;
struct tcphdr tcp_packet;
struct udphdr udp_packet;
struct rtp_g723 rtp_packet;

extern struct NatInfo pNat;
extern int g_iplen;


u_char aa[udpLen]={0x9c ,0x5e ,0x46 ,0x30 ,0xf0 ,0x22 ,0x08 ,0xe1 ,0x20 ,0x17 ,0x5a ,0xc4 ,0x8c ,0x00 ,0xa1 ,0x99 ,0x2a ,0xc5 ,0xf8 ,0x2b ,0x56 ,0x82 ,0x9b ,0x33 ,0x88 ,0xd2 ,0x36 ,0x1c ,0xd6 ,0x1c ,0x0b ,0x71 ,0x11 ,0x94 ,0x0a ,0x83 ,0xfe ,0x83 ,0xdf ,0xa4 ,0x56 ,0x9d ,0xf1 ,0x95 ,0x3f ,0xe7 ,0xba ,0x31};


inline u_short in_cksum(u_short *addr, int len)
{
    register int nleft = len;
    register u_short *w = addr;
    register int sum = 0;
    u_short answer = 0;

     /* Our algorithm is simple, using a 32 bit accumulator (sum), we add
      * sequential 16 bit words to it, and at the end, fold back all the
      * carry bits from the top 16 bits into the lower 16 bits. */

     while (nleft > 1) {
         sum += *w++;
         nleft -= 2;
     }

     /* mop up an odd byte, if necessary */
     if (nleft == 1) {
         *(u_char *)(&answer) = *(u_char *) w;
         sum += answer;
     }

     /* add back carry outs from top 16 bits to low 16 bits */
     sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
     sum += (sum >> 16); /* add carry */
     answer = ~sum; /* truncate to 16 bits */
     return(answer);
}


static void InitTcp()
{
	memset(&ip_packet, 0, sizeof(ip_packet));
	memset(&tcp_packet, 0, sizeof(tcp_packet));


	ip_packet.ip_hl = 5;
	ip_packet.ip_v = 4;
	ip_packet.ip_tos = 0x08;
	ip_packet.ip_len = sizeof(struct ip)+ sizeof(struct tcphdr);
	ip_packet.ip_off = 0;
	ip_packet.ip_ttl = 64;
	ip_packet.ip_p = IPPROTO_TCP;
	ip_packet.ip_sum = 0;

		
	//tcp_packet.rst = 1;
	//tcp_packet.fin = 1;
	tcp_packet.syn = 1;
	tcp_packet.psh = 1;
	tcp_packet.ack = 1;
	tcp_packet.doff = 5;
	tcp_packet.window = htons(65535);
	tcp_packet.check = 0;
}


void MakeTcp()
{

    struct cksum cksum;

    ip_packet.ip_dst.s_addr = pNat.s_source_ip;//dstaddr;
    ip_packet.ip_src.s_addr = pNat.s_dst_ip;//dstaddr;


    tcp_packet.seq = htonl(pNat.n_ack);
    tcp_packet.ack_seq = htonl(pNat.n_seq+1);//rand();//0;
    tcp_packet.source = htons(pNat.n_dst_port);//rand();
    tcp_packet.dest = htons(pNat.n_source_port);


    cksum.pseudo.daddr = pNat.s_source_ip;//dstaddr;
    cksum.pseudo.saddr = pNat.s_dst_ip;//random();


    cksum.pseudo.mbz = 0;
    cksum.pseudo.ptcl = IPPROTO_TCP;
    cksum.pseudo.tcpl = htons(sizeof(struct tcphdr));

    cksum.tcp = tcp_packet;

    tcp_packet.check = in_cksum((void *)&cksum, sizeof(cksum));

    return;
}



static void InitUdp()
{
	memset(&ip_packet, 0, sizeof(ip_packet));
	memset(&udp_packet, 0, sizeof(udp_packet));

	ip_packet.ip_hl = 5;
	ip_packet.ip_v = 4;
	ip_packet.ip_tos = 0;
	ip_packet.ip_len = sizeof(struct ip)+ sizeof(struct udphdr)
		     +sizeof(struct rtp_g723)+sizeof(aa);
	ip_packet.ip_off = 0;
	ip_packet.ip_ttl = 64;
	ip_packet.ip_p = IPPROTO_UDP;
	ip_packet.ip_sum = 0;

        udp_packet.check = 0;
        udp_packet.len = htons(sizeof(struct udphdr)
		+sizeof(struct rtp_g723) +sizeof(aa));

	return;
}


void MakeRtp()
{
    memset(&rtp_packet, 0, sizeof(rtp_packet));
    rtp_packet.ver=2;
    rtp_packet.pad=0;
    rtp_packet.ext=0;
    rtp_packet.csrc_count=0;

    rtp_packet.mark=0;
    rtp_packet.payload=4;

    rtp_packet.seq= htons(pNat.rtp_seq +1);
    rtp_packet.stamp =htonl(pNat.rtp_stamp +50);

    rtp_packet.ssrc = htonl(pNat.rtp_ssrc);

    return;
};



void MakeUdp()
{
        struct cksum_udp cksum_udp;

        ip_packet.ip_dst.s_addr = pNat.s_dst_ip;//dstaddr;
        ip_packet.ip_src.s_addr = pNat.s_source_ip;//srcaddr;


        udp_packet.source = htons(pNat.n_source_port);
        udp_packet.dest = htons(pNat.n_dst_port);
	MakeRtp();
                                             
        cksum_udp.pseudo.daddr = pNat.s_dst_ip;//dstaddr;
        cksum_udp.pseudo.saddr = pNat.s_source_ip;//random();
        cksum_udp.pseudo.mbz = 0;
        cksum_udp.pseudo.ptcl = IPPROTO_UDP;
        cksum_udp.pseudo.tcpl = htons(sizeof(struct udphdr) 
			+sizeof(struct rtp_g723) +sizeof(aa));

        cksum_udp.udp = udp_packet;
	cksum_udp.rtp = rtp_packet;

	memcpy(cksum_udp.data, aa, sizeof(aa));

        udp_packet.check = in_cksum((void *)&cksum_udp, sizeof(cksum_udp));

        return;

}



void MakePoe()
{
	/* Set destination to Ethernet broadcast address */
	memcpy(poe_packet.ethHdr.h_dest, pNat.src_mac, ETH_ALEN);
	memcpy(poe_packet.ethHdr.h_source, pNat.dst_mac, ETH_ALEN);

	poe_packet.ethHdr.h_proto = htons(0x8864);
	poe_packet.ver = 1;
	poe_packet.type = 1;
	poe_packet.code = 0x00;
	poe_packet.session = htons(pNat.sess_id);

	poe_packet.length = htons(128);
	poe_packet.p_proto = htons(0x0021);
	
	return;
}


int BlockPoeTcp()
{
	int fd;
	struct sockaddr sa;
	struct ifreq ifr;
	char pack_msg[128]={0};
	int optval=1;
	int fromlen=0;
	int ret=0;

	InitTcp();
	MakeTcp();
	MakePoe();

	memcpy(pack_msg,(u_char*)&poe_packet, sizeof(poe_packet));
	memcpy(pack_msg+(sizeof(poe_packet)),(u_char*)&ip_packet,sizeof(ip_packet));
	memcpy(pack_msg+(sizeof(poe_packet)+ sizeof(ip_packet)),
		(u_char*)&tcp_packet,sizeof(tcp_packet));


	if ((fd = socket(PF_INET, SOCK_PACKET, htons(0x8864))) < 0) {
		printf("create socket error!");
	}

	/* Fill in hardware address */
	strncpy(ifr.ifr_name, "eth0", sizeof(ifr.ifr_name));
	if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) {
		printf("ioctl(SIOCGIFHWADDR)");
	}


	/* Sanity check on MTU */
	strncpy(ifr.ifr_name, "eth0", sizeof(ifr.ifr_name));
	if (ioctl(fd, SIOCGIFMTU, &ifr) < 0) {
		printf("ioctl(SIOCGIFMTU)");
	}

	if (ifr.ifr_mtu < ETHERMTU) {
		perror("MTU");
	}


	memset(&sa, 0, sizeof(sa));
	sa.sa_family = AF_INET;
	strcpy(sa.sa_data, "eth0");

	/* We're only interested in packets on specified interface */
	if (bind(fd, (struct sockaddr *) &sa, sizeof(struct sockaddr)) < 0) {
		perror("bind");
		return -1;
	}

	fromlen = sizeof(struct sockaddr);	


	if (sendto(fd, pack_msg, 128, 0, &sa,
			 fromlen) < 0) {
		perror("sendto (sendPacket)");
		return -1;
	}
	else
		printf("success:%d",ret);

	close(fd);
	return 1;
}




int BlockEthTcp()
{
	int fd;
	struct sockaddr_in sa;
	char pack_msg[128]={0};
	int optval=1;
	static int i=0;

	//set dest address
	bzero(&sa, sizeof(sa));
	sa.sin_family = AF_INET;
	sa.sin_addr.s_addr = pNat.s_source_ip;
	sa.sin_port = pNat.n_source_port;


	InitTcp();
	MakeTcp();


	memcpy(pack_msg,(u_char*)&ip_packet,sizeof(ip_packet));
	memcpy(pack_msg+ sizeof(ip_packet),
		(u_char*)&tcp_packet,sizeof(tcp_packet));


	if ((fd = socket(PF_INET, SOCK_RAW, IPPROTO_TCP)) < 0) {
		printf("create socket error!");
		return 0;
	}
	
	setsockopt(fd, IPPROTO_IP, IP_HDRINCL, (char*)&optval, sizeof(optval));
	
	if(sendto(fd,pack_msg,sizeof(struct tcphdr)+sizeof(struct ip),0,
	    (struct sockaddr *)&sa,sizeof(sa))<0)
	{
		perror("tcp:");
	}
	
	printf("%d\n",i++);
	close(fd);	
	return 1;
}




int BlockEthUdp()
{
	int fd;
	struct sockaddr_in sa;
	char pack_msg[128]={0};
	int optval=1;
	static int i=0;

	//set dest address
	bzero(&sa, sizeof(sa));
	sa.sin_family = AF_INET;
	sa.sin_addr.s_addr = pNat.s_dst_ip;
	sa.sin_port = pNat.n_dst_port;


	InitUdp();
	MakeUdp();

	memcpy(pack_msg,(u_char*)&ip_packet,sizeof(ip_packet));
	memcpy(pack_msg+ sizeof(ip_packet),
		(u_char*)&udp_packet,sizeof(udp_packet));
	memcpy(pack_msg+ sizeof(ip_packet)+sizeof(struct udphdr),
		(u_char*)&rtp_packet, sizeof(rtp_packet));
	memcpy(pack_msg+ sizeof(ip_packet)+sizeof(struct udphdr)
		+sizeof(struct rtp_g723),aa,sizeof(aa));


	if ((fd = socket(PF_INET, SOCK_RAW, IPPROTO_UDP)) < 0) {
		printf("create socket error!");
		return 0;
	}
	
	setsockopt(fd, IPPROTO_IP, IP_HDRINCL, (char*)&optval, sizeof(optval));
	

	if(sendto(fd,pack_msg,sizeof(struct udphdr)+sizeof(struct ip)
	    +sizeof(struct rtp_g723)+sizeof(aa),0,
	    (struct sockaddr *)&sa,sizeof(sa))<0)
	{
		perror("udp:");
	}
	
	printf("sd:%d\n",i++);
	close(fd);	
	return 1;
}