With Elliot back from Hackaday Europe, he and Al Williams had a lot to talk about with two weeks of Hackaday posts to catch up on. Not to mention the mailbag was overflowing.

This week, the guys look at girlie cyberdecks, a 3D printed circuit board, and talk electric motorcycles. Is 3D printing safe? Want an accurate moon on your desk? How about modern punch cards? All of that and much more were on the menu this week.

For the can’t miss articles, Zoe Skyforest weighs in on file sharing via LAN while Al Williams talks about the surprising state-of-the-art in vacuum tube tech right before their end.

What do you think? Leave us a comment or record something and send it to our mailbag.

html5-player.libsyn.com/embed/…

Download a copy of the podcast with an MP3 this week in glorious pink and purple.

Where to Follow Hackaday Podcast

Places to follow Hackaday podcasts:

• iTunes
• Spotify
• Stitcher
• RSS
• YouTube
• Check out our Libsyn landing page

News:

• Another Gift To The World From CERN: Their Entire Set Of KiCad Libraries

Mailbag

• BirdNET-PI :: BirdWeather
• Environmental Monitoring On The Cheap
• A Merciless Environmental Monitoring System
• A Web Connected Seismometer
• Building The DIY HP41C: A Field Report
• Got something to share for the Mailbag? Drop us a line. Already sent something in? Maybe send it again as we were… ahem… experiencing technical difficulties.

What’s that Sound?

• No one guessed the sound, so by random draw, [Jeeef] wins the T-shirt. Tune in next week for your chance to guess What’s That Sound?

Interesting Hacks of the Week:

• Mermaid Clutch-Purse Cyberdeck Is Unapologetically Girly
• VTech Toy Becomes PinkPad, The DIY Linux Laptop
• Using 3D Printers To Make Circuit Boards
  
  • Prototyping Circuits: Easy Cheap Fast Reliable Techniques
  • wd5gnr.com/shoexmit.jpg
  • Retro Gadgets: The 1974 Breadboard Project

  
  

• Honda Wants To Complicate Your E-Motorcycle
• Digital Organizer Given Modern Upgrade
• Investigating The Health Impacts Of UFPs And VOCs From FDM Printers
• Electroplating 3D Prints Without Requiring A Big Vat

Quick Hacks:

• Elliot’s Picks:
  
  • Remembering The Tech We Lost With A Virtual Graveyard
  • Put The Moon On Your Desk
  • A DIY 3D Printing Filament Dryer
  • Extract 3D Video Game Content By Firing Up Photo Mode
  • PreFlight Slicer Brings Added Part Strength Feature, And Many More

  
  

• Al’s Picks:
  
  • Turning A Junk Laptop Screen Into A Portable Monitor
  • 21st Century Punch Cards Are 3D Printed And Read By OpenCV
  • Prolog Via Pokémon

  
  

Can’t-Miss Articles:

• Between-Device Sharing Still Sucks
  
  • KDE Connect | KDE Connect: A project that enables all your devices to communicate with each other.
  • Snapdrop???? : r/software

  
  

• The Vacuum Tube’s Last Stand(s)

hackaday.com/2026/05/22/hackad…

As fun as ARM and RISC-V single-board computers (SBCs) are, all too often getting the most out of the hardware requires the use of an unofficial firmware image. So too with the Banana Pi BPI-R4 Pro router SBC that has been out for a while, as OpenWRT support for it still very much unofficial. This is where [Interfacing Linux] goes on a bit of a rant while assembling one of these puppies into a sleek metal enclosure.

The first rule of OpenWRT Club is of course that you never run an unofficial image on any hardware that’s part of any network you care about. This is somewhat upsetting, as the testing shown in the video below reveals that performance is great when running it.

Currently OpenWRT support is painfully working its way through development, per the OpenWRT PR thread, so there’s hope that official support will appear at some point. As with all of such SBCs the question is always whether official support appears before the hardware has been rendered firmly obsolete. Until then the community Debian 13 image might actually be safer.

youtube.com/embed/x6f_sJP-0ZE?…

hackaday.com/2026/05/22/how-th…

Google’s Project Zero demonstrates a new zero-click exploit for the Pixel 10 phones, showing a full escalation from remote to kernel without user interaction. During the investigation Project Zero found unprotected memory access from userspace in the Tensor G5 video processing chip driver, which allows direct write access to kernel memory.

Using previously discovered flaws in media decoding components — in this case CVE-2025-54957 in the Dolby digital audio decoder — Project Zero modified a Pixel 9 attack to work on the Pixel 10, despite newer protections built into the hardware to harden the system against memory corruption.

The author’s takeaway is mixed. Once the bug on Pixel 9 was reported, one could hope that the Android team would look into similar bugs in their newer systems. On the positive side, though, Project Zero reported the vulnerabilities to the Android team in November 2025 and they were patched in February of 2026, 71 days later. That’s 19 days short of the 90-day timeline.

Linus on AI and Security

Linus Torvalds clarified opinions on AI detected security vulnerabilities in the Linux kernel in a recent mailing list post about the Linux 7.1 kernel development cycle.

In typically succinct phrasing, Torvalds supports the use of AI tools in general, but considers any AI reported bug to be, by definition, public. Linus also requests that submitters of AI generated reports verify the report is accurate and engage with fixing the issue instead of doing an unverified drive-by report. It’s difficult to summarize his comments without being longer than his initial post, so for more full information, head over to the Linux kernel mailing list!

GitHub on AI and Bug Bounties

Similar to comments from Linus above, GitHub is detailing how AI generated reports will be handled in an attempt to generate higher-quality bug reports in the bug bounty program.

While slightly ironic that a platform which has gone deep down the AI rabbit hole is now facing issues of scope when AI-generated reports flood its own security program, the problem is certainly real. GitHub lays out what seems to be a fair list of requirements for a good bug report. One must provide a working example of the vulnerability in action, adhere to the scope of the bounty, and of course, the report must be valid.

All three of the requests directly target things AI has been historically terrible at, especially at scale when deployed by users with limited security background and experience. AI models have often been guilty of completely fabricating code, fixes, and data. Completely false security reports waste time.

GitHub further clarifies their position that malicious repositories are not, themselves, in scope for the bug bounty program, stating that users are responsible for what repositories they clone, fork, or otherwise interact with. This makes sense in the scope of a bug bounty program where a submitter can create an arbitrarily malicious repository and file a bug on it, but seems short-sighted given recent rampant exploitation of the GitHub actions build process. Expecting every user to understand the implications of the GitHub actions workflow before forking a public repository seems unlikely to work in the long term.

GitHub Internal Breach

Speaking of which, GitHub has posted to their security blog about a breach of internal repositories.

There are not a lot of details about the breach, but GitHub says a compromised VSCode extension on a developers system was used to gain the credentials for internal systems. If that sounds familiar, it should – many of the current worms targeting NPM and PyPi include code to infect VSCode extensions as well.

GitHub says that only internal company repositories were impacted, and that if any customer repositories are found to be affected the users will be notified.

If you find it amusing that a developer at GitHub, owned by Microsoft, was compromised by a Microsoft VSCode extension, hosted on the Microsoft’s extension repository, I’d say you’re right.

Zero-Copy Removed from AF_ALG

The Linux kernel is removing the zero-copy code from AF_ALG. The AF_ALG code is part of of the kernel-level encryption libraries, and has been used in the CopyFail exploits.

The patch notes that the zero-copy functionality was originally intended to accelerate performance with hardware encryption accelerators, but is rarely used for that purpose and has almost no dependencies in userspace tools. By removing the seldom used, but very complex, zero-copy API, the kernel developers hope to eliminate future bugs in the CopyFail class which manipulate the page table cache.

CISA Self-Doxes

A contractor for the US government cybersecurity watchdog agency CISA left a public GitHub repo – hilariously named “Private-CISA” – available, with credentials for CISA cloud services, authentication tokens, plaintext passwords, and internal credentials.

Brian Krebs reports on the full details. Credentials included access to the CISA AWS GovCloud systems, the internal CISA build system for tools, and plain-text logins to the repository of internal libraries. GitHub itself has protections to prevent accidentally publishing authentication tokens and credentials in repositories, but they were explicitly disabled.

The GitHub repository had been active since November of 2025, and even after being taken down, leaked credentials to access AWS GovCloud remained active for an additional 48 hours.

NGINX 0-Day

The NGINX web server is used on millions of systemsm approximately 30% to 40% of web servers, as both a traditional web server and as a proxy system for internal web services.

Last month the “nginx-rift” vulnerability allowed for arbitrary code execution via the NGINX rewrite engine. Now, the “nginx-poolslip” vulnerability has been found causing denial of service and in some cases remote code execution even on the latest NGINX versions.

Currently there are no official patches for the NGINX service, though there likely will be shortly. In the mean time, the primary suggestion for mitigating the bug is to ensure no “rewrite”, “if”, or “set” rules in the NGINX config use unnamed PCRE capture groups.

Pid-fd Linux Bug Gets Official

The “pid-fd” bug mentioned last week now has an official patch and CVE.

Not to be confused with CopyFail or DirtyFrag bugs which allow root access via corrupting the page cache of file data in RAM, this bug, also called “ssh-keysign-pwn”, enables reading any file regardless of file permissions, exposing important files like the system password file in /etc/shadow or the SSH private keys of the server or users, and executing commands as root via other common utilities including ssh-keysign, pkexec, and accounts-daemon.

RDS-Pintheft Linux bug

Seemingly not getting too much attention the V12 group released proof-of-concept code for another Linux kernel bug, naming it “RDS-pintheft”.

The bug lies in the Linux RDS network code, an alternate communications method for high-speed communications within clusters. It functions similarly to CopyFail and DirtyFrag: mis-handling memory buffers allows reliable overwriting of the page cache and replacing the perceived contents of a suid-root binary, granting instant root.

This exploit does require the RDS and RDS TCP kernel modules to be loaded, which may not be present on all distributions. If the module is already loaded or the attacker can cause it to be automatically loaded, and has the ability to execute code locally, it appears to be game over.

Patches are available and will likely be integrated into distribution kernel patches soon.

Google Self-Doxes Chromium

Bleeping Computer reports that Google has accidentally exposed the details of an un-patched Chromium exploit that enables JavaScript based botnets in all Chromium based browsers. Chromium is the open source browser engine which lies underneath Google Chrome, but also Microsoft Edge, Vivaldi, Opera, Arc, and Brave.

The JavaScript bug allows service workers to remain running in the background, even when the original page has been closed, or even when the browser itself has been closed. This would allow malicious websites, or ads carrying JavaScript injected into benign websites, to continue issuing requests without the user knowing, fueling a botnet for click fraud or denial of service attacks.

The bug was first reported in 2022, but ignored until 2024 when it was flagged as requiring attention. In February of 2026, the bug was marked as fixed, though no patches had been shipped yet. On May 20, details of the bug were automatically released because the bug had been closed for more than 14 weeks and marked as fixed.

But in fact the bug was not fixed, and the researcher noted that previous alerts that may have given the user a hint that something was occurring are now gone, making the attack even simpler.

Additional fixes will likely arrive shortly, given the publicity and severity of the bug.

hackaday.com/2026/05/22/this-w…

We talk about all kinds of autonomous vehicles here at Hackaday, from aerial drones to rugged rovers. A little less common are the submarine builds, likely due to their technical complexity. That said, though they perhaps benefit most from autonomy given they’re so hard to talk to while underwater. In any case, [Ayman] has built an impressive sub that uses some rudimentary techniques to navigate around while under the surface.

The build uses typical construction techniques for DIY subs of this size, with a clear acrylic tube serving as the body of the craft. It’s carefully sealed to ensure water ingress doesn’t send it to the bottom, using nifty tricks like a magnetic coupling for the prop. Inside, there’s a Raspberry Pi 4, kitted out with an Arducam IMX708 camera with a wide angle lens. It’s joined by a BNO085 inertial measurement unit, along with two BMP280 pressure sensors for keeping track of motion and the sub’s vital signs, while a DRV8833 motor controller runs the main drive motor.

There’s also an ESP32 which helps out with motor and servo control for steering, and ballast control. Sinking and floating the sub is handled with a pair of two ballast tanks constructed out of 5 mL syringes that are driven in and out with high-torque output gear motors. The build uses an antenna buoy so that communication can be maintained with the sub when it’s within a certain range of the surface.

A neat addition to the sub is its autonomous navigation code. [Ayman] whipped up some simple object avoidance routines, which rely on the Raspberry Pi’s camera. The code uses HSV values to track specific colored objects and avoid them, which proves more reliable than RGB as it allows tracking color in a largely brightness-independent manner.

Although we’ve featured other builds that use similar construction techniques, seeing a transparent submarine gliding through the water will always make us think of the incredible Open Source Underwater Glider that won the 2017 Hackaday Prize.

youtube.com/embed/_M3SRvy68w8?…

hackaday.com/2026/05/22/autono…

In 2025, we observed pervasive SSH tunnel activity, which has remained active into 2026, affecting many government organizations and commercial companies in Russia and Belarus. Behind some of this activity is Cloud Atlas, a group we have known since 2014. During our investigation, we identified new tools used by this group, as well as indicators of compromise.

The group is back to sending out archives containing malicious shortcuts that launch PowerShell scripts. This technique is employed in addition to the previously described use of malicious documents, which exploit an old vulnerability in the Microsoft Office Equation Editor process (CVE-2018-0802) to download and execute malicious code. We have observed the use of third-party public utilities (Tor/SSH/RevSocks) to gain a foothold in infected systems and create additional backup control channels.

Technical details

Initial infection

As for the primary compromise, Cloud Atlas remains consistent in using phishing. In the observed campaigns, the attackers emailed a ZIP archive containing an LNK file as an attachment.

Malware execution flow

Attackers use LNK shortcuts to covertly execute PowerShell scripts hosted on external resources. The command line of the shortcut:

Example of the PowerShell script downloaded and executed by the shortcut:

Example of the PowerShell script downloaded by the shortcut

Actions performed by the downloaded PowerShell:

Step	Action	Description
1	Drops “$temp\fixed.ps1”	Pre-staging: places the main payload locally in advance to ensure an execution capability independent of subsequent network connectivity or C2 availability.
2	Creates “Run” registry key “YandexBrowser_setup” for “$temp\fixed.ps1” startup	Early persistence: guarantees execution upon the next logon or reboot. If the script is interrupted during later stages, the payload will still activate automatically.
3	Downloads and drops “$temp\rar.zip” Extracts “*.pdf” from the downloaded “$temp\rar.zip”	Payload delivery: retrieves the decoy archive from the remote server to prepare user-facing content for the distraction phase.
4	Extracts “*.pdf” from the downloaded “$temp\rar.zip”	Decoy preparation: unpacks the legitimate-looking document so it can be executed silently without requiring user interaction.
6	Opens extracted decoy document “*.pdf” with user’s default software	User distraction: opens a convincing document to maintain user engagement and creates a legitimate workflow appearance to buy additional 30–120 seconds for background operations.
6	Executes “taskkill.exe /F /Im winrar.exe”	Process concealment: terminates the archive extractor to prevent the user from seeing the archive contents or noticing unexpected file extraction activity.
7	Searches and deletes “rar.zip”, “*.pdf.zip” and “*.pdf.lnk”	Anti-forensic cleanup: removes the initial infection artifacts before activating the main payload, reducing the number of disk traces available for incident response or EDR correlation.
8	Executes “$temp\fixed.ps1”	Controlled execution: launches the main payload only after persistence is secured, the user is distracted, and access traces are cleaned up.

Fixed.ps1 (loader)

The primary purpose of the Fixed.ps1 script is to deliver and install subsequent malware onto the compromised system, specifically VBCloud and PowerShower. Fixed.ps1 establishes persistence (by adding itself to registry Run keys), creates a decoy for the user (by opening a PDF document), and executes the next stages of the attack.

Fixed.ps1::Payload (VBCloud dropper)

Example of the fixed.ps1::Payload (VBCloud dropper)

This module functions as a dropper for the VBCloud backdoor. It drops two files onto the infected machine:

• video.vbs: the loader of the backdoor,VBCloud::Launcher. This is a VBScript that decrypts the contents of video.mds (typically using RC4 with a hardcoded key) and executes it in memory.
• video.mds: the encrypted body of the backdoor, VBCloud::Backdoor. This is the main module that connects to a C2 server to receive additional scripts or execute built-in commands. This backdoor is designed to function as a stealer, specifically targeting files with extensions of interest (such as DOC, PDF, XLS) and exfiltrating them.

Fixed.ps1::Payload (PowerShower)

This module installs a second backdoor called PowerShower on the system. We don’t have the specific script that performs this installation, but we assume it’s performed by a script similar to fixed.ps1::Payload (VBCloud dropper).

Unlike VBCloud, which focuses on file theft, PowerShower is primarily used for network reconnaissance and lateral movement within the victim’s infrastructure. PowerShower can perform the following tasks:

• Collect information about running processes, administrator groups, and domain controllers.
• Download and execute PowerShell scripts from the C2 server.
• Conduct “Kerberoasting” attacks (stealing password hashes of Active Directory accounts).

PowerShower is dropped onto the system via the path ‘C:\Users\[username]\Pictures\googleearth.ps1’.

Contents of the googleearth.ps1(PowerShower)

PowerShower::Payload (credential grabber)

PowerShower downloads an additional script for stealing credentials. It performs the following actions:

• Creates a Volume Shadow Copy of the C:\ drive.
• Copies the SAM (stores local user password hashes) and SECURITY system files from this shadow copy to C:\Users\Public\Documents\, disguising them as PDF files.
• The script is launched in several stages. To execute with high privileges, the script uses a UAC bypass technique via fodhelper.exe (a built-in Windows utility). This allows PowerShell to run as an administrator without directly prompting the user, which could otherwise raise suspicion.

The full launch chain looks like this:

The full Base64-decoded script is given below.

Multi-user RDP by patching termsrv.dll

Moving laterally across the victim’s network, the attackers executed a suspicious PowerShell script named rdp_new.ps1 (MD5 1A11B26DD0261EF27A112CE8B361C247):

The script is designed to allow multiple RDP sessions in Windows 10 by patching the termsrv.dll file. Termsrv.dll is the core Windows library that enforces Remote Desktop Services rules.

By default, Windows limits the number of simultaneous RDP sessions. Removing this restriction allows attackers to operate on the machine in the background without disconnecting the legitimate user, thereby reducing the likelihood of detection.

At first, the script enables RDP on the firewall and downgrades the RDP security settings:

Before modifying termsrv.dll, the script takes ownership and assigns itself full permissions. Then the script finds the sequence of bytes 39 81 3C 06 00 00 ?? ?? ?? ?? ?? ?? and replaces it with B8 00 01 00 00 89 81 38 06 00 00 90. After these manipulations, the script restarts the RDP service.

Example of script

The patched version allows multiple concurrent logins so attackers can stay connected without disrupting the legitimate user, thereby reducing suspicion.

Reverse SSH tunneling

As mentioned above, during this wave of attacks, the adversaries widely deployed reverse SSH tunnels to many hosts of interest. The compromised machine initiates an SSH connection to an attacker-controlled server, which allows attackers to bypass standard firewall rules via establishing outbound connections.

That way, even if the primary backdoor is discovered, the attackers can maintain control through the SSH tunnel.

To install a reverse SSH tunnel on a victim’s host, the attackers run VBS scripts via PAExec or PsExec.

We’ve seen three types of scripts:

• Gen.vbs (WriteToSchedulerGenerateKey.vbs) generates key for SSH tunnel.
• Run.vbs (WriteToSchedulerRunSSH.vbs) runs reverse SSH tunnel.
• Kill.vbs (WriteToSchedulerKillSSH.vbs) stops reverse SSH tunnel via taskkill.exe.

To achieve persistence, the attackers added a new scheduled task in Windows:

In some cases, before establishing a reverse SSH tunnel, attackers set new access permissions to the folder containing the private key to prevent the legitimate user or system administrators from easily accessing or modifying it:

Patched OpenSSH

Some OpenSSH binaries used by the attackers had their imports modified. Instead of libcrypto.dll, the SSH executable imports syruntime.dll, which was placed in the same folder as the binary. This was likely done to evade detection and ensure stealth.

In addition, we found a portable version of OpenSSH, presumably compiled by the adversaries:

RevSocks

In addition to Reverse SSH tunnels, the attackers installed RevSocks using the same infrastructure. RevSocks is an alternative tool to SSH for establishing tunnels and proxy connections, written in Golang. This tool allows direct connection to workstations on the local network. It also allows attackers to gain access to other segments of the victim’s network by using the machine as a gateway. In some cases, C2 addresses were hardcoded into the binary; in other cases, the C2 was passed in command line arguments.

There were also reverse SOCKS samples with hardcoded C2 addresses:

Tor tunneling

To maintain control over the compromised host, the Tor network was used in some cases. A minimal set of a Tor executable and configuration files, necessary for launching HiddenService, was copied to the system directories of infected devices. The name of the Tor Browser executable file was modified. As a result, the infected machine was accessible via RDP from the Tor network when accessing the generated .onion domain.
Below is an example of a configuration file for routing connections from Tor to RDP ports on the local network, as well as example command lines for logging into Tor.

Example of TOR configuration file

PowerCloud

We analyzed a new Cloud Atlas tool, PowerCloud. It collects user data with administrator privileges and writes this information to Google Sheets in Base64 format.

The tool represents an obfuscated PowerShell script. In most cases, it is packaged into an executable file using the PS2EXE utility, but we have also encountered variants in the form of a separate PowerShell script.

To find administrators on the victim host, the tool executes the following command:

This information is appended with the computer name and current date, the data is encoded in base64, and then the collected data is added to an existing Google Sheet.

PowerCloud script

Browser checker

Additionally, the attackers used another PowerShell script (MD5 5329F7BFF9D0D5DB28821B86C26D628F), compiled into an executable file via PS2EXE, which checks whether browser processes (Chrome, Edge, Firefox, and other) are running. This helps detect when the user is working on the computer. This can be used to choose the optimal time for conducting attacks (for example, when the user is away but their browser is still open) or simply to gather information about the victim’s habits.

The information about running browsers is written to a log file on the local host.

Fragment of the deobfuscated script

Victims

According to our telemetry, in late 2025 and early 2026, the identified targets of the described malicious activities are located in Russia and Belarus. The targeted industries mostly include government agencies and diplomatic entities.

We attribute the activity described in this report to the Cloud Atlas APT group with a high degree of confidence. The group used techniques and tools described previously, such as the initial access vector, the Python script for information gathering, and the Tor application for forwarding ports to the Tor network. The victim profile and geography also matches the Cloud Atlas targets.

We couldn’t help but notice some parallels with recent Head Mare activity. The PhantomHeart backdoor (available in Russian only), attributed to Head Mare and used to create an SSH tunnel, was placed in directories actively used by Cloud Atlas:

• C:\Windows\ime
• C:\Windows\System32\ime
• C:\Windows\pla
• C:\Windows\inf
• C:\Windows\migration
• C:\Windows\System32\timecontrolsvc
• C:\Windows\SKB

However, TTPs are still differentiated.

Conclusion

For more than ten years, the Cloud Atlas group has continued its activities and expanded its arsenal. Over the course of last year, many targeted campaigns in general were found to employ ReverseSocks, SSH and Tor, and the use of these utilities was no exception for Cloud Atlas. Creating such backup control channels using publicly available utilities significantly complicates the complete disruption of attackers’ actions on compromised systems. We will continue to closely monitor the group’s activity and describe their new tools and techniques.

Indicators of compromise

PowerCloud

7A95360B7E0EB5B107A3D231ABBC541A C:\Windows\wininet.exe
C0D1EAA15A2CEFBAB9735787575C8D8E C:\Windows\LiveKernelReports\update.exe
D5B38B252CF212A4A32763DE36732D40 C:\Windows\ime\imejp\dicts\i39884.exe
3C75CEDB1196DF5EAB91F31411ED4B33 C:\pla\reports.exe
42AC350BFBC5B4EB0FEDBA16C81919C7 C:\ProgramData\update_[redacted].exe
493B901D1B33EB577DB64AADD948F9CE C:\Windows\migration\wtr\MicrosoftBrowser.exe
2CABB721681455DAE1B6A26709DEF453 C:\Windows\pla\reports\winlog.exe
1B39E86EB772A0E40060B672B7F574F1 C:\Windows\System32\timecontrolsvc\vmnetdrv64.exe
1D401D6E6FC0B00AAA2C65A0AC0CFD6B C:\Windows\setup\scripts\install\software\activation\aact\dfsvc.exe
40A562B8600F843B717BC5951B2E3C29 C:\Windows\branding\scat.exe
F721A76DEB28FD0B80D27FCE6B8F5016 C:\Windows\ime\imekr\dicts\dfsvc.exe
D3C8AFD22BAA306FF659DB1FAC28574A C:\ProgramData\update_[redacted].exe
6D7B2D1172BBDB7340972D844F6F0717 C:\Users\[redacted]\AppData\Local\1c\1cv8\1cv8ud.exe
C:\Users\[redacted]\AppData\Local\1c\1cv8\svc.exe
9769F43B9DE8D19E803263267FA6D62E C:\Users\[redacted]\AppData\Local\1c\1cv8\1cv8ud.exe
63B6BE9AE8D8024A40B200CCCB438F1D C:\Windows\notepad.exe
6AA586BCC45CA2E92A4F0EF47E086FA1 C:\Windows\splwow32.exe
EBA3BCDB19A7E256BF8E2CC5B9C1CCA9 C:\Users\[redacted]\Desktop\soc\stant.exe
B4E183627B7399006C1BC47B3711E419 C:\WINDOWS\ime\service.exe
F56B31A4B47AD3365B18A7E922FBA1A8 dfsvc.exe
F6F62456FB0FCC396FB654CBED339BC3 –
25C8ED0511375DCA57EF136AC3FA0CCA C:\branding\dwmw.exe

Browser checker

5329F7BFF9D0D5DB28821B86C26D628F C:\ProgramData\checker_[redacted].exe

ReverseSocks

2B4BA4FACF8C299749771A3A4369782E C:\Windows\PLA\System\bounce.exe
C:\Windows\pla\print_status.exe
BA9CE06641067742F2AFC9691FAFF1DC C:\ProgramData\hp\client.exe
FB0F8027ACF1B1E47E07A63D8812ED50 C:\Windows\System32\timecontrolsvc\vmnetdrv64.exe
BBF1FA694122E07635DEEAC11AD712F8 C:\Windows\System32\HostManagement.exe
F301AA3D62B5095EEC4D8E34201A4769 C:\Windows\ime\imejp\msfu.exe
F9C3BBE108566D1A6B070F9C5FB03160 C:\Windows\ime\imetc\help\IMTCEN14.exe

Malicious MS Office documents

369B75BDCDED16469EDE7AB8BEDCFAE1
9EAAE9491F6A50D6DF0BE393734A44CB
3E6E9DF00A764B348EC611EE8504ACA0
9BD788F285E32A05E6591D1EB36EBFFC
F42085522EC2EBB16EDCF814E7C330AD
2042EB5D52F0B535A1CE6B6F954C8C2B
2AA1E9765EF6B00B94A9B6BE0041436A
36120F5E9411BCBAC7104EF3FA964ED2
5000A353399500BC78381DC95B6ED2DC
579A9952D31CAD801A3988DBE7914CE7
867B634588C0FD6B26684D502C15AB03
38FA4306FA4406BA31CF171AF4D36E34
83EDDE9F7EEEFAC0363413972F35572B
CC751619BFEC0DC4607C17112B9E3B2C
A632858F14B36F03D0F213F5F5D6BFF2
097CA205AD9E3B72018750280904718C
69121C36EB8BF77962DCA825FCFFD873
C5702EB250F855C8C872FFFB9BB656ED
ED34F5A136FBA4FDEA976570FAA33ED7
0577DB70844E88B32B954906E2F20798
28ECF8FB6719E14231B94B4D37629B0E
0857C84B62289A1A9F29E19244E9A499
0C514E137860F489E3801213460EF938
50568B1F9335A7E3BA4E5DF035A8FB86
7F776AD200287D6DE14A29158C457179
51F7F794ED43FB90D0F8EBBB5EFFE628
B8C753DD254509FBA5077FFD5067EAB0
BC3739DEC8CD8F54F3F60A85F3ED600E
EC076CD21C483A40156F4E40D08DADED
216CB7F31D383C0DD892B284DF05A495
116F59E70A9DF97F4ADAEA71EECB1E9A
7242AC065B50BCDE9308756B49DBADCB
8158552950D2E13B075001CE0C52AA97
A75DBED984963B9AB21309C5B2F8FD9B
0320DD389FDBAB25D46792BD2817675E
5339D1A666F3E40FE756505CF1D87D4B
67D7E3AEEB673BF60C59361C12A4ED81
89572F0ED20791A5AC9FC4267D67CCB0
B6AAE073E7BFEBF4D643C2BBEB5C02E1
344CA9EA07CD4AC90EF27F8890D4EC05

Domains and IPs

Reverse SSH/Socks domains

tenkoff[.]org
cloudguide[.]in
goverru[.]com
kufar[.]org
ultimatecore[.]net
spbnews[.]net
onedrivesupport[.]net

Malicious and compromised domains used in MS Office documents

amerikastaj[.]com
bigbang[.]me
paleturquoise-dragonfly-364512.hostingersite[.]com
wizzifi[.]com
totallegacy[.]org
mamurjor[.]com
landscapeuganda[.]com
lafortunaitalian.co[.]uk
kommando[.]live
internationalcommoditiesllc[.]com
humanitas[.]si
fishingflytackle[.]com
firsai.tipshub[.]net
alnakhlah.com[.]sa
allgoodsdirect.com[.]au
agenciakharis.com[.]br

Powershell payload staging

istochnik[.]org
znews[.]neti
investika-club[.]com
194.102.104[.]207
46.17.45[.]56
46.17.45[.]49
46.17.44[.]125
46.17.44[.]212
185.22.154[.]73
194.87.196[.]163
195.58.49[.]9
93.125.114[.]193
93.125.114[.]57
45.87.219[.]116
37.228.129[.]224
185.53.179[.]136
185.126.239[.]77
5.181.21[.]75
146.70.53[.]171
45.15.65[.]134
185.250.181[.]207
81.30.105[.]71

File paths

VBS scripts

WriteToSchedulerKillSSH.vbs
Create_task_day.vbs
WriteToSchedulerGenerateKey.vbs
C:\Windows\INF\Run.vbs
c:\Windows\INF\install.vbs
Update.vbs
c:\Windows\PLA\System\Gen.vbs
C:\Windows\INF\GenK.vbs
c:\Windows\PLA\System\Kill.vbs
c:\Windows\PLA\System\Run.vbs

ssh.exe

c:\Windows\ime\imejp\Asset.exe
c:\Windows\PLA\System\conhosts.exe
c:\Windows\INF\BITS\esentprf.exe
c:\Windows\INF\MSDTC\RuntimeBrokers.exe
c:\Windows\inf\diagnostic.exe

ReverseSocks

C:\Windows\PLA\System\bounce.exe
C:\ProgramData\hp\client.exe
C:\Windows\System32\timecontrolsvc\vmnetdrv64.exe

Tor client

C:\Windows\Resources\Update\Intel.exe
C:\Windows\INF\package.exe

securelist.com/cloud-atlas-202…

If you’ve played Cyberpunk 2077, you might have seen the rad jacket that has a screen in the collar. Once upon a time, such a thing would be solely the preserve of science fiction—you certainly wouldn’t be achieving that look with cathode ray tubes, that much is for sure. However, technology has advanced to the point where [Zibartas] was able to produce just such a jacket in real life.

The key to the build is the advent of the flexible OLED screen. [Zibartas] was able to source four such panels in a smartphone-like aspect ratio, which came in at the hefty price of $300 each. Two Raspberry Pi 4s were enlisted to drive two screens each. The older model Pi was chosen as it was capable of achieving a neat hack to better play smooth video across two displays. A rudimentary sync system was whipped up using GPIO pins to keep video from both Pis playing together. From there, it was simply a matter of figuring out how to create a structure to hold the screens within the large collar of the scratch built cyberpunk-styled jacket. As it turns out they don’t actually flex much in the final install, as they’re held in a 3D printed structure to keep them safe from damage.

The final result is quite something, very accurately recreating the jacket from the game itself. While technically a simple build, actually pulling it off required some delicate work and smart design decisions to make it practical to wear. We’ve featured some other fun jackets over the years, too.

youtube.com/embed/5UXCVEk83kE?…

hackaday.com/2026/05/22/jacket…

Nearly all modern PCBs are designed with the help of EDA software, but not all of them. [ALTco] shows us the process of plotting out a board the old-fashioned way — by hand.

Back in the day, drawing out the traces on a PCB lead to beautiful, smooth lines that [ALTco] wanted to imitate. But first, he needed to figure out how the rest of the fabrication process worked. He starts by just experimenting, both with the “resist” markers and paint, and the etching compound. Things rarely work first-try, and neither did his home-made etchant. So then it was time to buy some ferric chloride, the standard copper etchant for PBCs. A few more tests sorted out which permanent marker worked best.

[ALTco] starts by thoroughly cleaning a raw copper-clad board so the marker sticks properly, then draws the circuit for a little analog fan controller. The board is then laid in a bath of the etchant for several minutes while gently rocking it to keep the reaction going. Finally the board is taken out, etchant stored for re-use, and the board washed with water and then presumably IPA to remove the remaining marker. Some assembly of the newly-printed circuit board later and you have a cute little smoke absorber for your soldering projects.

youtube.com/embed/iJwyHakxCe4?…

hackaday.com/2026/05/21/making…

Do you want to go back to an era when Windows was… simpler? Back when things worked, before the AI and the bloat took over your hard drive and RAM space in equal measure? You might like to give Classic 7 a spin (via The Register).

From the drop, we should state that Classic 7 is not Windows 7 at all. Instead, it’s a reskin of Windows 10, specifically, the IoT Enterprise LTSC version. This is a particularly attractive version of Windows 10, as Microsoft has promised long-term support in terms of security updates until 2032. It also strips out annoying consumer-focused bloat like the Xbox gaming overlay and Cortana, and it eliminates forced feature updates that have become the norm in modern Windows installs. Combine all those niceties with the clean and simple feel of the recreated Windows 7 interface, and you have a beautiful operating system that has everything you need and nothing you don’t.

There are, of course, some hurdles to jump over; you’d need to find an appropriate license for this version of Windows and all that jazz. But if you long for the days before Microsoft so cruelly eviscerated the Start Menu and started making everything worse, you might find that Classic 7 is for you.

[Thanks to Stephen Walters for the tip!]

hackaday.com/2026/05/21/get-th…

Will your next project be a success? Only time will tell, but if you build [gokux]’s tiny ESP32 fortune cookie, we predict that, at the very least, there won’t be any crumbs involved.

After briefly entertaining the idea of shoving an ESP32 in a standard fortune cookie, [gokux] thought better of it and came up with this instead. Once shaken, this small gadget displays a fortune on its e-paper screen. It can store over 3,000 fortunes and works entirely offline, so you’re never without an oracle.

Inside you’ll find a Seeed Xiao ESP32-S3 Plus and a matching e-paper display board. [gokux] is detecting the shakes with an MPU-6050 accelerometer, and powers everything with a small Li-Po pouch.

If you tire of the fortunes that shake out, the small buttons on the left side will get you into the other modes, which are a dice roller and a coin flipper. Again, you just shake the thing until you get what you want. Be sure to check it out in the video after the break.

Want to know how an MPU-6050 works, and what it looks like under the hood? Yeah, we thought so.

youtube.com/embed/Mc15yoheJ4g?…

hackaday.com/2026/05/21/e-fort…