Skip to content
Artwork for Schlüsseltechnologie

Schlüsseltechnologie

Xyrillian Noises

Die IT hat unser Leben in den letzten Jahrzehnten von Grund auf verändert. Aber wie funktioniert sie wirklich? Das möchte ttimeless mal erklärt bekommen. Zum Glück hat Xyrill Antworten.

Play
  • 24 episodes
  • monthly
  • Avg 1 hr 8 min
  • German
Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • S1 · E78
    Sep 11, 2025 · 1 hr 4 min

    STP078: Common Weakness Enumeration (Teil 1)

    Nachdem wir kurz über Alex' Feedback gesprochen haben, soll es heute mal wieder um Sicherheit gehen; diesmal speziell darum, was Personen die Software schreiben beachten sollten, um die bekantesten Fallstricke sicher zu umgehen. Shownotes Rückbezug STP049: CVE-Datenbank für bekannte Sicherheitslücken in bestimmten Programmen (z.B. Heartbleed ist CVE-2014-0160) betrieben von dem privaten Forschungsinstitut Mitre Corporation auf Basis von Fördermitteln der US-Regierung April 2025: kurzzeitige Verwirrung nach Aussetzen des Fördervertrages, dann einen Tag später Kommando zurück (Pentaradio berichtete) neben CVE pflegt Mitre Corp. eine weniger bekannte Datenbank: CWE (Common Weakness Enumeration), ein Klassifizierungssystem für Arten von Sicherheitslücken wir besprechen die jährliche Rangliste der CWE Top 25 mit Stand von 2024 wertvoll, weil man so als interessierter Laie oder Programmierer-Generalist ein Gefühl für wichtige Angriffsvektoren bekommt Platz 1: CWE-79; fehlerhafte Neutralisierung von Eingaben während der Erzeugung von Webseiten ("Cross-Site Scripting", XSS) siehe Beispielbild im Link Webseiten können JavaScript-Code enthalten, der auf dem Browser des Endanwenders ausgeführt wird wenn Webseiten aus Eingaben anderer Benutzer zusammengebaut werden, können diese Code einschleusen Lösung: Escaping (Entfernen oder Ersetzen von Zeichen mit syntaktischer Bedeutung), kann durch Template Engines teilweise automatisiert werden passend dazu Platz 7: CWE-78; fehlerhafte Neutralisierung von Eingaben während der Erzeugung von Befehlszeilen außerdem Platz 13: CWE-77; dasselbe für alle anderen Befehlssprachen, die nicht JavaScript oder die System-Shell sind allgemeiner als Platz 12: CWE-20; unzureichende Überprüfung von Eingaben Lösung: "assume all input is malicious"; nur Eingaben akzeptieren, die strikten Formatvorgaben folgen (z.B. unter Einsatz von regulären Ausdrücken, siehe STP021) Platz 2, 6 und 20: CWE-787 und CWE-125; Schreiben bzw. Lesen außerhalb des allokierten Speicherbereichs ("Out-of-Bounds Write/Read") sowie als übergeordnete Kategorie CWE-119; allgemeiner Pufferüberlauf ("Buffer Overflow") und passend dazu Platz 8: CWE-416; Benutzung nach dem Freigeben ("Use after Free") alle bereits besprochen in STP047 Lösung: speichersichere Programmiersprachen, Speicherprofiling-Tools wie Valgrind (siehe STP076) Platz 3: CWE-89; SQL-Injektion SQL siehe STP012: Abfragesprache für relationale Datenbanksysteme Beispiel siehe XKCD 327 Lösung: Datenwerte von der Abfrage trennen (z.B. SELECT * FROM users WHERE name = 'Alice' -> SELECT * FROM users WHERE name = $1 mit Datensatz ["Alice"]) passend dazu Platz 11: CWE-94; Code-Injektion (dasselbe für Programmcode); Überlapp zu CWE-77 Platz 4: CWE-352; Cross-Site Request Forgery (CSRF) Angreifer möchte im Namen des Opfers eine Aktion ausführen (z.B. auf Rechnung des Opfers in einem Webshop bestellen) Angreifer schiebt dem Opfer ein manipuliertes HTML-Formular unter, dass beim Abschicken die gewünschte Aktion auslöst, aber mit den Cookies (und damit der Identität des Opfers) Lösung: CSRF-Tokens (echte HTML-Formulare erhalten ein einmalig nutzbares Token, dass nicht vom Angreifer gefälscht werden kann) passend dazu Platz 19: CWE-918; Server-Site Request Forgery (SSRF) dabei manipuliert der Angreifer nicht ein menschliches Opfer oder einen Webclient, sondern einen Webserver, mit seinem privilegierten Zugriff andere Webserver abzufragen Platz 5: CWE-22; Pfaddurchquerung ("Path Traversal") z.B. bei Webservern mit statischen Inhalten: entsprechende Dateien liegen im Dateisystem in einem bestimmten Ordner Dateien außerhalb dieses Ordners sollen eigentlich nicht zugreifbar sein, aber manchmal geht http://example.com/../../../etc/passwd oder dergleichen Lösung: magische Pfadelemente wie .. (bei Pfaden) oder / (bei Dateinamen) ablehnen Feedback zu STP063 Alex schreibt: danke für den Podcast. Ich bin wie immer weit im Rückstand mit Hören, habe zu Folge 63 aber mal die Turing-Maschine für die Subtraktion neu gebastelt. [...] Den Input muss man mit folgender 0 eingeben, also 1110110 z.B. Gebaut habe ich das auf https://turingmachinesimulator.com/. //---------------------------------------------------------------------- //Syntax: //-------CONFIGURATION name: sub init: q0 accept: qe //-------DELTA FUNCTION: //[current_state],[read_symbol] //[new_state],[write_symbol],[>|<|-] // < = left // > = right // - = hold // use underscore for blank cells q0,1 // 1en 1.Op überspringen q0,1,> q0,0 q1,0,> q1,0 // 0en überspringen q1,0,> q1,1 q2,1,> q2,0 // mehr als eine 1 im 2. Op? Ja->q5, nein->q3 q3,0,< q2,1 q5,1,> q5,1 // 1en 2.Op überspringen, dann auf letzte 1 des 2.Op q5,1,> q5,0 q6,0,< q6,1 // letzte 1 des 2. Op durch 0 ersetzen q7,0,< q7,1 // zurück, 1en 2. Op überspringen q7,1,< q7,0 q8,0,< q8,0 // zurück, 0en überspringen q8,0,< q8,1 // letzte 1 des 1. Op auf 0 setzen, zurück zu q1 q1,0,> q3,1 // letzte 1 des 2. Op auf 0 setzen q4,0,< q4,0 // zurück, 0en überspringen q4,0,< q4,1 // letzte 1 des 1.Op auf Null setzen, zum Ende qe,0,>

  • S1 · E77
    Aug 21, 2025 · 57 min

    STP077: Liste von Listen

    Als der inoffizielle Wikipedia-Vorlesepodcast sehen wir es als unsere Pflicht, eine Eigenheit dieser anzusprechen: nämlich Listen von Listen, obwohl es uns eigentlich um Listen im Speicher geht. Shownotes Rückbezüge: fundamentale Datenstrukturen siehe STP071: Felder/Listen, assoziative Datenfelder (Maps), Graphen Frage: Wie stellt man solche Datenstrukturen im Speicher dar? Gibt es darauf überhaupt die eine richtige Antwort? algorithmische Komplexität siehe STP029: Liste mit n Elementen ausdrucken in O(n), aber sortieren in O(n log(n)) bis O(n^2) Speicherallokation siehe STP047 und Speicherschutz siehe STP019: Bezug wird gleich klar werden Listen kann man als verkettete Liste darstellen klassisches Studienobjekt in Erstsemester-Datenstrukturen-Vorlesungen intuitiv verständlich: Parallele zu segmentierten Halsketten wahlweise einfach oder doppelt verkettet effiziente Operationen: Einfügen am Ende, Entfernen am Ende ineffiziente Operationen: Einfügen in der Mitte, Wahlzugriff/Suche Vergleichstabelle mit Darstellung der Zeiteffizienz alles in allem durchwachsene Performance -> geht es besser? alternative Strategie: interne Darstellung der Liste als balancierter Baum (oder evtl. "ausgeglichener Baum") außerdem Link auf die englische Wikipedia, die nicht nur unbalancierte, sondern auch balancierte Bäume zeigt kann nur sortierte Listen darstellen Idee: Wurzelknoten hat das Median-Element, dann der linke Ast alle kleineren und der rechte Ast alle größeren Elemente im Grunde alle gängigen Operationen mittelschnell: Wahlzugriff/Suche, Einfügen an beliebigen Stellen, Entfernen von beliebigen Stellen (Änderungen erfordern im Allgemeinen ein Austarieren des Baumes) große Variation von Implementationsstrategien für dieses Balancieren -> hier nicht verkettete Listen und balancierte Bäume sehen auf dem Papier ziemlich effizient aus, haben aber in ihrer reinen Form pathologisch schlechtes Speicherverhalten hoher Platzverbrauch: z.B. bei einfach bzw. doppelt verketteten Listen muss zu jedem Element müssen noch eine bzw. zwei Speicheradressen abgelegt werden hohe Allokationslast: wenn nicht eine Arena oder ein vergleichbarer Small Object Allocator verwendet wird schlechte Lokalität: beim Durchlaufen nachfolgender Elemente werden im schlimmsten Fall ständig unterschiedliche Speicherseiten getroffen, was fortlaufend Seitenfehler verursachen kann in der Praxis mit Abstand dominante Implementationsstrategie: dynamische Felder Beobachtung: Einfügen oder Löschen an beliebigen Stellen wird kaum gemacht; man hängt eher mehrmals ans Ende an und sortiert dann, falls nötig Idee: Optimieren auf Einfügen am Ende bei möglichst optimalen Speicherverhalten Umsetzung: einfaches Feld (ein fortlaufendes Stück Speicher, in dem mehrere Elemente hintereinander abgelegt werden) mit aktuellem Füllstand N und Kapazität K Einfügen ans Ende: normalerweise einfach N erhöhen; wenn N nicht in K passt, größeren Speicher reservieren, alles hinüberkopieren und die alten Speicherallokation verwerfen Löschen vom Ende: einfach N reduzieren, keine Deallokation erforderlich Einfügen am Anfang oder in die Mitte: alle Elemente dahinter nach hinten verschieben nahezu optimales Speicherverhalten von dynamischen Feldern begründet ihre Dominanz Platzverbrauch: neben der Speichergröße der Elemente selber nur zwei Zahlen (N und K) Allokationslast: Vergrößern geht für gewöhnlich in exponentiellen Schritten und wird damit für wachsende Listen immer seltener nötig Lokalität: lineare Suche durch die Liste geht linear durch den Speicher hindurch -> folgende Speicherseiten können vom Prozessor oft schon auf Verdacht vorgeladen werden trotzdem: die anderen Datenstrukturen haben auch ihre Berechtigung (z.B. modifizierte balancierte Bäume als Basis für Datenbank-Indizes) Xyrill will auch noch auf analoge Weise über Maps und Graphen reden -> weiter in STP079

  • S1 · E76
    Jul 31, 2025 · 58 min

    STP076: Debugging

    Die Zeiten, in denen wie von Grace Hopper "actual bugs" in Computern gefunden werden, sind wohl weitestgehend vorbei. Trotzdem ist Debugging bis heute eine Sache, um die man in der IT nicht herumkommt. Shownotes Wikipedia definiert den Begriff: Als Debuggen (dt. Entwanzen) oder Fehlerbehebung bezeichnet man in der Informatik den Vorgang, in einem Computerprogramm Fehler oder unerwartetes Verhalten zu diagnostizieren und zu beheben. Die Suche von Programmfehlern (sogenannten Bugs) ist eine der wichtigsten und anspruchsvollsten Aufgaben der Softwareentwicklung und nimmt einen großen Teil der Entwicklungszeit in Anspruch. Ein guter Programmierer muss daher auch das Debuggen beherrschen und umgekehrt: Nicht jeder gute Programmierer ist auch ein guter Debugger. Xyrill hat eine Anekdote: Firefox im Hotel-WLAN hängt beim Starten vier Minuten nicht dramatisch, könnte man auch hinnehmen (oder halt auf einen anderen Browser wechseln) Xyrill war aber in der Stimmung, zu debuggen Kategorie 1: Werkzeuge zum Mitlauschen traceroute (bzw. tracert unter Windows): Nachverfolgung der Netzwerkroute zu einem bestimmten Ziel anhand von Ping-Paketen mit begrenzter TTL; stark variable Pings oder plötzliche Anstiege des Pings deuten auf ein Problem an dem entsprechenden Hop hin tcpdump und Wireshark: Mitschneiden aller Netzwerkpakete, die über ein Netzwerk-Interface versendet oder empfangen werden (evtl. mit Suchmuster, z.B. "nur auf Port 80" oder "nur für Ziel-/Quelladresse 192.168.0.1") mitmproxy et al: Fangnetz für HTTP-Anfragen und -Antworten, die von einem Prozess geschickt und empfangen werden (quasi wie tcpdump, aber einige Netzwerkschichten höher); super zum Reverse-Engineering von webbasierten APIs mal nicht Netzwerk: strace listet alle Syscalls (Systemrufe) auf, die ein Prozess während seiner Lebenszeit macht (siehe Beispiel unten) zurück zum Hotel-WLAN-Beispiel: strace zeigt Timeout bei DNS-Anfrage zum eigenen Hostnamen jeweils 2x nach 120s Grund für diese Anfragen bleibt unklar, aber die Lösung ist eindeutig: expliziter Eintrag für den eigenen Hostnamen in /etc/hosts, um die DNS-Abfrage zu umgehen Kategorie 2: Werkzeuge zum Nachverfolgen printf-Debugging: im Programmcode vorrübergehend Befehle einbauen, die zu sinnfälligen Zeitpunkten Logmeldungen ausdrucken, insb. beinhaltend den aktuellen Zustand von bestimmten Variablen (sprich: transiente Form von Logging, siehe STP032) Debugger wie gdb: Ausführung eines Programms bis zum Moment des Crashs oder bis zu benutzerdefinierten Haltepunkten; dann schrittweise Ausführung bzw. Inspektion von Variablen (flexibler als printf-Debugging, aber erfordert direkten Zugriff auf den Prozess) Profiler wie valgrind: Ausführung eines Programms und währenddessen Erfassung von Statistiken zu Laufzeit- und Speichernutzung, um Speicherzugriffsfehler oder Ineffizienzen aufzudecken Kategorie 3: Werkzeuge zum Zurückverfolgen Bisektion z.B. mit git bisect: Aufspüren derjenigen Änderung in einem Versionsverwaltungssystem, die eine bestimmte Verhaltensänderung (z.B. einen Bug oder einen Performance-Einbruch) ausgelöst hat Beispiel einer strace-Ausgabe für den Befehl mv /tmp/foo /tmp/bar (stark verkürzt): $ strace mv /tmp/foo /tmp/bar execve("/usr/bin/mv", ["mv", "/tmp/foo", "/tmp/bar"], 0x7fff820357b0 /* 67 vars */) = 0 ... (ca. 60 Zeilen an Setup-Phase der libc und anderer Shared Libraries ausgelassen) ... ioctl(0, TCGETS, {c_iflag=ICRNL|IXON|IUTF8, c_oflag=NL0|CR0|TAB0|BS0|VT0|FF0|OPOST|ONLCR, c_cflag=B38400|CS8|CREAD, c_lflag=ISIG|ICANON|ECHO|ECHOE|ECHOK|IEXTEN|ECHOCTL|ECHOKE, ...}) = 0 renameat2(AT_FDCWD, "/tmp/foo", AT_FDCWD, "/tmp/bar", RENAME_NOREPLACE) = -1 EEXIST (File exists) openat(AT_FDCWD, "/tmp/bar", O_RDONLY|O_PATH|O_DIRECTORY) = -1 ENOTDIR (Not a directory) newfstatat(AT_FDCWD, "/tmp/foo", {st_mode=S_IFREG|0644, st_size=0, ...}, AT_SYMLINK_NOFOLLOW) = 0 newfstatat(AT_FDCWD, "/tmp/bar", {st_mode=S_IFREG|0644, st_size=0, ...}, AT_SYMLINK_NOFOLLOW) = 0 geteuid() = 1001 faccessat2(AT_FDCWD, "/tmp/bar", W_OK, AT_EACCESS) = 0 renameat2(AT_FDCWD, "/tmp/foo", AT_FDCWD, "/tmp/bar", 0) = 0 lseek(0, 0, SEEK_CUR) = -1 ESPIPE (Illegal seek) close(0) = 0 close(1) = 0 close(2) = 0 exit_group(0) = ? +++ exited with 0 +++

  • S1 · E75
    Jul 10, 2025 · 56 min

    STP075: Prozessorarchitekturen im Vergleich

    Nach einer sehr deutlichen Einordnung der Aufnahmezeit kommen wir im Wesentlichen zu den Unterschieden zwischen x86 und ARM. Natürlich wird auch geklärt, was das ist. Gegen Ende gibt es noch ein paar Meinungen und Weissagungen zum Thema KI. Shownotes Rückbezug STP011: grundsätzliche Beschreibung von Maschinensprache siehe Beispiel unter dem obenstehenden Link Maschinensprache ist spezifisch für die Prozessorarchitektur, genauer die Befehlssatzarchitektur (instruction set architecture, ISA) heutzutage relevante ISA x86: PCs, Notebooks, Server, Supercomputer, Apple Macs bis 2020 ARM: Smartphones, Tablets, Apple Macs seit 2020, Einplatinencomputer (SBC) wie Raspberry Pi Embedded: AVR, MIPS, etc. Hochleistungsrechnen: neben x86 noch Power und SPARC Neuentwicklungen: RISC-V, LoongArch Warum ist die Wahl der ISA wichtig? ISA beschreibt nominal, wie ein CPU die Bits in einer ausführbaren Binärdatei (sprich: die kodierte Form der Maschinensprache) zu interpretieren hat daraus als Konsequenz Festlegung von Hardware-Parametern wie der Adressbreite oder der Anzahl und Größe der verfügbaren Register Designentscheidungen in der ISA wirken sich auf die maximal erreichbare Performance und auf die Energieeffizienz aus klassischerweise Gegenüberstellung zweier verschiedener Design-Philosophien: Complex Instruction Set Computing (CISC) und Reduced Instruction Set Computing (RISC) (die Grenzen verschwimmen aber in der Praxis) historischerweise war CISC die Domäne großer CPU-Hersteller, die sich ein kompliziertes Design leisten konnten, um dem Programmierer Arbeit abzunehmen (z.B. Intel); und RISC die Domäne kleiner CPU-Hersteller, die aus möglichst wenig Arbeitseinsatz möglichst viel erreichen wollten Was steht in einem Maschinencode-Befehl drin? grundsätzlich eine Operation, die ausgeführt wird (z.B. "Addition zweier 64-Bit-Zahlen") als Quellen für Argumente und Ziel für das Ergebnis: entweder Register, Speicher oder Immediate-Argumente Beispiel CISC: 20 verschiedene Ausführungen des ADD-Befehls in x86-64 Beispiel RISC: 2 verschiedene Ausführungen des ADD- bzw. ADDI-Befehls in RISC-V (RV32I) wenn RISC wie bei RISC-V eine Load/Store-Architektur verwendet, muss man also im Zweifelsfall Argumente erst aus dem Speicher in Register laden dadurch tendenziell mehr Maschinencode, aber weniger Komplexität in der CPU Abwägungen zwischen Energieeffizienz (ARM) und Performance (x86) aktueller ARM-Befehlssatz (A64) hat durchgängig 4 Byte große Befehle, was das Dekodieren vereinfacht; x86-Befehle haben eine variable Breite zwischen 1 und 15 Byte x86 hat eine lange Pipeline, um u.a. die komplexen Befehle in kleinere Teilschritte (Micro-Operations) zu zerlegen oder bestimmte häufige Befehlssequenzen in effizientere Gruppen (Macro-Operations) zu fusionieren und damit die Performance zu steigern; ARM-Prozessoren machen das nicht und sparen dadurch Energieaufwand x86 hat für bestimmte Rollen designierte Spezialregister, die je nach Befehl feste Bedeutungen haben; ARM (und RISC allgemein) verwendet für fast alles 31 General-Purpose-Register

Showing 21–24 of 24 episodes