Hace un tiempo hice un vídeo para Webempresa donde hablaba sobre el desarrollo de extensiones usando el patrón MVC en Joomla. También se explicaba como usar partes del Framework de Joomla y hacíamos un ejemplo sobre el ForntEnd de Joomla.

En esta ocasión en el vídeo trata sobre como desarrollar la parte del Backend de la extensión, la metodología es similar, pero hay funciones nuevas que merece la pena ver con más profundidad. Queda todo recojido en un vídeo de unos 50 minutos que podéis ver en el canal de Youtube de Webempresa o aquí debajo.

Podéis descargar el código de ejemplo aquí.

PD: Un saludo para Gnumax que me anima constantemente para que siga escribiendo artículos en el blog.

PHP es un lenguaje de programación muy potente, intuitivo y fácil de utilizar. Además tiene gran cantidad de librerías desarrolladas de las que nos podemos aprovechar. Si eres administrador de sistemas y además tienes que realizar labores de administración de sistemas, estoy seguro que te encontrarás en multitud de situaciones donde utilizar PHP será la opción más rápida y comoda para llevar a cabo tus propósitos.
Por ejemplo, imagina que tienes que ejecutar una tarea diaria que involucre acceso a base de datos de una aplicación que está desarrollada en PHP y que dispone de su propia API, como por ejemplo Joomla. Además está tarea tiene que estar integrada dentro de una serie de shell scripts realizados ya, que funcionan bien y no quieres tener que reprogramarlos en PHP. Tienes 3 opciones, implementar las tareas dentro de otros shell scripts o scripts en perl, desaprovechando tus conocimientos de PHP y el API de Joomla, pasar tus scripts de shel Linux a PHP, lo que puede resultar una pérdida de tiempo si ya funcionan correctamente.. o la tercera y por la que me decanto, utilizar PHP desde la línea de comandos y crear un script de PHP que acepte los parámetros necesarios e invocarlo desde otros shell scripts o scripts en perl que ya tengamos implementados. Así que por todo esto vamos a ver como utilizar PHP en el CLI.

En Linux para saber que programa va a interpretar el código del script, se utiliza el shebang, que es una lína que se coloca al principio, que incorpora los caracteres #! seguidos del path al intérprete. Para saber cual es la ruta del interprete de PHP podemos utilizar los comandos

wich php
#o también
whereis php

Por ejemplo, nuestro script, en un SO CentOS, empezaría así:

#!/usr/bin/php

<?php
 #código del script PHP
?>

Después la metodología de codificación es muy similar a la de cualquier script PHP desarrollado para ser ejecutado en Apache, con la diferencia de que ahora los parámetros los recibimos del Array $argv[] en lugar de utilizar los Arrays $_POST, $_GET o $_REQUEST. Deberemos de utilizar las marcas de PHP del mismo modo que en un script de CGI (&gt?php ?<) para que el intérprete de PHP ejecute el código. Por ejemplo, creamos un primer script de ejemplo con el nombre prueba.php y el siguiente código:

#!/usr/bin/php
<?php
print_r($argv);
?>

Si lo invocamos de la siguiente forma, obtendremos la siguiente salida:

./prueba.php argumento1 argumento2

#Salida del comando:

Array
(
[0] => ./prueba.php
[1] => argumento1
[2] => argumento2
)

Como veis, es muy fácil acceder a los parámetros del script utilizando el array $argv, es una buena idea asignar las variables del array a variables con nombres más intuitivos para no liarnos después en la programación. La posición 0 del array $argv siempre contiene el nombre del script desde elq ue se llama, esto es algo habitual, el que haya programado shell script en Bash lo sabrá muy bien. Podemos utilizar la función array_shift($argv) para eliminar el primer parámetro o recorrer el array $argv con un while.

Realizar comprobaciones básicas
En la variable $argc se almacena un entero con el número de parámetros introducidos. Empleando este valor podemos hacer algunas comprobaciones básicas:

#!/usr/bin/php

if ($argc != 3) {
   die("Modo de empleo: prueba.php <num_usuarios> <bloquear> \n");
}

$num_usuarios = $argv[1];
$bloquear = $argv[2];

Comprobar que el valor de entrada es un valor numérico:

if (!is_numeric($param)){
 die("$param no es un número");
}

Acceso a las variables de entorno

Puedes acceder a las variables de entorno del sistema

putenv("EDITOR=/path/al/editor");
echo "Actualmente estás usando el editor por defecto: " . getenv('EDITOR') ;

El resto es cuestión de saber programar en PHP. Por ejemplo, podemos utilizar el API de Joomla si nos lo proponemos si lo incluimos como se indica en la documentación de Joomla.
En próximos artículos veremos algunas funciones muy útiles para emplear en nuestros scripts de CLI en PHP..

Después de una temporadita sin escribir nada, me he decidido a ponerme delante del teclado y escribir un corto tutorial sobre como instalar un servidor SVN en Linux, usaremos una distribución de paquetes RPM, pero en distribuciones de paquetes DEB el proceso es muy similar, sólo hay que usar el sentido común..

Todo programador sabe de la importancia de un servidor de versiones a la hora de programar en grupo o de mantener un software que va creciendo con el tiempo, nada mejor que disponer de nuestro propio servidor SVN para esto.

Instalando y configurando el servidor SVN

Para instalar el servidor es muy sencillo, simplemente nos accedemos al terminal de línea de comandos como root y ejecutamos lo siguiente:

yum install subversion

Deberemos asegurarnos previamente de que no tenemos la palabra “perl” en la línea de excludes del fichero yum.conf, si fuera así deberíamos de comentar la línea de exludes, guardar cambios y volver a ejecutar el comando.

Una vez se haya completado la instalación, dispondremos del servidor y el cliente de subversion instalados en nuestro sistema. Ahora deberemos de crear el directorio donde guardaremos nuestros repositorios de software, en mi caso voy a guardarlos en el directorio /root/repos, después crearemos nuestro primer repositorio.

mkdir /root/repos
svnadmin create /root/repos/nombre_repositorio

Siguiendo estos sencillos pasos ya disponemos de un repositorio creado, ahora vamos a ver como lanzar el servicio. Por defecto no se crea el script de inicialización que debería de almacenarse en /etc/init.d/subversion, por lo que tendremos que lanzar el servicio manualmente, para ello ejecutamos el siguiente comando:

mkdir /root/repos
svnserve -d -r /root/repos

Este comando lanzará el proceso que dejará el servidor subversion a la escucha en el puerto 3690. Para saber si está el proceso a la escucha podemos emplear el siguiente comando:

netstat -anp | grep svn

#La salida del comando debería ser algo así:
#
# tcp        0      0 :::3690                     :::*                        LISTEN      17911/svnserve
#
#Vemos que hay un proceso con PID 17911 escuchando en el puerto 3690 del protocolo TCP.

Para parar el servicio, podemos proceder a matar el proceso con un “kill -9 PID”, en este caso, “kill -9 17911″ .

Para realizar una importación inicial podemos ejecutar el siguiente comando:

mkdir /root/repos
svn import /home/david/software/miproyecto file:///root/repos/nombre_repositorio/ -m "Importacion inicial"

Este comando efectuará una importación inicial del directorio miproyecto al repositorio que acabamos de crear. Deberemos de tener el puerto 3690 abierto tanto en entrada como salida para poder usar el servidor y clientes de SVN respectivamente, podemos usar estos comandos:

iptables -A INPUT -p TCP --dport 3690 -j ACCEPT
iptables -A OUTPUT -p TCP --dport 3690 -j ACCEPT

Ya tenemos nuestro servidor corriendo, vamos a ver como configurar los accesos al servidor. Si accedemos al directorio /root/repos/nombre_repositorio veremos que hay creados 3 ficheros: authz , passwd y svnserve.conf. Hacemos una copia de seguridad antes de editarlos por si acaso :)
Vamos al fichero svnserve.conf y dejamos los siguientes valores:

[general]
anon-access = none
auth-access = write
password-db = passwd
authz-db = authz
realm = Mi software

Como veis, hemos limitado el acceso a gente anonima, por lo que todo el mundo deberá de acceder con usuario y contraseña que ahora veremos como definir. Ahora vamos al fichero passwd y dejamos los siguientes valores para crear el usuario david, puede cambiar el nombre de usuario y pass por el que quieras, logicamente:

[users]
david = MiPasComplicado4758965

Por último editamos el fichero authz y lo dejamos como se muestra:

[groups]
# harry_and_sally = harry,sally

[nombre_repositorio:/]
david = rw

Como puedes ver, se pueden definir grupos. En este caso le damos acceso de lectura y escritura al usuario david. Guardamos los cambios y ya tenemos nuestro servidor SVN configurado. Ahora vamos a ver como usar el cliente de línea de comandos de una forma básica.

Usando el cliente de SVN

Nos vamos a un ordenador cualquiera y hacemos el checkout inicial, para ello navegamos en línea de comandos hasta el directorio donde queremos hacer el checkout y usamos el siguiente comando:

svn checkout --username david svn://miserver.com:3690/nombre_repositorio/

Nos pedira el password y descargará todo el código al directorio actual. Ahora vamos a ver un par de comandos básicos para añadir ficheros y actualizar nuestro código. Imaginar que queremos crear un nuevo directorio y dentro de este directorio queremos crear un fichero, pues accedemos al código y ejecutamos lo siguiente.

mkdir midir
cd midir
nano mificheronuevo.php
#Escribimos el contenido que necesitemos

#Añadimos un nuevo fichero
svn add midir mificheronuevo.php
svn commit -m "Comentarios del commit" midir mificheronuevo.php

Con este código creamos un nuevo directorio, dentro creamos un fichero, los añadimos al repositorio central de Subversion y ejecutamos el commit para subirlos al servidor.

Copias de seguridad de Subversion

Podemos hacer copias de seguridad de nuestro repositorio empleando el siguiente comando:

svnadmin dump /root/repos/nombre_repositorio > nombre_repositorio.svn_dump

Después podemos recuperarla fácilmente en otro servidor creando un nuevo respositorio y volcando el dump:

svnadmin create /root/repos/nombre_repositorio
svnadmin load /root/repos/nombre_repositorio < nombre_repositorio.svn_dump

Si investigas un poco más, verás como puedes hacer dumps solo de los cambios efectuados a partir de un número de revisión concreto y muchas cosas más. De momento, hasta aquí hemos llegado.. Recomiendo la lectura de este artículo de Ariel Camus para los no iniciados. Saludos!!

El otro día publicamos en WebEmpresa una serie de videotutoriales que estube realizando en el trabajo y que conforman un curso sobre el componente BreezingForms, componente utilizado para crear formularios. BreezingForms es una evolución del no continuado FacileForms, adaptado a Joomla 1.5 por Crosstec y muy ampliado con respecto a su hermano pequeño.

Realmente es una opción muy buena si piensas trabajar mucho con Joomla.

Algunos de los contenidos que se ven en este curso son:

1. Creación de formularios en el modo clásico
2. Creación de formularios en el modo fácil
3. Creación de formularios en el modo rápido
4. Uso del modo Integrator
5. Creación de formularios multi-idioma con Joomfish y BreezingForms

Podéis ver los vídeos desde la página de Vimeo Youtube de WebEmpresa.

Facebook es uno de los sitios web más concurridos del planeta, de hecho, según el ranking de Alexa es el segundo dominio con más tráfico de internet. Esta red social se encuentra desarrollada en PHP, lo que demuestra la gran escalabilidad que puede llegar a tener esta tecnología.

Los ingenieros de Facebook, se han tenido que enfrentar a muchos problemas a la hora de mantener en pie su portal, y uno de ellos es la cantidad de CPU usada por PHP, que al tratarse de un lenguaje dinámico requiere un mayor uso de la CPU para ejecutar el código. Para optimizar este proceso, los ingenieros de Facebook han creado el proyecto “HipHop for PHP”.

HipHop for PHP analiza el código fuente en PHP y lo convierte en un código C++ que se compila con g++. Este código C++ se ejecuta como extensión de PHP, es decir, lo que se ejecuta es una dll, un binario ejecutable, y no se tiene que interpretar el código cada vez que se hace una petición.

Con este sistema han logrado reducciones de uso de CPU de hasta el 50%, que es un resultado más que interesante.

Pese a lo interesante que parece, el sistema acaba de ser anunciado y no es perfecto, por lo que si nuestro código hace uso de funciones PHP propias de lenguajes dinámicos, como eval(), o create_function(), HipHop no será capaz de transformar el código fuente, aunque se está trabajando en soportar estas funciones.

¿Te imaginas el core de Joomla optimizado con HipHop? ¿Te imaginas poder instalar una extensión de PHP que ejecute toda la lógica de CMS’s como Joomla o WordPress reduciendo en un 50% el uso de CPU? En un futuro es posible, quien sabe.

En Ustream puedes ver el video de la presentación en inglés.

Timthumb es un script PHP, desarrollado por Darren Hoyt, que resulta muy útil para redimensionar imágenes usando PHP. Se utiliza bastante en templates para WordPress, para crear los thumbnails de los posts. Además permite hacer crop de las imágenes para que no pierdan las proporciones al ser redimensionadas. Necesita que la librería GD esté cargada, cosa que casi todos los hostings tienen.

Para empezar a usar el script solo tienes que bajartelo desde el SVN de Google Code. Una vez descargado, muévelo a tu servidor web. La primera vez que lo uses, el script creará un subdirectorio con el nombre “cache”. En este subdirectorio se almacenarán los thumbnails realizados para no tener que redimensionar las imágenes cada vez que se realiza una petición. El subdirectorio “cache” tiene que tener permisos de escritura y ejecución para que todo funcione bien (por supuesto, de lectura también). Una vez todo esté en sus sitio puedes empezar a usar el script de esta manera tan sencilla:

<img src="/scripts/timthumb.php?src=/images/imagen_grande.jpg&h=150&w=150&zc=1" alt="thumb" >

Las opciones que tiene el script son las siguientes:

• w: anchura del thumbnail
• h: altura del thumbnail
• zc: zoom crop (0 o 1)
• q: quality (por defecto es 75, y lo máximo es 100)

Ejemplos de Timthumb

He realizado algunos ejemplos usando una imagen de un balón de futbol. El tamaño original de la imagen es de 1280×1024. Vamos a ver el efecto del script sobre la imagen:
Redimensión a 150×150 sin zoom crop

<img src="/scripts/timthumb.php?src=/images/balon_grande.jpg&h=150&w=150" alt="thumb" >

Redimensión a 150×150 con zoom crop

<img src="/scripts/timthumb.php?src=/images/balon_grande.jpg&h=150&w=150&zc=1" alt="thumb" >

Como se puede observar, el zoom crop hace su faena y evita que la imagen se distorsione, aunque sea a costa de perder un trozo de imagen en el lateral. Si quieres que la imagen ocupe menos espacio puedes jugar con el parametro “q”, que por defecto se establece a 75, pero lo puedes reducir para bajar la calidad del thumbnail y que ocupe menos espacio.
Redimensionar solo la altura

<img src="/scripts/timthumb.php?src=/images/balon_grande.jpg&h=150" alt="thumb" >

Indicando solo la altura, se redimensiona la imagen manteniendo las proporciones.

Posición del crop

El crop, por defecto se hace en la parte central de la imagen, pero en imágenes grandes puede ser que al hacer crop se elimine la parte de la imagen menos apropiada. Para evitar esto Studio-XL ha desarrollado una modificación del script. Se puede descargar desde su sitio. Su script funciona exactamente igual, pero añade la opción de especificar el parámetro “cropfrom”. Cropfrom puede tener los siguientes valores:

1. middle
2. middleleft
3. middleright
4. topleft
5. topright
6. topcenter
7. bottomleft
8. bottomright
9. bottomcenter

El resultado de aplicar estos parámetros es el siguiente:

Cropfrom topleft

<img src="/scripts/timthumb.php?src=/images/balon_grande.jpg&h=150&w=150&zc=1&cropfrom=topleft" alt="thumb" >

Cropfrom topright

<img src="/scripts/timthumb.php?src=/images/balon_grande.jpg&h=150&w=150&zc=1&cropfrom=topright" alt="thumb" >

Un script muy fácil de usar que sin duda nos puede ayudar a crear plantillas más creativas.

La programación web es un mundo complejo e inseguro. La seguridad de nuestra aplicación depende de muchos factores que debemos tener en cuenta, desde la seguridad del servidor donde se aloja, hasta las técnicas de programación empleadas en esta.

Una de las vulnerabilidades que más se ha explotado útimamente han sido las basadas en ataques XSS (Cross Site Scripting), que consiste en inyectar código malicioso en un sitio web para que se ejecute automáticamente al abrirlo en el navegador.

Imagina por un momento que eres un Webmaster de una comunidad de usuarios y utilizas el CMS Joomla para administrarla. Imagina que usas un componente de terceros para administrar los roles de usuarios, etc.. algo muy común. Un buen día llegas a casa y abres una sesión como administrador de tu sitio, y te quedas logueado con la pestaña abierta. Ahora abres otra pestaña, y en esta pestaña hay un código Javascript que hace algo como lo siguiente:

window.location.href= "http://tuSitioJoomla/administrator/index2.php?option=com_users&task=deleteall..."

Al estar logueado como administrador, si el componente no está debidamente protegido es posible que llegue a borrar todos los datos de nuestros usuarios, y nuestra amada comunidad se irá al garete en menos que canta un gallo. Si encima, estó lo combinamos con una política de copias de seguridad insuficiente o inexistente, nos encontraremos ante una situación bastante dificil de resolver y que seguro que nadie le gustaría vivir.

Esta técnica de construir consultas maliciosas aprovechandose de la sesión de un administrador es una rama del XSS denominada como CSRF(Cross Site Request Forgery).

Para evitar estos problemas de seguridad, el API de Joomla proporciona unos métodos interesantes cuya finalidad es comprobar que la petición se ha realizado desde un sitio seguro, y no la está relizando cualquiera. Estos métodos generan un Token, (en español testigo) que es único para cada sesión que se genera en el servidor. Este token es un conjunto de carácteres generados en base a tu dirección IP, hora y algunos parámetros variables, con el fin de dificultar o imposibilitar la recreación del mismo token por el atacante (que académico me ha quedado este párrafo ;-) ). Cuando recibamos los datos en el servidor, deberemos comprobar que el testigo se encuantra intacto en la petición, y que por lo tanto se puede garantizar la autenticidad de la petición, es decir, que esta petición la hemos generado nosotros y no la ha generado un script malintencionado. La implementación con el API de Joomla es muy sencilla. Si no tienes conocimientso sobre el API de Joomla es recomendable que te leas los tutoriales sobre desarrollo de extensiones en Joomla.

Método POST

Tenemos el siguiente formulario:

<form action="index.php" method="post">
 
	Nombre:
<input name="nombre" type="text" />
 
	Email destino:
<input name="email" type="text" />
 
	Cuerpo:
<input name="cuerpo" type="text" />
 
	<input type="submit" value="Enviar Email" />
        <?php echo JHTML::_( 'form.token' ); ?>
	<input name="option" type="hidden" value="com_prueba" />
	<input name="task" type="hidden" value="enviarEmail" />
</form>

Mediante el siguiente código:

<?php echo JHTML::_( 'form.token' ); ?>

se genera el token, que valida que realmente es el usuario el que ha enviado la petición. Después, en el task, se valida que el token sea correcto. El token, en este caso es un campo de tipo hidden con una cadena de caracteres aleatoria para cada sesión. A continuación se muestra el codigo del task enviarEmail.

   function enviarEmail(){
      JRequest::checkToken() or die( 'Token invalido' );
 
      echo "email enviado!!";
   }

Si todo a funcionado correctamente, se mostrará un mensaje por pantalla indicando que el email a sido enviado correctamente. En caso de que la petición haya sido creada desde un sitio diferente que no sea la página de administración de Joomla aparecerá un mensaje advirtiendonos que el Token es invalido, y se interrumpirá la aplicación. La comprobación la realiza el método checkToken, que genera el mismo Token y lo compara con el que viene desde el cliente, en caso de ser diferentes se cancela la ejecución del script.

Método GET

Para usar los tokens con el método GET se hace usando el objeto JUtility. A continuación se muetsra el código de una típica tabla donde se muestra una lista de usuarios con enlaces para borrar cada usuario, muy tipico.

<table border="0">
<tbody>
<tr>
  <td>
	David
  </td>
  <td>
	<a href="<?php echo JRoute::_( 'index.php?option=com_prueba&amp;task=eliminar&amp;usuario=David&'. JUtility::getToken() .'=1' ); ?>">Eliminar</a>
  </td>
</tr>
<tr>
  <td>
	Pepe
  </td>
  <td>
	<a href="<?php echo JRoute::_( 'index.php?option=com_prueba&amp;task=eliminar&amp;usuario=Pepe&'. JUtility::getToken() .'=1' ); ?>">Eliminar</a>
  </td>
</tr>
<tr>
  <td>
	Juan
  </td>
  <td>
	<a href="<?php echo JRoute::_( 'index.php?option=com_prueba&amp;task=eliminar&usuario=Juan' ); ?>">Eliminar</a>
  </td>
</tr>
</tbody>
</table>

La orden de borrar se envía al task eliminar. A continuación se muestra el código.

	function eliminar(){
		JRequest::checkToken( 'get' ) or die( 'Token invalido' );
		echo "Usuario eliminado!!";
	}

Una vez introducida la protección en el task, si alguien intenta enviar una dirección del estilo “index.php?option=com_prueba&task=eliminar&usuario=Juan”, obtendrá el mensaje “Token invalido”, de hecho, si intentas eliminar a Juan, como no se le ha introducido el token, dará error y no será borrado.

Conclusión

Usando este método solventaremos casi todos los problemas de Cross Site Request Forgery y spoofing que nos podamos encontrar, y es muy recomendable (yo diría que obligado) utilizar está tecnica, que resulta muy sencilla y fácil de implementar. Descargar código de componente con el ejemplo.

Vía Documentación oficial de Joomla