skcptun

skcptun

skcptun est un tunnel KCP crypté pour OpenWRT et Linux et MacOS, implémenté en langage C et Lua.

État

• "Ce n'est pas comme si on ne pouvait pas l'utiliser"
• Actuellement, il s'agit d'une version avec Lua ajouté, et la version pure C n'est plus maintenue.

caractéristiques

• Basé sur un tunnel crypté UDP fiable, les données de transmission cryptées n'ont aucune caractéristique.
• Il peut être utilisé pour accélérer les connexions réseau, avec le mode rapide et le mode normal. La vitesse de transmission mesurée en mode rapide est bien supérieure à celle de la transmission TCP. (repère de nivellement)
• Prend actuellement en charge deux modes : le mode TUN et le mode TCP
  • En mode TUN, le client et le serveur créent chacun une carte réseau virtuelle sur le même segment de réseau. Le client transmet de manière transparente tous les paquets IP au serveur via le tunnel KCP crypté, similaire au mode VPN traditionnel.
  • En mode TCP, le client écoute un (ou plusieurs) ports et transmet de manière transparente toutes les données reçues au serveur via le tunnel KCP crypté. Le serveur transmet de manière transparente les données au serveur désigné. Il est généralement utilisé lorsque le mode TUN est bloqué.
• Vous pouvez utiliser des scripts Lua pour implémenter vos propres services personnalisés basés sur l'API fournie par skcptun.

Installer

Environnement d'exploitation : Linux, MacOS

Bibliothèques dépendantes : OpenSSL, libev

Après avoir téléchargé le code source et l'avoir décompressé :

 cd skcptun
mkdir build
cd build
cmake ..
make

Si vous clonez directement, vous devez mettre à jour le sous-module :

 git submodule update --init --recursive

Configuration de l'environnement

Mode TCP

• Configurez le fichier de configuration et démarrez-le pour l'utiliser

Mode TUN

• Étant donné que le tunnel est établi via la technologie de carte réseau virtuelle, les paramètres réseau nécessaires doivent être définis.
• En prenant Linux (Debian) comme exemple, le noyau doit prendre en charge le module tun. Confirmez avec la commande "modinfo tun".
• Nécessite l'installation des kits d'outils "iproute2" et "iptables".

Serveur

• Activez le transfert IP, ajoutez la configuration suivante au fichier "/etc/sysctl.conf" et exécutez "sysctl -p" pour prendre effet.

 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

• Activez le transfert IP et modifiez la politique de transfert par défaut "iptables -P FORWARD ACCEPT"
• Modifiez l'adresse source de nat par l'adresse de la carte réseau de sortie "iptables -t nat -A POSTROUTING -s 192.168.2.1/24 -o enp1s0 -j ​​​​MASQUERADE"

client

• Activer le transfert IP

utiliser

 skcptun <configfile>

• configfile est le fichier de configuration
• S'il s'agit du mode TUN, les autorisations root sont requises pour s'exécuter.

Fichier de configuration :

Le fichier de configuration est un fichier Lua, reportez-vous à "skcptun_config_sample", il y a des commentaires à l'intérieur.

Variables internes fournies par skcptun

sans

"skt" est une variable globale intégrée utilisée par les scripts Lua, notamment "skt.conf.*", "skt.api.*" et "skt.cb.*".

Informations de configuration de skcptun

"skt.conf.*" : variables d'informations de configuration exposées par skcptun aux scripts Lua.

skt.conf.tun_ip

L'IP de la carte réseau virtuelle, du client et du serveur doit être définie sur le même segment de réseau, valable en modes "tun_client" et "tun_server".

skt.conf.tun_mask

Le masque de sous-réseau de la carte réseau virtuelle, les paramètres client et serveur sont cohérents et sont valables en modes "tun_client" et "tun_server".

skt.conf.skcp_serv_conf_list_size

Le nombre de "skcp_serv_conf".

skt.conf.skcp_serv_conf_list[i].raw

Le i-ième pointeur "skcp_serv_conf" lui-même est utilisé pour transmettre des paramètres à l'API.

skt.conf.skcp_serv_conf_list[i].addr

L'adresse IP du i-ème "skcp_serv_conf"

skt.conf.skcp_serv_conf_list[i].port

Le port du i-ième "skcp_serv_conf"

skt.conf.skcp_serv_conf_list[i].key

La chaîne chiffrée du i-ème "skcp_serv_conf"

skt.conf.skcp_serv_conf_list[i].ticket

Le ticket d'accès convenu entre le i-ème client et le serveur "skcp_serv_conf" est valable en modes "tun_client" et "proxy_client".

skt.conf.skcp_serv_conf_list[i].max_conn_cnt

Le nombre maximum de connexions pour le i-ième "skcp_serv_conf", valable en modes "proxy_server" et "tun_server".

La configuration de skt.conf.skcp_cli_conf_list* est la même que celle de skt.conf.skcp_serv_conf_list*

skt.conf.etcp_serv_conf_list_size

Le nombre de "etcp_serv_conf_list"

skt.conf.etcp_serv_conf_list[i].raw

Le pointeur du serveur TCP "etcp_serv_conf" lui-même est utilisé pour transmettre des paramètres à l'API.

skt.conf.etcp_serv_conf_list[i].addr

L'adresse d'écoute du serveur TCP.

skt.conf.etcp_serv_conf_list[i].port

Le port d'écoute du serveur TCP.

skt.conf.etcp_cli_conf_list_size

Le nombre de "etcp_cli_conf_list"

skt.conf.etcp_cli_conf_list[i].raw

Le pointeur du client TCP "etcp_cli_conf" lui-même est utilisé pour transmettre des paramètres à l'API.

skt.conf.etcp_cli_conf_list[i].addr

L'adresse de connexion du client TCP, valable en mode "serveur proxy".

skt.conf.etcp_cli_conf_list[i].port

Le port de connexion du client TCP, valable en mode "serveur proxy".

API Lua interne fournie par skcptun

"skt.api.*", l'API exposée par skcptun aux scripts Lua.

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

Initialisez skcp.

• paramètre
  • conf : configuration de skcp
  • loop : objet de boucle d'événement
  • skcp_mode : mode de démarrage skcp, entier, 1 représente le mode serveur, 2 représente le mode client
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Renvoie avec succès l'objet skcp

skt.api.skcp_free(skcp)

Détruisez et libérez skcp.

• paramètre
  • objet skcp
• Valeur de retour : Aucun

skt.api.skcp_req_cid(skcp, ticket)

Demandez l'identifiant de connexion au serveur skcp.

• paramètre
  • objet skcp
  • ticket : le ticket correspondant dans les informations de configuration, chaîne
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Renvoie "ok" avec succès

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

Envoyez des messages via skcp.

• paramètre
  • objet skcp
  • cid : identifiant de connexion de skcp, entier
  • buf : contenu du message, chaîne
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Renvoie avec succès le nombre d'octets envoyés avec succès >= 0, entier

skt.api.skcp_close_conn(skcp, cid)

Fermez une connexion skcp.

• paramètre
  • objet skcp
  • cid : identifiant de connexion de skcp, entier
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Renvoie 0 avec succès, entier

skt.api.skcp_get_conn(skcp, cid)

Obtenez une connexion skcp.

• paramètre
  • objet skcp
  • cid : identifiant de connexion de skcp, entier
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Objet de connexion réussi

skt.api.etcp_server_init(conf, boucle)

Initialisez le serveur etcp.

• paramètre
  • conf : configuration de skcp
  • loop : objet de boucle d'événement
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Renvoie avec succès l'objet serveur etcp

skt.api.etcp_server_free(etcp)

Détruisez et libérez le serveur etcp.

• paramètre
  • objet serveur etcp
• Valeur de retour Aucune

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

Envoyez des messages aux clients via etcp.

• paramètre
  • objet serveur etcp
  • fd : fd correspondant, entier
  • buf : contenu du message, chaîne
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Renvoie avec succès le nombre d'octets envoyés avec succès > 0, entier

skt.api.etcp_server_get_conn(etcp, fd)

Obtenez une connexion à un serveur etcp.

• paramètre
  • objet serveur etcp
  • fd : fd correspondant, entier
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Renvoie avec succès l'objet conn

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

Fermez une connexion au serveur etcp.

• paramètre
  • objet serveur etcp
  • fd : fd correspondant, entier
  • Silencieux : s'il faut fermer silencieusement. S'il n'est pas fermé silencieusement, l'événement "on_close" sera déclenché. 1 signifie fermeture silencieuse, 0 signifie fermeture non silencieuse.
• Valeur de retour : Aucune

skt.api.etcp_client_init(conf, boucle)

Initialisez le client etcp.

• paramètre
  • conf : configuration de skcp
  • loop : objet de boucle d'événement
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Renvoie avec succès l'objet client etcp

skt.api.etcp_client_free(etcp)

Détruisez et libérez le client etcp.

• paramètre
  • objet client etcp
• Valeur de retour : Aucun

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

Envoyez des messages au serveur via etcp.

• paramètre
  • objet client etcp
  • fd : fd correspondant, entier
  • buf : contenu du message, chaîne
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Renvoie avec succès le nombre d'octets envoyés avec succès > 0, entier

skt.api.etcp_client_create_conn(etcp, adresse, port)

Créez une connexion etcp.

• paramètre
  • objet client etcp
  • addr : besoin de se connecter à l'adresse du serveur, chaîne
  • port : besoin de se connecter au port du serveur
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Renvoie avec succès le fd créé, type entier

skt.api.etcp_client_close_conn(etcp, fd)

Fermez une connexion client etcp.

• paramètre
  • objet client etcp
  • fd : fd correspondant, entier
• Valeur de retour : Aucun

skt.api.etcp_client_get_conn(etcp, fd)

Obtenez une connexion client etcp.

• paramètre
  • objet client etcp
  • fd : fd correspondant, entier
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Renvoie avec succès l'objet conn

skt.api.tuntap_write(fd, buf)

Écrivez les données sur la carte réseau virtuelle.

• paramètre
  • fd : fd de la carte réseau virtuelle, entier
  • buf : données à écrire, chaîne
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Nombre d'octets écrits avec succès, entier

skt.api.get_from_skcp(skcp, nom)

Obtenez la valeur du champ correspondant dans l'objet skcp, à savoir : "skcp.name".

• paramètre
  • objet skcp
  • name : nom du champ dans skcp, ne prend actuellement en charge que le champ "fd", chaîne
• valeur de retour
  • L'échec renvoie "nil, error_msg"
  • Renvoie avec succès la valeur correspondant au nom, n'importe quel

skt.api.get_ms()

Obtenez le nombre de millisecondes depuis 1970 pour le système actuel.

• Paramètres : Aucun
• Valeur de retour :
  • entier

skt.api.hton32(i)

Convertissez les variables entières 32 bits de l'ordre des octets de l'hôte en ordre des octets du réseau.

• paramètre
  • i : type entier dans l'ordre des octets de l'hôte
• valeur de retour
  • Renvoie un entier dans l'ordre des octets du réseau

skt.api.ntoh32(i)

Convertissez les variables entières 32 bits de l'ordre des octets du réseau en ordre des octets de l'hôte.

• paramètre
  • i : type entier dans l'ordre des octets du réseau
• valeur de retour
  • Renvoie un entier dans l'ordre des octets de l'hôte

skt.api.band(a, b)

Effectuer une opération ET logique au niveau du bit sur deux entiers et renvoyer le résultat

skt.api.bor(a, b)

Effectuer une opération OU logique au niveau du bit sur deux entiers et renvoyer le résultat

skt.api.bxor(a, b)

Effectuer une opération XOR au niveau du bit sur deux entiers et renvoyer le résultat

skt.api.blshift(i, n)

Décale l'entier vers la gauche de n bits et renvoie le résultat

skt.api.brshift(i, n)

Décale l'entier vers la droite de n bits et renvoie le résultat

skt.api.lookup_dns(domaine)

Résolution de nom de domaine

• paramètre
  • domain : nom de domaine à résoudre, chaîne
• valeur de retour
  • Renvoie l'IP correspondante au format pointé (IPV4), chaîne

L'interface de rappel que le script Lua doit implémenter

"skt.cb.*" doit implémenter différentes interfaces selon différents modes de démarrage pour le rappel skcptun.

skt.cb.on_init(boucle)

La première interface de rappel appelée au démarrage du script et n'est appelée qu'une seule fois

• Plage valide : tous les modes
• paramètre
  • loop : objet de boucle d'événement
• Valeur de retour : Aucune

skt.cb.on_skcp_accept(skcp, cid)

Le serveur skcp crée avec succès un cid et n'est appelé qu'une seule fois pour chaque connexion.

• Plage valide : "proxy_server", "tun_server"
• paramètre
  • objet skcp
  • cid : identifiant de connexion de skcp, entier
• Valeur de retour : Aucune

skt.cb.on_skcp_check_ticket(skcp, ticket)

Le serveur skcp vérifie si le ticket est correct.

• Plage valide : "proxy_server", "tun_server"
• paramètre
  • objet skcp
  • ticket : ticket qui doit être vérifié, chaîne
• Valeur de retour :
  • Renvoie 0 si la vérification est réussie
  • Si la vérification échoue, une valeur non nulle est renvoyée.

skt.cb.on_skcp_recv_cid(skcp, cid)

skcp reçoit un cid, indiquant qu'une connexion a été établie avec succès avec le serveur skcp. Autrement dit, la structure asynchrone de « skt.api.skcp_req_cid(skcp, ticket) » est renvoyée.

• Plage valide : "proxy_client", "tun_client"
• paramètre
  • objet skcp
  • cid : identifiant de connexion de skcp, entier
• Valeur de retour : Aucune

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

skcp reçoit les données correspondant à la connexion de cid.

• Plage valide : tous les modes
• paramètre
  • objet skcp
  • cid : identifiant de connexion de skcp, entier
  • buf : contenu du message reçu, chaîne
• Valeur de retour : Aucun

skt.cb.on_skcp_close(skcp, cid)

Le rappel lorsque skcp ferme une connexion peut généralement être provoqué par un délai d'attente ou par la réception d'une commande de fermeture de l'homologue. La connexion n'a pas été véritablement fermée à ce moment-là.

• Plage valide : tous les modes
• paramètre
  • objet skcp
  • cid : identifiant de connexion de skcp, entier
• Valeur de retour : Aucun

skt.cb.on_tcp_accept(fd)

Le serveur TCP reçoit une demande de connexion.

• Plage valide : "proxy_client", "tun_client"
• paramètre
  • fd : fd demandé par la connexion, entier
• Valeur de retour : Aucun

skt.cb.on_tcp_recv(fd, buf)

Recevez les données TCP correspondant à la connexion de fd.

• Plage valide : tous les modes
• paramètre
  • fd : fd de la connexion, entier
  • buf : contenu du message reçu, chaîne
• Valeur de retour : Aucun

skt.cb.on_tcp_close(fd)

Fermez la connexion TCP correspondant à fd. La connexion n'est pas vraiment fermée à ce moment.

• Plage valide : tous les modes
• paramètre
  • fd : fd de la connexion, entier
• Valeur de retour : Aucune

skt.cb.on_tun_read(buf)

Recevez des données de la carte réseau virtuelle.

• Plage valide : "tun_client", "tun_server"
• paramètre
  • buf : contenu du message reçu, chaîne
• Valeur de retour : Aucun

skt.cb.on_beat()

Déclenche un appel toutes les secondes.

• Plage valide : "proxy_client", "tun_client"
• Paramètres : Aucun
• Valeur de retour : Aucun

test

environnement

• Serveur : Linux/1C/1G
• Client : MacOS/8C/8G
• État du réseau, valeur 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

Données de processus (RTT)

• Nombre de connexions : 1 ; paquets de données : 1000 ; intervalle d'envoi : 100 ms

 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

• Nombre de connexions : 10 ; paquets de données : 1000 ; intervalle d'envoi : 100 ms

 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

en conclusion

• Dans le même environnement réseau, l'effet d'amélioration de la vitesse est d'environ 30 à 40 %.

Avis

• Je viens de terminer l'écriture, pour un usage personnel et les fonctions sont en cours de perfectionnement
• Assurez-vous de ne pas l'utiliser pour accélérer le cryptage du proxy sock5 ?