Laravel: Securizando APIs

Desde hace un tiempo he estado trabajando en una apliación web para facilitar la gestión de servidores, para ello he desarrollado varias APIs para poder ejecutar comandos en servidores. Uno de los puntos más criticos de esto es permitir o denegar el acceso a los usuarios para llamar a estas APIs.

En mi caso, estoy usando el sitema de auth de Laravel con la librería Adldap2-Laravel para manejar accesos desde Active Directory. Por determinadas razones nececsito que mis usuarios puedan hacer llamadas via un token de autorización. Este paso es muy sencillo, Laravel con su módulo de Auth nos proporciona este mecanismo si utilizas el driver de base de datos y no el driver LDAP ya que no comprueba si el token que usas pertenece a un usuario dado de baja en ldap o le ha expirado la cuenta. Para corregir este comportamiento debemos hacer lo siguente.

Debemos añadir al archivo de configuración de autenticación (config/auth.php), los nuevos guards y providers “custom” que vamos a generar:

    'guards' => [
        ...
        'api' => [
            'driver' => 'token',
            'provider' => 'api-users',
        ],
    ],
    'providers' => [
        .....
         'api-users' => [
             'driver' => 'custom',
             'model'  => App\User::class,
         ],
    ],

El siguiente paso es indicar en el archivo de rutas de APIs que el guard de authenticación que queremos usar es el de ‘api’ (routes/api.php):

Route::middleware('auth:api')->get('/user', function (Request $request) {
    return $request->user();
});

Para que el provider de usuarios sepa que clase debe usar debemos crear nuestro proveedor e indicarselo a laravel:

app/Providers/CustomUserProvider.php

<?php
namespace App\Providers;

use Adldap\Laravel\Facades\Adldap;
use Illuminate\Contracts\Auth\Authenticatable as UserContract;
use Illuminate\Auth\EloquentUserProvider;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Str;

class CustomUserProvider extends EloquentUserProvider

{
	/**
	 * Retrieve a user by the given credentials. *
	 * @param array $credentials *
	 @return \Illuminate\Contracts\Auth\Authenticatable|null
	 */
	public

	function retrieveByCredentials(array $credentials)
	{
		if (empty($credentials)) {
			return;
		}
                // First we will add each credential element to the query as a where clause.
                // Then we can execute the query and, if we found a user, return it in a 
                // Eloquent User "model" that will be utilized by the Guard instances.
                $query = $this->createModel()->newQuery();
		foreach($credentials as $key => $value) {
			if (!Str::contains($key, 'password')) {
				$query->where($key, $value);
			}
		}

		$user = $query->first();
		if (!$user) {
			return;
		}

		// Securing API CALLS with LDAP checks

		$adldap_user = Adldap::search()->users()->find($user->id);
		if ($adldap_user->isExpired() || $adldap_user->isDisabled()) {
			return;
		};
		return $user;
	}
}

Dentro de la clase anterior hemos sobreescrito la función retrieveByCredentials para que además de comprobar el token del usuario compruebe si éste ha expirado en LDAP o está deshabilitado.

El siguiente archivo que debemos modificar es el AuthServiceProvider para que nos cargue nuestro proveedor ‘custom’:

app/Providers/AuthUserProvider.php


<?php 

namespace App\Providers;

use Illuminate\Support\Facades\Gate;
use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;

class AuthServiceProvider extends ServiceProvider

	{
	/** * The policy mappings for the application. * * @var array */
	protected $policies = ['App\Model' => 'App\Policies\ModelPolicy', ];
	/**
	 * Register any authentication / authorization services.
	 *
	 * @return void
	 */
	public

	function boot()
		{
		$this->app['auth']->provider('custom',
		function ($app, array $config)
			{
			$model = $app['config']['auth.providers.users.model'];
			return new CustomUserProvider($app['hash'], $model);
			});
		$this->registerPolicies();

		//

		}
	}

Adicionalmente, como la librería de LDAP no está preparada para el uso de tokens, es necesarío parchear para que la primera vez que hace login el usuario le genere un token:

app/Controllers/Auth/LoginController.php

A este controller le debemos sobreescribir la funcion authenticated del siguiente modo:

    protected function authenticated(Request $request, $user)
    {
        if (empty($user->api_token)) {
            $user->api_token = str_random(60);
            $user->save();
        }
    }

De esta forma, la primera vez que se genera un usuario al no tener un token asignado lo generaremos al vuelo.

Para comrpobar si ha ido se está generando el token podemos revisar la base de datos o imprimirlo en el blade del siguiente modo:

  @if(Auth::check())
        <a href="api/user?api_token={{ Auth::user()->api_token }}">Mi usuario JSON</a>
  @endif

Liberado código SWifi Keygen y Airwin 2

Buenos días,

Tras varios meses sin tiempo para actualizar estos softwares he decidido liberar el código para que la comunicad me ayude a mantenerlo.

El proyecto Swifi se encuentra en medio de una refactorización para poder segmentar los generadores de claves.

https://github.com/berni69/SwifiKeygen

El proyecto de Airwin2 tiene algunos cambios gráficos a medio crear, además de haber añadido algunas opciones que no están publicadas actualmente:

https://github.com/berni69/Airwin2

Saludos,

WebSockets – Dashboard colaborativa

Desde hace unos años, se han puesto de moda la tecnología WebSocket.
Esta tecnología es una extensión del protocolo HTTP para simular un socket. Comunmente un sócket de comunicación es un recurso que se utiliza para poder transferir datos entre aplicaciones/máquinas. Existen varios tipos de sockets: UDP,TCP,RAW,UNIX,… cada uno se utiliza para una determinada función.

Por ejemplo, UDP se va muy bien para transferir grandes cantidades de datos ya que reduce el overhead introducido por cabeceras, Los sockets TCP se usan para las aplicaciones que no toleran errores en transmisión ya que posee un buen sistema de control de flujo y errores. En ambos casos existe un evidente problema: se necesitan abrir puertos específicos en los firewalls para poder establecer la conexión. Por defecto, el puerto 80/443 que utiliza el servidor de WebSocket suele estar abierto ya que son los puertos estándares de cualquier servidor HTTP.

Diagrama de Websockets

Este diagrama muestra la negociación y uso del protocolo de websockets

Este tipo de socket se utiliza en los navegadores para poder mantener un flujo de comunicación constante por lo facilita la operativa a los programadores web para tener el contenido actualizado en sus páginas. El clásico ejemplo de uso de websockets es construir una sala de chat en la que en tiempo real se reciben y envían mensajes (Hangouts utiliza websockets), las notificaciones de Facebook utilizan websockets.

Ejemplo básico de uso de Webcoskets con node JS
Servidor:

var server = require('websocket').server, http = require('http');

var socket = new server({
    httpServer: http.createServer().listen(1337)
});

socket.on('request', function(request) {
    var connection = request.accept(null, request.origin);

    connection.on('message', function(message) {
        console.log(message.utf8Data);
        connection.sendUTF('pong');
        setTimeout(function() {
            connection.sendUTF('[!] Server Event happended');
        }, 1000);
    });

    connection.on('close', function(connection) {
        console.log('connection closed');
    });
}); 

Cliente:

<div id="content"></div>

<script type="text/javascript">
    var content = document.getElementById('content');
    var socket = new WebSocket('ws://localhost:1337');
    socket.onopen = function () {
        setTimeout(function() {
                socket.send('ping');
        }, 1000);
    };
    socket.onmessage = function (message) {
        content.innerHTML += message.data +'<br />';
    };

    socket.onerror = function (error) {
        console.log('WebSocket error: ' + error);
    };
</script>

Fuente: http://hawkee.com/snippet/16051/

Para los que trabajamos en grupo en determinadas ocasiones necesitamos sincronizar determinadas tareas, como el reinicio y arranque de determinados servidores. Por ello poder avisar a los compañeros de que has iniciado la tarea y que lo reciban en tiempo real es importante, en esto nos ayudan los websockets. Si alguien quiere ver la potencia que ofrece este tipo de tecnología recomiendo ver una dashboard de ejemplo colaborativa que he diseñado para este fin. El código es libre y susceptible de aceptar mejoras:

https://github.com/berni69/ws-dashboard

Tratando logs con awk

Hoy en el trabajo me he encontrado con una problemática bastante común cuando tratamos de filtrar logs: mucha información que no nos interesa.

Para solventar este problema, habitualmente, la primera aproximación sería con grep y cut pero habitualmente se quedan cortos ya que es complicado usarlos para filtrar por fecha/hora.

En este ejemplo se usará un archivo de log del estilo

2016/06/29 17:10:35.838:Fatal error core dumped
2016/06/29 17:15:35.838:Fatal error core dumped
2016/06/29 17:20:35.838:Fatal error core dumped
2016/06/29 17:30:35.838:Fatal error core dumped

Para poder filtrar por hora, podemos usar awk, en el siguiente script contaremos el numero de líneas que hay en un intervalo de tiempo determinado (por defecto, los últimos 15 min).

#!/bin/awk -f

BEGIN {

if(minutos==""){minutos=15 }
    umbral = minutos *60  # Miramos los ultimos N segundos del log 
    now = strftime("%H:%M:%S",systime())
    counter=0;
    debug=0
 }
{ 
    split($2,chunks,".");
    hour=chunks[1];
    m=split(hour,w,":")
    n=split(now,t,":")
    FIRSTTIME= (t[1]*3600) + (t[2]*60) + t[3]
    SECONDTIME= (w[1]*3600) + (w[2]*60) + w[3]
    DIFFTIME=(FIRSTTIME - SECONDTIME)
    if (debug == 1){
        printf("%s|%s|%s\n",FIRSTTIME,SECONDTIME,DIFFTIME)
    }
    if(DIFFTIME < umbral ){
        counter++;
    }
}
END { print  counter }

Para ejecutarlo bastaría con ejecutar:

cat mylog.log | awk -f script.awk -v minutos=8

Y el resultado sería

echo '2016/06/29 17:10:35.838:Fatal error core dumped
2016/06/29 17:15:35.838:Fatal error core dumped
2016/06/29 17:20:35.838:Fatal error core dumped
2016/06/29 17:30:35.838:Fatal error core dumped' | awk -f /var/www/scripts/countSuperacionesAma.awk -v minutos=8
1

Pues de este modo tan sencillo podemos tratar logs en función del tiempo.

Streaming procesos en php

En determinadas ocasiones he necesitado generar una web que me ejecute un proceso del sistema operativo que tarda bastante. Es bastante frustrante tener que esperar a que el proceso termine para saber como se está ejecutando, si eres tan impaciente como yo, este es tu código.

<?php
header('Content-Type: text/html; charset=utf-8');
header('Cache-Control: no-cache');
ini_set('max_execution_time', 600);
echo '<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />';
echo "<style type='text/css'>
 body{
 background:#000;
 color: #7FFF00;
 font-family:'Lucida Console',sans-serif !important;
 font-size: 12px;
 }
 </style></head><body>";
?>

El primer paso es configurar el timeout de la aplicación para que PHP no cierre el proceso, acto seguido indicamos al navegador que esta web no se debe cachear. Y para darle un poco de formato generamos el estilo de una consola de MSDOS.

El siguiente paso es preparar la salida de PHP para que vaya enviando por el socket HTTP la información que se genera sin esperar a que finalice la ejecución del script.

<?php

function disable_ob() {
    // Turn off output buffering
    ini_set('output_buffering', 'off');
    // Turn off PHP output compression
    ini_set('zlib.output_compression', false);
    // Implicitly flush the buffer(s)
    ini_set('implicit_flush', true);
    ob_implicit_flush(true);
	ob_end_flush();
    // Clear, and turn off output buffering
    while (ob_get_level() > 0) {
        // Get the curent level
        $level = ob_get_level();
        // End the buffering
        ob_end_clean();
        // If the current level has not changed, abort
        if (ob_get_level() == $level) break;
    }
    // Disable apache output buffering/compression
    if (function_exists('apache_setenv')) {
        apache_setenv('no-gzip', '1');
        apache_setenv('dont-vary', '1');
    }
}

// tell php to automatically flush after every output
// including lines of output produced by shell commands
disable_ob();
flush();
?>

Para finalizar sólo nos queda ejecutar el comando e ir imprimiendo su salida. En este caso voy a ejecutar un script en python “unbufered” para que el intérprete no se guarde la salida estándar hasta que termina de ejecutar el comando:


$cmd = 'python -u automate.py 2>&1'; 
$pid = popen( $cmd,"r");
 
echo "<body><pre>";
while( !feof( $pid ) )
{
 echo fread($pid, 256);
 flush();
 //ob_flush();
 echo "<script>window.scrollTo(0,99999);</script>";
 usleep(100000);
}
pclose($pid);

Con las líneas:

 echo "<script>window.scrollTo(0,99999);</script>";
 usleep(100000);

Conseguimos el navegador haga scroll hasta la última linea impresa y que PHP no consuma más recursos de los necesarios ya que no es necesario que esté todo el tiempo comprobando la salida estándar del proceso ejecutado.

Resultado:

Console

Matar un proceso en Windows

Esta tarde un compañero me ha pedido si conocía si se podía matar un proceso dependiendo de la RAM que consumía y relanzarlo sin utilizar nada más que no fuera BATCH en Windows XP,… si señores BATCH 🙂

Pues evidentemente le dije que no lo sabía pero que lo investigaría. Y este ha sido el resultado, este script mata cualquier cmd.exe que consuma más de 4000Kb de RAM.

@echo off
set process=cmd.exe
set memLimit=4000
tasklist /FI "IMAGENAME eq %process%" | findstr  %process% > tmp
for /f "tokens=5" %%x in (tmp) do set memUsage=%%x
echo "Memusage %memUsage%"
if %memUsage% gtr %memLimit% goto killme
goto end 
:killme
taskkill /f /FI "IMAGENAME eq %process%"
%process%
:end
echo "fin"
del tmp

Sé que se puede mejorar el uso de archivos temporales pero.. como le dije a mi compñero BATCH no es mi fuerte