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.860
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.560 --> 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.260 --> 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.480 --> 00:00:54.480
Oder wie haben wir sie genannt? Also intern hieß sie einfach

00:00:54.480 --> 00:00:56.820
Security. 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.400 --> 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:35.000 --> 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.660
es betrifft vor allen Dingen die

00:05:06.660 --> 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.920 --> 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.560
lange Zeit war das ganz,

00:06:09.040 --> 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 das leichteste, das ist die unterste Ebene, auf der wir jetzt anfangen.

00:09:41.240 --> 00:09:44.700
Ich finde das aber sehr spannend, weil was du sagtest, 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.880 --> 00:09:51.560
Und ich glaube, es war irgendwie, ich habe gerade nachgeguckt, 1945, als sie rausgekommen ist.

00:09:51.560 --> 00:09:57.060
Und diese Harvard-Architektur, die daneben liegt, die macht halt diese Getrennung von Daten und Programmspeicher.

00:09:57.540 --> 00:10:03.260
Und du sagst jetzt, es gibt auf dem CPU, also der CPU benutzt für alle Menschen, die da vielleicht nicht so drin sind,

00:10:04.100 --> 00:10:06.400
Opcodes, ja, 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.360
die ihm dazu geschickt werden,

00:10:13.360 --> 00:10:15.600
in den einzelnen, was sind das,

00:10:15.660 --> 00:10:17.260
Decks? Nein, Registern.

00:10:17.980 --> 00:10:18.940
Macht der dann diese Operation

00:10:18.940 --> 00:10:20.740
und

00:10:20.740 --> 00:10:22.460
da kann was schief gehen.

00:10:23.660 --> 00:10:25.320
Philipp, vielleicht kannst du das noch ein bisschen

00:10:25.320 --> 00:10:26.980
erklären, weil das irgendwie, klingt das sehr spannend.

00:10:29.020 --> 00:10:29.300
Ja, weil

00:10:29.300 --> 00:10:31.280
wenn ich einen ganz klassischen Buffer-Overflow habe,

00:10:31.380 --> 00:10:33.020
was dann halt passiert ist, wie gesagt, der Benutzer,

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

00:10:35.520 --> 00:10:37.000
oder in Wirklichkeit ist das der Angreifer,

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

00:10:39.640 --> 00:10:41.340
an. 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:45.260
wie Knob-Codes drin

00:10:45.260 --> 00:10:46.900
vorkommen. Und

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

00:10:49.680 --> 00:10:50.840
aber das ist halt genauso

00:10:50.840 --> 00:10:53.400
designt, dass man das auch

00:10:53.400 --> 00:10:55.440
als Ob-Codes für die CPU interpretieren kann.

00:10:55.960 --> 00:10:57.380
Und genau das ist das Problem dann

00:10:57.380 --> 00:10:59.180
nachher, dass der Entwickler dachte,

00:10:59.300 --> 00:11:01.740
okay, da kommt einfach nur Text rein, aber in Wirklichkeit

00:11:01.740 --> 00:11:03.240
hat der Angreifer den Text so geschickt

00:11:03.240 --> 00:11:05.220
konstruiert, dass er ein gültiges Programm ist.

00:11:06.240 --> 00:11:07.160
Und es ist sozusagen,

00:11:07.480 --> 00:11:08.400
wir können

00:11:08.400 --> 00:11:11.280
für die CPU, weil das konkret zu machen

00:11:11.280 --> 00:11:12.860
ist häufig sehr schwer so im Luftlernraum,

00:11:13.600 --> 00:11:14.940
aber weswegen ich schnell

00:11:14.940 --> 00:11:17.320
zur Neumann-Architektur gegangen bin, ist

00:11:17.320 --> 00:11:19.120
das Problem ist ein

00:11:19.120 --> 00:11:21.080
ganz grundsätzliches Architekturproblem

00:11:21.080 --> 00:11:23.200
und die Features,

00:11:23.340 --> 00:11:25.180
die wir jetzt da oben drüberlegen, wie zum Beispiel

00:11:25.180 --> 00:11:27.220
Non-Executable Pages und so ein Kram

00:11:27.220 --> 00:11:29.100
oder was dann halt auf

00:11:29.100 --> 00:11:30.060
anderen Ebenen kommt,

00:11:32.180 --> 00:11:33.880
Address Randomization und so ein Zeug.

00:11:35.100 --> 00:11:39.420
Das sind alles bloß kleine Trostplaster

00:11:39.420 --> 00:11:42.840
und man macht es den Angreifern schwerer

00:11:42.840 --> 00:11:45.580
und teilweise auch um Größenordnungen schwerer,

00:11:45.660 --> 00:11:46.520
dagegen anzukommen.

00:11:46.740 --> 00:11:50.780
Aber das Restrisiko kann in der Architektur halt nie weggehen.

00:11:50.900 --> 00:11:51.600
Sie wird nie weggehen.

00:11:51.600 --> 00:11:53.400
Und die Effekte, die wir aber sehen,

00:11:53.720 --> 00:11:56.380
lassen sich auf anderen Ebenen genauso wieder erklären.

00:11:57.100 --> 00:11:59.260
Und ein Buffer-Overflow lässt sich gut vergleichen

00:11:59.260 --> 00:12:01.820
und das ist für viele Leute wieder einfacher vorstellbar,

00:12:02.180 --> 00:12:04.020
wie mit einer SQL Injection.

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

00:12:05.820 --> 00:12:08.100
Eine 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.780
mein Name ist Bobby bla bla bla

00:12:11.780 --> 00:12:13.720
Semikolon Drop Tables

00:12:13.720 --> 00:12:16.100
und auch da ist es

00:12:16.100 --> 00:12:17.860
so, das Programm hat gedacht,

00:12:18.260 --> 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:27.800
Weil wir drücken ja alles

00:12:27.800 --> 00:12:29.740
als Text aus. Der Name ist

00:12:29.740 --> 00:12:32.000
Text 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.860
ich das eben nicht richtig

00:12:39.860 --> 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.960
gewesen wäre. Und der Trick ist ja eben der

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

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

00:12:52.140 --> 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.940 --> 00:13:03.380
dann geht da alles quer durcheinander.

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

00:13:08.020 --> 00:13:09.660
Also das Glas Milch, das zu voll ist

00:13:09.660 --> 00:13:10.620
und dann tropft das auf die Erde

00:13:10.620 --> 00:13:12.560
und dann hat man alles nass und denkt sich,

00:13:12.620 --> 00:13:13.000
oh nein.

00:13:13.780 --> 00:13:14.120
Ja, genau.

00:13:14.860 --> 00:13:16.640
Buffer-Overflow ist sozusagen die Variante von

00:13:16.640 --> 00:13:17.860
das Glas ist zu voll

00:13:17.860 --> 00:13:20.760
und auch Python schützt einen vor sowas

00:13:20.760 --> 00:13:22.380
im Prinzip erstmal nur im Sinne von,

00:13:22.380 --> 00:13:24.320
ja Python selber gibt sich extrem viel Mühe,

00:13:24.420 --> 00:13:25.580
selber keinen Mist zu machen.

00:13:26.100 --> 00:13:26.800
Wenn du aber,

00:13:26.900 --> 00:13:28.300
und ich habe mit sowas halt selber auch,

00:13:28.980 --> 00:13:29.780
also ich sage immer,

00:13:29.840 --> 00:13:30.860
ich fasse C nur dann an,

00:13:30.900 --> 00:13:32.080
wenn die anderen es verrissen haben.

00:13:32.580 --> 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.920 --> 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.880 --> 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.380 --> 00:13:52.440
Und es hat lange gehalten.

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

00:13:54.540 --> 00:13:55.940
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:00.900 --> 00:14:03.360
Und da ist es halt zum Beispiel so,

00:14:04.520 --> 00:14:07.440
nicht jeder Buffer-Overflow ist gleich halt als Security-Problem ausnutzbar.

00:14:07.440 --> 00:14:10.260
Bevor ich halt sozusagen selber Code ausführen kann,

00:14:10.620 --> 00:14:13.380
kommen noch andere Fehlerklassen oder Effekte vorher.

00:14:14.040 --> 00:14:16.000
Typischerweise ist das dann erstmal ein Denial of Service.

00:14:16.480 --> 00:14:18.480
Also zum Beispiel, dass halt das Programm crasht.

00:14:19.260 --> 00:14:21.020
Das ist erstmal noch nicht so dramatisch.

00:14:21.100 --> 00:14:23.860
Das ist natürlich auch aus dem Thema Availability

00:14:23.860 --> 00:14:26.720
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 einem Crash starte ich im schlimmsten Fall, starte ich normalerweise die Anwendung einfach neu, dann geht es weiter.

00:14:36.780 --> 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 Leuten verwendet werden, haben ein Minuszeichen drin.

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

00:14:52.760 --> 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.220 --> 00:15:11.140
Und das ist in Postgres auch okay, der hat die ganzen Encoding-Namen auch immer noch mit ohne Minus rumliegen.

00:15:12.060 --> 00:15:19.960
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.040 --> 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.740 --> 00:15:42.440
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.700 --> 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.840 --> 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 und 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.160 --> 00:16:54.480
Und das eine bei zu viel in einer sogenannten Arena im Small Object Allocator ist der Pointer auf die nächste Arena.

00:16:55.980 --> 00:17:02.580
Und der landet dann halt im Nirvana und dann gibt es halt einen Zeg-Fault und dann sagt das Linux halt, so geht es hier nicht.

00:17:03.860 --> 00:17:08.380
Und das ist ein typisches Beispiel für, da hat jemand dann einen zu kleinen Buffer alloziiert, 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.320 --> 00:17:26.480
Und der Effekt muss noch nicht sein, dass jemand Code ausführen kann, 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.140 --> 00:17:41.900
Genau, es könnte 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.480 --> 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 irgend so eine Remote-Verwaltungssoftware. Ich weiß nicht, den Namen wieder vergessen.

00:18:01.280 --> 00:18:02.400
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.220 --> 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.460 --> 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.100 --> 00:18:23.300
Ja, das ist im Deutschen, haben wir das sozusagen

00:18:23.300 --> 00:18:25.240
nicht getrennt. Ich finde das eigentlich so

00:18:25.240 --> 00:18:27.420
ein schönes Beispiel, dass

00:18:27.420 --> 00:18:29.500
Konzepte

00:18:29.500 --> 00:18:31.620
mit extra Begriffen in anderen

00:18:31.620 --> 00:18:33.420
Sprachen einem nochmal einen neuen Blick liefern,

00:18:34.020 --> 00:18:35.620
dass Sicherheit im Englischen halt mit

00:18:35.620 --> 00:18:37.680
Security und mit Safety übersetzt

00:18:37.680 --> 00:18:39.040
werden kann. Und Safety ist halt die

00:18:39.040 --> 00:18:41.840
auf Menschenleben und körperliche Unversehrtheit

00:18:41.840 --> 00:18:43.860
bezogene Perspektive

00:18:43.860 --> 00:18:45.680
von Sicherheit. Und Security ist

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

00:18:48.160 --> 00:18:49.680
Aber kannst du das denn in der modernen Gesellschaft

00:18:49.680 --> 00:18:50.620
wirklich auseinanderhalten?

00:18:51.380 --> 00:18:53.640
Ja, das ist halt sozusagen genau das Thema, dass man

00:18:53.640 --> 00:18:55.720
das, und damit

00:18:55.720 --> 00:18:57.100
machen wir jetzt einen schönen nächsten Bogen,

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

00:18:59.500 --> 00:19:02.820
Also ich stelle mir gerade die Gesichtsbemalung vor,

00:19:02.920 --> 00:19:05.520
die dazu führt, dass die Kamera den Algorithmus verändert

00:19:05.520 --> 00:19:10.780
und ein anderes Gesicht immer in die Daten erkennen lässt.

00:19:10.940 --> 00:19:13.780
Und dann kann ich mich tarnen mit einer gewissen Schminke

00:19:13.780 --> 00:19:14.880
und als jemand anderes ausgeben.

00:19:15.300 --> 00:19:17.820
Weil der Algorithmus dadurch denkt, ich bin jemand anderes,

00:19:17.880 --> 00:19:19.420
weil ich einen anderen Gesichtshash bekomme oder so.

00:19:20.520 --> 00:19:22.700
Das ist so spannend in dem ganzen Machine Learning Umfeld,

00:19:22.800 --> 00:19:24.360
dass du diese adversarial Models hast,

00:19:24.780 --> 00:19:28.060
dass du sozusagen auf der einen Seite ein Model haben kannst,

00:19:28.160 --> 00:19:30.060
was Dinge erkennt und jemand anders weiß aber,

00:19:30.200 --> 00:19:34.920
wie er auf Basis eines Models Outputs generiert,

00:19:35.160 --> 00:19:37.720
die dieses Model dann wieder aus dem Takt bringen.

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

00:19:40.900 --> 00:19:41.620
obwohl man andere Sachen ...

00:19:41.620 --> 00:19:48.160
Die Ecke von Philipp fand ich jetzt nochmal wichtig und spannend,

00:19:48.160 --> 00:19:51.100
dass halt dieses Thema, ah, hier passiert ja nichts Schlimmes,

00:19:51.560 --> 00:19:55.260
das Interessante ist eben, durch dieses Architekturproblem

00:19:55.260 --> 00:19:57.240
trifft es halt alle und jeden.

00:19:57.360 --> 00:20:04.540
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.120 --> 00:20:09.800
Den schreibt man jetzt und der ist da und ganz ehrlich, Leute, die Code finden, werden ihn benutzen.

00:20:10.760 --> 00:20:15.720
Er wird irgendwo benutzt werden und er wird für Dinge benutzt werden, die man sich nicht vorgestellt hat.

00:20:16.700 --> 00:20:25.280
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:25.900 --> 00:20:30.520
Ah ja, dann mach mal ein Projekt mit NPM-Paketen oder sowas.

00:20:30.740 --> 00:20:34.220
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.860 --> 00:20:48.620
Ich finde, die Leute haben keine moralische Verpflichtung

00:20:48.620 --> 00:20:50.980
anderen gegenüber aus ihrem Freizeitprojekt,

00:20:50.980 --> 00:20:55.680
wo sie sagen, da steckt einfach nur meine Lust und meine persönliche Motivation drin.

00:20:55.900 --> 00:20:57.880
anderen Garantien auszusprechen,

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

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

00:21:01.540 --> 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:06.900
ist es natürlich

00:21:06.900 --> 00:21:08.880
ein

00:21:08.880 --> 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.820 --> 00:21:23.600
Ja, ich meine, 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.620 --> 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.000 --> 00:21:42.180
Nein.

00:21:44.180 --> 00:21:47.020
Zu viele Leute gehen nämlich ohne

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

00:21:49.520 --> 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.840
und halt entsprechend in die Sicherheit

00:21:57.840 --> 00:21:58.460
investieren.

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

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

00:22:04.220 --> 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.320
wer sich unsicher fühlt und einen Helm aufsetzt, ist

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

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

00:22:21.980 --> 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.360 --> 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.660 --> 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:10.300 --> 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.660 --> 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.600 --> 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.760 --> 00:25:01.120
Das ist dann halt immer, also da herzugehen und zu sagen, ich hätte jetzt hier gerne mal schnell eine HTTP-Library und ich würde ja noch mal von der SSL, noch mal da drüben, Repository von GitHub, sowas ist bei aller halt eher nicht so an der Tagesordnung.

00:25:01.280 --> 00:25:29.160
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, ja, das, 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, ähm, und da muss man immer aufpassen, dass es halt kontextbezogen ist.

00:25:29.160 --> 00:25:43.460
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.400 --> 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.600 --> 00:26:08.000
Ich glaube, auch die Steuerungssoftware dafür ist auch in ALA geschrieben

00:26:08.000 --> 00:26:09.440
oder so und die ist sogar

00:26:09.440 --> 00:26:12.180
bewiesen, dass die tatsächlich

00:26:12.180 --> 00:26:14.180
das tut, was in der Spezifikation steht.

00:26:14.980 --> 00:26:16.040
Nur das Problem

00:26:16.040 --> 00:26:18.400
ist halt, sie haben irgendwie die falsche Spezifikation

00:26:18.400 --> 00:26:19.700
verwendet.

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

00:26:21.360 --> 00:26:24.100
Die Spezifikation war halt für die alten Motoren

00:26:24.100 --> 00:26:25.200
irgendwie und dann

00:26:25.200 --> 00:26:27.560
waren die Sensordaten

00:26:27.560 --> 00:26:29.800
für den Computer halt

00:26:29.800 --> 00:26:31.160
irgendwie so, nee, das kann nicht sein.

00:26:31.600 --> 00:26:32.820
Aber es ist ja bewiesen,

00:26:33.540 --> 00:26:35.400
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.720 --> 00:26:45.220
Und ja, das

00:26:45.220 --> 00:26:47.560
ist ja auch sowas. Ich meine, klar, man kann halt

00:26:47.560 --> 00:26:49.600
beweisen manchmal, dass Programme das tun, was sie tun

00:26:49.600 --> 00:26:51.480
sollen, aber dann muss man ja immer noch sicher

00:26:51.480 --> 00:26:53.480
sein können, dass die Spezifikation

00:26:53.480 --> 00:26:55.480
richtig ist. Aber irgendwie, man kommt

00:26:55.480 --> 00:26:56.920
da in so einen infiniten Regress und

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

00:26:59.620 --> 00:27:01.440
Das war jetzt ein Fall, wo ein Hardware-Update

00:27:01.440 --> 00:27:03.160
dazu geführt hat, dass das Ding nicht mehr lief.

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

00:27:08.900 --> 00:27:09.720
Aber auch in Python

00:27:09.720 --> 00:27:11.480
hat man ja nicht völlig verloren. Also auch wenn

00:27:11.480 --> 00:27:13.820
Python solche strengen Garantien nicht so direkt

00:27:13.820 --> 00:27:15.600
hat, man kann natürlich Assertions einbauen

00:27:15.600 --> 00:27:17.520
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.460
Wenn ich sage, ich baue hier eine Assertion ein und sage, okay,

00:27:21.800 --> 00:27:23.520
ich erwarte, dass die Eingabe nur so lang ist

00:27:23.520 --> 00:27:25.520
oder ich erwarte, wie du eben als Beispiel gebracht hast,

00:27:25.580 --> 00:27:27.540
Christian, dass halt nur irgendwelche bestimmten Zahlen

00:27:27.540 --> 00:27:29.680
davor kommen, das kann ich auch in Python machen.

00:27:30.180 --> 00:27:31.560
Das geht, das macht den Code ein bisschen

00:27:31.560 --> 00:27:33.540
länger, da muss man sich ein paar Gedanken machen,

00:27:33.960 --> 00:27:35.240
aber das ist ja sicherlich auch ein

00:27:35.240 --> 00:27:37.820
Merkmal von qualitativen

00:27:37.820 --> 00:27:39.540
Code, dass man sich halt immer Gedanken macht, okay,

00:27:39.940 --> 00:27:41.640
was sind meine Eingangsbedingungen, was sind

00:27:41.640 --> 00:27:43.600
meine Bedingungen, die ich vielleicht

00:27:43.600 --> 00:27:45.360
rausgebe, dass ich auch schaue, okay, die Daten, die ich

00:27:45.360 --> 00:27:47.540
rausgebe, die kann ich in ein anderes

00:27:47.540 --> 00:27:49.560
Modul in meinem Programm, die kann ich auch nochmal validieren,

00:27:49.640 --> 00:27:51.280
dass da alles in Ordnung ist, dass das zum Beispiel

00:27:51.280 --> 00:27:53.040
irgendeinem Schema entspricht oder sowas,

00:27:53.680 --> 00:27:55.600
also das ist ja auch in Python nicht unmöglich und es gibt

00:27:55.600 --> 00:27:57.740
natürlich auch in Python noch sehr viele andere Sachen

00:27:57.740 --> 00:27:59.640
im Rahmen eines sicheren Prozesses, die ich

00:27:59.640 --> 00:28:01.620
durchführen kann. Also das beginnt ja bei ganz

00:28:01.620 --> 00:28:02.720
normalem Code-Review.

00:28:03.560 --> 00:28:05.600
Da guckt halt jemand anders drauf und sagt halt vielleicht,

00:28:05.720 --> 00:28:06.920
okay, der Code sieht komisch aus.

00:28:07.520 --> 00:28:09.560
Und dann kann ich halt sowohl Tests durchführen

00:28:09.560 --> 00:28:11.400
gegen den Source-Code, also dass ich

00:28:11.400 --> 00:28:13.220
mir den gesamten Source-Code nehme

00:28:13.220 --> 00:28:15.420
und ein automatisiertes Programm drüber laufen lasse,

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

00:28:17.720 --> 00:28:19.460
Hier machst du wahrscheinlich eine SQL-Injection

00:28:19.460 --> 00:28:21.600
oder NC, ein Buffer-Overflow, das sieht

00:28:21.600 --> 00:28:22.520
irgendwie gefährlich aus.

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

00:28:25.880 --> 00:28:27.520
fahren, wo ich sage, okay, ich starte meine Anwendung

00:28:27.520 --> 00:28:29.420
einfach mal und dann nehme ich mal so einen

00:28:29.420 --> 00:28:31.060
Hackertool und das probiert einfach mal aus.

00:28:31.440 --> 00:28:33.100
Kann ich hier komische Sachen eingeben und

00:28:33.100 --> 00:28:35.320
crashen in das Programm oder macht das Programm

00:28:35.320 --> 00:28:37.440
irgendwas komisches. Also auch in Python ist das

00:28:37.440 --> 00:28:38.640
nicht verloren. Da kann man

00:28:38.640 --> 00:28:40.940
auch sehr sichere Anwendungen schreiben,

00:28:41.640 --> 00:28:43.420
was meistens das gleiche ist wie eine gute

00:28:43.420 --> 00:28:45.280
Anwendung zu schreiben, weil die stürzt halt nicht ab

00:28:45.280 --> 00:28:47.400
und die kann auch mit allen Benutzerangaben

00:28:47.400 --> 00:28:49.320
umgehen. Und nicht mal nur von Angreifern,

00:28:49.400 --> 00:28:51.480
sondern auch von Benutzern. Also ich hatte das beruflich

00:28:51.480 --> 00:28:53.420
auch so. Wir haben, wir dachten

00:28:53.420 --> 00:28:55.000
erst, wir hätten einen Angreifer, weil unsere

00:28:55.000 --> 00:28:57.420
Anwendung abgestürzt ist, aber hat sich herausgestellt,

00:28:57.820 --> 00:28:59.360
wir hatten ein ähnliches Problem wie beim

00:28:59.360 --> 00:29:01.540
Buffer-Overflow, wir hatten ein Datenbankfeld mit einer bestimmten Länge

00:29:01.540 --> 00:29:03.320
und die Länge war aber

00:29:03.320 --> 00:29:05.480
in Bytes und dann kamen halt User an

00:29:05.480 --> 00:29:07.760
und haben ihre kleine Tony-Figur

00:29:07.760 --> 00:29:09.460
mit ganz viel Smileys genannt

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

00:29:11.220 --> 00:29:12.140
und

00:29:12.140 --> 00:29:15.360
führte zu einem Crash und auch sowas

00:29:15.360 --> 00:29:17.380
kann man natürlich auch vorher darauf achten und

00:29:17.380 --> 00:29:19.280
entsprechend auch

00:29:19.280 --> 00:29:20.580
testen, das ist ja noch ein anderer

00:29:20.580 --> 00:29:23.660
Bestandteil eines sicheren Prozesses,

00:29:24.140 --> 00:29:25.360
der jetzt sagen kann, ich schreibe

00:29:25.360 --> 00:29:27.260
vorher Tests und ich überlege mir entweder

00:29:27.260 --> 00:29:29.240
manuell oder sogar automatisiert, wie

00:29:29.240 --> 00:29:31.320
sehen komische Eingaben aus. Bei Nummern

00:29:31.320 --> 00:29:33.020
sind das meistens Null oder

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

00:29:36.540 --> 00:29:37.060
Typischerweise

00:29:37.060 --> 00:29:39.280
auch Zahlen, die vielleicht über

00:29:39.280 --> 00:29:41.160
die 32 Bytes hinausgehen, was

00:29:41.160 --> 00:29:42.580
in Python jetzt nicht so ein Problem ist oder

00:29:42.580 --> 00:29:45.200
über die 64 Bits

00:29:46.040 --> 00:29:47.200
hinausgehen. Also wenn

00:29:47.200 --> 00:29:49.080
ich da eine sehr große Zahl, wenn ich 2 hoch 64

00:29:49.080 --> 00:29:50.960
plus 1 schreibe, 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:54.180
führt das halt zu einem

00:29:54.180 --> 00:29:57.240
Absturz oder zu komischem Verhalten.

00:29:57.960 --> 00:29:59.060
Und damit kann ich auch

00:29:59.060 --> 00:30:00.400
in Python, glaube ich, sehr gut Sicherheit

00:30:00.400 --> 00:30:03.080
sichern. Also du würdest

00:30:03.080 --> 00:30:05.080
tatsächlich in solchen kritischen Fällen, wo du

00:30:05.080 --> 00:30:06.800
überlegst, 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:10.940
und dann sagen, Assert, this should never happen

00:30:10.940 --> 00:30:12.900
oder sowas. 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.180
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.520 --> 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.500 --> 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.100 --> 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:30.440
Wer sind deine Angreifer? Was haben die für Motivationen? Was haben die für Ressourcen? Und jetzt gucken wir mal, wie mappen wir das alles aufeinander? Wie sind deine Assets mit was geschützt gegenüber welchen Angriffsszenarien?

00:37:31.860 --> 00:37:38.260
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.640 --> 00:37:43.780
Wenn du Logging machst, dann musst du dir über die Integrität vom Log Gedanken machen, dann musst du dir über Zeitstempel Gedanken machen.

00:37:44.320 --> 00:37:51.940
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.

00:37:52.020 --> 00:37:57.120
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.320
Ja, also man muss

00:38:33.320 --> 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 jetzt mal an, was du so in Python oder auch in anderen Programmiersprachen alles programmiert hast.

00:39:01.780 --> 00:39:06.820
Und das sind dann erfahrene Entwickler in 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.920 --> 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.860
Da brauchen wir halt gute Angreifer auch, die so ein bisschen ein paar Tricks kennen.

00:39:37.320 --> 00:39:39.580
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.080 --> 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.600 --> 00:40:01.880
Haben wir nur eine ganz kleine Schwachstelle oder ist unsere Admin-Oberfläche ohne Benutzernamen 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.600 --> 00:40:39.600
Also 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, aber wenn ich halt fünf Scheiben Schweizer Käse hintereinander lege, ist die Filtrationsrate dann doch relativ gut.

00:40:40.200 --> 00:41:08.760
Dass also wirklich über fünf Schichten an der gleichen Stelle überall die Löcher sind, das passiert halt normalerweise nicht und deswegen würde ich halt es immer, also aus meiner dann längerfristigen Erfahrung, würde ich halt sagen, es kommt immer auf den Kontext drauf an, 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:10.120 --> 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.680 --> 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.060 --> 00:42:20.860
Also ich habe zum Beispiel ein paar Kunden, denen gucke ich über die Schulter und da weiß ich dann so, okay, bei dir knall ich da jetzt eine Waffe davor, weil ansonsten traue ich mich nicht, das ins Netz rauszulassen. Du sagst mir, es muss raus ins Netz.

00:42:22.260 --> 00:42:35.020
Das ist das gleiche Prinzip wie ein Virenscanner, also da habe ich irgendwie ein Muster, das ich suche, bei einer Basis, und sage, okay, wenn ich das Muster finde, dann mache ich irgendwas, dann unterbinde ich die Anfrage, oder schmeiße das Muster raus, oder mache irgendwas.

00:42:35.020 --> 00:42:48.760
Genau, das ist schon ein bisschen gefährlich, weil eine Möglichkeit ist halt schon, wie bei einem Virenscanner, die Wald- und Wiesenattacken findet der sicherlich, was im Internet das Grundrauschen ist, das findet er auf jeden Fall.

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

00:42:51.340 --> 00:42:53.600
dann merkst du dich da vielleicht auch in falscher Sicherheit.

00:42:54.220 --> 00:42:56.240
Weil man halt dann doch immer...

00:42:56.240 --> 00:42:57.640
Also du hast recht mit dem Schweizer Käse-Modell,

00:42:57.720 --> 00:42:58.860
das macht es vielleicht ein bisschen besser.

00:42:59.280 --> 00:43:02.140
Aber gleichzeitig kann ja so ein Waff auch wieder ein Angriffsmodell sein,

00:43:02.220 --> 00:43:03.800
weil der muss ja auch wieder alles interpretieren.

00:43:04.260 --> 00:43:07.180
Und ein Problem kann halt sein, dass mein Server davor und mein Server danach

00:43:07.180 --> 00:43:10.540
sowieso schon unterschiedliche Details anders interpretieren.

00:43:10.540 --> 00:43:12.840
Also bei HTTP zum Beispiel Junk Encoding

00:43:12.840 --> 00:43:16.240
oder irgendwelche komischen HTTPS-Optionen anders interpretieren.

00:43:16.620 --> 00:43:19.020
Und dass dann die Waff sogar noch ein neues Problem aufmacht,

00:43:19.100 --> 00:43:20.720
dass sie die Sachen anders interpretiert

00:43:20.720 --> 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.800 --> 00:43:27.200
Ne, genau. Deswegen ist es auch für uns zum Beispiel

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

00:43:29.040 --> 00:43:31.120
drüber gießen, sondern das ist halt, wir haben

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

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

00:43:34.480 --> 00:43:37.040
dann 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.180 --> 00:43:44.680
Und wenn,

00:43:45.000 --> 00:43:46.980
das muss er ja anbieten können erstmal in dem Moment,

00:43:47.020 --> 00:43:49.080
wenn er 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.220 --> 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.220 --> 00:44:01.680
dass tatsächlich diese Wald- und Wiesenscans

00:44:01.680 --> 00:44:03.440
und Angriffe gerne mal

00:44:03.440 --> 00:44:04.600
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:17.580
und die Anwendung dadurch in Performance-Probleme

00:44:17.580 --> 00:44:18.920
gerät. Und

00:44:18.920 --> 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
Sequel-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.600 --> 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.200
wurde, weil es halt

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

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

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

00:44:51.080 --> 00:44:55.340
aus Komplexitätsperspektive

00:44:55.340 --> 00:44:56.460
hast du immer das Problem der

00:44:56.460 --> 00:44:58.860
Kombinatorik. Das heißt, wenn du

00:44:58.860 --> 00:45:01.080
n Dinge hast, die miteinander reden,

00:45:01.520 --> 00:45:03.100
dann hast du halt n Quadrat Verbindungen

00:45:03.100 --> 00:45:04.680
mindestens. Und

00:45:04.680 --> 00:45:07.000
wenn du jetzt sagst, okay, das ist mir

00:45:07.000 --> 00:45:08.500
zu unsicher, ich packe noch eins davor.

00:45:09.640 --> 00:45:11.540
Dann hast du halt

00:45:11.540 --> 00:45:12.700
etwas als Quadrat.

00:45:12.820 --> 00:45:14.960
Das Problem ist, glaube ich, an der Stelle auch,

00:45:14.960 --> 00:45:17.100
wer halt irgendwie diese Architektur

00:45:17.100 --> 00:45:19.200
entscheidet und so und wem man da vertrauen kann.

00:45:19.300 --> 00:45:21.040
Gerade wenn Leute jetzt keine Ahnung haben von

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

00:45:23.360 --> 00:45:25.400
aber irgendwie Software als Manager irgendwie bestellen

00:45:25.400 --> 00:45:26.840
wollen. Die haben ja eine unheimliche

00:45:26.840 --> 00:45:29.000
Asymmetrie gegenüber den auch

00:45:29.000 --> 00:45:31.180
Entwicklern und so und die müssen halt vertrauen

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

00:45:33.240 --> 00:45:35.380
und die stellen sich dann meistens so ein Sammelsurium

00:45:35.380 --> 00:45:37.620
an, weiß nicht, Angebot und Nachfrage

00:45:37.620 --> 00:45:39.240
oder Best Practice oder irgendwas,

00:45:39.380 --> 00:45:40.920
was die halt an Informationen saugen können zusammen

00:45:40.920 --> 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.580 --> 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.960
ist fast eine unmögliche Aufgabe

00:45:56.960 --> 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.640 --> 00:46:17.820
oder wie der Prozess halt aussehen muss

00:46:17.820 --> 00:46:22.060
und wo man Sicherheits, ja, was ist das, Netze einzieht.

00:46:22.060 --> 00:46:26.900
Oder, ja, die Frage ist halt,

00:46:27.280 --> 00:46:29.800
welche Angriffsmöglichkeiten man irgendwie zur Verfügung stellen möchte.

00:46:29.940 --> 00:46:31.160
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.760
wo man dann draufhauen kann.

00:46:37.460 --> 00:46:38.720
Ja, die Versuchung ist ja nicht groß,

00:46:38.800 --> 00:46:42.060
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.520
und hoffe dann, dass das damit

00:46:56.520 --> 00:46:58.440
okay ist, 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:05.000 --> 00:47:06.520
wenn man die gesamte

00:47:06.520 --> 00:47:08.480
Software direkt so anlegt, dass man sagt, okay, bei der

00:47:08.480 --> 00:47:10.220
Produktion der Software, ich mache mir vielleicht

00:47:10.220 --> 00:47:12.480
vorher Gedanken, ich würde nicht mal sagen, viel über

00:47:12.480 --> 00:47:14.660
die eigentlichen Zertifizierungen

00:47:14.660 --> 00:47:16.500
oder die Prozesse, sondern

00:47:16.500 --> 00:47:18.720
vielleicht mehr, wie lasse ich die entwickeln?

00:47:18.900 --> 00:47:20.440
Wie sorge ich dafür, dass, wie gesagt,

00:47:20.580 --> 00:47:21.960
wie ich eben erwähnt hatte, Code-Review,

00:47:22.440 --> 00:47:24.460
also wie sorge ich dafür, dass das halt schon

00:47:24.460 --> 00:47:26.840
bei der

00:47:26.840 --> 00:47:28.360
Entwicklung direkt die Software sicher ist, weil

00:47:28.360 --> 00:47:30.160
nachher das draufzubauen ist immer schwieriger.

00:47:30.520 --> 00:47:32.260
Also nachher mit dem Scanner zu suchen ist, glaube ich,

00:47:32.280 --> 00:47:34.160
schwieriger als zu sagen, okay, ich habe

00:47:34.160 --> 00:47:36.380
Entwickler, die sich direkt darüber Gedanken

00:47:36.380 --> 00:47:38.480
machen. Das ist ja zum Beispiel total kaputt.

00:47:38.600 --> 00:47:40.120
Also ich hatte jetzt irgendwie mal so die

00:47:40.120 --> 00:47:41.700
Situation, dass so ein Konzern da war,

00:47:42.220 --> 00:47:56.780
Die wollten dann Software bereitstellen und dann haben sie gesagt, nee, aber neue Software ist irgendwie komisch, wir wollen die alle auditieren vorher so persönlich, also als Security-Team und haben dann so ein Service dann rausgebracht, dann jetzt im November und da war dann Django 1.10.4, weil das dann die sichere Version war.

00:47:56.780 --> 00:48:09.280
Das ist also LTS war 1.11 für alle, die es noch wissen. Das ist halt schon ein altes System und da gibt es halt dann irgendwie schon jede Menge irgendwie Exploits, wenn man irgendwie genug nach sucht, die irgendwo drinstehen und das wird dann von den Leuten irgendwie geauditet und man fragt sich halt, okay, was machen die denn da eigentlich?

00:48:09.720 --> 00:48:11.540
warum tun die das? Und das ist halt

00:48:11.540 --> 00:48:13.460
vielleicht so ein, ja, das kriegt man glaube ich

00:48:13.460 --> 00:48:15.100
gar nicht so gut in den Griff. Das ist halt wieder der Griff in Richtung

00:48:15.100 --> 00:48:17.000
Product Security statt Process Security.

00:48:18.340 --> 00:48:18.500
Die,

00:48:19.780 --> 00:48:21.500
also ein prozesshafter Ansatz

00:48:21.500 --> 00:48:23.160
und wir haben jetzt ja auch seit anderthalb Jahren,

00:48:23.300 --> 00:48:25.440
doch seit ein bisschen mehr als anderthalb Jahren

00:48:25.440 --> 00:48:26.860
machen wir bei uns ISO 27000

00:48:26.860 --> 00:48:28.620
und

00:48:28.620 --> 00:48:31.140
der Trick ist halt bei vielen,

00:48:31.560 --> 00:48:33.520
die prozesshaften Security-Sachen werden

00:48:33.520 --> 00:48:35.460
häufig missverstanden, weil

00:48:35.460 --> 00:48:37.120
die Standards, die es dazu gibt,

00:48:37.880 --> 00:48:39.440
wie eine Keule aussehen, obwohl sie

00:48:39.440 --> 00:48:41.540
eigentlich gar nicht so schlimm sind. Man muss da

00:48:41.540 --> 00:48:43.180
bloß, wenn man die Standards interpretiert,

00:48:43.320 --> 00:48:45.400
immer unterscheiden zwischen, was fordert der

00:48:45.400 --> 00:48:47.460
Standard formal und was ist im nächsten

00:48:47.460 --> 00:48:48.520
Satz schon nur noch die

00:48:48.520 --> 00:48:51.200
Implementationsguideline,

00:48:51.600 --> 00:48:53.220
wo man dann eigentlich selber

00:48:53.220 --> 00:48:55.620
Hoheit hat. Also ich habe halt auch jemanden,

00:48:55.680 --> 00:48:57.840
der meinte, ja, ISO 27000,

00:48:58.280 --> 00:48:59.360
seitdem müssen wir

00:48:59.360 --> 00:49:01.400
sämtliche Stromkabel einmal

00:49:01.400 --> 00:49:03.120
im Jahr irgendwie

00:49:03.120 --> 00:49:04.920
auf die Erdung prüfen.

00:49:05.660 --> 00:49:07.220
Also, nee, musst du nicht,

00:49:07.220 --> 00:49:09.020
ich habe auch eine ISO 27000, aber dann müsst ihr das doch auch mal so,

00:49:09.100 --> 00:49:09.900
nee, müssen wir nicht.

00:49:10.600 --> 00:49:12.540
Ja, aber, aber, 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:16.960
nein, die ISO sagt, du musst dich halt

00:49:16.960 --> 00:49:19.880
um die für dich relevanten Normen und Vorschriften kümmern.

00:49:20.340 --> 00:49:21.840
Das sagt die ISO 27000.

00:49:22.420 --> 00:49:23.300
Also macht man das.

00:49:24.100 --> 00:49:26.160
Und die sagt aber auch, du musst sie bewerten

00:49:26.160 --> 00:49:29.740
und musst dann Schlussfolgerungen für dich daraus ziehen.

00:49:30.620 --> 00:49:33.280
Und es ist völlig legitim, im Rahmen der ISO zu sagen,

00:49:33.460 --> 00:49:35.100
ja, wir haben zur Kenntnis genommen,

00:49:35.220 --> 00:49:37.680
dass ortsveränderliche elektrische Verbraucher

00:49:37.680 --> 00:49:39.760
irgendwie alle zwei Jahre auf X geprüft werden müssen.

00:49:41.140 --> 00:49:41.920
Machen wir nicht.

00:49:42.860 --> 00:49:43.920
Aber jetzt kannst du doch mal

00:49:43.920 --> 00:49:45.780
erklären, was für eine Lücke das offen lassen

00:49:45.780 --> 00:49:47.580
könnte, warum man das testen

00:49:47.580 --> 00:49:48.840
wollen möchte.

00:49:49.760 --> 00:49:51.680
So, naja, ISO als Prozess, die ISO

00:49:51.680 --> 00:49:53.520
als Informationssicherheitsprozess

00:49:53.520 --> 00:49:55.740
ist extrem umfassend und

00:49:55.740 --> 00:49:58.060
zwingt dich dazu, den kompletten

00:49:58.060 --> 00:49:59.200
Wertschöpfungsprozess

00:49:59.200 --> 00:50:01.440
von einem IT-System zu betrachten.

00:50:01.540 --> 00:50:03.080
Da gehört halt dann unter anderem auch dazu,

00:50:04.000 --> 00:50:05.660
dass du eben

00:50:05.660 --> 00:50:08.060
rechtliche Rahmenbedingungen bewertest

00:50:08.060 --> 00:50:09.920
etc., weil du musst

00:50:09.920 --> 00:50:11.740
am Ende immer für alle deine Assets

00:50:11.740 --> 00:50:13.400
und Philipp hat das halt schon,

00:50:13.760 --> 00:50:15.460
die vier Grundsicherheitsaspekte,

00:50:15.940 --> 00:50:17.220
also bei uns sind sie aufgeschlossen,

00:50:17.480 --> 00:50:19.080
manchmal wären es drei, manchmal wären es vier,

00:50:19.800 --> 00:50:21.560
halt nach Vertraulichkeit,

00:50:21.680 --> 00:50:24.060
Confidentiality, nach Integrität,

00:50:24.380 --> 00:50:26.260
Integrity, nach Authentizität

00:50:26.260 --> 00:50:28.220
und nach Availability

00:50:28.220 --> 00:50:29.300
zu schütten.

00:50:29.320 --> 00:50:31.800
Und was hat das jetzt damit zu tun, dass da so ein Stromkabel ist,

00:50:31.920 --> 00:50:34.180
in das sich... Ja, Strom ist zum Beispiel für die Availability

00:50:34.180 --> 00:50:36.260
wichtig. Okay, also

00:50:36.260 --> 00:50:38.400
Availability, okay. Und du misst

00:50:38.400 --> 00:50:40.400
halt dann da quasi nur die Stromleitung, um zu testen, ob das Ding

00:50:40.400 --> 00:50:42.500
irgendwann mal ausfällt. Na, es ist halt

00:50:42.500 --> 00:50:44.200
eine deutsche Norm, die kommt aus dem

00:50:44.200 --> 00:50:45.720
ich weiß nicht, welches ist,

00:50:46.180 --> 00:50:48.140
die schreibt halt vor, dass halt alle

00:50:48.140 --> 00:50:50.720
ortsveränderlichen Verbraucher

00:50:50.720 --> 00:50:52.420
auf Fehlerstrom

00:50:52.420 --> 00:50:54.400
zu prüfen sind, alle zwei Jahre halt so.

00:50:54.540 --> 00:50:56.360
Und wenn die ISO halt sagt, du musst halt

00:50:56.360 --> 00:50:58.680
alle für dich gültigen Rechtsnormen

00:50:58.680 --> 00:51:00.300
berücksichtigen und

00:51:00.300 --> 00:51:02.340
überwachen etc., dann schlägt sowas halt auch zu.

00:51:02.500 --> 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.520 --> 00:51:11.760
Und du sollst für dich daraus ableiten, ob das jetzt was ist, was relevant ist oder nicht.

00:51:11.820 --> 00:51:18.340
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.460 --> 00:51:21.140
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 News eindringt.

00:51:27.060 --> 00:51:32.140
Das Stromkabel, also das kann zum Beispiel passieren, wenn du deinen Prozess so aufstellst und sagst,

00:51:32.200 --> 00:51:35.100
naja, Stromkabel sind für uns keine sicherheitsrelevanten Dinge,

00:51:36.260 --> 00:51:40.740
deswegen kaufen wir die aus der Grabbelkiste beim Euroshop nebenan.

00:51:42.180 --> 00:51:45.200
Das heißt, dann verkaufen die dir plötzlich en masse Dinge,

00:51:45.400 --> 00:51:49.420
wo sie wissen, in einem halben Jahr geht da drinnen irgendwas kaputt

00:51:49.420 --> 00:51:52.680
und dann geht bei dir im Rechenzentrum mit einem Mal das Licht aus

00:51:52.680 --> 00:51:54.140
und dann ist deine Verfügbarkeit hin.

00:51:55.060 --> 00:51:57.560
Und weil dein Redundanzkonzept natürlich davon ausging,

00:51:57.980 --> 00:52:00.300
dass dir niemand so ein Ding untergejubelt hat,

00:52:00.580 --> 00:52:04.020
mit der Absicht, dass da ein kleiner Sollbruchkondensator oder irgendwas drin ist,

00:52:04.100 --> 00:52:08.640
der dann halt nach so und so viel schönen Laufzeit einfach eine Schmelzsicherung durchgehen lässt.

00:52:09.540 --> 00:52:12.380
Also das hat jetzt glaube ich auch erstmal nur relevant für so Atomkraftwerke oder sowas,

00:52:12.460 --> 00:52:14.900
die halt dann vernünftige Kühlung brauchen.

00:52:15.200 --> 00:52:20.120
Nein, das kommt auf deine Angreifer und die Motivation der Angreifer drauf an.

00:52:20.720 --> 00:52:23.740
Also die Story da drumherum wäre zum Beispiel, jemand zu sagen,

00:52:23.740 --> 00:52:29.300
wir betreiben Dienste sehr, sehr lange, teilweise 10, 15 Jahre und länger.

00:52:29.900 --> 00:52:43.560
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.060 --> 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.140 --> 00:53:02.240
Und wenn du dann halt sagst, naja, wenn da jemand ein richtiges Long Game spielt und sagt, ich habe hier drei Jahre Zeit, das ist nicht das Problem.

00:53:02.980 --> 00:53:07.700
Ich will aber, dass diese NGO mal so richtig gegen die Wand fährt, dann fahre ich jetzt die Lücke und sage,

00:53:07.700 --> 00:53:13.000
aha, ich habe rausgefunden, deren Hoster kauft immer irgendwie aus der Grabbelkiste die Stromkabel.

00:53:13.300 --> 00:53:16.280
Das dauert jetzt, naja, der tauscht nur so und so oft die Stromkabel aus.

00:53:16.880 --> 00:53:21.980
Aber wenn ich es schaffe, irgendwie einen Drittel seiner Stromkabel durch meine mit dieser Schmelzsicherung zu ersetzen,

00:53:22.440 --> 00:53:24.360
dann bin ich in drei Jahren so weit, dass dann irgendwie

00:53:24.360 --> 00:53:25.700
bei dem das RZ implodiert.

00:53:28.340 --> 00:53:30.320
Das ist sozusagen die...

00:53:30.320 --> 00:53:31.640
Und da muss man immer aufpassen.

00:53:33.420 --> 00:53:34.300
Da kommt dieser...

00:53:34.300 --> 00:53:36.520
Welcher XKCD ist das mit der hohen Verschlüsselung

00:53:36.520 --> 00:53:38.580
und der 5-Dollar-

00:53:38.580 --> 00:53:39.520
Entschlüsselungsmaschine?

00:53:40.720 --> 00:53:41.880
XKCD, bitte nochmal einmal.

00:53:43.360 --> 00:53:43.760
XKCD?

00:53:44.360 --> 00:53:44.760
Comic.

00:53:46.860 --> 00:53:50.800
Wo die Idee ist,

00:53:50.840 --> 00:53:52.380
dass wir eine ganz, ganz teure Verschlüsselung

00:53:52.380 --> 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.160 --> 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.080
Und man sagt halt auch an der Stelle, weil häufig,

00:54:12.080 --> 00:54:14.180
also wenn jetzt halt gerade dieses Thema

00:54:14.180 --> 00:54:15.300
Advanced Persistent Threat,

00:54:16.280 --> 00:54:18.000
also die typischerweise

00:54:18.000 --> 00:54:20.540
staatlich 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.900
gegen den Mossad

00:54:25.900 --> 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.440
Der kommt zu dir nach Hause und

00:54:36.440 --> 00:54:38.420
nimmt dich mit und dann

00:54:38.420 --> 00:54:39.000
reden wir nochmal.

00:54:40.500 --> 00:54:41.100
Und deswegen ist,

00:54:42.260 --> 00:54:44.340
wenn man das mal schluckt und sagt, okay,

00:54:44.820 --> 00:54:46.340
ich bin hier nicht der, der sich gegen

00:54:46.340 --> 00:54:48.200
den Mossad schützen muss, weil ich habe eh keine Chance,

00:54:48.640 --> 00:54:49.480
dann brauche ich aber auch nicht

00:54:49.480 --> 00:54:51.540
dann brauche ich aber auch nicht so tun, als wenn ich

00:54:51.540 --> 00:54:53.620
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:57.460
Bitte? Oder du brauchst einen eigenen

00:54:57.460 --> 00:54:59.020
Geheimdienst. Ja, genau.

00:55:01.140 --> 00:55:01.780
Das Fiese

00:55:01.780 --> 00:55:03.440
am Internet ist ja, dass du immer

00:55:03.440 --> 00:55:05.320
mit den besten Angreifern

00:55:05.320 --> 00:55:07.260
kommunizierst. Das heißt, vielleicht

00:55:07.260 --> 00:55:09.700
nicht mit dem Mossad, aber vielleicht hast du irgendwelche russische

00:55:09.700 --> 00:55:11.020
Hacker, die durchaus was drauf haben.

00:55:11.560 --> 00:55:13.320
Und die installieren dann halt, wie hier

00:55:13.320 --> 00:55:15.400
in der Uniklinik Düsseldorf, deine

00:55:15.400 --> 00:55:17.480
Ransomware. Und die sind auch

00:55:17.480 --> 00:55:19.760
fast auf dem Level von so einem Advanced

00:55:19.760 --> 00:55:20.420
Persistent Threat.

00:55:21.540 --> 00:55:22.760
Die haben vielleicht jetzt nicht so,

00:55:23.580 --> 00:55:25.660
also die machen schon ein bisschen Streufeuer, aber die haben

00:55:25.660 --> 00:55:27.620
durchaus das technische Know-how und

00:55:27.620 --> 00:55:29.480
auch die Zeit

00:55:29.480 --> 00:55:31.280
und die machen sich auch die Mühe, das an

00:55:31.280 --> 00:55:32.940
deine Architektur anzupassen.

00:55:34.120 --> 00:55:35.780
Also vielleicht noch mal kurz, Unique Düsseldorf,

00:55:35.840 --> 00:55:37.780
da gab es einen Vorfall, da sind die Server rausgefallen

00:55:37.780 --> 00:55:39.620
und da das Netzwerk intern nicht geordnet

00:55:39.620 --> 00:55:41.460
war, konnte man durch den einen

00:55:41.460 --> 00:55:43.020
befallenen Rechner irgendwie mehrere

00:55:43.020 --> 00:55:45.700
OP-Säle ausknipsen, wenn ich das richtig verstanden habe.

00:55:47.480 --> 00:55:50.680
Ja, ich weiß nicht genau, was da passiert ist, aber war...

00:55:50.680 --> 00:55:52.060
Hab ich nicht verfolgt, muss ich zugeben, ja.

00:55:52.720 --> 00:55:54.380
War aber auch, glaube ich, nicht der erste Fall in Deutschland

00:55:54.380 --> 00:55:56.540
und ich glaube, der dritte hat es auch ein paar Mal so richtig erwischt.

00:55:58.560 --> 00:56:00.640
Nee, natürlich, also das ist halt ja jetzt erstmal,

00:56:00.960 --> 00:56:03.060
die Mossad-Beispiele kommen immer zu dem Thema,

00:56:03.180 --> 00:56:06.860
wenn man anfängt, die Physical Security halt extrem stark zu übertreiben.

00:56:07.380 --> 00:56:09.920
Und das ist aber dummerweise auch das, wo Leute gerne übertreiben,

00:56:09.920 --> 00:56:11.220
weil das können sie sich bildlich vorstellen.

00:56:11.860 --> 00:56:14.840
Dann kommt halt immer noch ein, ja, warum ist hier vor dem RZ keine Panzersperre?

00:56:14.900 --> 00:56:16.480
Und alle nur, ach, ja.

00:56:17.480 --> 00:56:20.620
denkt dran, Panzersperre hilft dir nichts,

00:56:20.720 --> 00:56:22.220
weil in Deutschland hat die Feuerwehr,

00:56:22.620 --> 00:56:24.580
guck mal da draußen, siehst du diesen kleinen, unauffälligen

00:56:24.580 --> 00:56:26.460
grauen Kasten? Da ist der

00:56:26.460 --> 00:56:27.940
Generalschlüssel für das ganze Haus drin.

00:56:28.380 --> 00:56:31.120
Ja, wie? Na, das ist der Feuerwehrschlüsselkasten.

00:56:31.260 --> 00:56:32.360
Da gibt es einen

00:56:32.360 --> 00:56:34.260
Feuerwehrschlüssel, den hat die Feuerwehr,

00:56:34.500 --> 00:56:36.420
die kann das Ding aufschließen, die kommt hier rein.

00:56:37.300 --> 00:56:38.460
Also spar dir mal bitte deine

00:56:38.460 --> 00:56:39.180
Panzersperre.

00:56:41.360 --> 00:56:42.520
Also deswegen, das ist immer

00:56:42.520 --> 00:56:43.980
so dieses, für mich bloß

00:56:43.980 --> 00:56:46.280
abzugrenzen von, wenn du

00:56:46.280 --> 00:56:49.360
Wenn du das Niveau hast, musst du dir nochmal um ganz andere Sachen Gedanken machen.

00:56:49.760 --> 00:56:52.160
Und wenn man das aber mal so übertrieben hat, dann wird den Leuten schnell klar,

00:56:52.260 --> 00:56:55.540
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:59.320 --> 00:57:00.540
Und damit macht man auch mehr kaputt.

00:57:00.880 --> 00:57:04.160
Ich würde halt nochmal anknüpfen an den Punkt von dieser Prozessempfehlung.

00:57:04.240 --> 00:57:07.920
Ich würde halt immer versuchen, an allen Enden weniger ist mehr zu machen.

00:57:09.360 --> 00:57:13.500
Weniger Code, den du schreibst, ist typischerweise weniger Architektur, über die du nachdenken musst,

00:57:13.500 --> 00:57:37.400
Deswegen, ja, und damit auch ein Team, was gerade erst anfängt, würde ich eben nicht sagen, ihr fangt jetzt mal an, euch über Security-Gedanken zu machen. Auch bei uns in der ISO ist es halt, in unserer Umsetzung der ISO 27000 ist es halt auch so, dass wir sagen, du willst irgendwie ein neues Feature für die Plattform etc. entwickeln? Ja, mach halt. Ja, mach halt. Ja, und du kannst gern auch irgendwie deine drei, vier Testmaschinen auf der Plattform halt schon mal auf diese Branch umstellen. Habe ich kein Problem mit.

00:57:38.040 --> 00:57:51.900
Aber bevor das dann halt in großen Einsatz kommt, muss das halt mal durch eine Vier-Augen-Review durch und dann musst du mal irgendjemand anders erklärt haben, was du dir gedacht hast und dann gibt es dort eine Checkliste und die fragt, jetzt erklären wir mal, was du dir für Security für Gedanken gemacht hast.

00:57:51.900 --> 00:58:07.460
Und das ist im Prinzip, das ist bei uns der komplette formale Prozess für die Entwicklungssicherheit. Also übertrieben jetzt ein bisschen, aber im Prinzip ist sozusagen bei uns nur ein, ja komm, entwickle halt, da drüben sind die 10 Guidelines, was man in welchen Situationen so alles mal berücksichtigen könnte.

00:58:07.760 --> 00:58:21.180
Und aber das Einzige, wozu wir dich zwingen, ist, du musst in den Pull-Request, wo dein Feature in die General Availability geht, musst du mir oder deinem PR-Reviewer glaubhaft vermitteln, dass du dir jetzt wirklich adäquat zu dem Ding Gedanken gemacht hast.

00:58:22.000 --> 00:58:24.560
Schreibt man das dann als Text in den Pull-Request?

00:58:24.560 --> 00:58:25.840
Text in den Pull-Request rein.

00:58:27.400 --> 00:58:28.400
Da gibt es zwei

00:58:28.400 --> 00:58:30.400
Fragen. Das eine ist, was sind hier die

00:58:30.400 --> 00:58:32.180
Sicherheitsanforderungen? Und B,

00:58:32.680 --> 00:58:33.780
wie habt ihr die erfüllt?

00:58:34.640 --> 00:58:36.460
Wo ist hier der Nachweis, dass die erfüllt wurden?

00:58:37.000 --> 00:58:38.640
Wie seid ihr zu der Frage gekommen von

00:58:38.640 --> 00:58:40.860
was sind hier die relevanten Sicherheitsanforderungen?

00:58:41.480 --> 00:58:42.720
Und wie weist ihr nach,

00:58:42.800 --> 00:58:44.420
dass ihr das jetzt halt ordentlich umgesetzt habt?

00:58:44.520 --> 00:58:46.620
Das hört sich so ein bisschen an, als sollte man die Angst

00:58:46.620 --> 00:58:48.520
weglassen und tatsächlich nur, also

00:58:48.520 --> 00:58:50.740
die Worst-Case-Szenarien, also was ist das Schlimmste, was passieren kann?

00:58:50.840 --> 00:58:52.500
Also bei dir wären zum Beispiel jetzt Daten weg gewesen,

00:58:52.500 --> 00:58:54.440
das wäre nicht so gut gewesen, weil die so sehr

00:58:54.440 --> 00:58:56.380
privat sein müssen und an anderer Stelle ist

00:58:56.380 --> 00:58:58.220
vielleicht so, ja, okay, wenn man die Backups noch hat, dann

00:58:58.220 --> 00:59:00.460
ist halt nicht so schlimm und

00:59:00.460 --> 00:59:02.500
das ist halt dann vielleicht der Worst Case und da muss man

00:59:02.500 --> 00:59:04.500
sich halt Gedanken drüber machen, dass der nicht eintreten kann und der Rest

00:59:04.500 --> 00:59:05.380
ist dann egal.

00:59:07.120 --> 00:59:08.500
Also auch bei

00:59:08.500 --> 00:59:10.420
uns ist es so, unser Auditor zum Beispiel sagt halt

00:59:10.420 --> 00:59:12.540
auch immer, ein Unternehmen, was hochsicher

00:59:12.540 --> 00:59:14.520
ist und aber am Markt kein

00:59:14.520 --> 00:59:15.580
Produkt platzieren kann,

00:59:17.080 --> 00:59:18.040
hilft halt nicht.

00:59:18.820 --> 00:59:19.860
Es geht halt nicht.

00:59:21.060 --> 00:59:22.760
Und dieses Angstthema

00:59:22.760 --> 00:59:24.560
ist das schon relevant, weil halt Angst ist,

00:59:24.820 --> 00:59:26.620
häufig wird Security, gerade wenn es eine eigene

00:59:26.620 --> 00:59:28.220
Abteilung ist, immer wahrgenommen als,

00:59:28.520 --> 00:59:30.540
das sind halt die, die halt nachher unterschrieben

00:59:30.540 --> 00:59:32.460
haben sollen mit, hier ist alles sicher und

00:59:32.460 --> 00:59:33.980
deswegen sagen sie per Default einfach nein.

00:59:34.600 --> 00:59:36.480
Und für uns ist der Review-Prozess aber

00:59:36.480 --> 00:59:37.680
zum Beispiel auch umgedreht.

00:59:38.340 --> 00:59:40.500
Der Review-Prozess in einem PR bei uns

00:59:40.500 --> 00:59:42.140
ist halt immer nur ein,

00:59:42.960 --> 00:59:44.640
ja, man darf nicht alleine

00:59:44.640 --> 00:59:46.600
Zeug nach draußen prügeln. Sternchen

00:59:46.600 --> 00:59:48.700
Fußnote, doch es gibt Situationen, in denen

00:59:48.700 --> 00:59:50.500
man das darf, aber dann muss man noch mehr

00:59:50.500 --> 00:59:52.520
Dinge beachten, weil es

00:59:52.520 --> 00:59:54.700
gibt halt bei uns auch so Gefahr- und Verzugssituationen,

00:59:54.740 --> 00:59:55.940
dann muss ich handlungsfähig sein.

00:59:57.180 --> 00:59:58.600
Aber der Pull-Request

00:59:58.600 --> 01:00:00.380
ist halt, wenn der gemerged wird, ist das halt

01:00:00.380 --> 01:00:02.060
nicht die Aussage von dem Reviewer,

01:00:02.580 --> 01:00:04.260
dass er seinen Erstgeborenen

01:00:04.260 --> 01:00:06.460
irgendwie mit Blut unterschrieben

01:00:06.460 --> 01:00:08.320
dem Teufel überantwortet, dass

01:00:08.320 --> 01:00:10.120
er sagt, hier ist alles sicher,

01:00:11.280 --> 01:00:12.740
sondern der Vier-Augen-Prozess

01:00:12.740 --> 01:00:14.540
ist dafür da, dass ein zweiter

01:00:14.540 --> 01:00:16.340
Mensch dem ersten nochmal

01:00:16.340 --> 01:00:17.540
in die Augen guckt und sagt,

01:00:18.720 --> 01:00:20.180
also wenn du jetzt nicht noch sagst,

01:00:20.580 --> 01:00:22.280
ich soll nach irgendwas schauen, dann merge

01:00:22.280 --> 01:00:23.200
ich den Kram jetzt.

01:00:23.800 --> 01:00:25.800
Das ist aber dein Code, 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.460 --> 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.120
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.000 --> 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.600
von dem, was sie tun, sondern wieder

01:02:58.600 --> 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.340 --> 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.400 --> 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.520
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.920
Laufzeitumgebung von PHP und die Sprache selber

01:03:49.920 --> 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.200 --> 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.060 --> 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.660 --> 01:05:39.660
die halt super viele Requests bearbeiten

01:05:39.660 --> 01:05:40.380
oder so

01:05:40.380 --> 01:05:43.740
was hat letztens in einem

01:05:43.740 --> 01:05:44.880
Podcast irgendwie der

01:05:44.880 --> 01:05:47.780
Entwickler von Flastia

01:05:47.780 --> 01:05:49.440
Armin Ronacher gesagt, er meinte so

01:05:49.440 --> 01:05:51.280
Rust 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:57.660 --> 01:05:59.540
das ist halt, da kann man

01:05:59.540 --> 01:06:01.620
man kann nicht viel dran machen und das

01:06:01.620 --> 01:06:02.660
ist natürlich schon irgendwie

01:06:02.660 --> 01:06:05.360
irgendwie so, ja das ist

01:06:05.360 --> 01:06:07.720
Das würde ich

01:06:07.720 --> 01:06:09.300
gerne verstehen, weil da geht mir

01:06:09.300 --> 01:06:11.580
Philipp dreht den Kopf und ich habe auch so ein

01:06:11.580 --> 01:06:13.220
kleines Messer, was mir in der Tasche aufgeht.

01:06:13.340 --> 01:06:15.480
Ja, ja, klar. Also es ist, es muss,

01:06:16.340 --> 01:06:17.700
aber ich kann schon in gewisser

01:06:17.700 --> 01:06:19.680
Weise verstehen, was er meint.

01:06:19.900 --> 01:06:21.600
Also ich meine, bei Rust kannst du dir halt sicher sein,

01:06:21.700 --> 01:06:23.600
dass da nichts liegt, wenn du es halt

01:06:23.600 --> 01:06:25.480
richtig machst. Und da musst du mir auch mal erklären, was meinst du denn,

01:06:25.580 --> 01:06:27.300
damit da liegt was rum?

01:06:28.400 --> 01:06:29.500
Naja, zum Beispiel,

01:06:30.060 --> 01:06:31.860
dass halt der Hauptspeicher

01:06:31.860 --> 01:06:33.560
immer weiter anwächst, ohne dass du

01:06:33.560 --> 01:06:35.280
das eigentlich wolltest, ja, sozusagen,

01:06:35.480 --> 01:06:37.400
ohne dass du wirklich den Hauptspeicher brauchst, sondern

01:06:37.400 --> 01:06:39.460
dass halt Sachen nicht wieder weggeräumt werden,

01:06:39.560 --> 01:06:40.920
die halt irgendwann mal angefallen sind.

01:06:42.000 --> 01:06:43.560
Klar, also Python nimmt dir das

01:06:43.560 --> 01:06:45.040
Memory-Management halt komplett weg

01:06:45.040 --> 01:06:47.740
und das ist tatsächlich

01:06:47.740 --> 01:06:49.720
Fluch und Segen zugleich,

01:06:50.380 --> 01:06:51.200
logischerweise, also

01:06:51.200 --> 01:06:53.580
jede technische Entscheidung der Hinsicht hat immer Trade-Offs

01:06:53.580 --> 01:06:55.600
und ein Aspekt bei Python ist nun mal,

01:06:55.800 --> 01:06:57.440
dass Python Speicher,

01:06:57.520 --> 01:06:59.320
den es mal gebraucht hat, auch wenn es

01:06:59.320 --> 01:07:00.880
den Akut gerade nicht braucht,

01:07:01.440 --> 01:07:02.980
nicht einfach mal so wieder hergibt.

01:07:03.560 --> 01:07:07.100
Also wenn dein Prozess mal irgendwie, keine Ahnung, ein Gig oder zwei Gig groß ist,

01:07:07.640 --> 01:07:11.340
dann kann es gut sein, dass der das jetzt für die nächste Zeit mal behält,

01:07:11.460 --> 01:07:14.280
auch wenn du alle Objekte gelöscht hast und wenn die Garbage Collection durch war.

01:07:14.800 --> 01:07:17.740
Weil es ist halt auch ein Trade-Off zu sagen,

01:07:17.740 --> 01:07:23.420
naja, ständig Mellocs groß und klein und groß und klein zu machen, hat auch Nachteile.

01:07:23.500 --> 01:07:25.620
Es hat Nachteile in der Hauptspeicherfragmentierung.

01:07:25.780 --> 01:07:27.220
Das ist an sich ein Performance-Thema.

01:07:28.660 --> 01:07:32.820
Und Python als Universalsprache 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.940 --> 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.580 --> 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:09.740
Also dass das in deinem Rechner irgendwie 8 Gig, 16 Gig oder halt mal ein halbes Tera oder ein Tera RAM drin ist,

01:08:09.840 --> 01:08:13.380
das weiß ja kein Programm, das guckt auch kein Programm so wirklich nach heutzutage,

01:08:13.380 --> 01:08:18.400
sondern ein Programm geht her und sagt, ey, du, könnte ich mal irgendwie Speicher im Wert von 3 Terabyte haben?

01:08:18.500 --> 01:08:22.240
Und dann sagt normalerweise der Linux-Kern heutzutage, klar, kein Thema, hier hast du.

01:08:23.600 --> 01:08:28.620
Und erst in dem Moment, wo es das dann auch anfängt zu beschreiben, sagt der Kern,

01:08:28.660 --> 01:08:29.860
ach, du willst es auch noch benutzen,

01:08:30.800 --> 01:08:32.660
na dann, dann teilt er

01:08:32.660 --> 01:08:34.080
ihm tatsächlich irgendwie diese Sachen zu.

01:08:35.320 --> 01:08:36.600
Und deswegen gibt es

01:08:36.600 --> 01:08:38.680
einige Programme, MongoDB ist halt auch so ein Ding,

01:08:38.760 --> 01:08:40.620
die alloziieren zum Beispiel immer bloß in

01:08:40.620 --> 01:08:42.600
Vielfachen von 2 oder in

01:08:42.600 --> 01:08:44.020
Zweierpotenzen oder so ein Kram.

01:08:44.500 --> 01:08:46.680
Also wenn der halt hergeht und sagt, ich brauche hier mal RAM,

01:08:47.080 --> 01:08:48.820
dann sagt er als erstes, ich brauche 64

01:08:48.820 --> 01:08:50.640
Mac und dann irgendwie, ja, jetzt hätte ich auch lieber

01:08:50.640 --> 01:08:52.760
118, okay, also jetzt hätte ich

01:08:52.760 --> 01:08:54.680
gerne einen Gigabyte und das kann manchmal schon so ein bisschen

01:08:54.680 --> 01:08:55.560
unangenehm sein,

01:08:56.080 --> 01:08:57.180
aber

01:08:57.180 --> 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:11.680
Der kann sogenannte Huge-Pages machen.

01:09:11.780 --> 01:09:15.680
Das heißt, du musst dann halt nicht, wenn du einen Gigabyte alloziierst,

01:09:15.680 --> 01:09:22.100
musst der Kernel halt nicht eine Million mal eine 1-Kilobyte-Page irgendwo in seiner Tabelle abmarkern,

01:09:22.200 --> 01:09:26.200
weil auch das kann plötzlich schon mal 2, 3, 4, 500 Millisekunden dauern,

01:09:26.660 --> 01:09:29.400
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.960 --> 01:09:36.540
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.000 --> 01:09:47.220
Listen haben eine, es gibt eine Operation bei Listen, die ist unoffensichtlich O von 1.

01:09:49.200 --> 01:10:00.500
nämlich ein, genau, ein Append an Listen bei Python ist, wie war denn das, ne, Listen, sind Listen nicht immer ein O von 1 Append?

01:10:00.940 --> 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.120 --> 01:10:14.360
dass die Speicherallokation für Listen in Python auch immer nur verdoppelt.

01:10:15.000 --> 01:10:19.640
Der alloziiert einen Buffer für das Array, um die Indizes zu verwalten

01:10:19.640 --> 01:10:24.460
und alloziiert aber, wenn er dann sozusagen es größer machen muss,

01:10:24.520 --> 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.060 --> 01:11:05.840
Was Python aber macht ist, Python alloziiert immer dann das Doppelte von dem, was es vorher hatte, kopiert das einmal um, dann sind die nächsten n gratis, dann musst du wieder einmal verdoppeln, einmal kopieren und dann hast du wieder 2n gratis und das sind so typische Sachen, die man in solchen Situationen halt hat, was so Laufzeitumgebungen für einen automatisieren und machen und weswegen sich dann hinten so ein bisschen komische Speichereffekte ergeben.

01:11:06.060 --> 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.380 --> 01:11:19.500
Und da muss man sich halt irgendwann sagen, kann man nicht erklären, warum es genau das jetzt gerade tut, kann ich dir nicht erklären.

01:11:19.880 --> 01:11:25.860
Ich bin mir relativ sicher, dass es kein Leak ist, wenn du halt dann irgendwie mal sowas beobachtest über eine Woche oder einen Monat,

01:11:26.040 --> 01:11:30.140
wenn du einen langlaufenden Prozess hast und die Saisonalitäten findest und du was merkst wie,

01:11:30.140 --> 01:11:34.540
ah, okay, frühmorgens haben die Leute ihren Kaffee getrunken, jetzt lesen sie alle irgendwie das, was auf deiner Webseite ist,

01:11:34.620 --> 01:11:36.820
dann geht ihr Speicherbedarf irgendwie hoch,

01:11:37.200 --> 01:11:38.580
dann kommen abends irgendwann die Cronjobs,

01:11:38.660 --> 01:11:40.680
dann geht er nochmal ein bisschen hoch, dann passiert lange nichts

01:11:40.680 --> 01:11:42.340
und dann ist plötzlich, gibt er mal wieder ein bisschen

01:11:42.340 --> 01:11:43.900
Speicher frei und dann ist es irgendwie gut.

01:11:45.220 --> 01:11:46.480
Und wenn du dann aber siehst, okay,

01:11:46.540 --> 01:11:48.620
über einen Monat ist es immer das Gleiche, dann mag das

01:11:48.620 --> 01:11:50.520
zwar sein, dass er zu jedem einzelnen Zeitpunkt mal

01:11:50.520 --> 01:11:52.460
einen Speicher hat, den er jetzt gerade akut

01:11:52.460 --> 01:11:54.440
nicht braucht, aber es liegt

01:11:54.440 --> 01:11:54.800
nicht.

01:11:58.440 --> 01:12:00.720
Ja, ich weiß auch nicht, was er damit genau gemeint hat.

01:12:02.180 --> 01:12:02.720
Nee, ich verstehe,

01:12:02.840 --> 01:12:04.380
dass er sagt, ich kann zum Beispiel in

01:12:04.380 --> 01:12:06.280
Python ist es schwierig, kontrollierbar

01:12:06.280 --> 01:12:07.520
schlanke Prozesse zu bauen.

01:12:08.560 --> 01:12:10.440
Das geht nicht so ohne weiteres. Also das geht

01:12:10.440 --> 01:12:11.880
schnell, dass dein,

01:12:12.540 --> 01:12:15.060
wenn du zum Beispiel eine Datenverarbeitungspipeline

01:12:15.060 --> 01:12:16.540
hast mit zehn, neun oder zehn

01:12:16.540 --> 01:12:18.600
Schritten und jeder Schritt davon braucht

01:12:18.600 --> 01:12:20.640
irgendwie einen Gigabyte RAM,

01:12:20.920 --> 01:12:22.460
dann kann das schon sein, dass dein Python

01:12:22.460 --> 01:12:23.580
nachher zehn Gig frisst.

01:12:24.800 --> 01:12:26.660
Weil er halt eben den Speicher von vorher

01:12:26.660 --> 01:12:28.520
noch nicht freigegeben hatte, der jetzt aber auch gerade

01:12:28.520 --> 01:12:30.740
nicht gepasst hat, um das nächste Ding zu bearbeiten

01:12:30.740 --> 01:12:32.260
und dann so.

01:12:32.860 --> 01:12:35.140
das kriegst du unter Python halt nicht gut

01:12:35.140 --> 01:12:37.100
kontrolliert. Ja, vor allem, weil alles

01:12:37.100 --> 01:12:38.920
so dynamisch ist, weil ich also im Zweifel auch wirklich

01:12:38.920 --> 01:12:41.120
den Stack hochwandern kann und schauen kann, was da rumliegt

01:12:41.120 --> 01:12:43.240
oder ein Integer-Objekt als beliebiges

01:12:43.240 --> 01:12:45.000
Objekt sehen kann, was halt in Rust ohne

01:12:45.000 --> 01:12:47.100
weiteres nicht möglich ist und auch in anderen Poemischsprachen nicht geht.

01:12:49.060 --> 01:12:51.080
Aber auch ohne Speicherverwaltung

01:12:51.080 --> 01:12:52.900
kann ich ja in Python durchaus noch andere

01:12:52.900 --> 01:12:55.100
Sicherheitslücken machen, die also gar nichts mit dem Speicher zu tun

01:12:55.100 --> 01:12:56.860
haben, mit dem, was wir jetzt die

01:12:56.860 --> 01:12:58.840
meiste Zeit besprochen haben, sondern halt zum Beispiel,

01:12:58.940 --> 01:13:00.760
dass ich sage, ich verwende den Subprozess

01:13:00.760 --> 01:13:02.760
und öffne den Subprozess und

01:13:02.760 --> 01:13:05.860
übergebe einen String

01:13:05.860 --> 01:13:08.120
und habe diesen String halt konstruiert

01:13:08.120 --> 01:13:10.160
aus Benutzerdaten und jetzt habe ich

01:13:10.160 --> 01:13:11.880
plötzlich eine Command Injection, dass man

01:13:11.880 --> 01:13:13.700
beliebige Shell-Commandos ausführen kann.

01:13:15.260 --> 01:13:16.180
Das kann man in

01:13:16.180 --> 01:13:17.180
jeder Programmiersprache

01:13:17.180 --> 01:13:20.460
die Shell-Commandos

01:13:20.460 --> 01:13:22.140
ausführen können. Natürlich kannst du dich auf den Standpunkt

01:13:22.140 --> 01:13:24.180
stellen, okay, man hat das gefälligst nicht

01:13:24.180 --> 01:13:26.120
zu machen oder man hat gefälligst immer

01:13:26.120 --> 01:13:28.100
Shell gleich Freud zu setzen oder das ist ja der

01:13:28.100 --> 01:13:29.660
Standard, also dass man eine Liste übergibt.

01:13:30.940 --> 01:13:31.380
Aber

01:13:31.380 --> 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 doch 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.740 --> 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:55.980 --> 01:13:57.440
den Philipp da nennt, das ist halt ganz klassisch.

01:13:57.440 --> 01:13:59.640
Ja, das ist schon schlimm. Das ist ganz klassisch.

01:14:00.040 --> 01:14:01.480
Auch sehr beliebt

01:14:01.480 --> 01:14:03.380
ist, wenn Leute meinen, ich muss hier Flexibilität

01:14:03.380 --> 01:14:05.380
reinbringen und jagen halt irgendwie User-Input

01:14:05.380 --> 01:14:07.460
einfach durch einen Eval durch. Das ist sozusagen

01:14:07.460 --> 01:14:09.180
die interne Variante des

01:14:09.180 --> 01:14:11.000
Shell-Out. Was ist denn ein Eval?

01:14:11.420 --> 01:14:13.040
Achso, Eval, ja, okay, ja, Entschuldigung.

01:14:13.680 --> 01:14:15.280
Ja, Funktion, ja. Eval ist

01:14:15.280 --> 01:14:17.440
Evil. Ja, ja. Aber das ist im Prinzip

01:14:17.440 --> 01:14:19.180
die... Oh ja, doch,

01:14:19.340 --> 01:14:20.780
Pickle. Ei, ei, ei.

01:14:21.880 --> 01:14:23.180
Ja, Pickle,

01:14:23.340 --> 01:14:23.940
nur Trusted.

01:14:25.340 --> 01:14:26.920
Da kann man sich auch schon mit dem Fuß schießen.

01:14:26.920 --> 01:14:29.020
Mit Eval haben wir sogar einen ganz, ganz

01:14:29.020 --> 01:14:30.960
schlimmen Bug, und zwar da hat eine Anwendung auf die Idee

01:14:30.960 --> 01:14:32.920
gekommen, dass man doch das cachen

01:14:32.920 --> 01:14:34.980
könnte. Und man könnte

01:14:34.980 --> 01:14:36.800
doch den Code nehmen, und dann kann man sich

01:14:36.800 --> 01:14:39.080
so einen kurzen, 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:42.860 --> 01:14:45.020
der das ausführt, und dann kann man

01:14:45.020 --> 01:14:47.040
das cachen. Und dann war aber das Problem, dass

01:14:47.040 --> 01:14:48.960
sogar die noch eine Datenbank-Schwachstelle hatten,

01:14:49.040 --> 01:14:51.100
dass man sehen konnte, was in der Datenbank

01:14:51.100 --> 01:14:52.600
lag, und da lagen deren Cache-Objekte.

01:14:52.960 --> 01:14:54.820
Und dann lagen da plötzlich Benutzer-Passwörter oder

01:14:54.820 --> 01:14:56.960
sonst irgendwelche Sachen,

01:14:57.600 --> 01:14:58.840
die halt, also da kann man halt

01:14:58.840 --> 01:15:00.560
wenn man halt so Schwachstellen

01:15:00.560 --> 01:15:01.640
verkettet, kann man das auch

01:15:01.640 --> 01:15:03.980
auf sehr krumme,

01:15:05.180 --> 01:15:06.640
sehr fiese Sachen, die man mit

01:15:06.640 --> 01:15:08.120
einer einzelnen Schwachstelle gar nicht machen könnte.

01:15:08.640 --> 01:15:10.640
Also das war jetzt nicht der Fehler von dem,

01:15:10.800 --> 01:15:12.440
dass sie, also es war ein Fehler, dass man

01:15:12.440 --> 01:15:14.420
den Cache plötzlich sehen kann

01:15:14.420 --> 01:15:16.500
und es war ein anderer Fehler, dass sie überhaupt

01:15:16.500 --> 01:15:18.800
IWA verwendet haben, aber erst durch die Kombination

01:15:18.800 --> 01:15:20.300
ist es halt eigentlich eine Schwachstelle gewesen.

01:15:21.220 --> 01:15:22.700
Auch so ein klassischer Ding ist

01:15:22.700 --> 01:15:23.780
auch Directory Traversal,

01:15:24.280 --> 01:15:26.400
dass halt irgendwie von außen sagen kannst,

01:15:26.400 --> 01:15:27.860
ich will XYZ haben

01:15:27.860 --> 01:15:29.980
und dann wird halt nicht ordentlich geguckt,

01:15:30.100 --> 01:15:32.360
ob du durch Punkt-Punkt-Slash-Kombinationen

01:15:32.360 --> 01:15:34.080
plötzlich dir dann irgendwie ETC-Pass-Videos

01:15:34.080 --> 01:15:35.640
und so ein Kram halt auslesen lassen kannst.

01:15:36.360 --> 01:15:37.080
Und das sind immer auch,

01:15:37.200 --> 01:15:39.100
das ist tatsächlich, glaube ich, am wichtigsten.

01:15:39.600 --> 01:15:40.560
Und deswegen ist dieses,

01:15:40.640 --> 01:15:42.440
das ist wieder Variety matches Variety.

01:15:43.120 --> 01:15:43.780
Deswegen sagen wir,

01:15:43.840 --> 01:15:46.740
wir wollen so schnell so viele Verbesserungen

01:15:46.740 --> 01:15:47.760
in der Security wie möglich

01:15:47.760 --> 01:15:49.600
durch unsere Entwicklungspipeline jagen können,

01:15:50.360 --> 01:15:53.080
weil die eigentlichen Vektoren ist nachher,

01:15:53.180 --> 01:15:57.260
du hast immer eine Vielzahl von potenziellen Schwachstellen,

01:15:57.380 --> 01:15:59.420
die für sich genommen alle gar nicht so schlimm sind.

01:16:00.240 --> 01:16:03.340
Und wenn du aber immer nur auf der Suche nach dem einen großen Ding bist,

01:16:03.640 --> 01:16:06.040
um alles zu reparieren, dann vergisst man schnell,

01:16:06.160 --> 01:16:08.280
dass es halt eher um diese Verkettung geht, wie Philipp sagt.

01:16:08.780 --> 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:15.040 --> 01:16:16.640
ah, guck mal, da könntest du da drüben nochmal gucken.

01:16:17.840 --> 01:16:20.020
Ein Klassiker, den ich mag, sind Exceptions.

01:16:21.240 --> 01:16:23.640
Exceptions sind für mich die sensibelsten Daten,

01:16:23.640 --> 01:16:26.300
die dein System zur Laufzeit eigentlich von sich gibt.

01:16:27.380 --> 01:16:36.740
Weil, das Problem ist ja folgendes, dein System ist in einem nicht bekannten Zustand, mit Daten, die du nicht kennst und weißt nicht mehr, was es tun soll.

01:16:37.500 --> 01:16:40.660
So, und die Daten können halt alles sein.

01:16:40.880 --> 01:16:46.120
Das können die Kreditkartendaten sein, das können die was auch immer und dann steht da irgendwie Value Error, hast du nicht gesehen?

01:16:46.940 --> 01:16:50.380
Und du kannst den User nicht davon abhalten, Daten ins falsche Feld zu schreiben.

01:16:50.760 --> 01:16:55.040
Dann schreibt er seine Kreditkartendaten halt das erste Mal irgendwie bei seinem Nachnamen aus Versehen rein.

01:16:55.040 --> 01:17:19.040
Und deswegen diese Bewertung von was ist eigentlich sicher und was ist unsicher ist total schwer. Das Paradigma sollte auch eher sein, lieber ein bisschen zu sensibel zu sein und sozusagen dein Schutzniveau einmal grob festzulegen und zu sagen, okay, wir gehen ja mit Kreditkartendaten um, du musst davon ausgehen, dass irgendein doofer User, nein, die User sind nicht doof, es ist ein Usability-Problem.

01:17:19.040 --> 01:17:21.780
Usability-Problem ist, dass wir halt ein Gehirn haben, was bekloppt ist.

01:17:22.800 --> 01:17:26.240
Da kommt dieses ganze Thema Cognitive Processing rein von

01:17:26.240 --> 01:17:31.600
unser Gehirn will Energie sparen und deswegen reagiert es auf irgendeine Form von Challenge

01:17:31.600 --> 01:17:34.340
immer mit der billigstmöglichen Antwort, also Pattern Matching.

01:17:34.680 --> 01:17:38.120
Und das Pattern Matching von unserem Gehirn ist auch nicht Best Match, sondern First Match.

01:17:38.540 --> 01:17:42.240
Das heißt, du hast eine Seite vor dir, hast aus deinem Passwortmanager deine Kreditkartennummer kopiert,

01:17:42.320 --> 01:17:45.320
dein Kind will was von dir, ja bitte, ich muss nur noch, klick, klick, klick

01:17:45.320 --> 01:17:48.060
und dann hast du halt deine Kreditkartennummer

01:17:48.060 --> 01:17:49.420
in das falsche Feld eingetragen.

01:17:50.500 --> 01:17:53.540
Und das ist halt, wie war es bei Microsoft damals,

01:17:53.740 --> 01:17:55.400
alle zwei Millionen Mal,

01:17:55.840 --> 01:17:57.540
ja, das ist bei uns halt nächsten Dienstag.

01:17:59.480 --> 01:18:02.360
Und so was, und deswegen sagen wir auch,

01:18:02.400 --> 01:18:05.220
wenn wir Anwendungen dann mit Schutzniveaus belegen

01:18:05.220 --> 01:18:06.300
und sagen, was macht man hier,

01:18:06.560 --> 01:18:08.440
dann gucken wir eigentlich nur noch nach dem Worst Case

01:18:08.440 --> 01:18:10.380
und sagen so, jetzt müssen wir davon ausgehen,

01:18:10.460 --> 01:18:12.480
dass das ganze Ding mit dem Niveau geschützt werden muss.

01:18:12.560 --> 01:18:14.280
Weiter differenzieren macht überhaupt keinen Sinn mehr,

01:18:14.280 --> 01:18:16.260
weil du kommst dann von Hölzchen zu Stöckchen

01:18:16.260 --> 01:18:18.500
und irgendwer greift

01:18:18.500 --> 01:18:20.420
eh daneben. Und deswegen bin ich mal

01:18:20.420 --> 01:18:22.180
sensibel drum, wenn es darum geht, so Exceptions

01:18:22.180 --> 01:18:24.160
an externe Systeme weiterzuleiten,

01:18:24.880 --> 01:18:26.280
weil im Prinzip

01:18:26.280 --> 01:18:28.520
übergibst du jemandem externes

01:18:28.520 --> 01:18:30.460
alle deine Daten, weil du ja gar nicht

01:18:30.460 --> 01:18:32.400
weißt, was in der Exception drin ist. Wenn du es gewusst

01:18:32.400 --> 01:18:34.320
hättest, hättest du halt schon

01:18:34.320 --> 01:18:36.420
irgendwas geschrieben, damit die nicht auftritt.

01:18:37.340 --> 01:18:38.460
Aber wie

01:18:38.460 --> 01:18:40.360
bekommst du dann mit, wenn eine Exception passiert?

01:18:40.520 --> 01:18:42.520
Also an irgendein System muss das ja weitergeleitet werden, oder?

01:18:42.520 --> 01:19:11.640
Ja, internes System. Also ich meine, 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. 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 es dann da einfüttern.

01:19:19.960 --> 01:19:21.120
Was ist Greylock, Christian?

01:19:21.780 --> 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.160 --> 01:19:53.280
Der kann aus Logdaten IP-Adressen rauspopeln und, der technische Begriff für parsen, und hat halt dann wieder eine Anbindung daran abzugleichen, ob diese IPs assoziiert werden mit irgendeiner Form von, da kommen ständig Angriffe her.

01:19:53.520 --> 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.760 --> 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 irgendwann, oh, das Paket sieht nach Virus aus, sofort blocken wir alles von diesem Rechner und dann geht nichts mehr.

01:20:34.680 --> 01:20:47.360
Ja, genau. Da muss man immer mit vorsichtig sein. Und nichtsdestotrotz, so ein bisschen mit so Sachen experimentieren wir 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.

01:20:48.040 --> 01:20:57.540
Ja, aber ich meine, 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.540 --> 01:21:00.260
Kibana hört sich nach Kibakirschbanane an.

01:21:00.760 --> 01:21:05.320
Ja, es schmeckt nicht so gut wie Kirsche oder Banane, leider.

01:21:05.680 --> 01:21:08.060
Aber klingt auch lustig.

01:21:08.300 --> 01:21:12.300
Ja, nee, das ist so irgendwie Elasticsearch, also diese Richtung.

01:21:12.740 --> 01:21:15.320
Aber da werfen Leute auch Logdaten rein oder halt eben Greylock.

01:21:15.780 --> 01:21:17.900
Oder manche machen das auch mit Postgres.

01:21:18.900 --> 01:21:24.980
Aber ich meine jetzt für Python speziell, da gibt es dann irgendwie so Sentry oder Bugsnack oder so,

01:21:25.040 --> 01:21:26.820
wo die Tracebacks halt gesammelt werden.

01:21:27.380 --> 01:21:29.120
Kann man sowas eigentlich auch gut selber hosten?

01:21:29.120 --> 01:21:30.660
weil das habe ich jetzt tatsächlich verwendet,

01:21:30.860 --> 01:21:32.780
aber ich kenne es auch immer nur, dass man da externe

01:21:32.780 --> 01:21:34.840
Services verwendet. Kein Problem, Sentry

01:21:34.840 --> 01:21:36.960
kann man ohne Problem, ist ein Open-Source-Projekt, kann man

01:21:36.960 --> 01:21:38.500
ganz normal selber hausten.

01:21:39.300 --> 01:21:40.640
Genau, kommt ja auch selber aus der Python-Ecke,

01:21:40.780 --> 01:21:42.860
ist glaube ich auch Django unten drunter

01:21:42.860 --> 01:21:44.220
oder so, ich bin mir gar nicht mehr sicher, aber

01:21:44.220 --> 01:21:46.200
war es mal, aber stimmt, ist auch, genau,

01:21:46.320 --> 01:21:48.660
Sentry ist ja

01:21:48.660 --> 01:21:50.480
relativ groß geworden tatsächlich, Armin und so

01:21:50.480 --> 01:21:52.440
und die

01:21:52.440 --> 01:21:54.340
kannst du selber hosten tatsächlich an der Stelle,

01:21:55.060 --> 01:21:56.900
das würde ich dann auch immer empfehlen.

01:21:57.920 --> 01:21:58.720
Wichtig, sozusagen

01:21:58.720 --> 01:22:00.560
ein Unterschied von

01:22:00.560 --> 01:22:02.420
der Log Aggregation

01:22:02.420 --> 01:22:04.780
versus Exception Logging.

01:22:05.600 --> 01:22:06.540
Exception Logging hat

01:22:06.540 --> 01:22:08.640
die große Aufgabe, wenn

01:22:08.640 --> 01:22:10.540
du viel vom Gleichen

01:22:10.540 --> 01:22:12.400
entgegenkriegst, weil irgendwie der eine

01:22:12.400 --> 01:22:14.620
bugt gerade 50.000 Mal im letzten Tag auf,

01:22:14.680 --> 01:22:16.640
dann willst du, dass der dir die schon

01:22:16.640 --> 01:22:18.600
normalisiert und sagt, hier, das Problem

01:22:18.600 --> 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.060 --> 01:22:24.300
Logging macht natürlich immer nur,

01:22:24.920 --> 01:22:26.580
hier ist der Hydrant, hier kommt alles

01:22:26.580 --> 01:22:27.020
raus.

01:22:28.720 --> 01:22:31.960
Ja, interessant.

01:22:32.720 --> 01:22:34.720
Da gibt es viele verschiedene Typen von Angriffen,

01:22:34.900 --> 01:22:36.620
die man mit verschiedenen Typen

01:22:36.620 --> 01:22:38.280
von Verteidigungsmaßnahmen beantworten

01:22:38.280 --> 01:22:40.540
möchte, können muss.

01:22:41.780 --> 01:22:42.560
Probieren kann man das, ja.

01:22:44.380 --> 01:22:45.080
Sollen wir uns mal

01:22:45.080 --> 01:22:46.480
unbeliebt machen? Oder ich mache mich unbeliebt.

01:22:47.800 --> 01:22:49.120
Wir einen 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.760 --> 01:22:51.440
Ich meine, vielleicht

01:22:51.440 --> 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.780
das bringt alles nichts.

01:22:58.580 --> 01:22:59.720
aber...

01:22:59.720 --> 01:23:02.440
Vor allem müssen die ganz viel mit Speicher machen

01:23:02.440 --> 01:23:03.960
und ganz viel nur Level erarbeiten.

01:23:04.020 --> 01:23:05.300
Genau, das, was man eigentlich nicht haben will, ja.

01:23:06.320 --> 01:23:08.160
Also, wo ich es noch sehe, wo ich noch mitspiele,

01:23:08.280 --> 01:23:09.680
ist, wo wir es gerne haben,

01:23:10.220 --> 01:23:11.920
wo es angefragt wird und wir dem nicht

01:23:11.920 --> 01:23:13.780
harsch widersprechen,

01:23:14.400 --> 01:23:16.300
ist, wenn du sozusagen

01:23:16.300 --> 01:23:18.620
tatsächlich sowas hast wie, deine Anwendung

01:23:18.620 --> 01:23:20.360
nimmt Daten per Mail oder Upload

01:23:20.360 --> 01:23:22.240
entgegen und du weißt, die werden dann nachher

01:23:22.240 --> 01:23:24.160
auf eher schlecht gepflegten Rechnern

01:23:24.160 --> 01:23:25.160
wieder weiterverarbeitet.

01:23:26.000 --> 01:23:27.720
Also, wir haben so ein Kram, wo dann irgendwie, keine Ahnung,

01:23:27.800 --> 01:23:29.820
Word-Files reinkommen und die sollen dann von irgendeiner

01:23:29.820 --> 01:23:32.020
dritten Partei auf ihrem Windows-Rechner

01:23:32.020 --> 01:23:33.820
verarbeitet werden, dann habe ich

01:23:33.820 --> 01:23:35.700
halt mal einen Klamm-AV

01:23:35.700 --> 01:23:37.920
da mit drauf sitzen, der halt diese eine Datei

01:23:37.920 --> 01:23:39.900
scannt, aber das ist dann kein Ding,

01:23:40.020 --> 01:23:41.780
was das System scannt, sondern

01:23:41.780 --> 01:23:43.760
es ist bloß ein Programm. Hier scannt die eine

01:23:43.760 --> 01:23:45.680
Datei, du sagst, ja, okay, dann geben wir die

01:23:45.680 --> 01:23:47.740
weiter und wenn nicht, dann sperren wir sie halt zur

01:23:47.740 --> 01:23:49.820
Seite. Das ist eine Form von Viren-Scanner,

01:23:50.040 --> 01:23:51.860
da spiele ich punktuell halt noch mit.

01:23:52.460 --> 01:23:53.580
Das kann man schon mal machen.

01:23:54.040 --> 01:23:55.640
Was ich halt nicht leiden kann, sind diese

01:23:55.640 --> 01:23:57.580
Security-Suites, die dann irgendwie

01:23:57.580 --> 01:23:59.560
einen Rechner irgendwie übernehmen und irgendwie

01:23:59.560 --> 01:24:00.720
mehr Schaden machen als

01:24:00.720 --> 01:24:03.660
ich meine, da braucht man bloß Fefe lesen, da kriegst

01:24:03.660 --> 01:24:05.100
du es halt alle zwei Wochen wieder serviert.

01:24:06.040 --> 01:24:06.700
Schlangenhöhle und so.

01:24:08.440 --> 01:24:08.540
Ja.

01:24:10.040 --> 01:24:10.740
Ein gutes Konzept.

01:24:11.700 --> 01:24:13.180
Was ich eben noch kurz erwähnt hatte, was

01:24:13.180 --> 01:24:15.380
ich mir ja noch irgendwann drüber gestolpert bin,

01:24:15.440 --> 01:24:17.600
was bei Django eine DOS-Attacke

01:24:17.600 --> 01:24:19.460
möglich war, und zwar bei Regex, irgendwie, die man

01:24:19.460 --> 01:24:21.780
die benutzt worden ist, um bestimmte Formularfelder

01:24:21.780 --> 01:24:23.560
auszulesen. Das heißt, man konnte

01:24:23.560 --> 01:24:25.540
einfach, indem man in Formulare,

01:24:25.620 --> 01:24:27.620
ich glaube, E-Mail oder so, einen cleveren

01:24:27.620 --> 01:24:29.220
Regex reingeschrieben hat, irgendwie

01:24:29.220 --> 01:24:31.300
eine exponentiell wachsende

01:24:31.300 --> 01:24:33.600
oder Endlosschleife produzieren und dann

01:24:33.600 --> 01:24:35.760
die Seite... Man kann

01:24:35.760 --> 01:24:37.760
Regexe bauen, die sehr, sehr

01:24:37.760 --> 01:24:39.060
langsam werden dann. Genau.

01:24:39.920 --> 01:24:41.720
Dann hat man einfach ganz viele Requester dran geschickt

01:24:41.720 --> 01:24:43.280
und dann hat man halt die Seite in die Knie ziehen können.

01:24:43.780 --> 01:24:45.600
Das haben die irgendwann gefixt. Ich glaube, auch relativ spät,

01:24:45.640 --> 01:24:47.680
erst bei einer Zweier-Version, wenn ich das richtig bekommen habe.

01:24:48.880 --> 01:24:49.680
Sehr interessant, solche

01:24:49.680 --> 01:24:51.600
Sachen, also das denkt man immer, jemand, der

01:24:51.600 --> 01:24:53.320
keine Ahnung hat, nicht dran, dass in so

01:24:53.320 --> 01:24:55.220
einfachen Bibliotheken wie

01:24:55.220 --> 01:24:56.780
Regex da was Tolles hinterstehen kann.

01:24:56.860 --> 01:24:59.080
Was ist das? Perl Regex oder wie nennt man das?

01:24:59.120 --> 01:25:01.180
Diese Perl Compatible Regex

01:25:01.180 --> 01:25:02.440
als PCIe, aber ich

01:25:02.440 --> 01:25:04.660
weiß nicht, ob das...

01:25:04.660 --> 01:25:07.220
Die Python Regex Engine ist eine eigene.

01:25:07.580 --> 01:25:07.940
Ja, okay.

01:25:08.600 --> 01:25:11.220
Also moderne Regex Engines können schon nicht alle Fälle,

01:25:11.320 --> 01:25:12.740
aber viele Fälle da

01:25:12.740 --> 01:25:15.480
besser erkennen und haben dann da auch bessere Garantien.

01:25:15.740 --> 01:25:17.380
Also nicht erkennen, aber haben Garantien,

01:25:17.800 --> 01:25:19.080
dass das halt nicht in diesen

01:25:19.080 --> 01:25:20.540
exponentiellen Fall läuft. Natürlich nicht immer.

01:25:20.920 --> 01:25:23.080
Und natürlich kann ich immer ein Regex produzieren, der einfach

01:25:23.080 --> 01:25:24.900
so lange dauert, weil ich einfach sage, okay,

01:25:25.200 --> 01:25:27.220
hier kommt irgendwas Beliebiges und das darf beliebig

01:25:27.220 --> 01:25:29.100
oft vorkommen. Und wenn ich dann einen langen String

01:25:29.100 --> 01:25:30.120
habe, dann ist es halt total,

01:25:30.600 --> 01:25:32.780
dann gibt es natürlich

01:25:32.780 --> 01:25:34.100
exponentiell viele Möglichkeiten,

01:25:36.420 --> 01:25:37.440
wie ich

01:25:37.440 --> 01:25:39.060
das Matching nehmen kann. Und wenn ich den String

01:25:39.060 --> 01:25:40.580
so konstruiere, dass das Matching nie passiert,

01:25:41.100 --> 01:25:42.800
dann dauert es halt ewig.

01:25:42.800 --> 01:25:44.760
Also unendlich nicht, aber schon mal länger

01:25:44.760 --> 01:25:45.880
ist das Universum.

01:25:47.300 --> 01:25:48.820
So, ich mach hier mal kurz, wir müssen

01:25:48.820 --> 01:25:49.760
die Chapter-Mark hier ziehen.

01:25:50.700 --> 01:25:52.780
Ich muss jetzt raus, ihr könnt mich rausschneiden

01:25:52.780 --> 01:25:58.600
Wir haben eine Sekunde Pause gehabt, das könnt ihr rausschneiden.

01:25:59.660 --> 01:26:00.180
Alles klar.

01:26:01.200 --> 01:26:02.620
Ja, 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.300 --> 01:26:05.580
Euch noch viel Spaß. Bis dann. Ciao.

01:26:05.680 --> 01:26:05.800
Tschüss.

01:26:08.660 --> 01:26:09.060
Ja.

01:26:10.760 --> 01:26:12.260
Haben wir denn zu dem

01:26:12.260 --> 01:26:13.980
Security-Thema noch irgendwie,

01:26:14.540 --> 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.520
wollten?

01:26:20.120 --> 01:26:20.980
Ja, also

01:26:20.980 --> 01:26:23.380
mir fallen noch einige Sachen ein, aber frage ich

01:26:23.380 --> 01:26:25.000
erst mal euch weiter. Was geht es denn mit den

01:26:25.000 --> 01:26:26.580
Philipp-Fragen nochmal? Was wolltest du denn noch erzählen?

01:26:27.880 --> 01:26:29.700
Es gibt

01:26:29.700 --> 01:26:30.460
also, was vielleicht

01:26:30.460 --> 01:26:33.280
wichtig ist, dass man eine

01:26:33.280 --> 01:26:35.180
Funktion nimmt oder eine

01:26:35.180 --> 01:26:37.260
Standardmöglichkeit nimmt, um sich gegen die

01:26:37.260 --> 01:26:39.100
Sicherheitsschwachstelle zu verteidigen.

01:26:39.420 --> 01:26:41.120
Also wir haben eben schon Path Traverses angesprochen.

01:26:41.240 --> 01:26:43.560
Da könnt ihr mal denken, okay, also bei Path Traverses

01:26:43.560 --> 01:26:45.340
ist das Problem, dass ich irgendwas in den Pfad

01:26:45.340 --> 01:26:46.700
einschleuse, typischerweise halt

01:26:47.220 --> 01:26:50.660
um halt aus dem Pfad der Anwendung rauszukommen.

01:26:50.980 --> 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.220 --> 01:26:58.460
Weiß ich, die Passwortdatei oder die Datenbankdatei

01:26:58.460 --> 01:26:59.240
oder irgendwas anderes.

01:26:59.740 --> 01:27:02.340
Und eine Möglichkeit, um sich dagegen zu verteidigen,

01:27:02.400 --> 01:27:02.960
ist natürlich zu sagen,

01:27:03.080 --> 01:27:05.440
ich nehme immer alle Punkte raus oder so.

01:27:05.780 --> 01:27:06.660
Oder alle Slashes raus.

01:27:07.100 --> 01:27:09.180
Und dann kommt man halt auf andere Systeme,

01:27:09.200 --> 01:27:10.180
zum Beispiel unter Windows,

01:27:10.300 --> 01:27:11.600
da ist ja ein Doppelpunkt wichtig.

01:27:12.020 --> 01:27:13.160
Und dann muss man auch an den denken

01:27:13.160 --> 01:27:14.260
und dann ist der Backslash wichtig.

01:27:14.780 --> 01:27:16.180
Und es ist halt sehr schwierig,

01:27:16.260 --> 01:27:17.200
sowas richtig zu schreiben.

01:27:17.320 --> 01:27:18.400
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.680 --> 01:27:28.080
Und bei einigen Systemen geht das auch, also man kann zum Beispiel bei SQL Injection kann man relativ einfach vermeiden,

01:27:28.080 --> 01:27:34.660
weil das halt eigentlich nur ein einfaches Anführungszeichen ist, aber es ist halt immer gut, dann für eine fertige Funktion oder eine fertige Struktur zu nehmen,

01:27:35.100 --> 01:27:41.980
die genau dafür programmiert ist und die dann auch, zwar die sicher ist, aber die ist halt sicher oder hoffentlich sicher,

01:27:42.300 --> 01:27:49.400
weil es halt nur eine ist, in Python zum Beispiel, um Path-Traverse zu verhindern, kann man halt os.path.basename oder aus der Pathlib was nehmen,

01:27:49.960 --> 01:27:53.200
Statt selber zu versuchen, 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:56.540
Ja, genau.

01:27:57.040 --> 01:27:59.160
Es sei denn, man weiß, was man tut.

01:27:59.520 --> 01:28:01.080
An einigen Stellen kann das richtig sein.

01:28:01.560 --> 01:28:03.120
Und ich glaube, ein anderes häufiges Problem ist auch,

01:28:03.220 --> 01:28:09.180
dass man sagt, ich versuche, die Eingaben zu früh abzufangen.

01:28:09.180 --> 01:28:11.160
Also ich sage, okay, ich habe eine ganz komplizierte Anwendung.

01:28:11.660 --> 01:28:13.860
Und immer, wenn mir jemand was mit einem Anführungszeichen schickt,

01:28:13.940 --> 01:28:15.300
dann sage ich, geht nicht, ist Fehler.

01:28:15.460 --> 01:28:16.940
Oder ich schmeiße das Anführungszeichen raus.

01:28:17.540 --> 01:28:19.780
Und das ist natürlich klapp vielleicht.

01:28:19.880 --> 01:28:23.100
aber dann muss ich halt überall dran denken und es gibt halt verschiedene Kontexte.

01:28:23.920 --> 01:28:26.960
Also wenn ich einen Pfad habe, dann ist halt ein Slash oder ein Backslash ein Problem.

01:28:27.560 --> 01:28:32.080
Wenn ich aber HTML habe, dann ist das kleiner Zeichen oder das doppelte Anführungszeichen ein Problem

01:28:32.080 --> 01:28:33.320
und so weiter und so fort.

01:28:33.380 --> 01:28:37.200
Das heißt, es ist wichtig, dass man darauf achtet, dass man das in jedem Kontext richtig macht

01:28:37.200 --> 01:28:40.760
und es ist schwierig zu sagen, oder es ist ein häufiger Anfängerfehler zu sagen,

01:28:41.040 --> 01:28:43.640
okay, ich gehe davon aus, dass meine Daten irgendwie korrekt sind.

01:28:43.640 --> 01:28:47.380
Das ist dann doch immer sehr schwierig, weil man halt ein komplexes System hat,

01:28:47.460 --> 01:28:49.100
vielleicht sogar mit mehreren Microservices,

01:28:49.320 --> 01:28:51.060
die die Daten aus verschiedenen Quellen

01:28:51.060 --> 01:28:53.020
anliefern.

01:28:53.440 --> 01:28:55.240
Aber wenn man darauf vertraut, dass die Datenbank

01:28:55.240 --> 01:28:56.840
irgendwie gute Daten enthält, das ist immer

01:28:56.840 --> 01:28:58.040
sehr, sehr gefährlich.

01:29:02.900 --> 01:29:04.980
Ja, ist interessant, welche Assertions man da rausgibt

01:29:04.980 --> 01:29:06.860
oder welche Dinge man daraus macht, wenn das nicht dem

01:29:06.860 --> 01:29:08.140
erwarteten Standard entspricht oder so.

01:29:08.600 --> 01:29:10.980
Ein paar Stolperfallen, 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:17.460 --> 01:29:20.560
Okay, guter Tipp

01:29:20.560 --> 01:29:23.840
Ja

01:29:23.840 --> 01:29:25.640
Ja, ansonsten genau

01:29:25.640 --> 01:29:27.920
ein Thema, wo ich immer denke, das kann doch nicht so schwer

01:29:27.920 --> 01:29:29.900
sein, aber ich tue mich irgendwie schwer

01:29:29.900 --> 01:29:32.020
damit, ist halt, wie authentifiziert

01:29:32.020 --> 01:29:33.120
man sich eigentlich richtig

01:29:33.120 --> 01:29:35.700
irgendwie zum Beispiel per

01:29:35.700 --> 01:29:37.820
einer API, per

01:29:37.820 --> 01:29:38.860
HTTP oder so

01:29:38.860 --> 01:29:41.860
Web-Authentifizierung ist irgendwie nicht so

01:29:41.860 --> 01:29:42.240
einfach

01:29:42.240 --> 01:29:45.900
Es gibt ein paar interessante Artikel

01:29:45.900 --> 01:29:47.720
dazu, die wir irgendwie ja letztens gelesen hatten.

01:29:48.180 --> 01:29:48.940
Warum JBT

01:29:48.940 --> 01:29:51.320
kaputt ist. Ja, JBT sieht nicht gut aus, ja.

01:29:52.360 --> 01:29:53.680
Und dass ja viele Leute nutzen

01:29:53.680 --> 01:29:55.020
und sagen, das ist der Standard, den es da gibt.

01:29:55.720 --> 01:29:57.780
Und ich habe aber auch jetzt auch noch nicht so viel gefunden,

01:29:57.820 --> 01:29:59.300
was man da anderes machen kann. Es gibt irgendwie

01:29:59.300 --> 01:30:01.600
Passeto oder Pi-Passeto, aber da gibt es noch nichts wirklich

01:30:01.600 --> 01:30:03.440
Nutzbares. Das muss man irgendwie auch alles wieder

01:30:03.440 --> 01:30:05.640
selber machen vielleicht und das

01:30:05.640 --> 01:30:07.400
ist da vielleicht wieder nicht so eine gute Idee und

01:30:07.400 --> 01:30:09.440
da ist es gar nicht so einfach, irgendwie sich

01:30:09.440 --> 01:30:10.920
vernünftig per Token zu authentifizieren.

01:30:11.240 --> 01:30:13.300
Ja, tatsächlich. Also das, was ich jetzt auch, ist halt

01:30:13.300 --> 01:30:14.940
HTTP-only-Cookies.

01:30:15.760 --> 01:30:16.980
Ja, vielleicht.

01:30:17.820 --> 01:30:18.540
Also Sessions dann?

01:30:18.780 --> 01:30:23.200
Ja, Session Cookies ist halt manchmal ein bisschen schwierig.

01:30:23.780 --> 01:30:27.200
Aber ja, das ist immer wieder, wo ich mir denke,

01:30:27.340 --> 01:30:28.480
das müsste doch eigentlich jetzt einfach sein,

01:30:28.560 --> 01:30:29.780
aber irgendwie ist es das nicht.

01:30:34.780 --> 01:30:35.180
Tja.

01:30:35.940 --> 01:30:38.700
Oh, oder hast du mal so von Indie ausgesprochen,

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.160
kriegst du einfach eine E-Mail geschickt oder so und drückst dann

01:31:40.160 --> 01:31:42.260
auf einen Link und dann...

01:31:42.260 --> 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:50.840
schon sehr nett,

01:31:51.640 --> 01:31:54.140
aber... Das ist ja sicherlich immer

01:31:54.140 --> 01:31:56.120
die einfachste Lösung, wenn du sagst, ich möchte selber keinen

01:31:56.120 --> 01:31:57.780
Benutzernamen, keinen 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:05.820
Benutzernamen und Passwörter und ich verwende irgendein

01:32:05.820 --> 01:32:06.740
Single-Sign-On-System.

01:32:07.500 --> 01:32:10.200
Du hast ja schon OROS angesprochen oder OpenID Connect,

01:32:10.300 --> 01:32:12.800
ist ja der alternative Standard,

01:32:13.240 --> 01:32:15.280
dass man sagt, okay, jemand anders müsste sich drum kümmern.

01:32:15.860 --> 01:32:17.580
Und dann habe ich zwar diesen anderen Dienst,

01:32:17.660 --> 01:32:19.320
der irgendwo vielleicht auch in meinem Netzwerk ist,

01:32:19.360 --> 01:32:21.680
oder vielleicht sage ich, okay, ich erlaube Login mit Facebook,

01:32:21.820 --> 01:32:23.540
mit Google, mit Twitter und so weiter, mit GitHub.

01:32:25.100 --> 01:32:26.340
Dann müssen die sich ja drum kümmern.

01:32:26.500 --> 01:32:28.620
Und dann bin ich da raus aus der Sache.

01:32:28.680 --> 01:32:29.660
Ich muss kein Passwort speichern.

01:32:30.060 --> 01:32:31.300
Und für den Benutzer ist das ja eigentlich auch nicht schlecht,

01:32:31.300 --> 01:32:33.040
weil der Benutzer muss kein Passwort wählen.

01:32:34.040 --> 01:32:36.680
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.420
Aber das hat auch ein paar Falschstücke wieder, ne?

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.680 --> 01:32:57.380
Weil ich bin mir nicht sicher,

01:32:57.440 --> 01:32:59.960
ob das, was wir da gebaut haben, alles so gut, richtig funktioniert.

01:32:59.960 --> 01:33:01.680
Das wird sich dann irgendwie im Laufe der Zeit zeigen.

01:33:01.860 --> 01:33:04.400
Das müssen wir richtig testen. Mal gucken, ne?

01:33:05.640 --> 01:33:06.880
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.940 --> 01:33:16.340
Ja, aber

01:33:16.340 --> 01:33:18.980
was ich vor allen Dingen blöd

01:33:18.980 --> 01:33:20.640
finde bei diesen ganzen OpenIDO

01:33:20.640 --> 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.220
Ja gut, aber dadurch braucht

01:33:41.220 --> 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.340
Session-Token, die haben vielleicht auch eine

01:33:52.340 --> 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.500 --> 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
mich einmal ins Ausland geflogen, als man das noch

01:34:12.080 --> 01:34:14.060
durfte und habe eine

01:34:14.060 --> 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 meinem 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.880 --> 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.640
warum wurde die gehackt? Und dann sagst

01:35:16.640 --> 01:35:18.580
du, 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.560
die besten Sicherheitsstände, aber das Katzenforum, das ist

01:35:22.560 --> 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.280 --> 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:29.520 --> 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.560 --> 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.880 --> 01:35:49.200
Ja.

01:35:50.220 --> 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.380 --> 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.700
so mit, wie man die Leute auditen kann

01:36:06.700 --> 01:36:08.380
und da gibt es ja so Experimente zu.

01:36:09.040 --> 01:36:09.640
Also zum Beispiel

01:36:09.640 --> 01:36:12.460
einige Konzerne verschicken ja dann so

01:36:12.460 --> 01:36:14.600
Test-E-Mails oder Trainings-E-Mails

01:36:14.600 --> 01:36:16.260
regelmäßig, um zu gucken,

01:36:17.160 --> 01:36:18.160
klicken die Leute auf alles,

01:36:18.720 --> 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.220
ein bisschen erziehen oder sowas, sodass man die

01:36:26.220 --> 01:36:28.280
Quote davon reduziert und das ist eine ganz spannende.

01:36:29.100 --> 01:36:29.620
Ja, aber

01:36:29.620 --> 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.160 --> 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.680
oder Defense in Depth, dass ich sage, okay,

01:36:54.680 --> 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:21.980 --> 01:37:22.340
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.020
und sagst, okay, jedes System muss

01:37:31.020 --> 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 Standard, 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.600
Transport-Layers-Security.

01:38:12.800 --> 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.760
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.500
ineinander stecken und das ist dann, wobei es dann irgendwann

01:38:38.500 --> 01:38:40.680
alles 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.640 --> 01:38:54.540
Also der TLS-Teil macht halt die

01:38:54.540 --> 01:38:55.860
Vertraulichkeit,

01:38:55.940 --> 01:38:58.320
beziehungsweise Integrität, ich weiß jetzt gar nicht genau,

01:38:58.400 --> 01:39:00.220
aber was du halt auch noch...

01:39:00.220 --> 01:39:00.580
Beides, genau.

01:39:02.760 --> 01:39:04.100
Was du halt auch noch brauchst, ist halt

01:39:04.100 --> 01:39:06.680
Authentifizierung. Also du musst dich halt irgendwie

01:39:06.680 --> 01:39:08.400
gegenüber der Bank ausweisen, damit

01:39:08.400 --> 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.980 --> 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.720 --> 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:25.140 --> 01:39:26.720
Wie kriegt man das eigentlich ordentlich

01:39:26.720 --> 01:39:27.040
hin?

01:39:28.880 --> 01:39:30.680
Der coole Trick bei TLS ist halt,

01:39:30.740 --> 01:39:31.420
dass du sagen kannst,

01:39:31.880 --> 01:39:34.140
also du kannst erstmal sowieso asymmetrisch arbeiten,

01:39:34.260 --> 01:39:37.780
das heißt, der private Schlüssel verlässt nie die Box.

01:39:38.600 --> 01:39:40.940
Du hast also einen Client,

01:39:41.080 --> 01:39:44.960
also einen Service, der einen anderen Dienst was sendet

01:39:44.960 --> 01:39:46.580
und der hat einen privaten Schlüssel

01:39:46.580 --> 01:39:48.160
und der andere Dienst kennt nur den öffentlichen Schlüssel.

01:39:48.600 --> 01:39:49.700
Und das kannst du noch weiter treiben,

01:39:49.800 --> 01:39:50.380
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:56.060
sondern es gibt noch eine dritte Partei,

01:39:56.120 --> 01:39:57.000
die das irgendwie signiert.

01:39:57.740 --> 01:39:58.560
Und das verwendest du ja,

01:39:58.600 --> 01:39:59.740
wenn du auf eine normale Webseite gehst,

01:39:59.740 --> 01:40:01.060
eine normale HTTPS-Seite,

01:40:01.140 --> 01:40:02.840
dann ist die halt oben grün,

01:40:03.200 --> 01:40:04.880
weil halt dieses Zertifikat von jemandem

01:40:04.880 --> 01:40:06.920
signiert wurde. Und

01:40:06.920 --> 01:40:08.840
das kannst du aber auch kleinseitig verwenden,

01:40:08.920 --> 01:40:09.480
dass du sagst, okay,

01:40:10.020 --> 01:40:13.120
ich zertifiziere nicht nur, dass derjenige,

01:40:13.240 --> 01:40:14.700
der die Anfrage entgegennimmt,

01:40:14.700 --> 01:40:16.600
richtig ist und auch der, der die Anfrage sendet.

01:40:16.960 --> 01:40:18.340
Das ist ja tatsächlich wieder interessant, weil das

01:40:18.340 --> 01:40:20.280
das nächste Thema ist, was irgendwie eigentlich zu Security

01:40:20.280 --> 01:40:22.620
natürlich dazugehört und das wäre Kryptografie oder Verschlüsselung,

01:40:23.140 --> 01:40:24.400
ohne dass man ja wahrscheinlich nicht auskommt.

01:40:24.520 --> 01:40:26.780
Und da gab es ja irgendwie Algorithmen,

01:40:26.920 --> 01:40:27.960
mit denen man bestimmte Dinge

01:40:27.960 --> 01:40:30.700
verschlüsselt oder hasht oder wie auch immer.

01:40:30.920 --> 01:40:34.860
und die man dann mehr oder weniger schnell entschlüsseln konnte oder sowas.

01:40:34.960 --> 01:40:38.820
Oder man konnte sogar so Angriffe fahren wie, ich glaube, Rainbow Table nennt sich das oder sowas,

01:40:38.920 --> 01:40:41.140
dass man halt Passwort-Hashes einfach in eine Tabelle schmeißt und guckt,

01:40:41.540 --> 01:40:44.580
wie ist denn das Ergebnis von dem Hash, also was ist denn da der umgekehrte Wert von oder so.

01:40:45.060 --> 01:40:48.620
Und ja, wenn man solche Sachen halt irgendwie vermeiden möchte,

01:40:48.700 --> 01:40:51.760
dann müsste man, glaube ich, 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.920 --> 01:40:59.120
Verschlüsseln und, also mein Passwort möchte ich eigentlich nicht verschlüsseln,

01:40:59.120 --> 01:41:00.940
Weil dann muss ich ja den Schlüssel irgendwo auf dem Server

01:41:00.940 --> 01:41:01.540
speichern.

01:41:02.380 --> 01:41:04.900
Also das Passwort eines Nutzers.

01:41:05.040 --> 01:41:06.900
Ich meinte ja so SSH-Keys oder sowas.

01:41:06.960 --> 01:41:07.640
Das meine ich mit Schlüssel.

01:41:09.140 --> 01:41:10.980
Die dann bestimmt Algorithmus benutzen irgendwie.

01:41:11.120 --> 01:41:11.780
Okay, ja.

01:41:13.820 --> 01:41:14.800
Das man halt da, also

01:41:14.800 --> 01:41:16.920
das müsst ihr vielleicht nochmal erklären. Also wie man halt da

01:41:16.920 --> 01:41:19.520
von einem, ich sag mal,

01:41:19.560 --> 01:41:20.560
nicht so guten Algorithmus

01:41:20.560 --> 01:41:22.800
den Schlüssel berechnen kann aus einem Public Key oder sowas.

01:41:22.920 --> 01:41:24.200
Bei asymmetrischer Verschlüsselung.

01:41:28.140 --> 01:41:29.560
Du musst den Schlüssel selber

01:41:29.560 --> 01:41:31.700
eigentlich nicht berechnen. Du kannst ein Zertifikat

01:41:31.700 --> 01:41:33.660
berechnen, das ist der Schlüssel nochmal in

01:41:33.660 --> 01:41:35.740
kurz, aber du könntest eigentlich auch immer den Schlüssel

01:41:35.740 --> 01:41:37.280
an sich verwenden, den öffentlichen Schlüssel zumindest.

01:41:38.320 --> 01:41:39.600
Nur weil der öffentliche Schlüssel ist halt

01:41:39.600 --> 01:41:41.600
bei dieser Kryptografie sehr lang, das muss halt

01:41:41.600 --> 01:41:43.620
eine sehr lange Zahl sein und die kannst du halt

01:41:43.620 --> 01:41:45.540
eindampfen auf eine kürzere Zahl, die man

01:41:45.540 --> 01:41:47.560
aus verschiedenen Gründen dann verwendet, die auch immer gleich ist,

01:41:47.640 --> 01:41:49.540
egal wie lang der Schlüssel ist und

01:41:49.540 --> 01:41:51.500
das ist das Hash-Verfahren. Das verwenden wir auch bei

01:41:51.500 --> 01:41:53.480
Passwörtern und auch an vielen anderen Stellen, kann ich

01:41:53.480 --> 01:41:55.540
auch verwenden, um zum Beispiel zu überprüfen, wenn ich Software

01:41:55.540 --> 01:41:57.400
runterlade, dass die in Ordnung ist.

01:41:57.680 --> 01:42:02.500
Haben wir eben schon mal angesprochen, dass wenn ich das mit Python mache,

01:42:02.500 --> 01:42:07.940
dann habe ich zum Beispiel bei pip-env, oder bei pip habe ich ein pip-file oder ein pip-file.log

01:42:07.940 --> 01:42:09.980
und in dem pip-file.log stehen halt die ganzen Hashes drin.

01:42:10.480 --> 01:42:14.560
Und was ein Hash macht, ist halt genau eine lange Eingabe zu nehmen, egal welche Länge,

01:42:14.960 --> 01:42:21.080
und sie auf eine Zahl zu reduzieren, die eine relativ kurze Länge hat und die auch immer die gleiche Länge hat.

01:42:21.420 --> 01:42:23.860
Das sind dann halt nachher so 32 Buchstaben oder sowas.

01:42:24.480 --> 01:42:28.240
Und das ist halt kryptografische Magie.

01:42:29.520 --> 01:42:31.360
Und es gibt halt Mathematiker,

01:42:33.100 --> 01:42:35.340
die haben sich darum gekümmert,

01:42:35.440 --> 01:42:37.420
dass es nicht möglich ist, das rückwärts zu rechnen.

01:42:37.500 --> 01:42:38.300
Das heißt, wenn ich einen Hash habe,

01:42:38.360 --> 01:42:40.940
kann ich nicht das Original berechnen

01:42:40.940 --> 01:42:43.200
und ich kann gegeben einen Hash,

01:42:43.200 --> 01:42:46.140
kann ich überhaupt nicht ein Original finden.

01:42:46.260 --> 01:42:47.780
Das heißt, wenn du mir deinen Hash gibst,

01:42:47.880 --> 01:42:48.800
dann kann ich eigentlich sicher sein,

01:42:48.960 --> 01:42:52.520
dass die Originaldatei genau unverändert ist.

01:42:53.100 --> 01:42:55.260
Und genau dafür kann ich die halt einsetzen.

01:42:56.800 --> 01:42:56.860
Mhm.

01:42:58.400 --> 01:42:58.600
Ja.

01:42:59.080 --> 01:42:59.560
Mhm, mhm.

01:43:01.360 --> 01:43:03.200
Okay, das Rückrechnen ist dann bei unsicheren

01:43:03.200 --> 01:43:05.120
Hash-Verfahren dann vielleicht dann doch möglich

01:43:05.120 --> 01:43:06.820
oder sowas? Oder dauert das lange? Genau.

01:43:06.820 --> 01:43:09.000
Man kann halt Kollisionen finden

01:43:09.000 --> 01:43:10.780
dann. Und dann kann man eben

01:43:10.780 --> 01:43:12.560
beispielsweise Dokumente dadurch fälschen, dass man,

01:43:13.060 --> 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.200 --> 01:43:19.160
Wenn man weiß, wie man die Kollisionen erzeugen

01:43:19.160 --> 01:43:21.040
kann, dann kann man halt quasi beliebige Texte

01:43:21.040 --> 01:43:22.960
mit einem bestimmten Hash erzeugen. Und das ist natürlich

01:43:22.960 --> 01:43:23.340
ganz schlecht.

01:43:24.920 --> 01:43:27.020
Genau, dann habe ich halt deinen Schlüssel und dann kann

01:43:27.020 --> 01:43:28.680
halt jemand anders einen anderen Schlüssel generieren

01:43:28.680 --> 01:43:30.560
und die haben plötzlich den gleichen Hash.

01:43:31.260 --> 01:43:32.940
Dann kann er sich mit seinem eigenen Schlüssel,

01:43:33.040 --> 01:43:34.400
der so tut, als wäre dein Schlüssel, damit

01:43:34.400 --> 01:43:35.340
authentifizieren.

01:43:36.660 --> 01:43:38.720
Also es geht um Sicherheit von Kryptografie oder sowas

01:43:38.720 --> 01:43:40.920
in der Hinsicht noch? Ja, aber ich glaube, ich weiß

01:43:40.920 --> 01:43:43.160
gar nicht, ob man sich als Endanwender

01:43:43.160 --> 01:43:44.920
oder so wahnsinnig viel mit

01:43:44.920 --> 01:43:46.080
beschäftigen muss, weil

01:43:46.080 --> 01:43:49.120
ich glaube, wenn man da anfängt, sich für zu interessieren

01:43:49.120 --> 01:43:50.660
und dann irgendwelche Entscheidungen zu treffen,

01:43:50.860 --> 01:43:52.700
dann liegt man wahrscheinlich eher

01:43:52.700 --> 01:43:54.640
ist die Wahrscheinlichkeit hoch, dass man falsch liegt.

01:43:54.780 --> 01:43:56.680
Also genau, dann sollte man quasi diese Wahl

01:43:56.680 --> 01:43:58.880
auch gar nicht mehr treffen, welche kryptografischen

01:43:58.880 --> 01:44:01.140
Algorithmen man zum Verschlüsseln, Entschlüsseln

01:44:01.140 --> 01:44:01.940
benutzt. Ich glaube, das war's.

01:44:02.760 --> 01:44:04.940
Also wenn du zum Beispiel

01:44:04.940 --> 01:44:06.480
hasht, dann muss dir der Python-Hashlet

01:44:06.480 --> 01:44:08.280
sagen, okay, ich möchte diesen Hash haben.

01:44:08.340 --> 01:44:10.380
Dann sagst du zum Beispiel, ich möchte SHA-1 haben.

01:44:10.780 --> 01:44:12.080
Oder ich möchte MD5 haben.

01:44:12.380 --> 01:44:14.480
Und wenn du da die falsche Wahl triffst, dann hast du durchaus

01:44:14.480 --> 01:44:16.420
ein Problem. Also SHA-1 oder MD5 sollte man

01:44:16.420 --> 01:44:18.100
nicht nehmen, sondern SHA-256, oder?

01:44:18.760 --> 01:44:20.240
Genau, SHA-256 oder

01:44:20.240 --> 01:44:22.040
eine SHA-3-Variante oder was anderes.

01:44:22.280 --> 01:44:24.100
Aber eigentlich willst du gar nicht, dass der Entwickler sich

01:44:24.100 --> 01:44:26.340
drum Gedanken machen soll. Der Entwickler soll gar nicht

01:44:26.340 --> 01:44:28.360
sagen, okay, ich nehme SHA-1, sondern der Entwickler

01:44:28.360 --> 01:44:30.040
soll eigentlich sagen, okay, ich nehme eine fertige

01:44:30.040 --> 01:44:32.160
Bibliothek. Und dafür gibt es dann in Python

01:44:32.160 --> 01:44:33.820
zum Beispiel die neue

01:44:33.820 --> 01:44:36.260
Passwort-Bibliothek

01:44:36.260 --> 01:44:37.260
oder es gibt B-Crypt.

01:44:39.340 --> 01:44:40.240
Und da

01:44:40.240 --> 01:44:42.000
muss ich mich halt gar nicht drum kümmern. Ich weiß gar nicht,

01:44:42.060 --> 01:44:43.300
die Passwort-Bibliothek heißt, glaube ich, Secret?

01:44:44.040 --> 01:44:44.400
Secrets.

01:44:45.320 --> 01:44:47.420
Und da muss ich halt nicht mehr drum kümmern.

01:44:47.660 --> 01:44:49.100
Also da wird halt die Wahl für dich

01:44:49.100 --> 01:44:51.340
getroffen. Und das macht es

01:44:51.340 --> 01:44:53.100
für den Entwickler natürlich

01:44:53.100 --> 01:44:55.320
besser, weil der Entwickler keine Entscheidung

01:44:55.320 --> 01:44:57.180
treffen muss. Wenn du ein System

01:44:57.180 --> 01:44:59.300
groß zertifizieren musst, dann musst du wahrscheinlich trotzdem irgendwo

01:44:59.300 --> 01:45:01.360
eine Entscheidung treffen, weil da andere Leute drüber schauen

01:45:01.360 --> 01:45:03.720
wollen, aber für so die Wald- und Wiesenanwendung,

01:45:03.840 --> 01:45:05.420
die einfach mal

01:45:05.420 --> 01:45:07.200
von vielleicht einem kleinen Team entwickelt wird,

01:45:07.580 --> 01:45:09.300
ist das sicherlich eine bessere Option, wenn die

01:45:09.300 --> 01:45:11.100
keine kryptographischen Entscheidungen treffen.

01:45:11.480 --> 01:45:13.240
Also nicht mal die Entscheidung treffen, welche

01:45:13.240 --> 01:45:15.320
Algorithmen sie verwenden, sondern vielleicht nur noch

01:45:15.320 --> 01:45:17.320
sagen, ich möchte ein bestimmtes Sicherheitslevel

01:45:18.100 --> 01:45:19.340
haben. Das ist ja auch immer

01:45:19.340 --> 01:45:21.280
ein Trade-off, dass ich sage, okay, weil ich kann

01:45:21.280 --> 01:45:23.360
zum Beispiel mehrfach hintereinander hashen und

01:45:23.360 --> 01:45:25.120
dann kann man das halt bei dem Passwort

01:45:25.120 --> 01:45:26.840
dauert es auch länger,

01:45:27.040 --> 01:45:28.680
das rauszufinden, weil ich halt

01:45:28.680 --> 01:45:29.920
wenn ich

01:45:29.920 --> 01:45:33.040
ein Testpasswort habe, muss ich das ganz oft hashen,

01:45:33.180 --> 01:45:34.520
um das Zielpasswort zu finden.

01:45:35.020 --> 01:45:36.600
Aber das ist halt auch ein Problem, was

01:45:36.600 --> 01:45:39.260
auf deiner Seite, weil wenn du

01:45:39.260 --> 01:45:40.940
das jetzt sehr oft hashst, dann dauert es natürlich

01:45:40.940 --> 01:45:42.700
für dich länger. Und du möchtest ja

01:45:42.700 --> 01:45:44.980
nicht, dass dein Service plötzlich eine Minute

01:45:44.980 --> 01:45:46.820
braucht, wenn sich ein Benutzer einloggt, weil

01:45:46.820 --> 01:45:49.000
dein Passwort irgendwie eine Million Mal hasht oder sowas.

01:45:49.560 --> 01:45:51.040
Das ist für uns auch mal so ein

01:45:51.040 --> 01:45:52.960
schönes Ding bei Tests, wo man

01:45:52.960 --> 01:45:54.320
halt irgendwie Zeit sparen kann.

01:45:55.140 --> 01:45:57.260
Und ich meine, die Passwort-Hash-Funktionen

01:45:57.260 --> 01:45:57.920
sind ja genau die,

01:45:58.800 --> 01:46:00.900
sie sind ja genauso gestaltet, dass sie möglichst langsam

01:46:00.900 --> 01:46:01.880
sind irgendwie.

01:46:02.680 --> 01:46:04.940
Und genau, da will man dann vielleicht

01:46:04.940 --> 01:46:06.940
nochmal MD5 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:10.880
Und man legt ja, wenn man jetzt

01:46:10.880 --> 01:46:12.780
einen Test-Suite durchlaufen lässt, oft irgendwie

01:46:12.780 --> 01:46:14.060
ganz viele Nutzer an und

01:46:14.060 --> 01:46:16.720
das kann Dinge deutlich

01:46:16.720 --> 01:46:17.180
beschleunigen.

01:46:20.160 --> 01:46:20.520
Ja.

01:46:22.020 --> 01:46:22.920
Sehr, sehr interessant.

01:46:23.220 --> 01:46:25.220
Da fallen mir 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.360
Vulnerabilities und Disclosure

01:46:29.360 --> 01:46:30.440
und all so Themen.

01:46:30.940 --> 01:46:33.160
Ja, Pics tatsächlich. Und die Frage,

01:46:33.320 --> 01:46:35.560
wollen wir ein Standard-Lib-Modul

01:46:35.560 --> 01:46:36.100
vorstellen?

01:46:37.400 --> 01:46:39.300
Ich finde, der kann sich mit Siegwitz vorstellen.

01:46:39.980 --> 01:46:41.120
Kennst du dich mit Siegwitz auch?

01:46:41.840 --> 01:46:42.280
Aus?

01:46:42.720 --> 01:46:43.800
Nicht im Detail.

01:46:45.900 --> 01:46:46.300
Schade.

01:46:47.180 --> 01:46:48.340
Ich dachte, er hat gedacht, ich kann

01:46:48.340 --> 01:46:49.640
die Verantwortung von mir schieben.

01:46:50.340 --> 01:46:52.200
Ja, aber wenn du dich damit beschäftigt hast, dann mach das doch.

01:46:53.080 --> 01:46:54.060
Was ich? Nein, nein, nein.

01:46:54.440 --> 01:46:55.320
Nein? Nein, nein, nein.

01:46:58.380 --> 01:47:00.080
Was wäre denn euer Pick tatsächlich?

01:47:00.680 --> 01:47:01.600
Ja, also meiner

01:47:01.600 --> 01:47:03.540
wäre jetzt

01:47:03.540 --> 01:47:04.700
tatsächlich

01:47:04.700 --> 01:47:06.440
YouTube.dl.

01:47:09.440 --> 01:47:10.160
Wie kommst du

01:47:10.160 --> 01:47:10.840
da drauf?

01:47:12.060 --> 01:47:13.560
Ja, ich habe damit in letzter Zeit,

01:47:13.560 --> 01:47:14.720
im letzten Jahr viel gemacht.

01:47:14.860 --> 01:47:17.640
Ich habe es früher vielleicht ab und zu mal benutzt, um irgendwie mal

01:47:17.640 --> 01:47:19.600
Videos runterzuladen, die ich gerne

01:47:19.600 --> 01:47:21.600
auf der Platte hätte. Also genau

01:47:21.600 --> 01:47:22.660
dafür ist es ja da, aber

01:47:22.660 --> 01:47:25.140
im letzten Jahr habe ich das auch viel

01:47:25.140 --> 01:47:26.360
sozusagen

01:47:26.360 --> 01:47:29.420
in Projekten verwendet, weil es

01:47:29.420 --> 01:47:31.260
darum ging, wie man da Videos irgendwie

01:47:31.260 --> 01:47:32.760
automatisch verarbeiten 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.840 --> 01:47:39.520
Aber ich glaube, Philipp kann das

01:47:39.520 --> 01:47:41.320
deutlich besser erklären, was das eigentlich so tut

01:47:41.320 --> 01:47:42.480
und was so ein bisschen...

01:47:42.480 --> 01:47:45.340
Es gab auch so einen kleinen politischen Vorfall beim YouTube.

01:47:45.520 --> 01:47:47.180
Den müssen wir auch noch natürlich

01:47:47.180 --> 01:47:48.060
erzählen.

01:47:48.700 --> 01:47:51.340
Der Name von YouTube.de ist stark irreführend.

01:47:52.360 --> 01:47:56.140
Das hat angefangen als ein Download-Tool nur für YouTube.

01:47:57.100 --> 01:47:58.680
Und als ich das damals übernommen habe,

01:47:59.580 --> 01:48:01.860
da wurden, glaube ich, noch Vimeo unterstützt

01:48:01.860 --> 01:48:02.860
und noch ein, zwei andere Seiten.

01:48:03.440 --> 01:48:05.440
Aber als ich das abgegeben habe,

01:48:05.540 --> 01:48:07.500
also mittlerweile entwickle ich auch schon länger nicht mehr daran.

01:48:08.320 --> 01:48:09.240
Entwicke schon ein bisschen daran,

01:48:09.320 --> 01:48:11.200
aber bin halt nicht mehr der Chef-Maintainer.

01:48:13.340 --> 01:48:15.480
Und mittlerweile unterstützt es über 1.000 Dienste.

01:48:15.580 --> 01:48:17.600
Das heißt, 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 ja immer ein ordentliches

01:48:27.940 --> 01:48:30.020
Video zurückliefern. Du kannst natürlich

01:48:30.020 --> 01:48:31.000
auch sagen, ich möchte verschiedene

01:48:31.000 --> 01:48:33.700
Konfigurationen, also möchte ich das Video

01:48:33.700 --> 01:48:35.940
sortieren oder möchte ich direkt eine Playlist drunter laden

01:48:35.940 --> 01:48:37.880
und YouTube.dl ist komplett in Python

01:48:37.880 --> 01:48:39.900
geschrieben. Das ist vielleicht auch ein bisschen besonders, weil es

01:48:39.900 --> 01:48:41.900
eine Python-Anwendung ist, die

01:48:41.900 --> 01:48:43.140
gar keine Dependencies hat.

01:48:43.660 --> 01:48:45.760
YouTube.dl verlangt nur die Standard-Diplotik

01:48:45.760 --> 01:48:47.640
Und das auch sehr, sehr, sehr flexibel.

01:48:47.920 --> 01:48:54.740
Also bis vor kurzem noch konnten wir zwischen Python 2.6, ging noch, bis Python 3.8, wurde alles unterstützt.

01:48:55.220 --> 01:48:56.460
Hat sehr, sehr viele Benutzer.

01:48:58.020 --> 01:49:07.000
Und ja, ist halt hoffentlich ein super flexibles Tool, das man auch sowohl programmatisch als auch als Kommandozeitanwendung verwenden kann, um schnell was runterzuladen.

01:49:07.140 --> 01:49:14.280
Viele grafische oder serverseitige Programme verwenden auch intern YouTube.dl, um halt Videos runterzuladen aus verschiedensten Quellen.

01:49:14.680 --> 01:49:17.440
Typischerweise, also oft YouTube, aber kann auch was ganz anderes sein.

01:49:18.500 --> 01:49:29.260
Und der Vorfall, der halt passiert war, ist, also vor dem öffentlichen Vorfall bin ich und ein Hoster angeschrieben worden von einer deutschen Anwaltskanzlei, die Rasch heißt die.

01:49:29.260 --> 01:49:38.120
Die sind, wenn man nach denen googelt, also ich habe zuerst natürlich nach denen gegoogelt, als ich das Schreiben bekommen habe, sieht man, okay, die schicken normalerweise Abnahmen wegen Tauschbörsenvorfällen oder sowas.

01:49:38.140 --> 01:49:39.340
Irgendwie bekannt für den Namen, ja.

01:49:40.280 --> 01:49:48.440
Und die haben halt da typischen, also ich kann das jetzt nicht so beurteilen, ich bin kein Jurist,

01:49:48.740 --> 01:49:52.780
aber die haben ein sehr langes Papier geschrieben, wo sehr große Drohungen drin standen,

01:49:52.880 --> 01:49:56.720
was für mich eigentlich jetzt irrelevant ist, weil ich bin ja nicht mehr in ein Projekt involviert.

01:49:56.720 --> 01:50:00.960
Also ich habe noch gelegentlich Contributions geleistet, aber auch nichts mehr zu YouTube,

01:50:01.100 --> 01:50:02.780
sondern nur noch zu ganz anderen Seiten.

01:50:04.220 --> 01:50:08.020
Und dann haben die wohl aber mitbekommen, dass YouTube-DL auf GitHub gehostet ist.

01:50:08.800 --> 01:50:11.080
Und dann an die amerikanische,

01:50:11.180 --> 01:50:13.020
ja, so richtig technisch drauf waren sie

01:50:13.020 --> 01:50:14.960
nicht, aber gut, sind auch recht anwesend,

01:50:15.040 --> 01:50:17.080
sind keine Programmierer, haben halt nur so ein bisschen

01:50:17.080 --> 01:50:19.040
was gefunden und haben auch viele Sachen nicht richtig

01:50:19.040 --> 01:50:20.460
verstanden. Also,

01:50:21.500 --> 01:50:23.040
das ist halt, ja, kann man

01:50:23.040 --> 01:50:23.440
ja nicht machen.

01:50:25.180 --> 01:50:25.960
Und dann sind sie halt

01:50:25.960 --> 01:50:28.580
zu den Amerikanern gegangen und die

01:50:28.580 --> 01:50:30.880
RIA, und die

01:50:30.880 --> 01:50:32.380
hat dann halt GitHub

01:50:32.380 --> 01:50:33.920
eine Notiz geschickt,

01:50:35.180 --> 01:50:35.940
eine

01:50:35.940 --> 01:50:38.500
DMCA-Notiz,

01:50:38.900 --> 01:50:39.460
dass sie halt

01:50:39.460 --> 01:50:42.320
die YouTube.de

01:50:42.320 --> 01:50:44.120
sperren sollen. Und davon haben die meisten Leute erst

01:50:44.120 --> 01:50:46.220
mitbekommen, dass irgendwas nicht stimmt. Also diese

01:50:46.220 --> 01:50:48.200
Vorgeschichte, das war schon Wochen davor in Deutschland

01:50:48.200 --> 01:50:50.160
und auch andere Sachen waren Wochen

01:50:50.160 --> 01:50:52.320
davor, aber was die Öffentlichkeit mitbekommen hat,

01:50:52.400 --> 01:50:54.300
war, okay, GitHub ist gesperrt.

01:50:54.640 --> 01:50:56.080
Und GitHub ist freundlicherweise für

01:50:56.080 --> 01:50:58.320
das YouTube.de-Projekt, das hostet die Downloads.

01:50:58.980 --> 01:50:59.740
Das YouTube.de

01:50:59.740 --> 01:51:01.840
muss relativ häufig aktualisiert werden,

01:51:02.140 --> 01:51:04.400
also wird so alle zwei, drei Tage aktualisiert.

01:51:04.800 --> 01:51:07.700
Klar, bei irgendeiner Webseite ändert 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:12.920
Also da laufen pro Tag 10 PRs rein.

01:51:14.200 --> 01:51:19.040
Und dadurch entstehen halt große, hohe Downloadzahlen.

01:51:19.140 --> 01:51:21.320
Und dann ging halt erstmal gar nichts, weil GitHub das nicht gemacht hat.

01:51:21.780 --> 01:51:23.260
Das Projekt ist direkt umgeschwenkt.

01:51:23.260 --> 01:51:28.940
Und ich hatte schon befürchtet, dass es daran endet, dass das Projekt nur noch YouTube-Musik runterladen kann.

01:51:29.060 --> 01:51:33.140
Also der Stein des Anstoßes waren nicht die normalen YouTube-Downloads, sondern die YouTube-Musik-Videos.

01:51:33.220 --> 01:51:38.420
Das war das Problem, was die Rechtsanwälte bemängelt hatten.

01:51:39.220 --> 01:51:42.280
Und was jetzt aber passiert ist, dass glücklicherweise die IFF,

01:51:42.500 --> 01:51:45.240
die Electronic Frontier Foundation,

01:51:46.860 --> 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.560 --> 01:51:58.820
Und das Projekt wahrscheinlich jetzt ganz normal weiterläuft

01:51:58.820 --> 01:52:01.220
und alles wieder klappt.

01:52:01.660 --> 01:52:03.360
Ich war da auch gar nicht so viel involviert.

01:52:03.460 --> 01:52:05.540
Ich bin halt nur von zig Leuten angeschrieben worden,

01:52:05.640 --> 01:52:06.640
habe einige Interviews gegeben.

01:52:07.440 --> 01:52:08.760
Und ich bin halt natürlich rechtlich,

01:52:08.960 --> 01:52:10.740
habe ich mit einem Rechtsanwalt gesprochen.

01:52:11.460 --> 01:52:13.620
Damals hatte ich da nicht den richtigen Überblick.

01:52:13.780 --> 01:52:15.560
Ich habe dann auch eine Unterlassungserklärung abgegeben,

01:52:15.920 --> 01:52:17.880
dass ich nicht mehr daran teilnehme an YouTube.dl.

01:52:18.140 --> 01:52:18.720
Sehr traurig.

01:52:20.620 --> 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.580 --> 01:52:27.920
Und ich bin sehr froh, dass die IFF sich darum gekümmert hat.

01:52:28.260 --> 01:52:30.060
Und auch über die Unterstützung von GitHub.

01:52:30.780 --> 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.520 --> 01:52:38.120
Da kann man super leicht

01:52:38.120 --> 01:52:39.200
seinen eigenen Dienst hosten.

01:52:39.720 --> 01:52:41.380
Und die sind auch rechtlich

01:52:41.380 --> 01:52:44.120
angeschrieben worden, auch von den Rechtsanwälten rasch.

01:52:44.640 --> 01:52:45.660
Und die haben sich

01:52:45.660 --> 01:52:47.800
auf eigene Kosten, haben die ihre eigene

01:52:47.800 --> 01:52:50.060
Verteidigung organisiert. Die hosten halt nur die Webseite.

01:52:50.160 --> 01:52:51.360
Die hosten nicht das Programm selber.

01:52:51.920 --> 01:52:53.380
Aber auch das fand die Rechtsanwälte

01:52:53.380 --> 01:52:55.920
verwerflich. Glücklicherweise ist

01:52:55.920 --> 01:52:57.520
jetzt, glaube ich, alles gut und ich glaube,

01:52:57.580 --> 01:52:58.600
YouTube.de wird es genutzt.

01:52:59.840 --> 01:53:01.500
völlig unbestritten, dass das

01:53:01.500 --> 01:53:02.880
absolut legitim ist. Es haben sich

01:53:02.880 --> 01:53:05.520
nach der Sperrung auch sehr, sehr viele

01:53:05.520 --> 01:53:07.880
Museen oder Archivare

01:53:07.880 --> 01:53:09.700
oder Bibliotheken gemeldet, die gesagt haben,

01:53:09.800 --> 01:53:11.780
okay, wir verwenden das und wir haben sogar

01:53:11.780 --> 01:53:13.560
rechtlich das Anrecht darauf,

01:53:13.720 --> 01:53:15.720
selbst Musikvideos runterzuladen, weil

01:53:15.720 --> 01:53:17.780
das genau steht und irgendwie muss es

01:53:17.780 --> 01:53:19.720
halt passieren und YouTube.dl ist genau das Werkzeug,

01:53:19.820 --> 01:53:21.820
um sowas zu machen. Und ich glaube, der Nutzen

01:53:21.820 --> 01:53:23.620
von YouTube.dl überwiegt bei weitem

01:53:23.620 --> 01:53:25.040
das jegliche

01:53:25.040 --> 01:53:27.760
Probleme, dass man da ein Musikvideo

01:53:27.760 --> 01:53:29.780
in meiner Weise relativ schlechter Qualität

01:53:29.780 --> 01:53:30.860
von YouTube runterladen kann,

01:53:30.940 --> 01:53:37.220
was man ja auf Spotify oder überall bei Amazon oder bei Apple

01:53:37.220 --> 01:53:40.900
als MP3-Datei oder als Flak-Datei

01:53:40.900 --> 01:53:42.560
in deutlich besserer Qualität kaufen kann.

01:53:43.540 --> 01:53:46.820
Ich glaube, das ist viel besser für die Gesellschaft,

01:53:47.300 --> 01:53:49.100
dass YouTube.dl für alle verfügbar ist.

01:53:49.100 --> 01:53:51.100
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:58.260 --> 01:54:11.920
Ja, aber ja, ich glaube auch eher, das ist der, also sag mal so, das hat dem Projekt wahrscheinlich doch eher stark genützt. Das hat jetzt nochmal sehr viel Aufmerksamkeit bekommen und hat der Streisand-Effekt voll zugeschlagen.

01:54:11.920 --> 01:54:13.180
Ja, auf jeden Fall.

01:54:13.640 --> 01:54:15.940
Also ich bin tatsächlich froh, dass es mittlerweile soweit ist,

01:54:16.020 --> 01:54:18.340
dass solche Sachen nicht mehr einfach so dann weggeblockt werden,

01:54:18.460 --> 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:25.960 --> 01:54:28.060
langsam sich ja 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.360
Ich bin halt nur eine Person.

01:54:32.580 --> 01:54:36.020
Ich habe keine große juristische Know-how.

01:54:36.240 --> 01:54:37.960
Also ich kann das halt technisch beurteilen,

01:54:38.080 --> 01:54:39.260
was im Gesetz steht.

01:54:39.520 --> 01:55:08.420
aber offensichtlich gibt es auch einige Gerichte, die das sehr flexibel ausgelegt haben, was da im Gesetz steht, 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.660 --> 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 ist aber kein 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:26.940
Ja, der Jurist

01:55:26.940 --> 01:55:28.540
das dann selber ausprobiert und dann festgestellt,

01:55:28.580 --> 01:55:30.460
nee, er kann das nicht. Ja, genau, genau, exakt.

01:55:30.460 --> 01:55:31.900
Das darf er nicht. Genau.

01:55:32.640 --> 01:55:34.660
Und YouTube-DLS funktioniert eigentlich wie ein normaler

01:55:34.660 --> 01:55:36.020
Browser, ist nicht unterschiedlich,

01:55:36.300 --> 01:55:38.340
nicht grundsätzlich unterschiedlich wie Chrome, es hat auch

01:55:38.340 --> 01:55:40.180
einen eigenen JavaScript-Engine in Python geschrieben.

01:55:41.300 --> 01:55:42.640
Ach, äh, ah, okay,

01:55:42.840 --> 01:55:44.440
das und tatsächlich, die ist selber,

01:55:44.520 --> 01:55:46.380
aha, naja, stimmt, wenn es keine externen

01:55:46.380 --> 01:55:48.400
Abhängigkeiten gibt, oh, das wusste ich nicht, das hätte ich

01:55:48.400 --> 01:55:50.560
jetzt auch gedacht, dass das vielleicht irgendein

01:55:50.560 --> 01:55:52.580
Headless-Browser-Engine

01:55:52.580 --> 01:55:54.460
noch mit dabei ist oder so, nee, komplett, wow, okay.

01:55:54.460 --> 01:55:55.880
Also gar keine Python-Abhängigkeiten.

01:55:56.640 --> 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.680 --> 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.220
und haben halt Python 2.6 oder bis vor kurzem noch Python,

01:56:12.440 --> 01:56:14.600
oder vor allem jetzt noch Python 2.5 haben die noch drauf,

01:56:14.680 --> 01:56:16.120
oder Python 2.4, keine Ahnung.

01:56:16.380 --> 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:22.980 --> 01:56:24.980
Und das geht ja in Python

01:56:24.980 --> 01:56:26.360
relativ gut. Man kann die Datei ja einfach

01:56:26.360 --> 01:56:29.160
als ZIP verpacken und dann ist es ausführbar.

01:56:29.800 --> 01:56:30.900
Und man kann das auch mit

01:56:30.900 --> 01:56:33.300
YouTube.de

01:56:33.300 --> 01:56:34.860
CX Freeze, um halt

01:56:34.860 --> 01:56:36.760
auch eine Excel für Windows zu erzeugen.

01:56:37.000 --> 01:56:39.040
Und das läuft dann wirklich überall, ohne dass man es installieren

01:56:39.040 --> 01:56:40.920
muss. Und ich glaube, das ist auch ein Grund

01:56:40.920 --> 01:56:42.840
für den Erfolg dieser Software,

01:56:43.360 --> 01:56:45.020
dass man das halt einfach so laufen lassen kann,

01:56:45.080 --> 01:56:47.100
dass man sich keine Gedanken machen muss, auch wenn das System

01:56:47.100 --> 01:56:48.720
komplett zerschlossen ist als Python-Entwickler.

01:56:49.080 --> 01:56:50.700
Das klappt immer. YouTube.de, klar, braucht

01:56:50.700 --> 01:56:51.400
ungesunde Politik.

01:56:52.980 --> 01:56:53.780
Sehr gut, sehr gut.

01:56:55.620 --> 01:56:56.440
Ja, das klingt sehr spannend.

01:56:58.340 --> 01:56:58.660
Ja, ja,

01:56:58.760 --> 01:57:00.880
mir war das auch gar nicht so klar, dass man da tatsächlich

01:57:00.880 --> 01:57:02.340
irgendwie die meisten Seiten mit

01:57:02.340 --> 01:57:04.460
bedienen kann und dann,

01:57:04.940 --> 01:57:06.940
ja, ich hatte früher

01:57:06.940 --> 01:57:08.280
auch immer gedacht, das wäre eigentlich für YouTube,

01:57:09.100 --> 01:57:10.960
aber ja, es ist wirklich sehr, sehr

01:57:10.960 --> 01:57:12.100
praktisch, es nimmt einem auch viel ab.

01:57:12.360 --> 01:57:14.320
Ich benutze das jetzt halt immer so

01:57:14.320 --> 01:57:17.000
quasi,

01:57:17.000 --> 01:57:19.140
um halt automatisiert von allen möglichen

01:57:19.140 --> 01:57:20.980
Seiten Dinge runterzuladen und das ist halt sozusagen

01:57:20.980 --> 01:57:22.920
die Schnittstelle, die YouTube-DL

01:57:22.920 --> 01:57:24.260
ist sozusagen meine API zu

01:57:24.260 --> 01:57:26.260
Seiten, die Videos haben,

01:57:26.740 --> 01:57:28.440
um das Video da rauszukriegen.

01:57:28.800 --> 01:57:29.900
Genau, ohne, ja.

01:57:32.300 --> 01:57:32.740
Ja.

01:57:33.500 --> 01:57:33.940
Ja.

01:57:35.000 --> 01:57:36.820
Ja, Pics. Also ich

01:57:36.820 --> 01:57:38.540
würde dieses Mal gleich Python Date-Util

01:57:38.540 --> 01:57:40.720
picken, weil irgendwie das ein schöner Rapper ist,

01:57:40.840 --> 01:57:43.340
über wie man Datumsangaben

01:57:43.340 --> 01:57:44.000
irgendwie machen kann,

01:57:44.460 --> 01:57:46.200
in verschiedenen Zeitkalendern mit Deltas.

01:57:47.000 --> 01:57:48.660
Ich wollte es mal erwähnt haben, das stand irgendwo noch

01:57:48.660 --> 01:57:50.800
auf meiner Liste, hat jetzt nicht den Topic gar nicht so viel zu tun,

01:57:50.880 --> 01:57:51.000
mal.

01:57:52.820 --> 01:57:54.360
Ja, detutilt ist

01:57:54.360 --> 01:57:55.940
tatsächlich auch sehr nett. Also ich,

01:57:56.460 --> 01:57:58.460
das detutilt-pass, das passt

01:57:58.460 --> 01:58:00.840
erstaunlich viel. Also dem kann man

01:58:00.840 --> 01:58:02.780
irgendwelche Strings geben, die so, also man hat

01:58:02.780 --> 01:58:04.580
ja oft irgendwie, sieht man dann irgendwo so ein

01:58:04.580 --> 01:58:06.860
String mit Datums und Zeitangaben

01:58:06.860 --> 01:58:08.820
drin und dann denkt man sich, oh, wie waren

01:58:08.820 --> 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.420
Und dann nimmt man detutilt-pass

01:58:15.420 --> 01:58:17.040
und dann passt

01:58:17.040 --> 01:58:18.720
das automatisch, aber dann muss man irgendwie noch,

01:58:19.040 --> 01:58:20.800
ich glaube, das geht aber auch irgendwie, man kriegt

01:58:20.800 --> 01:58:22.640
auch aus dem Digital Pass dann raus,

01:58:23.120 --> 01:58:24.900
wie der Format-String eigentlich sein müsste.

01:58:25.120 --> 01:58:26.320
Und andere Kalender.

01:58:26.940 --> 01:58:28.940
Genau, weil Digital Pass

01:58:28.940 --> 01:58:30.800
sollte man nicht über größere

01:58:30.800 --> 01:58:32.720
Datenmengen aufrufen, weil das

01:58:32.720 --> 01:58:34.800
wird dann halt sehr langsam, wenn man das Inhaltschleife verwendet.

01:58:34.940 --> 01:58:36.880
Aber um rauszukriegen, wie man

01:58:36.880 --> 01:58:38.660
das denn jetzt eigentlich aufpasst und dann halt

01:58:38.660 --> 01:58:40.680
an den Format-String zu kommen, mit dem man

01:58:40.680 --> 01:58:42.560
dann letztlich verwendet, für

01:58:42.560 --> 01:58:44.360
Strip-Time oder so, das ist super.

01:58:45.740 --> 01:58:46.580
Und dein Pick-Up?

01:58:47.360 --> 01:58:48.100
Hatte ich doch schon.

01:58:48.520 --> 01:58:50.560
Ja, YouTube.dl. Ach, verdammt.

01:58:50.800 --> 01:58:52.340
Ja, richtig. Ich dachte jetzt, das ist der Philips-Pick gewesen.

01:58:52.820 --> 01:58:54.380
Na gut. Du bist da

01:58:54.380 --> 01:58:55.740
ausnahmsweise wegen dem YouTube-DL

01:58:55.740 --> 01:58:57.860
da rumgekommen. Es sei denn, du hast noch einen.

01:58:58.240 --> 01:58:58.600
Extra.

01:59:00.260 --> 01:59:02.300
Ne, das habe ich jetzt nicht vorbereitet.

01:59:03.080 --> 01:59:04.280
Ich habe mich auch 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.460 --> 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.140 --> 01:59:18.200
Die richtige Bibliothek, um halt Passwörter zu herstellen, wäre

01:59:18.200 --> 01:59:18.980
sowas wie B-Crypt.

01:59:20.800 --> 01:59:23.040
Ja, da haben wir das auch noch

01:59:23.040 --> 01:59:23.720
reinge...

01:59:23.720 --> 01:59:26.920
Ja, schön, dass ihr alle dabei seid.

01:59:26.960 --> 01:59:28.500
Danke, Philipp, dass du Zeit gefunden hast für uns.

01:59:28.820 --> 01:59:29.380
Ja, voll gut.

01:59:30.960 --> 01:59:32.140
Eine sehr interessante Episode.

01:59:32.360 --> 01:59:33.240
Ja, auch für mich sehr interessant.

01:59:34.520 --> 01:59:35.980
Ja, vielen Dank, dass ich dabei sein durfte.

01:59:36.440 --> 01:59:38.980
Wenn ich noch einmal ganz kurz

01:59:38.980 --> 01:59:40.720
Werbung machen darf, bei Poxine suchen wir

01:59:40.720 --> 01:59:42.060
immer Python-Entwickler.

01:59:43.260 --> 01:59:44.760
Oder was immer, aber aktuell suchen wir

01:59:44.760 --> 01:59:46.820
auf jeden Fall Python-Entwickler oder auch Leute,

01:59:46.820 --> 01:59:49.060
die mit Java oder mit JavaScript arbeiten.

01:59:49.540 --> 01:59:50.360
Speziell mit React.

01:59:50.800 --> 01:59:52.940
Also wenn ihr ein guter Entwickler seid,

01:59:53.060 --> 01:59:54.280
vielleicht sogar im Raum Düsseldorf

01:59:54.280 --> 01:59:56.920
oder auch nur ganz grob in NRW irgendwo,

01:59:57.520 --> 01:59:58.960
dann meldet euch bei Baboxine.

01:59:59.840 --> 02:00:02.080
Die Tonybox zu programmieren macht wirklich...

02:00:02.080 --> 02:00:04.200
Und die Dienste rund um die Tonybox zu programmieren

02:00:04.200 --> 02:00:05.320
macht sehr viel Spaß.

02:00:05.420 --> 02:00:06.760
Es ist total toll zu wissen,

02:00:06.760 --> 02:00:12.500
okay, jede Nacht gehen Tausende oder Millionen Kinder

02:00:12.500 --> 02:00:14.520
mittlerweile mit der Tonybox ins Schlaf.

02:00:14.660 --> 02:00:16.120
Und wir machen gute Dienste,

02:00:16.620 --> 02:00:19.720
die hoffentlich den Eltern das Leben einfach machen

02:00:19.720 --> 02:00:21.580
und dafür sorgen, dass die Kinder gute

02:00:21.580 --> 02:00:22.400
Geschichten hören.

02:00:23.040 --> 02:00:25.040
Das war die erste Werbeanzeige am Preißen-Podcast.

02:00:25.540 --> 02:00:28.740
Ja, aber ich kann nicht nur...

02:00:28.740 --> 02:00:29.680
Könnt ihr rausschneiden, falls

02:00:29.680 --> 02:00:31.660
ich meine... Nein, nein, nein, das finde ich super.

02:00:31.820 --> 02:00:32.920
Also Turnbox ist eine coole Sache.

02:00:33.560 --> 02:00:35.180
Ist ein schönes Projekt hier aus der Gegend.

02:00:37.340 --> 02:00:39.260
Ja, alles klar, dann würde ich sagen...

02:00:39.260 --> 02:00:41.520
Vielen Dank, Philipp. Und bleibt uns gewogen.

02:00:41.820 --> 02:00:43.600
Egal, wann ihr uns hört, schaltet wieder ein.

02:00:44.340 --> 02:00:45.420
Morgens, mittags, abends, tags, nachts

02:00:45.420 --> 02:00:46.820
und zum Einschlafen ist auch immer super.

02:00:47.780 --> 02:00:49.240
Liebe Grüße und bis zum nächsten Mal.

02:00:49.620 --> 02:00:50.420
Jo. Ja, tschüss.