dfox

The root cause of this attack is that the typical cryptocurrency wallet operational model involves the key leaving the device in plain text as part of the setup/backup process. Such a thing is impossible on any normal correctly configured HSM (while creating backups is possible by some sort of multi-step process where the secret key material never exists in plaintext outside the security boundary, how exactly that is done differs significantly between vendors).

It seems that they changed it again and now there is minified HTML with english message + simple script that injects the other languages and the icon, no animation. Which to me seems much more sensible.

Note that this list is list of places where if you are enterprise starlink customer SpaceX can provide you with physical ethernet port to plug your cable into when you want to handle your traffic yourself instead of that just going directly to the internet. That is kind of obscure service that even land-based PLMN operators offer but usually do not document in this way in publicly available documentation.

From the perspective of network design, the fact that this certainly is not exhaustive list of places where SpaceX has physical DC presence and physical reality it comes that some of these datacenters are selected based on the fact that the ground station is somewhere nearby (I would be surprised if there is even just one place on the list where nearby means "on the roof", because there is a lot of technical, logistical and administrative reasons why you do not want to put such a thing at a roof of a datacenter).

The "two E10Ks" part is the important part there, as you need a very powerful server to support SunRay users running Solaris. At my university there was something like 200 SunRays supported by cluster of T2000s (7 nodes IIRC), it was fine for CDE, Firefox and few dtterms, completely unusable with Gnome (it took Gnome like 10 minutes to even start).

On the other hand I have heard of some success stories about using SunRays as RDP clients, which is actually supported configuration (you still need a Solaris box that manages the sunrays and translates RDP to ALP).

In washing machine application the locking action is quite fast as the heating element is PTC connected more or less directly to mains, pretty substantial amount of energy gets dumped into the wax over few AC line cycles. In that application (and also in most industrial automation situations) ~100ms is more than fast enough because when most of the effector components are AC powered you end up with ~40ms worst case actuation delay just from the physics of AC electricity. On my washing machine it is quite noticeable that when you press "start" the door gets positively locked well before the capacitive sensing "button" finishes playing its haptic feedback non-sense. (the fact that front panel of cheap-ish toploading washing machine is actually a huge touchpad with haptic feedback that is designed to look and behave like five physical buttons says many things about economics of manufacturing stuff for that somewhat hostile environment at these scales)

You are assuming that the forgers care about the machine readable part at all. Vast majority of forged EU ID cards I have seen are trivially recognizable by the fact that the MRZ contains something that kinda-sorta matches the human readable part, but is syntactically invalid and has wrong checksums.

The problem there is that this is exactly the class of bug that does not exist in GNU coreutils because of philosophy of that project. Non-existence of such bugs proves that the impementation is not copied from AT&T code.

At a first glance passive RFID would be a perfect match for ride photos, the whole mechanism is ridiculously fast so speed of the ride would not matter much (the technology works at highway speeds just fine) and can work over ~15 meters.

But there are two somewhat significant issues with the radio layer in this application: the geometry of tag antenna is somewhat critical (making it into a band would be problematic) and the back scatter is attenuated by salt water blobs (ie. people) almost perfectly.

I suspect that is not an inherent limitation of the dual-ISA design (the HotChips slides mention some sort of bidirectional thread state mapping between arm and z), but just about there not being z/VM release that supports that (building such a thing is probably SMoP, but another question is whether that makes business sense).

IBM's mainframes do not really have a reset vector, the CPU gets initialized by some external means into whatever state the OS expects and then the clock gets enabled, so that distinction is quite moot.

They were always required. IIRC early AMD64 CPUs did not support x87 instructions in long mode at all (causing #UD), and that support was Intel's extension in first EM64T CPUs.

Basically the only thing interesting about the ConcertMaster is that Carmack used it (and that it looks somewhat cool). As for the keyboard itself, it is just a basic OEM membrane keyboard and not that good one even. The speakers are lets say adequate for the time and size.

Interestingly, the speaker part and the keyboard part are completely separate. The "cable" consists of four separate cables (keyboard, power, line out, mic in) in a thin sleeve. Mine was supplied with AT plug on the keyboard cable and Y-adapter that converted PS2 into AT DIN and barell jack for the speaker power. The keyboard label indeed says it is powered by 9V DC, but I guess that never really happened as PS/2 is 5V no matter what various devices say.

Edit: And as for the supper hard to find nowadays part: I suspect that part of the reason is that the keyboard module inside the thing is ridiculously sensitive to even minor spills.

Do not do this unless you do not have any other choice. Preferrably use whatever native barcode support of the printer involved, if it does not have that, just generate the barcode as vector image or bitmap with a resolution that is a integer fraction of the printers resolution. Generating correct Code128 as a SVG is about the same amount of work as generating the correct input for some sort of barcode font (the hard part is determining the switches between character sets, not generating bars from bytes).

The fact that this is standard practice does not mean that it is not perverse. It kind of works sanely for plain Code39 (and even then you will see effects of doing that in weird places, like VAG stamping human readable VIN on a chassis, including the Code39 start/stop symbols), once you start using barcode fonts for Code128-derived symbologies (ie. UPC/EAN) the whole thing becomes a pointless exercise.

It had, another thing is that it used somewhat questionable system for CD key validation, which is stubbed out in this release (https://github.com/BohemiaInteractive/CWR/blob/main/engine/P...).

One thing is 120bit RSA (readily broken with a graphing calculator at the time of release), another thing is the provenance of the RSA implementation code in the original binary.

The most important fix in SP1 for Office 2007 was fixing exactly that in Excel. Doing ridiculous amount of 4 byte reads made it basically unusable on network filesystems.

One point is that there is no reason for the entire secret to be one element of the underlying field, it can very well be a n-tuple of elements of a smaller field, with GF(2^8) being the somewhat obvious choice if you do not expect ridiculous numbers of shares, no need to deal with bignum math.

> cannot start with digit

Not only it can, but both CL and Emacs Lisp actually defines primitives with names that start with digit.

It is far from being universal. And the more annoying part of that is that there are at least 4 incompatible "standards" as to the format of the QRcode.

IIRC the really cheap Casio Organizers/DataBanks of 90's used 5x5 font. And then my ex used something like that on linux in order to fit a ridiculous amount of xterms onto 14" CRT (somewhat absurd feat with her congenital vision defect).

Gnat Studio just works on Windows.

It uses exactly the same font in the desktop version, and is probably entirely intentional.

The telling part about uselessness of that window is that the most visible difference between StarOffice 5.2 and OpenOffice.org 1.0 was that equivalent of this window was removed. It got reintroduced probably because it makes packaging LibreOffice for macOS easier.

> running identical software on multiple computer systems is the name of the software-architecture game

In the railway signalling industry (which for historically obvious reasons is obsessed with reliability) there even is a pattern of running different software implementing the same specification, written by different team, running on a different RTOS and different CPU architecture.

All the magic of Smalltalk is in the development tools that work by means of introspection into the running image, writing source code in text files causes you to lose all that. Add to that the fact that Smalltalk when written as source files is quite verbose.

Smalltalk does have standard text source file format, but that format is best described as human-readable, not human-writable. The format is essentially a sequence of text blocks that represent operations done to the image in order to modify it to a particular state interspersed with "data" (mostly method source code, but the format can store arbitrary stuff as the data blocks).

One exception to this is GNU Smalltalk which is meant to be used with source files and to that end uses its own more sane source file syntax.

PostgreSQL has this: https://www.postgresql.org/docs/current/ecpg.html

Unles the verification routine (eg. garage) keeps some state somewhere it has no way to prevent replays.

There is this kind of webdev-adjacent niche where the model of using documentation (or even intentionally sub-par documentation) as a marketing funnel for consulting and/or "Pro" versions is a thing. These projects are somewhat vocal about vibe coding killing their business models. If these projects really create any meaningful value is another question.

If I understand the history correctly then it started as a set of C preprocessor macros.

> Creating obfuscated values using integers

While that is often neat solution, do not do that by simply XORing the numbers with constant. Use a block cipher in ECB mode (If you want the ID to be short then something like NSA's Speck comes handy here as it can be instantiated with 32 or 48 bit block).

And do not even think about using RC4 for that (I've seen that multiple times), because that is completely equivalent to XORing with constant.