Assistente AI
Trascrizione
00:00:00Alessandro Brighente: To begin such that maybe you have longer breaks.
00:12:780Alessandro Brighente: okay? So we were talking about device authentication.
00:17:710Alessandro Brighente: right? So we're talking about Zigbee devices in here, and we one of these communication protocols that we use for
00:24:460Alessandro Brighente: IoT networks.
00:27:280Alessandro Brighente: So
00:28:300Alessandro Brighente: of course, we would like to create networks that are secure. So it means that at certain point there's someone that needs to authorize you to be part of the network and to and for communications to take place. Right? So we have 4 basic set 4 basic
00:44:00Alessandro Brighente: steps for Zb networks. Okay, so we have these. You don't see anything?
00:59:891Alessandro Brighente: Yeah. So we have a
01:02:110Alessandro Brighente: a trust center. Right? It's the the device we should communicate to in order to establish a secure communication right? So we have a key
01:10:810Alessandro Brighente: that we can use to to to
01:14:260Alessandro Brighente: basically Bootstrap, our secure communication. So we have this key, which is the trust center link key. I did so. It's a key that cryptographic key
01:25:865Alessandro Brighente: that should be provided to devices that want to join. Right? So it's something like they have a pre shared secret that they can use to to establish further communications. Right? So you see that this key is provided through out of band means.
01:42:460Alessandro Brighente: what does it mean? Out of band? It means that it's not something that we exchange with the with the communication protocol, or at least not a communication protocol. That is part of the network. We have other means to to provide this key to the to the node that one joint
01:58:880Alessandro Brighente: good. So, starting from this Tclg.
02:03:410Alessandro Brighente: we can establish a new key right? So we can have a key duration functions that. Both the the node that wants to join the transfer center can use in order to to derive a new new security that they have for the use
02:19:330Alessandro Brighente: then, thanks to the the transfer key that we derived at this step, we can exchange partner information. And the further information that we exchange is the actual network key, right? So the the key that you use for communicating in this particular zp, network. And this provides you with all the data that you need in order to communicate also with the other device. Right? So we have these
02:46:845Alessandro Brighente: key radiation functions and establishing a secure context base
02:52:96Alessandro Brighente: on a bootstrap communication between the node that wants to join and the the trust center on net right. This is something that you need a trust center. So this is kind of a centralized solution. And of course, it's a centralized solution. You have a trust center that is responsible of sharing the keys or
03:13:230Alessandro Brighente: delivering the keys to the the nodes that want to join. And then you have dedicated procedures for not all nodes being able to join, or whether the node just went to sleep more, for instance, and lost his connection with the with the network, and then need to reestablish a connection. So you have a lot of procedures for these. But the the key takeaway here that you is that you have these these different steps that you need in order to gain your network key. Right? So we have a single key
03:42:160Alessandro Brighente: for the whole network. It's about the the key modes that we've seen last time. Right? We can have
03:46:540Alessandro Brighente: a single key for the whole network, a key for a pairwise communication or group keys in this session. Here, we have a single
03:55:330Alessandro Brighente: key for the the whole network. So up to now we talked about the personal network, right? So networks that are kind of small in in size
04:05:518Alessandro Brighente: but sometimes these are not sufficient. So we would like to extend our communication over longer ranges. And that's why we have Laura one. Right? So Laura stands for
04:16:990Alessandro Brighente: long range. It's a proprietary radio communication technique. And when we talk about Laura one, we have a long range, wider network, right? So we have. Iot devices that communicate over larger geographical areas, right? It's not confined to the personal network. But it's something like the actual network that you
04:36:400Alessandro Brighente: that you can think of.
04:39:220Alessandro Brighente: Okay. So again, we're talking about an IoT protocol particularly, it's medium access control protocol. And this comes with the enhanced security compared to Zigby or 6 box or other communication protocols you have.
04:55:745Alessandro Brighente: For IoT nodes. Again, we need to. We take. We need to take into account the the low power consumption requirements, the the low complexity, low cost and high scalability. Right? Again, we have devices that resource constrained and potentially a lot of devices communicating with the one another.
05:14:738Alessandro Brighente: Also, in this case we have a joining procedure, right? So for notes to to join Laura, one network. And in this case we have a mutual authentication. So when we talk about mutual authentication, if we have 2 parties communicating thanks it means that one authenticates to the other, and the other authenticates to the one right, so both of them can authenticate each other.
05:38:191Alessandro Brighente: So what are the the security guarantees that we have via one we have that all Mac and application messages are, originally authenticated integrity protected, every play protected, and they are also encrypted right? So in particular, we have a end to end encryption for application payloads.
06:00:870Alessandro Brighente: So here you have, some information on the the Sanders that you use for a lot of one. We have a yes, again, something that we've already seen in
06:13:110Alessandro Brighente: Now the standards.
06:17:50Alessandro Brighente: And you see that we have devices with the unique key they can use or as communication and then globally unique. Identifier. Okay? So all the devices have a globally unique identifier. Right? So here you have the the sample that they use for this identifier, this Eui 64 base
06:40:567Alessandro Brighente: identifier. It's something that is standardized. And then you have identifiers for the Laura one networks. So each network has its own identifier. So then it would be global, unique identifier which is assigned by the Laura Alliance. Okay. So if you establish your Laura, one network and you want to register it for it to be recognized and accessible, you need to talk with the Laura Alliance, which is this
07:06:630Alessandro Brighente: standardization body. The budget deals with Gora networks and being provided with these identifier
07:17:504Alessandro Brighente: good. So again some of some information on which kind of encryption modes that. That you see here you have aes with the c mark for the key for the joining request. And then Cbc. Mark as an alternative, it's not really something we'll dive into, but it's just for you to to know that
07:40:620Alessandro Brighente: they use this this kind of stuff.
07:43:730Alessandro Brighente: And then, you see the keys that you can derive through the through a lot of authentication process. You see that you have a network key, right? So the 1st one
07:56:530Alessandro Brighente: and then the end to end encryption key right, the those 4 application level which you can use. So you have another key for that. So here you have. how these 2 different keys are distributed right for the network key. We have something. That the laura one network provides that we can use to verify package, integrity and authenticity.
08:21:270Alessandro Brighente: Instead, the application key is something that is indeed distributed by the application server, and, thanks to which we can encrypt and decrypt the the application payload. Right? So we're talking just about the the 7th layer. Yeah, the 7th layer of the Isoz model.
08:39:150Alessandro Brighente: So let's start to look at how irrespectively of the the specific communication technology that we use.
08:50:16Alessandro Brighente: Iot team
08:52:810Alessandro Brighente: form, right? So how do we get from a situation where we just have sparse notes to the situation where we have a complete network where nodes can exchange information. So we'll divide these this whole procedure in 2 steps. Right? So the 1st step is to to have to establish a connection, right? Medium application
09:14:890Alessandro Brighente: layer
09:16:700Alessandro Brighente: in here. We talk about assigning resources to notes right? So what does it mean to assign resources? It means to assign nodes, a specific kind of frequency that they can use to to send their information assign them a time slot in which they can communicate without causing interference right? And for them to to understand that there's actually a network. Right? There's some other devices in surroundings they can communicate with.
09:44:980Alessandro Brighente: And then, after this layer 2, we have another layer on top right, which is the actual establishment of routes, right? So how to forward package from 1 point of the negative to the other. So here we use another protocol right? So now that we have a devices that have their own shared resources and
10:06:450Alessandro Brighente: broad a basement resources.
10:09:560Alessandro Brighente: when to communicate and how to communicate. On top of that, we build the partner network which is organized as a graph. Okay, so we'll see how these graph is formed and how to exchange packets between a point and the other of the network. All of these, remembering that we are talking about the security of these networks, right? So we'll 1st see how these formation works for the the year 2 and
10:34:530Alessandro Brighente: some attacks against that, and then we will go to the routing part and see
10:39:870Alessandro Brighente: how these attacks work. So in here today, we'll just take a look at the
10:46:917Alessandro Brighente: the theory behind these attacks and then on not next week. The week after that. We take a look at simulators on how?
11:00:653Alessandro Brighente: Yeah. So basically, one of the most things most used software for IoT devices is these simulator? Right? So it establishes an IoT network. And each node in in this network we use, which is an operating system for IoT devices right for constraint devices, and it has the whole suite of protocols that we'll see today. So on
11:28:350Alessandro Brighente: in 2 weeks we will see the the whole implementation part of these things that we see today.
11:35:298Alessandro Brighente: With the idea that you will.
11:39:510Alessandro Brighente: we'll implement these attacks. Okay? So it's kind of a a lab, and I will send you the information that that you need in order to install everything on your machine such that when
11:49:656Alessandro Brighente: you come to the lab in 2 weeks. If you can bring your machine or create groups where you can work on software, it would be really nice.
11:59:530Alessandro Brighente: Good. So let's start with the with the network formation. We say that at the year 2 we have these i. 3, 8 dot 2 dot 15 dot 4, right? So mock protocol.
12:09:470Alessandro Brighente: and so in here. We want, as as I mentioned before, we want to assign nodes. Resources like use. This specific frequency at this time transmit during this time window right? And this is very important, because again, we have a network which potentially is composed by hundreds of nodes.
12:31:700Alessandro Brighente: and if all of them communicate at the same time and at the same frequency, it will be a mess in terms of interference. Right? They would, they would not be able to communicate.
12:39:770Alessandro Brighente: So with this whole, it lead 2 dot 15 dot 4 we want to provide resources that nodes can actually use to to establish successful communication, effective communications.
12:54:380Alessandro Brighente: How do we do that? Well, we said that one of the most that we can use is these 6 dish, right? So where the dish part stands for times, lot attention, hoping
13:04:190Alessandro Brighente: right? So you can imagine, the the whole frequency and time components of the network as a grid. Right? You have these 2 dimensional grid on one side. You have the the frequency on the other side. You have the time, and now the the let's. Let's say that we play a game right? We should allocate notes to these different
13:27:127Alessandro Brighente: points of the gridor, such that they don't. They do not interfere one another. So specific nodes are assigned a specific frequency and time.
13:34:980Alessandro Brighente: It's not
13:36:40Alessandro Brighente: okay. So this is exactly what these time slot that hoping is doing. We divide time into slots. And then we assign again frequency resources. But bear in mind that these frequency resources change in time. Right? It's not like a specific node is assigned frequency. One. And we'll use that frequency one forever. No, that's not like that
13:57:520Alessandro Brighente: channel hoping channel hoping means that in time the frequency, the current frequency that these the the single node will use is changing. And then it's changing. According to some algorithms, you have many different implementations of channel hoping we will see a deterministic deterministic implementation is what is the one that you find in the standard? But why do we change these this frequency. Well, because
14:25:50Alessandro Brighente: we want to provide the diversity, the network right? We want to provide the users with fair share of resources.
14:34:60Alessandro Brighente: And at the same time, this channel, hoping thing is something that you can use to prevent jamming attacks, for instance, right? Because if an order is always using the same transmit frequency to deliver its package. Then an attacker knows exactly where to to convey its noise signal. Right? It's the thing that we've seen for for the car keys, for instance, right? The car key is using just a single frequency. So once the attacker knows, the frequency can generate
15:01:410Alessandro Brighente: the the the noisy signal on top of that, whereas if we are using these channel hopping frequency channel hopping, the transmit, frequency is changing right? So unless the attacker can predict the next transmit frequency that device will use, it will not be able to continuously jam the the transmitter right?
15:23:400Alessandro Brighente: Good
15:27:550Alessandro Brighente: 10.
15:29:110Alessandro Brighente: Of course, if we have So this concept of the grid is nice, right? Because as long as we have sufficient frequencies and sufficient time slots, we can allocate all users in a let's say, or or tolerant way, right? They did not interfere with the one another. But then.
15:49:687Alessandro Brighente: the the frequency range that you can use is limited. Right? It's something that is regulated by authorities. You can transmit in just a specific frequency range for for your network. And then
16:02:650Alessandro Brighente: so you you have a combined set restricted. If you want set of frequencies that you can use.
16:09:10Alessandro Brighente: So the alternative to to allocate all devices with the different share of resources is to have more time slots right? So
16:19:180Alessandro Brighente: ideally, if you have a large number of devices. We'll need a large number of time slots, but then, if a device is assigned a single slot every I don't know 10,000 time slot, you said, you have a problem, right? It's low rate. Okay, it's slow rater as a network. But you don't want to wait 5 min. Be between a packet and the other, and that's not something that you want.
16:40:990Alessandro Brighente: So sometimes it happens that the nodes need to share the same resource and time and frequency resource. And in this case we have something which is called the Csm. Aca. Right? This guidance says, multiple access with condition avoidance. It's a way of accessing the the
17:00:830Alessandro Brighente: the resources in the network. It's something that we briefly seen during the during the last lecture.
17:09:245Alessandro Brighente: Basically what we would like to do with these. Csm, Aca is let's say that we have 2 nodes right, 2 notes that are assigned the same time, frequency resource, a specific time. So they will both try to transmit on that specific slot right? And then, thanks to these Csm aca, what they will do is try, transmit into that slot.
17:31:750Alessandro Brighente: and verify whether the slot is or not occupied by another transmission, and if it is not, then it will actually,
17:40:900Alessandro Brighente: transmit their message. If you said it's super bad, they would not do that. This prevents this prevents collisions right? It prevents devices not being actually able to to communicate.
18:01:990Alessandro Brighente: so it's a question for you is a medium control protocol, something that you've seen somewhere else. You have the wireless course or networking stuff.
18:10:720Alessandro Brighente: It's optional, it's optional, so you don't really know what what this thing is okay
18:24:319Alessandro Brighente: okay, yeah, maybe I can I can add to the to the website some some time out of these this protocol, just for you, if you don't know and you are interested into understanding why this this thing works and which guarantees you can have
18:37:470Alessandro Brighente: it would be it would be interesting.
18:40:858Alessandro Brighente: But yeah, for for what you care in this context is the fact that you need to share resources right? And you have dedicated algorithm that provides notes with the resources such that they do not collide with with one another and do not interfere.
19:00:130Alessandro Brighente: Then how
19:02:00Alessandro Brighente: so? What is this mechanism that we use to provide the devices with the time and the frequency resources.
19:10:560Alessandro Brighente: So we said that we have different functions that we can implement to to run this as
19:19:250Alessandro Brighente: assignment.
19:21:161Alessandro Brighente: And in here we look at the deterministic function. Right? So this is exactly the function that that you use. Right? This provides you with the with the frequency, the specific frequency that the the node should be using. You need communication.
19:37:810Alessandro Brighente: Okay? So you have a this function in here, which is kind of unique for each node.
19:46:240Alessandro Brighente: And so why is it unique? Well, because you have something in here you have a lookup table, and you have a set of frequencies that you can use. You cannot come up with random frequencies. There's just a specific set of frequencies. Again, that you can use. And this is provided through this lookup table. Okay? So the the output of this function is it's like
20:07:880Alessandro Brighente: key value dictionary. Right? So you provide a specific key and you get the the value output. Of course, these is more the number of channels. It's just these specific number of frequencies there that you can use. Right? So you need to have these rotational mechanism because these this part in here instead is increasing. Right? It's something like
20:33:724Alessandro Brighente: this is the part that depends on the noder itself, right? That it allows nodes to use the same function, but at the same time get the different share of resources.
20:46:460Alessandro Brighente: So these is the summation of the absolute slot number. Okay, that you have here. The definition is the number of times starting of the network. And so we establish the network. And then we count how many times of fast man. And then you have the channel offset, which is something it's an integer assigned by the by the scheduling algorithm.
21:11:210Alessandro Brighente: Right? So what does this thing mean? It means that the node at a certain point would join the network right? It would join the network. After that. A certain amount of time has has passed a certain number of time slots and it chooses a channel offset. Okay? An integer.
21:28:850Alessandro Brighente: Okay, this provides the the node itself with something I wouldn't say unique, but at least different from from that of other nodes that are already part of the network, or that will in the future join the the network.
21:43:850Alessandro Brighente: Okay? And this is somehow a representation of what you what you have in in these shared frequency shared resources set.
21:53:670Alessandro Brighente: Okay. So you have time divided into slots and you have slot frames. Right? You. You come for a certain number of time slots within each frame, and ideally, each node should be provided access to one at least one set of resources in each frame.
22:09:690Alessandro Brighente: Okay? So here you see that you have the channel offset, which, is the frequencies that you can use the actual communication frequencies. In this case you have 5 frequencies that you can use, and then you have a 5 square each of frame. And the algorithm that you've seen before, right? This deterministic function is, what does the device? Which of these.
22:32:840Alessandro Brighente: at which time? Instance? Okay, it's not perfect in in the sense that if you have many devices, of course they will, there will be collisions, but this is handled through System Aca, but it works okay it it.
22:48:730Alessandro Brighente: The it provides you. Some guarantees on the quality of service that you get on the
22:54:130Alessandro Brighente: the, the fair share of resources for advice. When we talk about medium access control, we talk about fairness
23:01:750Alessandro Brighente: of the of the network.
23:04:250Alessandro Brighente: Okay, so good. So just to give you some some hints on how attacks
23:15:440Alessandro Brighente: will work in here, and why we will have problems in implementing channel hoping algorithms
23:20:834Alessandro Brighente: this specific function in here. Right? It's a kind of a
23:27:100Alessandro Brighente: what would be very simple, right? Instead of having these this function.
23:32:480Alessandro Brighente: we can just use a counter right, and the node joins and use time frequency one. Then it uses 2, then it uses 3 and uses 4, then uses 5, then it goes back to 1, 2, 3, 4, 5, good. This would be super simple, and this is something that both the transmitter and the receiver can agree upon. When the node is joining the network, the receiver would know exactly which communication frequency would use.
23:56:510Alessandro Brighente: And that's very convenient right? You want the receiver to know which frequency the device is using. Otherwise it's receiving anything. It simply doesn't work
24:05:450Alessandro Brighente: good. So this is nice. But in terms of fairness guarantee, as we've said before, it's not that good and in terms of attacker. Well, it's very simple.
24:18:80Alessandro Brighente: If I know when the the node joined. I know exactly which frequency it's going to use, or I don't even care about knowing when the the node join right? I can just check which frequency node is using right now, and I would be able to predict the next one. And it's very simple. It's deterministic. It's just plus one at a time
24:37:730Alessandro Brighente: good in here instead, something a bit different. It's not like that, right? It's it's an in-between. It's not random, and it's not random. It's a deterministic function. But at least it's not as simple as increasing the counter by one.
24:54:420Alessandro Brighente: Okay, so this is better in terms of fairness, it's better in terms of
25:02:230Alessandro Brighente: not being that easy to predict. But still it's something easy to predict, right? It's something defined by the standard. So everyone knows this function is not something that the transmitter and receiver will agree upon, and has some secret that it's not
25:16:577Alessandro Brighente: available to attackers. Right? So if we know as attackers, we know that we are using these times, hoping we know exactly the the function to implement, to to predict the next channel that the the the transmitter will be using, and then we'll be able to to jam it
25:38:590Alessandro Brighente: so ideally.
25:40:460Alessandro Brighente: What would be really nice ideally, we would like to have something that is random, and because if it is completely random, then at least from a security point of view.
25:48:860Alessandro Brighente: it's not possible for the attacker to predict the assignment that the node will be using. But if it is random, how can the transmitter and receiver agree upon the the frequency that they will be using right. It's not the trigger tool to do. At least they should have some pre-shared secrets and generate some random numbers according to
26:10:462Alessandro Brighente: to a certain function that is not random. Right? It's observed Number generator, and and then randomness.
26:23:220Alessandro Brighente: And it's something like devices will be assigned according to a uniform distribution, one of the slots that they have
26:31:220Alessandro Brighente: available.
26:32:710Alessandro Brighente: and then the collision probability it's it's not that good right. So in terms of fairness, it's not good. So to have these in between the between usability and kind of security. This is the most use function. You see, it's not
26:50:560Alessandro Brighente: perfect, and it's definitely not but at least it makes the
27:00:310Alessandro Brighente: attacks against this. And I'm hoping right. So the game is how to print, to to defend the network against a very simple attacks that can simply predict the next frequency to to jam.
27:14:790Alessandro Brighente: But now let's move a bit higher than the than the physical layer. Right? So generally, we're talking about physical layer sending this noise signal. And here we want to. To exploit something a bit more structure in terms of protocol.
27:30:540Alessandro Brighente: So here we talk about the the 6 dish network formation. Right? So how do we actually get to? After that we get our shared resources? How do we establish a network to let the nodes know that they are actually part of a network.
27:45:110Alessandro Brighente: So in these 6 stage network, we have a root node. Right? So again, as I mentioned, we'll we'll be forming graphs and in graphs we have
27:56:650Alessandro Brighente: rooms.
27:58:00Alessandro Brighente: And in this case, in 60 network, the the route is called the Joint Register or coordinator at this Jrc, and what the Jrc does is to periodically broadcast some basic information. Right? So we have these enhanced beacon frames which contain basic information about the network, right? So it contains information as the Jrc. Id. The duration of a time slot the number of time slots in a frame, the channel, open sequence, sequence.
28:25:640Alessandro Brighente: and the location of the shared cell. Right? So it contains all this information in here. How many of these also there, in a soft frame. How many frequencies are there which function to use to predict the next frequency to use
28:40:280Alessandro Brighente: right? And how long each of these lock is in terms of time, right? And then, you see, there's another information here. Location of this shared cell, which is is a shared cell. But since we're talking about medium access control, we will have times in which no device in transmitting that it's just trying to access the resources.
29:03:800Alessandro Brighente: And then we will have times in which we have the translation of the actual data, right? So in the shared cell devices are trying to
29:12:300Alessandro Brighente: have access to the resources.
29:14:380Alessandro Brighente: And we need to know when this is right, because a node that wants to join the network needs to send its packet in the in the shared set to try to be part of the network. And then, when we talk about nodes that want to join the sixty-ish network, we are talking about pledges, right? So the pledges are the new nodes that want to be part of these 6
29:37:330Alessandro Brighente: network.
29:42:220Alessandro Brighente: Then it moved slide. But no.
30:14:730Alessandro Brighente: okay. So
30:16:840Alessandro Brighente: what happens when pledges. Want to want to join the network? Right? So the 1st thing is to to listen for enhanced speakers. Right? The pledges cannot be. Grc, right. They cannot be the router of the network, so they need to listen for the route to tell them how to use the resources available, so they need to receive a valid, enhanced speaker.
30:41:890Alessandro Brighente: Good. So when it receive when a pledge receives an enhanced weekend from, I know that is already part of the network. Then.
30:50:710Alessandro Brighente: by getting all this information gets to the state where it needs a dish synchronized node. Okay? So it knows what is the timing of the network knows the the.
31:03:740Alessandro Brighente: the resources of the network. And we'll try to access the the network through these structuring here. Right? We said that we need to try to access the network to tell the network. We want to be part of that during these shared frames.
31:24:290Alessandro Brighente: Good. So again, we can. We can see the network as being organized as a destination oriented directly representation. Here you have the Jfc. Which is the root, and then all the other notes. Here you have all nodes are already part of the 6 network. Right? So maybe all
31:47:268Alessandro Brighente: have their resources, and they actively communicate within this fish net. Now you have a pledging here the pledges? No? Then it waits for enhanced speaker. Right
31:57:381Alessandro Brighente: so in order to to have these enhanced. It needs to wait for that. Then the problem is, sometimes they the note doesn't get anything right. It's it's listening, but no one is telling anything to the node.
32:15:700Alessandro Brighente: So if the node doesn't receive anything after a certain amount of time, what it can do is to send these Eas package right? All the information solicitation it asks the for nearby devices to provide it with the information that it needs. In order to move on with the with the connection.
32:37:50Alessandro Brighente: and then at the point, if we have a node that is already part of the network and that can provide this information, it will respond with the with package. Right? These information object which has these
32:56:130Alessandro Brighente: right?
32:57:700Alessandro Brighente: Good. So if we have these this information, then we can be an Api join node apart of the network. Now, what is the problem? If the node.
33:13:10Alessandro Brighente: if the node needs to join the network right in this sense, it's we are talking about very low layers, right? We cannot have. I mean, we can have a encryption. We can have the security measure, but it's something that we don't have. In 16, right? So these packets are not encrypted, and there's no security mechanism in this.
33:33:220Alessandro Brighente: I mean, we want nodes to be able to join the network. But
33:38:210Alessandro Brighente: this mechanism of sending information solicitation packets. It's something that attackers can exploit.
33:44:230Alessandro Brighente: Right? So in particular, we're talking about these
33:47:740Alessandro Brighente: these attacks. Yeah, yes, right? So what the this attack does is having a a pledge right? A malicious pledge that is sending these yes, packets over and over again, and triggers nodes that are part of network of sending back these daio packets. Right?
34:11:719Alessandro Brighente: What is the effect of this? Well, the the effect is that we will have the shared resources to be full with these packets, right? A lot of them, and then we will also increase the energy consumption of the nodes that are already part of the network. And this is bad, right? When we're talking about IoT devices everything that makes the device consume more energy than what it should for tasks that are useless
34:39:182Alessandro Brighente: is a potential source of attack. And we are talking about power or battery depletion. All right, these attacks. Something goes towards that direction, because if the node continuously need to send the
34:51:100Alessandro Brighente: these the I/O packets that will increase its power to something.
34:57:390Alessandro Brighente: Okay? So these is an illustration how this thing might work right? So you have the malicious ledger in here. This is sending these package right and sending them to all the the notes that are within reach of its communication. And then all these notes would receive the package will respond with the Via package. Right?
35:26:440Alessandro Brighente: What happens in you see what happens in here? Right? So not only you will increase the power consumption of these notes, but you will congest the the shared cell. Right? And why is that bad? Because, if we congest the the shared cell. It means that potentially in your notes that want to join the network will not be able to to join the network anymore.
35:49:850Alessandro Brighente: Right? And these not not only holds up for new nodes that want to join, but maybe to. It also holds for nodes that were already part of the network that lost their connection, for whatever reason. And this is something that happens very often in in IoT networks, you cannot expect all the devices to be always on and always transmitting something right at a certain point. It would just
36:11:986Alessandro Brighente: go to to sleep mode, for instance, or lose their connectivity with the with the network, so they will need to rejoin.
36:18:540Alessandro Brighente: and these will not be possible in this time. Slot in here.
36:29:210Alessandro Brighente: Okay, everything cleared, questions, doubts.
36:36:102Alessandro Brighente: What does it mean from a security point of view and a legal point of view of.
36:53:100Alessandro Brighente: because I know that, like in software, if you go and we reversing the meeting on software.
36:59:430Alessandro Brighente: It's like a gray zone, because I know that Sony will
37:03:950Alessandro Brighente: to be honest. But there are other stuff like, I don't know, Microsoft.
37:13:90Alessandro Brighente: if you do it, they will just say, Thank you, will. We are going to patch it, and they gives you one, too. So
37:19:840Alessandro Brighente: so we speak about the around your communication between what?
37:24:980Alessandro Brighente: What's the boundary? So for law, I'm talking about Laura now. What happens in here is that it's proprietary in the sense that there's an alliance between behind these communication protocol. So if you want to to say that you have a lot of network, you need to talk with them. It's not like I established my. It will show up. No, it's better that you talk with the alliance, and you have the
37:50:940Alessandro Brighente: your identification number, for instance, and it's not something like the the protocol is.
38:00:110Alessandro Brighente: it's not open source, right? It's something we send. And then you find everything that you want related to the the protocol online. So there's nothing to reverse in there. Okay, it's just something about. We have the alliance. We have a centralization body for this. If we want to work on this specific matter, then we talk with the with the Alliance.
38:21:780Alessandro Brighente: Let me, Censive.
38:23:820Alessandro Brighente: There's not any money that I would save.
38:30:480Alessandro Brighente: Hey, let's have a break.
38:43:295Alessandro Brighente: Yes, that's a moment.
38:47:810Alessandro Brighente: Okay. So now, building on top of the
38:53:820Alessandro Brighente: the the situation. I thought, we said, that we have access to resources. We know when to transmit and how to transmit.
38:59:780Alessandro Brighente: The point is addressing right. So how do we get to transmit a packet from a point to the other of the network? So what we see now is the Ipv 6 routing protocol. Right? So we have the the actual protocol to deliver these packets. Usually you see it with the chronic.
39:17:550Alessandro Brighente: and so Rtn is the again. Epv, 6, routing protocol was developed by the Internet engineering task force is Ietf
39:28:109Alessandro Brighente: which has this group dedicated to routing over low power and loss in actors. This role working group
39:35:654Alessandro Brighente: and as you can imagine, it aims at providing this service right surrounding packets in low power in those scenarios
39:47:940Alessandro Brighente: kind of routing algorithm does this implement, we're talking about the distance vector okay, so it means that we have devices that are organized according to a directed, I'll see. Figure out very similar to what we've seen before, right? So these nodes that have access to one another where we have. I don't know.
40:05:780Alessandro Brighente: And the distance vector, means that we measure the distance in terms of a number of hops.
40:12:800Alessandro Brighente: Why do we care about this, because we know that if we want to deliver a packet to one from 1 point to the other of the network, and we need to be faster. We want to minimize the number of hopes required to to deliver the packet right? So the number of nodes through which the packet needs to go through to reach its destination.
40:39:30Alessandro Brighente: Good. So
40:42:30Alessandro Brighente: this is nice. So it means that we need to to build our routing table routing tables. According to these these vectors, right? So associated between each source and destination, there will be a specific number of hopes recorded into this table, and
41:00:550Alessandro Brighente: the fact of organizing the the network as a graph, as directly graph, it provides us with the, with the feature that we have no loops, right? So it means that there's no packet to get stuff into a loop and never delivered to to.
41:15:730Alessandro Brighente: It's a destination.
41:24:190Alessandro Brighente: Right? So think it's here. But it's so what I knew.
41:29:590Alessandro Brighente: So this is the kind of graph that we have. Right. So here we have the root node. Every part is designed so that it can get the the root
41:41:460Alessandro Brighente: and then this is the graph that we implement, for instance, right. So if a packet wants to send the if a note one wants to communicate with No. 2, let's say what it will do is to send its packet to this node. Here, then, get to the root. The route knows how to forward the packet, and we send it here right? So we know the number of hopes we do not have any
42:06:550Alessandro Brighente: and loops. But then let's say that we have a
42:10:830Alessandro Brighente: something like that instead. Right? We don't have a direct secret anymore. So the ways in which one can communicate with 2 is through these routing here right it could be through these routing here.
42:25:350Alessandro Brighente: but then we can have something like. Is also this one in here right so many times, and then deliver here. We don't want this kind of things to happen. Right? So it's a valid rule. But it's not something that we want. So the fact of having directly it means that we cannot implement these this kind of stuff in here. And we optimize the the the resources of the network and the the ways in which packets are
42:55:580Alessandro Brighente: delivered their destination.
42:58:800Alessandro Brighente: Wait in this case, so it it will always go through the the route.
43:05:550Alessandro Brighente: Yes, we have different sorting modes for this. We'll go through
43:09:236Alessandro Brighente: to this topic in a couple of slides. But yes, you need to go to the router, because that's the the one the root. Sorry, because that's the one that knows everything about the network and knows how to forward the information ideally. The network is very large, and you have many nodes. You cannot allow to have a complete routine tables inside each node, because it requires a lot of space
43:29:727Alessandro Brighente: the root. Notice that has that space and can contain information about everything. So you can segment your network right and say, Okay, this node in here only knows about parts in its area. But then, if it needs to communicate with another region. It needs to pass through someone that knows how to forward this information. Yes, there's something similar, and we'll see that. So I get it?
43:57:530Alessandro Brighente: Yes, because again you are, you're relying on some information that the node is provided right? So I'm telling the network that the number of hopes that I need to reach that destination is N.
44:08:550Alessandro Brighente: But there's no means to to verify this this end. So it's kind of similar to what you have.
44:15:640Alessandro Brighente: Hmm!
44:18:950Alessandro Brighente: But we'll have either.
44:21:930Alessandro Brighente: That is not related with the, with the
44:25:730Alessandro Brighente: verifying, the information that the node provides to to the network.
44:29:910Alessandro Brighente: And it's a matter of. I'm telling you the number of hopes.
44:33:100Alessandro Brighente: and you are relying on the fact that I'm telling you the the correct number of hopes without the
44:38:400Alessandro Brighente: sending packets. Phenomenon.
44:40:400Alessandro Brighente: Hmm, okay. So here's a representation of how these dog network related to Rpl may look like.
44:54:400Alessandro Brighente: alright. So we can divide these whole dog into different sub matters. Right? You have some dogs in here, and you see, we have different rpl, instances. Right? We have one. Here we have one here we have one here.
45:10:720Alessandro Brighente: and each of them is associated with its root node right? And so in here, in this one. It is bigger than the other. But you services you can create super daughters, right? So we have a smaller dollar in here where we can root information in in this fax in here. Right? So
45:31:430Alessandro Brighente: without necessarily go through the through the root node
45:38:550Alessandro Brighente: good. So
45:42:420Alessandro Brighente: Now, each note. The who wants to communicate in these in this matter
45:49:740Alessandro Brighente: can define its own objective function. Right? So what is it important for? For a specific node? Is it important to have a very low latency? Is it important to have reliability? Is it important to have a higher rate than the others. Right? So what is it that the node wants?
46:08:660Alessandro Brighente: Good? So basically, we can nodes can define their own objective functions?
46:14:260Alessandro Brighente: Alright. So we have. have. This objective function is something that we can define in each node. We'll see that this is something that that you can control in the OS,
46:27:900Alessandro Brighente: and we have these configurations like the the automatic utilization objective, the the rank which node so how distant is a node from the from the root node, for instance, and the selections of parents in the right. So when we talk about the graphs, you know that the node needs to know its parent node. It needs to know the 1st node is connected to
46:54:810Alessandro Brighente: okay. So these information is something that you have in the in these configurations, and
47:03:120Alessandro Brighente: this information is something that you have in the configure configuration.
47:06:150Alessandro Brighente: Then.
47:08:350Alessandro Brighente: when we talk about node ranks right? Each node is assigned one. It's an unsigned integer. Which, as I mentioned before, is the the number of hopes that separate the node from the root of its daughter from its Rpn. Network.
47:26:460Alessandro Brighente: This one in here, for instance, will have
47:29:396Alessandro Brighente: this value equal to 2. Right? There's 2 hopes that you need to go through to get to its, you know.
47:38:325Alessandro Brighente: But these are right, so
47:42:240Alessandro Brighente: is it here? It's soon when when we care about the number of hopes.
47:48:290Alessandro Brighente: But, as we mentioned before, we have objective functions, so these objective functions control the number to be assigned to these. this note rank, right? So because if we care about
48:00:140Alessandro Brighente: latency, for instance, and we know that one example
48:20:470Alessandro Brighente: yeah.
48:29:410Alessandro Brighente: no, I cannot come up with a guy.
48:31:798Alessandro Brighente: The point is,
48:34:220Alessandro Brighente: these are objective functions. Right? Assign a value to each of these link. Right? So my value can be, one hope, right? Just a single node separate me from there with node, or the value can be. I know that this link has a certain latency
48:50:730Alessandro Brighente: right? And when I send something in here. I expect this latency to occur, or these can be something like, I know that this link has a specific communication rate. Okay? So based on that. I can define the the node events right? And this is community right? Because if I care about latency here, and let's say that I have lx and LY. These node is separated through
49:14:560Alessandro Brighente: with the root node with these links. So it's not. The rank would be something like this summitation
49:21:270Alessandro Brighente: of being the latencies of the the links that separated from the from the root node.
49:29:180Alessandro Brighente: Okay? And these, of course, is something that you see, it's monotically increasing, either, because it's an unsigned integer, right? We we add them when we go through a specific part.
49:43:930Alessandro Brighente: And
49:50:640Alessandro Brighente: I have it. So.
49:57:208Alessandro Brighente: Let's say that this is the route number right? And then we have this situation in here.
50:03:450Alessandro Brighente: and we know the the latency, one latency, 2 and latency 3.
50:09:350Alessandro Brighente: Now I have a legend here that you know that that wants to join right? So for us in this sense, in terms of the god. So joining means selecting the the parent node. Right? So how does these node select the parent node? Well, we can evaluate the node or anchor that you have in here.
50:29:320Alessandro Brighente: right where you can evaluate and based on that, you decide them what the
50:36:890Alessandro Brighente: what it's best for for this node. Right? So let's assume that, for instance. let's say that l, 1 is greater than l. 2 plus l. 3, and talking about latencies right. So if this is the case, it doesn't make sense for node 4 to to join through node, one right to select node, one as a parent, because
51:00:300Alessandro Brighente: it cannot have latency guarantees. If he said it cares about the number of hopes right? Not the latency. We don't care about the the quality of the communication here, you would just need to minimize the number of hopes it passes through in order to get the no download form will select the one as it's very known. Right? So this is what
51:19:161Alessandro Brighente: I mean when we say that these node ring helps us in defining the the structure of the network. Right? We we need to decide how we want to join the network.
51:32:320Alessandro Brighente: Good. So also, in this in this situation, we have a a dollar information object? Right? We like this package
51:39:930Alessandro Brighente: a lot.
51:41:880Alessandro Brighente: And again, it's something that
51:45:225Alessandro Brighente: when Node want to join, they need to have access to this information because they contain the basic information related to the to the Api instance, right? That related to the graph engineering here.
51:58:00Alessandro Brighente: Good. So you see that you have, the the identifier of the Rpl instance, the the network we have, the Rpl instance id, we have the dog. Id. We have the daughter version number the Rpl. Mode of operation right? Whether it's a story mode, for instance, forward mode. This is something we'll see
52:16:72Alessandro Brighente: very shortly. The rank of the sending node right? The ranker is this value that we were discussing and the global configuration? Right? So how is the the graph structured.
52:30:311Alessandro Brighente: These messages are usually multicasted by notes.
52:36:650Alessandro Brighente: Okay, so Multicus, it means that you have that you are sending this packet or unintended range of receiving addresses by the software. It's not for for everyone, but it's just to
52:51:50Alessandro Brighente: specific nodes. Okay, in these is how we transmit the visa.
52:57:745Alessandro Brighente: Messages!
52:58:360Alessandro Brighente: And then also, in this case we have the dog information solicitation, right? So we can probe our neighbors. And let them have them sending us the information about the the dog.
53:12:670Alessandro Brighente: And of course, also here we have the the vulnerability that we've seen before.
53:18:991Alessandro Brighente: Then other type of control messages that we have in Rpl, the, we have destination advertisement objects
53:28:47Alessandro Brighente: and these. So when we talk about the gas packets. We talk about packets that we send up upwards right from the from the leaves to the root of the the graph in here instead. When when we talk about these dao, we talk about downward roads, right? So from the router up to down the leaves.
53:51:330Alessandro Brighente: Okay? So why do we need that because they provide us information on the path that we need to to go through.
53:59:20Alessandro Brighente: get the specific recipient node right? So this is something that we use to create the the routing tables.
54:05:490Alessandro Brighente: So, for instance, if Node 2 needs to
54:09:344Alessandro Brighente: to know how to reach, not, for instance, let's say this is connection, not to need to know about these specific notes, right? So it uses this, the Ao packets to do that
54:22:380Alessandro Brighente: right. So of course in here. I'm drawing arrows, and you have arrows also in the figures. But there's no actual physical connection, right? It's
54:31:910Alessandro Brighente: we are always talking about wireless connections.
54:37:160Alessandro Brighente: Then we have a consistency check as control messages again in Rtn.
54:44:787Alessandro Brighente: So these are something that we use partially for security. And we have counters and timestamps.
54:52:291Alessandro Brighente: We have challenge response mechanism to to defend against replay protection. And so we have these
55:00:930Alessandro Brighente: the basic means here.
55:06:240Alessandro Brighente: basic means are not there by default, right? But if we want to to have them, we need to
55:12:610Alessandro Brighente: to deploy the rpl secure mode. They need to to know that
55:16:600Alessandro Brighente: they're using these kind of messages to instantiate all the variables that you need for that
55:25:690Alessandro Brighente: good. So also this case information and the net. Information is made through these packets. Right? The I/O package services.
55:40:580Alessandro Brighente: good. So what happens when a note that receives it's
55:46:470Alessandro Brighente: flash via your message right? So you have a series of 4 steps that you see right? So the 1st thing is to calculate the its own rank, either to compute this rank, to to have it there ready when it needs to deliver its own messages
56:03:44Alessandro Brighente: decide on which product to join right. There might be multiple dollars around, and you want to join the one that is more convenient for you. Right? So so I mean.
56:14:710Alessandro Brighente: this might be the situation. Right? You have these 2 dogs in here, and you don't really care about connecting to this one and this one you just care about connected to the one that provides you with the best quality of service for yourself, according to to your objective function. So you can decide which one to join
56:33:990Alessandro Brighente: And this means basically that you need to decide your parent right? So you need to decide which the next one and separates you from the, from the room, and then you need to multicast your own message, of course, changing the rank right. The new rank is the the rank that you computed for for yourself as the new node that joins the the network
56:59:50Alessandro Brighente: good. So we want to maintain a topology, and we would not like the the topology to to change that often, because if the topology changes, it means that also tables need to change, because we need to change the way in which we reach a certain destination. And we said that this is something that might happen in IoT networks right? Because nodes are not always there. But at the same time we don't want the network to change. So
57:23:700Alessandro Brighente: we need to exchange these video packets kind of often, right? So every now and then. We just need to send these these packets. And at the same time we don't want to to congest the network with that much information?
57:38:880Alessandro Brighente: Right? So how do we decide? When to send these packets? Well, we have a dedicated algorithm for that. It's called the Trickle algorithm trigger algorithm. And yeah, it's just basically mechanism that Rpi uses to to decide when to send these dao messages. Right? So how does it work. Well, we have that notes need to maintain their counter right? There's a
58:06:500Alessandro Brighente: the O counter and a threshold associated with that
58:09:473Alessandro Brighente: together with the actual timer. So it's a parameter of the trickle diagram right there. It's just a variable that you said
58:17:168Alessandro Brighente: good. So we need to send the your messages when the trigger timer reaches. It's a threshold, right? We we have a threshold for that. So after a certain amount of time pass. We send these video messages, or we send the messages when we receive another via your message that contains some configuration change. Right? So, for instance,
58:43:86Alessandro Brighente: another rank that has changed, or a parent that has changed. And if that is the case, it means that we need to update our view of the network. And therefore we need to
58:53:116Alessandro Brighente: to let the other know that are part of the network, and depend maybe on our new messages to know about this configuration change?
59:04:470Alessandro Brighente: Good. So we need to to increase our counters right? And this is something that happens whenever we receive a message, and we discard it because we doesn't contain any useful information for us that we already part of the network right? And when does this occur? Well, if, of course, when the video packet doesn't include any configuration change about the network, for instance, right? If that is the case, we receive the packet, we can decode the packet, but then we discard. It's nothing we can do with that.
59:33:553Alessandro Brighente: Then we said that we have a threshold associated to these counter right, and if we receive a sufficient number of New Yorkers and we discard them, it means that our counter gets to
59:48:335Alessandro Brighente: to the threshold value.
59:51:310Alessandro Brighente: then we can say that the network is kind of stable right? So if that is the case, we reach the these distraction value without triggering any configuration change without needing to send any. Yeah. Your information, we can relax the the spreading of the information I disagree.
00:11:270Alessandro Brighente: maybe 10.
00:12:870Alessandro Brighente: Argue that the network is stable, and we would like to decrease the level of congestion here. So if that is the case, we reach this threshold value for the EU counter. We reset the all the parameters about the threshold counter, of course, and we double the trigger time. So it means that we we wait twice the time that we waited before
00:34:970Alessandro Brighente: in order to send our Dio packet and this is something that
00:43:250Alessandro Brighente: ideally continues to grow right. So if the network has no changes stable and everything is working fine.
00:49:110Alessandro Brighente: we we
00:52:930Alessandro Brighente: continuously decrease the number of the Ao package that we send in the network. But if at a certain point we receive an Ao package that contains a configuration change, then we reset all the timers right. Everything is reset to its initial value because we cannot deem the the network to be stable anymore. Okay, so we get back to the initial point where we set the chicken timer to its initial value. And we just send the the Au package when needed
01:27:830Alessandro Brighente: is kind of clear.
01:34:330Alessandro Brighente: Then how yeah, how does. Rpl, work. Well, we have different modes of operation for rpm, right? And it depends on how we forward packet, how we we store information, right? So in particular. What we have, is
01:52:930Alessandro Brighente: mainly 3 types of communications. Right? So we have, the multi point to point, which is kind of upward. I think today.
02:03:780Alessandro Brighente: the root, then we have a point to Multi point, right? So here, from the root to to the leaves, and then we have a a point to point communication. So, for instance, from Node one to node, 2.
02:20:780Alessandro Brighente: Look at it.
02:23:150Alessandro Brighente: Okay, so 4 point of a zone
02:26:850Alessandro Brighente: when we talk about the multipoint to point and the point to multi point.
02:31:570Alessandro Brighente: it's kind of straightforward, let's say with what we've said up to now, because we know our parents know instance right? So we know that if we need to go to the route we will 1st need to forward our packet to our parent, and then our parent will forward it to its parent. Blah blah! Up to get with the with the no. Right? So this is information that we have. But if you're talking about point to point communication right, if you want to send an extra problem, not one to know. 2.
02:59:340Alessandro Brighente: Then we need something more compared to to what we have up to now. Right? So in this sense. For them point to point communication. We have 2 different modes
03:11:20Alessandro Brighente: we have the no story mode and sorry mode the ones that we'll see up to now. Then, you have one hope it will be. But this is not something we'll we'll see. We'll just focus on the no story mode and and sorry mode.
03:25:800Alessandro Brighente: So
03:27:470Alessandro Brighente: what you have in the non storing mode, you see. In the figure all the traffic goes up all the way up to the node which is the one that is responsible of finding the right path for the for the packet to reach its destination.
03:48:690Alessandro Brighente: Okay? So
03:52:60Alessandro Brighente: these requires the exchange of different messages. Right? We need the messages that we need to establish the upward route. But then we also need those that define the downward route. So the message that we've seen before, right? So this is something that we need, we need to send the video messages downwards up to all the leaves, because we need to. To know how the information needs to
04:17:383Alessandro Brighente: to get to the last node. Okay, so what happens in here? Node 9 wants to send something to node 11. And we are in known story mode. So it means that we don't save any information related to the route that brings us to No. 11. So the what note 9 does is just sending the package to the node right? It will send this packet containing information about the destination.
04:42:380Alessandro Brighente: so note 9. Will send it to his parents. Blah blah up to the point where we need. We meet the we reach. They they would know now they would know them, knows the the path that he needs to go through in order to reach notice right, and he will just
05:00:480Alessandro Brighente: do the
05:02:80Alessandro Brighente: word transmission here. Right? So all the nodes know how to forward this information, thanks to the these dao messages, right? So in this known story mode, the only node that is responsible for routing tables is they would know. Right?
05:21:10Alessandro Brighente: Yeah, we have just one routing table in the root node.
05:26:640Alessandro Brighente: If we said, we're talking about the story mode. Then we have the each node keeps its own downward route information right? So each node has a routing table, and it just contain information on where to go in order to reach a downward destination.
05:43:340Alessandro Brighente: Okay? So in this case, for instance.
05:46:07Alessandro Brighente: node, 9 wants to send again. 11. Then it will send to this information this package to Node 7, node 7 will check whether it has a downward router that allow him to send the package. Node 11. It doesn't.
06:01:950Alessandro Brighente: so it gets to expire. No. 4, node 4 will check. Does it have a route that brings? It's packet to note 11. Yes, it has.
06:11:350Alessandro Brighente: Because, you see, it's downward. So okay, node 8 node 8 will check whether it's as a downward router towards Node 11, it has. And we'll send this information. You see, that we minimize the number of exchange that we need. We don't need to to reach them to have the information where to forward the package, but we only can forward package to nodes.
06:39:360Alessandro Brighente: That that somehow look at us as they would know right? We that aren't in the downward
06:47:980Alessandro Brighente: But
06:49:471Alessandro Brighente: so how do collect this information? Well, most. In this case we have the Ao messages right? So instead of the root node to send the ao messages to all the other notes in here we have each node that's sending its own. The Ao messages to build its routing table.
07:15:590Alessandro Brighente: Good good. Have a nice weekend.
07:20:540Alessandro Brighente: Thank you.