Das Unternehmen Cloudflare, das ein Content Delivery Network, Internetsicherheitsdienste und verteilte DNS-Dienste bereitstellt, hat mit Pingora ein in Rust geschriebenes hauseigenes…

Die Programmiersprache Rust liegt in einer neuen Version 1.77 vor, die mehrere APIs stabilisiert, endgültig das Makro „offset_of!“ einführt, Rekursion in asynchronen Funktionen erlaubt und…

Die Programmiersprache Rust liegt in einer neuen Version vor, die mehrere APIs stabilisiert, endgültig das Makro „offset_of!“ einführt, Rekursion in asynchronen Funktionen erlaubt und…

Netflix hat das Kommandozeilen-Tool bpftop veröffentlicht. Es soll die Leistungsoptimierung und -überwachung von eBPF-Programmen vereinfacht.

Google will die Interoperabilität zwischen Rust und C++ verbessern und hat der Rust Foundation dafür einen Zuschuss in Höhe von 1 Million US-Dollar gewährt.

Mit der Unterstützung von Rust im Basissystem von FreeBSD könnten viele Anwendungen auf die sichere Sprache portiert werden.

Das Rust-Team hat die Programmiersprache Rust in Version 1.74.0, angekündigt. Die neue Ausgabe bringt diverse Neuerungen und Verbesserungen mit.

Neu ist unter anderem, die Lint-Konfiguration durch den Paketmanager Cargo. Dabei unterstützt das Cargo.toml-Manifest nun eine [lints]-Tabelle, um die Berichtsstufe (forbid, deny, warn, allow) für Lints vom Compiler und anderen Werkzeugen zu konfigurieren.

Für Cargo gibt es noch weitere Funktionen. Die Entwickler nennen hier  Credential Provider und authentifizierte private Registries.

Credential Providers ermöglichen die Konfiguration, wie Cargo Berechtigungsnachweise für eine Registrierung erhält. Integrierte Anbieter sind für die betriebssystemspezifische sichere Speicherung von Geheimnissen unter Linux, macOS und Windows enthalten. Darüber hinaus können benutzerdefinierte Anbieter geschrieben werden, um beliebige Methoden zur Speicherung oder Erzeugung von Token zu unterstützen. Die Verwendung eines sicheren Anbieters für Anmeldeinformationen verringert das Risiko, dass Registrierungs-Token verloren gehen.

Private Registries können nun optional eine Authentifizierung für alle Operationen verlangen, nicht nur für die Veröffentlichung. Dies ermöglicht es privaten Cargo-Registries, ein sichereres Hosting von Crates anzubieten. Die Verwendung von privaten Registern erfordert die Konfiguration eines Credential Providers.

Die Ankündigung enthält auch Informationen zur Installation.

Der Beitrag Rust 1.74.0 ist fertig erschien zuerst auf Linux-Magazin.

Die Ferrous Systems GmbH hat einen Rust-Compiler für

Der Beitrag Rust-Compiler für sicherheitskritische Umgebungen steht unter Open-Source-Lizenz erschien zuerst auf LinuxCommunity.

Das Unternehmen Ferrous Systems will in Kürze Ferrocene, seinen Rust-Compiler für sicherheitskritische Anwendungen und Cybersicherheit, als Open-Source-Projekt veröffentlichen. Die Lizenzen Apache-2.0 oder MIT sollen zum Einsatz kommen.

Ferrocene bildet den Rust-Compiler “rustc” ab, Ferrous Systems hat diesen aber qualitätsgeprüft und qualifiziert für den Einsatz in Automobil- und Industrieumgebungen (derzeit gemäß ISO 26262 und IEC 61508). Der Compiler ist dem Rust-Projekt als Downstream angeschlossen, um Tests und Qualität auf bestimmten Plattformen weiter zu verbessern, teilt das Unternehmen mit. In den kommenden Wochen sollen weitere Informationen zu den Komponenten und Änderungen in Ferrocene veröffentlicht werden. Man habe zwei Jahre am Compiler gearbeitet und sei nun bereit, ihn verfügbar zu machen – aber auch vollständig quelloffen, teilt Ferrous Systems mit.

Weiter heißt es, dass man für Ferrocene auch kostenpflichtige vorgefertigte Binärdateien anbieten werde, die seien validiert und mit langfristigem Support von Rust-Experten flankiert. Die Kosten würden insbesondere den langfristigen Support abdecken, der über das hinausgehe, was das Rust-Projekt garantiere. Da in der nun aktuellen Version 23.06.0 noch proprietäre Anteile von einer früheren Partnerschaft steckten, werde man den freien Ferrocene Compiler in Version 23.06.1 in den kommenden Monaten veröffentlichen, sobald die proprietären Teile entfernt worden seien.

Der Beitrag Ferrocene: Rust-Compiler wird Open Source erschien zuerst auf Linux-Magazin.

Die neue stabile Version 1.72.0 der Programmiersprache Rust beseitigt unter anderem ein Limit bei der Const-Evaluierung.

In früheren Versionen von Rust gab es eine Beschränkung der Evaluierung von Konstanten beim Kompilieren. Das sollte verhindern, dass die Auswertung von benutzerdefinierten Konstanten in eine Endlosschleife gerät oder anderweitig unendlich viel Zeit in Anspruch nimmt, teilen die Entwickler mit. Allerdings habe man festgestellt, dass kreativer Rust-Code an diese Grenzen stoßen und einen Compilerfehler erzeugen könne, heißt es in der Ankündigung. Und es seien auch noch schlimmere Auswirkungen denkbar, weil das Erreichen des Limits je nach den vom Benutzer aufgerufenen Bibliotheken stark variiere. Es könne dann sogar vorkommen, das eine Bibliothek eine Anweisung in zwei Teile aufspalte und damit das Kompilieren von Code unmöglich mache. Dieses Limit entfällt nun.

Jetzt könnten Entwickler eine unbegrenzte Anzahl von Konst-Evaluierungen zur Kompilierzeit durchführen, heißt es weiter. Um lange Kompilierungen ohne Rückmeldung zu vermeiden, werde der Compiler immer eine Meldung ausgeben, nachdem der Code zur Kompilierzeit eine Weile gelaufen sei, und diese Meldung nach einer Zeitspanne wiederholen, die sich dann jedes Mal verdopple.

In der Ankündigung sind weitere Neuerungen aufgeführt und die Downloads verlinkt.

Der Beitrag Rust 1.72.0 bringt unbegrenzte Evaluierungsmöglichkeiten erschien zuerst auf Linux-Magazin.

Mehr als 1000 Entwickler schreiben inzwischen bei Google Rust-Code. Der Umstieg erfolgt offenbar schneller und einfacher als erwartet.

Das Open-Source-Team von Google hat die Ergebnisse einer Auswertung zur internen Nutzung der Programmiersprache Rust veröffentlicht. Grundlage dafür sind die Antworten von mehr als 1.000 Angestellten, die im vergangenen Jahr 2022 Rust-Code selbst geschrieben oder eingepflegt haben. Dabei räumt das Team auch mit einigen Gerüchten auf, die im Zusammenhang mit dem Wechsel auf Rust immer wieder genannt werden. Dazu gehört auch, dass es lange dauere, Rust zu erlernen. Google widerspricht hier deutlich.

Demnach fühlten sich zwei Drittel der befragten Entwickler schon nach nur maximal zwei Monaten sicher genug, zu einer bestehenden Codebasis in Rust beizutragen. Darüber hinaus heißt es, dass die Hälfte der Befragten nach nur vier Monaten genauso produktiv in Rust arbeiten könne wie in einer anderen Sprache. Laut Google entsprechen diese Zahlen auch dem Zeitraum zum Erlernen anderer Sprachen, sowohl “innerhalb als auch außerhalb von Google.”

Google schreibt: “Insgesamt haben wir keine Daten gesehen, die darauf hindeuten, dass Rust im Vergleich zu anderen Sprachen, die diese Entwickler zuvor bei Google verwendet haben, einen Produktivitätsnachteil mit sich bringt.” Von Vorteil für die Nutzung von Rust sind dabei laut der Auswertung auch die als “besonders hilfreich” bezeichneten Fehlermeldungen. Ebenso sei ein Großteil der Befragten zufrieden mit der eigenen Codequalität in Rust, wobei 85 Prozent der Entwickler davon ausgehen, dass ihr Code in Rust zu einer höheren Rate korrekt ist als in anderen Programmiersprachen.

Die größten Probleme beim Rust-Umstieg seien die als zu langsam beschriebene Geschwindigkeit des Rust-Compilers sowie die Makros, das Ownership-System und die Async-Programmierung. Google zieht aus der Umfrage folgenden Schluss: “Wenn Rust nicht nur besser für das Schreiben von qualitativ hochwertigem Code ist, sondern auch besser dafür geeignet ist, diesen Code schneller einzupflegen, dann ist das für Unternehmen, die die Einführung von Rust evaluieren und in Betracht ziehen, eine ziemlich überzeugende Reihe von Gründen, die über Leistung und Speichersicherheit hinausgehen.”

Der Beitrag Google-Entwickler wechseln schnell auf Rust erschien zuerst auf Linux-Magazin.

Die Programmiersprache Rust hat mit Version 1.70.0 das “sparse”-Protokoll von Cargo nun standardmäßig für das Lesen des Index von crates.io aktiviert, berichten die Entwickler.

Diese Funktion sei zwar bereits mit Rust 1.68.0 stabilisiert worden, bedurfte aber noch Konfigurationsarbeiten um sie mit crates.io verwenden zu können. Nutzer sollten damit von einer deutlich verbesserten Leistung beim Abrufen von Informationen aus dem crates.io-Index profitieren.

Benutzer, die sich hinter einer restriktiven Firewall befinden, müssen sicherstellen, dass der Zugriff auf “https://index.crates.io” möglich ist, heißt es in der Ankündigung. Wer bei der vorherigen Standardeinstellung bleiben will oder muss und den von GitHub gehosteten Git-Index weiter verwende, könne die Konfigurationseinstellung unter “registries.crates-io.protocol” verwenden, um die Standardeinstellung entsprechend zu ändern.

Zudem seien zwei neue Typen wurden für die einmalige Initialisierung gemeinsam genutzter Daten nun stabil, OnceCell und sein thread-sicheres Gegenstück OnceLock. Diese ließen sich überall dort verwendet werden, wo eine sofortige Konstruktion nicht erwünscht und vielleicht auch nicht möglich ist, wie etwa bei nicht-konstanten Daten in globalen Variablen.

Der Beitrag Rust 1.70.0 mit Sparse-Protokoll erschien zuerst auf Linux-Magazin.

Google, dass sich selbst als langjähriger Förderer und Investor von Rust bezeichnet, hat Audits für Rust-Crates veröffentlicht, die das Unternehmen in Open-Source-Google-Projekten verwendet.

Crates sind bei Rust Softwarekomponenten, die mit Paketen in anderen Sprachen vergleichbar sind. Rust mache es einfach, Code in Crates zu kapseln und weiterzugeben, berichtet Google. Man nutze im Konzern das breite Ökosystem der Open-Source-Rust-Crates, indem man Crates von Dritten einsetze aber auch eigene Crates veröffentliche.

Jeder Code von Dritten berge ein gewisses Risiko. Bevor ein Projekt ein Crate verwende, werde es in der Regel durch die Mitglieder geprüft, um es etwa an den Standards für Sicherheit zu messen. Da es in Googles Open-Source-Projekten viele gleiche Abhängigkeiten gebe, wäre es doppelter Aufwand wenn verschiedene Projekte dieselbe Crates prüfen würden, heißt es im Blogbeitrag. Deshalb hjabe man begonnen Audits projektübergreifend zu nutzen. Und diese Audits stelle man nun der breiteren Open-Source-Gemeinschaft zur Verfügung.

Die Audits der Crates würden kontinuierlich gesammelt und auf GitHub in Googles Supply-Chain-Repository veröffentlicht. Sie arbeiten laut Google mit Cargo Vet zusammen, um mechanisch zu verifizieren, dass ein Mensch alle Abhängigkeiten geprüft und ihre relevanten Eigenschaften aufgezeichnet habe und diese Eigenschaften die Anforderungen für das aktuelle Projekt erfüllten, berichtet Google

Die Audits, die die Eigenschaften vieler Open-Source-Rust-Crates bescheinigen, ließen sich problemlos in eigene Projekte importieren, heißt es weiter. Ausgestattet mit diesen Daten könne man entscheiden, ob die Crates die Anforderungen an Sicherheit, Korrektheit und Tests für die jeweiligen Projekte erfüllen würden.

Der Beitrag Google veröffentlicht Audits zu Rust Crates erschien zuerst auf Linux-Magazin.

Im Bestreben, kritische Software-Infrastruktur vor Speicherfehlern zu schützen, erhalten die Programme Su und Sudo einen Rewrite in der speichersicheren Programmiersprache Rust.

Initiiert wird die Neufassung von Su und Sudo von Prossimo, einer Initiative der Internet Security Research Group, die auch durch die Initiative Let’s Encrypt bekannt ist. Amazon finanziert den Rewrite.

Die Dienstprogramme Sudo und Su stellten eine kritische Privilegiengrenze auf fast allen Open-Source-Betriebssystemen dar und hätten eine lange Geschichte von Speichersicherheitsproblemen, lässt Prossimo wissen.

Sudo sei in den 1980er Jahren entwickelt worden und habe sich im Laufe der Jahrzehnte zu einem unverzichtbaren Werkzeug für die Durchführung von Änderungen bei gleichzeitiger Minimierung des Risikos für ein Betriebssystem entwickelt. Das Problem sei, dass es in C geschrieben und damit mit Speichersicherheitsproblemen behaftet sei.

Sudo und Su entsprächen allen Kriterien, die die Initiative für einen Rewrite definiert hat. Dazu zählen etwa der Verbreitungsgrad und die wichtige Funktion. Es sei wichtig, dass wir unsere kritischste Software schützen, insbesondere vor Sicherheitslücken im Speicher, heißt im Blogbeitrag von Prossimo. Es sei schwer, sich Software vorzustellen, die viel kritischer sei als Sudo und Su.  Der Arbeitsplan des Rewrites ist hier einsehbar. Das GitHub-Repository findet sich hier. Bis September 2023 sollen die Arbeiten abgeschlossen sein.

Wie Prossimo berichtet, hat eine kürzlich durchgeführte Studie ergeben, dass 60 bis 70 Prozent der Sicherheitslücken in iOS und macOS auf Speichersicherheitslücken zurückzuführen sind. Microsoft schätzt, dass 70 Prozent aller Sicherheitslücken in seinen Produkten in den letzten zehn Jahren auf Probleme mit der Speichersicherheit zurückzuführen sind. Google schätzt, dass 90 Prozent der Sicherheitslücken in Android auf Speichersicherheitsprobleme zurückzuführen sind. Eine Analyse von 0-Days, die in freier Wildbahn ausgenutzt wurden, ergab, dass es sich bei mehr als 80 Prozent der ausgenutzten Schwachstellen um Sicherheitslücken im Arbeitsspeicher handelt.

Der Beitrag Sudo und Su: Speichersicherer Rewrite in Rust erschien zuerst auf Linux-Magazin.

Die neue Version 1.69 der Programmiersprache Rust kann mit rund 3000 Commits von 500 Beitragenden aufwarten. Entsprechend zahlreich sind die Änderungen und Verbesserungen.

Obwohl die neue Ausgabe von Rust keine neuen Features mitbringt, sind die Entwickler angetan von Version 1.69. Besonders die zahlreiche Beteiligung sei erfreulich. Verbesserungen habe es unter anderem in der automatischen Behebung von Warnungen gegeben. Nachdem bereits in Rust 1.29.0 der Unterbefehl “cargo fix” hinzugefügt worden sei, um einige einfache Compiler-Warnungen automatisch zu beheben, habe es stetige Fortschritte in den automatisch zu behebenden Warnungen gegeben. Die Anzahl der Warnungen, die sich automatisch bereinigen ließen, sei entsprechend stetig gestiegen. Darüber hinaus habe man die Unterstützung für die automatische Behebung einiger einfacher Clippy-Warnungen hinzugefügt. Damit Entwickler von diesen Features auch Gebrauch machen, habe man nun mehr Aufmerksamkeit darauf gelenkt und der Paketmanager Cargo schlage nun vor, cargo fix oder cargo clippy –fix auszuführen, wenn es Warnungen entdecke, die sich automatisch beheben ließen, teilen die Entwickler mit.

Eine Verbesserung der Leistungsfähigkeit beim Kompilieren verspricht die Neuerung, dass Cargo nun standardmäßig die Ausgabe von Debug-Informationen in Build-Skripten vermeidet. Das Changelog zählt weitere Neuerungen in Rust auf.

Der Beitrag Rust 1.69 mit vielen Verbesserungen erschien zuerst auf Linux-Magazin.

Das National Institute of Standards and Technology (NIST) hat die Programmiersprache Rust in die Liste der “Safer Languages” aufgenommen.

Rust verfüge über ein Ownership-Modell, das sowohl Speicher- als auch Threadsicherheit zur Kompilierzeit garantiere, ohne dass ein Garbage Collector erforderlich sei, begründet das NIST seine Wahl. Dieses Modell ermöglicht es den Benutzern, leistungsstarken Code zu schreiben und gleichzeitig viele Fehlerklassen zu eliminieren, heißt es weiter. Und obwohl Rust auch über einen unsicheren Modus verfüge, sei dessen Verwendung explizit, und erlaube nur einen engen Bereich von Aktionen.

Das 1901 gegründete NIST untersteht dem US-Handelsministerium und gilt als eine der ältesten naturwissenschaftlichen Forschungseinrichtungen in den USA. Eine der vielen Initiativen des NIST ist das Projekt Software Assurance Metrics And Tool Evaluation (SAMATE). Dieses Gremium “widmet sich der Verbesserung der Software Assurance durch die Entwicklung von Methoden zur Bewertung von Software-Tools, der Messung der Effektivität von Tools und Techniken sowie der Identifizierung von Lücken in Tools und Methoden”, heißt es auf der NIST-Website.

Die Safer Languages wiederum sind eine Kategorie der SMATE “Klassen von Software-Sicherheitsfunktionen”. Das NIST empfiehlt dort die Verwendung von Programmiersprachen mit eingebauten Sicherheitsfunktionen, die von den Entwicklern aktiv überwacht und unterstützt werden.

Neben Rust sind bei den Safer Languages auch die Programmiersprachen und Sprach-Tools SPARK, Escher C Verifier Language, Fail-Safe C, Safe-Secure C/C++ (SSCC), die CERT Coding Standards und CCured aufgeführt.

Der Beitrag NIST macht Rust zur Safer Language erschien zuerst auf Linux-Magazin.

Das Ruffle-Projekt reimplementiert den Flash-Player in der Programmiersprache Rust. Auf diese Weise sollen alte Flash-Anwendungen weiterbetrieben werden können. Bei der Entwicklung gab es jetzt größere Fortschritte.

Das berichtet das Team in seinem frisch eröffneten Blog. Demnach emuliert die AVM1-Engine ihr Vorbild aus Adobe Flash deutlich besser. Damit laufen wiederum viele ActionScript-2-Spiele unter Ruffle. Als Beispiele nennen die Entwickler Bubble Bobble: The Revival, The Powerpuff Girls: Attack of the Puppybots und Cube Colossus.

Fortschritte gibt es auch bei der AVM2-Engine, die sich um die Ausführung von ActionScript-3-Code kümmert. Welche Funktionen im einzelnen wie weit implementiert sind, listet eine eigene Seite detailliert auf. Besonders gut voran kommt derzeit die XML-Unterstützung. Des Weiteren haben die Entwickler verschiedene Probleme behoben, die in einigen Fällen das Anklicken von Schaltflächen verhindert hatten. Insgesamt ist die Entwicklung so weit, dass sich viele Spiele von Flipline spielen lassen. Dazu zählen Papa’s Burgeria und Jacksmith. Ebenfalls funktionieren unter anderem die Spiele Canabalt, Diggy und Dino Run: Marathon of Doom.

Wer Ruffle auf Mobilgeräten nutzt, kann nun Text in die entsprechenden Felder eingeben. Tippt man ein solches Feld an, fährt die Bildschirmtastatur aus, alternativ lässt sich eine Bluetooth-Tastatur nutzen. Auf iOS-Geräten öffnen sich zudem endlich Kontextmenüs. Um sie hervorzuholen, drückt man etwas länger auf den Bildschirm.

Der Beitrag Ruffle-Projekt erhält Flash-Player in Rust am Leben erschien zuerst auf Linux-Magazin.

Mit der Veröffentlichung der Version 1.66.1 beheben die Entwickler der Programmiersprache Rust eine Sicherheitslücke, über die ein Man-in-the-Middle-Angriff (MITM) möglich wird.

Rust 1.66.1 behebt das Problem, dass der enthaltene Paketmanager Cargo die SSH-Hostschlüssel nicht verifiziert, wenn Abhängigkeiten oder Registry-Indizes mit SSH geklont werden. Diese Sicherheitslücke wird als CVE-2022-46176 gelistet. Die Lücke betrifft alle Rust-Versionen vor 1.66.1.

Wenn ein SSH-Client eine Kommunikation mit einem Server aufbaut, sollte der Client zur Vermeidung von MITM-Angriffen prüfen, ob er bereits in der Vergangenheit mit diesem Server kommuniziert hat und wie der öffentliche Schlüssel des Servers damals lautete, heißt es im Advisory zur Lücke. Wenn sich der Schlüssel seit der letzten Verbindung geändert hat, muss die Verbindung abgebrochen werden, da wahrscheinlich ein MITM-Angriff stattfindet. Es sei nun aber festgestellt worden, dass Cargo solche Überprüfungen nie implementiert und keine Validierung des öffentlichen Schlüssels des Servers durchgeführt hat, wodurch Cargo-Benutzer anfällig für MITM-Angriffe seien.

Im Advisory sind Anleitungen für die Upgrades aufgeführt und Alternativen beschrieben, sollte ein Update nicht sofort möglich sein.

Der Beitrag Rust 1.66.1 schließt Sicherheitslücke erschien zuerst auf Linux-Magazin.

Die aktuelle Version der Programmiersprache Rust schließt eine Sicherheitslücke bei der SSH Host-Key Überprüfung im Paketmanager Cargo

Quelle

Im September gab es mit Arti 1.0 die erste stabile Veröffentlichung des in Rust geschriebenen Tor-Client. Nun haben die Entwickler mit Arti 1.1.0 ein Feature-Release nachgereicht.

So lasse sich Arti 1.1.0 nun mit Support für die Anti-Zensur-Funktionen von Tor nutzen. Artie komme nun mit Bridges und pluggable Transports zurecht, teilen die Entwickler mit. Und obwohl dies wie eine relativ kleine Ankündigung aussehe, stecke dahinter eine Menge Arbeit, die in den vergangenen Monaten geleistet worden sei. Die Verwendung dieser Funktionen könne Arti effektiver machen, um Zugang zu Tor zu erhalten, trotz Zensur zwischen dem Nutzer und dem öffentlichen Internet, heißt es weiter.

Arti könne sich mit Bridges verbinden, wenn es mit der “bridge-client”-Funktion kompiliert wurde, was in der Arti-Binärdatei standardmäßig aktiviert sei. Auch die Verbindung mit pluggable Transports klappe beim Kompilieren mit der “pt-client”-Funktion, die ebenfalls standardmäßig in der Arti-Binärdatei aktiviert sei.

Arti benötigt jetzt aber Rust 1.60 oder höher, steht im Changelog für die neue Version. Damit seien einige neue Funktionen möglich geworden und es sei möglich geworden, Abhängigkeiten zu aktualisieren, die veraltet gewesen seien.

Der Beitrag Arti 1.1.0: Feature-Release von Tor-Client in Rust erschien zuerst auf Linux-Magazin.

Das uutils-Projekt implementiert die GNU Coreutils und somit die grundlegenden Kommandozeilenprogramme eines Linux-Systems in Rust. Mit der neuen Version nähern sich mehrere Tools ihren alten Kollegen weiter an.

Bei einem Fehler beenden sich jetzt die meisten Werkzeuge mit dem Rückgabewert „1“ und entsprechen so dem Verhalten der GNU-Tools. In den vorherigen uutils-Versionen gaben die Programme im Fehlerfall noch eine „2“ zurück. Auch „chroot“ liefert bessere Exit-Codes und unterstützt obendrein Kommandos mit Flags.

„cp“ kennt den Parameter „-H“ und behandelt weitere Fälle korrekt. „test“ unterstützt „-N“, „-ef“, „-nt“ und „-ot“ sowie 128 Bit lange Integer-Zahlen. Darüber hinaus haben die Entwickler die Art und Weise angepasst, wie „dd“ seine Parameter interpretiert. Damit bietet auch dieses Werkzeug eine bessere Kompatibilität zu seinem GNU-Pendant.

Die Neuimplementierung der Coreutils in Rust soll gleich mehrere Fliegen mit einer Klappe schlagen. So stellt Rust eine zeitgemäße Programmiersprache und bietet einen besseren Schutz vor Speicherfehlern. Obendrauf sollen die neu geschriebenen Tools auch noch flotter zu Werke gehen.

Weitere Informationen zur neuen Version liefern die Release Notes auf GitHub.

Der Beitrag Uutils 0.0.16 verbessert Kompatibilität zu den GNU Coreutils erschien zuerst auf Linux-Magazin.

Mit Arti 1.0.0 hat das Tor-Projekt ihre Implementierung der Tor-Protokolle in der Programmiersprache Rust veröffentlicht. Arti sei nun für einen breiteren Einsatz bereit, teilt das Projekt mit.

Bei der Definition des jetzt erreichten Meilensteins 1.0.0 sei man zur Auffassung gelangt, dass Arti “bereit für den Produktionseinsatz” sei. Man sollte in der Lage sein, Arti in der realen Welt benutzen zu können und ein ähnliches Maß an Privatsphäre, Benutzerfreundlichkeit und Stabilität zu erhalten, wie man es mit einem C-Client Tor möglich sei. Und die APIs sollten einigermaßen stabil sein.

Die Entscheidung, mit der Umsetzung in Rust sei gefallen, nachdem die C-Tor-Implementierung in die Jahre gekommen sei. Man habe bei der weiteren Entwicklung in C immer unter Beschränkungen gelitten. C ermutige einen unnötigen Low-Level-Ansatz für viele Programmierprobleme, und es erfordere dann mühsame Sorgfalt und Aufwand, um sicher benutzbar zu sein.  Auch deswegen sei das Entwicklungstempo in C immer langsamer als gewünscht gewesen, heißt es im Blogbeitrag von Tor.

Außerdem sei die bestehende C-Implementierung im Laufe der Jahre zu einem nicht gerade modularen Design herangewachsen. Es sei fast alles ist mit allem anderen verbunden, was es noch schwieriger mache, den Code zu analysieren und sichere Verbesserungen vorzunehmen.

Der Beitrag Arti 1.0.0: Tor in Rust erschien zuerst auf Linux-Magazin.

Die Rust-Arbeiten an Linux zeigen, dass die Sprache auch im Kernel genutzt werden kann. Nun gibt es Experimente für FreeBSD.

Der Entwickler David Young hat experimentelle Patches erstellt, um Kernel-Module für FreeBSD in der Programmiersprache Rust erstellen zu können. Das berichtet Young zusammen mit einer sehr ausführlichen Erläuterung im Forschungsblog des IT-Sicherheitsunternehmens NCC Group.

Motivation der Arbeiten sind dabei die zahlreichen Speicherfehler, die im Zusammenhang mit der Nutzung von C und C++ auftreten, in denen bisher üblicherweise Betriebssystemkernel erstellt werden. Young schreibt dazu: “Es ist allgemein anerkannt, dass ein großer Teil der Sicherheitsprobleme in komplexer Software auf Speichersicherheitsprobleme zurückzuführen ist.” Die Sprache Rust helfe dagegen dabei, bestimmte Fehlerklassen im Zusammenhang mit der Speicherverwaltung vorzubeugen.

Young verweist darüber hinaus auf die Arbeiten am Linux-Kernel, um dort Rust als Sprache neben C zu etablieren. Auch diese Arbeiten sind primär durch die Sicherheitsperspektive motiviert. Das sieht auch Linux-Gründer Linus Torvalds als einen der Hauptvorteile der Arbeiten an. Für FreeBSD habe es bisher bis auf veralteten Beispielcode aber keine Arbeiten in diese Richtung gegeben, weshalb Young diese Arbeit nun wieder aufgenommen habe, schreibt er.

Der so entstandene Code steht nun auf Github bereit. Dabei handelt es sich unter anderem um Rust-Sprachanbindungen für die Kernel-Header von FreeBSD, eine sichere Abstraktionsschicht sowie ein Beispielmodul. Die Abstraktionen seien jedoch nicht so fortgeschritten, wie dies bei Linux der Fall sei, räumt Young ein. Darüber hinaus wünscht sich der Entwickler, dass diese Arbeiten weitergeführt und künftig eventuell auch Kern-Komponenten in Rust erstellt werden. Ob dies aber letztlich geschieht und der Code in den Hauptzweig von FreeBSD aufgenommen wird, ist derzeit noch nicht absehbar.

Der Beitrag FreeBSD-Kernel bekommt experimentelle Rust-Patches erschien zuerst auf Linux-Magazin.

Rund fünf Monate nach der Version 1.18 erscheint die Ausgabe 1.19 der Programmiersprache Go. Viele Neuerungen betreffen Implementierungen in Toolchain und Runtime.

Auch die Bibliotheken haben Neuerungen erfahren. Wie gewohnt betonen die Entwickler die Rückwärtskompatibilität: Wir erwarten, dass fast alle Go-Programme weiterhin kompiliert werden und wie bisher laufen.

An der Sprache selbst gebe es nur eine kleine Änderung und die betreffe eine Korrektur des Geltungsbereichs von Typparametern in Methodendeklarationen, teilen die Entwickler mit. Bestehende Programme seien davon nicht betroffen.

Zudem sei das Speichermodell von Go wurde überarbeitet worden, um Go an das von C, C++, Java, JavaScript, Rust und Swift verwendete Speichermodell anzugleichen, heißt es weiter. Mit der Aktualisierung des Speichermodells führt Go 1.19 neue Typen im sync/atomic-Paket ein, die die Verwendung atomarer Werte erleichtern, wie atomic.Int64 und atomic.Pointer[T].

Die Laufzeitumgebung bietet nun Unterstützung für eine weiche Speicherbegrenzung. Diese Speichergrenze umfasst den Go-Heap und alle anderen von der Laufzeitumgebung verwalteten Speicher und schließt externe Speicherquellen wie Mappings der Binärdatei selbst, in anderen Sprachen verwalteten Speicher und vom Betriebssystem im Auftrag des Go-Programms gehaltenen Speicher aus, teilen die Entwickler mit.

Die Ankündigung nennt weitere Details.

Der Beitrag Go 1.19 mit Updates bei der Implementierung erschien zuerst auf Linux-Magazin.