Back to "StyloBot.:, so einfach wie möglich und kein einfacheres Teil"

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

# **StyloBot.:, so einfach wie möglich und kein einfacheres Teil**

*Enterprise Bot-Detektion sollte erforderlich sein, um einen PhD in der Infrastruktur zu verwenden.(oder tausende pro Monat in Ausgaben für die Verwendung von zwei Zeilen Code, ,, Null externe Dienste, , und you, 're laufen bis zu ), MSC8, Detektoren in Millisekunden auf jede Anfrage an jeden Endpunkt.*

**[Lesen Sie Teil StyloBot:® Kampf gegen Scrapers](https://www.mostlylucid.net/blog/botdetection-introduction)**

**[Lesen Sie Teil, wie Bots Smarter bekam](https://www.mostlylucid.net/blog/botdetection-part2-signature-pipeline-and-stylobot-architecture)**

**[StyloBot®.®net](https://stylobot.net)** Das reale Produktionssystem, das früh läuft.-.Exit-Detektion inline am Gateway.

<datetime class="hidden">2026-02-16T10:30</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/stylobot?style=social)](https://github.com/scottgal/stylobot)
[![Docker](https://img.shields.io/docker/pulls/scottgal/stylobot-gateway)](https://hub.docker.com/r/scottgal/stylobot-gateway)

---

[TOC]

---

## Die Idee

Einstein sagte angeblich: , Alles sollte so einfach wie möglich gemacht werden.,, aber kein einfacheres, dass das Design-Prinzip von StyloBot's Integrationsmodell ist.

Teile, die mit einem Fassungsvermögen von mehr als 1 kg oder weniger abgedeckt sind *warum* Bot-Detektionsfragen und *wie die Detektionspipeline funktioniert*Dieser Beitrag umfasst *wie wenig Code man eigentlich braucht* - und wie das gleiche System von einer Single---Datei-App zu einem vollständigen Produktionsgateway mit TimescaleDBC2, Qdrant-Vektorsuche ,, CPU, nur LLM-Klassifikation . skaliert

Die wichtigsten Erkenntnisse **jede Ebene verwendet die gleiche Detektionspipeline**Du schaltest die Rahmen nicht, während du anbaust. Du mischst Speicher und Bereicherung um denselben Kern.

---

## Zwei Codezeilen

Dies ist das absolute Minimum.... keine Konfigurationsdatei... keine Datenbankeinstellung... keine API-Schlüssel... keine Docker-Container...

```csharp
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddBotDetection();       // ← that's line 1

var app = builder.Build();
app.UseBotDetection();                    // ← that's line 2
app.Run();
```

Was gerade passiert ist

- **Detektoren** registriert: : userAgent pattern matching – , header consistency – , UP Datacenter Detection –, bushual analysis – MSC4 TPLS Fingerprinting – MCSK5 TP3/ TPCP-/ TP-Fingerabdruckanalyse – , HTTP-/2 ftexprinting - , chate-Verhaltensanalytik – MKS12 antwortsverhaltensfeedback – MSA13 – multi---Schichtkorrelation – MSSK15 und mehr – MSR16
- **Wave---basierte Pipeline**Detektoren, die in Abhängigkeitswellen laufen, ., Welle, 0, keine Abhängigkeiten, parallel ausgeführte ), spätere Wellen lösen nur dann aus, wenn frühere Signale eine tiefere Analyse rechtfertigen..,
- **SQLite-Speicher**:" A `botdetection.db` Datei auto--Creates für gelernte Muster und Gewichte-.Created No setup
- **In---Prozess-Ähnlichkeitssuche**HNSW Index für die Suche nach ähnlichen Bot-Signaturen
- **Heuristische Wertung**Eigenschaften, die pro Anfrage extrahiert wurden, werden durch ein leichtes im --Prozessmodell gewertet.

All dies läuft in **unter „1" Millisekunde** pro Anfrage auf Rohstoff-Hardware... nur für die CPU... keine GPU...

Jede Anfrage hat jetzt Erkennungsergebnisse über `HttpContext` erweiterungen

```csharp
app.MapGet("/", (HttpContext ctx) => Results.Ok(new
{
    isBot = ctx.IsBot(),
    probability = ctx.GetBotProbability(),     // 0.0-1.0: how likely it's a bot
    confidence = ctx.GetDetectionConfidence(),  // 0.0-1.0: how certain the system is
    type = ctx.GetBotType()?.ToString(),
    name = ctx.GetBotName()
}));
```

Detektion läuft, aber nichts blockiert – .-Sie entscheiden, was mit den Ergebnissen zu tun ist.

---

## Blockieren Sie alle Bots.,. Ganze App

Wenn Sie gerade Bots von Ihrer gesamten Anwendung sperren möchten, keine per-per--endpoint config-, keine Attribute - es ist eine Zeile JSON-:.

```json
{
  "BotDetection": {
    "BlockDetectedBots": true
  }
}
```

Dass ,' , es , . , Detektierte Bots über Ihrem Block , - , Vertrauensschwelle erhalten ein , ,403 , ( ,`MinConfidenceToBlock` Standardwerte für `0.8`Googlebot,Bingbot),C Social Media Previews Facebook,C Twitter/CXC),C und Überwachung Bots UberwachungszeitRoboter,C Pingdom)C sind per Default erlaubt -, weil Sie fast sicher wollen, dass diese

Oder die gleiche Sache im Code-Code, keine Konfigurationsdatei benötigt

```csharp
builder.Services.Configure<BotDetectionOptions>(o =>
{
    o.BlockDetectedBots = true;
    o.MinConfidenceToBlock = 0.8;           // only block when confident
    o.AllowVerifiedSearchEngines = true;     // Googlebot, Bingbot through
    o.AllowSocialMediaBots = true;           // Facebook, Twitter previews through
    o.AllowMonitoringBots = true;            // UptimeRobot, Pingdom through
});
```

Dies ist die ." .Ich möchte nicht daran denken , dass es " . . . . Detektion läuft . , . Bots werden blockiert , . gute Raupen erhalten durch . . . Bewegen Sie sich zu per .- .endpoint-Steuerung, wenn Sie es brauchen

---

## Minimales API-Beispiel Das komplette Beispiel

Hier ist ein komplettes ,, , Arbeits API mit Per-- , Endpoint Bot Schutz , . , Dies ist die gesamte `Program.cs`:

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

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

// Detection results available, no blocking
app.MapGet("/", (HttpContext ctx) => Results.Ok(new
{
    isBot = ctx.IsBot(),
    probability = ctx.GetBotProbability(),
    confidence = ctx.GetDetectionConfidence(),
    type = ctx.GetBotType()?.ToString(),
    name = ctx.GetBotName()
}));

// Block all bots
app.MapGet("/api/data", () => Results.Ok(new { data = "sensitive" }))
   .BlockBots();

// Allow search engines (Googlebot, Bingbot, Yandex)
app.MapGet("/products", () => Results.Ok(new { catalog = "public" }))
   .BlockBots(allowSearchEngines: true);

// Allow search engines + social media previews (Facebook, Twitter/X)
app.MapGet("/blog/{slug}", (string slug) => Results.Ok(new { post = slug }))
   .BlockBots(allowSearchEngines: true, allowSocialMediaBots: true);

// Health check: monitoring bots allowed (UptimeRobot, Pingdom)
app.MapGet("/health", () => Results.Ok("healthy"))
   .BlockBots(allowMonitoringBots: true);

// Humans only - blocks ALL bots including verified crawlers
app.MapPost("/api/submit", () => Results.Ok(new { submitted = true }))
   .RequireHuman();

// High-confidence blocking only (reduces false positives)
app.MapGet("/api/lenient", () => Results.Ok("data"))
   .BlockBots(minConfidence: 0.9);

// Geo + network blocking (needs GeoDetection contributor)
app.MapPost("/api/payment", () => Results.Ok("ok"))
   .BlockBots(blockCountries: "CN,RU", blockVpn: true, blockDatacenter: true);

// Honeypot: deliberately allow scrapers in
app.MapGet("/honeypot", () => Results.Ok("welcome"))
   .BlockBots(allowScrapers: true, allowMaliciousBots: true);

// Dev diagnostics
app.MapBotDetectionEndpoints();

app.Run();
```

Jede `.BlockBots()` Anrufblöcke **alle** Bot-Typen per Default – .-Sie entscheiden sich für bestimmte Typen *in der* mit der `Allow*` Parameter: Die Idee wird verweigert-von:-Default: , Weiße Liste der guten

### Bot-Typen, die Sie zulassen können

Parameter für das, was es erlaubt, warum Sie es verwenden
|-----------|---------------|-----------------|
| `allowSearchEngines` Googlebot: ,Bingbot:,BYNDEX SEO – -Sie möchten indexiert werden
| `allowSocialMediaBots` Facebook Twitter Twitter LinkedIn Vorschau auf den Link , Offene Graphenkarten |
| `allowMonitoringBots` BetriebszeitRoboter,B Pingdom,B StatusCake Gesundheitskontrollen,B Betriebszeitüberwachung
| `allowAiBots` GPTBot, ClaudeBot, ClaudeBotMSK2 , Google, - , Erweitert , MSC4 , Opt-- , um AI-Training , | ,
| `allowGoodBots` Zuführungsleser ,-Link-Checker Benachteiligte Automatisierung
| `allowVerifiedBots` Verifizierte Crawler von -Verstärkter Automatisierung
| `allowScrapers` SemrushBot - Honeypots - SEO-Forschung
| `allowMaliciousBots` Bekannte schlechte Akteure
| `minConfidence` | *(-Schwellenwert* Nur blockieren, wenn das System sehr sicher ist.

---

## MVC-Steuerungsmerkmale

Gleiche Detektions-Pipeline - Schutz durch Attribute - .

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

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

### Die Attribute

```csharp
[ApiController]
[Route("[controller]")]
public class ProductsController : ControllerBase
{
    // No protection - detection runs but nothing blocks
    [HttpGet]
    public IActionResult List() => Ok(new { products = "all" });

// Block all bots, allow search engines
    [HttpGet("catalog")]
    [BlockBots(AllowSearchEngines = true)]
    public IActionResult Catalog() => Ok(new { catalog = "indexed" });

// Block all bots, allow search engines + social previews
    [HttpGet("{id:int}")]
    [BlockBots(AllowSearchEngines = true, AllowSocialMediaBots = true)]
    public IActionResult Detail(int id) => Ok(new { id });
}

// Entire controller: humans only
[ApiController]
[Route("[controller]")]
[RequireHuman]
public class CheckoutController : ControllerBase
{
    [HttpPost("cart")]
    public IActionResult AddToCart() => Ok();

[HttpPost("pay")]
    public IActionResult Pay() => Ok();
}

// Infrastructure endpoints
[ApiController]
[Route("[controller]")]
public class InfraController : ControllerBase
{
    // Skip detection entirely
    [HttpGet("health")]
    [SkipBotDetection]
    public IActionResult Health() => Ok("ok");

// Monitoring bots allowed
    [HttpGet("status")]
    [BlockBots(AllowMonitoringBots = true)]
    public IActionResult Status() => Ok(new { uptime = "99.9%" });
}
```

### Geografisches Blockieren des Netzwerks

Diese arbeiten sowohl an MVC-Attributen als auch an Minimal API-Filtern.Sie benötigen den GeoDetection Contributor für Signaldaten.

```csharp
// Block countries
[BlockBots(BlockCountries = "CN,RU,KP")]
public IActionResult SensitiveApi() => Ok();

// Country whitelist - only these allowed
[BlockBots(AllowCountries = "US,GB,DE,FR")]
public IActionResult DomesticOnly() => Ok();

// Block VPNs + proxies (anti-fraud)
[BlockBots(BlockVpn = true, BlockProxy = true)]
public IActionResult Payment() => Ok();

// Block datacenter IPs + Tor
[BlockBots(BlockDatacenter = true, BlockTor = true)]
public IActionResult FormSubmission() => Ok();

// Combine: SEO-friendly + geo block + VPN block
[BlockBots(AllowSearchEngines = true, BlockCountries = "CN,RU", BlockVpn = true)]
public IActionResult ProtectedContent() => Ok();
```

---

## Jenseits von Block-/-Aktionspolitiken

Binärblock – /-allow ist einfach, aber begrenzt –.-Aktionspolitik getrennt *was Sie entdecken* von *Wie Sie reagieren*Definieren Sie die Antwortstrategien in config.,.orden Sie sie den Endpunkten zu.

### Appsettings.-json

```json
{
  "BotDetection": {
    "BotThreshold": 0.7,
    "ActionPolicies": {
      "api-block": {
        "Type": "Block",
        "StatusCode": 403,
        "Message": "Bot traffic is not allowed."
      },
      "api-throttle": {
        "Type": "Throttle",
        "BaseDelayMs": 500,
        "MaxDelayMs": 5000,
        "ScaleByRisk": true,
        "JitterPercent": 0.3
      },
      "shadow-mode": {
        "Type": "LogOnly",
        "AddResponseHeaders": true,
        "LogFullEvidence": true
      }
    }
  }
}
```

### Richtlinien den Endpunkten zuweisen

```csharp
// Bots get progressively slower responses (they don't know they're being throttled)
[BotPolicy("default", ActionPolicy = "api-throttle")]
public IActionResult Browse() => Ok();

// Hard block
[BotPolicy("default", ActionPolicy = "api-block")]
public IActionResult Confirm() => Ok();

// Shadow mode: log everything, block nothing (deploy first, tune later)
[BotPolicy("default", ActionPolicy = "shadow-mode")]
public IActionResult PublicApi() => Ok();
```

Fünf Richtlinientypen `Block` ,(,HTTP , 403),, `Throttle` (-Verzögerungen des Stealths `Challenge` (-CAPTCHA-/-proof---of---work-MSC4- `Redirect` Honeypot-Falle `LogOnly` Der Schatten-Modus von (, siehe [Maßnahmenpolitiken](https://github.com/scottgal/LLMApi/blob/main/Mostlylucid.BotDetection/docs/action-policies.md) für die vollständige Referenz

Shadow-Modus ist der empfohlene Startpunkt...Deploy Detection.,.Beobachten Sie die Ergebnisse.MSC2. *dann* Sperren beginnen

---

## Was man umsonst bekommt

Jede Anfrage nach `UseBotDetection()` hat diese Erweiterungen verfügbar auf `HttpContext`:

```csharp
// Am I talking to a bot?
context.IsBot()                    // true if probability >= threshold
context.IsHuman()                  // inverse
context.IsSearchEngineBot()        // Googlebot, Bingbot, etc.
context.IsVerifiedBot()            // DNS-verified bots
context.IsMaliciousBot()           // known bad actors

// How bad is it?
context.GetBotProbability()        // 0.0-1.0: likelihood of being a bot
context.GetDetectionConfidence()   // 0.0-1.0: how certain the system is
context.GetRiskBand()              // Low, Elevated, Medium, High
context.GetRecommendedAction()     // Allow, Challenge, Throttle, Block

// What is it?
context.GetBotType()               // BotType enum
context.GetBotName()               // "Googlebot", "Scrapy", etc.

// Full breakdown
var result = context.GetBotDetectionResult();
```

Zwei unabhängige Partituren sind hier von Bedeutung. **Bot-Wahrscheinlichkeit** Wie wahrscheinlich ist dies ein Bot-?) und **Detektionssicherheit** Wie sicher ist das System? *Mensch* Oder Sie können eine verdächtige Anfrage sehen, aber niedriges Vertrauen haben, weil nur ein Detektor ran.

---

## Signal---basierte Filterung

Über Bot-Typen hinaus: ,-StyloBot setzt Signale von seinen Detektoren frei..-Sie können Endpunkte auf der Grundlage spezifischer Signalwerte filtern.-- für Minimal API und MVC-.-

### Minimale API

```csharp
// Block VPN traffic
app.MapPost("/api/payment", () => Results.Ok())
   .BlockIfSignal(SignalKeys.GeoIsVpn, SignalOperator.Equals, "True");

// Block datacenter IPs
app.MapPost("/api/submit", () => Results.Ok())
   .BlockIfSignal(SignalKeys.IpIsDatacenter, SignalOperator.Equals, "True");

// Only allow US traffic
app.MapGet("/api/domestic", () => Results.Ok())
   .RequireSignal(SignalKeys.GeoCountryCode, SignalOperator.Equals, "US");

// Block high-confidence bots by heuristic score
app.MapGet("/api/premium", () => Results.Ok())
   .BlockIfSignal(SignalKeys.HeuristicConfidence, SignalOperator.GreaterThan, "0.9");
```

### MVC

```csharp
[BlockIfSignal(SignalKeys.GeoIsVpn, SignalOperator.Equals, "True")]
public IActionResult Payment() => Ok();

[RequireSignal(SignalKeys.GeoCountryCode, SignalOperator.Equals, "US")]
public IActionResult DomesticOnly() => Ok();
```

### Einlesen von Signalen

```csharp
app.MapGet("/debug", (HttpContext ctx) =>
{
    var country = ctx.GetSignal<string>(SignalKeys.GeoCountryCode);
    var isVpn = ctx.GetSignal<bool>(SignalKeys.GeoIsVpn);
    var isDc = ctx.IsDatacenter();
    var heuristic = ctx.GetSignal<double>(SignalKeys.HeuristicConfidence);

return Results.Ok(new { country, isVpn, isDc, heuristic });
});
```

Vollständige Signalreferenz [Signale und benutzerdefinierte Filter](https://github.com/scottgal/LLMApi/blob/main/Mostlylucid.BotDetection/docs/signals-and-custom-filters.md).

---

## Es zu testen

```bash
# Normal browser request → low bot score
curl -H "Accept: text/html" -H "Accept-Language: en-US" \
  -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
  http://localhost:5090/

# Googlebot → allowed where AllowSearchEngines=true
curl -A "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)" \
  http://localhost:5090/products

# Scraper → blocked by .BlockBots()
curl -A "Scrapy/2.7" http://localhost:5090/api/data

# Full detection breakdown → shows all signals and per-detector contributions
curl http://localhost:5090/bot-detection/check

# Simulate bot types via test mode header
curl -H "ml-bot-test-mode: malicious" http://localhost:5090/bot-detection/check
curl -H "ml-bot-test-mode: scraper" http://localhost:5090/api/data
```

Das `/bot-detection/check` Endpoint ist dein Entwicklungsfreund. Es gibt jedes Signal von jedem Detektor zurück.

---

## Wie es skaliert von Datei zum vollen Stack

Dies ist das Design-Prinzip, das am meisten zählt **jede Ebene verwendet die gleiche Detektionspipeline**Sie werden niemals den Schutzcode neu schreiben, indem Sie die Infrastruktur um denselben Kern herum hinzufügen.

### Tier Tier, wo Sie beginnen

```
Your App + AddBotDetection()
    └── SQLite (auto-created botdetection.db)
    └── In-process [HNSW](https://en.wikipedia.org/wiki/Hierarchical_navigable_small_world_graphs) similarity search
    └── 21 detectors, <1ms per request
    └── No external services
```

Alle MSK-Detektoren laufen in einer Welle.-, die auf Pipeline basiert ist.., Fast--, Path Detektoren, UserAgent,, Header,, IP-,, Behavioral,, TLS Fingerabdruck, ), parallel in Wave ausführen.MSC10, Heuristische Scoring-Extrakte, Features und führt ein leichtes Scorings-Modell aus.MSSK12, Erlernte Muster bestehen weiterhin bei SQLite über Neustarts hinweg aus.

**Gut für** Einzel-App ,, , , <100 , K-Anfragen , / , Tag , , , Beginnen ,.

### Tier .2:-Geoerkennung hinzufügen

Fügen Sie Geo-Routing plus die geo contributor.

```csharp
builder.Services.AddBotDetection();
builder.Services.AddGeoRoutingWithDataHub(); // free local GeoIP DB (no account)
builder.Services.AddGeoDetectionContributor(options =>
{
    options.FlagVpnIps = true;
    options.FlagHostingIps = true;
});
```

Wenn IP-Geolokalisierung neu ist [Hintergrund der GeoIP](https://en.wikipedia.org/wiki/Geolocation_software#IP_address) und [DataHub GeoIP-Datensatz](https://datahub.io/core/geoip2-ipv4) sind gute Ausgangspunkte ,. , DataHubCsv lädt eine kostenlose .~27 ,MB IP-Datenbank auf den ersten Lauf und hält es wöchentlich aktualisiert , . , Alle Lookups sind lokal , - , keine per...- , HTTP-Anrufe anfordern ,. , Für die Stadt ,- , Levelpräzision , , , verwenden [MaxMind GeoLite-2](https://dev.maxmind.com/geoip/geolite2-free-geolocation-data/).

Jetzt erhalten Sie geo-Signale (Ausland,Ausland VPN,Ausgangspunkt,Auszugspunkt ,Ausrichtungspunkt-Erkennung)Ausrichtung und Bot Herkunftsnachweis (Ausführungspunkt eines chinesischen Rechenzentrums `BlockCountries`, `BlockVpn`, `BlockDatacenter`, `BlockTor` Parameter aktivieren - .-

### Tier Kategorie: PostgreSQL ZeitskalaDB

SQLite durch PostgreSQL für Multi---Server-Shared Learning ersetzen und hinzufügen [ZeitskalaDB](https://docs.timescale.com/) (-A PostgreSQL-Erweiterung für Zeit--Seriendaten)-Für Analysen:-

```csharp
builder.Services.AddBotDetection();
builder.Services.AddStyloBotDashboard();
builder.Services.AddStyloBotPostgreSQL(connectionString, options =>
{
    options.EnableTimescaleDB = true;
    options.RetentionDays = 90;
    options.CompressionAfter = TimeSpan.FromDays(7);
});
```

```yaml
# docker-compose.yml
services:
  timescaledb:
    image: timescale/timescaledb:latest-pg16
    environment:
      POSTGRES_DB: stylobot
      POSTGRES_USER: stylobot
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - timescale-data:/var/lib/postgresql/data

app:
    build: .
    environment:
      ConnectionStrings__BotDetection: "Host=timescaledb;Database=stylobot;Username=stylobot;Password=${DB_PASSWORD}"
    depends_on:
      timescaledb:
        condition: service_healthy
```

TimescaleDB gibt Ihnen hypertable Partitionierung.Automatische Komprimierung...... ..(90-95%. Speicherreduzierung nach... Tagen.. .-),. kontinuierliche Aggregate für sub...

**Gut für** Mehrmals Server für , benötigen Analyse-Dashboard.

### Tier: Voller Stack - Gateway - Qdrant - LLM

```
Internet → Caddy (TLS) → Stylobot Gateway ([YARP](https://microsoft.github.io/reverse-proxy/)) → Your App
                              │
                              ├── TimescaleDB (analytics, learning)
                              ├── [Qdrant](https://qdrant.tech/documentation/) (vector similarity search)
                              └── LLamaSharp CPU [LLM](https://en.wikipedia.org/wiki/Large_language_model) (bot classification)
```

Das Gateway ist ein eigenständiger Docker-Container`scottgal/stylobot-gateway`Die Erkennung auf allen Traffic- und Forwards-Ergebnissen läuft als HTTP-Header. Ihre App liest Header. **kein SDK benötigt wird.**Wenn " ist nicht bekannt " ist, denken Sie an "[umgekehrter Proxy](https://en.wikipedia.org/wiki/Reverse_proxy) das vor Ihrer App sitzt und Sicherheit hinzufügt

```yaml
services:
  gateway:
    image: scottgal/stylobot-gateway:latest
    environment:
      DEFAULT_UPSTREAM: "http://app:8080"
      StyloBotDashboard__PostgreSQL__ConnectionString: "Host=timescaledb;..."
      StyloBotDashboard__PostgreSQL__EnableTimescaleDB: true
      BotDetection__Qdrant__Enabled: true
      BotDetection__Qdrant__Endpoint: http://qdrant:6334
      BotDetection__Qdrant__EnableEmbeddings: true
      BotDetection__AiDetection__Provider: LlamaSharp
      BotDetection__AiDetection__LlamaSharp__ModelPath: "Qwen/Qwen2.5-0.5B-Instruct-GGUF/qwen2.5-0.5b-instruct-q4_k_m.gguf"

app:
    build: .
    environment:
      BOTDETECTION_TRUST_UPSTREAM: true

qdrant:
    image: qdrant/qdrant:latest

timescaledb:
    image: timescale/timescaledb:latest-pg16

caddy:
    image: caddy:latest
```

Ihre App vertraut auf die Gateway-Header von '

```csharp
// ASP.NET Core
builder.Services.Configure<BotDetectionOptions>(o => o.TrustUpstreamDetection = true);
```

Oder lesen Sie Kopfzeilen direkt in jeder Sprache.

```python
# Python/Flask
@app.route('/api/data')
def api_data():
    if request.headers.get('X-Bot-Detected') == 'true':
        return jsonify(error='blocked'), 403
    return jsonify(data='sensitive')
```

```javascript
// Node.js/Express
app.get('/api/data', (req, res) => {
  if (req.headers['x-bot-detected'] === 'true') {
    return res.status(403).json({ error: 'blocked' });
  }
  res.json({ data: 'sensitive' });
});
```

**Kopfzeilen des Gateways sendet - :**

Beispiel für die Verwendung von |
|--------|---------|---------|
| `X-Bot-Detected` | `true` ]|-Bot-/-Humanklassifizierung ®|-
| `X-Bot-Confidence` | `0.91` Das Vertrauen in die Detektion
| `X-Bot-Detection-Probability` | `0.87` Wahrscheinlichkeit des Bot-Tests
| `X-Bot-Type` | `Scraper` Kategorie der Bot-Kategorie
| `X-Bot-Name` | `AhrefsBot` ]| Identifizierter Bot
| `X-Bot-Detection-RiskBand` | `High` Risikoklassifizierung

### Was jede Komponente hinzufügt

|-Komponente, was es tut
|-----------|-------------|-----------|
| **ZeitskalaDB** - Series analytics , Empfohlen für die Produktion |
| **Qdrant** Vector similarity search -® findet Bots, auch wenn sie rotieren User MS K2®Agenten Optional
| **LLamaSharp** Nur LLM für Bot-Cluster-Nennung und Klassifikationssynthese
| **Caddy, /, Nginx** Beenden von TLS-Dateien Beseitigen von statischen Dateien Berühren Sie Ihren vorhandenen umgekehrten Proxy
| **Gateway** Zentralisierte Detektion für Multi- oder Nicht--.-NET-Backends für multi- und --Service-Architekturen

### Wählen Sie Ihr Tier

```
Starting out?
├── Single ASP.NET app → Tier 1 (two lines of code)
│   └── Need geo blocking? → Tier 2 (one more line)
│       └── Need analytics? → Tier 3 (add PostgreSQL)
└── Multiple apps or non-.NET? → Tier 4 (Gateway)
```

Bewegen zwischen den Ebenen ist eine DI-Registrierungsänderung... Ihr Endpunktschutzcode... `[BlockBots]` Attribute: `.BlockBots()` filtern, die `context.IsBot()` überprüft, bleibt genau das gleiche, .

---

## Enterprise Hooks

Das Zwei---Linien-Setup ist der Startpunkt... Hier.'.s, was sonst noch für den Produktionseinsatz eingebaut wird.

### Response Headers für Debugging

Schalten Sie Detektion Header global ein, so dass Sie das Verhalten überprüfen können, ohne auf diagnostische Endpunkte zu treffen.

```json
{
  "BotDetection": {
    "ResponseHeaders": {
      "Enabled": true,
      "HeaderPrefix": "X-Bot-",
      "IncludeConfidence": true,
      "IncludeDetectors": true,
      "IncludeProcessingTime": true,
      "SkipPaths": ["/health"]
    }
  }
}
```

Jede Antwort bekommt `X-Bot-Detected`, `X-Bot-Confidence`, `X-Bot-Processing-Ms`Nützlich für Rand-Routing-Entscheidungen in Caddy, /, Nginx, und zum Debuggen in dev,., Deaktivieren in der Produktion oder Beschränkung auf vertrauenswürdige Netzwerke

### Herausforderungs-Politiken vor Blockierung)

Don.'.t Block auf Ungewissheit......herausforderung statt......... StyloBot hat fünf gebaute -.in Herausforderungstypen...

```json
{
  "BotDetection": {
    "ActionPolicies": {
      "challenge-on-uncertain": {
        "Type": "Challenge",
        "ChallengeType": "JavaScript"
      },
      "captcha-gate": {
        "Type": "Challenge",
        "ChallengeType": "Captcha",
        "RedirectUrl": "/captcha"
      },
      "proof-of-work": {
        "Type": "Challenge",
        "ChallengeType": "ProofOfWork"
      }
    }
  }
}
```

Herausforderungstypen `Redirect` Seite zur Herausforderung schicken `Inline` (,HTML interstitial, ),, `JavaScript` ,( ,JS-Beweis ,- ,von der Arbeit , ), , `Captcha`, `ProofOfWork` Zuweisen an Endpunkte über `[BotPolicy]`:

```csharp
[BotPolicy("default", ActionPolicy = "challenge-on-uncertain")]
public IActionResult Submit() => Ok();
```

### IP-Listen zulassen

Global erlauben und leugnen Listen für bekannte IPs und [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) Bereich:

```json
{
  "BotDetection": {
    "WhitelistedIps": ["203.0.113.10/32", "198.51.100.0/24"],
    "BlacklistedIps": ["1.2.3.4", "5.6.7.0/24"]
  }
}
```

Whitelisted IPs überspringen Detektion vollständig... Blacklisted IPs erhalten sofort blockiert... beide unterstützen CIDR-Notation...

### OpenTelemetrie Metrics

StyloBot setzt Metriken über `System.Diagnostics.Metrics`kompatibel mit [OpenTelemetrie](https://opentelemetry.io/docs/), [Prometheus](https://prometheus.io/docs/introduction/overview/), [Grafana](https://grafana.com/docs/).,- und beliebige ..-NET-Metriken

```csharp
builder.Services.AddOpenTelemetry()
    .WithMetrics(metrics => metrics.AddMeter("Mostlylucid.BotDetection"));
```

**Verfügbare Metriken**

Metrisches Messgerät Typ |, was es misst
|--------|------|-----------------|
| `botdetection.requests.total` Gesamtanfragen verarbeitet
| `botdetection.bots.detected` Anfragen, die als Bots eingestuft werden
| `botdetection.humans.detected` Anfragen, die als human eingestuft werden
| `botdetection.errors.total` Fehler bei der Erkennung von Pipeline-Fehlern
| `botdetection.detection.duration` Histogramm-Latenz der Erkennungslatenz
| `botdetection.confidence.average` Durchschnittliche Konfidenzintervalle
| `botdetection.cache.patterns.count` Anzahl der eingezäunten Muster

Dies sind die Zahlen, die Sie für Dashboards benötigen Benachrichtigungen, und Kapazitätsplanung. . Detection Latenz-Histogramm können Sie SLOs .. . Bot . / menschliche Zähler geben Ihnen Verkehrszusammensetzung im Laufe der Zeit .

### Voreinstellungen für Routengruppen

Bot-Schutz auf ganze Routengruppen anwenden, anstatt per---Endpunkt zu wiederholen.:

```csharp
// All /api routes: block bots, allow search engines
var api = app.MapGroup("/api").WithBotProtection(allowSearchEngines: true);
api.MapGet("/products", () => "data");
api.MapGet("/categories", () => "cats");

// Secured routes: humans only
var secure = app.MapGroup("/secure").WithHumanOnly();
secure.MapPost("/submit", () => "ok");
secure.MapPost("/checkout", () => "done");

// Individual endpoints can still override
api.MapGet("/special", () => "overridden")
   .BlockBots(allowSearchEngines: true, allowSocialMediaBots: true);
```

`WithBotProtection()` nimmt die gleichen Parameter wie `.BlockBots()`Beeindruckend, aber absichtlich immer Blöcke Schaber und bösartige Bots auf Gruppenebene `allowScrapers` / `allowMaliciousBots` auf Gruppen `WithHumanOnly()` ist die Gruppe entspricht der `.RequireHuman()`.

### Benannte Richtlinien auf Minimal API

Verwendung `.BotPolicy()` um benannte Aktionsrichtlinien Minimalen API-Endpunkten zuzuordnen `[BotPolicy]` tut für MVC-:

```csharp
// Throttle bots on this endpoint
app.MapGet("/api/data", () => "sensitive")
   .BotPolicy("default", actionPolicy: "api-throttle");

// Block with high-confidence threshold
app.MapPost("/api/submit", () => "ok")
   .BotPolicy("strict", actionPolicy: "block", blockThreshold: 0.8);
```

### Rückkopplungs-API

Meldung falscher Positive und Negative an das System über `POST /bot-detection/feedback`:

```bash
# Mark a detection as a false positive (bot detected but was actually human)
curl -X POST http://localhost:5090/bot-detection/feedback \
  -H "Content-Type: application/json" \
  -d '{"outcome": "Human", "notes": "Known partner integration"}'

# Mark a missed bot (human detected but was actually a bot)
curl -X POST http://localhost:5090/bot-detection/feedback \
  -H "Content-Type: application/json" \
  -d '{"outcome": "Bot", "notes": "Automated scraper spotted in logs"}'
```

Der Endpunkt gibt zurück, ob das Feedback ein falsch-positives oder falsch-negatives Verhältnis zum aktuellen Erkennungsergebnis darstellt.

### Gateway Trust Boundary mit HMAC Signing

Wenn Sie das YARP-Gateway verwenden, vertraut Ihr Backend den vorgelagerten Erkennungsköpfen. Dies ist eine sicherheitsempfindliche Einstellung von -... Sie müssen sicherstellen, dass nur das Gateway diese Header einstellen kann.

**Basis-Vertrauen - Netzwerk - Isolation nur auf der Ebene von ):**

```json
{
  "BotDetection": {
    "TrustUpstreamDetection": true
  }
}
```

**HMAC.-.signiertes Vertrauen**

```json
{
  "BotDetection": {
    "TrustUpstreamDetection": true,
    "UpstreamSignatureHeader": "X-Bot-Signature",
    "UpstreamSignatureSecret": "base64-encoded-shared-secret"
  }
}
```

Wann `UpstreamSignatureHeader` und `UpstreamSignatureSecret` sind gesetzt ,, , die Middleware überprüft ein [HMAC---SHAM256-](https://datatracker.ietf.org/doc/html/rfc2104) Signatur vor dem Vertrauen in die vorgelagerten Header

Verwenden Sie dies derzeit für **Benutzerdefinierte Gateway-Integrationen** Das eingebaute -in Stylobot-Gateway führt Bot---Detektions-Header vor, sendet HMAC-Signatur Header aber noch nicht aus..

Erforderliche signierte Kopfzeilen

- `X-Bot-Signature` ](-Basis ®64-HMAC-)-
- `X-Bot-Detection-Timestamp` (-Unix-Epoche Sekunden ,- UTC-)-

Unterzeichneter Vertrag

- `payload = X-Bot-Detected + ":" + X-Bot-Confidence + ":" + X-Bot-Detection-Timestamp`
- `signature = Base64(HMACSHA256(payload, base64Decoded(UpstreamSignatureSecret)))`

Signaturen außerhalb eines Replay-Fensters werden abgelehnt, wenn die Signatur fehlt oder abgelaufen ist, werden vorgelagerte Header von , zurückgewiesen und stattdessen wird eine vollständige lokale Erkennung ausgeführt.

**Wichtig** Nur dann Vertrauen aktivieren, wenn Ihr Backend hinter einem vertrauenswürdigen Reverse Proxy liegt. `X-Bot-Detected: false` und umgehen alle Detektionen... in der Produktion...

- Sicherstellen, dass das Backend nicht öffentlich zugänglich ist
- Streifen `X-Bot-*` Header an Ihrem Edge Proxy, bevor sie das Gateway erreichen
- Verwenden Sie HMAC-Signatur für die Verteidigung, auch mit Netzwerkisolation

---

## Was StyloBot nicht ist

Es lohnt sich, explizit zu sein.

- **Kein WAF-.** StyloBot doesn''-Inspektion von Nutzlasten für SQL-Injektion oder XSSD.-Inspection *Wer* macht die Anfrage nicht *Was ist* sie ,' , die senden .. , Verwenden Sie es neben einem WAF , , , nicht anstelle von one ?. .
- **Kein CAPTCHA-Bauernhof** Herausforderungen gibt es nicht, aber die Design-Philosophie ist Detektion. *Vorher* zu entscheiden, ob man anfechtet
- **Nicht nur im Umkreis von .** Detektion läuft per---Endpunkt mit per---Endpoint-Richtlinien `/products` Suchmaschinen erlauben, während `/api/checkout` erfordert Menschen , . , Dies ist Endpunkt Semantik , nicht Firewall-Regeln ,. ,
- **Nicht wolkenabhängig** Alles läuft selbst, --integriert, .-Qdrant,,-TimescaleDB, ,-LLM, alle optional, MSSK5-Der Kern ist zwei Zeilen Code und eine SQLite-Datei..-
- **Ungewissheit** Zwei unabhängige Werte Wahrscheinlichkeit +...Vertrauen )" bedeuten, dass Sie eine Bot-"" unterscheiden können, wahrscheinlich ein Bot-," wir ' sind sicher "" von " wahrscheinlich ein bot-," aber wir ' erraten "." Die meisten Systeme geben Ihnen eine Nummer und Hoffnung für das beste ."

---

## Was kommt als nächstes?

Teil behandelt, warum die Bot-Detektion zählt. Teil deckte die Erkennungspipeline Internals ab. Dieser Beitrag umfasste die minimale praktikable Integration und den Skalierungspfad von zwei Codezeilen zu einem vollständigen Produktionsgateway.

**Beginnen Sie mit :**

- NuGet-:- `dotnet add package Mostlylucid.BotDetection`
- Gateway Docker-: `docker pull scottgal/stylobot-gateway`
- [Vollständige Dokumente](https://github.com/scottgal/LLMApi/tree/main/Mostlylucid.BotDetection/docs)
- [Live-Demo, MSK, StyloBot, .,net](https://stylobot.net)

This is a preview from the server running through my markdig pipeline

Architecture ASP.NET Bot Detection Security

StyloBot.:, so einfach wie möglich und kein einfacheres Teil

Monday, 16 February 2026

Enterprise Bot-Detektion sollte erforderlich sein, um einen PhD in der Infrastruktur zu verwenden.(oder tausende pro Monat in Ausgaben für die Verwendung von zwei Zeilen Code, ,, Null externe Dienste, , und you, 're laufen bis zu ), MSC8, Detektoren in Millisekunden auf jede Anfrage an jeden Endpunkt.

Lesen Sie Teil StyloBot:® Kampf gegen Scrapers

Lesen Sie Teil, wie Bots Smarter bekam

StyloBot®.®net Das reale Produktionssystem, das früh läuft.-.Exit-Detektion inline am Gateway.

Die Idee

Einstein sagte angeblich: , Alles sollte so einfach wie möglich gemacht werden.,, aber kein einfacheres, dass das Design-Prinzip von StyloBot's Integrationsmodell ist.

Teile, die mit einem Fassungsvermögen von mehr als 1 kg oder weniger abgedeckt sind warum Bot-Detektionsfragen und wie die Detektionspipeline funktioniertDieser Beitrag umfasst wie wenig Code man eigentlich braucht - und wie das gleiche System von einer Single---Datei-App zu einem vollständigen Produktionsgateway mit TimescaleDBC2, Qdrant-Vektorsuche ,, CPU, nur LLM-Klassifikation . skaliert

Die wichtigsten Erkenntnisse jede Ebene verwendet die gleiche DetektionspipelineDu schaltest die Rahmen nicht, während du anbaust. Du mischst Speicher und Bereicherung um denselben Kern.

Zwei Codezeilen

Dies ist das absolute Minimum.... keine Konfigurationsdatei... keine Datenbankeinstellung... keine API-Schlüssel... keine Docker-Container...

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddBotDetection();       // ← that's line 1

var app = builder.Build();
app.UseBotDetection();                    // ← that's line 2
app.Run();

Was gerade passiert ist

Detektoren registriert: : userAgent pattern matching – , header consistency – , UP Datacenter Detection –, bushual analysis – MSC4 TPLS Fingerprinting – MCSK5 TP3/ TPCP-/ TP-Fingerabdruckanalyse – , HTTP-/2 ftexprinting - , chate-Verhaltensanalytik – MKS12 antwortsverhaltensfeedback – MSA13 – multi---Schichtkorrelation – MSSK15 und mehr – MSR16
Wave---basierte PipelineDetektoren, die in Abhängigkeitswellen laufen, ., Welle, 0, keine Abhängigkeiten, parallel ausgeführte ), spätere Wellen lösen nur dann aus, wenn frühere Signale eine tiefere Analyse rechtfertigen..,
SQLite-Speicher:" A botdetection.db Datei auto--Creates für gelernte Muster und Gewichte-.Created No setup
In---Prozess-ÄhnlichkeitssucheHNSW Index für die Suche nach ähnlichen Bot-Signaturen
Heuristische WertungEigenschaften, die pro Anfrage extrahiert wurden, werden durch ein leichtes im --Prozessmodell gewertet.

All dies läuft in unter „1" Millisekunde pro Anfrage auf Rohstoff-Hardware... nur für die CPU... keine GPU...

Jede Anfrage hat jetzt Erkennungsergebnisse über HttpContext erweiterungen

app.MapGet("/", (HttpContext ctx) => Results.Ok(new
{
    isBot = ctx.IsBot(),
    probability = ctx.GetBotProbability(),     // 0.0-1.0: how likely it's a bot
    confidence = ctx.GetDetectionConfidence(),  // 0.0-1.0: how certain the system is
    type = ctx.GetBotType()?.ToString(),
    name = ctx.GetBotName()
}));

Detektion läuft, aber nichts blockiert – .-Sie entscheiden, was mit den Ergebnissen zu tun ist.

Blockieren Sie alle Bots.,. Ganze App

Wenn Sie gerade Bots von Ihrer gesamten Anwendung sperren möchten, keine per-per--endpoint config-, keine Attribute - es ist eine Zeile JSON-:.

{
  "BotDetection": {
    "BlockDetectedBots": true
  }
}

Dass ,' , es , . , Detektierte Bots über Ihrem Block , - , Vertrauensschwelle erhalten ein , ,403 , ( ,MinConfidenceToBlock Standardwerte für 0.8Googlebot,Bingbot),C Social Media Previews Facebook,C Twitter/CXC),C und Überwachung Bots UberwachungszeitRoboter,C Pingdom)C sind per Default erlaubt -, weil Sie fast sicher wollen, dass diese

Oder die gleiche Sache im Code-Code, keine Konfigurationsdatei benötigt

builder.Services.Configure<BotDetectionOptions>(o =>
{
    o.BlockDetectedBots = true;
    o.MinConfidenceToBlock = 0.8;           // only block when confident
    o.AllowVerifiedSearchEngines = true;     // Googlebot, Bingbot through
    o.AllowSocialMediaBots = true;           // Facebook, Twitter previews through
    o.AllowMonitoringBots = true;            // UptimeRobot, Pingdom through
});

Minimales API-Beispiel Das komplette Beispiel

Hier ist ein komplettes ,, , Arbeits API mit Per-- , Endpoint Bot Schutz , . , Dies ist die gesamte Program.cs:

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

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

// Detection results available, no blocking
app.MapGet("/", (HttpContext ctx) => Results.Ok(new
{
    isBot = ctx.IsBot(),
    probability = ctx.GetBotProbability(),
    confidence = ctx.GetDetectionConfidence(),
    type = ctx.GetBotType()?.ToString(),
    name = ctx.GetBotName()
}));

// Block all bots
app.MapGet("/api/data", () => Results.Ok(new { data = "sensitive" }))
   .BlockBots();

// Allow search engines (Googlebot, Bingbot, Yandex)
app.MapGet("/products", () => Results.Ok(new { catalog = "public" }))
   .BlockBots(allowSearchEngines: true);

// Allow search engines + social media previews (Facebook, Twitter/X)
app.MapGet("/blog/{slug}", (string slug) => Results.Ok(new { post = slug }))
   .BlockBots(allowSearchEngines: true, allowSocialMediaBots: true);

// Health check: monitoring bots allowed (UptimeRobot, Pingdom)
app.MapGet("/health", () => Results.Ok("healthy"))
   .BlockBots(allowMonitoringBots: true);

// Humans only - blocks ALL bots including verified crawlers
app.MapPost("/api/submit", () => Results.Ok(new { submitted = true }))
   .RequireHuman();

// High-confidence blocking only (reduces false positives)
app.MapGet("/api/lenient", () => Results.Ok("data"))
   .BlockBots(minConfidence: 0.9);

// Geo + network blocking (needs GeoDetection contributor)
app.MapPost("/api/payment", () => Results.Ok("ok"))
   .BlockBots(blockCountries: "CN,RU", blockVpn: true, blockDatacenter: true);

// Honeypot: deliberately allow scrapers in
app.MapGet("/honeypot", () => Results.Ok("welcome"))
   .BlockBots(allowScrapers: true, allowMaliciousBots: true);

// Dev diagnostics
app.MapBotDetectionEndpoints();

app.Run();

Jede .BlockBots() Anrufblöcke alle Bot-Typen per Default – .-Sie entscheiden sich für bestimmte Typen in der mit der Allow* Parameter: Die Idee wird verweigert-von:-Default: , Weiße Liste der guten

Bot-Typen, die Sie zulassen können

Parameter für das, was es erlaubt, warum Sie es verwenden |-----------|---------------|-----------------| | allowSearchEngines Googlebot: ,Bingbot:,BYNDEX SEO – -Sie möchten indexiert werden | allowSocialMediaBots Facebook Twitter Twitter LinkedIn Vorschau auf den Link , Offene Graphenkarten | | allowMonitoringBots BetriebszeitRoboter,B Pingdom,B StatusCake Gesundheitskontrollen,B Betriebszeitüberwachung | allowAiBots GPTBot, ClaudeBot, ClaudeBotMSK2 , Google, - , Erweitert , MSC4 , Opt-- , um AI-Training , | , | allowGoodBots Zuführungsleser ,-Link-Checker Benachteiligte Automatisierung | allowVerifiedBots Verifizierte Crawler von -Verstärkter Automatisierung | allowScrapers SemrushBot - Honeypots - SEO-Forschung | allowMaliciousBots Bekannte schlechte Akteure | minConfidence | (-Schwellenwert Nur blockieren, wenn das System sehr sicher ist.

MVC-Steuerungsmerkmale

Gleiche Detektions-Pipeline - Schutz durch Attribute - .

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

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

Die Attribute

[ApiController]
[Route("[controller]")]
public class ProductsController : ControllerBase
{
    // No protection - detection runs but nothing blocks
    [HttpGet]
    public IActionResult List() => Ok(new { products = "all" });

    // Block all bots, allow search engines
    [HttpGet("catalog")]
    [BlockBots(AllowSearchEngines = true)]
    public IActionResult Catalog() => Ok(new { catalog = "indexed" });

    // Block all bots, allow search engines + social previews
    [HttpGet("{id:int}")]
    [BlockBots(AllowSearchEngines = true, AllowSocialMediaBots = true)]
    public IActionResult Detail(int id) => Ok(new { id });
}

// Entire controller: humans only
[ApiController]
[Route("[controller]")]
[RequireHuman]
public class CheckoutController : ControllerBase
{
    [HttpPost("cart")]
    public IActionResult AddToCart() => Ok();

    [HttpPost("pay")]
    public IActionResult Pay() => Ok();
}

// Infrastructure endpoints
[ApiController]
[Route("[controller]")]
public class InfraController : ControllerBase
{
    // Skip detection entirely
    [HttpGet("health")]
    [SkipBotDetection]
    public IActionResult Health() => Ok("ok");

    // Monitoring bots allowed
    [HttpGet("status")]
    [BlockBots(AllowMonitoringBots = true)]
    public IActionResult Status() => Ok(new { uptime = "99.9%" });
}

Geografisches Blockieren des Netzwerks

Diese arbeiten sowohl an MVC-Attributen als auch an Minimal API-Filtern.Sie benötigen den GeoDetection Contributor für Signaldaten.

// Block countries
[BlockBots(BlockCountries = "CN,RU,KP")]
public IActionResult SensitiveApi() => Ok();

// Country whitelist - only these allowed
[BlockBots(AllowCountries = "US,GB,DE,FR")]
public IActionResult DomesticOnly() => Ok();

// Block VPNs + proxies (anti-fraud)
[BlockBots(BlockVpn = true, BlockProxy = true)]
public IActionResult Payment() => Ok();

// Block datacenter IPs + Tor
[BlockBots(BlockDatacenter = true, BlockTor = true)]
public IActionResult FormSubmission() => Ok();

// Combine: SEO-friendly + geo block + VPN block
[BlockBots(AllowSearchEngines = true, BlockCountries = "CN,RU", BlockVpn = true)]
public IActionResult ProtectedContent() => Ok();

Jenseits von Block-/-Aktionspolitiken

Binärblock – /-allow ist einfach, aber begrenzt –.-Aktionspolitik getrennt was Sie entdecken von Wie Sie reagierenDefinieren Sie die Antwortstrategien in config.,.orden Sie sie den Endpunkten zu.

Appsettings.-json

{
  "BotDetection": {
    "BotThreshold": 0.7,
    "ActionPolicies": {
      "api-block": {
        "Type": "Block",
        "StatusCode": 403,
        "Message": "Bot traffic is not allowed."
      },
      "api-throttle": {
        "Type": "Throttle",
        "BaseDelayMs": 500,
        "MaxDelayMs": 5000,
        "ScaleByRisk": true,
        "JitterPercent": 0.3
      },
      "shadow-mode": {
        "Type": "LogOnly",
        "AddResponseHeaders": true,
        "LogFullEvidence": true
      }
    }
  }
}

Richtlinien den Endpunkten zuweisen

// Bots get progressively slower responses (they don't know they're being throttled)
[BotPolicy("default", ActionPolicy = "api-throttle")]
public IActionResult Browse() => Ok();

// Hard block
[BotPolicy("default", ActionPolicy = "api-block")]
public IActionResult Confirm() => Ok();

// Shadow mode: log everything, block nothing (deploy first, tune later)
[BotPolicy("default", ActionPolicy = "shadow-mode")]
public IActionResult PublicApi() => Ok();

Fünf Richtlinientypen Block ,(,HTTP , 403),, Throttle (-Verzögerungen des Stealths Challenge (-CAPTCHA-/-proof---of---work-MSC4- Redirect Honeypot-Falle LogOnly Der Schatten-Modus von (, siehe Maßnahmenpolitiken für die vollständige Referenz

Shadow-Modus ist der empfohlene Startpunkt...Deploy Detection.,.Beobachten Sie die Ergebnisse.MSC2. dann Sperren beginnen

Was man umsonst bekommt

Jede Anfrage nach UseBotDetection() hat diese Erweiterungen verfügbar auf HttpContext:

// Am I talking to a bot?
context.IsBot()                    // true if probability >= threshold
context.IsHuman()                  // inverse
context.IsSearchEngineBot()        // Googlebot, Bingbot, etc.
context.IsVerifiedBot()            // DNS-verified bots
context.IsMaliciousBot()           // known bad actors

// How bad is it?
context.GetBotProbability()        // 0.0-1.0: likelihood of being a bot
context.GetDetectionConfidence()   // 0.0-1.0: how certain the system is
context.GetRiskBand()              // Low, Elevated, Medium, High
context.GetRecommendedAction()     // Allow, Challenge, Throttle, Block

// What is it?
context.GetBotType()               // BotType enum
context.GetBotName()               // "Googlebot", "Scrapy", etc.

// Full breakdown
var result = context.GetBotDetectionResult();

Zwei unabhängige Partituren sind hier von Bedeutung. Bot-Wahrscheinlichkeit Wie wahrscheinlich ist dies ein Bot-?) und Detektionssicherheit Wie sicher ist das System? Mensch Oder Sie können eine verdächtige Anfrage sehen, aber niedriges Vertrauen haben, weil nur ein Detektor ran.

Signal---basierte Filterung

Über Bot-Typen hinaus: ,-StyloBot setzt Signale von seinen Detektoren frei..-Sie können Endpunkte auf der Grundlage spezifischer Signalwerte filtern.-- für Minimal API und MVC-.-

Minimale API

// Block VPN traffic
app.MapPost("/api/payment", () => Results.Ok())
   .BlockIfSignal(SignalKeys.GeoIsVpn, SignalOperator.Equals, "True");

// Block datacenter IPs
app.MapPost("/api/submit", () => Results.Ok())
   .BlockIfSignal(SignalKeys.IpIsDatacenter, SignalOperator.Equals, "True");

// Only allow US traffic
app.MapGet("/api/domestic", () => Results.Ok())
   .RequireSignal(SignalKeys.GeoCountryCode, SignalOperator.Equals, "US");

// Block high-confidence bots by heuristic score
app.MapGet("/api/premium", () => Results.Ok())
   .BlockIfSignal(SignalKeys.HeuristicConfidence, SignalOperator.GreaterThan, "0.9");

MVC

[BlockIfSignal(SignalKeys.GeoIsVpn, SignalOperator.Equals, "True")]
public IActionResult Payment() => Ok();

[RequireSignal(SignalKeys.GeoCountryCode, SignalOperator.Equals, "US")]
public IActionResult DomesticOnly() => Ok();

Einlesen von Signalen

app.MapGet("/debug", (HttpContext ctx) =>
{
    var country = ctx.GetSignal<string>(SignalKeys.GeoCountryCode);
    var isVpn = ctx.GetSignal<bool>(SignalKeys.GeoIsVpn);
    var isDc = ctx.IsDatacenter();
    var heuristic = ctx.GetSignal<double>(SignalKeys.HeuristicConfidence);

    return Results.Ok(new { country, isVpn, isDc, heuristic });
});

Vollständige Signalreferenz Signale und benutzerdefinierte Filter.

Es zu testen

# Normal browser request → low bot score
curl -H "Accept: text/html" -H "Accept-Language: en-US" \
  -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
  http://localhost:5090/

# Googlebot → allowed where AllowSearchEngines=true
curl -A "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)" \
  http://localhost:5090/products

# Scraper → blocked by .BlockBots()
curl -A "Scrapy/2.7" http://localhost:5090/api/data

# Full detection breakdown → shows all signals and per-detector contributions
curl http://localhost:5090/bot-detection/check

# Simulate bot types via test mode header
curl -H "ml-bot-test-mode: malicious" http://localhost:5090/bot-detection/check
curl -H "ml-bot-test-mode: scraper" http://localhost:5090/api/data

Das /bot-detection/check Endpoint ist dein Entwicklungsfreund. Es gibt jedes Signal von jedem Detektor zurück.

Wie es skaliert von Datei zum vollen Stack

Dies ist das Design-Prinzip, das am meisten zählt jede Ebene verwendet die gleiche DetektionspipelineSie werden niemals den Schutzcode neu schreiben, indem Sie die Infrastruktur um denselben Kern herum hinzufügen.

Tier Tier, wo Sie beginnen

Your App + AddBotDetection()
    └── SQLite (auto-created botdetection.db)
    └── In-process [HNSW](https://en.wikipedia.org/wiki/Hierarchical_navigable_small_world_graphs) similarity search
    └── 21 detectors, <1ms per request
    └── No external services

Gut für Einzel-App ,, , , <100 , K-Anfragen , / , Tag , , , Beginnen ,.

Tier .2:-Geoerkennung hinzufügen

Fügen Sie Geo-Routing plus die geo contributor.

builder.Services.AddBotDetection();
builder.Services.AddGeoRoutingWithDataHub(); // free local GeoIP DB (no account)
builder.Services.AddGeoDetectionContributor(options =>
{
    options.FlagVpnIps = true;
    options.FlagHostingIps = true;
});

Wenn IP-Geolokalisierung neu ist Hintergrund der GeoIP und DataHub GeoIP-Datensatz sind gute Ausgangspunkte ,. , DataHubCsv lädt eine kostenlose .~27 ,MB IP-Datenbank auf den ersten Lauf und hält es wöchentlich aktualisiert , . , Alle Lookups sind lokal , - , keine per...- , HTTP-Anrufe anfordern ,. , Für die Stadt ,- , Levelpräzision , , , verwenden MaxMind GeoLite-2.

Jetzt erhalten Sie geo-Signale (Ausland,Ausland VPN,Ausgangspunkt,Auszugspunkt ,Ausrichtungspunkt-Erkennung)Ausrichtung und Bot Herkunftsnachweis (Ausführungspunkt eines chinesischen Rechenzentrums BlockCountries, BlockVpn, BlockDatacenter, BlockTor Parameter aktivieren - .-

Tier Kategorie: PostgreSQL ZeitskalaDB

SQLite durch PostgreSQL für Multi---Server-Shared Learning ersetzen und hinzufügen ZeitskalaDB (-A PostgreSQL-Erweiterung für Zeit--Seriendaten)-Für Analysen:-

builder.Services.AddBotDetection();
builder.Services.AddStyloBotDashboard();
builder.Services.AddStyloBotPostgreSQL(connectionString, options =>
{
    options.EnableTimescaleDB = true;
    options.RetentionDays = 90;
    options.CompressionAfter = TimeSpan.FromDays(7);
});

# docker-compose.yml
services:
  timescaledb:
    image: timescale/timescaledb:latest-pg16
    environment:
      POSTGRES_DB: stylobot
      POSTGRES_USER: stylobot
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - timescale-data:/var/lib/postgresql/data

  app:
    build: .
    environment:
      ConnectionStrings__BotDetection: "Host=timescaledb;Database=stylobot;Username=stylobot;Password=${DB_PASSWORD}"
    depends_on:
      timescaledb:
        condition: service_healthy

TimescaleDB gibt Ihnen hypertable Partitionierung.Automatische Komprimierung...... ..(90-95%. Speicherreduzierung nach... Tagen.. .-),. kontinuierliche Aggregate für sub...

Gut für Mehrmals Server für , benötigen Analyse-Dashboard.

Tier: Voller Stack - Gateway - Qdrant - LLM

Internet → Caddy (TLS) → Stylobot Gateway ([YARP](https://microsoft.github.io/reverse-proxy/)) → Your App
                              │
                              ├── TimescaleDB (analytics, learning)
                              ├── [Qdrant](https://qdrant.tech/documentation/) (vector similarity search)
                              └── LLamaSharp CPU [LLM](https://en.wikipedia.org/wiki/Large_language_model) (bot classification)

Das Gateway ist ein eigenständiger Docker-Containerscottgal/stylobot-gatewayDie Erkennung auf allen Traffic- und Forwards-Ergebnissen läuft als HTTP-Header. Ihre App liest Header. **kein SDK benötigt wird.**Wenn " ist nicht bekannt " ist, denken Sie an "umgekehrter Proxy das vor Ihrer App sitzt und Sicherheit hinzufügt

services:
  gateway:
    image: scottgal/stylobot-gateway:latest
    environment:
      DEFAULT_UPSTREAM: "http://app:8080"
      StyloBotDashboard__PostgreSQL__ConnectionString: "Host=timescaledb;..."
      StyloBotDashboard__PostgreSQL__EnableTimescaleDB: true
      BotDetection__Qdrant__Enabled: true
      BotDetection__Qdrant__Endpoint: http://qdrant:6334
      BotDetection__Qdrant__EnableEmbeddings: true
      BotDetection__AiDetection__Provider: LlamaSharp
      BotDetection__AiDetection__LlamaSharp__ModelPath: "Qwen/Qwen2.5-0.5B-Instruct-GGUF/qwen2.5-0.5b-instruct-q4_k_m.gguf"

  app:
    build: .
    environment:
      BOTDETECTION_TRUST_UPSTREAM: true

  qdrant:
    image: qdrant/qdrant:latest

  timescaledb:
    image: timescale/timescaledb:latest-pg16

  caddy:
    image: caddy:latest

Ihre App vertraut auf die Gateway-Header von '

// ASP.NET Core
builder.Services.Configure<BotDetectionOptions>(o => o.TrustUpstreamDetection = true);

Oder lesen Sie Kopfzeilen direkt in jeder Sprache.

# Python/Flask
@app.route('/api/data')
def api_data():
    if request.headers.get('X-Bot-Detected') == 'true':
        return jsonify(error='blocked'), 403
    return jsonify(data='sensitive')

// Node.js/Express
app.get('/api/data', (req, res) => {
  if (req.headers['x-bot-detected'] === 'true') {
    return res.status(403).json({ error: 'blocked' });
  }
  res.json({ data: 'sensitive' });
});

Kopfzeilen des Gateways sendet - :

Beispiel für die Verwendung von
`X-Bot-Detected`	`true` ]	-Bot-/-Humanklassifizierung ®	-
`X-Bot-Confidence`	`0.91` Das Vertrauen in die Detektion
`X-Bot-Detection-Probability`	`0.87` Wahrscheinlichkeit des Bot-Tests
`X-Bot-Type`	`Scraper` Kategorie der Bot-Kategorie
`X-Bot-Name`	`AhrefsBot` ]	Identifizierter Bot
`X-Bot-Detection-RiskBand`	`High` Risikoklassifizierung

Was jede Komponente hinzufügt

-Komponente, was es tut
ZeitskalaDB - Series analytics , Empfohlen für die Produktion
Qdrant Vector similarity search -® findet Bots, auch wenn sie rotieren User MS K2®Agenten Optional
LLamaSharp Nur LLM für Bot-Cluster-Nennung und Klassifikationssynthese
Caddy, /, Nginx Beenden von TLS-Dateien Beseitigen von statischen Dateien Berühren Sie Ihren vorhandenen umgekehrten Proxy
Gateway Zentralisierte Detektion für Multi- oder Nicht--.-NET-Backends für multi- und --Service-Architekturen

Wählen Sie Ihr Tier

Starting out?
├── Single ASP.NET app → Tier 1 (two lines of code)
│   └── Need geo blocking? → Tier 2 (one more line)
│       └── Need analytics? → Tier 3 (add PostgreSQL)
└── Multiple apps or non-.NET? → Tier 4 (Gateway)

Bewegen zwischen den Ebenen ist eine DI-Registrierungsänderung... Ihr Endpunktschutzcode... [BlockBots] Attribute: .BlockBots() filtern, die context.IsBot() überprüft, bleibt genau das gleiche, .

Enterprise Hooks

Das Zwei---Linien-Setup ist der Startpunkt... Hier.'.s, was sonst noch für den Produktionseinsatz eingebaut wird.

Response Headers für Debugging

Schalten Sie Detektion Header global ein, so dass Sie das Verhalten überprüfen können, ohne auf diagnostische Endpunkte zu treffen.

{
  "BotDetection": {
    "ResponseHeaders": {
      "Enabled": true,
      "HeaderPrefix": "X-Bot-",
      "IncludeConfidence": true,
      "IncludeDetectors": true,
      "IncludeProcessingTime": true,
      "SkipPaths": ["/health"]
    }
  }
}

Jede Antwort bekommt X-Bot-Detected, X-Bot-Confidence, X-Bot-Processing-MsNützlich für Rand-Routing-Entscheidungen in Caddy, /, Nginx, und zum Debuggen in dev,., Deaktivieren in der Produktion oder Beschränkung auf vertrauenswürdige Netzwerke

Herausforderungs-Politiken vor Blockierung)

Don.'.t Block auf Ungewissheit......herausforderung statt......... StyloBot hat fünf gebaute -.in Herausforderungstypen...

{
  "BotDetection": {
    "ActionPolicies": {
      "challenge-on-uncertain": {
        "Type": "Challenge",
        "ChallengeType": "JavaScript"
      },
      "captcha-gate": {
        "Type": "Challenge",
        "ChallengeType": "Captcha",
        "RedirectUrl": "/captcha"
      },
      "proof-of-work": {
        "Type": "Challenge",
        "ChallengeType": "ProofOfWork"
      }
    }
  }
}

Herausforderungstypen Redirect Seite zur Herausforderung schicken Inline (,HTML interstitial, ),, JavaScript ,( ,JS-Beweis ,- ,von der Arbeit , ), , Captcha, ProofOfWork Zuweisen an Endpunkte über [BotPolicy]:

[BotPolicy("default", ActionPolicy = "challenge-on-uncertain")]
public IActionResult Submit() => Ok();

IP-Listen zulassen

Global erlauben und leugnen Listen für bekannte IPs und CIDR Bereich:

{
  "BotDetection": {
    "WhitelistedIps": ["203.0.113.10/32", "198.51.100.0/24"],
    "BlacklistedIps": ["1.2.3.4", "5.6.7.0/24"]
  }
}

Whitelisted IPs überspringen Detektion vollständig... Blacklisted IPs erhalten sofort blockiert... beide unterstützen CIDR-Notation...

OpenTelemetrie Metrics

StyloBot setzt Metriken über System.Diagnostics.Metricskompatibel mit OpenTelemetrie, Prometheus, Grafana.,- und beliebige ..-NET-Metriken

builder.Services.AddOpenTelemetry()
    .WithMetrics(metrics => metrics.AddMeter("Mostlylucid.BotDetection"));

Verfügbare Metriken

Metrisches Messgerät Typ	, was es misst
`botdetection.requests.total` Gesamtanfragen verarbeitet
`botdetection.bots.detected` Anfragen, die als Bots eingestuft werden
`botdetection.humans.detected` Anfragen, die als human eingestuft werden
`botdetection.errors.total` Fehler bei der Erkennung von Pipeline-Fehlern
`botdetection.detection.duration` Histogramm-Latenz der Erkennungslatenz
`botdetection.confidence.average` Durchschnittliche Konfidenzintervalle
`botdetection.cache.patterns.count` Anzahl der eingezäunten Muster

Voreinstellungen für Routengruppen

Bot-Schutz auf ganze Routengruppen anwenden, anstatt per---Endpunkt zu wiederholen.:

// All /api routes: block bots, allow search engines
var api = app.MapGroup("/api").WithBotProtection(allowSearchEngines: true);
api.MapGet("/products", () => "data");
api.MapGet("/categories", () => "cats");

// Secured routes: humans only
var secure = app.MapGroup("/secure").WithHumanOnly();
secure.MapPost("/submit", () => "ok");
secure.MapPost("/checkout", () => "done");

// Individual endpoints can still override
api.MapGet("/special", () => "overridden")
   .BlockBots(allowSearchEngines: true, allowSocialMediaBots: true);

WithBotProtection() nimmt die gleichen Parameter wie .BlockBots()Beeindruckend, aber absichtlich immer Blöcke Schaber und bösartige Bots auf Gruppenebene allowScrapers / allowMaliciousBots auf Gruppen WithHumanOnly() ist die Gruppe entspricht der .RequireHuman().

Benannte Richtlinien auf Minimal API

Verwendung .BotPolicy() um benannte Aktionsrichtlinien Minimalen API-Endpunkten zuzuordnen [BotPolicy] tut für MVC-:

// Throttle bots on this endpoint
app.MapGet("/api/data", () => "sensitive")
   .BotPolicy("default", actionPolicy: "api-throttle");

// Block with high-confidence threshold
app.MapPost("/api/submit", () => "ok")
   .BotPolicy("strict", actionPolicy: "block", blockThreshold: 0.8);

Rückkopplungs-API

Meldung falscher Positive und Negative an das System über POST /bot-detection/feedback:

# Mark a detection as a false positive (bot detected but was actually human)
curl -X POST http://localhost:5090/bot-detection/feedback \
  -H "Content-Type: application/json" \
  -d '{"outcome": "Human", "notes": "Known partner integration"}'

# Mark a missed bot (human detected but was actually a bot)
curl -X POST http://localhost:5090/bot-detection/feedback \
  -H "Content-Type: application/json" \
  -d '{"outcome": "Bot", "notes": "Automated scraper spotted in logs"}'

Der Endpunkt gibt zurück, ob das Feedback ein falsch-positives oder falsch-negatives Verhältnis zum aktuellen Erkennungsergebnis darstellt.

Gateway Trust Boundary mit HMAC Signing

Basis-Vertrauen - Netzwerk - Isolation nur auf der Ebene von ):

{
  "BotDetection": {
    "TrustUpstreamDetection": true
  }
}

HMAC.-.signiertes Vertrauen

{
  "BotDetection": {
    "TrustUpstreamDetection": true,
    "UpstreamSignatureHeader": "X-Bot-Signature",
    "UpstreamSignatureSecret": "base64-encoded-shared-secret"
  }
}

Wann UpstreamSignatureHeader und UpstreamSignatureSecret sind gesetzt ,, , die Middleware überprüft ein HMAC---SHAM256- Signatur vor dem Vertrauen in die vorgelagerten Header

Verwenden Sie dies derzeit für Benutzerdefinierte Gateway-Integrationen Das eingebaute -in Stylobot-Gateway führt Bot---Detektions-Header vor, sendet HMAC-Signatur Header aber noch nicht aus..

Erforderliche signierte Kopfzeilen

X-Bot-Signature ](-Basis ®64-HMAC-)-
X-Bot-Detection-Timestamp (-Unix-Epoche Sekunden ,- UTC-)-

Unterzeichneter Vertrag

payload = X-Bot-Detected + ":" + X-Bot-Confidence + ":" + X-Bot-Detection-Timestamp
signature = Base64(HMACSHA256(payload, base64Decoded(UpstreamSignatureSecret)))

Wichtig Nur dann Vertrauen aktivieren, wenn Ihr Backend hinter einem vertrauenswürdigen Reverse Proxy liegt. X-Bot-Detected: false und umgehen alle Detektionen... in der Produktion...

Sicherstellen, dass das Backend nicht öffentlich zugänglich ist
Streifen X-Bot-* Header an Ihrem Edge Proxy, bevor sie das Gateway erreichen
Verwenden Sie HMAC-Signatur für die Verteidigung, auch mit Netzwerkisolation

Was StyloBot nicht ist

Es lohnt sich, explizit zu sein.

Kein WAF-. StyloBot doesn''-Inspektion von Nutzlasten für SQL-Injektion oder XSSD.-Inspection Wer macht die Anfrage nicht Was ist sie ,' , die senden .. , Verwenden Sie es neben einem WAF , , , nicht anstelle von one ?. .
Kein CAPTCHA-Bauernhof Herausforderungen gibt es nicht, aber die Design-Philosophie ist Detektion. Vorher zu entscheiden, ob man anfechtet
Nicht nur im Umkreis von . Detektion läuft per---Endpunkt mit per---Endpoint-Richtlinien /products Suchmaschinen erlauben, während /api/checkout erfordert Menschen , . , Dies ist Endpunkt Semantik , nicht Firewall-Regeln ,. ,
Nicht wolkenabhängig Alles läuft selbst, --integriert, .-Qdrant,,-TimescaleDB, ,-LLM, alle optional, MSSK5-Der Kern ist zwei Zeilen Code und eine SQLite-Datei..-
Ungewissheit Zwei unabhängige Werte Wahrscheinlichkeit +...Vertrauen )" bedeuten, dass Sie eine Bot-"" unterscheiden können, wahrscheinlich ein Bot-," wir ' sind sicher "" von " wahrscheinlich ein bot-," aber wir ' erraten "." Die meisten Systeme geben Ihnen eine Nummer und Hoffnung für das beste ."

Was kommt als nächstes?

Beginnen Sie mit :

NuGet-:- dotnet add package Mostlylucid.BotDetection
Gateway Docker-: docker pull scottgal/stylobot-gateway
Vollständige Dokumente
Live-Demo, MSK, StyloBot, .,net