Privatsphäre

Veröffentlicht am 2025-12-22 von Elmar Dott

Immer wieder begegne ich Aussagen wie, „Ich nutze Apple wegen des Datenschutzes.“ oder „Unter Linux gibt es keine Viren.“ und so weiter und so fort. Im richtigen Leben schmunzle ich dann in mich hinein und verkneife mir eine Antwort. Diese Menschen sind meist Jünger einer bestimmten Marke, die sie abgöttisch anbeten und sogar mit ihrem Leben verteidigen würden. Daher spare ich meine Energie für sinnvolleres auf, wie zum Beispiel diesen Artikel hier zu verfassen.

Mein Bestreben, ist, möglichst wenig technische Details beziehungsweise auch wenig Fachsprache zu verwenden, damit auch die Menschen ohne entsprechenden Hintergrund Zugang zu diesem Thema finden. Sicher mag der ein oder andere Skeptiker nach Beweisen meiner Aussagen rufen, die meine Behauptungen zu belegen. Diesen Personen sei gesagt, dass es für die einzelnen Aussagen genügend Stichworte gibt, mit denen man sich selbst auf die Suche machen kann, und entsprechend genügend Primärquellen findet, die abseits von KI und Wikipedia existieren.

Wenn man darüber sinniert, was Freiheit eigentlich bedeutet, stößt man oft auf Aussagen wie: „Freiheit ist, das zu tun, worauf man Lust hat, ohne dabei die Freiheit anderer Menschen zu beeinträchtigen.“ Diese Definition beinhaltet auch, die Tatsache, dass vertrauliche Aussagen auch vertraulich bleiben. Hier gibt es allerdings schon Bestrebungen, lange vor der Verfügbarkeit von elektronischen Geräten zur Kommunikation. Nicht umsonst gibt es eine jahrtausendealte Kunst namens Kryptografie, mit der Nachrichten, die auf unsicheren Wegen übermittelt werden, für Uneingeweihte unverständlich bleiben. Dass die Begehrlichkeiten, die Gedanken anderer Menschen zu erfahren, sehr alt sind, besagt auch der Spruch, dass die beiden ältesten Gewerbe der Menschheit die käufliche Liebe und die Spionage sind. Daher kann man sich die Frage stellen: Wieso sollte dies nun im Zeitalter der Kommunikation anders sein?

Besonders unbedachte Zeitgenossen begegnen dem Thema mit der Einstellung, sie hätten ohnehin nichts zu verbergen, wozu sollten sie dann auf die eigene Privatsphäre bedacht sein? Ich persönlich gehöre zu der Gruppe Menschen, die diese Einstellung für sehr gefährlich halten, da sie machthungrigen Gruppierungen Tür und Tor für den Missbrauch öffnet. Jeder Mensch hat Bereiche in seinem Leben, die er nicht in die Öffentlichkeit gezerrt bekommen möchte. Hier kann es sich um spezielle sexuelle Vorlieben handeln, Untreue dem Partner gegenüber oder eine Vorliebe für das Glücksspiel, also Dinge, die eine perfekte Fassade von moralischer Integrität schnell bröckeln lässt.

In der DDR glaubten viele Menschen, das sie selbst zu unbedeutend waren, als dass der berüchtigte Inlandsgeheimdienst STASI an ihnen Interesse haben könnte. Wie sehr sie mit ihrer Einschätzung danebenlagen, zeigte die Öffnung der STASI‑Unterlagen nach der deutschen Wiedervereinigung. In diesem Zusammenhang möchte ich nur auf die gültige Gesetzeslage in der EU hinweisen, die Errungenschaften wie Hatespeech, Chatkontrolle und Vorratsdatenspeicherung vorweisen kann. Auch die Privatwirtschaft hat genügend Gründe, mehr über jeden einzelnen Menschen zu erfahren. Denn so lässt sich dieser optimal manipulieren und zum Kauf von Dienstleistungen und Produkten animieren. Eine Zielstellung von Unternehmen ist, den optimalen Preis ihrer Angebote ermitteln zu können, also den größtmöglichen Gewinn zu erzielen. Das erreicht man durch Methoden der Psychologie. Oder glauben Sie wirklich, dass Produkte wie ein Telefon, mit dem man fotografieren kann, wirklich den Preis wert sind, der dafür verlangt wird? Wir sehen also: Es gibt genügend Gründe, wieso personenbezogene Daten durchaus einen hohen Wert haben können. Betrachten wir uns daher einmal die vielen technologischen Halbwahrheiten an, die in der breiten Öffentlichkeit so kursieren. Viele dieser Halbwahrheiten habe ich auch bei Technologieprofis vernommen, die selbst viele Dinge nicht hinterfragt haben.

Bevor ich aber in die Details einsteige, möchte ich noch eine essenzielle Aussage voranstellen. Es gibt keine sichere und private Kommunikation, wenn elektronische Geräte involviert sind. Wer ein absolut vertrauliches Gespräch führen möchte, geht bei starkem Wind auf ein freies Feld, mit einem Sichtradius von mindestens 100 Metern und verdeckt beim Sprechen seinen Mund. Natürlich ist mir klar, dass auch dort Mikrofone versteckt sein könnten. Diese Aussage ist eher demonstrativ und zeigt, wie schwer es ist, eine vertrauliche Umgebung zu schaffen.

Beginnen wir mit der beliebten Marke Apple. Viele der Apple-Nutzer glauben, ihre Geräte wären besonders sicher. Das stimmt nur so weit, dass durchaus Fremde, die versuchen, sich unautorisierten Zugriff auf die Geräte zu verschaffen, große Hürden überwinden müssen. Dafür sind viele Mechanismen in den Betriebssystemen enthalten, die es erlauben, zum Beispiel auf den Telefonen Anwendungen und Inhalte zu blockieren.

Das Unternehmen Microsoft, steht dem in nichts nach und geht noch einige Schritte weiter. Seitdem das Internet für die breite Masse verfügbar ist, rätselt man darüber, welche Telemetriedaten der Nutzer Windows an den Mutterkonzern sendet. Windows 11 treibt alles noch viel mehr auf die Spitze und speichert jeden Tastenanschlag und macht alle paar Sekunden einen Screenshot vom Bildschirm. Angeblich werden diese Daten nur lokal auf dem Computer gespeichert. Das kann man natürlich gern glauben, und selbst wenn es so wäre, handelt es sich hier um eine enorme Sicherheitslücke. Denn jeder Hacker, der einen Windows 11 Rechner kompromittiert, kann dann diese Daten auch auslesen und hat Zugriff auf Onlinebanking und alle möglichen Accounts.

Tschüß Privatsphäre, Tschüß Freiheit

Zudem verweigert Windows 11 seinen Dienst bei angeblich veralteten Prozessoren. Dass Windows schon immer sehr ressourcenhungrig war, ist keine Neuheit. Der Grund der Restriktion auf alte CPUs hat aber einen anderen Grund. CPUs der neuen Generation haben ein sogenanntes Sicherheitsfeature, mit dem sich der Computer eindeutig identifizieren und über das Internet deaktivieren lässt. Das Stichwort, um das es hier geht, lautet Pluton Security Processor mit dem Trusted Platform Module (TPM 2.0).

Wie sehr die Begehrlichkeiten von Microsoft sind, alle möglichen Informationen über die eigenen User abzugreifen, zeigen auch die Änderungen der AGB um das Jahr 2022. Diese bekamen einen neuen Abschnitt, der Microsoft die Erlaubnis erteilt, alle durch ihre Produkte erlangten Daten zum Trainieren von künstlicher Intelligenz verwenden zu dürfen. Zudem behält man sich das Recht vor, bei erkannter Hatespeech den Nutzer von allen Microsoft Produkten auszuschließen.

Aber keine Sorge, nicht nur Microsoft hat solche Disclaimers in den eigenen AGB. Auch Social Media Platformen wie Meta, besser bekannt unter den Produkten Facebook und WhatsApp, oder die Kommunikationsplattform Zoom agieren so. Die Liste solcher Anwendungen ist natürlich weitaus länger. Es ist jeder Einzelne dazu eingeladen, sich vorzustellen, welche Möglichkeiten die bereits beschriebenen Dinge eröffnen.

Das Neueste wird nicht immer das Beste sein

Ich habe ja bereits Apple als problematisch im Bereich Sicherheit und Privatsphäre erwähnt. Aber auch Android, das Betriebssystem von Google für SMART‑Fernseher und Telefone, gibt enormen Raum für Kritik. Nicht ganz ohne Grund kann man aus den Telefonen die Akkus nicht mehr entfernen. Denn Android verhält sich genauso wie Windows und sendet alle möglichen Telemetriedaten an den Mutterkonzern. Hierzu kommt noch der 2025 bekannt gewordene Skandal des Herstellers Samsung. Dieser hat ein israelisches, verstecktes Programm namens AppCloud auf seinen Geräten, von dem sich nur erahnen lässt, welchen Zweck es erfüllt. Vielleicht hilft auch die Erinnerung, als im Jahr 2023 bei vielen Palästinensern und anderen von Israel erklärten Feinden die Pager explodiert sind. In der Securityszene ist es kein Geheimnis, dass Israel im Bereich Cybersecurity und Cyberattacken an einsamer Spitze steht.

Ein anderes Thema bei Telefonen ist die Verwendung sogenannter Messenger. Neben den bekannten wie WhatsApp und Telegram gibt es auch ein paar Nischenlösungen wie Signal und Session. Alle diese Anwendungen sprechen von einer Ende zu Ende Verschlüsselung für sichere Kommunikation. Es ist schon richtig, dass Hacker hier so ihre Schwierigkeiten haben, um an die Informationen zu kommen, wenn sie nur den Netzwerkverkehr mitschneiden. Was aber nach erfolgreicher Übertragung und der Entschlüsselung auf dem Zielgerät dann mit der Nachricht passiert, steht auf einem anderen Blatt. Wie sonst sollten sich die Meta AGB mit den bereits enthaltenen Passagen erklären lassen?

Wenn man alle die bereits erwähnten Tatsachen zusammen nimmt, muss man sich nicht wundern, wieso viele Geräte wie Apple, Windows und Android erzwungene Updates etabliert haben. Natürlich dient nicht alles der totalen Kontrolle. Auch das Thema Resilienz, welches Geräte vorzeitig altern lässt, um diese durch Neue zu ersetzen, ist ein Grund.

Privatsphäre mit Kodachi Linux im Internet zurückgewinnen

Nun gibt es natürlich auch genügend Angebote, die ihren Nutzern enorme Sicherheit versprechen. An erster Stelle sei das freie Open Source Betriebsystem Linux erwähnt. Es gibt viele verschiedene Linux-Derivate und nicht alle behandeln das Thema Security und Privatsphäre mit der gleichen Priorität. Die von der Firma Canonical veröffentlichte Distribution Ubuntu, erhält regelmäßig Kritik. So war um das Jahr 2013 das Unity Desktop voll mit Werbung, was viel Ablehnung erfahren hat. Auch dass es unter Linux keine Viren gäbe, ist ein Mythos. Sie gibt es durchaus und der Virenscanner unter Linux heißt ClamAV, nur ist deren Verbreitung aufgrund der geringen Privatinstallationen im Vergleich zu Windows weniger verbreitet. Außerdem gelten bisher Linuxnutzer als ein wenig nerdig und klicken nicht so schnell auf verdächtige Links. Wer aber dann unter Linux all die tollen Anwendungen wie Skype, Dropbox, KI Agenten und so weiter installiert hat, hat gegenüber der Big Tech Industrie keine verbesserte Sicherheit.

Ähnlich verhält es sich auch mit sogenannten „degoggeled“ Smartphones. Auch hier ist ein Problem, die verfügbare Hardware, die sehr reguliert ist. Aber auch die Alltagstauglichkeit zeigt oft Grenzen auf. Diese Grenzen finden sich bereits im familiären Umfeld und bei Freunden, die sich kaum von WhatsApp und Co. abbringen lassen. Aber auch Onlinebanking kann hier einem erhebliche Schwierigkeiten bereiten, denn Banken bieten ihre Apps aus Sicherheitsgründen nur über den verifizierten Google Play Store an.

Wir sehen, das Thema ist sehr umfangreich und ich habe nicht einmal alle Punkte aufgezählt, noch bin ich sehr in die Tiefe gegangen. Ich hoffe, ich konnte dennoch ein wenig Sensibilisierung erreichen, dass zumindest das Smartphone nicht überall mitgenommen und auch mehr Zeit ohne die ganzen technischen Geräte wieder in der Wirklichkeit mit anderen Menschen verbracht wird.

User Tracking und Shadowbanned

Zähl auf mich – Java Enums

Veröffentlicht am 2025-12-15 von Elmar Dott

Antworten

Eigentlich denkt man als erfahrener Entwickler oft, dass reine CORE Java Themen eher was für Anfänger sind. Das muss aber nicht unbedingt so sein. Ein Grund ist natürlich die Betriebsblindheit, die sich bei ‚Profis‘ mit der Zeit einstellt. Dieser Betriebsblindheit kann man nur entgegenwirken, wenn man sich gelegentlich auch mit vermeintlich vertrauten Themen erneut beschäftigt. Aufzählungen in Java sind leider zu Unrecht etwas unbeachtet und finden viel zu wenig Anwendung. Ein möglicher Grund für diese stiefmütterliche Behandlung können auch die vielen im Netz verfügbaren Tutorials zu Enums sein, die lediglich eine triviale Verwendung demonstrieren. Fangen wir zuallererst also damit an, wo Enums in Java ihre Verwendung finden.

Gehen wir einmal von ein paar einfachen Szenarien aus, die uns im Entwickleralltag begegnen. Stellen wir uns vor, wir müssen eine Hashfunktion implementieren, die mehrere Hash-Algorithmen wie MD5 und SHA-1 unterstützen kann. Als Einstiegspunkt haben wir auf Benutzerebene dann oft eine Funktion, die so oder ähnlich ausschauen kann: String hash(String text, String algorithm); – eine technisch korrekte Lösung.

Ein anderes Beispiel kann das Logging sein. Um einen Logeintrag zu schreiben, könnte die Methode wie folgt aussehen: void log(String message, String logLevel); und so lassen sich die Beispiele in diesem Stil beliebig fortführen.

Das Problem dieser Variante sind freie Parameter wie logLevel und algorithm, die für den korrekten Gebrauch nur eine sehr begrenzte Anzahl von Möglichkeiten gestatten. Das Risiko, dass Entwickler im Projektstress diesen Parameter falsch befüllen, ist recht hoch. Tippfehler, Variationen in Groß- und Kleinschreibung und so weiter sind mögliche Fehlerquellen. In der Java API gibt es durchaus einige solcher verbesserungswürdigen Designentscheidungen.

Um die Verwendung der API, also der nach außen genutzten Funktionen, zu verbessern, führen wie so oft viele Wege nach Rom. Ein Weg, der durchaus öfter zu sehen ist, ist die Verwendung von Konstanten. Um die Lösung ein wenig besser zu verdeutlichen, greife ich das Beispiel der Hash-Funktionalität auf. Es sollen die beiden Hash-Algorithmen MD5 und SHA-1 in der Klasse Hash unterstützt werden.

void Hash {
	
	public final static MD5 = "1";
	public final static SHA-1 = "2";

	/**
	 * Creates a hash from text by using the chosen algorithm.
	 */
	public String calculateHash(String text, String algorithm) {
		String hash = "";

		if(algorithm.equals(MD5)) {
			hash = MD5.hash(text);
		}
		if(algorithm.equals(SHA-1)) {
			hash = SHA-1.hash(text);
		}
		return hash;
	}
}

// Call
calculateHash("myHashValue", Hash.MD5);

void Hash {
	
	public final static MD5 = "1";
	public final static SHA-1 = "2";

	/**
	 * Creates a hash from text by using the chosen algorithm.
	 */
	public String calculateHash(String text, String algorithm) {
		String hash = "";

		if(algorithm.equals(MD5)) {
			hash = MD5.hash(text);
		}
		if(algorithm.equals(SHA-1)) {
			hash = SHA-1.hash(text);
		}
		return hash;
	}
}

// Call
calculateHash("myHashValue", Hash.MD5);

In der Klasse Hash werden die beiden Konstanten MD5 und SHA-1 definiert, um anzuzeigen, welche Werte für den Parameter algorithem gültige Werte darstellen. Entwickler mit etwas Erfahrung erkennen diese Konstellation recht schnell und verwenden sie auch korrekt. Auch hier ist die Lösung technisch gesehen absolut korrekt. Aber auch wenn Dinge syntaktisch richtig sind, heißt es nicht, dass sie im semantischen Kontext bereits eine optimale Lösung darstellen. Die hier vorgestellte Strategie missachtet nämlich die Entwurfskriterien für objektorientierte Programmierung. Obwohl wir bereits durch die Konstanten gültige Eingabewerte für den Parameter algorithm bereitstellen, gibt es keinen Mechanismus, der die Verwendung der Konstanten erzwingt.

Nun könnte man argumentieren, das ist doch nicht wichtig, solange die Methode mit einem gültigen Parameter aufgerufen wird. Dem ist aber nicht so. Denn jeder Aufruf der Methode calculateHash ohne die Verwendung der Konstanten führt bei Refactorings zu möglichen Problemen. Will man aus Vereinheitlichung beispielweise den Wert “2“ in sha1 ändern, wird das überall da zu Fehlern führen, wo die Konstanten nicht zum Einsatz kommen. Wie können wir es also besser machen? Die bevorzugte Lösung sollte die Verwendung von Enums sein.

Alle in Java definierten Enums sind von der Klasse java.lang.Enum [2] abgeleitet. Eine Auswahl der Methoden ist:

name() gibt den Namen dieser Enum-Konstante genau so zurück, wie er in ihrer Enum-Deklaration angegeben ist.
ordinal() gibt die Ordnungszahl dieser Enum-Konstante zurück (ihre Position in der Enum-Deklaration, wobei der ersten Konstante die Ordnungszahl Null zugewiesen wird).
toString() gibt den Namen dieser Enum-Konstante so zurück, wie er in der Deklaration enthalten ist.

Enums gehören in Java von Anfang an zum Sprachkern und sind recht intuitiv zu benutzen. Für den Parameter algorithm erzeugen wir mit den beiden Werten MD5 und SHA1 die Enumklasse HashAlgorithm.

public enum HashAlgorithm {
    MD5, SHA1
}

Dies ist die einfachste Variante, wie man ein Enum definieren kann. Eine einfache Aufzählung der gültigen Werte als Konstanten. In dieser Notation sind Konstantenname und Konstantenwert identisch. Wichtig beim Umgang mit Enums ist sich bewusst zu sein das die Namenkonventionen für Konstanten gelten.

Die Namen von als Klassenkonstanten deklarierten Variablen und von ANSI-Konstanten sollten ausschließlich in Großbuchstaben geschrieben und die Wörter durch Unterstriche („_“) getrennt werden. (ANSI-Konstanten sollten zur Vereinfachung der Fehlersuche vermieden werden.) Bsp.: static final int GET_THE_CPU = 1;

[1] Oracle Dokumentation

Diese Eigenschaft führt uns zum ersten Problem bei der vereinfachten Definition von Enums. Wenn wir aus irgendeinem Grund anstatt SHA-1 anstatt SHA1 definieren wollen, wird das zu einem Fehler führen, da “-“ nicht der Konvention für Konstanten entspricht. Daher findet sich für die Definition von Enums meist folgendes Konstrukt:

public enum HashAlgorithm {

    MD5("MD5"),
    SHA1("SHA-1");

    private String value;

    HashAlgorithm(final String value) {
        this.value = value;
    }

    public String getValue() {
        return this.value;
    }
}

public enum HashAlgorithm {

    MD5("MD5"),
    SHA1("SHA-1");

    private String value;

    HashAlgorithm(final String value) {
        this.value = value;
    }

    public String getValue() {
        return this.value;
    }
}

In diesem Beispiel wird die Konstante SHA1 um einen String Wert “SHA-1“ erweitert. Um an diesen Wert zu gelangen, ist es notwendig, einen Zugriff dafür zu implementieren. Dieser Zugriff erfolgt über die Variable value, welche den zugehörigen Getter getValue() besitzt. Damit die Variable value auch befüllt wird, benötigen wir noch einen zugehörigen Konstruktor. Wie die verschiedenen Zugriffe auf den Eintrag SHA1 mit den entsprechenden Ausgaben zeigt der nachfolgende Testfall.

public class HashAlgorithmTest {

    @Test
    void enumNames() {
        assertEquals("SHA1",
                HashAlgorithm.SHA1.name());
    }

    @Test
    void enumToString() {
        assertEquals("SHA1",
                HashAlgorithm.SHA1.toString());
    }
    
    @Test
    void enumValues() {
        assertEquals("SHA-1",
                HashAlgorithm.SHA1.getValue());
    }


    @Test
    void enumOrdinals() {
        assertEquals(1,
                HashAlgorithm.SHA1.ordinal());
    }
}

public class HashAlgorithmTest {

    @Test
    void enumNames() {
        assertEquals("SHA1",
                HashAlgorithm.SHA1.name());
    }

    @Test
    void enumToString() {
        assertEquals("SHA1",
                HashAlgorithm.SHA1.toString());
    }
    
    @Test
    void enumValues() {
        assertEquals("SHA-1",
                HashAlgorithm.SHA1.getValue());
    }


    @Test
    void enumOrdinals() {
        assertEquals(1,
                HashAlgorithm.SHA1.ordinal());
    }
}

Zuerst greifen wir auf den Namen der Konstante zu, der für unser Beispiel SHA1 lautet. Das gleiche Ergebnis erhalten wir mit der toString() Methode. Den Inhalt von SHA1, also den Wert SHA-1 erhalten wir über den Aufruf unserer definierten Methode getValue(). Zusätzlich kann noch die Position von SHA1 in der Enum abgefragt werden. Dies ist für unser Beispiel die zweite Stelle, an der SHA1 vorkommt, und hat dadurch den Wert 1. Schauen wir uns für die Implementierung der Hash-Klasse aus Listing 1 die Änderung für Enums an.

public String calculateHash(String text, HashAlgorithm algorithm) {
    String hash = "";
    switch (algorithm) {
        case MD5:
		hash = MD5.hash(text);
            break;
        case SHA1:
		hash = SHA1.hash(text);
            break;
    }
    return hash;
}

//CaLL
calculateHash(“text2hash“, HashAlgorithm.MD5);

public String calculateHash(String text, HashAlgorithm algorithm) {
    String hash = "";
    switch (algorithm) {
        case MD5:
		hash = MD5.hash(text);
            break;
        case SHA1:
		hash = SHA1.hash(text);
            break;
    }
    return hash;
}

//CaLL
calculateHash(“text2hash“, HashAlgorithm.MD5);

Wir sehen in diesem Beispiel eine deutliche Vereinfachung der Implementierung und erreichen zudem eine sichere Verwendung für den Parameter algorithm, der nun durch die Enum bestimmt wird. Sicher gibt es einige Kritiker, die möglicherweise die Menge des zu schreibenden Codes bemängeln und darauf verweisen, dass dies viel kompakter möglich wäre. Solche Argumente kommen eher von Personen, die keine Erfahrung mit großen Projekten von mehreren Millionen Zeilen Quelltext konfrontiert wurden oder nicht in einem Team mit mehreren Programmierern zusammenarbeiten. Im objektorientierten Entwurf geht es nicht darum, möglichst jedes überflüssige Zeichen zu vermeiden, sondern lesbaren, fehlertoleranten, ausdruckstarken und leicht änderbaren Code zu schreiben. Alle diese Attribute haben wir in diesem Beispiel mit Enums abgedeckt.

Laut dem Tutorial von Oracle für Java Enums [3] sind noch viel komplexere Konstrukte möglich. Enums verhalten sich wie Java Klassen und können auch mit Logik angereichert werden. Die Spezifikation sieht hier vor allem die Methoden compare() und equals() vor, was Vergleichen und Sortieren ermöglicht. Für das Beispiel der Hashalgorithmen würde diese Funktionalität keinen Mehrwert bringen. Auch sollte man grundsätzlich davon Abstand nehmen, weitere Funktionalität beziehungsweise Logik in Enums unterzubringen, da diese ähnlich wie reine Datenklassen behandelt werden sollten.

Dass Enums durchaus ein wichtiges Thema in der Java Entwicklung darstellen, zeigt auch der Umstand, dass J. Bloch in seinem Buch “Effective Java“ dazu ein ganzes Kapitel mit knapp 30 Seiten gewidmet hat.

Damit haben wir ein ausführliches Beispiel über die korrekte Verwendung von Enums durchgearbeitet und vor allem auch erfahren, wo dieses Sprachkonstrukt in Java eine sinnvolle Anwendung findet.

Ressourcen

Abonnement / Subscription

[English] This content is only available to subscribers.

[Deutsch] Diese Inhalte sind nur für Abonnenten verfügbar.

Maven Master Class

Elmar Dott Juni 26, 2025

Maven Master Class

Referenzen & Literatur

Elmar Dott Juni 26, 2025

Maven Master Class

Elmar Dott Juni 26, 2025

Python-Programme über PIP unter Linux installieren

Veröffentlicht am 2025-12-01 von Elmar Dott

Antworten

Vor sehr vielen Jahren hat die nach der britischen Komikertruppe benannte Skriptsprache Python unter Linux das altehrwürdige Perl abgelöst. Das heißt, jede Linux Distribution enthält einen Python-Interpreter von Hause aus. Eigentlich eine recht praktische Sache. Eigentlich! Wenn da nicht das leidige Thema mit der Sicherheit wäre. Aber fangen wir einmal der Reihe nach an, denn dieser kleine Artikel ist für Leute gedacht, die unter Linux in Python geschriebene Software zum Laufen bringen möchten, aber selbst weder Python kennen noch irgendetwas mit Programmieren am Hut haben. Daher ein paar kleine Hintergrundinformationen, um zu verstehen, worum es überhaupt geht.

Alle aktuellen Linux Varianten, die von der Distribution Debian abgeleitet sind, also Ubuntu, Mint und so weiter, werfen einen kryptischen Fehler, wenn man versucht, ein Pythonprogramm zu installieren. Da man vermeiden möchte, dass wichtige Systembibliotheken, die in Python geschrieben wurden, durch die Installation zusätzlicher Programme überschrieben werden und dadurch ein Fehlverhalten im Betriebssystem hervorrufen, wurde ein Schutz eingebaut, der das verhindert. Leider steckt auch hier wie so oft der Teufel im Detail.

ed@P14s:~$ python3 -m pip install ansible
error: externally-managed-environment

× This environment is externally managed
╰─> To install Python packages system-wide, try apt install
    python3-xyz, where xyz is the package you are trying to
    install.
    
    If you wish to install a non-Debian-packaged Python package,
    create a virtual environment using python3 -m venv path/to/venv.
    Then use path/to/venv/bin/python and path/to/venv/bin/pip. Make
    sure you have python3-full installed.
    
    If you wish to install a non-Debian packaged Python application,
    it may be easiest to use pipx install xyz, which will manage a
    virtual environment for you. Make sure you have pipx installed.
    
    See /usr/share/doc/python3.13/README.venv for more information.

ed@P14s:~$ python3 -m pip install ansible
error: externally-managed-environment

× This environment is externally managed
╰─> To install Python packages system-wide, try apt install
    python3-xyz, where xyz is the package you are trying to
    install.
    
    If you wish to install a non-Debian-packaged Python package,
    create a virtual environment using python3 -m venv path/to/venv.
    Then use path/to/venv/bin/python and path/to/venv/bin/pip. Make
    sure you have python3-full installed.
    
    If you wish to install a non-Debian packaged Python application,
    it may be easiest to use pipx install xyz, which will manage a
    virtual environment for you. Make sure you have pipx installed.
    
    See /usr/share/doc/python3.13/README.venv for more information.

Als Lösung soll nun eine virtuelle Umgebung eingerichtet werden. Debian 12 und auch das gerade im August 2025 frisch erschienene Debian 13 nutzen Python in der Version 3. Python2 und Python 3 sind zueinander nicht kompatibel. Das heißt, in Python2 geschriebene Programme laufen nicht ohne Weiteres in Python 3.

Wenn man nun unter Python irgendein Programm installieren möchte, erledigt dies der sogenannte Paketmanager. Die meisten Programmiersprachen haben einen solchen Mechanismus. Der Paketmanager für Python heißt PIP. Hier kommen schon die ersten Komplikationen ins Spiel. Es gibt pip, pip3 und pipx. Solche Namensinkonsistenzen findet man auch beim Python Interpreter selbst. Version 2 startet man auf der Konsole mit python und Version 3 mit python3. Da sich dieser Artikel auf Debian 12 / Debian 13 und seine Derivate bezieht, wissen wir, dass zumindest mal Python 3 am Start ist. Um die tatsächliche Python Version zu erfahren, kann man auf der Shell auch python3 -V eingeben, was bei mir die Version 3.13.5 zutage fördert. Versucht man indies python oder python2 kommt eine Fehlermeldung, dass der Befehl nicht gefunden werden konnte.

Schauen wir uns zuerst einmal an, was überhaupt pip, pip3 und pipx bedeuten soll. PIP selbst heißt nichts anderes als Package Installer for Python [1]. Bis Python 2 galt PIP und ab Version 3 haben wir entsprechend auch PIP3. Ganz speziell ist PIPX [2] welches für isolierte Umgebungen gedacht ist, also genau das, was wir benötigen. Daher geht es im nächsten Schritt darum, PIPX zu installieren. Das erreichen wir recht leicht über den Linux-Paketmanager: sudo apt install pipx. Um festzustellen, welche PIP Variante bereits auf dem System installiert ist, benötigen wir folgenden Befehl: python3 -m pipx --version, der in meinem Fall 1.7.1 ausgibt. Das heißt, ich habe auf meinem System als Ausgangsbasis das originale Python3 und dazu PIPX installiert.

Mit der gerade beschriebenen Voraussetzung kann ich nun unter PIPX alle möglichen Python Module installieren. Der Grundbefehl lautet pipx install <module>. Um ein nachvollziehbares Beispiel zu schaffen, wollen wir jetzt im nächsten Schritt Ansible installieren. Auf die Verwendung von pip und pip3 sollte verzichtet werden, da diese zum einen erst installiert werden müssen und zum anderen zu dem eingangs krypischen Fehler führen.

Ansible [3] ist ein Programm, das in Python geschrieben wurde und ab der Version 2.5 auf Python 3 migriert wurde. Nur sehr knapp ein paar Worte zu dem, was Ansible selbst für ein Programm ist. Ansible gehört in die Klasse der Konfigurationsmanagementprogramme und erlaubt es völlig automatisiert mit einem Skript Systeme zu provisionieren. Eine Provisionierung kann zum Beispiel als virtuelle Maschine erfolgen und umfasst das Festlegen der Hardware-Ressourcen (RAM, HDD CPU Kerne, etc.), Installieren des Betriebssystems, das Einrichten des Benutzers und das Installieren und Konfigurieren weiterer Programme.

Als Erstes müssen wir Ansible mit pipx install ansible installieren. Wenn die Installation beendet ist, können wir den Erfolg mit pipx list überprüfen, was bei mir zu folgender Ausgabe führt:

ed@local:~$ pipx list
venvs are in /home/ed/.local/share/pipx/venvs
apps are exposed on your $PATH at /home/ed/.local/bin
manual pages are exposed at /home/ed/.local/share/man
   package ansible 12.1.0, installed using Python 3.13.5
    - ansible-community

ed@local:~$ pipx list
venvs are in /home/ed/.local/share/pipx/venvs
apps are exposed on your $PATH at /home/ed/.local/bin
manual pages are exposed at /home/ed/.local/share/man
   package ansible 12.1.0, installed using Python 3.13.5
    - ansible-community

Die Installation ist aber hier noch nicht beendet, denn der Aufruf ansible –version wird mit einer Fehlermeldung quittiert. Das Problem, welches sich hier ergibt, hat etwas mit der Ansible Edition zu tun. Wie wir bereits in der Ausgabe von pipx list sehen können, haben wir die Community Edition installiert. Weswegen der Befehl ansible-community --version lautet, der bei mir aktuell die Version 12.2.0 zutage fördert.

Wer lieber in der Konsole ansible anstatt ansible-community eingeben möchte, kann das über eien alias erreichen. Das Setzen des Alias ist hier nicht ganz so trivial, da dem Alias Parameter übergeben werden müssen. Wie das gelingt, ist aber Thema eines anderen Artikels.

Gelegentlich kommt es aber auch vor, dass Pythonprogramme über PIPX nicht installiert werden können. Ein Beispiel hierfür ist streamdeck-ui [4]. Die Hardware StreamDeck von Elgato konnte lange Zeit unter Linux mit dem in Python implementierten stremdeck-ui genutzt werden. Mittlerweile gibt es noch eine Alternative namens Boatswain, die nicht in Python geschrieben wurde, auf die man besser ausweichen sollte. Denn leider führt die Installation von streamdeck-ui zu einem Fehler, der aus der Abhängigkeit zur Bibliothek ‘pillow’ herrührt. Versucht man nun, das Installationsscript aus dem Git Repository von streamdeck-ui zu nutzen, findet man einen Verweis auf die Installation von pip3, über das streamdeck-ui bezogen werden kann. Kommt man dann an den Punkt, um den Befehl pip3 install --user streamdeck_ui auszuführen, erhält man die Fehlermeldung, externally-managed-environment die ich zu Anfang des Artikels bereits beschrieben habe. Da wir bereits PIPX nutzen, ist es nicht zielführend, eine weitere virtuelle Umgebung für Python Programme zu erstellen, da diese auch nur wieder zu dem Fehler mit der Bibliothek pillow führen wird.

Da ich selbst kein Python-Programmierer bin, aber durchaus einige Erfahrungen mit komplexen Abhängigkeiten in großen Java Projekten habe und das Programm streamdeck-ui eigentlich besser als Boatwain empfunden hatte, habe ich mich ein wenig im GitHub Repository umgeschaut. Zuerst fällt auf, dass die letzte Aktivität im Frühjahr 2023 stattgefunden hat und eine Reaktivierung eher unwahrscheinlich ist. Schauen wir uns dennoch einmal die Fehlermeldung genauer an, um eine Idee zu bekommen, wie man bei Installationen anderer Programme das Problem eingrenzen kann.

Fatal error from pip prevented installation. Full pip output in file:
    /home/ed/.local/state/pipx/log/cmd_pip_errors.log

pip seemed to fail to build package:
    'pillow'

Fatal error from pip prevented installation. Full pip output in file:
    /home/ed/.local/state/pipx/log/cmd_pip_errors.log

pip seemed to fail to build package:
    'pillow'

Wenn man nun einen Blick in die zugehörige Logfile wirft, erfährt man, dass die Abhängigkeit von pillow kleiner als Version 7 und größer als Version 6.1 definiert ist, was zur Verwendung von der Version 6.2.2 führt. Schaut man nun einmal nach, was pillow eigentlich macht, erfährt man, dass dies eine Bibliothek für Python 2 war, mit der Grafiken gerendert werden konnten. Die in streamdeck-ui verwendete Version ist ein Fork von pillow für Python 3 und Ende 2025 bereits in der Version 12 verfügbar. Möglicherweise könnte das Problem dadurch behoben werden, indem eine aktuelle Version von pillow zum Einsatz kommt. Damit das gelingt, sind mit hoher Wahrscheinlichkeit auch Anpassungen am Code von streamdeck-ui vorzunehmen, da vermutlich seit der Version 6.2.2 einige Inkompatibilitäten der genutzten Funktionen vorhanden sind.

Mit dieser Analyse sehen wir, dass die Wahrscheinlichkeit, streamdeck-ui unter pip3 zum Laufen zu bekommen, in dasselbe Ergebnis führt wie mit PIPX. Wer nun auf die Idee kommt, unbedingt auf Python 2 zu downzugraden, um alte Programme zum Laufen zu bekommen, der sollte dies besser in einer gesonderten, isolierten Umgebung, zum Beispiel mit Docker versuchen. Python 2 hat seit vielen Jahren keinen Support durch Updates und Security Patches, weswegen eine parallele Installation zu Python 3 auf dem eigenen Betriebssystem keine gute Idee ist.

Wir sehen also, dass die anfangs beschriebene Fehlermeldung gar nicht so kryptisch ist, wenn man indes gleich auf PIPX setzt. Bekommt man sein Programm dann immer noch nicht installiert, hilft ein Blick auf die Fehlermeldung, der uns meist darüber aufklärt, dass wir ein veraltetes und nicht mehr gepflegtes Programm verwenden wollen.

Resources

Abonnement / Subscription

[English] This content is only available to subscribers.

[Deutsch] Diese Inhalte sind nur für Abonnenten verfügbar.

Artikel

Plattenspieler

Elmar Dott Okt. 20, 2025

Artikel Tutorials

Künstliche Intelligenz GPD4all unter Linux installieren

Peter Kapherr Aug. 25, 2025

Konferenzen

Grazer Linux Tage 2022

Elmar Dott Apr. 23, 2022

PDF-Generierung mit TP-CORE

Veröffentlicht am 2025-11-24 von Elmar Dott

Antworten

PDF ist vermutlich das wichtigste interoperable Dokumentenformat zwischen Betriebssystemen und Geräten wie Computer, Smartphone und Tablet. Die wichtigste Eigenschaft für PDF ist die Unveränderlichkeit der Dokumente. Natürlich sind auch hier Grenzen gesetzt und man kann heutzutage problemlos mit entsprechenden Programmen Seiten aus einem PDF Dokument entfernen oder hinzufügen. Dennoch lassen sich die Inhalte der einzelnen Seiten nicht ohne Weiteres verändern. Wo vor Jahren noch kostspielige Spezialsoftware wie beispielsweise Acrobat von Adobe nötig war, um mit PDF umzugehen, sind mittlerweile viele kostenfreie Lösungen auch für den kommerziellen Einsatz verfügbar. So beherrschen die gängigen Office Suiten den Export des Dokumentes als PDF.

Gerade im Geschäftsbereich ist PDF eine hervorragende Wahl, um Rechnungen oder Berichte zu generieren. Hier setzt auch dieser Artikel an. Ich beschreibe, wie einfache PDF Dokumente für die Rechnungslegung etc. genutzt werden können. Komplizierte Layouts, wie sie beispielsweise für Magazine und Zeitschriften in Verwendung kommen, sind nicht Teil dieses Artikels.

Technisch kommt die frei verfügbare Bibliothek openPDF zum Einsatz. Das Konzept ist, aus einem gültigen HTML Code, welcher in einem Template enthalten ist, eine PDF zu generieren. Da wir uns im JAVA Umfeld bewegen, ist die Template Engine der Wahl Velocity. Alle diese Abhängigkeiten nutzt TP-CORE in der Funktionalität PdfRenderer, welche als Fassade implementiert ist. Dies soll die Komplexität der PDF-Generierung in der Funktionalität kapseln und einen Austausch der Bibliothek ermöglichen.

Auch wenn ich nun kein Spezialist der PDF-Generierung bin, habe ich im Laufe der Jahre einige Erfahrungen speziell mit dieser Funktionalität in Bezug auf die Wartbarkeit von Softwareprojekten sammeln können. Dazu gibt es sogar einen Konferenzvortrag. Als ich vor sehr vielen Jahren den Entschluss gefasst hatte, PDF in TP-CORE zu unterstützen, gab es nur die iText-Bibliothek, die zu dieser Zeit mit der Version 5 frei verfügbar war. Ähnlich wie Linus Torvalds mit seinem ursprünglich genutzten Source Control-Management-System, erging es mir. Itext wurde kommerziell und ich brauchte eine neue Lösung. Nun, ich bin nicht Linus, der mal fix GIT aus dem Boden stampft, also habe ich nach einiger Wartezeit openPDF entdeckt. OpenPDF ist ein Fork von iText5. Jetzt musste ich meinen bestehenden Code entsprechend anpassen. Das erforderte einiges an Zeit, war aber dank meiner Kapselung eine überschaubare Aufgabe. In diesem Anpassungsprozess habe ich allerdings Probleme entdeckt, die mir in meiner kleinen Welt bereits das Leben schwer gemacht haben, also habe ich TP-CORE Version 3.0 veröffentlicht, um in der Funktionalität Stabilität zu erreichen. Wer also TP-CORE in einer 2.X Version verwendet, findet dort als PDF Lösung noch iText5. Das soll aber jetzt genug über die Entstehungsgeschichte sein. Kümmern wir uns darum, wie wir aktuell mit TP-CORE 3.1 PDF generieren können. Auch hier gilt: Mein größtes Ziel ist es, eine möglichst hohe Kompatibilität zu erreichen.

Bevor wir beginnen können, müssen wir TP-CORE als Abhängigkeit in unser Java Projekt einbinden. Das Beispiel demonstriert die Verwendung von Maven als Build Werkzeug, kann aber leicht auf Gradle umgestellt werden.

<dependency>
    <groupId>io.github.together.modules</groupId>
    <artifactId>core</artifactId>
    <version>3.1.0</version>
</dependency>

Um etwa eine Rechnung zu generieren, brauchen wir verschiedene Schritte. Zu erst benötigen wir ein HTML Template, das wir mit Velocity erzeugen. Das Template kann natürlich Platzhalter für Namen und Adresse enthalten, wodurch Serienbriefe und Batchverarbeitung möglich sind. Der folgende Code zeigt, wie wir damit umgehen können.

<h1>HTML to PDF Velocity Template</h1>

<p>Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet.</p>

<p>Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat.</p>

<h2>Lists</h2>
<ul>
    <li><b>bold</b></li>
    <li><i>italic</i></li>
    <li><u>underline</u></li>
</ul>

<ol>
    <li>Item</li>
    <li>Item</li>
</ol>

<h2>Table 100%</h2>
<table border="1" style="width: 100%; border: 1px solid black;">
    <tr>
        <td>Property 1</td>
        <td>$prop_01</td>
        <td>Lorem ipsum dolor sit amet,</td>
    </tr>
    <tr>
        <td>Property 2</td>
        <td>$prop_02</td>
        <td>Lorem ipsum dolor sit amet,</td>
    </tr>
    <tr>
        <td>Property 3</td>
        <td>$prop_03</td>
        <td>Lorem ipsum dolor sit amet,</td>
    </tr>
</table>

<img src="path/to/myImage.png" />

<h2>Links</h2>
<p>here we try a simple <a href="https://together-platform.org/tp-core/">link</a></p>

<h1>HTML to PDF Velocity Template</h1>

<p>Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet.</p>

<p>Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat.</p>

<h2>Lists</h2>
<ul>
    <li><b>bold</b></li>
    <li><i>italic</i></li>
    <li><u>underline</u></li>
</ul>

<ol>
    <li>Item</li>
    <li>Item</li>
</ol>

<h2>Table 100%</h2>
<table border="1" style="width: 100%; border: 1px solid black;">
    <tr>
        <td>Property 1</td>
        <td>$prop_01</td>
        <td>Lorem ipsum dolor sit amet,</td>
    </tr>
    <tr>
        <td>Property 2</td>
        <td>$prop_02</td>
        <td>Lorem ipsum dolor sit amet,</td>
    </tr>
    <tr>
        <td>Property 3</td>
        <td>$prop_03</td>
        <td>Lorem ipsum dolor sit amet,</td>
    </tr>
</table>

<img src="path/to/myImage.png" />

<h2>Links</h2>
<p>here we try a simple <a href="https://together-platform.org/tp-core/">link</a></p>

template.vm

In dem Template sind drei Properties enthalten: $prop_01, $prop_02 und $prop_03, die wir mit Werten füllen müssen. Das gelingt uns mit einer einfachen HashMap, die wir mit dem TemplateRenderer einfügen, wie das folgende Beispiel zeigt.

Map<String, String> properties = new HashMap<>();
properties.put("prop_01", "value 01");
properties.put("prop_02", "value 02");
properties.put("prop_03", "value 03");

TemplateRenderer templateEngine = new VelocityRenderer();
String directory = Constraints.SYSTEM_USER_HOME_DIR + “/“;
String htmlTemplate = templateEngine
                .loadContentByFileResource(directory, "template.vm", properties);

Map<String, String> properties = new HashMap<>();
properties.put("prop_01", "value 01");
properties.put("prop_02", "value 02");
properties.put("prop_03", "value 03");

TemplateRenderer templateEngine = new VelocityRenderer();
String directory = Constraints.SYSTEM_USER_HOME_DIR + “/“;
String htmlTemplate = templateEngine
                .loadContentByFileResource(directory, "template.vm", properties);

Der TemplateRenderer benötigt drei Argumente:

directory – Der vollständige Pfad vo das Template zu finden ist.
template – den Namen des Velocity-Templates
properties – Die HashMap mit den zu ersetzenden Variablen

Das Ergebnis ist ein gültiger HTML Code, aus dem wir nun über den PdfRenderer das PDF generieren können. Eine Besonderheit ist die Konstante SYSTEM_USER_HOME_DIR, welche auf das Nutzerverzeichnis des aktuell angemeldeten Benutzers zeigt und die Unterschiede einzelner Betriebssysteme wie Linux und Windows abfängt.

PdfRenderer pdf = new OpenPdfRenderer();
pdf.setTitle("Title of my own PDF");
pdf.setAuthor("Elmar Dott");
pdf.setSubject("A little description about the PDF document.");
pdf.setKeywords("pdf, html, openPDF");
pdf.renderDocumentFromHtml(directory + "myOwn.pdf", htmlTemplate);

PdfRenderer pdf = new OpenPdfRenderer();
pdf.setTitle("Title of my own PDF");
pdf.setAuthor("Elmar Dott");
pdf.setSubject("A little description about the PDF document.");
pdf.setKeywords("pdf, html, openPDF");
pdf.renderDocumentFromHtml(directory + "myOwn.pdf", htmlTemplate);

Das Listing zum Erstellen der PDF ist überschaubar und recht selbsterklärend. Es ist natürlich möglich, das HTML hardcodiert zu übergeben. Die Nutzung des Templates erlaubt hier eine Trennung von Code und Design, was auch spätere Anpassungen flexibel erlaubt.

Das Standardformat ist A4 mit den Dimensionen size: 21cm 29.7cm; margin: 20mm 20mm; und ist als inline CSS definiert. Über die Methode setFormat(String format); lässt sich dieser Wert individuell festlegen. Der erste Wert steht hierbei für die Breite und der zweite Wert für die Höhe.

Der PDF Renderer hat auch die Möglichkeit, einzelne Seiten aus einem Dokument zu löschen.

PdfRenderer pdf = new OpenPdfRenderer();
PdfDocument original = pdf.loadDocument( new File("document.pdf") );
PdfDocument reduced = pdf.removePage(original, 1, 5);
pdf.writeDocument(reduced, "reduced.pdf");

PdfRenderer pdf = new OpenPdfRenderer();
PdfDocument original = pdf.loadDocument( new File("document.pdf") );
PdfDocument reduced = pdf.removePage(original, 1, 5);
pdf.writeDocument(reduced, "reduced.pdf");

Wir sehen also, dass bei der Implementierung der PDF Funktionalität sehr viel Wert auf eine einfache Handhabung gelegt wurde. Dennoch gibt es viele Möglichkeiten, individuelle PDF Dokumente zu erstellen. Daher hat die Lösung, über HTML das Layout zu definieren, einen besonderen Reiz. Trotz, dass der PdfRenderer mit einer sehr überschaubaren Funktionalität aufwartet, ist es sehr einfach möglich, durch den Vererbungsmechanismus von Java das Interface und die zugehörige Implementierung durch eigene Lösungen zu erweitern. Diese Möglichkeit besteht auch für alle anderen Implementierungen aus TP-CORE.

TP-CORE ist auch für den kommerziellen Gebrauch frei und hat dank der Apache 2 Lizenz keine Einschränkungen. Der Source Code ist unter https://git.elmar-dott.com zu finden und die Dokumentation inklusive Security und Testcoverage findet sich unter https://together-platform.org/tp-core/.

Treasure chest – Part 1

RTFM – benutzbare Dokumentationen

Veröffentlicht am 2025-11-17 von Elmar Dott

Antworten

Ein alter Handwerksmeister pflegte immer zu sagen: Wer schreibt, der bleibt. Seine Intention war vor allem, ein vernünftiges Aufmaß und Wochenberichte seiner Gesellen zu bekommen. Diese Informationen benötigte er, um eine korrekte Rechnung stellen zu können, was für den Erfolg des Unternehmens maßgeblich war. Dieses Bild lässt sich auch gut auf die Softwareentwicklung übertragen. Erst als die in Japan von Yukihiro Matsumoto entwickelte Programmiersprache Ruby eine englischsprachige Dokumentation besaß, begann der weltweite Siegeszug von Ruby.

Wir sehen also, dass Dokumentation einen durchaus hohen Stellenwert für den Erfolg eines Softwareprojektes haben kann. Es beschränkt sich nicht nur auf einen Informationsspeicher im Projekt, wo neue Kollegen notwendige Details erfahren. Natürlich ist für Entwickler Dokumentation ein recht leidiges Thema. Stetig muss diese aktuell gehalten werden und oft fehlen auch Fertigkeiten, um die eigenen Gedanken sortiert und nachvollziehbar für andere auf Papier zu bringen.

Ich selbst kam vor sehr vielen Jahren erstmalig mit dem Thema Dokumentation durch das Lesen des Buches „Softwaretechnik“ von Johannes Siedersleben in Berührung. Dort wurde Ed Yourdon mit der Aussage zitiert, dass vor Methoden wie UML die Dokumentation oft in der Form einer viktorianischen Novelle vorlag. Während meines Berufslebens habe ich auch einige solcher viktorianischen Novellen angetroffen. Das Ärgerliche daran war: Nachdem man sich durch die Textwüste gekämpft hatte – anders als mit Überwindung und Kampf kann man das Gefühl nicht beschreiben –, hatte man die gesuchten Informationen immer noch nicht. Frei nach Goethes Faust: „So steh ich da ich armer Tor und bin so klug als wie zuvor.“

Hier sehen wir bereits einen ersten Kritikpunkt für schlechte Dokumentationen: eine unangemessene Länge der Ausführungen, die wenig Informationen enthalten. Hier müssen wir uns der Tatsache bewusst werden, dass das Schreiben nicht jedem in die Wiege gelegt wurde. Schließlich ist man ja Softwareentwickler und nicht Buchautor geworden. Das bedeutet für das Konzept „erfolgreiche Dokumentation“, dass man möglichst niemanden zu seinem Glück zwingen sollte und sich besser im Team nach Personen umschaut, die für Dokumentation ein Händchen haben. Das soll nun aber nicht bedeuten, dass alle anderen von der Aufgabe Dokumentation freigestellt sind. Ihr Input ist für die Qualität essenziell. Korrekturlesen, auf Fehler hinweisen und Ergänzungen vorschlagen sind durchaus notwendige Punkte, die sich gut auf vielen Schultern verteilen lassen.

Es ist durchaus ratsam, das Team, oder einzelne Teammitglieder gelegentlich rhetorisch zu schulen. Dabei sollte der Fokus auf einer präzisen, kompakten und verständlichen Ausdrucksweise liegen. Dabei geht es auch darum, die eigenen Gedanken so zu sortieren, dass diese auf Papier gebracht werden können und dabei einem roten Faden folgen. Die dadurch verbesserte Kommunikation wirkt sich sehr positiv auf die Entwicklungsprojekte aus.

Eine aktuell gehaltene Dokumentation, die gut zu lesen ist und wichtige Informationen enthält, wird schnell zu einem lebenden Dokument, ganz gleich, welche Formen gewählt wurden. Dies ist auch ein grundlegendes Konzept für erfolgreiches DevOps und agile Vorgehensmodelle. Denn diese Paradigmen setzen auf einen guten Informationsaustausch und adressieren auch das Vermeiden von sogenannten Informationssilos.

Ein Punkt, der mich wirklich triggert, ist die Aussage: Unsere Tests sind die Dokumentation. Nicht alle Stakeholder können programmieren und sind daher auch nicht in der Lage, die Testfälle zu verstehen. Zudem demonstrieren Tests zwar das Verhalten von Funktionen, sie demonstrieren aber nicht per se die richtige Verwendung. Meist fehlen auch Variationen von verwendbaren Lösungen. Damit Testfälle einen dokumentativen Charakter haben, ist es notwendig, spezielle Tests exakt für diesen Zweck zu entwickeln. Dieses Vorgehen hat meiner Ansicht nach zwei gravierende Vorteile. Zum Ersten bleibt die Dokumentation zur Implementierung aktuell, denn bei Änderungen schlägt der Testfall fehl. Ein weiterer positiver Effekt ist, dass der Entwickler über die Verwendung seiner Implementierung bewusst wird und einen ungünstigen Entwurf zeitnah korrigieren kann.

Natürlich gibt es mittlerweile unzählige technische Lösungen, die je nach Sichtweise auf das System für unterschiedliche Personengruppen geeignet sind. Issue- und Bug-Tracking Systeme wie beispielsweise das kommerzielle JIRA oder das freie Redmine bilden ganze Prozesse ab. Sie erlauben es den Testern, erkannte Probleme und Fehler der Software einer Releaseversion zuzuordnen. Projektleiter können mit dem Release Management eine Priorisierung der Korrekturen vornehmen und die Entwickler dokumentieren die verwendete Korrektur. Soweit die Theorie. In der Praxis habe ich in nahezu jedem Projekt erlebt, wie in diesen Systemen die Kommentarfunktion als Chat missbraucht wurde, um den Änderungsstatus zu beschreiben. Als Ergebnis hat man eine Fehlerbeschreibung mit unzähligen nutzlosen Kommentaren und wirkliche weiterführende Informationen fehlen komplett.

Eine weitverbreitete technische Lösung in Entwicklungsprojekten sind auch sogenannte Enterprise Wikis. Sie ergänzen einfache Wikis durch eine Navigation und ermöglichen das Erstellen geschlossener Spaces, auf die nur explizit zugelassene Nutzergruppen feingranulare Berechtigungen wie Lesen oder Schreiben erhalten. Neben der weitverbreiteten kommerziellen Lösung Confluence gibt es auch eine freie Variante namens Blue Spice, die auf dem MediaWiki basiert. Wikis erlauben die kollaborative Arbeit an einem Dokument und die einzelnen Seiten können auch über verschiedene Zusammenstellungen als PDF exportiert werden. Damit die Wikiseiten auch benutzbar bleiben, sollte man Wert auf eine saubere und möglichst einheitliche Formatierung legen. Tabellen sollten mit ihrem Inhalt auf eine A4 Seite passen, ohne dass es zu unerwünschten Umbrüchen kommt. Das verbessert den Lesefluss. Es gibt auch viele Fälle, in denen Aufzählungen der Übersichtshalber Tabellen vorzuziehen sind.

Dies bringt uns auch zu einem weiteren sehr heiklen Thema, den Grafiken. Es ist durchaus korrekt, dass ein Bild oft mehr als tausend Worte sagt. Aber eben nicht immer! Im Umgang mit Grafiken ist es wichtig, sich bewusst zu sein, dass Bilder oft einiges an Zeit für die Erstellung benötigen und oft auch nur mit viel Aufwand angepasst werden können. Daraus ergeben sich einige Konsequenzen, um sich das Leben zu erleichtern. Zum Erstellen von Grafiken wird sich auf ein Standardprogramm (Format) festgelegt. Auf teure Grafikprogramme wie Photoshop und Corel ist zu verzichten. Grafiken, die für Wikiseiten erstellt wurden, sind in ihrem Original, also der änderbaren Datei, an die Wikiseite anzufügen. Es kann auch ein eigenes Repository dafür aufgebaut werden, um so eine Wiederverwendung in anderen Projekten zu ermöglichen.

Wenn ein Bild keinen Mehrwert bedeutet, sollte man darauf besser verzichten. Dazu ein kleines Beispiel. Es ist nicht notwendig, eine Grafik anzufertigen, auf der 10 Strichmännchen abgebildet sind, unter denen dann der Rollenname oder eine Person steht. Hier ist es zielführend, eine einfache Aufzählung anzufertigen, die sich im Übrigen auch leichter ergänzen beziehungsweise anpassen lässt.

Professionelle Screenshots anfertigen

Aber auch auf überfrachtete Grafiken sollte man verzichten. Treu nach dem Motto „Viel hilft viel“: Sorgen zu detaillierte Informationen eher für Verwirrung und können zu Missinterpretationen führen. Eine Buchempfehlung ist „Softwarearchitekturen dokumentieren und kommunizieren“ von Stefan Zörner. Er arbeite in diesem Titel optimal heraus, wie wichtig die verschiedenen Sichtweisen auf ein System sind und welche Personengruppen mit einer expliziten Sicht angesprochen werden. Dazu möchte ich auch die Gelegenheit nutzen, um seine 7. Regeln für eine gute Dokumentation wiederzugeben.

Schreibe aus Sicht des Lesers.
Vermeide unnötige Wiederholungen.
Vermeide Mehrdeutigkeiten, wenn nötig Notation erläutern.
Verwende Standards wie z. B. UML.
Halte Begründungen (Warum) fest.
Die Dokumentation ist aktuell zu halten, aber nie zu aktuell.
Überprüfe die Gebrauchstauglichkeit (Review).

Wer im Projekt damit beauftragt ist, die Dokumentation zu schreiben beziehungsweise deren Fortschritt und Aktualität sicherzustellen hat, sollte sich immer bewusst sein, dass wichtige Informationen enthalten sind, diese auch korrekt und verständlich dargestellt werden. Eine kompakte und übersichtliche Dokumentation lässt sich auch bei fortschreitendem Projekt problemlos anpassen und erweitern. Anpassungen gelingen immer dann am besten, wenn der betroffene Bereich möglichst zusammenhängend ist und möglichst nur einmal vorkommt. Diese Zentralisierung erreicht man durch Referenzen und Verlinkungen, so dass die Änderung im Original sich auf die Referenzen auswirkt.

Natürlich gibt es zum Thema Dokumentation noch viel mehr zu sagen, schließlich ist es Gegenstand verschiedener Bücher, aber das würde den Rahmen dieses Artikels übersteigen. Mir ging es vor allem darum, für das Thema eine Sensibilisierung zu schaffen, denn Paradigmen wie Agilität und DevOps basieren auf einem guten Informationsfluss.

Artikel

Marketing mit künstlicher Intelligenz

Neo Diseno Sep. 1, 2025

Artikel

Wie man Bitcoin kauft und damit bezahlen kann

Elmar Dott Jan. 14, 2025

Artikel

Passwörter, aber sicher?

Mike Homberger Sep. 15, 2025

Artikel Publikationen

Prozesslandschaften

Elmar Dott Dez. 15, 2022

Artikel

Stabilität in der Krise – business continuity & disaster recovery

Elmar Dott Okt. 21, 2024

Artikel Publikationen

Der grüne Punkt – Mythos Wiederverwendung

Elmar Dott Apr. 1, 2022

BugChaser – Die Grenze der Testabdeckung

Veröffentlicht am 2025-11-10 von Elmar Dott

Antworten

Die mittlerweile im Software Engineering etablierten Paradigmen wie Test Driven Development (TDD) und Behavior Driven Development (BDD) mit entsprechend einfach zu bedienenden Werkzeugen haben eine neue pragmatische Sichtweise auf das Thema Software Tests eröffnet. Ein wichtiger Faktor in kommerziellen Softwareprojekten sind automatisierte Tests. Deshalb spricht man in diesem Kontext von einer erfolgreichen Teststrategie, wenn die Testausführung ohne menschliches Zutun vonstattengeht.

Testautomatisierung bildet die Grundlage, um Stabilität und Risikoreduzierung bei kritischen Arbeiten zu erreichen. Zu solchen kritischen Tätigkeiten zählen insbesondere das Refactoring, Maintenance und Fehlerkorrekturen. Allen diesen Aktivitäten obliegt eine Gemeinsamkeit: dass sich keine neuen Fehler in den Code einschleichen dürfen.

In dem Artikel „The Humble Programmer“ von 1972 stellte Edsger W. Dijkstra folgendes fest:

„Programmtests können ein sehr effektiver Weg sein, um das Vorhandensein von Fehlern aufzuzeigen, sind aber völlig unzureichend, um deren Abwesenheit nachzuweisen.“

Eine alleinige Automatisierung der Testausführung ist deshalb nicht ausreichend, um sicherzustellen, dass Änderungen der Codebasis keine unerwünschten Effekte auf bestehende Funktionen haben. Aus diesem Grund muss die Qualität der Testfälle bewertet werden. Hierzu gibt es bereits bewährte Werkzeuge.

Bevor wir tiefer in die Thematik einsteigen, wollen wir uns zuerst überlegen, was eigentlich automatisiertes Testen bedeutet. Diese Frage ist recht einfach zu beantworten. Nahezu jede Programmiersprache hat ein entsprechendes Unit Test Framework. Unit Tests rufen eine Methode mit verschiedenen Parametern auf und vergleichen den Rückgabewert mit einem Erwartungswert. Stimmen beide Werte überein, gilt der Test als bestanden. Zusätzlich kann noch überprüft werden, ob eine Ausnahme geworfen wurde.

Für den Fall, dass eine Methode keinen Rückgabewert hat oder keinen Fehler wirft, kann diese Methode nicht getestet werden. Auch als private gekennzeichnete Methoden oder innere Klassen, sind nicht ohne Weiteres zu testen, da sie nicht direkt aufgerufen werden können. Diese sind über öffentliche Methoden, welche die ‚versteckten‘ Methoden aufrufen, zu testen.

Im Umgang mit als private gekennzeichneten Methoden ist es keine Option, die dadurch abgebildete Funktionalität über Techniken wie die Verwendung der Reflection API zu erreichen und zu testen. Denn wir müssen uns bewusst machen, dass solche Methoden oft auch dazu verwendet werden, Fragmente zu kapseln, um Dopplungen zu vermeiden.

public boolean method() {
    boolean success = false;
    List collector = new ArryList();
    collector.add(1);
    collector.add(2);
    collector.add(3);
    
    sortAsc(collector);
    if(collector.getFirst().equals(1)) {
        success = true;
    }
    return success;
}

private void sortAsc(List collection) {
    collection.sort( 
            (a, b) -> { 
                return -1 * a.compareTo(b); 
            });
}

public boolean method() {
    boolean success = false;
    List collector = new ArryList();
    collector.add(1);
    collector.add(2);
    collector.add(3);
    
    sortAsc(collector);
    if(collector.getFirst().equals(1)) {
        success = true;
    }
    return success;
}

private void sortAsc(List collection) {
    collection.sort( 
            (a, b) -> { 
                return -1 * a.compareTo(b); 
            });
}

Um also effektiv automatisierte Tests schreiben zu können, ist es notwendig, einem gewissen Codingstil zu folgen. Das vorangegangene Listing 1 demonstriert auf einfache Weise, wie testbarer Code aussehen kann.

Da Entwickler für ihre eigene Implementierung auch die zugehörigen Komponententests schreiben, ist das Problem von schwer testbarem Code in Projekten, die einem testgetriebenen Ansatz folgen, weitgehend eliminiert. Die Motivation zu testen liegt nun beim Entwickler, da dieser mit diesem Paradigma feststellen kann, ob seine Implementierung sich wie gewünscht verhält. Dabei müssen wir uns aber fragen: Ist das bereits alles, was wir tun müssen, um gute und stabile Software zu entwickeln?

Wie wir uns bei solchen Fragen immer denken können, lautet die Antwort nein. Ein essenzielles Werkzeug, um die Qualität der Tests zu bewerten, ist das Erreichen einer möglichst hohen Testabdeckung. Dabei wird zwischen Branch und Line Coverage unterschieden. Um den Unterschied etwas besser zu verdeutlichen, schauen wir kurz auf den Pseudocode in Listing 2.

if( Expression-A OR Expression-B ) {
	print(‘allow‘);
} else {
	print(‘decline‘);
}

Unser Ziel ist es, nach Möglichkeit alle Zeilen zu durchlaufen. Dazu brauchen wir bereits zwei separate Testfälle. Einen für das Betreten des IF-Zweiges und einen für das Betreten des ELSE-Zweiges. Damit wir aber auch eine hundertprozentige Branch-Coverage erzielen, müssen wir alle Varianten des IF-Zweiges abdecken. Für das Beispiel heißt das: ein Test, der Expression-A true werden lässt, und ein weiterer Test, der Expression-B true werden lässt. Daraus ergeben sich insgesamt drei verschiedene Testfälle.

Der Screenshot aus dem Projekt TP-CORE zeigt, wie eine solche Testabdeckung in ‚echten‘ Projekten aussehen kann.

Natürlich ist dieses Beispiel sehr einfach und es gibt im wirklichen Leben oft Konstrukte, bei denen man trotz aller Bemühungen nicht alle Lines beziehungsweise Branches erreicht. Sehr typisch sind Exceptions aus Fremdbibliotheken, die zu fangen sind, aber unter normalen Umständen nicht provoziert werden können.

Aus diesem Grund versuchen wir zwar, eine möglichst hohe Testabdeckung zu erreichen, und streben natürlich die 100 % an, aber es gibt genügend Fälle, in denen dies nicht möglich ist. Eine Testabdeckung von 90% gelingt aber durchaus. Der Industriestandard für kommerzielle Projekte liegt bei 85 % Testabdeckung. Mit diesen Erkenntnissen können wir also sagen, dass die Testabdeckung mit der Testbarkeit einer Anwendung korreliert. Das bedeutet, die Testabdeckung ist ein geeignetes Maß für die Testbarkeit.

Hier muss man allerdings auch zugeben, dass die Metrik der Testabdeckung ihre Grenze hat. Reguläre Ausdrücke und Annotationen zur Datenvalidierung sind nur einige einfache Beispiele für eine nicht aussagefähige Testabdeckung.

Ohne allzu sehr in die Implementierungsdetails einzugehen, stellen wir uns vor, wir müssten einen regulären Ausdruck schreiben, um Eingaben auf ein korrektes 24 Stunden Format zu überprüfen. Haben wir das korrekte Intervall nicht im Auge, ist unser regulärer Ausdruck möglicherweise nicht korrekt. Das richtige Intervall für das 24-Stunden-Format lautet: 00:00 – 23:59. Beispiele für fehlerhafte Werte sind 24:00 oder 23:60. Ist uns dieser Fakt nicht bewusst, können trotz Testfällen Fehler in unserer Anwendung versteckt sein, bis sie verwendet werden un zu Fehlern führen.

Dies ist ein hervorragendes Beispiel für das Zitat von Dijkstra zu Beginn des Artikels. Zudem möchte ich noch ein weiteres Zitat aus einem Artikel anführen, an dem Christian Bird mitgewirkt hat. Der Artikel heißt „The Design of Bug Fixes“ und ist aus dem Jahr 2013.

„… In a few cases, participants were unable to think of alternative solutions …“

Hier ging es um die Fragestellung, ob eine Fehlerkorrektur immer die optimale Lösung darstellt. Abgesehen davon wäre zu klären, was in kommerziellen Softwareentwicklungsprojekten eine optimale Lösung darstellt. Sehr demonstrativ ist die Aussage, dass es Fälle gibt, in denen Entwickler nur einen Weg kennen beziehungsweise verstehen. Das spiegelt auch unser Beispiel der RegEx wider. Softwareentwicklung ist ein Denkprozess, der sich auch nicht beschleunigen lässt. Unser Denken wird durch unsere Vorstellungskraft bestimmt, die wiederum von unserer Erfahrung beeinflusst ist.

Dies zeigt uns bereits ein weiteres Beispiel für Fehlerquellen in Testfällen. Ein Klassiker sind z. B. inkorrekte Vergleiche in Collections. Es geht unter anderem um das Vergleichen von Arrays. Die Problematik, mit der wir hier zu kämpfen haben, ist das Thema, wie auf Variablen zugegriffen wird: Call by Value oder Call by Reference. Bei Arrays erfolgt der Zugriff über Call by Reference, also direkt auf die Speicherzelle. Weist man nun ein Array einer neuen Variable zu und vergleicht beide Variablen, sind diese immer gleich, da man das Array mit sich selbst vergleicht. Ein Beispiel für einen Testfall, der eigentlich keine Aussagekraft hat. Ist die Implementierung dennoch korrekt, wird dieser fehlerhafte Testfall nie ins Gewicht fallen.

Diese Erkenntnis zeigt uns, dass ein blindes Erreichen der Testabdeckung für die Qualität nicht zielführend ist. Natürlich ist es verständlich, dass im Management diese Metrik einen hohen Stellenwert hat. Wir haben aber auch nachweisen können, das man sich darauf alleine nicht verlassen darf. Wir sehen also, dass auch für Testfälle Codeinspektionen und Refactorings ein Bedarf besteht. Da man aus Zeitgründen nun nicht den ganzen Code von vorn bis hinten lesen und auch verstehen kann, ist es wichtig, auf problematische Bereiche zu konzentrieren. Wie kann man aber diese Problembereiche finden? Hier hilft uns eine vergleichsweise neue Technik. Die theoretischen Arbeiten dazu sind bereits etwas älter, es hat nur eine Weile gedauert, bis entsprechende Implementierungen verfügbar wurden.

Mutation Testing. Dies erlaubt, durch Veränderung des Originalcodes Testfälle zu finden, die trotz verschiedener Mutationen nicht fehlschlagen. Damit haben wir ein weiteres Werkzeug an der Hand, die Qualität der vorhandenen Tests zu bewerten. In diesem Artikel habe ich zeigen können, dass man sich nicht komplett auf die Testcoverage verlassen darf. Um dieses Problem zu lösen, können wir uns des Mutation Testing bedienen. Wie konkret Mutation Testing funktioniert, kann wiederum Thema eines eigenständigen Artikels sein und würde an dieser Stelle den Rahmen sprengen.

Artikel

PHP Elegant Testing in Laravel

Elmar Dott Okt. 6, 2025

Konferenzen

Entwickler Tage remote 2024

Elmar Dott Mai 25, 2024

Artikel Publikationen

Test First?

Elmar Dott Dez. 20, 2023

Plattenspieler II

Veröffentlicht am 2025-11-03 von Elmar Dott

Antworten

Nachdem wir im ersten Teil dieses Workshops eher allgemein Fragestellungen wie Dateisysteme und Partitionen besprochen haben, wenden wir uns im zweiten und letzten Teil der Artikelserie verschiedenen Diagnosetechniken zu. Unser Hauptarbeitsgerät hierfür wird die Bash sein, da die folgenden Werkzeuge alle kommandzeilenbasiert sind.

Auch für diesen Teil gilt, größte Sorgfalt walten zu lassen. Die hier beschriebenen Praktiken können bei unsachgemäßer Anwendung zu Datenverlusten führen. Für etwaige Schäden übernehme ich keine Haftung.

Plattenspieler

Beginnen wir auch gleich mit der Möglichkeit, herauszufinden, wie viel Speicher wir noch auf unserer Festplatte freihaben. Wer gelegentlich auf Servern sein Unwesen treibt, kommt um den Befehl df nicht umher. Schließlich hat der SSH Client kein grafisches Interface und man muss sich auf der Shell zurechtfinden.

Mit df -hT lassen sich alle Speicher, physisch und virtuell, in menschenlesbarer Form anzeigen.

ed@local:~$ df -hT
Filesystem     Type      Size  Used Avail Use% Mounted on
udev           devtmpfs   32G     0   32G   0% /dev
tmpfs          tmpfs     6.3G  2.8M  6.3G   1% /run
/dev/nvme0n1p2 ext4      1.8T  122G  1.6T   8% /
tmpfs          tmpfs      32G  8.0K   32G   1% /dev/shm
efivarfs       efivarfs  196K  133K   59K  70% /sys/firmware/efi/efivars
tmpfs          tmpfs     5.0M   16K  5.0M   1% /run/lock
tmpfs          tmpfs     1.0M     0  1.0M   0% /run/credentials/systemd-journald.service
tmpfs          tmpfs      32G   20M   32G   1% /tmp
/dev/nvme0n1p1 vfat      975M  8.8M  966M   1% /boot/efi
tmpfs          tmpfs     6.3G  224K  6.3G   1% /run/user/1000

ed@local:~$ df -hT
Filesystem     Type      Size  Used Avail Use% Mounted on
udev           devtmpfs   32G     0   32G   0% /dev
tmpfs          tmpfs     6.3G  2.8M  6.3G   1% /run
/dev/nvme0n1p2 ext4      1.8T  122G  1.6T   8% /
tmpfs          tmpfs      32G  8.0K   32G   1% /dev/shm
efivarfs       efivarfs  196K  133K   59K  70% /sys/firmware/efi/efivars
tmpfs          tmpfs     5.0M   16K  5.0M   1% /run/lock
tmpfs          tmpfs     1.0M     0  1.0M   0% /run/credentials/systemd-journald.service
tmpfs          tmpfs      32G   20M   32G   1% /tmp
/dev/nvme0n1p1 vfat      975M  8.8M  966M   1% /boot/efi
tmpfs          tmpfs     6.3G  224K  6.3G   1% /run/user/1000

Wie wir in der Ausgabe sehen können, ist der Mountpunkt / ein ext4 Dateisystem, mit einer nvme SSD die eine Kapazität von 1,8 TB hat, von der circa 1,2 TB noch frei sind. Würden noch andere Speichermedien wie externe Festplatten oder USB vorhanden sein, wären sie ebenfalls Bestandteil der Liste. Sicher gehört etwas Übung dazu, den Blick für die relevanten Details zu schärfen. Im nächsten Schritt wollen wir uns ein wenig in der Diagnose üben.

lsblk

Falls die Ausgabe von df zu unübersichtlich ist, kann auch auf das Werkzeug lsblk zurückgegriffen werden, das für Anfänger eine etwas verständlichere Auflistung bereitstellt.

ed@local:~$ sudo lsblk
NAME         MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
loop0          7:0    0     4K  1 loop /snap/bare/5
loop1          7:1    0  73.9M  1 loop /snap/core22/2139
loop2          7:2    0 516.2M  1 loop /snap/gnome-42-2204/226
loop3          7:3    0  91.7M  1 loop /snap/gtk-common-themes/1535
loop4          7:4    0  10.8M  1 loop /snap/snap-store/1270
loop5          7:5    0  50.9M  1 loop /snap/snapd/25577
loop6          7:6    0  73.9M  1 loop /snap/core22/2133
loop7          7:7    0  50.8M  1 loop /snap/snapd/25202
loop8          7:8    0   4.2G  0 loop 
└─veracrypt1 254:0    0   4.2G  0 dm   /media/veracrypt1
sda            8:0    1 119.1G  0 disk 
└─sda1         8:1    1 119.1G  0 part 
sr0           11:0    1  1024M  0 rom  
nvme0n1      259:0    0   1.9T  0 disk 
├─nvme0n1p1  259:1    0   976M  0 part /boot/efi
├─nvme0n1p2  259:2    0   1.8T  0 part /
└─nvme0n1p3  259:3    0  63.7G  0 part [SWAP]

ed@local:~$ sudo lsblk
NAME         MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
loop0          7:0    0     4K  1 loop /snap/bare/5
loop1          7:1    0  73.9M  1 loop /snap/core22/2139
loop2          7:2    0 516.2M  1 loop /snap/gnome-42-2204/226
loop3          7:3    0  91.7M  1 loop /snap/gtk-common-themes/1535
loop4          7:4    0  10.8M  1 loop /snap/snap-store/1270
loop5          7:5    0  50.9M  1 loop /snap/snapd/25577
loop6          7:6    0  73.9M  1 loop /snap/core22/2133
loop7          7:7    0  50.8M  1 loop /snap/snapd/25202
loop8          7:8    0   4.2G  0 loop 
└─veracrypt1 254:0    0   4.2G  0 dm   /media/veracrypt1
sda            8:0    1 119.1G  0 disk 
└─sda1         8:1    1 119.1G  0 part 
sr0           11:0    1  1024M  0 rom  
nvme0n1      259:0    0   1.9T  0 disk 
├─nvme0n1p1  259:1    0   976M  0 part /boot/efi
├─nvme0n1p2  259:2    0   1.8T  0 part /
└─nvme0n1p3  259:3    0  63.7G  0 part [SWAP]

S.M.A.R.T

Um gleich vor der Benutzung unseren neu erstandenen Speicher auf Herz und Nieren zu prüfen, bedienen wir uns der sogenannten S.M.A.R.T (Self-Monitoring, Analysis and Reporting Technology) Tools. Das kann man zum einen mit dem im ersten Teil dieses Artikels vorgestellten Programm Disks tun, oder mit ausführlicheren Informationen über die Bash. Mit df -hT haben wir die SSD /dev/nvme0 bereits identifiziert, sodass wir smartctl aufrufen können.

ed@local:~$ sudo smartctl --all /dev/nvme0 
smartctl 7.4 2023-08-01 r5530 [x86_64-linux-6.12.48+deb13-amd64] (local build)
Copyright (C) 2002-23, Bruce Allen, Christian Franke, www.smartmontools.org

=== START OF INFORMATION SECTION ===
Model Number:                       SAMSUNG MZVL22T0HDLB-00BLL
Serial Number:                      S75ZNE0W602153
Firmware Version:                   6L2QGXD7
PCI Vendor/Subsystem ID:            0x144d
IEEE OUI Identifier:                0x002538
Total NVM Capacity:                 2,048,408,248,320 [2.04 TB]
Unallocated NVM Capacity:           0
Controller ID:                      6
NVMe Version:                       1.3
Number of Namespaces:               1
Namespace 1 Size/Capacity:          2,048,408,248,320 [2.04 TB]
Namespace 1 Utilization:            248,372,908,032 [248 GB]
Namespace 1 Formatted LBA Size:     512
Namespace 1 IEEE EUI-64:            002538 b63101bf9d
Local Time is:                      Sat Oct 25 08:07:32 2025 CST
Firmware Updates (0x16):            3 Slots, no Reset required
Optional Admin Commands (0x0017):   Security Format Frmw_DL Self_Test
Optional NVM Commands (0x0057):     Comp Wr_Unc DS_Mngmt Sav/Sel_Feat Timestmp
Log Page Attributes (0x0e):         Cmd_Eff_Lg Ext_Get_Lg Telmtry_Lg
Maximum Data Transfer Size:         128 Pages
Warning  Comp. Temp. Threshold:     83 Celsius
Critical Comp. Temp. Threshold:     85 Celsius

Supported Power States
St Op     Max   Active     Idle   RL RT WL WT  Ent_Lat  Ex_Lat
 0 +     8.41W       -        -    0  0  0  0        0       0
 1 +     8.41W       -        -    1  1  1  1        0     200
 2 +     8.41W       -        -    2  2  2  2        0     200
 3 -   0.0500W       -        -    3  3  3  3     2000    1200
 4 -   0.0050W       -        -    4  4  4  4      500    9500

Supported LBA Sizes (NSID 0x1)
Id Fmt  Data  Metadt  Rel_Perf
 0 +     512       0         0

=== START OF SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED

SMART/Health Information (NVMe Log 0x02)
Critical Warning:                   0x00
Temperature:                        37 Celsius
Available Spare:                    100%
Available Spare Threshold:          10%
Percentage Used:                    0%
Data Units Read:                    43,047,167 [22.0 TB]
Data Units Written:                 25,888,438 [13.2 TB]
Host Read Commands:                 314,004,907
Host Write Commands:                229,795,952
Controller Busy Time:               2,168
Power Cycles:                       1,331
Power On Hours:                     663
Unsafe Shutdowns:                   116
Media and Data Integrity Errors:    0
Error Information Log Entries:      0
Warning  Comp. Temperature Time:    0
Critical Comp. Temperature Time:    0
Temperature Sensor 1:               37 Celsius
Temperature Sensor 2:               37 Celsius

Error Information (NVMe Log 0x01, 16 of 64 entries)
No Errors Logged

Self-test Log (NVMe Log 0x06)
Self-test status: No self-test in progress
No Self-tests Logged

ed@local:~$ sudo smartctl --all /dev/nvme0 
smartctl 7.4 2023-08-01 r5530 [x86_64-linux-6.12.48+deb13-amd64] (local build)
Copyright (C) 2002-23, Bruce Allen, Christian Franke, www.smartmontools.org

=== START OF INFORMATION SECTION ===
Model Number:                       SAMSUNG MZVL22T0HDLB-00BLL
Serial Number:                      S75ZNE0W602153
Firmware Version:                   6L2QGXD7
PCI Vendor/Subsystem ID:            0x144d
IEEE OUI Identifier:                0x002538
Total NVM Capacity:                 2,048,408,248,320 [2.04 TB]
Unallocated NVM Capacity:           0
Controller ID:                      6
NVMe Version:                       1.3
Number of Namespaces:               1
Namespace 1 Size/Capacity:          2,048,408,248,320 [2.04 TB]
Namespace 1 Utilization:            248,372,908,032 [248 GB]
Namespace 1 Formatted LBA Size:     512
Namespace 1 IEEE EUI-64:            002538 b63101bf9d
Local Time is:                      Sat Oct 25 08:07:32 2025 CST
Firmware Updates (0x16):            3 Slots, no Reset required
Optional Admin Commands (0x0017):   Security Format Frmw_DL Self_Test
Optional NVM Commands (0x0057):     Comp Wr_Unc DS_Mngmt Sav/Sel_Feat Timestmp
Log Page Attributes (0x0e):         Cmd_Eff_Lg Ext_Get_Lg Telmtry_Lg
Maximum Data Transfer Size:         128 Pages
Warning  Comp. Temp. Threshold:     83 Celsius
Critical Comp. Temp. Threshold:     85 Celsius

Supported Power States
St Op     Max   Active     Idle   RL RT WL WT  Ent_Lat  Ex_Lat
 0 +     8.41W       -        -    0  0  0  0        0       0
 1 +     8.41W       -        -    1  1  1  1        0     200
 2 +     8.41W       -        -    2  2  2  2        0     200
 3 -   0.0500W       -        -    3  3  3  3     2000    1200
 4 -   0.0050W       -        -    4  4  4  4      500    9500

Supported LBA Sizes (NSID 0x1)
Id Fmt  Data  Metadt  Rel_Perf
 0 +     512       0         0

=== START OF SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED

SMART/Health Information (NVMe Log 0x02)
Critical Warning:                   0x00
Temperature:                        37 Celsius
Available Spare:                    100%
Available Spare Threshold:          10%
Percentage Used:                    0%
Data Units Read:                    43,047,167 [22.0 TB]
Data Units Written:                 25,888,438 [13.2 TB]
Host Read Commands:                 314,004,907
Host Write Commands:                229,795,952
Controller Busy Time:               2,168
Power Cycles:                       1,331
Power On Hours:                     663
Unsafe Shutdowns:                   116
Media and Data Integrity Errors:    0
Error Information Log Entries:      0
Warning  Comp. Temperature Time:    0
Critical Comp. Temperature Time:    0
Temperature Sensor 1:               37 Celsius
Temperature Sensor 2:               37 Celsius

Error Information (NVMe Log 0x01, 16 of 64 entries)
No Errors Logged

Self-test Log (NVMe Log 0x06)
Self-test status: No self-test in progress
No Self-tests Logged

Eine sehr praktische Informationsquelle, besonders wenn man beabsichtigt, eine gebrauchte Platte zu verbauen. Glücklicherweise zeigt meine System SSD nach knapp zwei Jahren Nutzung keine Auffälligkeiten.

fdisk

Der Klassiker unter den Festplattenprogrammen ist fdisk, das auch unter Windows Systemen verfügbar ist. Mit fdisk können nicht nur Platten formatiert werden, sondern auch einige Informationen herausgekitzelt werden. Hierfür gibt es die Parameter -l für list und -x mit mehr Details. Das Programm fdisk ist recht komplex und zum Formatieren von Datenträgern empfehle ich eher die im ersten Teil dieses Artikels vorgestellten grafischen Varianten Disks und Gparted. Mit dem grafischen Interface ist die Wahrscheinlichkeit, Fehler zu machen, weitaus geringer als in der Shell.

ed@local:~$ sudo fdisk -l
Disk /dev/nvme0n1: 1.86 TiB, 2048408248320 bytes, 4000797360 sectors
Disk model: SAMSUNG MZVL22T0HDLB-00BLL              
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 347D3F20-0228-436D-9864-22A5D36039D9

Device              Start        End    Sectors  Size Type
/dev/nvme0n1p1       2048    2000895    1998848  976M EFI System
/dev/nvme0n1p2    2000896 3867305983 3865305088  1.8T Linux filesystem
/dev/nvme0n1p3 3867305984 4000796671  133490688 63.7G Linux swap

Disk /dev/sda: 119.08 GiB, 127865454592 bytes, 249737216 sectors
Disk model: Storage Device  
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xa82a04bd

Device     Boot Start       End   Sectors   Size Id Type
/dev/sda1        2048 249737215 249735168 119.1G 83 Linux

ed@local:~$ sudo fdisk -l
Disk /dev/nvme0n1: 1.86 TiB, 2048408248320 bytes, 4000797360 sectors
Disk model: SAMSUNG MZVL22T0HDLB-00BLL              
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 347D3F20-0228-436D-9864-22A5D36039D9

Device              Start        End    Sectors  Size Type
/dev/nvme0n1p1       2048    2000895    1998848  976M EFI System
/dev/nvme0n1p2    2000896 3867305983 3865305088  1.8T Linux filesystem
/dev/nvme0n1p3 3867305984 4000796671  133490688 63.7G Linux swap

Disk /dev/sda: 119.08 GiB, 127865454592 bytes, 249737216 sectors
Disk model: Storage Device  
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xa82a04bd

Device     Boot Start       End   Sectors   Size Id Type
/dev/sda1        2048 249737215 249735168 119.1G 83 Linux

Basisreparatur mit Konsistenzcheck: fsck

Sollten wider Erwarten Probleme auftauchen, besteht mit dem Werkzeug fsck (File System Consistency Check) die Möglichkeit, das Dateisystem zu überprüfen und gegebenenfalls zu reparieren. Dazu muss man allerdings die entsprechende Partition angeben.

sudo fsck /dev/sdc

Wie man in dem Screenshot sehen kann, hatte ich vor einiger Zeit eine Partition mit einem defekten Superblock, sodass ein Zugriff auf die Daten nicht mehr möglich war. Grund für den Fehler war eine kaputte Speicherzelle in der SSD. Mit etwas Mühe ließ sich dann auf die Daten zugreifen und ich konnte diese auf einen anderen Speicher kopieren. Das klappt nicht immer. Weshalb ich als kleinen Ratschlag mitgeben möchte, vor solchen Rettungsaktionen immer gut vorbereitet zu sein. Das heißt, auch ein entsprechend großes, funktionierendes Ziellaufwerk bereit zu haben, um bei Erfolg sofort eine Sicherungskopie anfertigen zu können. Viele der hier vorgestellten Operationen verändern die Daten auf dem Speicher und es ist nicht sicher, ob ein erneuter Zugriff gelingen wird.

Linux Sysadmin Witz

Linux Sys-Admins empfehlen Anfängern gern das Löschen der französischen Sprachdateien, die man ja nicht braucht, um Platz zu sparen. Dazu soll man den Befehl sudo rm -fr / in der Konsole eintippen und ENTER drücken. Das sollte man auf keinen Fall tun, denn der Befehl löscht die gesamte Festplatte. Es gilt als das Gefährlichste, was man in Linux tun kann. Mit rm initiert man das Löschen, die Parameter -f und -r stehen für force und rekursiv, und der unscheinbare / verweist auf das Hauptverzeichnis.

Fake Check

Bisweilen kommt es vor, dass man Speicher erstanden hat, die eine hohe Kapazität anzeigen, diese Kapazitäten aber nicht im Ansatz vorhanden sind. Es handelt sich um sogenannte Fake Geräte. Das Problem dieser Fake Geräte ist, dass die Daten, die auf das Gerät geschrieben werden, für die keine Kapazität mehr vorhanden ist, im Nirwana landen. Leider erhält man keine Fehlermeldung und bemerkt das Problem oft erst, wenn man zu einem späteren Zeitpunkt wieder auf die Daten zugreifen möchte.

Ein sehr unschöner Weg, wie man an FAKE‑Geräte kommt, ist ein Hack in Amazon. Damit der Versand zuverlässig und schnell vonstattengeht, bietet Amazon für seine Händler die Option an, die Waren im eigenen Logistikcenter zu deponieren. Händler, die diese Option nutzen, werden auch bevorzugt auf der Amazon Seite angezeigt. Das Problem ist nun, dass gleiche Produkte alle in die selbe Kiste kommen, was durchaus auch Sinn ergibt. Diesen Umstand nutzen Kriminelle schamlos aus und senden an Amazon ihre FAKE-Produkte. Im Nachhinein kann man dann nicht mehr zuordnen, wer der ursprüngliche Lieferant war.

Abonnement / Subscription

[English] This content is only available to subscribers.

[Deutsch] Diese Inhalte sind nur für Abonnenten verfügbar.

Network Attached Storage (NAS)

Ein weiteres Szenario für den Umgang mit Massenspeichern unter Linux sind sogenannte NAS‑Festplatten, die über ein Netzwerkkabel an den Router angeschlossen werden und dann allen Geräten wie Fernsehern etc. zur Verfügung stehen. Damit der Zugriff auf die Dateien nur für berechtigte Nutzer freigegeben wird, kann man ein Passwort festlegen. Günstige Lösungen für den Heimgebrauch gibt es zum Beispiel von Western Digital mit der Produktserie MyCloud. Nun wäre es eine sehr praktische Sache, wenn man die eigene NAS automatisch beim Bootvorgang auf seinem Linuxsystem anmeldet, sodass sie ohne weitere Anmeldung sofort benutzbar ist. Dazu muss man die URL des NAS z. B. aus der Gebrauchsanweisung oder über einen Netzwerkscan ermitteln. Hat man jetzt alle notwendigen Informationen wie URL / IP, Anmeldenamen und Passwort, kann man mit einem Eintrag in der Datei /etc/fstab das NAS registrieren. Die Datei fstab haben wir bereits im Abschnitt über die SWAP Datei kennengelernt.

Zuerst installieren wir für einen problemlosen Zugriff auf die für NAS Systeme üblichen Dateisysteme NFS Unterstützung für Linux.

Abonnement / Subscription

[English] This content is only available to subscribers.

[Deutsch] Diese Inhalte sind nur für Abonnenten verfügbar.

Im nächsten Schritt müssen wir eine Datei anlegen, die den automatischen Login ermöglicht. Diese Datei nennen wir nas-login und speichern sie unter /etc/nas-login. Der Inhalt dieser Datei sind unsere Login Informationen.

user=accountname
password=s3cr3t

Abschließend editieren wir die Datei fstab und fügen als letzte Zeile folgende Information hinzu:

Abonnement / Subscription

[English] This content is only available to subscribers.

[Deutsch] Diese Inhalte sind nur für Abonnenten verfügbar.

Das Beispiel ist für eine Western Digital MyCloud Platte, die über die URL //wdmycloud.local/account erreichbar ist. Account ist an den entsprechenden Benutzer anzupassen. Der Mountpoint unter Linux lautet /media/nas. In den meisten Fällen muss man dieses Verzeichnis vorher mit sudo mkdir /media/nas erstellen. In den Credentials tragen wir die Datei mit unseren Anmeldeinformationen /etc/nas-login ein. Nach einem Reboot wird der Nasspeicher im Dateibrowser angezeigt und kann verwendet werden. Je nach Netzwerkgeschwindigkeit kann das den Bootvorgang um ein paar Sekunden verlängern. Noch länger dauert es, wenn der Rechner nicht mit dem heimischen Netzwerk verbunden ist und das NAS nicht verfügbar ist. Man kann sich mit einem Raspberry Pi auch sein eigenes NAS bauen, das kann aber Stoff für einen zukünftigen Artikel sein.

Anschließend möchte ich noch ein paar Worte zum Service von Western Digital verlieren. Ich hatte bereits 2 Tauschgeräte, die jedes Mal problemlos durch WD ersetzt worden sind. Natürlich habe ich dem Service im Vorfeld meine Analysen per Screenshot übermittelt, wodurch unsachgemäßer Gebrauch durch mich ausgeschlossen werden konnte.
Die in diesem Artikel vorgestellten Techniken haben mir dabei sehr geholfen, weswegen ich überhaupt auf die Idee gekommen bin, diesen Text zu verfassen. Damit will ich es auch belassen und hoffe, euch leisten die hier zusammengetragenen Informationen ebenso hilfreiche Dienste wie mir.

Konferenzen

Grazer Linux Tage 2022

Elmar Dott Apr. 23, 2022 1 min read

Heimnetz ohne Werbung mit AdGuard auf dem RaspberryPI Leider ist von Minute 1:00 bis 2:10 kein Tonmitschnitt vorhanden 🙁 –…

Artikel

Professionelle Screenshots anfertigen

Neo Diseno Sep. 29, 2025

Artikel

Pfadfinder

Elmar Dott Okt. 13, 2025

Kryptografie – mehr als nur Zufall

Veröffentlicht am 2025-10-27 von Elmar Dott

Antworten

Im täglichen Sprachgebrauch benutzen wir das Wort Zufall recht unreflektiert. Sätze wie, „Ich bin zufällig hier vorbeigekommen.“ oder „Was für ein Zufall, dich hier zu treffen.“ kennt jeder von uns. Aber was möchten wir damit zum Ausdruck bringen? Eigentlich möchten wir damit sagen, dass wir die aktuelle Situation nicht erwartet haben.

Zufall ist eigentlich ein mathematischer Ausdruck, den wir in den täglichen Sprachgebrauch übernommen haben. Zufall meint etwas nicht Vorhersagbares. Also Dinge wie, an welcher Stelle sich zu einem exakten Moment ein beliebiges Elektron eines Atoms befindet. Welchen Weg ich zu einem bestimmten Ziel nehme, kann zwar beliebig sein, dennoch lassen sich über Wahrscheinlichkeiten Präferenzen ableiten, welche die Wahl dann durchaus vorhersagbar machen.

Umstände für ein solches Szenario können Entfernung, persönliche Befinden (Zeitdruck, Unwohlsein oder Langeweile) oder äußere Umstände (Wetter: Sonnenschein, Regen) sein. Habe ich Langeweile UND es scheint die Sonne, wähle ich für etwas Zerstreuung und Neugier eine unbekannte Strecke. Habe ich wenig Zeit UND es regnet, entscheide ich mich für den mir kürzesten bekannten Weg, oder eine Strecke, die möglichst überdacht ist. Daraus folgt: Je besser man die Gewohnheiten einer Person kennt, umso vorhersagbarer sind ihre Entscheidungen. Vorhersagbarkeit aber widerspricht dem Konzept Zufall.

Dass mathematische Begriffe, die sehr streng definiert sind, zeitweilig als Modeerscheinung in unseren täglichen Sprachgebrauch übernommen werden, ist keine neue Sache. Ein sehr populäres Beispiel, das bereits Joseph Weizenbaum angeführt hat, möchte ich hier kurz aufgreifen. Der Begriff Chaos. Eigentlich beschreibt Chaos im mathematischen, den Umstand, dass eine sehr kleine Änderung bei sehr langen Strecken das Ergebnis erheblich verfälscht, sodass es nicht einmal als Schätzung oder Näherung verwendet werden kann. Eine typische Anwendung ist die Astronomie. Richte ich einen Laserstrahl von der Erde auf den Mond, so verursacht bereits eine Abweichung im Winkel von wenigen Millimetern, dass der Laserstrahl kilometerweit am Mond vorbeigeht. Um solche Gegebenheiten populärwissenschaftlich einer breiten Masse zu erklären, verwendete man eine Assoziation, dass, wenn ein Schmetterling in Tokio mit den Flügeln schlägt, dies zu einem Sturm in Berlin führen kann. Leider gibt es nicht wenige Pseudowissenschaftler, die dieses Bild aufgreifen und ihrer Umwelt als Tatsache verkaufen. Das ist natürlich Unfug. Das Flügelschlagen eines Schmetterlings kann auf der anderen Seite des Globus keinen Sturm erzeugen. Denken wir nur daran, welche Auswirkungen das auf unsere Welt hätte, alleine die ganzen Vögel, die sich jeden Tag in die Luft schwingen.

„Warum ist die Ehe des Mathematikers gescheitert? Seine Frau war nicht berechenbar.“

Warum ist Zufall in der Mathematik aber eine so wichtige Sache? Im Konkreten geht es um das breite Thema Kryptografie. Wenn wir für die Verschlüsselung Kombinationen wählen, die man leicht erraten kann, ist der Schutz schnell dahin. Dazu ein kleines Beispiel.

Die Seiten des Internets sind statuslos. Das bedeutet, dass, nachdem eine Webseite aufgerufen wird und man auf einen Link klickt, um zur nächsten Seite zu gelangen, alle Informationen aus der vorangegangenen Seite verloren gegangen sind. Um dennoch Dinge wie in einem Onlineshop, einen Warenkorb und all die sonst noch notwendigen Funktionen zum Einkaufen bereitstellen zu können, gibt es die Möglichkeit, Daten auf dem Server in sogenannten Sessions zu speichern. Zu diesen Daten gehört oft auch das Login des Nutzers. Um die Sessions zu unterscheiden, haben diese eine Identifikation (ID). Der Programmierer legt nun fest, wie diese ID generiert wird. Eine Eigenschaft dieser IDs ist, dass sie eindeutig sein müssen, es darf also keine ID zweimal vorkommen.

Nun könnte man auf die Idee kommen, den Zeitstempel inklusive der Millisekunden zu nutzen, um daraus einen Hash zu generieren. Der Hash verhindert, dass man auf den ersten Blick erkennt, dass die ID aus einem Zeitstempel erstellt wird. Ein geduldiger Hacker hat dieses Geheimnis mit ein wenig Fleiß vergleichsweise schnell gelüftet. Hinzukommt noch die Wahrscheinlichkeit, dass zwei Nutzer zur gleichen Zeit eine Session erzeugen können, was zu einem Fehler führen würde.

Nun könnte man auf die Idee kommen, die SessionID aus verschiedenen Segmenten wie Zeitstempel + Benutzernamen und anderen Details zusammenzubauen. Obwohl steigende Komplexität einen gewissen Schutz bietet, ist dies keine wirkliche Sicherheit. Denn Profis haben Methoden mit überschaubarem Aufwand, diese ‚vermeidlichen‘ Geheimnisse zu erraten. Der einzig wirkliche Schutz ist die Verwendung von kryptografisch sicherem Zufall. Als ein Segment, das sich mit noch so viel Aufwand nicht erraten lässt.

Bevor ich aber verrate, wie wir dem Problem begegnen können, möchte ich den typischen Angriffsvektor und den damit erzeugten Schaden auf SessionIDs kurz besprechen. Wenn die SessionID durch einen Angreifer erraten wurde und diese Session noch aktiv ist, dann kann der Hacker diese Session in seinem Browser übernehmen. Das Ganze nennt sich Session Hijacking oder auch Session Riding. Der Angreifer, der eine aktive Session übernehmen konnte, ist als fremder Nutzer mit einem Profil, das ihm nicht gehört, bei einem Onlinedienst angemeldet. Damit kann er alle Aktionen durchführen, die ein legitimer Nutzer auch tun kann. Es wäre also möglich, in einem Onlineshop eine Bestellung auszulösen und die Ware an eine andere Adresse zu schicken. Ein Umstand, den es mit allen Mitteln zu verhindern gilt.

Nun gibt es verschiedene Strategien, die eingesetzt werden, um das Stehlen einer aktiven Session zu unterbinden. Jede einzelne dieser Strategien bietet schon einen ‚gewissen‘ Schutz, aber die volle Stärke wird erst durch die Kombination der verschiedenen Optionen erreicht, denn die Hacker rüsten ja auch stetig nach und suchen nach Möglichkeiten. Im Rahmen dieses kleinen Artikels betrachten wir ausschließlich den Aspekt, wie man eine kryptografisch sichere Session ID erzeugen kann.

So ziemlich alle gängigen Programmiersprachen haben eine Funktion random(), die eine zufällige Zahl erzeugt. Die Implementierung dieser Zufallszahl variiert. Leider sind diese generierten Zahlen für Angreifer gar nicht so zufällig, wie sie sein sollten. Deswegen gilt für Entwickler immer der Grundsatz, diese einfache Zufallsfunktion zu meiden. Stattdessen gibt es für Backendsprachen wie PHP und JAVA kryptografisch sichere Implementierungen für Zufallszahlen.

Für Java Programme kann man auf die Klasse java.security.SecureRandom zurückgreifen. Eine wichtige Funktion dieser Klasse ist die Möglichkeit, aus verschiedenen Kryptografie-Algorithmen [1] zu wählen. Zusätzlich lässt sich der Startwert über den sogenannten Seed. Um die Verwendung ein wenig zu demonstrieren, hier ein kleiner Codeausschnitt:

Abonnement / Subscription

[English] This content is only available to subscribers.

[Deutsch] Diese Inhalte sind nur für Abonnenten verfügbar.

Wir sehen, die Verwendung ist recht einfach und kann leicht angepasst werden. Für PHP ist es sogar noch einfacher, Zufall zu erzeugen. Dazu ruft man lediglich die Funktion random_int ( $min, $max ); [2] auf. Das Intervall kann optional angegeben werden.

Wir sehen also, dass die Annahme vieler Menschen, unsere Welt wäre in großen Teilen berechenbar, nicht ganz. Es gibt in vielen Bereichen der Naturwissenschaften Prozesse, die wir nicht berechnen können, Diese bilden dann wiederum die Grundlage, um ‚echten‘ Zufall zu erzeugen. Für Anwendungen, die einen sehr starken Schutz benötigen, greift man oft auf Hardware zurück. Das können etwa Geräte sein, die den radioaktiven Zerfall eines gering strahlenden Isotops messen.

Das Feld der Kryptografie und auch der Web-Application-Security sind natürlich noch viel umfangreicher. Dieser Artikel sollte mit einem recht einfachen Beispiel auf die Notwendigkeit dieser Thematik lenken. Dabei habe ich es vermieden, mit komplizierter Mathematik mögliche Interessenten zu verwirren und sie schlussendlich auch zu vergraulen.

Ressourcen

Abonnement / Subscription

[English] This content is only available to subscribers.

[Deutsch] Diese Inhalte sind nur für Abonnenten verfügbar.

Artikel

Das Neueste wird nicht immer das Beste sein

Elmar Dott Sep. 18, 2023 6 min read

Artikel

Kryptografie – mehr als nur Zufall

Elmar Dott Okt. 27, 2025

Konferenzen

Grazer Linux Tage 2022

Elmar Dott Apr. 23, 2022

Plattenspieler

Veröffentlicht am 2025-10-20 von Elmar Dott

Antworten

Der Umgang mit Massenspeichern wie Festplatten (HDD), Solid State Drive (SSD), USB, Speicherkarten oder Network Attached Storages (NAS) ist unter Linux gar nicht so schwer, wie viele glauben. Man muss es lediglich schaffen, alte Gewohnheiten, die man sich unter Windows angeeignet hat, wieder loszulassen. In diesem Kompaktkurs erfahren Sie alles Notwendige, um auf Linux Desktops und -Servern mögliche aufkommende Probleme zu meistern.

Bevor wir auch gleich in aller Tiefe in das Thema eintauchen, noch ein paar wichtige Fakten über die Hardware selbst. Hier gilt vor allem der Grundsatz: Wer billig kauft, kauft doppelt. Wobei das Problem nicht einmal das Gerät selbst ist, was man austauschen muss, sondern die möglicherweise verlorenen Daten und der Aufwand, alles wieder neu einzurichten. Diese Erfahrung habe ich vor allem bei SSDs und Speicherkarten gemacht, wo es durchaus einmal vorkommen kann, dass man einem Fake Produkt aufgesessen ist und der versprochene Speicherplatz nicht vorhanden ist, obwohl das Betriebssystem die volle Kapazität anzeigt. Wie man mit solchen Situationen umgeht, besprechen wir allerdings ein wenig später.

Ein weiterer wichtiger Punkt ist die Verwendung im Dauerbetrieb. Die meisten Speichermedien sind nicht dafür geeignet, 24 Stunden jeden Tag, 7 Tage die Woche eingeschaltet zu sein und verwendet zu werden. Festplatten und SSDs, die für Laptops gemacht worden sind, gehen bei einer Dauerbelastung zügig kaputt. Deswegen sollte man sich bei Dauerbetrieb, wie es bei NAS‑Systemen der Fall ist, explizit nach solchen speziellen Geräten umschauen. Die Firma Western Digital hat zum Beispiel verschiedene Produktlinien. Die Linie Red ist für Dauerbetrieb ausgelegt, wie es bei Servern und NAS der Fall ist. Wichtig ist, dass in der Regel die Datentransfergeschwindigkeit bei Speichermedien etwas geringer ist, wenn dafür die Lebensdauer erhöht wird. Aber keine Sorge, wir verlieren uns jetzt nicht in den ganzen Details, die man noch zum Thema Hardware sagen könnte, und wollen es dabei belassen, um zum nächsten Punkt zu gelangen.

Ein signifikanter Unterschied zwischen Linux und Windows ist das Dateisystem. Also der Mechanismus, wie das Betriebssystem den Zugriff auf die Informationen organisiert. Windows Nutzt als Dateisystem NTFS und USB Sticks oder Speicherkarten sind oft auch unter FAT formatiert. Der Unterschied ist, dass mit NTFS Dateien, die über 4 GB groß sind, gespeichert werden können. FAT wird der Stabilität eher von Geräteherstellern in Navigationssystemen oder Autoradios bevorzugt. Unter Linux sind vornehmlich die Dateisysteme ext3 oder ext4 anzutreffen. Natürlich gibt es noch viele Spezialformate, die wir aber an dieser Stelle nicht weiter besprechen wollen. Der große Unterschied zwischen Linux- und Windows Dateisystemen ist das Sicherheitskonzept. Während NTFS keinen Mechanismus hat, um das Erstellen, Öffnen oder Ausführen von Dateien und Verzeichnissen zu kontrollieren, ist dies für ext3 und ext4 ein grundlegendes Konzept.

Speicher, die in NTFS oder FAT formatiert sind, können problemlos an Linux Rechner angeschlossen werden und die Inhalte können gelesen werden. Um beim Schreiben von Daten auf Netzwerkspeicher, die wegen der Kompatibilität oft auf NTFS formatiert sind, keine Verluste zu riskieren, nutzt man das SAMBA Protokoll. Samba ist meist bereits Bestandteil vieler Linux Distributionen und kann in wenigen Augenblicken auch installiert werden. Es ist keine spezielle Konfiguration des Dienstes notwendig.

Nachdem wir nun gelernt haben, was ein Dateisystem ist und wozu diese notwendig sind, stellt sich nun die Frage, wie man einen externen Speicher unter Linux formatieren kann. Die beiden grafischen Programme Disks und Gparted sind hierzu ein gutes Gespann. Disks ist ein wenig universeller nutzbar und es lassen sich mit diesem Programm bootfähige USB Sticks erstellen, mit denen man anschließend Computer installieren kann. Gparted ist eher geeignet, bei Festplatten oder SSDs bestehende Partitionen zu erweitern oder kaputte Partitionen zu reparieren.

Bevor sie nun weiterlesen und sich gegebenenfalls daran machen, den ein oder anderen Tipp nachzustellen, ist es wichtig, dass ich an dieser Stelle einen Warnhinweis gebe. Bevor Sie irgendetwas mit Ihren Speichermedien ausprobieren, fertigen Sie zuallererst eine Datensicherung an, auf die Sie bei Unglücken zurückgreifen können. Zudem weise ich ausdrücklich darauf hin, sich nur an den Szenarien zu versuchen, die Sie verstehen und bei denen Sie wissen, was Sie tun. Für mögliche Datenverluste übernehme ich keine Haftung.

Eingebautes Backup in Linux mit rsync

Bootfähige USB & Speicherkarten mit DISKS

Ein Szenario, das wir gelegentlich benötigen, ist die Erstellung von bootfähigen Datenträgern. Ganz gleich, ob es ein USB‑Stick für die Installation eines Windows‑ oder Linux‑Betriebssystems oder das Installieren des Betriebssystems auf einer SD‑Karte für die Verwendung auf einem RaspberryPI ist: Das Vorgehen ist identisch. Bevor wir starten, benötigen wir ein Installationsmedium, das wir als ISO in der Regel von der Homepage des Betriebssystemherstellers herunterladen können, und einen zugehörigen USB‑Stick.

Als Nächstes öffnen wir das Programm Disks und wählen den USB Stick aus, auf den wir die ISO Datei installieren wollen. Danach klicken wir auf die drei Punkte im oberen Rahmen des Fensters und wählen aus dem erscheinenden Menü den Eintrag Restore Disk Image. In dem nun sich öffnenden Dialog wählen wir für das Eingabefeld Image to Restore unsere ISO Datei aus und klicken auf Start Restoring. Mehr ist nicht zu tun.

Partitionen und MTF mit Gparted reparieren

Ein anderes Szenario, mit dem man konfrontiert sein kann, ist das Daten auf einem Stick z. B. nicht lesbar sind. Wenn die Daten selbst nicht beschädigt sind, kann man Glück haben und mit GParted das Problem lösen. In einigen Fällen kann es sein, (A) dass die Partitionstabelle beschädigt ist und das Betriebssystem einfach nicht weiß, wo der Startpunkt ist. Eine andere Möglichkeit ist, (B) dass die sogenannte Master File Table (MFT) beschädigt ist. In der MTF ist der Vermerk, in welcher Speicherzelle eine Datei gefunden wird. Beide Probleme lassen sich mit GParted schnell wieder in Ordnung bringen.

Natürlich ist es nicht möglich, in einem allgemeinen Artikel auf die vielen komplexen Aspekte der Datenrettung einzugehen.

Nachdem wir nun wissen, dass eine Festplatte aus Partitionen besteht und diese Partitionen ein Dateisystem enthalten. Können wir jetzt sagen, dass alle Informationen zu einer Partition mit dem darauf formatierten Dateisystem in der Partitionstabelle gespeichert sind. Um alle Dateien und Verzeichnisse innerhalb einer Partition zu finden, bedient sich das Betriebssystem eines Index, in dem es nachschauen kann, die sogenannten Master File Table (MFT). Dieser Zusammenhang führt uns bereits zum nächsten Punkt, dem sicheren Löschen von Speichermedien.

Datenschredder – sicheres Löschen

Wenn wir Daten auf einem Speichermedium löschen, wird lediglich der Eintrag, wo die Datei zu finden ist aus der MFT entfernt. Die Datei ist also weiterhin vorhanden und kann von speziellen Programmen immer noch gefunden und ausgelesen werden. Das sichere Löschen von Dateien gelingt nur, wenn wir den freien Speicherplatz mehrfach überschreiben. Da wir nie wissen können, wo eine Datei physisch auf einem Speichermedium geschrieben wurde, müssen wir nach dem löschen den gesamten freien Speicherplatz mehrfach überschreiben. Spezialisten raten zu drei Schreibvorgängen, bei denen jeweils unterschiedliche Muster geschrieben werden, um selbst Speziallaboren eine Wiederherstellung unmöglich zu machen. Ein Programm unter Linux, mit dem man zusätzlich noch ‚Datenmüll‘ zusammenkehrt und löscht, ist BleachBit.

Das sichere Überschreiben von gelöschten Dateien ist je nach Größe des Speichermediums eine etwas länger andauernde Aktion, weswegen man dies nur sporadisch macht. Ganz sicher sollte man alte Speichermedien aber rückstandsfrei löschen, wenn diese ‚aussortiert‘ werden und dann entweder entsorgt oder an andere weitergegeben werden.

Ganze Festplatten 1:1 spiegeln – CloneZilla

Ein weiteres Szenario, mit dem wir konfrontiert werden können, ist die Notwendigkeit, eine Kopie der Festplatte anzufertigen. Das ist dann relevant, wenn für den aktuellen Computer die bestehende Festplatte bzw. SSD gegen eine neue mit höherer Speicherkapazität ausgetauscht werden soll. Windowsnutzer nutzen hier oft die Gelegenheit, ihr System neu zu installieren, um in Übung zu bleiben. Wer bereits länger mit Linux arbeitet, weiß es zu schätzen, dass Linux-Systeme sehr stabil laufen und die Notwendigkeit einer Neuinstallation nur sporadisch besteht. Daher bietet es sich an die Daten der aktuellen Festplatte bitweise auf die neue Platte zu kopieren. Das gilt natürlich auch für SSDs beziehungsweise von HDD zu SSD und umgekehrt. Dieses Vorhaben gelingt uns mit dem freien Werkzeug CloneZilla. Dazu erstellen wir einen bootfähigen USB mit CloneZilla und starten den Rechner im Livesystem von CloneZilla. Danach schließen wir die neue Platte mit einem SATA / USB Adapter an den Rechner an und starten die Datenübertragung. Bevor wir nach Fertigstellung unseren Computer aufschrauben und die Platten tauschen, ändern wir im BIOS die boot Reihenfolge und schauen, ob unser Vorhaben überhaupt geglückt ist. Nur wenn sich der Rechner über die neue Platte problemlos starten lässt, machen wir uns an den physischen Austausch. Diese kleine Anleitung beschreibt das prinzipielle Vorgehen und ich habe bewusst auf eine detaillierte Beschreibung verzichtet, da sich die Oberfläche und Bedienung von neueren Clonezilla-Versionen unterscheiden kann.

SWAP – die Auslagerungsdatei unter Linux

An dieser Stelle verlassen wir auch nun die grafische Benutzeroberfläche und wenden uns der Kommandozeile zu. Wir kümmern uns um eine sehr spezielle Partition, die manchmal erweitert werden muss. Es geht um die SWAP File. Die SWAP File ist das, was bei Windows Auslagerungsdatei heißt. Das heißt, hier schreibt das Betriebssystem Daten hin, die nicht mehr in den RAM passen, und kann bei Bedarf diese Daten schneller wieder in den RAM einlesen. Indessen kann es vorkommen, dass diese Auslagerungsdatei zu klein ist und erweitert werden muss. Aber auch das ist kein Hexenwerk, wie wir gleich sehen werden.

Abonnement / Subscription

[English] This content is only available to subscribers.

[Deutsch] Diese Inhalte sind nur für Abonnenten verfügbar.

Wir haben an dieser Stelle bereits einiges über den Umgang mit Speichermedien unter Linux besprochen. Im zweiten Teil dieser Artikelserie vertiefen wir die Möglichkeiten von Kommandozeilenprogrammen und schauen zum Beispiel, wie NAS-Speicher permanent in das System gemountet werden können. Aber auch Strategien, um defekte Speicher zu identifizieren, werden Thema des nächsten Teils werden. Insofern hoffe ich, euer Interesse geweckt zu haben, und würde mich über ein reichliches Teilen der Artikel von diesem Block freuen.

Artikel

PHP Elegant Testing in Laravel

Elmar Dott Okt. 6, 2025 12 min read

Automatisierte Unit Tests mit PEST in PHP und dem Lavarel Framework für eigene Webanwendungen nutzen. Weiterlesen →

Konferenzen

Chemnitzer Linux Tage 2022

Elmar Dott Juni 8, 2022

Artikel

Plattenspieler II

Elmar Dott Nov. 3, 2025

Pfadfinder

Veröffentlicht am 2025-10-13 von Elmar Dott

Antworten

Damit wir Konsolenprogramme systemweit direkt aufrufen können, ohne dass wir dazu den vollständigen Pfad angeben müssen, bedienen wir uns der sogenannten Pfadvariable. Wir speichern also in dieser Pfadvariable den gesamten Pfad inklusive des ausführbaren Programmes, der sogenannten Executable, um auf der Kommandozeile den Pfad inklusive der Executable nicht mehr mit angeben zu müssen. Übrigens leitet sich aus dem Wort executable die in Windows übliche Dateierweiterung exe ab. Hier haben wir auch einen signifikanten Unterschied zwischen den beiden Betriebssystemen Windows und Linux. Während Windows über die Dateiendung wie beispielsweise exe oder txt weiß, ob es sich um eine reine ASCII Textdatei oder um eine ausführbare Datei handelt, nutzt Linux die Metainformationen der Datei, um diese Unterscheidung zu machen. Deswegen ist es unter Linux eher unüblich, diese Dateiendungen txt und exe zu verwenden.

Typische Anwendungsfälle für das Setzen der Pfadvariable sind Programmiersprachen wie Java oder Werkzeuge wie das Buildwerkzeug Maven. Wenn wir zum Beispiel Maven von der offiziellen Homepage heruntergeladen haben, können wir das Programm an einer beliebigen Stelle auf unserem System entpacken. Unter Linux könnte der Ort /opt/maven und unter Microsoft Windows C:/Programme/Maven lauten. In diesem Installationsverzeichnis gibt es wiederum ein Unterverzeichnis /bin in dem die ausführbaren Programme liegen. Die Executable für Maven heißt mvn und um etwa die Version auszugeben, wäre unter Linux ohne den Eintrag in der Pfadvariablen das Kommando wie folgt: /opt/maven/bin/mvn -v. Also ein wenig lang, wie wir durchaus zugeben können. Der Eintrag des Installationsverzeichnisses von Maven in den Pfad verkürzt den gesamten Befehl auf mvn -v. Dieser Mechanismus gilt übrigens für alle Programme, die wir als Befehl in der Konsole verwenden.

Bevor ich dazu komme, wie die Pfadvariable unter Linux, als auch unter Windows angepasst werden kann, möchte ich noch ein weiteres Konzept, die Systemvariable, vorstellen. Systemvariablen sind globale Variablen, die uns in der Bash zur Verfügung stehen. Die Pfadvariable zählt auch als Systemvariable. Eine andere Systemvariable ist HOME, welche auf das Stammverzeichnis des angemeldeten Benutzers zeigt. Systemvariablen werden großgeschrieben und die Wörter mit einem Unterstrich getrennt. Für unser Beispiel mit dem Eintragen der Maven Executable in den Pfad, können wir auch eine eigene Systemvariable setzen. Hier gibt es für Maven die Konvention M2_HOME und für Java gilt JAVA_HOME. Als best practice bindet man das Installationsverzeichnis an eine Systemvariable und nutzt dann die selbst definierte Systemvariable, um den Pfad zu erweitern. Dieses Vorgehen ist recht typisch für Systemadministratoren, die ihre Serverinstallation mithilfe von Systemvariablen vereinfachen. Denn diese Systemvariablen sind global und können von Automatisierungsskripten auch ausgelesen werden.

Die Kommandozeile, oder auch Shell, Bash, Konsole und Terminal genannt, bietet mit echo eine einfache Möglichkeit, den Wert der Systemvariablen auszugeben. Am Beispiel der Pfadvariable sehen wir auch gleich den Unterschied zu Linux und Windows. Linux: echo $PATH Windows: echo %PATH%

ed@local:~$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/snap/bin:/home/ed/Programs/maven/bin:/home/ed/.local/share/gem//bin:/home/ed/.local/bin:/usr/share/openjfx/lib

ed@local:~$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/snap/bin:/home/ed/Programs/maven/bin:/home/ed/.local/share/gem//bin:/home/ed/.local/bin:/usr/share/openjfx/lib

Beginnen wir auch nun gleich mit der einfachsten Möglichkeit, die Pfadvariable zu setzen. Unter Linux müssen wir lediglich die versteckte Datei .bashrc editieren. Am Ende der Datei fügen wir folgende Zeilen hinzu und speichern den Inhalt.

export M2_HOME="/opt/maven"
export PATH=$PATH:$M2_HOME/bin

Wir binden an die Variable M2_HOME das Installationsverzeichnis. Anschließend erweitern wir die Pfadvariable um um die M2_HOME Systemvariable mit dem Zusatz zum Unterverzeichnis der ausführbaren Dateien. Dieses Vorgehen ist auch bei Windows Systemen üblich, da sich so der Installationspfad einer Anwendung schneller finden und auch anpassen lässt. Nach dem Ändern der Datei .bashrc muss das Terminal neu gestartet werden, damit die Änderungen wirksam werden. Dieses Vorgehen stellt sicher, dass auch nach einem Neustart des Rechners die Einträge nicht verloren gehen.

Unter Windows besteht die Herausforderung darin, lediglich die Eingabemaske zu finden, wo die Systemvariablen gesetzt werden können. In diesem Artikel beschränke ich mich auf die Variante für Windows 11. Es kann natürlich sein, dass sich bei einem künftigen Update der Weg, die Systemvariablen zu editieren, geändert hat. Zwischen den einzelnen Windows Versionen gibt es leichte Variationen. Die Einstellung gilt dann sowohl für die CMD als auch für die PowerShell. Der nachfolgende Screenshot zeigt, wie man in Windows 11 zu den Systemeinstellungen gelangt.

Dazu klicken wir auf einen leeren Bereich auf dem Desktop die rechte Maustaste und wählen den Eintrag System aus. Im Untermenü System – Über finden sich die Systemeinstellungen, die das Popup Systemproperties öffnen. In den Systemeinstellungen drücken wir den Knopf Umgebungsvariablen, um die finale Eingabemaske zu erhalten. Nach den entsprechenden Anpassungen muss ebenfalls die Konsole neu gestartet werden, um die Änderungen wirksam werden zu lassen.

In dieser kleinen Hilfe haben wir den Zweck von Systemvariablen kennengelernt und wie man diese dauerhaft unter Linux und Windows speichert. Den Erfolg unserer Anstrengungen können wir in der Shell anschließend zügig über echo mit der Ausgabe des Inhalts der Variablen kontrollieren. Und schon sind wir dem IT-Profi wieder einen Schritt nähergekommen.

Konferenzen