api-security

SUSPICIOUS. The skill is internally consistent as an API security testing playbook, and its AWS data flow points to official endpoints rather than a credential-harvesting proxy. However, it equips an AI agent with offensive security techniques, authenticated replay, and cross-tenant authorization testing, which is high-risk capability for an agent even without clear malware behavior.

This is an offensive attack guide, not source code for an npm or other software package. It documents arbitrary command execution, persistence, reverse shells, hidden-tool access, and credential theft techniques. No directly executable malware is present in the supplied fragment, but the described actions would be highly dangerous when applied to a vulnerable system.

The provided fragment is a targeted exploitation script for a Mattermost custom slash-command/dialog workflow. It authenticates with an access token, triggers a dialog, captures a privileged open_dialog event over WebSocket to recover redacted webhook/dialog metadata, and then forges a dialog submission to the Mattermost dialogs/submit endpoint with attacker-controlled values. This is designed to cause server-side webhook forwarding and downstream action execution (including potential SSH/SSRF/port-scan pivot scenarios). No meaningful obfuscation is present; the maliciousness is primarily behavioral and process-oriented.

This fragment is unequivocally malicious content: it provides practical XSS/DOM-injection payloads tailored to unsafe rendering of attacker-influenced LLM output, including mechanisms for sensitive data exfiltration, keylogging, remote hook loading, and destructive form actions. If such content appears in a software supply-chain artifact, it would represent a severe security backdoor risk (or at minimum an intentionally malicious inclusion), even though the snippet itself is presented as payload text rather than a runnable module.

This fragment is a high-adversity exploitation guide (with automation) targeting GraphQL authorization weaknesses: it demonstrates how to use aliases and identifier guessing for mass exfiltration of sensitive user/secret fields, and how to use mutation IDOR patterns to modify/delete other users’ data. There is no evidence of obfuscation or stealth code; the risk is primarily that the content is directly usable for unauthorized access and tampering. If found inside a software supply chain artifact, it should be treated as strongly suspicious and likely malicious/intentional.

No direct malware or executable compromise behavior is evident because the fragment is instructional content describing how to perform GraphQL introspection and evade introspection/WAF filtering. However, it is high-misuse guidance: it provides concrete, actionable payloads and evasion methods to enumerate backend schema structure (including potentially hidden/admin types) via network responses and error channels. If present inside an open source dependency, its primary supply-chain risk is enabling offensive reconnaissance, not in-package malicious execution.

This fragment is an explicit, attacker-oriented exploitation/bypass guide for defeating WAFs and related protections (encoding/normalization evasion, parameter pollution, spoofed forwarded headers, and a framework middleware bypass header), including automation support via sqlmap tampering and a custom payload-mutating function. While it does not itself demonstrate system-level malware behavior, it is highly actionable and unsafe for inclusion in a production dependency due to its direct facilitation of real-world attacks. Treat the package/dependency as high-risk for supply-chain abuse; require strict review, removal, and validation of intent (is it merely documentation for security testing or integrated/hidden tooling?).

This fragment is explicitly an attack playbook for exploiting an LLM-enabled SQL execution tool via prompt injection. It details enumeration, sensitive data (including password-field) extraction, destructive modification and persistence-like insertion, and potential escalation to OS command execution via database-specific primitives. While it is not executable malware code and contains no obfuscation, it is highly security-relevant and would be severe risk if shipped as part of a dependency or otherwise incorporated into a software supply chain.

The provided fragment is a prompt-injection/jailbreak playbook targeting LLM guardrails, with clear goals of system prompt/tool disclosure and attempts to reach privileged actions via an agent/tool framework. There is no evidence of software supply-chain malware within this fragment itself (no executable dependency code), but it represents a significant application-layer security threat if used against or embedded in an LLM-backed service lacking robust instruction hierarchy defenses and tool-access controls.

This fragment is a highly actionable exploitation playbook for query-string/parameter pollution used to extract sensitive account recovery tokens from an internal API via unsafe URL concatenation. While it contains no executable malware code, its content is directly supportive of credential/token theft and account takeover, making it a significant security risk if distributed as part of a software supply chain artifact.

This fragment is explicit, end-to-end CSWSH exploit material: it opens a WebSocket intended to be cookie/session authenticated by the victim browser, captures messages via ws.onmessage(event.data), and exfiltrates those contents to an attacker-controlled server using fetch() (POST body or GET querystring). It contains strong malicious indicators (weaponized generator, off-origin data theft, no defensive controls) and is not suitable for inclusion in a legitimate software package.

This fragment is explicitly an offensive, step-by-step WebSocket attack/verification playbook. It instructs how to spoof identity-related handshake inputs (Origin, X-Forwarded-For, Cookie, CSRF-like headers), manipulate the WebSocket upgrade process, and verify success via successful upgrade and follow-on privileged actions. There is no evidence of benign or protective functionality. In a dependency context, this is highly suspicious and potentially dangerous because it enables authentication/authorization bypass attempts.

No malicious dependency code is present in this fragment because it is a non-executable, exploit-instruction document. However, the content is highly actionable and explicitly describes an attack chain consistent with REST path traversal/route manipulation leading to API discovery and sensitive token extraction for account takeover. If found in a dependency, it should be treated as a serious security concern (harmful facilitation/unsafe content), even though it does not itself execute malware.

No dependency/library source code is provided—only an exploit/attack methodology describing how to use content-type confusion to reach XXE, including an explicit file:// external entity payload. Therefore, there is no way to evaluate actual runtime malicious behavior of a package module, but the content is clearly designed for exploitation and represents a high misuse risk.

The provided fragment is an explicitly malicious, highly actionable exploitation guide for HTTP verb discovery and unauthorized API state manipulation (e.g., setting product price to 0 and completing a fraudulent purchase). It contains no obfuscation and no self-contained executable malware, but it meaningfully facilitates abuse via crafted OPTIONS/PATCH/PUT/DELETE requests and validation-bypass techniques. Treat as high-risk misuse content if present in a software supply chain.

This material is a high-risk offensive reconnaissance playbook for GraphQL schema reconstruction using Apollo error-message suggestions (including an authenticated variant). While it contains no malware payload or obfuscation, it strongly enables attacker enumeration of hidden schema metadata and can support subsequent exploitation. Treat as security-sensitive and not appropriate for benign distribution or execution against systems without explicit authorization.

This fragment is not dependency source code; it is a step-by-step exploitation guide for abusing exposed Swagger/OpenAPI documentation to enumerate and execute privileged/destructive API operations (e.g., user deletion) using an authenticated session. No evidence of package-level malware or obfuscation is present in the fragment itself, but the content is highly actionable and indicates significant application-layer security impact if such authorization weaknesses exist in the target.

This fragment is explicitly malicious/offensive content: it teaches and provides code to generate GraphQL alias-batched payloads to evade HTTP request-based rate limiting and perform high-volume brute-force/verification attempts (login, 2FA/OTP, promo codes), with guidance to confirm success via response tokens/flags. It contains no benign library functionality and shows no obfuscation. If such logic were included in a supply-chain package, it would represent a direct abuse enabler and high security risk.