Aller au contenu
DevSecOps Logo DevSecOps
Docs
Blog
Blog

ASSH simplifie la configuration du client SSH

logo assh

Aujourd’hui, je vais vous parler d’un outil qui va vous permettre de simplifier la configuration de vos clients SSH. Cet outil s’appelle ASSH, pour Advanced SSH Config. ASSH est un wrapper pour SSH qui permet de gérer de manière dynamique et avancée les configurations SSH.

Les configurations SSH standard peuvent vite devenir complexes et difficiles à gérer, surtout dans des environnements avec de nombreux serveurs. ASSH propose une solution à ce problème en introduisant une couche d’abstraction.

Fonctionnement d’ASSH

Plongeons maintenant dans les concepts clés d’ASSH pour mieux comprendre comment cet outil enrichit l’expérience SSH. ASSH n’est pas juste un wrapper ; c’est une réinvention intelligente de la façon dont nous interagissons avec SSH.

ASSH fonctionne en s’intercalant entre votre client SSH et vos connexions SSH. Il intercepte les commandes SSH et les manipule selon les configurations spécifiées dans votre fichier ~/.ssh/config. Cela permet une grande flexibilité et une personnalisation approfondie de vos connexions.

Le cœur d’ASSH repose sur deux composants principaux :

  1. Le Parser de Configuration : ASSH lit et interprète le fichier de configuration SSH. Il ajoute une couche supplémentaire de fonctionnalités tout en respectant la syntaxe et les fonctionnalités de base du fichier SSH original.
  2. Le Proxy SSH : Lorsqu’une connexion SSH est initiée, ASSH agit comme un proxy. Il peut modifier dynamiquement les paramètres de connexion, répartir la charge entre plusieurs hôtes, ou même rebondir à travers plusieurs serveurs pour atteindre la destination finale.

L’un des aspects les plus puissants d’ASSH est sa capacité à gérer des configurations complexes avec simplicité. Par exemple, vous pouvez configurer des connexions à travers des serveurs proxy, définir des règles de reconnexion automatique, ou même gérer des groupes d’hôtes avec des configurations similaires.

Avec ASSH, vous avez la possibilité de définir des règles avancées pour chaque hôte ou groupe d’hôtes dans votre fichier de configuration. Ces règles peuvent inclure :

  • Balancing et Failover : Répartir les connexions entre plusieurs hôtes pour équilibrer la charge ou fournir une redondance.
  • Chaining et Jump Hosts : Connectez-vous à un hôte via un ou plusieurs intermédiaires, ce qui est particulièrement utile dans des environnements complexes ou sécurisés.
  • Hooks Personnalisés : Exécutez des scripts ou des commandes spécifiques à différents moments de votre connexion SSH, comme avant la connexion, après la déconnexion, etc.

Installation d’ASSH

Que vous soyez sous Linux, macOS ou Windows, le processus d’installation est conçu pour être aussi simple que possible. ASSH est facilement installable via les gestionnaires de paquets courants. Par exemple, sous macOS, vous pouvez utiliser Homebrew :

Terminal window
brew install assh

Sous Linux, le processus peut varier légèrement en fonction de votre distribution, mais ASSH est généralement disponible via les gestionnaires de paquets standard.

ASSH peut aussi être installé avec asdf-vm :

Terminal window
asdf plugin add assh
asdf install assh latest
asdf global assh latest

Les Fichiers de Configuration ASSH

Après avoir installé ASSH, il est essentiel de comprendre comment sont définis les fichiers de configuration. Mais avant cela pour ceux qui ne maitrisent pas trop ce fichier de configuration voici un rappel.

Rappel sur les configurations SSH

Le fichier ~/.ssh/config est un fichier texte standard qui définit les paramètres pour les connexions SSH. Ce fichier peut inclure des informations comme les noms d’hôte, les adresses IP, les noms d’utilisateur, les ports et d’autres options de configuration.

Voici un exemple de ce à quoi pourrait ressembler une entrée de base dans ce fichier :

Host monserveur
    HostName monserveur.example.com
    User monutilisateur
    Port 22
    IdentityFile ~/.ssh/id_ed25519

Dans cet exemple, monserveur est un alias pour la connexion SSH au serveur monserveur.example.com. Ce fichier spécifie également le nom d’utilisateur, le port et le fichier d’identité SSH à utiliser pour cette connexion.

Host *.example.com
    User monutilisateur
    IdentityFile ~/.ssh/id_ed25519
    ControlMaster auto
    ControlPath ~/.ssh/cm-%r@%h:%p
    ControlPersist 5m

Dans cet exemple, *.example.com est un modèle pour la connexion SSH aux serveurs dont le nom de domaine se termine par .example.com. Ce modèle spécifie également le nom d’utilisateur, le fichier d’identité SSH et les paramètres de connexions à utiliser pour cette connexion.

Pour plus d’informations vous pouvez vous rendre sur ce guide.

Construction du fichier de configuration ASSH

ASSH utilise son propre fichier de configuration, nommé .assh.yml, pour construire le fichier SSH. Dans ce fichier de configuration assh y ajoute ses propres options et fonctionnalités. Par exemple, avec ASSH, vous pouvez définir des modèles pour des configurations communes, utiliser des hooks pour déclencher des actions spécifiques et bien plus encore.

Voyons cela en détail avec un premier exemple assez simpliste :

hosts:
  on1.robert.local:
    User: bob

Dans cet exemple, on1.robert.local se connectera avec l’utilisateur bob.

Génération de la configuration SSH

La première chose à faire avant de démarrer quoi que ce soit, c’est de sauvegarder le fichier actuel :

Terminal window
cp ~/.ssh/config ~/.ssh.config.orig

Pour construire ou mettre à jour votre fichier de configuration SSH, utilisez la commande suivante :

Terminal window
assh config build

Cette commande permet à ASSH de générer un fichier de configuration SSH enrichi, prenant en compte les fonctionnalités avancées d’ASSH.

Voici le contenu généré avec le fichier ci-dessus :

# This file was automatically generated by assh vn/a (n/a)
# on 2024-01-13 07:21:27 +0100 CET, based on ~/.ssh/assh.yml
#
# more info: https://github.com/moul/assh


# host-based configuration
Host on1.robert.local
  User bob


# global configuration
Host *
  ProxyCommand /home/bob/.asdf/installs/assh/2.16.0/bin/assh connect --port=%p %h

Si vous lisez bien le wrapper assh est utilisé à chaque invocation de la ssh.

Validation de l’installation

Pour vérifier que tout est en ordre, vous pouvez tester votre configuration en établissant une connexion SSH à un de vos serveurs :

Terminal window
ssh on1.robert.local

Si la connexion est réussie, ASSH est correctement installé et configuré !

Configuration avancée d’ASSH

Les Paramètres par Défaut

Les paramètres par défaut dans ASSH servent de configuration de base pour tous les hôtes qui ne spécifient pas explicitement certains paramètres. Cela est particulièrement utile dans les environnements avec de nombreux serveurs, car cela permet de maintenir une configuration uniforme et centralisée.

Pour configurer les paramètres par défaut dans ASSH, vous devez définir une section defaults dans votre fichier. Voici un exemple de configuration des paramètres par défaut :

defaults
  User defaultuser
  Port 22
  IdentityFile ~/.ssh/id_ed25519
  ForwardAgent yes
  ControlMaster auto
  ControlPath ~/.ssh/multiplex/%r@%h:%p
  ControlPersist 10m

Dans cet exemple, tous les hôtes hériteront de ces paramètres par défaut, à moins qu’ils ne soient redéfinis dans la configuration spécifique de l’hôte.

Bien que les paramètres par défaut soient appliqués à tous les hôtes, vous pouvez toujours les surcharger pour des hôtes spécifiques. Par exemple :

Host specialserver
  HostName special.example.com
  User specialuser
  Port 2222

Dans ce cas, specialserver utilisera un utilisateur et un port différents de ceux définis dans les paramètres par défaut.

Les Templates

Un template dans ASSH est une sorte de modèle de configuration qui peut être appliqué à plusieurs entrées de votre fichier ~/.ssh/config. Cela vous permet de définir une configuration de base et de la réutiliser pour différents hôtes, en évitant ainsi la redondance et en facilitant la maintenance des configurations.

Pour créer un template dans ASSH, vous commencez par définir une section Templates dans votre fichier de configuration. Par exemple :

templates:
  my-template:
    User: bart

Dans cet exemple, my-template est un template qui définit un paramètre commun : l’utilisateur.

Pour appliquer ce template à un hôte, référencez simplement le nom du template dans la configuration de l’hôte :

Host server1
  Inherits my-template
  HostName server1.example.com


Host server2
  Inherits my-template
  HostName server2.example.com

Ici, server1 et server2 héritent tous les deux des paramètres définis dans my-template, ce qui garantit une cohérence dans la configuration tout en réduisant la duplication.

Les hooks

hosts:
  proxmox:
    User: root
    Aliases:
      - proxmox.robert.local
    OnConnect:
      - exec echo '{{.}}' | jq . >> ~/.ssh/last_connected_host.txt

Dans cet exemple, chaque fois que vous vous connectez à proxmox, une ligne sera ajoutée au fichier stockant l’historique des connexions.

Il est possible d’utiliser des variables ASSH dans les hooks :

Terminal window
  Hooks:
    # Automatically backup ~/.ssh/config
    BeforeConfigWrite:
      - 'exec set -x; cp {{.SSHConfigPath}} {{.SSHConfigPath}}.bkp'


    AfterConfigWrite:
      # Concat another `ssh_config` file with the one just generated by `assh`
      - 'exec cat ~/.ssh/my-heroku-generated-config >> {{.SSHConfigPath}}'


      # Alert me with a Desktop notification
      - notify "{{.SSHConfigPath}} has been rewritten"


    OnConnect:
      # Log internal information to a file
      - 'exec echo {{.}} | jq . >> ~/.ssh/last_connected_host.txt'


      # Alert me with a Desktop notification
      - notify New SSH connection to {{.Host.Prototype}} at {{.Stats.ConnectedAt}}


      # Write the host prototype to the terminal stderr
      - write New SSH connection to {{.Host.Prototype}}


    OnDisconnect:
      # write on terminal and in a Desktop notification some statistics about the finished connection
      - "write  SSH connection to {{.Host.HostName}} closed, {{.Stats.WrittenBytes }} bytes written in {{.Stats.ConnectionDuration}} ({{.Stats.AverageSpeed}}bps)"
      - "notify SSH connection to {{.Host.HostName}} closed, {{.Stats.WrittenBytes }} bytes written in {{.Stats.ConnectionDuration}} ({{.Stats.AverageSpeed}}bps)"

Les principales variables ASSH :

Terminal window
// Host: http://godoc.org/github.com/moul/advanced-ssh-config/pkg/config/#Host
{{.Host.Name}}                                  //  localhost
{{.Host.HostName}}                              //  127.0.0.1
{{.Host.Port}}                                  //  22
{{.Host.User}}                                  //  moul
{{.Host.Prototype}}                             //  moul@127.0.0.1:22
{{.Host}}                                       //  {"HostName":"localhost","Port":22","User":"moul","ControlPersist":"yes",...}
{{printf "%s:%s" .Host.HostName .Host.Port}}    //  localhost:22


// Stats: http://godoc.org/github.com/moul/advanced-ssh-config/pkg/commands/#ConnectionStats
{{.Stats.ConnectedAt}}                           //  2016-07-20 11:19:23.467900594 +0200 CEST
{{.Stats.WrittenBytes}}                          //  3613
{{.Stats.WrittenBytesHuman}}                     //  3.6kb
{{.Stats.DisconnectAt}}                          //  2016-07-20 11:19:29,520515792 +0200 CEST
{{.Stats.ConnectionDuration}}                    //  6.052615198s
{{.Stats.ConnectionDurationHuman}}               //  6s
{{.Stats.AverageSpeed}}                          //  596.933bps
{{.Stats.AverageSpeedHuman}}                     //  3.4kb/s

Les includes

Les “includes” permettent de séparer votre configuration ASSH en plusieurs fichiers. Cette approche est particulièrement utile pour gérer des configurations volumineuses ou pour partager des configurations communes entre plusieurs utilisateurs ou systèmes.

includes:
- ~/.ssh/assh.d/*.yml
- /etc/assh.yml
- $ENV_VAR/blah-blah-*/*.yml

Les gateways

Plutôt que de se connecter directement à la cible finale, votre connexion SSH passe d’abord par cette passerelle. Cette méthode est souvent utilisée pour accéder à des serveurs situés dans des réseaux isolés ou sécurisés.

Pour configurer une gateway avec ASSH, vous devez définir cette gateway dans votre fichier de configuration SSH. Voici un exemple de base :

hosts:
  hosta:
    Hostname: 1.2.3.4


  hostb:
    Hostname: 5.6.7.8
    Gateways: hosta


  hostc:
    Hostname: 9.10.11.12
    Gateways: hostb


  hostd:
    Hostname: 13.14.15.16
    Gateways:
    - direct
    - hosta

Générons le fichier :

Terminal window
# This file was automatically generated by assh vn/a (n/a)
# on 2024-01-13 08:16:00 +0100 CET, based on ~/.ssh/assh.yml
#
# more info: https://github.com/moul/assh


# host-based configuration
Host hosta
  # HostName: 1.2.3.4


Host hostb
  # HostName: 5.6.7.8
  # Gateways: [hosta]


Host hostc
  # HostName: 9.10.11.12
  # Gateways: [hostb]


Host hostd
  # HostName: 13.14.15.16
  # Gateways: [direct, hosta]


# global configuration
Host *
  ProxyCommand /home/bob/.asdf/installs/assh/2.16.0/bin/assh connect --port=%p %h

Les autres commandes de la CLI

L’interface en ligne de commande (CLI) d’ASSH offre plusieurs commandes sous assh config qui permettent de gérer efficacement vos configurations SSH. Ces commandes permettent de construire, visualiser et manipuler la configuration de manière avancée.

Visualisation Graphique des Hôtes

La commande assh config graphviz génère une représentation graphique de vos hôtes et de leurs relations, au format Graphviz.

Terminal window
assh config graphviz


digraph G {
        "10.0.0.*"->"vr1.robert.local"[ color=red, label=1 ];
        "machine*"->"vr1.robert.local"[ color=red, label=1 ];
        "10.0.0.*" [ color=blue ];
        "machine*" [ color=blue ];
        "vr1.robert.local" [ color=blue ];
}

Cela peut être extrêmement utile pour visualiser des configurations complexes, en particulier lorsque vous avez des dépendances ou des relations entre différents hôtes, comme des gateways ou des configurations en cascade.

Sortie au Format JSON

La commande assh config json fournit une représentation en JSON de votre configuration. C’est une fonctionnalité utile pour l’intégration avec d’autres outils ou pour un traitement automatisé.

Terminal window
assh config json


{
  "hosts": {
    "10.0.0.*": {
      "User": "root",
      "Gateways": [
        "vr1.robert.local"
      ]
    },
    "192.168.3.*": {
      "User": "ubuntu"
    },
    "machine*": {
      "User": "bob",
      "Gateways": [
        "vr1.robert.local"
      ]
    },
    "on1.robert.local": {
      "User": "bob"
    },
    "proxmox": {
      "User": "root",
      "Aliases": [
        "proxmox.robert.local"
      ]
    },
    "proxmox2": {
      "User": "root",
      "Aliases": [
        "proxmox2.robert.local"
      ]
    },
    "vr1.robert.local": {
      "User": "root"
    }
  },
  "templates": {},
  "defaults": {
    "StrictHostKeyChecking": "no",
    "UserKnownHostsFile": [
      "/dev/null"
    ],
    "Hooks": {}
  },
  "asshknownhostfile": "~/.ssh/assh_known_hosts"
}

Cela peut servir à analyser et traiter votre configuration SSH dans des scripts ou des applications qui consomment des données JSON.

Lister Tous les Hôtes

La commande assh config list est un moyen rapide de lister tous les hôtes définis dans votre configuration ASSH.

Terminal window
assh config list


Listing entries


    10.0.0.* -> root@[dynamic]:22


    192.168.3.* -> ubuntu@[dynamic]:22


    machine* -> bob@[dynamic]:22


    on1.robert.local -> bob@on1.robert.local:22


    proxmox -> root@proxmox:22


    proxmox2 -> root@proxmox2:22


    vr1.robert.local -> root@vr1.robert.local:22


    (*) General options:
        StrictHostKeyChecking: no
        UserKnownHostsFile: /dev/null

C’est un outil pratique pour obtenir un aperçu rapide de tous vos hôtes configurés, ce qui peut être utile pour la vérification et la gestion de vos configurations.

Faire des Recherches

Enfin, la commande assh config search permet de rechercher des entrées spécifiques dans votre configuration en utilisant un texte de recherche.

Usage:

Terminal window
assh config search proxmox


Listing results for proxmox:
    proxmox -> root@proxmox:22
    proxmox2 -> root@proxmox2:22

Cette fonction est particulièrement utile lorsque vous travaillez avec un grand nombre d’hôtes et que vous devez trouver rapidement des informations spécifiques.

Conclusion

En parcourant les divers aspects et fonctionnalités d’ASSH, je vous ai fait découvrir comment cet outil révolutionne la manière dont je gére mes configuration SSH. De la configuration initiale et des paramètres par défaut à l’utilisation avancée de templates, gateways et de la CLI, ASSH se révèle être un allié indispensable pour tout administrateur système.

Plus d’infos