mini Firewall programmieren ??

[Gigant02]

moin moin

also ich wollte mal eine mini firewall programmieren

und zwar will ich nur einen Port sperren und wieder freigeben
wie mache ich sowas ??

wie läuft sowas generrell ??

lg, gigant

[DGL-luke]

einen port kannst du ganz einfach sperren, indem du ihn belegst.

du musst nur einen socket erstellen und an dem port lauschen lassen.

[Gigant02]

klingt sehr sehr interresant

aber was ist wenn der port schon von einer anderen software belegt ist ?? dann kann ich ihn ja nicht mehr belegen

wie kann ich denn den port für mich wieder freimachen ??

wenn ich lausche kann ich ja auch rausfinden welche ip mich auf den port pingen will

und wie gehe ich sowas an ich habe das noch nie gemacht


lg,

[Larsi]

auch wenns schon alt ist pushe :) ich mal die frage von gigant 02 bzw. ich will das gleiche wissen!

[Larsi]

der zweite Push

[KrasserChecker]

Schau dir mal "Layered Service Provider" (kurz: LSP) an, damit kann man genau so etwas machen.

[Larsi]

kannste mir da n link auser suchseiten :) geben???

[shmia]

Um eine Firewall für Windows zu programmieren, benötigt man schon recht tiefgreifende Kenntnisse von WinSock und der darunterliegenden NDIS Treiberschicht.
Man müsste einen NDIS Intermediate Driver programmieren.

Ab Windows XP und höher ist die Windows Firewall API verfügbar, was die Arbeit deutlich erleichtet.
http://msdn2.microsoft.com/en-us/library/aa366453(VS.85).aspx
Trotzdem ist das nichts für Anfänger.

[EConvertError]

iSafer muss hier erwähnt werden. Click!

Für Anfänger sicher nicht zu empfehlen, aber ich bin ganz gut damit zurechtgekommen. Unter Vista habe ich es noch nicht getestet.

Viel Spaß damit,
Andreas

[Larsi]

gibtsfür die windows firewall api n download bzw. ne aleitung/tutorial???

[Zacherl]

Steht doch alles im MSDN: http://msdn2.microsoft.com/en-us/library/aa366415(VS.85).aspx

[k4ni]

Ich hab hier mal was für dich:

Delphi-Quellcode:

unit DropAllU;
{
Aufruf:
   InstallFW('192.168.0.2');

und zum schluss:
   RemoveFW;
}

interface

   procedure InstallFW(MyIP: String);
   procedure RemoveFW;

implementation

uses Windows;

const
     IPHLPAPI = 'IPHLPAPI.DLL';

type
  PFFORWARD_ACTION  =  Integer;
  PPFFORWARD_ACTION =  ^PPFFORWARD_ACTION;
  //
  INTERFACE_HANDLE  =  Pointer;
  //
  PFADDRESSTYPE     =  Integer;
  PPFADDRESSTYPE    =  ^PFADDRESSTYPE;
  //
  TByteArray        =  Array [0..Pred(MaxInt)] of Byte;
  PByteArray        =  ^TByteArray;
  TIpBytes          =  Array [0..3] of Byte;

const
  PF_ACTION_DROP    =  1;

const
  PF_IPV4           =  0;

function   PfCreateInterface(
           dwName:           DWORD;
           inAction:         PFFORWARD_ACTION;
           outAction:        PFFORWARD_ACTION;
           bUseLog:          BOOL;
           bMustBeUnique:    BOOL;
           var ppInterface:  INTERFACE_HANDLE): DWORD;
           stdcall; external IPHLPAPI name '_PfCreateInterface@24';

function   PfDeleteInterface(
           pInterface:       INTERFACE_HANDLE): DWORD;
           stdcall; external IPHLPAPI name '_PfDeleteInterface@4';

function   PfBindInterfaceToIPAddress(
           pInterface:       INTERFACE_HANDLE;
           pfatLinkType:     PFADDRESSTYPE;
           IPAddress:        PByteArray): DWORD;
           stdcall; external IPHLPAPI name '_PfBindInterfaceToIPAddress@12';

function   PfUnBindInterface(
           pInterface:       INTERFACE_HANDLE): DWORD;
           stdcall; external IPHLPAPI name '_PfUnBindInterface@4';

var
   Handle_Interface : INTERFACE_HANDLE = nil;

function StrToInt(S: PChar): Integer;
begin
   Result := 0;
   if S = '' then Exit;
   while S^ in ['0'..'9'] do begin
      Result := Result * 10 + Integer(S^) - Integer('0');
      Inc( S );
   end;
end;

function StrToIpBytes( IpStr: String ): TIpBytes;
var N : Integer;
begin
   N := 0;
   while Pos('.', IpStr)>0 do begin
      Result[N] := StrToInt(@Copy(IpStr, 1, Pos('.', IpStr) - 1)[1]);
      Delete(IpStr, 1, Pos('.', IpStr));
      Inc(N);
   end;
   Result[N] := StrToInt(@IpStr[1]);
end;

procedure InstallFW(MyIP: String);
var
   IpLocal : TIpBytes;
begin
   if (MyIP <> '') and Not Assigned(Handle_Interface) then begin
      FillChar(IpLocal, 4, #0);
      IpLocal := StrToIpBytes(MyIP);

      PfCreateInterface(0, PF_ACTION_DROP, PF_ACTION_DROP, False, False, Handle_Interface);
      PfBindInterfaceToIPAddress(Handle_Interface, PF_IPV4, @ipLocal);
   end;
end;

procedure RemoveFW;
begin
   if Assigned(Handle_Interface) then begin
      PfUnBindInterface(Handle_Interface);
      PfDeleteInterface(Handle_Interface);
      Handle_Interface := nil;
   end;
end;

end.

Credits dafür an x000x.

Das schließt allerdings alle ports. Doch ich will auch irgendwie hinbekommen damit es nur einen einzigen schließt. Doch ich kriegs nich hin :gruebel:

[Larsi]

und was muss ich daüfr an uses einbinden??? und wenn man das dann macht, wird dann auch zb der internetaufbau von firefox gestoppt oder können sich diese programme dem wiedersetzen???

[Die Muhkuh]

Larsi, ich möchte Dir ja nicht zu Nahe treten, aber ich denke, dass eine eigene Firewall doch noch etwas zu hoch für Dich ist.

Wie Andreas schon erwähnt hat, braucht man einiges an Wissen und wenn Du nicht mal Imstande bist, Dir Informationen selbst zu ergoogln (siehe Deine Posts #7 und #10), ist Dein Vorhaben schon von vorneherein zum Scheitern verurteilt.

[Larsi]

da hast du wohl rech aber es wäre trotzdem nett wenn mir jemand sagen könnte was ich in die usues einbinden soll :lol:

[Die Muhkuh]

Du hast eine komplette (funktionierende) Unit. Da brauchst Du nichts mehr in Uses einbinden. Du musst letztendlich nur diese Unit in Dein Programm einbinden und die entsprechenden Funktionen aufrufen.

[Larsi]

ok. in dem code da stand ja ganz oben als kommentar sowas wie 192.22.2.3 sperren oder so. dann wird doch da gar nicht alles gesperrt oder???

[Die Muhkuh]

Wenn Du lesen würdest, was k4ni geschrieben hat:

Zitat:

Zitat von k4ni

Das schließt allerdings alle ports.

[k4ni]

Speicher die unit unter DropAllU.pas ab und füge es am besten in den ordner des projects ein.
Dann einfach DropAllU zu uses hinzufügen und um die Firewall zu aktivieren benützt du
InstallFw('local ip here');
und zum entfernen bzw. deaktivieren benützt du
RemoveFw();

Um die local ip zu ermitteln hab ich hier noch was für dich:

Delphi-Quellcode:

uses .., .., WinSock;
..
function LocalIP:string;
var
  WSA  : TWSAData;
  ILen : integer;
  PHst : PChar;
  PHEn : PHostEnt;
begin
  WSAStartup( $0101, WSA );
  ILen := $FF;
  PHst := StrAlloc( ILen );
  gethostname( PHst, ILen );
  PHEn := gethostbyname( PHst );

  with PHEn^ do  result:=format(
   '%d.%d.%d.%d',
   [ord(h_addr^[ 0 ]), ord(h_addr^[ 1 ]),
   ord(h_addr^[ 2 ]), ord(h_addr^[ 3 ])]
  );

  {Nuke the string}
  StrDispose( PHst );

  {Dust and Clean}
  WSACleanup;

end;

Hab ich bin Hier

[Hador]

Zitat:

Zitat von Larsi

da hast du wohl rech aber es wäre trotzdem nett wenn mir jemand sagen könnte was ich in die usues einbinden soll :lol:

Zitat:

Zitat von k4ni

Delphi-Quellcode:

uses Windows;

Ließ doch einfach mal das, was man dir schreibt

EDIT: Da hat ein kleines rotes etwas wohl mal wieder Urlaub

[Die Muhkuh]

Lars, Du bist gute 2 Stunden zu spät und hast wohl auch die zweite Seite nicht gesehen? :zwinker:

[Hador]

Zitat:

Zitat von Die Muhkuh

Lars, Du bist gute 2 Stunden zu spät und hast wohl auch die zweite Seite nicht gesehen? :zwinker:

Oh Gott, ich glaub ich sollte ins Bett gehen :oops:
'n paar Studen durchgehend Mathe zu machen scheint wohl dem Gehirn der Aufmerksamkeit zu schaden :wink:

[k4ni]

Weis jemand von euch wie man die InstallFW function von DropAllU auf einzelne ports eingrenzen kann?

[x000x]

Moin moin,

ich hab die Unit von oben mal so angepasst, dass eben nur ein Port geblockt wird.
In meinem Fall:
Alle ausgehenden Pakete, die als Ziel eine beliebige IP haben und dort auf Port 80 wollen
Alle eingehenden Pakete, die von einer beliebigen IP kommen und deren Quellport eben 80 ist.

Ansonsten wird nix geblockt.

Das Beispiel ist ohne Fehlerbehandlung - ich denke das kann jeder selber einbauen und anpassen...

Delphi-Quellcode:

procedure InstallFW(MyIP: String);
var
   IpLocal      : TIpBytes;
   ipOther      : TIpBytes;
   ipOtherMask  : TIpBytes;
   ipMy         : TIpBytes;
   ipMyMask     : TIpBytes;
begin
   if (MyIP <> '') and Not Assigned(Handle_Interface) then begin
      FillChar(IpLocal, 4, #0);
      IpLocal := StrToIpBytes(MyIP);

      PfCreateInterface(0, PF_ACTION_FORWARD, PF_ACTION_FORWARD, False, False, Handle_Interface);
      PfBindInterfaceToIPAddress(Handle_Interface, PF_IPV4, @ipLocal);

      //
      ipMy        := StrToIpBytes(PChar(MyIP));
      ipMyMask    := StrToIpBytes('255.255.255.255');
      //
      ipOther     := StrToIpBytes('0.0.0.0');
      ipOtherMask := StrToIpBytes('0.0.0.0');

      // Eingehende Pakete
      ZeroMemory(@ipFltIn, SizeOf(ipFltIn));
      ipFltIn.dwFilterFlags      := 0;
      ipFltIn.dwRule             := 0;
      ipFltIn.pfatType           := PF_IPV4;
      ipFltIn.fLateBound         := 0;
      ipFltIn.dwProtocol         := FILTER_PROTO_TCP;

      ipFltIn.wDstPort           := FILTER_TCPUDP_PORT_ANY;
      ipFltIn.wDstPortHighRange  := FILTER_TCPUDP_PORT_ANY;
      ipFltIn.DstAddr            := @ipMy;
      ipFltIn.DstMask            := @ipMyMask;
      ipFltIn.wSrcPort           := 80;
      ipFltIn.wSrcPortHighRange  := 80;
      ipFltIn.SrcAddr            := @ipOther;
      ipFltIn.SrcMask            := @ipOtherMask;

      // Ausgehende Pakete
      ZeroMemory(@ipFltOut, SizeOf(ipFltOut));
      ipFltOut.dwFilterFlags      := 0;
      ipFltOut.dwRule             := 0;
      ipFltOut.pfatType           := PF_IPV4;
      ipFltOut.fLateBound         := 0;
      ipFltOut.dwProtocol         := FILTER_PROTO_TCP;
      ipFltOut.wDstPort           := 80;
      ipFltOut.wDstPortHighRange  := 80;
      ipFltOut.DstAddr            := @ipOther;
      ipFltOut.DstMask            := @ipOtherMask;
      ipFltOut.wSrcPort           := FILTER_TCPUDP_PORT_ANY;
      ipFltOut.wSrcPortHighRange  := FILTER_TCPUDP_PORT_ANY;
      ipFltOut.SrcAddr            := @ipMy;
      ipFltOut.SrcMask            := @ipMyMask;

      PfAddFiltersToInterface(Handle_Interface, 1, @ipFltIn, 1, @ipFltOut, nil);
   end;
end;

PS: Es handelt sich hier NICHT um eine Firewall, sondern lediglich nur um einen Paketfilter!

[k4ni]

Danke danke danke danke!!
Das hät ich in 100 jahren nicht hinbekommen :D Vielen dank!

[Larsi]

Hi,
hab das njetzt nochmal ausprobiert aber irgendwie kommt beim compilen immer dieser Fehler:
[Pascal Fehler] DropallU.pas(24): E2086 Typ 'PPFFORWARD_ACTION' ist nicht vollständig definiert
[Pascal Fataler Fehler] Unit3.pas(7): F2063 Verwendete Unit 'DropallU.pas' kann nicht compiliert werden

[x000x]

Moin moin,

kommt der Fehler auch, wenn du mein Beispielcode unverändert kompilierst?

[Larsi]

Ja, ich hab nichts verändert! Kann mir jemand mal ne exe hochladen ich möchte mal sehen ob's geht :) :) :) Also jetzt von dem was alle blockiert

[x000x]

Moin moin,

hab dann keine Ideen... Hab kein Turbo Delphi hier um des zu testen.
Aber die kompilierte EXE kannste haben... Wie gesagt, blockt nur Port 80 und
WinXP SP2 ist Vorraussetzung. Unter Vista wird es nicht funktionieren.

[MorphieX]

funktioniert ja schon extrem gut!

nur hab ich die Geschichte mit dem Regeln-Erstellen nicht so ganz verstanden...
Wie würde es dann z.B. aussehen, wenn ich alle Ports -bis auf ein paar (von mir ausgewählte)- sperren wollte?


Würd mich über ne Antwort sehr freuen!! :P

[x000x]

Moin moin,

in dem du das Interface mit Parameter PF_ACTION_DROP erstellst. Also

Delphi-Quellcode:

   PfCreateInterface(0, PF_ACTION_DROP, PF_ACTION_DROP, False, False, Handle_Interface);

Jetzt wird von Haus aus alles geblockt, nur die Pakete die deinen Regeln entsprechen, werden durchgelassen.

[MorphieX]

Okay, wie ich alle Ports blockiere, wusste ich schon, nur haperts bei mir daran, spezielle Ports wieder freizugeben.

Wie sieht denn so ein "Filter" aus, der spezielle Ports durchlässt?
In deinem Beispiel auf Seite 2 war der Filter ja dafür verantwortlich, dass die Ports zu einer bestimmten IP "geforwardet" *g* werden, das kann ich hier sicher so nicht verwenden, oder?

[Sherlock]

Edit: OMG...da hingen ja noch ein paar Seiten hinten dran...sorry...Bis ebens tand hier noch obsoleter, überflüssiger Quatsch.

Sherlock

[x000x]

Doch kannst du. Wenn du genau das Beispiel nimmst und nur PF_ACTION_FORWARD durch PF_ACTION_DROP ersetzt,
werden alle Pakete die von irgendeiner IP mit QuellPort 80 kommen durchgelassen. Und alle Pakete die deinen
Rechner verlassen wollen und als Zielport 80 haben, werden ebenfalls durchgelassen.

Wenn du genau dieses Beispiel testen willst, solltest du auch noch den Port 53 dazunehmen, da sonst die
Namensauflösung nicht funktioniert (ist ja ebenfalls geblockt).

[Morphie]

Hmmm, dann bin ich da wohl zu blööd zu ;-)

Delphi-Quellcode:

procedure netzsperren(MyIP: String);
var
   IpLocal      : TIpBytes;
   ipOther      : TIpBytes;
   ipOtherMask  : TIpBytes;
   ipMy         : TIpBytes;
   ipMyMask     : TIpBytes;
begin
   if (MyIP <> '') and Not Assigned(Handle_Interface) then begin
      FillChar(IpLocal, 4, #0);
      IpLocal := StrToIpBytes(MyIP);

      PfCreateInterface(0, PF_ACTION_DROP, PF_ACTION_DROP, False, False, Handle_Interface); 
      PfBindInterfaceToIPAddress(Handle_Interface, PF_IPV4, @ipLocal); 


      ipMy        := StrToIpBytes(PChar(MyIP));
      ipMyMask    := StrToIpBytes('255.255.255.255');
      //
      ipOther     := StrToIpBytes('0.0.0.0');
      ipOtherMask := StrToIpBytes('0.0.0.0');

      // Eingehende Pakete
      ZeroMemory(@ipFltIn, SizeOf(ipFltIn));
      ipFltIn.dwFilterFlags      := 0;
      ipFltIn.dwRule             := 0;
      ipFltIn.pfatType           := PF_IPV4;
      ipFltIn.fLateBound         := 0;
      ipFltIn.dwProtocol         := FILTER_PROTO_TCP;

      ipFltIn.wDstPort           := FILTER_TCPUDP_PORT_ANY;
      ipFltIn.wDstPortHighRange  := FILTER_TCPUDP_PORT_ANY;
      ipFltIn.DstAddr            := @ipMy;
      ipFltIn.DstMask            := @ipMyMask;
      ipFltIn.wSrcPort           := 3389;
      ipFltIn.wSrcPortHighRange  := 3389;
      ipFltIn.SrcAddr            := @ipOther;
      ipFltIn.SrcMask            := @ipOtherMask;

      // Ausgehende Pakete
      ZeroMemory(@ipFltOut, SizeOf(ipFltOut));
      ipFltOut.dwFilterFlags      := 0;
      ipFltOut.dwRule             := 0;
      ipFltOut.pfatType           := PF_IPV4;
      ipFltOut.fLateBound         := 0;
      ipFltOut.dwProtocol         := FILTER_PROTO_TCP;
      ipFltOut.wDstPort           := 3389;
      ipFltOut.wDstPortHighRange  := 3389;
      ipFltOut.DstAddr            := @ipOther;
      ipFltOut.DstMask            := @ipOtherMask;
      ipFltOut.wSrcPort           := FILTER_TCPUDP_PORT_ANY;
      ipFltOut.wSrcPortHighRange  := FILTER_TCPUDP_PORT_ANY;
      ipFltOut.SrcAddr            := @ipMy;
      ipFltOut.SrcMask            := @ipMyMask;

      PfAddFiltersToInterface(Handle_Interface, 1, @ipFltIn, 1, @ipFltOut, nil);
      //portfreigeben(3389,MyIP); //RDP
      {portfreigeben(137,MyIP); //NetBIOS Name Service
      portfreigeben(139,MyIP); //NetBIOS File and Printer Sharing
      portfreigeben(445,MyIP); //NetBIOS File and Printer Sharing
      portfreigeben(135,MyIP); //RPC
      portfreigeben(1025,MyIP); //RPC
      portfreigeben(2049,MyIP); //NFS
      portfreigeben(1080,MyIP); //SOCKS
      portfreigeben(7,MyIP); //PING Request
      portfreigeben(8700,MyIP); //DER SERVER!!!}
   end;
end;

Da sollte er doch eigentlich alle Ports blockieren, außer 3389, richtig?
Bin über RDP auf dem Rechner drauf, auf dem ich das Programm ausführe, die Verbindung wird trotzdem unterbrochen...
Gedankenfehler von mir?

[x000x]

Moin moin,

ja sollte es und macht es bestimmt auch. Ich kenne mich mit dem RDP Protokoll nicht wirklich aus, evtl. wird
aber der Port 3389 nur zur Verbindung genutzt und die Session läuft über einen anderen Port?

Ich habe dir die DropAllU.pas mal so angepasst, das nur noch Namensauflösung und Port 80 funktionieren. Wenn das
auch nicht bei dir funktionieren sollte, dann liegts an :gruebel: ...

[Morphie]

Vielen Dank für deine Mühe,
hat allerdings ebenfalls nicht funktioniert, komme, sobald ich InstallFW aufrufe, nicht über Port 80 raus.

Was mir aber aufgefallen ist (wurde glaub ich auch schon ne Seite vorher besprochen)...
bei

Delphi-Quellcode:

type
  PFFORWARD_ACTION  =  Integer;
  PPFFORWARD_ACTION =  ^PPFFORWARD_ACTION;

bekomme ich folgende Meldung:

Zitat:

[DCC Fehler] DropAllU.pas(24): E2086 Typ 'PPFFORWARD_ACTION' ist nicht vollständig definiert
[DCC Fehler] Project1.dpr(6): F2063 Verwendete Unit '..\..\..\Desktop\DropAllU.pas' kann nicht compiliert werden

Hab das dann mal in

Delphi-Quellcode:

type
  PFFORWARD_ACTION  =  Integer;
  PPFFORWARD_ACTION =  ^PFFORWARD_ACTION;

geändert, dann ist die Meldung weg.

hat das vielleicht damit etwas zutun?



Ich habe bestimmt irgendwas übersehen...
IP: 192.168.44.241
Subnetzsmaske: 255.255.255.0
ist da etwas entscheidend?

Gruß Morphie

[x000x]

Moin moin,

jo, da haste nen Fehler entdeckt. Hatte die Teile aus einer Fltdefs.pas kopiert, und da ist es auch schon falsch drinne.
Ändere mal folgendes ab:

Delphi-Quellcode:

//..
// rausnehmen und dafür...
//  PFFORWARD_ACTION  =  Integer;
//  PPFFORWARD_ACTION =  ^PFFORWARD_ACTION;
// dies rein
  _PfForwardAction = (
    PF_ACTION_FORWARD,
    PF_ACTION_DROP  );
  PFFORWARD_ACTION = _PfForwardAction;
  PPFFORWARD_ACTION = ^_PfForwardAction;

//..

// und das jetzt ganz weg
//const
//  PF_ACTION_FORWARD =  0;
//  PF_ACTION_DROP    =  1;

Damit sollte es dann jetzt aber funktionieren.

[Morphie]

Okay, großen Schritt weiter...
Das öffnen der Ports funzt!
Besten Dank ;)

Allerdings hab ich immer noch nicht raus, warum RDP bei mir abbricht, wenn ich Port 3389 öffne... Habe im Netz nichts darüber gefunden, dass irgendein anderer Port ebenfalls genutzt wird... :(


Wenn da nun noch jemand ne Lösung für hat, wär ich unglaublich dankbar ;)

Morphie

[x000x]

Hm, dann schau doch mal mit netstat welche Ports/IPs/Protokolle bei dir belegt/benutzt werden, wenn du eine aktive RDP Session hast.
Evtl. weisst du dann mehr?!