UnboundCompute

@unboundcompute source repo

194 skills
0 followers
6 hours ago last updated

▌
Auditing S3 Object Ownership Trust · unboundcompute
Audit object-storage ownership and per-object access for trust the bucket policy does not cover: an object uploaded by another account that keeps that uploader's ownership and ACL, a bucket where object ACLs still grant access despite a restrictive bucket policy, a cross-account write that lands an object the bucket owner cannot read or that carries a public grant, and a policy that scopes by prefix while an ACL on the object overrides it. Covers S3 and compatible stores where object ownership, object ACLs, and the bucket policy interact to decide who reads and controls each object. Use when a bucket receives objects from more than one principal and access is meant to be governed centrally. The cross-account or ACL-granted principal is the source, the object read or control is the sink, and the access the bucket policy did not intend is the bug.

0
installs
▌
Auditing Android Component Exposure · unboundcompute
Audit an Android app for components another app on the device can reach and drive, after the manifest export flags and permission gates are resolved. Covers an activity, service, broadcast receiver, or content provider exported without a permission gate, an intent filter that makes a component implicitly exported, a provider that grants URI access or exposes files across the app boundary, a permission declared with a weak protection level, and a component that trusts intent extras from an untrusted caller for a sensitive action. Use when reviewing the manifest and the component code that handles an inbound intent, not the deep-link URL trust that a WebView loads (that is the deep-link skill). A cross-app caller is the source, a reachable exported component acting on the intent is the sink, and a sensitive component another app can invoke unguarded is the bug.

0
installs
▌
Auditing Ble And Gatt Authorization · unboundcompute
Audit a Bluetooth Low Energy device for missing authorization on its GATT attributes: a characteristic performing a sensitive action or revealing sensitive data readable or writable by any peer, pairing or bonding that is not required or falls back to an unauthenticated Just Works mode with no link encryption, an authorization decision the device pushes to the mobile app instead of enforcing on the peripheral, and a replayable command a sniffer can capture and resend. Covers BLE peripherals, wearables, locks, medical and IoT devices, and their GATT services where a connected peer reads or writes characteristics. Use when a peer can connect over BLE and the peripheral's own enforcement of who may read or write each characteristic is the boundary. The unauthorized connected peer or captured command is the source, the sensitive read, write, or action on the peripheral is the sink, and the missing pairing, characteristic-level authorization, or replay protection is the bug.

0
installs
▌
Auditing Container Image Provenance · unboundcompute
Audit how a cluster decides which container images to trust and run: an image referenced by a mutable tag rather than a content digest, a workload pulling from a registry that admits unsigned or unverified images, a signature or attestation policy that is configured but not enforced at admission, and a base image or layer whose origin the pipeline never verified. Covers Kubernetes and container platforms where the image a workload runs is the code that runs, and where tag mutability, signing, and provenance decide whether it is the intended artifact. Use when workloads pull images whose signing and provenance are not enforced end to end. The unverified image reference is the source, the running container is the sink, and the code that runs without proven provenance is the bug.

0
installs
▌
Auditing Device Code And Pkce Flows · unboundcompute
Audit the server side of the authorization-code-with-proof-key and device-authorization grants for bugs that let a stolen or guessed code become a token. Covers a token endpoint that issues without checking the proof-key verifier at all, that accepts the plain challenge method or a challenge-absent downgrade, or that binds the verifier to the client rather than to the specific code; and a device grant whose short user code is brute-forceable because polling is unthrottled, whose device code is not bound to the requesting client, or whose approval is not tied to the authenticated approver. Scoped to the proof-key and device-code specifics, not general federated login, which a separate skill covers. Use when reviewing a token endpoint or a device-authorization endpoint. The token request parameters are the source, token issuance is the sink, and an unenforced proof binding between them is the bug.

0
installs
▌
Auditing Grpc Service Authorization · unboundcompute
Audit a gRPC service for a method a caller can reach without the authorization the service assumes an interceptor enforces, after the interceptor coverage and the channel credentials are resolved. Covers authorization installed on the unary interceptor while the streaming chain omits it, a per-method authorization gap reachable at the wrong privilege, server reflection enabled in production exposing the full API, a plaintext channel with metadata trusted unverified, an absent message-size or recursion-depth limit inviting decode denial of service, and a transcoding gateway that does not apply the same auth filter as native gRPC. Use when reviewing service and interceptor registration, method handlers, and channel setup, not the certificate-validation mechanics the transport skill owns. A caller with forged or absent metadata is the source, a service method acting without an authorization check is the sink, and an interceptor that does not cover the method or stream is the bug.

0
installs
▌
Auditing Skill And MCP Instructions · unboundcompute
Lint the natural-language instruction text of an agent skill or MCP server, not its code: the skill body, the frontmatter description, tool descriptions, and parameter text a model reads and obeys. Covers instructions hidden in comments or markup, invisible and look-alike Unicode, override phrases that countermand earlier instructions, concealment directives that tell the agent to hide an action from the user, and instructions that steer the agent to read secrets and send them out. Use when reviewing a skill, an MCP server, or a marketplace entry before trusting it, or auditing what instruction text enters an agent's context. Every word the model reads is instruction surface; a planted instruction is the finding.

0
installs
▌
Auditing Webauthn And Passkey Flows · unboundcompute
Audit the server side of passwordless authentication for ceremony-verification bugs that let an attacker-shaped response become an authenticated session. Covers a registration or authentication ceremony whose challenge is not bound to a server-issued single-use value, an origin or relying-party identifier that is never checked or checked by substring, a user-verification flag ignored when policy required it, attestation accepted when it was required, a signature counter regression that hides a cloned authenticator, and the highest-severity case where a cryptographically valid assertion seats a session for a user other than the one the credential is bound to. Use when reviewing code that verifies a registration or authentication ceremony and establishes identity from the result. The attacker-shaped ceremony response is the source, the authenticated session is the sink, and a missing required check between them is the bug.

0
installs
▌
Auditing Websocket Connection Trust · unboundcompute
Audit a WebSocket endpoint for trust established once at the handshake and never re-checked, so a cross-site page or a post-handshake message drives a privileged action, after the origin check and the credential source are resolved. Covers a missing or always-true origin check on the upgrade with ambient-cookie authentication, authentication at the handshake with no per-message authorization, a message treated as transport into a downstream injection sink, an unbounded frame or connection allowance inviting denial of service, tunneling past HTTP-layer controls that inspect only the request, and sensitive data broadcast to under-scoped subscribers. Use when reviewing the upgrade handler, the per-message dispatch, and the origin and credential checks, not the wss certificate validation the transport skill owns. A cross-origin or unauthenticated handshake is the source, a privileged action reached over the socket is the sink, and trust checked only at the upgrade is the bug.

0
installs
▌
Hunting Crlf And Response Splitting · unboundcompute
Hunt CRLF injection where untrusted input carrying a carriage return and line feed reaches a response header, a log line, or an outbound email header that does not strip or reject those characters, letting the attacker inject headers, split the message, forge log entries, or add email headers. Use when input flows into a Set-Cookie, Location, or custom response header, into a log written from request data, or into mail headers built from user input. Covers full response splitting into injected content or cache poisoning, header injection, log forging, and email header injection. The untrusted input is the source, the header, log, or email writer is the sink, and the injected line that the consumer treats as new structure is the bug.

0
installs
▌
Auditing API Key And Token Lifecycle · unboundcompute
Audit the lifecycle of API keys and access tokens for weaknesses that let one keep working past its intended bounds: a key issued with broader scope than the caller needs so a leak grants far more than one function, a key or token with no expiry that stays valid indefinitely, a revocation path that does not actually stop the key so a rotated or compromised credential keeps authenticating, a key that leaks into logs, URLs, client-side code, or error messages and is never rotated, and a token whose scope or audience is not enforced on use so it works against endpoints it was never meant for. Use when a long-lived programmatic credential authenticates a caller and the bounds on that credential (scope, expiry, revocability) are the boundary. The over-scoped, unexpiring, or leaked key is the source, the access it grants past its intended bounds is the sink, and the missing scope limit, expiry, or working revocation is the bug.

0
installs
▌
Auditing Cors And Cross Origin Trust · unboundcompute
Audit the code and configuration that decide cross-origin access, for trust a browser turns into a read of authenticated data. Covers a response that reflects an arbitrary request origin into the allow-origin header alongside allow-credentials, an allowlist that accepts the null origin, allowlist matching by prefix, suffix, substring, or an unanchored pattern that a lookalike origin satisfies, the origin header trusted as an authorization or request-forgery defense, and a cross-window message handler that acts on data without an exact origin and source check. Scoped to the code and config that build the decision, not a live-header scan. Use when reviewing cross-origin response headers, origin-based access logic, or cross-window message handlers. The request origin or the posted message is the source, the credentialed cross-origin read or the message sink is the sink, and trusting an attacker-set origin is the bug.

0
installs
▌
Auditing Ml Inference Endpoint Abuse · unboundcompute
Audit a hosted model inference endpoint for abuse that costs money or steals the asset: an unauthenticated or weakly keyed endpoint anyone can call, no per-caller rate or spend limit so a caller runs up unbounded inference cost, model extraction where systematic queries reconstruct the model or its decision boundary, membership and training-data inference that recovers whether a record was in the training set, and a response that returns full probabilities or embeddings that make extraction and inversion easier. Covers deployed prediction and embedding endpoints for classifiers, recommenders, and other served models, distinct from loading an untrusted model or serving a chat assistant. Use when a model is exposed as a callable endpoint and its cost, confidentiality, and integrity are the boundary. The unbounded or systematic query stream is the source, the run-up cost or reconstructed model or training data is the sink, and the missing auth, rate/spend bound, or over-informative response is the bug.

0
installs
▌
Hunting Formula Injection In Exports · unboundcompute
Hunt formula injection, also called CSV injection, where an untrusted field stored by the application is later written into an exported CSV, TSV, or spreadsheet and a spreadsheet program evaluates it as a formula when a victim opens the file. A cell whose first character is an equals, plus, minus, or at sign, or a tab or carriage-return prefix, is treated as a formula, so a stored value can call a data connection or hyperlink to exfiltrate other cells, trigger a legacy dynamic-data command that runs a program, or spoof content the recipient trusts. The vulnerable step is the export, not the page that stored the value, and the victim is whoever opens the download. Use when the app exports user-controlled data to a spreadsheet format. The stored untrusted field is the source, the exported cell a spreadsheet evaluates is the sink, and formula execution in the recipient's client is the bug.

0
installs
▌
Testing LLM Insecure Output Handling · unboundcompute
Test what happens after the model speaks: whether an application trusts model output and passes it, unescaped, into a browser, a terminal, a shell, a database, or another system. Covers model-driven XSS and markup injection, data exfiltration through rendered markdown images and links, terminal and ANSI escape injection, invisible-unicode and ascii smuggling in output, and output used to build code, SQL, or shell commands. Use when reviewing any app that renders, executes, or forwards LLM output. The model's output is an untrusted string.

0
installs
▌
Auditing Datastore Exposure And Abuse · unboundcompute
Audit in-memory and cache datastores such as Redis and memcached for exposure and command abuse: an instance reachable without authentication, a request that composes datastore commands from untrusted input, or server-side scripting and module or config commands that reach code execution or a file write. Covers unauthenticated network exposure, command injection where input becomes a command rather than a value, Lua or scripting evaluation on untrusted input, and dangerous administrative commands that rewrite the on-disk file or load a module. Use when an application talks to a cache or key-value store and either the instance is network-reachable or untrusted input reaches the command layer. The untrusted input or the open port is the source, the datastore command interface is the sink, and the unauthenticated access or the composed dangerous command is the bug.

0
installs
▌
Auditing Declared Vs Used Permissions · unboundcompute
Find the consent gap in an agent skill or MCP server: the distance between the permissions and capabilities it declares and what its bundled code and instructions actually exercise. Covers over-broad grants a skill requests but never uses, capabilities it exercises without declaring, and grants that are used but still wider than the task needs. Read the declared surface in frontmatter or manifest, inventory the real behavior, and diff the two in both directions. Use when reviewing a skill or server before install, or auditing least privilege across an agent's installed set. An over-broad or undeclared grant is the finding.

0
installs
▌
Auditing Ecs Task Metadata Boundaries · unboundcompute
Audit container task credential and metadata boundaries in orchestrated compute such as ECS: a workload that can reach the container credential endpoint or the host instance metadata service to obtain a role broader than the task needs, a task role over-scoped for the workload, a sidecar or co-located container sharing the same credentials, and a server-side request path inside the task that reaches the metadata endpoint. Covers the task credential relative URI, the instance metadata service reachable from a task, and the blast radius when one container in a task is compromised. Use when containerized workloads assume a task or instance role and the metadata endpoints are the boundary. The reachable metadata endpoint is the source, the credential it returns is the sink, and the role wider than the task's need is the bug.

0
installs
▌
Auditing Namespace As Tenant Boundary · unboundcompute
Audit a Kubernetes namespace that is treated as a tenant isolation boundary for the isolation it does not actually provide: cluster-scoped resources and nodes shared across namespaces, RBAC that grants a tenant reach beyond its own namespace, missing network policy so pods cross namespaces freely, and shared cluster services (DNS, ingress, admission, storage classes) that see or serve every tenant. Covers multi-tenant clusters where each tenant is given a namespace and the namespace is assumed to contain them. Use when a namespace is the unit of tenant separation and the assumption is that a tenant cannot affect or observe another. The tenant confined to a namespace is the source, the cross-tenant resource or namespace it reaches is the sink, and the isolation the namespace does not enforce is the bug.

0
installs
▌
Auditing Randomness And Nonce Quality · unboundcompute
Audit security-sensitive values for weak randomness: a non-cryptographic generator, a predictable or constant seed, a reused nonce or initialization vector, or an output too short to resist guessing, feeding a value whose only defense is unpredictability. Covers session and authentication tokens, password-reset and verification links, cross-site-request tokens and one-time codes, and cryptographic nonces or initialization vectors, drawn from a statistical generator instead of a cryptographic one, seeded from a timestamp or a constant, reused across messages under one key, or truncated into a space small enough to brute-force. Scoped to the randomness, seed, nonce lifecycle, and entropy length, not the choice of cipher, mode, or hash, which a separate skill covers. Use when a generated value gates access or protects a message. The generator is the source, the security-sensitive value is the sink, and predictability between them is the bug.

0
installs
▌
Hunting Dns Rebinding And Ssrf Pivots · unboundcompute
Hunt server-side request forgery and DNS rebinding that turn a server into a proxy for the internal network: a URL or hostname a caller controls that the server fetches, a validation that checks the hostname once but connects later so a rebinding answer swaps it for an internal address, a redirect the fetcher follows into internal space, and a reached internal service (metadata endpoint, admin port, database) that trusts callers by network position. Covers server-side fetchers, webhooks, importers, and previewers that resolve and connect to a caller-influenced destination. Use when a server makes outbound requests to destinations a caller can influence and internal services trust the server's network position. The caller-controlled destination is the source, the internal service the server reaches is the sink, and the time-of-check rebinding or unvalidated fetch that reaches it is the bug.

0
installs
▌
Hunting Expression Language Injection · unboundcompute
Hunt expression-language injection where untrusted input reaches a server-side expression evaluator: Spring Expression Language, OGNL, MVEL, JEXL, a Jakarta or JSP EL context, or a rules engine that evaluates strings. Covers request data flowing into an expression compiled and evaluated at runtime, where the language exposes type access, method calls, or a runtime handle that reaches command execution. Use when the application evaluates expressions built from or influenced by untrusted input rather than from fixed developer-authored strings. The untrusted value that becomes part of an evaluated expression is the source, the expression evaluator is the sink, and the reachable path from evaluation to a runtime or reflection call is the bug.

0
installs
▌
Hunting Kubelet And Node API Exposure · unboundcompute
Hunt for node-level Kubernetes endpoints that are reachable and under-authenticated: a kubelet API that allows anonymous or unauthenticated requests to list pods, read logs, or exec into containers, a read-only kubelet port exposing pod and node data, a node-local metadata or debug endpoint reachable from a pod, and a kubelet authorization mode that authenticates but does not restrict what a caller can do. Covers Kubernetes nodes where the kubelet and other node-local services expose control over the pods on that node. Use when node endpoints may be reachable from pods or the network and their authentication is the only thing standing between a caller and node-level control. The reachable caller is the source, the kubelet or node endpoint is the sink, and the anonymous or unauthorized access it permits is the bug.

0
installs
▌
Hunting Ldap Injection And Bind Trust · unboundcompute
Hunt LDAP injection and bind-trust flaws where untrusted input reaches a directory query or an authentication bind: a request value spliced into a search filter or a distinguished name without escaping, letting the caller alter the filter logic or the search base, and authentication flows that bind with attacker-influenced credentials in ways that permit anonymous or unauthenticated bind to pass as success. Covers filter metacharacter injection, DN injection that changes the subtree searched, and bind logic that treats an empty-password or anonymous bind as a valid login. Use when an application builds LDAP filters or DNs from input, or authenticates by binding to a directory. The untrusted value that becomes filter or DN structure is the source, the search or bind call is the sink, and the missing escape or the accepted anonymous bind is the bug.

0
installs
▌
Hunting Price And Coupon Manipulation · unboundcompute
Hunt for ways a buyer can control the price the server charges: a price, quantity, or line total taken from the client request instead of recomputed server-side from a trusted catalog, a negative or overflowing quantity that drives the total down or wraps it, a discount or coupon that stacks, reuses past its limit, or applies to items it should not, and a total computed on the client and trusted at checkout. Covers e-commerce carts, checkout totals, and promotion engines where the amount charged is derived from item prices, quantities, and discounts. Use when a buyer influences cart contents or promotions and the charged total is the boundary. The client-supplied price, quantity, or coupon is the source, the discounted or negative charged total is the sink, and the client-trusted amount or unenforced coupon rule that produces it is the bug.

0
installs
▌
Hunting Python Unsafe Deserialization · unboundcompute
Hunt Python deserialization that executes attacker code: untrusted input reaching pickle.loads, an unsafe YAML load, marshal, jsonpickle, dill, or a numpy or pandas loader that unpickles, where the format supports arbitrary object construction through __reduce__ or a tag. Covers pickled data in requests, cookies, caches, message queues, and model or dataframe files, and YAML documents that instantiate arbitrary Python objects. Use when a service loads serialized Python objects it did not produce with a loader that reconstructs arbitrary types rather than parsing data only. The untrusted serialized blob is the source, the reconstructing loader is the sink, and the __reduce__ or object tag that runs a callable during load is the bug.

0
installs
▌
Hunting Xpath And XML Query Injection · unboundcompute
Hunt XPath and XQuery injection where untrusted input is concatenated into a query expression that is then evaluated against an XML document or an XML database, so the input changes the structure of the query rather than supplying a value. A predicate closed early and rewritten to always be true bypasses an authentication or authorization lookup, and a rewritten path or an injected union walks the document to read nodes the caller was never meant to reach, including blind boolean and out-of-band variants where the response only reflects true or false. Use when an XPath or XQuery string is built from request data. The untrusted input concatenated into the expression is the source, the evaluation of that expression is the sink, and the attacker-controlled query structure is the bug.

2
installs
▌
Mapping Pod To Cloud Credential Reach · unboundcompute
Map what cloud identity a compromised pod can reach and what that identity can then do: a pod bound to a workload identity or role far broader than it needs, a node instance role reachable from any pod through the node metadata endpoint, a service-account token mounted into a pod that federates to cloud, and the chain from one pod's credential to another cloud resource or identity. Covers Kubernetes on cloud where pods obtain cloud credentials through workload identity federation, mounted tokens, or the node role, and where a pod compromise becomes cloud access. Use when pods hold or can reach cloud credentials and the blast radius of a pod compromise is the question. The compromised pod is the source, the cloud resource its credential reaches is the sink, and the over-broad or reachable credential is the bug.

0
installs
▌
Reviewing Detection Rules For Evasion · unboundcompute
Stress detection-as-code rules the way an attacker who has read them would: a rule keyed on one literal spelling of an action that a casing, quoting, whitespace, path, flag-ordering, or encoding variant slips past, a left-anchored or misplaced-wildcard match defeated by added noise, an exclusion or allowlist keyed on a field the attacker sets, and a rule over telemetry the log source never actually emits. Covers matching the spelling instead of the behavior, anchor and wildcard placement, self-defeating negation, and coverage gaps in the underlying events. Use when reviewing or threat-modeling detection content for brittleness rather than authoring it. The attacker-set field is the source, the rule's match decision is the guard, and a malicious event that performs the action yet does not match is the finding.

0
installs
▌
Auditing Admission Control Policy Gaps · unboundcompute
Audit cluster admission control for gaps that let a non-compliant or hostile workload through: a validating webhook that fails open when its backend is unreachable, a policy that scopes by namespace or label and misses the namespaces that matter, a mutating webhook whose changes are trusted downstream, and an ordering or exemption that lets a privileged pod bypass the checks meant to stop it. Covers Kubernetes admission webhooks and policy engines that are supposed to enforce workload security at create and update time. Use when admission policies are the control that keeps privileged, unsigned, or over-permissioned workloads out of the cluster. The workload submitted for admission is the source, the admitted resource is the sink, and the policy gap that let it through is the bug.

0
installs
▌
Auditing Csrf And Unsafe State Changes · unboundcompute
Audit state-changing endpoints for cross-site request forgery, where a request that rides the victim's ambient cookies is authorized on that session alone with no unpredictable, session-bound proof the request came from the app, letting an attacker page trigger the change as the victim. Use when reviewing forms and actions that modify data, change settings, move funds, or alter access, and how each is protected. Covers missing or unvalidated tokens, tokens not bound to the session, cookie-only same-site reliance and its gaps, state-changing GET requests, and content-type or method-override assumptions. The cross-site request on the victim's session is the source, the state-changing endpoint is the sink, and acting without unpredictable session-bound proof of origin is the bug.

0
installs
▌
Auditing Group Policy And Sysvol Trust · unboundcompute
Audit trust placed in group policy content and the domain policy share, where a low-privileged principal can write a policy object, its files on the domain share, or its link, causing that policy to run scripts, set scheduled tasks, install software, or change security settings on every machine the policy applies to, or where a stored credential or an unsigned policy file lets any domain user act on the policy. Use when policy objects, their share files, or their links may be writable by non-administrators or carry stored secrets. Covers writable policy content, writable links and scope, embedded credentials, and unsigned or world-readable policy files. The low-privileged write to policy content or link is the source, the machines applying the policy are the sink, and running attacker-chosen policy on those machines is the bug.

0
installs
▌
Auditing Security Logging Completeness · unboundcompute
Audit whether an application actually records the security events an investigation would need, and whether the logs themselves leak or lie: a security decision (authentication, an authorization denial or sensitive grant, a credential or privilege change, access to sensitive data) that fires with no durable record, an audit entry missing the actor, target, or outcome, secrets or personal data flowing into a widely-readable log, and untrusted input written to a log without neutralizing line breaks so entries can be forged. Covers coverage gaps at the decision points, record sufficiency and tamper-resistance, log-as-disclosure, and log injection. Use when assessing whether the code emits the security signal downstream detection and forensics depend on. The security action or the secret is the source, the audit or log sink is the sink, and the missing or unsafe record is the finding.

0
installs
▌
Auditing Serverless Event Source Trust · unboundcompute
Audit event-driven function handlers that trust the event because it arrived from inside the platform: a handler that treats any delivered event as authentic without verifying its true source or integrity, event fields flowing untrusted into a database write, command, downstream call, or constructed path, a function reachable by several event types or actors that runs privileged logic for one that should not trigger it, and an over-broad execution identity that turns a single spoofed or injected event into wide reach. Covers source authentication, event injection, per-event-type and per-actor authorization, and execution-role blast radius across queues, object-store notifications, schedules, topics, and gateways. Use when functions are triggered by events and the handler trusts the payload or its claimed origin. The event payload is the source, the handler's action is the sink, and the assumed-not-verified trust is the bug.

0
installs
▌
Auditing Service Account Key Lifecycle · unboundcompute
Audit cloud and platform service-account keys for lifecycle weaknesses that turn a non-human credential into standing access: a user-managed key file that never expires and is copied into repos, CI config, or developer laptops, a service account granted far more privilege than its workload needs so the key is a broad credential, a key that is never rotated and has no owner tracking who holds copies, a key that can be created or downloaded by someone who should only use the account, and a disabled or deleted service account whose outstanding keys still authenticate. Use when a non-human identity authenticates with a long-lived key and the scope, rotation, and containment of that key is the boundary. The over-privileged, unrotated, or exportable service-account key is the source, the workload-level access an attacker gains by holding it is the sink, and the excess privilege, missing rotation, or exportable key material is the bug.

0
installs
▌
Auditing Smart Contract Access Control · unboundcompute
Audit a smart contract for a privileged action any caller can reach, so an attacker invokes a function that should be restricted. Covers a state-changing or fund-moving function missing an authorization modifier, an ownership or role check that is wrong or bypassable, an unprotected initializer that lets an attacker seize ownership of a proxy or an uninitialized contract, a delegatecall to an attacker-supplied or upgradeable target that runs foreign code in this contract's context, a self-destruct or upgrade reachable without the right role, and a role granted to an address that should not hold it. Use when the fix would add or repair an authorization check, not reorder effects before interactions (that is the reentrancy skill). The attacker calling a privileged function is the source, the restricted action executing for them is the sink, and a missing or defeated authorization check is the bug.

0
installs
▌
Hunting Defi Economic And Oracle Flaws · unboundcompute
Hunt a decentralized-finance protocol for a way to profit by moving a price or breaking an economic invariant, rather than by defeating an access check or re-entering. Covers a price read from a spot source an attacker can move within a transaction, a manipulable oracle or a single-source feed with no sanity bound, a swap or liquidation that trusts a pool ratio a flash loan can skew, rounding or fee-accounting that a repeated interaction drains, share or collateral math that lets a first or precise depositor steal value, and a slippage or deadline parameter left unchecked. Use when the fix is an economic or pricing safeguard (a manipulation-resistant oracle, a bound, corrected math), not an authorization check or a reentrancy guard. The manipulable price or invariant is the source, the value the attacker extracts is the sink, and a value decision that trusts a movable input is the bug.

0
installs
▌
Hunting Iam Privilege Escalation Paths · unboundcompute
Hunt privilege-escalation paths in cloud identity and access management: a low-privileged principal that chains role assumptions, policy rewrites, role-passing, and over-broad trust relationships to reach an administrative or data-access principal. Covers the identity-to-permission-to-resource graph, the known escalation primitives (passing a more privileged role to a service, rewriting a policy to a permissive version, assuming a role whose trust condition is too loose), and the boundary controls that should stop the chain. Use when reviewing cloud IAM, role and policy configuration, or an identity graph. A reachable path from an untrusted principal to admin is the finding.

0
installs
▌
Hunting Path Traversal And File Access · unboundcompute
Hunt path traversal and unsafe file access where untrusted input builds a filesystem path and the resolved path escapes the intended base directory, so the process reads or writes files it should not. Covers download and upload names, template and include paths, static-file routes, and archive members driven to dot-dot or absolute or drive-letter targets, encoded and double-encoded separators, null-byte truncation on legacy stacks, symlink following, and the difference between checking the raw input and checking the canonicalized absolute path. Use when input becomes a path passed to an open, read, write, include, or send-file call. The untrusted path input is the source, the filesystem open or write is the sink, and reaching a file outside the intended directory is the bug.

0
installs
▌
Hunting Server Side Template Injection · unboundcompute
Hunt server-side template injection where untrusted input becomes part of a template that the engine compiles and evaluates, rather than data passed into a fixed precompiled template. Covers input concatenated into a template string, a user-chosen template name or path, and admin or content features that render user-authored templates, across engines like Jinja, Twig, Freemarker, Velocity, ERB, and Handlebars. The impact runs from expression evaluation and data disclosure up to remote code execution when the engine exposes object internals or a weak sandbox. Use when a template string or name is built from input, or a feature lets users supply template markup. The untrusted value reaching compilation is the source, the template engine eval is the sink, and expression evaluation escalating to disclosure or code execution is the bug.

0
installs
▌
Auditing Ansible Become And Vault Trust · unboundcompute
Audit configuration-management privilege escalation and secret handling for trust that runs as root on every managed host: a task that escalates with become across a whole play when only one step needs it, a role or variable sourced from an untrusted place that runs under that escalation, a vault-encrypted secret whose decryption key is exposed to the runner or logged, and a templated value or module argument that takes attacker-influenceable input while privileged. Covers Ansible and similar agentless tools where a control node runs plays that escalate privilege and decrypt secrets across a fleet. Use when playbooks escalate with become or handle vault secrets across managed hosts. The untrusted role, variable, or input running under escalation is the source, the privileged task or decrypted secret is the sink, and the over-broad escalation or exposed key is the bug.

0
installs
▌
Auditing Clickjacking And UI Redressing · unboundcompute
Audit a web application for UI-redressing attacks where an attacker frames the real site and tricks a user into acting on it unknowingly: a sensitive page that can be embedded in an attacker's iframe because it lacks frame-ancestors or X-Frame-Options, a state-changing action reachable by a single click that an overlay or transparent frame steers, a drag-and-drop or keystroke redressing that captures input meant for the attacker page, and a confirmation step that a framed overlay hides. Covers web pages with authenticated, state-changing actions (settings changes, purchases, approvals, connect flows) that could be loaded inside a frame the user cannot see. Use when a sensitive action can be triggered by a click and the page can be framed by another origin, making framing the boundary. The attacker page that frames or overlays the real site is the source, the unknowing state-changing click is the sink, and the missing framing protection or unguarded one-click action is the bug.

0
installs
▌
Auditing Host Mount And Device Exposure · unboundcompute
Audit the host paths and devices a workload mounts for reach across the container boundary onto the node: a writable hostPath into a sensitive node directory, a mount of the host root or a system path that exposes other pods' data and node configuration, a raw device or block volume that grants low-level host access, and a hostPath whose subpath or symlink handling lets a workload escape the intended directory. Covers Kubernetes and container hosts where hostPath volumes and device mounts connect a container to the node filesystem and hardware. Use when workloads mount host paths or devices and the question is what node state that mount exposes. The workload holding the host mount is the source, the node file or device it reaches is the sink, and the host-path or device exposure beyond the workload's need is the bug.

0
installs
▌
Auditing JWT Verification And Key Trust · unboundcompute
Audit how a service verifies JSON Web Tokens for the classic verification bypasses: an algorithm-confusion attack where a token switches the signing algorithm so a public key is used as a symmetric secret or the algorithm is set to none, a key selected from an attacker-controllable header (a key id, a JWKS URL, or an embedded key) so the token names its own signer, a signature that is decoded but not actually verified, and claims (expiry, issuer, audience) that are parsed but not enforced. Covers services that accept and verify JWTs to authenticate or authorize a caller. Use when a JWT is the credential and its verification is the boundary. The forged or unverified token is the source, the authenticated or authorized action it grants is the sink, and the algorithm confusion, attacker-chosen key, or unverified claim that accepts it is the bug.

0
installs
▌
Auditing Mfa Enrollment And Reset Abuse · unboundcompute
Audit multi-factor authentication enrollment, reset, and recovery for paths that let an attacker add their own factor or bypass the check: a first-factor session that can enroll a new authenticator without re-proving identity so a stolen password adds a second factor, an MFA reset or recovery flow guarded only by a weak signal (an email link, a knowledge question, a support request) that resets the factor to attacker control, a step-up prompt that can be skipped or is not enforced server-side on a sensitive action, backup codes that are weak, reusable, or issued without authentication, and an MFA-fatigue or push-bombing flow that approves on a single tap. Use when adding, resetting, or satisfying a second factor is the boundary between a stolen first factor and a full account takeover. The enrollment or reset request is the source, the attacker-controlled factor or bypassed check is the sink, and the missing identity proof or skippable step-up is the bug.

0
installs
▌
Auditing Mobile Webview Bridge Exposure · unboundcompute
Audit the trust a mobile app places in web content loaded in an embedded WebView, where a native bridge exposes app capabilities to JavaScript, letting web content that the app did not author, remote pages, loaded third-party frames, or attacker-influenced URLs, call native methods, read app data, or act with the app's privileges, because the bridge is exposed to untrusted origins, the loaded content is not origin-restricted, or the bridge methods do not check the caller. Use when a native app embeds a WebView that both loads remote or mixed content and exposes a native interface to script. Covers script-to-native bridges reachable by untrusted content, unrestricted content loading, and bridge methods that trust any caller. The untrusted web content reaching the bridge is the source, the native method it invokes is the sink, and web script driving native capability is the bug.

0
installs
▌
Auditing Saml And Oidc Federation Trust · unboundcompute
Audit federated single sign-on for assertions a relying party should not trust: a SAML response whose signature is not verified over the right element so a wrapped or altered assertion passes, an OIDC ID token whose issuer, audience, or nonce is unchecked, a relying party that accepts an assertion for any user because the subject or email is trusted without binding, and a federation that honors an identity provider or signing key it should not. Covers SAML and OpenID Connect where a relying party consumes assertions or ID tokens minted by an identity provider to authenticate users. Use when login trust crosses from an identity provider to a relying party and assertion validation is the boundary. The forged or misbound assertion is the source, the authenticated session it grants is the sink, and the missing signature, issuer, audience, or binding check that accepts it is the bug.

0
installs
▌
Auditing Session Lifecycle And Fixation · unboundcompute
Audit how an application issues, rotates, and destroys session identifiers, so an attacker cannot fixate or outlive a session. Covers a session identifier not regenerated at login or privilege change, a logout that clears the client cookie but leaves the server session valid, a session that never expires or has no idle or absolute timeout, an identifier accepted from a URL or a header an attacker can seed, a session cookie missing the secure, http-only, or same-site attributes, and a cookie scoped to a parent domain shared with untrusted subdomains. Use when reviewing authentication, logout, and session-management code and the cookie attributes it sets; it assumes the identifier is unguessable and scopes to lifecycle, not entropy. An attacker who can set or keep a session identifier is the source, the victim authenticating into it is the sink, and a session that is not rotated or invalidated is the bug.

0
installs
▌
Auditing Ssh Trust And Agent Forwarding · unboundcompute
Audit secure-shell trust hygiene, not cipher hardening: a forwarded authentication agent a remote host can abuse to log in as you elsewhere, client configuration or a proxy-command directive influenced by an untrusted source, host-key verification disabled or blind-accepted so a machine-in-the-middle succeeds, and authorized-key entries whose forced command can be escaped or whose source and forwarding are unrestricted. Covers agent-socket exposure on multi-user or untrusted hosts, config and proxy-command injection from attacker-controlled data, trust-on-first-use gaps, and permissive key options. Use when auditing how hosts and users establish secure-shell trust and what a compromised endpoint can reach. The forwarded socket, injected directive, or unverified key is the source, authentication or command execution as an unintended identity is the sink.

0
installs
▌
Auditing Tls And Certificate Validation · unboundcompute
Audit client code for transport security that is disabled or defeated, so an attacker on the network path can intercept a connection the client believes is protected. Covers verification switched off (a trust-all setting, a permissive flag, an environment override), a custom trust manager or callback that returns success unconditionally, a hostname check that is skipped or always passes, acceptance of an expired or self-signed certificate through a swallowed error, certificate pinning that is absent where required or falls through to accept on failure, and a silent downgrade to cleartext when the handshake fails. Use when reviewing code that opens outbound TLS connections, configures an HTTP or socket client, or installs a custom trust store. An attacker in a man-in-the-middle position is the source, the client accepting a forged certificate is the sink, and validation that does not fail closed is the bug.

0
installs
▌
Hunting Adcs Certificate Template Abuse · unboundcompute
Hunt privilege escalation through Active Directory Certificate Services template and enrollment misconfiguration, where a low-privileged principal can enroll for a certificate that authenticates as a more privileged account, because a template lets the enrollee supply the subject, allows a client authentication use, has weak enrollment permissions, or the certificate authority accepts a requester-set identity. Use when a certificate authority issues templates for domain authentication and a standard user can enroll. Covers enrollee-supplied subject alternative names, overly broad enrollment rights, dangerous template flags, and requester-controlled identity. The low-privileged enrollment for an identity-bearing certificate is the source, the certificate authority issuing it is the sink, and authenticating as a more privileged account with that certificate is the bug.

0
installs
▌
Hunting Orm And Query Builder Injection · unboundcompute
Hunt injection that survives an object-relational mapper or query builder: untrusted input reaching a raw-query escape hatch, an unparameterizable identifier (a column, table, or sort order), or a structured filter or update object whose keys become query operators or column references. Covers raw-query methods that take a string or fragment, sort and column selectors taken from the request, and operator injection where a request body passed as a filter turns a comparison always-true or references a field it should not. Use when data access goes through an ORM or query builder and untrusted input reaches a raw method, an identifier argument, or a filter or update object rather than a bound value. The untrusted value that becomes query structure is the source, the data-access call is the sink, and the missing allowlist between them is the bug.

0
installs
▌
Hunting PHP Object Injection Pop Chains · unboundcompute
Hunt PHP object injection where untrusted input reaches unserialize or a framework unserializer and a reachable class carries a magic method that fires during or after reconstruction. Covers native unserialize on request data, cookies, or cache entries, phar deserialization triggered by filesystem functions on an attacker-controlled path, and property-oriented programming chains through __wakeup, __destruct, __toString, and __call that reach a file write, a command, or an SQL sink. Use when a PHP app deserializes data it did not produce and application or library classes define magic methods with side effects. The untrusted serialized string is the source, the unserialize or phar trigger is the sink, and the magic-method chain to a dangerous call is the bug.

0
installs
▌
Hunting Server Side Prototype Pollution · unboundcompute
Hunt server-side prototype pollution in JavaScript and TypeScript backends where untrusted input sets a __proto__, constructor, or prototype key through a recursive merge, a deep clone, a path-based set, or a query or body parser, polluting Object.prototype so a later property read returns an attacker value. Covers the pollution primitive (the write that reaches the prototype) and the gadget (a downstream read of an unset property that changes control flow, a command, a template, or a query). Use when a Node service merges or path-assigns untrusted structured input into objects and later reads properties that may be absent. The untrusted key reaching the prototype is the source, the polluting merge or set is the sink, and the gadget read that turns pollution into impact is the bug.

0
installs
▌
Testing Client Side Dom Vulnerabilities · unboundcompute
Test the vulnerabilities that live entirely in the browser, where the server is never the sink: DOM-based cross-site scripting from client-side sinks, DOM clobbering, prototype pollution that corrupts application logic, unsafe cross-window messaging, client-side path and open-redirect handling, and cross-origin information leaks. Use when reviewing a single-page app, heavy client-side JavaScript, a browser extension, or any code that reads attacker-influenceable input and writes it into the DOM, a sink, or a shared object. The taint never reaches the server.

0
installs
▌
Adjudicating Dependency Cve Reachability · unboundcompute
Decide whether a CVE in a dependency actually exposes your application before you scramble to patch: is the vulnerable function on a real call path from your code, do the trigger preconditions hold, and can an attacker control the input that reaches it. Use when an advisory, SCA scan, or dependency bot flags a CVE and you must separate a genuine exposure from unreachable noise, or justify why you are or are not affected. Covers pinning the vulnerable symbol, call-path reachability, precondition checks, and taint from your entry points.

0
installs
▌
Auditing Container Image Build Hardening · unboundcompute
Audit container image build definitions (Dockerfile, containerfile, and the compose or run config that sets runtime flags) for an image that ships over-privileged or carrying a secret, after multi-stage discards and deploy-time overrides are accounted for. Covers an image that runs as root, a secret baked into a layer, remote content pulled unpinned or unverified, a mutable or untagged base, an over-broad copy that pulls in local secrets and history, and a dangerous runtime request such as privileged mode or a sensitive host mount. Use when reviewing the image build plane, not the deploy-time security context or the cloud resource definition. The build definition is the source, the shipped image or run config is the sink, and privilege or a secret that survives into the final image is the bug.

0
installs
▌
Hunting Active Directory Acl Abuse Paths · unboundcompute
Hunt privilege escalation through Active Directory object permission abuse, where a low-privileged principal holds a right over a more privileged object, letting it reset a password, add itself to a group, set a delegation or logon script, write a service principal name, or take ownership and rewrite the object's permissions, chaining one granted right into control of a higher-privileged account. Use when directory object permissions may grant a standard user a write over a privileged user, group, computer, or organizational unit. Covers force-password-reset, group membership writes, generic-write and write-owner abuse, and delegated control chains. The low-privileged right over a privileged object is the source, the directory operation that right authorizes is the sink, and gaining control of the higher-privileged account is the bug.

0
installs
▌
Hunting Kerberos And Ad Delegation Abuse · unboundcompute
Hunt for Active Directory Kerberos delegation configurations that let one identity act as another: a service account with unconstrained delegation that can impersonate any user who authenticates to it and reuse their ticket anywhere, constrained delegation configured so a service can request tickets for higher-privileged targets, resource-based delegation an attacker can set on an object they control to relay into it, a service account with a weak password exposed to Kerberoasting through its service principal name, and an account not requiring pre-authentication that is roastable offline. Use when a service is allowed to reuse or request a user's Kerberos identity and the scope of that delegation is the boundary. The delegation right or roastable credential is the source, the impersonated higher-privileged identity is the sink, and the overbroad delegation or crackable service account is the bug.

0
installs
▌
Hunting Setuid And Capability Escalation · unboundcompute
Hunt local privilege escalation through setuid and setgid binaries and per-file capabilities: programs that run as a more privileged identity, or files granted a capability such as changing user id, overriding file permissions, raw disk or memory access, or loading kernel modules, that expose an exec, file-read, file-write, or library-load primitive an unprivileged caller can reach. Covers known dangerous tools left with the bit set, custom or bundled setuid programs that shell out or trust a writable path, and over-broad capabilities that are privilege in all but name. Use when auditing a host, image, or package for local privilege escalation. The elevated identity is the source, the primitive it exposes is the sink, and the missing confinement is the bug.

0
installs
▌
Auditing Account Recovery And Reset Trust · unboundcompute
Audit password reset and account recovery flows for the trust that lets an attacker take over an account: a reset token that is guessable, long-lived, reusable, or not bound to the account it was issued for, a recovery path that verifies a weaker factor than login and bypasses multi-factor, a reset link whose host comes from an attacker-controllable header so the token leaks, and a recovery that trusts an unverified email or phone change to redirect the reset. Covers the recovery surface of authentication systems, where resetting a credential or recovering access is the alternate door into an account. Use when an application offers password reset or account recovery and that flow is a path to authentication. The attacker-driven recovery request is the source, the account it takes over is the sink, and the weak token, bypassed factor, or leaked reset link that grants it is the bug.

0
installs
▌
Auditing Editor Extension Workspace Trust · unboundcompute
Audit an editor or IDE extension for actions it runs on untrusted workspace contents, after the workspace-trust capability and activation events are resolved. Covers a task, debug preLaunchTask, or command that auto-runs on folder open, a tool path or command template read from workspace settings and executed, a workspace-trust bypass where a risky operation runs in restricted mode, a language server that loads or executes a workspace-declared binary, repo-controlled data reaching a shell or task-execution sink, and an extension webview that renders repo content without a content-security policy. Use when reviewing an extension manifest (activation events, the untrusted-workspace capability), its workspace config handling, or its language-server tool resolution. A cloned untrusted repository is the source, an action the extension auto-runs on open is the sink, and repo-controlled code reaching execution without a trust gate is the bug.

0
installs
▌
Auditing File Upload And Content Handling · unboundcompute
Audit a file-upload and content-handling path for an attacker-supplied file whose bytes, declared type, name, or embedded content reach a sink that stores it in a served or executable location or feeds it to a parser that acts on its content, after the type-decision layer and the serve behavior are resolved. Covers an extension or content-type trusted for a type decision that a second layer contradicts, an SVG, HTML, or XML file stored and served inline as active content, image or document parser exploitation, a polyglot file passing one content check yet executing in another context, an upload path writing outside the intended directory, and an archive expanding to a write primitive. Use when reviewing upload validation, storage, and serving, not the client-side DOM sink or the archive-extraction write primitive their own skills own. An uploaded file is the source, a serve or parse sink acting on its content is the sink, and a type decision one layer contradicts is the bug.

0
installs
▌
Auditing Infrastructure As Code Exposures · unboundcompute
Audit existing infrastructure-as-code definitions (Terraform, OpenTofu, CloudFormation, Bicep, Pulumi) for resource state that would provision an insecure resource, after variables, modules, and account defaults are resolved. Covers storage exposed to the public, a security-group or firewall rule open to the whole internet on a sensitive port, an identity or resource policy with wildcard actions or principals, encryption left off or a snapshot or image shared publicly, logging or audit trails disabled, and a plaintext secret in a variable default or connection string. Use when reviewing the static definition files, not authoring or refactoring them, and not walking the runtime identity graph. The declared resource block is the source, the insecure provisioned resource it would create is the sink, and effective config that violates the baseline is the bug.

0
installs
▌
Auditing Init And Sidecar Injection Trust · unboundcompute
Audit the init and sidecar containers a workload runs, including ones injected by a mutating admission webhook, for trust the main container never granted: an injected sidecar that runs with broader privileges, host access, or credentials than the workload, an init container that fetches and executes remote content before the app starts, a shared volume or process namespace that lets a sidecar read the main container's secrets, and an injection whose image and configuration come from a source the workload owner does not control. Covers Kubernetes pods where init and sidecar containers, declared or webhook-injected, share the pod with the application. Use when pods run init or sidecar containers, especially injected ones. The injected or auxiliary container is the source, the pod resource or credential it reaches is the sink, and the trust it holds beyond the main container is the bug.

0
installs
▌
Auditing Network Policy Segmentation Gaps · unboundcompute
Audit cluster network segmentation for the reachability a workload should not have: a namespace with no default-deny so every pod can reach every other pod, a missing egress policy that lets a compromised pod call out to the internet or the cloud metadata endpoint, an overly broad selector that admits more sources than intended, and a policy that governs one direction while the other stays open. Covers Kubernetes network policies and equivalent segmentation where pod-to-pod, pod-to-service, and pod-to-external reachability is meant to be constrained. Use when network policy is the control limiting lateral movement and egress in a cluster. The reachable source pod is the source, the pod, service, or external endpoint it can reach is the sink, and the segmentation gap that permits the reach is the bug.

0
installs
▌
Auditing Secure Boot And Firmware Signing · unboundcompute
Audit updater and bootloader code for a firmware trust boundary that lets an unsigned or downgraded image be flashed or booted. Covers an update image that reaches a flash write or a boot jump with no signature check between receipt and commit, a verification result that is ignored or inverted, an integrity hash mistaken for an authenticity signature, a signature checked over the wrong or partial bytes or over a different buffer than the one committed, a verification key kept in writable storage or selected by a field in the image, and anti-rollback that is missing or checked before the signature so a known-vulnerable version re-flashes. Use when reviewing code that receives, verifies, flashes, or boots a firmware image. The received image is the source, the flash write or boot jump is the sink, and a verified authenticity check failing to dominate that path is the bug.

0
installs
▌
Auditing Third Party Script And Sri Trust · unboundcompute
Audit a web application for trust placed in third-party scripts it loads into its own page: an external script tag with no Subresource Integrity hash so a compromised CDN or vendor serves altered code that runs with full page privileges, a tag manager or analytics loader that injects further scripts the site never reviews, a script served over a mutable URL or wildcard source that can be swapped, and a Content-Security- Policy that is missing or permissive enough to allow arbitrary external script. Covers browser front ends, marketing and analytics tags, payment and widget embeds, and any page that loads JavaScript it did not author from another origin. Use when a page runs third-party script in its own security context and the integrity of that code is the boundary. The compromised or swapped third-party script is the source, the full-privilege execution in the page (data theft, skimming, defacement) is the sink, and the missing integrity pin or permissive script policy is the bug.

0
installs
▌
Auditing Workload Secret Exposure Surface · unboundcompute
Audit how a workload holds its secrets for the exposure that outlives the secret's intent: a secret passed as an environment variable that any process, crash dump, or child inherits and that debug endpoints echo, a secret volume mounted where a sidecar or a shared process can read it, a secret written into logs or an error, and a Kubernetes secret readable by more service accounts than the one workload that needs it. Covers containerized workloads where secrets reach the process through environment, mounted files, or the orchestrator's secret store. Use when a workload consumes secrets and the question is who or what else can read them. The workload secret is the source, the process, sidecar, log, or extra reader that can see it is the sink, and the exposure beyond the intended consumer is the bug.

0
installs
▌
Hunting Broken Object Level Authorization · unboundcompute
Hunt broken object-level authorization (BOLA, also called IDOR): endpoints that accept a client-supplied object reference - a numeric id, UUID, key, slug, filename, or an id nested in a request body or token - and read or mutate that object without checking the authenticated caller is entitled to it. Covers direct references, enumerable and guessable ids, references buried in nested or batch payloads, second-order ids stored then trusted later, and ownership checks that run on one path but not its siblings. Use when reviewing any API or handler that fetches or changes a record by an id the client controls. The reference is the source, the data access is the sink, and the missing owner binding is the bug.

0
installs
▌
Hunting Content Type And Parser Confusion · unboundcompute
Hunt content-type sniffing and parser confusion where untrusted content is served or consumed with an ambiguous or attacker-influenced type, so a browser sniffs a response as HTML, a backend picks a different interpretation than the sender intended, or two parsers on one path disagree. Use when user content is echoed with a missing, wrong, or user-controlled content type, when uploads are typed by extension or by the client, or when a request body can be parsed more than one way. Covers response sniffing, upload-filter bypass, polyglot files, charset-driven scripting, and multipart differentials. The ambiguously typed content is the source, the sniffer or parser that resolves the type is the sink, and the interpretation the attacker forces is the bug.

0
installs
▌
Hunting Host Header And Url Parsing Trust · unboundcompute
Hunt trust placed in the Host or a forwarded host header and in inconsistently parsed URLs, where the app builds absolute links, keys a cache, routes a request, or matches an allowlist from a header or a parsed URL an attacker can influence or that two components parse differently. Use when a service derives its own external URL from the request, when a cache or router keys on the host, or when a security decision parses a URL. Covers password-reset and verification-link poisoning, cache poisoning, routing to internal virtual hosts, and redirect or fetch allowlist bypass through parser differentials. The attacker-influenced host or ambiguous URL is the source, the link builder, cache key, router, or allowlist parse is the sink, and trusting a host or a parse the attacker controls is the bug.

0
installs
▌
Hunting HTTP Request Smuggling And Desync · unboundcompute
Hunt for request smuggling where two HTTP processors on the same path disagree about where one request ends and the next begins: a front end and back end that resolve conflicting Content-Length and Transfer-Encoding headers differently, a proxy that forwards a body the origin re-parses, a keep-alive connection where a smuggled prefix poisons the next user's request, and a rewrite or normalization difference that desyncs the stream. Covers chained HTTP/1.1 processors, proxies, load balancers, and origins where request framing is parsed more than once. Use when a request crosses more than one HTTP parser and their framing agreement is the boundary. The desyncing request is the source, the poisoned next request or back-end path is the sink, and the framing disagreement between the two parsers is the bug.

0
installs
▌
Hunting Mobile Tls Pinning And Trust Gaps · unboundcompute
Hunt transport trust gaps in a mobile app, where the app accepts a network position it should reject, because it trusts user-added certificate authorities, allows cleartext or mixed connections, disables or misapplies certificate validation, or pins only some connections so an unpinned or fallback path lets a network attacker read or alter traffic the app treats as secure. Use when reviewing how a mobile app establishes and validates its network connections and whether every sensitive connection resists an intercepting network position. Covers user-trusted anchors, cleartext and mixed connections, disabled or permissive validation, and partial or bypassable pinning. The intercepting network position the app fails to reject is the source, the connection the app treats as trusted is the sink, and reading or altering supposedly secure traffic is the bug.

0
installs
▌
Testing Postmessage And Web Message Trust · unboundcompute
Test cross-document messaging trust, where a browser message handler acts on data whose origin or content an attacker can influence by opening or framing the window, or where code sends sensitive data to another window with a wildcard target. Use when reviewing client code that registers a message event listener and routes the data into the DOM, an evaluation, navigation, or storage, or that posts secrets across windows. Covers a missing, wildcard, or substring origin check, a missing source-window check, a wildcard target that leaks data, and a deserialized message driving a sink. The message event is the source, the handler sink or the outbound post is the sink, and acting without an exact origin and source check, or leaking to a wildcard target, is the bug.

0
installs
▌
Testing Smtp Smuggling And Email Spoofing · unboundcompute
Test a mail setup for sender spoofing that survives authentication: SPF, DKIM, and DMARC records that exist but do not align or enforce, subdomains left unprotected, and the end-of-data desync known as SMTP smuggling, where an inbound and an outbound mail server disagree on where one message ends so a second message with a forged, auth-passing sender is smuggled in. Covers policy present but not enforced, alignment gaps between the envelope and header sender, missing subdomain policy, open relay, and inconsistent message-boundary parsing between hops. Use when auditing a domain's mail authentication or a mail server's boundary handling. The crafted or smuggled message is the source, an accepted spoofed delivery is the sink.

0
installs
▌
Auditing Http2 And Grpc Multiplexing Trust · unboundcompute
Audit HTTP/2 and gRPC edges for framing and multiplexing trust that breaks when a stream is translated or reused: an h2c or HTTP/2-to-HTTP/1.1 downgrade that reintroduces request smuggling, pseudo-header and header handling that lets a stream forge its path or authority, multiplexed streams on one connection whose authentication or rate limit is applied per connection rather than per stream, and a gRPC gateway that trusts metadata or a method name a caller controls. Covers HTTP/2 front ends, gRPC services, and gateways that translate between protocols. Use when an edge terminates or downgrades HTTP/2 or multiplexes gRPC calls and per-stream trust is assumed. The crafted stream or metadata is the source, the back-end request or method it reaches is the sink, and the downgrade or per-connection trust that admits it is the bug.

0
installs
▌
Auditing Jit Provisioning And Role Mapping · unboundcompute
Audit just-in-time account provisioning at federated (SAML or OIDC) login for trust misplaced in the assertion that drives it: a first login that creates an account and assigns roles from identity-provider claims (groups, email domain, department) the service never validates, a claim-to-role mapping that grants more privilege than the claim should or defaults new users into a privileged role, an email or domain claim trusted to auto-join a tenant so an attacker with a lookalike address lands inside it, and a JIT update that re-elevates an account on every login from mutable claims. Use when a federated login provisions an account and the mapping from assertion claims to local roles and tenancy is the boundary. The attacker-shaped login assertion is the source, the over-privileged or wrong-tenant provisioned account is the sink, and the unvalidated claim or over-granting role mapping is the bug.

0
installs
▌
Auditing Service Mesh Mtls And Authz Trust · unboundcompute
Audit a service mesh for the trust it claims but does not enforce: a mesh in permissive mode that accepts plaintext alongside mutual TLS so an unauthenticated caller still gets through, an authorization policy that is absent, scoped too narrowly, or defaults to allow, a workload reachable outside the mesh that bypasses the sidecar entirely, and an identity check that trusts a header a caller can set. Covers service meshes where sidecars are supposed to enforce mutual TLS and per-service authorization between workloads. Use when a mesh is the control asserting who may call whom and that calls are authenticated. The unauthenticated or unauthorized caller is the source, the called service is the sink, and the permissive mode or missing authz policy that admits it is the bug.

0
installs
▌
Auditing Sso Logout And Session Revocation · unboundcompute
Audit single sign-on logout and session revocation for sessions that outlive the event meant to end them: a logout that clears the local application session but never ends the identity-provider session so re-login is silent, a single-logout flow the application ignores so signing out at the identity provider leaves downstream application sessions alive, an access or refresh token that keeps working after logout or after an admin disables the account, a session that survives a password reset or deprovisioning event, and a back-channel logout notification the application never processes. Covers SAML and OIDC single sign-on, single logout, back-channel logout, and token revocation across relying applications. Use when a user, admin, or identity provider ends a session and whether every downstream session and token actually terminates is the boundary. The logout or revocation event is the source, the session or token that keeps working is the sink, and the unpropagated logout or unrevoked token is the bug.

0
installs
▌
Auditing System Prompt And Context Leakage · unboundcompute
Audit an AI application for confidential material bleeding out of the model context: a system prompt that carries secrets (API keys, internal URLs, business rules, hidden instructions) and can be coaxed out verbatim, retrieved documents or tool outputs from one user surfacing in another user's answer, conversation or memory from one session or tenant leaking into the next, and a debug or error path that echoes the raw prompt or context. Covers assistants, chat features, and agents where a system prompt, retrieved context, or cross-session memory holds data that must not reach the user or another tenant. Use when the model context holds anything confidential and the boundary is what the model will reveal. The extraction prompt or cross-tenant request is the source, the leaked prompt or context is the sink, and the secret-in-prompt or unscoped context that exposes it is the bug.

0
installs
▌
Auditing Terraform State And Backend Trust · unboundcompute
Audit infrastructure-state storage and its backend for exposure and tampering: a state file holding plaintext secrets in a backend readable by too many principals, a state bucket or backend without encryption, versioning, or access scoping, a missing or unenforced state lock that allows concurrent corrupting writes, and a backend configuration that lets an attacker redirect state to a location they control. Covers Terraform and similar tools where the state file records real resource attributes and often secret values, and where whoever can read or write state can read those secrets or subvert the next apply. Use when infrastructure state is stored in a shared backend and that backend is the boundary. The principal who can read or write state is the source, the state store is the sink, and the exposed secret or the tamperable state is the bug.

0
installs
▌
Auditing Windows Token And Privilege Abuse · unboundcompute
Audit privilege escalation through Windows access token and privilege abuse, where a process holds a sensitive privilege or can obtain a more privileged token, letting a lower-privileged foothold impersonate a privileged caller, load a driver, take ownership, back up protected files, or debug another process to reach a higher context. Use when a service or process runs with a named sensitive privilege enabled or can receive and impersonate tokens from privileged callers. Covers impersonation privileges, token theft and duplication, and the backup, restore, ownership, load-driver, and debug privileges. The privilege or the capturable privileged token is the source, the operation the privilege authorizes is the sink, and reaching a higher-privileged context from a lower one is the bug.

0
installs
▌
Hunting Helm Template And Values Injection · unboundcompute
Hunt injection through Kubernetes packaging templates and their values: an untrusted value rendered into a manifest without quoting so it injects YAML structure, a value that flows into a container command, an annotation, or an RBAC rule and grants more than intended, and a chart that renders privileged security context or host access from a caller-supplied value. Covers Helm-style templating where a values file or a user-supplied override is rendered into Kubernetes manifests, and where an unescaped or unconstrained value becomes structure, a command, or a permission. Use when charts render manifests from values that a tenant, a pipeline, or a user can influence. The untrusted value rendered into the manifest is the source, the template render is the sink, and the injected YAML structure or widened permission is the bug.

0
installs
▌
Hunting Java Deserialization Gadget Chains · unboundcompute
Hunt Java deserialization that turns an untrusted byte stream into code execution: attacker-controlled data reaching readObject, an ObjectInputStream, or a framework endpoint that deserializes, with a gadget on the classpath whose readObject or finalizer drives a property-oriented chain to a dangerous call. Covers native serialization, JNDI lookups reached through deserialized objects, and framework entry points that accept a serialized object over HTTP, a message queue, a cache, or a cookie. Use when a service reads serialized Java objects it did not produce and reachable library versions carry a known gadget. The untrusted serialized stream is the source, the deserialization call is the sink, and the gadget chain from readObject to a runtime or naming call is the bug.

0
installs
▌
Hunting Mass Assignment And Property Authz · unboundcompute
Hunt mass assignment and broken object-property authorization: handlers that bind a client request payload straight onto a record or model and let the caller write fields it should never control - role, is_admin, owner_id, tenant, price, balance, verified, status, or another user's foreign key. Covers auto-binding and hydration that take the whole payload, blocklist filters that miss a field, nested and relation fields that reopen the hole, type juggling that flips a flag, and read paths that return properties the caller should not see. Use when reviewing any create or update handler that maps request fields onto a persisted object. The payload field is the source, the record write is the sink, and the server-controlled property is the bug.

0
installs
▌
Hunting Mobile Secret And Storage Exposure · unboundcompute
Hunt a mobile app for a real credential shipped in the binary or written to storage another party can read, scoped strictly to mobile-specific sinks. Covers a live secret embedded in the app package or its resources, sensitive data written to world-or-sandbox-readable storage without encryption, a secret placed outside the platform keystore where a weaker guard protects it, data cached or logged where another app or a device-level reader reaches it, and a backup or debug path that carries sensitive data off the device. Use when reviewing the app package, its storage writes, and its logging, distinguishing a public identifier from a credential and judging whether the platform sandbox already contains the data. The embedded or stored secret is the source, a party that can read it is the sink, and a real credential exposed beyond its intended reader is the bug.

0
installs
▌
Hunting Nosql Operator And Where Injection · unboundcompute
Hunt NoSQL injection where untrusted input becomes query structure rather than a bound value: a request body whose keys turn into query operators, a value that arrives as an object instead of a scalar, or input reaching a server-side JavaScript evaluation such as $where, a mapReduce function, or an aggregation expression. Covers document stores where a filter built from a request object lets the caller inject comparison operators, always-true conditions, or code, and key-value or wide-column stores where input shapes the query language. Use when data access takes structured input from the request into a query filter or a server-side expression. The untrusted value that becomes an operator or an expression is the source, the query or evaluation call is the sink, and the missing type and shape check is the bug.

0
installs
▌
Hunting Server Side And Edge Side Includes · unboundcompute
Hunt server-side include and edge-side include injection, where untrusted input is reflected into a document that a processor later interprets for include and exec directives. When an origin server has server-side includes enabled, a reflected directive can read a server file or run a command. When a cache, content-delivery network, or proxy in front of the origin parses edge-side include tags, a reflected tag can fetch an internal URL for server-side request forgery, poison a shared cache, or copy a victim's cookie into a page. The edge case is easy to miss because the origin developer never sees the processor that evaluates the tag. Use when reflected input reaches a document that an include-capable server or edge tier processes. The reflected input is the source, the include or exec directive the processor evaluates is the sink, and the resulting file read, command, request forgery, or cache poisoning is the bug.

0
installs
▌
Reviewing Rate Limiting And Abuse Controls · unboundcompute
Review whether sensitive and expensive endpoints are rate-limited and whether the limit can be bypassed, as a coverage-and-keying problem rather than a taint flow. Covers a login, credential-reset, one-time-code verify, signup, token, payment, or expensive-query endpoint with no limit on any layer of its path, a limit keyed on a client-supplied identifier the caller can rotate, a counter held per process so it multiplies across instances, a throttle with no lockout or backoff that permits slow brute force, and an enumeration oracle left unthrottled. Use when reviewing the handlers and configuration behind authentication, account, payment, and costly operations. The sensitive or expensive endpoint is the source, the enforcement decision and the identifier it is keyed on are the sink, and a missing or spoofable limit is the bug.

0
installs
▌
Auditing Message Broker Topic Authorization · unboundcompute
Audit message-broker topic and queue authorization for reach a client should not have: a wildcard subscription that receives another tenant's messages, a publish permission broad enough to inject into a control or command topic, a shared broker where topic naming is the only separation between tenants, and a client authenticated to the broker but not authorized per topic so any connection can read or write any topic. Covers MQTT, Kafka, AMQP, and similar brokers where publish and subscribe permissions on topics or queues are the boundary between producers, consumers, and tenants. Use when a broker carries messages across trust boundaries and topic-level authorization is the control. The client publishing or subscribing is the source, the topic or queue it reaches is the sink, and the wildcard or missing per-topic authorization that admits it is the bug.

0
installs
▌
Hunting Command Argument And Flag Injection · unboundcompute
Hunt argument and flag injection where untrusted input occupies a slot in a subprocess argument vector, with no shell involved, and the target program parses it as an option rather than data. Covers a value that starts with a dash and becomes a flag, and a value inserted before the program separates options from operands, turning a data argument into one that changes behavior: writing or reading a file, running an embedded command, changing a config or protocol, or reaching a network target. This is not command injection, there is no shell, so metacharacter defenses miss it; the fix is an argument terminator and a fixed positional layout. Use when input is placed into an argv slot of a spawned tool. The untrusted argv value is the source, the target program option parser is the sink, and an argument reinterpreted as a dangerous option is the bug.

0
installs
▌
Hunting Mobile Tapjacking And Overlay Abuse · unboundcompute
Hunt mobile interface redressing, where another app draws over or intercepts a sensitive screen so the user acts on the attacker's terms without knowing it, approving a permission, confirming a transaction, or entering a secret while an overlay hides or fakes what they are really touching, because the sensitive screen does not detect that it is obscured, does not filter touches passed through an overlay, or does not bind the confirmation to what the user actually saw. Use when a mobile app presents consent, confirmation, or credential-entry screens that another app could overlay or intercept. Covers tap hijacking through overlays, obscured-touch acceptance, accessibility-driven interaction, and confirmations not bound to the displayed action. The overlaying or intercepting app is the source, the sensitive screen accepting the redirected interaction is the sink, and the user approving what they did not intend is the bug.

0
installs
▌
Hunting Subdomain Takeover And Dangling Dns · unboundcompute
Hunt DNS records that point at infrastructure the organization no longer controls, so an attacker can claim the target and serve content under a trusted name. Covers a CNAME or ALIAS to a decommissioned platform host that the provider lets anyone re-register, a dangling NS delegation whose nameserver or zone no longer exists in the account, a record that outlives its resource because infrastructure-as-code or a teardown pipeline deletes the resource but not the record, and a wildcard or unclaimed virtual host routed to a default backend. Use when reviewing DNS zone files, the DNS records declared in infrastructure-as-code, and the pipelines that provision and tear down them. The resolvable record whose target is unclaimed is the source, an attacker serving content on the trusted origin is the sink, and a claimable dangling target is the bug.

0
installs
▌
Auditing Cross Account Role Trust Boundaries · unboundcompute
Audit cross-account IAM role assumption for trust policies that let the wrong principal assume a role: a trust policy with a wildcard or overbroad principal, a missing or unverifiable external ID on a third-party role, a confused-deputy path where a vendor assumes your role on any customer's behalf, and a role chain that reaches privileges the origin principal should never hold. Covers AWS assume-role trust policies, condition keys that should scope who may assume, and the transitive reach of one assumption into the next. Use when roles in one account can be assumed from another account, a partner, or a service, and the trust policy is the boundary. The external principal permitted by the trust policy is the source, the assume-role grant is the sink, and the trust scope wider than the intended relationship is the bug.

0
installs
▌
Auditing Open Redirect And Forced Navigation · unboundcompute
Audit redirect and navigation flows where an untrusted return, next, or callback URL, a stored value, or a referer drives a server redirect, a client-side location assignment, or a meta refresh to an attacker-chosen destination, enabling phishing, credential capture on a lookalike page, or theft of an OAuth code or token carried on the redirect. Use when a parameter or stored value controls where a user is sent after login, logout, an action, or an authorization step. Covers protocol-relative and backslash hosts, userinfo and whitespace tricks, and dangerous schemes that a naive allowlist misses. The untrusted target URL is the source, the redirect or navigation is the sink, and sending the user to an attacker-controlled destination is the bug.

0
installs
▌
Auditing Windows Named Pipe And Rpc Exposure · unboundcompute
Audit local privilege escalation through Windows inter-process interfaces, where a privileged service exposes a named pipe, remote procedure call endpoint, or local COM server that a lower-privileged caller can reach and that performs a privileged action, impersonates the caller unsafely, or trusts caller-supplied input without authorization, letting a standard user drive privileged behavior. Use when a service listens on a named pipe, an RPC interface, or a COM server reachable by non-administrators. Covers weak interface permissions, unsafe impersonation of a connecting client, missing caller authorization, and privileged actions exposed to low-privileged callers. The lower-privileged call into the interface is the source, the privileged action the service performs is the sink, and driving privileged behavior as a standard user is the bug.

0
installs
▌
Hunting Blind And Second Order SQL Injection · unboundcompute
Hunt the SQL injection that first-order testing misses: blind injection where the response carries no error or data and the signal is a boolean difference or a timing delay, and second-order injection where input is stored safely on one request and later concatenated into a query on a different code path. Covers values that reach a query only after being read back from the database, a cache, or a log, and sinks that reveal nothing directly so confirmation depends on an inferential channel. Use when a value is stored now and used in a query later, or when a parameter reaches a query whose response shows no direct output. The untrusted value that becomes query structure at the later or blind sink is the source, that query is the sink, and the unparameterized use on the second path is the bug.

0
installs
▌
Hunting Mutual Tls And Service Identity Gaps · unboundcompute
Hunt for gaps in how a service establishes and verifies the identity of the peer calling it: a mutual-TLS endpoint that requests a client certificate but does not require or verify it, verification that checks the certificate chains to a trusted authority but never checks which identity it names, a trust anchor broad enough that any certificate it issued is accepted as any service, and an identity derived from a spoofable attribute (a header, a source IP) instead of the verified certificate. Covers service-to-service calls where mutual TLS or a certificate is meant to prove which service is calling. Use when a service authorizes callers by their identity and mutual TLS or a client certificate is the proof. The unverified or misbound peer is the source, the called service it authenticates to is the sink, and the missing certificate requirement, identity check, or trust-anchor scoping that admits it is the bug.

0
installs
▌
Hunting Windows Credential Material Exposure · unboundcompute
Hunt exposure of Windows credential material, where secrets that authenticate a user or machine, cached logon verifiers, stored service and task passwords, protected-store secrets, saved connection credentials, and credentials left in memory of a privileged process, are readable by a principal that should not reach them because of a weak permission, an over-privileged token, or storage that does not bind the secret to the intended account. Use when reviewing where Windows keeps authentication secrets and which principals can read each store. Covers cached verifiers, service and scheduled-task secrets, protected-store material, saved credentials, and process memory. The readable credential store or process is the source, the read that recovers usable secret material is the sink, and obtaining a credential the reader was not entitled to is the bug.

0
installs

194 published skills · page 1 of 2