Sauberes Trinkwasser sprudelt hierzulande wie selbstverständlich aus dem Hahn. Und das soll auch so bleiben. Es wäre falsch zu behaupten, dass Wasser flächendeckend knapp ist in Deutschland. Doch steigende Temperaturen, Dürren und extreme Wetterereignisse bedrohen unsere Talsperren und Grundwasserreserven auf vielfältige Weise.

Laut Deutschem Wetterdienst war es hierzulande seit 1931 noch nie so trocken wie 2025 von Anfang Februar bis Mitte April. Da stellt sich durchaus die Frage, ob das mit dem Trinkwasser auch weiterhin so reibungslos klappt.

Der Artikel erklärt die direkten und indirekten Gefahren für unser Trinkwasser und zeigt auf, welche Lösungsansätze es gibt, um die Versorgung in Quantität und Qualität auch für zukünftige Generationen zu sichern.

Das war die Leseprobe unseres heise-Plus-Artikels „Analyse: Das wahre Wasserproblem Deutschlands und welche Maßnahmen nötig sind“.
Mit einem heise-Plus-Abo können Sie den ganzen Artikel lesen.

Ihre Aufgabe führt Sie direkt in eine digitale Gruft. Mit Kali Linux und einer Portion Neugier jagen Sie versteckte Flaggen und treten am Ende gegen den Necromancer an. Hinter der Spielkulisse steckt ein intensives Hacking-Rätsel in einem abgeschotteten Netzwerk.

Im Webinar „Die Necromancer-Challenge“ führt c’t-Redakteur Wilhelm Drehling durch diese besondere CTF-Challenge (Capture The Flag).

Praxisnahe Einblicke in Hacking-Werkzeuge

Drehling hackt sich im Webinar durch alle elf Level. Um zum Ziel zu gelangen, greift er auf unterschiedliche Hacking-Tools zurück: Er klopft Server mit nmap ab, knackt Passwörter mit Hydra und analysiert den Netzwerkverkehr mit Wireshark. Dabei verzichtet er bewusst auf Fachchinesisch und trockene CVE-Tabellen. Sie gewinnen ein Gefühl dafür, wie man eine solche CTF-Challenge systematisch angeht und erfahren, wie Sie ein eigenes sicheres Hacking-Netzwerk aufsetzen.

Während des Webinars sollten Sie sich zunächst auf das Geschehen am Bildschirm konzentrieren und erst später selbst aktiv werden. Als Teilnehmer erhalten Sie Zugriff auf die Aufzeichnung sowie die begleitenden c’t-Artikel, um das Gelernte im eigenen Tempo nachzuvollziehen.

Vom Zusehen zum Selbermachen

Das c’t-Webinar richtet sich an alle Menschen, die sich fürs Hacken interessieren, egal ob Anfänger oder mit Vorkenntnissen. Sie entwickeln ein Gespür für Angriffsmethoden und lernen, Schwachstellen zu identifizieren. Wilhelm Drehling gibt zudem wertvolle Tipps zu Lernplattformen, Kali-Alternativen und hilfreichen Tools. Allgemeine Verständnisfragen können Sie jederzeit im Chat stellen.

• Datum: 16. September 2025
• Uhrzeit: 15:00 bis 18:00 Uhr
• Preis: 69,00 Euro

Zur Teilnahme benötigen Sie lediglich einen aktuellen Browser. Alle weiteren Informationen sowie Details zur Anmeldung finden Sie auf der Webseite von heise academy.

(abr)

Nachdem ich in meinem letzten Artikel Contracts in C++26: Ein tiefer Einblick in die Verträge kurz die Details von Contracts vorgestellt habe, möchte ich mich nun näher mit der sehr interessanten Evaluations-Semantik befassen.

Wenn eine Contracts Assertion auftritt, wird eine der vier Bewertungssemantiken angewendet: ignore, observe, enforce und quick-enforce. Die Tabelle gibt einen Überblick über die vier Semantiken:

Leider ist es derzeit nicht möglich, diese Evaluations-Semantiken in vollem Umfang zu sehen.

Checking-Semantik und Terminating-Semantik

Während die Checking-Semantik die Vertrags-Assertion nur auswertet, beendet die Terminating-Semantik auch das Programm.

Eine standardkonforme Implementierung muss nicht jede der vier genannten Evaluations-Semantiken implementieren. Sie kann auch ihre eigene Semantik anbieten.

ignore

Wie der Name schon sagt, ignoriert die ignore-Semantik die Auswertung des Prädikats. Dennoch muss das Prädikat syntaktisch korrekt sein.

observe

Die observe-Semantik ist eine Checking-Semantik. Im Allgemeinen können drei Bedingungen zu einer Vertragsverletzung führen:

• Die Auswertung des Prädikats gibt false zurück.
• Die Auswertung des Prädikats verursacht eine Exception.
• Die Auswertung des Prädikats erfolgt zur Compile-Zeit, aber das Prädikat ist kein konstanter Ausdruck.

Wenn zur Compile-Zeit eine Vertragsverletzung auftritt, wird eine Diagnose ausgegeben und die Kompilierung fortgesetzt.

Wenn eine Vertragsverletzung zur Laufzeit auftritt, wird der Vertragsverletzungs-Handler aufgerufen, der auf ein Objekt vom Datentyp const std::contracts::contract_violation verweist, das Informationen über die Vertragsverletzung enthält. Wenn der Vertragsverletzungs-Handler normal zurückkehrt, wird die Programmausführung fortgesetzt.

enforce

Die enforce-Semantik ruft den Vertragsverletzungs-Handler zur Laufzeit auf. Das Programm wird beendet, wenn der Contract-Violation-Handler normal zurückkehrt. Die enforce-Semantik ist eine sogenannte terminierende Semantik. Das bedeutet, dass im Falle einer Vertragsverletzung die Programmausführung beendet wird. Danach kann eine der folgenden Aktionen erfolgen:

• Aufruf von std::terminate,
• Aufruf von std::abort oder
• sofortige Beendigung der Ausführung.

Zur Compile-Zeit wird die Kompilierung abgebrochen.

quick-enforce

Die quick-enforce-Semantik ruft den Vertragsverletzungs-Handler zur Laufzeit nicht auf. Als terminierende Semantik beendet sie das Programm sofort. In diesem Fall wird beispielsweise __builtin_trap() verwendet.

Zur Compile-Zeit wird die Kompilierung abgebrochen.

Vertragsverletzungs-Handler

Der Vertragsverletzungs-Handler hat folgende Signatur:

void handle_contract_violation( std::contracts::contract_violation );

Die Implementierung stellt den Standard-Vertragsverletzungs-Handler bereit. Sie kann jedoch auch zulassen, dass dieser Standard-Vertragsverletzungs-Handler durch einen benutzerdefinierten ersetzt wird.

In seiner ausgezeichneten Präsentation Contracts for C++ auf der ACCU 2025 stellt Timur Doumler einige spannende Beispiele für benutzerdefinierte Vertragsverletzungshandler vor:

// Protokollierung
  
void handle_contract_violation( std::contracts::contract_violation violation ) {
    LOG(std::format("Contract violated at: {}\n", violation.location()));   
}

// Setze einen Haltepunkt
  
void handle_contract_violation( std::contracts::contract_violation violation ) {
    std::breakpoint();
}

// Warte, bis ein Debugger angeschlossen ist
  
void handle_contract_violation( std::contracts::contract_violation violation ) {
    
while (!std::is_debugger_present())
     /* spin */

    std::breakpoint();
}

// Stacktrace ausgeben
  
void handle_contract_violation( std::contracts::contract_violation violation ) {
    std::cout << std::stacktrace::current(1);
}

// An den Standard-Handler für Vertragsverletzungen übergeben
  
void handle_contract_violation( std::contracts::contract_violation violation ) {
    std::cout << std::stacktrace::current(1);
    std::contracts::invoke_default_contract_violation_handler(violation);
}

Abschließend möchte ich die Schnittstelle des Objekts std::contracts::contract_violation vorstellen, das der Vertragsverletzungs-Handler empfängt:

• kind gibt die Art der Vertragsverletzung zurück.
• semantic gibt die Evaluations-Semantik zurück, wenn die Vertragsverletzung auftritt.
• is_terminating gibt zurück, ob die Evaluations-Semantik beendet wird.
• detection_mode gibt den Grund für die Vertragsverletzung zurück.
• evaluation_exception gibt einen std::exception_ptrzur zur Ausnahme zurück, die bei der Prädikatbewertung ausgelöst wurde.
• comment gibt eine erklärende Zeichenfolge zur Vertragsverletzung zurück.
• location gibt einen std::source_location zurück, der den Ort der Vertragsverletzung angibt.

Weitere Informationen zum std::contracts::contract_violation-Objekt finden sich auf der cppreference-Seite.

Wie geht es weiter?

In meinem nächsten Artikel werde ich mich auf die kleineren Features in C++26 konzentrieren. Ich beginne mit den kleinen Sicherheits-Features in der Kernsprache.

(rme)