• 4 Posts
  • 13 Comments
Joined 3 years ago
cake
Cake day: August 10th, 2023

help-circle



  • Do nix and then use nix2appimage, or nix bundle to package the app compressed as an arx archive without the startup times they complain about.

    You can also use https://github.com/DavHau/nix-portable to bundle it a bit better, without needing nix on the host.

    And then, based off a quick search:

    https://github.com/neobrain/nix2flatpak

    https://github.com/barstoolbluz/nix2deb

    I couldn’t find nix2rpm or nix2pacman, but there exist tools to convert between formats (alien, debtap, rpmtap, and one more who’s name I can’t remember but I remeber as being the most versatile).

    What I’m trying to say, is that when people said “just use nix”, they probably really mean to use nix as a platform to build other packages withouth doing extra work.

    On the other hand,

    You can also use one of the newfangled appimage like formats: https://docs.pkgforge.dev/formats/packages

    This one is linked in there and creates a static executable from any binary: https://github.com/VHSgunzo/sharun

    Now they would still have to build for macos and windows, but they are already doing that anyways.

    As a sidenote, there is also this: https://github.com/pacur/pacur , which is an aur like repo that buids debs, rpm’s, and pacman packages. So there’s semi-automatic updates, via a publuc repo you can out stuff on.

    The real elite solution, imo, is to host forgejo, or use codeberg, which insanely has a package registry for every possible format of packages. So you can directly just push there, after building however you want.

    But if developer’s were good at packaging, I wouldn’t be so mad when they try to do it.

    Because this:

    The next version will include a new built-in self-updating mechanism

    Downloading unsigned, unverified binaries directly from the latest versioned github release?

    Makes it so that all that’s needed for getting malware on the system is pwning the developers account via some supply chain malware, that hooks into there browser and pushes a release.

    And every additional developer who can release, or every github actions that is potentially vulnerable but can be made to release, or claude (since the author is letting it commit, which requires it to run without sandboxing afaik) becomes more attack surface.

    There are ways to fix this. Conventional distros use multi party signing of commits and releases, where developers continously verify eachother and look over changes.

    More newfangled flows involve using github actions to build immutable releases, directly from tagged versions of the code.

    But random developer #3989 isn’t doing this. They are distributing their software in a way that malware distributors will be ery happy to see after pwning their account.

    I want devs to use nix, because then I can build or run their program directly from the source code. It sidesteps so many issues with visibility of the supply chain, or being unable to inspect what I am running.

    I like nix becuase I can make developers like the above satisfied by giving them a way to easily build static binaries, or other formats.


  • Package 2+ year-old frozen releases of as much upstream software as you can, and then ignore the upstreams, their bug-fix releases, and their complaints about this.

    This is the worst of all worlds!

    I disagree.

    Have you ever helped a non tech nerd use a computer? They don’t really understand how it works. Instead, they just have a workflow, a set of steps they follow to send an email or get to facebook. When those steps break, they panic, throwing up hands.

    I once helped someone who got stuck, where the issue was that outlook had been set to sort emails by file size, rather than date. Outlook (new) and other constant changes by Microsoft have been a nightmare. When a new bug is introduced in the middle of an existing workflow, everything falls apart because they are unable to find a workaround.

    Stable distros, the ones that freeze 2+ year old packages are built for people like those. People who use workflows, rather than computers. These users will also never, ever submit a bug report. They will never go online to annoy developers. They might not even know what a “bug” is. These users unknowingly appreciate it when package versions are frozen, when nothing is moved, and even when no bugs is fixed, because it means their workflows will never need to change. And by the time of the next stable distro release, I would have ample time to prepare and draft up new workflows for them.

    Unfortunately I have to support people who use Windows because we are locked in to the ecosystem everywhere. But I’ve come to respect the stable distro model, and I really wish I could be supporting those distros instead of Windows.

    I understand the frustration of the author, and other developers who have to deal with users who come online to submit bug reports and complain about issues that have been fixed in a newer version of the software. But I dislike takes like this, because it’s a form of nonresponse bias in your polling. You are only listening to the people speaking up, and viewing them as your entire community, without understanding that there are vastly more people who are just silent about this.

    Ubuntu continues to dominate the Linux desktop marketshare (overall, stats from Steam are different). But you don’t hear anything about it online, because the vast majority of people who use Ubuntu, just… use it. It works for them. They don’t go online to tinker further, or to praise it, or to complain.

    I like Arch Linux. I love receiving new features. But it has new bugs every week. One time dragging bookmarks into firefox’s bookmark bar caused a crash. Another time it was KDE issues. I can and do quickly find workarounds, and then the bugs get fixed and I handle the new bugs. But a normal user can’t do that.

    My opinion is that if a user is reporting bugs to developers or complaining about older package versions, they should just switch to a distro with newer packages, preferably a rolling release. Those kind of users are probably able to do the above, able to cope with the unstability of the system. It doesn’t mean unreliable, as the system is reliable and works overall, but my workflows are constantly adjusted in minor ways, to work around minor issues or for efficiency gains. I recommended a user frustrated with older packages to do that in another comment.

    Users of say, Arch Linux, or Nixos, tend to like tinkering, which often leads to needing help, which results in joining discussions, causing them to be overrepresented. But, we are not the majority of Linux users, according to last year’s stackoverflow survey. We are somewhat of a loud minority.

    I understand the frustration of developers dealing with distros like Ubuntu, Red Hat, or Debian, due to their slow moving policy, and perspective of stability as being relaxed about even fixing bugs. But these distros have their place in our society, and they have a real purpose behind these policies.









  • So Signal does not have reproducible builds, which are very concerning securitywise. I talk about it in this comment: https://programming.dev/post/33557941/18030327 . The TLDR is that no reproducible builds = impossible to detect if you are getting an unmodified version of the client.

    Centralized servers compound these security issues and make it worse. If the client is vulnerable to some form of replacement attack, then they could use a much more subtle, difficult to detect backdoor, like a weaker crypto implementation, which leaks meta/userdata.

    With decentralized/federated services, if a client is using other servers other than the “main” one, you either have to compromise both the client and the server, or compromise the client in a very obvious way that causes the client to send extra data to server’s it shouldn’t be sending data too.

    A big part of the problem comes with what Github calls “bugdoors”. These are “accidental” bugs that are backdoors. With a centralized service, it becomes much easier to introduce “bugdoors” because all the data routes through one service, which could then silently take advantage of this bug on their own servers.

    This is my concern with Signal being centralized. But mostly I’d say don’t worry about it, threat model and all that.

    I’m just gonna @ everybody who was in the conversation. I posted this top level for visibility.

    @[email protected] @[email protected] @[email protected] @[email protected] @[email protected]

    EDIT: elsewhere in the thread it is talked about what is probably a nation state wiretapping attempt on an XMPP service: https://www.devever.net/~hl/xmpp-incident

    For a similar threat model, signal is simply not adequate for reasons I mentioned above, and that’s probably what poqVoq was referring to when he mentioned how it was discussed here.

    The only timestamps shared are when they signed up and when they last connected. This is well established by court documents that Signal themselves share publicly.

    This of course, assumes I trust the courts. But if I am seeking maximum privacy/security, I should not have to do that.