Gabriel Martorelli

Subdomain takeover, dangling cloud and DNS records, backup systems, network printers and secrets leaking out through logs and telemetry.

Bind settings, ACLs and security rules, plus vector databases: stored data that becomes credentials the moment the service is reachable.

Node.js in the renderer, custom protocols with filesystem reach, extension permissions and content scripts, and secrets still sitting in source maps.

Manifest and exported components, deep links and app links, WebView bridges, Keychain and Keystore, pinning and mobile API authentication.

Jupyter, MLflow tracking servers, GPU nodes and schedulers, MLOps trust boundaries and model weights that are also executable software.

Untrusted text that gains authority, indirect injection, tool calling versus authorization, retrieval poisoning and MCP authorization in depth.

Persistent connections few teams review, protobuf and reflection, and persisted queries: what authorization looks like after the handshake or the hash.

Object and function level authorization, fields the client should never control, deprecated versions still running and what an OpenAPI schema does not prove.

DNS rebinding, PDF generators, headless browsers, webhook senders and URL preview crawlers: server-side requests nobody wrote on purpose.

Canonicalization and encoding, LFI wrappers, image parser bugs and Zip Slip: the path the server actually opens versus the one you thought you sent.

XXE, XSLT and XPath injection, plus Java, .NET, Python pickle and PHP object injection: when stored data carries code across a trust boundary.

ORMs and JSON filters, second-order and blind SQLi, MongoDB operators as query logic, shell versus argv injection, CRLF and expression language.

Key confusion, JWK and kid injection, session lifecycle, password reset, MFA bypass, account recovery and where a passkey still falls back to a weaker channel.

redirect_uri validation, PKCE, OIDC discovery, SAML signature wrapping and metadata, dynamic client registration and device-flow phishing.

Sources and sinks that never reach the server, CSP bypass, DOM clobbering, client-side path traversal and prototype pollution on both sides of the wire.

Reflected origins with credentials, SameSite, modern CSRF against APIs, clickjacking, postMessage handlers and open redirects that carry real impact.

Host header injection, path confusion between two normalizers, trusted headers, nginx alias, Apache .htaccess, IIS handlers and server-side includes.

CL.TE and TE.CL, HTTP/2 downgrades, desync races, cache poisoning and deception, plus parameter pollution read four different ways by four parsers.

Self-hosted runners, Jenkins, dependency confusion, artifact poisoning, npm and PyPI trust, secrets in git history and Postman collections in a repo.

AWS Lambda execution roles, cross-cloud serverless, SQS consumers that trust message content, and CDN origins still reachable without the edge in front.

S3 and cross-cloud storage policy, Terraform state, Azure Key Vault, SAS tokens, HashiCorp Vault and KMS: who can read, decrypt and sign.

AWS STS AssumeRole, Azure managed identities, Entra ID, service principals, GCP impersonation and Cognito trust policies: movement without a password.

From one RBAC verb to cluster control, plus ServiceAccount tokens, registry credentials, workload identity and admission webhooks that run before a pod exists.

Capabilities, systemd units, Unix and Docker sockets, namespaces and cgroups: where root splits into pieces and where isolation actually breaks.

SeImpersonatePrivilege, service permissions, scheduled tasks, DLL search order, named pipes, UAC token filtering and COM hijacking, each with its precondition.

Forest trusts and SIDHistory, SCCM, WSUS, LDAP enumeration and the four different execution paths behind WinRM, WMI, DCOM and PsExec.

PrinterBug, PetitPotam, DFSCoerce, LLMNR and DHCPv6 spoofing, SMB signing and MachineAccountQuota: how a coerced login turns into domain access.

Kerberoasting, AS-REP roasting, gMSA, pass-the-hash, DPAPI, Credential Manager and LAPS: preconditions, validation and where impact actually grows.

Mobile API pentesting: intercepting the real API past certificate pinning, device ID as weak identity, token handling, deep links and WebView.

Secret leakage in LLM applications: system prompts, tool output, RAG authorization, cross tenant caches, logs and the model provider boundary.

Why model.pkl is code: pickle and joblib trust boundaries, PyTorch weights_only, model registries, and what safetensors and skops actually fix.

MCP servers as an attack surface: tools as executable capability, token audience binding, confused deputy problems and prompt injection with real reach.

Race conditions in web apps: the window between check and update, the single packet attack over HTTP/2, multi endpoint races and what actually fixes them.

Using BloodHound past the shortest path: collection quality, reading an edge before running anything, session volatility and Cypher queries.

SSTI from detection to impact: plaintext versus code context, engine identification, sandbox escapes, and why remote code execution is not a given.

ESC8 explained: relaying coerced NTLM authentication into the AD CS web enrollment endpoint, and why the issued certificate outlives the relay.

OAuth account takeover chains: redirect URI matching, state and PKCE bindings, account linking abuse, email as identity and Mix-Up attacks.

Business logic testing: sequence abuse, negative values, coupon and discount state machines, multi tenant checks and concurrency as a logic bug.

AWS IAM for pentesters: reading policies as relationships, sts:AssumeRole and iam:PassRole paths, permissions boundaries and resource policies.

MSSQL inside Active Directory: impersonation with EXECUTE AS, xp_cmdshell, linked server chains, the double hop problem and coerced authentication.

Kubernetes pentesting from inside a Pod: ServiceAccount identity, the RBAC verbs that matter, Secrets, pods/exec, node access and cloud identity.

AD CS past ESC1: what ESC2 through ESC8 each abuse, how Certipy groups them, and what Strong Certificate Mapping changed about older material.

Why a masked CI/CD variable is still readable by the job, how secrets leak through artifacts, shared runners and logs, and how to cut the blast radius.

Golden, Silver and Diamond Tickets compared: which key forges each one, what the PAC carries, and why krbtgt rotation has to be done twice.

GraphQL pentesting: schema discovery without introspection, resolver level authorization, aliases and batching, and query complexity limits.

The three Kerberos delegation models compared: what each one trusts, how to enumerate them and what to look for in each during a pentest.

GitHub Actions as an attack surface: pull_request_target pwn requests, GITHUB_TOKEN scope, expression injection and self hosted runner risk.

Resource-Based Constrained Delegation from the ground up: where the config lives, why write access to the target matters, and S4U2Self with S4U2Proxy.

Blind SSRF without a visible response: DNS and HTTP out of band signals, timing side channels, redirects, and what the report can actually claim.

NTLM Relay in practice: what makes a relay path viable, how SMB signing and LDAP channel binding change it, and a lab walkthrough with ntlmrelayx.

API pentesting for BOLA, BFLA and property level authorization, why two accounts are mandatory, and where object IDs hide outside the URL.

Shadow Credentials in AD: writing msDS-KeyCredentialLink to authenticate as the target through PKINIT, without ever touching its password.

Linux privilege escalation past sudo -l: SUID binaries, capabilities, cron jobs, systemd units, group membership and the Docker socket.

Kerberos for pentesters: AS-REQ, TGT, SPNs and the PAC, where AS-REP Roasting and Kerberoasting fit, and why clock skew breaks everything.

How a user controlled URL reaches cloud metadata, why IMDSv1 and IMDSv2 change the test, and how to prove impact without breaking the target.

AD CS ESC1 end to end: the four template conditions that create it, enumeration with Certipy, requesting the certificate, and how to remediate it.

JWT attacks past alg none: algorithm confusion, weak HS256 secrets, kid injection, jwk and jku abuse, and the claim checks that actually matter.

How Active Directory ACL abuse works: GenericAll, GenericWrite, WriteDACL and WriteOwner, how to find the path in BloodHound and how to validate it.