BrowserForge .NET

A comprehensive .NET library for generating realistic browser fingerprints and HTTP headers using advanced Bayesian networks. This is a feature-complete port of the popular Python BrowserForge library, designed to help developers create authentic browser automation scenarios while avoiding detection.

🌟 Features

🧠 Bayesian Network Engine: Advanced statistical modeling for generating correlated browser characteristics
🔍 Fingerprint Generation: Create realistic browser fingerprints for Chrome, Firefox, Safari, and Edge
📊 Anomaly Detection: Built-in validation and suspicious pattern detection
🌐 HTTP Header Generation: Generate authentic browser headers with proper correlations
🎭 Browser Automation Integration: Seamless integration with Playwright, Pyppeteer, and other frameworks
📱 Multi-Platform Support: Comprehensive Windows, macOS, and Linux browser characteristics
🔧 Extensive Validation: Hardware consistency checks and realism assessment
⚡ High Performance: Optimized for .NET 9.0 with minimal memory footprint

📦 Installation

NuGet Package Manager

Install-Package BrowserforgeDotnet

.NET CLI

dotnet add package BrowserforgeDotnet

PackageReference

<PackageReference Include="BrowserforgeDotnet" Version="1.0.0" />

🚀 Quick Start

Basic Fingerprint Generation

using BrowserforgeDotnet.Fingerprints;

// Generate a basic realistic fingerprint
var fingerprint = Fingerprint.CreateBasic();

Console.WriteLine($"User Agent: {fingerprint.Navigator.UserAgent}");
Console.WriteLine($"Screen: {fingerprint.Screen.Width}x{fingerprint.Screen.Height}");
Console.WriteLine($"Platform: {fingerprint.Navigator.Platform}");
Console.WriteLine($"Languages: {string.Join(", ", fingerprint.Navigator.Languages)}");

// Export to JSON
var json = fingerprint.ToJson();

HTTP Headers Generation

using BrowserforgeDotnet.Headers;

// Generate realistic HTTP headers
var headers = HeaderGenerator.GenerateHeaders(BrowserType.Chrome);

foreach (var header in headers)
{
    Console.WriteLine($"{header.Key}: {header.Value}");
}

Browser-Specific Fingerprints

// Generate Chrome fingerprint
var chromeFingerprint = Fingerprint.CreateChrome();

// Generate Firefox fingerprint  
var firefoxFingerprint = Fingerprint.CreateFirefox();

// Generate Safari fingerprint
var safariFingerprint = Fingerprint.CreateSafari();

🏗️ Architecture Overview

BrowserForge .NET uses a sophisticated Bayesian network approach to ensure statistical consistency across all generated browser characteristics. The library analyzes real-world browser data patterns to create fingerprints that are indistinguishable from genuine browsers.

Core Components

Bayesian Network Engine: Probabilistic modeling for correlated data generation
Fingerprint Validation: Multi-layered validation system for realism assessment
Anomaly Detection: Pattern recognition for identifying suspicious characteristics
Browser Injectors: Ready-to-use integrations for popular automation frameworks

📚 Detailed Usage Examples

Screen Constraints

using BrowserforgeDotnet.Fingerprints;

// Desktop screen constraints
var desktopScreen = Screen.Desktop();
var fingerprint = Fingerprint.CreateWithScreen(desktopScreen);

// Mobile screen constraints
var mobileScreen = Screen.Mobile();
var mobileFingerprint = Fingerprint.CreateWithScreen(mobileScreen);

// Custom screen constraints
var customScreen = new Screen(
    minWidth: 1440, 
    maxWidth: 2560, 
    minHeight: 900, 
    maxHeight: 1440
);

Advanced Fingerprint Validation

using BrowserforgeDotnet.Fingerprints;

var fingerprint = Fingerprint.CreateBasic();

// Comprehensive validation
var validationResult = FingerprintValidator.ValidateFingerprint(fingerprint);

Console.WriteLine($"Is Valid: {validationResult.IsValid}");
Console.WriteLine($"Suspiciousness Score: {validationResult.SuspiciousnessScore}/100");
Console.WriteLine($"Risk Assessment: {validationResult.GetRiskAssessment()}");

// Check for anomalies
if (validationResult.Anomalies.Any())
{
    Console.WriteLine("Detected anomalies:");
    foreach (var anomaly in validationResult.Anomalies)
    {
        Console.WriteLine($"  - {anomaly.Type}: {anomaly.Description}");
    }
}

Hardware Consistency Validation

// Validate hardware consistency
var hardwareResult = FingerprintUtils.ValidateHardwareConsistency(fingerprint);

Console.WriteLine($"Hardware Consistent: {hardwareResult.IsValid}");
foreach (var issue in hardwareResult.Anomalies)
{
    Console.WriteLine($"Issue: {issue.Description}");
}

Realism Assessment

// Comprehensive realism check
var realismResult = FingerprintUtils.CheckBrowserFingerprintRealism(fingerprint);

Console.WriteLine($"Realistic: {realismResult.IsValid}");
Console.WriteLine($"Suspiciousness Score: {realismResult.SuspiciousnessScore}/100");

// Get detailed breakdown
var scoreBreakdown = FingerprintUtils.GetSuspiciousnessScore(fingerprint);
Console.WriteLine($"Overall Score: {scoreBreakdown.OverallScore}/100");

Console.WriteLine("Risk Factors:");
foreach (var risk in scoreBreakdown.RiskFactors)
{
    Console.WriteLine($"  - {risk}");
}

Console.WriteLine("Recommendations:");
foreach (var recommendation in scoreBreakdown.Recommendations)
{
    Console.WriteLine($"  - {recommendation}");
}

🔧 API Reference

Core Classes

`Fingerprint`

The main class for browser fingerprint generation and manipulation.

public class Fingerprint
{
    public NavigatorFingerprint Navigator { get; set; }
    public ScreenFingerprint Screen { get; set; }
    public List<string> Fonts { get; set; }
    public List<string> VideoCodecs { get; set; }
    public List<string> AudioCodecs { get; set; }
    
    // Factory methods
    public static Fingerprint CreateBasic()
    public static Fingerprint CreateChrome()
    public static Fingerprint CreateFirefox()
    public static Fingerprint CreateSafari()
    public static Fingerprint CreateEdge()
    
    // Export methods
    public string ToJson()
    public Dictionary<string, object> ToDictionary()
}

`NavigatorFingerprint`

Represents browser navigator properties.

public record NavigatorFingerprint
{
    public string UserAgent { get; init; }
    public string Platform { get; init; }
    public string Language { get; init; }
    public List<string> Languages { get; init; }
    public int HardwareConcurrency { get; init; }
    public int? DeviceMemory { get; init; }
    public string Vendor { get; init; }
    public Dictionary<string, object> UserAgentData { get; init; }
}

`FingerprintValidator`

Provides comprehensive fingerprint validation capabilities.

public static class FingerprintValidator
{
    public static ValidationResult ValidateFingerprint(Fingerprint fingerprint)
    public static List<Anomaly> DetectAnomalies(Fingerprint fingerprint)
    public static SuspiciousnessScore GetSuspiciousnessScore(Fingerprint fingerprint)
}

Utility Functions

`FingerprintUtils`

Utility functions for fingerprint manipulation and analysis.

public static class FingerprintUtils
{
    public static BrowserType GetBrowserFromUserAgent(string userAgent)
    public static string GenerateAcceptLanguageHeader(List<string> languages)
    public static Dictionary<string, object> GenerateBatteryInfo()
    public static List<string> FilterFontsForPlatform(List<string> fonts, string platform)
    public static ValidationResult CheckBrowserFingerprintRealism(Fingerprint fingerprint)
    public static ValidationResult ValidateHardwareConsistency(Fingerprint fingerprint)
}

🔗 Integration Examples

Playwright Integration

using Microsoft.Playwright;
using BrowserforgeDotnet.Injectors.Playwright;

// Create realistic fingerprint
var fingerprint = Fingerprint.CreateChrome();

// Launch browser with fingerprint
var browser = await Playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions
{
    Headless = false
});

var context = await browser.NewContextAsync();
var page = await context.NewPageAsync();

// Inject fingerprint
await PlaywrightInjector.InjectFingerprint(page, fingerprint);

// Your automation code here
await page.GotoAsync("https://example.com");

Pyppeteer Integration

using BrowserforgeDotnet.Injectors.Pyppeteer;

// Generate fingerprint and inject into Pyppeteer
var fingerprint = Fingerprint.CreateChrome();
await PyppeteerInjector.InjectFingerprint(page, fingerprint);

Custom HTTP Client

using BrowserforgeDotnet.Headers;

var headers = HeaderGenerator.GenerateHeaders(BrowserType.Chrome);
var client = new HttpClient();

foreach (var header in headers)
{
    client.DefaultRequestHeaders.Add(header.Key, header.Value);
}

🧪 Testing

Running Tests

# Run all tests
dotnet test

# Run with coverage
dotnet test --collect:"XPlat Code Coverage"

# Run specific test category
dotnet test --filter "Category=Fingerprints"

Test Categories

BayesianNetworkTests: Core Bayesian network functionality
FingerprintsTests: Fingerprint generation and validation
HeadersTests: HTTP header generation
FingerprintValidationTests: Validation and anomaly detection
IntegrationTests: Browser automation integration tests

Writing Custom Tests

[Fact]
public void Should_Generate_Valid_Chrome_Fingerprint()
{
    // Arrange & Act
    var fingerprint = Fingerprint.CreateChrome();
    
    // Assert
    fingerprint.Should().NotBeNull();
    fingerprint.Navigator.UserAgent.Should().Contain("Chrome");
    
    var validation = FingerprintValidator.ValidateFingerprint(fingerprint);
    validation.IsValid.Should().BeTrue();
    validation.SuspiciousnessScore.Should().BeLessThan(30);
}

🤝 Contributing

We welcome contributions! Please follow these guidelines:

Fork the repository and create a feature branch
Write tests for any new functionality
Follow C# coding standards and use consistent formatting
Update documentation for any API changes
Submit a pull request with a clear description

Development Setup

# Clone the repository
git clone https://github.com/browserforge/browserforge-dotnet.git
cd browserforge-dotnet

# Restore dependencies
dotnet restore

# Build the solution
dotnet build

# Run tests
dotnet test

Code Style

Follow Microsoft C# Coding Conventions
Use meaningful variable and method names
Add XML documentation for public APIs
Write unit tests for new features

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Credits and Acknowledgments

This .NET library is a port of the original Python BrowserForge project. Special thanks to:

daijro - Original Python BrowserForge author
BrowserForge Contributors - The original Python library contributors
Microsoft - For the excellent .NET ecosystem
xUnit, FluentAssertions, Moq - Testing framework contributors

🔧 System Requirements

.NET 9.0 or later
Memory: Minimum 512MB RAM
Storage: ~50MB for the library and dependencies
Supported OS: Windows, macOS, Linux

📊 Performance Characteristics

Fingerprint Generation: ~1-5ms per fingerprint
Validation: ~10-50ms per fingerprint
Memory Usage: ~10-50MB typical usage
Thread Safety: All public APIs are thread-safe

🆘 Support

Documentation: Wiki
Issues: GitHub Issues
Discussions: GitHub Discussions

🗺️ Roadmap

Additional browser support (Opera, Brave)
Enhanced mobile browser fingerprints
WebRTC fingerprint generation
Canvas fingerprint generation
Audio fingerprint generation
Machine learning-based anomaly detection improvements

Name		Name	Last commit message	Last commit date
Latest commit History 24 Commits
BrowserforgeDotnet		BrowserforgeDotnet
browserforge		browserforge
.gitignore		.gitignore
README.md		README.md

bartasx/browserforgedotnet

Folders and files

Latest commit

History

Repository files navigation