Kcptun - A UDP Tunnel Based on KCP Protocol - Converting TCP Streams to KCP+UDP to Stream IPTV

Edited on In Views: Reading time ≈ 7 mins.

Suited for applications with low latency and high speed requirements, it is reputed to double the transmission efficiency X2+.

Target

Accelerating end-to-end remote transmission (point-to-point p2p transmission, encapsulating TCP data as UDP KCP data) through UDP tunneling.

Kcptun is a simple and fast UDP tunnel based on the KCP protocol, capable of converting TCP streams to KCP+UDP streams.

Application

Simple deployment and configuration.

Here’s an example:

  1. A certain application on a remote/distant client needs to access a specific TCP service within the server’s network segment (such as a game or IPTV).
  2. By launching the kcptun client on the remote client’s router#1 (listening on a local port and then specifying the server’s IP and port, along with encryption information), this kcptun client’s listening port becomes the port the local application will use to connect.
  3. Connect to the specific kcp server (listening on the server’s port and then specifying the destination TCP service [IP address and port]) through the server (forwarded from router#2’s port).
  4. This encrypted and encapsulated entire chain is established over UDP, purportedly doubling transmission efficiency X2+.

Below are two examples of using docker for kcptun applications.

Practical Example 1:

https://hub.docker.com/r/lowid/kcptun

If the service to be encapsulated is a SOCKS proxy on the server:

Server side (kcp+socks) compose file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
kcp-server:
  image: lowid/kcptun:v20170329
  command:
    --listen :29900
    --target dante-server:1080
    --mode fast2
  ports:
    - "30003:29900/udp"
  environment:
    - KCPTUN_KEY=your_password
  links:
    - dante-server
  restart: always

dante-server:
  image: vimagick/dante
  expose:
    - "1080"
  volumes:
    - ./sockd.conf:/etc/sockd.conf
  restart: always

Server side sockd.conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
debug: 0
logoutput: stderr
internal: 0.0.0.0 port = 1080
external: eth0
socksmethod: username none
clientmethod: none
user.privileged: root
user.unprivileged: nobody

client pass {
    from: 0.0.0.0/0 port 1-65535 to: 0.0.0.0/0
    log: error
}

socks pass {
    from: 0.0.0.0/0 to: 0.0.0.0/0
    #socksmethod: username
    log: error
}

Client side compose file

1
2
3
4
5
6
7
8
9
10
11
12
client:
  image: lowid/kcptun:v20170329
  entrypoint: client_linux_amd64
  command:
    --localaddr :12948
    --remoteaddr server_ip_address:30003
    --mode fast2
  ports:
    - "12948:12948/tcp"
  environment:
    - KCPTUN_KEY=your_password
  restart: always

Practical Example 2:

1
2
3
4
5
6
7
8
9
10
11
12
13
$ docker pull chenhw2/kcptun

$ docker run -d \
    -e "ARGS=server -t 10.0.0.1:80" \
    -p 29900:29900/udp \
    chenhw2/kcptun


#Client
$ docker run -d \
    -e "ARGS=client -r [kcp_server]:29900" \
    -p 12948:12948/tcp \
    chenhw2/kcptun

Related Content

Implementation Approach

Abandoning the docker approach.

KCP Server:

1
./server_linux_amd64 -t "192.168.6.243:8012" -l ":29900" -mode fast3 -nocomp -dscp 46 --key op.carlzeng.com --crypt salsa20

Explanatory note: Because this service on port 29900 is configured on a specific server (not on the main router’s public IP), it requires port mapping on the main router’s public IP (i.e., to forward external 29900 UDP data to the same port on this specific server).

1
2
3
4
5
# Configuration in Padavan interface on K2P

KCP Client: ./client_darwin_amd64 -r "KCP_SERVER_IP:29900" -l ":8012" -mode fast3 -nocomp -autoexpire 900 -sockbuf 16777217 -dscp 46

/opt/bin/kcptun  -r "@@@.@@@.@@@.@@@:29900" -l ":88012" -key op.carlzeng.com -crypt salsa20 -mode fast3 -dscp 46 -autoexpire 900 -nocomp

A comprehensive diagram of the entire process

An instance of the entire process using kcptun

A peculiar testing method was used to play through frp to another location;
Testing experience: High definition is very smooth, 4K still experiences some lag;
TODO: Waiting for the next step to test local area network playback on the client side after KCP transmission.

After such KCP transmission, as per reports, the transmission latency is halved, and the speed is doubled X2+; awaiting further practical testing to verify.

Source of Inspiration

[Tutorial, project address: https://github.com/xtaci/kcptun/](