PingTalk Client

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
##############################################################################
#  Copyright (C) 2010 Kenkeiras <kenkeiras@gmail.com>
#
#  This program is free software. It comes without any warranty, to
#  the extent permitted by applicable law. You can redistribute it
#  and/or modify it under the terms of the Do What The Fuck You Want
#  To Public License, Version 2, as published by Sam Hocevar.
#
#  See http://sam.zoy.org/wtfpl/COPYING for more details.
##############################################################################

import sys

try:
    from scapy.all import IP, ICMP, send, sr # Scapy
except:
    print >>sys.stderr, "Este script necesita scapy"

from os import devnull # Para suprimir los mensajes de Scapy :P
from os import urandom # para obtener strings pseudo-aleatorias
from time import sleep # para esperar entre mensaje y mensaje

buff_size = (1 << 10) # Tamaño del buffer de lectura

sleep_time = 0.01 # Tiempo entre comprobaciones de fin de hilos

global done
done = 0 # nº de hilos que acabaron
rand_data = False # ¿El data del ping será aleatoria?

class ping_client:
    # Genera un identificador de 16-bits a partir del mensaje
    def two_bytes(self,msg):
        x = 0L
        s = msg[ : 2]
        if (len(s) > 1):
            x = (ord(s[0]) + (ord(s[1]) << 8))
        elif (len(s) == 1):
            x = ord(s[0])
        else:
            x = 0
        if (self.debug):
            print >>sys.stderr,  s,"->",
            print >>sys.stderr,hex(x)
        return x

    # Actualiza el paquete al próximo número de secuencia
    def next_seq(self, paq):
        paq[1].seq = (paq[1].seq + 1) & 0xFFFF

    # Prepara el paquete para mandarlo
    def craft_paq(self,
                 src_ip,
                 dst_ip,
                 data = "A",
                 rep = 56,
                 paq_type = 8,
                 paq_code = 0):
        ip = IP(src = src_ip, dst = dst_ip)
        icmp = ICMP()
        icmp.type = paq_type
        icmp.code = paq_code
        icmp.id = 0
        return [ip, icmp, str(data * rep)]

    # Envía un paquete
    def send_paq(self, paq):
        send(paq)

    # Ensambla un paquete
    def asm_paq(self, paq):
        return paq[0]/paq[1]/paq[2]

    # Inicializa el objeto
    def __init__(self, src_ip, dst_ip,rand_data = False ,debug = False, data = "Hey!", rep = 14, sleep_time = 0.01):
        self.debug = debug
        self.paq = self.craft_paq(src_ip, dst_ip, data, rep)
        self.rand = rand_data
        self.rep = rep
        self.sleep_time = sleep_time

    # Manda el mensaje
    def send(self, msg, part = False):
        i = 0
        while True:
            self.next_seq(self.paq) # Siguiente número de secuencia
            if (self.rand): # Si el data es aleatorio, se genera
                r = urandom(self.rep)
                self.paq[2] = r
            self.paq[1].id = self.two_bytes(msg) # Se prepara el nuevo id
            self.send_paq(self.asm_paq(self.paq)) # Se envía

            # Si no es parte de un mensaje mayor
            # envía todo
            if (not part):
                if (len(msg) < 1):
                    break
                msg = msg[2 : ]

            # Si lo es, envía todo lo posible y devuelve el resto
            else:
                msg = msg[2 : ]
                if (len(msg) < 2):
                    return msg

            # Espera un poco para intentar que lleguen en orden
            sleep(sleep_time)

    # Envía parte de un mensaje
    def send_part(self, msg):
        return self.send(msg, True)

# Muestra las opciones
def show_help(arg0):
    print arg0, "-s <ip de origen> -d <ip de destino> [-t <nº de hilos>] [-p <paquetes/hilo>] [-b <datos a enviar>] [-r <nº de repeticiones de los datos>] [ -f <archivo a enviar>] [ -u ]"
    print arg0, "-h   : muestra esto"
    print arg0, "-u   : los datos enviados (no los identificadores) son aleatorios"

threadN = 1 # Número de hilos
src_ip = "" # IP de origen
dst_ip = "" # IP de destino
times = 10  # Paquetes que enviará cada hilo
data = "A" # Cadena que se enviará
rep = 56    # Veces que se repetirá la cadena
fname = ""

# Se leen los parámetros
argc = len(sys.argv)
i = 1
while i < argc:
    if (sys.argv[i] == "-h"):
        show_help(sys.argv[0])
        exit(0)

    elif (sys.argv[i] == "-s"):
        i += 1
        src_ip = sys.argv[i]

    elif (sys.argv[i] == "-u"):
        rand_data = True

    elif (sys.argv[i] == "-d"):
        i += 1
        dst_ip = sys.argv[i]

    elif (sys.argv[i] == "-p"):
        i += 1
        times = int(sys.argv[i])

    elif (sys.argv[i] == "-t"):
        i += 1
        threadN = int(sys.argv[i])

    elif (sys.argv[i] == "-b"):
        i += 1
        data = sys.argv[i]

    elif (sys.argv[i] == "-r"):
        i += 1
        rep = int(sys.argv[i])

    elif (sys.argv[i] == "-f"):
        i += 1
        fname = sys.argv[i]

    else:
        print >>sys.stderr, "Opción [", sys.argv[i], "] desconocida"
        exit(1)

    i += 1

if (src_ip == "") or (dst_ip == ""):
    print >>sys.stderr, "No se han especificado las IP que se enviarán"
    exit(1)

s = ping_client(src_ip, dst_ip, rand_data  = rand_data, data = data, rep = rep)

# Elimina los mensajes superfluos de stdout
tmp = sys.stdout

# Se escribe el mensaje
if (fname == ""):
    data = raw_input(">>>")
    if (data [-1] == "\n"):
        data = data[:-1]

    sys.stdout = open(devnull, "a")
    s.send(data)
else: # Se obtiene de un archivo
    sys.stdout = open(devnull, "a")
    f = open(fname, "r")
    l = "" # Prepara un buffer vacío
    while (True):
        l += f.read(buff_size | 1) # Le añade una carga de datos
        ll = len(l)
        if (ll < buff_size): # Si es el último
            s.send(l) # no hay siguiente mensaje
            break
        l = s.send_part(l) # sino, si lo hay

sys.stdout = tmp # Restaura la salida

print "[Hecho]"