Usar la SDK de AmazonS3 para subir ficheros con PHP

Muy simple y en sencillos pasos os explicaré como podemos subir nuestros ficheros a nuestro almacen de amazon S3.

Para empezar nos descargamos la SDK de la web oficial Descargar SDK para PHP.

Descomprimimos y configuramos el fichero config-sample.php y realizamos lo siguiente:

• introducimos nuestra key donde pone 'key' => 'PegamosNuestraKey', 
• y la clave secreta donde pone 'secret' => 'PegamosNuestraClave',
• por último guardamos el fichero en el mismo sitio con el nombre config.php

Una vez echo esto solo nos queda crear el fichero php con la siguiente información.

authenticate($bucket, AmazonS3::ACL_PUBLIC);

//indicamos la ruta donde almacenarlo del bucket y la ruta del fichero a copiar.
   $s3->batch()->create_object($bucket, 'carpeta_bucket/nombreNewFichero.txt', array(
    'fileUpload' => 'FICHEROaCOPIAR.txt',
    'acl' => AmazonS3::ACL_PUBLIC
   ));

//para acabar subimos el fichero
   $file_upload_response = $s3->batch()->send();

//si queremos comprobar que todo está correcto
   if ($file_upload_response->areOK()) echo "Fichero subido correctamente";
   else echo "Error, no se ha subido el fichero";
?>

Suficiente ya esta listo, solo tengo dos pegas hay que controlar que el fichero se ha subido bien, antes de eliminar el original o desecharlo por que puede que si se da el caso de que hay muchas peticiones de subida alguna no termine correctamente. La otra pega que no se si es un problema de mi framework que he usado pero los ficheros que quieres subir tienen que estar en el mismo directorio que el php que los va ha subir, tiene fácil solución con usar copy(); 

Espero que os sea útil. Se que últimamente no hago mas que hablar de PHP me encantaría probar la SDK para JAVA o los otros lenguajes para la que esta disponible, prometo que en mis futuros post intentare dejar de hablar tanto de PHP.

un saludo a todos

Crear tu sistema de caché con PHP

Os presento el último grito de moda. Un sencillo fragmento de código que te permite cachear nuestras páginas web.

¿Que ventajas tiene esto?

En páginas muy visitadas que necesitan mucho tiempo de carga, páginas lentas y para evitar la larga espera. O para evitar tráfico innecesario de una web o la sobrecarga de peticiones en el servidor... Podemos cargar la web ya almacenada en el cliente.

¿Cómo?

Aplicamos el siguiente código

< ? p h p
       // Definimos la ruta y el nombre del archivo en caché
       $cachefile = 'cached-files/'.date('M-d-Y').'.php';
       
       //Definimos el tiempo de vida del fichero en segundos. Por ejemplo 5 horas.
       $cachetime = 18000;

       //Comprobamos si el fichero caché está fresco y aun sirve. Si es así, Lo mostramos y salimos.
       if (file_exists($cachefile) && time() - $cachetime < filemtime($cachefile)) {
              include($cachefile);
              exit;
       }

       // Si no hay ningún archivo o el archivo de demasiado viejo, mostramos la página y la capturamos.
       ob_start();
? >
< h t m l >
       Código html
< / h t m l >
< ? p h p
       // Una vez terminado guardamos el contenido en el fichero
       $fp = fopen($cachefile, 'w');
       fwrite($fp, ob_get_contents());
       fclose($fp);

       // Finalmente enviamos la salida al navegador
       ob_end_flush();
? >

La mierda del WhatsApp

Como podéis ver, me parece una aplicación que está echa de pena. Por suerte en esta vida las cosas mas tontas son las que triunfan. La información que voy a compartir está sacada del estudio realizado Alberto Ortega en su post 'WhatsApp y su seguridad, ¿pwn3d?'. Es decir que nada de lo que ponga aquí es mentira esta comprobado.

Bien y ¿porque ODIO esta aplicación? muy simple, como desarrollador pienso que una aplicación que usa el puerto 443(HTTPS) y el protocolo XMPP para enviar los mensajes por el puerto 5222 a bin-short.whatsapp.net Como narices se les ocurre enviarlo en ¡¡TEXTO PLANO!! cagada de primer curso.

¿Como nos podemos aprovechar de ese error?

Os paso unos links del mismo autor que ha desarrollado la aplicación WhatsAppSniffer en fase Beta. Solo hay que arrancar el programa, seleccionar un adaptador que se pueda poner en modo promiscuo introduciendo su número y pulsar enter. WhatsAppSniffer esperará a que los paquetes comiencen a pasar y los irá mostrando en pantalla con sus respectivos datos.

Descarga WhatsAppSniffer - 4.71 kb

Descarga SourceCode - 81.83 kb

No se si opinareis lo mismo pero suponiendo que esto se solucione en alguna futura actualización ¿que nos queda?

Grupos de usuarios de solo un máximo de diez personas.
Solo un año gratis y después hay que pagar.
...

No soy partidario de apoyar a Apple pero actuaron bien en quitar WhatsApp del AppStore. Y como siempre la cagaron al permitir que vuelva al AppStore.

Predicar esta aplicación WhatsAppSniffer para que todos hagan uso de ella y terminen por mejorar el programa o retirarlo por sus agujeros de seguridad.

Buscar en el Market que hay un sin fin de aplicaciones mejores que WhatsApp.

un saludo

Smushit plugin en PHP

No hace mucho hable de la novedosa API que nos presentaba Smushit. Bien pues hoy voy a publicar como aprovechar eso para aplicarlo de forma automática en nuestro sitio web.

Para empezar creamos un class.smushit.php con el siguiente código

<?PHP
    // smushit-php - a PHP client for Yahoo!'s Smush.it web service
    //
    // Janu 15, 2012
    // Endika Iglesias <endika2@gmail.com>
    // June 24, 2010
    // Tyler Hall <tylerhall@gmail.com>
class SmushIt{
const SMUSH_URL = 'http://www.smushit.com/ysmush.it/ws.php?';
public $filename;
public $url;
public $compressedUrl;
public $size;
public $compressedSize;
public $savings;
public $error;
public function __construct($data = null){
if(!is_null($data)){
if(preg_match('/https?:\/\//', $data) == 1)
$this->smushURL($data);
else
$this->smushFile($data);
}
}
public function smushURL($url){
$this->url = $url;
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, self::SMUSH_URL . 'img=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 5);
$json_str = curl_exec($ch);
curl_close($ch);
return $this->parseResponse($json_str);}
public function smushFile($filename){
$this->filename = $filename;
if(!is_readable($filename)){
$this->error = 'Could not read file';
return false;}
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, self::SMUSH_URL);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 5);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, array('files' => '@' . $filename));
$json_str = curl_exec($ch);
curl_close($ch);
return $this->parseResponse($json_str);}
private function parseResponse($json_str){
            $this->error = null;
            $json = json_decode($json_str);
            if(is_null($json)){
                $this->error = 'Bad response from Smush.it web service';
                return false;
            }
            if(isset($json->error)){
                $this->error = $json->error;
                return false;
            }
            $this->filename       = substr (strrchr ($json->src, '/'), 1 );
            $this->size           = $json->src_size;
            $this->compressedUrl  = $json->dest;
            $this->compressedSize = $json->dest_size;
            $this->savings        = $json->percent;
return true;}
function saveImage($path) {
$url=$this->compressedUrl;
$c = curl_init();
          curl_setopt($c,CURLOPT_URL,$url);
          curl_setopt($c,CURLOPT_HEADER,0);
         curl_setopt($c,CURLOPT_RETURNTRANSFER,true);
         $s = curl_exec($c);
         curl_close($c);
         $f = fopen($path, 'wb');
         $z = fwrite($f,$s);
         if ($z != false) return true;
return false;}
}

Esta clase inicialmente fue creada por Tyler Hall el 24 de Junio del 2010 pero la versión que os paso hoy aquí, tiene ciertas modificaciones que creo que nos vendrían muy bien.

Una vez creada la clase comenzamos a usarla. Os paso un ejemplo de como crear un script que optimice nuestra imagen.

<?php
//incluimos nuestra clase
include('class.smushit.php');
//instanciamos la clase con la URL de la foto original
$img = new SmushIt('http://urlImagenOriginal.com/img/fotos/foto1.jpg');
//optenemos la URL de la imagen optimizada
$urlOptiImg=$img->compressedUrl;
/*por último comprobaremos que nos da un resultado, puede darse el caso de que la imagen no se pueda optimizar más, por tanto la variable $urlOptiImg no devolverá nada*/

 if (isset($urlOptiImg)){
//en caso contrarío almacenaremos la imagen optimizada en la ruta con el nombre que le indiquemos.
     $guardar = $img->saveImage('../../directorio/fotos/imagenOptimizada.jpg');
     var_dump($guardar);
}

?>

Eso es todo :)

JavaScript: Cómo escribir código eficaz

Las aplicaciones web de la actualidad contienen grandes cantidades de código JavasScript. Así pues, el rendimiento no es solamente una cuestión del tiempo que la página tarde en cargar, sino también de cómo responde a medida que se utiliza. La mejor manera de garantizarlo es escribiendo código JavaScript lo más eficiente posible para todos los navegadores.

utilice variables locales
Las variables locales son los identificadores de lectura y escritura más rápida en JavaScript.
un ejemplo:

          function createChildFor(elementId){
                    var element = document.getElementById(elementId),
                    new Element = document.createElement ("div");
                    element.appendChild(newElement);
          }

Esta función contiene dos referencias a la variable global document. Dado que document se utiliza en
más de una ocasión, debería almacenarse en una variable local para que la referencia sea más rápida

          function createChildFor(elementId){
                    var doc = document,
                    element = doc.getElementById(elementId),
                    new Element = doc.createElement ("div");
                    element.appendChild(newElement);
          }

La versión reescrita de la función almacena document en una variable local llamada doc. Dado que doc existe en la primera parte de la cadena, puede resolverse con mayor rapidez que document.

Debemos almacenar los valores a los que se accede con frecuencia en una variable local.

          function process(data){
                    if(data.count > 0){
                              for (var i=0; i< data.count; i++){
                                        processData(data.item[i]);
                              }
                    }
          }

de la siguiente forma:

          function process(data){
                    var count = data.count;
                    if(count > 0){
                              for (var i=0; i< count; i++){
                                        processData(data.item[i]);
                              }
                    }
          }


Los condicionales más rápidos
utilice IF:

-Cuando no existan más de dos valores diferenciados que comprobar.

-Cuando exista un gran número de valores de puedan separarse fácilmente en rangos.

utilice SWICHT:
-Cuando haya más de dos pero menos de diez valores diferenciados que comprobar.
-Cuando no haya rangos para las condiciones porque los valores sean no lineales.

utilice ARRAYS:
-Cuando existen más de 10 valores que comprobar.
-Cuando los resultados de las condiciones sean valores únicos, en lugar de un número de acciones que deban emprenderse.


Bucles rápidos
Existen cuatro tipos de bucle diferentes en JavaScript. FOR, DO-WHILE, WHILE y el cuarto FOR-IN. Este ultimo cuyo propósito es el de iterar por las propiedades enumerables de un objeto de JavaScript.
Naturalmente solo funciona cuando conocemos las propiedades del objeto.

SIN OPTIMIZAR:
          var values=[1,2,3,4,5];
//FOR
          for (var i=0; i<values.length;i++){
                    process(values[i]);
          }
//DO-WHILE
          var j=0;
          do {
                    process(values[j++]);
          }while (j < values.length);
//WHILE
          var k=0;
          while (k < values.length){
                    process (values[k++]);
          }



OPTIMIZADO 1/2;
          var values=[1,2,3,4,5];
          var length = values.length;
//FOR
          for (var i=0; i<length;i++){
                    process(values[i]);
          }
//DO-WHILE
          var j=0;
          do {
                    process(values[j++]);
          }while (j < length);
//WHILE
          var k=0;
          while (k < length){
                    process (values[k++]);
          }

Otra vía sencilla para mejorar el rendimiento de un bucle consiste en reducir el iterador hacia un valor 0 en lugar de incrementarlo hacia la longitud total. Este sencillo cambio puede dar como resultado un ahorro del 50 por 100 sobre el tiempo de ejecución original, dependiendo de la complejidad de cada iteración.

OPTIMIZADO 2/2:
          var values=[1,2,3,4,5];
          var length = values.length;
//FOR
          for (var i=length;i--;){
                    process(values[i]);
          }
//DO-WHILE
          var j=length;
          do {
                    process(values[--j]);
          }while (j);
//WHILE
          var k=length;
          while (k--){
                    process (values[k]);
          }

Un saludo a todos los lectores ;)

SSH conexiones sin password

Si nos encontramos obligados a conectarnos vía SSH continuamente, podemos saltarnos el paso de introducir la contraseña. Mediante una clave algo más privada que nos identifique en el proceso. No se trata de ningún truco simplemente lo que aremos es digitalizar nuestra identidad y que el servidor nos identifique cada vez que necesitemos entrar.

Para empezar abrimos nuestra consola e introducimos:

nombre@ordenador:~$ ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/user/.ssh/id_rsa): <– Enter
Enter passphrase (empty for no passphrase): <– se deja en blanco
Enter same passphrase again: <– se deja en blanco
Your identification has been saved in /home/user/.ssh/id_rsa.
Your public key has been saved in /home/user/.ssh/id_rsa.pub.
The key fingerprint is:
66:66:66:66:66:66:66:66:66:66:66:66:66:66:66:66 nombre@ordenador
The key’s randomart image is:
+--[ RSA 2048]----+
|                 |
|                 |
|                 |
|     . .         |
|    . + 5 . 7 o  |
|     o 5 . = 7   |
|      + 7 . = +  |
|         =7 . o E.|
|          7   o7o|
+-----------------+


Una vez terminado introducimos lo siguiente en nuestra consola

nombre@ordenador:~$ ssh-copy-id -i .ssh/id_rsa.pub usuario@ipServidor
usuario@ipServidor′s password:
Now try logging into the machine, with “ssh ‘usuario@ipServidor′”, and check in:
.ssh/authorized_keys
to make sure we haven’t added extra keys that you weren’t expecting.
nombre@ordenador:~$

Ya está todo listo. La próxima vez que intentemos conectarnos haciendo un

ssh usuario@ipServidor

No nos pedirá la clave de acceso. En caso de no ser así mejor será que revisemos el fichero /etc/ssh/sshd_config y descomentemos lo siguiente:

RSAAuthentication yes
PubkeyAuthentication yes

Reiniciamos y TaCHAN!!!