(in)sicurezza digitale

2026-04-27 18:19:25

LockBit 5.0 in Escalation: dalla Banca delle Banche Centrali Latinoamericane alle logistiche Europee

LockBit 5.0 — nome in codice ChuongDong — non è la resurrezione di un brand cybercriminale: è la prova che i ransomware-as-a-service più organizzati si evolvono più velocemente delle operazioni delle forze dell’ordine che li contrastano. Nell’ultima settimana di aprile 2026, la gang ha rivendicato colpi su un istituto finanziario fondato dalle banche centrali latinoamericane, su società di logistica tedesche e su numerose altre vittime in Europa, Asia e nelle Americhe. Un’analisi tecnica e operativa della minaccia più attiva del momento.

Storia e resurrezione: da Operation Cronos a LockBit 5.0

Nel febbraio 2024, la joint task force internazionale Operation Cronos — guidata dall’NCA britannica con la partecipazione di Europol, FBI e polizie di altri dieci paesi — aveva inflitto quello che sembrava un colpo definitivo all’ecosistema LockBit: server sequestrati, chiavi di decryption pubblicate, affiliati arrestati in Polonia e Ucraina, e il volto del presunto admin “LockBitSupp” esposto pubblicamente.

La risposta del gruppo è arrivata con una certa prevedibilità: già nel settembre 2025, LockBit ha annunciato sul forum dark web RAMP la versione 5.0, coincidendo con il sesto anniversario dell’operazione. A distanza di circa sette mesi dal lancio, il quadro è chiaro: il gruppo ha ripreso la sua cadenza operativa, con oltre 100 vittime rivendicate sulla nuova data leak site (DLS) e attività in costante escalation nel 2026.

Architettura tecnica: cosa c’è di nuovo in LockBit 5.0

LockBit 5.0 è costruito su un’architettura a due componenti principali, un Loader e un modulo Ransomware, con una separazione netta tra funzioni di delivery e payload di cifratura.

Il Loader decifra il payload ransomware usando XOR combinato con compressione LZ e lo esegue direttamente in memoria, senza mai scrivere il binario cifrato su disco — una tecnica che complica notevolmente l’analisi forense e il rilevamento da parte degli antivirus tradizionali.

Sul fronte cifratura, la versione 5.0 introduce significativi miglioramenti rispetto alla 4.0:

• Cifratura differenziale basata sulla dimensione dei file: per i file più grandi viene cifrata solo una porzione, massimizzando la velocità dell’attacco e comprimendo la finestra di risposta per i difensori.
• Modulo di cancellazione delle Shadow Copy aggiornato: basato su codice derivato da Conti, ora utilizza le VSS API native di Windows invece degli strumenti da riga di comando, riducendo le tracce nel log degli eventi.
• Patching di EtwEventWrite: disabilita in memoria il Windows Event Tracing for Windows (ETW), cieco di fatto i sistemi di SIEM e EDR che si affidano ai provider nativi.
• Controlli di geolocalizzazione e locale: i campioni escludono automaticamente i sistemi nei paesi della CIS (Comunità degli Stati Indipendenti), un pattern tipico degli operatori ransomware di madrelingua russa.
• Estensioni randomizzate a 16 caratteri: i file cifrati ricevono un’estensione generata casualmente per ogni campagna, impedendo il rilevamento basato su signature statiche.

Multi-piattaforma: Windows, Linux e VMware ESXi nel mirino

Una delle novità più significative di LockBit 5.0 è l’espansione cross-platform. Il gruppo ha sviluppato tre varianti distinte — per Windows, Linux e VMware ESXi — che possono essere deployate in modo coordinato su tutta l’infrastruttura di una vittima.

La variante ESXi è progettata specificamente per cifrare i datastore delle macchine virtuali, paralizzando interi ambienti virtualizzati in un singolo passaggio. Per un’organizzazione enterprise che fa affidamento su VMware, questo significa che server, applicazioni critiche e database possono essere resi inaccessibili simultaneamente, moltiplicando la pressione a pagare il riscatto.

Le vittime di aprile 2026: da Bladex alle logistiche europee

La settimana del 26-27 aprile 2026 ha visto LockBit 5.0 rivendicare una serie di attacchi di profilo elevato, in particolare:

• Bladex (Panama): istituto finanziario multinazionale fondato direttamente dalle banche centrali dei paesi latinoamericani e caraibici. LockBit ha annunciato la pubblicazione dei dati entro 14-15 giorni. Un attacco a un istituto con questo profilo istituzionale ha implicazioni che vanno ben oltre il singolo incidente.
• Merlo Teleskoplader (Germania): produttore tedesco di macchinari industriali; la rivendicazione include potenziale esfiltrazione di dati tecnici e commerciali.
• D. Heinrichs Logistic GmbH (Bremerhaven, Germania): provider logistico nel porto di Bremerhaven, nodo strategico per il commercio europeo.

La concentrazione di vittime tedesche nel settore logistico/industriale suggerisce una campagna mirata, o quantomeno che gli affiliati di LockBit 5.0 stiano attivamente prendendo di mira la filiera produttiva e logistica europea.

Indicatori di compromissione e pattern di attacco

# File system indicators (Windows)
%TEMP%\ReadMeForDecrypt.txt         # Ransom note (naming convention LockBit 5.0)
*.{16-char random extension}         # File cifrati con estensione randomizzata
# Processi sospetti (behavior indicators)
vssadmin.exe (chiamate VSS API native invece di CLI)
wevtutil.exe (possibile log clearing pre-cifratura)
wmic.exe shadowcopy delete
# ETW patching (in-memory)
EtwEventWrite patched -> NOP sled   # Disabilita event tracing Windows
# Geolocation check (CIS exclusion)
GetUserDefaultLCID() / GetLocaleInfoW()  # Controllo locale pre-esecuzione
# Network indicators
Comunicazioni C2 su infrastrutture TOR
Data exfiltration pre-cifratura via tool personalizzato (data theft stage)
# Loader behavior
XOR + LZ decompression in memoria
Nessuna scrittura del payload cifrato su disco (fileless execution)

Il modello RaaS e la resilienza di LockBit

La sopravvivenza di LockBit alle operazioni delle forze dell’ordine non è un caso: è il risultato di un modello RaaS (Ransomware-as-a-Service) progettato con ridondanza in mente. Gli affiliati — decine di gruppi criminali indipendenti che noleggiano il malware in cambio di una percentuale dei riscatti — possono continuare a operare anche quando l’infrastruttura centrale viene sequestrata. Quando il codice e le build vengono trapelate o ricostruite, il lancio di una nuova versione diventa relativamente rapido.

LockBit 5.0 dimostra anche una capacità di adattamento tecnico reale: il patching in memoria di ETW, l’uso delle VSS API invece dei comandi shell, e l’architettura modulare cross-platform non sono aggiornamenti cosmetici ma miglioramenti mirati a sopravvivere agli EDR e ai SIEM di nuova generazione.

Raccomandazioni per i difensori

• Proteggere i backup offline e immutabili: la strategia più efficace contro LockBit rimane avere copie fuori dalla portata del ransomware. I backup connessi alla rete sono sempre stati l’obiettivo primario degli operatori.
• Monitorare le API di Volume Shadow Copy: rilevare chiamate anomale alle VSS API da processi inusuali, non solo l’esecuzione di vssadmin.
• EDR con visibilità sulle patch in-memory: i provider che monitorano l’integrità del codice in memoria (PatchGuard bypass, EtwEventWrite tampering) hanno significativamente più chance di rilevare LockBit 5.0 prima dell’esecuzione del payload.
• Segmentazione rigorosa degli ambienti VMware: i datastore ESXi non devono essere accessibili da host che non abbiano una necessità operativa diretta.
• Threat hunting basato su estensioni randomizzate: configurare alert su mass-rename di file con estensioni sconosciute nei file server critici.
• Verifica della geolocation check: se in un ambiente vengono rilevati controlli di locale da processi inusuali, potrebbe indicare una fase di reconnaissance pre-attivazione del payload.

LockBit 5.0 non è un fantasma del passato. È una minaccia attiva, tecnicamente evoluta e operativamente resiliente. L’attacco a Bladex — un’istituzione finanziaria nata per volontà delle banche centrali di un’intera regione del mondo — è il segnale che nessun settore, nessuna dimensione aziendale e nessuna geografia è fuori dal mirino del gruppo più prolifico del ransomware mondiale.

Spcnet.it

2026-04-27 13:55:45

CodeAct e Hyperlight: agenti AI piu veloci con meno chiamate al modello nel .NET Agent Framework

Chi lavora con agenti AI su basi .NET sa bene che il vero collo di bottiglia non è spesso la qualità del modello, ma il numero di round trip tra il modello stesso e i tool. Un agente che deve recuperare dati, filtrarli, fare calcoli e assemblare un risultato finisce tipicamente per eseguire cinque o sei chiamate separate al modello, ognuna con la propria latenza e il proprio costo in token. Microsoft ha presentato una soluzione concreta a questo problema: CodeAct, ora disponibile nel pacchetto alpha agent-framework-hyperlight.

Il problema: troppi turni, troppa latenza

Nel flusso tradizionale, un agente ragiona come segue: chiede al modello quale tool usare, esegue quel tool, rimanda il risultato al modello, il quale decide il prossimo tool, e così via. Questo schema modello → tool → modello → tool moltiplica la latenza e il consumo di token con ogni step aggiuntivo. Su task composti da tre, quattro o cinque operazioni concatenate (tipico nelle pipeline di data wrangling, elaborazione report, lookup incrociati), il costo diventa significativo.

CodeAct risolve il problema in modo elegante: invece di chiedere al modello di scegliere un tool alla volta, gli viene offerto un singolo tool speciale chiamato execute_code. Il modello esprime l’intero piano come un breve programma Python, che viene eseguito una volta sola in un ambiente sandbox. Il risultato? Latenza ridotta del ~50% e consumo di token calato di oltre il 60% su workload rappresentativi, secondo i dati pubblicati da Microsoft.

Hyperlight: sandbox micro-VM per sicurezza senza compromessi

La parte che rende CodeAct praticabile in produzione è Hyperlight: una tecnologia Microsoft che avvia una micro-VM isolata per ogni esecuzione di codice generato dal modello. Il codice Python prodotto dall’LLM gira dentro questa sandbox, senza accesso al filesystem host, alla rete o a qualsiasi risorsa non esplicitamente autorizzata. I tool reali invece continuano a girare nel runtime dell’applicazione, con tutti i permessi necessari.

Il bridge tra sandbox e tool avviene tramite la funzione call_tool(...): quando il codice nella sandbox chiama call_tool("nome_tool", ...), Hyperlight instrada la chiamata verso il tool nel processo principale, ne ritorna il risultato nella sandbox, e il programma continua. Il codice generato dall’AI rimane isolato; solo i tool verificati e distribuiti dallo sviluppatore hanno accesso reale alle risorse.

Come si integra CodeAct nel proprio agente

Il setup è sorprendentemente compatto. Dopo aver installato i pacchetti agent-framework e agent-framework-hyperlight:

from agent_framework import Agent, tool
from agent_framework_hyperlight import HyperlightCodeActProvider

@tool
def get_weather(city: str) -> dict:
    # Restituisce il meteo corrente per una citta
    return {"city": city, "temperature_c": 21.5, "conditions": "partly cloudy"}

codeact = HyperlightCodeActProvider(
    tools=[get_weather],
    approval_mode="never_require",
)

agent = Agent(
    client=client,
    name="CodeActAgent",
    instructions="Sei un assistente utile.",
    context_providers=[codeact],
)

result = await agent.run(
    "Ottieni il meteo di Seattle e Amsterdam e confrontali."
)


HyperlightCodeActProvider si occupa di due cose in automatico: registra il tool execute_code ad ogni run dell’agente, e inietta nel system prompt le istruzioni sulla sandbox e sui tool disponibili via call_tool(...).

Gestione delle approvazioni: chi controlla cosa

Agent Framework distingue due modalità di approvazione per i tool:

• never_require: il framework invoca il tool automaticamente.
• always_require: ogni chiamata viene sospesa in attesa di un’approvazione human-in-the-loop.

Con CodeAct, la logica cambia leggermente. I tool registrati su HyperlightCodeActProvider non vengono esposti direttamente al modello come tool di primo livello: il modello vede solo execute_code e raggiunge gli altri tool scrivendo call_tool("nome", ...) nel programma Python. L’approvazione, se richiesta, si applica all’intero blocco di codice, non alle singole chiamate interne.

La regola pratica è chiara: i tool puri e sicuri (lookup dati, calcoli, chiamate read-only) vanno passati al provider, così il modello li può comporre in un unico turno. I tool con side effect (invio email, scrittura su sistemi in produzione, transazioni economiche) vanno tenuti sull’agente direttamente con approval_mode="always_require", così il modello li deve invocare esplicitamente uno per uno.

Quando conviene usare CodeAct

CodeAct non è la soluzione giusta per ogni agente. I benefici massimi si ottengono con task che coinvolgono molte operazioni concatenate e chainabili: data wrangling, generazione report, lookup multipli, calcoli intermedi. Se il task dell’agente si risolve quasi sempre con una o due chiamate a tool, il guadagno è marginale.

È anche importante considerare che il codice Python generato dal modello deve essere revisionabile: uno dei vantaggi collaterali di CodeAct è che l’intero piano dell’agente è concentrato in un singolo blocco di codice leggibile e auditabile, invece di essere distribuito su una catena di messaggi di tool-call.

Conclusione

CodeAct con Hyperlight rappresenta un’evoluzione pragmatica nell’architettura degli agenti AI su .NET: meno turni, meno token, stessa qualità. Il pattern è disponibile oggi nel pacchetto alpha agent-framework-hyperlight, pronto per essere sperimentato su workload interni prima di adottarlo in produzione. Chi sta già usando Agent Framework e si trova a costruire pipeline di tool-calling complesse troverà probabilmente il guadagno di latenza immediato e concreto.

---

Fonte: CodeAct in Agent Framework: Faster Agents with Fewer Model Turns – Microsoft Dev Blogs, 23 aprile 2026

CodeAct in Agent Framework: Faster Agents with Fewer Model Turns | Microsoft Agent Framework

Explore the hyperlight codeact agent framework and streamline your tool-calling sequences with enhanced performance.

^{Eduard van Valkenburg (Microsoft Agent Framework)}

Spcnet.it

2026-04-27 11:00:43

LangChain.js per sviluppatori JavaScript: corso gratuito per costruire agenti AI

Volete costruire agenti AI con JavaScript che vadano oltre le semplici chat? Agenti che ragionano, chiamano strumenti esterni e interrogano knowledge base in modo autonomo? Microsoft ha pubblicato un corso gratuito e open source per fare esattamente questo: LangChain.js for Beginners, 8 capitoli con oltre 70 esempi TypeScript eseguibili.

Se già conoscete Node.js, npm, TypeScript e async/await, non avete bisogno di passare a Python per sviluppare applicazioni AI. LangChain.js vi mette a disposizione i componenti necessari — chat model, tool, agenti, retrieval e molto altro — senza dover cablare tutto da zero.

Perché LangChain.js?

LangChain.js è come avere un negozio di ferramenta completamente fornito a portata di mano. Invece di fabbricare ogni strumento dal metallo grezzo, prendete quello che serve dallo scaffale e iniziate a costruire. La libreria astrae l’integrazione con vari LLM (OpenAI, Azure OpenAI, Anthropic e altri), standardizza l’interfaccia per tool e agenti, e fornisce primitive per la costruzione di pipeline RAG.

Il vantaggio rispetto a Python? Zero friction per chi già lavora nell’ecosistema JavaScript/TypeScript. Stessi strumenti di build, stesso toolchain CI/CD, stessa base di codice.

Struttura del corso: un approccio agent-first

La maggior parte dei tutorial su LangChain inizia con document loader ed embedding. Questo corso arriva agli agenti e ai tool presto, perché è lì che si trovano i sistemi AI in produzione. Gli agenti decidono cosa fare, quando usare strumenti, e se hanno bisogno di cercare dati.

Capitoli 1-3: fondamenta

La prima chiamata a un LLM, chat model, streaming, prompt template e output strutturati con schemi Zod. Contenuto classico, ma necessario prima che le cose si facciano interessanti.

Capitolo 4: Function Calling e Tool

Qui l’AI smette di parlare e inizia a fare. Si insegna al modello a chiamare funzioni personalizzate, e lui ragiona su quando usarle. Esempio pratico:

import { ChatOpenAI } from "@langchain/openai";
import { tool } from "@langchain/core/tools";
import { z } from "zod";

const weatherTool = tool(
  async ({ city }) => {
    // chiamata a una API meteo reale
    return `Il meteo a ${city} è soleggiato, 22°C`;
  },
  {
    name: "get_weather",
    description: "Ottieni le condizioni meteo correnti per una città",
    schema: z.object({
      city: z.string().describe("Il nome della città"),
    }),
  }
);

const model = new ChatOpenAI({ model: "gpt-4o" });
const modelWithTools = model.bindTools([weatherTool]);

const result = await modelWithTools.invoke(
  "Che tempo fa a Milano?"
);
console.log(result.tool_calls);

Capitolo 5: Agenti con pattern ReAct

Un LLM risponde a domande. Un agente ragiona attraverso i problemi, sceglie i tool giusti ed esegue piani multi-step. Il capitolo 5 mostra come costruire agenti con il pattern ReAct (Reason + Act): il modello alterna tra pensiero esplicito e azioni concrete fino a raggiungere la risposta finale.

import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { ChatOpenAI } from "@langchain/openai";

const agent = createReactAgent({
  llm: new ChatOpenAI({ model: "gpt-4o" }),
  tools: [weatherTool, searchTool, calculatorTool],
});

const response = await agent.invoke({
  messages: [{ role: "user", content: "Pianifica un itinerario a Roma per domani" }],
});
console.log(response.messages.at(-1)?.content);

Capitolo 6: MCP — Model Context Protocol

Il Model Context Protocol sta diventando lo standard per connettere l’AI a servizi esterni. Il capitolo guida alla costruzione di server MCP e al collegamento degli agenti tramite trasporti HTTP e stdio. È un’abilità sempre più richiesta man mano che l’ecosistema AI aziendale matura.

Capitoli 7 e 8: RAG agentivo

I capitoli finali portano documenti, embedding e ricerca semantica, poi combinano tutto in Agentic RAG. L’agente decide quando cercare nella knowledge base e quando rispondere direttamente da ciò che già conosce.

È una distinzione importante. Il RAG tradizionale è come lo studente che sfoglia il libro di testo per ogni domanda, anche “Quanto fa 2+2?”. Il RAG agentivo è lo studente intelligente che risponde alle domande semplici a memoria e apre il libro solo quando ne ha davvero bisogno. Il risultato: risposte più veloci, costi inferiori (meno ricerche di embedding non necessarie) e un’esperienza complessivamente migliore.

Come iniziare

Il corso è open source su GitHub. Per iniziare bastano tre comandi:

# Clona il repository
git clone https://github.com/microsoft/generative-ai-with-javascript

# Installa le dipendenze
cd generative-ai-with-javascript/lessons/08-langchain/
npm install

# Configura la chiave API
cp .env.example .env
# Aggiungi AZURE_OPENAI_API_KEY o OPENAI_API_KEY nel file .env

# Esegui il primo esempio
npx ts-node chapter1/01-first-llm-call.ts

Ogni capitolo include spiegazioni concettuali con analogie concrete, esempi di codice eseguibili immediatamente, sfide pratiche per testare la comprensione e punti chiave per consolidare l’apprendimento.

A chi è rivolto

Il corso si rivolge a sviluppatori JavaScript/TypeScript che conoscono npm install e async/await. Non è richiesta esperienza precedente in AI o machine learning. Ogni capitolo inizia con un’analogia del mondo reale per ancorare il concetto prima di qualsiasi codice.

Per chi già lavora su applicazioni .NET o backend e vuole esplorare il lato AI senza cambiare linguaggio, questo corso rappresenta il punto di ingresso ideale: nessun boilerplate Python, nessun ambiente virtuale da gestire, solo TypeScript e strumenti già familiari.

Considerazioni finali

LangChain.js ha raggiunto una maturità che lo rende adatto a progetti di produzione. Il corso di Microsoft colma un gap reale: la maggior parte della documentazione e dei tutorial sull’AI generativa è orientata a Python. Avere un percorso strutturato, gratuito e orientato agli agenti per l’ecosistema JavaScript è un vantaggio concreto per chi già lavora in questo stack.

Se state valutando come integrare capacità AI nelle vostre applicazioni Node.js o Deno, o se volete costruire un copilota interno per il vostro team, questo è il punto di partenza più pragmatico disponibile oggi.

---

Fonte originale: LangChain.js for Beginners: A Free Course to Build Agentic AI Apps with JavaScript — Microsoft for Developers

LangChain.js for Beginners: A Free Course to Build Agentic AI Apps with JavaScript - Microsoft for Developers

Want to build AI agents with JavaScript that go beyond basic chat completions? Agents that reason, call tools, and pull from knowledge bases on their own?

^{Yohan Lasorsa (Microsoft for Developers)}

(in)sicurezza digitale

2026-04-27 10:59:28

UNC6692 usa Microsoft Teams per distribuire SNOW: email bombing, impersonazione helpdesk e compromissione del dominio Active Directory

Si parla di:
Toggle

Non serve uno zero-day quando si puo’ semplicemente telefonare. O meglio: mandare un messaggio su Microsoft Teams fingendo di essere il supporto IT aziendale. E’ questa la filosofia operativa di UNC6692, un gruppo di minaccia documentato da Google Threat Intelligence Group (GTIG) e Mandiant il 22 aprile 2026, che ha sviluppato una delle catene di intrusione piu’ efficaci osservate di recente: zero vulnerabilita’ software sfruttate, impatto devastante.

La catena di attacco: dalla casella di posta al dominio compromesso

La campagna di UNC6692 si articola in piu’ fasi con una logica narrativa precisa, progettata per sfruttare i processi cognitivi delle vittime anziche’ le vulnerabilita’ del software. Tutto inizia tra fine dicembre 2025 e i mesi successivi con un’operazione di email bombing: le vittime — prevalentemente dipendenti senior (77% dei casi rilevati) — si trovano improvvisamente sommerse da migliaia di email spam, un’inondazione che paralizza l’attivita’ lavorativa e genera panico.

Nel momento di massima confusione, arriva il soccorso: un messaggio su Microsoft Teams da un account che si presenta come tecnico del supporto IT interno. L’attaccante offre assistenza per il problema email e guida la vittima attraverso una sequenza di azioni apparentemente legittime. Il punto critico e’ il click su un link che porta a una pagina di phishing ospitata su un bucket Amazon S3 — presentata come “Mailbox Repair and Sync Utility v2.1.5”. L’URL su S3 non e’ in lista di blocco di quasi nessun proxy aziendale, e il dominio amazonaws.com gode di alta reputazione nei sistemi di URL filtering.

La suite SNOW: tre strumenti, un’unica operazione

Il download dalla pagina di phishing avvia l’esecuzione di un binario AutoHotKey (RegSrvc.exe) che funge da dropper per l’ecosistema SNOW, una suite malware modulare composta da tre componenti distinti, ciascuno con un ruolo specializzato nella catena di compromissione.

SNOWBELT e’ un backdoor basato su JavaScript, distribuito come estensione Chromium (directory: SysEvents). Viene installato in modalita’ non-supervised attraverso policy forzate, non tramite il Chrome Web Store. Si maschera sotto nomi come “MS Heartbeat” o “System Heartbeat”. Una volta attivo nel browser della vittima, intercetta sessioni autenticate, cookie, token OAuth e qualsiasi credenziale inserita nelle form web. Comunica con il C2 tramite richieste verso bucket S3 in us-east-2, usando un VAPID key fisso come identificatore.

SNOWGLAZE e’ un tunneler Python compatibile con Windows e Linux. La sua funzione primaria e’ creare un tunnel WebSocket autenticato tra il sistema della vittima e l’infrastruttura C2 dell’attaccante, tipicamente un sottodominio Heroku. Questo tunnel permette all’attaccante di instradare traffico RDP, PsExec e altri protocolli attraverso una connessione apparentemente legittima verso Heroku, eludendo i controlli firewall.

SNOWBASIN e’ il backdoor persistente per il controllo remoto completo: esecuzione di comandi via cmd.exe o PowerShell, cattura di screenshot, upload/download di file e auto-terminazione. E’ SNOWBASIN che gestisce la fase di post-exploitation, una volta che il foothold iniziale e’ stabilito.

Post-exploitation: dal PC della vittima al domain controller

L’analisi di Mandiant descrive una sequenza di post-exploitation metodica e aggressiva. Dopo l’installazione della suite SNOW, l’attaccante utilizza SNOWGLAZE per stabilire una sessione PsExec verso il sistema compromesso, poi avvia una scansione della rete locale alla ricerca di sistemi raggiungibili su porte 135 (RPC), 445 (SMB) e 3389 (RDP). Una volta identificato un server di backup, SNOWGLAZE viene usato per instradare una sessione RDP verso di esso.

Sul server di backup avviene la fase critica: l’attaccante usa Windows Task Manager per eseguire il dump del processo LSASS (Local Security Authority Subsystem Service), catturando in chiaro tutti gli hash delle password degli account autenticati sul sistema, inclusi account privilegiati con accesso al dominio Active Directory. Il file di dump viene esfiltrato via LimeWire attraverso il tunnel SNOWGLAZE. Con gli hash estratti, e’ possibile effettuare attacchi pass-the-hash per autenticarsi come qualsiasi account del dominio, portando alla compromissione completa dell’infrastruttura AD.

Indicatori di compromissione (IoC)

# URL phishing (pattern)
https://service-page-[ID]-outlook.s3.us-west-2.amazonaws.com/update.html?email=

# C2 SNOWGLAZE (WebSocket)
wss://sad4w7h913-b4a57f9c36eb[.]herokuapp[.]com:443/ws

# C2 SNOWBELT (pattern URL S3)
https://[a-f0-9]{24}-[0-9]{6,7}-[0-9]{1}.s3.us-east-2.amazonaws[.]com

# SNOWBELT VAPID Key
BJkWCT45mL0uvV3AssRaq9Gn7iE2N7Lx38ZmWDFCjwhz0zv0QSVhKuZBLTTgAijB12cgzMzqyiJZr5tokRzSJu0

# File sospetti (dropper)
RegSrvc.exe    # binario AutoHotKey rinominato
Protected.ahk  # script AHK malevolo

# Directory estensione Chrome malevola
SysEvents/  # in %LOCALAPPDATA%\Google\Chrome\User Data\Default\Extensions

# Hash SHA256
SNOWGLAZE: 2fa987b9ed6ec6d09c7451abd994249dfaba1c5a7da1c22b8407c461e62f7e49
SNOWBELT background.js: 7f1d71e1e079f3244a69205588d504ed830d4c473747bb1b5c520634cc5a2477

Attribuzione e contesto

UNC6692 e’ classificato da Google/Mandiant come UNC (Uncategorized): non e’ ancora stata stabilita un’attribuzione definitiva a un paese o gruppo noto. Il profilo operativo mostra tuttavia caratteristiche interessanti: capacita’ di sviluppo malware custom elevate, pazienza tattica (la campagna di email bombing precede l’attacco di settimane) e una chiara preferenza per obiettivi aziendali con accesso privilegiato a infrastrutture IT. L’assenza di exploit zero-day puo’ indicare sia un operatore esperto che preferisce metodi OPSEC-sicuri, sia un gruppo finanziariamente motivato che ha ottimizzato il rapporto costo/impatto delle proprie operazioni.

Consigli per i difensori

La campagna UNC6692 mette in evidenza lacune difensive comuni negli ambienti enterprise. Sul fronte delle policy Microsoft Teams, e’ fondamentale limitare la possibilita’ per utenti esterni di contattare dipendenti interni tramite Teams: configurare una allowlist dei tenant esterni autorizzati e’ il primo passo. Sul fronte della protezione da email bombing, implementare rate limiting e filtri anti-spam aggressivi con alert su aumenti anomali di volume per singolo account. Per la protezione del browser, deployare policy Group Policy che blocchino l’installazione di estensioni Chrome non approvate e monitorare la creazione di nuove directory in %LOCALAPPDATA%. Monitorare il traffico verso sottodomini Heroku e bucket S3 non registrati come legittimi nel proprio inventario cloud. Infine, proteggere LSASS con Credential Guard su tutti i sistemi Windows 10/11 e Server 2019+: questa misura da sola avrebbe bloccato la fase piu’ critica dell’attacco documentato.

La campagna UNC6692/SNOW e’ un esempio paradigmatico di come il perimetro piu’ difficile da difendere non sia tecnico, ma umano: un dipendente stressato da un’inondazione di spam e “soccorso” da un collega del supporto IT e’ una vittima quasi inevitabile, indipendentemente dalla sofisticazione dell’infrastruttura di sicurezza aziendale.

Spcnet.it

2026-04-26 18:13:43

State Pattern in C#: guida decisionale con esempi pratici

Gli oggetti cambiano comportamento in base al loro stato interno continuamente. Un documento passa da bozza a revisione a pubblicato. Un personaggio di un gioco alterna tra inattivo, in corsa e in attacco. Un pagamento transita da pending ad autorizzato a catturato. La domanda quando usare lo State Pattern in C# emerge nel momento in cui la logica condizionale inizia a ramificarsi sullo stesso campo stato in metodo dopo metodo — e ogni nuovo stato obbliga a toccare più file.

In questo articolo troverete una guida decisionale pratica per il pattern State in C#: quando merita davvero il suo posto e quando soluzioni più semplici — enum o flag booleani — bastano e avanzano.

Cos’è lo State Pattern e cosa fa davvero

Lo State Pattern consente a un oggetto di cambiare il proprio comportamento quando il suo stato interno cambia. Dall’esterno sembra che l’oggetto abbia cambiato classe. Invece di sparpagliare istruzioni if e switch in ogni metodo che dipende dallo stato corrente, si incapsula il comportamento di ciascuno stato in una propria classe. L’oggetto delega al state object attivo in quel momento.

La struttura coinvolge tre ruoli:

• Context — mantiene un riferimento allo state object corrente e vi delega il comportamento
• State interface — dichiara i metodi che ogni stato deve implementare
• Concrete state classes — implementano l’interfaccia con il comportamento specifico del loro stato

Quando avviene una transizione, il context sostituisce il riferimento al proprio state object. Questo approccio elimina i blocchi condizionali che crescono ogni volta che si aggiunge uno stato nuovo.

Segnali che indicano che avete bisogno dello State Pattern

Non ogni oggetto con un campo status ha bisogno dello State Pattern. Tuttavia certi code smell sono segnali forti che il pattern ripulirà il design.

La logica condizionale si ramifica sullo stesso stato ovunque

Questo è il trigger principale. Quando vedete lo stesso switch o if-else che controlla _status in tre, quattro o dieci metodi diversi, il vostro oggetto sta gestendo le transizioni di stato nel modo più difficile. Ogni nuovo stato significa toccare ciascuno di quei metodi.

Avete regole di transizione complesse

Se le transizioni valide dipendono dallo stato attuale — e alcune azioni devono lanciare eccezioni o essere semplicemente ignorate a seconda di dove ci si trova — il pattern State rende queste regole esplicite invece di affogarle in condizionali.

Ogni stato ha un comportamento distinto

Quando lo stato influenza come si comporta un metodo, non soltanto se eseguirlo, il pattern vale l’investimento. Ciascuna classe stato diventa un luogo coeso che racchiude tutto il comportamento per quella condizione.

Scenario 1: gestione degli ordini (comportamento condizionale complesso)

Ecco un esempio di elaborazione ordini con lo State Pattern:

public interface IOrderState
{
    void Submit(OrderContext context);
    void Cancel(OrderContext context);
    void Ship(OrderContext context);
    void Deliver(OrderContext context);
}

public sealed class OrderContext
{
    public IOrderState CurrentState { get; private set; }
    public string OrderId { get; }

    public OrderContext(string orderId)
    {
        OrderId = orderId;
        CurrentState = new PendingState();
    }

    public void TransitionTo(IOrderState state)
    {
        Console.WriteLine(
            $"Order {OrderId}: " +
            $"{CurrentState.GetType().Name} -> " +
            $"{state.GetType().Name}");
        CurrentState = state;
    }

    public void Submit() => CurrentState.Submit(this);
    public void Cancel() => CurrentState.Cancel(this);
    public void Ship()   => CurrentState.Ship(this);
    public void Deliver() => CurrentState.Deliver(this);
}

public sealed class PendingState : IOrderState
{
    public void Submit(OrderContext context)
    {
        Console.WriteLine("Ordine inviato per elaborazione.");
        context.TransitionTo(new ProcessingState());
    }

    public void Cancel(OrderContext context)
    {
        Console.WriteLine("Ordine annullato prima dell'invio.");
        context.TransitionTo(new CancelledState());
    }

    public void Ship(OrderContext context) =>
        throw new InvalidOperationException("Impossibile spedire un ordine in attesa.");

    public void Deliver(OrderContext context) =>
        throw new InvalidOperationException("Impossibile consegnare un ordine in attesa.");
}

Notate come PendingState sappia esattamente cosa fare (o non fare) per ogni azione. Non c’è nessuno switch nello stato: il polimorfismo gestisce tutto.

Scenario 2: workflow e gestione dei processi

Un caso d’uso classico è la gestione di una domanda con audit trail integrato:

public interface IApplicationState
{
    string StatusName { get; }
    void Review(ApplicationContext context);
    void Approve(ApplicationContext context);
    void Reject(ApplicationContext context);
    void RequestInfo(ApplicationContext context);
}

public sealed class ApplicationContext
{
    public IApplicationState CurrentState { get; private set; }
    public string ApplicantName { get; }
    public List<string> AuditLog { get; } = new();

    public ApplicationContext(string applicantName)
    {
        ApplicantName = applicantName;
        CurrentState = new SubmittedState();
        Log("Domanda inviata");
    }

    public void TransitionTo(IApplicationState state)
    {
        Log($"Transizione a {state.StatusName}");
        CurrentState = state;
    }

    public void Log(string message) =>
        AuditLog.Add($"[{DateTime.UtcNow:u}] {message}");
}

L’audit trail viene aggiornato automaticamente a ogni transizione, senza duplicazione di codice nei metodi chiamanti.

Scenario 3: gestione dello stato di un personaggio in un gioco

I giochi sono un esempio naturale: un personaggio che alterna tra IdleState, RunningState, AttackingState e DyingState beneficia enormemente di questo pattern, poiché ciascuno stato ha logica di input e di update completamente diversa.

Quando NON usare lo State Pattern

Il pattern non è sempre la risposta giusta. Evitate di applicarlo nei seguenti casi:

• Stati booleani semplici: se l’oggetto ha solo attivo e inattivo, un campo booleano è più chiaro e diretto.
• Pochi stati senza transizioni significative: se avete due o tre stati con poco comportamento differenziato, gli enum bastano.
• La logica di transizione è esterna all’oggetto: se le decisioni di cambio stato appartengono a un orchestratore esterno, il pattern State aggiunge complessità senza benefici.

State Pattern vs alternative: quando scegliere cosa

Un enum con un switch è la scelta giusta quando gli stati sono pochi, stabili e il comportamento differisce solo su una o due dimensioni. Appena gli stati crescono, il comportamento diverge significativamente per metodo, o le transizioni diventano complesse, è il momento di passare al pattern State.

Il pattern State non è la stessa cosa del pattern Strategy: Strategy cambia l’algoritmo usato per una singola operazione, mentre State cambia il comportamento complessivo dell’oggetto al variare della condizione interna. Possono tuttavia lavorare insieme: una transizione di stato può emettere eventi che degli Observer gestiscono.

Integrazione con Dependency Injection

Una domanda comune è se il pattern State si integri bene con la DI di ASP.NET Core. La risposta è sì, con qualche accorgimento: le classi stato concrete possono essere registrate nel contenitore DI, ma è consigliabile usare factory o ActivatorUtilities.CreateInstance per creare le istanze in modo da evitare cicli nel contenitore.

Conclusione

Lo State Pattern in C# risolve un problema preciso: oggetti il cui comportamento cambia radicalmente al variare dello stato interno, con transizioni complesse e comportamento specifico per stato. Prima di applicarlo, fate questa verifica rapida: contate quante volte controllate lo stesso campo di stato in metodi diversi. Se la risposta supera tre o quattro, probabilmente il pattern vi risparmierà mesi di manutenzione futura.

La regola d’oro rimane: preferite sempre la soluzione più semplice che risolve il problema. Un enum con uno switch è più leggibile di una gerarchia di classi per casi banali. Ma quando la complessità cresce, lo State Pattern offre un’architettura che scala senza sforzo.

---

Fonte originale: When to Use State Pattern in C#: Decision Guide with Examples — Dev Leader

When to Use State Pattern in C#: Decision Guide with Examples

Discover when to use state pattern in C# with real decision criteria, use case examples, and guidance on when simpler alternatives work better.

^{Nick Cosentino (Dev Leader)}

(in)sicurezza digitale

2026-04-26 18:11:56

GlassWorm muta ancora: 73 estensioni “sleeper” su Open VSX pronte a svegliarsi come malware

Una campagna di supply chain attack di nuova generazione non aspetta di essere scoperta: prima si mimetizza, poi colpisce. È questa la logica dietro GlassWorm, un attore malevolo che ha trasformato il marketplace Open VSX in un campo minato di estensioni apparentemente legittime, pronte ad attivarsi dopo settimane di apparente innocenza.

La nuova ondata: 73 estensioni sleeper identificate

Il 25 aprile 2026, i ricercatori di Socket hanno pubblicato un’analisi approfondita rilevando 73 nuove estensioni per Open VSX — il registry alternativo a Visual Studio Marketplace, utilizzato principalmente dagli sviluppatori di VSCodium e Eclipse Theia — che mostrano caratteristiche riconducibili alla campagna GlassWorm. Almeno sei di queste estensioni si sono già “svegliate”, aggiornandosi per distribuire payload malevoli, mentre le restanti rimangono classificate come sleeper ad alta confidenza in attesa di attivazione.

Il meccanismo è elegante nella sua perversità: le estensioni vengono pubblicate con codice pulito, superano i controlli automatici del marketplace, accumulano installazioni e fiducia degli utenti — poi, attraverso un aggiornamento silenzioso o aggiungendo una dipendenza malevola, si trasformano in vettori di malware. Nessun exploit, nessun CVE: pura abuso della fiducia nella supply chain del software.

Evoluzione di una campagna persistente

GlassWorm non è un attore nuovo. La campagna è attiva almeno dal tardo 2024, con escalation progressive che si sono succedute nel corso del 2025-2026. A dicembre 2025 furono rilevate le prime 24 estensioni impersonatrici; a febbraio 2026 si scoprì che un account sviluppatore compromesso era stato usato per propagare il malware; a marzo 2026 la campagna scalò a 72 estensioni attive su Open VSX con diffusione tramite abuso di dipendenze. L’ondata di aprile 2026 rappresenta dunque l’evoluzione più sofisticata finora osservata.

Gli obiettivi rimangono costanti: furto di segreti di sviluppo (API key, token, credenziali), svuotamento di wallet di criptovalute, e trasformazione dei sistemi infetti in proxy per ulteriori attività criminali. Il target primario sono sviluppatori che lavorano su macOS, Linux e Windows con ambienti basati su VS Code o suoi fork.

Tecniche di attacco: la profondità della sleeper strategy

L’analisi di Socket rivela una serie di pattern tecnici ricorrenti nell’attuale cluster di 73 estensioni. I publisher sono account GitHub neonati, con una o due repository pubbliche: una repository vuota con nome composto da otto caratteri casuali e una contenente il codice dell’estensione. Questo pattern serve a superare le verifiche di identità del marketplace, che richiedono un profilo GitHub associato.

Le estensioni impersonano utility popolari — ad esempio il language pack turco per VS Code — usando la stessa icona, un nome simile e contenuti copiati dal pacchetto legittimo. Una volta guadagnata la fiducia degli utenti, la delivery del malware avviene in due modalità principali: aggiornamento diretto dell’estensione per includere codice offuscato, oppure aggiunta di una dipendenza da un’estensione separata che contiene il loader GlassWorm, sfruttando il fatto che l’installazione di un’estensione può portare all’installazione automatica di tutte le sue dipendenze dichiarate.

I payload attivati al momento includono: VSIX malevoli ospitati su GitHub, binari nativi firmati con certificati rubati, JavaScript offuscato con tecniche di code splitting per sfuggire all’analisi statica. Il loader GlassWorm, una volta eseguito nell’ambiente VS Code, ha accesso allo stesso filesystem, alle variabili d’ambiente e ai token di sessione dell’IDE — un privilegio enorme che permette di esfiltrare le credenziali di ogni servizio cloud configurato nello strumento di sviluppo.

Contesto più ampio: l’ecosistema VS Code come vettore sistemico

GlassWorm rappresenta un sintomo di una vulnerabilità strutturale: gli ecosistemi di estensioni per editor di codice sono intrinsecamente difficili da proteggere. A differenza dei package manager come npm o PyPI, dove esiste una cultura più consolidata di analisi della sicurezza, i marketplace di estensioni IDE tendono ad avere meccanismi di revisione più leggeri e una percezione del rischio più bassa da parte degli utenti. Un desarrollatore che installa un’estensione VS Code raramente si chiede se stia introducendo un RAT nella propria workstation.

La tecnica della sleeper extension è particolarmente insidiosa perché richiede pazienza da parte dell’attaccante — una caratteristica tipica di campagne sponsorizzate da attori con risorse significative. Non è ancora stata stabilita un’attribuzione definitiva per GlassWorm, ma il livello di sofisticazione e persistenza suggerisce un gruppo criminale strutturato o un attore nation-state interessato alla compromissione di pipeline di sviluppo software.

Indicatori di compromissione (IoC)

# Pattern publisher malevoli (account GitHub)
- Account con repository vuota a nome di 8 caratteri esadecimali
- Account creati tra gennaio e aprile 2026 senza storia pubblica

# Pattern nomi estensioni sospette (esempi noti)
- Estensioni che impersonano language pack (es. Turkish Language Pack for VSCode)
- Estensioni con nomi che differiscono di un carattere da quelle legittime

# Comportamenti runtime sospetti
- Lettura di variabili d'ambiente (PATH, HOME, credenziali cloud)
- Connessioni in uscita verso bucket S3 su us-east-2 o us-west-2
- Caricamento dinamico di script da URL GitHub Raw

# Repository di tracking
https://socket.dev/glassworm-v2  (lista aggiornata estensioni maligne)

Consigli per i difensori

Per chi gestisce ambienti di sviluppo, alcune misure concrete. Prima di tutto, applicare policy di allowlist per le estensioni VS Code/VSCodium approvate, impedendo l’installazione di estensioni non verificate dall’organizzazione. Monitorare con strumenti come Socket o Phylum le dipendenze dei progetti, incluse quelle delle estensioni IDE. Configurare il traffico di rete delle workstation degli sviluppatori per rilevare connessioni anomale verso S3 bucket sconosciuti o hostname Heroku. Abilitare la telemetria degli IDE aziendali e integrarla nel SIEM per rilevare accessi insoliti al keychain o alle variabili d’ambiente. Infine, considerare l’adozione di ambienti di sviluppo containerizzati o in sandbox, dove l’impatto di un’estensione compromessa è limitato al container.

Socket mantiene una pagina dedicata al tracking di GlassWorm v2 con l’elenco aggiornato delle estensioni malevole identificate: consultarla periodicamente è una misura di igiene minima per chi usa Open VSX. La campagna è ancora attiva e il numero di sleeper non ancora attivati — stimato in oltre 60 — suggerisce che il peggio non sia ancora avvenuto.

Spcnet.it

2026-04-26 10:08:16

Classificazione documenti in C# senza AI: approccio deterministico, spiegabile e pronto per la produzione

Classificare automaticamente i documenti aziendali è uno di quei problemi che, a prima vista, sembra un caso d’uso ideale per i modelli AI. Ma in ambienti di produzione, la stabilità, la tracciabilità e la prevedibilità del comportamento spesso contano più della flessibilità. In questo articolo vediamo come implementare un classificatore di documenti rule-based, ponderato e completamente spiegabile in C# .NET, senza toccare un singolo modello di machine learning.

Perché non partire dall’AI?

I modelli AI per la classificazione di testo sono potenti, ma introducono una serie di criticità in contesti enterprise:

• Non-determinismo: lo stesso documento può ricevere classificazioni diverse a seconda della versione del modello, del wording del prompt o di aggiornamenti interni del provider.
• Opacità: spiegare a un responsabile compliance perché il modello ha classificato un contratto come “fattura” è praticamente impossibile.
• Dipendenza da pipeline di dati: aggiornare il classificatore richiede raccolta di dati, rietichettatura, riaddestramento e deployment.

Un approccio deterministico e rule-based risolve tutti e tre i problemi: stesso input, stesso output, sempre. Ogni decisione è tracciabile e modificabile senza toccare il codice, solo aggiornando un file di configurazione JSON.

Architettura del classificatore

Il sistema segue una pipeline chiara:

1. Caricamento dei profili di classificazione da file JSON
2. Apertura del documento .docx con TX Text Control
3. Estrazione del testo da corpo, intestazioni e piè di pagina
4. Rilevamento delle regioni strutturali (titolo, heading, corpo, header, footer)
5. Matching delle regole per categoria con strategie configurabili
6. Calcolo degli score ponderati per categoria
7. Restituzione della categoria vincente con confidence score e spiegazione dettagliata

L’elemento chiave è che tutta la logica di classificazione vive nel file JSON, non nel codice. Questo significa che un domain expert (non un developer) può modificare e migliorare il classificatore semplicemente editando la configurazione.

Il file di configurazione

Ogni categoria è descritta da un insieme di regole. Ogni regola specifica:

• term: il termine o la frase da cercare
• weight: il peso del contributo di questa regola allo score
• matchMode: la strategia di matching (Phrase, WholeWord, Contains)
• strength: la forza del segnale (Strong, Weak)

Esempio per la categoria “Resume”:

{
  "name": "Resume",
  "rules": [
    {
      "term": "work experience",
      "weight": 3.0,
      "matchMode": "Phrase",
      "strength": "Strong"
    },
    {
      "term": "email",
      "weight": 1.0,
      "matchMode": "WholeWord",
      "strength": "Weak"
    }
  ]
}

La distinzione tra segnali forti e deboli è cruciale. “Work experience” in un documento è un indicatore molto specifico di un CV, mentre “email” può apparire praticamente ovunque e deve pesare di meno. Questa granularità evita i falsi positivi che affliggono i classifier naïve basati su semplice keyword counting.

Estrazione strutturata con TX Text Control

Il classificatore non tratta il documento come un blocco di testo piatto. Usando TX Text Control .NET Server, estrae il contenuto per regioni strutturali:

using var textControl = new ServerTextControl();
textControl.Create();
textControl.Load(docxPath, StreamType.WordprocessingML);

Vengono estratti separatamente:

• textControl.Paragraphs → testo del corpo
• textControl.Sections → HeadersAndFooters → intestazioni e piè di pagina di ogni sezione

Questa distinzione è fondamentale: nelle fatture, i termini identificativi come “FATTURA N.” appaiono tipicamente all’inizio del documento o nel titolo. Nei report, il tipo di documento è spesso incorporato nell’header. Ignorare queste regioni significherebbe perdere segnali classificatori di primo livello.

Structure Awareness: non tutto il testo vale uguale

Il miglioramento più significativo rispetto al semplice keyword matching è la consapevolezza della struttura. Il classificatore assegna pesi diversi agli stessi termini a seconda della regione in cui appaiono:

• Un termine nel titolo del documento ha peso massimo: è quasi certamente indicativo del tipo di documento
• Un termine in un heading H1/H2 ha peso alto
• Lo stesso termine nel corpo del documento ha peso standard
• Nel footer (tipicamente template boilerplate) il peso è ridotto

Questo approccio riflette come un essere umano leggerebbe effettivamente il documento: prima si guarda il titolo, poi le intestazioni principali, infine il corpo.

Scoring, confidence e spiegabilità

Al termine dell’analisi, il sistema restituisce non solo la categoria vincente, ma anche:

• Il confidence score (rapporto tra lo score della categoria vincente e la somma degli score di tutte le categorie)
• Una spiegazione dettagliata: quali regole hanno fatto match, in quale regione, con quale peso

Questa tracciabilità è essenziale per scenari di audit e compliance. Se un documento viene classificato erroneamente, il problema è sempre identificabile e correggibile: si modifica la regola nel JSON e si riclassifica. Nessun riaddestramento, nessuna nuova pipeline di dati.

Quando usare questo approccio (e quando no)

L’approccio deterministico è ottimale quando:

• Il set di categorie è definito e stabile (fatture, contratti, report, CV, ecc.)
• La compliance e l’auditability sono requisiti primari
• Il volume di documenti è alto e la velocità di classificazione è critica
• Non si dispone di dataset etichettati sufficienti per addestrare un modello

Dove l’AI rimane superiore è nei casi con categorie ambigue, linguaggio naturale molto variabile, o quando il set di categorie evolve rapidamente e non si vuole aggiornare manualmente le regole. Un’architettura ibrida – classificazione rule-based come primo filtro, AI solo per i casi borderline – è spesso la soluzione migliore in produzione.

Conclusione

La classificazione documentale senza AI non è un’alternativa di ripiego: è una scelta ingegneristica deliberata per sistemi che richiedono stabilità, spiegabilità e controllo. Il pattern rule-based, ponderato e configuration-driven descritto in questo articolo è già in uso in ambienti di produzione enterprise e offre vantaggi concreti in termini di manutenibilità e trasparenza.

Se il vostro stack include la gestione di documenti .docx in C#, questo approccio vale la pena di essere valutato prima di introdurre la complessità di un modello ML.

Fonte: Document Classification Without AI: Deterministic, Explainable, and Built for Production in C# .NET – Bjoern Meyer, TX Text Control Blog

Document Classification Without AI: Deterministic, Explainable, and Built for Production in C# .NET

In this article, we explore how to implement document classification without relying on AI. We will discuss deterministic methods that are explainable and suitable for production environments.

^{Bjoern Meyer (Text Control)}