¿Qué es un ataque DDoS? ¿Cómo podemos evitarlo?

El Viernes 21 de Octubre de 2016 se produjo el mayor y más importante ataque DDoS de los últimos años. El ataque fue dirigido hacia los servicios DynDNS y dejo fuera de combate a decenas de web y servicios como por ejemplo Twitter, Reddit, Github, Amazon, Spotify…

Lo grave del asunto es que el ataque al parecer fue perpetrado gracias a una vulnerabilidad existente en dispositivos IoT (Internet de las cosas), como son los electrodomésticos conectados a la red.

¿Que es un ataque DDos?

Vayamos por partes;  Un ataque de denegación de servicio (DoS) es un ataque dirigido hacia una red o sistema de computadoras que provoca que el mismo deje de responder a los usuarios. Esto ocasiona que el sistema esté fuera de línea el tiempo que dura el ataque más el tiempo de restablecimiento del sistema que suele oscilar entre 20 minutos y varias horas en el peor de los casos.

El caso que nos ocupa es una ampliación de este ataque y sus siglas DDoS corresponden a ataque de denegación de servicio distribuido o Distributed Denial of Service, en el que el ataque se lleva a cabo desde cientos o miles de puntos diferentes hacia el mismo objetivo.

Existen diferentes tipos de ataque, pero básicamente se trata de enviar un flujo tal de peticiones que el sistema no puede atenderlas por lo que acaba tirando el servicio por seguridad. Otros ataques pueden suponer interrupciones de componentes físicos de red o incluso alteración de las tablas de enrutamiento.

¿Por qué es tan popular el ataque DDoS?

Los ataques DDoS se han vuelto muy populares debido a que el objetivo no tiene por que tener ninguna vulnerabilidad, ya que son ataques de infraestructura. Por esto cualquiera podría comprar un pack de ataque DDoS por unos 150€ y mantener fuera de línea a un rival de League of Legends por ejemplo (Sí, esto ha pasado). Ojo, antes he mencionado que se ataca desde cientos o miles de ordenadores y es que estos ordenadores sí que suelen estar afectados por alguna clase de vulverabilidad (como Mirai en el internet de las cosas) o malware.

¿Qué se busca con los ataques DDoS?

Aquí debemos tener en cuenta los tipos de ataque; estos pueden ser personalizados, los cuales no tienen mucha repercusión mediática y suelen buscar un objetivo concreto (dejar fuera de línea a un rival o tirar el servidor del examen de la universidad) o globales, los cuales buscan una gran repercusión mediática, suelen estar reivindicados por organizaciones o grupos hacktivistas y sirven para que el mundo les preste atención.

¿Como podemos evitar los ataques DDoS?

No se puede… sin más, hoy en día es imposible evitar este tipo de ataques debido a que las causas son los propios mecanismos de seguridad de nuestras infraestructuras informáticas. Hace unos años podríamos pensar que si todos nuestros ordenadores estuvieran libres de malware, no podrían pertenecer a botnets (redes de ordenadores zombies controlados por un mismo malware y que son capaces de perpetrar ataques DDoS dirigidos) y entonces sería mucho más complicado realizar estos ataques pero, ay amigos, bienvenidos al internet de las cosas.

El internet de las cosas y Mirai.

Actualmente no son pocos los hogares que disponen de más de un ordenador conectado a internet sin siquiera darse cuenta. ¿Tienes una SmartTv? ¿un frigorífico conectado a internet? ¿Un ebook, tablet, videoconsola? ¿Quizá tengas una de esas nuevas bombillas inteligentes o un Chromecast? ¿Una camara IP? Podría seguir así mucho rato pero aunque no tengas nada de esto, seguro que tienes un router en casa ¿verdad? ¿Le has cambiado la contraseña? :D

¿Por que os cuento esto? Bueno, todos esos artículos son susceptibles de ser participes en la mayor botnet jamás creada, Mirai.

Mirai es capaz de convertir sistemas Linux en bots controlados remotamente y además ni siquiera necesita crackearlos ya que la mayoría de nosotros no se preocupa de cambiar la contraseña genérica de estos dispositivos. Mirai puede afectar a impresoras, camaras de vigilancia o routers caseros y hay poco que podamos hacer.

Este es un problema que tiene difícil solución y quizá sería un buen momento para plantearnos si realmente necesitamos tantos dispositivos inteligentes o sería más sensato usar nuestra inteligencia y dejar de ser tan cómodos.

Y tú. ¿Tienes muchos aparatos conectados a internet?

Leer más

Truco C# - Eliminar / Matar procesos Windows por nombre o id

En este post os voy a enseñar una manera sencilla de eliminar procesos concretos por nombre o id mediante programación.

Para poder hacer uso de este truco vamos a necesitar añadir System.Diagnostics a nuestro programa ya que haremos uso de la clase Process. Una vez hecho esto vamos a definir 3 métodos, uno para matar procesos por su id de proceso y dos que irán por nombre de proceso; el primero eliminará la primera ocurrencia y el segundo eliminará todos los procesos con el mismo nombre (el proceso "Chrome" puede ser un buen ejemplo para probarlo).

Matar tarea por Id.

 
        private void KillTaskById(int taskid)
        {
            try
            {
                Process proceso = Process.GetProcessById(taskid);
                proceso.Kill();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

Matar tarea por Nombre. Primera ocurrencia.

         private void KillTaskByName(string taskName)
        {
            try
            {
                Process[] procesos = Process.GetProcessesByName(taskName);
                procesos[0].Kill();
            } 
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

Matar tarea por Nombre. Todas las ocurrencias.

 
        private void KillAllTasksByName(string taskName)
        {
            try
            {
                foreach (Process proceso in Process.GetProcessesByName(taskName))
                {
                    proceso.Kill();
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

Probadlo y dejar en los comentarios que os ha parecido.

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.

Leer más

Truco C# - Listar todos los servicios de un webservice

Hacía ya mucho tiempo que no posteaba nada, mas por falta de tiempo que por otra cosa, pero hoy os traigo una nueva entrada con un truco para C#.

Si habéis leido el título ya intuireis de que va el truco de hoy. Se trata, ni más ni menos de cómo obtener la lista de servicios publicados en un webservice.

Para que el método funcione lo único que necesitais es la url de un descriptor de webservice (acabará en ?wsdl o ?singleWSDL) para pasarla como parametro al método GetWsdlMethods que os describo a continuación.

 
        private string[] GetWsdlMethods(string wsdlUrl)
        {
            List<string> services = new List<string>();

            try
            {
                XmlTextReader myStreamReader = new XmlTextReader(wsdlUrl);

                ServiceDescription wsdl =
                   ServiceDescription.Read(myStreamReader);

                txtMethods.Clear();

                foreach (PortType pt in wsdl.PortTypes)
                {

                    services.Add(string.Format("PortType {0}", pt.Name));
                    services.Add("\r\n----------------------------------------");
                    foreach (Operation op in pt.Operations)
                    {
                        services.Add(string.Format("\r\n{0}", op.Name));
                    }
                }
            }
            catch
            {
                services.Add("ERROR READING WDSL URL");
            }

            return services.ToArray();
        }

Probadlo y dejar en los comentarios que os ha parecido.

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.

Leer más

Cómo bloquear / desactivar / eliminar los anuncios de Skype

Todos los que usamos Skype nos hemos acostumbrado a convivir con los anuncios que la aplicación nos muestra pero, ¿sabíais que se pueden desactivar de una manera muy sencilla? Sigue leyendo y te explico cómo.

Leer más

Truco Java - Uso de ListIterator

Hoy más que un truco os voy a poner un ejemplo de utilización de la clase ListIterator. 

ListIterator es un iterador secuencial que posibilita recorrer listas en cualquier sentido. Hay que tener presente que la posición de un iterador no representa ningún valor real de la lista, siempre estará entre dos elementos, al principio o al final.

En el ejemplo vamos a recorrer un Array de cadenas extrayendo los valores numéricos y posteriormente recorriendo la lista hacia adelante y hacia atrás.

 
package TrucosIExpression;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.ListIterator;

/**
 *
 * @author InvalidExpression
 */
public class Truco1 {

    /**
     * Metodo que extray todos los valores numéricos de un array de cadenas
     * y lo devuelve en un ArrayList
     * @param cadenas String[] .
     * @return ArrayList con valores numericos extraidos.
     */
    public ArrayList extraerNumeros(String[] cadenas) {
        if (cadenas == null) {
            throw new IllegalArgumentException("Parámetro erroneo.");
        } else {
            ArrayList arrayCadenas = new ArrayList();
            arrayCadenas.addAll(Arrays.asList(cadenas));
            ListIterator listaIterador;
            listaIterador = arrayCadenas.listIterator();
            while (listaIterador.hasNext()) {
                String cadena = (String) listaIterador.next();
                try {
                    Integer numero = new Integer(cadena);
                } catch (NumberFormatException e) {
                    listaIterador.remove();
                }
            }
            return arrayCadenas;
        }
    }

    /**
     * Metodo main.
     *
     * @param args String[] args.
     */
    public static void main(String[] args) {
        Truco1 trucoIterator = new Truco1();
        String[] cadenas = {"SILLA","5", "1", "4", "MESA", 
                            "8", "ZAPATO", "CERVEZA", "10", "12"};
        ArrayList arrayNumeros = trucoIterator.extraerNumeros(cadenas);
        ListIterator iterador = arrayNumeros.listIterator();
        //Recorremos de principio a fin con hasNext
        while (iterador.hasNext()) {
            System.out.println(iterador.next());
        }
        //Recorremos desde el final hasta el principio.
        while (iterador.hasPrevious()) {
            System.out.println(iterador.previous());
        }
    }
}

El resultado de la ejecución de este pequeño programa en NetBeans sería el siguiente:

Si necesitáis más información sobre ListIterator podéis encontrarla aquí.

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.

Leer más

Truco Delphi - Enviar emails usando el servicio Gmail de Google

En el truco de hoy os voy a enseñar como podéis enviar correos electrónicos desde vuestra aplicación Delphi mediante vuestra cuenta Gmail.

Para ello vamos a hacer uso de los componentes Indy disponibles en cualquier versión de RAD Studio (en el truco se utiliza la versión XE8 pero está testeado en XE5 también).

Vamos a crearnos una función SendGMail con el siguiente código:

  
procedure SendGmail(pUsuario, pPassword, pAsunto, pCuerpo, pDestino : string);
var
  Smtp : TidSMTP;
  ManejadorSSL : TidSSLIOHandlerSocketOpenSSL;
  Mensaje: TIdMessage;
begin
  ManejadorSSL := TIdSSLIOHandlerSocketOpenSSL.Create(nil);
  with ManejadorSSL do
  begin
   Destination := 'smtp.gmail.com:587';
   Host := 'smtp.gmail.com';
   MaxLineAction := maException;
   Port := 587;
   SSLOptions.Method := sslvTLSv1;
   SSLOptions.Mode := sslmUnassigned;
   SSLOptions.VerifyMode := [];
   SSlOptions.VerifyDepth := 0;
  end;

  Smtp := TIdSMTP.Create( nil );

  with Smtp do
  begin
    IoHandler := ManejadorSSL;
    Host := 'smtp.gmail.com';
    Port := 25;
    Username := pUsuario;
    Password := pPassword;
    UseTLS := utUseExplicitTLS;
  end;

  Mensaje := TIdMessage.Create(nil);
  with Mensaje do
  begin
    Clear;
    Subject := pAsunto;
    Body.Text := pCuerpo;
    Recipients.Add;
    Recipients.Items[0].Address := pDestino;
  end;

  Smtp.Connect;
  if smtp.Connected then
  begin
    smtp.Send(Mensaje);
    smtp.Disconnect;
  end;

  FreeAndNil(Smtp);
  FreeAndNil(Mensaje);
  FreeAndNil(ManejadorSSL);

end;
 

Y ya está, solamente tendremos que llamar a esta función con los parámetros relativos a nuestra cuenta para enviar nuestro correo.

En lugar de crear los objetos dinámicamente, podéis pegar objetos directamente desde la paleta de componentes en vuestro formulario y ahorraros el create; si lo hacéis dinámicamente no olvidéis incluir en el uses las referencias necesarias:

 uses
  [...] IdMessage, IdIOHandler, IdIOHandlerSocket, IdIOHandlerStack,
  IdSSL, IdSSLOpenSSL, IdBaseComponent, IdComponent, IdTCPConnection,
  IdTCPClient, IdExplicitTLSClientServerBase, IdMessageClient, IdSMTPBase,
  IdSMTP,IdAttachmentFile,IdGlobal;
 

Observaréis que falta la opción de adjuntar algún archivo, pero eso lo vamos a dejar para futuros trucos.

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.

Leer más

Truco Delphi - MessageBox organizados y personalizados.

Si eres, o has sido, programador Delphi, seguramente te has encontrado muchas aplicaciones donde se utiliza la función Showmessage, MessageBox o Messagedlg o incluso todas a la vez de manera desorganizada y no unificada.

En este truco/post os voy a mostrar como organizar vuestros mensajes de aplicación en una única unidad y como personalizarlos con vuestros propios iconos sin necesidad de crear formularios específicos para ellos.

Mi recomendación es que utilicéis siempre MessageBox, por dos motivos:

1. MessageBox es una función de la Api de Windows, por tanto, los textos de los botones estarán localizados al idioma del sistema.
2. Permite una mayor personalización y control de los mensajes mostrados.

En toda aplicación suelen utilizarse, al menos, tres tipos de mensajes de diálogo con el usuario; Mensajes de error, mensajes de aviso y mensajes de pregunta.

Mi recomendación es que os creéis una unidad donde agrupéis todos esos mensajes de manera que podáis utilizarlos en toda la aplicación, por ejemplo algo así:

unit UDialogos;

interface

uses Windows;

procedure MensajeError(owner: HWND; p_texto :string);
procedure MensajeAviso(owner: HWND; p_texto :string);
function Pregunta(owner: HWND; p_texto, p_titulo: string) : boolean;

implementation

procedure MensajeError(owner: HWND; p_texto :string);
begin
  MessageBox(owner, pchar(p_texto), 'Error',
               MB_ICONERROR or MB_OK or MB_TASKMODAL)
end;

procedure MensajeAviso(owner: HWND; p_texto :string);
begin
  MessageBox(owner, pchar(p_texto),'Aviso',
               MB_ICONINFORMATION or MB_OK or MB_TASKMODAL )
end;

function Pregunta(owner: HWND; p_texto, p_titulo: string) : boolean;
begin
  result := MessageBox(owner, pchar(p_texto), pchar(p_titulo),
               MB_ICONQUESTION or MB_YESNO or MB_TASKMODAL) = IDYES
end;

end.

De esta manera tendremos todos los mensajes localizados en una unidad de nuestra aplicación y a nuestra disposición para cuando los necesitemos.

Es importante utilizar correctamente el parámetro "owner" de esas funciones y pasárles siempre el "Handle" del formulario que llama a la función ("Self.Handle") para que los diálogos sepan delante de quién deben mostrarse.

Si no os gustan los iconos por defecto que muestra Windows, siempre podéis utilizar los vuestros utilizando "MB_USERICON", pero en este caso deberéis utilizar la función MessageBoxIndirect.

Supongamos que tenemos un icono en los recursos de nuestra aplicación llamado 'ICONICO' y que queremos mostrarlo en un mensaje de dialogo concreto, escribiríamos lo siguiente:

  
procedure MensajePersonalizado(owner: HWND; p_texto, p_titulo :string);
var
  flags : uint;
  MsgPars: TMsgBoxParams;
begin
  flags := MB_USERICON or MB_OK or MB_DEFBUTTON1 or MB_TASKMODAL;

  //Establecemos los parámetros
  with MsgPars do
  begin
    cbSize := SizeOf(MsgPars);
    hwndOwner := owner;
    hInstance := Sysinit.hInstance;
    lpszText := PChar(p_texto);
    lpszCaption := pchar(p_titulo );
    dwStyle := flags;
    lpszIcon := 'ICONICO'; //Nuestro icono en los recursos
    dwContextHelpId := 0;
    lpfnMsgBoxCallback := nil;
    dwLanguageId := LANG_NEUTRAL;
  end;

  MessageBoxIndirect(MsgPars);

end;

Una última consideración sobre utilizar MB_OKCANCEL o MB_YESNO. Cualquier flag que incluya OK y/o CANCEL responderá a las teclas "Intro" para el OK y "Escape" para el CANCEL, es decir, si utilizáis MB_YESNO, "intro" y "escape" no funcionarán, si utilizáis MB_OKCANCEL, si que lo harán.

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.

Leer más