Foro de elhacker.net

Resulta que al hacer sizeof(mac), obtengo 4 bytes, cuando una mac tiene 6 bytes, uno para cada u_char si no me equivoco.

u_char *mac_gateway = new u_char[6]();
 
		u_long num_gateway = inet_addr(adaptador->GatewayList.IpAddress.String);
 
 
		if (num_gateway == INADDR_NONE){
			Sleep(REINTENTAR_MITM * 1000);
			continue;
		}
 
		if (!enviar_arp(adaptador->GatewayList.IpAddress.String,
			adaptador->IpAddressList.IpAddress.String, mac_gateway)){
			Sleep(REINTENTAR_MITM/2 * 1000);
			continue;
		}
 
		for (int i = 0; i < 6; i++)
			printf("%d=%x ", i,mac_gateway[i]); 
 
		system("pause");
 
		for (int i = 0; i < 4; i++)
			printf("%d=%x ", i, ip_gateway[i]);
		system("pause");
		cout << sizeof(mac_gateway) << sizeof(mac_atacante);

Me salen que todas las macs tienen 4 bytes WTF, la ip son 4 bytes, pero las macs no se supone que tienen 6?.

Me he quedado un poco loco con esto. Haber si sabéis algo.

Gracias, un saludo.

Edito: Que broma es esta:

u_char *mac = new u_char[500]();
cout << sizeof(mac);

¿Estás en un pc de 32 bits?

No, es de 64 bits

mac no es un array de 500 elementos. mac es un puntero. Un puntero que apunta a un array de 500 elementos.
Los punteros tienen un tamaño generalmente de 4 bytes.

Ahh vale, estaba cambiandolo por variables estaticas u_char[6] etc, pero no creo que sea buena idea, ¿como puedo hacer para que me diga el tamaño de lo que apunta el puntero? XP porque con sizeof(*mac) me sale uno el primer elemento, pero para que me diga el tamaño de todos como se puede hacer?.

Gracias como siempre, un saludo.

Edito: Parece que no se puede, hay que hacer una variable estatica y pasar su dirección al puntero, luego ¿la unica solucion es multiplicar por 2 las variables declaradas?.

porque ahora habra:

 u_char mac[6]; u_char *pmac; pmac = &(mac[0]); ...

Y me parece una caca tremenda XD.

Bueno parece que sustituyendo los punteros por esto:

&(mac_gateway[0])

Se soluciona parcialmente el problema, pero esto no lo consigo solucionar:

&(ip_atacante[0]) = (u_char*)&num_atacante;

ERROR: La expresion debe tener valor L modificable.

Solución:

memcpy(&(ip_atacante[0]), (u_char*)&num_atacante, sizeof(u_char)* 4);
		memcpy(&(ip_gateway[0]), (u_char*)&num_gateway, sizeof(u_char)* 4);
		memcpy(&(mac_atacante[0]), (u_char*)adaptador->Address, sizeof(u_char)* 6);

Así funciona, ¿os parece  buena idea? O es mala calidad de código?

Tal como dice, la parte L (left) de la expresión (L = R), debe ser modificable. La dirección de una variable no es modificable, es solo un número.


Puedes hacer eso con memoria dinámica. ¿Para qué necesitas saber su tamaño? ¿No es siempre 6?
Y en caso de que por lo que fuera cambiase, ¿no puedes crear una variable y guardarle un 6?

La idea de conocer el tamaño de bytes de la variable es para detectar posibles errores al pasar la mac, por ejemplo si llegan 4 bytes solo, pues que detecte error apartir del tamaño, pues deberían llegar 6.

Pero con un puntero parece que no se puede por si mismo, por ello es mejor haciendo u_char mac[6]; y pasar &(ip_gateway[0]) como puntero ¿no?

Saludos.

Quiero saber los bytes que tiene cada u_char*, supongo que no podré utilizar entonces u_char* mac= new...

Vamos a ver. No hay manera de que te envíen "solo 4 bytes" y que lo puedas detectar, salvo que la función te especifique la cantidad de bytes.

Una de 2, o te llegan 6 bytes, o no te llegan. No necesitas saber el tamaño.

Necesito declararlo en la HEAP, por lo tanto lo dejaré como lo tenía al principio.

Y ¿como sé si me llegan los bytes o no me llegan?, me refiero me pasan un puntero que apunta a 2 u_char, y lo copio en un puntero de mac, no daría error, pero la mac solo tendría 2 caracteres válidos.

u_char *mac1 = u_char[6]();
u_char * mac2 = u_char[6]();
 
mac1[0] = 0x12; mac 1[1] = 0xc3;
 
mac2 = mac1; // ¿Como detecto que no tiene 6 bytes válidos
//¿tengo que crear una función que lo calcule? o hay alguna funcion que lo haga o algo?
 
 

La idea es que no de lugar a problemas como el que puse, por ejemplo al añadir una victima (ip y mac) a la lista de hosts):

u_char* lista_victimas::obtener_ip(u_char* mac)
{
	if (sizeof(mac) != sizeof(u_char)* 6)
		return NULL;

Quizaaas:

u_char* lista_victimas::obtener_ip(u_char* mac)
{
	if (strlen((char*)mac) != sizeof(u_char)* 6)
		return NULL;

Aunque así da desde la posicion del puntero que pasamos hasta el final de este. Si es mayor no hay problema, si es menor que 6 la mac que obtendremos será erronea.

¿Por qué te iban a pasar un puntero que apunta a 2 elementos? O te pasan una mac, o no te la pasan. Si la función no te pasa 6 elementos, y no te marca ningun tipo de error, entonces la función no es correcta.

Si le pasas un valor incorrecto a la función, no es culpa de la función, sino de pasarle el valor incorrecto. No hay forma lógica de saber cuantos bytes son correctos y cuantos no. Cada error, lo tienes que tener en cuenta en su momento. No puedes andar acarreándolo hasta ese momento.

Entiendo lo que dices, pero una capa extra adicional no creo que venga mal, pues aunque no falla al pasar los datos a la función si se altera el entorno puede fallar el valor pasado y lo copiaría como mac algo que no sería una mac y todo fallaría y sería muy cantoso, antes de guardar una víctima tengo que asegurarme bien de que al menos los datos tienen las dimensiones esperadas (siempre y cuando no generemos errores al tratarlo de remediar).

Cuando incluyo una victima a la lista (ip,mac):

void lista_victimas::añadir_victima(victima v)
{
	if (strlen((char*)v.ip) >= sizeof(u_char)* 4 &&
		strlen((char*)v.mac) >= sizeof(u_char)* 6)
		victimas.push_back(v);
}

Así aseguro las dimensiones, una capa de seguridad adicional.

Y si se altera el entorno, podría cambiar solo el mac, y dejar un mac sin sentido.
Si se altera el entorno, las funciones podrían fallar.

La mac SIEMPRE va a tener 6 elementos, SALVO que tú le hayas puesto algo erroneo. Si ese no es el caso, entonces tendrá 6 elementos.

Otra cosa, es que quieras usar una clase o estructura.