• Vehicle Networks: Vehicle Networks History (10 Minutes)
• Vehicle Networks: CAN Bus-History (10 Minutes)
• Vehicle Networks: CAN Bus-Physical Layer (30 Minutes)
• Activity: Create our Own CAN Bus (15 Minutes)
• Activity: Transmit Messages on CAN Bus (15 Minutes)
• Vehicle Networks: CAN Bus Frame (10 Minutes)
• Activity: Receive Messages on CAN Bus (30 Minutes)
• Activity: Reverse Engineer Controller Traffic (30 Minutes)
• Activity: DoS CAN Bus (15 Minutes)
• Diagnostics: Building a ISO 15765-2 Frame (30 Minutes)
• Activity: Fuzzing CAN Bus (30 Minutes)
• Security: Understanding Security Access (30 Minutes)

Or if you are in San Jose April 23rd, stop by Design West and check out my one hour talk on Vehilce Network Denial of Service.

More details to come as they are released.

Update:

Just got the time and Date for “Exploited from Detroit” "How to Communicate with Your Car’s Network"
Day/Time: Friday, July 13, 2012 - 2200
Location: Sassaman (18th floor)

Stop Normal Communications (GMLAN and Others):
This service is fun because you can make the Normal Communications (the ECU to ECU communications that occurs normally on the network) stop.  Why would such a service exist, mostly to clear the bus for large amounts of data such as when a controller is going to be reflashed over the CAN Bus.  On GMLAN this service is 0x28.  It does not require any sub-function so an example of this might be: 0x7E0 01 28 00 00 00 00 00 00. This will command the engine controller to stop sending normal communications.  Of course you don’t ever want to do this while the car is being driven, but it’s pretty fun to see what happens when you do it!

You will see the Engine Controllers Normal messages virtually disappear.  I say virtually because not all messages will go away, some that are mission critical will stay, but a lot of them will not.

This service can also be useful if you want to simulate the messages the ECU would send without removing the power to the controller or cutting the CAN Bus itself.

This service requires that you continually send a Tester Present (0x3E) message periodically (2 seconds is good) in order to maintain this.  If you want to return the communications send a Return to Normal message (0x20): 0x7E0 01 20 00 00 00 00 00 00.  This will restore communications.  Or simply stop sending the Tester Present message and it will automatically restore communications after 3 seconds. Oh what fun you’ll have.

Input/Output Control (ISO 14229 – UDS):
This is pretty much the coolest services ever made.  I/O Control is exactly as it sounds, you can command Outputs on the Module to do your bidding.  Of course software control will limit your bidding to a safe and secure bidding, but it’s still cool.

I/O Control (Service 0x2F) requires 3 parameters: a DID (Data ID), Control Record, and Control Mask.  The DID is a two byte ID for the output (or input) you want to modify.  Control Record is what you want the output to do (On/Off, Up/Down, etc.). Control Mask is a bitwise mask of one or more parameters that will be modified.  An Example of a I/O Control is something like this: 0x7E0 06 2F 11 22 07 01 00 00 00.  Where 0x1122 is the DID, 0x07 is the Control Record, and 0x0100 is the mask.  This is not a real function, but you could potentially iterate through all possibilities and wait for the controller to give you a positive response.  It would take a while, but it’d be interesting to see what happened…. Right!?

It’s likely that you will get a negative response from the controller 0x7E8 03 7F 2F 13 00 00 00 00, where 0x13 is the Negative Response Code (NRC).

Here are a few possible NRCs you may receive:

•    0x13 – Incorrect Message Length or Invalid Format.
•    0x22 – Condition Not Correct.
•    0x31 – Request Out of Range.
•    0x33 – Security Access Denied.
•    0x80-0xFF – OEM Specific.

Good luck……. .. have fun ..

Here is an example of and OBDII message to get Engine Speed using the CAN Bus ($01 is the Service):
$7DF 02 01 0D 00 00 00 00 00

Will hopefully return the following:
$7E8 04 41 0D 01 FE 00 00 00

Here is a simple list of some common Services that you might find:

OBDII Services (a.k.a. Modes):
$01 - Request Current Powertrain Diagnostic Data
$02 - Request Powertrain Freeze Frame Data
$03 - Request Emission-Related Diagnostic Trouble Codes
$04 - Clear/Reset Emission-Related Diagnostic Information
$05 - Request Oxygen Sensor Monitoring Test Results
$06 - Request On-Board Monitoring Test Results for Specific Monitored Systems
$07 - Request Emission-Related Diagnostic Trouble Codes Detected During Current or Last Completed Driving Cycle
$08 - Request Control of On-Board System, Test or Component
$09 - Request Vehicle Information
$0A - Request Emission-Related Diagnostic Trouble Codes with Permanent Status

Services $10 and higher are non-OBDII services also known as Enhanced Diagnostics.  This is because, unlike OBDII Diagnostics, these services are not government mandated thus each OEM will use their own specification.  For Example GM vehicles use the GMLAN diagnostic protocol.  Ford used ISO-14230 but now use ISO-14229 (UDS).  Each OEM is can decidedly use their own enhanced diagnostic protocol.

GMLAN Enhanced Services:
$10 - Initiate Diagnostics
$12 - Read Failure Record
$1A - Read Diagnostic ID (DID)
$20 - Return To Normal
$22 - Read Data By Parameter ID (PID)
$23 - Read Memory Address
$27 - Security Access
$28 - Disable Normal Communications
$2C - Define Dynamic Data Packet ID (DPID)
$2D - Define PID by Memory Address
$34 - Request Download
$36 - Transfer Data
$3B - Write DID
$3E - Tester Present
$A2 - Report Programming State
$A5 - Enter Programming Mode
$A9 - Check Codes
$AA - Read DPID
$AE - Device Control

Here is an example of a CAN Bus message to get the Engine Speed using Enhanced Diagnostics (where $22 is the service):
$7E0 03 22 00 0D 00 00 00 00

And this will hopefully return:
$7E8 04 62 00 0D 01 7E 00 00

ISO - 14229:
$10 - Diagnostic Session Control
$11 - ECU Reset
$14 - Clear Diagnostic Information
$19 - Read Diagnostic Trouble Codes (DTC)
$22 - Read Data by ID
$23 - Read Memory by Address
$24 - Read Scaling Data by ID
$27 - Security Access
$28 - Communications Control
$2A - Read Data by Periodic ID
$2C - Dynamically Define Data ID
$2E - Write Data by ID
$2F - Input/Output Control
$31 - Routine Control
$34 - Request Download
$35 - Request Upload
$36 - Transfer Data
$37 - Request Transfer Exit
$3D - Write Memory by Address
$3E - Tester Present
$83 - Access Timing Parameter
$84 - Secured Data Transmission
$85 - Control DTC Setting
$86 - Response on Event
$87 - Link Control

Now that you have a list of Services, hopefully this will make reading the raw can data a bit more manageable. Soon I will post more information about specific services themselves.  If any are more interesting to you, please post in the comments below.

Please check out www.defcon.org for more information about what days the workshops will be held.

Here is a preliminary example of what will be:

* Introduction
* What is Vehicle Network Communications (Demo)
* Compare Vehicle Comms vs. Ethernet
* Compare Vehicle Comms vs. TCP/IP
* Types of Vehicle Network Physical Layers
* J1850 PWM/VPW
* LIN/ISO 9141
* CAN Bus
* SWCAN
* LSFT CAN
* DW CAN
* Devices Used to Connect to CAN BUS
* Arduino (Demo)
* neoVI/ValueCAN (Demo)
* Generic ELM Tool
* DW CAN Bus Physical Network (Wires and Resistive Properties)
* CAN BUS Data Frame
* IPC or other Controller (Demo)
* Understanding the data on the Bus: Diagnostic Message vs. Normal Messages
* Reverse Engineering Normal Messages (Demo)
* Diagnostic Protocols
* OBDII
* ISO 14239
* ISO 14229
* GMLAN
* Commanding the Vehicle Controllers using CAN BUS
* Understanding Security Systems
* Controller Security Access (Possible Demo)
* Immobilizers (Possible Demo)
* Q&A
* The autoAPIa Project

UPDATE:

Workshops schedule has been released go to https://www.defcon.org/html/defcon-19/dc-19-workshops.html#Leale for more information about the workshops.  The cost is $200 (Cash only) and it will take place starting at 10:00 AM on Friday, August 5th.  I am not sure yet if it is first-come-first-serve or not.  I will update when I find out.

UPDATE 2:

Thank everyone for coming out to the DefCon workshop, had many more people that I thought could make it.  It was a wonderful success.  As promissed here are the links for the workshop's powerpoint:  http://www.canbushack.com/defcon19/workshop.pptx

So if the ArbID is the identifier of the message, what are Extended IDs?  The concept is simple, take the ArbID and add data bytes from the frame as the ID as well.  For instance, say you have to messages you want to send: Engine Speed and Engine Coolant Temp.  A lot of the time you will see them sent in the same message with the same ID and always in their same respective location in that message.  However what if you wanted all of your parameters to occupy byte 5 of every frame, and instead you change out the ID to denote the parameter, but because of application rules you are only allowed to broadcast on a single ID?  In this case you would use Extended IDs.

For example your only ID you are allowed to send is ID 0x444 (again this is because of rules imposed by a network design committee not by CAN Bus itself).  And you have more data than one frame can possibly hold or you want all of your parameters to be in the 5th byte?  In this case you may set byte 1 as your Extended ID and for each parameter you would assign a new ID.  So Engine Speed would be 0x0C and Coolant Temp would be 0x05 and Engine Parameter X = 0x06, Y=0x07, etc.

Your Engine Speed Frame would look like this: 0x444 0C 03 00 FF 22 00 00 00 00; where 0x22 Is the engine speed. And for Engine Coolant Temp it may look like this 0x444 05 04 00 FF 10 00 00 00 00; where 0x10 is the Engine Coolant value.  So you can see that if you have certain limitations on network IDs, Extended IDs can give you more versatility.

Extended IDs can also be seen in Diagnostics messages as well.  For instance Toyota vehicles often use Extended IDs for Diagnostic Requests and Responses. A typical Enhanced Diagnostic Request on Toyota vehicles starts with 0x750 and the first data byte is the Destination Controller Address.  Compare this with an OEM that does not use Extended IDs, but rather assigns each ECU Destination address its own Arbitration ID (Ford, GM, Chysler, etc.)  The more controllers you have the fewer available Arbitration IDs would be available because they would be taken by Diagnostic Identifiers.

Now you know what some applications are for extended IDs and know that you know, it should be easier for you to identify them when reverse engineering data on the CAN Bus.

With thousands of data parameters flowing continuously along one or more CAN Buses in any particular vehicle, there is no doubt that finding out what these parameters mean can be very benificial, but, in having the data, you can also use it to simulate what is there.

So why would you want to simulate what is ALREADY there? One, because you want to get rid of what is there and add something of your own. Removing the engine and engine controller? No problem just simulate it, the other modules probably wont care. Removing the driver or passenger seat, no problem just simulate it, the other modules probably wont care.

Or two, you want to enhance the functionality of existing controllers. Want the doors to auto-lock at 2mph not 5mph? No problem simulate the lock message, the doors won't mind. Want to have the vehicle chime all the time while the seat belts aren't buckled, no problem simulate the chime.

So how does simulation work? Typically, you will need to look at the message(s) that you want to simulate. What is there Arbitration ID? What is there data length? Is the data static or dynamic? Is it sent periodically, on event, or both? If you send the message and do not remove the original controller that is sending the message are the desired results nullified by the original controller (i.e. if you are sending head lights ON and the original controller is sending head lights OFF, do the headlight turn ON, OFF or flicker?) ?

Once you've answered these questions, then you are ready to begin. So what was the Arbitration ID? Let's say it was 0x555. Ok now what's the data length? 8 bytes with static data, sent periodically at 100ms update rate.

Let's assume this message is a command that moves the driver mirror up when we change the first byte from 0x00 to 0x01. So the message on the Bus looks something like this: 0x555 00 00 00 00 00 00 00 00. But if we send our simulated message of 0x555 01 00 00 00 00 00 00 00 the mirror will move up just a smidge and if we send it at 100ms it will continue to move up until we stop sending or we change the first data byte from 0x01 back to 0x00. However we may notice that the upward movement of the mirror is not as smooth as when I press the up button of the mirror control switch. This is because you are simulating a message that is already present on the CAN Bus. This means that the receiving controller is receiving your message 0x01 and the original controller's message 0x00 and interpreting an Up command when your message arrives and a Stop command when the original controller's message arrives. Depending on how well or bad the software for the mirror control module is written, this may cause havoc on the system you plan to implement, and will most definitely be the source of many CAN Bus Error frames (don't worry there not too bad, in general it is almost impossible to cause any issue when simulating an existing CAN Arbitration ID).

So, in this instants, if we want to make the control as smooth as the original switch, we must stop the existing controller from sending the message. There are a couple of ways to do this, the first is obvious, disconnect or power-down the original controller. Remove a fuse, disconnect the CAN Bus or power from the controller. Now of course this will most definitely have other symptoms, but if your application can tolerate this, then its the easiest and simplest solution.

Next to physically disconnecting the module is using diagnostic messaging to ask the module the stop sending. Often called Disable Normal Communications. If supported, this service will make the module stop sending its data. The problem is that the message format and rules are typically quite different from vehicle manufacture to manufacture, so unless you know what this message is, it is difficult to make this work. Plus this method suffers similar draw-backs as the power-down method mentioned above.

Last, you can gateway the message. Gatewaying the message is done by disconnecting the sending OR receiving module (typically easier when it is the receiver). Once disconnected, you can gateway all of the message to the receiving module EXECPT the one that you want to simulate. This allows you to have complete control over the data in that message while maintaining the messages and data from other modules. As you can imagine this solution requires the most work because you must have a device that is fast, support at least two identical CAN Bus channels, and is quickly programmable. But if you can get these three things together, you will can simulate nearly any message with nearly zero issues.

Well this has been some simulating conversation...