1
2
3

iptables -A INPUT -j DROP
iptables -A OUTPUT -j DROP
iptables -A FORWARD -j DROP

Fatto, vi siete chiusi fuori dal server e anche molti software ora non stanno più funzionando.

Voi ( e i cattivi) non potete più entrare perchè iptables è un firewall (porta tagliafuoco) e quindi sta scartando (-j DROP) tutte le richieste che arrivano al server e i software non funzionano più perchè iptables elimina anche i messaggi che passano per l’interfaccia di loopback (lo) che viene usata dai programmi per comunicare tra loro.

Iptables divide le sue regole in 3 tabelle (tables), ognuna dedicata ad un utilizzo diverso:

• nat
• mangle
• filter

Ogni tabella ha delle chains (elenchi di regole) predefinite.
Per un utilizzo minimo ci basta la tabella mangle e 3 delle sue chains:

• INPUT: dedicata hai pacchetti destinati all’host locale
• OUTPUT: per i pacchetti uscenti
• FORWARD: pacchetti destinati ad altri host

.
Naturalmente per mettere in produzione un firewall è meglio (molto meglio, essenziale) capire come funziona iptables e come i pacchetti attraversano tabelle e chains, non mi dilungo, leggetelo qui o in un qualunque altro sito dell’elenco che propone google.

Per farla breve, comunque, un pacchetto entra in una chain e si scorre l’elenco di regole contenute dalla prima all’ultima,applicandole immediatamente.
Di conseguenza un pacchetto che incontra un DROP viene scartato ed esce dalla chain.

Prima cosa da imparare: l’ordine delle regole conta.
Nel cattivo esempio di cui sopra non serve a niente aggiungere altre regole, siamo fuori e ci rimarremo.

Cancelliamo quindi le regole inserite sopra.
Abbiamo 3 sintassi possibili:

1. Le regole non sono ancora persistenti, vanno esplicitamente salvate, quindi riavviare la macchina.
   Questo ci manda a ramengo l’uptime, ma noi perfortuna non ne siamo schiavi.
2. Eliminarle tutte insieme

   1	iptables -F

3. Cancelliamo una regola alla volta:

   1 2	iptables -D {regola} iptables -D [CHAIN] [numero di riga(partendo da 1)]

   iptables -D si può usare inserendo il numero di riga in cui appare la regola oppure riscrivendo la regola con la sintassi usata per aggiungerla (-A oppure -I)

Verifichiamo di esserci liberati delle regole chiedendone la lista (-L):

• una elenco semplice

  1	iptables -L

• più informazioni

  1	iptables -L -v

• con numeri di linea (così magari usiamo con più tranquillità l’opzione -D)

  1	iptables -L --line-numbers

A questo punto possiamo prendere il tablet (non un iPad per favore) su cui abbiamo segnato i servizi offerti e le porte che usano per iniziare ad appendere le regole.
Per semplicità userò negli esempi solo le chain INPUT e OUTPUT.

La nostra priorità è di consentire tutto il traffico sull’interfaccia di loopback (lo), quindi:

1
2

iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -i lo -j ACCEPT

spiegazione:

iptables, appendi (-A) alla chain INPUT la regola che tutti i pacchetti che passano per l’interfaccia (-i lo) sono accettati (-j ACCEPT)

Al primo posto dei servizi permessi c’è sicuramente ssh quindi vogliamo che siano possibili connessioni entranti e uscenti sulla porta 22 (default).

1

iptables -A INPUT --dport 22 -j ACCEPT

Questa regola dice ad iptables di accettare le connessioni entranti dirette alla porta 22.
Questa regola base può (e deve) essere migliorata con ulteriori vincoli:

• accettare solo uno specifico protocollo, nel caso specifico tcp

  1

  -p tcp

• verificare lo stato della connessione. Nel caso di connessioni entranti dobbiamo accettare sia comunicazioni nuove che già attive (NEW ed ESTABLISHED)

  1	-m state --state NEW,ESTABLISHED

  attenzione, non di devono essere spazi intorno alla virgola.

• potremmo poi voler accettare solo le connessioni dirette ad un solo IP

  1	-d [indirizzo ip]

• oppure consentire l’accesso solo ad uno specifico IP/rete

  1	-s [indirizzo ip]/[netmask]

  per lasciare libera la connessione si può non specificare nulla oppure usare

  1

  -s 0/0

• eventualmente si può anche specificare da che porta deve partire la connessione affinchè sia accettata

  1	--sport [numero di porta]

  per consentire un intervallo

  1 2 3

  --sport [porta partenza]:[porta base] es. --sport 1024:65535

Una regola ragionevolmente restrittiva da cui partire diventa quindi:

1

iptables -A INPUT -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT

Siccome dopo diremo al firewall di scartare tutti i pacchetti entranti e uscenti che non siano altrimenti regolati dobbiamo anche dire ad iptables cosa fare delle risposte che richiede il client ssh:

1

iptables -A OUTPUT -p tcp -m state --state ESTABLISHED -j ACCEPT

La sintassi è identica, cambia solo la chain a cui appenderlo e non sono specificate le porte della connessione.

A questo punto non rimane che reiterare la logica applicata per ssh per ogni servizio a cui vogliamo consentire l’accesso.

Finito l’elenco dei servizi blocchiamo tutto di nuovo:

1
2
3

iptables -A INPUT -j DROP
iptables -A OUTPUT -j DROP
iptables -A FORWARD -j DROP

A questo punto un port scanner tipo nmap vi segnalerà solo la porta ssh disponibile e l’output di iptables -L dovrebbe essere:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
ACCEPT     all  --  anywhere             anywhere            
ACCEPT     tcp  --  anywhere             anywhere            tcp dpt:ssh state NEW,ESTABLISHED 
DROP       all  --  anywhere             anywhere            
 
Chain FORWARD (policy ACCEPT)
target     prot opt source               destination         
DROP       all  --  anywhere             anywhere            
 
Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination         
ACCEPT     all  --  anywhere             anywhere            
ACCEPT     tcp  --  anywhere             anywhere            tcp spt:ssh dpts:login:65535 state ESTABLISHED 
DROP       all  --  anywhere             anywhere

Il parametro -A appende una regola in fondo alla chain selezionata, volendo inserire una regola in una posizione specifica si usa:

1

iptables -I INPUT 3 {regola}

Che ci consente di appendere {regola} alla terza posizione della chain (sempre partendo da 1).

Lavorando con i firewall è purtroppo molto facile fare errori che poi richiedono di loggarsi in locale sulla macchina per essere riparati.
Siccome più spesso che no il server è a qualche chilometro dalla tastiera su cui stiamo lavorando la seconda semplice precauzione da prendere è di spegnere il firewall ogni 5 minuti

1
2
3
4

crontab -e
  */5 * * * * /sbin/service iptables stop (centos)
  */5 * * * * /etc/init.d/iptables stop (debian-like)
  */5 * * * * /sbin/iptables -F (per tutte le stagioni)

Ovviamente la prima precauzione da prendere è provare la configurazione sul server di test.

Riassunto dei comandi

• visualizzare le regole

  1	iptables -L -v --line-number

• eliminare tutte le regole

  1	iptables -F

• eliminare una regola

  1 2	iptables -D [chain] [numero regola] iptables -D [chain] {sintassi regola}

• appendere una] regola in fondo alla chain

  1 2 3

  iptables -A [chain] {sintassi regola} es. iptables -A INPUT -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT (per ssh)

• appendere una regola in posizione specifica

  1	iptables -I [chain] [numero riga] {sintassi regola}

Iptables ha molti più parametri di così.
Per un firewall sicuro ci vuole molto più studio di questo semplice tutorial, si possono creare nuove chains e modificare i pacchetti prima del routing e dopo il routing; genericamente si può gestire ogni aspetto dei flussi entranti e uscenti.

In un mondo perfetto avremmo un ottimo supporto ai caratteri anche nei browser, ma così non è, quindi ci teniamo la nostra manciata di font sempre uguali (qualcuno ha detto verdana?) e tiriamo avanti sopravvivendo al dispiacere di non poter godere di opere come quelle che per esempio ci elenca quotidianamente typojungle.
Siamo costretti a questo dal fatto che ogni computer può visualizzare solo i font che ha installati.

Alla terribile ingiustizia che chi può si gode l’Helvetica mentre gli altri si beccano l’Arial purtroppo non c’è rimedio (tranne flash naturalmente), ma per piccoli pezzetti di testo, tipicamente i titoli si può supplire sostituendo la scritta in html con un analogo in flash (o un’immagine).

sIFR fa la scelta di utilizzare il javascript per sostituire l’elemento indicato e tutti i suoi figli con un filmato in flash delle stesse dimensioni (quasi).
sIFR3 risulta abbastanza semplice da aggiungere ad una pagina i passi riassunti brutalmente sono solo 4:

1. Avere il file .swf: non richiede quasi preparazione, infatti basta aprire il .fla fornito nel pacchetto, cancellare il testo, impostare il font che si vuole utilizzare e pubblicare il filmato.
2. includere nella pagina il css sifr.css:

   1

3. includere nella pagina i file sifr.js e sifr-confg.js:

   1 2	<script src="/path/to/sifr.js" type="text/javascript"><!--mce:0--></script> <script src="/path/to/sifr-config.js" type="text/javascript"><!--mce:1--></script>

4. inserire nel sifr-config.js i filmati da attivare, dove attivarli e le impostazioni da usare (color, background ed altre amenità “simil css”.
   Una minima configurazione comprende:

   1 2 3

   var strangeFont = { src: "/path/to/strangefont.swf" } //il path è relativo alla pagina che carica il filmato sIFR.activate(strangeFont); // ci deve essere un solo "activate" per ogni sIFR, ma è possibile la sintassi sIFR.activate(font1,font2,font3,...,fontN) sIFR.replace(strangeFont, {selector: 'h1'}); // .className per le classi #idValue per gli id

Probabilmente seguendo questi 4 step la pagina ora fa un po’ schifo, le cose migliorano molto dopo aver scoperto che sIFR.replace() consente una sintassi css-like ed infatti:

1

sIFR.replace(strangeFont, {selector:'h1', css:['.sIFR-root{color:#ff0000; font-size:10px}']}

trasforma tutti gli <h1> della pagina in un bel colore rosso puro e corpo 10. Attenzione, non ho scritto il codice del colore a 6 cifre in quanto masochista, ma perchè flash non riconosce l’abbreviazione a 3 cifre come fanno i css.

Altre cose a cui fare stare attenti:

• se lo sfondo non è uniforme sIFR.replace() ci consente l’opzione transparent:true
• a sIFR.replace() possono essere aggiunti tutti gli stili che vogliamo, quindi è perfettamente valida la sintassi css['sIFR-root{...}','.class{...}'] purchè i selettori siano tutti figli dell’elemento da sostituire. è comunque da tenere presente che questo sistema non è perfetto e quindi utilizzarlo può far venire mal di testa ed insoddisfazione. Molto meglio è utilizzare diversi sIFR.replace() con i selettori ordinati dal più particolare al più generale. Per esempio

  1 2 3 4

  sIFR.replace('ul#main li.selected'); sIFR.replace('ul#main li'); sIFR.replace('li.selected'); sIFR.replace('li');

  In questo modo si dovrebbero avere meno mal di testa, ma non è vero, solo l’esperienza fa passare questo tipo di malesseri.

• sIFR calcola l’ingombro del filmato flash in base all’ingombro che ha l’oggetto che deve sostituire, può capitare che il js di sIFR si esegua prima che l’ingombro venga assegnato (es. Safari carica in parallelo css e js) provocando uno strano aspetto alla pagina. Per verificare che il problema sia questo basta ridimensionare la finestra del browser, se va tutto a posto la questione è proprio questa.
  Per risolvere questo problema bisogna applicare qualche hack che ritardi l’esecuzione del js fino al momento giusto
• evitare di sostituire i link. sIFR non può sostituire direttamente i tag <a> quindi bisogna applicarlo ad un elemento padre. A mio parere il gioco non vale la candela

In conclusione sIFR è sicuramente uno script ottimamente programmato a partire da un’idea intelligente, ma a me non piace.
Per quanto io sia un amante della tipografia sostituire del testo con altri oggetti non è una soluzione è un hack per aggirare il problema e come tutti gli hack non conduce ad un risultato perfetto.
Naturalmente a piccole dosi può produrre un risultato ottimo, ma il confine è così sottile che la differenza tra usarlo ed abusarlo è troppo facile da superare.

Per quel che riguarda gli altri sistemi di embedding dei font ancora non li ho provati e tantomeno messi in produzione.
Non ho intenzione di provare Cufon perchè il testo sostituito non è selezionabile (in quanto immagine) e questo mi sembra un grosso sgarbo nei confronti dell’utente.

Typekit invece che cos’è? questo di bradcolbow.com è un mirabile riassunto, quello che penso io è che potrebbe essere un buon sistema, vedremo.

Non ho nulla contro il plugin il cui funzionamento è ineccepibile, ma si basa su un parametro che varia a seconda del browser rendendo necessario interpretare i risultati solo dopo aver sniffato il browser del navigatore.

Mousewheel infatti all’attivazione dell’evento “rotella girata” restituisce una variabile delta contenente un signed int che ci dice di quanto è stata spostata la rotella e ce ne indica il verso grazie al segno.

Su firefox uno spostamento della rotella verso l’utente (per me giù) è positivo ed uno spostamento nell’altro verso (su) è negativo. In opera esattamente il contrario.

Ho scoperto ora il problema ed aggiornerò il post con la mia soluzione (quando l’avro almeno pensata) e con altre indicazioni sul comportamento negli altri browser.

“hey js dammi un oggetto di tipo jquery che eventualmente contiene parameters”

Che è ben diverso da “hey js trasformami parameters in un oggetto jquery e ridammelo“.

quindi se a questo codice html:

<div><p>Lorem ipsum bla bla bla</p></div>

applicchiamo il jqueroso:

var tmp = $(‘span’);

l’espressione if ($tmp) {//stuffs} risulterà sempre eseguita perchè tmp è un  oggetto jquery (un array) di lunghezza nulla, quindi un sistema per rendere efficace l’espressione potrebbe essere:

if ($tmp.length>0) {//better stuffs}

Ci sono tanti altri sistemi, ad esempio prima di scoprire questo effettuavo il controllo sui valori di altri attributi con $(tmp).attr(), ma questo è più compatto e funziona sempre (dovrebbe).