start	end	text
0	6500	Hello, everyone. My name is Marcelo Secuchin. Today I'm going to be talking about Chupacabra.
6500	15320	It is an open source do-it-yourself tool for interacting with automotive CAN bus.
15900	23600	Just a quick disclaimer, this presentation is based solely on my opinion. It has nothing
23600	30280	to do with my employer. And keep in mind, if you attempt to do the things that I'm covering
30280	38220	here, you might potentially damage your vehicle. And keep in mind, if you damage your vehicle,
38220	45500	malfunctions may or may not incur safety issues for you and others. So be careful if you attempt
45500	54900	to do stuff here. I cannot accept the risks. Okay. A little bit about me. I'm a security
56020	62780	engineer. I do secure development lifecycle. I work close with the dev teams on my daily
62780	71760	basis to make sure they write secure code and applications. I try to do a lot of automation
71760	84200	with Python. And surprise, surprise, the Chupacabra that I develop uses Python a lot.
84200	94040	And my first exposure to CAN, to the CAN protocol, was a while ago when I was a secured software
94040	103180	engineer and I developed some industrial control software. And we know that a lot of PLCs rely on
103180	112420	the CAN open protocol for communication. I also like building stuff with single board open source
112420	121500	hardware, such as BeagleBone and Raspberry Pi. And one of the cool things that I built was some
121500	131460	coding bots, so I could teach my kids learning Python. And this is what brought me here because I
131460	141780	attempted to, when I tried first to do some CAN hacking, I researched and CANtact was the most
142860	151240	known tool for doing that. And because of and but it was sold out on a lot of vendors and
151240	158940	they even mentioned it was because of DEF CON. It was really interesting. And then I remembered that
159800	167240	one of those bots that I built for my kids, I used the BeagleBone Blue, which
168040	177880	had an embedded CAN controller and the transceiver on it. So and I thought considering
177880	187760	options and I said, well, why not try doing that using a BeagleBone Blue rather than waiting longer
187760	200760	for them to be able to buy the CANtact. So this presentation is about how to use BeagleBone Blue
200760	209560	SocketCAN and PythonCAN to do to interact with the CAN bus on your vehicle, more specifically to
209560	219220	the ODB2 CAN bus. At the end, I will bring some research I have ongoing, still ongoing, no solid
219220	227440	results, but trying to connect to ECUs directly. It is possible, but it's still an ongoing work.
228340	236800	And I plan to make it interesting for both newcomers like me that are attempting car
236800	244820	hacking for the first time. So the Chupacabra is easy enough to build and plug into your car and
244820	251620	start doing stuff. But it could be very useful for more experienced hackers as well, because
251620	259640	since it's a single board computer, you could easily extend it to different applications or
259640	268500	use cases that you might have when you're doing your hacking. So all the Chupacabra code is
268500	274960	available on GitHub. So if you're an expert, chances are that all you need to know from
274960	281900	this presentation is this URL. So you can take a look on the code. And also, on GitHub, I share
282220	292200	a link to a Hackster.io tutorial that I wrote with very detailed step-by-step instructions,
292200	300020	so you can build a Chupacabra device exactly to the one that we're going to cover today.
300020	307100	And I hope that I'm going to share the mistakes that I made when I was attempting to do it for
307100	314720	the first time. And hopefully, it will help others when trying to do that. And with a device
314720	321440	easy enough to build, potentially, you can engage more people on attempting car hacking and growing
321440	330840	the community. So this is the device. It's basically a BeagleBone, as you can see here,
332410	341320	with some add-ons. So basically, I connected a USB cellular modem here on the USB jack.
341320	351960	I connect a DC jack here, so I get power from the ODB2 port on my car. And of course, I will need
353340	363400	a ODB connector to connect it to my car. And here, this is the CAM port on the BeagleBone
363400	374220	Blue. So all you need to do is to connect a JSTSH cable here. And then on the back, you connect it
374840	385120	to your ODB2 extension cable. Of course, you can wire it directly to... this is the back
385940	395640	of the device. We can also see that I use a battery. It's completely optional, but you can
395640	403200	use it even if you're... let's say you were building a car tracking application. And even
403200	411180	after your car batteries die, using the battery, your BeagleBone will be still alive and you can
411180	418420	still track the GPS coordinates with this GPS module here and potentially recover your car,
418420	426380	if that is your goal. So I use a very simple material. So I use a plastic plate like this
426380	434000	to put all the pieces together. Some rubber bands, but you can build it differently. Again,
434000	440540	all the instructions are on the Hackster.io article. And all you need to do is to put all
440540	449580	those pieces together so you have a functioning BeagleBone to plug to your ODB2 port on your car.
449740	458120	And also, you don't need to add all those parts together. I would say if all you need to
458120	468360	want to do is to just use a socket cam to exchange some cam messages with your car,
468360	477020	all you need to do is, of course, the BeagleBone Blue and a connector like this.
477020	484600	The name is a JSTSH connector. You connect it to one end of the BeagleBone and then
485020	495020	you can use solid hookup wires like this to connect it to this connector. And then
495020	503220	the other end directly to the ODB ports to your car if you want to keep things simple. Or
504140	513020	you can just build it using the ODB2 extension like this. Okay, so what does...
513760	522400	once you build your device, what does it do? So the idea here is to create a connection
523040	530860	between your CAN bus from inside your vehicle to the outside world. So from my perspective,
530860	538440	I can assume that most of the manufacturers create a threat modeling of their CAN bus system,
538440	545620	assuming that they are going to be isolated from the outside world. So of course, you would need
545620	553220	physical access to the car. But the idea here is to create an easy way of so you can exfiltrate
553220	560800	data from your car to the CAN bus. And the BeagleBone Blue makes it very convenient because
560800	569700	it's really easy to connect the GPS module that I showed before. And on the top of that,
569700	578540	it already has the embedded Wi-Fi access point and interface. So you can connect it directly
578540	585880	or connect it to your Wi-Fi network and access the internet. Or as I showed, you could use
586620	594280	a cellular modem like this to the USB port. And even if your car drives away and goes out of
594280	599520	the range of your Wi-Fi network, you still have communication to your vehicle and you would be
599520	606660	able to potentially send CAN messages to your car remotely. And one other cool thing about
606660	614000	doing it using a single board computer, you can easily expand it to some other different
614000	620100	applications. You can, for instance, create a geofence application. You want to maybe disable
620100	628460	your car if it goes too far. Or maybe you want to track it back. You can, for instance,
628460	640240	plug USB cameras and microphones. So if you want to capture audio. You can even use servos because
640240	648600	the BeagleBone Blue is a robotic... it's intended for robotic applications. So you can plug servos
648600	655160	here on those rails and perform some physical actions inside your car if you need it. You can
655160	664600	even try to robotify your car, let's put it that way. So this is what it... oops, sorry. This is
664600	673040	what it does. And once we run the Chupacabra inside your car, you're going to see on your
673040	679740	local terminal, I'm assuming you SSH to your BeagleBone, and you're going to see once you run
679740	686020	the Python script, you're going to see on your terminal what we have on the left. By default,
686020	694540	it will start monitoring your vehicle speed from the ODB2 port, the RPM, and the temperature.
695320	702040	And we'll also start sending all that information along with the GPS coordinates
702520	712080	to a Flask application running on AWS. The source code for the Flask application is also available
712580	720740	on the GitHub repo. So as I mentioned, by default, it will send only vehicle speeds,
720740	734140	temperature, and RPM. But if you want to use other ODB2 PID from your ODB2 port,
734520	742880	I created this convenient CSV file that if on the left column here, on the Enable Disabled
742880	754440	column, you just set 0 and 1 to the ODB2 PIDs that you want to enable or disable. So as you
754440	761600	can see here, this is one example. And all you need to do is customize it, and then you should
761600	769460	be able to monitor other information from the ODB2 port other than the speed, temperature,
769460	780640	and RPM. Okay, so how do you connect a BeagleBone to your ODB2 port? As I mentioned before,
780640	792200	you have the CAN connector here. You use the JST connector to plug it here. And then all you need
792200	802580	to do is to go to the female ODB2 port on your car and connect the CAN high and CAN low pins to
803260	815360	the pin 6 and 14 respectively on your ODB2 port on your car. And it brings me to the first mistake
815360	825660	I made. Keep in mind that this schematic, these pin numbers, are related to the female ODB2 port.
825660	834680	So initially, what I tried to do, as you can see here on this picture, I connected the JST
834680	844300	connector to the BeagleBone, and I used some hookup cables, and I cut a cable like this,
844300	851940	and for convenience, I would connect my BeagleBone hookup wires to a male ODB2 connector.
852280	859760	And keep in mind, if you do that, the numbers 1 to 8 will be mirrored because the female connects
859760	867460	front to front, the male and female connects like this. So the eighth pin here on the female
867460	874620	is actually the third pin here on the male. So keep those things in mind. This is a mistake that
874620	883180	I made, and I believe I want to just prevent you from wasting time troubleshooting those things.
883400	890940	And other mistakes that I did, and it could potentially help you when attempting this.
891580	899080	So use a multimeter is your friend. I would be able to easily catch up that mistake if you use
899220	907660	a multimeter and make sure you have some voltage on the pins that you want to tap in. And by the
907660	913640	way, on my car, the pins 3 and 11 that I connected by mistake initially, they don't have any voltage
913640	919060	there because they don't do anything. So with a multimeter, you would be able to catch issues
919060	928640	like this. Another mistake that I did was when I saw CAN dump, I assume a TCP dump. So
929380	937660	it's a sniffer, right? Sniffing traffic, so they should be similar. They are in some extent.
937660	945480	However, CAN bus is not Ethernet. You need at minimum two nodes on the bus so you can
945480	953800	potentially transmit and sniff some traffic. So initially, I enabled the CAN interface on my
953800	961440	BeagleBone. I started CAN dump on one terminal. I started doing CAN send on the other. And I didn't
961440	967960	see anything. And I didn't know why. The reason is because you need two nodes so you have at
967960	974860	minimum, so you have a CAN. But even before doing that, what I would recommend, play a little bit
974860	985180	with vCAN first. It's very easy to install vCAN on a Ubuntu Linux, for instance, and then you can
985880	994380	do the CAN send and CAN dump and monitor the messages and understand how it works before
994380	1001840	even attempting to a real physical CAN. Another common issue that I had to face is you have to
1001840	1010900	know the bitrate. So if you want a CAN bus to work properly. And for my vehicle, by default, it
1010900	1021620	uses 500k baud rate. And yours might be different. So keep that in mind. So this is a suggestion.
1021620	1028240	So if you want to make sure your Chupacabra is working and you understand a little bit how CAN
1028240	1037640	works, create a CAN bus breadboard like this. It's really simple. You just use some
1037640	1044080	jump wires to hook your JST connectors to a breadboard. The only thing you need to know is
1044800	1051340	I'm using blue for CAN high here and white for CAN low. The only thing that you need to know is you
1051340	1062420	need a 120 ohms resistor at each end connecting the CAN high and CAN low
1062420	1070640	rails. It's going to be very helpful because then you can plug two BeagleBones, for instance,
1070640	1079180	and exchange some CAN messages between each other with CAN dump. Another useful thing
1079180	1087240	that I would recommend, not necessarily, but it might be helpful, is to cut a extension cable
1087240	1096980	like this. So if things are not working properly, for instance, I bought a very simple device like
1096980	1105360	this. It's a scan tool that supports scan ODB2. It's very cheap. And it was working. And I didn't
1105360	1113800	know why my BeagleBone wasn't working properly. So I created this. I cut this cable and hooked
1113800	1121220	one through 16, all the pins on my breadboard rails. And then I was able to connect it,
1121220	1130340	this device to this extension and the extension to the car. And then here on the picture with
1130340	1141100	the zoom, I could hook the JST connector to this breadboard and then start CAN dump there.
1141100	1147380	And for instance, use this device to retrieve the VIN number. And then I would see the exactly
1147380	1153980	messages that it was exchanging and understand what could be wrong with my BeagleBone that I
1154620	1162480	wasn't getting right. And in my case, what I didn't know at that time was this. I was expecting
1162480	1169760	to plug the BeagleBone to the ODB2 port, start CAN dump, and I was expecting to see a lot of
1169760	1177980	traffic there. But what I noticed is that my ODB2 port was silent. It was just listening to...
1177980	1184980	because it was segmented to the other CAN buses on the car. So it was just waiting for
1185820	1192800	some specific CAN messages to reply to it. And this is exactly what happened. This is
1192800	1201920	when I sniffed the comments from this device here, that was the CAN message I saw. And then
1202480	1208460	using the CAN dump on the CAN0 from the BeagleBone, I saw the request and the response
1208460	1219500	with my VIN number there. All right. So let's say you're confident enough, you understand how to
1219500	1228620	play with CAN bus using a BeagleBone. And now you wanna... and you built your Chupacabra device,
1228620	1236360	you wanna run it on your vehicle. So my suggestion would be play a little bit first
1236360	1242960	with a socket CAN and make sure everything is working. So just try different bit rates,
1242960	1248600	for instance, here on this, I'm trying the 500k, which is what worked for my car.
1248600	1256540	Enable the CAN0 interface and open another terminal with CAN dump. And on a different
1256540	1264780	terminal, you send the request VIN message. And by the way, all those messages, including
1264780	1271940	this request VIN, is available on the CSV worksheet that I have available on GitHub.
1271940	1278220	So you can try different stuff there. Once you know, once you see the request and the response,
1278220	1285900	you know that your Chupacabra and your BeagleBone is able to properly use socket CAN in your car.
1286720	1294920	And then if you want to test the GPS module, you would recommend using this TIO command.
1295200	1304820	By default, it uses the serial port TTY02 with baud rate 4800. This is a specific one that I
1304820	1313640	use it. All the parts are listed on the Hackster.io article, and I point to vendors that supply them.
1313640	1320880	So, and when you start the TIO command, you're going to see a lot of GPS sentences
1320880	1327940	flowing around. And wait a little bit for the module to find a GPS satellite.
1328000	1334540	And once you get some GPRMC sentences, similar to this one that I have on screen,
1334540	1342180	you can use an online decoder, just like this RL.SC. It's really cool, by the way.
1342600	1349520	You just need to provide the GPRMC and it will plot your exact locations on a map.
1351180	1356560	For cellular connection, so for connection, all you need to do is to make sure you have
1357260	1368960	internet connection from your BeagleBone, either by using a Wi-Fi network or a cellular LTE modem,
1368960	1375240	which is what I did. I use the hologram vendor because it's very Python friendly.
1375320	1382660	The documentation is really good, so it was really easy to install it and get it working on my
1382660	1387560	BeagleBone. Again, all the documentation is available on my Hackster.io article.
1387760	1392740	And at the end of the day, all you need to do is to ping a public server on the internet and make
1392740	1399920	sure you have internet connection so the data that your Chupacabra is capturing can be exfiltrated
1399920	1406800	to a server. And once you know everything is working properly, it is time for you to clone
1406800	1414220	the repo. Go to the Chupacabra folder and play around a little bit with the CSV files and enable
1414220	1422320	and disable the ODB2 PIDs that you are interested in. And then just run the Python script. And by
1422320	1429760	the way, it's all Python 3 basic. I don't think it works with Python 2. And if everything goes
1429760	1436220	well, you're going to see all the ODB2 PIDs that you enabled being displayed on the screen.
1436400	1442600	And also, if you have an internet connection, by default, it's going to be exfiltrated to this
1442600	1451360	public AWS Flask app that I had running. And by default, the script points to that. If you want
1451360	1461000	to create your own, just use the code available on this server or on this GitHub repo. And then
1461000	1469100	you can customize it, run in a different cloud environment and customize it any way you want.
1470140	1479640	Okay, let me run a quick demo video here so we have an idea how the Chupacabra works.
1480560	1489640	So, this is the device. I'm going to plug into the ODB2 port from my car. The engine is on,
1489640	1498700	already running. Yeah, so I'm just showing where is the ODB2 port on my vehicle. It's usually
1498700	1505980	some close to the steering wheel. And then I'm going to put it on the dashboard because I'm
1505980	1510460	going to monitor it from outside the vehicle. This is something that is really convenient
1510460	1517420	compared to the other solutions. Because you have the embedded access, Wi-Fi access point on the
1517420	1524080	vehicle, you can just connect to it and run Chupacabra from there. This is what you would
1524080	1531560	get on your terminal if everything goes well. And then you can monitor your car. Of course,
1531560	1539000	if it goes out of range, it will want to work. But you can monitor your ODB2 data
1539000	1549560	from outside the car. Now, I have a test from inside the car. Here is I'm running
1550580	1558400	the same test from inside the car. But the cool thing here is I'm going, I perform a lap around
1558400	1567680	the course, and I'm monitoring the GPS data. So, it's exfiltrating using the cellular network to
1567680	1577140	AWS server that I had running, right? And you're going to freeze the video exactly
1578720	1585660	where the coordinates was exfiltrated. Then when I got home, I just visited the public
1586760	1596340	AWS Flask application, and I saw all the GPRMC sentences available there, and I could plot them
1596340	1605860	on the map. So, if I was away from the vehicle, I would be able to track it wherever it was.
1607140	1613920	And if you plot all the, and it will, GPS will also give you the speed. And if you plot all the
1613920	1621720	coordinates that are available in the application, you would have an idea from where the vehicle was
1621720	1629760	traveling. So, I performed a course around a few blocks, and this is what I show here.
1630200	1643330	All right. So, this is how the device works, right? So, it is able to exfiltrate
1643330	1652470	ODB2 and GPS data. But what's next? And this is a currently work. I have only preliminary results,
1652470	1659090	but probably the next thing that you want to do is to go beyond of the ODB2 CAN bus,
1659090	1666150	and actually tap into a real CAN bus for your vehicle. And you can do it using the exactly
1666150	1673110	same device. So, what I've been doing so far, so rather than reverse engineering every wire inside
1673110	1683530	and disassembling my dashboard, that would be insane hard work to do, you can alternatively
1683530	1691930	go to your dealership and get a book like this, a supplemental, electric supplemental manual,
1691930	1699070	and it will give you a lot of detailed information about all the cables, where all the
1699530	1706090	electronic components from your vehicles are located, and the connections between them.
1706570	1716410	So, for instance, really close to my steering wheel on my vehicle, I have this ETAC ECU
1716410	1724050	that is also located pretty close to the ODB2 connector. So, I thought, okay, let me connect
1724050	1732010	those two CAN buses that are segmented from my vehicle, and then I can monitor everything.
1732070	1739910	And that was my goal. So, knowing where the ECU is, it's pretty, helps a lot.
1740370	1746170	And here is a picture of the vehicle. So, to get physical access to that specific ECU,
1746170	1750850	all we needed to do was to remove a couple of plastic covers from my vehicle.
1750850	1758770	And that was it. I could see the ECU from the bottom of the driving seat.
1760190	1766310	And also, the electronic supplemental will give you detailed information about the ECUs on your
1766310	1773330	car. So, for this one specifically, if you look to the picture on the left, on the bottom, I have
1773330	1781890	this C411 connector. And if you go deep on the manual, you're going to notice, then on the
1781890	1788970	diagram on the right, on the top, you have, you know, you would know that the C411 connector
1789500	1797270	is actually connected to a CAN drive. And the pins eight and nine are connected respectively
1797770	1807870	to CAN low and high to another component they call ECM on this vehicle. And not only that,
1807870	1816190	you know, you have the wiring colors used for those cables. So, I know that the CAN high
1816580	1829350	on pin nine is BR, which is brown cable, and the CAN low on pin eight is Y, a yellow cable.
1829350	1839330	So, looking carefully inside my dashboard, I was able to find this ETOX ECU with this specific
1839330	1848590	connector. And you can see the brown and yellow cable on pins eight and nine. And also close to
1848590	1860070	the arrow that I put, you can see the ODB2 port on the top. So, again, so what I needed to do,
1860070	1866290	all I needed to do is to use a hookup wire like this. This is not the actual CAN cable. It's just
1866490	1874410	a hookup wire that I manually twisted myself. Oh, this is another common mistake. Make sure
1875280	1880710	you either use a real CAN cable, or if you're using hookup wires like me, make sure they are
1880710	1887410	not too long, because they might not function well. And you can try to manually twist them to
1887410	1894610	mimic what a real CAN cable would, the physical properties of a real CAN cable.
1895470	1906730	But back to this, be aware that by bridging those segmented CAN buses on your car,
1906730	1913450	you may, you might damage your electronic components on your car,
1913450	1920750	and incur safety issues for you and for others. So be sure you know what you're doing, and be
1920750	1931570	careful. Okay, so once I got a good physical connection with those pins, I used a multimeter
1931570	1940990	to make sure I had good wiring. On this specific ACU, when I have the ignition off, it gives me
1940990	1953310	1.13 volts, but when I turn the ignition on, I get the expected 2.5 volts. Another mistake that I
1953310	1962630	did, I recommend turning on the engine, because you would very quickly kill your battery. I did
1962630	1969830	that, don't make the mistakes that I did. Okay, so now that I know with the multimeter that I have
1970310	1977610	a good physical connection with the ACU, I connected the other end of the hookup wires
1977610	1987550	directly to the back of the BeagleBone with the other, with the existing CAN high and CAN low
1988650	1999250	cables, wires that I had to the ODB2. And that's all I needed to do. And then by doing that,
1999250	2007750	as opposed to the initial result that I had only with the CAN, the ODB2 CAN, now if I run
2008350	2016750	CAN dump from the Chupacabra device, now I see a lot of traffic between this ETACC ACU
2016750	2029230	that I connected and the other electronic device ECM from my vehicle. I can tell,
2029230	2040810	and exchange information through the CAN bus. All right, so that's where I got so far.
2040810	2047430	What I'm planning to do, that's what I'm trying to do right now, is to reverse engineering some
2047430	2056590	of those messages. For instance, I'm trying to use a CAN dump to write, to save the traffic,
2056590	2061990	to dump the traffic to a local file, do something on the vehicle, for instance,
2061990	2069450	opening and closing the power window, and then using CAN player, try to replay the traffic,
2069450	2077890	and try to open and close the window just by replaying the messages. The problem is,
2077890	2085250	I wasn't so successful doing that so far. And every time I try that, I get a beautiful and
2085250	2094530	shining service engine light on my vehicle, and I might break my vehicle at some point.
2094550	2100610	And not only that, maybe I'm not even connected to the right CAN bus that I should be tapping
2100610	2108210	into if I want to open and close the window. So I have a lot of work to do to do that yet.
2108210	2114750	But what tells me I'm on the right path is, when I do CAN sniffer, unfortunately,
2114750	2122630	because it's a very busy CAN bus, it's still very polluted to me to tell exactly what's going on
2122630	2128790	when I open and close the window. But I see something go, some action, there are some
2128790	2135950	different, some new messages showing up when I'm doing those actions. So I still don't know
2135950	2142410	what's going on, but that's what I'm trying to do. Get some interesting CAN messages so I can
2142410	2151330	replay them later. So since I wasn't able to get, for instance, the opening and closing window yet,
2151330	2158250	let's assume the message that I want to do remote execution on my car is the retrieve
2158250	2166170	VIN message, right? Which is the one I'm highlighting here with the CAN send command.
2166170	2175170	So my goal is to create a kind of RPC where I have a new endpoint on the
2175170	2182430	on the Flask application running on the cloud that I would be able to send any CAN message
2182430	2190870	that I wanted to be executed remotely on the car. Of course, I had to URL encode the
2190870	2202030	hashtag here so I could post this URL to my Flask application and get it available.
2202190	2207630	And in order to do that, here's an oversimplified version of the changes that
2207630	2213990	would be needed on the current Chupacabra implementation. And by the way, once I get it
2213990	2220450	working, I will update the code and make it available. But if community guys, if you feel
2220450	2227190	free to fork the code and or even submit pull requests, I would be very excited if people
2227830	2234310	would start doing that, actually. But the idea here is to do what I showed before,
2234310	2243270	submitting messages remotely to create this kind of reverse HTTP command and control,
2243270	2252510	I would create on the server application a queue into new endpoints, a GET and POST endpoint on
2252510	2260390	this RPC endpoint. And whenever you send a GET a POST message with the CAN message,
2260390	2269050	it would add to the queue. And then on the GET request, you would pop a message,
2269050	2277970	CAN message from the queue and then you execute it on the client. So the changes on the client,
2277970	2288570	the Chupacabra.py, would be basically hitting the RPC flask application with the GET request.
2288570	2295350	It would give you a keyword CAN message that you submitted, and then it would send it to the bus
2295350	2302330	and execute on your car. Of course, this is a very oversimplified version. Just to illustrate,
2302330	2308790	you would need to add some error catches here, some logic, and even you would need to parse
2308790	2318490	the JSON data to put your CAN message together. But that's the idea. So this is one suggestion,
2318490	2331130	this is what I'm going for. But again, it's a Python code on an open source hardware platform.
2331130	2341350	Feel free to do whatever you want to do with it. And the takeaways here from this presentation
2342150	2349230	is, again, I want to build an open source hardware and software platform that could be
2349230	2356210	useful for newcomers that are attempting this for the first time, but also for more experienced
2356210	2364590	guys that see a need for a single board computer running on a car where they could remotely
2365240	2375730	do some stuff there. Currently, the code that I have on GitHub only do GPS and ODB2 CAN
2376270	2384600	messages, data exfiltration. But as I just showed, I plan to expand it in the future.
2386210	2393680	Yeah, so let's use it, guys. I'm open to feedback. Let's grow the community.
2394590	2405090	And let's have fun. Oh, one thing I would like to thank my friend Robert from Autobahn AI.
2405090	2413550	He helped me a lot with all his knowledge on Automagic CAN with issues that I have,
2413550	2419390	troubleshooting things and attempt different approaches. So thank you, Robert. It was really
2419390	2428850	appreciated. And that's all I have, guys. So again, all the information that you need to
2428850	2436350	build the Chupacabra is available on GitHub. And if you have any questions, suggestions,
2436350	2445310	hit me on social media. I would be very happy to see people using the device. And
2446070	2453810	if people have the same issue that I have trying to buy other open source tools because they were
2453810	2463350	sold out, let's make BeagleBone sold out. I'm going to measure the success of this presentation
2463870	2472090	based on whether or not we can sold out all the BeagleBone Blues next year because everybody
2472090	2480190	will be trying to hack their cards using this open source platform. So again, thank you, guys.
2481410	2489550	I'm open for questions. Reach out to me either on social media or on the Q&A session.