Introduction to Secure Multiparty Computation with Yehuda Lindell

[00:00:00]so okay so let's start with what is npc or what is multi-party computation uh uh so uh mpc is a uh uh it's a world research software photography really in the late 80s mid to late 80s that began this research around this question there's been thousands literally thousands of research papers but it was purely theoretical until recently so it depends how you define recent but you know in 2010 or about 10 years ago there was almost there was very little you could really do practically they were they were very powerful feasibility results a lot of beautiful research but it wasn't something that you could really think about deploying and then there was over the last decade there's been a very significant research effort to make mpc uh efficient enough to use in practice and and now actually we can and this is actually being deployed and i'll talk about some of that today so it's it's a it's very active in terms of the applied area of research but also now in commercialization efforts and the idea behind npc is very simple we want to compute on private data without revealing anything and that's all we want to do can we actually carry out these private computations the difference between something like fully homogeneous encryption is that npc uses interaction so we have these parties interacting and we want to compute without revealing our private data so let's just start off with a simple toy example just so that we can get an understanding of the type of things that we're doing it's really a very it's really a toy example um but i think it's nice so we have three cryptographers who want to compute the average of their salaries uh but they don't want to reveal it their salary to anybody else if you can see the numbers here in the slide the salaries are so low that they really just don't want anybody else to know uh that as cryptographers with phds this is all they're earning so how can they essentially compute this without somehow giving their values to someone else uh and and actually it seems to be problematic because you have uh you want to essentially just add the numbers together right the average and the sum are the same up to multiplying or dividing by three so they want to add these numbers together but without anybody seeing anything so how can you add numbers without knowing what you're looking at so alice starts and she chooses a very large random number for example 652 1995 and she adds that to her salary and sends the result to bob so bob gets 772 1995.

[00:02:45]now bob uh gets this number and the first thing you should think about is that this doesn't really reveal very much about alice's salary and in particular maybe alice earns a hundred thousand dollars but she chose a different number she chose 672 1995. so the fact that uh um the fact that uh he got this value doesn't reveal alice's salary the next thing what that bob does bob takes that number and adds his salary to it and sends it to eve so now bob adds 105 000 and sends 877 195 to even eve once again doesn't really know anything at all uh because she just gets this number and she doesn't know what that big random number was in the beginning eve then adds her salary to that and sends it back to alice so alice now gets 942 1995 and alice can subtract the initial random number that she used and divided by three so now it's uh ninety six thousand uh ninety six thousand six hundred sixty six is the result and that indeed is the average salary of the three cryptographers uh it's it's clear that uh bob and uh um eve did not learn anything by what we said but uh what about alice so with alice the way you should think of it is all she really got to see was the sum of all three salaries and that's actually what she's supposed to learn so she knows nothing about the the you know the the bob and eve salary and which one is higher or lower this is something that she cannot learn any information about whatsoever so this is a protocol that's secure as long as the most one you know one out of the three cryptographies is corrupted well if two are corrupted that doesn't matter because the average would reveal the third so it doesn't make a difference anyway so when so that's just a toy example but what do we mean when we talk about mpc and npc security we really want a computation amongst a set of parties uh who want to join you know some joint function whatever they want to compute while ensuring two main properties they're actually more but these are the two most important ones the first is privacy which tells us that nothing but the output is learned so you should learn the average of the salaries but you shouldn't learn anything beyond that and and it's important to note that the average of the salaries actually reveal some information about the service right so if uh alice earns 120 000 and she sees that the average salary is 96 000 then she knows for sure that at least one of bob and eve earn less than her but that's something which is revealed by the output and the output is what we're supposed to compute but you shouldn't reveal anything beyond that the second thing is that the output should be correct it shouldn't be possible to somehow compute something which is incorrect you could think about an auction or an election say an election you wouldn't want the candidate who got the minority to come out as the winner because that well in most countries you wouldn't want that so that uh is uh uh the correctness of the function being computed as well and and all of these should be guaranteed even if some other parties are cheating are behaving as adversaries and that's the basic security properties that you want when we talk about adversarial behavior though there are two uh possible uh or two main models there are more but two main models the first is what we call a semi honest model and here essentially the adversary is running the correct software um but they should not be able to learn anything by looking at the transcript of what's being said so actually what they see they can look at everything that's being sent and received and they they shouldn't be able to learn anything from that but but we trust that they're running their correct software uh why would you know what what would that model that may model situations like two hospitals wanting to collaborate no one thinks that one hospital is going to try to steal the private information from the other hospital but for regulatory reasons they're not allowed to pull their health data so they could think about a a semi-honest a model where essentially they trust each other they're just not allowed to reveal anything and indeed seminar security models something what we would call inadvertent leakage you know for sure that nothing about your information is being leaked and you don't have to worry about someone else learning something about your confidential information but in general we what we do want to think about stronger security models and then we talk about malicious adversaries so this is an adversary who can run any software they can run anything that they want they know the protocols and design and they still should not be able to learn anything so this is the more classical type of adversary we have a set of 50 people they want to compute statistics on their salaries and they even if some of those subset of those collude together to attack the protocol and they run some specific code which is written just to attack the protocol and learn more information we have a proof of security that that's impossible to do and there are two main settings also in terms of the corruption we can talk about if the adversary can corrupt any number of parties so it could corrupt all but one and that last party should still have security guarantee uh depending on what the function is and or we can talk about something called an honest majority where we assume that they can only the attacker can only corrupt up to or less than half of the parties the uh um there are some variants on that as well but typically obviously a dishonest majority model is better because you get resilience and security against more corruptions but it's also more expensive so it sometimes can be a trade-off there are cases where you can accept an honest majority and then uh depending on your threat modeling and then that gives you more efficient protocols and of course uh like with anything that's in you know the rigorous uh cryptograph cryptographic uh methodology we mathematically approve security against a mathematically rigorous definition so how would you how would we define how can we define this notion of security for mpc and it's actually not that easy because in encryption we say something very simple if you see encrypted data you learn nothing except for maybe the length of the message and it's not that difficult to model learning nothing although it's also not that easy the first definition of security for encryption was only in 1984 but we can model this notion of not learning anything but here you are learning something you're learning uh your input you're learning the output sorry and not only that that output depends on your input so what so and you could be a corrupted party providing input so this becomes very messy to try and define and and and the way we define it is by thinking about what would the ideal situation be now we all live in our modern world and i guess we can all agree that our world is our real world is not ideal uh so this is just a a uh uh sort of a mental experiment uh in order to define security so let's think about what the ideal situation we're here we have alice and bob and they want to carry out a computation and ideally there is a trusted and incorruptable third party that every that that they trust and and really cannot be corrupted and if such an entity existed in the world and couldn't be corrupted then the parties could just send their inputs to that trusted party over perfectly secure communication channels which also don't exist but it's part of our mental experiment that trusted party can compute the output and just send it back to both parties right this would be a great world if we had trust in the world we would be able to solve our private computing problems very very well right very easy send your input to this trusted party they do the computation and they give you back the output now just to understand and appreciate why this really does make sense we talked about privacy and correctness well clearly in this ideal world the parties learn nothing but their output because that's all they saw they gave an input and they got back their output okay that's uh they can't learn anything beyond it because they there was nothing else that they saw and correctness is also clear because this incorruptible trusted third party uh computes the function correctly because they're trusted and they're honest and that means that we um now we have a guarantee of correctness as well so in this ideal world our basic properties are are preserved they're actually more independent of imports and we can talk about in some settings things called fairness and guaranteed output delivery but i don't want to complicate this more more than i already have to so in the real world unfortunately we don't have trusted parties either because there's no one that we all trust or more importantly even if we do trust even if we all do trust rand we don't know that nigel won't break into rand's computer and therefore be able to to result in you know to steal information so trust is not just uh understanding that somebody is uh not a malicious person it's also understanding that nobody um nobody else can breach it's accepting that nobody can breach them and since everybody is breachable we don't have any trusted party in the world so in the real world the parties just interact with each other they send messages to each other and they get some output at the end of the protocol and the definition of security for mpc is that an npc protocol must behave like an ideal world protocol in the id world protocol you just sent your input and got your output and what that means is that an attacker can't do any more in this uh our real interaction in its real world than it could in the ideal world and because in the ideal world the only thing you can do is choose your own input and then get back the output that means in the real protocol the most you can cheat is just to choose your own input and arguably at least in many scenarios you're allowed to choose your own input right to when you're voting you're allowed to choose who you want to vote for when you're in an auction you're allowed to choose the amount of money you want to beat for that product but it does mean that if uh we're comparing our dna to see if we're related then we have to understand uh do i have any interest in changing my my input so for example a nigel is giving away a million dollars to his uh he he knows he has a long lost second cousin and there are uh actually algorithms you can run to compare dna to see if people are related and i tell nigel i'm your long lost second cousin and here let's run an npc on our dna in order for me to prove that to you right because i don't want to give up my dna obviously so i would actually have an interest in maybe changing my dna because i want the result to be that i am that long-lost cousin and getting idles million dollars so sometimes you know just the issue of input choosing your input can be an issue in many cases though that's just allowed and uh and so it's fine so what are the definitional advantages and this is i think a really important slide uh when we think about this ideal world this enables us to use mpc without being a cryptographer you don't need to care at all how this mpc protocol works because all you need to do is to build your application assuming you have a trusted party so you just assume you have this secure black box that you can send your input to get back in output now build a security application right so you were building an application for i don't know whatever it is whatever your application happens to be whether it's a uh um related to to health or or finance or or security it doesn't matter what the application is and you can just think about you can abstract out this mpc component as a secure black box and then uh as long as your application is secure using uh this black box then once you replace the black box with an interactive mpc protocol you know that everything remains the same so that's really really helpful for security professionals or computer scientists and software engineers who don't you know don't know npr are not cryptographers if you're given an mpc protocol that suits your needs that's also a challenge right building the mpc protocol is is still needs to be done if you're given that then you know how to use it and that's important to understand a couple of words of warning firstly npc talks about the process of computation but not the function itself so npc tells you that nothing is learned by any of the parties by any address any adversarial coalition um nothing is learned except the result of the function but uh so the process reveals nothing you only get the output but it doesn't mean that the output itself is okay to reveal for example if rand and i ran a secure computation to learn the average of our two salaries then i know rand salary because i if i know my salary and the average i can compute rand salary and that means that this as a function reveals all the input it's not an interesting function to compute right so so in some cases you have to analyze if you're using npc to do statistics other statistics that we're revealing okay and if they're not or if there's a concern then you need to use other tools like differential privacy but that can be actually combined so mpc combined with differential privacy actually can have a lot of advantages in terms of the noise you introduce so if there are questions about the function that has to be dealt with independently mpc doesn't talk about whether the output itself is is valid to reveal or not it just reveals the output and that's important to know uh you know so average decides the problem but if you're an npc of cryptographic functions you know so one party has the key and the other import or the key is split then by definition the output of the cryptographic function doesn't reveal anything that it shouldn't because that's what the crypto record function is supposed to do so there are cases where it's very easy to understand that it's okay and there are cases where it's easy to understand that it's not okay and then there's the whole middle area that you have to really analyze with your application in many cases what people will say is you know what i have to compute this output and it's either i do it privately or not privately so in any case i'm improving the situation so we're okay is that legitimate or not i think that's more for the uh privacy researchers and philosophers than it is is for me to say the second word of warning as i mentioned is the parties can choose their own inputs and if it's a problem you need to work that out into the definition so if for example our parties they're inputting their salaries and we think that somebody can skew it by putting in an incorrect salary and we want to prevent that then we should somehow uh get a signed assigned salary and verify signatures or something like that within the mpc protocol sometimes that's easy and sometimes it's not again with uh in many cases you can do a game theoretic analysis where you say it's okay [Music] it's okay to change if someone changes their input that's actually not going to be in their interest because they won't get the utility so we accept that that risk okay so how does mpc work i will start with a fun problem we have a guy and a girl and they want to check if they're if they're interested in going out okay so it's the uh um the problem is that they're uh embarrassed to ask each other that one one is uh you know if you know if i ask a girl out and she says no then afterwards i'm embarrassed to see her and if i'm in a work scenario situation it's even worse because i have to come into work the next day and she's next to me and i'm worried that i'm going to be embarrassed so i think that a while ago i saw that slack there was some slack plug-in that someone had built that you could say if you like someone in the organization you could ascend that and if ever if they that other person said you then you would both get messages hey you two like each other that's done without mpc and so that information sits somewhere i'm not sure that's a very good idea but let's run it by mpc so let's assume that everyone in class is going to pairwise check if they both say yes then they get told yes and if at least one of them is not then the output is not now you it might be confusing uh you know if i said yes and someone else said no so i'm asking nigel i'm doing this with nigel and i say yes i want to go on a date with nigel nigel says no you might think okay but i sh you know i know that i said yes and so therefore i know that nigel said no so what privacy has been preserved the answer is that nigel doesn't know that i say he said yes right nigel sees no and he thinks okay yohoda probably also said no uh so we both said no i i don't lose any face in term with nigel on this so here's the way we can do this with cards alice and bob each get two cards a king and an ace and if alice this won't make sense to the end so just bear with me so if alice likes bob she puts the king first and the ace afterwards and if not she puts the a's first and the king afterwards and bob does the exact reverse so if he likes alice he puts ace then king and otherwise king banks then they put their cards on the table face down so alice can't see what the order that bob put and bob can't see the order that alice put and they put an ace in the middle okay now let's have a look at the possible configurations if alice and bob like each other then alice likes bob so it's king ace and bob likes alice so it's ace king that means we have three aces in a row but in any other situation if either they both don't like each other or one doesn't like the other we have these other three configurations that you can see and if you look at all of these three configurations they're actually identical up to a rotate so they all have ace king two aces and a king just up to a rotate so the last one which is ace king ace king ace those two ace at the end are actually next to each other if you rotate the cards and so what they actually do the parties turn over that middle ace and then randomly rotate so alice takes the five cards and randomly cuts and bob does the same thing and they open it up and they see that if they have if they have the uh um three aces in a row up to rotation then they both said yes they go out on a date and if they don't then they have no idea you know if they both said no or one said no that remains completely private for the computer scientists amongst us what we've actually done here is compute an and gate and that's a sign we know that we can build any you know compute any function from an extor gate for example so here you can do an and go with cards and you can compose and gates so that will give a hint to what we're going to do later on okay so in the in the 80s and 90s there were a lot of very powerful feasibility theorems proven for mpc which basically say that you can actually compute any function that you want so for any number of parties any function that's obviously can be computed in polynomial time you can also compute an npc so we could in theory run sql queries on a database that's encrypted or say database that's split or data that is split amongst multiple parties um we can do that without ever bringing the data together and this could be it doesn't matter what that what the size of the database is of course it doesn't mean that it's very efficient and we'll get to that later on but in theory it can be done and we'll talk now later about how it can be done efficiently and and the question is you know how can you make a theorem how can you prove an argument that you can securely include anything anything means anything well that's the advantage of you know the the foundations of theoretical computer science we know that we can represent any function as a boolean or an arithmetic circuit so we have different basic gates and then we can show how we can compute any circuit like that in mpc and that means that we can argue that you can compute anything and this will be very important so we'll come back to it later on it might sound this this can never be even remotely efficient but i'll come back to that as well later on so i want to talk about a specific construction called the owls gobbled circuits and it's a it's uh probably the most technical part we're going to talk about but it actually is if you bear with me you'll see that it it makes sense and it doesn't require anything uh are too um too overwhelming so we take an and gate with uh input wise uv and output y is w just so what does an and the and gate does it maps uh our pairs of bits to an output so 0 0 0 1 and 1 0 all go to zero but if both of the inputs are one then we get one and in the output and this is a single boolean gate and we want to show how we can somehow encrypt that gate and yet still be able to compute it okay so the first thing that i do is i replace the zeros and the ones with random values that represent zero on one okay so uh the u wire i choose k u 0 and k u1 which is two random values two you know random cryptographic keys for example 128 bits long and then i write instead of the u instead of zero value i write k zero and the one okay you want to do the same for v and w so you can see that this is exactly the same as an and gate but instead of writing zero and one i'm just writing these long random values instead now if i would randomly permute the rows in this table i would argue you would still know what the values are and the reason why you would know the values is because in the third column the value zero appears three times and that means that you know that that is the zero value whereas kw1 is the one value because you know it's an and gate and once he knows what's the zero and the one you would know also in the u and the v so i couldn't give this table to someone and say here's a gobbled gate that you don't know you know what the 0 and 1 values are but i could do instead is i could encrypt doubly encrypt each value so i can take k z k w 0 and doubly encrypted under k v 0 and k u 0 and likewise and the k v 1 and k u 0 and k u 1 and k v 0 and i could encrypt the one value for the w under ku1 and kv1 and i could permute these in random order and if i give you these four ciphertexts in random order you actually know nothing because these are just encryptions you can't you don't know which value appears more or less because you just see ciphertext so it's all hidden but the important thing is if i was to give you one key on each input wire and i'll demonstrate this next in the next slide so it'll make more sense but if i was to give you one key on each input wire so i give you k u 0 and k v 1 you could try to decrypt the first ciphertext and you'd fail because you don't have kv-0 you will try to encrypt the second ciphertext well you would succeed and you get kw zero back but you actually don't know at all what you've computed because i gave you two random values and you managed to get a third random value by decrypting but you actually don't know what you did so you obliviously computed this and gate without knowing at all what you've computed and that's the really powerful notion of of of gobbling a circuit and these keys on these input wires and we call them garbled inputs as well so let's see uh what we can do how we can build that into something a bigger picture so i've taken a circuit now with two and gates and one or gate and the first thing i do is i randomly assign a pair of values i assign a pair of random values sorry to each wire in the circuit okay so each circuit here this is uh this y is the a wire i assign k a zero and k a one and so forth so so on and so forth for all of the y's in the circuit and then i just build the table from the previous slide for each of these gates okay so the first and gate i just build exactly these these four encryptions where i'm encrypting the e values because they're the output wires with the two input wires exactly as you saw on the previous slide and then i do the same thing for this and gate i'm going to encrypting the uh f the f random values with the a and the e ones exactly exactly the same that's over here and then final then i finally for the or gate i do the same thing i'm encrypting the g uh random values using the e and the d here it's an or gate so notice that kg1 appears three times because it's an or gate and not an ended okay so i give you i cannot give you these three uh um gobble gates these three tables essentially are encryptions of each gate and they also give you what we call an output translation table so give you something enables you to go from the random values at the end to the real values so here i tell you okay if you've got sorry excuse me apologies uh so if you get kf0 in output you'll be able to look at this pair here and know that that actually means zero because it's somewhere you need to get the real output in the end okay so this is a garbled circuit and now i want to show you how you can actually use this to compute so let's say i have input 0 1 0 1 and i want to give it to somebody else to compute this circuit without knowing anything that they've done except for the output okay so this is the input i give them the garbled circuit which is the three tables for the gates and the two output translation tables and then i also give them gobbled values on the input wires i give them ka0 kb1 kc 0 and kd1 okay so give them these values and i have these encryptions okay and we don't need to go into the exact definition of the encryption the encryption just think of it as a black box for now it really works in this way in this construction and so they have these values and what they can now do is go gate by gate and compute so the first gate in the top electrical order of the circuit is this and gate so they have kb1 and kc0 and they can go to the first table and they find that it decrypts the third row of course as i mentioned these are all permitted orders so the order doesn't reveal anything but for the sake of this demonstration i'm leaving them in the correct order so they go and they manage to decrypt this first third value and once they do that they now have k 0 e as the result which makes sense because they had a 1 and zero on the input so they get k zero e the next they can now go ahead and compute the net sorry they can now go ahead and compute the next and gate using a and e so this and gate over here and how do they do that in the same way they can take k a0 and k e0 and they find that they decrypt this first ciphertext and they get kf0 as output finally they can go to the third gate the or gate they have k0e and kd kd1 they find that that decrypts the second value which gives them k1g and then they can now finally take k0f and kg k1g and look at the output translation table and see that they have zero on one for output okay so they'll learn that the output is zero one and what i what i'm going to argue now is that there could actually be multiple inputs for this because it could be 0 1 0 1 but it could also be 1 0 0 1 would give the same output as would 1 1 0 1 would give the same output or 0 1 1 1 would give the same output in fact there are many different outputs so there are very many many different inputs that give the same output and you computed this circuit you got the output you didn't learn anything else and that's exactly what we want in mpc okay so i hope that that makes sense made sense that's the most technical part of the talk so i hope it made sense to everybody but now i want to build from that an actual mpc protocol with multiple parties so i want to show you a three-party protocol that is secure as long as almost one of them is corrupted it's a malicious party they can try to cheat however they want okay so party p1 is this server over here has input x party p2 is this server over here as input y and party p3 has no input we call them an auxiliary party they're there to help okay and it's going to be secure as long as at most one is malicious so nobody has to trust anybody else but we're assuming that no two will collude together okay as long as that doesn't happen this is exactly honest majority setting we talked about so how does this work the first thing this gobbled circuit needs a lot of randomness so the two parties choose a seed for a pseudo-atom generator basically generate a lot of randomness so they can both build the same gobbled circuit because it's just randomness so if they have the same random seed they'll generate the same goggle circuit and then the first party will generate the garbled input that relates to his value because that's just choosing you know is a ka0 or ka1 is it kb 0 or kb1 depending on the bits of x and the second server does the same thing for y and they send all of this to this third server here so this third server the third party receives the goblet circuit from both and the garbled input related to their to the respective inputs the reason why we send uh both the governor circuit from both is because one real problem when using double circuits is that because it's encrypted you actually have no idea what function it computes so you might think you're computing one function but really compute something else and that would be a huge problem but if both p1 and p2 are sending the global circuit then p3 just checks it's the same and if it's the same then it knows that at least one of p1 and p2 are honest and that means that it knows it's the correct gobbled circuit so to say the other party who's corrupted cannot send anything but the valid garbled circuit or else it will be detected once this third party has the garbled circuit verifies that they're same they have the inputs in exactly the same way as we showed in the previous slide they're able to compute the gobbled circuit and get the output and send it back and i can send it back in a way so they can't change the output either so this is a real this is a an npc protocol for three parties it's secure against malicious adversary corrupting one party because nobody can do anything that they're not allowed to do by the validation of the goblet circuit and the third party just has encrypted values can't do anything except to compute the circuit it can't change anything because it doesn't know anything else to do and we can of course prove that formally but uh um just take my word for it for now um another i just want to stress this is a simple protocol there exists also protocol for two parties uh the secret gets one corrupted there are protocols against um for that can involve many parties and uh will be secure even if a dishonest majority if there's a dishonest majority but this is the protocol that i'll show here okay so that's it that's doing for general c computation what about specific tasks because sometimes we can use certain properties uh you know that protocol talked about very something very generic which is uh you know um mpc of uh of a circuit so it can be used to represent any function i'll show you later on that that's really important in practice but sometimes we also have very specific tasks we want to solve and then we can do different things the first thing i want to talk about is threshold cryptography which is to compute a cryptographic function without any single party holding the key so i'm going to split a key amongst parties and i require uh them all to agree in order to carry out the operation why would i want to do that number one i'm going to make it hard to steal the key because the key isn't sitting in any single place that i can breach and go and steal it and the second thing is i would like to maybe for very sensitive operations require a quorum to authorize it uh you know signing on bank transactions or more recently if you followed the solar winds the massive solarwinds saga what happened there is it is the uh attackers managed to get a legitimate signature for a code signing key on malware that they then pushed out as a software update and were able to go and breach thousands of networks and and uh organizations and us government organizations a huge breach but it was caused by managing to use a key uh maliciously but in order to sign on code you would need a quorum of parties to agree to it and they would know that you know they would verify that indeed there is an update and what the update is and so on and so forth you would very much mitigate that sort of attack okay so how can we do this let's look at rsa okay it's the rsa function and it doesn't matter if you're familiar or not familiar what all you need to know is that the rsa private operation for signing or decryption is taking a value y which is derived from a message or a ciphertext and raising it to the power of d where d is a secret value now there is also mod n and there are but let you can just ignore all of the modular operations what i'm going to talk about now so the secret operation is y to the power of d and this value d is the secret that we want to protect so first i can just share this simply between two parties two servers s one miss two uh by making choosing d1 and d2 at random so they sum to d okay so s1 can choose a random d1 and s2 just sets it to be d minus d1 again i'm ignoring the mod you can just ignore all the mod so we have d1 and d2 so d1 plus d2 equals d and the important thing is that if all you have is d1 that's server s1 then it reveals nothing about d because it's just random and d2 also reveals nothing about d because because uh a d1 actually completely hides d okay so cs2 has d minus d1 it's like a one-time pad right d2 actually uh if you're just given d2 you know nothing so neither s1 or s2 knows anything about the secret key d so recall that s1 sd1 is 2 sd2 and they sum to d and they want to compute this private operation of y to the power of d and they need to do that without anybody learning anything about about d itself this seems to be difficult but actually it's very easy because raising to the power of something has a very nice algebraic property so s2 just computes y to the power of d2 and sends it to s1 s1 computes y to the power of d1 so they only do local operations and then s1 can multiply these together and the algebraic operation that we're looking at is when you multiply two values together that were computed by raising the same base to different exponents you just add the exponent okay so z1 times z2 is y to the d1 times y d2 which is just y to the power of d1 plus d2 and that equals y to the power of d okay so in the end they get the result but they didn't reveal anything about d1 or d2 to each other and also by s1 verifying there's a wave you know rsa sorry is an easy invertible function so you can actually compute back and check you got the correct thing but i don't want to go into all those details now we can prove formally that uh this reveals nothing beyond the result but again intuitively you can understand why because d1 and d2 are never revealed to each other and then you can build a protocol from this for uh you know type of uh uh you know doing rsa operations without keeping the key in any single place that can install it maybe you want to do this for for tls or you want to do this for code signing so a client will send a hash message as part of a code signing operation for example and the uh they'll just run this protocol the second server will compute a wider power of d2 similar to the first server the first server it could be y to d1 and multiply together and send back the result so this could give you like a a software type of hsm hybrid security module that can run in the cloud or between clouds or between environments so that the key is never in any place to be stolen and that gives you a a very very simple mpc protocol but there's something also called proactive security and proactive security is an ocean npc which tells you that i'm concerned that yeah okay so you split this key d into two places but maybe i'll corrupt one machine today and it'll take me two months to get to the other machine but i'll get there eventually and then i'll steal that part and eventually have d1 and d2 and i can add them together so what we can actually do is we change the sharing so the attacker has to essentially breach both machines at the same time in the same interval for example in the same hour so how do we do that the servers run a coin tossing protocol to get a random value r that's a very simple npc protocol i won't go into how they do that but they get a random value r that needs to can influence and the first party just adds r to their share the second party subtracts r from their share and obviously d1 prime plus d2 prime equals d because you just added r and subtracted r so it cancels out but if an attacker steals d1 because they broke into the first machine and two hours later when they're long no longer on the first machine they're in the second machine and they get d2 prime then all they get is d1 and d2 prime and that reveals nothing whatsoever about d because that value r again hides uh is like a one-time pad and hides the value of the secret key so this notion of proactive security is a very powerful one it means you can have these long-lived npc systems where the keys are or where the secrets in general are protected on an ongoing basis it's possible to do other threshold cryptography you can do ecdh and ecdsa and schnoor and edsa and key generation because and they mostly have nice algebraic structures so we can build uh dedicated protocols but there are a lot of cryptography which has no structure like aes and hmac and and you know what can you do in those circumstances right because it's just strange you know there's no structure at all and the answer is that you can use the gobbled circuits method that i showed you beforehand there are other methods as well but just as an example and because they can compute any function you can use it to compute these as well so you can protect aes keys and hmac keys in exactly the same way as what we do for rsa and this might but you might ask okay but this is going to be really expensive right aes has 31 000 gates 6400 and gates and 25 000 xor gates there have been many many optimizations we can make extra gates essentially free we could do and gates more efficiently than i showed you um so it can take you know half a millisecond to gobble and evaluate an as circuit and actually just so to just to understand uh we can do uh on on you know not powerful machines on just the very this quite simple four core 10 gigabit machines in in azure for example we're going to do 500 aes gcm operations with aes 256 for on a 32-bit input so that's for like a key wrap operation so this is a very important operation and all of that all the communication generating these gobbled circuits evaluating them sending back and forth we get a throughput of 500 per second so this really is efficient uh enough to use and and and achieves high performance so that that is important to know let's look at another uh concrete example private set intersection so we have alice and bob they have sets a and b and i want to compute the intersection for example uh um i join signal and i want to know who else here is on signal it wouldn't it be great if we didn't uh set intersection pro uh protocol where we would see that uh i would be able to learn that nigel so so the so signal holds this uh um list of uh contacts and only those who in my contact list who are in their contact list i would i would learn about so that means the signal wouldn't learn people in my contact list who aren't signal members and i wouldn't learn anyone who's on signal that's not in my list a signal doesn't do a secure priority section protocol they use just simple hashing and inside they use sgx but that is not a secure npc protocol i won't go into why uh the problem has many solutions uh and there's been a lot of work done and i'll show a very conceptually conceptually simple one here for semi-honest advertisers and the tool that i'm going to use is something called oblivious pseudo-random function evaluation and the pseudorandom function is just a function that given input outputs something which looks rat like random garbage and not connected to the input and this tool is an npc protocol where alice inputs a key k for the function bob inputs in their value b and alice will learn nothing while bob will learn the function on b with that key okay so bob will learn this pseudorandom output which looks like complete garbage and alice will learn nothing uh concretely this could be aes or a surround function based on elliptic curves let's just think for now that it's aes so just like a block cipher alice has the key bob has the input and bob gets the output and alice learns nothing there's a type of you know basic encryption primitive so alice has uh this input her input set a1 through a n bob has his input set of b1 through to bm and they want to compute the intersection the first step is for alice to choose a random key for this evaluation and for them to run many uh executions of this oblivious aes evaluation this by the way could be done using the same protocol that we used beforehand if there was a third party or it could use a different protocol it doesn't matter but using some mpc protocol they can run this where alice inputs k bob inputs the i input bi and gets back y i and then bob at the end will get you know we'll have the outputs for all of his inputs y1 through ym alice will then locally compute the aes function on her inputs okay so locally compute x1 through xm which is aes on all of her a values and we'll send them to bob and bob will get this list x1 through xn which are just aes encrypted values of a so actually bob doesn't know anything about the a values because by the security of aes and by the fact that alice chose the random key and bob knows nothing about it he learns nothing about alice's inputs but what bob can do is compare which values did he get that are in alice's list so bob can look for values where y i appears in alice's list and if y i appears in alice's list that means that bob's bi actually equals some aj in other words it's a value in the intersection and he can just add then no oh okay y i is in alice's list so therefore i know that bi is in the intersection and he can send back also he get output and send it back downs this is only secure for semi honest adversaries you need to add more for militias but but i think it really demonstrates that it can be done very simply and very efficiently um you can just run these computations in the end you can compute the intersection without revealing anything more and i'll show you uh real-world uses of that in a moment okay so to sum up i wanna we've talked about what mpc is we've talked about techniques um and now we'll talk about actually using this in practice so uh anybody who lost many techniques that's absolutely fine because now we just talk about the use cases in in practice today and in practice i mean in production these are things that organizations are actually using okay so advertising conversion for google so the problem that google wants to solve is as follows i get an advertisement to buy a bmw on my mobile phone don't worry google is smart enough not to show me any such advertisements so uh but but you know if i had a lot more money maybe i would get advertisements to buy a bmw and and you know when i'm looking at my newspaper on my phone and the question is how can google determine or and and bmw how can i determine the effectiveness of that advertisement right it's not like if i'm showing an advertisement for something that i can buy on my phone then i'll see okay so you would have shown this advertisement for a um you know a set of headphones and he bought it online and therefore we know we can we can correlate the fact that i was showing the advertisements the fact that i actually bought that um but if it's a bmw no one buys a bmw from the phone i saw the advertisement and then i went into the dealership and that's completely not connected to the fact that i was shown new advertisement so how can we do this the solution is we can compute how many people were shown the ad on their cell phone and we can compute how many people who were shown that ad actually bought a bmw so if i could have the list of everybody's the phone numbers of everybody's cell phone who was shown the ad and i could look at the list of the phone number of everybody who bought a bmw that's the information that bmw has and the first list is the information that google has then i can call that and see the conversion percentage from being shown an ad to buying a bmw you also want to normalize this by what's the expected what you know what what would be the the expected chance i would buy a bmw if i wasn't showing the advertisement but let's leave that normalization out now this is a classic but the problem is that that google and bmw don't want to share their list this is a significant privacy concern well the whole thing is a privacy concerning google but this is even bigger privacy consumers going outside of google and google actually solves this by using private set intersection they don't actually show the phone number of who appears they use a variant of private settings section which just gives the cardinality or the sum of amounts spent and google actually uses this to truly measure the effectiveness of advertisements and in that way preserves privacy while being able to know how much to charge for showing advertisements to uh you know for for products like a bmw or something like that because that's a real product in in in our production used by google another interesting use case is was done in boston this isn't a commercial use case but it's a what we they're called empire mpc for social good um the boston women's workforce uh no boston's women's work council wanted to run a study on the the wage gap study so they wanted they the wage gap between men and women in different organizations and companies in boston they went to their companies and asked can you give us information and of course they said no it's private information they're probably also worried about the fact that they could be uh you know legally in trouble if they're worse than others and what they actually did is they they managed to build this in conjunction with boston university they would actually be running mpc so actually ran an mpc where the different organizations input information about uh their employees and what whether male female and how much they earn and they managed to get the suggestion where they had over a hundred thousand employees in this study and they could really work out what the wage gap truly was in boston this is a large scale here we're talking you know in 19 2018 there are 125 employers 140 000 employees in the study 12 billion dollars in annual wages and they could see the wage gap between men and women at scale that previously was impossible to actually compute and uh here you can look up the boston wage gap study you'll find a lot of information here's how they're explaining uh how it's done and so this is a very interesting use of mpc for social good and there's been other work on that which is which is really exciting in my opinion duality is a startup company that is using a mixture of mpc and fully homomorphic encryption uh so it's again it's also a type of mpc that in order to to enable different organizations to really share data or at least compute analytics on shared data it's important i want to stress that the main difference again between mpc and foreign encryption is interaction so where you can interact essentially there's no reason not to use npc but there are use cases where flammable encryption is is great because you can just outsource the computation to someone else and just get the result and decrypt that's something that you can't necessarily do with mpc with the mpc uh um you actually need interaction but the state of the art of mpc today is that it's orders of magnitude faster than for them of encryption for the vast majority of use cases i'm not saying that there aren't cases where it changes but but typically that's the case share mind similar model uh to allow organizations to collaborate uh to compute for example they estonia wanted to to correlate tax records and education requires to understand do students to go out to work are they contributing to the fact that more students are failing so do this computation and the result was no the fact that students are going out to work while they're studying is not contributing to their failing um although with my professor had on from my past i think students should focus on their studies but and go to work later but that's completely not related to npc and finally for key protection i mentioned this beforehand this is what unbound does so again splitting keys into two or more pieces using them without ever bringing together and continue refreshing them you can have a uh this this actually a deployment is a real deployment of a large bank in europe that's a customer of unbound uh they're splitting the keys between three pairs of machines uh ep and dp is entry point and partner so that's the pair of parties running an npc computation on keys and they had uh one pair between their on-premise data center and aws a second between aws and azure and the third between azure and and and their on-prem data center so there are application servers in aws azure and on there in their data center that can all access what we call the entry point so they can do the computations and um but the key is the key is not whole in any place because each pair holds an independent sharing of the key an attacker would have to simultaneously breach two completely different environments in order to learn anything again that's a real deployment in in production today i talked about the solarwinds beforehand and this notion of of a quorum authorization and here's where npc can move beyond key theft which is just preventing someone from stealing a key to actually preventing someone from misusing the key okay and and you can do this by setting up you know a flexor you know a quorum so you would need two out of three parties from the r d team and one of the two parties from the legal team in order to sign on code that we pushed out and that and the and the cryptographic key for signing would be split between servers and even maybe these people's mobiles and they would all participate in npc protocol to ensure that that cannot be bypassed even attacker got into the system without breaching a full quorum that is able to authorize they wouldn't be able to get that code signed and that's a powerful paradigm for protection for protecting cryptographic infrastructure another use case of that is you could do two-factor authentication with npc so you'd like to use your mobile for uh um because you carry it everywhere and it can do operations but it's extremely vulnerable it's very insecure but you can build a virtual smart card a one-time password token by sharing the key between the mobile and the server and having the key never on the mobile to be stolen uh again refreshing so that you give things trying to cloning you have auditing that there are a lot of advantages to this model it's very easy to deploy and manage and again the fact that the key isn't actually written on mobile means that you can get strong protection while using a mobile and this is actually also used uh by very very this is in production millions of people are actually accessing their mobile app for their bank by this without knowing it's completely invisible to them so in summary mpc is a mature technology one that's ready for deployments it still requires high expertise to deploy so you need to understand what problems you can solve efficiently you need to tailor protocols to specific needs in some cases there are subtleties in published protocols so a lot of papers on npc will talk about things but they won't ever they won't necessarily say verify that this point that you get is indeed on the elliptic curve but you have to do that so there are a lot of things you need to still understand you know to that transition but there are more and more people out there with that expertise making this a reality and it's being used in production and uh it's getting more and more exposure and as we get that exposure we're learning from the market uh what problems they once sold and and indeed its use and interest in it are actually growing very very fast so thank you very much and i'll be happy to take any questions okay great um that was fantastic thank you very much that was really really good um great so we've got a first question from yan right uh so seems i can't uh share my video anyway thanks for the great presentation um i have a question regarding kind of how to prove that i participated in such an mpc protocol so for instance um i know my input and um after the protocol is run i i also have the output how can i kind of show an independent party that actually um this output originated from my input even without kind of sharing everything and uh also trying to yeah in the best way to to keep my input still private uh is there a way to do that yeah so um you know obviously you know that it's correct because you participate in the product quality for secure against militias adversaries and you have that guarantee once you want to show to someone else there are two possible things to do one is to define that as part of the function that you're computing so you could define a function where the result is the output signed with uh signed with something along with i don't know the identity of all of the uh um participants with a signature key with a signing key that is shared amongst all the participants and the public keys is a published one if that works for your scenario that's one possibility the second is defining a model where which enables you to come out with again assigned audits of the computation there has been some research on that in what's called the setting of convert adversaries a converted adversary's anniversary that can cheat like a malicious adversary but there's a hot there's a guarantee they'll be caught and there's been work on how do i um make sure that if someone is caught i can actually get also proof uh that they were that they were cheating so i could show to someone else and therefore um you know there'll be some punishment of some kind so there has been work in that area uh there's no straight answer to you to your question rather i would say there certainly are techniques out there what you would need to do is define exactly what the setting is what sort of computation you're looking at whether this idea of sharing a key in a generic way would work or not and if it does then how can you build an efficient mpc protocol for or you know there's a lot of very interesting npc research still that to be done there so defining such a model uh and saying uh can you do that uh in in general and how efficiently that that would be an interesting research question all right thanks for your input uh great uh cohen i i'm not sure if that's how you pronounce your name let me unmute you uh if you guys yeah [Applause] [Music] uh allow participants to start video there you go okay all right hi hey uh thanks for the presentation first of all uh really great uh uh very interesting um so earlier in your presentation you mentioned that when using mpc uh nothing is learned except except for the output of the function but if that output is also sensitive information we could combine it with differential privacy um if we would do that we would make that combination how how would we go about adding the noise uh of the differential right um yeah of the different privacy uh i think you should do it before you reveal the output of the mc function since that is priced information now um how would it work conceptually which would it also be a joint computation in in that case the way that you know the typical way of using differential privacy is that if you wanted to do differential privacy on on many people have inputs you want to compute statistics is you would tell each party to add noise to their own input and then you would just really reveal it and do a computation the problem is you then have to add a lot of noise because each party has to add noise and there's a lot of noise and you lose a lot of utility but what you can do with npc is you will define the function again thinking about this ideal model paradigm and this this you know secure we have this trusted party you would define the function so it would compute the statistic and only add noise on the aggregate at the end so rather than computing the mean and standard deviation by taking noisy inputs and competing upon them and then getting a lot of noise you would inside the mpc compute the mean and standard deviation and sample noise for differential privacy and at it and only that would be the output of the function that would be revealed so nothing intermediate is revealed because that's me to find a function that computes it all together and you are now only have to add very little noise at the end and how much noise that is i'm not a differential privacy expert so you have to work with you know bring bring those forces together but you can add much less noise and get much greater utility by combining the two together that make sense i couldn't amuse myself sorry about that uh yeah would it would that be more costly to do uh when you've when you include it within the protocol so that uh so for for some things like secure aggregation that that's fairly cheap but if you uh if you would just compute a mean for instance but then when you add this to the uh to the protocol it would be would it become much more expensive so it will certainly become more expensive because uh you're adding uh an operation but if you're using generic mpc then it probably won't add a lot if you have something which has a very dedicated sort of you have a dedicated solution for then then it can be tricky but this is uh some this is uh uh uh something that one would have to research and look at my in my intuition says that there are many cases where you won't be paying a severe penalty but there are others where it would be more and it also depends on you know there's different differential privacy sampling as well and some sampling is easier than other right so how efficient is it to sample a gaussian in npc okay and that's part of the research that needs to be done but but i think many cases can be done you know a lot of these also especially these type of statistics use cases we don't need real-time solutions right so if it's a little bit more expensive it's okay okay thank you very much rand you're on mute as well but but we saw we we read your lips that you asked you said daniel so daniel go ahead oh great hi hey so i have a few small questions regarding the garbage secrets and the protocols that you showed so you showed a basic protocol for three participants and i i wonder uh first thing out of the two first participants know that the output of the auxiliary auxiliary participant is correct and is not a malicious and that's a fair quest first question and the second question about that is that you assume there that the communication is not a compromise because they they share the seed and are there any protocols or other settings where you can you can remove that assumption yeah okay so for the first question when you look at the when you think about the global circuit operation at the end you get this like wires on the you get these random values on the output wire so in the small example we showed there was like k 0 f or in k1 g or something like that i don't know because you had though so uh because everything is encrypted that is the only value that the auxiliary server sees and if the xero server doesn't send back zero but sends you k0f then they're unable to come up with k1f because they because it was all encrypted so they can only one learn one of the random values on the output wire and therefore that proves the actual value that that was received so this is also proven in in this literature on you know generic sort of carbon circuits and this is actually a proven property that you get from goblet circuit so that's easy in terms of the secure channels so firstly in practice we assume secure channels um uh you can assume that at least in you know in the unbound setting uh that these are servers that are set up and you have tls channels or is in a mobile and a server you can set up a mutual authenticated tls channel so therefore we can assume secure channels in general in protocols that haven't assume an honest majority you typically have to have a secure channel so if you can't assume it but if you had a then you have a problem if you have a two-party protocol uh and we're secure against only one being corrupted in principle there's not you know there's nothing not much an attacker can do uh eavesdropping certainly will reveal nothing and even in an active attack you can argue certain properties but uh in in reality in practice setting up secure channels is not a concern okay thanks and i have another small question something i didn't understand about the how government circuits work uh so at the uh at the end you said that you need to um so all of the outputs are a are encrypted and you need to try to decrypt every row in the table until you succeed to decrypt one of them and that's how you know what is the output of the of your two inputs right so that's the way i presented it in practice so we don't do that we have better solutions for that so you know the original garbage circuit you could do that and have some redundancies that you would know if something decrypted correctly or incorrectly or you could use authenticated encryption so you would know if it was encrypted correctly or incorrectly but there are uh you know what i showed is a very is the conception the way it works but today after in many many years of research there are much much more efficient ways of doing that we know exactly which one to decrypt not only that we can reduce we actually don't need two psychotics and not four so there have been a lot of optimizations uh what i showed you is conceptual notion and there's been a lot of literature to read to understand in government i was just wondering yeah how do you know when you were a successful in education if you want to think about using authenticated encryption then you would have a mac that would say in practice we don't do that but conceptually such a thing is possible you have a what sorry i missed your last sentence a mac a message authentication code authenticate encryption is something that if it's incorrect it would fail so you could use something like that okay thanks uh pascal you have a question yes yes hi uh hi yoda thank you for your uh super interesting talk um i don't have really questions about the crypto side of things more about i would say the the perception of mpc in the industry and how globally can be adapted or if you're like with your experience at inbound what kind of experience do you have in terms of deployment i mean are are people um um i mean what are the roadblocks for general adaption of mpc yeah and maybe you can talk as well of your experience with certification i believe you went through a fips 140-2 certification at some point which must have been a nightmare um nobody probably in the certification uh space had um actually evaluated and a fully fled a full-fledged mpc solution before um can you can you talk about that absolutely so i'll start with the first question around adoption and barriers and awareness when we started five so years ago what's npc what is that that's not possible you must be breaking garbage but but we've come a long way since then mpc as a technology has appeared in what they're called five gardeners hype cycles which are so many new technologies come into the market a lot of people have heard about mpc um we are we get this what is that sort of question much less today if at all in terms of adoption we have three of the five largest banks in north america using our product and we have about 10 banks overall as our customers and we have other very very large non-financial like one of the largest software companies in the world use their products to do all of their code signing globally so there is uh we're at the point where we see that there is enough adoption that the market is willing to do it is is is receptive to it i understand the value of having a software solution the hsms are both a pain in the butt they not necessarily provide the security they claim as well and when you want to be multi-cloud and hybrid cloud and have everything else is virtualized you need software solutions right so there is that there is more of that awareness having said that we still have work to do right we still have a lot of work to do it's not that but it's certainly in production and very conservative organizations and we're able to get over that we're over that situation where people sort of look at you strange what are you talking about having said that there are certainly organizations that say listen i've been using hardware for 30 years i'm comfortable using that and i don't you know so there's certainly both but adoption is i don't think that we're losing contracts anymore because oh it's nbc and i don't know what that is there are lots of reasons why someone wants to buy you know another hsn from talis or they want to use the cloud kms for their solution and there are a lot of you know there are different trade-offs you know i'm used to this solution i have had it in the past but we're less uh we're getting less that okay this is a strange technology i don't understand i'm not saying it doesn't happen but it's happening less in terms of uh i hope that's the first question in terms of certification uh so yeah we we uh i spent a long time working with nist um and it wasn't easy and in fact there was even a real barrier in that the uh fip specification talks about a single boundary and we wanted to argue that if you an mpc is not in a single boundary right so if i could have easily certified by running both sides of the npc on a single machine and i would have flip certification for that but we are on fuel certification for whether you're really running in practice which is on different machines so we argue to nist that if you take two of the if you take our modules and you run them in different machines but connected with a fip certified tls channel you should you should define that as a single boundary and i actually did a workshop at nist i went out to virginia and i did a workshop for uh half a day on mpc both their research group which they have serious cryptographers in the research group you know them and also the cmv cmvp i think is the group they came and we presented what is npc about they understood that you know not certifying this which is much more secure than you know standard software is crazy and um eventually they uh they had to do some work to allow this definition of two separate modules with a tls channel and we got both level one and level two certification level three and four we cannot get because it explicitly requires hardware protection so by definition we can't it doesn't say if you have hardware then right that that would be fine it says the hardware has to be this so we can't do level three and four and nist is actually running a threshold cryptography uh you know process but it's yeah if it happens in less than a decade i'll be surprised but um my hope and this is one thing that i said to them is that if you only enable us to get level one and level two with this then there's no point you have to think about a process that will allow us to get uh at least to the same level of hardware because it's a difference it's a different security paradigm but one that that is certainly just as valid as hardware and i would argue actually more valid in today's environment when you look at the hsms you have no idea what's running inside there and they're completely opaque right would have i mean i'm not sure it would have been easier to go for a common criteria certification right so with common criteria the easier part about common criteria is that you define there a certain uh what's the term target of evaluation yeah the target evaluation but then there is a profile right you define a certain profile and then you can make that profile suited to what uh you're doing right exactly and then but the question would then remain if a bank because you know what what did banks do level three and four regulation is is is not mandated this is internal bank regulation but what they did 25 years ago they said okay we need an hsm there is no other solution the good hsm's are level three and four so we require level three but there's no real reason for that so either you the bank decides that they can get over that and certainly some already have or they uh um say no that that's but if they're using common criteria if they've put hardware inside their profiles that they require then then we haven't really done very much and common criteria is is very expensive and even longer than fips so it is so uh yeah so but but it is an interesting question that we think about every now and then so don't you think it would it would be worth the the pain of of going i mean of issuing a protection profile specifically for mpc to kind of pave the way to further you know certifications for mpc i mean i guess once once it's done people now have a referential to apply the the cc methodology and then it could benefit the whole ecosystem have you have you considered like doing that or getting something i think that's that is actually a very good idea we didn't look at starting common criteria the price that was at that time was was so high that we thought we needed to wait yeah i'm not sure it's something that we'll do this year or right now but but actually given this conversation i think it's something that i think we should put more thought into and i think it does make sense so yeah exactly when i'm not sure but but but i i think your approach is very valid and we should consider it interesting okay thanks thanks very much thank you um do we have any other questions uh guys just raise your hand if you have any questions uh if not i actually have one um i was wondering about uh whether you know mpc was prone to some kind of side channel attacks uh and if so how you know how serious are they how difficult are they okay so the first thing i'll note is that a timing attack would certainly be one that you need to think about because if i'm doing rsa between two priorities so i've corrupted this machine if i can time the response time from the other machine then i can corrupt one machine only and learn so timing attacks certainly you need to think about for example so we use openness itself for the for most of the underlying basic crypto operations and when we're doing the rsa protocol that i showed you in the slides uh we make sure that we use the uh constant time exponentiation okay so so that's certainly time we need to think about what about the other things so with other things the answer there are two answers that i'll give the first answer is that according to the security model we talk about if you corrupt only one machine you can't learn anything you need to corrupt both now if you do a side channel attack therefore on a machine you certainly can't get anything so the question is okay so uh what do we say about side channels on two machines right so i managed to get on the same physical machine as as two virtual machines running mpc what can i do there and the answer like the only answer i can tell you is that this is completely on uh you know fresh unresearched territory and and what's the word it's uh insurance uncharted territory exactly uh intuitively this is going to be a hard side channel attack because you need to look at things that are correlated between two different executions essentially at the same time i bring it together but i am my gut tells me that absolutely absolutely such a thing would be possible uh so the best practice is of course to limit with your operations that's again that's why we chose to use for a low-level uh uh crypto we use openssl even when uh we needed to use for one of our protocols we used pair so we tricked open ssl into thinking paella's rsa it's we have a nice trick for doing that by the way uh we tricked openness ssl into thinking uh that pair is rsa because now i know that the operations that i'm doing have all of the side channels sort of protections around that are built in for when you have a local sanitary velocity curve operations and so on and so forth we're going to make sure that we're using the same low-level operations that are supposed to be side-channel proof because typically people are using them in isolation but otherwise yes this i i believe it's something should be a concern but by having this model think about now breaching two different machines at the same time having control and having a virtual machines on two at the same time being able to run active side channel attacks and correlate that you know everything's possible in the security world right and nothing's impossible but that becomes uh you know much harder and much less likely than you know getting onto one machine and running that side channel attack so that would be like a nation-state type of adversary that you would consider for something like that no no no i think you would like a group or something like that right i i would think so for sure yeah and and uh and even then so you know we're playing around with ideas of running the you know sgx i don't trust i think sjx is leaky it just doesn't work but it's great as a secondary measure right so what about running mpc inside a trusted enclave are you not still fully malicious npc i'm not trusting anything about this specific or rather trusted execution environment but you're making now a side channel attack uh you know you need to run a full sidechain attack you can't get a snapshot of the memory even if you're on both machines so you know that that that's where it becomes of interest okay great uh i think we don't have any additional questions um do you have any last comments you want to make i know i enjoyed it i hope that everybody found it uh beneficial and uh the discussion the end was great as well can you share maybe uh the the link to your company maybe if you want to share like your your twitter uh sure it says chatter this is a chat disabled um let me enable that let's hope that the zoom bomber left uh by now all right there you go that should work so the company's unbound tech and that's the url you can have a look and on my twitter is just euro lindo so perfect well thank you very much that was really great um so guys the idea is that for this meetup every month we're gonna uh cover a topic around a secure computation uh since this was our second meetup the next one is probably gonna be also an introduction to another technique if you've got ideas please send them to me and once we've gone through maybe four or five or six different techniques we'll start digging super deep into way more technical stuff or way more like you know example applications um you know again you're very happy that we now have a thousand people in the group that's super exciting you know this group is six weeks old uh so that's a pretty nice uptake especially considering that we've only posted on twitter i think you know a big part is thanks to you actually uh after we posted your talk we had 400 people join the meetup group so wow you're definitely a very attractive speaker i have to say well thank you very much and i'll see you guys soon thanks a lot thanks guys bye everyone bye-bye