Montag, 15. Oktober 2018

Powershell und Windows Update

Der Hyper-V Server hat ein Management Interface welches aus mehreren Scripts besteht:
Auszug

  • sconfig.cmd
    • sconfig.vbs
    • WUA_SearchDownloadInstall.vbs
    • ...
Die VBS-Scripts liegen %systemroot%\system32\en-us\ (bzw. anderen Sprachen).
Gesteuert wird das Windows Update über die Windows Update API. Die Doku ist schwerer Stoff, ich habe mir von verschiedenen Seiten und aus dem oben erwähnten Script ein paar Dinge zusammen gelesen und will es hier kurz notieren.
Meine Scripts in dem Artikel sind alle nicht perfekt, sondern eher als Lösungsansatz gedacht. Damit kann man z.B. beim Hyper-V Server etwas mehr tun als nur mit der sconfig "Oberfläche".

Die Schritte etwas im Detail

Zuerst muss man festlegen welche Updates man suchen will (ein paar Details):
$Criteria = "IsInstalled=0 and Type='Software'"
$Criteria = "IsInstalled=0 and Type='Driver'"
Dann werden verschiedene Com Objecte eingerichtet und z.B. die Titel der verfügbaren Updates angezeigt.
$Searcher = New-Object -ComObject Microsoft.Update.Searcher
$SearchResult = $Searcher.Search($Criteria).Updates
# Titel anzeigen
$SearchResult|select Title
Powershell bietet an der Stelle etwas mehr Komfort zur Suche und Auswahl als die eigentliche API. Deshalb füge ich hier bewusst den Neubau der Update Collection ein. Eigentlich ist diese jetzt schon in $SearchResult enthalten.
$updatesToDownload = New-Object -ComObject Microsoft.Update.UpdateColl
$SearchResult|%{ if($_.Title -match "KB2267602") {$updatesToDownload.Add($_)}}
$updatesToDownload|select Title
Danach werden die gewünschten Updates heruntergeladen.
$Session = New-Object -ComObject Microsoft.Update.Session
$Downloader = $Session.CreateUpdateDownloader()
$Downloader.Updates = $updatesToDownload
$Downloader.Download()
Um es ganz korrekt zu machen, kann man noch eine Collection der wirklich heruntergeladenen Updates erstellen ...
$updatesToInstall = New-Object -ComObject Microsoft.Update.UpdateColl
$SearchResult|%{ if($_.isDownloaded) {$updatesToInstall.Add($_)}}
... um dann die Updates zu installieren.
$Installer = New-Object -ComObject Microsoft.Update.Installer
$Installer.Updates = $updatesToInstall
$Result = $Installer.Install()
Als Abschluss wird bei Bedarf ein Neustart ausgeführt.
If ($Result.rebootRequired) { shutdown.exe /t 0 /r }

Komplett in einem Script

Das Ganze als ein Script mit zwei Parametern am Anfang:
Den Type entweder weglassen (Alle suchen) oder auf Software oder Driver setzen.
Bei $compare kann man entweder nur einen "*" für "Alles" setzen oder wie im Beispiel den Begriff mit Wildcards für ein bestimmtes Update.
# Parameter
$Criteria = "IsInstalled=0 and Type='Software'"
$compare= "*" # "*KB2267602*"
# Suche notwendige Updates 
$Searcher = New-Object -ComObject Microsoft.Update.Searcher
$SearchResult = $Searcher.Search($Criteria).Updates
# Zusammenstellung Download Collection
$updatesToDownload = New-Object -ComObject Microsoft.Update.UpdateColl
$SearchResult|%{ if( $_.Title -like $compare ) {$updatesToDownload.Add($_)}}
#$updatesToDownload|select Title
#$updatesToDownload.Count
# Download Updates 
$Session = New-Object -ComObject Microsoft.Update.Session
$Downloader = $Session.CreateUpdateDownloader()
$Downloader.Updates = $updatesToDownload
if ($updatesToDownload.Count -gt 0) {$Downloader.Download()}
# Zusammenstellung Install Collection
$updatesToInstall = New-Object -ComObject Microsoft.Update.UpdateColl
$SearchResult|%{ if($_.isDownloaded) {$updatesToInstall.Add($_)}}
# Install Updates 
$Installer = New-Object -ComObject Microsoft.Update.Installer
$Installer.Updates = $updatesToInstall
$Result = $Installer.Install()
# Neustart wenn gefordert
If ($Result.rebootRequired) { shutdown.exe /t 0 /r }

Was lief bisher?

Man kann sich auch die gesamte Historie anzeigen lassen:
Wann wurde welches Update installiert? Die Zeiten werden in UTC angezeigt!
# Historie abfragen
$session = new-object -comobject Microsoft.Update.Session
$searcher = $session.CreateUpdateSearcher()
$history = $searcher.QueryHistory(0, $searcher.GetTotalHistoryCount())
$history |select Date,Title |more
Leider liefert das Ergebnis am Ende immer viele Leerzeilen.

Mehr Komfort

Die Powershell Gallery halt ein umfangreiches Scriptmodul "PSWindowsUpdate" bereit mit dem der Windows Update Service wohl sehr komfortabel behandelt werden kann. Ich habe mir das zunächst nur kurz angeschaut. Um das Script aus der PSGallery zuinstallieren muss man ein paar Vorbereitungen treffen, das ist hier ganz gut beschrieben.

Noch ein Special

In $SearchResult stehen auf den zweiten Blick noch mehr Informationen!
So erzeugt man eine Liste mit Detailinformationen, z.B. mit der UpdateID oder dem Download Link.
#$Criteria = “IsInstalled=0 and Type=’Software'”
$Searcher = New-Object -ComObject Microsoft.Update.Searcher
$SearchResult = $Searcher.Search($Criteria).Updates

foreach ($update in $SearchResult) {
  $title = $update.Title
  $guid = $update.Identity.UpdateId
  $title
  $guid
  $bundles = $update.BundledUpdates
     foreach($bundledUpdate in $bundles) {
        foreach($content in $bundledUpdate.DownloadContents) {
           if (!$content.IsDeltaCompressedContent) {
              $url = $content.DownloadUrl
              $url
            }
        }
    }
}

Mit der so ermittelten UpdateID wäre es auch möglich die Suche nach speziellen Paketen auszuführen:
$Criteria = "IsInstalled=0 and UpdateID='a3fafd03-b687-49e6-9df9-3963057ce376'"

Es gibt mit CIM und "PowerShell remoting session" auch einen Ansatz die VMs zentral zu patchen.

Sonntag, 16. September 2018

Virtuelle Maschinen erzeugen und administrieren mit Powershell

Kennt Ihr das? Hilfe Texte stimmen nicht, Beschreibungen funktionieren nicht? Das Thema Powershell und VM ist auch damit ganz schlimm gebeutelt.

VM anlegen

Man kann eine leere VM anlegen, das ergibt ein relativ mageres Ergebnis:
1GB RAM, Generation 1, keine Disk.
New-VM –Name 'Test1'
Will man in etwa das Ergebnis, was der Hyper-V Manager Wizard nur mit der Eingabe "Name" erzeugt, muss man es so machen:
$vm = 'Test2'
New-VM –Name $vm –NewVHDPath "$vm.vhdx" -NewVHDSizeBytes 127GB
Bisher haben wir VMs der Generation 1 erzeugt.
Viel mehr als im nächsten Befehl, kann man bei New-VM gar nicht angeben.
$vm = 'Test3'
New-VM –Name $vm -Generation 2 –MemoryStartupBytes 4GB –NewVHDPath "$vm.vhdx" -NewVHDSizeBytes 32GB
Alles weitere muss man mit Set-VM* Befehlen machen.

Startmedien - DVD Laufwerk

Das wichtigste dabei (und nicht ganz einfach wie man denkt) wäre ja die Angabe von Start- bzw. Installationsmedien. Kaum noch existieren wirklich optische Laufwerke, das Handling am Hyper-V Server wäre extrem unpraktisch. Man kann ohne weiteres ISO oder VHD Images einbinden, aber nur wenn sie lokal auf dem Hyper-V Server liegen. Microsoft hat eine sehr eigenartige Sicherheit eingebaut, wenn es um den Zugriff auf ein Image geht, welches auf einem Server liegt.
Auch die hier beschriebenen Wege funktionieren bei mir nur in der manuellen Art für VMs der Generation 1!

Mein Resumé: Startmedien gehen nur lokal

Mag sein es funktioniert in AD Umgebungen, ich habe es in einer Workgroup versucht, und wirklich viel experimentiert, ich bekomme es nicht hin! Man kann auf dem Hyper-V Host ein Image mounten und sich einen Überblick von den Laufwerksbuchstaben ausgeben lassen.
Mount-DiskImage -ImagePath \\omv1\shares\ISO\de_windows_7_All_with_sp1_x64_.iso
Get-Volume|? DriveType -eq CD-ROM

Für VMs der Generation 1 kann man nun im Hyper-V Manager das physische Laufwerk auswählen und zuweisen. (Mit Set-VMDvdDrive kann man nur echte DVD Laufwerke zuweisen)

Bei VMs der Generation 2 kann man nur mit lokalen ISO Images arbeiten!
Mann muss zunächst ein DVD Laufwerk hinzufügen.
Add-VMDvdDrive -VMName $vm -Path D:\ISO\Name.iso
Mit Set-VMDvdDrive kann man lokale ISO Images zuweisen und ändern.

Konfiguration Netzwerk, Bootreihenfolge und Prozessor

Damit der Startvorgang nicht am PXE Boot "verhungert" sollte man noch die Boot Reihenfolge festlegen
$VMDVD=Get-VMDvdDrive -VMName $vm
Set-VMFirmware -VMName $vm -FirstBootDevice $VMDVD
Oder man legt die Reihenfolge neu fest, die neue vhdx Datei kann sowieso nicht booten, er sollte in dem Fall beim ersten Mal von der DVD starten
$VMHDD=Get-VMHardDiskDrive -VMName $vm
Set-VMFirmware -VMName $vm -BootOrder $VMHDD, $VMDVD
Will man den (einzigen) Netzwerk Adapter noch mit dem (einzigen) virtuellen, externen Switch verbinden, kann man das so machen
Connect-VMNetworkAdapter -VMName $vm -SwitchName (Get-VMSwitch|? Switchtype -eq External).Name
Während wir den mindest RAM bei der Einrichtung festgelegt haben, hat die VM bisher nur einen Prozessor. Man kann so alle verfügbaren Prozessoren zuweisen
Set-VMProcessor -VMName $vm -Count (Get-VMHost).LogicalProcessorCount

Zusammenfassung

Hier ein Template/Script für eine neue VM, Der VM Name kann als Parameter übergeben werden oder wird abgefragt (Mandatory=$true).
In der ersten und zweiten Zeile werden alle Parameter gesetzt. Ich habe deshalb auf übermäßig viele Variablen verzichtet.
<#
.SYNOPSIS 
    Das Script erstellt eine neue virtuelle Maschine
.DESCRIPTION 
    Das Script erstellt eine neue virtuelle Maschine
.EXAMPLE 
    CreateVM Name 
.NOTES 
    Generation 2, 32 GB HDD, 4 GB RAM, alle Prozessoren
#>
#region Params
param(
    [Parameter(Position=0, Mandatory=$true,HelpMessage="Name der VM",ValueFromPipeline=$false)]
    [System.String]
    $vm=""
)
#endregion 

New-VM –Name $vm -Generation 2 –MemoryStartupBytes 4GB –NewVHDPath "$vm.vhdx" -NewVHDSizeBytes 32GB
Add-VMDvdDrive -VMName $vm 
$VMDVD=Get-VMDvdDrive -VMName $vm
$VMHDD=Get-VMHardDiskDrive -VMName $vm
Set-VMFirmware -VMName $vm -BootOrder $VMHDD, $VMDVD
Connect-VMNetworkAdapter -VMName $vm -SwitchName (Get-VMSwitch|? Switchtype -eq External).Name
Set-VMProcessor -VMName $vm -Count (Get-VMHost).LogicalProcessorCount

Für die DVD habe ich mal noch einen "Würgaround" gefunden.
Dieser Mehrzeiler schaut nach, ob die ISO Datei im lokalen Pfad schon existiert und kopiert diese ansonsten dahin.
$DVD = "name.iso"
$Ziel = 'D:\ISO\'
$Quelle = '\\omv1\shares\iso\'
$Diff = Compare-Object -ReferenceObject (gci -Path $Ziel) -DifferenceObject (gci -Path $Quelle)
Copy-Item -Path (($Diff|? InputObject -like $DVD).InputObject).FullName -Destination $Ziel
# DVD einlegen
Set-VMDvdDrive -VMName $vm -Path $Ziel$DVD

Damit das lokale Verzeichnis nicht vermüllt, kann man ja von Zeit zu Zeit die ISOs entfernen, die nicht mehr eingebunden sind.
$Ziel = 'D:\ISO\'
$InUse = (Get-VMDvdDrive -VMName *|? Path -like $Ziel*).Path
$Exist = (gci -Path $Ziel).Fullname
$Diff = Compare-Object -ReferenceObject $Exist -DifferenceObject $InUse
Remove-Item ($Diff|? SideIndicator -eq '<=').InputObject -confirm

Aufräumen

Dieser Einzeiler löscht alle VMs und deren virtuelle HDDs, deren Name mit Test beginnt.
Jeder Löschvorgang verlangt nach Bestätigung! Bitte genau hinschauen, ich übernehme keine Verantwortung!
Ich hoffe, dass ich in einem Jahr noch weiß, wie dieser Einzeiler funktioniert.
% ist das Kürzel für ForEach, $_ Ist das aktuelle Element der Schleife
-process enthält den Ausführungsteil(, beide Befehlsteile werden in getrennten Schleifen abgearbeitet.)
-InputObject die Eingabe
% -process {Remove-Item (Get-VMHardDiskDrive -VMName $_.name).Path -Confirm ; Remove-VM -VMName $_.name} -inputobject (Get-VM -VMName Test*)

Informationen

Man kann sich relativ schnell einen Überblick über die Cmdlets verschaffen und detaillierte Hilfe abrufen. (Leider stimmt auch in den Hilfetexten nicht alles)
Get-Help Hyper-V
Get-Help Set-VM*

Mittwoch, 5. September 2018

Storage Pool auf dem Hyper-V Server verwalten

Wie bekommt man einen gespiegeltes HDD System, welches unter Windows Server 2012 als Storage Pool eingerichtet war, wieder online?

Ein paar Befehle für die  Analyse des Storage mit Powershell 

So bekommt man ein Bild der vorhandenen Disks:
get-disk

Number Friendly Name Serial Number                    HealthStatus         OperationalStatus      Total Size Partition
                                                                                                             Style
------ ------------- -------------                    ------------         -----------------      ---------- ----------
1      Samsung SS... S1DBNSAF878015M                  Healthy              Online                  232.89 GB GPT
0      Samsung SS... S21PNSAG155972R                  Healthy              Online                  232.89 GB GPT
6      VD1           {05bf1a4e-44d2-11e5-80d3-7824... Healthy              Offline                   1.82 TB GPT
5      VD2           {dcdf1498-41bd-11e5-80cf-7824... Healthy              Offline                    930 GB GPT
7      TOSHIBA Ex...            92N5P3KXT             Healthy              Online                  931.51 GB MBR
Zwei Platten sind Offline, die Disks 2,3 und 4 "fehlen".

Die Abfrage der Virtuellen Disk ergibt folgendes Bild:
get-virtualdisk

FriendlyName ResiliencySettingName OperationalStatus HealthStatus IsManualAttach    Size
------------ --------------------- ----------------- ------------ --------------    ----
VD1          Mirror                OK                Healthy      False          1.82 TB
VD2          Simple                OK                Healthy      False           930 GB
Obwohl die eigentlichen Laufwerke im Storage Pool ausgeblendet werden, kann man sich die echten Laufwerke anzeigen lassen:
Get-physicaldisk

FriendlyName              SerialNumber    CanPool OperationalStatus HealthStatus Usage            Size
------------              ------------    ------- ----------------- ------------ -----            ----
Samsung SSD 840 EVO 250GB S1DBNSAF878015M True    OK                Healthy      Auto-Select 232.89 GB
WDC WD2003FYPS-27Y2B0     WD-WCAVY7115101 False   OK                Healthy      Auto-Select   1.82 TB
TOSHIBA External USB 3.0  92N5P3KXT       False   OK                Healthy      Auto-Select 931.51 GB
Samsung SSD 850 EVO 250GB S21PNSAG155972R False   OK                Healthy      Auto-Select 232.89 GB
ST31000333AS              9TE24JDS        False   OK                Healthy      Auto-Select  931.5 GB
WDC WD2003FYPS-27Y2B0     WD-WCAVY5334150 False   OK                Healthy      Auto-Select   1.82 TB

Get_PhysicalDisk kann aber mehr, mit Hilfe von Format-List habe ich mal eine Ausgabe der Zuordnung zu den Hardware Ports gebastelt
Get-PhysicalDisk| Select-Object -Property DeviceId,PhysicalLocation,BusType,MediaType,FriendlyName,SerialNumber| Sort-Object -Property DeviceId |Format-Table

DeviceId PhysicalLocation                BusType MediaType   FriendlyName              SerialNumber
-------- ----------------                ------- ---------   ------------              ------------
0        Integrated : Adapter 0 : Port 1 SATA    SSD         Samsung SSD 850 EVO 250GB S21PNSAG155972R
1        Integrated : Adapter 1 : Port 0 SATA    SSD         Samsung SSD 840 EVO 250GB S1DBNSAF878015M
2        Integrated : Adapter 1 : Port 1 SATA    HDD         ST31000333AS              9TE24JDS
3        Integrated : Adapter 1 : Port 4 SATA    HDD         WDC WD2003FYPS-27Y2B0     WD-WCAVY5334150
4        Integrated : Adapter 1 : Port 5 SATA    HDD         WDC WD2003FYPS-27Y2B0     WD-WCAVY7115101
6        Integrated : Adapter 0 : Port 0 USB     Unspecified TOSHIBA External USB 3.0  92N5P3KXT

Den Zusammenhang zwischen Storage Pool, VirtualDisk und PhysicalDisk kann man auch anzeigen lassen. Dazu braucht man zunächst ein Object auf den Storage Pool
$stpool = (Get-StoragePool -FriendlyName "SP1")
Get-VirtualDisk -StoragePool $stpool

FriendlyName ResiliencySettingName OperationalStatus HealthStatus IsManualAttach    Size
------------ --------------------- ----------------- ------------ --------------    ----
VD1          Mirror                Degraded          Warning      False          1.82 TB

Get-PhysicalDisk -StoragePool $stpool

FriendlyName          SerialNumber    CanPool OperationalStatus HealthStatus Usage          Size
------------          ------------    ------- ----------------- ------------ -----          ----
WDC WD2003FYPS-27Y2B0 WD-WCAVY7115101 False   OK                Healthy      Retired     1.82 TB
WDC WD2003FYPS-27Y2B0 WD-WCAVY5334150 False   OK                Healthy      Auto-Select 1.82 TB
Für die Information auf welcher Disk das Volume des Systemlaufwerkes ist, habe ich diese Befehlskette gefunden.
Get-Disk (Get-Partition | ? isboot).DiskNumber

Storage Pool Disk wieder aktivieren

Ich möchte das VD1 wieder online ist, dies wird nämlich nicht automatisch getan, wenn der Storagepool an einen andere Maschine gehangen wird. Da VD1 eine (virtuelle) Disk ist, geht das mit dem set-disk Cmdlet
Set-Disk -Number 6 -IsOffline $False
Es gab bei mir die Situation, dass eine Disk nach dem Import von einer Physical Disk in eine vhdx Datei mit dem Hyper-V Manager sowohl offline als auch readonly war. Auch readonly lässt sich mit Set-Disk beheben.
Set-Disk -Number 5 -IsReadonly $False

Storage Pool Disk Fehler behandeln

Versucht man in einem StoragePool, der 2 HDD enthält und darin eine Mirror VirtualDisk - eine HDD geordnet zu entfernen und diese danach durch eine Andere zu ersetzen, funktioniert das praktisch nicht. Obwohl man eine Platte als Retired markiert, lässt sie sich nicht entfernen. Man muss erst einen neue HDD zum StoragePool hinzufügen. Aber selbst das ist mir nicht richtig gelungen.
Dies habe ich versucht:
Set-PhysicalDisk -FriendlyName "WDC WD2003FYPS-27Y2B0" -SerialNumber WD-WCAVY7115101 -Usage Retired
Repair-VirtualDisk -FriendlyName "VD1"
# Zwei Varianten um das Objekt der richtigen PhysicalDisk zu bekommen
$PDToRemove = Get-PhysicalDisk | Where-Object { $_.Usage -eq 'Retired'}
$PDToRemove = Get-PhysicalDisk -FriendlyName "WDC WD2003FYPS-27Y2B0" -SerialNumber WD-WCAVY7115101
Remove-PhysicalDisk -PhysicalDisks $PDToRemove -StoragePoolFriendlyName "SP1"
Aber diese Aktion endet mit einem Fehler:
StorageWMI 48011,Remove-PhysicalDisk

Storage Pool entfernen

Erkenntnis: Storage Pool sieht gut aus, ist mir aber so undurchsichtig! Nach der kompletten Sicherung der Daten, habe ich einfach alles entfernt:
Set-Disk -Number 6 -IsOffline $true
Remove-VirtualDisk -FriendlyName "VD1"
Remove-StoragePool -FriendlyName "SP1"
Jetzt tauchen die Platten 3 + 4 wieder normal in der Ansicht auf (get-disk) und können normal verwendet werden. Um sie völlig leer zu machen verwendet man Clear-Disk
Clear-Disk -Number 3
Clear-Disk -Number 4
Get-Disk |Where-Object PartitionStyle –Eq "RAW" |Initialize-Disk 

Um eine neue Partition anzulegen, einen bestimmten Laufwerksbuchstaben zu vergeben und es gleich zu formatieren, kann man so vorgehen.
New-Partition -DiskNumber 3 -UseMaximumSize -DriveLetter S |Format-Volume

Dienstag, 4. September 2018

Partitionen und virtuelle Disk

In Hyper-V per default eine neue virtuelle Platte (VHDX) erstellt - und dann...

  • stellt man fest, dass Platten mit dynamischer Größe mit der Zeit viel langsamer sind als virtuelle Platten mit fester Größe. 
  • Das virtuelle Platten auf einer SSD viel schneller sind als auf einer herkömmlichen HDD
  • Das es jetzt ziemlich verschwenderisch ist, 127 GB auf der knappen SSD zu belegen, um eine virtuelle Platte zu hosten, die mit weniger als der Hälfte üppig ausgestattet wäre.

Dafür ein kurzes HowTo, wie man von dieser Ausgangssituation zum gewünschten Ziel kommt. Für einen Trockentest, kann man so eine virtuelle Disk zum Test anlegen. Die verwendeten Größen sind nur als Beispiel zu sehen.

Test Datei erstellen

Die typische System Platte sieht in etwa so aus.
PartitionNumber  DriveLetter Offset                                        Size Type
---------------  ----------- ------                                        ---- ----
1                            1048576                                     450 MB Recovery
2                            472907776                                    99 MB System
3                            576716800                                    16 MB Reserved
4                C           593494016                                126.45 GB Basic
Die folgende Zeilen erstellen eine vhdx Datei mit genau dieser Struktur. Das Windows Upgrade baut manchmal noch eine Partition hinten dran.
Dummerweise gibt es die x-VHD Powershell-Cmdlets nur, wenn die Hyper-V Rolle komplett installiert ist. Alternativ kann man dafür diskpart verwenden.
$VDisk = "D:\VHD\TestBase.vhdx"
New-VHD -Path $VDisk -SizeBytes 127GB
$Disk = Mount-VHD -Path $VDisk -Passthru|Get-Disk
$Disk
$Disk|Initialize-Disk -Passthru|Remove-Partition -PartitionNumber 1
$Disk|New-Partition -Size 450MB -GptType '{de94bba4-06d1-4d40-a16a-bfd50179d6ac}'
$Disk|New-Partition -Size 99MB -GptType '{c12a7328-f81f-11d2-ba4b-00a0c93ec93b}'
$Disk|New-Partition -Size 16MB -GptType '{e3c9e316-0b5c-4db8-817d-f92df00215ae}'
$Disk|New-Partition -Size ((get-disk $Disk.Number).LargestFreeExtent-450MB) -AssignDriveLetter|Format-Volume
$Disk|New-Partition -UseMaximumSize -GptType '{de94bba4-06d1-4d40-a16a-bfd50179d6ac}'
$DriveLetter = ($Disk|Get-Partition|Get-Volume|? Driveletter -ne $null).DriveLetter
$path = ($DriveLetter+":\Test.tmp");$file = [io.file]::Create($path);$file.SetLength(10GB);$file.Close()
Dismount-VHD -Path $VDisk
Initialize-Disk erzeugt per default eine "reserved" Partition. Da ich die Original Struktur haben wollte, wird diese zunächst gelöscht und an dritter Stelle wieder erzeugt. Für diese Test vhdx ist das unerheblich, im produktiven Umfeld würde ich das nicht machen.
Die vorletzte Zeile enthält keine Pipe sondern mehrere Befehle um einfach einen große Datei in dem Volume zu erzeugen.

Minimierung der Ausgangsdatei

Die folgende Befehlsfolge reduziert die Partition in der Datei auf ein Minimum und reduziert die vhdx Datei auf ein Minimum. Zunächst mounten wir die vhdx Datei und erhalten als Ausgabe die Tabelle der Volumes.
Mount-VHD -Path $VDisk -Passthru| Get-Disk | Get-Partition | Get-Volume
Die folgende Aktion kann eine Partition auf minimale Größe bringen. Den richtigen Laufwerksbuchstaben einsetzen:
$DriveLetter = "E"
$size = Get-PartitionSupportedSize -DriveLetter $DriveLetter
Resize-Partition -DriveLetter $DriveLetter -Size $size.sizeMin
Manchmal baut Windows Update an das Ende der Systemplatte eine Wiederherstellungspartition, diese ist eigentlich unnütz und verhindert die Verkleinerung der gesamten Disk.
So kann man Partitionen entfernen. Vorsicht! Dieser Befehl löscht Daten, fragt aber vorher nach. Bitte genau lesen! 
Der zweite Befehl listet uns den Inhalt, im dritten Befehl muss die richtige PartitionNumber nn gesetzt werden.
$Disk = Get-Disk (Get-Partition -DriveLetter $DriveLetter).DiskNumber|Get-Partition
$Disk
$Disk |? PartitionNumber -eq nn|Remove-Partition
Hat man die letzte Partition verkleinert, kann man auch die gesamte Disk verkleinern:
Dismount-VHD -Path $VDisk
Resize-VHD -path $VDisk -ToMinimumSize
Zum Schluss kann man noch die Dateigröße der vhdx Datei verringern.
Optimize-VHD -path $VDisk -mode full
Jetzt befindet sich die vhdx in minimaler Größe und kann z.B. schneller kopiert werden.

In Form bringen

Anschließend soll die Datei wieder in eine produktive Form gebracht werden. Zunächst die komplette Disk auf die gewünschte Größe bringen.
Resize-VHD -path $VDisk -SizeBytes 500MB
Danach Mounten und die Struktur anschauen, das letzte Volume kann vergrößert werden.
In der zweiten Zeile den richtigen Laufwerksbuchstaben einsetzen!
Mount-VHD -Path $VDisk -Passthru| Get-Disk | Get-Partition | Get-Volume
$DriveLetter = "E"
$size = Get-PartitionSupportedSize -DriveLetter $DriveLetter
Resize-Partition -DriveLetter $DriveLetter -Size $size.sizeMax
Jetzt noch die virtuelle Disk vom dynamischen in ein festes Format wandeln. Dabei wird eine neue Datei erzeugt.
Dismount-VHD -Path $VDisk
Convert-VHD -path $VDisk –DestinationPath V:\NeuerName.vhdx –VHDType Fixed

Nützlich

Zwischen den einzelnen Schritten, kann immer mal der momentane Zustand der vhdx Datei und der Partition überprüft werden.
Get-VHD $VDisk
Get-PartitionSupportedSize -DriveLetter $DriveLetter
So ermittelt man die Werte für Disk und Partition.
Get-Disk
Get-Partition -DiskNumber 8
$size = (Get-PartitionSupportedSize -DiskNumber 8 -PartitionNumber 2)
Resize-Partition -DiskNumber 8 -PartitionNumber 2 -Size $size.SizeMax
Die x-VHD Powershell Cmdlets lassen sich etwas umständlicher durch diskpart Befehle ersetzen
create vdisk file="c:\ttt\testBase.vhdx" maximum=1024
sel vdisk file="c:\ttt\testBase.vhdx"
attach vdisk
detach vdisk
expand vdisk maximum=20000
Anbinden und auswerfen der vhdx Datei geht auch mit dem Windows Explorer.
Die Konvertierung kann man auch mit dem Hyper-V Manager durch Import der vhdx Datei bewerkstelligen.

Will man mehr als die Standardausgabe von einem Cmdlet sehen, hilft das Format-List Cmdlet. Es gibt alle Elemente in einzelnen Zeilen aus.
Get-Disk |Format-List -Property *
Dadurch erhält man z.B. die Information über Elemente nach denen man auch Filtern kann.
Get-Disk |Where-Object {$_.Bustype -Eq "USB"}|

Ist die Zielfestplatte beim Konvertieren in den Type Fixed zu klein, ist die Fehlermeldung ziemlich unspezifisch:
Convert-VHD : Fehler beim Konvertieren des virtuellen Datenträgers.
Fehler beim Konvertieren von "d:\vhd\hyper-v-2016.vhdx".
In Zeile:1 Zeichen:1
+ Convert-VHD -path $VDisk –DestinationPath V:\Hyper-V2016-C.vhdx –VHDT ...
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Convert-VHD], VirtualizationException
    + FullyQualifiedErrorId : OperationFailed,Microsoft.Vhd.PowerShell.Cmdlets.ConvertVhd

Montag, 27. August 2018

Hyper-V Server verwenden

Der Plan: Hyper-V Server 2016 (download) als Grundlage für einen kleinen Server verwenden und darauf u.a. einen bisherigen Windows Server 2012R als virtuelle Maschine zu betreiben. Nebenbei sollen dann eventuell noch andere kleinere System laufen.
  • Hardware Unabhängigkeit (es gibt einige Hardwaretreiber nicht als Serverversion, auch von namhaften Herstellern wie Intel) 
  • Kein Leistungsverlust
  • Headless Betrieb, komplett von Windows 10 remote administrierbar
Ich hatte dazu schon einmal einen Artikel, den will ich hiermit konkretisieren.

Installation und Einrichtung des Servers


  • Ganz klassisch mit USB Stick, Monitor und Tastatur. Standardeinstellungen, die System Partition auf der SSD soll später verkleinert werden. 
  • System english aber Spracheinstellung deutsch, Zeitzone Berlin. 
  • Beim ersten Boot vom USB Stick auf UEFI oder BIOS Modus achten!

Mit dem Programm sconfig (nach der Anmeldung im Vordergrund und jederzeit wieder mit sconfig aufrufbar) wird folgendes eingestellt:

2) Computer Name
4) Configure Remote Man. (4-3)Enabled + ...Response to Ping
7) Remote Desktop (7-e-2)     Enabled (all Clients) ...less secure

Für den Computer Namen will er neu starten, deswegen kann man den Punkt zuletzt machen und anschließen braucht man die lokale Anmeldung nicht  mehr. Es geht alles über RDP.

Die weiteren Einstellungen erfolgen in Powershell, dazu kann man einfach das cmd Fenster hinter dem sconfig Fenster in den Vordergrund holen und Powershell starten.

Remote Desktop

Funktioniert sofort nach der obigen Grundkonfiguration, aber eben nur wenn nicht die Option 1) more secure eingestellt wurde. Das liegt offenbar an einem, nach der Installation noch nicht vorhandenem Patch des CredSSP. Nach dem Windows Update des Systems funktioniert auch die Option 1).

Netzwerk und Firewall

Windows typisch befindet sich das Netzwerk zunächst in der Category Public. Damit sind aber viele Firewall Regeln schärfer und viele Zugriff nicht zugelassen. Das ist im internen Netzwerk nicht sinnvoll, also ändern auf private. Der erste Befehl liefert uns die Informationen zum Netzwerk:
Get-NetConnectionProfile


Name             : Network
InterfaceAlias   : Ethernet
InterfaceIndex   : 3
NetworkCategory  : Public
IPv4Connectivity : Internet
IPv6Connectivity : NoTraffic
Der folgende Befehl setzt den Anschluss auf Private:
Set-NetConnectionProfile -InterfaceIndex 3 -NetworkCategory Private
Den Erfolg kann man leicht mit dem vorhergehenden Befehl überprüfen.
Die IP Adresse sollte fest sein, der DHCP Server und wenn vorhanden der DNS Server sollten so konfiguriert werden, dass der die IP Adresse fest zugeordnet ist und der Computer Name als FQDN aufgelöst werden kann.

Remote Management

Dafür sind Powershell Remoting und der Credential Security Support Provider zu aktivieren.
Enable-PSRemoting
Enable-WSManCredSSP -Role server
Damit ist die Server Konfiguration abgeschlossen

Einrichtung am Client Windows 10

Das Netzwerk und die Firewall sind zunächst auch so einzurichten, dass die NetworkCategory  : Private ist (siehe oben).
Der Computer Name des Hyper-V Servers muss als FQDN auflösbar sein, bitte so prüfen.
nslookup name.domain
Funktioniert das nicht, kann/muss ein Eintrag in der Datei C:\Windows\System32\drivers\etc\hosts gemacht werden.

Hyper-V-Verwaltungstools

Man kann sich anzeigen lassen, welche Hyper-V Features schon installiert sind
Get-WindowsOptionalFeature -Online -FeatureName *hyper-v*  | where state -eq enabled| select DisplayName, FeatureName
Will man nur die Management Tools installieren, geht prinzipiell mit Powershell, ist jedoch noch nichts von Hyper-V installiert kommt leider ein Fehler. Es funktioniert nur im Dialog so wie gewünscht.
Windows Features aktivieren oder deaktivieren (nicht Apps & Features und nicht optionale Features)
Eine Krücke mit Powershell wäre: Alles installieren und die Hyper-V-Plattform wieder deinstallieren.
Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V-Management-PowerShell -all
disable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V
Allerdings ist dafür wegen der Installation von Hyper-V-Plattform ein Neustart fällig.

Vertrauen in einer Workgroup 

Eigentlich ist die Empfehlung von Microsoft auf dem Client als Erstes ebenfalls den Befehl Enable-PSRemoting auszuführen. Allerdings aktiviert das primär auch die Remote Verwaltung des Clients.
Es geht auch etwas sparsamer:

$server = "name.domain"
$user = "administrator"
Start-Service -Name winrm
Set-Item WSMan:\localhost\Client\TrustedHosts -Value $server
Stop-Service -Name winrm
cmdkey /add:$server /user:$user /pass

Jetzt öffnet man den Hyper-V Manager und fügt unter dem Punkt "Verbindung mit Server herstellen" den Server mit dem Namen "name.domain" (also exakt so wie bisher verwendet) ohne Angabe eines Benutzers hinzu.

Danke, dass ich dafür diesen Artikel lesen durfte.

Remote Shutdown für den Server einrichten

Die Konfiguration wird auf dem Hyper-V Server in der Powershellkonsole durchgeführt.

Benutzer anlegen

Das Passwort wird abgefragt.
New-LocalUser "UserShutdown"

Benutzerrechte festlegen

Dazu muss zunächst ein PS Script Modul heruntergeladen und eingebunden werden.
$url = "https://gallery.technet.microsoft.com/scriptcenter/Grant-Revoke-Query-user-26e259b0/file/198800/1/UserRights.psm1"
$output = "UserRights.psm1"
# $start_time = Get-Date
Invoke-WebRequest -Uri $url -OutFile $output
# Write-Output "Time taken: $((Get-Date).Subtract($start_time).Seconds) second(s)"
Import-Module .\UserRights.psm1

User Rechte erteilen 
Grant-UserRight -Account "UserShutdown" -Right SeRemoteShutdownPrivilege"

Firewall

Regeln für "File and Print" aktivieren
netsh advfirewall firewall set rule group=”File and Printer Sharing” new enable=Yes

Volume verkleinern

Ich würde gern noch das Volume C auf dem Hyper-V Server minimieren. 48 GB sollten dafür ausreichen, derzeit ist das Volume 127 GB groß. Die Aufgabe erledigt man einfach mit:
diskpart

Am Prompt von diskpart lässt man sich die Plattenkonfiguration zeigen, wählt die gewünschte Partition und verkleinert sie um den Betrag 80000 MB. (1024 MB = 1 GB)
list disk
sel disk 0
list part
sel part 4
shrink desired=80000
exit

Probleme

Scheinbar ziemlich aktuell taucht ein Problem auf, wenn die CredSSP der beiden Maschinen einen unterschiedlichen Patchlevel haben. Ich konnte mich zwar mit dem Hyper-V Manager zu meinem Hyper-V Server verbinden und kann den komplett administrieren, eine Verbindung zu den Virtuellen Gastmaschinen schlug aber wieder mit der Meldung "CredSSP ... Oracle ... Remediation ... linkid=866660" fehl. Abhilfe schafft in dem Fall auf die Schnelle:
gpedit und diese Einstellung am Client
Quelle

Dies und das

Firewall aus und einschalten
NetSh Advfirewall set allprofiles state off
NetSh Advfirewall set allprofiles state on


Firewall Rules abfragen
Get-NetFirewallRule -name *

Donnerstag, 23. August 2018

FritzBox mit TR064 abfragen

TR064 oder TR-064 ist ein Schnittstellen Protokoll für DSL Router. Hier findet man nähere Information und ein paar Dokumente.
Das Modul FRITZBOX von FHEM kennt zwei Kommandos für TR064
get FritzBoxName tr064ServiceList
gibt einen strukturierte List mit Funktionen und Kommandos.
get FritzBoxName tr064Command Kommando
lässt TR064 Kommandos an die Fritzbox senden und man bekommt etwas zurück. Aber wie kommt man zu dem Syntax für "Kommando"?
Hier habe ich im Forum mal einen Beispielbefehl gefunden, von dem habe ich mich versucht weiter zu hangeln.
get FB7490 tr064Command WANPPPConnection:1 wanpppconn1 GetInfo
Gibt eine Liste zurück aus der man Werte zu DSL Verbindung auslesen könnte.
  • Aber was gibt es denn noch so? 
  • Wie kommt man von der Service Liste zum Befehl?
Beispiel aus der Service Liste
 Spec: http://192.168.90.1:49000/wancommonifconfigSCPD.xml    Version: 1.0
 Service: WANCommonInterfaceConfig:1     Control: wancommonifconfig1
----------------------------------------------------------------------------------------------------------------------------------
  GetCommonLinkProperties ( ) = ( NewWANAccessType NewLayer1UpstreamMaxBitRate NewLayer1DownstreamMaxBitRate NewPhysicalLinkStatus )
  GetTotalBytesSent ( ) = ( NewTotalBytesSent )
  GetTotalBytesReceived ( ) = ( NewTotalBytesReceived )
  GetTotalPacketsSent ( ) = ( NewTotalPacketsSent )
  GetTotalPacketsReceived ( ) = ( NewTotalPacketsReceived )
  X_AVM-DE_SetWANAccessType ( NewAccessType )
  X_AVM-DE_GetOnlineMonitor ( NewSyncGroupIndex ) = ( NewTotalNumberSyncGroups NewSyncGroupName NewSyncGroupMode Newmax_ds
                                    Newmax_us Newds_current_bps Newmc_current_bps Newus_current_bps Newprio_realtime_bps
                                    Newprio_high_bps Newprio_default_bps Newprio_low_bps )
Für ein funktionierendes tr064Command braucht man:
  1. Aus der Überschrift: den Wert hinter Service: 
  2. den Wert hinter Control: 
  3. Die Werte für Action stehen in der Tabelle links,
  4. dahinter steht in der Klammer das Argument 
und auf der rechten Seite (hinter dem Gleichheitszeichen) stehen die zu erwartenden Werte.

Das Kommando wird im Prinzip so zusammen gesetzt:
get FritzboxName tr064Command Service Control Action Argument Value
Beispiel 1: ohne Argument (weil die Klammer leer ist)
get FB7490 tr064Command WANCommonInterfaceConfig:1 wancommonifconfig1 GetCommonLinkProperties
Beispiel 2: Argument und Value
get FB7490 tr064Command WANCommonInterfaceConfig:1 wancommonifconfig1 X_AVM-DE_GetOnlineMonitor NewSyncGroupIndex 0

Während man ja bis zum Argument noch über die Service Liste kommt, wird es dann beim Value irgendwie schwierig. Zumindest gab es in dem Dokument  dann Anhaltspunkte, das habe ich gefunden über Google mit dem Begriff aus der Überschrift des Service Abschnittes "wancommonifconfigSCPD"

Ansonsten hilft probieren, suchen und raten.

Mittwoch, 22. August 2018

QR Code für WiFi Zugang

Ohne viel zu tippen und eventuell falsche Zahlen und Buchstaben kommt man mit modernen Android und IOS Systemen per Scan ins Wlan. WiFi Zugang (WLAN) teilen heisst der Menüpunkt im Smartphone wenn man mit dem Wlan verbunden ist. Und das Smartphone zeigt in dem Moment genau einen QR Code, den man mit dem anderen Smartphone scannen kann und mit einem Klick kann man sich verbinden.
Also einfach einen QR Code fürs Wlan basteln!

Es gibt dazu einen standardisierten String der bereitgestellt werden muss. Die einzelnen Textelemente sind durch ; getrennt. Die "" können normalerweise entfallen.
WIFI:T:WPA;P:"password";S:"SSID Name";;
Unter debian Linux
sudo apt-get install qrencode
Unter OpenWrt gibt es auch das Paket qrencode allerdings mit Einschränkungen.

Diese Befehlszeile erzeugt die PNG Datei:
qrencode -t png -o ~/SSID_wifi_config.png 'WIFI:T:WPA;P:"password";S:"SSID Name";;'


Oder unter OpenWrt erzeugt man eine SVG Datei, da ist kein PNG verfügbar!
qrencode -t svg -o ~/SSID_wifi_config.svg 'WIFI:T:WPA;P:"password";S:"SSID Name";;'
Die fertige Datei drucken, oder anderweitig zur Verfügung stellen.

Mit dem "QR Code Reader - Ohne Werbung" von Sustainable App-Developer hatte ich guten Erfolg unter Android. Er will nur Bilder aufnehmen und braucht keine weiteren Rechte.

Freitag, 17. August 2018

Mit OpenWrt Presence Informationen ermitteln

Der zentrale Router weiß ja eigentlich am Besten was los ist im Netzwerk. Ich habe mal die Idee verfolgt auf dem OpenWrt einen Prozess zu starten, der aktuelle Information von Netzwerkgeräten nach "aussen" übermittelt. Als erstes Beispiel will ich mal einen bestimmten Wlan Client ermitteln.
Da die finale kurze Abfrage Schleife leicht unübersichtlich ist, erkläre ich erstmal die einzelnen Komponenten.

Ein paar Grundlagen

Je nach Wlan Hardware hat man unterschiedliche Tools um das Wlan abzufragen. Bei mir war iw und iwinfo vorhanden. Ich muss noch prüfen ob der Befehl ip auch (und ganz universell) zu gebrauchen wäre.
Die Ausgabe wird dann für die weitere Verarbeitung gefiltert. Diese beiden Befehle liefern das gleiche Ergebnis:
iwinfo |grep -oE "wlan\d-\d|wlan\d"
iw dev | grep Interface | cut -f 2 -s -d" "

Eine Liste der im Router definierten Wlan Netzwerke.
wlan0
wlan1
wlan1-1
wlan1-2
Eine List der angemeldeten Clients bekommt man mit einem dieser beiden Befehle:
iwinfo wlan1-1 assoclist
iw dev wlan1-1 station dump
In einer Schleife über alle Wlan Netzwerke und einem Ausgabe Filter bekommt man eine komplette Liste der MAC Adressen der aktiven Wlan Clients:
for w in $(iwinfo |grep -oE "wlan\d-\d|wlan\d"); do
   iwinfo $w assoclist | grep -o -E '([[:xdigit:]]{1,2}:){5}[[:xdigit:]]{1,2}'
done

Abfrage einer bestimmten MAC Adresse

Jetzt alles zusammengefasst mit einer Abfrage eine bestimmten MAC Adresse und als Resultat die Übergabe an einen Dummy in FHEM (API WEB ohne csrf Token!).
Das Script /root/loop.sh
#Die Verzögerungszeit der Abfrageschleife kann auch übergeben werden
WATCHDOG_SLEEP_SEC=${1:-2}
#Url zu FHEM
u=http://192.168.56.80:8088/fhem?cmd=set%20WL_Mi6%20
MAC_ADDRESS_1="80:AD:xx:xx:xx:xx"

while sleep $WATCHDOG_SLEEP_SEC; do
 if (
      for m in $(
                 for w in $(iwinfo |grep -oE "wlan\d-\d|wlan\d")
                 do
                   iwinfo $w assoclist | grep -o -E '([[:xdigit:]]{1,2}:){5}[[:xdigit:]]{1,2}'
                 done
                )
      do
        [ "$m" = "$MAC_ADDRESS_1" ] && exit 0
      done
      exit 1
    )
 then
   c=on
 else
   c=off
 fi

 # tue nur etwas wenn sich c geändert hat
 if [ "$c1" != "$c" ] ; then wget -qs $u$c ; c1=$c ; fi

done

Automatischer Start

Jetzt fehlt noch der automatische Start in OpenWrt. Dafür ist procd zuständig. Ich habe dazu ein init Script mit minimaler Funktion erstellt (siehe auch Erklärung unter dem Text):
cat <<EOF > /etc/init.d/loop
#!/bin/sh /etc/rc.common

USE_PROCD=1

START=99
STOP=01

start_service() {
    procd_open_instance
    procd_set_param command /bin/sh "/root/loop.sh"
    procd_set_param stdout 1
    procd_set_param stderr 1
    procd_close_instance
}
EOF 
Achtung! ich lerne ja selbst immer wieder dazu und habe diesen Code mal bewusst als Here Doc  dargestellt. Wenn man den Text, inklusive der ersten und letzten Zeile, einfach in die Eingabe des Terminals wirft, wird automatisch die Datei am richten Ort erzeugt, ohne das man einen Editor bemühen muss! 
Wer das nicht will, der kopiert den Text ohne die erste und letzte Zeile in den Editor seiner Wahl.

Das Ganze muss noch ausführbar gemacht und aktiviert werden:
chmod +x /etc/init.d/loop
/etc/init.d/loop enable
/etc/init.d/loop start 
Mit dem Befehl service kann man überprüfen ob der Dienst angekommen ist und ihn auch steuern.
root@wrt1900:~# service
service "" not found, the following services are available:
boot              dropbear          linksys_recovery  network           sysfixtime        uhttpd
cron              firewall          lm-sensors        odhcpd            sysntpd           umount
dnsmasq           gpio_switch       log               rpcd              system            urandom_seed
done              led               loop              sysctl            ucitrack


War es das schon?

Es gibt natürlich weitere Ideen:

  • Umstieg auf Eventbasierte Abarbeitung ähnlich wie im verlinkten Beispiel.
  • Konfigurierbare Abfrage mehrerer Clients
  • Auslesen aller Host und Übergabe an FHEM 
Aber jetzt will ich erstmal diesen Prozess eine Weile Probe laufen lassen und ein Monitoring des Routers einrichten.

Mittwoch, 8. August 2018

Lokale Namen OpenWrt

Mit der Fritzbox war es immer etwas mystisch: Wann klappt die Namens Auflösung von lokalen Geräten? Am Ende war nur noch Konfiguration mit IP Adressen anstatt Namen angesagt. Blöd wenn man mal etwas umstellen will. Mit OpenWrt sollte es doch jetzt alles klar beherrschbar sein!?

Erkenntnisse

Scheinbar werden von dnsmasq die lokalen Namen erst geliefert, wenn die DHCP Clients die Lease aktualisiert haben. Theoretisch überleben die Leases auch einen Neustart des Routers. Ich hatte aber oft die Situation, da war nach dem Start alles erstmal weg. Die Leasetime steht per Standard auf 12 h. Da dauert es dann ganz schön lange, wenn ein Client mal die Lease erneuern will. Irgendwo hatte ich mal gelesen, dass passiert nach der halben Leasetime (6 h). Dafür muss eine Lösung her.
Frage: Wo packt man jetzt Hostnamen hin, damit sie sofort zur Verfügung stehen?
Antwort: /etc/hosts

Code

Die static Leases sind schlecht lesbar wenn sie nur die IP und Mac enthalten, der Hostname sollte da schon mit in die Liste. Damit man nicht alles doppelt halten und konfigurieren muss, wäre es jetzt sinnvoll die static Leases einfach auszulesen und in die hosts Datei zu schreiben.
Teile des Codes habe ich aus dem Ubuntu Wiki.
Die Abschnitte im Code sind entsprechend kommentiert.

#!/bin/ash

# Perform work in temporary files
temphosts1=`mktemp`
temphosts2=`mktemp`
dom=$(uci get dhcp.@dnsmasq[0].domain)

# If this is our first run, save a copy of the system's original hosts file and set to read-only for safety
if [ ! -f ~/hosts-system ]
then
 echo "Saving copy of system's original hosts file..."
 cp /etc/hosts ~/hosts-system
 chmod 444 ~/hosts-system
fi

# Read Hostnames from DHCP
for i in $(uci show dhcp | grep -oE "host\[\d+\].ip"|grep -oE '\d+'); do
  ip=$(uci get dhcp.@host[$i].ip)
  name=$(uci get dhcp.@host[$i].name)
   if [ ! -z $name ]
   then
    echo $ip $name.$dom $name >>$temphosts2
   fi
done

echo -e "\n# Ad hosts from dhcp "`date` | cat ~/hosts-system - $temphosts2 > $temphosts1

cp $temphosts1 /etc/hosts

# Clean up temp files and remind user to copy new file
echo "Cleaning up..."
rm $temphosts1 $temphosts2

# The File must be readable for everyone
chmod 644 /etc/hosts

#Restart Service
/etc/init.d/dnsmasq restart
echo "Done."


Dienstag, 31. Juli 2018

Import static Leases in OpenWrt

OpenWrt kann mit speziellen Kommandos (uci) in der Shell konfiguriert werden.
Ich habe mir immer gewünscht, statische DHCP Reservierungen einfach durch Textdateien zu konfigurieren. OpenWrt kann zwar wenigsten in der Weboberfläche die MAC Adressen per Copy&Paste einfügen, aber ich hätte es gern komfortabler.
Wer spielen will, der macht zunächst nichts kaputt. Die Konfigurationsänderungen werden zunächst nur temporär ausgeführt.
Die dhcp Konfiguration anzeigen:
uci show dhcp
uci show dhcp | grep '@host\[0\]'
uci get dhcp.@host[0].ip
Die Host Einträge in der /etc/config/dhcp stehen dort am Ende und sind nicht indiziert. Das uci indiziert sie "fließend" für uns und einen direkten Zugriff:

  • [0] ist der erste, 
  • [-1] der letzte Eintrag.

Vorbereitung

Die Standard Shell in OpenWrt ist ash. Diese kann leider nicht mit Arrays umgehen. Dazu braucht man die bash.
Um Dateien anzulegen und zu editieren arbeite ich lieber mit nano. Für die weitere Arbeit mit dem Artikel bitte die zwei Pakete installieren:

  • bash
  • nano

Hosts hinzufügen

Will man einen neuen Host eintragen geht das mit folgendem Beispiel. Ein neuer Eintrag wird angefügt und ist damit der Letzte, dieser wird um die Werte ip und mac ergänzt:
uci add dhcp host
uci set dhcp.@host[-1].ip='192.168.76.11'
uci set dhcp.@host[-1].mac='5c:af:3c:45:ad:be'
Mit einer Schleife kann man Zeilenweise den stdin lesen und und pro Zeile einen neuen Hosteintrag erstellen. Damit die static Leases lesbar bleiben sollte ein Hostname mit in die Tabelle.
Read Host per Line -> rhpl.sh
while read line; do
   array=($line)
   uci add dhcp host
   uci set dhcp.@host[-1].ip=${array[0]}
   uci set dhcp.@host[-1].mac=${array[1]}
   uci set dhcp.@host[-1].name=${array[2]}
done
Dazu eine Datei mit Wertepaaren -> wp.txt
192.168.1.1 aa:bb:cc:dd:ee:d1 host1
192.168.1.2 aa:bb:cc:dd:ee:d2 host2
192.168.1.3 aa:bb:cc:dd:ee:d3 host3
Das Ganze mit der Pipe verknüpft und fertig ist der Import!
bash rhpl.sh <wp.txt
Mit show kann man sich den Erfolg anzeigen lassen. Noch ist nichts aktiv!

Hosts löschen

Will man vor dem Import aufräumen, kann man mit einem (nicht perfekten) Einzeiler erst einmal alle Hosts löschen:
while [ $? -eq 0 ]; do uci delete dhcp.@host[-1];done
Die Schleife läuft einmal zu viel, deswegen gibt es einen Fehler. Aber alle Hosts sind gelöscht.

Host auslesen

Damit man die Liste der Werte Paar nicht komplette per Hand erstellen muss, kann man existierende Daten auslesen. Die entstandenen Dateien kann man bei Bedarf bearbeiten und anschließend importieren.

Static Leases auslesen

Um alle Hosts in eine Datei zu exportieren, braucht man eine formatierte Ausgabe
printf "$(uci get dhcp.@host[-1].ip) $(uci get dhcp.@host[-1].mac) $(uci get dhcp.@host[-1].name)\n"
Und ein Array mit den vorhandenen Indizes. Ein doppelter "Eierkuchen" liefert uns dies aus dem show Befehl.
echo $(uci show dhcp | grep -oE "host\[\d+\].ip"|grep -oE '\d+')
Eine simple Schleife liefert uns die Wertepaare als Ausgabe.
wrlp.sh
for i in $(uci show dhcp | grep -oE "host\[\d+\].ip"|grep -oE '\d+'); do
  printf "$(uci get dhcp.@host[$i].ip) $(uci get dhcp.@host[$i].mac) $(uci get dhcp.@host[$i].name)\n"
done
Die schreibt man einfach in eine Datei.
bash wrlp.sh >wpo.txt

Aktuelle Leases auslesen

Um einfach mal alle existierenden Leases auszulesen genügt ein Einzeiler (vorher bash starten!)
cut -d* -f1 /tmp/dhcp.leases |while read line; do array=($line);echo ${array[2]} ${array[1]} ${array[3]};done >wpl.txt
Die Datei dhcp.leases enthält für unbekannte Felder den "*". Der Befehl cut entfernt den Rest der Zeile ab dem störenden *, der würde sonst die Dateinamen im aktuellen Verzeichnis auflösen!

Finale

Das uci System arbeitet temporär, will man seine Änderungen fest machen, muss man diese speichern und das jeweilige System(dhcp) neu starten.
uci commit dhcp
/etc/init.d/dnsmasq restart
luci-reload

Die uci Schnittstelle ist auch über JSON erreichbar.
wiki.teltonika.lt

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.

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. 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"

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

Mittwoch, 18. Juli 2018

Kalender in FHEM einbinden

Die älter Bereitstellung des Link habe ich bereits hier gezeigt. In der neuen Form des Google Kalenders gibt es den grünen iCal Button nicht mehr, der Link steht jetzt unter Einstellungen/<Kalendername>/Kalendereinstellungen und dort weit unten in der Box:
Privatadresse im iCal Format
Darunter steht der wichtige Hinweis:
Mit dieser Adresse können Sie von anderen Anwendungen aus auf den Kalender zugreifen, ohne ihn öffentlich zu machen.

Das Kalender Modul in FHEM ist aktuell überarbeitet und die Funktionen sind erweitert und geändert worden. Mittlerweile weiß ich, dass es keine gute Lösung ist ein Modul einzusetzen, welches auf einem anderen Modul aufsetzt aber völlig getrennt von dem entwickelt wird. Man schafft unnötig Abhängigkeiten.
Bei der Einbindung eines Kalenders in FHEM sollte man sich über den praktischen eigenen Umgang mit dem Kalender und dem Aktualisierungsintervall (Standard 1 h) Gedanken machen. Ein Abfallkalender der sich das ganze Jahr praktisch nicht ändert muss entweder nie oder höchsten 1 mal Tag aktualisiert werden.

1. Beispiel: 

Signalisierung der Abfalltonne, Aktualisierung einmal am Tag
define AbfallKalender Calendar ical url https://... 86400
Dann brauchen wir ein Gerät wo die aktuelle Tonne drin steht, im einfachsten Fall ein Dummy
define Tonne dummy
Und ein Timer der einmal am Tag den Kalender ausliest und das Ergebnis ablegt.
define a_Tonne at *12:00:00 set Tonne {(my $evt=fhem('get AbfallKalender events format:custom="$S" limit:from=1d,to=1d');;;;$evt?$evt:"0")}
Die Funktion:
  • Am Mittag den Kalender für morgen auslesen -> limit:from=1d,to=1d
  • Nur den Textinhalt des Eintrages lesen -> format:custom="$S"
  • $evt?$evt:"0" -> Falls kein Termin gefunden wird, wird der dann leere String durch eine 0 ersetzt.
  • Den resultierenden Text in den Dummy Tonne schreiben.
Damit kann man am Vortag des Termines ein Aktion auslösen: z.B. Nachmittag den Hinweis geben: die Tonne muss morgen raus. Und am Morgen des Termines kann man nochmal den Hinweis geben: die Tonne muss heute raus. Der Zeitpunkt im Timer entscheidet über das Auftauchen und Verschwinden des Inhaltes von der "Tonne".
Hinweis:
Bei Perl Code innerhalb von einem at Kommando müssen die ; verdoppelt werden, im define müssen sie auch verdoppelt werden, deshalb ;;;; !
Bei Perl Code im set Befehl muss eine zusätzliche Klammer () stehen, sonst wird der Perlausdruck als String gesehen: set Tonne {3+5} ergibt {3+5} im Dummy, set Tonne {(3+5)} ergibt 8 im Dummy.

2. Beispiel: 

Im Kalender stehen FHEM Device Namen (z.B. Aktoren), die Terminzeiten sind die Schaltzeiten.
Der Kalender mit stündlicher Aktualisierung:
define TestKalender Calendar ical url https://... 
Dann wiederum ein Dummy:
define Urlaub dummy
Und ein notify, welches exakt zu Beginn (start) und Ende (end) des Termines den Dummy auf on oder off setzt. (Code für die Raw Def)
define n_TestKalender notify TestKalender:changed:.* {\
  my $cmd ='on';;\
  $cmd = 'off' if ($EVTPART2 eq 'end');;\
  my $actor = fhem('get '.$NAME.' events format:custom="$S" filter:uid=="'.$EVTPART1.'" limit:count=1');;\
  fhem("set $actor $cmd");;\
}

Funktion
Das Calendar Modul wirft zum Zeitpunkt des Termines ein paar Events, davon spricht das notify genau auf diese Beiden an:
2018-07-16 16:25:00 Calendar TestKalender changed: 123456googlecom start
...
2018-07-16 16:30:00 Calendar TestKalender changed: 123456googlecom end
Der Event hat drei Teile:
  • $EVTPART0 ist uninteressant, 
  • $EVTPART1 enthält die ID des Eintrages und 
  • $EVTPART2 "start" bzw. "end".

Mit Hilfe der ID wird der Kalendertext gelesen und mit den umgewandelten "on" (start) und "off" (end) Befehlen das Device in FHEM gesetzt.
Warum sieht der Befehl so kompliziert aus?

  • Der uid/format String muss im String die doppelten Anführungszeichen enthalten! Damit dies funktioniert, muss der gesamte Befehl in ' ' gesetzt werden. Innerhalb werden dann zwar " akzeptiert aber keine Variablen mehr aufgelöst. Diese muss man hier mit Verkettung/concatenation einbauen.

Weiter unten habe ich eine (für den Anfänger) besser lesbare Variante eingebaut.

Komplexen Code auslagern

Für komplexeren Code sollte man alles in die 99_myUtils auslagern und im notify lediglich die wichtigen Parameter übergeben:
define n_TestKalender notify TestKalender:changed:.* {KalenderSub($EVTPART1,$EVTPART2,$NAME)} 
Das folgende Beispiel filtert das Ereignis (Devicenamen) "Urlaub" aus dem Kalender und setzt das gleichlautendes Device bei Start und Ende auf ja /nein. Alle anderen Events werden zwar getriggert aber verworfen.
Die sub kann man beliebig komplex gestaltet. Damit der get Befehl lesbar bleibt, habe ich alles in extra Variablen gepackt. (Code für die 99_myUtils.pm)
sub KalenderSub ($$$)
   {
     my ($uid,$cmd,$cname) = @_;
     #Logging der Paramter bei Bedarf;     #Log 1, "uid: $uid | Start/End: $cmd | cal: $cname";
     my $format = '"$S"';
     $uid='"'.$uid.'"';
     $cmd = 'ja' if ($cmd eq 'start');
     $cmd = 'nein' if ($cmd eq 'end');
     $dev = 'Urlaub';
     my $actor = fhem("get $cname events format:custom=$format filter:uid==$uid limit:count=1");
     # Unterschiedliche Abfragen auf ist exakt oder enthält möglich;
     #fhem("set $actor $cmd") if ($actor eq $dev);
     if ($actor =~ /$dev/) {fhem("set $dev $cmd")};
}

Tipp

Der Calendar Aufruf wird mit Level 3 geloggt, wenn man das nicht möchte hängt man an den Befehlsaufruf einfach noch ",1" an.
fhem("Befehl",1)

Weitere Infos:
Forum
Wiki (derzeit nicht aktuell)

Samstag, 7. Juli 2018

Etwas Powershell für ssh

Alle Hostverbindungen sind in lnk Dateien definiert und jetzt wäre es cool wenn man diese Definitionen vielfach weiterverwendet.
In Ergänzung zu meinem letzten Artikel will ich hier ein paar Bausteine aufzeigen und die Gedanken dahinter und den Syntax kurz erklären.

Zunächst mal ein paar grundlegende Variablen und Objekte damit der Code universell bleibt.
# Varianten für Zielpfad
#$HomePath = "$env:HOMEDRIVE$env:HOMEPATH\Desktop"
$HomePath = "$env:onedrive\ssh Hosts"
# Filter
$Filter = "*.lnk"
$FArg = "@"

# Shell Object zum Zugriff auf Eigenschaften von lnk
$shell = New-Object -COM WScript.Shell

Kurz und kompakt ist die Variante mit konsequenter Ausnutzung von Pipes.

  • GCI liefert alle Dateien mit der Endung lnk in einem Pfad.
  • Für jedes Element wird ein Shell Objekt erzeugt und im Element Arguments nochmal gefiltert. Im Beispiel auf das Zeichen @ um wirklich nur die lnk Dateien mit user@host zu behandeln. Im Element Targetpath steht der Befehl komplett mit Pfad.
  • Für alle gefilterten Elemente wird ein neuer Prozess mit cmd gestartet und einfach das Kommando aus der lnk Datei aufgeführt.

Ergo werden alle vorhandenen "ssh" Hostdefinitionen in separaten Fenstern geöffnet.
# Variante mit Pipes
Get-childItem $HomePath -filter $Filter |
  ForEach-Object {$shell.CreateShortcut($_.FullName)}|where Arguments -match $FArg|
    ForEach-Object {
       Start-Process "cmd.exe" "/c $($_.Targetpath) $($_.Arguments)"
    }
Die beiden Elemente Targetpath und Arguments liegen als eine Art Objectreferenz vor. Damit wirklich der Inhalt als String verwendet wird muss dies im Process Aufruf mit $() aufgelöst werden.
Es geht auch ohne Pipes, dann werden alle Übergänge in Variablen gespeichert, der Ablauf ist gleich.
# Variante ohne Pipes
$Files = Get-childItem $HomePath -filter $Filter
ForEach ($File in $Files) {
   $lnkfile = $shell.CreateShortcut($File.FullName) 
   if ($($lnkfile.Arguments) -match $FArg ) {
      Start-Process "cmd.exe" "/c $($lnkfile.Targetpath) $($lnkfile.Arguments)"
   }
}
Für andere Fälle kann man auch einfach ein Array mit Hosts erstellen und lässt eine ForEach Schleife über dieses Array laufen.
$Hosts = @("192.168.178.80","192.168.178.81","192.168.178.82","192.168.178.83")
ForEach ($h in $Hosts) {}
Um den Code leserlich und modular zu halten, kann man zu Beginn alles in Variablen packen. Die Unterbringung von Befehlssquenzen in Variablen ist nicht ganz trivial. Damit man gut testen kann und nicht immer den ganzen Code verändern muss, packe ich  auch das erste cmd Argument in eine String Variable $cs.
#Absoluter Pfad zum Public Key
$Keyfile = "$env:HOMEDRIVE$env:HOMEPATH\.ssh\id_rsa.pub"
$cs = "/C "  # Schließt das cmd Fenster nach Abarbeitung
#$cs = "/K "  # Lässt das cmd Fenster offen - nur für Tests wichtig!
$sshTarget = "pi@$h"
Die eigentliche Codezeile ( Ersatz ssh-copy-id) enthält zwei in sich geschachtelte Argumentelisten. Zunächst der Fenstertyp für cmd.exe in $cs.
Die Kombination aus $cs, $C1 und $sshTarget wäre für sich ausführbar, Ergebnis ist eine Shellkonsole.
Danach kommt die Argumentenliste (Befehle) die in der Shellkonsole ausgeführt werden sollen. Diese muss komplett in " " verpackt werden. Innerhalb dieser Argumentenliste werden wieder Variablen mit dem $ Zeichen im Namen gebildet. Diese Namen haben nichts mit der aufrufenden Powershell zu tun.
Damit Powershell die Zeichen $ und " nicht auflöst, muss man sie mit Backticks (`) schützen. Wenn man die Befehlsfolge an den Stellen aufteilt, wo man sie auch separat testen könnte, bleibt sie lesbar und ist gut zu dokumentieren. Der Code funktioniert, im eigentlichen Artikel gibt es eventuell eine aktuelle Variante.
$C1 = "type $Keyfile | ssh " 
$C2 = " akey='.ssh/authorized_keys'; okey='keee.tmp'; cat | tr -d '\r' >`$okey;" # Variablen erzeugen, Text aus der Pipe ohne CR speichern
$C3 = " umask 077; test -d .ssh || mkdir .ssh;" # Berechtigung setzen, Verzeichnis prüfen sonst anlegen
$C4 = " test -f `$akey || cat `$okey >`$akey;" # Datei prüfen sonst direkt anlegen
$C5 = " grep -q `"`"`$(cat `$okey)`"`" `$akey  || cat `$okey >>`$akey;rm `$okey" # Prüfen ob Key schon vorhanden sonst hinzufügen 
Der grep Befehl bekommt einen String übergeben der in sich durch " geschützt sein muss. Damit die Shell die " nicht auflöst müssen sie in der Shell durch Verdopplung geschützt werden, damit Powershell die " im String nicht auflöst müssen sie durch ` geschützt werden.
Jetzt fügen wir alles zusammen und testen das Ergebnis als Ausgabe. Hier erfolgt jetzt das oben erwähnte Einpacken der Shellbefehle in " . Man kann $C2 bis $C5 flexibel weglassen und einzeln testen.
$Argument = $($cs + $C1 + $sshTarget + " `"" + $C2 + $C3 + $C4 + $C5 + "`"")
Write-Output $Argument
Wenn alles gut aussieht kann man den Befehl testen.
Start-Process "cmd.exe" $Argument
Jetzt kann man alles zusammenpacken und auf Knopfdruck entweder alle Hosts auf einmal in getrennten ssh Fenstern öffnen oder gleich alle Hosts mit einem Vorgang mit den eigenen Public Keys versorgen.
Hier eine komplette Version mit ein paar Optionen, die durch Kommentarzeichen noch aus- oder eingeschaltet werden müssen.
# Varianten für Zielpfad
#$HomePath = "$env:HOMEDRIVE$env:HOMEPATH\Desktop"
$HomePath = "$env:onedrive\ssh Hosts"

# eigener Public Key
$Keyfile = "$env:HOMEDRIVE$env:HOMEPATH\.ssh\id_rsa.pub"
# Filter 
$Filter = "*.lnk"
$FArg = "pi@"
# cmd Fenstertyp bestimmen
$cs = "/C"  # Schließt das cmd Fenster nach Abarbeitung
#$cs = "/K"  # Lässt das cmd Fenster offen - nur für Tests wichtig!

# Kommando für cmd Aufruf in Einzelteilen
$C1 = " type $Keyfile | ssh " 
$C2 = " akey='.ssh/authorized_keys'; okey='keee.tmp'; cat | tr -d '\r' >`$okey;" # Variablen erzeugen, Text aus der Pipe ohne CR speichern
$C3 = " umask 077; test -d .ssh || mkdir .ssh;" # Berechtigung setzen, Verzeichnis prüfen sonst anlegen
$C4 = " test -f `$akey || cat `$okey >`$akey;" # Datei prüfen sonst direkt anlegen
$C5 = " grep -q `"`"`$(cat `$okey)`"`" `$akey  || cat `$okey >>`$akey;rm `$okey" # Prüfen ob Key schon vorhanden sonst hinzufügen 

# Die Alternativen Zeilen für OpenWrt Router
#$FArg = "root@"
#$C2 = " akey='/etc/dropbear/authorized_keys'; okey='keee.tmp'; cat | tr -d '\r' >`$okey;"

# Shell Object zum Zugriff auf Eigenschaften von lnk
$shell = New-Object -COM WScript.Shell
# Variante mit Pipes
Get-childItem $HomePath -filter $Filter |
  ForEach-Object {$shell.CreateShortcut($_.FullName)}|where Arguments -match $FArg|
    ForEach-Object {
       $sshTarget = $_.Arguments
       # Entweder nur die Public Keys übertragen 
       $Argument = $($cs + $C1 + $sshTarget + " `"" + $C2 + $C3 + $C4 + $C5 + "`"")
       # oder nur die Terminalsession öffnen
       #$Argument = "$cs $($_.Targetpath) $($_.Arguments)"
        
       Write-Output $Argument # Zum Test
       #Start-Process "cmd.exe" $Argument # eigentlicher Befehl 
    }

Samstag, 30. Juni 2018

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!

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!
Der get Befehl kann nicht mit Wildcards im Namen umgehen.
Get-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0
Aber powershell bietet dafür eine Möglichkeiten, um die Liste zu filtern:
Get-WindowsCapability -Online | where name -match 'ssh'
Get-WindowsCapability -Online | where name -like '*ssh*'
Get-WindowsCapability -Online | where state -eq 'Installed'

Der Add Befehl kann nicht mit Wildcards umgehen.
Add-WindowsCapability -Online -Name OpenSSH.Client~~~~0.0.1.0

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. Ein Versuch wird 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

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! 

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