PHP
INTALENTIA, PHP
2
INDICE
TEMA 1: INTRODUCCIÓN Introducción a PHP Instalación y configuración de Apache Instalación y configuración de PHP Recursos de PHP
TEMA 2: LENGUAJE PHP BÁSICO Sintaxis básica Tipos de datos Variables Constantes Expresiones y operadores Estructuras de control Funciones Tablas Bibliotecas de funciones
TEMA 3: FORMULARIOS Acceso a formularios HTML desde PHP El formulario de PHP Subida de ficheros al servidor Validación de los datos de un formulario
INTALENTIA, PHP
3
TEMA 4: ACCESO A BASES DE DATOS MYSQL EN PHP
Bases de datos en la Web Instalación y configuración de MySQL Herramientas de administración: phpMyAdmin Lenguaje SQL Funciones de PHP para el acceso a bases de datos MySQL Ejercicios Consulta avanzada de tablas
TEMA 5: SESIONES Introducción Manejo de sesiones Autenticación de usuarios
TEMA 6: SEGURIDAD Introducción Variables globales Nombres de ficheros Subida de ficheros Bibliotecas Formularios
INTALENTIA, PHP
4
TEMA 1: Introducción
Introducción a PHP.
Lenguajes de script
• PHP es un lenguaje de script del lado del servidor. Otros lenguajes similares son ASP, JSP o ColdFusion.
• Los scripts PHP están incrustados en los documentos HTML y el servidor los interpreta y ejecuta antes de servir las páginas al cliente.
• El cliente no ve el código PHP sino los resultados que produce.
¿Cómo funciona PHP?
Internet
<P> Hola, Ana </P>
Servidor Web
Página HTML
Cliente (navegador)
Página HTML
INTALENTIA, PHP
5
Internet
Para conocer un poco más PHP, comenzaremos por la persona que le dio vida, Rasmus Lerdorf, quien lo creó para uso personal en 1994.
Sus siglas significan: PHP = Personal Hypertext Processor. La Versión actual es PHP 5.
Es un módulo que se añade al servidor web y fue concebido inicialmente para Apache*.
¿Por qué usar PHP?
Usamos PHP por sus ventajas, ya que es potente, fácil de aprender, de libre distribución, permite el acceso a bases de datos y otras funcionalidades orientadas a la red. Además dispone de abundante soporte en la Web.
Dentro de sus utilidades encontramos:
• Herramientas para la gestión de MySQL, como PHPMyAdmin (www.phpmyadmin.net)
• Editores de PHP, como DevPHP (www.sourceforge.net) o Eclipse (www.eclipse.org)
• Manuales de PHP y MySQL
*Apache es un servidor web HTTP de código abierto, para plataformas Unix (BSD, GNU/Linux, etc.), Microsoft Windows, Macintosh y otras, que implementa el protocolo HTTP/1.1 y la noción de sitio virtual.
Página PHP Página HTML
Intérprete PHP
<?PHP $nombre = "Ana"; print ("<P>Hola, $nombre</P>"); ?>
<P>Hola, Ana</P>
Cliente (navegador)
Página HTML
INTALENTIA, PHP
6
Instalación y configuración de Apache
Pasos que dar para la instalación de Apache.
1. Descargar:
1.1 Conectar a www.apache.org
1.2 Seleccionar HTTP Server
1.3 Elegir la versión estable más reciente
1.4 Apache 2: versión 2.0.55
1.5 Apache: versión 1.3.34
1.6 Elegir la versión 2.0.55 y descargarla a una carpeta temporal
2. Instalar:
2.1 Ejecutar el archivo bajado y seguir las instrucciones
2.2 Introducir la información requerida: Network Domain: localhost,
Server name: localhost, Administrator’s Email Address:
webmaster@localhost
2.3 Instalar como servicio (no disponible en W9X)
2.4 Seleccionar instalación típica e instalar en la carpeta por defecto,
c:\Archivos de Programa\ApacheGroup\
2.5 Se crea el grupo de programas Apache HTTP Server y la carpeta
c:\Archivos de Programa\ApacheGroup\Apache2
2.6 Arrancar el servidor: Inicio > Programas > Apache HTTP Server
2.0.55>Control Apache Server > Start
2.7 Ejecutar el navegador y cargar http://localhost/
2.8 Si sale la página de inicio del servidor, la instalación habrá sido
correcta
INTALENTIA, PHP
7
3. Configuración:
3.1 Archivo de configuración: httpd.conf, situado en c:\Archivos de
Programa\Apache Group\Apache2\conf
3.2 Ejecutar Inicio > Programas > Apache HTTP Server 2.0.55 > Configure
Apache Server > Edit the Apache httpd.conf Configuration File
3.3 Cambios: DocumentRoot -> c:/htdocs (por defecto es c:/Archivos de
Programa/Apache Group/Apache2/htdocs). <Directory “c:/htdocs”>.
Añadir index.php a DirectoryIndex
3.4 Crear carpeta c:\htdocs
3.5 Crear una página de inicio o copiar los ficheros de
c:/Archivos de Programa/Apache
Group/Apache2/htdocs
3.6 Reiniciar apache para leer la nueva configuración
Instalación y configuración de PHP
Pasos que se deben dar para la instalación y configuración de PHP:
1. Descargar:
1.1 Conectar a www.php.net
1.2 Seleccionar downloads, windows binaries
1.3 Elegir la versión estable actual, PHP 5.1.2
1.4 Hay varias posibilidades: seleccionar PHP 5.1.2 zip package
1.5 Elegir un mirror (España: rediris)
1.6 Descargar a una carpeta temporal
INTALENTIA, PHP
8
2. Descomprimir:
2.1 Extraer a la carpeta c:\
2.2 Se crea la carpeta c:\php-5.1.2-Win32. Renombrar a c:\php
3. Configurar:
3.1 Seguir las instrucciones del archivo install.txt
3.2 Copiar el archivo de configuración php.ini-recommended como php.ini en la carpeta del sistema (habitualmente c:\windows)
3.3 Editarlo y cambiar lo siguiente: doc_root = c:\htdocs y extension_dir = c:\php\ext
3.4 Editar httpd.conf y añadir las líneas siguientes: LoadModule php5_module c:/php/php5apache2.dll y AddType application/x-httpd-php .php
3.5 Reiniciar Apache
4. Probar:
4.1 Crear una página PHP de prueba y cargarla con el navegador
4.2 Ejemplo: prueba.php en c:\htdocs\
4.3 Ejecutar el navegador y teclear la URL http://localhost/prueba.php
<?PHP phpinfo(); ?>
INTALENTIA, PHP
9
Instalación y configuración de PHP
Instalación del editor Dev-PHP:
1. Descargar de http://sourceforge.net/projects/devphp 2. Ejecutar archivo descargado y seguir las instrucciones. Tomar los valores por
defecto 3. Dev-PHP queda configurado como el editor predeterminado para los archivos
PHP
Instalación del entorno de programación Eclipse
1. Eclipse es un entorno de programación que se puede utilizar para desarrollar aplicaciones en PHP. Para ello es preciso instalar un plugin denominado PHPeclipse
2. Los pasos para instalar Eclipse y PHPeclipse son: Descargar Eclipse de http://www.eclipse.org/downloads, Descomprimir archivo ZIP en la carpeta donde se desee ubicar el programa (no precisa instalación), Descargar PHPeclipse de http://www.phpeclipse.de, Descomprimir el archivo descargado en una ubicación temporal. Se crean dos carpetas, features y plugins Copiar el contenido de la carpeta features dentro de la carpeta features situada bajo la carpeta de Eclipse, Copiar el contenido de la carpeta plugins dentro de la carpeta plugins situada bajo la carpeta de Eclipse.
3. Documentación: Manuales en www.apache.org, www.php.net, www.mysql.com
4. Tutoriales, scripts, artículos: www.phpbuilder.com, www.codewalkers.com, www.devshed.com, www.melonfire.com
*NOTA
El editor Dev-PHP ocupa muy poco espacio y es muy simple de manejar. El entorno Eclipse (véase a continuación) ocupa bastante más espacio y consume más recursos del sistema, pero ofrece una potencia muy superior para el desarrollo de aplicaciones en PHP
INTALENTIA, PHP
10
TEMA 2: LENGUAJE PHP BÁSICO
Sintaxis básica
PHP es sensible a las mayúsculas ¿Cómo se incrusta en la página web?
<?PHP ... ?>
recomendado, siempre disponible <?= expresión ?>
equivale a <? echo expresión ?>
Las instrucciones se separan con un ; como en C. La marca final ?> implica un ;
Comentarios: como en C, /* … */ y //
Para imprimir: echo y print
echo: muestra una o más cadenas
echo cadena1 [, cadena2…]; // no es una función
echo “Hola mundo”;
echo “Hola “, “mundo”;
print: muestra una cadena
print cadena; // no es una función
print “Hola mundo”;
print “Hola “ . “mundo”;
INTALENTIA, PHP
11
Para poder ver más claro todo lo anterior expondremos un ejemplo práctico:
<HTML>
<HEAD>
<TITLE>Mi primer programa en PHP</TITLE>
</HEAD>
<BODY>
<?PHP
print (“<P>Hola mundo</P>”);
?>
</BODY>
</HTML>
Uso de \n para generar código HTML legible
a) Sin \n
Código PHP
Código HTML
Salida
Print (“<P> Párrafo 1 </P>”)
Print (“<P> Párrafo 2 </P>”)
<P>Párrafo 1 </P><P> Párrafo 2</P>
Párrafo 1
Párrafo 2
INTALENTIA, PHP
12
b) Con \n
Código PHP
Código HTML
Salida
Inclusión de ficheros externos: include() y require()
Ambos incluyen y evalúan el fichero especificado pero la diferencia es que en caso de error include() produce un warning y require() un error fatal. Se usará require() si al producirse un error debe interrumpirse la carga de la página
Ejemplo:
<HTML>
<HEAD>
<TITLE>Título</TITLE>
<?PHP
// Incluir bibliotecas de funciones
require ("conecta.php");
require ("fecha.php");
require ("cadena.php");
require ("globals.php");
<P>Párrafo 1 </P>
<P> Párrafo 2</P>
Párrafo 1
Párrafo 2
Print (“<P> Párrafo 1 </P>\n”)
Print (“<P> Párrafo 2 </P>\n”)
INTALENTIA, PHP
13
?>
</HEAD>
<BODY>
<?PHP
include ("cabecera.html");
?>
// Código HTML + PHP
. . .
<?PHP
include ("pie.html");
?>
</BODY>
</HTML>
Tipos de datos
PHP soporta 8 tipos de datos primitivos:
Tipos escalares: boolean, integer, double, string Tipos compuestos: array, object Tipos especiales: resource, NULL
El tipo de una variable no se suele especificar. Se decide en tiempo de ejecución en función del contexto y puede variar. Funciones de interés:
La función gettype() devuelve el tipo de una variable Las funciones is_type comprueban si una variable es de un tipo dado:
is_array(), is_bool(), is_float(), is_integer(), is_null(), is_numeric(), is_object(), is_resource(), is_scalar(), is_string()
INTALENTIA, PHP
14
La función var_dump() muestra el tipo y el valor de una variable. Es especialmente interesante con los arrays.
Tipo integer (números enteros): 27, -5, 0 Tipo double (números reales): 1.234, -5.33 Tipo boolean (lógico): Valores: true, false (insensibles a las mayúsculas). El 0 y la cadena vacía tienen valor false
Tipo string: Las cadenas se encierran entre comillas simples o dobles:
‘simples’: admite los caracteres de escape \’ (comilla simple) y \\ (barra). Las variables NO se expanden
“dobles”: admite más caracteres de escape, como \n,\r, \t, \\, \$, \”. Los nombres de variables SÍ se expanden
Ejemplos:
$a = 9;
print ‘a vale $a\n’;
// muestra a vale $a\n
print “a vale $a\n”;
// muestra a vale 9 y avanza una línea
print “<IMG SRC=‘logo.gif’>”;
// muestra <IMG SRC=‘logo.gif’>
print “<IMG SRC=\”logo.gif\”>”;
// muestra <IMG SRC=“logo.gif”>
Acceso a un carácter de la cadena: La forma es $inicial = $nombre{0};
INTALENTIA, PHP
15
Variables
Entre las características de las variables podemos encontrar: Siempre van precedidas de un $ El nombre es sensible a las mayúsculas Comienzan por letra o subrayado, seguido de letras, números o subrayado Variables predefinidas: $GLOBALS, $_SERVER, $_GET, $_POST, $_COOKIES, $_FILES, $_ENV, $_REQUEST, $_SESSION Ámbito: globales al fichero (excepto funciones) o locales a una función Ejemplo:
$valor = 5; print “El valor es: “ . $valor . “\n”; print “El valor es: $valor\n”; // ojo: comillas dobles Resultado: El valor es: 5
Variables variables: Se pueden crear nombres de variables dinámicamente. Estas variables variables toman su nombre del valor de otra variable previamente declarada
Ejemplo:
$a = "hola";
$$a = "mundo";
print "$a $hola\n";
print "$a ${$a}";
Resultado: hola mundo
hola mundo
INTALENTIA, PHP
16
Ejemplo de variables variables: página internacionalizada (1):
Ejemplo de variables variables: página internacionalizada (2):
<?PHP
$ mensaje _ es = “Hola”;
$ mensaje _en =”Hello”;
$ idioma =”es”;
$ mensaje =”mensaje_”. $ idioma;
Print $$ mensaje;
? >
<?PHP
$ mensaje _ es = “Hola”;
$ mensaje _en =”Hello”;
$ idioma =”en”;
$ mensaje =”mensaje_”. $ idioma;
Print $$ mensaje;
? >
INTALENTIA, PHP
17
Constantes
Definición de constantes: define (“CONSTANTE”, “hola”); print CONSTANTE; No llevan $ delante Sólo se pueden definir constantes de los tipos escalares (boolean, integer, double, string)
Expresiones y Operadores
Operadores aritméticos: +, -, *, /, %, ++, -- Operador de asignación: =, operadores combinados: .=, +=, etc. $a = 3; $a += 5; _ a vale 8. $b = “hola ”; $b .= “mundo”; _ b vale “hola mundo”. Equivale a $b = $b . “mundo”; Operadores de comparación: ==, !=, <, >, <=, >= y otros Operador de control de error: @. Antepuesto a una expresión, evita cualquier mensaje de error que pueda ser generado por la expresión Operadores lógicos: and (&&), or (||), !, xor and/&& y or/|| tienen diferentes prioridades Operadores de cadena: concatenación: . (Punto). Asignación con concatenación: .=
INTALENTIA, PHP
18
Precedencia de operadores (de mayor a menor): ++, -- *, /, % +,- <, <=, >, >= ==, != && || and or
Estructuras de control
Estructuras selectivas: if-else y switch
Estructuras repetitivas: while, for y foreach Estructura selectiva if-else:
Mismo comportamiento que en C.
Las sentencias compuestas se encierran entre llaves.
elseif puede ir todo junto.
If (condición)
Sentencia
If (condición)
Sentencia 1
Else
Sentencia 2
If (condición 1)
Sentencia 1
Else if (condición 2)
Sentencia 2
…
Else if (condición n)
Sentencia n
Else
Sentencia n+1
INTALENTIA, PHP
19
Ejemplo de estructura selectiva if-else:
<?PHP
if ($sexo == ‘M’)
$saludo = "Bienvenida, ";
else
$saludo = "Bienvenido, ";
$saludo = $saludo . $nombre;
print ($saludo);
?>
Estructura selectiva switch:
switch (expresión)
{
case valor_1:
sentencia 1
break;
case valor_2:
sentencia 2
break;
…
case valor_n:
sentencia n
break;
INTALENTIA, PHP
20
default
sentencia n+1
}
Mismo comportamiento que en C, sólo que la expresión del case puede ser integer, float o string
Ejemplo de estructura selectiva switch:
switch ($extension)
{
case ("PDF"):
$tipo = "Documento Adobe PDF";
break;
case ("TXT"):
$tipo = "Documento de texto";
break;
case ("HTML"):
case ("HTM"):
$tipo = "Documento HTML";
break;
default:
$tipo = "Archivo " . $extension;
}
print ($tipo);
INTALENTIA, PHP
21
Estructura repetitiva while:
while (condición)
sentencia
Tiene el mismo comportamiento que en C
Ejemplo de estructura repetitiva while:
<?PHP
print ("<UL>\n");
$i=1;
while ($i <= 5)
{
print ("<LI>Elemento $i</LI>\n");
$i++;
}
print ("</UL>\n");
?>
Estructura repetitiva for:
for (inicialización; condición; incremento)
sentencia
Mismo comportamiento que en C
INTALENTIA, PHP
22
Ejemplo de estructura repetitiva for:
<?PHP
print ("<UL>\n");
for ($i=1; $i<=5; $i++)
print ("<LI>Elemento $i</LI>\n");
print ("</UL>\n");
?>
Funciones
Ejemplo: function suma ($x, $y) { $s = $x + $y; return $s; } $a=1; $b=2; $c=suma ($a, $b);
print $c;
Por defecto los parámetros se pasan por valor
Paso por referencia:
function incrementa (&$a)
{
$a = $a + 1;
}
$a=1;
INTALENTIA, PHP
23
incrementa ($a);
print $a; // Muestra un 2
Argumentos por defecto
function muestranombre ($titulo = "Sr.")
{
print "Estimado $titulo:\n";
}
muestranombre ();
muestranombre ("Prof.");
Salida:
Estimado Sr.:
Estimado Prof.:
Los argumentos con valores por defecto deben ser siempre los últimos:
function muestranombre ($nombre, $titulo= "Sr.")
{
print "Estimado $titulo $nombre:\n";
}
muestranombre (“Fernández”);
muestranombre (“Fernández”, "Prof.");
Salida:
Estimado Sr. Fernández:
INTALENTIA, PHP
24
Estimado Prof. Fernández:
Tablas
Sintaxis: array ([clave =>] valor, ...)
La clave es una cadena o un entero no negativo. El valor puede ser de cualquier tipo válido en PHP, incluyendo otro array
Ejemplos:
$color = array (‘rojo’=>101, ‘verde’=>51, ‘azul’=>255);
$medidas = array (10, 25, 15);
_ Acceso:
$color[‘rojo’] // No olvidar las comillas
$medidas[0]
El primer elemento es el 0
La estructura de control foreach permite iterar sobre arrays
Sintaxis:
foreach (expresión_array as $valor)
sentencia
foreach (expresión_array as $clave => $valor)
sentencia
Ejemplos:
foreach ($color as $valor)
print “Valor: $valor<BR>\n”;
foreach ($color as $clave => $valor)
print “Clave: $clave; Valor: $valor<BR>\n”;
INTALENTIA, PHP
25
Salida:
Valor: 101
Valor: 51
Valor: 255
Clave: rojo; Valor: 101
Clave: verde; Valor: 51
Clave: azul; Valor: 255
Bibliotecas de funciones
Existen muchas bibliotecas de funciones en PHP Algunos ejemplos:
Funciones de manipulación de cadenas Funciones de fecha y hora Funciones de arrays Funciones de ficheros Funciones matemáticas Funciones de bases de datos Funciones de red
Algunas bibliotecas requieren la instalación de componentes adicionales Todas las funciones de biblioteca están comentadas en la documentación de PHP. Funciones de manipulación de cadenas:
• explode()
Divide una cadena en subcadenas array explode (string separator, string string [,int limit])
• rtrim(), ltrim(), trim()
Eliminan caracteres a la derecha, a la izquierda o por ambos lados de una cadena string rtrim ( string str [, string charlist])
INTALENTIA, PHP
26
• strstr()
Busca la primera ocurrencia de una subcadena • strtolower() / strtoupper()
Convierte una cadena a minúscula / mayúscula
• strcmp() / strcasecmp()
Compara dos cadenas con/sin distinción de mayúsculas • strlen()
Calcula la longitud de una cadena
Funciones de fecha y hora:
• date(): Formatea una fecha según un formato dado
Ejemplo:
$fecha = date ("j/n/Y H:i");
print ("$fecha");
Resultado:
26/9/2005 17:36
• strtotime(): Convierte una fecha en un timestamp de UNIX
Ejemplo:
$fecha = date ("j/n/Y", strtotime(“5 april
2001"));
print ("$fecha");
Resultado:
5/4/2001
INTALENTIA, PHP
27
Funciones de arrays:
• array_count_values(): Calcula la frecuencia de cada uno de los elementos de un array
• array_search(): Busca un elemento en un array
• count(): Cuenta los elementos de un array
• sort(), rsort(): Ordena y reindexa un array (r=decreciente)
• ksort(), krsort(): Ordena por claves un array (r=decreciente)
INTALENTIA, PHP
28
TEMA 3:Formularios
Acceso a formularios HTML desde PHP
Desde PHP se puede acceder fácilmente a los datos introducidos desde un formulario HTML
Veámoslo con un ejemplo simple:
Fichero uno.php
<HTML>
<BODY>
<FORM ACTION=”dos.php” METHOD=”POST”>
Edad: <INPUT TYPE=”text” NAME=”edad”>
<INPUT TYPE=”submit” VALUE=”aceptar”>
</FORM>
</BODY>
</HTML>
Fichero dos.php
<HTML>
<BODY>
<?PHP
print (“La edad es: $edad”);
?>
</BODY>
</HTML>
INTALENTIA, PHP
29
A partir de PHP 4.2.0, el valor por defecto de la directiva de PHP register_globals es off
Esto tiene una gran importancia sobre los formularios, ya que no es posible acceder a las variables enviadas de la manera anterior (como variables globales). En su lugar hay que utilizar la variable predefinida de PHP
$_REQUEST, escribiendo $_REQUEST[‘edad’] en lugar de $edad
Se puede poner register_globals = on en el fichero de configuración php.ini, pero no es recomendable por motivos de seguridad. Una alternativa que permite hacer mínimos cambios en el código ya existente es la siguiente: $edad = $_REQUEST[‘edad’];
INTALENTIA, PHP
30
Fichero uno.php
<HTML>
<BODY>
<FORM ACTION=”dos.php” METHOD=”POST”>
Edad: <INPUT TYPE=”text” NAME=”edad”>
<INPUT TYPE=”submit” VALUE=”aceptar”>
</FORM>
</BODY>
</HTML>
Fichero dos.php
<HTML>
<BODY>
<?PHP
$edad = $_REQUEST[‘edad’];
print (“La edad es: $edad”);
?>
</BODY>
</HTML>
Acceso a los diferentes tipos de elementos de entrada de formulario:
Elementos de tipo INPUT: TEXT, RADIO, CHECKBOX, BUTTON, FILE, HIDDEN, PASSWORD, SUBMIT
Elemento SELECT: Simple / múltiple
Elemento TEXTAREA
INTALENTIA, PHP
31
TEXT
Introduzca la cadena a buscar:
<INPUT TYPE="text" NAME="cadena" VALUE="valor por defecto" SIZE="20">
<?PHP
$cadena = $_REQUEST[‘cadena’];
print ($cadena);
?>
RADIO
Sexo:
<INPUT TYPE="radio" NAME=“sexo" VALUE=“M“ CHECKED>Mujer
<INPUT TYPE="radio" NAME=“sexo" VALUE=“H">Hombre
<?PHP
$sexo = $_REQUEST[‘sexo’];
print ($sexo);
?>
INTALENTIA, PHP
32
CHECKBOX
<INPUT TYPE="checkbox" NAME="extras[]" VALUE="garaje" CHECKED>Garaje
<INPUT TYPE="checkbox" NAME="extras[]" VALUE="piscina">Piscina
<INPUT TYPE="checkbox" NAME="extras[]" VALUE="jardin">Jardín
<?PHP
$extras = $_REQUEST[‘extras’];
$n = count ($extras);
for ($i=0; $i<$n; $i++)
print (“$extras[$i]<BR>\n”);
//foreach ($extras as $extra)
//print (“$extra<BR>\n”);
?>
BUTTON
<INPUT TYPE="button" NAME=“actualizar" VALUE="Actualizar datos">
<?PHP
$actualizar = $_REQUEST[‘actualizar’];
if ($actualizar)
print ("Se han actualizado los datos");
?>
INTALENTIA, PHP
33
FILE
<FORM ACTION="procesa.php" METHOD="post“
ENCTYPE="multipart/form-data">
<INPUT TYPE="file" NAME="fichero">
</FORM>
HIDDEN
<?PHP
print(“<INPUT TYPE=’hidden’ NAME=’username’ VALUE=’$usuario’>\n”);
?>
<?PHP
$username = $_REQUEST[‘username’];
print ($username);
?>
PASSWORD
Contraseña: <INPUT TYPE="password" NAME="clave">
<?PHP
$clave = $_REQUEST[‘clave’];
print ($clave);
?>
INTALENTIA, PHP
34
SUBMIT
<INPUT TYPE="submit" NAME="enviar" VALUE="Enviar datos">
<?PHP
$enviar = $_REQUEST[‘enviar’];
if ($enviar)
print ("Se ha pulsado el botón de enviar");
?>
SELECT simple
Color:
<SELECT NAME=“color">
<OPTION VALUE=“rojo" SELECTED>Rojo
<OPTION VALUE=“verde">Verde
<OPTION VALUE=“azul">Azul
</SELECT>
<?PHP
$color = $_REQUEST[‘color’];
print ($color);
?>
INTALENTIA, PHP
35
SELECT múltiple
Idiomas:
<SELECT MULTIPLE SIZE="3" NAME="idiomas[]">
<OPTION VALUE="ingles" SELECTED>Inglés
<OPTION VALUE="frances">Francés
<OPTION VALUE="aleman">Alemán
<OPTION VALUE="holandes">Holandés
</SELECT>
<?PHP
$idiomas = $_REQUEST[‘idiomas’];
$n = count ($idiomas);
for ($i=0; $i<$n; $i++)
print (“$idiomas[$i]<BR>\n”);
//foreach ($idiomas as $idioma)
//print (“$idioma<BR>\n”);
?>
TEXTAREA
Comentario:
<TEXTAREA COLS=“50" ROWS=“4" NAME="comentario">
Este libro me parece ...
</TEXTAREA>
<?PHP
$comentario = $_REQUEST[‘comentario’];
INTALENTIA, PHP
36
print ($comentario);
?>
El formulario de PHP
La forma habitual de trabajar con formularios en PHP es utilizar un único programa que procese el formulario o lo muestre según haya sido o no enviado, respectivamente
Ventajas: Disminuye el número de ficheros, Permite validar los datos del formulario en el propio formulario.
Procedimientos: si se ha enviado el formulario: Procesar formulario
si no: Mostrar formulario fsi
Esquema de funcionamiento:
a) b)
La 1ª vez que se carga la página se muestra el formulario (a)
La 2ª vez se procesa el formulario (b)
Si se ha enviado el formulario: Procesar formulario
Si no: Mostrar formulario fsi
INTALENTIA, PHP
37
Para saber si se ha enviado el formulario se acude a la variable correspondiente al botón de envío. Si este botón aparece de la siguiente forma en el formulario HTML:
<INPUT TYPE="SUBMIT" NAME="enviar“ VALUE="procesar">
Entonces la condición anterior se transforma en:
if (isset($enviar))
o bien
if ($enviar == “procesar”)
Subida de ficheros al servidor
Para subir un fichero al servidor se utiliza el elemento de entrada FILE
Hay que tener en cuenta una serie de consideraciones importantes:
El elemento FORM debe tener el atributo
ENCTYPE="multipart/form-data“
El fichero tiene un límite en cuanto a su tamaño. Este límite se fija de dos formas diferentes: en el fichero de configuración php.ini y en el propio formulario
INTALENTIA, PHP
38
php.ini
Formulario
Consideraciones (cont)
Debe darse al fichero un nombre que evite coincidencias con ficheros ya subidos. Por ello, y como norma general, debe descartarse el nombre original del fichero y crear uno nuevo que sea único
El fichero subido se almacena en un directorio temporal y hemos de moverlo al directorio de destino usando la función move_upload_file()
;;;;;;;;;;;;;;;;
; File Uploads ;
;;;;;;;;;;;;;;;;
; Whether to allow HTTP file uploads.
file_uploads = On
; Temporary directory for HTTP uploaded files (will use
; system default if not specified).
;upload_tmp_dir =
; Maximum allowed size for uploaded files.
upload_max_filesize = 2M
<INPUT TYPE=”HIDDEN” NAME=”MAX_FILE_SIZE” VALUE='102400'>
<INPUT TYPE=”FILE” NAME="fichero">
INTALENTIA, PHP
39
Procedimiento:
Si se ha subido correctamente el fichero:
Asignar un nombre al fichero
Mover el fichero a su ubicación definitiva
si no:
Mostrar un mensaje de error
fsi
HTML
La variable $_FILES contiene toda la información del fichero subido:
$_FILES['imagen']['name']
Nombre original del fichero en la máquina cliente
$_FILES['imagen']['type']
Tipo mime del fichero. Por ejemplo, "image/gif"
$_FILES['imagen']['size']
Tamaño en bytes del fichero subido
$_FILES['imagen']['tmp_name']
Nombre del fichero temporal en el que se almacena el fichero subido en el servidor
$_FILES['imagen’]['error']
Código de error asociado al fichero subido
<INPUT TYPE="HIDDEN" NAME="MAX_FILE_SIZE" VALUE="102400"> <INPUT TYPE="FILE" SIZE="44" NAME="imagen">
INTALENTIA, PHP
40
PHP
if (is_uploaded_file ($_FILES['imagen']['tmp_name'])) { $nombreDirectorio = "img/"; $idUnico = time(); $nombreFichero = $idUnico . "-" . $_FILES['imagen']['name']; move_uploaded_file ($_FILES['imagen']['tmp_name'], $nombreDirectorio . $nombreFichero); } else print ("No se ha podido subir el fichero\n");
if (is_uploaded_file ($_FILES['imagen']['tmp_name'])) { $nombreDirectorio = "img/"; $nombreFichero = $_FILES['imagen']['name']; $nombreCompleto = $nombreDirectorio . $nombreFichero; if (is_file($nombreCompleto)) { $idUnico = time(); $nombreFichero = $idUnico . "-" . $nombreFichero; } move_uploaded_file ($_FILES['imagen']['tmp_name'], $nombreDirectorio . $nombreFichero); } else print ("No se ha podido subir el fichero\n");
INTALENTIA, PHP
41
Validación de formularios
Este procedimiento se puede resumir para que sólo haya que mostrar una vez el formulario, bien con los valores por defecto o con los valores introducidos, y con los errores en su caso:
si se ha enviado el formulario: validar datos fsi si se ha enviado el formulario y no hay errores: Procesar formulario si no: Mostrar formulario con valores por defecto o ya enviados
fsi
Esquema de funcionamiento:
a) b) c)
La 1ª vez que se carga la página se muestra el formulario (a)
La 2ª y sucesivas veces se validan los datos
Si hay errores, se muestra de nuevo el formulario con los errores (b)
Si no hay, se procesa el formulario (c)
Si se ha enviado el formulario: validar datos
fsi
Si se ha enviado y no hay errores:
Procesar formulario
si no:
Mostrar formulario
fsi
INTALENTIA, PHP
42
TEMA 4: Acceso a base de datos MySQL en PHP
Bases de datos en la Web
Las bases de datos permiten almacenar de una forma estructurada y eficiente toda la información de un sitio web
Ventajas:
• Proporcionar información actualizada • Facilitar la realización de búsquedas • Disminuir los costes de mantenimiento • Implementar sistemas de control de acceso • Almacenar preferencias de los usuarios
Esquema básico de un sitio web soportado por bases de datos:
INTALENTIA, PHP
43
Instalación y config. de MySQL
Pasos:
1. Descargar
Conectarse a la página web de MySQL, www.mysql.com Seleccionar Downloads Elegir la versión estable más reciente. A fecha de febrero de 2004 es la 4.0.17 Seleccionar la plataforma y un mirror del cual descargar el archivo comprimido Descargar el archivo a una carpeta temporal
2. Descomprimir e instalar
Descomprimir el archivo descargado en una carpeta temporal
Ejecutar el archivo setup.exe. Instalar en la carpeta por defecto, c:\mysql (instalación típica)
3. Arrancar
Arrancar el servidor, que queda residente en memoria. Alternativas:
• Ejecutar c:\mysql\bin\mysqld.exe (mysqld-nt.exe en Windows NT/2000/XP) • Ejecutar el programa c:\mysql\bin\winmysqladmin, que arranca el servidor y se
autoprograma para hacerlo automáticamente cada vez que arranca la máquina
Formas de establecer la conexión con el servidor:
• Ejecutando el cliente mysql desde la línea de órdenes • Mediante alguna herramienta que proporcione una interfaz gráfica como
phpMyAdmin • Desde una página web mediante la interfaz que proporciona MySQL. Es lo que
haremos con la biblioteca de funciones de MySQL que posee PHP
INTALENTIA, PHP
44
4. Configuración
Es conveniente modificar la configuración de usuarios por defecto de MySQL. La primera tarea es asignar una clave al administrador (root) del servidor:
Desde la línea de órdenes:
C:\mysql\bin> mysql -u root mysql
mysql> UPDATE user
SET Password=PASSWORD('clave')
WHERE user='root';
mysql> FLUSH PRIVILEGES;
mysql> quit
Con la herramienta PHPMyAdmin, editando los datos del usuario root
Con la utilidad WinMySQLAdmin, que permite editar el fichero de configuración my.ini
Además hay que crear los usuarios de las distintas bases de datos y asignarles los permisos. En general, para una base de datos es conveniente definir dos usuarios:
Un usuario anónimo que tenga permisos de lectura sobre las tablas que se estime adecuado
Un usuario administrador que tenga permisos para insertar, modificar o eliminar elementos de las tablas de la base de datos
Para cada usuario hay que indicar la máquina desde la que se conectará (localhost para acceso web), el nombre del usuario y la contraseña
Herramientas de administración : phpMyAdmin
phpMyAdmin es una herramienta para la administración del servidor de bases de datos MySQL Dispone de una interfaz gráfica y es gratuita
INTALENTIA, PHP
45
Pasos para su instalación:
1. Descargar: Conectarse a la dirección http://www.phpmyadmin.net Seleccionar Downloads Seleccionar la versión más reciente. A fecha de febrero de 2004 es la 2.5.5 Seleccionar un mirror e iniciar la descarga
2. Descomprimir:
Descomprimir debajo de la carpeta raíz de la web, c:\htdocs Cambiar el nombre de la carpeta creada (phpMyAdmin- 2.5.5) a phpmyadmin
3. Configuración: La configuración se realiza a través del fichero config.inc.php, situado en la carpeta donde se haya instalado phpMyAdmin Configuración típica para un servidor local:
... $cfg['Servers'][$i]['host'] = 'localhost'; //MySQL hostname $cfg['Servers'][$i]['user'] = 'root'; //MySQL user $cfg['Servers'][$i]['password'] = 'clave'; //MySQL password ...
siendo ‘clave’ la contraseña asignada al administrador (root) de MySQL
4. Ejecutar: Ejecutar Apache Abrir el navegador y teclear la url http://localhost/phpmyadmin/index.php
INTALENTIA, PHP
46
Lenguaje SQL
SQL (Structured Query Language) es el lenguaje que se utiliza para comunicarse con la base de datos.
Procedimiento de comunicación con la base de datos:
Orden SQL
Resultado
Las instrucciones más habituales son SELECT, INSERT, UPDATE, DELETE
Veamos su sintaxis básica y algunos ejemplos de uso
Para ello utilizaremos una tabla noticias con cinco campos: un identificador único de la noticia, el título de la noticia, el texto de la noticia, la categoría de la noticia y la fecha de publicación de la noticia
Noticias Id Título Texto Categoría Fecha
SELECT
Sintaxis:
SELECT expresión FROM tabla
[WHERE condición]
[ORDER BY {unsigned_integer | col_name | formula} [ASC | DESC] ,...]
[LIMIT [offset,] row_count | row_count OFFSET offset]
Página PHP
BBDD
INTALENTIA, PHP
47
Ejemplo:
SELECT * from noticias WHERE fecha=CURDATE() LIMIT 10 ORDER BY fecha
DESC
Obtiene las noticias del día con un tope máximo de 10, ordenadas de la más reciente a la más antigua
INSERT
Sintaxis:
INSERT [INTO] nombre_tabla [(nombre_columna,...)]
VALUES ((expresión | DEFAULT),...), (...),...
INSERT [INTO] nombre_tabla
SET nombre_columna=(expresión | DEFAULT), ...
Ejemplo:
INSERT INTO noticias (id, titulo, texto, categoria, fecha) VALUES
(37, “Nueva promoción en Nervión”, “145 viviendas de lujo en
urbanización ajardinada situadas en un entorno privilegiado”,
“promociones”, CURDATE())
Inserta una noticia con los valores indicados
UPDATE
Sintaxis:
UPDATE nombre_tabla
SET nombre_columna1=expr1 [, nombre_columna2=expr2 ...]
[WHERE condición]
[ORDER BY ...]
INTALENTIA, PHP
48
[LIMIT row_count]
Ejemplo:
UPDATE noticias SET categoria = “ofertas” WHERE id=37
Modifica la categoría de la noticia con id=37 de la tabla
DELETE
Sintaxis:
DELETE FROM nombre_tabla
[WHERE condición]
[ORDER BY ...]
[LIMIT row_count]
Ejemplo:
DELETE FROM noticias WHERE fecha < CURDATE()-10
Borra las noticias con más de 10 días de antigüedad
Funciones de PHP para el acceso a bases de datos MySQL
Los pasos para acceder desde PHP a una base de datos son los siguientes:
Conectar con el servidor de bases de datos Seleccionar una base de datos Enviar la instrucción SQL a la base de datos Obtener y procesar los resultados
Cerrar la conexión con el servidor de bases de datos
INTALENTIA, PHP
49
Acceso a bases de datos MySQL
Las funciones concretas de MySQL que realizan estas operaciones son:
Conectar con el servidor de bases de datos:
mysql_connect()
Seleccionar una base de datos:
mysql_select_db()
Enviar la instrucción SQL a la base de datos:
mysql_query()
Obtener y procesar los resultados:
mysql_num_rows() y mysql_fetch_array()
Cerrar la conexión con el servidor de bases de datos:
mysql_close()
Conectar con el servidor de bases de datos:
mysql_connect()
Devuelve un identificador de la conexión en caso de éxito y false en caso contrario
Sintaxis:
$conexion = mysql_connect (servidor, username, password);
Ejemplo:
$conexion = mysql_connect (“localhost”, “cursophp”, “”)
or die (“No se puede conectar con el servidor”);
$conexion = mysql_connect (“localhost”, “cursophp-ad”, “php.hph”)
or die (“No se puede conectar con el servidor”);
INTALENTIA, PHP
50
Seleccionar una base de datos: mysql_select_db()
Devuelve true en caso de éxito y false en caso contrario
Sintaxis: mysql_select_db (database);
Ejemplo:
mysql_select_db (“lindavista”)
or die (“No se puede seleccionar la base de datos”);
Enviar la instrucción SQL a la base de datos:
mysql_query()
Devuelve un identificador o true (dependiendo de la instrucción) si la instrucción se ejecuta correctamente y false en caso contrario
Sintaxis: $consulta = mysql_query (instrucción, $conexion);
Ejemplo:
$consulta = mysql_query (“select * from noticias”, $conexion)
or die (“Fallo en la consulta”);
Obtener y procesar los resultados: mysql_num_rows(), mysql_fetch_array()
En el caso de que la instrucción enviada produzca unos resultados, mysql_query() devuelve las filas de la tabla afectadas por la instrucción
mysql_num_rows() devuelve el número de filas afectadas
Para obtener las distintas filas del resultado se utiliza la función mysql_fetch_array(), que obtiene una fila del resultado en un array asociativo cada vez que se invoca
Sintaxis:
$nfilas = mysql_num_rows ($consulta);
$fila = mysql_fetch_array ($consulta);
INTALENTIA, PHP
51
Ejemplo:
Noticias
1 Título 1 Texto 1 Ofertas 05/02/2004 2 Título 2 Texto 2 Promociones 05/02/2004 3 Título 3 Texto 3 Promociones 04/02/2004 4 Título 4 Texto 4 Costas 01/02/2004 5 Título 5 Texto 5 Promociones 31/01/2004
Instrucción:
select * from noticias where categoria=“promociones”
Obtención de las filas:
$nfilas = mysql_num_rows ($consulta);
if ($nfilas > 0)
{
for ($i=0; $i<$nfilas; $i++)
{
$fila = mysql_fetch_array ($consulta);
procesar fila i-ésima de los resultados
}
}
$Consulta
$nfilas=3
INTALENTIA, PHP
52
Obtener los resultados: mysql_num_rows(),
mysql_fetch_array()
Para acceder a un campo determinado de una fila se usa la siguiente sintaxis:
$fila[“nombre_campo”] // por ser un array asociativo
$fila[i] // i=índice del campo desde 0
Ejemplo:
for ($i=0; $i<$nfilas; $i++)
{
$fila = mysql_fetch_array ($consulta);
echo “Título: “ . $fila[“titulo”];
echo “Fecha: “ . $fila[“fecha”];
}
Cerrar la conexión con el servidor de bases de datos:
mysql_close()
Sintaxis:
mysql_close ($conexion);
Ejemplo
mysql_close ($conexion);
INTALENTIA, PHP
53
Consulta avanzada de tablas
Objetivo: mostrar los resultados de la consulta divididos en bloques de un número determinado de elementos (por ejemplo, de 5 en 5)
Requisitos:
• Recuperar un número limitado de elementos de la tabla • Implementar un mecanismo de navegación que permita avanzar al siguiente o
volver al anterior bloque de elementos
Para recuperar un número fijo de elementos de una tabla se utiliza la opción LIMIT de la orden SELECT. Así, por ejemplo,
SELECT * from noticias LIMIT 0, 5
recupera los 5 primeros elementos de la tabla. Y en
general,
SELECT * from noticias LIMIT $comienzo, $num
recupera $num elementos a partir de la posición
$comienzo
La variable $num tendrá un valor constante (en este caso 5), mientras que la variable $comienzo se incrementará o decrementará en 5 unidades al pasar a la página siguiente o anterior
Para ello se pasará la variable como parámetro en el enlace asociado al botón correspondiente
Por ejemplo, el código para el botón siguiente será:
"<A HREF='$PHP_SELF?comienzo=" . ($comienzo + $num) .
"'>Siguiente</A>“
Habrá que comprobar previamente que el nuevo valor de comienzo es válido, es decir, que se encuentra dentro de los límites de la tabla devuelta por la consulta.
INTALENTIA, PHP
54
Objetivo:
Mostrar los resultados de una consulta de manera que se puedan filtrar en función del valor de una determinada columna de la tabla
Requisitos:
Recuperar de una tabla los elementos que cumplan una determinada condición
Permitir seleccionar un valor de entre los valores posibles de una columna
Para recuperar los elementos de una tabla que cumplen una condición se utiliza la opción WHERE de la orden SELECT. Por ejemplo,
SELECT * from noticias WHERE categoria=’ofertas’
recupera las noticias cuya categoría tiene el valor
“ofertas”. Y en general,
SELECT * from noticias WHERE categoria =’$categoria’
recupera las noticias cuya categoría tiene el valor dado por la variable $categoria
La variable $categoria se obtendrá de un elemento SELECT
Objetivo:
Modificar el ejercicio anterior para que los resultados se actualicen de forma automática al seleccionar un nuevo valor para la columna
Requisitos:
• Obtener automáticamente los valores de una columna de tipo enumerado a partir de la tabla
• Utilizar código JavaScript para detectar un cambio en la opción seleccionada de un elemento de tipo SELECT
INTALENTIA, PHP
55
Función JavaScript que actualiza una página en función de la opción seleccionada en el elemento SELECT de nombre ‘categoria’ del formulario de nombre ‘selecciona’:
<SCRIPT LANGUAGE='JavaScript'>
<!--
function actualizaPagina ()
{
i = document.forms.selecciona.categoria.selectedIndex;
categoria =
document.forms.selecciona.categoria.options[i].value;
window.location = ‘muestra_noticias.php?categoria=' +
categoria;
}
// -->
</SCRIPT>
Para ejecutar la función JavaScript es preciso asociarla al elemento SELECT a través del evento ONCHANGE, que se activa cuando se modifica la opción seleccionada:
<SELECT NAME='categoria' ONCHANGE='actualizaPagina()'>
Es conveniente que la opción seleccionada aparezca marcada por defecto al actualizar la página
Para ello es preciso generar las opciones del elemento SELECT de forma automática
De esta manera se puede comparar cada una de las opciones con el valor proveniente del formulario y colocar el atributo SELECTED a la que corresponda
INTALENTIA, PHP
56
En el formulario del ejercicio anterior los valores de los campos de tipo enumerado (ENUM) están escritos directamente en el propio código. Así, para la categoría de noticia se tiene:
<SELECT NAME=“categoria">
<OPTION VALUE=“promociones">promociones
<OPTION VALUE=“ofertas" SELECTED>ofertas
<OPTION VALUE=“costas">costas
</SELECT>
Este hecho no es muy deseable ya que si se modifican los valores de la categoría en la tabla hay que modificar también el código del formulario
Lo ideal es tomar los valores automáticamente de la tabla en lugar de escribirlos ‘a mano’ en el código. Para ello se utiliza la siguiente instrucción SQL:
SHOW columns FROM noticias LIKE ‘categoria‘
que devuelve una tabla con las propiedades del campo
‘categoria’. El elemento [1] de esta tabla contiene lo siguiente:
enum(“promociones",“ofertas",“costas")
A partir de esta información podemos obtener los valores del tipo enumerado y generar las opciones del elemento SELECT. Sólo queda marcar con SELECTED la opción que estaba seleccionada en caso de haberse enviado el formulario
INTALENTIA, PHP
57
TEMA 5: Sesiones
Introducción
A veces es necesario mantener el estado de una conexión entre distintas páginas o entre distintas visitas a un mismo sitio
Ejemplos: aplicaciones personalizadas, carrito de la compra, control de acceso
Las sesiones permiten disponer de unas variables con valores persistentes durante toda la conexión del usuario.
Estas variables pueden almacenarse en el cliente mediante cookies o en el servidor
PHP dispone de una biblioteca de funciones para la gestión de sesiones
Manejo de sesiones
Funciones de PHP para el manejo de sesiones:
session_start (): inicializa una sesión y le asigna un identificador de sesión
único. Si la sesión ya está iniciada, carga todas las variables de sesión
session_register (variable): registra una variable de sesión
session_unregister (variable): elimina una variable de sesión
session_is_registered (variable): comprueba si una variable está registrada.
Devuelve true en caso afirmativo y false en caso contrario
session_destroy (): cierra una sesión
El manejo de las sesiones se realiza de la siguiente forma:
• Todas las páginas deben realizar una llamada a session_start() para cargar las
variables de la sesión
• Esta llamada debe estar colocada antes de cualquier código HTML
• Conviene llamar a session_destroy() para cerrar la sesión
INTALENTIA, PHP
58
Autenticación de usuarios
Una cuestión frecuente en un sitio web es controlar el acceso de los usuarios a una
zona determinada del mismo
La autenticación de usuarios puede realizarse en el propio servidor web. Así, en
Apache los ficheros .htaccess permiten limitar el acceso a un determinado recurso del
servidor
Una alternativa más compleja pero más flexible es utilizar PHP junto con una base de
datos para controlar el acceso de los usuarios. Para ello se utilizan las sesiones.
Login
Mostrar formulario
Menú
Mostrar error
Consultar noticias
Insertar noticia
Logout
INTALENTIA, PHP
59
NO
SI
NO
SI
NO ERROR
SI
Consultar Noticias Insertar Noticias Logout
INICIO
Enviado formulario
Datos correcto
Iniciar Sesión
Sesión Iniciada
Menú
Mostrar formulario
Mostrar error
INTALENTIA, PHP
60
TEMA 6: Seguridad
Introducción
Primera recomendación: Disponer siempre de versiones actualizadas de Apache y
PHP
Aspectos de PHP que pueden dar lugar a vulnerabilidades:
• Variables globales
• Nombres de ficheros
• Subida de ficheros
• Bibliotecas
• Datos enviados desde formularios
Variables globales
Cuando register_globals está activado en el fichero php.ini, PHP crea automáticamente
variables globales a partir de los datos de los formularios y de las cookies
Esto puede dar lugar a problemas como en el ejemplo siguiente:
<?PHP
if (comprueba_privilegios())
$superuser = true;
...
?>
Una llamada a este script de la forma pagina.php?superuser=1 permitiría obtener
privilegios de superusuario
INTALENTIA, PHP
61
Para resolver este problema existen tres soluciones:
1. Deshabilitar register_globals en el fichero php.ini
La directiva register_globals del fichero php.ini establece si se admite o no la creación
automática de variables globales
A partir de PHP 4.2.0 el valor por defecto de esta directiva es off, que es el valor
recomendable
2. Inicializar las variables
El problema anterior se soluciona dando un valor inicial a la variable $superuser: <?PHP $superuser = false; if (comprueba_privilegios()) $superuser = true; ...
?>
Es recomendable inicializar todas las variables antes de usarlas. Se puede usar la
directiva error_reporting=E_ALL en php.ini para que se muestre un aviso cuando se
use una variable que no haya sido previamente inicializada
En un entorno de producción debe evitarse la aparición de mensajes de aviso o error.
Para ello se utilizan las siguientes directivas en php.ini:
display_errors = off
log_errors = on
error_log = /var/log/php_errors.log
Los errores irán al fichero especificado en lugar de mostrarse en la pantalla
INTALENTIA, PHP
62
Establecer el orden de las variables en PHP:
PHP crea automáticamente variables globales a partir del entorno (E), las cookies (C),
la información del servidor (S) y los parámetros GET (G) y POST (P)
La directiva variables_order controla el orden de estas variables. El valor por defecto
es “EGPCS”
Permitir la creación de variables globales desde parámetros GET y POST y desde
cookies es potencialmente peligroso. Un posible valor para variables_order que evita
esto es “ES”
En tal caso para acceder a los parámetros de los formularios y a las cookies se deben
utilizar los arrays globales:
$_REQUEST, $_GET, $_POST y $_COOKIES
Establecer el orden de las variables en PHP:
Si se modifican las directivas register_globals y/o variables_order es preciso revisar los
scripts existentes para adaptarlos a las nuevas circunstancias
Una forma puede ser la siguiente:
$edad = $_REQUEST[‘edad’];
...
INTALENTIA, PHP
63
Nombre de ficheros
Es relativamente fácil construir un nombre de fichero que se refiera a algo distinto a lo
que se pretende
Sea el siguiente código:
include (“/usr/local/lib/bienvenida/$username”);
Este código pretende mostrar un mensaje de bienvenida personalizado para el usuario.
Aparentemente no es peligroso, pero ¿qué ocurriría si el usuario introduce como
nombre la cadena “../../../../etc/passwd”?: Se mostraría el fichero de passwords del
sistema
Además hay que tener en cuenta que las funciones de manejo de ficheros como
include() o require() admiten nombres de ficheros remotos, lo que podría provocar la
ejecución de código maligno cargado de otro servidor. Sea, por ejemplo, el código
include ($libdir . “/conecta.php”);
Si un atacante modifica el valor de la variable $libdir a, pongamos por caso,
“http://atacante/”, y coloca en la raíz del mismo un fichero de nombre conecta.php, su
código sería ejecutado
Se puede desactivar la funcionalidad de acceso a ficheros remotos con la siguiente
directiva en php.ini: allow_url_fopen = off
Para chequear nombres de ficheros se utilizan las funciones realpath() y basename().
La primera convierte direcciones relativas en absolutas y la segunda toma una ruta y
devuelve la parte correspondiente al nombre del fichero.
INTALENTIA, PHP
64
Ejemplo:
$file = $_POST[‘username’];
$file2 = basename (realpath($file));
if ($file2 != $file)
die (“$file no es un username válido”);
include (“/usr/local/lib/bienvenida/$file”);
Otra defensa contra los nombres de ficheros incorrectos es la directiva de php.ini
open_basedir:
open_basedir = /alguna/ruta
PHP limitará las operaciones sobre ficheros al directorio especificado y sus
subdirectorios:
include (“/alguna/ruta/lib.inc”); // permitido
include (“/otra/ruta/lib.inc”); // da error
Subida de ficheros
La subida de ficheros permite a un usuario enviar cualquier fichero al servidor, lo cual
encierra un gran peligro ya que un atacante puede subir un código maligno y luego
ejecutarlo, causando más daño que cuando se incluye el código desde un servidor
remoto
INTALENTIA, PHP
65
Como recomendación general, debe evitarse utilizar el nombre enviado por el
navegador (podría ser, por ejemplo, /etc/passwd). Es conveniente generar un nombre
único para el fichero subido
Otro peligro es el tamaño de los ficheros. Aunque se limite el tamaño máximo en el
formulario, los ficheros se reciben automáticamente y luego se comprueba su tamaño
Es posible que un usuario intente provocar un ataque de denegación de servicio
enviando varios ficheros de gran tamaño a la vez y llenando el sistema de ficheros
utilizado por PHP para almacenarlos
Para evitar esto se puede utilizar la directiva post_max_size de php.ini. El valor por
defecto suele ser más elevado de lo necesario
Sea ahora el siguiente código:
if (file_exists($file)) // chequea la existencia en
// el sistema local
include (“$file”);
Esto evitaría la inclusión de un fichero remoto aunque el atacante controlase la
variable $file
Sin embargo, el atacante podría crear su propio formulario usando el nombre file para
el campo de tipo fichero y al enviarlo colocaría en el servidor un fichero cuyo código
sería ejecutado
Bibliotecas
Es conveniente almacenar los ficheros de biblioteca fuera de la raíz de la web para
evitar que puedan ser accedidos por su URL
En tal caso debe hacerse saber a PHP la ubicación de los ficheros indicando la ruta
completa en los include() y require() o bien mediante la directiva include_path en
php.ini
include_path = “.:/usr/local/php:/usr/local/lib/myapp”
INTALENTIA, PHP
66
Esto es particularmente importante cuando en el código de la biblioteca aparecen
passwords, como es el caso de las funciones de conexión con bases de datos
Formularios
Si el autor del comentario introdujo algún código HTML en el texto del mismo, el
código será interpretado y sus efectos podrían ser graves
Para evitar esto se puede utilizar la función htmlspecialchars(), que impide que se
interpreten los caracteres especiales de HTML (<, >, &)
El código quedaría de la siguiente manera:
print (“Nombre: “ . $nombre);
print (“Comentario: “ . htmlspecialchars($comentario));
Resumen
De todo lo anterior podemos concluir las dos recomendaciones siguientes:
• Configurar adecuadamente PHP a través del fichero php.ini
• Seguir unas buenas prácticas en la programación
Hay que tener en cuenta que cualquier cambio en la configuración de PHP afectará a
los scripts de todos los usuarios y posiblemente a algunas herramientas, lo cual debe
ser tenido en cuenta y estudiarse sus consecuencias antes de proceder a realizarlos
INTALENTIA, PHP
67
Top Related