Titanium Web Proxy

https://github.com/justcoding121/titanium-web-proxy
Admin
A lightweight HTTP(S) proxy server written in C#.
Tokens:494,939
Snippets:3,547
Trust Score:9
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Service installation examples

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/cli.md

Examples for installing the service on Windows, Linux (systemd), and macOS. Includes per-user installation on Linux with `--user`.

```shell
# Windows — UAC prompt if you are not already Administrator
titanium service install -c C:\proxy\twp.yaml
titanium service status
titanium service stop
titanium service start

# Linux (systemd) — sudo prompt if you are not root
titanium service install -c /etc/titanium/twp.yaml
# Per-user (no elevation); for start-at-boot without login:
#   loginctl enable-linger $USER
titanium service install -c ~/twp.yaml --user

# macOS (LaunchDaemon) — sudo prompt if you are not root
titanium service install -c /usr/local/etc/titanium/twp.yaml

```

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

### Quick start: CLI, YAML config, and .NET library

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/index.md

Quick start examples for the Titanium Web Proxy: CLI commands to test and run a proxy with a YAML configuration, the YAML configuration file (twp.yaml) that defines a plain reverse proxy listener on port 8000 forwarding to port 8080, and a C# library example that creates a ProxyServer, logs request URLs, adds an explicit proxy endpoint with SSL decryption, ensures the root certificate, and starts the server.

```shell
# Download a CLI zip from /download, then:
titanium test -c twp.yaml
titanium run -c twp.yaml
```

```yaml
schemaVersion: "7.1"
listeners:
  - host: "127.0.0.1"
    port: 8000
    # false = plain reverse proxy (no HTTPS decrypt)
    decryptSsl: false
    forwardHost: "127.0.0.1"
    forwardPort: 8080
```

```csharp
using System.Net;
using Titanium.Web.Proxy;
using Titanium.Web.Proxy.Models;

using var proxyServer = new ProxyServer();
proxyServer.BeforeRequest += async (s, e) =>
{
    Console.WriteLine(e.HttpClient.Request.Url);
};

var endPoint = new ExplicitProxyEndPoint(IPAddress.Loopback, 8000, decryptSsl: true);
proxyServer.AddEndPoint(endPoint);
proxyServer.CertificateManager.EnsureRootCertificate(
    userTrustRootCertificate: true,
    machineTrustRootCertificate: false);
proxyServer.Start();
```

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

### Install .NET package: Titanium.Web.Proxy

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/README.md

Install the Titanium.Web.Proxy NuGet package. Use the `--prerelease` flag to get beta versions.

```shell
dotnet add package Titanium.Web.Proxy
# Prerelease / beta:
dotnet add package Titanium.Web.Proxy --prerelease
```

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

### service command syntax

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/cli.md

Installs, uninstalls, starts, stops, restarts, or checks the status of the OS service. `--user` is not supported on Windows; `--no-start` installs without starting.

```text
titanium service install -c <config> [--name titanium] [--user] [--no-start]
titanium service uninstall [--name titanium] [--user]
titanium service start|stop|restart|status [--name titanium] [--user]

```

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

### Start(bool)

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.ProxyServer.html

Method to start the proxy server instance.

```APIDOC
## Start(bool)

### Description
Starts the proxy server instance. The operation is transactional: if any endpoint fails to start, all listeners started by this call are stopped, the system-upstream-proxy resolver is disposed, and the proxy is left in a non-running state before the exception propagates.

### Method
Start

### Signature
`public void Start(bool changeSystemProxySettings = true)`

### Parameters
- **changeSystemProxySettings** (bool) - Optional - Whether to clear any system proxy settings pointing to our own endpoint (causing a cycle). Default is `true`.
```

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

### Check and install HTTP/3 dependencies

Source: https://github.com/justcoding121/titanium-web-proxy/wiki/HTTP-3

Use these commands to check and install HTTP/3 native dependencies when QuicListener.IsSupported is false. The install command is opt-in and requires network and sudo/admin access.

```bash
titanium http3-deps status
titanium http3-deps install
```

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

### Check and install HTTP/3 dependencies via CLI

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/http3.md

Use `titanium http3-deps status` to check if Quic is supported, and `titanium http3-deps install` to install missing dependencies. The install command requires network and sudo.

```bash
titanium http3-deps status
titanium http3-deps install   # only if status shows unsupported

```

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

### Install Plus add-on and check version

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/install.md

Installs the Plus add-on via the CLI and verifies the version. There is no separate Plus download; enable it in the config with `plus.enabled: true`.

```shell
titanium update --plus
titanium version --check --plus
```

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

### Check and install HTTP/3 dependencies (CLI)

Source: https://github.com/justcoding121/titanium-web-proxy/wiki/HTTP-3

Commands to check status and install MsQuic natives for CLI/Inspector products. The install command supports apt, dnf, zypper, apk, and brew, and is intended for edge hosts only.

```bash
titanium http3-deps status
titanium http3-deps install   # apt / dnf / zypper / apk / brew — edge hosts only
```

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

### Quick start test and run commands

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/cli.md

Validate the config with `titanium test` and start the proxy with `titanium run`. Foreground run blocks until Ctrl+C or SIGTERM; exit 0 on clean stop, 1 on errors.

```shell
titanium test -c twp.yaml
titanium run -c twp.yaml

```

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

### Install libmsquic on Ubuntu

Source: https://github.com/justcoding121/titanium-web-proxy/wiki/HTTP-3

Downloads and installs the Microsoft package repository and libmsquic package on Ubuntu. Required for NuGet library hosts on Linux.

```bash
curl -fsSL --proto '=https' --tlsv1.2 \
  "https://packages.microsoft.com/config/ubuntu/$(. /etc/os-release; echo $VERSION_ID)/packages-microsoft-prod.deb" \
  -o packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb && rm packages-microsoft-prod.deb
sudo apt-get update && sudo apt-get install -y libmsquic
```

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

### Explicit MITM proxy setup with ProxyServer

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/library.md

Creates an explicit HTTPS-decrypting proxy on loopback port 8000, registers a BeforeRequest handler, ensures the root certificate is trusted, and starts the server.

```csharp
using System.Net;
using Titanium.Web.Proxy;
using Titanium.Web.Proxy.Models;

using var proxyServer = new ProxyServer();
proxyServer.BeforeRequest += async (sender, e) =>
{
    // Inspect or rewrite e.HttpClient.Request
};

var endPoint = new ExplicitProxyEndPoint(IPAddress.Loopback, 8000, decryptSsl: true);
proxyServer.AddEndPoint(endPoint);
proxyServer.CertificateManager.EnsureRootCertificate(
    userTrustRootCertificate: true,
    machineTrustRootCertificate: false);
proxyServer.Start();
```

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

### Validate and run the CLI proxy

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/getting-started.md

Validate the configuration with titanium test and then run the proxy with titanium run. The run command stays in the foreground; press Ctrl+C to stop. To start at boot, use titanium service install -c twp.yaml.

```shell
titanium test -c twp.yaml
titanium run -c twp.yaml
```

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

### EnsureRootCertificate()

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.Network.CertificateManager.html

Ensure certificates are setup (creates root if required). Also makes root certificate trusted based on initial setup from proxy constructor for user/machine trust.

```APIDOC
## EnsureRootCertificate()

### Description
Ensure certificates are setup (creates root if required). Also makes root certificate trusted based on initial setup from proxy constructor for user/machine trust.

### Method
EnsureRootCertificate

### Signature
`public void EnsureRootCertificate()`
```

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

### Access log YAML configuration example

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/configuration.md

YAML example for enabling the opt-in NDJSON access log under server.accessLog. The log is written after each response and bodies are never buffered for this feature. Omit accessLog or leave path empty for zero cost on the hot path.

```yaml
server:
  accessLog:
    path: "./logs/access.ndjson"
    sampleRate: 1.0   # 0.0–1.0; omit for 1.0

```

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

### Full server YAML configuration example

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/configuration.md

Complete YAML example for the server section, showing all configurable keys and their defaults. Use as a reference for server-level settings including HTTP/2, HTTP/3, TLS, pooling, limits, policy modes, and certificate manager. Note that null values leave library or profile defaults, and the apply order is profile first, then overlays.

```yaml
server:
  profile: PublicFacing   # Balanced | LegacyCompatible | PublicFacing
  enableHttp2: true
  enableHttp3: null
  enableRfc8441: false
  enableQpackDynamicTable: false
  enableHttpsSvcbDnsDiscovery: null
  enable100ContinueBehaviour: false
  compatibilityMode100Continue: false
  enableWinAuth: false
  originHttpVersionPolicy: PreserveClientVersion  # or NormalizeToHttp11
  viaHeaderPseudonym: "titanium-web-proxy"
  blockPrivateNetworkDestinations: false
  blockLoopbackDestinations: false
  checkCertificateRevocation: NoCheck
  dnsServerEndPoint: "8.8.8.8:53"
  accessLog:
    path: "logs/access.ndjson"   # omit or null = off (zero cost)
    sampleRate: 1.0              # 0.0–1.0
  timeouts:
    connectionTimeOutSeconds: 60
    connectTimeOutSeconds: 20
    clientHeaderTimeoutSeconds: 0
    responseHeaderTimeoutSeconds: 0
    idleReadTimeoutSeconds: 0
    idleWriteTimeoutSeconds: 0
    requestTimeoutSeconds: 0
    networkFailureRetryAttempts: 1
  pooling:
    enableConnectionPool: true
    enableTcpServerConnectionPrefetch: true
    enableIpv6UnreachableSoftSkip: true
    maxCachedConnections: 128
    maxConcurrentHttp11HttpsOriginCreates: null
    maxConcurrentClientConnections: null
    noDelay: true
    enableTcpKeepAlive: true
    tcpTimeWaitSeconds: 0
    listenerBackLog: 1024
    reuseSocket: true
    threadPoolWorkerThread: null
  limits:
    maxHeaderLineBytes: 65536
    maxHeaderCount: 256
    maxHeaderAggregateBytes: 262144
    maxEncodedBodyBytes: null
    maxDecodedBodyBytes: null
    maxDecompressionRatio: 200
    maxConcurrentClients: null
    maxConcurrentStreamsPerConnection: 256
    maxPeerInitiatedIncompleteStreamResets: 100
    maxOpenHeaderBlockFrames: 128
    maxOpenHeaderBlockDurationSeconds: 10
    connectionPoolingEnabled: true
    maxCachedConnectionsPerHost: 128
    maxOriginHttp2ConnectionsPerAuthority: 8
    maxCertificateCacheEntries: 1024
    maxCertificateDiskCacheEntries: null
    maxBufferedBodyBytes: 4194304
    maxDecodedHeaderListBytes: 65536
    maxWebSocketFramePayloadBytes: 16777216
  policyModes:
    bodyBudget: Enforce
    decompressionRatio: Enforce
    headerLimits: Enforce
    admissionControl: Enforce
    http2AbuseBudget: Enforce
    allowAmbiguousFraming: false
  tls:
    supportedSslProtocols: [Tls12, Tls13]
    supportedServerSslProtocols: [None]
  upstream:
    forwardToUpstreamGateway: false
    upstreamProxyConfigurationScript: null
    httpProxy:
      hostName: "proxy.example"
      port: 8080
      proxyType: Http
    httpsProxy: null
    upStreamEndPoint: null
    upStreamEndPointIPv4: null
    upStreamEndPointIPv6: null
  decryptSkipHosts: []      # present ⇒ Replace tunnel-only list (omit key to keep Merge factory defaults)
  decryptOnlyHosts: []      # when non-empty, only these hosts are decrypted (Replace with skip/only)
  # Decrypt failure bypass (learned tunnel) is ProxyServer.EnableDecryptFailureBypass / Inspector only — not a twp.yaml key
  systemProxyBypassHosts: null  # present ⇒ Replace OS bypass (omit ⇒ Merge identity defaults); SSO risk if removed
  proxyLoopback: true       # localhost via proxy when building SystemProxySettings from config
  certificateManager:
    certificateEngine: BouncyCastleFast
    leafCertificateKeyAlgorithm: EcdsaP256
    pfxFilePath: null
    pfxPassword: null
    overwritePfxFile: true
    certificateValidDays: 396
    certificateGraceDays: 2
    certificateCacheTimeOutMinutes: 60
    rootCertificateName: null
    rootCertificateIssuerName: null
    saveFakeCertificates: true
    disableWildCardCertificates: false
  accessLog: null   # opt-in NDJSON access log (see below)

```

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

### DataEventArgs.Count

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.StreamExtended.Network.DataEventArgs.html

Gets the length of valid data in the buffer starting from the offset.

```APIDOC
## Property: Count

### Description
Length from offset in buffer with valid data.

### Declaration
```csharp
public int Count { get; }
```

### Property Value
| Type | Description |
| --- | --- |
| int | The length of valid data. |
```

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

### Http2ProbeStartedAt

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.Diagnostics.TunnelConnectTiming.html

Gets the timestamp when the HTTP/2 origin capability probe started or was retrieved from cache.

```APIDOC
## Http2ProbeStartedAt

### Description
Gets the timestamp when the HTTP/2 origin capability probe started or was retrieved from cache.

### Declaration
```csharp
public DateTime? Http2ProbeStartedAt { get; }
```

### Property Value
| Type | Description |
| --- | --- |
| DateTime? | The timestamp when the probe started, or null if not available. |
```

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

### ApplyFastColdStartLeafSettings()

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.Network.CertificateManager.html

Applies fast cold-start leaf settings for MITM certificate generation.

```APIDOC
## ApplyFastColdStartLeafSettings()

### Description
Fast first-visit MITM for modern TLS clients (browsers, current HttpClient): [BouncyCastleFast](Titanium.Web.Proxy.Network.CertificateEngine.html#Titanium_Web_Proxy_Network_CertificateEngine_BouncyCastleFast), ECDSA P-256 leaves, and [SaveFakeCertificates](Titanium.Web.Proxy.Network.CertificateManager.html#Titanium_Web_Proxy_Network_CertificateManager_SaveFakeCertificates) enabled. The root CA stays RSA. Library [Balanced](Titanium.Web.Proxy.Options.ProxyProfile.html#Titanium_Web_Proxy_Options_ProxyProfile_Balanced) still defaults to RSA-2048 leaves for widest compatibility. Call this from Inspector, CLI, and desktop MITM hosts where clients are known to accept ECDSA server certificates.

### Method
ApplyFastColdStartLeafSettings

### Endpoint
CertificateManager.ApplyFastColdStartLeafSettings()

### Parameters
#### Path Parameters
None.

#### Query Parameters
None.

#### Request Body
None.

### Request Example
None.

### Response
#### Success Response (200)
No return value.

#### Response Example
None.

### Declaration
```csharp
public void ApplyFastColdStartLeafSettings()
```
```

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

### TunnelConnectTiming.TotalDuration

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.Diagnostics.TunnelConnectTiming.html

Gets the wall time from CONNECT capability work start to browser TLS completion.

```APIDOC
## Property: TotalDuration

### Description
Gets the wall time from CONNECT capability work start to browser TLS completion.

### Declaration
```csharp
public TimeSpan? TotalDuration { get; }
```

### Property Value
| Type | Description |
| --- | --- |
| [TimeSpan](https://learn.microsoft.com/dotnet/api/system.timespan)? | The total duration of the CONNECT tunnel establishment, or null if not available. |

```

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

### GetFinalAuthToken(String, String, Guid)

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.Network.WinAuth.WinAuthHandler.html

Gets the final token given the server challenge token.

```APIDOC
## GetFinalAuthToken(String, String, Guid)

### Description
Gets the final token given the server challenge token.

### Method
GetFinalAuthToken

### Signature
public static string GetFinalAuthToken(string serverHostname, string serverToken, Guid requestId)

### Parameters
- **serverHostname** (String) - The server hostname.
- **serverToken** (String) - The server challenge token.
- **requestId** (Guid) - The request identifier.

### Returns
- **String** - The final authentication token.
```

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

### Enable HTTP/3 and add QUIC endpoint

Source: https://github.com/justcoding121/titanium-web-proxy/wiki/Home

Opt-in HTTP/3 support. Set EnableHttp3 to true, create a TransparentQuicProxyEndPoint on port 443, add it, and start the proxy. Existing event handlers work unchanged for HTTP/3 streams.

```csharp
proxy.EnableHttp3 = true;
var quicEndPoint = new TransparentQuicProxyEndPoint(IPAddress.Any, 443);
proxy.AddEndPoint(quicEndPoint);
proxy.Start();
```

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

### OriginCapabilityStartedAt

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.Diagnostics.TunnelConnectTiming.html

Gets the timestamp when origin HTTP/3 capability resolution started (cache lookup and/or SVCB queue).

```APIDOC
## OriginCapabilityStartedAt

### Description
Gets the timestamp when origin HTTP/3 capability resolution started (cache lookup and/or SVCB queue).

### Declaration
```csharp
public DateTime? OriginCapabilityStartedAt { get; }
```

### Property Value
| Type | Description |
| --- | --- |
| DateTime? | The timestamp when the capability resolution started, or null if not available. |
```

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

### Render practical reverse charts from downloaded results

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/tools/RpsLoadProbe/README.md

Renders practical reverse charts from downloaded compare-product and heavier roots. Requires installing requirements-charts.txt first. Writes up to six PNGs (rps-practical-{os}.png and rps-practical-heavier-{os}.png) into wiki/images when data exists; macOS heavier is skipped today.

```bash
pip install -r tools/RpsLoadProbe/requirements-charts.txt
python3 tools/RpsLoadProbe/render-practical-charts.py \
  --results-root tools/RpsLoadProbe/results/gha-dl/<productRunId> \
  --bodies-root tools/RpsLoadProbe/results/gha-dl/<bodiesRunId> \
  --post-root tools/RpsLoadProbe/results/gha-dl/<postRunId> \
  --arch-root tools/RpsLoadProbe/results/gha-dl/<archRunId> \
  --grpc-root tools/RpsLoadProbe/results/gha-dl/<grpcRunId> \
  --out-dir wiki/images \
  --title-suffix '@ <sha>'
```

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

### GetInitialAuthToken(String, String, Guid)

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.Network.WinAuth.WinAuthHandler.html

Gets the initial client token for server using credentials of user running the proxy server process.

```APIDOC
## GetInitialAuthToken(String, String, Guid)

### Description
Gets the initial client token for server using credentials of user running the proxy server process.

### Method
GetInitialAuthToken

### Signature
public static string GetInitialAuthToken(string serverHostname, string authScheme, Guid requestId)

### Parameters
- **serverHostname** (String) - The server hostname.
- **authScheme** (String) - The authentication scheme (e.g., NTLM, Kerberos).
- **requestId** (Guid) - The request identifier.

### Returns
- **String** - The initial authentication token.
```

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

### Example curl request to transcoded endpoint

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/grpc-json-transcoding.md

Send a GET request to the annotated path /v1/greeter/world. The expected response is a JSON object with the message field.

```shell
curl -s http://127.0.0.1:8080/v1/greeter/world
# {"message":"Hello world"}
```

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

### Configure proxy limits and transparent endpoint

Source: https://github.com/justcoding121/titanium-web-proxy/wiki/Performance

C# example showing how to raise connection and stream limits on the proxy and configure a transparent endpoint with custom limits and HTTP protocol translation.

```csharp
proxy.MaxCachedConnections = 512;
proxy.ResourceLimits = ProxyResourceLimits.Create(
    /* … */,
    maxConcurrentStreamsPerConnection: 1000,
    maxCachedConnectionsPerHost: 512,
    /* … */);

var ep = new TransparentProxyEndPoint(IPAddress.Any, 443, decryptSsl: true)
{
    ForwardHost = "127.0.0.1",
    ForwardPort = 8080,
    ForwardCleartext = true,
    MaxCachedConnections = 256,
    GenericCertificateName = "example.com"
};
ep.BeforeSslAuthenticate += (_, a) =>
{
    a.UpstreamHttpProtocol = UpstreamHttpProtocol.Http11;
    a.AllowHttpProtocolTranslation = true; // HTTP/2 client → HTTP/1 origin
    return Task.CompletedTask;
};
```

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

### Annotate gRPC service with google.api.http

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/grpc-json-transcoding.md

Define a gRPC service with REST/JSON mappings using google.api.http annotations. The example shows a GET mapping for SayHello and a POST mapping with body: "*" for CreateHello.

```protobuf
syntax = "proto3";
package helloworld;
import "google/api/annotations.proto";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {
    option (google.api.http) = {
      get: "/v1/greeter/{name}"
    };
  }
  rpc CreateHello (HelloRequest) returns (HelloReply) {
    option (google.api.http) = {
      post: "/v1/greeter"
      body: "*"
    };
  }
}

message HelloRequest { string name = 1; }
message HelloReply { string message = 1; }
```

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

### Install Titanium CLI with Homebrew

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/download.md

Installs the Titanium CLI on macOS via Homebrew. Requires Homebrew to be installed on the system.

```shell
brew tap justcoding121/titanium
brew install titanium
```

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

### Run RpsLoadProbe with CPU sampling and collect dumps/traces

Source: https://github.com/justcoding121/titanium-web-proxy/wiki/Performance-Profiling

Run the RpsLoadProbe executable with a 150-second single-concurrency run to attach the CPU sampler, then in a second shell collect a full dump and a sampled thread-time trace for the proxy process. The ramp logs print the proxy PID to use.

```powershell
tools/RpsLoadProbe/bin/Release/net10.0/RpsLoadProbe.exe --ramp --mode <arm> --concurrency 64 `
  --warmup-sec 2 --duration-sec 150 --results-dir tools/RpsLoadProbe/results/profiling
# ramp logs print: attach: split origin pid=… proxy pid=…
# in a second shell:
dotnet-dump collect -p <proxy PID> --type Full
dotnet-trace collect -p <proxy PID> --profile dotnet-sampled-thread-time --duration 00:00:25
```

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

### CreateSystemProxySettings(bool, IEnumerable<string>?)

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.MitmExclusionDefaults.html

Builds SystemProxySettings with identity bypass rules and optional user additions using Merge mode.

```APIDOC
## CreateSystemProxySettings(bool, IEnumerable<string>?)

### Description
Builds SystemProxySettings with identity bypass rules and optional user additions using Merge mode.

### Method
CreateSystemProxySettings

### Signature
public static SystemProxySettings CreateSystemProxySettings(bool proxyLoopback, IEnumerable<string>? additionalBypassRules)

### Parameters
- **proxyLoopback** (bool) - Required - When true, localhost uses the proxy (platform-specific loopback rule).
- **additionalBypassRules** (IEnumerable<string>?) - Optional - Additional bypass rules to merge with the default identity bypass rules.

### Returns
- **SystemProxySettings** - The constructed system proxy settings.
```

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

### Install TitaniumInspector on macOS with install-app.sh

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/inspector.md

Used to install TitaniumInspector on macOS after extracting the zip. Makes the installer scripts executable and runs install-app.sh, which places the application in ~/Applications/Titanium Inspector.app.

```shell
chmod +x install-app.sh uninstall-app.sh TitaniumInspector
./install-app.sh      # ~/Applications/Titanium Inspector.app

```

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

### Quick start YAML configuration

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/cli.md

Minimal YAML config for the proxy: listens on 127.0.0.1:8000 and forwards to 127.0.0.1:8080. Uses schemaVersion 7.1.

```yaml
schemaVersion: "7.1"
listeners:
  - host: "127.0.0.1"
    port: 8000
    decryptSsl: false
    forwardHost: "127.0.0.1"
    forwardPort: 8080

```

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

### Configure MITM exclusions with Merge and Replace modes

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/library.md

Shows how to create system proxy settings with factory identity hosts (Merge) or a custom list (Replace), and how to apply decrypt exclusions. Merge is the default for back-compat; Replace makes caller lists authoritative and can break SSO if identity hosts are removed.

```csharp
// Merge: factory identity hosts + extras
var settings = MitmExclusionDefaults.CreateSystemProxySettings(
    proxyLoopback: true,
    additionalBypassRules: ["*.corp.example.com"]);
proxyServer.SetAsSystemProxy(endPoint, ProxyProtocolType.AllHttp, settings);

// Replace: full list you provide (factory not re-added)
var custom = MitmExclusionDefaults.CreateSystemProxySettings(
    proxyLoopback: true,
    MitmExclusionDefaults.SystemProxyBypassRules.Append("*.corp.example.com"),
    MitmExclusionMode.Replace);

MitmExclusionDefaults.ApplyDecryptExclusions(endPoint, () => true,
    decryptSkipHosts: ["*.bank.example.com"],
    decryptOnlyHosts: null,
    MitmExclusionMode.Replace);
```

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

### Reverse proxy HTTP/3 setup in C#

Source: https://github.com/justcoding121/titanium-web-proxy/wiki/HTTP-3

Configures a reverse proxy endpoint with HTTP/3 and HTTP/2 support, including QUIC authentication and SSL authentication handlers. Requires enabling HTTP/3 on the proxy and setting the forward host and port.

```csharp
#pragma warning disable TWP001
var proxy = new ProxyServer { EnableHttp3 = true, EnableHttp2 = true };

if (QuicListener.IsSupported)
{
    var reverse = new TransparentProxyEndPoint(IPAddress.Any, 443, decryptSsl: true)
    {
        EnableHttp3 = true,
        ForwardHost = "127.0.0.1",
        ForwardPort = 8080,
        ForwardCleartext = true,
        GenericCertificateName = "localhost",
        MaxInboundBidirectionalStreams = 256,
    };
    reverse.BeforeQuicAuthenticate += (_, e) =>
    {
        e.UpstreamHttpProtocol = UpstreamHttpProtocol.Http11;
        return Task.CompletedTask;
    };
    reverse.BeforeSslAuthenticate += (_, e) =>
    {
        e.UpstreamHttpProtocol = UpstreamHttpProtocol.Http11;
        e.AllowHttpProtocolTranslation = true;
        return Task.CompletedTask;
    };
    proxy.AddEndPoint(reverse);
}
#pragma warning restore TWP001

proxy.Start();
```

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

### Install TitaniumInspector on Linux with install.sh

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/inspector.md

Used to install TitaniumInspector on Linux after extracting the zip. Makes the installer scripts executable and runs install.sh, which places the application in ~/.local/share with a desktop entry.

```shell
chmod +x install.sh uninstall.sh TitaniumInspector
./install.sh          # ~/.local/share/TitaniumInspector + desktop entry

```

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

### Install Titanium packages via Chocolatey

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/tools/packaging/PACKAGING.md

Installs the Titanium CLI and Inspector packages via Chocolatey. The --pre variants install pre-release (beta) versions. Package IDs are titanium-cli (zip) and titanium-inspector (MSI).

```shell
choco install titanium-cli
choco install titanium-inspector
choco install titanium-cli --pre
choco install titanium-inspector --pre
```

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

### run command syntax

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/cli.md

Starts the proxy from a config file. `-c` is required; `-v` enables debug logging; `--service` runs in service-worker mode; `--name` sets the Windows SCM name (default `titanium`).

```text
titanium run -c <config> [-v|--verbose] [--service] [--name <service-name>]

```

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

### CreateSystemProxySettings(bool, IEnumerable<string>?, MitmExclusionMode)

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.MitmExclusionDefaults.html

Builds SystemProxySettings from factory and/or caller bypass rules, allowing merge or replace of OS defaults.

```APIDOC
## CreateSystemProxySettings(bool, IEnumerable<string>?, MitmExclusionMode)

### Description
Builds SystemProxySettings from factory and/or caller bypass rules, allowing merge or replace of OS defaults.

### Method
CreateSystemProxySettings

### Signature
public static SystemProxySettings CreateSystemProxySettings(bool proxyLoopback, IEnumerable<string>? bypassRules, MitmExclusionMode mode)

### Parameters
- **proxyLoopback** (bool) - Required - When true, localhost uses the proxy (platform-specific loopback rule).
- **bypassRules** (IEnumerable<string>?) - Optional - Extra rules in Merge mode, or the full authoritative list in Replace mode.
- **mode** (MitmExclusionMode) - Required - Merge factory OS-bypass defaults, or replace them with bypassRules.

### Returns
- **SystemProxySettings** - The constructed system proxy settings.
```

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

### Run all benchmarks with dotnet run

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/benchmarks/Titanium.Web.Proxy.Benchmarks/README.md

Run the benchmark harness manually in Release mode. Use --filter '*' to run all benchmarks.

```powershell
dotnet run -c Release --project benchmarks/Titanium.Web.Proxy.Benchmarks -- --filter '*'
```

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

### Install and check Plus with titanium update --plus

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/plus.md

Install or update Plus and check its version. The version check reports local to remote and exits with code 2 when a newer Plus is available or Plus is missing. The update command installs or upgrades only when needed, printing a message and skipping the download if Plus is already current.

```shell
titanium update --plus
titanium version --check --plus
# Prerelease / beta channel:
titanium update --plus --channel beta
titanium version --check --plus --channel beta
```

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

### ProxyServer Lifecycle Methods

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/src/Titanium.Web.Proxy/PublicAPI.Shipped.txt

Methods to start and stop the proxy server.

```APIDOC
## ProxyServer.Start(bool changeSystemProxySettings = true)

### Description
Starts the proxy server, optionally changing the system proxy settings.

### Method
Start

### Signature
`void Start(bool changeSystemProxySettings = true)`

### Parameters
- **changeSystemProxySettings** (bool) - Optional - Whether to change the system proxy settings.
```

```APIDOC
## ProxyServer.Stop()

### Description
Stops the proxy server.

### Method
Stop

### Signature
`void Stop()`
```

```APIDOC
## ProxyServer.StopAsync(System.TimeSpan? drainTimeout = null)

### Description
Asynchronously stops the proxy server, optionally draining connections for a specified timeout.

### Method
StopAsync

### Signature
`Task StopAsync(System.TimeSpan? drainTimeout = null)`

### Parameters
- **drainTimeout** (System.TimeSpan?) - Optional - The timeout for draining connections.
```

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

### Enable HTTP/3 with transparent QUIC endpoint

Source: https://github.com/justcoding121/titanium-web-proxy/wiki/HTTP-3

Configures a ProxyServer for transparent UDP-only HTTP/3. Guard with QuicListener.IsSupported, set EnableHttp3, add a TransparentQuicProxyEndPoint on UDP 443, and optionally hook BeforeQuicAuthenticate. Existing event hooks like BeforeRequest continue to work unchanged.

```csharp
#pragma warning disable TWP001 // Experimental HTTP/3 API
var proxy = new ProxyServer();

// Guard with IsSupported so the app degrades gracefully on unsupported platforms.
if (QuicListener.IsSupported)
{
    // Opt in to HTTP/3.
    proxy.EnableHttp3 = true;

    // Add a transparent QUIC endpoint on UDP 443.
    var quicEndPoint = new TransparentQuicProxyEndPoint(IPAddress.Any, 443)
    {
        // Optional: plug in your own NAT-original-destination resolver.
        // OriginalDestinationResolver = new MyNatResolver(),

        // Optional: tune QUIC connection limits.
        MaxInboundBidirectionalStreams = 100,
        IdleTimeout = TimeSpan.FromSeconds(30),
    };
    proxy.AddEndPoint(quicEndPoint);

    // Hook into QUIC connections (analogous to BeforeSslAuthenticate for TCP).
    quicEndPoint.BeforeQuicAuthenticate += (sender, e) =>
    {
        // Optionally pin the origin protocol for all streams on this connection.
        // e.UpstreamHttpProtocol = UpstreamHttpProtocol.Http3;

        // Optionally override certificate validation.
        // e.CertificateValidationCallback = MyValidator;
        return Task.CompletedTask;
    };
}
#pragma warning restore TWP001

// All existing event hooks work unchanged.
proxy.BeforeRequest += async (sender, e) =>
{
    // e.HttpClient.Request.Url — the full request URL.
    // e.UpstreamHttpProtocol — override origin protocol for this stream only.
};

proxy.Start();
```

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

### SessionEventArgsBase.ClientEndPoint

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/src/Titanium.Web.Proxy/PublicAPI.Shipped.txt

Gets the client endpoint.

```APIDOC
## SessionEventArgsBase.ClientEndPoint Property

### Description
Gets the client endpoint.

### Property Type
System.Net.IPEndPoint
```

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

### BuildProxyOverride(string?)

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.SystemProxySettings.html

Builds the WinINET-style semicolon-separated bypass list that would be applied to the OS.

```APIDOC
## BuildProxyOverride(string?)

### Description
Builds the WinINET-style semicolon-separated bypass list that would be applied to the OS.

### Declaration
```csharp
public string BuildProxyOverride(string? currentProxyOverride)
```

### Parameters
- **currentProxyOverride** (string?) - The current proxy override string to be processed.

### Returns
- **string** - The constructed bypass list as a semicolon-separated string.

```

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

### SessionEventArgs.WebSocketDecoder

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/src/Titanium.Web.Proxy/PublicAPI.Shipped.txt

Gets the WebSocket decoder.

```APIDOC
## SessionEventArgs.WebSocketDecoder Property

### Description
Gets the WebSocket decoder.

### Property Type
Titanium.Web.Proxy.WebSocketDecoder
```

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

### Request.Host

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.Http.Request.html

Gets the host of the request.

```APIDOC
## Property: Host

### Description
Gets the host.

### Declaration
csharp
public string Host { get; }


### Property Value
| Type | Description |
| --- | --- |
| [string](https://learn.microsoft.com/dotnet/api/system.string) | |

```

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

### CLI command overview

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/website/docs/cli.md

Lists all top-level CLI commands: run, test, service, version, update, and http3-deps. Use `titanium <command> --help` for nested help.

```text
titanium run -c <config> [-v|--verbose] [--service]
titanium test -c <config>
titanium service install|uninstall|start|stop|restart|status
titanium version [--check] [--plus] [--channel beta]
titanium update [--plus] [--remove-plus] [--channel beta]
titanium http3-deps status|install

```

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

### Ok(string)

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.SystemProxyChangeResult.html

Creates a SystemProxyChangeResult instance representing a successful proxy change operation, with the provided message.

```APIDOC
## Ok(string)

### Description
Creates a SystemProxyChangeResult instance representing a successful proxy change operation, with the provided message.

### Method
Ok

### Signature
public static SystemProxyChangeResult Ok(string message)

### Parameters
- **message** (string) - Required - The message describing the success.

### Returns
- **SystemProxyChangeResult** - A result object indicating success.
```

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

### Explicit HTTP(S) proxy with URL logging (C#)

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/README.md

Sets up an explicit proxy on 127.0.0.1:8000 that logs each requested URL. Requires trusting a generated root certificate for HTTPS decryption, which modifies the current user's certificate store. The proxy runs until Enter is pressed.

```csharp
using System;
using System.Net;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Titanium.Web.Proxy;
using Titanium.Web.Proxy.EventArguments;
using Titanium.Web.Proxy.Models;

using var proxyServer = new ProxyServer();

proxyServer.Logging.MinimumLevel = LogLevel.Information;
proxyServer.BeforeRequest += OnRequest;

var endPoint = new ExplicitProxyEndPoint(IPAddress.Loopback, 8000, decryptSsl: true);
proxyServer.AddEndPoint(endPoint);

// Create and trust the root certificate used to decrypt HTTPS traffic.
proxyServer.CertificateManager.EnsureRootCertificate(
    userTrustRootCertificate: true,
    machineTrustRootCertificate: false);

proxyServer.Start();
proxyServer.Logger.LogInformation("Proxy listening on 127.0.0.1:8000. Press Enter to stop.");
await Console.In.ReadLineAsync();
proxyServer.Stop();

Task OnRequest(object sender, SessionEventArgs e)
{
    proxyServer.Logger.LogInformation("{Url}", e.HttpClient.Request.Url);
    return Task.CompletedTask;
}
```

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

### SessionEventArgsBase.ConnectTimeout

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/src/Titanium.Web.Proxy/PublicAPI.Shipped.txt

Gets or sets the connection timeout.

```APIDOC
## SessionEventArgsBase.ConnectTimeout Property

### Description
Gets or sets the connection timeout.

### Property Type
System.TimeSpan
```

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

### CreateSystemProxySettings()

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.MitmExclusionDefaults.html

Builds SystemProxySettings with factory identity bypass rules and loopback (Merge).

```APIDOC
## CreateSystemProxySettings()

### Description
Builds `SystemProxySettings` with factory identity bypass rules and loopback (`Merge`).

### Method
CreateSystemProxySettings

### Returns
- **SystemProxySettings** - The created system proxy settings.

### Declaration
```csharp
public static SystemProxySettings CreateSystemProxySettings()
```
```

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

### SessionEventArgsBase.ClientConnectionId

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/src/Titanium.Web.Proxy/PublicAPI.Shipped.txt

Gets the client connection ID.

```APIDOC
## SessionEventArgsBase.ClientConnectionId Property

### Description
Gets the client connection ID.

### Property Type
long
```

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

### SessionEventArgs.RequestTimeout

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/src/Titanium.Web.Proxy/PublicAPI.Shipped.txt

Gets or sets the request timeout.

```APIDOC
## SessionEventArgs.RequestTimeout Property

### Description
Gets or sets the request timeout.

### Property Type
System.TimeSpan
```

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

### ProxyServer(string?, string?, bool, bool, bool)

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.ProxyServer.html

Initializes a new instance of the ProxyServer class with custom root certificate names and trust options.

```APIDOC
## ProxyServer(string?, string?, bool, bool, bool)

### Description
Initializes a new instance of ProxyServer class with provided parameters.

### Declaration
```csharp
public ProxyServer(string? rootCertificateName, string? rootCertificateIssuerName, bool userTrustRootCertificate = true, bool machineTrustRootCertificate = false, bool trustRootCertificateAsAdmin = false)
```

### Parameters
- **rootCertificateName** (string) - Required - Name of the root certificate.
- **rootCertificateIssuerName** (string) - Required - Name of the root certificate issuer.
- **userTrustRootCertificate** (bool) - Optional - When true (the default), EnsureRootCertificate() installs the MITM root into the current-user Personal and Trusted Root stores. Prefer user-only trust for interactive apps; pass false when trust must be fully opt-in.
- **machineTrustRootCertificate** (bool) - Optional - When true, also trust in the local-machine stores (needs elevation). Defaults to false — machine trust is opt-in for services/admin installs, not for normal desktop use.
- **trustRootCertificateAsAdmin** (bool) - Optional - When true, attempt elevated trust via UAC (Windows only). Defaults to false.
```

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

### CreateSystemProxySettings(bool)

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.MitmExclusionDefaults.html

Builds SystemProxySettings with factory identity bypass rules (Merge).

```APIDOC
## CreateSystemProxySettings(bool)

### Description
Builds `SystemProxySettings` with factory identity bypass rules (`Merge`).

### Method
CreateSystemProxySettings

### Parameters
- **proxyLoopback** (bool) - Required - Whether to proxy loopback traffic.

### Returns
- **SystemProxySettings** - The created system proxy settings.

### Declaration
```csharp
public static SystemProxySettings CreateSystemProxySettings(bool proxyLoopback)
```
```

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

### RootCertificate

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.Network.CertificateManager.html

Gets or sets the root certificate.

```APIDOC
## RootCertificate

### Description
The root certificate.

### Declaration
```csharp
public X509Certificate2? RootCertificate { get; set; }
```

### Property Value
| Type | Description |
| --- | --- |
| [X509Certificate2](https://learn.microsoft.com/dotnet/api/system.security.cryptography.x509certificates.x509certificate2) |  |
```

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

### ServerHelloInfo Class

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.StreamExtended.ServerHelloInfo.html

Documentation for the ServerHelloInfo class, including its constructor and properties.

```APIDOC
## Class ServerHelloInfo

### Description
Wraps up the server SSL hello information.

### Namespace
Titanium.Web.Proxy.StreamExtended

### Assembly
Titanium.Web.Proxy.dll

### Syntax
```csharp
public class ServerHelloInfo
```

### Inheritance
object -> ServerHelloInfo

### Constructors

#### ServerHelloInfo(int handshakeVersion, int majorVersion, int minorVersion, byte[] random, byte[] sessionId, int cipherSuite, int serverHelloLength)

Initializes a new instance of the ServerHelloInfo class.

##### Declaration
```csharp
public ServerHelloInfo(int handshakeVersion, int majorVersion, int minorVersion, byte[] random, byte[] sessionId, int cipherSuite, int serverHelloLength)
```

##### Parameters
- **handshakeVersion** (int) - The handshake version.
- **majorVersion** (int) - The major version.
- **minorVersion** (int) - The minor version.
- **random** (byte[]) - The random data.
- **sessionId** (byte[]) - The session ID.
- **cipherSuite** (int) - The cipher suite.
- **serverHelloLength** (int) - The length of the server hello message.

### Properties

#### CipherSuite

Gets the cipher suite.

##### Declaration
```csharp
public int CipherSuite { get; }
```

##### Property Value
- **CipherSuite** (int) - The cipher suite.

#### CompressionMethod

Gets the compression method.

##### Declaration
```csharp
public int CompressionMethod { get; }
```

##### Property Value
- **CompressionMethod** (int) - The compression method.
```

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

### DataEventArgs.Buffer

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.StreamExtended.Network.DataEventArgs.html

Gets the buffer containing the data.

```APIDOC
## Property: Buffer

### Description
The buffer with data.

### Declaration
```csharp
public byte[] Buffer { get; }
```

### Property Value
| Type | Description |
| --- | --- |
| byte[] | The buffer containing the data. |
```

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

### CreateSystemProxySettings

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/src/Titanium.Web.Proxy/PublicAPI.Unshipped.txt

Static factory methods to create SystemProxySettings instances with various configurations.

```APIDOC
## CreateSystemProxySettings (Overloads)

### Description
Creates system proxy settings with optional loopback and bypass rules.

### Methods
- `static SystemProxySettings CreateSystemProxySettings()`
- `static SystemProxySettings CreateSystemProxySettings(bool proxyLoopback)`
- `static SystemProxySettings CreateSystemProxySettings(bool proxyLoopback, IEnumerable<string>? additionalBypassRules)`
- `static SystemProxySettings CreateSystemProxySettings(bool proxyLoopback, IEnumerable<string>? bypassRules, MitmExclusionMode mode)`

### Parameters
- **proxyLoopback** (bool) - Optional - Whether to proxy loopback connections.
- **additionalBypassRules** (IEnumerable<string>?) - Optional - Additional bypass rules.
- **bypassRules** (IEnumerable<string>?) - Optional - Bypass rules.
- **mode** (MitmExclusionMode) - Optional - The exclusion mode.

### Return Value
SystemProxySettings
```

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

### SslExtension.Value

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.StreamExtended.Models.SslExtension.html

Gets the value of the SSL extension.

```APIDOC
## Property: Value

### Description
Gets the value.

### Declaration
```csharp
public int Value { get; }
```

### Property Value
| Type | Description |
| --- | --- |
| int | The value. |
```

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

### TwpConfigLoader.LoadFile

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/src/Titanium.Web.Proxy.Configuration/PublicAPI.Unshipped.txt

Loads a configuration from a file path.

```APIDOC
## TwpConfigLoader.LoadFile

### Description
Loads a configuration from a file path.

### Method
Static method

### Signature
`static Titanium.Web.Proxy.Configuration.TwpConfigLoader.LoadFile(string path) -> Titanium.Web.Proxy.Configuration.Models.TwpConfig`

### Parameters
- **path** (string) - Required - The path to the configuration file.

### Returns
- **TwpConfig** - The loaded configuration object.

```

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

### SslExtension.Position

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.StreamExtended.Models.SslExtension.html

Gets the position of the SSL extension.

```APIDOC
## Property: Position

### Description
Gets the position.

### Declaration
```csharp
public int Position { get; }
```

### Property Value
| Type | Description |
| --- | --- |
| int | The position. |
```

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

### SslExtension.Name

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.StreamExtended.Models.SslExtension.html

Gets the name of the SSL extension.

```APIDOC
## Property: Name

### Description
Gets the name.

### Declaration
```csharp
public string Name { get; }
```

### Property Value
| Type | Description |
| --- | --- |
| string | The name. |
```

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

### InstallRootIntoCertificateStores(bool)

Source: https://github.com/justcoding121/titanium-web-proxy/blob/develop/docs/api/Titanium.Web.Proxy.Network.CertificateManager.html

Installs the root into Personal + Trusted Root stores only (Windows CryptUI Yes/No on Root Add). Does not prune orphans or run Unix Keychain/NSS trust.

```APIDOC
## InstallRootIntoCertificateStores(bool machineTrusted = false)

### Description
Installs the root into Personal + Trusted Root stores only (Windows CryptUI Yes/No on Root Add). Does not prune orphans or run Unix Keychain/NSS trust — UI callers should finish those off the dispatcher after CryptUI returns so Avalonia does not show Not Responding.

### Method
InstallRootIntoCertificateStores

### Signature
public bool InstallRootIntoCertificateStores(bool machineTrusted = false)

### Parameters
- **machineTrusted** (bool) - Optional - Indicates whether to install in machine trust stores.

### Returns
- **bool** - True when the user Root store entry was newly added.
```
Tokens:
Raw