Könnt ihr mir helfen? Ich habe mir eine Firewall gebaut. Normalerweise funktioniert die auch, nur heute hat sie komischerweise versagt, was eigentlich nicht sein kann!

INTERFACE_HANDLE interfaceHandle;
FILTER_HANDLE filterHandle;

	PF_FILTER_DESCRIPTOR filter;

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

	unsigned long myIp = LongToIp("192.168.0.5");

	PBYTE localIp = (PBYTE)&myIp;

	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("0.0.0.0");

	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, 1, &filter, &filterHandle);

Dieser Code sollte doch JEGLICHE Pakete mit der übergebenen IP nicht mehr durchlassen? Tut es aber. Hat gestern funktioniert, die IP wurde geblockt. Heute nicht mehr, die Pakete kommen durch.

Was kann ich tun?
MfG

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

MFG

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

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.

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?

[/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?

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!

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

Dieses Posting wurde automatisch erzeugt.

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

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

Dieses Posting wurde automatisch erzeugt.

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

Danke! Das API ist ja mal scheisse beschrieben.
MfG