Foro de elhacker.net

Siguiendo como funcionan las clases en python, sabemos que una clase en python tiene sus atributos propios (self.*) y sus métodos que pueden ser accesibles desde dentro o fuera, pero además tiene un método __init() que se ejecuta automáticamente al llamar a la clase.

Así pues si queremos un thread que realice una determinada tarea este método es muy eficaz, por ejemplo para hacer ARP spoofing, debemos de trabajar con listas de hosts, funciones que afectan sobre ellos, y luego tenemos que permitir acceso externo para poder detenerlo o reiniciarlo.

Así pues creo este hilo para buscar cual es la mejor forma de programar esas subrutinas o módulos que están formados por funciones estáticas, atributos propios, y luego funciones externas que hacen de wrapper de los anteriores para poder controlar el funcionamiento de la subrutina desde otra parte del código externa.

Y bien ¿qué ideas se me han ocurrido?, me gustaría ver cuáles se os ocurrirían a vosotros y debatirlo hasta encontrar la manera más eficaz. La idea es no dar visibilidad en partes donde no se necesita, proteger el código.

1. Crear un namespace, con funciones que hacen de wrapper y pueden ser llamadas por terceros para controlar la subrutina. Y declarar las funciones correspondientes a la subrutina como static fuera del namespace.

spoofing.h

namespace Spoofing
{
Init();
Restart();
Uninit();
};
 
void EscanearRed();
void RealizarSpoofing();
...
 

spoofing.cpp

 
static BOOL * run = new BOOL();
 
Spoofing::Init()
{
     *run = TRUE;
     hosts 
     param1, param2
     //declaramos aqui todas las variables de la subrutina, la lista de hosts...
     //y las inicializamos con las funciones static.
     while(*run)
     {
     EscanerRed();
     if(hosts)
          thread spoof(RealizarSpoofing, param1, param2);...
     }
     ...
}
 
Spoofing::Uninit()
{
     *run = FALSE;
}
 
...
 
static void EscanearRed(para1, param2)
{
      if(*run)
          ...
}
static void RealizarSpoofing()
{
      while(*run)
          ...
}
 

Utilizo una variable booleana para detener los subthreads que genera la subrutina. De esta manera controlo la subrutina desde el namespace. Al incluir al main.cpp la cabecera spoofing.h no tiene visibilidad a funciones que no son del namespace, no tiene acceso a datos que no le interesan.

Lo malo que hay que pasar parametros del namespace a las funciones static, ¿sería mejor declarar todas las variables fuera de Init() para así  no tener que estar pasandolas como argumento de una funcion a otra?, como ocurre con el BOOL* que gracias a que esta fuera no es necesario pasarlo entre funciones.

2. Crear una clase con todos los atributos, ponerla un método Init(), Uninit(), Restart(). Un constructor que inicialice a NULL los atributos, y tras instanciar la clase pasar a llamar a Init(), Uninit(), etc. Lo malo de esto sería que esa clase para poderla usar desde fuera habría que pasar su dirección de memoria. Por ejemplo si en el main.cpp la instanciamos y llamamos a Init(), y luego en archivox.cpp queremos llamar a Uninit(), debemos de pasarle la dirección de la clase instanciada.

También puede tener funciones estáticas.

De momento pongo estos 2 que son los que más me han hecho dudar, y sí también se puede poner todo con funciones staticas, pero ya que es C++ vamos a aprovechar los namespaces y las clases.

Agradecería críticas constructivas

¿Cual creéis que es la mejor? ¿y cuál usaríais vosotros?.

Saludos!!.

Suena que estas haciendo una biblioteca de funciones privada, no veo problema en ello solo que me da curiosidad el tema.

Que libreria estas usando internante libnet? libpcap?

Realmente tengo poca expriencia con C++ (Orientado a objetos) se leer y escribir el codigo pero como tu dices no he experimentado el sacarle provecho al namespace.

Creo que C++ y también maneja elementos privados y publicos no?

http://stackoverflow.com/questions/860339/difference-between-private-public-and-protected-inheritance

saludos

Buenas Kaxper ;)

Bienvenido al maravillosos mundo de la OOP (prog. orientada a objetos), dónde mínimo hay que leer sobre patrones de diseño, jerarquía y estructura de clases, herencia multiple, clases abstractas, interfaces, overrides, overload, herencia virtual etc

Si tienes una clase que es única, por ejemplo con métodos estáticos, lo mejor es que implementes el patrón Singleton en la misma, por lo tanto a la hora de utilizar un método de dicha clase tendrías: Clase.GetMiClase().MétodoStatic() y ya habrías convertido dichos métodos estáticos en el paradigma de OOP.

Si quieres desde un Thread llamar a un método de una clase instanciada puedes referenciar un puntero a un miembro de dicha clase y llamarlo desde la rutina del Thread, sin necesidad de aislar la lógica de una clase, por lo tanto queda mejor estructurado.

Separar tu módelo de programación en múltiples clases, sin escribir código, sólo la lógica (funciones/clases/dependencias), te será de gran ayuda a la hora de visualizar como quedará el proyecto, además solucionará los problemas de herencia que puedas llegar a tener, pues lo mejor de programar es tener una vision temprana del proyecto, sino tocará reescribir o morir programando.


Así es, soporta herencia privada, pública, protected y virtual.

Saludos!

Hola a los 2 gracias por las respuestas.


Lo que busco es hacer visible para fuera solo lo que haga falta, si quiero hacer arp spoofing, no quiero que desde fuera tengan acceso a las funciones para hacerlo, sino que simplemente tengan acceso a iniciar, detener, reiniciar. Y por eso solo debe ser visible esa parte, la idea hasta ahora es meterlo en un namespace los métodos accesibles desde fuera, y las funciones que no tienen porque ver en static que desarrollan la subrutina.

Uso winpcap es para windows.

La visibilidad sin clases (donde si se puede poner private, protected, public..), hay que hacerla desde metiendo solo lo justo en los archivos de cabecera que incluiremos donde queramos luego acceder a ese módulo.


Si buen consejo, aunque el proyecto en sí es muy variable en contenido, cada día se me antoja una cosa XD, pero bueno ya están centradas las ideas principales.

En python al llamar una clase te ejecuta su método init() y corre con sus atributos y otros métodos, en c++ ¿como puedo hacer eso?.

...Lo he estado pensando y ya te digo, con singleton una clase puede trabajar como un namespace.
Lo unico que en un namespace no se pueden declarar variables, tienen que ponerse estáticas en su .cpp donde se declaran sus funciones, ambas se pueden hacer.

Saludos!.

Eso viene siendo el constructor. En C++, Java y otros lenguajes, lo haces con un método con el mismo nombre que la clase, sin tipo de retorno. Sobrecargable para los parámetors que quieras, eso sí.

Bueno tiene pinta que eso del Singleton va a dar mucho juego.

Nunca lo había probado no sabía muy bien que función le podía dar cuando lo veía, ahora he buscado unos ejemplos en cpp y tiene pinta de que va a esta bastante entretenido.

Quizás incluso remplace el namespace por una clase Singleton XDD.

class S
{
public:
	static S& getInstance()
	{
		static S    instance;
		return instance;
	}
	void set(int b){a = b;}
	void imprime(){cout <<a; }
private:
	int a;
	S() { a = 22; }
	S(S const&);              // Don't Implement.
	void operator=(S const&); // Don't implement
 
};
 
S::getInstance().imprime();
	S::getInstance().set(6); 
	S::getInstance().imprime();
 

Saludos!!