>

19 abril 2015

Bloquear, banear las ips de atacantes al ssh en Raspberrypi con un script de Python

Los que tenemos una Raspberry pi y nos conectamos desde cualquier parte del mundo :-) a través de ssh, tenemos un problema con ciertos personajes que quieren acceder también a ella vía bruteforce. Si no sabes de lo que estoy hablando te aconsejo que accedas al fichero auth.log dentro del directorio /var/log/, aquí podrás ver los múltiples intentos de acceso que tienes.
Cansado de que se quisieran conectar a ella, decidí crearme un script en python que lee el fichero auth.log y mete las ips  en un conjunto y las añade al iptables. Con ello banneo o bloqueo todas las ips extrañas.
Antes de ejecutar el script deberás instalar la aplicación ipset y iptables si no las tienes ya instaladas, para ello deberás ejecutar los siguientes comandos:

  1. sudo apt-get update
  2. sudo apt-get install ipset
  3. sudo apt-get install iptables

Aquí os dejo el script pero podéis descargarlo desde github 

#!/usr/bin/env python3.4
 
"""
 sudo ipset create banthis hash:ip maxelem 1000000
 sudo ipset add banthis 1.1.1.1
 sudo iptables -I INPUT -m set --match-set banthis src -p tcp --destination-port 22 -j DROP


 $ sudo ipset save banthis > banthis.txt
 $ sudo ipset destroy banthis
 $ sudo ipset restore -f banthis.txt

"""

# IMPORTS
import hashlib
import re
import socket
import pprint
import subprocess
import commands
import os
import time
 
# VARS
log_path = '/var/log/auth.log'
hosts=[]
full_hosts_data=[]
previous_ip = ""
previous_host = ""

#Create ipset
def create_banthis():
 return subprocess.call("ipset create banthis hash:ip maxelem 1000000" ,shell=True);

#Save ipset
def save_banthis():
 return subprocess.call("ipset save banthis > banthis.txt" ,shell=True);

#Add ip to ipset
def anhade_ip(ip):
 return subprocess.call(["ipset", "add", "banthis", ip]);

#Add ipset to iptables
def anhade_iptables():
 subprocess.call("iptables -I INPUT -m set --match-set banthis src -p tcp --destination-port 22 -j DROP",shell=True);

def borra_iptables():
 p = subprocess.Popen(["iptables", "-L", "--line-numbers"], stdout=subprocess.PIPE);
 output , err = p.communicate();
 for line in output.split("\n"):
  check_1 = line.find("banthis");
  if check_1 != -1 :
   index= subprocess.call("iptables -D INPUT " + line[0],shell=True);

#Check requirements
def check_requirements():
  ipset_status = commands.getstatusoutput("hash ipset")
  iptables_status = commands.getstatusoutput("hash iptables")
  if ipset_status[0] != 0 or iptables_status[0] != 0:
    raise Exception("Iptables and/or ipset not found, please intstall these dependencies first")

#Adjust lines
def adjust_item( str, i ):
    if len(str) < i:
        for j in range(i-len(str)):
            str = str + " "
    return str
 
#Lookup ip by name
def get_ip_hostname(name):
 try:
            return socket.gethostbyname(name);
        except Exception:
            return "0";

#Date
def get_date( my_line ):
    date_words = my_line.split(":")
    date = date_words[0] +":"+ date_words[1] +":"+ ((date_words[2]).split(" "))[0]
    return date

try:
 start_time = time.time();
 check_requirements();
 if save_banthis() == 1:
  create_banthis();

 # READ FILE
 with open(log_path, 'rt') as log:
     text = log.read();

 # COLLECTING HOSTS AND IPS
 for line in text.split("\n"):
  if "sshd" in line:
   if len(line) > 5:
    check_1 = line.find("rhost=")
    if check_1 != -1 :
     words = line[check_1:len(line)].split(" ");
     if len(words) > 2 :
      if len(words[2]) > 5 :
       user = words[2].split("=")[1];
       ip = words[0].split("=")[1];
       host = ip;
       pat = re.compile("^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$");  
       test = pat.match(ip);
       if not test:
        ip = get_ip_hostname(ip);
        if ip != "0":
         host = ip;  
       exists_check = 0
       for my_host in hosts:
        if my_host["ip"] == ip:
         exists_check = 1;
       if exists_check == 0:
        if not "192.168." in ip :
         hosts.append({"ip":ip, "hostname":host , "accounts":user, "date":get_date( line )});

 # PRINT TABLE HEADERS
 print(
  adjust_item("DATE", 16 ),
  adjust_item("IP", 15),
  adjust_item("HOSTNAME", 40),
  adjust_item("ACCOUNTS", 30)
 )
 for item in hosts:
  anhade_ip(item["ip"])
  parsed_ip           = adjust_item( item["ip"],          15 )
  parsed_date         = adjust_item( item["date"],        16 )
  parsed_host         = adjust_item( item["hostname"] ,   40 )
  parsed_accounts     = adjust_item( item["accounts"],    30 )
  print(
   parsed_date[:16],
   parsed_ip, parsed_host[:40],
   parsed_accounts[:30],
  )
 borra_iptables();
 anhade_iptables();
 print("--- %s seconds ---" % (time.time() - start_time));
except Exception as e:
 print str(e);

10 agosto 2014

Ni todo es gratuito ni todo es público

Aunque Internet y las redes sociales son un gran escaparate y una magnifica autopista para alcanzar fácilmente la información deseada, algunas veces puede ser una fuente de quebraderos de cabeza para los usuarios que no dan su consentimiento para que determinados datos referentes a su vida personal o profesional se publiquen.

Afortunadamente el Tribunal de Justicia de la Unión Europea (TJUE) ha dictaminado que buscadores de Internet como Google y posteriormente Bing retiren los enlaces a informaciones publicadas en el pasado, si se comprueba que son lesivas para alguna persona o carecen de relevancia.

Si consideráis que se ha vulnerado vuestro derecho a la privacidad o que alguna de las referencias que aparecen en el buscador no se ajustan a la realidad no dudéis en presentar una reclamación.
Aquí os dejo el link de acceso al formulario de Google y al de Microsoft Bing

De todas formas sigue existiendo un vacío legal entorno a la privacidad en la red ya que aunque los buscadores acaten la sentencia de la UE, las páginas donde están publicadas las informaciones a las que se hace referencia no se dan por aludidas.

29 junio 2014

Conectándote a la Máquina Virtual de Java (JVM)

La entrada de hoy va de como te conectas a la máquina virtual de java mediante programación, y te preguntarás ¿para qué me voy a conectar a la maquina virtual?, pues muy fácil, podrás controlar la memoria, threads y leer las propiedades del sistema.


package es.jnovo;

import java.io.File;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.Set;

import javax.management.MBeanServerConnection;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;

import com.sun.tools.attach.AgentInitializationException;
import com.sun.tools.attach.AgentLoadException;
import com.sun.tools.attach.AttachNotSupportedException;
import com.sun.tools.attach.VirtualMachine;
import com.sun.tools.attach.VirtualMachineDescriptor;
import com.sun.tools.attach.spi.AttachProvider;

public class Jvm {

 public static void main(String[] args) {
  systema();
 }

 public static String systema() {
  StringBuilder salida = new StringBuilder();
  try {
   final AttachProvider attachProvider = AttachProvider.providers().get(0);

   VirtualMachineDescriptor descriptor = null;
   for (VirtualMachineDescriptor virtualMachineDescriptor : attachProvider.listVirtualMachines()) {

    // System.out.println(virtualMachineDescriptor.displayName());

    if (virtualMachineDescriptor.displayName().contains("eclipse")) {
     descriptor = virtualMachineDescriptor;
    }
   }

   if (descriptor == null)
    throw new RuntimeException("No tienes descriptor de la maquina virtual");

   VirtualMachine virtualMachine;

   virtualMachine = attachProvider.attachVirtualMachine(descriptor);

   final String home = virtualMachine.getSystemProperties().getProperty("java.home");
   final String agent = home + File.separator + "lib" + File.separator + "management-agent.jar";

   virtualMachine.loadAgent(agent);

   final Object portObject = virtualMachine.getAgentProperties().get("com.sun.management.jmxremote.localConnectorAddress");

   final JMXServiceURL target = new JMXServiceURL(portObject + "");
   final JMXConnector connector = JMXConnectorFactory.connect(target);
   final MBeanServerConnection remote = connector.getMBeanServerConnection();

   // listamos los threads del sistema
   ObjectName objName = new ObjectName(ManagementFactory.THREAD_MXBEAN_NAME);
   Set mbeans = remote.queryNames(objName, null);
   for (ObjectName name : mbeans) {
    ThreadMXBean threadBean = ManagementFactory.newPlatformMXBeanProxy(remote, name.toString(), ThreadMXBean.class);
    long threadIds[] = threadBean.getAllThreadIds();
    for (long threadId : threadIds) {
     ThreadInfo threadInfo = threadBean.getThreadInfo(threadId);
     System.out.println(threadInfo.getThreadName() + " / " + threadInfo.getThreadState());
    }
   }
  } catch (AttachNotSupportedException e) {
  } catch (IOException e) {

  } catch (AgentLoadException e) {
  } catch (AgentInitializationException e) {
  } catch (MalformedObjectNameException e) {
  }
  return salida.toString();
 }
}



29 marzo 2014

TimeOut en un webservice sin tocar el código autogenerado

Alguna vez seguro que habéis necesitado que el cliente del servicio web al que estáis llamando no tenga un tiempo de espera muy grande, sobre todo si es llamado desde un proceso que se ejecuta en una web, ya que podemos dejar colgados threads.
Con el siguiente código podreis ajustar este tiempo sin tener que modificar los ficheros generados por el wsdljava

//direccion del webservice 
String myEndpointURL = "endpointURL";
// tiempo de espera del web service
Integer myTimeOutWS = new Integer(60000);
XXXXXXX_DefaultLocator service = new XXXXXXX_DefaultLocator();
//Casteamos el Service a Stub
org.apache.axis.client.Stub stub = (org.apache.axis.client.Stub) service.getXXXXXXX_DefaultSoap12(new URL(endpoint));
//Seteamos el timeout de la llamada del servicio web 
stub.setTimeout(myTimeOutWS != null ? myTimeOutWS.intValue() : 60000);
serviceProvider = service.getXXXXXXX_DefaultSoap12(new URL(conectionUrl));

07 enero 2014

Método que reemplaza un string javascript

//Metodo que reemplaza un string
function reemplaza(salida,valor, porValor){
    var intIndexOfMatch = salida.indexOf( valor );
    // Creamos un bucle para buscar el caracter a reemplazar
    while (intIndexOfMatch != -1){
        //reemplazamos el valor
        salida = salida.replace( valor, porValor );
       
        //realizamos la busqueda
        intIndexOfMatch = salida.indexOf( valor );
    }
    return salida;
}

19 octubre 2013

Método que comprueba que no haya duplicado en un HashMap de java (hasmap)

Este método putToMap comprueba que no existan duplicados en un HashMap
import java.util.HashMap;
import java.util.Map;

/**
 * @author jnovos
 * 
 */
public class MyHashMap {

 private final Map map = new HashMap();

 public static void main(String[] args) {
  MyHashMap myHashMap = new MyHashMap();
  myHashMap.putToMap("1", "valor1");
 }

 private String putToMap(String key, String value) {
  if (this.map.containsKey(key)) {
   return value;
  } else {
   return (String) this.map.put(key, value);
  }
 }

}

09 junio 2013

Auto completado con el tab en Windows XP

Cuantas veces has echado de menos cuando estas en un editor de comandos o shell o comand prompt el autocompletado en el XP , para habiltarlo sigue los siguientes pasos(tal y como se especifica):
  1. Pulsa el boton de Inicio
  2. Selecciona Ejecutar y escribe regedit
  3. Expande  HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Command Processor
  4. Doble click en  CompletionChar
  5. Reemplaza el valor que hay con un 9
  6.  Pulsa OK

08 junio 2013

Eliminar una acción predeterminada de una aplicación en android

Cuentas veces queremos que una aplicación de nuestro smartphone android no abra un link de twitter o facebook y no sabemos cómo quitar esa maldita asociación al programa pues se hace así:

  • Ir a ajuste / aplicaciones seleccionar todas y buscar la asociada (Por ejemplo Internet
  •   Una vez dentro busca la opción Ejecutar de Forma Predeterminada y pulsa Borrar valores Predeterminados