Automobile Hacking and Security v1.0

Define parallel communication fundamentals, including multi-wire, eight-bit data transfer with D0–D7, and its reliability trade-offs, as a foundation for exploring the can protocol in automobile security.

Explore serial communication basics, including a single wire data stream, and distinguish synchronous and asynchronous modes. Recognize start and end bits and protocols like Ethernet, I2C, SPI, USB, and eSATA.

Master the basics of the CAN protocol, featuring two wires CAN high and CAN low, node-based ECUs, and a broadcast, message-based, serial asynchronous network.

Discover how the CAN protocol enables vehicle communication by defining a shared CAN bus, node access, data frames, and message prioritization for reliable data transmission.

Learn the CAN data frame: idle state, start of frame zero, 11-bit identifier for access priority, RTR for data vs remote, up to 8 bytes, CRC with acknowledgment, and end-of-frame.

Examine how a CAN network connects nodes with a host, controller, and transceiver, where host sends messages and interrupts guide actions, and microcontroller vs microprocessor are discussed.

Explore how can bus arbitration uses dominant and recessive bits, where the dominant state overrides recessive. See how 11-bit identifiers set priority for data on can high and low lines.

The lecture explains how a remote frame requests data and how a data frame responds, with a focus on the dominant bit differences and an introduction to the can protocol.

Install can utils and dependencies on a Linux system to enable can communication with a laptop, explore a car simulator, and prepare a virtual interface for these tools.

Create and bring up a virtual can interface vcan0 using a virtual kernel, then verify it with ifconfig and prepare to use can-utils tools in the next video.

Explore the can utils framework and virtual can interface, and learn to generate, log, and analyze CAN packets with tools like random, can dump, can sniff, and can player.

Install a virtual car simulator, compile the tool, and connect it to the can utils framework, then configure and start the can interface to control the simulator with basic commands.

Connect a car simulator to the can utils framework to dump can frames and perform a replay attack using can player, capturing blinkers, doors, and acceleration.

Learn to locate exact CAN frames by recursively splitting log files and replaying attacks, isolating the packet responsible for a door operation through iterative file splits and tests.

Use the can sniff method to identify can frames and locate door, blinker, and acceleration packets. Observe identifiers like 19 B for doors, 188 for blinkers, and 244 for acceleration.

Learn to send exact can frames with cansend method using can utils to control doors and blinkers on a virtual car. Prepare to work with the physical car hardware.

Explore the essential hardware to connect an Arduino UNO with a canvas shield to a vehicle’s OBD port, including power, analog and digital pins, and serial data.

Learn to install the Arduino IDE, select the Arduino UNO board, install libraries, verify and upload sketches, and use the serial monitor to test a blinking LED on pin 13.

Connect the canvas shield to an Arduino Uno, align pins, attach the serial wire, and connect the OBD port to the vehicle, with micro SD recording.

download the can-utils code from the provided github repository and open it in the Arduino IDE; modify portrait, c pin, crystal, and car speed, then upload to the Arduino UNO.

Connect the device to the car via the OBD port, noting its varying placement by manufacturer, then connect the USB to a laptop to establish a real-world vehicle connection.

Set up the canvas device with the car, upload the code, and display CAN packets in the serial monitor; verify 44 variables and proper MCP Crystal and canvas shield alignment.

Create a physical can interface can0 on Kali Linux by attaching the Arduino, identifying /dev/ttyACM0, bringing the interface up, and setting a 1000 queue length.

Connects to a real car via can0, dumps CAN frames on ignition, and saves about 6000 lines of data to a file.

Demonstrate a simple replay attack on a real car interface with a can player, confirming blinker activity via crafted files and familiar commands from a virtual car.

Explore how to sniff CAN frames from a real vehicle interface, mask and filter packets by ID, and identify which messages drive specific car actions.

Provide an honest review and suggestions to help improve this course and others in the bonus section. Download the HTML resources for discounted course codes and explore additional courses.