bug-bounty

High-risk offensive security skill. It is internally consistent as a bug-hunting/exploitation reference, but its actual footprint is to enable an AI agent to perform scans, exploit chains, OAST callbacks, and dependency-confusion PoCs against external systems. Not confirmed malware, but unsafe and inappropriate for general agent use.

This skill is internally consistent with its stated purpose, but that purpose is to equip an AI agent for offensive security exploitation. It is not covert malware, yet it is high risk because it provides exploit execution, exfiltration patterns, brute force workflows, and attacker-controlled callback endpoints suitable for misuse against live targets.

High-risk offensive security skill. Its capabilities mostly match its stated bug-bounty purpose, so it is not disguised malware, but it equips an AI agent to perform real-world reconnaissance, exploit testing, prompt-injection/system-prompt extraction, and OOB data-callback workflows against external targets. Official-ish install paths reduce malware confidence, yet the overall skill remains dangerous and suspicious due to offensive scope, callback endpoints, credential use, and agentic attack guidance.

SUSPICIOUS: the skill is internally consistent as a bug-bounty playbook, but its actual footprint is a high-risk offensive security capability for an AI agent. It enables reconnaissance, exploit development, prompt/system extraction, OOB callbacks, and real-world testing against external targets, with mutable third-party tool installs and broad exposure to untrusted content.

SUSPICIOUS: the skill is internally consistent as a bug-bounty/web recon guide, but its actual footprint is a high-risk offensive security capability for an AI agent. There is no clear credential exfiltration or malware behavior, yet the combination of autonomous scanning, secret/source extraction, and multiple third-party tool chains makes it unsafe and disproportionate for general agent use.

This skill is a high-risk offensive capability pack for password spraying and credential attacks. Its behavior is internally consistent with its stated purpose, but that purpose is to help an AI agent perform real intrusion attempts against third-party accounts, so it should be classified as suspicious/high risk rather than benign.

SUSPICIOUS: internally coherent as a bug-bounty reversal guide, but its actual capability is an offensive security skill that teaches an AI agent to bypass request-signing and anti-bot controls and automate testing against protected endpoints. It is not overt malware and does not appear to harvest credentials or exfiltrate to third-party servers, but it is high-risk because the skill's purpose is exploitation-oriented.

This skill is coherent with its stated purpose as a Web3 security research and audit methodology guide, but it equips an AI agent with offensive security workflows and includes commands to install tools, clone PoC repos, and run analysis/exploit tests. No clear credential theft, stealth, or malicious exfiltration is present; the main risk is enabling high-impact security testing and executing third-party research code.

The provided file is best characterized as an offensive WebSocket testing/exploitation harness with explicit CSWSH-style credential abuse and direct exfiltration of WebSocket-received data to an attacker-controlled domain. The code contains multiple hardcoded attack probes (authz/authn bypass testing, IDOR via victim identifiers, XSS/SQLi-like payloads, and admin action attempts). There is no evidence of obfuscation; the suspiciousness is in the explicit malicious behavior and payloads. If this behavior appears in a dependency that can be executed automatically during install or runtime, it should be treated as a critical supply-chain red flag and removed/reviewed urgently.

The fragment exhibits multiple high-risk, adversary-friendly trading mechanics: (1) router swaps accept unbounded slippage (`amountOutMin=0`), (2) swaps can be forced through an owner-configured routing pool (`mandatoryPool`), and (3) rebasing can be triggered during DEX interactions (`_rebase()` in `_transfer` when touching `uniswapPair`). Together these create predictable conditions for MEV/sandwich exploitation and unfair price impact. There is no clear evidence of classic off-chain/on-system malware (exfiltration, backdoors, persistence), but the economic extraction and user-trading safety risk are substantial given the shown logic.

SUSPICIOUS: the skill is internally coherent as a bug bounty methodology, but its actual footprint is a high-risk offensive-security orchestrator for AI agents. The strongest concerns are exploit guidance, broad autonomous probing, session reuse across tools, and explicit use of interactsh-style callback infrastructure.

No explicit embedded malware/backdoor was found in this fragment. However, the code frequently executes shell commands with shell=True while incorporating variables derived from untrusted CLI input (especially the target/domain). This creates a significant command-injection risk if an attacker can influence the 'domain' value. Additional supply-chain/integrity concerns exist (runtime curl downloads without verification) and sys.path modification increases import-hijack risk if the project directory can be tampered with. Because this module’s behavior heavily depends on external scripts/binaries under tools/, supply-chain compromise of those components would also be amplified.

This module is best characterized as a malicious payload generator: it implements deliberate Unicode steganography (U+2062/U+2064) to embed hidden prompt-injection instructions inside otherwise visible text, and it also packages extensive offensive security exploitation/probing payloads. While it does not execute commands or perform network exfiltration directly, it produces and exports weaponized artifacts (including cleartext references) intended for downstream abuse against LLMs/assistants or security targets. Treat as unsafe/malicious in a software supply chain context; it should not be included in trusted dependencies.

High-confidence malicious/offensive behavior: this Bash script actively generates and uploads server-executable payloads to verify RCE, performs time-based SQLi verification, sends SSTI probing payloads, tests SAML signature stripping by posting crafted (unsigned) assertions, and probes MFA rate-limit/workflow bypass. It writes exploitation artifacts (findings and Metasploit .rc) and drives external scanners (nuclei/dalfox). This is not a benign library module; it is an exploitation-oriented scanner/PoC generator and should be treated as highly risky in any supply-chain dependency context.

This module is best characterized as an offensive, dual-use authorization scanner/exploitation harness rather than malware. It actively probes cross-user data access (IDOR), performs potentially state-changing GraphQL mutations, attempts 2FA rate-limit testing via rapid OTP submissions, and evaluates CORS/CSRF-related behavior. It also prints and stores potentially sensitive API responses in memory/console, increasing the risk of sensitive data exposure to whoever runs/logs it. No classic stealth/backdoor/payload execution indicators are present in this fragment; the primary risk is abuse and data exposure inherent to its scanning behavior.

SUSPICIOUS: the skill is internally consistent as a mobile pentest guide, but its actual footprint is a high-risk offensive security capability set for AI agents. Tool provenance is mostly legitimate, yet the combination of decompilation, credential extraction, SSL pinning bypass, signer recovery, and live API attack workflows makes it dangerous even without clear malicious deception.

SUSPICIOUS: the skill is coherent with its stated purpose, but that purpose is to give an AI agent offensive smart-contract auditing and exploit-PoC capability. Dependency provenance is mostly consistent and data flows are direct to the configured RPC provider, yet the combination of exploit tooling plus credentialed RPC use makes it high security risk even without clear malware behavior.

SUSPICIOUS: the skill is internally coherent as a GraphQL pentest guide, but it is a high-risk offensive-security skill for an AI agent. It enables live exploitation, brute force, and DoS-style testing against external targets; supply-chain risk is moderate, while operational misuse risk is high.

The analyzed fragments collectively present a high-risk security profile dominated by upgradeability governance weaknesses, insufficient signature-domain protections, potential ERC4626 mispricing, and role-management uncertainties. Even without explicit exploit code, the combination of unguarded upgrade paths, reinitialization risks, and asset-control surfaces warrants treating the package as unsuitable for production use until a thorough, context-specific audit is completed and remediation is applied (tighten upgrades, implement proper nonce/domain handling, secure ERC4626 pricing, complete initializer safeguards, and fix role grants). Security risk is high due to the potential for unauthorized upgrades, replay and DoS vulnerabilities, and financial manipulation; operational risk is significant until fixes are applied.

This fragment is an offensive WAF/authorization bypass probe tool. It actively sends crafted requests (including TRACE and spoofed forwarding headers) and even includes an encoded script payload for baseline sampling, then records which responses look like bypasses. While it does not show classic malware behaviors (no reverse shell, no credential theft, no file system persistence, no network exfiltration to third-party domains), it is high-risk from an abuse perspective because it enables exploitation/bypass testing. Additionally, it sources and executes external package components (external_arsenal.sh, banner.sh, waf_response_analyzer.py, and optionally byp4xx/wafw00f), which could contain additional malicious behavior not visible here—so the supply-chain risk depends heavily on those files’ integrity.

SUSPICIOUS. The skill is coherent with its stated CI/CD security purpose, but that purpose is itself an offensive security capability for an AI agent. Its footprint is high risk because it teaches exploitation and exfiltration paths, invokes external scanners via an unseen installer script, and combines untrusted target content with shell-based analysis. Not confirmed malware, but unsafe to grant broadly.

This module is best classified as an offensive security testing tool for Zendesk with high misuse potential: it performs authorization-bypass-style IDOR enumeration, unauthenticated exposure probing, GraphQL introspection with optional local persistence, and—most importantly—creates tenant webhooks pointing to internal/metadata/localhost-style endpoints (an SSRF-style capability). No clear stealth/persistence or classic malware behavior is present in the visible fragment, but it can materially interact with and modify a tenant, making it a security-risk artifact if run without explicit authorization and tight scope controls.

No direct evidence of hidden malware (no eval/dynamic code execution from untrusted data, no credential theft/exfiltration, no backdoor/persistence in this snippet). However, the script carries significant supply-chain risk by executing a remote installer script (Homebrew install via curl piped into bash), installing many third-party binaries through package managers, downloading and extracting a third-party binary (sisakulint) from GitHub releases (checksum-checked but version discovery is ‘latest’), updating nuclei templates, and cloning external repositories in credential-attack mode. If upstream repositories/releases or dependency chains were compromised, this installer would faithfully install and potentially run the malicious payloads. Overall: likely a legitimate tool installer with inherent supply-chain exposure rather than clear sabotage in the provided fragment.

SUSPICIOUS: The skill is internally coherent as an offensive scanner suite, and the Interactsh dependency appears official rather than deceptive. However, it is a high-risk security/exploit skill for AI agents, uses live credentials in scans, and performs OOB callback testing through third-party infrastructure, so it should be treated as dangerous even without clear malware indicators.

This module is an offensive authorization-testing/exploitation tool. It uses user-supplied session cookies to authenticate against HackerOne, extracts CSRF tokens, performs cross-account read checks, and attempts multiple state-changing GraphQL mutations with real side effects (including closing/disclosure, bounty/assignment, and email sharing) while flagging potential authorization bypasses based on response content. While it is not obfuscated and does not exhibit classic malware behaviors like credential theft or exfiltration, its operational capability to enact unauthorized changes makes it a strong security risk if present as a dependency in a supply chain.

SUSPICIOUS/HIGH-RISK skill due to giving an AI agent concrete blockchain security exploitation and audit capabilities against financial systems. It shows no clear credential theft, malware payload, or exfiltration path, but it materially increases offensive capability and references an unverifiable local scanner component.

The provided code fragment is an attacker-style GraphQL recon and active probing harness. It explicitly attempts bypasses (GET-based introspection when blocked), performs disruptive workload tests (batching/alias/depth bombs), runs injection-oriented scanning (gqlmap/SQLi-style probe), and persists detailed reconnaissance results to disk. While it is not obviously implementing persistence/stealth malware inside the fragment, its operational intent and side effects make it highly risky to distribute or execute against any systems without explicit authorization.

No direct malware indicators are present in this module (no persistence, obfuscation, system modification, or exfiltration to unknown hosts). However, the code is an active, authenticated, high-impact testing harness that can generate abuse-like traffic: concurrent 2FA OTP attempts, bounty award/accept races, negative/extreme bounty validation probes, and concurrent email changes. The main supply-chain dependency risk is the unknown behavior of tools.safe_http.safe_urlopen imported via a runtime sys.path adjustment. Treat this as security-sensitive/offensive tooling: likely safe only in tightly controlled, explicit authorization scenarios.

This module is an offensive LLM red-team harness that sends carefully crafted prompt-injection/jailbreak/system-prompt-leak instructions to a user-specified HTTP chat endpoint and flags outcomes using a per-run canary and heuristic leakage/compliance checks. It includes an exfiltration-style beacon pattern inside prompt payloads to induce or observe outbound-style behavior in the target application/model. While it does not exhibit classic malware behaviors (no local compromise or obfuscation), it is directly actionable for probing and potentially exploiting LLM deployments, so it carries a high security risk if misused against unauthorized targets.

This fragment is best characterized as an offensive security testing script that actively probes auth/OAuth and password reset behaviors by sending crafted headers and parameters (attacker.com origin/host manipulation, redirect_uri bypass payloads, and bearer-token validation). While it does not obviously implement covert malware (no persistence, no process spawning, no hidden network exfiltration beyond the intended target, no keylogging/clipboard), it contains functionality commonly used in real attacks. Additionally, the snippet appears syntactically broken for check_ssrf_webhook(), and it imports safe_urlopen from a local module path that is not visible here—so supply-chain risk depends heavily on that dependency’s implementation.

This shell script is not a benign dependency; it functions as an offensive OSINT-to-credential-candidate pipeline. It harvests employee emails from public sources, derives/enriches names, generates username permutations, and (optionally) creates personal-style password candidates, then instructs how to use those artifacts for credential spraying. While the fragment shows no direct exfiltration or stealth, its end-to-end behavior materially enables unauthorized access attempts. Primary risks are (1) high misuse potential due to credential-spraying preparation and (2) execution of locally stored tools without integrity verification, increasing supply-chain/trust risk if those binaries are tampered.

This module is a credential-spraying/brute-force automation tool that performs repeated HTTP POST login attempts using operator-supplied username/password lists (and optional CSRF extraction), infers likely authentication success from response heuristics, logs attempt outcomes locally, and can stop on suspected hits. It also includes a fallback that disables TLS certificate verification if certifi is missing, further increasing operational risk. This represents a significant malicious/abusive supply-chain risk when included as a dependency, even though password values are only partially logged (hash prefixes).

This module is a credential-spraying/password-spray orchestrator. It collects operator-provided user/password lists and target endpoints, requires interactive confirmations designed to prevent wrong-target mistakes, then dispatches to networked credential-attack implementations (Python handlers and trevorspray) and persists run output to disk. While there are no obvious stealth/obfuscation techniques in this Bash fragment, the capability it enables is inherently high-risk and consistent with malicious or unauthorized authentication testing.

This module is best characterized as a DOM XSS exploitation/testing harness: it actively injects multiple executable XSS payload variants (including javascript: and script/event-based vectors) into user-supplied URL query/fragment parameters, loads the result in headless Chromium, and confirms client-side execution via a randomized canary marker exposed through Playwright. There is no direct evidence of stealth, persistence, credential theft, or exfiltration in this fragment; however, the capability to automate browser-based XSS payload delivery is inherently security-relevant and can be misused. As a supply-chain dependency, it poses moderate-to-high risk primarily due to offensive functionality and artifact-writing capability (screenshots) rather than classic malware behavior.

This module is best characterized as an upload/parser fuzzing and exploit-shaping utility. It intentionally constructs malformed and adversarial multipart/form-data payloads (including traversal-like Content-Disposition sub-parameter injection, NUL-byte boundaries, CRLF/LF mixing, nested boundaries, duplicate parameters, and encoding tricks). It can optionally POST these crafted payloads to an arbitrary user-specified URL. There is no direct evidence of covert malware behavior (no hidden exfiltration endpoints, no credential theft, no command execution), but the tool’s capabilities can materially facilitate attacking vulnerable servers or testing multipart upload handling in a way that could be misused. Use only with clear authorization and safeguards.

This module is an offensive NoSQL injection scanner. It actively sends crafted MongoDB-style operator payloads (including a $where sleep/timing probe) to a user-provided login endpoint and reports likely vulnerabilities based on HTTP status/length differences and timing deltas. While it does not exhibit typical malware behaviors (no backdoor/persistence/exfiltration/keylogging), it is directly capable of exploitation and therefore poses a significant security risk if misused or run against unauthorized targets. The snippet also relies on a local helper safe_urlopen whose safety cannot be verified here.

This module is highly suspicious and likely malicious in intent: it is explicitly a “hidden/invisible prompt injection” payload generator/encoder that conceals attacker instructions using Unicode stealth and can output/save ready-to-deploy injection artifacts. While it does not perform network exfiltration itself, it includes exfiltration-oriented instructions/URLs and prompt-injection objectives (system prompt/tool extraction, cross-tenant probing, RAG poisoning, and response overriding). Treat it as high-risk supply-chain tooling; avoid using it in dependencies for production or untrusted environments.

SUSPICIOUS. The skill is not malware and shows no credential theft, installer abuse, or exfiltration, but it is an offensive security hunting guide for a live blockchain target. Its footprint is text-only and internally consistent, yet the purpose enables AI-assisted exploit research, which makes it higher-risk than ordinary documentation.

This module is a high-risk, offensively purposed JWT attack toolkit. It can: (1) forge signature-bypass tokens via `alg=none`, (2) forge HS256-signed JWTs using attacker-supplied secret material and injected claims, (3) generate RS256->HS256 confusion demonstrations by treating a PEM blob as an HMAC secret, and (4) brute-force HS256 HMAC secrets offline from a wordlist. While it does not show network exfiltration or system command execution, its core functionality directly enables authentication bypass and secret compromise, making it unacceptable as a trusted dependency in security-sensitive contexts.

High misuse potential. The fragment is an operator-focused playbook that chains OSINT/breach-based candidate generation with staged decision logic culminating in HTTP-form credential spraying against a specified login endpoint, including persistent logging and resumable workflow design. Even though it instructs the agent not to execute and mentions dry-run/user consent gates, it remains directly actionable for authentication-attempt execution, which is strongly associated with malicious credential attacks.

This module is a credential-spraying automation tool targeting an OAuth2 password-grant token endpoint. It reads attacker-controlled user/password lists, repeatedly sends POST requests containing credentials, determines likely success by checking for access_token in responses, logs per-attempt results (including password hash prefixes and server error details), and reports plaintext credentials for detected hits in its runtime summary flow. While it is not obfuscated, its core functionality is high-risk and strongly aligned with unauthorized credential-stuffing activity. Include only in tightly controlled, authorized testing contexts with strict guardrails; treat it as extremely dangerous in general supply-chain scenarios.

This module is high-risk client-side reconnaissance code. It installs hooks on fetch and XHR to capture and retain GraphQL/AI/Hai/Copilot-related request bodies (via JSON parsing) and parsed response JSON, then can export the full captured dataset (including responses) to the clipboard through haiDump(). Additional helper functions fetch and scan all loaded JS bundles for keywords and reveal hidden UI elements, further supporting surveillance and mapping of application behavior. Overall, the behavior strongly matches unauthorized data collection/exfiltration patterns rather than benign debugging.

In this fragment, the Bash file functions purely as an authenticated test orchestrator: it uses bearer tokens to query HackerOne’s GraphQL endpoint for introspection and then delegates all higher-risk behaviors (IDOR/OAuth/SSRF/race/reset testing) to external local Python helper scripts, capturing their outputs to a log file. There are no hardcoded credentials, no visible obfuscated payloads, and no direct evidence of malware behavior within this wrapper itself. The primary security concern is that it operates with high-privilege tokens and creates a durable record of tool outputs; additionally, the actual maliciousness/intent cannot be confirmed without reviewing the delegated Python scripts, so risk is assessed as moderate due to potential misuse and unknown code in external tooling.

This fragment strongly indicates a recon-to-attack credential/authorization spraying toolkit (HTTP form and OAuth password-grant) with lockout-aware behavior and GraphQL-based auditing/hunting. No actual code implementation is provided in the excerpt, so specifics about network destinations, data handling, persistence, or stealth cannot be confirmed; nevertheless, the intent signals are severe enough that the dependency should be treated as highly suspicious/malicious until verified against a legitimate, explicitly authorized security-testing use case.

This module is an offensive, automation-focused WAF/authorization bypass tool. Its documented behavior—adaptive WAF/vendor fingerprinting, bypass-request mutation (headers/path/method/content-type), block-baseline calibration and scoring, and extraction/logging of WAF incident identifiers—materially enables unauthorized probing and likely follow-on exploitation. The inclusion of payload encoding/mutation and multipart parser-confusion bypass tooling further increases abuse potential. As a supply-chain dependency, it would represent a high security risk due to its evasion/exploitation orientation and conditional delegation to an external bypass package. No clear obfuscation is evident from the provided fragment, but the threat is intent and capability rather than concealment.

The fragment is highly abuse-enabling malicious guidance for constructing multi-stage exploit chains. While it is not executable code, it provides concrete steps and decision logic to achieve severe outcomes such as OAuth authorization-code theft leading to account takeover, SSRF-based cloud/IAM credential harvesting, XSS→CSRF admin privilege escalation, secret extraction from exposed web assets, and prompt-injection-driven data exfiltration. Treat any inclusion in a software supply chain as a high security risk artifact.

This artifact is an explicit offensive exploitation “chain builder” that instructs an agent to actively validate and combine web vulnerabilities into high-impact compromise chains (OAuth ATO/code theft, SSRF→cloud metadata credential access, stored XSS→admin priv-esc/automation, and other weaponized patterns). It includes operational constraints (confirm/prove chains, time-box tests) and OOB validation guidance that materially enables real-world exploitation. No code execution is present in the snippet, but the provided content functions as an actionable agent prompt/config and is therefore high risk for supply-chain inclusion.

The provided fragment is documentation for a recon utility that enumerates open non-HTTP services using external scanners (active probing via naabu and optional passive enrichment via smap/Shodan) and then highlights attack-surface ports relevant to follow-on compromise. No malicious payload or execution logic is shown here, so malware cannot be confirmed from this fragment alone. However, the explicit exploitation/pivot guidance (e.g., webshell/container escape/dumping concepts) makes the tool security-sensitive and potentially high-risk for misuse if included in untrusted environments. Review the actual implementation files to verify that behavior is limited to recon/port enumeration, includes appropriate safeguards, and does not perform exploitation beyond intended scope.

This package’s provided content is high-risk in intent and capability: it is designed to forge and manipulate JWTs (alg=none, RS256→HS256 confusion, and HS256 secret cracking via a wordlist) and to test exploitation by replaying forged tokens for privilege escalation/auth bypass. No executable code is shown, so additional supply-chain malware behaviors (e.g., data exfiltration or backdoors) cannot be confirmed from this snippet alone, but the documented functionality is strongly consistent with offensive exploitation tooling and should be treated as security-sensitive/dual-use with strict usage controls.

The provided material is a behavioral description of a dual-use cloud reconnaissance workflow, not the executable implementation. No direct malware indicators (e.g., credential theft, backdoors, obfuscated payloads, or covert exfiltration code) can be verified from this fragment. The primary concern is the tool’s explicit capability to enumerate public storage and infer potential Cloudflare-bypassing origin IPs, which can materially facilitate unauthorized targeting if misused. A proper review requires the actual script/code to confirm absence of unsafe operations (credential handling, remote exfiltration, dynamic execution) and to validate scope/authorization guardrails.