Good day, DEF CON and Car Hacking Village.
I am Jonathan Petit,
and I'm here with two of my colleagues,
Rashid Ansari and Kong Chen.
We are the research team for Qualcomm
working on connected and automated vehicle security.
Today, we're going to talk about misbehavior detection
and demonstrating you some attacks on VLAN board unit.
So before we start, I think it is important
that we understand what is V2X communication.
So V2X enable devices like vehicles,
pedestrians or roadside unit to be equipped
with an onboard unit, a device that enables
all of those components to broadcast information
in the surrounding to create an awareness.
So in this example, we have three cars
and are all equipped with V2X technology.
And we'll see that now the white car
is performing an emergency brake.
Therefore, because the onboard unit
is connected to the CAN bus,
it can detect that there is a high deceleration,
for example, and that in the brake pressure,
and therefore we'll be able to generate a message
that he's sending to the surrounding vehicle.
So those messages are called basic safety message
here in the US, so that's the BSM
that we're going to talk about in this talk.
When the vehicle receive a BSM,
they are able to understand that the white car
is performing an emergency brake,
and therefore themselves brake,
avoiding a chain of collision.
So we see the huge benefit, safety benefit,
especially in that V2V use case that we are showing you.
This is an emergency electronic brake light application,
and it's consuming BSM sent by other vehicle
to understand an emergency brake is happening.
So there is many application for safety
and auto efficiency that are designed for V2X.
So this is the context here.
We are looking at those type of application.
So then, of course, we understand
that from a security standpoint,
we do not want external attacker
to be able to send bad messages to the other vehicles.
So all the messages that are sent
are actually digitally signed.
So in the same example we just showed before,
now we have the white car is actually signing
with this private key, attaching a certificate,
the message before sending it.
The receiver will use the keys in order to verify
that this is sent by an authenticated vehicle.
Good.
But as you might imagine,
this doesn't prevent any bad content to be sent.
You could be authenticated, but sending wrong information.
So here in our same example,
we have here the white car is an attacker,
is sending a fake EBL to the other vehicles.
The other vehicle will verify the signature.
It's all valid.
Therefore, they have to use a content
which says it is an emergency brake.
Here in the animation you just saw here,
the blue car didn't stop.
And you might wonder why.
It's because we can make an assumption
that this vehicle was equipped or is equipped with a camera
and therefore didn't see the white car braking.
But the red car has no line of sight
and therefore has to trust that information.
So we clearly understand
and you need a misbehavior protection system
to defend against such attacks.
And this is one we're going to present today
is really about the attacks and how you perform this
and how you protect against this.
So let me show you a little bit
on our example about misbehavior.
Here on the left-hand side,
this is an application called intelligent signaling.
This is where you have a traffic light
equipped with a roadside unit
with the same kind of equipment
to receive the message sent by the vehicle.
And by reading the BSM,
it adjusts the signal phase and time.
Therefore, it's going to play with the red and green
on this different segment coming at the intersection.
And an attack that was demonstrated by some researcher
showed that if the vehicles are sending wrong BSMs,
I'm going to just run the video here,
if you send that, and after 30 minutes of attack,
you can see this long line at each of two,
or actually three intersections,
three segment of the intersection.
So an application that consumed a BSM that is fake,
even though it's purely authenticated,
if you do not do a misbehavior analysis protection,
you might see issues like this in intelligent signaling.
Now looking on the right-hand side,
we have a position jump attack.
So the position here in that representation,
you are, the ego vehicle is the green dot.
You're driving and an attacker is sending messages
with the same identifier, but he's jumping,
he's changing his position.
That's where you see this blue dot,
this is the BSM received.
And it's flickering because it's actually jumping
back and forth.
And sometimes outside of the frame here that you can see,
but it's basically doing it back and forth.
That's the position jump attack.
And what is interesting,
as you're going to hear this sound in a few seconds,
is that sometimes this is performing here
a forward collision warning.
So even though this was a position jump,
you might see you need to detect those kinds of behavior.
Same identifier and still jumping back and forth.
That shouldn't be taken in consideration by an application.
I have other example to show you.
Here, this is another representation of the onboard unit.
Here, this is, we use MATLAB actually as a visualization.
And you are the red car.
And all the other blocks that you see,
the blue and orange one,
are the vehicles also sent by the V2X message.
So you're going to represent this local dynamic map
with all the vehicles.
On the left-hand side, you have the first misbehavior.
It's changing headings.
Because part of the BESM,
there is the position,
there is your kinematic states, your velocity,
but also you have the headings
that helps pass planning, for example.
To know where is this car going?
Especially when you perform pass prediction
when you're using Kalman filter.
You want to use that heading.
And here, in this specific example,
you see the car actually spinning.
So we are changing the heading all the time.
So now your system that consumed the BESM
to perform pass planning
might be really confused by this kind of behavior.
In the middle, we have a single attack.
So this is where an attacker
is using multiple certificates that are all valid at once.
So it could be 20 certificates valid per week.
And for example, you'll be using your 20 or 19,
depends if you want to use yours,
and you send your 19
to create 19 other ghost vehicles on the road.
And you can make them move as you wish.
So that is what happens when you map
all the BESM you receive
and put them on this virtual view.
It is really hard for the connected
and even automated vehicle in the future
to behave in this kind of really noisy environment.
On the right hand side, we have a position overlap.
This is where an attacker is actually overlapping
two of those vehicles.
So here, that is basically what we see.
And here even overlapping with your own position.
And those are just a couple of example
about what we call misbehavior
that are all authenticated messages,
but the content is wrong.
So when we look at V2X misbehavior,
there's what we call a misbehavior life cycle.
So you receive those V2X messages,
and here we gave example about basic safety message
because they are the one commonly frequently sent
every 100 millisecond to other neighboring vehicle.
The first stage is the detection.
You want to do misbehavior detection.
So what do you do in this case?
The goals are to validate the position of the sender,
his motion, its motion, and the presence.
To do that, you can also,
you have to look at the application content.
So the application layer content,
meaning you look at the content of the message itself.
You will look at a different field,
are they plausible, are they actually consistent?
But one important thing is that you need to understand
the effect on the V2X application
that is consuming that ESM.
Because not all messages are actually triggering
an application event.
In our case of the EEBL that we showed earlier,
you will perform an EEBL,
so perform yourself a heart breaking or warning the user
only if the vehicle is ahead of you
with a sudden deceleration, for example,
and a brake status flag at one.
So I could be sending wrong messages,
but I'm not ahead of you,
and therefore it will not trigger the V2X application.
So it is important to understand that
because not all messages are equal
and therefore should be investigated.
As we're going to demonstrate in the demo later,
it is really also important to look at the lower layer
of the IETF stack.
I'm going to give you an example
where you can use signal strengths of the signal
to really identify the position
or the presence of another vehicle.
So, but then really finally,
when you build a detection system,
you need to have a timely detection.
You want a real time detection
because this is a safety of life application.
This is the information is useful to,
in our example of an EEBL to perform an emergency brake.
Therefore you need to detect that attack really quickly.
You cannot afford to wait the whole chain
until the global reaction.
And you have to do this, so in real time, if possible,
and with high accuracy, and that's the performance part
where in some cases, our case, for example,
we want to favor recall over precision
because it is important to capture
as much attack as possible
and really precise only on one attack.
So, but that will depend on your system
and your use case and what you will consider.
So this is everything you need to consider
when you want to build a detection system.
As soon as you've detected,
it's not just enough to detect
and give it to the application.
You need to perform a local reaction.
And two example about what could happen locally
on your vehicle is to dismiss the further messages
from the same identifier.
But as we know, there is privacy by design in V2X,
which means that we, each vehicle are using pseudonyms
and can change them according to pseudonym change strategies.
So what about pseudonym change in this case?
If you dismiss that,
the same standard will simply change identifier.
It's still a question here.
Another reaction that we do locally
is to adjust your kinematic state.
So you will perform potentially a graceful degradation.
Let's say that you are in a platoon of vehicle,
of connected vehicle,
where you use those BSTEM to know that the vehicle is ahead
and agree on the inter-vehicle distance.
And now you detect that in that platoon,
there is a misbehavior.
You better actually say,
oh, let me leave the platoon
or degrade and say,
if this was a level four autonomous vehicle,
for example, you want to go a level three,
you want to go back to the driver,
or you want to warn the driver.
So it is important to think in terms of the cyberspace,
dismissing the further message
and also on the physical space, what do you do?
Then also, when you do your detection,
you will perform, you will generate a report.
That's the reporting phase.
So here, depending on the type of misbehavior,
you will have different type of misbehavior report.
And this is currently under standardization
to actually agree about what should be in that report.
When do you put the evidence?
What evidence do you need?
And this report is important
because it is sent to encrypted
and sent to the MA, the Misbehavior Authority.
It is a component part of the PKI for,
and in our case, the SCMS.
The Misbehavior Authority,
receive all the misbehavior report from different vehicles,
aggregate those misbehavior report.
And it is the only one that can actually link
this different pseudonym to the same device
by actually a process of talking
to the other SCMS component, PKI component.
And this is how, for example,
they could detect a Sybil attack
because they will know that all those devices
are linked to the same pseudonym.
So that is an example
about what is happening in the investigation.
And then the MA will decide what is the global reaction.
In cyberspace, this is a revocation,
for example, of the enrollment certificate.
If you cannot revoke,
as it is the case currently in Europe,
you just block the generation
of future pseudonym certificate for that vehicle.
And then you will put that on,
for example, in the US,
we put that on the CRL,
the Certification of Location List,
that is then provided to all vehicles
so that they can dismiss immediately the message.
But something that isn't discussed yet
is really what happened in the physical space.
You could, for example,
inform the owner of the vehicle, of the device,
and to perform an inspection, to repair,
and therefore to perform a re-enrollment
into the system in a secure location.
Or maybe why not performing
a remote vehicle immobilization?
For now, you are stopping the vehicle where it is
because that's been a misbehavior.
Of course, this remote vehicle immobilization
could be problematic
if this is coming from a faulty sensor
and not a real malicious attacks.
But you know what we are saying,
it's like there's a need of cyber reaction
and physical space also reaction.
So this is the whole misbehavior lifecycle.
And as we can definitely see it,
as an attacker, if I fool the detection part,
you will never report me,
you will never react to it,
you will know no investigation
and no verbal reaction.
Therefore for this presentation,
we're going to focus on this part
about how an attacker can defeat the detection system.
And we're going to show you a progression.
How do we usually do the attacks?
So where are we going to start
and then slowly make it a smarter and smarter attacker.
For this now, I will have my colleague, Rashid.
I'm going to take over to talk to you
about this progression of attacks.
Can you hear me now?
All right, yeah.
Thank you, Jonathan.
So as Jonathan talked about the detection portion
of misbehavior detection system.
So this slide shows you all the possible ways
that we look at right now to detect any attack.
So any attack on the application
or on the physical layer,
or anything.
So let's go over what we do about,
how we go about checking all the,
checking everything in the V2X space here.
So first we look at basic plausibility checks,
where we look at if the speed or angle
or acceleration in a BSM or a CAM message is unrealistic.
Is it too high or is the turning angle
too much as the vehicle?
As you saw in the heading change example,
is the vehicle really changing its heading a lot?
Is this really possible?
And we can do this on a per message basis.
And that's how,
and you don't need a chain of messages for this.
So an attack can be detected
with one message as well in this case.
Then we look at consistency with the sensor.
So we look at whatever messages we are getting,
like whatever speed you're getting,
you compare that with, let's say a radar,
like if a radar is tracking any other vehicle,
whatever speed that radar,
that you can calculate using the radar input,
you compare that with the information you're getting
in the V2X, in the BSM.
So that way this can also be done in a per message basis,
but can only be done on vehicles that are nearby.
And by nearby, I mean in line of sight,
because radars, cameras can only work in line of sight,
but not in non-line of sight.
Similarly, we look at the RF,
we compare the position, the direction, the velocity,
we look at the consistency on the RF side
as well as on the V2X side.
And then we would also look at map data.
So we look at the consistency with the map data we had.
If a car, for example, has a position that goes
through buildings, that is not really a lane
that we know about.
So we would really like to see,
okay, is the information coming in the V2X message,
does that correlate with what we have in the map data?
And then we look at consistency
between the senders' messages.
So consistency within the message itself from a sender,
like if the brake status,
for example, if the brake status is not consistent
with deceleration between the messages,
like if the brake is applied,
is the acceleration negative?
Is the vehicle really decelerating?
So that is one example we look at,
is the position, speed, and acceleration,
is that consistent with each other?
So that is one more thing.
And there are many more things that we can look at
in a VSM or a CAM message.
Then we look at consistency with other vehicles' messages.
So for example, if you have multiple vehicles
going on a highway, and you look at one-way traffic,
all the vehicles are heading towards this one direction,
and one vehicle is coming directly
in the opposite direction.
So that is a possible misbehavior.
It can be that there is some crazy driver
who is coming on this direction,
but it is really highly unlikely,
and we consider that as a misbehavior.
Or we look at, that is one example,
but in general terms, we look at the trajectory
that is implied by one car and match it with others.
Like for speed, for example,
the speed of vehicles should almost be similar
on a highway scenario as well.
So we look at that as well.
Now, this is how we detect.
And now talking about the fun part,
how do you attack all of this?
So what we do is we look at how an attacker will go about
attacking the misbehavior system
or the B2X system as a whole on the receiver.
So the attacker could attack the security layer,
he could attack on the L1, L2 layer,
that physical MAC layer,
that is, he could perform some attacks on the spectrum,
or he could attack on the application layer as well.
So for example, on security layer,
what he can do, he can send outdated messages.
That means the generation time of the message
is too far behind,
but you're still receiving that message now.
So that is kind of an attack,
that is kind of a message
that you shouldn't have really received.
And then the other attack is
that the vehicle could just send unsigned BSMs
and you just receive those messages,
you say, oh, this is not authenticated,
you drop that.
Then to counter an outdated B2X message attack,
the attacker could forward the generation time in the BSMs
and you could keep that current
to actually try to circumvent the old message check
that can be performed on the security layer.
The attacker could also send a message
without a certificate to invoke no certificate check,
he could also send an expired certificate,
he could incorrectly sign a message,
and then he could be inconsistent on the channel
as well during transmission.
Now, all of these attacks on the security layer,
what they could do is they can starve the receiver
of resources, of processing power.
So even though all these messages are false
and they raise all these concerns,
the receiver could already lose processing
any BSM that is from a legitimate vehicle
and possibly not react to any real incident
that might happen in front of it.
So similarly, you look at coming to spectrum misbehavior
on the physical and math layer,
the attacker could, as we see
in any wireless communication,
could just jam the signal with the blast energy
of the channel and the receiver cannot hear anything.
Then he could also perform a DOS attack.
For example, he can send only preambles.
He can just say, oh, my message length is this much
and does not send the message,
which is a truncate after preamble attack
that we have heard about recently.
And a lot of wireless communication standards
actually ask the receiver to wait
for a certain period of time after the counter
to wait for the message
so that they can read the message during that time.
So the attacker actually...
So the receiver just waits and does not process
any other messages coming in.
So that can be a DOS attack that the attacker could perform.
And then the attacker could change his MAC address
so that if you filter MAC, according to,
if you recognize an attacker's MAC address,
if I get any message with this MAC address,
I'm going to filter any messages coming from this guy.
He can change that MAC address and still pass your filter.
Coming to the application layer,
the attacker could just fuzz all the fields,
like we do in all...
like we do in testing any mechanism.
The attacker could just say, oh,
I'm sending a speed of minus infinity to infinity
and I want to see how does the way,
does the receiver really accept those messages?
Or what kind of behavior does the vehicle show me
if I send such messages?
And as Jonathan showed about civil attack,
the way we could change MAC addresses,
use the same certificate or different certificates
and create those vehicles.
And then lastly, the attacker could formulate
specific messages to fool V2X applications.
And we're going to talk about this in detail now
with an example of the EBL application
in the next couple of slides.
So here you can see that there are two cars here,
the blue one we consider as the victim vehicle,
the benign vehicle,
and the dark gray car is the attacker.
Now the attacker formulates a normal BSM,
which is marked all as green,
where all the fields of the BSM are consistent
with each other.
You have position, you have speed,
you have positive acceleration.
You don't have any braking,
you don't have any EBL flag set.
The EBL flag is the flag that has to be set
for the EBL application to actually react
to a heartbreaking event.
So whenever a vehicle, if it is hit
and it is heartbreaking, the EBL flag is set
and the receiver, whenever it receives the EBL application,
sees that flag first and then checks other things.
So here, the attacker at first just transfers
a normal BSM, our benign vehicle receives that message
and says, oh, it's a normal car,
goes about on its way.
And then now our attacker says,
okay, now I'm going to start my attack.
And now the attacker puts the EBL flag as one.
And you can see that he has not changed all of the fields.
So the brake is zero
and the acceleration is also positive.
This should not really be the case.
But if you don't have any misbehavior detection,
the benign vehicle, when it receives this message,
it says, oh, it's a heartbreaking event,
I should brake, it's safety critical to me
or I might crash into the vehicle.
And our attacker goes about his way ahead.
So at this point, our vehicle maybe looks at,
maybe he doesn't see any car in the vehicle space
after a while.
And like, oh, okay, there was no car in the vehicle space,
neither physically in front of me.
So I should just continue my motion.
Maybe my EBL application was good.
So this is what is the attack that we consider.
And here we assume that the benign vehicle
doesn't use his sensors like camera or radar
in this example to verify messages.
So how would you detect such kind of an attack?
So firstly, as it might be apparent
that you look at the inconsistency within the BSMPs
and you say, oh, okay, so there's an inconsistency,
it is possible that this message is wrong.
And you can also check the telemetry of the attacker.
So if the attacker, after an EBL,
you would expect that the vehicle would stop,
but if the vehicle continues to change its positions
and has a positive speed and the vehicle keeps on moving,
meaning it doesn't have any change between the telemetry
that was before the attack or after the attack,
that is another indication
where how you could detect such kind of an attack.
Now we talk about fake EBL version two attack,
where our attacker has gotten smarter.
He's like, okay, you check for both of those things.
You check for inconsistency
and you check for my telemetry.
So I'm going to become smarter.
Again, the attacker transmits a normal BSM,
goes about his way, the benign vehicle follows it.
Now he transmits a fake EBL message,
formulated specifically to counter the detection
in the first version.
You can see that the EBL flag is set as one,
the brake is also set as one
and the acceleration is also negative.
So when our benign vehicle receives this,
his detectors don't give him any indication
and this vehicle just sees,
oh, okay, this is a heartbreaking event.
And the attacker also stops in the V2X space.
The attacker moves physically, but stops in the V2X space.
So our benign vehicle sees, oh, there is a vehicle stopped.
So the telemetry has changed as well.
So I should brake.
The victim vehicle brakes in this case
and does not continue motion.
So this is an improvement on the attack.
Now, how would you detect this kind of an attack?
We have looked at all the application layer side of things
in the previous checks.
Now we look at the physical layer side of things,
where we look at the signal strength versus the distance.
So as you can see on the graph on the bottom right section,
on the X-axis, you have the distance
and on the Y-axis, you have the signal strength.
And what we have seen is that the signal strength
should reduce as the distance increases
between any two vehicles in this kind of a graph.
But in this case, if the attacker
is sending constant positions in front of you,
but is actually physically changing his positions,
his characteristics would look something
like the red line you see.
The distance is the same,
but the signal strength keeps reducing.
So this is how you could actually find out genuine vehicles
versus an attack vehicle in such cases.
Now our attacker thinks, okay, now you remember me
and I'm going to try to circumvent this.
So we have a version three attack
that the attacker could perform as well.
So here the attacker again, transmits a normal DSM.
And now he again, you know,
formulates a fake email message
with all the fields consistent
and transmit that message over our way to receive it.
The attacker stops in vehicle space,
transmits constant positions after the attack,
but continues physically, right?
So our victim vehicle again stops.
It's just like the version two attack.
But now what the attacker does
is that the attacker goes into a silent period.
So the attacker would go into a silent period here
where it would stop transmitting any DSMs.
So to conserve the storage space in the benign vehicle,
the benign vehicle would check its database,
like, oh, I have, how far,
have I received any BSM recently from this vehicle,
from this attack, from this attacker?
And you would say, no, it has been a long time
since I have not received it.
Let's say five seconds.
Five seconds is also a long time in a real-time system.
And we assume that the benign vehicle
just deletes all the information
just to conserve its storage space.
And now he doesn't see any vehicle anyways in front of it.
So it starts continuing its motion in the V2X space.
It doesn't see any vehicle,
so it starts continuing its motion
in the physical space as well.
Now the attacker, he says,
okay, now you have forgotten about me.
He waits for this vehicle ahead,
like it slows down or something,
and performs the same attack.
Now, since our benign vehicle
doesn't have any history on this attacker,
since he deleted this earlier,
it would fall for the same attack again.
That is what we think an improved attacker would do.
And how would you detect?
You would, of course, again,
look at the physical properties
of this kind of an attack,
and possibly remember these kinds of vehicles
who kind of were not,
that you were not sure about,
that, okay, maybe this vehicle was malicious.
So you try to remember more,
remember such kind of vehicles for a longer time
to detect, to have history on them.
So that if you have a random jump like this
in the V2X space, that this gray vehicle here,
the vehicle in the V2X space,
jumped from back to here,
you can say that this is a random jump,
and this is possibly a mistake.
Yes, so this is how we have formulated
a cat and mouse game,
where you come up with an attacker,
like a red team, blue team kind of thing,
where the attacker becomes smarter,
we make our detector smarter,
and we expand our detectors
from the application layer to the physical layer,
and map layer, and we expand the portfolio
of all the detectors.
And now we have a demo for this,
that we would like to present there,
where we try to simulate these attacks.
And I would like to hand over
the screen to my colleague, Song.
Thank you, Rashid.
Yeah, hello everyone.
In the following demo,
I will present the three attacking scenario
as presented by Rashid,
in order to show the progression of our attacks.
So first, let's take a look at our demo setup.
And this is a demo setup that we show in CES 2020.
As you can see, there are two Roadrunner boards,
and one HMI device, and one demo control panel.
And a Roadrunner is a Qualcomm CV2x development platform,
and that is equipped with Qualcomm CV2x chipset.
And it is used as an onboard unit in this demo.
Here you can see we have two Roadrunners,
one of which is the genuine host vehicle,
while the other one is the remote attacker vehicle.
Since the Roadrunner can play the pre-recorded BSM files,
so even though they are placed stationary,
they can still transmit BSMs to each other,
as if they are traveling on a real road.
On the other hand, the HMI display is an Android application
that will visualize the interaction
between the two vehicles.
And the control panel is used to control
and configure our demo.
So here is the control panel of our demo.
And on top of the panel,
you can see the option of our attack scenarios
from fake EVL version one to version three.
Actually, we have many more attack scenarios,
but here we only show those three.
And below the attack options
is our misbehavior protection system status display,
which will show the detection results
of our misbehavior protection system.
So now, let's start version one
of the fake EVL explained by Rashid.
In version one, the attacker generates a fake EVL warning,
but keeps moving both physically
as well as in the V2X space,
as shown in this HMI display.
So in this HMI display, as you can see,
the green bubble here is the host vehicle,
while the blue bubble is the remote vehicle.
From the perspective of the host vehicle,
based on the BSM it received.
And the overlay here on the right of the display
is not a vehicle.
Actually, it's a dashboard for the host vehicle,
which will indicate the safety warnings
generated by the safety applications.
Let's resume the demo.
So as you can see,
from the perspective of the host vehicle,
both are moving normally
until the host vehicle received a fake EVL warning.
And this is because, just as Rashid explained,
because of the inconsistency between the position field
and the EVL flag in the BSMs.
So you can see the blue bubble is still moving,
but it transmits a fake EVL warning.
However, our misbehavior protection system
can easily detect this inconsistency
by applying the possibility check
and the consistency check.
So this is a very easy attacking scenario.
Of course, a smart attacker
will come up with smarter attacks.
Now let's look at the second one,
the version two of our fake EVL attack.
So in version two, explained by Rashid,
the attacker will generate a fake EVL warning,
but all the fields in the BSM are consistent,
meaning that the attacker will move physically,
but it will stop in the V2X space.
Now let's switch into the...
So as you can see, in this version,
the blue bubble is moving normally in the beginning,
but then it will stop in the V2X.
As you can see here,
the blue bubble indeed stopped in the V2X space.
So the host vehicle, we believe,
is a normal vehicle in the application layer.
However, if we're applying our physical layer detector,
such as the signal strength,
we can detect such misbehavior.
So our host vehicle can ignore this fake EVL warning
and continue the motion.
You can see here, our host vehicle is still moving,
even though it detects this,
because it detects this misbehavior.
The attacker can keep finding ways to upgrade his attack,
explained by Rashid.
And so in version three,
and the attacker, the host vehicle,
the attacker will enter a silent period
after performing the first fake EVL attack.
And then he will disappear from the V2X space,
hoping that the host vehicle will forget about him
and then he will show up again.
Now let's take a look at this scenario.
So in the beginning, the blue bubble behaves normally.
Then he will perform the fake EVL version two.
As you can see, in the V2X space,
but then it disappeared,
hoping the host vehicle will forget about him.
Now, after the silent period,
it shows up again and then perform the attack again.
So again, this attack can also be detected
using the physical layer detectors
just introduced by Rashid.
Okay.
So as the demo shows that a smart attacker
can always find ways to create smarter attacks
as our detection algorithm evolves.
For example, we showed that using the physical layer,
we can detect the fake EVL attack version two
and version three.
However, a smart attacker may circumvent our detector
by, for example, matching the signal strengths
with valid distribution.
Valid signal strength distribution
by adjusting the transmission power.
And other cases,
attacker can use different MAC address
and pseudonym certificates to perform a stable attack
as introduced previously
to fool the majority based detector.
And actually there are many more ways
that attacker can progress
to perform more advanced attacks.
However, by improving our detection system,
we are able to squeeze the attacker to the corner
and raise the bar and the cost of the successful attack.
And on the other hand,
the progression of the attack can push for a stronger
and more robust detection system.
Thank you.
Thank you, Rashid.
So we are coming to the conclusion of this talk.
So what we showed you today is
why, what is misbehavior, first of all, in V2X
and give you many examples.
And then we even went through this misbehavior life cycle,
detection, local reaction, reporting,
investigation, global reaction.
And then we demonstrated the progression of an attack.
What does the attacker do to be smarter and smarter?
What would you test when you want to attack the system?
So, and we'll give you a demo of this
working on real onboard unit.
So as a conclusion, really we understand why
misbehavior protection is super important
for more secure V2X deployment.
You need to have it,
otherwise authentication isn't sufficient.
You will see this big data.
You need to be able to analyze it and detect it.
But what's good is that misbehavior detection,
reporting, investigation, reaction
are all being standardized right now.
So we hope that then really we're going to raise that bar
on making it harder for an attacker
and all have at least minimum performance
in terms of detection.
And also what is really positive
is that misbehavior protection solutions exist
and have been deployed in, for example,
one in the connected vehicle part of deployment.
So this is positive, you know,
it's there, we are ahead of the curve, basically.
But as we've seen, the attacker is always smarter
and will try to counter what you do.
So we still have a lot of open challenges
and I really just like to give you three examples here.
The first one is,
if you are using a machine learning based detector,
therefore an attacker will use a visual example,
a visual machine learning to fool your detection algorithm.
So this is a really active field right now
to look at visual machine learning.
And so therefore, if you're based on that,
you need to look at it.
This is still a highly sophisticated level of attack,
but it is a matter of time
before it's making it easier to be there.
The second part is that we've shown today
only the detection, the attacks on the first step.
So you need to investigate the attack on the reporting,
investigation and a global reaction.
What could you do on those different stages?
And finally, don't forget that V2X
will be part of an automated vehicle
and therefore will be fused with other sensors.
So you need to analyze the effect of V2X attack
on the sensor fusion to understand
how much inconsistency and insensitivity
can you create just from the V2X standpoint.
With that, this is the end of our presentation
and we'll be happy to take questions.
Thank you.