skcptun

scptun

skcptun é um túnel KCP criptografado para OpenWRT e Linux e MacOS, implementado em linguagem C e Lua.

estado

• “Não é como se não pudesse ser usado”
• Atualmente é uma versão com Lua adicionada, e a versão C pura não é mais mantida.

característica

• Com base no túnel criptografado UDP confiável, os dados de transmissão criptografados não possuem características.
• Pode ser usado para acelerar conexões de rede, com modo rápido e modo normal. A velocidade de transmissão medida do modo rápido é muito maior que a transmissão TCP. (marca de referência)
• Atualmente suporta dois modos: modo TUN e modo TCP
  • No modo TUN, o cliente e o servidor criam uma placa de rede virtual no mesmo segmento de rede. O cliente transmite de forma transparente todos os pacotes IP para o servidor através do túnel KCP criptografado, semelhante ao modo VPN tradicional.
  • No modo TCP, o cliente escuta uma (ou mais) portas e transmite de forma transparente todos os dados recebidos para o servidor através do túnel KCP criptografado. O servidor transmite os dados de forma transparente para o servidor designado. Geralmente é usado quando o modo TUN está bloqueado.
• Você pode usar scripts Lua para implementar seus próprios serviços customizados com base na API fornecida pelo skcptun.

Instalar

Ambiente operacional: Linux, MacOS

Bibliotecas dependentes: OpenSSL, libev

Após baixar o código fonte e descompactá-lo:

 cd skcptun
mkdir build
cd build
cmake ..
make

Se você clonar diretamente, precisará atualizar o submódulo:

 git submodule update --init --recursive

Configuração do ambiente

Modo TCP

• Configure o arquivo de configuração e inicie-o para uso

Modo TUN

• Como o túnel é estabelecido através da tecnologia de placa de rede virtual, é necessário fazer as configurações de rede necessárias.
• Tomando o Linux (Debian) como exemplo, o kernel precisa suportar o módulo tun. Confirme com o comando "modinfo tun".
• Requer kits de ferramentas "iproute2" e "iptables" instalados.

Servidor

• Habilite o encaminhamento de IP, adicione a seguinte configuração ao arquivo "/etc/sysctl.conf" e execute "sysctl -p" para entrar em vigor.

 net.ipv4.ip_forward=1
net.ipv4.conf.all.route_localnet = 1
net.ipv4.conf.default.route_localnet = 1
net.ipv4.conf.[网卡接口].route_localnet = 1
net.ipv4.conf.lo.route_localnet = 1
net.ipv4.conf.[虚拟网卡接口].route_localnet = 1

• Ative o encaminhamento de IP e modifique a política de encaminhamento padrão "iptables -P FORWARD ACCEPT"
• Modifique o endereço de origem do nat para o endereço da placa de rede de saída "iptables -t nat -A POSTROUTING -s 192.168.2.1/24 -o enp1s0 -j ​​​​MASQUERADE"

cliente

• Habilitar encaminhamento de IP

usar

 skcptun <configfile>

• configfile é o arquivo de configuração
• Se for o modo TUN, serão necessárias permissões de root para executar.

Arquivo de configuração:

O arquivo de configuração é um arquivo Lua, consulte "skcptun_config_sample", contém comentários.

Variáveis ​​internas fornecidas por skcptun

skt

"skt" é uma variável global integrada usada por scripts Lua, incluindo "skt.conf.*", "skt.api.*" e "skt.cb.*".

Informações de configuração do skcptun

"skt.conf.*": Variáveis ​​de informações de configuração expostas pelo skcptun para scripts Lua.

skt.conf.tun_ip

O IP da placa de rede virtual, cliente e servidor precisam ser configurados para o mesmo segmento de rede, válido nos modos "tun_client" e "tun_server".

skt.conf.tun_mask

A máscara de sub-rede da placa de rede virtual, as configurações do cliente e do servidor são consistentes e válidas nos modos "tun_client" e "tun_server".

skt.conf.skcp_serv_conf_list_size

O número de "skcp_serv_conf".

skt.conf.skcp_serv_conf_list[i].raw

O i-ésimo ponteiro "skcp_serv_conf" é usado para passar parâmetros para a API.

skt.conf.skcp_serv_conf_list[i].addr

O endereço IP do i-ésimo "skcp_serv_conf"

skt.conf.skcp_serv_conf_list[i].port

A porta do i-ésimo "skcp_serv_conf"

skt.conf.skcp_serv_conf_list[i].key

A string criptografada do i-ésimo "skcp_serv_conf"

skt.conf.skcp_serv_conf_list[i].ticket

O ticket de acesso acordado entre o i-ésimo cliente e servidor "skcp_serv_conf" é válido nos modos "tun_client" e "proxy_client".

skt.conf.skcp_serv_conf_list[i].max_conn_cnt

O número máximo de conexões para o i-ésimo "skcp_serv_conf", válido nos modos "proxy_server" e "tun_server".

A configuração do skt.conf.skcp_cli_conf_list* é igual à do skt.conf.skcp_serv_conf_list*

skt.conf.etcp_serv_conf_list_size

O número de "etcp_serv_conf_list"

skt.conf.etcp_serv_conf_list[i].raw

O próprio ponteiro do servidor tcp "etcp_serv_conf" é usado para passar parâmetros para a API.

skt.conf.etcp_serv_conf_list[i].addr

O endereço de escuta do servidor tcp.

skt.conf.etcp_serv_conf_list[i].port

A porta de escuta do servidor tcp.

skt.conf.etcp_cli_conf_list_size

O número de "etcp_cli_conf_list"

skt.conf.etcp_cli_conf_list[i].raw

O próprio ponteiro do cliente tcp "etcp_cli_conf" é usado para passar parâmetros para a API.

skt.conf.etcp_cli_conf_list[i].addr

O endereço de conexão do cliente tcp, válido no modo "servidor proxy".

skt.conf.etcp_cli_conf_list[i].port

A porta de conexão do cliente tcp, válida no modo "servidor proxy".

API Lua interna fornecida por skcptun

"skt.api.*", a API exposta por skcptun para scripts Lua.

skt.api.skcp_init(conf,loop,skcp_mode)

Inicialize o skcp.

• parâmetro
  • conf: configuração do skcp
  • loop: objeto de loop de evento
  • skcp_mode: modo de inicialização do skcp, inteiro, 1 representa o modo servidor, 2 representa o modo cliente
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Retorna com sucesso o objeto skcp

skt.api.skcp_free(skcp)

Destrua e libere o skcp.

• parâmetro
  • objeto skcp
• Valor de retorno: Nenhum

skt.api.skcp_req_cid(skcp, ticket)

Solicite o ID de conexão do servidor skcp.

• parâmetro
  • objeto skcp
  • ticket: o ticket correspondente nas informações de configuração, string
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Retorne "ok" com sucesso

skt.api.skcp_send(skcp, cid, buf)

Envie mensagens via skcp.

• parâmetro
  • objeto skcp
  • cid: ID de conexão do skcp, inteiro
  • buf: conteúdo da mensagem, string
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Retorna com sucesso o número de bytes enviados com sucesso >= 0, inteiro

skt.api.skcp_close_conn(skcp,cid)

Feche uma conexão skcp.

• parâmetro
  • objeto skcp
  • cid: ID de conexão do skcp, inteiro
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Retorna 0 com sucesso, inteiro

skt.api.skcp_get_conn(skcp,cid)

Obtenha uma conexão skcp.

• parâmetro
  • objeto skcp
  • cid: ID de conexão do skcp, inteiro
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Objeto de conexão bem-sucedido

skt.api.etcp_server_init(conf,loop)

Inicialize o servidor etcp.

• parâmetro
  • conf: configuração do skcp
  • loop: objeto de loop de evento
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Retorna com sucesso o objeto do servidor etcp

skt.api.etcp_server_free(etcp)

Destrua e libere o servidor etcp.

• parâmetro
  • objeto de servidor etcp
• Valor de retorno Nenhum

skt.api.etcp_server_send(etcp,fd,buf)

Envie mensagens para clientes via etcp.

• parâmetro
  • objeto de servidor etcp
  • fd: fd correspondente, inteiro
  • buf: conteúdo da mensagem, string
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Retorna com sucesso o número de bytes enviados com sucesso> 0, inteiro

skt.api.etcp_server_get_conn(etcp,fd)

Obtenha uma conexão com um servidor etcp.

• parâmetro
  • objeto de servidor etcp
  • fd: fd correspondente, inteiro
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Retorna com sucesso o objeto conn

skt.api.etcp_server_close_conn(etcp,fd,silencioso)

Feche uma conexão do servidor etcp.

• parâmetro
  • objeto de servidor etcp
  • fd: fd correspondente, inteiro
  • Silencioso: Se deve fechar silenciosamente. Se não for fechado silenciosamente, o evento "on_close" será acionado. 1 significa fechamento silencioso, 0 significa fechamento não silencioso.
• Valor de retorno: Nenhum

skt.api.etcp_client_init(conf,loop)

Inicialize o cliente etcp.

• parâmetro
  • conf: configuração do skcp
  • loop: objeto de loop de evento
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Retorna com sucesso o objeto cliente etcp

skt.api.etcp_client_free(etcp)

Destrua e libere o cliente etcp.

• parâmetro
  • objeto cliente etcp
• Valor de retorno: Nenhum

skt.api.etcp_client_send(etcp,fd,buf)

Envie mensagens para o servidor através do etcp.

• parâmetro
  • objeto cliente etcp
  • fd: fd correspondente, inteiro
  • buf: conteúdo da mensagem, string
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Retorna com sucesso o número de bytes enviados com sucesso> 0, inteiro

skt.api.etcp_client_create_conn(etcp, endereço, porta)

Crie uma conexão etcp.

• parâmetro
  • objeto cliente etcp
  • addr: Precisa se conectar ao endereço do servidor, string
  • porta: precisa se conectar à porta do servidor
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Retorna com sucesso o fd criado, tipo inteiro

skt.api.etcp_client_close_conn(etcp,fd)

Feche uma conexão do cliente etcp.

• parâmetro
  • objeto cliente etcp
  • fd: fd correspondente, inteiro
• Valor de retorno: Nenhum

skt.api.etcp_client_get_conn(etcp,fd)

Obtenha uma conexão de cliente etcp.

• parâmetro
  • objeto cliente etcp
  • fd: fd correspondente, inteiro
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Retorna com sucesso o objeto conn

skt.api.tuntap_write(fd,buf)

Grave dados na placa de rede virtual.

• parâmetro
  • fd: fd da placa de rede virtual, inteiro
  • buf: dados a serem gravados, string
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Número de bytes gravados com sucesso, inteiro

skt.api.get_from_skcp(skcp, nome)

Obtenha o valor do campo correspondente no objeto skcp, a saber: "skcp.name".

• parâmetro
  • objeto skcp
  • nome: nome do campo no skcp, atualmente suporta apenas campo "fd", string
• valor de retorno
  • A falha retorna "nil, error_msg"
  • Retorna com sucesso o valor correspondente ao nome, qualquer

skt.api.get_ms()

Obtenha o número de milissegundos desde 1970 para o sistema atual.

• Parâmetros: Nenhum
• Valor de retorno:
  • inteiro

skt.api.hton32(i)

Converta variáveis ​​inteiras de 32 bits da ordem de bytes do host para a ordem de bytes da rede.

• parâmetro
  • i: tipo inteiro na ordem de bytes do host
• valor de retorno
  • Retorna um número inteiro na ordem de bytes da rede

skt.api.ntoh32(i)

Converta variáveis ​​inteiras de 32 bits da ordem de bytes da rede para a ordem de bytes do host.

• parâmetro
  • i: Tipo inteiro na ordem de bytes da rede
• valor de retorno
  • Retorna um número inteiro na ordem de bytes do host

skt.api.band(a,b)

Execute uma operação AND lógica bit a bit em dois inteiros e retorne o resultado

skt.api.bor(a,b)

Execute uma operação OR lógica bit a bit em dois inteiros e retorne o resultado

skt.api.bxor(a,b)

Execute uma operação XOR bit a bit em dois inteiros e retorne o resultado

skt.api.blshift(i,n)

Desloque o número inteiro para a esquerda em n bits e retorne o resultado

skt.api.brshift(i,n)

Desloque o número inteiro para a direita em n bits e retorne o resultado

skt.api.lookup_dns(domínio)

Resolução de nome de domínio

• parâmetro
  • domínio: nome de domínio a ser resolvido, string
• valor de retorno
  • Retorna o IP correspondente em formato pontilhado (IPV4), string

A interface de retorno de chamada que o script Lua precisa implementar

"skt.cb.*" precisa implementar diferentes interfaces de acordo com diferentes modos de inicialização para retorno de chamada skcptun.

skt.cb.on_init(loop)

A primeira interface de retorno de chamada chamada quando o script é iniciado e só é chamada uma vez

• Faixa válida: todos os modos
• parâmetro
  • loop: objeto de loop de evento
• Valor de retorno: Nenhum

skt.cb.on_skcp_accept(skcp, cid)

O servidor skcp cria um cid com sucesso e é chamado apenas uma vez para cada conexão.

• Intervalo válido: "proxy_server", "tun_server"
• parâmetro
  • objeto skcp
  • cid: ID de conexão do skcp, inteiro
• Valor de retorno: Nenhum

skt.cb.on_skcp_check_ticket(skcp, bilhete)

O servidor skcp verifica se o ticket está correto.

• Intervalo válido: "proxy_server", "tun_server"
• parâmetro
  • objeto skcp
  • ticket: ticket que precisa ser verificado, string
• Valor de retorno:
  • Retorna 0 se a verificação for bem-sucedida
  • Se a verificação falhar, um valor diferente de zero será retornado.

skt.cb.on_skcp_recv_cid(skcp, cid)

O skcp recebe um cid, indicando que uma conexão foi estabelecida com sucesso com o servidor skcp. Ou seja, a estrutura assíncrona de "skt.api.skcp_req_cid(skcp, ticket)" é retornada.

• Intervalo válido: "proxy_client", "tun_client"
• parâmetro
  • objeto skcp
  • cid: ID de conexão do skcp, inteiro
• Valor de retorno: Nenhum

skt.cb.on_skcp_recv_data(skcp, cid, buf)

skcp recebe os dados correspondentes à conexão do cid.

• Faixa válida: todos os modos
• parâmetro
  • objeto skcp
  • cid: ID de conexão do skcp, inteiro
  • buf: conteúdo da mensagem recebida, string
• Valor de retorno: Nenhum

skt.cb.on_skcp_close(skcp,cid)

O retorno de chamada quando o skcp fecha uma conexão geralmente pode ser causado por um tempo limite ou pelo recebimento de um comando de fechamento do peer. A conexão não foi realmente fechada neste momento.

• Faixa válida: todos os modos
• parâmetro
  • objeto skcp
  • cid: ID de conexão do skcp, inteiro
• Valor de retorno: Nenhum

skt.cb.on_tcp_accept(fd)

O servidor TCP recebe uma solicitação de conexão.

• Intervalo válido: "proxy_client", "tun_client"
• parâmetro
  • fd: fd solicitado pela conexão, inteiro
• Valor de retorno: Nenhum

skt.cb.on_tcp_recv(fd, buf)

Receba os dados tcp correspondentes à conexão do fd.

• Faixa válida: todos os modos
• parâmetro
  • fd: fd da conexão, inteiro
  • buf: conteúdo da mensagem recebida, string
• Valor de retorno: Nenhum

skt.cb.on_tcp_close(fd)

Feche a conexão tcp correspondente a fd A conexão não foi realmente fechada neste momento.

• Faixa válida: todos os modos
• parâmetro
  • fd: fd da conexão, inteiro
• Valor de retorno: Nenhum

skt.cb.on_tun_read(buf)

Receba dados da placa de rede virtual.

• Intervalo válido: "tun_client", "tun_server"
• parâmetro
  • buf: conteúdo da mensagem recebida, string
• Valor de retorno: Nenhum

skt.cb.on_beat()

Aciona uma chamada a cada segundo.

• Intervalo válido: "proxy_client", "tun_client"
• Parâmetros: Nenhum
• Valor de retorno: Nenhum

teste

ambiente

• Servidor:Linux/1C/1G
• Cliente: MacOS/8C/8G
• Status da rede, valor do ping:

 21 packets transmitted, 20 packets received, 4.8% packet loss
round-trip min/avg/max/stddev = 159.492/164.087/171.097/3.232 ms

Dados de processo (RTT)

• Número de conexões: 1 pacotes de dados: 1000; intervalo de envio: 100ms;

 TCP RTT:
------------
Min = 161.0
Max = 1239.0
Average = 293.956
NR = 1000

 Skcptun RTT:
------------
Min = 160.0
Max = 487.0
Average = 181.618
NR = 1000

• Número de conexões: 10 pacotes de dados: 1000; intervalo de envio: 100ms;

 TCP RTT:
------------
Min = 159.0
Max = 1076.0
Average = 262.500
NR = 10000

 Skcptun RTT:
------------
Min = 159.0
Max = 534.0
Average = 174.251
NR = 10000

para concluir

• No mesmo ambiente de rede, o efeito de melhoria da velocidade é de cerca de 30% a 40%.

Perceber

• Acabei de escrever, para uso pessoal e as funções estão sendo aperfeiçoadas
• Certifique-se de não usá-lo para acelerar a criptografia do proxy sock5.