New question

Question:

Date: 24-02-2017 04:05:14 (In Spanish)

Ejemplo de codificado y decodificado en PHP (encoded / decoded)[Resolved]

Hola a todos, en esta oportunidad les quería compartir estas dos funciones para realizar codificado y decodificado de textos y números. En muchas situaciónes requerimos ofuscar un dato para aumentar un poco la seguridad al no permitir su fácil interpretación y con estas funciones podremos realizarlo.

        <?php
        function codificar($dato) {
            $resultado = $dato;
            $arrayLetras = array('M', 'A', 'R', 'C', 'O', 'S');
            $limite = count($arrayLetras) - 1;
            $num = mt_rand(0, $limite);
            for ($i = 1; $i <= $num; $i++) {
                $resultado = base64_encode($resultado);
            }
            $resultado = $resultado . '+' . $arrayLetras[$num];
            $resultado = base64_encode($resultado);
            return $resultado;
        }

        function decodificar($dato) {
            $resultado = base64_decode($dato);
            list($resultado, $letra) = explode('+', $resultado);
            $arrayLetras = array('M', 'A', 'R', 'C', 'O', 'S');
            for ($i = 0; $i < count($arrayLetras); $i++) {
                if ($arrayLetras[$i] == $letra) {
                    for ($j = 1; $j <= $i; $j++) {
                        $resultado = base64_decode($resultado);
                    }
                    break;
                }
            }
            return $resultado;
        }
        ?>


Nota: el $arrayLetras puede crecer en letras y alterar las posiciones de las mismas, pero no puede repetir letras.

Aquí también les dejo un ejemplo 100% ejecutable para ejemplificar su uso.
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Ejemplo de codificado y decodificado en PHP (encoded / decoded)</title>
    </head>
    <body>
        <?php
        function codificar($dato) {
            $resultado = $dato;
            $arrayLetras = array('M', 'A', 'R', 'C', 'O', 'S');
            $limite = count($arrayLetras) - 1;
            $num = mt_rand(0, $limite);
            for ($i = 1; $i <= $num; $i++) {
                $resultado = base64_encode($resultado);
            }
            $resultado = $resultado . '+' . $arrayLetras[$num];
            $resultado = base64_encode($resultado);
            return $resultado;
        }

        function decodificar($dato) {
            $resultado = base64_decode($dato);
            list($resultado, $letra) = explode('+', $resultado);
            $arrayLetras = array('M', 'A', 'R', 'C', 'O', 'S');
            for ($i = 0; $i < count($arrayLetras); $i++) {
                if ($arrayLetras[$i] == $letra) {
                    for ($j = 1; $j <= $i; $j++) {
                        $resultado = base64_decode($resultado);
                    }
                    break;
                }
            }
            return $resultado;
        }
        ?>

        <h1>Ejemplo de codificado y decodificado en PHP (encoded / decoded)</h1>

        <?php
        $id = 508; //dato a ser ocultado
        echo 'Dato crudo: ' . $id;
        echo '<br/><br/>';
        $resultado = codificar($id);
        echo 'Dato codificado: ' . $resultado;
        echo '<br/><br/>';
        echo 'Dato decodificado: ' . decodificar($resultado);
        ?>
    </body>
</html>

Ver Demo Online

Comentarios extra:
* la función podrá dar codificaciones singulares para cada programador si se modifica el array $arrayLetras.
* la función entrega códigos distintos para distintas llamadas, aún asi garantizando el decodificado para todos los casos.
* esta claro que este es un ejemplo simple, mejor sería armar una clase llamada "Codificacion" y haces que estas dos funciones sean métodos estáticos, y el array $arrayLetras sea una variable estática (no digo constante para evitar la serialización y deserialización del array) declarada fuera de los métodos codificar y decodificar.
* si tiene algún otro ejemplo para compartir de codificado y decodificado se agradece el aporte.

Saludos y buen código!
Tags: Decoded - Encoded - Encryption - Input - Obfuscate - PHP - Security Votes: 5 - Answers: 13 - Views: 41 Share on: Google Facebook Twitter LinkedIn Link
 

Answers:

  • Date: 27-02-2017 19:39:20 Hola Fernando

    Muy bueno tu aporte!

    Me he puesto con el desafío que has planteado de transcribir el codigo a POO.
    Iba bien hasta que hice statico el array de letras.

    codificacion.class.php

    <?php
    class codificacion {
        private static  $arrayLetras = array('M', 'A', 'R', 'C', 'O', 'S');
    
        public static function codificar($dato){
            $resultado = $dato;
          
            $limite = count(self::arrayLetras) - 1;
            $num = mt_rand(0, $limite);
            for ($i = 1; $i <= $num; $i++) {
                $resultado = base64_encode($resultado);
            }
            $resultado = $resultado . '+' . self::arrayLetras[$num];
            $resultado = base64_encode($resultado);
            return $resultado;
        }
    
        public static function decodificar($dato) {
            $resultado = base64_decode($dato);
            list($resultado, $letra) = explode('+', $resultado);
           
            for ($i = 0; $i < count(self::arrayLetras); $i++) {
                if (self::arrayLetras[$i] == $letra) {
                    for ($j = 1; $j <= $i; $j++) {
                        $resultado = base64_decode($resultado);
                    }
                    break;
                }
            }
            return $resultado;
        }
    }
    //-------------- FIN DE LA CLASS ---------------
    
    $miDato ="Si podes leer esto es porque esta sin codificar :p";
    $miDatoCodificado = codificacion::codificar($miDato);
    
    echo '<strong>Dato Crudo:</strong> <br/>';
    echo $miDato;
    echo '<hr/>';
    echo '<strong>Dato Codificado:</strong> <br/>';
    echo $miDatoCodificado;
    echo '<hr/>';
    echo '<strong>Dato Decodificado:</strong> <br/>';
    echo codificacion::decodificar($miDatoCodificado);
    


    Al ejecutarlo da error: ( ! ) Parse error: syntax error, unexpected '[' in codificacion.class.php on line 13
    Y se refiere a la linea del método codificar() :
     $resultado = $resultado . '+' . self::arrayLetras[$num];


    Después de hacer varias pruebas logre hacerlo funcionar con el siguiente codigo.
    Ahora si utilizo un método getArrayLetras() funciona correctamente.

    <?php
    class codificacion {
        private static  $arrayLetras = array('M', 'A', 'R', 'C', 'O', 'S');
    
        private static function getArrayLetras() {
            return self::$arrayLetras;
        }
    
        public static function codificar($dato){
            $resultado = $dato;
         
            $limite = count(self::getArrayLetras()) - 1;
            $num = mt_rand(0, $limite);
            for ($i = 1; $i <= $num; $i++) {
                $resultado = base64_encode($resultado);
            }
            $resultado = $resultado . '+' . self::getArrayLetras()[$num];
            $resultado = base64_encode($resultado);
            return $resultado;
        }
    
        public static function decodificar($dato) {
            $resultado = base64_decode($dato);
            list($resultado, $letra) = explode('+', $resultado);
           
            for ($i = 0; $i < count(self::getArrayLetras()); $i++) {
                if (self::getArrayLetras()[$i] == $letra) {
                    for ($j = 1; $j <= $i; $j++) {
                        $resultado = base64_decode($resultado);
                    }
                    break;
                }
            }
            return $resultado;
        }
    }
    //-------------- FIN DE LA CLASS ---------------
    
    $miDato ="Si podes leer esto es porque esta sin codificar :p";
    $miDatoCodificado = codificacion::codificar($miDato);
    
    echo '<strong>Dato Crudo:</strong> <br/>';
    echo $miDato;
    echo '<hr/>';
    echo '<strong>Dato Codificado:</strong> <br/>';
    echo $miDatoCodificado;
    echo '<hr/>';
    echo '<strong>Dato Decodificado:</strong> <br/>';
    echo codificacion::decodificar($miDatoCodificado);
    


    No logro entender el porque no funciona en el primer codigo.

    Por otro lado creo que el de codificar los datos hay que tener en cuenta que el largo strlen() de la cadena codificada generada es muy superior a la cadena original

    En otro comentario publicare otro codigo que no tiene referencia a los códigos que he expuesto aquí.

    Saludos
      Votes: 2 - Link answer
     
  • Date: 27-02-2017 20:06:07 Hola
    Como lo he mencionado en el comentario anterior.
    Ahora publico el codigo estructurado de la versión Demo propuesto por Fernando

    Lo he alterado un poco, se trata en agregarle una $clave de cifrado.

    De tal manera que sea:
    codificar($Dato,"Clave");
    decodificar($DatoCodificado,"Clave");

    Se trata de agregarle una clave que sirve para encriptar y para desencriptar se debe ingresar la misma clave con la cual fue encriptado.
    Con claves distintas generarian cadenas codificada distintas. Es decir si se utiliza una clave "abc123" es distinto que usar una clave "MiClave782s"

    encriptarDesencriptarDemo.php
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="UTF-8">
        <title>Ejemplo de codificado y decodificado en PHP (encoded / decoded)</title>
    </head>
    <body>
    <?php
    function codificar($dato,$key) {
        $resultado = $dato;
        $arrayLetras = array('M', 'A', 'R', 'C', 'O', 'S');
        $limite = count($arrayLetras) - 1;
        $num = mt_rand(0, $limite);
        for ($i = 1; $i <= $num; $i++) {
            $resultado = base64_encode($resultado);
        }
        $resultado = $resultado . '+' . $arrayLetras[$num];
        $resultado =base64_encode(mcrypt_encrypt(MCRYPT_RIJNDAEL_256, md5($key), $resultado, MCRYPT_MODE_CBC, md5(md5($key))));
        return substr($resultado,0,-1);
    }
    function decodificar($dato,$key) {
        $resultado = rtrim(mcrypt_decrypt(MCRYPT_RIJNDAEL_256, md5($key), base64_decode($dato), MCRYPT_MODE_CBC, md5(md5($key))), "\0");
         list($resultado, $letra) = explode('+', $resultado);
        $arrayLetras = array('M', 'A', 'R', 'C', 'O', 'S');
        for ($i = 0; $i < count($arrayLetras); $i++) {
            if ($arrayLetras[$i] == $letra) {
                for ($j = 1; $j <= $i; $j++) {
                    $resultado = base64_decode($resultado);
                }
                break;
            }
        }
        return $resultado;
    }
    
    ?>
    
    <h1>Ejemplo de codificado y decodificado en PHP (encoded / decoded)</h1>
    <?php
    $id = 508; //dato a ser ocultado
    echo 'Dato crudo: ' . $id;
    echo '<br/><br/>';
    $id_codificado = codificar($id,"Abc157");
    echo 'Dato codificado: ' . $id_codificado;
    echo '<br/><br/>';
    echo 'Dato decodificado: ' . decodificar($id_codificado,"Abc157");
    ?>
    </body>
    </html>
    


    El codigo presenta un problema, el cual es si para desencriptar se utiliza una clave que es distinta con la que se encripto el codigo falla fatalmente!
    Por ejemplo:
    <?php
    $id = 508; //dato a ser ocultado
    echo 'Dato crudo: ' . $id;
    echo '<br/><br/>';
    $id_codificado = codificar($id,"Abc157");
    echo 'Dato codificado: ' . $id_codificado;
    echo '<br/><br/>';
    echo 'Dato decodificado: ' . decodificar($id_codificado,"Abc200");
    ?>
    


    Mas allá que la cadena decodificada son simbolos raros <?>
    Y en ciertos casos produciría:
    ( ! ) Notice: Undefined offset: 1 in encriptarDesencriptarDemo.php on line 23

    Que se refiere a la linea de la función decodificar()
      list($resultado, $letra) = explode('+', $resultado);


    Faltaría resolver ese fallo, que no arroje el error, que devuelve no es posible decodificar.
    Habría que ver como hacer para que verifique si se puede o no decodificar.
    Una de las cosas que se me ocurre ahora, es en el dato encriptado agregarle la clave con la cual ha sido encriptado, dicha clave tambien debe estar encriptada.

    Saludos
      Votes: 2 - Link answer
     
  • Date: 28-02-2017 02:27:25 Hola Walter, observa que en tu primer código, cuando utilizas la variable estática $arrayLetras te esta faltando anteponer el símbolo $, veamoslo en código.

    Forma incorrecta de acceder a la variable estática:
    self::arrayLetras


    Forma correcta:
    self::$arrayLetras


    Tan solo deberás agregar hacer el remplazo de la forma incorrecta por la correcta y listo, funciona perfecto (lo he probado).

    En cuanto al error del offset que comentas en tu segundo comentario, no lo he analizado, pero no creo que lo este arrojando la línea:
    list($resultado, $letra) = explode('+', $resultado);

    Tipicamente este error se da cuando quieres acceder a una posición inexistente de un array...., habrá que profundizar....

    Muchas gracias por tus comentarios y contribución al código original.

    Saludos y buen código!
      Votes: 3 - Link answer
     
  • Date: 28-02-2017 03:36:43 Sobre mi primer comentario, el primer codigo efectivamente, fue subsanado con self::$arrayLetras. Me he equivocado en la forma de acceder a la variable estática. No sé como no me di cuenta ya que en le getArrayLetras() del segundo codigo lo había empleado correctamente.
    Dejo el codigo corregido por si alguien lo quiere probar:
    codificacion.class.php

    <?php
    class codificacion {
        private static  $arrayLetras = array('M', 'A', 'R', 'C', 'O', 'S');
    
        public static function codificar($dato){
            $resultado = $dato;
            $limite = count(self::$arrayLetras) - 1;
            $num = mt_rand(0, $limite);
            for ($i = 1; $i <= $num; $i++) {
                $resultado = base64_encode($resultado);
            }
            $resultado = $resultado . '+' . self::$arrayLetras[$num];
            $resultado = base64_encode($resultado);
            return $resultado;
        }
    
        public static function decodificar($dato) {
            $resultado = base64_decode($dato);
            list($resultado, $letra) = explode('+', $resultado);
            for ($i = 0; $i < count(self::$arrayLetras); $i++) {
                if (self::$arrayLetras[$i] == $letra) {
                    for ($j = 1; $j <= $i; $j++) {
                        $resultado = base64_decode($resultado);
                    }
                    break;
                }
            }
            return $resultado;
        }
    }
    //-------------- FIN DE LA CLASS ---------------
    
    $miDato ="Si podes leer estoes porque esta sin codificar :p";
    $miDatoCodificado = codificacion::codificar($miDato);
    
    echo '<strong>Dato Crudo:</strong> <br/>';
    echo $miDato;
    echo '<hr/>';
    echo '<strong>Dato Codificado:</strong> <br/>';
    echo $miDatoCodificado;
    echo '<hr/>';
    echo '<strong>Dato Decodificado:</strong> <br/>';
    echo codificacion::decodificar($miDatoCodificado);
    


    ¿El codigo en POO esta bien? ¿que se podría mejorar?



    En cuanto al codigo de mi segundo comentario encriptarDesencriptarDemo.php

    No siempre da error.
    Por ejemplo usando:

    <h1>Ejemplo de codificado y decodificado en PHP (encoded / decoded)</h1>
    <?php
    $id = 508; //dato a ser ocultado
    echo 'Dato crudo: ' . $id;
    echo '<br/><br/>';
    $id_codificado = codificar($id,"157");
    echo 'Dato codificado: ' . $id_codificado;
    echo '<br/><br/>';
    echo 'Dato decodificado: ' . decodificar($id_codificado,"158");
    ?>


    Refrescando la pagina varias veces se encuentra distintos resultados algunos con error otras veces sin error.

    Aveces sin error:


    Otras veces con error:


    De todas maneras aunque no de error, no es ni eficiente ni elegante devolver una cadena decodificada que no tiene sentido legible ya que las claves son distintas. Creo que hay que repensar el codigo, que primero se validen las claves antes de codificarlas, en caso que sean idénticas decodificar en caso contrario devolver un NULL

    Una vez solucionado el error se podría agregar la $clave al codigo POO.

    Muchas gracias Fernando por la corrección.

    Que tengas un buen dia

    Saludos
      Votes: 1 - Link answer
     
  • Date: 02-03-2017 14:50:15 Estas funciones son un buen ejercicio para practicar algoritmos, pero una mala práctica de seguridad. Mi recomendación es que no las usen en sus desarrollos.

    Una fuente (de muchas que dicen cosas similares):

    Cryptography - Why shouldn't we roll our own?

    Base64 es un algoritmo diseñado para convertir información binaria en cadenas imprimibles para ser transmitidas por medios antiguos. No fué diseñado para ofuscar la información.

    "Desencriptar" esta información es trivial. Descartamos los últimos dos caracteres (metadatos) y realizamos un base64_decode() una y otra vez hasta que el contenido deja de parecer texto imprimible (para el caso de información binaria) o hasta que aparece el texto con sentido (para el caso de texto plano). Aún sin descartar los metadatos obtenemos el original completo con un poco de basura al final.
      Votes: 1 - Link answer
     
  • Date: 02-03-2017 15:55:41 Sebastián se te agradece por tu punto de vista sobre este tema.
    Sería de gran valor para la comunidad si tienes algun codigo para compartirnos de encriptacion y desencriptacion de datos que sea mas seguro que el propuesto.

    Que tengas un buen dia.
    Saludos
      Votes: 0 - Link answer
     
  • Date: 02-03-2017 17:09:41 Lo recomendado para esto es usar la extensión mcrypt.

    En esta pregunta de StackOverflow la respuesta aceptada ofrece una clase que permite encriptar y desencriptar de manera segura y sencilla usando una clave que se provee cada vez que se desea encriptar/desencriptar algo.

    También son interesantes las recomendaciones que dá el usuario que responde, por ejemplo sobre cómo debería formarse la clave a usar.
      Votes: 0 - Link answer
     
  • Date: 03-03-2017 00:49:15 Buenos días comunidad, solo quería comentar/recordar que si bien aquí ahora se esta hablando de encriptar y desencriptar, la idea de la función original es realizar codificado y decodificado (no encriptación).

    Al margen de esto, gracias Walter y Sebastian por sus aportes y comentarios del caso, saludos a todos!
      Votes: 0 - Link answer
     
  • Date: 03-03-2017 03:41:09 En Facebook me consultaron "¿para qué sirve la función? "

    Transcribo mi respuesta: "Explicado desde el post original, codificar un dato con una seguridad básica, porque nadie conoce tu array de letras y la codificación se da de forma aleatoria en un distinto orden cada vez, me explico? "

    Saludos,

    PD: si alguien quiere hacer un aporte sobre encriptar y desencriptar en un nuevo post, buenas prácticas, etc bienvenido sea!
      Votes: 0 - Link answer
     
  • Date: 03-03-2017 03:54:01 Lo suponía, pero me parece interesante mencionar que hay cuestiones que se presentan de manera confusa en el post, e invitan a los más principiantes a confundir codificación con encriptación.

    Por ejemplo:

    El post presenta un "método privado" de codificación, es decir, una función secreta (debido al "pass" que contiene).

    No es recomendable usar métodos privados de codificación con la esperanza de que terceros no puedan acceder a la información (para eso se usa la encriptación). De otro modo se llega a una "falsa sensación de seguridad".

    El término "codificación" se refiere a expresar la información de un modo alternativo, atañendose a un código de conocimiento público.

    El objetivo de la codificación es que la información sea representada correctamente, evitando malas interpretaciones o pérdida de datos.

    La información codificada no tiene representaciones varias, sino una única. En otras palabras, cada vez que se codifica un dato debe obtenerse el mismo resultado.
    La función propuesta devuelve distintas codificaciones para la misma cadena. Esto es una característica de la encriptación, no de la codificación.

    Algunos ejemplos de codificación son:
    ABCdic // obsoleto
    ASCII // Con bytes de 7 bits. Set de 127 caracteres. Ya no se usa. El objetivo era representar el alfabeto en forma de números (ya que las computadoras internamente sólo manejan números).
    ASCII Extendido // Con bytes de 8 bits. Set de 256 caracteres. Reemplazó al ASCII y ahora todos llamamos ASCII a este. El objetivo era representar más caracteres que los 127 que ASCII permitía.
    ISO-8859-1 (aka 'Latin1') // Derivado de una de las "code pages" de Microsoft. Tiene 2 versiones. La más pura desaprovecha algunas posiciones y la otra versión (Windows-1252) las usa para representar algunos caracteres más.
    etc.

    Hay muchas otras codificaciones, de las cuales la reina hoy en día es UTF-8 porque permite representar todos los caracteres del conjunto Unicode (es decir, de muchísimos de los idiomas usados en el mundo) y es "bastante" compatible con Latin1 cuando los que se usan son los caracteres occidentales.

    La codificación base64 es un método CASI universal para lograr que cualquier dato binario pueda "pasar por cualquier tubería", pero hay excepciones, es decir, casos en los que puede fallar. Se me ocurren dos casos, uno de ellos las funciones codificar/decodificar de este post. Veamos por qué:

    En el caso de Base64 la codificación se logra "cortando" la cadena de caracteres (de 8 bits) en pedazos de 6 bits. Cada 3 octetos (bytes de 8 bits) se obtienen 4 sextetos (bytes de 6 bits) y se los representa en una tabla reducida de 64 caracteres (que luego se representan de nuevo en 8 bits).
    Los 64 caracteres que componen esa tabla son: A-Z,a-z,0-9,+/=. El objetivo es poder transmitir información binaria a través de medios que fueron pensados para transmitir texto, como por ejemplo, el email.

    Nótese que la implementación más común de Base64 incluye el +, / y el =, por lo tanto:
    - No es 100% seguro para incluir en urls, y
    - La función del decodificar() va a fallar en algunos casos debido a que la linea
                list($resultado, $letra) = explode('+', $resultado);
    

    está asumiendo que base64 no puede emitir el caracter '+' dentro del resultado, cuando en realidad puede.

    Conclusión: No tiene sentido realizar una codificación sin un verdadero objetivo. Si el objetivo es encriptar, es mejor usar funciones de encriptación. Si el objetivo es que la información llegue correctamente hay que analizar las características del medio de transmisión. En el caso de las funciones del post original no ofrecen ninguna ventaja por sobre las funciones base64_encode() / base64_decode().
      Votes: 2 - Link answer
     
  • Date: 03-03-2017 04:41:38 Sebastian, muchas gracias la información y tu opinión, y bienvenido a la comunidad, que creo que no te hemos saludado ;)

    Saludos a todos!
      Votes: 0 - Link answer
     
  • Date: 03-03-2017 04:48:42 Gracias Fernando.

    Me uní a la comunidad debido a tu sugerencia de que hablemos esto aquí y no en facebook.
      Votes: 2 - Link answer
     
  • Date: 03-03-2017 20:47:25 Sebastian muchas gracias por toda la info que nos has dado

    Dejare el codigo obtenido de Two-way encryption: I need to store passwords that can be retrieved Sugerido por Sebastian en uno de sus comentarios sobre un enlace de StackOverflow.
    Me ha parecido muy interesante.

    Encryption.class.php

    <?php
    /**
     * A class to handle secure encryption and decryption of arbitrary data
     *
     * Note that this is not just straight encryption.  It also has a few other
     *  features in it to make the encrypted data far more secure.  Note that any
     *  other implementations used to decrypt data will have to do the same exact
     *  operations.  
     *
     * Security Benefits:
     *
     * - Uses Key stretching
     * - Hides the Initialization Vector
     * - Does HMAC verification of source data
     *
     */
    class Encryption {
    
        /**
         * @var string $cipher The mcrypt cipher to use for this instance
         */
        protected $cipher = '';
    
        /**
         * @var int $mode The mcrypt cipher mode to use
         */
        protected $mode = '';
    
        /**
         * @var int $rounds The number of rounds to feed into PBKDF2 for key generation
         */
        protected $rounds = 100;
    
        /**
         * Constructor!
         *
         * @param string $cipher The MCRYPT_* cypher to use for this instance
         * @param int    $mode   The MCRYPT_MODE_* mode to use for this instance
         * @param int    $rounds The number of PBKDF2 rounds to do on the key
         */
        public function __construct($cipher, $mode, $rounds = 100) {
            $this->cipher = $cipher;
            $this->mode = $mode;
            $this->rounds = (int) $rounds;
        }
    
        /**
         * Decrypt the data with the provided key
         *
         * @param string $data The encrypted datat to decrypt
         * @param string $key  The key to use for decryption
         * 
         * @returns string|false The returned string if decryption is successful
         *                           false if it is not
         */
        public function decrypt($data, $key) {
            $salt = substr($data, 0, 128);
            $enc = substr($data, 128, -64);
            $mac = substr($data, -64);
    
            list ($cipherKey, $macKey, $iv) = $this->getKeys($salt, $key);
    
            if (!hash_equals(hash_hmac('sha512', $enc, $macKey, true), $mac)) {
                 return false;
            }
    
            $dec = mcrypt_decrypt($this->cipher, $cipherKey, $enc, $this->mode, $iv);
    
            $data = $this->unpad($dec);
    
            return $data;
        }
    
        /**
         * Encrypt the supplied data using the supplied key
         * 
         * @param string $data The data to encrypt
         * @param string $key  The key to encrypt with
         *
         * @returns string The encrypted data
         */
        public function encrypt($data, $key) {
            $salt = mcrypt_create_iv(128, MCRYPT_DEV_URANDOM);
            list ($cipherKey, $macKey, $iv) = $this->getKeys($salt, $key);
    
            $data = $this->pad($data);
    
            $enc = mcrypt_encrypt($this->cipher, $cipherKey, $data, $this->mode, $iv);
    
            $mac = hash_hmac('sha512', $enc, $macKey, true);
            return $salt . $enc . $mac;
        }
    
        /**
         * Generates a set of keys given a random salt and a master key
         *
         * @param string $salt A random string to change the keys each encryption
         * @param string $key  The supplied key to encrypt with
         *
         * @returns array An array of keys (a cipher key, a mac key, and a IV)
         */
        protected function getKeys($salt, $key) {
            $ivSize = mcrypt_get_iv_size($this->cipher, $this->mode);
            $keySize = mcrypt_get_key_size($this->cipher, $this->mode);
            $length = 2 * $keySize + $ivSize;
    
            $key = $this->pbkdf2('sha512', $key, $salt, $this->rounds, $length);
    
            $cipherKey = substr($key, 0, $keySize);
            $macKey = substr($key, $keySize, $keySize);
            $iv = substr($key, 2 * $keySize);
            return array($cipherKey, $macKey, $iv);
        }
    
        /**
         * Stretch the key using the PBKDF2 algorithm
         *
         * @see http://en.wikipedia.org/wiki/PBKDF2
         *
         * @param string $algo   The algorithm to use
         * @param string $key    The key to stretch
         * @param string $salt   A random salt
         * @param int    $rounds The number of rounds to derive
         * @param int    $length The length of the output key
         *
         * @returns string The derived key.
         */
        protected function pbkdf2($algo, $key, $salt, $rounds, $length) {
            $size   = strlen(hash($algo, '', true));
            $len    = ceil($length / $size);
            $result = '';
            for ($i = 1; $i <= $len; $i++) {
                $tmp = hash_hmac($algo, $salt . pack('N', $i), $key, true);
                $res = $tmp;
                for ($j = 1; $j < $rounds; $j++) {
                     $tmp  = hash_hmac($algo, $tmp, $key, true);
                     $res ^= $tmp;
                }
                $result .= $res;
            }
            return substr($result, 0, $length);
        }
    
        protected function pad($data) {
            $length = mcrypt_get_block_size($this->cipher, $this->mode);
            $padAmount = $length - strlen($data) % $length;
            if ($padAmount == 0) {
                $padAmount = $length;
            }
            return $data . str_repeat(chr($padAmount), $padAmount);
        }
    
        protected function unpad($data) {
            $length = mcrypt_get_block_size($this->cipher, $this->mode);
            $last = ord($data[strlen($data) - 1]);
            if ($last > $length) return false;
            if (substr($data, -1 * $last) !== str_repeat(chr($last), $last)) {
                return false;
            }
            return substr($data, 0, -1 * $last);
        }
    }
    //Note that I'm using a function added in PHP 5.6: hash_equals. If you're on lower than 5.6, you can use this substitute function which implements a timing-safe comparison function using double HMAC verification:
    
    function hash_equals($a, $b) {
        $key = mcrypt_create_iv(128, MCRYPT_DEV_URANDOM);
        return hash_hmac('sha512', $a, $key) === hash_hmac('sha512', $b, $key);
    }
    


    Encriptar.php su uso:
    <?php
    require_once 'Encryption.class.php';
    //encriptar
    $e = new Encryption(MCRYPT_BLOWFISH, MCRYPT_MODE_CBC);
    $data = 'Esto es un dato para encriptar';
    $key = 'MiClave1525';
    
    
    $hashed_password = crypt($key); // dejar que el salt se genera automáticamente
    
    echo 'Dato original: <br/> <br/>';
    echo $data;
    echo '<hr/>';
    
    $encryptedData = $e->encrypt($data, $key);
    echo 'Dato encriptado: <br/> <br/>';
    echo $encryptedData;
    echo '<hr/>';
    
    //desencriptar
    $e2 = new Encryption(MCRYPT_BLOWFISH, MCRYPT_MODE_CBC);
    $data = $e2->decrypt($encryptedData, $key);
    
    echo 'Dato desncriptado: <br/> <br/>';
    echo $data;
    echo '<hr/>';
    


    Resultando:


    Si alguien desea puede seguir contribuyendo en este post con otras alternativas.

    Saludos
      Votes: 1 - Link answer
     
To actively participate in the community first must authenticate, enter the system.Sign In