Tunnellisation SSH automatique depuis Windows

J'essaie de configurer un ordinateur Windows pour toujours avoir deux tunnels SSH vers mon serveur Linux.

Actuellement, j'utilise PuTTY pour ouvrir les deux tunnels SSH: je me connecte au serveur dans PuTTY, le laisse minimisé et ne le touche jamais. Cela fonctionne bien, sauf lorsque la connexion SSH tombe: PuTTY affiche un message d'erreur et je dois fermer manuellement l'erreur et me reconnecter au serveur.

Ce que je voudrais faire, c'est avoir une application qui peut configurer les deux tunnels SSH, et peut se reconnecter automatiquement, sans avoir à faire quoi que ce soit manuellement, y compris entrer un mot de passe. Les données que j'envoie à travers les deux tunnels sont des connexions VNC, donc souvent je ne serai pas sur la machine pour effacer les erreurs et saisir les mots de passe. Les deux tunnels sont un tunnel local et un tunnel distant.

(Oui, je suis conscient des dangers de la connexion automatique à SSH. Je prévois de créer un utilisateur dédié sans privilèges et non autorisé à se connecter de manière interactive et à l'utiliser.)

J'ai trouvé cette question: comment garder un tunnel SSH ouvert de manière fiable? , mais qui utilise Linux comme client SSH, et j'utilise Windows.

Essayez Bitvise Tunnelier - cela fonctionne pour moi. Je l'ai défini pour établir des tunnels SSH tout en n'étant visible que sous forme d'icône de plateau. Il établit la connexion SSH au démarrage et la rétablit dès que la connectivité est restaurée après une coupure ou après la mise en veille du système. Je préfère toujours l'apparence de la console Putty, donc je continue de l'utiliser - mais pour garder les tunnels en place, j'utilise maintenant Tunnelier. Le seul inconvénient majeur que j'ai trouvé est le manque de support IPv6, que Putty fournit sans aucune action de l'utilisateur.

Essayez MyEnTunnel . Il peut se reconnecter en cas d'échec de connexion.

Jetez un œil à Xshell - il est plus scriptable que PuTTY et est gratuit pour un usage domestique (si c'est là que vous devez l'utiliser). Il prétend avoir une fonctionnalité de reconnexion automatique, mais je ne l'ai pas essayée et je suis sur un ordinateur portable basé sur Linux depuis quelques mois maintenant, donc je n'ai aucun moyen de la tester sur le mo.

Deux excellents outils:

Les deux ont ces caractéristiques:

• Pourrait être automatisé au démarrage
• Open source
• Gérez plusieurs tunnels en même temps
• Pourrait résider dans la barre d'état système
• Gratuit (Mobaxterm a une version gratuite)
• Crypter le mot de passe stocké

1. Mobaxterm

Site: http://mobaxterm.mobatek.net/

Capturer :

2. Gestionnaire de tunnel SSH

Site: https://code.google.com/archive/p/ssh-tunnel-manager/

Capturer :

J'ai essayé de nombreuses solutions comme les gestionnaires de tunnels SSH, mais toutes étaient inconvenantes pour moi: trop d'écrans de configuration, parfois bogués (une fois, le gestionnaire de tunnels SSH a purgé tous! Les paramètres que j'avais! J'ai donc dû restaurer les paramètres des 30 tunnels). Alors ils ont tous perdu ma confiance. C'est pourquoi je propose un script Powershell personnalisé, facilement configurable, modifiable, petit, mais qui fonctionne. Publié ici et ci-dessous:

Pour commencer à l'utiliser, vous avez besoin d'une configuration comme celle-ci:

# LocalPort TargetHost  TargetPort  SshHost SshUsername SshKeyPath 
18080   google.com  80  bastion.example.com User    D:\secure\path\to\private_key.ppk

Enregistrez-le en tant que config.csv. Et utiliser un script PowerShell pour le maintenir est:

<#
.SYNOPSIS
  Powershell script for keeping ssh tunnel up and running

.DESCRIPTION
  This script uses configuration of tunnels located in config.csv. For more information visit http://tsherlock.tech/2019/03/13/simple-ssh-tunnel-auto-reconnect-using-putty-and-powershell/

.NOTES
  Version:        1.0
  Author:         Anton Shkuratov
  Creation Date:  2019-03-13
  Purpose/Change: Initial script development

#>

$currentDir = $PSScriptRoot
if (-not $env:PATH.Contains($currentDir)) {
  $env:PATH="$env:PATH;$currentDir"
}

# Check plink is accessible
try {
  Start-Process plink.exe -WindowStyle Hidden
} catch {
  Write-Host Error running plink.exe Please make sure its path is in PATH environment variable
  EXIT 1
}

# Parse config
$config = [System.IO.File]::ReadAllLines("$currentDir\config.csv");
$bindings = New-Object System.Collections.ArrayList
$regex = New-Object System.Text.RegularExpressions.Regex("(\d)+\s([^ ]+)\s(\d+)\s([^ ]+)\s([^ ]+)\s([^ ]+)", [System.Text.RegularExpressions.RegexOptions]::IgnoreCase);
$keyPasswords = @{}
$procs = @{}

foreach($line in $config) {
  $match = $regex.Match($line)

  if ($match.Success) {
    $sshKey = $match.Groups[6];

    $bindings.Add(@{
      LocalPort = $match.Groups[1];
      TargetHost = $match.Groups[2];
      TargetPort = $match.Groups.Groups[3];
      SshHost = $match.Groups[4];
      SshUser = $match.Groups[5];
      SshKey = $match.Groups[6];
    });

    if (-not $keyPasswords.ContainsKey($sshKey)) {
      $pass = Read-Host "Please enter password for key (if set): $sshKey" -AsSecureString
      $keyPasswords.Add($sshKey, $pass);
    }
  }
}

# Starting Processes
function EnsureRunning($procs, $keyPasswords, $binding) {

  if ($procs.ContainsKey($binding) -and $procs[$binding].HasExited) {

    $proc = $procs[$binding]
    $sshKey = $binding.sshKey
    $out = $proc.StandardError.ReadToEnd()

    if ($out.Contains("Wrong passphrase")) {
      Write-Host "Wrong pass phrase for $sshKey, please re-enter"
      $pass = Read-Host "Please enter password for key: $sshKey" -AsSecureString
      $keyPasswords[$sshKey] = $pass;
    } else {
      $exitCode = $proc.ExitCode
      $tHost = $binding.sshHost

      Write-Host "Connection to $tHost is lost, exit code: $exitCode"
    }
  }

  if (-not $procs.ContainsKey($binding) -or $procs[$binding].HasExited) {
    $sshUser = $binding.SshUser
    $sshHost = $binding.SshHost
    $sshKey = $binding.SshKey
    $lPort = $binding.LocalPort
    $tPort = $binding.TargetPort
    $tHost = $binding.TargetHost
    $sshKeyPass = [Runtime.InteropServices.Marshal]::PtrToStringAuto([Runtime.InteropServices.Marshal]::SecureStringToBSTR($keyPasswords[$sshKey]))

    $psi = New-Object System.Diagnostics.ProcessStartInfo;
    $psi.FileName = "plink.exe";
    $psi.UseShellExecute = $false;

    $psi.CreateNoWindow = $true;
    $psi.RedirectStandardInput = $true;
    $psi.RedirectStandardError = $true;

    $psi.Arguments = "-ssh $sshUser@$sshHost -i `"$sshKey`" -batch -pw $sshKeyPass -L $lPort`:$tHost`:$tPort"

    $proc = [System.Diagnostics.Process]::Start($psi);

    Start-Sleep 1

    if (-not $proc.HasExited) {
      Write-Host Connected to $sshUser@$sshHost
    }

    $procs[$binding] = $proc;
  }
}

function EnsureAllRunning($procs, $keyPasswords, $bindings) {
  while($true) {
    foreach($binding in $bindings) {
      EnsureRunning $procs $keyPasswords $binding
    }
    Start-Sleep 1
  }
}


try {
  # Waiting for exit command
  Write-Host Working... Press Ctrl+C to stop execution...
  EnsureAllRunning $procs $keyPasswords $bindings
} finally {
  # Clean up
  Write-Host Clean up

  foreach($proc in $procs.Values) {
    if ($proc -ne $null -and -not $proc.HasExited) {
      $proc.Kill();
    }
  }
}

Une fois qu'il est configuré, exécutez-le comme:

powershell -File autossh.ps1

Si vous êtes un fan de Putty, essayez Putty Tray .

Il possède quelques fonctions supplémentaires, notamment la tentative de reconnexion automatique après un échec de connexion et la reconnexion lorsque votre ordinateur sort du mode veille.

Comme déjà mentionné par quelqu'un d'autre, je combinerais cela avec une authentification par clé publique sans phrase de passe.

En théorie, cela devrait être assez fiable, mais je ne suis pas un expert en sécurité, je ne peux donc pas vous conseiller à ce sujet.

Je l'ai googlé et j'ai obtenu quelques résultats pour votre question, vous pouvez toujours essayer un combo de recherche, automate putty logince que j'ai fait. Voici un résultat particulièrement utile qui devrait vous convenir:

http://www.neox.net/w/2008/04/22/putty-auto-login-macro-putty-connection-manager/

Il vous explique comment configurer une macro pour le mastic. Téléchargez également Putty connection manager ici (car le lien est rompu à partir du lien initial):

http://sourceforge.net/projects/puttycm/

J'ai également utilisé Putty et j'ai eu le même problème jusqu'à ce que je trouve une meilleure solution - Essayez ADVSoft Persistent SSH https://persistentssh.com fonctionne comme un service Windows et maintient les tunnels SSH en état d'exécution. Gratuit pour un usage personnel, pas besoin d'installer autre chose.