# **StyloBot: mahdollisimman yksinkertainen eikä yhtään yksinkertaisempi M SK1osuus 3)**

*Enterprise bot detection shouldn't require a PhD in infrastructure (or thousands per month in expenditure to use!). Two lines of codeM SK3 zero external servicesMST4 and youMSC5re running MSV6up up toMS) \21\ detectors in milliseconds on every request to every endpoint\MST9\*

**[Luettelo osasta 1: StyloBot: Puolustus Scrapereiden vastaisesti](https://www.mostlylucid.net/blog/botdetection-introduction)**

**[Luettelo osasta 2: Miten botit ovat tulleet älykkäämmiksi](https://www.mostlylucid.net/blog/botdetection-part2-signature-pipeline-and-stylobot-architecture)**

**[👉 See It LiveM SK1 StyloBot.net](https://stylobot.net)** - Todellisen tuotantojärjestelmän käyttö varhaisessa vaiheessa

<!--category-- ASP.NET, Bot Detection, Security, Architecture -->
<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]

---


## Ajatus

Einstein sanoi luultavasti:,, ", Kaikki on tehtävä mahdollisimman yksinkertaiseksi.,, mutta ei yksinkertaisempaa.." Tämä on StyloBotin suunnitteluperiaate, yhdentymismalli ' ja .

Osat 1 ja 2 katto *miksi* bot-tutkimukset ja *miten havaitsemisputki toimii*. Tämä ilmoitus kattaa *kuinka vähän koodia todella tarvitaan* - ja se, miten sama järjestelmä laajennetaan yhdestä ainoasta \-\file-appista täydelliseen tuotantoportaaliin \TimescaleDB \ , \ Qdrant vector search \

Keskeinen käsitys: **jokaisella tasolla käytetään samaa havaitsemisputkea**. Ette vaihta puitteita kasvaessanne . Etteko lisää varastointia ja rikastamista saman ytimen ympärille

---


## Kaksi koodia

Tämä on ehdoton vähimmäismäärä. Ei config-asiakirjaa , ei tietokannan perustamista, ei API-kysymyksiäM SK3 ei Docker- konttejaMSC4

```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();
```

Mitä juuri tapahtui?

- **21-detektorit** kirjallinen: UserAgent-muodonvaihdon, otsikon johdonmukaisuusMSC2 IP datacenterin havaitseminen , käyttäytymisanalyysiM SK4 TLS-silmäjäljittäminen MST5 JAMSV6JAMSP7 TCPMSL8 IP-silmajäljityksetMSR9 HTTPMS/2 silmjäljitysM, Cache-käytännön analyysi(Cache behavior analysis)
- **Wave-pohjainen kaasuputki**: Detektorit toimivat riippuvuusaaleissa . Aalto | 0 | \ ( \ ei ole riippuvaisia \) \ toteutetaan rinnakkain ♫ . \ myöhemmät aaltot aktivoidaan vain silloin, kun aiempien signaalien perusteella voidaan analysoida syvällisemmin ♫
- **SQLite-tietokanta**: `botdetection.db` auto-lomake-luonnostaa opittuja malleja ja painoja
- **In-prosessin samankaltaisuuden haku**: HNSW-indeksi samankaltaisten bot-signaattoreiden löytämiseksi
- **Heuristinen tulos**:

Kaikki tämä käy läpi **alle 1 millisekundin** tavaroiden laitteistoa koskevan pyynnön mukaan. vain CPU , ei GPU

Jokaisen pyynnön havaitsemistulokset ovat nyt saatavilla `HttpContext` laajennukset:

```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()
}));
```

Tunnus toimii, mutta mitään ei pysäytetä. Te päätätte, mitä tehdä tulosten kanssaM SK1

---


## Blokkaa kaikki botit, Koko sovellus

Jos haluatte vain estää robotit koko käytännöstänne, - ei per- loppupisteen configM SK2 ei tunnusia - seMSC4 yksi JSONin rivi

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

Se's itM SK1 Tunnetut botit yli ryhmäänne -luottamuksen kynnysarvo saa 403 (`MinConfidenceToBlock` defaults to `0.8`). hakukoneet | ( | Googlebot |, | Bingbot ♫ ), | sosiaalisen median esittelyt ♫( | Facebook ♫

Tai sama asia kodessa, ei tarvita config-asiakirjaa:

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

Tämä on "I don't want to think about it " modeM SK3 Detection runsMSC4 bots get blockedMST5 good crawlers get throughMSV6 Move to perMSR7endpoint control when you need itMSL8

---


## Minimal API: täydellinen esimerkki

Siihen sisältyy täydellinen ', , ja per- sekä loppupistebot-suoja. `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();
```

Joka vuosi `.BlockBots()` puhelukiellot **kaikki** bot types by default. Te valitsette erityiset tyypit *sisällytetään* neuvoston `Allow*` parametrit. Ajatuksena on kieltää

### Bot-tyypit, joita voitte sallia

| Parameter | Se, mitä se sallii
|-----------|---------------|-----------------|
| `allowSearchEngines` | Googlebot
| `allowSocialMediaBots` | FacebookM SK1 Twitter/XMSC3 LinkedIn | Link previewsMST5 Open Graph cards SSK6
| `allowMonitoringBots` | UptimeRobot, PingdomM SK2 StatusCake | Terveydentarkastukset
| `allowAiBots` |, GPTBot, ,, ClaudeBot, M SK2, Google,-, laajennettu |, opt, - AI-koulutusta varten
| `allowGoodBots` | Feed-reaktoritM SK1 linkkitarkastajat | Benign-automaatti
| `allowVerifiedBots` | DNS
| `allowScrapers` | AhrefsBot
| `allowMaliciousBots` | Tunnetut huonot toimijoiden joukot
| `minConfidence` | *(kynnys* | Suljetaan vain silloin, kun järjestelmä on hyvin varma

---


## MVC-johdon käyttäjät: Merkitteet

Sama havaitsemisjohto, ominaisuuksien kautta suojeleminenM SK1

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

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

### Luettelo ominaisuuksista

```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%" });
}
```

### Maantieteellinen & Verkon sulkeminen

Nämä koskevat sekä MVC-ominaisuuksia että Minimal API-filterejä. Ne edellyttävät GeoDetection -koordinaattoria signaalitietojen saamiseksi.

```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();
```

---


## Päätöslauselman ulkopuoliset toimintalinjat

Binaariblokti/ sallitaan yksinkertainen mutta rajallinenM SK1 Toimintapolitiikat erillään *mitä havaitsee* peräisin *miten te reagoitte*. Defines response strategies in config

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

### Politiikat kohdennetaan loppukohtiin

```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();
```

Viisi politiikkatyyppiä: `Block` (HTTP `Throttle` (varmuus viivästykset `Challenge` (CAPTCHA/proof--work), `Redirect` ( `LogOnly` (shadow mode [toimintapoliittiset asiakirjat](https://github.com/scottgal/LLMApi/blob/main/Mostlylucid.BotDetection/docs/action-policies.md) täydelliseen viittaukseen.

Suositus lähtökohdaksi on "shadow mode". *sitten* aloitetaan sulkeminen.

---


## Mitä saatte ilmaiseksi

Jokaisen pyynnön jälkeen `UseBotDetection()` on näitä laajennuksia saatavilla `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();
```

Kaksi riippumatonta tulosta ovat tässä asiassa tärkeitä: **bot-mahdollisuus** (mikä todennäköisyys on, että tämä on roboti **havaitsemisluottamus** ( miten varma järjestelmä on *inhimillinen* ( vähäinen todennäköisyysM SK1 suuri luottamus ). Toisin sanoen voitte nähdä epäilyttävän pyynnön, mutta luottamuksenne on heikko, koska vain yksi detektaattori toimi

---


## Signal-perusteinen filtrointi

Sen lisäksi, että bottityypit , StyloBot paljastaa 100+ tallennettuja signaaleja detekttoreistaan. Voitte filtroida loppukohtia erityisten signaaliarvojen perusteella - sekä Minimal API:n että MVC:n osalta

### Vähimmäis-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();
```

### Luonnollinen viestinlaskelma

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

Täydellinen signaaliohje: [signaalit ja räätälöityt filterit](https://github.com/scottgal/LLMApi/blob/main/Mostlylucid.BotDetection/docs/signals-and-custom-filters.md).

---


## Testoiminen

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

Euroopan unionin `/bot-detection/check` loppupiste on kehityksen ystävänne.

---


## Miten se Scales: Filesta Full Stackiin

Tämä on tärkein suunnitteluperiaate: **jokaisella tasolla käytetään samaa havaitsemisputkea**. Ette koskaan kirjoita suojelukoodia uudelleen.

### Luokitus 1: itsenäinen -määräinenM SK2missä aloitatte)

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

Kaikki 21 havaintolaitteet toimivat aaltoon perustuvalla kaasuputkilla -Väliläisellä pipelinellä.Nopealla jäljittäjälläM SK3Tähteiden havainnollisella jäljittäjällä |( |UserAgent | , | Päällysmerkintöjen jäljitellään rinnakkain Wave-järjestelmässä |, | IP ‐, | Behavioral | , | TLS -silmäjälkien jäljityksellä |m) | toteutetaan rinnakkaisesti Wave-järjestelmään |

**Hyvä :** Yhteinen app, M SK1K-pyynnöt/päivä

### Tason 2: GeoDetection lisääminen

Lisätään geo-reitti ja geo-maksaja:

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

Jos IP geolocation on uusi: [GeoIP:n tausta](https://en.wikipedia.org/wiki/Geolocation_software#IP_address) ja [DataHub GeoIP-tietokokonaisuus](https://datahub.io/core/geoip2-ipv4) ovat hyviä lähtökohtia. DataHubCsv laatii vapaan ~27MB IP-tietokannan ensimmäisessä toiminnassa ja pitää sen ajantasaistettavana viikkoinaM SK2 Kaikki hakut ovat paikallisia - ei perMSC4pyyntää HTTP-puhelujaMST5 kaupungilleMSSK6tasokohtainen täsmällisyys [MaxMind GeoLite2](https://dev.maxmind.com/geoip/geolite2-free-geolocation-data/).

Nyt saatte 20+ maantieteelliset signaalit |( maa | , | VPN ‐, | proxy | МSK4 | Tor ‐ , | tietokeskuksen havaitseminen ) | ja robotin alkuperän todentaminen ♫ ( | Googlebot kiinalaisesta tietokeskuksesta `BlockCountries`, `BlockVpn`, `BlockDatacenter`, `BlockTor` parametrit aktivoivat.

### Taso 3: PostgreSQL + TimescaleDB

Pakotetaan SQLite PostgreSQLin avulla monien -verkon yhteistä oppimista varten ja lisätään [AikatauluDB](https://docs.timescale.com/) (aikaa koskeva PostgreSQL-lisäys-sarjatietojaM SK2analyysiä varten

```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 antaa hypertablen jakautumisen, automaattinen kompressio (90-95% varastointien vähentäminen 7 päivien jälkeenM SK3 alakohtaisten aggregateiden jatkuvat aggregatit

**Hyvä :** >100K-pyynnöt, /päivä,, useat serverit, M SK3 tarvitsee analyyttistä paneelia, .

### Taso 4: Täysinrunkoinen - Portaali | + | 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)
```

Portaali on standalone Docker container (`scottgal/stylobot-gateway`), joka suorittaa havaitsemisen kaikista liikenteestä ja siirtää tulokset HTTP:n otsikoiksiM SK1 Oman appin lukee otsikot - **ei tarvita SDK:tä, mikä tahansa kieli**. Jos "\gateway\"\ on tuntematon[reverse proxy](https://en.wikipedia.org/wiki/Reverse_proxy) , joka on appin etupuolella ja lisää turvallisuutta

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

sovelluksenne luotti verkonhaltijaan'otsakeihinM SK1

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

Vai lukekaa otsikot suoraan missä tahansa kielessä:

```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' });
});
```

**Kapteenin lähettämät otsikot:**

| Otsake SSK1 Esimerkki | Tavoite S|
|--------|---------|---------|
| `X-Bot-Detected` | `true` | BotM SK1ihmisluokitus
| `X-Bot-Confidence` | `0.91` | havaitsemisluottamus
| `X-Bot-Detection-Probability` | `0.87` | Bot-mahdollisuus
| `X-Bot-Type` | `Scraper` | Bot-luokka
| `X-Bot-Name` | `AhrefsBot` | tunnistettu bot |
| `X-Bot-Detection-RiskBand` | `High` | Riskin luokittelu |

### Se, mitä jokainen osatekijä lisää

| Osiaan | Mitä se tekee | | | välttämättömiä
|-----------|-------------|-----------|
| **AikatauluDB** | AikaMSC1sarjaanalyysit,kompressoitu varastointiM SK3johdonmukaiset agregaatiot
| **Qdranti** | Vektorin samankaltaisuustutkimus - löytää robotit myös silloin, kun ne pyörivät käyttäjätM SK2Agentsit SSK3 valinnainen PSK4
| **LLamaSharp** | CPUM SK1onnistaan LLM bot-ryhmittymien nimittämiseen ja luokittelusynteesiin | Vaihtoehtoinen |
| **Caddy/Nginx** | TLS:n lopettaminen, statiset asiakirjat | olemassa oleva käänneproxy |
| **Portaali** | Keskitettyä havaitsemista monien \- \app- tai muiden \ -. \NETin backend -järjestelmien osalta.

### Omien eläintenne valinta

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

Tasojen välinen liikkuminen on DI-rekisterin muutos. loppupisteenne suojakoodi M SK1 `[BlockBots]` Attributet, `.BlockBots()` filters, `context.IsBot()` tarkistukset - pysyy täsmälleen samanaM SK1

---


## Enterprise Hooks -yhtiö

- on lähtökohtana sekä . että ', ja tässä on otettu huomioon myös tuotantokäyttöä koskevat seikat.

### Vastauksen otsikot puutteiden korjaamiseksi

Otetaan käyttöön havaitsemista koskevat otsikot maailmanlaajuisesti, jotta voidaan tarkistaa käyttäytymistä puuttumatta diagnostisiin loppukohtiin:

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

Jokainen vastaus saa `X-Bot-Detected`, `X-Bot-Confidence`, `X-Bot-Processing-Ms`, jneM SK1 hyödyllinen Caddyssä tehtyjen etusuuntauspäätösten tekemisessä /Nginx, ja devissä tehtävän parannuskeinojen parissa M SK4 Suljetetaan tuotantoon tai rajoitetaan luottamuksellisiin verkkoihin

### Haasteena olevat toimintalinjat (Yritykset ennen vyöhykettäM SK1

Don' ei pysäytä epävarmuutta M SK1 haastetta sen sijaan. StyloBotilla on viisi built-in challenge-tyyppiä -

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

Haasteentyyppit: `Redirect` (kysymyksiä koskevaan sivuunM SK1 `Inline` (HTML interstitiaali `JavaScript` (JS-todistus `Captcha`, `ProofOfWork` (laskentahaasteM SK1 Assign to endpoints via `[BotPolicy]`:

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

### IP-lupa/Katsaukset kieltäydyt

Maailmanlaajuiset sallivat ja kieltäytyvät luettelot tunnettujen IP:ien osalta sekä [Kansainvälinen huumausainekauppasopimus](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) rajat:

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

Valkoilla listalla olevat IP-osoitteet jättävät havaitsemisen kokonaan huomiotta. Mustalla listalla olevia IP-oikeuksia estetään välittömästiM SK1 Molemmat tukevat CIDR-merkintää.

### OpenTelemetry -metri

StyloBot paljastaa mittasuhteet `System.Diagnostics.Metrics`, yhteensopiva [Avointelemetri](https://opentelemetry.io/docs/), [Prometheus](https://prometheus.io/docs/introduction/overview/), [Grafana](https://grafana.com/docs/), ja kaikki .NET-mittaukset kuluttajat

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

**Käytettävissä olevat mittarit:**

| Metriki | Typo | Mitkä mittaukset SSK3
|--------|------|-----------------|
| `botdetection.requests.total` | Kävijä | Käsiteltyjen pyyntöjen kokonaismäärä SSK2
| `botdetection.bots.detected` | Kävijä | Pyynnöt, jotka ovat luokiteltuja botteiksi
| `botdetection.humans.detected` | Kävijä | Inhimillisesti luokiteltuja vaatimuksia
| `botdetection.errors.total` | Verkonvastaaja | Pääteputken virheet PSK2
| `botdetection.detection.duration` | Histogrammi | havaitsemisvalmius viivästys SSK2ms
| `botdetection.confidence.average` | Gauge
| `botdetection.cache.patterns.count` | Gauge

Nämä ovat ne numerot, joita tarvitsette taulukoille, hälytystoiminnalleM SK1 ja kapasiteetin suunnittelulle . havaitsemisen viivästymishistogrammi antaa mahdollisuuden asettaa SLO:ita. BotMSC4 ihmisen laskentalaitteet antavat liikenteen kokoonpanon ajan mittaan

### Tavalliset etenemisryhmät

Sovelletaan bot-suojaa kokonaisiin reittiryhmiin sen sijaan, että toistetaan kutakin kohtaa

```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()` ottaa samat geo/network/confidence-parameterit kuin `.BlockBots()`, mutta estää tarkoituksellisesti aina scraperit ja haitalliset robotit ryhmätasolla `allowScrapers` / `allowMaliciousBots` ryhmien osalta). `WithHumanOnly()` on ryhmän ekvivalentti `.RequireHuman()`.

### Vähimmäisissä API-ohjelmissa nimettyjä politiikkoja

Käytöstä `.BotPolicy()` nimitettyjen toimintapolitiikkojen myöntäminen vähimmäistason API:n loppupisteille - sama asia `[BotPolicy]` toimii 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);
```

### Feedback API

Valitettavat myönteiset ja kielteiset tiedot palautetaan järjestelmään `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"}'
```

Lopupiste palauttaa sen, edustaako palaute väärä myönteinen tai väärä kielteinen suhteessa nykyiseen havaitsemistulokseen. Tämä on pohja suljettuunM SK1loopin oppimiseen .

### Portaalin luottamuksen raja HMAC:n allekirjoituksella

Kun otetaan käyttöön YARP-portaali, takapiirissänne luetaan etäisyydessä olevia havaitsemista koskevia otsikoita. Tämä on turvallisuutta koskevaa toimenpidettä -tunteellista toimenpiteitä M SK3 teidän on varmistettava, että ainoastaan verkon kautta voidaan asettaa nämä otsikotMSC4

**Perusluottamus**

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

**HMAC- allekirjoitettu luottamus M SK1kryptografinen tarkastus ):**

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

Kun `UpstreamSignatureHeader` ja `UpstreamSignatureSecret` vahvistetaan, ja keskinäinen ohjelmisto tarkistaa [HMAC-](https://datatracker.ietf.org/doc/html/rfc2104) allekirjoitus ennen kuin uskotaan etuvirtaisia otsikoita.

Käyttäkää tätä tällä hetkellä **custom gateway/proxy integraatiot** , jotka lisäävät allekirjoitus otsikot. Rakennettu-Stylobotin verkonkäytävässä etenee robotiM SK2 havaitsemis otsikot , mutta ei vielä lähetä HMAC-signaalin otsikoita

Tarvittavat allekirjoitetut otsikot:

- `X-Bot-Signature` (base64HMACM SK2
- `X-Bot-Detection-Timestamp` (Yhdistyneen kuningaskunnan aikavälin sekuntit

Sopimus allekirjoitetaan:

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

Signatures outside a 5-minute replay window are rejected

**Tärkeää:** Antakaa luottamus vain silloin, kun backend on luotettavan käänteisen proxyn takana. Jos hyökkääjä voi saavuttaa backendin suoraan, he voivat valehdella `X-Bot-Detected: false` ja ohittaa kaikki havainnot. tuotannossaM SK1

- Varmistakaa, että backend ei ole julkisesti saatavilla (Dockerin sisäinen verkko, Kubernetes ClusterIP )
- Tappiot `X-Bot-*` otsakkeet etukäteisvaltuutetussanne ennen kuin ne saapuvat portaaliin
- Käyttäkää HMAC-signointia puolustustarkoituksiin-inM SK1 syvyydessä jopa verkkojen eristämisen yhteydessä

---


## Se, mikä StyloBot ei ole

On syytä olla selvä:

- **Ei WAF.** StyloBot ei ”'” tarkastaa SQL-intryynnistä tai XSS:stä aiheutuvia maksuja. *jotka* esittää pyynnön, ei *mitä* ne' lähettävät . Käyttäkää sitä rinnakkain WAF:n kanssa
- **Ei CAPTCHA-tiloja.** Ongelmapolitiikat ovat olemassa, mutta suunnittelun filosofia on havaitseminen. *ennen* päätöksenteon tekeminen siitä, asetetaanko kyseenalaiseksi
- **Ei pinta-alaa- yksinomaanM SK1** Tunnus toimii per-pääkohdalla per -pää kohdan politiikkojen kanssa. `/products` sallitaan hakukoneiden käyttö `/api/checkout` tarvitaan ihmisiä. Tämä on loppupisteen semantiikkaa, ei firewall-sääntöjäM SK2
- **Ei pilveä-riippuvainenM SK1** Kaikki toimii itse-contained. Qdrant , TimescaleDBM SK3 LLM MST4 kaikki valinnaisetMSC5 Ydin on kaksi riviä koodia ja SQLite-fiili
- **epävarmuus** Kaksi riippumatonta tulosta (todennäköisyys |+luottamus | ) tarkoittaa sitä, että voitte erottaa ♫"koskeellisesti botista ♫

---


## Mikä's seuraava

Osa 1 käsitteli sitä, miksi robotin havaitseminen on tärkeääM SK1 osa 2 käsitti havaitsemisputken sisäisyyksiä. Tämä osasto käsitellyt vähimmäistason elinkelpoista integraatiota ja scaling-tietä–- kahdesta koodilinjasta täysimääräiseen tuotantoportaaliin

**Aloitetaan:**

- NuGet: `dotnet add package Mostlylucid.BotDetection`
- Gateway Docker: `docker pull scottgal/stylobot-gateway`
- [Täydet asiakirjat](https://github.com/scottgal/LLMApi/tree/main/Mostlylucid.BotDetection/docs)
- [Live demo: StyloBot.net](https://stylobot.net)