Quando si realizza una chat in PHP o altro linguaggio è necessario prevedere una funzione che effettui la pulizia dei messaggi inoltrati dagli utenti.
Tale codice dovrà intercettare le parole ritenute non legali e oscurarle in fase di visualizzazione.

A tal proposito realizzeremo una funzione in PHP che chiameremo semplicemente filtro; la quale ammetterà come parametro d’input una stringa di testo, contenente appunto il messaggio da filtrare.
La nostra funzione sostituirà le parole incriminate con degli asterischi, lasciando però inalterali il primo e l’ultimo carattere che la compongono.
Se ad esempio volessimo filtrare dal messaggio tutte le ricorrenze della parola gratis, vedremmo al suo posto la parola: g****s.
Vediamo quindi il codice della funzione filtro:

<?php
  $parole = "gratis,sesso,acquista,visitami";

  function filtro($testo){
      global $parole;
      $app = split(',',$parole);
      for($i=0; $i<count($app); $i++){
          if(stripos($testo,$app[$i])!==false){
              $sostituta = substr($app[$i],0,1);
              for($j=1; $j<strlen($app[$i])-1; $j++){
                   $sostituta=$sostituta.'*';
              }
              $sostituta = $sostituta.substr($app[$i],-1);
              $testo = str_ireplace($app[$i],$sostituta,$testo);
          }
      }
      return $testo;
  }
?>

La funzione utilizza essenzialmente cinque funzioni PHP per la manipolazione delle stringhe:

- split
- stripos
- strlen
- substr
- str_ireplace

Da notare innanzitutto la presenza di una variabile parole definita a livello globale, che conterrà appunto la sequenza di parole, separate da virgola(,), da filtrare.
Per personalizzare il codice è sufficiente aggiungere le stringhe da filtrare nella variabile parole.
Tornando alla funzione, vediamo per grandi linee le operazioni che essa effettua sul testo in input:

1. Preleva tutte le parole da filtrare (split)
2. Cerca ciascuna parola nel messaggio di input (stripos)
3. Realizza una parola sostitutiva calcolata sulla lunghezza dell’originale (strlen)
4. La parola sostitutiva mantiene il carattere iniziale e finale dell’originale (substr)
5. La parola incriminata viene sostituita (str_ireplace)

Infine il messaggio viene restituito pulito.
La funzione, una volta salvata in un file separato(ad esempio filtro.php) verrà così invocata:

// Richiamo alla funzione
require('filtro.php');

// Chiamata alla funzione su testo $messaggio
$stringa_pulita = filtro($messaggio);

La funzione può tornare molto utile anche qualora si desiderasse eliminare dal messaggio link o url poco graditi. Basterà, come già detto sopra, aggiungere le stringhe da controllare alla variabile globale $parole, prestando attenzione a separare ciascuna da una virgola.

Cliccando qui è possibile vedere in azione il codice.

Cliccando qui è possibile scaricare il codice.

In questo articolo realizzeremo una classe PHP per gestire la cache delle nostre pagine web.
L’obiettivo sarà quello di mettere in cache una pagina intera o parte di essa per essere poi riutilizzata ad una successiva richiesta che rientri in un tempo limite da noi preventivamente scelto. Questa tecnica, sapientemente utilizzata, evita l’esecuzione di script “pesanti” che vengono richiamati frequentemente, soprattutto qualora i dati rappresentati non subiscono variazioni nel breve termine.
La classe phpCache avrà i seguenti metodi:

• start() – Per avviare il processo di cache della pagina
• stop() – Per concludere il processo di cache della pagina
• paginaCorrente() – Per prelevare il nome della pagina corrente

Inoltre il costruttore della classe acquisisce due parametri:

• Il periodo di validità di un file in cache (espresso in minuti)
• Il percorso relativo per la cartella di cache

In fondo all’articolo è possibile provare e scaricare il codice completo.

Vediamo subito il codice della classe PhpCache:

<?php
class PhpCache{
	var $durata;
	var $cache_url;
	var $nome_pagina;

	/*
                Costruttore - i parametri sono:
	   i minuti di vita della cache e il percorso della cartella di cache
	*/
	function PhpCache($minuti,$percorso){
		$this->durata = intval($minuti) * 60;
		$this->cache_url = $percorso;
	}

	// Funzione di start della cache
	function start(){
		// Start dell'output buffer
		ob_start();
		// prelevo il nome della pagina attuale e creo il percorso nella cache
		$this->nome_pagina = $this->cache_url."".$this->paginaCorrente();
		/* se il file esiste in cache e la versione è ancora valida rispetto al tempo di vita
		   allora includo il file in cache e non vado oltre
		*/
		if (file_exists($this->nome_pagina) && ((time() - $this->durata) < filemtime($this->nome_pagina)))
		{
			include($this->nome_pagina);
			exit;
		}
	}

             // Funzione di stop della cache
	function stop(){
		// Scriviamo il contenuto del buffer nel file di cache
		$file = fopen($this->nome_pagina, 'w');
		fwrite($file, ob_get_contents());
		fclose($file);
		// Chiudiamo il buffer
		ob_end_flush();
	}

	// Metodo che restituisce il nome della pagina [eventuali parametri compresi]
	function paginaCorrente() {
		$pagina_corrente = $_SERVER["SERVER_NAME"].$_SERVER['REQUEST_URI'];
		$pezzi = explode("/",$pagina_corrente);
		$pagina_corrente = $pezzi[count($pezzi)-1];
		return $pagina_corrente;
	}
}
?>

Per capire come funziona questa classe possiamo innanzitutto dire che:
tutto il codice compreso tra la chiamata al metodo start() e la chiamata al metodo stop() viene messo in cache

Lo start() ha innanzitutto il compito di aprire un buffer di output (ob_start()) in modo da convogliare tutto il codice di echo e html in una unica variabile, inoltre verificare se la pagina richiesta sia già presente in cache e sia ancora valida:

ob_start();
$this->nome_pagina = $this->cache_url."".$this->paginaCorrente();
if (file_exists($this->nome_pagina) && ((time() - $this->durata) < filemtime($this->nome_pagina)))
{
	include($this->nome_pagina);
	exit;
}

A tale scopo è di supporto il metodo paginaCorrente() che restituisce il nome della pagina richiesta, compreso di eventuali parametri in GET.
Il metodo di stop() ha il compito di salvare il contenuto del buffer nel file in cache, in modo tale che ad una nuova apertura della pagina il metodo di start() possa verificarne la presenza.

La classe va utilizzata quindi nel seguente modo:

require_once('phpCache.php');

$cache = new PhpCache(10,'cache/');
$cache->start();

// segue il codice php/html
// ...

$cache->stop();

Nel costruttore abbiamo, ad esempio, scelto di rendere validi i file in cache per 10 minuti e salvare quest’ultimi in una cartella denominata cache/.

In conclusione è possibile scaricare e provare il codice. A tal proposito si consiglia di verificare il salvataggio in cache della pagina d’esempio controllando l’orario che questa stampa a video.

Cliccando qui è possibile vedere in azione il codice.

Cliccando qui è possibile scaricare il codice.

Dopo il cifrario di Cesare e Vigenère continuiamo l’excursus sulle tecniche di cifratura che hanno contraddistinto la storia e l’evoluzione di questa disciplina.
Leon Battista Alberti, vissuto a metà del ’400, fu una delle figure artistiche più poliedriche del Rinascimento. Scrittore, architetto e matematico, fu anche un celebrato crittografo per gli standard della sua epoca, ed inventò un metodo per generare messaggi criptati con l’aiuto di un apparecchio, il disco cifrante.
Il disco cifrante è il primo sistema di cifratura polialfabetica, ancor prima del “troppo” famoso cifrario di Vigenère rispetto cui è estremamente più potente.
L’apparecchio si compone di due dischi concentrici, rotanti uno rispetto all’altro, contenenti un alfabeto ordinato per il chiaro (testo da cifrare) e un alfabeto mischiato per il cifrato (testo risultante). Permette la sostituzione polialfabetica con periodo irregolare. Lo scorrimento degli alfabeti avviene per mezzo di lettere chiave inserite nel corpo del crittogramma.
Nonostante la potenza di questo algoritmo il suo utilizzo è molto semplice e intuitivo. Prendiamo ad esempio in considerazione i due alfabeti:

Il mittente e il destinatario si accordano su un indice di cifratura che dovrà rimanere segreto. Quest’indice è essenzialmente una lettera dell’alfabeto ordinato.
In base a questo indice si effettuerà la cifratura/decifratura, sottoponendo di volta in volta una lettera del disco interno e mobile.
In relazione agli alfabeti visti sopra, se ad esempio la lettera “indice” fosse la “A” e si decidesse di cifrare con lettera “chiave” uguale a “s” si otterrebbe il seguente disco cifrante (abbiamo ruotato di n posizioni l’alfabeto mischiato):

A questo punto cifriamo la frase: CIAO MAMMA

CIAO MAMMA = Scgsy bsbbs

Sostituendo a ciascuna lettera in chiaro del disco superiore, la sottostante lettera cifrata del disco inferiore si ottiene il testo cifrato. Da notare la prima lettera in maiuscolo (la R) che indica appunto la lettera chiave di cifratura utile al destinatario per interpretare il messaggio.
Dopo aver cifrato alcune lettere si inserisce una nuova lettera maiuscola che indica il cambio delle lettera chiave, ruotando appunto il disco mobile e ottenendo una nuova cifratura.
Il cifrario di Alberti è quindi a tutti gli effetti una sostituzione polialfabetica con alfabeti mischiati cambiati saltuariamente in modo segreto.

Veniamo ora al nostro codice PHP che ci permette di implementare tale cifrario.
Realizzeremo una classe denominata Alberti che farà uso di due array contenenti il primo l’alfabeto ordinato e in maiuscolo e il secondo un alfabeto mischiato in minuscolo.
Nel costruttore della classe acquisiamo due lettera:

• La lettera indice dell’alfabeto ordinato
• La lettera chiave dell’alfabeto mischiato

Infine forniremo tre metodi:

• Stampa del disco ottenuto
• Cifratura
• Decifratura

In fondo all’articolo è possibile provare e scaricare il codice completo.

Vediamo il codice della classe:

<?php
class Alberti{
	var $fisso = array('A','B','C','D','E','F','G','H','I','J','K','L','M', 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z');
	var $disco = array('t','d','v','h','a','r','s','z','c','p','e','w', 'i','x','g','u','k','m','b','l','y','f','j','o','n','q');
	var $posizione;
	function Alberti($base, $partenza){
		// Scegliamo la lettera di base che andrà in posizione 0
		$this->posizione = array_search(strtoupper($base),$this->fisso);
		$app1 = array_slice($this->fisso,0,$this->posizione);
		$app2 = array_slice($this->fisso,$this->posizione);
		$this->fisso = array_merge($app2,$app1);
		// Ruotiamo il disco interno in base alla lettera di partenza che andrà in posizione 0
		$rotazione = array_search(strtolower($partenza),$this->disco);
		$app1 = array_slice($this->disco,0,$rotazione);
		$app2 = array_slice($this->disco,$rotazione);
		$this->disco = array_merge($app2,$app1);
	}

	function stampa(){
		echo "<table border='1'><tr><td>Disco esterno</td>";
		for($i=0; $i<count($this->fisso); $i++){
			echo "<td>".$this->fisso[$i]."</td>";
		}
		echo "</tr><tr><td>Disco interno</td>";
		for($i=0; $i<count($this->disco); $i++){
			echo "<td>".$this->disco[$i]."</td>";
		}
		echo "</tr></table>";
	}

	function cifratura($testo){
		$txt_cifrato = strtoupper($this->disco[0])."";
		for($i=0; $i<strlen($testo); $i++){
			$chr_t = substr($testo,$i,1);
			if(in_array(strtoupper($chr_t),$this->fisso)){
				$pos = array_search(strtoupper($chr_t),$this->fisso);
				$txt_cifrato = $txt_cifrato.$this->disco[$pos];
			}else{
				$txt_cifrato = $txt_cifrato.$chr_t;
			}
		}
		return $txt_cifrato;
	}

	function decifratura($cifrato){
		$txt_chiaro = "";
		for($i=1; $i<strlen($cifrato); $i++){
			$chr_t = substr($cifrato,$i,1);
			if(in_array(strtolower($chr_t),$this->disco)){
				$pos = array_search(strtolower($chr_t),$this->disco);
				$txt_chiaro = $txt_chiaro.$this->fisso[$pos];
			}else{
				$txt_chiaro = $txt_chiaro.$chr_t;
			}
		}
		return $txt_chiaro;
	}
}
?>

L’alfabeto del disco mobile (quello mischiato) è stato scelto in modo del tutto arbitrario, è possibile modificarlo per ottenere cifrature sempre diverse.
Nel costruttore, in relazione alle due lettere acquisite, vengono ruotati gli alfabeti in modo tale da far coincidere in posizione 0 (zero) le due lettere scelte per la cifratura.
A tale scopo viene utilizzato una funzione php molto utile, array_slice, che ci permette di tagliare un array ottenendo un sottoarray:

$app1 = array_slice($this->disco,0,$rotazione);
$app2 = array_slice($this->disco,$rotazione);

Una volta riuniti i due sottoarray in ordine inverso si ottine la rotazione dell’alfabeto.
Grazie a questi due array la cifratura e decifratura si limita ad una sostituzione di lettere in base alla loro posizione.

La sintassi per utilizzare questa classe è la seguente:

<?php
require_once 'alberti.php';
$alberti = new Alberti($lettera_indice,$lettera_chiave);
$alberti->stampa();
$txt_cifrato = $alberti->cifratura($testo);
$txt_decifrato = $alberti->decifratura($txt_cifrato);
?>

Alcune considerazioni finali sono d’obbligo; l’algoritmo implementato non tiene conto di alcune varianti presenti nella cifratura di Alberti, riguardanti ad esempio le lettere doppie e i numeri.
Per ottenere una sostituzione polialfabetica basta poi invocare la classe più volte cambiando di conseguenza la lettera chiave dell’alfabeto mischiato.

All’interno della cartella contenente il codice completo sono presenti i seguenti file:

• alberti.php (la classe vista sopra)
• test.php (lo script che effettua la cifratura/decifratura)
• index.html (un form per il test di coppie chiave-testo in chiaro)

Cliccando qui è possibile vedere in azione il codice.

Cliccando qui è possibile scaricare il codice.

In due articoli precedenti abbiamo analizzato, grazie a PHP, due algoritmi di cifratura: Cesare e Blowfish.
Il primo al solo scopo didattico-storico, mentre il secondo pienamente utilizzabile all’interno delle nostre applicazioni, viste le sue potenzialità e il grado di sicurezza che fornisce.

Il cifrario di Vigenère è il più semplice dei cifrari polialfabetici. Si basa sull’uso di un versetto (chiave) per controllare l’alternanza degli alfabeti di sostituzione.
Il metodo si può considerare una generalizzazione del cifrario di Cesare; invece di spostare sempre dello stesso numero di posti la lettera da cifrare, questa viene spostata di un numero di posti variabile ma ripetuto, determinato in base ad una parola chiave e da scrivere ripetutamente sotto il messaggio, carattere per carattere:

Il testo cifrato si ottiene spostando la lettera chiara di un numero fisso di caratteri, pari al numero ordinale della lettera corrispondente della chiave.
Per semplificare la cifratura/decifratura Vigenère propose una matrice quadrata (26 X 26) composta da alfabeti ordinati e spostati.
Nel codice che andremo a sviluppare utilizzeremo questa versione “classica” dell’algoritmo, difatti realizzeremo la matrice e la cifratura/decifratura verrà eseguita su di essa.
In fondo all’articolo è possibile provare e scaricare il codice completo.

Passiamo quindi al codice della classe che chiameremo vigenere.php.
La classe si comporrà dei seguenti metodi:

• Costruttore per la realizzazione della matrice (tavola di Vigenère)
• Metodo di cifratura
• Metodo di decifratura
• Metodo che stampa a video la tavola di Vigenère

Ecco il codice PHP:

<?php
class Vigenere{
	var $alfabeto = array('A','B','C','D','E','F','G','H','I','J','K','L','M','N', 'O','P','Q','R','S','T','U','V','W','X','Y','Z');
	var $matrice;
	var $chiave;

	// Il costruttore imposta la chiave e realizza la matrice
	function Vigenere($chiave){
		$this->chiave = str_replace(array(" ",".",",",";"),"", $chiave);
		$app1 = array();
		$app2 = array();
		$alfabeto_app = array();
		for($i=0; $i<26; $i++){
			$k=0;
			$app1 = array_slice($this->alfabeto,0,$i);
			$app2 = array_slice($this->alfabeto,$i);
			$this->matrice[$i] = array_merge($app2,$app1);
		}
	}

	// Metodo che stampa la matrice
	function stampaTavola(){
		echo "<table border='1' cellpadding='1' cellspacing='0'>
		<tr><td rowspan='27' width='50px' align='center'>T<br>E<br>S<br>T<br>O<br> <br>I<br>N<br> <br>C<br>H<br>I<br>A<br>R<br>O<br></td><td colspan='26' align='center' height='50px'>CHIAVE</td></tr>";
		for($i=0; $i<26; $i++){
			echo "<tr>";
			for($j=0; $j<26; $j++){
				echo "<td align='center'>".$this->matrice[$i][$j]."</td>";
			}
			echo "</tr>";
		}
		echo "</table>";
	}

	// Metodo per la cifratura
	function cifratura($testo){
		$txt_cifrato = "";
		$l_chiave = strlen($this->chiave);
		$k = 0;
		for($i=0; $i<strlen($testo); $i++){
			$chr_t = substr($testo,$i,1);
			$chr_c = substr($this->chiave,$k,1);

			if(in_array(strtoupper($chr_t),$this->alfabeto) && in_array(strtoupper($chr_c),$this->alfabeto)){
				$x = array_search(strtoupper($chr_t),$this->alfabeto);
				$y = array_search(strtoupper($chr_c),$this->alfabeto);
				$txt_cifrato = $txt_cifrato.$this->matrice[$x][$y];
				$k++;
			}else{
				$txt_cifrato = $txt_cifrato.strtoupper($chr_t);
			}
			if($k==$l_chiave) $k = 0;
		}
		return $txt_cifrato;
	}

	// Metodo per la decifratura
	function decifratura($testo){
		$txt_decifrato = "";
		$l_chiave = strlen($this->chiave);
		$k = 0;
		for($i=0; $i<strlen($testo); $i++){
			$chr_t = substr($testo,$i,1);
			$chr_c = substr($this->chiave,$k,1);
			if(in_array(strtoupper($chr_t),$this->alfabeto) && in_array(strtoupper($chr_c),$this->alfabeto)){
				$colonna = array_search(strtoupper($chr_c),$this->alfabeto);
				$riga = 0;
				for($c=0; $c<26; $c++){
					if($this->matrice[$c][$colonna]==$chr_t){
						$riga = $c;
						break;
					}
				}
				$txt_decifrato = $txt_decifrato.$this->matrice[$riga][0];
				$k++;
			}else{
				$txt_decifrato = $txt_decifrato.$chr_t;
			}
			if($k==$l_chiave) $k = 0;
		}
		return $txt_decifrato;
	}
}
?>

Utilizzando un array contenete l’alfabeto, realizzeremo la matrice semplicemente tagliando ad ogni riga l’alfabeto in due parti, grazie alla funzione array_slice, per poi ricomporlo in maniera inversa.
Grazie a questa matrice i metodi cifratura e decifratura risultano abbastanza semplici:
- cicliamo lettera per lettera sul testo in chiaro e sulla chiave
- per ogni coppia di lettere (chiaro-chiave) verifichiamo le posizioni nell’alfabeto
- le coordinate x e y ottenute individueranno la lettera cifrata nella matrice
Il cuore del codice di cifratura è composto essenzialmente dalle tre righe:

$x = array_search(strtoupper($chr_t),$this->alfabeto);
$y = array_search(strtoupper($chr_c),$this->alfabeto);
$txt_cifrato = $txt_cifrato.$this->matrice[$x][$y];

Per la decifratura il procedimento è lo stesso, richiede solo una ricerca differente basata sulle colonne identificate dalle lettere che compongono la chiave.
Infine è presente un metodo denominato stampaTavola che visualizza a video la matrice favorendo la verifica manuale del processo di cifratura/decifratura.

La classe va così richiamata:

<?php
require_once 'vigenere.php';

$vigenere = new Vigenere($chiave);
$vigenere->stampaTavola();
$txt_cifrato = $vigenere->cifratura($testo);
$txt_decifrato = $vigenere->decifratura($txt_cifrato);
?>

All’interno della cartella contenente il codice completo sono presenti i seguenti file:

• vigenere.php (la classe vista sopra)
• test.php (lo script che effettua la cifratura/decifratura)
• index.html (un form per il test di coppie chiave-testo in chiaro)

Cliccando qui è possibile vedere in azione il codice.

Cliccando qui è possibile scaricare il codice.

In un articolo precedente si è vista la crittografia con algoritmo Blowfish in PHP.
Esistono però molteplici algoritmi di cifratura, alcuni utilizzati durante le guerre mondiali, altri ancora più antichi utilizzati nel lontano medioevo.
Uno degli algoritmi più antichi di cui si abbia traccia storica è il “Cifrario di Cesare”. È un cifrario a sostituzione monoalfabetica in cui ogni lettera del testo in chiaro è sostituita nel testo cifrato dalla lettera che si trova un certo numero di posizioni dopo nell’alfabeto. Questi tipi di cifrari sono detti anche cifrari a sostituzione: la sostituzione avviene lettera per lettera, scorrendo il testo dall’inizio alla fine.
Grazie allo studio di alcuni storici sappiamo che Giulio Cesare utilizzava in genere una chiave di 3 per la cifratura.
In generale quindi la seguente frase in chiaro:
CIAO MAMMA
grazie al Cifrario di Cesare con chiave 3, diventa:
FLDR PDPPD

Realizzeremo quindi una classe PHP che chiameremo Cesare; implementeremo la logica di cifratura e decifratura con un valore della chiave arbitrario acquisito in fase di istanziamento.
In fondo all’articolo è possibile provare e scaricare il codice completo.
Vediamo innanzitutto la classe cesare.php:

<?php
class Cesare{
	var $alfabeto = array('A','B','C','D','E','F','G','H','I','J','K','L','M','N', 'O','P','Q','R','S','T','U','V','W','X','Y','Z');
	var $chiave;

	// La chiave è un valore numerico da 1 a 25
	function Cesare($chiave){
		if($chiave>25){
			$this->chiave = $chiave % 26;
		}else{
			$this->chiave = $chiave;
		}
	}

	// Metodo per sostituzione lettera in fase di cifratura
	function sostituisciLettera($lettera){
		if(in_array(strtoupper($lettera),$this->alfabeto)){
			$posizione = array_search(strtoupper($lettera),$this->alfabeto);
			return strtolower($this->alfabeto[($posizione+$this->chiave) % 26]);
		}else{
			return $lettera;
		}
	}

	// Metodo per sostituzione lettera in fase di decifratura
	function ripristinaLettera($lettera){
		if(in_array(strtoupper($lettera),$this->alfabeto)){
			$posizione = array_search(strtoupper($lettera),$this->alfabeto);
			if(($posizione - $this->chiave) >= 0){
				return strtolower($this->alfabeto[($posizione - $this->chiave)]);
			}else{
				return strtolower($this->alfabeto[(count($this->alfabeto) + ($posizione - $this->chiave))]);
			}
		}else{
			return $lettera;
		}
	}

	// Metodo per cifratura di un testo in chiaro
	function cifratura($testo){
		$txt_cifrato = "";
		for($i=0; $i<strlen($testo); $i++){
			$carattere = substr($testo,$i,1);
			$carattere_cifrato = $this->sostituisciLettera($carattere);
			$txt_cifrato = $txt_cifrato.$carattere_cifrato;
		}
		return $txt_cifrato;
	}

	// Metodo per decifratura di un testo cifrato
	function decifratura($testo){
		$txt_chiaro = "";
		for($i=0; $i<strlen($testo); $i++){
			$carattere = substr($testo,$i,1);
			$carattere_chiaro = $this->ripristinaLettera($carattere);
			$txt_chiaro = $txt_chiaro.$carattere_chiaro;
		}
		return $txt_chiaro;
	}
}
?>

La classe fa uso di un array denominato alfabeto che contiene appunto le lettere dell’alfabeto. Il costruttore imposta il valore della chiave che sarà un valore compreso tra 0 e 25, tenendo comunque presente che una chiave uguale a 0 produrrà un testo cifrato uguale a quello in chiaro.
I metodi:
- sistituisciLettera
- ripristinaLettera
si occupano di sostituire un carattere con un altro in relazione al valore della chiave. Il primo metodo sarà utilizzato in fase di cifratura, sostituendo quindi una lettera con la successiva di n posizioni. Viceversa il metodo ripristinaLettera sarà utilizzato in fase di decifratura sostituendo la lettera in input con la precedente di n posizioni.
Infine i metodi cifratura e decifratura hanno il compito di scorrere il testo in chiaro o cifrato per convertire una lettera alla volta.

La classe va così invocata:

require_once 'cesare.php';

$cifrario = new Cesare($chiave);
$txt_cifrato = $cifrario->cifratura($testo);
$txt_chiaro = $cifrario->decifratura($txt_cifrato);

All’interno della cartella contenente il codice completo sono presenti i seguenti file:

• cesare.php (la classe vista sopra)
• test.php (lo script che effettua la cifratura/decifratura)
• index.html (un form per il test di coppie chiave-testo in chiaro)

Cliccando qui è possibile vedere in azione il codice.

Cliccando qui è possibile scaricare il codice.

In questo articolo vedremo come utilizzare l’algoritmo Blowfish per cifrare un testo in chiaro.
Innazitutto Blowfish è un algoritmo a chiave simmetrica a blocchi, ideato nel 1993 da Bruce Schneier e implementato in molti software di crittografia.
Quest’algoritmo utilizza varie tecniche tra le quali la rete Feistel, le S-box dipendenti da chiavi e funzioni F non invertibili che lo rendono, forse, l’algoritmo più sicuro attualmente disponibile. Le chiavi utilizzate sono di dimensioni variabili fino ad un massimo di 448 bit e i blocchi utilizzati per la cifratura sono di 64 bit. Non si conoscono al momento tecniche di attacco valide nei suoi confronti. E’ considerato uno degli algoritmi di cifratura a blocchi più veloce (risulta più veloce di DES e IDEA). Blowfish non è brevettato ed è di dominio pubblico.

Evitando di entrare nel cuore dell’algoritmo (troppo complesso per essere spiegato in questa sede), realizzeremo una classe php che inglobi l’algoritmo fornendoci essenzialmente solo i metodi che ci interessano:

• Impostare la chiave
• Cifrare un testo
• Decifrare un testo

Inoltre realizzeremo uno script di test e un form html per verificare il risultato finale.
Di seguito il codice della classe Crittografia:

<?php
// Richiamo il codice che implementa Blowfish
require_once('blowfish.php');

class Crittografia{
	var $chiave;
	var $blowfish;

	// Costruttore della classe Crittografia - prende in input la chiave in chiaro
	function Crittografia($stringa){
		$this->chiave = $stringa;
	}

	// Funzione di codifica di un testo in chiaro
	function cifratura($stringa){
		$this->blowfish = new Horde_Cipher_blowfish;
		$encrypt = '';
		$mod = strlen($stringa) % 8;
		if ($mod > 0) {
			$stringa .= str_repeat("\0", 8 - $mod);
		}
		foreach (str_split( $stringa, 8 ) as $chunk){
			$encrypt .= $this->blowfish->encryptBlock($chunk, $this->getChiave());
		}
		return base64_encode($encrypt);
	}

	// Funzione di decodifica di un testo cifrato
	function decifratura($stringa){
		$this->blowfish = new Horde_Cipher_blowfish;
		$decrypt = '';
		$data = base64_decode($stringa);
		foreach (str_split( $data, 8 ) as $chunk){
			$decrypt .= $this->blowfish->decryptBlock($chunk, $this->getChiave());
		}
		return trim($decrypt);
	}

	// Funzione per restituzione della chiave
	function getChiave(){
		return $this->chiave;
	}
}
?>

La classe Crittografia farà uso dei metodi dell’algoritmo Blowfish, quindi il codice inizia con il require della classe.
Il costruttore della classe è molto semplice, infatti acquisisce in input una stringa che sarà la chiave utilizzata per la cifratura/decifratura.
Di seguito i metodi fondamentali, cifratura e decifratura. Entrambi prendono come parametro una stringa e restituiscono una nuova stringa che nel primo caso sarà il testo cifrato e viceversa nel secondo caso sarà il testo in chiaro.
All’interno di entrambi i metodi viene istanziato l’oggetto Horde_Cipher_blowfish e viene suddivisa la stringa di input in gruppi di 8 caratteri per effettuare la cifratura/decifratura un blocco per volta.
Vediamo quindi in che modo richiamare la classe Crittografia:

<?php
// Richiamo la classe
require_once 'crittografia.php';

// Istanzio l'oggetto Crittografia con chiave $chiave
$blowfish = new Crittografia($chiave);

// Cifro un testo $txt
$txt_cifrato = $blowfish->cifratura($txt);

// Decifro il testo ottenuto dalla cifratura
$txt_originale = $blowfish->decifratura($txt_cifrato);
?>

All’interno della cartella contenente il codice completo sono presenti i seguenti file:

• blowfish.php (l’algoritmo di cifratura)
• crittografia.php (la classe che inbloba l’algoritmo blowfish)
• test.php (lo script che effettua la cifratura/decifratura)
• index.html (un form per il test di coppie chiave-testo in chiaro)

Cliccando qui è possibile vedere in azione il codice.

Cliccando qui è possibile scaricare il codice.

In questo articolo vedremo come realizzare una pagina web che permetta l’ascolto, tramite il plugin di Windows Media Player, di una playlist in formato m3u in modalità shuffle cioè in ordine casuale di brani.
Più precisamente lo script php realizzerà una playlist diversa per ogni chiamata della pagina, in modo tale che ogni utente connesso ascolterà la stessa playlist ma in un ordine differente di esecuzione. Potremo, con le dovute differenze, creare una sorta di webradio.

Innanzittutto è necessario creare un file con estensione .m3u che conterrà semplicemente la lista degli url degli mp3 da eseguire.
Ad esempio l’ipotetico file playlist.m3u:

http://www.miosito.com/musica/canzone_0.mp3

http://www.miosito.com/musica/canzone_1.mp3

http://www.miosito.com/musica/canzone_2.mp3

http://www.miosito.com/musica/canzone_3.mp3

http://www.miosito.com/musica/canzone_4.mp3

Tale file sarà locato nel nostro spazio web ad esempio nella cartella /stream.

Andiamo ora a vedere il codice php che implementerà la funzione shuffle:

<?php
// url del file m3u originale
$file_playlist = "/stream/playlist.m3u";

// url del file m3u casuale, utilizzo valore random per differenziarlo
$file_playlist_shuffle = "/stream/playlist_".rand (10,9999).".m3u";

// scarico la playlist in un array, ogni elemento è un url
$lines = file($file_playlist);

// ordino in modo casuale gli elementi dell'array
shuffle($lines);

// realizzo il file m3u con la playlist casuale
$var=fopen($file_playlist_shuffle,"w");
for($i=0; $i<count($lines); $i++){
    fwrite($var, $lines[$i]);
}
fclose($var);
?>

Lo script appena visto verrà inserito all’interno della nostra pagina web prima dell’aperura del tag html. Una volta conslusa l’esecuzione del codice php, avremo nella nostra cartella /stream il file originale “playlist.m3u” e un file tipo “playlist_153.m3u” che conterrà la playlist in un ordine diverso. (il numero 153 è solo di esempio)

Il player audio andrà quindi a leggere il flusso audio dal secondo file appena realizzato.
Vediamo quindi il codice completo player.php:

<?php
// -- INIZIO configurazione script
$url_sito = "http://www.donatantonio.it/";
$file_playlist = "stream/playlist.m3u";
$file_playlist_shuffle = "stream/playlist_".rand (10,9999).".m3u";
// -- FINE configurazione

$lines = file($file_playlist);
shuffle($lines);
$var=fopen($file_playlist_shuffle,"w");
for($i=0; $i<count($lines); $i++){
    fwrite($var, $lines[$i]);
}
fclose($var);
?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="author" content="Fabio Donatantonio" />
<title>Media Player - Shuffle Mode</title>
</head>
<body>
<h1>Stai ascoltando la playlist</h1>
<!-- Codice lettore Media Player -->
<object id="mediaplayer" classid="clsid:6bf52a52-394a-11d3-b153-00c04f79faa6"
width="300" height="300"
codebase = "http://activex.microsoft.com/activex/controls/mplayer/en/nsmp2inf.cab#Version=5,1,52,701">
<param name="url" value="<?php echo $url_sito.$file_playlist_shuffle;?>" />
<param name="autostart" value="1" />
<param name="showcontrols" value="1" />
<param name="stretchtofit" value="0" />
<param name="enablecontextmenu" value="0" />
<param name="ShowStatusBar" value="1" />
<param name="src" value="<?php echo $url_sito.$file_playlist_shuffle;?>" />
<embed id="mediaplayer" type="application/x-mplayer2" width="300" height="300" src="<?php echo $url_sito.$file_playlist_shuffle;?>" showstatusbar="1" enablecontextmenu="0" stretchtofit="0" showcontrols="1" autostart="1" url="<?php echo $url_sito.$file_playlist_shuffle;?>">
</embed></object>
<!-- Fine codice lettore Media Player -->
</body>
</html>

Una volta personalizzato e caricato il file sul nostro spazio web e richiamata la pagina dal browser ascolteremo la playlist in ordine casuale.

Clicca qui per scaricare lo script completo.

Alcune osservazioni e idee in conclusione:
1 – La pagina richiede Media Player come player audio
2 – La cartella contenente le playlist andrebbe “svuotata” regolarmente in virtù delle connessioni alla pagina. Ciò magari è implementabile sempre con php.
3 – Con un pò di pazienza e fantasia si potrebbe utilizzare l’array degli url mp3 per realizzare un player audio implementato in javascript.

In questo articolo vedremo come realizzare una simpatica mappa personalizzata seguendo lo stile grafico di Google Maps.
Quello di cui abbiamo bisogno sono:

• Una mappa in formato JPG
• Un paio di simboli grafici come in Google Maps

Nel nostro esempio utilizzeremo come mappa:

Come simboli invece quelli classici presenti in Google Maps:

Il nostro obiettivo sarà essenzialmente quello di realizzare una mappa nella quale posizioneremo i simboli in luoghi da noi scelti.
A tale scopo utilizzeremo le librerie GD di PHP, ed in poche righe di codice raggiungeremo il nostro obiettivo. (N.B. E’ necessario avere installata e configurata la libreria GD)
Apporremo ad esempio su Napoli, Salerno e Sapri i tre simboli, non prima di aver individuato le coordinate sulla cartina. In ultimo salveremo la mappa risultante e la stamperemo a video.

<?php
// carico l'immagine da usare come mappa
$campania = imageCreateFromJpeg('campania.jpg');

// carico i simboli in stile Google Maps
$rosso = imageCreateFromPng('rosso.png');
$giallo = imageCreateFromPng('giallo.png');
$verde = imageCreateFromPng('verde.png');

// appongo i simboli in 3 posizioni diverse della cartina
// imageCopy(la mappa, il simbolo da apporre, coordinata x mappa, coordinata y mappa, coordinata x simbolo, coordinata y simbolo, larghezza simbolo, altezza simbolo);

// simbolo rosso su Salerno
imageCopy($campania,$rosso,203,151,0,0,15,25);

// simbolo verde su Napoli
imageCopy($campania,$verde,124,115,0,0,15,25);

// simbolo giallo su Sapri
imageCopy($campania,$giallo,333,272,0,0,15,25);

// la cartina è pronta per essere creata e memorizzata
imageJpeg($campania,"campania_maps.jpg",100);

// stampa a video
echo "<img src='campania_maps.jpg' alt='La mia mappa'/>";
?>

Ecco il risultato dello script:

In poche linee di codice abbiamo creato la nostra prima mappa. Con un pizzico di fantasia sarà possibile realizzare mappe più complesse o semplicemente aggiungere elementi ad immagini di base.

Clicca qui per scaricare lo script e le immagini.

Con questo semplice script che di seguito viene proposto possiamo memorizzare in un file di testo le informazioni essensiali che riguardano gli utenti connessi ad un sito o ad una applicazione web.
Possiamo ad esempio memorizzare per ogni connessione le seguenti informazioni:

• Data e ora
• Indirizzo IP del Client
• Indirizzo di provenienza Client
• Altre info come Browser e SO

Vediamo quindi lo script che ci permette di implementare il logger.

<?php
$provenienza = $_SERVER['HTTP_REFERER'];
$data = date("d-m-y"); $ora = date("G:i:s");
$ip = $_SERVER['REMOTE_ADDR'];
$altre_info = $_SERVER['HTTP_USER_AGENT'];

$testo = "------\n\r".$data." ".$ora;
$testo = $testo."\n\rIndirizzo IP: ".$ip;
$testo = $testo."\n\rProvenienza connessione: ".$provenienza;
$testo = $testo."\n\rAltre info: ".$altre_info;
$testo = $testo."\n\r------\n\r";

$var=fopen("logger.txt","a");
fwrite($var,$testo);
fclose($var);
?>

Questo script va posizionato in cima ad una pagina php o comunque di regola nella pagina index del sito.

Le utilissime librerie GD di PHP permettono di disegnare e modificare immagini, ben più difficile è realizzare grafici partendo da una serie di dati o da un database.
La libreria PChart permette di fare tutto ciò con estrema semplicità e tutto in poche linee di codice, realizzeremo grafici a barre, a torta e lineari utilizzando al meglio le librerie GD.

E’ innanzitutto necessario scaricare PChart da qui.

Vediamo ora come realizzare un semplice grafico utilizzando la libreria.

<?php
// importiamo la libreria
include("pChart/pData.class");
include("pChart/pChart.class");

// carico i valori da rappresentare graficamente - utilizzo 2 array
$DataSet = new pData;
$DataSet->AddPoint(array(0,3,6,2,3,1,4,8,10,6,3,5,6),"Serie1");
$DataSet->AddPoint(array(0,1,3,4,1,3,7,5,6,7,3,8,5),"Serie2");
$DataSet->AddAllSeries();

// imposto la legenda
$DataSet->SetSerieName("La prima serie","Serie1");
$DataSet->SetSerieName("La seconda serie","Serie2");  

// imposto un nome agli assi cartesiani
$DataSet->SetXAxisName("Mesi");
$DataSet->SetYAxisName("Valore raggiunto");

$Test = new pChart(500,250);

// imposto l'aspetto del grafico
$Test->setFixedScale(0,11);
$Test->setFontProperties("Fonts/tahoma.ttf",8);
$Test->setGraphArea(50,40,500,210);
$Test->drawFilledRoundedRectangle(7,7,543,243,5,240,240,240);
$Test->drawRoundedRectangle(5,5,550,250,5,400,400,400);
$Test->drawGraphArea(255,255,255,TRUE);
$Test->drawScale($DataSet->GetData(),$DataSet->GetDataDescription(), SCALE_NORMAL,150,150,150,TRUE,0,0);
$Test->drawGrid(10,TRUE,230,230,230,50);

// imposto il tipo di grafico - lineare, curvilineo, torta ecc...
$Test->setColorPalette(0,0,255,0);
$Test->setLineStyle(1.5);
$Test->drawTreshold(0,143,55,72,TRUE,TRUE);
$Test->drawCubicCurve($DataSet->GetData(),$DataSet->GetDataDescription());
$Test->drawPlotGraph($DataSet->GetData(),$DataSet->GetDataDescription(), 1.5,1.5,0,0,255);

// imposto titolo e legenda del grafico e quindi lo realizzo
$Test->drawLegend(55,40,$DataSet->GetDataDescription(),255,255,255);
$Test->setFontProperties("Fonts/tahoma.ttf",10);
$Test->drawTitle(100,22,"Il primo grafico",0,0,100);
$Test->Render("grafico.png");
?>

Quello che abbiamo realizzato è un semplice grafico introduttivo. Studiando la documentazione di PChart si potranno realizzare grafici complessi e graficamente accattivanti. Si potrà ad esempio prelevare i dati da un file excel, personalizzare gli assi cartesiani, i colori e le scale e sbizzarrirsi a creare grafici tridimensionali.

Ecco il risultato del nostro script: