# **mostlylucid.botdetection**
*स्कॉपर्स वास्तविक उपयोगकर्ताओं की नकल करने के लिए AI का प्रयोग शुरू करने के बारे में हैं, इसलिए मैंने एक बोट डिटेक्टर बनाया जो सीखता है*
**प्रमुख संकल्पना: व्यवहारिक रूटिंग** यह एक नया वर्ग सक्षम करता है - जहां पारदर्शी , समायोज्य | " |teams \ " detectors और सीखने वाली प्रणालियों को सीखा गया व्यवहार पैटर्नों पर आधारित प्रतिक्रियात्मक रूप से ट्रैफिक को मार्ग दिखाता है [YARP गेटवे](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway)बॉट्स कभी भी आपके बैकएण्ड तक नहीं पहुँचते
2025-12-08T07:00
[](https://www.nuget.org/packages/mostlylucid.botdetection/)
[](https://github.com/scottgal/mostlylucid.nugetpackages/blob/main/Mostlylucid.BotDetection/README.md)
[](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway)
---
## **यह क्यों है**
बोट पता लगाना आधुनिक वेब इंजीनियरिंग में सबसे कठिन समस्याओं में से एक है
इसलिए नहीं क्योंकि बॉट्स अधिक स्मार्ट हो गया - लेकिन इसलिए **AI ने वास्तविक उपयोगकर्ता व्यवहार को अनुकरण करने के लिए इसे क्षुद्र बना दिया**:
* परिवर्तित आवासीय प्रतिनिधि
* पूरी तरह से वैध ब्राउज़र अंगुल छापें
* वास्तविक माउस गति
* जावास्क्रिप्ट चला रहा है
* जब अवरोधित किया जाता है तब अनुकूलन
वाणिज्यिक समाधान इस समस्या को हल करता है, लेकिन वे1 महंगा होते हैं।
मैं कुछ अलग करना चाहता था
* खोलें
* स्थानीय
* समझदार
* विस्तारित करने में आसान
* चलाने के लिए सस्ते (yesM SK1 Raspberry Pi पर भी
तो मैंने बनाया **mostlylucid.botdetection** के लिए एक मॉड्यूलर learning bot detection engine
यह सरल शुरू हुआ और फिर बहुत अधिक रोचक चीज़ में विकसित हो गया
---
[TOC]
---
## **एक ठोस उदाहरण (यह वास्तव में क्या पकड़ता है**
यह एक वास्तविक है
एक scraper spoofs:
```
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120
```
वैध दिखता है
लेकिन यह *भूल जाता है* एक हेडर Chrome हमेशा भेजता है:
```
Sec-Fetch-Mode
```
और इसके `Accept-Language` हेडर नहीं matches claimed locale
और अनुरोध दर स्पष्ट रूप से स्वचालित है
**एक संकेत ठीक है**
सिस्टम इसे milliseconds के नीचे चिह्नित करता है
यह संपूर्ण डिजाइन का आधार है
**एक बड़े पर निर्भर नहीं करें**
---
## प्रणाली का दर्शन
इस परियोजना के मूल में-,, यह वास्तव में bot पता लगाने के बारे में नहीं है।
आधुनिक scrapers अधिक अनुकूल जीवों की तरह व्यवहार करते हैं। वे सीखते हैं।
यहां का दर्शन सरल है।
यह सिस्टम पारदर्शी होने के लिए बनाया गया है।
---
## **यह कैसे काम करता है (छोटे संस्करण**
कई छोटे डिटेक्टरों के माध्यम से अनुरोध प्रवाह
इसे एक हवाई अड्डे सुरक्षा जांच बिंदु के रूप में सोचें
```mermaid
flowchart TB
subgraph Request["Incoming Request"]
R[HTTP Request]
end
subgraph FastPath["Fast Path (< 100ms)"]
UA[User-Agent Check]
HD[Header Analysis]
IP[Datacenter IP Lookup]
RT[Rate Anomalies]
HE[Heuristic Model]
end
subgraph SlowPath["Slow Path (Async Learning)"]
LLM[LLM Reasoning]
Learn[Weight Learning]
end
subgraph Output["Decision"]
Score[Risk Score 0-1]
Action[Allow / Throttle / Block]
end
R --> UA & HD & IP & RT
UA & HD & IP & RT --> HE
HE --> Score --> Action
HE -.-> LLM -.-> Learn
Learn -.->|updates weights| HE
style FastPath stroke:#10b981,stroke-width:2px
style SlowPath stroke:#6366f1,stroke-width:2px
style Output stroke:#f59e0b,stroke-width:2px
```
### **त्वरित पथ**
समक्रमिक रूप से चलाता है
* ज्ञात बोट पैटर्न
* गुम हेडर वास्तविक ब्राउज़र हमेशा भेजें
* डेटा केंद्र आईपी (AWS/AzureM SK2GCPMSC3
* दर स्पाइक
* यूए + शीर्षिकाओं के बीच असंगतताएं
यह पकड़ता है **80%** bots instantly
### **धीमी पथ**
पृष्ठभूमि में चलाता है
* सीखी हुई भारों के साथ हीरिस्टिक मॉडल
* एलएलएम तर्क के माध्यम से [ओलामाCity name (optional, probably does not need a translation)](https://ollama.com/)
* पैटर्न प्रतिष्ठा अद्यतन कर रहा है
* अस्थिर संकेत भूल जा रहा है
यह अनुकूलन bots - सबसे अधिक लोगों को पकड़ता है *सोचना* वे उपयोक्ता पर "regex के साथ पकड़ रहे हैं
---
## **इसे 10 सेकेंड में प्रयास करें**
```bash
dotnet add package Mostlylucid.BotDetection
```
```csharp
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddBotDetection();
var app = builder.Build();
app.UseBotDetection();
app.Run();
```
यह है
---
## **क्या पता लगाता है (एक नज़र में**
जाँचें | क्या यह पाता है
| --------------- | ------------------------------------------------- |
| **उपयोगकर्ता-अभिकर्ता** ज्ञात बॉट्स
| **शीर्षिका** | गुम सुरक्षा शीर्षिकाएँ
| **आईपी** क्लाउड होस्ट जो अपने को गृह उपयोगकर्ता बनाते हैं
| **दर** | स्वचालन बर्स्ट्स
| **सुसंगतता** Chrome के बिना
सटीकता स्लीपर विशेषता है - आधुनिक बोट स्पॉफ कर सकते हैं *एक* संकेत लेकिन आमतौर पर क्रॉस में असफल
---
## **एक वास्तविक पता लगाने का परिणाम (Broken Down**
यहाँ\'\s क्या एक वास्तविक पता लगाने की तरह दिखता है -\ यह चलाने के डेमो से है `fastpath` नीति (सभी डिटेक्टर समांतर में हैंM SK1 उत्पादन में, अधिकांश अनुरोध केवल 2-3 डिटेटर सहमत हो जाने के बाद जल्दी बाहर निकलते हैं
### सारांश
```json
{
"policy": "fastpath",
"isBot": false,
"isHuman": true,
"humanProbability": 0.8,
"botProbability": 0.2,
"confidence": 0.76,
"riskBand": "Low",
"recommendedAction": { "action": "Allow", "reason": "Low risk (probability: 20%)" },
"processingTimeMs": 50.7,
"detectorsRan": ["UserAgent", "Ip", "Header", "ClientSide", "Behavioral", "Heuristic", "VersionAge", "Inconsistency"],
"detectorCount": 8,
"earlyExit": false
}
```
**डिटेक्टर 8 में चलाया गया** एकाधिक साक्ष्य स्रोतों में समानांतर निष्पादन
### डिटेक्टर योगदान
प्रत्येक डिटेक्टर एक भारित प्रभाव का योगदान करता है
| डिटेक्टर | | | प्रभाव || | वज़न | МSK3 | भारित
|----------|--------|--------|----------|--------|
| **उपयोक्ता अभिकर्ता** अभिकर्ता सामान्य दिखाई देता है
| **शीर्षिका** हेडर सामान्य दिखाई देते हैं
| **व्यवहारिक** अनुरोध पैटर्न सामान्य दिखाई देते हैं
| **शल्यचिकित्सा** | -0.77 | 2.0 | **-1.54** मानव संभावना
| **क्लाइंट साइड** फ़िंगरप्रिंट वैध प्रतीत होता है
| **संस्करण आयु** ब्राउज़र
| **असंगतता** कोई हेडर नहीं
| **आईपी** स्थानीय होस्ट dev में तटस्थ
**ह्रासीय डिटेक्टर** यहाँ पर प्रभावी है - यहM SK1 इसकी भारित 2x और मानव विश्वास को प्राप्त करने के लिए उपयोग किया गया \16 विशेषताएँ
### संकलित संकेत
प्रत्येक डिटेक्टर संकेतों का उत्सर्जन करता है जो ह्रासीय मॉडल में फीड करता है
```json
{
"ua.is_bot": false,
"ua.raw": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36...",
"ip.is_local": true,
"ip.address": "::1",
"header.has_accept_language": true,
"header.has_accept_encoding": true,
"header.count": 16,
"fingerprint.integrity_score": 1,
"behavioral.anomaly": false,
"heuristic.prediction": "human",
"heuristic.confidence": 0.77,
"versionage.analyzed": true
}
```
ये संकेत समय पर बने रहते हैं और सीखने वाली प्रणाली को प्रशिक्षित करते हैं
### श्रेणी विभाजन
अंतिम निर्णय के लिए श्रेणी के आधार पर कुल प्राप्तियां
श्रेणी | अंक | | | भार || | नोट्स
|----------|-------|--------|-------|
| हेरिस्टिक | | | \ -1.54 | МSK3 | {\displaystyle \mathcal {MSK}{4 | & quot;|\,& quot ; सबसे मजबूत मानव संकेत |
उपयोगकर्ता अभिकर्ता
हेडर
व्यवहारिक
क्लाइंटसाइड
संस्करण आयु
असंगतता
आईपी
**कुल भारित अंक** → मजबूत मानव संकेत
> **नोट** यह डेमो है `fastpath` ऐसी नीति जो चलती है **सभी** दृश्यता के लिए डिटेक्टर . आरंभिक आउट सक्षम होने वाले वास्तविक उत्पादन में **के तहत 10ms**. यह यहाँ है क्योंकि डेमो मोड आरंभिक आउट को सभी योगदानों को दिखाने के लिए अक्षम करता है
### LLM के साथ पूरा पाइपलाइन (डेमो मोड
तुलना के लिए, यहाँ `demo` नीति - LLM तर्क सहित पूरी पाइपलाइन **असहमत होना**:
```json
{
"policy": "demo",
"isBot": false,
"isHuman": true,
"humanProbability": 0.87,
"botProbability": 0.13,
"confidence": 1.0,
"botType": "Scraper",
"riskBand": "Low",
"recommendedAction": { "action": "Allow", "reason": "Low risk (probability: 13%)" },
"processingTimeMs": 1370,
"aiRan": true,
"detectorsRan": ["UserAgent", "Ip", "Header", "ClientSide", "Behavioral",
"VersionAge", "Inconsistency", "Heuristic", "HeuristicLate", "Llm"],
"detectorCount": 10
}
```
**सेकंड में 10 детектор** - एलएलएम चला और *असहमत* गुर्दे के साथ
| डिटेक्टर | | | प्रभाव || | वज़न | МSK3 | भारित
|----------|--------|--------|----------|--------|
| **एलएलएम** | +0.85 | 2.5 | **+2.13** à¤à¥à¤°à¥à¤
| **ग्रीष्मकालीन** सभी प्रमाणों के साथ मानव
| **शल्यचिकित्सा** मानव संभाव्यता
| **उपयोक्ता अभिकर्ता** अभिकर्ता सामान्य दिखाई देता है
| **शीर्षिका** हेडर सामान्य दिखाई देते हैं
| **व्यवहारिक** अनुरोध पैटर्न सामान्य दिखाई देते हैं
| **क्लाइंट साइड** कोई अंगुली छाप नहीं
| **संस्करण आयु** ब्राउज़र
| **असंगतता** कोई हेडर नहीं
| **आईपी** स्थानीय होस्ट
यह दिलचस्प मामला है - **एलएलएम इसे एक संभावित बोट के रूप में चिह्नित किया** जबकि सभी स्थिर डिटेक्टरों ने कहा मानव
```json
{
"ai.prediction": "bot",
"ai.confidence": 0.85,
"ai.learned_pattern": "Browser string suggests Chrome, common in bots. Presence of cookies and a specific referer also points to a potential bot."
}
```
LLM का तर्क एक सिग्नल के रूप में रिकॉर्ड किया जाता है जो सीखने की प्रणाली में फिर से फीड करता है
सूचना
1. **दो बार हियूरिस्टिक रन** सभी डिटेक्टरों से पहले - आरंभिक ( सभी प्रमाणों के बाद ) & #44; और बाद में ( & #39; दोनों ने कहा कि \""\human\"\ with \'88%\ confidence\.\
2. **एलएलएम असहमति** इसका भारित प्रभाव आंशिक रूप से हीरिस्टिक प्रतिकूल होता है
3. **कोई औठाछाप नहीं** ClientSide ने returned 0 because JS hadn
4. **अंतिम निर्णय: अनुमति दें** LLM के साथ भी संदिग्धता के साथ-साथ संयुक्त साक्ष्य मानव के पक्ष में है `botType: "Scraper"` फ्लैग का अर्थ है यह देख रहा है
श्रेणी विभाजन तनाव को दर्शाता है
श्रेणी | अंक | | | भार || | नोट्स
|----------|-------|--------|-------|
| **शल्यचिकित्सा** Strong human signal |
| **एआई** LLM का कहना है कि बोट
उपयोगकर्ता अभिकर्ता
हेडर
व्यवहारिक
क्लाइंटसाइड
संस्करण आयु
असंगतता
आईपी
**कुल भारित अंक** मानव जीतता है, लेकिन एलएलएम का मतभेद चिह्नित किया गया है
> **प्रमुख अंतर्दृष्टि** जब वे असहमत होते हैं, तब प्रमाणों को भारित किया जाता है और बहुसंख्यक जीतता है, लेकिन अल्पसंख्यक राय सीखने के लिए रिकॉर्ड की जाती है
> **महत्वपूर्ण** यह verbose आउटपुट डेमो है।`X-Bot-Confidence`, `X-Bot-RiskBand`, आदि `context.IsBot()` जाँच करें. पूरा JSON त्रुटि सच्याना और अनुकूलन के लिए है
---
## **परिणाम का उपयोग**
```csharp
if (context.IsBot())
return Results.StatusCode(403);
var score = context.GetBotConfidence(); // 0.0–1.0
var risk = context.GetRiskBand(); // Low/Elevated/Medium/High
```
### अंतिम बिन्दुओं को सुरक्षित करना
```csharp
app.MapGet("/api/data", Secret).BlockBots();
app.MapGet("/sitemap.xml", Sitemap)
.BlockBots(allowVerifiedBots: true);
```
जोखिम स्तर कार्य का मार्गदर्शन करते हैं
जोखिम | विश्वसनीयता
| -------- | ---------- | ------------------ |
कम
| उन्नयनित | | 0.3–0.5 | || | लॉग | / | दर
मध्यम
उच्च
---
## **अभियांत्रिकी पता लगाना (वैकल्पिक**
आवश्यक नहीं है - लेकिन उन्नत स्वचालन पकड़ने के लिए उपयोगी
### **शल्यचिकित्सा detector (Fast**
सिस्टम में एक हियूरिस्टिक डिटेक्टर शामिल है जो गतिशील रूप से सीखे हुए वजनों के साथ लॉजिस्टिक रिग्रेसन का प्रयोग करता है
विशिष्ट लंबितता **1–5ms**
```json
{
"BotDetection": {
"AiDetection": {
"Heuristic": {
"Enabled": true,
"LoadLearnedWeights": true,
"EnableWeightLearning": true
}
}
}
}
```
विशेषताएँ गतिशील रूप से निकाली जाती हैं - नए पैटर्न स्वचालित रूप से डिफ़ॉल्ट वजन प्राप्त करते हैं और समय के साथ सीखते हैं *अपने* यातायात
### **Ollama LLM (Deep Reasoning)**
evasive bots को पकड़ता है जो तेजी से नियमों के लिए दिखते हैं [ओलामाCity name (optional, probably does not need a translation)](https://ollama.com/) स्थानीय LLM निष्कर्ष के लिए.
```bash
ollama pull gemma3:1b
```
```json
{
"BotDetection": {
"AiDetection": {
"Provider": "Ollama",
"Ollama": { "Model": "gemma3:1b" }
}
}
}
```
AI है **असफल-safe** यदि यह नीचे हो जाता है तो -
---
## **सीखने की प्रणाली**
स्थिर ब्लॉक सूची अस्थिर हो जाती है
तो यह प्रणाली सीखता है
```mermaid
flowchart LR
N[Neutral] -->|repeated bad activity| S[Suspect]
S -->|confirmed| B[Blocked]
B -->|no activity| S
S -->|stays clean| N
style B stroke:#ef4444,stroke-width:2px
style S stroke:#eab308,stroke-width:2px
style N stroke:#10b981,stroke-width:2px
```
पैटर्न समय के साथ टूटते हैं
* आईपी पुनः माना जाता है
* गलत कॉन्फ़िगरेशन किए गए स्क्रिप्टों को निश्चित किया जाता है
* यातायात स्वाभाविक रूप से बदलता है।
टूटने के बिना आप हमेशा के लिए वैध उपयोगकर्ताओं को अवरोधित करें
```json
{
"BotDetection": {
"Learning": {
"Enabled": true,
"ScoreDecayTauHours": 168,
"GcEligibleDays": 90
}
}
}
```
---
## **अपने अनुप्रयोग के लिए YARP गेटवे: किनारा संरक्षण**
वहाँ’ भी है **डोकर-पहली YARP उल्टी प्रॉक्सी** जो खोज चलाता है *पहले* अनुरोध आपके एप्लिकेशन पर चिपकते हैं
```mermaid
flowchart LR
I[Internet] --> G[YARP Gateway]
G -->|Human| App[Your App]
G -->|Search Engine Bot| App
G -->|Malicious| Block[403]
```
इसे एक लाइन में चलाएँ
```bash
docker run -p 80:8080 \
-e DEFAULT_UPSTREAM=http://your-app:3000 \
scottgal/mostlylucid.yarpgateway
```
पर काम करता है
* लिनक्स
* मैकओएस
* विंडोज़Comment
* **ARM (**
अनुकूल रूटिंग के लिए
```yaml
services:
gateway:
image: scottgal/mostlylucid.yarpgateway
volumes:
- ./yarp.json:/app/config/yarp.json
```
---
## **एक उचित उत्पादन कॉन्फ़िग**
```json
{
"BotDetection": {
"BotThreshold": 0.7,
"BlockDetectedBots": true,
"EnableAiDetection": true,
"Learning": { "Enabled": true },
"PathPolicies": {
"/api/login": "strict",
"/sitemap.xml": "allowVerifiedBots"
}
}
}
```
---
## **यह कहाँ जा रहा है**
यह भाग है
अगले भागों को गहराई में खोना
* **भाग 2**: [नवीन आंतरिकों, हस्ताक्षर स्मृति, प्रतिक्रिया प्रतिक्रिया रिबैक लूप्सM SK2 और स्टेलोबोट वास्तुकला](/blog/post/botdetection-part2-signature-pipeline-and-stylobot-architecture)
* **भाग 3**: व्यवहार विश्लेषण
* **भाग 4**: क्लाइंट
* **भाग 5**: वास्तविक में सीखने के वजनों को हृदीय डिटेक्टर
* **भाग 6**: एलएलएम पहचान आंतरिक
* **भाग 7**: सीखने की प्रणाली को सही ढंग से समझा गया
**भावी रोडमैप**
* वैक्टर एम्बेडिंग के साथ RAG-आधारित पैटर्न मिलान
* स्थानीय लघु मॉडल निष्कर्ष के माध्यम से [लामाशर्प](https://github.com/SciSharp/LLamaSharp) / ऑनिक्स
* नवीन आक्रामक पैटर्नों को पहचानने के लिए सांकेतिक समानता
अगर आप एक बोट डिटेक्टर चाहते हैं तो आप कर सकते है *समझना*, *बढ़ाना*, और *कहीं भी चलाना*यह श्रृंखला आपके लिए है
---
## **लिंक्स**
* **GitHub:** पूर्ण डक
[https://github≥.com/scottgalM SK3mostlylucidMSC4nugetpackages](https://github.com/scottgal/mostlylucid.nugetpackages)
* **नूगेट** पैकेज संस्थापित करें
[https://www](https://www.nuget.org/packages/mostlylucid.botdetection)
* **डॉकर हब** YARP गेटवे
[https://hub,.docker,.com,M SK3r,MSC4scottgal,MST5mostlylucid,MSSK6yarpgateway](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway)
**गैर लाइसेंस – सार्वजनिक डोमेन. आप चाहें जिस तरह इस्तेमाल करें**