Newsgroup: it.comp.sicurezza.varie
Titolo: Com'è questo firewall?

http://www.idrci.net/packetfilter/html/index.html

> 
http://www.idrci.net/packetfilter/html/index.html
Com'è IPChains/Tables ?

 Com'è IPChains/Tables ?
Appunto :-)
E' uno stateful packet filter, di cui esiste anche la versione con NAT. In
pratica, anziche' bloccare solo determinati pacchetti presi uno alla volta,
mantiene la storia di cio' che e' passato subito prima, per capire se si
tratta di un tentativo di hacking oppure no.
Trovi la traduzione della home qui da me (
http://www.alogica.it/idrci.htm
),
in attesa che sia pronto tutto il website in italiano.
Ciao
Luca

 Appunto :-)
Cioè?
Che significa? Posso usarlo sul mio Win 2000 al posto di ZA?
Ciao!

 Che significa? Posso usarlo sul mio Win 2000 al posto di ZA?
Certo. ZA e' un firewall statico (come Kerio, Outpost, Norton ecc..), cioe'
blocca il singolo pacchetto che corrisponde/non corrisponde ad un dato
criterio, mentre CHX-I traccia la storia dei pacchetti precedenti e delle
connessioni interrotte, per "capire" se si tratti di un tentativo di attacco
oppure no.
Ciao
Luca

E' azzardato definirlo l'iptables per winzoz?
Dal poco che ho letto sembrerebbe!

 Dal poco che ho letto sembrerebbe!
Direi che non č azzardato .. dopotutto l'idea
di base dal quale č nato č proprio quella; che
poi aggiunga anche un minimo di interfaccia
grafica per la gestione ...beh... non credo sia
una cosa scomoda :-)
Ciao

 una cosa scomoda :-)
Si però per quanto riguarda iptables, il lavoro sporco come ho letto viene
effettuato direttamente nel kernel di linux, mentre in winzozz no.
Che vantaggi ci sono ad effettuare firewalling nel kernel?

 Che vantaggi ci sono ad effettuare firewalling nel kernel?
Velocita'.
-- 
HappyCactus - Linux User #209744
* 
http://sourceforge.net/projects/qixl
* 
www.google.com
 / 
groups.google.com

 Velocita'.
Solo questo?
Mi chiedevo una cosa: un exploit come quello sulla porta 135 di Windows di
questa estate, con un packet filtering nel kernel, sarebbe mai avvenuto?

 Con qualsiasi packet filter.
Ok. Un'altra cosa, che tu sappia ci sono problemi ad usare ZA e CHX-I
insieme?
Possibili interferenze? Non voglio, per ora, togliere ZA e mettere solo
CHX-I perchè non so configurarlo come si deve.
A tal proposito, ci sono in rete delle configurazioni template per CHX-I?
Grazie.

 A tal proposito, ci sono in rete delle configurazioni template per CHX-I?
Che io sappia .. no, considera perň dopo aver installato CHX
i "normali personal firewall" non vedranno piů gli "hit" (esempio
portscan ecc..) dall'esterno dato che questi verranno intercettati
_prima_ da CHX che "gira" a livello kernel utilizzando un suo
driver per il filtraggio dei pacchetti ... driver che tra parentesi si
aggancia parzialmente alle API _native_ (kernel) di packet filtering
che _SONO_PRESENTI_ da Windows 2000 in poi
Ciao


:-) Capito.
Senti, un documento che spieghi come funziona il packet filtering su
Win2000/XP?
Ho iniziato a leggere il tutorial di IPTABLES, esiste un doc equivalente per
sistem win?
Grazie :-)

 Non so: non uso personal firewall dai tempi dei primi atguard.
E come.....ti proteggi dalle vulnerabilità?

 sistem win?
http://tinyurl.com/vzgc
http://tinyurl.com/vzgn
http://tinyurl.com/vzgs
Buon divertimento :-)


Grazie :-)

 Possibili interferenze?
Ecco. Cerca i milioni di thread a riguardo di due PFW/AV/NIDS... che
lavorano insieme... ce n'e' stato uno anche di recente (non piu' di due
mesi fa).


> Ok. Un'altra cosa, che tu sappia ci sono problemi ad usare ZA e CHX-I
Dimenticavo ... a parte il fatto che (come ho scritto) non credo
ci dovrebbero essere problemi, io _eviterei_ di usare ZA in
assoluto, meglio (molto meglio) KerioPF o Sygate, ZA nelle
ultime versione è diventato "trash" e lascia in giro un mucchio
di roba che ... oltre a creare problemi, rallenta anche (ed in
modo sensibile) la velocità di "navigazione", ti conviene se
possibile disinstallarlo facendo attenzione a rimuovere a mano
_tutte_ le schifezze che si lascia dietro, per dettagli, vedi
http://www.zonelabs.com/store/content/support/znalm26Main.jsp#1
Ciao

 
http://tinyurl.com/vzgs
Calma raga.
Cosa centra bill?

 
Ho dato un'occhiata ma mi rimanda al supporto di microsoft. Mi sembba di 
capire che ci sarebbe da mettere mani al registro di cfg di windows. O no ??
Markus

 capire che ci sarebbe da mettere mani al registro di cfg di windows. O no
??
Uh ?!? Naa ... per quanto riguarda il primo link ... si tratta della
documentazione
relativa alle API di packet filtering presenti nel kernel, il che significa
che se vuoi
usarle ... dovrai scriverti un programma (cosa tra l'altro non difficile)
gli altri URL
invece sono relativi alle API di firewalling e NAT; tanto per capirsi
(sperando che
il server accetti il post), questo è un esempio di utilizzo della
PacketFilter API
che è apparso sul numero 10 (Ottobre 2000) di Windows Developer's Journal
(quindi non è esattamente una novità :-D !!)
<================== CODICE ========================>
//------------------------------------------------------------------
//  netBlock.cpp - Copyright (C) Ton Plooy 2000.
//------------------------------------------------------------------
#include <stdlib.h>
#define  WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <fltdefs.h>
SERVICE_STATUS_HANDLE s_hSvc      = NULL;
SERVICE_STATUS        s_SvcStat   = { 0 };
LPSTR                 s_szSvcName = "netBlock";
LPSTR                 s_pRegRoot  = "SOFTWARE\\WDJ\\netBlock";
INTERFACE_HANDLE      s_hIf       = NULL;
//------------------------------------------------------------------
BOOL        Install(char *szSvcName);
BOOL        Uninstall(char *szSvcName);
BOOL        AddIpAddress(char *pArgs);
void        AddFilter(char cIO, char *pLoc, char *pRem, char *pPrt);
BYTE       *stoip(char *szStrIP, BYTE IP[4]);
VOID WINAPI ServiceMain(DWORD dwArgc, LPTSTR *lpszArgv);
VOID WINAPI Handler(DWORD fdwControl);
LONG        GetRegStr(char *szRoot, char *szKey,
                      char *szDefault, char *szVal, int nValSize);
LONG        SetRegStr(char *szRoot, char *szKey, char *szVal);
//------------------------------------------------------------------
int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrevInst,
                      LPSTR pArgs, int nCmdShow)
{
    SERVICE_TABLE_ENTRY SvcEntry[2];
    if ((pArgs != NULL) && (strncmp(pArgs, "-i", 2) == 0)) {
        // Install service
        if (Install(s_szSvcName) == TRUE)
            MessageBox(NULL, "Service installed","netBlock", MB_OK);
        else
            MessageBox(NULL, "Install failed", "netBlock", MB_OK);
    }
    else if ((pArgs != NULL) && (strncmp(pArgs, "-u", 2) == 0)) {
        // Uninstall service
        if (Uninstall(s_szSvcName) == TRUE)
            MessageBox(NULL, "Service removed", "netBlock", MB_OK);
        else
            MessageBox(NULL, "Uninstall failed", "netBlock", MB_OK);
        SetRegStr(s_pRegRoot, "Filter", "");
    }
    else if ((pArgs != NULL) && (strncmp(pArgs, "-a", 2) == 0)) {
        // Add a new ip-address/mask
        if (AddIpAddress(pArgs + 2) == TRUE)
            MessageBox(NULL, "IP address added", "netBlock", MB_OK);
    }
    else {
        // Service started
        SvcEntry[0].lpServiceName = s_szSvcName;
        SvcEntry[0].lpServiceProc = ServiceMain;
        SvcEntry[1].lpServiceName = NULL;
        SvcEntry[1].lpServiceProc = NULL;
        StartServiceCtrlDispatcher(SvcEntry);
    }
    return 0;
}
//------------------------------------------------------------------
//
//------------------------------------------------------------------
VOID WINAPI ServiceMain(DWORD dwArgc, LPTSTR *lpszArgv)
{
    int   rc, nPort, nNum, nErr, nStat, bDtr;
    BYTE  szMsg[256], localIP[4];
    DWORD Start, Stop;
    s_hSvc = RegisterServiceCtrlHandler(s_szSvcName, Handler);
    s_SvcStat.dwServiceType             = SERVICE_WIN32_OWN_PROCESS;
    s_SvcStat.dwCurrentState            = SERVICE_RUNNING;
    s_SvcStat.dwControlsAccepted        = SERVICE_ACCEPT_STOP;
    s_SvcStat.dwWin32ExitCode           = NO_ERROR;
    s_SvcStat.dwServiceSpecificExitCode = NO_ERROR;
    s_SvcStat.dwCheckPoint              = 0;
    s_SvcStat.dwWaitHint                = 0;
    SetServiceStatus(s_hSvc, &s_SvcStat);
    // Create interface and set up IP filter(s)
    PfCreateInterface( 0, PF_ACTION_FORWARD, PF_ACTION_FORWARD,
                       FALSE, TRUE, &s_hIf );
    char szAddr[512], szLocal[32], *s = szAddr, *e = szAddr, *r, *p;
    GetRegStr(s_pRegRoot, "LocalNIC", "", szLocal, sizeof(szLocal));
    GetRegStr(s_pRegRoot, "Filter"  , "", szAddr , sizeof(szAddr));
    // Walk all comma separated entries
    while (e != NULL) {
        if ((e = strchr(s, ',')) != NULL) *e = '\0';   // Mark end
        for (r = s + 1; *r != '\0' && *r == ' '; r++); // Skip space
        for (p = r + 1; *p != '\0' && *p != ' '; p++); // Go past r
        if (*p == ' ') *p++ = '\0';                    // End of r
        for (         ; *p != '\0' && *p == ' '; p++); // Skip space
        AddFilter(s[0], szLocal, r, p);
        if (s != NULL) s = e + 1; // Advance s to next entry
    }
    stoip(szLocal, localIP); //
    rc = PfBindInterfaceToIPAddress(s_hIf, PF_IPV4, localIP);
    return ;
}
//------------------------------------------------------------------
VOID WINAPI Handler(DWORD fdwControl)
{
    // State change notifications
    switch (fdwControl) {
    case SERVICE_CONTROL_STOP:
        // Remove filter interface and stop service
        PfUnBindInterface( s_hIf );
        PfDeleteInterface( s_hIf );
        s_SvcStat.dwCurrentState = SERVICE_STOPPED;
        SetServiceStatus(s_hSvc, &s_SvcStat);
        break;
    default:
        break;
    }
    return ;
}
//------------------------------------------------------------------
BOOL Install(char *szSvcName)
{
    SC_HANDLE hSCM, hService;
    char      szFilePath[256];
    // Open the Service Control Manager
    if ((hSCM = OpenSCManager(NULL, NULL,
                              SC_MANAGER_ALL_ACCESS)) == NULL) {
        return FALSE;
    }
    // Get the executable file path
    GetModuleFileName(NULL, szFilePath, sizeof(szFilePath));
    // Create the service
    hService = CreateService(hSCM, szSvcName, szSvcName,
                             SERVICE_ALL_ACCESS,
                             SERVICE_WIN32_OWN_PROCESS,
                             SERVICE_AUTO_START,
                             SERVICE_ERROR_NORMAL,
                             szFilePath,
                             NULL, NULL, NULL, NULL, NULL);
    if (hService == NULL) {
        CloseServiceHandle(hSCM);
        return FALSE;
    }
    CloseServiceHandle(hService);
    CloseServiceHandle(hSCM);
    return TRUE;
}
//------------------------------------------------------------------
BOOL Uninstall(char *szSvcName)
{
    SC_HANDLE hSCM, hService;
    BOOL      bRc = FALSE;
    // Open the Service Control Manager
    if ((hSCM = OpenSCManager(NULL, NULL,
                              SC_MANAGER_ALL_ACCESS)) == NULL) {
        return FALSE;
    }
    if ((hService = OpenService(hSCM, szSvcName, DELETE)) != NULL) {
        if (DeleteService(hService)) {
            bRc = TRUE;
        }
        CloseServiceHandle(hService);
    }
    CloseServiceHandle(hSCM);
    return bRc;
}
//------------------------------------------------------------------
BOOL AddIpAddress(char *pArgs)
{
    LONG rc;
    // i|o <local ip address> <remote ip-address> [port]
    if (pArgs[0] != 'i' && pArgs[0] != 'o' && pArgs[0] != 'l') {
        MessageBox(NULL, "Set address arguments:\n"
            "-ai  <remote IP> [t|u<port>]  (set input filter)\n"
            "-ao <remote IP> [t|u<port>]  (set output filter)\n"
            "-al  <local IP>  (specify adapter)\n\n"
            "Local IP must be set once.", "netBlock", MB_OK);
        return FALSE;
    }
    if (pArgs[0] == 'l') {
        pArgs++;
        while (isspace(*pArgs)) pArgs++;
        rc = SetRegStr(s_pRegRoot, "LocalNIC", pArgs);
    }
    else {
        char szAddr[512];
        GetRegStr(s_pRegRoot, "Filter", "", szAddr, sizeof(szAddr));
        wsprintf(szAddr + strlen(szAddr), "%s%s",
                szAddr[0] ? "," : "", pArgs);
        rc = SetRegStr(s_pRegRoot, "Filter", szAddr);
    }
    return rc == ERROR_SUCCESS;
}
//------------------------------------------------------------------
void AddFilter(char cIO, char *pLocal, char *pRemote, char *pPort)
{
    PF_FILTER_DESCRIPTOR ipFlt;
    BYTE                 srcIP[4], destIP[4];
    memset( &ipFlt, 0, sizeof(ipFlt) );
    ipFlt.dwFilterFlags     = FD_FLAGS_NOSYN;
    ipFlt.dwRule            = 0;
    ipFlt.pfatType          = PF_IPV4;
    ipFlt.dwProtocol        = pPort[0] == 't' ? FILTER_PROTO_TCP :
                              pPort[0] == 'u' ? FILTER_PROTO_UDP :
                                                FILTER_PROTO_ANY ;
    ipFlt.fLateBound        = 0;
    ipFlt.wSrcPort          = FILTER_TCPUDP_PORT_ANY;
    ipFlt.wDstPort          = pPort[0] ? atoi(pPort + 1) :
                              FILTER_TCPUDP_PORT_ANY;
    ipFlt.wSrcPortHighRange = ipFlt.wSrcPort;
    ipFlt.wDstPortHighRange = ipFlt.wDstPort;
    if (cIO == 'i') {       // Input filter
        ipFlt.SrcAddr       = stoip(pRemote, destIP);
        ipFlt.SrcMask       = (PBYTE)"\xFF\xFF\xFF\xFF";
        ipFlt.DstAddr       = stoip(pLocal, srcIP);
        ipFlt.DstMask       = (PBYTE)"\xFF\xFF\xFF\xFF";
        PfAddFiltersToInterface( s_hIf, 1, &ipFlt, 0, NULL, NULL );
    }
    else {                  // Output filter
        ipFlt.SrcAddr       = stoip(pLocal, srcIP);
        ipFlt.SrcMask       = (PBYTE)"\xFF\xFF\xFF\xFF";
        ipFlt.DstAddr       = stoip(pRemote, destIP);
        ipFlt.DstMask       = (PBYTE)"\xFF\xFF\xFF\xFF";
        PfAddFiltersToInterface( s_hIf, 0, NULL, 1, &ipFlt, NULL );
    }
    return ;
}
//------------------------------------------------------------------
BYTE *stoip(char *szStrIP, BYTE IP[4])
{
    // String to byte IP
    char szStr[64], *p;
    strncpy(szStr, szStrIP, sizeof(szStr));
    szStr[sizeof(szStr) - 1] = '\0';
    if ((p = strrchr(szStr, '.')) != NULL) {
        *p = '\0', IP[3] = atoi(p + 1);
        if ((p = strrchr(szStr, '.')) != NULL) {
            *p = '\0', IP[2] = atoi(p + 1);
            if ((p = strrchr(szStr, '.')) != NULL) {
                *p = '\0';
                IP[1] = atoi(p + 1);
                IP[0] = atoi(szStr);
            }
        }
    }
    return IP;
}
//------------------------------------------------------------------
LONG GetRegStr(char *szRoot, char *szKey, char *szDefault,
               char *szVal, int nValSize)
{
    LONG rc; DWORD dwLen, dwType; HKEY  hKey;
    szVal[0]  = '\0';
    if ((rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szRoot, 0L,
                KEY_ALL_ACCESS, &hKey)) == ERROR_SUCCESS) {
        dwLen = (DWORD)nValSize;
        rc = RegQueryValueEx(hKey, szKey, 0L, &dwType,
                            (BYTE *)szVal, &dwLen);
        RegCloseKey(hKey);
    }
    if ((rc != ERROR_SUCCESS) && (szDefault != NULL))
        strncpy((char *)szVal, szDefault, nValSize);
    return rc;
}
//------------------------------------------------------------------
LONG SetRegStr(char *szRoot, char *szKey, char *szVal)
{
    LONG rc; DWORD dwDisp; HKEY hKey;
    if ((rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szRoot, 0L,
                    KEY_ALL_ACCESS, &hKey)) != ERROR_SUCCESS) {
        if ((rc = RegCreateKeyEx(HKEY_LOCAL_MACHINE, szRoot, 0L,
                    NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,
                    NULL, &hKey, &dwDisp)) != ERROR_SUCCESS) {
            return rc;
        }
    }
    RegSetValueEx(hKey, szKey, 0, REG_SZ,
                  (PBYTE)szVal, strlen(szVal) + 1);
    RegCloseKey(hKey);
    return rc;
}
<================== CODICE ========================>
per la compilazione, avendo il "Platform SDK" (necessario per
le varie librerie/headers) basta ...
cl netblock.cpp -link iphlpapi.lib advapi32.lib user32.lib
il codice di cui sopra è un "filtro alla rovescia" nel senso che
permette di bloccare le connessioni _VERSO_ gli indirizzi IP
e le porte specificate, ad esempio aggiungendo un filtro per
216.239.59.99 porta 80 non sarà possibile accedere al server
web di Google ... ovvio che leggendosi la documentazione e
guardando il codice di cui sopra non è difficile implementare
un packet filter "regolare"
Ciaooo :-) !


Infatti, stavo giusto per postare che oggi ho letto dell'accoppiata Kerio PF
e CHX-I  e che appunto volevo farla anche io.
Grazie infinite per la tua gentilezza :-)
P.S. Sai di insieme di regole che posso usare per il mio sistema con Win2000
SP4?
Ho molti programmi p2p e di messaging e nn vorrei bloccarli del tutto.
Grazie :-)

Ciao,
Ma perche' non provate a vedere 
www.pcprotection.it
 e' un personal 
firewall di tipo packet filetering scritto da una azienda italiana.
Esiste in due versioni una per uso personale ed una per uso aziendale.
Ciao


 intercettate prima da kerio e di conseguenza chx non le vede.
Hm ... dipende ... sei sicuro di aver "chiuso" la 135 in CHX ?
Dai un'occhiata qui 
http://members.shaw.ca/BIND-PE_and_ICS/
c'è una config di esempio che usa proprio Kerio + CHX (vabbè
c'è anche ICS ma nel tuo caso non cambia nulla)

 Grazie :-)
Beh 
http://members.shaw.ca/BIND-PE_and_ICS/
  :-)
Ciao
-- 
* ObiWan
DNS "fail-safe" for Windows 2000 and 9X clients.
http://ntcanuck.com
408 XP/2000 tweaks and tips
http://ntcanuck.com/tq/Tip_Quarry.htm

 Esiste in due versioni una per uso personale ed una per uso aziendale.
Peccato che sul sito abbia trovato solo il download dell'upgrade e non 
una full per uso personale!

 contemporaneamente?
La prudenza lo richiederebbe: non puoi sapere come si comportino due
software cosi' intrusivi e che non sono stati progettati per lavorare
insieme. Ne vale la pena correre il rischio?


 insieme. Ne vale la pena correre il rischio?
Concordo, anche se ho potuto verificare che CHX e Kerio "convivono"
senza problemi, in buona sostanza ho testato CHX come firewall "vero"
ed ho aggiunto Kerio solo per i controlli "outbound" (applicazioni...) e
posso dire che lavorano senza problemi, ovvio che l'ideale sarebbe
avere un f/w dedicato e separato, ma in un'installazione home non è
sempre possibile una cosa del genere; se poi vuoi dare un'occhiata
ad una config CHX+Kerio (con ICS) vedi
http://members.shaw.ca/BIND-PE_and_ICS/
la config di cui sopra funziona allegramente e senza problemi ormai
da più di un anno ed il tipo che l'ha messa in piedi (con una mano da
parte del sottoscritto) la usa per la sua LAN domestica di 5 macchine
ora, anche se la macchina ICS+CHX che fa da gateway potrebbe essere
sostituita con (es.) IPCop, Axn (il tizio del sito) ha voluto usare windows
proprio per vedere se si riusciva a fare una cosa del genere usando
una macchina "riciclata" e ... a quanto sembra ... c'è riuscito ;-)
