Yossarian

The "use cooldown" [0] blog post looks particularly relevant today. I'd argue automated dependency updates pose a greater risk than one-day exploits, though I don't have data to back that up. That's harder to undo a compromised package already in thousands of lock files, than to manually patch a already exploited vulnerability in your dependencies. [0] https://blog.yossarian.net/2025/11/21/We-should-all-be-using-dependenc…

Isn't it worth the balance between stability and effort to go with LTS (long term support / security updates only)? You know the updates on LTS will be relatively much safer. The limit of potential breaking updates to every 2 years is mostly the point. But if you're just talking about a home lab where you want to use the latest advances without the latest exploits, try a dependency cooldown. Simon Willison recently pointed out this post by William Woodruff about dependency cooldowns [0]. Wait a day between update release and adoption to identify supply chain compromises. In other words: Don't move fast. Don't break things. Or: Move slow. Keep things. [0] https://blog.yossarian.net/2025/11/21/We-should-all-be-using-dependenc…

Hey! I must've responded to the wrong thread. Unless the link on this post was changed. You're blog looks just perfect to me, and loads fine even on my extremely slow Redmi A5. And even the code examples look fine. So sorry! I must've accidentally written my comment on the wrong page. The post I thought I was responding to showed a website with an animated "breathing" background which was completely locking up my phone. Edit: Just to drive this point home, if you're the author https://blog.yossarian.net you've made a perfect looking blog and I wouldn't change a thing.

(Author of this post.) If you’re interested in how this went down, the timeline section[1] in particular is worth jumping to: my key takeaway is that this vulnerability was reintroduced, and that there’s only limited evidence that the Ultralytics team have done a full revocation and rotation of all accounts and credentials that the attacker may have had access to. Given that, it’s not inconceivable that a third round of backdoored packages will occur. I would recommend that people exercise extreme caution when installing the current versions; most users would probably be best served by pinning to an older version from before any indicators of compromise. [1]: https://blog.yossarian.net/2024/12/06/zizmor-ultralytics-injection#app…

The vulnerability was not in the source code of the repo. See https://blog.yossarian.net/2024/12/06/zizmor-ultralytics-injection for a deeper analysis - a great read!

> were previously supported I think it was over this debacle, definitely over some debacle, someone made a great blog post that pointed out this wording is usually incorrect (edit: Link https://blog.yossarian.net/2021/02/28/Weird-architectures-werent-suppo… HN Thread: https://news.ycombinator.com/item?id=26294397). It previously worked, but no one was promising support for niche architectures. It just happened to work (at least enough that there weren't obvious bugs, who knows if fully). Expecting support for every non-standard way you can use the software is usually not a reasonable expectation of maintainers.

I love this kind of stuff. For example the date of October 6th, 1582 doesn't exist. https://blog.yossarian.net/2015/06/09/Dates-That-Dont-Exist

Back when that happened, this post came out: https://blog.yossarian.net/2021/02/28/Weird-architectures-werent-suppo… TL;DR: Look at it from our perspective. It's not reasonable for us to be beholden to the limitations of build targets we never consented to supporting and possibly didn't even know about.

> If everyone starts waiting a week, their exploits will wait 2 weeks It's much easier to break into an NPM/Github account and push malicious commits in the few hours a maintainer is sleeping than it is to push something out and not have it noticed for 2 weeks. There are lists of attacks which had an exposure window which was much shorter than 2 weeks: https://daniakash.com/posts/simplest-supply-chain-defense/ https://blog.yossarian.net/2025/11/21/We-should-all-be-using-dependenc…

Maybe just not the very latest. https://blog.yossarian.net/2025/11/21/We-should-all-be-using-dependenc…

The neat part is you can do whatever you want in a GitHub action, corporate policy be damned. So: git clone <tmate / banned action git URL> cd <the action> Run the action start point. Apparently this is a feature, not a security risk. https://blog.yossarian.net/2025/06/11/github-actions-policies-dumb-byp…

This article was on the front page recently that discusses the idea behind this: https://blog.yossarian.net/2025/11/21/We-should-all-be-using-dependenc… Most of the time, you need quick patches because of fairly recent dependency changes, so if you just wait and kind of "debounce" you dependency updates, you can cover a lot of supply chain vulnerabilities etc.

> Can you really say you trust all of these? We need better capabilities. E.g. when I run `fd`, `rg` or similar such tool, why should it have Internet access? IMHO, just eliminating Internet access for all tools (e.g. in a power mode), might fix this. The second problem is that we have merged CI and CD. The production/release tokens should ideally not be on the same system as the ones doing regular CI. More users need access to CI (especially in the public case) than CD. For example, a similar one from a few months back https://blog.yossarian.net/2024/12/06/zizmor-ultralytics-injection

Its benefits are very much completely negated in real-world use. See https://blog.yossarian.net/2023/05/21/PGP-signatures-on-PyPI-worse-tha… - the data suggests that nobody is verifying these PGP signatures at all.

Meanwhile the Python Package Index has recently dropped official support for PGP signatures: https://blog.pypi.org/posts/2023-05-23-removing-pgp/ -- apparently due to too few useful/verifiable signatures, as per https://blog.yossarian.net/2023/05/21/PGP-signatures-on-PyPI-worse-tha…

I thought it was just using the totally safe transmute, this one: https://blog.yossarian.net/2021/03/16/totally_safe_transmute-line-by-l… But I guess there is another trick.

PyPi did indeed, but it's a fairly interesting case. It was removed because the implementation was ineffective More information on that here: https://blog.yossarian.net/2023/05/21/PGP-signatures-on-PyPI-worse-tha… There was a lot of talk about why this didn't go the other way; keeping signing, but making the practice meaningful. I forget the details about that.

Hah! I have been a fan of your blog. Also, I can't believe I missed that you wrote a post inspired by one of my posts! [1] Argh! [1]: https://blog.yossarian.net/2023/02/11/The-unsafe-language-doom-princip…

They are an atrocity in AT&T syntax. They are perfectly readable in Intel format. For example: https://blog.yossarian.net/2020/06/13/How-x86_64-addresses-memory

There’s a guy that reverse engineered them but he would only describe the broad strokes. Part of the system works with the value stored on the card so there is a way to get free rides but it’s not easy to figure out. https://events.ccc.de/congress/2005/fahrplan/attachments/594-paper_Mag… https://events.ccc.de/congress/2005/fahrplan/events/765.en.html https://blog.yossarian.net/2016/07/17/Decoding-the-Metrocard-Part-2

Linux does this, actually. It's called "static calls", and it saves on an indirect branch by directly overwriting jmp instructions to point elsewhere: https://blog.yossarian.net/2020/12/16/Static-calls-in-Linux-5-10. As others have mentioned, doing this repeatedly has performance implications.

Weird architectures weren't supported to begin with: https://blog.yossarian.net/2021/02/28/Weird-architectures-werent-suppo… If you're still running a system with an arcane ISA, support it yourself. 99% of the people running modern Linux are interested in three CPU architectures (four or five once RISC-V gains traction), all of them supported by Rust. Supporting old or obscure ISAs is not a priority at this point compared to bringing kernel memory safety into the 21st century, which Rust helps a lot with.

> which GitHub goes to extents to document GitHub Actions policies as applying to `uses:` clauses If it were phrased like this then you would be right. The docs would give a false sense of security, would be misleading. So I went to check, but I didn't find such assertion in the linked docs (please let me know if I missed it) [0] So I agree with the commenter above (and Github) that "editing the github action to add steps to download a script and running" is not a fundamental flaw of this system designed to do exactly that, to run commands as instructed by the user. Overall we should always ask ourselves: what's the threat model here? If anyone can edit the Github Action, then we can make it do a lot of things, and this "Github Action Policy" filter toggle is the last of our worry. The only way to make the CI/CD pipeline secure (especially since the CD part usually have access to the outside world) is to prevent people from editing and running anything they want in it. It means preventing the access of users to the repository itself in the case off Github Actions. [0] https://blog.yossarian.net/2025/06/11/github-actions-policies-dumb-byp…

> And if they do, is it good design to install back-ends for (say) 23 such target architectures that you're never going to cross-compile for, in practice? Does that benefit the user? rustc --print target-list | wc -l 287 I'm kinda surprised at how large that is, actually. But yeah, I don't mind if I have the capability to cross-compile to x86_64-wrs-vxworks that I'm never going to use. I am not an expert on all of these details in clang specifically, but with rustc, we take advantage of llvm's target specifications, so you that you can even configure a backend that the compiler doesn't yet know about by simply giving it a json file with a description. https://doc.rust-lang.org/nightly/nightly-rustc/rustc_target/spec/inde… While these built-in ones aren't defined as JSON, you can ask the compiler to print one for you: rustc +nightly -Z unstable-options --target=x86_64-unknown-linux-gnu --print target-spec-json It's lengthy so instead of pasting here, I've put this in a gist: https://gist.github.com/steveklabnik/a25cdefda1aef25d7b40df35a026144d Anyway, it is true that gcc supports more targets than llvm, at least in theory. https://blog.yossarian.net/2021/02/28/Weird-architectures-werent-suppo…

> Because PyPI (or an attacker) could always substitute a new key. No, they couldn't. The old package would authorize a later update. Think blockchain. > This might be a misunderstanding, but I don't think you actually want this: lots of large packages have multiple release managers (and contributors who come and go); you don't want to manually resolve each new human identity that appears for a package distribution. I'm not sure you actually know how organizations release software: You wouldn't have signatures of individuals in that case of course, but stuff signed by keys owned by the organization. Think signed Linux packages from distributions. > What most people actually want is a strong cryptographic attestation that the package distribution came from the same source as the thing hosting the source code […] No, that's completely uninteresting. Nothing could bother me less. I know already that every time I'm downloading something from e.g. Microsoft GitHub it comes form Microsoft GitHub. There is strong E2E encryption in place making that sure (TLS). Same for any other hoster. > […] since both that service and the owner of the repository are presumed trusted. Wrong again. I'm not trusting any hosting service any more than any other random people on the internet. Not only that a service can get malicious for any reason at any time, get hacked, or be forced by authorities to perform targeted attacks, I actually don't have any trust relationship with them…