Apache web server zero-day bug is easy to exploit – patch now!


The venerable Apache web server has just been updated to fix a dangerous remote code execution (RCE) bug.

This bug is already both widely-known and trivial to exploit, with examples now circulating freely on Twitter, and a single, innocent-looking web request aimed at your server could be enough for an attacker to take it over completely.

Estimates of Apache’s prevalence vary, but a good guess is that somewhere between a quarter and a third of internet-facing HTTP services will end up getting handled by an instance of Apache.

Remember that even if you don’t run your organisation’s public-facing web servers on Apache (perhaps you use the popular nginx product on Unix, or Microsoft IIS on Windows), you may nevertheless have Apache running somewhere on your network.

Indeed, any software product you use that has its own HTTP interface, such as a document management system or a support ticketing system, might, for all you know, be using Apache as its built-in web server.

You should therefore review your network not just for traditional web servers that are intended to be reached by visitors from outside, but also for HTTP servers inside the network that cybercriminals such as ransomware gangs could use to extend or expand an attack that is already underway.

Intriguingly, given the nature of the bug, this flaw, dubbed CVE-2021-41773, was introduced less than a month ago, in Apache 2.4.49.

Ironically, this means that Apache users who were sloppy about updating last time, and are still back on 2.4.48 or earlier, will skip past this vulnerability altogether.

To patch against the bug, upgrade immediately to Apache 2.4.50.

Path traversal explained

When we first heard about CVE-2021-41773, documented as a “path traversal and file disclosure vulnerability”, we assumed that the flaw had been lying around unnoticed in the Apache code for years.

That’s because path traversal bugs are very last-century, and many path-validation flaws that show up in contemporary code turn out to be programming artefacts left over from a less careful age.

Simply put, a path traversal bug happens when a user tries to access a file on the server that ought to be considered off-limits, but the security check on the location of the file fails.

This programming mistake often happens because there are many different ways of referring to the same file, and you have to take all of them into account.

For example, let’s assume that you are currently sitting in a directory called /home/duck (the equivalent of C:Usersduck on Windows), where you have placed a file called findme.txt.

Canonically, which is the jargon term for “the one true way to do it”, you’d refer to this file as:


If you wanted to make certain that this file really was located in the /home/duck directory, the obvious programmatic way to do it would simply be to check that the full filename starts with /home/duck/, for example like this:

But this isn’t good enough, because all major filing systems on all major operating systems allow you to have filenames that “jump around” inside the directory tree, for example like this:


In directory names, dot-dot is shorthand for “go up a directory”, so that in the first filename above, subdir1/subdir2/ descends two levels deeper into the directory tree, while the ../../ that follows goes back up again by two levels.

In other words, every instance ../ in a filename essentially cancels out the directory name that immediately precedes it in the path.

Our simplistic isfilewithinpath() functio would conclude that the files findme.txt and passwd above were both safely contained underneath the “root path” of /home/duck/, because both paths start with exactly that text string.

But only the first file is actually under /home/duck/, because those names simplify to…


…which in turn simplify, or canonicalise, to:


Hmmm. One of them is our very own findme.txt file, safely stashed in our own directory tree, while the other is the central Unix/Linux password file from the system directory /etc.

(On modern systems, the passwd file is a bit of a misnomer: it does contain usernames, but for security reasons hasn’t contained passwords or even password hashes for many decades, just in case you were wondering.)

Indeed, you can even use dot-dot as a sort of escape-completely-from-anywhere mechanism, because when you reach the root directory of the system itself, typically / on Unix or C: on Windows, every subsequent dot-dot gets ignored, like this:

/home/duck/findme.txt                --> /home/duck/findme.txt
/home/duck/../findme.txt             --> /home/findme.txt
/home/duck/../../findme.txt          --> /findme.txt
/home/duck/../../../../findme.txt    --> /findme.txt   <-- we've hit the ceiling and now we simply stay there (no errors)
/home/duck/../../../../../findme.txt --> /findme.txt

In other words, you don’t have to know your exact place in the directory hierarchy to escape to any other specific subdirectory, as long as you put plenty of dot-dot-slash entries in the filename.

In particular, you won’t cause an error if you accidentally have more dot-dots than are strictly necessary.

Try the command below on a Windows computer from almost anywhere on the C: drive, and you will print out the HOSTS file (a list of IP number overrides for specific server names, often used by legitimate users to block annoying ad networks, and by malware to block useful cybersecurity websites).

Note that this filename is an innocent-looking relative filename (because it doesn’t explicitly denote a hard-wired path that it wants to use), but thanks to the dot-dot-slash trickery, it effectively acts as an absolute pathname.

The dot-dots launch you upwards until you reach C:, where you just bounce repeatedly off the ceiling and stay in C: until the path starts descending again to to the desired finishing point:

-- I went three levels down in my own home directory:

C:Usersducktestsubdir1subdir2> type ....................WindowsSystem32driversetchosts

-- But even using a non-absolute path I traversed to the Windows directory:

# Copyright (c) 1993-2009 Microsoft Corp.
# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.
[. . .]
# For example:
#     rhino.acme.com          # source server
#     x.acme.com              # x client host

# localhost name resolution is handled within DNS itself.
#       localhost
#       ::1             localhost

All security conscious software, especially including web servers, needs to be on the lookout for this sort of trickery.

Path traversal treachery can allow attackers to specify filenames that look as though they’re in a harmless location, and thus to read them, or perhaps even to write or execute them, when they aren’t supposed to see them at all.

If we wanted to look out for dot-dot treachery in a URL, we would need to look out for double-dots and react accordingly, for example like this:

But this is not a strict enough test for a web server, because URLs that include file and path names can be encoded using what are known as URL escape sequences.

URL escapes represent ASCII characters that would otherwise be illegal in URLs by converting them into a percent sign followed by two hexadecimal digits to represent the ASCII code.

You can’t have spaces in a URL, for example, so if you want to use a filename or directory name that includes a space as part of a URL, you have to transmit it as %20, short for “replace this with ASCII hex code 0x20” (decimal 32), which denotes a space character.

And even if a character in a URL doesn’t need escaping, you can generally escape it anyway in your web request, and the server at the other end will decode it and use it correctly, as you will find if you try either or both of these commands:

   $ curl -D - https://nakedsescurity.sophos.com/podcast/
   $ curl -D - https://nakedsecurity.sophos.com/%70%6F%64%63%61%73%74/

The URL path in the second command above is just the word podcast converted into ASCII numbers, converted into hexadecimal, and then separated with percent markers.

So, to detect the appearance of the dot-dot sequence in a URL path, you really need to look for any or all of the following different ways of encoding it:

   .   .    <-- both dots can be represented literally as themselves

   %2E .    <-- or the first dot alone can be escaped
   %2e .    <-- and note that URL escapes can use upper or lower case hex digits

   .   %2E  <-- or the second dot alone can be escaped
   .   %2e   

   %2E %2E  <-- or they can both be escaped
   %2e %2E
   %2e %2E
   %2e %2e

The CVE-2021-41733 bug introduced in Apache 2.4.49 was new code added to normalise, or canonicalise, URL paths to remove inconsistent, unnecessary or dangerous parts of the pathname…

..but (as far as we can see) the code only correctly detected the first three cases above, where either both dots were sent unescaped, or only the first dot was escaped.

By encoding the second dot as %2E, you could bypass the dot-dot check and thus exploit this aptly-named path traversal vulnerability.

Initial reports correctly implied that this bug was exploitable for reading files that were off-limits, including accessing files outside the web server’s own directory tree, as well as downloading script and other source code files inside the server tree that were not supposed to be directly accessible to website visitors.

That’s bad enough, but it turns out that by asking for a rogue file, for example by trying to access the system’s shell interpreter, and at the same time supplying a rogue HTTP header in your request, you may be able not only to execute arbitrary programs on the server, but also to pass arbitrary parameters (command line options) to those programs.

When you have remote, unauthenticated access to a command shell like bash, and you can send it any commands you like via a simple HTTP request, you pretty much have a generic server “backdoor”, and you have pwned the system completely.

The bug has been fixed somewhat clumsily by checking explicitly for a dot-dot sequence in which the first character already appears as a dot, either because it was sent literally or has already been converted, while the second character may appear as a literal dot or as a %2E sequence that has not yet been unescaped.

What to do?

  • If you have Apache 2.4.49, you need to update right away to Apache 2.4.50 if you haven’t already. This bug is widely-known and sample code to abuse it is widely available online.
  • If you have older version of Apache, you aren’t affected by this bug. Ironically, perhaps, if you were slow to update last time (2.4.49 came out on 15 September 2021) then your sluggishness has protected you this time.
  • Don’t just patch this hole on internet-facing web servers. Do the publicly exposed ones first, because that’s where your immediate danger lies. But expect cybercrooks to adopt this exploit as a “lateral movement” trick once they already have a beachhead inside a network, because it’s so easy to abuse.
  • If in doubt whether any of the web-enabled software you use includes Apache, ask your vendor. If you have network scanning tools such as Nmap available, you can probe for HTTP or HTTPS servers on your own network and check their reply headers, which often reveal the server code in use, notably in the Server: header.


If you know the server name (or IP number) and port number of HTTP or HTTPS services on your network, you can look at the headers that come back when you send a basic web request to it, as you see here:

$ curl --http-1.1 --head https://nakedsecurity.sophos.com/
HTTP/1.1 200 OK
Server: nginx                   <-- We're using Nginx
Date: Wed, 06 Oct 2021 17:19:46 GMT
Content-Type: text/html; charset=UTF-8
[. . . ]

$  curl --http1.1 --head https://www.apache.org
HTTP/1.1 200 OK
Connection: keep-alive
Content-Length: 73991
Server: Apache                  <-- As you would expect!
[. . .]

$ curl --http1.1 --head
HTTP/1.1 501 Not implmemented
Server: Lua-TLS-Generic         <-- Local test server I use for articles
Connection: close
Content-Type: text/plain
[. . .]

Some results may be inconclusive because they don’t return a Server: header, like the excellent, free Fossil source code management tool that we use for our sample code.

This product has a web server that doesn’t use Apache, but doesn’t have a server tag of its own:

$ fossil ui
Listening for HTTP requests on TCP port 8080
[. . .]

$ curl --http1.1 --head
HTTP/1.0 302 Moved Temporarily
Date: Wed, 6 Oct 2021 17:23:52 +0000
Connection: close
X-Frame-Options: SAMEORIGIN
[. . .]

Likewise, some servers may deliberately choose to identify themselves as something other than they really are, either as a decoy to mislead naive network scanners that routinely hurl unwanted exploit “tests” at them, or for compatibility reasons with client apps that expect a specific vendor’s product at the other end.

Products You May Like

Articles You May Like

5 common Ticketmaster scams: How fraudsters steal the show
Smishing Triad Targets India with Fraud Surge
AT&T Confirms Data Breach Affecting Nearly All Wireless Customers
Hackers Downloaded Call Logs from Cloud Platform in AT&T Breach
Cyber-Attack on Evolve Bank Exposed Data of 7.6 Million Customers

Leave a Reply

Your email address will not be published. Required fields are marked *