fbpx

Como encriptar los IDs en Laravel

Encriptación de IDs en Laravel

Laravel es uno de los frameworks de PHP mas utilizados en la actualidad, y aunque recibe actualizaciones constantemente añadiendo nuevas funcionalidades, hay algunos procesos que aún no incorpora. Uno de ellos es la encriptación automática de ids.

En primer lugar, tenemos que conocer una serie de factores que serán necesario tener claros a la hora de encriptar.

  • APP_KEY: laravel encripta los datos usando una key que se encuentra en el archivo .env. Esta clave se genera automáticamente con la instalación y se puede cambiar usando el comando php artisan key:generate, lo cual es recomendable hacer cada cierto tiempo para hacer más segura nuestra página.
  • Helpers: funciones de ayuda o que realizan funciones específicas.
  • Traits: emula la herencia múltiple en php y se usa cuando se va a usar código en varios lugares de nuestra aplicación.
  • Accesors: da un valor a un atributo del modelo.
  • Appends: añade un nuevo atributo al modelo.
  • Middlewares: filtra las peticiones php

Creación del helper

Desde aquí generamos un código alfanumérico a través de la encriptación de un id numérico. Crearemos el helper en app/Helpers y lo llamaremos Encryptor.php


class Encryptor
{
   public static function method()
   {
       return Config::get('app.cipher');
   }

   public static function hash_key(){
       return hash('sha256', Str::substr(Config::get('app.key'), 7));
   }

   public static function iv()
   {
       $secret_iv = Str::substr(Config::get('app.key'), 7);
       $iv = substr(hash('sha256', $secret_iv), 0, 16);

       return $iv;
   }



   public static function encrypt($value)
   {
       $output = openssl_encrypt($value, self::method(), self::hash_key(), 0, self::iv());
       $output = base64_encode($output);

       return $output;
   }

   public static function decrypt($value)
   {
       $output = openssl_decrypt(base64_decode($value), self::method(), self::hash_key(), 0, self::iv());
       return (int)$output;
   }
}

Las tres primeras funciones se usarán para generar los datos que luego usaremos encriptar el código en las funciones de encrypt y decrypt.

Función method: Recogemos el método de encriptación declarado en el fichero app.php. Por defecto  laravel usa AES-256-CBC

Función hash_key: encriptamos el código del APP_KEY que encontramos en el fichero .env con el método sha256 (se puede usar otro método)

Función iv: generamos el valor que garantiza que el valor encriptado sea único. Aquí podemos usar cualquier valor. Nosotros encriptaremos una parte del APP_KEY y la usaremos como iv.

Funciones encrypt y decrypt: Estas funciones recibirán un valor (el id en este caso) el cual encriptaremos o desencriptaremos usando las funciones php openssl_encrypt/openssl_decrypt y base64_encode/base64_decode respectivamente, usando los valores generados por las funciones anteriores.

Creación del helper

En el trait crearemos el accesor para luego poder hacer un use en cada modelo que necesitemos encriptar un id. Crearemos el helper en app/Trait y lo llamaremos EncryptationId.php

El accesor hará uso de la función encrypt que hemos creado en el helper Encryptor.php


use App\Helpers\Encryptor;

trait EncryptationId
{
 /**
  * Funcion que recupera el id del modelo y lo encripta
  * @param $value valor del id autonumerico
  * @return string con el valor del id encriptado
  */
 public function getEncidAttribute()
 {

   return Encryptor::encrypt($this->attributes['id']);
 }


}

Modelo

Hacemos un use del trait que contiene el accesor y añadimos la variable encid que contendrá el id encriptado al modelo.

use App\Traits\EncryptationId;


class User extends Model
{
   use EncryptationId;
   protected $appends = ['encid'];
}

Controlador

Con hacer uso del modelo para generar un objeto, ya podremos obtener el encid


public function index()
{
    $users = $User::all();

    return view(‘users’, compact(users));
}

public function edit($id)
{
    $user = $User::find($id);
    //dd($user->encid)

    return view(‘user’, compact(user));
}





public function store($id, Request $request)
{
    $user = $User::find($id);
    
    $user->update([
        //$request...
    ])
    return view(‘users’);
}

Vista

En la vista sólo tendremos que hacer uso del objeto que hemos enviado y extraer el encid para usarlo donde queramos.


users.blade.php

@foreach($users as $user)

    Editar usuario: <a href=”/users/{{$user->encid}}”>{{$user->name}} </a>

@endforeach


user.blade.php


<form method="post" action="/user/{{$user->encid}}">
    …..
</form>


Middleware

Añadiremos el código que se encargará de comprobar que lo que está pasando por el middleware contiene la palabra id o _id ya sea enviado por get o por post, y si encuentra ese valor lo desencripta antes de llegar al controlador.


class EncryptMiddleware
{
 /**
  * Handle an incoming request.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Closure  $next
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
   /**
    * Se recoge la request enviada por get y se recorren y desencriptan los parámetros que tiene. El controlador recoge los datos desencriptados para procesarlos correctamente
    */
   foreach($request->route()->parameters as $key => $value){
     if($key == 'id' || Str::endsWith($key, ['_id'])) {
       $request->route()->setParameter($key, Encryptor::decrypt($value));
     }
   }

   /**
* Se comprueba si el método es post. Si lo es se recorren sus parámetros y se comprueba que en los datos enviados por el formulario hay algún parámetro que se llame exactamente ID o que contenga _ID. Si la comprobación es exitosa se desencripta para que el controlador pueda procesar los datos correctamente
    */
   if($request->isMethod('post')){
     $array = [];
     foreach ($request->request as $key => $value) {
       if($key == 'id' || Str::endsWith($key, ['_id'])){
         // Si lo que recibe es un array, se desencripta cada valor del array, se guarda en un array temporal y se aplica sobre el array original de la request
         if (is_array($value)){
           foreach ($value as $key_array=>$array_item) {
             if($array_item != NULL){
               array_push($array, Encryptor::decrypt($array_item));
             }
           }
           $request->request->set($key, $array);
         } else {
           if($value != NULL){
             $request->request->set($key, Encryptor::decrypt($value));
           }
         }

       }
     }
   }

   return $next($request);
 }
}

Web

Todas las rutas que englobe el EncryptMiddleware se verán afectadas por la desencriptación de ids


Route::middleware(‘encrypt)->group(function () {
    Route::get(‘/users’, ‘UserController@index);
    Route::get(‘/users/{id}’, ‘UserController@edit’);
    Route::post(‘/users/{id}’, ‘UserController@store);
}

Y con todo esto ya tendremos la encriptación de ids implementada en nuestra web.

Menú

Utilizamos cookies propias y de terceros para recopilar información que ayuda a optimizar su visita. Las cookies no se utilizan para recoger información de carácter personal. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies

ACEPTAR
Aviso de cookies