If you don't already know and need to be sure, you have to start over with new hardware in a new network with new secrets. Firmware may be compromised and traces covered up, so reinstalling the operating system is not guaranteed to get the attacker out, nor can you trust the system to tell you if it was compromised or not. Your best bet would have been to record all incoming network traffic to a system only accessible offline and use it to verify no one tried to get it. Otherwise you can just hope, which is what mostly everyone will do, and will mostly be alright, because they're not important enough.
If you haven't rebooted yet then you can check how many mtcp handshakes you've received. It takes a lot of them to exploit this. 48 minutes according to the disclosure. So if it's a small number you haven't been hacked. Use "nstat -az | grep -i mpcapable"
It makes me want to login in, to share the history and recommendations between screens. I think a neat way to do that would be to authenticate with some other service that can just store and sync an encrypted blob that is the Local Storage of the site. That could be fairly private and doesn't put any load on the first site, it wouldn't need accounts. This could be a browser feature but then it doesn't work between browsers.
If you read commit logs of, say kernel.org and a distro kernel, and aren't concerned you are blissfully ignorant (and it is worse for the broader userland repos). It's particularly bad when they don't track a kernel.org LTS. Their kernel orgs are pretty lean and this has been the status quo for decades. CVEs of sufficient stature like this will get fixed but majority of other issues slip by unnoticed. LTS is kind of a myth, it trades ABI and API stability for a lot of other issues.
For years, Red Hat employed more kernel developers than anyone and contributed more. These days they're "only" the fourth largest contributor, after Intel, Google, and Meta, but they are still among the largest corporate contributors.
If that's a lean kernel org, I don't know what a fat one would look like.
My hearsay, from friends and colleagues that work(ed) there, is that the shipped product is not really where you see these "heavy hitters".. a lot of the maintenance happens offshore.
The Noble 6.8.0 LTS kernel is a mess. Im not sure what we are going to do in our org. We have been discussing it for a few months. I want an in house fork based on an GKH LTS but others are hesitant to take on that level of responsibility.
Anything important should be virtualised and regularly snapshotted. Nothing is invulnerable but if it can be reconstituted in an hour, that’s close enough. If it isn’t and you care enough then a standby server with failover should take care of it.
Regardless of the OS, kernel, or program you select there will inevitably be holes in your stack. A VM will always provide better isolation and more flexibility. In this instance it would mean being able to patch the box running the service without messing with the driver for the backing storage.
Depends on the VM system. Full blown virtualization add complexity and attack surface. Running vmless[0] could be even better if you trust the design of the isolation enough.
I have found that Debian BPO kernel + BPO ZFS works well, and since ZFS gives you complete snapshotting capability a broken upgrade isn't as much of an issue, rolling back with zfsbootmenu is easy.
What usually happens to me is that I run a full package update, forget about it for a while, and then reboot. And then the server doesn't come back online - and I'm not in front of it to fix it.
LTS kernel pretty much solved this issue for me when I switched.
Over the past few months I've started to install newer ubuntu kernels using the mainline PPA. However, it goes long periods of time without getting updates, so it's not really a satisfactory solution. In one case I just built the kernel myself.
LTS doesn't work if you want immediate fixes like the current environment requires.
Given the current and rapidly upcoming environment, would that not imply that those are no longer viable choices? As like a fairly urgent emergency consideration?
If they cannot demonstate being systematically able to adapt towards the required reaction time (minutes? hours?) by almost-comically many orders of magnitude (multiple weeks), and it is only going to get worse, then what other conclusion could there be?
Like they'll only organizationally adapt when it's far too late (everybody using their shit has already been pwned), and then it'll be an unpracticed emergency adaptation.
No, they are providing a service, LTS, that customers still want and pay for. Only once the customers realise its not a workable product and they want a rolling update product, with all the changes that implies, will this change.
I’m pretty confused because apparently Anthropic is the group that followed “responsible disclosure” but apparently even though upstream was patched a couple weeks ago, still nothing on either.
They pull from Debian unstable every 6 months and that's it. Afterward, changes made in Debian mean nothing to Ubuntu.
Don't trust Ubuntu's LTS promises, either. Most of the modern packages you care about are in universe, which almost never gets patched after the initial release.
I think they deliberately leave the free LTS version insecure in order to sell Pro licenses. But guess what, even Pro doesn't get timely patches.
I'd be seriously considering Debian or, hear me out, NixOS. We run all our work servers on Ubuntu, but ~6 months ago I switched my workstation to NixOS and I couldn't be happier. I've been following "latest" or whatever they call it, being able to treat the OS package versions like the rest of our software (update the flake.lock file and then burn it in in dev+stg for ~2 weeks before rolling to prod) is pretty attractive.
to be fair their storage, and I mean their SANs, is still the best (excluding very expensive alternatives that are only really beating IBM in few limited scenarios).
I still like DB2, but only for banking/finance core stuff, and their mainframes are just unique machines, I'm very fond of them.
I don't think I can recall an instance where there was an issue this bad (a box being vulnerable just by virtue of being connected to the internet, or exposing nothing other than ssh) and I didn't have timely patches for it. I had to turn off my server and home automation system because of this. Really not acceptable at all and makes me want to switch everything to debian.
Going by the proxmox forum the fix is already in the sources (proxmox released their kernel based on them a few days ago). But I could not see, if it is already released for the users.
Yes, we (Proxmox) included the fix for this in 7.0.14-25, which was initially packaged two weeks ago.
It went through internal QA and to the test soon after that, then a few days later to the no-subscription repository and as of yesterday morning CET it was cleared for the enterprise one, so it's available on all repos of all Products we got in their current supported releases.
For kernel updates we where even more conservative in the past, but with the current churn on often quite relevant fixes picked up the pace a bit on moving them along, trying still to balance rolling out fixes fast(er) while not doing that so fast that tricky (hardware/setup specific) regressions don't get caught.
edit: As this makes the rounds we also released a PSA for it now [0] to make our status here easier to find.
He likes the look of nearest neighbor texture sampling, not software rendering.
You can do nearest neighbor in hardware rendering and you can do bilinear in software rendering. Rendering mode and texture sampling are two totally different things.
I think there's more to it. In Quake, the software renderer decides the color of each pixel, based on running some code on the CPU, which can do anything. GPU rasterization is far more standardized, with standards defining how each triangle ought to be sampled at each pixel coordinate (and the fact that you're sampling triangles in the first place).
The whole process is standardized with GPU rendering, leading to ways of rendering and content authoring that's quite different from how things used to be, and while definitely possible, modern 'retro' games often render like GPU accelerated games and just disable texture filtering, which doesn't quite give you the look.
He mentions Build games, which are not strictly polygonal.
While general purpose computation exists on GPUs, and the standard rasterization pipeline can be implemented in software, graphics cards have pushed people towards a 'look and feel' which comes partly from standardized data structures, content authoring and rendering approaches, that have made games feel samey.
Whereas with software rendering, essentially you have an array of pixels which you can set to a certain color, and the rest is up to you, which made devs come up with unique ways of rendering and authoring content.
The intricate level designs that were made possible with BSP based tools and are basically 'free' to render in software, had hell of a time making the transition to GPUs, as they rely on traversing the tree while drawing pixels, whereas for the GPU, you need to submit a list of triangles (unless you go GPGPU)
Modern games look samey because they all want the same result - photorealism - and aren't fussy about using an off-the-shelf solution - i.e. UE5 and Unity. We have absolutely insane levels of control over the rendering pipeline and almost everything is programmable; the GPU is an endless fountain of parallel programming. But in order to take advantage of any of that you have to actually start changing engine code, or write your own renderer, and games don't care because the default UE5 look is "good enough".
There is some standardization in that, if you issue geometry and sample textures normally, you will be relying on hardware units for rasterization and texture sampling, and those do have a relatively limited set of options for how they work. However, those options encompass most if not all of what 3D engines could ever want or need, even the early 3D ones that had all sorts of hacks. The kinds of things GPUs can't actually rasterize in hardware are things like NURBS or metaballs, but this doesn't matter because the industry settled on triangles[0] as the medium of real-time 3D really early on.
A lot of the look of old 3D games comes down to them doing things the lazy way, and I'm proud to say the lazy way is still very much supported - so long as you turn off features that didn't exist later on and limit yourself. I'm not as familiar with old DOS games, so I'll use the PS1 as an example. The "PS1 look" is very much a result of its incredibly limited rasterizer, whose limitations can be trivially emulated in modern hardware:
1. Don't allocate or bind a depth buffer. You will need to Z-sort your geometry every frame. Part of the "PS1 look" is that some games did it wrong; if you do it correctly you'll be burning performance for no visual benefit. Pick a scheme that breaks in a visually interesting way. Likewise make sure to not allocate any multisampling since the PS1 didn't anti-alias either.
2. Restrict the precision of vertices in your vertex shader by rounding them. The PS1 did vertex math with incredibly low precision and it makes vertices wobble.
3. Restrict the precision of UVs in your fragment shader. PS1 UVs were 0-255, so you want 1/256 precision.
4. Aggressively discard geometry that clips the edge of the viewport. The PS1 did not have proper polygon clipping; you just couldn't render off the end of the viewport, so games had to discard geometry and subdivide polygons to avoid things disappearing. This is another "if you do it well, nobody will notice" thing.
5. Turn off perspective-correct attribute interpolation; this will make your UVs warp and distort at certain angles. You do this with the `noperspective` attribute in GLSL.
6. Disable bilinear filtering when sampling textures.
7. Allocate and render to a low-precision color buffer. Lots of games would change the color depth to match the available VRAM. This is probably the hardest aspect to emulate unless you are actively counting VRAM usage and sticking to realistic values.
8. Bitcrush your textures before uploading them. The same reasoning applies here. Also, don't upload any mipmaps.
9. Lighting was done through vertex colors, which were calculated on the CPU. You don't have to limit yourself to CPU lighting but you do have to make sure lighting is done in the vertex shader.
10. Optional: implement the early model PS1 texture banding bug in your fragment shader.
This will give you a rendering pipeline that is good for basically all purposes except bit-accurate PS1 emulation. Of course, if you were doing bit-accurate emulation, nothing stops you from issuing a screen-filling quad and writing a GPU shader that does software rasterization on the GPU. Or launching a compute shader that accesses the framebuffer arbitrarily - although you do have to worry about memory coherency across warps and workgroups. Texture sampling can also be done "in software" if you so wish - i.e. by doing unfiltered reads to the texture which are glorified array lookups, and then filtering those reads as you wish.
[0] There was a brief moment where quads might have been able to win - artists like to work with them, and Nvidia was shipping quad hardware. But the advantage died very quickly, and quads can be easily converted to triangles - not so much the other way around.
However well intentioned your post may be in explaining this, it misses my point.
There's no single oldschool look, as people writing software renderers didn't have a sanctioned way of doing so - a lot of them weren't even using triangles, or were using a mix of techniques.
You are describing how to make a game look like the PS1 games, but the PS1 actually had a - somewhat flawed, but unique - GPU which kind of forced the limitations you outlined here, and forced a singular way of rendering.
That wasn't really true with Quake or Duke3D or the PC in general. You just drew to the screen with whatever technique you chose, which resulted in a unique look for each game.
What I think they are trying to tell you is that there isn't a single sanctioned way of doing modern accelerated rendering. One could argue there was when GPUs were less flexible and had a fixed pipeline, but modern day GPUs are absurdly versatile, and just as capable of handling any form of rendering that had to be done mainly in the CPU, either through compute shaders, or by creatively using the raytracing or rasterization pipelines. There have been some talks about ditching the traditional pipelines model altogether and moving towards an all computer shader + intrinsics model for modern APIs, inspired by CUDA, even. That's how flexible they've become.
In Quake's case, it uses rasterization. Modern GPUs' rasterization pipeline are extremely configurable, not even needing triangles as immediate inputs anymore.
Doesn't Duke3D use the same rendering method as Doom? While there's no specific acceleration for column-based rendering, compute shaders can replicate the same behavior, but in parallel.
Modern GPUs can handle, from raymarched fractals, to raytraced voxels, to rasterized PS1-inspired scenes, etc. It's not like styles are lacking. If anything, GPUs have provided opportunities for more weird combinations by making other techniques viable as well. Contrast that to past, where techniques were cutoff by hardware limitations, resulting in similar ones being used to achieve the same results (both Doom and Duke3d use column-based rendering, for instance).
Technically you're right, a gpu is just a bunch of ALU and FPU in a way, we just defer computation to a massive array of them so the cpu can do other things, what you do on these gpu cores is up to you.
That said, historically, software rendering meant non-accelerated passes that could be carried out by a cpu at decent enough FPS.
ps: some could also say that a FPU is not software rendering since early x86 didn't have it in the cpu.
But if you want to experience GLQuake that looks like software-rendered Quake, that's a simple settings change in your GPU driver, overriding the texture sampling mode. That's literally the only difference. I'm not sure the author is aware that it is a viable option to tweak the hardware rendering this way.
> if you want to experience GLQuake that looks like software-rendered Quake, that's a simple settings change in your GPU driver, overriding the texture sampling mode. That's literally the only difference.
Is that the case?
https://fabiensanglard.net/3dfx_sst1/ has a side-by-side screenshot comparison of the two, and software Quake's colours and lighting look way more rich and vibrant; it's not just smoother textures. It's possible that GLQuake/one of the many source ports since has improved on this though.
Of course I know this is a particular quality of GLQuake and not an actual limitation of hardware rendering. And I agree with in general with the contention that this article is talking about a particular art style associated with mid 90s software rasterizers rather than about "software rendering" itself.
In the caption under the image it explains that the 3Dfx card lacked gamma correction, which is why it looked so saturated. The Voodoo was a pass-through card: it had its own DAC for generating display signal when a full screen 3D game was running, but otherwise your 2D accelerator was used. So on the same machine a software rendered game and a 3D accelerated game had different output even if the frame buffer was identical, due to different circuitry (and the Voodoo card’s circuitry lacking gamma correction made it hella saturated as you see here).
This could have been corrected on the art side, by recalibrating the texture maps to the voodoo gamma levels, and that’s why there are great arcade machines from that era with wonderful graphics (designed for the hardware they were running in production), but GLQuake looks all washed out.
Are you sure? I haven't played enough Quake to know either way, but I did play Deus Ex in software mode (unreal engine), and that had a lot of differences to the other renderers. I very much doubt texture sampling mode alone would reach a similar result.
(It even had graphic errors, green textures in the faces etc giving everything a very alien look. But that's not what I mean).
May be a couple settings. IIRC full bright textures didn't translate well in early GPU renderers. Often they'd appear shaded as if they weren't light sources at all.
It would make the tampering more expensive, but not too expensive given the 100 million dollar reward, while also making inspection of the device practically impossible for users.
If you can't get to the insides without breaking it, the only devices verified to likely be safe would be unusable too, so the product would in practice be even more unsafe.
If the user first inspects it and then glue it on their own, that would work, but it wouldn't solve this problem. Evil maid attack is something else and obviously harder at scale.
reply