coreutils

Die coreutils sind eine Reihe von Programmen, die auf den meisten Unix-Systemen standardmäßig installiert sind. Zu den coreutils (Kernprogramme) gehören häufig verwendete Werkzeuge, die grundlegende Funktionen für die Interaktion mit dem Betriebssystem bieten, wie ls, cp, head, tail, cat, mkdir, touch, wc und viele andere. Diese Anwendungen werden oft in Skripten verwendet, d. h. in einer Reihe von Anweisungen für das Betriebssystem oder in einem Programm, bei denen es äußerst wichtig ist, dass sie wie erwartet funktionieren. Wenn die Ausgabe dieser Kernprogramme von den Erwartungen abweicht, kann dies zu Fehlern bei der Ausführung des Skripts führen. Die uutils coreutils bieten eine gemeinsame Schnittstelle zu diesen Anwendungen für mehrere Plattformen.

Durch das Neuschreiben dieser kritischer Komponenten in der speichersicheren Sprache Rust adressiert das Projekt potenzielle Sicherheitsrisiken, die mit der Verwendung der Programmiersprache C verbunden sind. Dieser Umbau verbessert die allgemeine Sicherheit, Stabilität und Zuverlässigkeit des modernen Betriebssystems.

Die Initiative ist von großer Bedeutung, da sie das Risiko der Kompromittierung von Computern minimiert, auf denen zahlreiche von außen erreichbare Dienste laufen. Außerdem hat das Projekt durch die Einführung von Rust mehr Mitwirkende gewinnen können, da die Sprache unter Software-Entwickler*innen aktuell immer beliebter wird.

Das Projekt wird von einem erfahrenen Debian-Maintainer geleitet, der mit Rust-Expert*innen zusammenarbeitet. Während sich diese Arbeit zunächst auf Debian und Ubuntu konzentriert, unterstützt sie viele andere Betriebssysteme wie Mac OS X, Windows, FreeBSD, OpenBSD, Android und Redox.

Die Umstellung kritischer Komponenten auf eine speichersichere Sprache mindert typische Schwachstellen, die oft zu ernsthaften Sicherheitsproblemen in Debian, Ubuntu und dem breiteren Ökosystem der Linux-Distributionen führen. Dies ist von wesentlicher Bedeutung für den Schutz der Integrität von Systemen, auf denen eine Vielzahl von exponierten Diensten läuft, für die Verringerung des Missbrauchspotenzials und für die Gewährleistung der Stabilität und Zuverlässigkeit von Systemen, die diese Komponenten verwenden.

Darüber hinaus orientiert sich das Projekt an der sich entwickelnden Landschaft der Programmiersprachen und den Präferenzen von Entwickler*innen. Die Wahl von Rust trägt nicht nur Sicherheitsbedenken Rechnung, sondern spiegelt auch einen breiteren Trend in der Branche wider, wie bei Firefox, dem Linux-Kernel, Android usw. Da Rust unter Ingenieur*innen immer beliebter wird, bietet das Projekt eine attraktive Möglichkeit, neue Mitwirkende in die Community zu holen. Dieser Zuwachs an Mitwirkenden kann zu einer verstärkten Zusammenarbeit, einem breiteren Kompetenzspektrum innerhalb der Community und einem nachhaltigeren und widerstandsfähigeren Entwicklungsökosystem führen.

Der STF gibt Arbeiten in Auftrag, um die Sicherheit und Funktionalität von Linux zu verbessern, indem kritische Funktionen, die Teil der GNU coreutils sind, nahtlos durch speichersichere Implementierungen in Rust ersetzt werden.

1. Dateiverwaltungsprogramme
   • Kompatibilität für weit verbreitete Befehle wie ls und mv, um einen nahtlosen Übergang für Nutzer*innen zu gewährleisten.
   • Sicherstellung der Kompatibilität für grundlegende Dateiverwaltungsprogramme wie chown, cp, install, mkdir, rm und touch.
2. Anzeige- und Formatierungsfunktionen
   • Kompatibilität mit wichtigen Anzeige- und Formatierungsfunktionen wie df, du, fmt, printf, stat, tail und wc.
   • Verbesserte Systemüberwachungs- und Datenpräsentationsfunktionen, die den Nutzer*innen effiziente Analysewerkzeuge zur Verfügung stellen.
3. Zusätzliche Werkzeuge
   • Kompatibilität mit anderen Anwendungen wie cut, date, und seq, die den Nutzer*innen ein umfassendes Toolset für die Datenmanipulation und das Zeitmanagement bieten.
4. Entwicklung eines eigenen Argumenten-Parsers
   • Implementierung eines neuen Argumenten-Parsers, der das GNU-Parsing-Verhalten nachahmt, um die Komplexität des Codes zu reduzieren und die Wartbarkeit zu verbessern.
   • Laufende Entwicklung, um fehlende Funktionen zu implementieren und sie in coreutils zu integrieren.
5. Wartung und Bugfixing
   • Kontinuierliche Wartung und Behebung von Fehlern, um die Stabilität und Zuverlässigkeit von Rust coreutils zu gewährleisten.
   • Bearbeitung offener Fehlermeldungen, Implementierung von Fixes basierend auf Nutzer*innen-Feedback und Erhaltung einer hohen Performance durch laufende Optimierungen.