Hola Visitante

Mensajes recientes

Páginas: [1] 2 3 ... 10
1
Noticias del Blog / Shaping con Iptables: Limitando CPS
« Último mensaje por Javier Martinez Arandigoyen en Febrero 25, 2019, 11:17:49 am »

Estimados, voy a explicar aunque será largo como es mi instalación. Tengo un servidor proxmox versin 5-2 y debajo de él virtualizadas dos máquinas llamémosle srv (10.10.20.3) y srvbbdd (10.10.20.12), La primera tiene intalado jboss y apache fundamentalmente y srvbbdd tiene la base de datos.


Proxmox tiene la ip 10.10.20.2 y su gateway es 10.10.20.1 y un certificado thawte instalado para jboss y apache.

Con la configuración que tengo en iptables todo funciona perfecto desde fuera, el problema es que tengo una máquina al mismo nivel de proxmox con la ip 10.10.20.200 que internamente no es capaz de navegar por la ip https:10.10.20.2/….


Os paso el fichero de las IPTables que tengo configurados


# Generated by iptables-save v1.6.0 on Thu Jan 31 21:03:29 2019

*nat

:PREROUTING ACCEPT [3523:196189]

:INPUT ACCEPT [3296:181100]

:OUTPUT ACCEPT [891:56124]

:POSTROUTING ACCEPT [1196:72720]

-A PREROUTING -i vmbr0 -p tcp -m tcp –dport 2227 -j DNAT –to-destination 10.10.20.11:22

-A PREROUTING -i vmbr0 -p tcp -m tcp –dport 8080 -j DNAT –to-destination 10.10.20.11:80

-A PREROUTING -i vmbr0 -p tcp -m tcp –dport 2222 -j DNAT –to-destination 10.10.20.12:22

-A PREROUTING -i vmbr0 -p tcp -m tcp –dport 2224 -j DNAT –to-destination 10.10.20.5:11$

-A PREROUTING -i vmbr0 -p udp -m udp –dport 2224 -j DNAT –to-destination 10.10.20.5:11$

-A PREROUTING -i vmbr0 -p tcp -m tcp –dport 2229 -j DNAT –to-destination 10.10.20.5:22

-A PREROUTING -i vmbr0 -p tcp -m tcp –dport 2223 -j DNAT –to-destination 10.10.20.3:22$

-A PREROUTING -i vmbr0 -p tcp -m tcp –dport 443 -j DNAT –to-destination 10.10.20.3

#-A POSTROUTING -s 10.10.20.0/24 -o vmbr0 -j SNAT –to-source 10.10.20.2

-A POSTROUTING -s 10.10.20.0/24 -o vmbr0 -j MASQUERADE

COMMIT

# Completed on Thu Jan 31 21:03:29 2019

# Generated by iptables-save v1.6.0 on Thu Jan 31 21:03:29 2019

*filter

:INPUT ACCEPT [32224:1934324]

:FORWARD ACCEPT [507898:206067765]

:OUTPUT ACCEPT [2193222:2985984916]

COMMIT

# Completed on Thu Jan 31 21:03:29 2019


La cuestion es que todo funciona desde fuera, pero cuando desde el ordenador 20.200 hago un https://10.10.20.2 (ip del proxmox nada funciona(.


Estimado Berni, quizás si le echaras un vistazo y poder explicarte…


2
Noticias del Blog / Shaping con Iptables: Limitando CPS
« Último mensaje por Berni69 en Febrero 24, 2019, 02:41:50 pm »

Publícalo aquí y miraremos a ver si te podemos echar un cable.

Un saludo


3
Noticias del Blog / Shaping con Iptables: Limitando CPS
« Último mensaje por javier Martinez Arandigoyen en Febrero 24, 2019, 02:40:54 pm »

Estimado Amigo, tengo unos problemas para configurara iptables. Debe ser algo sencillo que me está llevando días sacarlo adelante. No si si alguien me podría ayudar. Mi cuenta es jmarandigoyen@gmail.com


4
Noticias del Blog / LibBeat en PHP - Creando nuestro "log-shipper".
« Último mensaje por Berni69 en Febrero 02, 2019, 07:25:00 pm »

En mi último proyecto me he visto en la necesidad de enviar datos desde una apliación PHP contra un elasticsearch que tenía montado. Los requisitos  del proyecto eran:





  • Insertar trazas operacionales en ElasticSearch
  • Usar el protocolo Beats en un puerto específico
  • Hacerlo en PHP




Qué es ElasticSearch ?





ElasticSearch es un motor de búsqueda basado en Lucene, provee capacidad de búsqueda de texto avanzada, distribuida, y multi tenant. Proporciona fiabilidad, escalabilidad y proporciona múltiples formas de acceso a sus datos.  Lucene es una base de datos no relacional (NoSql) de alto rendimineto hecha en Java y orientada a documentos, almacena los documentos en forma de JSON.  Habitualmente, cuando se hace referencia a ElasticSearch se habla del stack de elasticsearch (ELK/BELK):









  • ElasticSearch: Base de datos no relacional dónde se almacena información.
  • Logstash: Procesa y prepara los documentos para insertarlos dentro de elasticsearch.
  • Kibana: Herramienta de visualización de datos.
  • Beats: Envía logs a la plataforma ELK para que sean indexados en elasticsearch.




ELK Stack
Flujo de información ELK




¿Qué es Beats?





Como ya se ha comentado en el punto anterior, Beats es el encargado de enviar información a elasticsearch. Más que una pieza de software es un concepto, todos los shippers de la familia beats tienen en común que están escritos en Go y utilizan la librería libbeat para implementar el protocolo lumberjack v2 utilizado entre logstash y los shippers beats.  Existen múltiples shippers dentro de la família de beats. Los más comunes son:





  • Filebeat: Lee información de archivos de texto planos y los envía a logstash.
  • WinLogBeat: Envía logs de windows al Stack ELK.
  • PacketBeat: Captura paquetes en la red y los envía a ELK.
  • HeartBeat: Envía paquetes para saber si una máquina esta activa o no.
  • MetricBeat: Colecciona métricas de salud de las máquinas donde esta instalado y lo envía a ELK.
  • Y muchos más implementados por la comunidad




¿Cómo funciona Beats?





Tras mucho buscar no encontré nada en la red que me pudiera servir, todo el mundo terminaba usando el protocolo HTTP contra la API de Elasticsearch o contra una instancia de Logstash. Por esta razón, decidí investigar como funcionaba el protocolo de Beats. Este software implementa un protocolo conocido como Lumberjack en su segunda versión. Es un protocolo desarrollado inicialmente para logstash pero extendido y mejorado para ser más eficiente en su segunda versión.





La única información que encontré es el siguiente archivo en Github https://github.com/logstash-plugins/logstash-input-beats/blame/master/PROTOCOL.md#L12, dónde se explica vagamente el tipo de tramas que componen el protocolo pero no su uso.





Un paquete de Beats puede contener más de una trama la descripción básica de la trama es la siguiente:





### Framing

      0                   1                   2                   3
      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
     +---------------+---------------+-------------------------------+
     |   version(1)  |   frame type  |     payload ...               |
     +---------------------------------------------------------------+
     |   payload continued...                                        |
     +---------------------------------------------------------------+



Cada trama es autocontenida y no está relacionada con la anterior. Para poder enviar una trama es necesario enviar una trama del tipo “Window” especificando el número de tramas de que se enviarán en el mismo paquete, si no se envía en el mismo paquete logstash no puede recontruir la información.  Despues de la trama window se añadirán tramas de datos (Json, Gzip, Data,..), por lo que un paquete de 3 mensajes tendría la siguiente forma:





|W(3)J(Payload1)J(Payload2)J(Payload3)|



Tras este mensaje el servidor debe responder con un ack y con el último mensaje procesado:





|A(3)|



Cómo no encontré nada hecho en PHP en GitHub decidí implementar mi propia implementación de lumberjack v2. La podéis encontrar en





https://github.com/berni69/libbeat-php





O si usáis composer, podéis instalarla con:





composer require berni69/libbeat



Una vez integrada en el proyecto, es tan sencilla de usar como:





use libbeat\BeatSender;
$beat = new  BeatSender('192.168.26.12', 5044);
$beat->send("test_log");
$beat->set_compression_rate(0);
$beat->send(["test_log2", "test_log3"]);



Este sencillo código permite enviar a logstash los mensajes “test_log”, test_log2 y test_log3 mediante el protocolo beats.





El caso típico de uso es enviar las excepciones de PHP al stack de elastic para poder depurar en caso de problemas. Esto es muy útil si se crea una cola dónde se van añadiendo todas las excepciones y un proceso asíncrono va procesando la cola y la va volcando a elastic usando el código anterior para no penalizar la ejecución de PHP.







5
Noticias del Blog / Security Headers en Wordpress
« Último mensaje por Berni69 en Febrero 02, 2019, 02:28:15 pm »

Esta breve entrada tratará de enseñar como se debe configurar de manera segura una instalación de wordpress. El requisito para que esto funcione debe ser tener wordpress con un certificado seguro (SSL/TLS) configurado.





¿Qué son los security headers o encabezados/cabeceras de seguridad?





Son extensiones que proporciona el consorcio de W3C para proteger al usuario contra ataques malintencionados al navegador de un cliente. Este tipo de cabeceras son eficaces para bloqeuar recursos de terceros que no se cargan debidamente, o de dominios no confiables. Otras impiden que la web se cargue como un iframe o incrustada dentro de algún dipo de contenedor para evitar clickjacking (robo de clicks).





Una vez sabemos para que son las security headers, deberemos editar el archivo .htaccess  de nuestro wordpress:





Y añadir el siguiente bloque.





Options +FollowSymLinks -Indexes
php_flag display_errors Off
php_flag session.cookie_httponly on
php_flag session.cookie_secure on

RewriteCond %{REQUEST_METHOD} ^(TRACE|DELETE|TRACK) [NC]
RewriteRule ^(.*)$ - [F,L]

SetEnvIf Host ^www.bitsdelocos.es$ is_main_domain
Header set X-Content-Type-Options nosniff env=is_main_domain
Header set X-XSS-Protection "1; mode=block" env=is_main_domain
Header unset X-Powered-By env=is_main_domain
Header unset X-Pingback env=is_main_domain
Header unset SERVER env=is_main_domain
Header set Content-Security-Policy "default-src 'self' https: data: wss: 'unsafe-inline' 'unsafe-eval';" env=is_main_domain
Header set strict-transport-security "max-age=300; preload" env=is_main_domain





Las 4 primeras líneas impiden que se listen archivos en las carpetas que no poseen ningun index.php que cargue por defecto, se muestren errores que pueden exponer información sensible del servidor al haber un error o que se obtenga información de debug con los métodos trace y track del servidor apache.





La línea de SetEnvIf es útil si tenemos subdominios sin SSL y no queremos que esta configuración se herede en ellos, en caso de que todo esté securizado se puede eliminar y quitar “env=is_main_domain” de las demás.  





Con estas modificaciones se consigue añadir los headers necesarios para poder tener un wordpress seguro en la capa de “navegador”, y ocultar información sensible del servidor web que pudiera dar pistas a un atacante de nuestra infraestructura.







6
Noticias del Blog / SWifi Keygen 1.0.0.6
« Último mensaje por Berni69 en Enero 17, 2019, 12:46:37 pm »

La forma más sencilla es con airodump, con el comando net wlan de windows se puede llegar a sacar pero no recuerdo la sintaxis o con netstubler (no se si aun funciona en las nuevas versiones de windows).


7
Noticias del Blog / SWifi Keygen 1.0.0.6
« Último mensaje por Santiago en Enero 17, 2019, 12:45:15 pm »

Hola. Tengo un problema para conectarme a una red WIFI-ARNET-XXXX. Dónde podría ver que tipo de MAC tiene una red a la que quisiera conectarme?


8
Noticias del Blog / Automatizando ACLs en SQUID
« Último mensaje por Berni69 en Enero 03, 2019, 09:47:03 pm »

Buenas noches en esta entrada os traigo una forma muy sencilla de automatizar el uso de SQUID como proxy de nagevación temporal.





¿Qué es un proxy de navegación?I





Un proxy, o servidor proxy, en una red informática, es un servidor  —programa o dispositivo—, que hace de intermediario en las peticiones  de recursos que realiza un cliente (A) a otro servidor (C) (Wikipedia).





Proxy inverso/ Reverse Proxy
Arquitectura de un proxy inverso








Los proxys web son dispositivos que se utilizan para permitir, acelerar, inspeccionar  o  cachear peticiones a recursos web (HTTP/HTTPS). Esto permite reducir el ancho de banda usado, acelerar la navegación, o modificar contenido en función de reglas de capa 7. Este comportamiento es muy útil para poder controlar qué el tráfico que esta circulando por la red. Existen varios tipos de proxy según su arquitectura:





  • Proxys transparentes: Este tipo de proxys se añade de forma transparente en el flujo de la conexión de internet y el usuario sin que este tenga que configurar nada en su equipo (Las direcciones IP de origen y de destino no son alteradas)
  • Reverse Proxys: Este tipo de proxys instalan entre la entrada de internet y los servidores web, su funcionamiento se basa en cachean peticiones estáticas para liberar a los servidores web de tener que procesarlas cada vez que les llegan.
  • Forward Proxys: Este tipo d e proxys de navegación se encargan de cachear, aplicar ACLs, inspección de tráfico,.. pero es el usuario final que debe configurar el equipo para reenviar las peticiones al proxy.




Forward Proxy
Arquitectura del ForwardProxy




¿Qué es squid?





SQUID es un proxy open source (http://www.squid-cache.org/) pensado para optimizar el uso de la web implementando cachés de contenido. Puede funcionar tanto como reverse proxy como forward proxy, es decir, sirve para optimizar la navegación de internet como para mejorar el delivery de una página web.





Para instalar SQUID en Centos 7 basta con ejecutar :





    yum -y install epel-release
    yum -y update
    yum clean all
    yum -y install squid
    systemctl start squid
    systemctl enable squid



De este modo tendremos SQUID funcionando accesible desde todas las redes privadas, para una una instalación doméstica es suficiente pero si se desea hilar más fino, squid necesita algunos tuneos. Para que no se pueda conectar todo el mundo ni acceder a todo el contenido SQUID incorpora varias ACLs modificables a través de su configuración. (/etc/squid/squid.conf)






# Example rule allowing access from your local networks.
# Adapt to list your (internal) IP networks from where browsing
# should be allowed
acl localnet src 0.0.0.1-0.255.255.255 # RFC 1122 "this" network (LAN)
acl localnet src 10.0.0.0/8 # RFC 1918 local private network (LAN)
acl localnet src 100.64.0.0/10 # RFC 6598 shared address space (CGN)
acl localnet src 169.254.0.0/16 # RFC 3927 link-local (directly plugged) machines
acl localnet src 172.16.0.0/12 # RFC 1918 local private network (LAN)
acl localnet src 192.168.0.0/16 # RFC 1918 local private network (LAN)
acl localnet src fc00::/7       # RFC 4193 local private network range
acl localnet src fe80::/10       # RFC 4291 link-local (directly plugged) machines




¿Porqué no deberíamos dejar todos los rangos privado abiertos?





En una empresa, no todos los segmentos de red deben tener acceso libre a internet puesto que durante un ataque, simplifica mucho la instalación de software malicioso, el control del malware y la posible exfiltración de información.





¿Cómo securizarlo?





En una época donde la agilidad no es un mérito sino un requisito, es necesario implementar una solución que pueda ser ágil sin comprometer la integridad de los sistemas de la información. Por esta razón, tener que editar el archivo de configuración cada vez que un servidor debe conectarse es no es funcional. Por suerte, SQUID implementa un tipo de ACLs para llamar a scripts/binarios externos:





external_acl_type acl_ext ttl=10 %SRC /etc/squid/acl_ext.py
acl ExtAcl external acl_ext
http_access allow ExtAcl



Con estas tres líneas, SQUID será capaz de comunicarse con un componente externo enviando la dirección IP de origen, en este caso un script de Python que se conectará a una DB MySql dónde estarán las reglas de acceso:





#!/usr/bin/python

import mysql.connector
import sys
import logging

logger = logging.getLogger('squid_auth')
logger.setLevel(logging.DEBUG)
fh = logging.FileHandler('/var/log/squid_ext.log')
fh.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)


def match_acl(src):
    """USAGE:The function returns True if the user and passwd match False otherwise"""
    # Write your own function definition.
    # Use mysql, files, /etc/passwd or some service or whatever you want
    mydb = mysql.connector.connect(
        host="mydb.example.com",
        user="db_user",
        passwd="db_pwd",
        database="mydb"
    )
    mycursor = mydb.cursor()
    mycursor.execute("SELECT count(*) as c FROM squid_acls where valid_to >= now() and `start_ip` <= INET_ATON(%s) and `end_ip` >= INET_ATON(%s)",(src,src))
    myresult = mycursor.fetchall()
    logger.debug(myresult)
    return myresult[0][0] > 0


try:
    while True:
        # read a line from stdin
        src = sys.stdin.readline().strip()
        if src:
            if match_acl(src):
                logger.error("{}: OK".format(src))
                sys.stdout.write('OK\n')
            else:
                logger.error("{}: OK".format(src))
                sys.stdout.write('ERR\n')
            # Flush the output to stdout.
            sys.stdout.flush()
except Exception as ex:
    logger.error(ex)



Como backend tengo un una aplicación de Laravel que gestiona la tabla de mysql, el archivo de migración de esta tabla es:





<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class AddSquidAclTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('squid_acls', function (Blueprint $table) {
            $table->increments('id');
            $table->integer('start_ip');
            $table->integer('end_ip');
            $table->timestamp('valid_to');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('squid_acls');
    }
}




El controlador de la API sería para esta tabla sería:





<?php

namespace App\Http\Controllers;

use App\Library\Networking\IpHelpers;
use App\Models\SquidAcl;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

class SquidAclController extends Controller
{
    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        request()->validate([
            'ip' => 'required',
            'time' => 'required|numeric'
        ]);

        $range = IpHelpers::getIpRange($request->input('ip'));
        if ($range != null) {

            $squid = new SquidAcl();
            $squid->start_ip = $range['start_ip'];
            $squid->end_ip = $range['end_ip'];
            $squid->valid_to = DB::raw('NOW() + INTERVAL ' . $request->input('time') . ' MINUTE');
            $squid->save();
            return response()->json(['result' => 1]);
        }
        return response()->json(['result' => 0]);
    }
}




La clase IpHelper que se encarga de obtener los rangos de IPs contenidos en un CIDR, en una IP, o en un dominio:





<?php
namespace App\Library\Networking;

class IpHelpers
{

    public static function getIpRange($cidr)
    {
        if (self::isIpv4($cidr)) {
            $start = $end = ip2long($cidr);
            return array('start_ip' => $start, 'end_ip' => $end);
        } elseif (self::isCidr($cidr)) {

            list($ip, $mask) = explode('/', $cidr);

            $maskBinStr = str_repeat("1", $mask) . str_repeat("0", 32 - $mask);      //net mask binary string
            $inverseMaskBinStr = str_repeat("0", $mask) . str_repeat("1", 32 - $mask); //inverse mask

            $ipLong = ip2long($ip);
            $ipMaskLong = bindec($maskBinStr);
            $inverseIpMaskLong = bindec($inverseMaskBinStr);
            $netWork = $ipLong &amp; $ipMaskLong;

            $start = $netWork + 1;//ignore network ID(eg: 192.168.1.0)

            $end = ($netWork | $inverseIpMaskLong) - 1; //ignore brocast IP(eg: 192.168.1.255)
            return array('start_ip' => $start, 'end_ip' => $end);
        } else {
            putenv('RES_OPTIONS=retrans:1 retry:1 timeout:1 attempts:1');
            $cidr = gethostbyname($cidr);
            if (isset($cidr) &amp;&amp; self::isIpv4($cidr)) {
                return self::getIpRange($cidr);
            }
            return null;
        }

    }

    public static function isIpv4($ip)
    {
        return filter_var($ip, FILTER_VALIDATE_IP) !== false;
    }

    public static function isCidr($cidr)
    {
        $parts = explode('/', $cidr);
        if (count($parts) != 2) {
            return false;
        }

        $ip = $parts[0];
        $netmask = intval($parts[1]);

        if ($netmask < 0) {
            return false;
        }

        if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) {
            return $netmask <= 32;
        }

        if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)) {
            return $netmask <= 128;
        }

        return false;
    }

}



Y para finalizar la ruta a la API:





Route::middleware('auth:api')->post('admin/squid/acl', 'SquidAclController@store');




Por ejemplo, si deseamos dar permisos temorales de conexión durante 60 minutos, bastaría con lanzar:





curl https://localhost/api/admin/squid/acl --data 'ip=192.168.33.33&amp;time=60' -H "Authorization: Bearer XXXXX" --http1.1



Donde XXXX es el token del usuario que tiene permisos para ejecutar esta acción.


9
Noticias del Blog / Automatizando ACLs en SQUID
« Último mensaje por Berni69 en Enero 03, 2019, 08:09:45 pm »
10
Noticias del Blog / SWifi Keygen 1.0.0.6
« Último mensaje por Berni69 en Enero 03, 2019, 07:50:49 pm »

Hola,


Arreglado el link


Saludos,


Páginas: [1] 2 3 ... 10