Enterprise-botdetektorn borde inte kräva en doktorsexamen i infrastruktur. ( eller tusen i månaden för att använda den.

Read Part 1: StyloBot: Kämpar tillbaka mot schackare

Lees del 2: Hur botar blev smartare

👉 Se det live: StyloBotM SK2net - Den verkliga produktionssystemet körs tidigt -

Idéen

Einstein ansåg att allting skulle göras så enkelt som möjligt. , men inte så enkelt, ." Det är ' som designprincipen bakom StyloBot och ' som är integreringsmodell.

Delarna 1 och 2 täckt varför bot-detektorer och hur det detekterade pipelinet fungerar. Denna artikel omfattar hur liten kod du faktiskt behöver - och hur samma system skalar från en enda plikapp till ett komplettt produktionsportaal med TimescaleDB, Qdrant-vektorsökningen , och CPUM SK4 endast LLM-klassificering

Den viktigaste insikten varje nivå använder samma detektionskanal. Du, ', skiftar inte fram konstruktioner när du växer.

Två rader kod

Detta är det absoluta minimumet. Inga konfigurationsfiler ,

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

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

Vad har just hänt?

• 21-detektorer registrerad: UserAgent mönster matchingM SK1 headerkonsistens , IP datacenter-detektor-detection, beteendeanalysMska4 TLS fingerprinting Mske5 JA Mska6JA Mske7 TCP / IP fingerprintningMsko9 HTTP M Ska10 fingerprintingsM Ska11 cache-beteende-analys, Mska12 responsbeteendens återkoppling, , multi, M Ska14, lagerkorrelation, ,, och mer,Mska16
• Pipeline baserat på våg: Detektorer körs i beroendevågor . Wella | | 0 | ( | inga beroenden | МSK4 | utför parallellt |. | Senare vågor triggar bara när tidigare signaler kräver mer djupgående analys
• SQLite lagring: A botdetection.db file auto- skapar lärde mönster och vikter. Ingen konfiguration
• In-processliknande sök: HNSW-index för att hitta liknande Bot-signaturer . Ingen extern vektordatabas
• Heuristisk poäng: ~50 egenskaper extraherade per begäran

Allt det här körs in under 1 millisekund per fråga på handelshardware. endast CPU , ingen GPU

Varje begäran har nu detektionsresultat tillgängliga via HttpContext förlängningar:

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

Detektorn går igång men inget blockerar.. Du bestämmer vad du ska göra med resultaten.

Blokera alla Bots, Hela App

Om du bara vill blockera robotar från hela din application - inga per- slutpunkt configM SK2 inga attribut - detMSC4 en rad JSON

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

Det är "'". Det är det. Det detekterade robotar ovanför din block, - och självförtroende tröskeln får enMinConfidenceToBlock defaults till 0.8sökmotorer Googlebot Bingbot ( Facebook , Twitter / X ), och övervakningsrobotar ( UptimeRobot , Pingdom ) är standardmässigt tillåtna eftersom du nästan definitivt vill ha dem

Eller samma sak i koden

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

Det här är """. Jag vill inte tänka på det. " "", modet, . "" Detektorn kör "", , "" Boten blir blockerade, , "", bra klättrar går igenom "". . "", rör sig till "" per "",- "", slutpunktkontroll när du behöver den.

Minimal API: Det kompletta exemplet

Här är "'" en komplett "," -drivande API med per , "-" och endpoint bot protection . 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();

Varje .BlockBots() ringblöcke alla bot-typer standardmässigt. Du väljer specifika typer i med Allow* parametrar. Tanken är att förneka-avM SK2defaultMSC3 att göra en vitlista av de bra

Bot-typer du kan tillåta

MVC Controllers: egenskaper

Samma detekteringssledning, skydd genom attributer.

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

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

Attityderna

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

Geografisk blockering av nätverk &

De arbetar både med MVC-Attribute och Minimal API-filter. De kräver GeoDetection-koordinatorn för signaldata

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

Utöver blockering

Binärblock/ tillåten är enkel men begränsad . Aktionspolitik separat vad du upptäcker från hur du reagerar. Definiera reaktionsstrategier i konfigurationen

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

Spegla regler till slutpunkter

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

Fem policytyper: Block (HTTP 403), Throttle (tydliga fördröjningar Challenge (CAPTCHA Redirect ( LogOnly ( skuggan Modus ). Se den handlingspolitiker för hela referensen.

Skadormodiet är den empfohlena utgångspunkten. Inspeg av detektorn, titta på resultatenM SK2 ton tröskeln , sedan börja blockera.

Vad du får gratis

Varje begäran efter UseBotDetection() har dessa förlängningar tillgängliga på 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();

Två oberoende poäng spelar roll här. bot sannolikhet ( hur troligt är det att detta är en robot detektionsförtroende ( hur säker är systemet mänsklig ( låg sannolikhet , hög självförtroende M SK2 Eller så kan du se en misstänksam begäran men ha låg självförroende eftersom bara ett detektor fungerade

Signal-baserade filtrering

Förutom bottyper, StyloBot visar 100+ skrivna signaler från dess detektorer . Du kan filtrera ändepunkter baserat på specifika signalvärden | - | för både Minimal API och MVC

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

Att läsa inlinesignaler

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

Full signal reference: signaler och anpassade filter.

Att testa det

# 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

Den /bot-detection/check Endpoint är din utvecklingsvän, .. Den återskapar varje signal från varje detektor. , Timing data , och per detektor så att du kan se exakt vad

Hur det skalar: från file till full stack

Detta är designprincipen som betyder mest varje nivå använder samma detektionskanal. Du, ', skriver aldrig om ditt skyddskod igen.

Tier 1: Själva - Bevarat | ( | Var du börjar |) |

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

Alla 21 detektorer körs i en våg-baserad pipelineM SK2 snabba - banadetektorer | ( | UserAgent |, | Header ♫ , | IP | МSK7 | Behavior | , | TLS fingerprint | JSK9 | sätter igång parallellt i Wave ♫ ♫ Hjärisistiska uträkningsextrakter ♫ ~50 | egenskaper och kör en lätt scoring-modell ♫. | lärda mönster förblir kvar hos SQLite över hela början ♫

Bra för: Enkel app, <100K-ansökningarM SK2dag

Tier 2: Lägg till Geodetection

Lägg till geo-riktning plus geo-koordinatorn:

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

Om IP: s geografisk plats är ny: GeoIP bakgrund och DataHub GeoIP dataset är bra utgångspunkter. DataHubCsv laddar ned en gratis ~27MB IP-databas i första sträckan och håller den uppdaterad omvecklingsmässigt MaxMind GeoLite2.

Nu får du 20+ geosignaler | | ( | land | , | VPN | МSK3 | proxy |, | Tor | , | datacenterdetektion | ) | och robotens ursprungskontroll |( | Googlebot från ett kinesiskt datacenter BlockCountries, BlockVpn, BlockDatacenter, BlockTor parametrar aktiveras.

Niveau 3: PostgreSQL + TimescaleDB

Ersätta SQLite med PostgreSQL för multi-servers gemensamt lärande och lägga till TimescaleDB (a PostgreSQL-extension för tid- seriedata ) för analytik

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 ger dig hypertable partitioning, automatiserad kompression | (90-95% | lagerförminning efter |7 | dagar | МSK3 | kontinuerliga aggregationer för sub |

Bra för: >100K begäran, / dag, M SK2 flera server, , behov av analytik-dashboard,.

Tier 4: Full 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)

Gatewayn är en enskild Dockercontainer (scottgal/stylobot-gateway) som driver detektion på alla trafiker och skickar ut resultat som HTTP-Header | . | Din app läser opskrifte ingen SDK behövs, vilket språk som helst. Om " utgångspunkt " är obekant , tänk påomvänd proxy som sitter framför din app och tillhandahåller säkerhet

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

Din app litar på portalen

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

Eller läsa opskrifte direkt på vilket språk som helst:

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

Koplar som portaal skickar ut:

Vad varje komponent lägger till

Välj din nivå

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)

Att röra sig mellan våningar är en DI-registrationsförändring. ditt Endpoint-skyddskod - [BlockBots] attributes, den .BlockBots() filterar, den context.IsBot() kontrollerar - stannar exakt samma .

Enterprise Hooks

De två "-" -linjerna är utgångspunkten.

Response-Header för debugging

Aktivera detektionsголовer globalt så att du kan kontrollera beteendet utan att träffa diagnostiska slutpunkter:

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

Varje respons får X-Bot-Detected, X-Bot-Confidence, X-Bot-Processing-Ms, etc .användbar för gränssnittrutteringsbeslut i Caddy/NginxM SK3 och för avbugning i devMSC4 Deaktivera produktionen eller begränsa till tillförlitliga nätverk

Utmanande regler (Friktion före blockering )

Don' blockerar inte på osäkerhet - utmaning iställetM SK2 StyloBot har fem byggda utmaningstyper

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

Utmanande typer: Redirect ( skicka till utmanande sidan Inline (HTML interstitiell), JavaScript (JS-tegenskap-av-arbetarM SK3 Captcha, ProofOfWork (komputationsutmaningM SK1 Spegla till slutpunkter via [BotPolicy]:

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

IP tillåter/Neg listor

Globala tillåtna och förneka listor för kända IPs och CIDR intervall:

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

Vallisterade IPs hoppar över att upptäcka helt. svartlistade IPs blir blockerade omedelbart . Båda stödjer CIDR-notationen

OpenTelemetry-mätrik

StyloBot visar ut mätvärden via System.Diagnostics.Metrics, kompatibel med OpenTelemetry, Prometheus, Grafana, och alla .NET-mätrik konsumenter

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

Available metrics:

Det här är siffrorna du behöver för brädseln, varning , och kapacitetsplaneringM SK2 Detektorns latens-histogram låter dig sätta upp SLOs. BotMSC4 mänskliga mätare ger dig trafikkomposition över tid

Route Group Defaults

Applicera robotskydd på hela maršrutgrupper istället för att upprepa per-endpointM SK1

// 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() tar samma geo/nätverk/förtroende parametrar som .BlockBots(), men avsiktligt blockerar alltid scraper och ondskefulla robotar på gruppnivå. allowScrapers / allowMaliciousBots om grupper). WithHumanOnly() är gruppens ekvivalent till .RequireHuman().

Namerade regler på Minimala API

Använda .BotPolicy() att anse namnda handlingspolicyr till Minimal API slutpunkter - samma sak [BotPolicy] gör 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);

Feedback API

rapportera falska positiva och negativa tillbaka till systemet via 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"}'

Slutpunkten returnerar om återkopplingen representerar ett falskt positivt eller falskt negativt förhållande till det nuvarande upptäcktsresultatet

Gateway Trust Boundary med HMAC-signatur

När du använder YARP-portaalet, litar din baksida på uppströmsdetektionsspetsar

Grund tro (nätverk -utrymme isolering bara):

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

HMAC-signerad tillit (kryptografisk verifiering

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

När UpstreamSignatureHeader och UpstreamSignatureSecret är ställda, och mellanvaran ser HMAC-SHA256 handtekening innan man litar på uppströms opskrifte.

Använd det här för custom gateway/proxy integrationer som lägger ut signering-header. Den byggda - i Stylobot-portaalen förflyttar roboten framåt M SK2 spårning-headers , men emiterar inte än HMAC-signatur-headering

Benötiga signerade opskrifte:

• X-Bot-Signature (bas, 64, HMAC, M SK2
• X-Bot-Detection-Timestamp (Unix-epok sekunder , UTCM SK2

Att underteckna kontrakt

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

Signaturer utanför ett 5-minuter återspelningsfenster avfärdas . Om undertecknet saknas, ofullständigtM SK3 eller är utgångsdatumsMSC4 uppströmsheader avfärdades och full lokal detektion körs istället

viktigt: Aktivera enbart tillit när din baksida ligger bakom en tillitlig omvänd proxy. Om en attacker kan nå din baksidan direkt X-Bot-Detected: false och kringgå alla upptäckter. I produktionenM SK1

• Var säkra på att backend inte är allmänt tillgänglig. (Docker-intern nätverk , Kubernetes ClusterIP)
• Stripp X-Bot-* opskrifte vid din gräns proxy innan de når portaalet
• Använd HMAC-signatur för bevakning

Vad StyloBot inte är

Vålig att vara uppenbart:

• Inte en WAF. StyloBot inte inspekterar payloader för SQL-injiction eller XSS. Det identifierar som gör begäran, inte vad de' skickar . Använd den tillsammans med en WAF
• Inte en CAPTCHA gård. Utmaningspolitiker finns, men designfilosofin är det detekterande, det första, det andra. Målet är att veta vad du har att göra med före beslutande om att ifrågasätta
• Inte perimeter- endastM SK1 Detektorn kör per- slutpunkt med per - slutpunktens policyr /products tillåt sökmotorer medan /api/checkout kräver människor. Detta är slutpunkters semantik , inte firewall-regler
• Inte moln Allt körs själv.
• Osäkerhet Två oberoende poäng ( sannolikhet + självförtroende ) betyder att du kan skilja " antagligen en robot M, vi | ' | är säkra på ♫ " | från ♫ " | antagligt en robot

Vad' är nästa

Del 1 visade varför botdetektorn spelar roll . Del ♫ 2 ♫ visade detektorleitungsinternen ♫

Ta igång:

• NuGet: dotnet add package Mostlylucid.BotDetection
• Gateway Docker: docker pull scottgal/stylobot-gateway
• Hela dokument
• Live demo: StyloBot.net