Trail of Bits

Patch code with conditional compilation to overcome checksums, global state, and validation barriers during fuzzing.

Analyzes smart contract codebases against Trail of Bits best practices, generating documentation and security recommendations.

Diagnose and fix Claude in Chrome MCP extension connectivity issues and native host conflicts.

Scan Substrate/FRAME pallets for 7 critical vulnerabilities: arithmetic overflow, panic DoS, weight miscalculation, unsafe storage writes, unsigned validation gaps, bad randomness, and origin checks.

Interpret Culture Index behavioral profiles, team composition, burnout risk, and hiring fit using trait distance analysis and survey-vs-job comparison.

Perform risk-focused security analysis of code changes with blast radius calculation, test coverage assessment, and comprehensive markdown reports.

Create production-quality Semgrep rules for detecting security vulnerabilities and code patterns with mandatory testing and validation.

Measure code coverage during fuzzing to assess harness effectiveness and identify fuzzing blockers.

Configure Python projects with uv, ruff, and ty for linting, formatting, and type checking.

Run parallel Semgrep static analysis with automatic language detection, Pro support, and merged SARIF output.

Configure and deploy AddressSanitizer to detect buffer overflows and memory corruption bugs during C/C++ fuzzing campaigns.

Write effective fuzzing harnesses across C++, Rust, and other languages to maximize code coverage and bug detection.

Annotates codebases with unit and dimension comments to prevent arithmetic bugs in financial and scientific code.

Safely analyzes and cleans up local git branches and worktrees with user confirmation gates.

Validate cryptographic implementations against Google's test vectors for known attacks and edge cases.

Scans TON smart contracts for critical security vulnerabilities in FunC code including sender validation, integer overflow, and gas handling issues.

Scans Cosmos SDK blockchains for 9 consensus-critical vulnerabilities including non-determinism and rounding errors.

Iteratively review and fix Claude Code skill quality issues using automated cycles until standards met.

Build custom fuzzers using modular LibAFL library for advanced security testing.

Identify dependencies at heightened risk of exploitation or takeover by analyzing supply chain attack surface.

Guide design and structuring of multi-step Claude Code workflow skills with decision trees and subagent delegation.

Parse, filter, deduplicate, and convert static analysis results from SARIF files into actionable security findings.

Pause and ask targeted questions to eliminate ambiguity before implementing work.

Audit GitHub Actions workflows for prompt injection vulnerabilities in AI agent integrations using static analysis.

Use authenticated gh CLI for GitHub operations instead of unauthenticated curl requests.

Assess codebase maturity using Trail of Bits' 9-category framework with evidence-based ratings and actionable recommendations.

Prepare codebases for security audits using Trail of Bits checklist: set goals, run static analysis, increase test coverage, remove dead code, and generate documentation.

Scan Cairo/StarkNet smart contracts for 6 critical vulnerabilities including arithmetic overflow, L1-L2 messaging, and signature replay attacks.

Execute Trail of Bits' 5-step secure development workflow: run Slither scans, check special features, generate security diagrams, document properties, and analyze manual review areas.

Analyze and parse DWARF debug information (v3-v5) from binaries using specialized tools and standard verification workflows.

Diagnose and triage Buttercup CRS pod failures, cascades, and resource pressure using kubectl commands and log analysis patterns.

Port existing Semgrep security rules to new target languages with AST analysis, test-first validation, and applicability verification.

Audit cryptographic code for timing vulnerabilities that leak secrets through execution time variations.

Find similar vulnerabilities across codebases using pattern-based analysis with CodeQL and Semgrep after identifying an initial bug.

Author high-performance malware detection rules using YARA-X with optimized string selection, false positive reduction, and platform-specific patterns.

Detects missing zeroization of sensitive data in C/C++/Rust code with assembly-level and compiler optimization analysis.

Perform line-by-line code analysis to build deep architectural understanding before vulnerability discovery.

Scans Algorand smart contracts for 11 critical vulnerabilities including rekeying attacks and access control issues.

Scans Solana programs for 6 critical vulnerabilities including CPI, PDA, and signer validation issues.

Detects timing side-channel vulnerabilities in cryptographic code implementations.

Identifies state-changing entry points in smart contracts for security auditing across multiple languages.

Guides property-based testing across languages and smart contracts for stronger test coverage.

Runs external LLM code reviews using OpenAI Codex or Google Gemini CLI on code changes.

Fuzz Rust code using cargo-fuzz with libFuzzer backend and integrated sanitizer support.

Use libFuzzer to coverage-guided fuzz C/C++ projects compiled with Clang for security vulnerabilities.

Fuzz Ruby code and C extensions using coverage-guided fuzzing to detect memory corruption and undefined behavior.

Extract and search HTTP traffic from Burp Suite project files using regex patterns on headers, bodies, and audit findings.

Generates minimal allowlist-based Seatbelt sandbox profiles to isolate and restrict macOS applications with defense-in-depth access controls.

Detect fail-open vulnerabilities where apps run insecurely with missing or weak default configuration instead of crashing safely.

Verifies blockchain code implements exactly what specifications define, identifying gaps between documentation and implementation with evidence-based findings.

Generates production-ready devcontainer configurations with Claude Code, language-specific tooling, and persistent volumes.

Analyze token implementations and integrations for ERC20/ERC721 conformity, detect 24+ weird token patterns, assess security risks.

Systematically verifies suspected security bugs to distinguish TRUE POSITIVES from FALSE POSITIVES with documented evidence.

Identifies error-prone APIs, dangerous configurations, and security footguns that enable developer misuse.

Create domain-specific token dictionaries to guide fuzzers toward deeper code paths in parsers and protocols.

Scans codebases for security vulnerabilities using interprocedural data flow and taint tracking across 8 languages.