Fluxzy

https://docs.fluxzy.io/documentation/core/
Admin
Fluxzy is a MITM proxy built on .NET that intercepts, records, and modifies HTTP traffic between...
Tokens:13,751
Snippets:122
Trust Score:5.8
Update:7 months ago
Show doc for...
Tokens:
Raw
### Basic Fluxzy Proxy Configuration and Startup (.NET)

Source: https://docs.fluxzy.io/documentation/core/startup-example.html

Demonstrates how to configure and start a Fluxzy proxy using C#. It sets up rules to modify request headers and add response headers. The proxy listens on localhost:8000. This example requires .NET 6.0 or later.

```csharp
using System.Net;
using Fluxzy;
using Fluxzy.Rules.Actions;
using Fluxzy.Rules.Filters;

var fluxzyStartupSetting = FluxzySetting
    .CreateDefault(IPAddress.Loopback, 8000)
    .AddAlterationRules(
        new UpdateRequestHeaderAction("user-agent", "{previous} - MITM-ed by fluxzy"),
        AnyFilter.Default
    )
    .AddAlterationRules(
        new AddResponseHeaderAction("X-Fluxzy-Appended-Response-Header", "Hello"),
        AnyFilter.Default
    );

await using (var proxy = new Proxy(fluxzyStartupSetting))
{
    var _ = proxy.Run();

    Console.WriteLine("Press any key to exit...");
    Console.ReadLine();
}

```

--------------------------------

### Install Fluxzy.Core NuGet Package

Source: https://docs.fluxzy.io/documentation/core/startup-example.html

Adds the Fluxzy.Core NuGet package to your .NET project. This package contains the necessary libraries to use Fluxzy's proxy functionalities.

```shell
dotnet add package Fluxzy.Core

```

--------------------------------

### Create a new .NET Console App

Source: https://docs.fluxzy.io/documentation/core/startup-example.html

Initializes a new .NET console application project. This is the first step to begin developing with Fluxzy.

```shell
dotnet new console

```

--------------------------------

### Full Fluxzy Traffic Capture and Export Example (C#)

Source: https://docs.fluxzy.io/documentation/core/save-http-traffic.html

This comprehensive C# code example illustrates the complete process of capturing HTTP traffic with Fluxzy and exporting it to both `.fxzy` and `.har` files. It includes setting up the proxy, running the capture session, making an HTTP request, and then exporting the captured data. It also highlights the importance of disposing the proxy before exporting.

```csharp
using System.Net;
using Fluxzy;

var captureDirectory = "my_path"; 

var fluxzyStartupSetting = FluxzySetting
    .CreateDefault(IPAddress.Loopback, 44344)
    .SetOutDirectory(captureDirectory);

using var client = new HttpClient(new HttpClientHandler
{
    Proxy = new WebProxy("localhost", 44344)
});

await using (var proxy = new Proxy(fluxzyStartupSetting))
{
    var endPoints = proxy.Run();

    Console.WriteLine($"Fluxzy is listen on the following endpoints: " +
                      $"{string.Join(" ", endPoints.Select(t => t.ToString()))}");

    await client.GetByteArrayAsync("https://example.com");
}

// Capture to a fxzy file 
Packager.Export(captureDirectory, "my_capture_session.fxzy");

// Capture to a har file
Packager.ExportAsHttpArchive(captureDirectory, "my_capture_session.har");
```

--------------------------------

### Install Fluxzy.Core via NuGet

Source: https://docs.fluxzy.io/documentation/core/introduction.html

Installs the Fluxzy.Core NuGet package, providing the core MITM proxy functionality for recording and altering HTTP traffic through filters and actions.

```powershell
PM> Install-Package Fluxzy.Core
```

--------------------------------

### FluxzySetting: Default Configuration Initialization (.NET)

Source: https://docs.fluxzy.io/documentation/core/startup-example.html

Initializes the `FluxzySetting` with default parameters, specifying the IP address and port for the proxy to listen on. If arguments are omitted, it defaults to 127.0.0.1 on port 44344.

```csharp
var fluxzyStartupSetting = FluxzySetting
            .CreateDefault(IPAddress.Loopback, 8000)

```

--------------------------------

### Full Example: Capture PCAPNG for HttpClient Request

Source: https://docs.fluxzy.io/documentation/core/04-capture-raw-packets.html

Demonstrates a complete example of capturing the raw PCAPNG file for an `System.Net.HttpClient` request to 'https://www.example.com'. It configures Fluxzy to use the `CapturedTcpConnectionProvider`, sets up an `HttpClient` to use the Fluxzy proxy, makes a request, and then extracts and saves the raw capture and merges all captures.

```csharp
using System.Net;
using Fluxzy;
using Fluxzy.Core.Pcap;
using Fluxzy.Core.Pcap.Pcapng.Merge;
using Fluxzy.Readers;

var tempDirectory = "fluxzy_dump_folder";

var fluxzyStartupSetting = FluxzySetting
    .CreateDefault()
    .SetOutDirectory(tempDirectory);

await using (var tcpConnectionProvider = await CapturedTcpConnectionProvider.CreateInProcessCapture())
{
    await using var proxy = new Proxy(fluxzyStartupSetting, tcpConnectionProvider: tcpConnectionProvider);

    var endpoints = proxy.Run();

    using var httpClient = new HttpClient(new HttpClientHandler()
    {
        // We instruct the HttpClient to use the proxy
        Proxy = new WebProxy("127.0.0.1", endpoints.First().Port),
        UseProxy = true
    });

    // Make a request to a remote website
    using var response = await httpClient.GetAsync("https://www.example.com/");

    // Fluxzy is in full streaming mode, this means that the actual body content 
    // is only captured when the client reads it. 
    await (await response.Content.ReadAsStreamAsync()).CopyToAsync(Stream.Null);
}

using var archiveReader = new DirectoryArchiveReader(tempDirectory);

// We retrieve back the exchange related to the request to example.com
var requestExchange =
    archiveReader.ReadAllExchanges().First(r => r.KnownAuthority == "www.example.com");

using var pcapFileStream = File.Create("example.com.pcapng");

// We copy the raw packets to a pcap file
await archiveReader.GetRawCaptureStream(requestExchange!.ConnectionId!)!.CopyToAsync(pcapFileStream);

using var mergePcapFileStream = File.Create("all-captures.pcapng");
PcapMerge.MergeDumpDirectory(tempDirectory, mergePcapFileStream);
```

--------------------------------

### Install Fluxzy.Core.Pcap via NuGet

Source: https://docs.fluxzy.io/documentation/core/introduction.html

Installs the Fluxzy.Core.Pcap NuGet package, which includes the core MITM proxy logic and enables raw packet capture. This package is a transitive dependency of Fluxzy.Core.

```powershell
PM> Install-Package Fluxzy.Core.Pcap
```

--------------------------------

### Test Fluxzy Proxy with curl

Source: https://docs.fluxzy.io/documentation/core/startup-example.html

Uses the `curl` command to send a HEAD request to a target URL through the configured Fluxzy proxy. This tests the proxy's ability to modify request headers and add response headers.

```shell
curl -x 127.0.0.1:8000 -I -k https://example.com

```

--------------------------------

### Forward Request with Fluxzy

Source: https://docs.fluxzy.io/documentation/core/short-examples/forward-request.html

This C# code snippet demonstrates how to configure Fluxzy to forward requests. It initializes Fluxzy settings, adds a rule to forward requests to 'https://qwant.com/' for hosts ending with 'google.com', and then starts a proxy server.

```csharp
using Fluxzy;
using Fluxzy.Rules.Actions;
using Fluxzy.Rules.Filters;
using Fluxzy.Rules.Filters.RequestFilters;

var fluxzySetting = FluxzySetting.CreateDefault();

fluxzySetting.AddAlterationRules(
    new ForwardAction("https://qwant.com/"),
    new HostFilter("google.com", StringSelectorOperation.EndsWith));

// Create a new proxy instance 
await using var proxy = new Proxy(fluxzySetting);

Console.WriteLine("Press any key to exit");
Console.ReadKey();
```

--------------------------------

### FluxzySetting: Add Response Header Appending Rule (.NET)

Source: https://docs.fluxzy.io/documentation/core/startup-example.html

Adds a rule to append a new response header named 'X-Fluxzy-Appended-Response-Header' with the value 'Hello'. This action is performed when `AnyFilter.Default` is satisfied.

```csharp
.AddAlterationRules(
        new AddResponseHeaderAction("X-Fluxzy-Appended-Response-Header", "Hello"),
        AnyFilter.Default
    )

```

--------------------------------

### Example Rule File Structure (YAML)

Source: https://docs.fluxzy.io/documentation/core/how-to-use-rule-file.html

This YAML structure defines rules for Fluxzy, each consisting of a filter and a list of actions. Filters determine when a rule is applied (e.g., based on host or request method), and actions specify modifications to the request or response (e.g., setting cookies, adding headers).

```yaml
rules:
- filter: 
    type: HostFilter
    pattern: example.com
    operation: endsWith
  actions:
    - type: setRequestCookieAction
      name: my-session-cookie
      value: my-session-value
- filter: 
    type: PostFilter
  actions:
    - type: AddResponseHeaderAction
      headerName: X-Proxy
      headerValue: Passed through fluxzy
    - type: ForceHTTP11Action
```

--------------------------------

### C# Example: Hooking Fluxzy Events

Source: https://docs.fluxzy.io/documentation/core/hooking-events.html

This C# code snippet demonstrates how to hook into Fluxzy's event system to receive notifications for ExchangeUpdated and ConnectionUpdated events. It initializes Fluxzy, sets up event handlers to print basic information about the events, and then runs the proxy. This allows for observing exchange and connection states without altering them.

```csharp
using Fluxzy;

var fluxzySetting = FluxzySetting.CreateDefault();

// Create a new proxy instance 

await using (var proxy = new Proxy(fluxzySetting))
{
    proxy.Writer.ExchangeUpdated += (_, args) =>
    {
        // Do something with the exchange
        // args.Exchange

        Console.WriteLine($"#{args.ExchangeInfo.Id:0000} {args.UpdateType}: " +
                          $"{args.ExchangeInfo.Method} {args.ExchangeInfo.FullUrl}");
    };

    proxy.Writer.ConnectionUpdated += (_, args) =>
    {
        // Do something with the exchange
        // args.Exchange

        Console.WriteLine($"#{args.Connection.Id:0000} New connection: " +
                          $"{args.Connection.Authority.HostName} {args.Connection.Authority.Port}");
    };

    proxy.Run();

    Console.WriteLine("Press any key to exit");
    Console.ReadKey();
}
```

--------------------------------

### Configure Alteration Rule Fluently

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Configures an alteration rule using a fluent API. This example adds a rule that appends 'X-Proxy: Passed through fluxzy' to any response.

```csharp
fluxzySetting.ConfigureRule()
    .When(AnyFilter.Default)
        .Do(new AddResponseHeaderAction("X-Proxy", "Passed through fluxzy"));
```

--------------------------------

### FluxzySetting: Add Request Header Modification Rule (.NET)

Source: https://docs.fluxzy.io/documentation/core/startup-example.html

Adds a rule to modify the 'user-agent' request header. It appends a string to the existing value using the `{previous}` placeholder, which represents the original header value. This rule is applied when `AnyFilter.Default` is met.

```csharp
.AddAlterationRules(
        new UpdateRequestHeaderAction("user-agent", "{{previous}} - Relayed by fluxzy"),
        AnyFilter.Default
    )

```

--------------------------------

### Set Save Filter for Traffic

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Configures a filter to control which traffic is saved to disk. This example saves only requests made to 'google.com' using an EndsWith string selector operation.

```csharp
// Save only requests that are made to google.com
fluxzySetting.SetSaveFilter(new HostFilter("google.com", StringSelectorOperation.EndsWith));
```

--------------------------------

### Get Default CA Certificate for Fluxzy

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Retrieves the default built-in CA certificate used by Fluxzy for producing on-the-fly certificates for HTTPS interception. Returns a System.Security.Cryptography.X509Certificates.X509Certificate2 object.

```csharp
// Will return a System.Security.Cryptography.X509Certificates.X509Certificate2
var defaultCertificate = Certificate.UseDefault().GetX509Certificate();
```

--------------------------------

### FluxzySetting Initialization and Network Binding

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Demonstrates how to create a default FluxzySetting instance and configure listening addresses and ports.

```APIDOC
## FluxzySetting Initialization and Network Binding

### Description
This section covers the initialization of the `FluxzySetting` class and how to specify the network addresses and ports the proxy should listen on. It is recommended to use the static `CreateDefault` method for obtaining an instance.

### Method
Static methods and instance methods

### Endpoint
N/A (Configuration class)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
// Create a default setting listening on loopback address and default port 44344
var fluxzySetting = FluxzySetting.CreateDefault(IPAddress.Loopback, 44344);

// Add another endpoint to listen on IPv6 loopback address and port 8080
fluxzySetting.AddBoundAddress(IPAddress.IPv6Loopback, 8080);

// Add another endpoint to listen on any IPv4 address and port 8081
fluxzySetting.AddBoundAddress("0.0.0.0", 8081);

// Using port 0 lets the OS choose a free port
fluxzySetting.AddBoundAddress(IPAddress.Loopback, 0);
```

### Response
#### Success Response (200)
N/A (Configuration class)

#### Response Example
N/A
```

--------------------------------

### Configuring SSL Engine

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Explains how to switch between the default .NET SSL provider and Bouncy Castle for SSL/TLS connections.

```APIDOC
## Configuring SSL Engine

### Description
This section describes how to configure the SSL/TLS engine used by Fluxzy for connecting to remote hosts. You can choose between the default operating system's SSL provider or Bouncy Castle.

### Method
Instance methods

### Endpoint
N/A (Configuration class)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
// Use Bouncy Castle as the SSL engine
fluxzySetting.UseBouncyCastleSslEngine();

// Revert to the default OS SSL engine
fluxzySetting.UseOsSslEngine();
```

### Response
#### Success Response (200)
N/A (Configuration class)

#### Response Example
N/A
```

--------------------------------

### Fluxzy CLI Rule File Usage

Source: https://docs.fluxzy.io/documentation/core/how-to-use-rule-file.html

This command demonstrates how to specify a rule file to the Fluxzy CLI using the -r or --rule-file option. This allows you to configure the CLI's behavior without recompiling the application.

```bash
fluxzy start --rule-file my-rule-file.yaml
```

--------------------------------

### Load and Set Custom Root Certificate in Fluxzy (C#)

Source: https://docs.fluxzy.io/documentation/core/short-examples/use-custom-root-certificate.html

Demonstrates how to load a custom root certificate from a PKCS#12 file and set it for Fluxzy. This involves creating a FluxzySetting, loading the certificate using the Certificate class, and then applying it to the Fluxzy setting before initializing the proxy. Requires the Fluxzy SDK.

```csharp
using Fluxzy;
using Fluxzy.Certificates;

var fluxzySetting = FluxzySetting.CreateDefault();

var myPkcs12Certificate = Certificate.LoadFromPkcs12("/path/to/ca.com.pfx", "password");

// Alternatively, you can use Certificate.LoadFromUserStoreByThumbprint()
// to load the certificate from the default user store

fluxzySetting.SetCaCertificate(myPkcs12Certificate);

await using var proxy = new Proxy(fluxzySetting);

Console.WriteLine("Press any key to exit");
Console.ReadKey();
```

--------------------------------

### Configuring CA Certificates

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Explains how to use the default CA certificate or provide a custom certificate (from a file or store) for SSL interception.

```APIDOC
## Configuring CA Certificates

### Description
This section details how to manage the Certificate Authority (CA) certificate used by Fluxzy for SSL interception. You can retrieve the default certificate or load your own from a PKCS12 file or the Windows certificate store.

### Method
Static methods and instance methods

### Endpoint
N/A (Configuration class)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
// Get the default CA certificate
var defaultCertificate = Certificate.UseDefault().GetX509Certificate();

// Load a certificate from a PKCS12 file
var p12Certificate = Certificate.LoadFromPkcs12("pcks12File.p12", "password");

// Load a certificate from the user store by its thumbprint
var storeCertificate = Certificate.LoadFromUserStoreByThumbprint("certificateThumbprint");

// Set the CA certificate on the FluxzySetting instance
fluxzySetting.SetCaCertificate(p12Certificate); // Or defaultCertificate, storeCertificate
```

### Response
#### Success Response (200)
N/A (Configuration class)

#### Response Example
N/A
```

--------------------------------

### Mock Response with File, JSON, and Forwarding - C#

Source: https://docs.fluxzy.io/documentation/core/short-examples/mock-response.html

This C# code snippet demonstrates how to configure Fluxzy to mock responses. It uses `WhenUriMatch` to specify URL patterns and `ReplyFile` to serve a file, `ReplyJson` to return a JSON string, and `Forward` to redirect requests. It sets up a proxy instance and waits for user input.

```csharp
using Fluxzy;
using Fluxzy.Rules.Actions;
using Fluxzy.Rules.Actions.HighLevelActions;
using Fluxzy.Rules.Filters;
using Fluxzy.Rules.Filters.RequestFilters;

var fluxzySetting = FluxzySetting.CreateDefault();

fluxzySetting.ConfigureRule()
    .WhenUriMatch("https://server.com/api/animal/dogs", StringSelectorOperation.StartsWith)
    .ReplyFile("/path/to/dog.jpeg", 200, "image/jpeg")
    .WhenUriMatch("https://server.com/api/animal/cats", StringSelectorOperation.StartsWith)
    .ReplyJson(@"[
                   {
                     "name": "opale"
                   }
                 ]")
    .WhenAll(new PostFilter(), new HostFilter("www.google.com"))
    .Forward("https://www.example.com"); 

// Create a new proxy instance 
await using var proxy = new Proxy(fluxzySetting);

Console.WriteLine("Press any key to exit");
Console.ReadKey();

```

--------------------------------

### Load Rule File Content as String in C#

Source: https://docs.fluxzy.io/documentation/core/example-load-rule-file.html

Demonstrates loading rule file content from a YAML string and adding it to Fluxzy settings. This method is useful for dynamic rule configuration within the application. It requires the Fluxzy SDK and standard .NET libraries.

```csharp
using System.Net;
using Fluxzy;

var ruleContent = File.ReadAllText("rule.yaml");

var fluxzyStartupSetting = FluxzySetting
    .CreateDefault(IPAddress.Loopback, 44344)
    .AddAlterationRules(ruleContent);

await using var proxy = new Proxy(fluxzyStartupSetting);

_ = proxy.Run();

Console.WriteLine("Press any key to exit");
Console.ReadKey();
```

--------------------------------

### Enable Traffic Archiving to Directory

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Enables saving traffic to disk by specifying an archiving policy that creates output in a specified directory. Live capturing can only output to a directory.

```csharp
// Save the trafic to the directory
fluxzySetting.SetArchivingPolicy(ArchivingPolicy.CreateFromDirectory("out_directory"));
```

--------------------------------

### Configuring Save Filters

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Shows how to apply filters to control which traffic is saved to disk.

```APIDOC
## Configuring Save Filters

### Description
This section explains how to use save filters to selectively save traffic to disk. Filters can be based on various criteria, such as hostnames.

### Method
Instance methods

### Endpoint
N/A (Configuration class)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
// Save only requests made to google.com (ending with)
fluxzySetting.SetSaveFilter(new HostFilter("google.com", StringSelectorOperation.EndsWith));
```

### Response
#### Success Response (200)
N/A (Configuration class)

#### Response Example
N/A
```

--------------------------------

### Use Existing Certificate with UseCertificateAction (C#)

Source: https://docs.fluxzy.io/documentation/core/short-examples/use-existing-certificate.html

This snippet demonstrates how to configure Fluxzy to use an existing PKCS12 certificate for a specific host. It involves loading the certificate, defining a rule to match the host, and applying the `UseCertificateAction`. This is useful when you have a custom certificate you need to use for SSL/TLS termination.

```csharp
using Fluxzy;
using Fluxzy.Certificates;
using Fluxzy.Rules.Actions;
using Fluxzy.Rules.Filters;
using Fluxzy.Rules.Filters.RequestFilters;

var fluxzySetting = FluxzySetting.CreateDefault();

var myPkcs12Certificate = Certificate.LoadFromPkcs12("/path/to/mydomain.com.pfx", "password");

fluxzySetting.ConfigureRule()
    .WhenHostMatch("mydomain.com", StringSelectorOperation.EndsWith)
    .Do(new UseCertificateAction(myPkcs12Certificate));

// Create a new proxy instance 
await using var proxy = new Proxy(fluxzySetting);

Console.WriteLine("Press any key to exit");
Console.ReadKey();

```

--------------------------------

### Create Default FluxzySetting Instance

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Creates a default FluxzySetting instance, specifying listen addresses and ports. If not provided, defaults to IPV4 loopback and port 44344.

```csharp
var fluxzySetting = FluxzySetting
    .CreateDefault(IPAddress.Loopback, 44344);
```

--------------------------------

### Load Custom CA Certificate from User Store

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Loads a custom CA certificate from the default user store using its thumbprint. The certificate must be a valid CA certificate and include the private key.

```csharp
// Load from default user store 
var storeCertificate = Certificate.LoadFromUserStoreByThumbprint("certificateThumbprint");
```

--------------------------------

### Implement Custom Fluxzy Action in C#

Source: https://docs.fluxzy.io/documentation/core/05-low-level-filters.html

Demonstrates how to create a custom action by inheriting from Fluxzy.Rules.Action. It overrides key properties like ActionScope and DefaultDescription, and implements the InternalAlter method to modify exchange contexts, such as aborting connections or altering headers. This requires the Fluxzy.Core and Fluxzy.Rules NuGet packages.

```csharp
using Fluxzy.Core;
using Fluxzy.Core.Breakpoints;
using Fluxzy.Rules;
using Action = Fluxzy.Rules.Action;

namespace low_level_filters;

public class ShowCaseAction : Action
{
    public override FilterScope ActionScope => FilterScope.OnAuthorityReceived;

    public override string DefaultDescription => nameof(ShowCaseAction);

    public override ValueTask InternalAlter(ExchangeContext context, Exchange? exchange, Connection? connection,
        FilterScope scope,
        BreakPointManager breakPointManager)
    {
        // Uncomment this line to abort the connection
        // context.Abort = true;

        // Uncomment this line to skip SSL decryption
        // context.BlindMode = true; 

        // Uncomment this line to add a client certificate to the request
        // context.ClientCertificates ??= new();
        // context.ClientCertificates.Add(Certificate.LoadFromPkcs12("my-pkcs-12.p12", "password"));

        // Uncomment this line to add a server certificate to the action
        // context.ServerCertificate = new X509Certificate2("domain-cert.pfx", "password")

        // Add a new request header 
        // context.RequestHeaderAlterations.Add(new HeaderAlterationReplace("User-Agent", "My Custom Hook", true));

        // Explore provided argument to see all possible actions

        return default;
    }
}
```

--------------------------------

### Add Custom Action to Fluxzy Proxy Settings (C#)

Source: https://docs.fluxzy.io/documentation/core/05-low-level-filters.html

This C# code illustrates how to configure Fluxzy settings to include a custom action. It demonstrates creating default settings, adding a rule with a custom filter and action, and then adding the `GreedyMockAction` to the alteration rules for any request.

```csharp
using Fluxzy;
using low_level_filters;

var fluxzySetting = FluxzySetting.CreateDefault();

fluxzySetting.ConfigureRule()
    .When(new ShowCaseFilter())
    .Do(new ShowCaseAction());

// We add our custom action to the default setting
fluxzySetting.AddAlterationRulesForAny(new GreedyMockAction());

// Create a new proxy instance
await using (var _ = new Proxy(fluxzySetting))
{
    Console.WriteLine("Press any key to exit");
}

```

--------------------------------

### Load Custom CA Certificate from PKCS12 File

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Loads a custom CA certificate from a PKCS12 file, requiring the file path and password. This certificate must be a valid CA certificate and contain a private key.

```csharp
// Load from a PKCS12 file
var p12Certificate = Certificate.LoadFromPkcs12("pcks12File.p12", "password");
```

--------------------------------

### Implement IStreamSubstitution for Mocked Response Body (C#)

Source: https://docs.fluxzy.io/documentation/core/05-low-level-filters.html

This C# code demonstrates how to implement the `IStreamSubstitution` interface to replace the original response stream with a mocked one. It includes draining the original stream to prevent connection hangs and returning a new `MemoryStream` with custom content.

```csharp
using System.Text;
using Fluxzy.Core;
using Fluxzy.Misc.Streams;

namespace low_level_filters;

internal class GreedyMockSubstitution : IStreamSubstitution
{
    public async ValueTask<Stream> Substitute(Stream originalStream)
    {
        // We must drain the original stream to prevent the remote connection from hanging
        // DrainAsync is an extension method from Fluxzy.Misc.Streams.StreamExtensions that will read
        // the stream until EOF and return the content length

        await originalStream.DrainAsync();

        // Return a new stream with a mocked response for the sake of this example
        return new MemoryStream(Encoding.UTF8.GetBytes("This response wash mocked"));
    }
}

```

--------------------------------

### Register System Proxy with Fluxzy Core (C#)

Source: https://docs.fluxzy.io/documentation/core/06-capturing-os-trafic.html

This C# code snippet demonstrates how to use Fluxzy.Core to automatically deflect OS traffic. It initializes a new proxy instance, retrieves listening endpoints, registers the first available endpoint as the system proxy, and shows how to unregister it using DisposeAsync().

```csharp
using Fluxzy;
using Fluxzy.Core;

// Create a new proxy instance 
await using var proxy = new Proxy(FluxzySetting.CreateDefault());

// Proxy run will returns the endpoints that the proxy is listening on
var endPoints = proxy.Run();

// Pick an endpoint and register it as the system proxy
var proxyRegistration = await SystemProxyRegistrationHelper.Create(endPoints.First());

// System proxy is now set 

// Call DisposeAsync() to unregister the proxy
await proxyRegistration.DisposeAsync();
```

--------------------------------

### Enable NSS Key Log Collection with Bouncy Castle SSL Provider

Source: https://docs.fluxzy.io/documentation/core/04-capture-raw-packets.html

Configures Fluxzy to use the Bouncy Castle SSL provider and enable NSS key log collection. This involves adding `.UseBouncyCastleSslProvider()` to the `FluxzySetting` and then using `IArchiveReader.GetRawCaptureKeyStream` and `PcapngUtils.CreatePcapngFileWithKeysAsync` to create a deciphered PCAPNG file.

```csharp
var fluxzyStartupSetting = FluxzySetting
    .CreateDefault()
    .SetOutDirectory(tempDirectory)
    .UseBouncyCastleSslProvider(); // Add this line
```

```csharp
// create the stream to store the final pcapng file 
using var finalPcapStream = File.Create("example.com.deciphered.pcapng");

// retrieve the encrypted raw pcapng file as stream
using var encryptedRawPcapStream = archiveReader.GetRawCaptureStream(requestExchange.ConnectionId)!; 

// read the NSS Key log 
var nssKeyLog = archiveReader.GetRawCaptureKeyStream(requestExchange.ConnectionId)
    !.ReadToEndGreedy(); // This method is reads a stream to end and return the result as string, assuming UTF8.

// The helper that will combine the NSS key log and the encrypting pcapng file to a final pcapng file 
await PcapngUtils.CreatePcapngFileWithKeysAsync(nssKeyLog, encryptedRawPcapStream, finalPcapStream);
```

--------------------------------

### Revert to Default OS SSL Provider

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Reverts Fluxzy's SSL provider back to the default operating system's SSL engine, disabling the use of Bouncy Castle.

```csharp
fluxzySetting.UseOsSslEngine();
```

--------------------------------

### Limiting Concurrent Connections

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Details how to limit the number of concurrent HTTP/1.1 connections per host.

```APIDOC
## Limiting Concurrent Connections

### Description
This section explains how to limit the number of concurrent HTTP/1.1 connections that Fluxzy can establish to a single host. This setting does not apply to HTTP/2 connections due to their multiplexing nature.

### Method
Instance methods

### Endpoint
N/A (Configuration class)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
// Set the maximum number of concurrent connections per host to 32
fluxzySetting.SetConnectionPerHost(32);
```

### Response
#### Success Response (200)
N/A (Configuration class)

#### Response Example
N/A
```

--------------------------------

### Export Capture Session to HAR File using C#

Source: https://docs.fluxzy.io/documentation/core/short-examples/export-http-archive-format.html

This C# code snippet demonstrates how to initiate a capture session with Fluxzy, set an output directory, and then export the captured data to an HTTP Archive (HAR) file. It utilizes the `FluxzySetting` and `Packager` classes.

```csharp
using Fluxzy;

var tempDirectory = "/path/to/temp/directory";

var fluxzySetting = FluxzySetting.CreateDefault();

fluxzySetting.SetOutDirectory(tempDirectory);

// Create a new proxy instance 
await using (var proxy = new Proxy(fluxzySetting))
{
    // Connect to client to 127.0.0.1:443 proxy

    Console.WriteLine("Press any key to exit");
    Console.ReadKey();
}

Packager.ExportAsHttpArchive(tempDirectory, "export.har");
```

--------------------------------

### Implement Custom Fluxzy Filter in C#

Source: https://docs.fluxzy.io/documentation/core/05-low-level-filters.html

Shows how to create a custom filter by inheriting from Fluxzy.Rules.Filter. It overrides the InternalApply method to define filtering logic, returning a boolean to indicate a match, and specifies the FilterScope for evaluation timing. This requires the Fluxzy and Fluxzy.Rules NuGet packages.

```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Fluxzy;
using Fluxzy.Core;
using Fluxzy.Rules;
using Fluxzy.Rules.Filters;

namespace low_level_filters
{
    public class ShowCaseFilter : Filter
    {
        protected override bool InternalApply(ExchangeContext? exchangeContext, IAuthority authority, IExchange? exchange,
            IFilteringContext? filteringContext)
        {
            // Should returns true 

            return true;
        }

        public override IEnumerable<FilterExample> GetExamples()
        {
            yield break;
        }

        /// <summary>
        ///  Indicated the timing where this filter is evaluated
        /// </summary>
        public override FilterScope FilterScope => FilterScope.RequestHeaderReceivedFromClient;
    }
}
```

--------------------------------

### Enabling Traffic Archiving

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Details how to configure Fluxzy to save captured network traffic to disk.

```APIDOC
## Enabling Traffic Archiving

### Description
This section describes how to enable the feature to save captured network traffic to disk. This is done by specifying an archiving policy using `SetArchivingPolicy` or its shortcut `SetOutDirectory`.

### Method
Instance methods

### Endpoint
N/A (Configuration class)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
// Save traffic to a specified directory
fluxzySetting.SetArchivingPolicy(ArchivingPolicy.CreateFromDirectory("out_directory"));

// Using the shortcut method
fluxzySetting.SetOutDirectory("out_directory");
```

### Response
#### Success Response (200)
N/A (Configuration class)

#### Response Example
N/A
```

--------------------------------

### Read from Fxzy Archive File - C#

Source: https://docs.fluxzy.io/documentation/core/03-reading-archives.html

Shows how to instantiate FxzyArchiveReader to read data from a .fxzy file. This file format is optimized for storing HTTP sessions and PCAPNG data, ensuring rapid I/O during capture sessions.

```csharp
var reader = new FxzyArchiveReader("path/to/fxzy/file");

// call subsequent method to retrieve a particular exchange or connection
```

--------------------------------

### Configure Client Certificate Authentication in Fluxzy (C#)

Source: https://docs.fluxzy.io/documentation/core/short-examples/client-certificate.html

This C# code demonstrates how to configure Fluxzy to use a client certificate for mutual TLS authentication. It loads a certificate from a PKCS12 file and applies it as an alteration rule for a specific absolute URI. Dependencies include the Fluxzy SDK. The input is a PKCS12 file path, password, and target URI. The output is a configured Fluxzy proxy instance.

```csharp
using Fluxzy;
using Fluxzy.Certificates;
using Fluxzy.Rules.Actions;
using Fluxzy.Rules.Filters.RequestFilters;

var fluxzySetting = FluxzySetting.CreateDefault();

var certificate = Certificate.LoadFromPkcs12("clientCertificiate.p12", "password");

fluxzySetting.AddAlterationRules(
    new SetClientCertificateAction(certificate),
    new AbsoluteUriFilter("https://customapi.com/animals/cats"));

// Create a new proxy instance 
await using var proxy = new Proxy(fluxzySetting);

Console.WriteLine("Press any key to exit");
Console.ReadKey();
```

--------------------------------

### Read from Directory Archive - C#

Source: https://docs.fluxzy.io/documentation/core/03-reading-archives.html

Demonstrates how to initialize and use DirectoryArchiveReader to read from a directory containing Fluxzy archive data. This reader allows access to HTTP sessions and PCAPNG data stored within the directory structure.

```csharp
IArchiveReader reader = new DirectoryArchiveReader("path/to/directory");

// call subsequent method to retrieve a particular exchange or connection
```

--------------------------------

### Set Output Directory for Fluxzy Capture using C#

Source: https://docs.fluxzy.io/documentation/core/short-examples/export-http-archive-format.html

This C# code snippet shows how to configure the output directory for Fluxzy's capture sessions. It uses the `SetOutDirectory` method of the `FluxzySetting` class to specify where temporary files and exported data will be stored.

```csharp
fluxzySetting.SetOutDirectory(tempDirectory);
```

--------------------------------

### Configure Fluxzy to Save Traffic to a Directory (C#)

Source: https://docs.fluxzy.io/documentation/core/save-http-traffic.html

This snippet demonstrates how to configure Fluxzy to save captured HTTP traffic to a specified directory. It uses the `FluxzySetting` class and its `SetOutDirectory()` method to define the location for storing traffic data. This is a prerequisite for exporting the traffic later.

```csharp
var fluxzyStartupSetting = FluxzySetting
    .CreateDefault()
    .SetOutDirectory("my_capture_session_directory");
```

--------------------------------

### Export Captured Traffic to Files (C#)

Source: https://docs.fluxzy.io/documentation/core/save-http-traffic.html

This snippet shows how to export captured HTTP traffic from a directory to either a Fluxzy Archive File (`.fxzy`) or an HTTP Archive (`.har`) file. It utilizes the `Packager` helper class with its `Export()` and `ExportAsHttpArchive()` methods, respectively. This step is performed after the capture session has ended.

```csharp
// Export to a fxzy file
Packager.Export("my_capture_session_directory", "my_capture_session.fxzy");

// Export to a HAR file
Packager.ExportAsHttpArchive("my_capture_session_directory", "my_capture_session.har");
```

--------------------------------

### Register Custom Fluxzy Action and Filter in C#

Source: https://docs.fluxzy.io/documentation/core/05-low-level-filters.html

Illustrates how to register custom filters and actions with Fluxzy settings. It uses the ConfigureRule method to chain a custom filter (ShowCaseFilter) with a custom action (ShowCaseAction), defining the conditions under which the action should be performed. This requires the Fluxzy core library.

```csharp
var fluxzySetting = FluxzySetting.CreateDefault();

fluxzySetting.ConfigureRule()
    .When(new ShowCaseFilter())
    .Do(new ShowCaseAction());
```

--------------------------------

### Inject HTML Tag Action in C#

Source: https://docs.fluxzy.io/documentation/core/short-examples/inject-code-in-html-pages.html

Demonstrates how to use the InjectHtmlTagAction in C# to insert a style tag into the `<head>` of HTML pages. This action is part of the Fluxzy proxy configuration and requires specifying the HTML content and the target tag.

```csharp
// See https://aka.ms/new-console-template for more information

using Fluxzy;
using Fluxzy.Rules.Actions.HighLevelActions;
using Fluxzy.Rules.Filters.RequestFilters;

var fluxzySetting = FluxzySetting.CreateDefault();

fluxzySetting.ConfigureRule()
    // When the content type is text/html
    .When(new RequestHeaderFilter("text/html", "content-type"))

    // Inject the following html tag into the head tag
    .Do(new InjectHtmlTagAction()
    {
        HtmlContent = "<style>body { background-color: red !important; }</style>",
        Tag = "head",
    });

await using var proxy = new Proxy(fluxzySetting);

Console.WriteLine("Press any key to exit");

Console.ReadKey();

```

--------------------------------

### Skip SSL Tunneling with Complex Filters

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Utilize the `SkipSslTunnelingAction` for more advanced filtering of SSL traffic. This allows for the creation of complex rules based on host patterns using regular expressions.

```csharp
fluxzySetting.AddAlterationRules(new Rule(new SkipSslTunnelingAction(),
    new HostFilter(@"google\.(com)|(fr)$", StringSelectorOperation.Regex)));
```

--------------------------------

### Use Bouncy Castle SSL Provider

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Configures Fluxzy to use Bouncy Castle as the SSL provider for connecting to remote hosts. This enables gathering NSS keys from SSL sessions.

```csharp
fluxzySetting.UseBouncyCastleSslEngine();
```

--------------------------------

### Add Tunneled Hosts for SSL Decryption Skip

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Avoid decrypting SSL traffic for specified hosts by calling the `AddTunneledHosts` method. This is a straightforward way to exclude domains from SSL interception.

```csharp
fluxzySetting.AddTunneledHosts("google.com", "example.com");
```

--------------------------------

### Adding Alteration Rules

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Details how to add rules to modify traffic traversing Fluxzy, including adding headers or applying transformations.

```APIDOC
## Adding Alteration Rules

### Description
This section covers how to define and add alteration rules to modify requests or responses. Rules consist of filters to match traffic and actions to perform on the matched traffic.

### Method
Instance methods

### Endpoint
N/A (Configuration class)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
// Add a rule to append a response header to any response
fluxzySetting.AddAlterationRules(
    new Rule(
        new AddResponseHeaderAction("X-Proxy", "Passed through fluxzy"),
        AnyFilter.Default
    )
);

// Using fluent API to configure a rule
fluxzySetting.ConfigureRule()
    .When(AnyFilter.Default)
        .Do(new AddResponseHeaderAction("X-Proxy", "Passed through fluxzy"));

// Load rules from a rule file
// fluxzySetting.AddAlterationRules("path/to/rules.json");
```

### Response
#### Success Response (200)
N/A (Configuration class)

#### Response Example
N/A
```

--------------------------------

### Convert HAR File to Fluxzy Directory - C#

Source: https://docs.fluxzy.io/documentation/core/03-reading-archives.html

Illustrates the use of HarImportEngine to convert a HAR (HTTP Archive) file into a Fluxzy dump directory. This utility method facilitates the integration of existing HAR files into the Fluxzy ecosystem for analysis.

```csharp
var harImportEngine = new HarImportEngine();
harImportEngine.WriteToDirectory("file.har", "fluxzy_dump_directory");
```

--------------------------------

### Limit Concurrent Connections Per Host

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Sets a limit on the number of concurrent HTTP/1.1 connections allowed per host. This setting does not apply to H2 connections due to their multiplexing nature.

```csharp
fluxzySetting.SetConnectionPerHost(32);
```

--------------------------------

### Capture Raw Packets with CapturedTcpConnectionProvider

Source: https://docs.fluxzy.io/documentation/core/04-capture-raw-packets.html

Initializes the `CapturedTcpConnectionProvider` for capturing raw TCP connections and setting up a `Proxy` with Fluxzy. This provider is part of the Fluxzy.Core.Pcap package and enables dumping active TCP connections to PCAPNG files.

```csharp
await using var tcpConnectionProvider = await CapturedTcpConnectionProvider.CreateInProcessCapture();
await using var proxy = new Proxy(fluxzyStartupSetting, tcpConnectionProvider: tcpConnectionProvider);
```

--------------------------------

### Export Fluxzy Capture Session to HAR File using C#

Source: https://docs.fluxzy.io/documentation/core/short-examples/export-http-archive-format.html

This C# code snippet demonstrates the final step of exporting a Fluxzy capture session to an HTTP Archive (HAR) file. It calls the `Packager.ExportAsHttpArchive` method, specifying the directory containing the captured data and the desired output filename.

```csharp
Packager.ExportAsHttpArchive(tempDirectory, "export.har");
```

--------------------------------

### Merge All PCAPNG Files into a Single File

Source: https://docs.fluxzy.io/documentation/core/04-capture-raw-packets.html

Merges multiple PCAPNG files from a dump directory into a single PCAPNG file using the `PcapMerge.MergeDumpDirectory` utility. This is useful for consolidating captures from different connections into one file for easier analysis.

```csharp
using var mergePcapFileStream = File.Create("all-captures.pcapng");
PcapMerge.MergeDumpDirectory(tempDirectory, mergePcapFileStream);
```

--------------------------------

### Add Additional Listen Addresses to FluxzySetting

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Adds more endpoints to an existing FluxzySetting instance. Supports specifying IP addresses (IPv6 loopback, any IPv4) and ports.

```csharp
// Listen on 8080 on ::1 
fluxzySetting
    .AddBoundAddress(IPAddress.IPv6Loopback, 8080);

// Listen on 8081 on any IPv4 address
fluxzySetting
    .AddBoundAddress("0.0.0.0", 8081);
```

--------------------------------

### Register Response Body Substitution in Fluxzy Action (C#)

Source: https://docs.fluxzy.io/documentation/core/05-low-level-filters.html

This C# code shows how to create a Fluxzy `Action` that registers a custom `IStreamSubstitution` for the response body. The `InternalAlter` method is overridden to call `context.RegisterResponseBodySubstitution` with an instance of `GreedyMockSubstitution`.

```csharp
using Fluxzy.Core;
using Fluxzy.Core.Breakpoints;
using Fluxzy.Rules;
using Action = Fluxzy.Rules.Action;

namespace low_level_filters;

internal class GreedyMockAction : Action
{
    public override ValueTask InternalAlter(ExchangeContext context, Exchange? exchange, Connection? connection, FilterScope scope,
        BreakPointManager breakPointManager)
    {
        context.RegisterResponseBodySubstitution(new GreedyMockSubstitution());
        return default;
    }

    public override FilterScope ActionScope => FilterScope.ResponseHeaderReceivedFromRemote;

    public override string DefaultDescription =>  nameof(GreedyMockAction);
}

```

--------------------------------

### Set Custom CA Certificate in FluxzySetting

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Sets a custom CA certificate for the Fluxzy proxy to use. The provided certificate must be a valid CA certificate and contain a private key.

```csharp
fluxzySetting.SetCaCertificate(p12Certificate);
```

--------------------------------

### Add Alteration Rule to Append Response Header

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Adds an alteration rule to transform traffic. This rule appends a custom 'X-Proxy' header to any response passing through the proxy.

```csharp
// Add a rule that append a response header to any response
fluxzySetting.AddAlterationRules(
    new Rule(
        new AddResponseHeaderAction("X-Proxy", "Passed through fluxzy"),
        AnyFilter.Default
    ));
```

--------------------------------

### Disable Global SSL Interception

Source: https://docs.fluxzy.io/documentation/core/fluxzy-settings.html

Completely disable global SSL interception by applying the `SkipSslTunnelingAction` with a default filter. This action must be triggered on `OnAuthorityReceived`.

```csharp
fluxzySetting.AddAlterationRules(new Rule(new SkipSslTunnelingAction(), AnyFilter.Default));
```
Tokens:
Raw