I Combattenti stanno per iniziare a usare l'IA per imitare gli utenti reali - quindi ho costruito un rilevatore di robot che impara , si adatta

Concepto chiave: Conduttura comportamentale. Questo permette di creare una nuova categoria - dove i rilevatori e i sistemi di apprendimento , regolabili "teams" guidano il traffico riflessivo basandosi su modelli di comportamento imparatiMSC4 non regole staticheM SK5 Con la Gateway YARP, i bot non raggiungono mai la vostra backend. O usate il middleware per costruire un percorso comportamentale direttamente nella vostra strata di appM SK2

Perché esiste?

La rilevazione dei bot è diventata uno dei problemi più difficili dell'ingegneria web moderna.

Non perché i robot siano diventati più intelligenti - ma perché L'IA ha reso banale imitare il vero comportamento degli utenti.:

• Proxy residentiali in rotazione
• Impronte digitali del browser perfettamente valide.
• movimento realistico del mouse
• L'esecuzione di JavaScript
• L'adattamento quando bloccato

Le soluzioni commerciali lo risolvono, ma sono costose. Il mese è tipico.

Volevo qualcosa di diverso:

• Apertura
• Locale
• Capibile.
• Facile a estendere.
• Cheap to run (yes, anche su un Raspberry PiM SK2

Quindi ho costruito mostlylucid.botdetection - un motore modulare, di rilevamento dei robot dell'apprendimento per .NETM SK3

Cominciò con il semplice… e poi è diventato qualcosa di molto più interessante.

Un esempio concreto (Cos'ha veramente catturato?

Qui ’è un vero scenario -il mondo :

Scropper spoofs:

User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120

Sembra legittimo.

Ma è così. Si dimentica. un titolo Chrome manda sempre:

Sec-Fetch-Mode

E il suo Accept-Language il titolo non’non corrisponde alla localizzazione pretendeta.

E il tasso di richiesta è chiaramente automatizzato.

Un segnale è buono. Due è sospettosoM SK1 Tre è un modello.

Il sistema lo indica sotto 100 millisecondi - non c'è bisogno di intelligenza artificiale

Questo è il fondamento dell'intero progetto: Non dipendere da un grande modello.

La filosofia del sistema

In fondo, questo progetto non riguarda il rilevamento dei robot, ma il trattare il traffico come un sistema vivente piuttosto che un flusso di richieste isolate.

I moderni spazzaturatori si comportano più come organismi adattativi: imparano, mutareM SK2 rilevare le debolezze , e reagire alla pressioneMSC4 Quindi la difesa deve evolversi ancheMST5

La filosofia qui è semplice: osservare i segnaliM SK1 li combinare , lasciarli interagire, e adattarsi nel tempoMSC4 Invece di un singolo MST5botMSL6nonMSSK7bot\MST8 controllareMS, il motore diventa una rete di piccoli rilevatoriMSP10 ognuno contribuisce alla creazione di prove in una lavagna comuneMSV11 dove possono emergere comportamenti più altiMSS12 ordini di ordineMSR13 Le politiche diventano flussi composibiliMRS14 non difficiliM SS15 regole codificateSSS16 La reputazione si sposta gradualmente invece di cambiare statiMRSS17 L'IA è solo un altro contribuitoreMSNS18 non un monolitoMISS19

Il sistema è costruito per essere trasparente, spiegabileM SK1 estendibile, e auto-elaborabile - correttivoMST4 con l'obiettivo a lungo termineMSSK5 di comportarsi meno come una firewall e più come un sistema immunitarioMSM6 veloce al limiteMSV7 intelligente nel nucleoM SV8 e sempre ad imparareM Sv9

Come funziona (La breve versione)

Le richieste passano attraverso diversi piccoli rilevatori, ognuno contribuisce a un piccolo pezzo di prove.

Pensate a questo come ad un posto di controllo per la sicurezza dell'aeroporto.

flowchart TB
    subgraph Request["Incoming Request"]
        R[HTTP Request]
    end

    subgraph FastPath["Fast Path (< 100ms)"]
        UA[User-Agent Check]
        HD[Header Analysis]
        IP[Datacenter IP Lookup]
        RT[Rate Anomalies]
        HE[Heuristic Model]
    end

    subgraph SlowPath["Slow Path (Async Learning)"]
        LLM[LLM Reasoning]
        Learn[Weight Learning]
    end

    subgraph Output["Decision"]
        Score[Risk Score 0-1]
        Action[Allow / Throttle / Block]
    end

    R --> UA & HD & IP & RT
    UA & HD & IP & RT --> HE
    HE --> Score --> Action

    HE -.-> LLM -.-> Learn
    Learn -.->|updates weights| HE

    style FastPath stroke:#10b981,stroke-width:2px
    style SlowPath stroke:#6366f1,stroke-width:2px
    style Output stroke:#f59e0b,stroke-width:2px

Il percorso veloce (< 100ms)

Funziona sincronicamente. Non funzionaM SK1 non rallenta la vostra app.

• Pattern di bot conosciuti
• Header mancanti veri browser che mandano sempre
• IP del centro di dati (AWS/AzureM SK2GCP )
• I picchi di tasso
• Inconsistenze tra i titoli UA +

Questo cattura. 80% di bot immediatamente.

Via lenta (Async)

Funziona nel background.

• Modello heuristico con pesci imparati
• Il ragionamento LLM attraverso Ollama
• aggiornare la reputazione del modello
• Dimenticare segnali stalli.

Questo cattura i robot adattativi - quelli che la maggior parte delle persone usa. Pensare. Stanno pescando con "regex sull'User

Provate in 10 secondi

dotnet add package Mostlylucid.BotDetection

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddBotDetection();

var app = builder.Build();
app.UseBotDetection();
app.Run();

Quello’è questo. Tutto funziona fuori dagli schemi .

Cosa rileva (In un'occhiata)

La consistenza è la funzione sleeper - i bot moderni possono imitare. Uno. Signale ma di solito fallisce al croiso-coerenza del segnale.

Un risultato reale di rilevamento (Broken DownM SK1

Qui ' è come appare una rilevazione reale - viene dalla dimostrazione che fa funzionare il fastpath politica ( tutti i rilevatori in paralleloM SK1 nella produzione, la maggior parte delle richieste esce presto dopo che 2-3 i rilevanti sono d'accordoMSC4

Summary

{
  "policy": "fastpath",
  "isBot": false,
  "isHuman": true,
  "humanProbability": 0.8,
  "botProbability": 0.2,
  "confidence": 0.76,
  "riskBand": "Low",
  "recommendedAction": { "action": "Allow", "reason": "Low risk (probability: 20%)" },
  "processingTimeMs": 50.7,
  "detectorsRan": ["UserAgent", "Ip", "Header", "ClientSide", "Behavioral", "Heuristic", "VersionAge", "Inconsistency"],
  "detectorCount": 8,
  "earlyExit": false
}

I rilevatori 8 funzionavano in 51ms. - che ' l'esecuzione parallela attraverso diverse fonti di prove.

Contribuzioni del rilevatore

Ogni rilevatore contribuisce ad un impatto ponderato. negativo = segnale umanoM SK2 positivo = segnali robotMSC4

L'informazione figura nella parte dispositiva. Detttore euristico domina qui - è ' ha un peso ≥2x e ha usato 16 caratteristiche per raggiungere M88% la fiducia umana R.

I segnali raccolti

Ogni rilevatore emette segnali che entrano nel modello heuristico:

{
  "ua.is_bot": false,
  "ua.raw": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36...",
  "ip.is_local": true,
  "ip.address": "::1",
  "header.has_accept_language": true,
  "header.has_accept_encoding": true,
  "header.count": 16,
  "fingerprint.integrity_score": 1,
  "behavioral.anomaly": false,
  "heuristic.prediction": "human",
  "heuristic.confidence": 0.77,
  "versionage.analyzed": true
}

Questi segnali persistono e formano il sistema di apprendimento nel tempo.

Ripartimento delle categorie

Sconti aggregati per categorie per la decisione finale:

Totale punteggio ponderato: -2.11 → Signale umano forte → AllowM SK2

Nota: Questo è il demo '. fastpath Una politica che funziona. Tutti. Detettori per la visibilità. Nella produzione reale con l'exit anticipato attivato, altoM SK2 richieste di fiducia si spegneno solo dopo MSC3 i rilevatori sono d'accordo - tipicamente sotto 10ms. Il 51ms qui è dovuto al fatto che il modo di dimostrazione blocca l'uscita rapida per mostrare tutte le contributi.

Pipeline completo (Modo di dimostrazione con LLM)

Per il confronto, qui's la demo politica - il tubo completo, compreso il ragionamento LLM. Questo mostra cosa succede quando i rilevatori Non sono d'accordo.:

{
  "policy": "demo",
  "isBot": false,
  "isHuman": true,
  "humanProbability": 0.87,
  "botProbability": 0.13,
  "confidence": 1.0,
  "botType": "Scraper",
  "riskBand": "Low",
  "recommendedAction": { "action": "Allow", "reason": "Low risk (probability: 13%)" },
  "processingTimeMs": 1370,
  "aiRan": true,
  "detectorsRan": ["UserAgent", "Ip", "Header", "ClientSide", "Behavioral",
                   "VersionAge", "Inconsistency", "Heuristic", "HeuristicLate", "Llm"],
  "detectorCount": 10
}

10 rilevatori in 1.4 secondi - l'LLM è andata avanti. Non sono d'accordo. con l'euristica.

Questo è il caso interessante - LLM l'ha etichettata come un potenziale robot. mentre tutti i rilevatori statici dicevano umano.

{
  "ai.prediction": "bot",
  "ai.confidence": 0.85,
  "ai.learned_pattern": "Browser string suggests Chrome, common in bots. Presence of cookies and a specific referer also points to a potential bot."
}

Il ragionamento del LLM' viene registrato come un segnale che ritorna al sistema di apprendimento. Nel tempoM SK2 se questo schema continua a comparire e viene confermato come traffico di robotMSC3 i pesci heuristici si adattanoMska4

Aviso:

1. Correzioni euritiche due volte. - all'inizio ( prima di tutti i rilevatori ) e tardi S( dopo tutte le prove ). Entrambi hanno detto SSK5 umano SSK6 con ESM7 fiducia ESM8

2. LLM non è d'accordo. - ha individuato schemi che i rilevatori statici non hanno rilevatoM SK1 Il suo +2.13 impatto ponderato sostanzialmente corrisponde all'eurismo's

3. Senza impronte digitali. - ClientSide ha risposto 0 perché JS non aveva ancora ejecutato '. In un browser realeM SK4 questo aggiungerebbe più segnali umaniMSC5

4. Verdetto finale: Permettete - anche con la sospettazione del LLMM SK1, l'evidenza combinata è ancora in favore dell'uomo. botType: "Scraper" La bandiera significa che è stato osservato.

La classifica delle categorie mostra la tensione:

Totale punteggio ponderato: -1.86 → L'uomo vince, ma il dissenso del LLMM SK2 è notato .

Percezione chiave: Il sistema non si fida blindamente di nessun singolo rilevatore. Quando non sono d'accordo, le prove vengono weightate e la maggioranza vince. Ma le opinioni delle minoranze vengono registrate per l'apprendimento.

Importante: Questo output verbose è demo-only. In produzione , si ottiene una risposta bassa tramite i titoli HTTP M SK3X-Bot-Confidence, X-Bot-RiskBand, etcM SK1 o un semplice context.IsBot() Check. Il JSON completo è per debuggere e regolare - non lo spedi mai ai clienti

Usando i risultati

if (context.IsBot())
    return Results.StatusCode(403);

var score = context.GetBotConfidence();  // 0.0–1.0
var risk  = context.GetRiskBand();       // Low/Elevated/Medium/High

Proteggere i punti finali

app.MapGet("/api/data", Secret).BlockBots();
app.MapGet("/sitemap.xml", Sitemap)
   .BlockBots(allowVerifiedBots: true);

I livelli di rischio guidano l'azione:

Detezione AI (Opzionale)

Non è necessario - ma utile per catturare automatizzazione avanzata.

Detettore euristico (FastM SK1Learning)

Il sistema include un rilevatore heuristico che usa la regressione logistica con pesci dynamicamente imparati. Comincia con dei predefinimenti sensibili e si evolve basando su feedback di rilevamento.

La latenza tipica: 1–5ms

{
  "BotDetection": {
    "AiDetection": {
      "Heuristic": {
        "Enabled": true,
        "LoadLearnedWeights": true,
        "EnableWeightLearning": true
      }
    }
  }
}

Le caratteristiche vengono estratte dinamicamente - i nuovi schemi ricevono automaticamente il peso di default e imparano nel tempoM SK1 Il sistema scopre cosa conta per il vostro. traffic.

Ollama LLM (Deep Reasoning)

Cattura robot evasivi che sembrano "fine" con regole velociM SK2 Usazioni Ollama per l'inferenza locale LLM.

ollama pull gemma3:1b

{
  "BotDetection": {
    "AiDetection": {
      "Provider": "Ollama",
      "Ollama": { "Model": "gemma3:1b" }
    }
  }
}

L'IA è fallire-sicura - se ' scendeM SK2 la detezione continua normalmente.

Il sistema di apprendimento: Adaptivo, Non stimolanteM SK2felici

Le liste di blocchi statici sono inesistente. Gli attacchi si adattano. Quindi questo sistema impara.

flowchart LR
    N[Neutral] -->|repeated bad activity| S[Suspect]
    S -->|confirmed| B[Blocked]
    B -->|no activity| S
    S -->|stays clean| N

    style B stroke:#ef4444,stroke-width:2px
    style S stroke:#eab308,stroke-width:2px
    style N stroke:#10b981,stroke-width:2px

I modelli si decadono nel tempo:

• Le IP vengono riassignate.
• I script malconfigurati vengono corretti.
• Il traffico cambia naturalmente.

Senza decadere voi’d bloccare gli utenti legittimi per sempre.

{
  "BotDetection": {
    "Learning": {
      "Enabled": true,
      "ScoreDecayTauHours": 168,
      "GcEligibleDays": 90
    }
  }
}

YARP Gateway: Edge Protection for Your App

C'è anche un MSK. Docker- primo proxy YARP inverso che conduce la rilevazione. prima. le richieste colpiscono la vostra app.

flowchart LR
    I[Internet] --> G[YARP Gateway]
    G -->|Human| App[Your App]
    G -->|Search Engine Bot| App
    G -->|Malicious| Block[403]

Lo fate in una sola linea:

docker run -p 80:8080 \
  -e DEFAULT_UPSTREAM=http://your-app:3000 \
  scottgal/mostlylucid.yarpgateway

Works on:

• Linux
• MacOS
• Windows
• ARM (yesM SK1 Raspberry Pi)

Per routing personalizzato:

services:
  gateway:
    image: scottgal/mostlylucid.yarpgateway
    volumes:
      - ./yarp.json:/app/config/yarp.json

Un sistema di produzione ragionevole

{
  "BotDetection": {
    "BotThreshold": 0.7,
    "BlockDetectedBots": true,
    "EnableAiDetection": true,
    "Learning": { "Enabled": true },
    "PathPolicies": {
      "/api/login": "strict",
      "/sitemap.xml": "allowVerifiedBots"
    }
  }
}

Dove sta andando?

Questa è la parte 1 (la panoramica). Le parti successive scavano più a fondo:

• Parte 2: Nuovi interni, memoria di firmaM SK1 cicli di risposta di feedback , e architettura dello StyloBot (codificatoMST4 livelloMst5
• Parte 3: Analitica del comportamento
• Parte 4: Client-Side fingerprinting
• Parte 5: Il rilevatore heuristico - pesa l'apprendimento in tempo reale
• Parte 6: Interna dell'identificazione LLM
• Parte 7: Il sistema di apprendimento è spiegato correttamente

Mappa stradale futura:

• Un modello basato su RAG- che corrisponde alle inserzioni vettoriali.
• Locale piccola deduzione del modello attraverso LlamaSharp / ONNX
• Semantica somiglianza per rilevare nuovi schemi di attacchi

Se volete un rilevatore di bot potete Capire., espandere., e andare ovunque., questa serie è per voi

Link

• GitHub: Documenti completi https://githubMSC1com/scottgalM SK3mostlylucidMスク4nugetpackages
• NuGet: installare il pacchetto. https://www .nuget.orgM SK3packagesMST4mostlylucidMSC5botdetection
• Docker Hub: La porta YARP https://hubMSC1docker.comM SK3rMST4scottgalMS/mostlylucidMSSK6yarpgateway

Non licenziare – dominio pubblico. Usarlo come voleteM SK2