Windows 2003 Shell Scripting. Abläufe automatisieren ohne Programmierkenntnisse

Microsoft hat lange versäumt, den Befehlsumfang der Kommandozeile an die ständige Weiterentwicklung von Windows anzupassen. Dafür wurde der Windows Script Host (WSH) als Basis für die befehlsbasierte Administration eingeführt, der allerdings Wissen in der objektorientierten Programmierung voraussetzt und dessen Befehle man nicht direkt in die Kommandozeile eingeben kann, sondern nur über eine Skriptsprache wie VBScript. Viele Administratoren von Windows-Servern sind aber nicht bereit, sich Wissen zu diesem Thema anzueignen. Das hat Microsoft auch mitbekommen und neue Kommandozeilenbefehle ab Windows Server 2008 eingeführt und alte, die im Windows Resource Kit gelandet waren, wieder in die Standardinstallation aufgenommen. Dass Microsoft dabei Unix-Administratoren über die Schultern geschaut hat, ist kein Geheimnis, man merkt es an der Entwicklung der PowerShell, aber auch an neuen Befehlen für die Kommandozeilen wie zum Beispiel where und whoami.

Im letzten Kapitel des Buchs prophezeit Armin Hanisch der cmd.exe und der Batch eine düstere Zukunft, da sich 2006 schon die PowerShell angekündigt hat. Aber auch für die PowerShell benötigt man, wenn man sie intensiv nutzen will, wie für den WSH Grundkenntnisse in der objektorientierten Programmierung, die Lernkurve ist also steiler. Die Befehle der PowerShell, auch Cmdlets genannt, liefern nicht bloß Text zurück, wie die textbasierte Kommandozeile der Windows Shell, sondern gleich .NET-Objekte, deren Eigenschaften man im weiteren Verlauf gezielt ansprechen kann. Wobei es für Windows-Administratoren oder Power-User unbedingt lohnt, sich in die PowerShell einzuarbeiten, um Windows zu automatisieren. Einfacher geht das aber immer noch mit der cmd.exe, ihren mächtigen Befehlen wie for oder wmic und Batchskripten, wenn man nicht programmieren mag. Daher denke ich, dass uns Batchdateien noch eine ganze Weile begleiten werden, und ich hoffe, dass es bald eine überarbeitete Neuauflage des Buchs für Windows Server 2008 R2 geben wird.

Da man mit der Windows Shell schnell an seine Grenzen stößt, geht es in einem interessanten Kapitel des Buchs um das Zusammenspiel zwischen Batch und VBScript, um zum Beispiel Messageboxen zu erstellen. Man muss den Code aber nicht unbedingt in eine temporäre Datei auslagern, es geht auch mit einem here document:

' 2>nul & @echo off
' 2>nul & cls
' 2>nul & title mixed.bat - VBScript und Batch in einer Datei
' 2>nul & echo Das ist die Windows Shell
' 2>nul & time /t
' 2>nul & echo.
' 2>nul & echo Schau doch  mal unter eventvwr.msc nach!
' 2>nul & echo.
' 2>nul & cscript //Nologo //E:vbs %~f0

:: WScript.Echo "Das ist der WSH!" & vbCrLf
:: set sh = WScript.CreateObject("WScript.Shell")
:: sh.LogEvent 2, "Kaffe ist alle"
:: set sh = Nothing

Die Batch kennt das Hochkomma nicht und reagiert mit einer Fehlermeldung, die dann mit 2>nul ins Nirvana geschickt wird. Anschließend wird der nächste Befehl mit dem &-Zeichen angeknüpft. Der Teil mit dem VBScript besteht für das Shell Script nur aus Kommentaren, wie man an den beiden Doppelpunkten sieht. VBScript wiederum sieht das Hochkomma als Kommentarzeichen an und ignoriert deshalb das Batchprogramm. Der Doppelpunkt ist in VBScript ein Trennzeichen für mehrere Befehle in einer Zeile, womit :: zwar ein gültiger Befehl ist, in diesem Fall aber nichts bewirkt.

Batch und PowerShell mit dem Parameter Command

Das Mischen von Batch und Powershell ist wesentlich eleganter. Schnell und einfach funktioniert das mit einem Einzeiler, weil man der PowerShell im Gegensatz zum WSH über den Parameter -Command einzelne Befehle übergeben kann:

@echo off
title cmdPS.bat - Demo um ein PowerShell-Skript von einem Batch zu starten
echo.
echo Das ist die Windows Shell
echo %time:~0,-3%
echo.
 
powershell -command "& {Write-Host;Write-Warning 'Starte PowerShell';gps power*,cmd*;Write-Host;Write-Warning 'Beende PowerShell'}"
 
echo.
echo Das ist wieder die Windows Shell
echo %time:~0,-3%
echo. 
pause & exit /b

Nun, was macht man aber, wenn man einen ganzen Skriptblock verarbeiten will? Ein schönes Beispiel dafür habe ich im französischsprachigen Blog von Walid Toumi gefunden, welches ich aber ein bisschen abgewandelt habe:

@echo off
title cmdPS.bat - Demo um ein PowerShell-Skript von einem Batch zu starten
echo.
echo Das ist die Windows Shell
echo %time:~0,-3%
echo.

:: Begin Function Get-Test
for /f "delims=:" %%a in ('
     findstr /BN "::@PS$Get-Test" %~f0
 ') do set /a Line=%%a
 more +%Line% %~f0  | powershell -command -
:: End Function Get-Test
 
echo.
echo Das ist wieder die Windows Shell
echo %time:~0,-3%
echo. 
pause & exit /b 

::@PS$Get-Test
Function Get-Test {
  param()
  Begin{
    Write-Warning "Starte PowerShell" 
  }
  Process{
    gps power*,cmd*  
    <# 
      Kommentarblock
    #>
  }
  End{
   Write-Host
   Write-Warning "Beende PowerShell"
  }
}
Get-Test
 
exit
:: End Function Get-Test

Zentrale Punkte des Skripts sind die For-Schleife, der Findstr- und der More-Befehl, sowie letztendlich der PowerShell Parameter -command oder kurz -c:

:: Begin Function Get-Test
for /f "delims=:" %%a in ('
     findstr /BN "::@PS$Get-Test" %~f0
 ') do set /a Line=%%a
 more +%Line% %~f0  | powershell -command -
:: End Function Get-Test

Bei der For-Schleife steht die Option /f für das Durchsuchen von Dateien (engl. files). Mit delims=: wird der Doppelpunkt als Trennzeichen festgelegt. Warum der Doppelpunkt, oder warum überhaupt ein Trennzeichen? Weil findstr — das einzige Werkzeug, das in der Windows Shell mit grep vergleichbar ist — wegen der Option /B in jeder Zeile des Skripts, dafür steht %~f0, schaut, ob sie mit dem Ausdruck “::@PS$Get-Test” beginnt. Der Ausdruck ist dabei beliebig, es sollte bloß eine Zeichenfolge sein, die so weder in einer Batchdatei noch in einem PowerShell-Skript vorkommt. Wenn das der Fall ist, sorgt die Option /N dafür, dass die Zeilennummer, in diesem Fall 21, mit set /a Line=%%a der Variable Line übergeben wird. Das Ergebnis von findstr sieht folgendermaßen aus: 21:@::PS$Get-Test. Da wir aber nur die Zeilennummer brauchen, schneiden wir den Teil danach inklusive des Doppelpunkts einfach mit "delims=:" ab. Die Zeilenummer wird für das Kommando more benötigt, das mit der Anzeige des PowerShell-Codes aus der Batchdatei ab dieser Zeile beginnt: more +%Line% %~f0. Das Ergebnis wird dann direkt an die PowerShell weitergeleitet. Durch den Paramter -Command werden die angegebenen Befehle so ausgeführt, als wären sie direkt in der PowerShell-Eingabeaufforderung eingegeben worden, so wie bei dem Beispiel mit dem Einzeiler weiter oben. Wenn nach -Command ein “-” folgt, kann die Zeichenfolge auch ein Skriptblock sein, was uns hier zugute kommt, da durch more und der Verkettung mit | ja schließlich ein Skriptblock an die PowerShell weitergeleitet wird. Im PowerShell-Skriptblock wird die Funktion Get-Test definiert, die nichts weiter aufregendes macht, als alle PowerShell- und CMD-Prozesse anzuzeigen. Am Ende wird die Funktion mit Get-Test ausgeführt und die PowerShell mit exit wieder beendet.

Batch und PowerShell mit dem Parameter EncodedCommand

Als weitere Möglichkeit, Batch- und PowerShell-Code zu mischen, kann man den Skriptblock mit Base64 codieren. Dazu muss man den Block an eine Variable übergeben, beispielsweise mit $code = {}. Alles was zwischen den geschweiften Klammern steht landet in der Variable $code.

$code = {
Function Get-Test {
  param()
  Begin{
    Write-Warning "Starte PowerShell" 
  }
  Process{
    gps power*,cmd*  
    <# 
      Kommentarblock
    #>
  }
  End{
   Write-Host
   Write-Warning "Beende PowerShell"
  }
}
}

Danach wird der Inhalt der Variable konvertiert:

[convert]::ToBase64String([Text.Encoding]::Unicode.GetBytes($code))

Der mit Base64 codierte Block muss dann in einer Zeile in die Batchdatei eingefügt werden:

@echo off
title cmdPS.bat - Demo um ein PowerShell-Skript von einem Batch zu starten
echo.
echo Das ist die Windows Shell
echo %time:~0,-3%
echo.
 
powershell -EncodedCommand DQAKAEYAdQBuAGMAdABpAG8AbgAgAEcAZQB0AC0AVABlAHMAdAAgAHsADQAKACAAIABwAGEAcgBhAG0AKAApAA0ACgAgACAAQgBlAGcAaQBuAHsADQAKACAAIAAgACAAVwByAGkAdABlAC0AVwBhAHIAbgBpAG4AZwAgACIAUwB0AGEAcgB0AGUAIABQAG8AdwBlAHIAUwBoAGUAbABsACIAIAANAAoAIAAgAH0ADQAKACAAIABQAHIAbwBjAGUAcwBzAHsADQAKACAAIAAgACAAZwBwAHMAIABwAG8AdwBlAHIAKgAsAGMAbQBkACoAIAAgAA0ACgAgACAAIAAgADwAIwAgAA0ACgAgACAAIAAgACAAIABLAG8AbQBtAGUAbgB0AGEAcgBiAGwAbwBjAGsADQAKACAAIAAgACAAIwA+AA0ACgAgACAAfQANAAoAIAAgAEUAbgBkAHsADQAKACAAIAAgAFcAcgBpAHQAZQAtAEgAbwBzAHQADQAKACAAIAAgAFcAcgBpAHQAZQAtAFcAYQByAG4AaQBuAGcAIAAiAEIAZQBlAG4AZABlACAAUABvAHcAZQByAFMAaABlAGwAbAAiAA0ACgAgACAAfQANAAoAfQANAAoARwBlAHQALQBUAGUAcwB0AA0ACgA=
 
echo.
echo Das ist wieder die Windows Shell
echo %time:~0,-3%
echo. 
pause & exit /b

Der Vorteil dieser Variante liegt darin, dass die Batchdatei übersichtlicher ist. Der Nachteil ist natürlich, dass man keinen direkten Einfluss auf den PowerShell-Code mehr hat und ihn bei jeder Änderung wieder in Base64 umwandeln muss.

Da PowerShell-Skripte aus Sicherheitsgründen nicht ganz so einfach gestartet werden können, eignen sich Batchdateien sehr gut für die Unterstützung von PowerShell-Skripten. Man kann mit den Batchprogrammen zum Beispiel bei der Verteilung von PowerShell-Skripten die ein oder andere Ungewissheit umschiffen, zum Beispiel wenn man nicht weiß, ob das Zielsystem aufgrund der “Execution Policy” grundsätzlich bereit ist, Powershell-Skripte auszuführen:

powershell -ExecutionPolicy Unrestricted -c "& {write-warning 'Hallo Welt'}; exit"

Oder, um mit den Remotefähigkeiten der Kommandozeilenwerkzeuge wie AT das Gastsystem gezielt auf den Einsatz eines PowerShell-Skripts vorzubereiten, indem man die PowerShell dort mit einem Taskjob direkt aus dem Taskplaner startet.

@echo off
title Demo um Variablen von VBScript an CMD zuzuweisen
color 2F
mode 55,9

:: Set variable for InputBox:
set myMessage=Hallo, wie ist dein Name?
set myTitle=Bitte Namen eingeben
call :subInputBox

:: Display variable
if "%flag%"=="false" (
	set myMessage=Es wurde nichts eingegeben, oder die Eingabe abgebrochen.
	set myTitle=Keine Eingabe
	call :subMsgBox
) else (
	set myMessage=Hallo %cmdText%!
	set myTitle=Begrüßung
	call :subMsgBox
)
goto End

:: Start subroutine subInputBox
:subInputBox
set VBS="%Temp%\vbsInputBox.vbs"
set CMD="%Temp%\cmdVar.bat"
 
>> %VBS% echo Option Explicit 
>> %VBS% echo Dim strText  
>> %VBS% echo Dim objShell : Set objShell = CreateObject("Wscript.Shell")  
>> %VBS% echo Dim objFSO   : Set objFSO = CreateObject("Scripting.FileSystemObject") 
>> %VBS% echo Dim objFile  : Set objFile = objFSO.CreateTextFile(%CMD%) 
:: Pass variable from batch to VBScript
>> %VBS% echo strText = InputBox("%myMessage%", "%myTitle%")
>> %VBS% echo if strText = vbNullString then 
:: Create batch file
>> %VBS% echo objFile.WriteLine "@echo off"
>> %VBS% echo objFile.WriteLine "set flag=false" 
>> %VBS% echo else 
>> %VBS% echo objFile.WriteLine "@echo off"
:: Set variable in batch file
>> %VBS% echo objFile.WriteLine "set cmdText=" ^& strText  
>> %VBS% echo end if 
>> %VBS% echo objFile.Close  
 
cscript %VBS% > NUL
call %CMD% > NUL
 
del %CMD%
del %VBS%
 
goto :EOF
:: End subroutine subInputBox

:: Start subroutine subMsgBox
:subMsgBox
>> %Temp%\MsgBox.vbs echo MsgBox "%myMessage%", VbInformation + VbOKOnly, "%myTitle%" 
cscript %Temp%\MsgBox.vbs > NUL
del %Temp%\MsgBox.vbs
goto :EOF
:: End of subroutine subMsgBox

:: End of batch file
:End

Schauen wir uns das Skript Stück für Stück an, allerdings um ein paar Kommentare gekürzt, die mit den beiden Doppelpunkten :: beginnen.

@echo off
title Demo um Variablen von VBScript an CMD zuzuweisen
color 2F
mode 55,9

Das @-Zeichen ganz am Anfang des Skripts stellt die Ausgabe der Befehlszeile auf dem Bildschirm für den aktuellen Befehl aus. In diesem Fall ist es echo off, der die Befehlszeile für alle nachfolgenden Befehle ausschaltet, zumindest solange, bis ein echo on kommt. Danach werden Titel, Farbe und Form der aktuellen cmd.exe festgelegt.

set myMessage=Hallo, wie ist dein Name?
set myTitle=Bitte Namen eingeben
call :subInputBox

Mit set werden zwei Variablen myMessage und myTitle definiert, die den beschreibenden Text für die InputBox des VBScripts beinhalten. Anschließend wird mit call die Subroutine subInputBox aufgerufen. Seit Windows 2000 sind einfache Subroutinen in der Windows Shell möglich, indem vor der Subroutinen eine Sprungmarke definiert wird. Mit dem Aufruf call :<lable> wird der Ablauf des Skripts zum angegebenen Sprungziel geleitet. Nachdem die Ausführung in der Subroutine durch goto :EOF beendet wird, springt der Ablauf auf die Zeile hinter call :<lable> zurück und wird dort fortgesetzt. Um den logischen Ablauf des Skripts zu folgen, springen wir jetzt auch dort hin:

:: Start subroutine subInputBox
:subInputBox
set VBS="%Temp%\vbsInputBox.vbs"
set CMD="%Temp%\cmdVar.bat"
 
>> %VBS% echo Option Explicit 
>> %VBS% echo Dim strText  
>> %VBS% echo Dim objShell : Set objShell = CreateObject("Wscript.Shell")  
>> %VBS% echo Dim objFSO   : Set objFSO = CreateObject("Scripting.FileSystemObject") 
>> %VBS% echo Dim objFile  : Set objFile = objFSO.CreateTextFile(%CMD%) 
>> %VBS% echo strText = InputBox("%myMessage%", "%myTitle%")
>> %VBS% echo if strText = vbNullString then 
>> %VBS% echo objFile.WriteLine "@echo off"
>> %VBS% echo objFile.WriteLine "set flag=false" 
>> %VBS% echo else 
>> %VBS% echo objFile.WriteLine "@echo off"
>> %VBS% echo objFile.WriteLine "set cmdText=" ^& strText  
>> %VBS% echo end if 
>> %VBS% echo objFile.Close  
 
cscript %VBS% > NUL
call %CMD% > NUL
 
del %CMD%
del %VBS%
 
goto :EOF
:: End subroutine subInputBox

Am Anfang steht die Sprungmarke :subInputBox, zu der uns der Call-Aufruf geführt hat. Danach werden die Variablen VBS und CMD mit den Dateinamen gesetzt in denen der Code für das VBScript und die Batchdatei geschrieben werden. Durch die Umgebungsvariable %Temp% werden die beiden Dateien auch gleich in den temporären Ordner gespeichert. Dann wird jede einzelne Zeile des VBScripts mit Hilfe der Ausgabeumleitung >> der Reihe nach in die VBS-Datei geschrieben, deren Name zusammen mit den Pfad in der Variable %VBS% gespeichert wurde. Dabei sind folgende Zeilen interessant:

>> %VBS% echo Dim objFile  : Set objFile = objFSO.CreateTextFile(%CMD%) 
>> %VBS% echo strText = InputBox("%myMessage%", "%myTitle%")

Über die Batch-Variablen %CMD%, %myMessage% und %myTitle% werden Variablen bzw. deren Inhalt im VBScript gesetzt. In einer Zeile weiter unten ist das ganze dann andersherum: Eine Variable wird vom VBScript zurück in die Batchdatei geschrieben.

>> %VBS% echo objFile.WriteLine "set cmdText=" ^& strText

Dabei muss man allerdings darauf achten, dass das &-Zeichen mit einem ^ maskiert wird. Wenn man ein für die Batchdatei besonderes Zeichen benutzt, muss man es mit dem sogenannten Escape-Zeichen kennzeichnen, was auch quoten genannt wird. Auf diese Weise kann man auch XML-Dateien erzeugen, obwohl die Symbole für die Ein- und Ausgabeumleitung für Dateien < und > schon belegt sind.

Wenn das VBScript erstellt ist, wird es mit cscript %VBS% aufgerufen. Dabei startet cscript das Skript mit dem Windows Scripting Host im Kontext der Kommandozeile. Sollte dabei irgendeine Ausgabe auf der Konsole erfolgen wird das Ergebnis mit der Umleitung > nul ins Nirwana geschickt. Danach ruft call %CMD% die Batchdatei auf, die das VBScript erstellt hat. Wenn das erledigt ist, räumt der Befehl del auf, indem die beiden Dateien wieder gelöscht werden. Mit goto :EOF wird die Subroutine verlassen und zurück zum Ausgangspunkt gesprungen.

if "%flag%"=="false" (
	set myMessage=Es wurde nichts eingegeben, oder die Eingabe abgebrochen.
	set myTitle=Keine Eingabe
	call :subMsgBox
) else (
	set myMessage=Hallo %cmdText%!
	set myTitle=Begrüßung
	call :subMsgBox
)
goto End

Weiter geht es mit einer If-Bedingung. Der Inhalt der Variable %flag% wurde durch das VBScript an die temporäre Batchdatei cmdVar.bat übergeben, die dadurch den Weg in die aktuelle Batchdatei gefunden hat. Man könnte auch auf die Idee kommen, statt eines Flags eine Sprungmarke mit goto zu verwenden. Dummerweise lassen sich keine Sprungmarke von einer Batchdatei in eine andere übertragen.

Mit der If-Bedingung kann man anhand des Flags entscheiden, welcher Knopf in der InputBox gedrückt worden ist, OK oder Abbruch. Wurde Abbruch geklickt bzw. im Eingabefeld nichts eingegeben wird die Flag-Variable auf False gesetzt und der If-Zweig ausgeführt. Andernfalls kommt der Else-Zweig zum Einsatz. Mehrere Befehle können durch runde Klammern gruppiert werden, um den Code besser zu strukturieren. Zeilenumbrüche und Einrückungen sind dabei in Ordnung, wobei man beachten muss, dass die öffnende Klammer in der gleichen Zeile steht wie der If-Befehl, und dass vor dem Else-Befehl die schließende und danach wieder die öffnende Klammer in derselben Zeile stehen müssen. Hinter der schließenden und vor der öffnenden Klammer muss ein Leerzeichen sein, sonst funktioniert es nicht.

:: Start subroutine subMsgBox
:subMsgBox
>> %Temp%\MsgBox.vbs echo MsgBox "%myMessage%", VbInformation + VbOKOnly, "%myTitle%" 
cscript %Temp%\MsgBox.vbs > NUL
del %Temp%\MsgBox.vbs
goto :EOF
:: End of subroutine subMsgBox

In beiden Zweigen der If-Bedingung werden mit set Variablen definiert und danach die Subroutine subMsgBox aufgerufen, mit der wiederum ein VBScript erstellt wird, um eine MessageBox zu erzeugen. Nach dem Aufruf der MessageBox wird die temporäre Datei gelöscht und die Subroutine mit goto :EOF wieder verlassen. Das sich anschließende goto End überspringt die beiden Subroutinen und führt den Programmablauf an das Ende der Batchdatei.

:: End of batch file
:End

Es ist natürlich einfacher, die ganze Geschichte gleich in VBScript zu programmieren, doch es geht hier um die Demonstration professionell aussehende Fenster in einer Batchdatei zu erstellen und den Inhalt von Variablen aus der Batchdatei in diese Fenster zu übergeben und umgekehrt.

Literatur:

• Batch-Programmierung
• Visual Basic Script (VBS)
• Windows 2003 Shell Scripting. Abläufe automatisieren ohne Programmierkenntnisse, Armin Hanisch, ISBN 978-3827321787

EncFS unter Ubuntu

In der aktuellen Ubuntu-User zeigt der Artikel “Sicher in die Wolke”, wie man seine Dateien mit GnuPG verschlüsseln kann, bevor man sie einer Cloud-Anwendung wie Ubuntu One oder Dropbox übergibt und wieder entschlüsselt. Da das Ver- und Entschlüsseln der Dateien dabei im Terminal stattfindet, wirkt das Verfahren unnötig kompliziert. Die Webseite nosinmiubuntu zeigt, wie es mit Cryptkeeper und EncFS unter Ubuntu 10.11.10 Oneiric Ocelot und Unity einfacher geht. Da sich Cryptkeeper und EncFS in den Repositories von Oneiric befinden, kann man beide Programme über das Software-Center oder über das Terminal installieren:

sudo apt-get install cryptkeeper encfs

Einrichten des Panel Applets

Damit Cryptkeeper nach dem nächsten Ab- und wieder Anmelden des Benutzers als Panel Applet im System-Tray von Unity erscheint, muss man das Programm in eine sogenannte “Whitelist” eintragen. Im Gegensatz zu Gnome ist das Panel Applet in Unity ziemlich eingeschränkt. Am einfachsten kann man sich alle Applets anzeigen lassen:

gsettings set com.canonical.Unity.Panel systray-whitelist "['all']"

Die unerwünschte Nebenwirkung ist dann aber, dass man wirklich alle Applets im Panel sieht. Will man nur das Panel Applet von Cryptkeeper zusätzlich zulassen, sollte man erst einmal schauen, welche Applets bereits auf der Whitelist stehen:

gsettings get com.canonical.Unity.Panel systray-whitelist

Wenn die Ausgabe nichts anzeigt, reicht ein

gsettings set com.canonical.Unity.Panel systray-whitelist "['Cryptkeeper']"

um Cryptkeeper zum Panel hinzu zufügen. Sieht die Ausgabe aber wie im folgenden Beispiel aus,

$ gsettings get com.canonical.Unity.Panel systray-whitelist
['JavaEmbeddedFrame', 'Mumble', 'Wine', 'Skype', 'hp-systray']

sollte man Cryptkeeper an das Ende der Liste setzen:

$ gsettings set com.canonical.Unity.Panel systray-whitelist "['JavaEmbeddedFrame', 'Mumble', 'Wine', Skype', 'hp-systray', 'Cryptkeeper']"

Anschließend sollte man nochmal prüfen, ob es geklappt hat. Wenn die Ausgabe in etwa so, wie die folgende aussieht, scheint es funktioniert zu haben:

$ gsettings get com.canonical.Unity.Panel systray-whitelist['JavaEmbeddedFrame', 'Mumble', 'Wine', 'Skype', 'hp-systray', 'Cryptkeeper']

Danach muss Cryptkeeper noch unter “Startprogramme” eingetragen werden. Dazu drückt man die Super-Taste (das ist die ehemalige Windows-Taste) und trägt in das Suchfeld “Startprogramme” ein. Das Programm-Icon taucht schon nach nur wenigen Buchstaben auf.

Der Eintrag sieht dann folgendermaßen aus und wird über den Button “Speichern” und “Schließen” festgeschrieben:

Erst nach dem Ab- und wieder Anmelden werden die Änderungen sichtbar, und man sieht, ob es wirklich geklappt hat, wenn man das Symbol mit dem Schlüsselpaar im Panel sieht:

Cryptkeeper im Einsatz

Um einen Ordner zu verschlüsseln oder einen bereits mit EncFS verschlüsselten Ordner zu importieren, klickt man mit der linken Maustaste auf das Schlüsselpaar. Um einen neuen verschlüsselten Ordner anzulegen, wählt man “Erstelle verschlüsselten Ordner”.

In dem Fenster, das sich anschließend öffnet, wählt man den übergeordneten Ordner aus, z.B. “Ubuntu One” und trägt den Namen des neuen Ordners ein, z.B. “Dokumente” und klickt dann, was ein wenig gewöhnungsbedürftig ist, links auf “Vor”. Dann trägt man sein Passwort zweimal ein. Das Passwort sollte natürlich nicht zu einfach sein. Man darf es aber auch nicht vergessen, denn dann sind die Daten im verschlüsselten Verzeichnis verloren. Ein Beispiel, für ein gutes Passwort, das ein paar Kriterien wie mindestens 8 Zeichen, Buchstaben gemischt mit Zahlen und Sonderzeichen erfüllt, aber auch gleichzeitig leicht zu merken ist, ist das Wort Passwort, wenn man es in dieser oder einer ähnlich Form schreibt:

Pa$$w0r+

[Update] Bitte beachtet den Kommentar von dakira weiter unten. Zitat: “Bei einem Dictionary-Angriff werden auch alle möglichen beliebten Substitutionen geprüft.”[/Update] Ein gutes Verhältnis zwischen praktischem Nutzen und Sicherheit muss aber jeder für sich selbst finden. Bestätigt man das Passwort, indem man wieder links auf “Vor” klickt, wird der verschlüsselte Ordner angelegt. Klickt man wieder mit der linken Maustaste auf das Schlüsselsymbol, werden dieser und eventuell andere verschlüsselte Ordner angezeigt. Ist der Ordner geöffnet, sieht man einen Haken davor.

Klickt man auf diesen Haken, wird der Ordner geschlossen. Klickt man erneut auf den Eintrag, wird das Passwort angefordert und die Dateien werden wieder entschlüsselt, was unter anderem durch den Haken anzeigt wird.

EncFS ver- und entschlüsselt aber nicht nur Ordner und die darin enthaltenen Dateien, es legt auch einen Mount-Punkt für die entschlüsselten Daten an, über den man auf seine Dateien zugreifen kann. Der Mount-Punkt kann leider nicht über den Dateimanager ausgehängt werden, sondern nur über Cryptkeeper, indem man, wie gesagt, den Haken bzw. den Eintrag mit dem Verzeichnis-Pfad anklickt.

Wie man im Terminal des Bildausschnitts sieht, bildet das FUSE-Framework das Fundament von EncFS, um normalen Nutzern das Mounten von verschlüsselten Verzeichnissen zu ermöglichen. Da EncFS dateiorientiert arbeitet, benötigt man keine eigene Partition und auch keinen Container, wie bei Truecrypt. Auf der anderen Seite hätte Truecrypt aber den Vorteil, dass man auch unter einem anderen Betriebssystem wie zum Beispiel Windows 7 wieder an seine verschlüsselten Daten kommen könnte, da FUSE nur unter Unix- und Gnu/Linux-Systemen verfügbar ist.

EncFS unter Windows

Man kommt an Windows leider nicht immer vorbei, es gibt aber mit EncFS4Win glücklicherweise ein Projekt, das einen Port für Windows auf der Basis von Dokan — user mode file system for windows bereit stellt. Daher installiert man zuerst die aktuelle Dokan-Bibliothek, um danach die Datei encfs.zip nach “C:\Program Files” zu entpacken. Das Programm ENCFSW.EXE, das man zum Entschlüssen der Ordner startet, bringt schon eine grafische Oberfläche ähnlich wie Cryptkeeper mit.

Man erkennt EncFS4Win an das Schlüsselsymbol in der Taskleiste. Soll das Programm automatisch starten, kann man einen Haken bei der Option “Start at login” setzen. Um einen verschlüsselten Ordner zu öffnen oder anzulegen, klickt man auf “Open/Create”.

Anschließend wählt man den verschlüsselten Ordner aus.

Da Windows anders als Unix-artige Betriebssysteme keine Mount-Punkte kennt, muss man dem zu entschlüsselnden Ordner einen Laufwerksbuchstaben zuweisen.

Der entschlüsselte Inhalt des Ordners steht dann unter diesem Laufwerksbuchstaben bereit. Anders als unter Ubuntu aber nur unter diesem Laufwerksbuchstaben und nicht nochmal innerhalb eines Ordners in Ubuntu One oder im Dropbox-Ordner.

EncFS unter Android

Mit Boxcrypter aus dem Android-Market hat man sogar die Möglichkeit, seine mit EncFS verschlüsselten Ordner unter Android zu öffnen. Kleiner Wermutstropfen ist aber, dass das leider nur mit Dropbox funktioniert. Andere Dateisynchronisations-Dienste wie Ubuntu One werden zur Zeit nicht unterstützt. Außerdem ist Boxcrypter noch in der Entwicklungsphase und kann verschlüsselte Dateien nur lesen. Die Schreibunterstützung soll aber bald folgen. Seit Anfang Oktober kann die kostenpflichtige Version von BoxCryptor auch innerhalb eines EncFS-Containers schreiben.

Ein weiterer Nachteil von Boxcrypter ist auch, dass es EncFS nicht voll unterstützt. Man muss beim Verschlüsseln der Dateien ein paar EncFS-Optionen deaktivieren, damit es funktioniert. Zuguter letzt ist noch wichtig, dass der Schlüssel nicht von der Synchronisierung durch Dropbox ausgenommen wird. Denn dann funktioniert es nicht.

Um einen verschlüsselten Ordner zu erstellen, der auch unter Android funktioniert, legt man ihn zusammen mit dem Mount-Punkt für das Volumen, in das man später die Dateien kopiert, im Terminal an:

mkdir ~/Dropbox/.encrypted
mkdir ~/Dropbox/Dokumente

Dann erfolgt die Einrichtung der Verschlüsselung mit EncFS:

encfs ~/Dropbox/.encrypted ~/Dropbox/Dokumente

Im folgenden Auswahlmenü wählt man dann “x” für den Expertenmodus:

Neuer verschlüsselter Datenträger wird erstellt.
Bitte wählen Sie eine der folgenden Optionen:
 "x" für den Expertenmodus,
 "p" für den vorkonfigurierten Paranoia-Modus,
 etwas anderes oder eine Leerzeile wählt den Standard-Modus.
?> x
Manuelle Konfiguration gewählt.

Als Verschlüsselungsalgorithmus kann man AES wählen,

Die folgenden Verschlüsselungsalgorithmen sind verfügbar
1. AES : 16 byte block cipher
 unterstützte Schlüssellänge zwischen 128 und 256 Bits
 unterstützte Blockgröße zwischen 64 und 4096 Bits
2. Blowfish : 8-Byte-Blockchiffre
 unterstützte Schlüssellänge zwischen 128 und 256 Bits
 unterstützte Blockgröße zwischen 64 und 4096 Bits
Geben Sie die Nummer Ihrer Auswahl an: 1
Gewählter Algorithmus "AES"

und bei der Schlüssellänge 128 Bit:

Bitte wählen Sie eine Schlüssellänge in Bit. Die von Ihnen gewählte Verschlüsselung
unterstützt Längen von 128 bis 256 Bit in 64 Bit Schritten.
Zum Beispiel: 
128, 192, 256
Gewählte Schlüssellänge: 128
Verwenden Schlüssellänge von 128 Bit

Bei der Dateisystem-Blockgröße kann man einfach mit der Enter-Taste den Standard übernehmen.

Anschließend ist es aber wichtig, bei den Verschlüsselungsalgorithmen für Dateinamen “Stream” zu wählen, in dem man die Taste “3″ drückt:

Die folgenden Verschlüsselungsalgorithmen für Dateinamen stehen zur Verfügung:
1. Block : Blockverschlüsselung, versteckt die Dateinamengröße etwas
2. Null : No encryption of filenames
3. Stream : Stromchiffre, möglichst kurze Dateinamen
Geben Sie die Nummer Ihrer Auswahl an: 3
Gewählter Algorithmus "Stream""

Beim Vector-Chaining muss man mit “no” bestätigen, bzw. irgendeine Antwort eingeben, die mit einem “n” beginnt, alles andere bedeutet ja:

Enable filename initialization vector chaining?
This makes filename encoding dependent on the complete path, 
rather then encoding each path element individually.
The default here is Yes.
Any response that does not begin with 'n' will mean Yes: no

Das Gleiche, also mit einer Eingabe, die mit einem “n” beginnt Nein zu sagen, muss man nochmal in der nächsten

Enable per-file initialization vectors?
This adds about 8 bytes per file to the storage requirements.
It should not affect performance except possibly with applications
which rely on block-aligned file io for performance.
The default here is Yes.
Any response that does not begin with 'n' will mean Yes: no

und in der übernächsten Abfrage machen:

Externe IV Verkettung abgeschaltet, da 'IV Verkettung'
und 'einmalige IV' Merkmale für diese Option benötigt werden.
Enable block authentication code headers
on every block in a file?  This adds about 12 bytes per block
to the storage requirements for a file, and significantly affects
performance but it also means [almost] any modifications or errors
within a block will be caught and will cause a read error.
The default here is No.
Any response that does not begin with 'y' will mean No: no

Zum Schluss muss man nochmal darauf achten, dass jedem Block-Vorspann keine Zufallsbytes hinzugefügt werden, indem man die Zahl 0 eingibt:

Sollen jedem Block-Vorspann Zufallsbytes hinzugefügt werden?
Das wird die Leistung veringern, aber sicherstellen, dass die
Blöcke unterschiedliche Sicherheitscodes verwenden. Sie können das selbe
Resultat mit geringeren Leistungseinbußen erzielen, indem Sie die dateispezifischen Initialisierungsvektoren aktivieren.
Auswahl der Anzahl der Bytes, von 0 (Keine Zufallsbytes) bis 8: 0

Mit Cryptkeeper kann man den neu erstellten verschlüsselten Ordner danach importieren. Wenn man im Fenster “Import an EncFS encrypted Folder” auf den Stift klickt, kann man den Pfad auch per Hand eingeben. Bei mir lautet er ~/Dropbox/.encrypted/:

Nach dem ersten Start von BoxCryptor auf dem Android-Handy muss man den verschlüsselten Ordner auswählen, in meinem Fall also .encrypted:

Hat man sein Passwort eingegeben, das man vorher bei der Erstellung des EncFS-Ordners angegeben hat, kann man auf seine verschlüsselten Dateien und Ordner lesend zugreifen:

Seit Ubuntu 10.11 Oneiric Ocelot ist MPlayer2 im Repository vorhanden und kann einfach im Terminal oder über das Ubuntu Software-Center installiert werden, so dass man kein PPA wie für Ubuntu 10.04 Lucid und höher mehr benötigt:

sudo add-apt-repository ppa:ripps818/coreavc
sudo apt-get update
sudo apt-get install mplayer

Ab Oneiric installiert man dann MPlayer2 wie folgt:

$ sudo apt-get install mplayer2
Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut       
Status-Informationen einlesen... Fertig
Die folgenden Pakete werden ENTFERNT:
  mplayer
Die folgenden NEUEN Pakete werden installiert:
  mplayer2
0 aktualisiert, 1 neu installiert, 1 zu entfernen und 0 nicht aktualisiert.
Es müssen 1.328 kB an Archiven heruntergeladen werden.
Nach dieser Operation werden 1.942 kB Plattenplatz freigegeben.
Möchten Sie fortfahren [J/n]?

Wie man sieht, wird das alte MPlayer-Paket entfernt und dafür MPlayer2 installiert. Der Start erfolgt nach der erfolgreichen Installation allerdings immer noch über den bekannten Befehl:

$ mplayer
MPlayer2 UNKNOWN (C) 2000-2011 MPlayer Team
Usage:   mplayer [options] [url|path/]filename

Man kann Mplayer ohne grafische Oberfläche auf der Konsole benutzen. Wer es ausprobieren möchte, kann sich das Ergebnis mit folgendem Befehl anschauen:

sudo mplayer -vo fbdev /Pfad/zum/Video

Die Rechte eines Superusers werden in diesem Testfall benötigt, weil sonst der Zugriff auf /dev/fb0 nicht gewährt wird.

Schöner ist es, MPlayer in einer Konsole innerhalb einer grafischen Oberfläche zu starten. Dazu reicht einfach

mplayer /Pfad/zum/Video

Für den Schnelleinstieg in die simple grafische Oberfläche reichen die Pfeiltasten zum Vor- und Zurückspulen, die Leertaste für Pausen, die Taste F für den Vollbildmodus und die Tasten 0 und 9 zum lauter und leiser stellen. Weitere Tasten sind:

Wer eine komfortablere Benutzeroberfläche benötigt, sollte SMPlayer aus dem Software-Center probieren. Wenn man aber ein bisschen mit der Konsole zurecht kommt und Spaß daran hat, braucht man keine andere Benutzeroberfläche. Radio geht wunderbar:

mplayer http://208.80.54.28/FUTUROAAC

und DVB-T klappt auch:

mplayer dvb://arte -cache 30720 -cache-min 5

Falls das Paket youtube-dl installiert ist, kann man mit MPlayer2 auch Youtube-Videos gucken, vorausgesetzt, man hat mit der Suchmaschine seines Vertrauens eine passende URL zum Video ermittelt:

sudo apt-get install youtube-dl
mplayer $(youtube-dl -g http://www.youtube.com/watch?v=u7Dg3LrhmIY)

Wenn man in den “Einstellungen” unter “Abgleichen” den Eintrag “Tomboy im Internet” wählt und anschließend “Connect” klickt, öffnet sich ein Browser-Fenster zum eigenen Ubuntu One-Konto, um Tomboy-Web zu legitimieren. Wenn das erfolgreich ist, steht dort: “Tomboy-Web-Legitimierung erfolgreich. Drücken Sie im Einstellungsfenster von Tomboy die Eingabetaste und klicken Sie auf »Speichern«, um mit dem Abgleich zu beginnen.” Nur kann man nicht auf “Speichern” klicken, weil der Button, anders als in der Abbildung unten, ausgegraut ist.

Der Fehler ist bekannt und wird hoffentlich bald behoben. Damit der Button nicht mehr ausgegraut ist, muss man im Feld mit der Adresse zum Server einfach etwas hinzufügen, oder den letzten Schrägstrich (Slash) von https://one.ubuntu.com/notes/ löschen. Danach kann man die Konfiguration speichern und der Abgleich der Notizen kann starten.

Die Suche nach einem Editor mit integrierter Shell kann man bei der PowerShell etwas abkürzen, da man im Zielverzeichnis der Installation PowerShell ISE findet. Die drei Buchstaben stehen für Integrated Scripting Environment, eine grafische Benutzeroberfläche, mit der man im selben Fenster nicht nur Befehle, sondern auch Skripte ausführen, schreiben und bearbeiten kann. Ziel des Workshops ist es, eine Liste von MP3-Dateien ohne Dateiendung zu erzeugen. Um eine Dateiliste auszugeben gibt es dank der Aliase viele Möglichkeiten. So kann man wie in der Bash ls nehmen, oder auch dir. Dahinter verbirgt sich jedes Mal das Cmdlet get-childitem, kurz gci.

.

Wie man auf der Abbildung sieht, listet get-childitem mehr Parameter auf, als man vielleicht möchte. Ich will zum Beispiel nur den Namen und nicht die anderen drei Parameter Mode, LastWriteTime und Length. Um die anderen Parameter auszuschließen, braucht man nur den eingeben, den man möchte. In meinem Fall also:

gci -Name

Um die MP3-Endungen der Auflistung zu entfernen, wird im Workshop der Befehl sed benutzt, den es leider in einer Standard-Installation von Windows nicht gibt. Anstelle von sed und einem regulären Ausdruck verwende ich eine ForEach-Schleife mit dem Replace-Parameter, die durch eine Liste von Objekten geht und dabei jedes Objekt einzeln abarbeitet. Das jeweilige Objekt wird in der Schleife mit $_ angesprochen, ein Platzhalter in der aktuellen Pipeline. Eine Eigenschaft eines Objekts wird dann mit $_.NameDerEigenschaft angesprochen. Solche Platzhalter heißen Automatische Variable. Wer genau wissen möchte, welche Automatische Variable es in der PowerShell gibt, kann sich mit folgendem Befehl einen Überblick verschaffen:

get-help about_automatic_variables

Eine Auflistung der MP3-Dateien im Verzeichnis, aber ohne die Dateiendungen, sähe dann folgendermaßen aus:

gci -Name | foreach {$_ -replace ".mp3", ""} > titelliste.txt

Mit der Umleitung in die Textdatei titelliste.txt wird die Dateiliste nicht in die Konsole geschrieben, sondern gleich in die Textdatei hinein, die für die CD-Hülle ausgedruckt werden soll. Führt man den Befehl ein zweites Mal aus, stößt man allerdings auf ein Problem: In der Textdatei stehen nicht nur die Titel, sondern auch der Name der Textdatei, weil die sich nun ebenfalls im Verzeichnis befindet. Damit sie nicht angezeigt wird, kann man alle Dateien mit der Endung TXT von der Liste ausschließen.

gci -Name -Exclude *.txt | foreach {$_ -replace ".mp3", ""} > titelliste.txt

Ich möchte auch gerne überprüfen, welche Infos in die Textdatei geschrieben werden und zur Kontrolle die Dateien zusätzlich auch noch in der Konsole ausgeben. Im Workshop von Ubuntu User wird dazu der Befehl tee benutzt, der wie ein T-Stück die Ausgabe in zwei Richtungen lenkt. Das Commandlet Tee-Object bewirkt in der PowerShell dasselbe und die Kurzform ist wie in der Bash tee. Das vollständige Kommando zur Ausgabe des Verzeichnisses mit den MP3-Dateien auf der Konsole und in eine Textdatei sieht dann so aus:

gci -Name -Exclude *.txt | foreach {$_ -replace ".mp3", ""} | tee titlliste.txt
01 sad robot
02 take me to the bonuslevel because i need an extralife
03 lemmings in love
04 space invaders
05 i want to be a machine
06 1_2 player game
07 game over
08 rock'n'roll hall of fame

Den Inhalt der Textdatei kann man dann auch ausdrucken, falls man schnell mal ein CD-Cover mit den Songs drauf braucht. Dazu muss man aber erstmal wissen, welche Drucker am Rechner überhaupt angeschlossen sind. In der Bash klappt das mit dem Befehl lpstat -a, in der PowerShell benötigt man dazu ein WMI-Objekt wie win32_printer.
Das Cmdlet für die WMI-Objekte heißt Get-WmiObject oder kurz gwmi. Mit der Umleitung in das Select-Objekt wird dann nur der Name des Druckers angezeigt:

gwmi win32_printer | select name
 
name
----
Brother HL-2030 series
Microsoft XPS Document Writer

Wenn man den Drucker weiß, kann man den Inhalt der Textdatei zum Drucker umleiten, wofür in der Bash der Befehl lp zuständig ist:

Get-Content titlliste.txt | Out-Printer -name "Brother HL-2030 series"

Windows selbst bietet keine Bordmittel, um einzelne Anwendungen von der Benutzerkontensteuerung herauszunehmen. Man kann zwar Anwendungen über die Aufgabenplanung mit höheren Privilegien starten, aber nur über eine Verknüpfung. Das fand ich für diesen Fall zu fummelig. In den “Eigenschaften” der einzelnen Anwendung kann man zwar die Option “Programm als Administrator ausführen” setzen, was aber nur funktioniert, wenn man die Benutzerkontensteuerung deaktiviert hat, wovon abzuraten ist.

Letztendlich habe ich das Tool Microsoft Application Compatibility Toolkit installiert, um die UAC für bestimmte Anwendungen zu deaktivieren. Ich habe dazu zwei Anleitungen gefunden, die beide behaupten, man könne beim Compatibility Administrator den Punkt “Als Administrator ausführen” mittels rechter Maustaste aus dem Startmenü anklicken. Bei mir ging es seltsamerweise nicht. Es klappt aber, wenn ich im Ordner “C:\Program Files\Microsoft Application Compatibility Toolkit\Compatibility Administrator” mit der rechten Maustaste auf die Anwendung klicke, um sie mit Administrationsrechten zu starten. So wie in der Anleitung beschrieben konnte ich dann die folgenden Anwendungen aus der Benutzerkontensteuerung heraus nehmen:

• C:\Program Files\Samsung\BatteryLifeExtender\BatteryLifeExtender.exe
• C:\Program Files\Samsung\BatteryLifeExtender\StartUpSetup.exe
• C:\Program Files\Samsung\Samsung Update Plus\SUPBackground.exe
• C:\Program Files\Samsung\EasySpeedUpManager\EasySpeedUpManager2.exe
• C:\Program Files\Samsung\SamsungFastStart\SmartRestarter.exe

Auf der Suche nach einer E-Mail-Adresse

Jetzt kann man sich eine mögliche und formal richtige E-Mail-Adresse für die Empfängerin ausdenken, eine E-Mail an diese Adresse schicken und darauf warten, ob der Mailserver die Nachricht auch erfolgreich zustellen kann. Wenn er nämlich scheitert, bekommt man eine Fehlermeldung als Antwort zurück. Entweder probiert man so lange herum, bis diese Antwort ausbleibt, oder man kann, um das Ganze abzukürzen, den Test auch in die Konsole verlagern. Das Werkzeug für diesen Test ist das Telnet [1], für das bei den meisten GNU/Linux-Distributionen, MacOS X und sogar bei Windows ein Tool vorinstalliert oder schnell nachträglich zu installieren ist.

In der Vergangenheit war Telnet eine unverschlüsselte und daher unsichere Methode für die Fernwartung von Rechnern. Der Vorteil von Telnet ist aber, dass man sich über den entsprechenden Port mit so ziemlich jedem Server verbinden kann, der ein textbasiertes Protokoll beherrscht, also auch mit Mailservern. Diesen Vorteil muss man allerdings mit Vorsicht genießen, da er auch von Spammern genutzt wird.

Woher kommt das Wort „Spam“?

Die Bezeichnung „Spam“ für Massenmails zu Werbezwecken im Internet wurde durch einen Sketch der englischen Komikertruppe Monty Python geprägt. Der Sketch [2] spielt in einem Imbiss, in dem es fast ausschließlich nur Spam (spiced ham), also „gewürzten Schinken“, auf der Speisekarte gibt. Auf die Frage, ob es auch etwas ohne Spam gäbe, antwortet die Kellnerin: „Well, there’s spam egg sausage and spam, that’s not got much spam in it.“ Woraufhin die Kundin sagt: „I don’t want ANY spam!“. Später, beim Versuch, etwas ohne Spam zu bestellen, kreischt sie sogar: „I don’t like spam!“ Spam wird in dem Sketch 132 mal genannt und steht synonym für eine unnötig häufige Verwendung und Wiederholung.

Wie funktioniert E-Mail eigentlich?

Bevor es losgeht, sollte man sich noch kurz klar darüber werden, was beim Versenden von E-Mails überhaupt passiert und ein paar Begriffe klären. In der Regel schreibt man eine E-Mail mit einem E-Mail-Programm, das auch E-Mail-Client oder, etwas technischer, „Mail User Agent“ (MUA) genannt wird. Traditionell werden die E-Mails vom „Mail Transfer Agent“ (MTA), das ist dann der Mailserver, entgegengenommen, falls nicht ein „Message Submission Agent“ (MSA) dazwischen geschaltet ist, der die E-Mails vom MUA an den MTA übergibt. Das Protokoll zum Versenden der Nachrichten zwischen diesen Servern heißt „Simple Mail Transfer Protocol“ (SMTP). Auf der Empfängerseite ist der „Mail Delivery Agent“ (MDA) verantwortlich für die Zustellung zum E-Mail-Client. Die Protokolle, die zum Abholen von Nachrichten verwendet werden heißen „Post Office Protocol“ (POP) oder „Internet Message Access Protocol“ (IMAP).

Der Weg einer E-Mail vom Sender zum Empfänger.
© Polluks (CC-BY-SA-3.0)

Nach der Theorie die Praxis

Normalerweise fragen Mailserver beim Versenden von E-Mails nach dem vollständigen Namen einer Domain. Da hier keine E-Mail verschickt werden soll, wird mit dem Befehl nslookup nach dem entsprechenden Domainnamen gesucht:

$ nslookup -q=mx google.com
Server:         192.168.178.1
Address:        192.168.178.1#53
 
Non-authoritative answer:
google.com      mail exchanger = 50 alt4.aspmx.l.google.com.
google.com      mail exchanger = 10 aspmx.l.google.com.
google.com      mail exchanger = 20 alt1.aspmx.l.google.com.
google.com      mail exchanger = 30 alt2.aspmx.l.google.com.
google.com      mail exchanger = 40 alt3.aspmx.l.google.com.

Gesucht wird nach dem „Mail Exchange Resource Record“ (MX-Eintrag) der Domain google.com im „Domain Name System“ (DNS), der sich ausschließlich mit dem E-Mail-Dienst (SMTP) beschäftigt. Wie man sieht hat Google gleich mehrere MX-Einträge mit unterschiedlichen Prioritäten, damit bei einem Ausfall der jeweils andere die E-Mails entgegen nehmen kann. Der Eintrag mit dem höchsten numerischen Wert hat meist die niedrigste Priorität. Das nutzen Spammer gerne aus, indem sie sich mit dem Mailserver mit der niedrigsten Priorität verbinden, um Spamfilter zu umgehen, die auf dem Server mit der höchsten Priorität laufen. Laut dem MX-Eintrag ist der Server mit der höchsten Priorität aspmx.l.google.com. Mit dem wird jetzt die Verbindung über Telnet und dem Port 25 für SMTP aufgebaut:

$ telnet aspmx.l.google.com 25
Trying 74.125.39.27...
Connected to aspmx.l.google.com.
Escape character is '^]'.
220 mx.google.com ESMTP 3si5028908fav.179

Was in diesem Fall bei Google klappt, kann bei anderen Mailservern schon schief gehen. Zur Abwehr von Spammern lassen einige Mailserver – zum Beispiel von GMX – eine Verbindung zum Server im MX-Eintrag gar nicht erst zu, wenn die Anfrage über die dynamische IP eines Client-PCs gestellt wird und nicht von einem anderen Mailserver kommt. Es kann aber auch sein, dass der Mailserver aufgrund einer Störung einfach nicht erreichbar ist.

Was einem der Statuscode so sagt

Die letzte Zeile der obigen Ausgabe beginnt mit einer Zahl, nämlich 220. Im SMTP-Protokoll werden Befehle der Reihe nach ausgeführt und jeder Befehl wird mit einem Statuscode beantwortet. Die Beschreibung, die auf den Statuscode folgt, ist für Menschen gedacht und für das Protokoll ohne Bedeutung. Beginnt der Statuscode so wie in diesem Fall mit einer 2, dann war die Bearbeitung erfolgreich, bei einer 3 fehlen noch Informationen und bei einer 5 ist ein Fehler aufgetreten.

Als erstes erwartet der Server eine Begrüßung in Form eines HELO, dabei ist es im Prinzip völlig egal, welches Argument man nach dem Befehl einträgt, auch wenn man eigentlich die eigene Domain angeben sollte:

helo hi
250 mx.google.com at your service

Der Statuscode mit der 2 am Anfang zeigt, dass der Befehl erfolgreich bearbeitet wurde und der Server zu Diensten steht. Anschließend gibt man die E-Mail-Adresse des Absenders mit dem Befehl MAIL FROM ein:

mail from: <test.user@googlemail.com> 250 2.1.0 OK 3si5028908fav.179

Die spitzen Klammern vor und nach der E-Mail-Adresse sind wichtig. Ansonsten erhält man einen Syntax Error. Als nächstes gibt man einen Empfänger ein, zum Beispiel eine Adresse von der man weiß, dass sie existiert:

rcpt to: <larry.page@google.com>
250 2.1.5 OK 3si5028908fav.179

Gibt es die E-Mail-Adresse wirklich?

Die 250 oben verrät, dass der Befehl erfolgreich war. Die E-Mail-Adresse scheint zu existieren. Doch auch hier gibt es die ein oder andere Falle, die Mailserver Spammern stellen.

Manche Mailserver haben ein Catch-All für E-Mails, dann laufen alle E-Mails mit einer formal richtigen E-Mail-Adresse der Domain in der gleichen Mailbox zusammen und der Mailserver antwortet in diesem Fall bei jeder formal gültigen Adresse mit einem „OK“.

Vielleicht wird auch eine Graue Liste zur Spambekämpfung eingesetzt. Dabei wird die erste E-Mail von einem unbekannten Absender abgewiesen und erst nach dem nächsten Zustellversuch angenommen.

Eine weitere Methode ist das „Sender Policy Framework“ (SPF). Hier schaut der empfangende Mailserver nach, ob die Domain im Befehl MAIL FROM mit dem Argument des Befehls HELO übereinstimmt. Wenn das nicht der Fall ist, kann es gut sein, dass der Rechner E-Mails für diese Domain gar nicht versenden darf. Dadurch soll das Fälschen von Absendern auf SMTP-Ebene erschwert werden.

Der nächste Versuch zeigt, dass der Mailserver von Google vermutlich kein Catch-All verwendet:

rcpt to: <sandra.fruendt@google.com>
550-5.1.1 The email account that you tried to reach does not exist. Please try
550-5.1.1 double-checking the recipients email address for typos or
550-5.1.1 unnecessary spaces. Learn more at                             
550 5.1.1 http://mail.google.com/support/bin/answer.py?answer=6596 3si5028908fav.179

Auch ohne den Statuscode sieht man, dass hier etwas falsch läuft. Die E-Mail-Adresse existiert laut dem Mailserver nicht. Das kann auch wiederum mehrere Ursachen haben: Entweder ist Frau Fründt eine Externe und gehört nicht zum Unternehmen oder es gibt dort mehr als eine Sandra Fründt oder die Administratoren bei Google halten ein einheitliches Namensschema für E-Mail-Adressen in einem Unternehmen für überbewertet. Ein paar Versuche später wird klar, dass der letzte Punkt zutrifft. Mit dem Befehl QUIT schließt man die Telnet-Sitzung wieder.

Zum Validieren reicht es nicht

Am Ende konnte die – vermutlich – korrekte E-Mail-Adresse von Frau Fründt zusammen mit den hier gesammelten Infos nur durch weiteres Googeln genauer abgeglichen werden. Zur Validierung von E-Mail-Adressen ist das Verfahren aus den oben genannten Gründen somit nur begrenzt geeignet und wäre mit einem Webdienst wie verify-email.org [3] wesentlich schneller gegangen. Im Prinzip lässt sich so eigentlich nur ermitteln, ob zum Zeitpunkt der Abfrage der Mailserver bereit oder in der Lage ist, den Mailversand zu einer bestimmten E-Mail-Adresse durchzuführen. Das kann für die Fehlerdiagnose bei Versandproblemen durch das Mailprogramm sehr hilfreich sein, indem man seinen eigenen oder den Mailserver des Providers testet und dessen Funktionsweise direkt in einer seiner Protokollsprachen SMTP, POP3 oder IMAP überprüft, aber auch zum Testen der eigenen Spamfilter.

Bonuslevel: Eine E-Mail über Telnet versenden

Eine E-Mail über Telnet zu versenden ist zwar etwas komplizierter, kann sich aber zum Testen durchaus lohnen [4]. Als Beispiel dient hier der Maildienst von Google, wobei andere E-Mail-Dienst-Anbieter ähnlich funktionieren sollten.

Das SMTP-Protokoll wurde aufgrund der zunehmenden Spamproblematik um Verfahren zur Authentifizierung und Verschlüsselung erweitert [5]. Um eine E-Mail zu verschicken, muss man häufig diese Erweiterungen des Mailservers nutzen. Welche aktiv sind, findet man mit dem Befehl EHLO heraus, der für „Enhanced HELO“ steht:

$ telnet smtp.googlemail.com 25 
Trying 74.125.39.16... 
Connected to googlemail-smtp.l.google.com. 
Escape character is '^]'. 
220 mx.google.com ESMTP d1sm327505fai.4 
helo hi 
250 mx.google.com at your service 
ehlo hi 
250-mx.google.com at your service, [89.182.218.152] 
250-SIZE 35882577 
250-8BITMIME 
250-STARTTLS 
250 ENHANCEDSTATUSCODES

Wie man an dem Beispiel gut sehen kann, schweigt sich der Befehl HELO darüber aus, welche Fähigkeiten der Server bei Verschlüsselung, Authentifizierung und so weiter besitzt. Die bekommt man nur als Antwort auf EHLO. Die Ausgabe von STARTTLS zeigt zum Beispiel, dass der Server Verschlüsselung unterstützt.

Codiertes Login

Aufgrund des vermehrten Spamaufkommens verlangen Mailserver heutzutage eine Authentifizierung. Zur Vorbereitung der Authentifizierung und weil man gleich sowieso eine verschlüsselte Verbindung über openssl aufbauen muss, verlässt man den Server jetzt mit dem Befehl QUIT.

Die Authentifizierung findet in einer Base64-Kodierung statt. Dazu gibt man im Terminal den Befehl base64 ein und drückt „Enter“. Anschließend folgt der Anmeldename, wieder gefolgt von „Enter“. Um die Eingabe zu beenden, drückt man die Tasten „Strg“ + „D“ und erhält in etwa folgendes Ergebnis:

$ base64 
test.user@gmail.com 
dGVzdC51c2VyQGdtYWlsLmNvbQo=

Das Passwort wird genauso mit Base64 kodiert. Wenn das erledigt ist, baut man die verschlüsselte Verbindung zum Mailserver mit openssl auf:

$ openssl s_client -starttls smtp -crlf -connect smtp.googlemail.com:25

Es folgt eine wirklich lange Ausgabe im Terminal, in der man unter anderem sehen kann, dass Zertifikate ausgetauscht werden. Wenn diese erste Hürde überwunden ist, begrüßt man den Server wieder mit EHLO:

ehlo hi 
250-mx.google.com at your service, [89.182.218.152] 
250-SIZE 35882577 
250-8BITMIME 
250-AUTH LOGIN PLAIN XOAUTH 
250 ENHANCEDSTATUSCODES

Nach der Begrüßung folgt das Login mit dem Befehl AUTH LOGIN und dem Base64-kodierten Benutzernamen gleich dahinter:

auth login dGVzdC51c2VyQGdtYWlsLmNvbQo=
334 UGFzc3dvcmQ6

Der Statuscode 3 zeigt an, dass der Server noch weitere Infos benötigt. Die Beschreibung, die einen darauf hinweisen soll, was genau noch fehlt, ist übrigens auch Base64-kodiert:

$ base64 -d 
UGFzc3dvcmQ6 
Password:

Das heißt, man soll das Passwort eingeben, natürlich Base64-kodiert:

RGFzaXN0R2VoZWltCg==
235 2.7.0 Accepted

Sender und Empfänger

Nach der Eingabe des Base64-kodierten Passworts wird die E-Mail geschrieben. Mit den Befehlen MAIL FROM und RCPT TO werden Sender und Empfänger der E-Mail festgehalten:

mail from: <test.user@gmail.com > 
250 2.1.0 OK l22sm324987fam.37 
rcpt to: <empfaenger@beispiel.net> 
250 2.1.5 OK l22sm324987fam.37

Wichtig ist, dass die E-Mail-Adressen in spitzen Klammern stehen. Man kann RCPT TO auch mehrmals benutzen, wenn man die E-Mail an weitere Empfänger versenden möchte.

Der Befehl DATA gibt an, dass jetzt die E-Mail folgt. Zu Beginn gibt man der E-Mail beliebige Kopfzeilen mit, wobei Absender, Empfänger und Betreffzeile hier am sinnvollsten sind. Welche Adressen man in den Kopfzeilen einträgt, ist egal, es können ganz andere sein, als die, die in den Befehlen MAIL FROM und RCPT TO weiter oben eingetragen wurden. So einfach kann man Absender fälschen.

data 
354  Go ahead l22sm324987fam.37 
From : Test <test.user@gmail.com>
To: Empfaenger <empfaenger@beispiel.net>
Subject: Hier kommt eine Testmail 
 
Hallo Empfaenger,
hier kommt eine Testmail. 
Viele Gruesse.

Wenn der Text fertig ist, beendet man den Befehl DATA mit einem einzelnen Punkt in einer separaten Zeile. Nach der Bestätigung der Eingabe durch den Mailserver ist die E-Mail verschickt und man verlässt Telnet wieder über den Befehl QUIT.

Links
[1] http://de.wikipedia.org/wiki/Telnet
[2] http://www.youtube.com/watch?v=anwy2MPT5RE
[3] http://wiki.ubuntuusers.de/Mailserver_testen
[4] http://www.linux-magazin.de/Heft-Abo/Ausgaben/2002/04/Transport-Sicherung

Um überhaupt etwas mit Pywinauto oder Win32com zu machen, muss man Python unter Windows installiert haben. Ich habe mich zum Beispiel für Python 3.2 entschieden. Alternativ gibt es auch noch die Communuty Edition von ActivePython, das schon extra Module wie Win32com mitbringt. Beim original Python muss man auf jeden Fall noch die Erweiterung Pywin32 herunterladen, wenn man das Modul Win32com nutzen möchte. Allerdings kann es passieren, dass der erste Versuch, das Modul zu importieren, auf einen Fehler hinaus läuft:

>>> import win32com.client 
Traceback (most recent call last):
File "D:\EQ\InventoryDumps\testScript1.py", line 1, in <module>
import win32com.client as win32
File "D:\Python32\lib\site-packages\win32com\__init__.py", line 5, in <module>
import win32api, sys, os
ImportError: DLL load failed: The specified module could not be found.

Ist das der Fall, kann man das Problem mit folgendem Befehl beheben:

C:\Python32\Scripts\pywin32_postinstall.py

Wenn die Installation erfolgreich ist, steht einem die Welt der Windows-Objekte wie COM oder WSH mehr oder weniger offen. So kann man mit COM Anwendungen aus dem Microsoft Office-Paket oder den Internet Explorer automatisieren. COM dient dabei zur Interprozesskommunikation und dynamische Objekterzeugung unter Windows. Bevor man die Funktionen von COM-Objekten nutzen kann, muss man sie instanzieren, wofür die COM-Komponenten Schnittstellen anbieten. Im folgenden Beispiel wird eine Instanz des Internet Explorers durch die Angabe seiner ProgID (“InternetExplorer.Application”) erzeugt:

import win32com.client
ie = win32com.client.Dispatch("InternetExplorer.Application")
ie.Visible = 1
ie.Navigate("http://www.datenteiler.de")
ie.GoHome()
ie.quit()

Nach der Instanzierung steht ein Internet Explorer bereit, der allerdings noch nicht zu sehen ist, außer als Prozess im Taskmanager oder mit dem Cmdlet Get-Process in der PowerShell. Der Prozess ist unabhängig vom Python-Interpreter. Wird die Konsole geschlossen, bleibt der Prozess erhalten und aktiv. Erst wenn man der Eigenschaft von Visible auf wahr setzt, wird diese Instanz des Internet Explorers sichtbar.
Wenn man sich mit dem Einsatz von COM-Anwendungen in der PowerShell auskennt, kommt einem der Quelltext doch bekannt vor:

$ie = New-Object -ComObject InternetExplorer.Application
$ie.Visible = $true
$ie.Navigate("http://www.datenteiler.de")
$ie.GoHome()
$ie.Quit()

Das folgende SendKey-Beispiel mit dem WSH kann auch zu einem Déjà-vu führen, wenn man den Python-Quelltext mit dem VBScript-Code vergleicht. Erstmal das Beispiel um Tastendrücke zu simulieren in Python:

import win32api
import win32com.client
shell = win32com.client.Dispatch("WScript.Shell")
shell.Run("Notepad") 
win32api.Sleep(1500) 
shell.AppActivate("Notepad") 
win32api.Sleep(1500) 
shell.SendKeys("Hallo Welt!{ENTER}") 
shell.SendKeys("^s")
shell.SendKeys("{ENTER}")
win32api.Sleep(1500)
shell.SendKeys("Hallo.txt{ENTER}")

Das Äquivalent in VBScript sieht dann so aus:

' SendkeyBeispiel.vbs
Option Explicit
Dim objWScriptShell
Set objWScriptShell = CreateObject("WScript.Shell")
objWScriptShell.Run "notepad"
Wscript.Sleep 1500 ' Warte bis Notepad fertig ist
objWScriptShell.SendKeys "Hallo Welt!{ENTER}"
objWScriptShell.SendKeys "^s"
objWScriptShell.SendKeys "{ENTER}"
Wscript.Sleep 1500
objWScriptShell.SendKeys "Hallo.txt{ENTER}"
WScript.Quit

Man kann mit dem Win32Com-Modul in Python noch einiges mehr anfangen, zum Beispiel die Maus positionieren und Mausklicks senden. Damit sind die Möglichkeiten von Python im Component Object Model oder des Windows Script Host bei weitem noch nicht ausgeschöpft.

# Bubblesort in Python
 
def bubblesort(a):
    for j in range(len(a) - 1):
        for i in range(len(a) - j - 1):
            if a[i] > a[i+1]:
                tmp = a[i]
                a[i] = a[i+1]
                a[i+1] = tmp
    return a
 
a = [3, 0, 1, 8, 7, 2, 5, 4, 6, 9]
print("Unsortiert: ", a)
 
result = bubblesort(a)	
print("Sortiert  : ", result)

Ich hoffe nur, dass ich die Musik auch wieder aus meinem Kopf bekomme. ;-)

[via zipfelmaus.com]