स्टेलोबोट

Monday, 16 February 2026

Enterprise bot detection shouldn't require a PhD in infrastructure (or thousands per month in expenditure to use

भाग पढ़ें 1: StyloBot: Scrapers के विरुद्ध वापस लड़ना

भाग पढ़ें 2: कैसे बोट्स स्मार्ट हो गया

👉 See It Live - वास्तविक उत्पादन प्रणाली आरंभिक रूप से चल रही है

द आइडिया

आइंस्टाइन ने कहा था कि सभी चीजें यथासंभव सरल बनायी जानी चाहिए, लेकिन इससे अधिक सरल नहीं।

भाग 1 और 2 कवर क्यों बोट पता लगाने के मामले और पता लगाने की पाइपलाइन कैसे काम करता है. यह पोस्ट शामिल है आप वास्तव में कितना छोटा कोड की जरूरत है - और कैसे एक ही प्रणाली एक एकल फाइल एप्लिकेशन से एक पूर्ण उत्पादन गेटवे में TimescaleDB के साथ मापन करता है

प्रमुख अंतर्दृष्टि प्रत्येक स्तर एक ही खोज पाइपलाइन का उपयोग करता हैआप एक ही कोर के आसपास भंडारण और समृद्धीकरण जोड़ रहे हैं

कोड की दो पंक्तियाँ

यह निरपेक्ष न्यूनतम है. कोई कॉन्फ़िग फ़ाइल नहीं

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

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

अभी क्या हुआ

21 जांचक पंजीकृत: उपयोक्ता अभिकर्ता पैटर्न मिल्दोपना, हेडर संगतताMSC2 आईपी डेटा सेंटर पता लगानेM SK3 व्यवहार विश्लेषणMST4 टीएलएस अंगुली छाप MSP5 JA 3/JA\4), TCPMS8 आई पी अंगुलि छापMS, एचटीटीपी≥/2 अंगूली छाप, कैश व्यवहार विश्लेषण
तरंग---आधारित पाइपलाइन: डिटेक्क्टर निर्भरता तरंगों में चलाते हैं।
SQLite भंडारण: A botdetection.db फ़ाइल स्वतः- सीखे गए पैटर्न और वज़न के लिए बनाता है
प्रक्रिया समानता खोज मेंसमान बोट हस्ताक्षर ढूंढने के लिए एचएनएसवी सूचकांक
मनोवैज्ञानिक अंकनप्रत्येक अनुरोध पर निकाले गए विशेषताएँ

यह सब में चला जाता है 1 मिलीसेकेंड के नीचे वस्तुगत हार्डवेयर पर प्रति अनुरोध

हर अनुरोध अब पता लगाने के परिणाम उपलब्ध है HttpContext एक्सटेंशन

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

पता चलाता है लेकिन कुछ भी अवरोधित नहीं करता है. आप परिणामों के साथ क्या करना तय करते हैं

सभी बोट्स को ब्लॉक करें

यदि आप सिर्फ अपने पूरे अनुप्रयोग से बॉट्स को रोकना चाहते हैं तो - per नहीं है

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

या कोड में एक ही बात

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

यह है "मुझे नहीं लगता, 'इस बारे में सोचना चाहते हैं।

न्यूनतम API: पूर्ण उदाहरण

यहाँ ' एक पूरा , per के साथ कार्य API है - \endpoint bot सुरक्षा |. यह पूरी है 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();

हर .BlockBots() कॉल ब्लॉक्स सभी डिफ़ॉल्ट द्वारा bot प्रकार. आप विशिष्ट प्रकार चुनें में के साथ Allow* पैरामीटरों. विचार अस्वीकार करता है

बोट क़िस्में जिसे आप अनुमति दें

पैरामीटर |-----------|---------------|-----------------| | allowSearchEngines Googlebot | allowSocialMediaBots Facebook,Twitter/X, LinkedIn|Link previews,Open Graph cards | allowMonitoringBots अपटाइम रोबोट1 Pingdom2 StatusCake Health checks4 अपटाइम मॉनिटरिंग | allowAiBots GPTBot, ClaudeBot, Google-Extended |Opt-in to AI training | allowGoodBots फीड रीडर | allowVerifiedBots डीएनएस | allowScrapers AhrefsBot | allowMaliciousBots | जानी-पहली बुराईकर्ताओं | हनीपोट्स | minConfidence | थ्रेसहोल्ड जब सिस्टम बहुत निश्चित है तब ही ब्लॉक करें

MVC नियंत्रक

गुणों के माध्यम से समान पहचान पाइपलाइन, सुरक्षा

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

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

गुण

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

भौगोलिक & नेटवर्क अवरोधन

ये दोनों MVC विशेषताओं और न्यूनतम API फिल्टर पर काम करते हैं

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

ब्लॉक से परे

द्विआधारी ब्लॉक जो आप पता लगाते हैं से आप कैसे प्रतिक्रिया करते हैंकॉन्फ़िग में प्रतिक्रिया रणनीतियों को परिभाषित करें

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

अंतिम बिन्दुओं को नीतियां सौंपें

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

पांच नीति प्रकार Block HTTP Throttle (छिद्र विलंब Challenge (CAPTCHA/proof-of-work Redirect (हॉनिपोट ट्रैप LogOnly ( छाया मोड कार्य नीति डॉक पूरा संदर्भ के लिए

छाया मोड सिफारिशित आरंभ बिन्दु है. डेप्लो डिटेक्शन, परिणाम देखेंM SK2 ट्युन थ्रेसहोल्ड्स तब अवरोध आरंभ करें

क्या आप निःशुल्क प्राप्त कर सकते हैं

प्रत्येक अनुरोध के बाद UseBotDetection() इन विस्तारों पर उपलब्ध है 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();

यहाँ दो स्वतंत्र अंक महत्वपूर्ण हैं bot संभाव्यता (क्या संभावना है यह एक बोट है पता लगाना विश्वास ( प्रणाली कितनी निश्चित है मानव कम संभाव्यता

सिग्नल-आधारित फिल्टरिंग

बॉट प्रकारों के अलावा, स्टेलोबोट अपने डिटेक्टर से टाइप किए गए संकेतों को प्रदर्शित करता है।

न्यूनतम 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");

एमवीसी

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

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

इनलाइन संकेत पढ़ रहा है

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

पूर्ण संकेत संदर्भ संकेत और मनपसंद फिल्टर.

इसका परीक्षण कर रहा है

# 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

/bot-detection/check अंत बिंदु आपका विकास मित्र है।

यह फ़ाइल से पूर्ण स्टैक तक कैसे मापता है

यह सबसे महत्वपूर्ण डिजाइन सिद्धांत है प्रत्येक स्तर एक ही खोज पाइपलाइन का उपयोग करता है. आप\ '\ तुम कभी भी प्रतिरक्षा कोड को फिर से नहीं लिखते\ .\ आप'\ एक ही कोर के चारों ओर अवसंरचना जोड़ रहे हैं

टियर 1: स्वंय -Contained (Where You Start

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

सभी 21 डिटेक्टर एक तरंग में चलाते हैं-आधारित पाइपलाइन के आधार पर चलाते हैM SK2 तेजी सेMSC3पथ डिटेक्टरों को चलाता है।

के लिए अच्छा है एकल अनुप्रयोग

टियर 2: जोड़ें ज्यामिति पता

जोड़ें भू रूटिंग और भू योगदानकर्ता

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

यदि आईपी भौगोलिक स्थान नया है जीओआईपी पृष्ठभूमि और डेटाHub GeoIP डाटासेट अच्छे आरंभ बिन्दु हैं. DataHubCsv एक निःशुल्क ~27MB आईपी डाटाबेस को पहली बार चलाने पर डाउनलोड करता है और इसे साप्ताहिक अद्यतन रखता है। MaxMind GeoLite.

टियर 3: PostgreSQL + TimescaleDB

multi-server shared learning के लिए PostgreSQL से SQLite बदलें और जोड़ें TimescaleDB समय के लिए PostgreSQL एक्सटेंशन

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

टाइमस्केलडीबी आपको हाइपरटेबल विभाजन प्रदान करता है।

के लिए अच्छा है >100K अनुरोधोंM SK1दिन, बहुसंक्रमक सर्वर

टियर 4: पूर्ण स्टैक | - | गेटवे |+ | Qdrant

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)

गेटवे एक स्टैंडलोन डोकर कन्टेनर है (scottgal/stylobot-gatewayजो सभी ट्रैफिक पर पता चलाता है और HTTP हेडर के रूप में परिणाम अग्रेषित करता है कोई SDK आवश्यक नहींयदि "gateway" अपरिचित है तो , सोचेंउल्टा प्रॉक्सी जो आपके एप्लिकेशन के सामने बैठता है और सुरक्षा जोड़ता है

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

आपका अनुप्रयोग गेटवे पर भरोसा करता है

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

या किसी भी भाषा में सीधे हेडर पढ़ें

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

गेटवे भेजता है शीर्षिका

हेडर |--------|---------|---------| | X-Bot-Detected | true मानव वर्गीकरण | X-Bot-Confidence | 0.91 खोज विश्वास | X-Bot-Detection-Probability | 0.87 बोट संभाव्यता | X-Bot-Type | Scraper बोट श्रेणी | X-Bot-Name | AhrefsBot पहचाना गया बोट | X-Bot-Detection-RiskBand | High जोखिम वर्गीकरण

क्या प्रत्येक अवयव जोड़ता है

अवयव	क्या करता है
TimescaleDB	समयM SK1 श्रेणी विश्लेषण, संकुचित भंडारणMSC3 सतत समुच्चयों , रखरखाव नीतियां			उत्पादन के लिए अनुशंसित
क्वारंटCity name (optional, probably does not need a translation)	भेक्टर समानता खोज	-	जब भी वे घूमते हैं तो भी बॉट्स को पाता है
लामाशर्प bot क्लस्टर नामकरण और वर्गीकरण संश्लेषण के लिए केवल LLM
कैडी/Nginx TLS समाप्ति
गेटवे	बहुविध के लिए केंद्रित पता लगाने के लिए-\app या गैर-.\NET बैकएण्ड्स के लिए

अपने टियर चुनना

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)

स्तरों के बीच चलना एक डीआई पंजीकरण परिवर्तन है [BlockBots] विशेषताएँ, .BlockBots() फिल्टर्स, context.IsBot() जाँच करता है - बिल्कुल वही रहता है

उद्यम Hooks

दो लाइन सेटअप आरंभ बिन्दु है

डिबगिंग के लिए प्रतिक्रिया हेडर

खोज शीर्षिकाओं को वैश्विक रूप से चालू करें ताकि आप निदान अंतबिंदुओं पर क्लिक किए बिना व्यवहार सत्यापित कर सकते हैं

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

प्रत्येक प्रतिक्रिया प्राप्त करता है X-Bot-Detected, X-Bot-Confidence, X-Bot-Processing-MsCaddy में किनारा रूटिंग निर्णय के लिए उपयोगी

चुनौतियां नीतियाँ (ब्लॉक से पहले की गति

अनिश्चितता पर ब्लॉक नहीं करता है - चुनौती के बजाय

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

चुनौतियों के प्रकार Redirect चुनौती पृष्ठ को भेजें Inline एचटीएमएल अंतर्वर्ती JavaScript (JS प्रमाणन Captcha, ProofOfWork (आकलन चुनौती [BotPolicy]:

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

आईपी अनुमति

ज्ञात आईपी के लिए वैश्विक अनुमति और अस्वीकार सूची तथा सीडीआर रेंज

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

श्वेत सूचीकृत आईपी पूरी तरह से पता लगाने को छोड़ देते हैं. ब्लैक सूचीकृत IP तुरंत बन्द हो जाते है. दोनों CIDR नोटेशन का समर्थन करते हैं

ओपन टेलीमीटरी मैट्रिक्स

स्टेलोबोट के माध्यम से मापन प्रदर्शित करता है System.Diagnostics.Metrics, के साथ संगत ओपन टेलीमीटरी, प्रोमेथ्यूस, ग्राफानाCity name (optional, probably does not need a translation), और किसी भी .NET मापन उपभोक्ता

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

उपलब्ध मापन

मापन करता है क्या |--------|------|-----------------| | botdetection.requests.total गणक | संशोधित अनुरोधों की कुल संख्या | botdetection.bots.detected कंटर | बोट के रूप में वर्गीकृत अनुरोध | botdetection.humans.detected कंटर | मानव के रूप में वर्गीकृत अनुरोध | botdetection.errors.total कंटर | पाइपलाइन त्रुटियों की पहचान | botdetection.detection.duration हिस्टोग्राम | botdetection.confidence.average गेज | रोलिंग औसत विश्वास | botdetection.cache.patterns.count गेज

ये नंबर हैं जो आपको dashboards के लिए आवश्यक है।

रूट समूह तयशुदा

प्रति बार दोहराने के बजाय संपूर्ण मार्ग समूहों पर बोट संरक्षण लागू करें

// 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() वही geo/network/confidence पैरामीटर लेता है जैसे .BlockBots()लेकिन उद्देश्य से हमेशा समूह स्तर पर स्क्रैपर और हानिकारक बोटों को रोकता है allowScrapers / allowMaliciousBots समूहों पर WithHumanOnly() समूह का समकक्ष है .RequireHuman().

न्यूनतम API पर नामित नीतियाँ

उपयोग करें .BotPolicy() नामित कार्य नीतियों को न्यूनतम API अंतबिंदुओं - के लिए सौंपने के लिए एक ही बात [BotPolicy] के लिए करता है

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

फीडबैक API

गलत सकारात्मक और नकारात्मक को सिस्टम के माध्यम से वापस रिपोर्ट करें 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"}'

अंतिम बिंदु बताता है कि क्या फीडबैक मौजूदा पता लगाने के परिणाम की तुलना में गलत सकारात्मक या गलत नकारात्मक का प्रतिनिधित्व करता है

HMAC हस्ताक्षर के साथ गेटवे ट्रस्ट सीमा

जब YARP गेटवे का उपयोग करता है, आपका बैकएण्ड उपस्ट्रीम पता लगाने के हेडरों पर भरोसा रखता है।

आधारभूत विश्वास

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

HMAC-signed trust (cryptographic verification

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

जब UpstreamSignatureHeader और UpstreamSignatureSecret सेट कर रहे हैं, मध्यवर्ती उपकरण एक जांच करता है HMAC ऊपरी स्ट्रीम हेडरों पर विश्वास करने से पहले हस्ताक्षर

इस के लिए उपयोग करें मनपसंद गेटवे जो साइनिंग हेडर जोड़ते हैं

आवश्यक हस्ताक्षरित शीर्षिका

X-Bot-Signature (
X-Bot-Detection-Timestamp unit-symbols

संविदा पर हस्ताक्षर

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

एक 5-minute replay window के बाहर हस्ताक्षरों को अस्वीकृत किया जाता है

महत्वपूर्ण सिर्फ विश्वास सक्षम करें जब आपका बैकएण्ड एक विश्वसनीय उल्टा प्रॉक्सी के पीछे है X-Bot-Detected: false और सभी पता लगाने को पार करना. उत्पादन में

सुनिश्चित करें कि बैकएण्ड सार्वजनिक रूप से उपलब्ध नहीं है
स्ट्रिप X-Bot-* वे गेटवे तक पहुँचने से पहले अपने किनारे प्रॉक्सी में शीर्षिका
प्रतिरक्षा के लिए HMAC साइनिंग का उपयोग करें

स्टेलोबोट क्या नहीं है

स्पष्ट होना चाहिए

कोई WAF नहीं स्टेलोबोट SQL इंजेक्शन या XSS के लिए पैयलोड का निरीक्षण नहीं करता है जो अनुरोध कर रहा है क्या वे भेज रहे हैं
एक CAPTCHA फार्म नहीं है चुनौतियां नीतियां मौजूद हैं, लेकिन डिजाइन दर्शन पता लगाना है पहले चुनौत करने का निर्णय करना
परिधि नहीं पता चलता है per-endpoint के साथ per-end point नीतियों से /products खोज इंजनों को अनुमति दें जबकि /api/checkout मनुष्यों की आवश्यकता है. यह अंतबिंदु अर्थशास्त्र है
बादल नहीं सब कुछ स्वचालित चलाता है
अनिश्चितता दो स्वतंत्र अंक (संभाव्यता |+ विश्वास | ) इसका अर्थ यह है कि आप अलग-अलग कर सकते हैं "संभवतः एक बोट |

क्या है

भाग 1 क्यों बोट पता लगाने के लिए महत्वपूर्ण है शामिल किया गया था खंड | . | भाग |2 | पता लगाने की पाइपलाइन आंतरिक खंडों को खंडित किया गया है खंड 3 | यह पद न्यूनतम व्यवहार्य एकीकरण और scaling पथ खंड 4 | दो लाइन कोड से एक पूर्ण उत्पादन गेटवे खंड 5

आरंभ करें

नूगेट dotnet add package Mostlylucid.BotDetection
गेटवे डॉकर docker pull scottgal/stylobot-gateway
पूरा डॉक
लाईव डेमो