Very cool to see PyPI put more emphasis towards exposing provenance info. It would be even cooler if trusted publishing would finally support reusable workflows (https://github.com/pypi/warehouse/issues/11096).
It would be even nicer if there were a way to have an attestation without publishing with a workflow controlled by one of the tech giants. There's no way for me, someone who has had a PyPI account for many years and has used it for all that time to upload packages, to attach my own public key to my PyPI account and then sign uploaded distributions with my private key so the signature can be verified and count as an attestation.
I think the problem is this type of attestation is hard to weigh as a trust signal, vs the cloud CI version.
Inherently, if someone steals your key, or gains access to a box that can use that key for signing, they are indistinguishable from you. Hand PGP signing also lacks time-bound signing, any ratchet mechanism, CT log, consistent key hierarchy, or standard to bind signer name and project identity.
> this type of attestation is hard to weigh as a trust signal, vs the cloud CI version
In the sense that I'm not a large corporation and nobody else is auditing my personal computer, yes, that's true. Note, though, that large corporations are also subject to nefarious actors misusing their infrastructure. What if a rogue employee hacks their internal system? Or Russia or China manages to get a backdoor into it?
In any case, all this doesn't make the method I described impossible. It just means that attestations produced by an individual workflow need to be clearly labeled to distinguish them from attestations produced using a tech forge's workflow, so people will understand what, specifically, is being attested to. Then people could weigh each trust signal as they choose.
> Hand PGP signing
To be clear, I wasn't talking specifically about this method of signing with a personal key. I agree there are lots of issues with PGP as an overall system. I was only talking about the general idea of having some way for individuals to independently generate an attestation without having to go through a tech forge's workflow.
I think their system is vague, subject to political pressure to revoke attestation, and confusing.
We definitely should have a system that has multiple mechanisms for authorship attestation, of ongoing identity control, code control and binary generation sanctity. The last step can be made repeatable if we can manage reproducible builds.
If you generate the GPG key on the yubikey (every tutorial says not to do this unfortunately). Practically, hardly anyone does it securely with a HSM/yubikey, and they store their key online, where it is collected by info stealers. Even if someone uses a Yubikey, they can prove that they did. The lack of a CT system means signing is secret and not timestamped. We need to do better.
Seems valid to me. EMudhra meant it to be secret, the secret was reversed due to using insufficiently large numbers, so now the secret is compromised. It's the same as if someone went into hiding, and someone tracked down the hiding spot via flaws in the plan, you'd say the location was compromised.
It was a particularly poor choice of number, but still
> didn't say they did anything with a VLM to check the output vs the original library
Assuming VLM stands for vision–language model: We validated that all pixels are bit-identical across those 30M GIFs. So we didn't need a language model for that, we just compared expected and actual pixel buffers for strict equality. :)
A concern with these LLM-driven rewrites is that the Rust code isn't really idiomatic, it ends up being C++ code in a trench coat (raw pointers everywhere, manual validation of thousands of unsafe blocks). So far every publicized rewrite I'm aware of has had an "oh and we'll definitely spend the thousands of hours needed to fundamentally rework the code to properly utilize lifetimes later" admission tacked on at the end. Has there been progress in improving that aspect during the LLM phase of the rewrite? If so that would be an incredible win for the industry!
> Has there been progress in improving that aspect during the LLM phase of the rewrite?
I'd say so! We aim to have our replacements to be `forbid(unsafe)` - no raw pointers - outside of `ffi.rs`. Of course it's tricky because we need to interoperate with existing C code, but we've been trying to come up with abstractions that make this a bit more ergonomic (https://github.com/google/safer_cffi).
reply