Chisel

Chisel est un tunnel TCP/UDP rapide, transporté via HTTP, sécurisé via SSH. Un seul exécutable incluant à la fois le client et le serveur. Écrit en Go (golang). Chisel est principalement utile pour traverser les pare-feu, mais il peut également être utilisé pour fournir un point de terminaison sécurisé vers votre réseau.

Table des matières

• Fonctionnalités
• Installation
• Démo
• Utilisation
• Contribution
• Journal des modifications
• Licence

Fonctionnalités

• Facile à utiliser
• Performant*
• Connexions chiffrées utilisant le protocole SSH (via crypto/ssh)
• Connexions authentifiées ; connexions client authentifiées avec un fichier de configuration utilisateurs, connexions serveur authentifiées avec correspondance d'empreintes.
• Le client se reconnecte automatiquement avec backoff exponentiel (réglable via --min/max-retry-interval) ; les pings keepalive expirent, donc les connexions silencieusement mortes (veille/réveil, expirations NAT, redémarrages du serveur) sont détectées et rétablies
• Les clients peuvent créer plusieurs points de terminaison de tunnel sur une seule connexion TCP
• Les clients peuvent éventuellement passer par des proxys SOCKS ou HTTP CONNECT
• Redirection de port inversée (les connexions passent par le serveur et sortent par le client)
• Le serveur peut éventuellement servir de proxy inverse
• Le serveur permet éventuellement les connexions SOCKS5 (Voir le guide ci-dessous)
• Les clients permettent éventuellement les connexions SOCKS5 depuis un port redirigé inversé
• Connexions client via stdio qui prennent en charge ssh -o ProxyCommand fournissant SSH sur HTTP

Installation

Binaires

Voir la dernière version ou téléchargez-la et installez-la maintenant avec curl https://i.jpillora.com/chisel! | bash

Les binaires sont compilés avec la dernière version de Go, qui définit les versions minimales du système d'exploitation : Windows 10 / Server 2016, macOS 12, noyau Linux 3.2, FreeBSD 12.2. Pour les systèmes plus anciens (par exemple Windows 7), utilisez la version v1.8.1 ou antérieure.

Docker

```sh docker run --rm -it jpillora/chisel --help

Les images sont multi-architectures et publiées à la fois sur Docker Hub (`jpillora/chisel`) et sur le registre de conteneurs GitHub (`ghcr.io/jpillora/chisel`).

### Fedora

Le paquet est maintenu par la communauté Fedora. Si vous rencontrez des problèmes liés à l'utilisation du RPM, veuillez utiliser ce [suivi de problèmes](https://bugzilla.redhat.com/buglist.cgi?bug_status=NEW&bug_status=ASSIGNED&classification=Fedora&component=chisel&list_id=11614537&product=Fedora&product=Fedora%20EPEL).```sh
sudo dnf -y install chisel

Source

Source```sh

$ go install github.com/jpillora/chisel@latest

## Démo

Vous pouvez lancer votre propre serveur de démonstration en quelques minutes (l'ancienne démo Heroku a disparu avec le niveau gratuit de Heroku). [`example/fly.toml`](https://github.com/jpillora/chisel/blob/HEAD/example/fly.toml) déploie ce `chisel server` sur l'allocation gratuite de [fly.io](https://fly.io) :```sh
$ chisel server --port $PORT --backend http://example.com
# listens on $PORT, proxies normal web requests to http://example.com

Déployez-le avec fly launch --copy-config depuis le répertoire example/, puis créez un tunnel vers n'importe quel service exécuté à côté du serveur, par exemple :```sh $ chisel client https://.fly.dev 3000

connects to your chisel server,

tunnels your localhost:3000 to the server's localhost:3000

Visiter l'URL de votre application dans un navigateur atteint le proxy backend par défaut du serveur et affiche une copie de [example.com](http://example.com).

## Utilisation

<!-- render these help texts by hand,
  or use https://github.com/jpillora/md-tmpl
    with $ md-tmpl -w README.md -->

<!--tmpl,code=plain:echo "$ chisel --help" && go run main.go --help | sed 's#0.0.0-src (go1\..*)#X.Y.Z#' -->``` plain 
$ chisel --help

  Usage: chisel [command] [--help]

  Version: X.Y.Z

  Commands:
    server - runs chisel in server mode
    client - runs chisel in client mode

  Read more:
    https://github.com/jpillora/chisel

$ chisel server --help

Usage: chisel server [options]

Options:

--host, Defines the HTTP listening host – the network interface
(defaults the environment variable HOST and falls back to 0.0.0.0).

--port, -p, Defines the HTTP listening port (defaults to the environment
variable PORT and falls back to port 8080).

--key, (deprecated use --keygen and --keyfile instead)
An optional string to seed the generation of a ECDSA public
and private key pair. All communications will be secured using this
key pair. Share the subsequent fingerprint with clients to enable detection
of man-in-the-middle attacks (defaults to the CHISEL_KEY environment
variable, otherwise a new key is generate each run).

--keygen, A path to write a newly generated PEM-encoded SSH private key file.
If users depend on your --key fingerprint, you may also include your --key to
output your existing key. Use - (dash) to output the generated key to stdout.

--keyfile, An optional path to a PEM-encoded SSH private key. When
this flag is set, the --key option is ignored, and the provided private key
is used to secure all communications. (defaults to the CHISEL_KEY_FILE
environment variable). Since ECDSA keys are short, you may also set keyfile
to the inline key string itself, exactly as printed by --keygen (a base64
string with a "ck-" prefix); no extra base64 encoding is needed.

--authfile, An optional path to a users.json file. This file should
be an object with users defined like:
  {
    "<user:pass>": ["<addr-regex>","<addr-regex>"]
  }
when <user> connects, their <pass> will be verified and then
each of the remote addresses will be compared against the list
of address regular expressions for a match. Patterns are NOT
anchored by default: "10.0.0.1:80" also matches
"210.0.0.1:8080", and "." matches any character. Anchor your
patterns, e.g. "^10\.0\.0\.1:80$". The empty string ""
matches every address. Addresses will
always come in the form "<remote-host>:<remote-port>" for normal remotes,
"R:<local-interface>:<local-port>" for reverse port forwarding
remotes, and "socks" for SOCKS5 proxy access. Note that SOCKS5
access previously bypassed this list; existing authfiles which
should allow SOCKS5 must add an entry matching "socks" (the
empty wildcard "" matches everything, including "socks"). This
file will be automatically reloaded on change. Reloads apply
to new connections and to new tunnels of connected clients;
established tunnels are not interrupted.

--auth, An optional string representing a single user with full
access, in the form of <user:pass>. It is equivalent to creating an
authfile with {"<user:pass>": [""]}. If unset, it will use the
environment variable AUTH.

--keepalive, An optional keepalive interval. Since the underlying
transport is HTTP, in many instances we'll be traversing through
proxies, often these proxies will close idle connections. You must
specify a time with a unit, for example '5s' or '2m'. Defaults
to '25s' (set to 0s to disable).

--backend, Specifies another HTTP server to proxy requests to when
chisel receives a normal HTTP request. Useful for hiding chisel in
plain sight. --proxy is accepted as an alias for this flag.

--socks5, Allow clients to access the internal SOCKS5 proxy. See
chisel client --help for more information.

--reverse, Allow clients to specify reverse port forwarding remotes
in addition to normal remotes.

--tls-key, Enables TLS and provides optional path to a PEM-encoded
TLS private key. When this flag is set, you must also set --tls-cert,
and you cannot set --tls-domain.

--tls-cert, Enables TLS and provides optional path to a PEM-encoded
TLS certificate. When this flag is set, you must also set --tls-key,
and you cannot set --tls-domain.

--tls-domain, Enables TLS and automatically acquires a TLS key and
certificate using LetsEncrypt. Setting --tls-domain requires port 443.
You may specify multiple --tls-domain flags to serve multiple domains.
The resulting files are cached in the "$HOME/.cache/chisel" directory.
You can modify this path by setting the CHISEL_LE_CACHE variable,
or disable caching by setting this variable to "-". You can optionally
provide a certificate notification email by setting CHISEL_LE_EMAIL.

--tls-ca, a path to a PEM encoded CA certificate bundle or a directory
holding multiple PEM encode CA certificate bundle files, which is used to 
validate client connections. The provided CA certificates will be used 
instead of the system roots. This is commonly used to implement mutual-TLS. 

--pid Generate pid file in current working directory

-v, Enable verbose logging

--help, This help text

Signals: The chisel process is listening for: a SIGINT or SIGTERM to begin a graceful shutdown (a second signal forces an immediate exit), a SIGUSR2 to print process stats, and a SIGHUP to short-circuit the client reconnect timer

Version: X.Y.Z

Read more: https://github.com/jpillora/chisel

<!--/tmpl-->


<!--tmpl,code=plain:echo "$ chisel client --help" && go run main.go client --help | sed 's#0.0.0-src (go1\..*)#X.Y.Z#' -->``` plain 
$ chisel client --help

  Usage: chisel client [options] <server> <remote> [remote] [remote] ...

  <server> is the URL to the chisel server.

  <remote>s are remote connections tunneled through the server, each of
  which come in the form:

    <local-host>:<local-port>:<remote-host>:<remote-port>/<protocol>

    ■ local-host defaults to 0.0.0.0 (all interfaces).
    ■ local-port defaults to remote-port.
    ■ remote-port is required*.
    ■ remote-host defaults to 127.0.0.1 (server localhost).
    ■ protocol defaults to tcp.

  which shares <remote-host>:<remote-port> from the server to the client
  as <local-host>:<local-port>, or:

    R:<local-interface>:<local-port>:<remote-host>:<remote-port>/<protocol>

  which does reverse port forwarding, sharing <remote-host>:<remote-port>
  from the client to the server's <local-interface>:<local-port>.

    example remotes

      3000
      example.com:3000
      3000:google.com:80
      192.168.0.5:3000:google.com:80
      socks
      5000:socks
      R:2222:localhost:22
      R:socks
      R:5000:socks
      stdio:example.com:22
      1.1.1.1:53/udp

    When the chisel server has --socks5 enabled, remotes can
    specify "socks" in place of remote-host and remote-port.
    The default local host and port for a "socks" remote is
    127.0.0.1:1080. Connections to this remote will terminate
    at the server's internal SOCKS5 proxy. When the server also
    has --authfile set, SOCKS5 access requires an entry matching
    the token "socks" in the user's address list.

    When the chisel server has --reverse enabled, remotes can
    be prefixed with R to denote that they are reversed. That
    is, the server will listen and accept connections, and they
    will be proxied through the client which specified the remote.
    Reverse remotes specifying "R:socks" will listen on the server's
    default socks port (1080) and terminate the connection at the
    client's internal SOCKS5 proxy.

    When stdio is used as local-host, the tunnel will connect standard
    input/output of this program with the remote. This is useful when 
    combined with ssh ProxyCommand. You can use
      ssh -o ProxyCommand='chisel client chiselserver stdio:%h:%p' \
          [email protected]
    to connect to an SSH server through the tunnel.

  Options:

    --fingerprint, A *strongly recommended* fingerprint string
    to perform host-key validation against the server's public key.
    Fingerprint mismatches will close the connection.
    Fingerprints are generated by hashing the ECDSA public key using
    SHA256 and encoding the result in base64.
    Fingerprints must be 44 characters containing a trailing equals (=).
    Legacy MD5 colon fingerprints (deprecated) are still accepted,
    but only in their full 16-octet form; truncated prefixes are
    rejected.

    --auth, An optional username and password (client authentication)
    in the form: "<user>:<pass>". These credentials are compared to
    the credentials inside the server's --authfile. defaults to the
    AUTH environment variable.

    --keepalive, An optional keepalive interval. Since the underlying
    transport is HTTP, in many instances we'll be traversing through
    proxies, often these proxies will close idle connections. You must
    specify a time with a unit, for example '5s' or '2m'. Defaults
    to '25s' (set to 0s to disable).

    --max-retry-count, Maximum number of times to retry before exiting.
    Defaults to unlimited.

    --min-retry-interval, Minimum wait time before retrying after a
    disconnection. Defaults to 1 second.

    --max-retry-interval, Maximum wait time before retrying after a
    disconnection. Defaults to 5 minutes.

    --proxy, An optional HTTP CONNECT or SOCKS5 proxy which will be
    used to reach the chisel server. Authentication can be specified
    inside the URL. Credentials must be URL-encoded; for example a
    "#" in the password must be written as "%23".
    For example, http://admin:[email protected]:8081
            or: socks://admin:[email protected]:1080
    The socks://, socks5:// and socks5h:// schemes are equivalent:
    DNS is always resolved by the proxy.

    --header, Set a custom header in the form "HeaderName: HeaderContent".
    Can be used multiple times. (e.g --header "Foo: Bar" --header "Hello: World")

    --hostname, Optionally set the 'Host' header (defaults to the host
    found in the server url).

    --sni, Override the ServerName when using TLS (defaults to the 
    hostname).

    --tls-ca, An optional root certificate bundle used to verify the
    chisel server. Only valid when connecting to the server with
    "https" or "wss". By default, the operating system CAs will be used.

    --tls-skip-verify, Skip server TLS certificate verification of
    chain and host name (if TLS is used for transport connections to
    server). If set, client accepts any TLS certificate presented by
    the server and any host name in that certificate. This only affects
    transport https (wss) connection. Chisel server's public key
    may be still verified (see --fingerprint) after inner connection
    is established.

    --tls-key, a path to a PEM encoded private key used for client 
    authentication (mutual-TLS).

    --tls-cert, a path to a PEM encoded certificate matching the provided 
    private key. The certificate must have client authentication 
    enabled (mutual-TLS).

    --pid Generate pid file in current working directory

    -v, Enable verbose logging

    --help, This help text

  Signals:
    The chisel process is listening for:
      a SIGINT or SIGTERM to begin a graceful shutdown
        (a second signal forces an immediate exit),
      a SIGUSR2 to print process stats, and
      a SIGHUP to short-circuit the client reconnect timer

  Version:
    X.Y.Z

  Read more:
    https://github.com/jpillora/chisel

Sécurité

Le chiffrement est toujours activé. Au démarrage d'un serveur chisel, celui-ci génère une paire de clés publique/privée ECDSA en mémoire. L'empreinte de la clé publique (SHA256 encodé en base64) est affichée au démarrage du serveur. Au lieu de générer une clé aléatoire, le serveur peut éventuellement spécifier un fichier de clé, à l'aide de l'option --keyfile. Lorsque les clients se connectent, ils affichent également l'empreinte de la clé publique du serveur. Le client peut imposer une empreinte particulière à l'aide de l'option --fingerprint. Les anciennes empreintes MD5 sont toujours acceptées mais doivent être au format complet de 16 octets séparés par des deux-points — les préfixes tronqués sont rejetés. Consultez l'option --help ci-dessus pour plus d'informations.

Le serveur limite également la taille des messages websocket entrants avant l'authentification (CHISEL_WS_READ_LIMIT, 512 Kio par défaut), afin que des pairs non authentifiés ne puissent pas épuiser la mémoire avec des messages surdimensionnés. La valeur par défaut se situe confortablement au-dessus du paquet de transport maximal de 256 Kio de x/crypto/ssh, de sorte qu'aucun paquet SSH valide n'est jamais rejeté. Seule la valeur 0 désactive la limite ; les valeurs négatives reviennent à la valeur par défaut sûre.

Authentification

À l'aide de l'option --authfile, le serveur peut éventuellement fournir un fichier de configuration user.json pour créer une liste d'utilisateurs acceptés. Le client s'authentifie ensuite à l'aide de l'option --auth. Consultez users.json pour un exemple de fichier de configuration d'authentification. Consultez l'option --help ci-dessus pour plus d'informations.

Notes sur le comportement du fichier d'authentification :

• Le fichier est surveillé et rechargé à chaud — y compris les enregistrements d'éditeur via renommage (vim) et les mises à jour de configmap kubernetes. Les rechargements s'appliquent aux nouvelles connexions et aux nouveaux tunnels des clients déjà connectés ; les utilisateurs supprimés perdent immédiatement l'accès aux nouveaux tunnels, bien que les tunnels établis ne soient pas interrompus.
• Les modèles d'adresse sont des expressions régulières et ne sont pas ancrés — ancrez-les avec ^ et $ (le serveur émet un avertissement concernant les modèles non ancrés au chargement). La chaîne vide "" correspond à tout.
• L'accès SOCKS5 est contrôlé par une entrée correspondant au jeton socks. Changement majeur : SOCKS5 contournait auparavant entièrement le fichier d'authentification ; les serveurs exécutant --socks5 avec --authfile doivent accorder socks aux utilisateurs qui doivent conserver l'accès proxy (les entrées génériques "" continuent de fonctionner).
• Les chaînes d'authentification sans deux-points (user:pass) constituent désormais une erreur fatale au démarrage tant côté serveur que côté client — auparavant, elles désactivaient silencieusement l'authentification.
• L'utilisateur --auth survit aux rechargements du fichier d'authentification et gagne les conflits de noms avec les utilisateurs du fichier.

En interne, cela est réalisé à l'aide de la méthode d'authentification Password fournie par SSH. Apprenez-en plus sur crypto/ssh ici http://blog.gopheracademy.com/go-and-ssh/. Les ouvertures/fermetures de session (avec l'utilisateur, l'adresse source et les remotes) et les tentatives de connexion échouées sont journalisées au niveau info.

Guide TLS

La configuration sécurisée la plus simple est --tls-domain, qui provisionne automatiquement un certificat LetsEncrypt (nécessite le port 443 et un enregistrement DNS pointant vers le serveur) :```sh chisel server --port 443 --tls-domain chisel.example.com --auth user:pass chisel client --auth user:pass https://chisel.example.com R:2222:localhost:22

Pour utiliser votre propre certificat (auto-signé ou CA interne), générez une paire clé/certificat et pointez les deux côtés vers les bons fichiers :```sh
chisel server --port 443 --tls-key key.pem --tls-cert cert.pem
chisel client --tls-ca ca.pem https://chisel.example.com 3000

Pour le TLS mutuel, passez également --tls-ca au serveur et --tls-cert/--tls-key à chaque client. Notez que TLS enveloppe le transport de chisel de l'extérieur ; la couche SSH interne chiffre et authentifie toujours, donc la validation --fingerprint fonctionne avec ou sans TLS.

Guide SOCKS5 avec Docker

1. Générez une nouvelle clé privée dans le terminal

   root@kitploit:~

   chisel server --keygen -
   # ou enregistrez-la sur le disque --keygen /path/to/mykey
   

2. Démarrez votre serveur chisel

   root@kitploit:~

   jpillora/chisel server --keyfile '<chaîne ck-base64 ou chemin de fichier>' -p 9312 --socks5
   

3. Connectez votre client chisel (en utilisant l'empreinte du serveur)

   root@kitploit:~

   chisel client --fingerprint '<voir la sortie du serveur>' <adresse-serveur>:9312 socks
   

4. Pointez vos clients SOCKS5 (par ex. OS/Navigateur) vers :

   root@kitploit:~

   <adresse-client>:1080
   

5. Vous disposez désormais d'une connexion SOCKS5 chiffrée et authentifiée sur HTTP

Remarque : si le serveur utilise également --authfile, les utilisateurs doivent disposer d'une entrée correspondant au jeton socks pour utiliser le proxy (voir Authentification).

SOCKS inversé avec un fichier d'authentification

Pour permettre à un client spécifique d'agir comme nœud de sortie SOCKS, accordez-lui l'adresse d'écoute du SOCKS inversé (R:socks écoute sur 127.0.0.1:1080 du serveur) :```json { "exituser:password": ["^R:127\.0\.0\.1:1080$"] }

I need the actual content of chunk 23 to translate it. Please provide the Markdown text you'd like me to translate from English to French.```sh
chisel server --reverse --authfile users.json
chisel client --auth exituser:password <server-address> R:socks
# server-side consumers point SOCKS5 clients at 127.0.0.1:1080,
# and their traffic exits via the chisel client's network

Voir aussi l'exemple de tunnel inversé étape par étape.

Fonctionnement derrière un CDN (Cloudflare)

chisel fonctionne à travers les CDN qui prennent en charge les WebSockets. Pour Cloudflare : activez les WebSockets, proxiez (orange-cloud) l'enregistrement DNS, et connectez les clients avec https://. Le CDN termine le TLS, mais la couche SSH interne signifie que la validation --fingerprint authentifie toujours votre serveur chisel de bout en bout — le CDN ne peut ni lire ni modifier le trafic tunnelisé. Conservez --keepalive à sa valeur par défaut de 25s pour rester sous les délais d'inactivité du CDN, et notez que les proxys qui suppriment les en-têtes Upgrade ne peuvent pas transporter chisel du tout.

Réglage avec les variables d'environnement

Les réglages moins courants sont des variables d'environnement, toutes lues avec un préfixe CHISEL_ (par ex. CHISEL_WS_TIMEOUT=10s) :

HOST, PORT, AUTH, et CHISEL_KEY/CHISEL_KEY_FILE sont documentés dans les textes --help ci-dessus.

Mises en garde

Étant donné que la prise en charge des WebSockets est requise :

• Les fournisseurs IaaS prennent tous en charge les WebSockets (sauf si un proxy HTTP non compatible a été imposé devant vous, auquel cas je dirais que vous avez été rétrogradé en PaaS)
• Les fournisseurs PaaS varient dans leur prise en charge des WebSockets
  • Heroku a une prise en charge complète
  • Openshift a une prise en charge complète bien que les connexions ne soient acceptées que sur les ports 8443 et 8080
  • Google App Engine standard n'a aucune prise en charge (l'environnement flexible en a une)

Contribution

• http://golang.org/doc/code.html
• http://golang.org/doc/effective_go.html
• github.com/jpillora/chisel/share contient le paquet partagé
• github.com/jpillora/chisel/server contient le paquet serveur
• github.com/jpillora/chisel/client contient le paquet client

Journal des modifications

• 1.0 - Version initiale
• 1.1 - Remplacement du chiffrement symétrique simple par SSH ECDSA
• 1.2 - Ajout de la prise en charge de SOCKS5 (serveur) et HTTP CONNECT (client)
• 1.3 - Ajout de la prise en charge du tunnel inversé
• 1.4 - Ajout de la prise en charge d'en-têtes HTTP arbitraires
• 1.5 - Ajout de la prise en charge de SOCKS inversé (par @aus)
• 1.6 - Ajout de la prise en charge de stdio côté client (par @BoleynSu)
• 1.7 - Ajout de la prise en charge UDP
• 1.8 - Passage à une image Docker scratch
• 1.9 - Passage à Go 1.21. Remplacement de la graine --key par des chaînes de clés P256 avec --key{gen,file} (par @cmenginnz)
• 1.10 - Passage à Go 1.22. Ajout de .rpm .deb et .apk aux versions. Correction d'une mauvaise comparaison de versions.
• 1.11 - Passage à Go 1.25.1. Mise à jour de toutes les dépendances.
• 1.12 - Passe de fiabilité et de sécurité :
  • les pings keepalive expirent désormais (CHISEL_PING_TIMEOUT), donc les connexions mortes se reconnectent rapidement après veille/réveil, délais NAT et redémarrages du serveur
  • les rechargements d'authfile survivent aux renommages d'éditeur et aux échanges de configmaps kubernetes, et s'appliquent en direct aux clients connectés (nouveaux tunnels ; les tunnels établis ne sont pas interrompus)
  • rupture : avec --socks5 + --authfile, l'accès SOCKS5 exige désormais une entrée d'authfile correspondant à socks (les entrées génériques "" continuent de fonctionner)
  • rupture : les empreintes MD5 héritées tronquées sont rejetées — --fingerprint doit être l'empreinte SHA256 complète (ou la forme MD5 complète à 16 octets avec deux-points)
  • rupture : les chaînes d'authentification sans deux-points (par ex. --auth user) sont une erreur fatale au démarrage au lieu de désactiver silencieusement l'authentification
  • la demi-fermeture TCP est propagée à travers les tunnels, et les cibles inaccessibles rejettent le tunnel au lieu de présenter une connexion morte (CHISEL_DIAL_TIMEOUT, défaut 30s)
  • arrêt gracieux sur SIGTERM avec vidage des requêtes HTTP (CHISEL_SHUTDOWN_GRACE) ; un second signal force la sortie
  • les nœuds de sortie UDP ne se cassent plus ni ne fuient au-delà de 100 flux simultanés (CHISEL_UDP_MAX_CONNS)
  • les messages websocket entrants sont limités en taille avant authentification (CHISEL_WS_READ_LIMIT)
  • le serveur ne panique plus lorsqu'un client se déconnecte entre la poignée de main SSH et sa requête de configuration (#608)
  • le client sort avec un code non nul lorsque --max-retry-count est épuisé ; nouveau --min-retry-interval (défaut 1s) ; socks5:// accepté pour --proxy
  • les builds go install rapportent leur version réelle ; les sessions et les échecs de connexion sont journalisés au niveau info
  • les binaires de version sont compilés avec Go 1.27.0 ; x/crypto/ssh est mis à jour vers v0.55.0 pour traiter GO-2026-6303
  • les versions livrent désormais des images multi-architectures basées sur scratch construites avec ko, avec racines CA, sur GHCR et Docker Hub ; la publication se fait en deux étapes — le taggage construit une version GitHub brouillon plus des images taguées par version, et la publication du brouillon promeut les tags Docker latest / X / X.Y

Mise à niveau vers 1.12

Quatre changements peuvent nécessiter une action lors de la mise à niveau depuis 1.11.x ou antérieur :

1. SOCKS5 + --authfile (appliqué depuis v1.11.7) : les utilisateurs qui doivent conserver l'accès proxy ont besoin d'une entrée d'authfile correspondant au jeton socks (le générique "" continue de fonctionner). Voir Authentification. Les requêtes refusées sont journalisées côté serveur comme Denied connection to socks (ACL).
2. --fingerprint : les empreintes MD5 héritées tronquées sont rejetées. Utilisez l'empreinte SHA256 complète imprimée par le serveur et le client (la forme MD5 complète à 16 octets avec deux-points est toujours acceptée, mais dépréciée).
3. --auth les valeurs doivent être <user>:<pass> — les chaînes sans deux-points échouent désormais au démarrage au lieu de désactiver silencieusement l'authentification.
4. Codes de sortie : chisel client avec --max-retry-count sort désormais avec un code non nul lorsque les tentatives de connexion sont épuisées ; les scripts vérifiant $? et les unités systemd Restart=on-failure le remarqueront.

Licence

MIT © Jaime Pillora