{

Raw Packet Sender

using: Delphi + Winsock 2

Copyright (c) 2000 by E.J.Molendijk (<a href="mailto:xes@dds.nl">xes@dds.nl</a>)

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

Перед использованием измените значения SrcIP+SrcPort+

DestIP+DestPort на нужные!

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

}

unit main;

interface

uses

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

 StdCtrls, OleCtrls, Registry;

Const

 SrcIP = '123.123.123.1';

 SrcPort = 1234;

 DestIP = '123.123.123.2';

 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 // !!! also 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 пакета

 SOCK_RAW = 3; // интерфейс raw-протокола

 IPPROTO_IP = 0; // dummy for IP

 IPPROTO_TCP = 6; // tcp

 IPPROTO_UDP = 17; // user datagram protocol

 IPPROTO_RAW = 255; // raw IP пакет

 INVALID_SOCKET = TSocket(NOT(0));

 SOCKET_ERROR = -1;

var

 Form1: TForm1;

implementation

// Импортируем функции Winsock 2

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

//

// Description:

// This function calculates the 16-bit one's complement sum

// for the supplied buffer

//

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)[i];

  inc(i);

  Size := Size - SizeOf(Word);

 end;

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

 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

  // преобразуем ip адреса

  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);

  //

  // IP version goes in the high order 4 bits of ip_verlen. The

  // IP header length (in 32-bit words) goes in the lower 4 bits.

  //

  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; // время жизни пакета

  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 ;

  //

  // Build the UDP pseudo-header for calculating the UDP checksum.

  // The pseudo-header consists of the 32-bit source IP address,

  // the 32-bit destination IP address, a zero byte, the 8-bit

  // IP protocol field, the 16-bit UDP length, and the UDP

  // header itself along with its data (padded with a 0 if

  // the data is odd length).

  //

  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;

  //

  // Now assemble the IP and UDP headers along with the data

  // so we can send it

  //

  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));

  // Apparently, this SOCKADDR_IN structure makes no difference.

  // Whatever we put as the destination IP addr in the IP header

  // is what goes. Specifying a different destination in remote

  // will be ignored.

  //

  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

  // Создаём сокет

  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;

  // строим пакет

  BuildHeaders( SrcIP, SrcPort,

  DestIP, DestPort,

  'THIS IS A TEST PACKET',

  Buf, Remote, iTotalSize );

  // Отправляем пакет

  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.');

  // Закрываем сокет

  CloseSocket(sh);

 finally

  // Закрываем Winsock 2

  WSACleanup;

 end;

end;

procedure TForm1.Button1Click(Sender: TObject);

begin

 SendIt;

end;

end.