Proyectos de Subversion Moodle

<?php

// NOTA IMPORTANTE:

// Las credenciales y claves RSA NO DEBEN ESTAR HARDCODEADAS EN UN ENTORNO DE PRODUCCIÓN.

// Considere usar variables de entorno, un archivo de configuración externo, o las propias configuraciones de Moodle

// para almacenar LLWS_USERNAME, LLWS_PASSWORD, LLWS_RSA_N, LLWS_RSA_D, LLWS_RSA_E.

// Por simplicidad en este ejemplo, se mantienen aquí para la demostración de los cambios.

define('LLWS_USERNAME', 'leaderdslinked-ws');

define('LLWS_PASSWORD', 'KFB3lFsLp&*CpB0uc2VNc!zVn@w!EZqZ*jr$J0AlE@sYREUcyP');

define('LLWS_RSA_N', 34589927);     // Clave pública RSA N

define('LLWS_RSA_D', 4042211);      // Clave privada RSA D

define('LLWS_RSA_E', 7331);         // Clave pública RSA E

define('LLWS_CATEGORY_ID', 6);      // ID de categoría para cursos

// Inclusión de archivos necesarios de Moodle

require_once(__DIR__ . '/../config.php');

global $DB, $CFG;

// Inclusión de librerías de Moodle

require_once($CFG->libdir . '/moodlelib.php');

require_once($CFG->libdir . '/externallib.php');

require_once($CFG->libdir . '/authlib.php');

require_once($CFG->libdir . '/gdlib.php'); // Para procesamiento de imágenes

require_once($CFG->dirroot . '/user/lib.php'); // Para funciones de usuario

require_once(__DIR__ . '/rsa.php'); // Asegúrate de que esta ruta sea correcta para tu clase RSA

require_once(__DIR__ . '/lib.php'); // Asegúrate de que esta ruta sea correcta para tus funciones ll_get_user_by_email, ll_get_username_available, ll_create_user

// Helper function to output JSON error and exit

// NOTA: Estos headers solo se configuran cuando hay un error para una respuesta JSON.

// Para un login exitoso, no se necesitan estos headers.

function output_json_error($errorCode)

{

    // Es buena práctica asegurar que la sesión se cierre antes de la salida,

    // aunque el manejo de salida de Moodle podría cubrir esto.

    if (function_exists('session_write_close')) {

        session_write_close();

    }

    header('Content-Type: application/json');

    // Para entornos de producción, considera restringir Access-Control-Allow-Origin

    // a dominios específicos si esta vista será accedida vía AJAX desde otros orígenes.

    // Si es una redirección directa, CORS es irrelevante para una respuesta JSON.

    header('Access-Control-Allow-Origin: *');

    echo json_encode(['success' => false, 'data' => $errorCode]);

    exit;

}

// Obtención y sanitización de parámetros de la petición

$username   = trim(isset($_REQUEST['username']) ? filter_var($_REQUEST['username'], FILTER_SANITIZE_STRING) : '');

$password   = trim(isset($_REQUEST['password']) ? filter_var($_REQUEST['password'], FILTER_SANITIZE_STRING) : '');

$timestamp  = trim(isset($_REQUEST['timestamp']) ? filter_var($_REQUEST['timestamp'], FILTER_SANITIZE_STRING) : '');

// Usamos FILTER_VALIDATE_INT para asegurar que sea un entero y no un string numérico grande.

$rand       = intval(isset($_REQUEST['rand']) ? filter_var($_REQUEST['rand'], FILTER_VALIDATE_INT) : 0, 10);

$data       = trim(isset($_REQUEST['data']) ? filter_var($_REQUEST['data'], FILTER_SANITIZE_STRING) : '');

// --- Validaciones de Seguridad ---

// Validación de parámetros de seguridad mínimos

if (empty($username) || empty($password) || empty($timestamp) || empty($rand) || !is_integer($rand)) {

    output_json_error('ERROR_SECURITY1');

}

// Validación del nombre de usuario de la API

if ($username !== LLWS_USERNAME) { // Usamos !== para comparación estricta

    output_json_error('ERROR_SECURITY2');

}

// Validación del formato del timestamp

$dt = \DateTime::createFromFormat('Y-m-d\TH:i:s', $timestamp);

if (!$dt) {

    output_json_error('ERROR_SECURITY3');

}

// Validación del rango de tiempo del timestamp (±5 minutos) para prevenir Replay Attacks

$t0 = $dt->getTimestamp();

$t1 = strtotime('-5 minutes');

$t2 = strtotime('+5 minutes');

if ($t0 < $t1 || $t0 > $t2) {

    output_json_error('ERROR_SECURITY4'); // Habilitado para prevenir Replay Attacks

}

// Validación de la contraseña (hash de la contraseña de la API + rand + timestamp)

$expectedPasswordString = $username . '-' . LLWS_PASSWORD . '-' . $rand . '-' . $timestamp;

if (!password_verify($expectedPasswordString, $password)) {

    output_json_error('ERROR_SECURITY5');

}

// --- Validación y Desencriptación de Datos de Usuario ---

// Validación de datos

if (empty($data)) {

    output_json_error('ERROR_PARAMETERS1');

}

// Decodificación de datos en base64

$data = base64_decode($data);

if ($data === false || empty($data)) { // base64_decode puede retornar false

    output_json_error('ERROR_PARAMETERS2');

}

// Desencriptación de datos usando RSA

try {

    $rsa = new rsa(); // Asegúrate de que la clase 'rsa' esté correctamente cargada.

    $rsa->setKeys(LLWS_RSA_N, LLWS_RSA_D, LLWS_RSA_E);

    $data = $rsa->decrypt($data);

} catch (Throwable $e) {

    // Registra el error para depuración, pero no lo expongas al cliente.

    error_log("RSA Decryption Error: " . $e->getMessage());

    output_json_error('ERROR_PARAMETERS3');

}

// Conversión de datos a array

$data = (array) json_decode($data, true); // Añadido 'true' para asegurar un array asociativo

if (empty($data)) {

    output_json_error('ERROR_PARAMETERS4');

}

// Extracción y validación de datos del usuario

$email      = trim(isset($data['email']) ? filter_var($data['email'], FILTER_SANITIZE_EMAIL) : '');

$first_name = trim(isset($data['first_name']) ? filter_var($data['first_name'], FILTER_SANITIZE_STRING, FILTER_FLAG_STRIP_LOW | FILTER_FLAG_STRIP_HIGH) : '');

$last_name  = trim(isset($data['last_name']) ? filter_var($data['last_name'], FILTER_SANITIZE_STRING, FILTER_FLAG_STRIP_LOW | FILTER_FLAG_STRIP_HIGH) : '');

// Asegúrate de que los datos esenciales del usuario estén presentes y sean válidos.

if (!filter_var($email, FILTER_VALIDATE_EMAIL) || empty($first_name) || empty($last_name)) {

    output_json_error('ERROR_PARAMETERS5');

}

// --- Búsqueda o Creación de Usuario en Moodle ---

$user = ll_get_user_by_email($email); // Asume que esta función busca al usuario por email

$new_user = false;

if ($user) {

    // Usuario encontrado

} else {

    // Usuario no encontrado, proceder a la creación

    $new_user = true;

    $username_moodle = ll_get_username_available($first_name, $last_name); // Genera un nombre de usuario disponible para Moodle

    $user = ll_create_user($username_moodle, $email, $first_name, $last_name); // Crea el usuario

    // Procesamiento de imagen de perfil si se proporciona y el usuario fue creado

    if ($user) {

        $filename   = trim(isset($data['image_filename']) ? filter_var($data['image_filename'], FILTER_SANITIZE_STRING, FILTER_FLAG_STRIP_LOW | FILTER_FLAG_STRIP_HIGH) : '');

        $content    = trim(isset($data['image_content']) ? filter_var($data['image_content'], FILTER_SANITIZE_STRING) : '');

        // Validación básica de nombre de archivo para evitar path traversal

        if ($filename && strpos($filename, '..') === false && strpos($filename, DIRECTORY_SEPARATOR) === false) {

            $tempfile = sys_get_temp_dir() . DIRECTORY_SEPARATOR . $filename; // Usar directorio temporal del sistema

            try {

                $decoded_content = base64_decode($content);

                if ($decoded_content !== false && !empty($decoded_content)) {

                    file_put_contents($tempfile, $decoded_content);

                    if (file_exists($tempfile)) {

                        $usericonid = process_new_icon(context_user::instance($user->id, MUST_EXIST), 'user', 'icon', 0, $tempfile);

                        if ($usericonid) {

                            $DB->set_field('user', 'picture', $usericonid, array('id' => $user->id));

                        }

                    }

                }

            } catch (\Throwable $e) {

                // IMPORTANT: Registra el error de la imagen, pero no abortes el login del usuario si la imagen falla.

                error_log("Error processing user image for user ID {$user->id}: " . $e->getMessage());

            } finally {

                // Asegúrate de eliminar el archivo temporal

                if (file_exists($tempfile)) {

                    unlink($tempfile);

                }

            }

        }

    }

}

// Verificación de creación/recuperación de usuario

if (!$user) {

    output_json_error('ERROR_MOODLE1');

}

// --- Inscripción en Cursos para Usuarios Nuevos ---

if ($new_user) {

    $role = $DB->get_record('role', array('archetype' => 'student'));

    $enrolmethod = 'manual';

    $courses = get_courses(); // Obtiene todos los cursos

    foreach ($courses as $course) {

        // CORRECCIÓN: Error tipográfico 'categoy_id' a 'category_id'

        if ($course->category_id == LLWS_CATEGORY_ID) {

            $context = context_course::instance($course->id);

            if (!is_enrolled($context, $user)) { // Verifica si el usuario ya está inscrito

                $enrol = enrol_get_plugin($enrolmethod);

                if ($enrol === null) {

                    // Si el método de matriculación manual no existe, loguea un error y continúa.

                    // No debería abortar el login del usuario por esto.

                    error_log("Enrolment method '{$enrolmethod}' not found for course ID {$course->id}.");

                    continue; // Pasa al siguiente curso

                }

                // Obtener o crear una instancia de matriculación manual para el curso

                $instance = $enrol->add_default_instance($course); // Esto intenta encontrar o crear una instancia por defecto

                if ($instance === null) {

                    // Si add_default_instance falla (ej. no hay permisos), intenta crear una nueva instancia.

                    // Esto es menos común si add_default_instance no funciona, pero es una alternativa.

                    $instanceid = $enrol->add_instance($course);

                    $instance = $DB->get_record('enrol', array('id' => $instanceid));

                }

                if ($instance) {

                    $enrol->enrol_user($instance, $user->id, $role->id);

                } else {

                    error_log("Failed to get or create manual enrolment instance for course ID {$course->id}.");

                }

            }

        }

    }

}

// --- Completar el Proceso de Inicio de Sesión ---

// Obtener datos completos del usuario (asegura que todos los campos de Moodle estén cargados)

$user = get_complete_user_data('id', $user->id);

if ($user) {

    // Verificar si la cuenta está confirmada

    if (empty($user->confirmed)) {

        output_json_error('ACCOUNT_NOT_CONFIRMED');

    }

    // Verificar si la contraseña ha expirado (solo para autenticación LDAP)

    $userauth = get_auth_plugin($user->auth);

    if (!isguestuser() && !empty($userauth->config->expiration) && $userauth->config->expiration == 1) {

        $days2expire = $userauth->password_expire($user->username);

        if (intval($days2expire) < 0) {

            output_json_error('PASSWORD_EXPIRED');

        }

    }

    // CORRECCIÓN: Para un flujo de login web, Moodle maneja la sesión existente.

    // complete_user_login() es suficiente para establecer la sesión del usuario.

    // Eliminar el cierre agresivo de todas las sesiones a menos que sea un requisito muy específico.

    // Si la sesión actual ya está autenticada, complete_user_login() la actualizará.

    // Si necesitas forzar un re-login de la sesión actual, puedes hacerlo de forma más granular:

    /*

    if (isloggedin() && get_userid() !== $user->id) { // Si un usuario diferente ya está logueado en esta sesión

        \core\session\manager::terminate_current();

        session_destroy();

        setcookie('MoodleSession', '', time() - 3600, '/'); // Eliminar la cookie de la sesión anterior

    }

    */

    // Completar el proceso de inicio de sesión de Moodle.

    // Esto establecerá la sesión del usuario $user.

    complete_user_login($user);

    // Aplicar límite de inicio de sesión concurrente (descomentado si es necesario)

    // \core\session\manager::apply_concurrent_login_limit($user->id, session_id());

    // Configurar cookie de nombre de usuario (Moodle lo maneja internamente)

    if (!empty($CFG->nolastloggedin)) {

        // No almacenar último usuario conectado en cookie

    } else if (empty($CFG->rememberusername)) {

        // Sin cookies permanentes, eliminar la anterior si existe

        set_moodle_cookie('');

    } else {

        set_moodle_cookie($user->username);

    }

    // Limpiar mensajes de error y redirección de sesión antes de la redirección final

    unset($SESSION->loginerrormsg);

    unset($SESSION->logininfomsg);

    unset($SESSION->loginredirect); // Descartar loginredirect si estamos redirigiendo

    // Configurar la URL de destino

    $urltogo = $CFG->wwwroot . '/my'; // Página "Mi Moodle"

    // Verificar que la sesión se haya iniciado correctamente antes de redirigir

    if (isloggedin() && !isguestuser()) {

        // Redirección HTTP para una vista web exitosa

        redirect($urltogo);

    } else {

        // Falló la autenticación final en Moodle, a pesar de las validaciones previas.

        output_json_error('LOGIN_FAILED_MOODLE');

    }

} else {

    // Esto debería ser capturado por output_json_error('ERROR_MOODLE1') anteriormente,

    // pero es un fallback.

    output_json_error('USER_NOT_FOUND');

}

// El script debería terminar con una redirección o una respuesta JSON de error.

// El 'exit;' final es redundante si se usa redirect() o output_json_error() que ya contienen exit().

exit;