# **स्टेलोबोट**
*Enterprise bot detection shouldn't require a PhD in infrastructure (or thousands per month in expenditure to use*
**[भाग पढ़ें 1: StyloBot: Scrapers के विरुद्ध वापस लड़ना](https://www.mostlylucid.net/blog/botdetection-introduction)**
**[भाग पढ़ें 2: कैसे बोट्स स्मार्ट हो गया](https://www.mostlylucid.net/blog/botdetection-part2-signature-pipeline-and-stylobot-architecture)**
**[👉 See It Live](https://stylobot.net)** - वास्तविक उत्पादन प्रणाली आरंभिक रूप से चल रही है
2026-02-16T10:30
[](https://www.nuget.org/packages/mostlylucid.botdetection/)
[](https://github.com/scottgal/stylobot)
[](https://hub.docker.com/r/scottgal/stylobot-gateway)
---
[TOC]
---
## द आइडिया
आइंस्टाइन ने कहा था कि सभी चीजें यथासंभव सरल बनायी जानी चाहिए, लेकिन इससे अधिक सरल नहीं।
भाग 1 और 2 कवर *क्यों* बोट पता लगाने के मामले और *पता लगाने की पाइपलाइन कैसे काम करता है*. यह पोस्ट शामिल है *आप वास्तव में कितना छोटा कोड की जरूरत है* - और कैसे एक ही प्रणाली एक एकल फाइल एप्लिकेशन से एक पूर्ण उत्पादन गेटवे में TimescaleDB के साथ मापन करता है
प्रमुख अंतर्दृष्टि **प्रत्येक स्तर एक ही खोज पाइपलाइन का उपयोग करता है**आप एक ही कोर के आसपास भंडारण और समृद्धीकरण जोड़ रहे हैं
---
## कोड की दो पंक्तियाँ
यह निरपेक्ष न्यूनतम है. कोई कॉन्फ़िग फ़ाइल नहीं
```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();
```
अभी क्या हुआ
- **21 जांचक** पंजीकृत: उपयोक्ता अभिकर्ता पैटर्न मिल्दोपना, हेडर संगतताMSC2 आईपी डेटा सेंटर पता लगानेM SK3 व्यवहार विश्लेषणMST4 टीएलएस अंगुली छाप MSP5 JA 3/JA\4), TCPMS8 आई पी अंगुलि छापMS, एचटीटीपी≥/2 अंगूली छाप, कैश व्यवहार विश्लेषण
- **तरंग---आधारित पाइपलाइन**: डिटेक्क्टर निर्भरता तरंगों में चलाते हैं।
- **SQLite भंडारण**: A `botdetection.db` फ़ाइल स्वतः- सीखे गए पैटर्न और वज़न के लिए बनाता है
- **प्रक्रिया समानता खोज में**समान बोट हस्ताक्षर ढूंढने के लिए एचएनएसवी सूचकांक
- **मनोवैज्ञानिक अंकन**प्रत्येक अनुरोध पर निकाले गए विशेषताएँ
यह सब में चला जाता है **1 मिलीसेकेंड के नीचे** वस्तुगत हार्डवेयर पर प्रति अनुरोध
हर अनुरोध अब पता लगाने के परिणाम उपलब्ध है `HttpContext` एक्सटेंशन
```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()
}));
```
पता चलाता है लेकिन कुछ भी अवरोधित नहीं करता है. आप परिणामों के साथ क्या करना तय करते हैं
---
## सभी बोट्स को ब्लॉक करें
यदि आप सिर्फ अपने पूरे अनुप्रयोग से बॉट्स को रोकना चाहते हैं तो - per नहीं है
```json
{
"BotDetection": {
"BlockDetectedBots": true
}
}
```
यह है कि अपने ब्लॉक से ऊपर पता लगाए गए बोटconfidence थ्रेसहोल्ड को प्राप्त करें`MinConfidenceToBlock` डिफ़ॉल्ट में `0.8`खोज इंजनों (गुगलबॉट | , | Bingbot |), | सामाजिक मीडिया पूर्वावलोकन & #44; ( | Facebook | МSK5 & #39; Twitter \ / | X | ), और मॉनीटरिंग बॉट्स के लिए अनुमति दी जाती है।
या कोड में एक ही बात
```csharp
builder.Services.Configure(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`:
```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();
```
हर `.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 नियंत्रक
गुणों के माध्यम से समान पहचान पाइपलाइन, सुरक्षा
```csharp
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddBotDetection();
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.UseBotDetection();
app.MapControllers();
app.Run();
```
### गुण
```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%" });
}
```
### भौगोलिक & नेटवर्क अवरोधन
ये दोनों MVC विशेषताओं और न्यूनतम API फिल्टर पर काम करते हैं
```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();
```
---
## ब्लॉक से परे
द्विआधारी ब्लॉक *जो आप पता लगाते हैं* से *आप कैसे प्रतिक्रिया करते हैं*कॉन्फ़िग में प्रतिक्रिया रणनीतियों को परिभाषित करें
### 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
}
}
}
}
```
### अंतिम बिन्दुओं को नीतियां सौंपें
```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();
```
पांच नीति प्रकार `Block` HTTP `Throttle` (छिद्र विलंब `Challenge` (CAPTCHA/proof-of-work `Redirect` (हॉनिपोट ट्रैप `LogOnly` ( छाया मोड [कार्य नीति डॉक](https://github.com/scottgal/LLMApi/blob/main/Mostlylucid.BotDetection/docs/action-policies.md) पूरा संदर्भ के लिए
छाया मोड सिफारिशित आरंभ बिन्दु है. डेप्लो डिटेक्शन, परिणाम देखेंM SK2 ट्युन थ्रेसहोल्ड्स *तब* अवरोध आरंभ करें
---
## क्या आप निःशुल्क प्राप्त कर सकते हैं
प्रत्येक अनुरोध के बाद `UseBotDetection()` इन विस्तारों पर उपलब्ध है `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();
```
यहाँ दो स्वतंत्र अंक महत्वपूर्ण हैं **bot संभाव्यता** (क्या संभावना है यह एक बोट है **पता लगाना विश्वास** ( प्रणाली कितनी निश्चित है *मानव* कम संभाव्यता
---
## सिग्नल-आधारित फिल्टरिंग
बॉट प्रकारों के अलावा, स्टेलोबोट अपने डिटेक्टर से टाइप किए गए संकेतों को प्रदर्शित करता है।
### न्यूनतम 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");
```
### एमवीसी
```csharp
[BlockIfSignal(SignalKeys.GeoIsVpn, SignalOperator.Equals, "True")]
public IActionResult Payment() => Ok();
[RequireSignal(SignalKeys.GeoCountryCode, SignalOperator.Equals, "US")]
public IActionResult DomesticOnly() => Ok();
```
### इनलाइन संकेत पढ़ रहा है
```csharp
app.MapGet("/debug", (HttpContext ctx) =>
{
var country = ctx.GetSignal(SignalKeys.GeoCountryCode);
var isVpn = ctx.GetSignal(SignalKeys.GeoIsVpn);
var isDc = ctx.IsDatacenter();
var heuristic = ctx.GetSignal(SignalKeys.HeuristicConfidence);
return Results.Ok(new { country, isVpn, isDc, heuristic });
});
```
पूर्ण संकेत संदर्भ [संकेत और मनपसंद फिल्टर](https://github.com/scottgal/LLMApi/blob/main/Mostlylucid.BotDetection/docs/signals-and-custom-filters.md).
---
## इसका परीक्षण कर रहा है
```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
```
`/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: जोड़ें ज्यामिति पता
जोड़ें भू रूटिंग और भू योगदानकर्ता
```csharp
builder.Services.AddBotDetection();
builder.Services.AddGeoRoutingWithDataHub(); // free local GeoIP DB (no account)
builder.Services.AddGeoDetectionContributor(options =>
{
options.FlagVpnIps = true;
options.FlagHostingIps = true;
});
```
यदि आईपी भौगोलिक स्थान नया है [जीओआईपी पृष्ठभूमि](https://en.wikipedia.org/wiki/Geolocation_software#IP_address) और [डेटाHub GeoIP डाटासेट](https://datahub.io/core/geoip2-ipv4) अच्छे आरंभ बिन्दु हैं. DataHubCsv एक निःशुल्क ~27MB आईपी डाटाबेस को पहली बार चलाने पर डाउनलोड करता है और इसे साप्ताहिक अद्यतन रखता है। [MaxMind GeoLite](https://dev.maxmind.com/geoip/geolite2-free-geolocation-data/).
अब आप प्राप्त कर सकते हैं 20+ भू संकेतों | ( | देश |, | वीएनपी | एमएसके3 | प्रॉक्सी |एमएसके4 | टोर | मीएसके5 | डेटा केंद्र पता लगाना | मएसके6 | और बोट मूल सत्यापन |मएसके7 | एक चीनी डेटा केन्द्र से गूगल बोट | माएसके8 | संदिग्ध | मेएसके9 `BlockCountries`, `BlockVpn`, `BlockDatacenter`, `BlockTor` पैरामीटर सक्रिय करें
### टियर 3: PostgreSQL + TimescaleDB
multi-server shared learning के लिए PostgreSQL से SQLite बदलें और जोड़ें [TimescaleDB](https://docs.timescale.com/) समय के लिए PostgreSQL एक्सटेंशन
```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
```
टाइमस्केलडीबी आपको हाइपरटेबल विभाजन प्रदान करता है।
**के लिए अच्छा है** >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" अपरिचित है तो , सोचें[उल्टा प्रॉक्सी](https://en.wikipedia.org/wiki/Reverse_proxy) जो आपके एप्लिकेशन के सामने बैठता है और सुरक्षा जोड़ता है
```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
```
आपका अनुप्रयोग गेटवे पर भरोसा करता है
```csharp
// ASP.NET Core
builder.Services.Configure(o => o.TrustUpstreamDetection = true);
```
या किसी भी भाषा में सीधे हेडर पढ़ें
```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' });
});
```
**गेटवे भेजता है शीर्षिका**
हेडर
|--------|---------|---------|
| `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
दो लाइन सेटअप आरंभ बिन्दु है
### डिबगिंग के लिए प्रतिक्रिया हेडर
खोज शीर्षिकाओं को वैश्विक रूप से चालू करें ताकि आप निदान अंतबिंदुओं पर क्लिक किए बिना व्यवहार सत्यापित कर सकते हैं
```json
{
"BotDetection": {
"ResponseHeaders": {
"Enabled": true,
"HeaderPrefix": "X-Bot-",
"IncludeConfidence": true,
"IncludeDetectors": true,
"IncludeProcessingTime": true,
"SkipPaths": ["/health"]
}
}
}
```
प्रत्येक प्रतिक्रिया प्राप्त करता है `X-Bot-Detected`, `X-Bot-Confidence`, `X-Bot-Processing-Ms`Caddy में किनारा रूटिंग निर्णय के लिए उपयोगी
### चुनौतियां नीतियाँ (ब्लॉक से पहले की गति
अनिश्चितता पर ब्लॉक नहीं करता है - चुनौती के बजाय
```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"
}
}
}
}
```
चुनौतियों के प्रकार `Redirect` चुनौती पृष्ठ को भेजें `Inline` एचटीएमएल अंतर्वर्ती `JavaScript` (JS प्रमाणन `Captcha`, `ProofOfWork` (आकलन चुनौती `[BotPolicy]`:
```csharp
[BotPolicy("default", ActionPolicy = "challenge-on-uncertain")]
public IActionResult Submit() => Ok();
```
### आईपी अनुमति
ज्ञात आईपी के लिए वैश्विक अनुमति और अस्वीकार सूची तथा [सीडीआर](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) रेंज
```json
{
"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`, के साथ संगत [ओपन टेलीमीटरी](https://opentelemetry.io/docs/), [प्रोमेथ्यूस](https://prometheus.io/docs/introduction/overview/), [ग्राफानाCity name (optional, probably does not need a translation)](https://grafana.com/docs/), और किसी भी .NET मापन उपभोक्ता
```csharp
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 के लिए आवश्यक है।
### रूट समूह तयशुदा
प्रति बार दोहराने के बजाय संपूर्ण मार्ग समूहों पर बोट संरक्षण लागू करें
```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()` वही geo/network/confidence पैरामीटर लेता है जैसे `.BlockBots()`लेकिन उद्देश्य से हमेशा समूह स्तर पर स्क्रैपर और हानिकारक बोटों को रोकता है `allowScrapers` / `allowMaliciousBots` समूहों पर `WithHumanOnly()` समूह का समकक्ष है `.RequireHuman()`.
### न्यूनतम API पर नामित नीतियाँ
उपयोग करें `.BotPolicy()` नामित कार्य नीतियों को न्यूनतम API अंतबिंदुओं - के लिए सौंपने के लिए एक ही बात `[BotPolicy]` के लिए करता है
```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);
```
### फीडबैक API
गलत सकारात्मक और नकारात्मक को सिस्टम के माध्यम से वापस रिपोर्ट करें `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"}'
```
अंतिम बिंदु बताता है कि क्या फीडबैक मौजूदा पता लगाने के परिणाम की तुलना में गलत सकारात्मक या गलत नकारात्मक का प्रतिनिधित्व करता है
### HMAC हस्ताक्षर के साथ गेटवे ट्रस्ट सीमा
जब YARP गेटवे का उपयोग करता है, आपका बैकएण्ड उपस्ट्रीम पता लगाने के हेडरों पर भरोसा रखता है।
**आधारभूत विश्वास**
```json
{
"BotDetection": {
"TrustUpstreamDetection": true
}
}
```
**HMAC-signed trust (cryptographic verification**
```json
{
"BotDetection": {
"TrustUpstreamDetection": true,
"UpstreamSignatureHeader": "X-Bot-Signature",
"UpstreamSignatureSecret": "base64-encoded-shared-secret"
}
}
```
जब `UpstreamSignatureHeader` और `UpstreamSignatureSecret` सेट कर रहे हैं, मध्यवर्ती उपकरण एक जांच करता है [HMAC](https://datatracker.ietf.org/doc/html/rfc2104) ऊपरी स्ट्रीम हेडरों पर विश्वास करने से पहले हस्ताक्षर
इस के लिए उपयोग करें **मनपसंद गेटवे** जो साइनिंग हेडर जोड़ते हैं
आवश्यक हस्ताक्षरित शीर्षिका
- `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`
- [पूरा डॉक](https://github.com/scottgal/LLMApi/tree/main/Mostlylucid.BotDetection/docs)
- [लाईव डेमो](https://stylobot.net)