<Construir um simples Captcha ⁄ >

body{
  font-family: Verdana, Tahoma, Arial, sans-serif;font-size: 62.5%;
  color: #000;background: #fff;text-align: left;
}
 
form#my_form_captcha{
  padding: 1.5em;
  border: solid 0.6em #36393D;
  width: 33em;
}
 
form#my_form_captcha span.error{
  color: #FF1A00;font-size: 1.2em;
  text-decoration: underline;font-weight: 900;
}
 
label{font-size: 1.1em;}
 
label#lbl_my_captcha{
  font-weight: 700;font-size: 1.4em;color: #4096EE;
}
 
input{
  border: solid .04em #C3D9FF;color: #B02B2C;
  background-color: #FFFF88;
}
input#my_captcha_value{
  font-size: 2.5em; border-color: #FF7400;text-align: center;
}
 
input#bt_action{
  background-color: #356AA0;font-size: 1.4em;color: #F9F7ED;
  font-weight: 900;border: 0;
 
}
 
fieldset#my_captcha_fieldset{
  text-align: center;width: 31em;border: solid .5em #F9F7ED;
}
 
fieldset#my_captcha_fieldset legend{
  border: solid .01em #D15600;font-size: 1.5em;
  font-variant: small-caps;padding: .4em;
  font-weight: 800;background-color: #FF7400;color: #eee;
}

<?php
//class para automaticamente fazer o load das classes
if(function_exists("__autoload")) return;{
  function __autoload($class){
    include_once("class.$class.php");
  }
}
?>

<?php
 
/**
 * Class SingletonBasicMath
 * Esta class serve como exemplo para a implementação 
 * de PHP Chaining e o uso de Singleton
 */
class SingletonBasicMath {
 
  private static $_instance;
  private $_value = 0;
 
  /**
    * Método Construtor
    * Vai impossibilitar que sejam criadas várias instâncias do objecto
    */
  public function __construct() {
    //permite só que seja criada uma única instância de um objecto (Singleton)
    if (!self::$_instance) {self::$_instance = $this;}
  }
 
  public function Sum($value) {
    $this->_value += $value;
    return $this;
  }
 
  public function Subtract($value) {
    $this->_value -= $value;
    return $this;
  }
 
  public function Multiply($value) {
    $this->_value *= $value;
    return $this;
  }
 
  public function Divide($value) {
    $this->_value /= $value;
    return $this;
  }
 
  public function Reset() {
    $this->_value = 0;
    return $this;
  }
 
  public function Result() {return $this->_value;}
 
  public function toString() {return "<br>Result = {$this->Result()}<br>";}
 
  /**
    * Eliminar referências do objecto
  */
  public function __destruct() {
    $this->_value = null;
    self::$_instance = null;
  }
}
 
?>
 

<?php
 
/**
 * Abstract Class MyCaptcha
 * 
 * Esta class não pode ser instanciada, só extendida.
 * 
 * É implementada a Pattern Singleton
 *
 * @author Pedro Correia - pedrocorreia.net
 */
abstract class MyCaptcha{
  private static $_instance;
  private $_result;
 
  /**
   * Método construtor
   *
   * @param Int Resultado
   */
  public function __construct($result){
    //singleton design pattern
    if (!self::$_instance) {self::$_instance = $this;}
    $this->_result=$result;
  }
 
  /**
   * Obter Resultado
   *
   * @return Int
   */
  public function GetResult(){return $this->_result;}
 
  /**
   * Verificar se o captcha é ou não válido
   *
   * @param Int
   * @return Boolean
   */
  public final function Validate($value){return ($value==$this->GetResult());}
 
  /**
   * Codificar String
   *
   * @param String Texto a codificar
   * @param Bool Codificar tudo?
   * @return String
   */
  public function Encode($string,$encodeAll=true){
    $chars = array();
    $ent = null;
 
    $chars = preg_split("//", $string, -1, PREG_SPLIT_NO_EMPTY);
    $count=count($chars);
    for ($i = 0; $i < $count; $i++){
      if (preg_match("/^(\w| )$/",$chars[$i]) && $encodeAll == false)
      $ent[$i] = $chars[$i];
      else
      $ent[$i] = "&#" . ord($chars[$i]) . ";";
    }
    if ( sizeof($ent) < 1) return "";
 
    return implode("",$ent);
  }
}
 
?>

<?php
 
/**
 * Class MySimpleMathCaptch
 * 
 * Esta class vai extender a MyCaptcha e construir 
 * um Captcha à base de 2 operações numéricas: soma e multiplicação
 *
 * @author Pedro Correia - pedrocorreia.net
 */
class MySimpleMathCaptcha extends MyCaptcha {
 
  private $_lnumber=0;
  private $_rnumber=0;
  private $_operand="+";
  private $_allowed_operands="+*";
 
  private $_min_rand_number=1;
  private $_max_rand_number=32768;
 
  //variável estática que identifica o nome a utilizar
  //quando o objecto for serializado e guardado na Session
  public static $_session_serialize="my_simplemath_captcha";
 
  /**
   * Método construtor.
   *
   * @param Int 1º Número
   * @param Int 2º Número
   * @param Char Operando
   * @param Int Número minimo para a aleatoriedade
   * @param Int Número máximo para a aleatoriedade
   */
  public function __construct($lnumber="",$rnumber="",$operand="+",$min_rand="",$max_rand=""){
    $is_allowed=strpos($this->_allowed_operands,$operand);
    if (!is_numeric($is_allowed)) throw new Exception("OperandIsNotAllowed");
 
    if($min_rand) $this->RandNumberMin($min_rand);
    if($max_rand) $this->RandNumberMax($max_rand);
 
    if(!$lnumber) $lnumber=mt_rand($this->_min_rand_number,$this->_max_rand_number);
    if(!$rnumber) $rnumber=mt_rand($this->_min_rand_number,$this->_max_rand_number);
    $this->_operand=$operand;
    $this->_lnumber=$lnumber;
    $this->_rnumber=$rnumber;
 
    //criar objecto SingletonBasicMath
    $math=new SingletonBasicMath();
 
    //verificar qual a operação e obter o seu resultado
    switch ($this->_operand){
      case "+":
        $result=$math->Sum($lnumber)->Sum($rnumber)->Result();
        break;
      case "*":
        $result=$math->Sum(1)->Multiply($lnumber)->Multiply($rnumber)->Result();
        break;
    }
 
    //guardar o resultado
    parent::__construct($result);
  }
 
  /**
   * Getter/Setter número minimo para calcular a aleatoriedade
   *
   * @param Int
   * @return Int
   */
  public function RandNumberMin($value){
    if($value) $this->_min_rand_number=$value;
    else return $this->_min_rand_number;
  }
 
  /**
   * Getter/Setter número máximo para calcular a aleatoriedade
   *
   * @param Int
   * @return Int
   */
  public function RandNumberMax($value){
    if($value) $this->_max_rand_number=$value;
    else return $this->_max_rand_number;
  }
 
  /**
   * Formatar String para ser apresentada ao utilizador
   *
   * @param String
   * @return String
   */
  public function ToString($encode=true){
    $str=sprintf("%d %s %d = ",$this->_lnumber,$this->_operand,$this->_rnumber);
    if($encode) $str=$this->Encode($str);
 
    return $str;
  }
 
}
?>

<?php
session_start();
 
$action=$_POST["bt_action"];
 
//não há postback, estamos a aceder pela 1ª vez à página
if(!$action) {
  $output=BuildForm();
}
 
//há um postback, vamos verificar se o captcha está ou não correcto
//se estiver correcto enviamos para o output uma mensagem de sucesso,
//caso contrário, construímos novamente o formulário
else if($action){
 
  //buscar o objecto à Session
  $session_name=MySimpleMathCaptcha::$_session_serialize;
  $session=$_SESSION[$session_name];
 
  //se o objecto se encontra na session, vamos então fazer o unserialize
  if($session){
    //fazer o unserialize ao objecto para que podemos aceder aos
    //seus métodos e atributos
    $captcha=unserialize(base64_decode($session));
 
    //verificar se o resultado inserido pelo utilizador é o resultado do captcha
    //para tal recorremos ao método "Validate"
    if($captcha->Validate($_POST["my_captcha_value"])){
      $output="Obrigado pelo registo ...";
    }
    else{ //o captcha está errado
      $output=BuildForm("Verifique se inseriu correctamente o resultado");
    }
  }
  //por algum motivo o objecto não se encontra na Session, 
  //vamos construir novamente o formulário
  else{
    $output=BuildForm();
  }
}
 
 
/**
 * Construir Formulário, CAPTCHA e guardar o objecto serializado na sessão
 *
 * @return String
 */
function BuildForm($error_msg=""){
 
  //construir CAPTCHA
  $captcha=new MySimpleMathCaptcha();
 
  //guardar objecto serializado na sessão
  $_SESSION[MySimpleMathCaptcha::$_session_serialize]=base64_encode(serialize($captcha));
 
  if($error_msg) $error_msg="<span class='error'>$error_msg</span><br/><br/>";
 
  return "
  <form method='post' action='' id='my_form_captcha'>
    $error_msg
    <label for='my_email' id='lbl_my_email'>E-mail</label>
    <input type='text' id='my_email' name='my_email' size='20' />
    <br/><br/>
 
    <fieldset id='my_captcha_fieldset'>
      <legend>Insira o Resultado</legend>
      <label for='my_captcha_value' id='lbl_my_captcha'>{$captcha->ToString()}</label>
      <input type='text' value='' name='my_captcha_value' id='my_captcha_value' size='10' />
    </fieldset>
 
    <br/><br/>
    <input type='submit' value='Enviar Dados' id='bt_action' name='bt_action' />
 
  </form>
  "; 
}
 
 
?>

<?php
include_once ("Classes/AutoLoad.inc");
include_once ("ProcessRequests.php");
?>
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>MyCaptcha</title>
<link rel="stylesheet" type="text/css" href="css/style.css" media="all" />
</head>
<body>
  <?php
    echo $output;
  ?>
</body>
</html>