mirror of
https://github.com/nuxsmin/sysPass.git
synced 2026-03-03 23:24:07 +01:00
446 lines
16 KiB
PHP
446 lines
16 KiB
PHP
<?php
|
|
/**
|
|
* sysPass
|
|
*
|
|
* @author nuxsmin
|
|
* @link http://syspass.org
|
|
* @copyright 2012 Rubén Domínguez nuxsmin@syspass.org
|
|
*
|
|
* This file is part of sysPass.
|
|
*
|
|
* sysPass 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.
|
|
*
|
|
* sysPass 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 sysPass. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
defined('APP_ROOT') || die(_('No es posible acceder directamente a este archivo'));
|
|
|
|
class SP_Init {
|
|
// Associative array for autoloading. classname => filename
|
|
public static $CLASSPATH = array();
|
|
// The installation path on the server (e.g. /srv/www/syspass)
|
|
public static $SERVERROOT = '';
|
|
// The current request path relative to the sysPass root (e.g. files/index.php)
|
|
private static $SUBURI = '';
|
|
// The sysPass root path for http requests (e.g. syspass/)
|
|
public static $WEBROOT = '';
|
|
public static $LANG = '';
|
|
|
|
/**
|
|
* SPL autoload
|
|
*/
|
|
public static function autoload($classname){
|
|
$class = str_replace("sp_", '', strtolower($classname));;
|
|
$classfile = dirname(__FILE__)."/$class.class.php";
|
|
|
|
//error_log('Cargando clase: '.$classfile);
|
|
|
|
if (file_exists($classfile)) {
|
|
include_once ($classfile);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Inicialiar la aplicación
|
|
* @return none
|
|
*
|
|
* Esta función inicializa las variables de la aplicación y muestra la página
|
|
* según el estado en el que se encuentre.
|
|
*/
|
|
public static function init(){
|
|
// Registro del cargador de clases
|
|
spl_autoload_register(array('SP_Init','autoload'));
|
|
|
|
error_reporting(E_ALL | E_STRICT);
|
|
|
|
if (defined('DEBUG') && DEBUG) {
|
|
ini_set('display_errors', 1);
|
|
}
|
|
|
|
date_default_timezone_set('UTC');
|
|
|
|
// Intentar desactivar magic quotes.
|
|
if (get_magic_quotes_gpc()==1) {
|
|
ini_set('magic_quotes_runtime', 0);
|
|
}
|
|
|
|
// Copiar la cabecera http de autentificación para apache+php-fcgid
|
|
if (isset($_SERVER['HTTP_XAUTHORIZATION']) && !isset($_SERVER['HTTP_AUTHORIZATION'])) {
|
|
$_SERVER['HTTP_AUTHORIZATION'] = $_SERVER['HTTP_XAUTHORIZATION'];
|
|
}
|
|
|
|
// Establecer las cabeceras de autentificación para apache+php-cgi
|
|
if (isset($_SERVER['HTTP_AUTHORIZATION'])
|
|
&& preg_match('/Basic\s+(.*)$/i', $_SERVER['HTTP_AUTHORIZATION'], $matches)) {
|
|
list($name, $password) = explode(':', base64_decode($matches[1]), 2);
|
|
$_SERVER['PHP_AUTH_USER'] = strip_tags($name);
|
|
$_SERVER['PHP_AUTH_PW'] = strip_tags($password);
|
|
}
|
|
|
|
// Establecer las cabeceras de autentificación para que apache+php-cgi funcione si la variable es renombrada por apache
|
|
if (isset($_SERVER['REDIRECT_HTTP_AUTHORIZATION'])
|
|
&& preg_match('/Basic\s+(.*)$/i', $_SERVER['REDIRECT_HTTP_AUTHORIZATION'], $matches)) {
|
|
list($name, $password) = explode(':', base64_decode($matches[1]), 2);
|
|
$_SERVER['PHP_AUTH_USER'] = strip_tags($name);
|
|
$_SERVER['PHP_AUTH_PW'] = strip_tags($password);
|
|
}
|
|
|
|
self::setPaths();
|
|
|
|
// Establecer el modo debug si una sesión de xdebug está activa
|
|
if ( !defined('DEBUG') || !DEBUG ) {
|
|
if (isset($_COOKIE['XDEBUG_SESSION'])) {
|
|
define('DEBUG', true);
|
|
}
|
|
}
|
|
|
|
// Cargar el lenguaje
|
|
self::selectLang();
|
|
// Comprobar la configuración
|
|
self::checkConfig();
|
|
// Comprobar si está instalado
|
|
self::checkInstalled();
|
|
|
|
// Comprobar si la Base de datos existe
|
|
if ( ! db::checkDatabaseExist() ){
|
|
self::initError(_('Error en la verificación de la base de datos'));
|
|
}
|
|
|
|
// Comprobar si el modo mantenimiento está activado
|
|
self::checkMaintenanceMode();
|
|
// Comprobar la versión y actualizarla
|
|
self::checkVersion();
|
|
// Inicializar la sesión
|
|
self::initSession();
|
|
|
|
// Intentar establecer el tiempo de vida de la sesión en PHP
|
|
$sessionLifeTime = self::getSessionLifeTime();
|
|
@ini_set('gc_maxlifetime', (string)$sessionLifeTime);
|
|
|
|
if ( ! SP_Config::getValue("installed", false) ) {
|
|
$_SESSION['user_id'] = '';
|
|
}
|
|
|
|
if ( isset($_SERVER['PHP_AUTH_USER']) && isset($_SESSION['user_id'])
|
|
&& $_SERVER['PHP_AUTH_USER'] != $_SESSION['user_id']) {
|
|
self::logout();
|
|
}
|
|
|
|
// Manejar la redirección para usuarios logeados
|
|
if ( isset($_REQUEST['redirect_url']) && self::isLoggedIn() ) {
|
|
$location = 'index.php';
|
|
|
|
// Denegar la regirección si la URL contiene una @
|
|
// Esto previene redirecciones como ?redirect_url=:user@domain.com
|
|
if (strpos($location, '@') === FALSE) {
|
|
header('Location: ' . $location);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// El usuario está logado
|
|
if ( self::isLoggedIn() ) {
|
|
if (isset($_GET["logout"]) && $_GET["logout"]) {
|
|
self::logout();
|
|
header("Location: ".self::$WEBROOT.'/');
|
|
}
|
|
return;
|
|
} else {
|
|
// Si la petición es ajax, no hacer nada
|
|
if ( (isset($_POST['is_ajax']) || isset($_GET['is_ajax']) )
|
|
&& ($_POST['is_ajax'] || $_GET['is_ajax']) ){
|
|
return;
|
|
}
|
|
|
|
SP_Html::render('login');
|
|
exit();
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* @brief Establecer las rutas de la aplicación
|
|
* @return none
|
|
*
|
|
* Esta función establece las rutasdel sistema de archivos y web de la aplicación.
|
|
* La variables de clase definidas son $SERVERROOT, $WEBROOT y $SUBURI
|
|
*/
|
|
private static function setPaths(){
|
|
// Calcular los directorios raíz
|
|
self::$SERVERROOT = str_replace("\\", '/', substr(__DIR__, 0, -4));
|
|
|
|
// Establecer la ruta include correcta
|
|
set_include_path(self::$SERVERROOT.'/inc'.PATH_SEPARATOR.
|
|
self::$SERVERROOT.'/config'.PATH_SEPARATOR.
|
|
get_include_path() . PATH_SEPARATOR.self::$SERVERROOT);
|
|
|
|
self::$SUBURI = str_replace("\\", "/", substr(realpath($_SERVER["SCRIPT_FILENAME"]), strlen(self::$SERVERROOT)));
|
|
|
|
$scriptName = isset($_SERVER['REQUEST_URI']) ? $_SERVER['REQUEST_URI'] : '';
|
|
if (substr($scriptName, -1) == '/') {
|
|
$scriptName .= 'index.php';
|
|
// Asegurar que suburi sigue las mismas reglas que scriptName
|
|
if (substr(self::$SUBURI, -9) != 'index.php') {
|
|
if (substr(self::$SUBURI, -1) != '/') {
|
|
self::$SUBURI = self::$SUBURI . '/';
|
|
}
|
|
self::$SUBURI = self::$SUBURI . 'index.php';
|
|
}
|
|
}
|
|
|
|
//self::$WEBROOT = substr($scriptName, 0, strlen($scriptName) - strlen(self::$SUBURI) + 1);
|
|
self::$WEBROOT = substr($scriptName, 0, strpos($scriptName,self::$SUBURI));
|
|
|
|
if (self::$WEBROOT != '' and self::$WEBROOT[0] !== '/') {
|
|
self::$WEBROOT = '/'.self::$WEBROOT;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Comprobar el archivo de configuración.
|
|
* @return none
|
|
*
|
|
* Esta función comprueba que el archivo de configuración exista y los permisos sean correctos.
|
|
*/
|
|
private static function checkConfig() {
|
|
if ( !is_dir(self::$SERVERROOT.'/config') ){
|
|
self::initError(_('El directorio "/config" no existe'));
|
|
} elseif ( !is_writable(self::$SERVERROOT.'/config') ) {
|
|
self::initError(_('No es posible escribir en el directorio "config"'));
|
|
} elseif ( substr(sprintf('%o', fileperms(self::$SERVERROOT.'/config')), -4) != "0750" ){
|
|
self::initError(_('Los permisos del directorio "/config" son incorrectos'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Comprueba que la aplicación esté instalada
|
|
* @return none
|
|
*
|
|
* Esta función comprueba si la aplicación está instalada. Si no lo está, redirige al instalador.
|
|
*/
|
|
private static function checkInstalled() {
|
|
// Redirigir al instalador si no está instalada
|
|
if (!SP_Config::getValue('installed', false) && self::$SUBURI != '/index.php') {
|
|
$url = 'http://'.$_SERVER['SERVER_NAME'].':'.$_SERVER["SERVER_PORT"].self::$WEBROOT.'/index.php';
|
|
header("Location: $url");
|
|
exit();
|
|
} elseif ( !SP_Config::getValue('installed', false) && self::$SUBURI == '/index.php') {
|
|
// Comprobar si sysPass está instalada o en modo mantenimiento
|
|
if (!SP_Config::getValue('installed', false)) {
|
|
SP_Html::render('install');
|
|
exit();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Comprobar si el modo mantenimeinto está activado
|
|
* @return none
|
|
*
|
|
* Esta función comprueba si el modo mantenimiento está activado.
|
|
* Devuelve un error 503 y un reintento de 120s al cliente.
|
|
*/
|
|
public static function checkMaintenanceMode() {
|
|
if ( SP_Config::getValue('maintenance', false) ) {
|
|
header('HTTP/1.1 503 Service Temporarily Unavailable');
|
|
header('Status: 503 Service Temporarily Unavailable');
|
|
header('Retry-After: 120');
|
|
|
|
self::initError(_('Aplicación en mantenimiento'),_('En breve estará operativa'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Inicialiar la sesión de usuario
|
|
* @return none
|
|
*/
|
|
private static function initSession() {
|
|
// Evita que javascript acceda a las cookis de sesion de PHP
|
|
ini_set('session.cookie_httponly', '1;');
|
|
|
|
// Si la sesión no puede ser iniciada, devolver un error 500
|
|
if ( session_start() === false){
|
|
|
|
SP_Common::wrLogInfo(_('Sesion'), _('La sesión no puede ser inicializada'));
|
|
|
|
header('HTTP/1.1 500 Internal Server Error');
|
|
$errors[] = array(
|
|
'type' => 'critical',
|
|
'description' => _('La sesión no puede ser inicializada'),
|
|
'hint' => _('Contacte con el administrador'));
|
|
|
|
SP_Html::render('error',$errors);
|
|
exit();
|
|
}
|
|
|
|
$sessionLifeTime = self::getSessionLifeTime();
|
|
|
|
// Regenerar el Id de sesión periódicamente para evitar fijación
|
|
if (!isset($_SESSION['SID_CREATED'])) {
|
|
$_SESSION['SID_CREATED'] = time();
|
|
$_SESSION['START_ACTIVITY'] = time();
|
|
} else if (time() - $_SESSION['SID_CREATED'] > $sessionLifeTime / 2) {
|
|
session_regenerate_id(true);
|
|
$_SESSION['SID_CREATED'] = time();
|
|
// Recargar los permisos del perfil de usuario
|
|
$_SESSION['usrprofile'] = SP_Users::getUserProfile();
|
|
}
|
|
|
|
// Timeout de sesión
|
|
if (isset($_SESSION['LAST_ACTIVITY']) && (time() - $_SESSION['LAST_ACTIVITY'] > $sessionLifeTime)) {
|
|
if (isset($_COOKIE[session_name()])) {
|
|
setcookie(session_name(), '', time() - 42000, '/');
|
|
}
|
|
|
|
self::wrLogoutInfo();
|
|
|
|
session_unset();
|
|
session_destroy();
|
|
session_start();
|
|
}
|
|
|
|
$_SESSION['LAST_ACTIVITY'] = time();
|
|
}
|
|
|
|
/**
|
|
* @brief Deslogar el usuario actual y eliminar la información de sesión
|
|
* @return none
|
|
*/
|
|
private static function logout() {
|
|
self::wrLogoutInfo();
|
|
|
|
session_unset();
|
|
session_destroy();
|
|
}
|
|
|
|
/**
|
|
* @brief Escribir la información de logout en el registro de eventos
|
|
* @return none
|
|
*/
|
|
private static function wrLogoutInfo() {
|
|
$inactiveTime = round(((time() - $_SESSION['LAST_ACTIVITY']) / 60),2);
|
|
$totalTime = round(((time() - $_SESSION['START_ACTIVITY']) / 60),2);
|
|
|
|
$message['action'] = _('Finalizar sesión');
|
|
$message['text'][] = _('Usuario').": ".$_SESSION['uname'];
|
|
$message['text'][] = _('IP').": ".$_SERVER['REMOTE_ADDR'];
|
|
$message['text'][] = _('Tiempo inactivo').": ".$inactiveTime." min.";
|
|
$message['text'][] = _('Tiempo total').": ".$totalTime." min.";
|
|
|
|
SP_Common::wrLogInfo($message);
|
|
}
|
|
|
|
/**
|
|
* @brief Comprobar si el usuario está logado
|
|
* @returns bool
|
|
*/
|
|
public static function isLoggedIn() {
|
|
if( isset($_SESSION['ulogin']) AND $_SESSION['ulogin']) {
|
|
// TODO: refrescar variables de sesión.
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @brief Obtener el timeout de sesión desde la configuración
|
|
* @returns int con el tiempo en segundos
|
|
*/
|
|
private static function getSessionLifeTime() {
|
|
return SP_Config::getValue('session_timeout', 60 * 60 * 24);
|
|
}
|
|
|
|
/**
|
|
* @brief Devuelve el tiempo actual en coma flotante
|
|
* @returns float con el tiempo actual
|
|
*
|
|
* Esta función se utiliza para calcular el tiempo de renderizado con coma flotante
|
|
*/
|
|
public static function microtime_float(){
|
|
list($usec, $sec) = explode(" ", microtime());
|
|
return ((float)$usec + (float)$sec);
|
|
}
|
|
|
|
/**
|
|
* @brief Devuelve un eror utilizando la plantilla de rror
|
|
* @param string $str con la descripción del error
|
|
* @param string $hint opcional, con una ayuda sobre el error
|
|
* @returns none
|
|
*/
|
|
public static function initError($str, $hint = ''){
|
|
$errors[] = array(
|
|
'type' => 'critical',
|
|
'description' => $str,
|
|
'hint' => $hint);
|
|
|
|
SP_Html::render('error',$errors);
|
|
exit();
|
|
}
|
|
|
|
/**
|
|
* @brief Establece el lenguaje de la aplicación
|
|
* @returns none
|
|
*
|
|
* Esta función establece el lenguaje según esté definidi en la configuración o en el navegador.
|
|
*/
|
|
private static function selectLang(){
|
|
$browserLang = str_replace("-","_",substr($_SERVER['HTTP_ACCEPT_LANGUAGE'], 0, 5));
|
|
$configLang = SP_Config::getValue('sitelang');
|
|
|
|
self::$LANG = ( $configLang ) ? $configLang : $browserLang;
|
|
|
|
putenv("LANG=".self::$LANG);
|
|
setlocale(LC_MESSAGES, self::$LANG);
|
|
setlocale(LC_ALL, self::$LANG);
|
|
bindtextdomain("messages", self::$SERVERROOT."/inc/locales");
|
|
textdomain("messages");
|
|
bind_textdomain_codeset("messages", 'UTF-8');
|
|
}
|
|
|
|
/**
|
|
* @brief Comrpueba y actualiza la versión de la aplicación
|
|
* @returns none
|
|
*/
|
|
private static function checkVersion(){
|
|
$update = FALSE;
|
|
$configVersion = SP_Config::getValue('version');
|
|
$databaseVersion = SP_Config::getConfigValue('version');
|
|
$appVersion = implode('.', SP_Util::getVersion());
|
|
|
|
if ( $configVersion != $appVersion ){
|
|
SP_Config::setValue('version', $appVersion);
|
|
$update = TRUE;
|
|
}
|
|
|
|
if ( $databaseVersion != $appVersion ){
|
|
SP_Config::setConfigValue('version', $appVersion);
|
|
$update = TRUE;
|
|
}
|
|
|
|
if ( $update === TRUE ){
|
|
$message['action'] = _('Actualización');
|
|
$message['text'][] = _('Actualización de versión realizada.');
|
|
$message['text'][] = _('Versión') . ': ' . $appVersion;
|
|
|
|
SP_Common::wrLogInfo($message);
|
|
SP_Common::sendEmail($message);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Empezar a calcular el tiempo y memoria utilizados
|
|
$memInit = memory_get_usage();
|
|
$time_start = SP_Init::microtime_float();
|
|
|
|
// Inicializar sysPass
|
|
SP_Init::init(); |