ssh Zugang für fhem über Script einrichten

Ich mache einige Dinge aus dem Docker Container heraus über ssh auf dem Docker Host, anstatt den Container zu sehr zu verbiegen. (Artikel andocken).

Dafür habe ich mal ein Script gebastelt und ein paar Aufruf Varianten ausgearbeitet. Damit sollte mit wenigen Handgriffen die Einrichtung des ssh public key Zuganges innerhalb FHEM auf einen anderen Host gelingen. 

Das Script hat nur wenige Zeilen es werden beliebig Hostnamen oder IP Adressen als Argumente übergeben. 

1. Die eventuell vorhandenen Einträge in known_host werden gelöscht und neu eintragen.
2. Es wird überprüft ob bereits ein ssh Key vorhanden ist, falls nicht wird ein Neuer erzeugt.
3. Der public key wird zur möglichen Weiterverarbeitung (in authorized_keys) ausgegeben.

Ich zeige den Aufruf 

• als komplettes Here Doc, als lokales Script oder Script vom GitHub, 
• als anderer User,
• oder direkt im Docker Container.

Das eigentliche Ziel: der public key von User fhem auf dem HostA wird dem User userB auf HostB gegeben damit User fhem sich als userB ohne Passworteingabe an HostB anmelden / Befehle ausführen kann.

Man beachte in allen Beispielen die unterschiedliche Verwendung der Shell Optionen -c und -s!

Befehle und Scripts per ssh ausführen

Ich möchte über ssh (mit Powershell oder Perl) auf einem Linux Computer Befehle ausführen und dort Aktionen steuern.

Dazu braucht man ein paar Vorbereitungen, muss ein paar Eigenheiten beachten und ich möchte hier meine Erkenntnisse notieren.

Die ssh Einrichtung für Linux (fhem) habe ich hier schon mal beschrieben. Auf die Übertragung des public Key mit der Powershell gehe ich kurz ein. 

ssh mit public key

ich habe dazu schon mehrfach was geschrieben - aber man lernt ja immer wieder dazu. Deshalb noch ein ziemlich komprimierter Artikel: 

Ein HowTo für die Automatisierung von Remote Aufgaben in FHEM über ssh. 

Nachtrag 2023: Es gibt einen neuen Artikel, der die Einrichtung ganz kompakt mit einem Script zeigt.

Windows von FHEM über ssh steuern

Windows OpenSSH Server installieren

Als ersten Schritt sollte man zunächst unabhängig von der Windows Version prüfen ob ein entsprechender Dienst schon läuft oder existiert:

Get-Service -Name *ssh*

Windows 10 + Server 2019

In den aktuellen Windows Versionen (ab dem Jahr 2019) ist der OpenSSH Server enthalten und kann einfach installiert werden.

Get-WindowsCapability -Online -Name OpenSSH.Server* | Add-WindowsCapability -Online
Get-Service -Name sshd | Set-Service -StartupType Automatic
Get-Service -Name sshd | Start-Service

Windows Server 2016, 2012 R2 und 2012

In früheren Windows Versionen kann der OpenSSH Server nur über ein extra download/Setup installiert werden.
Als Voraussetzung für die Installation muss die Ausführung von Powershellscripten erlaubt sein.

Set-Executionpolicy Remotesigned

Ich habe für die Installation ein komplettes Script auf GitHub  zur Verfügung gestellt.
Man kann es einfach herunterladen und starten.

Ergänzung 2021:  TLS1 kann nicht mehr verwendet werden, es kommt unter Umständen zur Fehlermeldung. Hier habe ich Abhilfe gefunden und eine zusätzliche Zeile eingebaut. Eventuell schafft ein .net Update Abhilfe.

[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]'Tls11,Tls12'
invoke-webrequest https://raw.githubusercontent.com/heinz-otto/Powershell/master/InstallLatestSshd64.ps1 -OutFile InstallLatestSshd64.ps1
.\InstallLatestSshd64.ps1

Das Script überprüft die Windows Server Version und installiert ein fehlendes
Windows Management Framework 5.1 (dann ist zwischendurch ein Reboot erforderlich). Es wird die aktuellste sshd Version heruntergeladen und die Anmeldung für die Administratoren Gruppe freigeschaltet.

Um bei dieser Installationsart anschließend die Programme wie ssh oder ssh-keygen einfach verwenden zu können, kann der Pfad erweitert werden. Hier die Powershell und die cmd Variante für die aktuelle Sitzung:

$Env:Path += "C:\Program Files\OpenSSH-Win64\;"
set PATH=C:\Program Files\OpenSSH-Win64\;%PATH%

Die Verwendung von Parametern in der Powershell kann fehlerhaft sein. Im Zweifel die CMD verwenden!

Das CMD Fenster unter Windows Server 2012 liefert für ssh nicht das richtige Terminal (conpty), eine interaktive Arbeit ist damit nicht wirklich möglich. Scripte können aber abgearbeitet werden.

Anmeldung am Windows OpenSSH Server

Man kann sich wie gewohnt von jedem System (Windows 10 Version 1803 hat den ssh Client aktiv) mit ssh user@host am SSH Server anmelden!
Der ssh Server akzeptiert nur den "Kurznamen". Windows kürzt den Anmeldenamen ein (z.B. bei einem Onlinekonto).
Man kann den Namen leicht in der Powershell Konsole ermitteln:

whoami

SSH Zugang mit Public Key einrichten

Achtung: Auch in Windows darf die Datei %USERPROFILE%\.ssh\authorized_keys nicht für jedermann zugreifbar sein. Nur DER Benutzer (Eigentümer), Administratoren und System darf Zugriff haben, sonst wird der Public Key abgelehnt!

Bitte den Hinweis am Ende des Artikels für die Gruppe der Administratoren beachten!
Bitte alle Schritte (Befehlszeilen) einzeln kopieren und ausführen!

Problem: Bei Windows als SSH Server versagt leider das Tool ssh-copy-id. Hier drei Szenarien für die Einrichtung des ssh Zuganges mit public key zu einem Windows Server.

Voraussetzung: Benutzer hat schon einen RSA Key. Wenn nicht muss er vorher erzeugt werden!

(ssh-keygen -f ~/.ssh/id_rsa -P "" -t rsa oder ssh-keygen -f %USERPROFILE%\.ssh/id_rsa -P "" -t rsa)

Linux Shell

ziel=user@host
pkey=$(cat ~/.ssh/id_rsa.pub)
ssh $ziel "findstr /c:\"$pkey\" .ssh\authorized_keys ||mkdir .ssh ||echo $pkey >>.ssh\authorized_keys"

Windows CMD

set ziel=user@host
set /p pkey=< %userprofile%\.ssh\id_rsa.pub
ssh %ziel% "findstr /c:""%pkey%"" .ssh\authorized_keys ||mkdir .ssh ||echo %pkey% >>.ssh\authorized_keys"

Windows Powershell

$ziel='user@host'
$pkey = $(type $env:userprofile\.ssh\id_rsa.pub)
ssh $ziel "findstr /c:`"`"$pkey`"`" .ssh\authorized_keys ||mkdir .ssh ||echo $pkey >>.ssh\authorized_keys"

Hinweis: Die Befehle nach ssh werden in der CMD von Windows abgearbeitet! Der Public Key wird direkt durch Variablen "Auflösung" mitgegeben. Der Trenner || ist eine bedingte Abarbeitung der folgenden Befehle. 

Ersteinrichtung
Alle Schritte in Kurzform für den Public Key Zugang für den User fhem zu einem Windows SSH-Remotesystem habe ich hier ausführlich gezeigt.

Nur mit Public Key

Man kann den Zugang sehr sicher machen und nur public key zulassen. Dazu muss man die Passwort Authentisierung abschalten indem in der Datei C:\ProgramData\ssh\sshd_config diese Zeile eingefügt wird:

PasswordAuthentication no

Hinweis: Die Config Datei enthält alle Optionen mit ihren Standardwerten als Kommentarzeilen. Jede Änderung in der Datei muss durch einen restart des sshd Services aktiviert werden.

Powershellscript von FHEM aus starten

Bei der Ausführung von Befehlen vom Linux System aus muss man beachten, dass der Backslash verdoppelt (geschützt) werden muss. Ansonsten kann man wie gewohnt Befehle absetzen und sogar Powershell Scripts mit Argumenten ausführen.

"ssh user\@host 'powershell C:\\Tools\\Scripts\\TestPsFhem.ps1' 'http://host:8083' 'DummyName'"

Oder auch mittels powershell cmdlets direkt starten

"ssh user\@host powershell -command stop-vm vmName"
{qx 'ssh user@host powershell -command get-service' }

Innerhalb von Powershell kann man auch mit einem Powershellscript über HTTP auf FHEM zugreifen.
Powershellbeispiel:
Fragt einen Dienst ab und schreibt Status und Displayname nach FHEM zurück in einen Dummy

<#
.SYNOPSIS
    This Script is for testing the FHEM Client for HTTP
.DESCRIPTION
    Give FHEM Server url and Dummy 
.NOTES
    Will give a State and Displayname of Service back
#>
#region Params
param(
    [Parameter(Mandatory=$true,Position=0,HelpMessage="-first 'Portnumber or URL'")]
    [String]$first,
    [Parameter(ValueFromPipeline=$true,ValueFromRemainingArguments=$true)]
    [String[]]$sec
)
#endregion 
$serv="wuauserv"

if (!(Test-Path .\fhemcl.ps1)) {
    Write-Output "fhemcl.ps1 fehlt"
    invoke-webrequest "https://raw.githubusercontent.com/heinz-otto/fhemcl/master/fhemcl.ps1" -OutFile "fhemcl.ps1"
}

$state=get-service $serv
.\fhemcl.ps1 $first "set $sec $($state.status)"
.\fhemcl.ps1 $first "setreading $sec Displayname $($state.DisplayName)"

Eigenheiten für Administratoren in einigen Windows Versionen?

Symptom:
Ein Mitglied der Gruppe administrators kann offenbar keine Anmeldung mit Public Key machen. Obwohl alles eingerichtet ist, wird das Passwort abgefragt. 

Das trifft zu für Windows Server Version 2012 und Windows 10 ab Version 2004.

Bei Windows Server 2012 R2, 2016 und 2019 war es bisher nicht so.

Neue Erkenntnis: Ist eventuell so gewollt und teilweise fehlerhaft implementiert: Link.

Eine Lösung:
Ich habe mir die Sache näher angeschaut und ich habe bei einigen Installationen Unterschiede in der aktiven sshd Konfigurationsdatei C:\ProgramData\ssh\sshd_config gefunden.
Kommentiert man dort am Ende der Datei den folgenden Eintrag mit einem # aus,

Match Group administrators
       AuthorizedKeysFile __PROGRAMDATA__/ssh/administrators_authorized_keys

funktioniert auch die Anmeldung für Mitglieder der Administratoren. Der Dienst ssd (OpenSSH SSH Server) muss dafür neu gestartet werden!
Hintergrund:
Es gibt zwei Erklärungen für diese Verhalten

1. Es werden unterschiedliche Inhalte der Datei ausgeliefert - mit und ohne den beiden oben gezeigten Zeilen am Dateiende. 
2. Der sshd vergleicht dabei die Klarnamen der Gruppenbezeichnung. Ich installiere gern für den Server EN Systeme und gebe Ihnen eine DE mui.

• Ein 2012 EN System mit DE mui hat administrators - > match!
• Alle späteren EN Systeme (2012 R2, 2016) mit DE mui haben Administratoren -> kein match!

Der folgende Code kommentiert die verantwortlichen Zeilen in der config aus. In meinem Setupscript für die älteren Serversysteme ist dieser Code bereits enthalten.

# Patch sshd config to allow administrators Group public Key logon
$Quelle="${Env:ProgramData}\ssh\sshd_config"
write-output "patch the sshd config on $Quelle"
Stop-Service -Name sshd
$Inhalt = Get-Content $Quelle
#search 2 lines contains administrators and insert commment sign
$Inhalt|foreach {if ($_ -match "administrators") {$Inhalt[$_.readcount-1]=$_.Insert(0,"#")}}
set-Content $Quelle $Inhalt
Start-Service -Name sshd

Alternative Lösung:

Die Schlüssel der entsprechenden User wirklich in die Datei c:\ProgramData\ssh\administrators_authorized_keys eintragen. Wie hier beschrieben, müssen dazu noch weitere Änderungen (Rechte an Datei und Inhalt C:\ProgramData\ssh\sshd_config) durchgeführt werden.

Den OpenSSH Server wieder loswerden

Stop-Service -Name sshd 
pushd
cd "${Env:ProgramFiles}\OpenSSH-Win64\" 
.\uninstall-sshd.ps1
popd
rm -recurse "${Env:ProgramFiles}\OpenSSH-Win64"
rm -recurse "${Env:ProgramData}\ssh"
Remove-NetFirewallRule -Name sshd

Zum Nachlesen

Ziel des Artikels war es, kurz und knapp alle Schritte zusammenzufassen.
Ausführlicher kann man in folgenden Artikeln nachlesen:
https://heinz-otto.blogspot.com/2018/06/windows-hat-jetzt-ssh.html
https://heinz-otto.blogspot.com/2017/01/per-ssh-remote-befehle-direkt-ausfuhren.html
https://docs.microsoft.com/en-us/windows-server/administration/openssh/openssh_server_configuration

Ersatz für ssh-copy-id

Manchmal kommt es vor, das auf einem System das Tool ssh-copy-id nicht vorhanden ist. Dann gibt es zwar einfache Alternativen, aber wenn man nicht genau weiß worauf es ankommt, wird es schnell kompliziert. Ich mache hier raus mal einen kurzen Artikel, weil ich auch ein paar Besonderheiten der Shell gelernt habe. 

Für die Verwendung unter Windows habe ich ein Powershellscript auf GitHub abgelegt.

Die einzelnen Schritte

Was macht ssh-copy-id bzw. was muss man berücksichtigen?
Alles in allem geht es darum, den Public Key von System 1 (lokal) nach System 2 (remote) zu übertragen um sich zukünftig vom System 1 am System 2 vereinfachten anzumelden und Befehle auszuführen.

• lokalen Public Key an das Remotesystem senden.
• im Remotesystem schauen ob der Pfad .ssh schon existiert, 
• wenn nicht: Pfad anlegen.
• in diesem Pfad schauen ob schon eine Datei .ssh/id_rsa.pub existiert, 
• wenn nicht: mit dem Public Key erzeugen.
• wenn schon vorhanden: prüfen ob der public Key schon enthalten ist,
• wenn nicht: Den Public Key hinzufügen.

Wer Hemmungen hat den Programmcode zu verwenden, kann die oben genannten Schritte auch manuell mit ls und nano (Public Key einfach mit copy&paste übertragen) abarbeiten.
 Schon die erste Aufgabe ist nicht trivial, hier wird mit der Pipe gearbeitet und in Abhängigkeit der Shell stehen dort unterschiedliche Subsysteme zur Verfügung. Variablen können nicht einfach transportiert werden.
Hinweise:

• Ich habe die Codestücke zur Erklärung ohne Maskierung geschrieben. So funktionieren sie aus der Windows cmd Konsole bzw. direkt in der Shell. Wie weiter unten erläutert muss $ und " maskiert werden!
• der letzte Befehl (cat bzw. echo) ist nur zum Test ob es funktioniert hat.

Am Einfachsten geht es in eine Datei.

cat .ssh/id_rsa.pub | ssh user@host "cat >kee.tmp;cat kee.tmp"

In Windows sind für Linux oft schädliche Zeilumbrüche (CR/LF) enthalten, dies Variante filtert die CR aus.

type .ssh\id_rsa.pub | ssh user@host "cat | tr -d '\r' >kee.tmp;cat kee.tmp"

Nach einigen Versuchen glaube ich mittlerweile, dass es mit diesem Konstrukt auch zuverlässig in eine Variable ($pub) kommt:

cat .ssh/id_rsa.pub | ssh user@host "pub=$(cat );echo $pub"
type .ssh\id_rsa.pub | ssh user@host "pub=$(cat | tr -d '\r');echo $pub"

Ob das Verzeichnis existiert ist schnell getestet, das ODER führt den Befehl danach nur bei false aus. Vorher wird mit dem umask Befehl die richtige Berechtigung für den neuen Pfad sichergestellt.

umask 077;test -d .ssh || mkdir .ssh

Auf ähnliche Art wird die Datei getestet und bei false einfach erzeugt:

test -f .ssh/authorized_keys || cat kee.tmp >.ssh/authorized_keys
test -f .ssh/authorized_keys || echo $pub >.ssh/authorized_keys

Danach wird der Inhalt der Datei mit grep auf Vorhandensein des Key geprüft und bei false wird der public Key angehängt. Bei der ersten Variante wird die tmp datei gelöscht.
Da Leerzeichen im Public Key sind, braucht grep den Suchstring in "ein zwei drei"!

grep -q "$(cat kee.tmp)" .ssh/authorized_keys  || cat kee.tmp >>.ssh/authorized_keys;rm kee.tmp
grep -q "$(echo $pub)" .ssh/authorized_keys  || echo $pub >>.ssh/authorized_keys

Die Einzeiler

Da die Dateinamen im Code öfters gebraucht werden, definiere ich sie am Anfang als Variable. Jetzt steht noch zusätzlich die Aufgabe den Einzeiler so zu schreiben, dass alle Sonderzeichen von der Shell richtig behandelt werden. Die folgenden Varianten haben als Ziel ein Linux System! Startet man den Befehl aus der Linux Shell muss mit dem Backslash \ maskiert werden:

cat .ssh/id_rsa.pub | ssh user@host "p='.ssh';akey=\$p'/authorized_keys'; okey='kee.tmp'; cat >\$okey; umask 077; test -d \$p || mkdir \$p; test -f \$akey || cat \$okey >\$akey; grep -q \"\$(cat \$okey)\" \$akey  || cat \$okey >>\$akey;rm \$okey"
cat .ssh/id_rsa.pub | ssh user@host "p='.ssh';akey=\$p'/authorized_keys'; pub=\$(cat ); umask 077; test -d \$p || mkdir \$p; test -f \$akey || echo \$pub >\$akey; grep -q \"\$(echo \$pub)\" \$akey || echo \$pub >>\$akey"

Startet man man den Einzeiler aus der cmd von Windows, müssen lediglich die " verdoppelt werden:

type .ssh\id_rsa.pub | ssh user@host "p='.ssh';akey=$p'/authorized_keys'; pub=$(cat | tr -d '\r'); umask 077; test -d $p || mkdir $p; test -f $akey || echo $pub >$akey; grep -q ""$(echo $pub)"" $akey || echo $pub >>$akey"

Baut man den Befehl in Powershell zusammen muss mit dem Backtick ` maskiert werden.

Der Pfad .ssh gilt für die meistens Standard Systeme mit Benutzeranmeldung. Bei vielen Spezialsystemen (Zielsystem) muss der Pfad angepasst werden!
z.B. /etc/dropbear bei OpenWrt.

cat .ssh/id_rsa.pub | ssh user@host "p='/etc/dropbear';akey=\$p'/authorized_keys'; pub=\$(cat ); umask 077; test -d \$p || mkdir \$p; test -f \$akey || echo \$pub >\$akey; grep -q \"\$(echo \$pub)\" \$akey || echo \$pub >>\$akey"

Die nächste Variante hat als Ziel ein Windows System!

ziel='user@host';pkey=$(cat ~/.ssh/id_rsa.pub);ssh $ziel "findstr /c:\"$pkey\" .ssh\authorized_keys ||mkdir .ssh ||echo $pkey >>.ssh\authorized_keys"

Maskierung von Sonderzeichen
Windows: Nur " muss verdoppelt werden -> ""
Linux: $ und " müssen mit \ maskiert werden -> \$ \"
Powershell: $ und " müssen mit ` maskiert werden -> `$ `"

Windows hat jetzt ssh

Seit vielen Jahren gibt es eine open-ssh Portierung für Windows im Entwicklungs/Beta/Schatten Dasein. Seit der Windows 10 Version 1803 (in 1709 noch als Beta) ist es jetzt offiziell als Feature enthalten und der Client sogar per Default installiert. Die interessante Frage:

Ersetzt das putty?

Wäre zumindest mein Ziel, dann muss man in Zukunft nichts nachinstallieren. Einfach mal versuchen:
Windows + r Taste zum Ausführen drücken und den Befehl eintippen:

ssh username@hostname-oder-IP-Adresse

Es kommt die Abfrage nach dem Passwort bzw. beim ersten Mal vornweg die typische Frage nach der Authentizität des Hostes. Schon ist die Terminalkonsole offen.

Verbindung mit ssh Key

Die OpenSSH Portierung stellt auch einige Tools wie ssh-keygen zur Verfügung. Wie üblich kann man sich einen Key Pärchen im Homedirectory im Pfad .ssh erzeugen lassen. Der Befehl

ssh-keygen -t rsa

schlägt als Verzeichnis vor: C:\Users\name/.ssh/id_rsa
Was natürlich bezüglich der Pfade irgendwie lustig aussieht: Windows trifft Linux.

Alle ssh Befehle mit Bezug auf die Benutzerumgebung müssen ein einem cmd Fenster in der Benutzerumgebung ausgeführt werden!
Geht ganz einfach mit Windows + r Taste + cmd
Die Verwendung einer Powershellkonsole ist wegen der Zeichenkodierung nicht zu empfehlen (siehe weiter unten).

Man kann, wie üblich, den Public Key auf andere System übertragen und sich dort ohne weitere Passworteingabe einloggen und Befehle ausführen (Blog Link zu verwandtem Thema).
Dazu unbedingt die Anmeldung am Windows entsprechend absichern!

Mit SCP Dateien kopieren

Eigentlich ist dies die Funktion von WinSCP &Co. Aber Windows bringt jetzt zumindest Zugriff über die Kommandozeile mit. Und wenn das mit dem Key ohne Passwort funktioniert - warum dann zweimal anmelden?
Kurz und knapp der Syntax um eine Datei zwischen den HomeDirs zu kopieren.
Wie immer: Quelle -> Ziel

scp Dateiname username@hostname:
scp username@hostname:Dateiname .

Während Remote als Ziel der Pfad entfallen kann (HomeDir) muss bei lokal als Ziel mindestens der "." (HomeDir) stehen.

Eigenheiten

Die Anführungszeichen!

• Remote Befehle müssen in die "Doppelten" gekapselt werden. Bei Linux gehen dort auch einfach 'Remote Befehl'.

Das Beispiel erzeugt lokal eine Datei mit dem Inhalt der Ausgabe des Remote Befehls:

ssh username@hostname "ls -l" >InhaltUserHomeDir.txt

Tools fehlen oder sind unvollständig!

• ssh-copy-id fehlt
• ssh-keygen -R funktioniert erst seit der Windows Version 1809

Ein paar Details und Workarounds findet man weiter hinten in diesem Artikel.

Die Antwort

Ich denke putty kann insgesamt mehr, aber wer genau das braucht, was ich hier beschrieben habe, kommt mit dem neuen ssh Client in Windows 10 (ab Version 1083) gut klar. Und die folgende Menüleiste finde ich komfortabler als putty.

Ein paar Tipps

Menüleiste mit den fertigen Verbindungen

Basis ist ein neuer Ordner mit Verknüpfungen darin.
Tipp: Wer ein MS Konto benutzt hat OneDrive, dann am Besten dort und es ist überall verfügbar!
Beispiel: Ordnername "ssh Hosts"

Rechtsklick auf Laufwerk oder Desktop / Neu / Ordner

in dem Ordner Rechtsklick / Neu /Verknüpfung

Rechtsklick Taskleiste / Neue Symbolleiste / Ordner auswählen

Zwei Angaben bei der Verknüpfung: 1 Fenster Befehl und 2. Fenster "Menüpunktname"
Nach dem Klick auf Neue Symbolleiste navigiert man zu dem gerade angelegten Ordner.

Fertiges ssh Menü

Beispiel für Verknüpfungsziele

• ssh username@192.168.1.1
• ssh pi@raspberrypi
• cmd

Wie man das noch etwas mit Powershell kombinieren kann zeige ich in diesem Artikel.

Putty Keys verwenden

Wenn man schon mit einem Putty Key gearbeitet hat, kann man den weiter verwenden. Wobei es bei eigenen Maschinen auch nicht schlimm und am Ende einfacher ist, einen Neuen zu erzeugen.
Man braucht dazu puttygen. In dem grafischen Tool wird mit Load das existierende ppk File mit dem Key geladen.
Den public Key kann man direkt mit der sichtbaren Schaltfläche exportieren, er muss aber dann noch weiter bearbeitet werden, deshalb hier irgendeinen temporären Namen (c:\users\Name\ppkPub.txt) verwenden und diesen mit Pfadangabe merken!
Den private Key müssen wir exportieren: Conversions / Export OpenSSH Key
Hier gleich den richtigen Ort und Namen angeben %userprofile%\.ssh\id_rsa
Dabei eventuell vorher den Pfad %userprofile%\.ssh erzeugen.
Jetzt unbedingt ein cmd Fenster und nicht Powershell öffnen! Der Public Key hat ein falsches Text Format (mehrzeilig). Das Tool ssh-keygen kann diesen umwandeln und gleich an die richtige Stelle schreiben:

ssh-keygen -i -f c:\users\Name\ppkPub.txt >%userprofile%\.ssh\id_rsa.pub

Wie und wo installieren?

Wer jetzt Stelle sucht wo es aktiviert und installiert wird, wird feststellen: Die Sache wird auch nicht übersichtlicher! Je nach dem wie man die Windows Suche benutzt, findet man jetzt:

• Apps & Features - dort findet man es unter dem Punkt Optionale Features verwalten.
• Programme hinzufügen oder entfernen - führt letztlich zu Apps & Features
• Optionale Features - führt direkt zum Punkt
• Windows-Features aktivieren oder deaktivieren - ist etwas völlig anderes. Obwohl man hier durchaus Komponenten aus Optionale Features findet.
• Systemsteuerung / Programm deinstallieren oder Ändern hat zwar Windows-Features als Unterpunkt aber die Programme die hier gelistet werden müssen nicht mit denen übereinstimmen die man unter Apps & Features findet.

Powershell ist immer eine gute Lösung, wenn man die Installation exakt beschreiben will. Auf docs.microsoft.com findet man unter dem Stichwort WindowsCapability ein paar cmdlets die aus der dism Verwaltung kommen. Deswegen ist der Syntax etwas "speziell" und man muss schon die Abfrage als Administrator ausführen!
Hinweis: Damit das Installationsthema nicht so einfach wird:

• Get-WindowsOptionalFeature liefert Windows-Features, 
• Get-Package liefert installierte Programme, 
• Get-AppxPackage liefert "vorinstallierte Programme".

Auf dem Server gibt es ein separates Set an CMD-lets z.B. Get-WindowsFeature, Install-WindowsFeature...

Einschränkungen Windows ssh Client

Leider existiert das Tool ssh-copy-id nicht. Deswegen muss man den Key mit ein paar Linux Befehlen übertragen. Ich habe dazu einen extra Artikel verfasst.

Das Tool ssh-keygen kann die known_hosts Datei nicht verwalten.
Update: Aktuell mit der Windows Version 1809 funktioniert es wie gewohnt.
Bisher wurde ein Versuch spartanisch quittiert:

ssh-keygen -R 192.168.178.82
Updating known_hosts is not supported in Windows yet.

Die Datei .ssh\known_hosts ist UTF-8 und mit CR LF kodiert. Man kann sie mit einem Texteditor einfach editieren und die fragliche Zeile löschen. Oder mit dem cat und grep Pendant von Windows geht es mit diesem Zweizeiler:

type .ssh\known_hosts > .ssh\known_hosts.org
findstr /V "192.168.178.82" .ssh\known_hosts.org > .ssh\known_hosts

Windows OpenSSH Server installieren

Edit: Ich habe hier einen Artikel mit einer ergänzenden Anleitung zur Installation des ssh Servers erstellt.

Das machen wir einfach alles mit Powershell.
Windows 10
Der Add Befehl kann hier nicht mit Wildcards umgehen.

Add-WindowsCapability -Online -Name  OpenSSH.Server~~~~0.0.1.0

Jetzt prüfen ob erfolgreich installiert wurde:

Get-WindowsCapability -Online | where name -match 'ssh'

Man kann auch die installierten Dienste prüfen, sie laufen aber noch nicht!

Get-Service -Name *ssh*

Also Dienste auf Automatic setzen und starten:

Get-Service -Name *ssh* | Set-Service -StartupType Automatic
Get-Service -Name *ssh* | Start-Service

Jetzt kann man sofort loslegen und sich zum ssh Server verbinden, eine separate Firewallregel braucht man nicht, die ist offenbar schon eingerichtet. Ich musste nichts weiter einrichten!

Man wird über ssh zur cmd Konsole verbunden, hier kann man dann auch Powershell starten! 

Man kann diese auch als default Konsole eintragen.

Hinweis:
Die Konfiguration des Servers liegt in C:\ProgramData\ssh.

Get-ChildItem -Path 'C:\ProgramData\ssh\'

Quelle zur Installation

Windows Server
Auf dem Windows Server ist ssh erst ab der ReleaseID 1709 integriert Windows Server 2016 ist die ID 1607.
Auch auf früheren Versionen kann man die aktuelle Win32 OpenSSH Version installieren.
Achtung: für den folgenden Code (und für eine aktuelle Management Umgebung) muss Windows Management Framework 5.1 installiert sein!

[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
$url = 'https://github.com/PowerShell/Win32-OpenSSH/releases/latest/'
$request = [System.Net.WebRequest]::Create($url)
$request.AllowAutoRedirect=$false
$response=$request.GetResponse()
$url = $([String]$response.GetResponseHeader("Location")).Replace('tag','download') + '/OpenSSH-Win64.zip'
Invoke-WebRequest $url -OutFile openssh.zip
Expand-Archive .\openssh.zip 'C:\Program Files\'
cd 'C:\Program Files\OpenSSH-Win64\'
.\install-sshd.ps1
New-NetFirewallRule -Name sshd -DisplayName 'OpenSSH Server (sshd)' -Enabled True -Direction Inbound -Protocol TCP -Action Allow -LocalPort 22
Start-Service -Name sshd
Set-Service -Name sshd -StartupType automatic

Tipp zur Anmeldung mit ssh an Windows 10

Ich melde mich mit einem Online Konto (Format user@domain) am Windows Desktop an. Windows legt intern zu diesem Online Konto eine Art "Kurznamen" an. Der ssh Server akzeptiert nur diesen kurzen Namen, eventuell kann man generell diesen Kurznamen verwenden, wenn man sich an anderen Diensten über das Netzwerk anmeldet.
Mit einer der folgenden Befehle kann man den Kurznamen ermitteln:

whoami
[Environment]::UserName
[System.Security.Principal.WindowsIdentity]::GetCurrent().Name

Hintergrund zur Powershell Textcodierung

In der Powershell (offenbar der > Befehl) werden Text Dateien nicht in der Codierung UTF-8 sondern mit der Codierung UCS-2 LE BOM angelegt. Abhilfe in Powershell? Schwierig.
Mit Notepad++ kann man die Codierung gut anschauen.

Ein paar Tests:

• Der Befehl innerhalb PS type .ssh/*.pub >catPub.txt erzeugt lokal eine Datei in UCS-2 LE BOM Codierung
• innerhalb cmd eine Datei in UTF-8 Codierung
• Der Befehl in CMD oder PS type .ssh/*.pub |ssh pi@192.168.178.80 "cat >picatpub.txt" erzeugt eine Datei in UTF-8 Codierung mit Windows CR LF
• Wandelt man jetzt mit nano picatpub.txt durch Speichern mit alt+m in Unix LF um dann macht ein erneuter Befehl in cmd type .ssh/*.pub |ssh pi@192.168.178.80 "cat >>picatpub.txt" eine Datei in UTF-8 Codierung mit Unix LF

Das bedeutet:

• die Übertragung über ssh / type ->  cat "filtert" die UCS-2 LE BOM Codierung aber nicht Windows CR LF.
• Der cat Befehl unter linux ändert existierende Unix LF nicht!
• Der type Befehl in PS mit Umleitung >> in eine existierende Datei mit UTF-8 führt zum Datensalat

Ein paar Ansätze:
Ansi ausgeben
UTF8-BOM erzeugen
Keys wieder löschen.
Winscp

Per ssh Remote Befehle direkt ausführen

Hinweis 2021: Dieser Artikel ist etwas in die Jahre gekommen und ich habe mittlerweile einige Dinge neu beschrieben:

https://heinz-otto.blogspot.com/2021/01/befehle-und-scripts-per-ssh-ausfuhren.html

https://heinz-otto.blogspot.com/2020/09/ssh-mit-public-key.html

https://heinz-otto.blogspot.com/2019/05/windows-von-fhem-aus-steuern.html

https://heinz-otto.blogspot.com/2018/07/ersatz-fur-ssh-copy-id.html

https://heinz-otto.blogspot.com/2018/06/windows-hat-jetzt-ssh.html

---