WEBVTT

00:00:00.000 --> 00:00:04.100
Ja hallo liebe Hörerinnen und Hörer, willkommen beim Python Podcast in der 26. Episode heute.

00:00:04.700 --> 00:00:08.400
Heute ist das Thema Security, ein Thema was ich persönlich sehr sehr spannend finde.

00:00:08.920 --> 00:00:12.500
Da haben wir natürlich auch wieder Gäste eingeladen, neben dem Jochen und mir, dem Dominik,

00:00:12.840 --> 00:00:15.880
sind heute wieder dabei der Christian, der Toini und der Philipp. Hallo Philipp!

00:00:16.500 --> 00:00:16.740
Hallo!

00:00:17.520 --> 00:00:20.820
Wie geht es euch? Stellt euch doch mal kurz vor, wer ihr denn seid und dann erzählen wir ein bisschen was über die Folge.

00:00:24.200 --> 00:00:26.600
Tja, wer fängt an? Also ich bin der Jochen.

00:00:26.600 --> 00:00:28.880
im Podcast.

00:00:29.160 --> 00:00:30.420
Das habt ihr mich wahrscheinlich schon

00:00:30.420 --> 00:00:31.280
einmal dabei gehabt.

00:00:31.700 --> 00:00:34.700
Also ich glaube, das brauche ich gar nicht weiter ausführen.

00:00:35.060 --> 00:00:36.460
Aber ich glaube, am interessantesten ist wahrscheinlich

00:00:36.460 --> 00:00:38.480
Philipp, der ist jetzt gerade zum ersten Mal dabei.

00:00:38.720 --> 00:00:38.880
Genau.

00:00:39.660 --> 00:00:42.500
Ich bin Philipp, ich habe bis vor kurzem

00:00:42.500 --> 00:00:44.160
noch an der Uni Düsseldorf

00:00:44.160 --> 00:00:46.200
studiert und nachher auch

00:00:46.200 --> 00:00:48.280
gelehrt zum Thema unter anderem auch Security.

00:00:48.520 --> 00:00:50.280
Also ich habe da die Vorlesung zur

00:00:50.280 --> 00:00:52.460
Internet Security, glaube ich.

00:00:52.460 --> 00:00:54.220
Oder wie haben sie sie genannt? Also Internet Security,

00:00:54.220 --> 00:00:54.840
einfach Security.

00:00:54.840 --> 00:00:57.620
die Security-Vorlesung gehalten.

00:00:57.820 --> 00:00:58.560
Netzwerk haben wir sie genannt.

00:00:59.300 --> 00:01:00.680
Also Netzwerksicherheit sieht sie offiziell.

00:01:02.040 --> 00:01:03.500
Und bin jetzt seit

00:01:03.500 --> 00:01:05.700
zweieinhalb Jahren arbeite ich für die Firma

00:01:05.700 --> 00:01:06.800
Boxine in Düsseldorf.

00:01:07.360 --> 00:01:08.980
Die ist wahrscheinlich bekannt durch ihr Produkt

00:01:08.980 --> 00:01:10.820
die Tonybox. Also wenn man keine Kinder hat,

00:01:10.900 --> 00:01:11.760
dann kennt man die Tonybox.

00:01:12.540 --> 00:01:13.820
Und genau die läuft auch mit Python.

00:01:14.060 --> 00:01:15.180
Vielleicht kommen wir da nochmal ein bisschen dazu.

00:01:16.560 --> 00:01:18.280
Oh cool, da haben wir letztens am Wochenende noch jemanden getroffen,

00:01:18.400 --> 00:01:19.620
der für die Firma arbeitet. Interessant.

00:01:20.160 --> 00:01:22.080
Ja, ja, ich habe mich letztes Wochenende genau mit Jens,

00:01:22.200 --> 00:01:23.900
deswegen kannst du dann wahrscheinlich auch lange unterhalten.

00:01:23.900 --> 00:01:25.540
Genau, der Jens ist auch in meinem Team. Jens ist auch

00:01:25.540 --> 00:01:27.640
einer von den Python-Entwicklern

00:01:27.640 --> 00:01:28.080
bei Boxine.

00:01:30.000 --> 00:01:31.280
Ja, die

00:01:31.280 --> 00:01:33.300
Tonybox ist super beliebt.

00:01:33.620 --> 00:01:34.800
Ja, dass es ein Python-Projekt geworden ist.

00:01:34.960 --> 00:01:37.660
Ihr kennt ja bestimmt, das sind diese kleinen Spielzeug-

00:01:37.660 --> 00:01:39.440
Figuren, die man auf eine Box stellt und dann

00:01:39.440 --> 00:01:41.380
spielen sie ein Hörspiel. Also für alle, die keine Kinder

00:01:41.380 --> 00:01:41.780
haben.

00:01:43.820 --> 00:01:45.560
Genau. Ja, schön. Also heute

00:01:45.560 --> 00:01:47.380
das Thema Security. Wir wollen das so ein bisschen aus

00:01:47.380 --> 00:01:49.440
mehreren Perspektiven beleuchten, die wir noch gar nicht

00:01:49.440 --> 00:01:51.500
so genau festgelegt haben. Sie immer, ich habe

00:01:51.500 --> 00:01:53.400
keine Ahnung, stell du mir Fragen. Und

00:01:53.400 --> 00:01:54.540
und die Jungs antworten ein bisschen.

00:01:55.360 --> 00:01:56.840
Ja, fangen wir doch direkt an.

00:01:57.600 --> 00:01:59.000
Was ist denn Sicherheit? Security?

00:01:59.300 --> 00:02:01.200
Was meint das denn? Also, dass

00:02:01.200 --> 00:02:02.920
niemand irgendwie einbricht und dann hat jemand irgendwie

00:02:02.920 --> 00:02:05.200
einen kaputten Pullover an und dann riecht dann so ein Rechner

00:02:05.200 --> 00:02:07.140
mit grüner Schrift und dunklem Monitor

00:02:07.140 --> 00:02:09.020
oder wie sieht das aus?

00:02:10.060 --> 00:02:11.200
Das trifft es wahrscheinlich schon ziemlich

00:02:11.200 --> 00:02:11.500
gut.

00:02:12.460 --> 00:02:15.000
Du möchtest Leute

00:02:15.000 --> 00:02:15.980
schützen davor,

00:02:15.980 --> 00:02:18.240
oder du möchtest

00:02:18.240 --> 00:02:19.940
Systeme schützen vor irgendwelchen

00:02:19.940 --> 00:02:22.100
Angreifern. Das ist das grundsätzliche Prinzip

00:02:22.100 --> 00:02:23.760
für Sicherheit. Du hast dann verschiedene Ziele.

00:02:24.500 --> 00:02:26.280
Ganz traditionell hat man die Integrität,

00:02:26.360 --> 00:02:27.600
dass ich sagen möchte, niemand möchte etwas ändern.

00:02:27.960 --> 00:02:29.540
Ich habe die Vertraulichkeit, dass ich sagen möchte,

00:02:29.620 --> 00:02:31.940
niemand soll rausfinden können,

00:02:32.020 --> 00:02:34.120
welche Daten meine Benutzer haben. Zum Beispiel bei uns

00:02:34.120 --> 00:02:36.160
beruflich bei der Tonybox. Auf die kann man

00:02:36.160 --> 00:02:37.960
ja beliebige Audio-Teilen draufspielen und es soll

00:02:37.960 --> 00:02:40.200
auf keinen Fall möglich sein, dass irgendjemand anders die Audio-Teilen

00:02:40.200 --> 00:02:41.660
von einem Kunden

00:02:41.660 --> 00:02:44.000
abrufen kann. Das wäre

00:02:44.000 --> 00:02:46.120
Vertraulichkeit. Und dann haben wir noch

00:02:46.120 --> 00:02:48.180
Ziele, die werden

00:02:48.180 --> 00:02:49.900
manchmal so Zuverlässigkeit genannt oder

00:02:49.900 --> 00:02:52.040
Availability, wo es halt

00:02:52.040 --> 00:02:53.960
darum geht, dass das System verfügbar

00:02:53.960 --> 00:02:54.560
ist die ganze Zeit.

00:02:55.960 --> 00:02:57.720
Okay, also schon irgendwas, was einen auch privat

00:02:57.720 --> 00:02:59.720
betreffen kann natürlich und vor dem man vielleicht

00:02:59.720 --> 00:03:00.540
geschützt werden möchte.

00:03:01.400 --> 00:03:03.780
Ja, und

00:03:03.780 --> 00:03:05.280
wie macht man das denn in Python?

00:03:08.360 --> 00:03:10.040
Ja, ich würde jetzt so spontan

00:03:10.040 --> 00:03:11.680
sagen, eigentlich hat man ja in Python schon mal ganz gute

00:03:11.680 --> 00:03:13.620
Karten, weil ein großer Teil der wirklich

00:03:13.620 --> 00:03:15.060
bösen Fehler, die einem da so

00:03:15.060 --> 00:03:17.560
begegnen können, hat man jetzt in Python

00:03:17.560 --> 00:03:19.600
eigentlich gar nicht. Also so mit Buffer-Overflows

00:03:19.600 --> 00:03:21.500
hat man eigentlich eher nicht so wirklich viel zu tun.

00:03:22.040 --> 00:03:24.080
Obwohl, jetzt eigentlich schon wieder, dem müsste ich erklären, was das ist.

00:03:24.260 --> 00:03:25.140
Oh nein, das wollte ich schon.

00:03:25.160 --> 00:03:28.120
Wir sind direkt eingeschrieben, du hast gesagt, man kann Fehler machen und das bedeutet,

00:03:28.560 --> 00:03:30.280
dass Fehler zu Sicherheitslücken

00:03:30.280 --> 00:03:32.140
führen können, die dann Angreifer ausnutzen können.

00:03:32.400 --> 00:03:33.980
Ist vielleicht einer der Punkte, über die wir vielleicht reden,

00:03:34.060 --> 00:03:36.220
welche Sicherheitslücken es denn gibt, aber was du sagst,

00:03:36.240 --> 00:03:37.980
heißt, es gibt Fehler, die jemand gemacht hat, also

00:03:37.980 --> 00:03:40.040
ein Entwickler, eine Entwicklerin gemacht hat, die

00:03:40.040 --> 00:03:41.560
dazu führen, dass es

00:03:41.560 --> 00:03:43.200
schwierig wird?

00:03:44.480 --> 00:03:46.020
Genau, das Programm macht dann irgendwas, was

00:03:46.020 --> 00:03:48.080
der Entwickler nicht gedacht hat. Also der Entwickler dachte sich,

00:03:48.180 --> 00:03:49.840
okay, da kommen doch immer gute Daten

00:03:49.840 --> 00:03:50.740
und dann hat

00:03:50.740 --> 00:03:56.300
und jemand mit einem grünen Bildschirm und einem Kapuzenpulli nachher herausgefunden,

00:03:56.380 --> 00:04:00.020
okay, wenn ich ganz bestimmte Daten sende, dann macht das Programm etwas, was der Entwickler nicht wollte

00:04:00.020 --> 00:04:05.820
und erlaubt mir dann Zugriff auf irgendwelche geheimen Daten oder im schlimmsten Fall erlaubt mir sogar Code auszuführen bei irgendjemand.

00:04:07.180 --> 00:04:10.000
Genau das wollen wir halt verhindern und da gibt es halt eine ganze Menge Schwachstellen,

00:04:10.140 --> 00:04:11.720
je nachdem auf welcher Plattform man ist.

00:04:12.760 --> 00:04:16.260
Also zum Beispiel auch mit Python gibt es Unterschiede natürlich, wenn ich einen Treiber schreibe,

00:04:16.740 --> 00:04:19.540
dann kann auch der erwähnte Buffer-Overflow vielleicht schon mal passieren.

00:04:19.540 --> 00:04:22.500
Wenn ich mit Python eher

00:04:22.500 --> 00:04:24.480
eine Web-Anwendung schreibe, dann muss ich mir da halt

00:04:24.480 --> 00:04:25.960
typische Sicherheitsblicken anschauen

00:04:25.960 --> 00:04:28.120
Aber das ist eigentlich immer, dass ich irgendwelche Eingaben

00:04:28.120 --> 00:04:30.200
des Benutzers nicht richtig

00:04:30.200 --> 00:04:32.760
interpretiere und dann plötzlich komische Sachen mache

00:04:32.760 --> 00:04:34.480
Benutzereingabe, Speicher, also Buffer, Overflow

00:04:34.480 --> 00:04:36.640
vielleicht nochmal ganz kurz, der Speicher

00:04:36.640 --> 00:04:38.800
läuft voll und dann kommt man in Bereiche rein

00:04:38.800 --> 00:04:40.280
die das Programm gar nicht vorgesehen hat

00:04:40.280 --> 00:04:42.760
und dann passieren komische magische Dinge

00:04:42.760 --> 00:04:44.060
Das ist dann diese Blackbox

00:04:44.060 --> 00:04:46.600
Mensch mit dem Kapuzzer-Kolore

00:04:46.600 --> 00:04:48.480
Naja, also ganz ganz kurz

00:04:48.480 --> 00:04:52.840
irgendwie, ja, ist auch eine relativ spezielle Art von Sicherheitsproblem, aber das gab

00:04:52.840 --> 00:04:56.460
irgendwann, ich glaube, das war dann Mitte der 90er, ich weiß nicht mehr so ganz genau, gab es einen Artikel

00:04:56.460 --> 00:05:00.660
im Frag Magazine von Aleph One

00:05:00.660 --> 00:05:04.020
irgendwie, Smashing the Stack for Fun and Profit und

00:05:04.020 --> 00:05:08.900
es betrifft vor allen Dingen die Programmiersprache C, die ist halt, das sind Strings

00:05:08.900 --> 00:05:12.660
Nullpointer terminiert und, naja,

00:05:12.660 --> 00:05:16.640
wenn man... Ach so! Genau, also da steht nicht

00:05:16.640 --> 00:05:19.100
anzuzwingen vorher dran, der ist jetzt so und so lang

00:05:19.100 --> 00:05:20.960
und dann liest man halt nur bis da,

00:05:21.100 --> 00:05:23.000
sondern man liest halt so lange, bis halt ein Nullbyte

00:05:23.000 --> 00:05:24.840
kommt und dann hört man halt auf damit.

00:05:24.960 --> 00:05:26.900
Oder halt eben auch nicht, wenn man irgendwie das

00:05:26.900 --> 00:05:28.980
falsch macht. Ah, das heißt, wenn man am Ende sagt, da sind gar

00:05:28.980 --> 00:05:30.780
keine Nullbytes, sondern sein eigener Code, dann liest er

00:05:30.780 --> 00:05:33.000
gar nicht, liest er es immer noch weiter. Genau, wenn man

00:05:33.000 --> 00:05:34.640
zum Beispiel einen festen Buffer definiert hat

00:05:34.640 --> 00:05:37.260
aber nicht überprüft,

00:05:37.320 --> 00:05:38.560
ob die Eingabe von dem Benutzer halt

00:05:38.560 --> 00:05:40.760
vielleicht länger ist, dann kann man halt über den Buffer

00:05:40.760 --> 00:05:42.740
hinwegschreiben unter Umständen.

00:05:43.100 --> 00:05:45.000
Und dann halt auch, also was man dann

00:05:45.000 --> 00:05:46.020
macht, man schreibt dann irgendwie eine Menge

00:05:46.020 --> 00:05:48.720
NOPS, was ist das?

00:05:48.880 --> 00:05:50.800
Irgendwas A oder so

00:05:50.800 --> 00:05:52.780
rein, hofft dann, dass

00:05:52.780 --> 00:05:54.840
beim Rücksprung aus der Funktion irgendwie

00:05:54.840 --> 00:05:56.840
man in diesem Bereich landet und dann rutscht

00:05:56.840 --> 00:05:59.160
es halt durch bis zu einem Shell-Code, den man mit reingeschrieben

00:05:59.160 --> 00:06:00.920
hat und dann kann man also im besten Fall

00:06:00.920 --> 00:06:02.840
irgendwie direkt das Programm

00:06:02.840 --> 00:06:03.560
komplett übernehmen.

00:06:05.180 --> 00:06:05.900
Das war

00:06:05.900 --> 00:06:07.920
lange Zeit,

00:06:08.040 --> 00:06:10.840
viel Server-Software hatte

00:06:10.840 --> 00:06:13.100
diese Fehler und man konnte das halt ausnutzen.

00:06:14.080 --> 00:06:14.960
Obwohl, ich meine, heute spielt

00:06:14.960 --> 00:06:18.060
ist vielleicht auch immer noch eine Rolle, vielleicht eher so bei Clients, ich glaube Server,

00:06:18.820 --> 00:06:20.740
obwohl es gibt es vielleicht immer noch, ich weiß es nicht mehr so genau,

00:06:20.980 --> 00:06:21.960
ich habe auch lange nicht mehr drauf geguckt,

00:06:22.940 --> 00:06:27.100
aber das ist eigentlich genau so das, was sich Leute vielleicht vorstellen,

00:06:27.420 --> 00:06:33.840
wenn man davon redet, dass jetzt irgendwie irgendwelche Server gehackt werden oder so.

00:06:34.540 --> 00:06:36.940
Man gibt irgendwas ein oder führt ein Programm aus

00:06:36.940 --> 00:06:38.400
und dann hat man eine Shell auf einem anderen System,

00:06:38.620 --> 00:06:41.020
wo man einfach Code ausführen kann oder beliebige Kommandos.

00:06:41.020 --> 00:06:45.080
Da kann man auch tatsächlich sozusagen diese Perspektiven von

00:06:45.080 --> 00:06:49.060
man muss halt, da kann man nochmal einen ganzen Schritt zurückgehen, weil im Prinzip

00:06:49.060 --> 00:06:52.640
das Thema Sicherheit kann man noch weiter aufmachen

00:06:52.640 --> 00:06:57.480
wenn ich halt, Philipp hat gesagt Anwenderinput

00:06:57.480 --> 00:07:01.540
das ist so ein, das muss oder kann man noch weiter abstrahieren, weil

00:07:01.540 --> 00:07:05.660
im Prinzip sind Viren halt auch nichts anderes als Anwenderinput

00:07:05.660 --> 00:07:09.360
Das ganze Thema von Security

00:07:09.360 --> 00:07:14.600
und die Programme, die man nicht will,

00:07:15.680 --> 00:07:18.920
lässt sich halt stark darauf zurückführen,

00:07:19.020 --> 00:07:20.300
dass wir halt eine sogenannte

00:07:20.300 --> 00:07:21.420
von-Neumann-Architektur haben.

00:07:22.060 --> 00:07:23.420
Das geht halt zurück auf die,

00:07:23.660 --> 00:07:24.980
was weiß ich jetzt, gar nicht mehr.

00:07:25.600 --> 00:07:26.680
Mir wurde mal vorher erworfen,

00:07:26.740 --> 00:07:27.600
Opa redet vom Krieg,

00:07:27.660 --> 00:07:28.680
aber da war ich nicht dabei.

00:07:30.060 --> 00:07:32.420
60er, 70er, irgendwo da, noch älter,

00:07:32.560 --> 00:07:35.240
40er, von-Neumann-Architektur, noch älter.

00:07:35.380 --> 00:07:38.120
Das war vor dem Zweiten Weltkrieg wahrscheinlich sogar.

00:07:39.360 --> 00:07:46.980
und irgendwo da, also als es so richtig losging gerade erst mit den ganzen allgemeinen Rechenmaschinen

00:07:46.980 --> 00:07:55.700
und die Von-Neumann-Architektur hat halt ein wichtiges Konzept und das ist halt, dass der Programmspeicher mit der Datenspeicher einzeln.

00:07:56.760 --> 00:08:06.440
Es gab früher Rechnerarchitekturen, da waren Daten von der Eingabe und die Daten, die den Prozessor gesteuert haben,

00:08:06.440 --> 00:08:08.560
also das Programm, komplett getrennt

00:08:08.560 --> 00:08:10.420
macht halt das

00:08:10.420 --> 00:08:12.280
große Problem, dass du nicht einfach

00:08:12.280 --> 00:08:14.500
irgendwie Programme als Daten runterladen

00:08:14.500 --> 00:08:16.400
und ausführen kannst, also der Effekt, den wir dadurch

00:08:16.400 --> 00:08:18.340
haben von der Neumann Architektur ist ja, ich kann ins Internet

00:08:18.340 --> 00:08:20.080
gehen, kann mir Daten runterladen

00:08:20.080 --> 00:08:22.400
und die dann als Programm ausführen, das Problem ist

00:08:22.400 --> 00:08:22.720
aber

00:08:22.720 --> 00:08:26.120
der Vorteil ist gleichzeitig der Nachteil, das heißt

00:08:26.120 --> 00:08:28.360
auch Daten, die vielleicht gar nicht als Programm

00:08:28.360 --> 00:08:30.140
gedacht waren, werden als

00:08:30.140 --> 00:08:32.380
Programm ausgeführt und das ist sozusagen die ganze

00:08:32.380 --> 00:08:34.260
Krux da dran, dass die CPU

00:08:34.260 --> 00:08:36.160
schon nicht unterscheiden kann von

00:08:36.160 --> 00:08:38.840
sind die Bytes bei mir gerade

00:08:38.840 --> 00:08:40.860
gedacht für, ich soll mit ihnen rechnen

00:08:40.860 --> 00:08:42.600
oder ich soll damit meinen

00:08:42.600 --> 00:08:44.280
Instruction Pointer befüttern.

00:08:44.900 --> 00:08:46.640
Das kannst du halt, da gibt es ein

00:08:46.640 --> 00:08:48.740
dieses Grundproblem wird never ever

00:08:48.740 --> 00:08:50.860
jemals weggehen. Das geht nie weg.

00:08:51.880 --> 00:08:52.860
Na gut, also

00:08:52.860 --> 00:08:54.660
moderne CPUs haben ja durchaus

00:08:54.660 --> 00:08:56.320
einige Verteidigungen dagegen.

00:08:56.760 --> 00:08:58.700
Moderne CPUs haben einen Marker, wo

00:08:58.700 --> 00:09:00.900
drin steht, okay, diese Speicherseite

00:09:00.900 --> 00:09:01.880
ist ausfüllbar oder nicht.

00:09:02.560 --> 00:09:04.660
Das geht ja dann schon in Richtung

00:09:04.660 --> 00:09:06.720
der konkurrierenden Harvard-Architektur ein bisschen, dass man sagt,

00:09:06.820 --> 00:09:09.480
okay, das sind die Daten, das sind die Instruktionen.

00:09:10.500 --> 00:09:10.860
Aber

00:09:10.860 --> 00:09:12.480
natürlich gibt es immer noch Tricks. Also selbst bei den

00:09:12.480 --> 00:09:14.760
Buffer-Overflows gibt es halt

00:09:14.760 --> 00:09:15.940
sehr, sehr viele Möglichkeiten,

00:09:17.020 --> 00:09:18.320
wie man genau

00:09:18.320 --> 00:09:20.900
dann doch irgendwie noch ein Programm

00:09:20.900 --> 00:09:22.900
konstruieren kann, das halt eigentlich nur aus Daten besteht.

00:09:23.180 --> 00:09:25.020
Also wo du sagst, okay, das sind eigentlich nur Daten,

00:09:25.540 --> 00:09:26.920
aber die auf

00:09:26.920 --> 00:09:28.820
komischen Stellen liegen und dann trotzdem den

00:09:28.820 --> 00:09:29.980
Programmfluss irgendwie beeinflussen.

00:09:30.680 --> 00:09:32.760
Ich wollte eigentlich zu dieser Frage

00:09:32.760 --> 00:09:34.780
mit den, was machen denn die CPUs dann da falsch?

00:09:35.320 --> 00:09:36.660
Kannst du zum Schluss kommen? Ihr habt ja jetzt damit

00:09:36.660 --> 00:09:37.340
den Einstieg gefunden.

00:09:37.500 --> 00:09:40.920
Das ist die unterste Ebene, auf der wir jetzt

00:09:40.920 --> 00:09:42.620
anfangen. Ich finde das aber sehr spannend, weil was du

00:09:42.620 --> 00:09:44.660
sagtest, dass diese unterschiedlichen Architekturen,

00:09:44.780 --> 00:09:46.580
also ich glaube, von Neumann nennt man auch irgendwie

00:09:46.580 --> 00:09:48.720
Princeton-Architektur und ich glaube, es war irgendwie,

00:09:48.860 --> 00:09:50.580
ich habe gerade nachgeguckt, 1945, als

00:09:50.580 --> 00:09:52.680
sie rausgekommen ist und diese

00:09:52.680 --> 00:09:54.720
Harvard-Architektur, die daneben liegt, die macht

00:09:54.720 --> 00:09:56.460
halt diese Getrennung von Daten und

00:09:56.460 --> 00:09:58.480
Programmspeicher und du sagst jetzt, es gibt

00:09:58.480 --> 00:10:00.740
auf dem CPU, also der CPU

00:10:00.740 --> 00:10:02.400
benutzt für alle Menschen, die

00:10:02.400 --> 00:10:03.260
vielleicht nicht so drin ist,

00:10:04.060 --> 00:10:06.360
Opcodes, also Operation Codes,

00:10:06.440 --> 00:10:08.160
das heißt, die sagen, was für eine Rechenoperation

00:10:08.160 --> 00:10:10.320
der machen soll, der Kern,

00:10:10.660 --> 00:10:12.240
und dann macht der genau mit den Daten,

00:10:12.280 --> 00:10:13.340
die ihm dazugeschickt werden,

00:10:13.340 --> 00:10:15.560
in den einzelnen, was sind das,

00:10:15.640 --> 00:10:17.200
Stacks? Nein, Registern.

00:10:17.920 --> 00:10:18.900
Macht der dann diese Operation

00:10:18.900 --> 00:10:20.700
und

00:10:20.700 --> 00:10:22.420
da kann was schief gehen.

00:10:23.620 --> 00:10:25.300
Philipp, vielleicht kannst du das noch ein bisschen

00:10:25.300 --> 00:10:26.940
erklären, weil das klingt ja sehr spannend.

00:10:28.980 --> 00:10:29.280
Ja, weil

00:10:29.280 --> 00:10:31.240
wenn ich einen ganz klassischen Buffer-Overflow habe,

00:10:31.240 --> 00:10:39.840
und der Angeber gibt eine längere Datenfolge an.

00:10:40.280 --> 00:10:43.700
Und wie wir eben schon erwähnt haben, da könnten dann zum Beispiel verschiedene Instruktionen wie

00:10:43.700 --> 00:10:48.100
Nobcodes drin vorkommen. Und das sieht aus wie

00:10:48.100 --> 00:10:50.820
normaler Text, aber das ist halt genauso

00:10:50.820 --> 00:10:55.420
designt, dass man das auch als Obcodes für die CPU interpretieren kann.

00:10:55.980 --> 00:11:00.160
Und genau das ist das Problem danach, dass der Entwickler dachte, okay, da kommt einfach nur Text

00:11:00.160 --> 00:11:04.120
rein, aber in Wirklichkeit hat der Angreifer den Text so geschickt konstruiert, dass er ein

00:11:04.120 --> 00:11:05.160
gültiges Programm ist.

00:11:05.880 --> 00:11:12.020
Und es ist sozusagen, wir können für die CPU, weil das konkret zu machen ist häufig sehr schwer

00:11:12.020 --> 00:11:15.280
so im Luftlernraum, aber weswegen ich schnell zur

00:11:15.280 --> 00:11:20.120
Neumann-Architektur gegangen bin, ist, das Problem ist ein ganz grundsätzliches

00:11:20.120 --> 00:11:24.000
Architekturproblem und die Features, die wir jetzt da oben

00:11:24.000 --> 00:11:27.180
drüberlegen, wie zum Beispiel non-executable pages und so ein Kram,

00:11:27.180 --> 00:11:30.040
oder was dann halt auf anderen Ebenen kommt

00:11:30.040 --> 00:11:33.840
Address Randomization und so ein Zeug.

00:11:35.080 --> 00:11:36.960
Das sind alles bloß

00:11:36.960 --> 00:11:39.380
kleine Trostpflaster

00:11:39.380 --> 00:11:43.480
und man macht es den Angreifern schwerer und teilweise auch

00:11:43.480 --> 00:11:46.500
um Größenordnungen schwerer dagegen anzukommen,

00:11:46.500 --> 00:11:49.680
aber das Restrisiko kann in der Architektur

00:11:49.680 --> 00:11:52.700
halt nie weggehen. Sie wird nie weggehen und die Effekte,

00:11:52.780 --> 00:11:55.420
die wir aber sehen, lassen sich auf anderen Ebenen genauso

00:11:55.420 --> 00:12:01.780
wieder erklären und ein Buffer-Overflow lässt sich gut vergleichen und das ist für viele Leute wieder einfacher vorstellbar

00:12:01.780 --> 00:12:08.060
wie mit einer SQL-Injection. Das ist genau das gleiche. Eine SQL-Injection ist, gib hier bitte deinen Namen ein

00:12:08.060 --> 00:12:13.680
und dann kommt das berühmte, mein Name ist Bobby, bla bla bla, Semikolon, Drop Tables.

00:12:15.260 --> 00:12:22.620
Und auch da ist es so, das Programm hat gedacht, ich habe eine Eingabe und die Datenbank haut dann aber einmal

00:12:22.620 --> 00:12:25.740
und sagt, das ist doch jetzt die nächste Query hier.

00:12:26.360 --> 00:12:28.500
Weil wir drücken ja alles als Text aus.

00:12:28.720 --> 00:12:34.600
Der Name ist Text und das Programmierstatement für die SQL-Datenbank ist auch nur Text

00:12:34.600 --> 00:12:37.040
und wird dann aber eben als Programm interpretiert.

00:12:37.460 --> 00:12:41.100
Und wenn ich das eben nicht richtig escape an der Stelle,

00:12:41.920 --> 00:12:46.660
dann finden solche Modusübergänge statt, wo etwas, was eigentlich als Eingabe zu verarbeiten gewesen wäre.

00:12:46.660 --> 00:12:49.480
Und der Trick ist ja eben der von Neumann Architektur,

00:12:49.480 --> 00:12:57.820
das SQL-Statement, was ich an den Server drücke, ist ja aus Serverperspektive erst mal Daten,

00:12:58.340 --> 00:13:00.100
die als Programm zu interpretieren sind.

00:13:00.200 --> 00:13:03.340
Und wenn darin halt Mist stattfindet, dann geht da alles quer durcheinander.

00:13:05.500 --> 00:13:07.620
Und das ist in Buffer-Overflow im Prinzip nichts anderes.

00:13:07.980 --> 00:13:12.960
Also das Glas Milch, das zu voll ist und dann tropft das auf die Erde und dann hat man alles nass und denkt sich, oh nein.

00:13:13.740 --> 00:13:14.080
Ja, genau.

00:13:14.840 --> 00:13:17.820
Buffer-Overflow ist sozusagen die Variante von, das Glas ist zu voll.

00:13:17.820 --> 00:13:19.880
und auch Python schützt einen

00:13:19.880 --> 00:13:21.820
vor sowas im Prinzip erstmal nur

00:13:21.820 --> 00:13:23.840
im Sinne von, ja Python selber gibt sich extrem

00:13:23.840 --> 00:13:25.560
viel Mühe selber keinen Mist zu machen,

00:13:26.080 --> 00:13:27.960
wenn du aber, und ich hab mit sowas halt selber

00:13:27.960 --> 00:13:29.740
auch, also ich sag immer,

00:13:29.800 --> 00:13:32.040
ich fass C nur dann an, wenn die anderen es verrissen haben.

00:13:32.580 --> 00:13:33.880
Ich schreib nie C-Code

00:13:33.880 --> 00:13:35.800
neu. Ich hab den C-Code nur in der Hand,

00:13:35.880 --> 00:13:38.020
wenn die anderen es völlig kaputt gemacht haben

00:13:38.020 --> 00:13:39.880
und ich gerade so noch weiß, wie ich es mir ganz mache.

00:13:40.960 --> 00:13:42.080
Der Pleiko-PG

00:13:42.080 --> 00:13:43.980
ist zum Beispiel halt im Datenbankumfeld,

00:13:45.360 --> 00:13:46.760
da merkt man so,

00:13:46.760 --> 00:14:16.740
und das ist ein bisschen

00:14:16.760 --> 00:14:46.740
und die Programmiersprache Python.

00:14:46.760 --> 00:15:05.100
haben ein Minuszeichen drin. ISO 8501 und so Kram. Und im Psycho-PG ist es so, dass der Encoding-Buffer tatsächlich davon ausgeht, dass da ein Minus drin ist und sie meinten, es wäre eine gute Idee, sie müssen alles normieren und die Minusse rausnehmen.

00:15:05.100 --> 00:15:06.500
und das ist im Postgres auch okay.

00:15:07.100 --> 00:15:11.100
Der hat die ganzen Encoding-Namen auch immer noch mit ohne Minus rumliegen

00:15:11.100 --> 00:15:14.840
und ein Kunde von uns kam aber dann damals auf die Idee,

00:15:15.180 --> 00:15:19.940
es gibt in Postgres einen Alias für UTF-8, der heißt Unicode.

00:15:22.300 --> 00:15:25.540
So, und dann hat der Psycho halt gesagt, na jetzt kommt hier ein Encoding-Name,

00:15:25.540 --> 00:15:32.200
also streiche ich das Minus raus, also ziehe einen neuen Buffer, der genau ein Byte kürzer ist

00:15:32.200 --> 00:15:39.500
und schreibt dann Unicode ohne Minus in einen statt, was haben es, U-N-I-C-O-D-E,

00:15:39.600 --> 00:15:42.400
in einen 6-Byte langen Buffer statt in einen 7-Byte langen Buffer.

00:15:42.960 --> 00:15:45.080
Und weil sie aber nicht einfach nur malloc benutzt haben,

00:15:45.180 --> 00:15:48.480
weil ganz kleine Objekte zu alloziieren im Speicher halt ineffizient sein kann,

00:15:48.600 --> 00:15:50.740
hat Python einen sogenannten Small Object Allocator.

00:15:51.760 --> 00:15:54.820
Damit kann ich eine Page, die ist typischerweise ein K oder sowas,

00:15:54.820 --> 00:15:57.340
je nachdem, das System kann ja auch ein Megabyte oder größer sein,

00:15:57.420 --> 00:15:59.460
aber gehen wir mal von einem K aus oder 4K,

00:15:59.460 --> 00:16:05.920
und dann packt Python halt solche 6-Byte-Objekte alle zusammen in eine Page

00:16:05.920 --> 00:16:19.040
und dann brauche ich halt statt 200 Pages, also statt 200k nur 1k,

00:16:20.120 --> 00:16:22.000
die werden eng an eng hintereinander gepackt

00:16:22.000 --> 00:16:28.640
und was dann passiert ist, ist, dass der Server, der das hatte, so alle Woche mal gecrashed ist.

00:16:29.460 --> 00:16:54.440
und ich habe das halt versucht rauszufinden und irgendwann habe ich da mit, ich glaube, ich habe mit Guido mal reingeguckt, ich habe mit Martin von Löwis reingeguckt, mit ein paar Leuten und irgendwann haben wir festgestellt, der schreibt dann halt manchmal genau auf den letzten Eintrag in dieser Page dieses eine Byte zu viel und das eine Byte zu viel in einer sogenannten Arena im Small Object Allocator ist der Pointer auf die nächste Arena.

00:16:54.440 --> 00:16:57.860
und der landet dann halt im Nirvana

00:16:57.860 --> 00:16:59.740
und dann gibt es halt einen Zagfault

00:16:59.740 --> 00:17:02.540
und dann sagt das Linux halt, so geht es hier nicht.

00:17:03.820 --> 00:17:05.320
Und das ist ein typisches Beispiel für,

00:17:05.360 --> 00:17:07.160
da hat jemand dann einen zu kleinen Buffer alloziiert,

00:17:07.260 --> 00:17:08.340
das ist dann ein Buffer-Overflow,

00:17:08.440 --> 00:17:10.600
er schreibt mehr Daten rein, als da reingehören,

00:17:11.120 --> 00:17:12.840
weil er sich einfach bloß verrechnet hat

00:17:12.840 --> 00:17:15.000
und der Effekt muss noch nicht sein,

00:17:15.040 --> 00:17:16.200
dass jemand Code ausführen kann,

00:17:16.320 --> 00:17:17.960
aber der Effekt ist halt typischerweise,

00:17:17.960 --> 00:17:19.280
dass das Programm anfängt Müll zu machen

00:17:19.280 --> 00:17:21.340
und dann haben wir, Philipp hat da ja auch genickt,

00:17:21.700 --> 00:17:23.420
schon mal die Availability, die Verfügbarkeit

00:17:23.420 --> 00:17:26.440
von der Anwendung reduziert und das ist ein Sicherheitsproblem tatsächlich auch.

00:17:27.300 --> 00:17:31.380
Genau, es könnte auch dann sein, dass das nachher auf dem Server irgendwo läuft, wo dein Postgres läuft und das kann

00:17:31.380 --> 00:17:35.560
vielleicht auch jemand, den Server möchtest du für viele Kunden bereitstellen und dann

00:17:35.560 --> 00:17:39.260
ist es auch richtig kritisch, wobei hoffentlich niemand dein Encoding im Server

00:17:39.260 --> 00:17:41.860
steuern kann, das wäre wahrscheinlich eine andere Sicherheitslücke.

00:17:42.480 --> 00:17:47.380
Ja, aber also Denial of Service ist halt, das ist böser, als die meisten Leute so

00:17:47.380 --> 00:17:51.460
zunächst vermuten würden. Ich meine, wir hatten ja jetzt auch letztens irgendwann in Düsseldorf an der Uniklinik

00:17:51.460 --> 00:17:53.240
ja auch so einen eher gemeinen Fall.

00:17:53.540 --> 00:17:55.220
Irgendwie so diese

00:17:55.220 --> 00:17:57.520
Ransomware-Geschichten, die es da gibt. Ich weiß nicht, das war

00:17:57.520 --> 00:17:59.420
irgendeine Remote-Verwaltungssoftware.

00:17:59.560 --> 00:18:00.780
Ich weiß nicht, den Namen wieder vergessen.

00:18:01.300 --> 00:18:02.380
Citrix. Citrix, genau.

00:18:03.520 --> 00:18:05.540
Irgendeine uralte Version davon und dann ist

00:18:05.540 --> 00:18:07.520
irgendjemand hingegangen und hat denen ihre Daten verschlüsselt

00:18:07.520 --> 00:18:09.540
oder so und hat sie erpresst. Und da ist

00:18:09.540 --> 00:18:11.300
glaube ich dann tatsächlich auch jemand bei gestorben oder so.

00:18:11.440 --> 00:18:13.000
Das war irgendwie sehr unschön.

00:18:14.460 --> 00:18:14.540
Ja.

00:18:15.520 --> 00:18:17.480
Das ist dann auch der Teil, den

00:18:17.480 --> 00:18:19.220
grenzt man in der Security manchmal ab.

00:18:19.320 --> 00:18:21.440
Im Englischen ist es halt...

00:18:21.460 --> 00:18:23.260
Ja, das ist im Deutschen, haben wir das sozusagen

00:18:23.260 --> 00:18:25.200
nicht getrennt. Ich finde das eigentlich so

00:18:25.200 --> 00:18:27.780
ein schönes Beispiel, dass

00:18:27.780 --> 00:18:29.480
Konzepte

00:18:29.480 --> 00:18:31.580
mit extra Begriffen in anderen

00:18:31.580 --> 00:18:33.380
Sprachen einem nochmal einen neuen Blick liefern,

00:18:33.980 --> 00:18:35.580
dass Sicherheit im Englischen halt mit

00:18:35.580 --> 00:18:37.640
Security und mit Safety übersetzt

00:18:37.640 --> 00:18:39.000
werden kann. Und Safety ist halt die

00:18:39.000 --> 00:18:41.800
auf Menschenleben und körperliche Unversehrtheit

00:18:41.800 --> 00:18:43.820
bezogene Perspektive

00:18:43.820 --> 00:18:45.640
von Sicherheit. Und Security ist

00:18:45.640 --> 00:18:47.240
halt die Frage, ob das Fahrrad noch da ist.

00:18:48.120 --> 00:18:49.620
Aber kannst du das denn in der modernen Gesellschaft

00:18:49.620 --> 00:18:50.580
wirklich auseinanderhalten?

00:18:50.580 --> 00:18:53.020
Ja, das ist halt sozusagen genau das Thema,

00:18:53.300 --> 00:18:53.600
dass man,

00:18:55.060 --> 00:18:57.080
damit machen wir jetzt einen schönen nächsten Bogen,

00:18:57.440 --> 00:18:59.300
dass Security extrem kontextspezifisch ist.

00:19:01.000 --> 00:19:02.780
Sie stellen mir gerade die Gesichtsbemalung vor,

00:19:02.880 --> 00:19:05.160
die dazu führt, dass die Kamera den Algorithmus

00:19:05.160 --> 00:19:07.160
verändert und ein anderes Gesicht immer in die

00:19:07.160 --> 00:19:11.100
Daten erkennen lässt und dann

00:19:11.100 --> 00:19:12.860
kann ich mich tarnen mit einer

00:19:12.860 --> 00:19:14.820
gewissen Schminke und als jemand anderes ausgeben.

00:19:15.260 --> 00:19:16.420
Weil der Algorithmus dadurch

00:19:16.420 --> 00:19:19.060
denkt, ich bin jemand anderes, weil ich einen anderen Gesichtshash bekomme

00:19:19.060 --> 00:19:19.400
oder so.

00:19:20.580 --> 00:19:22.680
Das ist der Fun in dem ganzen Machine Learning Umfeld,

00:19:22.760 --> 00:19:24.320
dass du diese Adversarial Models hast,

00:19:24.740 --> 00:19:26.220
dass du sozusagen auf der einen Seite

00:19:26.220 --> 00:19:28.480
ein Model haben kannst, was Dinge

00:19:28.480 --> 00:19:30.380
erkennt und jemand anderes weiß aber, wie er

00:19:30.380 --> 00:19:32.740
auf Basis eines Models

00:19:32.740 --> 00:19:34.880
Outputs generiert,

00:19:35.120 --> 00:19:36.540
die dieses Model dann

00:19:36.540 --> 00:19:37.700
wieder aus dem Takt bringen.

00:19:38.620 --> 00:19:40.420
Ja, nur für seinen Social Score oder sowas kann man den dann

00:19:40.420 --> 00:19:41.580
hochhalten, obwohl man andere Sachen...

00:19:41.580 --> 00:19:46.460
Die Ecke von Philipp fand ich

00:19:46.460 --> 00:19:48.380
jetzt nochmal wichtig und spannend, dass

00:19:48.380 --> 00:19:50.480
halt dieses Thema, ah, hier passiert ja

00:19:50.480 --> 00:19:51.060
nichts Schlimmes.

00:19:52.220 --> 00:19:54.200
Das Interessante ist eben, durch dieses

00:19:54.200 --> 00:19:56.520
Architekturproblem trifft es halt

00:19:56.520 --> 00:19:58.440
alle und jeden. Also jedes Stückchen Code, was du

00:19:58.440 --> 00:20:00.080
schreibst und mit dem großen Problem

00:20:00.080 --> 00:20:02.160
Dual Use, du weißt halt nie,

00:20:02.580 --> 00:20:04.500
wofür wird Code halt mal eingesetzt werden.

00:20:05.060 --> 00:20:06.460
Den schreibt man jetzt und der ist

00:20:06.460 --> 00:20:08.540
da und ganz ehrlich, Leute, die Code

00:20:08.540 --> 00:20:09.780
finden, werden ihn benutzen.

00:20:10.700 --> 00:20:12.620
Er wird irgendwo benutzt werden

00:20:12.620 --> 00:20:14.420
und er wird für Dinge benutzt werden,

00:20:14.420 --> 00:20:15.680
die man sich nicht vorgestellt hat.

00:20:16.680 --> 00:20:18.360
Wobei ich da auch immer eine Lanze dafür breche,

00:20:18.440 --> 00:20:20.320
zu sagen, naja, der, der den Code in den

00:20:20.320 --> 00:20:22.060
Context einführt, hat

00:20:22.060 --> 00:20:24.340
die Verantwortung sicherzustellen, dass er

00:20:24.340 --> 00:20:25.240
da was Sinnvolles tut.

00:20:25.940 --> 00:20:28.660
Dann macht er ein

00:20:28.660 --> 00:20:29.920
Projekt mit NPM-Paketen.

00:20:30.560 --> 00:20:32.220
Genau, aber das ist

00:20:32.220 --> 00:20:34.180
deren Verantwortung.

00:20:34.380 --> 00:20:36.600
Es ist nicht die Verantwortung von jemandem,

00:20:36.760 --> 00:20:38.500
es gibt im Open-Source-Umfeld, kann man ja auch

00:20:38.500 --> 00:20:40.460
viel da nochmal drüber reden,

00:20:40.560 --> 00:20:42.280
über die Motivation von Leuten, die halt so

00:20:42.280 --> 00:20:44.240
Open-Source-Packages maintainen, die dann

00:20:44.240 --> 00:20:46.140
ein riesen Schwergewicht kriegen. Ich finde,

00:20:46.200 --> 00:20:48.300
die Leute haben keine moralische Verpflichtung

00:20:48.300 --> 00:20:50.120
anderen gegenüber, aus ihrem

00:20:50.120 --> 00:20:53.240
Freizeitprojekt, wo sie sagen, da steckt einfach nur meine Lust und meine

00:20:53.240 --> 00:20:58.420
persönliche Motivation drin, anderen Garantien auszusprechen, dass sie damit

00:20:58.420 --> 00:21:00.100
jetzt einen Space Shuttle betreiben können.

00:21:00.100 --> 00:21:03.740
Das darf man so nicht umdrehen.

00:21:05.360 --> 00:21:07.620
Und nichtsdestotrotz ist es natürlich

00:21:07.620 --> 00:21:12.120
ein etwas zusammengeschimmertes

00:21:12.120 --> 00:21:16.060
kleines Raumschiff, was immer droht auseinanderzufallen, was auf der einen Seite mit Kohle und auf der anderen

00:21:16.060 --> 00:21:17.600
Seite mit einem Handpedal betrieben wird

00:21:17.600 --> 00:21:19.920
und kann also genau weiß, wo denn jetzt das nächste

00:21:19.920 --> 00:21:20.460
Leck entsteht.

00:21:20.780 --> 00:21:23.840
Ja, ich hätte auch große

00:21:23.840 --> 00:21:25.160
Bedenken, irgendwie so medizinische,

00:21:25.340 --> 00:21:26.960
Software für medizinische Geräte zu schreiben oder

00:21:26.960 --> 00:21:29.760
irgendwelche Software, die Flugzeuge steuert oder so,

00:21:29.840 --> 00:21:31.900
da hätte ich irgendwie groß, würde ich wahrscheinlich

00:21:31.900 --> 00:21:33.360
eher lieber nicht. Wahrscheinlich schon bei

00:21:33.360 --> 00:21:36.000
Bank-Transaktionsgeschichten schon Bedenken, aber

00:21:36.000 --> 00:21:37.840
Allein das zeichnet

00:21:37.840 --> 00:21:39.560
dich aber eigentlich schon aus als jemand, der

00:21:39.560 --> 00:21:41.600
qualifiziert sein könnte, das zu tun.

00:21:42.040 --> 00:21:43.160
Ich weiß nicht, weil

00:21:43.160 --> 00:21:45.320
zu viele Leute

00:21:45.320 --> 00:21:47.460
gehen nämlich ohne diese

00:21:47.460 --> 00:21:48.780
Vorsicht heran.

00:21:49.480 --> 00:21:51.440
Also, man hat mal früher gesagt,

00:21:51.520 --> 00:21:53.340
die Deutschen bauen die besten Atomkraftwerke,

00:21:53.620 --> 00:21:55.140
weil die so scheiß viel Angst davor haben.

00:21:56.040 --> 00:21:57.500
Und halt entsprechend in die

00:21:57.500 --> 00:21:58.420
Sicherheit investieren.

00:21:59.420 --> 00:22:01.100
Deswegen ist Siemens mit den

00:22:01.100 --> 00:22:02.980
Atomkraftwerken so ein Exportschlager.

00:22:04.140 --> 00:22:05.520
Andere haben halt weniger Angst

00:22:05.520 --> 00:22:07.460
davor und machen dann halt

00:22:07.460 --> 00:22:08.640
auch weniger Sicherheit.

00:22:10.020 --> 00:22:11.260
Das ist so ein bisschen ein,

00:22:11.920 --> 00:22:13.500
wer sich halt auf dem Fahrrad sicher fühlt

00:22:13.500 --> 00:22:14.480
und keinen Helm aufsetzt,

00:22:14.480 --> 00:22:20.020
und wer sich unsicher fühlt und einen Helm aufsetzt, ist am Ende bei einer echten Kollision feiner raus.

00:22:21.600 --> 00:22:25.120
Ja, aber ich meine, das ist einfach so.

00:22:25.240 --> 00:22:29.380
Ich glaube, das, was mich da so unsicher fühlen lässt, ist halt einfach, es ist schwer zu hinzu...

00:22:29.380 --> 00:22:35.620
Also es ist schwer, überhaupt sicherzustellen, dass da nichts passieren kann.

00:22:35.760 --> 00:22:37.400
Es ist einfach, es kann so viel schief gehen.

00:22:37.400 --> 00:22:39.080
Es geht auch nicht.

00:22:39.080 --> 00:22:44.680
Das ist dann der schöne Übergang zu dem Thema Security als Prozess halt.

00:22:45.780 --> 00:22:56.300
Man kann halt immer, ich glaube etwas, was lange in der Informatik gelehrt wurde, ist halt das Problem sozusagen Security als abstrakte mathematische Eigenschaft eines Systems.

00:22:57.360 --> 00:23:05.840
Das wird an vielen Stellen auch noch verfolgt und da kommen interessante Sachen raus, gerade wenn wir gucken in Richtung strenger Typsysteme und all so ein Zeug.

00:23:05.840 --> 00:23:09.040
also ADA zum Beispiel, dieses ganze Umfeld.

00:23:10.920 --> 00:23:14.760
Und da finde ich es auch spannend, dass die tatsächlich dort Engineering haben.

00:23:15.320 --> 00:23:18.200
Ich hatte ADA nur mal im Studium und muss sagen,

00:23:18.400 --> 00:23:23.100
also es ist halt, was die Garantien angeht, wirklich straff.

00:23:23.760 --> 00:23:24.920
Es ist auch ziemlich schnell.

00:23:25.540 --> 00:23:27.980
Ich habe aber nie irgendwas Sinnvolles damit programmieren können.

00:23:28.260 --> 00:23:30.500
Kannst du vielleicht nochmal ganz kurz erklären, was ADA ist?

00:23:30.940 --> 00:23:35.500
ADA ist eine Sprache, die ist extrem formal definiert.

00:23:35.840 --> 00:23:51.000
und die wird hauptsächlich im militärischen Bereich eingesetzt, also bei uns an der Uni ist die gelehrt worden und dann gab es halt gerne mal von der Eurocopter und von anderen Leuten Besuche, wo es dann darum ging, irgendwie Steuersysteme für Kampfhufschrauber und so ein Kram zu programmieren.

00:23:51.000 --> 00:23:55.420
und die ist halt, die zeichnet sich dadurch aus, dass sie ein sehr umfassendes

00:23:55.420 --> 00:23:59.480
Typsystem hat. Das heißt, da wo man in anderen Sprachen halt sagt,

00:23:59.560 --> 00:24:03.560
ich hätte hier gern einen Integer, kannst du dem Ding halt sagen,

00:24:03.660 --> 00:24:07.520
ja, ich will hier einen Integer haben, der darf aber nur von 7 bis 9, 11,

00:24:07.620 --> 00:24:11.820
13 und 12 sein. Und der Compiler

00:24:11.820 --> 00:24:15.280
kann dir vorher über alle Operationen deines Programms schon sagen,

00:24:15.280 --> 00:24:19.080
ob die Verkettung der Operationen in Summe

00:24:19.080 --> 00:24:20.920
noch zu zulässigen Ergebnissen führt.

00:24:21.820 --> 00:24:23.020
Oder ob du irgendwo deine

00:24:23.020 --> 00:24:24.220
Wertebereiche sprengen würdest.

00:24:24.880 --> 00:24:26.740
Und gleichzeitig, und das ist halt wirklich cool,

00:24:26.900 --> 00:24:28.380
die können halt Echtzeit

00:24:28.380 --> 00:24:31.200
und sie sind auch auf anderen Systemen

00:24:31.200 --> 00:24:33.060
sehr, sehr schnell in der Laufzeit nachher.

00:24:33.140 --> 00:24:34.620
Und das ist halt, das ist was wert.

00:24:35.500 --> 00:24:36.680
Gleichzeitig ist es aber so,

00:24:37.100 --> 00:24:38.900
immer wenn es um I.O. geht, nämlich da,

00:24:38.900 --> 00:24:40.700
wo halt dieses Thema, da kommen Daten

00:24:40.700 --> 00:24:42.660
von draußen rein oder müssen wieder raus,

00:24:43.120 --> 00:24:44.520
da gucken sie so ein bisschen in die Luft und sagen,

00:24:44.640 --> 00:24:47.220
naja, das macht jemand anders.

00:24:47.220 --> 00:24:49.660
Das ist dann halt immer

00:24:49.660 --> 00:24:51.240
also da herzugehen und zu sagen,

00:24:51.360 --> 00:24:53.320
ihr kennt jetzt hier gerne mal schnell eine

00:24:53.320 --> 00:24:54.800
HTTP-Library und ich würde dir

00:24:54.800 --> 00:24:57.420
SSL nochmal da drüben, Repository

00:24:57.420 --> 00:24:59.140
von GitHub, sowas ist bei aller

00:24:59.140 --> 00:25:01.080
halt eher nicht so an der Tagesordnung.

00:25:01.300 --> 00:25:03.080
Du brauchst halt auch eine entsprechende

00:25:03.080 --> 00:25:05.500
Engineering-Menge und Genauigkeit,

00:25:05.760 --> 00:25:07.340
all die Kombinationen, mit denen du

00:25:07.340 --> 00:25:09.300
sozusagen konfrontiert wirst, dir so genau

00:25:09.300 --> 00:25:11.400
anzugucken, das lohnt sich

00:25:11.400 --> 00:25:13.240
halt auch eigentlich nur,

00:25:13.380 --> 00:25:15.740
wenn da wirklich Menschenleben dranhängen.

00:25:15.740 --> 00:25:17.660
Ja, das, wenn du sagst, es ist okay,

00:25:17.980 --> 00:25:19.560
wenn dieses kleine Programm jetzt

00:25:19.560 --> 00:25:20.860
zwei Millionen Euro kostet.

00:25:21.420 --> 00:25:23.820
Wo jemand anders sagt, komm, da hack ich dir jetzt das Shell-Skript runter

00:25:23.820 --> 00:25:24.500
und dann ist es gut.

00:25:26.720 --> 00:25:27.920
Und da muss man immer aufpassen,

00:25:28.000 --> 00:25:29.140
dass es halt kontextbezogen ist.

00:25:29.380 --> 00:25:31.500
Also, die kommen halt aus dieser Ecke von einer

00:25:31.500 --> 00:25:33.920
mathematisch perfekten, idealisierten

00:25:33.920 --> 00:25:35.780
Variante von so, wir schreiben jetzt

00:25:35.780 --> 00:25:37.660
das Programm und das ist dann sicher.

00:25:38.340 --> 00:25:39.780
Und wenn du in ausreichend komplexe

00:25:39.780 --> 00:25:41.660
Systeme kommst, musst du aber eigentlich

00:25:41.660 --> 00:25:43.400
eher einen prozessorientierten Ansatz machen.

00:25:44.320 --> 00:25:45.360
Genau, genau, da würde ich

00:25:45.360 --> 00:25:47.360
nämlich jetzt auch gerade noch kurz einhaken

00:25:47.360 --> 00:25:49.280
und sagen, naja, das Blöde ist, dass

00:25:49.280 --> 00:25:51.340
einem halt auch diese Geschichten nicht unbedingt schützen

00:25:51.340 --> 00:25:52.980
vor wirklich fatalen

00:25:52.980 --> 00:25:55.400
Fehlern, wie zum Beispiel

00:25:55.400 --> 00:25:57.300
ich weiß nicht, ob das der Jungfernflug

00:25:57.300 --> 00:25:59.260
der von irgendeiner neuen Ariane-Version

00:25:59.260 --> 00:26:01.020
war, Ariane 5, äh Ariadne

00:26:01.020 --> 00:26:03.380
Ariadne oder Ariane, Ariane glaube ich

00:26:03.380 --> 00:26:03.560
5

00:26:03.560 --> 00:26:07.240
Ich glaube auch die Steuerungssoftware dafür ist

00:26:07.240 --> 00:26:09.420
auch in Ada geschrieben oder so und die ist sogar

00:26:09.420 --> 00:26:11.080
bewiesen

00:26:11.080 --> 00:26:13.200
dass die tatsächlich das tut, was in der

00:26:13.200 --> 00:26:15.200
Spezifikation steht, nur

00:26:15.200 --> 00:26:18.360
das Problem ist halt, sie haben irgendwie die falsche Spezifikation

00:26:18.360 --> 00:26:19.700
verwendet

00:26:19.700 --> 00:26:20.580
das war Wind

00:26:20.580 --> 00:26:24.080
die Spezifikation war halt für die alten Motoren

00:26:24.080 --> 00:26:25.400
irgendwie und dann hat

00:26:25.400 --> 00:26:27.520
irgendwie waren die Sensordaten

00:26:27.520 --> 00:26:29.780
für den Computer halt

00:26:29.780 --> 00:26:31.140
irgendwie so, nee das kann nicht sein

00:26:31.140 --> 00:26:33.940
aber es ist ja bewiesen, das ist

00:26:33.940 --> 00:26:35.360
richtig, daher muss ich defekt sein

00:26:35.360 --> 00:26:37.660
dann hat sich der erste Steuerungskomputer ausgeschaltet

00:26:37.660 --> 00:26:39.380
und dann hat sich der zweite auch noch ausgeschaltet

00:26:39.380 --> 00:26:40.780
und dann war halt Schluss

00:26:40.780 --> 00:26:42.780
und dann ist die Rakete halt abgestürzt

00:26:42.780 --> 00:26:44.740
und ja

00:26:44.740 --> 00:26:59.060
Das ist ja auch sowas. Ich meine, klar, man kann halt beweisen manchmal, dass Programme das tun, was sie tun sollen, aber dann muss man ja immer noch sicher sein können, dass die Spezifikation richtig ist. Aber irgendwie, man kommt da in so einen infiniten Regress und selbst das hilft einem nicht.

00:26:59.700 --> 00:27:05.300
Das war jetzt ein Fall, wo ein Hardware-Update dazu geführt hat, dass das Ding nicht mehr lief. Also keine Updates fahren, never touch a running system.

00:27:05.300 --> 00:27:35.280
machen.

00:28:05.300 --> 00:28:06.920
und der Code sieht komisch aus.

00:28:07.540 --> 00:28:09.540
Und dann kann ich ja sowohl Tests durchführen

00:28:09.540 --> 00:28:11.360
gegen den Source-Code, also dass ich

00:28:11.360 --> 00:28:13.180
mir den gesamten Source-Code nehme

00:28:13.180 --> 00:28:15.380
und ein automatisiertes Programm drüber laufen lasse,

00:28:15.440 --> 00:28:17.600
das mir halt sagt, okay, die Stelle sieht komisch aus.

00:28:17.680 --> 00:28:19.440
Hier machst du wahrscheinlich eine SQL-Injection

00:28:19.440 --> 00:28:21.060
oder ein C, ein Buffer-Overflow,

00:28:21.200 --> 00:28:22.480
das sieht irgendwie gefährlich aus.

00:28:23.180 --> 00:28:25.840
Und dann kann ich natürlich auch sogenannte Blackbox-Tests

00:28:25.840 --> 00:28:27.500
fahren, wo ich sage, okay, ich starte meine Anwendung

00:28:27.500 --> 00:28:29.360
einfach mal und dann nehme ich mal so ein

00:28:29.360 --> 00:28:31.020
Hacker-Tool und das probiert einfach mal aus.

00:28:31.380 --> 00:28:33.080
Kann ich hier komische Sachen eingeben und

00:28:33.080 --> 00:28:36.000
und crashen das Programm oder macht das Programm irgendwas komisches.

00:28:36.500 --> 00:28:37.840
Also auch in Python ist das nicht verloren.

00:28:38.240 --> 00:28:40.900
Da kann man auch sehr sichere Anwendungen schreiben,

00:28:41.620 --> 00:28:44.020
was meistens das gleiche ist wie eine gute Anwendung zu schreiben,

00:28:44.180 --> 00:28:47.780
weil die stürzt halt nicht ab und die kann auch mit allen Benutzerangaben umgehen,

00:28:48.200 --> 00:28:50.180
noch nicht mal nur von Angreifern, sondern auch von Benutzern.

00:28:50.600 --> 00:28:51.760
Also ich hatte das beruflich auch so.

00:28:52.840 --> 00:28:56.440
Wir dachten erst, wir hätten einen Angreifer, weil unsere Anwendung abgestürzt ist,

00:28:56.500 --> 00:28:59.840
aber hat sich herausgestellt, wir hatten ein ähnliches Problem wie beim Buffer-Overflow.

00:28:59.840 --> 00:29:01.500
Wir hatten ein Datenbankfeld mit einer bestimmten Länge

00:29:01.500 --> 00:29:01.500


00:29:01.500 --> 00:29:03.940
und die Länge war aber in Bytes

00:29:03.940 --> 00:29:05.740
und dann kamen halt User an und haben

00:29:05.740 --> 00:29:07.720
ihre kleine Tony-Figur

00:29:07.720 --> 00:29:09.440
mit ganz viel Smileys genannt

00:29:09.440 --> 00:29:11.220
und dann passte das nachher nicht

00:29:11.220 --> 00:29:12.120
und

00:29:12.120 --> 00:29:15.820
führte zu einem Crash und auch sowas kann man natürlich

00:29:15.820 --> 00:29:17.340
auch vorher darauf achten und

00:29:17.340 --> 00:29:19.860
entsprechend auch testen,

00:29:20.000 --> 00:29:22.460
das ist ja noch ein anderer Bestandteil

00:29:22.460 --> 00:29:23.620
eines sicheren Prozesses,

00:29:24.100 --> 00:29:25.900
der sagen kann, ich schreibe vorher Tests

00:29:25.900 --> 00:29:27.700
und ich überlege mir entweder manuell

00:29:27.700 --> 00:29:29.680
oder sogar automatisiert, wie sehen komische

00:29:29.680 --> 00:29:32.000
Eingaben aus. Bei Nummern sind das meistens

00:29:32.000 --> 00:29:33.760
Null oder sehr kleine

00:29:33.760 --> 00:29:35.420
Zahlen oder sehr große Zahlen.

00:29:36.520 --> 00:29:37.720
Typischerweise auch

00:29:37.720 --> 00:29:39.240
Zahlen, die vielleicht über

00:29:39.240 --> 00:29:41.640
die 32 Bytes hinausgehen, was in Python jetzt

00:29:41.640 --> 00:29:43.520
nicht so ein Problem ist oder über die 64

00:29:43.520 --> 00:29:45.720
Bits hinausgehen.

00:29:46.960 --> 00:29:47.760
Also wenn ich da eine sehr

00:29:47.760 --> 00:29:49.740
große Zahl, wenn ich 2 hoch 64 plus 1 schreibe,

00:29:49.820 --> 00:29:51.600
dann in Python gar kein Problem. Aber

00:29:51.600 --> 00:29:53.600
in vielen anderen Programmiersprachen führt das halt

00:29:53.600 --> 00:29:54.140
zu einem

00:29:54.140 --> 00:30:05.362
Abschluss oder zu komischem Verhalten Und damit kann ich auch in Python glaube ich sehr gut Sicherheit sichern Also du wirst tats in solchen kritischen F wo du dir

00:30:05.422 --> 00:30:07.743
ich weiß nicht so genau, was da rauskommt, Assertment-Statements

00:30:07.743 --> 00:30:09.582
in den Code schreiben einfach und dann

00:30:09.582 --> 00:30:11.362
sagen Asserts should never happen oder sowas.

00:30:11.482 --> 00:30:13.582
Und dann fliegt dann...

00:30:14.263 --> 00:30:15.263
Genau, vielleicht auch testen.

00:30:15.462 --> 00:30:17.482
Also bei dem Beispiel, was ich eben gebracht habe, wo die

00:30:17.482 --> 00:30:19.462
zwei Emojis eingeben haben oder andere

00:30:19.462 --> 00:30:21.403
komische Unicode-Zeichen, haben wir halt einen Test

00:30:21.403 --> 00:30:23.043
gemacht. Und dieser Test, also wir haben

00:30:23.043 --> 00:30:27.102
sowohl einen Unit-Test, der also ganz normal in der Anwendung läuft,

00:30:27.482 --> 00:30:31.503
wo wir halt mal ausprobieren, was passiert, wenn ich nur Emotions eingebe oder andere komische Strings.

00:30:31.982 --> 00:30:35.922
Und wir haben aber auch einen End-to-End-Test, der das gesamte System testet.

00:30:36.383 --> 00:30:43.802
Zum Beispiel hatten wir auch mal einen Bug, der durch den Reverse-Proxy vor unserer Anwendung verursacht wurde,

00:30:44.123 --> 00:30:45.222
dass der halt Sachen falsch macht.

00:30:45.602 --> 00:30:47.922
Und sowas kann man dann halt nicht so richtig testen.

00:30:47.922 --> 00:30:52.182
Natürlich könnte man auch in Nginx sagen, ich schreibe eine Art Unit-Test für unsere Nginx-Konfiguration,

00:30:52.182 --> 00:30:52.182


00:30:54.182 --> 00:30:55.043
zu schreiben,

00:30:56.143 --> 00:30:58.043
der halt wirklich eine echte Anfrage

00:30:58.043 --> 00:30:59.942
gegen das echte System schickt, oder gegen Prod, also

00:30:59.942 --> 00:31:01.743
kann man sogar gegen sein Production-System testen,

00:31:02.182 --> 00:31:04.163
aber natürlich testet man das im Normalfall zuerst

00:31:04.163 --> 00:31:05.923
gegen Development und sendet

00:31:05.923 --> 00:31:07.682
mal komische Anfragen und schaut, okay,

00:31:08.342 --> 00:31:10.243
geht das, kommen hier ordentlich Ergebnisse raus

00:31:10.243 --> 00:31:12.062
und meldet das

00:31:12.062 --> 00:31:13.942
System vielleicht auch hinten drum schon,

00:31:14.082 --> 00:31:15.462
dass irgendwas umgefallen ist und

00:31:15.462 --> 00:31:18.182
das kann man halt damit schon ganz gut testen.

00:31:19.643 --> 00:31:20.163
Ich finde

00:31:20.163 --> 00:31:22.062
das halt auch spannend aus der Perspektive von

00:31:22.182 --> 00:31:27.982
User lassen sich halt mehr Dinge einfallen, als man selber halt vorher konstruieren kann.

00:31:28.763 --> 00:31:37.702
Tests sind an der Stelle immer natürlich auch super, weil man, wenn man im Hinterkopf behält, dass Tests halt eben nicht dafür da sind, Beweise zu ersetzen.

00:31:37.702 --> 00:31:44.542
Also ja, sie sind sogar eine Annäherung eines Beweises, aber sie können halt nie alle Fälle abdecken.

00:31:44.702 --> 00:31:50.243
Das geht halt schon in dem Moment schief, wenn du halt ein kontinuierliches Wertesystem hast an der Stelle.

00:31:50.243 --> 00:31:55.883
und was da halt interessanterweise zum Tragen kommt, aus einer ganz anderen Ecke von Security,

00:31:56.042 --> 00:31:58.842
ich weiß gerade nicht mehr, welcher amerikanischen Militär das war,

00:31:59.883 --> 00:32:02.102
das kommt so aus dem Counterterrorism-Zeug,

00:32:03.062 --> 00:32:07.143
das ist Only Variety Can Match Variety.

00:32:07.783 --> 00:32:13.503
Also das Problem von Terrorismus ist halt, dass Terroristen extrem variierte Inputs,

00:32:13.503 --> 00:32:14.923
also Angriffe fahren.

00:32:15.982 --> 00:32:19.802
Da geht es ja nicht um eine reguläre Kriegsführung nach Genfer Konvention,

00:32:19.802 --> 00:32:21.722
sondern die machen Dinge, gerade

00:32:21.722 --> 00:32:23.722
weil sie verboten sind und

00:32:23.722 --> 00:32:25.842
weil keiner damit rechnet an Stellen, wo keiner damit

00:32:25.842 --> 00:32:28.163
rechnet und die Amerikaner

00:32:28.163 --> 00:32:29.903
haben halt irgendwann rausgefunden, wir können dem

00:32:29.903 --> 00:32:31.743
halt nicht mit herkömmlichen Maßnahmen, indem

00:32:31.743 --> 00:32:33.462
wir alle möglichen Fälle durchdeklinieren

00:32:33.462 --> 00:32:35.842
entgegentreten, sondern du brauchst

00:32:35.842 --> 00:32:37.722
halt kognitive Diversität, um

00:32:37.722 --> 00:32:39.342
auf diese absurden Ideen zu kommen

00:32:39.342 --> 00:32:41.763
du brauchst tatsächlich Leute, die unterschiedlich

00:32:41.763 --> 00:32:44.042
ticken und ganz ehrlich, keiner von uns

00:32:44.042 --> 00:32:45.822
wenn ich hier in die Runde

00:32:45.822 --> 00:32:47.842
gucke, wir haben halt vier mittelalte weiße Männer

00:32:47.842 --> 00:32:50.342
und die

00:32:50.342 --> 00:32:52.263
Diversität ist auf der Ebene

00:32:52.263 --> 00:32:54.342
halt auch kognitiv dadurch mit dem Bias

00:32:54.342 --> 00:32:56.263
belegt. Keiner von uns kommt auf

00:32:56.263 --> 00:32:57.862
die Idee in seinen Tests halt

00:32:57.862 --> 00:33:00.442
Katzen-Emojis in den Inputs

00:33:00.442 --> 00:33:01.962
zu zeigen. Das macht halt von uns keiner.

00:33:02.743 --> 00:33:04.302
Und an der Stelle

00:33:04.302 --> 00:33:06.202
ist Security als Prozess halt

00:33:06.202 --> 00:33:07.763
tatsächlich auch von einer hohen Diversität,

00:33:08.523 --> 00:33:10.143
also braucht eine hohe

00:33:10.143 --> 00:33:12.003
Diversität, immer mit dem kleinen

00:33:12.003 --> 00:33:14.243
Zusatz von kognitiver

00:33:14.243 --> 00:33:16.222
Diversität, die aber auch tatsächlich

00:33:16.222 --> 00:33:17.903
überlappt mit kultureller und

00:33:17.903 --> 00:33:20.202
persönlicher Erfahrung

00:33:20.202 --> 00:33:22.283
etc., um halt

00:33:22.283 --> 00:33:23.722
das erzeugt zu kriegen, dass man halt

00:33:23.722 --> 00:33:25.582
auf genügend Ideen kommt,

00:33:26.042 --> 00:33:27.783
die dann mal so eine Baseline herstellt von

00:33:27.783 --> 00:33:29.302
okay, das ist jetzt hier nicht mehr scheiße.

00:33:31.462 --> 00:33:32.082
Naja, das ist immer,

00:33:32.302 --> 00:33:34.202
ich finde das aus einem prozesshaften Ansatz gesehen

00:33:34.202 --> 00:33:36.003
und das ist halt das, wo wenn Jochen

00:33:36.003 --> 00:33:37.923
der halt sagt, hilf ich, ich will keinen Space-Structure-Code

00:33:37.923 --> 00:33:39.942
schreiben, aber Leute, die halt besser

00:33:39.942 --> 00:33:41.322
differenzieren können zwischen

00:33:41.322 --> 00:33:43.802
ja, wie gut oder schlecht ist es denn,

00:33:43.862 --> 00:33:45.822
versus ist es jetzt perfekt sicher oder ist es nicht

00:33:45.822 --> 00:34:15.823
und die

00:34:15.823 --> 00:34:45.802
und Jochen unterhalten sich über die Programmiersprache Python

00:34:45.823 --> 00:35:15.802
und Jochen unterhalten sich über die Programmiersprache Python

00:35:15.822 --> 00:35:20.022
Petent und ihr aktualisiert das so, wie es halt nötig ist und jada, jada, jada.

00:35:20.923 --> 00:35:23.862
Aber das war dann halt auch plötzlich ein Kampf, wo die da vorstanden und

00:35:23.862 --> 00:35:26.782
sagten, fuck, ich muss jetzt hier das Siegel drauf machen, obwohl ich eigentlich

00:35:26.782 --> 00:35:29.762
in der Liste geschrieben habe, verstößt gegen unsere Sicherheitspolicy.

00:35:30.582 --> 00:35:34.923
Ja, stimmt, das ist ein großes Problem. Das ist auch so ein Problem mit so

00:35:34.923 --> 00:35:37.643
Zertifizierungen, die man ja sonst vielleicht macht, wenn man jetzt irgendwie

00:35:37.643 --> 00:35:41.963
ein Auto fährt oder keine Ahnung, wo das eigentlich herkommt, Kirmesgeräte hat,

00:35:42.022 --> 00:35:45.743
auf denen Leute rumfahren. Dann kommt der TÜV und sagt halt, okay, ist noch nicht

00:35:45.743 --> 00:35:47.062
durchgerostet, alles klar, hier das Siegel.

00:35:47.802 --> 00:35:49.643
Das geht halt bei Software nicht so gut,

00:35:49.822 --> 00:35:51.743
weil die muss man ja ändern und eigentlich braucht man

00:35:51.743 --> 00:35:52.743
dann eine neue Zertifizierung.

00:35:53.062 --> 00:35:55.463
Ja, genau, das wäre,

00:35:55.582 --> 00:35:57.163
könnte man jetzt denken, dass das die Lösung wäre.

00:35:57.243 --> 00:35:58.282
Ich habe das schon gemacht.

00:35:58.562 --> 00:36:01.943
Ja, ich habe

00:36:01.943 --> 00:36:04.203
2003 oder 2004

00:36:04.203 --> 00:36:05.643
haben wir damals mit

00:36:05.643 --> 00:36:07.743
Soap eine Common Criteria Zertifizierung

00:36:07.743 --> 00:36:09.443
gemacht und das war

00:36:09.443 --> 00:36:11.683
so ein Challenge, da gab es einen Sponsor,

00:36:11.762 --> 00:36:13.463
der uns das bezahlt hat und

00:36:13.463 --> 00:36:15.403
parallel dazu hatte damals

00:36:15.403 --> 00:36:16.502
Red Hat den

00:36:16.502 --> 00:36:18.903
J-Boss, glaube ich, durch eine

00:36:18.903 --> 00:36:21.342
Common Criteria gejagt und

00:36:21.342 --> 00:36:23.302
wir hatten im Prinzip das gleiche Schutzniveau

00:36:23.302 --> 00:36:24.743
anzubieten.

00:36:25.282 --> 00:36:27.362
Eine ERP 3 Plus oder ERP 4 oder so ein

00:36:27.362 --> 00:36:27.582
Kram.

00:36:29.582 --> 00:36:31.302
Ich kann

00:36:31.302 --> 00:36:33.522
auch nur die humoristische

00:36:33.522 --> 00:36:35.203
Variante irgendwie so, die unterste ist

00:36:35.203 --> 00:36:36.262
irgendwie das Programm existiert,

00:36:36.802 --> 00:36:39.582
die nächste ist dann irgendwie ja, das Programm existiert

00:36:39.582 --> 00:36:40.943
und es gibt Dokumentation dazu,

00:36:41.623 --> 00:36:43.282
dann die nächste ist irgendwie, jemand hat mal

00:36:43.282 --> 00:36:45.322
geguckt, ob die Dokumentation zum Programm passt und dann

00:36:45.322 --> 00:36:47.883
und es existiert

00:36:47.883 --> 00:36:49.423
ein formaler Beweis, dass das Programm korrekt ist.

00:36:49.762 --> 00:36:51.203
Wo dann irgendwie so ein Zwischenschritt fehlt,

00:36:51.602 --> 00:36:53.903
das ist, glaube ich, Stufe 6

00:36:53.903 --> 00:36:54.663
oder weiß ich nicht genau.

00:36:55.342 --> 00:36:57.302
Ja, ERP 6 ist die formale Verifikation, genau.

00:36:58.423 --> 00:36:59.542
Und, nee, nee,

00:36:59.542 --> 00:37:01.082
wir hatten da schon ein relativ hohes Schutzniveau

00:37:01.082 --> 00:37:02.982
und die Common Criteria als

00:37:02.982 --> 00:37:05.822
Framework, um über Security nachzudenken,

00:37:06.062 --> 00:37:07.562
inhaltlich, ist toll.

00:37:08.002 --> 00:37:09.683
Weil du kriegst halt einen Katalog

00:37:09.683 --> 00:37:11.782
von, also du hast zum einen einen Prozess,

00:37:12.223 --> 00:37:13.602
der dir sagt, okay, mach dir mal Gedanken

00:37:13.602 --> 00:37:15.582
über, wer sind denn deine Assets?

00:37:16.002 --> 00:37:17.102
Wer sind deine Angreifer?

00:37:17.423 --> 00:37:18.982
Was haben die für Motivationen?

00:37:19.203 --> 00:37:20.403
Was haben die für Ressourcen?

00:37:20.963 --> 00:37:23.562
Und jetzt gucken wir mal, wie mappen wir das

00:37:23.562 --> 00:37:24.842
alles aufeinander von

00:37:24.842 --> 00:37:27.683
wie sind deine Assets

00:37:27.683 --> 00:37:29.463
mit was geschützt gegenüber welchen

00:37:29.463 --> 00:37:30.383
Angriffsszenarien?

00:37:31.562 --> 00:37:33.443
Und die haben auch noch einen tollen

00:37:33.443 --> 00:37:35.443
Implementationskatalog, wo sie sagen, okay, also

00:37:35.443 --> 00:37:37.582
wenn du folgendes countern möchtest, könnte man zum Beispiel

00:37:37.582 --> 00:37:39.623
Logging machen. Wenn du Logging machst, dann musst

00:37:39.623 --> 00:37:41.623
du dir über die Integrität vom Log Gedanken

00:37:41.623 --> 00:37:43.423
machen, da musst du dir über Zeitstempel-Gedanken

00:37:43.423 --> 00:37:45.463
machen, da musst du, das ist sozusagen, das ist so ein bisschen,

00:37:45.842 --> 00:37:47.403
da kannst du wie bei so einem Spinnennetz irgendwie

00:37:47.403 --> 00:37:49.062
reingreifen, erstmal, was interessiert mich,

00:37:49.362 --> 00:37:51.703
und dann kommen alle Sachen hinterher, von die du noch berücksichtigen

00:37:51.703 --> 00:37:53.643
musst. Das ist viel, aber es ist

00:37:53.643 --> 00:37:55.542
eigentlich erstmal auf der Ebene

00:37:55.542 --> 00:37:57.082
fachlich gar nicht schlecht gewesen.

00:37:57.463 --> 00:37:59.703
Das große Problem ist, die Common Criteria

00:37:59.703 --> 00:38:01.623
kommt aus der Produktsicherheit.

00:38:03.022 --> 00:38:03.482
Und die

00:38:03.482 --> 00:38:05.383
gehen halt davon aus, dass ein Produkt eben

00:38:05.383 --> 00:38:07.243
siehe, ein Karussell auf dem Jahrmarkt,

00:38:07.562 --> 00:38:09.683
das Ding wird einmal gebaut und existiert jetzt,

00:38:09.683 --> 00:38:12.002
und jetzt ist das ab und jetzt läuft das 30 Jahre.

00:38:12.463 --> 00:38:13.883
Wenn du aber sowas wie einen Open Source

00:38:13.883 --> 00:38:14.982
Application Server hast,

00:38:15.643 --> 00:38:18.963
wo du exakt ein Release

00:38:18.963 --> 00:38:19.423
einmal

00:38:19.423 --> 00:38:21.683
verifizieren darfst

00:38:21.683 --> 00:38:23.943
und dann kommt

00:38:23.943 --> 00:38:26.002
aber in 23 Stunden das nächste raus

00:38:26.002 --> 00:38:27.562
und du fängst

00:38:27.562 --> 00:38:29.782
die ganze Zertifizierung wieder von vorne an,

00:38:29.862 --> 00:38:30.782
das geht dann halt schief.

00:38:32.462 --> 00:38:34.002
Ja, außer man muss ja die Zertifizierung

00:38:34.002 --> 00:38:35.883
erstmal, also es kann manchmal

00:38:35.883 --> 00:38:37.683
sehr gut sein, dass man sich über alle Sachen

00:38:37.683 --> 00:38:39.743
Gedanken macht, aber man kann ja auch ganz viele Sachen

00:38:39.743 --> 00:38:41.683
vermissen. Also ich glaube, der

00:38:41.683 --> 00:38:43.703
viel besser, oder also

00:38:43.703 --> 00:38:45.482
für viele Anwendungen besser ist es,

00:38:45.723 --> 00:38:47.443
wenn man sagt, ich mache einen Pentest, also ich

00:38:47.443 --> 00:38:49.683
einen Auftrag geben. Bei einem Pentest

00:38:49.683 --> 00:38:51.383
geht halt jemand anders hin und sagt, ich

00:38:51.383 --> 00:38:53.383
checke deine Software. Also entweder

00:38:53.383 --> 00:38:55.462
checke ich die von außen oder ich schaue mir

00:38:55.462 --> 00:38:57.782
den Source-Good an, ich schaue mir das mal an,

00:38:57.822 --> 00:38:59.683
was du so in Python oder auch in anderen

00:38:59.683 --> 00:39:01.022
Programmiersprachen alles programmiert hast.

00:39:01.623 --> 00:39:03.862
Und das sind dann halt erfahrene Entwickler

00:39:03.862 --> 00:39:05.502
in der genau der Programmiersprache

00:39:05.502 --> 00:39:07.842
und die können halt schon, vielleicht auch mit automatischen

00:39:07.842 --> 00:39:09.802
Tools, sehr schnell kritische Stellen

00:39:09.802 --> 00:39:11.643
finden. Also damit habe ich auch

00:39:11.643 --> 00:39:12.582
gute Erfahrungen gemacht.

00:39:13.482 --> 00:39:15.362
Das ist natürlich eine ganz andere Herangehensweise, dass man sagt, okay,

00:39:15.542 --> 00:39:17.683
ich versuche nicht alles irgendwie, den ganzen

00:39:17.683 --> 00:39:19.602
Prozess, ich schreibe kein Papier,

00:39:19.962 --> 00:39:21.862
sondern ich lasse den wesentlichen Leuten anfangen, uns zu coden.

00:39:22.403 --> 00:39:23.263
Und das muss man natürlich auch

00:39:23.263 --> 00:39:25.743
regelmäßig wiederholen. Das bringt natürlich nichts, wenn man vor 10 Jahren

00:39:25.743 --> 00:39:27.423
das mal gemacht hat. Aber das ist auch

00:39:27.423 --> 00:39:28.903
sicherlich eine Methode, mit der man

00:39:28.903 --> 00:39:31.143
seine Anwendung gut absichern kann.

00:39:31.582 --> 00:39:33.562
Du musst also den Angreiferhut aufsetzen und da draufhauen,

00:39:33.562 --> 00:39:35.542
solange bis auseinander fällt. Da brauchen wir halt gute Angreifer

00:39:35.542 --> 00:39:36.802
auch, die so ein bisschen ein paar Tricks kennen.

00:39:37.302 --> 00:39:39.522
Ich glaube, wenn man jetzt nur so Tools drauf loslässt, dann weiß ich nicht.

00:39:40.223 --> 00:39:41.482
Genau, also wenn man nur

00:39:41.482 --> 00:39:43.302
ein Tool selber drauf loslässt, hilft es wahrscheinlich nicht.

00:39:43.383 --> 00:39:45.143
Aber wenn man halt jemanden beauftragt, der

00:39:45.143 --> 00:39:47.502
da wirklich Experte ist,

00:39:48.062 --> 00:39:49.183
ich glaube, das ist eine ganz

00:39:49.183 --> 00:39:51.282
gute Möglichkeit, um so einen Blick

00:39:51.282 --> 00:39:53.462
zu bekommen, wie schlimm ist denn mit unserer Anwendung?

00:39:53.542 --> 00:39:54.982
Haben wir nur eine ganz kleine Schwachstelle?

00:39:55.403 --> 00:39:57.562
Oder ist unsere Admin-Oberfläche

00:39:57.562 --> 00:39:59.522
ohne Benutzernamen

00:39:59.522 --> 00:40:01.163
und Passwort irgendwie verfügbar und man kann beliebig

00:40:01.163 --> 00:40:02.903
einen Code hochladen? Und ich glaube,

00:40:02.903 --> 00:40:09.403
Das ist noch ein bisschen eine andere Herangehensweise, aber ich glaube, das ist oftmals effektiver, vor allem für so kleinere Projekte.

00:40:09.703 --> 00:40:16.482
Wenn man natürlich eine Zertifizierung braucht, dann braucht man sie, aber ich weiß nicht, ob das immer auch wirklich zu Sicherheit führt, wenn ich nur ganz viel Papier schreibe.

00:40:17.102 --> 00:40:22.643
Also ich würde an der Stelle halt eine Lanze brechen für das, was wir jetzt zu Corona-Zeiten kennengelernt haben als irgendwie Schweizer Käse-Modell.

00:40:24.183 --> 00:40:32.782
Du kannst halt, also für alle, die das noch nicht gehört hatten, ist sozusagen die ganzen Maßnahmen, alle Anti-Corona-Maßnahmen sind für sich genommen natürlich durchlöchert.

00:40:32.903 --> 00:40:36.802
wie so ein Schweizer Käse, aber wenn ich halt fünf Scheiben Schweizer Käse hintereinander lege,

00:40:37.243 --> 00:40:39.542
ist die Filtrationsrate dann doch relativ gut.

00:40:40.383 --> 00:40:43.842
Dass also wirklich über fünf Schichten an der gleichen Stelle überall die Löcher sind,

00:40:43.903 --> 00:40:45.443
das passiert halt normalerweise nicht.

00:40:46.163 --> 00:40:50.243
Und deswegen würde ich halt es immer, also aus meiner dann längerfristigen Erfahrung,

00:40:50.362 --> 00:40:53.243
würde ich halt sagen, es kommt immer auf den Kontext drauf an.

00:40:53.383 --> 00:40:55.482
Man muss immer erstmal gucken, was sind hier eigentlich die Assets gerade.

00:40:56.022 --> 00:41:00.042
Und wenn ich gerade hier in meinem Heimkeller irgendwie die Temperaturdaten von meinem Haus aufschreibe,

00:41:00.042 --> 00:41:30.022
und Jochen unterhalten sich über die Programmiersprache Python

00:41:30.042 --> 00:41:32.322
wo ich dann weiß, jetzt habe ich wenigstens nichts

00:41:32.322 --> 00:41:33.243
unnütz vergessen

00:41:33.243 --> 00:41:36.423
während dann halt das Thema ist

00:41:36.423 --> 00:41:38.302
halt auch jemand zum Beispiel vom Pentest

00:41:38.302 --> 00:41:40.383
da würde ich auch sagen, einige Leute mit denen

00:41:40.383 --> 00:41:42.143
ich mich dann austausche, sagen, ne dann

00:41:42.143 --> 00:41:44.203
machst du halt lieber auch noch gleichzeitig sozusagen

00:41:44.203 --> 00:41:45.703
eine externe Code Review

00:41:45.703 --> 00:41:48.102
die sozusagen über das was du brauchst halt dann nochmal

00:41:48.102 --> 00:41:50.542
im Whitebox drüber guckst und dann kannst du nochmal von draußen

00:41:50.542 --> 00:41:52.302
draufhauen und diese ganzen

00:41:52.302 --> 00:41:54.423
Schichten ergeben dann halt und gleichzeitig

00:41:54.423 --> 00:41:56.342
kannst du dann an vielen Stellen ja auch wenn man

00:41:56.342 --> 00:41:58.342
standardisierte Protokolle

00:41:58.342 --> 00:42:00.082
wie halt HTTP immer so dazwischen hat.

00:42:00.462 --> 00:42:01.943
Dann gibt es da ja auch noch die Möglichkeit,

00:42:02.123 --> 00:42:04.802
immer nochmal so Schichten einzuziehen wie eine Web-Application-Firewall,

00:42:05.302 --> 00:42:06.663
die einem so bestimmte

00:42:06.663 --> 00:42:08.423
Sachen schon mal

00:42:08.423 --> 00:42:10.183
wegfängt. Also ich habe zum Beispiel ein paar Kunden,

00:42:10.582 --> 00:42:11.643
denen gucke ich über die Schulter

00:42:11.643 --> 00:42:14.042
und da weiß ich dann so, okay, bei dir

00:42:14.042 --> 00:42:15.623
knall ich da jetzt eine Waffe davor,

00:42:16.562 --> 00:42:18.082
weil ansonsten traue ich mich nicht,

00:42:18.203 --> 00:42:20.322
das ins Netz rauszulassen. Du sagst mir, es muss raus

00:42:20.322 --> 00:42:20.822
ins Netz.

00:42:22.183 --> 00:42:24.243
Das ist das gleiche Prinzip wie ein Virenscanner.

00:42:24.522 --> 00:42:25.282
Da habe ich irgendwie

00:42:25.282 --> 00:42:27.562
ein Muster, das ich suche.

00:42:27.562 --> 00:42:29.522
bei einer Bar und sagt, okay, wenn ich das Muster

00:42:29.522 --> 00:42:31.183
finde, dann mache ich irgendwas, dann

00:42:31.183 --> 00:42:33.502
unterbinde ich die Anfrage oder schmeiße das

00:42:33.502 --> 00:42:34.943
Muster raus und mache irgendwas.

00:42:35.403 --> 00:42:36.183
Das ist

00:42:36.183 --> 00:42:39.143
schon ein bisschen gefährlich, weil

00:42:39.143 --> 00:42:41.383
eine Möglichkeit ist halt schon, wie bei einem Visenscanner,

00:42:42.022 --> 00:42:43.143
dass der,

00:42:43.522 --> 00:42:45.663
also die Wald- und Wiesenattacken

00:42:45.663 --> 00:42:47.562
findet der sicherlich. So was im Internet das Grundrauschen

00:42:47.562 --> 00:42:49.522
ist, das findest du auf jeden Fall. Aber wenn dann

00:42:49.522 --> 00:42:51.482
wirklich jemand deine Firma angreifen will, dann

00:42:51.482 --> 00:42:53.502
merkst du dich da vielleicht auch in falscher Sicherheit,

00:42:54.042 --> 00:42:55.562
weil man halt dann doch immer...

00:42:55.982 --> 00:42:57.403
Also du hast recht mit dem Schweißer Gessel,

00:42:57.403 --> 00:43:01.362
Modell, das macht es vielleicht ein bisschen besser, aber gleichzeitig kann ja so ein Waf auch wieder

00:43:01.362 --> 00:43:05.322
ein anderes Modell sein, weil der muss ja auch wieder alles interpretieren und ein Problem kann halt sein, dass

00:43:05.322 --> 00:43:09.282
mein Server davor und mein Server danach sowieso schon unterschiedliche Details

00:43:09.282 --> 00:43:13.362
anders interpretieren, also bei HTTP zum Beispiel Junk Encoding oder irgendwelche

00:43:13.362 --> 00:43:17.403
komischen HTTPS-Optionen anders interpretieren und dass dann die Waf sogar

00:43:17.403 --> 00:43:21.542
noch ein neues Problem aufmacht, dass sie plötzlich Sachen anders interpretiert und

00:43:21.542 --> 00:43:25.102
dann vielleicht sogar eine Schwachstelle an sich hat, also auch die Waf ist ja nur Code.

00:43:25.102 --> 00:43:27.143
Ne genau, deswegen ist das auch für uns zum Beispiel

00:43:27.143 --> 00:43:29.223
keine Maßnahme, die wir halt so Blanko überall drüber

00:43:29.223 --> 00:43:31.243
gießen, sondern das ist halt, wir haben halt

00:43:31.243 --> 00:43:32.542
dann Kunden, wo feststellen, also

00:43:32.542 --> 00:43:35.123
die Waffe ist für uns mehr oder weniger dann

00:43:35.123 --> 00:43:37.022
der erste Move, also manchmal

00:43:37.022 --> 00:43:39.163
wie du sagst, will irgendwer einfach in seiner

00:43:39.163 --> 00:43:41.082
Ausschreibung sehen, da muss eine Waffe davor

00:43:41.082 --> 00:43:42.562
dann packe ich da eine Waffe davor

00:43:42.562 --> 00:43:45.263
und wenn, das

00:43:45.263 --> 00:43:47.163
muss er ja anbieten können erstmal in dem Moment, wenn er

00:43:47.163 --> 00:43:49.022
das fragt und wenn der dann irgendwie nach zwei Monaten

00:43:49.022 --> 00:43:50.943
fragt mit, warum ist das hier alles so doof, dann sage ich

00:43:50.943 --> 00:43:53.102
du wolltest eine Waffe haben, dann sagt er mir, jetzt machst du wieder aus

00:43:53.102 --> 00:43:53.923
dann mache ich es halt wieder aus

00:43:53.923 --> 00:44:04.542
und wo wir es häufiger als Werkzeug tatsächlich sehen ist, dass tatsächlich diese Wald- und Wiesenscans und Angriffe gerne mal massiv für Last sorgen.

00:44:05.383 --> 00:44:14.743
Und das ist halt, wir sehen immer wieder Anwendungen, wo Leute mit SQL-Injection versuchen, quer über so eine Anwendung drüber gießen

00:44:14.743 --> 00:44:17.802
und die Anwendung dadurch in Performance-Probleme gerät.

00:44:18.482 --> 00:44:21.683
Und das ist halt tatsächlich was, das filtern wir dann damit zum Beispiel vorne weg.

00:44:21.683 --> 00:44:25.643
Also jetzt hier haben wir den natürlichen SQL-Kram, das hat da nichts zu suchen, zack, weg, raus.

00:44:27.362 --> 00:44:27.782
Ah, okay.

00:44:28.562 --> 00:44:34.002
Ja, aber ich habe auch schon mal von jemandem gehört, der so Pentests macht,

00:44:34.482 --> 00:44:39.443
dass er meinte, da war eine Bank, die hatte irgendwie ein System vor den Datenbanken

00:44:39.443 --> 00:44:42.423
und das sollte eigentlich aus dem SQL irgendwie alles rausfiltern,

00:44:42.562 --> 00:44:45.082
und das hat dazu geführt, dass SQL-Injection wieder möglich wurde,

00:44:45.423 --> 00:44:49.183
weil es halt Dinge zu viel rausgenommen hat.

00:44:49.183 --> 00:44:52.602
Du hast ja

00:44:52.602 --> 00:44:55.282
aus Komplexitätsperspektive

00:44:55.282 --> 00:44:57.743
hast du immer das Problem der Kombinatorik

00:44:57.743 --> 00:44:58.822
das heißt, wenn du

00:44:58.822 --> 00:45:01.042
n Dinge hast, die miteinander reden

00:45:01.042 --> 00:45:03.062
dann hast du halt n Quadrat Verbindungen

00:45:03.062 --> 00:45:04.623
mindestens und

00:45:04.623 --> 00:45:07.423
wenn du jetzt sagst, okay, das ist mir zu unsicher

00:45:07.423 --> 00:45:08.482
ich packe noch eins davor

00:45:08.482 --> 00:45:11.423
dann hast du noch mehr

00:45:11.423 --> 00:45:12.643
n plus 1 Quadrat

00:45:12.643 --> 00:45:14.923
Das Problem ist glaube ich an der Stelle auch

00:45:14.923 --> 00:45:17.042
wer halt irgendwie diese Architektur

00:45:17.042 --> 00:45:19.163
entscheidet und so und wem man da vertrauen kann.

00:45:19.243 --> 00:45:20.982
Gerade wenn Leute jetzt keine Ahnung haben von

00:45:20.982 --> 00:45:23.022
Sicherheit oder von Computern allgemein,

00:45:23.302 --> 00:45:25.342
aber irgendwie Software als Manager irgendwie bestellen

00:45:25.342 --> 00:45:26.802
wollen. Die haben ja eine unheimliche

00:45:26.802 --> 00:45:28.943
Asymmetrie gegenüber den auch

00:45:28.943 --> 00:45:31.123
Entwicklern und so und die müssen halt vertrauen

00:45:31.123 --> 00:45:33.183
auf das, was denen da erzählt wird

00:45:33.183 --> 00:45:35.322
und die stellen sich dann meistens so ein Sammelsurium

00:45:35.322 --> 00:45:37.562
an Angebot und Nachfrage

00:45:37.562 --> 00:45:39.203
oder Best Practice oder irgendwas,

00:45:39.322 --> 00:45:40.862
was die halt in Informationen saugen können zusammen

00:45:40.862 --> 00:45:43.322
und das ist ja auch schon so eine Art

00:45:43.322 --> 00:45:45.082
Baukasten und das ist ja nie ganzheitlich

00:45:45.082 --> 00:45:47.163
irgendwie gedacht, was wird ja auch immer dann teuer und so,

00:45:47.542 --> 00:45:49.143
muss dann auch wieder sparen und

00:45:49.143 --> 00:45:50.842
wenn man das dann rauslässt, dann ist ja klar,

00:45:50.962 --> 00:45:53.243
Fehler sind ja völlig vorprogrammiert

00:45:53.243 --> 00:45:55.143
und sich da richtig vor zu schützen

00:45:55.143 --> 00:45:56.903
ist fast eine unmögliche Aufgabe

00:45:56.903 --> 00:45:59.203
und die Frage wäre vielleicht, wie man solchen

00:45:59.203 --> 00:46:01.002
Menschen auch eine Möglichkeit geben kann,

00:46:01.423 --> 00:46:02.862
Systeme in sicherer zu denken,

00:46:03.362 --> 00:46:05.263
also ihr habt jetzt gesagt, so Prozesse von Anfang an

00:46:05.263 --> 00:46:07.362
so ein bisschen, das würde ja wirklich bedeuten,

00:46:07.462 --> 00:46:08.822
dass man sich, bevor man damit anfängt,

00:46:09.223 --> 00:46:11.062
mit einem Systemarchitekten oder sowas

00:46:11.062 --> 00:46:13.022
intensiv auseinandersetzen muss,

00:46:13.022 --> 00:46:43.002
und Jochen unterhalten sich über die Programmiersprache Python

00:46:43.022 --> 00:47:13.002
und Jochen unterhalten sich über die Programmiersprache Python

00:47:13.022 --> 00:47:18.683
eigentlichen Zertifizierung oder die Prozesse, sondern vielleicht mehr, wie lasse ich die entwickeln?

00:47:18.862 --> 00:47:23.502
Wie sorge ich dafür, dass, wie ich eben erwähnt hatte, Code Review, also wie sorge ich dafür,

00:47:23.643 --> 00:47:28.143
dass das halt schon bei der Entwicklung direkt die Software sicher ist?

00:47:28.203 --> 00:47:30.123
Weil nachher das draufzubauen ist immer schwieriger.

00:47:30.482 --> 00:47:33.383
Also nachher mit dem Scanner zu suchen ist, glaube ich, schwieriger als zu sagen, okay,

00:47:33.783 --> 00:47:36.643
ich habe Entwickler, die sich direkt darüber Gedanken machen.

00:47:37.002 --> 00:47:38.442
Das ist ja zum Beispiel total kaputt.

00:47:38.542 --> 00:47:41.643
Also ich hatte jetzt irgendwie mal so die Situation, dass so ein Konzern da war.

00:47:41.643 --> 00:47:43.903
und die wollten dann Software bereitstellen

00:47:43.903 --> 00:47:46.062
und dann haben sie gesagt, nee, aber neue Software

00:47:46.062 --> 00:47:47.962
ist irgendwie komisch, wir wollen die alle auditieren vorher

00:47:47.962 --> 00:47:49.602
so persönlich, also als Security-Team

00:47:49.602 --> 00:47:52.243
und haben dann so ein Service dann rausgebracht

00:47:52.243 --> 00:47:54.102
dann jetzt im November und da war

00:47:54.102 --> 00:47:56.062
dann Django 1.10.4, weil das dann die

00:47:56.062 --> 00:47:57.962
sichere Version war. Also LTS war 1.11

00:47:57.962 --> 00:48:00.102
für alle, die es noch wissen. Das ist halt schon ein altes

00:48:00.102 --> 00:48:01.743
System und da gibt es halt dann irgendwie schon jede Menge

00:48:01.743 --> 00:48:03.743
Exploits, wenn man irgendwie genug nach sucht,

00:48:03.783 --> 00:48:05.962
die irgendwo drinstehen und das wird dann

00:48:05.962 --> 00:48:08.022
von den Leuten irgendwie geaudited und man fragt sich halt

00:48:08.022 --> 00:48:09.223
okay, was machen die denn da eigentlich?

00:48:09.223 --> 00:48:10.802
Warum tun die das?

00:48:12.482 --> 00:48:15.042
Das ist halt wieder der Griff in Richtung

00:48:15.042 --> 00:48:16.962
Product Security statt Process Security

00:48:16.962 --> 00:48:21.102
Also ein prozesshafter

00:48:21.102 --> 00:48:22.602
Ansatz und wir haben jetzt ja auch seit

00:48:22.602 --> 00:48:24.482
einhalb Jahren, doch seit

00:48:24.482 --> 00:48:26.903
ein bisschen mehr als eineinhalb Jahren machen wir bei uns ISO 27000

00:48:26.903 --> 00:48:28.582
und

00:48:28.582 --> 00:48:30.783
der Trick ist halt bei

00:48:30.783 --> 00:48:32.542
vielen, die prozesshaften

00:48:32.542 --> 00:48:34.502
Security Sachen werden häufig missverstanden

00:48:34.502 --> 00:48:36.822
weil die Standards, die es dazu

00:48:36.822 --> 00:48:38.982
gibt, wie eine Keule aussehen

00:48:38.982 --> 00:48:40.542
obwohl sie eigentlich gar nicht so schlimm sind

00:48:40.542 --> 00:48:43.143
man muss da bloß, wenn man die Standards interpretiert

00:48:43.143 --> 00:48:44.362
immer unterscheiden zwischen

00:48:44.362 --> 00:48:46.163
was fordert der Standard formal

00:48:46.163 --> 00:48:48.502
und was ist im nächsten Satz schon nur noch die

00:48:48.502 --> 00:48:51.163
Implementationsguideline

00:48:51.163 --> 00:48:52.643
wo man dann eigentlich

00:48:52.643 --> 00:48:55.562
selber Hoheit hat, also ich habe halt auch jemanden

00:48:55.562 --> 00:48:56.783
der meinte

00:48:56.783 --> 00:48:58.903
der ISO 27000, seitdem müssen

00:48:58.903 --> 00:49:00.982
wir sämtliche Stromkabel

00:49:00.982 --> 00:49:01.942
einmal im Jahr

00:49:01.942 --> 00:49:04.883
irgendwie auf die Erdung prüfen

00:49:04.883 --> 00:49:07.183
also, ne, muss man nicht

00:49:07.183 --> 00:49:08.962
ich habe auch eine 27, aber dann müsste man das doch auch mal so

00:49:08.962 --> 00:49:09.862
nehmen müssen wir nicht.

00:49:10.562 --> 00:49:12.482
Ja, aber, aber, ja, nehmen müssen wir nicht.

00:49:13.582 --> 00:49:15.163
Dann dreht man so eine Schleife mit,

00:49:15.243 --> 00:49:16.903
naja, die ISO sagt, du musst dich halt

00:49:16.903 --> 00:49:18.743
um die für dich relevanten Normen und

00:49:18.743 --> 00:49:20.883
Vorschriften kümmern, das sagt die

00:49:20.883 --> 00:49:22.942
ISO 27000, also macht man

00:49:22.942 --> 00:49:24.862
das, und die sagt aber auch,

00:49:24.922 --> 00:49:26.123
du musst sie bewerten

00:49:26.123 --> 00:49:28.982
und musst dann Schlussfolgerungen für dich

00:49:28.982 --> 00:49:29.703
daraus ziehen.

00:49:30.562 --> 00:49:32.723
Und es ist völlig legitim im Rahmen der ISO

00:49:32.723 --> 00:49:34.802
zu sagen, ja, wir haben zur Kenntnis

00:49:34.802 --> 00:49:36.143
genommen, dass ortsveränderliche

00:49:36.143 --> 00:49:38.683
elektrische Verbraucher irgendwie alle zwei Jahre auf

00:49:38.683 --> 00:49:39.723
X geprüft werden müssen.

00:49:41.022 --> 00:49:41.883
Machen wir nicht.

00:49:42.883 --> 00:49:44.663
Ihr könnt doch mal erklären, was für eine Lücke

00:49:44.663 --> 00:49:46.602
das offen lassen könnte, warum

00:49:46.602 --> 00:49:48.802
man das testen wollen möchte.

00:49:49.723 --> 00:49:50.623
So, naja, ISO als

00:49:50.623 --> 00:49:52.082
Prozess, die ISO als

00:49:52.082 --> 00:49:54.862
Informationssicherheitsprozess ist extrem umfassend

00:49:54.862 --> 00:49:56.842
und zwingt dich dazu,

00:49:57.302 --> 00:49:59.143
den kompletten Wertschöpfungsprozess

00:49:59.143 --> 00:50:00.743
von einem IT-System

00:50:00.743 --> 00:50:02.502
zu betrachten. Da gehört halt dann unter anderem

00:50:02.502 --> 00:50:04.143
auch dazu, dass

00:50:04.143 --> 00:50:06.362
du eben rechtliche

00:50:06.362 --> 00:50:08.002
Rahmenbedingungen bewertest,

00:50:08.002 --> 00:50:10.263
etc., weil du musst am Ende

00:50:10.263 --> 00:50:11.703
immer für alle deine Assets

00:50:11.703 --> 00:50:14.042
und für den hat das halt schon die vier

00:50:14.042 --> 00:50:16.002
Grundsicherheitsaspekte, also

00:50:16.002 --> 00:50:18.203
bei uns sind sie aufgeschlüsselt, manchmal wären es drei,

00:50:18.302 --> 00:50:20.362
manchmal wären es vier, halt nach

00:50:20.362 --> 00:50:22.342
Vertraulichkeit, Confidentiality,

00:50:22.822 --> 00:50:24.002
nach Integrität,

00:50:24.322 --> 00:50:26.203
Integrity, nach Authentizität

00:50:26.203 --> 00:50:28.163
und nach Availability

00:50:28.163 --> 00:50:30.362
zu schütten. Und was hat das jetzt damit zu tun,

00:50:30.442 --> 00:50:31.763
dass da so ein Stromkabel ist,

00:50:32.102 --> 00:50:34.123
in das sich... Ja, Strom ist zum Beispiel für die Availability

00:50:34.123 --> 00:50:36.203
relativ wichtig. Okay, also

00:50:36.203 --> 00:50:40.942
Availability, okay. Und du misst halt dann da quasi nur die Stromleitung, um zu testen, ob das Ding irgendwann mal ausfällt.

00:50:41.422 --> 00:50:44.163
Es ist halt eine deutsche Norm, die kommt aus dem

00:50:44.163 --> 00:50:48.102
ich weiß nicht welches ist, die schreibt halt vor, dass halt alle

00:50:48.102 --> 00:50:51.962
ortsveränderlichen Verbraucher auf

00:50:51.962 --> 00:50:56.302
sind alle zwei Jahre halt so. Und wenn die ISO halt sagt, du musst halt

00:50:56.302 --> 00:51:00.243
alle für dich gültigen Rechtsnormen berücksichtigen und

00:51:00.243 --> 00:51:04.422
überwachen etc., dann schlägt sowas halt auch zu. Was die Leute aber eben häufig missverstehen

00:51:04.422 --> 00:51:06.562
ist, dass in der ISO drinsteht, du sollst es bewerten.

00:51:07.623 --> 00:51:08.602
Und du sollst für dich

00:51:08.602 --> 00:51:10.322
daraus ableiten, ob das jetzt

00:51:10.322 --> 00:51:12.302
was Relevantes ist oder nicht. Du kannst als

00:51:12.302 --> 00:51:14.403
Geschäftsführer oder als CISO an der Stelle immer

00:51:14.403 --> 00:51:16.502
sagen, okay, ich habe da fünf Risiken

00:51:16.502 --> 00:51:18.302
gesehen, ich akzeptiere die.

00:51:19.643 --> 00:51:20.542
Jetzt hast du aber meine Story

00:51:20.542 --> 00:51:22.322
kaputt gemacht. Ich wollte eigentlich die

00:51:22.322 --> 00:51:24.342
Story hören, wie man durch das Stromkabel

00:51:24.342 --> 00:51:26.203
in den Rechner des NUS einbringt.

00:51:27.922 --> 00:51:28.322
Stromkabel,

00:51:29.022 --> 00:51:30.462
das kann zum Beispiel passieren,

00:51:30.542 --> 00:51:32.082
wenn du deinen Prozess so aufschätzt und sagst,

00:51:32.082 --> 00:52:02.062
und Jochen unterhalten sich über die Programmiersprache Python

00:52:02.082 --> 00:52:26.082
und

00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:26.082


00:52:26.082 --> 00:52:29.263
sehr, sehr lange, teilweise 10, 15 Jahre und länger.

00:52:29.842 --> 00:52:34.763
Das heißt, wenn ich, und auch teilweise mit politischem Impact,

00:52:35.362 --> 00:52:38.042
also wir haben ein paar Systeme, die sind unter anderem zu uns gewandert,

00:52:38.243 --> 00:52:43.522
extra aus Amerika raus, von Non-Profits, die unter anderem im Nahen Osten halt aktiv sind.

00:52:44.123 --> 00:52:48.763
Und die haben ein massives Sicherheitsbedürfnis um das Leben derer,

00:52:48.962 --> 00:52:53.362
deren Daten in dem Ding drin stehen, weil da halt Decknamen und so ein Zeug auftauchen.

00:52:53.362 --> 00:52:54.763
und die,

00:52:55.783 --> 00:52:56.982
wenn du dann halt sagst, naja,

00:52:57.422 --> 00:52:59.203
wenn da jemand ein richtiges Longgame spielt

00:52:59.203 --> 00:53:00.763
und sagt, ich hab hier drei Jahre Zeit,

00:53:01.203 --> 00:53:02.203
das ist nicht das Problem.

00:53:02.903 --> 00:53:05.362
Ich will aber, dass diese NGO mal so richtig gegen die Wand

00:53:05.362 --> 00:53:07.183
fährt, dann fahre ich jetzt die Lücke

00:53:07.183 --> 00:53:09.422
und sage, aha, ich hab rausgefunden, der ein Hoster

00:53:09.422 --> 00:53:10.763
kauft immer irgendwie beim,

00:53:11.223 --> 00:53:12.942
aus der Grabbelkiste die Stromkabel,

00:53:13.283 --> 00:53:15.203
das dauert jetzt, naja, der tauscht nur so und so oft

00:53:15.203 --> 00:53:17.342
die Stromkabel aus, aber wenn ich

00:53:17.342 --> 00:53:19.062
es schaffe, irgendwie ein Drittel

00:53:19.062 --> 00:53:21.283
seiner Stromkabel durch meine mit dieser Schmelzsicherung

00:53:21.283 --> 00:53:23.322
zu ersetzen, dann bin ich in drei Jahren

00:53:23.322 --> 00:53:25.082
soweit, dass dann irgendwie bei dem das RZ

00:53:25.082 --> 00:53:25.663
implodiert.

00:53:28.322 --> 00:53:29.482
Das ist sozusagen

00:53:29.482 --> 00:53:31.082
die... Und da muss man immer

00:53:31.082 --> 00:53:31.582
aufpassen.

00:53:33.562 --> 00:53:35.183
Da kommt dieser, welcher XKCD ist

00:53:35.183 --> 00:53:36.723
das mit der hohen Verschlüsselung und

00:53:36.723 --> 00:53:39.462
der 5-Dollar-Entschlüsselungsmaschine?

00:53:40.602 --> 00:53:41.302
XKCD, bitte

00:53:41.302 --> 00:53:41.842
nochmal einmal.

00:53:43.243 --> 00:53:44.743
XKCD, Comic.

00:53:46.903 --> 00:53:47.403
Da gibt es

00:53:47.403 --> 00:53:49.322
eine schöne...

00:53:49.322 --> 00:53:50.962
Wo die Idee ist, dass du

00:53:50.962 --> 00:53:53.002
eine ganz, ganz teure Verschlüsselung kaufen kannst

00:53:53.002 --> 00:53:54.422
mit super zertifiziert

00:53:54.422 --> 00:53:56.763
und dann kommt aber jemand zu deinem

00:53:56.763 --> 00:53:57.663
Admin mit einem

00:53:57.663 --> 00:54:00.683
5 Dollar Baseballschläger und

00:54:00.683 --> 00:54:02.663
bedroht ihn dann und sagt, okay, gib mir das Passwort

00:54:02.663 --> 00:54:04.723
und wenn das für mich gibt, dann hau ich

00:54:04.723 --> 00:54:06.643
dich mit dem Schläger und dann bringt dir die

00:54:06.643 --> 00:54:08.763
beste Zertifizierung und die beste Sicherheit nichts.

00:54:08.922 --> 00:54:10.123
Ja, tatsächlich, ja.

00:54:10.442 --> 00:54:12.322
Und man sagt halt auch an der Stelle, weil häufig, also

00:54:12.322 --> 00:54:14.123
wenn jetzt halt gerade dieses Thema

00:54:14.123 --> 00:54:16.462
Advanced Persistent Threat, also

00:54:16.462 --> 00:54:18.663
die typischerweise staatlich

00:54:18.663 --> 00:54:20.502
finanzierte Organisationen

00:54:20.502 --> 00:54:22.442
oder Teams, die irgendwo reingehen sollen,

00:54:22.442 --> 00:54:24.022
man sagt halt auch so schön

00:54:24.022 --> 00:54:25.842
gegen den Mossad

00:54:25.842 --> 00:54:28.922
schützt du dich nicht

00:54:28.922 --> 00:54:31.183
weil den Mossad

00:54:31.183 --> 00:54:32.263
interessiert nicht

00:54:32.263 --> 00:54:34.683
was du für Security irgendwo in deinem RZ hast

00:54:34.683 --> 00:54:37.062
der kommt zu dir nach Hause und nimmt dich mit

00:54:37.062 --> 00:54:39.082
und dann reden wir nochmal

00:54:39.082 --> 00:54:40.883
so deswegen

00:54:40.883 --> 00:54:41.223
ist eben

00:54:41.223 --> 00:54:43.962
wenn man das mal schluckt und sagt

00:54:43.962 --> 00:54:47.123
ich bin hier nicht der der sich gegen den Mossad schützen muss

00:54:47.123 --> 00:54:48.163
weil ich habe eh keine Chance

00:54:48.163 --> 00:54:50.942
dann brauche ich aber auch nicht so tun

00:54:50.942 --> 00:54:52.942
als wenn ich sozusagen alles auf dem Niveau

00:54:52.942 --> 00:54:55.183
machen müsste. Oder du brauchst einen eigenen Geheimdienst.

00:54:56.022 --> 00:54:56.283
Bitte?

00:54:56.643 --> 00:54:58.982
Oder du brauchst einen eigenen Geheimdienst. Ja, genau.

00:55:01.002 --> 00:55:02.783
Das Fiese am Internet ist ja, dass

00:55:02.783 --> 00:55:05.263
du immer mit den besten Angreifern

00:55:05.263 --> 00:55:06.643
kommunizierst. Das heißt,

00:55:07.022 --> 00:55:08.962
vielleicht nicht mit dem Mossad, aber vielleicht hast du

00:55:08.962 --> 00:55:10.962
irgendwelche russische Hacker, die durchaus was drauf haben

00:55:10.962 --> 00:55:12.942
und die installieren dann halt wie

00:55:12.942 --> 00:55:14.862
hier in der Uniklinik Düsseldorf

00:55:14.862 --> 00:55:16.743
deine Ransomware und die wollen halt,

00:55:17.022 --> 00:55:18.903
die sind auch fast auf dem Level

00:55:18.903 --> 00:55:20.362
von so einem Advanced Persistent Threat.

00:55:20.942 --> 00:55:32.903
und die haben vielleicht jetzt nicht so, also die machen schon ein bisschen Streufeuer, aber die haben durchaus das technische Know-how und auch die Zeit und die machen sich auch die Mühe, das an deine Architektur anzupassen.

00:55:34.143 --> 00:55:45.663
Also vielleicht nochmal kurz, und nicht in Düsseldorf, da gab es einen Vorfall, da ist die Server rausgefallen und da das Netzwerk intern nicht geordnet war, konnte man durch den einen befallenen Rechner irgendwie mehrere OP-Säle ausknipsen, wenn ich das richtig verstanden habe.

00:55:45.663 --> 00:55:45.663


00:55:45.663 --> 00:55:50.502
Ja, ich weiß nicht genau, was da passiert ist, aber war

00:55:50.502 --> 00:55:51.842
Hab ich nicht verfolgt, muss ich zugeben

00:55:51.842 --> 00:55:54.342
War aber auch, glaube ich, nicht der erste Fall in Deutschland

00:55:54.342 --> 00:55:56.502
und ich glaube, Python hat es auch ein paar Mal so richtig erwischt

00:55:56.502 --> 00:56:00.263
Die, ne, natürlich, also das ist halt ja

00:56:00.263 --> 00:56:02.123
jetzt erstmal, die Mossad-Beispiele

00:56:02.123 --> 00:56:04.042
kommen immer zu dem Thema, wenn man anfängt, die

00:56:04.042 --> 00:56:06.223
Physical Security halt extrem stark

00:56:06.223 --> 00:56:08.442
zu übertreiben und das ist aber dummerweise

00:56:08.442 --> 00:56:10.302
auch das, wo Leute gerne übertreiben, weil das können

00:56:10.302 --> 00:56:11.163
sie sich bildlich vorstellen

00:56:11.163 --> 00:56:14.123
Dann kommt halt immer noch ein, ja, warum ist hier vor dem RZ keine

00:56:14.123 --> 00:56:14.123


00:56:14.123 --> 00:56:44.102
und Jochen unterhalten sich über die Programmiersprache Python

00:56:44.123 --> 00:56:46.482
abzugrenzen von, wenn du

00:56:46.482 --> 00:56:48.462
das Niveau hast, musst du dir nochmal um ganz andere

00:56:48.462 --> 00:56:50.403
Sachen Gedanken machen und wenn man das aber mal

00:56:50.403 --> 00:56:52.283
so übertrieben hat, dann wird den Leuten schnell klar, dass

00:56:52.283 --> 00:56:54.322
Security halt eine Abwägung ist und eine

00:56:54.322 --> 00:56:56.703
kontextspezifische Abwägung und immer nur auf 100%

00:56:56.703 --> 00:56:58.403
zu schalten, geht halt nicht.

00:56:59.283 --> 00:57:00.502
Und damit macht man auch mehr kaputt.

00:57:00.842 --> 00:57:02.582
Ich würde halt nochmal anknüpfen an den Punkt von

00:57:02.582 --> 00:57:04.442
dieser Prozessempfehlung, ich würde

00:57:04.442 --> 00:57:06.542
halt immer versuchen, an allen Enden

00:57:06.542 --> 00:57:08.582
weniger ist mehr zu machen.

00:57:09.322 --> 00:57:10.663
Weniger Code, den du schreibst,

00:57:10.723 --> 00:57:12.383
ist typischerweise weniger Architektur,

00:57:12.462 --> 00:57:13.922
über die du nachdenken musst, ist weniger

00:57:14.123 --> 00:57:19.442
und damit auch ein Team, was gerade erst anfängt, würde ich eben nicht sagen, ihr fangt jetzt mal an, euch über Security-Gedanken zu machen.

00:57:20.263 --> 00:57:25.422
Auch bei uns in der ISO ist es halt, in unserer Umsetzung der ISO 27000 ist es halt auch so, dass wir sagen,

00:57:26.022 --> 00:57:28.862
du willst irgendwie ein neues Feature für die Plattform etc. entwickeln? Ja, mach halt.

00:57:29.723 --> 00:57:30.623
Ja, mach halt.

00:57:31.183 --> 00:57:35.903
Ja, und du kannst gern auch irgendwie deine drei, vier Testmaschinen auf der Plattform halt schon mal auf diese Branch umstellen.

00:57:36.422 --> 00:57:37.362
Habe ich kein Problem mit.

00:57:38.002 --> 00:57:43.403
Aber bevor das dann halt in großen Einsatz kommt, muss das halt mal durch eine Vier-Augen-Review durch.

00:57:43.403 --> 00:57:46.442
und dann musst du mal irgendjemand anders erklärt haben, was du dir gedacht hast.

00:57:46.502 --> 00:57:51.842
Und dann gibt es dort eine Checkliste und die fragt, jetzt erklär mir mal, was du dir zu Security für Gedanken gemacht hast.

00:57:51.842 --> 00:57:56.842
Und das ist im Prinzip, das ist bei uns der komplette formale Prozess für die Entwicklungssicherheit.

00:57:58.783 --> 00:58:03.302
Also übertrieben jetzt ein bisschen, aber im Prinzip ist sozusagen bei uns nur ein, ja komm, entwickle halt.

00:58:03.602 --> 00:58:07.403
Da drüben sind die zehn Guidelines, was man in welchen Situationen so alles mal berücksichtigen könnte.

00:58:07.403 --> 00:58:11.542
und aber das Einzige, wozu wir dich zwingen, ist, du musst in den Pull-Request,

00:58:11.783 --> 00:58:14.102
wo dein Feature in die General Availability geht,

00:58:14.623 --> 00:58:18.183
musst du mir oder deinem PR-Reviewer glaubhaft vermitteln,

00:58:18.283 --> 00:58:21.143
dass du dir jetzt wirklich adäquat zu dem Ding Gedanken gemacht hast.

00:58:21.962 --> 00:58:24.322
Schreibt man das dann als Text in den Pull-Request?

00:58:24.322 --> 00:58:25.783
Als Text in den Pull-Request rein.

00:58:27.263 --> 00:58:31.322
Da gibt es zwei Fragen. Das eine ist, was sind hier die Sicherheitsanforderungen

00:58:31.322 --> 00:58:33.743
und B, wie habt ihr die erfüllt?

00:58:34.643 --> 00:58:36.422
Wo ist hier der Nachweis, dass die erfüllt wurden?

00:58:36.422 --> 00:58:40.822
Wie seid ihr zu der Frage gekommen von was sind hier die relevanten Sicherheitsanforderungen

00:58:40.822 --> 00:58:44.383
und wie weist ihr nach, dass ihr das jetzt halt ordentlich umgesetzt habt?

00:58:44.502 --> 00:58:47.062
Das hört sich so ein bisschen an, als sollte man die Angst weglassen

00:58:47.062 --> 00:58:50.683
und tatsächlich nur die Worst-Case-Szenarien, also was ist das Schlimmste, was passieren kann

00:58:50.683 --> 00:58:53.342
also bei dir wären zum Beispiel jetzt Daten weg gewesen, das wäre nicht so gut gewesen

00:58:53.342 --> 00:58:55.143
weil die so sehr privat sein müssen

00:58:55.143 --> 00:58:59.302
und an anderer Stelle ist es vielleicht so, ja okay, wenn man die Backups noch hat, dann ist es halt nicht so schlimm

00:58:59.302 --> 00:59:03.942
und das ist halt dann vielleicht der Worst-Case und da muss man sich halt Gedanken darüber machen, dass der nicht eintreten kann

00:59:03.942 --> 00:59:05.342
und der Rest ist dann egal

00:59:05.342 --> 00:59:35.322
Ja.

00:59:35.342 --> 00:59:37.623
der Review-Prozess aber zum Beispiel auch umgedreht.

00:59:38.243 --> 00:59:39.283
Der Review-Prozess

00:59:39.283 --> 00:59:41.243
in dem PR bei uns ist halt

00:59:41.243 --> 00:59:43.163
immer nur ein, ja,

00:59:43.602 --> 00:59:45.383
man darf nicht alleine Zeug nach draußen

00:59:45.383 --> 00:59:47.022
prügeln. Sternchen-Fußnote.

00:59:47.322 --> 00:59:49.362
Doch, es gibt Situationen, in denen man das darf,

00:59:49.482 --> 00:59:51.123
aber dann muss man noch mehr Dinge beachten.

00:59:52.082 --> 00:59:53.342
Weil es gibt halt bei uns auch so

00:59:53.342 --> 01:00:10.065
Gefahr und Verzugssituationen dann muss ich handlungsf sein Aber der Pull ist halt wenn er gemerged wird ist das halt nicht die Aussage von dem Reviewer dass er seinen Erstgeborenen irgendwie mit Blut unterschrieben dem Teufel dass er sagt hier ist alles sicher

01:00:11.025 --> 01:00:23.165
sondern der Vier-Augen-Prozess ist dafür da, dass ein zweiter Mensch dem ersten nochmal in die Augen guckt und sagt, also wenn du jetzt nicht noch sagst, ich soll nach irgendwas schauen, dann merge ich den Kram jetzt.

01:00:23.165 --> 01:00:37.265
Das ist aber dein Code, den ich jetzt gleich merge. Und das ist ganz spannend, weil das ist ein kognitiver Prozess, der halt einer Person, einem anderen Menschen, und da gehört Empathie eben mit dazu, gegenüberstellt und sagt, ich lasse das hier raus.

01:00:37.265 --> 01:01:07.245
und Jochen unterhalten sich über die Programmiersprache Python

01:01:07.265 --> 01:01:09.365
so aufwendig, dann muss er sich aber auch lohnen,

01:01:09.845 --> 01:01:11.185
sondern wir drehen es halt um und

01:01:11.185 --> 01:01:13.265
sagen, nee, der Review-Prozess ist erstmal freundlich

01:01:13.265 --> 01:01:15.225
und der Default ist, wir gucken

01:01:15.225 --> 01:01:17.325
da zusammen drüber und alle machen ihre Arbeit

01:01:17.325 --> 01:01:18.905
und reden drüber und klären das

01:01:18.905 --> 01:01:21.305
und dann lassen wir es auch raus und dann ist der in 5 Minuten

01:01:21.305 --> 01:01:23.325
erledigt. Also wenn ich halt

01:01:23.325 --> 01:01:25.185
zum Beispiel nur, weiß ich, ein Pull-Request

01:01:25.185 --> 01:01:27.065
bei uns kann sein, Paket-Update vom

01:01:27.065 --> 01:01:28.805
Nginx, weil war ein CVE drin,

01:01:28.925 --> 01:01:30.165
kommt die nächste meiner Version.

01:01:30.365 --> 01:01:32.065
Ein CVE ist ein Vulnerable, ne?

01:01:33.145 --> 01:01:35.105
Ja genau, also war eine Vulnerability,

01:01:35.105 --> 01:01:59.045
und die

01:01:59.045 --> 01:02:25.185
Anforderungen, Anforderungen war, wir müssen Updates machen, weil wir die Sicherheit aufrechterhalten sollen. Nachweis, naja, das ist jetzt die alte Version war die, die neue ist die, zack, fertig, raus damit, Ende. That's it. Das ist halt den Leuten in den Prozessen das so an die Hand zu geben, dass sie nicht jedes Mal vor so einer Checkliste stehen von, du musst jetzt aber umhalten, damit dir nachher keiner den Kopf abbeißt, weil das ist ja alles immer nur noch Asscovering, dass niemandem die Schuld zugeschoben werden kann.

01:02:25.185 --> 01:02:29.565
und das ist ja nicht der Prozess, um den es geht, sondern der Prozess ist, dass Leute produktiv arbeiten können

01:02:29.565 --> 01:02:33.305
und während dieser Arbeit der Vektor der Änderung immer heißt,

01:02:33.545 --> 01:02:37.065
mit jeder Änderung machen wir es erstmal potenziell sicherer und nicht unsicherer.

01:02:37.445 --> 01:02:40.265
Und wenn man dann sagt, okay, wenn ich das für alle Änderungen sicherstellen kann,

01:02:40.325 --> 01:02:42.345
dass alle Änderungen die richtigen Vektor haben,

01:02:43.465 --> 01:02:46.385
ja, dann mache ich doch einfach mehr Änderungen und werde halt immer sicherer.

01:02:47.145 --> 01:02:51.085
Ja, das ist interessant, was mir da gerade noch als Idee kommt.

01:02:51.265 --> 01:02:54.905
Es gibt da ein Problem bei dieser Sache mit den quasi Pull-Requests.

01:02:54.905 --> 01:02:57.045
wenn das jetzt nicht in so einer Firma ist, wo alle Leute da Ahnung haben

01:02:57.045 --> 01:02:58.545
von dem, was sie tun, sondern wieder

01:02:58.545 --> 01:03:01.005
den nicht ganz optimalen Fall angenommen,

01:03:01.665 --> 01:03:03.065
dann kann sich jemand hinstellen,

01:03:03.145 --> 01:03:04.965
kann sagen, er ist jetzt hier der Türsteher und der guckt sich das

01:03:04.965 --> 01:03:05.405
alles an.

01:03:06.705 --> 01:03:08.445
Und dann

01:03:08.445 --> 01:03:11.005
hat er eine Existenzberechtigung, obwohl er eigentlich sonst gar nichts

01:03:11.005 --> 01:03:12.985
tun muss und das kann dann

01:03:12.985 --> 01:03:14.365
sehr, ja, so ein bisschen

01:03:14.365 --> 01:03:16.505
diese Informationsasymmetrie dann ausnutzen.

01:03:18.585 --> 01:03:18.845
Für mich

01:03:18.845 --> 01:03:20.905
regelt das der Wettbewerb. Eine Firma, die so drauf ist,

01:03:20.945 --> 01:03:22.545
wird halt Schwierigkeiten haben,

01:03:23.345 --> 01:03:24.885
wirklich immer weiter nach vorne zu laufen.

01:03:24.905 --> 01:03:28.225
Was ich halt noch spannend finde ist, dass Python natürlich

01:03:28.225 --> 01:03:29.945
um mal die Schleife jetzt noch zu ziehen

01:03:29.945 --> 01:03:32.185
auch als Sprache

01:03:32.185 --> 01:03:33.505
natürlich ein gutes Standing hat

01:03:33.505 --> 01:03:36.025
Ich hatte vorhin nochmal irgendwie durchgeguckt

01:03:36.025 --> 01:03:37.065
und wenn man halt guckt

01:03:37.065 --> 01:03:38.765
wenn ich

01:03:38.765 --> 01:03:42.045
wir könnten jetzt sozusagen, also der völlige

01:03:42.045 --> 01:03:44.225
Tiefschlag ist natürlich, wenn ich es gegen PHP vergleiche

01:03:44.905 --> 01:03:46.465
da habe ich halt

01:03:46.465 --> 01:03:48.445
das Problem, dass allein die Laufzeitumgebung

01:03:48.445 --> 01:03:49.865
von PHP und die Sprache selber

01:03:49.865 --> 01:03:52.105
ich hatte vorhin geguckt

01:03:52.105 --> 01:03:53.705
über die letzten 20 Jahre

01:03:53.705 --> 01:03:56.885
über 600 CVEs eingesammelt haben.

01:03:58.565 --> 01:04:02.685
Und die machen im Prinzip in einigen Jahren das Fünffache von dem,

01:04:02.825 --> 01:04:07.585
was Python über die letzten 20 Jahre insgesamt hat.

01:04:08.265 --> 01:04:12.065
Also bei Python kamen irgendwie 20 CVEs oder sowas raus über die letzten 20 Jahre.

01:04:12.905 --> 01:04:14.345
Viel mehr kommt da einfach nicht.

01:04:15.725 --> 01:04:17.765
Und das ist halt auch schon mal was, wo man sagen kann,

01:04:17.765 --> 01:04:18.565
okay, das ist was.

01:04:19.665 --> 01:04:22.665
Auf der einen Seite die Sprache selber hat viele Probleme nicht,

01:04:22.665 --> 01:04:26.905
so was wie ein Buffer-Overflow zum Beispiel, kannst du mit Python erstmal so nicht erzeugen

01:04:26.905 --> 01:04:30.605
und es ist auch in der Community ja so verankert, dass extrem viele Bibliotheken,

01:04:30.725 --> 01:04:34.245
viele Frameworks das ja auch als Thema für sich erklärt haben und eben sagen,

01:04:34.525 --> 01:04:38.865
wir basteln nicht nur um Security-Probleme rum, sondern versuchen sie dann ordentlich zu fixen

01:04:38.865 --> 01:04:42.965
und es gab auch in Python selber, also die Sachen, die es gab, wenn ich halt schaue,

01:04:43.045 --> 01:04:45.785
das war mal irgendwann ein LibXML-Thema,

01:04:46.405 --> 01:04:50.765
weil du halt zum Beispiel LibXML über das externes Auflösen

01:04:50.765 --> 01:04:52.705
von Entities dann irgendwie Code ausführen

01:04:52.705 --> 01:04:53.785
konntest und so ein Kram.

01:04:55.485 --> 01:04:56.905
Aber die wurden halt in der

01:04:56.905 --> 01:04:58.685
Community immer sehr

01:04:58.685 --> 01:04:59.945
differenziert und schnell

01:04:59.945 --> 01:05:02.765
diskutiert und auch adäquat behoben.

01:05:05.345 --> 01:05:06.685
Da habe ich einfach eine völlig

01:05:06.685 --> 01:05:08.425
andere Basis, von der ich ausgehe,

01:05:08.805 --> 01:05:10.765
als wenn ich praktisch bei jeder Codezeile,

01:05:10.825 --> 01:05:12.465
die ich schreibe, da denke ich dann eher so an C,

01:05:13.065 --> 01:05:14.865
tatsächlich meinen Doktorkittel angezogen

01:05:14.865 --> 01:05:16.845
haben muss, um ja nicht daneben

01:05:16.845 --> 01:05:17.345
zu tappen.

01:05:17.745 --> 01:05:19.445
Ja, dann hat das glaube ich sowas wie Rust

01:05:19.445 --> 01:05:21.365
auch deswegen gekommen, oder? Weil das genau das dann

01:05:21.365 --> 01:05:22.285
wieder anders macht und

01:05:22.285 --> 01:05:24.165
den Griff kriegt, ja.

01:05:26.065 --> 01:05:27.245
Ja, ja, also Rust ist

01:05:27.245 --> 01:05:29.425
auf jeden Fall, also ich meine, es kommt halt

01:05:29.425 --> 01:05:30.865
immer darauf an, was man jetzt,

01:05:31.385 --> 01:05:33.325
ich glaube eben vor Buffer-Overflows

01:05:33.325 --> 01:05:35.405
muss man gar nicht so viel Angst haben, aber

01:05:35.405 --> 01:05:37.585
wenn man jetzt Server betreibt,

01:05:37.685 --> 01:05:39.585
die halt super viele Requests bearbeiten

01:05:39.585 --> 01:05:40.285
oder so,

01:05:41.985 --> 01:05:43.365
was hat letztens

01:05:43.365 --> 01:05:45.045
in einem Podcast irgendwie der

01:05:45.045 --> 01:05:47.725
Entwickler von Flastia,

01:05:47.805 --> 01:05:49.365
Armin Ronacher, gesagt, er meinte so,

01:05:49.445 --> 01:06:07.325
Rust ist halt für ihn schon allein deswegen so viel netter, weil Python hätte er ja auch irgendwie sehr gerne gemacht, aber das liegt halt wie Sau. Das ist halt, da kann man, man kann nicht viel dran machen und das ist natürlich schon irgendwie, irgendwie so, ja, das ist, ja.

01:06:07.325 --> 01:06:13.145
Das würde ich gerne verstehen, weil da geht mir, Philipp dreht den Kopf und ich habe auch so ein kleines Messer, was mir in der Tasche aufgeht.

01:06:13.145 --> 01:06:13.745
Ja, ja, klar.

01:06:16.045 --> 01:06:17.205
Aber ich kann

01:06:17.205 --> 01:06:18.925
schon in gewisser Weise verstehen, was er

01:06:18.925 --> 01:06:21.105
meint. Also ich meine, bei Rust kannst du dir halt

01:06:21.105 --> 01:06:22.245
sicher sein, dass da nichts liegt,

01:06:23.145 --> 01:06:23.985
wenn du es halt richtig machst.

01:06:24.045 --> 01:06:27.225
Was meinst du denn damit da liegt was rum?

01:06:28.325 --> 01:06:29.425
Naja, zum Beispiel,

01:06:30.005 --> 01:06:30.405
dass halt

01:06:30.405 --> 01:06:32.945
der Hauptspeicher immer weiter anwächst, ohne

01:06:32.945 --> 01:06:34.625
dass du das eigentlich wolltest,

01:06:34.785 --> 01:06:37.105
sozusagen, ohne dass du wirklich den Hauptspeicher brauchst,

01:06:37.185 --> 01:06:39.185
sondern dass halt Sachen nicht wieder weggeräumt

01:06:39.185 --> 01:06:40.825
werden, die halt irgendwann mal angefallen sind.

01:06:41.665 --> 01:06:42.745
Klar, also Python

01:06:42.745 --> 01:06:44.985
nimmt dir das Memory Management halt komplett weg

01:06:44.985 --> 01:06:47.025
und das

01:06:47.025 --> 01:06:48.885
ist tatsächlich Fluch und

01:06:48.885 --> 01:06:50.865
Segen zugleich, logischerweise.

01:06:51.045 --> 01:06:52.605
Also jede technische Entscheidung, die er hinsicht hat,

01:06:52.665 --> 01:06:55.025
immer Trade-Offs und ein Aspekt bei Python

01:06:55.025 --> 01:06:56.145
ist nun mal, dass Python

01:06:56.145 --> 01:06:58.645
Speicher, den es mal gebraucht hat,

01:06:58.825 --> 01:07:00.805
auch wenn es den Akut gerade nicht braucht,

01:07:01.365 --> 01:07:02.885
nicht einfach mal so wieder hergibt.

01:07:03.465 --> 01:07:04.865
Also wenn dein Prozess mal

01:07:04.865 --> 01:07:07.045
irgendwie, keine Ahnung, ein Gig oder zwei Gig groß ist,

01:07:07.585 --> 01:07:08.945
dann kann es

01:07:08.945 --> 01:07:10.785
gut sein, dass der das jetzt für die nächste Zeit

01:07:10.785 --> 01:07:12.825
mal behält, auch wenn du alle Objekte gelöscht hast

01:07:12.825 --> 01:07:14.225
und wenn die Garbage Collection durch war,

01:07:14.745 --> 01:07:16.825
weil es ist halt auch ein Trade-Off

01:07:16.825 --> 01:07:18.845
zu sagen, naja, ständig

01:07:18.845 --> 01:07:20.765
Mellox groß und klein und

01:07:20.765 --> 01:07:22.745
groß und klein zu machen, hat auch

01:07:22.745 --> 01:07:24.825
Nachteile. Es hat Nachteile in der Hauptspeicherfragmentierung,

01:07:25.725 --> 01:07:27.165
das ist an sich ein Performance-Thema,

01:07:27.345 --> 01:07:28.425
jada, jada, jada, jada

01:07:28.425 --> 01:07:30.685
und Python als Universalsprache

01:07:30.685 --> 01:07:32.765
in der Hinsicht, wo eben Memory Management als

01:07:32.765 --> 01:07:34.745
ich kümmere mich drum drauf steht,

01:07:35.605 --> 01:07:36.965
verstehe ich, dass es in diese

01:07:36.965 --> 01:07:38.685
Richtung neigt, eben eher

01:07:38.685 --> 01:07:44.705
diesen universalen Ansatz zu verfolgen und Rust tritt nun mal an mit, du hast deinen Speicher im Griff, dann müssen sie das auch abliefern.

01:07:44.865 --> 01:07:46.385
Das ist klar.

01:07:46.945 --> 01:07:51.345
Also nochmal ganz kurz, was ein Melloc ist, also du alloziierst irgendeinen Speicher?

01:07:54.485 --> 01:08:02.165
Genau, also wenn du vom Betriebssystem halt Speicher haben möchtest, dann ist es heutzutage eh schon nur noch virtueller Speicher.

01:08:02.165 --> 01:08:32.145
und die Programmiersprache Python

01:08:32.165 --> 01:08:34.025
und dann teilt er ihnen tatsächlich irgendwie diese Sachen zu.

01:08:35.205 --> 01:08:38.625
Und deswegen gibt es einige Programme, MongoDB ist halt auch so ein Ding,

01:08:38.685 --> 01:08:43.965
die alloziieren zum Beispiel immer bloß in Vielfachen von 2 oder in 2er Potenzen oder so ein Kram.

01:08:44.445 --> 01:08:46.625
Also wenn der halt hergeht und sagt, ich brauche hier mal RAM,

01:08:47.005 --> 01:08:49.065
dann sagt er als erstes, ich brauche 64 MB,

01:08:49.185 --> 01:08:51.265
und dann irgendwie, ja jetzt hätte ich aber lieber 118 MB,

01:08:51.585 --> 01:08:53.245
okay, also jetzt hätte ich gerne 1 GB.

01:08:53.445 --> 01:08:55.505
Und das kann manchmal schon so ein bisschen unangenehm sein,

01:08:55.505 --> 01:08:57.125
aber

01:08:57.125 --> 01:09:00.725
der Vorteil ist halt

01:09:00.725 --> 01:09:02.645
wenn der Speicher dann auch am Stück

01:09:02.645 --> 01:09:04.725
ausgeliefert wird, dann hat das bestimmte

01:09:04.725 --> 01:09:06.925
andere charmante Aspekte

01:09:06.925 --> 01:09:08.945
weil dann bestimmte Overhead-Strukturen im Kernel

01:09:08.945 --> 01:09:10.785
dann halt reduziert werden können, der kann sogenannte

01:09:10.785 --> 01:09:11.945
Huge-Pages machen, das heißt

01:09:11.945 --> 01:09:14.885
du musst dann halt nicht, wenn du einen Gigabyte

01:09:14.885 --> 01:09:16.765
alloziierst, muss der Kernel halt nicht

01:09:16.765 --> 01:09:17.865
eine Million mal

01:09:17.865 --> 01:09:20.625
eine 1 Kilobyte-Page irgendwo

01:09:20.625 --> 01:09:22.725
in seiner Tabelle abmarkern, weil auch das

01:09:22.725 --> 01:09:24.765
kann plötzlich schon mal 2, 3, 4,

01:09:24.765 --> 01:09:29.325
500 Millisekunden dauern, sondern der sagt dann einfach nur noch, hier hast du das Gigabyte.

01:09:30.605 --> 01:09:34.625
Und das sind so Sachen, wo Python dann eben auch häufig optimiert und Python ist extrem

01:09:34.625 --> 01:09:38.925
erfolgreich, was diese Optimierung angeht. Ein Beispiel dafür sind zum Beispiel Listen.

01:09:39.785 --> 01:09:47.165
Listen haben eine, es gibt eine Operation bei Listen, die ist unoffensichtlich O von 1,

01:09:47.165 --> 01:09:53.865
nämlich ein Append an Listen bei Python

01:09:53.865 --> 01:09:56.145
ist

01:09:56.145 --> 01:10:00.445
sind Listen nicht immer ein O von 1 Append?

01:10:00.865 --> 01:10:01.245
Ja, sollte.

01:10:02.365 --> 01:10:06.045
Es gab irgendeinen spezifischen Fall.

01:10:06.045 --> 01:10:09.705
Also die Story drumherum grob ist die, dass die Speicherallokation

01:10:09.705 --> 01:10:14.285
für Listen in Python auch immer nur verdoppelt.

01:10:15.125 --> 01:10:17.105
Der allozidierten Buffer für die

01:10:17.105 --> 01:10:19.565
für das Array, um die Indizes zu verwalten

01:10:19.565 --> 01:10:21.285
und

01:10:21.285 --> 01:10:22.925
alloziiert aber, wenn er dann

01:10:22.925 --> 01:10:24.945
es größer machen muss, nicht einfach

01:10:24.945 --> 01:10:26.845
sozusagen, dann muss er ja sozusagen

01:10:26.845 --> 01:10:29.005
das ganze, achso genau, das Problem ist, wenn du es dann größer

01:10:29.005 --> 01:10:30.385
machen willst, musst du

01:10:30.385 --> 01:10:32.905
den Bestandsspeicher plus 1 nochmal

01:10:32.905 --> 01:10:34.905
neu alloziieren, alles umkopieren und

01:10:34.905 --> 01:10:36.885
dann halt das neue reinschreiben. Was Python aber macht

01:10:36.885 --> 01:10:38.965
ist, Python alloziiert immer

01:10:38.965 --> 01:10:40.925
dann das Doppelte von dem, was es vorher hatte,

01:10:41.925 --> 01:10:42.885
kopiert das einmal um,

01:10:43.645 --> 01:10:44.565
dann sind die nächsten

01:10:44.565 --> 01:10:46.325
n gratis,

01:10:47.105 --> 01:11:05.785
Dann muss er wieder einmal verdoppeln, einmal kopieren und dann hast du wieder 2n gratis und das sind so typische Sachen, die man in solchen Situationen halt hat, was so Laufzeitumgebungen für einen automatisieren und machen und weswegen sich dann hinten so ein bisschen komische Speichereffekte ergeben.

01:11:05.785 --> 01:11:10.225
da habe ich lange Zeit meines Lebens auch immer mit dem Kopf

01:11:10.225 --> 01:11:14.865
an meinem Kopf kratzend davor gestanden und konnte Leuten nicht erklären, warum es das jetzt gerade tut

01:11:14.865 --> 01:11:18.545
und da muss man sich halt irgendwann sagen, kann man nicht erklären, warum es genau das jetzt gerade tut

01:11:18.545 --> 01:11:21.885
kann ich dir nicht erklären, ich bin mir relativ sicher, dass es kein Leak ist

01:11:21.885 --> 01:11:25.805
wenn du halt dann irgendwie mal sowas beobachtest über eine Woche oder einen Monat

01:11:25.805 --> 01:11:30.065
wenn du einen langlaufenden Prozess hast und die Saisonalitäten findest und du was merkst wie

01:11:30.065 --> 01:11:34.485
ah ok, frühmorgens haben die Leute ihren Kaffee getrunken, jetzt lesen sie alle irgendwie das was auf seiner Webseite ist

01:11:34.485 --> 01:12:04.465
und Jochen unterhalten sich über die Programmiersprache Python

01:12:04.485 --> 01:12:06.685
ist es schwierig, kontrollierbar schlanke

01:12:06.685 --> 01:12:07.465
Prozesse zu machen.

01:12:08.505 --> 01:12:10.665
Das geht nicht so ohne weiteres. Also das geht schnell,

01:12:10.845 --> 01:12:12.705
dass dein, wenn du

01:12:12.705 --> 01:12:15.005
zum Beispiel eine Datenverarbeitungspipeline

01:12:15.005 --> 01:12:16.805
hast mit 9 oder 10 Schritten

01:12:16.805 --> 01:12:18.545
und jeder Schritt davon braucht

01:12:18.545 --> 01:12:20.585
irgendwie einen Gigabyte RAM,

01:12:20.905 --> 01:12:22.705
dann kann das schon sein, dass dein Python nachher

01:12:22.705 --> 01:12:23.505
10 Gig frisst.

01:12:24.705 --> 01:12:26.585
Weil er halt eben den Speicher von vorher

01:12:26.585 --> 01:12:28.605
noch nicht freigegeben hatte, der jetzt aber auch gerade nicht

01:12:28.605 --> 01:12:30.665
gepasst hat, um das nächste Ding zu bearbeiten

01:12:30.665 --> 01:12:32.205
und dann so.

01:12:32.205 --> 01:12:35.665
Das kriegst du unter Python halt nicht gut kontrolliert

01:12:35.665 --> 01:12:37.725
Ja, vor allem weil alles so dynamisch ist

01:12:37.725 --> 01:12:39.885
weil ich also im Zweifel auch wirklich den Stack hochwandern kann

01:12:39.885 --> 01:12:41.065
und schauen kann, was da rumliegt

01:12:41.065 --> 01:12:43.825
oder ein Integer-Objekt als beliebiges Objekt sehen kann

01:12:43.825 --> 01:12:45.745
was halt in Rast ohne weiteres nicht möglich ist

01:12:45.745 --> 01:12:47.065
und auch in anderen Programmiersprachen nicht geht

01:12:47.065 --> 01:12:49.625
Aber auch

01:12:49.625 --> 01:12:51.725
ohne Speicherverwaltung kann ich ja in Python

01:12:51.725 --> 01:12:53.525
durchaus noch andere Sicherheitslücken machen

01:12:53.525 --> 01:12:55.145
die also gar nichts mit dem Speicher zu tun haben

01:12:55.145 --> 01:12:57.845
mit dem, was wir jetzt die meiste Zeit besprochen haben

01:12:57.845 --> 01:12:59.185
sondern halt zum Beispiel, dass ich sage

01:12:59.185 --> 01:13:00.705
ich verwende einen Subprozess

01:13:00.705 --> 01:13:02.745
und öffne den Subprozess und

01:13:02.745 --> 01:13:05.345
übergebe

01:13:05.345 --> 01:13:07.265
einen String und habe diesen

01:13:07.265 --> 01:13:09.025
String halt konstruiert aus Benutzerdaten

01:13:09.025 --> 01:13:11.465
und jetzt habe ich plötzlich eine Command Injection,

01:13:11.525 --> 01:13:13.385
dass man beliebige Shell-Commandos ausführen

01:13:13.385 --> 01:13:13.625
kann.

01:13:15.185 --> 01:13:17.105
Das kann man in jeder Programmiersprache

01:13:17.105 --> 01:13:19.405
und in jeder

01:13:19.405 --> 01:13:20.785
Programmiersprache, die Shell-Commandos ausführen kann.

01:13:20.865 --> 01:13:22.665
Natürlich kannst du dich auf den Standpunkt stellen,

01:13:22.985 --> 01:13:24.865
man hat das gefälligst nicht zu machen oder

01:13:24.865 --> 01:13:27.285
man hat gefälligst immer Shell gleich false zu setzen

01:13:27.285 --> 01:13:29.185
oder der Standard, dass man eine Liste

01:13:29.185 --> 01:13:29.585
übergibt.

01:13:30.705 --> 01:13:31.305
aber

01:13:31.305 --> 01:13:34.525
es gibt noch zahlreiche andere

01:13:34.525 --> 01:13:35.885
Schwachstellen, glaube ich, die

01:13:35.885 --> 01:13:38.605
auf höherem Level noch passieren können,

01:13:38.665 --> 01:13:40.245
die gar nichts mit dem Speicher direkt zu tun haben.

01:13:42.005 --> 01:13:42.165
Ja,

01:13:42.565 --> 01:13:43.405
absolut, genau.

01:13:44.145 --> 01:13:46.305
Habt ihr schon mal böse Sachen gesehen, die in Python

01:13:46.305 --> 01:13:47.305
schiefgegangen sind?

01:13:48.925 --> 01:13:50.385
Ich weiß nicht, ich überlege gerade, ob ich

01:13:50.385 --> 01:13:52.245
irgendwas mal wirklich

01:13:52.245 --> 01:13:53.265
Schlimmes gesehen habe.

01:13:54.245 --> 01:13:56.385
Der Shellout, den Philipp

01:13:56.385 --> 01:13:57.845
da nennt, das ist schon schlimm.

01:13:57.845 --> 01:13:59.585
Das ist klassisch.

01:13:59.585 --> 01:14:02.025
auch sehr beliebt ist, wenn Leute

01:14:02.025 --> 01:14:03.805
meinen, ich muss hier Flexibilität reinbringen

01:14:03.805 --> 01:14:05.665
und jagen halt irgendwie User-Input einfach durch

01:14:05.665 --> 01:14:07.385
ein Eval durch. Das ist sozusagen

01:14:07.385 --> 01:14:09.545
die interne Variante des Shell-Out.

01:14:09.865 --> 01:14:10.945
Was ist denn ein Eval?

01:14:11.345 --> 01:14:15.525
Eval ist Evil.

01:14:16.625 --> 01:14:18.225
Aber das ist im Prinzip die...

01:14:18.225 --> 01:14:19.985
Oh ja, doch, Pickle.

01:14:20.305 --> 01:14:20.785
Eieiei.

01:14:21.985 --> 01:14:23.845
Ja, Pickle, nur trusted.

01:14:23.845 --> 01:14:24.305
Ja.

01:14:25.205 --> 01:14:26.845
Da kann man sich schon mit dem Fuß schießen.

01:14:26.905 --> 01:14:29.365
Mit Eval haben wir sogar einen ganz, ganz schlimmen Bug,

01:14:29.365 --> 01:14:31.185
und zwar hat eine Anwendung auf die Idee gekommen,

01:14:31.525 --> 01:14:33.245
dass man doch das cachen könnte.

01:14:33.885 --> 01:14:35.125
Und man könnte doch

01:14:35.125 --> 01:14:37.225
den Code nehmen und dann kann man sich so ein

01:14:37.225 --> 01:14:39.025
kurzes, also man nimmt irgendwelche Benutzerdaten,

01:14:39.465 --> 01:14:41.285
die oftmals abgerufen werden, dann schreibt

01:14:41.285 --> 01:14:42.685
man dynamisch Python-Code,

01:14:43.285 --> 01:14:45.365
der das ausführt und dann kann man das cachen.

01:14:45.825 --> 01:14:46.965
Und dann war aber das Problem, dass

01:14:46.965 --> 01:14:49.205
sogar die noch eine Datenbank-Schlafstelle hatten, dass man

01:14:49.205 --> 01:14:51.265
sehen konnte, was in der Datenbank lag

01:14:51.265 --> 01:14:52.525
und da lagen deren Cache-Objekte.

01:14:52.905 --> 01:14:55.125
Und dann lagen da plötzlich Benutzer-Passwörter oder sonst

01:14:55.125 --> 01:14:56.905
irgendwelche Sachen,

01:14:57.545 --> 01:14:58.785
die halt, also da kann man halt

01:14:58.785 --> 01:15:08.085
Wenn man Schwachstellen verkettet, kann man das auf sehr krumme, sehr fiese Sachen, die man mit der einzelnen Schwachstelle gar nicht machen könnte.

01:15:08.625 --> 01:15:20.245
Also das war jetzt nicht der Fehler von denen, also es war ein Fehler, dass man den Cache plötzlich sehen kann und es war ein anderer Fehler, dass sie überhaupt Ival verwendet haben, aber erst durch die Kombination ist es halt eigentlich eine Schwachstelle gewesen.

01:15:20.245 --> 01:15:22.765
Auch so ein klassisches Ding ist ja auch

01:15:22.765 --> 01:15:24.765
Directory Traversal, dass halt

01:15:24.765 --> 01:15:26.665
irgendwie von außen sagen kannst, ich will

01:15:26.665 --> 01:15:28.805
xyz haben und dann

01:15:28.805 --> 01:15:30.425
wird halt nicht ordentlich geguckt, ob du durch

01:15:30.425 --> 01:15:32.745
. . . Kombinationen plötzlich dir

01:15:32.745 --> 01:15:34.665
dann irgendwie etc. pass, wenn du dir unseren Kram halt

01:15:34.665 --> 01:15:36.825
auslesen lassen kannst und das sind immer

01:15:36.825 --> 01:15:39.045
auch, das ist tatsächlich glaube ich am wichtigsten

01:15:39.045 --> 01:15:40.765
und deswegen ist dieses, das ist

01:15:40.765 --> 01:15:42.385
wieder Variety matches Variety

01:15:42.385 --> 01:15:44.605
deswegen sagen wir, wir wollen so schnell

01:15:44.605 --> 01:15:46.665
so viele Verbesserungen

01:15:46.665 --> 01:15:48.885
in der Security wie möglich durch unsere Entwicklungspipeline

01:15:48.885 --> 01:15:50.665
jagen können, weil

01:15:50.665 --> 01:15:53.005
die eigentlichen Vektoren ist nachher,

01:15:53.125 --> 01:15:54.785
dass du hast immer eine Vielzahl

01:15:54.785 --> 01:15:56.705
von potenziellen

01:15:56.705 --> 01:15:58.845
Schwachstellen, die für sich genommen alle gar nicht so

01:15:58.845 --> 01:16:00.845
schlimm sind. Und wenn du aber

01:16:00.845 --> 01:16:02.985
immer nur auf der Suche nach dem einen großen Ding

01:16:02.985 --> 01:16:04.665
bist, um alles zu reparieren,

01:16:05.065 --> 01:16:06.865
dann vergisst man schnell, dass es halt eher um

01:16:06.865 --> 01:16:08.225
diese Verkettung geht, wie Philipp sagt.

01:16:08.725 --> 01:16:10.785
Da gibt es viele Kleinigkeiten, die das halt machen.

01:16:10.925 --> 01:16:12.625
Also eben Directory Traversal, irgendwie Daten

01:16:12.625 --> 01:16:14.705
abzusaugen, die dir dann einfach nur noch den Pointer geben

01:16:14.705 --> 01:16:16.565
für, ah guck mal, da könntest du da drüben nochmal gucken.

01:16:16.565 --> 01:16:19.945
in Klassiker, den ich mag, sind Exceptions.

01:16:21.065 --> 01:16:26.245
Exceptions sind für mich die sensibelsten Daten, die dein System zur Laufzeit eigentlich von sich gibt,

01:16:27.025 --> 01:16:31.885
weil das Problem ist ja folgendes, dein System ist in einem nicht bekannten Zustand,

01:16:32.565 --> 01:16:36.685
mit Daten, die du nicht kennst und weißt nicht mehr, was es tun soll.

01:16:37.445 --> 01:16:40.605
So, und die Daten können halt alles sein.

01:16:40.805 --> 01:16:43.845
Das können die Kreditkartendaten sein, das können die was auch immer.

01:16:43.945 --> 01:16:46.045
Und dann steht da irgendwie Value Error, hast du nicht gesehen?

01:16:46.565 --> 01:16:48.805
und du kannst den User nicht davon abhalten,

01:16:48.945 --> 01:16:50.325
Daten ins falsche Feld zu schreiben.

01:16:50.705 --> 01:16:52.545
Dann schreibt er seine Kreditkartendaten

01:16:52.545 --> 01:16:54.685
halt das erste Mal irgendwie bei seinem Nachnamen aus Versehen

01:16:54.685 --> 01:16:56.445
rein. Und deswegen diese

01:16:56.445 --> 01:16:58.505
Bewertung von was ist eigentlich sicher und was

01:16:58.505 --> 01:16:59.785
ist unsicher, ist total schwer.

01:17:00.785 --> 01:17:02.605
Das Paradigma sollte auch

01:17:02.605 --> 01:17:04.405
eher sein, lieber ein bisschen

01:17:04.405 --> 01:17:06.525
zu sensibel zu sein und sozusagen

01:17:06.525 --> 01:17:08.145
dein Schutzniveau einmal

01:17:08.145 --> 01:17:10.065
grob festzulegen und zu sagen, okay,

01:17:10.445 --> 01:17:11.925
wir gehen ja mit Kreditkartendaten um.

01:17:12.585 --> 01:17:14.485
Du musst davon ausgehen, dass irgendein

01:17:14.485 --> 01:17:16.525
doofer User, nein, die User sind nicht doof,

01:17:16.565 --> 01:17:34.265
Es ist ein Usability-Problem. Das Usability-Problem ist, dass wir halt ein Gehirn haben, was bekloppt ist. Da kommt dieses ganze Thema Cognitive Processing rein von unser Gehirn will Energie sparen und deswegen reagiert es auf irgendeine Form von Challenge immer mit der billigstmöglichen Antwort, also Pattern Matching.

01:17:34.265 --> 01:17:38.045
und das Pattern-Matching von unserem Gehirn ist auch nicht Best-Match, sondern First-Match.

01:17:38.445 --> 01:17:42.165
Das heißt, du hast eine Seite vor dir, hast aus deinem Passwort-Manager deine Kreditkartennummer kopiert,

01:17:42.245 --> 01:17:45.265
dein Kind will was von dir, ja bitte, ich muss nur noch, klick, klick, klick,

01:17:45.365 --> 01:17:49.665
und dann hast du halt deine Kreditkartennummer in das falsche Feld eingetragen.

01:17:50.425 --> 01:17:55.325
Und das ist halt, wie wir das bei Microsoft damals, alle zwei Millionen Mal,

01:17:55.765 --> 01:17:57.465
ja, das ist bei uns halt nächsten Dienstag.

01:17:57.465 --> 01:17:59.525
und

01:17:59.525 --> 01:18:02.525
sowas, deswegen sagen wir auch, wenn wir

01:18:02.525 --> 01:18:03.865
Anwendungen dann mit Schutzniveaus

01:18:03.865 --> 01:18:06.245
belegen und sagen, was macht man hier,

01:18:06.505 --> 01:18:08.365
dann gucken wir eigentlich nur noch nach dem Worst Case

01:18:08.365 --> 01:18:10.485
und sagen so, jetzt müssen wir davon ausgehen, dass

01:18:10.485 --> 01:18:12.405
das ganze Ding mit dem Niveau geschützt werden muss.

01:18:12.505 --> 01:18:14.205
Weiter differenzieren macht überhaupt keinen Sinn mehr,

01:18:14.545 --> 01:18:16.185
weil du kommst dann von Hölzchen zu Stöttchen

01:18:16.185 --> 01:18:18.445
und irgendwer greift

01:18:18.445 --> 01:18:20.345
eh daneben und deswegen bin ich mal

01:18:20.345 --> 01:18:22.125
sensibel drum, wenn es darum geht, so Exceptions

01:18:22.125 --> 01:18:24.105
an externe Systeme weiterzuleiten,

01:18:24.845 --> 01:18:26.225
weil im Prinzip

01:18:26.225 --> 01:18:32.745
übergibst du jemandem Externes alle deine Daten, weil du ja gar nicht weißt, was in der Exception drin ist. Wenn du es gewusst hättest,

01:18:33.325 --> 01:18:36.365
hättest du halt schon irgendwas geschrieben, damit die nicht auftritt.

01:18:37.285 --> 01:18:42.445
Aber wie bekommst du dann mit, wenn Exception passiert? Also an irgendein System muss das ja weitergeleitet werden, oder?

01:18:42.445 --> 01:18:50.145
Ja, internes System. Ich habe mich hier heute jetzt noch nicht wieder vorgestellt, ich bin ja so ein bisschen Stammgast schon.

01:18:50.145 --> 01:18:51.145
Philipp und und

01:19:20.145 --> 01:19:21.045
Was ist Greylock, Christian?

01:19:21.685 --> 01:19:25.765
Das ist ein Log-Aggregationssystem, also den kannst du mit Log-Daten befüttern

01:19:25.765 --> 01:19:30.405
und ihn dann nachher Parser drüber jagen lassen und dir automatisch Alerts schicken.

01:19:30.965 --> 01:19:34.705
Das ist auch so ein Ding, da spielen wir gerade zum Beispiel mit rum für so Threat-Themen.

01:19:35.485 --> 01:19:42.385
Der kann aus Log-Daten IP-Adressen rauspopeln und, der technische Begriff für Parsen,

01:19:42.385 --> 01:19:53.225
und hat halt dann wieder eine Anbindung an, daran abzugleichen, ob diese IPs assoziiert werden mit irgendeiner Form von, da kommen ständig Angriffe her.

01:19:53.825 --> 01:19:58.025
Und dann kann ich die Auswertung dann wieder zurückfüttern auf meine Firewall vorne und kann sagen,

01:19:58.025 --> 01:20:05.365
so, und immer wenn irgendwie eine IP, die den Threat-Indicator hat, irgendwie öfter als so und so oft pro Stunde vorkommt,

01:20:05.725 --> 01:20:07.445
dann wird die jetzt erstmal für drei Tage lahmgelegt.

01:20:07.445 --> 01:20:34.205
Das ist aber gefährlich, es kann ja sein, dass jetzt irgendjemand auf die Idee kommt und sagt, okay, du hast einen ganz, ganz wichtigen Kunden, mit dem du immer kommunizierst und derjenige schafft es irgendwie in das Netz reinzukommen von dieser IP und dann listet er diese Anfrage aus. Ich glaube, da gab es auch schon mal Virus-Genere, die sobald ein Paket kam, dann die gesamte IP geblockt haben und dann konnte man die lustig anschreiben von 8888, einem typischen DNS-Server und die haben gesagt, oh, das Paket sieht nach Virus aus, alles sofort blocken, alles von diesem Rechner und dann geht nichts mehr.

01:20:34.205 --> 01:20:37.905
Ja genau, da muss man immer mit vorsichtig sein

01:20:37.905 --> 01:20:39.745
und nichtsdestotrotz

01:20:39.745 --> 01:20:42.065
so ein bisschen mit so Sachen experimentieren wir halt gerne mal rum

01:20:42.065 --> 01:20:43.625
zu gucken, wie sie aussehen

01:20:43.625 --> 01:20:45.525
und dann willst du halt immer noch die Möglichkeit haben, nochmal

01:20:45.525 --> 01:20:47.885
durchgreifen zu können in dem Moment

01:20:47.885 --> 01:20:49.845
Klar, aber ich meine

01:20:49.845 --> 01:20:51.885
macht das auch solche Sachen wie

01:20:51.885 --> 01:20:53.545
weil ich kenne das eigentlich eher so als

01:20:53.545 --> 01:20:55.765
es gibt immer, entweder verwenden Leute

01:20:55.765 --> 01:20:57.485
diesen Kibana-Stack oft

01:20:57.485 --> 01:21:00.285
Kibana hatte ich nachher Kibakisch-Banane an

01:21:00.285 --> 01:21:01.145
Ja

01:21:01.145 --> 01:21:31.145


01:21:31.145 --> 01:21:33.085
auch immer nur, dass man da externe Services

01:21:33.085 --> 01:21:35.185
verwendet. Kein Problem, Sentry kann man

01:21:35.185 --> 01:21:36.885
ohne Problem, ist ja auch ein Source-Projekt, kann man

01:21:36.885 --> 01:21:38.445
ganz normal selber hosten.

01:21:39.245 --> 01:21:41.085
Kommt ja auch selber aus der Python-Ecke, ist glaube ich

01:21:41.085 --> 01:21:43.045
auch Django unten drunter oder so,

01:21:43.125 --> 01:21:44.165
ich bin mir gar nicht mehr sicher, aber

01:21:44.165 --> 01:21:46.125
stimmt, ist auch genau.

01:21:47.985 --> 01:21:49.385
Sentry ist ja relativ groß geworden

01:21:49.385 --> 01:21:50.425
tatsächlich, Armin und so.

01:21:51.245 --> 01:21:53.225
Und die kannst du selber

01:21:53.225 --> 01:21:54.285
hosten tatsächlich an der Stelle.

01:21:54.765 --> 01:21:56.265
Das würde ich dann auch immer empfehlen.

01:21:57.745 --> 01:21:59.145
Wichtig ist sozusagen der Unterschied

01:21:59.145 --> 01:22:02.365
von der Log Aggregation

01:22:02.365 --> 01:22:02.865
versus

01:22:02.865 --> 01:22:04.725
Exception Logging.

01:22:05.505 --> 01:22:07.965
Exception Logging hat die große Aufgabe,

01:22:08.445 --> 01:22:09.885
wenn du viel vom

01:22:09.885 --> 01:22:11.745
Gleichen entgegenkriegst, weil

01:22:11.745 --> 01:22:13.985
der eine bugt gerade 50.000 Mal

01:22:13.985 --> 01:22:15.945
im letzten Tag auf, dann willst du, dass der dir die

01:22:15.945 --> 01:22:17.665
schon normalisiert und sagt, hier,

01:22:17.825 --> 01:22:19.845
das Problem gab es jetzt in 50.000

01:22:19.845 --> 01:22:21.805
Instanzen, hier sind die Parameter, die ich gesehen

01:22:21.805 --> 01:22:23.765
habe. Logging macht natürlich

01:22:23.765 --> 01:22:25.685
immer nur, hier ist der Hydrant,

01:22:25.825 --> 01:22:26.945
hier kommt alles raus.

01:22:29.145 --> 01:22:59.125
Ja, einfach so.

01:22:59.145 --> 01:23:02.385
vor allem müssen die ganz viel mit Speicher machen

01:23:02.385 --> 01:23:03.905
und ganz viel Level erarbeiten

01:23:03.905 --> 01:23:05.105
genau, das was ich nicht haben will

01:23:05.105 --> 01:23:08.105
also wo ich es noch sehe, wo ich noch mitspiele

01:23:08.105 --> 01:23:09.665
ist, wo wir es gerne haben

01:23:09.665 --> 01:23:11.865
wo es angefragt wird und wir dem nicht

01:23:11.865 --> 01:23:13.725
harsch widersprechen

01:23:13.725 --> 01:23:15.965
ist, wenn du

01:23:15.965 --> 01:23:17.705
tatsächlich sowas hast wie

01:23:17.705 --> 01:23:19.925
deine Anwendung nimmt Daten per Mail oder

01:23:19.925 --> 01:23:21.885
Upload entgegen und du weißt, die werden dann

01:23:21.885 --> 01:23:24.105
nachher auf eher schlecht gepflegten Rechnern

01:23:24.105 --> 01:23:25.085
wieder weiterverarbeitet

01:23:25.085 --> 01:23:27.665
also wir haben so ein Kram, wo dann keine Ahnung

01:23:27.665 --> 01:23:30.805
Wordfiles reinkommen und die sollen dann von irgendeiner dritten Partei auf ihrem

01:23:30.805 --> 01:23:34.205
Windows-Rechner verarbeitet werden, dann habe ich halt mal

01:23:34.205 --> 01:23:37.185
einen Klamm-AV damit drauf sitzen, der halt diese

01:23:37.185 --> 01:23:40.205
eine Datei scannt, aber das ist dann kein Ding, was das

01:23:40.205 --> 01:23:43.085
System scannt, sondern es ist bloß ein Programm. Hier

01:23:43.085 --> 01:23:46.085
scannt die eine Datei, du sagst, ja, okay, dann geben wir die weiter und

01:23:46.085 --> 01:23:49.165
wenn nicht, dann sperren wir sie halt zur Seite. Das ist eine Form

01:23:49.165 --> 01:23:51.805
von Virenscanner, da spiele ich punktuell halt noch mit.

01:23:52.385 --> 01:23:55.165
Das kann man schon mal machen. Was ich halt nicht leiden kann,

01:23:55.165 --> 01:23:59.285
sind diese Security-Suites, die dann irgendwie einen Rechner irgendwie übernehmen und

01:23:59.285 --> 01:24:03.205
irgendwie mehr Schaden machen als, also gut, ich meine, da braucht man bloß Fefe lesen,

01:24:03.265 --> 01:24:06.645
da kriegst du es halt alle zwei Wochen wieder serviert, Schlangenhöhle und so.

01:24:09.965 --> 01:24:10.665
Ein gutes Konzept.

01:24:11.645 --> 01:24:15.125
Was ich eben noch kurz erwähnt hatte, was ich mir noch irgendwann drüber gestolpert

01:24:15.125 --> 01:24:18.665
bin, was bei Django eine DOS-Attacke möglich war, und zwar bei RackEx,

01:24:18.785 --> 01:24:22.385
die benutzt worden ist, um bestimmte Formularfelder auszulesen,

01:24:22.385 --> 01:24:24.305
Das heißt, man konnte einfach, indem man

01:24:24.305 --> 01:24:26.385
in Formulare, ich glaube E-Mail oder so,

01:24:27.065 --> 01:24:28.425
einen cleveren Regex reingeschrieben hat,

01:24:28.785 --> 01:24:30.345
irgendwie eine

01:24:30.345 --> 01:24:32.325
exponentiell wachsende oder endlose

01:24:32.325 --> 01:24:34.105
Schleife produzieren und dann die

01:24:34.105 --> 01:24:36.485
Seite... Man kann Regex

01:24:36.485 --> 01:24:38.305
bauen, die sehr, sehr langsam werden

01:24:38.305 --> 01:24:39.005
dann. Genau.

01:24:39.805 --> 01:24:41.145
Dann hat man einfach ganz viele Requester

01:24:41.145 --> 01:24:43.185
dran geschickt und dann hat man halt die Seite in die Knie zwinkern.

01:24:43.705 --> 01:24:44.985
Das haben die irgendwann gefixt. Ich glaube auch

01:24:44.985 --> 01:24:47.025
relativ spät, erst bei einer Zweier-Version, wenn ich das richtig

01:24:47.025 --> 01:24:49.285
bekommen habe. Sehr interessant,

01:24:49.465 --> 01:24:50.985
solche Sachen. Also das denkt man immer

01:24:50.985 --> 01:24:52.945
jemand, der keine Ahnung hat, nicht dran, dass

01:24:52.945 --> 01:24:55.145
in so einfachen Bibliotheken wie

01:24:55.145 --> 01:24:56.725
RegEx da was Tolles hinterstehen kann.

01:24:56.805 --> 01:24:59.025
Was ist das? Perl RegEx oder wie nennt man das?

01:24:59.065 --> 01:25:01.065
Diese Perl Compatible RegEx

01:25:01.065 --> 01:25:02.405
als PCIe, aber ich

01:25:02.405 --> 01:25:04.585
weiß nicht, ob das...

01:25:04.585 --> 01:25:07.145
Die Python RegEx Engine ist eine eigene.

01:25:07.505 --> 01:25:07.885
Ja, okay.

01:25:08.545 --> 01:25:10.945
Also moderne RegEx Engines können schon nicht alle

01:25:10.945 --> 01:25:12.685
Fälle, aber viele Fälle da

01:25:12.685 --> 01:25:14.925
besser erkennen und haben dann auch bessere

01:25:14.925 --> 01:25:16.645
Garantien, also nicht erkennen, aber haben

01:25:16.645 --> 01:25:19.005
Garantien, dass das halt nicht in diesen

01:25:19.005 --> 01:25:20.485
exponentiellen Fall läuft. Natürlich nicht immer.

01:25:20.485 --> 01:25:22.585
und natürlich kann ich immer einen Regex produzieren,

01:25:22.665 --> 01:25:24.585
der einfach so lange dauert, weil ich einfach sage,

01:25:24.685 --> 01:25:26.645
okay, hier kommt irgendwas Beliebiges und das

01:25:26.645 --> 01:25:28.565
darf beliebig auch vorkommen und wenn ich dann

01:25:28.565 --> 01:25:30.045
einen langen String habe, dann ist es halt total,

01:25:30.545 --> 01:25:31.405
dann gibt es

01:25:31.405 --> 01:25:34.045
natürlich exponentiell viele Möglichkeiten,

01:25:36.365 --> 01:25:38.465
wie ich das Matching nehmen kann

01:25:38.465 --> 01:25:40.525
und wenn ich den String so konstruiere, dass das Matching nie passiert,

01:25:41.045 --> 01:25:42.745
dann dauert es halt ewig.

01:25:42.965 --> 01:25:44.565
Also unerländlich nicht, aber schon mal

01:25:44.565 --> 01:25:45.305
länger ist das Universum.

01:25:47.225 --> 01:25:48.265
So, ich mache hier mal kurz,

01:25:48.265 --> 01:25:49.705
wir müssen eine Chapter-Mark hier ziehen.

01:25:50.485 --> 01:25:52.745
Ich muss jetzt raus, ihr könnt mich rausschneiden.

01:25:53.305 --> 01:25:54.185
Alles klar, du kannst

01:25:54.185 --> 01:25:55.785
das falsche sagen.

01:25:56.445 --> 01:25:58.525
Wir haben eine Sekunde Pause gehabt, das könnt ihr rausschneiden.

01:25:59.605 --> 01:26:00.145
Alles klar.

01:26:01.145 --> 01:26:02.865
Insofern, bis zur

01:26:02.865 --> 01:26:03.905
Fortsetzung demnächst mal wieder.

01:26:04.245 --> 01:26:05.505
Euch noch viel Spaß. Bis dann. Ciao.

01:26:08.505 --> 01:26:08.985
Ja.

01:26:10.705 --> 01:26:12.185
Haben wir denn zu dem

01:26:12.185 --> 01:26:13.925
Security-Thema noch irgendwie,

01:26:14.445 --> 01:26:16.105
ich weiß nicht genau, irgendwelche Dinge,

01:26:16.365 --> 01:26:18.225
die wir unbedingt erzählen

01:26:18.225 --> 01:26:18.465
wollten?

01:26:18.465 --> 01:26:20.545
oder, ja,

01:26:20.805 --> 01:26:22.645
also, mir fallen noch einige

01:26:22.645 --> 01:26:23.885
Sachen ein, aber frage ich erstmal euch weiter.

01:26:23.965 --> 01:26:26.505
Was willst du denn noch erzählen?

01:26:27.865 --> 01:26:30.225
Es gibt, also, was

01:26:30.225 --> 01:26:32.245
wichtig ist, dass

01:26:32.245 --> 01:26:34.265
man eine Funktion nimmt

01:26:34.265 --> 01:26:36.245
oder eine Standardmöglichkeit nimmt,

01:26:36.605 --> 01:26:38.385
um sich gegen eine Sicherheitsschwachstelle

01:26:38.385 --> 01:26:39.945
zu verteidigen. Also, wir haben eben schon

01:26:39.945 --> 01:26:42.085
Path Traverses angesprochen, da könnte man denken, okay,

01:26:42.745 --> 01:26:44.265
also, bei Path Traverses ist das Problem, dass ich

01:26:44.265 --> 01:26:46.345
irgendwas in den Pfad einschleuse, typischerweise

01:26:46.345 --> 01:26:47.945
halt . . . .

01:26:47.945 --> 01:26:55.585
slash um halt aus dem Pfad der Anwendung rauszukommen und dann statt eine lokale Datei der Anwendung zu lesen, bekomme ich halt eine Datei irgendwo aus dem System.

01:26:56.105 --> 01:26:59.165
Weiß ich, die Passwortdatei oder die Datenbankdatei oder irgendwas anderes.

01:26:59.665 --> 01:27:05.385
Und eine Möglichkeit, um sich dagegen zu beteiligen, ist natürlich zu sagen, ich nehme immer alle Punkte raus oder so.

01:27:05.705 --> 01:27:06.585
Oder alle Slashes raus.

01:27:06.985 --> 01:27:11.525
Und dann kommt man halt auf andere Systeme, zum Beispiel unter Windows, da ist ja ein Doppelpunkt wichtig.

01:27:11.945 --> 01:27:14.185
Und dann muss man auch an den denken und dann ist der Backslash wichtig.

01:27:14.645 --> 01:27:17.145
Und es ist halt sehr schwierig, sowas richtig zu schreiben.

01:27:17.145 --> 01:27:21.125
und da gibt es immer wieder Leute, die es versuchen, die sagen, ja, ich weiß es trotzdem und bei einigen

01:27:21.125 --> 01:27:24.965
Systemen geht das auch, also man kann zum Beispiel bei SQL

01:27:24.965 --> 01:27:29.025
Induction kann man relativ einfach vermeiden, weil das halt eigentlich

01:27:29.025 --> 01:27:33.185
nur ein einfaches Anführungszeichen ist, aber es ist halt immer gut dann für eine fertige Funktion

01:27:33.185 --> 01:27:36.865
oder eine fertige Struktur zu nehmen, die genau dafür programmiert ist und

01:27:36.865 --> 01:27:41.005
die dann auch, zwar die sicher ist, aber die ist halt sicher

01:27:41.005 --> 01:27:44.825
oder hoffentlich sicher, weil es halt nur eine ist, in Python zum Beispiel, in Prath

01:27:44.825 --> 01:27:46.485
zu verhindern, kann man halt

01:27:46.485 --> 01:27:48.905
os.path.basename oder aus der PathLib

01:27:48.905 --> 01:27:50.485
was nehmen, statt halt

01:27:50.485 --> 01:27:53.145
selber zu versuchen, diesen String zu bearbeiten.

01:27:53.425 --> 01:27:54.825
Also nicht selber machen, Security

01:27:54.825 --> 01:27:56.465
war das der... Ja, genau.

01:27:56.985 --> 01:27:58.445
Es sei denn, man weiß, was man

01:27:58.445 --> 01:28:00.765
tut. An einigen Stellen kann das richtig

01:28:00.765 --> 01:28:02.725
sein. Und ich glaube, ein anderes häufiges Problem

01:28:02.725 --> 01:28:03.685
ist auch, dass man sagt,

01:28:04.525 --> 01:28:06.545
ich versuche, die Eingabenbedarfen zu früh

01:28:06.545 --> 01:28:09.105
abzufangen.

01:28:09.225 --> 01:28:10.565
Also ich sage, okay, ich habe eine ganz komplizierte

01:28:10.565 --> 01:28:12.485
Anwendung und immer wenn mir jemand

01:28:12.485 --> 01:28:14.585
was mit einem Anführungszeichen schickt, dann sage ich, geht

01:28:44.585 --> 01:28:46.785
sehr schwierig, weil man halt ein komplexes

01:28:46.785 --> 01:28:48.425
System hat, vielleicht sogar mit mehreren

01:28:48.425 --> 01:28:50.565
Microservices, die die Daten aus verschiedenen

01:28:50.565 --> 01:28:51.005
Quellen

01:28:51.005 --> 01:28:54.525
anliefern. Aber wenn man darauf vertraut, dass

01:28:54.525 --> 01:28:56.485
die Datenbank irgendwie gute Daten enthält, das ist

01:28:56.485 --> 01:28:57.965
immer sehr, sehr gefährlich.

01:29:02.865 --> 01:29:04.585
Ja, ist interessant, welche Assertions man da

01:29:04.585 --> 01:29:06.545
daraus gibt oder welche Dinge man daraus macht, wenn das

01:29:06.545 --> 01:29:08.065
nicht dem erwarteten Standard entspricht oder so.

01:29:08.545 --> 01:29:10.405
Ein paar Stolperfallen, dass man einfach

01:29:10.405 --> 01:29:11.905
interpretiert, was da kommt, ist wahrscheinlich

01:29:11.905 --> 01:29:14.345
eine Mitte, wie die... Genau, man muss immer misstrauisch sein gegenüber

01:29:14.345 --> 01:29:16.005
bei allen Daten, also auch der eigene Datenbank,

01:29:16.325 --> 01:29:17.325
auch die kann Schrott enthalten.

01:29:19.565 --> 01:29:20.465
Okay, guter Tipp.

01:29:23.585 --> 01:29:26.285
Ja, ansonsten genau, ein Thema,

01:29:26.445 --> 01:29:28.305
wo ich immer denke, das kann doch nicht so schwer sein, aber

01:29:28.305 --> 01:29:30.125
ich tue mich irgendwie schwer damit,

01:29:30.545 --> 01:29:32.205
ist halt, wie authentifiziert man sich

01:29:32.205 --> 01:29:34.005
eigentlich richtig irgendwie

01:29:34.005 --> 01:29:35.625
zum Beispiel per

01:29:35.625 --> 01:29:38.085
einer API, per HTTP

01:29:38.085 --> 01:29:40.205
oder so, oder die Web-Authentifizierung

01:29:40.925 --> 01:29:42.165
ist irgendwie nicht so einfach.

01:29:43.145 --> 01:29:44.325
Und dann, ja,

01:29:44.345 --> 01:30:06.668
Es gibt ein paar interessante Artikel dazu die wir letztens gelesen hatten warum JBT kaputt ist und dass die Leute nutzen und sagen das ist der Standard den es da gibt Ich habe aber auch jetzt auch noch nicht so viel gefunden was man da anderes machen kann Es gibt irgendwie Passeto oder PyPasseto aber da gibt es noch nichts wirklich Nutzbares Das muss man irgendwie auch alles wieder selber machen vielleicht und das ist auch vielleicht wieder nicht so

01:30:06.668 --> 01:30:08.688
eine gute Idee und da ist es gar nicht so

01:30:08.688 --> 01:30:10.867
einfach, sich vernünftig per Token zu authentifizieren.

01:30:11.188 --> 01:30:12.747
Ja, tatsächlich. Also das, was ich jetzt auch

01:30:12.747 --> 01:30:14.907
ist halt, ja, HTTP-only-Cookies.

01:30:15.688 --> 01:30:15.907
Ja.

01:30:16.547 --> 01:30:16.907
Vielleicht.

01:30:17.767 --> 01:30:20.707
Ja, Session-Cookies ist halt

01:30:20.707 --> 01:30:21.287
manchmal ein bisschen

01:30:21.287 --> 01:30:23.727
schwierig, aber

01:30:23.727 --> 01:30:29.767
Aber ja, das ist immer wieder, wo ich mir denke, das müsste doch eigentlich jetzt einfach sein, aber irgendwie ist es das nicht.

01:30:35.688 --> 01:30:39.447
Oh, oder hast du mal so von Indie aus gehört?

01:30:39.648 --> 01:30:41.987
Ich meine, das ist halt so eine etwas abgespeckte O-Aus-Variante.

01:30:42.907 --> 01:30:44.467
Nee, gar nicht.

01:30:44.547 --> 01:30:44.907
Okay, ja.

01:30:45.967 --> 01:30:46.547
Was ist das?

01:30:46.547 --> 01:30:49.387
Das ist sozusagen, dass man halt

01:30:49.387 --> 01:30:52.547
selber

01:30:52.547 --> 01:30:53.367
also

01:30:53.367 --> 01:30:56.087
das ist auch von dem

01:30:56.087 --> 01:30:58.287
von den gleichen, also das hat

01:30:58.287 --> 01:31:00.887
jetzt komme ich vom Hölzchen aufs Stöckchen

01:31:00.887 --> 01:31:03.247
das hat was mit dem Indie-Web zu tun, das ist so eine Bewegung

01:31:03.247 --> 01:31:04.627
um, dass man halt

01:31:04.627 --> 01:31:06.827
die Dinge selber machen kann, wo man

01:31:06.827 --> 01:31:08.787
normalerweise immer irgendwelche Unternehmen für braucht

01:31:08.787 --> 01:31:09.427
die das halt machen

01:31:09.427 --> 01:31:12.987
und es geht zum Beispiel darum, dass man sich mit seiner eigenen

01:31:12.987 --> 01:31:14.407
Webseite einloggen können will

01:31:14.407 --> 01:31:17.267
sozusagen. Also nicht

01:31:17.267 --> 01:31:19.207
Username, Passwort, sondern man

01:31:19.207 --> 01:31:21.387
gibt halt ein URL an und dann hat man

01:31:21.387 --> 01:31:23.168
gibt es halt sozusagen einen Hook, wo dann

01:31:23.168 --> 01:31:25.188
irgendwie man sagen kann,

01:31:25.407 --> 01:31:26.527
wie man jetzt

01:31:26.527 --> 01:31:28.867
wie man sagt, dass man jetzt

01:31:28.867 --> 01:31:31.168
authentifiziert ist und dann zum Beispiel kann man sich dann halt irgendwie

01:31:31.168 --> 01:31:33.168
eine

01:31:33.168 --> 01:31:35.027
Push-Notification schicken lassen aufs Handy

01:31:35.027 --> 01:31:37.267
und dann sagt man halt, ja okay, das war

01:31:37.267 --> 01:31:39.168
jetzt richtig oder man kriegt einfach eine E-Mail geschickt

01:31:39.168 --> 01:31:40.947
oder so und drückt dann auf einen Link und dann

01:31:40.947 --> 01:31:43.367
Ja, mal dein YubiKey bitte oder sowas. Genau, genau, genau.

01:31:43.367 --> 01:31:46.447
und solche Sachen. Und man ist ja sehr frei in der Art, wie man das halt dann,

01:31:47.148 --> 01:31:50.807
wie man diese Authentifizierung gestalten kann. Und das klingt eigentlich schon sehr nett.

01:31:53.247 --> 01:31:56.607
Das ist ja sicherlich immer die einfachste Lösung, wenn du sagst, ich möchte selber keinen Benutzernamen,

01:31:56.707 --> 01:32:00.527
keinen Passwort speichern, weil einerseits sind mir die Daten zu sensitiv und ich muss genau gucken,

01:32:00.587 --> 01:32:04.387
wie ich das richtig speichere. Ist zu sagen, okay, ich mache einfach, ich speichere überhaupt keine Benutzernamen

01:32:04.387 --> 01:32:09.087
und Passwörter und ich verwende irgendein Single Sign-On-System. Du hast ja schon ORAS angesprochen

01:32:09.087 --> 01:32:10.927
oder OpenID Connect, das ist ja der

01:32:10.927 --> 01:32:12.747
alternative Standard,

01:32:13.188 --> 01:32:15.227
dass man sagt, okay, jemand anders muss sich drum kümmern.

01:32:15.807 --> 01:32:16.987
Und dann habe ich zwar diesen

01:32:16.987 --> 01:32:19.107
anderen Dienst, der irgendwo vielleicht auch in meinem Netzwerk

01:32:19.107 --> 01:32:20.567
ist oder vielleicht sagt, okay, ich erlaube

01:32:20.567 --> 01:32:23.027
Login mit Facebook, mit Google, mit Twitter und so weiter

01:32:23.027 --> 01:32:23.507
und mit GitHub.

01:32:25.047 --> 01:32:26.987
Dann müssen die sich halt drum kümmern und dann kann ich halt

01:32:26.987 --> 01:32:28.947
da auch meinen, bin ich da raus aus der Sache. Ich muss kein

01:32:28.947 --> 01:32:31.027
Passwort speichern und für den Benutzer ist das ja eigentlich auch nicht

01:32:31.027 --> 01:32:32.987
schlecht, weil der Benutzer muss kein Passwort wählen.

01:32:34.027 --> 01:32:35.247
Wenn der Benutzer ein Passwort wählt,

01:32:35.307 --> 01:32:36.627
das ist ja auch...

01:32:36.627 --> 01:32:38.047
nicht so gut. Aber das hat auch

01:32:38.047 --> 01:32:40.347
ein paar Falschstücke wieder. Also zum Beispiel, wir hatten

01:32:40.347 --> 01:32:42.307
jetzt das System, dass wir auch so

01:32:42.307 --> 01:32:44.347
ein OpenID Connect irgendwie Schriftstelle bauen

01:32:44.347 --> 01:32:46.087
mussten, aber wir haben das dann über

01:32:46.087 --> 01:32:48.547
Django All aus versucht zu implementieren,

01:32:48.627 --> 01:32:50.247
der ja viele davon schon bereitstellt, irgendwie als

01:32:50.247 --> 01:32:52.027
Pakete und dann mussten wir aber so einen eigenen

01:32:52.027 --> 01:32:54.387
Provider dafür bauen, weil der, den wir

01:32:54.387 --> 01:32:55.987
da hatten, der hat nicht genau das gemacht, was wir wollen.

01:32:56.487 --> 01:32:58.347
Ich bin mir nicht sicher, ob das, was wir da gebaut haben,

01:32:58.427 --> 01:32:59.907
alles so gut, so richtig funktioniert.

01:33:00.107 --> 01:33:01.627
Das wird sich dann irgendwie im Laufe der Zeit zeigen.

01:33:01.807 --> 01:33:04.047
Das müssen wir richtig testen. Mal gucken.

01:33:05.487 --> 01:33:06.087
Beim ersten

01:33:06.087 --> 01:33:06.827
Pentest, hoffentlich.

01:33:08.027 --> 01:33:10.107
Oder beim ersten Pentest, der ungefragt ist

01:33:10.107 --> 01:33:11.087
und ungefragt ausgesucht wird.

01:33:13.927 --> 01:33:16.307
Ja, aber

01:33:16.307 --> 01:33:18.127
was ich

01:33:18.127 --> 01:33:20.027
vor allen Dingen blöd finde bei diesen ganzen

01:33:20.027 --> 01:33:21.907
OpenID-OAuth-Geschichten auch,

01:33:22.047 --> 01:33:24.027
ist halt, dass man dann halt alles an so

01:33:24.027 --> 01:33:26.587
bestimmte User-Accounts

01:33:26.587 --> 01:33:27.907
hängt. Weiß ich nicht, ob das jetzt GitHub,

01:33:28.007 --> 01:33:29.927
Twitter oder schlimmer noch vielleicht Facebook

01:33:29.927 --> 01:33:31.887
ist oder so. Dann passiert irgendwas Blödes

01:33:31.887 --> 01:33:33.967
und dann verliert man halt den Account und dann verliert man gleichzeitig

01:33:33.967 --> 01:33:35.507
den Zugang zu ganz vielen anderen Sachen.

01:33:36.087 --> 01:33:37.847
Das ist ja auch irgendwie nicht so schön.

01:33:38.727 --> 01:33:39.467
Ja gut, aber dadurch

01:33:39.467 --> 01:33:41.807
braucht der Blitz halt nur noch

01:33:41.807 --> 01:33:43.727
ein Kennwort und Facebook kann halt sehr, sehr

01:33:43.727 --> 01:33:45.887
viel bessere Sachen, bessere Authentifizierung

01:33:45.887 --> 01:33:47.148
durchführen, als du es machen könntest.

01:33:47.267 --> 01:33:49.887
Die schauen halt auf deine IP-Adresse, auf deinen Browser,

01:33:50.087 --> 01:33:51.747
die haben noch einen Session-Token, die haben

01:33:51.747 --> 01:33:53.527
vielleicht auch eine Mehrfach-Authentifizierung,

01:33:53.907 --> 01:33:56.067
dass du noch

01:33:56.067 --> 01:33:57.567
irgendwie auf dem Handy was bestätigen musst

01:33:57.567 --> 01:33:59.407
und das gibt es ja

01:33:59.407 --> 01:34:01.587
an einer Partei, das musst du nicht alles selber

01:34:01.587 --> 01:34:02.267
implementieren.

01:34:02.267 --> 01:34:03.648
Wenn du es selber implementierst,

01:34:03.648 --> 01:34:09.547
Es gibt wirklich dann einige Firmen, die das dann wohl doch dann ernster nehmen, als man manchmal so denkt.

01:34:09.648 --> 01:34:12.467
Ich war zum Beispiel mich einmal irgendwo ans Ausland geflogen, als man das noch durfte irgendwie

01:34:12.467 --> 01:34:16.727
und habe eine relativ hohe Überweisung angefordert, irgendwie da so durchgeführt.

01:34:17.407 --> 01:34:20.007
Und auf einmal bekam ich dann so einen Anrufer von meinem Telefon von der Bank, die meinte so,

01:34:20.087 --> 01:34:25.407
ja, hallo, wollen Sie das wirklich tun? Oder waren Sie das?

01:34:26.047 --> 01:34:27.648
Ja, das war ich. Ja, das ist ja alles gut.

01:34:28.547 --> 01:34:30.507
Ja, aber das war schon mal nett, dass Sie nochmal nachgefragt haben,

01:34:30.507 --> 01:34:33.487
anstatt dass Sie einfach eine hohe Summe irgendwo hin überweisen oder von irgendwo.

01:34:33.648 --> 01:34:35.627
Das ist schon gar nicht so

01:34:35.627 --> 01:34:37.607
unrichtig, dass dann vielleicht

01:34:37.607 --> 01:34:39.967
dann ein Mensch da nochmal nachguckt, also dass dann solche

01:34:39.967 --> 01:34:41.987
Alerts irgendwie in das System rausgehen, die dann nochmal

01:34:41.987 --> 01:34:42.947
gucken, wenn irgendwas ist

01:34:42.947 --> 01:34:45.807
Genau, das kann deine Anwendung ja nicht leisten, das

01:34:45.807 --> 01:34:47.767
möchtest du ja normalerweise nicht machen, du möchtest ja nicht anfangen

01:34:47.767 --> 01:34:50.107
SMS zu verschicken oder was auch immer

01:34:50.107 --> 01:34:52.207
oder solche Überprüfungen

01:34:52.207 --> 01:34:53.967
zu machen und ich glaube, das ist einfacher, wenn man sowas

01:34:53.967 --> 01:34:56.168
zentralisiert und wenn du

01:34:56.168 --> 01:34:57.607
ein Passwort, also

01:34:57.607 --> 01:34:59.787
viele Leute verwenden halt ein Passwortmanager, aber auch

01:34:59.787 --> 01:35:01.967
die, glaube ich, die große Masse an Leuten

01:35:01.967 --> 01:35:04.347
verwendet immer noch in 2020 keinen Passwortmanager,

01:35:04.787 --> 01:35:06.047
sondern haben ein Standardpasswort,

01:35:06.107 --> 01:35:08.148
was sie dabei verwenden. Und wenn dann halt irgendein

01:35:08.148 --> 01:35:10.247
Katzenforum gehackt wird, dann bist du plötzlich dran

01:35:10.247 --> 01:35:11.987
und dann rufen deine Kunden an, warum wurde hier

01:35:11.987 --> 01:35:14.007
meine Bankseite oder was auch immer, welche Seite

01:35:14.007 --> 01:35:16.188
du anbietest, warum wurde die gehackt?

01:35:16.247 --> 01:35:18.047
Und dann sagst du, ja, du hast das gleiche Passwort in deinem

01:35:18.047 --> 01:35:19.507
Katzenforum verwendet. Und die haben halt,

01:35:20.067 --> 01:35:22.207
wir haben die besten Sicherheitsstände, aber das Katzenforum,

01:35:22.287 --> 01:35:23.327
das ist halt nur irgendeine Kiste,

01:35:23.507 --> 01:35:24.787
die irgendwo läuft.

01:35:25.267 --> 01:35:28.168
Da reichen sich die

01:35:28.168 --> 01:35:29.947
Hacker, die wird in der Türklinke

01:35:29.947 --> 01:35:31.887
drücken sich die Hand, weil da halt

01:35:31.887 --> 01:35:33.727
so viele Hacker drauf sind, dass die sich

01:35:33.727 --> 01:35:35.467
gegenseitig schon stören mit ihren ganzen Exploits

01:35:35.467 --> 01:35:37.607
auf dem Katzenforum. Und das ist halt ein Problem, was

01:35:37.607 --> 01:35:39.847
du mit dem Sing-It-Sign-On direkt

01:35:39.847 --> 01:35:41.767
an andere Leute verschiebst. Dann muss sich Facebook

01:35:41.767 --> 01:35:43.707
oder Google oder wer auch immer

01:35:43.707 --> 01:35:45.747
oder dein eigener Sing-It-Sign-On-Service

01:35:45.747 --> 01:35:46.987
muss sich dann darum kümmern.

01:35:48.827 --> 01:35:49.148
Ja.

01:35:50.188 --> 01:35:51.827
Ja, ja. Ja, wir haben ja noch so ein paar Sachen

01:35:51.827 --> 01:35:53.227
glaube ich vergessen. Also was wäre mit Security?

01:35:54.307 --> 01:35:56.188
Müsste man ja eigentlich noch über Social Engineering

01:35:56.188 --> 01:35:58.027
reden und ganz andere

01:35:58.027 --> 01:35:59.967
Geschichten. Also ein paar USB-Sticks auf den Parkplatz

01:35:59.967 --> 01:36:01.127
fallen lassen oder sowas.

01:36:01.887 --> 01:36:06.668
und wie man Corporate sicher bekommt und wie man die Leute auditen kann.

01:36:07.007 --> 01:36:08.307
Und da gibt es ja so Experimente zu.

01:36:09.007 --> 01:36:15.507
Zum Beispiel, einige Konzerne verschicken ja dann so Test-E-Mails oder Trainings-E-Mails regelmäßig,

01:36:15.747 --> 01:36:20.747
um zu gucken, klicken die Leute auf alles, was da so in Mail verflattert.

01:36:21.127 --> 01:36:22.648
Und die Antwort ist schon, ja, das tun sie.

01:36:23.067 --> 01:36:25.668
Und dann kann man die halt ein bisschen erziehen oder sowas,

01:36:25.767 --> 01:36:28.227
sodass man die Quote davon reduziert und das ist eine ganz spannende.

01:36:28.227 --> 01:36:29.567
Ja, aber

01:36:29.567 --> 01:36:32.387
da würde ich jetzt auch ganz spontan

01:36:32.387 --> 01:36:34.247
würde ich sagen, naja gut, aber ich meine, dafür sind doch

01:36:34.247 --> 01:36:36.148
die Sachen dafür da, dass man da drauf klickt

01:36:36.148 --> 01:36:38.047
also ich meine, das ist ja

01:36:38.047 --> 01:36:39.787
das kann es ja eigentlich nicht sein, dass man

01:36:39.787 --> 01:36:41.967
irgendwie die Leute dazu entzieht

01:36:41.967 --> 01:36:43.867
irgendwie sich an komische Regeln zu halten

01:36:43.867 --> 01:36:46.027
damit die Software bleiben darf

01:36:46.027 --> 01:36:46.727
das ist ja irgendwie

01:36:46.727 --> 01:36:49.927
Ja gut, da gibt es ja ein ganz wichtiges Sicherheitskonzept, was wir noch gar nicht so richtig

01:36:49.927 --> 01:36:51.987
wir haben es Schweizer Käse genannt

01:36:51.987 --> 01:36:53.607
oder Defense in Depth, dass ich sage, okay

01:36:53.607 --> 01:36:56.047
ich sorge dafür, dass auch wenn

01:36:56.047 --> 01:36:57.587
also dem Chef der Firma

01:36:57.587 --> 01:37:27.567
und Jochen unterhalten sich über die Programmiersprache Python

01:37:27.587 --> 01:37:57.567
und Jochen unterhalten sich über die Programmiersprache Python

01:37:57.587 --> 01:38:00.648
und die HubiKey angesprochen, den man genauso einsetzen kann, wenn er ein Mensch ist.

01:38:01.047 --> 01:38:03.447
Aber auch zwischen Systemen ist das, glaube ich, so der goldene Stand,

01:38:03.527 --> 01:38:05.887
dass man sagt, okay, ich habe einen Client-Site TLS-Zertifikat,

01:38:05.947 --> 01:38:07.148
ich habe einen Server-Site TLS-Zertifikat.

01:38:07.168 --> 01:38:09.567
Vielleicht nochmal ganz kurz da, einmal kurz das Low-Layer.

01:38:09.747 --> 01:38:12.287
Also TLS ist irgendwie Transport Layer Security.

01:38:12.747 --> 01:38:13.967
Genau, auch bekannt als SSL.

01:38:14.148 --> 01:38:14.927
SSL ist der Vorgang.

01:38:15.287 --> 01:38:18.007
Und das macht doch was sicher, wie eine Verbindung zu einem anderen Rechner,

01:38:18.087 --> 01:38:19.527
dass die irgendwie verschlüsselt übertragen,

01:38:19.587 --> 01:38:21.407
dass man sich nicht in die Mitte setzen kann, um das abzuhören.

01:38:21.727 --> 01:38:23.507
Ja, nicht eine Verbindung zu einem anderen Rechner,

01:38:23.507 --> 01:38:27.467
sondern auch von einer Anwendung.

01:38:27.587 --> 01:38:28.667
in einer anderen Anwendung.

01:38:28.947 --> 01:38:30.767
Ja, genau.

01:38:32.807 --> 01:38:33.127
Ja, okay.

01:38:33.707 --> 01:38:35.167
Ja, das sind halt irgendwie so genestete

01:38:35.167 --> 01:38:37.707
Sicherheitslevel, die irgendwie so ineinander stecken und das ist dann

01:38:37.707 --> 01:38:39.627
wo es dann irgendwann alles relativ komplex sein

01:38:39.627 --> 01:38:41.347
mit den ganzen... Ja, ja, du brauchst halt

01:38:41.347 --> 01:38:43.688
allein für sowas wie eben

01:38:43.688 --> 01:38:45.027
so eine stinknormale, ich weiß nicht,

01:38:45.247 --> 01:38:47.927
Anwendung, wie du besuchst, bist auf deiner Bankseite

01:38:47.927 --> 01:38:49.827
und machst da irgendeine Transaktion

01:38:49.827 --> 01:38:51.587
und müssen halt viele Dinge gewährleistet

01:38:51.587 --> 01:38:53.827
sein, also der TLS-Teil

01:38:53.827 --> 01:38:55.807
macht halt die Vertraulichkeit

01:38:55.807 --> 01:38:58.267
beziehungsweise Integrität, ich weiß jetzt gar nicht genau,

01:38:58.627 --> 01:38:59.667
aber was du halt auch noch

01:38:59.667 --> 01:39:00.567
beides genau,

01:39:01.327 --> 01:39:04.047
was du halt auch noch brauchst, ist halt

01:39:04.047 --> 01:39:06.347
Authentifizierung, also du musst dich halt

01:39:06.347 --> 01:39:08.347
irgendwie gegenüber der Bank ausweisen, damit

01:39:08.347 --> 01:39:09.587
die Bank weiß,

01:39:10.507 --> 01:39:12.527
wer du bist und überprüfen

01:39:12.527 --> 01:39:14.207
kann und das ist dann der dritte Teil, ob du auch

01:39:14.207 --> 01:39:16.107
autorisiert bist, das zu tun, was du da tun willst,

01:39:16.188 --> 01:39:18.387
das ist halt nochmal getrennt davon, weil es kann ja sein,

01:39:18.387 --> 01:39:20.247
du hast dich zwar eingeloggt, aber du darfst

01:39:20.247 --> 01:39:22.267
irgendetwas nicht machen und

01:39:22.267 --> 01:39:24.047
Autorisierung ist ja auch nochmal so ein Riesenthema,

01:39:24.047 --> 01:39:54.047
das ist, wie kriegt man das eigentlich ordentlich hin und Der coole Trick beim PLS ist halt, dass du sagen kannst, ich, also du kannst erstmal sowieso asymmetrisch arbeiten, das heißt, der private Schlüssel verlässt nie die Box. Du hast also einen Client, also einen Service, der einen anderen Dienst was sendet und der hat einen privaten Schlüssel und der andere Dienst kennt nur den öffentlichen Schlüssel und das kannst du noch weiter treiben, indem du halt sagst, ich verwende nicht, der andere Dienst muss so nicht mal den öffentlichen Schlüssel kennen, sodass

01:39:54.047 --> 01:40:24.027
und Jochen unterhalten sich über die Programmiersprache Python

01:40:24.047 --> 01:40:25.287
auskommt und da gab es ja irgendwie

01:40:25.287 --> 01:40:27.927
Algorithmen, mit denen man bestimmte Dinge

01:40:27.927 --> 01:40:30.107
verschlüsselt oder hasht

01:40:30.107 --> 01:40:31.947
oder wie auch immer und die man dann

01:40:31.947 --> 01:40:34.107
mehr oder weniger schnell entschlüsseln

01:40:34.107 --> 01:40:35.787
konnte oder sowas. Oder man konnte sogar so

01:40:35.787 --> 01:40:37.947
Angriffsverfahren wie Rainbow Table

01:40:37.947 --> 01:40:39.787
nennt sich das oder sowas, dass man halt Passwort hasht

01:40:39.787 --> 01:40:41.907
und einfach in eine Tabelle schmeißt und guckt, wie ist denn das

01:40:41.907 --> 01:40:44.087
Ergebnis von dem Hash, also was ist denn da der umgekehrte Wert

01:40:44.087 --> 01:40:45.887
von oder so. Und ja, wenn man

01:40:45.887 --> 01:40:47.667
solche Sachen halt irgendwie

01:40:47.667 --> 01:40:49.367
vermeiden möchte, dann müsste man glaube ich

01:40:49.367 --> 01:40:51.707
schon gucken, welchen Algorithmus man zum Schlüsseln,

01:40:51.707 --> 01:40:52.907
zum Entschlüsseln seiner Schlüssel nimmt.

01:40:52.907 --> 01:40:53.967
auch irgendwie...

01:40:53.967 --> 01:40:55.047
Ach, und das ist zwar für Schlüsselsachen.

01:40:56.007 --> 01:40:58.867
Mein Passwort möchte ich eigentlich nicht verschlüsseln,

01:40:59.247 --> 01:41:00.867
weil dann muss ich ja den Schlüssel irgendwo auf dem Server

01:41:00.867 --> 01:41:01.487
speichern.

01:41:02.688 --> 01:41:04.967
Also das Passwort eines Nutzers möchte ich nicht.

01:41:04.967 --> 01:41:06.847
Ich meinte ja so SSH-Keys oder sowas,

01:41:06.907 --> 01:41:07.607
das meinte ich mit Schlüssel,

01:41:08.867 --> 01:41:10.947
die dann bestimmten Algorithmus benutzen irgendwie.

01:41:11.067 --> 01:41:11.747
Okay, ja.

01:41:13.747 --> 01:41:15.947
Das müsste ich ja vielleicht nochmal erklären,

01:41:16.087 --> 01:41:18.347
also wie man halt da von einem

01:41:18.347 --> 01:41:20.507
nicht so guten Algorithmus

01:41:20.507 --> 01:41:22.747
den Schlüssel berechnen kann aus einem Public Key oder sowas.

01:41:22.907 --> 01:41:24.148
bei asymmetrischer Verschlüsselung.

01:41:28.487 --> 01:41:30.747
Den Schlüssel selber musst du eigentlich nicht berechnen.

01:41:30.807 --> 01:41:32.167
Du kannst ein Zertifikat berechnen,

01:41:32.467 --> 01:41:34.707
das ist der Schlüssel nochmal in kurz, aber du könntest

01:41:34.707 --> 01:41:36.307
eigentlich auch immer den Schlüssel an sich verwenden,

01:41:36.427 --> 01:41:37.247
den öffentlichen Schlüssel zumindest.

01:41:38.447 --> 01:41:39.867
Nur weil der öffentliche Schlüssel ist halt bei dieser

01:41:39.867 --> 01:41:42.547
Kryptografie sehr lang, das muss halt eine sehr lange Zahl sein

01:41:42.547 --> 01:41:44.567
und die kannst du halt eindampfen auf eine

01:41:44.567 --> 01:41:46.407
kürzere Zahl, die man aus verschiedenen Gründen dann

01:41:46.407 --> 01:41:48.107
verwendet, die auch immer gleich ist, egal wie lang

01:41:48.107 --> 01:41:50.467
der Schlüssel ist und das ist das Hash-Verfahren.

01:41:50.747 --> 01:41:52.307
Das verwenden wir auch bei Passwörtern und auch an vielen

01:41:52.307 --> 01:41:56.087
und die anderen Stellen kann ich auch verwenden, um zum Beispiel zu überprüfen, wenn ich Software runterlade,

01:41:56.527 --> 01:41:59.688
dass die in Ordnung ist. Haben wir eben schon mal angesprochen, dass wenn ich

01:41:59.688 --> 01:42:03.827
das mit Python mache, dann habe ich zum Beispiel bei pip

01:42:03.827 --> 01:42:07.887
habe ich ein pip-File und ein pip-File.log

01:42:07.887 --> 01:42:11.707
und in dem pip-File.log stehen halt die ganzen Hashes drin. Und was ein Hash macht, ist halt genau

01:42:11.707 --> 01:42:15.867
eine lange Eingabe zu nehmen, egal welche Länge, und sie auf eine Zahl

01:42:15.867 --> 01:42:19.927
zu reduzieren, die eine relativ kurze Länge hat

01:42:19.927 --> 01:42:23.807
und die auch immer die gleiche Länge hat. Das sind dann halt nachher so 32 Buchstaben oder sowas.

01:42:24.467 --> 01:42:28.188
Und das ist halt kryptografische Magie.

01:42:29.487 --> 01:42:31.327
Und es gibt halt Mathematiker,

01:42:33.027 --> 01:42:36.487
die haben sich darum gekümmert, dass es nicht möglich ist,

01:42:36.487 --> 01:42:40.228
das rückwärts zu rechnen. Das heißt, wenn ich ein Hash habe, kann ich nicht das Original

01:42:40.228 --> 01:42:43.467
berechnen und ich kann gegeben einen Hash, kann ich

01:42:43.467 --> 01:42:48.407
überhaupt nicht ein Original finden. Das heißt, wenn du mir dein Hash gibst, dann kann ich eigentlich

01:42:48.407 --> 01:42:48.927
hier sein, dass

01:42:48.927 --> 01:42:52.467
die Originaldatei genau unverändert ist.

01:42:53.047 --> 01:42:54.267
Und genau dafür kann ich die halt

01:42:54.267 --> 01:42:55.228
einsetzen.

01:42:56.728 --> 01:42:56.807
Mhm.

01:42:58.347 --> 01:42:58.547
Ja.

01:43:01.087 --> 01:43:02.427
Okay, das Rückrechnen ist dann

01:43:02.427 --> 01:43:04.267
bei unsicheren Hash-Verfahren dann vielleicht

01:43:04.267 --> 01:43:06.547
dann doch möglich oder sowas? Oder dauert das lange?

01:43:06.747 --> 01:43:08.148
Ja, und man kann halt

01:43:08.148 --> 01:43:10.347
Kollisionen finden dann. Und dann kann man

01:43:10.347 --> 01:43:12.307
eben beispielsweise Dokumente dadurch fälschen, dass

01:43:12.307 --> 01:43:13.527
man, wenn man hinten

01:43:13.527 --> 01:43:15.907
Leerzeichen anfügt oder wegnimmt, kann man ja

01:43:15.907 --> 01:43:17.787
viele Kombinationen erzeugen, weil man weiß, wie man

01:43:17.787 --> 01:43:20.007
die Kollision erzeugen kann, dann kann man halt

01:43:20.007 --> 01:43:22.387
quasi beliebige Texte mit einem bestimmten Hash erzeugen

01:43:22.387 --> 01:43:23.307
und das ist natürlich ganz schlecht.

01:43:24.847 --> 01:43:26.148
Genau, dann habe ich halt deinen Schlüssel

01:43:26.148 --> 01:43:28.148
und dann kann halt jemand anders einen anderen Schlüssel

01:43:28.148 --> 01:43:30.247
generieren und die haben plötzlich den gleichen

01:43:30.247 --> 01:43:31.947
Hash. Dann kann er sich mit

01:43:31.947 --> 01:43:34.027
seinem eigenen Schlüssel, der so tut, als wäre dein Schlüssel

01:43:34.027 --> 01:43:35.287
damit authentifizieren.

01:43:36.487 --> 01:43:38.307
Also es geht um Sicherheit von Kryptografie

01:43:38.307 --> 01:43:39.267
oder sowas in der Hinsicht noch?

01:43:39.847 --> 01:43:41.967
Ja, aber ich glaube, ich weiß gar nicht, ob man

01:43:41.967 --> 01:43:43.547
sich als Endanwender oder so

01:43:43.547 --> 01:43:46.047
wahnsinnig viel mit beschäftigen muss, weil

01:43:46.047 --> 01:43:49.067
ich glaube, wenn man da anfängt, sich für zu interessieren

01:43:49.067 --> 01:43:50.627
und dann irgendwelche Entscheidungen zu treffen,

01:43:50.807 --> 01:43:52.587
dann liegt man wahrscheinlich eher

01:43:52.587 --> 01:43:54.607
hoch, dass man falsch liegt.

01:43:54.607 --> 01:43:56.627
Also genau, dann kann man quasi diese Wahl

01:43:56.627 --> 01:43:57.747
auch gar nicht mehr treffen, welche

01:43:57.747 --> 01:44:01.087
kryptografischen Algorithmen man zum Verschlüsseln, Entschlüsseln

01:44:01.087 --> 01:44:01.367
benutzt.

01:44:01.728 --> 01:44:03.607
Also wenn du

01:44:03.607 --> 01:44:06.427
zum Beispiel hasht, dann musst du in der Python-Hashlet

01:44:06.427 --> 01:44:08.247
sagen, okay, ich möchte diesen Hash haben.

01:44:08.307 --> 01:44:10.327
Dann sagst du zum Beispiel, ich möchte SHA-1 haben.

01:44:10.747 --> 01:44:12.047
Oder ich möchte MD5 haben.

01:44:12.327 --> 01:44:14.447
Und wenn du da die falsche Wahl triffst, dann hast du durchaus

01:44:14.447 --> 01:44:16.507
ein Problem. Also SHA-1 oder FD5 sollte man nicht

01:44:16.507 --> 01:44:18.047
nehmen, sondern SHA-256, oder?

01:44:18.688 --> 01:44:20.407
Genau, SHA-2256 oder eine

01:44:20.407 --> 01:44:22.387
SHA-3-Variante oder was anderes. Aber

01:44:22.387 --> 01:44:24.067
eigentlich willst du gar nicht, dass der Entwickler sich

01:44:24.067 --> 01:44:26.287
darum Gedanken machen soll. Der Entwickler soll gar nicht

01:44:26.287 --> 01:44:28.327
sagen, okay, ich nehme SHA-1, sondern der Entwickler

01:44:28.327 --> 01:44:29.967
soll eigentlich sagen, okay, ich nehme eine fertige

01:44:29.967 --> 01:44:32.107
Bibliothek. Und dafür gibt es dann in Python

01:44:32.107 --> 01:44:33.747
zum Beispiel die neue

01:44:33.747 --> 01:44:36.407
Passwortbibliothek, oder es

01:44:36.407 --> 01:44:37.228
gibt Bcrypt.

01:44:39.287 --> 01:44:40.207
Und da

01:44:40.207 --> 01:44:42.107
muss ich mich gar nicht drum kümmern. Ich weiß gar nicht, die

01:44:42.107 --> 01:44:43.267
Passwortbibliothek heißt, glaube ich, Secret?

01:44:43.267 --> 01:44:47.367
und da muss ich halt nicht mehr drum kümmern.

01:44:47.607 --> 01:44:49.627
Also da wird halt die Wahl für dich getroffen

01:44:49.627 --> 01:44:51.688
und das macht es für den

01:44:51.688 --> 01:44:53.067
Entwickler natürlich

01:44:53.067 --> 01:44:55.267
besser, weil der Entwickler keine Entscheidung

01:44:55.267 --> 01:44:57.387
treffen muss. Wenn du ein System groß

01:44:57.387 --> 01:44:59.627
zertifizieren musst, dann musst du wahrscheinlich trotzdem irgendwo eine Entscheidung

01:44:59.627 --> 01:45:01.547
treffen, weil da andere Leute drüber schauen wollen,

01:45:01.627 --> 01:45:03.667
aber für so die Wald- und Wiesenanwendung,

01:45:03.667 --> 01:45:05.688
die einfach mal von

01:45:05.688 --> 01:45:07.728
vielleicht einem kleinen Team entwickelt wird, ist das

01:45:07.728 --> 01:45:09.247
sicherlich eine bessere Option, wenn die

01:45:09.247 --> 01:45:11.607
keine kryptographischen Entscheidungen treffen. Also

01:45:11.607 --> 01:45:15.467
und nicht mal die Entscheidung treffen, welche Algorithmen sie verwenden, sondern vielleicht nur noch sagen,

01:45:15.547 --> 01:45:19.547
ich möchte ein bestimmtes Sicherheitslevel haben. Das ist ja auch immer ein

01:45:19.547 --> 01:45:23.587
Trade-off, dass ich sage, okay, ich kann das zum Beispiel mehrfach hintereinander hashen und dann

01:45:23.587 --> 01:45:27.087
kann man das halt bei dem Passwort, dauert es auch länger, das

01:45:27.087 --> 01:45:31.807
rauszufinden, weil ich halt, wenn ich ein Testpasswort

01:45:31.807 --> 01:45:35.567
habe, muss ich das ganz oft hashen, um das Zielpasswort zu finden, aber das ist

01:45:35.567 --> 01:45:39.447
halt auch ein Problem, was, auf deiner Seite, weil wenn du das halt

01:45:39.447 --> 01:45:41.527
sehr oft hasht, dann dauert es natürlich ein bisschen länger.

01:45:42.127 --> 01:45:43.627
Und du möchtest ja nicht,

01:45:43.767 --> 01:45:45.307
dass dein Service plötzlich eine Minute braucht,

01:45:45.447 --> 01:45:47.527
wenn sich ein Nutzer einloggt, weil dein Passwort

01:45:47.527 --> 01:45:48.947
irgendwie eine Million mal hasht oder sowas.

01:45:49.507 --> 01:45:51.407
Das ist bei uns auch mal so ein schönes Ding

01:45:51.407 --> 01:45:53.148
bei Tests, wo man halt

01:45:53.148 --> 01:45:54.247
Zeit sparen kann.

01:45:55.567 --> 01:45:57.407
Die Passwort-Hash-Funktionen sind ja

01:45:57.407 --> 01:45:59.307
genau die, sie sind ja

01:45:59.307 --> 01:46:01.287
genauso gestaltet, dass sie möglichst langsam sind.

01:46:02.627 --> 01:46:02.807
Und

01:46:02.807 --> 01:46:05.127
genau, da will man dann vielleicht noch mal

01:46:05.127 --> 01:46:06.887
MD5 verwenden oder sowas in der Art,

01:46:07.587 --> 01:46:08.847
weil das ist halt dann deutlich schneller.

01:46:09.447 --> 01:46:17.447
und man legt ja, wenn man jetzt ein Test-Suite durchlaufen lässt, oft ganz viele Nutzer an und das kann Dinge deutlich beschleunigen.

01:46:21.947 --> 01:46:30.427
Sehr, sehr interessant. Da fallen mir ganz viele Sachen, glaube ich, noch zu ein, was man da so macht mit Vulnerabilities und Disclosure und all diesen Dingen.

01:46:30.987 --> 01:46:36.067
Ja, PIX tatsächlich. Und die Frage, wollen wir ein Standard-Lib-Modul vorstellen?

01:46:37.007 --> 01:46:38.927
Ich finde, der ist gerade ein Secret-Modul.

01:46:39.447 --> 01:46:40.188
Ja, das ist super.

01:46:40.188 --> 01:46:41.148
Kennst du dich mit Siegwitz auch?

01:46:42.667 --> 01:46:43.767
Nicht im Detail.

01:46:45.867 --> 01:46:46.267
Schade.

01:46:47.167 --> 01:46:49.587
Ich dachte, ich kann dir die Verantwortung von mir schieben.

01:46:50.287 --> 01:46:51.627
Ja, aber wenn du dich damit beschäftigt hast,

01:46:51.707 --> 01:46:52.127
dann mach das doch.

01:46:53.127 --> 01:46:54.047
Nein, nein, nein.

01:46:54.367 --> 01:46:54.527
Nein.

01:46:58.287 --> 01:46:59.367
Was wäre denn euer Blick?

01:47:00.307 --> 01:47:01.547
Ja, also meiner

01:47:01.547 --> 01:47:03.507
wäre jetzt

01:47:03.507 --> 01:47:04.627
tatsächlich

01:47:04.627 --> 01:47:06.367
youtube.dl

01:47:09.447 --> 01:47:10.807
Wie kommst du denn da drauf?

01:47:11.987 --> 01:47:13.507
Ja, ich habe damit in letzter Zeit

01:47:13.507 --> 01:47:15.287
im letzten Jahr viel gemacht. Ich habe das so,

01:47:15.367 --> 01:47:17.607
ich habe es früher vielleicht ab und zu mal benutzt, um irgendwie mal

01:47:17.607 --> 01:47:19.547
Videos runterzuladen, die ich gerne

01:47:19.547 --> 01:47:21.547
auf der Platte hätte. Also genau

01:47:21.547 --> 01:47:22.688
dafür ist es ja da, aber

01:47:22.688 --> 01:47:25.107
im letzten Jahr habe ich das auch viel

01:47:25.107 --> 01:47:26.287
sozusagen

01:47:26.287 --> 01:47:29.387
in Projekten verwendet, weil es

01:47:29.387 --> 01:47:31.207
darum ging, wie man da Videos irgendwie

01:47:31.207 --> 01:47:32.707
automatisch verarbeiten kann und so.

01:47:33.967 --> 01:47:35.148
Ja, und

01:47:35.148 --> 01:47:36.767
es ist ein sehr, sehr schönes Tool.

01:47:36.767 --> 01:47:38.847
Es ist halt, genau, ja, aber ich glaube,

01:47:38.847 --> 01:47:38.847


01:47:38.847 --> 01:47:40.847
und Philipp kann das deutlich besser erklären, was das eigentlich

01:47:40.847 --> 01:47:42.427
so tut und was so ein bisschen...

01:47:42.427 --> 01:47:44.847
Ich habe auch so einen kleinen politischen Vorfall

01:47:44.847 --> 01:47:46.787
beim YouTube.de, den müssen wir auch noch

01:47:46.787 --> 01:47:48.047
natürlich erzählen.

01:47:48.728 --> 01:47:51.307
Der Name von YouTube.de ist stark irreführend.

01:47:52.347 --> 01:47:54.907
Das hat angefangen als ein

01:47:54.907 --> 01:47:56.067
Download-Tool nur für YouTube

01:47:56.067 --> 01:47:58.627
und als ich das damals übernommen habe,

01:47:59.547 --> 01:48:00.847
da wurden glaube ich

01:48:00.847 --> 01:48:02.827
noch Vimeo unterstützt und noch ein, zwei andere Seiten,

01:48:03.387 --> 01:48:04.148
aber als ich das

01:48:04.148 --> 01:48:06.688
abgegeben habe, also mittlerweile entwickle ich auch schon

01:48:06.688 --> 01:48:07.467
länger nicht mehr daran,

01:48:07.467 --> 01:48:11.207
oder entwickle schon ein bisschen dran, aber bin halt nicht mehr der Chef-Maintainer

01:48:11.207 --> 01:48:15.427
oder Wappen-Maintainer und mittlerweile unterstützt es über 1000 Dienste.

01:48:15.547 --> 01:48:20.027
Das heißt, du kannst es auch auf irgendeine komische Anime-Seite laufen lassen oder auf die ARD-Audiothek

01:48:20.027 --> 01:48:24.307
oder auf archive.org

01:48:24.307 --> 01:48:28.067
oder die CCC-Kongress-Seite und es wird dir halt immer ein ordentliches Video

01:48:28.067 --> 01:48:32.387
zurückliefern. Du kannst natürlich auch sagen, ich möchte verschiedene Konfigurationen

01:48:32.387 --> 01:48:35.907
also ich möchte das Video sortieren oder möchte direkt eine Playlist runterladen

01:48:35.907 --> 01:48:38.247
und YouTube.dl ist komplett in Python geschrieben,

01:48:38.688 --> 01:48:41.487
das ist vielleicht auch ein bisschen besonders, weil es eine Python-Anwendung ist,

01:48:41.767 --> 01:48:43.087
die gar keine Dependencies hat.

01:48:43.587 --> 01:48:47.587
YouTube.dl verlangt nur die Standard-Diplotik und das auch sehr, sehr flexibel.

01:48:47.587 --> 01:48:51.688
Also bis vor kurzem noch konnten wir zwischen Python 2.6,

01:48:52.267 --> 01:48:55.107
ging noch bis Python 3.8, wurde alles unterstützt,

01:48:55.228 --> 01:48:56.427
hat sehr, sehr viele Benutzer

01:48:56.427 --> 01:49:02.107
und ist halt hoffentlich ein super flexibles Tool,

01:49:02.188 --> 01:49:05.547
das man auch sowohl programmatisch als auch als Commodore-Zeitanwendung verwenden kann

01:49:05.547 --> 01:49:07.387
um schnell was runterzuladen. Viele

01:49:07.387 --> 01:49:09.327
grafische oder serverseitige Programme

01:49:09.327 --> 01:49:10.767
verwenden auch intern YouTube.de

01:49:10.767 --> 01:49:13.387
um halt Videos runterzuladen aus

01:49:13.387 --> 01:49:15.307
verschiedensten Quellen. Typischerweise, also

01:49:15.307 --> 01:49:17.407
oft YouTube, aber kann auch was ganz anderes sein.

01:49:18.447 --> 01:49:19.407
Und der Vorfall,

01:49:19.487 --> 01:49:21.267
der halt passiert war, ist, also

01:49:21.267 --> 01:49:23.207
vor dem öffentlichen Vorfall

01:49:23.207 --> 01:49:25.367
bin ich und ein Host da angeschrieben

01:49:25.367 --> 01:49:27.627
worden von einer deutschen Anwaltskanzlei,

01:49:27.827 --> 01:49:29.207
die Rush heißt die,

01:49:29.547 --> 01:49:30.827
die sind, wenn man nach denen googelt,

01:49:31.148 --> 01:49:33.067
ich hab sie erst natürlich nach denen gegoogelt, als ich

01:49:33.067 --> 01:49:34.967
das schreiben bekommen hab, sieht man, okay, die

01:49:34.967 --> 01:49:38.107
für schickende malen Abnahmen wegen Tauschbörsenvorfällen oder sowas.

01:49:38.127 --> 01:49:39.307
Irgendwie bekannt für den Namen, ja.

01:49:40.327 --> 01:49:48.387
Und die haben halt da typischen, also ich kann das jetzt nicht so beurteilen, ich bin kein Jurist,

01:49:48.688 --> 01:49:52.747
aber die haben ein sehr langes Papier geschrieben, wo sehr große Drohungen drin standen,

01:49:52.827 --> 01:49:56.667
was für mich eigentlich jetzt irrelevant ist, weil ich bin ja nicht mehr in ein Projekt involviert,

01:49:57.127 --> 01:50:00.907
also ich habe noch gelegentlich Contributions geleistet, aber auch nichts mehr zu YouTube,

01:50:01.047 --> 01:50:02.747
sondern nur noch zu ganz anderen Seiten.

01:50:02.747 --> 01:50:08.007
und dann haben die wohl aber mitbekommen, dass YouTube.dl auf GitHub gehostet ist.

01:50:09.027 --> 01:50:13.167
Und dann an die amerikanischen, ja, richtig technisch drauf waren sie nicht,

01:50:13.607 --> 01:50:15.867
aber gut, sie sind auch Rechteinwälte, sind keine Programmierer,

01:50:16.247 --> 01:50:19.367
haben halt nur so ein bisschen was gefunden und haben auch viele Sachen nicht richtig verstanden.

01:50:20.287 --> 01:50:23.347
Also das ist halt, ja, kann man halt nicht machen.

01:50:24.807 --> 01:50:29.707
Und dann sind sie halt zu den Amerikanern gegangen und die RIA

01:50:29.707 --> 01:50:42.967
und die hat dann halt GitHub eine Notiz geschickt, eine DMCA-Notiz, dass sie halt die YouTube.js sperren sollen.

01:50:43.067 --> 01:50:45.307
Und davon haben die meisten Leute erst mitbekommen, dass irgendwas nicht stimmt.

01:50:45.707 --> 01:50:50.407
Also diese Vorgeschichte, das war schon Wochen davor in Deutschland und auch andere Sachen waren Wochen davor,

01:50:50.587 --> 01:50:54.228
aber was die Öffentlichkeit mitbekommen hat, war okay, GitHub ist gesperrt.

01:50:54.228 --> 01:50:58.267
Und GitHub ist freundlicherweise für das YouTube.js Projekt, das haustet die Downloads.

01:50:58.267 --> 01:51:28.247
und die Programmiersprache Python.

01:51:28.267 --> 01:51:32.148
runterladen kann. Also der Stein des Anschlusses war nicht die normale YouTube-Downloads, sondern die

01:51:32.148 --> 01:51:35.907
YouTube-Musikvideos. Das war das Problem, was die

01:51:35.907 --> 01:51:40.327
Rechtsanwälte bemängelt hatten. Und was jetzt aber passiert ist,

01:51:40.427 --> 01:51:43.427
dass glücklicherweise die IFF, die Electronic

01:51:43.427 --> 01:51:48.167
Frontier Foundation, in den USA die Verteidigung

01:51:48.167 --> 01:51:51.667
übernommen hat von YouTube.dl und da eine Gegennotiz geschickt hat und jetzt auf

01:51:51.667 --> 01:51:56.407
GitHub wieder alles da ist und GitHub das wieder hostet und das Projekt wahrscheinlich

01:51:56.407 --> 01:52:01.167
und ich bin jetzt ganz normal weitergelaufen und es alles wieder klappt.

01:52:01.567 --> 01:52:01.567
Ich war da auch gar nicht so viel involviert, ich bin halt nur von zig Leuten angeschriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenriebenrieben

01:52:26.407 --> 01:52:27.867
wo das die IFS sich darum gekümmert hat.

01:52:28.188 --> 01:52:30.027
Und auch über die Unterstützung von GitHub

01:52:30.027 --> 01:52:32.107
und zuletzt wollte ich vielleicht auch erwähnen,

01:52:32.167 --> 01:52:34.127
es gibt einen deutschen Hoster, der daran beteiligt ist,

01:52:34.547 --> 01:52:35.467
das ist Uberspace,

01:52:35.967 --> 01:52:38.067
da kann man super leicht

01:52:38.067 --> 01:52:39.907
seinen eigenen Dienst hosten und

01:52:39.907 --> 01:52:41.327
die sind auch rechtlich

01:52:41.327 --> 01:52:43.767
angeschrieben worden, auch von den Rechtsanwälten

01:52:43.767 --> 01:52:45.627
rasch und die haben sich

01:52:45.627 --> 01:52:47.767
auf eigene Kosten, haben die ihre eigene

01:52:47.767 --> 01:52:50.027
Verteidigung organisiert. Die hosten halt nur die Webseite,

01:52:50.127 --> 01:52:51.307
die hosten nicht das Programm selber

01:52:51.307 --> 01:52:53.327
aber auch das fand die Rechtsanwälte

01:52:53.327 --> 01:52:55.867
verwerflich. Glücklicherweise ist

01:52:55.867 --> 01:53:25.847
und Jochen unterhalten sich über die Programmiersprache Python

01:53:25.867 --> 01:53:55.847
und die Programme.

01:53:55.867 --> 01:53:57.247
Ja

01:53:57.247 --> 01:54:00.587
Aber ja, also ich glaube

01:54:00.587 --> 01:54:01.927
auch eher, das ist der, also

01:54:01.927 --> 01:54:04.188
sagen wir mal so, das hat dem Projekt wahrscheinlich doch

01:54:04.188 --> 01:54:06.427
eher stark genützt

01:54:06.427 --> 01:54:08.107
das hat jetzt nochmal sehr viel Aufmerksamkeit

01:54:08.107 --> 01:54:10.047
bekommen und hat

01:54:10.047 --> 01:54:11.847
der Streisand-Effekt voll zugeschlagen

01:54:11.847 --> 01:54:13.167
Ja, auf jeden Fall

01:54:13.167 --> 01:54:16.047
Also ich bin tatsächlich froh, dass es mittlerweile soweit ist, dass

01:54:16.047 --> 01:54:18.107
solche Sachen nicht mehr einfach so dann weggeblockt

01:54:18.107 --> 01:54:20.067
werden, sondern dass die Leute sich anfangen

01:54:20.067 --> 01:54:21.987
mit solchen Dingen auch juristisch dann auszukennen

01:54:21.987 --> 01:54:24.287
und dass diese komischen Kanzleien

01:54:24.287 --> 01:54:25.827
oder wie man ja auch immer das dann nennen soll

01:54:25.827 --> 01:54:28.027
langsam aber sicher gegen die Wände rennen.

01:54:28.967 --> 01:54:30.087
Ja, ist natürlich als Open Source

01:54:30.087 --> 01:54:32.327
Programmierer. Ich bin halt nur eine Person.

01:54:32.547 --> 01:54:34.107
Ich habe da keine

01:54:34.107 --> 01:54:35.967
große juristische Know-how.

01:54:36.207 --> 01:54:37.927
Also ich kann das halt technisch beurteilen,

01:54:38.027 --> 01:54:40.287
was im Gesetz steht. Aber offensichtlich

01:54:40.287 --> 01:54:42.047
gibt es auch einige Gerichte, die

01:54:42.047 --> 01:54:43.987
das sehr flexibel

01:54:43.987 --> 01:54:45.847
ausgelegt haben, was da im Gesetz steht.

01:54:46.427 --> 01:54:48.228
Also das Landgericht Hamburg hat gesagt,

01:54:48.387 --> 01:54:49.787
okay, im Wesentlichen,

01:54:49.787 --> 01:54:51.487
da steht, dass es

01:54:51.487 --> 01:54:54.027
eine

01:54:54.027 --> 01:54:55.547
eine technisch

01:54:55.547 --> 01:54:56.527
durchsetzbare

01:54:56.527 --> 01:54:59.747
Verschlüsselung oder Verschleierung geben muss

01:54:59.747 --> 01:55:01.627
und das hat er einfach interpretiert als, ja, das

01:55:01.627 --> 01:55:03.667
hört sich aber komisch an, das interpretieren wir jetzt anders

01:55:03.667 --> 01:55:05.487
und jetzt haben sie es gesagt in dem Urteil,

01:55:05.747 --> 01:55:07.827
eigentlich alles, was ein normaler Benutzer nicht machen kann,

01:55:07.867 --> 01:55:09.148
ist verboten. Das heißt,

01:55:09.547 --> 01:55:11.467
es gab ein

01:55:11.467 --> 01:55:13.847
vergleichbares Urteil und da hatte jemand argumentiert,

01:55:13.947 --> 01:55:15.707
okay, das kann man aber auch in den Browser-Tools machen

01:55:15.707 --> 01:55:17.747
und da hat das Landgericht Hamburg gesagt, nee, das ist

01:55:17.747 --> 01:55:19.728
aber kein normaler Benutzer nicht,

01:55:19.827 --> 01:55:21.587
weil das ist nicht im Internet Explorer drin oder so.

01:55:22.067 --> 01:55:23.787
Und das ist halt eine sehr

01:55:23.787 --> 01:55:24.927
fragt über die Argumentation.

01:55:25.787 --> 01:55:27.987
Der Jurist hat das dann selber ausprobiert

01:55:27.987 --> 01:55:29.207
und dann festgestellt, nee, er kann das nicht.

01:55:29.527 --> 01:55:29.927
Ja, genau.

01:55:32.367 --> 01:55:33.927
Und YouTube-DLS funktioniert eigentlich

01:55:33.927 --> 01:55:34.907
wie ein normaler Browser.

01:55:35.188 --> 01:55:37.927
Nicht grundsätzlich unterschiedlich wie Chrome.

01:55:38.007 --> 01:55:40.148
Es hat auch der eigene JavaScript-Engine in Python geschrieben.

01:55:41.287 --> 01:55:42.067
Ach, äh,

01:55:42.087 --> 01:55:42.587
ah, okay.

01:55:44.207 --> 01:55:45.467
Naja, stimmt.

01:55:45.587 --> 01:55:47.267
Dann kann er ja externe Abhängigkeiten geben.

01:55:47.567 --> 01:55:50.507
Das hätte ich jetzt auch gedacht, dass das vielleicht irgendein

01:55:50.507 --> 01:55:52.547
Headless-Browser-Engine

01:55:52.547 --> 01:55:53.467
noch mit dabei ist oder so.

01:55:53.467 --> 01:55:53.467


01:55:54.467 --> 01:55:55.847
Gar keine Python-Abhängigkeiten.

01:55:56.487 --> 01:55:58.447
Klar, wenn ich jetzt normale

01:55:58.447 --> 01:56:00.507
Python-Anwendungen schreibe, dann verwende ich Abhängigkeiten.

01:56:00.627 --> 01:56:02.467
Wir haben ja eben gerade besprochen, dass es eigentlich gut ist,

01:56:02.507 --> 01:56:03.707
wenn ich fertige Bibliotheken verwende.

01:56:04.247 --> 01:56:06.407
Aber YouTube.de muss halt auf ganz unterschiedlichen

01:56:06.407 --> 01:56:08.167
Systemen laufen. Da gibt es halt Leute, die kommen an mit

01:56:08.167 --> 01:56:09.547
Red Hat und haben halt, weiß ich,

01:56:10.027 --> 01:56:11.887
Python 2.6 oder bis vor kurzem noch

01:56:11.887 --> 01:56:14.547
Python 2.5 haben die noch drauf

01:56:14.547 --> 01:56:16.067
oder Python 2.4, keine Ahnung.

01:56:16.327 --> 01:56:18.167
Und da kannst du halt nicht darauf vertrauen, dass die auch überhaupt

01:56:18.167 --> 01:56:20.307
irgendwas installieren können. Die sind halt froh,

01:56:20.347 --> 01:56:22.327
wenn die ein Binary bekommen.

01:56:22.327 --> 01:56:22.327


01:56:24.707 --> 01:56:29.707
und das geht ja in Python relativ gut. Man kann die Datei einfach als ZIP verpacken und dann ist es ausführbar.

01:56:29.707 --> 01:56:36.707
Und man kann es auch mit YouTube.acx freeze verwenden, um halt auch eine Excel für Windows zu erzeugen

01:56:36.707 --> 01:56:39.707
und das läuft dann wirklich überall ohne das man es installieren muss.

01:56:39.707 --> 01:56:44.707
Und ich glaube das ist auch ein Grund für den Erfolg dieser Software, dass man das halt einfach so laufen lassen kann,

01:56:44.707 --> 01:56:48.707
dass man sich keine Gedanken machen muss, auch wenn das System komplett zerschlossen ist als Python-Entwickler.

01:56:48.707 --> 01:56:51.707
Das klappt immer. YouTube.acx braucht nur eine schnelle Politik.

01:56:51.707 --> 01:56:53.728
Sehr gut, sehr gut

01:56:53.728 --> 01:56:56.447
Ja, es klingt sehr spannend

01:56:56.447 --> 01:56:59.987
Ja, ja, mir war das auch gar nicht so klar

01:56:59.987 --> 01:57:02.027
dass man da tatsächlich irgendwie die meisten Seiten

01:57:02.027 --> 01:57:03.567
mit bedienen kann

01:57:03.567 --> 01:57:05.967
und dann, ja, ich

01:57:05.967 --> 01:57:07.887
hatte früher auch immer gedacht, das wäre eigentlich für

01:57:07.887 --> 01:57:09.287
YouTube, aber

01:57:09.287 --> 01:57:12.047
ja, es ist wirklich sehr, sehr praktisch, es nimmt einem auch viel ab

01:57:12.047 --> 01:57:13.927
also ich benutze das jetzt halt

01:57:13.927 --> 01:57:14.267
immer so

01:57:14.267 --> 01:57:17.427
quasi um halt

01:57:17.427 --> 01:57:20.267
automatisiert von allen möglichen Seiten Dinge runterzuladen

01:57:20.267 --> 01:57:21.547
und das ist halt sozusagen die Schnittstelle

01:57:21.547 --> 01:57:23.507
die YouTube-DL ist sozusagen meine

01:57:23.507 --> 01:57:25.787
API zu Seiten, die Videos

01:57:25.787 --> 01:57:27.627
haben, um das Video

01:57:27.627 --> 01:57:28.387
da rauszukriegen.

01:57:28.387 --> 01:57:28.688
Genau.

01:57:29.367 --> 01:57:35.728
Ja, Pix.

01:57:36.188 --> 01:57:38.188
Also ich würde dieses Mal gleich Python Date

01:57:38.188 --> 01:57:40.247
Tutorial picken, weil irgendwie das ein schöner

01:57:40.247 --> 01:57:41.307
Rapper ist, über wie man

01:57:41.307 --> 01:57:43.967
Datumsangaben irgendwie machen kann.

01:57:44.427 --> 01:57:46.167
Verschiedene Zeitkalendern mit Deltas

01:57:46.167 --> 01:57:48.087
irgendwie. Ich wollte es mal erwähnt haben,

01:57:48.167 --> 01:57:50.107
das stand irgendwo noch auf meiner Liste, hat jetzt nicht den Topic gar nicht

01:57:50.107 --> 01:57:50.747
mehr so viel zu tun.

01:57:51.547 --> 01:57:53.947
Ja, Datutils

01:57:53.947 --> 01:57:55.567
ist tatsächlich auch sehr nett

01:57:55.567 --> 01:57:57.487
also ich, das Datutil

01:57:57.487 --> 01:57:59.327
Parse, das Parse, erstaunt

01:57:59.327 --> 01:58:01.367
nicht viel, also dem kann man irgendwelche Strings

01:58:01.367 --> 01:58:03.228
geben, die so, also man hat ja oft irgendwie

01:58:03.228 --> 01:58:04.987
sieht man dann irgendwo so ein String

01:58:04.987 --> 01:58:07.507
mit Datums und Zeitangaben drin und dann

01:58:07.507 --> 01:58:08.767
denkt man sich, oh, wie waren

01:58:08.767 --> 01:58:11.607
jetzt nochmal die Format-String-Dinger

01:58:11.607 --> 01:58:12.547
wie hießen die nochmal alle?

01:58:13.747 --> 01:58:15.527
Und dann nimmt man Datutil Parse

01:58:15.527 --> 01:58:17.787
und dann passt das automatisch

01:58:17.787 --> 01:58:19.527
aber dann muss man irgendwie noch, ich glaube

01:58:19.527 --> 01:58:21.447
das geht aber auch irgendwie, man kriegt auch aus dem

01:58:21.447 --> 01:58:23.327
DTutorial Pass dann raus, wie der

01:58:23.327 --> 01:58:24.728
Formatstring eigentlich sein müsste.

01:58:25.047 --> 01:58:27.527
Und andere Kalender. Genau, weil

01:58:27.527 --> 01:58:29.447
DTutorial Pass sollte man nicht

01:58:29.447 --> 01:58:31.407
über größere Datenmengen

01:58:31.407 --> 01:58:33.507
irgendwie aufrufen, weil das wird dann halt sehr langsam,

01:58:33.648 --> 01:58:35.067
wenn man das Inhaltschleife verwendet, aber

01:58:35.067 --> 01:58:37.507
um rauszukriegen, wie man das denn jetzt eigentlich

01:58:37.507 --> 01:58:39.487
aufpasst und dann halt an den Formatstring zu

01:58:39.487 --> 01:58:41.587
kommen, den man dann letztlich verwendet

01:58:41.587 --> 01:58:43.527
für Strip-Time oder so,

01:58:43.728 --> 01:58:44.307
das ist super.

01:58:45.688 --> 01:58:47.447
Und dein Pickoffen?

01:58:47.447 --> 01:58:48.047
Hatte ich doch schon.

01:58:48.047 --> 01:59:18.027
und Jochen unterhalten sich über die Programmiersprache Python

01:59:18.047 --> 01:59:18.947
oder sowas wie Bequipped.

01:59:22.047 --> 01:59:23.688
Da haben wir das auch noch reinge...

01:59:23.688 --> 01:59:24.887
Ja,

01:59:25.228 --> 01:59:27.587
schön, dass ihr alle dabei seid. Danke, Philipp, dass du

01:59:27.587 --> 01:59:29.347
Zeit gefunden hast für uns. Ja, voll gut.

01:59:30.907 --> 01:59:32.087
Eine sehr interessante Episode.

01:59:32.307 --> 01:59:33.167
Ja, auch für mich sehr interessant.

01:59:34.467 --> 01:59:35.927
Ja, vielen Dank, dass ich dabei sein durfte.

01:59:36.228 --> 01:59:36.947
Ja, mir geht's auch.

01:59:37.707 --> 01:59:39.567
Wenn ich noch einmal ganz kurz Werbung machen darf,

01:59:39.747 --> 01:59:42.007
bei Poxine suchen wir immer Python-Entwickler.

01:59:43.228 --> 01:59:43.728
Oder was immer,

01:59:43.947 --> 01:59:45.887
aber aktuell suchen wir auf jeden Fall Python-Entwickler

01:59:45.887 --> 01:59:47.867
oder auch Leute, die mit Java oder mit

01:59:47.867 --> 01:59:50.307
und Javascript arbeiten, speziell mit React.

01:59:50.867 --> 01:59:54.228
Also wenn ihr ein guter Entwickler seid, vielleicht sogar im Raum Düsseldorf

01:59:54.228 --> 01:59:56.867
oder auch nur ganz grob in NRW irgendwo,

01:59:57.467 --> 01:59:58.927
dann meldet euch bei Vaboxine.

01:59:58.927 --> 01:59:59.867
Box zu programmieren.

02:00:00.527 --> 02:00:02.927
Die Dienste rund um die Tony Box zu programmieren

02:00:02.927 --> 02:00:04.627
macht sehr viel Spaß. Es ist total

02:00:04.627 --> 02:00:05.807
toll zu wissen, okay,

02:00:06.667 --> 02:00:07.147
jede Nacht

02:00:07.147 --> 02:00:10.927
gehen Tausende oder Millionen

02:00:10.927 --> 02:00:12.827
Kinder mittlerweile mit der Tony Box

02:00:12.827 --> 02:00:14.847
ins Schlaf und wir machen gute Dienste,

02:00:15.367 --> 02:00:16.767
die hoffentlich den Eltern

02:00:16.767 --> 02:00:18.467
das Leben einfach machen

02:00:18.467 --> 02:00:20.907
und dafür sorgen, dass die Kinder gute Geschichten

02:00:20.907 --> 02:00:23.127
hören. Das war die erste Werbeanzeige

02:00:23.127 --> 02:00:23.747
am Python Podcast.

02:00:24.287 --> 02:00:26.927
Ja, aber ich kann nicht nur...

02:00:27.487 --> 02:00:28.187
Könnt ihr rausschneiden.

02:00:28.927 --> 02:00:30.427
Nein, nein, nein, das finde ich super.

02:00:30.587 --> 02:00:33.927
Das ist ein schönes Projekt hier aus der Gegend.

02:00:36.167 --> 02:00:37.927
Ja, alles klar, dann würde ich sagen.

02:00:37.987 --> 02:00:38.607
Vielen Dank, Philipp.

02:00:39.407 --> 02:00:41.447
Bleibt uns gewogen, egal wann ihr uns hört.

02:00:41.707 --> 02:00:42.347
Schaltet wieder ein.

02:00:42.927 --> 02:00:44.167
Morgens, mittags, abends, tags, nachts.

02:00:44.307 --> 02:00:45.547
Zum Einschlafen ist auch immer super.

02:00:46.547 --> 02:00:47.967
Liebe Grüße und bis zum nächsten Mal.

02:00:48.807 --> 02:00:49.167
Tschüss.