79 % contre 51 % : les néobanques indépendantes en retard sur la sécurité des applications. Lire le rapport

Analyse approfondie

Analyse approfondie

Contournement de l'auth-proxy SFTP de Rclone via une clé publique (CVE-2026-134352)

Le cache auth-proxy de rclone serve sftp ignorait le type d'identifiant : une clé publique connue se connectait comme son propriétaire ; corrigé en 1.76.0.

En bref

  • Le cache de serve sftp --auth-proxy de rclone indexait le backend par nom d'utilisateur, identifiant et adresse IP du client, mais pas par type d'identifiant. Une clé publique rejouée comme mot de passe touchait la même entrée.
  • rclone 1.51.0 à 1.75.2 avec serve sftp et --auth-proxy est concerné. Un attaquant qui connaît la clé publique base64 d'un utilisateur peut amorcer le cache avec une proposition de clé non signée, puis se connecter comme cet utilisateur.
  • VulnCheck a publié CVE-2026-134352 le 2026-11-21, notée CVSS v4.0 9,2 Critique et v3.1 8,1 Élevé. L'avis de rclone la note Élevée 8,1. Aucune exploitation n'est connue et elle n'est pas dans le KEV au 2026-11-22.
  • Mettez à niveau vers rclone 1.76.0 ou ultérieur. Si cela doit attendre, cessez d'utiliser --auth-proxy sur serve sftp, car le rappel de mot de passe reste actif tant que le proxy l'est.

Suis-je concerné ?

Toutes ces conditions doivent être réunies pour qu'un déploiement soit exposé :

  • Il exécute rclone serve sftp avec --auth-proxy <program>.
  • Le binaire rclone est en 1.51.0 à 1.75.2. La version 1.76.0 corrige la faille.
  • Un attaquant connaît l'encodage base64 d'une clé publique SSH que le proxy d'authentification accepte. Les clés publiques ne sont pas des secrets et sont souvent publiées ou lisibles.
  • L'attaquant peut joindre le service. Il amorce l'entrée en cache avec une proposition de clé publique non signée, puis utilise la méthode mot de passe avec le même nom d'utilisateur depuis la même adresse IP du client avant l'expiration. La durée de vie par défaut est de 300 secondes d'inactivité, rafraîchie à chaque accès. Aucune connexion du propriétaire de la clé n'est nécessaire.

La politique du proxy ne supprime pas l'exposition. PasswordCallback appelle le proxy à chaque tentative de mot de passe dès qu'un proxy est configuré, donc un déploiement dont le proxy accepte les clés publiques et refuse tous les mots de passe garde un chemin de mot de passe accessible. Sur une socket Unix, ipFromAddr renvoie une chaîne vide pour chaque client, donc la condition de même IP cesse d'être un obstacle. Comme l'attaquant crée l'entrée avec la proposition non signée, la fenêtre de 300 secondes commence à sa connexion.

Ligne de version Versions concernées Version corrigée
rclone 1.x avec serve sftp --auth-proxy 1.51.0 à 1.75.2 1.76.0
rclone 1.x sans --auth-proxy Aucune Sans objet

La fiche CVE évalue la faille à CVSS v4.0 9,2 Critique (CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N) et CVSS v3.1 8,1 Élevé (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H). L'avis du fournisseur la note CVSS v3.1 8,1 Élevé.

Seul serve sftp est concerné. Les commandes serve ftp, serve http et serve webdav passent false pour l'indicateur de clé publique, et serve s3 utilise un chemin séparé par clé d'accès. Un hôte qui n'utilise rclone que pour copier, synchroniser ou monter n'atteint jamais ce code.

Vérifiez le binaire en cours d'exécution et la définition du service :

rclone version
ps -eo pid,args | grep '[r]clone serve sftp'
grep -rn -- '--auth-proxy' /etc/systemd/system /lib/systemd/system 2>/dev/null

Pour un conteneur, vérifiez le processus à l'intérieur du conteneur en cours d'exécution, pas une image fraîchement tirée :

docker exec <container> rclone version
docker inspect <container> --format '{{json .Config.Cmd}} {{json .Config.Entrypoint}}'

Comment corriger ?

Mettez à niveau vers rclone 1.76.0 ou une version ultérieure et redémarrez chaque processus serve sftp. Le correctif se trouve dans le cache du proxy et dans les rappels d'authentification SFTP, donc un redémarrage est nécessaire même lorsque le binaire est remplacé sur place.

  1. Mettez à jour le binaire avec la méthode de déploiement utilisée. rclone selfupdate installe la version stable actuelle, qui est 1.76.0 :
rclone selfupdate
rclone version
  1. Pour l'image conteneur officielle, tirez 1.76.0 et recréez le conteneur. Un conteneur en cours d'exécution garde l'ancien binaire jusqu'à son remplacement :
docker pull rclone/rclone:1.76.0
docker stop rclone
docker rm rclone
docker run -d --name rclone -v /srv/rclone:/config/rclone rclone/rclone:1.76.0 serve sftp --auth-proxy /path/to/proxy
  1. Pour une compilation Go, déplacez le module vers le tag corrigé et recompilez :
go install github.com/rclone/rclone@v1.76.0
  1. Pour les paquets de distribution, confirmez que la version du paquet est 1.76.0 ou ultérieure. Une distribution qui fournit encore 1.75.2 laisse le déploiement exposé même après une mise à niveau normale des paquets.

Si la mise à niveau ne peut pas avoir lieu maintenant, retirez --auth-proxy de serve sftp et servez un ensemble fixe d'utilisateurs avec --user et --pass ou --authorized-keys. Cela supprime entièrement le cache vulnérable du proxy. Restreindre le service à un réseau d'administration réduit la surface d'attaque mais ne corrige pas la logique du cache, car un attaquant qui peut atteindre le service doit toujours remplir la condition de même IP. Aucun réglage ne désactive l'authentification par mot de passe tant que --auth-proxy est utilisé.

Quelle est la cause racine ?

La clé de cache de l'auth-proxy n'incluait pas le type d'identifiant. Une clé publique et la même clé publique envoyée comme mot de passe produisaient la même clé, donc la seconde requête recevait le backend en cache de la première sans que le proxy soit consulté.

Proxy.Call est le point d'entrée unique de l'authentification de serve sftp. Il calcule une clé de cache, la cherche dans p.vfsCache et n'appelle le programme proxy qu'en cas d'absence. La fonction de clé vulnérable se trouve dans cmd/serve/proxy/proxy.go en v1.75.2 :

func generateCacheKey(user, auth, clientIP string) string {
    mac := hmac.New(sha256.New, cacheKeyHMACKey)
    mac.Write([]byte(auth))
    // Separate the two so ("ab", "c") can't collide with ("a", "bc")
    mac.Write([]byte{0})
    mac.Write([]byte(clientIP))
    return user + "-" + hex.EncodeToString(mac.Sum(nil)[:8])
}

La clé couvre le nom d'utilisateur hors du hachage, et l'identifiant et l'adresse IP du client à l'intérieur. Le type d'identifiant, que l'appelant connaît sous la forme isPublicKey, ne fait pas partie des entrées. Proxy.Call ne lit cet indicateur qu'en cas d'absence, pour indiquer au programme proxy la méthode utilisée par le client :

func (p *Proxy) Call(user, auth string, isPublicKey bool, remoteAddr string) (VFS *vfs.VFS, vfsKey string, err error) {
    clientIP := ipFromAddr(remoteAddr)
    cacheKey := generateCacheKey(user, auth, clientIP)
    value, ok := p.vfsCache.GetMaybe(cacheKey)
    if !ok {
        kind := authPassword
        if isPublicKey {
            kind = authPublicKey
        }
        value, err = p.call(user, auth, kind, clientIP)
        if err != nil {
            return nil, "", err
        }
    }
    // ...
    authHash := sha256.Sum256([]byte(auth))
    if subtle.ConstantTimeCompare(authHash[:], entry.pwHash[:]) != 1 {
        // reject
    }
    return entry.vfs, cacheKey, nil
}

Les deux rappels SSH fournissent l'identifiant dans le même encodage. PublicKeyCallback dans cmd/serve/sftp/server.go encode en base64 la clé publique sérialisée et appelle Proxy().Call avec true. PasswordCallback transmet les octets du mot de passe sous forme de chaîne et appelle Proxy().Call avec false. Lorsque les octets du mot de passe sont la clé publique base64, l'argument auth est identique octet pour octet, donc le HMAC correspond.

Un second défaut rendait l'entrée en cache facile à créer. Avant le correctif, PublicKeyCallback demandait un backend au proxy dès qu'un client proposait une clé, avant que le client prouve qu'il détenait la clé privée. La bibliothèque SSH appelle ce rappel pendant la négociation de clé avec une proposition non signée. Un attaquant qui connaissait une clé publique pouvait donc faire créer et mettre en cache un backend pour cet utilisateur sans détenir la clé privée.

Comment la faille est-elle exploitée ?

Un attaquant qui connaît la clé publique d'un utilisateur se connecte comme cet utilisateur en amorçant d'abord le cache avec une proposition de clé non signée, puis en envoyant la clé comme mot de passe depuis la même adresse.

  1. Le déploiement exécute rclone serve sftp --auth-proxy <program>, et le proxy accepte la clé publique de la victime.
  2. L'attaquant obtient la clé publique de la victime, par exemple depuis un fichier authorized_keys, un dépôt public ou un serveur de clés, et l'encode en base64 au format du protocole.
  3. L'attaquant se connecte avec le nom d'utilisateur de la victime et propose la clé publique sans signature, ce que la bibliothèque SSH fait pendant la négociation de clé. PublicKeyCallback de rclone demande le proxy, reçoit le backend de la victime et le met en cache sous le nom d'utilisateur, la clé base64 et l'adresse IP du client de l'attaquant. La connexion elle-même n'est pas authentifiée.
  4. Pendant les 300 secondes de durée de vie du cache, l'attaquant se reconnecte avec le même nom d'utilisateur depuis la même adresse IP du client et s'authentifie par mot de passe, en utilisant la clé publique base64 comme mot de passe.
  5. PasswordCallback calcule la même clé de cache. La recherche touche l'entrée de la victime, et la comparaison SHA-256 de l'identifiant correspond car la chaîne est identique.
  6. rclone renvoie le backend en cache et n'appelle jamais le programme proxy, donc la politique du proxy et son journal d'audit ne voient pas la connexion.

Une connexion légitime du propriétaire de la clé crée la même entrée, mais elle n'est pas nécessaire. Le commit correctif de la proposition non signée indique que la combinaison permettait à un attaquant de se connecter comme tout utilisateur dont il connaissait la clé publique, depuis sa propre adresse IP et sans que l'utilisateur se soit connecté.

L'avis rapporte une reproduction de bout en bout contre un vrai écouteur serve sftp sur 127.0.0.1. Ne détenant que la clé publique base64, le testeur a lu le fichier de la victime et écrit un nouveau fichier dans le backend de la victime. Un proxy instrumenté a enregistré zéro appel pendant la session de l'attaquant. rclone crédite torjan0, Saku0512, utkarsh2102, ncw et calbebop dans l'avis.

Comment se déroule l'attaque ?

Un attaquant propose la clé publique sans signature pour amorcer le cache, puis la rejoue comme mot de passe. La clé de cache ignore le type d'identifiant, donc le rejeu correspond à l'entrée et renvoie le backend de la victime sans que le proxy soit interrogé.

flowchart LR A["L'attaquant propose la clé publique
sans signature depuis sa propre IP"] --> B["Le proxy renvoie le backend de la victime"] B --> C["Clé de cache = HMAC de l'identifiant et de l'IP
sans le type d'identifiant"] C --> D["L'attaquant envoie la même clé base64
comme mot de passe depuis la même IP"] D --> E["La même clé de cache touche l'entrée de la victime
la chaîne d'identifiant correspond"] E --> F["Le proxy n'est pas appelé
l'attaquant obtient le VFS en lecture-écriture"]

Que peut faire un attaquant ?

Un attaquant qui possède la clé publique d'une victime obtient la vue en lecture-écriture du backend de cette victime pendant la fenêtre de cache, et peut répéter l'attaque en amorçant une nouvelle entrée.

  • Lire et écrire les fichiers de la victime. La reproduction de l'avis a lu un fichier et en a écrit un nouveau. La couche SFTP de rclone expose toutes les opérations de lecture-écriture du backend, y compris la création, l'écrasement, le renommage et la suppression.
  • Contourner l'autorisation et l'audit du proxy. Le programme proxy est le composant qui associe un utilisateur à un backend et peut révoquer l'accès. Un succès du cache le contourne, donc une révocation enregistrée dans le proxy ne s'applique pas à la session en cache.
  • Franchir une frontière entre locataires. Lorsqu'un serveur rclone expose plusieurs backends via un seul proxy, l'entrée en cache appartient au backend de la victime, donc l'attaquant atteint ce backend plutôt que le sien.

Les conditions sont énumérées en entier ici. Le déploiement doit utiliser serve sftp avec --auth-proxy, et le proxy doit accepter la clé publique de la victime. L'attaquant doit connaître cette clé. Il amorce ensuite l'entrée avec une proposition non signée et se reconnecte avec le même nom d'utilisateur depuis la même adresse IP du client, qui est sa propre adresse. Derrière un NAT, un hôte bastion ou un répartiteur de charge, de nombreux clients partagent une adresse, et sur une socket Unix chaque client a la chaîne vide. L'attaquant n'a besoin ni de la clé privée, ni d'un mot de passe, ni d'une connexion préalable du propriétaire, ni d'un accès au programme proxy.

L'impact s'arrête au backend que le proxy a renvoyé pour cet utilisateur. L'avis démontre la lecture et l'écriture de fichiers. Il ne démontre pas l'exécution de code sur l'hôte rclone, et cet article ne l'affirme pas.

Pourquoi le correctif fonctionne-t-il ?

Le correctif ajoute le type d'identifiant à la clé de cache et le vérifie lors d'un succès. Il empêche aussi le proxy de s'exécuter pour des clés publiques dont le client n'a pas encore prouvé la possession.

-func generateCacheKey(user, auth, clientIP string) string {
+func generateCacheKey(user, auth string, kind authKind, clientIP string) string {
    mac := hmac.New(sha256.New, cacheKeyHMACKey)
+   mac.Write([]byte{byte(kind)})
    mac.Write([]byte(auth))
    // Separate the two so ("ab", "c") can't collide with ("a", "bc")
    mac.Write([]byte{0})
    mac.Write([]byte(clientIP))
    return user + "-" + hex.EncodeToString(mac.Sum(nil)[:8])
 }

Proxy.Call dérive désormais kind avant la recherche et le passe à generateCacheKey, donc une requête par mot de passe et une requête par clé publique ne peuvent jamais partager une entrée. Le garde final compare aussi le type stocké, pas seulement le hachage de l'identifiant :

    authHash := sha256.Sum256([]byte(auth))
-   if subtle.ConstantTimeCompare(authHash[:], entry.pwHash[:]) != 1 {
+   if entry.kind != kind || subtle.ConstantTimeCompare(authHash[:], entry.pwHash[:]) != 1 {

Le second changement déplace l'appel au proxy hors de PublicKeyCallback vers un nouveau VerifiedPublicKeyCallback, que la bibliothèque SSH appelle seulement après que le client a signé avec la clé privée :

        PublicKeyCallback: func(c ssh.ConnMetadata, pubKey ssh.PublicKey) (*ssh.Permissions, error) {
            fs.Debugf(describeConn(c), "Public key login attempt for %s", c.User())
            if s.provider.IsProxy() {
-               _, vfsKey, err := s.provider.Proxy().Call(...)
+               // This is also called for keys offered without a
+               // signature, so leave asking the proxy until
+               // VerifiedPublicKeyCallback when the client has proved
+               // it holds the private key.
+               return &ssh.Permissions{}, nil
            }

Ensemble, ces changements ferment les deux moitiés de l'attaque : une entrée en cache ne peut plus être atteinte avec un autre type d'identifiant, et une proposition de clé non signée ne peut plus créer d'entrée. CallAccessKey a été mis à jour pour passer authAccessKey, donc le chemin S3 conserve aussi une clé distincte. Le correctif est complet pour le chemin proxy de serve sftp nommé dans l'avis.

Comment vérifier si j'ai été compromis ?

L'attaque ne laisse aucun fichier sur disque. Un succès du cache contourne le programme proxy, donc la vérification la plus solide consiste à comparer le journal d'authentification de rclone avec le journal du proxy sur la même fenêtre.

rclone journalise chaque tentative de mot de passe au niveau debug depuis PasswordCallback. Sur un déploiement dont le proxy n'accepte que les clés publiques, toute ligne de mot de passe est suspecte :

journalctl -u rclone --since "30 days ago" | grep -i "Password login attempt"

Le journal du programme proxy doit enregistrer un appel par connexion acceptée. Une connexion SFTP réussie dans le journal de connexion de rclone sans appel correspondant au proxy est la signature d'un succès du cache. Comparez sur le nom d'utilisateur et l'adresse IP source :

grep -i "login attempt" /var/log/rclone.log
grep -i "<username>" /var/log/auth-proxy.log

Cherchez ensuite des écritures que l'utilisateur légitime n'a pas faites dans le backend que le proxy associe à cet utilisateur. Le serveur SFTP de rclone ne journalise pas les opérations par fichier par défaut. Aucun indicateur de compromission, adresse IP ou empreinte de fichier n'est publié pour cette CVE, et une tentative qui échoue aux conditions du cache peut ne laisser aucune trace au-delà d'une poignée de main SSH refusée.

Chronologie

  • 2026-10-09 : les deux commits correctifs ont été rédigés dans le dépôt rclone.
  • 2026-11-06 : rclone 1.76.0 est sorti et l'avis du fournisseur GHSA-66qv-66mg-9h74 a été publié.
  • 2026-11-21 : VulnCheck a publié CVE-2026-134352 à 16:34 UTC.

Les commits correctifs ont été rédigés 43 jours avant la CVE
Figure 1 : des commits correctifs du 2026-10-09 à CVE-2026-134352 le 2026-11-21, avec la sortie de v1.76.0 entre les deux. Source : commits rclone, version v1.76.0 et fiche CVE, vérifiés le 22 novembre 2026

FAQ

Cela concerne-t-il serve ftp, serve http, serve webdav ou serve s3 ? Non. Seul serve sftp passe true pour l'indicateur de clé publique. Les serveurs FTP, HTTP et WebDAV passent false, et S3 utilise CallAccessKey avec son propre type de clé.

Mon proxy d'authentification refuse tous les mots de passe. Suis-je quand même concerné ? Oui. PasswordCallback appelle le proxy dès qu'un proxy est configuré, et le rappel est inconditionnel. Le proxy ne voit jamais la tentative de l'attaquant car le cache répond d'abord.

L'attaquant a-t-il besoin de la clé privée ou du mot de passe de la victime ? Non. L'attaquant a besoin de la clé publique base64, qui n'est pas un secret. La proposition de clé non signée remplit l'entrée en cache, donc ni la clé privée ni une connexion du propriétaire ne sont nécessaires.

Combien de temps dure la fenêtre d'attaque ? L'entrée en cache vit 300 secondes d'inactivité et est rafraîchie à chaque accès. Un attaquant qui rate une fenêtre peut réessayer en amorçant de nouveau l'entrée.

L'attaquant doit-il venir de la même adresse IP ? La première et la seconde connexion doivent partager la clé de cache, donc elles utilisent le même nom d'utilisateur et la même adresse IP du client. C'est l'adresse de l'attaquant, pas celle de la victime. Derrière un NAT, un hôte bastion ou un répartiteur de charge, de nombreux clients partagent une adresse. Sur une socket Unix, chaque client a la chaîne vide comme adresse, donc la condition disparaît.

CVE-2026-134352 est-elle exploitée en conditions réelles ? Aucune exploitation n'est connue au 2026-11-22, et la CVE n'est pas dans le KEV de la CISA. L'avis rapporte une reproduction réussie en laboratoire, pas des attaques.

Trouvez les services SFTP exposés avec Ostorlab

La découverte de surface d'attaque d'Ostorlab inventorie les hôtes et services que votre organisation expose, y compris les points de terminaison SFTP, afin que vous sachiez quels systèmes vérifier et corriger en priorité. La détection de cette faille rclone n'est pas confirmée ; l'inventaire est le point de départ de la vérification manuelle de version et de configuration décrite dans « Suis-je concerné ? ».

Références

  • Avis de sécurité rclone GHSA-66qv-66mg-9h74, publié le 2026-11-06 (vérifié le 22 novembre 2026) : https://github.com/rclone/rclone/security/advisories/GHSA-66qv-66mg-9h74
  • Fiche CVE-2026-134352, publiée le 2026-11-21 (vérifiée le 22 novembre 2026) : https://www.cve.org/CVERecord?id=CVE-2026-134352
  • Commit correctif f6ca72fabb09, « serve sftp: fix auth proxy letting a public key be used as a password », rédigé le 2026-10-09 (vérifié le 22 novembre 2026) : https://github.com/rclone/rclone/commit/f6ca72fabb09
  • Commit correctif 866e7ac577aa, « serve sftp: fix auth proxy running for public keys the client can't use », rédigé le 2026-10-09 (vérifié le 22 novembre 2026) : https://github.com/rclone/rclone/commit/866e7ac577aa
  • Version rclone v1.76.0, publiée le 2026-11-06 (vérifiée le 22 novembre 2026) : https://github.com/rclone/rclone/releases/tag/v1.76.0
  • Page de téléchargement de rclone (vérifiée le 22 novembre 2026) : https://rclone.org/downloads/
  • Dépôt rclone, 61 155 étoiles (vérifié le 22 novembre 2026) : https://github.com/rclone/rclone
  • Image conteneur officielle de rclone, 145 855 065 tirages (vérifiée le 22 novembre 2026) : https://hub.docker.com/r/rclone/rclone