 For the IRS hands-on, I propose to create an example of IRS SCB encryption decryption on a PNWB535. We will select a NISTAS vector from the document we can find on the link below. So let's switch to STM32 Cubed Ideal. Let's create first an empty project for our nuclear board. So let's take the board selectors with WB55 and I will take this one and we will have some IRS Accelerator. Let's initialize old peripheral with default mode. Okay, everything is ready. We will first activate in the security topic. We've got two IRS. We take the first one and we just activate it. As you can see here, we can already configure the data type, the key size, the encryption decryption value, the data with unit, and the key on EV configuration that you need to skip on note. Okay, for the moment, I will generate it without any value and then we will select the test vector we want to use. So let's just generate the code first. Okay, so by default, the key was not initialized here. And we've got the harvest in it that have been created with the parameters according to what we've got in the graphical interfaces. So now I propose that we open the new document to select our test vector. So I open this document. Let's check where the vector should I select. So what I want to do is a CBA, for example. And let's say why not 256 encrypt, for example? Okay, so here we've got the key value, the first block, the plain text, the input block, the output block, and the ciphertext for this block. So for this example, let's take just this one and let's encrypt just the first block. Okay, so I copy those data inside my code and document to keep them in mind. So on the top, here we just to put some, I would say, comment. And this is our, this is a vector test that we want to validate together. Okay, so here we've got key value on two lines here. So we've got a plain text for the input block. So the same output block and the ciphertext. So I propose to do just the encryption of the first block. We can, I would say encrypt all the blocks, but it may be simpler here. So I propose now to configure the encryption inside. So I will copy the key value because if I come back here, I can now just copy past. Then we can decide to the type data of 32-bit or 16-bit or 8-bit. So I propose 32-bit, it will be easier to convert. The key size 256. So I copy it again. That's been targeted. Okay, word for the data units. Okay, so I think everything is fine. Let's generate the code or update the code currently. Yes, just save my comment. So let's check the code generated. Now the key value have been, I would say, declared in this variable. If I have a look to the configuration, we will use 32-bit, 256-bit for the key size, and it has a CB. Okay, so now we'll need to declare the array for the input data, another for the data encrypted. And then I propose to decrypt and to compare to what it was encrypt. So let's create the array now. So let's declare here, we say that we will work with 32-bit long data. So input data. Okay, one block forward. Okay, and then we will initialize with the plain text that is here. It's for magic property, one, two. Okay, so this is my input data. Now I will encrypt them and put the result in another array. And then I will try to decrypt this data and then we can check that we find again this input data. Okay, so we declare the different structure that we will need. So let's encrypt and decrypt it. So the initialization have been already done, I would say. So let's do HL encrypt and then completion. We can encrypt it. I just want a basic encrypt. I should not put this B. Here we've got the crypt and we just want to encrypt, not with DMA or with HIT, just a basic one. So here will be the pointers. Suggested this one, I think it's okay. This is my input data and the size we have to put here is four. E, I would put would be my encrypted data. And let's put a time out value of 1000, for example. Okay, then I propose that to do a decrypt. So let's take a decrypt. Here we can just copy this one. The input size this time will be the encrypted data as is still four. The output is my decrypt data and another time out of 1000, for example. Okay, let's build this and now let's execute this code. Okay, so let's remove all those expressions and let's put them the input data, the encrypted data. We miss it, sorry. And the decrypt data. Okay, so if we open those one and request to see them in hexadecimal, we'll find our value again. I prepare those all to be in hexadecimal and this one also in hexadecimal. Okay, so let's do a step by step first. I do the encryption and you can see the result here. Okay, we will check after in our sources and then try to decrypt and we find again the same value. Let's check the encrypted data value regarding the test vectors we have copied here. So it should be F3EEG1BG. So, so basically just work. Okay, this is really a simple example just to show you how you can test a new vector. If you need to do some adaptation with a bit, it's trivial, I will see. But this is the first step. So now I will maybe have some way to measure the performance. So first I will stop debugging. And we will use a c-stick counter to count how many ticks happen to have the encryption and the decryption. Okay, so we will need some volatile variable. So I propose to create storage three different. So a time starts, then we have time and and we will compute the difference between the both with time and if. Okay, let's define some micro. We'll use it at different location. So the time start first will be equal to the c-stick. So it was with a bt c-stick and we just check the value and remember hits, I would say. So I need to put the name of my micro. So we time measure start. Here we will remember this value. Then we will define the time measure stop. So here in the time and we just take the new value of the c-stick. And I propose in the same macro also we compute the time diff. So time diff equal time and minus time starts. Okay, so now we can use this just before launching the encryption task or the encryption API. And then the time is in and stop when we finish. And we do it again with start. Okay, so I will also need to reinitialize the value of the c-stick just to ensure that it started from a good point, I would say. So to do that I can use a HL function for this to reinitialize this value. So it's a HL c-stick config. And here I will put a huge number that way we are sure to have overshoot of this timer. Okay, let's compile this code. Okay, sorry, I miss. Now it should be okay. Let's try to compile this one. Okay, this time it works. Let's debug this now. So this time what I would like to see is this value also in the expression. And let's stop just after here to see how many ticks we have for the encryption. That's not good. I should have made an error. Yes, it time starts minus, sorry. It's decreasing, not increasing. I miss it. Sorry about this. Let's do it again, terminate and reload. The counter starts at the top and decreases each time. So this time it should be okay. Just run it. Okay, this time I prefer such kind of value. So for the encryption, I've got this number of statistics. And if I go for the decryption, it should be longer. In fact, yes. Quite more long. And you remember we have to derive the key first and then to do the decryption. This measurement of performance, I would say is a little bit, there is no perspective now. But when you will use some software library, you can instrument the code in the same way and compare the value. That could be interesting.