 Hello everyone, my name is Michael Eichle and I quickly introduce the Article Dynamic Local Searchable Symmetric Encryption or SSE for short that I wrote with Prismino, my supervisor. Even though this is only a short video abstract, in the beginning I will quickly recap searchable symmetric encryption, so the definition and the main motivation behind it. Then I will talk about memory efficiency and the two variants, so locality and page efficiency, and then lastly I will recap our results. The first result we obtain is the definition and analysis of a weighted variant of two choice, which is a very classical balls into bins problem. Then we use this variant in order to construct memory efficient dynamic SSE schemes, which are the first of its kind, and have very good efficiency guarantees. And lastly I will quickly recap the connection that we drew between locality and page efficiency. The main goal behind searchable symmetric encryption is to outsource confidential information. So assume for example we have a lot of documents such as medical information, emails, or police records, all of which are identified via IDs, and we need to outsource this information because we might not have enough space locally. So in order to do this, generally we can just encrypt our data and put it on the server, but of course this is not very satisfying because if we just encrypt it without any preparation, then if we later on want to retrieve information we would have to download the entire block of encrypted data because otherwise there is no guarantee of efficient interaction with our data. And this is where searchable symmetric encryption comes in because it allows us to first encrypt our data and then later on efficiently interact with it in the form of SQLI queries. In this work we specifically looked at keyword queries where we first supply a keyword and then expect to retrieve the identifiers that match this keyword. So given COVID I expect to retrieve ID1 and ID3 which are the identifiers of all the documents that match the keyword COVID. So essentially the reverse index is a set of pairs of keywords and identifier lists drawn as such. And in SSE we now try to encrypt the reverse index such that we first of all can store the encrypted identifier lists on the server and also efficiently retrieve them if we supply an access token here drawn as squares. In action we can use the setup of SSE to encrypt our data, then we can move the encrypted database to the server and delete all our information locally because now of course the server holds our information permanently and then later on we can still interact with our data by supplying for example search queries where we give the access token to the server for a given keyword and then we can retrieve the matching identifiers for this keyword. In this work we also look at update queries where we can supply update tokens in order to add or remove identifiers. Here for example the blue update token allows us to add the pink identifier to the blue list and then later on if we were to search the blue list again we would expect to also retrieve the pink identifier in addition to the blue identifiers. And of course because we provide confidential information we want to ensure that the server learns as little information as possible. So even though the server might be an honest but curious snake that tries to learn as much information as possible about the confidential data that we provided we want to provably ensure that not much information can be learned. And if you're curious about how we quantify not much then I will refer you to the main talk at crypto where I will talk a bit more about the leakage of our schemes. Now that we know what SSE is I will quickly recap the main notions of efficiency of SSE. The first notion is locality which is important for HDDs so if you were to store your encrypted data on HDDs and the second notion is page efficiency which is important if you store your data on SSDs and in this work we basically construct efficient SSE schemes for both notions of efficiency. In more detail we first define the allocation scheme layer 2 choice which is basically a variant of standard 2 choice that also works with weighted items and has all these standard bounds we know and love from 2 choice. Then we define layer SSE which is basically a very straightforward construction of a page efficient dynamic SSE scheme given layer 2 choice and based on the layer 2 choice standard bounds we here get O tilde of log log n over p page efficiency where n is the number of items in the database and p is the page size. Then we define the generic local transform which draws a connection between page efficiency and locality and allows us to build a local scheme given a page efficient scheme. And using this generic local transform applying it on layered SSE we obtain a local dynamic SSE scheme that again has all tilde of log log n re-deficiency. Here it is important to note that the maximal list size is bounded similar to other comparable local SSE schemes. Lastly we define unconfined SSE which does not have this restriction. More concretely it is a static SSE scheme with all of log to the power of epsilon n re-deficiency where epsilon is any constant bigger than zero. So I hope I got you interested in our results and in our schemes and if you are interested in any of the constructions then I invite you to come to my talk and I hope we see each other at crypto.