openstamanager/src/Auth.php

482 lines
14 KiB
PHP
Raw Normal View History

<?php
2020-09-07 15:04:06 +02:00
/*
* OpenSTAManager: il software gestionale open source per l'assistenza tecnica e la fatturazione
2021-01-20 15:08:51 +01:00
* Copyright (C) DevCode s.r.l.
2020-09-07 15:04:06 +02:00
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
2019-07-25 17:20:24 +02:00
use API\Response as API;
use Models\User;
/**
* Classe per la gestione delle utenze.
*
* @since 2.3
*/
class Auth extends \Util\Singleton
{
/** @var array Stati previsti dal sistema di autenticazione */
protected static $status = [
'success' => [
'code' => 1,
'message' => 'Login riuscito!',
],
'failed' => [
'code' => 0,
'message' => 'Autenticazione fallita!',
],
'disabled' => [
'code' => 2,
'message' => 'Utente non abilitato!',
],
'unauthorized' => [
2018-11-22 15:34:44 +01:00
'code' => 5,
'message' => "L'utente non ha nessun permesso impostato!",
],
];
/** @var array Opzioni di sicurezza relative all'hashing delle password */
2018-07-08 16:18:44 +02:00
protected static $password_options = [
'algorithm' => PASSWORD_BCRYPT,
'options' => [],
];
2018-06-26 16:33:15 +02:00
/** @var array Opzioni per la protezione contro attacchi brute-force */
2018-07-08 16:18:44 +02:00
protected static $brute_options = [
'attemps' => 3,
'timeout' => 180,
];
2017-09-04 10:43:22 +02:00
/** @var bool Informazioni riguardanti la condizione brute-force */
protected static $is_brute;
/** @var array Informazioni riguardanti l'utente autenticato */
protected $user;
2018-07-08 16:18:44 +02:00
/** @var string Stato del tentativo di accesso */
protected $current_status;
2018-06-26 16:33:15 +02:00
/** @var string|null Nome del primo modulo su cui l'utente ha permessi di navigazione */
protected $first_module;
protected function __construct()
{
2018-09-20 12:05:22 +02:00
$database = database();
if ($database->isInstalled()) {
// Controllo dell'accesso da API
2019-07-25 17:20:24 +02:00
if (API::isAPIRequest()) {
$token = API::getRequest()['token'];
$user = $database->fetchArray('SELECT `id_utente` FROM `zz_tokens` WHERE `enabled` = 1 AND `token` = :token', [
':token' => $token,
]);
2018-05-03 17:29:10 +02:00
$id = !empty($user) ? $user[0]['id_utente'] : null;
}
// Controllo sulla sessione attiva
elseif (!empty($_SESSION['id_utente'])) {
$id = $_SESSION['id_utente'];
}
if (!empty($id)) {
$this->identifyUser($id);
}
$this->saveToSession();
}
}
/**
* Effettua un tentativo di accesso con le credenziali fornite.
*
* @param string $username
* @param string $password
*
* @return bool
*/
public function attempt($username, $password)
{
session_regenerate_id();
// Controllo sulla disponibilità dell'accesso (brute-forcing non in corso)
if (self::isBrute()) {
return false;
}
2018-09-20 12:05:22 +02:00
$database = database();
$log = [];
2018-06-26 16:33:15 +02:00
$log['username'] = $username;
$log['ip'] = get_client_ip();
2018-07-08 16:18:44 +02:00
$status = 'failed';
$users = $database->fetchArray('SELECT id, password, enabled FROM zz_users WHERE username = :username LIMIT 1', [
':username' => $username,
]);
if (!empty($users)) {
$user = $users[0];
if (!empty($user['enabled'])) {
$this->identifyUser($user['id']);
$module = $this->getFirstModule();
if (
$this->isAuthenticated() &&
$this->password_check($password, $user['password'], $user['id']) &&
!empty($module)
) {
// Accesso completato
$log['id_utente'] = $this->user->id;
2018-07-08 16:18:44 +02:00
$status = 'success';
// Salvataggio nella sessione
$this->saveToSession();
} else {
if (empty($module)) {
2018-07-08 16:18:44 +02:00
$status = 'unauthorized';
}
// Logout automatico
$this->destory();
}
} else {
2018-07-08 16:18:44 +02:00
$status = 'disabled';
}
}
2018-07-08 16:18:44 +02:00
// Salvataggio dello stato corrente
$log['stato'] = self::getStatus()[$status]['code'];
$this->current_status = $status;
// Salvataggio del tentativo nel database
$database->insert('zz_logs', $log);
return $this->isAuthenticated();
}
/**
* Controlla se l'utente è autenticato.
*
* @return bool
*/
public function isAuthenticated()
{
return !empty($this->user);
}
/**
* Controlla se l'utente appartiene al gruppo degli Amministratori.
*
* @return bool
*/
public function isAdmin()
{
return $this->isAuthenticated() && !empty($this->user->is_admin);
}
/**
* Restituisce le informazioni riguardanti l'utente autenticato.
*
* @return User
*/
public function getUser()
{
return $this->user;
}
2018-07-08 16:18:44 +02:00
/**
* Restituisce lo stato corrente.
*
* @return string
*/
public function getCurrentStatus()
{
return $this->current_status;
}
/**
* Restituisce il token di accesso all'API per l'utente autenticato.
*
* @return string
*/
public function getToken()
{
$token = null;
if ($this->isAuthenticated()) {
$user = self::user();
2020-02-23 14:21:49 +01:00
$tokens = $user->getApiTokens();
$token = $tokens[0]['token'];
}
return $token;
}
/**
* Distrugge le informazioni riguardanti l'utente autenticato, forzando il logout.
*/
public function destory()
{
if ($this->isAuthenticated() || !empty($_SESSION['id_utente'])) {
$this->user = [];
$this->first_module = null;
session_unset();
session_regenerate_id();
2019-07-25 17:20:24 +02:00
if (!API::isAPIRequest()) {
2018-07-27 12:17:17 +02:00
flash()->clearMessages();
}
}
}
/**
* Restituisce il nome del primo modulo navigabile dall'utente autenticato.
*
2018-06-26 16:33:15 +02:00
* @return string|null
*/
public function getFirstModule()
{
if (empty($this->first_module)) {
$parameters = [];
$query = 'SELECT id FROM zz_modules WHERE enabled = 1';
if (!$this->isAdmin()) {
$query .= " AND id IN (SELECT idmodule FROM zz_permissions WHERE idgruppo = (SELECT id FROM zz_groups WHERE nome = :group) AND permessi IN ('r', 'rw'))";
$parameters[':group'] = $this->getUser()['gruppo'];
}
2018-09-20 12:05:22 +02:00
$database = database();
$results = $database->fetchArray($query." AND options != '' AND options != 'menu' AND options IS NOT NULL ORDER BY `order` ASC", $parameters);
if (!empty($results)) {
$module = null;
2018-07-09 10:44:54 +02:00
$first = setting('Prima pagina');
if (!in_array($first, array_column($results, 'id'))) {
$module = $results[0]['id'];
} else {
$module = $first;
}
$this->first_module = $module;
}
}
return $this->first_module;
}
/**
* Restituisce l'hashing della password per la relativa memorizzazione nel database.
*
* @param string $password
*
2018-06-26 16:33:15 +02:00
* @return string|bool
*/
public static function hashPassword($password)
{
2018-07-08 16:18:44 +02:00
return password_hash($password, self::$password_options['algorithm'], self::$password_options['options']);
}
/**
* Restituisce l'elenco degli stati del sistema di autenticazione.
*
* @return array
*/
public static function getStatus()
{
return self::$status;
}
/**
* Controlla se l'utente è autenticato.
*
* @return bool
*/
public static function check()
{
return self::getInstance()->isAuthenticated();
}
/**
* Controlla se l'utente appartiene al gruppo degli Amministratori.
*
* @return bool
*/
public static function admin()
{
return self::getInstance()->isAdmin();
}
/**
* Restituisce le informazioni riguardanti l'utente autenticato.
*
* @return User
*/
public static function user()
{
return self::getInstance()->getUser();
}
/**
* Distrugge le informazioni riguardanti l'utente autenticato, forzando il logout.
*/
public static function logout()
{
return self::getInstance()->destory();
}
/**
* Restituisce il nome del primo modulo navigabile dall'utente autenticato.
*
* @return string
*/
public static function firstModule()
{
return self::getInstance()->getFirstModule();
}
/**
2017-09-04 10:43:22 +02:00
* Controlla se sono in corso molti tentativi di accesso (possibile brute-forcing in corso).
*
* @return bool
*/
public static function isBrute()
{
2018-09-20 12:05:22 +02:00
$database = database();
2018-07-03 15:05:27 +02:00
if (!$database->isInstalled() || !$database->tableExists('zz_logs') || Update::isUpdateAvailable()) {
2017-09-04 10:43:22 +02:00
return false;
}
if (!isset(self::$is_brute)) {
$results = $database->fetchArray('SELECT COUNT(*) AS tot FROM zz_logs WHERE ip = :ip AND stato = :state AND DATE_ADD(created_at, INTERVAL :timeout SECOND) >= NOW()', [
':ip' => get_client_ip(),
':state' => self::getStatus()['failed']['code'],
':timeout' => self::$brute_options['timeout'],
]);
2017-09-04 11:53:30 +02:00
2018-07-08 16:18:44 +02:00
self::$is_brute = $results[0]['tot'] > self::$brute_options['attemps'];
2017-09-04 10:43:22 +02:00
}
2017-09-04 10:43:22 +02:00
return self::$is_brute;
}
/**
2017-09-04 10:43:22 +02:00
* Restituisce il tempo di attesa rimanente per lo sblocco automatico dellla protezione contro attacchi brute-force.
*
* @return int
*/
public static function getBruteTimeout()
{
2017-09-20 15:10:23 +02:00
if (!self::isBrute()) {
2017-09-04 10:43:22 +02:00
return 0;
}
2018-09-20 12:05:22 +02:00
$database = database();
$results = $database->fetchArray('SELECT TIME_TO_SEC(TIMEDIFF(DATE_ADD(created_at, INTERVAL '.self::$brute_options['timeout'].' SECOND), NOW())) AS diff FROM zz_logs WHERE ip = :ip AND stato = :state AND DATE_ADD(created_at, INTERVAL :timeout SECOND) >= NOW() ORDER BY created_at DESC LIMIT 1', [
':ip' => get_client_ip(),
':state' => self::getStatus()['failed']['code'],
':timeout' => self::$brute_options['timeout'],
]);
return intval($results[0]['diff']);
}
2018-12-29 12:03:22 +01:00
/**
* Controlla la corrispondenza delle password ed eventualmente effettua un rehashing.
*
* @param string $password
* @param string $hash
* @param int $user_id
*/
protected function password_check($password, $hash, $user_id)
{
$result = false;
$rehash = false;
// Retrocompatibilità
if ($hash == md5($password)) {
$rehash = true;
$result = true;
}
// Nuova versione
if (password_verify($password, $hash)) {
$rehash = password_needs_rehash($hash, self::$password_options['algorithm'], self::$password_options['options']);
$result = true;
}
// Controllo in automatico per futuri cambiamenti dell'algoritmo di password
if ($rehash) {
$database = database();
$database->update('zz_users', ['password' => self::hashPassword($password)], ['id' => $user_id]);
}
return $result;
}
/**
* Memorizza le informazioni riguardanti l'utente all'interno della sessione.
*/
protected function saveToSession()
{
if (session_status() == PHP_SESSION_ACTIVE && $this->isAuthenticated()) {
// Retrocompatibilità
foreach ($this->user as $key => $value) {
$_SESSION[$key] = $value;
}
$_SESSION['id_utente'] = $this->user->id;
$identifier = md5($_SESSION['id_utente'].$_SERVER['HTTP_USER_AGENT']);
if ((empty($_SESSION['last_active']) || time() < $_SESSION['last_active'] + (60 * 60)) && (empty($_SESSION['identifier']) || $_SESSION['identifier'] == $identifier)) {
$_SESSION['last_active'] = time();
$_SESSION['identifier'] = $identifier;
}
}
}
/**
* Identifica l'utente interessato dall'autenticazione.
*
* @param int $user_id
*/
protected function identifyUser($user_id)
{
$database = database();
try {
$results = $database->fetchArray('SELECT id, idanagrafica, username, (SELECT nome FROM zz_groups WHERE zz_groups.id = zz_users.idgruppo) AS gruppo FROM zz_users WHERE id = :user_id AND enabled = 1 LIMIT 1', [
':user_id' => $user_id,
]);
2018-12-29 12:03:22 +01:00
if (!empty($results)) {
$this->user = User::with('group')->find($user_id);
2019-07-25 17:20:24 +02:00
2019-07-25 18:05:47 +02:00
if (!API::isAPIRequest() && !empty($this->user->reset_token)) {
2019-07-25 17:20:24 +02:00
$this->user->reset_token = null;
$this->user->save();
}
2018-12-29 12:03:22 +01:00
}
} catch (PDOException $e) {
$this->destory();
}
}
}