NeverLocal Experiment, directors Stefano Gogioso & Fabrizio Romano Genovese

See you later guys.

Uh okay. Hello everyone. So basically while Stephano prepares and uh does the last tuning for the thing that you say you see here I will basically cover uh what we are going to do with this experiment. Okay. So, uh, we are going to create, uh, a super massive black hole that will swallow the villa completely into oblivion.

No, I'm joking. The only super massive black hole for for now has been in our finances to buy all this equipment. Um, let me tell you briefly what this does. Uh, okay. Does this work?

No, no problem. Uh Jesus, give me a second. I'm very sorry. Uh okay. So yeah, so today we are basically going to showcase how standard quantum key distribution infrastructure can be used uh to make trusted execution enclaves more secure.

So what this means is that in particular we will implement one-time programs using TE's and conjugate coding. Now there are a lot of mysterious words in in this slide. So we'll start with a recap telling you what this is all about. Uh so a trusted execution enclave uh or in short TE is a chip that has an hardware module in it that is secure. So basically there is some part of this chip that has some cryptographic keys burned into it that cannot get out of it uh and because they are very difficult to extract.

You literally need an electron microscope to do that. An example of this is your hardware wallet if you have one. Uh basically there are some private keys in it. You access them by specifying uh the seed phrase but they never come out of uh your wallet. You just pass a transaction to the wallet.

It gets signed and it gets out. So you can pass encrypted information to the TE that can be only decrypted on the chip. And this allows you to do a lot of cryptographically strong things. So um okay so one of the things that you can do is one-time programs. Okay so one-time programs are basically programs that can be executed only one time.

They are useful for a lot of uh financial and blockchain applications. Um now there is a theorem that basically tells you how uh one-time programs are provably impossible to realize both classically and in the quantum world. Uh to do this basically you require some sort of trusted setup to to build a one-time program. It's not something that you can just build out of standard cryptography. Um TE's offer one option for this setup.

So basically if you have a TE you can do a one-time program with it and the idea is that you encrypt this program you send it to the TE using the TE key to encrypt it that you don't have access to. You only see the public key of this thing. Um basically the TE executes this program and then it locks itself and basically say okay now I cannot do anything more. Uh now obviously this makes the program not executable twice but has uh some downsides. Uh most importantly when you do one time programs like this the word you should focus on is lock.

What does it mean that the T locks? Uh well obviously I could implement literally an hardware switch to do this but I don't want to throw a T out of the window every time I I need to run a program. Uh but if I don't throw the TE away and then I need to you know make it reusable, I could basically try to find some hacky way to some loophole in the TE logic so that I can execute the program more than once. These things are called replay attacks. They've been demonstrated and they exist.

So what we want to do with this weird setup is leverage quantum physics to makes this uh impossible or like incredibly hard. So now let me give you an introduction to quantum. So first of all what we are doing here is an experiment in quantum information. Now quantum information is a radically different thing compared to classical information. So the main difference that you have to keep in mind is that a classical piece of information can be copied at will.

So for instance, if I tell you uh you know uh in 40 minutes we'll have lunch, you can literally take this information and tell it to everyone you know and they will know. You can copy this information at will uh or files. You can copy paste files. Quantum information instead behaves like a resource. It's not something that you can copy.

You can transfer it around but you cannot copy it. This is called uh no cloning theorem and is one of the most important theorems basic theorems of quantum theory. So this simple idea is the basis of quantum cryptography. Now let me cover uh the basic unit of information that we will use in this experiment. So uh you probably heard already the word cubit.

A cubit is the main computation unit of quantum computing. So probably you know what a bit is. A bit is something that is either zero or one. A cubit instead can be any point on that sphere which is called the block sphere. Um so you can see that it's not just like two things.

It's a continuum of things an entire surfaces of possible states. Now the most important thing is that if I give you a cubit uh in in principle you do not know which point in this sphere the cubit is. So we know that it's here now but if I just give you a cubit you need to measure it to to see what state you have. Um we'll get to measurement in a second. What you can do though is you can transform this cubit.

So you can basically rotate this sphere and the cubit you know can change place but it's a kind of a blind operation like I have an operation that says rotate whatever thing I have 90 degrees along this axis whatever I have will rotate 90° but I didn't know what I had before I don't know what I have now uh because I'm like performing this operation uh like uh I were blind now to access the information you need to measure the cubit. What does it mean to measure a cubit? It means that basically you choose an an axis on this sphere. In this case, we are choosing this axis that is conventionally called the Z axis uh 0 01. That's you know just standard quantum nomenclature.

And when you measure what happens is that this point that you had uh collapses either to zero or to one. So this cubit gets destroyed in the process of measurement and becomes one of these poles becomes either zero or one. Now how does it happen? Uh this is a probabilistic process. Basically uh there is a probability that it will become zero and a probability that it will become one.

Now you see that the more this thing is close to one of the two poles, the more it's likely that it will end up being there. So for instance, this thing is way closer to zero than to one. So when we measure it like probably 85% of the times we'll get zero. If we had this cubit like a thousand of these cubits I don't know 850 times we would get zero and the rest 150 times we would get one. Now importantly notice the following thing.

If I have this cubit here so I have a cubit in a zero state. If I measure along this axis, I will always obtain zero because it's literally coinciding with zero. So in this case, the probability of this thing being measured becoming one is zero. The probability of being zero is one because basically it already coincides with the axis I want to measure on. But if I measure along this axis, you see that this thing is completely unbiased.

It's like it lies like that and it could go one way or the other with equal probabilities. Um so I can go either to this thing here that we call conventionally plus or this thing here that we call conventionally minus. Now the important thing is that this this thing that I had before again gets completely changed in the measuring process. So I basically lose this information forever. And if you think about it, I'm transforming this thing into pure noise.

I'm saying I have a thing here. Now I flip a coin and I will get one of these two things here. Um this is also true vice versa obviously. So if I have like something like this thing here and I measure it along this axis is the same. I'm basically destroying the information and going up or down with equal probability.

Okay. So this is the basis of something called conjugate coding which is what we are doing there. So the idea of conjugate coding is the following. Uh imagine that I have two bits two classical bits and I want to encode them using a quantum computer in a way so that I can recover only one of these two. So you want to choose okay I want to recover the first or the second and when you do the other one is permanently destroyed.

How do you do it? Well, you encode the first bit as a cubit in this axis. So if your first bit was say zero, you choose you instantiate a cubit in this way. If it was one, you instantiate it in this way. For the second bit, you do the same but on this axis here.

So if you want had a a zero uh you encode it as plus and if you add a one, you encode it as minus. So these are called zed and x bases conventionally. Now the point is that you have two cubits and now these two cubits represent your classical bits. You have encoded a classical bit into a cubit. Now you scramble them like you know you just permute them and you don't tell your friends which one encoded which bit.

So now they see two things. Remember that you you cannot access that information without measuring. Uh and now what they say is like okay I wanted to recover the first bit. Well, if they want to recover the first bit, they know that it's encoded in this axis. They just don't know which of the cubits it is.

So, they will be forced to measure both of the cubits in this axis here. And in the process, they will completely destroy the information about the other cubit which was encoded in this other axis. So, this is the the basis of the thing. And what they will get was the original bit that they wanted to access plus some noise, some random noise. Now they will basically need the TE to distinguish between which is the noise and which was the bit.

So the T will have the information inside. We'll say yeah I know that you know the first bit was encoded in the second cubit for instance. So you do the measurements. You give the measurements to the T and the T can say okay yeah you measured in this order. I know which is which.

So now I can tell you which one is noise and which one is the thing that you wanted. So how do we use this to do you know why why do you need that weird stuff there? The reason why we need this weird stuff there is that the way we implement this is with this kind of infrastructure. We have a laser uh one party has that we call conventionally Alice has a laser. This laser shoots single photons and the other part is Bob that has a detector.

So it has a thing to detect these photons. Now what Alice does is she polarizes uh their photon. Polar polarization is a property of light. You apply a filter and you can polarize vertically, horizontally, diagonally. You have various choices.

So now what Alice does is you can see here if she wants to send the first bit and the first bit is zero, she polarizes this way. If she want to send the first bit and it's one, then it she polarizes in this other way. Uh, and she can use oblique polarization for the other basis. And now what Bob needs to do, Bob needs to measure the polarization of this photon. And the it sets the detector by putting a filter, a screen.

And basically you can see that you know if the detector is the wrong one, uh, it will measure in the wrong axis. So this is just like the practical implementation of the thing we were talking about. Now what we did uh codewise is uh coding something called trust that basically uses all these that I told you about to create one time programs. So uh it's a small library to do conjugate coding based on one time programs on tees. Uh it's written in rust as the name can suggest uh and can be used in embedded systems.

So it can be run on very small ships. Um that's the repo on GitHub if you want to play with it is MIT licensed is completely free. So feel free to explore. So how does this work? The protocol is basically run in three phases.

In the preparation phase you basically are the preparing party Alice. You prepare the cubit and you send them to the measuring party using QKD infrastructure. So basically you have the laser, you prepare the polarization and you send it using fiber optic. The that thing here that big red box is the is the laser. Those things small things here are yes I'm pointing lasers at the lasers.

The small things are detectors. So in the measurement phase you have um oh together sorry with this information she also sends her encrypted one-time program to the TE which is owned by Bob. Now Bob says okay I want to run my program. So what do I do? Uh well I choose an input to evaluate the program on and the T tells Bob where in which kind of which choices of measurement he has to operate.

At this point the TE receives the measurement outcomes and decides to run the program or not depending on you know whatever inputs were received. So in practice the way this works is like this. We inside T rust there is literally nothing more than an incomplete table. So we have some entries as you can see some of these entries have are filled some are not. The one that are not filled are marked with zeros by another row called bit mask and one that are present are marked with one.

Now the difference is that we call these one entries here security bits. Uh these are the secret bits because not even the TE knows them. So what happens is that also the TE stores information about the orderings. So for instance it knows that uh you know this represents basically the first bit string that we want to send. So as I tell told you in the in before uh I want to send two bits so that only one is recovered.

Uh I'm doing this n times. So I want to send n bits so that only sorry two n bits so that only n gets recovered. So this is the zero bits the first bits in our initial examples. These are the second bits and the ordering thing is telling to the TE which cubit will encode which bit. So in here we know that the first cubit encodes the first bit.

The second cubit encodes the second bit. In this case is the opposite. Huh. Oh. Uh yeah.

Um Andrea, can you find some black tape somewhere? Some gaffa. Thanks. Um okay. So this is how we implement this in code.

Uh is basically just a strct. Um now what happens is that during the measurement phase the TE operator will basically choose an input to evaluate the one-time program on what we do now is we compute the hash of this input. Hash is a cryptographic operation which is quantum secure. And what it gives you is you take the input and you get a string of fixed length of zeros and one. Um then basically this string will tell uh the TE which measurements we have to operate.

Pictorially it looks like this. Basically this is the hash. This thing here choices are the hash bits and they will basically tell the T uh you here want to measure this bit here here you want to measure this bit here and so and so uh then you do the measurements. So you measure all these couples of cubits that you have and you will obtain a string of outcomes like so. Now what you do is when you have you know the zero entries uh you don't write anything here uh so sorry uh wait okay this is what happens right now so you have this string of outcomes you have the orderings you have the choices etc.

Now what you do in the result phase is that the te takes the measurement information takes the preparation information and decides if they want if it wants to run the program or not. How does it work? Well, it basically uses the ordering information and the choices information to decide for each couple which one is noise and which one is not. Uh this is written in the purged uh row. So for instance you see in here basically the first uh this bit was encoded by the first cubit but I wanted to make and we are on again.

Okay. So what happens is that uh for instance in this case I wanted to measure uh the first cubit uh sorry the first bit which was encoded in the first cubit um sorry in the second cubit which is this one. And so this is what I have here and this thing I forget. So now I report this information here in these small triangles the outcomes of the measurements. And now you can see that this is in this case you know for the security bit what I had before this is what I measured and these two things have to coincide.

So for instance in here they do not coincide which means that the measurement didn't give me what I wanted. So this could either mean that there is noise or there is tampering. In any case, what happens is that uh if I do not trip a huge number of security bits, the TE will use this to give me a secret string. So basically in the secret bits that are, you know, the ones with a zero here, it will take this number and it will spit it out. So this goes here, this goes here, this goes here, this goes here, this goes here.

Um basically, okay, perfect. So that's what we do. And the point is that now we can use this secret uh to uh either run a one-time program directly on the TE or to feed it to something else like a garbble circuit to evaluate a one-time program in an even more more secure way but I don't won't talk about it right now. So as I said basically there are two ways of using these things. The one is the pure TE modes.

In this case all bits are security bits. So in this table here there will be basically uh no ones. They will all be sorry no zeros. They will all be ones. Uh and again I can use this as a test.

If I pass enough tests I run the program or not. The upside of this thing is that is better gives better protection against replaying than standard TE's. Uh and it's fully stateless. The downside is that if the TE is act we are game over anyway. The second way to do this is by having the secret bits and again these secret bits can be used to unlock some other cryptographic protocol such garbage circuit.

The upside is that at this point if they don't uh if someone steals the root of trust we do not care too much like the tea becomes really hardened and the reason is uh that basically if you see in this example here the security bits were not in the TE in the first place. So even if someone hacks the TE and reads the information before the measurement is done or after the measurement is done, they cannot extract this secret string. To extract this secret string, they should be very strategic. Hack the TE only when the measurement happens. Hack the code inside so that the measurement is strategically done in a weird way and then basically they could access the full secret.

But the point is that if you hack this thing right now, you just get out something that is what you wanted in the first place. This won't allow you to run more than once your program. And the way this is used is that then you feed this to a garbble circuit or other primitive primitives and you do it. The downside is that this is computationally is lower. Okay.

So, uh feel again feel free to play with this stuff. Uh we provide plenty of examples. uh this code can be run on this chip here which is only $4. So if you don't have you know the remaining $100,000 that are in that box uh but you still want a hint of how this thing works. We also offer um a simulator which is basically a classical program that simulates the output of uh the QKD based measurements.

Obviously, this will not be secure uh but it will give you a feeling of how this stuff works. And yeah, now we go to the demonstration. Basically, I'm I'm done with the presentation. So, with this last 20 minutes, I think we can we can go. Um are you already ready or not really ready?

We'll see.

So, okay. Uh let me let me also cover very shortly why we have a box or stuff like that. So as I told you uh in the beginning basically the the way Jesus Christ sorry uh basically the way this thing works is by shooting photons. You see here we were shooting photons. Now unfortunately uh all around us we are surrounded by guess what photons.

So, uh, we need that black box to, uh, shield the lasers and the detectors from the ambient light interference. Um, that's why it's completely covered. But, uh, yeah. So inside there what we have is the laser which will shoot this thing this these photonss that will be split uh and then measured uh you know in the full like real example as you can say uh you as you can see here Alis and Bob should be specially separated so there should be some you know for instance kilometers of fiber between these two parties uh obviously here we are doing everything in a self-contained way So, it

it's uh it's all here. By the way, let let me tape the the thing. We have the gaffa. So, can I can I tape it or? Yes.

No. No. You don't have to close the windows because we have the best invention of humankind, which is duct tape. people.

So the funny thing is that both me and Stephano were basically theoretical scientists. So you know when we bought this thing in the first place a few months ago, we were like, "Oh, what the What we did for 10 years is actually doable. signature. Oh my gosh. So now let me see if my computer can be plugged into this thing.

I'm very skeptical because I use a weird operating system, but you can never tell.

Give me a second. Uh yeah, but I wanted to show

if it works, I'll eat my boots literally.

Yeah. So, we have a little helper which is basically formatting an Ethereum transaction right now. And as you know in blockchain what you do is you sign the transaction. Uh signing a transaction literally means signing the hash of the transaction.

Exactly.

Yeah.

That thing there.

Uh do not take this one because it's it's a if you can go to transaction helper and

no no you I know just show the code. Um so uh transaction util transaction preparer yes if you yeah perfect

all right

so in here basically what you have is you see we have from address that's a sender to address we are sending to the zero address the value which in this case is one ether And then we are basically formatting this transaction. Now Stephano cannot run this thing because Ether's RS doesn't build on his system unfortunately. But what this thing spits out is a transaction ash that needs to be signed. Uh now I will basically give this hash to him uh so that he can pass it to the TE which has a secret K burned into it. uh and uh then we will get the signature out from the

TE. I'm literally passing this thing on WhatsApp. So

WhatsApp.

Yes. Yes. It's very artal as you can see.

Can you send it to?

Yes. So, okay, I paste the hash on Telegram. It's that one just Yeah. copied. Perfect.

Yes.

All right. These are the two windows that I will use to pass maybe can I have a minute to say what's in yeah I also passing you the row transaction is not signed so this on ether scan uh it will show you that it's a transaction it's valid but it's not signed there is no signature and so it cannot be executed

why not

because he has no signature right uh so if you do If you uh wrote no if you go on scan and row transaction signer [Music]

one transaction. Yes,

if you copy paste that string and you I'll just start by getting the sign transaction first and then you can

Yeah. All right. So, um couple of things just uh just for you to know what's effectively in the box and

I have the thing by the way.

You have the one. Yeah. Yeah. Yeah.

Okay. That's a very interesting address.

Yeah. So if you copy paste that thing in the row transaction X and you decode.

Yeah.

You can see that there is no s uh why there is a sign. Yeah. Okay. There shouldn't be a signature there. I think that's randomly calculated.

I will just I will just do other things in the meantime. Uh there there's plenty of things to do anyway. So, here is the brief, very brief explanation of what's going on here. Got it. So, that's that's all we needed for this demonstration.

That's the packaged contents of this box as they were uh in London just before I put them in the hands of some trusted couriers that brought it here safely. It turns out quite incredibly. I didn't really uh I didn't imagine that. That's almost all we needed. What we really needed for this particular project was a skilled watch maker who spent about a month of time going from theoretical quantum information person doing quantum gravity for his PhD to learning how to do experimental quantum platonics because apparently that's what his job is right now.

Um so that's the that's the necessary components for this experiment including personnel. uh he taught me how to do it yesterday. Uh but I wouldn't have been able to do it without instructions honestly. Uh these are the individual pieces. There's a photon pair source which is a big laser.

In fact, it's a small laser but it has a big pump laser and then there's a lot of loss and a few photons very sparse number of photons come out of two fiber optic cables from the front. In fact, they are so few that we have to tape the box down and tape it at the bottom because just the sunlight that comes through that little aperture in the front is enough to drown the signal from that and make it hard for me to run the experiment. Um the the noise threshold goes high. So that's the that's the generator of the photons that get into the experiment. And then there's the end of the photons.

That's where the photons start their. So here the photons start their life. Here a brief uh few nanoconds after in fact I think picosconds after the photons end their life they slammed against the detectors and the detectors emit some signal which we can record on some microcontrollers and use to determine whether we have seen the zero outcome, the one outcome or we just missed the photo. And for your information, that's what the signals look like on an oscilloscope in our London office. The these are just uh two of the photons.

So the two photonss that come out and they come out typically they should come out perfectly aligned of the laser. But because there's always photons drifting around no matter how well we tape that, there's a bunch of other signals. It's just that they are not perfectly aligned. They have to be timed exactly for the detector to look at it. Uh except the timing difference between them.

You can't really see it here, but I can tell you the spacing is in the order of few hundred nonds between different pulses. The spacing between the photons is tens of nanconds, sometimes single nanconds. And so you need to have something which has that precision to detect which ones are actually the coincident the correlated pairs coming from the laser which is the signal for the protocol and which ones are just random photos that come from the air and enter the box and you don't want them because they carry who knows what information. And what we what you need to do is you implement a small piece of electronic circuitry which is called a coincidence detection. And what it does is when the signals are sufficiently aligned, there's a bunch of MOSFETs and resistors that implement effectively an end gate, but a very short-term one.

And they translate these very short peaks, which by the way would be too short for the uh microcontroller to reliably detect anyway. And they translate them into a pulse that is longer, but only comes if they are sufficiently well timed. if they defer by even like 20 nanconds, the pulse doesn't come. It just gets lower very quickly. And and so this allows us in hardware to detect coincidences before we pass them to the microcontroller.

So one of the photos that come comes out of the laser is entirely wasted. It's only used for this timing purpose and it tells you when to expect something in the other detector. What is noise and what is not noise. Without that photon, you do not know what the which photons are the interesting ones and which photonss are just random from the air. In fact, there's many more random photons from the air that interesting ones.

And this is a cryptographic impact because it allows you to hide some of the error. Even if you have a bit of error in your protocol, as long as there's enough thermal photons from the air, from the light, then those will drown whatever imperfections in your signal. you know because you can do the coincidence detection which ones are the right ones but without the herald photon you can't do it. Uh other pieces uh practical pieces that the photonss go through there's a beam splitter. The beam splitter is a way to take a photon coming from one path.

So you use we decided to use an encoding of cubits which is called path encoding. We use the two fiber optic cables for each photon. And depending on whether the photon is in the first cable or in the second cable, the bit encoded is zero or one. And this is very classical. It's just classical light.

But because photons are quantum, what you can do is you can pass them through a reflective cube which has there's like a laser, a test laser coming through. This one is invisible. Um and in this cube photonss enter from one port and they get split on both parts at the same time with a phase in between. So now the photon classically is on both parts in superposition and the phase between the parts is the thing that encodes the bit. So if you try to measure individual the two fiber optics you plug them into the detector without doing this the correct measurement you just get 50/50 random coin flips.

Nothing interesting. If you want to decode them, you pass them through a second one of these which scramles them and makes them come out of the correct port again. So you this this is a way to pick the basis that you want to encode information into and decode information from. Then you have some switches which are used to communicate classical choices to the photons. It is very hard.

I mean photos travel really fast the speed of light which is fast. Uh you cannot really time operations mechanically that fast and nothing complicated. So the best way to work with photons and implement quantum computations is to have fixed sets of equipment that do different things and have one kind of component that is fast which is a switch. And the switch all the switch does is decide path one, path two, nothing else. And you have a bunch of these switches together and you can use one to decide which basis, one to decide which bit code.

Then they go through four different paths. Then they get merged together and they get sent to the destination. The destination does the same thing. has two switches that decide which basis to measure in. They go through to different paths, merge again and get detected.

And so you have all of these paths that are alternatives that the photon is only in one of them or in two of them in superposition or in many of them in superposition, but they need to be merged back into one. And that's what fiber mergers are for. We only need two to one fiber mergers. So two fibers come in, they are it's fused fiber optic. It's a very precise process.

The photons come into this junction and they come out of a single fiber. And this is a polarization. All of this is polarization maintaining because we use polarization for part of the process. And finally, we have the stars of the show which are the microcontrollers. There are two of them.

One of them controls the encoding side of things. One of them controls the decoding side of things. In reality, they would be in different places.

Alice and Bob. Yes.

Alice and Bob. But in here, because we need to do a compact demonstration, they're in the same box. Uh, one of them decides which basis to encode the secret information into and which bit to encode and the other one decides which basis to measure the information from. And so they are attached to the various switches that we have that control the paths of the photons. That's the way this experiments.

Laser is on. Uh, box is sealed. Hopefully there's not a lot of interference in there right now. So,

I'm going to start running things.

So, if you go on Telegram, you can see I sent you the right RPC at the moment.

Okie dokie.

Um, okay.

I am. Yeah. Yeah. One second. I will go on Telegram.

Yep.

So, you can see it's considerably shorter because it's actually not signed.

Yep. So, this is the one. Yes.

And I'm going to

if you space it there. Yes.

Yep.

The code you will see that the there is no basically no signature information. It should come right after value. It does not because there isn't. Um

it does say valid false.

Yes. Because it's not signed. Um cool. So I also passed the ash and then then you can uh put

um Yeah. So first things first, there is a bit of the protocol that involves the secret that these two enclaves should have. The the information in this secret is a couple of tables of bits that need to be produced. Uh there's two rows in this table and we need to pick the ordering of the bits in the table. So whether zero means x or zero means z.

This is the secret information that's shared by the two tees. We put it as the first input of our program. So let me run the let me flash the two chips and run the programs. So first things first I'm going to flash program one goes on com 4. That's the one.

It's waiting for the hex string from the serialization utility. Program two goes on com six. I had to write them on my arm to remember. And that's also waiting for the same information. So this is the secret table that the two T's would have stored inside and would use to decide how to encode the data and how to decode the data.

So this information comes from a small utility that we have that Fabitzio has written. I shall not take credit for this. Um I'm going to just put two security bytes because it's a short demonstration. So let's say 0 x uh 0 1 2 3 0 x 4 5 6 7 and 0 x 8 9 8 B and this gives me this takes there are 16 bits here 16 bits here 16 bits here there's 48 bits they get encrypted using the T key so technically you'd give this information this information can't be read from the outside It's decrypted by the enclave. So you can pass this but only the enclave knows what the table is.

So this is encrypted with a key that that's that's secret to the enclave. Uh use it as you see fit and I shall see fit to use it here. So enter it on the controller on the sending party. So Alice enter it on the receiving party say Bob. And now I am told okay this is valid information please provide the input to your program.

The input to my program is going to be the hash to sign.

Uh no not that one. If you go on telegram this is the row transaction. Yes that one.

This one

7cc.

7C.

Yeah.

And so this is the hash of the transaction which I will put here.

Yeah. And if everything goes well, which it never does. Ah, well, no, not error. The the watchdog has killed the program. Let's try again.

These things are as fiddly as they can possibly be. This time I will be fast. Done.

Yeah. Bunch of bits were generated uh for debugging purposes. I have printed them. You wouldn't. This is the secret information.

See the information I sent initially has. Let me just kill them so that the watchdog doesn't restart them. The information that I sent this was a secret information that was decoded by the the T internally and it contained these secret basis choices. these secret bits for the Z- basis, these secret bits for the X basis, and these were used to generate a bunch of switch inputs that determine whether the photons went into the X path or the Z path, that whether the bit encoded was the zero bit or the one bit. And on the other side, the detector received these photons, looked at the detectors, got some bits out of the detection process, and these were the bits that were obtained.

Sorry. These were the bits that are were obtained. These would be the measurement outcomes. They were validated. They were valid and the security was verified.

This was a fairly clearly fairly well tuned um procedure and it worked out for this program execution. So now the T internally has a key. The key was used to sign this transaction and now this information that I have should be the one that I paste, right? If I've done everything right, which I am not sure I've done, how do I verify it? Uh, yeah, let's see.

I I think you should give it to me so that I can give you the RPC because that's just a signature.

Yeah, but can I not verify the the signature by myself in some

I don't know.

No. Enter a sign.

I don't know if it try. Uh I don't know if the format is

No, it's all right.

So I'll just send it to you.

Just send me the transaction.

Now what I would I would like to show you my screen, but it's it's a nightmare uh with two computers at the same time.

Uh yes. So

second. Now basically I will copy this signature into my program.

You want the cable?

No,

I mean I'm done. The problem is not the cable. The problem where is my computer release. Okay. Now I should have this thing which is here.

Okay. Now if you go with this one

I do what?

Uh just copied in the transaction decoder.

Yeah. This one.

Uh yeah.

Yeah. Now if you go to the code you will see it's all the same but now there are three more parameters VRS those are the signature parameters. So now the transaction is signed and indeed it says valid true because the transaction now can be executed. So

and the important thing is that all the signing happened on the TE. Uh so you know in a real case scenario only Alice as the private key sends it to the TE and Bob basically gives a transa works like another wallet basically. Bob takes a transaction feeds it to the TE and the TE signs it for him and then he broadcasts it with the difference that he can sign any transaction he wants with that secret key only once. then it cannot do it anymore because it destroyed the quantum information encoding the table in the process and that's it.

Yeah. Thank you. Thank you very much.