1  – La frequenza

ovvero il numero degli invii.

Una newsletter giornaliera è davvero impegnativa e spesso funziona solo per le grandi aziende che hanno molte persone dedicate a questo lavoro, dal punto di vista del cliente, una newsletter quotidiana può essere pesante(chi di voi non è incappato almeno una volta,  nella newsletter di una famosa società che stampa biglietti da visita che inizia con la V) e non è improbabile che si smetta di seguirla. Leggevo da qualche parte che uno dei maggiori motivi per cui si smette di seguire un account di twitter è : il numero elevato di tweet .

Potrebbe essere lo stesso per le e-mail non credete ?

Ultimamente mi sono iscritto ad alcune newsletter, volevo  provare un po’ l’esperienza di  e-mail mandate da grandi aziende, (come sapete la mia preferita ad oggi, è la newsletter della casa giapponese creatrice di Mario Bros, ma anche la casa madre di Topolino non è da meno )  direi che la frequenza ottimale è una al massimo, due volte al mese. Ci sono aziende che sono assolutamente precise e creano newsletter per  i primi del mese (per esempio una compagnia aerea tedesca che inizia con la L) e sono molto efficaci.

2 – Cancellazione

importante mettete ben in evidenza il link unscribe e rendete l’esperienza di cancellazione semplice;  non c’è niente di peggio che quelle società che vi fanno cancellare e poi vi iscrivono ad altre newsletter ancora più estenuanti . E’ importante creare un processo di cancellazione  con solo un click.

3 – Grafica

come vi dicevo nello scorso articolo, le newsletter fatte con un blocco note non fanno molta strada, se non finire nello spam, senza essere nemmeno lette. Per cui grafica, grafica e  grafica e  se non siete grafici, esistono dei template davvero fatti bene ad un costo irrisorio. Mi piacciono molto le newsletter con un layout pulito con alcune informazioni in evidenza, e invece non sopporto quelle con mille messaggi che rendono il tutto confuso. Avete molte cose da comunicare? bene, dividetele in più newsletter.

4 – Oggetto della mail

prima di tutto evitate punti esclamativi e troppe maiuscole nell’oggetto della mail .

Come vi accennavo la scorsa volta è fondamentale usare pannelli/software professionali per inviare le e-mail per cui è anche importante inserire i codici di tracciamento ( per capirci : analytics ) così potrete monitorare l’apertura delle e-mail . Se notate che i tassi di apertura sono molto bassi vi consiglio di controllare l’oggetto della mail. L’oggetto deve essere accattivante e deve stimolare la curiosità dell’utente.

5 – usare opzione “confirmed opt-in”:

importante usare questa opzione con la quale l’utente deve cliccare un link per confermare l’iscrizione alla vostra newsletter. Con questa opzione sarete abbastanza sicuri che l’utente è davvero deciso a seguirvi, per cui il tasso di cancellazione sarà molto basso. So che magari avrete paura che alcune persone facciano fatica con il meccanismo, ma vi servono davvero utenti che non sanno neanche aprire un link di conferma ? o che magari controllano la mail due volte l’anno ? NO non vi servono.

6 – Offerte

negli ultimi tempi le nostre e-mail sono piene zeppe di messaggi, per esempio newsletter di aziende di terze parti a cui non vi siete iscritti direttamente, ma che in una clausola piccolina all’atto della vostra iscrizione, hanno la possibilità di rigirare il vostro indirizzo e-mail ad altre aziende ( questo succede con molte applicazioni di Facebook per esempio ). Perché un’utente dovrebbe iscriversi alla vostra newsletter che per lui potrebbe essere l’ennesima ?

Cercate di offrire qualcosa in cambio, per esempio vedo molti siti che offrono e-book(anche solo parziali o e-book generici ), promozioni esclusive o contenuti esclusivi per gli iscritti.

7 – Nome

se vi mettete dalla parte dell’utente, non vi sembra molto più familiare essere chiamati per nome, piuttosto che gentile utente. Naturalmente all’atto della registrazione alla vostra newsletter mettete nome ed e-mail e molti pannelli/software per newsletter gestiranno in automatico il tutto .

8 – Form

non esagerate con le richieste all’atto dell’iscrizione alla vostra newsletter, bastano nome ed e-mail ,so benissimo che più dati ottenete e più è facile profilare gli utenti , ma come spesso faccio io, e cioè mi metto dalla parte dell’utente, trovare una form di iscrizione con 100 campi, mi fa scappare immediatamente.

9 – Perseverate

non tutte le vendite vengono effettuate dopo la prima newsletter ( anzi meno del 2% ) la stragrande maggioranza delle vendite (circa l’80 %) viene effettuata dal quinto al dodicesimo contatto .

Per cui non abbattetevi se dopo la prima e-mail, non avrete  ottenuto  grandi risultati in termini di vendita, ci vuole tempo per avere una buona lista di utenti affezionati .

10 -Testate

ho seguito alcuni corsi, e leggo alcuni blog per aggiornarvi, non potete neanche immaginare quanto sia fondamentale il test A/B sulle newsletter, ho visto statistiche importanti con percentuali 93% di un layout e 7 % per il secondo layout solo per aver cambiato una immagine o il colore di un tasto. Ecco il test di una newsletter potrebbe decretare o meno il successo della stessa.

Ultimo importante consiglio aggiornatevi mi raccomando, le regole di internet e dell’interazione utente/sito cambiano velocemente

Per cui continuate ad aggiornarvi e iscrivetevi a quante più newsletter potete (io ho creato un account  mail apposito per l’iscrizione alle varie newsletter) , perché la cosa più importante è imparare e poi sperimentare (lo dico dal primo articolo). Mettetevi sempre nei panni dell’utente, testate  e di sicuro otterrete risultati .

Buon lavoro

Siamo arrivati all’ultima puntata di questa guida base al linguaggio PHP, e per concludere affrontiamo oggi un argomento di sicuro non semplice ma che cercheremo di trattare in modo tale da fornire alcuni strumenti utili per la sua comprensione: stiamo parlando delle espressioni regolari. In una sola puntata non riusciremo a trattare l’argomento in modo completo al 100% ma con le nozioni che avremo alla fine potremo eseguire diverse operazioni.

Le espressioni regolari

Per iniziare possiamo dire che cosa sono e a che cosa servono le espressioni regolari. Si tratta di particolari costrutti che si usano per verificare se all’interno di una stringa (e quando in PHP si parla di stringa si intende anche un testo lungo e complesso) è presente una certa sottostringa. Potreste pensare che in realtà non ci sono novità perché abbiamo già visto, nella puntata dedicata alle funzioni sulle stringhe, come cercare e sostituire sottostringhe. In realtà le espressioni regolari sono uno strumento molto più potente perché non definiscono semplici sottostringhe ma, data la loro natura versatile, con un solo pattern (una sequenza di caratteri) possiamo cercare una grande varietà di sottostringhe.

Le espressioni regolari possono essere utili per moltissime situazioni: per esempio, nella puntata in cui parlavamo dei form abbiamo fatto un cenno alle espressioni regolari perché abbiamo detto che servono per controllare se l’utente inserisce un indirizzo email corretto. Questo infatti potrebbe essere un utilizzo, ma potremmo usare le espressioni regolari per altre operazioni, per esempio controllare se un dominio è stato scritto correttamente, evidenziare una certa occorrenza o un insieme di occorrenze in un testo, cercare tutte le etichette HTML presenti in un testo, sostituire doppi apici con virgolette, controllare la complessità di una password e via dicendo.

I metacaratteri

Entriamo subito nell’argomento e iniziamo a parlare di “metacaratteri”, ovvero di caratteri speciali inseriti all’interno di una espressione regolare e che sono dotati di un significato ben preciso. Per esempio la sequenza [a-z] indica “qualsiasi lettera minuscola compresa tra la a e la z”. Se volessimo invece trovare tutte le lettere non solo minuscole ma anche maiuscole dovremmo scrivere un’espressione come questa: [a-zA-Z]. Avrete quindi intuito che le parentesi quadre racchiudono un insieme di caratteri. Vediamo quali sono i metacaratteri:

I quantificatori

Esistono poi i quantificatori, che indicano quante volte bisogna cercare un’occorrenza all’interno della nostra stringa principale:

Alcuni esempi…

Facciamo alcuni esempi per comprendere meglio:

… e altri esempi, più pratici

E così via. A questo punto abbiamo quindi gli strumenti per creare dei pattern utili… partiamo dall’esempio più semplice, ovvero un pattern per validare una partita IVA che come tutti sappiamo è composta da undici numeri:

^[0-9]{11}$

Non facciamo altro che creare una sequenza [0-9] che indica un qualsiasi numero, e la facciamo seguire subito dalla sequenza {11} che indica che il numero deve obbligatoriamente occorrere undici volte. L’accento circonflesso e il dollaro indicano ovviamente l’inizio e la fine della stringa. Se omettessimo uno dei due, avremmo vanificato il controllo in quanto potremmo inserire un qualsiasi numero prima o dopo la nostra partita IVA e il pattern verrebbe comunque validato perché il nostro script non saprebbe da dove inizia o dove finisce la stringa.

Possiamo poi creare un pattern che controlli che un dato file sia un’immagine:

^.+\.(jpeg|jpg|png|gif)$

Abbiamo qui il punto che indica una qualsiasi sequenza di caratteri, seguito da un “vero” punto (per essere considerato tale, deve essere preceduto dal carattere di escape) e quindi dalle estensioni tipiche delle immagini “da web” (jpeg, jpg, png, gif) tra parentesi tonde e separate tra di loro per mezzo dell’operatore disgiuntivo.

Prendiamo poi, per esempio, un controllo per validare una data:

^[0-9]{1,2}\.[0-9]{1,2}\.[0-9]{4}$

In questo caso non facciamo altro che creare tre sequenze [0-9] rispettivamente per i giorni, i mesi e gli anni: nei primi due casi il numero può comparire da un minimo di una a un massimo di due volte e deve essere seguito da un punto (con cui separiamo i numeri della data… gusti personali) a sua volta preceduto da un backslash. Per quanto riguarda l’anno invece il numero deve essere obbligatoriamente presente quattro volte.

Più complesso invece è il pattern per validare un indirizzo email:

^[a-zA-Z0-9_\.\-]+@[a-zA-Z0-9_\.\-]+\.[a-z]{2,6}$

Nella prima sequenza tra parentesi quadre inseriamo tutti i caratteri alfanumerici insieme all’underscore, al punto e al trattino e indichiamo che possono ricorrere una o più volte attraverso l’uso del segno +, a fui facciamo seguire la chiocciola. Questa prima sequenza rappresenta il nome utente dell’indirizzo. Dopo la chiocciola inseriamo un’altra sequenza tra parentesi quadre simile alla prima e poi inseriamo il punto preceduto dal carattere di escape. Abbiamo quindi il nome del dominio, a cui facciamo seguire l’espressione [a-z] che può ricorrere da un minimo di 2 fino a un massimo di 6 volte: è nient’altro che l’estensione del dominio.

Le classi di caratteri

Per alcune delle espressioni che abbiamo utilizzato esistono poi le cosiddette “classi di caratteri”, ovvero caratteri che corrispondono a precise sequenze e che possono accorciare molto il nostro lavoro. Vediamone alcune:

Negli ultimi cinque casi, le parentesi quadre sono parte integrante della sequenza, quindi se vogliamo cercare i i segni di interpunzione nella nostra stringa il pattern dovrà essere strutturato in questo modo:

[[:punct:]]

Con le classi di caratteri, le stringhe per la validazione di partite IVA e indirizzi email, tanto per prendere due degli esempi che abbiamo fatto in precedenza, potrebbero diventare una cosa di questo tipo:

^\d{11}$

^\S+@[\w.-]+\.[a-z]{2,6}$

Espressioni regolari e PHP: preg_match e preg_replace

Ma come fare per eseguire il controllo nel nostro script PHP? Abbiamo bisogno di una funzione, preg_match, che riceve come parametri il pattern e la stringa da controllare e nel caso in cui nel testo ci sia almeno una coincidenza con il pattern, la funzione restituirà come risultato 1 (true), e in caso contrario il risultato sarà 0 (false).

Per esempio, poniamo il caso di uno script che controlla se un utente, attraverso un form, ha caricato un’immagine con estensione corretta (il nome dell’immagine sarà stato precedentemente memorizzato in una variabile $immagine).

if (preg_match('/^.+\.(jpeg|jpg|png|gif)$/', $immagine)) {
echo "Grazie per aver caricato l'immagine!";
}
else {
echo "L'immagine ha un'estensione non valida";
}

I due slash inseriti dopo gli apici del primo parametro della funzione sono i delimitatori: se non inseriti, lo script restituirà un errore. Il meccanismo della funzione è molto semplice: il blocco if controlla che il risultato sia true e in caso affermativo stampa la scritta “Grazie per aver caricato l’immagine!”, mentre in caso contrario la scritta mostrata all’utente sarà “L’immagine ha un’estensione non valida”.

La funzione può essere usata anche, ovviamente, nel modo inverso, al negativo, facendo precedere la funzione dal punto esclamativo che indica negazione:

if (!preg_match('/^[a-zA-Z0-9_\.\-]+@[a-zA-Z0-9_\.\-]+\.[a-z]{2,6}$/', $indirizzoemail)) {
echo "Indirizzo email non valido";
}
else {
echo "Indirizzo email valido!";
}

In questo caso abbiamo controllato un indirizzo email. La documentazione ufficiale della funzione preg_match si può trovare all’indirizzo http://php.net/manual/en/function.preg-match.php.

Abbiamo detto poi che attraverso le espressioni regolari possiamo poi anche fare sostituzioni all’interno di un testo. Questa operazione si può eseguire attraverso l’utilizzo della funzione preg_replace che riceve tre parametri: l’espressione regolare che definisce le sequenze da sostituire, la sottostringa sostituta e la stringa all’interno della quale compiere la sostituzione. Con un esempio banale:

$testo = "Cane, gatto, topo, cavallo, pecora, mucca";
echo preg_replace ("/[aeiou]/", "*", $testo);

Attraverso l’utilizzo della funzione preg_replace (il cui risultato sarà direttamente stampato attraverso echo) cerchiamo nella stringa $testo tutte le volte in cui occorre una vocale tramite la sequenza [aeiou], e sostituiamo ogni vocale con un asterisco. Questa funzione si presta a diversi utilizzi… per esempio, stiamo costruendo un blog e vogliamo censurare le parolacce dei nostri commentatori (farò un esempio… senza parolacce ma che funziona allo stesso modo).

$testo = "Il gatto mangia il topo";
echo preg_replace ("/(gatto|topo)/", "***", $testo);

In questo caso la parola “gatto” e la parola “topo” vengono sostituite dalla sequenza ***. Possiamo poi adoperare la funzione anche per sostituire etichette HTML:

$testo = "<strong>Ciao</strong>!!!!!";
$testo = preg_replace("/(<strong>)/", "<em>", $testo);
echo preg_replace("/(<\/strong>)/", "</em>", $testo);

In questo caso sostituiamo tutte le parole marcate in grassetto con parole marcate in corsivo. Questi non sono che alcuni esempi, e la versatilità delle espressioni regolari dà modo a ognuno di sfruttarle al meglio per le proprie esigenze. Per chiunque fosse interessato all’argomento, consiglio di approfondire facendo una ricerca sul web: si trovano davvero molti siti che sapranno spiegare meglio di me e in modo più completo l’utilizzo di questo affascinante strumento.

Ciao a tutti!!!

Benissimo, con la puntata di oggi termina anche la nostra guida di base al linguaggio PHP!

Mi auguro che la guida sia stata di vostro gradimento, che possa essere stata utile per imparare qualcosa di nuovo o per ripassare e che possa in generale dare un piccolo aiuto a chiunque voglia cimentarsi con PHP. Ringrazio Laura per avermi fornito questo spazio e ovviamente un grazie a tutti quelli che mi hanno seguito fino a questo punto, a quelli che hanno seguito anche poche puntate, a chi si è collegato una volta sola e a tutti coloro che hanno commentato e hanno tentato di risolvere gli esercizi

Un grande saluto!!!!!!!

Terminiamo oggi la breve panoramica sui più comuni problemi di sicurezza con una puntata sul session hijacking, che consiste nel “furto dell’identità” di un utente che si collega a un sito web.

Session hijacking: che cos’è

Che cosa fa il malintenzionato che sottopone l’utente di un sito a session hijacking? Non fa altro che rubare l’identificativo di sessione dell’utente (ogni sessione ha un proprio id) per poi loggarsi al sito spacciandosi per l’utente a cui ha rubato le credenziali. Uno dei metodi più comuni per rubare le credenziali è sfruttare il cross-site scripting: abbiamo però già parlato nell’episodio precedente di come difenderci da questo tipo di attacchi, quindi vedremo oggi come coprirci anche da un furto ottenuto tramite “session fixation”: con la session fixation, i dati verranno rubati tramite una sessione creata ad hoc dal malintenzionato.

Certo, affinché si verifichi una session fixation devono essere soddisfatte due condizioni: codice vulnerabile e utente sprovveduto. Nella puntata sulle sessioni non abbiamo parlato del modo in cui l’id di sessione viene propagato: ciò può avvenire tramite un cookie che viene appositamente creato per contenere l’id (cookie che si estinguerà alla chiusura del browser) oppure, nel caso in cui i cookie siano stati disabilitati, tramite metodi get e post. Il ladro di sessioni può convincere l’utente del nostro sito (magari tramite una mail o con un post su un blog) a collegarsi a un indirizzo simile a questo: www.nostrosito.it/login.php?PHPSESSID=12345 dove, attraverso la query string e ipotizzando che l’id di sessione venga propagato tramite get, decide il numero di sessione.

Simuliamo un attacco

Per comprendere meglio il meccanismo di un attacco session fixation proviamo a simularne uno (ma, come detto nella scorsa puntata, solo affinché vi possiate difendere). Per prima cosa assicuriamoci che nelle impostazioni del nostro PHP sia abilitata la trasmissione dei dati di sessione attraverso url: clicchiamo quindi sull’icona di Wamp, andiamo sotto la voce PHP e quindi apriamo il file php.ini. Cerchiamo adesso la direttiva session.use_trans_sid, che è quella che consente la tramissione degli id di sessione via url (a proposito: i commenti sopra di essa vi diranno che abilitarla sottopone a rischi di sicurezza). Se è a 1 lasciamola com’è, altrimenti se è impostata a 0 dobbiamo settarla a 1. Cerchiamo poi la direttiva session.use_only_cookies (permette la trasmissione degli id di sessione solo tramite cookie) e impostiamola a 0.

A questo punto creiamo un semplice codice PHP che al nostro collegamento dà inizio a una sessione che memorizza il numero di volte in cui visualizziamo la pagina con il nostro browser:

<?php
session_start();
if (!isset($_SESSION['conto'])) {
$_SESSION['conto'] = 0;
} else {
$_SESSION['conto']++;
}
echo "Numero:" . $_SESSION['conto']."";
?>

Tutto molto semplice. Con la solita funzione isset controlliamo che la variabile $_SESSION['conto'] non sia stata inizializzata: se non esiste, la creiamo e la impostiamo a 0, se invece esiste già la incrementiamo. Terminato il blocco if stampiamo la nostra variabile.

Salvate il file chiamandolo, per esempio, “fixation.php” e inseritelo in una cartella “prova” all’interno della cartella “www” di Wamp. A questo punto aprite il vostro browser preferito (per esempio Firefox), eliminate tutti i cookie di localhost e collegatevi a questo indirizzo: http://localhost/prova/fixation.php?PHPSESSID=12345. Aggiornate la pagina un qualsiasi numero di volte, arriviamo per esempio a 9.

A questo punto chiudete pure il browser. Riaprite un altro browser (esempio, Chrome), magari anche su un altro computer se fate la prova su un server remoto, e provate a collegarvi allo stesso indirizzo: come potrete notare il conto non ripartirà da 0 ma partirà da dove siete rimasti prima (nel nostro caso vedremo “10”). Cosa significa questo? Abbiamo simulato un ipotetico utente A che utilizza Firefox, apre la pagina con il link che gli è stato suggerito dal malintenzionato utente B e dà inizio a una sessione. L’utente B aprirà poi il suo Chrome con l’id di sessione da lui stesso creato e potrà accedere ai dati dell’utente A. In questo caso si tratta semplicemente del numero di volte che ha aggiornato la pagina, ma questo tipo di attacco funziona tranquillamente anche su script molto più complessi (per esempio un login a un sito web: il malintenzionato B potrà accedere indisturbato a tutti i dati personali dell’utente A) che però hanno seri problemi di sicurezza.

Come difendersi: session_regenerate_id

Come difendersi da questo attacco? Il metodo più semplice è rigenerare spesso l’id di sessione, in modo da rendere inefficaci gli attacchi: questo si può fare agevolmente tramite l’apposita funzione session_regenerate_id, che si applica in modo molto semplice:

session_regenerate_id();

E in genere va fatto dopo aver dato il via alla sessione con session_start. La documentazione ufficiale di questa funzione si trova all’indirizzo http://php.net/manual/en/function.session-regenerate-id.php. Inoltre sarebbe bene che le direttive di cui sopra, session.use_trans_sid e session.use_only_cookies, fossero impostate rispettivamente a 0 e 1. Comunque l’utilizzo di session_regenerate_id è di per sé già sufficiente per difendersi. È quindi bene rigenerare spesso, anche prima che l’utente abbia fatto login (inserendo quindi la funzione nella pagina di login, per esempio).

Come difendersi: controllo sullo user agent

Infine potremmo eseguire un controllo aggiuntivo sullo user agent dell’utente (perché niente impedisce che uno stesso id di sessione, come abbiamo visto, possa essere utilizzato da due utenti diversi): questo consente anche di avere una difesa contro attacchi di tipo “session sidejacking”. Attraverso questo tipo di attacco, comunque difficile da mettere in atto, il malintenzionato cerca di intercettare l’id di sessione attraverso i pacchetti di rete che vengono scambiati tra il server e il browser dell’utente. Per ovviare a questa minaccia può essere utile fare in modo che l’accesso venga impedito nel caso in cui lo user agent di chi richiede l’accesso al nostro sito non corrisponda a quello dell’utente che ha effettuato il login.

Per fare questo abbiamo bisogno della variabile superglobale $_SESSION: dovremo associare a essa il valore dell’elemento HTTP_USER_AGENT della variabile superglobale $_SERVER, meglio se codificato tramite funzione md5. Il tutto nella pagina o nella funzione che consente il login:

$_SESSION['HTTP_USER_AGENT'] = md5($_SERVER['HTTP_USER_AGENT']);

In questo modo abbiamo creato un elemento della sessione chiamato HTTP_USER_AGENT a cui abbiamo associato nient’altro che il nostro user agent criptato con md5. A questo punto, per eseguire il controllo, potremmo utilizzare un codice simile a questo:

if (isset($_SESSION['HTTP_USER_AGENT'])) {
if ($_SESSION['HTTP_USER_AGENT'] != md5($_SERVER['HTTP_USER_AGENT'])) {
logout();
}
}

Con questo script non facciamo altro che controllare, sempre tramite la funzione isset, se esiste la sessione con elemento “HTTP_USER_AGENT”: in caso affermativo, se il suo valore è diverso dallo user agent, sempre criptato con md5, dell’utente che sta eseguendo lo script (in altre parole se chi si è loggato ha uno user agent diverso rispetto a quello dell’utente che sta cercando di forzare l’accesso al sito), rimandiamo l’utente a una ipotetica funzione logout che distruggerà la sessione.

Anche per oggi la puntata è arrivata alla fine: vi do appuntamento alla prossima, la trentesima nonché ultima della nostra guida!

XSS: Cross-site scripting

Partiamo dal cosiddetto “Cross-site scripting”, noto anche come XSS: si tratta di un problema, molto diffuso, che riguarda la sicurezza dei form e in particolare i form che non applicano controlli sui campi. Il malintenzionato può, tramite il form, far eseguire un codice JavaScript che magari rimanda a un suo sito dove è contenuto uno script dannoso. A proposito: ricordo a tutti quelli che leggono (visti i numerosi accessi al sito) che alcune delle cose che sto per illustrare, se messe in pratica, costituiscono un reato penalmente perseguibile. Ve ne parlo solo affinché vi possiate difendere.

Tornando al nostro XSS, prendiamo un semplicissimo form per inserire un messaggio:

<form action="xss.php" method="get">
Nome:<br />
<input type="text" name="nome" /><br />
Messaggio: <br />
<textarea rows="10" cols="20" name="messaggio"></textarea><br />
<input type="submit" name="invia" value="Invia!" /><br />
</form>

E supponiamo che il codice della pagina xss.php sia strutturato in questo modo:

<?php
echo "Nome: {$_GET['nome']}";
echo "<br /><br />Messaggio: <br /><br />";
echo stripslashes($_GET['messaggio']);
?>

Bene, questo è un codice del tutto insicuro perché non ci sono controlli di sicurezza. Nel campo “messaggio” l’hacker può facilmente inserire un codice JavaScript di questo tipo:

<script language="text/javascript">document.location.href="http://www.web-magazine.it";</script>

Dove ovviamente al posto di web-magazine.it c’è un sito malvagio. Attraverso la stampa con echo, il codice viene inserito nella pagina xss.php e quindi eseguito. E ovviamente, date le tante cose che si possono fare con JavaScript, il reindirizzamento non è che una possibilità: il malintenzionato può infatti anche installare script dannosi direttamente all’interno del sito. E questo tipo di attacco funziona sia che il nostro form abbia metodo get, sia che abbia metodo post. Tipicamente, gli script XSS vengono utilizzati per rubare cookie ai malcapitati.

Come difendersi dal cross-site scripting

Difendersi da questo tipo di attacchi è veramente molto semplice: bisogna solo tenerlo a mente! Basterà fare in modo che i caratteri riservati del linguaggio HTML vengano sostituiti con le relative entità (per esempio la parentesi uncinata aperta con <) o che le etichette HTML vengano del tutto cancellate.

Per fare questo abbiamo tre funzioni: htmlspecialchars, htmlentities e strip_tags. Funzionano tutte allo stesso modo: ricevono come parametro la stringa per la quale dobbiamo sostituire i caratteri. Ecco quindi qual è il codice corretto e sicuro da utilizzare nella pagina xss.php:

<?php
echo "<br /><br />Messaggio: <br /><br />";
echo htmlspecialchars(stripslashes($_GET['messaggio']));
?>

Oppure

echo htmlentities(stripslashes($_GET['messaggio']));

O ancora

echo strip_tags(stripslashes($_GET['messaggio']));

htmlspecialchars, htmlentities e strip_tags

Ci sono ovviamente alcune differenze tra le tre funzioni. La differenza tra htmlspecialchars e htmlentities consiste nel fatto che la prima converte in entità solo i caratteri riservati di HTML, mentre la seconda converte anche i caratteri speciali (per esempio, se dovessimo scrivere in tedesco, la o con la dieresi – ö – sarebbe convertita in ö). La funzione strip_tags invece elimina del tutto le etichette HTML. In ogni caso, il codice immesso dal malintenzionato verrebbe stampato sullo schermo e non eseguito (anzi, nel caso di strip_tags le tag verrebbero del tutto eliminate). E ricordate sempre: uno dei migliori metodi per difendersi dagli attacchi è filtrare tutto ciò che arriva in input sul nostro sito. In questo caso abbiamo visto come filtrare attraverso le tre funzioni di cui abbiamo parlato: potete trovare le documentazioni ufficiali delle funzioni a queste pagine: http://www.php.net/manual/en/function.htmlspecialchars.php (htmlspecialchars), http://php.net/manual/en/function.htmlentities.php (htmlentities), http://it.php.net/manual/en/function.strip-tags.php (strip_tags).

SQL Injection

Il secondo problema di vulnerabilità che vediamo oggi è la cosiddetta SQL Injection (iniezione di SQL). Anche in questo caso l’attacco prende di mira form scritti male per eseguire un codice SQL malevolo, e adesso vedremo nel dettaglio in cosa consiste questa pratica e perché è tanto pericolosa. Prendiamo per esempio questo semplice form per connettersi a un sito:

<form action="login.php?step=2" method="post">
Nickname:<br />
<input type="text" name="nickname" /><br />
Password: <br />
<input type="password" name="psw" /><br />
<input type="submit" name="invia" value="Invia!" /><br />
</form>

In questo caso il nostro form, invece di rimandare a una nuova pagina, rimanda alla stessa ma con l’aggiunta della query string ?step=2, in modo da scrivere tutto nella stessa pagina. L’azione del form andrà quindi scritta in un blocco if di questo tipo:

if (isset($_GET['step']) && $_GET['step'] == 2) {
// azione
}
else {
}

Ipotizziamo anche che il gestore del sito o del blog sia stato così sprovveduto da aver fatto in modo che le password vengano inserite in chiaro nel database (quindi senza criptarle attraverso il form di registrazione). Ora prendiamo il pessimo script che esegue il controllo sui dati immessi dall’utente:

$query = "SELECT * FROM autori WHERE Nickname = '{$_POST['nickname']}' AND Password = '{$_POST['psw']}'";
$risultato = mysql_query($query);
if (mysql_num_rows($risultato) == '1') {
echo "Benvenuto, utente autenticato";
// codice che mostra l'eventuale pagina personale dell'utente
}
else {
echo "Spiacente, password errata";
}

Chiariamo subito la funzione nuova, mysql_num_rows: restituisce il numero dei record trovati dalla query (nel nostro caso uno, anche perché si suppone che gli username siano univoci) e riceve come parametro il risultato della query. Qua si trova la documentazione ufficiale della funzione: http://php.net/manual/en/function.mysql-num-rows.php. Pertanto se la funzione dà come risultato 1 (e quindi trova il record), l’utente sarà loggato, in caso contrario ci sarà un messaggio che informerà l’utente di aver inserito una password errata.

Questo codice è estremamente vulnerabile, soprattutto nel caso in cui l’impostazione magic quotes gpc di PHP sia disattivata: in locale potete controllarlo su WAMP cliccando sull’icona nella barra delle applicazioni, quindi andare alla voce PHP e ancora andare su Impostazioni PHP. Se la voce “magic quotes gpc” è spuntata significa che è attiva e avete maggiori protezioni contro le SQL Injection. Ci sono però tanti provider che non attivano le magic quotes sui loro server. Ma cosa sono le magic quotes? Si tratta di un processo che aggiunge in automatico i caratteri di escape alle stringhe, ma dobbiamo sapere che a partire dalla versione 5.3.0 di PHP, magic quotes è deprecato e nella versione 6 addirittura non c’è più.

Vediamo quindi cosa può fare il malintenzionato. Nella casella nickname può inserire il nome “Federico”, e fin qui niente di strano. Ma nella casella password può tranquillamente inserire questa stringa:

' OR Nickname='Federico

Così facendo, il nostro codice eseguirebbe questa query:

$query = "SELECT * FROM autori WHERE Nickname = 'Federico' AND Password =
'' OR Nickname='Federico'";

La clausola OR inserita dal malintenzionato vanificherà il controllo sulla password: questo perché la query strutturata in tal modo dice di selezionare tutti i record della tabella autori il cui nickname sia Federico e la cui password sia vuota oppure, in alternativa a quest’ultima clausola, il cui nickname sia Federico. Dal momento che la seconda clausola è soddisfatta il malintenzionato riuscirà a entrare agevolmente al posto di Federico all’interno del sito, spacciandosi per lui e magari rubando i suoi dati… o insomma facendo tutto ciò che di cattivo si può fare entrando nel profilo di un’altra persona.

Criptiamo la password con md5

La prima operazione da fare è criptare la password attraverso la funzione md5: nel database non dovrà essere inserita in chiaro ma andrà fatta passare attraverso questa funzione (in un’ipotetica query con comando INSERT INTO metteremo tra i VALUES ‘md5($_POST['password']‘). MD5 è un algoritmo crittografico di hashing che fu realizzato nel 1991 da Ronald Linn Rivest, un crittografo statunitense: l’algoritmo trasforma una stringa in un’altra stringa a 128 bit, e non è possibile risalire alla stringa originale (se non andando… a tentativi). La funzione md5 di PHP riceve come parametro semplicemente la stringa da criptare e la documentazione ufficiale si trova qui: http://it.php.net/manual/en/function.md5.php.

Questo è solo uno dei tanti modi per criptare una password: parliamo di questo perché è il più semplice da utilizzare, ma c’è chi usa anche sistemi più sofisticati. Il nostro codice pertanto dovrà presentarsi in questa forma:

$query = "SELECT * FROM autori WHERE Nickname = '{$_POST['nickname']}' AND Password = '". md5($_POST['psw']). "'";

Dove i punti che separano md5($_POST['psw']) dal resto del codice sono un modo per concatenare valori all’interno di una variabile (le virgole non funzionano).

In questo caso ci salviamo dal malintenzionato che immette i dati di cui sopra, ma siamo ancora vulnerabili. Questo perché l’hacker potrebbe scrivere nella casella del nickname questa stringa cattivissima:

Federico' --

E magari può anche lasciare in bianco il campo della password. In tal modo la query diventerebbe questa:

$query = "SELECT * FROM autori WHERE Nickname = 'Federico' -- AND Password =
''";

I due trattini nel linguaggio SQL indicano i commenti: pertanto tutto ciò che viene dopo i due trattini sarà ignorato. Capite quindi la pericolosità della cosa malgrado il controllo tramite algoritmo md5. Sarà un giochetto per il malintenzionato riuscire a entrare nel sito e magari carpire tutta la lista degli utenti registrati o a far di peggio: pensate se potesse entrare con l’account dell’amministratore.

Come difendersi dalla SQL injection

Qual è pertanto il modo più sicuro per difendersi da questo tipo di attacco? Non dovremo far altro che aggiungere una funzione per controllare i dati immessi dall’utente (ricordate… filtrare sempre tutto), e si tratta della funzione mysql_real_escape_string, che inserisce i giusti caratteri di escape prima dei caratteri “pericolosi”. Riceve come parametro semplicemente la stringa a cui aggiungere i parametri di escape. Quindi la nostra query dovrà assumere questa forma per evitare attacchi:

$query = "SELECT * FROM autori WHERE Nickname = '". mysql_real_escape_string($_POST['nickname']) ."' AND Password = '". mysql_real_escape_string($_POST['psw']). "'";

Riusciremo così a rendere inoffensivo l’attacco del malintenzionato, perché l’ultima stringa che abbiamo visto risulterà invece in questo modo:

$query = "SELECT * FROM autori WHERE Nickname = 'Federico\' -- AND Password = ''";

Questa funzione va utilizzata solo nel caso in cui magic quotes gpc sia disattivo. Per essere però del tutto sicuri utilizziamo la funzione get_magic_quotes_gpc, che controlla la configurazione delle magic quotes (non riceve alcunché come parametro), e inseriamola in un blocco if:

if(get_magic_quotes_gpc()) {
$query = "SELECT * FROM autori WHERE Nickname = '". $_POST['nickname'] ."' AND Password = '".
$_POST['psw']. "'";
}
else {
$query = "SELECT * FROM autori WHERE Nickname = '". mysql_real_escape_string($_POST['nickname']) ."'
AND Password = '". mysql_real_escape_string($_POST['psw']). "'";
}

Controlliamo con il ciclo che il processo magic quotes gpc sia attivo, e in caso affermativo creiamo la nostra query senza la funzione mysql_real_escape_string, e in caso contrario ovviamente la aggiungiamo. Trovate la documentazione ufficiale di queste due funzioni qui http://it.php.net/manual/en/function.mysql-real-escape-string.php (mysql_real_escape_string) e qui http://php.net/manual/en/function.get-magic-quotes-gpc.php (get_magic_quotes_gpc).

Vi aspetto come sempre alla prossima puntata!

Ce ne ho messo di tempo ma alla fine ho pensato che sarebbe stato giusto dare delle spiegazioni.
Il mio problema è che non ho capacità di sintesi per cui mi sa che queste spiegazioni dureranno parecchi post.

Spiegazioni riguardo due cose principalmente.

La prima è il blog, e la carenza di aggiornamenti.

Web Magazine non si è fermato ma quasi, tempo di scrivere non ne ho più e non credo che ne avrò mai, e se non fosse per i miei preziosi Federico e Dario, rispettivamente Mr. Php e Mr. Seo, il blog sarebbe quasi defunto.

Lunga vita ai miei collaboratori!

Leggete i loro post Leggete i loro post Leggete i loro postLeggete i loro post Leggete i loro post Leggete i loro postLeggete i loro post..

i ragazzi si impegnano!

La seconda spiegazione è il perchè dopo anni in cui ho professato la cosiddetta missione freelance io sia tornata a timbrare cartellini.

Facciamo però un passo indietro, anticipando prima di tutto che questo non è un post tecnico, nè un tutorial nè una guida, è un post assolutamente personale dedicato ai miei storici seguaci e a chi proprio non sa farsi gli affari propri.

Leggendo questo post non imparerete nulla, qualcuno si farà due risate e straccerà il mio ebook… dopo averlo stampato.

Ma se pensate che le esperienze vissute possano in qualche modo arricchire allora vi racconto la mia vita negli ultimi sei mesi e cercheremo anche di dare un senso a quel titolo assurdo.

Giugno 2011 -  Dopo un breve scambio di email decido di accettare un prestigioso nonchè molto-ma-mooolto-ben-pagato incarico, rigorosamente freelance, come interface designer per un progetto della Commissione Europea, progetto che mi avrebbe portato a 900km da casa per sei mesi fino ad un massimo di tutta la vita, se lo avessi voluto.
Progetto che puoi andare a sbandierare in giro perchè oggettivamente lavorare in una ex centrale nucleare in un contesto europeo dove si parla esclusivamente in inglese è una cosa maledettamente fica, non facciamo i falsi modesti.

A quel punto se fossimo stati in una di quelle storie di Topolino con il “bivio” (si ok, leggevo topolino ma mi stava sulle palle) avrei imboccato la strada cosiddetta: Ricca e alquanto infelice. Ma qui ci arriveremo.

Aspettavo quindi  la partenza di Settembre, potevo godermi le vacanze certa del fatto che sarei poi partita per soldolandia e nel frattempo avrei fatto giusto qualche lavoretto da casa, il bello di lavorare e abitare praticamente su una spiaggia è che in estate fare pausa pranzo in costume ti ripaga da tutte le rotture di palle che ti portano i clienti.. ma invece no, niente relax pre partenza, accetto una consulenza.

In realtà era una sorta di sostituzione di un web designer, quindi sarei dovuta restare  per 6 settimane in una web agency di Napoli non potendo lavorare da casa per questo tipo di incarico, ma l’agenzia già in fase di colloquio mi aveva impressionata positivamente. Persone umili ma assolutamente competenti, idee chiare in termini di business e un ambiente allegro e giovanile che, diciamocela tutta, non potevo di certo trovare nelle 4 mura del mio studiolo casalingo.

E si, accetto, nonostante la spiaggia, il costume, e il perenne e dolcissimo suono del mare.

Prendo l’auto e torno ai rumori della città, al caos delle agenzie, e alla bellezza di poter scambiare opinioni dal vivo con un collega.

E il primo giorno in agenzia, mentre mi sentivo come una scolaretta di trent’anni che aveva tanta voglia di fare bella figura,  vengo assalita dal panico.

Mi viene assegnato il primo incarico: Disegnare un logo.

Io, che non ho problemi a dire ad un cliente che se vuole il logo lo pagherà il doppio semplicemente perchè odio fare i loghi;

io, che ho fatto le migliori litigate nella speranza di chiarire il concetto che un web designer e un grafico pubblicitario sono due figure assolutamente diverse..

io che non voglio che i loghi vengano considerati come accessori gratuiti di un sito, come il bicchiere che il supermercato ti regala se acquisti il latte, come il cioccolatino che ti offre il bar mentre ti serve il caffè, come il pareo che esce da Donna Moderna ad Agosto.

Ecco, il logo non è il pareo di Donna Moderna.

Io dovevo disegnare un logo???

Pensavo mi considerassero una discreta web designer, e mi hanno chiesto di disegnare un logo.

Il primo giorno di lavoro.

Ma ora ho tanta fame quindi il resto lo scriverò poi.

Con la puntata di oggi vedremo in che modo, con PHP, è possibile conservare informazioni durante la navigazione: si tratta di un aspetto molto utile soprattutto se è necessario costruire un sito web che debba consentire ai propri utenti di fare il login e di navigare le pagine in qualità di utenti registrati. Per fare questo abbiamo due strumenti a nostra disposizione: il primo è costituito dalle sessioni, il secondo dai cookie.

Le sessioni

Iniziamo dalle sessioni: dobbiamo immaginare le sessioni come “contenitori” in cui possiamo inserire diverse informazioni. Queste informazioni verranno memorizzate sul server e dureranno il tempo di una… “sessione”, appunto, perché quando il browser verrà chiuso tutte queste informazioni saranno cancellate.

La funzione session_start

PHP mette a disposizione di chiunque voglia creare una sessione la variabile superglobale $_SESSION, che funziona proprio come tutte le altre variabili superglobali di cui abbiamo già parlato nelle puntate scorse. Prima di tutto però c’è un’operazione preliminare da compiere, ovvero avviare la sessione. Lo si fa con una sezione apposita, session_start, che deve obbligatoriamente essere inserita prima di qualsiasi tipo di output all’interno del nostro file PHP:

<?php
session_start();
// codice...
?>

Creare sessioni

La funzione session_start (la cui documentazione ufficiale si può trovare all’indirizzo http://php.net/manual/en/function.session-start.php) non solo permette di creare una sessione, ma permette anche di recuperare dati da una sessione creata in un’altra pagina. Ma come si fa a creare una sessione? Basta semplicemente utilizzare la variabile superglobale $_SESSION e associare a essa le informazioni:

$_SESSION['nome'] = "Federico";
$_SESSION['id'] = "1";
$_SESSION['livello'] = "3";

Ovviamente queste informazioni, nel caso di un utente che si collega al nostro sito, si possono agevolmente recuperare da un database (nell’esempio ometterò, per semplicità, la query, perché parleremo nella prossima puntata di come recuperare in modo corretto e allo stesso tempo semplice i dati immessi da un utente per fare un login):

$query = // ipotetica select per verificare i dati inseriti dall'utente
$result = mysql_query($query);
$numero_record = mysql_num_rows($result);
if($numero_record == 1) {
while($row = mysql_fetch_array($result, MYSQL_ASSOC)) {
$_SESSION['id'] = $row['id'];
$_SESSION['nome'] = $row['nome'];
$_SESSION['livello'] = $row['livello'];
}
echo "Login effettuato con successo!";
}

In tutte le pagine che vorremo riservare agli utenti registrati, dovremo inserire prima di qualsiasi altra cosa la funzione session_start: se omettessimo la funzione, la pagina non potrebbe ricevere le informazioni delle sessioni. Se per esempio con un blocco if controlliamo che l’utente sia loggato (per esempio verificando, tramite isset, che sia impostato il livello dell’utente a sua volta memorizzato nella variabile superglobale $_SESSION) ma allo stesso tempo dimentichiamo di inserire la funzione session_start, la conseguenza sarà che la pagina non conoscerà le informazioni memorizzate nella sessione e la nostra applicazione si comporterà come se l’utente non si fosse mai loggato al sito. Attenzione anche a non dichiarare due volte la funzione (spesso, includendo file nella pagina, può capitare di farlo), perché session_start può essere dichiarata una volta soltanto.

Come azzerare o eliminare le sessioni

Le sessioni possono essere poi azzerate o eliminate: per fare questo è possibile utilizzare le funzioni session_unset e session_destroy. La differenza consiste nel fatto che la prima funzione elimina soltanto i dati (senza cancellare gli elementi dell’array che abbiamo dichiarato in precedenza), la seconda invece elimina dati e array. Pertanto in seguito a session_destroy sarà necessario dichiarare nuovamente session_start. Sono utili in funzioni di logout e si invocano in modo molto semplice:

session_unset();
session_destroy();

I cookie

Parliamo adesso dei cookie: molti di voi li avranno già sentiti nominare. I cookie (letteralmente “biscotti”) sono informazioni che vengono inviate dal server al client: e proprio qui sta la prima differenza rispetto alle sessioni, perché queste ultime rimangono sul server. Un’altra differenza consiste nel fatto che la sessione viene cancellata nel momento in cui il browser viene chiuso: il cookie invece persiste fino alla sua scadenza, impostata quando il cookie viene creato. Data la natura dei cookie, questi ci torneranno utili se vogliamo creare un modulo di login che si “ricordi” dell’utente una volta chiuso il browser, per evitargli magari di immettere nuovamente nome e password al collegamento successivo. Un altro esempio può essere dato da un sito multilingua: se il nostro sito accoglie l’utente in italiano, ma quest’ultimo preferisce l’inglese, potrebbe rendersi necessario un cookie che si ricordi dell’impostazione settata dall’utente (ovvero “sito in lingua inglese”) ogni volta che si collega.

La funzione setcookie e i suoi parametri

Per creare un cookie esiste un’apposita funzione, setcookie, che riceve tre parametri principali: il nome del cookie, le informazioni e la durata:

setcookie("nome", "Federico", time()+3600);

La durata si imposta utilizzando la funzione time: quest’ultima restituisce il numero di secondi trascorsi dal 1 gennaio 1970 alle ore 00:00:00. Si tratta della data di inizio del tempo calcolato sui sistemi Unix ed è, come già detto, espresso in secondi: si intuisce quindi che al valore restituito da time bisognerà aggiungere un numero di secondi equivalente al periodo di durata del nostro cookie. Nel caso dell’esempio, 3600 secondi: significa che il cookie avrà la durata di un’ora (formata da 3600 secondi). Si intuisce quindi che è possibile settare una durata qualsiasi per il nostro cookie, anche di anni!

setcookie("nome", "Federico", time()+3600*24); //un giorno

setcookie("nome", "Federico", time()+3600*24*30); // un mese

setcookie("nome", "Federico", time()+3600*24*365); // un anno

Se invece la scadenza non viene impostata, il cookie scadrà semplicemente alla fine della sessione. La documentazione ufficiale della funzione time è disponibile all’indirizzo http://php.net/manual/en/function.time.php.

Quello che abbiamo visto sopra è l’esempio più tipico, ma in realtà si possono estendere a sette i parametri che la funzione setcookie può ricevere, perché oltre a nome, valore e scadenza possiamo specificare anche percorso (ovvero la directory per cui è valido il cookie), il dominio (come per il percorso, ma si estende a tutto il dominio), la sicurezza (che se settata a true fa in modo che il cookie venga trasmesso solo attraverso protocollo sicuro https) e httponly (funziona come la sicurezza: se settato a true, fa in modo che il cookie venga trasmesso solo tramite protocollo http, e di conseguenza non sarà accessibile a linguaggi di scripting come JavaScript). Per esempio:

setcookie("nome", "Federico", time()+3600, "/prova/", "web-magazine.it", true, true);

In questo caso il cookie è valido solo per la cartella “prova” del sito “web-magazine.it” (che non va scritto con “www” anteposto), si trasmette solo in presenza di una connessione sicura ed è accessibile solo al protocollo http.

setcookie("nome", "Federico", time()+3600, "/");

In questo caso invece abbiamo creato, attraverso la formula “/”, un cookie che è valido per tutte le cartelle del sito.

Recuperare il valore dei cookie

Per recuperare il valore di un cookie che abbiamo impostato in precedenza, sarà necessario utilizzare la variabile superglobale $_COOKIE, e il nome dell’elemento dell’array non sarà altro che il primo valore che abbiamo passato come parametro alla funzione setcookie:

echo $_COOKIE['nome']; // stampa “Federico”

È ovvio che possiamo anche inizializzare variabili a cui abbinare i valori delle nostre sessioni o dei nostri cookie:

$nome = $_SESSION['nome'];
$cognome = $_COOKIE['cognome'];

Per poi utilizzarle comodamente all’interno del nostro codice, magari su blocchi condizionali. Tipicamente, ci si assicura che prima le variabili di sessione e i cookie siano settati tramite funzione isset, onde evitare di veder comparire warning sul sito nel caso in cui sessioni e cookie non siano ancora stati scritti (per esempio quando l’utente si è appena collegato al sito e non ha ancora fatto login).

Eliminare i cookie

Abbiamo visto prima come eliminare una sessione. I cookie non hanno una specifica funzione per eliminarli, ma per farlo basta semplicemente utilizzare, di nuovo, la funzione setcookie (a proposito, la pagina di documentazione ufficiale è http://php.net/manual/en/function.setcookie.php) impostando però, come scadenza, un tempo negativo:

setcookie("nome", "Federico", time()-3600);

E così facendo avremo eliminato il nostro cookie. Sempre la solita funzione si utilizza se vogliamo modificare i valori di un cookie: basterà semplicemente invocare setcookie con i nuovi parametri.

E anche per oggi la puntata arriva al termine… arrivederci al prossimo episodio!!!

Se ritenete di avere le caratteristiche adatte e avete voglia di lavorare  in un ambiente giovane e stimolante inviate il vostro curriculum a info@totalcup.com e non dimenticate di citare i vostri lavori web più rappresentativi, in particolare specificate il vostro ruolo nel progetto!

Cercasi web designer!

Totalcup s.r.l. nuovo social network dedicato all’organizzazione di incontri sportivi di squadra, cerca un web interface designer da inserire nel team di sviluppo, che si occuperà del disegno e sviluppo front end, delle interfacce utente e di tutti gli aspetti legati alla usabilità e User Experience del portale.

Si richiede esperienza nella progettazione e disegno di layout web e conoscenza approfondita di xhtml, css e framework Javascript.

Il lavoro è a Napoli, full time. Non vengono prese in consiederazione candidature per telelavoro.

Inizio questo post con un’ immagine che dice moltissimo sul valore delle e-mail, e soprattutto su quanto siano usate ad oggi.

Questa infografica ci fa vedere benissimo il rapporto tra: il numero degli account dei vari social network, dei siti e delle e-mail e la loro attività quotidiana, le e-mail battono tutti; con circa 3 miliardi di utenti e 188 miliardi di attività giornaliere (intese come messaggi ).

Proviamo a distinguere i vari tipi di E-mail :

E-mail Personali

sono i tipici messaggi inviati da una persona alla seconda in modo diretto e personale

E-mail Transazionali

sono i messaggi (solitamente automatici) che notificano qualcosa, ad esempio la registrazione ad un portale, solleciti, scadenze,bonifici etc . Solitamente questo tipo di e-mail non sono inviati in modo massivo .

E-mail pubblicitarie (DEM)

Newsletter

sono messaggi periodici che l’ azienda invia ai propri clienti o  collaboratori o a tutte quelle persone che sono interessati al prodotto o all’azienda stessa. Come detto sono comunicazioni inviati con cadenza periodica come per esempio mensile o quindicinali.

Le newsletter non fanno riferimento a promozioni in particolare ma sono indispensabili per mantenere viva una linea di comunicazione tra l’azienda e l’utente interessato .

Ora che abbiamo visto le varie tipologie di messaggi, proviamo a vedere alcuni principi fondamentali dell’e-mail marketing .

Solitamente si invia un messaggio per incrementare le vendite, incrementare gli iscritti o per coltivare la fedeltà del cliente, bisogna seguire delle strategie precise  come : dare informazioni di valore, tempestive e rilevanti in cambio di un po’ di tempo ed attenzione da parte dell’utente.

Il cliente è disposto a condividere con noi  alcuni dei suoi dati personali, se : la nostra pubblicità non risulta invasiva e fastidiosa, se rispettiamo la sua privacy e se riusciamo a personalizzare sempre di più i messaggi che gli inviamo.

Io personalmente credo che una e-mail risulti più efficace quanto più è bella graficamente e soprattutto quando non è inviata 10 volte a settimana .

Sicuramente molti di voi saranno iscritti ad alcune newsletter; provate a pensare qual è secondo voi la migliore e perché, io nella mia hit parade ho quella di un noto marchio giapponese di videogiochi (quella di Mario per intenderci ).

Nei commenti inviatemi le vostre .

In commercio esistono molte società che vendono dei pannelli per newsletter molto efficaci per l’invio di grosse quantità di e-mail. Basta fare una ricerca su un motore di ricerca e se ne trovano davvero tanti .

E’ fondamentale usare software/pannelli appositi per newsletter, e non fare invii con outlook  (questo per non violare le regole,sempre più severe, antispam dei server ), i vari software o pannelli online, oltre ad avere plugin particolari come per esempio :  gestioni delle liste di e-mail, anteprima delle e-mail e in alcuni casi anteprime delle varie e-mail dei riceventi (per esempio yahoo, hotmail, gmail etc è molto importante per vedere se il layout si apre bene su tutti i vari browser) e naturalmente unscribe molto veloce da parte dell’utente e dei servizi che servono a vedere se il messaggio ha una buona probabilità o meno di finire nei vari filtri antispam .

Mi raccomando: se superate 50-100 e-mail per invio non usate il vostro client o provider per mandare le e-mail, se alcune filtri vi inseriscono nell’antispam diventa un problema per il vostro dominio e per la vosta reputazione online.

Una delle principali critiche che ricevo dai clienti è : perché devo pagare un servizio di newsletter, visto che l’e-mail è gratis ?

Nelle righe precedenti ho provato a spiegarlo, oltre a tutti i vantaggi nell’usare prodotti creati apposta per inviare newsletter, è fondamentale non finire nelle black list dei servizi antispam .

Come costruire una lista di indirizzi

Diciamo subito che acquistare migliaia di indirizzi (anche se ben profilati dalla società da cui li acquistiamo) non ha un gran ritorno (rispetto all’investimento ). Le e-mail ben profilate costano e l’apertura del messaggio non è sempre scontata da persone che non conoscono il nostro brand o i nostri prodotti.

Questo è sempre un discorso particolare, se mandate 2 milioni di e-mail sicuramente dei risultati li avrete e sicuramente venderete i vostri prodotti e servizi, ma bisogna vedere quanto costano 2 milioni di e-mail  e soprattutto è molto alta la possibilità che siano utenti/clienti  una “tantum” e non clienti selezionati e affiliati.

La soluzione migliore è costruirsi il proprio database di propri utenti, un primo consiglio è inserire un piccolo spazio nel proprio sito, dove inserire un box con “Iscriviti alla newsletter” . Ricordatevi di inserire l’autorizzazione al trattamento dei dati perché come tutti saprete, l’indirizzo di posta elettronica è un dato personale, in base alle norme sul trattamento dei dati , l’interessato ha tutto il diritto ad opporsi al trattamento dei dati che lo riguardano.

Detto questo, ci sono ormai moltissime aziende che fanno confermare un link inviato alla propria mail , solo dopo la conferma dell’iscrizione inseriscono l’ e-mail nel proprio database. Questo metodo a molti sembra complicato e fa perdere delle iscrizioni, ma sei davvero sicuro ti serva un’ utente che non apre la casella di posta e non sa cliccare un link ?

Un secondo consiglio, ben più complicato del primo è di realizzare campagne pubblicitarie, a misura del proprio business/prodotto e realizzare delle landing page .

Delle buone landing page o meglio delle squeeze page (che sono delle particolari pagine di arrivo che hanno come unico obiettivo, la raccolta dell’indirizzo e-mail) sono capaci di popolare un database di e-mail , molto in fretta e, cosa davvero più importante , le e-mail sono profilate sulle richieste  dell’azienda .

Nel prossimo post vorrei completare questo argomento con : “come creare messaggi e-mail efficaci”e se avete altre curiosità sulle e-mail marketing, chiedetelo nei commenti

Dario

Con la puntata di oggi metteremo in pratica i concetti appresi negli ultimi episodi della guida e vedremo come costruire un semplice form di ricerca PHP/MySQL per fare ricerche all’interno del nostro blog. Come sempre, in occasione di puntate “pratiche”, faremo un ripasso generale degli ultimi concetti ma introdurremo anche qualcosa di nuovo.

Costruiamo il form

Allora, iniziamo a costruire il nostro form, in maniera molto semplice, come siamo abituati:

<form name="ricerca" action="ricerca.php" method="post">
<input type="text" name="cerca" />
<input type="submit" name="vai" value="Cerca!" />
</form>

Si tratta, come vedete, di un semplicissimo form con metodo post che rimanda a una pagina “ricerca.php”. Il nostro form ha un campo, che servirà all’utente per immettere il testo da ricercare, e un bottone per inviare i dati.

Nel costruire la pagina “ricerca.php”, come prima cosa assicuriamoci di fare un controllo sul pulsante: se è stato premuto, quindi se l’utente proviene dalla pagina del form, sarà eseguito il codice, e in caso contrario (se per esempio l’utente arriva alla pagina ricerca.php semplicemente digitandola nella barra degli indirizzi) non dovrà succedere alcunché. Vediamo:

if(isset($_POST['vai'])) {
// codice
// codice
// codice
}
else {
}

Iniziamo a riempire la pagina dei risultati…

Vediamo ora come riempire il blocco if. Per prima cosa dobbiamo decidere se la ricerca riguarderà soltanto i post o i commenti. Noi vedremo tre esempi: il primo per i post, il secondo per i commenti e il terzo per entrambi.

Iniziamo dalla ricerca nei soli post. Per prima cosa stampiamo una scritta per indicare all’utente che la ricerca è stata compiuta e quindi inizializziamo una variabile, a cui assoceremo la parola cercata:

echo "Ecco i risultati della tua ricerca:<br /><br /> ";
$parolacercata = $_POST['cerca'];

Fatto questo è arrivato il momento di creare la nostra query per la ricerca all’interno della base di dati:

$query = "SELECT * FROM Post WHERE Titolo LIKE '%$parolacercata%' OR TestoHTML LIKE '%$parolacercata%'";

L’operatore LIKE e i suoi utilizzi

Bene, vedete che abbiamo due “novità”: la prima è l’operatore LIKE, e la seconda sono i due simboli di percentuale prima e dopo la variabile. Procediamo con ordine.

LIKE è un operatore di confronto, come l’uguale, il maggiore, il minore e tutti gli altri. Funziona più o meno come l’operatore di uguaglianza, ma con una differenza molto significativa: con l’uguale avremmo cercato la parola precisa, invece con LIKE eseguiamo una ricerca “non precisa”. I due caratteri di percentuale prima e dopo la variabile della parola cercata servono infatti per dare una “connotazione” all’operatore LIKE, nel senso che immettendolo prima della variabile, dichiariamo che potrebbero esserci altri caratteri prima della parola che abbiamo cercato, e invece immettendolo dopo non facciamo altro che dichiarare che potrebbero esserci altri caratteri subito dopo.

Ma vediamo un esempio concreto. Supponiamo di avere tre post, il primo che si intitola “Ciao”, il secondo che si intitola “Ciao a tutti!” e il terzo “Un ciao ai miei amici!”. E supponiamo anche di avere alcune query di ricerca (per semplicità operiamo soltanto sul titolo):

$query = "SELECT * FROM Post WHERE Titolo = '$parolacercata'";

$query = "SELECT * FROM Post WHERE Titolo LIKE '$parolacercata'";

$query = "SELECT * FROM Post WHERE Titolo LIKE '%$parolacercata'";

$query = "SELECT * FROM Post WHERE Titolo LIKE '$parolacercata%'";

$query = "SELECT * FROM Post WHERE Titolo LIKE '%$parolacercata%'";

Supponiamo adesso di cercare la parola “ciao”. Vediamo i risultati per i cinque casi che abbiamo elencato sopra:

• Caso 1: viene trovato soltanto il post intitolato “Ciao”, perché abbiamo chiesto informazioni precise, ovvero i post il cui titolo è esattamente uguale alla parola cercata (maiuscole e minuscole non contano perché SQL non è case sensitive come abbiamo avuto già modo di rimarcare);
• Caso 2: è del tutto equivalente al caso 1 (quindi è praticamente inutile usare LIKE da solo);
• Caso 3: vengono trovati i post che contengono la parola cercata anche se ci sono caratteri che la precedono. Nel nostro caso troviamo soltanto “Ciao”, perché è vero che il post “Un ciao ai miei amici!” ha la parola “ciao” preceduta da altri caratteri, ma è anche seguita da un’altra sequenza (“ ai miei amici”), quindi non soddisfa i requisiti di ricerca. Se avessimo avuto un post intitolato “Un ciao”, sarebbe stato restituito come risultato;
• Caso 4: il contrario del precedente, vengono trovati “Ciao” e “Ciao a tutti!”. Abbiamo infatti cercato i record dove il campo titolo contiene la parola cercata ma può anche contenere una stringa di caratteri dopo. “Ciao” e “Ciao a tutti!” soddisfano questa condizione;
• Caso 5: vengono trovati tutti e tre i post, dal momento che abbiamo detto di estrarre i record il cui campo titolo contiene la parola cercata, che può essere o preceduta o seguita da altre sequenze di caratteri.

Possiamo poi anche fare ricerche “negative”:

$query = "SELECT * FROM Post WHERE Titolo NOT LIKE '%$parolacercata%'";

In questo caso, anteponendo quindi la parola NOT all’operatore LIKE, la nostra interrogazione fa in modo che vengano estratti i post il cui titolo non contiene la parola cercata, preceduta o seguita da altre stringhe di caratteri. E poi abbiamo anche un altro carattere speciale, l’underscore:

$query = "SELECT * FROM Post WHERE Titolo LIKE '_$parolacercata_'";

In questo caso la nostra interrogazione estrae tutti i post che contengono la parola cercata, preceduta o seguita da un solo carattere: pertanto, se il carattere di percentuale equivale a “qualsiasi numero di caratteri”, l’underscore equivale a “un solo carattere”.

La specifica ESCAPE

Potremmo però voler cercare una parola che sia effettivamente preceduta da un underscore, e quindi non volerlo considerare come carattere speciale. In questo caso dovremo scrivere questo:

$query = "SELECT * FROM post WHERE Titolo NOT LIKE '_$parolacercata' ESCAPE";

Aggiungendo la specifica ESCAPE facciamo capire che quello che precede la variabile cercata è un vero underscore e non un carattere speciale.

Bene, una volta inviata la nostra interrogazione possiamo procedere con la stampa:

while ($record = mysql_fetch_array($risultato, MYSQL_ASSOC)) {
echo $record['Titolo']; echo "<br />";
}

Riepiloghiamo…

In questo caso stampiamo soltanto il titolo, ma possiamo decidere a piacere come far apparire all’utente il risultato della nostra ricerca. Quindi riepiloghiamo tutto il codice della pagina “ricerca.php”:

if(isset($_POST['vai'])) {
echo "Ecco i risultati della tua ricerca:<br /><br /> ";
$parolacercata = $_POST['cerca'];
$query = "SELECT * FROM post WHERE Titolo NOT LIKE '%$parolacercata%'";
$risultato = mysql_query($query);
while ($record = mysql_fetch_array($risultato, MYSQL_ASSOC)) {
echo $record['Titolo']; echo "<br />";
}
}
else {
}

E anche per oggi è tutto… vi aspetto alla prossima!

Terminiamo il nostro panorama sulle operazioni che si possono fare sul database parlando oggi di funzioni aggregate e di query annidate. Iniziamo dalle prime, dette anche “funzioni di aggregazione”: si tratta di una serie di funzioni che il linguaggio SQL ci mette a disposizione per estrarre diversi tipi di informazione dal nostro database, perlopiù di tipo statistico.

La funzione COUNT

Supponiamo, per esempio, di voler creare una pagina all’interno della quale inserire una serie di statistiche relative al nostro blog. Potremmo iniziare dal numero complessivo dei post presenti nel blog (e quindi nel database). Come fare per sapere quanti sono? Utilizziamo la funzione aggregata COUNT, che invocheremo sulla tabella dando un nome al risultato che verrà estratto tramite la clausola AS. Vediamo la sintassi:

$query = "SELECT COUNT(*) AS TotalePost FROM Post";
$risultato = mysql_query($query);

Tutte le funzioni devono essere invocate dopo il comando SELECT. Nel nostro caso, invochiamo la funzione COUNT su tutti i campi (*) e quindi chiamiamo il risultato TotalePost. Possiamo poi stampare il tutto come abbiamo visto finora:

while ($record = mysql_fetch_array($risultato, MYSQL_ASSOC)) {
echo "Totale post presenti nel blog: "; echo $record['TotalePost'];
}

La funzione SUM

Supponiamo invece di voler conoscere il numero totale dei commenti ma senza operare sulla tabella Commenti: vogliamo utilizzare un campo NumCommenti della tabella Post in cui avremo inserito il numero di commenti per ogni singolo post. In questo caso ci sarà di aiuto la funzione SUM, che, come si può intuire dal nome, esegue la somma dei valori dei record. Supponiamo di avere quattro post: il primo ha dodici commenti, il secondo cinque, il terzo nove e il quarto quindici per un totale di quarantuno commenti.

La sintassi è del tutto simile a quella di COUNT. Invochiamo SUM subito dopo il comando SELECT, tra parentesi indichiamo il campo che ci interessa (ovvero il campo i cui valori saranno sommati tra di loro), diamo un nome al risultato e selezioniamo la tabella:

$query2 = "SELECT SUM(NumCommenti) AS TotaleCommenti FROM Post";
$risultato2 = mysql_query($query2);
while ($record2 = mysql_fetch_array($risultato2, MYSQL_ASSOC)) {
echo "Totale commenti presenti nel blog: "; echo $record2['TotaleCommenti'];
}

La funzione AVG

A questo punto potrebbe essere interessante sapere qual è il numero medio di commenti ai post del nostro blog (nel nostro caso è 10,25). Abbiamo anche una funzione per conoscere la media: si tratta di AVG (dall’inglese “average” che significa “media”) e il meccanismo è identico a quello di SUM. Vediamo:

$query3 = "SELECT AVG(NumCommenti) AS MediaCommenti FROM Post";
$risultato3 = mysql_query($query3);
while ($record3 = mysql_fetch_array($risultato3, MYSQL_ASSOC)) {
echo "Media commenti ai post: "; echo $record3['MediaCommenti'];
}

Le funzioni MAX e MIN

Non è cambiato niente, se non la funzione invocata subito dopo il comando SELECT. Potremmo poi voler conoscere qual è il numero dei commenti del post con il maggior numero di commenti e al contrario qual è il numero di commenti del post con il minor numero di commenti. Per compiere queste due operazioni abbiamo le funzioni MAX e MIN, e anche in questi due casi il meccanismo è simile a quello delle funzioni che abbiamo appena visto. Diamo un’occhiata a MAX:

$query4 = "SELECT MAX(NumCommenti) AS Massimo FROM Post";
$risultato4 = mysql_query($query4);
while ($record4 = mysql_fetch_array($risultato4, MYSQL_ASSOC)) {
echo "Numero commenti massimo: "; echo $record4['Massimo'];
}

E adesso MIN:

$query5 = "SELECT MIN(NumCommenti) AS Minimo FROM Post";
$risultato5 = mysql_query($query5);
while ($record5 = mysql_fetch_array($risultato5, MYSQL_ASSOC)) {
echo "Numero commenti minimo: "; echo $record5['Minimo'];
}

Le query annidate

Ma cosa dovremmo fare se volessimo sapere qual è il post con il maggior numero di commenti (e quindi non solo qual è il numero di commenti del post con il maggior numero di commenti)? Dobbiamo ricorrere a una query annidata, detta anche “subquery”: le query annidate sono interrogazioni che si trovano all’interno di altre interrogazioni. Il caso che prendiamo in esame noi è il più semplice: una interrogazione viene posta come condizione della clausola WHERE. Vediamo come funziona:

$query6 = "SELECT Titolo FROM Post WHERE NumCommenti = (SELECT MAX(NumCommenti) FROM Post)";
$risultato6 = mysql_query($query6);

Fino al WHERE quindi niente di strano: dopo l’uguale però inseriamo un nuovo comando SELECT, che dovrà estrarre il numero massimo di commenti presenti in un post. La query “più grande” estrarrà quindi il titolo il cui numero di commenti sarà uguale al massimo numero di commenti per un post presenti nel nostro database. Stampiamo poi molto semplicemente così:

while ($record6 = mysql_fetch_array($risultato6, MYSQL_ASSOC)) {
echo "Post con il maggior numero di commenti: "; echo $record6['Titolo'];
}

Ripetiamo la stessa cosa anche per conoscere il post con il minor numero di commenti. Possiamo poi creare dei comandi SELECT che estraggono informazioni dai risultati di altri comandi SELECT, come in questo caso:

$query = "SELECT * FROM (SELECT * FROM Post WHERE Id > 5) AS PrimaSelect WHERE NumCommenti > 6";
$risultato = mysql_query($query);

Che è una complicazione inutile in quanto avremmo ottenuto lo stesso risultato con un solo comando SELECT, ma è utile per capire il meccanismo delle query annidate. In questo caso selezioniamo tutti i risultati tratti a loro volta dai risultati di una prima selezione, che dovrà obbligatoriamente essere nominata (AS PrimaSelect), altrimenti la query non funzionerà e ci sarà un errore. La prima selezione, quella interna, estrae tutti i record dalla tabella Post che hanno un id maggiore di 5, e da questa selezione, il comando SELECT principale estrae i post che hanno più di sei commenti.

L’esercizio di oggi

Vi lascio come sempre con un esercizio: create una query che esegua la somma di tutti i commenti presenti nel database escludendo però il post con il maggior numero di commenti. Alla prossima!