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)

Am Abend hat es über Deutschland ein Spektakel gegeben, das so nur alle paar Jahre zu sehen ist: eine totale Mondfinsternis. Und das zu einer Uhrzeit, zu der die meisten Menschen noch wach waren. Die Eklipse begann gegen 19.30 Uhr und endete kurz vor 21 Uhr. Danach lag der Mond nur noch partiell im Erdschatten.

Eine Mondfinsternis kann es nur bei Vollmond geben. Die von der Sonne angestrahlte Erde wirft wie ein Sonnenschirm einen Schatten in den Weltraum. Wenn der Mond durch diesen Schatten läuft, sieht man eine Mondfinsternis. Steht der Trabant im vollen Umfang in diesem Schatten, spricht man von einer totalen Finsternis.

Zu kinderfeundlicher Uhrzeit

Einen Haken hatte diese Mondfinsternis aber: Über Deutschland stand der Erdtrabant erst, als er schon komplett im Sonnenschatten war, wie Carolin Liefke vom Haus der Astronomie in Heidelberg vorab erläutert hatte. Da er derzeit kein außergewöhnlich großer „Supermond“ ist, war es schwieriger, ihn am Horizont zu erkennen. „Es ist sogar möglich, dass man ihn erst sehen kann, wenn er schon aus der totalen Finsternis raus ist“, hatte Liefke erklärt.

Ungewöhnlich mag erschienen sein, dass der Mond zu keiner Zeit so verdunkelt war, wie man das etwa von einer Sonnenfinsternis kennt. Er schimmerte während der Finsternis rötlich, da die Strahlen der Sonne in der Atmosphäre der Erde gebrochen werden.

Ganz lange, rote Sonnenstrahlen werden dabei in die Schattenzone hineingestreut und beleuchten den Mond dadurch rot. Wie intensiv dies wirkte, war abhängig unter anderem vom Smog in der Luft.

München

Auf dem 60 Meter hohen Olympiaberg fanden sich am Sonntagabend rund 300 Menschen ein, um zunächst über eine Stunde lang eine graue Wolkenwand im Osten anzustarren. Die Wenigsten bemerkten den gegenüber stattfindenden, wunderschönen Sonnenuntergang zwischen Olympiastadion und der neuen Eventarena SAP Garden. Erst ganz kurz vor dem Ende der Totalität, um 20:50 Uhr, stieg der Mond über die Wolken. Für Fotos mit imposantem Vordergrund stand er da schon viel zu hoch am Himmel, aber für einige Minuten waren noch Bilder der kupferroten Scheibe möglich.

Da die Luft über der Stadt schon den ganzen Tag diesig war, gab es keine ganz klaren Motive für die rund 20 Fotografen. Und auch nicht für den einen Hobby-Astronomen, der per Sackkarre und großem Rucksack ein kleines Spiegelteleskop samt Stativ auf den Hügel befördert hatte. Die schönsten Bilder ergaben sich wetterbedingt, als der Mond knapp aus dem Kernschatten austrat und schon wieder einen hellen Fleck links unten zeigte. Es dauerte dann keine fünf Minuten, bis das Rot wieder von den hellen Reflektionen überstrahlt wurde. Dabei konnte man dann auch einem zunehmenden Mond zusehen, bei dem die Sichel falsch herum ist: links statt rechts.

Die nächste totale Mondfinsternis

Wer das Ereignis verpasst hat, könnte am 3. März 2026 Urlaub in Amerika oder Asien einplanen. In Deutschland gibt es die nächste Chance erst am 31. Dezember 2028.

(nie)