php caricamento file Archivi

7 Ottobre 2020 Nessun commento

[PHP] Classe in PHP per autenticazione utenti con LDAP

Immaginiamo di avere un server Windows con dominio chiamato torregatti.local. Possiamo effettuare l’autenticazione tramite PHP utilizzando il metodo LDAP (Lightweight Directory Access Protocol).

Anzitutto assicuriamoci di avere attiva la libreria LDAP all’interno del PHP.

Su Linux possiamo installare la libreria, per esempio con Ubuntu digitiamo:

apt-get install php-ldap

1	apt-get install php-ldap

Mentre su Windows, per esempio usando XAMPP, sarà sufficiente attivare l’estensione nel file php.ini, rimuovendo il commento alla seguente riga:

;extension=php_ldap.dll

1	;extension=php_ldap.dll

Che diventerà quindi:

extension=php_ldap.dll

1	extension=php_ldap.dll

Fatto questo possiamo creare una classe che si occupi del processo di login.

Prima di procedere vediamo il minimo indispensabile per effettuare il processo:

$conn = ldap_connect("ldap://192.168.56.1", 389 );

if( $conn ) {
	
	ldap_set_option($conn, LDAP_OPT_PROTOCOL_VERSION, 3);
	ldap_set_option($conn, LDAP_OPT_REFERRALS, 0);
	
	$bind = @ldap_bind($conn, "TORREGATTI\\ADMINISTRATOR", "Password123");
	
	if( $bind ) {
		ldap_close( $conn );
		echo "connesso!";
	} else {
		die("Errore autenticazione");
	}

} else {
	die("Errore di connessione");
}

$conn = ldap_connect("ldap://192.168.56.1", 389 );

if( $conn ) {

ldap_set_option($conn, LDAP_OPT_PROTOCOL_VERSION, 3);

ldap_set_option($conn, LDAP_OPT_REFERRALS, 0);

$bind = @ldap_bind($conn, "TORREGATTI\\ADMINISTRATOR", "Password123");

if( $bind ) {

ldap_close( $conn );

echo "connesso!";

} else {

die("Errore autenticazione");

}

} else {

die("Errore di connessione");

}

In questo caso stiamo entrando con l’utente amministratore TORREGATTI\ADMINISTRATOR che ha per password Password123

Ricordiamoci che nel nostro esempio il dominio è torregatti.local e il server si trova sull’indirizzo 192.168.56.1. Ci stiamo collegando con una connessione non sicura, usando il protocollo ldap anziché ldaps (richiederebbe la porta 636).

Possiamo creare una classe che effettui tutto il processo di login e ci permetta di verificare l’autenticazione mediante i cookie, nella maniera seguente:

class LDAPLogin {
	
	private $server;
	private $username;
	private $password;
	private $ssl;
	private $key;
	
	const ERR_NO_ERROR = 0x0;
	const ERR_CONNECTION = 0x1;
	const ERR_PROTOCOL = 0x2;
	const ERR_REFERRALS = 0x3;
	const ERR_SERVER = 0x4;
	const ERR_USERNAME = 0x5;
	const ERR_AUTH = 0x6;
	const ERR_KEY = 0x7;
	
	private $status = 0x0;
	private $cookie_username = "ldap_username";
	private $cookie_hash = "ldap_hash";
	private $cookie_expire = 30;
	
	function __construct( $server = NULL, $user = NULL, $pass = NULL , $ssl = false , $key = null ) {
		$this->setServer( $server );
		$this->setUsername( $user );
		$this->setPassword( $pass );
		$this->setSSL( $ssl );
		$this->setKey( $key );
	}
	
	function setCookies( $username , $hash , $expire ) {
		$this->cookie_username = $username;
		$this->cookie_hash = $hash;
		$this->cookie_expire = $expire;
	}
	
	function setServer( $server ) {
		$this->server = $server;
		return $this;
	}
	
	function setUsername( $username ) {
		$this->username = $username;
		return $this;
	}
	
	function setPassword( $password ) {
		$this->password = $password;
		return $this;
	}
	
	function setSSL( $ssl = true ) {
		$this->ssl = $ssl;
		return $this;
	}
	
	function setKey( $key ) {
		$this->key = $key;
		return $this;
	}
	
	function authenticate() {
		
		if( !$this->server ) $this->status = self::ERR_SERVER;
		if( !$this->username ) $this->status = self::ERR_USERNAME;
		if( !$this->key ) $this->status = self::ERR_KEY;
		
		if( $this->status == self::ERR_NO_ERROR ) {
			
			$connString = ($this->ssl?"ldaps":"ldap") . "://" . $this->server;
			$connPort = $this->ssl ? 636 : 389;
			
			$conn = ldap_connect( $connString , $connPort );
			
			if( $conn ) {
				
				ldap_set_option($conn, LDAP_OPT_PROTOCOL_VERSION, 3) or $this->status = self::ERR_PROTOCOL;
				ldap_set_option($conn, LDAP_OPT_REFERRALS, 0) or $this->status = self::ERR_REFERRALS;
				
				if( $this->status == self::ERR_NO_ERROR ) {
					
					$bind = @ldap_bind($conn, $this->username, $this->password);
				
					if( $bind ) {
						
						ldap_close( $conn );
						
						setcookie( $this->cookie_username , $this->username , time() + 3600 * 24 * $this->cookie_expire );
						
						setcookie( $this->cookie_hash , hash("sha512",$this->username . $this->key) , time() + 3600 * 24 * $this->cookie_expire );
						
					} else {
						
						$this->status = self::ERR_AUTH;
						
					}
	
				}
				
			} else {
				$this->status = self::ERR_CONNECTION;
			}
		
		}
		
		return $this;
		
	}
	
	function getError() {
		return $this->status;
	}
	
	function isAuth() {
		return $_COOKIE[$this->cookie_hash] == hash("sha512",$_COOKIE[$this->cookie_username] . $this->key);
	}
	
	function logout() {
		setcookie( $this->cookie_username , NULL , 0 );
		setcookie( $this->cookie_hash , NULL , 0 );
		return $this;
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

class LDAPLogin {

private $server;

private $username;

private $password;

private $ssl;

private $key;

const ERR_NO_ERROR = 0x0;

const ERR_CONNECTION = 0x1;

const ERR_PROTOCOL = 0x2;

const ERR_REFERRALS = 0x3;

const ERR_SERVER = 0x4;

const ERR_USERNAME = 0x5;

const ERR_AUTH = 0x6;

const ERR_KEY = 0x7;

private $status = 0x0;

private $cookie_username = "ldap_username";

private $cookie_hash = "ldap_hash";

private $cookie_expire = 30;

function __construct( $server = NULL, $user = NULL, $pass = NULL , $ssl = false , $key = null ) {

$this->setServer( $server );

$this->setUsername( $user );

$this->setPassword( $pass );

$this->setSSL( $ssl );

$this->setKey( $key );

}

function setCookies( $username , $hash , $expire ) {

$this->cookie_username = $username;

$this->cookie_hash = $hash;

$this->cookie_expire = $expire;

}

function setServer( $server ) {

$this->server = $server;

return $this;

}

function setUsername( $username ) {

$this->username = $username;

return $this;

}

function setPassword( $password ) {

$this->password = $password;

return $this;

}

function setSSL( $ssl = true ) {

$this->ssl = $ssl;

return $this;

}

function setKey( $key ) {

$this->key = $key;

return $this;

}

function authenticate() {

if( !$this->server ) $this->status = self::ERR_SERVER;

if( !$this->username ) $this->status = self::ERR_USERNAME;

if( !$this->key ) $this->status = self::ERR_KEY;

if( $this->status == self::ERR_NO_ERROR ) {

$connString = ($this->ssl?"ldaps":"ldap") . "://" . $this->server;

$connPort = $this->ssl ? 636 : 389;

$conn = ldap_connect( $connString , $connPort );

if( $conn ) {

ldap_set_option($conn, LDAP_OPT_PROTOCOL_VERSION, 3) or $this->status = self::ERR_PROTOCOL;

ldap_set_option($conn, LDAP_OPT_REFERRALS, 0) or $this->status = self::ERR_REFERRALS;

if( $this->status == self::ERR_NO_ERROR ) {

$bind = @ldap_bind($conn, $this->username, $this->password);

if( $bind ) {

ldap_close( $conn );

setcookie( $this->cookie_username , $this->username , time() + 3600 * 24 * $this->cookie_expire );

setcookie( $this->cookie_hash , hash("sha512",$this->username . $this->key) , time() + 3600 * 24 * $this->cookie_expire );

} else {

$this->status = self::ERR_AUTH;

}

} else {

$this->status = self::ERR_CONNECTION;

}

return $this;

}

function getError() {

return $this->status;

}

function isAuth() {

return $_COOKIE[$this->cookie_hash] == hash("sha512",$_COOKIE[$this->cookie_username] . $this->key);

}

function logout() {

setcookie( $this->cookie_username , NULL , 0 );

setcookie( $this->cookie_hash , NULL , 0 );

return $this;

}

Per effettuare il login sarà sufficiente configurare la classe nella maniera seguente:

$ldap = (new LDAPLogin( "192.168.56.1" , "TORREGATTI\\ADMINISTRATOR" , "Password123" ))
		->setKey("0bb74b7aa9cadf13d2c05332744ebc8ee5b09ef9a53cb67ea0b3adabde4f598b");
		
if( $ldap->authenticate()->getError() == LDAPLogin::ERR_NO_ERROR ) {
	// autenticazione avvenuta
}

$ldap = (new LDAPLogin( "192.168.56.1" , "TORREGATTI\\ADMINISTRATOR" , "Password123" ))

->setKey("0bb74b7aa9cadf13d2c05332744ebc8ee5b09ef9a53cb67ea0b3adabde4f598b");

if( $ldap->authenticate()->getError() == LDAPLogin::ERR_NO_ERROR ) {

// autenticazione avvenuta

}

Abbiamo aggiunto una nostra chiave casuale e segreta che verrà utilizzata per la costruzione del hash nei cookie.

Per verificare che l’utente sia autenticato, una volta terminato il processo di login, sarà sufficiente richiamare:

if( $ldap->isAuth() ) {
	// ok, utente autenticato
}

if( $ldap->isAuth() ) {

// ok, utente autenticato

}

Per effettuare il logout sarà sufficiente richiamare:

$ldap->logout();

1	$ldap->logout();

E’ molto probabile che l’inserimento di username e password lo si voglia fare dopo aver costruito l’oggetto per l’autenticazione LDAP, in tal caso si potrebbe procedere nella maniera seguente:

$ldap = (new LDAPLogin("192.168.56.1"))->setKey("0bb74b7aa9cadf13d2c05332744ebc8ee5b09ef9a53cb67ea0b3adabde4f598b");

$ldap->setUsername( "TORREGATTI\\ADMINISTRATOR" )->setPassword( "Password123" );
		
if( $ldap->authenticate()->getError() == LDAPLogin::ERR_NO_ERROR ) {
	echo "autenticazione avvenuta!";
}

$ldap = (new LDAPLogin("192.168.56.1"))->setKey("0bb74b7aa9cadf13d2c05332744ebc8ee5b09ef9a53cb67ea0b3adabde4f598b");

$ldap->setUsername( "TORREGATTI\\ADMINISTRATOR" )->setPassword( "Password123" );

if( $ldap->authenticate()->getError() == LDAPLogin::ERR_NO_ERROR ) {

echo "autenticazione avvenuta!";

}

Con il metodo getError() è possibile verificare gli altri eventuali errori durante il processo di autenticazione, sfruttando le costanti della classe.

Vedi articolo

18 Febbraio 2020 1 commento

[php] Configurare php.ini per l’upload dei file

L’upload dei file, nel PHP, dipende da diverse parametri, alcuni diretti ed altri indiretti, configurabili nel php.ini.

Anzitutto individuiamo il file di configurazione in uso. Per farlo è sufficiente utilizzare, in una pagina php, l’istruzione phpinfo();

Otterremo un output simile a questo:

Nel mio caso specifico, sotto Plesk, il file si trova in /opt/plesk/php/7.3/etc/php.ini

In una configurazione predefinita di Ubuntu Server 19.10 avremmo qualcosa di simile invece:

Il percorso del file php.ini in questo caso è /etc/php/7.3/apache2/php.ini

Detto questo modifichiamo il suddetto file individuando le seguenti istruzioni:

upload_max_filesize

Questo è il parametro principale, quello che riguarda la massima dimensione di un file in upload. Di solito si trova impostato a 2M oppure 8M. Se volessimo consentire un upload di 20MB dovremmo metterlo a: upload_max_filesize = 20M

post_max_size

Questo parametro indica la massima dimensione dell’intestazione di POST, nel caso specifico se volessimo aumentare il valore a 20MB dovremmo digitare: post_max_size = 20M

Attenzione, perché il POST contiene non solo il file in upload, ma anche altre istruzioni. Con una dimensione di 20MB significa che il massimo file caricabile sarà probabilmente attorno ai 19MB, perché una parte del post è utilizzata per inviare anche altre istruzioni, per quanto in genere ridotte e piccole. Un’istruzione più corretta potrebbe essere: post_max_size = 21M

max_file_uploads

Questo parametro definisce invece il numero massimo di file caricabili. Di predefinito è impostato su 20, quindi si potranno caricare al massimo 20 file in una volta. Se volessimo consentire il caricamento simultaneo di 50 file, potremmo impostarlo come: max_file_uploads = 50

A queste, che sono le istruzioni specificatamente dedicate al caricamento dei file, se ne aggiungono altre che sono strettamente connesse.

memory_limit

Il limite di memoria allocabile dal processo di PHP per l’esecuzione delle operazioni. Nel caso di grossi caricamenti questo limite potrebbe dover essere aumentato. Di solito il valore è 128M, ovvero 128MB, se volessimo aumentare il valore a 256MB dovremmo scrivere: memory_limit = 256MB

max_execution_time

Il massimo tempo di esecuzione del processo PHP. Di predefinito è impostato su 30 secondi, il che vuol dire che se l’upload impiega più tempo il PHP chiuderà l’operazione allo scadere del limite del tempo. Possiamo aumentare questo valore, per esempio su 10 minuti (60 secondi x 10), digitando: max_execution_time = 600

max_input_time

Come prima, anche questo parametro concorre col precedente. Se il tempo massimo di esecuzione è inferiore a questo parametro il processo di input verrà comunque interrotto; viceversa se questo valore è basso l’input verrà interrotto secondo quest’ultimo parametro. Se vogliamo dare anche qui 10 minuti per il massimo tempo di input digitiamo: max_input_time = 600

Riassumiamo infine tutte quante le variabili assieme:

upload_max_filesize = 20M
post_max_size = 21M
max_file_uploads = 50
memory_limit = 256MB
max_execution_time = 600
max_input_time = 600

upload_max_filesize = 20M

post_max_size = 21M

max_file_uploads = 50

memory_limit = 256MB

max_execution_time = 600

max_input_time = 600

Vedi articolo