WEBVTT

00:00.000 --> 00:03.940
Lautsprecher, das hört sich noch ein bisschen komisch an.

00:06.060 --> 00:08.280
Ja, das wundert mich auch. Warte mal.

00:10.780 --> 00:11.800
Irgendwas stimmt noch nicht.

00:12.340 --> 00:13.640
Dann müssen wir nochmal duplizieren hier.

00:14.660 --> 00:15.680
Gleich klappt es dann besser.

00:16.600 --> 00:18.980
Und Ton höre ich irgendwie über den Lautsprecher auch noch nicht.

00:20.380 --> 00:21.000
Dann kommt der.

00:21.220 --> 00:23.200
Ah, jetzt hört es sich besser an. Wunderbar.

00:23.800 --> 00:24.860
Dann machen wir das doch so.

00:25.980 --> 00:28.560
So, jetzt also. Letzter Vortrag für heute.

00:30.000 --> 00:31.840
Das Beste kommt zum Schluss, sagt man sonst immer.

00:32.820 --> 00:35.600
Der Philipp, auch früherer Student von uns,

00:35.720 --> 00:40.260
erzählt uns was zum Thema Whitebox-Fuzzing und CI-CD-Pipeline.

00:40.400 --> 00:41.560
Ich bin gespannt. Viel Spaß.

00:42.480 --> 00:45.100
Perfekt. Hallo, ich hoffe, ihr hört mich alle gut.

00:46.240 --> 00:49.940
Es ist eine Weile her, glaube ich jetzt ein Jahr, zwei Jahre,

00:50.220 --> 00:51.300
dass ich das letzte Mal hier stand.

00:51.940 --> 00:53.920
Ich habe hier auch Medieninformatik studiert,

00:53.920 --> 00:55.460
dann Master noch oben drauf gemacht.

00:55.920 --> 00:58.400
Momentan arbeite ich als Solution Engineer bei Code Intelligence.

00:59.320 --> 01:02.280
Das ist, ich sage noch ein bisschen später was zu der Firma,

01:03.020 --> 01:05.840
Schwerpunkt ist so ein bisschen Application Security Testing,

01:06.560 --> 01:08.360
darüber geht jetzt auch so ein bisschen der Vortrag,

01:08.540 --> 01:11.840
generell einfach die Frage, wie kann ich eigentlich ein Security Testing

01:11.840 --> 01:17.140
in ein agiles Development, oder eine agile Development-Method mit reinbringen,

01:17.640 --> 01:21.420
wie kann ich ein Security Testing in das CI-CD-Private-Blind mit reinbringen.

01:22.920 --> 01:26.400
Genau, da dazu, wenn ihr irgendwelche Fragen habt, unterbrecht mich einfach.

01:26.780 --> 01:29.020
Also ich bin es gewohnt, dass ich mich einfach unterbreche,

01:29.100 --> 01:30.060
das ist tatsächlich auch mein Job,

01:30.660 --> 01:33.520
viele Präsentationen oder Vorträge zu halten.

01:34.820 --> 01:36.500
Es lebt aus meiner Sicht immer davon,

01:36.720 --> 01:39.220
von der Interaktion mit den Leuten, die Fragen stellen.

01:39.600 --> 01:41.360
Das heißt, wenn ihr irgendwas habt, fragt.

01:42.220 --> 01:43.780
Wenn ihr nachher keine Fragen habt,

01:43.860 --> 01:45.540
dann kann man das nachher auch relativ schnell beenden,

01:46.220 --> 01:47.420
weil dann war es anscheinend langweilig.

01:47.920 --> 01:50.680
Aber ich hoffe mal, dass ihr ein paar Dinge mitnehmt

01:50.680 --> 01:52.580
und es heißt nur ein paar Anekdoten.

01:53.120 --> 01:54.680
Das wäre manchmal auch gar nicht so schlecht.

01:54.680 --> 02:00.020
Generell so ein bisschen, okay, ich gehe davon aus, ja, SED ist ein Begriff,

02:00.700 --> 02:03.920
agile Development-Methoden auch, ja, sehr gut.

02:04.500 --> 02:07.260
Gut, dann fangen wir an mit etwas sehr, sehr Negativen,

02:07.540 --> 02:09.960
hoffentlich in einigermaßen witzige Bilder verpackt.

02:10.560 --> 02:12.940
Der Zustand von Application Security Testing.

02:13.540 --> 02:15.800
Es interessiert keine Sau, gar nicht.

02:16.440 --> 02:19.460
Was die Leute interessiert, ist Compliance und eigene Sicherheit.

02:20.400 --> 02:23.680
Sicherheit im Sinne von den Tools, die ich deploy, die ich vertreibe,

02:24.360 --> 02:25.960
Da wird nachher in die AGBs reingeschrieben,

02:26.040 --> 02:28.820
dass die Leute im Zweifelsfall verantwortlich sind, wenn sie die Software einsetzen.

02:30.420 --> 02:32.680
Es ist aus der Sicht ein Trauerspiel.

02:33.640 --> 02:36.720
Ich habe euch da auch zwei Anekdoten mitgebracht.

02:36.800 --> 02:38.160
Ich muss immer auffassen, dass ich keine Namen nenne.

02:38.780 --> 02:42.160
Generell, meine Firma hat relativ viele Kunden aus dem Automotive-Sektor.

02:42.740 --> 02:46.320
Nicht nur, aber unter anderem ein größerer Teil davon.

02:48.140 --> 02:52.400
Die Automotive-Kunden sind alle so ein bisschen gezwungen in Zukunft,

02:52.400 --> 02:55.060
eine Technologie namens Fuzzing einzusetzen.

02:55.900 --> 02:58.460
Was Fuzzing genau ist, sage ich später noch,

02:59.020 --> 03:01.540
aber auf jeden Fall, die sind bei neueren Projekten gezwungen,

03:01.680 --> 03:02.900
diese Technologie einzusetzen.

03:03.760 --> 03:07.580
Jetzt ist es so, es gibt eine einfache Möglichkeit,

03:07.740 --> 03:10.240
eine schwere Möglichkeit, auch da kommen wir dann nachher nochmal später dazu,

03:11.040 --> 03:13.920
und wir haben prinzipiell ein bisschen die schwere Möglichkeit,

03:14.180 --> 03:16.420
dass die ein bisschen mehr Effort am Anfang verursacht,

03:16.860 --> 03:19.800
dafür aber langfristig sehr viel schneller, sehr viel besser,

03:19.800 --> 03:20.880
sehr viel effizienter läuft.

03:21.600 --> 03:24.700
Entsprechend sind wir auch an viele Kunden herangetreten und die waren noch so,

03:25.540 --> 03:29.400
ach ja, wir müssen es jetzt mal zwar machen, aber dann nehmen wir doch das Einfachste,

03:29.520 --> 03:32.440
weil einen Mehrwert haben wir doch sowieso nicht davon, wir sind doch schon sicher.

03:33.080 --> 03:35.980
Das heißt, bei denen laufen statische Sachen mit rum und Pentest.

03:36.440 --> 03:38.060
Und wir gehen davon aus, damit passt es.

03:38.780 --> 03:41.420
Das Ergebnis war, dass die uns eine Software gegeben haben,

03:41.540 --> 03:45.200
die eben durch beide Sicherheitstests durch ist, wo sie eigentlich kurz vorm Deployen waren,

03:45.580 --> 03:49.620
wo sie gesagt haben, naja, also im Sinne von, ja, jetzt schickt man sie mal weg,

03:49.620 --> 03:51.400
wenn sie da nichts finden, dann lassen sie uns endlich in Ruhe.

03:53.500 --> 03:55.760
Die Antwort war dann, als wir den Report rausgerückt haben,

03:55.940 --> 03:59.900
oh, also einige Dinge sind drin gewesen,

04:00.040 --> 04:02.780
unter anderem relativ kritische Remote Code Execution Schwachstellen,

04:03.140 --> 04:05.120
also es war richtig, richtig übel.

04:05.560 --> 04:08.120
Wenn sie es so deployed hätten, hätten sie es direkt zurückziehen müssen.

04:08.320 --> 04:09.500
Also es wäre ein direkter Rückruf gewesen,

04:10.320 --> 04:12.660
wer die Automobilindustrie kennt, weiß, es wird richtig teuer.

04:13.280 --> 04:15.160
So, zweites Projekt, gleiche Situation.

04:16.160 --> 04:18.920
Und dann haben wir gesagt, okay, jetzt skalieren wir das so ein bisschen,

04:18.920 --> 04:22.960
habt ihr noch weitere Produkte oder neue Projekte und haben dann,

04:23.040 --> 04:25.100
weil wir eben mit dem Team schon ein bisschen geredet haben,

04:25.200 --> 04:28.860
auch schon andere quasi so ein bisschen im Blick gehabt und haben eben auch vorgeschlagen,

04:28.960 --> 04:31.980
hier nehmen wir doch mal eins, das schon deployed ist, das so ein bisschen älter ist,

04:32.540 --> 04:33.540
da finden wir auch Sachen.

04:33.880 --> 04:36.760
Ab da ist der Manager eingeschritten und hat gesagt, stopp, das machen wir nicht,

04:37.000 --> 04:41.780
alte Projekte testen wir einfach nicht, weil wenn ihr da irgendwas findet,

04:41.860 --> 04:43.960
müssen wir wirklich einen Recruit starten, das wollen wir nicht.

04:44.960 --> 04:48.860
Das heißt, obwohl die genau gesehen haben, in ihrem Code sind jenseits

04:48.860 --> 04:50.820
Schwachstellen drin und wir reden von Schwachstellen,

04:50.920 --> 04:52.460
die dafür sorgen, dass ein Auto komplett hinsteht.

04:52.840 --> 04:54.840
Das dann komplett, also im besten Fall neu startet,

04:55.240 --> 04:56.900
aber wo die Software einmal komplett

04:56.900 --> 04:58.800
abstürzt, beziehungsweise komplett übernommen

04:58.800 --> 05:00.800
werden kann. Und obwohl sie das

05:00.800 --> 05:02.080
gesehen haben, haben sie gesagt, oh,

05:02.360 --> 05:03.900
Rückrufe ist zu teuer, machen wir nicht.

05:04.740 --> 05:06.660
Und da, also das ist so ein Beispiel, wo man weiß,

05:06.740 --> 05:09.000
okay, über das Gesetz kamen die Compliance

05:09.000 --> 05:10.440
rein, sie müssen jetzt Fast-Testing machen,

05:10.960 --> 05:12.520
aber sie wollen eigentlich nur die Compliance erfüllen.

05:12.680 --> 05:14.620
Sicherheit interessiert sie nicht. Im Zweifelsfall

05:14.620 --> 05:15.580
interessiert sie die Geldbeute.

05:16.820 --> 05:17.640
Zweites Beispiel.

05:17.640 --> 05:20.640
Nicht Automobilindustrie, trotzdem Embedded.

05:20.640 --> 05:28.140
Wir reden, ich rede mit einem Kunden, der sehr engagiert ist, der sehr motiviert ist,

05:28.140 --> 05:31.380
der aber so ein bisschen gegen Windmühlen kämpfen muss.

05:31.380 --> 05:38.100
Also er hat die Führungsetage hinter sich, aber er kämpft gegen die alten Deafleads,

05:38.100 --> 05:40.000
die so ein bisschen der Meinung sind, ach,

05:40.000 --> 05:42.480
Hashtag haben wir vor 25 Jahren nicht müssen, das müssen wir jetzt auch nicht.

05:42.480 --> 05:46.880
Und offiziell ist das Gesetz nicht vorgeschrieben, dann vergisst man das.

05:47.340 --> 05:49.300
Jetzt erzählt er mir auf der letzten Messe, als ich ihn gesehen habe,

05:49.380 --> 05:53.440
oh ja, diese Woche ist wieder eine Person gestorben und drei Leute sind schwer verletzt worden.

05:54.080 --> 05:55.780
Weil einfach ein Sensor nicht funktioniert hat,

05:56.160 --> 05:58.740
dass sie es nicht gescheit getestet hatten, wie soft der da abgestürzt ist,

05:59.100 --> 06:04.440
und der Typ und seine Kollegen von mehreren Tonnen Metallteilen zerquetscht worden sind.

06:05.680 --> 06:09.000
Und die Aussage, ja, letzte Woche war es besser, da ist nur einer gestorben.

06:09.840 --> 06:11.400
Das ist die Aussage, die der hat.

06:12.120 --> 06:15.860
Und das Traurige ist, er ist schon relativ abgestummt.

06:15.860 --> 06:17.320
Seine Deafleads sind noch viel schlimmer.

06:17.960 --> 06:19.240
Die sind wirklich hingestanden und haben gesagt,

06:19.340 --> 06:21.740
naja, testen hat man früher auch nicht müssen,

06:21.840 --> 06:24.540
offiziell müssen wir es nicht, das hat Leute bei Sterben, das passiert.

06:25.420 --> 06:27.660
Das sagen die Leute, die diese Software schreiben,

06:28.160 --> 06:31.020
die in einem Zweifelsfall so dermaßen schief geht und Leute platt macht.

06:31.980 --> 06:34.320
Und von dem her kann mir keiner erzählen, dass Security wichtig ist.

06:35.080 --> 06:37.720
Also wirklich, ihr könnt mir nicht erzählen, dass Security wichtig ist.

06:37.780 --> 06:40.120
Security ist immer nur dann wichtig, wenn es um mich selber geht,

06:40.180 --> 06:41.320
wenn ich selber Geld verlieren kann.

06:41.480 --> 06:42.860
Wenn es um andere geht, scheißegal.

06:43.340 --> 06:47.200
Die sollen schauen, was dann nachher herauskommt, das interessiert mich nicht.

06:48.320 --> 06:50.200
Und das ist eigentlich eine sehr, sehr tragische Situation,

06:50.460 --> 06:53.740
entsprechend habe ich hier auch einige Memes mal rausgezogen,

06:55.040 --> 06:56.800
ich darf auch, wie gesagt, Firma nicht nennen,

06:57.280 --> 06:59.820
aber letztlich auch mit einem C-Level-Person gesprochen,

06:59.820 --> 07:04.340
die mehr oder weniger verantwortlich ist, die sagt, naja, Security-Testing mehr, wäre schon schön,

07:05.280 --> 07:08.120
aber praktisch sehen Sie, wir sind so unter Druck von den chinesischen Herstellern,

07:08.180 --> 07:10.320
wir wollen eigentlich nur neue Features releasen,

07:10.320 --> 07:13.880
und alles, was uns dabei hindert oder in irgendeiner Art und Weise

07:13.880 --> 07:16.220
nicht darauf ausgerichtet ist, machen wir gar nicht.

07:16.460 --> 07:18.100
Brauchen wir gar nicht diskutieren, machen wir nicht.

07:19.400 --> 07:21.940
Wir kommen dann tatsächlich wieder rein über Effizienzgründe,

07:22.080 --> 07:24.820
aber wie das dann zusammenkommt, will ich auch noch später erzählen.

07:26.600 --> 07:28.960
Aber das ist einfach so der traurige Zustand

07:28.960 --> 07:32.140
unserer Programmierindustrie.

07:35.060 --> 07:36.300
Generell ist es so eine Sache,

07:36.920 --> 07:38.180
was für Möglichkeiten gibt es überhaupt?

07:38.180 --> 07:42.760
Um das alles wieder ein bisschen freundlicher, ein bisschen optimistischer zu machen,

07:43.480 --> 07:45.540
was für Möglichkeiten gibt es, Code zu testen?

07:46.560 --> 07:50.720
Eine Sache ist relativ klar, statische Analyse, das hat jeder von uns in der IDI schon gesehen,

07:51.160 --> 07:52.960
das ist immer dann, wenn ein Fehler hochkommt und sagt,

07:53.060 --> 07:56.380
hier, Achtung, du hast da Strich vergessen oder sonst irgendwas.

07:56.820 --> 07:57.600
Das ist sehr, sehr simpel.

07:58.680 --> 08:01.440
Vorteil ist einfach, ich sehe, ich brauche keinen Programmcode ausführen,

08:01.520 --> 08:02.520
ich sehe einfach direkt, was passiert.

08:03.380 --> 08:05.060
Zweite Möglichkeit ist dynamisches Testing.

08:06.000 --> 08:07.480
Gerade wenn ihr jetzt in IT-Security

08:07.480 --> 08:09.000
oder in Tutorien,

08:09.240 --> 08:10.680
wobei das sind sogar die AGs,

08:10.740 --> 08:12.640
freitags glaube ich, drin sitzt,

08:13.120 --> 08:15.020
dann habt ihr es noch benutzt, um Enumeration-Attacks

08:15.020 --> 08:17.200
laufen zu lassen, einfach um rauszufinden,

08:17.300 --> 08:19.160
was irgendwo versteckt ist.

08:19.200 --> 08:21.000
Da gibt es viele Anwendungsmöglichkeiten,

08:21.100 --> 08:23.200
einfach um dynamisch den Code zu testen.

08:24.060 --> 08:24.940
Und dann offensichtlich,

08:25.100 --> 08:26.160
klar, es gibt noch das Pentesting,

08:26.760 --> 08:27.500
das kennt jeder.

08:30.140 --> 08:31.120
Beziehungsweise unterbrecht mich,

08:31.160 --> 08:31.800
wenn das nicht der Fall ist.

08:31.800 --> 08:33.580
Also wenn irgendeiner sagt, Pentesting kennt er nicht,

08:33.580 --> 08:36.820
oder sonst irgendeine Methode, Hand hoch oder gleich reinrufen, kein Problem.

08:38.160 --> 08:39.860
Jeder kennt es? Alles klar, dann machen wir weiter.

08:40.540 --> 08:41.700
Genau, Pentesting.

08:42.180 --> 08:45.340
Das heißt, eine Person kriegt einen Auftrag, die Software zu testen,

08:45.400 --> 08:47.840
dann kriegst du irgendeinen Bericht zurück,

08:48.180 --> 08:51.740
dann kannst du raussuchen, was für Fehler sind drin und wie richte ich die wieder.

08:52.360 --> 08:55.840
Das Problem bei der Sache ist, wir sind jetzt gerade im Kontext von der CICD,

08:56.300 --> 08:57.860
das heißt, wir sind einigermaßen zeitkritisch.

08:58.580 --> 09:02.020
Und wenn ich jetzt hier einen Pentester hinsetze,

09:02.020 --> 09:03.940
der in drei Tagen meine Software testet,

09:04.160 --> 09:07.520
dann könnt ihr euch mal vorstellen, wie lang so ein Zyklus ist von einem Deployment.

09:07.920 --> 09:09.060
Das machen wir also in dem Fall nicht.

09:09.720 --> 09:12.520
Daher ist leider Pentesting in dem Fall nicht die richtige Möglichkeit,

09:12.680 --> 09:14.600
oder einfach keine akzeptable Möglichkeit,

09:14.900 --> 09:18.080
weil sie den ganzen Ansatz mit einem schnellen Deployment schon killt.

09:18.700 --> 09:22.420
Das heißt, wir haben noch Static Analysis und Dynamic Analysis übrig.

09:23.300 --> 09:26.940
Okay, dann schauen wir uns mal an, was ist Static Analysis eigentlich?

09:27.640 --> 09:30.580
Wie gesagt, ich scanne die Grammatik, ich scanne den Code,

09:30.580 --> 09:34.600
ich schaue, habe ich irgendwelche Patterns drin, die verdächtig sind,

09:34.720 --> 09:37.080
die typischerweise zu irgendwelchen Schwachstellen führen können.

09:38.260 --> 09:41.120
Also ich bin hier relativ einfach, relativ schnell unterwegs.

09:41.300 --> 09:44.120
Und vor allem, ich weiß genau, wo eigentlich die Probleme sind.

09:44.200 --> 09:46.460
Weil wenn ich was finde, dann habe ich ja Zugriff zum Source Code,

09:46.580 --> 09:48.200
dann weiß ich ganz genau, an welcher Zeile das ist.

09:48.540 --> 09:51.060
Also kann ich genau sehen, wo muss ich hier ansetzen.

09:51.260 --> 09:55.200
Und deswegen gilt ganz einfach, also Static Analysis ist easy to set up,

09:55.760 --> 09:57.540
es ist ganz einfach, die Fehler danach zu finden.

09:58.120 --> 09:59.520
ich habe relativ schnelle Ergebnisse,

09:59.620 --> 10:01.240
weil das Zeug läuft die ganze Zeit nebenher,

10:01.780 --> 10:04.780
und ich habe dann nachher auch die Insights in den Programmcode

10:04.780 --> 10:06.520
und sehe genau, wo ist denn eigentlich das Problem.

10:07.320 --> 10:09.940
Dafür ist ein Nachteil offensichtlich, ich habe keine Runtime-Malage.

10:10.600 --> 10:13.060
Das heißt, wenn irgendwelche Deadlocks auftreten,

10:13.160 --> 10:15.920
oder wenn irgendwelche Konfigurationssachen über Code gelöst sind,

10:17.300 --> 10:19.320
dann komme ich da einfach mit Statische Analyse nicht drauf.

10:19.380 --> 10:20.840
Ich habe keine Möglichkeit, darauf zu kommen,

10:21.060 --> 10:22.400
wenn mir einfach dieser Kontext fehlt.

10:23.340 --> 10:26.600
Und dann natürlich, ich habe eine erhöhte Chance auf False Positives,

10:26.600 --> 10:31.680
Wenn ich zum Beispiel, ich habe im Stephan-Quatsch, glaube ich,

10:31.740 --> 10:35.840
ach genau, bei der Abschiedsfeier von Walter oben,

10:36.380 --> 10:41.360
hatten wir es tatsächlich ganz kurz von komplexen Programmen,

10:41.440 --> 10:45.080
die unter anderem eigene SQL-Querys dynamisch erstellen müssen.

10:45.540 --> 10:49.840
Die ich dann vorher eben alle nicht über Prepared Statements setzen kann,

10:49.880 --> 10:51.040
sondern die wirklich dynamisch bauen muss.

10:51.620 --> 10:54.780
Jetzt gibt es die Möglichkeit natürlich, alles unsanitized zu machen,

10:55.120 --> 10:58.800
schlechte Idee, oder aber ich schicke das vorher immer in die Datenbank

10:58.800 --> 11:00.340
und baue so ein halbes Prepared Statement,

11:00.380 --> 11:03.980
also ich sanitize das auf eine andere Art und Weise, ohne Prepared Statement.

11:04.720 --> 11:07.520
Je nachdem, in welcher Funktion ich das mache, in welcher Reihe folge ich das mache,

11:07.580 --> 11:09.800
wird aber ein statischer Scanner immer anschlagen,

11:09.880 --> 11:13.860
weil er sagt, hier im Zweifelsfall, allein dieses Query in die Datenbank

11:13.860 --> 11:16.620
ist halt unsanitized, es ist kein Prepared Statement,

11:17.200 --> 11:18.520
das schlägt schief.

11:18.520 --> 11:21.500
Selbst wenn ich jede Möglichkeit darauf zuzugreifen,

11:21.580 --> 11:24.580
irgendwie sanitized hätte, wird der statische Scanner hier immer anschlagen.

11:24.580 --> 11:28.720
Und das ist einfach das Problem, ich habe hier dadurch einfach eine erhöhte False-Positive-Rate,

11:29.120 --> 11:30.200
wenn mir einfach der Kontext fehlt.

11:31.000 --> 11:33.000
Und klar, natürlich Language-Dependent.

11:33.120 --> 11:37.200
Ich muss für jede neue Sprache, muss ich einen neuen statischen Scanner schreiben,

11:37.640 --> 11:40.300
das ist einfach Standard in dem Sinne.

11:41.440 --> 11:43.580
Gut, dann haben wir als nächstes das dynamische Testen.

11:45.620 --> 11:50.580
Relativ eindeutig, praktisch gesehen ist es, ich generiere über Listen oder über zufällige Inputs,

11:50.580 --> 11:52.140
Inputs, irgendwelche

11:52.140 --> 11:54.620
Inputs, die ich auf ein Programm

11:54.620 --> 11:56.140
schmeiße und dann schaue ich, was passiert.

11:56.620 --> 11:58.340
Das Ding ist, ich habe keinen direkten Insight,

11:58.560 --> 12:00.080
sondern ich kann von außen

12:00.080 --> 12:02.240
betrachten, sehe ich stürzt es ab, habe ich

12:02.240 --> 12:04.360
irgendwelche Nebeneffekte, was passiert hier eigentlich.

12:04.440 --> 12:05.680
Aber ich kann es immer nur von außen sehen.

12:06.000 --> 12:08.340
Ich sehe nicht, was innerhalb des Programms

12:08.340 --> 12:08.920
eigentlich passiert.

12:09.960 --> 12:12.300
Also ich habe keine Insights hier, ich kann nur

12:12.300 --> 12:13.180
von außen anschauen.

12:14.160 --> 12:15.480
Vorteil ist, ich habe Runtime-Knowledge.

12:16.520 --> 12:18.140
Also wenn ich hier keine SQL-Injection-Schwachstelle

12:18.140 --> 12:20.120
triggern kann und

12:20.120 --> 12:22.080
alle Möglichkeiten abgedeckt hätte, die eben

12:22.080 --> 12:24.240
eine SQL-Injection-Schwachstelle checkern könnten,

12:24.560 --> 12:26.240
kann ich davon ausgehen, da habe ich auch nachher nichts drin.

12:27.160 --> 12:27.820
Genau, hoppala.

12:28.900 --> 12:29.840
Das machen wir kurz weg.

12:31.960 --> 12:33.420
So, genau.

12:35.420 --> 12:36.140
Genau, damit

12:36.140 --> 12:37.720
habe ich einfach keine False Positives

12:37.720 --> 12:39.640
und ich bin unerheblich von der Sprache.

12:39.960 --> 12:41.500
Was mich eigentlich nur interessiert, ist das Interface.

12:42.500 --> 12:43.920
Habe ich eine Restschnittstelle, habe ich sonst

12:43.920 --> 12:45.820
irgendwas, wie muss ich diesem Programm Daten checken?

12:45.900 --> 12:48.080
Das ist das, was wichtig ist, alles andere interessiert

12:48.080 --> 12:50.000
mich nicht. Nachteil ist,

12:50.120 --> 12:51.660
ich bin relativ komplex im Setup,

12:52.100 --> 12:53.880
das heißt, ich muss meinen Programme-Erschleuder deployen,

12:53.940 --> 12:56.120
ich muss alles, was dahinter hängt, auch noch mitdeployen.

12:56.820 --> 12:57.900
Ich muss es nachher warten,

12:58.000 --> 12:59.480
ich muss es alles auf die neueste Version bringen.

12:59.940 --> 13:01.480
Ich habe hier einfach einen erheblichen Aufwand,

13:01.520 --> 13:02.780
das alles auf dem Laufen zu bekommen.

13:03.540 --> 13:05.120
Und dann, wenn ich irgendein Finding habe,

13:05.700 --> 13:07.180
dann habe ich eine relativ anstrengende Zeit,

13:07.200 --> 13:09.060
herauszufinden, woher das Problem eigentlich kommt.

13:09.980 --> 13:12.240
Im Zweifelsfall habe ich irgendwo irgendwas vergessen

13:12.240 --> 13:15.900
und dann darf ich den gesamten Code durchsuchen,

13:15.900 --> 13:17.000
was, wo, wie passiert.

13:17.880 --> 13:21.720
Aber ich habe in Zweifelsfall richtig gelitten, da Fehler zu suchen.

13:22.800 --> 13:24.520
Und dann, naja, ich bin langsamer.

13:24.720 --> 13:26.560
Ich bin deutlich langsamer als ein statisches Scanning.

13:27.460 --> 13:29.500
Wenn ich einfach das erstmal hinschicken muss,

13:29.980 --> 13:31.420
das erstmal alles deployen muss,

13:31.480 --> 13:33.680
dann muss ich den Test oder den Fasser laufen lassen.

13:34.560 --> 13:36.160
Dann habe ich in Zweifelsfall noch Probleme,

13:36.240 --> 13:37.420
weil ich aufs Netzwerk drauf muss.

13:37.520 --> 13:41.060
Also ich bin um Faktoren langsamer als ein statisches Scanning.

13:41.660 --> 13:43.380
Und wie gesagt, ich habe keine Ahnung,

13:43.460 --> 13:44.780
was ich da eigentlich genau getestet habe.

13:45.280 --> 13:47.040
Das heißt, ich kann mich irgendwo drauf eingeschossen haben

13:47.040 --> 13:48.980
auf 10%, wenn die 100% getestet haben

13:48.980 --> 13:50.840
mit allen Varianten, aber die restlichen

13:50.840 --> 13:52.300
90% sind halt auch einfach übrig.

13:52.740 --> 13:54.200
Da habe ich keine Ahnung, was da eigentlich drin steckt.

13:54.260 --> 13:56.340
Und ich kann nicht mal beurteilen, wie viel das eigentlich ist.

13:57.020 --> 13:57.960
Also ich weiß eigentlich nur,

13:58.420 --> 14:00.760
naja, ich habe gerade Zeit reingesteckt, es ist nichts rausgefallen,

14:01.300 --> 14:02.080
wird schon gut gehen.

14:02.620 --> 14:04.960
Das ist Blackbox-Testing.

14:06.060 --> 14:06.280
Also,

14:07.560 --> 14:08.240
nicht ideal.

14:11.060 --> 14:12.160
Das ist unsere Situation.

14:12.400 --> 14:14.700
Wir haben entweder das eine, wo wir genau wissen,

14:14.780 --> 14:17.480
was passiert, aber keine Ahnung haben, was jetzt in echt passiert,

14:17.580 --> 14:19.400
sondern wir nehmen nur Annahmen basierend auf dem Code,

14:19.780 --> 14:22.600
oder das andere, dass wir sagen, okay, wir testen, was jetzt wirklich passiert,

14:22.700 --> 14:24.600
aber wir haben keine Ahnung, wie weit wir da eigentlich sind,

14:24.660 --> 14:25.780
was wir alles abgedeckt haben.

14:26.240 --> 14:27.920
Eine ganz schön blöde Situation,

14:28.820 --> 14:30.840
weil wir praktisch sehen, mit beiden Möglichkeiten

14:30.840 --> 14:35.020
keine Aussage über die Sicherheit von unserem Programmcode testen können.

14:35.140 --> 14:38.040
Wir haben einfach keine Ahnung, was danach eigentlich passiert,

14:38.120 --> 14:39.160
wenn ich es wirklich deploye.

14:40.080 --> 14:41.980
So, das ist das Problem.

14:42.260 --> 14:43.600
Zum Glück gibt es da zwei Möglichkeiten,

14:44.200 --> 14:45.420
IAST und Whitebox Fuzzing.

14:46.680 --> 14:50.040
So, IAST, Interactive Application Security Testing,

14:50.040 --> 14:53.960
also SAST, Static Application Security Testing,

14:54.540 --> 14:56.700
DAST wäre Dynamic Application Security Testing,

14:56.800 --> 14:59.940
jetzt gibt es noch IAST, Interactive Application Security Testing.

15:00.720 --> 15:02.160
Das ist der Ansatz, in dem ich versuche,

15:02.220 --> 15:04.860
also ich komme vom Statischen und versuche noch ein bisschen

15:04.860 --> 15:07.660
Runtime-Informationen dazu zu bringen.

15:08.480 --> 15:10.880
Also, stellt euch das vor, ihr habt,

15:10.880 --> 15:13.180
also ich habe einen anderen

15:13.180 --> 15:15.140
Bytecode-Interpreter,

15:15.440 --> 15:17.060
der dann kontrolliert, was passiert

15:17.060 --> 15:19.320
im statischen Umfeld, auf was für Funktionen

15:19.320 --> 15:21.360
greife ich eigentlich zu und aber auch

15:21.360 --> 15:23.420
sehen kann, hier, da ist gerade eine Exception

15:23.420 --> 15:25.180
geflogen, die war nicht gut oder ich bin jetzt

15:25.180 --> 15:26.280
gerade irgendwie doch in ein

15:26.280 --> 15:28.780
SQL-Injection-Vulnerability-typisches

15:28.780 --> 15:30.860
Fall reingeschlittert.

15:31.200 --> 15:33.680
Also ich habe hier einfach die Möglichkeiten,

15:33.900 --> 15:34.760
aus dem Statischen

15:34.760 --> 15:37.540
noch diese Runtime-Informationen obendrauf zu klatschen.

15:38.280 --> 15:39.260
Das ist der Ansatz hier.

15:39.860 --> 15:41.920
Das andere ist Whitebox und Smart Fuzzing,

15:42.020 --> 15:43.980
das ist darüber, wo der Rest vom Vortrag gehen wird.

15:45.320 --> 15:48.320
Das ist eben die Aussage, ich habe diesen Blackbox-Fuzzing-Approach,

15:48.360 --> 15:49.780
wo ich random Daten generiere,

15:50.220 --> 15:52.160
und ich gebe dem jetzt noch Zugriff auf den Source-Code,

15:52.880 --> 15:55.480
und eben auch während der Instrumentierung,

15:55.480 --> 15:58.760
und kann damit dann auch genauer sagen, was treffe ich eigentlich, was treffe ich nicht,

15:59.320 --> 16:01.420
wie verhält sich das, was für Checks werden gemacht.

16:01.840 --> 16:04.220
Wie gesagt, wir haben jetzt einfach die Situation,

16:04.420 --> 16:07.740
dass wir von beiden Extremen eine Möglichkeit gesucht haben,

16:07.820 --> 16:09.180
eigentlich zur Mitte zu kommen.

16:09.260 --> 16:11.300
und einen guten Ansatz zu finden.

16:12.380 --> 16:14.820
Beide haben auch relativ ähnliche Eigenschaften tatsächlich.

16:15.260 --> 16:17.120
Also sie sind einigermaßen einfach zum Setup,

16:17.520 --> 16:20.780
weil auch ein Whitebox-Fasser im Zweifelsfall nicht mehr alles deployen muss,

16:20.860 --> 16:22.680
sondern auf Unit-Test-Ebene auch Arbeit.

16:23.080 --> 16:26.520
Ich habe relativ, also ich habe low effort, die Findings zu finden,

16:26.800 --> 16:28.380
weil ich genau weiß, wo sind sie eigentlich.

16:29.480 --> 16:32.760
Ich habe Runtime-Knowledge und ich habe relativ schnell meine Ergebnisse.

16:33.660 --> 16:34.860
Einfach, ich muss nie über das Netzwerk,

16:34.860 --> 16:36.660
im Idealfall muss ich nicht über das Netzwerk,

16:36.980 --> 16:38.800
sondern ich laufe in der Applikation selber,

16:39.260 --> 16:41.380
und bin dann einfach sehr viel schneller unterwegs.

16:42.040 --> 16:44.120
Die Nachteile sind so ein bisschen unterschiedlich,

16:44.200 --> 16:47.380
da muss man sich immer so raussuchen, was möchte man eigentlich gerade erreichen,

16:47.960 --> 16:50.880
um eine Entscheidung zu treffen, welche Möglichkeit oder welche Lösung

16:50.880 --> 16:52.220
jetzt eigentlich das richtige Verein ist.

16:52.880 --> 16:56.980
Die ersten Sachen laufen hauptsächlich auf interpretierten Sprachen

16:56.980 --> 16:58.520
oder auf Sprach-mit-Byte-Code.

16:59.100 --> 17:01.680
Also wie gesagt, ich habe eine Spracherhängigkeit, klar,

17:02.200 --> 17:06.580
aber die ändern einfach die Ausführdatei,

17:06.580 --> 17:08.160
bzw. die Art und Weise, wie ausgeführt wird.

17:09.120 --> 17:10.300
Das ist gut,

17:10.780 --> 17:12.500
wenn ich eben im Zweifelsfall in der Production

17:12.500 --> 17:14.520
kontrollieren kann, ob irgendeiner

17:14.520 --> 17:15.900
gerade eine Schwachstelle ausnutzt.

17:16.180 --> 17:17.980
Und im Zweifelsfall die ganze Applikation killen kann

17:17.980 --> 17:19.140
und sagen kann, der kommt nicht mehr ran.

17:19.760 --> 17:20.480
Also ich habe hier

17:20.480 --> 17:24.260
in Serverumfelden, im Productive-Bereich

17:24.260 --> 17:25.420
vielleicht einen Vorteil,

17:26.080 --> 17:27.840
Nachteil ist ganz ehrlich, aber gerade aus dem

17:27.840 --> 17:30.180
Automotive Security-Bereich ist relativ eindeutig,

17:30.540 --> 17:32.140
die müssen alle Tools, die nachher

17:32.140 --> 17:34.280
einen Effekt auf ihr Produkt

17:34.280 --> 17:35.460
haben, auf ihr Programm haben,

17:35.940 --> 17:37.040
zertifizieren lassen.

17:37.840 --> 17:39.080
Und das ist eine relativ große Hürde.

17:39.840 --> 17:41.260
Und entsprechend wollen die nichts haben,

17:41.600 --> 17:44.800
was in irgendeiner Art und Weise später dann das Ergebnis verändert.

17:44.800 --> 17:50.480
Also das Binary dann verändert, das sie nachher irgendwie deployen.

17:51.340 --> 17:54.080
Auf der anderen Seite haben wir Whitebox und Smart Fuzzing.

17:54.700 --> 17:58.180
Nachteil da ist, ihr müsst Entry Points selber schreiben,

17:58.280 --> 18:00.960
also eine Art Unit Test selber schreiben, das zeige ich euch gleich noch.

18:01.360 --> 18:02.380
Und es braucht Rechenleistung,

18:02.620 --> 18:05.360
weil ihr eben die ganzen unterschiedlichen Inputs selber generieren wollt.

18:05.780 --> 18:07.800
Das heißt, es ist blöd, wenn ihr das alles auf dem Laptop macht,

18:07.880 --> 18:09.600
sondern ihr wollt irgendwo eine Lösung haben,

18:10.060 --> 18:12.880
wo ihr das hindeployen könnt, was ihr entsprechend testet,

18:13.220 --> 18:14.840
was euch das Ergebnis zurückliefert.

18:15.100 --> 18:16.760
Das ist so der ideale Aufbau hier.

18:17.920 --> 18:21.380
Dafür habt ihr aber im Production-Betrieb kein Monitoring,

18:21.820 --> 18:23.700
aber auch keine Veränderungen im Binary.

18:24.880 --> 18:26.840
Also, wie gesagt, Vor- und Nachteile.

18:27.880 --> 18:30.240
Wie gesagt, ich fokussiere mich auf Whitebox-Fassung,

18:30.340 --> 18:31.140
naja, das ist mein Job.

18:31.140 --> 18:35.260
und entsprechend gehen wir da ganz kurz weiter.

18:35.380 --> 18:37.920
Das ist hier so ein, also ihr merkt, das hier ist ein Marketing-Slide,

18:38.000 --> 18:41.120
ich habe einfach nicht die Zeit gehabt, die ganzen Slides von Hand selber zu machen.

18:41.620 --> 18:44.220
Ich hoffe, ihr seht mir das nach, wichtig sind die zwei Bilder unten.

18:45.000 --> 18:47.520
Black-Box-Fuzzing, ich beschreibe es immer so ein bisschen,

18:47.660 --> 18:51.480
das ist eigentlich, wie als hätte ich einen langen Stock und eine sehr, sehr dreckige Pfütze.

18:52.020 --> 18:53.780
Und jetzt muss ich da drin nach irgendwelchen Dingen suchen.

18:54.720 --> 18:56.060
Wenn ich Glück habe, finde ich die Sachen.

18:56.400 --> 18:58.380
Ich habe aber keine Ahnung, was ich gerade eigentlich getestet habe

18:58.380 --> 19:00.920
und ich habe keine Ahnung, wo ich das Zeug gerade eigentlich gefunden habe.

19:01.140 --> 19:03.500
Ich weiß bloß, irgendwann ist was angeschlagen.

19:04.240 --> 19:06.100
Auf der anderen Seite habe ich Whitebox-Fuzzing,

19:06.840 --> 19:09.860
da brauche ich zugehörigen Source-Code, instrumentiere dann entsprechend,

19:10.020 --> 19:13.640
habe also Flex drin im Binary und sehe dann genau,

19:13.920 --> 19:16.040
welche Eingabe hat welche Zeile getriggert,

19:16.420 --> 19:17.940
was für Checks sind da vorher passiert,

19:18.820 --> 19:20.960
warum habe ich vielleicht einen Branch erwischt

19:20.960 --> 19:22.380
und warum habe ich einen Branch nicht erwischt.

19:22.820 --> 19:23.720
Da oben ist gerade eine Frage.

19:31.140 --> 19:38.140
Also was dann Hacker machen, ist quasi wie Blackbox-Testing dann, oder?

19:38.740 --> 19:39.520
Standardmäßig ja.

19:40.040 --> 19:43.420
Es gibt noch so einen netten, so ein bisschen illegalen Workaround.

19:43.720 --> 19:46.000
Du kannst natürlich die Sachen reverse-compilen.

19:46.280 --> 19:48.060
Also wenn du ein Programm hast, ein wirkliches Programm hast,

19:48.360 --> 19:50.860
kannst du versuchen, es reverse-zu-engineeren, dass du einen Source-Code hast.

19:51.220 --> 19:54.320
Dann kannst du versuchen, einen Whitebox-Fuzzing-Approach einzubauen

19:54.320 --> 19:57.340
und es dann wieder zu kompilieren und dann zu schauen, was steckt eigentlich drin.

19:57.740 --> 20:00.020
Das Problem ist bloß, dann steckst du relativ viel Energie rein

20:00.020 --> 20:04.120
und du brauchst Zugriff auf die Datei, die du dann reverse-engineerst.

20:04.260 --> 20:06.620
Aber prinzipiell würde das funktionieren.

20:07.520 --> 20:09.940
Aber standardmäßig ist ein Blackbox-Fuzzing-Approach, da hast du recht.

20:10.440 --> 20:11.140
Okay, danke.

20:11.980 --> 20:14.140
Oh, die Frage hätte ich ganz kurz noch wiederholen müssen, oder?

20:16.900 --> 20:18.480
Der kennt sich aus? Okay, perfekt.

20:18.820 --> 20:20.640
Tobi, du schreist kurz rein, wenn das nicht der Fall ist.

20:21.320 --> 20:22.780
Ich hoffe, wir würden dich hören, oder?

20:24.220 --> 20:25.360
Ich denke schon, ja.

20:26.200 --> 20:28.040
Perfekt, alles klar. Danke.

20:30.020 --> 20:34.600
Genau, also wie gesagt, ich habe andere Anforderungen, ich brauche ganz wenig den Source Code,

20:34.960 --> 20:37.780
dafür sehe ich aber genau, was passiert und bin sehr viel effizienter.

20:39.220 --> 20:42.280
Ihr seht auch später, warum das Sinn macht, also ich habe ein paar Beispiele vorbereitet,

20:42.340 --> 20:46.100
um euch mal zu zeigen, was so typische Schwachstellen von Blackbox-Fasser werden,

20:46.240 --> 20:50.560
wo ein Whitebox-Fasser ziemlich mühelos reinspaziert und die Sachen eben findet.

20:52.180 --> 20:57.060
Genau, ganz kurz, das ist jetzt so ein Beispiel, wie so ein Whitebox-Fasser funktionieren kann.

20:57.060 --> 20:59.600
Wir instrumentieren hier einen Image-Parser.

21:00.060 --> 21:01.040
Warum einen Image-Parser?

21:01.500 --> 21:03.720
Ganz einfach, ein Image hat eine relativ spezielle Struktur,

21:04.200 --> 21:05.980
das heißt, ich brauche relativ viel Insider-Wissen,

21:06.160 --> 21:10.420
um überhaupt sinnvolle Ergebnisse generieren zu können.

21:11.320 --> 21:11.520
Okay?

21:12.900 --> 21:13.520
Ja, Frage?

21:15.780 --> 21:17.720
Was verstehst du hier unter Image?

21:18.420 --> 21:18.740
Image?

21:19.240 --> 21:21.100
Ja, also Image als Bild, oder?

21:21.340 --> 21:21.600
Genau.

21:21.800 --> 21:22.060
Okay.

21:22.760 --> 21:22.900
Genau.

21:23.400 --> 21:24.080
Ja, sorry.

21:24.080 --> 21:26.200
Also ein Bild-Parser.

21:27.060 --> 21:35.560
Genau. Also wie gesagt, wir haben Bildparser gewählt, weil wir eben hier ganz spezielle Informationen brauchen,

21:35.680 --> 21:38.740
um sinnvolle Ergebnisse nachher generieren zu können.

21:39.480 --> 21:40.580
Jetzt wissen wir am Anfang noch gar nichts.

21:40.800 --> 21:45.040
Also wir haben diesen Imageparser jetzt instrumentiert, wir haben unsere Flex drin, mehr wissen wir noch nicht.

21:45.520 --> 21:48.340
Das heißt, wir fangen am Anfang einfach an mit der Null und schauen mal, was passiert.

21:48.900 --> 21:51.360
Null in dem Fall ist ganz einfach ein ungültiges Image.

21:51.360 --> 21:55.100
das heißt, ich schmeiße mal ein ungültiges Image rein

21:55.100 --> 21:56.960
dann schaue ich mal, was passiert

21:56.960 --> 21:58.100
und nachher passiert genau das

21:58.100 --> 22:01.060
ich habe dann hier eben, dass ich kann sehen

22:01.060 --> 22:02.680
was für Zeilen ich erreicht habe

22:02.680 --> 22:04.860
in dem Fall ganz einfach, es sind zweimal

22:04.860 --> 22:07.440
Checks gelaufen, ob ich mit bestimmten

22:07.440 --> 22:08.780
Zeichen anfange

22:08.780 --> 22:11.520
im zweiten Mal mit FFD8

22:11.520 --> 22:13.060
ich habe beide Male

22:13.060 --> 22:14.360
diesen Check nicht bestanden

22:14.360 --> 22:16.620
und damit kommt zurück eben Image Formats Unknown

22:16.620 --> 22:19.160
und ich habe eben zwei Zeilen

22:19.160 --> 22:19.800
nicht erreicht

22:20.220 --> 22:21.860
Dieses return formats.gif

22:21.860 --> 22:23.160
und .jpg.

22:23.940 --> 22:25.840
Ich habe zwei Zeilen, die ich nicht erreicht habe.

22:26.620 --> 22:27.700
Diese Informationen

22:27.700 --> 22:28.800
gehen zurück an den Fasser

22:28.800 --> 22:31.420
und er weiß jetzt bei der zweiten Iteration schon,

22:31.500 --> 22:32.900
hey, ich habe einen Check nicht bestanden,

22:33.280 --> 22:35.620
ich muss mit FFD8 beginnen, dann funktioniert das wieder.

22:36.240 --> 22:36.700
Alles klar.

22:37.140 --> 22:39.100
Dann schmeißt er als nächstes eine FFD8 rein,

22:40.520 --> 22:41.920
dann komme ich an die nächste Zeile ran

22:41.920 --> 22:45.020
und habe damit auch schon ein gültiges Bild.

22:46.420 --> 22:47.260
Und das ist eben das Schöne.

22:47.480 --> 22:48.960
Ich habe in der zweiten Iteration

22:48.960 --> 22:51.700
schon festgestellt, wie die valide Eingabe aussieht.

22:52.660 --> 22:54.000
Im Blackbox-Fasser hat sich im Zweifelsfall

22:54.000 --> 22:55.340
da stundenlang die Zähne ausgebissen.

22:55.820 --> 22:57.900
Und keine Ahnung gehabt, was da eigentlich funktioniert,

22:57.980 --> 22:58.680
was nicht funktioniert.

22:58.960 --> 23:00.960
Wir haben in der zweiten Iteration schon herausgefunden,

23:01.040 --> 23:01.640
wie wir da rein müssen.

23:02.660 --> 23:04.940
Und damit können wir eine ganze Menge valider Bilder auch erzeugen.

23:05.120 --> 23:07.620
Grün, blau, rot oder irgendwas.

23:08.460 --> 23:09.260
Es funktioniert einfach.

23:09.360 --> 23:11.460
Ich weiß einfach, was für Checks werden hier gemacht

23:11.460 --> 23:12.060
und dann kann ich

23:12.060 --> 23:15.380
alle Pfade innerhalb dieses,

23:15.500 --> 23:16.920
also unterhalb dieser Guard

23:16.920 --> 23:18.080
ausprobieren.

23:18.960 --> 23:20.640
Also in dem Fall sind wir sehr, sehr effizient.

23:24.600 --> 23:30.940
Ganz kurz, ich habe vorher erzählt, wir müssen als Nachteil in irgendeiner Art und Weise einen Entry Point generieren.

23:31.540 --> 23:35.780
Also ich muss in irgendeiner Art und Weise den Faser an einer Stelle loslaufen lassen.

23:36.560 --> 23:40.180
Und was wir hier eben gemacht haben, ist, dass wir uns integriert haben in die nativen Test-Frameworks.

23:40.620 --> 23:47.000
Das heißt Java, JUnit, JavaScript, Jest, C, C++ ist das Google-Test-Framework

23:47.000 --> 23:49.460
und jeder, der in der Lage ist, damit nochmal

23:49.460 --> 23:51.860
einen Unitest zu schreiben, kann auch so einen Fasttest schreiben.

23:51.980 --> 23:53.620
Das ist super einfach. Also wirklich,

23:53.720 --> 23:55.820
ich habe immer noch die Wette offen, dass jeder dritte Semester

23:55.820 --> 23:57.880
das Problem lösen kann. Tobias, wenn bei dir

23:57.880 --> 23:59.820
einer im Semester drin sitzt, ein Projekt macht

23:59.820 --> 24:01.760
und sowas dann nicht hinbekommt,

24:02.240 --> 24:03.460
würde ich mir einfach Fragen stellen.

24:05.720 --> 24:07.080
Genau, und was ihr hier seht,

24:07.160 --> 24:09.620
gleich mal so ein Unitest, also ich habe hier wieder

24:09.620 --> 24:11.580
einen Encoder und einen Decoder.

24:12.740 --> 24:14.160
Die Idee ist, ich encode

24:14.160 --> 24:15.700
und decode es wieder und dann

24:15.700 --> 24:17.160
kontrolliere ich, dass nachher das Gleiche rauskommt.

24:18.060 --> 24:21.060
Und beim Unit-Test habe ich dann eben relativ viele Möglichkeiten,

24:21.340 --> 24:23.380
also ich kontrolliere einen mit Foo und einmal Bar,

24:24.020 --> 24:28.320
und im Zweifelsfall müsste ich das ja mit jedem interessanten Edge-Case von Hand schreiben.

24:29.020 --> 24:32.560
Relativ aufwendig, relativ nervig, ich habe keinen Bock drauf, sage ich ganz ehrlich.

24:32.780 --> 24:34.160
Also mit sowas kannst du mich jagen.

24:35.280 --> 24:37.580
Wie funktioniert ein Fast-Test im Gegensatz dazu?

24:38.200 --> 24:38.820
Na ganz einfach.

24:39.620 --> 24:44.320
Wie gesagt, gleiche Annotation, bloß ich teste oder ende einmal Add-Test zu Add-Fast-Test

24:44.320 --> 24:46.580
und ich gebe dann eben einen Input rein,

24:47.520 --> 24:48.440
in dem Fall einen String,

24:49.400 --> 24:51.100
und dann encode ich das und decode ich das

24:51.100 --> 24:53.620
und kontrolliere, dass das Ergebnis nachher das gleiche ist.

24:54.340 --> 24:54.860
Super einfach.

24:55.380 --> 24:58.220
Und der testet das jetzt mit über 10.000 Executions pro Sekunde

24:58.220 --> 24:59.220
auf meinem Laptop.

24:59.520 --> 25:01.080
Ihr könnt euch vorstellen, was ein Server damit macht.

25:02.200 --> 25:03.600
Und damit kommt es sehr, sehr viel weiter

25:03.600 --> 25:05.200
als mit einem normalen Unit-Test.

25:06.340 --> 25:08.040
Und oben rein findet er auch noch die ganzen Sachen,

25:08.140 --> 25:10.180
die im Zweifelsfall einen Rechner nicht zum Absturz bringen,

25:10.280 --> 25:11.760
beziehungsweise den Test nicht zum Failen bringen.

25:12.760 --> 25:14.280
Also in dem Fall sind wir einfach einen riesen Schritt weiter.

25:14.320 --> 25:16.160
gekommen. Kleiner Hinweis, sagt

25:16.160 --> 25:17.760
jemand von euch Property-Based Testing was?

25:19.460 --> 25:19.700
Nein?

25:20.600 --> 25:22.100
Okay. Normales Unit Testing

25:22.100 --> 25:24.060
hat eine sehr spezifische Eingabe

25:24.060 --> 25:25.720
und eine sehr spezifische Ausgabe.

25:25.860 --> 25:28.380
Und da wird kontrolliert, dass genau das rauskommt.

25:28.920 --> 25:29.840
Also in dem Fall, ich schmeiße

25:29.840 --> 25:31.400
Foo bar und nachher,

25:32.100 --> 25:33.980
also Foo rein, und dann habe ich nachher

25:33.980 --> 25:36.400
ganz konkret, was rauskommt

25:36.400 --> 25:38.040
und ich kontrolliere, dass es dann

25:38.040 --> 25:39.640
auch wieder, also im ersten Fall

25:39.640 --> 25:41.660
hier unten, das erste ist Foo

25:41.660 --> 25:43.700
und das zweite muss decoded auch wieder

25:43.700 --> 25:45.720
Foo sein. Ganz, ganz, ganz konkret.

25:46.480 --> 25:47.580
Bei Property-Based Testing

25:47.580 --> 25:49.320
ist es mir egal, was ich reinschmeiße.

25:49.900 --> 25:51.780
Ich definiere einfach nur den Zusammenhang

25:51.780 --> 25:53.520
zwischen Eingabe und Ausgabe.

25:54.600 --> 25:55.180
Anderes Beispiel.

25:55.620 --> 25:57.080
Wir haben eine Funktion plus 2.

25:58.000 --> 25:59.820
Und jetzt kann ich beim Unit-Test

25:59.820 --> 26:02.060
schmeißen ich eine 2 rein und kontrolliere, dass eine 4 rauskommt.

26:02.780 --> 26:03.980
Bei einem Property-Based Test

26:03.980 --> 26:05.980
schmeiße ich irgendwas rein und kontrolliere

26:05.980 --> 26:08.120
nachher, dass irgendwas plus 2 rauskommt.

26:09.080 --> 26:09.760
Genau das ist das.

26:10.580 --> 26:12.240
Bloß eben, also ich nenne es

26:12.240 --> 26:13.780
Property-Based Testing Plus,

26:14.400 --> 26:16.060
weil wir eben geguided sind

26:16.060 --> 26:18.580
und nicht random irgendwelche Eingaben testen.

26:20.580 --> 26:22.440
Genau, aber wie gesagt, so simpel.

26:24.580 --> 26:26.300
Okay, ich glaube,

26:26.520 --> 26:27.980
jetzt sind wir mit den einfachen Sachen durch.

26:28.060 --> 26:30.020
Ich würde euch ganz gerne noch kurz eine Demo zeigen,

26:30.440 --> 26:31.580
wie sowas dann auch richtig aussieht,

26:31.580 --> 26:33.460
weil Folien sind immer einfach.

26:34.040 --> 26:36.020
Folien ist leicht, da kann ich irgendeinen Scheiß draufschreiben.

26:37.400 --> 26:39.100
Ich zeige euch mal, wie das dann wirklich funktioniert.

26:39.100 --> 26:43.380
das ist jetzt hier so ein Beispielprojekt

26:43.380 --> 26:45.900
das vermutlich noch relativ klein ist

26:45.900 --> 26:49.140
besser?

26:49.820 --> 26:51.240
also ihr müsst mir sagen, ob ihr das genügend seht

26:51.240 --> 26:52.740
weil bei mir spiegelt das gerade so nicht

26:52.740 --> 26:59.440
ok, wenn ihr mir sagt, wo ich das mache, kein Problem

26:59.440 --> 27:02.980
Shift-Shift-7

27:09.100 --> 27:36.340
Ach, das sind Tests, dann gehen wir mal in die Funktion selber rein.

27:36.340 --> 27:41.220
Okay, das ist ein ganz einfacher Endpoint.

27:41.900 --> 27:43.600
Der macht nichts anderes, als dass er irgendwie

27:43.600 --> 27:46.560
einem String entgegennimmt und wenn dieser String

27:46.560 --> 27:48.540
eben Attacker entspricht, dann speichert es eine Exception,

27:48.660 --> 27:49.880
die ich nachher später auffangen kann.

27:50.240 --> 27:52.320
In dem Fall habe ich es mir einfach gemacht,

27:52.420 --> 27:54.140
ich habe einfach eine Exception genommen,

27:54.320 --> 27:56.140
in der ich ganz genau weiß, dass er Fasersau aufnimmt,

27:56.300 --> 27:58.540
als kritisch, weil ich es eben als Demo-Zweck

27:58.540 --> 27:59.980
mit dieser Art von Exception immer abfange.

28:00.700 --> 28:02.580
Das funktioniert aber mit jeder anderen Exception auch.

28:02.580 --> 28:04.100
Ich habe nachher auch andere Beispiele drin,

28:04.420 --> 28:06.120
die es eben mit anderen Exceptions genauso machen.

28:06.340 --> 28:11.240
aber einfach, dass ihr seht, das ist so die Situation, wenn ich eben Attacker loslaufen lasse,

28:11.320 --> 28:13.600
dann kriege ich nachher eine Fehlermeldung.

28:14.320 --> 28:15.680
So, wie teste ich das?

28:16.280 --> 28:19.360
Eben ganz einfach, ich habe hier nachher lauter Tests geschrieben.

28:28.120 --> 28:30.160
Da hätte ich mir mal Zeit nehmen müssen, um das vorbereiten.

28:30.240 --> 28:31.160
Ach genau, nehmen wir den da.

28:31.620 --> 28:33.580
So, das hier unten ist der Fasstest dazu.

28:33.580 --> 28:36.180
Hier oben seht ihr den normalen Unit-Test, wie sowas aussieht.

28:36.340 --> 28:38.000
wo ich eben die Funktion einfach aufrufe.

28:39.020 --> 28:41.180
Typischerweise habe ich normalerweise noch Asserts dabei.

28:41.760 --> 28:42.960
Und hier unten habe ich den Fast-Test.

28:43.100 --> 28:46.360
Und ihr seht, wie vorher gezeigt auf der Folie, genau das Gleiche,

28:46.500 --> 28:49.640
bloß die Annotation ändert sich und ich kriege hier eben Daten noch rein.

28:50.080 --> 28:51.280
Und dann kann ich das jetzt laufen lassen.

28:53.120 --> 28:55.060
Und dann findet ihr normalerweise auch gleich den Fehler.

28:59.460 --> 29:01.380
Es braucht immer ein bisschen, bis er aufgesetzt ist.

29:06.340 --> 29:11.340
Ja, genau.

29:11.900 --> 29:15.060
Also, wie gesagt, hat er die ganzen Testcases durchgemacht

29:15.060 --> 29:17.920
und hat dann eben festgestellt, dass er da ein paar hat,

29:17.940 --> 29:18.860
bei denen er ein Problem hat.

29:19.380 --> 29:20.580
Also, super einfach.

29:22.400 --> 29:23.460
Aber das sind einfache Tests.

29:24.120 --> 29:26.040
Jetzt haben wir eine einfache Funktion getestet.

29:26.120 --> 29:30.240
Das ist nett, aber die größten Probleme kommen normalerweise

29:30.240 --> 29:32.020
in Kombination mit anderen Funktionen.

29:32.220 --> 29:34.560
Also, wenn ich State verursache und dann irgendwie

29:34.560 --> 29:38.020
im State unsauber umgehe oder andere Probleme damit verursache.

29:38.140 --> 29:41.160
Also jetzt ist die Frage, wie schreibe ich Advanced Fast Tests,

29:41.240 --> 29:44.240
die eben auch feststellen, was passiert, wenn ich unterschiedliche Endpoints

29:44.240 --> 29:45.680
und unterschiedliche Reihenfolge umfasse.

29:48.120 --> 29:51.480
Zum Beispiel, das ist so ein Fast Test, der sowas testet.

29:51.960 --> 29:53.680
Ich zeige euch ganz kurz die Funktion nochmal dazu.

29:55.540 --> 29:58.740
Ich habe hier zwei Endpoints, First und Second.

30:01.640 --> 30:03.300
Die speichern sich einfach in State.

30:03.300 --> 30:06.460
und resetten den State wieder

30:06.460 --> 30:10.440
und wenn der unsauber ist, dann schmeißen Sie eine Fehlermeldung

30:10.440 --> 30:12.760
und stürzen ab. Das ist so die Idee dahinter.

30:14.220 --> 30:15.940
In dem FAST-Test geht es eben darum,

30:16.020 --> 30:18.120
dass ich den Fasser selber entscheiden lasse,

30:18.180 --> 30:20.600
in welcher Reihenfolge er welche Funktion aufruft,

30:20.660 --> 30:23.220
wie oft er sie aufruft, damit er eben auch in der Lage ist,

30:23.480 --> 30:25.240
solche State-Probleme zu testen.

30:26.060 --> 30:27.100
Das ist ganz einfach das hier.

30:27.800 --> 30:29.640
Sieht jetzt ein bisschen komplizierter aus, als es ist.

30:29.700 --> 30:31.800
Es ist ganz einfach, ich habe eine Vorschleife,

30:31.800 --> 30:34.300
die einfach regelmäßig durch die ganzen Endpoints durchgeht

30:34.300 --> 30:37.040
und dann ein Switch Case, der raussucht, wer ja Endpoint jetzt aufgerufen wird.

30:37.640 --> 30:40.260
Tada, fertig. Ziemlich simpel.

30:42.040 --> 30:44.000
Und der findet eben die ganzen Schwachstellen hier auch schon.

30:46.620 --> 30:47.560
Und das erzählt immer nochmal,

30:47.680 --> 30:49.120
dass ein Drittsemester sowas nicht hinbekommt.

30:52.480 --> 30:54.740
Braucht wieder ein paar Sekunden, bis er da ist.

30:55.400 --> 30:57.940
Aber genau, jetzt sollte er auch schon wieder abgestürzt sein.

30:58.200 --> 30:58.560
Perfekt.

30:59.440 --> 30:59.880
Genau.

31:01.800 --> 31:05.000
Das waren jetzt noch ein paar Tests, das sind so ein paar Beispiele.

31:05.400 --> 31:08.180
Jetzt zeige ich euch noch ganz kurz, was zum Beispiel eine, ich glaube,

31:08.600 --> 31:14.040
CWI 9,7, 9,8, irgendwie sowas in Google Jason Sanitizer war.

31:15.260 --> 31:16.580
Der Fast Test ist fast noch einfacher.

31:17.920 --> 31:22.060
Und zwar, hier hat Google uns, also tatsächlich, was Google ganz gerne gemacht hat,

31:22.060 --> 31:25.600
ist, uns einfach bezahlen, um Software von denen zu testen,

31:25.600 --> 31:33.800
und um Software aus der Open Source Welt zu testen.

31:33.960 --> 31:36.080
In dem Fall auch diesen Google JSON Sanitizer.

31:36.480 --> 31:39.040
Die Aussage war, völlig egal, was da rauskommt,

31:39.160 --> 31:40.880
das könnt ihr rein in HTML reinpacken,

31:41.160 --> 31:42.620
da ist nichts mehr drin, was gefährlich ist.

31:44.420 --> 31:46.980
Die Aussage heißt unter anderem, dass keine Script-Tags drin sind.

31:48.800 --> 31:49.860
Also, was haben wir gemacht?

31:50.540 --> 31:52.680
Wir haben den Fasser eben gebeten,

31:53.280 --> 31:55.440
irgendwas reinzuschmeißen in diesen JSON Sanitizer

31:55.440 --> 31:56.780
und dann haben wir nachher kontrolliert,

31:57.440 --> 32:00.100
ob ich irgendeinen Script-Tag drin haben kann.

32:00.340 --> 32:01.320
Kann ich irgendwas generieren,

32:01.400 --> 32:02.980
in dem ich nachher einen Script-Tag drin haben kann?

32:03.720 --> 32:05.340
Und siehe da, er braucht knapp drei Sekunden

32:05.340 --> 32:05.780
und er hat es.

32:10.980 --> 32:15.300
Das Schöne übrigens,

32:15.440 --> 32:16.960
alles was ich euch gerade zeige, ist Open Source.

32:17.600 --> 32:19.100
Also Code Intelligence verdient

32:19.100 --> 32:21.200
sein Geld eigentlich mit dem

32:21.200 --> 32:23.920
Environment rundherum,

32:24.220 --> 32:25.040
einfach mit den Servern,

32:25.040 --> 32:26.880
die dann das ermöglichen zu skalieren,

32:27.180 --> 32:29.100
das Zusammenarbeiten, das Einfahre-Deployment,

32:29.400 --> 32:30.100
die ganzen Sachen.

32:30.460 --> 32:31.440
Aber was ihr gerade seht,

32:31.800 --> 32:33.620
Jesser, der dann eben in der Lage ist,

32:33.880 --> 32:35.400
ein Whitebox-Fasser für Java,

32:35.820 --> 32:36.720
ist komplett Open Source.

32:37.680 --> 32:39.040
Und das könnt ihr eins zu eins nachher,

32:39.120 --> 32:40.640
also wirklich, wenn ihr jetzt hinsitzt

32:40.640 --> 32:42.260
und euch Jesser anschaut,

32:42.340 --> 32:44.240
könnt ihr nachher, bevor ich fertig bin mit dem Vortrag,

32:44.680 --> 32:46.220
schon die ersten Fast-Tests am Laufen haben.

32:46.420 --> 32:47.500
So einfach ist das ganze Zeug.

32:49.140 --> 32:49.760
Das war eine Challenge.

32:49.760 --> 32:51.760
Also, genau.

32:55.040 --> 32:57.300
ja, das ist tatsächlich das schon.

32:58.100 --> 32:59.220
Jetzt ist die Frage, was hat das mit

32:59.220 --> 32:59.600
ja?

33:02.320 --> 33:03.520
Wo sehe ich jetzt

33:03.520 --> 33:05.500
den Input, der jetzt hier

33:05.500 --> 33:07.220
dieses Script-Tag erzeugt hat?

33:08.300 --> 33:08.700
Tatsächlich,

33:09.660 --> 33:10.880
das ist jetzt so ein bisschen das

33:10.880 --> 33:13.820
Problem bei der Sache, oder nicht das Problem.

33:15.440 --> 33:15.640
Also,

33:16.340 --> 33:17.760
du kannst jetzt hier einfach mit dem Debugger durchgehen.

33:18.420 --> 33:19.780
Du kannst hier einen Breakpoint setzen.

33:21.620 --> 33:22.020
Hoppala.

33:25.040 --> 33:31.360
So, setzen wir einen Breakpoint und lassen es als Debugger laufen.

33:31.360 --> 33:53.880
Also, die Idee ist,

33:53.880 --> 33:55.840
ich kann das als Debugger laufen lassen und dann Schritt für Schritt

33:55.840 --> 33:57.940
durchgehen und sehe dann ganz genau, was hat er hinzugefügt.

34:01.360 --> 34:05.740
Aus irgendeinem Grund will er gerade aber nicht in den Bagger rein.

34:15.280 --> 34:18.440
Okay, da blockt er jetzt gerade schon, aber tatsächlich die Idee ist einfach,

34:18.560 --> 34:22.180
dadurch, dass ich in JUnit integriert bin, kann ich genau die gleichen Vorgehen benutzen,

34:22.300 --> 34:27.120
die ich bei JUnit-Test benutze, um eben da zu kontrollieren, was gerade eigentlich der Input ist.

34:28.040 --> 34:30.640
Genauso zeigte mir nachher eigentlich auch die ganzen PhyNICs an.

34:30.640 --> 34:37.020
das Problem ist bloß bei der Sache, die visuelle Aufbereitung funktioniert alles mit Tools,

34:37.220 --> 34:38.540
die nicht Open Source sind.

34:38.980 --> 34:41.440
Und ich habe dem Dirk versprochen, wir halten uns heute an die Open Source Sachen.

34:43.100 --> 34:45.460
Das heißt, das ist so ein bisschen die Einschränkung.

34:45.840 --> 34:50.100
Normalerweise würde ich sagen, kein Problem, CIFS, Finding, zeigen wir es an, kein Ding.

34:51.940 --> 34:54.860
Aber genau da laufen wir eben in die Limitierung, genau damit laufen wir rein,

34:54.940 --> 34:56.480
wo Code Intelligence eigentlich sein Geld verdient,

34:56.480 --> 35:00.480
eben mit dem ganzen Zeug rundherum, um das eben noch einfacher und noch schöner zu machen.

35:00.640 --> 35:08.880
Sonst noch irgendwelche Fragen dazu?

35:09.900 --> 35:10.120
Nein?

35:11.260 --> 35:11.500
Okay.

35:13.300 --> 35:13.940
Nächste Sache.

35:14.240 --> 35:16.260
Eigentlich sind wir hier losgelaufen mit CICD-Integration.

35:17.960 --> 35:19.460
Was für einen Bezug hat es eigentlich dazu,

35:19.520 --> 35:20.500
was wir jetzt gerade gemacht haben?

35:21.340 --> 35:22.160
Das ist relativ einfach.

35:22.900 --> 35:24.460
Ich kann diese ganzen Tests hier automatisch

35:24.460 --> 35:25.620
in der CICD mitlaufen lassen.

35:25.760 --> 35:26.880
Das ist ja die ganze Idee dahinter.

35:27.020 --> 35:30.200
Ich bin so schnell und so flexibel in meinen Tests,

35:30.640 --> 35:34.580
dass ich dann nachher kein Problem habe, also keine große Zeit brauche

35:34.580 --> 35:39.340
und die ganze Zeit permanent bei jedem Commit, bei jedem Merge,

35:40.020 --> 35:42.340
die ganzen Tests wieder laufen zu lassen.

35:42.820 --> 35:45.100
Das ist eben eine sehr, sehr angenehme Sache.

35:45.500 --> 35:48.720
Ich zeige euch ganz kurz, wie das jetzt hier funktionieren würde.

35:50.100 --> 35:51.920
Also, schnellster Fall, ganz einfach.

35:52.460 --> 35:56.840
Dadurch, dass wir integriert sind, ich lasse nachher einen Maven-Test mitlaufen in der CI-CD.

35:57.200 --> 35:57.660
Ganz einfach.

35:58.000 --> 36:00.440
Ich beteste die ganzen Fast-Tests mit durch, Sache erledigt.

36:00.640 --> 36:05.000
Wenn ich ein sehr, sehr großes Programm habe, dann lohnt sich das nicht mehr.

36:05.500 --> 36:09.340
Weil dann habe ich zu viele Fast-Tests und zu viel Zeit, die dann meine CI-CD braucht.

36:09.420 --> 36:10.520
Dann will ich das asynchron haben.

36:11.420 --> 36:13.980
Dann macht es tatsächlich Sinn, wieder in eine entsprechende Environment zu gehen,

36:14.060 --> 36:16.020
die dann asynchron die ganzen Fast-Tests laufen lässt.

36:16.460 --> 36:18.620
Also stellt euch das so vor, ihr startet die CI-CD,

36:19.100 --> 36:21.520
am Anfang baut ihr eben dieses Faser-Bar-Artifact zusammen,

36:21.780 --> 36:24.560
also dieses Artifact, wo die ganzen Fast-Tests dabei sind,

36:24.880 --> 36:27.480
schickt das an einen anderen Server raus, der testet es dann parallel,

36:28.000 --> 36:30.320
währenddessen mache ich was anderes, mache meinen normalen Unit-Test,

36:30.320 --> 36:32.140
mache, irgendwelchen Integrationstest mache,

36:32.180 --> 36:34.460
sonst noch irgendwas, und dann frage ich nach ein paar Minuten

36:34.460 --> 36:35.880
nach, hey, wie sieht es eigentlich aus?

36:43.760 --> 36:44.340
Projekte, also,

36:44.660 --> 36:44.780
ja?

36:46.380 --> 36:47.440
Mein Mikro ist ausgegangen.

36:48.980 --> 36:49.940
Vielleicht habe ich auch einfach,

36:51.320 --> 36:51.520
so,

36:53.260 --> 36:53.600
besser?

36:55.800 --> 36:56.740
Hat sich in meinem Ausschnitt

36:56.740 --> 36:57.120
versteckt.

36:59.380 --> 37:00.200
Genau, also wie gesagt,

37:00.200 --> 37:02.280
für kleine Projekte überhaupt kein Problem.

37:02.580 --> 37:04.400
Packt das so rein, funktioniert alles gut.

37:05.140 --> 37:05.800
Wenn eine Richtung

37:05.800 --> 37:08.280
10.000, 100.000 Seilen Code kommt, ab dann

37:08.280 --> 37:10.120
macht es keinen Sinn mehr. Weil ab dann braucht

37:10.120 --> 37:11.820
eure CICD Tage, bis ihr da durch ist.

37:12.220 --> 37:14.040
Ab dann habt ihr genau das gleiche Problem mit dem Pentest,

37:14.120 --> 37:16.320
dann könnt ihr gleich einen Pentest machen. Das ist genauso gut.

37:17.180 --> 37:17.900
Aber bis dahin,

37:18.300 --> 37:20.220
ganz einfach, packt

37:20.220 --> 37:22.360
über Maven eure CICD rein,

37:22.360 --> 37:23.440
dann ist die Sache durch.

37:25.240 --> 37:26.480
Das war es tatsächlich auch schon

37:26.480 --> 37:28.420
mit meinem Vortrag. Wenn irgendjemand Fragen

37:28.420 --> 37:30.560
hat, gerne. Ansonsten, ich hoffe

37:30.560 --> 37:32.500
einfach, dass ihr gesehen habt, was für Möglichkeiten

37:32.500 --> 37:34.360
es gibt im Zweifelsfall, einfach

37:34.360 --> 37:35.280
Code auch zu testen.

37:36.260 --> 37:37.360
Und dass ihr vielleicht hoffentlich

37:37.360 --> 37:40.460
nicht ganz zur Fraktion später gehört,

37:40.540 --> 37:42.480
die dann sagt, ach, Security Testing, scheißegal.

37:44.840 --> 37:46.580
Zumindest nicht zu der Fraktion,

37:46.740 --> 37:48.380
die dann nachher sagt, ach ja, dann bringt

37:48.380 --> 37:50.320
meine Software halt Leute um, das ist dann halt so.

37:50.900 --> 37:51.900
Das wäre mein Anliegen.

37:52.700 --> 37:54.020
Ansonsten, ich hoffe, das war für euch

37:54.020 --> 37:55.920
einigermaßen interessant.

37:58.420 --> 37:59.600
Super, vielen Dank, Philipp.

38:03.920 --> 38:05.940
Ist das nicht so ein Grundprinzip der Security,

38:06.120 --> 38:09.260
dass man immer nur ein bisschen besser sein muss als der nächst Schlechtere?

38:12.460 --> 38:13.720
Compliance-technisch, ja.

38:14.740 --> 38:17.720
Ich würde behaupten, wenn einer mit 100 oder mit 95 gegen die Wand fährt,

38:18.500 --> 38:20.300
das macht den Frey auch nicht mehr fett.

38:20.920 --> 38:24.440
Also das ist aus meiner Sicht einfach so.

38:25.680 --> 38:27.760
Ich habe nur ein bestimmtes Zeitbudget, ganz einfach.

38:28.420 --> 38:32.520
Und ich soll schauen, wie ich am effizientesten da auf einen akzeptablen Security-Stand komme.

38:33.340 --> 38:37.720
Und momentan sehe ich halt ganz arg, dass das Niveau so dermaßen niedrig ist,

38:38.360 --> 38:40.840
dass die Leute es überhaupt nicht interessiert, was sie da eigentlich machen.

38:40.920 --> 38:42.360
Das Einzige, was sie interessiert, ist Compliance.

38:43.120 --> 38:44.420
Und das tut eigentlich schon weh.

38:45.060 --> 38:49.580
Und vor allem, wenn man weiß, also mein Problem ist ganz klar, wir haben viele Automotive-Kunden.

38:50.000 --> 38:52.180
Ich habe eine ganze Menge Probleme mitbekommen.

38:52.560 --> 38:57.280
Und es gibt leider auch Hersteller, wo ich sage, um Gottes Willen, ich setze mich da in kein Auto rein.

38:57.280 --> 39:04.720
also das ist tatsächlich wirklich okay die harten beispiele lasse ich jetzt raus aber es ist es

39:04.720 --> 39:13.320
nur land dinge kennen wo denkt seite bescheuert wie zum geier kriegt ihr das also kann das mit

39:13.320 --> 39:20.520
eurem gewissen vereinbaren und das ist immer das was man sagt die security macht ein paar

39:20.520 --> 39:22.260
Ja, definitiv.

39:23.300 --> 39:25.080
Ja, ich habe auch das passende T-Shirt dazu.

39:26.260 --> 39:27.640
Also es hat funktioniert.

39:28.680 --> 39:31.940
Prima. Gibt es Fragen aus dem Publikum oder aus dem Chat?

39:37.880 --> 39:39.500
Jawohl, da haben wir doch eine Frage.

39:40.000 --> 39:41.920
Moment, langsam das Mikro kommt.

39:43.900 --> 39:44.500
Dankeschön.

39:45.000 --> 39:47.900
Mir ist auch noch ein Beispiel eingefallen zu Deinen,

39:47.900 --> 39:49.660
gerade aus den letzten Tagen.

39:49.660 --> 39:55.460
Ich habe da gelesen, dass zum Beispiel jetzt dort Phishing-Mails original aus Booking.com rauskommen.

39:56.280 --> 39:58.900
Und ich habe mir gedacht, aha, wie geht das Ganze?

39:58.980 --> 40:00.020
Na, es ist ganz einfach.

40:01.400 --> 40:05.440
Man versucht die Partner von Booking.com zu knacken.

40:05.780 --> 40:09.400
Also der Löwengastwirt zum Beispiel, der kriegt ein Phishing-Mail.

40:09.680 --> 40:13.660
Der ist natürlich Kunde von Booking.com und der lockt sich dort regelmäßig ein.

40:14.020 --> 40:18.420
Der kriegt dann ein Phishing-Mail, dann gibt er seine Credentials dort bei Man in the Middle ein

40:18.420 --> 40:20.280
und dann sind die weg, das ist ganz klar.

40:20.700 --> 40:23.540
Und daraufhin war die interessante Reaktion von Booking.com,

40:24.160 --> 40:27.880
ja, also, ja, schon ärgerlich, aber ist ja nicht unser Problem,

40:28.020 --> 40:30.620
das sind einfach diese dummen Typen draußen,

40:31.120 --> 40:33.740
die einfach nicht da auf alles Mögliche klicken und so.

40:34.020 --> 40:35.180
Und ich habe mir im Stillen gedacht,

40:35.780 --> 40:39.100
gute Leute, für 29 Euro kannst du bei Nitro-Key

40:39.100 --> 40:42.720
einen Fido 2-Key erstehen für deine Leute.

40:43.240 --> 40:44.800
Das würde euch nicht umbringen

40:44.800 --> 40:48.160
und ihr hättet diese ganze Problematik nicht mehr an der Backe.

40:48.420 --> 41:00.900
Aber nein, diese 29, die würden es wahrscheinlich mit Rabatt für 20 kriegen, diese 20 Euro ist es Booking nicht wert, die Gastwirte und die anderen einfach so abzusichern, dass die keinen Fehler machen können.

41:00.900 --> 41:16.860
Ich habe mir damals schon vor drei Jahren so ein Ding geholt und jetzt kann ich auch relativ mit gutem Gewissen mich auf Third-Party-Authentications verlassen oder sowas, weil auch wenn sie mir eine Fake-Seite unterschieben und ich will mich dort mit meinem Google-Account authentisieren oder sowas, die haben den Stick nicht.

41:16.860 --> 41:22.580
Und damit bin ich einfach sicher an der Stelle, hey, keine 20 Euro ist es Ihnen wert.

41:22.760 --> 41:28.460
Und das bestätigt nur diese Geschichte, ja, IT-Security ist irrelevant.

41:28.840 --> 41:30.020
Das juckt keine Sau.

41:31.060 --> 41:32.400
Sag doch sowas nicht.

41:35.560 --> 41:38.320
Wie soll ich jetzt die Studierenden motivieren, das weiterzulernen?

41:41.280 --> 41:44.640
Also, jetzt geht es leider gerade ein bisschen da vorbei,

41:44.640 --> 41:46.540
aber lieber Walter, ich muss dir kurz widersprechen.

41:46.860 --> 41:55.240
Im Geschäftsmodell sieht es ein bisschen anders aus, denn der Supportaufwand, bis der Ochsenwirt mit dem Nitro-Key zurechtkommt,

41:55.340 --> 42:03.220
den kannst du nochmal mit ein paar hundert Euro mit in die Bücher schreiben und dann muss der wahrscheinlich zehn Jahre von seinem Umsatz da nochmal abschreiben.

42:03.220 --> 42:17.720
tatsächlich muss leider aus erfahrung auch sagen der wille zeit zu investieren oder auch

42:17.720 --> 42:22.620
nur gedanken an was zu investieren dass ich nicht 100 prozent muss nicht vorhanden überhaupt nicht

42:22.620 --> 42:28.260
das ist das muss man merkt richtig bis zu einem halben jahr nach dem security vorfall

42:28.260 --> 42:30.700
weil ist Geld da, ist Wille da, ist Zeit da.

42:31.220 --> 42:35.180
Und nach diesem halben Jahr bricht es ein und dann musst du wieder richtig kämpfen,

42:35.260 --> 42:36.480
dass die Leute dir überhaupt antworten.

42:39.600 --> 42:44.460
Teilweise ist es echt traurig zu sehen, wie die Leute das erste Mal da stehen,

42:44.540 --> 42:49.520
total aufgewühlt und sagen, oh scheiße, wir haben ein richtiges Problem, helft uns.

42:50.120 --> 42:54.380
Und dann fängst du an, denen zu helfen und dann nach einem halben Jahr ist so die Motivation,

42:54.660 --> 42:55.840
zack, jetzt läuft es ja wieder.

42:55.840 --> 42:58.820
es tut richtig weh

42:58.820 --> 43:01.000
es tut richtig weh teilweise das zu sehen

43:01.000 --> 43:02.020
muss man echt sagen

43:02.020 --> 43:05.100
ich überlege jetzt mal was wir heute

43:05.100 --> 43:07.260
so an Themen gehört haben

43:07.260 --> 43:08.660
und das nochmal einzuordnen

43:08.660 --> 43:11.040
letztendlich sagst du ja auch

43:11.040 --> 43:12.980
das was wir bisher gemacht haben, also was Tobias

43:12.980 --> 43:14.040
eben vorgetragen hat

43:14.040 --> 43:16.960
da ist Geld für da, weil da schützen sich

43:16.960 --> 43:19.220
die Unternehmen quasi selber und ihre Infrastruktur

43:19.220 --> 43:20.900
aber die Produkte

43:20.900 --> 43:22.700
die sie ausliefern, egal

43:22.700 --> 43:23.720
so

43:23.720 --> 43:27.740
kriegt das denn nachher keiner mit und gibt es

43:27.740 --> 43:29.620
keinen Imageschaden, sodass dann die

43:29.620 --> 43:31.580
Verkaufszahlen vielleicht zurückgehen, also

43:31.580 --> 43:32.900
läuft das ab.

43:33.320 --> 43:35.440
Google hat auch, nee, das war nicht Google, das war Microsoft,

43:35.680 --> 43:37.820
die jetzt, glaube ich,

43:38.380 --> 43:39.500
war das nicht ein Masterkey,

43:40.020 --> 43:41.520
verloren gehabt haben und dann

43:41.520 --> 43:43.960
so richtig verkackt

43:43.960 --> 43:45.660
haben mit der Aufarbeitung und trotzdem

43:45.660 --> 43:47.820
die Verkäufe laufen weiter. Das Ding ist

43:47.820 --> 43:49.800
einfach das, meine Erfahrung ist,

43:49.860 --> 43:52.020
die Leute fangen dann an zu wechseln,

43:52.060 --> 43:53.360
wenn es ihnen richtig weh getan hat,

43:53.720 --> 43:57.940
Also wenn es Ihnen selber richtig wehgetan hat, und das ist nur in den selteneren Fällen der Fall,

43:58.860 --> 44:03.980
wenn Sie gesetzlich gezwungen werden, oder wenn Sie sonst, was wir auch gesehen haben,

44:04.800 --> 44:18.540
Leute, die dann Angebote einreichen für Jobs, für Angebote quasi ans Land,

44:18.540 --> 44:19.880
also wenn

44:19.880 --> 44:22.180
genau, für öffentliche Aufträge

44:22.180 --> 44:24.800
die haben angefangen sowas reinzubauen, damit sie noch ein Stichmittel

44:24.800 --> 44:27.180
haben, warum sie die Kosten erhöhen können

44:27.180 --> 44:28.220
das war

44:28.220 --> 44:30.380
also wenn sie sowas machen

44:30.380 --> 44:32.700
dann ist was anderes der treibende Fakt, die Security

44:32.700 --> 44:34.480
ist nie, Security ist wirklich nie

44:34.480 --> 44:35.660
und das ist

44:35.660 --> 44:38.660
Okay, jetzt nehmen wir mal an

44:38.660 --> 44:40.460
wir würden uns trotzdem dafür interessieren

44:40.460 --> 44:43.080
sichere Produkte auszuliefern

44:43.080 --> 44:44.760
wenn wir

44:44.760 --> 44:46.700
jetzt so ein Whitebox Phasing Tool

44:46.700 --> 44:48.880
einsetzen. Da steckt ja der Name

44:48.880 --> 44:50.800
sowas wie Testing auch drin.

44:50.920 --> 44:52.520
Du hast ja erklärt, wie testen war es.

44:52.580 --> 44:54.500
Heißt ja auch Fast-Test als Annotation.

44:55.980 --> 44:56.940
Testen heißt ja immer,

44:58.240 --> 44:59.160
ich kann nicht so 100%

44:59.160 --> 45:01.060
sicher sein, dass ich alles gefunden habe.

45:01.380 --> 45:02.980
Ich kann auch keine Security

45:02.980 --> 45:04.820
reintesten, genauso wie ich keine Qualität

45:04.820 --> 45:07.040
reintesten kann. Kannst du

45:07.040 --> 45:08.260
irgendwie eine Aussage machen,

45:08.840 --> 45:10.840
durch dieses Fuzzing, also durchprobieren

45:10.840 --> 45:11.440
von Werten,

45:11.440 --> 45:13.680
das heißt ja auch

45:13.680 --> 45:15.640
die Firma Code Intelligence,

45:15.640 --> 45:18.160
dadurch, dass ich eben ja weiß, wie der Code strukturiert ist,

45:18.240 --> 45:22.260
dass ich die Pfade kenne, dass ich vielleicht auch Variablen kenne.

45:23.140 --> 45:26.480
Wie gut bin ich denn dann nachher im Ergebnis zu einem,

45:26.580 --> 45:30.120
sagen wir mal, dumm-dämlich-Phasing, das einfach random Werte generiert?

45:30.280 --> 45:32.760
Gibt es da eine Aussage dazu, wie sich das unterscheidet?

45:33.060 --> 45:34.820
Ja, ziemlich deutlich sogar.

45:34.920 --> 45:38.100
Ich kann hier genau sehen, die Visualisierung ist auf Statement,

45:38.680 --> 45:41.040
aber der Phaser kann auf Branch-Ebene unterscheiden,

45:41.080 --> 45:42.520
was er getroffen hat, was er nicht getroffen hat.

45:42.520 --> 45:46.940
Von dem her kann ich ganz genau sehen, was war das Ergebnis von jedem einzelnen Test.

45:48.080 --> 45:49.840
Ich lasse den hier mal ganz kurz loslaufen.

45:49.940 --> 45:51.320
Das ist, wie gesagt, leider privat.

45:52.880 --> 45:55.040
Das ist nicht im Open Source Bereich dabei.

45:55.640 --> 46:00.780
Aber ich kann hier wirklich ganz genau sehen, was habe ich getestet, wie oft habe ich das getestet, was ist das Ergebnis.

46:01.900 --> 46:04.180
Und, naja, genau, jetzt ist es schon da.

46:05.020 --> 46:08.100
Ich kann tatsächlich hier nachher durchklicken und sehe da ganz genau,

46:08.100 --> 46:11.840
die Funktion,

46:12.720 --> 46:13.540
dann sehe ich ganz genau,

46:13.700 --> 46:15.600
diese Zeilen habe ich hier getriggert,

46:15.920 --> 46:17.060
den Rest habe ich nicht getriggert.

46:18.200 --> 46:20.160
Also ich weiß hier auf einmal,

46:20.360 --> 46:21.480
was ich getestet habe.

46:23.300 --> 46:24.340
Gerade aus dem Sinne

46:24.340 --> 46:25.860
macht es aus meiner Sicht

46:25.860 --> 46:27.480
auf jeden Fall Sinn, das zu tun.

46:28.240 --> 46:29.720
Und wie gesagt, ich spare mir sogar

46:29.720 --> 46:31.440
Unit-Testing-Aufwand, weil ich ein zweiter oder weniger

46:31.440 --> 46:32.320
Unit-Test schreiben muss.

46:32.720 --> 46:34.860
Es gibt wirklich rational kein Argument,

46:34.920 --> 46:36.940
das nicht zu tun. Ganz einfach.

46:36.940 --> 46:48.100
Du hast uns ja gerade erzählt, dass wir leider nicht rational handeln. Prima, gibt es sonst noch Fragen, nachdem du es etwas disillusioniert hast? Jawohl, da kommt noch eine Frage.

46:48.660 --> 47:01.040
Ich habe noch zum Abschluss eine beruhigende Ansage für die Security-Leute. Es gibt mittlerweile ein Thema, was auf den Konferenzen noch nach Security gehandelt wird und das ist die Barrierefreiheit.

47:01.040 --> 47:04.820
Okay, wir haben nicht den letzten Platz, na immerhin.

47:06.380 --> 47:06.780
Super.

47:07.580 --> 47:10.920
Wobei es da ja auch gesetzliche Vorkommen für Barrierefreiheit gibt.

47:12.100 --> 47:14.500
Aber soweit ich weiß, glaube ich nur für öffentliche Einrichtungen bis jetzt.

47:14.760 --> 47:16.760
Da wehren sich die Unternehmen wahrscheinlich auch gegen,

47:16.820 --> 47:18.100
haben auch genug Auflagen schon.

47:19.080 --> 47:19.480
Super.

47:19.900 --> 47:21.360
Aber das ist das Einzige, was hilft.

47:22.540 --> 47:24.620
Davor habe ich eigentlich gedacht, was soll der Schrott?

47:25.100 --> 47:27.660
Die wissen Leute, wissen doch selber, was am meisten Sinn macht,

47:27.660 --> 47:28.660
wie sie es am besten angehen.

47:28.660 --> 47:31.340
und jetzt habe ich gesehen, dass tatsächlich die ISO-Norm

47:31.340 --> 47:34.380
ist das Einzige, was FASING so richtig reintreibt in den Unternehmen.

47:34.720 --> 47:36.940
Und wenn man ganz klar sieht, was für Projekte die da auswählen,

47:37.020 --> 47:38.400
eben nur die, die eben drunter fallen,

47:38.900 --> 47:42.920
dann merkt man auch, dass nur die ISO-Norm eigentlich der treibende Faktor ist

47:42.920 --> 47:43.740
von einer erhöhten Security.

47:44.720 --> 47:46.240
Wir sehen es ja auch an anderen Stellen,

47:46.380 --> 47:49.700
selbst der Eigenschutz wurde ja von vielen Unternehmen lange vernachlässigt,

47:49.700 --> 47:52.140
bis dann das BSI-Gesetz kam und sagt so,

47:52.260 --> 47:55.340
also Leute, ihr müsst jetzt mal Systeme zur automatischen Angriffserkennung umsetzen,

47:55.540 --> 47:57.060
gerade bei den kritischen Infrastrukturen,

47:57.060 --> 47:59.540
und ihr müsst auch melden, wenn ihr angegriffen werdet.

47:59.760 --> 48:01.600
Das war ja so heute auch beim LKA gesehen,

48:01.820 --> 48:04.760
haben so bei 450.000 Unternehmen 50.000 melden nur

48:04.760 --> 48:06.040
und da stimmt irgendwie auch was nicht.

48:07.220 --> 48:09.120
Also da haben wir noch ein bisschen was zu tun

48:09.120 --> 48:11.460
und man sieht es an der Regulierung,

48:11.580 --> 48:14.240
da werden bestimmt noch mehr Verschärfungen auch kommen.

48:14.360 --> 48:15.420
Wir haben noch mal eine Frage.

48:16.140 --> 48:17.940
Also ich möchte, was ich gesagt habe,

48:18.000 --> 48:19.640
jetzt nicht so radikal stehen lassen,

48:19.760 --> 48:21.460
wie es offensichtlich verstanden wurde.

48:22.440 --> 48:25.800
Wenn ich zurückdenke an die, wo ich bei der UBS AG gearbeitet habe,

48:25.800 --> 48:34.100
da ist zum Beispiel der eine Unterschied halt, dass dort die Security-Leute als Stababteilung neben dem, außerhalb der Hierarchie stehen.

48:34.240 --> 48:37.700
Und wenn die gesagt haben, nein zu etwas, dann war das ein Nein.

48:37.820 --> 48:40.280
Und dann bist du als Business-Mensch daran nicht vorbeigekommen.

48:40.700 --> 48:48.240
Also das kommt halt auch darauf an, wie das Ganze organisiert ist, welche Kraft die Security bekommt in der Firma.

48:48.700 --> 48:52.820
Das ist das eine. Und da sind schon einige Firmen recht erfolgreich unterwegs.

48:52.820 --> 48:56.420
dann natürlich glaube ich auch tut sich rechtlich einiges langsam.

48:56.800 --> 49:01.920
Also wir werden besser, diese Wildwestzeiten, Leute, das geht schon langsam zu Ende,

49:02.120 --> 49:04.220
also da gebe ich dir vollkommen recht.

49:04.440 --> 49:07.640
Es ist nur manchmal erschütternd zu sehen, wie lange das dauert, oder?

49:08.120 --> 49:13.460
Denn zu der Überzeugung von Philipp, da bin ich irgendwo im Bereich 2008, 2009 gekommen

49:13.460 --> 49:17.540
und es hat sich noch nicht so drastisch geändert momentan.

49:17.540 --> 49:22.180
Der Vortrag von Tobias hat mich fasziniert, weil du denkst,

49:22.180 --> 49:27.480
Und yes, das was die mittlerweile auffahren, dort an Geschützen, das ist ja unglaublich.

49:27.800 --> 49:33.180
Andererseits, du schaust auf Google News und es wimmelt von Katastrophenmeldungen in Bezug auf Security.

49:33.180 --> 49:37.480
Und du kriegst das gar nicht mehr richtig unter einen Hut.

49:37.940 --> 49:45.240
Die Aufwände steigen scheinbar ins Endlose, aber auch die Erfolge der Attacker steigen permanent.

49:45.600 --> 49:49.540
Die Universitäten leben in Angst und schrecken die Städte und überall.

49:50.220 --> 49:52.020
Also es ist schon irgendwie ein seltsames Ding.

49:52.180 --> 49:55.420
Das ist das eine, also es wird schon trotzdem besser, denke ich auch.

49:55.800 --> 49:58.400
Und trotzdem ist natürlich Security wichtig, IT-Security.

49:58.760 --> 50:06.200
Vielleicht noch als Nachsatz, ich habe schmunzeln müssen, weil das ist natürlich, Google steht ja auch ganz stark auf Fuzzing zum Beispiel.

50:06.200 --> 50:09.740
Also die haben das längst begriffen, dass das ein wichtiges Ding ist.

50:10.160 --> 50:16.080
Und ich habe aber trotzdem schmunzeln müssen, weil mir sind ein paar der ganz großen Security-Fehler der letzten Jahre eingefallen.

50:16.660 --> 50:21.400
Und die hätte man eigentlich schon durch einen schlichten Negativ-Test entdecken können.

50:21.400 --> 50:26.260
Wenn du alle Zertifikate, die dir vorgelegt werden, als gut akzeptierst,

50:26.540 --> 50:32.320
Mann, ein falsches Zertifikat hätte dir gezeigt, da ist aber ein dicker Bug irgendwo drin.

50:32.580 --> 50:38.360
Oder wenn du Random Numbers machst, die ganz offensichtlich nur einen 64K-Bereich abdecken,

50:38.740 --> 50:45.900
hey, mal einmal da ein kleines Bild abgebildet und du siehst, oh, da ist aber was oberfaul.

50:45.900 --> 50:50.680
Das heißt, das ist schon der Mercedes, aber vergesst vielleicht auch die kleine Lösung nicht,

50:50.680 --> 50:57.380
nämlich einfach Negativtests, bewusste Negativtests für Dinge, wo ihr wisst, die dürfen nicht passieren.

50:57.640 --> 51:01.760
Das will ich wenigstens explizit ausschließen, sozusagen. Danke.

51:02.220 --> 51:05.660
Das ist tatsächlich immer noch wichtig. Eine Sache noch ganz kurz zu Google und Fuzzing.

51:06.060 --> 51:09.180
Tatsächlich hat dieses Whitebox und Smart Fuzzing bei Google und Microsoft angefangen.

51:09.800 --> 51:11.940
Von denen stammt die Technologie.

51:12.920 --> 51:16.220
Unsere Gründer haben dann tatsächlich in der Doktorarbeit mal nachgeschaut,

51:16.320 --> 51:19.840
hey, es gibt die Technologie, die ist super effizient, warum benutzen das eigentlich keine anderen?

51:19.840 --> 51:23.540
und haben dann festgestellt, hey, Google und Microsoft haben ein Team von über 100 Doktoranden,

51:24.020 --> 51:25.260
um genau das Thema anzugehen.

51:25.860 --> 51:29.700
Und das Schöne ist, unsere Gründer sind dann angefangen mit der Idee,

51:29.840 --> 51:32.260
na gut, dann machen wir es halt einfach, dann machen wir es leicht zu benutzen,

51:32.700 --> 51:34.060
dann machen wir es angenehm.

51:34.620 --> 51:38.280
Und inzwischen ist es so weit, dass Google uns beauftragt, um ihre Sachen zu fassen.

51:38.740 --> 51:40.780
Und es ist ein Go, zum Beispiel der Fasser,

51:42.140 --> 51:43.660
na gut, der ist jetzt eine Weile unmaintained,

51:44.140 --> 51:46.660
aber ich glaube, die letzten Commits sind von unserem Gründer.

51:46.660 --> 51:52.720
Also tatsächlich, wenn Google inzwischen ein Problem mit Fuzzing hat, dann rufen die alle, also unsere Gründer an.

51:53.240 --> 51:56.100
So ist das Know-how da inzwischen sogar verteilt.

51:56.100 --> 51:59.520
Aber man muss ganz ehrlich sagen, es ist immer noch so ein bisschen so eine Nischensache.

52:00.000 --> 52:03.860
Also Leute, die wirklich Ahnung von Fuzzing haben, gibt es ganz, ganz, ganz wenig.

52:06.080 --> 52:11.500
Das ist für mich immer so der schöne Wink so ein bisschen.

52:12.240 --> 52:15.240
Einfach zu sehen, auch wenn Google anruft und sagt,

52:15.300 --> 52:16.960
hey, wir haben das Problem, kriegt ihr das gelöst?

52:17.600 --> 52:20.660
Und alle zwei Wochen später, ja, so und so haben wir es gemacht.

52:21.000 --> 52:24.500
Und den Leuten das Gewiss runterfällt so ein bisschen, das war möglich.

52:28.180 --> 52:31.160
Prima, dann haben wir noch Fragen, sehr gut.

52:31.580 --> 52:33.800
Sonst hätte ich versucht, noch einen versöhnlichen Abschluss zu finden,

52:33.900 --> 52:37.480
das hole ich dann gleich noch nach, hoffentlich, wenn ich frage.

52:37.480 --> 52:44.340
Wie entwickelt ihr das Prinzip des Testings weiter bei Code Intelligence,

52:44.560 --> 52:47.780
beziehungsweise was gibt es noch zu verbessern oder wo gibt es noch Schwachstellen?

52:49.040 --> 52:51.820
Das Problem ist immer die Benutzbarkeit.

52:52.600 --> 52:57.980
Also ich habe noch nie von jemandem gehört, oh, das bringt mir keinen Mehrwert.

52:58.420 --> 53:02.180
Ich habe immer nur gehört, oh, wir haben gerade andere Prioritäten und oh,

53:02.180 --> 53:05.640
unsere Leute haben gerade viel zu tun,

53:05.700 --> 53:07.880
wir haben keine Zeit noch, irgendwas anderes reinzubringen.

53:08.540 --> 53:11.040
Und was wir versuchen, ist, die Sachen immer noch einfacher zu machen.

53:11.640 --> 53:14.260
Das Ziel ist wirklich nachher, dass es einfacher ist,

53:14.320 --> 53:16.080
es zu benutzen, als es nicht zu benutzen.

53:16.640 --> 53:18.700
Momentan würde ich sagen, wir sind auf einem sehr guten Weg.

53:19.420 --> 53:21.240
Bei CC++ sind wir sogar schon einen Schritt weiter,

53:21.500 --> 53:23.260
da kann ich die ganzen Sachen automatisiert generieren.

53:23.640 --> 53:25.060
Da brauche ich dann gar keine Tests mehr schreiben,

53:25.500 --> 53:27.000
sondern bin ich in der Lage, einfach zu scannen,

53:27.080 --> 53:28.340
was für Public Functions habe ich,

53:28.600 --> 53:31.140
und dann generiere ich einen Fast-Test, der das alles sauber macht.

53:31.680 --> 53:33.660
Das ist für mich die Zukunft, wo es hingehen muss.

53:34.240 --> 53:38.220
Wo es eben schneller ist, alles zu testen, als es nicht zu testen

53:38.220 --> 53:39.640
und dann irgendwelche Fehler zu haben.

53:40.320 --> 53:42.680
Genau, das ist so mein Ziel.

53:42.940 --> 53:44.820
Da, wo ich sage, da haben wir einen großen Schritt getan.

53:45.560 --> 53:48.580
Und das Schöne ist, momentan in der Timeline,

53:50.220 --> 53:52.260
Mitte nächstes Jahres sind wir auf jeden Fall soweit.

53:52.600 --> 53:54.020
Also eigentlich ist das Ziel früher.

53:54.640 --> 53:56.340
Und in CC++ sind wir jetzt schon soweit.

54:01.140 --> 54:05.120
So, sieht so aus, als gäbe es keine weiteren Fragen.

54:05.220 --> 54:07.440
Wir sind auch mehr als perfekt im Zeitplan.

54:08.360 --> 54:12.400
Jetzt müssen wir mal irgendwie schauen, wie wir noch ein versöhnliches Ende finden.

54:13.060 --> 54:15.500
Nach so einem Security Day, dass wir jetzt nicht herausgehen und denken,

54:15.640 --> 54:17.600
ja die Welt ist böse und schlecht ist sie natürlich,

54:18.020 --> 54:21.620
aber was können wir tun, damit sie etwas besser wird oder was haben wir schon getan.

54:21.700 --> 54:23.440
Jetzt haben wir gesehen, es gibt Technologien.

54:23.960 --> 54:26.560
Wir müssen ein bisschen an der Psychologie noch arbeiten,

54:27.260 --> 54:30.500
dass sich das auch in den Köpfen festsetzt, dass es sinnvoll ist

54:30.500 --> 54:33.980
und dass man auch andere schützen sollte und nicht nur sich selber.

54:34.700 --> 54:37.160
Auch so ein bisschen gesellschaftlich denken.

54:37.740 --> 54:39.980
Ich denke, da tragen auch Veranstaltungen wie diese dabei

54:39.980 --> 54:42.940
und da freue ich mich auch, dass da ein entsprechendes Interesse da ist.

54:43.420 --> 54:46.600
Dass die Leute sagen, ja, wir müssen was tun und wir denken nicht nur an uns,

54:46.720 --> 54:49.620
sondern wir lernen hier etwas, um Anwendungen zu bauen,

54:50.140 --> 54:54.460
die eben unsere User schützen und unsere Kunden letztendlich auch schützen.

54:55.380 --> 54:58.160
Wenn wir das hinbekommen, dass so die Haltung sich da ändert,

54:58.160 --> 55:00.220
das ist ja auch das Wesentliche, was du angesprochen hast,

55:00.500 --> 55:02.040
dann sind wir auf einem guten Wege.

55:02.780 --> 55:06.800
Das Problem ist halt immer das liebe Geld, weil es kostet halt Geld.

55:07.240 --> 55:09.840
Man muss es von Anfang an berücksichtigen.

55:10.620 --> 55:15.240
Es muss halt irgendwie in die Köpfe rein, dass es unter Umständen oder in der Regel nachher teurer wird,

55:15.900 --> 55:21.820
wenn ich dann die Schwachstellen erst in Produktion habe oder dann eben, wenn das Produkt schon beim Kunden ist.

55:23.100 --> 55:27.240
Da hoffen wir mal, dass diese Erkenntnis sich auch durchsetzen wird

55:27.240 --> 55:31.700
und dann so tolle Tools, wie ihr die habt und auch andere tolle Tools,

55:31.780 --> 55:34.960
die wir heute gesehen haben, um den Betrieb dann abzusichern,

55:35.580 --> 55:39.240
sich durchsetzen werden, sodass wir dann nachher nicht beim LKA anrufen müssen

55:39.240 --> 55:42.620
und sagen, hallo, es ist was passiert, um die Schleife jetzt komplett zu drehen

55:42.620 --> 55:45.800
zum Anfang wieder, weil das würden wir gerne vermeiden,

55:46.380 --> 55:49.980
weil das bedeutet in der Regel, dass wir auch eine Betriebsunterbrechung haben

55:49.980 --> 55:53.200
oder in unserem Fall, dass wir vielleicht die Vorlesungen erstmal nicht halten können,

55:53.260 --> 55:57.000
weil unsere Unterlagen verschlüsselt worden sind oder die Mail-Server nicht mehr gehen.

55:57.240 --> 55:58.820
Und das wollen wir ja möglichst vermeiden.

55:58.940 --> 56:03.240
Insofern bedanke ich mich an alle, die sich für das Thema heute interessiert haben.

56:03.360 --> 56:08.480
Weiter am Ball bleiben und sich für eine Verbesserung in dem Bereich weiter einsetzen.

56:08.580 --> 56:10.700
Dann werden wir eine sicherere Welt bekommen.

56:11.400 --> 56:14.040
In diesem Sinne dann auch noch eine schöne Advents- und Weihnachtszeit.

56:14.780 --> 56:16.600
Alles Gute und vielen Dank fürs Dabeisein.

56:20.540 --> 56:21.640
Vielen Dank.

56:27.240 --> 56:57.220
Vielen Dank.