 Hello Okay, so This talk will be about implementing provably secure detection of direct injection attacks Which we will define what that is and it's by me Constantinobotropus Ashininele, Raphael Strosky, Aviv Weinstock and Vasile Sikas Okay, so what is direct injection attacks and it's pretty simple you can think of it as a write-only direct memory access or directly overriding RAM and It's a causal attacks that includes some pretty realistic cases. So for example if this room were to be set on fire come Mountainously then your computer will probably have some bit flips which can be exploited Although I would say that probably heat lamps is the safer option Another obvious scenario would be you know, for example, if we had a nuclear fallout You know, there will be some memory errors, but of course actually in one of the papers we read cosmic rays was Also recommended not sure where you would get that but you know But probably the more normal I guess Attack would be exploiting hardware that have this DMA feature for example network cards So in 2016 Lipton-Astrosky and Sikas had this pretty simple Solution so let's say you have program P What you do is you chop it up into blocks and you turn it into program P prime which is basically P but with all these tags between them and You can think of these tags like stack canaries, but you know for cryptographers who are very paranoid and for example if the Adversary were to inject in block one tag one has a Mac which can check and it will catch this injection and if the adversary were really clever and Basically overrides blocks 3 and tags 3 such that the Mac verifies then there is the attestation Process where the tags can be checked for that that it's a correct So what we're doing is basically we're implementing this clearly theoretical Solution and we're using you know x86 architecture and we're actually proving security with Cache which was not done in the 2016 Solution and what we're doing is we're also formalizing what assumptions we can make on ASCBC so that it can be used as a Mac and it's the name is The length of the name is to be desired But you know currently it's called strong randomness extractor against bit-facing attacks or Sribafa I guess and there's some more things, but you know we're working on and this a Picture here is basically our benchmark and As you can see here, I mean my mom be able to see the The words here might be a little bit small, but basically as the x-axis is the cache size So as cache size grows larger The overhead the performance overhead of this protection actually drops down such that it actually is very close to the original program And that's it. Thank you