# ImperialViolet

Published articles for ImperialViolet.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Proof automation in a language

DevFeed: [Proof automation in a language](<https://devfeed.tech/articles/proof-automation-in-a-language-135925.md>)

Original publisher: [Read original article](<http://www.imperialviolet.org/2026/11/15/proofauto2.html>)

Author: Adam Langley

Published: 2026-11-15T00:00:00Z

Content type: article

Language: en

Sources: [ImperialViolet](<https://devfeed.tech/sources/imperialviolet.md>)

Topics: [Lean](<https://devfeed.tech/topics/lean.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>)

Tags: [automation](<https://devfeed.tech/tags/automation.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [design](<https://devfeed.tech/tags/design.md>), [functional](<https://devfeed.tech/tags/functional.md>), [language](<https://devfeed.tech/tags/language.md>), [local](<https://devfeed.tech/tags/local.md>), [mutation](<https://devfeed.tech/tags/mutation.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [python](<https://devfeed.tech/tags/python.md>), [quality](<https://devfeed.tech/tags/quality.md>), [semantics](<https://devfeed.tech/tags/semantics.md>), [software](<https://devfeed.tech/tags/software.md>), [tradeoffs](<https://devfeed.tech/tags/tradeoffs.md>)

### AI overview

The experimental language combines mutable value semantics, contracts, refinement types, and literate programming to make code easier to reason about and verify with proof automation. Its restricted references are intended to reduce aliasing complexity and enable translation to Lean without separation logic; contracts specify behavior such as strict DER tag parsing, so readers can rely on a function's guarantees without inspecting its body. Arithmetic overflow, casts, indices, invariants, postconditions, and termination generate verification conditions. Z3 and cvc5 propose results, but Lean checks proofs; an LLM can write manual Lean proofs when automation times out. The tradeoff is substantial compute: the DER example produces 149 conditions, checks run at roughly 10 lines per second, and rechecking medium programs can take hours. The compiler front end and LLVM translation remain trusted parts of the system.

### Source excerpt

As I wrote previously, we have proof automation now. Given that fact, I think a very timely question is: how can we use it to improve software quality? The same machines that can write these proofs can also write large amounts of code. So an adjacent question is: how can we use them to improve software understandability? It would be a mistake to start off afresh on those problems because there have been a lot of ideas in programming language design over the decades. The viability of ideas shifts as the underlying cost structures change, so things that didn't take off at the time might suddenly make a lot more sense. Still, language design involves a lot of tradeoffs, and features sometimes interact in surprising ways, so a lot of the work involves mixing some interesting-seeming ingredients together, baking, and asking "what is this? Is this a cake?". So I wanted to give a taste of some of the ingredients that I'm thinking about at the moment, and of the result. Ingredients Mutable Value Semantics Value semantics roughly says that you can't observe mutations to one variable through a different name. Value semantics are great for reasoning locally about code as, without them, you're constantly unsure what non-local effects might be happening. When you work in a language, you instinctively know when it's using value semantics and when it's using reference semantics. Take Python: x = [1] y = x y[0] = 2 print(x) You likely know that that prints [2]. (Although if you write the same program in C++ with std::vector it prints [1]! There's no cross-language norm for this.) Over the span of four lines of code, this is irrelevant. But as the scope of the sharing increases, so does the mental complexity. If you want to be able to jump into a bit of code and understand what it's doing, knowing that there is no such aliasing is a huge boon. Functional programming resolves this by eliminating mutation: if there's no mutation then you certainly can't observe mutations via a differe

## We have proof automation now

DevFeed: [We have proof automation now](<https://devfeed.tech/articles/we-have-proof-automation-now-36616.md>)

Original publisher: [Read original article](<http://www.imperialviolet.org/2026/07/26/zstd-lean.html>)

Author: Adam Langley

Published: 2026-07-26T00:00:00Z

Content type: article

Language: en

Sources: [ImperialViolet](<https://devfeed.tech/sources/imperialviolet.md>)

Topics: [Lean](<https://devfeed.tech/topics/lean.md>), [Programming Language Type Systems](<https://devfeed.tech/topics/programming-language-type-systems.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [automation](<https://devfeed.tech/tags/automation.md>), [encoding](<https://devfeed.tech/tags/encoding.md>), [invariants](<https://devfeed.tech/tags/invariants.md>), [lean](<https://devfeed.tech/tags/lean.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [type-system](<https://devfeed.tech/tags/type-system.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

The author reports that several LLMs automatically proved universal properties of a Lean implementation of Zstandard's FSE table construction in about 20 minutes, with the proofs type-checking and no `sorry`s. The work required changing code that used `Id.run`, which was harder for the proof machinery. The author argues that LLMs may reduce the proof effort that has made dependently typed programming impractical, while stressing that larger systems may scale poorly and Lean's toy decoder ran 10x slower than `zstd`. An attempt to prove equivalence between optimized AArch64 assembly and Lean code worked for tiny functions, but the repository's popcount example exceeded the author's system memory and attempts to scale further failed.

### Source excerpt

I've long had a soft spot for dependently-typed languages like Coq Rocq and Lean. They offer the possibility of a type system capable of encoding and enforcing arbitrarily subtle invariants. The sort of thing that, in regular languages, ends up (at best) as a comment, and which quickly gets lost as the size of the team grows. Then you get subtle misunderstandings and components that don't quite fit together. It's often the case that those components have grown to a sufficient size that, when the problem is noticed, aligning either of them is a wearying prospect. Perhaps, say dependent types seductively, you could write those invariants formally and have a machine check them. (p.s. Coq changed its name! I remember many years ago at a Coq conference in Princeton, I tried suggesting that, in an English-speaking world, having a programming language called Coq was an impediment. I don't think the audience agreed at the time. I also joked that many of the talks there sounded like a speech by Tyrion Lannister, there being so many Coqs and Hoares. A joke that was hilarious and timely, even though it fell completely flat, coming as it did before the final season of that show and our collective memory-holing of it.) The problem has always been that with great type-system power comes great proof effort. I can certainly attest to entire days spent proving really quite simple things. Doing proofs is actually quite fun: it's challenging, interactive, and there's a clear goal. But gosh, does it take a lot of time, especially if, like me, you don't know what you're doing. There's also the periodic, galling experience, at the end of many hours of effort, where you realise that the goal that you're trying to prove is, in fact, false. The classic result here is the retrospective from the seL4 effort that found that, even though the project was large enough for the engineers to develop considerable experience, they spent about 10 times as much time proving as they did designing and imp

## TRMNL

DevFeed: [TRMNL](<https://devfeed.tech/articles/trmnl-36615.md>)

Original publisher: [Read original article](<http://www.imperialviolet.org/2025/07/27/trmnl.html>)

Author: Adam Langley

Published: 2025-07-27T00:00:00Z

Content type: article

Language: en

Sources: [ImperialViolet](<https://devfeed.tech/sources/imperialviolet.md>)

Topics: [smartdevices](<https://devfeed.tech/topics/smartdevices.md>), [JSON](<https://devfeed.tech/topics/json.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [3D](<https://devfeed.tech/topics/3d.md>), [webservice](<https://devfeed.tech/topics/webservice.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>)

Tags: [3d-printed](<https://devfeed.tech/tags/3d-printed.md>), [battery](<https://devfeed.tech/tags/battery.md>), [calendar](<https://devfeed.tech/tags/calendar.md>), [cloud-run](<https://devfeed.tech/tags/cloud-run.md>), [community](<https://devfeed.tech/tags/community.md>), [custom](<https://devfeed.tech/tags/custom.md>), [display](<https://devfeed.tech/tags/display.md>), [e-ink](<https://devfeed.tech/tags/e-ink.md>), [e-ink-display](<https://devfeed.tech/tags/e-ink-display.md>), [events](<https://devfeed.tech/tags/events.md>), [firmware](<https://devfeed.tech/tags/firmware.md>), [flash](<https://devfeed.tech/tags/flash.md>), [go](<https://devfeed.tech/tags/go.md>), [http](<https://devfeed.tech/tags/http.md>), [image](<https://devfeed.tech/tags/image.md>), [json](<https://devfeed.tech/tags/json.md>), [liquid](<https://devfeed.tech/tags/liquid.md>), [magnets](<https://devfeed.tech/tags/magnets.md>), [microcontroller](<https://devfeed.tech/tags/microcontroller.md>), [network](<https://devfeed.tech/tags/network.md>)

### AI overview

TRMNL combines an 800x600, 1-bit e-ink display with a sleeping microcontroller, yielding a reported battery life of six months or more. Its standard firmware fetches an image and sleep duration from a server over Wi-Fi; users can instead flash custom firmware or point the standard firmware at a custom HTTP server. The default service supports tiled layouts and private plugins that obtain data by polling a URL or receiving a webhook, with Liquid templates for rendering. The author used a Go program on Cloud Run to turn the family calendar into data for a fridge display. The main friction was coordinating device sleep and tile refresh schedules, which could leave the wrong day displayed. The author also notes an extra $20 charge for the Developer Edition and considers the device somewhat expensive for a neat but nonessential gadget.

### Source excerpt

The TRMNL is an 800x600, 1-bit e-ink display connected to a battery and a microcontroller, all housed in a nice but unremarkable plastic case. Because the microcontroller spends the vast majority of the time sleeping, and because e-ink displays don't require power unless they're updating, the battery can last six or more months. It charges over USB-C. When the microcontroller wakes up, it connects to a Wi-Fi network and communicates with a pre-configured server to fetch an 800x600 image to display, and the duration of the next sleep. You can flash your own firmware on the device, or point the standard firmware at a custom server. The company provides an example server, although you can implement the (HTTP-based) protocol in whatever way you wish. I considered running my own server, but thought I would give the easy path a try first to see if it would suffice. The default service lets you split the display into several tiles, and there are a number of pre-built and community-built things that can display in each. None of them worked well for me, but that's okay because you can create your own private ones. They get data either by polling a given URL, or by having data posted to a webhook. The layout is rendered using the Liquid templating system, which I had not used before, but it's reasonably straightforward. I wrote a Go program hosted on Cloud Run which fetches the family shared calendar and converts events from the next week into a JSON format designed to make it trivial to render in the templating system. With a 3D-printed holder, super glue, and some magnets, it's now happily stuck to the fridge where it displays the current date and the family events for the next week. The most awkward part of the default service is managing the refreshes. The device has a sleep schedule, and so do the tiles, which are only updated periodically. So the combination can easily leave the wrong day showing. It would be helpful if the service told you when the device would next up

## Continuous Glucose Monitoring

DevFeed: [Continuous Glucose Monitoring](<https://devfeed.tech/articles/continuous-glucose-monitoring-36614.md>)

Original publisher: [Read original article](<http://www.imperialviolet.org/2025/06/29/cgm.html>)

Author: Adam Langley

Published: 2025-06-29T00:00:00Z

Content type: opinion

Language: en

Sources: [ImperialViolet](<https://devfeed.tech/sources/imperialviolet.md>)

Topics: [data](<https://devfeed.tech/topics/data.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>), [App](<https://devfeed.tech/topics/app.md>), [Android](<https://devfeed.tech/topics/android.md>), [iphone](<https://devfeed.tech/topics/iphone.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [app](<https://devfeed.tech/tags/app.md>), [data](<https://devfeed.tech/tags/data.md>), [iphone](<https://devfeed.tech/tags/iphone.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [technology](<https://devfeed.tech/tags/technology.md>)

### AI overview

A personal review of over-the-counter continuous glucose monitoring. The author describes the sensor, its reading and transmission intervals, phone requirements, app experience, and physical application, based mainly on testing with an iPhone.

### Source excerpt

Continuous glucose monitoring has been a thing for a while. It's a probe that sits just inside your body and measures blood glucose levels frequently. Obviously this is most useful for type 1 diabetics, who need to regulate their blood glucose manually. (At this point, I would be amiss not to give a nod to the book Systems Medicine, which I think most readers would find fascinating. I can't judge whether it's correct or not, but it is a delightful exploration of a bunch of maladies from the perspective of differential equations.) But CGMs have been both expensive and prescription-only. And I am not a diabetic, type 1 or otherwise. But technology and, more importantly, regulation have apparently marched on, and even in America I can now buy a CGM for $50 that lasts for two weeks, over the counter. So CGM technology is now available to the mildly curious, like me. The device itself looks like a thick guitar pick, and it comes encased inside a much larger lump of plastic that has a pretty serious-looking spring inside. It takes readings every 5 minutes but only transmits every 15 minutes. You need a phone to receive the data and, if the phone is not nearby, it will buffer some number of samples and catch up when it can. The instructions say to keep the phone nearby at all times, so I didn't test how much it will buffer beyond an hour or so. I've got both an Android and an iPhone, but for this the iPhone was a more convenient device. So everything following probably applies to both ecosystems, but I've only tested it in one. The app is well made, although you can feel the lawyers & regulators hovering over every part of it. It gives you instructions about how to "install" the sensor, which you do by holding the big lump of plastic with the spring over a suitable spot on your body and then pressing the button. It's not a large needle, but it's not trivial either. There is a soupçon of cyberpunk about applying it to yourself in the bathroom but, honestly, my first thought

## A symmetric-key approach to post-quantum Web PKI

DevFeed: [A symmetric-key approach to post-quantum Web PKI](<https://devfeed.tech/articles/let-s-kerberos-36612.md>)

Original publisher: [Read original article](<http://www.imperialviolet.org/2024/04/07/letskerberos.html>)

Author: Adam Langley

Published: 2024-04-07T00:00:00Z

Content type: opinion

Language: en

Sources: [ImperialViolet](<https://devfeed.tech/sources/imperialviolet.md>)

Topics: [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Post-quantum cryptography](<https://devfeed.tech/topics/post-quantum-cryptography.md>), [Encryption](<https://devfeed.tech/topics/encryption.md>), [TLS (Transport Layer Security)](<https://devfeed.tech/topics/tls.md>), [public key](<https://devfeed.tech/topics/public-key.md>), [Security, Privacy and Abuse Prevention](<https://devfeed.tech/topics/security-privacy-and-abuse-prevention.md>), [kerberos](<https://devfeed.tech/topics/kerberos.md>)

Tags: [cryptography](<https://devfeed.tech/tags/cryptography.md>), [dns](<https://devfeed.tech/tags/dns.md>), [don-t](<https://devfeed.tech/tags/don-t.md>), [kerberos](<https://devfeed.tech/tags/kerberos.md>), [post-quantum](<https://devfeed.tech/tags/post-quantum.md>), [public](<https://devfeed.tech/tags/public.md>), [public-key](<https://devfeed.tech/tags/public-key.md>), [tls](<https://devfeed.tech/tags/tls.md>)

### AI overview

The article proposes using DNS records and shared symmetric keys with multiple certificate authorities to help authenticate a Kyber key agreement between a client and server. It notes that initial public-key connections to the authorities would still require large post-quantum signatures and raises privacy and policy concerns because authorities could observe which servers clients contact.

### Source excerpt

(I think this is worth pondering, but I don't mean it too seriously--don't panic.) Are the sizes of post-quantum signatures getting you down? Are you despairing of deploying a post-quantum Web PKI? Don't fret! Symmetric cryptography is post-quantum too! When you connect to a site, also fetch a record from DNS that contains a handful of "CA" records. Each contains: a UUID that identifies a CA ECA-key(server-CA-key, AAD=server-hostname) A key ID so that the CA can find "CA-key" from the previous field. "CA-key" is a symmetric key known only to the CA, and "server-CA-key" is a symmetric key known to the server and the CA. The client finds three of these CA records where the UUID matches a CA that the client trusts. It then sends a message to each CA containing: ECA-key'(client-CA-key) -- i.e. a key that the client and CA share, encrypted to a key that only the CA knows. We'll get to how the client has such a value later. A key ID for CA-key'. Eclient-CA-key(client-server-key) -- the client randomly generates a client-server key for each CA. The CA record from the server's DNS. The hostname that the client is connecting to. The CA can decrypt "client-CA-key" and then it can decrypt "server-CA-key" (from the DNS information that the client sent) using an AAD that's either the client's specified hostname, or else that hostname with the first label replaced with *, for wildcard records. The CA replies with Eserver-CA-key(client-server-key), i.e. the client's chosen key, encrypted to the server. The client can then start a TLS connection with the server, send it the three encrypted client-server keys, and the client and server can authenticate a Kyber key-agreement using the three shared keys concatenated. Both the client and server need symmetric keys established with each CA for this to work. To do this, they'll need to establish a public-key authenticated connection to the CA. So these connections will need large post-quantum signatures, but that cost can be amortised over

## Chrome support for passkeys in iCloud Keychain

DevFeed: [Chrome support for passkeys in iCloud Keychain](<https://devfeed.tech/articles/chrome-support-for-passkeys-in-icloud-keychain-36611.md>)

Original publisher: [Read original article](<http://www.imperialviolet.org/2023/10/18/icloudkeychain.html>)

Author: Adam Langley

Published: 2023-10-18T00:00:00Z

Content type: release

Language: en

Sources: [ImperialViolet](<https://devfeed.tech/sources/imperialviolet.md>)

Topics: [Google Chrome](<https://devfeed.tech/topics/google-chrome.md>), [Passkeys](<https://devfeed.tech/topics/passkeys.md>), [WebAuthn](<https://devfeed.tech/topics/webauthn.md>), [macOS](<https://devfeed.tech/topics/macos.md>)

Tags: [account](<https://devfeed.tech/tags/account.md>), [api](<https://devfeed.tech/tags/api.md>), [apple](<https://devfeed.tech/tags/apple.md>), [browsers](<https://devfeed.tech/tags/browsers.md>), [chrome](<https://devfeed.tech/tags/chrome.md>), [credentials](<https://devfeed.tech/tags/credentials.md>), [devices](<https://devfeed.tech/tags/devices.md>), [google](<https://devfeed.tech/tags/google.md>), [google-password-manager](<https://devfeed.tech/tags/google-password-manager.md>), [icloud](<https://devfeed.tech/tags/icloud.md>), [ios](<https://devfeed.tech/tags/ios.md>), [keychain](<https://devfeed.tech/tags/keychain.md>), [macos](<https://devfeed.tech/tags/macos.md>), [metadata](<https://devfeed.tech/tags/metadata.md>), [passkey](<https://devfeed.tech/tags/passkey.md>), [passkeys](<https://devfeed.tech/tags/passkeys.md>), [password-manager](<https://devfeed.tech/tags/password-manager.md>), [permission](<https://devfeed.tech/tags/permission.md>), [platforms](<https://devfeed.tech/tags/platforms.md>), [support](<https://devfeed.tech/tags/support.md>)

### AI overview

Chrome 118 adds support for creating and using iCloud Keychain passkeys on macOS 13.5 or later, complementing Chrome's existing credentials stored locally in the Chrome profile. Granting Chrome access to passkey metadata makes iCloud credentials appear in autofill and the account picker; declining leaves them usable with extra steps, and the permission can be changed in System Settings or reset with `tccutil reset WebBrowserPublicKeyCredential` (then restart Chrome). Saving requires an iCloud account and iCloud Keychain sync. Chrome cannot directly detect that sync status, so it uses iCloud Drive as an approximation when choosing iCloud Keychain by default for platform credential creation, with a separate default for accounts.google.com. Users can control the creation setting in `chrome://password-manager/settings`, or administrators can set `CreatePasskeysInICloudKeychain`. On macOS 14, passkeys from other password managers may temporarily be labeled "iCloud Keychain" in Chrome.

### Source excerpt

Chrome 118 (which is rolling out to the Stable channel now) contains support for creating and accessing passkeys in iCloud Keychain. Firstly, I'd like to thank Apple for creating an API for this that browsers can use: it's a bunch of work, and they didn't have to. Chrome has long had support for creating WebAuthn credentials on macOS that were protected by the macOS Keychain and stored in the local Chrome profile. If you've used WebAuthn in Chrome and it asked you for Touch ID (or your unlock password) then it was this. It has worked great for a long time. But passkeys are supposed to be durable, and something that's forever trapped in a local profile on disk is not durable. Also, if you're a macOS + iOS user then it's very convenient to have passkeys sync between your different devices, but Google Password Manager doesn't cover passkeys on those platforms yet. (We're working on it.) So having iCloud Keychain support is hopefully useful for a number of people. With Chrome 118 you'll see an "iCloud Keychain" option appear in Chrome's WebAuthn UI if you're running macOS 13.5 or later: You won't, at first, see iCloud Keychain credentials appear in autofill. That's because you need to grant Chrome permission to access the metadata of iCloud Keychain passkeys before it can display them. So the first time you select iCloud Keychain as an option, you'll see this: If you accept, then iCloud Keychain credentials will appear in autofill, and in Chrome's account picker when you click a button to use passkeys. If you decline, then you won't be asked again. You can still use iCloud Keychain, but you'll have to go though some extra clicks every time. You can change your mind in System Settings -> Passkeys Access for Web Browsers, or you can run tccutil reset WebBrowserPublicKeyCredential from a terminal to reset that permission system wide. (Restart Chrome after doing either of those things.) Saving a passkey in iCloud Keychain requires having an iCloud account and having iCloud K

## Signature counters

DevFeed: [Signature counters](<https://devfeed.tech/articles/signature-counters-36610.md>)

Original publisher: [Read original article](<http://www.imperialviolet.org/2023/08/05/signature-counters.html>)

Author: Adam Langley

Published: 2023-08-05T00:00:00Z

Content type: article

Language: en

Sources: [ImperialViolet](<https://devfeed.tech/sources/imperialviolet.md>)

Topics: [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [signed data](<https://devfeed.tech/topics/signed-data.md>), [Credential theft](<https://devfeed.tech/topics/credential-theft.md>)

Tags: [account](<https://devfeed.tech/tags/account.md>), [attack](<https://devfeed.tech/tags/attack.md>), [counter](<https://devfeed.tech/tags/counter.md>), [global](<https://devfeed.tech/tags/global.md>), [investigation](<https://devfeed.tech/tags/investigation.md>), [optional](<https://devfeed.tech/tags/optional.md>), [passkeys](<https://devfeed.tech/tags/passkeys.md>), [private-key](<https://devfeed.tech/tags/private-key.md>), [security-keys](<https://devfeed.tech/tags/security-keys.md>), [webauthn](<https://devfeed.tech/tags/webauthn.md>)

### AI overview

WebAuthn signature counters are optional; a key without one reports zero, while a credential that has reported a nonzero value must keep increasing it. A counter mismatch could reveal a cloned key, but the author considers that scenario far-fetched and says they have never heard of counters catching an attack. Websites that rely on counters should lock the account and investigate any non-incrementing value, including replacing the key; merely rejecting the assertion may let an attacker or user retry. There are privacy and compatibility limits: a global counter can help sites correlate a key's use, while synced passkeys omit counters because devices would need to keep values coherent. The author expects counters to become less common.

### Source excerpt

If you look at the structure of the signed messages in WebAuthn you'll notice that one of the fields is called the "signature counter". In the previous long post I said to ignore it, which is still correct, but here's why. Signature counters are optional for the authenticator to implement: it's valid for a security key not to have a signature counter, although the vast majority of them do. In that case, the counter value is always zero. But once a website has seen a non-zero value, then the security key has to ensure that the counter, for all future assertions from a given credential, is strictly increasing. The motivation of the signature counter is that it might allow websites to detect when a security key has been cloned. Cloning a security key is supposed to be very difficult. At the very least, you should need physical access to it, and hopefully you need to spend a substantial amount of time invasively interrogating it. But, if you assume all that happened, then one could clone a security key (probably destroying it in the process), get the private key of a credential out of it, and create a working replica which could be slipped back into the possession of the legitimate user, leaving them unaware that anything has happened. At this point, the attacker can create assertions at will because they know the credential's private key. If all that has happened, then the signature counter might uncover it. Unless the attacker can know exactly when the legitimate user has created an assertion, and thus incremented the counter, then eventually either they or the real user will create an assertion where the counter didn't increase. You might be able to tell, but I consider this a rather far-fetched scenario. Nevertheless, if a website wants to use the signature counters, then it must treat any non-incrementing counter as a signal to lock the account and trigger an investigation. At a minimum, the security key in question should be replaced. Simply rejecting the assertio

## Voice recognition

DevFeed: [Voice recognition](<https://devfeed.tech/articles/voice-recognition-36609.md>)

Original publisher: [Read original article](<http://www.imperialviolet.org/2023/07/29/voice-recognition.html>)

Author: Adam Langley

Published: 2023-07-29T00:00:00Z

Content type: article

Language: en

Sources: [ImperialViolet](<https://devfeed.tech/sources/imperialviolet.md>)

Topics: [asr](<https://devfeed.tech/topics/asr.md>), [Whisper](<https://devfeed.tech/topics/whisper.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [create](<https://devfeed.tech/tags/create.md>), [credential-management](<https://devfeed.tech/tags/credential-management.md>), [credentials](<https://devfeed.tech/tags/credentials.md>), [errors](<https://devfeed.tech/tags/errors.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [google-docs](<https://devfeed.tech/tags/google-docs.md>), [ios](<https://devfeed.tech/tags/ios.md>), [ipad](<https://devfeed.tech/tags/ipad.md>), [ipad-pro](<https://devfeed.tech/tags/ipad-pro.md>), [llms](<https://devfeed.tech/tags/llms.md>), [magic](<https://devfeed.tech/tags/magic.md>), [microphone](<https://devfeed.tech/tags/microphone.md>), [performance](<https://devfeed.tech/tags/performance.md>), [recognition](<https://devfeed.tech/tags/recognition.md>), [script](<https://devfeed.tech/tags/script.md>), [solved](<https://devfeed.tech/tags/solved.md>), [transcription](<https://devfeed.tech/tags/transcription.md>), [voice](<https://devfeed.tech/tags/voice.md>), [whisper](<https://devfeed.tech/tags/whisper.md>)

### AI overview

The author found iOS 17 voice recognition better than iOS 16 and Google Docs, but still error-prone on technical terms; correcting the dense mistakes could take as much effort as typing. A GPT-3.5-Turbo cleanup step improved a sample paragraph using a prompt to correct recognition errors, with uncommon technical terms listed as context. The author avoided asking for grammar fixes after seeing GPT turn some sentences into nonsense, and found the American spelling "recognize" in the instructions seemed to worsen results. They did not test GPT-4 because they misunderstood API pricing. An update says Whisper worked very well with a microphone-recording wrapper, though it sometimes added fabricated sentences at the end that the author removed. These are the author's reported results from an experiment, not a systematic comparison.

### Source excerpt

Update: Evan let me know that Whisper solved the voice recognition problem. He has a wrapper that records from a microphone and prints the transcription here. Whisper is very impressive and the only caveat is that it sometimes inserts whole fabricated sentences at the end. The words always sort of make sense in context, but there were no sounds that could possibly have caused it. It's always at the very end in my experience, and it's no problem to remove it so, with that noted, you should ignore everything below because Whisper is a better answer. Last week's blog post was rather long, and had a greater than normal number of typos. (Thanks to people who pointed them out. I think I've fixed all the ones that were reported.) This was because I saw in reviews that iOS 17's voice recognition was supposed to be much improved, and I figured that I'd give it a try. I've always found iOS's recognition to be superior to Google Docs and I have an old iPad Pro that's good for betas. iOS's performance remains good and, yes, I think it's better than iOS 16. But it's still hardly at the level of "magic", especially when using technical terms. Here's a paragraph taken directly from the raw output of last week's post (I've highlighted errors with italics): It is integrated into the W3C credential management specification and so it is called via navigator . credentials . create and navigator .credentials. get. This document is about understanding the deeper structures that underpin web orphan rather than being a guy as to its details. So we will leave a great many details to the numerous guides to Web Oran that already exist on the web and instead focus on how structures from UF were carried over into Web orphan and updated. While it's nice that many of the words are there, with that density of errors doing all the corrections means that it's not clearly better than typing things out. However, the world is all aflutter about LLMs these days. Can they help? I wrote a script to chunk

## From U2F to passkeys

DevFeed: [From U2F to passkeys](<https://devfeed.tech/articles/from-u2f-to-passkeys-36608.md>)

Original publisher: [Read original article](<http://www.imperialviolet.org/2023/07/23/u2f-to-passkeys.html>)

Author: Adam Langley

Published: 2023-07-23T00:00:00Z

Content type: article

Language: en

Sources: [ImperialViolet](<https://devfeed.tech/sources/imperialviolet.md>)

Topics: [Passkeys](<https://devfeed.tech/topics/passkeys.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [MFA](<https://devfeed.tech/topics/mfa.md>)

Tags: [authentication](<https://devfeed.tech/tags/authentication.md>), [bearer-token](<https://devfeed.tech/tags/bearer-token.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [passkeys](<https://devfeed.tech/tags/passkeys.md>), [password](<https://devfeed.tech/tags/password.md>), [replacement](<https://devfeed.tech/tags/replacement.md>), [security](<https://devfeed.tech/tags/security.md>), [security-keys](<https://devfeed.tech/tags/security-keys.md>), [standards](<https://devfeed.tech/tags/standards.md>)

### AI overview

Passkeys grew from U2F's use of security keys and digital signatures into discoverable WebAuthn credentials that can replace passwords. U2F credentials required a known credential ID and generally served as a second factor; FIDO2 added discoverable credentials, account metadata, and user verification, enabling sign-in before a username is entered. WebAuthn carried forward U2F's signed challenge and origin checks while adding RP IDs and extensions. Platform authenticators support reauthentication on the same device, while cross-platform keys and the hybrid phone flow support sign-in on another device. The earlier caBLE design relied on Bluetooth connections that the author describes as unreliable; hybrid uses Bluetooth to establish proximity and routes the rest over the internet, requiring internet access on both devices. Passkeys are typically synced, discoverable credentials intended to be recoverable, but syncing remains fragmented: the excerpt says Windows Hello does not sync, Google Password Manager syncs only among Android devices, and iCloud Keychain works only on Apple devices. Third-party password manager support was beginning to expand at the time described.

### Source excerpt

(This post is nearing 8 000 words. If you want to throw it onto an ereader there's an EPUB version too.) Introduction Over more than a decade, a handful of standards have developed into passkeys--a plausible replacement for passwords. They picked up a lot of complexity on the way, and this post tries to give a chronological account of the development of the core of these technologies. Nothing here is secret; it's all described in various published standards. However, it can be challenging to read these standards and understand how it's meant to fit together. The beginning: U2F U2F stands for "Universal Second Factor". It was a pair of standards, one for computers to talk to small removable devices called security keys, and the second a JavaScript API for websites to use them. The first standard of the pair is also called the Client to Authenticator Protocol (CTAP1), and when the term "U2F" is used in isolation, it usually refers to that. The JavaScript API, now obsolete, was generally referred to as the "U2F API". The goal of U2F was to eliminate "bearer tokens" in user authentication. A "bearer token" is a term of art in authentication that refers to any secret that is passed around to prove identity. A password is the most common example of such a secret. It's a bearer token because you prove who you are by disclosing it, on the assumption that nobody else knows the secret. Passwords are not the only bearer tokens involved in computer security by a long way--the infamous cookies that all web users are constantly bothered about are another example. But U2F was focused on user authentication, while cookies identify computers, so U2F was primarily trying to augment passwords. The problem with bearer tokens is that to use them, you have to disclose them. And knowledge of the token is how you prove your identity. So every time you prove your identity, you are handing another entity the power to impersonate you. Hopefully, the other entity is the intended counterparty and