Analisi della CVE-2022-23093 (FreeBSD Ping Stack Overflow)

Fatto questo possiamo fare una copia del file ping.c e aprirla con un editor avanzato come VSCode che ci aiuterà a capire cosa è utile e cosa no.

Arrivati a questo punto la cosa migliore da fare è partire dalla fine a ritroso verso l'inizio. Nel nostro caso specifico dalla funzione pr_pack() verso il main(). In questo modo siamo sicuri di analizzare esclusivamente il codice strettamente necessario per raggiungere il codice vulnerabile e niente di più.

Per prima cosa, quindi, scorriamo verso la funzione pr_pack() e cancelliamo per il momento tutto ciò che si trova al di sotto del codice vulnerabile e tutto ciò che è al di sopra e che non incide sul flusso di dati o di controllo. Questo significa che l'intera funzione pr_pack() passa da ~300 righe di codice a questo:

static void
pr_pack(char *buf, ssize_t cc, struct sockaddr_in *from, struct timespec *tv)
{
	u_char l;
	struct ip ip;
	int hlen;

	memcpy(&l, buf, sizeof(l));
	hlen = (l & 0x0f) << 2;
	memcpy(&ip, buf, hlen);
}

Questo ci permette di dire che ci è sufficiente che venga invocata la funzione pr_pack() affinché possiamo raggiungere il codice vulnerabile e non dobbiamo preoccuparci di condizioni, modifiche di dati o altre situazioni che possono rendere più complessa l'analisi e l'exploit.

Il passo successivo è individuare tutti i punti nel codice in cui viene invocata la funzione pr_pack(). Una semplice ricerca del nome della funzione è sufficiente, oppure facendo CTRL+click sul nome della funzione su VSCode sarà l'editor stesso a segnalarci tutti i riferimenti alla funzione.

Nel nostro caso specifico la funzione viene invocata una sola volta all'interno della funzione main() alla riga 958 per un totale di ~700 righe di codice da analizzare, quindi già la metà di quelle totali.

int
main(int argc, char *const *argv)
{
   pr_pack((char *)packet, cc, &from, tv);

A questo punto consideriamo che quando useremo ping lanceremo il comando ping -c 1 <target ip> per limitare a 1 il numero di pacchetti ICMP echo-request inviati. Questa informazione ci serve perché ora partiremo dall'inizio della funzione main() e cancelleremo tutto ciò che non è direttamente collegato all'invocazione della funzione pr_pack(); questo significa cancellare tutto il codice che viene utilizzato quando si lancia il comando con altri flag (a parte -c 1), la gestione degli errori (supponiamo di non avere mai errori) e l'utilizzo di tutte quelle variabili che non sono sotto il nostro controllo o che non vengono utilizzate durante l'invocazione della funzione vulnerabile.

Il risultato che proponiamo è il seguente:

int
main(int argc, char *const *argv)
{
	struct sockaddr_in from, sock_in;
	struct timespec last, intvl;
	struct iovec iov;
	struct msghdr msg;
	char *ep, *source, *target, *payload;
	struct sockaddr_in *to;
	u_long alarmtimeout;
	long ltmp;
	int almost_done, ch, df, hold, i, icmp_len, mib[4], preload;
	int ssend_errno, srecv_errno, tos, ttl;
	char ctrl[CMSG_SPACE(sizeof(struct timespec))];

	payload = source = NULL;

	cap_rights_t rights;
	bool cansandbox;

	options |= F_NUMERIC;

	ssend = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
	srecv = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);

	alarmtimeout = df = preload = tos = 0;

	outpack = outpackhdr + sizeof(struct ip);
	while ((ch = getopt(argc, argv, "Aac:DdfG:g:h:I:i:Ll:M:m:nop:QqRrS:s:T:t:vW:z:")) != -1)
	{
		switch(ch) {
		case 'c':
			ltmp = strtol(optarg, &ep, 0);
			npackets = ltmp;
			break;
		}
	}

	target = argv[optind];

	icmp_len = sizeof(struct ip) + ICMP_MINLEN + phdr_len;

	send_len = icmp_len + datalen;
	datap = &outpack[ICMP_MINLEN + phdr_len + TIMEVAL_LEN];
	
	bzero(&whereto, sizeof(whereto));
	to = &whereto;
	to->sin_family = AF_INET;
	to->sin_len = sizeof *to;
	if (inet_aton(target, &to->sin_addr) != 0) {
		hostname = target;
	}

	/* From now on we will use only reverse DNS lookups. */
	if (connect(ssend, (struct sockaddr *)&whereto, sizeof(whereto)) != 0)
		err(1, "connect");

	if (!(options & F_PINGFILLED))
		for (i = TIMEVAL_LEN; i < datalen; ++i)
			*datap++ = i;

	ident = getpid() & 0xFFFF;

	hold = 1;

	if (options & F_NUMERIC)
		cansandbox = true;

	hold = IP_MAXPACKET + 128;
	(void)setsockopt(srecv, SOL_SOCKET, SO_RCVBUF, (char *)&hold, sizeof(hold));

	if (uid == 0)
		(void)setsockopt(ssend, SOL_SOCKET, SO_SNDBUF, (char *)&hold, sizeof(hold));

	if (to->sin_family == AF_INET) {
		(void)printf("PING %s (%s)", hostname, inet_ntoa(to->sin_addr));
		(void)printf(": %d data bytes\n", datalen);

	}

	bzero(&msg, sizeof(msg));
	msg.msg_name = (caddr_t)&from;
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
#ifdef SO_TIMESTAMP
	msg.msg_control = (caddr_t)ctrl;
	msg.msg_controllen = sizeof(ctrl);
#endif
	iov.iov_base = packet;
	iov.iov_len = IP_MAXPACKET;

	if (preload == 0)
		pinger();		/* send the first ping */

	(void)clock_gettime(CLOCK_MONOTONIC, &last);

	intvl.tv_sec = interval / 1000;
	intvl.tv_nsec = interval % 1000 * 1000000;

	almost_done = 0;
	while (!finish_up) {
		struct timespec now, timeout;
		fd_set rfds;
		int n;
		ssize_t cc;

		FD_ZERO(&rfds);
		FD_SET(srecv, &rfds);

		(void)clock_gettime(CLOCK_MONOTONIC, &now);
		timespecadd(&last, &intvl, &timeout);
		timespecsub(&timeout, &now, &timeout);
		if (timeout.tv_sec < 0)
			timespecclear(&timeout);
		
		n = pselect(srecv + 1, &rfds, NULL, NULL, &timeout, NULL);

		if (n == 1) {
			struct timespec *tv = NULL;

			msg.msg_namelen = sizeof(from);
			cc = recvmsg(srecv, &msg, 0);

			if (tv == NULL) {
				(void)clock_gettime(CLOCK_MONOTONIC, &now);
				tv = &now;
			}

			pr_pack((char *)packet, cc, &from, tv);
			
		}
	}
}

Un totale di poco più di 100 righe di codice a fronte delle più di 1500 iniziali!

Come filtro per la cattura si può utilizzare semplicemente icmp.

Diamo di nuovo un'occhiata al codice vulnerabile che si trova all'inizio della funzione pr_pack() per capire a pieno la CVE-2022-23093:

/*
 * Get size of IP header of the received packet. The
 * information is contained in the lower four bits of the
 * first byte.
 */
memcpy(&l, buf, sizeof(l));
hlen = (l & 0x0f) << 2;
memcpy(&ip, buf, hlen);

La vulnerabilità risiede nel fatto che hlen (la lunghezza dell'header IP) viene calcolata a partire da un input utente, cioè a partire dai 4 bit meno significativi del primo byte. Normalmente il primo byte dell'header IP è sempre 0x45 (il carattere "E" in ASCII). Questo corrisponde a:

• IP versione 4 (0x40)
• 0x5 rappresenta la lunghezza in byte dell'header IP, calcolata come 0x5 << 2 = 5 * 2² = 20.