# Supported Protocols in the Fanqiang Repository: A Complete Technical Guide

> Explore the comprehensive protocol support in the bannedbook/fanqiang repository. Discover core Go implementations like HTTP/HTTPS, SOCKS5, STUN, DNS plus popular proxies such as Shadowsocks, V2Ray, and Trojan.

- Repository: [如何翻墙/fanqiang](https://github.com/bannedbook/fanqiang)
- Tags: deep-dive
- Published: 2026-09-05

---

**The bannedbook/fanqiang repository supports network protocols ranging from core Go implementations (HTTP/HTTPS, SOCKS5, STUN, DNS) to bundled proxy binaries (Shadowsocks, V2Ray, Trojan, Brook, Lightsocks, Lantern, and Psiphon).**

The Fanqiang codebase provides a comprehensive censorship-circumvention toolkit used by Android and desktop "one-click" tools. This guide examines the protocol implementations across the core Go library (`fqnews2/libcore`) and the higher-level wrapper scripts that extend support to additional proxy technologies.

## Core Protocols Implemented in Go

The **core Go library** (`fqnews2/libcore`) contains native implementations for four fundamental network protocols. These provide the foundation for connectivity and NAT traversal.

### HTTP and HTTPS with Modern TLS

The repository implements a configurable HTTP client in [`fqnews2/libcore/http.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/http.go) that enforces modern TLS standards. The client supports **restricted TLS** configurations and **certificate pinning** to prevent downgrade attacks.

Key methods include `NewHttpClient()`, `ModernTLS()` for TLS 1.2+ enforcement, and `NewRequest()` for building requests with `SetURL()`, `SetMethod()`, and `SetUserAgent()`.

### SOCKS5 Proxy Integration

SOCKS5 support is integrated directly into the HTTP client via the `TrySocks5()` method. When invoked (e.g., `TrySocks5(1080)`), the client attempts to tunnel traffic through `127.0.0.1:1080` using `socks.ClientHandshake5` from the `github.com/sagernet/sing/protocol/socks` package.

This implementation allows the HTTP client to automatically fallback to local SOCKS5 servers when direct connections fail.

### STUN for NAT Traversal

Full **Session Traversal Utilities for NAT (STUN)** protocol support resides in `fqnews2/libcore/stun/`. The implementation includes packet handling ([`packet.go`](https://github.com/bannedbook/fanqiang/blob/main/packet.go)), client logic ([`client.go`](https://github.com/bannedbook/fanqiang/blob/main/client.go)), and discovery mechanisms ([`discover.go`](https://github.com/bannedbook/fanqiang/blob/main/discover.go), [`host.go`](https://github.com/bannedbook/fanqiang/blob/main/host.go)).

The STUN client enables public IP/port discovery essential for peer-to-peer connections behind NAT devices.

### DNS Resolution (UDP and TCP)

Basic DNS query handling operates over UDP and is implemented in [`fqnews2/libcore/dns_box.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/dns_box.go). This module provides DNS request/response structures and UDP socket management, used internally by the STUN client and other utilities for hostname resolution without relying on system DNS.

## Extended Protocol Support via Bundled Tools

Beyond the native Go implementations, the repository extends support to additional proxy protocols through pre-compiled binaries and wrapper scripts located in the `ChromeGo` directories and Android documentation.

### Shadowsocks (SS)

The repository ships with a ready-made Android Shadowsocks client documented in [`android/Shadowsocks.md`](https://github.com/bannedbook/fanqiang/blob/main/android/Shadowsocks.md). The Go layer provides shared cryptographic primitives in [`fqnews2/libcore/crypto.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/crypto.go) for packet encryption and decryption, supporting the Shadowsocks protocol suite.

### V2Ray Protocol Suite

Multiple V2Ray-compatible protocols (VMess, VLess, etc.) are bundled in the ChromeGo packages. Rather than re-implementing these in Go, the repository invokes external V2Ray core binaries through wrapper scripts. The Go code serves as a launcher and process manager for these protocols.

### Trojan, Brook, and Lightsocks

- **Trojan**: Supported via the ChromeGo one-click package with launch scripts that invoke the Trojan binary.
- **Brook**: Implemented through external binary invocation with repository-provided wrapper scripts.
- **Lightsocks**: Bundled similarly in the ChromeGo package with wrapper scripts managing the pre-compiled Lightsocks binary.

### Proprietary Protocols (Lantern, Psiphon)

Protocols such as **蓝灯 (Lantern)** and **Psiphon** are supported out-of-the-box through packaged binaries. These are not re-implemented in Go but are launched via helper scripts in the `ChromeGo` directory, providing immediate usability without custom protocol coding.

## Working with the Core Protocols

The following examples demonstrate practical usage of the native Go implementations for HTTP tunneling, STUN discovery, and DNS resolution.

### Creating an HTTP Client with SOCKS5 Fallback

This example creates an HTTP client that enforces modern TLS and tunnels through a local SOCKS5 proxy on port 1080:

```go
client := libcore.NewHttpClient().
    ModernTLS().          // enforce TLS 1.2+
    TrySocks5(1080)       // forward through 127.0.0.1:1080 if available

req := client.NewRequest().
    SetURL("https://example.com").
    SetMethod("GET").
    SetUserAgent("Fanqiang/1.0")

resp, err := req.Execute()
if err == nil {
    body, _ := resp.GetContentString()
    fmt.Println(body)
}

```

### Discovering Public IP via STUN

To discover your public IP address and port using Google's STUN server:

```go
stunClient := stun.NewClient("stun.l.google.com:19302")
addr, err := stunClient.Discover()
if err == nil {
    fmt.Printf("Public IP: %s:%d\n", addr.IP, addr.Port)
}

```

### Executing Raw DNS Queries

For direct DNS resolution over UDP without system resolver dependencies:

```go
dnsReq := libcore.NewDNSRequest()
dnsReq.SetQuestion("example.com.", dns.TypeA)
resp, err := dnsReq.Exchange("8.8.8.8:53")
if err == nil {
    fmt.Println(resp.Answers)
}

```

## Key Implementation Files

The following source files contain the protocol implementations referenced throughout this guide:

- **[`fqnews2/libcore/http.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/http.go)**: HTTP/HTTPS client with SOCKS5 tunneling support via `TrySocks5()` and `socks.ClientHandshake5`.
- **`fqnews2/libcore/stun/`**: Complete STUN protocol stack including [`client.go`](https://github.com/bannedbook/fanqiang/blob/main/client.go), [`discover.go`](https://github.com/bannedbook/fanqiang/blob/main/discover.go), [`packet.go`](https://github.com/bannedbook/fanqiang/blob/main/packet.go), and [`host.go`](https://github.com/bannedbook/fanqiang/blob/main/host.go) for NAT traversal.
- **[`fqnews2/libcore/dns_box.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/dns_box.go)**: DNS request/response utilities and UDP handling for raw DNS queries.
- **[`fqnews2/libcore/crypto.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/crypto.go)**: Shared cryptographic primitives supporting Shadowsocks and other encrypted protocols.
- **`ChromeGo*/`**: Directories containing wrapper scripts for Trojan, Brook, Lightsocks, Lantern, and Psiphon binaries.
- **[`android/Shadowsocks.md`](https://github.com/bannedbook/fanqiang/blob/main/android/Shadowsocks.md)**: Documentation and configuration for the Android Shadowsocks client implementation.

## Summary

- The **core Go library** natively implements HTTP/HTTPS (with modern TLS), SOCKS5 proxy tunneling, STUN for NAT traversal, and DNS over UDP.
- **Extended protocol support** comes via bundled binaries for Shadowsocks, V2Ray (VMess/VLess), Trojan, Brook, Lightsocks, Lantern, and Psiphon.
- **Key entry points** in [`fqnews2/libcore/http.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/http.go) allow configurable HTTP clients with automatic SOCKS5 fallback.
- The **STUN implementation** in `fqnews2/libcore/stun/` provides complete NAT discovery capabilities without external dependencies.
- **Wrapper scripts** in the ChromeGo directories enable "one-click" usage of complex proxy protocols without requiring users to compile or configure binary dependencies manually.

## Frequently Asked Questions

### Does the Fanqiang repository implement V2Ray protocols in Go?

No, the repository does not implement V2Ray protocols (VMess, VLess) directly in Go code. Instead, it bundles official V2Ray core binaries and provides Go-based wrapper scripts to launch and manage these processes. The native Go implementation focuses on HTTP/HTTPS, SOCKS5, STUN, and DNS protocols.

### How does the HTTP client handle SOCKS5 proxy connections?

The HTTP client in [`fqnews2/libcore/http.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/http.go) implements SOCKS5 support through the `TrySocks5()` method, which accepts a port number (e.g., `TrySocks5(1080)`). This method uses `socks.ClientHandshake5` from the Sing protocol library to negotiate a tunnel through `127.0.0.1:1080` before sending HTTP requests, enabling automatic fallback when direct connections fail.

### Where is the STUN protocol implemented in the codebase?

The complete STUN protocol implementation resides in the `fqnews2/libcore/stun/` directory. This includes [`client.go`](https://github.com/bannedbook/fanqiang/blob/main/client.go) for session management, [`discover.go`](https://github.com/bannedbook/fanqiang/blob/main/discover.go) for public IP discovery, [`packet.go`](https://github.com/bannedbook/fanqiang/blob/main/packet.go) for message formatting, and [`host.go`](https://github.com/bannedbook/fanqiang/blob/main/host.go) for address handling. These files provide standalone NAT traversal capabilities without requiring external STUN libraries.

### What encryption protocols does the Shadowsocks implementation support?

The repository's Shadowsocks support utilizes shared cryptographic primitives located in [`fqnews2/libcore/crypto.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/crypto.go). While the Android client implementation is documented in [`android/Shadowsocks.md`](https://github.com/bannedbook/fanqiang/blob/main/android/Shadowsocks.md), the actual encryption/decryption logic for Shadowsocks packets is handled through these Go cryptographic utilities, supporting the standard Shadowsocks cipher suites used by the Android client.