Undefined Behavior in the STL - Lecture
Explore undefined behavior in C++ STL, its dangers, and presence in containers and algorithms. Learn protective measures and understand its purposeful introduction.
Memory-Safe C++ - Addressing Common Vulnerabilities
Explore memory-safe C++ with a new compiler and runtime that detects vulnerabilities without source code changes. Learn static analysis techniques and runtime checks for enhanced software security.
Building a Browser Rendering Engine in Rust - The Servo Project
Explore the evolution of Servo, a web rendering engine built in Rust, and discover how its memory safety and concurrent design are revolutionizing browser technology and web standards implementation.
Compile-Time Validation in C++ Programming
Master advanced compile-time validation techniques in C++ to enhance code safety and reliability through functional programming approaches, unit testing, and upcoming C++26 reflection features.
Bringing Memory Safety to Time Critical Embedded Systems for Automotive and Industrial Systems
Explore memory safety solutions for time-critical embedded systems, covering deterministic garbage collection, Rust, Realtime Java, and OSGi implementations in automotive and industrial applications.
RustSan - Retrofitting AddressSanitizer for Efficient Sanitization of Rust
Discover how RustSan enhances memory error detection in Rust programs through efficient sanitization techniques, improving performance while maintaining robust security guarantees for unsafe code blocks.
MetaSafe: Compiling for Protecting Smart Pointer Metadata to Ensure Safe Rust Integrity
Discover how MetaSafe protects Rust's smart pointer metadata through compiler extensions, ensuring memory safety in safe Rust while maintaining low performance overhead.
Don't Waste My Efforts: Pruning Redundant Sanitizer Checks by Developer-Implemented Type Checks
Discover how T-PRUNIFY optimizes type confusion detection in C++ programs by identifying and leveraging developer-implemented type checks, significantly reducing runtime overhead while maintaining security.
BUDAlloc: Defeating Use-After-Free Bugs by Decoupling Virtual Address Management from Kernel
Discover how BUDAlloc improves memory safety by detecting use-after-free bugs through virtual address management separation, offering better performance and reduced memory overhead compared to existing solutions.
A Binary-level Thread Sanitizer - Why Sanitizing on the Binary Level is Hard
Explore the challenges and solutions of binary-level thread sanitization through BINTSAN, a novel approach for detecting data races in Linux x86-64 targets without source code access.
What IF Is Not Enough? Fixing Null Pointer Dereference with Contextual Check
Discover how CONCH improves null pointer dereference fixes by incorporating contextual checks, achieving 85%+ patch accuracy through innovative intraprocedural and interprocedural analysis techniques.
Practical Tips for Safer C++ - Writing Bug-Free and Efficient Code
Discover practical strategies for writing safer, more reliable C++ code without compromising performance, featuring expert techniques for bug detection and prevention in everyday programming.
Exploiting Android's Hardened Memory Allocator - Security Analysis and Exploitation Techniques
Discover techniques for exploiting Scudo, Android's memory allocator, through an analysis of security measures and demonstration of new exploitation methods for gaining arbitrary memory write access.
On the Effectiveness of Control-Flow Integrity in Practice - A Systematic Overview
Explore the real-world effectiveness of Control-Flow Integrity protection across Android and Windows systems, revealing critical gaps between research advances and actual deployment in practice.
Not Quite Write: On the Effectiveness of Store-Only Bounds Checking
Explore the security limitations of store-only bounds checking in C/C++ code, examining bypass vulnerabilities and potential defenses for compiler-based memory safety enforcement.
C++'s Next Decade - The Future of Programming Language Evolution
Explore C++'s future trajectory with insights into compile-time reflection, memory safety improvements, and language simplification efforts that promise to revolutionize development practices over the next decade.
Black Hat USA 2025
Black Hat USA 2025
Black Hat Asia 2024
Black Hat Asia 2024
Black Hat Europe 2023
Black Hat Europe 2023
Black Hat Asia 2025
Black Hat Asia 2025
Black Hat Europe 2024
Black Hat Europe 2024