Autoriser les utilisateurs réguliers à SSH à l'aide d'une clé privée qu'ils ne peuvent pas lire

Disons que j'ai un ensemble de machines (appelées ici les machines des clients) dans lesquelles seule une petite liste de personnes (appelées le personnel de support) est autorisée à SSH, en utilisant un seul compte par machine (le compte d'accès au support).

Le personnel d'assistance est uniquement censé se connecter aux machines des clients à l'aide de clés. De plus, le personnel de support peut évoluer, de sorte qu'une personne qui quitte le personnel de support n'est pas autorisée à se connecter à une machine client. Par conséquent, il est interdit aux employés de lire les clés privées utilisées pour se connecter aux machines des clients. De plus, il est interdit de modifier le authorized_keysfichier sur les machines des clients.

Pour réaliser cette configuration, j'ai eu l'idée d'utiliser un proxy SSH auquel le personnel de support se connectera (avec l'authentification LDAP, mais c'est un autre problème) et qui contient les clés privées.

La question est: comment autoriser le personnel de support à utiliser la clé privée SSH sans pouvoir la lire?

Je crois que je dois faire un démon fonctionnant en tant que root sur la machine proxy qui acceptera la demande d'un utilisateur et ouvrira une session SSH pour lui, mais je ne sais pas comment le faire. Des idées?

Je suggérerais quelques options.

1. Protégez la clé ssh et exigez l'utilisation de la sudopart de votre équipe d'assistance. Vous pouvez le faire de manière transparente avec un wrapper. Appelez le wrapper, disons, /usr/local/bin/ssh-supportet faites-le contenir quelque chose comme ceci (non testé):

   #!/bin/bash
   export PATH=/usr/local/bin:/usr/bin:/bin
   export IFS=$' \t\n'
   export SUSER=ssupport
   
   # Restart if not running under sudo
   test "X$1" != 'X-S' && exec sudo -u "$SUSER" /usr/local/bin/ssh-support -S "$@"
   shift
   export SHOME="$(getent passwd "$SUSER" | cut -d: -f6)"
   
   # Extract single argument as hostname LABEL and validate that we have
   # an RSA private key for it. The target username, real hostname, port,
   # etc. can be defined in ~/.ssh/config for the user $SUSER (ssupport)
   label="$1"
   idfile="$SUSER/.ssh/id_rsa_for_$label"
   cgfile="$SUSER/.ssh/config"
   
   ok=true
   [[ "$label" =~ '/' ]] && { echo "Invalid label: $label" >&2; ok=; }
   [[ ! -s "$idfile" ]] && { echo "Missing identity file: $idfile" >&2; ok=; }
   [[ ! -s "$cgfile" ]] && { echo "Missing configuration file: $cgfile" >&2; ok=; }
   
   if test -n "$ok"
   then
       logger -t ssh-support "$SUDO_USER requested ssh to $label"
       exec ssh -i "$idfile" -F "$cgfile" "$label"
   fi
   exit 1

   Cela nécessiterait une entrée dans le sudoersfichier qui permettrait aux utilisateurs du supportgroupe d'utiliser l'outil. Cette commande leur permet d'exécuter l' ssh-supportoutil en tant ssupportqu'utilisateur - que vous devez créer. Il ne confère aucun privilège root.

   %support ALL = (ssupport) /usr/local/bin/ssh-support

   Si vous êtes heureux que les utilisateurs de soutien ne doivent pas besoin de fournisseur leur propre mot de passe pour exécuter l'outil (tel que demandé par l' sudoinvocation dans le script lui - même) , vous pouvez modifier la sudoersdéfinition ainsi:

   %support ALL = (ssupport) NOPASSWD: /usr/local/bin/ssh-support

   En supposant PATHcontenu que /usr/local/bin/vous appelleriez alors avec ssh-support clientname. En supposant également que vous avez créé l' ssupportutilisateur comme /home/ssupportvous le feriez /home/ssupport/.ssh/id_rsa_clientnameet en /home/ssupport/.ssh/id_rsa_clientname.pubtant que paire de certificats, et que vous avez une entrée d'hôte /home/ssupport/.ssh/configpour clientnamecelle définie l'utilisateur, l'hôte, le port, etc. pour la machine cible. Vous désactiveriez probablement la redirection X11, la redirection de port, etc. explicitement. Comme d'habitude, le /home/ssupport/.sshrépertoire devra être protégé avec des autorisations 0700.

2. Donnez à chaque membre du support leur propre compte utilisateur local et demandez à chaque personne d'utiliser sa propre clé ssh privée pour accéder aux serveurs du client. Lorsqu'une personne quitte le groupe de support, vous supprimez sa clé ssh des serveurs du client. Cela signifie que vous n'avez plus à vous soucier d'empêcher votre personnel de connaître la clé ssh privée.

Ce que vous voulez vraiment faire, c'est utiliser l'AC SSH et signer les clés utilisées par chaque personne de support (elles doivent avoir leurs propres clés ssh, comme les passeports) et configurer les serveurs de vos clients pour utiliser le TrustedUserCAKeys /etc/ssh/users_ca.pubdans / etc / ssh / sshd_config. De cette façon, le serveur acceptera n'importe quelle clé signée par la clé CA (à laquelle vous avez accès) et vous pourrez révoquer les clés de personnes qui ne sont plus en charge sans même toucher les touches autorisées.

Une recherche rapide de "ssh ca" a indiqué ce didacticiel: https://www.digitalocean.com/community/tutorials/how-to-create-an-ssh-ca-to-validate-hosts-and-clients-with -ubuntu ( faites défiler jusqu'à "Comment configurer les clés utilisateur") - bien que le tutoriel mentionne Ubuntu, il est indépendant de la distribution, mais vous avez besoin d'une nouvelle version d'OpenSSH qui prend en charge SSH CA

Une autre bonne entrée de blog sur le sujet est https://ef.gy/hardening-ssh (faites défiler jusqu'à "Certificats SSH").

Faites particulièrement attention à ce que vous puissiez signer la clé pour qu'elle soit valide pour une durée limitée, afin qu'elle expire automatiquement!

Il existe quelques réponses différentes impliquant un script wrapper pour ssh invoqué via sudo ou setuid-executable (vers un compte non root à usage spécial ). Comme le dit nkms , le passage de tous les arguments à ssh permet à l'utilisateur de faire des choses arbitraires avec les clés ssh que nous essayons de protéger. L'autre extrême que certains ont trouvé est de n'autoriser qu'un nom d'hôte.

L'OP dit que les administrateurs doivent pouvoir télécharger des choses.

Vous pouvez avoir deux wrappers d'arguments fixes à ssh différents. Un pour un shell de connexion, un autre pour scp. Aucun argument fourni par l'utilisateur autre que le nom d'hôte (et le nom de fichier à télécharger).

Ou un script wrapper qui s'utilise getoptlui-même pour analyser des options très limitées et brancher des choses dans une commande ssh principalement fixe. Ignorer (ou commettre des erreurs) les options non reconnues serait la voie à suivre.

N'essayez pas de filtrer les options ssh «dangereuses», écrivez simplement un wrapper qui peut faire deux choses: une connexion interactive ou télécharger un fichier (noms de fichiers locaux et distants). Vous devez encore faire un peu de désinfection là-bas, je suppose.

En fait, il est toujours facile de se tromper. Vous devez trouver un moyen d'empêcher l'utilisateur de donner le fichier contenant les clés ssh comme fichier local. Donc, vous essayez toujours de penser à tout ce qui doit être interdit, au lieu de commencer à ne rien autoriser. Ce serait un début pour vous assurer que les noms de fichiers ne contiennent aucun @ou :.

Si vous configurez un serveur proxy SSH, vous pouvez faire en sorte que le shell (in /etc/passwd) de vos utilisateurs ne soit pas défini sur un shell tel que bash, mais plutôt sur un script simple qui n'autorise pas l'accès au shell. Au lieu de cela, il demanderait alors un nom d'hôte cible ( read target) exec ssh "support@$target".

Notez que l'utilisation d'un proxy comme celui-ci peut rendre difficile l'utilisation d'outils tels que scple transfert de fichiers vers / depuis les machines client. Cela peut être un problème ou un avantage!

Vos assistants se connectent toujours via cette machine proxy, et uniquement à partir de celle-ci, afin que les clients puissent simplement authentifier la machine proxy à l'aide de HostbasedAuthentication .

Disons que la machine proxy est supporters.pcet que vous fournissez un support àcustomer.pc

customer.pc aura HostbasedAuthentication yes in /etc/ssh/ssd_config, supporters.pc listés dans /etc/ssh/shosts.equivet sa clé publique dans /etc/ssh/ssh_known_hosts.

Lorsque votre personnel de support se connecte à [email protected] et exécute ssh customer.pc, il générera ssh-keysign (8) (qui doit être défini), qui gérera la signature de la clé avec le fichier que vous ne pouvez pas lire et fournir à supporters.pc la preuve que la connexion provient bien de supporters.pc . En tant que customer.pc fait confiance à supporters.pc , votre membre du personnel est connecté en tant que support .

Utilisez un binaire wrapper

Pour ce cas d'utilisation particulier (voir la note importante ci-dessous), une possibilité est de créer un utilisateur (par exemple support-ssh) spécifiquement pour ces connexions SSH sortantes, puis d'installer un petit binaire wrapper qui s'exécute /usr/bin/ssh.

• Ne copiez pas + chmod le sshbinaire lui-même, car vous ne vous souviendrez pas de le recopier à chaque fois que vous appliquez des mises à jour de sécurité.
• Et ne l'utilisez pas en roottant qu'utilisateur plus privilégié, pour des raisons en lesquelles j'ai confiance sont évidentes.

Il s'agit d'une alternative fonctionnellement équivalente à l'utilisation sudopour élever les privilèges à ceux du support-sshcompte avec les compromis suivants:

• C'est plus petit et plus léger que sudo, donc il y a moins de risques d'erreur de configuration qui s'ouvre plus que vous ne le pensiez.
• Il est de votre responsabilité de le coder correctement - ne le faites que si vous êtes extrêmement prudent et (idéalement) avez une expérience du codage critique pour la sécurité.
• Il peut être personnalisé pour être plus spécifique que sudo(mais plus vous écrivez de code, plus vous devez auditer pour la sécurité).

Le binaire wrapper doit être défini HOMEsur le support-sshrépertoire personnel de l' utilisateur, de sorte que sshla ssh_configclé privée et appropriée sera récupérée . Mais l'utilisateur invoquant ne devrait pas être autorisé à lire ~support-ssh/.ssh/ou à lire son contenu.

L'emballage peut être aussi simple que:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char **argv)
{
    setenv("HOME", "/home/support-ssh", 1);
    /* allow only a single, non-option argument */
    if (argc!=2 || *argv[1]=='-') {
        fprintf(stderr, "Usage: %s <hostname>", argv[0]);
        exit(EXIT_FAILURE);
    }
    execv("/usr/bin/ssh", argv);
    return EXIT_FAILURE;
}

Vous voudrez peut-être être plus restrictif et vérifier que l'argument se argv[1]trouve dans un ensemble de noms d'hôtes autorisés. Ou moins restrictif et autorisez (un sous-ensemble de) les arguments d'option. Vous pouvez remplacer complètement les variables d'environnement (mais garder les importants tels que TERM, LC_*, etc.); notez cela LD_LIBRARY_PATHet LD_PRELOADsont particulièrement dangereux.

Un programme wrapper similaire pourrait être fourni scpsi nécessaire.

Une note sur l'applicabilité

Cette réponse répond aux circonstances spécifiques de la question, où les utilisateurs sont contractuellement obligés de suivre les procédures, et il y a des sanctions (par exemple, licenciement) pour les violer. Cela suppose que vous souhaitiez empêcher les employés de copier des clés privées avec désinvolture, plutôt que d'empêcher un attaquant déterminé d'obtenir un accès non autorisé.

Je suis d'avis que la sécurité est obtenue à la fois par des moyens de défense techniques et non techniques, et que l'équilibre obtenu ici ou en utilisant sudoest approprié à la situation présentée.