Si necesitas que una de las secciones de tu sitio web sea accesible a un círculo limitado pero indefinido de personas, la forma más sencilla de hacerlo es registrando y autorizando a los usuarios. Hay muchas formas de autorizar a los usuarios. Puede utilizar tanto herramientas de servidor web como herramientas de lenguaje de programación. Hablaremos del caso en el que se utilizan sesiones PHP.

Probablemente te gustaría ver una forma más moderna de crear esta forma. Todavía tengo planes de presentarlo completamente de una manera moderna y relevante, pero puedes ver que el formulario de comentarios se puede construir usando técnicas orientadas a objetos en PHP.

Primero, analicemos todos los pasos que daremos a continuación. ¿Qué necesitamos? Necesitamos un script que registre al usuario, lo autorice y lo redirija a algún lugar después de la autorización. También necesitaremos crear una página que esté protegida del acceso de usuarios no autorizados. Para el registro y la autorización, necesitaremos crear formularios HTML. Almacenaremos información sobre los usuarios registrados en una base de datos. Esto significa que todavía necesitamos un script para conectarnos al DBMS. Todo nuestro trabajo se realizará mediante funciones que escribimos nosotros mismos. Guardaremos estas funciones en un archivo separado.

Entonces, necesitamos los siguientes archivos:

• conexión al DBMS;
• funciones personalizadas;
• autorización;
• registro;
• página protegida;
• script de cierre de usuario;
• un script que verifica el estado de autorización del usuario;
• Hoja de estilo para el diseño más sencillo de nuestras páginas.

Todo esto no tendrá sentido si no tiene la tabla correspondiente en la base de datos. Inicie su herramienta de administración de DBMS (PhpMyAdmin o la línea de comando, lo que sea más conveniente) y ejecute la siguiente consulta en ella:

CREAR TABLA `usuarios` (`id` int(11) NOT NULL AUTO_INCREMENT, `login` char(16) NOT NULL, `contraseña` char(40) NOT NULL, marca de tiempo `reg_date` NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (` id`)) MOTOR=MyISAM CONJUNTO DE CARACTERES PREDETERMINADO=utf8 AUTO_INCREMENT=1;

Nombraré nuestros archivos de script de esta manera (todos estarán en un directorio):

• base de datos.php;
• funciones.php;
• iniciar sesión.php;
• registro.php;
• índice.php;
• cerrar sesión.php;
• comprobarAuth.php;
• estilo.css.

Estoy seguro de que el propósito de cada uno de ellos lo tiene claro. Comencemos con el script de conexión al DBMS. Ya lo has visto. Simplemente guarde el código de este script en un archivo llamado base de datos.php. Declararemos funciones personalizadas en el archivo funciones.php. ¿Cómo funcionará todo esto? Un usuario no autorizado intenta acceder a un documento protegido index.php, el sistema verifica si el usuario está autorizado, si el usuario no está autorizado, es redirigido a la página de autorización. En la página de inicio de sesión, el usuario debería ver un formulario de autorización. Vamos a hacerlo.

registro.

Ahora nuestro formulario necesita recibir alguna forma. Al mismo tiempo, definiremos reglas para otros elementos. De cara al futuro, presentaré el contenido completo de la hoja de estilo.

/* archivo style.css */ .row (margen-inferior:10px; ancho:220px; ) .row etiqueta ( display:block; font-weight:bold; ) .row input.text ( font-size:1.2em; relleno:2px 5px; ) .to_reg (tamaño de fuente:0.9em; ) .instruction (tamaño de fuente:0.8em; color:#aaaaaa; margen izquierdo:2px; cursor:predeterminado; ) .error (color:rojo; margen izquierdo: 3px)

Si todo se hace correctamente deberías tener en tu navegador lo siguiente:

Por supuesto, todavía no tenemos un solo usuario registrado y para iniciar sesión es necesario registrarse. Hagamos un formulario de registro.

Probablemente hayas notado que hay variables PHP en el código HTML. Son el contenido de los atributos de los campos de texto de los formularios, el contenido de los contenedores diseñados para mostrar errores. Pero no hemos inicializado estas variables. Vamos a hacer eso.

No hay ningún parámetro especificado en el atributo de acción de la etiqueta del formulario. En este caso, cuando se envíen los datos del formulario, se procesarán en el mismo script desde el que se enviaron. Esto significa que necesitamos escribir código que procese los datos del formulario. Pero primero analicemos el algoritmo para procesarlos.

Necesitamos que los campos de inicio de sesión y contraseña no estén vacíos. Luego debe verificar que el inicio de sesión cumpla con los requisitos. La contraseña también debe cumplir con los requisitos descritos, y la contraseña reespecificada debe coincidir y, además, deben ser idénticas. Si no se cumple alguna de estas condiciones, se debe detener el procesamiento de los datos del formulario, se debe escribir una alerta adecuada en la matriz de mensajes de error y se debe mostrar al usuario. Para comodidad del usuario, guardaremos el inicio de sesión que ingresó (si lo especificó) escribiendo su valor en la matriz $fields.

Si todo está bien, en la ventana de tu navegador, cuando accedas al documento registración.php, deberías ver algo como esto:

Ahora, digamos que el usuario hizo clic en el botón de registro y no completó los campos del formulario. Según nuestro algoritmo, el nombre de usuario y la contraseña no pueden estar vacíos. Si no se cumple esta condición, no será posible la inscripción. Tenemos en cuenta que el procesamiento de los datos del formulario se produce en el escenario actual. Esto significa que debemos cambiar su código agregando las comprobaciones apropiadas. Analicemos inmediatamente las siguientes comprobaciones. Si ha ingresado tanto un nombre de usuario como una contraseña, debe verificar que cumplan con los requisitos especificados. Para verificar el nombre de usuario y la contraseña, crearemos funciones personalizadas en el archivo funciones.php.

/** * funciones.php * Archivo con funciones de usuario */ // Conecta el archivo con los parámetros de conexión al DBMS require_once("database.php"); // Comprobando la función de nombre de usuario checkLogin($str) ( // Inicializa una variable con un posible mensaje de error $error = ""; // Si falta la línea de inicio de sesión, devuelve un mensaje de error if(!$str) ( $error = " No ha ingresado un nombre de usuario"; return $error ) /** * Verifique el nombre de usuario usando expresiones regulares * El inicio de sesión no debe tener menos de 4 ni más de 16 caracteres * Debe contener caracteres del alfabeto latino, números, * puede contener los caracteres "_", "-", "." */ $pattern = "/^[-_.a-z\d](4,16)$/i"; ($pattern, $str) ; // Si la verificación falla, devuelve un mensaje de error if(!$result) ( $error = "Caracteres no válidos en el nombre de usuario o el nombre de usuario es demasiado corto (largo)"; return $error; ) // Si todo está bien, devuelve el valor verdadero return true ) // Comprobando la función de contraseña del usuario checkPassword($str) ( // Inicializa una variable con un posible mensaje de error $error = ""; // Si lo hay sin línea de inicio de sesión, devuelve un mensaje de error if(!$ str) ( $error = "No ingresaste una contraseña";

devolver $error;

Te has registrado exitosamente en el sistema. Ahora serás redirigido a la página de inicio de sesión. Si esto no sucede, acceda a él mediante el enlace directo.

Deberías haber notado otra función nueva en el script: registro(). Pero aún no lo hemos anunciado. Vamos a hacer eso.

// Función de registro de usuario function Registration($login, $password) ( // Inicializa una variable con un posible mensaje de error $error = ""; // Si no hay una línea de inicio de sesión, devuelve un mensaje de error if(!$login) ( $ error = "No se ha especificado ningún inicio de sesión"; return $error; ) elseif(!$contraseña) ( $error = "No se ha especificado ninguna contraseña"; return $error; ) // Comprobar si el usuario ya está registrado // Conéctese al DBMS connect() ; // Escribe una cadena de consulta $sql = "SELECT `id` FROM `users` WHERE `login`="" . $login . """ // Realiza una consulta a la base de datos $query = mysql_query( $sql) o die( ""); // Mira el número de usuarios con este inicio de sesión, si hay al menos uno, // devuelve un mensaje de error if(mysql_num_rows($query) > 0) ( $error = " El usuario con el inicio de sesión especificado ya está registrado"; return $ error; ) // Si no existe dicho usuario, regístrelo // Escriba la cadena de consulta $sql = "INSERT INTO `users` (`id`,`login` ,`contraseña`) VALORES (NULL, "," . $iniciar sesión . " ","" . $contraseña. """; // Realizar una consulta a la base de datos $query = mysql_query($sql) o die("

No se puede agregar usuario: " . mysql_error() . ". Se produjo un error en la línea ". __LINE__".

Si todo está bien, tu usuario quedará registrado. Puedes probar el formulario. Intente registrar usuarios con los mismos inicios de sesión. Después de un registro exitoso, el usuario será redirigido al formulario de autorización. Anteriormente, simplemente creamos el marcado para mostrar este formulario. Dado que no hay ningún parámetro especificado en su atributo de acción, los datos enviados por el formulario se procesarán en el mismo script. Esto significa que debemos escribir código para procesarlo y agregarlo al documento login.php.

Si no estás registrado en el sistema, regístrate.

Probablemente hayas notado que en el script de autorización ahora tenemos otra función desconocida: autorización(). Esta función debe autorizar al usuario verificando primero si existe un usuario registrado con el mismo nombre de usuario y contraseña en la base de datos. Si no se encuentra dicho usuario, se cancelará la autorización y se mostrará un mensaje de error. Si la verificación tiene éxito, la función de autorización() iniciará una sesión y escribirá los valores de inicio de sesión y contraseña del usuario en ella, informará al script que la autorización fue exitosa y el script redirigirá al usuario a una página de recursos protegida.

/** * Función de autorización de usuario.

*La autorización del usuario se realizará* mediante sesiones PHP.

No se puede ejecutar la consulta: " . mysql_error() . ". Se produjo un error en la línea ". __LINE__".

Función checkAuth($login, $password) ( // Si no hay nombre de usuario o contraseña, devuelve false if(!$login || !$password) return false; // Verifica si dicho usuario está registrado // Conéctate al DBMS connect(); // Componga la cadena de consulta $sql = "SELECCIONE `id` DE `usuarios` DONDE `login`="".$login."" Y `contraseña`="".$contraseña.""" // Ejecutar la consulta $ query = mysql_query($sql) o die("

*La autorización del usuario se realizará* mediante sesiones PHP.

Ahora que el usuario ha llegado a la página protegida, debemos llamar a la función para verificar los datos de autorización. Colocaremos el script de llamada y verificación en un archivo checkAuth.php separado y lo conectaremos a aquellas páginas que estarán cerradas al acceso público.

/** * Script para verificar la autorización del usuario */ // Iniciar una sesión de la cual extraeremos el nombre de usuario y la contraseña // de los usuarios autorizados session_start(); // Conecta un archivo con funciones personalizadas require_once("functions.php"); /** * Para determinar si un usuario está autorizado, necesitamos * verificar si existen registros en la base de datos para su nombre de usuario * y contraseña. Para hacer esto, usaremos la función personalizada * para verificar la exactitud de los datos del usuario registrado.

* Si esta función devuelve falso, entonces no hay autorización.

*/ // Si la sesión contiene datos de inicio de sesión y contraseña, // verifíquelos if(isset($_SESSION["login"]) && $_SESSION["login"] && isset($_SESSION["password" ]) && $_SESSION["contraseña"]) ( // Si falla la comprobación de los datos existentes if(!checkAuth($_SESSION["login"], $_SESSION["contraseña"])) ( // Redirige al usuario al encabezado de la página de inicio de sesión( "ubicación: login.php"); // Detener la ejecución del script exit ) ) // Si no hay datos sobre el nombre de usuario o contraseña del usuario, // asumimos que no hay autorización, redirigimos al usuario // a la autorización página else ( header("ubicación: login.php"); // Detener la ejecución del script exit;

Ahora creemos el código para nuestra página segura. Será bastante sencillo.

Como puede ver, en un documento protegido incluimos solo un archivo: checkAuth.php. Todos los demás archivos están conectados en otros scripts. Por lo tanto, nuestro código no parece engorroso. Organizamos el registro y autorización de usuarios. Ahora debe permitir que los usuarios cierren sesión. Para hacer esto, crearemos un script en el archivo logout.php.

/** * Script de cierre de sesión del usuario. Dado que los usuarios * inician sesión a través de sesiones, su nombre de usuario y contraseña se almacenan * en la matriz superglobal $_SESSION. Para * cerrar sesión en el sistema, simplemente destruya los valores * de la matriz $_SESSION["login"] y $_SESSION["password"], después de lo cual * redirigimos al usuario a la página de inicio de sesión */ // Ser asegúrese de iniciar la sesión session_start(); unset($_SESSION["iniciar sesión"]); unset($_SESSION["contraseña"]); encabezado("ubicación: login.php");

El script de registro, autorización y verificación de usuarios está listo. Puedes usarlo tú mismo, complementarlo o cambiarlo para adaptarlo a tus necesidades. Si tienes alguna pregunta, puedes hacerla en los comentarios. Puede descargar todos los archivos discutidos aquí, empaquetados en un solo archivo.

PD Sé que es mejor escribir código orientado a objetos, sé que no vale la pena transmitir y almacenar una contraseña en texto sin cifrar, que la información ingresada en la base de datos debe verificarse con anticipación. Lo sé. No hablaré de esto aquí.

Gran parte de los sitios web tienen un formulario de registro para que sus usuarios se registren y así puedan beneficiarse de algún tipo de privilegio dentro del sitio. En este artículo veremos cómo crear un formulario de registro en PHP y MySQL.

Usaremos etiquetas simples y también usaremos etiquetas de tabla para diseñar la página web Sign-Up.html. Empecemos:

Listado 1: registrarse.html

Figura 1:

Descripción de la página web sing-in.html:

Como puede ver en la Figura 1, hay un formulario de registro y solicita algunos datos sobre el usuario. Estos son los datos comunes que cualquier sitio web solicita a sus usuarios o visitantes para crear una identificación y contraseña. Usamos la etiqueta de tabla porque para mostrar los campos del formulario en la página web en un formulario organizado como puede verlos en la Figura 1. Parece muy simple porque todavía no usamos el estilo CSS, ahora usemos estilos CSS y vinculemos el Archivo de estilo CSS con la página web sing-up.html.

Listado 2: estilo.css

/*Archivo CSS para la página web de registro*/ #body-color( color de fondo:#6699CC; ) #Sign-Up( imagen de fondo:url("sign-up.png"); tamaño de fondo:500px 500px ; repetición de fondo: sin repetición; posición de fondo: centro; margen inferior: 150 px; margen izquierdo: 450 px; fondo: #FF00FF; peso de fuente: negrita; tamaño de fuente: 20 px;

Listado 3: Vincula style.css con la página web sign-up.html

Figura 2:

Descripción del archivo style.css:

En el archivo CSS externo utilizamos algunos estilos que podrían parecer nuevos para usted. Como usamos una imagen de fondo y la configuramos en el centro de la página web. Lo cual se vuelve fácil de usar con la ayuda de la etiqueta html div. Como usamos tres identificaciones de etiquetas div. #button, #sing-up y #body-color y les aplicamos todos los estilos CSS y ahora puedes ver en la Figura 2 lo hermoso y atractivo que se ve. Puede utilizar muchos otros estilos CSS, como estilos CSS 2D y 3D. Se verá más hermoso de lo que parece ahora.

Después de estos trabajos tan simples, ahora vamos a crear una base de datos y una tabla para almacenar todos los datos en la base de datos de nuevos usuarios. Antes de crear una tabla, debemos saber qué requerimos del usuario. A medida que diseñamos el formulario, crearemos la tabla de acuerdo con el formulario de registro que puede ver en las Figuras 1 y 2.

Listado 3: Consulta de tabla en MySQL

CREAR TABLA Usuarios del sitio web (ID de usuario int(9) NOT NULL auto_increment, nombre completo VARCHAR(50) NOT NULL, nombre de usuario VARCHAR(40) NOT NULL, correo electrónico VARCHAR(40) NOT NULL, pase VARCHAR(40) NOT NULL, CLAVE PRIMARIA (ID de usuario) );

Descripción del Listado 3:

Una cosa que debes saber es que si no tienes la función MySQL para usar esta consulta, debes seguir mi artículo anterior sobre . desde este enlace podrás entender la instalación y requisitos. ¿Y cómo podemos usarlo?

En la consulta del listado 3 utilizamos todas aquellas cosas que necesitamos para el formulario de registro. Como hay variables de correo electrónico, nombre completo, contraseña y nombre de usuario. Estas variables almacenarán datos del usuario, que ingresará en el formulario de registro en la Figura 2 para el registro.

Después de todos estos trabajos, vamos a trabajar con la programación PHP, que es un lenguaje de programación del lado del servidor. Por eso es necesario crear una conexión con la base de datos.

Listado 4: Conexión de base de datos

Descripción del Listado 4:

Creamos una conexión entre la base de datos y nuestras páginas web. Pero si no sabe si funciona o no, use una cosa más en la última lista de verificación 5.

Listado 5: comprobando la conexión de conectividad de la base de datos

Listado de descripción 5:

En el Listado 5 intenté mostrarle que puede verificar y confirmar la conexión entre la base de datos y PHP. Y una cosa más: no usaremos el código del Listado 5 en nuestra página web de registro. Porque es sólo para que entiendas cómo puedes comprobar la conexión MySQL.

Ahora escribiremos una aplicación de programación PHP para verificar primero la disponibilidad del usuario y luego almacenarlo si es un usuario nuevo en la página web.

Listado 6: conectividad-registro.php

Descripción de conectividad-sign-up.php

En esta aplicación PHP utilicé la forma más sencilla de crear una aplicación de registro para las páginas web. Como puede ver, primero creamos una conexión como el listado 4. Y luego usamos dos funciones, la primera función es SignUP(), que es llamada por la declaración if de la última aplicación, donde primero se confirma presionar el registro. botón. Si se presiona, llamará a la función SingUp y esta función utilizará una consulta de SELECT para recuperar los datos y compararlos con el nombre de usuario y el correo electrónico que actualmente ingresa el usuario. Si el nombre de usuario y el correo electrónico ya están presentes en la base de datos, dirá lo siento, ya está registrado.

Si el usuario es nuevo, su nombre de usuario actual y su ID de correo electrónico no están presentes en la base de datos, la declaración If llamará a NewUser() donde almacenará toda la información del nuevo usuario. Y el usuario pasará a formar parte de la página web.

figura 3

En la figura 3, el usuario ingresa datos para registrarse si es un usuario antiguo de esta página web según los registros de la base de datos. Entonces, la página web mostrará un mensaje de que el usuario ya está registrado si el usuario es nuevo, por lo que la página web mostrará un mensaje de que el registro del usuario se completó.

Figura 4:

A medida que ingresamos datos en el formulario de registro (Figura 4), de acuerdo con la base de datos, el nombre de usuario y el correo electrónico que ingresamos en el formulario de registro para el registro ya están presentes en la base de datos. Entonces deberíamos probar un nuevo nombre de usuario y dirección de correo electrónico para registrarnos con una nueva identificación y contraseña.

Figura 5

En la figura 5, nos confirma qué nombre de usuario e identificación de correo electrónico ha ingresado el usuario. Ambos no están presentes en los registros de la base de datos. Entonces, ahora se crea una nueva ID y contraseña y el usuario puede usar su nueva ID y contraseña para iniciar sesión la próxima vez.

Conclusión:

En este artículo aprendimos la forma más sencilla de crear una página web de registro. También aprendimos cómo se maneja la base de datos si usamos PHP y MySQL. Intenté brindarle conocimientos básicos sobre la funcionalidad de la página web de registro. Cómo funciona en la parte trasera y cómo podemos cambiar su apariencia en la parte delantera. Para cualquier consulta no dudes y comenta.

Laravel requiere que Composer administre las dependencias del proyecto. Entonces, antes de instalar Laravel, asegúrese de tener Composer instalado en su sistema. En caso de que estés escuchando sobre Composer por primera vez, es una herramienta de gestión de dependencias para PHP similar al npm de node.

Para instalar Composer en su máquina, consulte esta publicación:

Instalación de Laravel en Windows:

Siga los pasos a continuación para instalar laravel en una máquina con Windows. No importa si tienes una pila xampp/wamp, funciona para ambos. En WAMP, asegúrese de instalar laravel en la carpeta "www" y en XAMPP, obviamente los "htdocs".

PASO-1) Abra la carpeta "htdocs" en XAMPP, mantenga presionada la tecla MAYÚS, haga clic derecho en la carpeta y elija "abrir ventana de comando aquí". Alternativamente, puede abrir la ventana de comandos y cambiar el directorio a "xampp/htdocs".

PASO-2) Ingrese el siguiente comando.

Compositor crear-proyecto laravel/laravel my_laravel_site --prefer-dist

Aquí "my_laravel_site" es el nombre de la carpeta donde se instalarán los archivos laravel. Cambia esto a tu gusto.

PASO 3) Ahora es el momento de tener paciencia ya que la instalación de Laravel llevará algún tiempo.

PASO-4) Una vez instalado, cambie el directorio a "my_laravel_site" (cd "my_laravel_site") en el símbolo del sistema e ingrese el siguiente comando.

Servicio artesanal php

PASO 5) Esto mostrará un mensaje similar a "Se inició el servidor de desarrollo Laravel:" junto con una URL.

PASO-6) Copie y pegue la URL en el navegador. Si todo va bien, verás la pantalla de bienvenida de Laravel.

PASO-7) ¡Listo! Ha instalado con éxito laravel en una máquina con Windows y está listo para comenzar.

Configuración de clave de aplicación:

Laravel requiere poca configuración después de la instalación. Requiere que configure la clave de la aplicación. Se trata de una cadena aleatoria de 32 caracteres que se utiliza para cifrar sesiones y otros datos confidenciales. Por lo general, esto se configurará automáticamente cuando instales laravel a través del compositor o el instalador de laravel.

En caso de que no esté configurado, deberá hacerlo manualmente. Primero asegúrese de cambiar el nombre del archivo ".env.example" a ".env" en la raíz de su aplicación. Luego abra el símbolo del sistema y cambie a la carpeta del proyecto laravel. Ahora ejecute el siguiente comando para generar la clave.

Clave artesanal php:generar

Copie esta clave generada a la variable APP_KEY en el archivo ".env". Guarda y listo.

Instalación de una versión específica de Laravel:

El método anterior hará que Composer descargue e instale la última versión de laravel. Si desea instalar versiones anteriores de laravel en su máquina, asegúrese de incluir el número de versión respectivo en el comando create-project.

Compositor crear-proyecto laravel/laravel=5.4 nombre-de-su-proyecto --prefer-dist Lea también:

De la misma manera puedes Instale fácilmente Laravel usando Composer en Windows.. Espero que encuentres útil este tutorial. Compártelo en tu círculo social si te gusta.

Hoy veremos la explotación de una vulnerabilidad crítica de 1 día en el popular CMS Joomla, que explotó en Internet a finales de octubre. Hablaremos de vulnerabilidades con números. CVE-2016-8869, CVE-2016-8870 Y CVE-2016-9081. Los tres provienen de una pieza de código que languideció en las profundidades del marco durante cinco largos años, esperando entre bastidores, solo para luego liberarse y traer consigo caos, sitios pirateados y las lágrimas de usuarios inocentes de este Joomla. Sólo los desarrolladores más valientes y valientes, cuyos ojos están rojos por la luz de los monitores y cuyos teclados están llenos de migas de pan, pudieron desafiar a los espíritus malignos furiosos y poner sus cabezas en el altar de las soluciones.

ADVERTENCIA

donde todo empezó

El 6 de octubre de 2016, Demis Palma creó un tema en Stack Exchange en el que preguntaba: ¿por qué, de hecho, en la versión 3.6 de Joomla hay dos métodos para registrar usuarios con el mismo nombre, Register()? El primero está en el controlador UsersControllerRegistration y el segundo está en el controlador UsersControllerUser. Damis quería saber si el método UsersControllerUser::register() se usaba en alguna parte, o si era simplemente un anacronismo evolutivo remanente de la vieja lógica. Su preocupación era que incluso si ninguna vista utiliza este método, se puede llamar mediante una consulta diseñada. A lo que recibí respuesta de un desarrollador bajo el sobrenombre de itoctopus, quien confirmó: el problema realmente existe. Y envió un informe a los desarrolladores de Joomla.

Entonces los acontecimientos se desarrollaron más rápidamente. El 18 de octubre, los desarrolladores de Joomla aceptaron el informe de Damis, quien en ese momento había redactado un PoC que permitiría el registro de usuarios. Publicó una nota en su sitio web, donde habló en términos generales sobre el problema que encontró y su opinión al respecto. El mismo día se lanza una nueva versión de Joomla 3.6.3, que todavía contiene código vulnerable.

Después de esto, Davide Tampellini le da la vuelta al error hasta el punto de registrar no a un simple usuario, sino a un administrador. Y ya el 21 de octubre llega un nuevo caso al equipo de seguridad de Joomla. Ya se habla de aumentar los privilegios. El mismo día aparece un anuncio en el sitio web de Joomla de que el martes 25 de octubre se lanzará la próxima versión con número de serie 3.6.3, que corrige una vulnerabilidad crítica en el kernel del sistema.

25 de octubre El equipo de ataque de seguridad de Joomla encuentra el último problema creado por el fragmento de código descubierto por Damis. Luego, se inserta una confirmación fechada el 21 de octubre con el nombre discreto Prepare 3.6.4 Stable Release en la rama principal del repositorio oficial de Joomla, lo que corrige el desafortunado error.

Después de esta revelación, numerosas personas interesadas se unen a la comunidad de desarrolladores y comienzan a promocionar la vulnerabilidad y preparar exploits.

El 27 de octubre, el investigador Harry Roberts carga un exploit listo para usar en el repositorio de Xiphos Research que puede cargar un archivo PHP en un servidor con un CMS vulnerable.

Detalles

Bueno, ya se acabó el trasfondo, pasemos a la parte más interesante: el análisis de la vulnerabilidad. Instalé Joomla 3.6.3 como versión de prueba, por lo que todos los números de línea serán relevantes para esta versión. Y todas las rutas a los archivos que verá a continuación se indicarán en relación con la raíz del CMS instalado.

Gracias al descubrimiento de Damis Palma sabemos que existen dos métodos que realizan el registro de usuarios en el sistema. El primero lo utiliza el CMS y se encuentra en el archivo /components/com_users/controllers/registration.php:108. El segundo (al que tendremos que llamar) se encuentra en /components/com_users/controllers/user.php:293. Echemos un vistazo más de cerca.

286: /** 287: * Método para registrar un usuario. 288: * 289: * @return boolean 290: * 291: * @since 1.6 292: */ 293: registro de función pública() 294: ( 295: JSession::checkToken("publicación") o jexit(JText::_ ("JINVALID_TOKEN")); ... 300: // Obtener los datos del formulario 301: $data = $this->input->post->get("user", array(), "array"); 315: $return = $model->validate($form, $data); 316: 317: // Comprobar errores 318: if ($return === false) 319: (... 345: //. Finalice el registro 346: $return = $model->register($data);

Aquí dejé sólo líneas interesantes. La versión completa del método vulnerable se puede ver en el repositorio de Joomla.

Averigüemos qué sucede durante el registro de usuario normal: qué datos se envían y cómo se procesan. Si el registro de usuario está habilitado en la configuración, el formulario se puede encontrar en http://joomla.local/index.php/component/users/?view=registration.

Una solicitud de registro de usuario legítima se parece a la siguiente captura de pantalla.

El componente com_users es responsable de trabajar con los usuarios. Preste atención al parámetro de la tarea en la solicitud. Tiene el formato $controlador.$método. Veamos la estructura del archivo.

Nombres de scripts en la carpeta. controladores corresponden a los nombres de los controladores llamados. Dado que nuestra solicitud ahora contiene $controller = "registration", se llamará el archivo registro.php y su método de registro().

Atención, pregunta: ¿cómo transferir el procesamiento de registro a un lugar vulnerable en el código? Probablemente ya lo hayas adivinado. Los nombres de los métodos vulnerables y reales son los mismos (registro), por lo que solo necesitamos cambiar el nombre del controlador llamado. ¿Dónde está ubicado nuestro controlador vulnerable? Así es, en el archivo. usuario.php. Resulta $controller = "usuario" . Juntando todo obtenemos task = user.register. Ahora la solicitud de registro se procesa mediante el método que necesitamos.

Lo segundo que debemos hacer es enviar los datos en el formato correcto. Aquí todo es sencillo. El registro legítimo() espera de nosotros una matriz llamada jform, en la que pasamos los datos de registro: nombre, inicio de sesión, contraseña, correo electrónico (ver captura de pantalla con la solicitud).

• /components/com_users/controllers/registration.php: 124: // Obtener los datos del usuario.

125: $requestData = $this->input->post->get("jform", array(), "array");

• Nuestro cliente obtiene estos datos de una matriz llamada usuario.

/components/com_users/controllers/user.php: 301: // Obtener los datos del formulario.

Nuestro tercer paso es encontrar un token CSRF válido, ya que sin él no habrá registro.

• /components/com_users/controllers/user.php: 296: JSession::checkToken("post") o jexit(JText::_("JINVALID_TOKEN"));

Parece un hash MD5 y puede obtenerlo, por ejemplo, desde el formulario de autorización en el sitio /index.php/component/users/?view=login.

Ahora puede crear usuarios utilizando el método deseado. Si todo salió bien, felicidades, acabas de explotar una vulnerabilidad. CVE-2016-8870"Falta la verificación de permisos para registrar nuevos usuarios".

Así es como se ve en el método de registro() "en funcionamiento" del controlador UsersControllerRegistration:

• /components/com_users/controllers/registration.php: 113: // Si el registro está deshabilitado: redirigir a la página de inicio de sesión.

114: if (JComponentHelper::getParams("com_users")->get("allowUserRegistration") == 0) 115: ( 116: $this->setRedirect(JRoute::_("index.php?option=com_users&view= iniciar sesión", falso)); 117: 118: devolver falso; 119:)

• Y así en vulnerable:

/components/com_users/controllers/user.php:

Sí, de ninguna manera.

Para comprender el segundo problema, mucho más grave, enviemos la solicitud que creamos y veamos cómo se ejecuta en varias partes del código. Aquí está la pieza que es responsable de validar los datos enviados por el usuario en el método de trabajo:

La continuación está disponible sólo para miembros.

Opción 1. Únase a la comunidad del "sitio" para leer todos los materiales del sitio

¡La membresía en la comunidad dentro del período especificado le dará acceso a TODOS los materiales de Hacker, aumentará su descuento acumulativo personal y le permitirá acumular una calificación profesional de Xakep Score!

El proceso de creación de un sistema de registro requiere bastante trabajo. Debe escribir un código que verifique la validez de las direcciones de correo electrónico, envíe correos electrónicos de confirmación, ofrezca la posibilidad de recuperar contraseñas, almacene contraseñas en un lugar seguro, valide los formularios de entrada y mucho más. Incluso cuando haga todo esto, los usuarios se mostrarán reacios a registrarse, ya que incluso el registro más mínimo requiere su actividad.

En el tutorial de hoy, desarrollaremos un sistema de registro simple que no requerirá contraseñas. El resultado será un sistema que se puede modificar o integrar fácilmente en un sitio web PHP existente. Si estás interesado, sigue leyendo.

Ahora estamos listos para comenzar con el código PHP. La funcionalidad principal del sistema de registro la proporciona la clase Usuario, que puede ver a continuación. La clase utiliza (), que es una biblioteca de bases de datos minimalista. La clase Usuario es responsable de acceder a las bases de datos, generar tokens de inicio de sesión y validarlos. Nos presenta una interfaz sencilla que se puede incorporar fácilmente al sistema de registro de sus sitios web basados ​​en PHP.

Usuario.clase.php

// Instancia ORM privada
$orma privada;

/**
* Encuentra un usuario por una cadena de token. Sólo se aceptan tokens válidos
* consideración. Un token es válido durante 10 minutos después de su generación.
* @param string $token El token a buscar
* @return Usuario
*/

Función estática pública findByToken($token)(

// lo buscamos en la base de datos y nos aseguramos de que la marca de tiempo sea correcta

->dónde("token", $token)
->where_raw("validez_token > AHORA()")
->buscar_uno();

Si(!$resultado)(
falso retorno;
}

Devolver nuevo usuario ($resultado);
}

/**
* Inicie sesión o registre un usuario.
* @return Usuario
*/

Función estática pública loginOrRegister($correo electrónico)(

// Si dicho usuario ya existe, lo devolvemos

Si(Usuario::existe($correo electrónico))(
devolver nuevo usuario ($correo electrónico);
}

// En caso contrario, créelo y devuélvalo

Usuario devuelto::create($correo electrónico);
}

/**
* Crear un nuevo usuario y guardarlo en la base de datos.
* @param string $email La dirección de correo electrónico del usuario
* @return Usuario
*/

Función estática privada crear ($ correo electrónico) (

// Escribe un nuevo usuario en la base de datos y lo devuelve.

$resultado = ORM::for_table("reg_users")->create();
$resultado->correo electrónico = $correo electrónico;
$resultado->guardar();

Devolver nuevo usuario ($resultado);
}

/**
* Verifique si dicho usuario existe en la base de datos y devuelva un valor booleano.
* @param string $email La dirección de correo electrónico del usuario
* @return booleano
*/

Existe una función estática pública ($email)(

// ¿Existe el usuario en la base de datos?
$resultado = ORM::for_table("reg_users")
->dónde("correo electrónico", $correo electrónico)
->contar();

Devuelve $resultado == 1;
}

/**
* Crear un nuevo objeto de usuario
* @param $param Instancia ORM, id, correo electrónico o nulo
* @return Usuario
*/

Función pública __construct($param = null)(

Si ($param instancia de ORM)(

// Se pasó una instancia ORM
$this->orm = $param;
}
demás si(is_string($param))(

//Se pasó un correo electrónico
$esto->
->dónde("correo electrónico", $param)
->buscar_uno();
}
demás(

Si(is_numeric($param))(
// Se pasó una identificación de usuario como parámetro
$id = $param;
}
else if(isset($_SESSION["loginid"]))(

// No se pasó ningún ID de usuario, mira la sesión
$id = $_SESSION["loginid"];
}

$this->orm = ORM::for_table("reg_users")
->dónde("identificación", $identificación)
->buscar_uno();
}

/**
* Genera un nuevo token de inicio de sesión SHA1, lo escribe en la base de datos y lo devuelve.
* @cadena de retorno
*/

Función pública generarToken())(
// genera un token para el usuario que ha iniciado sesión. Guárdelo en la base de datos.

$token = sha1($this->email.time().rand(0, 1000000));

// Guarda el token en la base de datos,
// y márcalo como válido sólo durante los próximos 10 minutos

$this->orm->set("token", $token);
$this->orm->set_expr("token_validity", "ADDTIME(NOW(),"0:10")");
$this->orm->save();

Devolver $token;
}

/**
*Inicia sesión con este usuario
* @retorno nulo
*/

Inicio de sesión de función pública()

// Marcar al usuario como iniciado sesión
$_SESSION["loginid"] = $this->orm->id;

//Actualiza el campo de base de datos last_login
$this->orm->set_expr("last_login", "AHORA()");
$this->orm->save();
}

/**
* Destruye la sesión y cierra la sesión del usuario.
* @retorno nulo
*/

Cerrar sesión de función pública()
$_SESSION = matriz();
desarmado($_SESSION);
}

/**
* Verifique si el usuario ha iniciado sesión.
* @return booleano
*/

Función pública iniciada sesión())(
return isset($this->orm->id) && $_SESSION["loginid"] == $this->orm->id;
}

/**
* Comprobar si el usuario es administrador
* @return booleano
*/

La función pública esAdmin())(
return $this->rank() == "administrador";
}

/**
* Encuentra el tipo de usuario. Puede ser administrativo o regular.
* @cadena de retorno
*/

Rango de función pública())(
if($this->orm->rango == 1)(
devolver "administrador";
}

Devolver "normal";
}

/**
* Método mágico para acceder a los elementos de lo privado.
* $orm instancia como propiedades del objeto de usuario
* @param string $key El nombre de la propiedad a la que se accede
* @retorno mixto
*/

Función pública __get($clave)(
if(isset($this->orm->$clave))(
devolver $this->orm->$key;
}

Devuelve nulo;
}
}
Los tokens se generan mediante un algoritmo y se almacenan en una base de datos. Usamos MySQL para configurar la columna token_validity en 10 minutos. Al validar un token, le decimos al motor que necesitamos un token, el campo token_validity aún no ha caducado. De esta forma limitamos el tiempo durante el cual el token será válido.

Observe que usamos el método mágico __get() al final del documento para acceder a las propiedades del objeto de usuario. Esto nos permite acceder a los datos que están almacenados en la base de datos como propiedades: $usuario->correo electrónico, $usuario->token. Como ejemplo, veamos cómo podemos usar esta clase en el siguiente fragmento de código:

Funciones.php

Función enviar_correo electrónico($de, $a, $asunto, $mensaje)(

// Función auxiliar para enviar correo electrónico

$headers = "Versión MIME: 1.0" . "\r\n";
$headers .= "Tipo de contenido: texto/sin formato; charset=utf-8" . "\r\n";
$encabezados .= "De: ".$de . "\r\n";

Devolver correo ($a, $asunto, $mensaje, $encabezados);
}

función get_page_url())(

// Descubra la URL de un archivo PHP

$url = "http".(empty($_SERVER["HTTPS"])?"":"s")."://".$_SERVER["SERVER_NAME"];

If(isset($_SERVER["REQUEST_URI"]) && $_SERVER["REQUEST_URI"] != "")(
$url.= $_SERVER["REQUEST_URI"];
}
demás(
$url.= $_SERVER["PATH_INFO"];
}

Devolver $url;
}

función límite_tasa($ip, $límite_hora = 20, $límite_10_min = 10)(

// El número de intentos de inicio de sesión durante la última hora con esta dirección IP

$count_hour = ORM::for_table("reg_login_attempt")
->
->where_raw("ts > SUBTIME(AHORA(),"1:00")")
->contar();

// El número de intentos de inicio de sesión durante los últimos 10 minutos con esta dirección IP

$count_10_min = ORM::for_table("reg_login_attempt")
->donde("ip", sprintf("%u", ip2long($ip)))
->where_raw("ts > SUBTIME(AHORA(),"0:10")")
->contar();

Si($count_hour > $limit_hour || $count_10_min > $limit_10_min)(
lanzar una nueva excepción ("¡Demasiados intentos de inicio de sesión!");
}
}

función rate_limit_tick($ip, $correo electrónico)(

// Crea un nuevo registro en la tabla de intentos de inicio de sesión

$login_attempt = ORM::for_table("reg_login_attempt")->create();

$login_attempt->correo electrónico = $correo electrónico;
$login_attempt->ip = sprintf("%u", ip2long($ip));

$login_attempt->save();
}

función de redirección ($url)(
encabezado("Ubicación: $url");
salida;
}
Las funciones rate_limit y rate_limit_tick nos permiten limitar el número de intentos de autorización durante un periodo de tiempo determinado. Los intentos de autorización se registran en la base de datos reg_login_attempt. Estas funciones se activan cuando se verifica el formulario de inicio de sesión, como puede ver en el siguiente fragmento de código.

El siguiente código fue tomado de index.php y es responsable de validar el formulario de inicio de sesión. Devuelve una respuesta JSON impulsada por el código jQuery que vimos en activos/js/script.js.

index.php

If(!empty($_POST) && isset($_SERVER["HTTP_X_REQUESTED_WITH"]))(

// Genera un encabezado JSON

Encabezado("Tipo de contenido: aplicación/json");

// ¿Es válida la dirección de correo electrónico?

If(!isset($_POST["correo electrónico"]) || !filter_var($_POST["correo electrónico"], FILTER_VALIDATE_EMAIL))(
throw new Exception ("Ingrese un correo electrónico válido.");
}

// Esto generará una excepción si la persona está arriba
// los límites de intentos de inicio de sesión permitidos (consulte funciones.php para obtener más información):
rate_limit($_SERVER["REMOTE_ADDR"]);

// Registra este intento de inicio de sesión
rate_limit_tick($_SERVER["REMOTE_ADDR"], $_POST["correo electrónico"]);

//Envía el mensaje al usuario

$mensaje = "";
$correo electrónico = $_POST["correo electrónico"];
$subject = "Su enlace de inicio de sesión";

Si(!Usuario::existe($correo electrónico))(
$subject = "¡Gracias por registrarse!";
$message = "¡Gracias por registrarse en nuestro sitio!\n\n";
}

// Intenta iniciar sesión o registrar a la persona
$usuario = Usuario::loginOrRegister($_POST["correo electrónico"]);

$message.= "Puedes iniciar sesión desde esta URL:\n";
$mensaje.= get_page_url()."?tkn=".$usuario->generateToken()."\n\n";

$message.= "El enlace caducará automáticamente después de 10 minutos.";

$resultado = send_email($fromEmail, $_POST["email"], $asunto, $mensaje);

Si(!$resultado)(
throw new Exception("Hubo un error al enviar su correo electrónico. Inténtelo de nuevo.");
}

Morir(json_encode(matriz(
"message" => "¡Gracias! Hemos enviado un enlace a tu bandeja de entrada. Revisa también tu carpeta de spam."
)));
}
}
captura(Excepción $e)(

Morir(json_encode(matriz(
"error"=>1,
"mensaje" => $e->getMessage()
)));
}
Tras la autorización o el registro exitosos, el código anterior envía un correo electrónico a la persona con un enlace para la autorización. El token está disponible como una variable $_GET "tkn" debido a la URL generada.

index.php

Si(isset($_GET["tkn"]))(

// ¿Es este un token de inicio de sesión válido?
$usuario = Usuario::findByToken($_GET["tkn"]);

// ¡Sí! Inicie sesión como usuario y redirija a la página protegida.

$usuario->iniciar sesión();
redirigir("protegido.php");
}

// Simbolo no valido. Redirigir nuevamente al formulario de inicio de sesión.
redirigir("index.php");
}
Al ejecutar $user->login() se crearán las variables de sesión necesarias, lo que permitirá al usuario permanecer conectado en inicios de sesión posteriores.

El cierre de sesión del sistema se implementa aproximadamente de la misma manera:

índice.php

If(isset($_GET["cerrar sesión"]))(

$usuario = nuevo Usuario();

Si($usuario->loggedIn())(
$usuario->cerrar sesión();
}

Redirigir("index.php");
}
Al final del código, redirigimos al usuario a index.php nuevamente, por lo que se elimina el parámetro ?logout=1 en la URL.

Nuestro archivo index.php también necesitará protección; no queremos que los usuarios que ya han iniciado sesión vean el formulario. Para hacer esto usamos el método $usuario->loggedIn():

índice.php

$usuario = nuevo Usuario();

if($usuario->loggedIn())(
redirigir("protegido.php");
}
Finalmente, veamos cómo puede proteger la página de su sitio web y hacerla accesible solo después de la autorización:

protegido.php

// Para proteger cualquier página PHP en tu sitio, incluye main.php
// y crea un nuevo objeto Usuario. ¡Es así de simple!

require_once "incluye/main.php";

$usuario = nuevo Usuario();

if(!$usuario->loggedIn())(
redirigir("index.php");
}
Después de esta verificación, puede estar seguro de que el usuario ha iniciado sesión correctamente. También tendrá acceso a los datos almacenados en la base de datos como propiedades del objeto $user. Para mostrar el correo electrónico del usuario y su clasificación, utilice el siguiente código:

Haga eco de "Su correo electrónico: ".$usuario->correo electrónico;
echo "Tu rango: ".$usuario->rank();
Aquí ranking() es el método porque la columna de clasificación en la base de datos generalmente contiene números (0 para usuarios regulares y 1 para administradores) y necesitamos convertir todos estos en nombres de clasificación, lo cual se implementa usando este método. Para convertir un usuario estándar en administrador, simplemente edite la entrada del usuario en phpmyadmin (o cualquier otro programa de base de datos). Como administrador, al usuario no se le otorgarán capacidades especiales. Usted mismo tiene derecho a elegir qué derechos conceder a los administradores.

¡Listo!

¡Con esto nuestro sencillo sistema de registro está listo! Puede usarlo en un sitio PHP existente o modernizarlo para adaptarlo a sus propios requisitos.