Una strada per innalzare la sicurezza della propria applicazione e dell’intero sistema è quella di fornire all’utente una password creata dal sistema seguendo un determinato criterio con l’intento di rispettare quelli che sono i requisiti minimi per una password sicura. Vogliamo quindi utilizzare:

• un insieme di caratteri alfabetici maiuscoli e minuscoli
• un insieme di numeri

La classe che vediamo di seguito è molto semplice prende 2 valori in input length e numbers che indicano rispettivamente la lunghezza totale della password ed il numero di cifre intendiamo inserire nella stringa che andiamo a generare. E’ costituita dal costruttore che si occupa di creare l’oggetto al momento dell’istanziazione della classe e dal metodo getPassword() che si occupa dell’elaborazione vera e propria dell’input per la generazione dell’output: la password.

Il costruttore si occupa appunto di costruire l’oggetto facendo le dovute verifiche sui tipi, di cui abbiamo parlato in un post precedente, ed agendo in base alla situazione che si verifica.

public function __construct($length, $numbers) {
if (!is_int($length) || !is_int($numbers)) {
die("randoPassword() richiede argomenti di tipo intero\n");
}
if ($length < $numbers) {
die("length deve essere maggiore di numbers\n");
}
$this->length = $length;
$this->numbers = $numbers;
}


Come anticipato il metodo getPassword() si occupa del lavoro vero e proprio, vediamo quindi come si comporta. Innanzitutto andiamo ad inserire nell’array random_char un numero di caratteri alfabetici presi da $alphabet pari al valore di $length meno il valore di $numbers. In secondo luogo aggiungiamo dei caratteri numerici presi casualmente tra 0 e 9 fino a raggiungere una numerosità dell’array random_char pari a $length. A questo punto avremmo già una password composta da lettere (maiuscole e minuscole) con n=$numbers caratteri numerici in coda. Per rendere le password meno ripetitive ho deciso di rimischiare i valori interni all’array con la comoda funzione shuffle prima di eseguire il return del metodo.

public function getPassword() {
$a = 0;
while ($a < ($this->length - $this->numbers)) {
$random_char[$a] = $this->alphabet[rand(0,51)];
$a++;
}

while ($a < $this->length) {
$random_char[$a] = rand(0,9);
$a++;
}

shuffle($random_char);

$a = 0;
while ($a < ($this->length + $this->numbers)) {
$password .= $random_char[$a];
$a++;
}
return $password;
}


Come sempre potete scaricare il codice completo della classe randomPassword.class.php in modo da studiarlo attentamente (l’indentazione lì è corretta) e provarlo ma soprattutto modificarlo e perfezionarlo in base a quello che vi ha insegnato la vostra esperienza.

Usate i commenti qui sotto per esprimere il vostro parere, i vostri dubbi, le vostre critiche e i suggerimenti che riteniate possano essere utili a me ed ai lettori.

CREDITS
L’immagine utilizzata nell’articolo proviene da Flickr, dove è stata pubblicata da Imagined Reality con licenza Creative Commons.

Questo non significa certo che PHP non rispetti il concetto di tipo, ogni valore che possiamo assegnare ad una variabile ha un tipo che possiamo verificare attraverso delle utili funzioni per la gestione delle variabili. Avremo quindi la possibilità di utilizzare is_bool(), is_integer(), is_string()…per verificare il tipo di una variabile passata come parametro, in caso positivo il valore di ritorno sarà true.

Effettuare il controllo del tipo di una varibile torna particolarmente importante quando si ha a che fare con gli argomenti di metodi e funzioni, casi in cui bisogna prestare particolare attenzione al codice che si scrive. Vediamo un esempio. Immaginiamo di estrarre delle informazioni di configurazione da un file XML, l’elemento <resolvedomains> specifica all’applicazione se provare o meno ad eseguire il reverse DNS di un IP.

<settings>
<resolvedomains>false</resolvedomains>
<settings>


La stringa “false” viene letta dall’appliccazione e passata ad un metodo chiamato outputAddress() che si occupa di visualizzare i dati di un determinato IP.

[php]
function outputAddresses($resolve) {
foreach($this->addresses as $address) {
print $address;
if ($resolve) {
print “(“. gethostbyaddr($address) .”)”;
}
print “\n”;
}
}
[/php]

Il metodo outputAddresses() non fa altro che iterare su un array di indirizzi IP mostrandoli uno ad uno, nel caso in cui $resolve sia true il metodo restituisce anche il dominio assieme all’IP. Vediamo una porzione di codice che potrebbe essere chiamata da questo metodo:

$settings = simplexml_load_file("settings.xml");
$manager = new AddressManager();
$manager->outputAddresses($settings->resolvedomains);

Questo codice non si comporta come ci si aspetterebbe: passando la stringa “false” al metodo outputAddress() trascuriamo l’assunzione implicita che il metodo fa riguardo all’argomento passato. Infatti il metodo si aspetta un valore di tipo booleano (true o false) ma la stringa “false” corrisponde al valore true in un test. Questo è dato dal fatto che PHP esegue un cast di una stringa non vuota al valore booleano true in un test if. Di conseguenza:

if ("false") {
//..
}


è equivalente a

if (true) {
//..
}

Esistono diverse strade per risolvere questo problema, quella più metodica e sicura richiede di modificare il metodo outputAddress() per fare in modo che sia pronto ad aspettarsi il corretto tipo di dato riferito all’argomento $resolv.

[php]
function outputAddresses($resolve) {
if (!is_bool($resolve)) {
die(“outputAddress() richiede un argomento di tipo booleano\n”);
}
}
[/php]

Un approccio di questo tipo obbliga chi utilizza il metodo a fornire l’argomento $resolv nel tipo di dato corretto evitando problemi di ogni sorta. Detto questo sta al programmatore considerare il potenziale impatto che l’utilizzo di tipi inaspettati potrebbe avere sulla propria applicazione. Non pensate di lasciare nulla al caso, chi userà le vostre classi non può leggere quello che avete in mente quando le realizzate quindi è consigliabile pensare sempre come i metodi che scrivete possano reagire alla “spazzatura” che potrebbero ricevere in input.