The Curious Engineer

All blogs / Rust

Sylvain Kerkour

kerkour.com

(Ab)using technology for fun & profit.

RustSecurityGo

’20’21’22’23’24’25’26
Posts
300 from 1 Jan 2020 to 28 Oct 2026
Posting
weekly (75 in the last year)
Kind
personal blog
Feed
https://kerkour.com/feed.xml

2026 63

  1. What distributed systems and end-to-end encrypted apps have in common? CRDTs and Rust!
  2. You will regret everything you say / write about AI
  3. Hybrid cryptography
  4. Malware, Backdoors and shady business practices: The secret life of connected devices
  5. Cloudflare is rewriting everything in Rust
  6. How Signal and WhatsApp deploy Rust to billions of Android and iOS devices
  7. Lies, damned lies, and Rust in the TechEmpower Web Framework Benchmarks
  8. Rust in the kernel? What about Rust without the kernel!
  9. Small and secure Docker images for Rust: Alpine vs Debian vs Scratch
  10. Rust generics: from Static to Dynamic dispatch
  11. Microcontrollers with good support for Rust
  12. Rust concurrency vs Go concurrency: stackless vs stackfull coroutines
  13. Lessons learned building an extended standard library for Rust (stdx)
  14. Fixing Rust's supply chain security: The good, the bad and the ugly
  15. Building a Plugin System for Rust: WebAssembly vs Native vs Scripting Language vs Rules Engine
  16. 7.5x faster encryption in Go with the new "simd" and "simd/archsimd" packages
  17. Building scalable backend services with Rust and PostgreSQL
  18. How Firecracker microVMs work under the hood to sandbox untrusted code and AI agents
  19. Diskless infrastructure
  20. Rust service hardening and production checklist
  21. Are 128-bit symmetric keys really secure against quantum computers?
  22. Optimize the common cases
  23. From microservice to subprocess
  24. Understanding the Rust hype for the busy developer
  25. The discourse about software craftsmanship conveniently ignores distribution
  26. Even if 90% of AI-discovered vulnerabilities are made up, it's still terrifying
  27. Momentum is why the spice continues to flow
  28. smallvec is probably one of the most underrated Rust crates
  29. Investigating why RustCrypto is slow: Deep dive into SIMD instructions and hardware acceleration
  30. S3 is a better abstraction than NFS / networked block storage
  31. High-performance Rust: Understanding and eliminating heap fragmentation
  32. Deep dive into iroh: A replacement for WireGuard or a P2P layer for your application?
  33. QUIC is much more than a replacement for TCP
  34. Hashing at 130 GB/s with XXH3, Rust and AVX-512
  35. Why stdx is not on crates.io
  36. BLAKE3 at 13GB/s on Zen 5
  37. Git commit prompt injection
  38. Announcing stdx, Rust's extended standard library: simplicity, performance and supply chain security for everyone
  39. We are in the golden age of Open Source. Surf the wave until it crashes.
  40. Async Rust: deep dive into cooperative scheduling and Tokio's architecture
  41. Keep calm and embrace (Rust) monorepos
  42. Scaling Rust codebases: Lessons learned organizing large projects and managing errors
  43. The limits of Rust, or why you should probably not follow Amazon, Cloudflare and Discord
  44. All databases will eventually be (re)written in Rust
  45. Cryptographic Right Answers: Post-Quantum Edition
  46. A Roadmap for Building an Extended Standard Library for Rust
  47. Supply chain nightmare: How Rust will be attacked and what we can do to mitigate the inevitable
  48. Bugs that the Rust compiler catches for you: The revolution of compiler-enforced correctness
  49. Building pentest devices with Rust and ESP32-C6 microcontrollers
  50. AI (and) Maximalism
  51. Rust is slowly but surely eating PostgreSQL: Deep dive into Neon, ParadeDB, PgDog and more
  52. Using Rust and Postgres for everything: patterns learned over the years
  53. Breaking SHA-2: length extension attacks in practice with Rust
  54. Is NIST's cryptography backdoored?
  55. How Rust and Its Compiler Have Revolutionized Software Engineering and Reliability
  56. How much time did you use your phone this weekend?
  57. Deploying Rust to production checklist
  58. Deep dive into Turso, the "SQLite rewrite in Rust"
  59. Elegant and safe concurrency in Rust with async combinators
  60. Full context commitment for AES authenticated encryption
  61. Let's Fucking Encrypt Everything
  62. Towards safe and modern cryptography: state of the Rust ecosystem in 2026
  63. SIMD programming in pure Rust

2025 41

  1. Smartphones are black holes
  2. (Social) media manipulation in one image
  3. Secure your Rust projects against supply chain attacks with Dev Containers
  4. Making sense of the video formats / codecs / containers mess (and what to use for long-term video archival)
  5. Encryption protects AGAINST criminals
  6. Notes on building CRDT-based local-first and end-to-end encrypted applications
  7. How CRDTs and Rust are revolutionizing distributed systems and local-first applications
  8. I no longer block AI bots on my website
  9. Entrepreneurs and athletes
  10. Like solar, Rust is inevitable
  11. It feels good to be online when most of the internet is down 😎
  12. Rust is eating the world: From embedded firmware to cross-platform applications, databases and big servers
  13. How Signal uses Rust to secure the communications of millions of people
  14. I created a Mastodon account for Pingoo
  15. I created a Bluesky account for Pingoo
  16. Building SQLite extensions in Rust
  17. vCPUs in the cloud: x86-64 vs ARM64 (aarch64)
  18. Behind the Scenes of Pingoo: Slashing Rust allocations with mimalloc and heapless to build the fastest reverse proxy
  19. Choosing between PostgreSQL and SQLite
  20. Hosting a website with automatic HTTPS and unmetered traffic for 3 € / month with Pingoo
  21. Case Study: How Proton uses Rust to build secure cross-platform applications for millions of people
  22. Implementing automatic HTTPS / TLS for Pingoo: Here is what it takes to build a secure internet
  23. Announcing Pingoo: The fast and secure Load Balancer / API Gateway with built-in service discovery, WAF and bot management (in Rust)
  24. Protecting Rust against supply chain attacks
  25. Key Derivation with ChaCha20 (or ChaCha12)
  26. ChaCha20-BLAKE3: Secure, Simple and Fast authenticated and committing encryption for any CPU
  27. Implementing a Key Encapsulation Mechanism (KEM) with X25519
  28. Rust is a great fit for the agentic era
  29. Pure Rust cryptography is better than raw performance
  30. Rust: A programming language that grows with you, your career and your projects
  31. Introduction to embedded development with Rust: Overview of the ecosystem
  32. How to securely encrypt your sensitive data with envelope encryption and KMS in Rust
  33. Announcing Markdown Ninja: Open Source alternative to Substack, Mailchimp and Netlify
  34. How to build small and secure Docker images for Rust (FROM scratch)
  35. Avoiding memory fragmentation in Rust with jemalloc
  36. How to implement cryptographically-secure API keys
  37. Creating problems to sell the solution is evil
  38. A 10x faster batch job by batching PostgreSQL inserts/updates with Rust and SQLx
  39. Writing against the global lobotomy
  40. Passwords suck. Can passkeys replace them?
  41. SHA-3 Explained: Understanding Keccak, The Sponge Construction, SHAKE, KMAC, TurboSHAKE and KangarooTwelve

2024 34

  1. Choosing a hash function for 2030 and beyond: SHA-2 vs SHA-3 vs BLAKE3
  2. The difference between Bandwidth and Traffic (ingress and egress)
  3. Comparing AWS S3 with Cloudflare R2: Price, Performance and User Experience
  4. How to solve your Cross-Origin Resource Sharing (CORS) errors by building a proxy with Cloudflare Pages and Cloudflare workers
  5. How to avoid the thundering herd problem in Go with the singleflight package
  6. How to deploy a Docker image to Scaleway serverless containers from a CI/CD pipeline (e.g. GitHub actions) using the API
  7. Leader election with PostgreSQL's advisory locks
  8. How to get the country of your visitors with Cloudflare
  9. Defending against bruteforce, credential stuffing and user enumeration attacks
  10. 5 Awesome (but less known) Rust projects
  11. Rust needs an extended standard library
  12. Programming vs Software Engineering (Rust vs Go)
  13. Towards safe and modern cryptography: Overview of the Rust ecosystem in 2024
  14. How HTTP/2 multiplexes multiple streams over a single TCP connection and how it was abused in a series of record-breaking DDoS attacks
  15. Rust Patterns: Make a reference &'static with Box::leak
  16. Rust has a HUGE supply chain security problem
  17. It's time to abolish the builder pattern in Rust
  18. Rust patterns: Don't put any code in mod.rs or lib.rs files
  19. Rust patterns: Micro SDKs
  20. Fingerprinting == Tracking?
  21. Practical countermeasures against supply chain attacks
  22. ChatGPT free
  23. Supply chain attacks and the many different ways I've backdoored your dependencies
  24. Are Cloudflare CAPTCHAs ruining the internet?
  25. Cloudflare stale-while-revalidate
  26. Distributed SQLite: Paradigm shift or hype?
  27. Optimizing SQLite for servers
  28. Plugged: Why the Apple Vision Pro is one of the biggest threats to your freedom
  29. Smokers
  30. How to generate a cryptographically secure random keys with /dev/urandom
  31. I ❤️ JWTs (JSON Web Tokens)
  32. How to get the real client IP address with Bunny.net CDN
  33. How to get the GeoIP (country) information of the client with Bunny CDN
  34. How to generate secure random encryption keys with OpenSSL

2023 37

  1. HTTP Caching: ETag vs Last-Modified headers
  2. Understanding Cloudflare's CF-Cache-Status Header
  3. Momentum and Emptiness
  4. How to update your local Go toolchain in 1 command with Go 1.21
  5. How to publish a Docker image to the GitHub Container Registry (ghcr.io) from GitHub Actions
  6. Why cloud bandwidth is so obscenely expensive and what you can do about that
  7. Announcing Cloudflare for Speed and Security
  8. The Cloudflare Book
  9. How to bypass Cloudflare and how to protect your websites
  10. How to download a large file in parallel (with aria2c)
  11. What are Autonomous Systems and why they matter (a lot) for your security
  12. How to copy files from a Docker container to the host
  13. How to use SHA-256 instead of SHA-1 as Git's hashing algorithm
  14. How to add one or more fields when marshalling a struct to JSON in Go
  15. Derive secure keys in Go with HKDF and SHA256
  16. Check if an IP address is IPV4 or IPV6 in Go
  17. How to format and prettify curl JSON output
  18. How to block outbound network and internet access for a Docker container
  19. Legalizing spyware. What can go wrong?
  20. Nobody cares about the metaverse. Neurotechnology is the end game of AR/VR headsets.
  21. Links of the week #2023-22
  22. How To Generate Secure Ed25519 SSH Keys
  23. Links of the week #2023-21
  24. How to generate a SHA256 HMAC in Go
  25. Fast hashing: It's not that simple
  26. How to zip and unzip files in Go
  27. Links of the week #2023-11
  28. Apple advanced data protection: A game-changer for privacy?
  29. Links of the week #2023-10
  30. Links of the week #2023-09
  31. Links of the week #2023-08
  32. Links of the week #2023-06
  33. Links of the week #2023-05
  34. Links of the week #2023-04
  35. Links of the week #2023-03
  36. Links of the week #2023-02
  37. Links of the week #2023-01

2022 22

  1. Links of the week #2022-51
  2. How to Use Robots.txt to Allow or Disallow Everything
  3. Links of the week #2022-47
  4. Links of the week #2022-46
  5. Links of the week #2022-45
  6. Links of the week #2022-44
  7. Links of the week #2022-43
  8. Links of the week #2022-42
  9. Links of the week #2022-41
  10. Links of the week #2022-40
  11. When to vendor (or not) your dependencies in Rust
  12. How to create an encrypted zip file with a password
  13. Learning Rust: The derive attribute
  14. How to rename multiple files in bash and remove a given prefix or suffix
  15. Links of the week #2022-39
  16. How to use OpenSSL to encrypt and decrypt files
  17. Public Toilets and Social Credit
  18. Multithreading in Rust
  19. Links of the week #2022-37
  20. Learn Rust by implementing a SHA-1 hash cracker
  21. Links of the week #2022-36
  22. iPhone = Privacy?

2021 2

  1. Continuous Learning
  2. Black Hat Rust

2020 3

  1. Apache License v2.0
  2. GNU Affero General Public License (AGPL) v3.0
  3. Hire Me - Sylvain Kerkour

Undated 98

  1. Urgent important archived
  2. Rust async combinators
  3. Links of the week 2022 35
  4. Diminishing returns knowledge
  5. Neuroplasticity and spaced repetition
  6. Rust combinators
  7. Links of the week 2022 34
  8. Too many tabs
  9. Why you need a knowledge base
  10. Top links of the week 2022 33
  11. Fisherman
  12. Denial of wallet attacks the new ddos
  13. Advanced shellcode in rust
  14. Rust projects maintenance and supply chain security
  15. Web application with rust and webassembly
  16. When to use serverless
  17. Zip bomb
  18. Rust github actions ci cd
  19. Optimize rust binary size
  20. Bitsquatting attack generator in rust
  21. Evil twin attack
  22. Rust crawler javascript single page application headless browser
  23. Programming languages are platforms
  24. Rust crawler json api
  25. Ubuntu linux automatic updates with unattended upgrades
  26. Rust crawler scraping and parsing html
  27. Npm install vs npm ci
  28. Rust crawler implementation
  29. Supply chain attacks and backdoored dependencies
  30. Rust crawler synchronization atomic types barrier
  31. Rust axum hostname router
  32. Rust crawler associated types
  33. Rust fearless concurrency
  34. Rust cross compilation
  35. Why not rust
  36. Rust is minimalist
  37. Rust functional programming
  38. Rust mental models
  39. End to end encryption key exchange cryptography rust
  40. Alignment
  41. Rust web framework 2022
  42. Rust background jobs
  43. End to end encryption domain separation cryptography
  44. Rust error handling
  45. Entropy is fatal
  46. Indispensable rust features to learn
  47. Rust web application clean architecture
  48. Csrf
  49. Rust file encryption chacha20poly1305 argon2
  50. Secure programming with vscode dev containers
  51. Rust read file
  52. Rust file encryption
  53. Book self publishing pandoc
  54. Rust position independent shellcode
  55. Rust crate backdoor
  56. Rust enum to string
  57. Rust symmetric encryption aead benchmark
  58. Rust default environment variables
  59. Signatures modern end to end encryption
  60. Fight climate change as a technologist
  61. Rust static site generator
  62. Rust reproducible cross compilation with docker
  63. Freedom the core value of hackers
  64. Go http long polling
  65. Engineer vs entrepreneur mindset
  66. Rust http long polling
  67. Shellcode in rust
  68. Why rust for offensive security
  69. Rust job queue with postgresql
  70. Framing
  71. Rust import crate from git
  72. Bullshit jobs
  73. Rust cryptography ecosystem
  74. Rust how to sort a vector
  75. Rust large cargo workspace
  76. Rust string to int and int to string
  77. Overthinking
  78. Rust fast port scanner
  79. High performance rust with sqlite
  80. The foobar challenge google secret hiring program
  81. Deploy rust on heroku with docker
  82. Http security headers
  83. Rust development workflow
  84. Rust worker pool
  85. Rust in production 2021
  86. Rust execute from memory
  87. Rust send email
  88. Rust for web development 2 years later
  89. The unusual way im funding my open source work
  90. Announcing opensourceweekly org
  91. 2019 december update
  92. Bloom whats next
  93. Bloom a free and open source google
  94. Bloom un google libre et open source
  95. The just cause and the infinite game
  96. Logging
  97. Cut the bullshit
  98. Introduction au reverse engineering android