# **StyloBot: Kämpar tillbaka mot schackare (Teil 1)**

*Skracker håller på att börja använda AI för att imitera riktiga användare. Så jag byggde en robotdetektor som lär sig, ,, anpassar sig och kämpar emot*

**[Lees del 2: Hur botar blev smartare - Den nya gränsen i Bot-detektorn](https://www.mostlylucid.net/blog/botdetection-part2-signature-pipeline-and-stylobot-architecture)**

**[👉 Se det live: StyloBotM SK2net](https://stylobot.net)** - Det här är det riktiga produktionssystemet som upptäcker din begäran i en enda millisekunder. CPU- endastM SK3 ingen GPU behövs.

**Nyckelkoncepten: Behavioural Routing** Detta gör det möjligt att skapa en ny kategori - där detektorer och lärande system som är transparenta , anpassningsbara | " | lag |" | reflektivt riktar trafiken baserat på lärda beteendemönster | , | inte statiska regler | МSK5 | med [YARP Gateway](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway), Boter når aldrig din baksida . Eller använda mellanvaran för att bygga beteendetsriktning direkt in i din app-skikt

<pinned/>
<!--category-- ASP.NET, Bot Detection, Security -->
<datetime class="hidden">2025-12-08T07:00</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/mostlylucid.nugetpackages?style=social)](https://github.com/scottgal/mostlylucid.nugetpackages/blob/main/Mostlylucid.BotDetection/README.md)
[![Docker](https://img.shields.io/docker/pulls/scottgal/mostlylucid.yarpgateway)](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway)

---


## **Varför finns detta?**

Bot-detektorn har blivit ett av de svåraste problemen i modern webteknik

**Problemet ändrades bara.** För tre år sedan **stora språkmodeller gjorde det obetydligt att imitera ett verkligt användarbeteende i stor skala**. En LLM, -, kraftfull skräpper inte bara blindt frågar om samma väg upprepade gånger, M SK3, den förstår din hemsidas struktur, ,, anpassar sig när den är blockerad, MSC5, och frågar efter sidor i en realistisk ordning. ., den är ojämlik från en människa förutom i aggregerade beteenden.

* Omvänd residentiell representanter
* Perfekt korrekta fingeravtryck
* Realistiska musrörelser
* Att utföra JavaScript
* Anpassning när blockerad

Commerciala lösningar löser detta, men de är dyra. Montan är typiskt beroende på skalan. ), är stängd, - är källkod och kopplad till specifika CDNs.. Du vet aldrig riktigt vad som händer under kapseln.

Jag ville ha något annorlunda.

* **Öffna** - Du kan läsa
* **Lokala** - Nej 3rdM SK2 parters API-sändningar , inga data som lämnar din infrastruktur
* **Förståeligt** - Förtydliga beslut , inte en svart ML-modell
* **Lika att sträcka ut** - Lägg till custom-detektorer för din specifika hot yta
* **Billig att springa** - CPU
* **Utbyggd för v4** - hanterar den moderna LLMs attacker

Så jag byggde **StyloBot** - en modulär , lärande robot-detektor för | . NET | . | Gratis | МSK4 | olicencerad |, | designad från grunden för den nya robotåldern

Det började enkelt, och sedan växte det till något mycket mer intressant.

---


[TOC]

---


## **Ett konkret exempel ( Vad det här faktiskt fångar**

Här är ett verkligt scenario

Ett skräpsprång

```
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120
```

Ser legitima ut.

Men det *glömmer* en titeln Chrome skickar alltid:

```
Sec-Fetch-Mode
```

Och dess `Accept-Language` header matchar inte den påstående lokalen

Och begäran är tydligt automatiserad.

**Ett signal är bra . Två är misstänkt M SK1 Tre är ett mönster .**

Systemet flagerar den under 100 millisekundar - ingen AI krävs

Detta är grunden till hela designen
**inte lita på en stor modell**

---


## Systemfilosofi

I själva verket handlar det här projektet inte om att upptäcka robotar utan **hantera trafiken som ett levande system** snarare än en ström av isolerade krav.

**Varför är detta viktigt nu?** LLM-motoriserade robotar är inte 'döjligaM SK2 De anpassar sig. En LLM-bot träffar din APIMska4 får hastighetenMske5 begränsadMskka6 ändrar användarenMsek7 agent, Mska8 roterar IPMssa9 frågar om förknippade produkter Msa10 som en människa skulle göraMsaka11 och sedan extraherar den systematiskt dataM Ska12 Statiska regler kanM ska13 inte hålla ikappMskan14 Men ett anpassningsbart system kan~Mska15

Moderna skrapare beter sig som organismer. De lär sig att muta. De mäter svagheter. De reagerar på tryck. De måste utvecklas också.

filosofin här är enkel

1. **Observera många signaler** -, UA, ,, opskrifte, ,, IP, M SK3, beteendemönster, MST4, kors, M ST5, lagerkonsistens
2. **Kombinera dem** - DonM SK1 inte lita på ett signal . Aggregerad bevis
3. **Låt dem interagera** - En perfekt UA är misstänksam om IP är ett datacenter . Koplar är misstänksamma om de
4. **Anpassning över tid** - Patterns bryts ut . Nya mönster dyker upp

Istället för ett enda "bot/not -bot **ett nätverk av små detektorer**, var och en bidrar med bevis till ett gemensamt beslut, - skapande lager, M SK2 Politier blir sammanbyggbara flöden, ,, inte svåra, -, kodade regler, MSC5, ryktet skiftar gradvis istället för att slå till val,., AI är bara en annan bidragande faktor, MST7, vägd tillsammans med hururistiken, Mst8, ingen monolith, M st9

Systemet är byggt **transparenta , förklarande, utvidgningsbara M SK2 och självliga - korrigerande**, med det långsiktiga målet att bete sig mindre som en firewall och mer som **immunsystem**: snabbt i kanten , intelligent i kärnan

---


## **Varför går det inte att upptäcka signalen? ( Och hur StyloBot undvikar det?**

De flesta system är beroende av ett eller två signaler:

- **"Blockera om användaren** → enkelt spoofedd . Moderna robotar använder riktiga användare
- **"Blocka om hastigheten > X begäranM SK2sek"** → Intelligent Bots throttle
- **"Blocka om IP finns i ett datacenter** → Residentiella proxynätverk har riktiga hemma-isp.
- **"Blockera om JavaScript inte gör det** → Browser utan huvud sätter igång JS perfekt

Pattern: **varenda enskild signal kan vara falskt.** Lösningen: **inte lita på ett signal**

StyloBot kombinerar många svaga signaler till en stark bedömelse. *plus* en datacenter IP *plus* saknade säkerhetskoder *plus* krävvärde avvikelser *plus* Cross- lagerkonsistens = botM SK2

---


## **Hur det fungerar (Skrattversionen)**

begäran strömmar genom flera små detektörer , var och en bidrar med en liten del bevis.

Tänk på det som flygplatss säkerhet. Ett TSA-agent som kontrollerar dokument är inte tillräckligt. Ett ' är inte nog men tre agenter som kollar dokument.

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

### **Fast Path (< 100ms)**

Runner i synkronitet. Fungerar inte’ saktar ned din appM SK2

* Bekant robotmönster
* Missande opskrifte riktiga webblader skickar alltid
* Datacenter IPs (AWS/Azure /GCPM SK3
* Prisspikes
* Ojämlikheter mellan UA + opskrifte

Det här fångar **80%** av bots omedelbart.

### **långsam väg (Async)**

Runner i bakgrunden.

* Heuristisk modell med lärde vikter
* LLM resonemang via [Ollama](https://ollama.com/)
* Att uppdatera mönsterrenomheten
* Att glömma döda signaler

Det fångar de anpassningsbara robotarna - som de flesta människor *tänk* de catchar med "regex på användaren

---


## **Försök det i 10 sekunder**

### Lokal installering

```bash
dotnet add package Mostlylucid.BotDetection
```

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

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

Det är det. Allt fungerar ur lådan.

### Titta på det först

vill inte installera ännu' **[Att besöka stylobot.net](https://stylobot.net)** att se produktionssystemet i werking. skicka in begäran , titta på dem analyserad i en enda millisekunder med full tidig analys

---


## **Vad det upptäcker ( På en titt**

| Kolla | Vad det hittar |
| --------------- | ------------------------------------------------- |
| **User-Agent** |kända robotar, bibliotekM SK2 skrapare |
| **Påskriftar** | Missande säkerhetskolor , otänkbara kombinationer |
| **IP** | molnadministratörer som låtsas vara | “ | hemanvändare
| **Takt** | Automatisk sprängning, fördelad slitning |
| **Konsistens** | “Chrome/120” utan Chrome

Konsistens är sömnmönstret - moderna robotar kan bluffa *ett* signal men oftast misslyckas vid korsning

---


## **Ett verkligt detektionsresultat (Broken Down**

Här är vad en riktig detektion ser ut som verkliga data från **[stylobot.net](https://stylobot.net)** som körs i produktion i tidiga tider-utbrott aktiverat. Du kan generera samma resultat själv genom att testa på den här live-siten

### sammanfattning

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

**Detektorer fungerade i 51ms** - att ' parallellt utförs över flera beviskällor

### Detektorkollektiv

Varje detektor bidrar med en viktad inverkan.

| Detektor | | | Inverkan | МSK2 | Gewicht || | Weighted |
|----------|--------|--------|----------|--------|
| **UserAgent** | -0.20 ♫ ♫ | ♫
| **Påskrift** | ♫ -0.15 ♫ ♫
| **Vanor** | ♫ -0.10 ♫ ♫
| **Heuristik** | -0.77 | 2.0 | **-1.54** | 88% mänskligt antaglighet
| **ClientSide** |
| **Versionsålder** | | | -0.05 |
| **Inkonsistens** | ♫ -0.05 ♫ ♫
| **IP** | 0.00 ♫ ♫ | ♫

Den **Röntgendetektor** dominerar här - det 's viktade 2x och använde m16 egenskaper för att nå M88% mänskligt tilltro

### Signaler samlats

Varje detektor släpper ut signaler som matas in i theuristisk modellen:

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

Dessa signaler förblir kvar och tränar lärandesystemet över tid.

### Kategorisfördelning

sammanlagda poäng per kategori för det slutgiltiga beslutet

| Kategorie | Punktzahl | | | Gewicht | МSK3 | Notar ||
|----------|-------|--------|-------|
| Heuristiskt | | | -1.54 |
| UserAgent ♫ ♫ | ♫
| Rubrik | -0.15 | | | 1.0 | МSK5 | Alla förväntade rubr finns här
| Behaviorell | ♫ ♫ -0.10 ♫
| ClientSide
| VersionAge | | | -0.04 |
| Inkonsistens | | | -0.04 |
| IP ♫ ♫ | ♫

**Totala vikterade poäng: M SK1** → Den starka mänskliga signalen

> **Nota:** Det här är demon ' `fastpath` politik som styr **alla** detektorer för synlighet. i verklig produktion med tidig utgång gjorda, högtM SK2 tillit till självförtroende utgår efter bara MSC3 detektorerna håller med - typiskt **under 10ms**. Den 51 ms här är för att demo-modiet avsperar tidig utgång för att visa alla bidrag

### Full Pipeline (Demo-Modus med LLM

För att jämföra: `demo` policy - hela pipelinen inklusive LLM resonemang . Detta visar vad som händer när detektorer **inte hålla med**:

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

**Detektorer i 1.4 sekunder** - körde LLM och *inte överens* med heuristiken

| Detektor | | | Inverkan | МSK2 | Gewicht || | Weighted |
|----------|--------|--------|----------|--------|
| **LLM** | +0.85 | 2.5 | **+2.13** | "Krom vanligt i robotar, cookies | + | Referent misstänkt
| **Häuristiskt Spät** | -0.77 ♫ ♫ | ♫
| **Heuristik** (
| **UserAgent** | -0.20 ♫ ♫ | ♫
| **Påskrift** | ♫ -0.15 ♫ ♫
| **Vanor** | ♫ -0.10 ♫ ♫
| **ClientSide** | 0.00 ♫ ♫ | ♫
| **Versionsålder** | | | -0.05 |
| **Inkonsistens** | ♫ -0.05 ♫ ♫
| **IP** | 0.00 ♫ ♫ | ♫

Detta är det intressanta fallet - **LLM flaggade det som en potentiell robot** medan alla statiska detektörer sa människan

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

LLMs resonemang registreras som en signal som återspeglar in i lärandesystemet.

Anmärkning:

1. **Heuristiska löpningar två gånger** - tidigt ( före alla detektorer ♫ ) ♫ och senare ♫ ♫ efter alla bevis ♫

2. **LLM höll inte med** - den såg mönster som statiska detektörerna misslyckades med

3. **Ingen fingeravtryck** - ClientSide gav tillbaka 0 eftersom JS inte hade Executerat ' ännu Executerad . I en riktig webblader skulle detta ge mer mänsklig signal

4. **Slutsatsen: tillåt** - även med LLMs misstänksamhet, ', så gynnar de kombinerade bevisen fortfarande människan. `botType: "Scraper"` flagga betyder att den är under observation

Kategorisfördelningen visar spänningen

| Kategorie | Punktzahl | | | Gewicht | МSK3 | Notar ||
|----------|-------|--------|-------|
| **Heuristik** | -3.46 ♫ ♫ | ♫
| **AI** LLM säger att robotar
| UserAgent ♫ ♫ | ♫
| Rubrik | -0.15 | | 3 | 4 | 5 | Alla opskrifte närvarande
| Behaviorell | | | 2 | 3 | 4 | 5 | Normala mönster
| ClientSide
| Versionsålder | | |
| Inkonsistens | | | -0.04 |
| IP ♫ ♫ | ♫

**Totala vikterade poäng: M SK1** → Människor vinner, , men LLMs motsättningar är noterade.

> **Nyckelinsikten:** Systemet inte litar blindt på en enda spårare. När de inte håller med om det, så är beviset viktade och majoriteten vinner. Men opinionsen från minoriteterna registreras för att lära sig.

> **viktigt:** Den här verbosa utgången är demo- endast . I produktionen får du en smal respons via HTTP-kolor (`X-Bot-Confidence`, `X-Bot-RiskBand`, etc .) eller en enkel `context.IsBot()` check. Den fulla JSON är till att avbugera och tända - du ' aldrig skicka det här till klienter

---


## **Genom att använda resultaten**

```csharp
if (context.IsBot())
    return Results.StatusCode(403);

var score = context.GetBotConfidence();  // 0.0-1.0
var risk  = context.GetRiskBand();       // Low/Elevated/Medium/High
```

### Att skydda slutpunkter

```csharp
app.MapGet("/api/data", Secret).BlockBots();
app.MapGet("/sitemap.xml", Sitemap)
   .BlockBots(allowVerifiedBots: true);
```

Risknivåerna guidar handlingen

| Risk | Förtroende | Recommender action M|
| -------- | ---------- | ------------------ |
| låga | < | | 3 | 4 | tillåt | 5
| Upphöjt | 0.3-0.5 | | | Log ♫ / ♫ Takt ♫
| Medel | | | 0.5-0.7 | SSK3 | Utmaningen
| Höga | > | | 3 | 4 | Block | 5

---


## **AI-detektor (Optionell)**

Inte nödvändigt - men användbart för att fånga avancerad automatiseringM SK1

### **Häuristisk detektor (**

Systemet består av en heuristisk detektor som använder logiskt regression med dynamiskt lärda vikter. Det börjar med vettiga standard och utvecklas baserat på detektionsfeedback

Typisk latens: **1-5ms**

```json
{
  "BotDetection": {
    "AiDetection": {
      "Heuristic": {
        "Enabled": true,
        "LoadLearnedWeights": true,
        "EnableWeightLearning": true
      }
    }
  }
}
```

Funktioner extraheras dynamiskt - nya mönster får automatiskt standardvikt och lär sig över tidM SK1 Systemet upptäcker vad som är viktigt *din* trafik.

### **Ollama LLM (Djupen resonemang**

Han fångar flytande robotar som ser ut som "fineM SK1 med snabba regler . Användar [Ollama](https://ollama.com/) för den lokala LLM-förklaringen.

```bash
ollama pull gemma3:1b
```

```json
{
  "BotDetection": {
    "AiDetection": {
      "Provider": "Ollama",
      "Ollama": { "Model": "gemma3:1b" }
    }
  }
}
```

AI är **fel-säkra** - om det

---


## **Lärningssystemet**

Statiska blocklistar går i dödläge. Attacker anpassar sig.
Så det här systemet lär sig

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

Pattern förrutsnar över tid:

* IPs blir omskiljade
* Misskonfigurerade skript blir fixade
* Trafiken förändras naturligt

Utan förödelse blockerar du legitima användare för alltid.

```json
{
  "BotDetection": {
    "Learning": {
      "Enabled": true,
      "ScoreDecayTauHours": 168,
      "GcEligibleDays": 90
    }
  }
}
```

---


## **YARP Gateway: Edge Protection for Your App**

Det finns också ett **Docker-first YARP bakvända proxy** som löser detektorn *före* begäran träffar din app.

```mermaid
flowchart LR
    I[Internet] --> G[YARP Gateway]
    G -->|Human| App[Your App]
    G -->|Search Engine Bot| App
    G -->|Malicious| Block[403]
```

kör den i en linje:

```bash
docker run -p 80:8080 \
  -e DEFAULT_UPSTREAM=http://your-app:3000 \
  scottgal/mostlylucid.yarpgateway
```

Werk på:

* Linux
* macOS
* Windows
* **ARM ( ja , Raspberry PiM SK2**

För anpassad routing:

```yaml
services:
  gateway:
    image: scottgal/mostlylucid.yarpgateway
    volumes:
      - ./yarp.json:/app/config/yarp.json
```

---


## **En rimlig produktionskontroll**

```json
{
  "BotDetection": {
    "BotThreshold": 0.7,
    "BlockDetectedBots": true,
    "EnableAiDetection": true,
    "Learning": { "Enabled": true },
    "PathPolicies": {
      "/api/login": "strict",
      "/sitemap.xml": "allowVerifiedBots"
    }
  }
}
```

---


## **Vart det här kommer**

Det här är en del 1 | ( | översikten
De kommande delar gräver djupare:

* **Del 2**: [Hur botar blev smartare - Den nya gränsen i Bot-detektorn](https://www.mostlylucid.net/blog/botdetection-part2-signature-pipeline-and-stylobot-architecture)
* **Del 3**: beteendeanalys
* **Del 4**: Client - fingeravtryck på sidan
* **Del 5**: Det heuristiska detektorn - lär vikter i realtid
* **Del 6**: LLM-detektionsinterner
* **Del 7**: Lärningssystemet förklarades ordentligt

**Framtidens plan**

* RAG-baserade mönster som matchar vektorbäddar
* Lokala små modellförklaringar via [Llamascharp](https://github.com/SciSharp/LLamaSharp) / ONNX
* Semantisk likhet för att upptäcka nya attacksmönster

Om du vill ha en robotdetektor så kan du *förstå*, *förlänga*, och *springa var som helst*, den här serien är till er

---


## **Akademik & Industry Reading**

Om du vill dyka in i varför det är svårt att upptäcka robotar och vad forskningen säger

### Bot-detektor & Evasion

- [Imperva: State of Bot Traffic Report 2024](https://www.imperva.com/blog/bot-attack-trends/) - verkliga- världsbot attack data
- [OWASP: Bot-Management](https://owasp.org/www-community/attacks/Bot_attack) - säkerhetsfundamentaler
- [Cloudflare: Bot-detektor Übersicht](https://www.cloudflare.com/learning/bots/what-is-bot-detection/) - Branchens perspektiv

### nätverkande av fingeravtryck

- [JA3: SSL/TLS Client Fingerprinting](https://github.com/salesforce/ja3) - TLS-signatur som matchar standarden
- [TCP/IP Fingerprinting](https://lcamtuf.coredump.cx/p0f3/) -nätverk-layer-OS-detektor
- [HTTP/2 Fingerprinting Techniques](https://www.cloudflare.com/learning/http/http2/) - Hur webblader skiljer sig i HTTP

### Behaviorell analys & Anomáliedetektor

- [Detektor avvikelser i data från tidserien (ACM)](https://en.wikipedia.org/wiki/Anomaly_detection) - Statistiska grunder
- [Markovkedjor i Intrusiondetektion](https://en.wikipedia.org/wiki/Markov_chain) - Stadsövergångsmodellering

### LLM-Spowered Threats & Data Poisoning

- [Dataförgiftande attacker på maskininlärning (arXiv](https://arxiv.org/abs/1811.03728) - Varför målar skräper dina data
- [Att extrahera utbildningsdata från stora språkmodeller (arXiv: 2302.07933)](https://arxiv.org/abs/2302.07933) - Varför vill robotar ha din innehåll
- [Web Scraping och upphovsrättsproblem](https://en.wikipedia.org/wiki/Web_scraping#Legal_issues) - Den juridiska vinkeln

### HEADlösa Browser Detektor

- [Puppeteer & Playwright Detection](https://antoinevastel.com/blog/detect-puppeteer-and-playwright/) - Hur hjärnlösa webblader identifieras
- [Canvas fingerprinting & Evasion](https://cvdazzle.com/) - Client

---


## **Projekt länkar**

* **GitHub:** fulla dokument
  [https://~github~.~com~/~scottgal~ /~stylobot](https://github.com/scottgal/stylobot)
* **NuGet:** installera paketet
  [https://www](https://www.nuget.org/packages/mostlylucid.botdetection)
* **Dockerhub:** YARP-portaal
  [https://hub](https://hub.docker.com/r/scottgal/stylobot-gateway)

---


**Utanlicenser - offentlig domain . Använd det som du vill**