23 Fragen zu Unix

Zu den effektivsten Packprogrammen (Komprimierungsprogrammen) unter Unix zählen: 1. **xz** Sehr hohe Kompressionsrate, besonders für große Dateien. Befehl: `xz datei` 2. **zstd (Zstandard)** Sehr schnell und bietet eine gute Kompressionsrate. Befehl: `zstd datei` 3. **gzip** Weit verbreitet, schnell, aber etwas geringere Kompression als xz oder zstd. Befehl: `gzip datei` 4. **bzip2** Bessere Kompression als gzip, aber langsamer. Befehl: `bzip2 datei` **Empfehlung:** Für die beste Kompressionsrate: **xz** Für ein gutes Verhältnis aus Geschwindigkeit und Kompression: **zstd** Weitere Infos: - [xz](https://tukaani.org/xz/) - [zstd](https://facebook.github.io/zstd/) - [gzip](https://www.gnu.org/software/gzip/) - [bzip2](https://sourceware.org/bzip2/) Die Wahl hängt vom Einsatzzweck ab: Geschwindigkeit, Kompressionsrate oder Kompatibilität.

Das "Loopback"-Device (oft als "loop" bezeichnet) ist eine Methode unter Unix/Linux, um eine Datei als Blockgerät zu behandeln, sodass sie wie ein echtes Gerät (z.B. eine Festplattenpartition) gemountet werden kann. Das wird häufig beim Einsatz von verschlüsselten Dateisystemen genutzt, etwa mit **cryptsetup** oder **losetup**. Wenn du nach einer Alternative zum klassischen "loop"-Device für verschlüsselte Dateisysteme suchst, gibt es mehrere Möglichkeiten: 1. **Direktes Blockgerät** Anstatt eine Datei als Loopback-Device zu verwenden, kannst du direkt eine Partition oder ein physisches Blockgerät (z.B. `/dev/sdb1`) für die Verschlüsselung nutzen. Beispiel: ``` cryptsetup luksFormat /dev/sdb1 cryptsetup open /dev/sdb1 mycrypt mkfs.ext4 /dev/mapper/mycrypt ``` 2. **Device Mapper (dm-crypt)** Moderne Verschlüsselungslösungen wie **dm-crypt** (genutzt von cryptsetup/LUKS) arbeiten direkt mit Blockgeräten und benötigen kein Loopback-Device, sofern du keine Datei als Container nutzt. 3. **Dateibasierte Container ohne Loopback** Einige Tools (z.B. **TrueCrypt**, **VeraCrypt**) können verschlüsselte Containerdateien auch ohne explizites Anlegen eines Loopback-Devices einbinden, indem sie intern den Zugriff regeln. 4. **FUSE-basierte Lösungen** Tools wie **EncFS** oder **gocryptfs** arbeiten auf Dateiebene und benötigen kein Loopback-Device, da sie das Dateisystem im Userspace (über FUSE) bereitstellen. - [EncFS](https://vgough.github.io/encfs/) - [gocryptfs](https://github.com/rfjakob/gocryptfs) **Fazit:** Du brauchst das Loopback-Device nur, wenn du eine Datei als Blockgerät mounten willst. Wenn du direkt mit Partitionen, physischen Geräten oder FUSE-basierten Lösungen arbeitest, ist das "loop"-Device nicht notwendig.

Das klassische Unix-Tool zum Verschlüsseln von Text auf der Konsole heißt `crypt`. Es ist ein Kommandozeilenprogramm, das in älteren Unix-Systemen verfügbar war. Die grundlegende Verwendung sieht so aus: ```bash crypt <passwort> <eingabedatei >ausgabedatei ``` Beispiel: ```bash crypt meinpasswort < klartext.txt > verschluesselt.txt ``` **Hinweis:** - Das `crypt`-Programm gilt heute als unsicher und wird auf modernen Unix- und Linux-Systemen meist nicht mehr mitgeliefert. - Für sichere Verschlüsselung empfiehlt sich stattdessen z.B. [GnuPG (gpg)](https://gnupg.org/) oder [OpenSSL](https://www.openssl.org/). Weitere Informationen zu `crypt` findest du z.B. in der [man page von crypt](https://man7.org/linux/man-pages/man1/crypt.1.html).

Um eine Funktion aus einer Unix-Bibliothek (z. B. einer Shared Library wie `libm.so` oder `libc.so`) direkt in der Shell auszuführen, gibt es keinen direkten Befehl, da Shells wie Bash keine Funktionen aus Shared Libraries direkt aufrufen können. Es gibt aber einige Möglichkeiten, dies zu erreichen: **1. Mit einem kleinen C-Programm:** Schreibe ein kurzes C-Programm, das die gewünschte Funktion aufruft, kompiliere es und führe es aus. Beispiel für die Funktion `cos` aus `libm.so`: ```c // datei: call_cos.c #include <stdio.h> #include <math.h> int main() { double x = 0.0; printf("%f\n", cos(x)); return 0; } ``` Kompilieren und ausführen: ```sh gcc -o call_cos call_cos.c -lm ./call_cos ``` **2. Mit dem Tool `nm` oder `objdump`:** Diese Tools zeigen dir, welche Funktionen in einer Bibliothek enthalten sind, aber sie führen sie nicht aus. **3. Mit `python` oder `perl` und `ctypes`/`FFI`:** Du kannst aus der Shell heraus ein Skript starten, das per FFI (Foreign Function Interface) eine Bibliotheksfunktion aufruft. Beispiel mit Python: ```sh python3 -c "import ctypes; print(ctypes.CDLL('libm.so.6').cos(0.0))" ``` **4. Mit `dlcall` (falls installiert):** Manche Systeme bieten Tools wie [`dlcall`](https://github.com/raffael87/dlcall), mit denen du direkt aus der Shell Funktionen aus Shared Libraries aufrufen kannst. **Fazit:** Direkt aus der Shell geht es nicht, aber mit einem kleinen Hilfsprogramm oder Skript kannst du jede Funktion aus einer Unix-Bibliothek aufrufen.

Pages ist eine Textverarbeitungssoftware von Apple und Teil der iWork-Suite. Sie ist offiziell nur für macOS und iOS verfügbar und kann nicht direkt für Unix- oder Linux-Systeme heruntergeladen werden. Es gibt keine offizielle Unix-Version von Pages. Falls du nach einer Alternative für Unix/Linux suchst, bieten sich Programme wie [LibreOffice Writer](https://www.libreoffice.org/) oder [OnlyOffice](https://www.onlyoffice.com/) an, die ähnliche Funktionen wie Pages bereitstellen. Eine direkte Downloadmöglichkeit für Pages auf Unix existiert nicht.

Um mit der Standardbibliothek **libcrypt** unter Unix eine Datei zu verschlüsseln, ist es wichtig zu wissen, dass **libcrypt** traditionell für das Hashen von Passwörtern (z. B. mit `crypt()`) verwendet wird, nicht für die Verschlüsselung von Dateien. Sie bietet keine Funktionen zur symmetrischen oder asymmetrischen Dateiverschlüsselung, sondern dient der Passwort-Hash-Erzeugung. **Funktionsnamen und Parameter von libcrypt:** - Die zentrale Funktion ist: ```c char *crypt(const char *key, const char *salt); ``` - **key**: Das zu hashende Passwort. - **salt**: Der Salt-Wert, der das Hash-Verfahren und die Zufälligkeit bestimmt. **Dateiverschlüsselung:** - Für die Verschlüsselung von Dateien werden üblicherweise andere Bibliotheken wie [OpenSSL](https://www.openssl.org/) (z. B. mit `EVP_EncryptInit`, `EVP_EncryptUpdate`, `EVP_EncryptFinal`) oder [libgcrypt](https://gnupg.org/software/libgcrypt/index.html) verwendet. - Mit **libcrypt** kannst du keine Datei verschlüsseln, sondern nur Passwörter hashen. **Wie findest du Funktionsnamen und Parameter?** - Lies die Manpages: ```bash man 3 crypt ``` - Sieh dir die Header-Datei an: ```c #include <crypt.h> ``` - Dokumentation online: [crypt(3) – Linux man page](https://man7.org/linux/man-pages/man3/crypt.3.html) **Fazit:** Mit **libcrypt** kannst du keine Datei verschlüsseln. Für Dateiverschlüsselung nutze spezialisierte Bibliotheken wie OpenSSL oder libgcrypt. Die Funktionsnamen und Parameter findest du in den jeweiligen Manpages oder der offiziellen Dokumentation.

Für den Unix-Kernel 2.16 (vermutlich meinst du Linux-Kernel 2.6.x, da 2.16 nicht existiert) gibt es einige native Crypto-Dateisysteme, die direkt im Kernel oder als Kernel-Module unterstützt werden und eigene Tools wie `mkfs` (zum Erstellen) und `fsck` (zum Prüfen) bereitstellen. Hier sind die wichtigsten: 1. **eCryptfs** - **Beschreibung:** Stacking-Kryptofilesystem, das auf bestehenden Dateisystemen aufsetzt. - **Tools:** Kein eigenes `mkfs` oder `fsck`, da es ein Overlay ist. - **Link:** [eCryptfs](https://wiki.archlinux.org/title/eCryptfs) 2. **dm-crypt/LUKS** - **Beschreibung:** Blockbasierte Verschlüsselung, meist mit LUKS als Management-Layer. - **Tools:** - `cryptsetup` (zum Einrichten und Verwalten) - Danach wird ein normales Dateisystem (z.B. ext3, ext4, xfs) mit `mkfs` und `fsck` verwendet. - **Link:** [cryptsetup/LUKS](https://gitlab.com/cryptsetup/cryptsetup) 3. **EncFS** - **Beschreibung:** FUSE-basiertes verschlüsseltes Dateisystem. - **Tools:** Kein eigenes `mkfs` oder `fsck`, da es FUSE nutzt. - **Link:** [EncFS](https://vgough.github.io/encfs/) 4. **reiser4 mit Verschlüsselung** - **Beschreibung:** Reiser4 unterstützt optionale Verschlüsselung (experimentell). - **Tools:** - `mkfs.reiser4` - `fsck.reiser4` - **Link:** [Reiser4](https://reiser4.wiki.kernel.org/index.php/Main_Page) 5. **ZFS mit nativer Verschlüsselung** - **Beschreibung:** ZFS unterstützt seit Version 0.8 native Verschlüsselung, aber das ist erst ab neueren Kernel-Versionen stabil. - **Tools:** - `zpool`, `zfs` (zum Erstellen und Prüfen) - **Link:** [OpenZFS](https://openzfs.org/) **Fazit:** Für Kernel 2.6.x ist **dm-crypt/LUKS** die am weitesten verbreitete und unterstützte Lösung, wobei die Verschlüsselung auf Blockebene erfolgt und du danach ein beliebiges Dateisystem mit den gewohnten Tools (`mkfs`, `fsck`) nutzen kannst. Ein echtes, rein dateibasiertes Crypto-Dateisystem mit nativen `mkfs`/`fsck`-Tools ist selten; Reiser4 mit Verschlüsselung ist eine der wenigen Ausnahmen, aber experimentell. **Hinweis:** Die meisten Crypto-Dateisysteme für Linux sind entweder als Overlay (eCryptfs, EncFS) oder als Blockverschlüsselung (dm-crypt/LUKS) implementiert. Ein "klassisches" Dateisystem mit nativer Verschlüsselung und eigenen `mkfs`/`fsck`-Tools ist selten. Weitere Infos zu den genannten Projekten findest du auf den verlinkten Seiten.

Das Reiser4-Dateisystem unterstützt von Haus aus keine integrierte Verschlüsselung wie beispielsweise das moderne ext4 mit fscrypt. Um Verschlüsselung mit Reiser4 unter Unix/Linux zu nutzen, gibt es zwei gängige Ansätze: **1. Verschlüsselung auf Blockgeräte-Ebene (empfohlen):** Hierbei wird das gesamte Dateisystem in einem verschlüsselten Container betrieben. Typische Tools sind: - **LUKS/dm-crypt:** - Erstelle eine Partition oder ein Image. - Verschlüssele diese mit `cryptsetup luksFormat`. - Öffne das verschlüsselte Laufwerk mit `cryptsetup open`. - Erstelle darauf das Reiser4-Dateisystem mit `mkfs.reiser4`. - Binde das Dateisystem wie gewohnt ein. Weitere Infos: [cryptsetup/LUKS](https://gitlab.com/cryptsetup/cryptsetup) **2. Verschlüsselung auf Dateisystem-Ebene:** Reiser4 bietet experimentelle Plugins für Verschlüsselung, die aber als instabil und nicht für produktive Nutzung empfohlen gelten. Die Konfiguration ist komplex und setzt voraus, dass Reiser4 mit entsprechenden Plugins kompiliert wurde. Mehr dazu: [Reiser4 Plugins](https://reiser4.wiki.kernel.org/index.php/Plugins) **Fazit:** Für den produktiven Einsatz empfiehlt sich die Verschlüsselung auf Blockgeräte-Ebene (z.B. mit LUKS/dm-crypt). Die Nutzung von Reiser4-eigenen Verschlüsselungsplugins ist experimentell und nicht weit verbreitet. **Hinweis:** Reiser4 ist ein experimentelles Dateisystem und wird von den meisten Linux-Distributionen nicht offiziell unterstützt. Für neue Projekte empfiehlt sich die Nutzung von ext4, Btrfs oder XFS mit etablierten Verschlüsselungslösungen.

Unter Unix-ähnlichen Betriebssystemen (wie Linux) wird das NTFS-Dateisystem in der Regel über das Open-Source-Projekt **NTFS-3G** eingebunden. Die native Verschlüsselung von NTFS, wie sie unter Windows mit EFS (Encrypting File System) ab Windows 2000 verfügbar ist, wird von NTFS-3G **nicht unterstützt**. Das bedeutet: - **NTFS-Verschlüsselung (EFS) ist unter Unix/Linux nicht möglich**, unabhängig von der NTFS-Version. - NTFS-3G kann verschlüsselte Dateien lesen, aber nicht entschlüsseln oder neue verschlüsselte Dateien anlegen. - Die NTFS-Verschlüsselung ist ein Feature von Windows und wird von Unix-Treibern nicht implementiert. **Fazit:** Unter Unix gibt es **keine NTFS-Version**, die Verschlüsselung direkt unterstützt. Wenn Verschlüsselung unter Unix benötigt wird, solltest du auf andere Lösungen wie LUKS, eCryptfs oder VeraCrypt zurückgreifen. Weitere Infos: - [NTFS-3G Projektseite](https://www.tuxera.com/community/open-source-ntfs-3g/) - [NTFS-Verschlüsselung (Wikipedia)](https://de.wikipedia.org/wiki/Encrypting_File_System)

Um in der Unix-Konsole Speicher freizugeben, gibt es verschiedene Ansätze, je nachdem, was genau gemeint ist: **1. Arbeitsspeicher (RAM) freigeben:** - RAM wird normalerweise vom Betriebssystem automatisch verwaltet. Du kannst aber Prozesse beenden, die viel Speicher verbrauchen: ```bash top ``` oder ```bash htop ``` Mit diesen Tools siehst du speicherintensive Prozesse und kannst sie mit `kill <PID>` beenden. - Um den Cache-Speicher (Page Cache, dentries, inodes) zu leeren (nur mit Root-Rechten): ```bash sudo sync; sudo sysctl -w vm.drop_caches=3 ``` **Achtung:** Das ist meist nicht nötig und sollte mit Bedacht eingesetzt werden. **2. Festplattenspeicher freigeben:** - Nicht mehr benötigte Dateien löschen: ```bash rm dateiname ``` - Leere den Papierkorb (je nach Desktop-Umgebung). - Temporäre Dateien löschen: ```bash sudo rm -rf /tmp/* ``` - Paket-Cache leeren (z.B. bei Debian/Ubuntu): ```bash sudo apt-get clean ``` **3. Swap-Speicher leeren:** - Swap deaktivieren und wieder aktivieren (Root-Rechte nötig): ```bash sudo swapoff -a sudo swapon -a ``` **Hinweis:** Das manuelle Freigeben von RAM ist in der Regel nicht notwendig, da das Betriebssystem dies effizient selbst erledigt. Festplattenspeicher kannst du durch Löschen nicht benötigter Dateien freigeben. Weitere Informationen findest du z.B. auf [ubuntuusers.de](https://wiki.ubuntuusers.de/Speicher_freigeben/).

eCryptfs ist ein kryptografisches Dateisystem für Unix-ähnliche Betriebssysteme, das häufig für die Verschlüsselung von Home-Verzeichnissen verwendet wird. Im Laufe der Zeit wurden verschiedene Schwachstellen in eCryptfs entdeckt. Hier sind einige wichtige Punkte: 1. **CVE-2016-1573**: Eine der bekanntesten Schwachstellen betrifft die Art und Weise, wie eCryptfs mit Dateinamen umgeht. Angreifer konnten durch speziell präparierte Dateinamen einen Pufferüberlauf auslösen, was zu einem Denial-of-Service oder potenziell zur Ausführung von Schadcode führen konnte. [NVD-Eintrag zu CVE-2016-1573](https://nvd.nist.gov/vuln/detail/CVE-2016-1573) 2. **Schwache Passphrasen**: Die Sicherheit von eCryptfs hängt stark von der verwendeten Passphrase ab. Schwache oder wiederverwendete Passwörter können leicht durch Brute-Force-Angriffe kompromittiert werden. 3. **Key-Handling und Speicher**: In älteren Versionen wurden Schlüssel manchmal nicht sicher aus dem Speicher entfernt, was ein Risiko darstellt, falls ein Angreifer physischen Zugriff auf das System erhält. 4. **Veraltete Entwicklung**: Die Entwicklung von eCryptfs ist weitgehend eingestellt. Es werden nur noch selten Sicherheitsupdates veröffentlicht, was das Risiko erhöht, dass neue Schwachstellen nicht behoben werden. 5. **Metadaten-Leaks**: eCryptfs verschlüsselt zwar Dateiinhalte, aber nicht unbedingt alle Metadaten (z.B. Dateigröße, Zugriffszeiten, Verzeichnisstruktur). Ein Angreifer kann daraus Rückschlüsse auf die gespeicherten Daten ziehen. **Empfehlung:** Für neue Systeme wird oft empfohlen, auf modernere Lösungen wie [fscrypt](https://github.com/google/fscrypt) (für ext4 und f2fs) oder [LUKS/dm-crypt](https://gitlab.com/cryptsetup/cryptsetup) umzusteigen, da diese aktiver gepflegt werden und als sicherer gelten. Für detaillierte Informationen zu aktuellen Schwachstellen empfiehlt sich ein Blick in die [CVE-Datenbank](https://cve.mitre.org/) oder die [Sicherheitsmeldungen der Linux-Distributionen](https://security-tracker.debian.org/tracker/source-package/ecryptfs-utils).

eCryptfs (Enterprise Cryptographic Filesystem) ist ein kryptografisches Dateisystem für Unix-ähnliche Betriebssysteme, das häufig für die Verschlüsselung von Home-Verzeichnissen unter Linux verwendet wurde. Es gibt einige bekannte Schwachstellen und Einschränkungen im Zusammenhang mit eCryptfs: 1. **Veraltete Entwicklung**: eCryptfs wird seit mehreren Jahren nicht mehr aktiv weiterentwickelt. Das bedeutet, dass neu entdeckte Schwachstellen möglicherweise nicht mehr behoben werden. 2. **CVE-2018-6594**: Eine bekannte Schwachstelle ist [CVE-2018-6594](https://nvd.nist.gov/vuln/detail/CVE-2018-6594). Hierbei handelt es sich um eine Race Condition, die es einem lokalen Angreifer ermöglichen kann, Root-Rechte zu erlangen, indem er Symlinks in einem eCryptfs-Mount manipuliert. 3. **Schwache Standardkonfigurationen**: In älteren Distributionen wurden teilweise schwache Verschlüsselungsalgorithmen oder kurze Schlüssel verwendet, was die Sicherheit beeinträchtigen kann. 4. **Metadaten nicht verschlüsselt**: eCryptfs verschlüsselt nur die Dateiinhalte, nicht aber die Dateinamen oder andere Metadaten. Ein Angreifer kann also weiterhin sehen, welche Dateien existieren und wie groß sie sind. 5. **Performance-Probleme**: Durch die Art der Verschlüsselung kann es zu Performance-Einbußen kommen, was bei großen Datenmengen oder vielen kleinen Dateien problematisch sein kann. 6. **Alternativen empfohlen**: Aufgrund der genannten Schwächen und der fehlenden Weiterentwicklung wird heute meist [fscrypt](https://github.com/google/fscrypt) oder [LUKS/dm-crypt](https://gitlab.com/cryptsetup/cryptsetup) empfohlen. **Fazit:** eCryptfs weist mehrere Schwachstellen auf, insbesondere durch fehlende Weiterentwicklung und bekannte Sicherheitslücken wie CVE-2018-6594. Für neue Systeme sollte auf modernere und aktiv gepflegte Verschlüsselungslösungen ausgewichen werden.

Um eine Datei unter Unix (bzw. Linux) mit Kernel-Modulen zu verschlüsseln, ohne zusätzliche Programme zu installieren, kannst du die im Kernel integrierten Crypto-APIs und Dateisysteme nutzen. Am gebräuchlichsten ist das Kernel-Modul **dm-crypt** in Verbindung mit **cryptsetup** und dem **Device Mapper**. Allerdings ist cryptsetup meist ein Zusatzprogramm, aber das Kernel-Modul selbst ist oft schon vorhanden. Eine Möglichkeit, ohne zusätzliche Programme und nur mit Bordmitteln zu arbeiten, ist die Nutzung von **eCryptfs** oder **fscrypt** (bei ext4), sofern diese im Kernel aktiviert und im System vorhanden sind. Diese bieten transparente Verschlüsselung auf Dateisystemebene. **Beispiel mit eCryptfs (falls im Kernel und System vorhanden):** 1. **Mounten eines verschlüsselten Verzeichnisses:** ```bash mkdir /home/user/private mkdir /home/user/secure sudo mount -t ecryptfs /home/user/private /home/user/secure ``` Du wirst nach einem Passwort und nach Verschlüsselungsoptionen gefragt. 2. **Dateien verschlüsseln:** Kopiere oder verschiebe Dateien nach `/home/user/secure`. Sie werden automatisch verschlüsselt im Backend-Verzeichnis `/home/user/private` abgelegt. 3. **Unmounten:** ```bash sudo umount /home/user/secure ``` **Wichtige Hinweise:** - eCryptfs ist auf vielen modernen Distributionen veraltet oder nicht mehr standardmäßig installiert. - Ohne Zusatzprogramme ist die Nutzung von Kernel-Krypto-Modulen meist auf das Einbinden von verschlüsselten Dateisystemen beschränkt. - Die eigentliche Verschlüsselung erfolgt transparent durch das Kernel-Modul, aber ein gewisses Setup (z.B. mount) ist immer nötig. **Alternative:** Mit dem Kernel-Modul **loop** und dem Device Mapper kannst du ein verschlüsseltes Loopback-Device anlegen, aber auch hier ist meist ein Hilfsprogramm wie `cryptsetup` oder `losetup` nötig. **Fazit:** Ohne jegliche Zusatzprogramme ist die Verschlüsselung einzelner Dateien nur mit Kernel-Modulen schwierig und meist nicht vorgesehen. Die Kernel-Module stellen die Funktionalität bereit, aber das Handling (z.B. Mounten, Schlüsselmanagement) erfolgt in der Regel über Userland-Tools. **Weitere Infos:** - [eCryptfs](https://wiki.ubuntu.com/eCryptfs) - [dm-crypt](https://wiki.archlinux.org/title/Dm-crypt) - [fscrypt](https://www.kernel.org/doc/html/latest/filesystems/fscrypt.html) Falls du eine bestimmte Distribution oder Kernel-Version nutzt, kann die Verfügbarkeit variieren.

Ja, unter Unix kannst du mit Pipes (`|`) und Umleitungen (`<`, `>`) Datenströme zwischen Prozessen flexibel verbinden. Wenn du „vor den systemeigenen Schreibbefehl“ und „hinter dem eigenen Read-Befehl“ etwas dazwischenschalten möchtest, kannst du Filterprogramme oder eigene Skripte in die Pipeline einbauen. **Beispiel:** Angenommen, du hast ein Programm `prog`, das von der Standardeingabe liest und auf die Standardausgabe schreibt. Du möchtest vor dem Schreiben von `prog` noch ein Filterprogramm (z.B. `sed`) und nach dem Lesen ein weiteres (z.B. `awk`) dazwischenschalten. ```sh echo "Text" | sed 's/Text/Neuer Text/' | prog | awk '{print toupper($0)}' ``` Hier passiert Folgendes: - `echo "Text"` erzeugt die Eingabe. - `sed 's/Text/Neuer Text/'` verändert die Eingabe, **bevor** sie an `prog` geht. - `prog` liest die veränderte Eingabe. - Die Ausgabe von `prog` wird von `awk` weiterverarbeitet, **nachdem** sie von `prog` geschrieben wurde. **Allgemein:** - Alles, was du **vor** dem Programm in die Pipe schreibst, beeinflusst die Eingabe (Read). - Alles, was du **nach** dem Programm in die Pipe schreibst, beeinflusst die Ausgabe (Write). **Weitere Möglichkeiten:** - Mit `tee` kannst du Datenströme aufteilen oder mitschneiden. - Mit Prozesssubstitution (`<(...)` und `>(...)`) kannst du komplexere Datenflüsse bauen. **Fazit:** Du kannst beliebige Programme oder Filter vor und nach deinem eigenen Programm in eine Pipe einbauen, um die Datenströme zu manipulieren. Das ist ein zentrales Konzept in Unix-Systemen. Weitere Infos: - [Pipes und Umleitungen in der Bash](https://wiki.ubuntuusers.de/Shell/Pipe/) - [GNU Bash Manual: Redirections](https://www.gnu.org/software/bash/manual/html_node/Redirections.html)

Android basiert auf dem Linux-Kernel, der wiederum ein Unix-ähnliches Betriebssystem ist. Das bedeutet, Android übernimmt viele grundlegende Prinzipien und Strukturen von Unix-Systemen, wie z.B. das Dateisystem, Benutzer- und Rechteverwaltung sowie Prozessmanagement. Allerdings ist Android kein klassisches Unix-System wie etwa macOS oder eine typische Linux-Distribution (z.B. Ubuntu). Die wichtigsten Unterschiede: - **Kernel:** Android verwendet den Linux-Kernel, der ursprünglich von Unix inspiriert wurde, aber nicht direkt von Unix abstammt. - **Benutzerschnittstelle:** Android nutzt keine klassischen Unix-Tools oder -Shells als Standard, sondern setzt auf eine eigene Laufzeitumgebung (früher Dalvik, jetzt ART) und eine speziell angepasste Benutzeroberfläche. - **Systembibliotheken:** Android verwendet eigene Bibliotheken (z.B. Bionic statt der GNU C Library). - **App-Ökosystem:** Android-Apps laufen in einer Sandbox und sind meist in Java/Kotlin geschrieben, nicht in klassischen Unix-Sprachen wie C oder Shell. **Fazit:** Android ist ein Unix-ähnliches System, weil es auf dem Linux-Kernel basiert und viele Unix-Prinzipien übernimmt. Es ist aber kein vollständiges Unix-System im klassischen Sinn, sondern eine speziell angepasste Plattform für mobile Geräte. Weitere Informationen findest du z.B. auf der offiziellen [Android-Entwicklerseite](https://developer.android.com/).