# **StyloBot: Come i bot sono diventati più intelligenti - La nuova frontiera nella detezione dei bot (Parte 2)** *Parte 1 era il motivo . Questa è la mostra - e - di raccontare quello che lo StyloBot fa, che è raro nelle pile di bot di produzione.* Teoria:Modelli di StyloBot per la detezione dei robot come un processo progressistaM SK1 precoce-Topologia d'uscita dei segnali comportamentali , con risultati di reazione che si riferiscono al contesto di campagna per la conservazione della memoria temporale limitata e di punteggio. Se avete un'invenzione di prezzi, inventario, o contenuti propriettariM SK2 si tratta di fermare la raccolta su larga scala -Su misura MSC4intelligenza del prezzoMST5incrocio competitivoMSST6la scorciata di addestramento artificialeMSM7 prima che diventi il vostro traffico di baseMSV8 > ### Cosa rende lo StyloBot diverso? > > - comportamentale, non regola- basata > - Detezione progressiva, non analisi completa > - campagna-awareM SK1 non chiedere-a aware > - real-time, non lotto **[Leggere la parte 1: StyloBot: Combattersi di nuovo contro i Combattenti](https://www.mostlylucid.net/blog/botdetection-introduction)** **[Leggere la parte 3: Semplice quanto possibile e non più semplice](https://www.mostlylucid.net/blog/botdetection-part3-as-simple-as-possible)** - Due linee di codice per l'intera porta di produzione **[👉 See It Live: StyloBotM SK2net](https://stylobot.net)** - Questo è il sistema di produzione reale che funziona prestoM SK1detection inline di sortie alla porta mesurazione inline; la latenza varia secondo le politiche e le onde attivateMSC4 [![NuGet](https://img.shields.io/nuget/v/mostlylucid.botdetection.svg)](https://www.nuget.org/packages/mostlylucid.botdetection/) [![GitHub](https://img.shields.io/github/stars/scottgal/stylobot?style=social)](https://github.com/scottgal/stylobot) [![Docker](https://img.shields.io/docker/pulls/scottgal/stylobot-gateway)](https://hub.docker.com/r/scottgal/stylobot-gateway) --- [TOC] --- ## Parte 2 Contexto Questo post skips setup and configuration (covered in Part 1), focusing instead on the novel internals that set StyloBot apart. --- ## Perché siamo qui? La nuova frontiera del bot Prima di immergersi nell'architettura, capire la minaccia. Non si tratta più di bloccare gli scafatori sempliciM SK3 ### Cosa fanno i Bot? I robot vanno in categorie: 1. **Spazzatori stupidi** (curl loopsM SK1 wget): Chiedere la stessa strada ripetutamente , header identiciMSC4 schemi prevedibiliMNK5 facile da bloccareMRK6 2. **Browser senza testa** (PuppeteerM SK1 Playwright): Immagina meglio i browser reali . Loro catturano le proprie risorse M SK4 gestiscono JavaScript 3. **reti di proxy residenziali**: Demande dai veri IP di un ISP di casa, che fanno fallire i controlli sulla geolocalizzazioneM SK2 Hanno ancora schemi di firma , ma sottiliMSC4 4. **LLM-bot alimentati** (NEWM SK1 Questi crawlano il vostro sito mantenendo una conversazione coerente-con schemi di accesso simili a quelli del .Si capiscono i contestiMSC4Miconicano un comportamento di browsing legittimo su larga scalaMST5 talvolta con l'intenzione di inquinare set di datiMst6Estrae informazioni propriettarieMSt7 o scarabocchiare per dati di allenamentoM st8 I primi tre esistono da anni. **Il quarto è dove la profondità conta.** Common real-world targets include price intelligence scraping, competitive intelligence crawling , and dataset harvesting for model trainingM SK3 ### Come si è evoluta la sofisticazione del bot | Generazione | tattica S| difesa M| |------------|--------|---------| | **v1: Basic** | Lo stesso IPM SK1 percorsi ripetuti, UA statica | Limitazione del tassoMSC4 blocchi di IP PSK5 | **v2: senza testa** | Il browser reale, L'esecuzione del sistema JSM SK2 La fettura dell'asset | Limiti di tasso comportamentaleMSC4 Le impronte digitali TLS CSK5 | **v3: Distributo** | IP rotantiM SK1 proxy residentii, tempi variabili | CrossMSC4 correlazione stratificataMST5 memoria di firma SST6 | **v4: LLM-Driven** (NOWM SK1 | Patterns di browsing naturali, Requisizioni contextualiMSC4 legittime mixed | | + spazzatura |, inquinamento dei set di dati ♫| Tutte le cose precedenti ♫ + modellazione di transizione ♫ **Il salto da v3 a v 4:** I vecchi bot seguivano regole o casualità. I nuovi bot *Capire.* la struttura del vostro sito. Un bot LLM potrebbe chiedere il prodotto A, poi i prodotti connessi B e C M SK2 come un vero utenteMSC3 poi estrarre sistematicamente i prezzi per un modello addestrato *la sequenza* Sembra naturale, ma il *obiettivo globale* è maliziosa. ### Perché questo non è un overkill? Potreste pensare::, ", "Isn, '", "Non rilevare i modelli di Markov e la convergenza dei cerchi", "Massive overengineering for blocking bots". No. Qui'sì perchéM SK2 1. **I robot adattativi avanzati sono costosi da gestire.** Costi di addestramento, tasse API, tempo GPUM SK2 Hanno vinto 'no richieste di scartoMSC4 Saranno *efficiente* e *obiettivo*. 2. **Immaginano gli umani eccezionalmente bene.** Un limite di tasso statico vince' non li catturateM SK1 Un utente-Un controllo dell'agente vince~'non funziona~M SK4 Avete bisogno di molti+- correlazione strati+M SK6 risposta+-loop di comportamento+MST8+Contexto di campagna+MSST9 3. **I falsi positivi sono costosi.** Bloccare un vero utente per errore, e si perdono. StyloBotM SK2 la memoria limitata e il ragionamento temporale vi permettono di mantenere una grande fiducia senza essere draconianiMSC3 4. **La superficie dell'attacco si sta espandendo.** I Combattenti non vogliono più solo il vostro HTML. Vogliono avvelenare l'indice di ricerca, estrarre algoritmi propriettariM SK2 addestrare modelli competitivi , o raccogliere email dagli utentiMSC4 Le scommesse sono più alte **Legge di riferimento:** - [OWASP: Bot Management](https://owasp.org/www-community/attacks/Bot_attack) - [Imperva: Rapporto del traffico di bot 2024](https://www.imperva.com/blog/bot-attack-trends/) - [Cloudflare: Capire la Detezione del Bot](https://www.cloudflare.com/learning/bots/what-is-bot-detection/) --- ## Principio architettonico fondamentale La maggior parte dei sistemi di robot fanno uno o due di questi; combinandoli alla fine-toM SK2la fine è ancora relativamente rara nei sistemi di produzioneMSC3 L'idea unificata è una topologia del segnale comportamentale valutata progressivamente MST4exit anticipatoMSM5 con feedback chiusoMSSM6loop e stato temporale limitato che permette una struttura di campagna emergenteMSS7 1. **Analizio progressista iniziale-exit M SK1 grafico delle onde)** → I controlli economici vanno prima ; l'analisi più approfondita va avanti solo quando le prime prove lo confermano. 2. **Rispondenza-cicli di feedback laterali** → Capisce come i robot ad adattamento avanzati cambiano il comportamento basandosi sulle vostre risposte. 3. **Correlazione a strati Cross-** → corrisponde alle affermazioni di identità (UAM SK2 geo) contro la verità della rete (TCPMNK5TLSMRK6HTTPMMK7 per rendere l'inganno materialemente più difficile 4. **La memoria della firma con lo stato temporale limitato** → Mantiene visibile il contesto della campagna senza crescita di RAM senza limiti sotto caricoM SK1 5. **Modellazione di transizione (Markov-flussi stilisticiM SK2** → Apertura schemi di extrazione sistematici che sembrano umani per la richiesta, ma si diffondono al livello della forma della sequenza (con un presupposto senza memoria 6. **Campaign clustering + convergenza** → Converti molti segnali deboli per -questione in entità di campagna durevole (onde,, prodotti,M SK4 famiglie,). Questo consente una risoluzione comportamentale più alta mantenendo le decisioni spiegabili. --- ## Il tubo in una sola foto ```mermaid flowchart LR R[Request] --> W[Wave Contributors] W --> A[Evidence Aggregation] A --> S[Signature + Temporal Context] S --> P[Probability, Confidence, Risk Band] P --> X[Policy Action] X --> Y[Response Outcome] Y --> F[Response Feedback Loop] F --> W ``` `Wave contributors` sono componenti di rilevatore in fase: la porta li fa girare nelle onde progressiste e si esce presto una volta che il rischio è sicuro basso o alto. Notate che il ciclo di feedback: il comportamento di risposta si inserisce nel prossimo ciclo di richiesta. **[Vedete questo tubo in produzione a stylobot.net](https://stylobot.net)** - Invia una richiesta e la segui attraverso il tubo con l'accensione inizialeM SK1exit enabled measured inline at the gateway --- ## Early Exit Execution Model (WaveM SK1Orchestrated Detector Graph) Invece di far funzionare tutti i rilevatori su ogni richiesta, StyloBot usa un **Una catena di tubature in fase.**: economico , i controlli veloci vanno prima. Solo se segnano qualcosa di sospetto spende CPU su costosiM SK3 analisi più approfonditeMSC4 **Perché questo conta:** Voi'non paghiamo il costo dell'analisi completa (consulti di un gruppoM SK2 correlazione più profonda , euritica LLMM Sk4 per ogni utilizzatore inoffendenteM sk5 Controlli veloci eliminano i bot ovvi immediatamenteMdk6 e prestoMk7 l'exit conserva la latenza per un buon trafficoMtk8 ```csharp services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); ``` Questo mantiene la latenza del percorso veloce- bassa, permettendo l'analisi profonda solo quando è giustificata da segnali precoci. --- ### Dove i sistemi di rilevamento dei bot esistenti si fermano La maggior parte dei servizi di rilevamento dei robot produttivi gestiscono v1-v3 efficacementeM SK2 Qui ' è la rottura del mercatoMSC4 | Soluzione | Controlla fino a | Si ferma al costo M| Costo | Come funziona S| |----------|---------------|----------|------|--------------| | **Limitazione del tasso semplice** (nginxM SK1 Apache) | vMSC4 \| v+2 | | | Free (OSSMスク9 ♫| Requisizioni per IPMska11UAMske12 Irraggiungibile per bypassare con la rotazione | **La reputazione IP di AWS WAF +** | vM SK1v2 | v+3 \| | | ~$5-20/ mese |+ per-tasse di richiesta | | GeoIP |+ conosciuto | МSK11 cattive liste IP |M. Niente modellazione comportamentale | | **La gestione del bot Cloudflare** | vM SK1v3 | v+4 \in parteMSC6 | | | ♫~$250-1000/month SSL fingerprintingMNK10 sfida JSMRK11 punteggio comportamentaleMMK12 non corrispondeMEK13non corrispondrà a una classificazione temporale o di campagnaMBK15classificazione a livello di gruppoMZK16 || | **Imperva/Incapsula** | vM SK1v3 | v+4 \in parteMSC6 || | | ~$3000-15000/ | anno | | | Impronta digitale del dispositivo | MISK10 | Linee di base comportamentali |MISK11 | Limiti di tasso | MiSK12 | Debole al LLM | miSK13 | Patterni specifici | **DataDome** | vM SK1v3 | v+4 \in parteMSC6 | | | ♫~$5000-25000/anno || RealeMST10time ML scoringMSSK11 adattabileMSS12 buono per v MSS13 Ma nessun modello esplicitato di transizione Markov o memoria di firma limitataMSM14 ♪MSS15 | **Akamai Bot Manager** | vM SK1v3 | v+4 \in parteMSC6 || | | ~$10000-50000+/ | anno | ( | tipo di misura | m) |m| | larghe impronte digitali e reputazione |M. | buona scala | M, | ma non progettata per un contesto di campagna coordinato | D. | T| | **Open source** (failM SK1ban, etcMSC3 | vMNK5 \| v+2 | | | Free \ (OSS\ MNK10\ |MNK11 | Log\ MMK12\based IP blocking\ MZK13\ No real\ MKK14\time request instrumentation\ MGK15\ \mNK16 | **StyloBot** | vM SK1v4 | Oltre CMS4 Gratis PES5OSSMSC6 | | NuGet package | | Tutti i precedenti |+ cicli di risposta ripercussionale | CMS10 modellazione di transizione | DSS11 | memoria di firma | SSS12 | convergenza di cluster | LLM | SS14 | rilevamento specifico | MS15 | chiaramente costruito per la nuova frontiera | SM16 | ES17 **Controllo della realtà dei costi:** - Soluzioni per l'impresa (CloudflareM SK1 Imperva, DataDome , AkamaiMSC4 sono **$3,000-$50,000+ annualmente** Perché loro' gestivano SaaS con M SK1 supporto e rapido ingestione dei dati. Sono veloci a deploizzare e gestire la superficie d'attacco della known v 2-vMSC5 - Open source (fail 2ban, nginx rate limitingM SK3 è gratis ma si ferma a vMSC4 - **StyloBot è gratis.** (Pachetta NuGet senza licenze), autoM SK2 gestita , e manodopera v+2-v+M SK5 Paga in infrastruttureMSC6CPU+, senza licenziamentoMスク8 **Percezione chiave:** La maggior parte delle soluzioni per l'impresa (CloudflareM SK1 Imperva, AkamaiMSC3 sono forti nella rilevazione v 2-vMSSK5 They catch headless browsers and distributed proxy networksMSL7 But they stop before vMST8 becauseMSR9 1. **No response-feedback loops** → PuòM SK1 non tracciare come i robot imparano dalle vostre risposte. 2. **Nessun modello di transizione.** → Può' non distinguere " modelli di browsing che sembrano umani ma che si estraggono sistematicamenteM SK3 3. **Nessuna memoria temporale limitata.** → O uno stato senza confini ( fuga di memoria sotto DDoS) o nessuna contrapposizioneM SK3 ragionamento temporaleMSC4 4. **Non c'è gruppi di campagna espliciti.** → Trattare ogni firma di bot in modo indipendente; sbagliare le onde coordinateM SK2 **Non sono sbagliati, ma gestiscono il mercato che esisteva in 2022..** Ma i robot LLM hanno cambiato il gioco. --- ## Architecture Deep Dive Il resto della posta passa attraverso ogni meccanismo del pipeline, con codici e esempi concreti. --- ## Respondenza-Feedback da parte della Request Scoring StyloBot registra il comportamento di risposta e lo piega in decisioni future di richiesta per la stessa firma cliente. ### Hook point in middleware ```csharp private async Task RecordResponseAsync( HttpContext context, AggregatedEvidence evidence, ResponseCoordinator coordinator, DateTime requestStartTime) { var ip = context.Connection.RemoteIpAddress?.ToString() ?? "unknown"; var ua = context.Request.Headers.UserAgent.ToString(); var clientId = $"{ip}:{GetHash(ua)}"; var signal = new ResponseSignal { RequestId = context.TraceIdentifier, ClientId = clientId, Timestamp = DateTimeOffset.UtcNow, StatusCode = context.Response.StatusCode, Path = context.Request.Path.Value ?? "/", Method = context.Request.Method, RequestBotProbability = evidence.BotProbability, InlineAnalysis = false }; await coordinator.RecordResponseAsync(signal, CancellationToken.None); // Improve transition modelling with observed response content type waveform?.UpdateResponseContentType(clientId, context.Response.ContentType); } ``` ### Cosa contribuisce? `ResponseBehaviorContributor` può aggiungere segnali come: - **Il percorso del vaso di miele colpisce:** Avete percorsi segreti che gli utenti reali non visitano mai (. `/admin/secret.php`). Un robot che le chiede è ovviamente malizioso. - **404 schemi di scansione:** Un bot che chiede 50 diversi percorsi che non esistono'non esistono ? Ricognizione classicaM SK3 - **Auth brute-combattimento forzato:** Ricevere ripetutamente le risposte 401/403 significa che qualcunoM SK1ha provato le password. - **Tasto-historia di violazione dei limiti:** Il bot ti colpisce continuamente dopo essere spazzato via. - **High composite response score:** La combinazione degli esempi mostra attacchi deliberati, non casualiM SK1 Questo trasforma la detezione in una **chiuso-sistema di controllo a circuito**: Osservate come si comporta il bot. *dopo.* e questo cambia il punteggio per la prossima richiesta. È come un circuito di feedback dove ogni interazione insegna al sistema di più sull'attore. --- ## Novel Bit #2: Markov-Modello di Transitione Stile Il rilevatore di forma d'onda costruisce un **Matrice di transizione** (un grafico che mostra quante volte le richieste si muovono da un tipo all'altro ) tra le classi di contenuti e valuta l'intero modello di navigazione. **Cosa significa in un linguaggio semplice:** Un modello Markov traccia " cosa succederà dopo?" basandosi su quello che avete appena vistoM SK2 I browser umani in genere chiedono una pagina → poi molti Assets | ( | immagini |, | scritture | МSK6 | → | poi un'altra pagina ♫ . | I bot mostrano spesso diversi schemi ♫ ```csharp var transitions = new int[3, 3]; var fromCounts = new int[3]; for (var i = 1; i < classes.Count; i++) { var from = (int)classes[i - 1]; var to = (int)classes[i]; transitions[from, to]++; fromCounts[from]++; } var pageToAsset = (double)transitions[(int)ContentClass.Page, (int)ContentClass.Asset] / fromCounts[(int)ContentClass.Page]; var pageToPage = (double)transitions[(int)ContentClass.Page, (int)ContentClass.Page] / fromCounts[(int)ContentClass.Page]; ``` E poi segna una forma di transizione sospettosa: ```csharp if (pageToPage > 0.7 && pageCt >= 5) contributions.Add(DetectionContribution.Bot( Name, "Waveform", 0.6, $"Scraper pattern: {pageToPage:P0} of page requests lead to another page", weight: 1.5, botType: BotType.Scraper.ToString())); ``` **La bandiera rossa:** Se 70% delle richieste di pagina vanno direttamente ad un'altra pagina (invece di prelevare gli abiti come fa un browser realeM SK2 quello' è una firma del botMST4 I browser reali prelevano la paginaMSSK5 poi caricano tutti i file supportanti (immaginiMS, CSSMSV8 JavaScriptMSC9 Gli spacciatori spesso sfuggono alla prelezione degli abiti e saltano semplicemente tra le pagineMSS10 --- ## Novel Bit #3: Wave-Grafa di Detettore Orchestrato Invece di far funzionare tutti i rilevatori su ogni richiesta, StyloBot usa un **Una catena di tubature in fase.**: economico , i controlli veloci vanno prima. Solo se segnano qualcosa di sospetto spende CPU su costosiM SK3 analisi più approfonditeMSC4 **Perché questo conta:** Voi'non paghiamo il costo dell'analisi completa (ModelliMLM SK2Locamenti di clusters , ecceteraMSC4 per ogni utilizzatore inoffensibileMST5 Controlli rapidi della reputazione eliminano immediatamente i bot ovviMst6 ```csharp services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); ``` Questo mantiene la latenza del percorso veloce- bassa, permettendo l'analisi profonda solo quando è giustificata da segnali precoci. --- ## Novel Bit #4: Cross-Correzione di Layer (Truth of Network vs Claimed IdentityM SK3 Un bot può mentire sull'User-Agent (la sequenza che afferma "IM SK3m Chrome su WindowsMSC4 Ma le strati più profonde della rete sono più difficili da falsificare convincentemente **L'idea:** Controlli se le affermazioni del bot' sono coerenti a diversi livelli: - **Layere TCP** (la connessione a basso livelloM SK1la connettività a livello ): Le macchine Windows hanno dimensioni e comportamenti specifici di finestre TCP. Il comportamento TCP del botMSC4 corrisponde al suo sistema OS claimedMST5 - **TLS/SSL strato** (hake di mano per l'encriptazione): Diversi browser usano diverse ordinazioni e versioni di TLS ciphereM SK2 Il bot ' ha una impronta digitale TLS che corrisponde a quella che dovrebbe avere Chrome МSK4or Safari ) - **HTTP/2 strato** (il modo in cui le strutture dei browser chiedono):I veri browser hanno comportamenti HTTP specificiM SK2clienti . Il bot li imita correttamenteMSC4 - **Langue geografica/** consistenza: Il bot afferma di essere a Tokyo ma usa un AWS datacenter IP? CheM SK2 è sospettoso . Se vedete incompatibili tra le strati 3+ , è quasi certamente un bot— perché falsificare tutte queste cose con consistenza è molto più difficile che cambiare solo l'User. ```csharp var osMismatch = AnalyzeOsCorrelation(tcpOsHint, tcpWindowOsHint, userAgentOs, signals); var browserMismatch = AnalyzeBrowserCorrelation(h2ClientType, userAgentBrowser, tlsProtocol, signals); var tlsMismatch = AnalyzeTlsCorrelation(tlsProtocol, userAgentBrowser, signals); var geoMismatch = AnalyzeGeoCorrelation(state, signals); if (anomalyCount >= 3) contributions.Add(DetectionContribution.Bot( Name, "Correlation", 0.85, $"Multiple layer mismatches detected ({anomalyCount}/{totalLayers})", weight: 2.0, botType: BotType.MaliciousBot.ToString())); ``` Questo è uno dei meccanismi più forti contro l'impalcatura nella pila. --- ## Novel Bit #5: Signature Memory With Bounded Temporal State StyloBot ricorda quello che ogni firma di bot ha fatto recentemente. Ma la memoria deve essere **I confini sono limitati.** (canM SK1non cresce per sempre ) e **ordinato** (updates can't race each otherM SK2 **Perché è difficile:** Immaginate un bot che continua a colpire il vostro sito dallo stesso IP e dallo stesso utente-Agent combo. Vogliate ricordare M SK2Questa cosa ha colpito la vasca da miele 5 volteMSC4 |"ha avuto 403s sui tentativi di authMST7 MMST8itMst9s parte di un gruppo coordinatoMSt10 Ma in scenario di traffico elevatiMSSK11 potete avere migliaia di firmeMSS13 e aggiornazioni che arrivano in paralleloM SS14 Senza gestimento dello stato prudenteMISS15 perderete o i dati MSKS16caches estraggono una storia importanteMS KS17 o spendete troppo memoria SSS18la crescita incontrollataMSCS19 Il StyloBot lo risolve con TTL-cache di memoria (memoria che si spegne automaticamente le vecchie firmeM SK2 più aggiornazioni sequenziali chiavete (quella firmaMNK4le aggiornazioni sono ordinateMMK5prevenendo le condizioni di corsaMRK6 ```csharp _signatureCache = new SlidingCacheAtom( async (signature, ct) => new SignatureTrackingAtom(signature, _options, _logger), _options.SignatureTtl, _options.SignatureTtl * 2, _options.MaxSignaturesInWindow, Environment.ProcessorCount, 10, _signals); _updateAtom = new KeyedSequentialAtom( req => req.Signature, async (req, ct) => await ProcessSignatureUpdateAsync(req, ct), Environment.ProcessorCount * 2, 1, true, _signals); ``` Si ottiene un parametro deterministico per l'ordine delle firme-paralelismo tra le firme , e il controllo automatico TTL/LRU della pressioneM SK4 --- ## Novel Bit #6: Cluster + Convergence Intelligence Il StyloBot non si ferma al singolo-scorsione della firma.Addiziona la campagnaM SK2Contexto di livelloMSC3 - **Clusteri di prodotti Bot:** Lo stesso strumento di scarico usato da molti attacchi. Se riconoscete un bot da `ScraperXYZ`, trovare un altro fa aumentare la fiducia - **Clustere di reti Bot:** Attacchi coordinati da diverse segnature (differenti IPM SK1utente rotante-agentiMSC3ma la stessa campagna ). Questi corrispondono temporalmenteMST5 ti colpiscono in ondaMst6 - **La reputazione del paese col decadimento:** La maggior parte del traffico di bot viene dalle IP dei datacenter in alcune regioni. - **famiglie di convergenza della firma:** A volte un bot ruota il suo User-Agent o IP parzialmente ma mantiene i comportamenti di base. Le famiglie di convergenza tracciano queste mutazioni correlateM SK2 ```csharp var cluster = _clusterService.FindCluster(signature); if (cluster != null) { signals[SignalKeys.ClusterType] = cluster.Type.ToString().ToLowerInvariant(); signals[SignalKeys.ClusterMemberCount] = cluster.MemberCount; if (cluster.Type == BotClusterType.BotProduct) contributions.Add(BotContribution( "Cluster", $"Part of bot product cluster '{cluster.Label}' ({cluster.MemberCount} members)", confidenceOverride: ProductConfidenceDelta, botType: "Scraper")); } var family = _signatureCoordinator.GetFamily(signature); if (family != null && family.MemberSignatures.Count > 1) { contributions.Add(BotContribution( "ConvergedFamily", $"Part of converged family ({family.MemberSignatures.Count} members, {family.FormationReason})", confidenceOverride: familyBoost)); } ``` Questo aumenta la qualità della rilevazione per il traffico lungo le frontiere senza incertamente escalare ogni sconosciuto. --- ## Leiden Bot-Clustering di reti Usazioni attuale di clustering **La propagazione dell'etichetta** ( Immaginate di diffondere un'etichetta colorata attraverso una rete —I bot simili finiscono con la stessa etichetta **Riparazione della comunità stile Leiden-** Il pass pulisce le cose ottimizzando i confini della comunità. **Inglese semplice:** Avete un grafico di signature dei robot, ,, con bordi che le collegano a quelle simili.. Leiden è un algoritmo che capisce quali signature si raggruppano insieme in modo naturale., e fa un lavoro migliore degli approcci ingenui.M SK4. Invece di dire: "", questi robot sono tutti simili.",, raggruppati insieme,,", Leiden dice:"", aspettate",,, questi 50, in realtà formano un gruppo coordinato stretto,,, e quelli 30, formano una campagna separata. Perché questo conta: 1. migliore qualità della comunità rispetto alla partizione dei grafici naivi. 2. Comunità più stabili per tutti i ripartimenti. 3. Una separazione più pulita tra i prodotti dei robot e le reti di bot coordinate. 4. Etichettature più forti in aval per i flussi di lavoro delle politiche e degli operatori. Flusso di livello alto-: ```mermaid flowchart LR V[Signature feature vectors] --> G[Weighted similarity graph] G --> L[Leiden community optimization] L --> R[Refinement and reassignment] R --> C[Stable bot-network communities] C --> P[Policy signals and dashboard labels] ``` Leiden-pass pseudocode tipo: ```csharp // Pseudocode for community refinement pass var graph = BuildSimilarityGraph(signatureVectors); var communities = Leiden.DetectCommunities( graph, resolution: 1.0, seed: 42); foreach (var community in communities) { var score = ComputeCommunityBotScore(community); var temporal = ComputeTemporalDensity(community); if (score >= botThreshold && temporal >= temporalThreshold) EmitCluster(community, type: BotClusterType.BotNetwork); } ``` Questo è importante perché ti dà una campagna sostenibile-entità di livelloM SK1 non solo collegamenti rumorosi di similitude parziale. Per i dettagli attuale di applicazione della produzione, consultate: 1. [Documenti di rilevamento dei cerchi](https://github.com/scottgal/stylobot/blob/main/Mostlylucid.BotDetection/docs/cluster-detection.md) 2. [Detettori in profondità](https://github.com/scottgal/stylobot/blob/main/mostlylucid.stylobot.website/src/Stylobot.Website/Docs/detectors-in-depth.md) --- ## I nuovi attributi sono la superficie di controllo del Runtime Gli attributi del MVC forniscono l'aereo di controllo operativo: ```csharp [BotPolicy("strict")] [BotAction("challenge", FallbackAction = "block")] public IActionResult Checkout() => Ok(); [BotDetector("UserAgent,Header,Ip", BlockAction = BotBlockAction.Throttle)] public IActionResult MultiDetector() => Ok(); ``` **Cosa fanno queste cose?** Si marcano individuali punti di fine con la posizione di sicurezza di cui hanno bisogno. Il checkout potrebbe avere bisogno di una protezione stretta ( sfidare i robot sospettati , bloccarli se riesconoM SK3 non risolverloMSC4 Un'API pubblica potrebbe semplicemente sfrecciarsiMST5 Un punto di ricerca potrebbe solo controllare l'utenteMst6 Agente e HeaderM st7 Questo permette alle squadre di applicare diverse strategie di rilevamento a diversi punti di termine senza scrivere middleware personalizzatoMstr8 decoratare solo l'azioneMtr9 **[Provate diverse politiche in diretta su stylobot.net](https://stylobot.net)** - Testare il `strict`, `balanced`, e `permissive` Politiche fianco a fianco nella produzione. Vedere le latenze reali quando i cambiamenti delle politiche hanno un impatto precoceM SK1il comportamento di decommissione. --- ## Come è progettato il sito di StyloBot Il sito pubblico è anche una produzione. ```mermaid flowchart LR I[Internet] --> C[Caddy] C --> G[Stylobot.Gateway] C --> W[Website for SignalR hub route] G --> W W --> T[(TimescaleDB/PostgreSQL)] G --> T G --> O[Ollama optional] ``` **Come leggere questo:** Caddy (proxy inversoM SK1 trasmette il traffico. Qualcuno va alla Gateway (che fa tutta la rilevazione dei botMSC4 qualcuno vai direttamente al sito web (per i dati realiMST6tabli di telemetria temporaleMSM7 Entrambi possono scrivere nella base di datiMSSK8 La Gateway può usare opzionialmente Ollama | MST9|modelli AI locali | SST10 | per l'analisi avanzata | sST11 Perché questa divisione funziona: 1. Gateway impone la rilevazione prima dei percorsi dell'app. 2. Il percorso del nodo SignalR rimane stabile per la telemetria dal vivo. 3. La persistenza condivisa dà una visione operazionale unificata. --- ## Perché è importante? Questi cinque differenziatori—closedM SK1detection of loop, transitionMSC3shape modellingMS,memoria della firma temporaleMST5crossMSSK6 correlazione stratiMSP7and campaignMSV8contexto di un gruppo di livelliMSS9dispongono una risoluzione comportamentale che i sistemi standard regexMSR10+MSR11-rateMRS12-limit non possono corrispondere a MSR13 **Volete vederli in azione?** Vai a **[stylobot.net](https://stylobot.net)** e testare il rilevatore in produzione. Mettete diverse richieste e guardate quanto presto-exit va a finire in—la maggior parte delle richieste analizzate in sotto--la latenza di millisecondiM SK4 Quello ' è dove la teoria diventa la performanceMSC6 --- ## Concepti tecnici: Referenze ufficiali Se i termini tecnici precedenti sembrano nuovi, qui ci sono riferimenti canonici dalla letteratura informatica e di sicurezza del network: ### Le catene di Markov & Analyse della transizione - [Wikipedia: Chain Markov](https://en.wikipedia.org/wiki/Markov_chain) - Concepto fondamentale per " Cosa succederà dopoM SK2 Modellazione - [Stanford CS109: Hidden Markov Models](https://cs109.github.io/data-science/hmm/) - Applicato a problemi di sequenza reale-world ### Clustering grafico & Detezione comunitaria - [Paper dell'algoritmo di Leiden (Traag et al., 2019)](https://arxiv.org/abs/1810.03247) - StatoM SK1di-laMSC3la rilevazione delle comunità nell'area delle reti[Guidatore locale](https://github.com/scottgal/stylobot/blob/main/Mostlylucid.BotDetection/docs/cluster-detection.md)) - [Algoritmi di diffusione dell'etichetta](https://en.wikipedia.org/wiki/Label_propagation) - Come funziona il clustering basale di StyloBot' ### Impronte digitali per la rete & Cross-Correzione di Layer - [Impronta digitale TLS (JA3/JA≥4)](https://github.com/salesforce/ja3) - Standard industriale per la corrispondenza della firma TLS - [TCP/IP Stack Fingerprinting](https://nmap.org/book/host-discovery-techniques.html) - NmapM SK1s p0f Referenza per gli strumenti - [HTTP/2 Fingerprinting](https://www.cloudflare.com/learning/http/http2/) - Come i browser si diffondono nel comportamento HTTP/2 - [OWASP: Fingerprinting](https://owasp.org/www-community/attacks/Fingerprinting) ### Gestione dello stato temporaneo & Cache Design - [Strategie di Caching basate su TTL-](https://en.wikipedia.org/wiki/Time_to_live) - memoria confinata con l'expizione - [Cache LRU con TTL](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.caching.memorycache) - .implementazione NET di riferimento ### Analisi comportamentali & Detezione di anomalie - [Detezione di estremità in serie temporali](https://en.wikipedia.org/wiki/Anomaly_detection) - Concepti fondamentali - [OWASP: Comportamento- Limitazione basata sul tasso](https://owasp.org/www-community/attacks/Rate_Limiting) - Quando e perché i limiti statici falliscono ### LLM-Driven Bots & Dataset Poisoning - [Il veleno dei dati contro i modelli di apprendimento automatico](https://arxiv.org/abs/1811.03728) - Perché gli smascheratori puntano ai vostri dati? - [Extrazione di dati della formazione LLM](https://arxiv.org/abs/2302.07933) - Perché i bot vogliono il vostro contenuto --- ## Read More (Deep Technical Docs) Questo post è l'esempio narrativo. Il dettaglio completo è nei docs: 1. [Repo principale README](https://github.com/scottgal/stylobot/blob/main/README.md) 2. [Referenza all'API di BotDetection](https://github.com/scottgal/stylobot/blob/main/Mostlylucid.BotDetection/docs/api-reference.md) 3. [Come funziona il StyloBot](https://github.com/scottgal/stylobot/blob/main/mostlylucid.stylobot.website/src/Stylobot.Website/Docs/how-stylobot-works.md) 4. [Detettori in profondità](https://github.com/scottgal/stylobot/blob/main/mostlylucid.stylobot.website/src/Stylobot.Website/Docs/detectors-in-depth.md) 5. [L'API dei dati di formazione](https://github.com/scottgal/stylobot/blob/main/Mostlylucid.BotDetection/docs/training-data-api.md) 6. [Detezione dei cerchi](https://github.com/scottgal/stylobot/blob/main/Mostlylucid.BotDetection/docs/cluster-detection.md) --- ## Parte 3 Parte 3 coprerà l'innalzamento della produzione: sogliaiM SK2 falsi - controllo positivoM Sk4 driftM sk5 e strategia di lancioMdk6