Options diverses

[General]
ipv6 = true
loglevel = notify

skip-proxy = 127.0.0.1, 192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12, 100.64.0.0/10, localhost, *.local

tun-excluded-routes = 192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12
tun-included-routes = 192.168.1.12/32

Options courantes

Activer la prise en charge complète d'IPv6 (par défaut : true)

ipv6 = true

loglevel (par défaut : warning)

loglevel = notify

L'une des valeurs none, fatal, warning, notify, info ou verbose. Il n'est pas recommandé d'activer verbose au quotidien, car cela dégrade nettement les performances.

skip-proxy

skip-proxy = 127.0.0.1, 192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12, 100.64.0.0/10, localhost, *.local

Sur la version iOS, cette option force les connexions vers ces domaines/plages d'IP à être traitées par le TUN de Chute, plutôt que par le proxy de Chute. Sur la version macOS, ces réglages sont appliqués au système lorsque « Définir comme proxy système » est activé. Cette option sert à corriger des problèmes de compatibilité avec certaines apps.

• Pour indiquer un seul domaine, saisissez le nom de domaine — par exemple, apple.com.
• Pour indiquer tous les sites d'un domaine, placez un astérisque devant le nom de domaine — par exemple, *apple.com.
• Pour indiquer une partie précise d'un domaine, précisez chaque partie — par exemple, store.apple.com.
• Pour indiquer des hôtes ou des réseaux par adresse IP, saisissez une adresse IP précise telle que 192.168.2.11 ou une plage d'adresses, telle que 192.168.2.* ou 192.168.2.0/24.

Remarque : si vous saisissez une adresse IP ou une plage d'adresses, vous ne pourrez contourner le proxy que lorsque vous vous connecterez à cet hôte par cette adresse, et non lorsque vous vous y connecterez par un nom de domaine qui résout vers cette adresse.

Écoute du serveur proxy

interface = 127.0.0.1
port = 8118
socks-interface = 127.0.0.1
socks-port = 8119

interface / port contrôlent l'adresse et le port d'écoute du serveur proxy HTTP (par défaut 127.0.0.1:8118). socks-interface / socks-port contrôlent le serveur proxy SOCKS5 (par défaut 127.0.0.1:8119).

Alias de compatibilité : doh-server est accepté comme alias de doh ; http-listen / socks5-listen (par ex. 0.0.0.0:6152, [::]:6153, ou un simple port) sont associés aux réglages d'interface/port ci-dessus. Un hôte d'écoute joker (0.0.0.0, :: ou *) définit également allow-wifi-access = true.

Authentification du proxy entrant

http-auth = username:password

Exige des clients qu'ils s'authentifient avant d'utiliser les serveurs proxy HTTP et SOCKS5 de Chute. La ligne peut être répétée pour autoriser plusieurs jeux d'identifiants.

Contourner les requêtes système

bypass-system = true

Lorsque cette option est activée, les requêtes émises par les processus système contournent le traitement de Chute.

Par défaut : true.

Toujours IP réelle

always-real-ip = *.example.com, tracker.example.org

Lorsque Chute fournit de fausses adresses IP pour les requêtes DNS détournées (voir hijack-dns), les noms d'hôte correspondant à cette liste séparée par des virgules reçoivent en réponse leurs véritables adresses IP résolues. Les jokers sont pris en charge.

Interrompre les connexions existantes

interrupt-exist-connections = true

Lorsque cette option est activée, changer la politique sélectionnée dans un groupe de politiques (via URL Test, Fallback, Load Balance, SSID ou sélection manuelle) ferme proprement les connexions existantes qui utilisaient l'ancienne politique. Cela garantit que les connexions utilisent immédiatement le proxy nouvellement sélectionné plutôt que de s'attarder sur l'ancien.

Chaque connexion concernée est fermée proprement avec un délai de 3 secondes avant une fermeture forcée.

Par défaut : false. Il s'agit d'un réglage global — il affecte tous les groupes de politiques.

Network Framework (macOS / tvOS)

network-framework = true

Active Network.framework d'Apple pour les connexions sortantes. Network.framework peut offrir de meilleures performances et une intégration moderne de la pile TLS sur les plateformes prises en charge.

Par défaut : true sur macOS, false sur iOS et tvOS.

Exclure les noms d'hôte simples

exclude-simple-hostnames = true

Lorsque cette option est activée, les requêtes vers des noms d'hôte simples (noms à étiquette unique sans point, par ex. localhost) contournent les règles de proxy et sont résolues localement. Cela évite des résolutions DNS inutiles pour les noms du réseau local.

Sur Chute Mac, une migration ponctuelle active cette option par défaut au premier lancement ; un réglage explicitement désactivé par l'utilisateur est respecté.

Par défaut : false.

Désactiver l'enregistrement en base de données

disable-db-record = true

Lorsque cette option est activée, Chute cesse d'écrire les enregistrements de trafic dans la base de données locale. Cela peut améliorer les performances et réduire l'usage du stockage, mais l'historique de trafic ne sera pas disponible dans Chute Dashboard.

Par défaut : false.

Affichage de la vitesse dans la barre des menus (Mac uniquement)

menu-bar-show-speed = true

Lorsque cette option est activée, Chute Mac affiche les vitesses d'envoi et de réception actuelles dans la barre des menus.

Par défaut : false.

Détourner les autres serveurs DNS

hijack-dns = 8.8.8.8:53

Par défaut, Chute ne renvoie de fausses adresses IP que pour les requêtes DNS envoyées à l'adresse DNS de Chute (198.18.0.2). Les requêtes envoyées à un DNS standard sont simplement transmises.

Certains appareils ou logiciels utilisent toujours un serveur DNS codé en dur. (Par exemple, les enceintes Google utilisent toujours 8.8.8.8). Vous pouvez utiliser cette option pour détourner la requête et obtenir une fausse adresse.

Vous pouvez utiliser hijack-dns = *:53 pour détourner toutes les requêtes DNS.

Routes exclues

tun-excluded-routes = 192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12

Chute VIF ne peut traiter que les protocoles TCP et UDP. Utilisez cette option pour contourner des plages d'IP précises afin de laisser passer tout le trafic.

Remarque : cette option ne fonctionne que pour le type VIF (utun) du mode amélioré — elle n'a aucun effet avec le type VPN PacketTunnel. Les requêtes traitées par le serveur proxy de Chute ne sont pas concernées. Combinez « skip-proxy » et « tun-excluded-routes » pour vous assurer que certain trafic HTTP contourne bien Chute.

Cette option peut provoquer une erreur système ENOMEM (Cannot allocate memory). Il semble s'agir d'un bug du système iOS. Évitez si possible d'utiliser cette option.

Routes incluses

tun-included-routes = 192.168.1.12/32

Par défaut, l'interface Chute VIF se déclare comme route par défaut. Mais comme l'interface Wi-Fi possède une route plus spécifique, une partie du trafic peut ne pas passer par l'interface Chute VIF. Utilisez cette option pour ajouter une route plus spécifique.

Remarque : cette option ne fonctionne que pour le type VIF (utun) du mode amélioré — elle n'a aucun effet avec le type VPN PacketTunnel.

Détection de protocole

sniffing-enabled = true
sniffing-timeout = 100

Chute peut détecter le protocole réel d'une connexion en inspectant les premiers octets. Cela permet à des règles comme PROTOCOL,TLS,Proxy de fonctionner correctement même pour des connexions entrantes non HTTP.

sniffing-enabled (par défaut : false)

sniffing-enabled = true

Active la détection de protocole pour les connexions TCP.

sniffing-timeout (par défaut : 100 ms)

sniffing-timeout = 200

Temps maximal, en millisecondes, d'attente des données initiales pour déterminer le protocole. Augmentez cette valeur si la détection de protocole échoue sur des connexions lentes.

Bloquer QUIC

block-quic = auto

Contrôle si Chute rejette le trafic QUIC détecté, y compris HTTP/3. QUIC fonctionne sur UDP et ne peut pas être déchiffré par le MitM HTTP de Chute. Rejeter QUIC peut inciter les clients compatibles à réessayer en TCP, ce qui permet un traitement par proxy sur TCP et, si elle est configurée, l'application du déchiffrement HTTPS.

Pour le trafic entrant par le TUN, Chute répond à un flux QUIC rejeté par un message ICMP/ICMPv6 Port Unreachable, afin que les clients compatibles puissent se rabattre sans attendre l'expiration d'un délai QUIC.

La détection QUIC pour block-quic est automatique et ne nécessite pas sniffing-enabled ; sniffing-enabled contrôle la détection de protocole TCP. Utilisez une règle PROTOCOL,QUIC,... lorsque vous avez besoin d'un traitement par règles de flux QUIC individuels.

Contourner le TUN

bypass-tun = 192.168.0.0/16, 10.0.0.0/8

Similaire à skip-proxy, mais opère au niveau du routage TUN/VIF. Les connexions vers ces plages d'IP contournent entièrement l'interface TUN et passent directement par la pile réseau du système.

Remarque : cette option ne fonctionne que pour le type VIF (utun) du mode amélioré. Elle n'a aucun effet avec le type VPN PacketTunnel.

Afficher une page d'erreur en cas de rejet

show-error-page-for-reject = true

Lorsque cette option est activée, Chute renvoie une page d'erreur lisible pour les requêtes rejetées, au lieu de simplement abandonner la connexion.

DNS optimiste

optimistic-dns = false

Lorsque cette option est activée, Chute renvoie immédiatement le résultat DNS en cache tout en actualisant l'enregistrement en arrière-plan. Cela réduit la latence de connexion, au prix d'un éventuel renvoi d'enregistrements DNS obsolètes.

Par défaut : true. Définissez optimistic-dns = false pour désactiver.

Autoriser l'accès Wi-Fi

allow-wifi-access = true

Permet aux autres appareils du même réseau d'atteindre les ports proxy HTTP et SOCKS5 de Chute, en élargissant l'adresse d'écoute des deux services à 0.0.0.0. Les configurations de style Surge — ainsi que la correspondance allow-lan de l'importateur sing-box — ne portent que ce drapeau et laissent interface à sa valeur par défaut 127.0.0.1 ; c'est pourquoi le drapeau doit élargir lui-même l'adresse d'écoute.

Le drapeau et un interface générique explicite sont deux écritures de la même intention, et Chute en prend l'union : une configuration qui écrit déjà 0.0.0.0 se comporte exactement comme avant. Modifier le drapeau relie les deux écouteurs, donc retirer l'accès prend effet au rechargement plutôt qu'au prochain démarrage.

Ce sont les ports du proxy, et ils n'ont aucune authentification tant que http-auth n'est pas défini. Sur un réseau que vous ne contrôlez pas, définissez aussi des identifiants.

Configuration gérée

#!MANAGED-CONFIG https://example.com/config.conf interval=86400 strict=false

Une configuration dont la première ligne est un en-tête #!MANAGED-CONFIG est retéléchargée automatiquement depuis l'URL. Les paramètres de cet en-tête et le comportement de mise à jour sont documentés dans Configuration gérée.

Replica / enregistrement du trafic

replica = true

La clé replica de [General] (replica = true) active l'enregistrement du trafic ; la section [Replica] filtre ce que Chute Dashboard affiche — ses clés sont documentées dans Réplique.

Accès au contrôleur externe (Chute Dashboard)

external-controller-access = password@0.0.0.0:6155

Démarre le serveur de contrôle distant utilisé par Chute Dashboard. La valeur s'écrit password@host:port ; un nom d'utilisateur peut éventuellement précéder le mot de passe (user:password@host:port). Sur iOS, un canal USB complémentaire est ouvert sur port + 1 (pas sur macOS). La connexion est décrite sur la page Chute Dashboard.

API de contrôle HTTP et interface web

[General]
external-http-controller = 127.0.0.1:9090
external-http-secret = your-secret-token
external-http-ui = true
external-http-cors = false

Chute fournit une API de contrôle HTTP intégrée et une interface de gestion web, comparables aux tableaux de bord de Clash et de Surge. L'API expose l'état du noyau, le trafic, les connexions, le DNS, les contrôles de politique et la gestion de configuration via des points de terminaison REST.

external-http-controller (par défaut : désactivé)

external-http-controller = 127.0.0.1:9090

Adresse et port du serveur de contrôle HTTP. Utilisez 127.0.0.1 pour un accès purement local. Se lier à une adresse non locale (par exemple 192.168.1.5:9090) exige un external-http-secret explicite : sans lui, le serveur refuse de démarrer et journalise ce qui manque.

Une adresse générique (0.0.0.0, ::, *) compte comme non locale pour cette vérification, car elle écoute sur toutes les interfaces — l'inverse d'un accès local. Les graphies acceptées sont 0.0.0.0:9090, *:9090 (la même chose) et, pour IPv6, [::]:9090 — un :::9090 nu reçoit ses crochets automatiquement ; une adresse impossible à analyser est signalée comme erreur de configuration au lieu de laisser silencieusement le contrôleur éteint. L'ensemble de 127.0.0.0/8 compte comme boucle locale, pas seulement 127.0.0.1.

external-http-secret (par défaut : un jeton généré)

external-http-secret = your-secret-token

Le jeton Bearer utilisé pour l'authentification de l'API. Les requêtes doivent contenir l'en-tête Authorization: Bearer <secret> — le jeton n'est accepté que dans cet en-tête, jamais en paramètre d'URL, et la comparaison se fait en temps constant. Un échec d'authentification renvoie 401 avec {"ok": false, "error": {"code": "unauthorized", "message": "missing or invalid token"}}. Seuls les chemins /api/* et les alias compatibles Clash sont protégés ; les fichiers statiques de l'interface web n'ont pas besoin de jeton (avec external-http-ui = false ils disparaissent tout à fait — la page renvoie 404).

Lorsque la clé est absente, Chute génère un jeton au lieu de servir sans authentification. Le jeton généré est écrit dans un fichier control-token du dossier de partage de Chute — pas à côté de la configuration : le conteneur du groupe d'apps sur iOS et tvOS, le répertoire de données privé de l'app sur Android —, lisible par son seul propriétaire, réutilisé d'un redémarrage à l'autre, et les applications vous le montrent — voir Ouvrir la console web. L'API de contrôle peut livrer la base des connexions, dont les enregistrements portent chaque URL, chaque en-tête et chaque nom de processus vus pendant l'exécution ; une console ouverte n'est pas une valeur par défaut raisonnable.

Si vous voulez malgré tout servir sans authentification, dites-le explicitement dans la configuration :

external-http-secret = none

Cela n'est accepté que pour une liaison en boucle locale. Hors boucle locale, ni none ni l'absence de clé ne suffisent : le serveur de contrôle refuse de démarrer et indique ce qu'il attend.

Mise à niveau : si vous comptiez sur l'absence de external-http-secret pour dire « pas d'authentification », vos scripts locaux commenceront à recevoir 401. Lisez le jeton généré dans l'application, ou écrivez external-http-secret = none pour conserver délibérément l'ancien comportement.

external-http-ui (par défaut : true)

external-http-ui = true

Lorsque cette option est activée, Chute sert une interface web intégrée à l'adresse du contrôleur. Cette interface propose un tableau de bord de vue d'ensemble, la gestion des connexions, l'inspection DNS, la surveillance du trafic, les contrôles de politique et l'édition de configuration. Définissez false pour conserver l'API activée tout en désactivant l'interface.

Ouvrir la console web

La console est servie à l'adresse du serveur de contrôle, et chaque application peut vous donner l'adresse et le jeton — y compris celui qui est généré, que vous n'auriez sinon aucun moyen de lire :

• Chute Mac : barre des menus → Ouvrir la console web, et Copier le jeton de la console web. La fenêtre de détail d'une connexion propose aussi Requêtes et historique, qui ouvre la console — sa page d'accueil, pas cette connexion.
• Chute iOS : panneau de contrôle → ligne Web UI → Ouvrir, Copier l'adresse ou Copier le jeton d'accès.
• Chute tvOS : le panneau de contrôle a une ligne distincte Adresse de l'interface web sous l'interrupteur Web UI, qui affiche l'hôte et le port. La sélectionner montre un QR code lorsque l'écouteur est joignable depuis d'autres appareils — le jeton de connexion voyage dans le code, pas à l'écran — et, lorsque le contrôleur est lié à la boucle locale, une explication à la place, car une console en boucle locale ne peut pas s'ouvrir depuis un téléphone.
• Chute Android : le panneau de contrôle affiche l'adresse en sous-titre de l'interrupteur API HTTP, et une ligne Jeton d'accès généré qui copie d'un appui — cette ligne n'apparaît que lorsque le noyau a généré le jeton ; un secret que vous avez configuré vous-même n'est jamais affiché.

L'adresse ainsi produite porte le jeton en paramètre d'URL. La page le consomme au chargement et le retire de la barre d'adresse, si bien qu'ouvrir le lien constitue une connexion complète et que personne n'a à recopier 32 caractères hexadécimaux.

external-http-cors (par défaut : false)

external-http-cors = true

Active les en-têtes CORS (partage de ressources entre origines) sur les réponses de l'API. Utile lorsque l'interface web ou des outils tiers doivent accéder à l'API depuis une autre origine.

Points de terminaison de l'API :

Notes sur les points de terminaison :

• GET /api/connections accepte limit (entier positif, valeur par défaut et maximale 1000) et cursor (ne renvoie que les connexions dont l'id est supérieur au curseur). Le data de la réponse contient connections, total, page_size, has_more et — lorsque d'autres pages existent — next_cursor.
• GET /api/connections/history accepte limit (par défaut 100, maximum 1000) et cursor/before (synonymes ; les passer tous les deux est rejeté).
• GET /api/connections/:id/request et .../response renvoient {"connection_id": <id>, "data": "<base64>"}. Les captures supérieures à 2 Mio renvoient 413.
• GET /api/config renvoie la configuration avec les valeurs sensibles (http-auth, external-http-secret, ca-p12, ca-passphrase, clés WireGuard et similaires) remplacées par <redacted> — ne réinjectez pas le résultat tel quel dans PUT /api/config, sinon les espaces réservés seraient écrits littéralement dans la configuration.
• PUT /api/config accepte soit du JSON {"configuration": "<full text>"}, soit le texte brut de configuration comme corps de requête (limite de 1 Mo). En cas de succès, le noyau se recharge — ou démarre, s'il ne tournait pas.
• PUT /api/policies/:group prend la sélection dans la première des clés de corps policy, name, selected, select ; la valeur peut être un nom de politique ou un index numérique sous forme de chaîne. Le nom de groupe spécial GLOBAL définit la politique globale sélectionnée.
• PUT /api/mode exige un nombre JSON : {"mode": 0} — 0 règles, 1 direct, 2 proxy.
• PUT /api/features/mitm et PUT /api/features/record-traffic prennent {"enabled": true}.
• GET /api/logs accepte since (secondes Unix) ; le tampon en mémoire conserve les 1000 entrées les plus récentes, chacune sous la forme {timestamp, level, section, message}.
• GET /api/health indique ce que le moteur retient et pourquoi il a refusé quelque chose en dernier, ainsi que la façon dont l'exécution précédente s'est terminée (clean, unclean ou suspected_memory — voir Dépannage).
• GET /api/events sert l'anneau en mémoire ; ?persisted=1 lit à la place l'historique enregistré de cette exécution et répond available: false si l'enregistrement est désactivé.
• Sans section [Tailscale], GET /api/tailscale répond state: "idle" — c'est une réponse normale, pas une erreur.
• Les sondes POST /api/diagnostics/* prennent leurs arguments dans la chaîne de requête ou dans un corps JSON, sont limitées à dix secondes et répondent exactement une fois. url-test/:policy rejette un nom de politique inexistant plutôt que de mesurer REJECT.
• POST /api/rules/match répond à la question où irait une requête, sans ouvrir de connexion. Il accepte host (ou une url dont il tire l'hôte et le port), port (443 par défaut), et en option ip, protocol, process, process_path, src_ip, src_port, in_port, in_type, in_user, in_name, network, ssid, bssid, from_tun, user_agent — un champ inconnu est refusé avec la liste des champs acceptés, plutôt qu'ignoré. La réponse porte la règle matched (sa ligne, son type, la politique qu'elle nomme et la resolved_policy vers laquelle un groupe pointe actuellement), la policy, need_resolve, ainsi que les rule_count et match_generation sur lesquels le calcul a été fait. Comme un domaine est mis en correspondance deux fois — une fois sur le nom, une seconde fois une fois l'adresse connue —, passes contient une entrée par passe ; sans ip, seule la passe avant résolution existe, et la réponse le dit dans note. Ajoutez explain=true pour obtenir les règles candidates qui auraient pu correspondre aussi, jusqu'à 50, avec le nombre de jeux de règles non dépliés.
• POST /api/config/validate analyse une configuration puis la jette : le noyau en cours n'en adopte rien. Envoyez-la sous la forme {"configuration": "<full text>"} ou en texte brut. La réponse comprend valid, error_count, advisory_count, rule_count, policy_count et une liste errors de {line, severity, content, error} — severity distingue une ligne refusée d'une ligne acceptée avec réserve, et content est la ligne fautive, expurgée, car une mauvaise ligne [Proxy] porte le plus souvent le mot de passe qui l'a rendue mauvaise. Servez-vous-en avant PUT /api/config, qui redémarre l'exécution que vous êtes en train de déboguer.
• GET /api/loglevel indique le level courant, le nslog_level, les sections écrites dans le fichier, et les available_levels / available_sections que vous pouvez définir. PUT (ou PATCH) accepte level, sections, ou les deux : sections est un tableau de noms de sections ou la chaîne "all", et un tableau vide est refusé — pour arrêter la journalisation, utilisez level avec none. Changer le niveau ainsi ne redémarre pas l'exécution, et c'est bien l'intérêt : loglevel = verbose dans le fichier exige un rechargement, et un rechargement perd précisément ce que vous cherchiez à voir.
• GET /api/rules renvoie aussi rewrite_hits : chaque règle de réécriture ou de Mock qui a agi pendant cette exécution, avec son compteur. Une règle absente de cette liste n'a jamais correspondu — c'est l'explication habituelle d'une réécriture qui semble ne rien faire. Le tableau suit jusqu'à 512 règles distinctes et signale tout ce qui dépasse dans rewrite_hit_dropped_rules.
• POST /api/rewrites/:family prend {"rule": "<configuration line>"} — exactement le texte que vous écririez dans le fichier. Une ligne qui ne s'analyse pas est refusée avec 400 au lieu d'être stockée comme une règle qui ne pourra jamais correspondre. :family vaut url-rewrite, header-rewrite, body-rewrite ou mock. Les règles ajoutées ainsi vivent dans le noyau en cours d'exécution et ne sont pas réécrites dans le fichier de configuration.
• GET /api/connections/export?format=har renvoie un document HAR 1.2 et POST /api/diagnostics/bundle un zip — ce sont des fichiers, donc contrairement à tous les autres points d'accès ils ne sont pas enveloppés dans {"ok": ..., "data": ...}. export accepte source (current par défaut, ou history), limit (100 par défaut, 300 au maximum), ids, et bodies=1 pour inclure les charges utiles capturées. Chaque entrée porte un objet _kl avec ce dont HAR n'a pas de champ : la politique choisie, la règle correspondante et les réécritures qui ont agi.

Exemple — lire l'état, puis changer un groupe de politiques :

curl -H "Authorization: Bearer your-secret-token" http://127.0.0.1:9090/api/status
{"ok":true,"data":{"running":true,"outbound_mode":0,"mitm":false, ...}}

curl -X PUT -H "Authorization: Bearer your-secret-token" \
     -d '{"policy": "ProxyB"}' http://127.0.0.1:9090/api/policies/MainGroup
{"ok":true,"data":{"outbound_mode":0,"selectable_groups":[...], ...}}

Exemple — demander où irait une requête, avant de l'émettre :

curl -X POST -H "Authorization: Bearer your-secret-token" \
     -d '{"url": "https://api.example.com/v1/orders", "explain": true}' \
     http://127.0.0.1:9090/api/rules/match
{"ok":true,"data":{"policy":"MainGroup","matched":{"rule":"DOMAIN-SUFFIX,example.com,MainGroup", ...}, ...}}

Restreindre le journal à un sous-système pendant la reproduction, sans redémarrer l'exécution :

curl -X PUT -H "Authorization: Bearer your-secret-token" \
     -d '{"level": "verbose", "sections": ["MitM", "DNS"]}' \
     http://127.0.0.1:9090/api/loglevel

Remarque : cette fonctionnalité est désactivée par défaut. Chaque réponse utilise l'enveloppe {"ok": true, "data": {...}} en cas de succès et {"ok": false, "error": {"code": "...", "message": "..."}} en cas d'erreur ; les corps de requête sont limités à 1 Mo.

Les points de terminaison PUT acceptent également PATCH. Des chemins d'alias compatibles Clash sont disponibles pour les tableaux de bord tiers : /version, /traffic, /connections, /configs, /proxies, /rules — ces chemins sont accessibles, mais les réponses utilisent l'enveloppe et les noms de champ de Chute plutôt que le schéma de Clash (/version ne renvoie que {"name", "run_id"}) ; les tableaux de bord Clash ne fonctionneront donc pas immédiatement.

Empreinte du client

global-client-fingerprint = chrome

Définit l'empreinte du client TLS pour toute politique qui n'a pas la sienne (fingerprint). La valeur propre à une politique l'emporte toujours ; il s'agit donc d'une valeur par défaut, et non d'un remplacement.

Les valeurs prises en charge sont chrome, firefox, safari et ios, ainsi que edge, 360, qq, android et random, toutes traitées comme Chrome. Une valeur non reconnue est ignorée et la pile TLS de la plateforme est utilisée.

Par défaut : vide, ce qui signifie la pile TLS de la plateforme. Seules les politiques Trojan, VMess, VLESS et ShadowTLS la lisent.