One of the most common ways of comparing the processing power of some microcontroller or older smartphone in a fantastical way was to say that they had more processing power than the Apollo Guidance Computer. While this sounds impressive on the surface, the AGC was the first integrated circuit computer ever built and is predictably under-powered by almost all modern standards. A more apt comparison would be to compare a smartphone to a supercomputer from some bygone era, and someone has recently done just that.
Cray 2
The linked article looks at a modern iPhone 17 compared to the Cray 2 supercomputer. When the Cray 2 was first built in the mid 80s, it was the fastest computer in the world at 1.9 GFLOPS using four vector processors. A modern iPhone is estimated to have slightly more than that, so in some ways the iPhone comes out on top.

However, the Cray 2 was built with vector processors, a specialized type of processor meant to perform rapid calculations on specific types of data sets. So the Cray 2 may have been faster at these types of tasks than the more general-purpose A19 processor, and the A19 may have the edge in other tasks.

The other major difference the article doesn’t discuss is what software runs on these computers. The Cray 2 supercomputer ran a modified version of UNIX System V, which at the time was owned by AT&T (and which ran on plenty of other computers as well). Although proprietary in some sense, it was much more open than Apple’s iOS operating system, allowing users to run whatever software they wanted to run on the supercomputers that they bought and paid for, and to modify many parts of the operating system itself. In that sense, the Cray will always maintain the edge over Apple and their walled garden.

hackaday.com/2026/03/26/modern…

A significant proportion of cyber incidents are linked to supply chain attacks, and this proportion is constantly growing. Over the past year, we have seen a wide variety of methods used in such attacks, ranging from creation of malicious but seemingly legitimate open-source libraries or delayed attacks in such seemingly legitimate libraries, to the simplest yet most effective method – compromising the accounts of popular library owners to subsequently release malicious versions of their libraries. Such libraries are used by developers everywhere and are included in many solutions and services. The consequences of an attack can vary widely, ranging from delivering malware to a developer’s device to compromising an entire infrastructure if the malicious library has made its way into the code of a service or product.

This is exactly what happened in March 2026, when attackers injected malicious code into the popular Python library LiteLLM, which serves as a multifunctional gateway for a large set of AI agents. The attackers released two trojanized versions of LiteLLM that delivered malicious scripts to the victim’s system. Both versions made their way into the PyPI repository for Python. A technical analysis revealed that the attackers’ primary targets were servers storing confidential data related to AWS, Kubernetes, NPM, etc., as well as various databases (MySQL, PostgreSQL, MongoDB, etc.). In the latter case, the attackers were primarily interested in database configurations. In addition, the malware’s logic included functionality for stealing confidential data from crypto wallets and techniques for establishing a foothold in the Kubernetes cluster.

Repository compromise

The compromise affected the package distribution channel via PyPI: on March 24, 2026, malicious LiteLLM versions litellm==1.82.7 and litellm==1.82.8 were uploaded to the registry. It was specifically the package’s distribution contents that were compromised: in the version 1.82.7, the malicious code was embedded in proxy_server.py, and in 1.82.8, the file litellm_init.pth was added.

Technical analysis

Both versions of the library contained the same malicious code, but its execution was implemented differently. In the version 1.82.7, it was executed only when the proxy functionality was imported, while in 1.82.8, a .pth file was added that was able to execute the code every time the interpreter started.

Example of the malicious code in proxy_server.py

The malicious code in the proxy_server.py and litellm_init.pth files contained Python code encoded in Base64. After execution, the infected script saved this code alongside itself as a p.py file and immediately executed it.

The p.py script launched the main payload – another script, also encoded in Base64 – without saving it to disk. At the same time, it wrote the output of this payload to a file in the directory from which it was launched. Before being written, the output was encrypted using the AES-256-CBC algorithm with a random key generated in the code, which was saved to the session.key file. The key file was also encrypted – using a pre-initialized public RSA key.

The encrypted key and the output were combined into a tpcp.tar.gz archive and sent to the attackers’ remote server.

What exactly happened within the malicious payload, whose output was sent to the C2 server? After it was launched, a recursive scan of the working directories on the victim’s system (/root, /app/, /var/www, etc.) began. In each directory, the script scanned the contents of files, which it output to the stdout buffer, from where it was then saved to the aforementioned file as the result. Next, the script collected system information and also saved it to a file. After that, it proceeded to search for sensitive data. It was interested in the following data located on servers and within the infrastructures of various services:

• SSH keys
• GIT accounts
• .env files
• AWS, Kubernetes, email service, database, and WireGuard configurations
• files related to Helm, Terraform, and CI
• TLS keys and certificates

A notable feature of this malware is that it does not limit itself to stealing files and configurations from the disk, but also attempts to extract runtime secrets from the cloud infrastructure.

The code above uses the addresses 169.254.169.254 and 169.254.170.2. The first corresponds to the AWS Instance Metadata Service (IMDS), through which an EC2 instance (a virtual server in AWS, a machine running in the cloud) can retrieve metadata and temporary IAM role credentials (an AWS account with a set of permissions that a service or application can use to obtain temporary credentials for calls to the AWS API). The second is used in Amazon ECS to issue temporary credentials to a container during execution. Thus, the malicious script targets not only static secrets but also those issued by the cloud that can grant direct access to AWS resources at the moment of infection.

Additionally, the script searches for crypto wallet configurations, as well as webhooks associated with Slack and Discord messengers. The latter indicate that attackers are interested not only in infrastructure secrets and accounts, but also in communication channels within the development team.

In the next stage, the malware moves from data collection to establishing a foothold in the Kubernetes cluster infrastructure: if it has enough access, it configures a privileged pod (the smallest execution unit in Kubernetes, containing one or more containers) by enabling the securityContext.privileged=true option and mounts the node’s root filesystem via hostPath. This allows it to escape the container and perform actions at the node level.

Next, the malware executes another stage of infection – it saves a base64-encoded script disguised as a legitimate system component to the Kubernetes node’s disk at the path /root/.config/sysmon/sysmon.py, and registers it via systemd. After launching, the script waits for an initial delay of 300 seconds, then begins periodically contacting the C2 node checkmarx[.]zone/raw, retrieving a link to the next payload from there. If the received value differs from the state previously saved in /tmp/.pg_state, the script downloads a new file to /tmp/pglog, makes it executable, and runs it in the background. At this stage, the attackers gain a foothold in the system and is capable of regularly delivering updated payloads without the need for re-injection. Since the malicious payload is written not to the container’s temporary file directory but directly to the Kubernetes cluster node, the attackers will retain access to the infrastructure even after the container has terminated.

A similar scenario is used for local persistence: in the absence of Kubernetes, the sysmon.py script is deployed in the user’s directory at ~/.config/sysmon/sysmon.py and is also registered as a service via systemd.

OpenVSX version of the malware

While analyzing files communicating with the C2 server, we discovered malicious versions of two common Checkmarx software extensions: ast-results 2.53.0 and cx-dev-assist 1.7.0. Checkmarx is used for application security assessment. These trojanized extensions contained malicious code that delivered the NodeJS version of the malware described above.

This version is downloaded from checkmarx[.]zone/static/checkmarx-util-1.0.4.tgz using NodeJS package installation utilities and is named checkmarx-util. Its key difference from the Python version is that it does not attempt to elevate privileges to the Kubernetes node level and does not create a privileged pod for persistence. Instead, it implements local persistence within the current environment. This means that the NodeJS variant persists only where it is already running.

Additionally, the list of folders to search for and steal secrets from is significantly smaller in this version than in the Python variant.

Checkmarx extensions are used to scan code and infrastructure configurations, so their compromise is quite dangerous: an attacker gains access not only to project files but also to a significant portion of the development environment, tokens, and local configurations.

Victimology

While assessing the attack’s impact, we saw victims all over the world. Most infection attempts occurred in Russia, China, Brazil, Netherlands and UAE.

Conclusion

As the technical analysis shows, the malicious scripts found in the LiteLLM versions are dangerous not only because they steal files containing sensitive data, but also because they target multiple critical infrastructure components simultaneously: the local system, cloud runtime secrets, the Kubernetes cluster, and even cryptographic keys. Such a broad scope of data collection allows an attacker to quickly move from compromising a single system and Python environment to seizing service accounts, secrets, and entire infrastructures.

Prevention and protection

To protect against infections of this kind, we recommend using a specialized solution for monitoring open-source components. Kaspersky provides real-time data feeds on compromised packages and libraries, which can be used to secure the supply chain and protect development projects from such threats.

Home security solutions, such as Kaspersky Premium, help ensure the security of personal devices by providing multi-layered protection that prevents and neutralizes infection threats. Additionally, our solution can restore a device’s functionality in the event of a malware infection.

To protect corporate devices, we recommend using a complex solution such as Kaspersky NEXT, which allows you to build a flexible and effective security system. The products in this line provide threat visibility and real-time protection, as well as EDR and XDR capabilities for threat investigation and response.

At the time of writing, the compromised versions of LiteLLM have already been removed from PyPI and OpenVSX. If you have used them, and as a proactive response to the threat, we recommend taking the following measures on your systems and infrastructure:

• Perform a full system scan using a reliable security solution.
• Rotate all potentially compromised credentials – API keys, environment variables, SSH keys, Kubernetes service account tokens, and other secrets.
• Check hosts and clusters for signs of compromise – the presence of ~/.config/sysmon/sysmon.py files, suspicious pods in Kubernetes.
• Clear the cache and conduct an inventory of PyPI modules: check for malicious ones and roll back to clean versions.
• Check for indicators of compromise (files on the system or network signs).

Indicators of Compromise:

URLs
models[.]litellm[.]cloud
checkmarx[.]zone

Infected packages
85ED77A21B88CAE721F369FA6B7BBBA3
2E3A4412A7A487B32C5715167C755D08
0FCCC8E3A03896F45726203074AE225D

Scripts
F5560871F6002982A6A2CC0B3EE739F7
CDE4951BEE7E28AC8A29D33D34A41AE5
05BACBE163EF0393C2416CBD05E45E74

securelist.com/litellm-supply-…

Introduction

On March 4, 2026, Google and iVerify published reports about a highly sophisticated exploit kit targeting Apple iPhone devices. According to Google, the exploit kit was first discovered in targeted attacks conducted by a customer of an unnamed surveillance vendor. It was later used by other attackers in watering-hole attacks in Ukraine and in financially motivated attacks in China. Additionally, researchers discovered an instance with the debug version of the exploit kit, which revealed the internal names of the exploits and the framework name used by its developers — Coruna. Analysis of the kit showed that it relies on the exploitation of many previously patched vulnerabilities and also includes exploits for CVE-2023-32434 and CVE-2023-38606. These two vulnerabilities particularly caught our attention because they had been first discovered as zero-days used in Operation Triangulation.

Operation Triangulation is a complex mobile APT campaign targeting iOS devices. We discovered it while monitoring the network traffic of our own corporate Wi-Fi network. We noticed suspicious activity that originated from several iOS-based phones. Following the investigation, we learned that this campaign employed a sophisticated spyware implant and multiple zero-day exploits. The investigation lasted for over six months, during which we disclosed our findings in connection to the attack. Kaspersky GReAT experts also presented these findings at the 37th Chaos Communication Congress (37C3).

Although all the details of both CVE-2023-32434 and CVE-2023-38606 have long been publicly available, and other researchers have developed their own exploits without ever seeing the Triangulation code, we decided to closely investigate the exploits used in Coruna. Some of the exploit kit distribution links provided by Google remained active at the time the report was published, which allowed us to collect, decrypt, and analyze all components of Coruna.

During our analysis, we discovered that the kernel exploit for CVE-2023-32434 and CVE-2023-38606 vulnerabilities used in Coruna, in fact, is an updated version of the same exploit that had been used in Operation Triangulation. The images below illustrate a high-level overview of the two attack chains. The exploit in question is highlighted with a red rectangle.

Attack chain of Operation Triangulation (simplified)

Attack chain of Coruna (simplified)

Moreover, we discovered that Coruna includes four additional kernel exploits that we had not seen used in Operation Triangulation, two of which were developed after the discovery of Operation Triangulation. All of these exploits are built on the same kernel exploitation framework and share common code. Code similarities from kernel exploits can also be found in other components of Coruna. These findings led us to conclude that this exploit kit was not patchworked but rather designed with a unified approach. We assume that it’s an updated version of the same exploitation framework that was used — at least to some extent — in Operation Triangulation.

Technical details

While we continue to investigate all exploits and vulnerabilities used by Coruna, this post provides a high-level overview of the exploit kit and attack chain.

Safari

Exploitation begins with a stager that fingerprints the browser and selects and executes appropriate remote code execution (RCE) and pointer authentication code (PAC) exploits depending on the browser version. It also contains a URL to an encrypted file with information about all available packages containing exploits and other components. The stager also includes a 256-bit key used to decrypt it. The URL and decryption key are passed to a payload embedded in PAC exploits.

Payload

The payload is responsible for initiating the exploitation of the kernel. After initialization, the payload first downloads a file with information about other available components. To extract it, the payload performs several steps processing multiple file formats.

First, the downloaded file is decrypted using the ChaCha20 stream cipher. Decryption yields a container with the magic number 0xBEDF00D, which stores LZMA-compressed data.

The file format used by the exploit kit to store compressed data

The decompressed data presents another container with the magic number 0xF00DBEEF. This file format is used in the exploit kit to store and retrieve files by their IDs.

The file format used by the exploit kit to store files

We provide a description of all possible File ID values below. At this stage, when the payload gathers information about all available file packages, this container holds only one file, and its File ID is 0x70000.

Finally, we get to the file with information about all available file packages. It starts with the magic value 0x12345678. The exploit kit uses this file format to obtain URLs and decryption keys for additional components that need to be downloaded.

The file format used by the exploit kit to store information about file packages

The components required for exploiting a targeted device are selected using the Package ID. Its high byte specifies the package type and required hardware. We’ve seen the following package types:

• 0xF2 – exploit for ARM64,
• 0xF3 – exploit for ARM64E,
• 0xA2 – Mach-O loader for ARM64,
• 0xA3 – Mach-O loader for ARM64E,
• 2 – implant for ARM64,
• 0xE2 – implant for ARM64E.

The payload code also supports additional package types, such as 0xF1, an exploit for older ARM devices that do not support 64-bit architecture. Interestingly, however, the files for such exploits are missing.

Other bytes of the Package ID define the supported firmware version and CPU generation.

Some of the observed Package IDs (those with unique content)

The files inside these packages are also stored in encrypted and compressed 0xF00DBEEF containers, but this time compression is optional and is determined by the second bit in the Flags field. Different packages contain different sets of files. A description of all possible File IDs is given in the table below.

Observed File IDs

After downloading the necessary components, the payload begins executing kernel exploits, Mach-O loaders, and the malware launcher. The payload selects an appropriate Mach-O loader based on the firmware version, CPU, and presence of the iokit-open-service permission.

Kernel exploits

We analyzed all five kernel exploits from the kit and discovered that one of them is an updated version of the same exploit we discovered in Operation Triangulation. There are many small changes, but the most noticeable are as follows:

• The code takes into account more values ​​from XNU version strings, allowing for more accurate version checking.
• Added a check for iOS 17.2. We assume that this was the latest version of iOS at the time of development (released in December 2023).
• Added checks for newer Apple processors: A17, M3, M3 Pro, M3 Max (released in fall 2023).
• Added a check for iOS version 16.5 beta 4. This version patched the exploit after our report to Apple.

Why does the exploit need to check for iOS 17.2 and newer CPUs if the targeted vulnerabilities were fixed in iOS 16.5 beta 4? The answer can be found by examining other exploits: they are all based on the same source code. The only difference is in the vulnerabilities they exploit, so these checks were added to support the newer exploits and appeared in the older version after recompilation.

Launcher

The launcher is responsible for orchestrating the post-exploitation activities. It also uses the kernel exploit and the interface it provides. However, since the exploit creates special kernel objects during its execution that provide the ability to read and write to kernel memory, the launcher simply reuses these objects without the need to trigger vulnerabilities and go through the entire exploitation path again. The launcher cleans up exploitation artifacts, retrieves the process name for injection from a config with the 0xDEADD00F magic number, injects a stager into the target process, uses it to execute itself, and launches the implant.

Conclusions

This case demonstrates once again the dangers associated with such malicious tools that lie in their potential wide usage. Originally developed for cyber-espionage purposes, this framework is now being used by cybercriminals of a broader kind, placing millions of users with unpatched devices at risk. Given its modular design and ease of reuse, we expect that other threat actors will begin incorporating it into their attacks. We strongly recommend that users install the latest security updates as soon as possible, if they have not already done so.

securelist.com/coruna-framewor…

One might think that [Da_Rius]’s mostly 3D printed wire stripper would count its insulation-shearing blades among the small number of metal parts required, but that turns out to not be the case. The blades are actually printed in PLA, seem to work just fine for this purpose. (We imagine they need somewhat frequent replacement, but still.)

Proper wire strippers are one of the most useful tools for a budding electronics enthusiast, because stripping hookup wire is a common task and purpose-built strippers make for quick and consistent results.

As far as tools go they are neither particularly expensive nor difficult to source, but making one’s own has a certain appeal to it. The process of assembling the tool is doubtless a rewarding one, and it looks like it results in a pretty good conversation starter if nothing else.

As mentioned, the tool is mostly 3D printed and does require some metal parts: fasteners, heat-set inserts, and a couple springs. Metal nuts and heat-set inserts are easy enough to obtain, but springs of particular size and shape are a bit trickier.

It is perfectly possible to make custom springs, and as it happens [Da_Rius] already has that covered with a separate project for using a hex key and printed jig to make exactly the right shapes and sizes from pre-tempered spring wire.

hackaday.com/2026/03/26/3d-pri…

Check your tape for spider nests before rewinding. (Credit: Brady Brandwood, YouTube)
Physical media has a certain amount of durability associated with it, a quality which is naturally determined by the way that they’re stored. Generally this does not involve being abandoned on the porch of a delipidated, abandoned house where the elements and any passing critter can have their way with it.

Exactly how playable would these VHS tapes and CDs still be? Whether it was out of a sense of burning curiosity, or for a similar reason that [Brady Brandwood] has a habit of adopting former seafood critters like lobsters as adorable pets, these items got recently collected and put to the test.

Normally VHS tapes are kept safely in a little sleeve or box in a dry, cool place, similar to CDs and DVDs. These particular items had however been left for at least a decade out in the open amidst the ransacked remains of abandoned homes. This meant that the VHS tapes were full of dirt and debris, and at least in one case with a spider nest that jammed up the thrift-store VHS/DVD combo player.

The CDs were cleaned and tried in a G5 iMac, with the obvious results there being that as long as the shiny layer with the data was intact, they worked fine. While a damaged disc tried to play somewhat, even the amazing audio CD error-correcting algorithms can not compensate for see-through gashes.

Perhaps the real surprise came from the VHS tapes, none of which had any protection from the elements other than the little plastic flap that keeps human paws from touching the tape directly. Although one tape looked somewhat moldy, after evicting a spider nest and some general clean-up, it played mostly fine.

One tape apparently it had a copy of The Land Before Time movie on it, while others contained various recordings, including of a concert with [Jerry Lee Lewis] and a recording of a Cartoon Network episode. Although the VCR’s head needed to be cleaned once during this whole test to remove some black gunk, none of the tapes seemed to show any signs of sticking, delaminating or any other issue commonly associated with degraded tapes.

This difference in physical durability between CDs and VHS tapes ought to not come as a surprise to anyone who has ever dropped a CD and saw the Scratch of Death on its shiny surface, yet the fact that the tapes survived what must have been years of Appalachian seasons is definitely somewhat impressive.

youtube.com/embed/lh-a8bTkGtQ?…

hackaday.com/2026/03/25/testin…

Many people base huge swaths of their lives on foundational philosophical texts, yet few have read them in their entirety. The one that springs to the forefront of many of our minds is The Art of Computer Programming by Donald Knuth. Full of many clever and outright revolutionary algorithms and new ways of thinking about how computers work, [Attoparsec] has been attempting to read this tome from cover to cover, and has found some interesting tidbits. One of those is the various algorithms around Gray Codes, and he built this device as a visual aid.

Gray Codes, otherwise known as reflected binary, is a way of ordering an arbitrarily large set of binary values so that only one bit changes between any two of them. The most common place these are utilized is in things like rotary encoders, where it provides better assurance that the position of a shaft is in a known location. To demonstrate this in a more visual way [Attoparsec] hooked up an industrial signal light, normally used for communicating the status of machinery in a factory, and then programmed it to display the various codes. A standard binary counter is used as a reference, and it can also display standard Gray Code as well as a number of other algorithms used for solving similar problems.

[Attoparsec] built this as an interactive display for the Open Sauce festival in San Francisco. To that end it needed to be fairly rugged, so he built it out of old industrial equipment, which is also a fitting theme for the light itself. There’s also a speed controller and an emergency stop button which also add to the motif. For a deeper dive on Gray Codes and their uses, take a look at this feature from a few years back.

youtube.com/embed/Z9X3dH5LjrM?…

hackaday.com/2026/03/25/demons…

In the maker world, it’s the Arduino and ESP32 lines that get the lion’s share of attention. However, you can do fantastic things with PIC chips, too, if you put the dev time in—it’s just perhaps less likely another maker has done so before you. A great example is this VGA output project from [grecotron].

A PIC18F47K42 is perhaps not the first part you would reach for to pursue any sort of video-based project. However, with the right techniques, you can get the 8-bit microcontroller pumping out the pixels surprisingly well. [grecotron] was able to get the chip outputting to a VGA monitor at a resolution of 360 x 480 with up to 16 colors. It took some careful coding to ensure the chip could reliably meet the timing requirements for the standard and to get HSYNC, VSYNC, and the color signals all dancing in harmony. Aiding in this regard was that the chip was clocked with a 14.3182 MHz crystal to make it easy to divide down from all the internal timers as needed. Supporting hardware is light, too—primarily consisting of a VGA connector, a couple of multiplexers, and resistor ladder DACs for the color signals. Files are on Github for those interested in deeper detail on the work.

VGA output is possible to implement on all kinds of microcontrollers—and even a bunch of raw logic if you know what you’re doing. If you’re pursuing your own video output wizardry, be sure to let us know on the tipsline.

hackaday.com/2026/03/25/vga-ou…

Digital clock projects have been with us since the 1970s, when affordable LEDs and integrated circuits became available. In 2026 most of them use a microcontroller, but for the AliExpress fans there’s one that goes straight back to the ’70s with a pile of logic chips. You can make it on the supplied PCBs, but that wasn’t for [ALTco]. Instead, he made the circuit in free form, using six metres of brass wire.

The construction is anchored together by a set of busbars that carry sockets for a set of seven-segment and driver modules. The circuit is typical for the day, with a crystal oscillator and divider chain feeding the counters for the displays. There are a few clever tricks that older engineers might recognize in order to reduce the chip count. In this case that’s negated by an extra set of circuitry allowing the time to be set from a rotary encoder.

We’re impressed by the intricacy of the device, made bit by bit without a plan, it as some wires what thread their way between others. It’s a truly beautiful piece, and it reminds us of our circuit sculpture contest back in 2020.

youtube.com/embed/w20A85zaaos?…

hackaday.com/2026/03/25/the-mo…