Frank Denis

Disclaimer: I'm one of the maintainers of Tink. I'm not sure if NaCl itself is production ready, but I'm a great fan of libsodium. If I weren't working on Tink, I'd use libsodium for my personal projects. Did you know that Frank Denis [1] the creator of libsodium is not working full time on crypto or security? He's a professional photographer. I can't figure out how he manages to single-handedly maintain such a high-profile high-quality library as a side project. We have a team of full time cryptographers and engineers working on Tink, but we've struggled a lot. We started Tink because all existing libraries that we had at Google didn't meet our requirements. Business-wise, we need an open source library that can work on all major platforms that Google products run on including web, iOS, Android, Borg and GCP. There are many Google products that need crypto integration with external partners. While we can take care of the crypto implementation on our side, we found that many partners got it wrong. It'd be very nice if they can use the same library that we're using internally. We learned very early that a single ciphersuite wouldn't work for everybody. Some would need short ciphertext. Some would need speed. Some would need FIPS certified. We want a library that can support a wide range of options. It should be easy to add new options and remove old ones. Security-wise, we found that most libraries are either too high-level or too low. The latter ask users for…

Speaking as someone who would love to see WebAssembly succeed as a cross-platform, cross-language way for me to write sandboxed plugins and CLI utilities, I do have to point out that, for out-of-browser use, WASM's MVP does regress various things: * https://00f.net/2018/11/25/webassembly-doesnt-make-unsafe-languages-sa… * https://www.usenix.org/system/files/sec20-lehmann.pdf (eg. Under WebAssembly's memory model, dereferencing NULL=0 won't lead to a segfault.)

Indeed! Lucet is a great piece of engineering. There are some very popular open-source runtimes that let you run WebAssembly server-side easily: Wasmer (Rust, with three different compilation tiers: Singlepass, Clif and LLVM), WAVM (C++. LLVM), and many more! (disclaimer: I work at Wasmer) There is some nice blogposts benchmarking them: https://00f.net/2019/10/22/updated-webassembly-benchmark/

I recommend this excellent reading, https://00f.net/2018/11/25/webassembly-doesnt-make-unsafe-languages-sa… It clarifies what “safe” means in this context.

I'm not too familiar with the state of wasm runtimes so this Frank Denis post/benchmark [0] was pretty helpful. tldr: > Are you looking for the best possible performance to build a “serverless” infrastructure? WAVM may be better a choice, combined with “snapshots” of the linear memory made after initialization, as done in the excellent FAASM. > For untrusted applications, and if you are into Rust, you may want to consider lucet and its unique ability to stop/resume/reschedule execution. > Are you looking for a one-runtime-to-rule-them-all thing for multiple components of your application, written in a variety of programming languages? wasmer will probably be the easiest to integrate. > Are you looking for a way to test the latest WebAssembly proposals? Check out wasmtime. Ditto if you need to run WebAssembly modules from Zig. wasmtime is fast, even on ARM CPUs, although I wish I could test on one of these fancy new Apple M1 machines. > Finally, if you need something simple, lightweight, that works everywhere, wasm3 is your friend. [0] https://00f.net/2021/02/22/webassembly-runtimes-benchmarks/

Also https://00f.net/2018/11/25/webassembly-doesnt-make-unsafe-languages-sa…

It depends on how you define supply chain attacks. Recently, there was an exploit discovered in an abandoned Rust package that was used by many other Rust projects, many unaware of it due to the sheer number of dependencies. Whether by negligence or malice, having a known vulnerability that permeates significant portions of the ecosystem is on the order of a supply chain attack. https://edera.dev/stories/tarmageddon Worse yet, independent research suggests that the state is arguably much worse: https://00f.net/2025/10/17/state-of-the-rust-ecosystem/ Given projects that make the claim of switching to Rust to access new contributors, it remains to be seen how many of those new contributors are capable of being retained.

WASM performance seems mostly fine for most applications [1]. Certainly better than Python or Ruby. Maybe running in the browser is a bit of a different story, given that it has to go through JS to manipulate the DOM, but I don't think this is a problem that can be solved with more developers. [1] https://00f.net/2023/01/04/webassembly-benchmark-2023/

I don't have them at hand, will post them to the wiki when I get a chance. That said there's 2 aspects to SQLite performance: compute and IO. For compute, wazero's current compiler is pretty naive, so CPU bound benchmarks will show a significant degradation vs. native. The numbers in [1] are still mostly valid: you should expect a 4x hit compared to native (mattn, less compared to modernc). A new optimizing compiler is being designed, which I expect will make this roughly on par with modernc. In terms of IO, the biggest performance limitation is the lack of good WAL support. If you're doing something IO bound in rollback journal mode with normal synchronization, performance should be comparable, because it's dominated by the number of fsyncs. But WAL offers better performance in most cases. 1: https://00f.net/2023/01/04/webassembly-benchmark-2023/

Well I think it's been pointed out, repeatedly, that wasm needs memory protection. I'm very far from the only person pointing out a lot of this btw: https://www.usenix.org/system/files/sec20_slides_lehmann.pdf https://i.blackhat.com/us-18/Thu-August-9/us-18-Lukasiewicz-WebAssembl… https://00f.net/2018/11/25/webassembly-doesnt-make-unsafe-languages-sa…

We actually have good data on this. Very little efficiency is lost in many cases - only around 14%: https://kripken.github.io/blog/wasm/2020/07/27/wasmboxc.html See also here, where wasm2c is the fastest wasm runtime: https://00f.net/2023/01/04/webassembly-benchmark-2023/ There are of course cases that can be slower, like code that depends heavily on SIMD, as wasm support for SIMD is still being improved. But in general compiling to wasm as an intermediary IR and then using an optimizing compiler can lead to very fast code.

latest benchmarks with wasm3, wasmer, wasmtime, wavm and etc: https://www.00f.net/2021/02/22/webassembly-runtimes-benchmarks

Disclaimer: I work on 1.1.1.1. You might not consider your /24 as personally identifying, but others might. The original RFC discusses these problems fairly well (https://tools.ietf.org/html/rfc7871, Privacy notice and privacy considerations). Frank Denis also wrote a good summary on ECS (https://00f.net/2013/08/07/edns-client-subnet/). There's a multitude of ways to fix this - use a whitelist of nameservers to send ECS to to avoid spraying the source prefix everywhere, encrypt the whitelisted connections, or aggregate the source prefix into a largest covering server scope (e.g. if the client is in /24 but nameserver serves the same answer for /16, then using any address in the /16 would do). We're evaluating all of them as there's different trade-offs (see https://blog.mozilla.org/futurereleases/2019/04/02/dns-over-https-doh-…

edns-client-subnet leads to a surprising number of privacy concerns. See: https://00f.net/2013/08/07/edns-client-subnet/ I find the cache timing issue particularly worrying. Cloudflare runs from 151 (and growing rapidly) locations worldwide. Without edns-client-subnet, the upstream DNS server will probably respond according to the geolocation of the Cloudflare location you're talking to -- which is probably pretty close to you, and therefore will probably produce a good outcome for you, while largely avoiding the privacy concerns.

This guy did: http://00f.net/2012/06/02/mod-pagespeed-as-a-proxy-for-your-phone/ And so did this guy: http://vincent.bernat.im/en/blog/2011-mobile-browsing-content-optimiza… You could even take mod_pagespeed and start selling your own competing optimizing proxy; it's open source. (Evil idea: run an optimizing proxy in a part of the world with very slow or expensive-per-byte internet and make money via ad insertion or replacement.)

Part 2: https://00f.net/2026/01/19/xet-intro-2/

There are some benchmarks of Cranelift-based Wasm VMs (Wasmtime) vs. LLVM-based Wasm VMs here: https://00f.net/2023/01/04/webassembly-benchmark-2023/ The (perhaps slightly exaggerated but encouraging to me at least!) money quote there is: > That’s right. The cranelift code generator has become as fast as LLVM. This is extremely impressive considering the fact that cranelift is a relatively young project, written from scratch by a very small (but obviously very talented) team. In practice anywhere from 10%-30% slower maybe is reasonable to expect. Compiler microbenchmarks are interesting because they're very "quantized": for any particular benchmark, often either you get the right transforms and achieve the correct optimized inner loop, or you don't. So the game is about getting more and more cases right and we're slowly getting there. (disclosure: I was tech lead of Cranelift in 2020-2022)