The Trail of Bits Blog
How Sui Move rethinks flash loan security
Safer cold storage on Ethereum
Subverting code integrity checks to locally backdoor Signal, 1Password, Slack, and more
Intern projects that outlived the internship
Implement EIP-7730 today
Speedrunning the New York Subway
Weaponizing image scaling against production AI systems
Marshal madness: A brief history of Ruby deserialization exploits
Trail of Bits' Buttercup wins 2nd place in AIxCC Challenge
Buttercup is now open-source!
AIxCC finals: Tale of the tape
Prompt injection engineering for attackers: Exploiting GitHub Copilot
Uncovering memory corruption in NVIDIA Triton (as a new hire)
The Unconventional Innovator Scholarship
Hijacking multi-agent systems in your PajaMAS
We built the security layer MCP always needed
Exploiting zero days in abandoned hardware
Inside EthCC[8]: Becoming a smart contract auditor
Detecting code copying at scale with Vendetect
Building secure messaging is hard: A nuanced take on the Bitchat security debate
Investigate your dependencies with Deptective
Buckle up, Buttercup, AIxCC’s scored round is underway!
Maturing your smart contracts beyond private key risk
Unexpected security footguns in Go's parsers
What we learned reviewing one of the first DKLs23 libraries from Silence Laboratories
A deep dive into Axiom’s Halo2 circuits
The Custodial Stablecoin Rekt Test
The cryptography behind passkeys
Datasig: Fingerprinting AI/ML datasets to stop data-borne attacks
Making PyPI's test suite 81% faster
Insecure credential storage plagues MCP
Deceiving users with ANSI terminal codes in MCP
How MCP servers can steal your conversation history
Jumping the line: How MCP servers can attack you before you ever use them
Kicking off AIxCC’s Finals with Buttercup
Sneak peek: A new ASN.1 API for Python
Mitigating ELUSIVE COMET Zoom remote control attacks
Introducing a new section on snapshot fuzzing for kernel-level testing in the Testing Handbook
Benchmarking OpenSearch and Elasticsearch
Continuous TRAIL
Threat modeling the TRAIL of Bits way
How Threat Modeling Could Have Prevented the $1.5B Bybit Hack
Don’t recurse on untrusted input
The $1.5B Bybit Hack: The Era of Operational Security Failures Has Arrived
Unleashing Medusa: Fast and scalable smart contract fuzzing
We’re partnering to strengthen TON’s DeFi ecosystem
The call for invariant-driven development
Preventing account takeover on centralized cryptocurrency exchanges in 2025
PyPI now supports archiving projects
Best practices for key derivation
Celebrating our 2024 open-source contributions
Auditing the Ruby ecosystem’s central package repository
35 more Semgrep rules: infrastructure, supply chain, and Ruby
Evaluating Solidity support in AI coding assistants
Attestations: A new generation of signatures on PyPI
Killing Filecoin nodes
Fuzzing between the lines in popular barcode software
A deep dive into Linux’s new mseal syscall
Auditing Gradio 5, Hugging Face’s ML GUI framework
Securing the software supply chain with the SLSA framework
A few notes on AWS Nitro Enclaves: Attack surface
Announcing the Trail of Bits and Semgrep partnership
Inside DEF CON: Michael Brown on how AI/ML is revolutionizing cybersecurity
Friends don’t let friends reuse nonces
Sanitize your C++ containers: ASan annotations step-by-step
“Unstripping” binaries: Restoring debugging information in GDB with Pwndbg
What would you do with that old GPU?
Provisioning cloud infrastructure the wrong way, but faster
“YOLO” is not a valid hash construction
We wrote the code, and the code won
Trail of Bits Advances to AIxCC Finals
Trail of Bits’ Buttercup heads to DARPA’s AIxCC
Cloud cryptography demystified: Google Cloud Platform
Our audit of Homebrew
Our crypto experts answer 10 key questions
Announcing AES-GEM (AES with Galois Extended Mode)
Trail of Bits named a leader in cybersecurity consulting services
Auditing the Ask Astro LLM Q&A app
Quantum is unimportant to post-quantum
Disarming Fiat-Shamir footguns
EuroLLVM 2024 trip report
Themes from Real World Crypto 2024
Finding mispriced opcodes with fuzzing
Understanding Apple’s On-Device and Server Foundation Models release
PCC: Bold step forward, not without flaws
Announcing the Burp Suite Professional chapter in the Testing Handbook
Exploiting ML models with pickle file attacks: Part 2
Exploiting ML models with pickle file attacks: Part 1
Announcing AI/ML safety and security trainings
Understanding AddressSanitizer: Better memory safety for your code
A peek into build provenance for Homebrew
Using benchmarks to speed up Echidna
The life and times of an Abstract Syntax Tree
Curvance: Invariants unleashed
Announcing two new LMS libraries
5 reasons to strive for better disclosure processes
Introducing Ruzzy, a coverage-guided Ruby fuzzer
Why fuzzing over formal verification?
Streamline your static analysis triage with SARIF Explorer
Read code like a pro with our weAudit VSCode extension
Releasing the Attacknet: A new tool for finding bugs in blockchain nodes using chaos testing
Secure your blockchain project from the start
DARPA awards $1 million to Trail of Bits for AI Cyber Challenge
Out of the kernel, into the tokens
Cryptographic design review of Ockam
Relishing new Fickling features for securing ML systems
How we applied advanced fuzzing techniques to cURL
When try, try, try again leads to out-of-order execution bugs
Our response to the US Army’s RFI on developing AIBOM tools
Circomspect has been integrated into the Sindri CLI
Continuously fuzzing Python C extensions
Breaking the shared key in threshold signature schemes
A few notes on AWS Nitro Enclaves: Images and attestation
Cloud cryptography demystified: Amazon Web Services
Why Windows can’t follow WSL symlinks
Master fuzzing with our new Testing Handbook chapter
Binary type inference in Ghidra
Improving the state of Cosmos fuzzing
Chaos Communication Congress (37C3) recap
Introducing DIFFER, a new tool for testing and validating transformed programs
Enhancing trust for SGX enclaves
We build X.509 chains so you don’t have to
Celebrating our 2023 open-source contributions
Our thoughts on AIxCC’s competition format
30 new Semgrep rules: Ansible, Java, Kotlin, shell scripts, and more
LeftoverLocals: Listening to LLM responses through leaked GPU local memory
Internet freedom with the Open Technology Fund
How to introduce Semgrep to your organization
Securing open-source infrastructure with OSTIF
Tag, you’re it: Signal tagging in Circom
Billion times emptiness
AI In Windows: Investigating Windows Copilot
We’ve added more content to ZKDocs
Catching OpenSSL misuse using CodeQL
Summer interns 2023 recap
A trail of flipping bits
DARPA’s AI Cyber Challenge: We’re In!
Say hello to the next chapter of the Testing Handbook!
Publishing Trail of Bits’ CodeQL queries
ETW internals for security research and forensics
How CISA can improve OSS security
Assessing the security posture of a widely used vision model: YOLOv7
Our audit of PyPI
Adding build provenance to Homebrew
The issue with ATS in Apple’s macOS and iOS
Numbers turned weapons: DoS in Osmosis’ math library
Introducing invariant development as a service
Pitfalls of relying on eBPF for security monitoring (and some solutions)
Don’t overextend your Oblivious Transfer
Security flaws in an SSO plugin for Caddy
Holy Macroni! A recipe for progressive language enhancement
Secure your Apollo GraphQL server with Semgrep
iVerify is now an independent company!
The Engineer’s Guide to Blockchain Finality
Can you pass the Rekt test?
Use our suite of eBPF libraries
A mistake in the bulletproofs paper could have led to the theft of millions of dollars
How AI will affect cybersecurity: What we told the CFTC
The future of Clang-based tooling
Announcing the Trail of Bits Testing Handbook
Fuzzing on-chain contracts with Echidna
Trail of Bits’s Response to OSTP National Priorities for AI RFI
Evaluating blockchain security maturity
What we told the CFTC about blockchain threats
Differential fuzz testing upgradeable smart contracts with Diffusc
Trail of Bits’s Response to NTIA AI Accountability RFC
Finding bugs in C code with Multi-Level IR and VAST
Trusted publishing: a new benchmark for packaging security
Real World Crypto 2023 Recap
Introducing Windows Notification Facility’s (WNF) Code Integrity
What should governments consider when getting involved with blockchain?
Typos that omit security features and how to test for them
A Winter’s Tale: Improving messages and types in GDB’s Python API
How to avoid the aCropalypse
Codex (and GPT-4) can’t beat humans on smart contract audits
Circomspect has more passes!
We need a new way to measure AI security
Reusable properties for Ethereum contracts
Escaping well-configured VSCode extensions (for profit)
Escaping misconfigured VSCode extensions
Readline crime: exploiting a SUID logic bug
cURL audit: How a joke led to significant findings
Harnessing the eBPF Verifier
Introducing RPC Investigator
Announcing a stable release of sigstore-python
Keeping the wolves out of wolfSSL
Another prolific year of open-source contributions
How to share what you’ve learned from our audits
Fast and accurate syntax searching for C and C++
What child is this?
How I gave ManticoreUI a makeover
Manticore GUIs made easy
Hybrid fuzzing: Sharpening the spikes of Echidna
Specialized Zero-Knowledge Proof failures
ABI compatibility in Python: How hard could it be?
We’re streamers now
Look out! Divergent representations are everywhere!
We sign code now
Stranger Strings: An exploitable flaw in SQLite
Porting the Solana eBPF JIT compiler to ARM64
Working on blockchains as a Trail of Bits intern
Secure your machine learning with Semgrep
It pays to be Circomspect
Magnifier: An Experiment with Interactive Decompilation
Using mutants to improve Slither
The road to the apprenticeship
Shedding smart contract storage with Slither
libmagic: The Blathering
A Typical Day as a Trail of Bits Engineer-Consultant
The Trail of Bits Hiring Process
Managing risk in blockchain deployments
Are blockchains decentralized?
Announcing the new Trail of Bits podcast
Themes from PyCon US 2022
Interactive decompilation with rellic-xref
Themes from Real World Crypto 2022
Improving the state of go-fuzz
Amarna: Static analysis for Cairo programs
The Frozen Heart vulnerability in PlonK
The Frozen Heart vulnerability in Bulletproofs
The Frozen Heart vulnerability in Girault’s proof of knowledge
Coordinated disclosure of vulnerabilities affecting Girault, Bulletproofs, and PlonK
Towards Practical Security Optimizations for Binaries
Optimizing a smart contract fuzzer
Maat: Symbolic execution made easy
Part 2: Improving crypto code in Rust using LLVM’s optnone
Part 1: The life of an optimization barrier
C your data structures with rellic-headergen
Finding unhandled errors using CodeQL
Toward a Best-of-Both-Worlds Binary Disassembler
Celebrating our 2021 Open Source Contributions
Disclosing Shamir’s Secret Sharing vulnerabilities and announcing ZKDocs
Detecting MISO and Opyn’s msg.value reuse vulnerability with Slither
What does your code use, and is it vulnerable? It-depends!
MUI: Visualizing symbolic execution with Manticore and Binary Ninja
How to choose an interesting project
Motivating global stabilization
Announcing osquery 5: Now with EndpointSecurity on macOS
All your tracing are belong to BPF
PrivacyRaven: Implementing a proof of concept for model inversion
Write Rust lints without forking Clippy
Discovering goroutine leaks with Semgrep
Solar: Context-free, interactive analysis for Solidity
A Year in the Life of a Compiler Fuzzing Campaign
Un-bee-lievable Performance: Fast Coverage-guided Fuzzing with Honeybee and Intel Processor Trace
Never a dill moment: Exploiting machine learning pickle files
The Tao of Continuous Integration
Serving up zero-knowledge proofs
Confessions of a smart contract paper reviewer
PDF is Broken: a justCTF Challenge
Breaking Aave Upgradeability
Reverie: An optimized zero-knowledge proof system
High-fidelity build instrumentation with blight
Smart (and simple) ways to prevent symlink attacks in Go
Good idea, bad design: How the Diamond standard falls short
Efficient audits with machine learning and Slither-simil
Let’s build a high-performance fuzzer with GPUs!
Osquery: Using D-Bus to query systemd data
Detecting Iterator Invalidation with CodeQL
PrivacyRaven Has Left the Nest
Graphtage: A New Semantic Diffing Tool
Using Echidna to test a smart contract library
Sinter: New user-mode security enforcement for macOS
Accidentally stepping on a DeFi lego
Contract verification made easier
Advocating for change
Upgradeable contracts made safer with Crytic
ECDSA: Handle with Care
How to check if a mutex is locked in Go
Breaking the Solidity Compiler with a Fuzzer
Detecting Bad OpenSSL Usage
Verifying Windows binaries, without Windows
Emerging Talent: Winternship 2020 Highlights
Reinventing Vulnerability Disclosure using Zero-knowledge Proofs
Bug Hunting with Crytic
Announcing the 1st International Workshop on Smart Contract Analysis
Revisiting 2000 cuts using Binary Ninja’s new decompiler
Announcing our first virtual Empire Hacking
An Echidna for all Seasons
Announcing the Zeek Agent
Financial Cryptography 2020 Recap
Real-time file monitoring on Windows with osquery
Our Full Report on the Voatz Mobile Voting Platform
Manticore discovers the ENS bug
Symbolically Executing WebAssembly in Manticore
Themes from Real World Crypto 2020
Exploiting the Windows CryptoAPI Vulnerability
Mainnet360: joint economic and security reviews with Prysm Group
64 Bits ought to be enough for anybody!
Introducing iVerify, the security toolkit for iPhone users
Announcing the Crytic $10k Research Prize
Everything You Ever Wanted To Know About Test-Case Reduction, But Didn’t Know to Ask
Security assessment techniques for Go projects
Two New Tools that Tame the Treachery of Files
Destroying x86_64 instruction decoders with differential fuzzing
How safe browsing fails to protect user privacy
Grace Hopper Celebration (GHC) 2019 Recap
Formal Analysis of the CBC Casper Consensus Algorithm with TLA+
Watch Your Language: Our First Vyper Audit
Multi-Party Computation on Machine Learning
TSC Frequency For All: Better Profiling and Benchmarking
Tethered jailbreaks are back
QueryCon 2019: A Turning Point for osquery
Crypto 2019 Takeaways
DeepState Now Supports Ensemble Fuzzing
Rewriting Functions in Compiled Binaries
Binary symbolic execution with KLEE-Native
Reverse Taint Analysis Using Binary Ninja
Wrapper’s Delight
A Day in the Life of Alessandro Gario, Senior Security Engineer
246 Findings From our Smart Contract Audits: An Executive Summary
From The Depths Of Counterfeit Smartphones
Better Encrypted Group Chat
Crytic: Continuous Assurance for Smart Contracts
Understanding Docker container escapes
Trail of Bits Named in Forrester Wave as a Leader in Midsize Cybersecurity Consulting Services
On LibraBFT’s use of broadcasts
Seriously, stop using RSA
Avoiding Smart Contract “Gridlock” with Slither
State of the Art Proof-of-Work: RandomX
Siderophile: Expose your Crate’s Unsafety
Use constexpr for faster, smaller, and safer code
Panicking the right way in Go
Creating an LLVM Sanitizer from Hopes and Dreams
Getting 2FA Right in 2019
Trail of Bits @ ICSE 2019 – Recap
Why you should go to QueryCon this week
Leaves of Hash
Announcing Manticore 0.3.0
Using osquery for remote forensics
Fuzzing Unit Tests with DeepState and Eclipser
Announcing Automated Reverse Engineering Trainings
Slither: The Leading Static Analyzer for Smart Contracts
Announcing the community-oriented osquery fork, osql
Announcing QueryCon 2019
User-Friendly Fuzzing with Sienna Locomotive
Performing Concolic Execution on Cryptographic Primitives
Fuzzing In The Year 2000
What Application Developers Need To Know About TLS Early Data (0RTT)
Symbolic Path Merging in Manticore
Fuzzing an API with DeepState (Part 2)
Fuzzing an API with DeepState (Part 1)
How McSema Handles C++ Exceptions
Empire Hacking: Ethereum Edition 2
How to write a rootkit without really trying
On Bounties and Boffins
What do La Croix, octonions, and Second Life have in common?
Fuzzing Like It’s 1989
$10,000 research fellowships for underrepresented talent
CSAW CTF Crypto Challenge: Breaking DSA
10 Rules for the Secure Use of Cryptocurrency Hardware Wallets
Return of the Blockchain Security Empire Hacking
Trail of Bits @ Devcon IV Recap
We crypto now
How contract migration works
The Good, the Bad, and the Weird
A Guide to Post-Quantum Cryptography
Slither – a Solidity static analysis framework
Introduction to Verifiable Delay Functions (VDFs)
How to Spot Good Fuzzing Research
Ethereum security guidance for all
Effortless security feature detection with Winchecksec
Protecting Software Against Exploitation with DARPA’s CFAR
Rattle – an Ethereum EVM binary analysis framework
Contract upgrade anti-patterns
Introducing windows-acl: working with ACLs in Rust
Get an open-source security multiplier
Fault Analysis on RSA Signing
You could have invented that Bluetooth attack
Optimizing Lifted Bitcode with Dead Store Elimination
Trail of Bits donates $100,000 to support young researchers through SummerCon
Announcing the Trail of Bits osquery support group
QueryCon 2018: our talks and takeaways
Manage your fleet’s firewalls with osquery
Manage Santa within osquery
Collect NTFS forensic information with osquery
State Machine Testing with Echidna
What do you wish osquery could do?
How to prepare for a security review
Vulnerability Modeling with Binary Ninja
Use our suite of Ethereum security tools
An accessible overview of Meltdown and Spectre, Part 2
“AMD Flaws” Technical Summary
Echidna, a smart fuzzer for Ethereum
2017 in review
Parity Technologies engages Trail of Bits
An accessible overview of Meltdown and Spectre, Part 1
Heavy lifting with McSema 2.0
Videos from Ethereum-focused Empire Hacking
What are the current pain points of osquery?
Announcing the Trail of Bits osquery extension repository
Securing Ethereum at Empire Hacking
How are teams currently using osquery?
Hands on the Ethernaut CTF
Trail of Bits joins the Enterprise Ethereum Alliance
Our team is growing
iOS jailbreak detection toolkit now available
Tracking a stolen code-signing certificate with osquery
Microsoft didn’t sandbox Windows Defender, so I did
An extra bit of analysis for Clemency
Magic with Manticore
Manticore: Symbolic execution for humans
A walk down memory lane
April means Infiltrate
McSema: I’m liftin’ it
The Challenges of Deploying Security Mitigations
The Smart Fuzzer Revolution
Devirtualizing C++ with Binary Ninja
Breaking Down Binary Ninja’s Low Level IL
2016 Year in Review
Let’s talk about CFI: Microsoft Edition
Meet Algo, the VPN that works
Shin GRR: Make Fuzzing Fast Again
Come Find Us at O’Reilly Security
Let’s talk about CFI: clang edition
Automated Code Audit’s First Customer
Windows network security now easier with osquery
Plug into New York’s Infosec Community
Work For Us: Fall and Winter Internship Opportunities
A fuzzer and a symbolic executor walk into a cloud
Your tool works better than mine? Prove it.
Why I didn’t catch any Pokemon today
Start using the Secure Enclave Crypto API
It’s time to take ownership of our image
2000 cuts with Binary Ninja
Empire Hacking Turns One
ProtoFuzz: A Protobuf Fuzzer
The DBIR’s ‘Forest’ of Exploit Signatures
Hacker Handle Bounty
The Problem with Dynamic Program Analysis
Apple can comply with the FBI court order
Tidas: a new service for building password-less apps
Join us at Etsy’s Code as Craft
Software Security Ideas Ahead of Their Time
Hacking for Charity: Automated Bug-finding in LibOTR
2015 In Review
Let’s Encrypt the Internet
Self-Hosted Video Chat with Tuber
Why we give so much to CSAW
Summer @ Trail of Bits
Flare-On Reversing Challenges 2015
Hardware Side Channels in the Cloud
How We Fared in the Cyber Grand Challenge
How to Harden Your Google Apps
Introducing the RubySec Field Guide
Closing the Windows Gap
Empire Hacking, a New Meetup in NYC
The Foundation of 2015: 2014 in Review
Close Encounters with Symbolic Execution (Part 2)
Close Encounters with Symbolic Execution
Speaker Lineup for THREADS ’14: Scaling Security
We’re Sponsoring the NYU-Poly Women’s Cybersecurity Symposium
Enabling Two-Factor Authentication (2FA) for Apple ID and DropBox
ReMASTering Applications by Obfuscating during Compilation
McSema is Officially Open Source!
Education Initiative Spotlight: THREADS Call for Papers
Education Initiative Spotlight: Build it Break it
Education Initiative Spotlight: CSAW Summer Program for Women
Trail of Bits Adds Mobile Security Researcher Nicholas DePetrillo to Growing Team
A Preview of McSema
We’ve Moved!
Dear DARPA: Challenge Accepted.
Trail of Bits Releases Capture the Flag Field Guide
Using Static Analysis and Clang To Find Heartbleed
Introducing Javelin
Semantic Analysis of Native Programs with CodeReason
iVerify is now available on Github
Free Ruby Security Workshop
Writing Exploits with the Elderwood Kit (Part 2)
Writing Exploits with the Elderwood Kit (Part 1)
Elderwood and the Department of Labor Hack
Ending the Love Affair with ExploitShield
Analyzing the MD5 collision in Flame