Connexion à distance SSH sous Windows

Tags:
Categories:

L’activation de l’accès distant SSH sous Windows nécessite généralement d’utiliser la fonctionnalité OpenSSH de Windows. Voici les étapes détaillées :

Vérification et installation d’OpenSSH

  1. Vérifier si OpenSSH est installé :

    • Ouvrez « Paramètres » > « Applications » > « Applications et fonctionnalités » > « Gérer les fonctionnalités facultatives ».
    • Dans la liste déjà installée, recherchez « Serveur OpenSSH ». S’il est présent, cela signifie qu’il a déjà été installé.

  2. Installer OpenSSH :

    • Si vous ne trouvez pas le serveur OpenSSH, vous pouvez cliquer sur « Ajouter une fonctionnalité » dans la page « Gérer les fonctionnalités facultatives », puis trouver « Serveur OpenSSH » dans la liste et cliquer sur « Installer ».

Démarrer et configurer le service OpenSSH

  1. Démarrer le service OpenSSH :

    • Une fois l’installation terminée, ouvrez l’invite de commandes (en tant qu’administrateur).
    • Tapez net start sshd pour démarrer le service OpenSSH. Pour que le service démarre automatiquement au démarrage, tapez sc config sshd start= auto.

  2. Configurer le pare-feu :

    • Assurez-vous que le pare-feu Windows autorise les connexions SSH. Vous pouvez accéder à « Panneau de configuration » > « Système et sécurité » > « Pare-feu Windows Defender » > « Paramètres avancés », puis créer une nouvelle règle de trafic entrant pour autoriser les connexions sur le port TCP 22.

Obtenir l’adresse IP et tester la connexion

  1. Obtenir l’adresse IP :

    • Pour vous connecter depuis un autre ordinateur à cet ordinateur Windows avec le service SSH activé, vous devez connaître son adresse IP. Vous pouvez utiliser la commande ipconfig dans l’invite de commandes pour afficher l’adresse IP de votre machine.

  2. Tester la connexion :

    • Sur un autre ordinateur ou un appareil mobile, utilisez un client SSH (par exemple : PuTTY, Termius, etc.) pour tenter de vous connecter à votre PC Windows, en utilisant le format ssh nom_utilisateur@adresse_ip. Où nom_utilisateur est le nom du compte Windows avec lequel vous souhaitez vous connecter, et adresse_ip est l’adresse IP que vous avez obtenue précédemment.

Modifier la configuration

Attention à éviter l’utilisation de la connexion par mot de passe, c’est une zone à risques absolue. Assurez-vous d’utiliser la clé publique pour la connexion. Nous devons modifier les paramètres pour désactiver la connexion par mot de passe et autoriser la connexion par clé publique.

Ce fichier de configuration est difficile à modifier, il nécessite des autorisations spéciales et doit garantir que les autorisations du répertoire et du fichier sont des valeurs spécifiques. Ici, nous recommandons d’utiliser un script pour effectuer les modifications.

# Vérifier les autorisations administrateur
$elevated = [bool]([System.Security.Principal.WindowsPrincipal]::new(
    [System.Security.Principal.WindowsIdentity]::GetCurrent()
).IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator))

if (-not $elevated) {
    Write-Error "Veuillez exécuter ce script en tant qu'administrateur"
    exit 1
}

# 1. Vérifier et installer le serveur OpenSSH
Write-Host "Vérification de l'état d'installation du serveur OpenSSH..."
$capability = Get-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0

if ($capability.State -ne 'Installed') {
    Write-Host "Installation du serveur OpenSSH..."
    Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0 | Out-Null
}

# 2. Démarrer et configurer le service SSH pour qu'il démarre automatiquement
Write-Host "Configuration du service SSH..."
$service = Get-Service sshd -ErrorAction SilentlyContinue
if (-not $service) {
    Write-Error "Échec de l'installation du service OpenSSH"
    exit 1
}

if ($service.Status -ne 'Running') {
    Start-Service sshd
}
Set-Service sshd -StartupType Automatic

# 3. Modifier le fichier de configuration
$configPath = "C:\ProgramData\ssh\sshd_config"
if (Test-Path $configPath) {
    Write-Host "Sauvegarde du fichier de configuration original..."
    Copy-Item $configPath "$configPath.bak" -Force
} else {
    Write-Error "Fichier de configuration introuvable : $configPath"
    exit 1
}

Write-Host "Modification de la configuration SSH..."
$config = Get-Content -Path $configPath -Raw

# Activer l'authentification par clé publique et désactiver l'authentification par mot de passe
$config = $config -replace '^#?PubkeyAuthentication .*$','PubkeyAuthentication yes' `
                  -replace '^#?PasswordAuthentication .*$','PasswordAuthentication no'

# S'assurer que les configurations nécessaires sont incluses
if ($config -notmatch 'PubkeyAuthentication') {
    $config += "`nPubkeyAuthentication yes"
}
if ($config -notmatch 'PasswordAuthentication') {
    $config += "`nPasswordAuthentication no"
}

# Réécrire le fichier de configuration
$config | Set-Content -Path $configPath -Encoding UTF8

Vérification des autorisations du fichier authorized_keys

# utilisateur normal
$authKeys = "$env:USERPROFILE\.ssh\authorized_keys"
icacls $authKeys /inheritance:r /grant "$($env:USERNAME):F" /grant "SYSTEM:F"
icacls "$env:USERPROFILE\.ssh" /inheritance:r /grant "$($env:USERNAME):F" /grant "SYSTEM:F"

# administrateur
$adminAuth = "C:\ProgramData\ssh\administrators_authorized_keys"
icacls $adminAuth /inheritance:r /grant "Administrators:F" /grant "SYSTEM:F"

Configuration des règles du pare-feu

# Autoriser le port SSH
New-NetFirewallRule -DisplayName "OpenSSH Server (sshd)" -Direction Inbound -Protocol TCP -Action Allow -LocalPort 22

Ajouter des clés publiques

Utilisateur normal

# utilisateur normal
$userProfile = $env:USERPROFILE
$sshDir = Join-Path $userProfile ".ssh"
$authorizedKeysPath = Join-Path $sshDir "authorized_keys"
$PublicKeyPath = "D:\public_keys\id_rsa.pub"

# Créer le répertoire .ssh
if (-not (Test-Path $sshDir)) {
    New-Item -ItemType Directory -Path $sshDir | Out-Null
}

# Définir les autorisations du répertoire .ssh
$currentUser = "$env:USERDOMAIN\$env:USERNAME"
$acl = Get-Acl $sshDir
$rule = New-Object System.Security.AccessControl.FileSystemAccessRule(
    $currentUser, "FullControl", "ContainerInherit,ObjectInherit", "None", "Allow"
)
$acl.AddAccessRule($rule)
Set-Acl $sshDir $acl

# Ajouter la clé publique
if (Test-Path $PublicKeyPath) {
    $pubKey = Get-Content -Path $PublicKeyPath -Raw
    if ($pubKey) {
        # S'assurer que la clé publique se termine par un saut de ligne
        if (-not $pubKey.EndsWith("`n")) {
            $pubKey += "`n"
        }

        # Ajouter la clé publique
        Add-Content -Path $authorizedKeysPath -Value $pubKey -Encoding UTF8

        # Définir les autorisations du fichier
        $acl = Get-Acl $authorizedKeysPath
        $acl.SetSecurityDescriptorRule(
            (New-Object System.Security.AccessControl.FileSystemAccessRule(
                $currentUser, "FullControl", "None", "None", "Allow"
            ))
        )
        Set-Acl $authorizedKeysPath $acl
    }
} else {
    Write-Error "Le fichier de clé publique n'existe pas : $PublicKeyPath"
    exit 1
}

# Redémarrer le service SSH
Write-Host "Redémarrage du service SSH..."
Restart-Service sshd

Administrateur

# administrateur
$adminSshDir = "C:\ProgramData\ssh"
$adminAuthKeysPath = Join-Path $adminSshDir "administrators_authorized_keys"
$adminPublicKeyPath = "D:\public_keys\id_rsa.pub"

# Créer le répertoire SSH pour administrateur
if (-not (Test-Path $adminSshDir)) {
    New-Item -ItemType Directory -Path $adminSshDir | Out-Null
}

# Définir les autorisations du répertoire SSH pour administrateur
$adminAcl = Get-Acl $adminSshDir
$adminRule = New-Object System.Security.AccessControl.FileSystemAccessRule(
    "Administrators", "FullControl", "ContainerInherit,ObjectInherit", "None", "Allow"
)
$adminAcl.AddAccessRule($adminRule)
Set-Acl $adminSshDir $adminAcl

# Ajouter la clé publique pour administrateur
if (Test-Path $adminPublicKeyPath) {
    $adminPubKey = Get-Content -Path $adminPublicKeyPath -Raw
    if ($adminPubKey) {
        # S'assurer que la clé publique se termine par un saut de ligne
        if (-not $adminPubKey.EndsWith("`n")) {
            $adminPubKey += "`n"
        }

        # Ajouter la clé publique
        Add-Content -Path $adminAuthKeysPath -Value $adminPubKey -Encoding UTF8

        # Définir les autorisations du fichier
        $adminAcl = Get-Acl $adminAuthKeysPath
        $adminAcl.SetSecurityDescriptorRule(
            (New-Object System.Security.AccessControl.FileSystemAccessRule(
                "Administrators", "FullControl", "None", "None", "Allow"
            ))
        )
        Set-Acl $adminAuthKeysPath $adminAcl
    }
} else {
    Write-Error "Le fichier de clé publique administrateur n'existe pas : $adminPublicKeyPath"
    exit 1
}

# Redémarrer le service SSH
Write-Host "Redémarrage du service SSH..."
Restart-Service sshd