# **StyloBot: Lutte contre les Scrappers M SK1Parte 1)**

*Les Scrapers vont commencer à utiliser l’AI pour imiter les utilisateurs réels -, c’est pourquoi j’ai construit un détecteur de robot qui apprend , s’adapte*

**[Lire la partie 2: Comment les bottes sont devenues plus intelligentes - La nouvelle frontière dans le domaine de la détection des bots](https://www.mostlylucid.net/blog/botdetection-part2-signature-pipeline-and-stylobot-architecture)**

**[👉 Voir en directM SK1 StyloBot.net](https://stylobot.net)** - Il s'agit du système de production réel qui détecte votre demande en millisecondes uniques.

**Concept clé: Routage comportemental.** Cela permet d’établir une nouvelle catégorie - où les détecteurs et les systèmes d’apprentissage transparents , réglables [Portail YARP](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway), Les bots ne parviennent jamais à votre backend. Ou utiliser le middleware pour construire des rouages comportementaux directement dans votre couche d'applicationM 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)

---


## **Pourquoi cela existe-t-il?**

La détection des bottes est devenue silencieusement l’un des problèmes les plus difficiles dans le domaine du web moderne.

**Le problème vient de changer.** Il y a trois ans, on pouvait bloquer , des bots avec regex sur l’utilisateur - la chaîne d’agents **les grands modèles linguistiques ont rendu trivial d'imiter le comportement réel des utilisateurs à l'échelle**. Un Scrapper à l’aide d’un LLMM SK1 ne demande pas le même chemin de façon aveugle et répétée. Il comprend la structure de votre site , s’adapte lorsqu’il est bloqué

* Proxyes résidentielles en rotation
* Des empreintes digitales parfaitement valides du navigateur
* Mouvement réel de la souris
* Exécution de JavaScript
* Adaptation lorsque bloquée

Les solutions commerciales permettent de résoudre ce problème, mais ellesM SK1 sont coûteuses (£3K-£50K+/le mois est typique en fonction de la taille de l’entrepriseMSSK5 ferméeMSC6sourceMST7 et liée à des NCD spécifiquesMSS8 Vous ne savez jamais vraiment ce qui se passe sous le capuchonMSR10 Et ils ont une limiteMSP11 la plupart ont été construites pour le paysage menaçant MSL12 MSR13 les navigateurs sans têteM SR14 les proxies distribuésMRS15 Ils s’arrêtent avant vMSV16 le LLMMSSR17 la frontière électriqueMRSS18 Si vous(MSR19) êtes rayé par l’automatisation intelligenteRMS20 ils fonctionnent bienMSTR21 si vous(RMS22) êtes sous coordinationRMSR23 intelligente~MSR24 attaque adaptative~MSTR25~ils(RMR26) jouent du piège~M SR27~up~RMS28

Je voulais quelque chose de différent:

* **Ouverture** - Vous pouvez lireM SK1 audit , et modifier chaque règle de détection
* **Local** - Non 3rd-appels d'API de la part des partiesM SK3 aucune donnée ne quitte votre infrastructure
* **Compréhensible** - Décisions explicatives , non noirsM SK2 modèle de boîte ML
* **Facile à élargir** - Ajouter des détecteurs personnalisés pour votre surface de menace spécifique
* **Cheap to run** - CPU, non coût de licence  ouiM SK3 même sur un Raspberry Pi
* **Élaboré pour v4** - Contribue aux attaques de l’ancienne LLM, non seulement hier, mais aussi aujourd’hui

J'ai donc construit **StyloBot** - un moteur modulaire de détection des robots d’apprentissage pour .NETM SK3 gratuit, non-licenséMSC5 conçu depuis le fond pour la nouvelle ère des bots

Il a commencé par simple … puis s’est transformé en quelque chose de beaucoup plus intéressant .

---


[TOC]

---


## **Exemple concrète (Qu'est-ce que cela atteigne en fait?**

C’est là un scénario réel.

A scraper spoofs:

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

Il semble légitime.

Mais ce n'est pas *a-t-elle oublié* un en-tête Chrome envoie toujours:

```
Sec-Fetch-Mode
```

En outre, `Accept-Language` header ne correspond pas à la localisation revendiquée’

Et le taux de demande est clairement automatisé.

**Un signal est parfait. Deux sont suspectsM SK1 Trois sont un modèle.**

Le système le signale sous 100 millisecondes - sans AI requise

C’est la base de l’ensemble du design:
**don’ ne dépend pas d’un grand modèle “bot ou nonM SK2 model. Recueillir les preuvesMSC4**

---


## La philosophie du système

Au cœur de ce projet, , n’est pas vraiment sur la détection des robots. **Traiter le trafic comme un système vivant** plutôt qu’un flux de demandes isolées.

**Pourquoi cela importe maintenant:** LLM-les bots à moteur ne sont pas 't stupidesM SK2ils s’adaptent. Un robot LLM touche votre APIMSC4 obtient le tauxMska5limitéMske6 modifie l’utilisateurM Ska7agentMSKA8 tourne IPM ska9 demande des produits connexes Mská10comme un humain le feraitMška11 puis extrait systématiquement les donnéesMshka12 Les règles statiques peuventMsaka13non se tenir au courantMaskan14 Mais un système adaptatif peutMzaka15

Les écrasiers modernes se comportent comme des organismes. Ils apprennent à muter, à détecter les faiblesses et à réagir à la pression. La défense doit donc évoluer.

La philosophie est simple:

1. **Observer de nombreux signaux** - UAM SK1 en-têtes , IP, patrons comportementauxMNK4 croisementMRK5cohérence des couches
2. **Combiner les deux** - Don ' ne croyez pas à un seul signal
3. **Permettez-les d'interagir** - Une UA parfaite est soupçonnée si l’IP est un centre de données . Les en-têtes sont suspectes s’ils' manquent des marqueurs réelsM SK3marqueurs de navigateurMSC4
4. **Adapter au fil du temps** - Les patrons se détruisent . De nouveaux patrons apparaissent. Apprenez continuellementM SK3

À la place d’un seul "botM SK1not-boatMSC3check ,, le moteur devient **un réseau de petits détecteurs**, chaque preuve contribue à la prise d’une décision partagée - couche de décision M SK2 Les politiques deviennent des flux composables , pas difficiles MSC4 règles codées MNK5 La réputation évolue graduellement au lieu de se déplacer dans les états de fait MMK6 L’AI n’est qu’un autre coauteur MRK7 pondérée en même temps que l’héuristique MEK8 non un monolith MZK9

Le système est conçu pour être **transparence, explicable , extensibleM SK2 et auto- correction**, avec l’objectif à long terme de se comporter moins comme une pare-feu et plus comme un **système immunitaire**: à l’avant-garde rapideM SK1 intelligent dans le cœur , et toujours en apprentissage

---


## **Pourquoi la détection d’un seul signal ne fonctionne pas (et comment le StyloBot l’évite)**

La plupart des systèmes reposent sur un ou deux signaux:

- **"Blocker si l’utilisateurM SK1Agent dit 'bot'"** → Équipement spoofed. Les bots modernes utilisent des utilisateurs réels
- **"Blocker si le taux est ≥> Demandes XM SK2sec"** → Throttle de robots intelligents . VousM SK2 bloquerez la puissance réelle-usagersMSC4
- **"Blocker si l’IP est dans un centre de données** → Les réseaux de proxy résidentiels ont des ISP réels à domicile. Bonne chanceM SK2
- **"Blocker si JavaScript ne l’execute pasM SK1t execute"** → Les navigateurs sans tête exécutent JS parfaitement correctement.

Le modèle: **tout signal unique peut être falsifié.** La solution: **don't ne dépend pas d’un seul signal.**

StyloBot combine de nombreux signaux faibles en un verdict fort. Un utilisateur parfaitM SK1 L'agent est bon. Un utilisateurs parfait - Un agent *plus* IP d'un centre de données *plus* les titres de sécurité manquants *plus* anomalies du taux de demande *plus* incohérence de la couche = botM SK2

---


## **Comment il fonctionne (La courte version)**

Les demandes sont transmises par plusieurs petits détecteurs, chacun contribuant à une petite pièce de preuveM SK1

Pensez à cela comme à la sécurité aéroportuaire: un agent de l’ASFC qui vérifie les documents n’est pas suffisant ' pas assez M SK2 Mais trois agents qui vérifient les documents , les laissez-passer d’atterrissage, , et le bagage ensemble atteignent ce qu’on manque

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

### **Voie rapide (< 100ms)**

Fonctionne en synchrone. Ne ralentit-il pas votre app?

* Patterns connus de robot
* Les en-têtes manquants sont toujours envoyées par les navigateurs réels
* IPs des centres de données (AWS/AzureM SK2GCP )
* Écarts de taux
* Incohérences entre les titres UA +

Il y a lieu d’examiner la question de savoir s’il est possible d’établir **80%** de bots instantanément.

### **Voie lente (Async)**

Fonctionne en arrière-plan.

* Modèle héuristique avec pondérations apprises
* Le raisonnement de LLM par l'entremise [Ollama](https://ollama.com/)
* Mise à jour de la réputation du modèle
* Forgetting stale signals

Cela attire les robots adaptatifs - ceux que la plupart des gens *envisager* ils're catching with "regex on User -AgentM SK3

---


## **Essayez en 10 secondes**

### Installation locale

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

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

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

Ce n’est pas le cas.

### Voir la première fois en direct

Ne désirez pas'ne voulez pas encore installer? **[Visitez stylobot.net](https://stylobot.net)** pour voir le système de production en action. Transmettre les demandes, les observer analysées dans des millisecondes avec pleine ouverture initialeM SK2 activé l'exit . Aucune signatureMSC4 entièrement interactifMNK5itMRK6 c'est la bonne choseMMK7

---


## **Ce qu’il détecte (à un aperçu )**

| Vérifier | Ce qu'il trouve |
| --------------- | ------------------------------------------------- |
| **Utilisateur-Agent** | Bots connusM SK1 bibliothèques , grappeurs MSC3
| **En-têtes** | Coordonnateurs de sécurité manquantsM SK1 combinaisons impossibles |
| **IP** | Les hôtes de nuages qui prétendent être des utilisateurs domestiques
| **Taux** | Explosions d'automatisationM SK1 Écrapage distribué |
| **Cohérence** | “Chrome/120” sans ChromeM SK3s actual header set |

La cohérence est la caractéristique du sommeil - les bots modernes peuvent faire des imitations *un* signal, mais généralement échec à la croisée-cohérence des signauxM SK1

---


## **Résultat de détection réelle (Broken DownM SK1**

Voici ce qui ressemble à une détection réelle : les données réelles de - **[stylobot.net](https://stylobot.net)** Running in production with early-exit enabled. Vous pouvez générer ces mêmes résultats vous-mêmes en testant sur le site en direct.

### Résumé

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

**Les détecteurs 8 ont été utilisés en 51ms** - que ' l’exécution parallèle entre plusieurs sources de preuves

### Contributions du détecteur

Chaque détecteur contribue à une incidence pondérée. négative = signal humainM SK2 positive = signal botMSC4

| Détecteur | Incidence | Poids m| Pondéré M| Raison L|
|----------|--------|--------|----------|--------|
| **Agent de l'utilisateur** | -0.20 ≥| ≤1.0 | -0.20 | Utilisateur %7 Agent apparaît normal
| **Intitulé** Les en-têtes apparaissent normales |
| **Le comportement** Les patrons de demande apparaissent normaux |
| **Héuristique** | -0.77 | 2.0 | **-1.54** | 88% probabilité humaine (16 caractéristiques
| **ClientSide** |  -0.05
| **Âge de la version** | -0.05 | | | ◦ |
| **Incohérence** | -0.05 ≥| ≤0.8 | -0.04 MSC6 Aucune en-tête MSC7 Incohérences de l’UA
| **IP** | 0.00 ≥| ≤0.5 | 0.00 MSC6 Localhost MSC7 neutre dans dev

L'article 5 de la Loi sur l'immigration et le statut des réfugiés **Détecteur héuriste** - ilM SK1 est pondéré 2x et a utilisé les 16 paramètres pour atteindre la confiance humaine

### Signals recueillis

Chaque détecteur émet des signaux qui alimentent le modèle héuristique:

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

Ces signaux persistent et forment le système d’apprentissage au fil du temps.

### Répartition des catégories

Cotes globales par catégorie pour la décision finale:

| Catégorie | Notes MSC2 Poids MSC3 Note SMC4
|----------|-------|--------|-------|
| Héristique | MSC2 | | 3 | 4 | 5 | Signal humain le plus fort | |
| Agent d'utilisateur | -0.20 | | 3 | 4 | 5 | Browser normal UA |
| Intitulé | -0.15 | | 3 | 4 | 5 | Tous les intitulés attendus sont présents | |
| Comportements MSC1 MSC2 | | 3 | 4 | 5 | Aucune anomalie de taux | | |
| ClientSide | -0.04 | | 3 | 4 | 5 | Reçue une empreinte digitale valide | |
| Âge de la version | | | 2 | 3 | 4 | 5 | Version courante du navigateur
| Incohérence
| IP | 0.00 | | 3 | 4 | 5 | Localhost | ( | dev neutre | ) |

**Cote pondérée totale: M SK1** → Système humain fort → Permettre

> **Note:** Il s’agit de la démo ' `fastpath` Politique qui fonctionne **tous** Détecteurs pour la visibilité. Dans la production réelle, avec l’activation d’une sortie anticipéeM SK1 élevée - les demandes de confiance qui sortent après seulement 2-3 les détecteurs s’accordent **sous 10ms**. Le mode de démonstration ne permet pas la sortie rapide pour montrer toutes les contributions.

### Pipeline complet (Mode de démonstration avec LLM)

Pour la comparaison, ci-dessousM SK1 est le `demo` Politique - le pipeline complet incluant la justification de LLM. Ce qui montre ce qui se passe lorsque les détecteurs **ne sont pas d'accord**:

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

**Détecteurs 10 en 1.4 secondes** - le LLM a démarré et *non-conformité* avec l’héuristique.

| Détecteur | Incidence | Poids m| Pondéré M| Raison L|
|----------|--------|--------|----------|--------|
| **LLM** | +0.85 | 2.5 | **+2.13** | "Chrome commun dans les robotsM SK2 témoins SSK3 indicateur suspect" |
| **HeuristicLate** | -0.77 ≥| ≤2.5 | -1.92 MSC6 MSC7 Homme SMC8 avec toutes les preuves SMC9
| **Héuristique** (au début de l’annéeM SK1 | | | 3 | 4 | 5 | 6 | 7 | 8 | 9 | probabilité humaine
| **Agent de l'utilisateur** | -0.20 ≥| ≤1.0 | -0.20 | Utilisateur %7 Agent apparaît normal
| **Intitulé** Les en-têtes apparaissent normales |
| **Le comportement** Les patrons de demande apparaissent normaux |
| **ClientSide** | 0.00 ≥| ≤1.8 | 0.00 MSC6 Aucune empreinte digitale MSC7 Attendement de la JS
| **Âge de la version** | -0.05 ≥| ≤0.8 | -0.04 MSC6 Browser MSC7 Versions OS courantes
| **Incohérence** | -0.05 ≥| ≤0.8 | -0.04 MSC6 Aucune en-tête MSC7 Incohérences de l’UA
| **IP** | 0.00 ≥| ≤0.5 | 0.00 MSC6 Localhost MSC7 neutre msc8 msc9

C’est le cas intéressant - **le LLM l'a signalé comme un bot potentiel** tandis que tous les détecteurs statiques disent être humains

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

Le raisonnement du LLM' est enregistré comme un signal qui retourne dans le système d’apprentissage.

Avis:

1. **Cours héuristiques deux fois** - tôt (avant tous les détecteurs) et tardivement après toutes les preuvesM SK4 Les deux répondants ont dit :

2. **LLM n'est pas d'accord** - il a repéré des patrons que les détecteurs statiques n’ont pas observésM SK1 Son impact pondéral +2.13 contrevient partiellement à l’héuristique

3. **Aucune empreinte digitale** - ClientSide a retourné 0 parce que JS n’avait pas encore exécuté

4. **Décision finale: Permettre** - même avec le soupçon de la LLMM SK1, , les preuves combinées favorisent encore l’humain. `botType: "Scraper"` le drapeau signifie qu’il est surveillé

La répartition des catégories montre la tension:

| Catégorie | Notes MSC2 Poids MSC3 Note SMC4
|----------|-------|--------|-------|
| **Héuristique** Signal humain fort |
| **AI** |  +2.13
| Agent d'utilisateur | -0.20 | | 3 | 4 | 5 | Browser normal |
| Intitulé MSC1 MSC2 | | 3 | 4 | 5 | Tous les intitulés présents | MSC6 |
Modèles normaux |
| ClientSide | 0.00 | | 3 | 4 | 5 | Aucune empreinte digitale encore | |
| Âge de la version
| Incohérence
| IP | 0.00 | | 3 | 4 | 5 | Vérificateur local | 6

**Cote pondérée totale: M SK1** → L’humain gagne , mais le dissident de la LLMM SK2 est noté.

> **Perspectives clés:** Le système ne fait pas confiance à n’importe quel seul détecteur. Lorsque ceux-ci sont en désaccord, les preuves sont pondérées et la majorité gagne.

> **Important:** Cette sortie verbose est une démonstration-seulement. Dans la production, vous obtiendrez une réponse slime via les en-têtes HTTP M SK3`X-Bot-Confidence`, `X-Bot-RiskBand`, etc .) ou un simple `context.IsBot()` vérifier. Le JSON complet est destiné au débugging et à l’ajustement.

---


## **Utilisation des résultats**

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

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

### Protéger les points finals

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

Les niveaux de risque guident l’action:

| Risque MSC1 Confiance MSC2 Mesures recommandées SMC3
| -------- | ---------- | ------------------ |
| Faible | < | | 3 | 4 | Permettre | 5 |
| Élevée | 0.3-0.5 ≥| Enregistrement MSC4 tauxMSc5limite MSC6
| Moyenne | 0.5-0.7 ≥| Défis M|
| Élevée  |

---


## **Détection de l'AI (Optionnelle)**

Non requis - mais utile pour capturer l'automatisation avancéeM SK1

### **Détecteur héuristique (FastM SK1Learning)**

Le système comprend un détecteur héuriste qui utilise la régression logistique avec des poids dynamiquement apprentis.

La latence typique: **1-5ms**

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

Les caractéristiques sont extraites dynamiquement - les nouveaux patrons obtiennent automatiquement des poids par défaut et apprennent au fil du temps . Le système découvre ce qui est important pour *de l’assurance-emploi;* Transports.

### **Ollama LLM (Considérations profondes)**

Capture des robots évasifs qui ressemblent "fine" à des règles rapidesM SK2 Usages [Ollama](https://ollama.com/) pour l'inférence locale LLM.

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

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

L'AI est **fail-safe** - si ' est en baisseM SK2 la détection se poursuit normalement

---


## **Le système d’apprentissage: Adaptif, Pas déclencheurM SK2Happi**

Les listes de blocs statiques sont bloquées. Les agresseurs s’adaptent.
Ainsi, ce système apprend

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

Les patrons se décomposent avec le temps:

* Les IP sont réassignés
* Les scripts malconfigurés sont corrigés
* Le trafic change naturellement

Sans défaillance, vous bloquez pour toujours les utilisateurs légitimes’d

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

---


## **YARP Gateway: Protection des bords pour votre application**

Il y a aussi une **Docker-premier proxy YARP inversé** qui effectue la détection *précédemment* les demandes atteignent votre app.

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

Passez en une seule ligne:

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

Travaux réalisés sur

* Linux
* macOS
* Windows
* **ARM ( oui , Raspberry PiM SK2**

Pour le routage personnalisé:

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

---


## **Une configuration de production raisonnable**

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

---


## **Où cela va?**

Il s'agit de la partie 1 (la vue d'ensembleM SK2
Les parties suivantes creusent plus loin:

* **Partie 2**: [Comment les bottes sont devenues plus intelligentes - La nouvelle frontière de la détection des bots](https://www.mostlylucid.net/blog/botdetection-part2-signature-pipeline-and-stylobot-architecture)
* **Partie 3**: Analyse des comportements
* **Partie 4**: Client - empreintes digitales latérales
* **Partie 5**: Le détecteur héuriste - mesure les poids d'apprentissage en temps réel
* **Partie 6**: Internaux de détection LLM
* **Partie 7**: Le système d’apprentissage a été expliqué correctement

**Feuille de route future:**

* Le modèle RAG- fondé sur la correspondance avec les embeddings vecteurs
* Local small model inference via [LlamaSharp](https://github.com/SciSharp/LLamaSharp) / ONNX
* Sémantique de la similitude pour détecter les nouveaux patrons d'attaque

Si vous voulez un détecteur de robots, vous pouvez *Comprendre*, *prolonger*, et *courir à n'importe où*, cette série est pour vous

---


## **Académique & Lecture de l'industrie**

Si vous voulez approfondir les raisons pour lesquelles la détection des robots est difficile et ce que dit la recherche:

### Détection des bottes & Évasion

- [Imperva: Rapport sur l'état du trafic des bottes 2024](https://www.imperva.com/blog/bot-attack-trends/) - Données sur les attaques bot du monde réel
- [OWASP: Gestion des bottes](https://owasp.org/www-community/attacks/Bot_attack) - Fondements de sécurité
- [Cloudflare: Vue d'ensemble de la détection des bottes](https://www.cloudflare.com/learning/bots/what-is-bot-detection/) - Perspective de l’industrie

### Étiquetage des empreintes digitales du réseau

- [JA3: SSL/TLS Imprimer les empreintes digitales des clients](https://github.com/salesforce/ja3) - Signature TLS correspondant à la norme
- [TCP/IP Fingerprinting: pM SK2f Référence](https://lcamtuf.coredump.cx/p0f3/) - Réseau-détection de l'OS layer
- [HTTP/2 Techniques d'imprimerie des doigts](https://www.cloudflare.com/learning/http/http2/) - Comment les navigateurs diffèrent-ils dans HTTP/2

### Analyse comportementale & Détection d'anomalies

- [Détection de l'écart dans les données des séries temporelles (ACMM SK1](https://en.wikipedia.org/wiki/Anomaly_detection) - Fondements statistiques
- [Chaînes Markov dans la détection des intrusions](https://en.wikipedia.org/wiki/Markov_chain) - Modélisation de la transition d'État

### LLM-Threats électriques & Poisonnement des données

- [Agressions à l’intoxication des données sur l’apprentissage de la machine (arXivM SK1 1811.03728)](https://arxiv.org/abs/1811.03728) - Pourquoi les scrapers ciblent vos données
- [Extracting Training Data from Large Language Models (arXiv: 2302.07933)](https://arxiv.org/abs/2302.07933) - Pourquoi les bots veulent votre contenu
- [Élimination du Web et questions relatives au droit d'auteur](https://en.wikipedia.org/wiki/Web_scraping#Legal_issues) - Le point de vue juridique

### Détection du navigateur sans tête

- [& Détection de la correction des paroles](https://antoinevastel.com/blog/detect-puppeteer-and-playwright/) - Comment les navigateurs sans tête sont identifiés
- [Imprimantes digitales sur canvas & Évasion](https://cvdazzle.com/) - Client- techniques de détection des côtés

---


## **Liens du projet**

* **GitHub:** documents complets
  [https://github.comMSC2scottgalM SK3stylobot](https://github.com/scottgal/stylobot)
* **NuGet:** installer le paquet
  [https://www .nuget.orgM SK3packagesMST4mostlylucidMSC5botdetection](https://www.nuget.org/packages/mostlylucid.botdetection)
* **Docker Hub:** Voie d'accès YARP
  [https://hub .docker.comM SK3rMSC4scottgalMST5stylobotMSP6gateway](https://hub.docker.com/r/scottgal/stylobot-gateway)

---


**Délivrance de licence - domaine public. Utilisez-le comme vous le souhaitez .**