# **mest uppenbart.botdetectionM SK1 Bekämpning mot schackare (Teg 1)**

*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](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway), Boter når aldrig din baksida . Eller använda mellanvaran för att bygga beteendetsriktning direkt in i din app-skikt

<pinned/>
<!--category-- ASP.NET, Bot Detection, Security -->
<datetime class="hidden">2025-12-08T07:00</datetime>

[![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/mostlylucid.nugetpackages?style=social)](https://github.com/scottgal/mostlylucid.nugetpackages/blob/main/Mostlylucid.BotDetection/README.md)
[![Docker](https://img.shields.io/docker/pulls/scottgal/mostlylucid.yarpgateway)](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway)

---


## **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.

---


[TOC]

---


## **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

```mermaid
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](https://ollama.com/)
* 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**

```bash
dotnet add package Mostlylucid.BotDetection
```

```csharp
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**

| Kolla | Vad det hittar |
| --------------- | ------------------------------------------------- |
| **User-Agent** |kända robotar, bibliotekM SK2 skrapare |
| **Påskriftar** | Missande säkerhetskolor , otänkbara kombinationer |
| **IP** | molnadministratörer som låtsas vara | “ | hemanvändare
| **Takt** | Automatisk sprängning, fördelad slitning |
| **Konsistens** | “Chrome/120” utan Chrome

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

```json
{
  "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.

| Detektor | | | Inverkan | МSK2 | Gewicht || | Weighted |
|----------|--------|--------|----------|--------|
| **UserAgent** | -0.20 ♫ ♫ | ♫
| **Påskrift** | ♫ -0.15 ♫ ♫
| **Vanor** | ♫ -0.10 ♫ ♫
| **Heuristik** | -0.77 | 2.0 | **-1.54** | 88% mänskligt antaglighet
| **ClientSide** |
| **Versionsålder** | | | -0.05 |
| **Inkonsistens** | ♫ -0.05 ♫ ♫
| **IP** | 0.00 ♫ ♫ | ♫

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:

```json
{
  "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

| Kategorie | Punktzahl | | | Gewicht | МSK3 | Notar ||
|----------|-------|--------|-------|
| Heuristiskt | | | -1.54 |
| UserAgent ♫ ♫ | ♫
| Rubrik | -0.15 | | | 1.0 | МSK5 | Alla förväntade rubr finns här
| Behaviorell | ♫ ♫ -0.10 ♫
| ClientSide
| VersionAge | | | -0.04 |
| Inkonsistens | | | -0.04 |
| IP ♫ ♫ | ♫

**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**:

```json
{
  "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

| Detektor | | | Inverkan | МSK2 | Gewicht || | Weighted |
|----------|--------|--------|----------|--------|
| **LLM** | +0.85 | 2.5 | **+2.13** | "Krom vanligt i robotar, cookies | + | Referent misstänkt
| **Häuristiskt Spät** | -0.77 ♫ ♫ | ♫
| **Heuristik** (
| **UserAgent** | -0.20 ♫ ♫ | ♫
| **Påskrift** | ♫ -0.15 ♫ ♫
| **Vanor** | ♫ -0.10 ♫ ♫
| **ClientSide** | 0.00 ♫ ♫ | ♫
| **Versionsålder** | | | -0.05 |
| **Inkonsistens** | ♫ -0.05 ♫ ♫
| **IP** | 0.00 ♫ ♫ | ♫

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

```json
{
  "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

| Kategorie | Punktzahl | | | Gewicht | МSK3 | Notar ||
|----------|-------|--------|-------|
| **Heuristik** | -3.46 ♫ ♫ | ♫
| **AI** LLM säger att robotar
| UserAgent ♫ ♫ | ♫
| Rubrik | -0.15 | | 3 | 4 | 5 | Alla opskrifte närvarande
| Behaviorell | | | 2 | 3 | 4 | 5 | Normala mönster
| ClientSide
| Versionsålder | | |
| Inkonsistens | | | -0.04 |
| IP ♫ ♫ | ♫

**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**

```csharp
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

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

Risknivåerna guidar handlingen

| Risk | Förtroende | Recommender action M|
| -------- | ---------- | ------------------ |
| låga | < | | 3 | 4 | tillåt | 5
| Upphöjt | 0.3–0.5 | | | Log ♫ / ♫ Takt ♫
| Medel | | | 0.5–0.7 | SSK3 | Utmaningen
| Höga | > | | 3 | 4 | Block | 5

---


## **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**

```json
{
  "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](https://ollama.com/) för den lokala LLM-förklaringen.

```bash
ollama pull gemma3:1b
```

```json
{
  "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

```mermaid
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.

```json
{
  "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.

```mermaid
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:

```bash
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:

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

---


## **En rimlig produktionskontroll**

```json
{
  "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](/blog/post/botdetection-part2-signature-pipeline-and-stylobot-architecture)
* **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](https://github.com/SciSharp/LLamaSharp) / 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~ /~mostlylucid~M SK4~nugetpackages](https://github.com/scottgal/mostlylucid.nugetpackages)
* **NuGet:** installera paketet
  [https://www](https://www.nuget.org/packages/mostlylucid.botdetection)
* **Dockerhub:** YARP-portaal
  [https://hub](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway)

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