Wanneer 'vaardigheden' de toeleveringsketen worden: de malware op de OpenClaw-marktplaats is een wake-up call.

/Algemeen/ Door

De afgelopen jaren is 'AI-agent' niet langer een marketingterm, maar een concrete workflow geworden: een assistent die je bestanden kan lezen, je browser kan openen, commando's kan uitvoeren en acties tussen verschillende services kan coördineren. Dat is de belofte.

Het probleem is datStroom heeft een distributiekanaal.En dat kanaal wordt steeds vaker een genoemd.vaardigheid: een klein, deelbaar 'handleidingpakket' dat een agent (en vaak ook de gebruiker) leert hoe een taak uit te voeren. Het is het app store-moment voor agents — alleen zijn de 'apps' vaakMarkdown-instructies.

De berichten van deze week over kwaadaardige OpenClaw-vaardigheden zijn een vroeg en zeer luid signaal dat we op het punt staan ​​de geschiedenis van de open-source toeleveringsketen te herhalen – maar met een twist: in plaats van een gecompileerde afhankelijkheid te vergiftigen, kunnen aanvallers een andere afhankelijkheid vergiftigen.documentatieen gebruik de behulpzaamheid van het middel als smeermiddel.

Hieronder volgt een praktische uitleg van wat er is gebeurd, waarom het zo goed werkt en wat u eraan kunt doen.

Wat OpenClaw-vaardigheden zijn (en waarom ze belangrijk zijn)

OpenClaw populariseerde een eenvoudig uitbreidingsmodel: voeg een 'vaardigheid' toe die uitlegt hoe een specifieke taak moet worden uitgevoerd — een bericht plaatsen op sociale media, mappen opschonen, een rapport samenvatten, een workflow automatiseren — en de agent krijgt een nieuwe mogelijkheid.

Binnen het bredere ecosysteem van 'agentvaardigheden' is een vaardigheid doorgaans een map die is opgebouwd rondom eenSKILL.mdbestand. Dat bestand bevat:

  • Metadata(naam / omschrijving)
  • Instructies(de eigenlijke stappen)
  • Optioneel:scriptsen andere gebundelde activa

Dat klinkt onschuldig omdat het op documentatie lijkt. Maar documentatie is nu juist wat mensen snel volgen, vooral als het eruitziet als een lijst met vereisten of een installatiehandleiding.

Ook bij vaardigheden is er sprake van een "de winnaar krijgt alles"-dynamiek: mensen worden aangetrokken tot wat populair is, wat nieuw is en wat tijd lijkt te besparen. Dat maakt een openbare marktplaats voor vaardigheden een zeer waardevol doelwit: als je een paar van de meest gedownloade items opoffert, kun je een geconcentreerde groep ervaren gebruikers bereiken – ontwikkelaars, beheerders en iedereen die waardevolle certificaten op zijn of haar computer heeft staan.

De kern van de truc: Markdown is niet langer "content", maar een installatieprogramma.

Traditionele aanvallen op de softwareleveringsketen vereisen vaak technische investeringen: verwarring over afhankelijkheden, typosquatting, kwaadaardige scripts na installatie, controle over een pakketnaam behouden en scanners omzeilen.

Een vaardighedenmarktplaats verlaagt de drempel.

Een kwaadaardige vaardigheid kan zoiets simpels doen als dit:

  1. Geef een plausibel hulpmiddel weer ("Twitter-skill", "cryptotracker", "automatiseringshulpmiddel").
  2. Voeg een sectie 'Vereisten' toe met een 'vereiste afhankelijkheid'.
  3. Geef een handige link en een korte opdrachtregel.
  4. Vertrouw erop dat de mens (of de agent) het uitvoert.

Dat is geen nieuw idee op het gebied van social engineering — het wordt al jaren gebruikt — maar agentworkflowsversterkenHet:

  • Agenten vatten de documentatie vol zelfvertrouwen samen ("Voer dit gewoon uit om de afhankelijkheid te installeren").
  • Agenten verminderen de frictie door de opdracht voor u te genereren.
  • In sommige configuraties kunnen agents zelf shell-opdrachten uitvoeren.

Op dat moment wordt "documentatie" een pad voor uitvoering op afstand.

Wat er volgens de rapporten is gebeurd in het OpenClaw-ecosysteem.

Diverse artikelen beschrijven een campagne waarbij aanvallers grote aantallen kwaadaardige skills uploadden naar de ClawHub-marktplaats en "installatiestappen" gebruikten om malware te verspreiden die gegevens steelt.

Volgens Jason Meller van 1Password bevatte een van de meest gedownloade skills instructies die gebruikers door een gefaseerde leveringsketen leidden: een link naar een 'afhankelijkheid', een versleuteld commando en vervolgens een payload die uiteindelijk een infostealer installeerde die ontworpen was om de computer te plunderen voor waardevolle geheimen.

CyberInsider beschrijft, op basis van onderzoek van Koi Security, een vergelijkbaar patroon op grote schaal: getrojaniseerde skills met "Voorwaarden" die gebruikers instrueren om versleutelde shellscripts uit te voeren of met een wachtwoord beveiligde archieven te downloaden, met als hoogtepunt payloads zoals Atomic macOS Stealer (AMOS) – een malwarefamilie die geassocieerd wordt met het stelen van inloggegevens en het aanvallen van wallets.

Of de exacte aantallen verschillen tussen de rapporten, devormis consistent:

  • Vaardigheden die als distributie worden ingezet
  • "Voorwaardelijke" instructies gebruikt als overtuigingsmiddel
  • Informatiedieven gebruikt als einddoel

Dat einddoel is belangrijk: moderne datadieven zijn niet uit op één wachtwoord, maar op een heel wachtwoord.sessietokens,browserprofielen,SSH-sleutels,cloud-referenties, EncryptowalletsMet andere woorden: de elementen die ervoor zorgen dat één gehackte laptop een grotere inbreuk vormt.

Als je ooit hebt gedacht: "Daar zou ik niet intrappen," dan heb je waarschijnlijk gelijk als je kalm en sceptisch blijft.

Maar de workflows van agenten veranderen de context:

  • Snelheid wordt de standaard.Je maakt gebruik van een agent omdat je snel wilt handelen.
  • De cognitieve belasting wordt uitbesteed.De agent transformeert een rommelige instructiepagina in een overzichtelijke checklist.
  • De autoriteit is geleend.Als de agent zegt: "Dit is de standaardafhankelijkheid", dan voelt het alsof het gecontroleerd is.

Met andere woorden: de agent hoeft niet in technische zin "misleid" te worden. Hij hoeft alleen maar aanwezig te zijn op het moment dat je wordt aangespoord iets risicovols te doen. Dat is genoeg om gedrag te beïnvloeden.

En als jeDoenAls de agent rechtstreeks commando's mag uitvoeren, kan een kwaadaardige vaardigheid "handsfree compromittering" mogelijk maken.

'Maar hoe zit het dan met MCP? Is het niet de bedoeling dat gereedschap daardoor veiliger wordt?'

Het Model Context Protocol (MCP) is een echte stap voorwaarts in de structurering van de toegang tot tools. Het standaardiseert hoe hosts tools, resources en prompts beschikbaar stellen en legt de nadruk op toestemming en controle van de gebruiker.

MCP maakt vaardigheden echter niet op magische wijze veilig.

Waarom?

  • Vaardigheden kunnen gebruikers instrueren om commando's buiten de MCP-grens uit te voeren.
  • Vaardigheden kunnen verwijzen naar scripts of downloads die MCP nooit aanraken.
  • Niet elke vaardigheid maakt gebruik van MCP.

MCP kan helpen wanneer de host sterke toegangsrechten, duidelijke toestemmingsprompts, logging en veilige standaardinstellingen implementeert. Maar een op Markdown gebaseerd distributiemechanisme kan dit nog steeds omzeilen door middel van ouderwetse social engineering.

Dit is de agentversie van beveiliging in de toeleveringsketen (en we hebben dit al eerder meegemaakt).

De softwarewereld heeft op de harde manier geleerd dat:

  • Populaire registers worden misbruikt.
  • Typosquatting werkt.
  • "Installeer deze helper" is een veelgebruikt startpunt.
  • De meest waardevolle slachtoffers zijn degenen die dingen bouwen.

Vaardigheidsplatformen combineren die lessen met twee nieuwe versnellers:

  1. Het "pakket" kan instructies zijn.Instructies zijn lastiger betrouwbaar te scannen, niet de code zelf.
  2. De runtime-omgeving is rijk aan inloggegevens.Door het ontwerp: browsers die overal zijn ingelogd, terminals met SSH-sleutels, cloud-CLI's, wachtwoordmanagers en lokale bestanden.

In zekere zin is een marktplaats voor vaardigheden een appwinkel waar de beste apps de mogelijkheid krijgen om te zeggen: "Kopieer en plak dit in Terminal om de functie in te schakelen." Dat probleem is niet op te lossen met één enkel selectievakje.

Praktische verdedigingsmechanismen (voor normale gebruikers)

Als je experimenteert met een agent die lokale toegang heeft, moet je deze behandelen als een nieuwe gebruiker van het besturingssysteem met superkrachten.

Dit is het pragmatische uitgangspunt:

  1. Gebruik een aparte machine of virtuele machine.Voor agent-experimenten. Geen opgeslagen bedrijfslogins. Geen SSH-sleutels voor productieomgevingen. Geen cloud-beheersessies.
  2. Bij installatieprogramma's van één regel code staat standaard 'nee'.Vooral alles wat de gegevens via een pipe naar `sh` doorstuurt, base64 gebruikt of je vraagt ​​om besturingssysteembeveiligingen te verwijderen.
  3. Vertrouw niet op de meest gedownloade items.Populariteit is een groeistrategie, geen veiligheidsmodel.
  4. Als je iets al hebt uitgevoerd, draai dan eerst de belangrijkste onderdelen door.Browsersessies, SSH-sleutels, API-tokens, cloud-sleutels.
  5. Voorkeur gaat uit naar vaardigheden die brongecontroleerd en beoordeelbaar zijn.(Git-repositories met geschiedenis, bekende beheerders en duidelijke herkomst).

Wat marktplaatsen moeten doen (om te overleven)

Als je een openbaar register van vaardigheden beheert, creëer je een potentieel aanvalsoppervlak.

Enkele praktische stappen die de kosten voor een aanvaller aanzienlijk verhogen:

  • Reputatie en herkomst van de uitgever(geverifieerde identiteiten, geschiedenis, handtekening).
  • Geautomatiseerd scannenop verdachte patronen (gecodeerde payloads, verhulde one-liners, verwijdering uit quarantaine, met wachtwoord beveiligde archieven, "installeer kernafhankelijkheid" met externe links).
  • Waarschuwing: wrijving in de gebruikersinterfacevoor externe links en shell-opdrachten.
  • Snelle uitschakeling en zichtbare incidentrespons(Behandel het als een app store, niet als een pastebin).

Geen van deze oplossingen is perfect, maar ze geven je tijd – en tijd is wat verdedigers nodig hebben.

Wat moeten makelaars in de toekomst aannemen?

Als je de agent-runtime zelf bouwt, ga er dan vanuit dat vaardigheden als wapens zullen worden ingezet.

Dat betekent:

  • Standaard weiger ik de uitvoering van het commando(Vereist toestemming per commando, geen eenmalige schakelaars).
  • Sterke zandbaktechniekvoor toegang tot het bestandssysteem en de browser.
  • Beperkte, tijdsgebonden machtigingenmet eenvoudige herroeping.
  • Controleerbare logboekenvan wat de agent las en wat hij uitvoerde.

Het eindresultaat is dezelfde richting die de cloud jaren geleden al insloeg: identiteit, beleid, minimale bevoegdheden en audit trails – maar dan teruggebracht tot het niveau van het werkstation.

Kortom

Het verhaal achter de OpenClaw-vaardigheden gaat niet alleen over "een paar mensen die malware hebben geüpload". Het is een voorproefje van het volgende strijdveld in de toeleveringsketen:Vaardigheden als distributiemiddel, Markdown als uitvoeringsmethode en agents als versneller.

Als agents op onze persoonlijke en zakelijke computers moeten draaien, heeft het ecosysteem een ​​vertrouwenslaag nodig die kennisbanken behandelt als appwinkels, documentatie als code en 'nuttige automatisering' als een bevoorrechte handeling – en niet als een alledaagse handigheid.

Bronnen

Document Title
When ‘skills’ become the supply chain: the OpenClaw marketplace malware wake‑up call
Malicious AI-agent ‘skills’ are turning documentation into a distribution channel for infostealers. Here’s how it works — and how to defend against it.
Title Attribute
oEmbed (JSON)
oEmbed (XML)
JSON
View all posts by Admin
Ikea’s bargain Matter-over-Thread devices are stumbling at the hardest step: getting connected
Should AI chatbots have ads? What Anthropic’s ‘no ads’ stance really means
Page Content
When ‘skills’ become the supply chain: the OpenClaw marketplace malware wake‑up call
Nature
Climate
/
General
/ By
Admin
In the last couple of years, “AI agent” stopped being a marketing phrase and started being a real workflow: an assistant that can read your files, open your browser, run commands, and stitch together actions across services. That’s the promise.
The problem is that
power has a distribution channel
. And that channel is increasingly called a
skill
: a small, shareable “how-to” package that teaches an agent (and often the user) how to accomplish a task. It’s the app store moment for agents — except the “apps” are frequently
markdown instructions
.
This week’s reports about malicious OpenClaw skills are an early, very loud signal that we’re about to repeat open-source supply‑chain history — but with a twist: instead of poisoning a compiled dependency, attackers can poison
documentation
and use the agent’s helpfulness as the lubricant.
Below is a practical explainer of what happened, why it works so well, and what you can do about it.
What OpenClaw skills are (and why they matter)
OpenClaw popularized a simple extension model: drop in a “skill” that explains how to do a narrow task — post on social media, clean folders, summarize a report, automate a workflow — and the agent gains a new capability.
In the broader “agent skills” ecosystem, a skill is typically a folder built around a
SKILL.md
file. That file contains:
Metadata
(name / description)
Instructions
(the actual steps)
Optionally:
scripts
and other bundled assets
That sounds benign because it looks like documentation. But documentation is exactly what people follow quickly, especially when it looks like a prerequisite list or installation guide.
Skills also have a “winner takes all” dynamic: people gravitate to what’s popular, what’s new, and what looks like it will save time. That makes a public skills marketplace a high-value target: compromise a few top downloads, and you can reach a concentrated set of power users — developers, operators, and anyone who has valuable credentials sitting on their machine.
The core trick: markdown isn’t “content” anymore — it’s an installer
Traditional software supply chain attacks often require technical investment: dependency confusion, typosquatting, malicious post-install scripts, maintaining control over a package name, and dodging scanners.
A skills marketplace lowers the bar.
A malicious skill can do something as simple as this:
Present a plausible tool (“Twitter skill,” “crypto tracker,” “automation helper”).
Add a “Prerequisites” section with a “required dependency.”
Provide a convenient link and a one‑liner command.
Rely on the human (or the agent) to execute it.
That’s not a new social engineering idea — it’s been used for years — but agent workflows
amplify
it:
Agents summarize docs confidently (“Just run this to install the dependency”).
Agents reduce friction by generating the command for you.
In some setups, agents can run shell commands themselves.
At that point, “documentation” becomes a remote execution path.
What the reports say happened in the OpenClaw ecosystem
Multiple write-ups describe a campaign in which attackers uploaded large numbers of malicious skills to the ClawHub marketplace and used “setup steps” to deliver infostealing malware.
According to 1Password’s Jason Meller, a top-downloaded skill included instructions that funneled users into a staged delivery chain: a link to a “dependency,” an obfuscated command, and then a payload that ultimately installed an infostealer designed to raid the machine for valuable secrets.
CyberInsider, citing research from Koi Security, describes a similar pattern at scale: trojanized skills with “Prerequisites” instructing users to run obfuscated shell scripts or download password-protected archives, culminating in payloads such as Atomic macOS Stealer (AMOS) — a malware family associated with credential theft and wallet targeting.
Whether the exact counts differ between reports, the
shape
is consistent:
Skills used as distribution
“Prerequisite” instructions used as persuasion
Infostealers used as the end goal
That end goal matters: modern infostealers aren’t after one password — they’re after
session tokens
,
browser profiles
SSH keys
cloud credentials
, and
crypto wallets
. In other words: the stuff that turns one compromised laptop into a broader compromise.
Why agents make this worse than a normal scammy download link
If you’ve ever thought, “I wouldn’t fall for that,” you’re probably right when you’re calm and skeptical.
But agent workflows change the context:
Speed becomes the default.
You’re using an agent because you want to move quickly.
Cognitive load is outsourced.
The agent turns a messy instruction page into a confident checklist.
Authority is borrowed.
If the agent says “This is the standard dependency,” it feels vetted.
In other words: the agent doesn’t need to be “tricked” in a technical sense. It just needs to be present while you’re being nudged to do a risky thing. That’s enough to tip behavior.
And if you
do
allow the agent to run commands directly, a malicious skill can become “hands-free compromise.”
‘But what about MCP? Isn’t that supposed to make tools safer?’
Model Context Protocol (MCP) is a real step forward for structuring tool access. It standardizes how hosts expose tools, resources, and prompts, and it emphasizes user consent and control.
However, MCP doesn’t magically make “skills” safe.
Why?
Skills can instruct users to run commands outside the MCP boundary.
Skills can link to scripts or downloads that never touch MCP.
Not every skill uses MCP at all.
MCP can help when the host implements strong permissioning, clear consent prompts, logging, and safe defaults. But a markdown-based distribution mechanism can still route around it through plain old social engineering.
This is the agent version of supply-chain security (and we’ve been here before)
The software world learned the hard way that:
Popular registries get abused.
Typosquatting works.
“Install this helper” is a common entry point.
The most valuable victims are the ones building things.
Skills marketplaces combine those lessons with two new accelerants:
The “package” can be instructions
, not code — and instructions are harder to scan reliably.
The runtime environment is credential-rich
by design: browsers logged into everything, terminals with SSH keys, cloud CLIs, password managers, and local files.
In a sense, a skills marketplace is an app store where the top apps are allowed to say “Copy-paste this into Terminal to enable the feature.” That’s not a solvable problem with one checkbox.
Practical defenses (for normal users)
If you’re experimenting with an agent that has local access, you need to treat it like a new operating system user with superpowers.
Here’s the pragmatic baseline:
Use a dedicated machine or VM
for agent experiments. No saved corporate logins. No production SSH keys. No cloud admin sessions.
Default to “no” on one-liner installers.
Especially anything that pipes curl into sh, uses base64, or asks you to remove OS protections.
Don’t trust “top downloaded.”
Popularity is a growth hack, not a security model.
Rotate what matters first if you already ran something.
Browser sessions, SSH keys, API tokens, cloud keys.
Prefer skills that are source-controlled and reviewable
(Git repos with history, known maintainers, clear provenance).
What marketplaces should do (if they want to survive)
If you run a public skills registry, you are running an attack surface.
A few practical steps that meaningfully raise attacker cost:
Publisher reputation and provenance
(verified identities, history, signing).
Automated scanning
for suspicious patterns (encoded payloads, obfuscated one-liners, quarantine removal, password-protected archives, “install core dependency” with offsite links).
Warning UI friction
for external links and shell commands.
Fast takedown and visible incident response
(treat it like an app store, not a pastebin).
None of these are perfect, but they buy time — and time is what defenders need.
What agent builders should assume going forward
If you’re building the agent runtime itself, assume skills will be weaponized.
That means:
Default-deny command execution
(require per-command consent, not once-and-forever toggles).
Strong sandboxing
for file system and browser access.
Scoped, time-bound permissions
with easy revocation.
Auditable logs
of what the agent read and what it executed.
The end state is the same direction the cloud took years ago: identity, policy, least privilege, and audit trails — but brought down to the workstation level.
Bottom line
The OpenClaw skills story isn’t just “some people uploaded malware.” It’s a preview of the next supply-chain battlefield:
skills as distribution, markdown as an execution path, and agents as the accelerator.
If agents are going to live on our personal and work machines, the ecosystem needs a trust layer that treats skills marketplaces like app stores, treats documentation like code, and treats “helpful automation” as a privileged operation — not a casual convenience.
Sources
https://www.theverge.com/news/874011/openclaw-ai-skill-clawhub-extensions-security-nightmare
https://1password.com/blog/from-magic-to-malware-how-openclaws-agent-skills-become-an-attack-surface
https://cyberinsider.com/341-openclaw-skills-distribute-macos-malware-via-clickfix-instructions/
https://agentskills.io/what-are-skills
https://modelcontextprotocol.io/specification/2025-06-18
←
Previous Post
Next Post
→
oEmbed (JSON)
oEmbed (XML)
JSON
View all posts by Admin
Ikea’s bargain Matter-over-Thread devices are stumbling at the hardest step: getting connected
Should AI chatbots have ads? What Anthropic’s ‘no ads’ stance really means
Malicious AI-agent ‘skills’ are turning documentation into a distribution channel for infostealers. Here’s how it works — and how to defend against it.
Document Title
Page not found - Florin.blog
Image Alt
Florin.blog
Title Attribute
Florin.blog » Feed
RSD
Skip to content
Placeholder Attribute
Search...
Page Content
Page not found - Florin.blog
Skip to content
Home
Blog
Garden Decor
Indoor
Main Menu
This page doesn't seem to exist.
It looks like the link pointing here was faulty. Maybe try searching?
Search for:
Search
Quick Links
Outdoors
About
Contact
Explore
Bestsellers
Hot deals
Best of The Year
Featured
Gift Cards
Help
Privacy Policy
Disclaimer
: As an Amazon Associate, we earn from qualifying purchases — at no extra cost to you.
Florin.blog
Florin.blog » Feed
RSD
Search...
e Nederlands