@Di4na Considering we haven't even remotely begun to liberate the hardware which is at the root of our systems, I don't think we have won.
Software was only ever the easy part, and even there the corposcum monopolies and their legislator cronies are doing their best to limit the effective Freedom of users (consider the criminalization of interoperability and adversarial interoperability). That they derive most of their tools from our labor intended to liberate in order to oppress is just a sick and ironic joke (and the best we could do in retaliation is just sabotage with results of indiscriminate harm, a profoundly undesirable notion).
But even if we managed to pull things back into the control of the users and ensure their software systems actually *serve the user*?
At the moment, the majority of us do our computing on hardware where any Freedom that software grants us could be pulled under our feet a moment's notice, should some hitherto unknown backdoor or vulnerability (what's the difference?) be activated.
Battles have been won, the campaign moved forward, but we're *far* from being able to just shout victory.
@lanodan@trevorflowers@csolisr The problem with unions, at least here, is that they *also* often have paperwork red tape requirements. So they wouldn't meaningfully differ from government, and in fact might be worse since they often have harsher requirements on recency of employment, certification/license and whatnot. (Needless to say, there's a lot to fix.)
I think the overwhelming majority of people involved in stuff like I2P are pseudonymous, and for good reason since the project feels a fair bit more serious about traffic obfuscation than Tor.
A lot of Free Software programmers do *not* have the academic certifications and so on paper do not have the "professional competency" they actually have. In some cases, due to a variety of issues unrelated to monetary cost, they *cannot* acquire said certification either.
It is also an issue for Libre work on politically inconvenient technologies (though it is equally an issue with pseudonymous authorship of some investigative stuff), such that alternative acknowledgements of specialization/competence might also pose a risk by flagging one as a target for feds.
@mia > - don't try to feel better by telling yourself others have it worse
Does that include comparing with oneself in terms of "it could be worse"? Both hypothetically and in knowledge of fact from having previously experienced said worse state?
"We must stay as we are because have always been this way (false). Progress is verboten. Change is verboten. Especially intentional change. Self-agency over one's physical form is verboten."
I'm not seeing any way for a sysadmin to prevent the use of gratuitous dependencies without having to rebuild the whole program.
This is a pretty common problem with systemd-related programs, really.
Distro defaults don't mean I'm interested in keeping the same defaults. And switching out systemd with a custom build isn't as trivial as other programs where a bit of PATH shenanigans suffices (at least without breaking a lot of the package manager's stuff).
@martin_ueding@glyph@AndresFreundTec@kirschwipfel > Sounds good. But some projects have a build stage which generates lots of things. Packagers for distributions need to up the needed environment and perform these steps. It seems much easier to use a provided artifact in these cases.
If you don't care about reliability, build-reproducibility and trustworthiness of your distro, sure.
> I think this attack is hard to defend against: An evil insider in the project with control over the code and artifacts.
Compromise of artifacts is a lot easier, you can ask the Linux Mint project about that.
> One could also hide malicious stuff in the code itself directly, in plain sight.
That requires a project with such awful code practices (accepting random unauditable blobs) that you'd hope the package maintainers would simply refuse to add it in the first place.
Binary artifacts have no business existing in Free Software (or near-binary considering how auditable pre-generated config scripts end-up being). The way it was compromised in this case is almost certain to have happened before and reminds me of the SourceForge malware debacle (so arguably that's another famous example of it happening before).
I"m not sure if many other projects do like Guix and record the checksum of the whole repository so as to ensure reproducibility purely from source.
@kirschwipfel@glyph@AndresFreundTec > If the packager chooses to use the official tarball as "the source", validating the checksum would not have helped. :-(
Unfortunately, yeah.
> Also whether it's always possible to run running autoreconf depends on the content of the tarball.
Of course if it isn't a C project then it probably isn't. If it is such a project, then one should have such tooling installed.
> Which brings me to the (preliminary) conclusion that we'd better use repos as source of trust
That is more sensible generally, as the history of an object and its belonging to a project is a reified (and verifiable) relationship under code versioning sytems, unlike arbitrary buckets of files.
@lanodan@ipg@halva You don't have to make the core in C and there are quite a few self-hosted languages that don't.
Linux has a stable ABI for userspace (mostly), so it is possible to even do the whole thing from scratch and communicating directly with the system that way, skipping C entirely. In general instead such languages deem it simpler to make a C wrapper which can communicate with their own ABI instead.
Hi, I'm Lispi, Lisp (Technomancer) Wizard (to eventually be).You might know me from @lispi314@mastodon.top I like Free Software, #Emacs and resilient computing a lot.I also like anime girls, animes with cute girls doing cute things and artwork with them too. Cute stories are good too.Some Pins:Software and Assumed Privilege, common problems: https://mastodon.top/@lispi314/111253066257920146Writing Privacy-preserving software & services 101: https://mastodon.top/@lispi314/110849018589421824#Kopimism #FreeSoftware #CommonLisp