F5 Big IP TMM uri_normalize_host Information Disclosure / Out-Of-Bounds Write

`F5 Big IP - TMM uri_normalize_host infoleak and out-of-bounds write  
  
Big IP's Traffic Management Microkernels (TMM) URI normalization incorrectly handles invalid IPv6 hostnames:  
  
When uri_normalize_host is called with a hostname of the form \u"[abcdef]\u", uri_norm_inet6 is called  
with the substring abcdef as an argument. Pseudo code of this function is shown below:  
  
int uri_norm_inet6(char *inbuf, int64_t inlen, char *outbuf, _DWORD *outlen) {  
struct in6_addr s; unsigned int ret;  
  
ret = uri_inet6_pton(inbuf, inlen, &s); if ( !ret ) {  
if ( inet_ntop(AF_INET6, &s, outbuf, 46u) ) *outlen = strlen(outbuf);  
else ret = 3;  
} return ret;  
}  
  
The s hostname is first passed to uri_inet6_pton, which is responsible for parsing a text IPv6  
address and initializing the network address structure s. If the function doesn't return an error,  
inet_ntop is called to turn s back into a printable (and normalized) string.  
  
The bug is that uri_inet6_pton incorrectly handles short hostnames. When a single hex character is  
passed to the function, it will only initialize the first two bytes of the in6_addr structure  
without returning an error. This means inet_ntop will now happily convert uninitialized stack memory  
into a printable IPv6 hostname.  
  
While this could already be a security vulnerability if the normalized hostname becomes visible to  
the attacker, it also breaks one of the core assumptions of callers of uri_normalize: Under normal  
circumstances, a normalized URL should never be longer than 3*input_length + 2 (this handles the  
worst case scenario of URL encoding every character in the URL + adding slashes). This means callers  
can just allocate an outbuf buffer with this size and the URI normalization functions do not have to  
perform any length checks.  
  
However, due to the described bug, the size invariant does not hold anymore leading to a  
straightforward out-of-bound write.  
  
TMM's URI normalization is used in a number of places. Luckily most of them do not perform  
normalization on the hostname allowing them to avoid this bug.  
  
However, there are a couple of configurations that can expose this bug to an attacker. (This list is  
based on static analysis as I don't have a test environment where I can verify all variants) iRules  
or BIG-IP LTM policies that use the \"normalize URI\" config option URL categorization as part of APM,  
SWG or PEM Risk Classification  
  
Proof of Concept:   
  
For a server configured with the following iRule:   
when HTTP_REQUEST {   
log local0. \"normalized: [HTTP::uri -normalized]\"   
log local0. \"uri: [HTTP::uri]\" }  
  
Send a request like this: echo -e \"GET h://[f] HTTP/1.1\\  
\\  
\" | ncat --ssl 10.154.0.3 443  
  
This will log uninitialized memory to /var/log/ltm on the F5 host:   
Dec 10 09:41:32 f5-16-vm info tmm[26669]: Rule /Common/normalized <HTTP_REQUEST>: normalized: h://[aa:cf01::c00:0:1100:0]/   
Dec 10 09:41:32 f5-16-vm info tmm[26669]: Rule /Common/normalized <HTTP_REQUEST>: uri: h://[aa]  
  
For debug TMM's using `wrapped_umem_alloc` for heap allocations, it will also lead to a direct  
crash of the TMM due to the heap buffer overflow.  
  
This bug is subject to a 90 day disclosure deadline. After 90 days elapse,  
the bug report will become visible to the public. The scheduled disclosure  
date is 2021-03-10. Disclosure at an earlier date is also possible if  
agreed upon by all parties.  
  
Credit Information:   
  
Felix Wilhelm of Google Project Zero  
  
Related CVE Numbers: CVE-2021-22991.  
  
  
  
Found by: [email protected]  
  
`