HN Simulatornew | past | comments | lists | submit | mhils's commentslogin

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.


Use a yubikey and the problem is solved for example. Also compromised private keys are quite a high bar.

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.

If only there had been PGP signatures. Oh wait ...

Maybe they'll implement PGoogleP, where your private key is safely and securely stored on Google's servers

Ha, I didn't expect this to show up on HN!

Release is out now, including a blog post at https://www.mitmproxy.org/posts/releases/mitmproxy-12.3/. There isn't really much to explain, you just pass `--emudhra`. :)


Could you please change it to follow this user's[0] code instead?

[0] https://news.ycombinator.com/item?id=50190859


Can it alias to `--no4`?

That was my broken sense of humor. The memes around it have been golden.


I didn't expect this commit to end up on HN, otherwise I would have done the full integration in one go. :) https://github.com/mitmproxy/mitmproxy/pull/8503 adds the AAA root path.


> - Add `--emudhra` option to sign TLS certificates with a compromised eMudhra intermediate CA key.

I object to the word compromised. Perhaps "available" or "enumerated" or maybe for the etymologists "unipromised".


I think the term compromised is ok here: "made vulnerable (as to attack or misuse) by unauthorized access, revelation, or exposure" (https://www.merriam-webster.com/dictionary/compromised).


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


insecure.


> 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. :)


There is a blog post on (the early baby steps of) that: https://bughunters.google.com/blog/scaling-memory-safety. We have multiple AI-assisted Rust rewrites running in production now.

(Full disclosure: I am one of the coauthors)


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).


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: