This year has seen massive uptake of AI models & crazy PyPI supply chain attacks (like today's LiteLLM repeat!). Combining the two, I thought it was wortwhile chatting about Rank-One Model Editing (ROME) attacks...

There's a range of ways python would get to a model / GPU -> this attack has malicious (naughty) python writing directly to GPU memory. That makes it particularly hard to catch given there's no spawned processes, or new files or any network calls to hunt for.

For those interested - there's a deep dive blog from cyber org Stealthium that covers GPU-side detection (tracing CUDA kernels launches via eBPF) and potential ways to achieve further stack attribution.

Welcome the communities thoughts? Reckon any of these model corruption attacks are in the wild and not yet been caught/seen?

(((Also while the example is soviet propaganda, anybody aware of other nations that like both model development, influence campaigns and rewriting history? Just sayin...)))

Shout out to the researchers behind the original paper, Locating and Editing Factual Associations in GPT: Kevin Meng, David Bau, Alex Andonian and Yonatan Belinkov. + to the folks at Mithril Security for their PoisonGPT work a while back.

I've been trying to fix an old laptop of mine (Acer Aspire ES1-531-P7KK) for a while now. It'd been locked to 0.48GHz, only clocking up to higher speeds temporarily while idle occasionally (though that could be due to the kernel simply reporting last requested frequency when the core wasn't in deep-idle C state). I isolated the assertion to a bunch of corroded resistors. I don't have the skill to replace 0402SMD resistors, nor do I have the tools for it, so I began tracing how the throttling mechanism works. I dumped my BIOS, ran it through UEFITool, extraced the PE32 Image Section, and found two IFR pages (Power and Advanced) that had mentions of "PROCHOT", which I've attached.

I tried booting into a UEFI shell and writing to NVRAM with setup_var.efi, but I got a Write Protection error. The BIOS lock is disabled ("Enable or Disable BIOS SPI region write protect," according to the extracted IFR), so I genuinely don't know what to do. Is there any other trick that I can try, or do I need to get my hands on a pi pico, logic shifter, SOIC8 clip, 3.3V to 1.8V DC, etc, and extract the BIOS, modify it to expose the hidden settings, and flash it back?

Despues de mucho tiempo ya esta publicado el core PQC de nexus-q con los demas crates disponibles, ya puedes utilizar el motor PQC open source con licencia MIT y Apache 2.0. SDK LENGUAJES, CLI, SERVER.

Brenchmarks disponibles Resultados:

ML-KEM-768/1024 y ML-DSA-65 entre 0.86x y 1.05x vs AWS-LC

Estoy trabajando ahora en incorporar el core dentro de los SDK para que no tengais que instalar libreria externas ni configurar nada manualmente.

Aun que el rust esta listo, quiero llevar la experencia de nexus-q a todos o los lenguajes mas usados. Para que sea lo mas facil posible instalar nexus-q sea el lenguaje que sea que estes utilizando.

Y recuerda OPEN SOURCE. Te dejo abajo el enlance a la web donde tienes toda la informacion y acceso directo al repositorio.

Compartelo, pruebalo, destruyelo, investigalo

Cualquier error que podais llegar a encontrar no dudeis en abrir una issue o si vais mas alla hacer fork y abrir PR

[Nexus-Q](http://www.nexus-q.link)

Currently working on the Graphic driver of Nvidia GForce 210
we can discuss about low level programming, IoT, webDev....

Am I the only one who finds it annoying when a website uses .blob URLs for media/content that can only be played inside that specific page?

I was wondering if it would be possible to build a browser extension that hooks into SourceBuffer.appendBuffer() and observes the binary chunks being passed to it.

The concept would be pretty simple:

Server → encrypted/chunked data → browser → appendBuffer() → decoder/player

The extension would collect the buffers as they arrive, keep them in the correct order, and potentially reconstruct the original resource from those fragments.

Not talking about breaking DRM or decrypting something the browser itself can't decrypt. More like:

If the browser receives and processes the data, why can't we have a DevTools-like tool that lets us inspect and reconstruct those buffers?

Something like a "Blob Inspector":

• Intercept appendBuffer() calls
• See the individual chunks
• Track their order/size
• Reassemble them
• Identify the resulting media/container format
• Export the reconstructed data when possible

It seems like Network DevTools gets you close, but .blob/MSE-based streaming makes it surprisingly difficult to get back to the actual resource.

Has anyone already built something like this?

Or is there some fundamental browser/MSE limitation that makes this approach impractical?

im creating ai model claude.ai with verification is upto me see the chat for expermental purpose ,it's training under constitutional ai strictly claude chat

Hello everyone,

I have been using eBPF/XDP for the past 5 years and was always a little frustrated by the lack of tooling when it comes to see what is happening underneath, especially when debugging deployed eBPF programs. Here I am sharing a tool I have been using for a couple of months now but only made public recently: ebpfexplorer.

It's a simple TUI self contained binary, that allows you to explore all eBPF programs & maps attached to your kernel. It comes with a formatting tool that allows you to format the raw binary blob into human readable symbols (like IPs for instance), using C type format.

Please have a look and feel free to propose PRs. Hope you find it useful too.

Hi everyone,

I've been working on NexOS, a Linux distro aimed at students and makers who want a PC that's ready for electronics and development right after install, instead of spending an afternoon setting everything up.

What ships out of the box (each tested inside the image):

- Arduino Center: 100 curated libraries in 20 categories, with version, license and dependency info. 82 of them compile-verified offline, plus board and serial-port diagnostics

- KiCad 9 (tested ERC/DRC, Gerber export, 3D render)

- TeX Live + TeXmaker, including French and Arabic documents

- Python Center: 8 ready environments (science, AI, vision, electronics, data, code quality…)

- An AI assistant that runs fully offline on the CPU, loaded only when you use it

- One store (Debian packages + Flathub), Btrfs snapshots before/after every update with one-click rollback, ufw firewall on by default

Full disclosure: I built this with heavy help from an AI coding assistant (Claude). It wrote a lot of the build scripts, tests and docs under my direction, and every feature claim above comes from a test that actually ran in the image. The evidence is in the repo.

Honest limits:

- It's a prototype, tested in VMs (QEMU, VirtualBox) but not yet on real hardware

- It's not lighter than Ubuntu: about 1.07 GB RAM at idle in my VM tests. I published the comparison, including where it loses

- No proprietary NVIDIA driver yet; you need to disable Secure Boot to boot the ISO

What would help me most: if you try it in a VM or on a spare PC, tell me your hardware and what worked or broke.

GitHub (ISO in Releases): https://github.com/rayanetaieb/NexOS

Thanks for reading, happy to answer any questions!

Hey everyone I’ve been experimenting with low-level systems programming in Rust and built a tiny, #!\[no_std\] lock-free map using atomic CAS and open addressing. First time sharing an open source systems project, I’d love to hear your thoughts or code critiques! ❤ the link https://github.com/voryiex/Titan-Cache-Engine

just a thought - devs with experience , please help me out atp

Hey everybody, I was taking a course in Embedded Operating Systems, and since my primary way of taking notes is Obsidian, I found it pretty annoying to deal with it since it’s missing some basic stuff like highlighting for ARM or RISC-V, and also dealing with memory maps and registers.

So I vibecoded a plugin to fix this small niche issues, it has some pretty comfy features, with hover cards for instructions and conversion of numbers in different basis, diagrams and also syntax for other smaller things such as Makefile, Linker Script, Verilog etc…

I wanted some opinions from external users, and thought that could be useful for the few people in my situation

Any tips or recommendations are welcome!

Instead of pointer-chasing through B-Tree node hierarchies, this index models the key distribution using streaming piecewise linear regression with strict epsilon error bounds.

Lookups compute positions directly on the CPU ALU before a local L1 cache search, reducing memory by 99% and cutting latency by 3x.

To clarify the technical phrasing without buzzwords:

1. Baseline: BTreeMap is indeed mutable. PGM indexes target immutable / read-heavy sorted datasets (OLAP engines, columnar storage, and SSTables in LSM trees). Even compared to a flat slice::binary_search (~20 cache line jumps across an 8MB array for 1M keys), PGM drastically reduces memory traffic.
2. ALU computation: Once segment parameters are loaded, the index position is estimated with a single multiply-add instruction in CPU registers: pos = y0 + slope * (key - x0). No pointer chasing or node traversals.
3. L1 cache search: Because error is mathematically bounded to +/- epsilon (e.g. epsilon = 16), the target key is guaranteed to sit within a contiguous 256-byte slice (4 cache lines). The local search hits L1 cache with prefetching rather than jumping across RAM.

The implementation and release benchmarks are reproducible here: https://github.com/gilnett/learned_index_lab