# ivirtual networks » Webmasters

Chuleta de expresiones regulares – PHP

Bony — Fri, 05 Mar 2010 03:19:59 +0000

De la mano de AddedBytes.com, les traemos (ellos trajeron, mas bien… pero queda molon!), esta chuleta del estilo “no salgan de casa sin ella”, escencial para programar y para intentar (no prometemos nada..) no volverse loco.

Aca les dejo unos ejemplos de lo que contiene la chuleta:

([A-Za-z0-9-]+) – Letters, numbers and hyphens

(\d{1,2}\/\d{1,2}\/\d{4}) – Date (e.g. 21/3/2006)

([^\s]+(?=\.(jpg|gif|png))\.\2) -jpg, gif or png image

(^[1-9]{1}$|^[1-4]{1}[0-9]{1}$|^50$) – Any number from 1 to 50 inclusive

(#?([A-Fa-f0-9]){3}(([A-Fa-f0-9]){3})?) – Valid hexadecimal colour code

((?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,15}) – 8 to 15 character string with at least one upper case letter, one lower case letter, and one digit (useful for passwords).

(\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,6}) – Email addresses

(\<(/?[^\>]+)\>) – HTML Tags

Ya visto algun ejemplillo, vamos a los links de descarga:

Download: http://www.megaupload.com/?d=VQTSY0SF

Password:

http://www.informaticavirtual.us

Saludos.

Head First Javascript – O’Reilly

Bony — Fri, 29 Jan 2010 01:06:34 +0000

Otro libro de las series Head First de O’Reilly, solo para principiantes, ya saben como son en las series Headfirst, son bien para novatos, para gente que este comenzando a programar.

Son entretenidos, bien explicados, y dinamicos.. varios dibujos en ellos, cosa de que no sea puro texto plano, para no aburrirnos tanto xD.

En fin, para leer mas o menos las caracteristicas de los Headfirst pueden ver este post que detalla bien todo.

Ahora, en cuanto al libro:

621 Paginas || Peso: 50Mb (Descomprimido) – 37Mb (Comprimido) || Idioma: Ingles

Descargar: http://www.megaupload.com/?d=8RDX28KQ

Pass: http://www.informaticavirtual.us

Saludos

Programacion para Internet: Perl & CGI

Bony — Thu, 14 Jan 2010 11:15:09 +0000

Un libro interesante sobre programacion en perl, seguramente si te interesa empezar a programar en perl (como yo), te resultara interesante.. al menos como un comienzo..

Tiene buenos ejemplos, aunque el tipico y odiable “Hola Mundo!”, tiene su antiguedad.. pero aun asi para mi sigue siendo util.., es una mezcla de un libro de referencias, y un libro de aprendizaje.

Sin mas, vamos a la informacion del libro:

Idioma: Español || Paginas: 175 || Peso: 1.1 Mb (Comprimido)

Descargar:

http://www.megaupload.com/?d=KC1N4QFJ

Se descomprime con el Winrar nomas, si pide contraseña es esta:

http://www.informaticavirtual.us

Saludos.

Sistema de login con PHP y MySQL

mnosh — Sat, 09 Jan 2010 00:34:31 +0000

Vamos a mostrar cómo crear un sistema de login utilizando PHP con el driver de PDO (para php5.x) y una base de datos MySQL.
La idea principal es registrar usuarios, loguearlos en el sitio y desloguearlos del mismo de la forma más simple para luego poder proteger áreas con unas simples líneas de código.
Partimos de una base de datos, no muy complicada, desde la consola podemos crearla con la siguientes consultas:

CREATE TABLE `users`.`acccounts` (
`id` INT( 11 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`nick` VARCHAR( 20 ) NOT NULL ,
`email` VARCHAR( 50 ) NOT NULL ,
`password` VARCHAR( 32 ) NOT NULL ,
`salt` CHAR( 6 ) NOT NULL
) ENGINE = MYISAM ;

Bien, nuestra base de datos se llama “users” y dentro tenemos nuestra tabla “accounts” la cual cuenta con una columna id, nick, email, password y salt.
La columna password almacenara la contraseña del usuario concatenada con el salto, todo esto encriptado en MD5, con lo cual conseguimos distintos hashes para mismos passwords (esto evita comparar hashes entre sí o contra alguna lista en internet).
Ok, para intentar hacerlo lo más simple posible, voy a utilizar un archivo con todas las funciones, clases, instancias, etc. y lo incluiré al principio de cada archivo.. evidentemente en un proyecto ordenaríamos el asunto, a modo de funcionar en MVC o como sea.

Bien, iniciamos la sesión y definimos las constantes para la conexión a la base de datos.

1
2
3
4
5

session_start();
defined('DB_HOST')? null : define("DB_HOST", "localhost"); //servidor mysql
defined('DB_USER')? null : define("DB_USER", "root"); // usuario mysql
defined('DB_PASS')? null : define("DB_PASS", ""); // password del usuario mysql
defined('DB_NAME')? null : define("DB_NAME", "users"); // nombre de la base de datos

creamos un objeto $db ,instancia de PDO con los atributos para manejar errores:

1
2
3
4
5
6

try {
$db = new PDO('mysql:host='.DB_HOST.';dbname='.DB_NAME, DB_USER, DB_PASS);
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch( PDOException $e ) {
die($e);
}

Nuestra clase Session, la cual manejara métodos para loguear, checar logueo y desloguear a nuestros usuarios.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Class Session{
public $datos;
public function logIn($datos){
$_SESSION['datos']=$datos;
$_SESSION['status']=true;
}
public function logOut(){
$this->datos=null;
$_SESSION['status']=false;

}
public function is_logged_in(){
if(isset($_SESSION['status'])){
$this->datos = unserialize($_SESSION['datos']);
return $_SESSION['status'];
}return false;

}
}
$session = new Session();

Creamos una clase Usuario, con métodos logIn y register.
el método register, comprueba que el nickname y el email ya no estén utilizados por algún otro usuario, luego inserta en la base de datos las credenciales si estas son validas.
$result=$result->fetch(PDO::FETCH_ASSOC) almacena en $result un array asociativo con los datos de la primer fila del resultado de la consulta. Para levantar todos los resultados utilizaríamos $result=$result->fetchAll(PDO::FETCH_ASSOC), con FETCH_NUM para recuperar arrays de índice numérico.
$result->rowCount() devuelve la cantidad de filas afectadas por la última consulta SQL, esperamos un 1 para un registro satisfactorio.
catch(PDOException $e) captura excepciones de PDO. Mientras desarrollamos podemos imprimir estos errores en pantalla para depurar, y en producción podemos enviarlos a un archivo de log.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public function register($nick, $email, $password, $salt){
global $db;
global $session;
try{
$result=$db->prepare("SELECT nick, email FROM acccounts WHERE acccounts.nick=:nick OR acccounts.email=:email LIMIT 1");
$result->bindParam(':nick',$nick);
$result->bindParam(':email', $email);
$result->execute();
$result=$result->fetch(PDO::FETCH_ASSOC);
if(!empty($result)){
$msg='';
if($result['nick']==$nick){ $msg.='

Nick name en uso

';}
if($result['email']==$email){ $msg.='

Email ya en uso

';}
return $msg;
}else{
try{
$result=$db->prepare("INSERT INTO acccounts(nick, email, password, salt) VALUES(:nick, :email, :password, :salt)");
$result->bindParam(':nick',$nick);
$result->bindParam(':email',$email);
$result->bindParam(':password',$password);
$result->bindParam(':salt',$salt);
$result->execute();
if($result->rowCount()){
$msg='nueva cuenta creada';
return $msg;
}

}catch(PDOException $e){
return false;
}
}
}catch(PDOException $e){
return false;
}
}
$user = new User();

Finalmente una pequeña función para generar saltos al azar, los cual luego concatenaremos al password de nuestro usuario.

1
2
3
4
5
6
7
8
9
10

function randomCH($size){
$i=0;
$keyString='';
while ($i < $size) {
$str = rand(97, 122);
$keyString .= chr($str);
$i++;
}
return $keyString;
}

Con esto ya tendríamos para generar registros, loguear, desloguear y chequear usuarios así como acceder a los datos de los mismos.

Aquí cerraríamos nuestro archivo de configuración el cual incluiríamos en todos los archivos que tengan que ver con el manejo de credenciales.
Ahora vamos a crear un índex, con 2 formularios, uno para registrar cuentas y el otro para loguear

1
2
3
4
5

require_once('dbconfig.php');
if($session->is_logged_in()){
echo 'hello '.$session->datos['nick'].' [ salir ]';
}else{
?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<div id="login_form">
<form action="login.php" method="POST">
<p>Nick: <input type="text" name="nick" size="20"/></p>
<p>Pass: <input type="password" name="password" size="20"/></p>
<p><input type="submit" name="login" value="Login"/></p>
</form>
</div>
<div id="register_form">
<form action="new_account.php" method="POST">
<p>Nick: <input type="text" name="nick" size="20"/></p>
<p>eMail: <input type="text" name="email" size="20"/></p>
<p>re-pass: <input type="password" name="repass" size="20"/></p>
<p>Pass: <input type="password" name="password" size="20"/></p>
<p><input type="submit" name="register" value="Register"/></p>
</form>
</div>

} ?>

Utilizando nuestro método $session->is_logged_in(), sabremos si el usuario esta logueado, de ser así, enviamos un saludo junto en enlace al logout y el nombre del usuario levantando desde el array. El método
is_logged_in recoge el estado directo desde la session, y deserializa el array con los datos del usuario (mail y nick en este caso) al cual luego accedemos desde $session->datos['nick']

en caso de no estar logueado, devuelve false y se ejecuta el else en el cual ofrecemos el formulario de login, y también el de registro.

El formulario de login nos lleva a login.php el cual contendría el siguiente código:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

require_once('dbconfig.php');
if(isset($_POST['login'])){
$nick=isset($_POST['nick'])? trim($_POST['nick']) : '';
$pass=isset($_POST['password'])? $_POST['password'] : '';
$err=0;
$output='';
if(!preg_match('/^[a-zA-Z0-9]{3,20}$/', $nick)){
$output.='

el nickname ingresado no es valido

';
$err++;
}
if(false !== strpos($pass, "\\")){ //pass sin "\"
$output.='

el password no puede contener \\

';
$err++;
}
if($err){
echo $output;
}else{
if($msg=$user->logIn($nick, $pass)){
header('Location: index.php');
}
}
}

Aquí requerimos el archivo de configuración con todo el yuyo dentro, y chequeamos los datos que nos devuelven, de la misma forma que lo haremos a la hora de registrar usuarios, con esto nos ahorramos consultar la base de datos si ya sabemos que los datos no deberían de estar presentes.
if(!preg_match(‘/^[a-zA-Z0-9]{3,20}$/’, $nick))
buscamos por un nick compuesto de letras y números, de un mínimo de 3 caracteres a un máximo de 20 (en nuestra SQL 20 fue el máximo de caracteres para el nick del usuario).
if(false !== strpos($pass, “\\”)
con esto chequeamos que el password no contenga una retrobarra “\” podemos agregar los filtros que queramos (máximo mínimo etc.).
cuando estamos ok con los datos enviados, intentamos loguear al usuario:
if($msg=$user->logIn($nick, $pass)){
header(‘Location: index.php’);
}
Aquí es simple y luego lo vamos a modificar, pero por el momento si logramos loguear al usuario (es decir si nos cae algo en $msg distinto de false, re direccionamos al index.php donde el usuario ya estará logueado y vera el mensaje de bienvenida.)
Sin registro, difícil tendremos usuarios, así que vamos a registrar algunos..
Nuestro formulario de registro, envía por métodos post a new_account.php y de esta forma lo registramos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

require_once('dbconfig.php');
if(isset($_POST['register'])){
$nick=isset($_POST['nick'])? trim($_POST['nick']) : '';
$email=isset($_POST['email'])? trim($_POST['email']) : '';
$pass=isset($_POST['password'])? $_POST['password'] : '';
$repass=isset($_POST['repass'])? $_POST['repass'] : '';
$output='';
$err=0;
if(!preg_match('/^[a-zA-Z0-9]{3,20}$/', $nick)){
$output.='

el nickname ingresado no es valido

';
$err++;
}
if(!filter_var($email, FILTER_VALIDATE_EMAIL)){
$output.='

el email ingresado no es valido

';
$err++;
}
if(false !== strpos($pass, "\\")){ //pass sin "\"
$output.='

el password no puede contener \\

';
$err++;
}
if($pass!=$repass){
$output.='

las contraseñas no coinciden

';
$err++;
}

if($err){
echo $output;
}else{
$salt=randomCH(6);
$pass=md5($pass.$salt);
if($msg=$user->register($nick, $email, $pass, $salt)){
echo $msg;
}
}
}

En este caso validamos el mail de igual forma que en login.php, y para el mail utilizamos un filtro:
(!filter_var($email, FILTER_VALIDATE_EMAIL)
no es una genialidad, se puede hacer algo más elaborado pero para este ejemplo nos valdrá.
La contraseña y la verificación de la misma deben ser iguales así que:
if($pass!=$repass){
$output.=’

passwords no coinciden

‘;
$err++;
}
si no hay errores registramos al usuario:
$salt=randomCH(6);
$pass=md5($pass.$salt);
if($msg=$user->register($nick, $email, $pass, $salt)){
echo $msg;
utilizando la función randomCH, pasándole 6 como parámetro (es la cantidad de caracteres para el salto en nuestra SQL)
concatenamos con el password del usuario y creamos un hash en md5
y luego, registramos al usuario e imprimimos el mensaje si nos llega.

Un archivo logout para deshacernos de la gente:

1
2
3

require_once('dbconfig.php');
$session->logOut();
header('Location: index.php');

Ok con eso ya tendríamos, nos valdría colocar al inicio de las paginas que requieran login el siguiente código:
if(!$session->is_logged_in()){
header(‘Location: login.html);
die();
}
aparte claro de incluir nuestro archivo de configuración para poder manejar sessiones y acceder a los métodos.
Bien…. bien feo pero bueno, la idea de este ejemplo es, aparte de ilustrar una forma para loguear usuarios (se puede complicar más, se puede utilizar otra encriptación etc. etc.), pero con este código el cual lo dejo para que lo bajen, en el próximo post, o en alguno de los próximos lo voy a retomar para mostrar una forma de loguear, deslogear y registrar usuarios utilizando Ajax, con jQuery y jSON.

Descargar archivos de ejemplo:
http://hotfile.com/dl/23457316/a5fd117/login.zip.html

Mas informacion:
http://www.php.net/manual/en/class.pdo.php

O’Reilly – Head First PHP & MYSQL

Bony — Thu, 31 Dec 2009 08:55:23 +0000

Un excelente e-book, en el cual aprendi mi base de programacion en PHP, si se tiene tiempo, y ganas de entender este lenguaje, con la ayuda algunas veces de un amigo (como yo la tuve por parte de mnosh), y la lectura de este libro, se puede llegar a tener una base muy solida.

Lo que mas impresiona del libro, es la manera de enseñar que tienen los tipejos de O’Reilly, muy particular.. en varios de sus libros dicen cosas como:

Usamos imagenes para que se entiendan mejor las cosas, y agregarle algo de humor al libro.

Si sos un programador profesional y solo buscas un libro de referencia, mejor no leas este libro.

Si no tenes idea del uso de la programacion, este libro es para ti.

Entre otros, es bastante entretenido el libro, y se aprende, el unico dilema para la mayoria de la gente es que esta en Ingles, si.. son 762 paginas en ingles, pero seguro que valen la pena (aparte, recuerden que no es puro texto.. por lo que leerlo nos llevara poco tiempo seguramente).

Sin mas, vamos a la informacion:

Idioma: Ingles || Paginas: 762 || Peso: 47Mb (Comprimido)

El link de descarga, es el siguiente:

http://www.megaupload.com/?d=WLDBDJXR

Y la contraseña para descomprimir el .rar (es una URL, si, no tienen que clickear en ella para recivir la contraseña, porque la URL es la contraseña):

http://www.informaticavirtual.us

Saludillos.

Como hacer un formulario de contacto con PHP utilizando captcha

Bony — Sun, 20 Dec 2009 07:00:19 +0000

Luego del post de mnosh, se me vino a la cabeza postear un formulario de contacto en PHP que yo tenia, empleando su captcha, para asi ya de paso, dar un ejemplo de como incorporarlo a un formulario, y usarlo correctamente.

En la carpeta “contacto” tenemos los siguientes archivos:

bauhs93.ttf
contacto.php
captcha.php (archivo de este post)

Vamos a usar una fuente nueva para nuestro captcha, asi que ya tenemos una linea que modificar en captcha.php.

Pero primero, vamos a ir con el codigo de contacto.php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//iniciamos session para poder acceder a ella a la hora de comprobar el codigo del captcha
session_start();

// $errores comienza en 0, se incrementaria si algo no va bien.
$errores=0;
// preparamos mensaje de salida como un string vacio, iremos agregando lineas a medida que vayamos encontrando errores.
$errMessage='';

//Chequeamos si se ha enviado el formulario.
if(isset($_POST['enviar'])){

//iniciamos y formateamos variables
$nombre=isset($_POST['nombre'])? ucwords(strtolower(trim($_POST['nombre']))) : '';
$email=isset($_POST['email'])? $_POST['email'] : '';
$texto=isset($_POST['texto'])? $_POST['texto'] : '';
$captcha = isset($_POST['captcha'])? $_POST['captcha'] : '';

// usamos el filtro para validar emails
if(!filter_var($email, FILTER_VALIDATE_EMAIL)){
// si no es valido, sumamos 1 a la cantidad de errores, y le agregamos a errMessage
// el error.
$errores++;
$errMessage.='el mail no parece valido
';
}
// comprobamos que el nombre contenga solo letras
if(!ereg('^[a-zA-Z]{3,40}$', $nombre)){
$errores++;
$errMessage.='a escrito un nombre incorrecto
';
}

// si el largo de la variable texto es mayor a 200...
if(strlen($texto)>200 || empty($texto)){
// sumamos 1 a la cantidad de errores, y le agregamos a errMessage el error.
$errores++;
$errMessage.='comentario demasiado largo
';
}

if($captcha != $_SESSION['cache_string']) {
// sumamos 1 a la cantidad de errores y agregamos el tipo de error a errMessage
$errores++;
$errMessage.='captcha ingresado invalido
';
}

// si no hay errores, entonces procedemos a armar, y enviar el mail..
if (!$errores) {
// armamos los headers del mensaje... el from, y etc..
$headers = "From: ".$email." ".$nombre. " <" .$email. ">";
//armamos el cuerpo del mensaje
$mensaje = "Administrador, han mandado un mail desde la web XXXXXXXX, el nombre del visitante es: {$nombre}, su email es: {$email} y el mensaje es el siguiente: \n\n {$texto}";
// @mail(...), devuelve true si la funcion no tiro ningun error (o sea, se mando el mail)
// si tu hosting no tiene smpt, te dara el error del else

if (@mail("matias.a18@gmail.com", "Asunto de nuestro mensaje", $mensaje, $headers)) {
echo '

Mensaje enviado satisfactoriamente

';
} else {
// el mensaje no ha podido ser enviado, mostramos el texto en la clase error de la css
// las razones por las que puede aparecer este mensaje es porque el puerto smpt no esta abierto
// en el servidor.
echo '

El mensaje no ha podido ser enviado

';
}
}else{
// como hubieron errores, los mostramos en la clase (definida en la .css) error.
echo '

' . $errMessage . '

';
}

}
?>

Como podran ver, usamos el archivo captcha.php, aunque, le cambiamos algo del anterior codigo, en la linea 16, en vez de ponerle:

1	$fontFile ="my_special_font.ttf";

Le ponemos:

1	$fontFile ="bauhs93.ttf";

Y listo, si el mensaje ha sido enviado correctamente, deberiamos recibir esta notificacion:

“Mensaje enviado satisfactoriamente”

Si el SMTP de nuestro hosting no esta activado, nos deberia de mostrar este mensaje:

“El mensaje no ha podido ser enviado”

Y, si hubo algun error, podriamos recibir alguno de los siguientes mensajes:

“captcha ingresado invalido” y/o “comentario demasiado largo” y/o “a escrito un nombre incorrecto” y/o “el mail no parece valido”.

Y listo, tenemos nuestro formulario de contacto hecho.. y listo.

Cualquier duda, en los comentarios.

Liberado Wordpress 2.9

mnosh — Sat, 19 Dec 2009 19:24:49 +0000

A partir de hoy los usuarios que utilizamos Wordpress podemos descargar automáticamente desde el dashboard la última versión de Wordpress 2.9 recientemente lanzada.

Entre las principales novedades se destaca la actualización de plugins en masa, con la cual podemos actualizar o comprobar actualizaciones para todos nuestros plugins y actualizarlos todos al mismo tiempo.

También se incluye la función trash, con lo cual en vez de eliminar un post o un comentario, ahora se envía a la papelera y permanecerá ahí por 30 días, con lo cual si nos arrepentimos podemos regresarla y por lo tanto no perderemos el post.

Aunque lo que más se destaca es sin duda el editor de imágenes, con lo cual ahora podremos subir una imagen y utilizar algunas herramientas básicas como crop y resize para quedarnos con una parte de la imagen o achicarla proporcionalmente, girarla, invertirla, etc.

Videos de YouTube, Daily Motion, Blip.tv, Flickr, Hulu, Viddler, Qik, Revision3, Scribd, Google Video, Photobucket, PollDaddy, y WordPress.tv ahora se insertan automáticamente

•   We now have rel=canonical support for better SEO.
•   There is automatic database optimization support, which you can enable in your wp-config.php file by adding define(‘WP_ALLOW_REPAIR’, true);.
•   Themes can register “post thumbnails” which allow them to attach an image to the post, especially useful for magazine-style themes.
•   A new commentmeta table that allows arbitrary key/value pairs to be attached to comments, just like posts, so you can now expand greatly what you can do in the comment framework.
•   Custom post types have been upgraded with better API support so you can juggle more types than just post, page, and attachment. (More of this planned for 3.0.)
•   You can set custom theme directories, so a plugin can register a theme to be bundled with it or you can have multiple shared theme directories on your server.
•   We’ve upgraded TinyMCE WYSIWYG editing and Simplepie.
•   Sidebars can now have descriptions so it’s more obvious what and where they do what they do.
•   Specify category templates not just by ID, like before, but by slug, which will make it easier for theme developers to do custom things with categories — like post types!
•   Registration and profiles are now extensible to allow you to collect things more easily, like a user’s Twitter account or any other fields you can imagine.
•   The XML-RPC API has been extended to allow changing the user registration option. We fixed some Atom API attachment issues.
•   Create custom galleries with the new include and exclude attributes that allow you to pull attachments from any post, not just the current one.
•   When you’re editing files in the theme and plugin editors it remembers your location and takes you back to that line after you save. (Thank goodness!!!)
•   The Press This bookmarklet has been improved and is faster than ever; give it a try for on-the-fly blogging from wherever you are on the internet.
•   Custom taxonomies are now included in the WXR export file and imported correctly.
•   Better hooks and filters for excerpts, smilies, HTTP requests, user profiles, author links, taxonomies, SSL support, tag clouds, query_posts and WP_Query

Mas informacion:
http://wordpress.org/development/2009/12/wordpress-2-9/

Creando un sistema simple para manejo de captcha en php

mnosh — Mon, 14 Dec 2009 05:31:05 +0000

Un sistema de captcha (Completely Automated Public Turing test to tell Computers and Humans Apart) es la solución frecuente para evitar que robots spamers que visiten nuestro sitio puedan registrarse, enviar comentarios, participar en encuestas o cualquier yuyo en cuestión. Si bien esto no nos garantiza un 100% de efectividad , de seguro nos vale.

Supongamos un sitio web desarrollado en php al cual queremos implementarle una solución para frenar bots spamers, bien entonces instalamos re-captcha y listo, gracias por participar…

Ok, si bien nos sirve, quizás queramos saber cómo funciona y por ahí crear el nuestro propio, así que de eso va este post… comencemos.

Para generar imágenes en php nos valemos de la librería GD el cual está presente en la mayoría de los web hosting. En caso de utilizar localhost, instalando wamp para Windows ya nos viene incluido, y desde Linux bastaría con compilar php con la opción de gd, así como las librerías de libpng y libjpeg ( ./configure –with-gd=/… –with-png-dir=/… –with-jpeg-dir=… ).

Básicamente lo que necesitamos es generar una cadena de texto con letras y números al azar, almacenarlo en la sesión y luego comprobar con lo que el usuario inserto en la caja del formulario, en caso de coincidir se salto el captcha, caso contrario regresamos con un mensaje de error y con una nueva imagen para intentar.

/** Archivo captcha.php **/

//iniciamos session
session_start();

// cantidad de letras en nuestro captcha
$passLength = 4;

// tamaño para la caja de captcha
$width = 200;
$height = 80;
// tamaño para el texto en pixceles
$textSize=30;
// archivo ttf que vamos a utilizar
// para escribir el texto en cuestion.
$fontFile ="my_special_font.ttf";

/**
* Genera un string con la cantidad de caracteres pasado.
* @param int $size cantidad de caracteres.
* @return $string mayusculas y numeros
*/
function randomCH($size){
$i=0;
$keyString='';
while ($i < $size) {
// AZ (65-90) 0-9 (48-57)
$str = rand(48, 90);
if($str<65 && $str>57){
continue;
}else{
$keyString .= chr($str);
$i++;
}
}
return $keyString;
}
// almacenamos un strign aleatorio
$cacheString=randomCH($passLength);

// almacenamos en la session la frase de la imagen
$_SESSION['cache_string']=$cacheString;

// creamos una imagen utilizando las medidas setteadas
$imgCaptcha = imagecreatetruecolor($width, $height);

// definimos algunos colores
//(esto debe hacerse luego de generar la imagen ya que debemos pasarle el recurso).
$blue = imagecolorallocate($imgCaptcha, 0, 0, 80);
$black = imagecolorallocate($imgCaptcha, 0, 0, 0);
$white = imagecolorallocate($imgCaptcha, 255,255,255);
$grey = imagecolorallocate($imgCaptcha, 100, 100, 100);

// creamos un par de rectangulos para simular un borde azul
imagefilledrectangle($imgCaptcha, 10, 10, $width-10, $height-10, $blue);
imagefilledrectangle($imgCaptcha, 20, 20, $width-20, $height-20, $black);

// cada texto se inclinara algunos pixceles de forma aleatoria
$rotationLetter = rand(-10, 10);

// escribimos en las canvas utilizando como parametros nuestra imagen, el tamaño de texto
// la rotacion aleatoria, posicion x, posicion y, color, archivo ttf y por ultimo el string
// utilizamos 2 textos para simular una sombra en gris por encima de las letras blancas
imagettftext($imgCaptcha, $textSize, $rotationLetter, 50, 55, $grey, $fontFile, $cacheString);
imagettftext($imgCaptcha, $textSize, $rotationLetter, 52, 57, $white, $fontFile, $cacheString);

// enviar cabezeras (para que no se cachee la imagen y el navegador siempre pida una nueva)
header("Expires: Tue, 20 Jul 2001 17:00:00 GMT");
header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
header("Cache-Control: no-store, no-cache, must-revalidate");
header("Cache-Control: post-check=0, pre-check=0", false);
header("Pragma: no-cache");

// enviar cabezera de imagen
header("Content-Type: image/png");

// utilizando imagejpeg o imagepng enviamos la imagen generada dinamicamente.
//imagejpeg($imgCaptcha);
imagepng($imgCaptcha);

// luego liberamos recursos en el sistema.
imagedestroy($imgCaptcha);
?>

Bien, leyendo los comentarios en el código se puede ir siguiendo paso a paso.
Ahora solo nos resta crear un formulario y llamar a la imagen como lo haríamos con una imagen estática desde HTML

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/** Archivo form.php **/
// iniciamos session
session_start();

// comprobamos si se envio el formulario y si lo que se envio coincide con el string guardado en session
if (isset($_POST["captcha"])) {
if ($_REQUEST["captcha"] == $_SESSION['cache_string']) {
echo "los caracteres ingresados son correctos..";
} else {
echo "error al ingresar los caracteres.";
}
exit(0);
}
?>

Bien, con eso ya estaríamos, y bastaría adaptarlo a nuestras necesidades.
Como comentarios finales, hay que prestar atención a algún par de cosirijillas, como por ejemplo:
1. debe iniciarse session en ambos archivos, (si el cliente no acepta cookies no nos servirá).

2. las cabeceras para evitar que la imagen sea cacheada por el navegador, y las cabeceras para decirle al navegador que es una imagen lo que debe esperar deben ser enviadas antes que nada, es decir que no nos vale generar ningún tipo de salida y luego intentar enviar cabeceras, esto produciría un error.

3. hay que revisar las rutas, pueden utilizar __FILE__ para referirse al path absoluto donde se encuentra en el servidor y luego concatenar rutas para encontrar el archivo de fuente, imágenes que quieran utilizar para complicar un poco más el texto, etc. En este caso tenemos todos los archivos en la misma carpeta (captcha.php, form.php y font.ttf).

4. al final del código utilicé la función imagepng($imagen), y también valdría utilizar imagejpeg($imagen), con una diferencia en calidad, sobre todo si utilizan imágenes externas con degrado, y por supuesto una saca en pantalla una imagen png, mientras que la otra una jpg.

5. el tipo de fuente es Bauhaus (la pueden buscar en su directorio de fuentes) o utilizar cualquier otra, claro está que deberían de chechear que sea legible por humanos.

Resultado final:

Para mas información sobre como manipular imágenes en php, pueden consultar el siguiente enlace:

http://php.net/manual/en/book.image.php