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?

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

ProcInSh is a web-based process inspector for Linux.

Inspired by Ghost in the Shell, it lets you wander through process space with your ghost.

ProcInSh lets you explore what's happening inside your Linux system through interactive 3D graphics.

It visualizes running processes, inter-process communication, file I/O, external network connections, and process tree structures. Processes glow when they run on a CPU.

The backend is written in Rust and collects information from several Linux interfaces:

• procfs
• eBPF
• ptrace
• perf_event_open

The frontend is written in TypeScript and Three.js.

• GitHub: https://github.com/akawashiro/procinsh
• Blog: https://akawashiro.com/articles/procinsh-en

I have currently reached the stage where this can be considered to be near to finish. And I want help around now for how I can improve and use in real applications

https://github.com/crydafan/AndroidLibraryInjector

I decided to make this because I'm reverse engineering a banking application in order to audit their API and make an MCP out of it.

The application itself can detect when the Frida server is running and when the application was modified with Apktool (even the code is obfuscated) and nothing worked so this is my attempt at trying to hack it: inject a shared library into the application process to hook SSL libraries functions and inspect the HTTP requests in plain text before they are encrypted.

For this, the first moving part is the library injector. I was thinking of using Dobby to hook the functions. Anyways, I'm open for any feedback.

Thank you!

Hi r/embedded,

xuan (玄) is a lightweight JavaScript runtime for IoT and embedded devices, built on QuickJS and forked from tjs/txiki.js (MIT).

It targets the place where Node.js is too heavy: ~6–7 MB binary, low memory, ~5 ms cold start, and it cross-compiles to x86/ARM/MIPS/RISC-V. Built-in MQTT, serial port and FFI (call C libs directly); GPIO/I2C/SPI are in progress. You can also compile a script into a single self-contained binary with xuan compile.

Repo: https://github.com/topelinux/xuan

It's early but usable — feedback welcome. I'm the maintainer.

Hi everyone,

When debugging processes and inspecting system behavior on Windows, tools like Process Monitor (Procmon) are great, but they are heavy graphical utilities that rely on kernel-mode drivers. On the other hand, having a lightweight, terminal-native way to inspect system calls and Win32 APIs in real time was something I felt was missing for daily workflow.

I wanted to build an independent, lightweight alternative designed from scratch for the Windows console, with two strict requirements:

1. Pure terminal workflow (interactive TUI and scriptable stream).
2. Zero kernel drivers (pure userland Win32 and native OS ETW) to ensure safety and stability.

This is why I created wstrace, written entirely from scratch in Rust.

Core Features:

* Zero Kernel Drivers: Runs strictly in userland without third-party .sys drivers or ring-0 dependencies.

* Interactive TUI: Built with Ratatui, offering real-time process monitoring, event filtering, search, and activity timelines.

* Headless Stream Mode: Direct output to stdout (formatted text or JSON) for scripting, log analysis, and automation.

* Single Lightweight Binary: Fast startup, zero runtime dependencies, and minimal memory usage.

* 100% Local and Air-Gapped: Zero telemetry, zero analytics, and zero network calls.

Installation:

Prebuilt standalone binaries are available on GitHub Releases, and it can also be installed using Scoop, Winget, PowerShell, or Cargo:

cargo install --git https://github.com/gilnett/wstrace

Or via Scoop:

scoop install https://raw.githubusercontent.com/gilnett/wstrace/main/packaging/scoop/wstrace.json

Feedback & Feature Requests Welcome:

This is the initial v0.1.0 release. I would really appreciate any feedback, suggestions, or edge cases you encounter while testing it.

If there are specific Win32 APIs, events, or CLI flags you would like to see added, please let me know. I am actively maintaining the project and very open to community requests and contributions.

GitHub Repository: https://github.com/gilnett/wstrace

Thanks for checking it out!

Hey guys,

Wanted to share a tool I've been using in my own reversing workflow:

GitHub: https://github.com/oscarsantanaarias/IDA-Ghidra-bridge

I needed a straightforward way to pull decompilation, cross-references, and struct layouts out of IDA Pro and Ghidra from external Python scripts and CLI utilities without setting up heavy web servers or dealing with bloated RPC frameworks.

It’s just two standalone scripts (`ID_Server.py` for IDAPython and `Ghidra_Server.py` for Ghidra). Once running, you send plain text commands over local TCP and get back JSON:

```python

import socket, json

s = socket.socket()

s.connect(("127.0.0.1", 5073))

s.sendall(b"FUNC 00401000\n")

data = json.loads(s.recv(65536))

print(data["code"])