Skracker håller på att börja använda AI för att imitera riktiga användare. Så jag byggde en robotdetektor som lär sig, ,, anpassar sig och kämpar emot

Nyckelkoncepten: Behavioural Routing Detta gör det möjligt att skapa en ny kategori - där detektorer och lärande system som är transparenta , anpassningsbara | " | lag |" | reflektivt riktar trafiken baserat på lärda beteendemönster | , | inte statiska regler | МSK5 | med YARP Gateway, Boter når aldrig din baksida . Eller använda mellanvaran för att bygga beteendetsriktning direkt in i din app-skikt

Varför finns detta?

Bot-detektorn har blivit ett av de svåraste problemen i modern webteknik

Inte för att robotar blev smartare - utan för AI gjorde det triviellt att imitera ett verkligt användarbeteende:

• Omvänd residentiell representanter
• Perfekt korrekta fingeravtryck
• Realistiska musrörelser
• Att utföra JavaScript
• Anpassning när blockerad

kommersiella lösningar löser detta, men de är dyra. Montan är typiskt.

Jag ville ha något annorlunda.

• Öffna
• Lokala
• Förståeligt
• Lika att sträcka ut
• Günstig att köra ( ja , även på en Raspberry Pi

Så jag byggde mestlucid.botdetection - en modulär, inlärningsbot-detektor för .NET

Det började enkelt, och sedan växte det till något mycket mer intressant.

Ett konkret exempel ( Vad det här faktiskt fångar

Här är ett verkligt scenario

Ett skräpsprång

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

Ser legitima ut.

Men det glömmer en titeln Chrome skickar alltid:

Sec-Fetch-Mode

Och dess Accept-Language header matchar inte den påstående lokalen

Och begäran är tydligt automatiserad.

Ett signal är bra . Två är misstänkt M SK1 Tre är ett mönster .

Systemet flagerar den under 100 millisekundar - ingen AI krävs

Detta är grunden till hela designen inte lita på en stor modell

Systemfilosofi

I själva verket handlar det här projektet inte om att upptäcka robotar utan att behandla trafiken som ett levande system snarare än en ström av isolerade begäran.

Moderna skrapare beter sig mer som anpassningsbara organismer. de lär sig att muta. de detekterar svagheter. de reagerar på tryck. de måste utvecklas också.

Den filosofin är enkel.: observerar signaler, , kombinerar dem, , låter dem interagera och anpassa sig över tid.M SK4 istället för ett enda maskineri- -/, inte -, eller ", kontrollerar ,, motoren blir ett nätverk av små detektörer.

Systemet är konstruerat så att det är transparentt, ,, förklarabart, ,, utvinningsbart,,, och självbyggande. -, korrigerar ,, med det långsiktiga målet att bete sig mindre som en firewall, men mer som ett immunsystem.

Hur det fungerar (Skrattversionen)

begäran strömmar genom flera små detektörer , var och en bidrar med en liten del bevis.

Tänk på det som en flygplatss säkerhetskontrollpunkt

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

Fast Path (< 100ms)

Runner i synkronitet. Fungerar inte’ saktar ned din appM SK2

• Bekant robotmönster
• Missande opskrifte riktiga webblader skickar alltid
• Datacenter IPs (AWS/Azure /GCPM SK3
• Prisspikes
• Ojämlikheter mellan UA + opskrifte

Det här fångar 80% av bots omedelbart.

långsam väg (Async)

Runner i bakgrunden.

• Heuristisk modell med lärde vikter
• LLM resonemang via Ollama
• Att uppdatera mönsterrenomheten
• Att glömma döda signaler

Det fångar de anpassningsbara robotarna - som de flesta människor tänk de catchar med "regex på användaren

Försök det i 10 sekunder

dotnet add package Mostlylucid.BotDetection

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

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

Det är det. Allt fungerar ur lådan.

Vad det upptäcker ( På en titt

Konsistens är sömnmönstret - moderna robotar kan bluffa ett signal men oftast misslyckas vid korsning

Ett verkligt detektionsresultat (Broken Down

Här är "'", det är hur en riktig detektion ser ut. fastpath policy (allt detektor i parallella sträckning ). I produktionen, kommer de flesta begäran ut tidigt efter att detektörerna har kommit överens

sammanfattning

{
  "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
}

Detektorer fungerade i 51ms - att ' parallellt utförs över flera beviskällor

Detektorkollektiv

Varje detektor bidrar med en viktad inverkan.

Den Röntgendetektor dominerar här - det 's viktade 2x och använde m16 egenskaper för att nå M88% mänskligt tilltro

Signaler samlats

Varje detektor släpper ut signaler som matas in i theuristisk modellen:

{
  "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
}

Dessa signaler förblir kvar och tränar lärandesystemet över tid.

Kategorisfördelning

sammanlagda poäng per kategori för det slutgiltiga beslutet

Totala vikterade poäng: M SK1 → Den starka mänskliga signalen

Nota: Det här är demon ' fastpath politik som styr alla detektorer för synlighet. i verklig produktion med tidig utgång gjorda, högtM SK2 tillit till självförtroende utgår efter bara MSC3 detektorerna håller med - typiskt under 10ms. Den 51 ms här är för att demo-modiet avsperar tidig utgång för att visa alla bidrag

Full Pipeline (Demo-Modus med LLM

För att jämföra: demo policy - hela pipelinen inklusive LLM resonemang . Detta visar vad som händer när detektorer inte hålla med:

{
  "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
}

Detektorer i 1.4 sekunder - körde LLM och inte överens med heuristiken

Detta är det intressanta fallet - LLM flaggade det som en potentiell robot medan alla statiska detektörer sa människan

{
  "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."
}

LLMs resonemang registreras som en signal som återspeglar in i lärandesystemet.

Anmärkning:

1. Heuristiska löpningar två gånger - tidigt ( före alla detektorer ♫ ) ♫ och senare ♫ ♫ efter alla bevis ♫

2. LLM höll inte med - den såg mönster som statiska detektörerna misslyckades med

3. Ingen fingeravtryck - ClientSide gav tillbaka 0 eftersom JS inte hade Executerat ' ännu Executerad . I en riktig webblader skulle detta ge mer mänsklig signal

4. Slutsatsen: tillåt - även med LLMs misstänksamhet, ', så gynnar de kombinerade bevisen fortfarande människan. botType: "Scraper" flagga betyder att den är under observation

Kategorisfördelningen visar spänningen

Totala vikterade poäng: M SK1 → Människor vinner, , men LLMs motsättningar är noterade.

Nyckelinsikten: Systemet inte litar blindt på en enda spårare. När de inte håller med om det, så är beviset viktade och majoriteten vinner. Men opinionsen från minoriteterna registreras för att lära sig.

viktigt: Den här verbosa utgången är demo- endast . I produktionen får du en smal respons via HTTP-kolor (X-Bot-Confidence, X-Bot-RiskBand, etc .) eller en enkel context.IsBot() check. Den fulla JSON är till att avbugera och tända - du ' aldrig skicka det här till klienter

Genom att använda resultaten

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

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

Att skydda slutpunkter

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

Risknivåerna guidar handlingen

AI-detektor (Optionell)

Inte nödvändigt - men användbart för att fånga avancerad automatiseringM SK1

Häuristisk detektor (

Systemet består av en heuristisk detektor som använder logiskt regression med dynamiskt lärda vikter. Det börjar med vettiga standard och utvecklas baserat på detektionsfeedback

Typisk latens: 1–5ms

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

Funktioner extraheras dynamiskt - nya mönster får automatiskt standardvikt och lär sig över tidM SK1 Systemet upptäcker vad som är viktigt din trafik.

Ollama LLM (Djupen resonemang

Han fångar flytande robotar som ser ut som "fineM SK1 med snabba regler . Användar Ollama för den lokala LLM-förklaringen.

ollama pull gemma3:1b

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

AI är fel-säkra - om det

Lärningssystemet

Statiska blocklistar går i dödläge. Attacker anpassar sig. Så det här systemet lär sig

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

Pattern förrutsnar över tid:

• IPs blir omskiljade
• Misskonfigurerade skript blir fixade
• Trafiken förändras naturligt

Utan förödelse blockerar du legitima användare för alltid.

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

YARP Gateway: Edge Protection for Your App

Det finns också ett Docker-first YARP bakvända proxy som löser detektorn före begäran träffar din app.

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

kör den i en linje:

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

Werk på:

• Linux
• macOS
• Windows
• ARM ( ja , Raspberry PiM SK2

För anpassad routing:

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

En rimlig produktionskontroll

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

Vart det här kommer

Det här är en del 1 | ( | översikten De kommande delar gräver djupare:

• Del 2: Nya insidan, handskriftsminnet , reaktionsfeedback-looparM SK2 och StyloBots arkitektur (kodMska4nivåMka5
• Del 3: beteendeanalys
• Del 4: Client - fingeravtryck på sidan
• Del 5: Det heuristiska detektorn - lär vikter i realtid
• Del 6: LLM-detektionsinterner
• Del 7: Lärningssystemet förklarades ordentligt

Framtidens plan

• RAG-baserade mönster som matchar vektorbäddar
• Lokala små modellförklaringar via Llamascharp / ONNX
• Semantisk likhet för att upptäcka nya attacksmönster

Om du vill ha en robotdetektor så kan du förstå, förlänga, och springa var som helst, den här serien är till er

Links

• GitHub: fulla dokument https://_github._com/_scottgal /_mostlylucidM SK4~nugetpackages
• NuGet: installera paketet https://www
• Dockerhub: YARP-portaal https://hub

Utanlicenser – offentlig domain . Använd det som du vill