Day 1: Leif-Nissen Lundbaek (XAIN)

Transcript

[Music] now going to go to our final speaker of the block who is a doctor leaf missin Lundberg CTO of xane Lafe right it's a last slide for some reason okay I don't know why doesn't work hmm okay

doesn't work at all okay yeah so um yeah first of all many things for being here and my name is Life Olympic I'm the CEO of Zane and one of the co-founders and at Sain we focus especially on transit access control protocols so not not so much really on payment protocols but solving really the problem that when you actually have such distributed systems and also interact with centralized systems you actually also need to solve the problem of giving permissions to other organizations for example or to other own people and so I hope it works now okay perfect

so yeah starting actually also in the field of IOT of course IOT gives us a lot of promises so of course we can build intelligent applications on top of many protocols of systems we can of course interact with multiple devices and actually of course build interoperable systems to actually solve certain problems of people that can actually then access these devices in a very fine-grained matter however actually it's not that fine-grained and also delegation of policies really is a problem here because many systems actually just fake the control so people have the illusion to have control over the data and their devices but actually

it's only in the control of platforms such as for example Amazon key or of course in the recent example of Facebook you only have the impression that you actually has a user have control but actually the authority controls everything in their environment and and this of course leads to limited interoperability between different systems as they are extremely centralized and of course don't really allow much trust in these systems so currently many of these systems are Authority managed access control systems so you can see on the left side that there is a central authority controlling and hosting of course the resources and the resource owner is of course just giving permissions to the authority to

manage this and the authority is then in their databases for example faking this control so some systems are for example called golden key systems here of course this is a huge problem and already ten years ago user managed access systems were created for example o of and oauth2 under um a and they try to solve this problem also of portability of access control so you have a resource owner that is giving for example an access token to someone else which integrates certain policies and these certain policies can then of course used by that person and you sign this transaction the problem however with these systems is

that first of all you don't really have much fine-grained control when it comes to shared economies in IOT so one example is I give access to someone else to my car and that person is then renting out this car again I have no possibility of actually controlling what the third party is actually doing with my car so this is this is the first problem here which oh f 2 is not solving and it also has very limited possibilities of actually handling fine-grained control here the second problem is that Oh F 2 systems are not really run on shared infrastructures so and if they are run on shared infrastructure you have no possibility of actually trusting

whatever policy you integrate here and of course these limits of course then that you actually don't have fine-grained policies because you can't trust them at all anyway and the third problem is in these systems that we actually interact with devices you have no ability of actually controlling that this device is not for example ddosed this means that for example in keyless go systems which a certain autumn automotive manufacturers have implemented it was a possible to attack these systems and to for example force them to restart and while restarting of course attacking them again and hacking into these

systems so for this most of these systems run through centralized servers and only offer online communication which of course limits the applicability of these systems a lot so you have for example in in car parks or in your garage you have no Appa the ability to actually open your car or of course not even being able to share your car so this of course limits then at the end how you can actually use these systems and the problem here is actually that each of these attacks is almost costless so you have no incentivization of actually behaving in a in a good manner so the solution that that we offer here

in our protocol is that we expand the um a protocol to in a decentralized manner so you have actually also different architecture at the end where resource owner is storing its policies and actually these policies become a domain-specific language so that you actually can write our program own policies and store them in a decentralized manner of an a decentralized network at the end and then as you can see on the right side here for example a requester can access such decision points and through these decision points are also retrieve some attributes that have been collected previously from the devices such attributes can be a 4-course how this

device was used and certain sensor data and this of course means also that the resource owner can then manage whatever has happened here before and can actually also prove it and through decentralization and a consensus mechanism it is also possible to prove that your policies have not been manipulated before and to have like a standardized way of writing such policies and to delegate these policies is extremely important when it comes to IOT and shared economies so how does it protocol work at the end so from a technical architecture point of view we implemented the system first with different OEMs where we have a user device this can be for example

speech speech recognition system can be also an app of course where you generate of course and an ID but also we have an embedded compilation entity which is running for example on a microcontroller and this of course becomes also become yeah well gets also a known idea at the end and on this invented compilation entity there is an embedded client and this embedded client is kind of like a light client but in a way that actually also validates the policy stores and these policies stores store acts at the end all policies and all attributes they can be the same but can be also different ones so we integrate this

protocol currently in different protocols for example theorem iota and hyper ledger so in some ways policy and attribute stores are the same and they of course validate then of course also the embedded clients and when you as a as a client or as user want to for example share your car you integrate and broadcast this policy how to use your car and broadcast this to the full clients and then your car receives these updates eventually as well so one example is here the device sharing example where you for example want to share your device with a friend so you update a policy how to use this

and then the friend which is in the middle graphic can access and open this car for example and use it in a certain way and every interaction with your car gets locked and also to stored in a distributed way so you can actually also prove how he actually behaved and on the third example we also have the possibility for offline communication and limited access so one example is here that you drive in a car park you go shopping and you ask the shop assistant to put your bags in the trunk of your car so you give them limited access basically to the car and this access is then burned by the car and of course

every interaction gets then locked again the second example is actually the delegation of policies and it is of course much more complex because we can have actually n type of parties here that come in row so one example here is that we have a producer in OEM for example Porsche and we have a car dealer that actually sells the car or leases the car and we have a lease holder then and the lease holder is again using this car in a shared economy to actually share it with other people so in this scenario usually the OEM has no control at all over what the user at the end is actually doing with the car however the OEM is still owning some of the software inside the car and also

need to maintain for example some of the software through updates for example and by the behavior of the user this can of course limit a lot what the producer can at the end do so the producer needs to still make sure that the user at the end is really behaving in a certain way and here all this process runs on a shared infrastructure on these policy stores where the OEM can of course then integrate certain control functionality certain policies and delegate them and through this protocol then also make sure that the user is actually behaving in this way and not differently and the third example is that of course each of these OEMs is currently using or trying

to integrate different blockchain protocols for example or just having centralized systems like an Oracle database and the problem becomes at the end that the interoperability between these systems is again extremely limited and also if you for example write certain commands in each of these protocols you also need to make sure that you can actually execute these commands inside the car and it's not about only receiving data through obd dongles for example which is of course like just a simple transaction to gather data and store it somewhere in a decentralized manner i mean it's quite simple it's much more complex to actually also grant access for example through certain functionalities inside

the car and also make sure that these processes and methods actually authenticated validated and then eventually executed and that you actually make sure that you know whatever has been executed here and for this we we started with the cerium actually to integrate our protocol in a cerium kind of in a similar manner as lightning protocol just for access control but of course it makes sense also to to expand this to further protocols so therefore we are currently also working together with other systems here with iota and hi pleasure to also make sure that our domain-specific language is actually integratable in these language different systems and

protocols and also programmable in a certain manner that actually the embedded clients can enforce also certain executions whenever certain mix of commands come and wherever they come from for example you can write then with an iota smart contract the same command as you can also write in a theorem then so all of these kind of like examples we also integrate it then with Porsche together in a pilot project so you can see here in the picture that we developed the embedded client inside then the car to actually also enforce these commands and to make sure that

these commands can then actually also be executed so online you can also find a video where we show what we've done there and and how we've done it and in this example we had three epics one of the epics was sharing actually your car with your family for example because Porsches will usually not be used in a sharing economy that much but that that was basically one epic another applic was audible data trails of course because that's actually what the car produces here it's roughly ten gigabytes per day and then it's of course also question what do you do with this data and whom do you give access to this data

and if I go back to to this slide then once one thing that you can actually do here as well is that you can for example write commands to ask for example users of a different car holder to also share data with you for example Porsche has not really many cars on the market while Volkswagen for example has millions of cars on the market so it becomes really interesting for Porsche also to ask Volkswagen users to share data with them for example to develop intelligent applications on top where of course the mass of data is really important on the other way Volkswagen can be extremely interested

on data from Porsche and data from Porsche is very valuable as they have high-definition sensors so they can build HD mapping applications on top the direct way of Volkswagen asking Porsche is in this case not possible of course due to regulation so asking the user is here the obvious choice and another example is third-party integration so DHL as a for example in this trunk delivery case was integrated here so you can for example deliver parcels in your trunk so the advantages of the of such kind of protocols is that you can

actually develop fine-grained access control commands to access for example certain devices and to make this really usable for human to machine interactions but also at the end for machine to machine interactions the second advantage is that it has a domain-specific language is actually programmable also for other protocols and the third advantage is that the secure offline or near-field communication of course also expands the way you can actually use it instead of just having like a single server sitting somewhere and using online communication to to ask for access so just as a few information about same so these are the

founders we're roughly 35 people right now so we've found it's - I founded it together with Michael hood as a CTO and Felix almond as CEO and we were created in 2014 at the University of Oxford first as a pure research project we've kind of like developed more into cooperation at this time working mostly together with Daimler and other corporations in the automotive field had a first successful pilot system which took quite a long time to integrate this protocol in actual manufacturing processes at Mercedes and in the beginning of this

year also launched the vehicle Network where actually you have embedded enforcement's of policies in cars together with Porsche and we just created also the foundation that basically hauls or the open-source code so our main clients are here Porsche Volkswagen and Daimler and yeah I actually would also like to offer you to join really to create such integrations to actually write also circuit secure access control commands and delegation protocols thank you very much [Applause]