pixel
Select Page

NETWAYS Blog

Skalierungseffekte von freier Software

Ein beliebtes Argument für den Einsatz von quelloffener (und idealerweise freier) Software ist, dass sie billiger wäre als eine vergleichbare proprietäre Lösung. Diese Annahme erscheint intuitiv richtig, schließlich ist diese Software oft einfach auffindbar und kostet erstmal überhaupt nichts. Seien es Programme zur Bildbearbeitung (gimp, inkscape), Browser (firefox), anständige Emailprogramme (thunderbird, Instant-Messaging-/Chat-Clients (conversations, matrix clients, gajim), Instant-Messagin-/Chat-Server (ejabberd, matrix server oder ganze Betriebssysteme (debian, ubuntu, Arch Linux) (was eigentlich unvorstellbar ist, wenn man den Aufwand der Entwicklung und Wartung in Betracht zieht).

Trotz allem ist natürlich nicht zu übersehen, dass proprietäre Software ein sehr schweren Standpunkt hat, allen voran natürlich das Betriebssystem auf den meisten Desktop-Computern, das immer noch Windows ist. Außerdem gibts es natürlich noch Hunderte und Tausende von Anwendungen, die proprietär sind, aber weniger bekannt sind, vor allem Fachanwendungen, aber auch die kleinen Programme auf den mobilen Endgeräten. Im Folgenden möchte ich deshalb auf ein paar Gedanken meinerseitz eingehen, warum dies so ist, was ich daran kritisieren möchte und was potentielle Lösungsansätze sind.

Der Grundgedanke für diesen Artikel, ist die Idee, dass freie Software sehr gut skaliert. Damit ist erstmal nicht gemeint, dass diese zwangsläufig sehr gut mit großer Last zurechtkommt, sondern dass bei vielen Projekten eine steigende Nutzerzahl mit einer steigenden Qualität der Software korreliert. Mag ein Projekt von ein oder zwei motivierten Personen gestartet werden, kann sich bei ein paar Tausend regelmässigen Nutzern vielleicht die eine oder andere mit entsprechenden Programmierkrenntnissen finden, die wieder etwas beiträgt. Und selbst, wenn es nur fünf oder zehn Personen sind, so ist dort bereits sehr viel Potential vorhanden, falls die Beteiligten motiviert sind, was sie bei einer freiwilligen und oft ehrenahmtlichen Teilnahme dann typischerweise auch sind.

Das heißt natürlich nicht, dass beliebte Projekte endlos größer und immer besser werden, zahlreiche Beispiele belegen das Gegenteil. Schließlich sind auch FOSS-Projekte immer nur Gruppierungen von Menschen, bei denen es leicht zu Problemen kommen kann, zu Streit oder Zwists oder es ändern sich einfach die Umstände, manchen verlieren über Zeit das Interesse, es stehen die benötigten Ressourcen nicht mehr zur Verfügung oder der ursprüngliche Anwendungsfall für die Software schwindet. Nichtsdestotrotz würde ich behaupten, dass, für gewisse Voraussetzungen, ein freies Modell für Software erkennbar vorteilhaft ist.

Warum sind nun noch soviele proprietäre Komponenten vorhanden? Meine Theorie an dieser Stelle ist, dass es schwierig ist, in dieser Gesellschaftsform, damit Geld zu machen und auch wenn das Ziel der meisten Menschen nicht das reich werden ist, so ist natürlich trotzdem immer die Frage im Raum, von was denn die Miete bezahlt werden soll und natürlich auch die Frage ob man Zeit und Motivation hat, die Probleme anderer Leute (oder auch nur die eigenen) zu lösen.

Bei proprietärer Software ist das Modell noch relativ einfach, man verkauft die Software in diskreten Einheiten als Produkt (klassisch wie bei Brot, Tomaten oder Baggern), Abomodell mit zeitbegrenzten Lizenzen oder in diversen anderen abgestuften Modellen, bei denen Geld für weitere Komponenten oder spezielle Features verlangt wird. Alle diese Einnahmemodelle sind meistens für FOSS nicht anwendbar; zwar spricht nichts dagegen auch hier die Software als Produkt zu verkaufen, aber es fällt schon schwerer, wenn die meisten Leute nach kurzer Suche die kostenlose Version im Internet finden, die sich ja nicht verhindern lässt (und auch nicht soll). Bei verschiedenen großen Projekten ist das teilweise kein Problem, so wird die Entwicklung des Linux-Kernels finanziell von großen Firmen getragen, deren Produkte wiederum darauf basieren. Zwar wären vermutlich weder HP, IBM, Intel, NEC, Google, Oracle, Cisco, Huawei oder gar Microsoft auf die Idee gekommen, etwas zu starten, was der Konkurrenz oder gar einfach der Menschheit an sich etwas hilft und was ohne größere Hindernisse von jeder (mit einem Computer) benutzt werden kann, aber konfrontiert mit der Option einen toten Gaul zu starten (und damit haben die Firmen durchaus Erfahrung, Microsoft Google) oder mit knirschenden Zähnen trotzdem noch Geld zu machen, war dann die Wahl einfach.

Für FOSS-Software, die auch in Unternehmen (offensichtlich) wichtig ist, gibt es durchaus die Möglichkeit Consulting oder Support hust anzubieten, aber dies ist für Software für Privatpersonen schwierig, aber auch für die Komponenten die die Infrastruktur weiter hinten bereitstellen, etwa für die dann benutzten Bibliotheken und Werkzeuge. Während man für den Fall der Privatsoftware hauptsächlich auf Enthusiasten zurückgreifen kann oder muss, gibt es bei wichtigen Bibliotheken fast nur die Hoffnung, dass Personen in Firmen dafür abgestellt werden oder Institutionen wie die Apache Software Foundation hier unterstützen. Dies ist zwar nicht direkt das Szenario der Tragik der Allmende, aber eine gewisse Verwandschaft lässt sich schwer leugnen.

Warum sollte das nun eigentlich jemanden interessieren oder etwas vulgärer formuliert: Was geht mich das an? Durch diese Mechanismen, die sicherlich jemand schöner und präziser formuliert hat, werden riesige Mengen an Ressourcen verschwendet. Wobei Ressourcen hier hauptsächlich menschliche Zeit, Nerven und Privatspäre sind. Zusätzlich wird hierbei soviel Potential für eine tatsächlich bessere Zukunft verbrannt, dass bei einer Spekulation über die verlorenen Möglichkeiten die Tränen kommen. Dieser Punkt bedarf wohl ein wenig der Erläuterung, deshalb möchte ich mit einem Beispiel fortfahren:

Beispiel Videokonferenzen

Gerade im Zug der aktuellen Pandemie haben Videokonferenzlösungen riesigen Zulauf erhalten, mittlerweile dürfte fast jede mal irgendein Zoom, Webex, Teams oder etwas in der Form kennen gelernt haben, typischerweise mehrere davon und natürlich mit allen tollen Problemen, inklusive katastrophalem Datenschutz, Sicherheitslücken und vielem mehr. Das Problem daran ist, dass alle diese Systemen nur okayish funktionieren, alle nicht miteinander reden und einem komplett sinnbefreite Hürden in den Weg legen. Ich möchte hier deshalb ein utopisches Gegenszenario formulieren:

Ich habe einen Client (ein Programm) auf dem Computer für Videokonferenzen, ich bekomme einen Link für eine Videokonferenz, der auf irgendeinen Server zeigt, dann fragt es mich nach einem Passwort, einer Nutzername/Passwort-Kombination oder sonst einer Authentifizierung, falls diese denn überhaupt nötig sein sollte. Wenn ich eine Videokonferenz eröffnen wollte, würde ich dort einen Knopf finden und einen Link erhalten, den ich über die üblichen Kanäle (Email, Messenger) dann einer mehreren Personen senden kann und fertig. Das Programm kann mein Video- und Audiosignal aufnehmen, konvertieren und senden, sowie die der anderen Teilnehmer empfangen und darstellen. Dazu kommt ein simpler Chat-Mechanismus und vielleicht Spielereien wie Notizen oder so. Damit wäre dann der allergrößte Teil all dieser anderen System abgedeckt. Im Hintergrund spricht es SIP (ein Protokoll ursprünglich von 1996) und vielleicht noch XMPP für den Chat oder so. Alles kein Hexenwerk, da die Protokolle und Bibliotheken teilweise schon seit Jahrzehnten vorhanden sind und die ganzen, oben erwähnten, Implementationen vermutlich genau diese Techniken ohnehin verwenden(!). Das Programm verfügt über vernünftige Hardware-Beschleunigung, damit ich meinen Computer und den Laubbläser vor dem Fenster noch unterscheiden kann und ist idealerweise kein verkleideter Browser, der nach dem Prinzip “Leerer Speicher ist verchwendeter Speicher” arbeitet.

Nun gut, mag sich die geneigte Leserin denken, die bis hier durchgehalten hat, denken, das klingt doch ganz gut, warum haben wir das denn nicht und meine Antwort wäre lapidar: Es lässt sich mit sinnvollen Dingen einfach schwer Geld machen. Mit den Ressourcen von Microsoft, Google, Cisco und all den anderen Anbietern zusammen wäre so ein Projekt durchaus leicht machbar, man könnte ein sinnvolles Prozedere ausarbeiten für die Protokollverhandlungen, für Erweiterungen, für Best Practices, ein paar hochbezahlte und vielleicht gute Programmierer dafür abstellen und wir hätten alle mehr davon. Jetzt ist aber das Problem, dass jemand die Frage stellen würde, was denn Firma A davon hat, wenn Firma B das auch einfach mitbenutzen kann oder (Schnappatmung) JEDER einfach ihre eigenes System aufsetzen könnte! Keine Kontrolle, vielleicht sogar keine Einnahmung! Unmöglich! So etwas ist heute kaum vorstellbar, was eigentlich obskur ist, schließlich haben sich vor Jahren (oder Jahrzehnten) genau solche Ansätze verbreitet, wie etwa Email. Ich kann mir tatsächlich nicht vorstellen, das so etwas wie Email noch einmal passieren könnte, mal ganz abgesehen davon, dass dieses Ökosystem unter der einseitigen Beeinflussung der großen Spieler auch schon massiv leidet.

Meine Verallgemeinerung dieser Situation ist folgende: Durch das Etablieren großer Monopole in dem Bereich wird die Entwicklung von tatsächlich nützlichen Dingen erheblich gebremst. Die simplistische Theorie des freien Marktes, der das beste Produkt befördert, funktioniert nur für den sehr eingeschränkten Rahmen etwa gleich großer (vieler) Spieler und Kunden mit sehr guten Informationen. Letzteres ist in Zeiten von endemischen absurden Marketingkampagnen und komplexen Thematiken ein Traum und ersteres bei großen Konzernen, die sich an zwei Händen abzählen lassen, auch nicht mehr gegeben. Jedes vielversprechende Startup (also ein Startup das viel Geld verspricht) wird schließlich bei dem geringsten Anzeichen von Erfolg von einem der Großen aufgekauft. Üblicherweise geht dabei dann alles Sinnvolle kaputt und das ganze Produkt wird dann abserviert, aber das ist auch nicht so tragisch, schließlich hat man sich relativ billig einen potentiellen Konkurrenten vom Hals geschafft.

Beispiel ÖPNV

Nehmen wir ein weiteres Beispiel zur Hand: Apps für den öffentlichen Personennah- und -fernverkehr. Nachdem ich sowieso den Miniaturcomputer in der Tasche habe, wäre die Anzeige des Fahrplans, der Ausfälle und Verspätungen und der Kauf der jeweiligen Tickets schon ein ziemliches Feature. Soweit, so gut, das Problem beginnt aber schon beim Umstieg von Nah- auf Fernverkehr, ersteres kann ich hier (im Raum Nürnberg) mit der VGN-App erledigen, für zweiteres bräuchte ich dann den DB Navigator (das hier) und dann in einer Zielstadt potentiell noch eine Dritte. Nun gut, dass sind verschiedene Unternehmen, erscheint zunächst mal logisch. Ich tendiere aber ein bisschen zum Minimalismus und suche deshalb nach der Lösung, die mit kleinstem Aufwand meine Anforderungen erfüllt. Meine Anforderung ist, von A nach B zu kommen, möglichst wenig Zeit und Geld dafür zu verbrauchen plus etwas abstraktere Kriterien wie “Ich möchte wissen von welchem Gleis wann welches Zug in welchem Abteil”. Alles Andere ist Unfug, wie etwa drei Apps dafür zu haben. Nachdem ALLE Personentransportgeschichten fast das gleiche tun, gibt es keinen Grund warum jeder jetzt das Rad nochmal neu erfindet!

Vermutlich gibt es ein paar Hundert Unternehmen weltweit, die fast das exakt gleiche bauen, fast völlig ohne Not. Natürlich sind alle Streckennetze ein wenig unterschiedlich, die Preisstrukturen auch und natürlich sind verschiedene Sprachen und kulture Gepflogenheit zu beachten, aber gibt es wirklich einen guten Grund Tausende halbgare Apps zu haben anstatt drei bis fünf (Monokulturen sind auch in der Software eine schlechte Idee, deshalb mehr eine) Gute? Es gibt Ansätze das Problem zu negieren (wie etwa die Öffi-App), aber das ist wieder mal ein kleines Team (eine Person?) die mühevoller Arbeit die ganzen APIs zusammenstückelt und natürlich ist dann Bezahlen auch keine Option darin.

Warum setzen sich denn die ÖPV-Unternehmen nicht zusammen und bauen das zu einer vollständigen Lösung aus? Mein Softwarewunsche hier wäre eine App mit der ich meine Ziele eingeben kann, die Optionen angezeigt bekomme, sinnvoll bezahlen kann und die mir dann sagt wann ich wo sein muss. Alles andere ist unnötig.

Anmerkung: Ich habe keine der oben erwänten Apps installiert, da alle keine freie Software sind, mit Trackern vollgestopft und nicht in Fdroid verfügbar. Pls fix.

Beispiel CAD-Software

Dies ist nun schon ein Nischenthema, aber durch, zumindest kleine, Einblicke in diese Sparte, bekommt man leicht das Gefühl eines großen Problems. Eine einstellige Anzahl von großen Spielern arbeitet an einer Reihe von mittelschlechten Softwareprodukten die natürlich alle nicht sinnvoll miteinander kompatibel sind. Diese sind dann natürlich extrem kostspielig (und außerdem schwierig zu benutzen). Ganz abgesehen davon, dass eine Firma mit der Wahl der Software sich in dieser Wahl “einschliesst”, sind diese Produkte für Hobbyisten, Startups oder kleine Unternehmen kaum erschwinglich. Ich kann nur darüber spekulieren wieviel Potential an interessanten Ingenieurskreationen dadurch verloren geht. Was wäre wenn ein ambitionierter Hobbyist ein Konzept für eine sinnvolle oder zumindest schöne Konstruktion einfach konstruieren und idealerweise noch simulieren könnte ohne sich sehr tief in die (leider noch qualitativ nicht so guten) freien Lösungen einzuarbeiten oder sehr viel Geld für eine teure Lizenz opfern. Das im Zweifelsfall die Formate auch nicht sinnvoll kompatibel sind, ist dann die Austauschbarkeit und Weitergabe eingeschränkt, was wiederum unnötige Mehrarbeit erzeugt.

Ausblick

Ich habe die Theorie das die Softwarewelt in der aktuellen Situation furchtbar ineffizient, rückständig, unsicher und unnötig schädlich für die Benutzer ist und vor allem, dass dies kein notwendiger Zustand ist, sondern eine Folge eines Denkens und Wirtschaftens, dass nicht den größten Nutzen vieler sondern nur Einzelner anstrebt (vielleicht nicht mal das). Diese Probleme begleiten uns täglich und werden auch absehbar nicht verschwinden, zumal sie sich sehr vertraut anfühlen, wenn man die Ursachen und die mangelnde Reaktion auf die Klimakatastrophe als Vergleich heranzieht. Zu ihrer Überwindung bräuchte es große organisatorische und vor allem willentliche Anstrengunen und ich hoffe, dass ich einen kleinen Beitrag dazu leisten kann, dass diese auch mal angegangen werden. Deshalb gibt es noch ein paar konkretere Vorschläge:

Abschaffung und Einschränkungen von Monopolen
Einzelne Unternehmen dürfen keine signifikanten Anteile an irgendeiner Sparte haben und müssen Schnittstellen für Komponenten von anderen Anbietern bieten. Die Benutzung dieser Schnittstellen darf nicht rechtlich eingeschränkt und künstlich blockiert werden

Öffentliche Gelder, öffentlicher Code
Ist das Motto der Kampagne der FSFE. Öffentliche Gelder dürfen nicht oder nur in sehr eingeschränkten Fällen zur Erstellung von nicht-freier Software benutzt werden

Keine proprietären Softwarekomponenten beschaffen oder verwenden, wenn dies in freier Software umgesetzt werden könnte. Es lohnt sich auf lange Sicht.

Unterstützt freie Software
Lasst den Entwicklern von eurer liebsten freien Software mal ein Dankeschön und etwas Geld da, das kann es einem auch mal wert sein

Zu guter Letzt möchte ich der geduldigen Leserin danken, die bis hierhin durchgehalten hat und möchte dazu einladen ein wenig Feedback dazulassen, falls es hier Zustimmung oder (fast noch wertvoller) Korrekturen und Kritig gibt.

Anschließend gibt es noch eine Sektion mit unbeliebten und unnötig geäußerten Meinungen zur Unterhaltung.

Unbeliebte Meinungen

Diese Sektion drückt meine persönliche Meinung und keine Position der Firma aus, welche dafür doch bitte keine Shitstorm bekommen sollte und bla bla bla. Wer sich angegriffen fühlt, darf mir dass in gewählter Wortwahl mitteilen oder für sich beleidigt sein.

  • Blockchains und Cryptowährungen sind Betrugsmaschen. Sie sind zu (fast) nichts nütze und sollten einfach nicht benutzt werden (Ich scheue hier das Wort “verboten”, aber unsympathisch ist es nicht). Jede Beteilung daran, macht einem zu einem Abzocker oder einem Opfer davon. Cryptowährungen sind ein System um Hoffnung auszunutzen und es ist nicht nur ein Nullsummenspiel, es ist ein Negativsummenspiel. Es macht die Welt insgesamt schlechter. Es ist falsch mitzumachen. Es wird da absehbar nichts Sinnvolles entstehen. Links: The Case against Crypto The Simple English Argument Against Crypto The Complete Argument Against Crypto The Philosophical Argument Against Crypto
  • Das gilt auch für NFTs was noch eine viel absurdere Idee. Das ist keine Verbesserung des Kunstmarktes, es ist ein Paradies für (Ab)Zocker
  • Die “sozialen Netzwerke” oder “sozialen Medien” sind größtenteils keine, sie dienen als Werbeplattform und damit zur Manipulation der Benutzer. In Summe schaden sie meiner Ansicht nach der geistigen Gesundheit schon der zugrunde liegenden Mechanismen wegen

Werbung

  • Es gibt eine neue Auflage des Icinga-Buches!
  • Sinnvolle stabile und bewährte Chat-Lösung gesucht? Wie wäre es mit XMPP? Zum selber hosten oder einfach. DSGVO-kompatibel einfach machbar, interoperabel, stabil, E2E-Verschlüsselung möglich
  • Die Free Software Foundation Europe wirbt im digitalen Raum für Bürgerrechte, freie Software und allgemein sinnvolle Entwicklungen. Kann man mal anschauen
Lorenz Kästle
Lorenz Kästle
Consultant

Lorenz hat seinen Bachelor der Informatik an der FAU gemacht und sich zuletzt mit Betriebssystemen dort beschäftigt. In seiner Freizeit beschäftigt er sich ein wenig mit XMPP und der Programmiersprache Erlang.

Administrators Toolbox: SSH

SSH

“Secure Shell oder SSH bezeichnet ein kryptographisches Netzwerkprotokoll für den sicheren Betrieb von Netzwerkdiensten über ungesicherte Netzwerke.[1] Häufig wird es verwendet, um lokal eine entfernte Kommandozeile verfügbar zu machen, d. h., auf einer lokalen Konsole werden die Ausgaben der entfernten Konsole ausgegeben, und die lokalen Tastatureingaben werden an den entfernten Rechner gesendet. Genutzt werden kann dies z. B. zur Fernwartung eines in einem entfernten Rechenzentrum stehenden Servers. Die neuere Protokoll-Version SSH-2 bietet weitere Funktionen wie Datenübertragung per SFTP.” [0]

Damit dürfte SSH den meisten Administratoren schon ein Begriff sein, zumindest wenn eine Maschine mit einem Unix im Netzwerk vorhanden war. Falls noch Unklarheit besteht: Wenn gelentlich PuTTY geöffnet wird, wird sehr wahrscheinlich SSH eingesetzt. Die Vorteile von SSH sind schnell benannt, es bietet schnelle, stabile, sichere (authentifiziert und verschlüsselt) und bandbreitensparsame Verbindungen ohne grossen Aufwand dafür betreiben zu müssen. Die Beginne des Protokolls liegen in den 90ern als damit mehrere klassische Unix-Dienste abgelöst wurden und seitdem gibts es nur selten grössere Neuerungen [1]. Dennoch sind einige sehr nützliche Funktionen in SSH recht unbekannt und dem soll hiermit Abhilfe geschaffen werden. Im folgenden gehe ich dabei auf zuerst ein wenig auf die Grundlagen ein und dann auf die etwas weniger bekannten Eigenschaften.

Das erste Mal

Ein typische SSH-Session beginnt mit der Eingabe des ssh-Kommandos und der Zieladdresse, also etwa eines DNS-Namens oder einer IP-Addresse:

# ssh 192.168.178.23

Ohne weitere Angaben wird dabei wird als Loginname der des aktuellen Nutzers verwendet, bei PuTTY wird man beim einwaehlen nach dem Loginnamen gefragt. Beim ersten Mal wird die folgende Meldung bzw. das Aequivalent auf PuTTY erscheinen:

The authenticity of host '192.168.178.23 (192.168.178.23)' can't be established.
ED25519 key fingerprint is SHA256:cBmwx2ZFgoK0EBvWf2CDtiu5a9hoPMn4xH4LjEnPH64.
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])?

Es ist an diesem Punkt bereits eine Verbindung zum Zielrechner aufgebaut und der öffentliche Schlüssel des Hosts abgerufen worden. Ohne jetzt auf die Details von asymmetrischer Kryptographie einzugehen zu wollen, muss dieser Mechanismus kurz erlaeutert werden. Bei der Installation erzeugt der SSH-Server ein oder mehrere Schlüsselpaare, ein Paar besteht aus einem öffentlichen und privaten Teil, diese sind mathematisch verbunden. Daten die mit dem öffentlichen Teil verschlüsselt werden sind nur mit dem privaten Teil entschlüsselbar. Mit dem privaten Teil können Daten signiert werden, was mit dem öffentlichen Teil verifiziert werden kann, dass heisst, die gesendeten Daten wurden genau so von etwas versandt, was Zugriff auf den privaten Schlüssel hat (als typischerweise die Person oder Maschine die den Schlüssel besitzt). Ein aehnliches Prinzip kommt auch an vielen Stellen beim Einsatz von TLS zum Tragen, also z.B. beim normalen Besuch einer Website (wenn oben in der Addressleiste des Browsers ein Schlosssymbol ist). Aufgrund eines Systems von Vertrauensankern kann jedoch der Browser schon mehr oder weniger garantieren, dass die Gegenstelle auch die gewünschte ist, ohne den Nutzer nach einer Bestaetigung zu fragen. Dieses Verfahren kommt bei SSH normalerweise NICHT zum Einsatz, dazu aber spaeter mehr.

Mit einem yes oder der Eingabe des Fingerabdrucks des öffentlichen Schlüssel des Ziels kann nun bestaetigt werden, dass man diesen als authentisch annimmt, bei PuTTY gibt es dementsprechende Knöpfe. Anmerkung: Diese Meldung wird, der Erfahrung nach, IMMER und ohne Verifikation ignoriert. Dies ist in einem kontrollierten Netzwerk (zuhause oder vielleicht auch in einem Betrieb) vermutlich unbedenklich, nicht jedoch, wenn die Verbindung nicht der eigenen Kontrolle unterliegt. Ein Angreifer kann sich an dieser Stelle zwischen den Nutzer und das Ziel schalten! Diese Verifikation sollte also mit Bedacht und mittels eines zweiten (gesicherten) Kanals erfolgen. Wenn man zum Beispiel über eine virtuelle serielle Schnittstelle der Virtualisierungssoftware Zugriff auf die Maschine hat, so kann man mit ssh-keygen den Fingerprint ermitteln:

# ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub
256 SHA256:cBmwx2ZFgoK0EBvWf2CDtiu5a9hoPMn4xH4LjEnPH64 root@generic-debian11 (ED25519)

Dabei ist zu beachten, dass heutzutage mehrere Schlüsselpaare vorhanden sind und in /etc/ssh/ das passende ausgewaehlt werden muss, hier ist das ED25519, es könnte aber auch z.B. RSA oder ECDSA sein. Dies sind verschieden Algorithmen, was hier erstmal ignoriert wird.

Anschliessend sollte die Passwortabfrage erscheinen bzw. unter PuTTY die Frage nach dem Loginname:

user@192.168.178.23's password:

Nach der Eingabe des Passwortes landet man dann auf der eingestellten Loginshell.

SSH-Schlüssel

Das Passwort jedesmal einzugeben ist natürlich unnötige Arbeit und zudem problematisch, da dann schlussendlich doch schlechte und/oder schon mal benutzte Passwörter verwendet werden. Die Lösung dafür ist recht einfach und schon vorhanden: SSH-Schlüssel. Das klingt ja erstmal wie das Thema weiter oben und tatsaechlich ist es in etwa auch das Gleiche, nur dass wir dieses Mal das Schlüsselpaar für einen Nutzer verwenden. Dafür wird zuerst mal ein Schlüsselpaar erzeugt:

ssh-keygen
Enter file in which to save the key (/home/user/.ssh/id_rsa):

hier kann nun ein gewünschter Dateipfad angegeben werden (alternativ gleich in den Befehl mit der Option -f)

Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:

Wie die Ausgabe beschreibt, kann hier eine Passphrase gesetzt werden, dies ist natürlich empfehlenswert. Waehrend einer laufenden Nutzersitzung, kann der Schlüssel einem SSH-Agenten hinzugefügt werden, so dass das Passwort nur einmal eingegeben werden muss.

Your identification has been saved in /home/user/.ssh/id_rsa
Your public key has been saved in /home/user/.ssh/id_rsa
The key fingerprint is:
SHA256:NY92co2ANzzBp6P82ILfZpmRALePZJxvU1Yxpt5UgGk user@host
The key's randomart image is:
+---[RSA 3072]----+
|         ..  o=o.|
|      . .o..Eo.o |
|       +.oO+...  |
|        BooOo=   |
|       +S*+=* o  |
|        +.B+     |
|       . = =     |
|      . o.B      |
|       ..+.      |
+----[SHA256]-----+

Der weitere Output zeigt dann noch den Erfolg der Operation an und stellt (aus irgendwelchen Gründen) den Fingerprint graphisch dar. Der Schlüssel kann dann auf die Zielmaschine kopiert werden:

ssh-copy-id -i $PFAD_ZUM_OEFFENTLICHEN_SCHLUESSEL $USER@$ZIEL

(wobei natürlich alle mit $ beginnenden Parameter durch die realen Werte ersetzt werden müssen) und dann benutzt werden mittels:

ssh -i $PFAD_ZUM_PRIVATEN_SCHLUESSEL $USER@$ZIEL

Da der Aufruf immer noch recht lang ist, kann man in einer Konfigurationsdatei ein paar Parameter setzen. Die Standardkonfigurationsdateien auf Unix-Systemen ist vermutlich ~/.ssh/config.

Host bla
    User $USER
    Hostname $ZIEL
    IdentityFile $PFAD_ZUM_PRIVATEN_SCHLUESSEL

Danach ist der Aufruf nur noch ssh bla. In PuTTY ist das Erstellen von Schlüssel und den Konfigurationseintraegen durch Klicken möglich.

Dateitransfer

Es gibt hier verschiedene Möglichkeiten:

1.scp Die Verwendung von scp ist relativ simpel und auch brauchbar für Skripte:

scp $LOKALE_DATEI $ZIELHOST:$ZIELORT_ODER_DATEI
scp $ZIELHOST:DATEI $LOKALE_ZIEL_DATEI

2.sftp Die Verwendung erinnert an die des Kommandos ftp und ist interaktiv, inklusive Verzeichniswechsel usw.

3.sshfs Eine FUSE-Implementierung von einem Dateisystem über SSH.

sshfs $ZIELHOST:$PFAD $LOKALES_VERZEICHNIS

haengt $PFAD des $ZIELHOST im $LOKALES_VERZEICHNIS ein.

Netzwerk

Ein paar sehr nützliche Features sind die Netzwerkoptionen von SSH, z.B.:

ssh -L 5555:bla:80 foo

transportiert alle Anfragen die an den lokalen Port 127.0.0.1:5555 gehen über SSH an den Host foo von wo aus sie über den normalen Netzwerkpfad (ohne SSH-Tunnel) dann auf Port 80 auf bla gehen. Sehr nützlich, wenn man etwa ein nur lokal erreichbares Webinterface besuchen möchte.

ssh -R 5555:localhost:6767 $ZIEL

Das Gegenstück, öffnet auf dem $ZIEL den Port 5555 und leitet in an den lokalen Port 6767 weiter.

ssh -J hop1,hop2 ziel

“Springt” per SSH über hop1 und hop2 zu ziel. Natürlich muss sich der Nutzer auf allen Systemen authentifizieren, aber benötigt keine Shell. Es können damit reine Gateways benutzt werden, die als “Eingangstor” in ein Netzwerk dienen.

ssh -D 6767 $ZIEL

Öffnet eine dynamische Port-Weiterleitung auf $Ziel. Kann auch von Browsern als SOCKS Proxy verwendet werden.

ssh $ZIEL -o "ProxyCommand=nc -X connect -x $PROXYHOST:$PROXYPORT %h %p"

Verbindet sich über den (HTTP-)Proxy $PROXYHOST auf Port $PROXYPORT zum $ZIEL

SSH-Zertifikate

Während die bisherigen Abschnitte SSH-Grundlagen und diverse Nutzungsmöglichkeiten behandelt haben, stellt sich dem interessierten Lesen oder auch dem fortgeschrittenen Nutzer schon die Frage nach der Skalierung solcher Setups. Die Authentizität einer Verbindung ist ja theoretisch durch die Schlüssel sicher gestellt, aber rein praktisch ist da die Problematik, dass man ja erstmal alle Host-Schlüssel in seiner ~/.ssh/known-hosts sammeln muss. Bei großen und dynamischen Umgebungen ein Sysiphos-Unterfangen, dass recht bald in Problemen resultiert. Das gleiche gilt natürlich für die Schlüssel der Nutzer. Da diese lokal für den sshd (den SSH-Daemon) verfügbar sein müssen, müssten potentiell ALLE Schlüssel ALLER Nutzer auf ALLE relevanten Maschinen kopiert und dort natürlich auch aktualisiert werden. Netzwerkdateisysteme sind natürlich ein Aus- oder Umweg, aber bergen das Risiko, dass bei einem Ausfall dieser Infrastruktur der Login überall sonst nicht mehr funktioniert. Naheliegenderweise gibt es dafür zumindest teilweise eine Lösung. In SSH gibt es nämlich auch Komponenten für eine Zertifikatsinfrastruktur. Diese ähnelt ein wenig der von TLS, ist jedoch deutlich rudimentärer und simpler. Dabei lassen sich SSH-Zertifizierungsschlüssel erstellen, die sowohl Host- als auch Nutzerschlüssel signieren können. Ein Nutzer muss dann nur noch dem Zertifizierungsschlüssel vertrauen um einen Host zu verifizieren und ein Host um einen Nutzer zu authentifizieren.

Der Zertifizierungsschlüssel besteht dabei, wie bisher bei den anderen Schlüsseln, auch wieder aus einem Schlüsselpaar:

# ssh-keygen -f ./ca_host_key -t ed25519
Generating public/private ed25519 key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in ./ca_host_key
Your public key has been saved in ./ca_host_key.pub
The key fingerprint is:
SHA256:3UmaB6K4wy/obEBhmeGYWZIKnlvF9emPY8xQgZmygPM user@host
The key's randomart image is:
+--[ED25519 256]--+
|.o* . ..+.       |
|=% . + +. o      |
|O.= o o .+. .    |
|.+ E o .oo * .   |
|. o . ..S.+ +    |
|.. . .  + o.     |
| . .+    * .     |
| .o .o  . .      |
| oo  ..          |
+----[SHA256]-----+

# cat ./ca_host_key.pub
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAICCdmjMLjw+WGI+Aj1FUHUCG16daqoyeet+GZWi1O/TS user@example.com

und damit können nun Host- oder Nutzerschlüssel signiert werden. Der Parameter -I enthält dabei die certificate_ID welche im Prinzip frei wählbar ist, aber für diesen Fall (der Host-Zertifikate) auf den eindeutigen Hostnamen gesetzt werden sollte.

# ssh-keygen -s ca_host_key -I testhost.local -h /etc/ssh/ssh_host_ecdsa_key.pub
Signed host key /etc/ssh/ssh_host_ecdsa_key-cert.pub: id "testhost.local" serial 0 valid forever

Dabei wird eine neue Datei host_ecdsa_key-cert.pub erstellt, die den unterschriebenen öffentlichen Schlüssel enthält, das sieht dann ungefähr so aus:

# cat ssh_host_ecdsa_key.pub
ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBMuXZN6or69chS+ZT6++P37JeRC5km+cIbzXnfCos9hvJ9jUbB+Becozdcmhfhj6Udg6FfxwDJqc5WaKHA0uErY= root@example.com
# cat ssh_host_ecdsa_key-cert.pub
ecdsa-sha2-nistp256-cert-v01@openssh.com AAAAKGVjZHNhLXNoYTItbmlzdHAyNTYtY2VydC12MDFAb3BlbnNzaC5jb20AAAAgtZ2LJPOCioVR9tG19Zekk3x6qru6bYXCIlMXsKSc43QAAAAIbmlzdHAyNTYAAABBBMuXZN6or69chS+ZT6++P37JeRC5km+cIbzXnfCos9hvJ9jUbB+Becozdcmhfhj6Udg6FfxwDJqc5WaKHA0uErYAAAAAAAAAAAAAAAIAAAAOdGVzdGhvc3QubG9jYWwAAAAAAAAAAAAAAAD//////////wAAAAAAAAAAAAAAAAAAADMAAAALc3NoLWVkMjU1MTkAAAAgIJ2aMwuPD5YYj4CPUVQdQIbXp1qqjJ5634ZlaLU79NIAAABTAAAAC3NzaC1lZDI1NTE5AAAAQFgq6IqNBRjJrysFdBHHceU83AXF0Vg13uq17ZJXn2hk98H6rRnLCV8XvOtRd9o1bxtc8xQ7Poigw4wuRbMjigY= root@testhost.local

Nun fehlt nur noch ein Eintrag in die known_hosts Datei:

@cert-authority *.example.com ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAICCdmjMLjw+WGI+Aj1FUHUCG16daqoyeet+GZWi1O/TS

Damit werden alle Host-Schlüssel akzeptiert, die von einem Host mit dem Namensmuster *.example.com kommen und mit dem Zertifizierungsschlüssel signiert sind.

Dasselbe lässt sich prinzipiell gleichartig auf Nutzerschlüssel übertragen, auf ein Beispiel wird hier nun verzichtet um diese Vorstellung hier knapp zu halten. Jedoch gibt es den einen oder anderen Punkt, der erwähnt werden sollte: Da es sich hier nicht um TLS handelt und die ganze Struktur sehr viel schmaller ist, ist das Widerrufen von Schlüsseln anderst gelöst. Es gibt keine zentrale Stelle die Revocation Lists führt, die abgefragt werden können. Eine solche Liste muss sich lokal auf der Maschine befinden, also etwa mit Ansible, Puppet, Salt, Chef… plaziert und aktualisiert werden. Dies ist natürlich gerade für Nutzerschlüssel zu empfehlen. Zusätzlich sollte erwähnt werden, dass es durchaus die Möglichkeit gibt, das System zu erweitern und eigene Erweiterungen zu erstellen, beispielsweise mit der AuthorizedKeysCommand-Direktive in der sshd-Konfiguration die einem erlaubt ein eigenes Programm zu erstellen/verwenden um die Nutzer zu authentifizieren und damit wiederum eine Anbindung an Datenbanken oder Netzwerkdienste.

Rekapitulation

SSH als Protokoll und mit den gängigen FOSS-Implementierungen ist ein sehr mächtiges Werkzeug für den Umgang mit vernetzten Computern und leider, zumindest in meiner Wahrnehmung, unterschätzt. Nicht nur lassen sich enorm viele Aufgaben damit erledigen, es ist dabei auch flexibel, schnell und ressourcensparend. Etwas, was in einer Zeit der eher penetranten, langsamen Anwendungen als Abwechslung doch mal wieder angenehm ist. Die Netzwerk-Tricks erlauben das sinnvolle Arbeiten, auch in Umgebungen mit eher kreativen Firewall-Regeln und mit ein wenig Einrichtung ist der Zugriff auf entfernte Rechner kaum noch von dem auf den eigenen, lokalen zu unterscheiden (ich würde zu eine Shell-Prompt raten, die dies farblich hervorhebt, es kann leicht zu Verwirrungen kommen). Mit ein bisschen zusätzlicher Arbeit kann das System auch gut skaliert werden. Und das schönste: Es ist schon da! Die Chancen sind gut, dass es bereits auf jedem Linux-System im Netzwerk vorhanden ist (und auf dem meisten aktiv) und auf jedem anderen Unix-System ist es sehr sicher verfügbar. Sogar auf den Windows-Systemen ist relativ einfach zu installeren (Microsoft bietet einfach auch OpenSSH als Dienst zur Installation an). Es lohnt sich hier auf jeden Fall mal ein wenig Zeit in das Setup zu investieren um die Arbeit ein wenig angenehmer und flüssiger zu gestalten und ich hoffe, dass dieser Artikel ein paar Anstösse in diese Richtung gegeben hat.

Danksagung

An dieser Stelle möchte ich kurz Dank ausrichten an das Entwicklungsteam von OpenSSH die das Protokoll und die wohl populärste Implementierung warten und stetig weiterentwickeln und etwas gebaut haben, was mir und vielen anderen den sinnvollen Umgang mit vernetzten Computern ermöglichen. Zusätzlich vielen Leuten im Internet die mir mit vielen Beispielen, Anleitungen und Erklärungen geholfen haben an diesen Punkt zu kommen, was sonst so nicht ohne weiteres möglich gewesen wäre.

Quellen

  • https://de.wikipedia.org/wiki/Secure_Shell
  • https://www.openssh.com/history.html
  • https://www.openssh.com/
  • https://wiki.archlinux.org/title/OpenSSH
  • https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/deployment_guide/s1-ssh-configuration
  • https://wiki.debian.org/SSH
Lorenz Kästle
Lorenz Kästle
Consultant

Lorenz hat seinen Bachelor der Informatik an der FAU gemacht und sich zuletzt mit Betriebssystemen dort beschäftigt. In seiner Freizeit beschäftigt er sich ein wenig mit XMPP und der Programmiersprache Erlang.

OSMC 2021 | Recap Day 3

The third and last day of the OSMC 2021 concludes the event for the year and, appropriatly, it is rather calm. Where the other days were full of talks, today only two events took place. Due to the smaller number of participants these take place in the NETWAYS / Icinga office space and bring back some life to rooms, which were rather empty in the last year.

Hackathon

In the container ecosystem, Kubernetes is an important player and worth taking a look at. Deploying, scaling and maintaining large systems is never an easy task and this is true for container-based environments, too. While Kubernetes may provide the tools and possibilites, it is a complex tool and must be administrated with care and knowledge. Often the time, the space or the helpful tutor is lacking, when one wants to experiment with a new “thing” and, for this reason, the OSMC Hackathon provides all of the aforementioned circumstances.

The participants can just get accustomed to the Kubernetes environment, try a small example application under helpful supervision or try to apply some freshly learned knowledge, gained at the conference, to this environment. In my experience the first and one of the biggest hurdle for a new tool/language/environment is to get accustomed to wording, the semantics of all the specific terms. While the underlying technologies are often similar to a certain degree, often each project is its own world. Trying to get accustomed to to a new world without a stepping stone to help one to map unknown parts to a known equivalend and understand the intersections and purpose of the component is a huge and difficult task. In the OSMC Hackathon Sebastian Saemann, Head of NETWAYS Web Services and Kubernetes expert, helped with getting into that system easier, explained the basics and the common pitfalls.

Different groups chose different paths to use this time. One group decided to setup a small container environment which hosts GitLab as an application, with the usual components, proxy, load balancer, storage and CI runners. The setup in itself might not surprise or astonish Kubernetes veterans. But the for the beginner, it is difficult to interact with the environment. For example just connecting directly to a single container requires one to know the proper commands. The Kubernets setup does add a lot of complexity to setup initially, but it might pay off, if the application need be scaled up for higher loads/more traffic. Another group worked on integrating Jaeger in a Kubernetes setup with a simple web application. Inspired was this scenario probably by some of the talks on the conference, especially this one.

Workshop

The OSMC Workshop centered around a, in comparison to the previous topic, rather convential theme: the integration of a directory with user data, which speaks LDAP, (for most people: Windows AD) into the Icinga ecosystem. If you are the lonely admin watching over the monitoring, creating credentials for yourself might be enough (is the login name ‘icingaadmin’? ;-)). But maybe your colleagues want to have a look at that fancy interfaces too, to see if their machines are still running. While this might be all good and proper, some of them might get the idea to try their luck with the Director and might, completely by accident of course, delete some of the services, change some intervalls or ruin the proper order of things in one way or the other. So, roles need to be created, permissions applied and users mapped to some groups, to preserve the integrity of the system.

Instead of taking the hard way to their destination, with all the pitfalls and easily made errors, the participants were here in the heartful care of NETWAYS Senior Consultant and Icinga expert Lennart Betz, who happily provided them with the knowledge from his rich experience in the Icinga environment.

Goodbye

For me, it was a really nice event and I hope that this was also true for the other participants. The OSMC might be over for this year and until we can hopefully meet up again next year, we wish you all a safe passage homeward and stay warm and healthy.

Lorenz Kästle
Lorenz Kästle
Consultant

Lorenz hat seinen Bachelor der Informatik an der FAU gemacht und sich zuletzt mit Betriebssystemen dort beschäftigt. In seiner Freizeit beschäftigt er sich ein wenig mit XMPP und der Programmiersprache Erlang.

OSMC 2021 | Recap Day 1

It’s time for OSMC again and contrary to recent event experiences, it is in presence with real people! And it is nice for a change! A full program offers much input to the visitors and showcases the things people created or changed since the last OSMC. After the cordial greeting by Bernd, the talks started. A small selection of these I will mention here.

On the bleeding edge of…

On the bleeding edge of Open Telemetry” was the topic of Philipp Krenns talk. The growing complexity of current application deployments and the resulting difficulties in detecting and analysing errors in distributed systems are a growing problem for developers and conventional methods are reaching their boundaries. A request/action/… that passes through such a system might result in an error at one stage, but the cause might lie at an earlier stage and without that context from the earlier stage, it might be very hard to find the actual cause.

To provide this context is the obvious idea, but not one which is easy to realize. Messages have to be “tagged”, logged and the resulting data put togehter. This presents a lot of problems, components must be able to work with those messages while keeping the context together. Tracing produces a lot of overhead, so it should probably only be done with samples, which causes the next problem of finding a representative sample. Of course several systems/software pieces were built to provide this functionality and, of course, they won’t talk to each other. In the best tradition of this XKCD comic the solution should be a unifying open standard to make it possible for different systems to interact in the task of tracing. Several implementations of OTel (Open Telemetry) in different languages exist to this date and should allow integration in other applications.

At the end of the presentation Philipp provided a live demonstration of tracing in a demo system with the Elastic Stack with nice graphes and a lot of information about single queries with all the context added by the different parts of the system.

Marius Oehler deepened the topic then with a talk about “inspectIT Ocelot: Dynamic OpenTelemetry Instrumentation at Runtime” where the specific task of generating telemetry data in Java applications was further investigated. Especially interesting is the approach, which requires none or minimal changes to the code of the application itself.

On contributions and databases

Our very own Feu Mourek gave a helpful overview about contributing to free and open software projects with “Contributing to Open Source with the example of Icinga“, hopefully inspiring people to give something back.

For all the people who suffer performance problems with their databases Peter Zaitsev showed a way to analyse the setup, the queries and several metrics from database setups. Very detailed and heavily customized Grafana dashboards and a monitoring agent to collect and process the interesting data points allow detailed and meaningful insights into the processes, only complete with powerful filters to find the needles in the haystack of a massive amount of data. If one is interested in optimizing the database setup it could be worth investigating the tools of Percona.

Gamification of observability

Bram Vogelaar did not only talk a little bit about his story down the rabbit hole of overengineering his personal website (he reaches Docker in the first half!), but also shared his thoughts about the profession of the monitoring admin itself in “Gamification of Observability. Compared to other professions (doctors, fireman and plane pilots) the IT world commonly lacks the structured approach that those professions have developed. For most operations people, there is no training for disasters and the recovery process, no analytical, structured approach to problems and no checklists to avoid human failures caused by repetitive and boring tasks. While many people might agree with this criticism and might be willing to implement such approaches and develop these technics, he sadly forgot to mention where administrators should find the time and personel. 🙂

The last presentation of the day was Bernd’s talk about the “Current State of Icinga“. He talked about new features, planned releases, upcoming events and the new Icinga brand. He presented the changes directly in an almost frictionless live demo.

This is only a small representation of the first day and it should by no means give the impression, that the other talks might be less significant or interesting. For me today there is neither the time nor the space here to fully reflect on all of them, so we might leave it at that. Watch them in our archives, coming soon after the conference!

Lorenz Kästle
Lorenz Kästle
Consultant

Lorenz hat seinen Bachelor der Informatik an der FAU gemacht und sich zuletzt mit Betriebssystemen dort beschäftigt. In seiner Freizeit beschäftigt er sich ein wenig mit XMPP und der Programmiersprache Erlang.

Standards vs. Apps

Apps

Eine haeufig gehoertes Thema fuer Absprachen dieser Tage ist gern mal
der Abgleich der Kommunikationsapps um eine gemeinsame Teilmenge zu
finden, die man dann in Zukunft verwenden koennte. Das Ergebnis ist dann,
abhaengig von der Gruppengroessee und der Interessenlage der Beteiligten
verschieden zufriedenstellend und kann durchaus zu der Installation
von Apps fuehren.

Chatapps

Man koennte sich natuerlich an der Stelle dann auch die Frage stellen,
warum es das braucht, warum ein Telegramm nicht mit einem Signal, iMessage,
Snapchat oder [beliebige Chatapp hier einfuegen] reden kann. Es waere ja irgendwo
schon gemuetlicher nur eine App zu haben. Von der Funktionalitaet sind
solche eher selten und in wenigen Punkten unterschiedlich.
Und die Antwort darauf kann schlechterdings eine technische
sein, Protokolle fuer solche Zwecke gibt es und eine “Uebersetzungs”-Schicht
einzubauen waere vermutlich ein vertretbarer Aufwand.
Es wuerden sicherlich ein paar Sachen nicht ueber verschiedene Dienste
hinweg funktionieren, aber 1:1-Chats und Gruppen waeren ja schon ausreichend.

Die naechste Option waere ja dann, wenn die Firmen hinter den Apps schon nicht miteinander
reden wollen, dass man auf seinem Geraet nur eine App installiert, die sich dann
mit allen diesen Diensten verbindet und das vermischt. Etwas frei zitiert:

“One App to rule them all, one app to bind them,…”
– Inschrift auf dem einen Ring, stark verfaelscht

Ein erstrebenswertes Ziel, wuerde es doch ebenefalls den Aufwand reduzieren (ganz zu schweigen
von Speicherplatz und Datenvolumen). Aber auch das ist nicht gaengig.

Angesichts der finanzstarken Lage vieler Betreiber solche Apps scheint es
mir unwahrscheinlich, dass solche Themen an einem “Koennen” scheitert.
Ein Erklaerungsansatz fuehrt diesen Zustand auf das Geschaeftsmodell zurueck,
das viele der Betreiber fahren.
So wird bei der Benutzung des Dienstes und durch die Apps oft das Verhalten
der Benutzer:innen ausgespaeht und dieser Datensatz direkt oder indirekt an die Kund:innen
verkauft. Der Kundenstamm rekrutiert sich dann aus den ueblichen Werbeleuten,
Quacksalbern, Propagandisten, Lobbyisten und Meinungsmachern (Mehrfachnennung moeglich,
Redundanz wahrscheinlich).
Interaktion fuer Leute ausserhalb des eigenen Systems zu erlauben wuerde
das Risiko der Reduktion der eigenen “Datenernte” beherbergen, da Personen
ausserhalb des Systems sich nicht die App installieren muessten, um mit einem Gegenueber innerhalb des Systems
zu kommunizieren und es wuerden vielleicht sogar welche die App entfernen.
Es waere also fundamental geschaeftsgefaehrdend, ein “offeneres” System zu bauen.

Videochats

Obwohl es schon vor 2020 diverse Videokommunikationssysteme gab, ist deren
Bedeutung stark angestiegen. Die Gruende dafuer sind offensichtlich, doch wie ist
denn der Zustand diese Oekosystems dieser Tage?
Das traurige Bild, dass sich einem bei der Betrachtung bietet, ist wiederum
das der verschiedenen Apps, die nicht miteinander interagieren.
Jetzt stellt sich bei verschiedenen Personenkreisen immer wieder die Frage,
ob man denn Zoom-, Teams-, Hangouts- oder sonst irgendein Meeting hat.
Dafuer gibt es dann jeweils eine dazugehoerige App oder man hofft, dass es noch
in einem von drei verschiedenen Browsern mit allen Funktionen laeuft.
Mit Glueck und am zweiten Vollmondtag in geradzahligen Monaten trifft das sogar zu.

Aber auch hier ist die gewuenschte Funktionalitaet sehr klar umrissen und wird von
allen abgedeckt. Es sollen n Teilnehmer 1 bis (n-1) Video- und Audiostreams bekommen
und auf der Seite ist ein Chatfenster.
Das klingt wiederrum technisch ueberschaubar, aber dennoch kann ich nicht mit
einem Teams-Client in ein Zoom-Meeting.
Das Szenario aehnelt somit in wesentlichen Punkten dem Zustand der Messenger,
der weiter oben beschrieben wurde.

Und damit kommt hier die rhetorische Frage, die zum naechsten Abschnitt ueberleitet:
Ginge das denn auch anders? Und wenn ja, wo?

Telefon

Als Gegenbeispiel kann hier die Telefonie dienen, ein Gespraech quer ueber den
Globus mit einer beliebigen Person ist recht leicht denkbar, soweit
diese auch ueber einen Telefonanschluss (oder heutzutage vielleicht eher einen Handyvertrag)
verfuegt. Dabei muss man nicht nach dem speziellen Dienstanbieter fragen, auch der Hersteller
des Geraetes interessiert wenig, wichtig ist einzig die Nummer.
Selbstverstaendlich gibt es da einige Einschraenkungen, wie etwa die Kosten und diverse
Altlasten, aber das ist in einem System, das deutlich aelter als die meisten Benutzer ist,
kaum verwunderlich. Verschiedenste Protokolle und Standards werden kombiniert um am
Ende das Gespraech zwischen zwei (oder mehr) Personen zu ermoeglichen.

Internet

Auch das Internet selbst ist ein Netzwerk von vielen verschieden Teilnehmern, die
ueber standardisierte Schnittstellen Daten austauschen und viele verschiedene Medien und
Uebertragungsvarianten kombinieren.
Es gibt kein Instagram-, kein Youtube- und kein TikTok-Internet, auch wenn es von
vielen hauptsaechlich dafuer verwendet wird.
Gemeinsame Standards schaffen eine Basis, die dies ermoeglicht.

Auch hier bietet es sich an, einen Blick auf das Geschaeftsmodel zu werfen,
Internet- und Telefonieanbieter verkaufen Zugaenge zu einem Netzwerk, beziehungsweise,
sie vermieten sie, da es meistens eher ein Abonnementmodel ist.
Es ist damit leicht vorstellbar, dass ein anbietendes Unternehmen dann ein gesteigertes Interesse daran
hat, den bestmoeglichen Zugriff auf das restliche Netzwerk zu bieten.
Soweit zumindest Theorie, in der Praxis ist das mit den Internetanbietern eine etwas
durchwachsenere Erfahrung.
So moechte sich etwa mindestens eine der groesseren Anbieter hierzulande den Zugang zu seinen
Kunden teuer bezahlen lassen und ist deshalb weniger auf gute Vernetzung bedacht als darauf
viel Geld dafuer einzustecken. Leidtragenden sind hierbei die Kleinkunden, die als
Verhandlungsmasse dienen. Dass das Geld dann auch nicht wirklich in das System reinvestiert
wird um zukunftsfaehige Verbindungen zu schaffen kommt dazu.
Aber das ist ein System von falschen Anreizen und hier nicht direkt Thema.

In Summe kann man heutzutage mit standardisierten Netzwerkprotokollen (UDP, TCP, HTTP, IMAP,…)
Daten zu fast beliebigen Punkten auf dem Globus schicken. Welches Programm ich dafuer verwende
ist dafuer (abgesehen natuerlich von der implementierten Funktionalitaet) irrelevant.

Standards

Es gibt viele verschiedene Formen von Standards, die ich hier, im Sinne des Artikels, in zwei
Gruppen teilen will.
Da sind zum einen Standards die eine oder mehre bestimmte Eigenschaften sicherstellen|definieren
um einen gewissen Zweck zu erreichen. Ungluecklicherweise ist diese Definition sehr vage,
deshalb moechte sie kurz ein wenig ausfuehren und Beispiele anbringen.
So gibt es etwa eine Klassifizierung fuer LASER (DIN EN 60825-1) die Laserquellen und -anlagen
nach ihrem Gefaehrdungspotential einteilen. Dann gibt es Richtlinien/Regularien, welche Klasse
in welcher Situation erlaubt ist und man kann beim Bau von entsprechenden Anlagen dann Massnahmen
oder Mechanismen einsetzen die zur Erreichung der geplanten Klasse dienlich sind (etwa Schutzvorrichten verbauen oder
Schutzkleidung vorschreiben).
Aehnliche Regelungen gibt es fuer alle moeglichen Arten von gesundheitlichen Gefahren, wie etwa im Brandschutz,
Laermbelastung, Luftverschmutzung, Arbeitszeiten und vielem mehr.

Die Art von Standards, um die es hier aber eigentlich geht, sind die Definitionen von Schnittstellen.
Sie stellen eine Art “passive Kommunikation” dar. Eine Schnittstellendefinition sagt mir, wie meine
Gegenseite in relevanten Punkten aussieht und zwar so, dass die genaue Implementierung nicht relevant
fuer meine Seite ist.
Ein greifbares Beispiel sind zum Beispiel metrische Gewinde (z.B. DIN ISO 1502:1996-12), ein M10er
Schraube wird immer in ein M10er Gewinde passen (solange beide innerhalb der Toleranzen sind), ohne,
dass sich der Hersteller der Schrauben und die Person, die das Gewinde bohrt, jemals persoenlich
absprechen muessten.
Diese Art von Standard gibt es, selbstverstaendlich, auch im Bereich der elektronischen Kommunikation oder Informationstechnik.
So sind etwa bei der IETF wichtige Protokolle standardisiert (IP, TCP, …) oder von der ITU die eher physikalischen
Schnittstellen normiert.

Diese Standards werden teilweise von mehr oder weniger offiziellen Stellen erstellt und betreut, teilweise von
von anderen Organisationen (etwa die Mediawiki-API von der Wikimedia-Gesellschaft, die Linux-API von der Linux Foundation oder
zahlreiche andere Projekte aus dem Bereich Open Source und der freien Software).
Dabei gibt es viele verschiedene Variante und Unterschiede, aber einer der wesentlichen ist, wie der Zugang zu dem
Standard geregelt ist. Waehrend etwa die RFCs frei und offen zugaenglich sind (also auch kostenfrei), sind DIN-Normen
zu erwerben, was ein gewisses Hindernis fuer Umsetzung darstellt.

Ein Standard erfordert natuerlich auch gewisse Zugestaendnisse, so ist etwa die Bereitstellung einer oeffentlichen
API bei einem Programm oder einem Dienst nicht wirklich nuetzlich, wenn sich diese API in kurzen Zeitraeumen
haeufig aendert. Das Erstellen von Drittanbietersoftware wird dadurch aufwaendiger und es erfordert haeufiger Updates
beim Benutzer. Eine Schnittstelle ist also auch ein zusaetzlicher Aufwand und eine Verantwortlichkeit gegenueber
Nutzern.
Dies hat natuerlich auch Nachteile, so koennen neue Features nicht leichtfertig eingebaut werden oder alte
Fehler nicht sofort oder auf beliebige Art und Weise behoben werden.
Ein Beispiel dafuer ist etwa Email, ein System, dass in einer anderen Zeit erdacht wurde und an vielen
Stellen Probleme hat. So waeren etwas Privatsphaere-foerdernde Verschluesselung, eine technisch
saubere und verifizierbare Signatur und andere Erweiterungen oder
Aenderungen durchaus technisch moeglich (moderne Messenger leben das ja teilweise vor), aber durch die Notwendigkeit
des Erhalts einer minimalen gemeinsamen Basis rottet das System auf einem Stand von vor fast 30 Jahren dahin.
Auf der positiven Seite kann man auch noch Mails schreiben indem man eine direkte Netzwerkverbindung zu einem
freundlichen Mailserver aufmacht (und schnell tippen kann).
Diese Problematik fuehrt teilweise zur Abkehr von offenen Standards, etwa beim Messenger “Signal”. Dort wird
auf ein zentralisiertes System gesetzt statt auf eine foerderiertes um den Stand aller
Teilnehmer einigermassen gleich zu halten und gleichzeitig neue Features implementieren zu koennen.

Der Punkt

Nach der langen Einleitung kommen wir nun endlich zum wirklichen Punkt des Artikels.
Im ersten Teil duerfte vermutlich das Wort App ins Auge gefallen sein.
Viele Dienste sind heutzutage mit einer eigenen App verbunden. Dies hat sich soweit
durchgesetzt, dass man bei irgendeinem neuen Dienst inzwischen sofort gefragt wird, was man
installieren muss.
Und dies oft ohne technische Notwendigkeit.

Man ist inzwischen daran gewoehnt, dass man sich fuer einen Dienst eine neue App installieren muss,
die dann froehlich das Addresbuch oder das Nutzungsverhalten irgendwo ins Internet laedt.
Daran ist man gewoehnt.
Der Hersteller der App jederzeit Einschraenkungen einfuehren, etwa Features entfernen, die Funktionalitaet
veraendern oder andere beliebige Masnahmen vornehmen.
So koennen etwa auch bestimmten Inhalte mehr oder weniger effektiv verboten werden.
Auch daran ist man gewoehnt.
Man ist nicht nur der Willkuerlichkeit ausgeliefert, es geht auch viel Potential verloren. So kann es innerhalb
einer Firma leicht zu einer gemeinsamen Perspektive kommen, die nicht unbedingt der der Nutzer entspricht.
Manchmal braucht es die Perspektive von Aussenstehenden um die Probleme zu identifizieren (und zu beheben).
Dies ist nicht moeglich, wenn sich Aussenstehende nicht mit den Moeglichkeiten auseinander setzen koennen
oder nicht duerfen.
Auch daran hat man sich mittlerweile gewoehnt.

Durch diese geschlossenen Oekosysteme entsteht auch gesamtgesellschaftlicher Schaden und neue Risiken.
So sind bereits einige Monopolisten entstanden, die man in bestimmten Bereichen fast nicht umgehen kann.
Ein Unternehmen oder eine Behoerde ohne Microsoft-Komponenten ist kaum denkbar, eine Kommunikation mit Menschen
ohne Whatsapp ist zumindest schwieriger.
Fuer viele proprietaere Softwareloesungen gibt es keine Dokumentation der Datenformate, so dass ein Wechsel
des Systems zwischen prohibitiv teuer und kaum moeglich rangiert.
Teilweise laesst sich auch ein altes System oder ein Teil davon nicht an ein Neues anbinden, weil keine Schnittstellen
existieren oder die vorhandenen nicht dokumentiert sind. Eine entsprechende Anekdote eine Systems, dass ausgemustert
werden musste, weil einige Teile davon veraltet waren, duerften die meisten inzwischen kennen.
Der entsprechende Mehraufwand schlaegt sich natuerlich in unnoetigen Kosten, Muell und verschwendeter Zeit nieder.
Auch aus dem Blickpunkt der Softwaresicherheit ist eine solche Monokultur durchaus bedenklich, wie die
Windows-Sicherheitsluecken der letzten Jahre gezeigt haben. Bei einer standardisierten Schnittstelle mit
verschiedenen Implementierungen gibt es zumindest eine gute Wahrscheinlichkeit, dass nur eine Implementierung
betroffen ist und damit der Schaden durch einen Angreifer reduziert wird.

Schluss

Meiner Meinung nach, brauchen wir fuer die Zukunft in unserer digitalen Welt wieder mehr
Standards (oder zumindest die staerkere Implementierung derselben) und mehr Fokus auf Protokolle, statt dem Fokus auf eine “App”.
Statt hunderte und tausende Male das gleiche neu und ein wenig anders zu implementieren und zwar meistens halbgar,
koennte festgelegt werden was da im Grunde passiert und es in Standards und Protokollbeschreibungen zusammenfassen.
Die Analyse und die Motivation fuer den Status Quo habe ich hier kaum bis gar nicht vorgenommen,
diese kommt vielleicht nochmal in einem weiteren Artikel, aber ich halte ihn, kurz gefasst, fuer ein Resultat
dieses Wirtschaftssystems.
In einer digitalen Welt, in der Konzerne auf eine Monopolstellung hinarbeiten und die meisten Gelder fuer
Konsumentensoftware und -dienste aus Werbeeinnahmen stammen, ist eine Verbesserung nicht so leicht denkbar.
Ganz allgemein ist ein Fokus auf Gewinnmaximierung vermutlich nicht die beste Zielsetzung aus Perspektive der
Softwareanwender.

Fuer die nachhaltigere, resilientere und vielfaeltigere Gesellschaft die fuer die Zukunft
gebraucht und teils gewollt wird, muss auch das digitale Oekosystem angepasst werden.
In dem jetzigen Zustand wirkt es eher unzureichend und zu stark auf Interessen Einzelner
fokussiert.

Ich habe versucht viel in diesen Text hineinzubringen, was vielleicht eher schlecht als recht dort
Platz gefunden hat. Ueber Kritik, Verbesserungen und vielleicht auch Gegenmeinungen wuerde ich mich
sehr freuen.
Fuer die Kuerze und die daraus folgenden Unvollstaendigkeiten moechte ich mich entschuldigen.

Wer sich fuer die hier angesprochenen Themengebiete interessiert, kann auch noch einen Blick auf folgende Themen werfen:

  • XMPP, ein vergleichsweise frueher Ansatz fuer einen sich fortentwickelnden Standard fuer allgemeine Chatdienste, nicht so haeufig zu sehen, aber vermutlich haben Sie es schon mal verwendet
  • Matrix, aehnlich zu XMPP aber juenger. Ebenfalls chatten in einem foerderierten Netzwerk
  • Fediverse, ein Ansatz fuer soziale Netzwerke, ebenfalls foerderiert, beinhaltet z.b. Mastodon (Microblogging wie Twitter), Peertube (Video-Plattform wie Youtube) und diverse andere Dienste und Protokolle
Lorenz Kästle
Lorenz Kästle
Consultant

Lorenz hat seinen Bachelor der Informatik an der FAU gemacht und sich zuletzt mit Betriebssystemen dort beschäftigt. In seiner Freizeit beschäftigt er sich ein wenig mit XMPP und der Programmiersprache Erlang.