Coming from Rust I am toying around with Lua at the moment. Lua is a small, simple and I would say a very neat language. But for big projects like an entire game I would personally much prefer a “traditional” compiled language like C/C++, Java/C# or Rust. Scripting langs are great for small scopes, but they quickly become a burden for bigger things in my opinion.

But I like to use Btrfs on top of LUKS and more often than not it’s not an option.

This is pretty verbatim.

That site is a gold mine!

I’ll look into that, thank you!

I’ve always been on android, so take this with a grain of salt. In my opinion Samsung phones have come a very long way. They used to be slower and bloated in comparison to other brands, especially while the market was still moving fast. I used to have a Sony, a ZTE, a Motorola, an Umi and a Jiayu - I tried quite a few over the years.

The recent generation are all fast enough and performance wise last 4+ years before they get noticably slow and an upgrade becomes necessary. Software support on Samsung is now phenomenal. I had so many bugs and hitches on other vendors’ phones and they were rarely fixed - the absolute opposite has been the experience on my Samsungs. Updates are frequent, smooth and stable.

I know this reads like an ad, but I was honestly positively suprised after I bought a Samsung tablet a few years back and have slowly switched over to Samsung devices. The same happened with all other members of my family. Samsung simply won.

I suppose the iPhone is very similar in that regard, both simply work and are great for everyday use. It’s almost boring!

I do advice you to look at the upper end though, they simply have more performance reserves. If you are a display menace and battery destroyer though, you won’t notice any significant slow down from the cheaper range in the 2 to 3 years you have before it becomes uneconomical to repair the device anyways.

Out of curiosity, how did you solve that software wise? I was planning to do the same thing with my old MFP. Are you just using CUPS and SANE?

It’s probably also highly automated and the staff’s job is just to watch for irregularities and alert the necessary teams.

That’s the biggest pain point with Signal and WhatsApp in my opinion. Telegram does it, but then of course it’s much easier for them to support. Sharing content from my tablet is such a hassle.

Neat, didn’t think of that!

I can really recommend those cards! They come in several sizes for laptop and desktop. I am not sure about USB. Just make sure you get the regular PCIe version and not the CNVio version (unless you have a compatible Intel Mainboard and somewhat recent processor). They differ in the naming, e.g. AX210/AX211 if I remember that right.

Unlikely, but who knows? Can you try and boot Windows (install iso probably enough)? Or some very old Linux distro? It might just be your monitor becoming weird with age.

Edit: Alsobtry with a laptop or something and see how it goes.

A naive implementation of a conversion from displayable IPv4 to 32bit integer IPv4 might look like this:

You have taken the four integer numbers of the IPv4 address from the text input, converted them to an integer and for simplicity sake we will say that they were put into variables a, b, c and d. It is common to just use ‘int’ for numbers and not choose something more fitting like ‘uint8’, so in our case the variables will look like this after assignment:

a: 0 b:0 c:0 d:2130706433

Now let’s declare a 32 bit variable R for our result and initialize it with 0 (or with d to skip a step, but optimization is not the point here).

Let’s work from left to right along the original representation. That means we’ll start with variable a. In an ideal case, only the rightmost 8 bits are set (0-255 decimal). Many will just make that (naive) assumption. We shift it to the left, so that the 8 bits that were previously on the very right are now in the leftmost 8 bit positions of variable a, like this: a<<24.

We are working with 32 bit integer variables and that means that in this first case, any bits beyond the intended 8 bits were “shifted out” to the left and are now gone. There is no problem here yet. We simply OR it to the result variable. The result R now contains the first 8 bits of the IPv4 address and they are correct.

Only when we want to do the same with variable b, c or d is when problems might appear. If we do the same as above with b, we now only need to shift to the second octet to the left: b<<16. If we simply put out shifted b into our result variable R by OR-ing it with the current result, we not only add 8 bits of information to our result, but possibly 16. In this case the input was 0, so nothing bad has happened yet.

We repeat the same for c by shifting it by only one octet: c<<8 and as c is also 0, nothing bad happens when we or it together with the previous result.

Now in the last step is where the (minimal) example from above gives us problems. In this case we do not need to shift at all (d<<0). Remember that our result R is still 0 at this point. If we now OR 0 and 2130706433 together, we just get 2130706433. This last step added 32 bits of information even though we only intended to add 8.

Our converted IPv4 address is valid and some might say we even did a correct conversion, but it is of course not the intuitive result we wanted.

As you can see, an attacker might choose b,c and d as they please to make the notation look irregular, but our conversion simply eats it up and spits out a valid address. That’s why it is important to always work with IP addresses as integer numbers in bit format. Convert first, then filter on that. You never know how somebody may have implemented the conversion and whether they reject odd choices like “0.0.0.2130706433”.

You could of course also prevent stuff like this by making the conversion smarter and have it reject a,b,c,d >256 or something similar, but then you are just putting bandaids on a simple problem with a simple solution. Our conversion had to work with 4 independent numbers in a loop. It’s best to only do that once and use 32 bit integers beyond that.

Nah, it’s easier in pretty much every language. It’s just a 32 bit number that can be compared with a standard “<=” or “=” comparison operator in pretty much every language out there and a single ASM instruction. Writing it as four smaller numbers joined with dots is just how it’s easy to display for humans.

Many make the mistake of thinking that IPv4 addressess are always encoded like that. The address “127.0.0.1” is just 2130706433 in decimal. Some tools even accept misformed addresses like “0.0.0.2130706433”. Security concerns come in to play when a program checks for local addresses by comparing the individual “127”, “0”, “0”, “1” parts (or eg. “192”, “168”, ““, ,””) and allow or deny access based on that for example. Another part of the software will likely just accept a misformed address and a malicious actor can circumvent the filtering from earlier.

Eh, those attempts are just noise anyway. Use proper pubkey auth instead of normal passwords and you’ll be fine. Any key size is probably enough to prevent successful bruteforce attacks. Anything above 2048 and there’s basically no chance for them to guess right within several years of constant trying. Most bots move along quickly as well, they try their predefined list of (common usernames) x (common passwords) and that’s it.

Install endlessh, an ssh tar pit, if you want to make their lives a little more annoying. Use a non-standard port if your OCD can’t stand the slowly filling auth attempt logs.

Someone mentioned Firefox Focus.

Smart.

The wiki page has a “History” segment and right below that… "In Fiction"💘🤠

Don’t forget about OpenCL.

Yes! There’s a git plugin for obsidian that supposedly works very nicely. Obsidian runs locally, on desktop and mobile and also offline which is super nice. Not opensource, but all your stuff is kept in a normal folder and all notes are regular markdown. The devs have pledged to make it opensource should they ever abandon the project.