Paket-Bombadierung trotz Software-Firewall

The-Kenny

Für mich sieht das garnicht nach Iso-C++ aus

Sorry, aber ich brauche dringend Hilfe.

Was könnte nicht stimmen, dass der Paket-Angriff meistens geblockt wird, aber eben nicht immer? Habe sogar eine Ausgabe in der Konsole für einen eventuellen Block. Also blockIp wird in jedem Fall ausgeführt, aber die Funktion tut nicht immer das, was sie sollte!

Also der Filter wurde gesetzt aber die IP hat fröhlich weitergesendet...

So sieht nun mein aktueller Code aus:

Main.h

#include "pcap.h"
#include <iostream>
#include <windows.h>
#include <Fltdefs.h>

typedef struct ip_address
{
	u_char byte1;
	u_char byte2;
	u_char byte3;
	u_char byte4;
} ip_address;

typedef struct ip_header
{
    u_char  ver_ihl;
    u_char  tos;
    u_short tlen;
    u_short identification;
    u_short flags_fo;
    u_char  ttl;
    u_char  proto;
    u_short crc;
    ip_address  saddr;
    ip_address  daddr;
    u_int   op_pad;
} ip_header;

typedef struct udp_header
{
    u_short sport;
    u_short dport;
    u_short len;
    u_short crc;
} udp_header;

void packetHandle(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data);

INTERFACE_HANDLE interfaceHandle;
FILTER_HANDLE filterHandle;

struct Data
{
	unsigned char byte1;
	unsigned char byte2;
	unsigned char byte3;
	unsigned char byte4;

	long second;

	void Add(unsigned char byte1, unsigned char byte2, unsigned char byte3, unsigned char byte4, long second)
	{
		this->byte1 = byte1;
		this->byte2 = byte2;
		this->byte3 = byte3;
		this->byte4 = byte4;

		this->second = second;
	}

	bool Compare(unsigned char byte1, unsigned char byte2, unsigned char byte3, unsigned char byte4)
	{
		if(this->byte1 == byte1 && this->byte2 == byte2 && this->byte3 == byte3 && this->byte4 == byte4)
			return true;
		else
			return false;
	}
}; Data currentData;

unsigned short packetCount = 0;

Main.cpp

unsigned long LongToIp(const char *ip)
{
	int octets[4];

	const char *auxCad = ip;
	unsigned long localIp = 0;

	for(int i = 0; i < 4; i++)
	{
		octets[i] = atoi(auxCad);

		if(octets[i] < 0 || octets[i] > 255)
			return 0;

		localIp |= (octets[i] << (i * 8));

		auxCad = strchr(auxCad, '.');

		if(auxCad == NULL && i != 3)
			return -1;

		auxCad++;
	}

	return localIp;
}

void blockIp(unsigned char ipByte1, unsigned char ipByte2, unsigned char ipByte3, unsigned char ipByte4)
{
	PF_FILTER_DESCRIPTOR filter;

	PfCreateInterface(0, PF_ACTION_FORWARD, PF_ACTION_FORWARD, FALSE, TRUE, &interfaceHandle); 

	BYTE localIp[] = {192, 168, 0, 5};

	PfBindInterfaceToIPAddress(interfaceHandle, PF_IPV4, localIp);

	filter.dwFilterFlags       = FD_FLAGS_NOSYN;
	filter.dwRule              = 0;
	filter.pfatType            = PF_IPV4;
	filter.wSrcPort            = FILTER_TCPUDP_PORT_ANY;
	filter.wSrcPortHighRange   = FILTER_TCPUDP_PORT_ANY;
	filter.wDstPort            = FILTER_TCPUDP_PORT_ANY;
	filter.wDstPortHighRange   = FILTER_TCPUDP_PORT_ANY;
	filter.fLateBound		   = 0;
	filter.dwProtocol          = FILTER_PROTO_ANY;

	unsigned long destinationIp = LongToIp("192.168.0.5");

	filter.DstAddr = (PBYTE)&destinationIp;
	filter.DstMask = (PBYTE)&destinationIp;

	in_addr inAddr;
	inAddr.S_un.S_un_b.s_b1 = ipByte1;
	inAddr.S_un.S_un_b.s_b2 = ipByte2;
	inAddr.S_un.S_un_b.s_b3 = ipByte3;
	inAddr.S_un.S_un_b.s_b4 = ipByte4;

	unsigned long sourceIp = LongToIp(inet_ntoa(inAddr));

	filter.SrcAddr = (PBYTE)&sourceIp;
	filter.SrcMask = (PBYTE)&sourceIp;

	PfAddFiltersToInterface(interfaceHandle, 1, &filter, 0, 0, &filterHandle);
}

int main()
{
    pcap_if_t *devices;
    pcap_t *deviceHandle;
    char errbuf[PCAP_ERRBUF_SIZE];

    pcap_findalldevs(&devices, errbuf);

	devices = devices->next;

    deviceHandle = pcap_open_live(devices->name, 65536, 1, 1000, errbuf);

    pcap_freealldevs(devices);

    pcap_loop(deviceHandle, 0, packetHandle, 0);

	PfRemoveFilterHandles(interfaceHandle, 1, &filterHandle);
	PfUnBindInterface(interfaceHandle);
	PfDeleteInterface(interfaceHandle);

    return 0;
}

void packetHandle(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data)
{
    ip_header *ih = (ip_header *)(pkt_data + 14);
	u_int ip_len = (ih->ver_ihl & 0xf) * 4;
	udp_header *uh = (udp_header *)((u_char*)ih + ip_len);

	if(ntohs(uh->dport) == 4664 && header->len == 117)
	{
		if(!packetCount)
			currentData.Add(ih->saddr.byte1, ih->saddr.byte2, ih->saddr.byte3, ih->saddr.byte4, header->ts.tv_sec);

		if(currentData.Compare(ih->saddr.byte1, ih->saddr.byte2, ih->saddr.byte3, ih->saddr.byte4))
		{
			if(header->ts.tv_sec == currentData.second)
				++packetCount;

			if(packetCount > 20)
			{
				blockIp(currentData.byte1, currentData.byte2, currentData.byte3, currentData.byte4);
				std::cout << "BLOCKED: " << (int)currentData.byte1 << "." << (int)currentData.byte2 << "." << (int)currentData.byte3 << "." << (int)currentData.byte4 << std::endl;
				packetCount = 0;
			}
		}
	}

	if(header->ts.tv_sec != currentData.second)
		packetCount = 0;
}

Also wenn eine IP mehr als 25 Pakete in der Sekunde mit der Größe 117 an port 4664 sendet, wird sie sofort geblockt. Hat wiegesagt immer funktioniert, aber eben nicht heute!

Was mache ich falsch? Benutze WinPCap.

Danke!
MfG

Hab was rausgefunden. Es funktioniert beim ersten IP block schnell, aber wenn danach eine andere IP angreift, dauert es 3x solange, bis der block reagiert.

Was kann da falsch sein? Hab es jetzt auch so gemacht, dass eine geblockte IP sofort in eine ausnahmeliste geworfen wird und nicht mehr überprüft wird, damit nicht mehrere filter angelegt werden.

Ohne Erfolg. Immer ab der zweiten unterschiedlichen Ip dauert es viel länger, bis der block greift. Die blockIp Funktion wird sofort aufgerufen, aber es werden noch 3 Sekunden lang die Pakete gesendet.

ich muss mich korrigieren:

Die erste IP wird geblockt, aber sobald eine neue IP sendet, wird zwar blockIp() aufgerufen, aber sie wird nicht geblockt!

jetzt mehrmals getestet, woran liegt das?

Hab grad nochwas rausgefunden:

[/cpp]
PfAddFiltersToInterface(interfaceHandle, 1, &filter, 0, 0, &filterHandle);

Sleep(2000);

PfRemoveFilterHandles(interfaceHandle, 1, &filterHandle);
PfUnBindInterface(interfaceHandle);
PfDeleteInterface(interfaceHandle);
[cpp]

So funktioniert es!

Kann es sein, dass man nicht mehrere FilterHandles/InterfaceHandles belegen darf?

Ohhh jetzt weiß ich es glaube ich!

Kann es sein, dass man für jeden Filter auch extra

INTERFACE_HANDLE interfaceHandle;
FILTER_HANDLE filterHandle;

anlegen muss? Habe die beiden nämlich global!

lolz

Wenn du für jeden ein neues Interface erstellst (was du ja tutst), dann ja.
Aber bist du dir sicher, dass du das auch musst?

C++ Forumbot

Dieser Thread wurde von Moderator/in HumeSikkins aus dem Forum C++ in das Forum C++/CLI mit .NET verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Nein bin mir nicht sicher. Aber ist ja auch egal. Ich möchte es jetzt so machen, kann es aber erst in der Nacht testen. So würde das doch endlich funktionieren:

void blockIp(unsigned char ipByte1, unsigned char ipByte2, unsigned char ipByte3, unsigned char ipByte4)
{
	INTERFACE_HANDLE *interfaceHandle = new INTERFACE_HANDLE;
	FILTER_HANDLE *filterHandle = new FILTER_HANDLE;
	PF_FILTER_DESCRIPTOR *filter = new PF_FILTER_DESCRIPTOR;

	PfCreateInterface(0, PF_ACTION_FORWARD, PF_ACTION_FORWARD, FALSE, TRUE, interfaceHandle); 

	unsigned char localIp[] = {192, 168, 0, 5};

	PfBindInterfaceToIPAddress(*interfaceHandle, PF_IPV4, localIp);

	filter->dwFilterFlags       = FD_FLAGS_NOSYN;
	filter->dwRule              = 0;
	filter->pfatType            = PF_IPV4;
	filter->wSrcPort            = FILTER_TCPUDP_PORT_ANY;
	filter->wSrcPortHighRange   = FILTER_TCPUDP_PORT_ANY;
	filter->wDstPort            = FILTER_TCPUDP_PORT_ANY;
	filter->wDstPortHighRange   = FILTER_TCPUDP_PORT_ANY;
	filter->fLateBound			= 0;
	filter->dwProtocol          = FILTER_PROTO_ANY;

	filter->DstAddr = localIp;
	filter->DstMask = localIp;

	in_addr inAddr;
	inAddr.S_un.S_un_b.s_b1 = ipByte1;
	inAddr.S_un.S_un_b.s_b2 = ipByte2;
	inAddr.S_un.S_un_b.s_b3 = ipByte3;
	inAddr.S_un.S_un_b.s_b4 = ipByte4;

	filter->SrcAddr = (unsigned char*)inet_ntoa(inAddr);
	filter->SrcMask = (unsigned char*)inet_ntoa(inAddr);

	PfAddFiltersToInterface(*interfaceHandle, 1, filter, 0, 0, filterHandle);
}

Kann da noch was vereinfacht werden? Mit dem Umwandeln und so und ist das überhaupt korrekt?

(Gehört das nicht in WINAPI? sorry)

Danke!
MfG

C++ Forumbot

Dieser Thread wurde von Moderator/in Jochen Kalmbach aus dem Forum C++/CLI mit .NET in das Forum WinAPI verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Ach, jo man darf anscheinend doch ned mehrere Interfaces erzeugen, dann geht der block nur für eine Ip.

Hab jetzt einmalig das Interface erzeugt und pro IP nur PF_FILTER_DESCRIPTOR.

Danke! Das API ist ja mal scheisse beschrieben.
MfG