WEBVTT

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

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

00:00:08.940 --> 00:00:12.520
Dazu haben wir natürlich auch wieder Gäste eingeladen, neben dem Jochen und mir, dem Dominik,

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

00:00:16.540 --> 00:00:16.760
Hallo!

00:00:17.580 --> 00:00:20.860
Wie geht's 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.240 --> 00:00:27.320
Tja, wer fängt an? Also, ich bin der Jochen.

00:00:27.320 --> 00:00:29.180
Wenn ihr diesen Podcast hört,

00:00:29.280 --> 00:00:31.320
habt ihr mich wahrscheinlich schon einmal dabei gehabt.

00:00:31.740 --> 00:00:32.800
Ja, okay. Also ich glaube,

00:00:32.900 --> 00:00:34.740
das brauche ich gar nicht weiter ausführen.

00:00:35.080 --> 00:00:36.740
Aber ich glaube, am interessantesten ist wahrscheinlich Philipp.

00:00:37.120 --> 00:00:38.500
Der ist jetzt gerade zum ersten Mal dabei.

00:00:38.740 --> 00:00:40.920
Genau. Ja, ich bin Philipp.

00:00:41.060 --> 00:00:42.680
Ich habe bis vor kurzem noch

00:00:42.680 --> 00:00:44.200
an der Uni Düsseldorf

00:00:44.200 --> 00:00:46.920
studiert und nachher auch gelehrt

00:00:46.920 --> 00:00:48.300
zum Thema unter anderem auch Security.

00:00:48.540 --> 00:00:50.320
Also ich habe da die Vorlesung zur

00:00:50.320 --> 00:00:52.480
Internetsicherheit, hieß die, glaube ich.

00:00:52.600 --> 00:00:54.880
Oder wie haben wir sie genannt? Also intern hieß die einfach Security.

00:00:55.700 --> 00:00:56.820
Die Security-Vorlesung

00:00:56.820 --> 00:00:58.600
gehalten. Netzwerk haben wir sie genannt.

00:00:59.340 --> 00:01:00.720
Also Netzwerksicherheit hieß sie offiziell.

00:01:02.120 --> 00:01:03.180
Und bin jetzt

00:01:03.180 --> 00:01:05.220
seit zweieinhalb Jahren arbeite ich

00:01:05.220 --> 00:01:06.840
für die Firma Boxine in Düsseldorf.

00:01:07.400 --> 00:01:09.000
Die ist wahrscheinlich bekannt durch ihr Produkt

00:01:09.000 --> 00:01:11.160
die Toni-Box. Also wenn man kleine Kinder hat, dann kennt

00:01:11.160 --> 00:01:13.260
man die Toni-Box. Und genau die läuft

00:01:13.260 --> 00:01:15.200
auch mit Python. Vielleicht kommen wir da nochmal ein bisschen dazu.

00:01:16.600 --> 00:01:17.080
Oh cool, da haben wir

00:01:17.080 --> 00:01:19.100
letztens am Wochenende noch jemanden getroffen, der für die Firma arbeitet.

00:01:19.180 --> 00:01:20.980
Ah, interessant. Ja, ja, ich habe mich jetzt

00:01:20.980 --> 00:01:23.080
letztes Wochenende, genau mit Jens, den kennst du dann wahrscheinlich

00:01:23.080 --> 00:01:24.980
auch lange unterhalten. Genau, der Jens ist auch in meinem Team.

00:01:25.220 --> 00:01:26.880
Jens ist auch ein anderer, einer von den

00:01:26.880 --> 00:01:28.360
Python-Entwicklern bei BoxCinema.

00:01:30.040 --> 00:01:30.360
Ja, cool.

00:01:30.380 --> 00:01:32.400
Ja, die Tony-Box ist super

00:01:32.400 --> 00:01:34.820
beliebt. Ja, dass es ein Python-Projekt geworden ist.

00:01:34.980 --> 00:01:36.540
Also ihr kennt ja bestimmt, das sind diese kleinen

00:01:36.540 --> 00:01:39.000
Spielzeugfiguren, die man auf eine Box

00:01:39.000 --> 00:01:40.920
stellt und dann spielen sie ein Hörspiel. Also für alle, die

00:01:40.920 --> 00:01:41.800
keine Kinder haben.

00:01:43.800 --> 00:01:45.140
Genau. Ja, schön.

00:01:45.320 --> 00:01:47.100
Also heute das Thema Security. Wir wollen das so ein bisschen

00:01:47.100 --> 00:01:49.080
aus mehreren Perspektiven beleuchten, die wir

00:01:49.080 --> 00:01:50.480
noch gar nicht so genau festgelegt haben.

00:01:50.920 --> 00:01:52.640
Ist wie immer, ich hab keine Ahnung, stell dumme Fragen

00:01:52.640 --> 00:01:54.580
und die Jungs antworten ein bisschen.

00:01:55.220 --> 00:02:09.060
Ja, fangen wir doch direkt an. Was ist denn Sicherheit, Security, was meint das denn? Also, dass niemand irgendwie einbricht und dann hat jemand irgendwie einen kaputten Pullover an und dann riecht er in so einem Rechner mit grüner Schrift und dunklem Monitor oder wie sieht das aus?

00:02:09.620 --> 00:02:22.500
Das triffst du wahrscheinlich schon ziemlich gut. Du möchtest Systeme schützen vor irgendwelchen Angreifern. Das ist das grundsätzliche Prinzip der Sicherheit.

00:02:22.540 --> 00:02:27.640
Du hast dann verschiedene Ziele. Ganz traditionell hat man die Intel gedreht, dass ich sagen möchte, niemand möchte etwas ändern.

00:02:28.000 --> 00:02:33.180
Ich habe die Vertraulichkeit, dass ich sagen möchte, niemand soll herausfinden können, welche Daten meine Benutzer haben.

00:02:33.440 --> 00:02:37.600
Zum Beispiel bei uns beruflich bei der Tonybox. Auf die kann man ja beliebige Audio-Teilen draufspielen.

00:02:37.700 --> 00:02:43.360
Und es soll auf keinen Fall möglich sein, dass irgendjemand anders die Audio-Teilen von einem Kunden abrufen kann.

00:02:43.680 --> 00:02:44.980
Also das wäre Vertraulichkeit.

00:02:45.640 --> 00:02:50.420
Und dann haben wir noch Ziele, die werden manchmal so Zuverlässigkeit genannt oder Availability.

00:02:51.520 --> 00:02:54.600
wo es halt darum geht, dass das System verfügbar ist die ganze Zeit.

00:02:55.880 --> 00:02:58.600
Okay, also schon irgendwas, was einen auch privat betreffen kann natürlich

00:02:58.600 --> 00:03:00.580
und vor dem man vielleicht geschützt werden möchte.

00:03:01.440 --> 00:03:05.320
Ja, und wie macht man das in Python?

00:03:08.400 --> 00:03:10.280
Ja, also ich würde jetzt so spontan sagen,

00:03:10.360 --> 00:03:12.020
eigentlich hat man ja in Python schon mal ganz gute Karten,

00:03:12.140 --> 00:03:14.260
weil ein großer Teil der wirklich bösen Fehler,

00:03:14.340 --> 00:03:16.660
die einem da so begegnen können,

00:03:16.760 --> 00:03:18.480
hat man jetzt in Python eigentlich gar nicht.

00:03:18.480 --> 00:03:21.500
Also so mit Buffer-Warflows hat man eigentlich eher nicht so wirklich viel zu tun.

00:03:21.520 --> 00:03:23.080
Obwohl, jetzt eigentlich schon wieder,

00:03:23.160 --> 00:03:24.120
dem müsste ich erklären, was das ist.

00:03:24.300 --> 00:03:25.180
Oh nein, das wollte ich schon.

00:03:25.200 --> 00:03:27.420
Wir sind direkt eingeschrieben, du hast gesagt, man kann Fehler machen.

00:03:27.640 --> 00:03:30.780
Und das bedeutet, dass Fehler zu Sicherheitslücken führen können,

00:03:30.920 --> 00:03:32.180
die dann Angreifer ausnutzen können.

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

00:03:34.080 --> 00:03:34.960
welche Sicherheitslücken es denn gibt.

00:03:35.060 --> 00:03:37.860
Aber was du sagst, heißt, es gibt Fehler, die jemand gemacht hat,

00:03:37.920 --> 00:03:39.860
also ein Entwickler, eine Entwicklerin gemacht hat,

00:03:39.920 --> 00:03:43.240
die dazu führen, dass es schwierig wird?

00:03:44.540 --> 00:03:45.820
Genau, das Programm macht dann irgendwas,

00:03:45.940 --> 00:03:47.120
was der Entwickler nicht gedacht hat.

00:03:47.120 --> 00:03:49.880
Also der Entwickler dachte sich, okay, da kommen doch immer gute Daten.

00:03:50.460 --> 00:03:56.320
Und dann hat jemand mit einem grünen Bildschirm und einem Kapuzenpulli nachher herausgefunden,

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

00:04:00.040 --> 00:04:02.640
und erlaubt mir dann Zugriff auf irgendwelche geheimen Daten

00:04:02.640 --> 00:04:05.840
oder im schlimmsten Fall erlaubt mir sogar Code auszuführen bei irgendjemand.

00:04:07.160 --> 00:04:08.360
Genau, das wollen wir halt verhindern.

00:04:08.440 --> 00:04:11.740
Und da gibt es halt eine ganze Menge Schwachstellen, je nachdem, auf welcher Plattform man ist.

00:04:12.800 --> 00:04:14.700
Also zum Beispiel auch mit Python gibt es Unterschiede natürlich,

00:04:14.700 --> 00:04:19.580
wenn ich einen Treiber schreibe, dann kann auch der erwähnte Buffer-Overflow vielleicht schon mal passieren.

00:04:20.460 --> 00:04:23.300
wenn ich mit Python eher eine Web-Anwendung

00:04:23.300 --> 00:04:25.120
schreibe, dann muss ich mir da halt typische

00:04:25.120 --> 00:04:27.040
Sicherheitsblicken anschauen. Aber das ist eigentlich immer,

00:04:27.140 --> 00:04:28.460
dass ich irgendwelche Eingaben des

00:04:28.460 --> 00:04:30.240
Benutzers nicht richtig

00:04:30.240 --> 00:04:32.780
interpretiere und dann plötzlich komische Sachen mache.

00:04:32.800 --> 00:04:35.060
Benutzer-Eingabe, Speicher, also Buffer-Overflow, vielleicht noch mal

00:04:35.060 --> 00:04:36.980
ganz kurz, dass irgendwie der Speicher läuft

00:04:36.980 --> 00:04:39.020
voll und dann kommt man in Bereiche rein, die

00:04:39.020 --> 00:04:40.700
das Programm gar nicht vorgesehen hat und dann

00:04:40.700 --> 00:04:42.760
passieren komische, magische Dinge.

00:04:43.240 --> 00:04:44.280
Das ist dann diese Blackbox der

00:04:44.280 --> 00:04:46.620
Mensch mit dem kaputten Pullover.

00:04:46.920 --> 00:04:48.520
Naja, also ganz, ganz kurz

00:04:48.520 --> 00:04:50.820
irgendwie, ja, ist auch eine relativ spezielle Art

00:04:50.820 --> 00:04:52.720
von Sicherheitsproblemen, aber das

00:04:52.720 --> 00:04:54.680
war irgendwann, ich glaube, das war dann Mitte der 90er,

00:04:54.740 --> 00:04:56.500
ich weiß nicht mehr so ganz genau, gab es einen Artikel

00:04:56.500 --> 00:04:59.040
im Frag Magazine

00:04:59.040 --> 00:05:00.680
von Aleph One

00:05:00.680 --> 00:05:02.820
irgendwie, Smashing the Stack for Fun

00:05:02.820 --> 00:05:04.040
and Profit und

00:05:04.040 --> 00:05:06.680
es betrifft vor allen Dingen die

00:05:06.680 --> 00:05:08.200
Programmiersprache C, die ist halt,

00:05:08.500 --> 00:05:10.160
da sind Strings Nullpointer terminiert

00:05:10.160 --> 00:05:12.700
und, naja,

00:05:12.900 --> 00:05:14.700
Ach so. Genau.

00:05:15.200 --> 00:05:16.680
Also da steht nicht

00:05:16.680 --> 00:05:18.960
einem String vorher dran, der ist jetzt so und so

00:05:18.960 --> 00:05:21.000
lang und dann liest man halt nur bis da,

00:05:21.140 --> 00:05:23.040
sondern man liest halt so lange, bis halt ein Nullbyte

00:05:23.040 --> 00:05:24.880
kommt und dann hört man halt auf damit

00:05:24.880 --> 00:05:26.940
oder halt eben auch nicht, wenn man irgendwie das

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

00:05:28.840 --> 00:05:30.720
gar keine Nullbytes, sondern sein eigener Code, dann liest

00:05:30.720 --> 00:05:32.820
ja gar nicht, liest das immer noch weiter. Genau,

00:05:32.880 --> 00:05:34.680
wenn man zum Beispiel einen festen Buffer definiert hat

00:05:34.680 --> 00:05:36.500
und aber nicht

00:05:36.500 --> 00:05:38.580
überprüft, ob die Eingabe von dem Benutzer halt

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

00:05:40.800 --> 00:05:42.740
hinwegschreiben unter Umständen

00:05:42.740 --> 00:05:44.920
und dann halt auch, also was man

00:05:44.920 --> 00:05:46.060
dann macht, man schreibt dann irgendwie eine Menge

00:05:46.060 --> 00:05:48.740
ein NOPS, was ist das?

00:05:48.940 --> 00:05:50.840
Irgendwas A oder so

00:05:50.840 --> 00:05:52.800
rein, hofft dann, dass

00:05:52.800 --> 00:05:54.880
beim Rücksprung aus der Funktion irgendwie

00:05:54.880 --> 00:05:56.880
man in diesem Bereich landet und dann rutscht

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

00:05:59.200 --> 00:06:00.960
hat. Und dann kann man also im besten Fall

00:06:00.960 --> 00:06:02.860
irgendwie direkt das Programm

00:06:02.860 --> 00:06:04.600
komplett übernehmen. Und

00:06:04.600 --> 00:06:05.980
ja, das war

00:06:05.980 --> 00:06:08.540
lange Zeit war das ganz,

00:06:09.060 --> 00:06:10.880
viel Server-Software hatte

00:06:10.880 --> 00:06:13.120
diese Fehler und man konnte das halt ausnutzen.

00:06:13.940 --> 00:06:15.000
Obwohl, ich meine, heute spielt

00:06:15.000 --> 00:06:16.800
das vielleicht auch immer noch eine Rolle, vielleicht eher

00:06:16.800 --> 00:06:18.080
so bei Clients, ich glaube Server,

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

00:06:21.020 --> 00:06:21.980
ich habe auch lange nicht mehr drauf geguckt.

00:06:23.000 --> 00:06:24.760
Ja, aber das ist halt so eine, das ist eigentlich genau

00:06:24.760 --> 00:06:26.640
so das, was sich Leute vielleicht

00:06:26.640 --> 00:06:27.800
vorstellen, wenn man

00:06:27.800 --> 00:06:30.760
davon redet,

00:06:30.840 --> 00:06:32.720
dass jetzt irgendwie irgendwelche

00:06:32.720 --> 00:06:33.880
Server gehackt werden oder so.

00:06:34.100 --> 00:06:36.620
Man gibt irgendwas ein oder führt ein Programm

00:06:36.620 --> 00:06:38.440
aus und dann hat man eine Shell auf einem anderen System,

00:06:38.640 --> 00:06:40.560
wo man einfach Code ausführen kann oder beliebige

00:06:40.560 --> 00:06:42.740
Kommandos. Da kann man

00:06:42.740 --> 00:06:44.780
auch tatsächlich sozusagen diese Perspektiven

00:06:44.780 --> 00:06:46.800
von, man muss halt

00:06:46.800 --> 00:06:48.620
da kann man nochmal einen ganzen Schritt zurückgehen, weil

00:06:48.620 --> 00:06:50.860
im Prinzip das Thema Sicherheit

00:06:50.860 --> 00:06:52.660
kann man noch weiter aufmachen

00:06:52.660 --> 00:06:54.620
wenn ich halt

00:06:54.620 --> 00:06:56.560
Philipp hatte gesagt

00:06:56.560 --> 00:06:58.580
Anwenderinput, das ist so ein

00:06:58.580 --> 00:07:00.600
das muss oder kann man noch weiter

00:07:00.600 --> 00:07:02.500
abstrahieren, weil im Prinzip

00:07:02.500 --> 00:07:04.240
sind Viren halt auch nichts anderes als

00:07:04.240 --> 00:07:05.680
Anwenderinput

00:07:05.680 --> 00:07:08.740
das ganze Thema von

00:07:08.740 --> 00:07:10.440
Security lässt sich halt darauf

00:07:10.440 --> 00:07:12.500
zurückführen, warum muss ich überhaupt darüber reden, warum

00:07:12.500 --> 00:07:14.600
macht ein Programm überhaupt was, was man nicht will

00:07:14.600 --> 00:07:16.940
lässt sich halt

00:07:16.940 --> 00:07:19.200
stark darauf zurückführen, dass

00:07:19.200 --> 00:07:21.200
wir halt eine sogenannte Verneumann-Architektur

00:07:21.200 --> 00:07:23.020
haben. Ja, das geht halt zurück

00:07:23.020 --> 00:07:25.000
auf die, was weiß ich jetzt, gar nicht mehr.

00:07:25.640 --> 00:07:27.220
Mir wurde immer vorher geworfen, Opa redet

00:07:27.220 --> 00:07:28.720
vom Krieg, aber da war ich nicht dabei.

00:07:30.120 --> 00:07:31.220
60er, 70er,

00:07:31.360 --> 00:07:33.120
irgendwo da, noch älter, 40er

00:07:33.120 --> 00:07:35.280
Verneumann-Architektur, noch älter.

00:07:35.420 --> 00:07:37.180
Das war vor dem

00:07:37.180 --> 00:07:38.160
Zweiten Weltkrieg wahrscheinlich sogar.

00:07:40.540 --> 00:07:41.140
Irgendwo da.

00:07:41.140 --> 00:07:43.020
Also als es so richtig losging, gerade erst

00:07:43.020 --> 00:07:47.000
mit den ganzen allgemeinen Rechenmaschinen.

00:07:47.760 --> 00:07:50.640
Und die von Neumann-Architektur hat halt ein wichtiges Konzept

00:07:50.640 --> 00:07:53.360
und das ist halt, dass der Programmspeicher

00:07:53.360 --> 00:07:55.820
und der Datenspeicher eins sind.

00:07:57.060 --> 00:08:00.640
Es gab früher Rechner-Architekturen,

00:08:01.440 --> 00:08:03.980
da waren Daten von der Eingabe

00:08:03.980 --> 00:08:06.480
und die Daten, die den Prozessor gesteuert haben,

00:08:06.560 --> 00:08:08.580
also das Programm, komplett getrennt.

00:08:09.560 --> 00:08:11.200
Macht halt das große Problem,

00:08:11.520 --> 00:08:15.240
dass du nicht einfach irgendwie Programme als Daten runterladen und ausführen kannst.

00:08:15.360 --> 00:08:17.760
Also der Effekt, den wir dadurch haben von der Neumann-Architektur ist ja,

00:08:17.800 --> 00:08:21.700
ich kann ins Internet gehen, kann mir Daten runterladen und sie dann als Programm ausführen.

00:08:21.780 --> 00:08:25.740
Das Problem ist aber, der Vorteil ist gleichzeitig der Nachteil.

00:08:25.740 --> 00:08:31.180
Das heißt, auch Daten, die vielleicht gar nicht als Programm gedacht waren, werden als Programm ausgeführt.

00:08:31.260 --> 00:08:36.200
Und das ist sozusagen die ganze Krux daran, dass die CPU schon nicht unterscheiden kann von,

00:08:36.740 --> 00:08:40.900
sind die Bytes bei mir gerade gedacht für, ich soll mit ihnen rechnen

00:08:40.900 --> 00:08:44.300
oder ich soll damit meinen Instruction-Pointer befüttern.

00:08:44.860 --> 00:08:46.680
Und das kannst du halt, da gibt es ein,

00:08:47.220 --> 00:08:49.500
dieses Grundproblem wird never ever jemals weggehen.

00:08:49.760 --> 00:08:50.880
Das geht nie weg.

00:08:51.920 --> 00:08:56.360
Na gut, also, moderne CPUs haben ja durchaus einige Verteidigungen dagegen.

00:08:56.640 --> 00:08:59.500
Also, moderne CPUs haben einen Marker, wo dann drin steht,

00:08:59.620 --> 00:09:01.900
okay, diese Speicherseite ist ausführbar oder nicht.

00:09:02.540 --> 00:09:06.340
Und genau das geht ja dann schon in Richtung der konkurrierenden Harvard-Architektur ein bisschen,

00:09:06.340 --> 00:09:09.520
dass man sagt, okay, das sind die Daten, das sind die Instruktionen.

00:09:10.560 --> 00:09:11.920
Aber natürlich gibt es immer noch Tricks.

00:09:12.080 --> 00:09:14.400
Also selbst bei den Buffer-Overflows

00:09:14.400 --> 00:09:15.980
gibt es halt sehr, sehr viele Möglichkeiten,

00:09:16.980 --> 00:09:21.600
wie man genau dann doch irgendwie noch ein Programm konstruieren kann,

00:09:21.680 --> 00:09:22.920
das dann eigentlich nur aus Daten besteht.

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

00:09:25.600 --> 00:09:27.780
aber die auf komischen Stellen liegen

00:09:27.780 --> 00:09:30.020
und dann trotzdem den Programmfluss irgendwie beeinflussen.

00:09:30.220 --> 00:09:33.220
Das ist spannend, weil ich wollte eigentlich zu dieser Frage mit den,

00:09:33.280 --> 00:09:34.820
was machen denn die CPUs dann da falsch,

00:09:35.360 --> 00:09:37.380
ganz zum Schluss kommen, ihr habt ja jetzt damit den Einstieg gefunden,

00:09:37.480 --> 00:09:41.160
Das ist die unterste Ebene, auf der wir jetzt anfangen.

00:09:41.240 --> 00:09:42.980
Ich finde das aber sehr spannend, weil was du sagtest,

00:09:43.320 --> 00:09:44.700
dass diese unterschiedlichen Architekturen,

00:09:44.820 --> 00:09:47.600
also ich glaube, von Neumann nennt man auch irgendwie Princeton-Architektur.

00:09:47.900 --> 00:09:49.600
Und ich glaube, es war irgendwie, ich habe gerade nachgeguckt,

00:09:49.820 --> 00:09:51.560
1945, als sie rausgekommen ist.

00:09:51.700 --> 00:09:54.440
Und diese Harvard-Architektur, die daneben liegt,

00:09:54.440 --> 00:09:57.060
die macht halt diese Getrennung von Daten und Programmspeicher.

00:09:57.560 --> 00:09:59.780
Und du sagst jetzt, es gibt auf dem CPU,

00:10:00.260 --> 00:10:03.260
also der CPU benutzt für alle Menschen, die vielleicht nicht so drin sind,

00:10:04.100 --> 00:10:06.380
Opcodes, also Operation Codes.

00:10:06.480 --> 00:10:08.200
Das heißt, die sagen, was für eine Rechenoperation

00:10:08.200 --> 00:10:10.340
der machen soll, der Kern.

00:10:10.680 --> 00:10:12.280
Und dann macht der genau mit den Daten,

00:10:12.320 --> 00:10:13.380
die ihm dazu geschickt werden,

00:10:14.120 --> 00:10:15.840
in den einzelnen, was sind das, Decks?

00:10:15.980 --> 00:10:17.540
Nein, Registern irgendwie,

00:10:18.080 --> 00:10:18.960
macht der dann diese Operation.

00:10:20.400 --> 00:10:22.440
Und da kann was schief gehen.

00:10:23.660 --> 00:10:24.180
Philipp, vielleicht kannst du das

00:10:24.180 --> 00:10:25.700
noch ein bisschen erklären,

00:10:25.800 --> 00:10:26.980
weil das klingt ja sehr spannend.

00:10:28.760 --> 00:10:30.460
Ja, weil wenn ich einen ganz klassischen

00:10:30.460 --> 00:10:32.180
Buffer-Overflow habe, was dann halt passiert ist,

00:10:32.260 --> 00:10:33.060
wie gesagt, der Benutzer,

00:10:33.140 --> 00:10:35.520
der Benutzer in Anführungszeichen,

00:10:35.660 --> 00:10:37.000
aber in Wirklichkeit ist das der Angreifer,

00:10:37.320 --> 00:10:39.840
gibt halt irgendwie eine längere Datenfolge an

00:10:39.840 --> 00:10:41.340
und wie wir eben schon erwähnt haben,

00:10:41.500 --> 00:10:43.520
da könnten dann zum Beispiel verschiedene Instruktionen

00:10:43.520 --> 00:10:46.020
wie Knob-Codes drin vorkommen

00:10:46.020 --> 00:10:48.840
und das sieht aus wie ein normaler Text,

00:10:49.660 --> 00:10:52.520
aber das ist halt genauso designt,

00:10:52.520 --> 00:10:55.460
dass man das auch als Ob-Codes für die CPU interpretieren kann.

00:10:56.020 --> 00:10:57.580
Und genau das ist das Problem dann nachher,

00:10:57.720 --> 00:11:00.480
dass der Entwickler dachte, okay, da kommt einfach nur Text rein,

00:11:00.920 --> 00:11:03.660
aber in Wirklichkeit hat der Angreifer den Text so geschickt konstruiert,

00:11:03.760 --> 00:11:05.200
dass er ein gültiges Programm ist.

00:11:05.660 --> 00:11:33.880
Und es ist sozusagen, wir können für die CPU, weil das konkret zu machen ist häufig sehr schwer so im Luftlernraum, aber weswegen ich schnell zur Neumann-Architektur gegangen bin, ist, das Problem ist ein ganz grundsätzliches Architekturproblem und die Features, die wir jetzt da oben drüberlegen, wie zum Beispiel non-executable pages und so ein Kram oder was dann halt auf anderen Ebenen kommt, Address Randomization und so ein Zeug.

00:11:35.120 --> 00:11:51.600
Das sind alles bloß kleine Trostpflaster und man macht es den Angreifern schwerer und teilweise auch um Größenordnungen schwerer, dagegen anzukommen, aber das Restrisiko kann in der Architektur halt nie weggehen, sie wird nie weggehen.

00:11:51.600 --> 00:12:03.600
Und die Effekte, die wir aber sehen, lassen sich auf anderen Ebenen genauso wieder erklären und ein Buffer-Overflow lässt sich gut vergleichen und das ist für viele Leute wieder einfacher vorstellbar, wie mit einer SQL-Injection.

00:12:04.400 --> 00:12:05.540
Das ist genau das Gleiche.

00:12:05.820 --> 00:12:08.100
Die SQL-Injection ist, gib hier bitte deinen Namen ein

00:12:08.100 --> 00:12:09.200
und dann kommt das berühmte

00:12:09.200 --> 00:12:11.760
Mein Name ist Bobby bla bla bla

00:12:11.760 --> 00:12:13.720
Semikolon Drop Tables.

00:12:15.020 --> 00:12:16.280
Und auch da ist es so,

00:12:16.460 --> 00:12:17.860
das Programm hat gedacht,

00:12:18.240 --> 00:12:19.200
ich habe eine Eingabe

00:12:19.200 --> 00:12:20.980
und die Datenbank

00:12:20.980 --> 00:12:23.740
haut dann aber einmal volle Kanne daneben

00:12:23.740 --> 00:12:25.780
und sagt, na das ist doch jetzt die nächste Query hier.

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

00:12:28.760 --> 00:12:30.240
Der Name ist Text

00:12:30.240 --> 00:12:32.000
und das Programmierstatement

00:12:32.000 --> 00:12:33.980
für die SQL-Datenbank ist auch nur

00:12:33.980 --> 00:12:35.860
Text und wird dann aber eben

00:12:35.860 --> 00:12:37.940
als Programm interpretiert. Und wenn

00:12:37.940 --> 00:12:39.840
ich das eben nicht richtig

00:12:39.840 --> 00:12:41.140
escape an der Stelle,

00:12:41.740 --> 00:12:44.020
dann finden solche Modusübergänge statt,

00:12:44.100 --> 00:12:45.960
wo etwas, was eigentlich als Eingabe zu verarbeiten

00:12:45.960 --> 00:12:47.980
gewesen wäre. Und der Trick ist ja eben der

00:12:47.980 --> 00:12:49.520
von Neumann Architektur,

00:12:50.140 --> 00:12:50.720
die SQL,

00:12:51.940 --> 00:12:53.920
das SQL-Statement,

00:12:54.000 --> 00:12:55.760
was ich an den Server drücke, ist ja aus

00:12:55.760 --> 00:12:57.840
Server-Perspektive erstmal Daten,

00:12:58.360 --> 00:12:59.860
die als Programm zu interpretieren

00:12:59.860 --> 00:13:01.860
sind. Und wenn da drin halt Mist stattfindet,

00:13:01.980 --> 00:13:03.380
dann geht da alles quer durcheinander.

00:13:03.980 --> 00:13:07.640
Und das ist im Buffer-Overflow im Prinzip nichts anderes.

00:13:08.020 --> 00:13:13.000
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.780 --> 00:13:14.120
Ja, genau.

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

00:13:18.460 --> 00:13:25.580
Und auch Python schützt einen vor sowas im Prinzip erstmal nur im Sinne von, ja, Python selber gibt sich extrem viel Mühe, selber keinen Mist zu machen.

00:13:26.100 --> 00:13:32.080
Wenn du aber, und ich habe mit sowas halt selber auch, also ich sage immer, ich fasse C nur dann an, wenn die anderen es verrissen haben.

00:13:32.620 --> 00:13:34.180
Ich schreibe nie C-Code neu.

00:13:34.520 --> 00:13:35.840
Ich habe den C-Code nur in der Hand,

00:13:35.900 --> 00:13:38.060
wenn die anderen es völlig kaputt gemacht haben

00:13:38.060 --> 00:13:39.900
und ich gerade so noch weiß, wie ich es wieder ganz mache.

00:13:41.020 --> 00:13:44.580
Der Psycho-PG ist zum Beispiel halt im Datenbankumfeld.

00:13:45.900 --> 00:13:48.860
Da merkt man so, dass die Leute halt eigentlich keine C-Programmierer sind,

00:13:48.920 --> 00:13:49.820
wenn man den Code anguckt.

00:13:50.400 --> 00:13:52.440
Und es hat lange gehalten.

00:13:53.120 --> 00:13:54.540
Philipp macht genau das richtige Gesicht.

00:13:54.540 --> 00:13:55.920
Das können jetzt die Podcast-Hörer nicht hören.

00:13:56.200 --> 00:14:00.240
Aber wir haben so einen Corona-tauglichen Video-Back-Channel.

00:14:01.020 --> 00:14:07.460
Und da ist es halt zum Beispiel so, nicht jeder Buffer-Overflow ist gleich halt als Security-Problem ausnutzbar.

00:14:07.460 --> 00:14:13.360
Bevor ich halt sozusagen selber Code ausführen kann, kommen noch andere Fehlerklassen oder Effekte vorher.

00:14:14.040 --> 00:14:18.480
Typischerweise ist das dann erstmal ein Denial of Service, also zum Beispiel, dass halt das Programm crasht.

00:14:19.260 --> 00:14:26.720
Das ist erstmal noch nicht so dramatisch, das ist natürlich auch aus dem Thema Availability als eine der vier Sicherheitsperspektiven.

00:14:26.820 --> 00:14:29.280
Nur die Recovery ist halt einfacher typischerweise.

00:14:29.420 --> 00:14:34.560
Bei dem Crash starte ich im schlimmsten Fall, starte ich normalerweise die Anwendung einfach neu, dann geht es weiter.

00:14:36.760 --> 00:14:42.640
Und beim Psycho war es zum Beispiel so, dass es im Postgres gibt Encoding-Namen.

00:14:43.640 --> 00:14:48.900
Und die meisten Encoding-Namen, die von den Leuten verwendet werden, haben ein Minuszeichen drin.

00:14:50.020 --> 00:14:52.220
ISO 88591 und so ein Kram.

00:14:53.140 --> 00:15:05.140
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.140 --> 00:15:19.980
Und das ist im Postgres auch okay, der hat die ganzen Encoding-Namen auch immer noch mit ohne Minus rumliegen und ein Kunde von uns kam aber dann damals auf die Idee, es gibt in Postgres einen Alias für UTF-8, der heißt Unicode.

00:15:22.020 --> 00:15:28.160
So, und dann hat der Psycho halt gesagt, naja, jetzt kommt hier ein Encoding-Name, also streiche ich das Minus raus,

00:15:29.780 --> 00:15:37.640
allozie einen neuen Buffer, der genau ein Byte kürzer ist und schreibt dann Unicode ohne Minus in einen statt, was haben es,

00:15:37.720 --> 00:15:42.420
U-N-I-C-O-D-E, in einen sechs Byte langen Buffer statt in einen sieben Byte langen Buffer.

00:15:43.000 --> 00:15:48.520
Und weil sie aber nicht einfach nur malloc benutzt haben, weil ganz kleine Objekte zu allociieren im Speicher halt ineffizient sein kann,

00:15:48.520 --> 00:15:50.760
hat Python einen sogenannten Small Object Allocator.

00:15:51.680 --> 00:16:19.040
Damit kann ich eine Page, die ist typischerweise ein K oder sowas, je nachdem, System kann ja auch ein Megabyte oder größer sein, aber gehen wir mal von einem K aus oder 4K, dann packt Python halt solche 6-Byte-Objekte alle zusammen in eine Page und dann brauche ich halt statt irgendwie, wenn wir kurz rechnen, 1066 sind 20, nee, 200, 200, dann brauche ich halt statt 200 Pages, also statt 200K nur 1K.

00:16:19.860 --> 00:16:47.560
Die werden eng an eng hintereinander gepackt und was dann passiert ist, ist, dass der Server, der das hatte, so alle Woche mal gecrashed ist 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, allmöglichen Leuten und irgendwann haben wir festgestellt, der schreibt dann halt manchmal genau auf den letzten Eintrag in dieser Page dieses eine Byte zu viel

00:16:48.200 --> 00:16:52.140
Und das eine bei zu viel in einer sogenannten Arena im Small Object Allocator

00:16:52.140 --> 00:16:54.480
ist der Pointer auf die nächste Arena.

00:16:56.020 --> 00:16:57.880
Und der landet dann halt im Nirvana.

00:16:58.080 --> 00:17:02.580
Und dann gibt es halt ein SegFault und dann sagt das Linux halt, so geht es hier nicht.

00:17:03.860 --> 00:17:07.200
Und das ist ein typisches Beispiel für, da hat jemand dann einen zu kleinen Buffer alloziiert.

00:17:07.300 --> 00:17:08.380
Das ist dann ein Buffer-Overflow.

00:17:08.480 --> 00:17:12.860
Er schreibt mehr Daten rein, als da reingehören, weil er sich einfach bloß verrechnet hat.

00:17:13.480 --> 00:17:16.220
Und der Effekt muss noch nicht sein, dass jemand Code ausführen kann.

00:17:16.220 --> 00:17:26.480
Aber der Effekt ist halt typischerweise, dass das Programm anfängt Müll zu machen und dann haben wir, Philipp hat da ja auch genickt, schon mal die Availability, die Verfügbarkeit von der Anwendung reduziert und das ist ein Sicherheitsproblem tatsächlich auch.

00:17:27.340 --> 00:17:41.900
Genau, es könnte ja auch dann sein, dass das nachher auf einem Server irgendwo läuft, wo dein Postgres läuft und das kann vielleicht auch jemand, den Server möchtest du für viele Kunden bereitstellen und dann ist es auch richtig kritisch, wobei hoffentlich niemand dein Encoding im Server steuern kann, das wäre wahrscheinlich eine andere Sicherheitslücke.

00:17:42.180 --> 00:18:00.800
Ja, aber also Denial of Service ist halt, das ist böser, als die meisten Leute so zunächst vermuten würden. Ich meine, wir hatten ja jetzt auch letztens irgendwann in Düsseldorf an der Uniklinik ja auch so einen eher gemeinen Fall. Irgendwie so diese Ransomware-Geschichten, die es da gibt. Ich weiß nicht, das war irgendeine Remote-Verwaltungssoftware. Ich weiß nicht, den Namen wieder vergessen.

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

00:18:03.280 --> 00:18:05.300
Ja, irgendeine uralte Version davon und dann

00:18:05.300 --> 00:18:07.120
ist irgendjemand hingegangen und hat denen ihre Daten

00:18:07.120 --> 00:18:08.580
verschlüsselt oder so und hat sie erpresst.

00:18:09.240 --> 00:18:11.340
Und da ist, glaube ich, dann tatsächlich auch jemand bei gestorben oder so.

00:18:11.460 --> 00:18:13.020
Das war irgendwie sehr unschön.

00:18:14.480 --> 00:18:14.580
Ja.

00:18:15.540 --> 00:18:16.960
Das ist dann auch der Teil,

00:18:17.400 --> 00:18:19.260
den grenzt man in der Security manchmal ab.

00:18:19.340 --> 00:18:20.420
Im Englischen ist es halt... Safety.

00:18:21.080 --> 00:18:22.400
Ja, das ist im Deutschen

00:18:22.400 --> 00:18:24.380
haben wir das sozusagen nicht getrennt.

00:18:24.480 --> 00:18:26.540
Ich finde das eigentlich so ein schönes

00:18:26.540 --> 00:18:27.460
Beispiel, dass

00:18:27.460 --> 00:18:30.520
Konzepte mit

00:18:30.520 --> 00:18:32.540
extra Begriffen in anderen Sprachen einem nochmal

00:18:32.540 --> 00:18:34.460
einen neuen Blick liefern, dass

00:18:34.460 --> 00:18:36.700
Sicherheit im Englischen halt mit Security und mit Safety

00:18:36.700 --> 00:18:38.460
übersetzt werden kann und Safety

00:18:38.460 --> 00:18:40.340
ist halt die auf Menschenleben

00:18:40.340 --> 00:18:42.360
und körperliche Unversehrtheit bezogene

00:18:42.360 --> 00:18:44.460
Perspektive von Sicherheit

00:18:44.460 --> 00:18:46.440
und Security ist halt die Frage, ob das

00:18:46.440 --> 00:18:48.540
Fahrrad noch da ist. Aber kannst

00:18:48.540 --> 00:18:50.620
du das denn in der modernen Gesellschaft wirklich auseinanderhalten?

00:18:51.360 --> 00:18:52.580
Ja, das ist halt sozusagen genau

00:18:52.580 --> 00:18:53.640
das Thema, dass man

00:18:53.640 --> 00:18:56.520
und damit machen wir jetzt einen schönen

00:18:56.520 --> 00:18:58.280
nächsten Bogen, dass Security extrem

00:18:58.280 --> 00:18:59.320
kontextspezifisch ist.

00:19:00.520 --> 00:19:19.420
Also ich stelle mir gerade die Gesichtsbemalung vor, die dazu führt, dass die Kamera den Algorithmus verändert und ein anderes Gesicht immer in die Daten erkennen lässt und dann kann ich mich tarnen mit einer gewissen Schminke und als jemand anderes ausgeben. Weil der Algorithmus dadurch denkt, ich bin jemand anderes, weil ich einen anderen Gesichtshash bekomme oder so.

00:19:20.380 --> 00:19:37.720
Das ist der Schwamm in dem ganzen Machine Learning Umfeld, dass du diese adversarial Models hast, dass du sozusagen auf der einen Seite ein Model haben kannst, was Dinge erkennt und jemand anderes weiß aber, wie er auf Basis eines Models Outputs generiert, die dieses Model dann wieder aus dem Takt bringen.

00:19:38.660 --> 00:19:41.880
Ja, nur für seinen Social Score oder sowas kann man den dann hochhalten, obwohl man andere Sachen tun kann.

00:19:44.880 --> 00:20:04.540
Die Ecke von Philipp fand ich jetzt nochmal wichtig und spannend, dass halt dieses Thema, ah, hier passiert ja nichts Schlimmes. Das Interessante ist eben, durch dieses Architekturproblem trifft es halt alle und jeden. Also jedes Stückchen Code, was du schreibst und mit dem großen Problem Dual Use, du weißt halt nie, wofür wird Code halt mal eingesetzt werden.

00:20:05.040 --> 00:20:25.280
Den schreibt man jetzt und der ist da und ganz ehrlich, Leute, die Code finden, werden ihn benutzen. Er wird irgendwo benutzt werden und er wird für Dinge benutzt werden, die man sich nicht vorgestellt hat. Wobei ich da auch immer eine Lanze dafür breche, zu sagen, naja, der, der den Code in den Kontext einführt, hat die Verantwortung, sicherzustellen, dass er da was Sinnvolles tut.

00:20:26.920 --> 00:20:30.520
Dann mach mal ein Projekt mit NPM-Paketen oder sowas.

00:20:30.520 --> 00:20:33.520
Genau, ja, aber das ist deren Verantwortung.

00:20:34.420 --> 00:20:36.640
Es ist nicht die Verantwortung von jemandem,

00:20:36.780 --> 00:20:40.500
es gibt im Open-Source-Umfeld, kann man ja auch viel da nochmal drüber reden,

00:20:40.620 --> 00:20:43.660
über die Motivation von Leuten, die halt so Open-Source-Packages maintainen,

00:20:44.000 --> 00:20:45.560
die dann ein riesen Schwergewicht kriegen.

00:20:45.880 --> 00:20:48.640
Ich finde, die Leute haben keine moralische Verpflichtung,

00:20:48.700 --> 00:20:51.440
anderen gegenüber aus ihrem Freizeitprojekt, wo sie sagen,

00:20:51.520 --> 00:20:55.680
da steckt einfach nur meine Lust und meine persönliche Motivation drin,

00:20:55.920 --> 00:20:58.060
anderen Garantien auszusprechen, dass

00:20:58.060 --> 00:20:59.940
sie damit jetzt einen Space Shuttle betreiben

00:20:59.940 --> 00:21:00.140
können.

00:21:01.300 --> 00:21:03.760
Das darf man so nicht umdrehen

00:21:03.760 --> 00:21:06.200
und nichtsdestotrotz

00:21:06.200 --> 00:21:07.660
ist es natürlich

00:21:07.660 --> 00:21:08.860
ein

00:21:08.860 --> 00:21:12.160
Das ist alles ein etwas zusammengeschimmertes

00:21:12.160 --> 00:21:13.840
kleines Raumschiff, was immer droht auseinander

00:21:13.840 --> 00:21:15.860
zu fallen, was auf der einen Seite mit Kohle und auf der

00:21:15.860 --> 00:21:17.620
anderen Seite mit einem Handpedal betrieben wird

00:21:17.620 --> 00:21:19.580
und keiner so genau weiß, wo denn jetzt

00:21:19.580 --> 00:21:20.500
das nächste Leck entsteht.

00:21:20.800 --> 00:21:23.600
Ja, ich hätte auch

00:21:23.600 --> 00:21:25.200
große Bedenken, irgendwie so medizinische

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

00:21:27.000 --> 00:21:29.120
irgendwelche Software, die Flugzeuge

00:21:29.120 --> 00:21:30.820
steuert oder so, da hätte ich irgendwie

00:21:30.820 --> 00:21:32.440
groß, würde ich wahrscheinlich eher lieber nicht.

00:21:32.640 --> 00:21:35.240
Wahrscheinlich schon bei Bank-Transaktionsgeschichten

00:21:35.240 --> 00:21:36.940
schon bedenken, aber...

00:21:36.940 --> 00:21:39.020
Allein das zeichnet dich aber eigentlich schon aus

00:21:39.020 --> 00:21:41.060
als jemand, der qualifiziert sein könnte,

00:21:41.140 --> 00:21:41.640
das zu tun.

00:21:42.920 --> 00:21:44.920
Zu viele

00:21:44.920 --> 00:21:47.000
Leute gehen nämlich ohne

00:21:47.000 --> 00:21:48.820
diese Vorsicht heran.

00:21:49.500 --> 00:21:50.880
Also, man hat mal

00:21:50.880 --> 00:21:53.380
früher gesagt, die Deutschen bauen die besten Nationenkraftwerke,

00:21:53.660 --> 00:21:55.160
weil die so scheiß viel Angst davor haben.

00:21:55.200 --> 00:21:57.540
und halt entsprechend in die

00:21:57.540 --> 00:21:58.460
Sicherheit investieren.

00:21:59.400 --> 00:22:01.160
Deswegen ist Siemens mit der

00:22:01.160 --> 00:22:03.020
Atomkraftwerke so ein Exportschlager.

00:22:04.180 --> 00:22:05.560
Andere haben halt weniger Angst

00:22:05.560 --> 00:22:07.500
davor und machen dann halt

00:22:07.500 --> 00:22:08.660
auch weniger Sicherheit.

00:22:10.160 --> 00:22:11.300
Das ist so ein bisschen ein

00:22:11.300 --> 00:22:13.540
wer sich halt auf dem Fahrrad sicher fühlt

00:22:13.540 --> 00:22:14.520
und keinen Helm aufsetzt,

00:22:14.900 --> 00:22:17.500
wer sich unsicher fühlt und einen Helm aufsetzt, ist am

00:22:17.500 --> 00:22:19.460
Ende bei einer echten Kollision halt

00:22:19.460 --> 00:22:20.040
feiner raus.

00:22:21.700 --> 00:22:24.920
Ja, aber ich meine, das ist einfach

00:22:24.920 --> 00:22:37.440
Ich glaube, also das, was mich da so unsicher fühlen lässt, ist halt einfach, es ist schwer überhaupt sicherzustellen, dass da nichts passieren kann. Es ist einfach, es kann so viel schief gehen.

00:22:37.440 --> 00:22:56.320
Es geht auch nicht. Das ist dann der schöne Übergang zu dem Thema Security als Prozess halt. 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.340 --> 00:23:14.780
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. Also ADA zum Beispiel, dieses ganze Umfeld. Und da finde ich es auch spannend, dass die tatsächlich dort Engineering haben.

00:23:14.920 --> 00:23:28.020
Und ich hatte ADA nur mal im Studium und muss sagen, also es ist halt, was die Garantien angeht, wirklich straff. Es ist auch ziemlich schnell. Ich habe aber nie irgendwas Sinnvolles damit programmieren können.

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

00:23:31.020 --> 00:23:51.280
ADA ist eine Sprache, die ist extrem formal definiert 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 Kampfhubschrauber und so ein Kram zu programmieren.

00:23:51.640 --> 00:24:09.920
Und die ist halt, die zeichnet sich dadurch aus, dass sie ein sehr umfassendes Typsystem hat. Das heißt, da wo man in anderen Sprachen halt sagt, ich hatte hier gerne einen Integer, kannst du dem Ding halt sagen, ja, ich will hier einen Integer haben, der darf aber nur von 7 bis 9, 11, 13 und 12 sein.

00:24:09.920 --> 00:24:20.940
Und der Compiler kann dir vorher über alle Operationen deines Programms schon sagen, ob die Verkettung der Operationen in Summe noch zu zulässigen Ergebnissen führt.

00:24:21.640 --> 00:24:34.660
Oder ob du irgendwo deine Wertebereiche sprengen würdest. Und gleichzeitig, und das ist halt wirklich cool, die können halt Echtzeit und sie sind auch auf anderen Systemen sehr, sehr schnell in der Laufzeit nachher. Und das ist halt, das ist was wert.

00:24:35.620 --> 00:24:47.260
Gleichzeitig ist es aber so, immer wenn es um I.O. geht, nämlich da, wo halt dieses Thema, da kommen Daten von draußen rein oder müssen wieder raus, da gucken sie so ein bisschen in die Luft und sagen, naja, das macht jemand anders.

00:24:48.740 --> 00:25:15.760
Das ist dann halt immer, also da herzugehen und zu sagen, ich hätte jetzt hier gerne mal noch schnell eine HTTP-Library und ich würde hier nochmal eine SSL und nochmal da drüben ein Repository von GitHub, sowas ist bei aller halt eher nicht so an der Tagesordnung und du brauchst halt auch eine entsprechende Engineering-Menge und Genauigkeit, all die Kombinationen, mit denen du sozusagen konfrontiert wirst, dir so genau anzugucken, das lohnt sich halt auch eigentlich nur, wenn da wirklich Menschenleben dranhängen.

00:25:15.760 --> 00:25:43.440
Wenn du sagst, es ist okay, wenn dieses kleine Programm jetzt zwei Millionen Euro kostet, wo jemand anders sagt, komm, da hack ich dir jetzt das Shell-Skript runter und dann ist es gut. Da muss man immer aufpassen, dass es halt kontextbezogen ist. Also die kommen halt aus dieser Ecke von einer mathematisch perfekten, idealisierten Variante von so, wir schreiben jetzt das Programm und das ist dann sicher. Und wenn du in ausreichend komplexe Systeme kommst, musst du aber eigentlich eher einen prozessorientierten Ansatz machen.

00:25:44.340 --> 00:26:03.580
Genau, da würde ich nämlich jetzt auch gerade noch kurz einhaken und sagen, naja, das Blöde ist, dass einem halt auch diese Geschichten nicht unbedingt schützen vor wirklich fatalen Fehlern, wie zum Beispiel, ich weiß nicht, ob das der Jungfernflug von irgendeiner neuen Ariane-Version war, Ariane 5, Ariadne oder Ariane, Ariane, glaube ich, 5.

00:26:05.580 --> 00:26:08.360
Ich glaube, auch die Steuerungssoftware dafür ist auch in ALA geschrieben oder so.

00:26:08.480 --> 00:26:14.180
Und die ist sogar bewiesen, dass die tatsächlich das tut, was in der Spezifikation steht.

00:26:14.980 --> 00:26:19.680
Nur das Problem ist halt, sie haben irgendwie die falsche Spezifikation verwendet.

00:26:20.120 --> 00:26:20.600
Das war Wind.

00:26:21.000 --> 00:26:24.460
Nee, die Spezifikation war halt für die alten Motoren irgendwie.

00:26:24.920 --> 00:26:31.160
Und dann waren die Sensordaten für den Computer halt irgendwie so, nee, das kann nicht sein.

00:26:31.620 --> 00:26:35.400
Aber es ist ja bewiesen, das ist richtig, daher muss ich defekt sein.

00:26:35.480 --> 00:26:37.680
dann hat sich der erste Steuerungskomputer ausgeschaltet

00:26:37.680 --> 00:26:39.420
und dann hat sich der zweite auch noch ausgeschaltet,

00:26:39.500 --> 00:26:40.800
der den übernommen hat und dann war halt Schluss.

00:26:41.260 --> 00:26:42.760
Und dann ist die Rakete halt abgestürzt.

00:26:43.700 --> 00:26:46.440
Und ja, das ist ja auch sowas.

00:26:46.540 --> 00:26:48.220
Ich meine, klar, man kann halt beweisen manchmal,

00:26:48.380 --> 00:26:49.800
dass Programme das tun, was sie tun sollen,

00:26:49.860 --> 00:26:52.020
aber dann muss man ja immer noch sicher sein können,

00:26:52.160 --> 00:26:53.920
dass die Spezifikation richtig ist.

00:26:53.920 --> 00:26:56.660
Aber irgendwie, man kommt da in so einen infiniten Regress

00:26:56.660 --> 00:26:59.100
und selbst das hilft einem nicht.

00:26:59.640 --> 00:27:02.040
Das war jetzt ein Fall, wo ein Hardware-Update dazu geführt hat,

00:27:02.080 --> 00:27:03.160
dass das Ding nicht mehr lief.

00:27:03.460 --> 00:27:05.340
Also keine Updates fahren, never touch a running system.

00:27:08.880 --> 00:27:10.880
Aber auch in Python hat man ja nicht völlig verloren.

00:27:11.080 --> 00:27:13.260
Also auch wenn Python solche strengen Garantien

00:27:13.260 --> 00:27:15.260
nicht so direkt hat, man kann natürlich Assertions

00:27:15.260 --> 00:27:17.520
einbauen und damit kann man so ein bisschen

00:27:17.520 --> 00:27:19.000
in die Richtung gehen, was Ada auch kann.

00:27:19.480 --> 00:27:21.160
Wenn ich sage, ich baue hier ein Assertion ein und sage,

00:27:21.280 --> 00:27:23.300
okay, ich erwarte, dass die Eingabe nur so lang

00:27:23.300 --> 00:27:25.340
ist oder ich erwarte, wie du eben als Beispiel gebracht

00:27:25.340 --> 00:27:27.260
hast, Christian, dass halt nur irgendwelche bestimmten

00:27:27.260 --> 00:27:29.380
Zahlen davor kommen, das kann ich auch in Python

00:27:29.380 --> 00:27:31.300
machen. Das geht, das macht den Code

00:27:31.300 --> 00:27:33.280
ein bisschen länger, da muss man sich ein paar Gedanken

00:27:33.280 --> 00:27:35.040
machen, aber das ist ja sicherlich auch

00:27:35.040 --> 00:27:37.200
ein Merkmal

00:27:37.200 --> 00:27:39.120
von qualitativen Code, dass man sich halt immer Gedanken

00:27:39.120 --> 00:27:41.320
macht, okay, was sind meine Eingangsbedingungen,

00:27:41.420 --> 00:27:42.460
was sind meine Bedingungen,

00:27:43.340 --> 00:27:45.120
die ich vielleicht rausgebe, dass ich auch schaue, okay, die Daten,

00:27:45.240 --> 00:27:46.900
die ich nochmal rausgebe, die kann ich

00:27:46.900 --> 00:27:49.100
in ein anderes Modul in meinem Programm, die kann ich auch nochmal

00:27:49.100 --> 00:27:51.260
validieren, dass da alles in Ordnung ist, dass das zum Beispiel

00:27:51.260 --> 00:27:53.040
irgendeinem Schema entspricht oder sowas.

00:27:53.700 --> 00:27:55.180
Also das ist ja auch in Python nicht unmöglich

00:27:55.180 --> 00:27:57.080
und es gibt natürlich auch in Python noch sehr viele

00:27:57.080 --> 00:27:59.000
andere Sachen im Rahmen eines sicheren

00:27:59.000 --> 00:28:01.000
Prozesses, die ich durchführen kann. Also das beginnt

00:28:01.000 --> 00:28:02.700
ja bei ganz normalem Code Review.

00:28:03.280 --> 00:28:22.520
Da guckt halt jemand anders drauf und sagt halt vielleicht, okay, der Code sieht komisch aus. Und dann kann ich halt sowohl Tests durchführen gegen den Source-Code, also dass ich mir den gesamten Source-Code nehme und ein automatisiertes Programm drüber laufen lasse, das mir halt sagt, okay, die Stelle sieht komisch aus. Hier machst du wahrscheinlich eine SQL-Injection oder ein C, ein Buffer-Overflow, das sieht irgendwie gefährlich aus.

00:28:23.180 --> 00:28:50.220
Und dann kann ich natürlich auch sogenannte Blackbox-Tests fahren, wo ich sage, okay, ich starte meine Anwendung einfach mal und dann nehme ich mal so ein Hackertool und das probiert einfach mal aus, kann ich hier komische Sachen eingeben und crashen in das Programm oder macht das Programm irgendwas komisches. Also auch in Python ist das nicht verloren. Da kann man auch sehr sichere Anwendungen schreiben, was meistens das gleiche ist wie eine gute Anwendung zu schreiben, weil die stört es halt nicht ab und die kann auch mit allen Benutzerangaben umgehen, noch nicht mal nur von Angreifern, sondern auch von Benutzern.

00:28:50.400 --> 00:29:14.440
Also ich hatte das beruflich auch so, wir dachten erst, wir hätten einen Angreifer, weil unsere Anwendung abgestürzt ist, aber hat sich herausgestellt, wir hatten ein ähnliches Problem wie beim Buffer-Overflow, wir hatten ein Datenbankfeld mit einer bestimmten Länge und die Länge war aber in Bytes und dann kamen halt User an und haben ihre kleine Tony-Figur mit ganz vielen Smileys genannt und dann passte das nachher nicht und führte zu einem Crash.

00:29:14.440 --> 00:29:17.040
und auch sowas kann man natürlich auch vorher darauf achten

00:29:17.040 --> 00:29:19.900
und entsprechend auch testen.

00:29:20.040 --> 00:29:23.660
Das ist ja noch ein anderer Bestandteil eines sicheren Prozesses,

00:29:24.140 --> 00:29:25.940
der sagen kann, ich schreibe vorher Tests

00:29:25.940 --> 00:29:28.780
und ich überlege mir entweder manuell oder sogar automatisiert,

00:29:29.140 --> 00:29:30.520
wie sehen komische Eingaben aus.

00:29:30.980 --> 00:29:34.260
Bei Nummern sind das meistens Null oder sehr kleine Zahlen

00:29:34.260 --> 00:29:35.460
oder sehr große Zahlen.

00:29:36.580 --> 00:29:38.160
Typischerweise auch Zahlen,

00:29:38.280 --> 00:29:41.020
die vielleicht über die 32 Bytes hinausgehen,

00:29:41.080 --> 00:29:42.420
was in Python jetzt nicht so ein Problem ist

00:29:42.420 --> 00:29:46.520
oder über die 64 Bits hinausgehen.

00:29:46.980 --> 00:29:48.260
Also wenn ich da eine sehr große Zahl,

00:29:48.340 --> 00:29:49.780
wenn ich 2 hoch 64 plus 1 schreibe,

00:29:49.860 --> 00:29:50.960
dann in Python gar kein Problem.

00:29:51.400 --> 00:29:53.060
Aber in vielen anderen Programmiersprachen

00:29:53.060 --> 00:29:56.180
führt das halt zu einem Absturz

00:29:56.180 --> 00:29:57.240
oder zu komischem Verhalten.

00:29:57.960 --> 00:29:59.740
Und damit kann ich auch in Python, glaube ich,

00:29:59.760 --> 00:30:02.340
sehr gut Sicherheit sichern.

00:30:02.680 --> 00:30:04.880
Also du würdest tatsächlich in solchen kritischen Fällen,

00:30:05.000 --> 00:30:05.400
wo du dir überlegst,

00:30:05.460 --> 00:30:06.800
ah, ich weiß nicht so genau, was dabei rauskommt,

00:30:06.920 --> 00:30:09.000
Assertment-Statements in den Code schreiben einfach

00:30:09.000 --> 00:30:11.400
und dann sagen Asserts should never happen oder sowas

00:30:11.400 --> 00:30:12.900
und dann... Genau, und

00:30:12.900 --> 00:30:14.800
fliegt dann. Genau, auch vielleicht

00:30:14.800 --> 00:30:16.860
auf Testen. Also bei dem Beispiel, was ich eben gebracht

00:30:16.860 --> 00:30:18.800
habe, wo die Nutzer Emojis eingeben

00:30:18.800 --> 00:30:20.580
haben oder andere komische Unicode-Zeichen,

00:30:20.900 --> 00:30:22.620
haben wir halt einen Test gemacht. Und dieser Test,

00:30:22.720 --> 00:30:25.060
also wir haben sowohl einen Unit-Test,

00:30:25.200 --> 00:30:26.860
der also ganz normal in der Anwendung

00:30:26.860 --> 00:30:28.880
läuft, wo wir halt mal ausprobieren, was passiert,

00:30:28.960 --> 00:30:30.800
wenn ich nur Emojis eingebe oder andere

00:30:30.800 --> 00:30:32.740
komische Strings. Und wir haben aber auch einen

00:30:32.740 --> 00:30:33.920
End-to-End-Test, der das

00:30:33.920 --> 00:30:36.800
gesamte System testet. Also zum Beispiel

00:30:36.800 --> 00:30:37.940
hatten wir auch mal einen Bug, der

00:30:37.940 --> 00:30:40.080
durch

00:30:40.080 --> 00:30:42.440
den Reverse-Proxy vor unserer Anwendung

00:30:42.440 --> 00:30:45.000
verursacht wurde, dass der halt Sachen falsch

00:30:45.000 --> 00:30:46.660
macht. Und sowas kann man dann halt

00:30:46.660 --> 00:30:48.860
nicht so richtig testen. Natürlich könnte man auch in

00:30:48.860 --> 00:30:50.520
Nginx sagen, ich schreibe eine Art Unit-Test

00:30:50.520 --> 00:30:52.920
für unsere Nginx-Konfiguration, aber

00:30:52.920 --> 00:30:55.080
da ist dann praktisch halt wirklich ein End-to-End-Test zu schreiben,

00:30:55.640 --> 00:30:57.000
der halt

00:30:57.000 --> 00:30:58.880
wirklich eine echte Anfrage gegen das echte System

00:30:58.880 --> 00:31:00.700
schickt oder gegen Prot, also da kann man sogar gegen sein

00:31:00.700 --> 00:31:02.920
Production-System testen, aber natürlich testet

00:31:02.920 --> 00:31:04.820
man das im Normalfall zuerst gegen Development

00:31:04.820 --> 00:31:07.080
und sendet mal komische Anfragen

00:31:07.080 --> 00:31:08.800
und schaut, okay, geht das?

00:31:08.920 --> 00:31:10.680
Kommen hier ordentlich Ergebnisse raus und

00:31:10.680 --> 00:31:12.840
meldet das System vielleicht auch

00:31:12.840 --> 00:31:15.060
hinten drum schon, dass irgendwas umgefallen ist

00:31:15.060 --> 00:31:17.100
und das kann man halt

00:31:17.100 --> 00:31:18.540
damit schon ganz gut testen.

00:31:19.700 --> 00:31:20.920
Ich finde das halt auch spannend

00:31:20.920 --> 00:31:22.120
aus der Perspektive von

00:31:22.120 --> 00:31:24.380
User lassen sich halt

00:31:24.380 --> 00:31:26.920
mehr Dinge einfallen, als man selber halt

00:31:26.920 --> 00:31:27.980
vorher konstruieren kann.

00:31:28.800 --> 00:31:30.640
Tests sind an der Stelle immer natürlich auch super,

00:31:31.500 --> 00:31:33.100
weil man, wenn man im Hinterkopf behält,

00:31:33.100 --> 00:31:34.400
dass Tests halt eben nicht

00:31:34.400 --> 00:31:36.200
dafür da sind, Beweise

00:31:36.200 --> 00:31:38.880
zu ersetzen. Also ja,

00:31:38.980 --> 00:31:44.580
Sie sind sogar eine Annäherung eines Beweises, aber sie können halt nie alle Fälle abdecken.

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

00:31:51.200 --> 00:31:55.920
Und was da halt interessanterweise zum Tragen kommt, aus einer ganz anderen Ecke von Security,

00:31:55.920 --> 00:32:02.140
ich weiß gerade nicht mehr, welcher amerikanische Militär das war, das kommt so aus dem Counterterrorism-Zeug,

00:32:02.760 --> 00:32:07.180
Das ist Only Variety Can Match Variety.

00:32:07.840 --> 00:32:14.960
Also das Problem von Terrorismus ist halt, dass Terroristen extrem variierte Inputs, also Angriffe fahren.

00:32:14.960 --> 00:32:19.840
Also da geht es ja nicht um eine reguläre Kriegsführung nach irgendwie Genfer Konvention,

00:32:20.060 --> 00:32:26.200
sondern die machen Dinge, gerade weil sie verboten sind und weil keiner damit rechnet, an Stellen, wo keiner damit rechnet.

00:32:26.900 --> 00:32:31.480
Und die Amerikaner haben halt irgendwann rausgefunden, wir können dem halt nicht mit herkömmlichen Maßnahmen,

00:32:31.640 --> 00:32:34.640
indem wir alle möglichen Fälle durchdeklinieren, entgegentreten,

00:32:34.780 --> 00:32:39.400
sondern du brauchst halt kognitive Diversität, um auf diese absurden Ideen zu kommen.

00:32:39.800 --> 00:32:42.120
Du brauchst tatsächlich Leute, die unterschiedlich ticken.

00:32:42.580 --> 00:32:46.140
Und ganz ehrlich, keiner von uns, wenn ich hier in die Runde gucke,

00:32:46.220 --> 00:32:47.900
wir haben halt vier mittelalte weiße Männer.

00:32:49.220 --> 00:32:54.800
Und die Diversität ist auf der Ebene halt auch kognitiv dadurch mit dem Bias belegt.

00:32:55.260 --> 00:33:00.660
Keiner von uns kommt auf die Idee in seinen Tests halt, Katzen-Emojis in den Input zu tragen.

00:33:00.700 --> 00:33:02.000
Das macht halt von uns keiner.

00:33:02.780 --> 00:33:05.700
Und an der Stelle ist Security als Prozess

00:33:05.700 --> 00:33:07.820
halt tatsächlich auch von einer hohen Diversität,

00:33:08.580 --> 00:33:10.860
also braucht eine hohe Diversität,

00:33:11.320 --> 00:33:14.940
immer mit dem kleinen Zusatz von kognitiver Diversität,

00:33:15.400 --> 00:33:16.740
die aber auch tatsächlich überlappt

00:33:16.740 --> 00:33:20.740
mit kultureller und persönlicher Erfahrung etc.,

00:33:21.260 --> 00:33:23.280
um halt das erzeugt zu kriegen,

00:33:23.360 --> 00:33:25.620
dass man halt auf genügend Ideen kommt,

00:33:26.080 --> 00:33:27.820
die dann mal so eine Baseline herstellt von,

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

00:33:30.700 --> 00:33:54.000
Naja, das ist immer, ich finde das aus einem prozesshaften Ansatz gesehen und das ist halt das, wo ich dann, wenn Jochen, der halt sagt, Hilfe, ich will keinen Space Shuttle Code schreiben, aber Leute, die halt besser differenzieren können zwischen, ja, wie gut oder schlecht ist es denn versus ist es jetzt perfekt sicher oder ist es nicht perfekt sicher, weil das kenne ich halt aus vielen auch so Corporate-Umgebungen, wenn man Diskussionen führt, für die ist halt Sicherheit ein An- oder Ausknopf.

00:33:54.540 --> 00:34:01.940
Entweder es ist sicher oder es ist nicht sicher, weil die müssen unter irgendeinem Produkt ihre Checkliste machen von, ja, dieses Produkt ist sicher, deswegen dürfen wir es einsetzen.

00:34:01.960 --> 00:34:03.580
Da steht halt immer auf Rot die Lampe, wenn man ehrlich ist.

00:34:04.180 --> 00:34:19.880
Ja, also ich habe halt schon Sachen gehabt, wo wir mit Institutionen aus dem Finanzumfeld, für die wir dann Sachen betreiben außerhalb der Kernrechenzentren, weil wir dann immer mit irgendwelchen jetzt so, oh, die Finanzwelt entdeckt, dass die Leute Apps wollen.

00:34:19.880 --> 00:34:48.220
Aber nein, ihr dürft, die App darf nicht mit unserem Kernbanking-System reden. Und dann sind wir da häufig so ein Layer dazwischen, wo wir sagen, okay, wir betreiben für euch diese ganzen APIs und machen da den Kram dazwischen, dann sind wir so diese Pufferzone. Und wenn ich dann aber einen Excel-File kriege mit 5000 Einträgen, wo die ganzen Security-Anforderungen laut dieses Finanzinstituts drin sind und ich dann in Zeile 2327 sage, ja, wenn ich jetzt die Cipher, die ihr da vorgebt, raus ins Internet lasse, dann ist es von heute auf morgen kaputt.

00:34:49.280 --> 00:35:00.980
Weil ihr habt das letzte Mal vor drei Jahren eure Cypher-Liste aktualisiert und für eure Rechenzentren, wo kein Internet reinkommt, mag das jetzt alles okay sein, aber wenn ich damit jetzt halt raus ins Internet gehe, dann ist es halt kaputt.

00:35:00.980 --> 00:35:18.580
Und jetzt musst du ihnen klar machen, naja, im Internet wird ständig alles angegriffen und du kannst jetzt nicht mit mir einen Vertrag schließen, wo du reinschreibst, welcher Cypher da drin stehen soll, sondern du machst mit mir bitte einen Vertrag, wo du sagst, nach bestem Wissen und Gewissen haltet ihr euch informiert und kompetent und ihr aktualisiert das, so wie es halt nötig ist.

00:35:18.580 --> 00:35:20.060
und jada, jada, jada.

00:35:21.000 --> 00:35:22.660
Aber das war dann halt auch plötzlich

00:35:22.660 --> 00:35:24.100
ein Kampf, wo die davor standen und sagten,

00:35:24.180 --> 00:35:26.500
ich muss jetzt hier das Siegel drauf machen, obwohl ich

00:35:26.500 --> 00:35:28.020
eigentlich in der Liste geschrieben habe,

00:35:28.120 --> 00:35:29.820
Verstöß gegen unsere Sicherheitspolicy.

00:35:30.640 --> 00:35:32.800
Ja, stimmt.

00:35:32.940 --> 00:35:34.720
Das ist ein großes Problem. Das ist auch so ein Problem

00:35:34.720 --> 00:35:36.560
mit so Zertifizierungen, die man ja sonst vielleicht

00:35:36.560 --> 00:35:38.460
macht, wenn man jetzt irgendwie ein Auto fährt oder

00:35:38.460 --> 00:35:40.660
keine Ahnung, wo das eigentlich herkommt,

00:35:40.760 --> 00:35:42.480
Kirmesgeräte hat, auf denen Leute

00:35:42.480 --> 00:35:44.580
rumfahren. Dann kommt der TÜV und sagt halt,

00:35:45.100 --> 00:35:46.620
okay, ist noch nicht durchgerostet, alles klar,

00:35:46.700 --> 00:35:48.740
das Siegel, das geht halt

00:35:48.740 --> 00:35:50.760
bei Software nicht so gut, weil die muss man

00:35:50.760 --> 00:35:52.800
ja ändern und eigentlich braucht man dann eine neue Zertifizierung,

00:35:52.900 --> 00:35:55.160
aber das, ja genau,

00:35:55.280 --> 00:35:56.740
das wäre, ja könnte man jetzt denken, dass das

00:35:56.740 --> 00:35:58.340
die Lösung wäre. Ich habe das schon gemacht,

00:35:58.540 --> 00:35:59.680
ich habe schon einen Software-Test.

00:36:00.740 --> 00:36:02.000
Ja, ich habe

00:36:02.000 --> 00:36:04.240
2003 oder 2004

00:36:04.240 --> 00:36:06.480
haben wir damals mit Soap eine

00:36:06.480 --> 00:36:08.140
Common Criteria Zertifizierung gemacht

00:36:08.140 --> 00:36:10.580
und das war so ein Challenge,

00:36:10.960 --> 00:36:12.680
da gab es einen Sponsor, der uns das bezahlt hat

00:36:12.680 --> 00:36:14.600
und parallel

00:36:14.600 --> 00:36:16.440
dazu hatte damals Red Hat den

00:36:16.440 --> 00:36:18.500
J-Boss, glaube ich,

00:36:18.540 --> 00:36:20.380
durch eine Common Criteria gejagt

00:36:20.380 --> 00:36:22.200
und wir hatten im Prinzip

00:36:22.200 --> 00:36:24.780
das gleiche Schutzniveau anzubieten.

00:36:25.340 --> 00:36:26.500
War irgendwie eine ERP 3 Plus

00:36:26.500 --> 00:36:27.640
oder ERP 4 oder so ein Kram.

00:36:27.780 --> 00:36:29.640
Du hast jetzt gerade irgendwie ein kryptische...

00:36:29.640 --> 00:36:32.080
Ich kann es nicht, ich kann auch nur

00:36:32.080 --> 00:36:34.260
die humoristische Variante irgendwie so,

00:36:34.540 --> 00:36:36.320
die unterste ist irgendwie, das Programm existiert

00:36:36.320 --> 00:36:38.280
irgendwie, die nächste ist dann

00:36:38.280 --> 00:36:40.080
irgendwie, ja, das Programm existiert und es gibt

00:36:40.080 --> 00:36:42.180
Dokumentation dazu, dann die nächste

00:36:42.180 --> 00:36:44.240
ist irgendwie, jemand hat mal geguckt, ob die Dokumentation

00:36:44.240 --> 00:36:45.700
zum Programm passt und dann irgendwie

00:36:45.700 --> 00:36:47.920
Die nächste ist dann irgendwie, es existiert

00:36:47.920 --> 00:36:49.460
ein formaler Beweis, dass das Programm korrekt ist.

00:36:49.800 --> 00:36:51.260
Wo dann irgendwie so ein Zwischenschritt fehlt,

00:36:51.660 --> 00:36:53.960
das ist glaube ich diese Stufe 6

00:36:53.960 --> 00:36:54.720
oder weiß ich nicht genau.

00:36:55.380 --> 00:36:57.340
Ja, ERP 6 ist die formale Verifikation, genau.

00:36:58.480 --> 00:36:59.820
Und, nee, nee, wir hatten

00:36:59.820 --> 00:37:01.760
da schon ein relativ hohes Schutzniveau und

00:37:01.760 --> 00:37:04.240
die Common Criteria als Framework,

00:37:04.380 --> 00:37:05.880
um über Security nachzudenken,

00:37:06.120 --> 00:37:07.600
inhaltlich, ist toll.

00:37:08.040 --> 00:37:09.740
Weil du kriegst halt einen Katalog

00:37:09.740 --> 00:37:11.820
von, also du hast zum einen einen Prozess,

00:37:12.260 --> 00:37:13.660
der dir sagt, okay, mach dir mal Gedanken

00:37:13.660 --> 00:37:15.620
über, wer sind denn deine Assets?

00:37:15.700 --> 00:37:38.260
Wer sind deine Angreifer? Was haben die für Motivationen? Was haben die für Ressourcen? So, und jetzt gucken wir mal, wie mappen wir das alles aufeinander von, wie sind deine Assets mit was geschützt gegenüber welchen Angriffsszenarien und die haben auch noch einen tollen Implementationskatalog, wo sie sagen, okay, also wenn du folgendes countern möchtest, könnte man zum Beispiel Logging machen.

00:37:38.360 --> 00:37:57.120
Wenn du Logging machst, dann musst du dir über die Integrität vom Log Gedanken machen, dann musst du dir über Zeitstempel Gedanken machen, dann musst du, das ist sozusagen, das ist so ein bisschen, da kannst du wie bei so einem Spinnennetz irgendwie reingreifen, erstmal was interessiert mich und dann kommen alle Sachen hinterher, von die du noch berücksichtigen musst. Das ist viel, aber es ist eigentlich erstmal auf der Ebene fachlich gar nicht schlecht gewesen.

00:37:57.120 --> 00:38:26.040
Das große Problem ist, die Common Criteria kommt aus der Produktsicherheit und die gehen halt davon aus, dass ein Produkt eben, siehe ein Karussell auf dem Jahrmarkt, das Ding wird einmal gebaut und existiert jetzt und jetzt ist das ab und jetzt läuft das 30 Jahre, wenn du aber sowas wie einen Open Source Application Server hast, wo du exakt ein Release einmal verifizieren darfst und dann kommt aber in 23 Stunden das nächste raus.

00:38:27.120 --> 00:38:29.120
Und du fängst die ganze Zertifizierung

00:38:29.120 --> 00:38:30.840
wieder von vorne an, das geht dann halt schief.

00:38:32.520 --> 00:38:33.340
Ja, also man muss

00:38:33.340 --> 00:38:34.800
ja die Zertifizierung erstmal, also

00:38:34.800 --> 00:38:37.020
es kann manchmal sehr gut sein, dass man sich

00:38:37.020 --> 00:38:39.120
über alle Sachen Gedanken macht, aber man kann

00:38:39.120 --> 00:38:41.260
ja auch ganz viele Sachen vermissen, also ich glaube

00:38:41.260 --> 00:38:43.240
der viel besser

00:38:43.240 --> 00:38:45.180
oder für viele Anwendungen besser

00:38:45.180 --> 00:38:47.180
ist es, wenn man sagt, ich mache einen Pentest

00:38:47.180 --> 00:38:49.200
und lasse ich einen Auftrag geben, bei einem

00:38:49.200 --> 00:38:51.200
Pentest geht halt jemand anders hin und sagt

00:38:51.200 --> 00:38:53.180
ich checke deine Software, also

00:38:53.180 --> 00:38:55.140
entweder checke ich die von außen oder

00:38:55.140 --> 00:39:01.080
ich schaue mir den Source Code an, ich schaue mir das mal an, was du so in Python oder auch in anderen Programmiersprachen alles programmiert hast.

00:39:01.780 --> 00:39:06.820
Und da sind dann erfahren Entwickler in der genau der Programmiersprache und die können dann halt schon,

00:39:07.100 --> 00:39:10.400
vielleicht auch mit automatischen Tools, sehr schnell kritische Stellen finden.

00:39:10.560 --> 00:39:12.640
Also damit habe ich auch gute Erfahrungen gemacht.

00:39:13.520 --> 00:39:17.220
Das ist natürlich eine ganz andere Herangehensweise, dass man sagt, okay, ich versuche nicht alles irgendwie,

00:39:17.440 --> 00:39:21.920
den ganzen Prozess, ich schreibe kein Papier, sondern ich lasse im Wesentlichen Leute anfangen, uns zu coden.

00:39:22.160 --> 00:39:24.480
Und das muss man natürlich auch regelmäßig wiederholen.

00:39:24.540 --> 00:39:26.520
Das bringt natürlich nichts, wenn man vor zehn Jahren das mal gemacht hat.

00:39:26.900 --> 00:39:28.380
Aber das ist auch sicherlich eine Methode,

00:39:28.540 --> 00:39:31.180
mit der man seine Anwendung gut absichern kann.

00:39:31.660 --> 00:39:33.600
Ja, du musst da seinen Angreiferhut aufsetzen und da draufhauen,

00:39:33.680 --> 00:39:34.620
solange du bist, auseinanderfällt er.

00:39:34.680 --> 00:39:36.840
Da brauchen wir halt gute Angreifer auch, die so ein bisschen ein paar Tricks kennen.

00:39:37.320 --> 00:39:39.560
Und ich glaube, wenn man jetzt nur so Tools drauf loslässt, dann weiß ich nicht.

00:39:40.260 --> 00:39:42.520
Genau, also wenn man nur ein Tool selber drauf loslässt,

00:39:42.600 --> 00:39:43.360
hilft es wahrscheinlich nicht.

00:39:43.440 --> 00:39:47.540
Aber wenn man halt jemanden beauftragt, der da wirklich Experte ist,

00:39:48.060 --> 00:39:50.100
ich glaube, das ist eine ganz gute Möglichkeit,

00:39:50.100 --> 00:39:53.500
um auch so einen Blick zu bekommen, wie schlimm ist denn mit unserer Anwendung?

00:39:53.580 --> 00:40:01.880
Haben wir nur eine ganz kleine Schwachstelle oder ist unsere Admin-Oberfläche ohne Benutzername und Passwort irgendwie verfügbar und man kann beliebigen Code hochladen?

00:40:02.460 --> 00:40:09.440
Und ich glaube, 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.440 --> 00:40:16.540
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.140 --> 00:40:22.700
Also ich würde an der Stelle halt eine Lanze verbrechen für das, was wir jetzt zu Corona-Zeiten kennengelernt haben als irgendwie Schweizer Käse-Modell.

00:40:23.580 --> 00:40:33.880
Aber 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, wie so ein Schweizer Käse.

00:40:34.340 --> 00:40:39.600
Aber wenn ich halt fünf Scheiben Schweizer Käse hintereinander lege, ist die Filtrationsrate dann doch relativ gut.

00:40:40.480 --> 00:40:45.500
Dass also wirklich über fünf Schichten an der gleichen Stelle überall die Löcher sind, das passiert halt normalerweise nicht.

00:40:46.060 --> 00:40:53.280
Und deswegen würde ich halt immer, also aus meiner dann längerfristigen Erfahrung, würde ich halt sagen, es kommt immer auf den Kontext drauf an.

00:40:53.420 --> 00:41:08.780
Man muss immer erstmal gucken, was sind hier eigentlich die Assets gerade und wenn ich gerade hier in meinem Heimkeller irgendwie die Temperaturdaten von meinen Hubs aufschreibe, denke ich mir so, ja, egal, dann darf es halt auch mal, wenn ich für mich entschieden habe, die dürfen auch ins Internet purzeln, dann ist schon okay.

00:41:11.060 --> 00:41:33.280
Aber tatsächlich diese Layer zu haben, auf der einen Seite Produktsicherheit tatsächlich sich anzugucken mit den, was sind hier eigentlich die technischen Maßnahmen und sowas wie eine Common Criteria im Hinterkopf zu haben, ist für mich inzwischen eher das Know-how von, das setze ich ein, während ich ein System aufbaue, um sozusagen schon vorher zu wissen, okay, wo ist denn die Checkliste, wo ich dann weiß, jetzt habe ich wenigstens nichts unnütz vergessen.

00:41:34.780 --> 00:41:53.640
Während dann halt das Thema ist halt auch jemand zum Beispiel vom Pentest, da würde ich auch sagen, einige Leute, mit denen ich mich dann austausche, sagen, nee, dann machst du halt lieber auch noch gleichzeitig sozusagen eine externe Code-Review, die sozusagen über das, was du brauchst, dann nochmal im Whitebox drüber guckst und dann kannst du nochmal von draußen draufhauen und diese ganzen Schichten ergeben dann halt.

00:41:53.640 --> 00:42:09.060
Und gleichzeitig kannst du dann an vielen Stellen ja auch, wenn man standardisierte Protokolle wie halt HTTP immer so dazwischen hat, dann gibt es da ja auch noch die Möglichkeit, immer nochmal so Schichten einzuziehen wie eine Web-Application-Firewall, die einem so bestimmte Sachen schon mal wegfängt.

00:42:09.160 --> 00:42:19.300
Also ich habe zum Beispiel ein paar Kunden, denen gucke ich über die Schulter und da weiß ich dann so, okay, bei dir knalle ich da jetzt eine Waffe davor, weil ansonsten traue ich mich nicht, das ins Netz rauszulassen.

00:42:19.400 --> 00:42:20.860
Du sagst mir, es muss raus ins Netz.

00:42:22.160 --> 00:42:24.300
Das ist das gleiche Prinzip wie ein Virenscanner.

00:42:24.520 --> 00:42:27.620
Also da habe ich irgendwie ein Muster, das ich suche.

00:42:27.900 --> 00:42:28.640
Genau, ja, ja, ja.

00:42:28.660 --> 00:42:30.680
Okay, wenn ich das Muster finde, dann mache ich irgendwas,

00:42:31.060 --> 00:42:34.280
dann unterbinde ich die Anfrage oder schmeiße das Muster raus

00:42:34.280 --> 00:42:35.000
oder mache irgendwas.

00:42:35.160 --> 00:42:35.460
Genau, genau.

00:42:35.460 --> 00:42:38.980
Das ist schon ein bisschen gefährlich,

00:42:39.100 --> 00:42:41.440
weil eine Möglichkeit ist halt schon wie bei einem Virenscanner,

00:42:42.080 --> 00:42:46.400
dass der, also die Wald- und Wiesenattacken findet der sicherlich.

00:42:46.480 --> 00:42:47.800
So was im Internet das Grundrauschen ist,

00:42:47.840 --> 00:42:48.740
das findest du auf jeden Fall.

00:42:49.160 --> 00:42:51.240
Aber wenn dann wirklich jemand deine Firma angreifen will,

00:42:51.240 --> 00:42:53.220
dann merkst du dich da vielleicht auch in falscher

00:42:53.220 --> 00:42:55.220
Sicherheit, weil man halt dann doch immer

00:42:55.220 --> 00:42:57.220
also du hast recht mit dem Schweizer

00:42:57.220 --> 00:42:58.860
Käse-Modell, das macht es vielleicht ein bisschen besser

00:42:58.860 --> 00:43:01.180
aber gleichzeitig kann ja so ein Waff auch

00:43:01.180 --> 00:43:03.100
wieder ein Angriffsmodell sein, weil der muss ja auch wieder alles

00:43:03.100 --> 00:43:05.200
interpretieren und ein Problem kann halt sein

00:43:05.200 --> 00:43:07.180
dass mein Server davor und mein Server danach

00:43:07.180 --> 00:43:09.320
sowieso schon unterschiedliche Details

00:43:09.320 --> 00:43:11.180
anders interpretieren, also bei HTTP

00:43:11.180 --> 00:43:12.980
zum Beispiel Junk Encoding oder

00:43:12.980 --> 00:43:15.420
irgendwelche komischen HTTPS-Optionen

00:43:15.420 --> 00:43:17.260
anders interpretieren und dass dann die Waff

00:43:17.260 --> 00:43:19.020
sogar noch ein neues Problem aufmacht

00:43:19.020 --> 00:43:20.740
dass sie plötzlich Sachen anders interpretiert

00:43:20.740 --> 00:43:23.240
und dann vielleicht sogar eine Schwachstelle

00:43:23.240 --> 00:43:25.140
an sich hat. Also auch die Waffe ist ja nur Code.

00:43:25.820 --> 00:43:27.200
Ne, genau. Deswegen ist es auch für uns zum Beispiel

00:43:27.200 --> 00:43:29.280
keine Maßnahme, die wir halt so Blanko überall drüber

00:43:29.280 --> 00:43:31.300
gießen, sondern das ist halt, wir haben halt

00:43:31.300 --> 00:43:32.600
dann Kunden, wo feststellen, also

00:43:32.600 --> 00:43:35.160
die Waffe ist für uns mehr oder weniger dann

00:43:35.160 --> 00:43:37.040
der erste Move. Also manchmal,

00:43:37.300 --> 00:43:39.220
wie du sagst, will irgendwer einfach in seiner

00:43:39.220 --> 00:43:41.120
Ausschreibung sehen, da muss eine Waffe davor.

00:43:41.460 --> 00:43:42.580
Pack ich da eine Waffe davor.

00:43:44.160 --> 00:43:45.320
Und wenn, das

00:43:45.320 --> 00:43:47.220
muss er ja anbieten können erstmal in dem Moment, wenn er

00:43:47.220 --> 00:43:49.080
das fragt. Und wenn der dann irgendwie nach zwei Monaten

00:43:49.080 --> 00:43:50.980
fragt mit, warum ist das hier alles so doof, dann sage ich,

00:43:51.020 --> 00:43:53.160
du wolltest eine Waffe haben, dann sagt der mir, jetzt machst du wieder aus,

00:43:53.240 --> 00:43:53.960
dann mache ich es halt wieder aus.

00:43:55.920 --> 00:43:57.240
Wo wir es häufiger als Werkzeug

00:43:57.240 --> 00:43:58.280
tatsächlich sehen, ist,

00:43:59.240 --> 00:44:01.680
dass tatsächlich diese Wald- und Wiesenscans

00:44:01.680 --> 00:44:03.160
und Angriffe gerne

00:44:03.160 --> 00:44:04.600
mal massiv für Last sorgen.

00:44:05.440 --> 00:44:06.480
Und das ist halt,

00:44:07.100 --> 00:44:08.740
wir sehen immer wieder Anwendungen,

00:44:09.240 --> 00:44:11.600
wo Leute mit SQL-Injection

00:44:11.600 --> 00:44:12.760
versuchen,

00:44:13.060 --> 00:44:14.800
quer über so eine Anwendung drüber gießen

00:44:14.800 --> 00:44:16.760
und die Anwendung dadurch in

00:44:16.760 --> 00:44:17.860
Performance-Probleme gerät.

00:44:18.900 --> 00:44:20.980
das ist halt tatsächlich, was das Filtern wird, dann damit

00:44:20.980 --> 00:44:22.740
zum Beispiel vorne weg. Also jetzt hier haben wir die ganze

00:44:22.740 --> 00:44:24.540
SQL-Kram, das hat da nichts drin zu suchen,

00:44:24.840 --> 00:44:25.680
zack, weg, raus.

00:44:27.420 --> 00:44:27.820
Ah, okay.

00:44:28.620 --> 00:44:30.920
Ja, aber genau, also ich habe

00:44:30.920 --> 00:44:32.760
auch schon mal von jemandem gehört, der so

00:44:32.760 --> 00:44:34.780
Pentests macht, dass er

00:44:34.780 --> 00:44:36.720
meinte, so ja, da war eine Bank, die hatte irgendwie

00:44:36.720 --> 00:44:38.840
ein System vor den

00:44:38.840 --> 00:44:40.920
Datenbanken und das sollte eigentlich aus

00:44:40.920 --> 00:44:42.680
dem SQL irgendwie alles rausfiltern, was

00:44:42.680 --> 00:44:44.840
und das hat dazu geführt, dass SQL-Injection wieder möglich

00:44:44.840 --> 00:44:46.180
wurde, weil es halt

00:44:46.180 --> 00:44:48.140
Dinge zu viel

00:44:48.140 --> 00:44:49.220
rausgenommen hat.

00:44:50.380 --> 00:44:51.080
Du hast

00:44:51.080 --> 00:44:53.380
ja aus

00:44:53.380 --> 00:44:56.300
Komplexitätsperspektive hast du immer das Problem

00:44:56.300 --> 00:44:57.780
der Kombinatorik.

00:44:58.240 --> 00:45:00.140
Das heißt, wenn du n Dinge hast,

00:45:00.240 --> 00:45:02.040
die miteinander reden, dann hast du halt

00:45:02.040 --> 00:45:03.600
n Quadratverbindungen mindestens.

00:45:04.420 --> 00:45:06.120
Und wenn du jetzt sagst,

00:45:06.220 --> 00:45:08.140
okay, das ist mir zu unsicher, ich packe noch eins

00:45:08.140 --> 00:45:08.500
davor,

00:45:09.560 --> 00:45:11.440
dann hast du noch mehr.

00:45:11.880 --> 00:45:14.200
Das Problem ist, glaube ich,

00:45:14.240 --> 00:45:15.680
an der Stelle auch, wer halt

00:45:15.680 --> 00:45:17.620
irgendwie diese Architektur entscheidet

00:45:17.620 --> 00:45:19.580
und so und wem man da vertrauen kann. Gerade wenn

00:45:19.580 --> 00:45:21.040
Leute jetzt keine Ahnung haben von

00:45:21.040 --> 00:45:23.520
Sicherheit oder von Computern allgemein, aber

00:45:23.520 --> 00:45:25.380
irgendwie Software als Manager irgendwie bestellen

00:45:25.380 --> 00:45:27.720
wollen. Die haben ja eine unheimliche Asymmetrie

00:45:27.720 --> 00:45:29.680
gegenüber den auch Entwicklern und so

00:45:29.680 --> 00:45:31.180
und die müssen halt vertrauen

00:45:31.180 --> 00:45:33.600
auf das, was denen da erzählt wird und die

00:45:33.600 --> 00:45:35.640
stellen sich dann meistens so ein Sammelsurium an

00:45:35.640 --> 00:45:37.600
Angebot und Nachfrage

00:45:37.600 --> 00:45:39.600
oder Best Practice oder irgendwas, was die

00:45:39.600 --> 00:45:40.920
halt an Informationen saugen können zusammen.

00:45:41.540 --> 00:45:43.380
Und das ist ja auch schon so eine Art

00:45:43.380 --> 00:45:45.140
Baukasten und das ist ja nie ganzheitlich

00:45:45.140 --> 00:45:47.220
irgendwie gedacht, was wird ja auch immer dann teuer und so,

00:45:47.600 --> 00:45:49.180
muss ja auch dann wieder sparen und

00:45:49.180 --> 00:45:50.880
wenn man das dann rauslässt, dann ist ja klar,

00:45:51.020 --> 00:45:53.280
Fehler sind ja völlig vorprogrammiert

00:45:53.280 --> 00:45:55.200
und sich da richtig vorzuschützen

00:45:55.200 --> 00:45:56.940
ist fast eine unmögliche Aufgabe

00:45:56.940 --> 00:45:59.240
und die Frage wäre vielleicht, wie man solchen

00:45:59.240 --> 00:46:01.060
Menschen auch eine Möglichkeit geben kann,

00:46:01.460 --> 00:46:02.920
Systeme in sicherer zu denken,

00:46:03.420 --> 00:46:05.300
also ihr habt jetzt gesagt, so Prozesse von Anfang an

00:46:05.300 --> 00:46:07.400
so ein bisschen, das würde ja wirklich bedeuten,

00:46:07.500 --> 00:46:08.880
dass man sich, bevor man damit anfängt,

00:46:09.260 --> 00:46:11.100
mit einem Systemarchitekten oder sowas

00:46:11.100 --> 00:46:13.080
intensiv auseinandersetzen muss,

00:46:13.180 --> 00:46:15.560
welche Tech-Stacks man benutzt oder so was

00:46:15.560 --> 00:46:17.820
oder wie der Prozess halt aussehen muss

00:46:17.820 --> 00:46:22.560
und wo man Sicherheits, ja, was ist das, Netze einzieht oder ...

00:46:25.600 --> 00:46:27.560
Ja, die Frage ist halt, welche Angriffsmöglichkeiten

00:46:28.360 --> 00:46:29.800
man irgendwie zur Verfügung stellen möchte.

00:46:29.920 --> 00:46:30.560
Da gibt es ja unzählige.

00:46:31.300 --> 00:46:32.820
Es ist ja nicht immer nur so diese Website,

00:46:32.940 --> 00:46:35.760
die nach außen dann da das Aushängeschild ist,

00:46:35.780 --> 00:46:36.740
wo man dann draufhauen kann.

00:46:37.440 --> 00:46:38.720
Ja, die Versuchung ist ja nicht groß,

00:46:38.800 --> 00:46:42.700
sich halt sozusagen als Feature, als Draufklopf anzukaufen,

00:46:42.800 --> 00:46:44.700
also ein riesiges System, was aktuell existiert,

00:46:44.800 --> 00:46:46.780
was in Wirklichkeit wahnsinnig unsicher ist

00:46:46.780 --> 00:46:48.680
und dass man sagt, okay, ich mache jetzt einfach,

00:46:48.800 --> 00:46:50.420
ich kaufe jetzt eine Waffe oder

00:46:50.420 --> 00:46:52.540
irgendwas anderes, mache einmal

00:46:52.540 --> 00:46:54.360
einen Pentest oder mache eine Sache

00:46:54.360 --> 00:46:56.960
und hoffe dann, dass das damit okay ist,

00:46:57.000 --> 00:46:58.440
dass ich halt so Sicherheit dazukaufen kann.

00:46:58.540 --> 00:47:00.280
Ich glaube, es ist viel,

00:47:00.520 --> 00:47:02.500
es entsteht viel bessere Software, nicht nur sichere,

00:47:02.580 --> 00:47:04.800
sondern auch bugfreie Software,

00:47:04.800 --> 00:47:06.780
wenn man die gesamte Software

00:47:06.780 --> 00:47:08.780
direkt so anlegt, dass man sagt, okay, bei der Produktion

00:47:08.780 --> 00:47:10.940
der Software, ich mache mir vielleicht vorher Gedanken,

00:47:11.360 --> 00:47:12.780
ich würde nicht mal sagen, viel über die

00:47:12.780 --> 00:47:14.840
eigentlichen Zertifizierung oder

00:47:14.840 --> 00:47:17.000
die Prozesse, sondern vielleicht mehr

00:47:17.000 --> 00:47:18.740
wie lasse ich die entwickeln?

00:47:18.920 --> 00:47:21.000
Wie sorge ich dafür, dass das, wie ich eben

00:47:21.000 --> 00:47:22.660
erwähnt hatte, Code Review, also

00:47:22.660 --> 00:47:24.460
wie sorge ich dafür, dass das halt schon

00:47:24.460 --> 00:47:27.200
bei der Entwicklung

00:47:27.200 --> 00:47:28.860
direkt die Software sicher ist? Weil nachher das

00:47:28.860 --> 00:47:30.960
draufzubauen ist immer schwieriger. Also nachher

00:47:30.960 --> 00:47:32.860
mit dem Scanner zu suchen ist, glaube ich, schwieriger als

00:47:32.860 --> 00:47:35.040
zu sagen, okay, ich habe Entwickler,

00:47:35.140 --> 00:47:36.680
die sich direkt darüber Gedanken machen.

00:47:37.060 --> 00:47:38.780
Das ist ja zum Beispiel total kaputt. Also ich

00:47:38.780 --> 00:47:40.720
hatte jetzt irgendwie mal so die Situation, dass

00:47:40.720 --> 00:47:42.720
so ein Konzern da war, die wollten

00:47:42.720 --> 00:47:44.700
dann Software bereitstellen und dann haben sie

00:47:44.700 --> 00:47:46.660
gesagt, nee, aber neue Software ist irgendwie komisch,

00:47:46.720 --> 00:47:48.580
wir wollen die alle auditieren vorher, so persönlich,

00:47:48.720 --> 00:47:50.680
also als Security-Team und haben dann so

00:47:50.680 --> 00:47:52.560
ein Service dann rausgebracht, dann

00:47:52.560 --> 00:47:54.580
jetzt im November und da war dann Django

00:47:54.580 --> 00:47:56.600
1.10.4, weil das dann die sichere Version

00:47:56.600 --> 00:47:58.700
war, das ist also LTS war 1.11, für alle, die es noch

00:47:58.700 --> 00:48:00.620
wissen, das ist halt schon ein altes System und da

00:48:00.620 --> 00:48:02.540
gibt es halt dann irgendwie schon jede Menge irgendwie Exploits,

00:48:02.580 --> 00:48:04.700
wenn man irgendwie genug nachsucht, die irgendwo drinstehen

00:48:04.700 --> 00:48:06.720
und das wird dann von den Leuten irgendwie

00:48:06.720 --> 00:48:08.540
geauditet und man fragt sich halt so, okay, was machen

00:48:08.540 --> 00:48:10.580
die denn da eigentlich, so, warum tun

00:48:10.580 --> 00:48:12.280
die das? Und das ist halt vielleicht so ein, ja,

00:48:12.620 --> 00:48:14.260
das kriegt man, glaube ich, gar nicht so gut in die Hüfte.

00:48:14.280 --> 00:48:16.160
Das ist halt wieder der Griff in Richtung Product Security statt

00:48:16.160 --> 00:48:17.000
Process Security.

00:48:18.340 --> 00:48:18.660
Also

00:48:18.660 --> 00:48:22.480
ein prozesshafter Ansatz und wir haben jetzt ja auch

00:48:22.480 --> 00:48:24.220
seit eineinhalb Jahren, nee, seit, doch,

00:48:24.300 --> 00:48:25.960
seit ein bisschen mehr als eineinhalb Jahren machen wir bei uns

00:48:25.960 --> 00:48:28.620
ISO 27000 und

00:48:28.620 --> 00:48:30.480
der Trick ist

00:48:30.480 --> 00:48:32.580
halt bei vielen, die prozesshaften

00:48:32.580 --> 00:48:34.560
Security-Sachen werden häufig missverstanden,

00:48:35.020 --> 00:48:36.320
weil die Standards, die es

00:48:36.320 --> 00:48:38.480
dazu gibt, wie eine Keule

00:48:38.480 --> 00:48:40.540
aussehen, obwohl sie eigentlich gar nicht so schlimm sind.

00:48:41.000 --> 00:48:42.480
Man muss da bloß, wenn man die Standards

00:48:42.480 --> 00:48:44.420
interpretiert, immer unterscheiden zwischen

00:48:44.420 --> 00:48:46.200
was fordert der Standard formal

00:48:46.200 --> 00:48:48.540
und was ist im nächsten Satz schon nur noch die

00:48:48.540 --> 00:48:50.480
Implementationsguideline,

00:48:51.600 --> 00:48:52.700
wo man dann eigentlich

00:48:52.700 --> 00:48:54.460
selber Hoheit hat. Also ich habe halt

00:48:54.460 --> 00:48:55.620
auch jemanden,

00:48:55.680 --> 00:48:57.840
der meinte, der ISO 27000,

00:48:58.280 --> 00:49:00.120
seitdem müssen wir sämtliche

00:49:00.120 --> 00:49:02.000
Stromkabel einmal im Jahr

00:49:02.000 --> 00:49:04.420
irgendwie auf die Erdung

00:49:04.420 --> 00:49:05.680
prüfen. Also

00:49:06.300 --> 00:49:07.600
nee, musst du nicht, ich habe auch nur

00:49:07.600 --> 00:49:09.640
27.000, aber dann müsst ihr das doch auch mal so, nee, müssen wir

00:49:09.640 --> 00:49:11.480
nicht. Ja, aber, aber,

00:49:11.640 --> 00:49:12.540
ja, nee, müssen wir nicht.

00:49:13.640 --> 00:49:15.200
Und dann dreht man so eine Schleife mit,

00:49:15.280 --> 00:49:17.460
die ISO sagt, du musst dich halt um die für dich

00:49:17.460 --> 00:49:19.580
relevanten Normen und Vorschriften

00:49:19.580 --> 00:49:21.840
kümmern, das sagt die ISO 27.000,

00:49:22.420 --> 00:49:23.300
also macht man das

00:49:23.300 --> 00:49:25.520
und die sagt aber auch, du musst sie

00:49:25.520 --> 00:49:27.620
bewerten und musst

00:49:27.620 --> 00:49:29.740
dann Schlussfolgerungen für dich daraus ziehen.

00:49:30.640 --> 00:49:31.580
Und es ist völlig

00:49:31.580 --> 00:49:33.700
legitim im Rahmen der ISO zu sagen, ja,

00:49:34.080 --> 00:49:35.320
wir haben zur Kenntnis genommen, dass

00:49:35.320 --> 00:49:37.680
ortsveränderliche elektrische Verbraucher

00:49:37.680 --> 00:49:39.480
irgendwie alle zwei Jahre auf X geprüft werden

00:49:39.480 --> 00:49:39.760
müssen.

00:49:41.140 --> 00:49:41.920
Machen wir nicht.

00:49:42.920 --> 00:49:45.280
Aber jetzt kannst du doch mal erklären, was für eine Lücke das

00:49:45.280 --> 00:49:47.120
offen lassen könnte, warum man das

00:49:47.120 --> 00:49:48.820
testen wollen möchte.

00:49:49.760 --> 00:49:51.040
So, naja, ISO als Prozess,

00:49:51.340 --> 00:49:53.520
die ISO als Informationssicherheitsprozess

00:49:53.520 --> 00:49:54.900
ist extrem umfassend

00:49:54.900 --> 00:49:56.920
und zwingt dich dazu,

00:49:56.920 --> 00:49:59.180
den kompletten Wertschöpfungsprozess

00:49:59.180 --> 00:50:00.800
von einem IT-System

00:50:00.800 --> 00:50:02.760
zu betrachten. Da gehört halt dann unter anderem auch

00:50:02.760 --> 00:50:04.200
dazu, dass

00:50:04.200 --> 00:50:09.000
dass du eben rechtliche Rahmenbedingungen bewertest etc.,

00:50:09.000 --> 00:50:11.740
weil du musst am Ende immer für alle deine Assets,

00:50:12.280 --> 00:50:15.460
und Philipp hat das halt schon, die vier Grundsicherheitsaspekte,

00:50:15.920 --> 00:50:19.080
also bei uns sind sie aufgeschlossen, manchmal wären es drei, manchmal wären es vier,

00:50:19.800 --> 00:50:24.900
halt nach Vertraulichkeit, Confidentiality, nach Integrität, Integrity,

00:50:25.020 --> 00:50:29.300
nach Authentizität und nach Availability zu schütten.

00:50:29.300 --> 00:50:32.860
Und was hat das jetzt damit zu tun, dass da so ein Stromkabel ist, in das sich …

00:50:32.860 --> 00:50:35.820
Strom ist zum Beispiel für die Availability relativ wichtig.

00:50:35.940 --> 00:50:37.120
Okay, also Availability, okay.

00:50:37.760 --> 00:50:39.660
Und du misst halt dann da quasi nur die Stromleitung,

00:50:39.760 --> 00:50:40.980
um zu testen, ob das Ding irgendwann mal ausfällt.

00:50:41.460 --> 00:50:43.160
Es ist halt eine deutsche Norm,

00:50:43.300 --> 00:50:45.700
die kommt aus dem, ich weiß nicht, welches ist,

00:50:46.180 --> 00:50:47.260
die schreibt halt vor,

00:50:47.400 --> 00:50:50.720
dass halt alle ortsveränderlichen Verbraucher

00:50:50.720 --> 00:50:54.400
auf Fehlerstrom zu prüfen sind, alle zwei Jahre halt so.

00:50:54.400 --> 00:50:55.840
Und wenn die ISO halt sagt,

00:50:55.920 --> 00:50:59.520
du musst halt alle für dich gültigen Rechtsnormen berücksichtigen

00:50:59.520 --> 00:51:02.340
und überwachen etc., dann schlägt sowas halt auch zu.

00:51:02.680 --> 00:51:06.620
Was die Leute aber eben häufig missverstehen, ist, dass in der ISO drinsteht, du sollst es bewerten.

00:51:07.680 --> 00:51:11.760
Und du sollst für dich daraus ableiten, ob das jetzt was Relevantes ist oder nicht.

00:51:11.760 --> 00:51:18.380
Du kannst als Geschäftsführer oder als CISO an der Stelle immer sagen, okay, ich habe da fünf Risiken gesehen, ich akzeptiere die.

00:51:19.700 --> 00:51:21.120
Jetzt hast du aber meine Story kaputt gemacht.

00:51:21.480 --> 00:51:26.280
Ich wollte eigentlich die Story hören, wie man durch das Stromkabel in den Rechner des CISOs einringt.

00:51:27.040 --> 00:51:40.740
Das Stromkabel, also das kann zum Beispiel passieren, wenn du deinen Prozessor aufstellst und sagst, naja, Stromkabel sind für uns keine sicherheitsrelevanten Dinge, deswegen kaufen wir die aus der Grabbelkiste beim Euroshop nebenan.

00:51:42.240 --> 00:51:54.160
Das heißt, dann verkaufen die dir plötzlich en masse Dinge, wo sie wissen, in einem halben Jahr geht da drinnen irgendwas kaputt und dann geht bei dir im Rechenzentrum mit einem Mal das Licht aus und dann ist deine Verfügbarkeit hin.

00:51:55.080 --> 00:52:08.640
Und weil dein Redundanzkonzept natürlich davon ausging, dass dir niemand so ein Ding untergejubelt hat mit der Absicht, dass da ein kleiner Sollbruchkondensator oder irgendwas drin ist, der dann halt nach so und so viel schönen Laufzeit einfach eine Schmelzsicherung durchgehen lässt.

00:52:09.320 --> 00:52:14.920
Also das ist glaube ich auch erstmal nur relevant für so Atomkraftwerke oder sowas, die halt dann vernünftige Kühlung brauchen.

00:52:15.220 --> 00:52:20.140
Nein, das kommt auf deine Angreifer und die Motivation der Angreifer drauf an.

00:52:20.720 --> 00:52:29.320
Also die Story da drumherum wäre zum Beispiel, jemand zu sagen, wir betreiben Dienste sehr, sehr lange, teilweise 10, 15 Jahre und länger.

00:52:29.560 --> 00:52:43.580
Das heißt, wenn ich, und auch teilweise mit politischem Impact, also wir haben ein paar Systeme, die sind unter anderem zu uns gewandert, extra aus Amerika raus, von Non-Profits, die unter anderem im Nahen Osten halt aktiv sind.

00:52:44.160 --> 00:52:53.420
Und die haben ein massives Sicherheitsbedürfnis um das Leben derer, deren Daten in dem Ding drin stehen, weil da halt Decknamen und so ein Zeug auftauchen.

00:52:54.120 --> 00:53:02.240
Und die, wenn du dann halt sagst, naja, wenn da jemand ein richtiges Longgame spielt und sagt, ich hab hier drei Jahre Zeit, das ist nicht das Problem.

00:53:02.720 --> 00:53:13.000
Ich will aber, dass diese NGO mal so richtig gegen die Wand fährt, dann farbe ich jetzt die Lücke und sage, aha, ich hab rausgefunden, deren Hoster kauft immer irgendwie aus der Grabbelkiste die Stromkabel.

00:53:13.340 --> 00:53:15.240
das dauert jetzt, naja, der tauscht nur so und so oft

00:53:15.240 --> 00:53:17.240
die Stromkabel aus, aber wenn

00:53:17.240 --> 00:53:19.120
ich es schaffe, irgendwie ein Drittel

00:53:19.120 --> 00:53:21.340
seiner Stromkabel durch meine mit dieser Schmelzsicherung

00:53:21.340 --> 00:53:23.380
zu ersetzen, dann bin ich in drei Jahren

00:53:23.380 --> 00:53:25.140
soweit, dass dann irgendwie bei dem das RZ

00:53:25.140 --> 00:53:25.700
implodiert.

00:53:28.340 --> 00:53:29.540
Das ist sozusagen

00:53:29.540 --> 00:53:31.140
die, und da muss man immer

00:53:31.140 --> 00:53:31.640
aufpassen,

00:53:32.960 --> 00:53:35.240
da kommt dieser, welcher XKCD ist

00:53:35.240 --> 00:53:36.960
das mit der hohen Verschlüsselung und dem

00:53:36.960 --> 00:53:39.520
der 5-Dollar-Entschlüsselungsmaschine?

00:53:40.700 --> 00:53:41.360
XKCD, bitte

00:53:41.360 --> 00:53:41.900
nochmal einmal.

00:53:43.220 --> 00:53:44.800
XKCD, Comic.

00:53:46.960 --> 00:53:50.800
Wo die Idee ist,

00:53:50.840 --> 00:53:52.400
dass du eine ganz, ganz teure Verschlüsselung

00:53:52.400 --> 00:53:54.480
kaufen kannst, mit super zertifiziert

00:53:54.480 --> 00:53:56.420
und dann kommt aber jemand

00:53:56.420 --> 00:53:57.720
zu deinem Admin mit einem

00:53:57.720 --> 00:54:00.420
5 Dollar Baseballschläger

00:54:00.420 --> 00:54:02.700
und bedroht ihn dann und sagt, okay, gib mir das Passwort.

00:54:03.140 --> 00:54:03.980
Wenn das für dich gibt, dann

00:54:03.980 --> 00:54:06.460
hau ich dich mit dem Schläger und dann bringt

00:54:06.460 --> 00:54:08.580
dir die beste Zertifizierung und die beste Sicherheit

00:54:08.580 --> 00:54:10.160
nichts. Ja, tatsächlich, ja.

00:54:10.500 --> 00:54:12.060
Und man sagt halt auch an der Stelle, weil häufig,

00:54:12.240 --> 00:54:14.560
gerade dieses Thema Advanced

00:54:14.560 --> 00:54:16.540
Persistent Threat, also

00:54:16.540 --> 00:54:18.720
die typischerweise staatlich

00:54:18.720 --> 00:54:20.540
finanzierte Organisationen

00:54:20.540 --> 00:54:22.500
oder Teams, die irgendwo reingehen sollen,

00:54:22.940 --> 00:54:24.080
man sagt halt auch so schön,

00:54:24.860 --> 00:54:25.880
gegen den Mossad

00:54:25.880 --> 00:54:28.620
schützt du dich

00:54:28.620 --> 00:54:30.020
nicht, weil

00:54:30.020 --> 00:54:32.280
der Mossad interessiert nicht,

00:54:32.680 --> 00:54:34.720
was du für Security irgendwo in deinem RZ hast.

00:54:35.040 --> 00:54:36.620
Der kommt zu dir nach Hause und nimmt

00:54:36.620 --> 00:54:38.620
dich mit und dann reden

00:54:38.620 --> 00:54:39.000
wir nochmal.

00:54:40.520 --> 00:54:53.640
Und deswegen ist, wenn man das mal schluckt und sagt, okay, ich bin hier nicht der, der sich gegen den Mossad schützen muss, weil ich habe eh keine Chance, dann brauche ich aber auch nicht so tun, als wenn ich sozusagen alles auf dem Niveau machen müsste.

00:54:54.040 --> 00:54:55.220
Oder du brauchst einen eigenen Geheimdienst.

00:54:56.080 --> 00:54:56.340
Bitte?

00:54:56.680 --> 00:54:57.920
Oder du brauchst einen eigenen Geheimdienst.

00:54:58.580 --> 00:54:59.020
Ja, genau.

00:55:00.880 --> 00:55:02.500
Aber das Fiese am Internet ist ja,

00:55:02.740 --> 00:55:06.320
dass du immer mit den besten Angreifern kommunizierst.

00:55:06.420 --> 00:55:08.380
Das heißt, vielleicht nicht mit dem Mossad,

00:55:08.460 --> 00:55:09.900
aber vielleicht hast du irgendwelche russische Hacker,

00:55:10.000 --> 00:55:11.060
die durchaus was draufhaben.

00:55:11.540 --> 00:55:12.760
Und die installieren dann halt,

00:55:12.940 --> 00:55:14.920
wie hier in der Uniklinik Düsseldorf,

00:55:15.260 --> 00:55:15.920
deine Ransomware.

00:55:15.920 --> 00:55:18.960
Und die sind auch fast auf dem Level

00:55:18.960 --> 00:55:20.420
von so einem Advanced Persistent Threat.

00:55:21.320 --> 00:55:22.920
Die haben vielleicht jetzt nicht so...

00:55:23.560 --> 00:55:25.200
Also, die machen schon ein bisschen Streufeuer,

00:55:25.340 --> 00:55:27.420
aber die haben durchaus das technische Know-how

00:55:27.420 --> 00:55:28.920
und auch die Zeit.

00:55:29.640 --> 00:55:32.940
Und die machen sich auch die Mühe, das an deine Architektur anzupassen.

00:55:33.600 --> 00:55:37.780
Also vielleicht noch mal kurz, Uniklinik Düsseldorf, da gab es einen Vorfall, da sind die Server rausgefallen.

00:55:37.900 --> 00:55:45.700
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:48.400 --> 00:55:51.900
Ja, ich weiß nicht genau, was da passiert ist, aber war ein bisschen nicht verfolgt, muss ich zugeben.

00:55:52.560 --> 00:55:56.540
War aber auch, glaube ich, nicht der erste Fall in Deutschland und ich glaube, das hat es auch ein paar Mal so richtig erwischt.

00:55:58.560 --> 00:56:11.200
Nee, natürlich. Also das ist halt ja jetzt erstmal, die Mossad-Beispiele kommen immer zu dem Thema, wenn man anfängt, die Physical Security halt extrem stark zu übertreiben. Und das ist aber dummerweise auch das, wo Leute gerne übertreiben, weil das können sie sich bildlich vorstellen.

00:56:11.820 --> 00:56:27.940
Dann kommt halt immer noch ein, ja warum ist hier vor dem RZ keine Panzersperre und alle nur, ja, denkt dran, Panzersperre hilft dir nichts, weil in Deutschland hat die Feuerwehr, guck mal da draußen, siehst du diesen kleinen unauffälligen grauen Kasten? Da ist der Generalschlüssel für das ganze Haus drin.

00:56:28.560 --> 00:56:36.420
Ja, wie? Na, das ist der Feuerwehrschlüsselkasten, da gibt es einen Feuerwehrschlüssel, den hat die Feuerwehr, die kann das Ding aufschließen, die kommt hier rein.

00:56:37.280 --> 00:56:39.180
Also spar dir mal bitte deine Panzersperre.

00:56:41.280 --> 00:56:49.360
Also deswegen, das ist immer so dieses für mich bloß abzugrenzen von, wenn du das Niveau hast, musst du dir nochmal um ganz andere Sachen Gedanken machen.

00:56:49.740 --> 00:56:55.540
Und wenn man das aber mal so übertrieben hat, dann wird den Leuten schnell klar, dass Security halt eine Abwägung ist und eine kontextspezifische Abwägung.

00:56:55.640 --> 00:56:58.440
Und immer nur auf 100% zu schalten, geht halt nicht.

00:56:58.560 --> 00:57:00.540
Und damit macht man auch mehr kaputt.

00:57:00.900 --> 00:57:02.640
Ich würde halt nochmal anknüpfen an den Punkt von

00:57:02.640 --> 00:57:04.700
dieser Prozessempfehlung. Ich würde halt

00:57:04.700 --> 00:57:06.600
immer versuchen, an allen Enden

00:57:06.600 --> 00:57:08.640
weniger ist mehr zu machen.

00:57:09.380 --> 00:57:10.720
Weniger Code, den du schreibst,

00:57:10.800 --> 00:57:12.740
ist typischerweise weniger Architektur, über die

00:57:12.740 --> 00:57:14.680
du nachdenken musst, ist weniger. Und damit

00:57:14.680 --> 00:57:16.720
auch ein Team, was gerade erst anfängt, würde ich eben

00:57:16.720 --> 00:57:18.740
nicht sagen, ihr fangt jetzt mal an, euch über Security

00:57:18.740 --> 00:57:20.800
Gedanken zu machen. Auch bei uns

00:57:20.800 --> 00:57:22.840
in der ISO ist es halt, in unserer

00:57:22.840 --> 00:57:24.740
Umsetzung der ISO 27000 ist es halt auch

00:57:24.740 --> 00:57:26.640
so, dass wir sagen, du willst irgendwie

00:57:26.640 --> 00:57:28.920
neues Feature für die Plattform etc. entwickeln? Ja, mach halt.

00:57:29.780 --> 00:57:30.680
Ja, mach halt.

00:57:31.240 --> 00:57:32.720
Ja, und du kannst gern auch irgendwie deine

00:57:32.720 --> 00:57:34.620
drei, vier Testmaschinen auf der Plattform halt

00:57:34.620 --> 00:57:35.940
schon mal auf diese Branch umstellen.

00:57:36.460 --> 00:57:38.500
Habe ich kein Problem mit. Aber,

00:57:38.600 --> 00:57:40.720
bevor das dann halt in großen Einsatz kommt,

00:57:41.220 --> 00:57:42.560
muss das halt mal durch eine

00:57:42.560 --> 00:57:44.460
Vier-Augen-Review durch. Und dann musst du mal

00:57:44.460 --> 00:57:46.480
irgendjemand anders erklärt haben, was du dir gedacht hast.

00:57:46.540 --> 00:57:48.280
Und dann gibt es dort eine Checkliste

00:57:48.280 --> 00:57:50.240
und die fragt, jetzt erklär mir mal, was du dir

00:57:50.240 --> 00:57:51.880
für Security für Gedanken gemacht hast.

00:57:51.880 --> 00:57:54.080
Und das ist im Prinzip, das ist bei uns

00:57:54.080 --> 00:57:56.100
der komplette formale Prozess

00:57:56.100 --> 00:57:57.480
für die Entwicklungssicherheit.

00:57:58.880 --> 00:57:59.940
Also übertrieben jetzt ein bisschen,

00:58:00.080 --> 00:58:01.880
aber im Prinzip ist sozusagen bei uns nur ein

00:58:01.880 --> 00:58:04.020
ja komm, entwickle halt, da drüben

00:58:04.020 --> 00:58:06.180
sind die zehn Guidelines, was man in welchen Situationen

00:58:06.180 --> 00:58:07.440
so alles mal berücksichtigen könnte.

00:58:08.080 --> 00:58:10.020
Und aber das Einzige, wozu wir dich zwingen, ist,

00:58:10.020 --> 00:58:12.120
du musst in dem Pull-Request, wo dein

00:58:12.120 --> 00:58:14.160
Feature in die General Availability geht,

00:58:14.620 --> 00:58:16.400
musst du mir oder deinem

00:58:16.400 --> 00:58:18.240
PR-Reviewer glaubhaft vermitteln,

00:58:18.320 --> 00:58:19.980
dass du dir jetzt wirklich adäquat zu dem

00:58:19.980 --> 00:58:21.200
Ding Gedanken gemacht hast.

00:58:21.860 --> 00:58:24.200
Schreibt man das dann als Text in den

00:58:24.200 --> 00:58:25.840
Pull-Request? Als Text in den Pull-Request rein.

00:58:26.100 --> 00:58:44.420
Da gibt es zwei Fragen. Das eine ist, was sind hier die Sicherheitsanforderungen? Und B, wie habt ihr die erfüllt? Wo ist hier der Nachweis, dass die erfüllt wurden? Wie seid ihr zu der Frage gekommen von, was sind hier die relevanten Sicherheitsanforderungen? Und wie weist ihr nach, dass ihr das jetzt halt ordentlich umgesetzt habt?

00:58:44.420 --> 00:59:05.380
Das hört sich so ein bisschen an, als sollte man die Angst weglassen und tatsächlich nur, also die Worst-Case-Szenarien, also was ist das Schlimmste, was passieren kann? Also bei dir wären zum Beispiel jetzt Daten weg gewesen, das wäre nicht so gut gewesen, weil die so sehr privat sein müssen. Und an anderer Stelle ist es vielleicht so, ja okay, wenn man die Backups noch hat, dann ist es halt nicht so schlimm. Und das ist halt dann vielleicht der Worst-Case und da muss man sich halt Gedanken darüber machen, dass der nicht eintreten kann und der Rest ist dann egal.

00:59:07.480 --> 00:59:33.980
Auch bei uns ist es so, unser Auditor zum Beispiel sagt halt auch immer, ein Unternehmen, was hochsicher ist und aber am Markt kein Produkt platzieren kann, hilft halt nicht. Es geht halt nicht. Und dieses Angstthema ist da schon relevant, weil halt Angst ist, häufig wird Security, gerade wenn es eine eigene Abteilung ist, immer wahrgenommen als, das sind halt die, die halt nachher unterschrieben haben sollen mit, hier ist alles sicher und deswegen sagen sie per Default einfach nein.

00:59:34.360 --> 00:59:55.940
Und für uns ist der Review-Prozess aber zum Beispiel auch umgedreht. Der Review-Prozess in einem PR bei uns ist halt immer nur ein, ja, man darf nicht alleine Zeug nach draußen prügeln, Sternchen, Fußnote, doch, es gibt Situationen, in denen man das darf, aber dann muss man noch mehr Dinge beachten, weil es gibt halt bei uns auch so Gefahr- und Verzugssituationen, dann muss ich handlungsfähig sein.

00:59:57.260 --> 00:59:59.020
aber der Pull-Request ist halt,

00:59:59.180 --> 01:00:01.140
wenn der gemerged wird, ist das halt nicht die Aussage

01:00:01.140 --> 01:00:02.960
von dem Reviewer, dass er

01:00:02.960 --> 01:00:04.900
seinen Erstgeborenen irgendwie

01:00:04.900 --> 01:00:07.100
mit Blut unterschrieben dem Teufel

01:00:07.100 --> 01:00:08.620
überantwortet, dass er

01:00:08.620 --> 01:00:10.120
sagt, hier ist alles sicher,

01:00:11.280 --> 01:00:12.980
sondern der Vier-Augen-Prozess ist

01:00:12.980 --> 01:00:15.020
dafür da, dass ein zweiter Mensch

01:00:15.020 --> 01:00:17.080
dem ersten nochmal in die Augen guckt

01:00:17.080 --> 01:00:19.000
und sagt, also wenn

01:00:19.000 --> 01:00:20.980
du jetzt nicht noch sagst, ich soll nach

01:00:20.980 --> 01:00:22.900
irgendwas schauen, dann merge ich den Kram

01:00:22.900 --> 01:00:24.820
jetzt. Also das ist aber dein Code,

01:00:24.880 --> 01:00:25.800
den ich jetzt gleich merge.

01:00:25.800 --> 01:00:46.040
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. Du hast jetzt gerade gesagt, du sagst mir, das ist das Beste an Arbeit, was du abzuliefern hast und ich gucke mit dir nochmal gemeinsam drüber, aber ich werde es nicht aufhalten.

01:00:46.040 --> 01:01:16.020
Ich bin hier nur der, der deinem Gewissen nochmal auf die Sprünge hilft, zu sagen, na, hast du nicht doch abgekürzt? Bist du dir wirklich sicher? Ich lasse das jetzt raus. Und das macht einen ganz massiven Unterschied, weil dann, was passiert? Die Änderungseinheiten werden kleiner, klassisches agiles Thema, weil die Leute nicht mehr sagen, oh Gott, oh Gott, oh Gott, der Review-Prozess ist so aufwendig, dann muss er sich aber auch lohnen, sondern wir drehen es halt um und sagen, nee, der Review-Prozess ist erstmal freundlich und der Default ist, wir gucken da zusammen drüber.

01:01:16.040 --> 01:01:18.140
und alle machen ihre Arbeit und reden drüber

01:01:18.140 --> 01:01:20.080
und klären das und dann lassen wir es auch

01:01:20.080 --> 01:01:21.920
raus und dann ist der in 5 Minuten erledigt.

01:01:22.880 --> 01:01:24.100
Also wenn ich halt zum Beispiel nur

01:01:24.100 --> 01:01:25.980
weiß ich, ein Pull-Request bei uns kann sein,

01:01:26.280 --> 01:01:27.900
Paket-Update vom Nginx, weil

01:01:27.900 --> 01:01:30.240
war ein CVE drin, kommt die nächste meiner Version.

01:01:30.420 --> 01:01:32.140
Ein CVE ist ein Vulnerable, was?

01:01:33.200 --> 01:01:34.040
Ja genau, also

01:01:34.040 --> 01:01:36.100
war eine Vulnerability, die bekannt war,

01:01:36.300 --> 01:01:38.200
die haben einen Patch bereitgestellt, wir spielen den Patch ein.

01:01:38.260 --> 01:01:40.020
Dann ist der Diff bei uns auf der Plattform

01:01:40.020 --> 01:01:41.460
typischerweise so zwei Zeilen lang,

01:01:42.040 --> 01:01:43.900
also irgendwie Version vom Nginx

01:01:43.900 --> 01:01:45.840
hochgedreht und den Hash halt angepasst.

01:01:46.040 --> 01:01:48.620
und die Review dazu sieht dann so aus,

01:01:49.440 --> 01:01:50.700
ja, ne, machen wir, oder?

01:01:50.960 --> 01:01:52.700
Ja, was war da noch drin in der

01:01:52.700 --> 01:01:54.620
Änderung? Ja, nix, war nur der CVE.

01:01:55.380 --> 01:01:56.740
Und beim NGINX? Ja, auch nur

01:01:56.740 --> 01:01:58.800
der CVE. Ja, jut, okay, was waren

01:01:58.800 --> 01:02:00.420
hier die Anforderungen? Anforderung war, wir

01:02:00.420 --> 01:02:02.560
müssen Updates machen, weil wir die Sicherheit

01:02:02.560 --> 01:02:04.540
aufrechterhalten sollen. Nachweis,

01:02:04.640 --> 01:02:06.620
naja, das ist jetzt die alte Version, war die, die neue ist

01:02:06.620 --> 01:02:08.180
die, zack, fertig, raus damit, Ende.

01:02:09.160 --> 01:02:09.700
That's it.

01:02:10.820 --> 01:02:12.360
Das ist halt den Leuten

01:02:12.360 --> 01:02:14.760
in den Prozessen das so an die Hand zu geben,

01:02:14.840 --> 01:02:17.440
dass sie nicht jedes Mal vor so einer Checkliste stehen von,

01:02:17.540 --> 01:02:20.980
du musst jetzt aber umhalten, damit dir nachher keiner den Kopf abbeißt.

01:02:21.060 --> 01:02:22.920
Weil das ist ja dann alles immer nur noch Ass-Covering,

01:02:23.340 --> 01:02:25.260
dass niemandem die Schuld zugeschoben werden kann.

01:02:25.920 --> 01:02:27.600
Und das ist ja nicht der Prozess, um den es geht,

01:02:27.680 --> 01:02:29.640
sondern der Prozess ist, dass Leute produktiv arbeiten können.

01:02:29.640 --> 01:02:33.360
Und während dieser Arbeit, der Vektor der Änderung immer heißt,

01:02:33.620 --> 01:02:37.140
mit jeder Änderung machen wir es erst mal potenziell sicherer und nicht unsicherer.

01:02:37.500 --> 01:02:40.320
Und wenn man dann sagt, okay, wenn ich das für alle Änderungen sicherstellen kann,

01:02:40.400 --> 01:02:42.420
dass alle Änderungen die richtigen Vektor haben,

01:02:43.520 --> 01:02:45.100
ja, dann mache ich doch einfach mehr Änderungen

01:02:45.100 --> 01:02:46.460
und werde halt immer sicherer.

01:02:47.360 --> 01:02:47.620
Ja.

01:02:49.020 --> 01:02:51.160
Ja, das ist interessant. Also was mir da gerade noch als Idee kommt,

01:02:51.160 --> 01:02:53.220
es gibt da eigentlich ein Problem bei dieser Sache

01:02:53.220 --> 01:02:55.000
mit den quasi Pull-Requests.

01:02:55.060 --> 01:02:57.100
Wenn das jetzt nicht in so einer Firma ist, wo alle Leute da Ahnung haben

01:02:57.100 --> 01:02:58.620
von dem, was sie tun, sondern wieder

01:02:58.620 --> 01:03:01.060
den nicht ganz optimalen Fall angenommen,

01:03:01.720 --> 01:03:03.140
dann kann sich jemand hinstellen,

01:03:03.220 --> 01:03:05.480
kann sagen, er ist jetzt hier der Türsteher und der guckt sich das alles an.

01:03:06.800 --> 01:03:07.040
Und

01:03:07.040 --> 01:03:09.240
dann hat er

01:03:09.240 --> 01:03:11.080
eine Existenzberechtigung, obwohl er eigentlich sonst gar nichts

01:03:11.080 --> 01:03:13.040
tun muss. Und das kann dann

01:03:13.040 --> 01:03:15.980
dieser Informationsasymmetrie

01:03:15.980 --> 01:03:16.560
dann ausnutzen.

01:03:18.640 --> 01:03:19.960
Für mich regelt das der Wettbewerb.

01:03:20.060 --> 01:03:21.440
Eine Firma, die so drauf ist, wird halt

01:03:21.440 --> 01:03:23.500
Schwierigkeiten haben, wirklich

01:03:23.500 --> 01:03:24.940
innovativ nach vorne zu laufen.

01:03:26.380 --> 01:03:27.780
Was ich halt noch spannend finde, ist, dass Python

01:03:27.780 --> 01:03:30.000
natürlich, um mal die Schleife jetzt noch zu ziehen,

01:03:31.500 --> 01:03:31.880
auch als

01:03:31.880 --> 01:03:33.560
Sprache natürlich ein gutes Standing hat.

01:03:34.140 --> 01:03:36.080
Ich hatte vorhin noch mal irgendwie durchgeguckt

01:03:36.080 --> 01:03:37.120
und wenn man halt guckt,

01:03:38.440 --> 01:03:38.820
wenn ich,

01:03:39.980 --> 01:03:41.780
wir könnten jetzt sozusagen, also der

01:03:41.780 --> 01:03:43.620
völlige Tiefschlag ist natürlich, wenn ich es gegen

01:03:43.620 --> 01:03:44.500
PHP vergleiche.

01:03:45.780 --> 01:03:47.660
Da habe ich halt das Problem, dass allein die

01:03:47.660 --> 01:03:49.940
Laufzeitumgebung von PHP und die Sprache selber

01:03:49.940 --> 01:03:51.840
ich hatte vorhin

01:03:51.840 --> 01:03:53.780
geguckt, über die letzten 20 Jahre

01:03:53.780 --> 01:03:55.160
über 600

01:03:55.160 --> 01:03:56.960
CVEs eingesammelt haben.

01:03:58.640 --> 01:03:59.620
Und die machen im Prinzip

01:03:59.620 --> 01:04:01.720
in einigen Jahren das

01:04:01.720 --> 01:04:04.200
Fünffache von dem, was Python über die

01:04:04.200 --> 01:04:05.220
letzten 20 Jahre

01:04:05.220 --> 01:04:07.660
insgesamt hat.

01:04:08.360 --> 01:04:09.900
Also bei Python kamen irgendwie 20

01:04:09.900 --> 01:04:12.140
CVS oder sowas raus über die letzten 20 Jahre.

01:04:12.980 --> 01:04:14.180
Viel mehr kommt da einfach

01:04:14.180 --> 01:04:16.040
nicht. Und

01:04:16.040 --> 01:04:17.840
das ist halt auch schon mal was, wo man immer sagen kann,

01:04:18.000 --> 01:04:20.060
okay, das ist was. Auf der einen

01:04:20.060 --> 01:04:22.060
Seite die Sprache selber hat viele

01:04:22.060 --> 01:04:23.400
Probleme nicht, sowas wie ein

01:04:23.400 --> 01:04:25.920
Buffer-Overflow zum Beispiel, kannst du mit Python

01:04:25.920 --> 01:04:28.180
erstmal so nicht erzeugen. Und es ist auch in der Community

01:04:28.180 --> 01:04:29.760
ja so verankert, dass extrem viele

01:04:29.760 --> 01:04:31.500
Bibliotheken, viele Frameworks

01:04:31.500 --> 01:04:33.880
das ja auch als Thema für sich erklärt haben und

01:04:33.880 --> 01:04:35.860
eben sagen, wir basteln

01:04:35.860 --> 01:04:37.920
nicht nur um Security-Probleme rum, sondern versuchen

01:04:37.920 --> 01:04:39.840
sie dann ordentlich zu fixen. Und es gab

01:04:39.840 --> 01:04:41.820
auch in Python selber, also die Sachen, die es

01:04:41.820 --> 01:04:43.560
gab, wenn ich halt schaue, das war mal

01:04:43.560 --> 01:04:45.840
irgendwann ein libxml-Thema,

01:04:46.480 --> 01:04:47.940
weil du halt zum Beispiel

01:04:47.940 --> 01:04:49.380
libxml über

01:04:49.380 --> 01:04:51.660
das externes Auflösen von Entities dann

01:04:51.660 --> 01:04:53.840
irgendwie Code ausführen konntest und so ein Kram.

01:04:55.560 --> 01:04:55.820
Aber

01:04:55.820 --> 01:04:57.920
die wurden halt in der Community

01:04:57.920 --> 01:05:00.000
immer sehr differenziert und schnell

01:05:00.000 --> 01:05:01.580
diskutiert und auch

01:05:01.580 --> 01:05:02.820
adäquat behoben.

01:05:05.400 --> 01:05:05.880
Da

01:05:05.880 --> 01:05:07.780
habe ich einfach eine völlig andere Basis, von der

01:05:07.780 --> 01:05:09.880
ich ausgehe, als wenn ich praktisch

01:05:09.880 --> 01:05:11.780
bei jeder Codezeile, die ich schreibe, da denke ich

01:05:11.780 --> 01:05:13.660
dann eher so an C, tatsächlich

01:05:13.660 --> 01:05:15.760
meinen Doktor-Kittel angezogen haben muss, um

01:05:15.760 --> 01:05:17.420
ja, nicht daneben zu tappen.

01:05:18.080 --> 01:05:19.640
Ja, dann hat, glaube ich, sowas wie Rust auch

01:05:19.640 --> 01:05:21.600
deswegen gekommen, oder? Weil das genau das dann wieder

01:05:21.600 --> 01:05:22.340
anders macht und

01:05:22.340 --> 01:05:24.240
in den Griff kriegt, ja.

01:05:26.160 --> 01:05:27.860
Ja, ja, also Rust ist auf jeden Fall,

01:05:27.960 --> 01:05:29.500
also ich meine, es kommt halt

01:05:29.500 --> 01:05:30.920
darauf an, was man jetzt,

01:05:31.460 --> 01:05:33.340
ich glaube, eben vor Buffer-Overflow,

01:05:33.420 --> 01:05:35.480
so muss man gar nicht so viel Angst haben, aber

01:05:35.480 --> 01:05:37.660
wenn man jetzt Server betreibt,

01:05:37.760 --> 01:05:39.660
die halt super viele Requests bearbeiten

01:05:39.660 --> 01:05:40.360
oder so.

01:05:41.980 --> 01:05:43.740
Was hat letztens in einem

01:05:43.740 --> 01:05:44.900
Podcast irgendwie der

01:05:44.900 --> 01:05:47.780
Entwickler von Flastia

01:05:47.780 --> 01:05:49.760
Armin Ronacher gesagt? Er meinte so, Rust

01:05:49.760 --> 01:05:51.280
ist halt für ihn schon

01:05:51.280 --> 01:05:53.500
allein deswegen so viel netter, weil

01:05:53.500 --> 01:05:55.720
Python hätte er ja auch irgendwie

01:05:55.720 --> 01:05:57.660
sehr gerne gemacht, aber das liegt halt wie Sau.

01:05:58.080 --> 01:05:59.540
Das ist halt, da kann man

01:05:59.540 --> 01:06:01.760
nicht viel dran machen. Und das ist

01:06:01.760 --> 01:06:02.620
natürlich schon irgendwie

01:06:02.620 --> 01:06:04.540
so.

01:06:06.960 --> 01:06:09.300
Das würde ich gerne verstehen, weil da geht mir

01:06:09.300 --> 01:06:11.000
Philipp dreht den Kopf und ich

01:06:11.000 --> 01:06:13.220
habe auch so ein kleines Messer, was mir in der Tasche aufgeht.

01:06:13.340 --> 01:06:15.200
Ja, ja, klar. Also es ist

01:06:15.200 --> 01:06:17.280
muss, aber ich kann

01:06:17.280 --> 01:06:19.000
schon in gewisser Weise verstehen, was er

01:06:19.000 --> 01:06:21.160
meint. Also ich meine, bei Rust kannst du dir halt

01:06:21.160 --> 01:06:22.320
sicher sein, dass da nichts liegt,

01:06:23.180 --> 01:06:24.040
wenn du es halt richtig machst.

01:06:24.140 --> 01:06:27.280
Was meinst du denn damit da liegt was rum?

01:06:28.420 --> 01:06:29.480
Naja, zum Beispiel,

01:06:30.060 --> 01:06:30.460
dass halt

01:06:30.460 --> 01:06:33.020
der Hauptspeicher immer weiter anwächst, ohne

01:06:33.020 --> 01:06:34.960
dass du das eigentlich wolltest, ja,

01:06:35.060 --> 01:06:37.160
sozusagen, ohne dass du wirklich den Hauptspeicher brauchst,

01:06:37.260 --> 01:06:38.800
sondern dass halt Sachen nicht wieder

01:06:38.800 --> 01:06:40.900
weggeräumt werden, die halt irgendwann mal angefallen sind.

01:06:42.000 --> 01:06:42.840
Klar, also Python

01:06:42.840 --> 01:06:44.800
nimmt dir das Memory-Management halt komplett

01:06:44.800 --> 01:06:46.600
weg und

01:06:46.600 --> 01:06:48.760
das ist tatsächlich Fluch

01:06:48.760 --> 01:06:50.920
und Segen zugleich, logischerweise.

01:06:51.100 --> 01:06:52.700
Also jede technische Entscheidung der Hinsicht hat

01:06:52.700 --> 01:06:54.660
immer Trade-Offs und ein Aspekt

01:06:54.660 --> 01:06:56.200
bei Python ist nun mal, dass Python

01:06:56.200 --> 01:06:58.700
Speicher, den es mal gebraucht hat,

01:06:58.900 --> 01:07:00.860
auch wenn es den Akut gerade nicht braucht,

01:07:01.420 --> 01:07:02.960
nicht einfach mal so wiederhergibt.

01:07:03.540 --> 01:07:04.740
Also wenn dein Prozess

01:07:04.740 --> 01:07:06.760
mal irgendwie, keine Ahnung, ein Gig oder zwei Gig groß

01:07:06.760 --> 01:07:08.900
ist, dann kann

01:07:08.900 --> 01:07:10.840
es gut sein, dass der das jetzt für die nächste Zeit

01:07:10.840 --> 01:07:12.880
mal behält, auch wenn du alle Objekte gelöscht hast

01:07:12.880 --> 01:07:14.280
und wenn die Garbage Collection durch war,

01:07:14.800 --> 01:07:16.880
weil es ist halt auch ein Trade-Off

01:07:16.880 --> 01:07:18.900
zu sagen, naja, ständig

01:07:18.900 --> 01:07:20.840
Mellocs groß und klein und

01:07:20.840 --> 01:07:22.800
groß und klein zu machen, hat auch

01:07:22.800 --> 01:07:24.840
Nachteile. Es hat Nachteile in der Hauptspeicher

01:07:24.840 --> 01:07:26.800
Fragmentierung, das ist an sich ein Performance

01:07:26.800 --> 01:07:28.500
Thema, jada jada jada jada

01:07:28.500 --> 01:07:30.740
und Python als Universalsprache

01:07:30.740 --> 01:07:32.820
in der Hinsicht, wo eben Memory Management als

01:07:32.820 --> 01:07:34.840
ich kümmere mich drum, draufsteht,

01:07:35.660 --> 01:07:37.020
verstehe ich, dass es in diese

01:07:37.020 --> 01:07:38.960
Richtung neigt, eben eher diesen

01:07:38.960 --> 01:07:40.880
universalen Ansatz da zu verfolgen. Und Rust

01:07:40.880 --> 01:07:42.860
tritt nun mal an mit, du hast deinen

01:07:42.860 --> 01:07:44.760
Speicher im Griff, dann müssen sie das auch abliefern.

01:07:44.920 --> 01:07:46.440
Das ist klar.

01:07:47.020 --> 01:07:48.860
Also nochmal ganz kurz, vielleicht, was

01:07:48.860 --> 01:07:50.700
ein Melloc ist, also du alloziierst

01:07:50.700 --> 01:07:51.640
irgendeinen Speicher, oder?

01:07:54.620 --> 01:07:56.560
Genau, also wenn du

01:07:56.560 --> 01:07:58.900
vom Betriebssystem halt Speicher haben möchtest,

01:07:59.660 --> 01:08:00.680
dann ist es ja heutzutage

01:08:00.680 --> 01:08:02.500
eh schon nur noch virtueller Speicher. Also

01:08:02.500 --> 01:08:11.080
Also dass das in deinem Rechner irgendwie 8 Gig, 16 Gig oder halt mal ein halbes Tera oder ein Tera RAM drin ist, das weiß ja kein Programm.

01:08:11.180 --> 01:08:18.400
Das guckt auch kein Programm so wirklich nach heutzutage, sondern ein Programm geht her und sagt, ey, du, könnte ich mal irgendwie Speicher im Wert von 3 Terabyte haben?

01:08:18.400 --> 01:08:22.240
Und dann sagt normalerweise der Linux-Kern heutzutage, klar, kein Thema, hier hast du.

01:08:23.560 --> 01:08:29.840
Und erst in dem Moment, wo es das dann auch anfängt zu beschreiben, sagt der Kern, ach, du willst es auch noch benutzen?

01:08:30.780 --> 01:08:34.080
Na dann, dann teilt er ihm tatsächlich irgendwie diese Sachen zu.

01:08:35.320 --> 01:08:38.680
Und deswegen gibt es einige Programme, MongoDB ist halt auch so ein Ding,

01:08:38.760 --> 01:08:44.020
die alloziieren zum Beispiel immer bloß in Vielfachen von 2 oder in 2 Potenzen oder so ein Kram.

01:08:44.520 --> 01:08:46.680
Also wenn der halt hergeht und sagt, ich brauche hier mal RAM,

01:08:47.080 --> 01:08:49.120
dann sagt er als erstes, ich brauche 64 MB,

01:08:49.120 --> 01:08:51.340
und dann irgendwie, ja jetzt hätte ich auch lieber 118 MB.

01:08:51.740 --> 01:08:53.260
Okay, also jetzt hätte ich gerne 1 GB.

01:08:53.500 --> 01:08:55.560
Und das kann manchmal schon so ein bisschen unangenehm sein,

01:08:56.080 --> 01:09:03.600
aber der Vorteil ist halt, wenn der Speicher dann auch am Stück ausgeliefert wird,

01:09:04.000 --> 01:09:07.000
dann hat das bestimmte andere charmante Aspekte,

01:09:07.120 --> 01:09:10.220
weil dann bestimmte Overhead-Strukturen im Kernel dann halt reduziert werden können.

01:09:10.300 --> 01:09:13.420
Der kann sogenannte Huge-Pages machen, das heißt, du musst dann halt nicht,

01:09:13.420 --> 01:09:17.940
wenn du einen Gigabyte alloziierst, muss der Kernel halt nicht eine Million mal

01:09:17.940 --> 01:09:22.100
eine 1-Kilobyte-Page irgendwo in seiner Tabelle abmarkern,

01:09:22.200 --> 01:09:26.180
weil auch das kann plötzlich schon mal 2, 3, 4, 500 Millisekunden dauern,

01:09:26.660 --> 01:09:29.380
sondern der sagt dann einfach nur noch, hier hast du das Gigabyte.

01:09:30.680 --> 01:09:33.900
Und das sind so Sachen, wo Python dann eben auch häufig optimiert.

01:09:33.980 --> 01:09:36.520
Und Python ist extrem erfolgreich, was diese Optimierung angeht.

01:09:37.300 --> 01:09:39.000
Ein Beispiel dafür sind zum Beispiel Listen.

01:09:40.020 --> 01:09:44.820
Listen haben eine, es gibt eine Operation bei Listen,

01:09:44.820 --> 01:09:47.240
die ist unoffensichtlich O von 1,

01:09:47.940 --> 01:10:00.500
nämlich ein, genau, ein Append an Listen bei Python ist, wie war denn das, ne, sind Listen nicht immer ein O von 1 Append?

01:10:00.500 --> 01:10:08.120
Ja, sollte, wer weiß es, ich weiß es, da war, ne, es gab irgendeinen spezifischen Fall, also die Story drumherum grob ist die,

01:10:08.580 --> 01:10:14.340
dass die Speicherallokation für Listen in Python auch immer nur verdoppelt.

01:10:15.200 --> 01:10:19.620
Der alloziiert einen Buffer für das Array, um die Indizes zu verwalten

01:10:19.620 --> 01:10:24.440
und alloziiert aber, wenn er dann sozusagen es größer machen muss,

01:10:24.440 --> 01:10:27.300
nicht einfach sozusagen, dann muss er ja sozusagen das Ganze,

01:10:27.460 --> 01:10:29.580
achso genau, das Problem ist, wenn du es dann größer machen willst,

01:10:30.040 --> 01:10:33.860
musst du den Bestandsspeicher plus 1 nochmal neu alloziieren,

01:10:33.980 --> 01:10:36.060
alles umkopieren und dann halt das neue reinschreiben.

01:10:36.140 --> 01:10:40.980
Was Python aber macht ist, Python alloziiert immer dann das Doppelte von dem, was es vorher hatte,

01:10:42.000 --> 01:10:46.380
kopiert das einmal um, dann sind die nächsten n gratis,

01:10:47.500 --> 01:10:54.180
dann musst du wieder einmal verdoppeln, einmal kopieren und dann hast du wieder 2n gratis.

01:10:54.920 --> 01:10:59.660
Und das sind so typische Sachen, die man in solchen Situationen halt hat,

01:10:59.780 --> 01:11:02.480
was so Laufzeitumgebungen für einen automatisieren und machen

01:11:02.480 --> 01:11:05.840
und weswegen sich dann hinten so ein bisschen komische Speichereffekte ergeben.

01:11:06.140 --> 01:11:12.480
Und da habe ich lange, lange Zeit meines Lebens auch immer mit meinem Kopf kratzend davor gestanden

01:11:12.480 --> 01:11:14.920
und konnte Leuten nicht erklären, warum es das jetzt gerade tut.

01:11:15.400 --> 01:11:17.200
Und da muss man sich halt irgendwann sagen, kann man nicht erklären.

01:11:17.300 --> 01:11:19.500
Warum es genau das jetzt gerade tut, kann ich dir nicht erklären.

01:11:19.880 --> 01:11:24.520
Ich bin mir relativ sicher, dass es kein Leak ist, wenn du halt dann irgendwie mal sowas beobachtest

01:11:24.520 --> 01:11:27.460
über eine Woche oder einen Monat, wenn du einen langlaufenden Prozess hast

01:11:27.460 --> 01:11:30.540
und die Saisonalitäten findest und du was merkst wie, ah, okay,

01:11:30.960 --> 01:11:33.680
frühmorgens haben die Leute ihren Kaffee getrunken, jetzt lesen sie alle irgendwie das,

01:11:33.780 --> 01:11:36.340
auf deiner Webseite ist, dann geht ihr Speicherbedarf

01:11:36.340 --> 01:11:37.760
irgendwie hoch, dann kommen abends

01:11:37.760 --> 01:11:39.720
irgendwann die Cronjobs, dann geht er nochmal ein bisschen hoch,

01:11:39.800 --> 01:11:41.360
dann passiert lange nichts und dann ist plötzlich,

01:11:41.520 --> 01:11:43.900
gibt er mal wieder ein bisschen Speicher frei und dann ist es irgendwie gut.

01:11:45.220 --> 01:11:45.820
Und wenn du dann

01:11:45.820 --> 01:11:47.960
aber siehst, okay, über einen Monat ist das immer das Gleiche,

01:11:48.140 --> 01:11:49.980
dann mag das zwar sein, dass er zu jedem einzelnen

01:11:49.980 --> 01:11:51.260
Zeitpunkt mal einen Speicher hat, den er

01:11:51.260 --> 01:11:53.160
jetzt gerade akut nicht braucht,

01:11:53.640 --> 01:11:54.800
aber es liegt nicht.

01:11:58.300 --> 01:11:59.740
Ja, ich weiß auch nicht,

01:11:59.780 --> 01:12:00.720
was er damit genau gemeint hat.

01:12:02.060 --> 01:12:03.600
Nee, ich verstehe das, dass er sagt, ich kann

01:12:03.600 --> 01:12:05.320
zum Beispiel, in Python ist es schwierig,

01:12:05.700 --> 01:12:07.540
kontrollierbar schlanke Prozesse zu bauen.

01:12:08.560 --> 01:12:09.520
Das geht nicht so ohne

01:12:09.520 --> 01:12:11.860
weiteres. Also das geht schnell, dass dein,

01:12:12.540 --> 01:12:13.140
wenn du zum Beispiel

01:12:13.140 --> 01:12:15.480
eine Datenverarbeitungspipeline hast mit

01:12:15.480 --> 01:12:17.580
neun oder zehn Schritten und jeder

01:12:17.580 --> 01:12:19.080
Schritt davon braucht irgendwie

01:12:19.080 --> 01:12:21.460
einen Gigabyte RAM, dann kann das

01:12:21.460 --> 01:12:23.580
schon sein, dass dein Python nachher zehn Gig frisst.

01:12:24.800 --> 01:12:25.620
Weil er halt eben

01:12:25.620 --> 01:12:27.540
den Speicher von vorher noch nicht freigegeben

01:12:27.540 --> 01:12:29.460
hatte, der jetzt aber auch gerade nicht gepasst hat, um das

01:12:29.460 --> 01:12:31.080
nächste Ding zu bearbeiten und

01:12:31.080 --> 01:12:33.460
dann so. Das ist halt

01:12:33.460 --> 01:12:35.700
das kriegst du unter Python halt nicht gut kontrolliert.

01:12:36.460 --> 01:12:37.780
Ja, vor allem, weil alles so dynamisch ist,

01:12:37.840 --> 01:12:39.760
weil ich also im Zweifel auch wirklich den Stack hochwandern

01:12:39.760 --> 01:12:41.300
kann und schauen kann, was da rumliegt oder

01:12:41.300 --> 01:12:43.720
ein Integer-Objekt als beliebiges Objekt sehen

01:12:43.720 --> 01:12:45.800
kann, was halt in Rust ohne weiteres nicht möglich ist

01:12:45.800 --> 01:12:47.100
und auch in anderen Poemischsprachen nicht geht.

01:12:49.060 --> 01:12:49.680
Aber auch

01:12:49.680 --> 01:12:51.800
ohne Speicherverwaltung kann ich ja in Python

01:12:51.800 --> 01:12:53.580
durchaus noch andere Sicherheitslücken machen,

01:12:53.700 --> 01:12:55.200
die also gar nichts mit dem Speicher zu tun haben,

01:12:55.200 --> 01:12:57.260
mit dem, was wir jetzt die meiste Zeit

01:12:57.260 --> 01:12:59.240
besprochen haben, sondern halt zum Beispiel, dass ich sage,

01:12:59.380 --> 01:13:00.760
ich verwende den Subprozess

01:13:00.760 --> 01:13:02.780
und öffne den Subprozess und

01:13:02.780 --> 01:13:05.860
übergebe einen String

01:13:05.860 --> 01:13:07.760
und habe diesen String halt

01:13:07.760 --> 01:13:09.780
konstruiert aus Benutzerdaten und

01:13:09.780 --> 01:13:11.540
jetzt habe ich plötzlich eine Command Injection,

01:13:11.580 --> 01:13:13.700
dass man beliebige Shell-Commandos ausführen kann.

01:13:15.240 --> 01:13:15.920
Das kann man

01:13:15.920 --> 01:13:17.180
in jeder Programmiersprache

01:13:17.180 --> 01:13:19.900
und in jeder Programmiersprache

01:13:19.900 --> 01:13:21.280
die Shell-Commandos ausführen kann. Natürlich kannst du

01:13:21.280 --> 01:13:23.640
dich auf den Standpunkt stellen, okay, man hat

01:13:23.640 --> 01:13:25.540
das gefälligst nicht zu machen oder man hat

01:13:25.540 --> 01:13:27.360
gefälligst immer Shell gleich freuds zu setzen

01:13:27.360 --> 01:13:29.260
oder das ist ja der Standard, also dass man eine Liste

01:13:29.260 --> 01:13:31.360
übergibt, aber

01:13:31.360 --> 01:13:33.820
das sind die, also es gibt noch

01:13:33.820 --> 01:13:35.700
zahlreiche andere Schwachstellen, glaube ich, die

01:13:35.700 --> 01:13:37.880
in höheren, auf höherem

01:13:37.880 --> 01:13:39.820
Level noch passieren können, die gar nichts mit dem Speicher direkt

01:13:39.820 --> 01:13:40.300
zu tun haben.

01:13:42.060 --> 01:13:43.820
Ja, absolut, genau, was habt

01:13:43.820 --> 01:13:45.880
ihr, habt ihr schon mal böse Sachen gesehen,

01:13:45.960 --> 01:13:47.360
die in Python schiefgegangen sind?

01:13:48.780 --> 01:13:50.080
Ich weiß nicht, ich überlege

01:13:50.080 --> 01:13:51.180
gerade, ob ich irgendwas mal

01:13:51.180 --> 01:13:53.320
wirklich Schlimmes gesehen habe.

01:13:53.800 --> 01:13:55.980
Django Rackaxe. Der Shellout,

01:13:56.020 --> 01:13:57.240
den Philipp da nennt, das ist halt ganz klassisch.

01:13:57.240 --> 01:13:59.640
Ja, das ist schon schlimm. Das ist ganz klassisch.

01:14:00.040 --> 01:14:02.100
Auch sehr beliebt ist, wenn Leute

01:14:02.100 --> 01:14:03.880
meinen, ich muss hier Flexibilität reinbringen

01:14:03.880 --> 01:14:05.740
und jagen halt irgendwie User-Input einfach durch

01:14:05.740 --> 01:14:07.460
einen E-Val durch. Das ist sozusagen

01:14:07.460 --> 01:14:09.660
die interne Variante des Shell-Outs.

01:14:09.960 --> 01:14:11.020
Was ist denn ein E-Val?

01:14:11.420 --> 01:14:13.040
E-Val, ja, okay, Entschuldigung.

01:14:13.680 --> 01:14:15.580
Ja, Funktion. E-Val ist Evil.

01:14:16.680 --> 01:14:17.640
Aber das ist im Prinzip die

01:14:17.640 --> 01:14:20.060
Oh ja, doch, Pickle.

01:14:20.360 --> 01:14:20.800
Ei, ei, ei.

01:14:22.060 --> 01:14:23.920
Ja, Pickle, nur trusted.

01:14:25.340 --> 01:14:26.020
Da kann man sich

01:14:26.020 --> 01:14:26.920
auch schon mit dem Fuß schießen.

01:14:27.220 --> 01:14:29.440
Mit E-Val hat man sogar einen ganz, ganz schlimmen Bug.

01:14:29.560 --> 01:14:31.240
Und zwar hat eine Anwendung auf die Idee gekommen,

01:14:31.580 --> 01:14:33.320
dass man doch das cachen könnte.

01:14:33.960 --> 01:14:36.200
Und man könnte doch den Code nehmen

01:14:36.200 --> 01:14:37.720
und dann kann man sich so ein kurzes...

01:14:37.720 --> 01:14:39.080
Also man nimmt irgendwelche Benutzerdaten,

01:14:39.520 --> 01:14:40.560
die oftmals abgerufen werden.

01:14:40.940 --> 01:14:42.740
Dann schreibt man dynamisch Python-Code,

01:14:43.360 --> 01:14:44.300
der das ausführt.

01:14:44.620 --> 01:14:45.420
Und dann kann man das cachen.

01:14:45.880 --> 01:14:46.800
Und dann war aber das Problem,

01:14:46.960 --> 01:14:48.940
dass sogar die noch eine Datenbank-Schwarstelle hatten,

01:14:49.040 --> 01:14:51.340
dass man sehen konnte, was in der Datenbank lag

01:14:51.340 --> 01:14:52.600
und da lagen deren Cache-Objekte.

01:14:52.960 --> 01:14:54.560
Und dann lagen da plötzlich Benutzer-Passwörter

01:14:54.560 --> 01:14:56.960
oder sonst irgendwelche Sachen.

01:14:57.980 --> 01:14:59.560
Also da kann man halt, wenn man

01:14:59.560 --> 01:15:01.460
Schwachstellen verkettet, kann man das

01:15:01.460 --> 01:15:03.980
auf sehr krumme,

01:15:05.180 --> 01:15:06.000
sehr fiese

01:15:06.000 --> 01:15:07.820
Sachen, die man mit einer einzelnen Schwachstelle gar nicht machen

01:15:07.820 --> 01:15:09.840
könnte. Also das war jetzt nicht

01:15:09.840 --> 01:15:11.480
der Fehler von denen, dass sie, also es war

01:15:11.480 --> 01:15:13.240
ein Fehler, dass man den Cache

01:15:13.240 --> 01:15:15.780
plötzlich sehen kann. Und es war ein anderer Fehler,

01:15:15.940 --> 01:15:17.380
dass sie überhaupt Eval verwendet haben.

01:15:17.740 --> 01:15:19.660
Aber erst durch die Kombination ist es halt eigentlich eine

01:15:19.660 --> 01:15:20.300
Schwachstelle gewesen.

01:15:21.240 --> 01:15:23.780
Auch so ein klassisches Ding ist auch Directory Traversal.

01:15:24.300 --> 01:15:25.480
Dass halt irgendwie

01:15:25.480 --> 01:15:27.540
von außen sagen kannst, ich will XYZ

01:15:27.540 --> 01:15:29.640
haben und dann wird halt nicht ordentlich

01:15:29.640 --> 01:15:31.320
geguckt, ob du durch Punkt-Punkt-Slash

01:15:31.320 --> 01:15:33.240
Kombinationen plötzlich dir dann irgendwie

01:15:33.240 --> 01:15:35.640
ETC-Pass-Videos und so ein Kram halt auslesen lassen kannst

01:15:35.640 --> 01:15:37.680
und das sind immer auch, das ist

01:15:37.680 --> 01:15:39.100
tatsächlich, glaube ich, am wichtigsten

01:15:39.100 --> 01:15:41.000
und deswegen ist dieses, das ist wieder

01:15:41.000 --> 01:15:43.360
Variety matches Variety, deswegen

01:15:43.360 --> 01:15:45.660
sagen wir, wir wollen so schnell so viele

01:15:45.660 --> 01:15:47.540
Verbesserungen in der Security wie

01:15:47.540 --> 01:15:49.600
möglich durch unsere Entwicklungspipeline jagen können,

01:15:50.360 --> 01:15:50.740
weil

01:15:50.740 --> 01:15:53.260
die eigentlichen Vektoren ist nachher, dass

01:15:53.260 --> 01:15:55.120
du hast immer eine Vielzahl von

01:15:55.120 --> 01:15:57.260
Vielzahl von potenziellen Schwachstellen,

01:15:57.380 --> 01:15:59.100
die für sich genommen alle gar nicht so schlimm

01:15:59.100 --> 01:16:01.120
sind. Und wenn du aber immer

01:16:01.120 --> 01:16:03.040
nur auf der Suche nach dem einen großen Ding

01:16:03.040 --> 01:16:04.720
bist, um alles zu reparieren,

01:16:05.120 --> 01:16:07.120
dann vergisst man schnell, dass es halt eher um diese

01:16:07.120 --> 01:16:08.280
Verkettung geht, wie Philipp sagt.

01:16:08.800 --> 01:16:10.860
Da gibt es viele Kleinigkeiten, die das halt machen.

01:16:11.000 --> 01:16:13.240
Also eben Directory Traversal, irgendwie Daten abzusaugen,

01:16:13.280 --> 01:16:14.940
die dir dann einfach nur noch den Pointer geben für

01:16:14.940 --> 01:16:16.640
ah, guck mal, da könntest du da drüben nochmal gucken.

01:16:17.840 --> 01:16:19.000
Ein Klassiker, den ich mag,

01:16:19.100 --> 01:16:20.000
sind Exceptions.

01:16:21.260 --> 01:16:23.300
Exceptions sind für mich die sensibelsten

01:16:23.300 --> 01:16:25.020
Daten, die dein System zur Laufzeit

01:16:25.020 --> 01:16:26.300
eigentlich von sich gibt.

01:16:27.660 --> 01:16:29.440
Weil das Problem ist ja folgendes.

01:16:29.740 --> 01:16:31.960
Dein System ist in einem nicht bekannten Zustand

01:16:31.960 --> 01:16:34.560
mit Daten, die du nicht kennst

01:16:34.560 --> 01:16:36.740
und weißt nicht mehr, was es tun soll.

01:16:37.960 --> 01:16:40.660
Und die Daten können halt alles sein.

01:16:40.880 --> 01:16:42.640
Das können die Kreditkartendaten sein,

01:16:42.740 --> 01:16:43.900
das können die was auch immer.

01:16:44.020 --> 01:16:45.320
Und dann steht da irgendwie Value Error.

01:16:45.380 --> 01:16:46.120
Hast du nicht gesehen?

01:16:46.920 --> 01:16:48.840
Und du kannst den User nicht davon abhalten,

01:16:48.980 --> 01:16:50.380
Daten ins falsche Feld zu schreiben.

01:16:50.760 --> 01:16:52.600
Dann schreibt er seine Kreditkartendaten

01:16:52.600 --> 01:16:54.760
halt das erste Mal irgendwie bei seinem Nachnamen aus Versehen

01:16:54.760 --> 01:16:56.520
rein. Und deswegen diese

01:16:56.520 --> 01:16:58.580
Bewertung von, was ist eigentlich sicher und was

01:16:58.580 --> 01:16:59.860
ist unsicher, ist total schwer.

01:17:00.880 --> 01:17:02.680
Das Paradigma sollte auch

01:17:02.680 --> 01:17:04.460
eher sein, lieber ein bisschen

01:17:04.460 --> 01:17:06.600
zu sensibel zu sein und sozusagen

01:17:06.600 --> 01:17:08.760
dein Schutzniveau einmal grob

01:17:08.760 --> 01:17:10.140
festzulegen und zu sagen, okay,

01:17:10.520 --> 01:17:12.020
wir gehen ja mit Kreditkartendaten um.

01:17:12.660 --> 01:17:14.560
Du musst davon ausgehen, dass irgendein

01:17:14.560 --> 01:17:16.580
doofer User, nein, die User sind nicht doof.

01:17:17.120 --> 01:17:18.800
Das Problem, es ist ein Usability-Problem.

01:17:18.800 --> 01:17:20.760
Das Usability-Problem ist, dass wir halt ein Gehirn

01:17:20.760 --> 01:17:21.780
haben, was bekloppt ist.

01:17:22.600 --> 01:17:49.780
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. Und das Pattern Matching von unserem Gehirn ist auch nicht Best Match, sondern First Match. Das heißt, du hast eine Seite vor dir, hast aus deinem Passwortmanager deine Kreditkartennummer kopiert, dein Kind will was von dir, ja bitte, ich muss nur noch, klick, klick, klick und dann hast du halt deine Kreditkartennummer in das falsche Feld eingetragen.

01:17:49.780 --> 01:18:12.480
So, und das ist halt, wie man bei Microsoft damals, alle zwei Millionen Mal, ja, das ist bei uns halt nächsten Dienstag. Und sowas, und deswegen sagen wir auch, wenn wir Anwendungen dann mit Schutzniveaus belegen und sagen, was macht man hier, dann gucken wir eigentlich nur noch nach dem Worst Case und sagen so, jetzt müssen wir davon ausgehen, dass das ganze Ding mit dem Niveau geschützt werden muss.

01:18:12.480 --> 01:18:19.080
Weiter differenzieren macht überhaupt keinen Sinn mehr, weil du kommst dann von Hölzchen zu Stöckchen und irgendwer greift eh daneben.

01:18:19.540 --> 01:18:24.180
Und deswegen bin ich immer sensibel drum, wenn es darum geht, so Exceptions an externe Systeme weiterzuleiten,

01:18:24.880 --> 01:18:31.740
weil im Prinzip übergibst du jemandem Externes alle deine Daten, weil du ja gar nicht weißt, was in der Exception drin ist.

01:18:31.800 --> 01:18:36.420
Wenn du es gewusst hättest, hättest du halt schon irgendwas geschrieben, damit die nicht auftritt.

01:18:38.640 --> 01:18:42.380
Wie bekommst du dann mit, wenn eine Exception passiert? Also an irgendein System muss das ja weitergeleitet werden.

01:18:42.480 --> 01:19:11.640
Ja, internes System. Also ich meine, wir, also, ich habe mich hier heute jetzt noch nicht wieder vorgestellt, ich bin ja so ein bisschen Stammgast schon. Philipp und ich, wir kennen uns noch nicht, ja. Wir betreiben halt Systeme auf eigenen, wir sind ein eigener sozusagen Cloud-Anbieter in der Hinsicht und haben die Infrastruktur und wir machen das auch so, dass wir halt zwischen den unterschiedlichen Locations, die wir haben, halt entweder verschlüsselt Sachen weiterreichen oder eben lieber Dienste dezentral überall lokal nochmal vorhalten und dann musst du halt selber noch eine Greylock-Instanz da haben.

01:19:11.640 --> 01:19:18.500
Und wenn man das heutzutage alles vernünftig ein bisschen automatisiert, dann lässt er halt noch eine Greylock-Instanz raus und kann sie dann da einfüttern.

01:19:19.940 --> 01:19:21.120
Was ist Greylock, Christian?

01:19:21.760 --> 01:19:23.760
Das ist ein Log-Aggregationssystem.

01:19:23.960 --> 01:19:30.460
Also den kannst du mit Log-Daten befüttern und ihn dann nachher Parser drüber jagen lassen und dir automatisch Alerts schicken.

01:19:31.020 --> 01:19:34.760
Das ist auch so ein Ding, da spielen wir gerade zum Beispiel mit rum für so Threat-Themen.

01:19:35.420 --> 01:19:38.680
Der kann aus Log-Daten IP-Adressen rauspopeln.

01:19:40.460 --> 01:19:53.300
und der technische Begriff für Parsen, und hatte 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.840 --> 01:20:07.500
Und dann kann ich die Auswertung dann wieder zurückfüttern auf meine Firewall vorne und kann sagen, so, und immer wenn irgendwie eine IP, die den Threat Indicator hat, irgendwie öfter als so und so oft pro Stunde vorkommt, dann wird die jetzt erstmal für drei Tage lahmgelegt.

01:20:07.680 --> 01:20:34.280
Ah, 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 löst er diese Anfrage aus. Ich glaube, da gab es auch schon mal Virenscanner, 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, sofort blocken wir alles von diesem Rechner und dann geht nichts mehr.

01:20:34.700 --> 01:20:48.400
Ja, genau. Da muss man immer mit vorsichtig sein und nichtsdestotrotz so ein bisschen mit so Sachen experimentieren, weil halt gerne mal rumzugucken, wie sie aussehen und dann willst du halt immer noch die Möglichkeit haben, nochmal durchgreifen zu können in dem Moment, klar.

01:20:48.400 --> 01:20:57.540
Ja, aber ich meine, das ist, macht das auch solche Sachen wie, weil ich kenne das eigentlich eher so als, es gibt immer, entweder verwenden Leute diesen Kibana-Stack oft.

01:20:58.560 --> 01:21:00.260
Kibana hört sich nach Kibakirsch-Banane an.

01:21:00.760 --> 01:21:12.300
Ja, es schmeckt nicht so gut wie Kirsche oder Banane, leider. Aber klingt auch lustig, ja, nee, das ist so irgendwie Elasticsearch und also diese Richtung.

01:21:12.460 --> 01:21:14.400
aber da werfen Leute auch Logdaten rein

01:21:14.400 --> 01:21:15.660
oder halt eben Greylock oder

01:21:15.660 --> 01:21:18.440
manche machen das auch mit Postgres oder

01:21:18.440 --> 01:21:20.540
aber ich meine jetzt für Python

01:21:20.540 --> 01:21:21.760
speziell, da gibt es dann irgendwie so

01:21:21.760 --> 01:21:24.580
Sentry oder Bugsnack

01:21:24.580 --> 01:21:26.480
oder so, wo die Tracebacks halt gesammelt

01:21:26.480 --> 01:21:28.300
werden. Kann man sowas eigentlich auch

01:21:28.300 --> 01:21:30.240
gut selber hosten, weil das habe ich jetzt tatsächlich

01:21:30.240 --> 01:21:32.360
verwendet, aber ich kenne es auch immer nur, dass man

01:21:32.360 --> 01:21:33.640
da externe Services verwendet.

01:21:34.040 --> 01:21:36.060
Kein Problem, Sentry kann man ohne Problem, ist auch ein

01:21:36.060 --> 01:21:38.360
Source-Projekt, kann man ganz normal selber hosten.

01:21:39.320 --> 01:21:40.640
Kommt ja auch selber aus der Python-Ecke,

01:21:40.640 --> 01:21:43.120
Ist, glaube ich, auch Django unten drunter oder so.

01:21:43.180 --> 01:21:43.860
Ich bin mir gar nicht mehr sicher.

01:21:44.120 --> 01:21:45.080
Ja, war es mal.

01:21:45.140 --> 01:21:46.200
Aber stimmt, ist auch, genau.

01:21:46.620 --> 01:21:47.340
Vielleicht nicht mehr.

01:21:48.120 --> 01:21:50.460
Century ist ja relativ groß geworden tatsächlich, Armin und so.

01:21:51.060 --> 01:21:54.340
Und die kannst du selber hosten tatsächlich an der Stelle.

01:21:54.900 --> 01:21:56.320
Das würde ich dann auch immer empfehlen.

01:21:57.900 --> 01:22:02.420
Wichtig ist sozusagen der Unterschied von der Log Aggregation

01:22:02.420 --> 01:22:04.780
versus Exception Logging.

01:22:05.540 --> 01:22:08.040
Exception Logging hat die große Aufgabe,

01:22:08.500 --> 01:22:10.540
wenn du viel vom Gleichen

01:22:10.540 --> 01:22:12.400
entgegenkriegst, weil irgendwie der eine

01:22:12.400 --> 01:22:14.320
backt gerade 50.000 Mal im letzten

01:22:14.320 --> 01:22:16.000
Tag auf, dann willst du, dass der dir die

01:22:16.000 --> 01:22:18.580
schon normalisiert und sagt, hier, das Problem

01:22:18.580 --> 01:22:20.440
gab es jetzt in 50.000 Instanzen,

01:22:20.540 --> 01:22:22.180
hier sind die Parameter, die ich gesehen habe.

01:22:23.040 --> 01:22:24.300
Logging macht natürlich immer nur,

01:22:24.920 --> 01:22:26.280
hier ist der Hydrant, hier kommt

01:22:26.280 --> 01:22:27.000
alles raus.

01:22:31.280 --> 01:22:31.960
Ja, interessant.

01:22:32.720 --> 01:22:34.180
Da gibt es also viele verschiedene Typen von

01:22:34.180 --> 01:22:36.280
Angriffen, die man irgendwie mit verschiedenen

01:22:36.280 --> 01:22:38.260
Typen von Verteidigungsmaßnahmen beantworten

01:22:38.260 --> 01:22:40.540
möchte, können muss,

01:22:41.720 --> 01:22:42.260
probieren kann.

01:22:44.400 --> 01:22:45.080
Sollen wir uns mal

01:22:45.080 --> 01:22:46.480
unbeliebt machen? Oder ich mach mich unbeliebt.

01:22:47.820 --> 01:22:49.120
Wir, ein Scanner oder sowas.

01:22:49.240 --> 01:22:50.760
Ich meine, was Leute immer so machen, wenn sie zu Hause,

01:22:50.940 --> 01:22:51.460
ich meine, vielleicht,

01:22:51.900 --> 01:22:55.140
sehr beliebt,

01:22:55.260 --> 01:22:56.540
aber irgendwie glaube ich zum Beispiel,

01:22:56.640 --> 01:22:57.800
das bringt alles nix.

01:22:59.900 --> 01:23:01.140
Vor allem müssen die ganz viel

01:23:01.140 --> 01:23:03.280
mit Speicher machen und ganz viel

01:23:03.280 --> 01:23:05.160
Level erarbeiten. Genau, das, was man eigentlich nicht haben will.

01:23:06.340 --> 01:23:07.340
Also wo ich es noch sehe,

01:23:07.420 --> 01:23:09.240
wo ich noch mitspiele, ist, wo wir es

01:23:09.240 --> 01:23:11.180
gern haben, wo es angefragt wird

01:23:11.180 --> 01:23:13.120
und dem nicht harsch

01:23:13.120 --> 01:23:15.320
widersprechen, ist,

01:23:15.560 --> 01:23:16.760
wenn du sozusagen tatsächlich

01:23:16.760 --> 01:23:19.300
sowas hast wie, deine Anwendung nimmt Daten

01:23:19.300 --> 01:23:21.300
per Mail oder Upload entgegen und du weißt,

01:23:21.380 --> 01:23:23.220
die werden dann nachher auf eher schlecht

01:23:23.220 --> 01:23:25.160
gepflegten Rechnern wieder weiterverarbeitet.

01:23:25.780 --> 01:23:27.180
Also wir haben so ein Kram, wo dann

01:23:27.180 --> 01:23:29.200
irgendwie, keine Ahnung, Wordfiles reinkommen und die sollen

01:23:29.200 --> 01:23:30.860
dann von irgendeiner dritten Partei auf ihrem

01:23:30.860 --> 01:23:32.640
Windows-Rechner verarbeitet werden.

01:23:33.320 --> 01:23:34.860
Dann habe ich halt mal einen

01:23:34.860 --> 01:23:37.060
Klamm-AV da mit drauf sitzen, der halt

01:23:37.060 --> 01:23:39.020
diese eine Datei scannt, aber das ist

01:23:39.020 --> 01:23:41.320
dann kein Ding, was das System scannt,

01:23:41.640 --> 01:23:42.600
sondern es ist bloß ein Programm.

01:23:42.980 --> 01:23:45.100
Hier scannt die eine Datei, du sagst, ja, okay,

01:23:45.180 --> 01:23:46.980
dann geben wir die weiter und wenn nicht, dann

01:23:46.980 --> 01:23:48.960
sperren wir sie halt zur Seite. Das ist

01:23:48.960 --> 01:23:51.280
eine Form von Virenscanner, da spiele ich punktuell

01:23:51.280 --> 01:23:53.060
halt noch mit. Das kann man

01:23:53.060 --> 01:23:55.020
schon mal machen. Was ich halt nicht leiden

01:23:55.020 --> 01:23:57.000
kann, sind diese Security-Suites,

01:23:57.060 --> 01:23:58.980
die dann irgendwie einen Rechner irgendwie übernehmen

01:23:58.980 --> 01:24:00.720
und irgendwie mehr Schaden machen als

01:24:00.720 --> 01:24:02.680
also gut, ich meine, da braucht man bloß

01:24:02.680 --> 01:24:04.660
Fefe lesen, da kriegst du es halt alle zwei Wochen wieder

01:24:04.660 --> 01:24:06.700
serviert, Schlangenöl und so.

01:24:07.060 --> 01:24:10.760
ein gutes Konzept

01:24:10.760 --> 01:24:12.320
was ich eben noch

01:24:12.320 --> 01:24:14.300
kurz erwähnt hatte, was ich mir ja noch irgendwann

01:24:14.300 --> 01:24:16.400
drüber gestolpert bin, was bei Django eine

01:24:16.400 --> 01:24:18.220
DOS-Attacke möglich war, und zwar

01:24:18.220 --> 01:24:20.620
bei Regex, die benutzt worden ist

01:24:20.620 --> 01:24:22.460
um bestimmte Formularfelder auszulesen

01:24:22.460 --> 01:24:24.380
das heißt man konnte einfach, indem man

01:24:24.380 --> 01:24:26.460
in Formulare, ich glaube E-Mail oder so

01:24:26.460 --> 01:24:28.480
einen cleveren Regex reingeschrieben hat

01:24:28.480 --> 01:24:30.400
irgendwie eine

01:24:30.400 --> 01:24:32.620
exponentiell wachsende oder Endlosschleife

01:24:32.620 --> 01:24:34.600
produzieren und dann damit die Seite

01:24:34.600 --> 01:24:36.540
man kann Regex

01:24:36.540 --> 01:24:38.620
zu bauen, die sehr, sehr langsam werden dann.

01:24:38.900 --> 01:24:39.060
Genau.

01:24:39.900 --> 01:24:42.580
Dann hat man einfach ganz viele Requester dran geschickt und dann hat man halt die Seite

01:24:42.580 --> 01:24:44.600
in die Knie ziehen können. Das haben die irgendwann gefixt.

01:24:44.680 --> 01:24:46.520
Ich glaube auch relativ spät, erst bei einer Zweier-Version,

01:24:46.640 --> 01:24:47.680
wenn ich das richtig bekommen habe.

01:24:48.880 --> 01:24:50.360
Sehr interessant, solche Sachen. Also das

01:24:50.360 --> 01:24:52.460
denkt man immer, jemand, der keine Ahnung hat, nicht dran,

01:24:52.860 --> 01:24:54.660
dass in so einfachen

01:24:54.660 --> 01:24:56.640
Bibliotheken wie RegEx da was Tolles hinterstehen

01:24:56.640 --> 01:24:58.560
kann. Ich glaube, was ist das? Perl RegEx oder wie

01:24:58.560 --> 01:25:00.580
nennt man das? Diese Perl Compatible

01:25:00.580 --> 01:25:02.440
RegEx, also PCIe, aber ich

01:25:02.440 --> 01:25:04.640
weiß nicht, ob das...

01:25:04.640 --> 01:25:06.440
Das ist nicht in Python. Die Python-Regex-Engine

01:25:06.440 --> 01:25:07.200
ist eine eigene.

01:25:08.380 --> 01:25:10.380
Also moderne Regex-Engines können schon

01:25:10.380 --> 01:25:11.960
nicht alle Fälle, aber viele Fälle

01:25:11.960 --> 01:25:14.420
da besser erkennen und haben dann

01:25:14.420 --> 01:25:16.360
auch bessere Garantien, also nicht erkennen,

01:25:16.480 --> 01:25:18.380
aber haben Garantien, dass das halt nicht

01:25:18.380 --> 01:25:20.560
in diesen exponentiellen Fall läuft. Natürlich nicht immer.

01:25:20.920 --> 01:25:22.640
Und natürlich kann ich immer ein Regex produzieren,

01:25:22.720 --> 01:25:24.440
der einfach so lange dauert, weil ich einfach

01:25:24.440 --> 01:25:26.340
sage, okay, hier kommt irgendwas Beliebiges

01:25:26.340 --> 01:25:27.880
und das darf beliebig oft vorkommen.

01:25:28.260 --> 01:25:30.120
Und wenn ich da einen langen String habe, dann ist es halt total,

01:25:30.620 --> 01:25:31.480
dann gibt es

01:25:31.480 --> 01:25:34.080
natürlich exponentiell viele Möglichkeiten,

01:25:34.640 --> 01:25:37.860
wie ich das Matching

01:25:37.860 --> 01:25:40.020
nehmen kann. Und wenn ich den String so konstruiere, dass das Matching

01:25:40.020 --> 01:25:42.040
nie passiert, dann dauert

01:25:42.040 --> 01:25:43.860
es halt ewig. Also unendlich

01:25:43.860 --> 01:25:45.380
nicht, aber schon mal länger ist das Universum.

01:25:47.320 --> 01:25:48.140
So, ich mach ja mal

01:25:48.140 --> 01:25:49.760
kurz, wir müssen die Chapter-Mark hier ziehen.

01:25:50.500 --> 01:25:51.420
Ich muss jetzt raus.

01:25:51.860 --> 01:25:52.780
Ihr könnt mich rausschneiden.

01:25:53.380 --> 01:25:55.860
Ich kann jetzt raus, du kannst einfach Tschüss sagen.

01:25:56.480 --> 01:25:57.760
Ja, wir haben eine Sekunde Pause gehabt,

01:25:57.820 --> 01:25:58.560
das könnt ihr rausschneiden.

01:25:59.640 --> 01:26:00.180
Alles klar.

01:26:01.180 --> 01:26:02.620
Tschüss, vielen Dank, dass du da warst.

01:26:02.640 --> 01:26:03.980
Bis zur Fortsetzung demnächst mal wieder.

01:26:04.640 --> 01:26:05.560
Viel Spaß, bis dann. Ciao.

01:26:08.620 --> 01:26:09.020
Ja.

01:26:10.580 --> 01:26:12.260
Haben wir denn zu dem

01:26:12.260 --> 01:26:13.980
Security-Thema noch irgendwie,

01:26:14.520 --> 01:26:16.160
ich weiß nicht genau, irgendwelche Dinge,

01:26:16.420 --> 01:26:18.300
die wir unbedingt erzählen

01:26:18.300 --> 01:26:18.860
wollten, oder?

01:26:20.240 --> 01:26:21.000
Ja, also,

01:26:22.220 --> 01:26:23.940
mir fallen noch einige Sachen ein, aber frage ich erst mal euch weiter.

01:26:24.040 --> 01:26:26.260
Was geht's denn, Philipp fragen wir nochmal. Was wolltest du denn noch

01:26:26.260 --> 01:26:26.960
erzählen zu Security?

01:26:29.160 --> 01:26:29.920
Es gibt, also,

01:26:30.060 --> 01:26:32.100
was vielleicht wichtig ist,

01:26:32.100 --> 01:26:33.920
dass man eine Funktion

01:26:33.920 --> 01:26:36.100
nimmt, oder eine Standardmöglichkeit

01:26:36.100 --> 01:26:37.500
nimmt, um sich gegen die Sicherheit

01:26:37.500 --> 01:26:40.000
Schwachstädte zu verteidigen. Also wir haben eben schon

01:26:40.000 --> 01:26:41.840
Path Traverses angesprochen, da könnt ihr mal denken,

01:26:41.980 --> 01:26:43.980
okay, also bei Path Traverses ist das Problem,

01:26:44.080 --> 01:26:45.800
dass ich irgendwas in den Pfad einschleuse,

01:26:45.940 --> 01:26:45.940
typischerweise halt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

01:26:45.940 --> 01:26:50.660
typischerweise halt ... um halt aus dem Pfad der Anwendung rauszukommen

01:26:50.660 --> 01:26:53.240
und dann statt eine lokale Datei der Anwendung zu lesen,

01:26:53.320 --> 01:26:55.660
bekomme ich halt eine Datei irgendwo aus dem System.

01:26:56.180 --> 01:26:59.240
Weiß nicht, die Passwortdatei oder die Datenbankdatei oder irgendwas anderes.

01:26:59.740 --> 01:27:02.960
Und eine Möglichkeit, um sich dagegen zu verteidigen, ist natürlich zu sagen,

01:27:03.060 --> 01:27:06.660
ich nehme immer alle Punkte raus oder so oder alle Slashes raus.

01:27:07.040 --> 01:27:10.160
Und dann kommt man halt auf andere Systeme, zum Beispiel unter Windows,

01:27:10.160 --> 01:27:11.640
da ist ja ein Doppelpunkt wichtig.

01:27:12.020 --> 01:27:14.260
Und dann muss man auch an den denken und dann ist der Backslash wichtig.

01:27:14.800 --> 01:27:17.200
Und es ist halt sehr schwierig, sowas richtig zu schreiben.

01:27:17.320 --> 01:27:18.420
Da gibt es immer wieder Leute, die es versuchen.

01:27:18.760 --> 01:27:20.260
Die sagen, ja, ich weiß es trotzdem.

01:27:20.700 --> 01:27:22.040
Und bei einigen Systemen geht das auch.

01:27:22.260 --> 01:27:28.080
Also man kann zum Beispiel bei SQL Injection kann man relativ einfach vermeiden,

01:27:28.240 --> 01:27:30.680
weil das halt eigentlich nur ein einfaches Anführungszeichen ist.

01:27:31.140 --> 01:27:34.680
Aber es ist halt immer gut, dann für eine fertige Funktion oder eine fertige Struktur zu nehmen,

01:27:35.060 --> 01:27:36.520
die genau dafür programmiert ist.

01:27:36.520 --> 01:27:41.980
Und die dann auch, zwar die sicher ist, aber die ist halt sicher oder hoffentlich sicher,

01:27:42.320 --> 01:27:44.080
weil es halt nur eine ist. In Python

01:27:44.080 --> 01:27:45.720
zum Beispiel, um Path-Traverse zu verhindern,

01:27:46.080 --> 01:27:48.160
kann man halt os.path.basename

01:27:48.160 --> 01:27:49.420
oder aus der Path-Lib was nehmen,

01:27:49.960 --> 01:27:52.080
statt halt selber zu versuchen,

01:27:52.160 --> 01:27:53.200
diesen String zu bearbeiten.

01:27:53.500 --> 01:27:55.820
Also nicht selber machen, Security war das der...

01:27:55.820 --> 01:27:57.960
Ja, genau. Es sei denn, man weiß,

01:27:58.160 --> 01:28:00.200
was man tut. Also an einigen

01:28:00.200 --> 01:28:01.840
Stellen kann das richtig sein. Und ich glaube,

01:28:01.880 --> 01:28:03.740
ein anderes häufiges Problem ist auch, dass man sagt,

01:28:04.600 --> 01:28:05.880
ich versuche, die Eingaben

01:28:05.880 --> 01:28:06.600
zu früh

01:28:06.600 --> 01:28:09.860
abzufangen. Also dass ich sage, okay,

01:28:09.880 --> 01:28:11.900
ich habe eine ganz komplizierte Anwendung und immer,

01:28:11.900 --> 01:28:38.800
wenn mir jemand was mit einem Anführungszeichen schickt, dann sage ich, geht nicht, ist Fehler oder ich schmeiße das Anführungszeichen raus und das ist natürlich klappt vielleicht, aber dann muss ich halt überall dran denken und es gibt halt verschiedene Kontexte, also wenn ich einen Pfad habe, dann ist halt ein Slash oder ein Backslash ein Problem, wenn ich aber HTML habe, dann ist das kleiner Zeichen oder das doppelte Anführungszeichen ein Problem und so weiter und so fort, das heißt, es ist wichtig, dass man darauf achtet, dass man das in jedem Kontext richtig macht und es ist schwierig zu sagen,

01:28:38.800 --> 01:28:40.760
oder es ist ein häufiger Anfänger vielleicht zu sagen,

01:28:41.040 --> 01:28:42.580
okay, ich gehe davon aus, dass meine Daten

01:28:42.580 --> 01:28:44.440
irgendwie korrekt sind. Das ist dann doch immer

01:28:44.440 --> 01:28:46.840
sehr schwierig, weil man halt ein komplexes

01:28:46.840 --> 01:28:48.500
System hat, vielleicht sogar mit mehreren

01:28:48.500 --> 01:28:50.640
Microservices, die die Daten aus verschiedenen

01:28:50.640 --> 01:28:51.060
Quellen

01:28:51.060 --> 01:28:54.580
anliefern. Aber wenn man darauf vertraut, dass

01:28:54.580 --> 01:28:56.540
die Datenbank irgendwie gute Daten enthält, das ist

01:28:56.540 --> 01:28:58.040
immer sehr, sehr gefährlich.

01:29:02.880 --> 01:29:04.560
Ja, ist interessant, welche Assertions man

01:29:04.560 --> 01:29:06.500
daraus gibt oder welche Dinge man daraus macht, wenn

01:29:06.500 --> 01:29:08.140
das nicht dem erwarteten Standard entspricht oder so.

01:29:08.800 --> 01:29:10.980
ein paar Stolper fallen. Dass man einfach interpretiert,

01:29:11.040 --> 01:29:11.960
was da kommt, ist wahrscheinlich

01:29:11.960 --> 01:29:14.960
eine mittelgültige Idee. Genau, man muss immer misstrauisch sein gegenüber allen Daten.

01:29:15.080 --> 01:29:16.880
Also auch der eigene Datenbank, auch die kann

01:29:16.880 --> 01:29:17.380
Schrott enthalten.

01:29:19.680 --> 01:29:20.520
Okay, guter Tipp.

01:29:21.280 --> 01:29:21.360
Ja.

01:29:23.520 --> 01:29:23.840
Ja.

01:29:24.600 --> 01:29:26.860
Ja, ansonsten, genau, ein Thema, wo ich immer

01:29:26.860 --> 01:29:28.360
denke, das kann doch nicht so schwer sein, aber

01:29:28.360 --> 01:29:30.180
ich tue mich irgendwie schwer damit,

01:29:30.620 --> 01:29:32.580
ist halt, wie authentifiziert man sich eigentlich

01:29:32.580 --> 01:29:34.060
richtig irgendwie

01:29:34.060 --> 01:29:35.680
zum Beispiel per

01:29:35.680 --> 01:29:38.840
einer API per HTTP oder so

01:29:38.840 --> 01:29:41.000
oder die Web-Authentifizierung

01:29:41.000 --> 01:29:42.240
ist irgendwie nicht so einfach.

01:29:43.240 --> 01:29:44.400
Und dann, ja.

01:29:44.700 --> 01:29:46.600
Es gibt ein paar interessante Artikel dazu, die wir

01:29:46.600 --> 01:29:48.500
letztens gelesen hatten, warum

01:29:48.500 --> 01:29:49.360
JBT kaputt ist.

01:29:49.580 --> 01:29:51.340
Ja, JBT sieht nicht gut aus, ja.

01:29:52.340 --> 01:29:54.560
Und dass ja viele Leute nutzen und sagen, das ist der Standard,

01:29:54.660 --> 01:29:56.640
den es da gibt. Und ich habe aber

01:29:56.640 --> 01:29:58.440
auch jetzt auch noch nicht so viel gefunden, was man da anders

01:29:58.440 --> 01:30:00.080
machen kann. Es gibt irgendwie Paseto oder

01:30:00.080 --> 01:30:02.540
PyPaseto, aber da gibt es noch nichts wirklich Nutzbares. Das muss man

01:30:02.540 --> 01:30:04.620
irgendwie auch alles wieder selber machen

01:30:04.620 --> 01:30:06.720
vielleicht und das ist da vielleicht wieder nicht so

01:30:06.720 --> 01:30:08.740
eine gute Idee und da ist es gar nicht so

01:30:08.740 --> 01:30:10.920
einfach, sich vernünftig per Token zu authentifizieren.

01:30:11.240 --> 01:30:12.800
Ja, tatsächlich. Also das, was ich jetzt auch

01:30:12.800 --> 01:30:14.940
ist halt, ja, HTTP-only-Cookies.

01:30:15.740 --> 01:30:15.960
Ja.

01:30:16.620 --> 01:30:18.540
Vielleicht. Also Sessions dann?

01:30:18.780 --> 01:30:20.160
Ja, Sessions, Session-Cookies.

01:30:20.400 --> 01:30:21.320
Ist halt manchmal ein bisschen

01:30:21.320 --> 01:30:23.740
schwierig, aber

01:30:23.740 --> 01:30:26.640
ja, also das ist immer wieder,

01:30:26.780 --> 01:30:28.480
wo ich mir denke, das müsste doch eigentlich jetzt einfach sein,

01:30:28.560 --> 01:30:29.800
aber irgendwie ist es das nicht.

01:30:30.800 --> 01:30:30.900
Ja.

01:30:34.980 --> 01:30:36.600
Tja. Oh, oder hast du

01:30:36.600 --> 01:30:38.700
mal so von Indie

01:30:38.700 --> 01:30:40.540
aufgehört? Also ich meine, das ist halt so eine

01:30:40.540 --> 01:30:42.020
etwas abgespeckte O-Aus-Variante.

01:30:42.940 --> 01:30:44.500
Nee, gar nicht.

01:30:44.600 --> 01:30:46.600
Okay, ja. Was ist das?

01:30:47.480 --> 01:30:48.180
Das ist sozusagen,

01:30:48.800 --> 01:30:49.440
dass man halt

01:30:49.440 --> 01:30:52.600
selber,

01:30:53.140 --> 01:30:53.420
also

01:30:53.420 --> 01:30:56.140
naja, also das ist auch von dem

01:30:56.140 --> 01:30:58.320
von den gleichen, also das hat,

01:30:58.500 --> 01:31:00.540
oh Gott, jetzt muss ich wiederkommen, ich vom Hölzchen aufs

01:31:00.540 --> 01:31:02.500
Stöckchen, das hat was mit dem Indie-Web zu tun,

01:31:02.580 --> 01:31:04.700
das ist so eine Bewegung, um, dass man halt

01:31:04.700 --> 01:31:06.220
die Dinge selber machen kann, die,

01:31:06.600 --> 01:31:08.460
wo man normalerweise immer irgendwelche Unternehmen

01:31:08.460 --> 01:31:09.460
braucht, die das halt machen.

01:31:10.900 --> 01:31:12.460
Und es geht zum Beispiel darum, dass man

01:31:12.460 --> 01:31:14.420
sich mit seiner eigenen Webseite einloggen können will.

01:31:16.260 --> 01:31:18.640
Also nicht Username, Passwort,

01:31:18.720 --> 01:31:20.300
sondern man gibt halt ein URL an

01:31:20.300 --> 01:31:22.440
und dann gibt es halt sozusagen

01:31:22.440 --> 01:31:23.960
einen Hook, wo dann irgendwie man

01:31:23.960 --> 01:31:26.220
sagen kann, wie man

01:31:26.220 --> 01:31:28.380
jetzt, wie man sagt,

01:31:28.460 --> 01:31:30.420
dass man jetzt authentifiziert ist und dann zum Beispiel kann man

01:31:30.420 --> 01:31:31.220
sich dann halt irgendwie

01:31:31.220 --> 01:31:34.460
eine Push-Notification schicken lassen

01:31:34.460 --> 01:31:36.520
aufs Handy. Und dann sagt man

01:31:36.520 --> 01:31:38.200
halt, ja, okay, das war jetzt richtig. Oder man

01:31:38.200 --> 01:31:40.280
kriegst du einfach eine E-Mail geschickt oder so und drückst dann auf

01:31:40.280 --> 01:31:42.280
einen Link und dann...

01:31:42.280 --> 01:31:44.260
Genau, genau, genau. Solche Sachen.

01:31:44.420 --> 01:31:46.240
Und man ist ja sehr frei in der Art, wie man das halt

01:31:46.240 --> 01:31:48.560
dann, wie man diese Authentifizierung

01:31:48.560 --> 01:31:50.200
gestalten kann und das klingt eigentlich

01:31:50.200 --> 01:31:52.280
schon sehr nett, aber...

01:31:53.500 --> 01:31:54.240
Das ist ja sicherlich immer die

01:31:54.240 --> 01:31:56.120
einfachste Lösung, wenn du sagst, ich möchte selber keinen

01:31:56.120 --> 01:31:57.800
Benutzernamen, kein Passwort speichern,

01:31:58.160 --> 01:32:00.160
weil einerseits sind mir die Daten zu sensitiv und ich muss

01:32:00.160 --> 01:32:01.700
genau gucken, wie ich das richtig speichere,

01:32:02.040 --> 01:32:04.060
ist zu sagen, okay, ich mache einfach, ich speichere überhaupt keine

01:32:04.060 --> 01:32:06.740
Benutzernamen, Passwörter und ich verwende irgendein Single-Sign-On-System.

01:32:07.500 --> 01:32:12.820
Du hast ja schon OROS angesprochen oder OpenID Connect ist ja der alternative Standard,

01:32:13.220 --> 01:32:15.280
dass man sagt, okay, jemand anders müsste sich darum kümmern.

01:32:15.860 --> 01:32:19.320
Und dann habe ich zwar diesen anderen Dienst, der irgendwo vielleicht auch in meinem Netzwerk ist

01:32:19.320 --> 01:32:23.540
oder vielleicht sage ich, okay, ich erlaube Login mit Facebook, mit Google, mit Twitter und so weiter, mit GitHub.

01:32:25.100 --> 01:32:28.620
Dann müssen die sich ja darum kümmern und dann bin ich da raus aus der Sache.

01:32:28.680 --> 01:32:29.680
Ich muss kein Passwort speichern.

01:32:30.080 --> 01:32:33.040
Und für den Benutzer ist das ja eigentlich auch nicht schlecht, weil der Benutzer muss kein Passwort wählen.

01:32:33.800 --> 01:32:36.040
Weil wenn der Benutzer ein Passwort wählt, das ist ja auch...

01:32:36.680 --> 01:32:37.160
Nicht so gut.

01:32:37.500 --> 01:32:39.240
Aber das hat auch ein paar Falschstücke wieder.

01:32:39.520 --> 01:32:41.160
Also zum Beispiel, wir hatten jetzt das System,

01:32:41.220 --> 01:32:44.740
dass wir auch so ein OpenID-Connect-Schnittstelle bauen mussten,

01:32:44.920 --> 01:32:48.600
aber wir haben das dann über Django All aus versucht zu implementieren,

01:32:48.680 --> 01:32:50.620
der ja viele davon schon bereitstellt, irgendwie als Pakete.

01:32:50.780 --> 01:32:53.660
Und dann mussten wir aber so einen eigenen Provider dafür bauen,

01:32:53.800 --> 01:32:54.680
weil der, den wir da hatten,

01:32:54.780 --> 01:32:56.040
der hat nicht genau das gemacht, was wir wollen.

01:32:56.040 --> 01:32:57.400
Und ich bin mir nicht sicher,

01:32:57.500 --> 01:32:59.960
ob das, was wir da gebaut haben, alles so gut richtig funktioniert.

01:33:00.140 --> 01:33:01.680
Das wird sich dann irgendwie im Laufe der Zeit zeigen.

01:33:01.840 --> 01:33:04.400
Das müssen wir richtig testen. Mal gucken, ne?

01:33:05.620 --> 01:33:06.860
Beim ersten Pentest, hoffentlich.

01:33:07.060 --> 01:33:08.900
Ja, ja, ja. Oder beim ersten

01:33:08.900 --> 01:33:10.140
Pentest, der ungefragt ist.

01:33:13.980 --> 01:33:16.340
Ja, aber

01:33:16.340 --> 01:33:19.000
was ich vor allen Dingen blöd

01:33:19.000 --> 01:33:20.620
finde bei diesen ganzen OpenIDO

01:33:20.620 --> 01:33:22.900
aus Geschichten auch, ist halt, dass man

01:33:22.900 --> 01:33:24.860
dann halt alles an so bestimmte

01:33:24.860 --> 01:33:26.820
User-Accounts hängt.

01:33:26.980 --> 01:33:28.700
Weiß ich nicht, ob das jetzt GitHub, Twitter oder

01:33:28.700 --> 01:33:30.560
schlimmer noch vielleicht Facebook ist oder so.

01:33:30.880 --> 01:33:32.840
Dann passiert irgendwas Blödes und dann verliert man halt den

01:33:32.840 --> 01:33:34.740
Account und dann verliert man gleichzeitig den Zugang zu ganz

01:33:34.740 --> 01:33:36.900
vielen anderen Sachen. Das ist ja auch

01:33:36.900 --> 01:33:37.880
irgendwie nicht so schön.

01:33:38.760 --> 01:33:41.200
Ja gut, aber dadurch braucht

01:33:41.200 --> 01:33:42.800
der Benutzer halt nur noch ein Kennwort und

01:33:42.800 --> 01:33:44.740
Facebook kann halt sehr, sehr viel bessere Sachen,

01:33:45.120 --> 01:33:46.900
bessere Authentifizierung durchführen, als du es machen

01:33:46.900 --> 01:33:49.020
könntest. Also die schauen halt auf deine IP-Adresse,

01:33:49.240 --> 01:33:50.660
auf deinen Browser, die haben noch ein

01:33:50.660 --> 01:33:52.320
Session-Token, die haben vielleicht auch eine

01:33:52.320 --> 01:33:53.560
Mehrfach-Authentifizierung,

01:33:53.960 --> 01:33:56.700
dass du noch irgendwie auf dem Handy

01:33:56.700 --> 01:33:58.300
was bestätigen musst und

01:33:58.300 --> 01:34:00.700
da gibt es dann eine Partei,

01:34:00.760 --> 01:34:02.320
das musst du nicht alles selber implementieren.

01:34:02.540 --> 01:34:04.760
Wenn du es selber implementierst, hast du...

01:34:04.760 --> 01:34:06.280
Ja, also es gibt wirklich dann einige

01:34:06.280 --> 01:34:07.960
Firmen, die das dann wohl doch

01:34:07.960 --> 01:34:09.980
ernster nehmen, als man manchmal so denkt. Ich war zum Beispiel

01:34:09.980 --> 01:34:12.080
in Mainz irgendwo in den Ausland geflogen, als man das noch

01:34:12.080 --> 01:34:14.080
durfte irgendwie und habe eine

01:34:14.080 --> 01:34:15.980
relativ hohe Überweisung angefordert

01:34:15.980 --> 01:34:18.080
oder durchgeführt. Und auf einmal bekam

01:34:18.080 --> 01:34:20.040
ich dann so einen Anrufer von einem Telefon von der Bank, die meinte so

01:34:20.040 --> 01:34:21.140
ja, hallo,

01:34:21.420 --> 01:34:24.140
wollen Sie das wirklich tun?

01:34:24.900 --> 01:34:25.440
Oder waren Sie das?

01:34:26.080 --> 01:34:27.700
Ja, das war ich. Ja, dann ist ja alles gut.

01:34:28.580 --> 01:34:29.960
Ja, aber das war schon mal nett, dass sie nochmal

01:34:29.960 --> 01:34:31.700
nachgefragt haben, anstatt dass sie einfach eine hohe Summe

01:34:31.700 --> 01:34:33.500
irgendwo hin überweisen oder von irgendwo.

01:34:34.320 --> 01:34:35.680
Das war schon, kann ich so

01:34:35.680 --> 01:34:37.660
unrichtig, dass dann vielleicht

01:34:37.660 --> 01:34:40.020
ein Mensch da nochmal nachguckt, also dass dann solche

01:34:40.020 --> 01:34:42.220
Alerts irgendwie in das System rausgehen, die dann nochmal gucken,

01:34:42.360 --> 01:34:44.260
wenn irgendwas ist. Genau, das

01:34:44.260 --> 01:34:46.260
kann deine Anwendung ja nicht leisten, das möchtest du ja

01:34:46.260 --> 01:34:47.820
normalerweise nicht machen. Du möchtest natürlich anfangen,

01:34:47.980 --> 01:34:50.140
SMS zu verschicken oder was auch immer

01:34:50.140 --> 01:34:52.260
oder solche Überprüfungen

01:34:52.260 --> 01:34:54.020
zu machen und ich glaube, das ist einfacher, wenn man sowas

01:34:54.020 --> 01:34:56.220
zentralisiert und wenn du

01:34:56.220 --> 01:34:57.640
ein Passwort, also

01:34:57.640 --> 01:34:59.840
viele Leute verwenden halt einen Passwortmanager, aber auch

01:34:59.840 --> 01:35:02.020
die, glaube ich, die große Masse an Leuten

01:35:02.020 --> 01:35:04.400
verwendet immer noch in 2020 keinen Passwortmanager,

01:35:04.840 --> 01:35:06.580
sondern haben ein Standardpasswort, was sie dabei

01:35:06.580 --> 01:35:08.820
verwenden. Und wenn dann halt irgendein Katzenforum

01:35:08.820 --> 01:35:10.540
gehackt wird, dann bist du plötzlich dran und dann

01:35:10.540 --> 01:35:12.680
rufen deine Kunden an, warum wurde hier meine Bankseite

01:35:12.680 --> 01:35:14.640
oder was auch immer, welche Seite du anbietest,

01:35:14.960 --> 01:35:16.700
warum wurde die gehackt? Und dann sagst du,

01:35:16.740 --> 01:35:18.580
ja, du hast das gleiche Passwort in deinem Katzenforum

01:35:18.580 --> 01:35:20.600
verwendet. Und die haben halt, wir haben

01:35:20.600 --> 01:35:22.580
die besten Sicherheitsstände, aber das Katzenforum, das ist

01:35:22.580 --> 01:35:24.440
halt nur irgendeine Kiste, die irgendwo

01:35:24.440 --> 01:35:25.820
läuft. Und die ist halt eh,

01:35:26.260 --> 01:35:28.540
da reichen sich die Hacker,

01:35:28.660 --> 01:35:29.520
die wird in der Türklinke,

01:35:30.040 --> 01:35:32.620
drücken sich die Hand, weil da halt so viele Hacker drauf

01:35:32.620 --> 01:35:34.520
sind, dass die sich gegenseitig schon stören

01:35:34.520 --> 01:35:36.480
mit ihren ganzen Exploits auf dem Katzenforum

01:35:36.480 --> 01:35:37.660
und das ist halt ein Problem, was

01:35:37.660 --> 01:35:40.560
du mit dem Sing-It-Sign-On direkt an andere

01:35:40.560 --> 01:35:42.100
Leute verschiebst. Dann muss sich Facebook oder

01:35:42.100 --> 01:35:44.480
Google oder wer auch immer oder dein eigener

01:35:44.480 --> 01:35:46.520
Sing-It-Sign-On-Service muss sich dann

01:35:46.520 --> 01:35:47.020
darum kümmern.

01:35:48.840 --> 01:35:49.200
Ja.

01:35:50.200 --> 01:35:52.360
Ja, ja. Ja, wir haben uns ein paar Sachen, glaube ich, vergessen.

01:35:52.520 --> 01:35:54.020
Also was wäre mit Security jetzt so ganz groß?

01:35:54.340 --> 01:35:56.220
Müsste man ja eigentlich noch über Social Engineering

01:35:56.220 --> 01:35:58.360
reden und ganz andere Geschichten.

01:35:58.740 --> 01:36:00.460
Also ein paar USB-Sticks auf den Parkplatz fallen lassen

01:36:00.460 --> 01:36:02.380
oder sowas und ob man

01:36:02.380 --> 01:36:04.400
Corporate sicher bekommt und wie das halt ist

01:36:04.400 --> 01:36:06.300
so mit, wie man die Leute auditen

01:36:06.300 --> 01:36:08.380
kann und da gibt es ja so Experimente zu.

01:36:09.000 --> 01:36:09.640
Also zum Beispiel

01:36:09.640 --> 01:36:12.240
einige Konzerne verschicken ja dann

01:36:12.240 --> 01:36:14.600
so Test-E-Mails oder Trainings-E-Mails

01:36:14.600 --> 01:36:16.280
regelmäßig, um zu gucken,

01:36:17.160 --> 01:36:18.180
klicken die Leute auf alles,

01:36:18.480 --> 01:36:20.240
was da so ins Mailfach

01:36:20.240 --> 01:36:22.100
flattert und die Antwort ist schon, ja,

01:36:22.280 --> 01:36:24.060
das tun sie. Und dann kann man die halt

01:36:24.060 --> 01:36:26.200
ein bisschen erziehen oder sowas, sodass man die

01:36:26.200 --> 01:36:28.280
Quote davon reduziert und das ist eine ganz spannende.

01:36:29.100 --> 01:36:29.640
Ja, aber

01:36:29.640 --> 01:36:32.420
da würde ich jetzt auch so ganz spontan

01:36:32.420 --> 01:36:34.180
würde ich sagen, naja gut, aber ich meine, dafür sind

01:36:34.180 --> 01:36:36.200
doch die Sachen dafür da, dass man da drauf klickt.

01:36:36.620 --> 01:36:38.080
Also ich meine, das ist ja,

01:36:38.220 --> 01:36:39.820
das kann es ja eigentlich nicht sein, dass man

01:36:39.820 --> 01:36:42.020
irgendwie die Leute dazu erzieht,

01:36:42.140 --> 01:36:43.920
irgendwie sich an komische Regeln zu halten,

01:36:44.140 --> 01:36:46.060
damit die Software bleiben darf.

01:36:46.180 --> 01:36:48.180
Das ist ja irgendwie... Ja gut, da gibt es ja ein ganz

01:36:48.180 --> 01:36:50.100
wichtiges Sicherheitskonzept, was wir noch gar nicht so richtig...

01:36:50.100 --> 01:36:52.040
Doch, wir haben es Schweizer Käse genannt

01:36:52.040 --> 01:36:53.700
oder Defense in Depth, dass ich sage, okay,

01:36:54.640 --> 01:36:56.080
ich sorge dafür, dass auch wenn

01:36:56.080 --> 01:36:57.880
also dem Chef der Firma, der

01:36:57.880 --> 01:37:00.000
schon 60 ist und der

01:37:00.000 --> 01:37:01.840
noch ein bisschen mit der Schreibmaschine arbeitet

01:37:01.840 --> 01:37:03.980
und der auf alles klickt, was bunt

01:37:03.980 --> 01:37:07.040
blinkt, dem gebe ich vielleicht keinen

01:37:07.040 --> 01:37:09.060
Ruhezugriff, auch wenn der sagt, ich bin der Chef, ich möchte

01:37:09.060 --> 01:37:10.720
auf die ganze Firma überall Zugriff haben.

01:37:11.180 --> 01:37:13.160
Da sage ich, okay, du kriegst deinen eigenen Rechner

01:37:13.160 --> 01:37:15.280
und von deinem Rechner darfst du nirgendwo rein

01:37:15.280 --> 01:37:16.180
und darfst vielleicht noch...

01:37:16.180 --> 01:37:18.740
Dazu beruht dann der Admin, der bei dir vor der Tür steht und

01:37:18.740 --> 01:37:20.180
das dann mit dir gemeiner macht.

01:37:22.000 --> 01:37:22.360
Ja.

01:37:23.620 --> 01:37:25.220
Ja, aber du kannst halt dafür sorgen,

01:37:25.220 --> 01:37:27.020
dass du halt Netze separierst oder

01:37:27.020 --> 01:37:29.360
im Zeiten des Homeoffice, dass du halt Systeme separierst

01:37:29.360 --> 01:37:31.040
und sagst, okay, jedes System muss

01:37:31.040 --> 01:37:33.100
eigentlich

01:37:33.100 --> 01:37:35.140
davon ausgehen, dass alle anderen Systeme gehackt sind,

01:37:35.200 --> 01:37:36.620
also auch im internen Netzwerk, also ich

01:37:36.620 --> 01:37:38.820
muss davon ausgehen, ich kann keinem

01:37:38.820 --> 01:37:41.080
nur aufgrund der IP-Adresse vertrauen, nur weil

01:37:41.080 --> 01:37:43.060
er mit mir kommunizieren kann, sondern das System

01:37:43.060 --> 01:37:45.360
muss halt ordentliche Single-Sign-On-Tokens überprüfen

01:37:45.360 --> 01:37:46.960
oder was auch sehr beliebt ist

01:37:46.960 --> 01:37:49.020
für Service-to-Service-Kommunikation, sind

01:37:49.020 --> 01:37:51.660
halt Client-Side-TLS-Zertifikate,

01:37:51.740 --> 01:37:52.740
dass ich sage, ich verwende das TLS

01:37:52.740 --> 01:37:54.660
nicht, wie man es normalerweise verwendet, dass ich

01:37:54.660 --> 01:37:57.000
einen Server habe, sondern ich habe auch einen Client,

01:37:57.120 --> 01:37:59.140
du hast ja eben schon den YubiKey angesprochen, den man genauso

01:37:59.140 --> 01:38:00.680
einsetzen kann, wenn da ein Mensch ist,

01:38:01.080 --> 01:38:02.920
aber auch zwischen Systemen ist das glaube ich so der

01:38:02.920 --> 01:38:04.840
goldenen Stand, dass man sagt, okay, ich habe

01:38:04.840 --> 01:38:06.620
einen Client-Site TLS-Zertifikat, ich habe einen Server-Site

01:38:06.620 --> 01:38:08.600
TLS-Zertifikat. Vielleicht nochmal ganz kurz da,

01:38:08.680 --> 01:38:10.520
einmal kurz das Low-Level, also TLS ist irgendwie

01:38:10.520 --> 01:38:12.280
Transport-Layers, sehr cute.

01:38:12.780 --> 01:38:14.780
Genau, auch bekannt als SSL. SSL ist der

01:38:14.780 --> 01:38:16.820
Vorgang. Und das macht sowas sicher, wie

01:38:16.820 --> 01:38:18.460
eine Verbindung zu einem anderen Rechner, dass die irgendwie

01:38:18.460 --> 01:38:20.780
verschlüsselt übertragen, dass man sich nicht in die Mitte setzen kann,

01:38:20.800 --> 01:38:22.580
um das abzuhören irgendwie. Ja, nicht eine Verbindung zu

01:38:22.580 --> 01:38:24.400
einem anderen Rechner, sondern, also

01:38:24.400 --> 01:38:25.580
auch, aber

01:38:25.580 --> 01:38:28.860
von einer Anwendung zu einer anderen Anwendung.

01:38:29.000 --> 01:38:30.200
Also auch auf dem lokalen Rechner. Ja, okay.

01:38:30.440 --> 01:38:30.880
Ja, genau.

01:38:32.880 --> 01:38:34.480
Ja, okay. Ja, das sind halt irgendwie so

01:38:34.480 --> 01:38:36.640
genestete Sicherheitslevel, die irgendwie so

01:38:36.640 --> 01:38:38.700
ineinander stecken und das ist dann, wo ist dann irgendwann alles

01:38:38.700 --> 01:38:40.680
relativ komplex dann mit den ganzen...

01:38:40.680 --> 01:38:42.480
Ja, ja, du brauchst halt allein, also

01:38:42.480 --> 01:38:44.520
für sowas wie eben so eine stinknormale,

01:38:44.640 --> 01:38:46.520
ich weiß nicht, so eine Anwendung, wie du besuchst,

01:38:46.940 --> 01:38:48.460
bist auf deiner Bankseite und

01:38:48.460 --> 01:38:50.580
machst da irgendeine Transaktion, müssen halt viele

01:38:50.580 --> 01:38:52.520
Dinge gewährleistet sein.

01:38:52.660 --> 01:38:54.540
Also der TLS-Teil macht halt die

01:38:54.540 --> 01:38:55.860
Vertraulichkeit,

01:38:55.960 --> 01:38:58.320
beziehungsweise Integrität, ich weiß jetzt gar nicht genau,

01:38:58.400 --> 01:39:00.160
aber was du halt auch noch...

01:39:00.160 --> 01:39:00.580
Beides, genau.

01:39:02.740 --> 01:39:04.080
Was du halt auch noch brauchst, ist halt

01:39:04.080 --> 01:39:06.680
Authentifizierung, also du musst dich halt irgendwie

01:39:06.680 --> 01:39:08.380
gegenüber der Bank ausweisen, damit

01:39:08.380 --> 01:39:09.640
die Bank weiß,

01:39:10.560 --> 01:39:12.860
wer du bist und überprüfen kann

01:39:12.860 --> 01:39:14.720
und das ist dann der dritte Teil, ob du auch autorisiert

01:39:14.720 --> 01:39:16.560
bist, das zu tun, was du da tun willst, das ist halt

01:39:16.560 --> 01:39:18.440
nochmal getrennt davon, weil es kann ja sein,

01:39:18.780 --> 01:39:20.720
du hast dich zwar eingeloggt, aber du darfst irgendetwas

01:39:20.720 --> 01:39:22.820
nicht machen und Autorisierung

01:39:22.820 --> 01:39:24.080
ist ja auch nochmal so ein Riesenthema,

01:39:24.500 --> 01:39:26.720
wie kriegt man das eigentlich ordentlich

01:39:26.720 --> 01:39:27.520
hin und

01:39:27.520 --> 01:39:30.680
Der coole Trick bei TLS ist halt,

01:39:30.740 --> 01:39:32.240
dass du sagen kannst, also

01:39:32.240 --> 01:39:37.780
Also du kannst erstmal sowieso asymmetrisch arbeiten, das heißt der private Schlüssel verlässt nie die Box.

01:39:38.600 --> 01:39:44.980
Du hast also einen Client, also einen Service, der einen anderen Dienst was sendet

01:39:44.980 --> 01:39:48.180
und der hat einen privaten Schlüssel und der andere Dienst kennt nur den öffentlichen Schlüssel.

01:39:48.620 --> 01:39:50.380
Und das kannst du noch weiter treiben, indem du halt sagst,

01:39:50.460 --> 01:39:53.500
der andere Dienst muss noch nicht mal den öffentlichen Schlüssel kennen,

01:39:53.920 --> 01:39:57.000
sondern es gibt noch eine dritte Partei, die das irgendwie signiert.

01:39:57.480 --> 01:39:59.740
Und das verwendest du ja, wenn du auf eine normale Webseite gehst,

01:39:59.840 --> 01:40:01.800
normale HTTPS-Seite, dann ist die halt

01:40:01.800 --> 01:40:03.860
oben grün, weil halt

01:40:03.860 --> 01:40:05.720
dieses Zertifikat von jemandem signiert wurde

01:40:05.720 --> 01:40:07.940
und das kannst du

01:40:07.940 --> 01:40:09.480
aber auch kleinseitig verwenden, dass du sagst, okay,

01:40:10.020 --> 01:40:11.900
der, ich zertifiziere

01:40:11.900 --> 01:40:13.980
nicht nur, dass derjenige, der die Anfrage

01:40:13.980 --> 01:40:15.860
entgegennimmt, richtig ist, sondern auch der, der

01:40:15.860 --> 01:40:17.800
die Anfrage sendet. Das ist ja tatsächlich wieder

01:40:17.800 --> 01:40:19.800
interessant, weil das nämlich das nächste Thema ist, was irgendwie eigentlich

01:40:19.800 --> 01:40:21.320
zu Security natürlich dazugehört und das wäre

01:40:21.320 --> 01:40:23.680
Kryptografie oder Verschlüsselung, ohne dass man ja

01:40:23.680 --> 01:40:25.340
wahrscheinlich nicht auskommt und da gab es ja irgendwie

01:40:25.340 --> 01:40:27.960
Algorithmen, mit denen man bestimmte Dinge

01:40:27.960 --> 01:40:29.800
verschlüsselt oder

01:40:29.800 --> 01:40:32.000
hasht oder wie auch immer und die man dann

01:40:32.000 --> 01:40:33.580
mehr oder weniger schnell

01:40:33.580 --> 01:40:35.680
entschlüsseln konnte oder sowas. Oder man konnte sogar

01:40:35.680 --> 01:40:37.980
so Angriffe fahren wie, ich glaube Rainbow Table

01:40:37.980 --> 01:40:39.900
nennt sich das oder sowas, dass man halt Passwort-Hashes

01:40:39.900 --> 01:40:41.820
einfach in eine Tabelle schmeißt und guckt, wie ist denn

01:40:41.820 --> 01:40:43.940
das Ergebnis von dem Hash, also was ist denn da der umgekehrte

01:40:43.940 --> 01:40:45.940
Wert von oder so. Und ja, wenn man

01:40:45.940 --> 01:40:47.720
solche Sachen halt irgendwie

01:40:47.720 --> 01:40:49.440
vermeiden möchte, dann müsste man glaube ich

01:40:49.440 --> 01:40:51.760
schon gucken, welchen Algorithmus man zum Schlüsseln,

01:40:51.780 --> 01:40:52.960
Entschlüsseln seiner Schlüssel nimmt.

01:40:53.980 --> 01:40:55.100
Achtung, das ist zwei verschiedene Sachen.

01:40:55.900 --> 01:40:57.800
Verschlüsseln und, also mein Passwort möchte ich

01:40:57.800 --> 01:40:59.660
eigentlich nicht verschlüsseln, weil dann

01:40:59.660 --> 01:41:01.540
muss ich ja den Schlüssel irgendwo auf dem Server speichern.

01:41:01.860 --> 01:41:03.600
Ja. Also das Passwort

01:41:03.600 --> 01:41:05.040
eines Nutzers möchte ich nicht.

01:41:05.040 --> 01:41:07.640
Also SSH-Keys oder sowas, das mache ich mit Schlüssel.

01:41:09.160 --> 01:41:09.700
Die dann

01:41:09.700 --> 01:41:10.960
bestimmten Algorithmus benutzen irgendwie.

01:41:11.140 --> 01:41:11.780
Okay, ja.

01:41:13.820 --> 01:41:15.580
Das man halt da, also das müsst ihr vielleicht

01:41:15.580 --> 01:41:17.260
nochmal erklären, also wie man halt da von einem

01:41:17.260 --> 01:41:19.520
einen, ich sag mal,

01:41:19.560 --> 01:41:21.360
nicht so guten Algorithmus den Schlüssel

01:41:21.360 --> 01:41:23.100
berechnen kann aus einem Public Key oder sowas, ja, bei

01:41:23.100 --> 01:41:24.200
asymmetrischer Verschlüsselung.

01:41:27.520 --> 01:41:30.800
den Schlüssel selber musst du eigentlich nicht berechnen.

01:41:30.860 --> 01:41:32.220
Du kannst ein Zertifikat berechnen,

01:41:32.540 --> 01:41:34.300
das ist der Schlüssel nochmal in Kurs, aber du

01:41:34.300 --> 01:41:36.360
könntest eigentlich auch immer den Schlüssel an sich verwenden,

01:41:36.480 --> 01:41:37.300
den öffentlichen Schlüssel zumindest.

01:41:38.520 --> 01:41:39.920
Nur weil der öffentliche Schlüssel ist halt bei dieser

01:41:39.920 --> 01:41:42.560
Kryptografie sehr lang, das muss halt eine sehr lange Zahl sein

01:41:42.560 --> 01:41:44.260
und die kannst du halt eindampfen auf

01:41:44.260 --> 01:41:46.280
eine kürzere Zahl, die man aus verschiedenen Gründen

01:41:46.280 --> 01:41:48.140
dann verwendet, die auch immer gleich ist, egal wie lang

01:41:48.140 --> 01:41:50.520
der Schlüssel ist und das ist das Hash-Verfahren.

01:41:50.800 --> 01:41:52.160
Das verwenden wir auch bei Passwörtern und auch an

01:41:52.160 --> 01:41:54.080
vielen anderen Stellen, kann ich auch verwenden, um

01:41:54.080 --> 01:41:56.120
zum Beispiel zu überprüfen, wenn ich Software runterlade,

01:41:56.580 --> 01:41:58.500
dass die in Ordnung ist. Haben wir eben schon mal

01:41:58.500 --> 01:41:59.720
angesprochen, dass wenn ich

01:41:59.720 --> 01:42:02.500
das mit Python mache,

01:42:02.620 --> 01:42:04.100
dann habe ich zum Beispiel bei pip-env

01:42:04.100 --> 01:42:06.700
oder bei pip habe ich ein pip-file

01:42:06.700 --> 01:42:08.760
oder ein pip-file.log und in dem pip-file.log

01:42:08.760 --> 01:42:09.980
stehen halt die ganzen Hashes drin.

01:42:10.480 --> 01:42:12.480
Und was ein Hash macht, ist halt genau eine lange

01:42:12.480 --> 01:42:14.560
Eingabe zu nehmen, egal welche Länge

01:42:14.560 --> 01:42:16.540
und sie auf eine Zahl zu reduzieren,

01:42:16.540 --> 01:42:17.140
die eine

01:42:17.140 --> 01:42:20.680
relativ kurze Länge hat und die auch immer die gleiche

01:42:20.680 --> 01:42:22.700
Länge hat. Das sind dann halt nachher so 32

01:42:22.700 --> 01:42:23.860
Buchstaben oder sowas.

01:42:24.560 --> 01:42:25.860
Und das

01:42:25.860 --> 01:42:27.840
ist halt kryptografische

01:42:27.840 --> 01:42:29.520
Magie und

01:42:29.520 --> 01:42:31.360
es gibt halt Mathematiker,

01:42:32.820 --> 01:42:34.240
also

01:42:34.240 --> 01:42:35.920
haben sich darum gekümmert, dass es nicht

01:42:35.920 --> 01:42:37.880
möglich ist, das rückwärts zu rechnen. Das heißt, wenn ich

01:42:37.880 --> 01:42:39.260
ein Hash habe, kann ich nicht

01:42:39.260 --> 01:42:41.580
das Original berechnen und ich kann

01:42:41.580 --> 01:42:43.640
gegeben einen Hash, kann ich nicht

01:42:43.640 --> 01:42:45.780
überhaupt ein Original

01:42:45.780 --> 01:42:47.780
finden. Das heißt, wenn du mir dein Hash gibst,

01:42:47.840 --> 01:42:48.980
dann kann ich eigentlich sicher sein, dass

01:42:48.980 --> 01:42:51.820
die Originaldatei genau

01:42:51.820 --> 01:42:53.700
unverändert ist. Und genau dafür

01:42:53.700 --> 01:42:55.260
kann ich die halt einsetzen.

01:42:55.860 --> 01:43:03.200
das Rückrechnen ist dann bei unsicheren

01:43:03.200 --> 01:43:05.120
Hashverfahren dann vielleicht dann doch möglich

01:43:05.120 --> 01:43:06.600
oder sowas oder dauert dann lange

01:43:06.600 --> 01:43:09.000
man kann halt Kollisionen finden

01:43:09.000 --> 01:43:11.160
und dann kann man eben beispielsweise

01:43:11.160 --> 01:43:12.560
Dokumente dadurch fälschen, dass man

01:43:12.560 --> 01:43:15.100
wenn man hinten Leerzeichen anfügt

01:43:15.100 --> 01:43:17.140
oder wegnimmt, kann man ja beliebig viele Kombinationen erzeugen

01:43:17.140 --> 01:43:19.300
wenn man weiß, wie man die Kollisionen erzeugen kann

01:43:19.300 --> 01:43:21.040
dann kann man halt quasi beliebige Texte

01:43:21.040 --> 01:43:23.360
mit einem bestimmten Hash erzeugen und das ist natürlich ganz schlecht

01:43:23.360 --> 01:43:26.200
Genau, dann habe ich halt deinen Schlüssel

01:43:26.200 --> 01:43:28.200
und dann kann halt jemand anders einen anderen Schlüssel

01:43:28.200 --> 01:43:30.300
generieren und die haben plötzlich den gleichen

01:43:30.300 --> 01:43:32.000
Hash. Dann kann er sich mit

01:43:32.000 --> 01:43:34.080
seinem eigenen Schlüssel, der so tut, als wäre dein Schlüssel

01:43:34.080 --> 01:43:35.340
damit authentifizieren

01:43:35.340 --> 01:43:38.340
Also es geht um Sicherheit von Kryptografie

01:43:38.340 --> 01:43:39.300
oder sowas in der Hinsicht noch?

01:43:39.880 --> 01:43:42.000
Ja, aber ich glaube, ich weiß gar nicht, ob man

01:43:42.000 --> 01:43:43.600
sich als Endanwender oder so

01:43:43.600 --> 01:43:46.080
wahnsinnig viel mit beschäftigen muss, weil

01:43:46.080 --> 01:43:48.260
ich glaube, wenn man da anfängt

01:43:48.260 --> 01:43:49.860
sich für zu interessieren und dann irgendwelche

01:43:49.860 --> 01:43:51.820
Entscheidungen zu treffen, dann liegt man

01:43:51.820 --> 01:43:53.880
wahrscheinlich eher, ist die Wahrscheinlichkeit hoch,

01:43:53.920 --> 01:43:55.880
dass man falsch liegt. Also genau, dann sollte man

01:43:55.880 --> 01:43:57.800
quasi diese Wahl auch gar nicht mehr treffen, welche

01:43:57.800 --> 01:43:59.640
kryptografischen Algorithmen man zum

01:43:59.640 --> 01:44:01.400
Verschlüsseln, Entschlüsseln benutzt.

01:44:01.780 --> 01:44:03.640
Doch, also wenn du

01:44:03.640 --> 01:44:05.820
zum Beispiel hasht, dann muss dir der

01:44:05.820 --> 01:44:07.600
Python-Hashlet, musst du sagen, okay, ich möchte

01:44:07.600 --> 01:44:09.080
diesen Hash haben. Dann sagst du zum Beispiel, ich möchte

01:44:09.080 --> 01:44:11.740
SHA-1 haben oder ich möchte MD-5

01:44:11.740 --> 01:44:13.680
haben. Und wenn du da die falsche Wahl

01:44:13.680 --> 01:44:15.540
triffst, dann hast du durchaus ein Problem. Also SHA-1

01:44:15.540 --> 01:44:17.920
oder MD-5 sollte man nicht nehmen, sondern SHA-256

01:44:17.920 --> 01:44:20.040
oder? Genau, SHA-256

01:44:20.040 --> 01:44:21.460
oder eine SHA-3-Variante oder

01:44:21.460 --> 01:44:23.500
was anderes. Aber eigentlich willst du gar nicht, dass

01:44:23.500 --> 01:44:25.540
der Entwickler sich drum Gedanken machen soll.

01:44:25.640 --> 01:44:27.340
Der Entwickler soll gar nicht sagen, okay, ich nehme ShyOne,

01:44:27.740 --> 01:44:29.480
sondern der Entwickler soll eigentlich sagen, okay, ich nehme

01:44:29.480 --> 01:44:31.520
eine fertige Bibliothek. Und dafür

01:44:31.520 --> 01:44:33.200
gibt es dann in Python zum Beispiel die

01:44:33.200 --> 01:44:35.520
neue Passwortbibliothek

01:44:36.260 --> 01:44:37.260
oder es gibt Bcrypt.

01:44:39.340 --> 01:44:39.660
Und

01:44:39.660 --> 01:44:41.520
da muss ich mich halt gar nicht drum kümmern.

01:44:41.680 --> 01:44:43.320
Ich weiß gar nicht, die Passwortbibliothek heißt, glaube ich, Secret?

01:44:44.080 --> 01:44:45.780
Secrets. Secrets, ja, genau.

01:44:46.020 --> 01:44:47.400
Und da muss ich halt nicht mehr drum kümmern.

01:44:47.660 --> 01:44:49.660
Also da wird halt die Wahl für dich getroffen

01:44:49.660 --> 01:44:51.760
und das macht es für den

01:44:51.760 --> 01:44:53.100
Entwickler natürlich

01:44:53.100 --> 01:44:55.320
besser, weil der Entwickler keine Entscheidung

01:44:55.320 --> 01:44:57.420
treffen muss. Wenn du ein System groß

01:44:57.420 --> 01:44:59.660
zertifizieren musst, dann musst du wahrscheinlich trotzdem irgendwo eine Entscheidung

01:44:59.660 --> 01:45:01.580
treffen, weil da andere Leute drüber schauen wollen,

01:45:01.660 --> 01:45:03.720
aber für so die Wald- und Wiesenanwendung,

01:45:03.720 --> 01:45:05.780
die einfach mal so von

01:45:05.780 --> 01:45:07.780
vielleicht einem kleinen Team entwickelt wird, ist das

01:45:07.780 --> 01:45:09.300
sicherlich eine bessere Option, wenn die

01:45:09.300 --> 01:45:11.640
keine kryptographischen Entscheidungen treffen. Also

01:45:11.640 --> 01:45:13.600
nicht mal die Entscheidung treffen, welche Algorithmen

01:45:13.600 --> 01:45:15.520
sie verwenden, sondern vielleicht nur noch sagen,

01:45:15.600 --> 01:45:18.100
ich möchte ein bestimmtes Sicherheitslevel

01:45:18.100 --> 01:45:19.960
haben. Das ist ja auch immer ein Trade-off,

01:45:20.040 --> 01:45:21.880
dass ich sage, okay, ich kann ja zum Beispiel mehrfach

01:45:21.880 --> 01:45:24.020
hintereinander hashen und dann kann man

01:45:24.020 --> 01:45:25.120
das halt bei dem Passwort

01:45:25.120 --> 01:45:28.160
dauert es auch länger, das rauszufinden,

01:45:28.260 --> 01:45:29.920
weil ich halt, wenn ich

01:45:29.920 --> 01:45:32.040
ein Testpasswort habe,

01:45:32.120 --> 01:45:34.140
muss ich das ganz oft hashen, um das Zielpasswort

01:45:34.140 --> 01:45:36.000
zu finden. Aber das ist halt auch ein

01:45:36.000 --> 01:45:38.080
Problem, was auf deiner

01:45:38.080 --> 01:45:39.960
Seite, weil wenn du das jetzt sehr oft

01:45:39.960 --> 01:45:41.560
hasht, dann dauert es natürlich bei dir länger.

01:45:42.120 --> 01:45:43.960
Und du möchtest ja nicht, dass dein

01:45:43.960 --> 01:45:45.780
Service plötzlich eine Minute braucht, wenn es den

01:45:45.780 --> 01:45:47.820
Benutzer einloggt, weil dein Passwort irgendwie

01:45:47.820 --> 01:45:48.960
eine Million mal hasht oder sowas.

01:45:49.560 --> 01:45:51.820
Das ist übrigens auch mal so ein schönes Ding bei

01:45:51.820 --> 01:45:54.000
Tests, wo man halt irgendwie Zeit sparen

01:45:54.000 --> 01:45:55.620
kann. Und da halte ich meine,

01:45:55.920 --> 01:45:57.940
die Passwort-Hash-Funktionen sind ja genau die,

01:45:58.820 --> 01:45:59.820
sie sind ja genauso

01:45:59.820 --> 01:46:01.340
gestaltet, dass sie möglichst langsam sind.

01:46:02.460 --> 01:46:02.860
Und

01:46:02.860 --> 01:46:05.620
genau, da will man dann vielleicht auch mal MD5

01:46:05.620 --> 01:46:06.940
verwenden oder sowas in der Art,

01:46:07.660 --> 01:46:08.880
weil das ist halt dann deutlich schneller.

01:46:09.600 --> 01:46:11.520
Und man legt ja, wenn man jetzt einen Testsuite

01:46:11.520 --> 01:46:13.720
durchlaufen lässt, oft irgendwie ganz viele Nutzer an

01:46:13.720 --> 01:46:14.540
und ja,

01:46:14.920 --> 01:46:17.180
das kann Dinge deutlich beschleunigen.

01:46:17.820 --> 01:46:18.260
Ja.

01:46:20.180 --> 01:46:20.580
Ja.

01:46:22.020 --> 01:46:23.860
Sehr, sehr interessant. Also da fallen mir

01:46:23.860 --> 01:46:25.220
ganz viele Sachen, glaube ich, noch zu ein.

01:46:25.900 --> 01:46:27.140
Was man da so macht mit

01:46:27.140 --> 01:46:29.700
Vulnerabilities und Disclosure und

01:46:29.700 --> 01:46:31.780
alle so Themen. Ja, Pics

01:46:31.780 --> 01:46:33.860
tatsächlich. Und die Frage, wollen wir

01:46:33.860 --> 01:46:35.560
ein Standard-Lib-Modul

01:46:35.560 --> 01:46:36.100
vorstellen?

01:46:37.400 --> 01:46:39.300
Ich finde, jetzt vielleicht ein Siegwitz vorstellen.

01:46:39.780 --> 01:46:41.200
Ja, das wäre super. Kennst du dich mit Siegwitz auch

01:46:41.200 --> 01:46:43.800
aus? Nicht im Detail.

01:46:44.120 --> 01:46:44.280
Okay.

01:46:45.860 --> 01:46:46.300
Schade.

01:46:47.200 --> 01:46:48.360
Ich dachte, er hat gedacht, ich kann

01:46:48.360 --> 01:46:49.640
die Verantwortung von mir schieben.

01:46:50.320 --> 01:46:52.180
Ja, aber wenn du dich damit beschäftigt hast, dann mach das doch.

01:46:53.080 --> 01:46:54.100
Was, ich? Nein, nein, nein.

01:46:54.440 --> 01:46:55.320
Nein? Nein, nein, nein.

01:46:58.420 --> 01:46:59.420
Was wäre denn euer Blick?

01:47:00.360 --> 01:47:01.600
Ja, also meiner

01:47:01.600 --> 01:47:03.560
wäre jetzt

01:47:03.560 --> 01:47:06.420
tatsächlich YouTube.dl.

01:47:09.420 --> 01:47:10.160
Wie kommst du

01:47:10.160 --> 01:47:10.840
da drauf?

01:47:12.060 --> 01:47:14.280
Ja, ich habe damit in letzter Zeit, im letzten Jahr

01:47:14.280 --> 01:47:16.020
viel gemacht. Ich habe das so, ich habe es früher

01:47:16.020 --> 01:47:18.100
vielleicht ab und zu mal benutzt, um irgendwie mal Videos

01:47:18.100 --> 01:47:20.180
runterzuladen, die ich gerne auf der Platte hätte.

01:47:21.180 --> 01:47:22.300
Also genau dafür ist es ja da.

01:47:22.760 --> 01:47:24.000
Aber im letzten

01:47:24.000 --> 01:47:25.140
Jahr habe ich das auch viel

01:47:25.140 --> 01:47:27.940
sozusagen in Projekten

01:47:27.940 --> 01:47:29.860
verwendet, weil es darum ging,

01:47:30.040 --> 01:47:32.040
wie man da Videos irgendwie automatisch verarbeiten

01:47:32.040 --> 01:47:32.760
kann und so.

01:47:33.980 --> 01:47:35.200
Ja, und

01:47:35.200 --> 01:47:36.820
es ist ein sehr, sehr schönes Tool.

01:47:37.860 --> 01:47:39.760
Aber ich glaube, Philipp kann das deutlich

01:47:39.760 --> 01:47:41.700
besser erklären, was das eigentlich so tut und was so

01:47:41.700 --> 01:47:42.480
ein bisschen...

01:47:42.480 --> 01:47:45.360
Es gab auch so einen kleinen politischen Vorfall beim YouTube.

01:47:45.520 --> 01:47:48.040
Dann müssen wir auch noch natürlich erzählen.

01:47:48.760 --> 01:47:50.260
Also der Name von YouTube.de

01:47:50.260 --> 01:47:51.340
ist stark irreführend.

01:47:52.380 --> 01:47:53.980
Also es hat angefangen

01:47:53.980 --> 01:47:56.140
als ein Download-Tool nur für YouTube

01:47:56.140 --> 01:47:57.980
und als ich das damals

01:47:57.980 --> 01:47:59.800
übernommen habe, da

01:47:59.800 --> 01:48:01.860
wurden glaube ich noch Vimeo unterstützt

01:48:01.860 --> 01:48:03.960
und noch ein, zwei andere Seiten, aber als ich

01:48:03.960 --> 01:48:05.980
das abgegeben habe, also mittlerweile

01:48:05.980 --> 01:48:07.500
entwickle ich auch schon länger nicht mehr daran,

01:48:08.320 --> 01:48:10.000
oder entwickle schon ein bisschen dran, aber bin halt nicht mehr

01:48:10.000 --> 01:48:11.240
der Chef-Maintainer

01:48:11.240 --> 01:48:13.560
oder überhaupt ein Maintainer und

01:48:13.560 --> 01:48:15.780
mittlerweile unterstützt es über tausend Dienste, das heißt

01:48:15.780 --> 01:48:17.600
du kannst es auch auf irgendeine komische Anime-Seite

01:48:17.600 --> 01:48:20.060
laufen lassen oder auf die ARD-Audiothek

01:48:20.060 --> 01:48:21.900
oder auf

01:48:21.900 --> 01:48:24.360
archive.org

01:48:24.360 --> 01:48:26.080
oder die CCC-Kongress-Seite

01:48:26.080 --> 01:48:27.940
und es wird dir halt immer ein ordentliches

01:48:27.940 --> 01:48:29.800
Video zurückliefern, du kannst

01:48:29.800 --> 01:48:31.000
natürlich auch sagen, ich möchte verschiedene

01:48:31.000 --> 01:48:33.700
Konfigurationen, also möchtest du das Video

01:48:33.700 --> 01:48:35.940
sortieren oder möchtest du direkt eine Playlist runterladen

01:48:35.940 --> 01:48:37.880
und YouTube-Date ist komplett in Python

01:48:37.880 --> 01:48:39.840
geschrieben, das ist vielleicht auch ein bisschen besonders, weil

01:48:39.840 --> 01:48:41.540
es eine Python-Anwendung ist,

01:48:41.820 --> 01:48:43.120
die gar keine Dependencies hat.

01:48:43.660 --> 01:48:45.760
YouTube.dl verlangt nur die Standard-Diplotek

01:48:45.760 --> 01:48:47.640
und das auch sehr, sehr, sehr flexibel.

01:48:47.640 --> 01:48:51.740
Also bis vor kurzem noch konnten wir zwischen Python 2.6,

01:48:52.380 --> 01:48:54.760
ging noch bis Python 3.8, wurde alles unterstützt.

01:48:55.260 --> 01:48:56.460
Hat sehr, sehr viele Benutzer.

01:48:58.040 --> 01:49:02.160
Und ja, ist halt hoffentlich ein super flexibles Tool,

01:49:02.220 --> 01:49:03.520
das man auch sowohl programmatisch

01:49:03.520 --> 01:49:05.580
als auch als Kommando-Zeitanwendung verwenden kann,

01:49:05.940 --> 01:49:07.000
um schnell was runterzuladen.

01:49:07.160 --> 01:49:09.380
Viele grafische oder serverseitige Programme

01:49:09.380 --> 01:49:10.960
verwenden auch intern YouTube.dl

01:49:10.960 --> 01:49:13.280
um halt Videos runterzuladen

01:49:13.280 --> 01:49:15.140
aus verschiedensten Quellen. Typischerweise

01:49:15.140 --> 01:49:17.220
also oft YouTube, aber kann auch was ganz anderes

01:49:17.220 --> 01:49:19.180
sein. Und der

01:49:19.180 --> 01:49:20.500
Vorfall, der halt passiert war, ist

01:49:20.500 --> 01:49:23.240
also vor dem öffentlichen Vorfall

01:49:23.240 --> 01:49:24.940
bin ich und ein Hoster

01:49:24.940 --> 01:49:27.680
angeschrieben worden von einer deutschen Anwaltskanzlei

01:49:27.680 --> 01:49:29.260
die Rush heißt die

01:49:29.260 --> 01:49:31.060
die sind, wenn man nach denen googelt, dann

01:49:31.060 --> 01:49:32.820
also ich hab zuerst natürlich nach denen gegoogelt

01:49:32.820 --> 01:49:34.860
als ich das Schreiben bekommen hab, sieht man okay

01:49:34.860 --> 01:49:36.480
die schicken normalerweise Abnahmen wegen

01:49:36.480 --> 01:49:38.120
Tauschbörsenvorfällen oder sowas.

01:49:38.220 --> 01:49:39.340
Irgendwie bekannt für den Namen, ja.

01:49:40.260 --> 01:49:56.720
Und die haben halt da typischen, also ich kann das jetzt nicht so beurteilen, ich bin kein Jurist, aber die haben ein sehr langes Papier geschrieben, wo sehr große Drohungen drin standen, was für mich eigentlich jetzt irrelevant ist, weil ich bin ja nicht mehr in ein Projekt involviert.

01:49:56.720 --> 01:49:58.720
auch schon, also ich habe noch gelegentlich

01:49:58.720 --> 01:50:00.560
Contributions geleistet, aber auch nichts mehr zu

01:50:00.560 --> 01:50:02.080
YouTube, sondern nur noch zu ganz anderen

01:50:02.080 --> 01:50:04.600
Seiten. Und dann

01:50:04.600 --> 01:50:06.180
haben die wohl aber mitbekommen, dass

01:50:06.180 --> 01:50:08.020
YouTube.dl auf GitHub gehostet ist.

01:50:08.900 --> 01:50:10.340
Und dann an die

01:50:10.340 --> 01:50:12.500
amerikanischen, ja, so richtig technisch

01:50:12.500 --> 01:50:14.460
drauf waren sie nicht, aber gut, sind auch

01:50:14.460 --> 01:50:16.560
recht anwesend, sind keine Programmierer, haben halt

01:50:16.560 --> 01:50:18.480
nur so ein bisschen was gefunden und haben auch viele Sachen

01:50:18.480 --> 01:50:20.460
nicht richtig verstanden. Also

01:50:20.460 --> 01:50:22.280
das ist halt,

01:50:22.640 --> 01:50:23.440
ja, kann man ja nicht machen.

01:50:25.160 --> 01:50:25.960
Und dann sind sie halt

01:50:25.960 --> 01:50:28.100
zu den Amerikanern gegangen

01:50:28.100 --> 01:50:29.940
und die RIAA

01:50:29.940 --> 01:50:31.520
und die hat dann halt

01:50:31.520 --> 01:50:33.920
GitHub eine Notiz geschickt,

01:50:35.140 --> 01:50:35.900
eine

01:50:35.900 --> 01:50:38.520
DMCA-Notiz,

01:50:38.900 --> 01:50:39.460
dass sie halt

01:50:39.460 --> 01:50:42.360
die YouTube-DA

01:50:42.360 --> 01:50:43.960
sperren sollen. Und davon haben die meisten Leute

01:50:43.960 --> 01:50:45.340
erst mitbekommen, dass irgendwas nicht stimmt.

01:50:45.740 --> 01:50:48.200
Also diese Vorgeschichte, das war schon Wochen davor in Deutschland

01:50:48.200 --> 01:50:49.940
und auch andere Sachen waren

01:50:49.940 --> 01:50:52.320
Wochen davor, aber was die Öffentlichkeit mitbekommen hat,

01:50:52.420 --> 01:50:54.280
war okay, GitHub ist gesperrt.

01:50:54.620 --> 01:50:55.860
Und GitHub ist freundlicherweise

01:50:55.860 --> 01:50:58.320
für das YouTube-2L-Projekt, das hostet die Downloads.

01:50:58.980 --> 01:50:59.780
Das YouTube-2L

01:50:59.780 --> 01:51:01.840
muss relativ häufig aktualisiert werden.

01:51:02.220 --> 01:51:03.900
Also wird so alle 2-3 Tage

01:51:03.900 --> 01:51:05.820
aktualisiert. Klar, bei irgendeiner Webseite ändert

01:51:05.820 --> 01:51:07.700
immer was oder irgendjemand fügt etwas hinzu.

01:51:08.120 --> 01:51:10.160
Und es ist halt auch ein sehr, sehr aktives Open-Source-Projekt.

01:51:10.320 --> 01:51:11.440
Also da laufen pro Tag

01:51:11.440 --> 01:51:12.920
10 PRs rein.

01:51:14.200 --> 01:51:16.540
dadurch

01:51:16.540 --> 01:51:19.640
stehen halt große, hohe Download-Zahlen und dann ging halt

01:51:19.640 --> 01:51:21.320
erstmal gar nichts, weil GitHub das nicht gemacht hat.

01:51:21.780 --> 01:51:23.740
Das Projekt ist direkt umgeschwenkt und ich hatte

01:51:23.740 --> 01:51:25.540
schon befürchtet, dass es daran endet,

01:51:25.860 --> 01:51:28.940
dass das Projekt nur noch YouTube-Musik runterladen kann.

01:51:29.060 --> 01:51:31.640
Also der Stein des Anstoßes waren nicht die normalen YouTube-Downloads,

01:51:31.940 --> 01:51:33.140
sondern die YouTube-Musik-Videos.

01:51:33.220 --> 01:51:38.400
Das war das Problem, was die Rechtsanwälte bemängelt hatten.

01:51:39.120 --> 01:51:40.380
Und was jetzt aber passiert ist,

01:51:40.380 --> 01:51:45.240
dass glücklicherweise die EFF, die Electronic Frontier Foundation,

01:51:45.880 --> 01:51:49.360
in den USA die Verteidigung übernommen hat von YouTube.dl

01:51:49.360 --> 01:51:50.840
und da eine Gegennotiz geschickt hat.

01:51:51.320 --> 01:51:54.420
Und jetzt auf GitHub wieder alles da ist und GitHub das wieder hostet.

01:51:54.920 --> 01:52:01.200
Und das Projekt wahrscheinlich jetzt ganz normal weiterläuft und alles wieder klappt.

01:52:01.640 --> 01:52:03.360
Ich war da auch gar nicht so viel involviert.

01:52:03.460 --> 01:52:06.640
Ich bin halt nur von zig Leuten angeschrieben worden, habe einige Interviews gegeben.

01:52:07.420 --> 01:52:10.740
Und ich bin halt natürlich rechtlich, habe ich mit einem Rechtsanwalt gesprochen.

01:52:11.420 --> 01:52:13.620
Damals hatte ich da nicht den richtigen Überblick.

01:52:13.620 --> 01:52:17.820
Habe dann auch eine Unterlassungserklärung abgegeben, dass ich nicht mehr daran teilnehme an YouTube.de.

01:52:18.100 --> 01:52:18.720
Sehr traurig.

01:52:20.540 --> 01:52:23.340
Aber das Projekt sieht jetzt gut aus

01:52:23.340 --> 01:52:25.460
und scheint überhaupt kein Problem zu sein.

01:52:25.860 --> 01:52:27.920
Und ich bin sehr froh, dass die EFS sich darum gekümmert hat.

01:52:28.240 --> 01:52:30.080
Und auch über die Unterstützung von GitHub.

01:52:30.840 --> 01:52:32.140
Und zuletzt sollte man vielleicht auch erwähnen,

01:52:32.200 --> 01:52:34.160
es gibt einen deutschen Hoster, der daran beteiligt ist.

01:52:34.560 --> 01:52:35.500
Das ist Uberspace.

01:52:36.280 --> 01:52:39.200
Da kann man super leicht seinen eigenen Dienst hosten.

01:52:39.720 --> 01:52:42.600
Und die sind auch rechtlich angeschrieben worden,

01:52:42.680 --> 01:52:44.120
auch von den Rechtsanwälten rasch.

01:52:44.660 --> 01:52:47.140
Und die haben sich auf eigene Kosten,

01:52:47.140 --> 01:52:48.740
die ihre eigene Verteidigung organisiert.

01:52:49.040 --> 01:52:50.060
Die hosten halt nur die Webseite.

01:52:50.160 --> 01:52:51.380
die hostet nicht das Programm selber,

01:52:51.800 --> 01:52:54.600
aber auch das fand die Rechtsanwälte verwerflich.

01:52:55.380 --> 01:52:56.600
Glücklicherweise ist jetzt, glaube ich, alles gut

01:52:56.600 --> 01:52:58.600
und ich glaube, YouTube.de wird es genutzt.

01:52:59.500 --> 01:53:00.800
Ich glaube, völlig unbestritten,

01:53:00.940 --> 01:53:02.480
dass es absolut legitim ist.

01:53:02.580 --> 01:53:04.400
Es haben sich nach der Sperrung

01:53:04.400 --> 01:53:06.280
auch sehr, sehr viele Museen

01:53:06.280 --> 01:53:08.940
oder Archivare oder Bibliotheken gemeldet,

01:53:09.020 --> 01:53:10.960
die gesagt haben, okay, wir verwenden das

01:53:10.960 --> 01:53:13.540
und wir haben sogar rechtlich das Anrecht darauf,

01:53:13.720 --> 01:53:15.160
selbst Musikvideos runterzuladen,

01:53:15.520 --> 01:53:17.100
weil das genau steht

01:53:17.100 --> 01:53:18.260
und irgendwie muss es halt passieren

01:53:18.260 --> 01:53:20.460
und YouTube-DL ist genau das Werkzeug, um sowas zu machen.

01:53:21.080 --> 01:53:23.600
Und ich glaube, der Nutzen von YouTube-DL überwiegt bei Weitem

01:53:23.600 --> 01:53:27.760
das jegliche Probleme, dass man da ein Musikvideo

01:53:27.760 --> 01:53:30.860
in meiner Weise relativ schlechter Qualität von YouTube runterladen kann,

01:53:30.860 --> 01:53:37.220
was man ja auf Spotify oder überall bei Amazon oder bei Apple

01:53:37.220 --> 01:53:42.560
als MP3-Datei oder als Flak-Datei in deutlich besserer Qualität kaufen kann.

01:53:43.180 --> 01:53:46.820
Ich glaube, das ist viel besser für die Gesellschaft,

01:53:47.320 --> 01:53:49.100
dass YouTube.dl für alle verfügbar ist.

01:53:49.180 --> 01:53:51.720
Aber als deutscher spitzfindiger Winkeladvokat,

01:53:51.740 --> 01:53:53.260
da kann man sich ja noch mal überlegen,

01:53:53.360 --> 01:53:55.900
ob man nicht noch einen kleinen Pfeilstrick herbeizaubern kann.

01:53:57.140 --> 01:53:57.300
Ja.

01:53:58.240 --> 01:53:58.680
Ja.

01:53:59.020 --> 01:54:00.920
Aber ja, ich glaube auch eher,

01:54:00.920 --> 01:54:05.920
das hat dem Projekt wahrscheinlich doch eher stark genützt.

01:54:06.700 --> 01:54:08.520
Das hat jetzt noch mal sehr viel Aufmerksamkeit bekommen

01:54:08.520 --> 01:54:11.920
und hat der Streisand-Effekt voll zugeschlagen.

01:54:12.180 --> 01:54:13.180
Ja, auf jeden Fall.

01:54:13.600 --> 01:54:15.940
Also ich bin tatsächlich froh, dass es mittlerweile so weit ist,

01:54:16.020 --> 01:54:18.340
dass solche Sachen nicht mehr einfach so dann weggeblockt werden,

01:54:18.440 --> 01:54:20.120
sondern dass die Leute sich anfangen,

01:54:20.260 --> 01:54:22.020
mit solchen Dingen auch juristisch dann auszukennen

01:54:22.020 --> 01:54:24.320
und dass diese komischen Kanzleien

01:54:24.320 --> 01:54:25.860
oder wie man ja auch immer das dann nennen soll,

01:54:26.220 --> 01:54:28.060
langsam aber sicher gegen die Wände rennen.

01:54:29.020 --> 01:54:30.800
Ja, ist halt schwierig als Open-Source-Programmierer.

01:54:30.860 --> 01:54:32.380
Ich bin halt nur eine Person.

01:54:32.580 --> 01:54:36.000
Ich habe keine große juristische Know-how.

01:54:36.000 --> 01:54:37.980
Also ich kann das halt technisch beurteilen,

01:54:38.120 --> 01:54:39.260
was im Gesetz steht.

01:54:39.700 --> 01:54:41.940
Aber offensichtlich gibt es auch einige Gerichte,

01:54:42.060 --> 01:54:45.140
die das sehr flexibel ausgelegt haben,

01:54:45.200 --> 01:54:45.880
was da im Gesetz steht.

01:54:46.020 --> 01:55:08.440
Also das Landgericht Hamburg hat gesagt, okay, im Wesentlichen, da steht, dass es technisch eine technisch durchsetzbare Verschlüsselung oder Verschleierung geben muss und das haben sie einfach interpretiert als, ja, das hört sich aber komisch an, das interpretieren wir jetzt anders und jetzt haben sie es gesagt in dem Urteil, eigentlich alles, was ein normaler Benutzer nicht machen kann, ist verboten.

01:55:08.700 --> 01:55:24.980
Das heißt, es gab ein vergleichbares Urteil und da hat ja jemand argumentiert, okay, das kann man aber auch in den Browser-Tools machen und dann hat das Landgericht Hamburg gesagt, nee, das kann aber ein normaler Benutzer nicht, weil das ist nicht im Internet Explorer drin oder so. Und das ist halt eine sehr fragwürdige Argumentation.

01:55:25.540 --> 01:55:28.020
Ja, da hat der Jurist das dann selber ausprobiert

01:55:28.020 --> 01:55:29.260
und dann festgestellt, nee, er kann das nicht.

01:55:29.560 --> 01:55:30.640
Ja, genau, genau, exakt.

01:55:31.680 --> 01:55:33.980
Und YouTube-DLS funktioniert eigentlich

01:55:33.980 --> 01:55:34.960
wie ein normaler Browser.

01:55:35.240 --> 01:55:37.980
Nicht grundsätzlich unterschiedlich wie Chrome.

01:55:38.040 --> 01:55:40.200
Es hat auch eine eigene JavaScript-Engine in Python geschrieben.

01:55:41.320 --> 01:55:42.120
Ach, äh,

01:55:42.140 --> 01:55:43.780
ah, okay, das und tatsächlich

01:55:43.780 --> 01:55:45.520
die ist selber, aha, naja, stimmt,

01:55:45.640 --> 01:55:47.320
wenn es keine externen Abhängigkeiten gibt.

01:55:47.600 --> 01:55:48.780
Oh, das wusste ich nicht, das hätte ich jetzt auch gedacht,

01:55:48.860 --> 01:55:52.580
dass das vielleicht irgendein Headless-Browser-Engine

01:55:52.580 --> 01:55:54.440
noch mit dabei ist oder so, nee, komplett, wow.

01:55:54.460 --> 01:55:55.900
Also gar keine Python-Abhängigkeiten.

01:55:56.520 --> 01:55:59.400
Klar, wenn ich jetzt normale Python-Anwendungen schreibe,

01:55:59.480 --> 01:56:00.580
dann verwende ich Abhängigkeiten.

01:56:00.660 --> 01:56:01.680
Wir haben ja eben gerade besprochen,

01:56:01.860 --> 01:56:03.760
dass es eigentlich gut ist, wenn ich fertige Bibliotheken verwende.

01:56:04.260 --> 01:56:07.040
Aber YouTube.jl muss halt auf ganz unterschiedlichen Systemen laufen.

01:56:07.140 --> 01:56:08.640
Da gibt es halt Leute, die kommen an mit Red Hat

01:56:08.640 --> 01:56:12.240
und haben halt Python 2.6 oder bis vor kurzem noch Python,

01:56:12.440 --> 01:56:14.600
oder vor allem jetzt halt noch Python 2.5 haben die noch drauf

01:56:14.600 --> 01:56:16.120
oder Python 2.4, keine Ahnung.

01:56:16.360 --> 01:56:17.540
Und da kannst du halt nicht darauf vertrauen,

01:56:17.640 --> 01:56:19.360
dass die auch überhaupt irgendwas installieren können.

01:56:19.760 --> 01:56:22.360
Die sind halt froh, wenn die ein Binary bekommen.

01:56:23.740 --> 01:56:39.260
Und das geht ja in Python relativ gut, man kann die Datei ja einfach als ZIP verpacken und dann ist es ausführbar und man kann das auch mit, ich glaube, mittlerweile verwendet YouTube.jl CX Freeze, um halt auch eine Excel für Windows zu erzeugen und das läuft dann wirklich überall, ohne dass man es installieren muss.

01:56:39.260 --> 01:56:51.400
Und ich glaube, das ist auch ein Grund für den Erfolg dieser Software, dass man das halt einfach so laufen lassen kann, dass man sich keine Gedanken machen muss, auch wenn das System komplett zerschlossen ist als Python-Entwickler, das klappt immer. YouTube.jl, klar, braucht ungesunde Politik.

01:56:51.400 --> 01:56:54.220
Sehr gut, sehr gut

01:56:54.220 --> 01:56:56.500
Ja, das klingt sehr spannend

01:56:56.500 --> 01:56:58.700
Ja, ja

01:56:58.700 --> 01:57:00.880
Mir war das auch gar nicht so klar, dass man da tatsächlich

01:57:00.880 --> 01:57:02.320
irgendwie die meisten Seiten mit

01:57:02.320 --> 01:57:04.480
bedienen kann und dann

01:57:04.480 --> 01:57:06.680
ja, ich hatte

01:57:06.680 --> 01:57:08.280
früher auch immer gedacht, das wäre eigentlich für YouTube

01:57:08.280 --> 01:57:10.680
aber ja, es ist wirklich

01:57:10.680 --> 01:57:12.100
sehr, sehr praktisch, es nimmt einem auch viel ab

01:57:12.100 --> 01:57:14.300
Ich benutze das jetzt halt immer so

01:57:14.300 --> 01:57:16.980
quasi

01:57:16.980 --> 01:57:18.700
um halt automatisiert von allen

01:57:18.700 --> 01:57:20.580
möglichen Seiten Dinge runterzuladen und das

01:57:20.580 --> 01:57:22.160
halt sozusagen die Schnittstelle, die

01:57:22.160 --> 01:57:24.260
YouTube-DL ist sozusagen meine API zu

01:57:24.260 --> 01:57:26.260
Seiten, die Videos haben,

01:57:26.840 --> 01:57:28.420
um das Video da rauszukriegen.

01:57:28.820 --> 01:57:30.320
Genau, ohne...

01:57:30.320 --> 01:57:35.840
Ja, Pics.

01:57:36.280 --> 01:57:38.240
Also ich würde dieses Mal gleich Python Date

01:57:38.240 --> 01:57:40.280
Util picken, weil irgendwie das ein schöner

01:57:40.280 --> 01:57:41.360
Rapper ist, über wie man

01:57:41.360 --> 01:57:44.020
Datumsangaben irgendwie machen kann.

01:57:44.460 --> 01:57:46.200
Verschiedene Zeitkalendern mit Deltas

01:57:46.200 --> 01:57:48.140
irgendwie. Ich wollte es nur mal erwähnt haben,

01:57:48.140 --> 01:57:49.960
das stand irgendwo noch auf meiner Liste, hat jetzt nicht den Topic

01:57:49.960 --> 01:57:50.800
gar nichts mehr so viel zu tun.

01:57:52.620 --> 01:57:54.000
Ja, Datutals

01:57:54.000 --> 01:57:55.620
ist tatsächlich auch sehr nett.

01:57:56.380 --> 01:57:57.900
Das Datutal-Pass,

01:57:57.960 --> 01:57:59.840
das passt erstaunlich viel.

01:58:00.380 --> 01:58:01.680
Also dem kann man irgendwelche Strings geben,

01:58:02.140 --> 01:58:03.820
also man hat ja oft irgendwie, sieht man dann irgendwo

01:58:03.820 --> 01:58:06.140
so einen String mit Datums

01:58:06.140 --> 01:58:07.960
und Zeitangaben drin und dann denkt man sich,

01:58:08.060 --> 01:58:09.920
oh, wie waren

01:58:09.920 --> 01:58:11.660
jetzt nochmal die Format-String-Dinger,

01:58:11.740 --> 01:58:12.580
wie hießen die nochmal alle?

01:58:13.840 --> 01:58:15.440
Und dann nimmt man Datutal-Pass

01:58:15.440 --> 01:58:17.820
und dann passt das automatisch,

01:58:17.900 --> 01:58:19.840
aber dann muss man irgendwie noch, ich glaube, das geht

01:58:19.840 --> 01:58:21.500
aber auch irgendwie, man kriegt auch aus dem

01:58:21.500 --> 01:58:23.920
Datutel-Pass dann raus, wie der Format-String

01:58:23.920 --> 01:58:24.880
eigentlich sein müsste.

01:58:25.080 --> 01:58:26.320
Und andere Kalender.

01:58:26.940 --> 01:58:29.500
Weil Datutel-Pass sollte man nicht

01:58:29.500 --> 01:58:31.460
über größere Datenmengen

01:58:31.460 --> 01:58:33.540
aufrufen, weil das wird dann halt sehr langsam,

01:58:33.680 --> 01:58:35.100
wenn man das Inhaltschleife verwendet, aber

01:58:35.100 --> 01:58:37.560
um rauszukriegen, wie man das denn jetzt eigentlich

01:58:37.560 --> 01:58:39.780
aufpasst und dann halt an den Format-String zu kommen,

01:58:40.200 --> 01:58:41.640
den man dann letztlich verwendet

01:58:41.640 --> 01:58:43.560
für Striptime oder so,

01:58:43.760 --> 01:58:44.360
das ist super.

01:58:45.720 --> 01:58:46.600
Und dein Pick-Up?

01:58:47.340 --> 01:58:48.100
Hatte ich doch schon.

01:58:48.740 --> 01:58:50.560
scheuen? Ja, YouTube.dl. Ach, verdammt.

01:58:50.780 --> 01:58:52.340
Ja, richtig. Ich dachte jetzt, das ist der Philips-Pick gewesen.

01:58:52.760 --> 01:58:54.380
Na gut. Du bist da

01:58:54.380 --> 01:58:55.780
ausnahmsweise wegen dem YouTube.dl

01:58:55.780 --> 01:58:57.860
da rumgekommen. Es sei denn, du hast noch einen.

01:58:58.360 --> 01:58:58.620
Extra.

01:59:00.280 --> 01:59:02.300
Ne, das habe ich jetzt nicht vorbereitet.

01:59:03.080 --> 01:59:04.280
Ich habe mich bei dem Secrets

01:59:04.280 --> 01:59:05.720
sehe ich gerade völlig vertauscht.

01:59:06.260 --> 01:59:07.820
Das ist gar nicht die Bibliothek, die eine

01:59:07.820 --> 01:59:10.300
die eine fertige Algorithmus nimmt,

01:59:10.300 --> 01:59:12.180
sondern die generiert dir erstmal nur den Zufall

01:59:12.180 --> 01:59:14.360
darunter und generiert

01:59:14.360 --> 01:59:15.260
erstmal nur zufällige Werte.

01:59:16.120 --> 01:59:18.200
Die richtige Bibliothek, um halt Passwörter zu herstellen, wäre

01:59:18.200 --> 01:59:19.000
sowas wie B-Crypt.

01:59:22.100 --> 01:59:23.740
Da haben wir das auch noch reingekriegt.

01:59:24.740 --> 01:59:26.300
Ja, schön,

01:59:26.400 --> 01:59:28.200
dass ihr alle dabei seid. Danke, Philipp, dass du Zeit gefunden hast

01:59:28.200 --> 01:59:29.380
für uns. Ja, voll gut.

01:59:30.960 --> 01:59:32.140
Eine sehr interessante Episode.

01:59:32.340 --> 01:59:33.280
Ja, auch für mich sehr interessant.

01:59:33.280 --> 01:59:35.200
Ja, vielen Dank,

01:59:35.300 --> 01:59:35.980
dass ich dabei sein durfte.

01:59:36.360 --> 01:59:39.220
Wenn ich noch einmal ganz kurz Werbung

01:59:39.220 --> 01:59:41.040
machen darf, bei Coxine suchen wir immer

01:59:41.040 --> 01:59:42.060
Python-Entwickler.

01:59:44.040 --> 01:59:45.140
Aktuell suchen wir auf jeden Fall

01:59:45.140 --> 01:59:47.140
Python-Entwickler oder auch Leute, die mit

01:59:47.140 --> 01:59:49.060
Java oder mit JavaScript arbeiten,

01:59:49.500 --> 01:59:50.340
speziell mit React.

01:59:50.900 --> 01:59:52.940
Also wenn ihr ein guter Entwickler seid,

01:59:53.080 --> 01:59:54.580
vielleicht sogar im Raum Düsseldorf oder

01:59:54.580 --> 01:59:56.900
auch nur ganz grob in NRW irgendwo,

01:59:57.520 --> 01:59:58.940
dann meldet euch bei Baboxine.

01:59:59.840 --> 02:00:01.120
Die Tonybox zu programmieren

02:00:01.120 --> 02:00:02.920
macht wirklich, die Dienste

02:00:02.920 --> 02:00:04.960
rund um die Tonybox zu programmieren, macht sehr

02:00:04.960 --> 02:00:06.760
viel Spaß. Es ist total toll zu wissen,

02:00:06.760 --> 02:00:08.400
okay, jede Nacht

02:00:08.400 --> 02:00:10.700
gehen

02:00:10.700 --> 02:00:12.500
Tausende oder Millionen Kinder

02:00:12.500 --> 02:00:14.800
mittlerweile mit der Tonybox ins Schlaf und

02:00:14.800 --> 02:00:16.680
wir machen gute Dienste, die

02:00:16.680 --> 02:00:18.060
die hoffentlich den Eltern

02:00:18.060 --> 02:00:20.380
das Leben einfach machen und

02:00:20.380 --> 02:00:22.400
dafür sorgen, dass die Kinder gute Geschichten hören.

02:00:23.040 --> 02:00:24.380
Das war die erste Werbeanzeige

02:00:24.380 --> 02:00:25.040
im Preißen-Podcast.

02:00:25.520 --> 02:00:28.740
Ja, aber ich kann nicht nur...

02:00:28.740 --> 02:00:29.900
Könnt ihr rausschneiden, falls...

02:00:29.900 --> 02:00:31.680
Nein, nein, nein, das finde ich super.

02:00:31.840 --> 02:00:34.640
Das ist ein schönes Projekt

02:00:34.640 --> 02:00:35.180
hier aus der Gegend.

02:00:37.340 --> 02:00:38.700
Ja, alles klar,

02:00:38.740 --> 02:00:39.860
dann würde ich sagen... Ja, vielen Dank, Philipp.

02:00:39.860 --> 02:00:41.540
Und bleibt uns gewogen.

02:00:41.840 --> 02:00:43.600
Egal, wann ihr uns hört, schaltet wieder ein.

02:00:44.320 --> 02:00:45.420
Morgens, mittags, abends, tags, nachts.

02:00:45.560 --> 02:00:46.820
einschlafen, das ist auch immer super.

02:00:47.780 --> 02:00:49.240
Ja, liebe Grüße und bis zum nächsten Mal.

02:00:49.620 --> 02:00:50.440
Jo. Ja, tschüss.