# **Meest duidelijk.botdetection: Terugvechten tegen Schrappers M SK2Part 1)**

*Schrappers beginnen nu AI te gebruiken om echte gebruikers na te bootsen, dus ik bouwde een bot-detektor die leert, , aanpast en , terugvecht.*

**Sleutelconcept: Gedragsrouten.** Dit maakt een nieuwe categorie - mogelijk, waarin transparante , aanpasbare МSK2teams " van detectoren en lerende systemen reflexief het verkeer routeren op basis van leren gedragspatronen M SK4 geen statische regels [YARP-Gateway](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway), bots bereiken je backend nooit. Of gebruik de middleware om gedragsroutes rechtstreeks in je applaag te bouwenM SK2

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

---


## **Waarom dit bestaat?**

Bot-detectie is rustig een van de moeilijkste problemen in het moderne webontwerp geworden.

Niet omdat robots slimmer werden - maar omdat **AI maakte het triviaal om echt gebruikergedrag na te bootsen.**:

* Roterende huisvestingsbediener
* Volkomen geldige browser vingerafdrukken
* Realistische muisbeweging
* JavaScript uitvoeren
* Aanpast wanneer geblokkeerd

Commerciële oplossingen kunnen dit oplossen, maar ze zijn duur.

Ik wilde iets anders.

* Open
* Plaaselijk
* Begrijpelijk
* Makkelijk te verlengen.
* Goed te doen (ja, zelfs op een Raspberry PiM SK2

Dus bouwde ik. **Meest duidelijk.botdetektie** - een modulaire, leerbot-detectiemachine voor .NETM SK3

Het begon simpel, en groeide toen op tot iets veel interessanter.

---


[TOC]

---


## **Een concrete voorbeeld (Wat dit eigenlijk bereikt)**

Hier is het echte scenario.

Een schrapperspoofs:

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

Ziet legitiem uit.

Maar het *Vergeet.* Chrome stuurt altijd een opskrif:

```
Sec-Fetch-Mode
```

En zijn `Accept-Language` header doesn’ niet overeenstemt met de beweerde locale.

En het verzoektempo is duidelijk automatiseerd.

**Eén signaal is goed. Twee is vermoedelijk . Drie is een patroon.**

Het systeem vlaggt het in onder 100 milliseconden - geen AI nodig

Dit is de basis van het hele ontwerp.
**don’ niet vertrouwen op één groot model “boot of niet ”model**

---


## Philosophie van het systeem

In zijn kern gaat dit project niet echt over bot-detectie, maar over het behandelen van het verkeer als een levend systeem in plaats van een stroom van geïsoleerde verzoeken.

Moderne schrappers gedragen zich meer als adaptieve organismen.

De filosofie hier is simpel: observeren signalen , combineren ze, , laten ze interageren,, en aanpassen over de tijd,. In plaats van een enkele "bot,MSC6 niet,M SK7bot en " controleren,MST9 wordt het motor een netwerk van kleine detectoren,MSP10 elke bijdragende bewijs in een gedeelde blackboard,MSV11 waar hogere gedragingen kunnen ontstaan,MSS13 Politieken worden samenstelbare stromen, MSS14, niet moeilijk,M SS15, gecodeerde regels, M SS16, Reputatie verschuift geleidelijk, in plaats van omvalsstaten,MS17 AI is slechts één andere bijdrager,MISS18, geen monolith,MSSA19

Het systeem is gebouwd om transparant te zijn.

---


## **Hoe het werkt (De korte versie)**

Versoeken stromen door verschillende kleine detectoren, elk een klein stukje bewijs bijdraagt

Beschouw het als een luchthavensveiligheidscontrolepunt.

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

Loopt synchroon. Doet het niet’Vertraag je appM SK2

* Kenne botpatronen
* Missing headers echte browsers sturen altijd
* Datacenter IPs (AWS /Azure/GCPM SK3
* Tempo pieken
* Inconsistenties tussen UA-headers +

Dit valt. **80%** van bots onmiddellijk.

### **Langzaam pad (Async)**

Loopt in de achtergrond.

* Heuristische model met leren gewichten
* LLM-argumentatie via [Ollama](https://ollama.com/)
* Opdateer patroon reputatie
* Stadige signalen vergeten

Dit gevangen de adaptieve robots -, die de meeste mensen vangen. *denken.* Ze'vangen met "regex op de gebruikerM SK2Agent ".

---


## **Probeer het in 10 seconden**

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

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

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

Dat is het. Alles werkt vanuit de doos.

---


## **Wat het detecteert (Op een ogenblik)**

| Bevestig | Wat het vindt |
| --------------- | ------------------------------------------------- |
| **Gebruiker-Agent** | bekende robots, bibliothekenM SK2 scrapers |
| **Opskriftes** | Missing security headers, onmogelijke combinaties |
| **IP** | Wolkenhosts die doen alsof ze 'home users' zijn.
| **Tempo** | Automatiseringsbuisjes, verspreide schrapping |
| **Konsistentie** |

Consistentie is de slaapfunctie - moderne robots kunnen spoofen. *Eén.* Signal, maar meestal mislukt bij kruising-signalecoherentie.

---


## **Een echte detectie resultaat (Broken Down)**

Hier zie je hoe een echte detectie eruit ziet. `fastpath` Politiek (alle detectoren in parallelle volgorde). In de productieM SK2 gaan de meeste verzoeken vroeg uit nadat slechts 2-3 detectoren het met elkaar eens zijnMSC4

### Opsomming

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

**8 detectoren draaiden in 51ms.** - dat'parallele uitvoering over meerdere bewijsbronnen

### Detector bijdragen

Elk detector draagt bij aan een gewaarwordde impact. Negatief = menselijk signaalM SK2 Positief ≥= botsignaal .

| Detector | | | Impact || | Weight | | | Gewaardeerd || | Rede | МSK5
|----------|--------|--------|----------|--------|
| **UserAgent** | -0.20 ♫ ♫ | ♫
| **Opskrif** | -0.15 ♫ ♫ | ♫
| **Gedrag** | -0.10 ♫ ♫
| **Heuristische** | -0.77 | 2.0 | **-1.54** | 88% menselijke waarschijnlijkheid.
| **Kliëntzijde** | -0.05 ♫ ♫ | ♫
| **VersionAge** | -0.05 ♫ ♫ | | ♫
| **Inconsistentie** | -0.05 ♫ ♫ | ♫
| **IP** | 0.00 ♫ ♫ | ♫

De gemeenschappelijke wetgeving van het land. **Heuristische detector** Het domineert hier - het' heeft een gewicht van 2x en gebruikte 16 eigenschappen om te bereiken.

### Signalen verzameld

Elk detector geeft signalen die in het hiuristische model terechtkomen:

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

Deze signalen blijven bestaan en trainen het leersysteem door de tijd heen.

### Kategorieverdeling

Geaggregate cijfers per categorie voor de uiteindelijke beslissing:

| Kategorie | Telling | Gewig | Notas SMK4
|----------|-------|--------|-------|
| Heuristische | -1.54 | | |
| Gebruikeragent | -0.20 | | | ♫ ♫ 1.0 \ | Normale browser UA ♫
| Opskrif | -0.15 | | |
| Gedragsmatig | -0.10 | | |
| Kliëntzijde | | | -0.04 |
| VersionAge | -0.04 | | |
| Inconsistentie | -0.04 | | |
| IP ≥| 0.00 ♫

**Totaal getogene score: -2.11** → Een sterk menselijk signaal → Toelaat.

> **Nota:** Dit is de demo. `fastpath` Een beleid dat werkt **Allemaal** detectoren voor zichtbaarheid. In de echte productie met vroege uitloop mogelijk, hogeM SK2betrouwen verzoeken uitgaan na slechts MSC3 detectoren overeenkomen - typisch **onder 10ms**. De 51ms hier is omdat de demo-modus vroege uitgang niet mogelijk maakt om alle bijdragen te laten zien.

### Volgrote pijpleiding (Demo-modus met LLM)

Voor vergelijking, hier' is de `demo` Politiek - de complete pijpleiding met LLM-argumentatie. Dit toont wat er gebeurt als detectoren **We zijn het er niet over eens.**:

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

**10 detectoren in 1.4 seconden** - loopde de LLM. *niet eens.* Met de heuristiek.

| Detector | | | Impact || | Weight | | | Gewaardeerd || | Rede | МSK5
|----------|--------|--------|----------|--------|
| **LLM** | +0.85 | 2.5 | **+2.13** |
| **HeuristischesLater** |  -0.77
| **Heuristische** (early) | | | -0.77 |
| **UserAgent** | -0.20 ♫ ♫ | ♫
| **Opskrif** | -0.15 ♫ ♫ | ♫
| **Gedrag** | -0.10 ♫ ♫
| **Kliëntzijde** Geen vingerafdruk (wacht JS
| **VersionAge** | -0.05 ♫ ♫ | | ♫
| **Inconsistentie** | -0.05 ♫ ♫ | ♫
| **IP** | 0.00 ♫ ♫ | ♫

Dit is het interessante geval - **De LLM noemde het een potentieel bot.** Alle statische detectoren zeiden menselijk.

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

De redenering van de LLM, ', wordt opgenomen als een signaal dat terugvoert naar het leersysteem.

Nota:

1. **Heuristische rennen twee keer.** - vroeg, ( voor alle detectoren en later 'M SK3' na alle bewijzen). Ze zeiden beiden: 'MST5' menselijk, MST6' met 'M ST7' vertrouwen, M ST8'

2. **LLM is het niet eens.** - het zag patronen die de statische detectoren mislaten. Het gewichtige impact van +2.13 is gedeeltelijk tegengesteld aan de heuristischen.

3. **Geen vingerafdruk.** - ClientSide keerde terug 0 omdat JS nog niet uitvoerd had '. In een echte browser zou dit meer menselijke signalen toevoegen.

4. **Finale beslissing: Toelaat** - zelfs met de vermoeden van de LLM' , zijn de gecombineerde bewijzen nog steeds in voordeel voor mensen. `botType: "Scraper"` Vlag betekent dat het wordt bekeken.

De categorieënverdeling toont de spanning:

| Kategorie | Telling | Gewig | Notas SMK4
|----------|-------|--------|-------|
| **Heuristische** | -3.46 ♫ ♫ | ♫
| **AI** LLM zegt bot |
| Gebruikeragent | -0.20 | | | ♫ ♫
| Opskrif | -0.15 | | |
| Gedragsmatig | -0.10 | | |
| Kliëntzijde | 0.00 | | | ♫ ♫ 1.8 \ | Fingerprint nog niet ♫
| Verbindingstijd | -0.04 | | |
| Inconsistentie | -0.04 | | |
| IP ≥| 0.00 ≤| ≥ 0.5 ±| Plaaselijke bediener

**Totaal getogene score: -1.86** → Mensen winnen, , maar het tegendeel van de LLM is gemerkt.

> **Key insight:** Het systeem trouwt niet blind aan één enkele detector. Als ze het niet eens zijn, wordt het bewijs getogen en de meerderheid wint. Maar minderheidsbetuigingen worden opgenomen voor het leren.

> **Belangrijk:** Deze verbose output is demo-only. In de productieMSC2 krijg je een slim antwoord via HTTP-headers M SK3`X-Bot-Confidence`, `X-Bot-RiskBand`, etc.) of een eenvoudige `context.IsBot()` check. De volle JSON is voor ontfouting en aanpassing - jeM SK2 stuur dit nooit naar de klanten .

---


## **Met de 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
```

### Beschermen van eindpunten

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

risiconiveaus bepalen de actie:

| Risico | Betrouwen | Voorgestelde acties |
| -------- | ---------- | ------------------ |
| Sagte | < ♫ ♫ 0.3 ♫
| Geëleveerd  |
| Gemiddeld | 0.5–0.7 | De uitdaging S|
| Hoë | > ♫ ♫ 0.7 ♫

---


## **AI-detectie (Opsionele)**

Niet nodig - maar nuttig voor het opvangen van geavanceerde automatisering.

### **Heuristische detector (FastM SK1Leerzaamheid)**

Het systeem bevat een heuristische detector die logistische regresie gebruikt met dynamisch geleerd gewichten. Het begint met gevoelige standaardwaarden en ontwikkelt zich op basis van detection feedback.

Typische latentie: **1–5ms**

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

Funkties worden dynamisch geextrahereerd - nieuwe patronen krijgen automatisch standaardgewicht en leren over de tijd. Het systeem ontdekt wat ertoe doet. *Je hebt het gevoel dat je je eigen creativiteit zou moeten verbeteren.* Verkeer.

### **Ollama LLM (Deep redeneren)**

Catches evasieve robots die eruitzien als "fine" met snelle regels [Ollama](https://ollama.com/) voor lokale LLM-inderving.

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

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

AI is **fail-safe** - als het gaande is' , de detectie blijft doorgaan.

---


## **Het leersysteem: Aanpasbaar, Niet stimulerendM SK2Gelukkig**

Statische blocklists gaan staaf. Attackers passen zich aan.
Dus dit systeem leert ..

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

Patronen vervalsen met de tijd:

* IP's worden opnieuw toegewezen.
* Misconfigureerde scripts worden opgelost.
* Het verkeer verandert natuurlijk.

Zonder verval blokkeren jullie voorgoed legitieme gebruikers.

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

---


## **YARP Gateway: Randbescherming voor je app**

Er is ook een ’. **Docker-eerste YARP omgekeerde proxy** Die de detectie uitvoert. *Voorheen* requests slaan op je app.

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

Loop het in één lijn:

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

Werken op:

* Linux
* MacOS
* Windows
* **ARM (ja , Raspberry Pi)**

Voor custom routing:

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

---


## **Een redelijke productie-instelling**

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

---


## **Waar dit heengaat**

Dit is deel 1 (de Übersicht).
De volgende onderdelen graven dieper:

* **Deel 2**: [Nieuwe internes, handtekeningsgeheue, reactiefeedback-loops , en StyloBot architectuur MSC3codeM SK4niveauMST5](/blog/post/botdetection-part2-signature-pipeline-and-stylobot-architecture)
* **Deel 3**: Gedragsanalyse
* **Deel 4**: Kliënt
* **Deel 5**: De hiuristische detector - leergewichten in realiteit
* **Deel 6**: LLM-detectie internen
* **Deel 7**: Het leersysteem werd goed verklaard

**Routenkaart voor de toekomst:**

* RAG-gebaseerd patroon passend aan vektorembeddings
* Lokale kleine modelhersening via [LlamaSharp](https://github.com/SciSharp/LLamaSharp) / ONNX
* Semantische gelijkenis voor het detecteren van nieuwe aanvalspatronen.

Als je een bot-detektor wilt, kan je dat ook doen. *begrijpen.*, *Verleng*, en *Overal lopen.*, deze reeks is voor jou

---


## **Links**

* **GitHub:** volle documenten
  [https://githubM SK1com/scottgalMSC3mostlylucidMスク4nugetpackages](https://github.com/scottgal/mostlylucid.nugetpackages)
* **NuGet:** Installeer het pakket.
  [https://www .nuget.orgM SK3packagesMST4mostlylucidMSC5botdetection](https://www.nuget.org/packages/mostlylucid.botdetection)
* **Docker Hub:** YARP-gateway
  [https://hubM SK1docker.comMST3rMSP4scottgalMSC5mostlylucid MST6yarpgateway](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway)

**Onlicensieverlening – publieke domein. Gebruik het hoe je wilt**