A veces es necesario cerrarlo del acceso no autorizado PHP página si está haciendo un área cerrada del sitio. Podría ser algún tipo de información oculta para sus clientes o visitantes del sitio, algún tipo de interfaz de administración para usted, etc. Puede pensar en cientos de tareas diferentes que requieren restricción de acceso.

Puede cerrar dicha página de varias formas complementarias:

1. Protección de contraseña (login/contraseña) usando variables $ _SERVIDOR ["PHP_AUTH_USER"] y $ _SERVIDOR ["PHP_AUTH_PW"].
2. Protección por IP dirección del cliente usando una variable $ _SERVIDOR ["REMOTE_ADDR"].
3. Protección por MAC dirección en redes locales (además de protección por IP).

Analicemos primero el primer método, que es el principal. Le permite cerrar el acceso a la página por usuario y contraseña, para que solo las personas puedan acceder. inicio de sesión informado y contraseña. Además, pueden dividirse de acuerdo con este criterio y emitirse en consecuencia. Información miscelánea para todos. Implementado emitiendo campos especiales en el encabezado del protocolo HTTP... Vamos a crear una función autenticación_enviar ():

" ,"

Error de autenticación

" ,"

Póngase en contacto con el administrador para obtener un nombre de usuario y una contraseña.

"," "; salir;);?>

Esta función informa al navegador que se requiere autorización de inicio de sesión y contraseña para acceder. Y también da una página en html para el usuario

" ,"

¡Bienvenidos!

" ,"

Ha iniciado sesión ", $ auth_user" y contraseña ", $ auth_pass,".

" ,"

"; ?>

El código de verificación de inicio de sesión y contraseña no es demasiado complicado en este caso, ya que está implementado para una sola persona. La lógica del trabajo es simple si no hay variable. $ _SERVIDOR ["PHP_AUTH_USER"] y $ _SERVIDOR ["PHP_AUTH_PW"] o sus valores no coinciden con los requeridos, luego llame a la función autenticación_enviar ()... No olvides que al final se llama Salida, por lo que el programa se termina.

La siguiente etapa de protección se implementa mediante filtración. IP las direcciones del cliente que se conecta. Por supuesto, en Internet, muchos proveedores emiten IP direcciones por un tiempo y esta protección es inútil, pero si Viene acerca de las redes locales corporativas, entonces este cheque proporcionará protección adicional.

¡¡¡No se encontró tu IP!!!"; salir;);?>

Aquí en la línea $ ips_permitidas separados por un espacio se indican IP direcciones a las que se permite el acceso. A continuación, obtenemos la matriz usando explotar () y hacer una búsqueda de la dirección del cliente de $ _SERVIDOR ["REMOTE_ADDR"]... Usé la función para buscar matriz_buscar (), ya que incorrectamente, su código implementado en C funcionará algo más rápido de lo que podemos escribir en PHP usando bucles por o para cada... Pero la velocidad no es lo principal aquí :)

Y el último paso de la defensa es comprobar MAC direcciones. Es paranoico y vale la pena usarlo si accedes desde red local y los datos que estás protegiendo son realmente muy importantes. Hasta ahora he implementado esta verificación solo en el sistema. linux, debido a la relativa facilidad de implementación. Pero puedes intentar implementarlo para cualquier otra plataforma. Escribimos la función:

Como ya han entendido los usuarios de Linux, se basa en ARP tabla del sistema, a la que se puede acceder mediante el archivo /proc/red/arp... La función busca las líneas para el requerido IP dirección y lo devuelve MAC la dirección:

Tu IP = 192.168.10.15 y MAC = 00:04:31:E4:F8:37

en sistema ventanas tal vez también hay algunas formas de obtener MAC más sencillo, pero de los que realmente funcionan, esta es la conclusión ARP tablas del sistema con el comando:

C: \ WINDOWS \> arp -a Interfaz: 192.168.10.15 en Interfaz 0x1000003 Dirección IP Dirección física Tipo 192.168.10.1 00-50-22-b0-6a-aa dinámica 192.168.10.2 00-0f-38-68-e9- e8 dinámico 192.168.10.3 00-04-61-9e-26-09 dinámico 192.168.10.5 00-0f-38-6a-b1-18 dinámico

Usted mismo puede implementar la protección basada en esta dirección, si realmente la necesita :) Pero recuerde que si tiene equipos no administrados en su red sin posibilidad de enlace MAC direcciones al puerto, esta protección puede no funcionar, ya que es posible falsificar todos sus datos de identificación utilizados para la protección (login, contraseña, dirección IP y MAC).

Aprenderemos a realizar una autenticación de usuario simple en el sitio. El sitio solo puede tener páginas para usuarios autorizados y funcionarán completamente si les agregamos nuestro bloque de autenticación. Para crearlo, necesita una base de datos MySQL. Puede tener 5 columnas (mínimo), o más si desea agregar información del usuario. Llamemos a la base de datos "Userauth".

Vamos a crear los siguientes campos en él: ID para contar el número de usuarios, UID para un único número de identificación nombre de usuario, nombre de usuario para nombre de usuario, correo electrónico para su dirección Correo electrónico y Contraseña para la contraseña. Puede usar la base de datos que ya tiene para autorizar al usuario, al igual que en el caso de la nueva base de datos, cree la siguiente tabla en ella.

Código MySQL

CREATE TABLE `users` (` ID` int (11) NOT NULL AUTO_INCREMENT, `UID` int (11) NOT NULL, ` Username` text NOT NULL, ` Email` text NOT NULL, ` Password` text NOT NULL, PRIMARY KEY (`ID`)) MOTOR = MyISAM JUEGO DE CARACTERES POR DEFECTO = utf8 AUTO_INCREMENT = 1;

Ahora vamos a crear el archivo "sql.php". Es el responsable de conectarse a la base de datos. Este código, en primer lugar, crea variables para el servidor y el usuario cuando se conecta al servidor. En segundo lugar, seleccionará la base de datos, en este caso "USERAUTH". Este archivo debe estar conectado a "log.php" y "reg.php" para acceder a la base de datos.

Código PHP

// Su nombre de usuario de MySQL$ pase = "redere"; // contraseña $ conn = mysql_connect ($ servidor, $ usuario, $ contraseña); // Conectar al servidor$ db = mysql_select_db ("userauth", $ conn); //seleccionar base de datos si (! $ db) ( // si no se puede seleccionar la base de datos echo "Lo siento, error: (/>"; // Muestra mensaje de error Salida (); // Permite que funcionen otros scripts PHP } ?>

La siguiente es la página de inicio de sesión, llamémosla "login.php". En primer lugar, comprueba los datos introducidos en busca de errores. La página tiene campos para un nombre de usuario, contraseña, un botón de envío y un enlace de registro. Cuando el usuario hace clic en el botón "Iniciar sesión", el código del archivo "log.php" procesará el formulario y luego se iniciará sesión en el sistema.

Código PHP

0) { // si hay errores de sesion$ error = "

"; // Inicia una tabla foreach ($ _SESSION [" ERRMSG "] como $ msg) ( // reconoce cada error$ error. = " "; // escribirlo en una variable) $ error = "

". $ mensaje."

"; // cerrar la mesa unset ($ _SESSION ["ERRMSG"]); // eliminar sesión } ?>

Nombre de usuario
Contraseña
	registro

Luego escribimos un script para iniciar sesión en el sistema. Llamémoslo "log.php". Tiene una función para limpiar los datos de entrada de la inyección de SQL que pueden estropear su secuencia de comandos. En segundo lugar, recibe los datos del formulario y los valida. Si la entrada es correcta, el script envía al usuario a la página de usuarios autorizados; si no, establece errores y envía al usuario a la página de inicio de sesión.

Código PHP

// iniciar sesion para grabar función Fix ($ str) (// borrar campos $ str = recortar ($ str); if (get_magic_quotes_gpc ()) ($ str = stripslashes ($ str);) // matriz para almacenar errores$ errflag = falso; // indicador de error $ nombreusuario = Fix ($ _ POST ["nombreusuario"]); //Nombre de usuario$ contraseña = Fix ($ _ POST ["contraseña"]); // contraseña) //verificar contraseña if ($ contraseña == "") ($ errmsg = "Falta la contraseña"; // error $ errflag = true; // levanta la bandera en caso de error) // si se establece el indicador de error, se dirige de nuevo al formulario de registro // registrar errores session_write_close (); // Cerrar la sesión // redirigir Salida (); ) // consulta a la base de datos$ qry = "SELECT * FROM` usuarios` WHERE `Nombre de usuario` =" $ nombre de usuario "Y` Contraseña` = "". md5 ($ contraseña). "" "; $ resultado = mysql_query ($ consulta); // verifique si la solicitud fue exitosa (si hay datos en ella) if (mysql_num_rows ($ resultado) == 1) (while ($ fila = mysql_fetch_assoc ($ resultado)) ($ _SESSION ["UID"] = $ fila ["UID"]; // obtener el UID de la base de datos y ponerlo en la sesión$ _SESSION ["NOMBRE DE USUARIO"] = $ nombre de usuario; // establece si el nombre de usuario coincide con el de la sesión session_write_close (); // Cerrar la sesión encabezado ("ubicación: miembro.php"); // redirigir)) else ($ _SESSION ["ERRMSG"] = "Usuario o contraseña no válidos"; // error session_write_close (); // Cerrar la sesión encabezado ("ubicación: login.php"); // redirigir Salida (); )?>

Vamos a crear una página de registro, llámela "registrar.php". Es similar a la página de inicio de sesión, solo que tiene algunos campos más y, en lugar de un enlace de registro, un enlace a login.php en caso de que el usuario ya tenga una cuenta.

Código PHP

0) { // si hay errores de sesion$ error = "

"; // inicio de la tabla foreach ($ _SESSION [" ERRMSG "] como $ msg) ( // establece cada error$ error. = " "; // escribirlos en una variable) $ error = "

". $ mensaje."

"; // final de la tabla sin establecer ($ _SESSION [" ERRMSG "]); // destruir la sesion } ?>

Nombre de usuario
Correo electrónico
Contraseña
Repite la contraseña
	tengo una cuenta

Ahora vamos a crear un script de registro en el archivo "reg.php". Incluirá "sql.php" para conectarse a la base de datos. Utiliza la misma función que en el script de inicio de sesión para borrar el campo de entrada. Las variables se establecen para posibles errores... Lo siguiente es una función para crear un identificador único que nunca se ha proporcionado antes. Luego, los datos se recuperan del formulario de registro y se validan. Comprueba que la dirección de correo electrónico esté en el formato correcto y que la contraseña se haya vuelto a introducir correctamente. Luego, el script verifica si hay un usuario con el mismo nombre en la base de datos y, de ser así, informa un error. Finalmente, el código agrega al usuario a la base de datos.

Código PHP

// iniciar sesion para grabar función Fix ($ str) (// borrar campos $ str = @trim ($ str); if (get_magic_quotes_gpc ()) ($ str = stripslashes ($ str);) devolver mysql_real_escape_string($ cadena); ) $ errmsg = matriz (); // matriz para almacenar errores$ errflag = falso; // indicador de error $ UID = "12323543534523453451465685454"; // ID único $ nombre de usuario = Fix ($ _ POST ["nombre de usuario"]); //Nombre de usuario$ correo = $ _POST ["correo"]; // Email $ contraseña = Fix ($ _ POST ["password"]); // contraseña $ rpassword = Fix ($ _ POST ["rpassword"]); // repetir contraseña // comprobar nombre de usuario if ($ nombreusuario == "") ($ errmsg = "Falta el nombre de usuario"; // error $ errflag = true; // levanta la bandera en caso de error) // verifique el correo electrónico si (! eregi ("^ [_ a-z0-9 -] + (\. [_ a-z0-9 -] +) * @ + (\. +) * (\. (2 ,3 )) $ ", $ email)) (// debe coincidir con el formato: [correo electrónico protegido]$ errmsg = "Correo electrónico inválido"; // error $ errflag = verdadero; // levanta la bandera en caso de error } //verificar contraseña if ($ contraseña == "") ($ errmsg = "Falta contraseña"; // error $ errflag = true; // levanta la bandera en caso de error } // comprobar si se repite la contraseña if ($ rpassword == "") ($ errmsg = "Falta la contraseña repetida"; // error $ errflag = true; // levanta la bandera en caso de error } // comprobar si la contraseña es válida if (strcmp ($ contraseña, $ rpassword)! = 0) ($ errmsg = "Las contraseñas no coinciden"; // error $ errflag = true; // levanta la bandera en caso de error } // comprobar si el nombre de usuario es libre if ($ nombre de usuario! = "") ($ qry = "SELECT * FROM` usuarios` WHERE `Username` =" $ nombre de usuario ""; // consulta MySQL $ resultado = mysql_query ($ qry); if ($ resultado) ( if (mysql_num_rows ($resultado)> 0) ( // si el nombre ya está en uso$ errmsg = "Nombre de usuario ya en uso"; // mensaje de error$ errflag = verdadero; // levanta la bandera en caso de error) mysql_free_result ($resultado); )) // si los datos no pasaron la validación, se dirige de nuevo al formulario de registro if ($ errflag) ($ _SESSION ["ERRMSG"] = $ errmsg; // mensaje de error session_write_close (); // Cerrar la sesión encabezado ("ubicación: registro.php"); // redirigir Salida (); ) // agregar datos a la base de datos$ qry = "INSERT INTO` userauth`.`users` (`UID`,` Username`, `Email`,` Password`) VALORES ("$ UID", "$ nombre de usuario", "$ email", "". md5 ($ contraseña). "") "; $ resultado = mysql_query ($ consulta); // comprobar si la solicitud de adición fue exitosa if ($resultado) (echo "Gracias por registrarse,". $ nombre de usuario. ". Inicie sesión aquí"; salir ();) else (morir ("Error, por favor contactar más tarde");)?>

También debe crear un script para cerrar la sesión del usuario en el sistema. Finaliza la sesión del usuario con el ID y el nombre únicos proporcionados y, a continuación, redirige al usuario a la página de inicio de sesión.

Código PHP

Finalmente, el script "auth.php" se puede usar para hacer que las páginas estén disponibles solo para usuarios autorizados. Comprueba los datos de inicio de sesión y, si son correctos, permite al usuario ver las páginas y, en caso contrario, solicita iniciar sesión. Además, si alguien intenta hackear el sitio mediante la creación de una de las sesiones, se interrumpirá, como en el caso general.

Código PHP

Una de las condiciones en el código anterior es el tema de la pregunta en.

El siguiente código debe insertarse en la página para usuarios autorizados, se llama, por ejemplo, "member.php", pero el tuyo se puede llamar como quieras.

Código PHP

Se le permite acceder a esta página. Desconectarse ( )

¡La autenticación de usuario está lista!

Este artículo está desactualizado.

Este artículo se escribió para el servicio de alojamiento compartido, que está obsoleto a partir del 1 de junio de 2019.

El servicio de alojamiento actual se puede solicitar en nuestro sitio web

Autorización HTTP usando PHP

Este artículo ha cubierto cómo crear una autorización HTTP con usando PHP, que te permitirá cerrar cualquier sección del sitio, por ejemplo, la parte administrativa.

Para la autenticación, HTTP proporciona un mecanismo simple de desafío-respuesta que puede ser utilizado por un servidor para desafiar la solicitud de un cliente y por un cliente para proporcionar información de autenticación. El esquema de autorización más común es " esquema básico autenticación "(Esquema de autenticación básica).

El esquema de autenticación "básico" se basa en el hecho de que el agente de usuario (navegador) debe autenticarse a sí mismo con una ID de usuario (nombre de usuario) y una contraseña para cada reino seguro (realm). El servidor atenderá la solicitud si puede verificar que el ID de usuario y la contraseña son correctos para un área segura dada. No se proporcionan parámetros de identificación adicionales en este esquema.

Al recibir una solicitud de identificación, el servidor responde con un desafío similar al siguiente:

WWW-Authenticate: Reino básico = "Área restringida" HTTP / 1.1 401 No autorizado

Aquí "Área restringida" es una cadena asignada por el servidor que identifica el área protegida de la URI solicitada (Solicitud-URI). Discurso lenguaje sencillo- el nombre del área protegida.

A continuación, para obtener los derechos de acceso, el agente de usuario (navegador) envía el ID de usuario (nombre de usuario) y la contraseña al servidor, separados por dos puntos (":"), dentro de una cadena de recomendaciones codificadas en base64 (credenciales):

Credenciales básicas = cookie básica "básica"

Aquí

• basic-cookie - cadena codificada en base64 que contiene el pase de usuario
• user-pass - una cadena como "userid: contraseña"
• ID de usuario: texto que no contiene caracteres ":"
• contraseña - texto

Tenga en cuenta que tanto el nombre de usuario como la contraseña distinguen entre mayúsculas y minúsculas. Es decir, por ejemplo, Usuario y usuario son dos nombres de usuario diferentes.

Autorización HTTP y PHP

Es posible que ya haya utilizado el esquema de autorización básico junto con PHP y sabe que la esencia del método se reduce a obtener las variables PHP_AUTH_USER y PHP_AUTH_PW del servidor web, que determinan el nombre de usuario y la contraseña, respectivamente, y de alguna manera procesarlas internamente. PHP -script. Pero tenga en cuenta que este método solo es efectivo cuando PHP funciona como un módulo del servidor web Apache. PHP se ejecuta en nuestro hosting en modo CGI/FastCGI y el método descrito anteriormente no funcionará, ya que las variables PHP_AUTH_USER y PHP_AUTH_PW no se pasarán dentro del script.

Sin embargo, hay una manera de eludir esta limitación y pasar los valores de nombre de usuario y contraseña que el usuario ingresa al script PHP. Para estos fines se utiliza mod_rewrite, un módulo de servidor web Apache. Las reglas que usaremos son las siguientes:

RewriteCond% (HTTP: Autorización) ^ Básico.* RewriteRule (.*) Index.php?Autorización =% (HTTP: Autorización)

Al solicitar a través de HTTP al archivo sitename.ru/www/index.php, Esta regla pasará el contenido del campo Autorización no vacío al parámetro de autorización mediante una solicitud GET. Si usamos PHP para ver el contenido de la variable $ _GET ["autorización"], veremos solo las credenciales básicas descritas anteriormente, una línea del formulario:

Preg_match ("/ ^ Basic \ s + (. *) $ / I", $ _GET ["autorización"], $ user_pass); list ($usuario, $pase) = explotar (":", base64_decode ($usuario_pase));

Por lo tanto, obtenemos dos variables: $ usuario y $ pase, que contienen el nombre de usuario y la contraseña, respectivamente. Ahora, como se mencionó anteriormente, solo necesitan procesarse de alguna manera, por ejemplo, en comparación con variables similares de una base de datos o de un archivo con cuentas de usuario.

Conclusión

El método discutido en este artículo funcionará con éxito no solo en nuestro alojamiento, sino también en cualquier lugar donde PHP se ejecute en modo CGI / FastCGI y Apache + mod_rewrite se use como servidor web.

Puede encontrar el código fuente de los ejemplos de trabajo en el Apéndice de este artículo.

Apéndice. Textos fuente del guion

Fuente del archivo htaccess

RewriteEngine en RewriteBase/RewriteCond% (HTTP: Autorización) ^ Básico.* RewriteRule (.*) Index.php?Autorización =% (HTTP: Autorización)

Fuente de secuencia de comandos PHP

$ autenticado = 0; if (isset ($ _ GET ["autorización"])) (if (preg_match ("/ ^ Basic \ s + (. *) $ / i", $ _GET ["autorización"], $ user_pass)) (lista ( $ usuario, $ pase) = explotar (":", base64_decode ($ usuario_contraseña)); // Comprobando la exactitud de los detalles de acceso ingresados ​​si ($ usuario == "usuario" && $ pase == "contraseña") ($ autenticado = 1;) )) if ($ autenticado) (// Autenticación exitosa echo ("usuario:". $ usuario. "
pass: ". $ pass);) else (header (" WWW-Authenticate: Basic realm = "Restricted Area" "); header (" HTTP / 1.1 401 Unauthorized "); echo (" Acceso denegado. ");) Literalmente ayer decidí empezar a desarrollar cuenta personal un sitio sin nombre. Surgió una pregunta ante mí sobre apariencia formulario de inicio de sesión, francamente, no quería diseñar el formulario, hacer información sobre herramientas y, en general, prestar mucha atención al formulario. Me apresuré tontamente a buscar soluciones preparadas, vi suficientes formas de mal gusto. Estaba pensando en encontrar algún componente listo para usar, una extensión lista para usar, pero la mayoría me decepcionó. Deambulando por los foros, me pareció interesante jugar la carta con la Autenticación HTTP: Básica. Fui a leer el manual, antes no estaba lo suficientemente consciente de Por aquí... Además, comenzaron los problemas.

No había adónde ir, recorrí la red en busca de sitios que se encargaran de generar formularios, códigos, estilos. Mis intentos de facilitarme las cosas fueron en vano. La salida no es genial, comencé a resolver el problema. En un momento traté de estropear una solución con .htaccess, encontré esto.

RewriteCond% (HTTP: Autorización) ^ Básico.* RewriteRule (.*) Index.php?Autorización =% (HTTP: Autorización)

Por desgracia, tengo problemas con Joomla, ya funciona bastante bien en .htaccess, y aquí estoy con mi código. Habiéndome tomado el tiempo de clasificar varias combinaciones, acepté que no volvería a escribir .htaccess. Desde el principio, el código era muy crudo, tan crudo que simplemente lo copié y pegué.

Hola ($ _SERVER ["PHP_AUTH_USER"]).

"; eco"

Ingresó la contraseña ($ _SERVER ["PHP_AUTH_PW"]).

"; } ?>

Funciona muy bien, y mi objetivo era implementar la autorización utilizando las palabras de código ya existentes que se encuentran en la tabla.

get ("usuario") === nulo) ($ db = JFactory :: getDbo (); $ consulta = $ db-> getQuery (true); $ consulta-> select ("*"); $ consulta-> from ("#__beda_users"); $consulta->where("codeword=".$consulta->cita ($_SERVIDOR ["PHP_AUTH_PW"])); if ($res = $db->setQuery($consulta) - > loadAssoc()) ($ sesión-> set ("usuario", $ res);) else (header ("WWW-Authenticate: Basic realm =" My Realm ""); header ("HTTP/1.0 401 Unauthorized") ; )) else (// Deberíamos ir aquí))?>

Funciona, cambian los valores, se crea la sesión. Maravilloso, pero en el caso de un clic para cancelar, los valores no importa lo que canceló, después de actualizar la página, regresan al lugar. Decidí que debería luchar contra esto desarmado... Agregué una línea.

If ($ res = $ db-> setQuery ($ consulta) -> loadAssoc()) ($ sesión-> set ("usuario", $ res);) else (unset ($ _ SERVIDOR ["PHP_AUTH_USER"], $ _SERVER ["PHP_AUTH_PW"]); encabezado ("WWW-Authenticate: Basic realm =" My Realm ""); encabezado ("HTTP / 1.0 401 No autorizado");)

Traté de hacer frente a estas variables, pero me adentraba más y más en la nada. Arreglado y comprobando la existencia de la sesión, pero en vano. Además, necesitaba hacer el final de la sesión, lo que, según los miembros del foro, es difícilmente posible. Llegué al fondo de la verdad de usar una dirección como inicio de sesión: [correo electrónico protegido]/. Genial, las variables han cambiado. $ _SERVIDOR ["PHP_AUTH_USER"], $ _SERVIDOR ["PHP_AUTH_PW"]... Por desgracia, esta no se convirtió en mi decisión final, porque después del final de la sesión, el tiempo $ _SERVIDOR ["PHP_AUTH_USER"], $ _SERVIDOR ["PHP_AUTH_PW"] siguió actuando. Así como después de forzar $ sesión-> establecer ("usuario", nulo). Estaba fuera de mí de ira, pero sabía que no me perdonaría si me defraudaba. Escribí una condición separada para verificar el cierre de sesión.

If ($ _ SERVIDOR ["PHP_AUTH_USER"] == "cerrar sesión") ($ sesión-> establecer ("usuario", nulo); encabezado ("Actualizar: 0; URL =");) if (! Isset ($ _ SERVIDOR [ "PHP_AUTH_PW"])) (encabezado ("WWW-Authenticate: Basic realm =" My Realm ""); encabezado ("HTTP / 1.0 401 No autorizado");) más (// Si se encuentra una palabra clave adecuada, cree una sesión if ($ sesión-> get ("usuario") === null) ($ db = JFactory :: getDbo (); $ consulta = $ db-> getQuery (true); $ consulta-> select ("* "); $ consulta-> from ("#__ beda_users"); $ consulta-> where ("palabra clave=". $ consulta-> cotización ($ _ SERVIDOR ["PHP_AUTH_PW"])); if ($ res = $ db-> setQuery ($consulta) -> loadAssoc()) ($sesión->set("usuario", $res);) else (unset ($_SERVER ["PHP_AUTH_USER"], $_SERVER ["PHP_AUTH_PW"] ); header ("WWW -Authenticate: Basic realm = "My Realm" "); header (" HTTP / 1.0 401 Unauthorized ");)) else (// Deberíamos ir aquí))

La condición funcionó, pero después de recargar la página, cuando aparece una ventana que le pide que ingrese Nombre de usuario y contraseña, los aceptó, pero después de actualizar la página, me pidió que volviera a ingresar la contraseña, haga clic en "Cancelar", $ _SERVER ["PHP_AUTH_USER"] cerrará la sesión. Actualizaré los valores, los asignará. Y al hacer clic en cancelar devolverá los valores anteriores. Problema.

Al final, la solución final se ve así.

$ sesión = JFactory :: getSession (); función http_auth ($ sesión) ($ sesión-> establecer ("usuario", nulo); deshabilitar ($ _ SERVIDOR ["PHP_AUTH_PW"], $ _SERVER ["PHP_AUTH_USER"]); encabezado ("WWW-Authenticate: Basic realm = "Auth""); header ("HTTP/1.0 401 Unauthorized");) if ($_SERVER ["PHP_AUTH_USER"] == "logout") ($ session-> set ("user", null); header( "Actualizar: 0; URL = ");) if ($ sesión-> get ("usuario") === nulo) (if (! Isset ($ _ SERVER [" PHP_AUTH_PW "])) (http_auth ($ sesión) ;) else ($ pw = $ _SERVER ["PHP_AUTH_PW"]; $ db = JFactory :: getDbo (); $ consulta = $ db-> getQuery (true); $ consulta-> select ("*"); $ consulta -> from ("#__beda_users"); $ consulta-> where ("palabra clave =". $ consulta-> cita ($ pw)); if ($ res = $ db-> setQuery ($ consulta) -> loadAssoc ( )) ( $ sesión-> set ("usuario", $ res);) else (http_auth ($ session);))) else (if (! isset ($ _ SERVIDOR ["PHP_AUTH_PW"])) (http_auth ($ sesión);) )

Para enviar un mensaje de "Autenticación requerida" al navegador del cliente, que a su vez conducirá a un cuadro de diálogo para ingresar un nombre de usuario y contraseña. Después de que el cliente haya ingresado su nombre de usuario y contraseña, se llamará nuevamente al script, pero esta vez con las variables predefinidas PHP_AUTH_USER, PHP_AUTH_PW y AUTH_TYPE, que contienen respectivamente el nombre de usuario, la contraseña y el tipo de autenticación. Estas variables se pueden encontrar en las matrices $ _SERVER y $ HTTP_SERVER_VARS. Actualmente, solo se admite la autenticación "básica". También puedes leer más Descripción detallada funciones encabezado () .

Un ejemplo de un fragmento de secuencia de comandos que obliga al cliente a iniciar sesión para ver la página:

Ejemplo de autenticación HTTP

if (! isset ($ _ SERVIDOR ["PHP_AUTH_USER"])) (
encabezado ( "WWW-Authenticate: Reino básico =" Mi Reino "");

eco "El texto enviado en caso de que
si el usuario presionó el botón Cancelar ";
Salida;
) demás (
eco"

Hola ($ _SERVER ["PHP_AUTH_USER"]).

" ;
eco "

Ingresó la contraseña ($ _SERVER ["PHP_AUTH_PW"]).

" ;
}
?>

Nota de compatibilidad: Tenga especial cuidado al especificar encabezados HTTP. Para garantizar la máxima compatibilidad con el numero mas grande diferentes clientes, la palabra "Básico" debe escribirse con una "B" mayúscula, la región (reino) debe estar encerrada entre comillas dobles (¡no simples!), y exactamente un espacio debe preceder al código 401 En el título HTTP / 1.0 401 .

En lugar de simplemente mostrar las variables PHP_AUTH_USER y PHP_AUTH_PW en la pantalla, es posible que desee verificar que sean correctas. Para ello, utilice una consulta de base de datos o busque un usuario en un archivo dbm.

Puedes observar las características del navegador explorador de Internet... Es muy exigente con el parámetro de los encabezados transmitidos. Especificación de un título WWW-Autenticar antes de enviar el estado HTTP / 1.0 401 es un pequeño truco.

Desde PHP 4.3.0, para evitar que alguien escriba un script para revelar la contraseña de una página que usa autenticación externa, las variables PHP_AUTH no se establecen si esta página usa autenticación externa y está configurado en modo seguro. Independientemente, la variable REMOTE_USER se puede usar para autenticar a un usuario autenticado externamente. Por lo tanto, siempre puede usar la variable $ _SERVER ["REMOTE_USER"] .

Nota: PHP usa la directiva AuthType para indicar si se usa o no la autenticación externa.

Cabe señalar que todo lo anterior no impide el robo de contraseñas de páginas que requieran autorización por parte de alguien que controle páginas no autorizadas ubicadas en el mismo servidor.

Y Netscape Navigator e Internet Explorer borran la memoria caché de autenticación de la ventana actual para el dominio dado cuando se recuperan del servidor. Esto se puede usar para obligar a un usuario a cerrar sesión y volver a mostrar el cuadro de diálogo de nombre de usuario y contraseña. Algunos desarrolladores usan esto para limitar la autorización por tiempo o para proporcionar un botón Cerrar sesión.

Ejemplo de autenticación forzada de HTTP nueva pareja Contraseña de inicio de sesión

función autenticar () (
encabezado ( "WWW-Authenticate: Reino básico =" Sistema de autenticación de prueba "");
encabezado ("HTTP / 1.0 401 no autorizado");
eco "Debe ingresar el nombre de usuario y la contraseña correctos para obtener acceso al recurso \ n";
Salida;
}

Si (! Isset ($ _ SERVIDOR ["PHP_AUTH_USER"]) ||
($ _POST ["Visto antes"] == 1 && $ _POST ["OldAuth"] == $ _SERVER ["PHP_AUTH_USER"])) (
autenticar ();
}
demás (
eco"

Bienvenido: ($ _SERVER ["PHP_AUTH_USER"])
" ;
eco "Inicio de sesión anterior: ($ _REQUEST [" OldAuth "])";
eco "

\ n ";
eco "\ n ";
eco "\ n ";
eco "\ n ";
eco "

\n";
}
?>

Los estándares de autenticación básica de HTTP no exigen este comportamiento, por lo tanto, no debe depender de él. Como han demostrado las pruebas, el navegador Lynx no borra el caché de autorización cuando recibe un estado 401 del servidor, y al hacer clic en "Atrás" y luego en "Adelante" es posible abrir dicha página, siempre que los atributos de autorización requeridos No han cambiado. Sin embargo, el usuario puede presionar la tecla "_" para borrar el caché de autenticación.

También hay que señalar que antes Versiones de PHP 4.3.3, la autenticación HTTP no funcionaba en servidores bajo administrado por Microsoft IIS si PHP se instaló como un módulo CGI debido a alguna limitación de IIS. Para que funcione correctamente en PHP 4.3.3+, debe editar la configuración configurando IIS llamado "Seguridad de Directorio". Haga clic en "Editar" y configure la opción "Acceso anónimo", todos los demás campos deben estar desmarcados.

Otra limitación si está utilizando IIS sobre ISAPI: las variables PHP_AUTH_ * no están definidas, pero al mismo tiempo está disponible la variable HTTP_AUTHORIZATION. Código de ejemplo que podría usar: lista ($ usuario, $ pw) = explotar (":", base64_decode (substr ($ _ SERVIDOR ["HTTP_AUTHORIZATION"], 6)));

Nota sobre IIS :: Para que la autenticación HTTP funcione correctamente en IIS, la opción cgi.rfc2616_headers en la configuración de PHP debe establecerse en 0 (el valor predeterminado).

Atención: En caso de que se utilice el modo protegido, el UID del script actual se agregará a la parte del dominio del encabezado WWW-Authenticate.

<<< Назад

Contenido

Adelante >>>

Si tiene más preguntas o algo no está claro, bienvenido a nuestro